cc-viewer 1.9.4 → 1.9.6

package/server/lib/sdk-manager.js

@@ -32,6 +32,8 @@ import { evaluateImDeny } from './im-deny.js';
 import { APPROVAL_TOOLS, isPublishCommand } from './approval-policy.js';
 import { reportSwallowed } from '@ccv/core/error-report';
 import { resolve as _pathResolve } from 'node:path';
+import { createHash } from 'node:crypto';
+import { registerSdkSessionLister } from './sdk-session-index.js';
 
 let _query;
 try {
@@ -71,7 +73,13 @@ function _getOrCreateSession(cwd) {
 // The ACTIVE session (the one the composer talks to). May be null before any init.
 function _active() { return _activeKey != null ? _sessions.get(_activeKey) : null; }
 
-// Resolve an anchor { cwd|project } to a Session WITHOUT switching active (read ops).
+function _matchesProject(sess, project) {
+  const rawBase = String(sess.cwd || '').replace(/\\/g, '/').split('/').filter(Boolean).pop();
+  const sanitized = rawBase ? rawBase.replace(/[^a-zA-Z0-9_\-.]/g, '_') : null;
+  return sanitized === project || rawBase === project;
+}
+
+// Resolve an anchor { instanceKey|cwd|project } to a Session WITHOUT switching active (read ops).
 // `cwd` is an absolute path (exact key match); `project` is the SANITIZED project name the
 // web client sends (ChatView stamps `viewProject || projectName`, where projectName =
 // projectKeyForCwd(cwd) — non [a-zA-Z0-9_-] chars become `_`, so a dir with spaces/CJK sends
@@ -80,8 +88,18 @@ function _active() { return _activeKey != null ? _sessions.get(_activeKey) : nul
 // guess). Returns null when the anchor resolves to no registered session.
 function _sessionForAnchor(anchor) {
   if (!anchor || typeof anchor !== 'object') return null;
+  const instanceKey = (typeof anchor.instanceKey === 'string' && anchor.instanceKey) || null;
   const cwd = (typeof anchor.cwd === 'string' && anchor.cwd) || null;
   const project = (typeof anchor.project === 'string' && anchor.project) || null;
+  if (instanceKey) {
+    for (const s of _sessions.values()) {
+      if (s.instanceKey === instanceKey) return s;
+    }
+    // An exact instance that no longer exists must never fall back to a
+    // same-basename sibling — that would execute the user's action in the
+    // wrong workspace. The caller's unknown-anchor path drops + reports it.
+    return null;
+  }
   if (cwd) return _sessions.get(_normalizeCwd(cwd)) || null;
   if (!project) return null;
   // exact-path form of a project (an absolute path was passed as `project`) — try key first.
@@ -89,9 +107,7 @@ function _sessionForAnchor(anchor) {
   if (byKey) return byKey;
   let found = null;
   for (const s of _sessions.values()) {
-    const rawBase = String(s.cwd || '').replace(/\\/g, '/').split('/').filter(Boolean).pop();
-    const sanitized = rawBase ? rawBase.replace(/[^a-zA-Z0-9_\-.]/g, '_') : null;
-    if (sanitized === project || rawBase === project) { if (found) return null; found = s; } // ambiguous → null
+    if (_matchesProject(s, project)) { if (found) return null; found = s; } // ambiguous → null
   }
   return found;
 }
@@ -100,12 +116,17 @@ function _sessionForAnchor(anchor) {
 export function __listSessionsForTests() { return [..._sessions.keys()]; }
 export function __getSessionKeyForTests(cwd) { return _normalizeCwd(cwd); }
 
-/** Enumerate the per-cwd SDK session registry for the header's live list. Each entry:
- * { key, cwd, active }. Read-only. */
+/** Enumerate the per-cwd SDK session registry for live workspace routing. Each entry:
+ * { key, cwd, active, instanceKey }. Read-only. NOTE: `key` is the registry's
+ * normalized-cwd key; attach/close responses instead alias `key` to the instanceKey
+ * for killPtyFor-shape parity (resume.js consumes `r.key === reattachedTo`). Callers
+ * must not mix the two namespaces. */
 export function listSdkSessions() {
-  return [..._sessions.values()].map((s) => ({ key: s.key, cwd: s.cwd, active: s.key === _activeKey }));
+  return [..._sessions.values()].map((s) => ({ key: s.key, cwd: s.cwd, active: s.key === _activeKey, instanceKey: s.instanceKey }));
 }
 
+registerSdkSessionLister(listSdkSessions);
+
 // Silence window for the watchdog. Must stay above the approval ceilings the turn can
 // legally wait on: perm/plan = 5min, AskUserQuestion = 24h ("GUI effectively has no
 // timeout" is a product contract). A pending approval exempts the turn from the
@@ -275,6 +296,7 @@ function _normalizeSdkTask(msg) {
 // `let` (rebinding, not a frozen property) so assignment paths like
 // `_messageQueue = []` keep working.
 function _createSession(key, cwd) {
+  const instanceKey = `ccv-${createHash('sha256').update(key).digest('hex').slice(0, 32)}`;
   // Launch config (per-session identity; adopted on lazy reconstruction)
   let _cwd = cwd;
   let _permissionMode = 'default';
@@ -337,13 +359,14 @@ function _createSession(key, cwd) {
   let _suppressDrain = false;
 
     // Wrap the process-global _broadcastWs so EVERY frame this session emits carries
-    // its routing identity (cwd + sessionId): with concurrent sessions on one WS, the
-    // frontend filters frames by cwd — without it every workspace's clients would see
-    // every other workspace's spinner/queue/modal frames.
+    // its routing identity (cwd + sessionId + instanceKey): with concurrent sessions on
+    // one WS, the frontend/server filter frames by workspace+instance — without it every
+    // workspace's (or same-basename twin's) clients would see every other workspace's
+    // spinner/queue/modal frames.
   function _broadcast(payload) {
     if (!_broadcastWs) return;
     try {
-      _broadcastWs({ cwd: _cwd, sessionId: _sessionId || null, ...payload });
+      _broadcastWs({ cwd: _cwd, sessionId: _sessionId || null, instanceKey, ...payload });
     } catch (err) { reportSwallowed('sdk-manager.broadcast', err); }
   }
 
@@ -440,7 +463,7 @@ function _createSession(key, cwd) {
         // Negative ack: the frontend cleared the composer optimistically — never fail
         // silently. Only the reject frame goes out (no queue-state — nothing changed).
         console.warn('[sdk-manager] queue full, rejecting message');
-        try { if (_broadcastWs) _broadcastWs({ type: 'queue-rejected', reason: 'full', cwd: _cwd, sessionId: _sessionId || null }); }
+        try { if (_broadcastWs) _broadcastWs({ type: 'queue-rejected', reason: 'full', cwd: _cwd, sessionId: _sessionId || null, instanceKey }); }
         catch (err) { reportSwallowed('sdk-manager.reject-broadcast', err); }
         return;
       }
@@ -459,7 +482,7 @@ function _createSession(key, cwd) {
   function _broadcastQueueState() {
     if (!_broadcastWs) return;
     try {
-      _broadcastWs({ type: 'queue-state', cwd: _cwd, sessionId: _sessionId || null, items: _messageQueue.map(({ id, text, ts }) => ({ id, text, ts })) });
+      _broadcastWs({ type: 'queue-state', cwd: _cwd, sessionId: _sessionId || null, instanceKey, items: _messageQueue.map(({ id, text, ts }) => ({ id, text, ts })) });
     } catch (err) { console.warn('[sdk-manager] queue-state broadcast threw:', err?.message); }
   }
 
@@ -531,8 +554,15 @@ function _createSession(key, cwd) {
       const headerCwd = String(_cwd).replace(/[\r\n\x00-\x1f\x7f]/g, '');
       if (headerCwd) {
         const projectHeader = `x-ccv-project-dir: ${headerCwd}`;
+        // Same-name twin isolation (review P2): also self-report this session's stable
+        // instanceKey so the interceptor stamps `_ccvInstance` → v2 meta.instance →
+        // scoped instance routing, exactly like a PTY spawn. Without it, two same-basename
+        // SDK workspaces share project-scoped frames (close teardown kills the twin's
+        // spinner/queue bubbles) and cold-load instance filters never match SDK sessions.
+        const instanceHeader = `x-ccv-instance: ${instanceKey}`;
+        const injected = `${projectHeader}\n${instanceHeader}`;
         options.env.ANTHROPIC_CUSTOM_HEADERS = options.env.ANTHROPIC_CUSTOM_HEADERS
-          ? `${options.env.ANTHROPIC_CUSTOM_HEADERS}\n${projectHeader}` : projectHeader;
+          ? `${options.env.ANTHROPIC_CUSTOM_HEADERS}\n${injected}` : injected;
       }
     }
     if (_settings) options.settings = _settings;
@@ -695,8 +725,8 @@ function _createSession(key, cwd) {
     const valid = state === 'idle' || state === 'running' || state === 'requires_action';
     if (!valid || state === _lastSessionState) return;
     _lastSessionState = state;
-    // _broadcast carries the routing envelope (cwd + sessionId) — every frame needs
-    // it so concurrent sessions' clients filter correctly.
+    // _broadcast carries the routing envelope (cwd + sessionId + instanceKey) — every
+    // frame needs it so concurrent sessions' clients filter correctly.
     _broadcast({ type: 'sdk-session-state', state });
   }
 
@@ -728,6 +758,7 @@ function _createSession(key, cwd) {
             slashCommands: msg.slash_commands,
             tools: msg.tools,
             cwd: _cwd,
+            instanceKey,
           };
           _broadcastWs(_lastInitSnapshot);
         } else if (msg.subtype === 'compact_boundary' && _broadcastWs) {
@@ -739,6 +770,7 @@ function _createSession(key, cwd) {
             postTokens: meta && meta.post_tokens,
             cwd: _cwd,
             sessionId: _sessionId || null,
+            instanceKey,
           });
           // Compaction is the only non-turn event that materially shrinks context — refresh
           // the usage panel. Coalesced with the turn-end refresh via the in-flight gate.
@@ -752,7 +784,7 @@ function _createSession(key, cwd) {
           // failed/stopped/killed terminal states the TODO HUD vocabulary lacks). The
           // server keeps no task table here — pure forward, merge semantics left to the
           // client (task_updated.patch is a wire-safe delta, not a full snapshot).
-          _broadcastWs({ type: 'sdk-task', cwd: _cwd, ..._normalizeSdkTask(msg) });
+          _broadcastWs({ type: 'sdk-task', cwd: _cwd, instanceKey, ..._normalizeSdkTask(msg) });
         }
         break;
 
@@ -798,7 +830,10 @@ function _createSession(key, cwd) {
         // doesn't go through ensureHooks() so this in-process callback is the
         // only way the renderer learns the turn is over.
         if (_onTurnEnd) {
-          try { _onTurnEnd({ sessionId: _sessionId, ts: Date.now() }); }
+          // Per-workspace (2026-10): carry the session's own cwd so the server
+          // can route turn_end to THIS workspace's SSE scope (SDK mode has no
+          // Stop-hook POST, so this callback is the only turn-end producer).
+          try { _onTurnEnd({ sessionId: _sessionId, ts: Date.now(), cwd: _cwd }); }
           catch (err) { console.warn('[sdk-manager] onTurnEnd threw:', err?.message); }
         }
         if (rec) _settleTurn(rec);
@@ -834,7 +869,7 @@ function _createSession(key, cwd) {
       ? resultMsg.errors.join('; ')
       : (typeof resultMsg.result === 'string' && resultMsg.result) || resultMsg.subtype || 'unknown error';
     if (_broadcastWs) {
-      try { _broadcastWs({ type: 'sdk-error', message: String(errs), cwd: _cwd, sessionId: _sessionId || null }); } catch (err) { console.warn('[sdk-manager] sdk-error broadcast threw:', err?.message); }
+      try { _broadcastWs({ type: 'sdk-error', message: String(errs), cwd: _cwd, sessionId: _sessionId || null, instanceKey }); } catch (err) { console.warn('[sdk-manager] sdk-error broadcast threw:', err?.message); }
     }
   }
 
@@ -912,7 +947,7 @@ function _createSession(key, cwd) {
     _ctxUsageFetching = false;
     _ctxUsageQueued = false;
     if (had && _broadcastWs) {
-      try { _broadcastWs({ type: 'sdk-context-usage', sessionId: _sessionId, ts: Date.now(), trigger, usage: null, cwd: _cwd }); }
+      try { _broadcastWs({ type: 'sdk-context-usage', sessionId: _sessionId, ts: Date.now(), trigger, usage: null, cwd: _cwd, instanceKey }); }
       catch (err) { reportSwallowed('sdk-manager.context-usage-broadcast', err); }
     }
   }
@@ -960,7 +995,7 @@ function _createSession(key, cwd) {
     const had = _lastMcpStatus !== null;
     _lastMcpStatus = null;
     if (had && _broadcastWs) {
-      try { _broadcastWs({ type: 'sdk-mcp-status', sessionId: _sessionId, ts: Date.now(), trigger, servers: null, cwd: _cwd }); }
+      try { _broadcastWs({ type: 'sdk-mcp-status', sessionId: _sessionId, ts: Date.now(), trigger, servers: null, cwd: _cwd, instanceKey }); }
       catch (err) { reportSwallowed('sdk-manager.mcp-status-broadcast', err); }
     }
   }
@@ -1131,7 +1166,7 @@ function _createSession(key, cwd) {
       : kind === 'plan' ? 'sdk-plan-resolved'
       : 'perm-hook-timeout';
     try {
-      _broadcastWs({ type, id, reason, cwd: _cwd, sessionId: _sessionId || null });
+      _broadcastWs({ type, id, reason, cwd: _cwd, sessionId: _sessionId || null, instanceKey });
     } catch (err) { console.warn('[sdk-manager] approval-dismiss broadcast threw:', err?.message); }
   }
 
@@ -1448,6 +1483,7 @@ function _createSession(key, cwd) {
   // body, now per-session). `init` = config adoption + that teardown/reset pair.
   return {
     key,
+    instanceKey,
     get cwd() { return _cwd; },
     get config() {
       return {
@@ -1500,6 +1536,13 @@ function _createSession(key, cwd) {
     },
     switchToSession: _switchToSession,
     getSessionId: () => _sessionId,
+    close: () => {
+      for (const { id, kind } of _cancelAllApprovals()) {
+        _broadcastApprovalDismiss(kind, id, 'session-closed');
+      }
+      _teardownResident();
+      _resetFullState();
+    },
     teardown: () => {
       _teardownResident();
       _resetFullState();
@@ -1564,20 +1607,19 @@ export function initSdkSession(cwd, projectName, { onTurnEnd, onQueryError, broa
  */
 export async function sendUserMessage(text, anchor) {
   if (!_query) throw new Error('Agent SDK not available');
-  const sess = _active();
-  if (!sess) {
-    // Uninitialized — the old module's state machine only came alive after
-    // initSdkSession; a pre-init send just resolves (the SDK-unavailable guard
-    // above already covered the only documented throw).
-    return;
-  }
-  if (anchor && (anchor.cwd || anchor.project)) {
+  if (anchor && (anchor.cwd || anchor.project || anchor.instanceKey)) {
     const target = _sessionForAnchor(anchor);
     if (!target) {
-      // A mis-resolved anchor must not silently drop the user's message — log + report.
-      const targetName = anchor.cwd || anchor.project;
+      // A mis-resolved anchor must not silently drop the user's message — log + report,
+      // and surface a toast through the same channel query errors use (the composer was
+      // already cleared client-side; without this the text vanishes without a trace).
+      const targetName = anchor.cwd || anchor.project || anchor.instanceKey;
       console.warn(`[sdk-manager] no SDK session registered for "${targetName}" — message dropped`);
       reportSwallowed('sdk-manager.route', new Error(`no SDK session for ${targetName}`));
+      if (_onQueryError) {
+        try { _onQueryError(`Workspace "${targetName}" is no longer available — message not sent.`); }
+        catch (err) { console.warn('[sdk-manager] onQueryError threw:', err?.message); }
+      }
       return;
     }
     if (target.key !== _activeKey) {
@@ -1585,6 +1627,13 @@ export async function sendUserMessage(text, anchor) {
     }
     return target.sendUserMessage(text);
   }
+  const sess = _active();
+  if (!sess) {
+    // Uninitialized — the old module's state machine only came alive after
+    // initSdkSession; a pre-init send just resolves (the SDK-unavailable guard
+    // above already covered the only documented throw).
+    return;
+  }
   return sess.sendUserMessage(text);
 }
 
@@ -1708,6 +1757,80 @@ export function setActiveSdkSession(cwd) {
   return true;
 }
 
+/** Activate a workspace by the same exact instance/cwd/project anchor used by SDK actions. */
+export function attachSdkSession(anchor) {
+  if (anchor && anchor.project && !anchor.instanceKey && !anchor.cwd) {
+    const matches = [..._sessions.values()].filter((s) => _matchesProject(s, anchor.project));
+    if (matches.length > 1) {
+      return {
+        ok: false,
+        reason: 'ambiguous',
+        candidates: matches.map((s) => ({ key: s.instanceKey /* aliases instanceKey for killPtyFor-shape parity */, instanceKey: s.instanceKey, cwd: s.cwd })),
+      };
+    }
+  }
+  const sess = _sessionForAnchor(anchor);
+  if (!sess) return { ok: false, reason: 'not-found' };
+  const switched = sess.key !== _activeKey;
+  _activeKey = sess.key;
+  // `key` aliases instanceKey for killPtyFor-shape parity (NOT the registry cwd key).
+  return { ok: true, key: sess.instanceKey, instanceKey: sess.instanceKey, cwd: sess.cwd, switched };
+}
+
+/**
+ * Close exactly one registered SDK workspace. A name-only anchor refuses
+ * same-basename ambiguity; an exact instance key never falls back to a name.
+ */
+export function closeSdkSession(anchor = {}) {
+  const instanceKey = typeof anchor.instanceKey === 'string' ? anchor.instanceKey : '';
+  let sess = null;
+  if (instanceKey) {
+    sess = _sessionForAnchor({ instanceKey });
+    if (!sess) return { ok: false, reason: 'not-found' };
+  } else if (anchor.cwd) {
+    sess = _sessionForAnchor({ cwd: anchor.cwd });
+  } else if (anchor.project) {
+    const matches = [..._sessions.values()].filter((s) => _matchesProject(s, anchor.project));
+    if (matches.length > 1) {
+      return {
+        ok: false,
+        reason: 'ambiguous',
+        candidates: matches.map((s) => ({ key: s.instanceKey /* aliases instanceKey for killPtyFor-shape parity */, instanceKey: s.instanceKey, cwd: s.cwd })),
+      };
+    }
+    sess = matches[0] || null;
+  }
+  if (!sess) return { ok: false, reason: 'not-found' };
+
+  const killedActive = sess.key === _activeKey;
+  const result = {
+    ok: true,
+    // `key` aliases instanceKey here (killPtyFor-shape parity: resume.js matches
+    // `p.key === killResult.reattachedTo`). It is NOT the registry's cwd key —
+    // the registry key is `sess.key`, a different namespace. Do not conflate.
+    key: sess.instanceKey,
+    instanceKey: sess.instanceKey,
+    cwd: sess.cwd,
+    killedActive,
+    reattachedTo: null,
+  };
+  // Remove the registry identity BEFORE user-callback-facing teardown frames. A
+  // close/relaunch triggered by one of those frames must register a fresh session,
+  // never be deleted by the tail of the older close operation.
+  _sessions.delete(sess.key);
+  if (killedActive) {
+    const survivor = _sessions.values().next().value || null;
+    _activeKey = survivor ? survivor.key : null;
+    result.reattachedTo = survivor ? survivor.instanceKey : null;
+  }
+  try {
+    sess.close();
+  } catch (err) {
+    reportSwallowed('sdk-manager.close', err);
+  }
+  return result;
+}
+
 /** The active session's cwd (header/switch addressing). '' when none. */
 export function getActiveSdkCwd() {
   const sess = _active();

package/server/lib/sdk-session-index.js

@@ -0,0 +1,25 @@
+// Synchronous read-only projection of the SDK session registry. Generic view
+// routing must not import sdk-manager (and eagerly load the Agent SDK) in PTY mode.
+import { reportSwallowed } from '@ccv/core/error-report';
+
+let _listSessions = null;
+
+export function registerSdkSessionLister(lister) {
+  _listSessions = typeof lister === 'function' ? lister : null;
+}
+
+export function listSdkSessionInstances() {
+  if (!_listSessions) return [];
+  try {
+    const rows = _listSessions();
+    return Array.isArray(rows) ? rows : [];
+  } catch (err) {
+    reportSwallowed('sdk-session-index.list', err);
+    return [];
+  }
+}
+
+export function findSdkSessionByInstance(instanceKey) {
+  if (typeof instanceKey !== 'string' || !/^ccv-[0-9a-f]+$/.test(instanceKey)) return null;
+  return listSdkSessionInstances().find((s) => s && s.instanceKey === instanceKey) || null;
+}

package/server/lib/task-state.js

@@ -1,26 +1,56 @@
 /**
  * task-state.js — in-memory reducer for the Claude Code task checklist.
  *
- * Maintains the single shared checklist of the session this cc-viewer process
- * hosts (fed by task-bridge.js via POST /api/task-event → deps.onTaskEvent).
- * The checklist is deliberately ONE map, not per-session: the main agent and
- * its teammates share the same task list in Claude Code, and each cc-viewer
- * server process only receives hooks from its own claude child tree
- * (CCVIEWER_PORT is injected per child). Cross-session leftovers are cleared
- * by resetTasks() on session boundaries (startup/clear from the MAIN agent —
- * see server.js onTaskSessionBoundary, which skips subagent events via
- * agentId).
+ * Per-workspace (2026-10): the checklist is bucketed by producer scope
+ * ('' = the bound project — the legacy singleton bucket; a parallel workspace
+ * gets its own bucket) so two concurrent claudes' task lists never clobber
+ * each other over SSE. Within a bucket the original single-map semantics are
+ * preserved: the main agent and its teammates share one list, cleared at
+ * session boundaries.
+ *
+ * The bucket KEY is computed by the caller (server.js's hook-payload scope
+ * resolver) — this module stays import-free (L1-lib, boundary gate) and never
+ * sees pty-manager. Callers that pass no bucket get the legacy '' bucket, so
+ * the single-workspace behavior is byte-identical.
  *
  * L1-lib: pure module, Node builtins only, no imports.
  */
 
-/** @type {string|null} last seen main session id (SSE tagging only) */
-let _sessionId = null;
-/** @type {Map<string, object>} insertion order = stable display order */
-const _tasks = new Map();
+/** @type {Map<string, {sessionId: string|null, tasks: Map<string, object>, lastUsedAt: number}>} */
+const _buckets = new Map();
+const _BUCKET_CAP = 16;
 
 const VALID_STATUSES = new Set(['pending', 'in_progress', 'completed', 'deleted']);
 
+function _normKey(bucket) {
+  return (typeof bucket === 'string' && bucket) ? bucket : '';
+}
+
+/** Get (or create) one scope's bucket. LRU-capped; the '' bucket is never
+ *  evicted (it is the legacy singleton view). */
+function _bucketFor(bucket) {
+  const k = _normKey(bucket);
+  let b = _buckets.get(k);
+  if (b) {
+    _buckets.delete(k);
+    _buckets.set(k, b);
+    return b;
+  }
+  b = { sessionId: null, tasks: new Map(), lastUsedAt: Date.now() };
+  _buckets.set(k, b);
+  while (_buckets.size > _BUCKET_CAP) {
+    let evicted = false;
+    for (const [bk] of _buckets) {
+      if (bk === '') continue; // never evict the bound bucket
+      _buckets.delete(bk);
+      evicted = true;
+      break;
+    }
+    if (!evicted) break;
+  }
+  return b;
+}
+
 function _touch(task) {
   task.updatedAt = Date.now();
   return task;
@@ -30,26 +60,29 @@ function _touch(task) {
  * Apply one normalized task event (the camelCase envelope task-bridge.js
  * POSTs). Unknown/malformed payloads are ignored.
  * @param {object} payload
+ * @param {string} [bucket] - producer scope key ('' = bound, the legacy view)
  */
-export function applyTaskEvent(payload) {
+export function applyTaskEvent(payload, bucket = '') {
   if (!payload || typeof payload !== 'object') return;
+  const b = _bucketFor(bucket);
+  b.lastUsedAt = Date.now();
   const { hookEventName } = payload;
   // New-prompt reset. MUST stay above the taskId guard (this event has no
-  // task_id) and MUST NOT move _sessionId — a foreign/malformed prompt event
-  // must not change the shouldResetTasks comparison base. resetTasks() nulls
-  // the tag anyway, so the next TaskCreated re-tags the session.
+  // task_id) and MUST NOT move the sessionId tag — a foreign/malformed prompt
+  // event must not change the shouldResetTasks comparison base. resetTasks()
+  // nulls the tag anyway, so the next TaskCreated re-tags the session.
   if (hookEventName === 'UserPromptSubmit') {
-    if (shouldResetTasksOnPrompt(payload, _sessionId)) resetTasks();
+    if (shouldResetTasksOnPrompt(payload, b.sessionId)) resetTasks(bucket);
     return;
   }
   const taskId = payload.taskId != null ? String(payload.taskId) : null;
   // Validate BEFORE touching the session tag: a malformed/unknown event must
   // not move the shouldResetTasks comparison base.
   if (!taskId) return;
-  if (payload.sessionId && !payload.agentId) _sessionId = payload.sessionId;
+  if (payload.sessionId && !payload.agentId) b.sessionId = payload.sessionId;
 
   if (hookEventName === 'TaskCreated') {
-    const existing = _tasks.get(taskId);
+    const existing = b.tasks.get(taskId);
     if (existing) {
       // Idempotent re-fire: keep the current status, refresh the text fields
       // and the teammate attribution (same field set as TaskCompleted).
@@ -59,7 +92,7 @@ export function applyTaskEvent(payload) {
       _touch(existing);
       return;
     }
-    _tasks.set(taskId, _touch({
+    b.tasks.set(taskId, _touch({
       taskId,
       subject: payload.taskSubject ?? null,
       description: payload.taskDescription ?? null,
@@ -74,8 +107,8 @@ export function applyTaskEvent(payload) {
   }
 
   if (hookEventName === 'TaskCompleted') {
-    const existing = _tasks.get(taskId) || _stub(taskId, payload);
-    if (!_tasks.has(taskId)) _tasks.set(taskId, existing);
+    const existing = b.tasks.get(taskId) || _stub(taskId, payload);
+    if (!b.tasks.has(taskId)) b.tasks.set(taskId, existing);
     existing.status = 'completed';
     if (payload.taskSubject != null) existing.subject = payload.taskSubject;
     if (payload.taskDescription != null) existing.description = payload.taskDescription;
@@ -87,11 +120,11 @@ export function applyTaskEvent(payload) {
   if (hookEventName === 'PostToolUse' && payload.toolName === 'TaskUpdate') {
     const status = VALID_STATUSES.has(payload.status) ? payload.status : null;
     if (status === 'deleted') {
-      _tasks.delete(taskId);
+      b.tasks.delete(taskId);
       return;
     }
-    const existing = _tasks.get(taskId) || _stub(taskId, payload);
-    if (!_tasks.has(taskId)) _tasks.set(taskId, existing);
+    const existing = b.tasks.get(taskId) || _stub(taskId, payload);
+    if (!b.tasks.has(taskId)) b.tasks.set(taskId, existing);
     // Patch only the fields present in the event; a TaskUpdate may carry any
     // subset (status flips, renames, owner claims). Re-opening a completed
     // task (completed → in_progress → pending) is valid and passed through.
@@ -124,10 +157,16 @@ function _stub(taskId, payload) {
   });
 }
 
-/** Clear the whole checklist (session boundary: startup/clear by main agent). */
-export function resetTasks() {
-  _tasks.clear();
-  _sessionId = null;
+/** Clear ONE bucket's checklist (session boundary: startup/clear by main agent). */
+export function resetTasks(bucket = '') {
+  const b = _bucketFor(bucket);
+  b.tasks.clear();
+  b.sessionId = null;
+}
+
+/** Tear down every bucket (server stop/start cycles). */
+export function resetAllTasks() {
+  _buckets.clear();
 }
 
 /**
@@ -171,12 +210,13 @@ export function shouldResetTasksOnPrompt(payload, currentSessionId) {
   return true;
 }
 
-/** Full-snapshot view for SSE broadcast; insertion order preserved. */
-export function getTaskSnapshot() {
-  return { sessionId: _sessionId, tasks: [..._tasks.values()] };
+/** Full-snapshot view of ONE bucket for SSE broadcast; insertion order preserved. */
+export function getTaskSnapshot(bucket = '') {
+  const b = _bucketFor(bucket);
+  return { sessionId: b.sessionId, tasks: [...b.tasks.values()] };
 }
 
 /** Test hook: restore pristine module state. */
 export function __resetForTests() {
-  resetTasks();
+  resetAllTasks();
 }

package/server/lib/turn-end-bridge.js

@@ -60,16 +60,21 @@ try {
 } catch { /* stdin may not be piped — fine, still notify */ }
 let sessionId = null;
 let transcriptPath = null;
+let cwd = null;
 try {
   const parsed = JSON.parse(stdinData);
   sessionId = parsed?.session_id || null;
   // transcript_path lets the DingTalk bridge read the final assistant turn straight from
   // Claude's own JSONL (the clean source, free of ANSI noise / the log-dedup bug).
   transcriptPath = parsed?.transcript_path || null;
+  // Per-workspace routing (2026-10): the Stop-hook stdin carries the session cwd —
+  // the server prefers sessionId→PTY resolution, with this cwd as the fallback
+  // scope hint (same precedence the task bridge already uses).
+  cwd = parsed?.cwd || null;
 } catch { /* fine */ }
 
 const internalToken = process.env.CCVIEWER_INTERNAL_TOKEN || '';
-const body = JSON.stringify({ sessionId, transcriptPath, ts: Date.now() });
+const body = JSON.stringify({ sessionId, transcriptPath, cwd, ts: Date.now() });
 const reqOpts = {
   hostname: '127.0.0.1',
   port: parseInt(port, 10),

package/server/lib/v2/live-feed.js

@@ -27,6 +27,7 @@ import { join } from 'node:path';
 import { reportSwallowed } from '@ccv/core/error-report';
 import { createIncrementalReconstructor } from '@ccv/core/delta-reconstructor';
 import { processWatchedEntry, sendEventToClients, sendEventRawToClients } from '../log-watcher.js';
+import { filterClientsByInstance } from './view-router.js';
 import { SessionSynthesizer } from './adapter.js';
 import { isDiscardableSession } from './session-select.js';
 import { isForeignLiveOwned } from './session-owner.js';
@@ -214,14 +215,14 @@ export class V2LiveFeed {
    * Backward compatible: a client with NO `_ccvViewInstance` stamp (the default / legacy /
    * single-instance view) sees every session regardless of `sessionInstance`; a session with
    * no stamped instance (legacy/external) is likewise visible to all.
+   *
+   * The project half keeps going through `_clientsFor()` (the server's filter
+   * closure — not necessarily the pure predicate); only the instance narrowing
+   * is delegated to the shared rule (view-router.filterClientsByInstance) so it
+   * can never drift from the server-side scoped broadcasts.
    */
   _clientsForInstance(sessionInstance) {
-    const base = this._clientsFor();
-    if (!sessionInstance) return base; // session carries no instance → visible to all viewers
-    let anyInstanceViewer = false;
-    for (const c of base) { if (c && c._ccvViewInstance) { anyInstanceViewer = true; break; } }
-    if (!anyInstanceViewer) return base; // nobody is instance-scoped → keep legacy broadcast
-    return base.filter((c) => !c || !c._ccvViewInstance || c._ccvViewInstance === sessionInstance);
+    return filterClientsByInstance(this._clientsFor(), sessionInstance || null);
   }
 
   /** Begin (or switch to) live-following a project's sessions/ root. */