@jaggerxtrm/specialists 3.18.0 → 3.18.2

package/dist/index.js

@@ -11712,8 +11712,36 @@ function initSchema(db) {
   migrateToV10(db);
   migrateToV11(db);
   migrateToV12(db);
+  migrateToV13(db);
   verifyWalMode(db);
 }
+function migrateToV13(db) {
+  const hasV13 = db.query("SELECT 1 FROM schema_version WHERE version = 13 LIMIT 1").get();
+  const specialistJobsColumns = new Set(db.query("PRAGMA table_info(specialist_jobs)").all().map((column) => column.name).filter((name) => typeof name === "string" && name.length > 0));
+  for (const column of [
+    { name: "pr_url", definition: "TEXT" },
+    { name: "pr_head_sha", definition: "TEXT" },
+    { name: "pr_state", definition: "TEXT" },
+    { name: "pr_merge_state", definition: "TEXT" },
+    { name: "pr_classification", definition: "TEXT" },
+    { name: "pr_base_ref", definition: "TEXT" },
+    { name: "pr_base_sha", definition: "TEXT" },
+    { name: "pr_drift_checked_at_ms", definition: "INTEGER" },
+    { name: "base_sha_pinned", definition: "TEXT" },
+    { name: "base_sha_pinned_at_ms", definition: "INTEGER" }
+  ]) {
+    if (!specialistJobsColumns.has(column.name)) {
+      db.run(`ALTER TABLE specialist_jobs ADD COLUMN ${column.name} ${column.definition}`);
+    }
+  }
+  if (hasV13) {
+    return;
+  }
+  db.run(`
+    INSERT OR IGNORE INTO schema_version (version, applied_at_ms)
+      VALUES (13, strftime('%s', 'now') * 1000);
+  `);
+}
 function migrateToV5(db) {
   const hasV5 = db.query("SELECT 1 FROM schema_version WHERE version = 5 LIMIT 1").get();
   if (!hasV5) {
@@ -12624,6 +12652,124 @@ class SqliteClient {
       return statuses;
     }, "listStatuses");
   }
