claude-code-session-manager 0.39.1 → 0.39.2

package/src/main/chatRunner.cjs

@@ -36,7 +36,12 @@
  *   chat:run:complete   { tabId, sessionId, finalMessage }
  *   chat:run:needs-input { tabId, sessionId, questions, raw }
  *   chat:run:error      { tabId, sessionId, message }
+ *                         — the kill-ceiling variant additionally carries
+ *                           { elapsedMs, ceilingMs, lastToolUses } so a resumed
+ *                           turn can tell whether an external side effect
+ *                           landed before verifying/retrying
  *   chat:run:notice     { tabId, sessionId, message }        — informational, not terminal
+ *                         (also fires at 80% of the kill ceiling as a wrap-up nudge)
  *   chat:context-usage  { tabId, sessionId, usedTokens, totalTokens, usedPct, categories }
  *                                                             — result of a silent `/context` probe
  */
@@ -239,6 +244,34 @@ function hasMcpConsentDenial(text) {
   return MCP_CONSENT_DENIAL_MARKERS.some((marker) => lower.includes(marker));
 }
 
+// Number of recent tool uses kept for the kill-message context (Ask 3).
+const RECENT_TOOL_USE_LIMIT = 3;
+const TOOL_USE_DETAIL_MAX_LEN = 60;
+
+// Renders a single classified tool_use (from classifyToolUse) plus a short
+// input-derived detail string into a human-readable descriptor, e.g.
+// "Bash(eas submit --platform ios …)". Pure formatting — no new stream
+// parsing; `detail` is lifted from the same already-parsed block.
+function renderToolUseDescriptor({ label, detail }) {
+  if (!detail) return label;
+  const truncated = detail.length > TOOL_USE_DETAIL_MAX_LEN
+    ? `${detail.slice(0, TOOL_USE_DETAIL_MAX_LEN)}…`
+    : detail;
+  return `${label}(${truncated})`;
+}
+
+// Pulls a short descriptive string out of a tool_use block's input, reusing
+// fields already present on the already-parsed block — not a new parser.
+function describeToolUseInput(block) {
+  const input = block?.input;
+  if (!input || typeof input !== 'object') return '';
+  if (typeof input.command === 'string') return input.command;
+  if (typeof input.description === 'string') return input.description;
+  if (typeof input.pattern === 'string') return input.pattern;
+  if (typeof input.file_path === 'string') return input.file_path;
+  return '';
+}
+
 // Instruction prepended to every prompt. Tells the agent how to signal that
 // it needs clarification vs. having completed the task.
 const STOP_SIGNAL_INSTRUCTION =
@@ -252,6 +285,17 @@ const STOP_SIGNAL_INSTRUCTION =
   `guess on what's genuinely blocked, but always answer what you can first. ` +
   `Otherwise complete the task and end with a concise summary of what you did.\n\n`;
 
+// ─── Hard wall-clock kill ceiling ────────────────────────────────────────
+// Defined here (ahead of CHAT_MODE_TRUTH_INSTRUCTION) so the prompt's stated
+// budget is always derived from this single constant — never a hand-written
+// duplicate that could drift from the real timer below.
+const KILL_CEILING_MS = 30 * 60 * 1000; // 30 minutes
+const KILL_CEILING_MIN = KILL_CEILING_MS / 60_000;
+// 80% warning point — gives the model a turn-visible nudge to wrap up before
+// the hard kill fires at 100%. Not configurable; see PRD out-of-scope note
+// re: making KILL_CEILING_MS itself configurable.
+const WARN_CEILING_MS = Math.floor(KILL_CEILING_MS * 0.8);
+
 // Instruction prepended to every prompt. Tells the agent the truth about this
 // execution mode: this Chat tab is a one-shot headless `claude -p` run — no
 // process survives after this turn ends, so background shells, scheduled
@@ -265,9 +309,12 @@ const CHAT_MODE_TRUTH_INSTRUCTION =
   `there is no later turn in which that could happen, so that promise would ` +
   `go unfulfilled and leave the user waiting with no explanation. If you need ` +
   `to poll something, do it synchronously within this turn with a bounded ` +
