@getpipher/armory-fleet 0.2.0 → 0.4.0

package/agents/general-purpose-cc.md

@@ -0,0 +1,11 @@
+---
+name: general-purpose-cc
+description: A focused general-purpose CC subagent. Use for any task needing Claude Code as the worker.
+backend: claude
+todoSync: true
+memoryHydrate: true
+vision: true
+---
+You are a focused subagent delegate running under Claude Code. Complete the assigned task
+thoroughly, work autonomously to completion, and return a concise result summary.
+Do not call the `todo` tool — the fleet engine manages todo tracking for you.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpipher/armory-fleet",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "private": false,
   "description": "The armory suite's subagent orchestrator for the pi coding agent — a cross-harness, superpowers-native fleet where every agent is armory-native from birth.",
   "license": "MIT",

package/src/backend/claude-detector.ts

@@ -0,0 +1,75 @@
+// src/backend/claude-detector.ts — version + stream-json schema smoke + flag-support probe (SPEC-3 §5).
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mapClaudeEvent } from "./claude-events.ts";
+import type { BackendVersionInfo } from "./registry.ts";
+
+const DEFAULT_BIN = "claude";
+
+export interface DetectOpts {
+  /** Fixture hook: an arg passed to the fake-claude via FLEET_FAKE_CLAUDE_PROBE env to select init-ok/init-drift. */
+  schemaProbeArg?: string;
+}
+
+function run(bin: string, args: string[], env?: NodeJS.ProcessEnv): Promise<{ stdout: string; stderr: string; code: number | null }> {
+  return new Promise((resolve) => {
+    const child = spawn(bin, args, { env: { ...process.env, ...env }, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (d) => { stdout += d.toString(); });
+    child.stderr?.on("data", (d) => { stderr += d.toString(); });
+    child.on("close", (code) => resolve({ stdout, stderr, code }));
+    // Capture the spawn error message into stderr so the caller can detect ENOENT (binary missing).
+    child.on("error", (err) => resolve({ stdout: "", stderr: err.message, code: null }));
+  });
+}
+
+function parseVersion(stdout: string): string {
+  const m = stdout.trim().match(/(\d+\.\d+\.\d+)/);
+  return m && m[1] ? m[1] : stdout.trim();
+}
+
+function probeFlags(helpText: string): Record<string, boolean> {
+  const has = (flag: string): boolean => new RegExp(`(^|\\s)${flag.replace(/-/g, "\\-")}(\\s|$)`).test(helpText);
+  return {
+    "--disallowed-tools": has("--disallowed-tools"),
+    "--allowed-tools": has("--allowed-tools"),
+    "--max-turns": has("--max-turns"),
+    "--resume": has("--resume"),
+    "--append-system-prompt": has("--append-system-prompt"),
+    "--output-format": has("--output-format"),
+  };
+}
+
+export async function detectClaude(bin: string = DEFAULT_BIN, opts: DetectOpts = {}): Promise<BackendVersionInfo | null> {
+  // Missing binary check: for an explicit path that doesn't exist, return null;
+  // for the default `claude` on PATH, the version run below resolves ENOENT → null.
+  if (bin !== DEFAULT_BIN && !existsSync(bin)) return null;
+  const versionRun = await run(bin, ["--version"]);
+  if (versionRun.code === null && /ENOENT/i.test(versionRun.stderr)) return null;
+  if (versionRun.code !== 0 && !versionRun.stdout) {
+    return { version: "", schemaOk: false, flagSupport: {}, note: `claude --version failed (code ${versionRun.code})` };
+  }
+  const version = parseVersion(versionRun.stdout);
+
+  // Schema smoke: spawn a throwaway ping in stream-json mode; scan the lines for a `system/init` event with session_id.
+  // (Real CC emits hook_started/hook_response system events before init; first-line-only would false-fail.)
+  const env = opts.schemaProbeArg ? { FLEET_FAKE_CLAUDE_PROBE: opts.schemaProbeArg } : undefined;
+  const smoke = await run(bin, ["-p", "--verbose", "--output-format", "stream-json", "ping"], env);
+  let schemaOk = false;
+  let note: string | undefined;
+  const lines = smoke.stdout.split("\n").filter((l) => l.trim());
+  for (const line of lines) {
+    const ev = mapClaudeEvent(line);
+    if (ev && ev.type === "session_init" && ev.backendSessionId) { schemaOk = true; break; }
+  }
+  if (!schemaOk) {
+    note = lines.length ? `schema drift (no init event with session_id; first line: ${lines[0]!.slice(0, 80)})` : "schema drift (no output emitted)";
+  }
+
+  // Flag-support probe (only meaningful if --help works).
+  const helpRun = await run(bin, ["--help"]);
+  const flagSupport = helpRun.code === 0 ? probeFlags(helpRun.stdout) : {};
+
+  return { version, schemaOk, flagSupport, note };
+}

package/src/backend/claude-events.ts

@@ -0,0 +1,39 @@
+// src/backend/claude-events.ts — map one CC stream-json NDJSON line → ChildSessionEvent (SPEC-3 §4.2).
+// Returns null for: filtered echoes (our own user writes), unknown types, malformed lines.
+// The caller logs null-but-parseable lines at debug (forward-compat: CC may add types we don't need).
+import type { ChildSessionEvent } from "../engine/spawnSubagent.ts";
+
+interface CCMessage { role?: string; content?: Array<{ type: string; text?: string }>; usage?: Record<string, unknown>; }
+interface CCEvent { type: string; subtype?: string; session_id?: string; message?: CCMessage; error?: { message?: string }; }
+
+export function mapClaudeEvent(line: string): ChildSessionEvent | null {
+  let ev: CCEvent;
+  try {
+    ev = JSON.parse(line) as CCEvent;
+  } catch {
+    return null; // malformed line — resilient
+  }
+  switch (ev.type) {
+    case "system":
+      if (ev.subtype === "init" && typeof ev.session_id === "string") {
+        return { type: "session_init", backendSessionId: ev.session_id };
+      }
+      return null;
+    case "assistant": {
+      const msg = ev.message;
+      if (!msg) return null;
+      const content = (msg.content ?? []).map((c) => ({ type: c.type, text: c.text }));
+      const usage = msg.usage as { cost?: { total?: number } } | undefined;
+      return { type: "message_end", message: { role: msg.role ?? "assistant", content, usage } };
+    }
+    case "result":
+      // turn boundary (success or error_max_turns) → turn_end drives the budget
+      return { type: "turn_end" };
+    case "error":
+      return { type: "error", message: { role: "error", content: [{ type: "text", text: ev.error?.message ?? "claude error" }] } };
+    case "user":
+      return null; // echo of our own stdin write — filtered
+    default:
+      return null; // unknown — forward-compat, caller logs at debug
+  }
+}

package/src/backend/claude-factory.ts

@@ -0,0 +1,50 @@
+// src/backend/claude-factory.ts — createClaudeChildFactory (SPEC-3 §4.1, §4.5, §4.6, §9.1).
+import { spawn, type ChildProcess } from "node:child_process";
+import type { ChildSessionFactory, ChildSessionOpts } from "../engine/spawnSubagent.ts";
+import type { BackendVersionInfo } from "./registry.ts";
+import type { ResumeStore } from "./resume-store.ts";
+import { ClaudeChildSession } from "./claude-session.ts";
+import { memoryScopesFor } from "../engine/child-loader.ts";
+
+export interface ClaudeFactoryOverrides {
+  /** Test hook: called instead of `spawn` to inspect args. Returns a ChildProcess-shaped stub. */
+  spawnOverride?: (args: string[]) => ChildProcess;
+}
+
+export function createClaudeChildFactory(
+  detector: BackendVersionInfo | null,
+  resumeStore: ResumeStore,
+  bin: string = "claude",
+  overrides: ClaudeFactoryOverrides = {},
+): ChildSessionFactory {
+  return {
+    async create(opts: ChildSessionOpts): Promise<{ session: ClaudeChildSession; model: string }> {
+      if (!detector?.schemaOk) {
+        throw new Error(`claude backend unavailable: ${detector?.note ?? "schema not ok"}`);
+      }
+      const memoryBlock = opts.agent.memoryHydrate ? opts.memoryPort.renderScopes(memoryScopesFor(opts.cwd)) : "";
+      const sys = memoryBlock ? `${opts.rolePrompt}\n\n${memoryBlock}` : opts.rolePrompt;
+      const resumeId = resumeStore.get("claude", opts.agent.sessionKey);
+
+      const args: string[] = ["-p", "--output-format", "stream-json", "--input-format", "stream-json", "--verbose"];
+      if (opts.model) args.push("--model", opts.model);
+      args.push("--append-system-prompt", sys);
+      // todo exclusion: prefer --disallowed-tools; fall back to --allowed-tools allow-list when the agent pins tools.
+      if (detector.flagSupport["--disallowed-tools"]) {
+        args.push("--disallowed-tools", "todo");
+      } else if (detector.flagSupport["--allowed-tools"] && opts.tools.length) {
+        const allowed = opts.tools.filter((t) => t !== "todo").join(",");
+        args.push("--allowed-tools", allowed);
+      }
+      // v0.3 leaves maxTurns to the engine's turn_end belt (no --max-turns flag; avoids double-enforcement).
+      if (resumeId && detector.flagSupport["--resume"]) args.push("--resume", resumeId);
+      args.push(opts.task);
+
+      const proc = overrides.spawnOverride
+        ? overrides.spawnOverride(args)
+        : spawn(bin, args, { cwd: opts.cwd, stdio: ["pipe", "pipe", "pipe"] });
+      const session = new ClaudeChildSession(proc, opts.agent.sessionKey, resumeStore);
+      return { session, model: opts.model ?? "" };
+    },
+  };
+}

package/src/backend/claude-session.ts

@@ -0,0 +1,75 @@
+// src/backend/claude-session.ts — ChildSession over a claude -p child process (SPEC-3 §4.4, §4.3).
+import type { ChildProcess } from "node:child_process";
+import { createInterface } from "node:readline";
+import type { ChildSession, ChildSessionEvent } from "../engine/spawnSubagent.ts";
+import { mapClaudeEvent } from "./claude-events.ts";
+import type { ResumeStore } from "./resume-store.ts";
+
+export class ClaudeChildSession implements ChildSession {
+  private readonly proc: ChildProcess;
+  private readonly sessionKey: string;
+  private readonly resumeStore: ResumeStore;
+  private readonly handlers: Array<(e: ChildSessionEvent) => void> = [];
+  private disposed = false;
+  private initCaptured = false;
+  private turnResolve: (() => void) | null = null;
+
+  constructor(proc: ChildProcess, sessionKey: string, resumeStore: ResumeStore) {
+    this.proc = proc;
+    this.sessionKey = sessionKey;
+    this.resumeStore = resumeStore;
+    const rl = createInterface({ input: proc.stdout! });
+    rl.on("line", (line) => this.onLine(line));
+    proc.on("close", () => { if (this.turnResolve) { const r = this.turnResolve; this.turnResolve = null; r(); } });
+  }
+
+  private onLine(line: string): void {
+    const ev = mapClaudeEvent(line);
+    if (!ev) return;
+    if (ev.type === "session_init" && ev.backendSessionId && !this.initCaptured) {
+      this.initCaptured = true;
+      this.resumeStore.set("claude", this.sessionKey, ev.backendSessionId);
+    }
+    if (ev.type === "turn_end" || ev.type === "error") {
+      if (this.turnResolve) { const r = this.turnResolve; this.turnResolve = null; r(); }
+    }
+    for (const h of this.handlers) h(ev);
+  }
+
+  async prompt(text: string): Promise<void> {
+    if (this.disposed) throw new Error("session disposed");
+    if (!this.proc.stdin) throw new Error("claude child has no stdin pipe");
+    const msg = JSON.stringify({ type: "user", message: { role: "user", content: [{ type: "text", text }] } }) + "\n";
+    return new Promise<void>((resolve) => {
+      this.turnResolve = resolve;
+      this.proc.stdin!.write(msg, () => { /* fire-and-forget; resolved on turn_end/close */ });
+    });
+  }
+
+  subscribe(handler: (e: ChildSessionEvent) => void): () => void {
+    this.handlers.push(handler);
+    return () => {
+      const i = this.handlers.indexOf(handler);
+      if (i >= 0) this.handlers.splice(i, 1);
+    };
+  }
+
+  async abort(): Promise<void> {
+    if (this.disposed) return;
+    try { this.proc.kill("SIGTERM"); } catch { /* already dead */ }
+    this.disposed = true;   // SIGTERM kills the child process; the session is irrecoverable
+  }
+
+  dispose(): void {
+    if (this.disposed) return;
+    this.disposed = true;
+    try { this.proc.kill("SIGKILL"); } catch { /* already dead */ }
+    this.proc.stdout?.destroy();
+    try { this.proc.stdin?.end(); } catch { /* already closed */ }
+    this.proc.removeAllListeners();
+  }
+
+  isDisposed(): boolean {
+    return this.disposed;
+  }
+}

package/src/backend/hook-parity.ts

@@ -0,0 +1,19 @@
+// src/backend/hook-parity.ts — declared per-backend hook parity (SPEC-3 §2.3, §4.6).
+// The chip is a static backend property, never inferred at spawn time.
+
+export type HookState = "✓" | "~";
+
+export interface BackendHookParity {
+  /** `todo` tool excluded from the child. */
+  todo: HookState;
+  /** memory-hydrate (3-scope) active in the child. */
+  memory: HookState;
+  /** vision: capability-aware. `✓` = full (describe_image fallback); `~` = pass-through only. */
+  vision: HookState;
+}
+
+/** Pi backend: full moat via loader injection + customTools (SPEC-2). */
+export const PI_HOOK_PARITY: BackendHookParity = { todo: "✓", memory: "✓", vision: "✓" };
+
+/** CC backend: moat via prompt/flag translation. Vision has no describe_image fallback (`~`). */
+export const CLAUDE_HOOK_PARITY: BackendHookParity = { todo: "✓", memory: "✓", vision: "~" };

package/src/backend/port.ts

@@ -0,0 +1,5 @@
+// src/backend/port.ts — single import surface for engine + views (SPEC-3 §3).
+export type { BackendHookParity, HookState } from "./hook-parity.ts";
+export { PI_HOOK_PARITY, CLAUDE_HOOK_PARITY } from "./hook-parity.ts";
+export type { Backend, BackendVersionInfo } from "./registry.ts";
+export { BackendRegistry } from "./registry.ts";

package/src/backend/registry.ts

@@ -0,0 +1,36 @@
+// src/backend/registry.ts — BackendRegistry + Backend descriptor (SPEC-3 §2.1).
+import type { ChildSessionFactory } from "../engine/spawnSubagent.ts";
+import type { BackendHookParity } from "./hook-parity.ts";
+
+export interface BackendVersionInfo {
+  version: string;
+  schemaOk: boolean;
+  /** Flag support matrix probed at detect time (kebab-case flag → supported?). */
+  flagSupport: Record<string, boolean>;
+  note?: string;
+}
+
+export interface Backend {
+  id: "pi" | "claude";
+  factory: ChildSessionFactory;
+  available: () => boolean;
+  versionInfo: () => BackendVersionInfo | null;
+  hookParity: BackendHookParity;
+}
+
+export class BackendRegistry {
+  private readonly backends = new Map<string, Backend>();
+  private readonly order: string[] = [];
+
+  register(b: Backend): void {
+    if (!this.backends.has(b.id)) this.order.push(b.id);
+    this.backends.set(b.id, b);
+  }
+  get(id: string): Backend | undefined {
+    return this.backends.get(id);
+  }
+  /** Registration-order list — the data source for the Backends view + engine lookup. */
+  list(): Backend[] {
+    return this.order.map((id) => this.backends.get(id)!).filter(Boolean);
+  }
+}

package/src/backend/resume-store.ts

@@ -0,0 +1,44 @@
+// src/backend/resume-store.ts — file-backed sessionKey → backendSessionId, per backend (SPEC-3 §2.4, §4.3).
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+function rootDir(): string {
+  return process.env.FLEET_RESUME_ROOT ?? join(process.env.HOME ?? "/tmp", ".pi", "agent", "cache", "fleet-resume");
+}
+
+/** Per-backend JSON map: { [sessionKey]: backendSessionId }. */
+function fileFor(backendId: string): string {
+  return join(rootDir(), `${backendId}.json`);
+}
+
+function readMap(backendId: string): Record<string, string> {
+  const f = fileFor(backendId);
+  if (!existsSync(f)) return {};
+  try {
+    return JSON.parse(readFileSync(f, "utf8")) as Record<string, string>;
+  } catch {
+    return {};
+  }
+}
+
+function writeMap(backendId: string, m: Record<string, string>): void {
+  const dir = rootDir();
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(fileFor(backendId), JSON.stringify(m, null, 2));
+}
+
+export class ResumeStore {
+  get(backendId: string, sessionKey: string): string | null {
+    return readMap(backendId)[sessionKey] ?? null;
+  }
+  set(backendId: string, sessionKey: string, backendSessionId: string): void {
+    const m = readMap(backendId);
+    m[sessionKey] = backendSessionId;
+    writeMap(backendId, m);
+  }
+  clear(backendId: string, sessionKey: string): void {
+    const m = readMap(backendId);
+    delete m[sessionKey];
+    writeMap(backendId, m);
+  }
+}

package/src/engine/run-registry.ts

@@ -12,6 +12,10 @@ export interface RunRecord {
   startedAt: number;
   endedAt?: number;
   resultSummary?: string;
+  /** Backend-native session id for resume (SPEC-3). */
+  backendSessionId?: string | null;
+  /** The sessionKey whose resume this run belongs to (SPEC-3). */
+  sessionKey?: string | null;
 }
 
 /** runId format: fl-<base36 ms>-<6 random> (SPEC-1 §5.1). */

package/src/engine/spawnSubagent.ts

@@ -3,6 +3,7 @@ import type { AgentDef, ThinkingLevel } from "../registry/frontmatter.ts";
 import type { FleetRunStatus, TodoSyncPort } from "../todo-sync/port.ts";
 import type { MemoryHydratePort } from "../memory-hydrate/port.ts";
 import type { VisionPort } from "../vision/port.ts";
+import type { BackendRegistry } from "../backend/port.ts";
 import { genRunId, RunRegistry } from "./run-registry.ts";
 import { createTurnBudget, DEFAULT_MAX_TURNS } from "./turn-budget.ts";
 import type { SingleSlotLock } from "./concurrency-lock.ts";
@@ -25,6 +26,8 @@ export interface ChildSessionEvent {
     content?: Array<{ type: string; text?: string }>;
     usage?: { cost?: { total?: number } };
   };
+  /** Emitted by a backend on session init (SPEC-3). Drives runRecord.backendSessionId. */
+  backendSessionId?: string;
 }
 
 export interface ChildSession {
@@ -62,13 +65,22 @@ export interface SpawnOptions {
   todoSync: TodoSyncPort;
   runRegistry: RunRegistry;
   lock: SingleSlotLock;
-  childFactory: ChildSessionFactory;
+  backendRegistry: BackendRegistry;   // SPEC-3: replaces childFactory — engine looks up by agentDef.backend
   parentModel: { provider: string; id: string };
   parentCwd: string;
   memoryPort?: MemoryHydratePort;
   visionPort?: VisionPort;
   signal?: AbortSignal;
   onEvent?: (e: ChildSessionEvent) => void;
+  /** SPEC-4: when set, this spawn is a lifecycle phase child. It links to this lifecycle todo
+   *  (not creates a new one) and finishRun skips mark-done/revert — the lifecycle engine owns
+   *  the lifecycle todo's status + progress block. */
+  lifecycleTodoId?: string;
+  /** SPEC-4: when set (lifecycle phase child), override the agent's `skills` frontmatter with
+   *  the lifecycle's merged phase skill bundle (Q1=B) + route to the phase's resolved backend
+   *  (Q4=C) instead of the agent's `backend`. */
+  skillsOverride?: string[];
+  backendOverride?: "pi" | "claude";
 }
 
 export interface SpawnResult {
@@ -107,12 +119,24 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
       return fail(runId, startedAt, `agent '${opts.agent}' not in registry; available: ${available}`, opts.agent);
     }
 
+    // SPEC-3: route via the backend registry; fail fast if the backend is missing/unavailable.
+    // SPEC-4: a lifecycle phase child may override the backend (Q4=C) + the skill bundle (Q1=B).
+    const backendId = opts.backendOverride ?? agentDef.backend;
+    const backend = opts.backendRegistry.get(backendId);
+    if (!backend || !backend.available()) {
+      const note = backend?.versionInfo()?.note ?? "not registered";
+      return fail(runId, startedAt, `backend '${backendId}' unavailable: ${note}`, opts.agent);
+    }
+    // SPEC-4: when a lifecycle provides a skills override, clone the agentDef so the factory's
+    // skillsOverride (buildChildLoader reads agent.skills) loads the phase's bundle, not the agent's.
+    const childAgent = opts.skillsOverride ? { ...agentDef, skills: opts.skillsOverride } : agentDef;
+
     // resolve model
     const model = opts.model ?? agentDef.model ?? `${opts.parentModel.provider}/${opts.parentModel.id}`;
 
     // child tools pass through UNFILTERED — the single-writer `todo`-exclusion is enforced
     // downstream by the child factory's `excludeTools: ["todo"]` (SPEC-2 §9.1 hardening).
-    const tools = agentDef.tools ?? PI_DEFAULT_TOOLS;
+    const tools = childAgent.tools ?? PI_DEFAULT_TOOLS;
     const memoryPort = opts.memoryPort ?? NOOP_MEMORY_PORT;
     const visionPort = opts.visionPort ?? NOOP_VISION_PORT;
 
@@ -128,7 +152,7 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
     try {
       const link = await opts.todoSync.linkOrCreateRunTodo({
         runId, agent: agentDef.name, task: opts.task,
-        todoId: opts.todoId, track: track && agentDef.todoSync,
+        todoId: opts.lifecycleTodoId ?? opts.todoId, track: track && agentDef.todoSync,
       });
       todoId = link.todoId;
       priorStatus = link.priorStatus;
@@ -138,15 +162,15 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
     }
 
     // spawn child
-    const { session } = await opts.childFactory.create({
+    const { session } = await backend.factory.create({
       cwd: opts.parentCwd,
       model,
-      thinkingLevel: agentDef.thinkingLevel,
+      thinkingLevel: childAgent.thinkingLevel,
       tools,
-      rolePrompt: agentDef.rolePrompt,
-      skills: agentDef.skills ?? [],
+      rolePrompt: childAgent.rolePrompt,
+      skills: childAgent.skills ?? [],
       task: opts.task,
-      agent: agentDef,
+      agent: childAgent,
       memoryPort,
       visionPort,
     });
@@ -160,7 +184,9 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
     opts.signal?.addEventListener("abort", onSignalAbort);
 
     const unsub = session.subscribe((e) => {
-      if (e.type === "turn_end") {
+      if (e.type === "session_init" && e.backendSessionId) {
+        opts.runRegistry.update(runId, { backendSessionId: e.backendSessionId, sessionKey: agentDef.sessionKey });
+      } else if (e.type === "turn_end") {
         if (budget.consume()) void session.abort();
       } else if (e.type === "message_end" && e.message?.role === "assistant") {
         const text = e.message.content?.map((c) => (c.type === "text" ? c.text ?? "" : "")).join("") ?? "";
@@ -217,15 +243,18 @@ async function finishRun(
 ): Promise<SpawnResult> {
   const endedAt = Date.now();
   opts.runRegistry.update(runId, { status, endedAt, resultSummary: finalText.slice(0, 120) });
-  // todo-sync reconciliation must not mask the run result
-  try {
-    if (status === "completed") {
-      await opts.todoSync.markRunTodoDone(todoId, priorStatus, finalText.slice(0, 500));
-    } else {
-      await opts.todoSync.markRunTodoReverted(todoId, priorStatus, error ?? status);
+  // SPEC-4: lifecycle phase children skip the per-run todo reconciliation — the lifecycle
+  // engine owns the lifecycle todo's status + progress block (Q7=C).
+  if (!opts.lifecycleTodoId) {
+    try {
+      if (status === "completed") {
+        await opts.todoSync.markRunTodoDone(todoId, priorStatus, finalText.slice(0, 500));
+      } else {
+        await opts.todoSync.markRunTodoReverted(todoId, priorStatus, error ?? status);
+      }
+    } catch {
+      // swallow — the run result is authoritative; the finally in spawnSubagent releases the lock
     }
-  } catch {
-    // swallow — the run result is authoritative; the finally in spawnSubagent releases the lock
   }
   return {
     status, finalText, runId, todoId, agent: agentName, model,