+  readPrDriftState(jobId) {
+    return withRetry(() => {
+      const row = this.db.query(`
+        SELECT pr_url, pr_head_sha, pr_state, pr_merge_state, pr_classification,
+               pr_base_ref, pr_base_sha, pr_drift_checked_at_ms,
+               base_sha_pinned, base_sha_pinned_at_ms
+        FROM specialist_jobs WHERE job_id = ? LIMIT 1
+      `).get(jobId);
+      if (!row)
+        return null;
+      const num = (v) => v === null || v === undefined ? null : typeof v === "bigint" ? Number(v) : typeof v === "number" ? v : null;
+      const str = (v) => v === null || v === undefined ? null : typeof v === "string" ? v : null;
+      return {
+        pr_url: str(row.pr_url),
+        pr_head_sha: str(row.pr_head_sha),
+        pr_state: str(row.pr_state),
+        pr_merge_state: str(row.pr_merge_state),
+        pr_classification: str(row.pr_classification),
+        pr_base_ref: str(row.pr_base_ref),
+        pr_base_sha: str(row.pr_base_sha),
+        pr_drift_checked_at_ms: num(row.pr_drift_checked_at_ms),
+        base_sha_pinned: str(row.base_sha_pinned),
+        base_sha_pinned_at_ms: num(row.base_sha_pinned_at_ms)
+      };
+    }, "readPrDriftState");
+  }
+  updatePrDriftState(jobId, drift) {
+    return withRetry(() => {
+      const ALLOWED = [
+        "pr_url",
+        "pr_head_sha",
+        "pr_state",
+        "pr_merge_state",
+        "pr_classification",
+        "pr_base_ref",
+        "pr_base_sha",
+        "pr_drift_checked_at_ms",
+        "base_sha_pinned",
+        "base_sha_pinned_at_ms"
+      ];
+      const setClauses = [];
+      const params = [];
+      for (const key of ALLOWED) {
+        if (!Object.prototype.hasOwnProperty.call(drift, key))
+          continue;
+        setClauses.push(`${key} = ?`);
+        const value = drift[key];
+        params.push(value === undefined ? null : value);
+      }
+      if (setClauses.length === 0)
+        return false;
+      setClauses.push("updated_at_ms = ?");
+      params.push(Date.now());
+      params.push(jobId);
+      const sql = `UPDATE specialist_jobs SET ${setClauses.join(", ")} WHERE job_id = ?`;
+      const result = this.db.run(sql, params);
+      return (result?.changes ?? 0) > 0;
+    }, "updatePrDriftState");
+  }
+  listStaleSpecialistJobs(opts) {
+    return withRetry(() => {
+      const nowMs = opts?.nowMs ?? Date.now();
+      const minAgeMs = opts?.minAgeMs ?? 60000;
+      const cutoff = nowMs - minAgeMs;
+      const statuses = ["starting", "running", "waiting"];
+      const placeholders = statuses.map(() => "?").join(", ");
+      const rows = this.db.query(`
+        SELECT job_id, specialist, status, status_json,
+               JSON_EXTRACT(status_json, '$.pid') AS pid,
+               updated_at_ms,
+               bead_id,
+               chain_id
+        FROM specialist_jobs
+        WHERE status IN (${placeholders})
+          AND pid IS NOT NULL
+          AND updated_at_ms < ?
+        ORDER BY updated_at_ms ASC
+        LIMIT 200
+      `).all(...statuses, cutoff);
+      const num = (v) => v === null || v === undefined ? 0 : typeof v === "bigint" ? Number(v) : typeof v === "number" ? v : 0;
+      const str = (v) => v === null || v === undefined ? null : typeof v === "string" ? v : null;
+      return rows.filter((row) => {
+        const pid = num(row.pid);
+        return Number.isInteger(pid) && pid > 0;
+      }).map((row) => ({
+        job_id: str(row.job_id) ?? "",
+        specialist: str(row.specialist) ?? "",
+        status: str(row.status) ?? "",
+        pid: num(row.pid),
+        updated_at_ms: num(row.updated_at_ms),
+        bead_id: str(row.bead_id),
+        chain_id: str(row.chain_id)
+      }));
+    }, "listStaleSpecialistJobs");
+  }
+  listJobsNeedingPrDriftRefresh(olderThanMs) {
+    return withRetry(() => {
+      const threshold = olderThanMs ?? Date.now() - 5 * 60 * 1000;
+      const rows = this.db.query(`
+        SELECT job_id, pr_url, pr_head_sha, pr_drift_checked_at_ms,
+               JSON_EXTRACT(status_json, '$.branch') AS branch
+        FROM specialist_jobs
+        WHERE pr_url IS NOT NULL
+          AND (pr_drift_checked_at_ms IS NULL OR pr_drift_checked_at_ms < ?)
+        ORDER BY pr_drift_checked_at_ms ASC NULLS FIRST
+        LIMIT 50
+      `).all(threshold);
+      const num = (v) => v === null || v === undefined ? null : typeof v === "bigint" ? Number(v) : typeof v === "number" ? v : null;
+      const str = (v) => v === null || v === undefined ? null : typeof v === "string" ? v : null;
+      return rows.map((row) => ({
+        job_id: str(row.job_id) ?? "",
+        pr_url: str(row.pr_url) ?? "",
+        pr_head_sha: str(row.pr_head_sha),
+        pr_drift_checked_at_ms: num(row.pr_drift_checked_at_ms),
+        branch: str(row.branch)
+      }));
+    }, "listJobsNeedingPrDriftRefresh");
+  }
   removeJobs(jobIds) {
     return withRetry(() => {
       if (jobIds.length === 0)
@@ -21471,6 +21617,14 @@ class SpecialistLoader {
     this.cache.set(name, merged.spec);
     return merged.spec;
   }
+  async getEffective(name) {
+    const merged = await this.buildMergedSpec(name);
+    if (!merged)
+      return null;
+    if (merged.warnings.length)
+      this.blockedFieldWarnings.set(name, merged.warnings);
+    return merged.spec;
+  }
   getBlockedFieldWarnings(name) {
     if (name)
       return this.blockedFieldWarnings.get(name) ?? [];
@@ -21956,6 +22110,24 @@ function findTokenUsage(payload) {
   }
   return normalizeTokenUsage(record3);
 }
+function extractMessageTextContent(message) {
+  if (!message || typeof message !== "object")
+    return "";
+  const record3 = message;
+  const content = record3.content;
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  return content.map((part) => {
+    if (!part || typeof part !== "object")
+      return "";
+    const item = part;
+    if (item.type !== undefined && item.type !== "text")
+      return "";
+    return typeof item.text === "string" ? item.text : "";
+  }).join("");
+}
 function findApiErrorMessage(payload) {
   if (!payload || typeof payload !== "object")
     return;
@@ -22231,6 +22403,9 @@ class PiAgentSession {
     const cavemanPath = join7(piExtDir, "caveman");
     if (existsSync7(cavemanPath))
       args.push("-e", cavemanPath);
+    const nvidiaNimPath = join7(homedir2(), ".pi", "agent", "git", "github.com", "xRyul", "pi-nvidia-nim");
+    if (existsSync7(nvidiaNimPath))
+      args.push("-e", nvidiaNimPath);
     const npmGlobalDir = resolveGlobalNodeModulesDir();
     const excludedExtensions = new Set(this.options.excludeExtensions ?? []);
     if (npmGlobalDir) {
@@ -22446,7 +22621,8 @@ class PiAgentSession {
     if (type === "message_end") {
       const role = event.message?.role;
       if (role === "assistant") {
-        this.options.onEvent?.("message_end_assistant");
+        const content = extractMessageTextContent(event.message);
+        this.options.onEvent?.("message_end_assistant", content ? { content, charCount: content.length } : undefined);
       } else if (role === "toolResult") {
         this.options.onEvent?.("message_end_tool_result");
       }
@@ -22475,7 +22651,7 @@ class PiAgentSession {
       const messages = event.messages ?? [];
       const last = [...messages].reverse().find((m) => m.role === "assistant");
       if (last) {
-        this._lastOutput = last.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+        this._lastOutput = extractMessageTextContent(last);
       }
       this._updateTokenUsage(findTokenUsage(event), "agent_end");
       this._updateFinishReason(findFinishReason(event), "agent_end");
@@ -22487,7 +22663,11 @@ class PiAgentSession {
       }
       this._agentEndReceived = true;
       this._clearStallTimer();
-      this.options.onEvent?.("agent_end");
+      if (this._lastOutput) {
+        this.options.onEvent?.("agent_end", { content: this._lastOutput, charCount: this._lastOutput.length });
+      } else {
+        this.options.onEvent?.("agent_end");
+      }
       this._doneResolve?.();
       return;
     }
@@ -22591,7 +22771,7 @@ class PiAgentSession {
           const delta = typeof ae.delta === "string" ? ae.delta : "";
           if (delta)
             this.options.onToken?.(delta);
-          this.options.onEvent?.("text", { charCount: delta.length });
+          this.options.onEvent?.("text", { charCount: delta.length, content: delta });
           break;
         }
         case "thinking_start":
@@ -25346,11 +25526,7 @@ function mapCallbackEventToTimelineEvent(callbackEvent, context) {
       };
     }
     case "text":
-      return {
-        t,
-        type: TIMELINE_EVENT_TYPES.TEXT,
-        ...context.charCount !== undefined ? { char_count: context.charCount } : {}
-      };
+      return null;
     case "agent_end":
     case "message_done":
     case "done":
@@ -27040,6 +27216,8 @@ class Supervisor {
       } : {},
       ...runOptions.variables?.chain_root_bead_id ? { chain_root_bead_id: runOptions.variables.chain_root_bead_id } : {},
       ...runOptions.workingDirectory ? { worktree_path: runOptions.workingDirectory } : {},
+      ...runOptions.baseShaPinned ? { base_sha_pinned: runOptions.baseShaPinned } : {},
+      ...runOptions.baseShaPinnedAtMs ? { base_sha_pinned_at_ms: runOptions.baseShaPinnedAtMs } : {},
       ...runOptions.workingDirectory ? { branch: resolveCurrentBranch(runOptions.workingDirectory) } : { branch: resolveCurrentBranch() },
       variables_keys: variablesKeys,
       reviewed_job_id_present: variablesKeys.includes("reviewed_job_id"),
@@ -27064,6 +27242,8 @@ class Supervisor {
       ...runOptions.workingDirectory ? { worktree_path: runOptions.workingDirectory } : {},
       ...runOptions.reusedFromJobId ? { reused_from_job_id: runOptions.reusedFromJobId } : {},
       ...runOptions.worktreeOwnerJobId ? { worktree_owner_job_id: runOptions.worktreeOwnerJobId } : {},
+      ...runOptions.baseShaPinned ? { base_sha_pinned: runOptions.baseShaPinned } : {},
+      ...runOptions.baseShaPinnedAtMs ? { base_sha_pinned_at_ms: runOptions.baseShaPinnedAtMs } : {},
       ...runOptions.worktreeOwnerJobId || runOptions.workingDirectory ? {
         chain_kind: "chain",
         chain_id: runOptions.worktreeOwnerJobId ?? id,
@@ -27168,7 +27348,6 @@ class Supervisor {
       execFileSync2("mkfifo", [fifoPath]);
       setStatus({ fifo_path: fifoPath });
     } catch {}
-    let textLogged = false;
     let runMetrics = {
       turns: 0,
       tool_calls: 0,
@@ -27184,6 +27363,8 @@ class Supervisor {
     let textCharCount = 0;
     let thinkingCharCount = 0;
     let turnTextAccumulator = "";
+    let assistantMessageAccumulator = "";
+    let lastPersistedAssistantMessage = "";
     let currentContextTokens = 0;
     const toolCallNames = [];
     const activeToolCalls = new Map;
@@ -27439,7 +27620,7 @@ ${appendError}
           writeFileSync5(this.resultPath(id), lastTurnSummaryTextContent || output, "utf-8");
         }
         try {
-          this.withSqliteOperation("upsertResult:resume_turn", (client) => client.upsertResult(id, output));
+          this.withSqliteOperation("upsertResult:resume_turn", (client) => client.upsertResult(id, lastTurnSummaryTextContent || output));
         } catch (error2) {
           console.warn(`[supervisor] SQLite upsertResult failed during resume turn: ${String(error2)}`);
         }
@@ -27447,7 +27628,7 @@ ${appendError}
           model: statusSnapshot.model ?? "unknown",
           backend: statusSnapshot.backend ?? "unknown",
           beadId: statusSnapshot.bead_id,
-          output
+          output: lastTurnSummaryTextContent || output
         });
         const passFinalize = shouldAutoFinalizeKeepAlive(output);
         const readOnlyClose = shouldAutoCloseReadOnlyKeepAlive(output);
@@ -27665,12 +27846,17 @@ ${appendError}
           textCharCount = 0;
           thinkingCharCount = 0;
           turnTextAccumulator = "";
+          assistantMessageAccumulator = "";
         }
         if (eventType === "message_start_assistant") {
           turnTextAccumulator = "";
+          assistantMessageAccumulator = "";
         }
         if (eventType === "text") {
           textCharCount += details?.charCount ?? 0;
+          if (typeof details?.content === "string") {
+            assistantMessageAccumulator += details.content;
+          }
         }
         if (eventType === "thinking") {
           thinkingCharCount += details?.charCount ?? 0;
@@ -27753,6 +27939,17 @@ ${appendError}
             data: metaDetails?.data
           } : undefined
         });
+        const assistantMessageContent = assistantMessageAccumulator || (typeof details?.content === "string" ? details.content : "");
+        if ((eventType === "message_end_assistant" || eventType === "agent_end") && assistantMessageContent.trim().length > 0 && assistantMessageContent !== lastPersistedAssistantMessage) {
+          appendTimelineEvent({
+            t: Date.now(),
+            type: TIMELINE_EVENT_TYPES.TEXT,
+            char_count: assistantMessageContent.length,
+            content: assistantMessageContent
+          });
+          lastPersistedAssistantMessage = assistantMessageContent;
+          assistantMessageAccumulator = "";
+        }
         if (timelineEvent) {
           appendTimelineEvent(timelineEvent);
           if (eventType === "tool_execution_end") {
@@ -27764,9 +27961,6 @@ ${appendError}
             const nextActiveTool = activeToolCalls.values().next().value?.tool;
             setStatus({ current_tool: nextActiveTool });
           }
-        } else if (eventType === "text" && !textLogged) {
-          textLogged = true;
-          appendTimelineEvent({ t: Date.now(), type: TIMELINE_EVENT_TYPES.TEXT });
         }
       }, (metricEvent) => {
         if (metricEvent.type === "token_usage") {
@@ -27977,14 +28171,15 @@ ${appendError}
       });
       isReadOnlySpecialist = finalResult.permissionRequired === "READ_ONLY";
       autoCommitPolicy = finalResult.autoCommit;
+      const reportedOutput = lastTurnSummaryTextContent || finalResult.output;
       emitRunCompleteForTurn({
         model: finalResult.model,
         backend: finalResult.backend,
         beadId: finalResult.beadId,
-        output: finalResult.output
+        output: reportedOutput
       });
       try {
-        this.withSqliteOperation("upsertResult:initial_turn", (client) => client.upsertResult(id, finalResult.output));
+        this.withSqliteOperation("upsertResult:initial_turn", (client) => client.upsertResult(id, reportedOutput));
       } catch (error2) {
         console.warn(`[supervisor] SQLite upsertResult failed during initial turn: ${String(error2)}`);
       }
@@ -28119,7 +28314,7 @@ ${appendError}
           exit_reason: runMetrics.exit_reason,
           metrics: enrichedRunMetrics,
           ...gitnexusSummary ? { gitnexus_summary: gitnexusSummary } : {}
-        }), latestOutput);
+        }), reportedOutput);
         return true;
       });
       if (completePersisted === undefined) {
@@ -28756,7 +28951,6 @@ var exports_view = {};
 __export(exports_view, {
   run: () => run5
 });
-import { readFile as readFile2 } from "fs/promises";
 import readline2 from "readline/promises";
 import { stdin as input, stdout as output } from "process";
 function permissionBadge2(permission) {
@@ -28921,9 +29115,13 @@ function printFullSpecialist(spec) {
   printBySection(spec, "stall_detection");
   printBySection(spec, "beads");
 }
-async function printRaw(summary) {
-  const content = await readFile2(summary.filePath, "utf-8");
-  console.log(content);
+async function printRaw(summary, loader) {
+  const spec = await loader.getEffective(summary.name);
+  if (!spec) {
+    console.error(`Specialist not found: ${summary.name}`);
+    process.exit(1);
+  }
+  console.log(JSON.stringify(spec, null, 2));
 }
 async function run5() {
   let args;
@@ -28961,7 +29159,7 @@ async function run5() {
     selectedSummary = chosen;
   }
   if (args.raw) {
-    await printRaw(selectedSummary);
+    await printRaw(selectedSummary, loader);
     return;
   }
   const specialist = await loader.get(selectedSummary.name);
@@ -29107,7 +29305,7 @@ __export(exports_init, {
   runGlobal: () => runGlobal,
   run: () => run7
 });
-import { copyFileSync, cpSync, existsSync as existsSync15, lstatSync, mkdirSync as mkdirSync8, readdirSync as readdirSync4, readFileSync as readFileSync13, readlinkSync, renameSync as renameSync3, symlinkSync, unlinkSync, writeFileSync as writeFileSync7 } from "fs";
+import { copyFileSync, cpSync, existsSync as existsSync15, lstatSync, mkdirSync as mkdirSync8, readdirSync as readdirSync4, readFileSync as readFileSync13, readlinkSync, renameSync as renameSync3, rmSync as rmSync3, symlinkSync, unlinkSync, writeFileSync as writeFileSync7 } from "fs";
 import { spawnSync as spawnSync10 } from "child_process";
 import { basename as basename4, dirname as dirname8, join as join15, relative, resolve as resolve6 } from "path";
 function ok(msg) {
@@ -29492,6 +29690,23 @@ function installProjectSkills(cwd, syncSkills) {
   ensureRootSymlink(join15(cwd, ".pi", "skills"), activeRoot);
   let copied = 0;
   let refreshed = 0;
+  let pruned = 0;
+  if (syncSkills) {
+    const currentSkills = new Set(skills);
+    for (const entry of readdirSync4(defaultRoot, { withFileTypes: true })) {
+      if (!entry.isDirectory() || currentSkills.has(entry.name))
+        continue;
+      const retiredDefaultPath = join15(defaultRoot, entry.name);
+      const retiredActivePath = join15(activeRoot, entry.name);
+      try {
+        if (lstatSync(retiredActivePath).isSymbolicLink() && resolve6(dirname8(retiredActivePath), readlinkSync(retiredActivePath)) === resolve6(retiredDefaultPath)) {
+          unlinkSync(retiredActivePath);
+        }
+      } catch {}
+      rmSync3(retiredDefaultPath, { recursive: true, force: true });
+      pruned++;
+    }
+  }
   for (const skill of skills) {
     const src = join15(sourceDir, skill);
     const defaultSkillPath = join15(defaultRoot, skill);
@@ -29510,6 +29725,8 @@ function installProjectSkills(cwd, syncSkills) {
     ok(`copied ${copied} skill${copied === 1 ? "" : "s"} to .xtrm/skills/default/`);
   if (refreshed > 0)
     ok(`re-synced ${refreshed} skill${refreshed === 1 ? "" : "s"} in .xtrm/skills/default/`);
+  if (pruned > 0)
+    ok(`pruned ${pruned} retired managed skill${pruned === 1 ? "" : "s"}`);
   ok("verified active skill symlinks in .xtrm/skills/active/");
 }
 function createSpecialistsDirs(cwd) {
@@ -31762,7 +31979,7 @@ __export(exports_validate, {
   parseArgs: () => parseArgs5,
   ArgParseError: () => ArgParseError3
 });
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 import { existsSync as existsSync18 } from "fs";
 function parseArgs5(argv) {
   const value = argv[0];
@@ -31785,7 +32002,7 @@ async function findSpecialist(name) {
   return list.find((item) => item.name === name);
 }
 async function loadSpecFromFile(filePath) {
-  const content = await readFile3(filePath, "utf-8");
+  const content = await readFile2(filePath, "utf-8");
   const raw = filePath.endsWith(".yaml") || filePath.endsWith(".yml") ? $parse(content) : JSON.parse(content);
   return SpecialistSchema.parseAsync(raw);
 }
@@ -31847,7 +32064,7 @@ async function run10() {
     }
     process.exit(1);
   }
-  const content = await readFile3(summary.filePath, "utf-8");
+  const content = await readFile2(summary.filePath, "utf-8");
   const result = await validateSpecialist(content);
   if (args.json) {
     console.log(JSON.stringify({
@@ -32647,7 +32864,7 @@ var init_edit = __esm(() => {
 });
 
 // src/specialist/resolution-diagnostics.ts
-import { readFile as readFile4 } from "fs/promises";
+import { readFile as readFile3 } from "fs/promises";
 import { createRequire as createRequire3 } from "module";
 import { execSync as execSync3 } from "child_process";
 import { join as join19 } from "path";
@@ -32744,7 +32961,7 @@ function probeHealth(catalog) {
 }
 async function loadResolvedConfigReport(args) {
   const manifest = readJsonFile3(join19(args.projectDir, "config", "specialists", `${args.specialistName}.specialist.json`));
-  const index = loadToolCatalogIndex(await readFile4(args.catalogsPath, "utf-8"));
+  const index = loadToolCatalogIndex(await readFile3(args.catalogsPath, "utf-8"));
   const catalogs = index.catalogs;
   const probes = catalogs.map(probeHealth);
   const extensionState = Object.fromEntries(probes.map((probe) => [probe.name, { health: probe.health, catalogCompatible: probe.drift === "none" }]));
@@ -33027,6 +33244,8 @@ async function launchSpecialist(opts) {
       forceJob: opts.args.forceJob,
       permissionRequired: opts.perm,
       workingDirectory: opts.workingDirectory,
+      baseShaPinned: opts.basePin?.baseShaPinned,
+      baseShaPinnedAtMs: opts.basePin ? Date.now() : undefined,
       reusedFromJobId: opts.reusedFromJobId,
       worktreeOwnerJobId: opts.worktreeOwnerJobId,
       output_file: opts.specialist.specialist.output_file
@@ -33040,6 +33259,19 @@ async function launchSpecialist(opts) {
 `)) : undefined),
     onJobStarted: ({ id }) => {
       opts.onJobStarted?.({ id });
+      if (opts.basePin) {
+        const sqliteClient = createObservabilitySqliteClient(opts.workingDirectory);
+        try {
+          sqliteClient?.updatePrDriftState(id, {
+            pr_base_ref: opts.basePin.branch,
+            pr_base_sha: opts.basePin.baseShaObserved,
+            base_sha_pinned: opts.basePin.baseShaPinned,
+            base_sha_pinned_at_ms: Date.now()
+          });
+        } finally {
+          sqliteClient?.close();
+        }
+      }
       process.stderr.write(dim8(`[job started: ${id}]
 `));
       const handoffPath = process.env.SPECIALISTS_BG_JOB_ID_PATH;
@@ -33114,6 +33346,7 @@ var bold10 = (s) => `\x1B[1m${s}\x1B[0m`, dim8 = (s) => `\x1B[2m${s}\x1B[0m`, gr
 var init_launch = __esm(() => {
   init_supervisor();
   init_runner();
+  init_observability_sqlite();
 });
 
 // node_modules/@earendil-works/pi-tui/dist/fuzzy.js
@@ -42933,6 +43166,9 @@ var init_feed = __esm(() => {
 // src/specialist/status-load.ts
 import { existsSync as existsSync20, readdirSync as readdirSync7, readFileSync as readFileSync18 } from "fs";
 import { join as join24 } from "path";
+function hasStatusId(status) {
+  return typeof status.id === "string" && status.id.trim().length > 0;
+}
 function readStatusesFromFiles(jobsDir) {
   if (!existsSync20(jobsDir))
     return [];
@@ -42942,7 +43178,9 @@ function readStatusesFromFiles(jobsDir) {
     if (!existsSync20(statusPath))
       continue;
     try {
-      statuses.push(JSON.parse(readFileSync18(statusPath, "utf-8")));
+      const status = JSON.parse(readFileSync18(statusPath, "utf-8"));
+      if (hasStatusId(status))
+        statuses.push(status);
     } catch {}
   }
   return statuses.sort((a, b) => b.started_at_ms - a.started_at_ms);
@@ -42990,27 +43228,148 @@ function enrichStatusesWithDerivedCurrentTool(statuses, jobsDir, sqliteClient) {
     current_tool: resolveDerivedCurrentTool(status, jobsDir, sqliteClient)
   }));
 }
+function statusFreshnessMs(status) {
+  return Math.max(status.last_event_at_ms ?? 0, status.started_at_ms ?? 0);
+}
+function mergeStatuses(fileStatuses, sqliteStatuses) {
+  const merged = new Map;
+  for (const status of fileStatuses) {
+    if (hasStatusId(status))
+      merged.set(status.id, status);
+  }
+  for (const status of sqliteStatuses) {
+    if (!hasStatusId(status))
+      continue;
+    const current = merged.get(status.id);
+    if (!current || statusFreshnessMs(status) >= statusFreshnessMs(current)) {
+      merged.set(status.id, status);
+    }
+  }
+  return [...merged.values()];
+}
+function isActiveStatus(status) {
+  return status.status === "starting" || status.status === "running" || status.status === "waiting";
+}
+function statusFromRunComplete(status) {
+  if (status === "COMPLETE")
+    return "done";
+  if (status === "CANCELLED")
+    return "cancelled";
+  if (status === "ERROR")
+    return "error";
+  return;
+}
+function latestRunComplete(events) {
+  for (let index = events.length - 1;index >= 0; index -= 1) {
+    const event = events[index];
+    if (event?.type === "run_complete")
+      return event;
+  }
+  return;
+}
+function mergedMetrics(status, complete) {
+  const tokenUsage = complete.token_usage ?? complete.metrics?.token_usage;
+  const metrics = {
+    ...status.metrics ?? {},
+    ...complete.metrics ?? {},
+    ...tokenUsage ? { token_usage: tokenUsage } : {},
+    ...complete.finish_reason ? { finish_reason: complete.finish_reason } : {},
+    ...complete.tool_calls ? { tool_call_names: complete.tool_calls, tool_calls: complete.tool_calls.length } : {},
+    ...complete.exit_reason ? { exit_reason: complete.exit_reason } : {}
+  };
+  return Object.keys(metrics).length > 0 ? metrics : undefined;
+}
+function hasStatusLoadEvidence(events, eventName) {
+  return events.some((event) => {
+    if (event.type !== "meta")
+      return false;
+    const meta = event;
+    return meta.source === "status-load" && meta.data?.component === "status-load" && meta.data?.event === eventName;
+  });
+}
+function statusLoadEvent(eventName, status, nextStatus, reason) {
+  return {
+    t: Date.now(),
+    type: "meta",
+    model: eventName,
+    backend: "status-load",
+    source: "status-load",
+    data: {
+      component: "status-load",
+      event: eventName,
+      job_id: status.id,
+      previous_status: status.status,
+      next_status: nextStatus,
+      pid: status.pid,
+      tmux_session: status.tmux_session,
+      reason
+    }
+  };
+}
+function persistReconciledStatus(sqliteClient, previous, next, events, reason) {
+  if (!sqliteClient)
+    return;
+  try {
+    const evidence = statusLoadEvent("status_reconciled", previous, next.status, reason);
+    if (hasStatusLoadEvidence(events, "status_reconciled")) {
+      sqliteClient.upsertStatus(next);
+      return;
+    }
+    sqliteClient.upsertStatusWithEvent(next, evidence);
+  } catch {}
+}
+function persistDeadJobEvidence(sqliteClient, status, events) {
+  if (!sqliteClient || hasStatusLoadEvidence(events, "dead_job_detected"))
+    return;
+  try {
+    sqliteClient.appendEvent(status.id, status.specialist, status.bead_id, statusLoadEvent("dead_job_detected", status, status.status, "active status has dead pid or tmux session"));
+  } catch {}
+}
+function reconcileStatusFromEvents(status, sqliteClient) {
+  if (!isActiveStatus(status) || !sqliteClient)
+    return status;
+  let events = [];
+  try {
+    events = sqliteClient.readEvents(status.id);
+  } catch {
+    events = [];
+  }
+  const complete = latestRunComplete(events);
+  const terminalStatus = statusFromRunComplete(complete?.status);
+  if (complete && terminalStatus && terminalStatus !== status.status) {
+    const reconciled = {
+      ...status,
+      status: terminalStatus,
+      elapsed_s: complete.elapsed_s ?? status.elapsed_s,
+      last_event_at_ms: complete.t,
+      model: complete.model ?? status.model,
+      backend: complete.backend ?? status.backend,
+      bead_id: complete.bead_id ?? status.bead_id,
+      metrics: mergedMetrics(status, complete),
+      ...complete.metrics?.output_type ? { output_type: complete.metrics.output_type } : {},
+      ...complete.error ? { error: complete.error } : {}
+    };
+    persistReconciledStatus(sqliteClient, status, reconciled, events, `terminal run_complete ${complete.status}`);
+    return reconciled;
+  }
+  if (isJobDead(status)) {
+    persistDeadJobEvidence(sqliteClient, status, events);
+  }
+  return status;
+}
+function reconcileStatuses(statuses, sqliteClient) {
+  return statuses.map((status) => reconcileStatusFromEvents(status, sqliteClient));
+}
 function loadStatuses() {
   const sqliteClient = createObservabilitySqliteClient();
   const jobsDir = resolveJobsDir();
   const fileStatuses = readStatusesFromFiles(jobsDir);
   try {
-    const sqliteStatuses = sqliteClient?.listStatuses() ?? [];
-    if (sqliteStatuses.length === 0) {
-      return enrichStatusesWithDerivedCurrentTool(fileStatuses, jobsDir, sqliteClient).sort((a, b) => b.started_at_ms - a.started_at_ms);
-    }
-    const merged = new Map;
-    for (const status of fileStatuses)
-      merged.set(status.id, status);
-    for (const status of sqliteStatuses) {
-      const current = merged.get(status.id);
-      if (!current || status.started_at_ms >= current.started_at_ms) {
-        merged.set(status.id, status);
-      }
-    }
-    return enrichStatusesWithDerivedCurrentTool([...merged.values()], jobsDir, sqliteClient).sort((a, b) => b.started_at_ms - a.started_at_ms);
+    const sqliteStatuses = (sqliteClient?.listStatuses() ?? []).filter(hasStatusId);
+    const merged = sqliteStatuses.length === 0 ? fileStatuses : mergeStatuses(fileStatuses, sqliteStatuses);
+    return enrichStatusesWithDerivedCurrentTool(reconcileStatuses(merged, sqliteClient), jobsDir, sqliteClient).sort((a, b) => b.started_at_ms - a.started_at_ms);
   } catch {
-    return enrichStatusesWithDerivedCurrentTool(fileStatuses, jobsDir, sqliteClient).sort((a, b) => b.started_at_ms - a.started_at_ms);
+    return enrichStatusesWithDerivedCurrentTool(fileStatuses.filter(hasStatusId), jobsDir, sqliteClient).sort((a, b) => b.started_at_ms - a.started_at_ms);
   } finally {
     sqliteClient?.close();
   }
@@ -43018,6 +43377,7 @@ function loadStatuses() {
 var init_status_load = __esm(() => {
   init_observability_sqlite();
   init_job_root();
+  init_supervisor();
   init_timeline_events();
 });
 
@@ -43296,6 +43656,20 @@ function formatToolDetail(event) {
   }
   return `${toolName}: ${dim9(event.phase)}`;
 }
+function formatAssistantTextContent(content) {
+  const normalized = content.replace(/\r\n/g, `
+`).trimEnd();
+  if (normalized.length <= ASSISTANT_TEXT_RENDER_LIMIT) {
+    return { body: normalized, renderedChars: normalized.length, truncated: false };
+  }
+  const body = normalized.slice(0, ASSISTANT_TEXT_RENDER_LIMIT);
+  return {
+    body: `${body}
+${dim9(`[assistant message truncated: ${normalized.length - ASSISTANT_TEXT_RENDER_LIMIT} chars hidden]`)}`,
+    renderedChars: ASSISTANT_TEXT_RENDER_LIMIT,
+    truncated: true
+  };
+}
 function formatEventLine(event, options2) {
   const ts = dim9(formatTime(event.t));
   const job = options2.colorize(`[${options2.jobId}]`);
@@ -43419,7 +43793,15 @@ function formatEventLine(event, options2) {
   } else if (event.type === "compaction" || event.type === "retry") {
     detailParts.push(`phase=${event.phase}`);
   } else if (event.type === "text") {
-    detailParts.push("kind=assistant");
+    if (event.content) {
+      const rendered = formatAssistantTextContent(event.content);
+      detail = `${dim9(`kind=assistant chars=${event.char_count ?? event.content.length} rendered=${rendered.renderedChars}${rendered.truncated ? " truncated=true" : ""}`)}
+${rendered.body}`;
+    } else {
+      detailParts.push("kind=assistant");
+      if (event.char_count !== undefined)
+        detailParts.push(`chars=${event.char_count}`);
+    }
   } else if (event.type === "thinking") {
     detailParts.push("kind=model");
   } else if (event.type === "message") {
@@ -43471,7 +43853,7 @@ function formatEventInlineDebounced(event, activePhase) {
     nextPhase: null
   };
 }
-var dim9 = (s) => `\x1B[2m${s}\x1B[0m`, bold11 = (s) => `\x1B[1m${s}\x1B[0m`, cyan6 = (s) => `\x1B[36m${s}\x1B[0m`, yellow10 = (s) => `\x1B[33m${s}\x1B[0m`, red2 = (s) => `\x1B[31m${s}\x1B[0m`, green9 = (s) => `\x1B[32m${s}\x1B[0m`, blue3 = (s) => `\x1B[34m${s}\x1B[0m`, magenta3 = (s) => `\x1B[35m${s}\x1B[0m`, JOB_COLORS, EVENT_LABELS;
+var dim9 = (s) => `\x1B[2m${s}\x1B[0m`, bold11 = (s) => `\x1B[1m${s}\x1B[0m`, cyan6 = (s) => `\x1B[36m${s}\x1B[0m`, yellow10 = (s) => `\x1B[33m${s}\x1B[0m`, red2 = (s) => `\x1B[31m${s}\x1B[0m`, green9 = (s) => `\x1B[32m${s}\x1B[0m`, blue3 = (s) => `\x1B[34m${s}\x1B[0m`, magenta3 = (s) => `\x1B[35m${s}\x1B[0m`, JOB_COLORS, EVENT_LABELS, ASSISTANT_TEXT_RENDER_LIMIT = 4000;
 var init_format_helpers = __esm(() => {
   JOB_COLORS = [cyan6, yellow10, magenta3, green9, blue3, red2];
   EVENT_LABELS = {
@@ -43570,6 +43952,39 @@ async function stopJob(jobId, opts = {}) {
     if (!status)
       throw new Error(`No job found: ${jobId}`);
     if (status.status === "done" || status.status === "error" || status.status === "cancelled") {
+      const pid2 = status.pid;
+      if (typeof pid2 === "number" && Number.isInteger(pid2) && pid2 > 0 && isProcessAlive(pid2, status.started_at_ms)) {
+        supervisor.emitControlEvent(jobId, "stop_terminal_alive_reaped", {
+          source: "cli",
+          pid: pid2,
+          previous_status: status.status,
+          reason: "registry_terminal_process_alive",
+          signal: "SIGTERM/SIGKILL",
+          tmux_session: status.tmux_session
+        });
+        try {
+          process.kill(-pid2, "SIGTERM");
+        } catch (err) {
+          if (err?.code !== "ESRCH") {
+            try {
+              process.kill(pid2, "SIGTERM");
+            } catch {}
+          }
+        }
+        const exited = await waitForProcessExit(pid2, 3000);
+        if (!exited) {
+          try {
+            process.kill(-pid2, "SIGKILL");
+          } catch {
+            tryKillProcessGroup(pid2);
+          }
+        }
+        if (status.tmux_session)
+          killTmuxSession(status.tmux_session);
+        process.stdout.write(`${green10("\u2713")} Reaped orphaned PID ${pid2} for job ${jobId} (registry was ${status.status}).
+`);
+        return;
+      }
       process.stderr.write(`${dim10(`Job ${jobId} already finalized (${status.status}).`)}
 `);
       return;
@@ -44810,9 +45225,11 @@ function collectStaleSpecialistJobs(options2 = {}) {
   const procRoot = options2.procRoot ?? "/proc";
   const nowMs = options2.nowMs ?? Date.now();
   const minKeepAliveAgeMs = options2.minKeepAliveAgeMs ?? 30 * 60 * 1000;
+  const minTerminalAliveAgeMs = options2.minTerminalAliveAgeMs ?? 60 * 1000;
   const observabilityClient = options2.observabilityClient ?? createObservabilitySqliteClient();
   const statuses = observabilityClient?.listStatuses() ?? [];
   const staleStatuses = statuses.filter((status) => ["starting", "running", "waiting"].includes(status.status));
+  const terminalStatuses = statuses.filter((status) => ["done", "error", "cancelled"].includes(status.status));
   const uptimeSeconds = readProcUptimeSecondsOrNull(procRoot) ?? nowMs / 1000;
   const candidates = [];
   for (const status of staleStatuses) {
@@ -44848,6 +45265,39 @@ function collectStaleSpecialistJobs(options2 = {}) {
       continue;
     candidates.push({ jobId: status.id, pid, beadId: status.bead_id ?? null, specialist: status.specialist, cwd: snapshot.cwd, ageMs, reason: "dead-toolchain" });
   }
+  for (const status of terminalStatuses) {
+    const pid = status.pid;
+    if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0)
+      continue;
+    const updatedAtMs = status.updated_at_ms ?? nowMs;
+    const ageMs = Math.max(0, nowMs - updatedAtMs);
+    if (ageMs < minTerminalAliveAgeMs)
+      continue;
+    const snapshot = readProcessSnapshot(pid, procRoot, uptimeSeconds);
+    if (!snapshot) {
+      if (readProcessLiveness(pid, procRoot) !== "alive")
+        continue;
+      candidates.push({
+        jobId: status.id,
+        pid,
+        beadId: status.bead_id ?? null,
+        specialist: status.specialist,
+        cwd: readProcCwdOrNull(pid, procRoot),
+        ageMs,
+        reason: "terminal-alive"
+      });
+      continue;
+    }
+    candidates.push({
+      jobId: status.id,
+      pid,
+      beadId: status.bead_id ?? null,
+      specialist: status.specialist,
+      cwd: snapshot.cwd,
+      ageMs,
+      reason: "terminal-alive"
+    });
+  }
   return candidates.sort((left, right) => left.pid - right.pid);
 }
 var DEFAULT_WARN_PCT = 70, DEFAULT_REFUSE_PCT = 85, CLOCK_TICKS_PER_SECOND = 100;
@@ -45666,7 +46116,7 @@ import {
   mkdirSync as mkdirSync12,
   readFileSync as readFileSync21,
   renameSync as renameSync4,
-  rmSync as rmSync3,
+  rmSync as rmSync4,
   statSync as statSync5,
   writeFileSync as writeFileSync13
 } from "fs";
@@ -45735,7 +46185,7 @@ function writeConsoleConfig(config2, cookie = `${process.pid}.${Math.floor(perfo
     renameSync4(tmpPath, location.path);
   } catch (renameError) {
     try {
-      rmSync3(tmpPath, { force: true });
+      rmSync4(tmpPath, { force: true });
     } catch {}
     logError("ps", "write_global_config", {
       step: "console_json",
@@ -49189,7 +49639,7 @@ var init_console = __esm(() => {
 });
 
 // src/specialist/worktree.ts
-import { existsSync as existsSync26, symlinkSync as symlinkSync2, mkdirSync as mkdirSync13, rmSync as rmSync4 } from "fs";
+import { existsSync as existsSync26, symlinkSync as symlinkSync2, mkdirSync as mkdirSync13, rmSync as rmSync5 } from "fs";
 import { join as join30, resolve as resolve9 } from "path";
 import { spawnSync as spawnSync15, execFileSync as execFileSync3 } from "child_process";
 function deriveBranchName(beadId, specialistName) {
@@ -49231,7 +49681,7 @@ function provisionWorktree(options2) {
   createWorktreeViaBd(worktreePath, branch, commonRoot);
   normalizeParentHooksPath(commonRoot);
   try {
-    rmSync4(join30(worktreePath, ".beads"), { recursive: true, force: true });
+    rmSync5(join30(worktreePath, ".beads"), { recursive: true, force: true });
     markBeadsSkipWorktree(worktreePath);
   } catch {}
   symlinkPiNpmCache(commonRoot, worktreePath);
@@ -49321,7 +49771,7 @@ var init_worktree = __esm(() => {
 });
 
 // src/specialist/epic-reconciler.ts
-import { mkdirSync as mkdirSync14, openSync as openSync2, readFileSync as readFileSync24, rmSync as rmSync5, writeFileSync as writeFileSync14 } from "fs";
+import { mkdirSync as mkdirSync14, openSync as openSync2, readFileSync as readFileSync24, rmSync as rmSync6, writeFileSync as writeFileSync14 } from "fs";
 import { join as join31 } from "path";
 function buildEpicLockPath(epicId) {
   const location = resolveObservabilityDbLocation();
@@ -49349,7 +49799,7 @@ function withEpicAdvisoryLock(epicId, action) {
   } finally {
     if (lockFd !== null) {
       try {
-        rmSync5(lockPath, { force: true });
+        rmSync6(lockPath, { force: true });
       } catch {}
     }
   }
@@ -50173,7 +50623,7 @@ ${conflicts.map((file) => `- ${file}`).join(`
 function runTypecheckGate(cwd = process.cwd()) {
   const hasTypeScriptConfig = existsSync27(join32(cwd, "tsconfig.json")) || readdirSync11(cwd).some((entry) => entry.startsWith("tsconfig") && entry.endsWith(".json"));
   if (!hasTypeScriptConfig) {
-    console.log("TypeScript gate: skipped (no tsconfig)");
+    console.log("TypeScript gate: skipped (no tsconfig \u2014 non-TS repo)");
     return;
   }
   const tsc = runCommand("bunx", ["tsc", "--noEmit"], cwd);
@@ -50184,7 +50634,22 @@ function runTypecheckGate(cwd = process.cwd()) {
   throw new Error(`TypeScript gate failed after merge.
 ${stderr || stdout || "Unknown tsc error"}`);
 }
+function hasNodeBuildScript(cwd) {
+  const packageJsonPath = join32(cwd, "package.json");
+  if (!existsSync27(packageJsonPath))
+    return false;
+  try {
+    const pkg = JSON.parse(readFileSync25(packageJsonPath, "utf8"));
+    return typeof pkg.scripts?.build === "string" && pkg.scripts.build.length > 0;
+  } catch {
+    return false;
+  }
+}
 function runRebuild(cwd = process.cwd()) {
+  if (!hasNodeBuildScript(cwd)) {
+    console.log("Rebuild: skipped (no package.json build script \u2014 non-Node repo)");
+    return;
+  }
   const build = runCommand("bun", ["run", "build"], cwd);
   if (build.status === 0)
     return;
@@ -50367,6 +50832,8 @@ var init_merge = __esm(() => {
 var exports_run = {};
 __export(exports_run, {
   run: () => run16,
+  resolveBasePin: () => resolveBasePin,
+  buildTmuxLiveFeedCommand: () => buildTmuxLiveFeedCommand,
   buildInjectedWriterDiffVariables: () => buildInjectedWriterDiffVariables,
   buildInjectedReviewerDiffVariables: () => buildInjectedReviewerDiffVariables
 });
@@ -50377,7 +50844,7 @@ import { spawn as cpSpawn, execSync as execSync5 } from "child_process";
 async function parseArgs8(argv) {
   const name = argv[0];
   if (!name || name.startsWith("--")) {
-    console.error('Usage: specialists|sp run <name> [--prompt "..."] [--bead <id>] ' + "[--worktree] [--job <id>] [--force-job] [--epic <id>] [--force-stale-base] [--context-depth <n>] [--model <model>] " + "[--no-beads] [--no-bead-notes] [--keep-alive|--no-keep-alive] [--json|--raw]");
+    console.error('Usage: specialists|sp run <name> [--prompt "..."] [--bead <id>] ' + "[--worktree] [--job <id>] [--force-job] [--epic <id>] [--base-sha <sha>] [--base-ref <branch>] [--accept-stale-base --reason <text>] [--context-depth <n>] [--model <model>] " + "[--no-beads] [--no-bead-notes] [--keep-alive|--no-keep-alive] [--json|--raw]");
     process.exit(1);
   }
   let prompt = "";
@@ -50395,6 +50862,10 @@ async function parseArgs8(argv) {
   let forceJob = false;
   let epicId;
   let forceStaleBase = false;
+  let acceptStaleBase = false;
+  let staleBaseReason;
+  let baseSha;
+  let baseRef;
   for (let i = 1;i < argv.length; i++) {
     const token = argv[i];
     if (token === "--prompt" && argv[i + 1]) {
@@ -50463,11 +50934,35 @@ async function parseArgs8(argv) {
       epicId = argv[++i];
       continue;
     }
+    if (token === "--base-sha" && argv[i + 1]) {
+      baseSha = argv[++i];
+      continue;
+    }
+    if (token === "--base-ref" && argv[i + 1]) {
+      baseRef = argv[++i];
+      continue;
+    }
+    if (token === "--reason" && argv[i + 1]) {
+      staleBaseReason = argv[++i];
+      continue;
+    }
+    if (token === "--accept-stale-base") {
+      acceptStaleBase = true;
+      continue;
+    }
     if (token === "--force-stale-base") {
+      process.stderr.write(`[deprecated] --force-stale-base is deprecated; use --accept-stale-base --reason <text>. Aliased for one release.
+`);
       forceStaleBase = true;
+      acceptStaleBase = true;
+      staleBaseReason ??= "deprecated --force-stale-base";
       continue;
     }
   }
+  if (acceptStaleBase && !staleBaseReason?.trim()) {
+    console.error("Error: --accept-stale-base requires --reason <text>.");
+    process.exit(1);
+  }
   if (worktree && reuseJobId !== undefined) {
     console.error("Error: --worktree and --job are mutually exclusive. Use one or the other.");
     process.exit(1);
@@ -50515,7 +51010,11 @@ async function parseArgs8(argv) {
     reuseJobId,
     forceJob,
     epicId,
-    forceStaleBase
+    forceStaleBase,
+    acceptStaleBase,
+    staleBaseReason,
+    baseSha,
+    baseRef
   };
 }
 function readBeadSummary(beadId) {
@@ -50621,7 +51120,7 @@ function assertNoStaleBaseSiblings(beadId, forceStaleBase) {
     if (staleSiblings.length === 0)
       return;
     if (forceStaleBase) {
-      process.stderr.write(dim11(`[stale-base guard bypassed: ${staleSiblings.length} unmerged sibling chain(s) under epic ${epicId}]
+      process.stderr.write(dim11(`[stale-base guard accepted: ${staleSiblings.length} unmerged sibling chain(s) under epic ${epicId}]
 `));
       return;
     }
@@ -50630,14 +51129,14 @@ function assertNoStaleBaseSiblings(beadId, forceStaleBase) {
     throw new Error(`Refusing worktree dispatch for bead '${beadId}': epic '${epicId}' has unmerged sibling chains with substantive commits.
 ` + `${lines}
 ` + `Publish the epic first: sp epic merge ${epicId}
-` + `If intentional, rerun with --force-stale-base.`);
+` + `If intentional, rerun with --accept-stale-base --reason <text>.`);
   } finally {
     sqliteClient.close();
   }
 }
 function resolveWorkingDirectory(args, jobsDir, permissionRequired, readStatus) {
   if (args.worktree) {
-    assertNoStaleBaseSiblings(args.beadId, args.forceStaleBase);
+    assertNoStaleBaseSiblings(args.beadId, args.acceptStaleBase);
     const info = provisionWorktree({
       beadId: args.beadId,
       specialistName: args.name
@@ -50766,6 +51265,111 @@ function formatFooterModel2(backend, model) {
 function shellQuote2(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
+function buildTmuxLiveFeedCommand(options2) {
+  const handoffPath = shellQuote2(options2.handoffPath);
+  const logPath = shellQuote2(`${options2.handoffPath}.log`);
+  const script = [
+    `cd ${shellQuote2(options2.cwd)}`,
+    `(${options2.runCommand}) > ${logPath} 2>&1 & run_pid=$!`,
+    "job_id=",
+    `for _ in $(seq 1 150); do if [ -s ${handoffPath} ]; then job_id=$(tr -d '\\r\\n' < ${handoffPath}); break; fi; if ! kill -0 "$run_pid" 2>/dev/null; then break; fi; sleep 0.1; done`,
+    `if [ -n "$job_id" ]; then printf '\\n[tmux live feed: %s]\\n' "$job_id"; ${options2.feedCommandPrefix} "$job_id" --follow; wait "$run_pid"; run_status=$?; exit "$run_status"; fi`,
+    `cat ${logPath} 2>/dev/null || true`,
+    'wait "$run_pid"',
+    "exit $?"
+  ].join("; ");
+  return `/bin/bash -c ${shellQuote2(script)}`;
+}
+function recordTmuxLiveFeedStarted(options2) {
+  const sqliteClient = createObservabilitySqliteClient(options2.cwd);
+  if (!sqliteClient)
+    return;
+  try {
+    sqliteClient.appendEvent(options2.jobId, options2.specialist, options2.beadId, {
+      t: Date.now(),
+      type: "meta",
+      model: "tmux_live_feed_started",
+      backend: "cli.run",
+      source: "cli.run",
+      data: {
+        component: "cli.run",
+        event: "tmux_live_feed_started",
+        job_id: options2.jobId,
+        tmux_session: options2.tmuxSession,
+        command: "sp feed <job> --follow",
+        outcome: "started"
+      }
+    });
+  } catch {} finally {
+    sqliteClient.close();
+  }
+}
+function runGit2(cwd, args) {
+  return execSync5(["git", ...args.map(shellQuote2)].join(" "), {
+    cwd,
+    stdio: "pipe",
+    encoding: "utf-8",
+    timeout: 1e4
+  }).trim();
+}
+function formatErrorMessage(error2) {
+  return error2 instanceof Error ? error2.message : String(error2);
+}
+function runGitForBasePin(cwd, args, runArgs) {
+  try {
+    return runGit2(cwd, args);
+  } catch (error2) {
+    const envelope = {
+      ok: false,
+      error_code: "base_fetch_failed",
+      blocked_by: ["fetch_or_resolve_failure"],
+      next_safe_action: "verify network/remote/declared base ref is reachable, or rerun with --accept-stale-base --reason <text> if intentional",
+      base_ref: runArgs.baseRef ?? null,
+      base_sha: runArgs.baseSha ?? null,
+      worktree_path: cwd,
+      underlying_error: formatErrorMessage(error2)
+    };
+    throw new Error(JSON.stringify(envelope));
+  }
+}
+function resolveBasePin(args, worktreePath) {
+  if (!worktreePath || !args.worktree && !args.baseSha)
+    return;
+  const baseRef = args.baseRef?.trim();
+  if (baseRef) {
+    runGitForBasePin(worktreePath, ["fetch", "origin", baseRef], args);
+  } else {
+    runGitForBasePin(worktreePath, ["fetch", "origin"], args);
+  }
+  const baseShaObserved = runGitForBasePin(worktreePath, ["rev-parse", baseRef ? "FETCH_HEAD" : "refs/remotes/origin/HEAD"], args);
+  const baseShaPinned = args.baseSha ?? baseShaObserved;
+  const currentSha = runGitForBasePin(worktreePath, ["rev-parse", "HEAD"], args);
+  const branch = runGitForBasePin(worktreePath, ["rev-parse", "--abbrev-ref", "HEAD"], args);
+  const commitsBehindText = runGitForBasePin(worktreePath, ["rev-list", "--count", `${currentSha}..${baseShaPinned}`], args);
+  const commitsBehind = Number.parseInt(commitsBehindText, 10) || 0;
+  const hasStaleBase = currentSha !== baseShaPinned || baseShaObserved !== baseShaPinned;
+  if (!hasStaleBase) {
+    return { baseShaPinned, baseShaObserved, currentSha, branch, commitsBehind, override: false };
+  }
+  if (args.acceptStaleBase) {
+    process.stderr.write(dim11(`[stale-base guard accepted: base_sha_pinned=${baseShaPinned} current_sha=${currentSha} reason=${args.staleBaseReason}]
+`));
+    return { baseShaPinned, baseShaObserved, currentSha, branch, commitsBehind, override: true };
+  }
+  const envelope = {
+    ok: false,
+    error_code: "stale_base",
+    blocked_by: ["worktree_base_mismatch"],
+    next_safe_action: "Fetch/recreate worktree from declared base, or rerun with --accept-stale-base --reason <text> if divergence is intentional.",
+    base_sha_pinned: baseShaPinned,
+    base_sha_observed: baseShaObserved,
+    current_sha: currentSha,
+    branch,
+    worktree_path: worktreePath,
+    commits_behind: commitsBehind
+  };
+  throw new Error(JSON.stringify(envelope));
+}
 function extractReviewedJobIdOverride(prompt) {
   const match = prompt.match(/(?:^|\n)\s*reviewed_job_id\s*:\s*([^\n]+)/i);
   const candidate = match?.[1]?.trim();
@@ -50950,15 +51554,23 @@ async function run16() {
     const launchStartedAt = Date.now();
     const innerArgs = process.argv.slice(2).filter((a) => a !== "--background");
     const cmd = `${process.execPath} ${process.argv[1]} ${innerArgs.map(shellQuote2).join(" ")}`;
-    const tmuxCmd = `/bin/bash -c ${shellQuote2(`cd ${shellQuote2(cwd)} && exec ${cmd}`)}`;
     let childPid;
     let childExitCode;
     let childExitPromise;
     let handoffPath;
+    let tmuxSessionName;
     if (isTmuxAvailable()) {
       const suffix = randomBytes(3).toString("hex");
       const sessionName = buildSessionName(args.name, suffix);
+      tmuxSessionName = sessionName;
       handoffPath = join33(jobsDir2, `.bg-job-id-${sessionName}`);
+      const feedCommandPrefix = [process.execPath, process.argv[1], "feed"].map(shellQuote2).join(" ");
+      const tmuxCmd = buildTmuxLiveFeedCommand({
+        cwd,
+        runCommand: cmd,
+        handoffPath,
+        feedCommandPrefix
+      });
       createTmuxSession(sessionName, cwd, tmuxCmd, { [JOB_ID_HANDOFF_PATH_ENV]: handoffPath });
     } else {
       const child = cpSpawn(process.execPath, [process.argv[1], ...innerArgs], {
@@ -51020,6 +51632,15 @@ async function run16() {
       jobId = resolveNewestJobIdFromJobsDir(jobsDir2, oldLatest, launchStartedAt - 1000);
     }
     if (jobId) {
+      if (tmuxSessionName) {
+        recordTmuxLiveFeedStarted({
+          cwd,
+          jobId,
+          specialist: args.name,
+          beadId: args.beadId,
+          tmuxSession: tmuxSessionName
+        });
+      }
       process.stdout.write(`${jobId}
 `);
     } else {
@@ -51045,7 +51666,9 @@ async function run16() {
     runOptions: { name: args.name, prompt },
     jobsDir
   });
-  const { workingDirectory, reusedFromJobId, worktreeOwnerJobId, inferredBeadId } = resolveWorkingDirectory({ ...args, worktree: useWorktree }, jobsDir, perm, (jobId) => statusReader.readStatus(jobId));
+  const effectiveArgs = { ...args, worktree: useWorktree };
+  const { workingDirectory, reusedFromJobId, worktreeOwnerJobId, inferredBeadId } = resolveWorkingDirectory(effectiveArgs, jobsDir, perm, (jobId) => statusReader.readStatus(jobId));
+  const basePin = resolveBasePin(effectiveArgs, workingDirectory);
   await statusReader.dispose();
   if (!effectiveBeadId && inferredBeadId) {
     effectiveBeadId = inferredBeadId;
@@ -51098,6 +51721,7 @@ async function run16() {
     circuitBreaker,
     beadsClient,
     workingDirectory,
+    basePin,
     reusedFromJobId,
     worktreeOwnerJobId,
     effectiveBeadId,
@@ -55213,7 +55837,8 @@ async function run17() {
       jobs = supervisor.listJobs().filter(isStandaloneJob);
     }
     if (jobId) {
-      const selectedJob = supervisor?.readStatus(jobId) ?? null;
+      const selectedStatus = loadStatuses().find((status) => status.id.startsWith(jobId)) ?? supervisor?.readStatus(jobId) ?? null;
+      const selectedJob = selectedStatus ? { ...selectedStatus, is_dead: isJobDead(selectedStatus) } : null;
       if (!selectedJob || !isStandaloneJob(selectedJob)) {
         if (jsonMode) {
           console.log(JSON.stringify({ error: `Job not found: ${jobId}` }, null, 2));
@@ -55364,6 +55989,7 @@ ${bold11("specialists status")}
 var init_status2 = __esm(() => {
   init_loader();
   init_supervisor();
+  init_status_load();
   init_job_root();
   init_observability_sqlite();
   init_format_helpers();
@@ -55416,7 +56042,8 @@ function parseArgs9(argv) {
     "--active",
     "--running",
     "--mine",
-    "--health"
+    "--health",
+    "--needs-attention"
   ]);
   const valueFlags = new Set(["--node", "--bead", "--since"]);
   let nodeId;
@@ -55459,6 +56086,7 @@ function parseArgs9(argv) {
     running: argv.includes("--running") || argv.includes("--active"),
     mine: argv.includes("--mine"),
     health: argv.includes("--health"),
+    needsAttention: argv.includes("--needs-attention"),
     beadFilter,
     sinceMs,
     nodeId,
@@ -55495,6 +56123,7 @@ function toJobNode(job) {
     context_health: job.context_health,
     metrics: job.metrics,
     startup_payload_json: job.startup_payload_json ?? null,
+    pr_classification: job.pr_classification,
     children: []
   };
 }
@@ -55844,7 +56473,8 @@ function renderJobLine(job, beadTitles, prefix, connector) {
   const width = Math.max(80, (process.stdout.columns ?? 160) - prefix.length - connector.length);
   const themed = renderJobRow(consoleJob, width, 0, false);
   const body = themed.startsWith("  ") ? themed.slice(2) : themed;
-  return `${prefix}${connector}${body}`;
+  const driftBadge = job.pr_classification && job.pr_classification !== "clean" ? red2(` [drift:${job.pr_classification}]`) : "";
+  return `${prefix}${connector}${body}${driftBadge}`;
 }
 function renderTreeNodes(nodes, beadTitles, prefix, renderedJobIds) {
   for (let i = 0;i < nodes.length; i++) {
@@ -56049,7 +56679,7 @@ function renderHuman(jobs, nodes, trees, all, includeTerminal, epicReadiness, he
   const includeSuffix = all ? "  " + dim9("\xB7 include terminal") : "";
   console.log(renderStatsLine(statsSnapshot, width) + includeSuffix);
 }
-function statusFromRunComplete(status) {
+function statusFromRunComplete2(status) {
   if (status === "COMPLETE")
     return "done";
   if (status === "CANCELLED")
@@ -56086,7 +56716,7 @@ function synthesizeStatusFromEvents(jobId) {
     return {
       id: jobId,
       specialist,
-      status: statusFromRunComplete(runComplete?.status),
+      status: statusFromRunComplete2(runComplete?.status),
       started_at_ms: first.t,
       elapsed_s: runComplete?.elapsed_s ?? Math.max(0, Math.round((last.t - first.t) / 1000)),
       last_event_at_ms: last.t,
@@ -56232,7 +56862,10 @@ function renderJson(jobs, nodes, trees, _all, epicReadiness, args, health) {
       context_health: job.context_health,
       startup_payload_json: job.startup_payload_json ?? null,
       payload_kb: formatPayloadStats2(job.startup_payload_json).payload_kb,
-      payload_tokens: formatPayloadStats2(job.startup_payload_json).payload_tokens
+      payload_tokens: formatPayloadStats2(job.startup_payload_json).payload_tokens,
+      attention_reasons: [
+        ...job.pr_classification && job.pr_classification !== "clean" ? [`pr_drift:${job.pr_classification}`] : []
+      ]
     })),
     nodes,
     trees,
@@ -56272,6 +56905,8 @@ function render(args) {
       return false;
     if (mineBeadIds && (!job.bead_id || !mineBeadIds.has(job.bead_id)))
       return false;
+    if (args.needsAttention && (!job.pr_classification || job.pr_classification === "clean"))
+      return false;
     const cleaned = isPsCleaned2(job);
     if (args.all)
       return true;
@@ -56280,7 +56915,7 @@ function render(args) {
     if (cleaned && args.includeCleaned && TERMINAL_STATES2.includes(job.status))
       return true;
     if (job.is_dead)
-      return false;
+      return true;
     if (ACTIVE_STATES2.includes(job.status))
       return true;
     if (args.active)
@@ -57101,6 +57736,8 @@ function getHumanEventKey2(event) {
       return `finish_reason:${event.finish_reason}:${event.source}`;
     case "turn_summary":
       return `turn_summary:${event.turn_index}`;
+    case "text":
+      return `text:${event.seq ?? ""}:${event.char_count ?? ""}:${event.content?.slice(0, 80) ?? ""}`;
     case "compaction":
     case "retry":
       return `${event.type}:${event.phase}`;
@@ -59522,7 +60159,7 @@ var exports_clean = {};
 __export(exports_clean, {
   run: () => run27
 });
-import { existsSync as existsSync37, readFileSync as readFileSync34, readdirSync as readdirSync18, rmSync as rmSync6, statSync as statSync12 } from "fs";
+import { existsSync as existsSync37, readFileSync as readFileSync34, readdirSync as readdirSync18, rmSync as rmSync7, statSync as statSync12 } from "fs";
 import { join as join42 } from "path";
 function parseDuration2(raw) {
   const match = /^(\d+)(ms|s|m|h|d)$/i.exec(raw.trim());
@@ -59932,6 +60569,30 @@ async function reapStaleSpecialistJobs(jobs, dryRun) {
         } catch {}
       } catch {}
     }
+    if (job.reason === "terminal-alive") {
+      try {
+        process.kill(-job.pid, "SIGTERM");
+      } catch (err) {
+        if (err?.code !== "ESRCH") {
+          try {
+            process.kill(job.pid, "SIGTERM");
+          } catch {}
+        }
+      }
+      await new Promise((resolve11) => setTimeout(resolve11, 500));
+      try {
+        process.kill(job.pid, 0);
+        try {
+          process.kill(-job.pid, "SIGKILL");
+        } catch {
+          try {
+            process.kill(job.pid, "SIGKILL");
+          } catch {}
+        }
+      } catch {}
+      reapedCount += 1;
+      continue;
+    }
     sqliteClient.markSpecialistJobCancelled(job.jobId, `cleanup: stale-reaper:${job.reason}`);
     reapedCount += 1;
   }
@@ -59949,7 +60610,7 @@ function printStaleJobSummary(reapedCount) {
 }
 function deleteJobDirectories(jobs) {
   for (const job of jobs) {
-    rmSync6(job.directoryPath, { recursive: true, force: true });
+    rmSync7(job.directoryPath, { recursive: true, force: true });
   }
   return jobs.length;
 }
@@ -60582,7 +61243,7 @@ var init_attach = __esm(() => {
 });
 
 // src/specialist/drift-detector.ts
-import { existsSync as existsSync38, readFileSync as readFileSync35, readdirSync as readdirSync19, rmSync as rmSync7 } from "fs";
+import { existsSync as existsSync38, readFileSync as readFileSync35, readdirSync as readdirSync19, rmSync as rmSync8 } from "fs";
 import { join as join43, resolve as resolve11, relative as relative3 } from "path";
 function listFiles(root) {
   if (!existsSync38(root))
@@ -60678,7 +61339,7 @@ function pruneStaleDefaults(repoRoot, dryRun, keepDiverged = false) {
   const targets = detectDriftForRepo(repoRoot).filter((f) => f.scope === "default" && (keepDiverged ? f.bytes_equal === true : true)).map((f) => f.path);
   if (!dryRun) {
     for (const target of targets)
-      rmSync7(target, { recursive: true, force: true });
+      rmSync8(target, { recursive: true, force: true });
   }
   return targets;
 }
@@ -61000,6 +61661,162 @@ async function run34() {
 }
 var bold12 = (s) => `\x1B[1m${s}\x1B[0m`, dim13 = (s) => `\x1B[2m${s}\x1B[0m`, yellow11 = (s) => `\x1B[33m${s}\x1B[0m`, cyan7 = (s) => `\x1B[36m${s}\x1B[0m`, blue4 = (s) => `\x1B[34m${s}\x1B[0m`, green13 = (s) => `\x1B[32m${s}\x1B[0m`;
 
+// src/specialist/pr-drift-refresh.ts
+import { execSync as execSync6 } from "child_process";
+import { createHash as createHash6 } from "crypto";
+function hashSummary(input2) {
+  return createHash6("sha256").update(input2).digest("hex").slice(0, 16);
+}
+function parsePrNumberFromUrl(prUrl) {
+  const match = prUrl.match(/\/pull\/(\d+)$/);
+  if (match)
+    return match[1];
+  if (/^\d+$/.test(prUrl))
+    return prUrl;
+  return;
+}
+function deriveClassification(raw) {
+  const mergeState = (raw.mergeStateStatus ?? "").toUpperCase();
+  const state = (raw.state ?? "").toLowerCase();
+  if (state === "merged" || state === "closed")
+    return "stale";
+  switch (mergeState) {
+    case "BEHIND":
+      return "needs-rebase";
+    case "DIRTY":
+      return "conflicted";
+    case "BLOCKED":
+      return "blocked";
+    case "CLEAN":
+    case "HAS_HOOKS":
+    case "UNSTABLE":
+      return "clean";
+    default:
+      return "unknown";
+  }
+}
+function classifyError(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  const lower = msg.toLowerCase();
+  if (lower.includes("enoent") || lower.includes("command not found") || lower.includes("no such file")) {
+    return { kind: "gh_unavailable", summary: hashSummary(msg) };
+  }
+  if (lower.includes("not found") || lower.includes("could not resolve")) {
+    return { kind: "no_pr", summary: hashSummary(msg) };
+  }
+  if (lower.includes("json") || lower.includes("parse")) {
+    return { kind: "parse_error", summary: hashSummary(msg) };
+  }
+  if (lower.includes("timeout") || lower.includes("econnrefused") || lower.includes("network")) {
+    return { kind: "network", summary: hashSummary(msg) };
+  }
+  return { kind: "network", summary: hashSummary(msg) };
+}
+async function refreshPrDriftForJob(opts) {
+  const { jobId, prUrl, headSha, client } = opts;
+  const now = Date.now();
+  const prNumber = parsePrNumberFromUrl(prUrl);
+  if (!prNumber) {
+    const patch2 = { pr_classification: "unknown", pr_drift_checked_at_ms: now };
+    client.updatePrDriftState(jobId, patch2);
+    return { ok: false, classification: "unknown", error_kind: "parse_error", error_summary: hashSummary("unparseable-pr-url") };
+  }
+  let stdout;
+  try {
+    stdout = execSync6(`gh pr view ${prNumber} --json state,mergeable,mergeStateStatus,baseRefName,baseRefOid,headRefOid,url`, { encoding: "utf8", timeout: 1e4, stdio: ["ignore", "pipe", "pipe"] });
+  } catch (err) {
+    const { kind, summary } = classifyError(err);
+    const patch2 = { pr_classification: "unknown", pr_drift_checked_at_ms: now };
+    client.updatePrDriftState(jobId, patch2);
+    return { ok: false, classification: "unknown", error_kind: kind, error_summary: summary };
+  }
+  let raw;
+  try {
+    raw = JSON.parse(stdout.trim());
+  } catch (err) {
+    const summary = hashSummary(err instanceof Error ? err.message : String(err));
+    const patch2 = { pr_classification: "unknown", pr_drift_checked_at_ms: now };
+    client.updatePrDriftState(jobId, patch2);
+    return { ok: false, classification: "unknown", error_kind: "parse_error", error_summary: summary };
+  }
+  const classification = deriveClassification(raw);
+  const patch = {
+    pr_url: raw.url ?? prUrl,
+    pr_head_sha: raw.headRefOid ?? headSha ?? null,
+    pr_state: raw.state ?? null,
+    pr_merge_state: raw.mergeStateStatus ?? null,
+    pr_classification: classification,
+    pr_base_ref: raw.baseRefName ?? null,
+    pr_base_sha: raw.baseRefOid ?? null,
+    pr_drift_checked_at_ms: now
+  };
+  client.updatePrDriftState(jobId, patch);
+  return { ok: true, classification, raw };
+}
+var init_pr_drift_refresh = () => {};
+
+// src/specialist/dead-job-audit.ts
+function defaultIsPidAlive2(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error2) {
+    if (error2 instanceof Error && "code" in error2 && error2.code === "ESRCH") {
+      return false;
+    }
+    return true;
+  }
+}
+function auditDeadJobs(opts) {
+  const dryRun = opts.dryRun ?? false;
+  const nowMs = opts.nowMs ?? Date.now();
+  const isPidAlive2 = opts.isPidAlive ?? defaultIsPidAlive2;
+  const minAgeMs = opts.minAgeMs ?? 60000;
+  const rows = opts.client.listStaleSpecialistJobs({ minAgeMs, nowMs });
+  const found = [];
+  let cancelled = 0;
+  for (const row of rows) {
+    if (isPidAlive2(row.pid))
+      continue;
+    const age_ms = Math.max(0, nowMs - row.updated_at_ms);
+    found.push({
+      job_id: row.job_id,
+      pid: row.pid,
+      reason: "container-restart-orphan",
+      age_ms
+    });
+    if (!dryRun) {
+      opts.client.markSpecialistJobCancelled(row.job_id, "container-restart-orphan");
+      cancelled += 1;
+      opts.client.appendForensicEvent(row.job_id, row.specialist, row.bead_id ?? undefined, createForensicEvent({
+        event_family: "lifecycle",
+        event_name: "dead_declared",
+        resource: {
+          service_namespace: "xtrm",
+          service_name: "specialists",
+          service_component: "dead-job-audit",
+          deployment_environment: "development",
+          repo: "specialists",
+          participant_kind: "specialist",
+          participant_role: row.specialist
+        },
+        correlation: { job_id: row.job_id, bead_id: row.bead_id ?? undefined },
+        body: {
+          job_id: row.job_id,
+          pid: row.pid,
+          age_ms,
+          reason: "container-restart-orphan",
+          dry_run: dryRun
+        }
+      }));
+    }
+  }
+  return { dryRun, found, cancelled };
+}
+var init_dead_job_audit = __esm(() => {
+  init_forensic_events();
+});
+
 // src/cli/doctor.ts
 var exports_doctor = {};
 __export(exports_doctor, {
@@ -61011,7 +61828,7 @@ __export(exports_doctor, {
   compareVersions: () => compareVersions2,
   cleanupProcesses: () => cleanupProcesses
 });
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 import { spawnSync as spawnSync23 } from "child_process";
 import { existsSync as existsSync39, lstatSync as lstatSync2, mkdirSync as mkdirSync15, readdirSync as readdirSync20, readFileSync as readFileSync36, readlinkSync as readlinkSync3, writeFileSync as writeFileSync19 } from "fs";
 import { dirname as dirname16, join as join44, relative as relative4, resolve as resolve13 } from "path";
@@ -61191,7 +62008,7 @@ function checkVersion() {
   return true;
 }
 function hashFile(path3) {
-  const hash = createHash6("sha256");
+  const hash = createHash7("sha256");
   hash.update(readFileSync36(path3));
   return hash.digest("hex");
 }
@@ -61524,7 +62341,7 @@ function checkClaudeMdFragments() {
   return allOk;
 }
 function parseDoctorArgs(argv) {
-  const opts = { json: false, drift: false, specialists: false };
+  const opts = { json: false, drift: false, specialists: false, pr_drift: false, reap_dead_jobs: false, dry_run: false };
   for (let i = 0;i < argv.length; i += 1) {
     const token = argv[i];
     if (token === "--json") {
@@ -61539,6 +62356,18 @@ function parseDoctorArgs(argv) {
       opts.specialists = true;
       continue;
     }
+    if (token === "--pr-drift") {
+      opts.pr_drift = true;
+      continue;
+    }
+    if (token === "--reap-dead-jobs") {
+      opts.reap_dead_jobs = true;
+      continue;
+    }
+    if (token === "--dry-run") {
+      opts.dry_run = true;
+      continue;
+    }
     if (token === "--root") {
       const value = argv[i + 1];
       if (!value || value.startsWith("--"))
@@ -61833,6 +62662,128 @@ function checkZombieJobs() {
   }
   return result.zombies === 0;
 }
+async function runDoctorPrDrift(json) {
+  const client = createObservabilitySqliteClient();
+  if (!client) {
+    if (json) {
+      console.log(JSON.stringify({ jobs: [], error: "observability sqlite unavailable" }));
+    } else {
+      console.error("observability sqlite unavailable");
+    }
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const jobs = client.listJobsNeedingPrDriftRefresh();
+    const results = [];
+    for (const job of jobs) {
+      const startedAt = Date.now();
+      console.error(JSON.stringify({
+        component: "pr_drift",
+        event: "refresh_attempted",
+        job_id: job.job_id,
+        duration_ms: 0,
+        gh_stderr_hash: "",
+        branch: job.branch ?? null,
+        checked_at_ms: startedAt
+      }));
+      const result = await refreshPrDriftForJob({
+        jobId: job.job_id,
+        prUrl: job.pr_url,
+        headSha: job.pr_head_sha ?? undefined,
+        client
+      });
+      const durationMs = Date.now() - startedAt;
+      const classification = result.classification;
+      const ghStderrHash = result.error_summary ? result.error_summary.slice(0, 8) : "";
+      const eventOut = {
+        component: "pr_drift",
+        event: result.ok ? "refresh_completed" : "refresh_failed",
+        job_id: job.job_id,
+        duration_ms: durationMs,
+        gh_stderr_hash: ghStderrHash,
+        pr_classification: classification,
+        branch: job.branch ?? null,
+        checked_at_ms: startedAt
+      };
+      console.error(JSON.stringify(eventOut));
+      results.push({
+        job_id: job.job_id,
+        classification,
+        pr_url: job.pr_url,
+        ...result.error_kind ? { error_kind: result.error_kind } : {},
+        duration_ms: durationMs
+      });
+    }
+    if (json) {
+      console.log(JSON.stringify({ jobs: results }, null, 2));
+    } else {
+      console.log(`
+${bold13("specialists doctor --pr-drift")}
+`);
+      if (results.length === 0) {
+        ok3("No PR-linked jobs need drift refresh");
+      } else {
+        for (const r of results) {
+          const icon = r.classification === "clean" ? green14("\u2713") : r.classification === "needs-rebase" ? yellow12("\u25CB") : r.classification === "conflicted" ? red7("\u2717") : r.classification === "blocked" ? yellow12("\u25A0") : r.classification === "stale" ? dim14("\u25CB") : yellow12("?");
+          const suffix = r.error_kind ? ` ${dim14(`(${r.error_kind})`)}` : "";
+          console.log(`  ${icon} ${r.job_id}  ${r.classification}${suffix}`);
+        }
+      }
+      console.log("");
+    }
+  } finally {
+    client.close();
+  }
+}
+async function runDoctorReapDeadJobs(opts) {
+  const client = createObservabilitySqliteClient();
+  if (!client) {
+    if (opts.json) {
+      console.log(JSON.stringify({ dryRun: opts.dry_run, found: [], cancelled: 0, error: "observability sqlite unavailable" }));
+    } else {
+      console.error("observability sqlite unavailable");
+    }
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const result = auditDeadJobs({
+      client,
+      dryRun: opts.dry_run,
+      nowMs: Date.now()
+    });
+    for (const finding of result.found) {
+      const structuredLog = {
+        component: "dead_job_audit",
+        event: "dead_declared",
+        job_id: finding.job_id,
+        age_ms: finding.age_ms,
+        dry_run: opts.dry_run
+      };
+      console.error(JSON.stringify(structuredLog));
+    }
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(`
+${bold13("specialists doctor --reap-dead-jobs")}
+`);
+      if (result.found.length === 0) {
+        ok3("No dead running/waiting jobs found");
+      } else {
+        const action = opts.dry_run ? "Would cancel" : "Cancelled";
+        console.log(`  ${yellow12("\u25CB")} ${result.found.length} dead job(s) found (${result.cancelled} ${action})`);
+        for (const f of result.found) {
+          console.log(`    - ${f.job_id} pid=${f.pid} age=${Math.round(f.age_ms / 1000)}s`);
+        }
+      }
+      console.log("");
+    }
+  } finally {
+    client.close();
+  }
+}
 async function run35(argv = process.argv.slice(3)) {
   const subcommand = argv[0];
   if (subcommand === "orphans") {
@@ -61844,6 +62795,10 @@ async function run35(argv = process.argv.slice(3)) {
     renderDriftTable(opts.root ?? process.cwd(), opts.json);
     return;
   }
+  if (opts.pr_drift) {
+    await runDoctorPrDrift(opts.json);
+    return;
+  }
   if (opts.specialists) {
     console.log(`
 ${bold13("specialists doctor --specialists")}
@@ -61853,6 +62808,10 @@ ${bold13("specialists doctor --specialists")}
     process.exitCode = overridesOk2 ? 0 : 1;
     return;
   }
+  if (opts.reap_dead_jobs) {
+    await runDoctorReapDeadJobs(opts);
+    return;
+  }
   if (subcommand && subcommand !== "--help" && subcommand !== "-h" && !subcommand.startsWith("--")) {
     console.error(`Unknown doctor subcommand: '${subcommand}'`);
     process.exit(1);
@@ -61887,8 +62846,10 @@ ${bold13("specialists doctor")}
 var bold13 = (s) => `\x1B[1m${s}\x1B[0m`, dim14 = (s) => `\x1B[2m${s}\x1B[0m`, green14 = (s) => `\x1B[32m${s}\x1B[0m`, yellow12 = (s) => `\x1B[33m${s}\x1B[0m`, red7 = (s) => `\x1B[31m${s}\x1B[0m`, CWD, CLAUDE_DIR, PI_DIR, XTRM_SKILLS_DIR, XTRM_DEFAULT_SKILLS_DIR, XTRM_ACTIVE_SKILLS_DIR, SPECIALISTS_DIR, DEFAULT_SPECIALISTS_DIR, USER_SPECIALISTS_DIR, HOOKS_DIR, CLAUDE_HOOKS_DIR, SETTINGS_FILE, MCP_FILE2, HOOK_NAMES;
 var init_doctor = __esm(() => {
   init_observability_sqlite();
+  init_pr_drift_refresh();
   init_canonical_asset_resolver();
   init_drift_detector();
+  init_dead_job_audit();
   init_loader();
   init_version_check();
   CWD = process.cwd();
@@ -62067,7 +63028,7 @@ var init_benchmarks = __esm(() => {
 });
 
 // src/specialist/model-probes.ts
-import { createHash as createHash7, randomUUID as randomUUID6 } from "crypto";
+import { createHash as createHash8, randomUUID as randomUUID6 } from "crypto";
 import { mkdirSync as mkdirSync17, readdirSync as readdirSync21, readFileSync as readFileSync38, writeFileSync as writeFileSync21 } from "fs";
 import { homedir as homedir11 } from "os";
 import { dirname as dirname18, join as join46, resolve as resolve14 } from "path";
@@ -62177,7 +63138,7 @@ function getProbeRunDir(model, specName, cacheDir = join46(homedir11(), ".cache"
   return resolve14(getProbeCanonicalPath(model, specName, cacheDir).replace(/\.json$/u, ""), randomUUID6());
 }
 function getProbeCanonicalPath(model, specName, cacheDir = join46(homedir11(), ".cache", "specialists", "probes")) {
-  const probeId = createHash7("sha256").update(`${model}\x00${specName}\x00${PROBE_TEMPLATE}`).digest("hex").slice(0, 12);
+  const probeId = createHash8("sha256").update(`${model}\x00${specName}\x00${PROBE_TEMPLATE}`).digest("hex").slice(0, 12);
   return join46(cacheDir, `${sanitizePathSegment(model)}-${sanitizePathSegment(specName)}-${probeId}.json`);
 }
 function sanitizePathSegment(value) {
@@ -62822,7 +63783,7 @@ import { createServer } from "http";
 import { randomUUID as randomUUID7 } from "crypto";
 import { once } from "events";
 import { spawnSync as spawnSync25 } from "child_process";
-import { access, readdir as readdir2, readFile as readFile5, constants } from "fs/promises";
+import { access, readdir as readdir2, readFile as readFile4, constants } from "fs/promises";
 import { existsSync as existsSync42 } from "fs";
 import { homedir as homedir12 } from "os";
 import { join as join48 } from "path";
@@ -62850,7 +63811,7 @@ async function checkUserDirSpecs(userDir) {
   let validCount = 0;
   for (const file of specFiles) {
     try {
-      const content = await readFile5(join48(userDir, file), "utf-8");
+      const content = await readFile4(join48(userDir, file), "utf-8");
       const json = file.endsWith(".json") ? content : null;
       if (!json)
         continue;
@@ -71559,8 +72520,18 @@ async function run40() {
         "  --epic <id>          Explicit epic membership for this job. Defaults to bead.parent.",
         "                       Useful for prep jobs belonging to a merge-gated epic.",
         "  --force-job          Bypass concurrency guard for active worktrees (MEDIUM/HIGH).",
-        "  --force-stale-base   Bypass stale-base guard when epic sibling chains have unmerged",
-        "                       substantive commits. Use at risk of later merge conflicts.",
+        "  --base-sha <sha>     Pin the base SHA the run measures against (specialists-05q.3).",
+        "                       Recorded on the job observability row as base_sha_pinned.",
+        "                       When omitted, defaults to the observed remote base tip.",
+        "  --base-ref <branch>  Base branch ref to fetch before pinning (default: origin/HEAD).",
+        "                       Combined with --base-sha for deterministic precondition checks.",
+        "  --accept-stale-base  Override the stale-base precondition gate. Requires --reason.",
+        "                       Logged in stderr + auditable via the structured refusal envelope",
+        "                       (specialists-05q.3). Prefer over deprecated --force-stale-base.",
+        "  --reason <text>      Required justification when --accept-stale-base is set.",
+        "                       Surfaced in stderr audit line + refusal envelope.",
+        "  --force-stale-base   [deprecated] Alias for --accept-stale-base with default reason.",
+        "                       Emits a deprecation warning; removal in a future release.",
         "",
         "Examples:",
         "  specialists run debugger --bead unitAI-55d",
@@ -72226,6 +73197,8 @@ async function run40() {
         "  7. zombie job detection",
         "  8. CLAUDE.md fragments (XTRM-MANAGED sentinels) \u2014 delegates to xt claude-sync",
         "  9. drift check for stale managed mirrors (--check-drift / --drift)",
+        " 10. PR drift refresh for tracked jobs (--pr-drift) \u2014 specialists-05q.2",
+        " 11. dead-job audit + reap orphans (--reap-dead-jobs [--dry-run]) \u2014 specialists-05q.4",
         "",
         "Behavior:",
         "  - prints fix hints for failing checks",
@@ -72237,10 +73210,26 @@ async function run40() {
         "                            Category A (specialists runtime) and Category B",
         "                            (filesystem skills/hooks) are distinct; doctor",
         "                            covers Category A only",
+        "  --pr-drift               Refresh PR/base drift state for tracked jobs by",
+        "                            shelling out to `gh pr view --json` (specialists-05q.2).",
+        "                            Iterates jobs whose pr_drift_checked_at_ms is stale or null;",
+        "                            updates pr_state/pr_merge_state/pr_classification/pr_base_sha.",
+        "                            Classifications: clean | needs-rebase | conflicted | blocked |",
+        "                            stale | unknown. gh failures classify as unknown (never throws).",
+        "  --reap-dead-jobs         Audit specialist_jobs rows in active states with dead pids",
+        "                            and mark them cancelled with reason container-restart-orphan",
+        "                            (specialists-05q.4). Emits xtrm.forensic.v1 lifecycle.dead_declared",
+        "                            event per finding. Conservative predicate: all of {active status,",
+        "                            pid set, ESRCH dead pid, age > 60s} must hold.",
+        "    --dry-run              Pair with --reap-dead-jobs: list findings without mutation.",
+        "    --json                 Emit JSON envelope { dryRun, found:[{job_id, pid, reason,",
+        "                            age_ms}], cancelled }.",
         "",
         "Examples:",
         "  specialists doctor",
         "  specialists doctor orphans",
+        "  specialists doctor --pr-drift",
+        "  specialists doctor --reap-dead-jobs --dry-run --json",
         ""
       ].join(`
 `));