claude-code-session-manager 0.122.0 → 0.123.0

package/src/main/pty.cjs

@@ -111,44 +111,6 @@ class PtyManager {
     this.outBuffers = new Map();
     this.flushTimers = new Map(); // tabId -> Timeout
     this.window = null;
-    this.outputListeners = new Map(); // tabId -> Set<{onData,onExit}>
-  }
-
-  /**
-   * Observe a tab's coalesced output (the same string the renderer gets) and
-   * its exit from the main process. Returns an unsubscribe function.
-   * @param {string} tabId
-   * @param {(tabId: string, chunk: string) => void} onData
-   * @param {(tabId: string, info: {exitCode: number, signal?: number}) => void} [onExit]
-   */
-  addOutputListener(tabId, onData, onExit) {
-    const entry = { onData, onExit };
-    let set = this.outputListeners.get(tabId);
-    if (!set) {
-      set = new Set();
-      this.outputListeners.set(tabId, set);
-    }
-    set.add(entry);
-    return () => {
-      const cur = this.outputListeners.get(tabId);
-      if (!cur) return;
-      cur.delete(entry);
-      if (cur.size === 0) this.outputListeners.delete(tabId);
-    };
-  }
-
-  /** Fire every onExit listener for `tabId` once (errors isolated), then drop them. */
-  #notifyExit(tabId, info) {
-    const set = this.outputListeners.get(tabId);
-    this.outputListeners.delete(tabId);
-    if (!set) return;
-    for (const l of [...set]) {
-      try {
-        l.onExit?.(tabId, info);
-      } catch (err) {
-        console.warn('[pty] output listener onExit threw', err);
-      }
-    }
   }
 
   /** Send any pending buffered output for `tabId` now, and clear its timer. */
@@ -162,16 +124,6 @@ class PtyManager {
     if (pending) {
       this.outBuffers.delete(tabId);
       sendIfAlive(this.window, `pty:data:${tabId}`, pending);
-      const set = this.outputListeners.get(tabId);
-      if (set) {
-        for (const l of [...set]) {
-          try {
-            l.onData?.(tabId, pending);
-          } catch (err) {
-            console.warn('[pty] output listener onData threw', err);
-          }
-        }
-      }
     }
   }
 
@@ -376,7 +328,6 @@ class PtyManager {
         this.sessions.delete(tabId);
         this.buffers.delete(tabId);
         this.#dropOutput(tabId);
-        this.#notifyExit(tabId, { exitCode, signal });
         return;
       }
       // Flush any still-buffered output BEFORE the exit event so the renderer
@@ -398,7 +349,6 @@ class PtyManager {
         });
       }
       sendIfAlive(this.window, `pty:exit:${tabId}`, { exitCode, signal });
-      this.#notifyExit(tabId, { exitCode, signal });
       this.sessions.delete(tabId);
       this.buffers.delete(tabId);
     });
@@ -461,9 +411,6 @@ class PtyManager {
       this.sessions.delete(tabId);
       this.buffers.delete(tabId);
       this.#dropOutput(tabId);
-      // Listeners learn the tab is gone now; the suppressed exit event that
-      // follows finds none left, so each fires exactly once.
-      this.#notifyExit(tabId, { exitCode: 0, signal: undefined });
     }
   }
 

package/src/main/runVerify.cjs

@@ -21,7 +21,8 @@
  *
  * Downgrade policy:
  *   clean           → null        (caller stamps 'completed')
- *   halt            → 'pending'   (re-fires automatically next slot)
+ *   halt            → 'pending'   (re-fires automatically next slot; only for
+ *                                  a run that printed no SCHEDULER_VERDICT line)
  *   deps_unmet      → 'pending'   (re-fires when deps clear)
  *   transcript_errors → historical rows only; no longer emitted
  *   verify_unavailable → 'needs_review' (unreadable log / verifier threw)
@@ -297,6 +298,30 @@ function scanSentinel(resultEvent, events) {
   return null;
 }
 
