mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-16 20:11:08 +00:00
* fix: correct terminal AI history resume behavior
The previous implementation plan mistakenly treated reopening an old terminal AI session in a fresh or reconnected SSH tab as a scope-retargeting feature.
The intended rule is draft-first:
- a fresh or reconnected terminal opens on a blank draft
- older chats remain available in history for manual access
- selecting history does not imply automatic scope transfer into the new tab
This change is a rule correction, not a conflict between product rules.
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
* fix: harden ai draft transitions
* fix ai session continuation from history
* fix: clear stale activeSessionIdMap entry when view resolves to draft
Addresses the Codex P2 review on aiPanelViewState.ts:38. When a terminal
scope mounts with a persisted activeSessionIdMap entry but no explicit
panelView and no draft, resolveDisplayedPanelView now returns the
default draft view (terminal fresh-start behavior). The sync effect
that writes into activeSessionIdMap is guarded by `if (!activeSession)
return`, so the old entry stays put. That stale entry then leaks into
activeTerminalTargetIds in every other scope, and
getSessionScopeMatchRank uses it to suppress host-matched history that
is actually resumable — so valid sessions vanish from the history
drawer until another action rewrites the map.
Add a dedicated effect that clears the scope's activeSessionIdMap
entry whenever the resolved panel view is draft but a persisted
session id is still present. This keeps the map an accurate record of
"which session each scope is currently showing" instead of a lagging
snapshot.
Also extend sessionScopeMatch.test.ts to cover the rank=2 exact-match
branch and the scope-type mismatch short-circuit, which were missing
from the original suite.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix: track cross-terminal session ownership by session id, not targetId
Addresses the Codex follow-up review on commit 345244b2. When a user
resumes a session from history into a different terminal, the session's
`scope.targetId` still points at the original terminal. The previous
ownership tracking — which checked whether `session.scope.targetId`
appeared in `activeTerminalTargetIds` (derived from the keys of
`activeSessionIdMap`) — therefore:
- could not prevent the same session from being resumed in multiple
terminals simultaneously, because the resumed session's targetId
never matches the current scope's targetId; and
- let `pruneInactiveScopedSessions` treat a session as orphaned and
clear its `externalSessionId` the moment the original terminal
closed, even though another terminal was actively using it.
Switch ownership to be keyed on session id:
- `getSessionScopeMatchRank` now takes `activeTerminalSessionIds`
(a Set of session ids currently displayed by other terminal scopes)
and returns rank 0 when `session.id` is in that set.
- `AIChatSidePanel` derives `activeTerminalSessionIds` from the
*values* of `activeSessionIdMap`, excluding the current scope's key.
- `pruneInactiveScopedSessions` gains an `activeSessionIds` parameter;
sessions whose id is in this set are never reported as orphaned and
never have their `externalSessionId` cleared, regardless of their
stored `scope.targetId`.
- `cleanupOrphanedAISessions` computes the in-use set from the
pre-cleanup `activeSessionIdMap`, filtered to live scopes, and
passes it through. The map is read once and reused.
Tests cover the new id-based ownership, the rank-2 exact-match path,
the scope-type-mismatch short-circuit, and the
"resumed-elsewhere session must not be cleaned" invariant.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---------
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: bincxz <16399091+binaricat@users.noreply.github.com>
Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
178 lines
5.1 KiB
TypeScript
178 lines
5.1 KiB
TypeScript
import assert from "node:assert/strict";
|
|
import test from "node:test";
|
|
|
|
import type {
|
|
AIPanelView,
|
|
AISession,
|
|
} from "../../infrastructure/ai/types.ts";
|
|
import {
|
|
applyDraftEntrySelection,
|
|
applyHistorySessionSelection,
|
|
normalizePanelView,
|
|
resolveDisplayedPanelView,
|
|
resolveDisplayedSession,
|
|
} from "./aiPanelViewState.ts";
|
|
|
|
function createSession(id: string): AISession {
|
|
return {
|
|
id,
|
|
title: `Session ${id}`,
|
|
messages: [],
|
|
createdAt: 1,
|
|
updatedAt: 1,
|
|
agentId: "catty",
|
|
scope: {
|
|
type: "terminal",
|
|
targetId: "terminal-1",
|
|
},
|
|
};
|
|
}
|
|
|
|
test("draft view never falls back to most recent history", () => {
|
|
const panelView: AIPanelView = { mode: "draft" };
|
|
const sessions = [createSession("session-2"), createSession("session-1")];
|
|
|
|
assert.equal(resolveDisplayedSession(panelView, sessions), null);
|
|
});
|
|
|
|
test("session view returns the selected session", () => {
|
|
const selectedSession = createSession("session-2");
|
|
const panelView: AIPanelView = { mode: "session", sessionId: selectedSession.id };
|
|
const sessions = [createSession("session-1"), selectedSession];
|
|
|
|
assert.equal(resolveDisplayedSession(panelView, sessions), selectedSession);
|
|
});
|
|
|
|
test("missing session target resolves to null instead of history fallback", () => {
|
|
const panelView: AIPanelView = { mode: "session", sessionId: "missing-session" };
|
|
const sessions = [createSession("session-2"), createSession("session-1")];
|
|
|
|
assert.equal(resolveDisplayedSession(panelView, sessions), null);
|
|
});
|
|
|
|
test("missing session target normalizes back to draft view", () => {
|
|
const panelView: AIPanelView = { mode: "session", sessionId: "missing-session" };
|
|
const sessions = [createSession("session-2"), createSession("session-1")];
|
|
|
|
assert.deepEqual(normalizePanelView(panelView, sessions), { mode: "draft" });
|
|
});
|
|
|
|
test("missing explicit panel view resumes the most recent matching history when no draft exists", () => {
|
|
const sessions = [createSession("session-2"), createSession("session-1")];
|
|
|
|
assert.deepEqual(
|
|
resolveDisplayedPanelView(undefined, false, sessions, undefined, "workspace"),
|
|
{ mode: "session", sessionId: "session-2" },
|
|
);
|
|
});
|
|
|
|
test("missing explicit panel view restores the persisted active session instead of the newest", () => {
|
|
const sessions = [createSession("session-2"), createSession("session-1")];
|
|
|
|
assert.deepEqual(
|
|
resolveDisplayedPanelView(undefined, false, sessions, "session-1", "workspace"),
|
|
{ mode: "session", sessionId: "session-1" },
|
|
);
|
|
});
|
|
|
|
test("persisted session id that no longer exists in history falls back to newest", () => {
|
|
const sessions = [createSession("session-2"), createSession("session-1")];
|
|
|
|
assert.deepEqual(
|
|
resolveDisplayedPanelView(undefined, false, sessions, "deleted-session", "workspace"),
|
|
{ mode: "session", sessionId: "session-2" },
|
|
);
|
|
});
|
|
|
|
test("null persisted session id falls back to newest history entry", () => {
|
|
const sessions = [createSession("session-2"), createSession("session-1")];
|
|
|
|
assert.deepEqual(
|
|
resolveDisplayedPanelView(undefined, false, sessions, null, "workspace"),
|
|
{ mode: "session", sessionId: "session-2" },
|
|
);
|
|
});
|
|
|
|
test("terminal scope without explicit view always starts from draft even when history exists", () => {
|
|
const sessions = [createSession("session-2"), createSession("session-1")];
|
|
|
|
assert.deepEqual(
|
|
resolveDisplayedPanelView(undefined, false, sessions, "session-1", "terminal"),
|
|
{ mode: "draft" },
|
|
);
|
|
});
|
|
|
|
test("missing explicit panel view prefers the draft when unsent input exists", () => {
|
|
const sessions = [createSession("session-2"), createSession("session-1")];
|
|
|
|
assert.deepEqual(
|
|
resolveDisplayedPanelView(undefined, true, sessions),
|
|
{ mode: "draft" },
|
|
);
|
|
});
|
|
|
|
test("draft state is used when there is no implicit history to resume", () => {
|
|
assert.deepEqual(
|
|
resolveDisplayedPanelView(undefined, true, []),
|
|
{ mode: "draft" },
|
|
);
|
|
});
|
|
|
|
test("history selection switches to the chosen session without touching draft state", () => {
|
|
const calls: string[] = [];
|
|
|
|
applyHistorySessionSelection("session-2", {
|
|
showSessionView: (sessionId) => {
|
|
calls.push(`view:${sessionId}`);
|
|
},
|
|
setActiveSessionId: (sessionId) => {
|
|
calls.push(`active:${sessionId}`);
|
|
},
|
|
closeHistory: () => {
|
|
calls.push("close-history");
|
|
},
|
|
});
|
|
|
|
assert.deepEqual(calls, [
|
|
"view:session-2",
|
|
"active:session-2",
|
|
"close-history",
|
|
]);
|
|
});
|
|
|
|
test("draft entry ensures a draft exists before switching the panel to draft mode", () => {
|
|
const calls: string[] = [];
|
|
|
|
applyDraftEntrySelection({
|
|
ensureDraft: () => {
|
|
calls.push("ensure-draft");
|
|
},
|
|
showDraftView: () => {
|
|
calls.push("show-draft");
|
|
},
|
|
});
|
|
|
|
assert.deepEqual(calls, [
|
|
"ensure-draft",
|
|
"show-draft",
|
|
]);
|
|
});
|
|
|
|
test("draft entry can preserve the current session view while ensuring draft state", () => {
|
|
const calls: string[] = [];
|
|
|
|
applyDraftEntrySelection({
|
|
ensureDraft: () => {
|
|
calls.push("ensure-draft");
|
|
},
|
|
showDraftView: () => {
|
|
calls.push("show-draft");
|
|
},
|
|
preserveSessionView: true,
|
|
});
|
|
|
|
assert.deepEqual(calls, [
|
|
"ensure-draft",
|
|
]);
|
|
});
|