cc-viewer 1.9.3 → 1.9.5

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. */

package/server/lib/v2/view-router.js

@@ -38,6 +38,54 @@ export function filterClientsByViewProject(clientList, project, boundProject) {
   return clientList.filter((c) => c && ((c._ccvViewProject || bound) === project));
 }
 
+/**
+ * Instance-narrowed variant of filterClientsByViewProject (multi-instance,
+ * 2026-10-06 rule lifted from live-feed._clientsForInstance): a frame stamped
+ * with an instance is visible to every viewer of the project EXCEPT clients
+ * stamped with a DIFFERENT instance. Unset on either side ⇒ visible (a client
+ * with no `_ccvViewInstance` stamp sees every instance; a frame with no
+ * instance reaches all of the project's viewers).
+ *
+ * @param {Array} clientList - SSE response objects.
+ * @param {string} project - the frame's project ('' ⇒ bound).
+ * @param {string|null} instance - the frame's instance, when known.
+ * @param {string} boundProject - the server's bound project.
+ * @returns {Array} the subset of clients that should receive the frame.
+ */
+export function filterClientsByScope(clientList, project, instance, boundProject) {
+  // Composition over duplication: project half, then the shared instance rule —
+  // the two can never drift apart.
+  return filterClientsByInstance(filterClientsByViewProject(clientList, project, boundProject), instance);
+}
+
+/**
+ * Instance-only narrowing over an ALREADY project-filtered client list — the
+ * live-feed composes its own project filter (`opts.clientFilter`, which may be
+ * a server-supplied closure rather than the pure predicate) with this rule.
+ * Same semantics as the instance half of filterClientsByScope: unset on either
+ * side ⇒ visible; nobody instance-stamped ⇒ the input array (same reference).
+ *
+ * @param {Array} clientList - already project-filtered SSE responses.
+ * @param {string|null} instance - the frame's instance, when known.
+ * @returns {Array}
+ */
+export function filterClientsByInstance(clientList, instance) {
+  if (!instance) return clientList;
+  // Exclude ONLY clients explicitly stamped with a DIFFERENT instance. An
+  // UNSTAMPED (project-level) viewer of the same project must also receive the
+  // frame: if an earlier `active:true` frame reached it while no instance viewer
+  // was online, the matching `active:false` must reach it too or its spinner
+  // never clears (the clear would be narrowed away the moment a parallel
+  // instance chip connects). Keeping active/clear on the SAME recipient set
+  // avoids that split delivery.
+  // Fast path: nobody is excluded (no differently-stamped client) ⇒ return the
+  // SAME array reference (no filter alloc), preserving legacy identity.
+  let anyExcluded = false;
+  for (const c of clientList) { if (c && c._ccvViewInstance && c._ccvViewInstance !== instance) { anyExcluded = true; break; } }
+  if (!anyExcluded) return clientList;
+  return clientList.filter((c) => !c || !c._ccvViewInstance || c._ccvViewInstance === instance);
+}
+
 /**
  * Extract the owning project dir name from a session dir path of the form
  * `<LOG_DIR>/<projectSan>/sessions/<dirName>`. Returns the on-disk `<projectSan>`

package/server/lib/workflow-watcher.js

@@ -39,7 +39,7 @@ function _signature(p) {
 function _isJournalFile(f) { return f.startsWith('wf_') && f.endsWith('.json'); }
 
 function _scan(state) {
-  const { workflowsDir, sessionId, project, clients, seen } = state;
+  const { workflowsDir, sessionId, project, clients, clientFilter, seen } = state;
   let files;
   try { files = readdirSync(workflowsDir); } catch { return; }
   for (const f of files) {
@@ -51,7 +51,11 @@ function _scan(state) {
     seen.set(f, sig);
     const data = readNormalizedJournal(p);
     if (!data) continue;
-    sendEventToClients(clients, 'workflow_update', {
+    // Per-workspace: a journal belongs to one project; when a client filter is
+    // installed the frame reaches only that project's viewers (legacy default:
+    // broadcast to all).
+    const target = typeof clientFilter === 'function' ? clientFilter(clients, project) : clients;
+    sendEventToClients(target, 'workflow_update', {
       sessionId,
       project: project || null,
       runId: data.runId,
@@ -99,7 +103,7 @@ function _baseline(state) {
  * 武装对某 workflows 目录的监视。同目录重复调用只刷新 clients 引用。
  * @param {{ workflowsDir: string, sessionId?: string, project?: string, clients: Array }} opts
  */
-export function armWorkflowWatch({ workflowsDir, sessionId, project, clients } = {}) {
+export function armWorkflowWatch({ workflowsDir, sessionId, project, clients, clientFilter } = {}) {
   if (!workflowsDir || !Array.isArray(clients)) return null;
 
   const existing = _armed.get(workflowsDir);
@@ -107,6 +111,7 @@ export function armWorkflowWatch({ workflowsDir, sessionId, project, clients } =
 
   const state = {
     workflowsDir, sessionId, project, clients,
+    clientFilter: typeof clientFilter === 'function' ? clientFilter : null,
     seen: new Map(), watcher: null,
     debounceTimer: null, safetyTimer: null, presenceTimer: null,
   };
@@ -177,13 +182,14 @@ function _authoritativeJournalExists(runDir, runId) {
 }
 
 function _scanLive(state) {
-  const { runDir, runId, sessionId, project, clients } = state;
+  const { runDir, runId, sessionId, project, clients, clientFilter } = state;
   const data = deriveLiveJournal(runDir, runId);
   if (data) {
     const sig = _liveSignature(data);
     if (sig !== state.lastSig) {  // 有实质变化才广播
       state.lastSig = sig;
-      sendEventToClients(clients, 'workflow_update', {
+      const target = typeof clientFilter === 'function' ? clientFilter(clients, project) : clients;
+      sendEventToClients(target, 'workflow_update', {
         sessionId,
         project: project || null,
         runId: data.runId,
@@ -228,7 +234,7 @@ function _startLiveWatch(state) {
  * 同 runDir 重复调用只刷新 clients。arm 时立即广播一次当前推导态（闭合 REST/arm 竞态）。
  * @param {{ runDir: string, runId: string, sessionId?: string, project?: string, clients: Array }} opts
  */
-export function armWorkflowLiveWatch({ runDir, runId, sessionId, project, clients } = {}) {
+export function armWorkflowLiveWatch({ runDir, runId, sessionId, project, clients, clientFilter } = {}) {
   if (!runDir || !runId || !Array.isArray(clients)) return null;
 
   const existing = _armedLive.get(runDir);
@@ -236,6 +242,7 @@ export function armWorkflowLiveWatch({ runDir, runId, sessionId, project, client
 
   const state = {
     runDir, runId, sessionId, project, clients,
+    clientFilter: typeof clientFilter === 'function' ? clientFilter : null,
     lastSig: null, watcher: null,
     debounceTimer: null, safetyTimer: null, presenceTimer: null,
   };