[Init] Initial commit - NetMesh terminal manager

electron/bridges/mcpServerBridge.hostOpenScope.test.cjs

@@ -0,0 +1,816 @@
+"use strict";
+
+const assert = require("node:assert/strict");
+const test = require("node:test");
+
+function loadFreshBridge() {
+  const bridgePath = require.resolve("./mcpServerBridge.cjs");
+  delete require.cache[bridgePath];
+  // Also clear retain/ownership deps so a fresh bridge gets fresh module state.
+  for (const key of Object.keys(require.cache)) {
+    if (key.includes(`${require("node:path").sep}mcpServerBridge${require("node:path").sep}`)) {
+      delete require.cache[key];
+    }
+  }
+  return require("./mcpServerBridge.cjs");
+}
+
+test("sidebar scope replace keeps host_open-owned sessions in the chat scope", async (t) => {
+  const bridge = loadFreshBridge();
+  t.after(() => bridge.cleanup());
+  bridge.init({
+    sessions: new Map(),
+    electronModule: null,
+  });
+  bridge.setPermissionMode("auto");
+  bridge.setVaultAgentInvoker(async (op) => {
+    if (op === "host.open") {
+      return { ok: true, sessionId: "sess-opened", hostId: "host-b", status: "connecting" };
+    }
+    return { ok: false, error: `unexpected op ${op}` };
+  });
+
+  bridge.updateSessionMetadata([
+    {
+      sessionId: "sess-original",
+      hostname: "10.0.0.1",
+      label: "server-a",
+      connected: true,
+      hostId: "host-a",
+    },
+    {
+      sessionId: "sess-opened",
+      hostname: "10.0.0.2",
+      label: "server-b",
+      connected: false,
+      hostId: "host-b",
+      protocol: "ssh",
+    },
+  ], "chat-1");
+
+  const opened = await bridge.dispatchBuiltinRpc("public/vault/hosts/open", {
+    chatSessionId: "chat-1",
+    hostId: "host-b",
+  });
+  assert.equal(opened.ok, true);
+  assert.equal(opened.sessionId, "sess-opened");
+
+  // AIChatSidePanel-style full replace of only the focused tab.
+  bridge.updateSessionMetadata([
+    {
+      sessionId: "sess-original",
+      hostname: "10.0.0.1",
+      label: "server-a",
+      connected: true,
+      hostId: "host-a",
+    },
+  ], "chat-1");
+
+  assert.deepEqual(
+    bridge.getScopedSessionIds("chat-1").sort(),
+    ["sess-opened", "sess-original"],
+  );
+});
+
+test("authoritative empty scope replace still clears host_open-owned sessions", async (t) => {
+  const bridge = loadFreshBridge();
+  t.after(() => bridge.cleanup());
+  bridge.init({
+    sessions: new Map(),
+    electronModule: null,
+  });
+  bridge.setPermissionMode("auto");
+  bridge.setVaultAgentInvoker(async () => ({
+    ok: true,
+    sessionId: "sess-opened",
+    hostId: "host-b",
+    status: "connecting",
+  }));
+
+  bridge.updateSessionMetadata([
+    { sessionId: "sess-opened", hostname: "10.0.0.2", label: "server-b", connected: false },
+  ], "chat-1");
+  await bridge.dispatchBuiltinRpc("public/vault/hosts/open", {
+    chatSessionId: "chat-1",
+    hostId: "host-b",
+  });
+
+  bridge.updateSessionMetadata([], "chat-1");
+  assert.deepEqual(bridge.getScopedSessionIds("chat-1"), []);
+
+  // A later non-empty sync must not resurrect the cleared owned session via
+  // cross-scope fallback / stale ownership.
+  bridge.updateSessionMetadata([
+    {
+      sessionId: "sess-opened",
+      hostname: "10.0.0.2",
+      label: "server-b",
+      connected: true,
+      hostId: "host-b",
+    },
+  ], "__external_mcp__");
+  bridge.updateSessionMetadata([
+    {
+      sessionId: "sess-original",
+      hostname: "10.0.0.1",
+      label: "server-a",
+      connected: true,
+      hostId: "host-a",
+    },
+  ], "chat-1");
+  assert.deepEqual(bridge.getScopedSessionIds("chat-1"), ["sess-original"]);
+  assert.equal(bridge.getSessionMeta("sess-opened", "chat-1"), null);
+});
+
+test("retained host_open metadata refreshes connected from another scope", async (t) => {
+  const bridge = loadFreshBridge();
+  t.after(() => bridge.cleanup());
+  bridge.init({
+    sessions: new Map(),
+    electronModule: null,
+  });
+  bridge.setPermissionMode("auto");
+  bridge.setVaultAgentInvoker(async () => ({
+    ok: true,
+    sessionId: "sess-opened",
+    hostId: "host-b",
+    status: "connecting",
+  }));
+
+  bridge.updateSessionMetadata([
+    {
+      sessionId: "sess-opened",
+      hostname: "10.0.0.2",
+      label: "server-b",
+      connected: false,
+      hostId: "host-b",
+      protocol: "ssh",
+    },
+  ], "chat-1");
+  await bridge.dispatchBuiltinRpc("public/vault/hosts/open", {
+    chatSessionId: "chat-1",
+    hostId: "host-b",
+  });
+
+  // Another surface (External MCP / opened tab) learns the session connected.
+  bridge.updateSessionMetadata([
+    {
+      sessionId: "sess-opened",
+      hostname: "10.0.0.2",
+      label: "server-b",
+      connected: true,
+      hostId: "host-b",
+      protocol: "ssh",
+      username: "root",
+    },
+  ], "__external_mcp__");
+
+  // Original chat sidebar still pushes only the focused tab.
+  bridge.updateSessionMetadata([
+    {
+      sessionId: "sess-original",
+      hostname: "10.0.0.1",
+      label: "server-a",
+      connected: true,
+      hostId: "host-a",
+    },
+  ], "chat-1");
+
+  assert.equal(bridge.getSessionMeta("sess-opened", "chat-1")?.connected, true);
+  assert.equal(bridge.getSessionMeta("sess-opened", "chat-1")?.username, "root");
+});
+
+test("retained host_open metadata accepts a later disconnect from another scope", async (t) => {
+  const bridge = loadFreshBridge();
+  t.after(() => bridge.cleanup());
+  bridge.init({
+    sessions: new Map(),
+    electronModule: null,
+  });
+  bridge.setPermissionMode("auto");
+  bridge.setVaultAgentInvoker(async () => ({
+    ok: true,
+    sessionId: "sess-opened",
+    hostId: "host-b",
+    status: "connecting",
+  }));
+
+  bridge.updateSessionMetadata([
+    {
+      sessionId: "sess-opened",
+      hostname: "10.0.0.2",
+      label: "server-b",
+      connected: true,
+      hostId: "host-b",
+      protocol: "ssh",
+    },
+  ], "chat-1");
+  await bridge.dispatchBuiltinRpc("public/vault/hosts/open", {
+    chatSessionId: "chat-1",
+    hostId: "host-b",
+  });
+
+  // The focused tab moved away; External MCP later learns the host dropped.
+  bridge.updateSessionMetadata([
+    {
+      sessionId: "sess-opened",
+      hostname: "10.0.0.2",
+      label: "server-b",
+      connected: false,
+      hostId: "host-b",
+      protocol: "ssh",
+    },
+  ], "__external_mcp__");
+
+  bridge.updateSessionMetadata([
+    {
+      sessionId: "sess-original",
+      hostname: "10.0.0.1",
+      label: "server-a",
+      connected: true,
+      hostId: "host-a",
+    },
+  ], "chat-1");
+
+  assert.equal(bridge.getSessionMeta("sess-opened", "chat-1")?.connected, false);
+});
+
+test("getSessionMeta clears stopped port forwards from another scope while owned session stays connected", async (t) => {
+  const bridge = loadFreshBridge();
+  t.after(() => bridge.cleanup());
+  bridge.init({
+    sessions: new Map(),
+    electronModule: null,
+  });
+  bridge.setPermissionMode("auto");
+  bridge.setVaultAgentInvoker(async () => ({
+    ok: true,
+    sessionId: "sess-opened",
+    hostId: "host-b",
+    status: "connecting",
+  }));
+
+  const forwards = [{ ruleId: "fwd-1", localPort: 8080, status: "active" }];
+  bridge.updateSessionMetadata([
+    {
+      sessionId: "sess-opened",
+      hostname: "10.0.0.2",
+      label: "server-b",
+      connected: true,
+      hostId: "host-b",
+      protocol: "ssh",
+      activePortForwards: forwards,
+    },
+  ], "chat-1");
+  await bridge.dispatchBuiltinRpc("public/vault/hosts/open", {
+    chatSessionId: "chat-1",
+    hostId: "host-b",
+  });
+
+  // Another surface reports the session still up, but forwards already stopped.
+  // chat-1 does not get another metadata replace (focused tab stayed elsewhere).
+  bridge.updateSessionMetadata([
+    {
+      sessionId: "sess-opened",
+      hostname: "10.0.0.2",
+      label: "server-b",
+      connected: true,
+      hostId: "host-b",
+      protocol: "ssh",
+      activePortForwards: [],
+    },
+  ], "__external_mcp__");
+
+  assert.equal(bridge.getSessionMeta("sess-opened", "chat-1")?.connected, true);
+  assert.deepEqual(bridge.getSessionMeta("sess-opened", "chat-1")?.activePortForwards, []);
+});
+
+test("getSessionMeta does not let another scope clear forwards on a live non-owned session", async (t) => {
+  const bridge = loadFreshBridge();
+  t.after(() => bridge.cleanup());
+  bridge.init({
+    sessions: new Map(),
+    electronModule: null,
+  });
+
+  const forwards = [{ ruleId: "fwd-1", localPort: 8080, status: "active" }];
+  bridge.updateSessionMetadata([
+    {
+      sessionId: "sess-live",
+      hostname: "10.0.0.1",
+      label: "server-a",
+      connected: true,
+      hostId: "host-a",
+      activePortForwards: forwards,
+    },
+  ], "chat-1");
+  bridge.updateSessionMetadata([
+    {
+      sessionId: "sess-live",
+      hostname: "10.0.0.1",
+      label: "server-a",
+      connected: true,
+      hostId: "host-a",
+      activePortForwards: [],
+    },
+  ], "__external_mcp__");
+
+  assert.deepEqual(
+    bridge.getSessionMeta("sess-live", "chat-1")?.activePortForwards,
+    forwards,
+  );
+});
+
+test("ordinary tab close forgets host_open ownership so sidebar sync cannot revive ghosts", async (t) => {
+  const bridge = loadFreshBridge();
+  t.after(() => bridge.cleanup());
+  const closedListeners = new Set();
+  bridge.init({
+    sessions: new Map(),
+    electronModule: null,
+    terminalWorkerManager: {
+      onSessionClosed(listener) {
+        closedListeners.add(listener);
+        return {
+          dispose: () => closedListeners.delete(listener),
+        };
+      },
+    },
+  });
+  bridge.setPermissionMode("auto");
+  bridge.setVaultAgentInvoker(async () => ({
+    ok: true,
+    sessionId: "sess-opened",
+    hostId: "host-b",
+    status: "connecting",
+  }));
+
+  bridge.updateSessionMetadata([
+    {
+      sessionId: "sess-opened",
+      hostname: "10.0.0.2",
+      label: "server-b",
+      connected: true,
+      hostId: "host-b",
+    },
+  ], "chat-1");
+  await bridge.dispatchBuiltinRpc("public/vault/hosts/open", {
+    chatSessionId: "chat-1",
+    hostId: "host-b",
+  });
+
+  // User closes the host_open tab through the normal UI / worker path.
+  for (const listener of closedListeners) {
+    listener({ sessionId: "sess-opened", reason: "closed", explicit: true });
+  }
+
+  bridge.updateSessionMetadata([
+    {
+      sessionId: "sess-original",
+      hostname: "10.0.0.1",
+      label: "server-a",
+      connected: true,
+      hostId: "host-a",
+    },
+  ], "chat-1");
+
+  assert.deepEqual(bridge.getScopedSessionIds("chat-1"), ["sess-original"]);
+  assert.equal(bridge.getSessionMeta("sess-opened", "chat-1"), null);
+});
+
+test("recoverable worker exits keep host_open ownership for reconnect", async (t) => {
+  const bridge = loadFreshBridge();
+  t.after(() => bridge.cleanup());
+  const closedListeners = new Set();
+  bridge.init({
+    sessions: new Map(),
+    electronModule: null,
+    terminalWorkerManager: {
+      onSessionClosed(listener) {
+        closedListeners.add(listener);
+        return {
+          dispose: () => closedListeners.delete(listener),
+        };
+      },
+    },
+  });
+  bridge.setPermissionMode("auto");
+  bridge.setVaultAgentInvoker(async () => ({
+    ok: true,
+    sessionId: "sess-opened",
+    hostId: "host-b",
+    status: "connecting",
+  }));
+
+  bridge.updateSessionMetadata([
+    {
+      sessionId: "sess-opened",
+      hostname: "10.0.0.2",
+      label: "server-b",
+      connected: true,
+      hostId: "host-b",
+    },
+  ], "chat-1");
+  await bridge.dispatchBuiltinRpc("public/vault/hosts/open", {
+    chatSessionId: "chat-1",
+    hostId: "host-b",
+  });
+
+  for (const event of [
+    { reason: "error" },
+    { reason: "worker-exit" },
+    { reason: "superseded" },
+    { reason: "closed" },
+    // Shell exits that leave the tab for reconnect (missing/nonzero exitCode).
+    { reason: "exited" },
+    { reason: "exited", exitCode: 1 },
+  ]) {
+    for (const listener of closedListeners) {
+      listener({ sessionId: "sess-opened", ...event });
+    }
+  }
+
+  // After reconnect, sidebar may push only the focused tab; ownership must
+  // still retain the host_open session.
+  bridge.updateSessionMetadata([
+    {
+      sessionId: "sess-original",
+      hostname: "10.0.0.1",
+      label: "server-a",
+      connected: true,
+      hostId: "host-a",
+    },
+  ], "chat-1");
+
+  assert.deepEqual(
+    bridge.getScopedSessionIds("chat-1").sort(),
+    ["sess-opened", "sess-original"],
+  );
+});
+
+test("clean shell exit keeps ownership until the tab is explicitly closed", async (t) => {
+  const bridge = loadFreshBridge();
+  t.after(() => bridge.cleanup());
+  const closedListeners = new Set();
+  bridge.init({
+    sessions: new Map(),
+    electronModule: null,
+    terminalWorkerManager: {
+      onSessionClosed(listener) {
+        closedListeners.add(listener);
+        return {
+          dispose: () => closedListeners.delete(listener),
+        };
+      },
+    },
+  });
+  bridge.setPermissionMode("auto");
+  bridge.setVaultAgentInvoker(async () => ({
+    ok: true,
+    sessionId: "sess-opened",
+    hostId: "host-b",
+    status: "connecting",
+  }));
+
+  bridge.updateSessionMetadata([
+    {
+      sessionId: "sess-opened",
+      hostname: "10.0.0.2",
+      label: "server-b",
+      connected: true,
+      hostId: "host-b",
+    },
+  ], "chat-1");
+  await bridge.dispatchBuiltinRpc("public/vault/hosts/open", {
+    chatSessionId: "chat-1",
+    hostId: "host-b",
+  });
+
+  // Worker reports a clean exit; auto-close may still leave the tab briefly,
+  // and disabled auto-close keeps it for reconnect — ownership stays.
+  for (const listener of closedListeners) {
+    listener({ sessionId: "sess-opened", reason: "exited", exitCode: 0 });
+  }
+
+  bridge.updateSessionMetadata([
+    {
+      sessionId: "sess-original",
+      hostname: "10.0.0.1",
+      label: "server-a",
+      connected: true,
+      hostId: "host-a",
+    },
+  ], "chat-1");
+  assert.deepEqual(
+    bridge.getScopedSessionIds("chat-1").sort(),
+    ["sess-opened", "sess-original"],
+  );
+
+  // Renderer tab close is the authoritative ownership drop.
+  for (const listener of closedListeners) {
+    listener({ sessionId: "sess-opened", reason: "closed", explicit: true });
+  }
+  bridge.updateSessionMetadata([
+    {
+      sessionId: "sess-original",
+      hostname: "10.0.0.1",
+      label: "server-a",
+      connected: true,
+      hostId: "host-a",
+    },
+  ], "chat-1");
+  assert.deepEqual(bridge.getScopedSessionIds("chat-1"), ["sess-original"]);
+});
+
+test("latest metadata revision wins across multiple chat and external scopes", async (t) => {
+  const bridge = loadFreshBridge();
+  t.after(() => bridge.cleanup());
+  bridge.init({ sessions: new Map(), electronModule: null });
+  bridge.setPermissionMode("auto");
+  bridge.setVaultAgentInvoker(async () => ({
+    ok: true,
+    sessionId: "sess-opened",
+    hostId: "host-b",
+    status: "connecting",
+  }));
+
+  bridge.updateSessionMetadata([{
+    sessionId: "sess-opened",
+    connected: true,
+    activePortForwards: [{ ruleId: "old-forward" }],
+  }], "chat-stale");
+  bridge.updateSessionMetadata([{
+    sessionId: "sess-opened",
+    connected: true,
+    activePortForwards: [],
+  }], "chat-owner");
+  await bridge.dispatchBuiltinRpc("public/vault/hosts/open", {
+    chatSessionId: "chat-owner",
+    hostId: "host-b",
+  });
+
+  bridge.updateSessionMetadata([{
+    sessionId: "sess-opened",
+    connected: false,
+    activePortForwards: [],
+  }], "__external_mcp__");
+  assert.equal(bridge.getSessionMeta("sess-opened", "chat-owner")?.connected, false);
+  assert.deepEqual(bridge.getSessionMeta("sess-opened", "chat-owner")?.activePortForwards, []);
+
+  bridge.updateSessionMetadata([{
+    sessionId: "sess-opened",
+    connected: true,
+    username: "reconnected-user",
+    activePortForwards: [{ ruleId: "new-forward" }],
+  }], "chat-live");
+  assert.equal(bridge.getSessionMeta("sess-opened", "chat-owner")?.connected, true);
+  assert.equal(bridge.getSessionMeta("sess-opened", "chat-owner")?.username, "reconnected-user");
+  assert.deepEqual(
+    bridge.getSessionMeta("sess-opened", "chat-owner")?.activePortForwards,
+    [{ ruleId: "new-forward" }],
+  );
+});
+
+test("host_open finishing after an empty scope replace restores its returned session", async (t) => {
+  const bridge = loadFreshBridge();
+  t.after(() => bridge.cleanup());
+  bridge.init({ sessions: new Map(), electronModule: null });
+  bridge.setPermissionMode("auto");
+  let finishOpen;
+  bridge.setVaultAgentInvoker(() => new Promise((resolve) => {
+    finishOpen = resolve;
+  }));
+
+  bridge.updateSessionMetadata([{ sessionId: "sess-original", connected: true }], "chat-race");
+  const opening = bridge.dispatchBuiltinRpc("public/vault/hosts/open", {
+    chatSessionId: "chat-race",
+    hostId: "host-b",
+  });
+  bridge.updateSessionMetadata([], "chat-race");
+  finishOpen({
+    ok: true,
+    sessionId: "sess-opened",
+    hostId: "host-b",
+    status: "connecting",
+    protocol: "ssh",
+    host: { id: "host-b", hostname: "10.0.0.2", label: "server-b", username: "root" },
+  });
+
+  const opened = await opening;
+  assert.equal(opened.ok, true);
+  assert.deepEqual(bridge.getScopedSessionIds("chat-race"), ["sess-opened"]);
+  assert.equal(bridge.getSessionMeta("sess-opened", "chat-race")?.label, "server-b");
+  assert.equal(bridge.getSessionMeta("sess-opened", "chat-race")?.connected, false);
+});
+
+test("initial external scope seed selects the latest session snapshot", (t) => {
+  const bridge = loadFreshBridge();
+  t.after(() => bridge.cleanup());
+  bridge.init({ sessions: new Map(), electronModule: null });
+
+  bridge.updateSessionMetadata([{
+    sessionId: "sess-shared",
+    connected: true,
+    username: "old-user",
+  }], "chat-old");
+  bridge.updateSessionMetadata([{
+    sessionId: "sess-shared",
+    connected: false,
+    username: "new-user",
+  }], "chat-new");
+
+  const seeded = bridge.syncLiveSessionsToExternalScope();
+  assert.equal(seeded.seeded, true);
+  assert.equal(bridge.getSessionMeta("sess-shared", "__external_mcp__")?.connected, false);
+  assert.equal(bridge.getSessionMeta("sess-shared", "__external_mcp__")?.username, "new-user");
+});
+
+test("explicit close before host_open returns cannot revive the closed session", async (t) => {
+  const bridge = loadFreshBridge();
+  t.after(() => bridge.cleanup());
+  bridge.init({ sessions: new Map(), electronModule: null });
+  bridge.setPermissionMode("auto");
+  let finishOpen;
+  bridge.setVaultAgentInvoker(() => new Promise((resolve) => {
+    finishOpen = resolve;
+  }));
+
+  bridge.updateSessionMetadata([{ sessionId: "sess-original", connected: true }], "chat-close-race");
+  const opening = bridge.dispatchBuiltinRpc("public/vault/hosts/open", {
+    chatSessionId: "chat-close-race",
+    hostId: "host-b",
+  });
+  // Renderer-side host.open creates and merges the tab before returning its
+  // result to the main process. Simulate the user closing that tab immediately.
+  bridge.mergeSessionMetadata([{
+    sessionId: "sess-opened",
+    hostId: "host-b",
+    connected: false,
+  }], "chat-close-race");
+  bridge.forgetClosedTerminalSession("sess-opened");
+  finishOpen({
+    ok: true,
+    sessionId: "sess-opened",
+    hostId: "host-b",
+    status: "connecting",
+    protocol: "ssh",
+  });
+
+  assert.equal((await opening).ok, true);
+  bridge.updateSessionMetadata([{ sessionId: "sess-original", connected: true }], "chat-close-race");
+  assert.deepEqual(bridge.getScopedSessionIds("chat-close-race"), ["sess-original"]);
+  assert.equal(bridge.getSessionMeta("sess-opened", "chat-close-race"), null);
+});
+
+test("app live sync makes host_open session usable without External MCP or a second AI panel", async (t) => {
+  const bridge = loadFreshBridge();
+  t.after(() => bridge.cleanup());
+  const requests = [];
+  bridge.init({
+    sessions: new Map(),
+    electronModule: null,
+    terminalWorkerManager: {
+      request(channel, payload, options) {
+        requests.push({ channel, payload, options });
+        if (channel === "netcatty:portforward:list") return Promise.resolve([]);
+        if (channel === "netcatty:ai:exec") {
+          return Promise.resolve({ ok: true, stdout: "ready\n", stderr: "", exitCode: 0 });
+        }
+        throw new Error(`unexpected worker request: ${channel}`);
+      },
+    },
+  });
+  bridge.setPermissionMode("auto");
+  bridge.setVaultAgentInvoker(async () => ({
+    ok: true,
+    sessionId: "sess-opened",
+    hostId: "host-b",
+    status: "connecting",
+    protocol: "ssh",
+    host: { id: "host-b", hostname: "10.0.0.2", label: "server-b", username: "root" },
+  }));
+
+  bridge.updateSessionMetadata([{ sessionId: "sess-original", connected: true }], "chat-owner");
+  await bridge.dispatchBuiltinRpc("public/vault/hosts/open", {
+    chatSessionId: "chat-owner",
+    hostId: "host-b",
+  });
+
+  // The app-level session state observes the connection. No External MCP scope
+  // and no AI panel for the opened tab are involved.
+  bridge.updateLiveSessionMetadata([{
+    sessionId: "sess-opened",
+    hostId: "host-b",
+    hostname: "10.0.0.2",
+    label: "server-b",
+    username: "root",
+    protocol: "ssh",
+    connected: true,
+  }]);
+
+  // Returning to the original tab replaces its sidebar payload with only A.
+  bridge.updateSessionMetadata([{ sessionId: "sess-original", connected: true }], "chat-owner");
+  assert.deepEqual(
+    bridge.getScopedSessionIds("chat-owner").sort(),
+    ["sess-opened", "sess-original"],
+  );
+  assert.equal(bridge.getSessionMeta("sess-opened", "chat-owner")?.connected, true);
+
+  const environment = await bridge.dispatchBuiltinRpc("netcatty/getContext", {
+    chatSessionId: "chat-owner",
+  });
+  const openedHost = environment.hosts.find((host) => host.sessionId === "sess-opened");
+  assert.equal(openedHost?.connected, true);
+
+  const executed = await bridge.dispatchBuiltinRpc("netcatty/exec", {
+    chatSessionId: "chat-owner",
+    sessionId: "sess-opened",
+    command: "pwd",
+  });
+  assert.deepEqual(executed, { ok: true, stdout: "ready\n", stderr: "", exitCode: 0 });
+  assert.equal(requests.some((entry) => entry.channel === "netcatty:ai:exec"), true);
+});
+
+test("chat cleanup during host_open closes the late-created unowned session", async (t) => {
+  const bridge = loadFreshBridge();
+  t.after(() => bridge.cleanup());
+  bridge.init({ sessions: new Map(), electronModule: null });
+  bridge.setPermissionMode("auto");
+  let finishOpen;
+  const calls = [];
+  bridge.setVaultAgentInvoker((op, params) => {
+    calls.push({ op, params });
+    if (op === "host.open") {
+      return new Promise((resolve) => {
+        finishOpen = resolve;
+      });
+    }
+    if (op === "session.close") return Promise.resolve({ ok: true, sessionId: params.sessionId });
+    throw new Error(`unexpected op ${op}`);
+  });
+
+  bridge.updateSessionMetadata([{ sessionId: "sess-original", connected: true }], "chat-deleted");
+  const opening = bridge.dispatchBuiltinRpc("public/vault/hosts/open", {
+    chatSessionId: "chat-deleted",
+    hostId: "host-b",
+  });
+  await bridge.cleanupScopedMetadata("chat-deleted");
+
+  // Renderer host.open can still finish its own merge after chat cleanup.
+  bridge.mergeSessionMetadata([{
+    sessionId: "sess-opened",
+    hostId: "host-b",
+    connected: false,
+  }], "chat-deleted");
+  finishOpen({
+    ok: true,
+    sessionId: "sess-opened",
+    hostId: "host-b",
+    status: "connecting",
+    protocol: "ssh",
+  });
+
+  assert.equal((await opening).ok, true);
+  assert.deepEqual(calls.map(({ op }) => op), ["host.open", "session.close"]);
+  assert.deepEqual(bridge.getScopedSessionIds("chat-deleted"), []);
+  assert.equal(bridge.getSessionMeta("sess-opened", "chat-deleted"), null);
+});
+
+test("failed compensating close keeps the late-created session tracked for retry", async (t) => {
+  const bridge = loadFreshBridge();
+  t.after(() => bridge.cleanup());
+  bridge.init({ sessions: new Map(), electronModule: null });
+  bridge.setPermissionMode("auto");
+  let finishOpen;
+  bridge.setVaultAgentInvoker((op) => {
+    if (op === "host.open") {
+      return new Promise((resolve) => {
+        finishOpen = resolve;
+      });
+    }
+    if (op === "session.close") {
+      return Promise.resolve({ ok: false, error: "renderer unavailable" });
+    }
+    throw new Error(`unexpected op ${op}`);
+  });
+
+  const opening = bridge.dispatchBuiltinRpc("public/vault/hosts/open", {
+    chatSessionId: "chat-deleted",
+    hostId: "host-b",
+  });
+  await bridge.cleanupScopedMetadata("chat-deleted");
+  bridge.mergeSessionMetadata([{
+    sessionId: "sess-opened",
+    hostId: "host-b",
+    connected: false,
+  }], "chat-deleted");
+  finishOpen({ ok: true, sessionId: "sess-opened", hostId: "host-b", status: "connecting" });
+
+  assert.equal((await opening).ok, true);
+  assert.deepEqual(bridge.getScopedSessionIds("chat-deleted"), []);
+  assert.equal(bridge.getSessionMeta("sess-opened", "chat-deleted"), null);
+  assert.equal(
+    bridge.reportOpenedSessionActivity({ sessionId: "sess-opened", phase: "touch" }),
+    true,
+  );
+});