+/**
+ * First line that starts at column 0 with the exact uppercase halt marker
+ * (`HALT:`) outside a fenced block, else null. Line-anchored and fence-aware
+ * because reports quote the marker in prose and paste tool output in fences,
+ * and PRD_AUTHORING.md §4/§9/§10 tell scripts to print it on failure — neither
+ * is the executor's own stop signal.
+ * @param {unknown} text
+ * @returns {string | null}
+ */
+function scanHaltLine(text) {
+  if (typeof text !== 'string') return null;
+  let inFence = false;
+  for (const raw of text.split('\n')) {
+    const line = raw.replace(/\r$/, '').trimEnd();
+    const t = line.trimStart();
+    if (t.startsWith('```') || t.startsWith('~~~')) {
+      inFence = !inFence;
+      continue;
+    }
+    if (!inFence && line.startsWith('HALT:')) return line;
+  }
+  return null;
+}
+
 /**
  * One-line reason after `SCHEDULER_VERDICT: FAIL` (same two-source scan order
  * as scanSentinel). Trimmed, capped at 300 chars; '' when absent.
@@ -742,13 +767,17 @@ async function verifyRun({
       else if (commitEvidence) commitEvidenceSource = 'transcript';
     }
 
-    // ── 3. HALT detection ─────────────────────────────────────────────────
-    // Primary: check the final `{"type":"result"}` event's `result` text.
-    if (resultEvent) {
-      const rt = resultEvent.resultText;
-      if (/\bHALT:/i.test(rt) || /^HALT\b/m.test(rt)) {
-        const firstLine = rt.split('\n')[0].slice(0, 200);
-        let reason = `Agent HALTed: ${firstLine}`;
+    // ── 3. HALT detection (fallback only) ─────────────────────────────────
+    // The SCHEDULER_VERDICT line is the executor's final say (FINISH_PROTOCOL
+    // VERDICT LINE step); the halt check is a fallback for runs that printed
+    // none. Incident: Rabbits-Game 163-attack-scorecard, 2026-10-24 — a PASS
+    // report quoting the marker in backticks was re-queued as a halt.
+    const sentinel = scanSentinel(resultEvent, events);
+    if (resultEvent && sentinel === null) {
+      const haltLine = scanHaltLine(resultEvent.resultText);
+      if (haltLine) {
+        const rt = resultEvent.resultText;
+        let reason = `Agent HALTed: ${haltLine.slice(0, 200)}`;
         // Embed machine-parseable floor date if present in HALT message.
         const dateMatch = rt.match(/~?(\d{4}-\d{2}-\d{2})/);
         if (dateMatch) reason += ` (eligible from: ${dateMatch[1]})`;
@@ -773,9 +802,6 @@ async function verifyRun({
       }
     }
 
-    // Scan for the SCHEDULER_VERDICT sentinel emitted by the finish protocol.
-    const sentinel = scanSentinel(resultEvent, events);
-
     // An explicit executor FAIL is always blocking — outranks every other
     // verdict and every override below (early return). Transcript issues are
     // kept as annotations so nothing is lost.
@@ -1022,6 +1048,7 @@ module.exports = {
   checkDeps,
   parseLog,
   scanSentinel,
+  scanHaltLine,
   scanSentinelReason,
   scanHumanQuestion,
   scanForeignWipPathsClaim,

package/src/main/scheduler/prdParser.cjs

@@ -19,6 +19,7 @@ const os = require('node:os');
 const path = require('node:path');
 const { splitFrontmatter } = require('../lib/prd/prdFrontmatter.cjs');
 const { deriveEpicIdFromPrdPath } = require('../lib/prd/prdLocations.cjs');
+const { parseFilesSection } = require('../lib/prd/prdGateFiles.cjs');
 const { reportDanglingAgentTypeOnce } = require('../lib/prd/prdAgentType.cjs');
 
 /**
@@ -100,6 +101,8 @@ async function parsePrdRaw(filePath) {
     // queue row is completed (a slug with no row is treated as already
     // done/archived, matching retireCompletedSlugs semantics).
     dependsOn: parseDependsOn(fm.dependsOn),
+    // Declared touch-list from the body's `# Files` section ([] when absent).
+    files: parseFilesSection(body),
     // Provenance stamp (PRD-authoring lockdown): set only by prdCreate.cjs's
     // buildPrdBody (create) or the update-prd route's legacy-adopt patch
     // (migration/manual adopt). A PRD discovered on disk with no value here

package/src/main/scheduler/prdPaths.cjs

@@ -16,6 +16,7 @@ const { DEFAULT_PROJECT_CWD } = require('../lib/scheduler/schedulerBatch.cjs');
 const { resolvePrdsDirs, resolveArchivedPrdsDirs, resolvePrdWriteDir, listEpicPrdDirs, resolveEpicPrdWriteDir, isSafeEpicId, listArchivedPrdDirs, ancestorEpicPrdDirs, ancestorEpicArchivedPrdDirs } = require('../lib/prd/prdLocations.cjs');
 const { migratePrds, consolidateFlatPrds, legacyAdoptExistingPrds } = require('../lib/prd/prdMigration.cjs');
 const { opsPath } = require('../lib/opsOwnership.cjs');
+const { bareSlug, resolveDepSlug } = require('../lib/prd/depSlugResolve.cjs');
 const { allProjectCwds, projectRootOf } = require('../lib/activeSessions.cjs');
 
 /**
@@ -268,6 +269,50 @@ async function safeSlugPath(slug) {
   return module.exports.safeSlugPathIn(dir, slug);
 }
 
+/**
+ * Resolve a BARE slug (no `NN-` prefix) to the unique NN-prefixed PRD file —
+ * for a caller whose create response was lost and never learned the NN.
+ * Scans the live PRD dirs, the archive dirs, and one level of
+ * `prds-archived/<ts>/`, matching with depSlugResolve's rule. `cwd` narrows to
+ * one project; omitted, it searches every candidate dir. Returns
+ * `{ ok: true, path, dir }`, `{ ok: false, reason: 'not-found' }`, or
+ * `{ ok: false, reason: 'ambiguous', files, error }` (never guesses).
+ */
+async function resolveBareSlugFile(slug, cwd) {
+  if (typeof slug !== 'string' || !slug || bareSlug(slug) !== slug) return { ok: false, reason: 'not-found' };
+  const live = cwd ? [module.exports.prdDirForCwd(cwd), ...listEpicPrdDirs(cwd)] : module.exports.candidatePrdsDirs();
+  const archived = cwd ? listArchivedPrdDirs(cwd) : module.exports.candidateArchivedPrdsDirs();
+  const dirs = [...live];
+  for (const a of archived) {
+    dirs.push(a);
+    const subs = await fsp.readdir(a, { withFileTypes: true }).catch(() => []);
+    for (const ent of subs) if (ent.isDirectory()) dirs.push(path.join(a, ent.name));
+  }
+  const found = []; // { slug, dir, file }
+  const seen = new Set();
+  for (const dir of dirs) {
+    const names = await fsp.readdir(dir).catch(() => []);
+    for (const n of names) {
+      if (!n.endsWith('.md')) continue;
+      const file = path.join(dir, n);
+      if (seen.has(file)) continue;
+      seen.add(file);
+      found.push({ slug: n.slice(0, -3), dir, file });
+    }
+  }
+  const matched = new Set(resolveDepSlug(slug, found.map((f) => f.slug)));
+  const hits = found.filter((f) => matched.has(f.slug));
+  if (hits.length === 0) return { ok: false, reason: 'not-found' };
+  if (hits.length > 1) {
+    const files = hits.map((h) => h.file);
+    return { ok: false, reason: 'ambiguous', files, error: `ambiguous slug "${slug}": matches ${files.join(' and ')} — use the full NN-prefixed slug` };
+  }
+  const only = hits[0];
+  const safe = module.exports.safeSlugPathIn(only.dir, only.slug);
+  if (!safe) return { ok: false, reason: 'not-found' };
+  return { ok: true, path: safe, dir: only.dir };
+}
+
 /**
  * The two distinct failure modes safeSlugPath collapses into one nullable
  * return (the defect this fixes — see the PRD that added this helper's
@@ -291,10 +336,10 @@ async function resolveSlugOrReason(slug, cwd) {
         return { ok: true, path: p };
       } catch { /* not in this dir — try the next candidate */ }
     }
-    return { ok: false, reason: 'not-found' };
+    return module.exports.resolveBareSlugFile(slug, cwd);
   }
   const dir = await module.exports.findPrdDir(slug);
-  if (!dir) return { ok: false, reason: 'not-found' };
+  if (!dir) return module.exports.resolveBareSlugFile(slug, cwd);
   const p = module.exports.safeSlugPathIn(dir, slug);
   if (!p) return { ok: false, reason: 'not-found' };
   return { ok: true, path: p };
@@ -522,6 +567,7 @@ module.exports = {
   safeSlugPathIn,
   realPrdsDir,
   safeSlugPath,
+  resolveBareSlugFile,
   resolveSlugOrReason,
   jobMatchesSlugAndCwd,
   unknownSlugMessage,