-  `timeout, then report the actual result. End this turn with either a real ` +
-  `result or an explicit statement that the user needs to reply for the work ` +
-  `to continue.\n\n`;
+  `timeout, then report the actual result. This turn is hard-killed after ` +
+  `${KILL_CEILING_MIN} minutes of wall-clock. Size every synchronous poll to ` +
+  `finish inside that budget; if the work cannot fit, do the part that fits, ` +
+  `report exactly what landed, and say what remains. End this turn with ` +
+  `either a real result or an explicit statement that the user needs to ` +
+  `reply for the work to continue.\n\n`;
 
 // ─── Serial run queue (v0.34) ───────────────────────────────────────────────
 // CONCURRENCY_CAP=2 (default) governs ALL runs — silent probes and manual
@@ -299,9 +346,6 @@ let activeCount = 0;
 let executor = executeRun;
 function __setExecutor(fn) { executor = fn || executeRun; }
 
-// ─── Hard wall-clock kill ceiling ────────────────────────────────────────
-const KILL_CEILING_MS = 30 * 60 * 1000; // 30 minutes
-
 // ─── Window reference (set by attachWindow) ────────────────────────────────
 
 let mainWindow = null;
@@ -378,6 +422,10 @@ function pump() {
  */
 function executeRun({ tabId, sessionId, prompt, cwd, resume, silent, onSilentResult, promptId }) {
   return new Promise((resolve) => {
+    const startedAt = Date.now();
+    // Last few tool_use blocks seen on the stream, oldest first — surfaced in
+    // the kill message (Ask 3) so a resumed turn knows what might have landed.
+    const recentToolUses = [];
     let settled = false;
     // Frees the lane exactly once: drops the cancel fn and resolves the promise
     // the pump is awaiting. Both exit and error paths funnel through here.
@@ -487,12 +535,40 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume, silent, onSilentRes
     // executor invocation returns — see comment above the inFlight Map decl.
     inFlight.set(tabId, { cancelFn, donePromise: null });
 
+    // 80%-of-ceiling warning — a turn-visible nudge to wrap up before the hard
+    // kill fires at 100%. Does not extend or otherwise affect the kill timer
+    // below; it is purely informational (Ask 2).
+    const warnTimer = setTimeout(() => {
+      if (silent) return; // silent probes are short-lived; nothing to warn
+      broadcast('chat:run:notice', {
+        tabId,
+        sessionId,
+        message:
+          `Heads up: this turn has been running for ${Math.round(WARN_CEILING_MS / 60_000)} ` +
+          `minutes and will be force-killed at the ${KILL_CEILING_MIN}-minute ceiling if it's ` +
+          `still going. Wrap up now — report exactly what has landed so far and what remains, ` +
+          `before the hard kill fires.`,
+      });
+    }, WARN_CEILING_MS);
+    if (warnTimer.unref) warnTimer.unref();
+
     // Hard wall-clock ceiling — SIGTERM + SIGKILL on expiry
     const killTimer = setTimeout(() => {
+      const elapsedMs = Date.now() - startedAt;
+      const lastToolUses = recentToolUses.slice();
+      const lastActionsText = lastToolUses.length > 0
+        ? lastToolUses.map(renderToolUseDescriptor).join(', ')
+        : 'none observed';
       emitTerminal('chat:run:error', {
         tabId,
         sessionId,
-        message: 'run exceeded 30-minute wall-clock ceiling',
+        elapsedMs,
+        ceilingMs: KILL_CEILING_MS,
+        lastToolUses,
+        message:
+          `Killed after ${Math.round(elapsedMs / 60_000)}m (ceiling ${KILL_CEILING_MIN}m). ` +
+          `Last actions: ${lastActionsText}. External side effects may have completed — verify ` +
+          `before retrying.`,
       });
       cancelFn();
     }, KILL_CEILING_MS);
@@ -520,6 +596,8 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume, silent, onSilentRes
             if (!silent) broadcast('chat:run:output', { tabId, delta: block.text });
           } else if (block.type === 'tool_use' && typeof block.name === 'string') {
             const classified = classifyToolUse(block);
+            recentToolUses.push({ ...classified, detail: describeToolUseInput(block) });
+            if (recentToolUses.length > RECENT_TOOL_USE_LIMIT) recentToolUses.shift();
             if (!silent) broadcast('chat:run:tool-use', { tabId, id: block.id, ...classified });
           }
         }
@@ -602,6 +680,7 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume, silent, onSilentRes
 
     child.on('error', (err) => {
       clearTimeout(killTimer);
+      clearTimeout(warnTimer);
       emitTerminal('chat:run:error', {
         tabId,
         sessionId,
@@ -618,6 +697,7 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume, silent, onSilentRes
     // terminalSent latch.
     child.on('close', (code, signal) => {
       clearTimeout(killTimer);
+      clearTimeout(warnTimer);
       // Flush any partial line that didn't end with \n
       if (lineBuffer.trim()) processLine(lineBuffer.trim());
 
@@ -759,6 +839,9 @@ module.exports = {
   probeContextUsage,
   STOP_SENTINEL,
   CHAT_MODE_TRUTH_INSTRUCTION,
+  KILL_CEILING_MS,
+  KILL_CEILING_MIN,
+  WARN_CEILING_MS,
   __setExecutor,
   enqueueExternalPrompt,
   registerAdminRoute,

package/src/main/config.cjs

@@ -143,6 +143,15 @@ function validateWrite(realAbs) {
       if (realAbs === feedbackSub || realAbs.startsWith(feedbackSub + path.sep)) {
         return;
       }
+      // PromptSession persistence (active-index.json + per-session archives,
+      // promptSessions.ts) and the scheduler's own read-modify-write of that
+      // same active index (promptSessionEvents.cjs, PRD 814) — narrowly
+      // scoped to session-manager-operations/prompt-sessions/, this repo's
+      // existing per-project artifact-store convention.
+      const promptSessionsSub = path.join(realRoot, 'session-manager-operations', 'prompt-sessions');
+      if (realAbs === promptSessionsSub || realAbs.startsWith(promptSessionsSub + path.sep)) {
+        return;
+      }
     }
   }
   throw new Error(`Write outside allowed write boundaries: ${realAbs}`);

package/src/main/ipcSchemas.cjs

@@ -278,7 +278,7 @@ const schedulerCreatePrd = z.object({
   sourceTabId: z.string().min(1).max(128).regex(NO_NEWLINE_RE, 'must not contain newlines').optional(),
   // User-selected Feature/Bug tag (PRD 774) carried from the originating
   // PromptTicket — deterministic, never LLM-classified.
-  tag: z.enum(['feature', 'bug']).optional(),
+  tag: z.enum(['feature', 'bug', 'discussion']).optional(),
 });
 
 // Bulk archive: slug list, capped to limit unbounded retag/archive payloads.

package/src/main/lib/__tests__/terminalRunOutcome.test.cjs

@@ -0,0 +1,118 @@
+/**
+ * terminalRunOutcome.test.cjs — unit tests for the history-independent
+ * terminal-run-outcome probe (PRD 812-689-fix-fix-distribute-adminserver-routes).
+ *
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/terminalRunOutcome.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const {
+  latestTerminalOutcomeForSlug,
+  MAX_DIRS_SCANNED,
+} = require('../terminalRunOutcome.cjs');
+
+function mkTmpRunsDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'terminal-run-outcome-'));
+}
+
+function writeRun(runsDir, runId, slug, meta, verdicts) {
+  const dir = path.join(runsDir, runId);
+  fs.mkdirSync(dir, { recursive: true });
+  if (meta !== undefined) {
+    fs.writeFileSync(path.join(dir, `${slug}.meta.json`), typeof meta === 'string' ? meta : JSON.stringify(meta));
+  }
+  if (verdicts !== undefined) {
+    fs.writeFileSync(path.join(dir, `${slug}.verdicts.json`), typeof verdicts === 'string' ? verdicts : JSON.stringify(verdicts));
+  }
+}
+
+test('returns completed for newest run with exitCode 0 + clean verdict', () => {
+  const runsDir = mkTmpRunsDir();
+  writeRun(runsDir, '2026-07-31T07-38-29-081Z', 'my-slug', { exitCode: 0, finishedAt: 1785483574748 }, { verdict: 'clean' });
+  const result = latestTerminalOutcomeForSlug('my-slug', { runsDir });
+  expect(result).toEqual({ status: 'completed', runId: '2026-07-31T07-38-29-081Z', finishedAt: new Date(1785483574748).toISOString() });
+});
+
+test('returns completed for pass_no_commit_already_shipped verdict', () => {
+  const runsDir = mkTmpRunsDir();
+  writeRun(runsDir, '2026-07-31T07-38-29-081Z', 'my-slug', { exitCode: 0, finishedAt: 1785483574749 }, { verdict: 'pass_no_commit_already_shipped' });
+  const result = latestTerminalOutcomeForSlug('my-slug', { runsDir });
+  expect(result).toEqual({ status: 'completed', runId: '2026-07-31T07-38-29-081Z', finishedAt: new Date(1785483574749).toISOString() });
+});
+
+test('returns failed for non-zero exitCode', () => {
+  const runsDir = mkTmpRunsDir();
+  writeRun(runsDir, '2026-07-31T07-38-29-081Z', 'my-slug', { exitCode: 1, finishedAt: 1785483574750 });
+  const result = latestTerminalOutcomeForSlug('my-slug', { runsDir });
+  expect(result).toEqual({ status: 'failed', runId: '2026-07-31T07-38-29-081Z', finishedAt: new Date(1785483574750).toISOString() });
+});
+
+test('returns failed for exitCode 0 with a non-completed-equivalent verdict', () => {
+  const runsDir = mkTmpRunsDir();
+  writeRun(runsDir, '2026-07-31T07-38-29-081Z', 'my-slug', { exitCode: 0, finishedAt: 1785483574751 }, { verdict: 'transcript_errors' });
+  const result = latestTerminalOutcomeForSlug('my-slug', { runsDir });
+  expect(result).toEqual({ status: 'failed', runId: '2026-07-31T07-38-29-081Z', finishedAt: new Date(1785483574751).toISOString() });
+});
+
+test('returns null when there is no run dir for the slug', () => {
+  const runsDir = mkTmpRunsDir();
+  writeRun(runsDir, '2026-07-31T07-38-29-081Z', 'other-slug', { exitCode: 0 }, { verdict: 'clean' });
+  expect(latestTerminalOutcomeForSlug('my-slug', { runsDir })).toBeNull();
+});
+
+test('returns null on malformed meta.json', () => {
+  const runsDir = mkTmpRunsDir();
+  writeRun(runsDir, '2026-07-31T07-38-29-081Z', 'my-slug', '{not json', { verdict: 'clean' });
+  expect(latestTerminalOutcomeForSlug('my-slug', { runsDir })).toBeNull();
+});
+
+test('returns null on malformed verdicts.json', () => {
+  const runsDir = mkTmpRunsDir();
+  writeRun(runsDir, '2026-07-31T07-38-29-081Z', 'my-slug', { exitCode: 0 }, '{not json');
+  expect(latestTerminalOutcomeForSlug('my-slug', { runsDir })).toBeNull();
+});
+
+test('returns null when runsDir does not exist', () => {
+  expect(latestTerminalOutcomeForSlug('my-slug', { runsDir: '/nonexistent/path/xyz' })).toBeNull();
+});
+
+test('picks the newest of several run dirs for the same slug', () => {
+  const runsDir = mkTmpRunsDir();
+  writeRun(runsDir, '2026-07-01T00-00-00-000Z', 'my-slug', { exitCode: 1, finishedAt: 10 });
+  writeRun(runsDir, '2026-07-31T07-38-29-081Z', 'my-slug', { exitCode: 0, finishedAt: 1785483574752 }, { verdict: 'clean' });
+  writeRun(runsDir, '2026-06-01T00-00-00-000Z', 'my-slug', { exitCode: 1, finishedAt: 5 });
+  const result = latestTerminalOutcomeForSlug('my-slug', { runsDir });
+  expect(result).toEqual({ status: 'completed', runId: '2026-07-31T07-38-29-081Z', finishedAt: new Date(1785483574752).toISOString() });
+});
+
+test('stats at most the newest few run dirs (bound enforced)', () => {
+  const runsDir = mkTmpRunsDir();
+  // Create many more matching run dirs than MAX_DIRS_SCANNED, all with a
+  // non-terminal-equivalent verdict so the loop never early-returns before
+  // exhausting the candidate slice — proves the bound is actually applied.
+  const total = MAX_DIRS_SCANNED + 10;
+  for (let i = 0; i < total; i++) {
+    const ts = `2026-07-${String(i + 1).padStart(2, '0')}T00-00-00-000Z`;
+    writeRun(runsDir, ts, 'my-slug', { exitCode: 0, finishedAt: i }, { verdict: 'transcript_errors' });
+  }
+
+  let readFileCalls = 0;
+  const fsImpl = {
+    readdirSync: (...a) => fs.readdirSync(...a),
+    existsSync: (...a) => fs.existsSync(...a),
+    readFileSync: (...a) => {
+      readFileCalls++;
+      return fs.readFileSync(...a);
+    },
+  };
+
+  latestTerminalOutcomeForSlug('my-slug', { runsDir, fsImpl });
+  // Each scanned dir reads meta.json, then (since exitCode===0) verdicts.json
+  // too, so at most MAX_DIRS_SCANNED * 2 readFileSync calls.
+  expect(readFileCalls).toBeLessThanOrEqual(MAX_DIRS_SCANNED * 2);
+});

package/src/main/lib/prdLocations.cjs

@@ -15,8 +15,9 @@
  */
 'use strict';
 
+const fs = require('node:fs');
 const path = require('node:path');
-const { activeProjectCwds } = require('../../../scripts/lib/activeSessions.cjs');
+const { activeProjectCwds, allProjectCwds } = require('../../../scripts/lib/activeSessions.cjs');
 
 const PRD_SUBPATH = ['session-manager-operations', 'scheduler', 'prds'];
 
@@ -34,13 +35,49 @@ function resolvePrdWriteDir(cwd) {
 
 /**
  * resolvePrdsDirs(maxAgeMin?, opts?) → string[]
- * One `<cwd>/session-manager-operations/scheduler/prds` dir per active
- * project cwd (activeProjectCwds' default window is 90 minutes). `opts` is
- * forwarded to activeProjectCwds (e.g. `projectsDir` override for tests).
+ *
+ * Every `<cwd>/session-manager-operations/scheduler/prds` dir that actually
+ * EXISTS on disk, across every project this machine has ever opened — plus
+ * the currently-active projects' dirs even if they haven't been created yet
+ * (write paths need a destination before the first PRD lands there).
+ *
+ * Deliberately NOT filtered by recency. This function answers "where do PRD
+ * source files live", and a project being quiet says nothing about whether it
+ * owns queued work. It used to return only activeProjectCwds' 90-minute
+ * window, which made a quiet project's PRDs unscannable — and reconcile()
+ * reads an unscannable PRD as a deleted one, silently dropping its queue row
+ * (2026-07-31: 142 PRDs across 6 quiet projects). Recency stays where it
+ * belongs: the feedback sweep, which genuinely only cares about live work.
+ *
+ * `maxAgeMin` is still honoured for the active-project half so existing
+ * callers and tests keep their semantics; `opts` is forwarded to the
+ * underlying scan (e.g. `projectsDir` override for tests).
  */
 function resolvePrdsDirs(maxAgeMin, opts) {
-  const cwds = activeProjectCwds(maxAgeMin, opts);
-  return cwds.map(resolvePrdWriteDir);
+  const dirs = [];
+  const seen = new Set();
+  const add = (dir) => {
+    if (seen.has(dir)) return;
+    seen.add(dir);
+    dirs.push(dir);
+  };
+
+  // Every historical project that has a PRD dir on disk — the set that
+  // matters for discovery, regardless of when it was last touched.
+  for (const cwd of allProjectCwds(opts)) {
+    let dir;
+    try { dir = resolvePrdWriteDir(cwd); } catch { continue; }
+    if (fs.existsSync(dir)) add(dir);
+  }
+
+  // Active projects are added unconditionally: a brand-new project has no
+  // prds/ dir yet, and callers that resolve a write destination must still
+  // find it. Scans over a non-existent dir are a harmless ENOENT no-op.
+  for (const cwd of activeProjectCwds(maxAgeMin, opts)) {
+    try { add(resolvePrdWriteDir(cwd)); } catch { /* unusable cwd */ }
+  }
+
+  return dirs;
 }
 
 module.exports = { resolvePrdWriteDir, resolvePrdsDirs, PRD_SUBPATH };

package/src/main/lib/prdMigration.cjs

@@ -18,6 +18,7 @@ const fsp = require('node:fs/promises');
 const path = require('node:path');
 const { splitFrontmatter } = require('./prdFrontmatter.cjs');
 const { resolvePrdWriteDir } = require('./prdLocations.cjs');
+const { expandHome } = require('./expandHome.cjs');
 
 /**
  * Move every `.md` file in legacyPrdsDir whose frontmatter `cwd` resolves to
@@ -55,13 +56,14 @@ async function migratePrds(legacyPrdsDir) {
     }
 
     const { fm } = splitFrontmatter(raw);
-    const cwd = fm.cwd && fm.cwd.trim();
-    if (!cwd) {
+    const rawCwd = fm.cwd && fm.cwd.trim();
+    if (!rawCwd) {
       unresolved.push({ file: name, reason: 'no cwd in frontmatter' });
       continue;
     }
+    const cwd = expandHome(rawCwd);
     if (!fs.existsSync(cwd)) {
-      unresolved.push({ file: name, reason: `cwd does not exist on disk: ${cwd}` });
+      unresolved.push({ file: name, reason: `cwd does not exist on disk: ${rawCwd}` });
       continue;
     }
 

package/src/main/lib/queueHistory.cjs

@@ -196,7 +196,7 @@ async function historyTerminalBySlug() {
       if (!line.trim()) continue;
       try {
         const j = JSON.parse(line);
-        if (j?.slug) map.set(j.slug, { status: j.status, finishedAt: j.finishedAt });
+        if (j?.slug) map.set(j.slug, { status: j.status, finishedAt: j.finishedAt, landedCommit: j.landedCommit ?? null });
       } catch {
         // corrupt/partial line — ignore
       }

package/src/main/lib/rcaFeedbackHook.cjs

@@ -57,6 +57,8 @@ const VERDICT_LABELS = {
   uncommitted_changes: 'uncommitted changes',
   no_verdict_sentinel: 'no commit or verdict sentinel',
   pass_no_commit: 'PASS sentinel but no commit landed',
+  pass_no_commit_already_shipped: 'PASS with no commit — deliverables already shipped',
+  pass_no_commit_prior_run_verified: 'PASS with no commit — prior run of this slug already landed the work',
 };
 
 function humanVerdict(verdict) {
@@ -66,6 +68,8 @@ function humanVerdict(verdict) {
 // ─── Failure-class matching (deterministic, no LLM) ─────────────────────────
 
 const FAILURE_CLASSES = {
+  ALREADY_SHIPPED: 'already-shipped',
+  SELF_QUEUE: 'self-queue',
   STUCK_LOOP: 'stuck-loop',
   POST_AC_OVERRUN: 'post-ac-overrun',
   NO_SENTINEL: 'no-sentinel',
@@ -75,6 +79,10 @@ const FAILURE_CLASSES = {
 };
 
 const PREVENTION_HINTS = {
+  [FAILURE_CLASSES.ALREADY_SHIPPED]:
+    "This run found its acceptance criteria already satisfied by a prior commit and correctly made no change, so no commit landed and the verifier returned `pass_no_commit`. This is a stale re-run, not an execution failure — the PRD's `.md` was never moved out of `session-manager-operations/scheduler/prds/` after the work shipped. Archive the PRD into `session-manager-operations/scheduler/prds-archived/` instead of re-queuing or re-running it.",
+  [FAILURE_CLASSES.SELF_QUEUE]:
+    "This run either invoked /develop or /process-feedback from inside its own headless execution, or backgrounded a long-running command and called ScheduleWakeup to check back later — both are the 'you ARE the executor — never re-queue or self-schedule' anti-pattern. A headless PRD run must perform its own acceptance criteria directly and has no next turn to resume it (standards.md → Execution discipline).",
   [FAILURE_CLASSES.STUCK_LOOP]:
     'Bound every command with `timeout <N> <cmd>` — never leave an unbounded `until`/`while true`/`sleep` poll in a PRD body (PRD_AUTHORING.md loop-hang guidance).',
   [FAILURE_CLASSES.POST_AC_OVERRUN]:
@@ -104,6 +112,9 @@ function extractRcaBlock(text) {
   return m ? m[1].trim() : null;
 }
 
+const ALREADY_SHIPPED_RE = /already (fully )?(satisfied|implemented|committed|done|shipped)|was (already )?(implemented|committed) in|nothing (new )?to commit|no (code )?changes were needed/i;
+const SELF_QUEUE_SKILL_RE = /Launching skill: session-manager-dev:(develop|process-feedback)/;
+const SELF_QUEUE_WAKEUP_RE = /ScheduleWakeup/;
 const STUCK_LOOP_RE = /\b(until\s|while\s+true|sleep\s)/i;
 const AC_CHECKBOX_RE = /^\s*[-*]\s*\[[xX]\]/;
 const SENTINEL_PASS_RE = /SCHEDULER_VERDICT:\s*PASS/;
@@ -120,6 +131,29 @@ const POST_AC_OVERRUN_MIN_TAIL_FRACTION = 0.3;
 function classifyFailure({ verdict, logTail }) {
   const lines = (logTail || '').split('\n');
 
+  // Checked first, before SELF_QUEUE/STUCK_LOOP: a correct executor that finds
+  // its acceptance criteria already satisfied by a prior commit makes no
+  // change and truthfully prints a PASS sentinel, so the run lands
+  // `pass_no_commit` (or `no_verdict_sentinel`, e.g. when it exits before the
+  // finish-protocol sentinel). Gated tightly on verdict so a tail that merely
+  // *mentions* "already implemented" (e.g. quoting a PRD body) while genuinely
+  // failing for another reason doesn't get misclassified as this benign case
+  // (incident: PRD 812-rca-self-delegation-failure-class re-ran 27 minutes
+  // after its own fix landed in 9cf0384 and was misclassified NO_SENTINEL).
+  if (
+    (verdict === 'pass_no_commit' || verdict === 'no_verdict_sentinel') &&
+    ALREADY_SHIPPED_RE.test(logTail || '')
+  ) {
+    return FAILURE_CLASSES.ALREADY_SHIPPED;
+  }
+
+  // Checked before STUCK_LOOP: a backgrounded command + ScheduleWakeup
+  // (variant b) can land words like "sleep"/"poll" in the tail via the PRD's
+  // own AC text, which would otherwise false-match STUCK_LOOP_RE (see PRD 771).
+  if (SELF_QUEUE_SKILL_RE.test(logTail || '') || SELF_QUEUE_WAKEUP_RE.test(logTail || '')) {
+    return FAILURE_CLASSES.SELF_QUEUE;
+  }
+
   const tailWindow = lines.slice(-STUCK_LOOP_WINDOW);
   if (tailWindow.some((l) => STUCK_LOOP_RE.test(l))) {
     return FAILURE_CLASSES.STUCK_LOOP;
@@ -301,12 +335,28 @@ async function fileRcaFeedback({ job, runDir, verdict, annotations, investigatio
       console.log(`[rca] skip: destPath escaped dest dir (${destPath})`);
       return { filed: false, reason: 'unsafe-path' };
     }
+    // /process-feedback archives dispositioned items to <dest.dir>/processed/
+    // immediately at disposition time (its own README convention) — long
+    // before this hook's own run-verify/self-heal passes might touch the same
+    // (slug, runId) again. Once archived, the live-dir check alone goes false
+    // and a re-trigger would refile a duplicate straight into the live inbox.
+    const processedPath = path.resolve(path.join(dest.dir, 'processed', fileName));
+    if (!processedPath.startsWith(path.resolve(path.join(dest.dir, 'processed')) + path.sep)) {
+      console.log(`[rca] skip: processedPath escaped processed dir (${processedPath})`);
+      return { filed: false, reason: 'unsafe-path' };
+    }
 
-    const alreadyFiled = fs.existsSync(destPath);
+    const liveExists = fs.existsSync(destPath);
+    const processedExists = !liveExists && fs.existsSync(processedPath);
+    const alreadyFiled = liveExists || processedExists;
     if (alreadyFiled && !investigationText) {
+      const existingPath = liveExists ? destPath : processedPath;
       console.log(`[rca] skip: already filed for ${job.slug}@${job.runId}`);
-      return { filed: false, reason: 'duplicate', path: destPath };
+      return { filed: false, reason: 'duplicate', path: existingPath };
     }
+    // An investigationText update must target wherever the file actually
+    // lives (live dir or processed/), not assume the live dir.
+    const targetPath = liveExists || !processedExists ? destPath : processedPath;
 
     const meta = readRunMeta(runDir, job.slug);
     const logPath = runDir ? path.join(runDir, `${job.slug}.log`) : null;
@@ -320,10 +370,10 @@ async function fileRcaFeedback({ job, runDir, verdict, annotations, investigatio
     });
 
     config.addAllowedRoot(dest.allowlistRoot);
-    await config.writeTextAtomic(destPath, markdown);
+    await config.writeTextAtomic(targetPath, markdown);
 
-    console.log(`[rca] ${alreadyFiled ? 'updated (investigation)' : 'filed'} ${destPath}`);
-    return { filed: true, path: destPath, updated: alreadyFiled };
+    console.log(`[rca] ${alreadyFiled ? 'updated (investigation)' : 'filed'} ${targetPath}`);
+    return { filed: true, path: targetPath, updated: alreadyFiled };
   } catch (e) {
     console.error('[rca] error filing RCA feedback', e?.message ?? String(e));
     return { filed: false, reason: 'error', error: e?.message ?? String(e) };

package/src/main/lib/terminalRunOutcome.cjs

@@ -0,0 +1,100 @@
+/**
+ * terminalRunOutcome.cjs — history-independent fallback for detecting an
+ * already-terminal (completed/failed) run for a PRD slug, by reading the
+ * newest run directory's <slug>.meta.json + <slug>.verdicts.json sidecars
+ * directly off disk instead of relying on history.jsonl (which may not
+ * exist yet — see PRD 812-689-fix-fix-distribute-adminserver-routes).
+ *
+ * Pure-ish: takes an injectable runsDir + fsImpl so tests can point it at a
+ * temp directory. Fails safe to null on any fs/JSON error so callers treat
+ * "unknown" the same as "no history match" (resurrect as pending).
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+/** Completed-equivalent verdicts — a clean, exit-0 run with nothing left to fix. */
+const COMPLETED_EQUIVALENT_VERDICTS = new Set([
+  'clean',
+  'pass_no_commit_target_verified',
+  'pass_no_commit_already_shipped',
+  'pass_no_commit_prior_run_verified',
+]);
+
+// Bounds the scan: only the newest few run dirs are stat'd per slug, never
+// the full runs/ directory (which can hold thousands of entries).
+const MAX_DIRS_SCANNED = 5;
+
+/**
+ * Returns { status: 'completed'|'failed', runId, finishedAt } for the newest
+ * run directory containing a `<slug>.meta.json`, or null if none is found or
+ * any fs/JSON error occurs (fail-safe: caller falls back to resurrecting the
+ * slug, unchanged current behavior).
+ */
+function latestTerminalOutcomeForSlug(slug, { runsDir, fsImpl = fs } = {}) {
+  if (!slug || !runsDir) return null;
+  let dirs;
+  try {
+    dirs = fsImpl.readdirSync(runsDir);
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(dirs) || dirs.length === 0) return null;
+
+  // Filter (cheap existence check) to dirs that actually have a run for this
+  // slug, mirroring resolveRunId's existing pattern in scheduler.cjs — this
+  // is a stat, not a read+parse.
+  const matches = dirs.filter((d) => {
+    try {
+      return fsImpl.existsSync(path.join(runsDir, d, `${slug}.meta.json`));
+    } catch {
+      return false;
+    }
+  });
+  if (!matches.length) return null;
+
+  // Dir names are ISO timestamps with `:`/`.` replaced by `-` — lexical
+  // descending sort is chronological descending. Only read+parse (the
+  // expensive part) the newest few.
+  matches.sort().reverse();
+  const candidates = matches.slice(0, MAX_DIRS_SCANNED);
+
+  for (const dir of candidates) {
+    const metaPath = path.join(runsDir, dir, `${slug}.meta.json`);
+    let meta;
+    try {
+      meta = JSON.parse(fsImpl.readFileSync(metaPath, 'utf8'));
+    } catch {
+      return null;
+    }
+
+    // meta.json's finishedAt is an epoch-ms number; callers (e.g. the
+    // history-archive-candidate path, which feeds Date.parse) expect an ISO
+    // string like queueHistory's finishedAt — normalize here.
+    const finishedAt = typeof meta.finishedAt === 'number'
+      ? new Date(meta.finishedAt).toISOString()
+      : (meta.finishedAt ?? null);
+
+    if (meta.exitCode !== 0) {
+      return { status: 'failed', runId: dir, finishedAt };
+    }
+
+    const verdictsPath = path.join(runsDir, dir, `${slug}.verdicts.json`);
+    let verdicts;
+    try {
+      verdicts = JSON.parse(fsImpl.readFileSync(verdictsPath, 'utf8'));
+    } catch {
+      return null;
+    }
+
+    if (COMPLETED_EQUIVALENT_VERDICTS.has(verdicts.verdict)) {
+      return { status: 'completed', runId: dir, finishedAt };
+    }
+    return { status: 'failed', runId: dir, finishedAt };
+  }
+  return null;
+}
+
+module.exports = { latestTerminalOutcomeForSlug, COMPLETED_EQUIVALENT_VERDICTS, MAX_DIRS_SCANNED };