@getpipher/armory-fleet 0.10.2 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpipher/armory-fleet",
-  "version": "0.10.2",
+  "version": "0.11.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-session.ts

@@ -72,4 +72,9 @@ export class ClaudeChildSession implements ChildSession {
   isDisposed(): boolean {
     return this.disposed;
   }
+
+  /** SPEC-6-2: cross-process liveness probe — is the claude child proc still running? */
+  isAlive(): boolean {
+    return !this.disposed && this.proc.killed === false && this.proc.exitCode === null && this.proc.signalCode === null;
+  }
 }

package/src/engine/run-registry.ts

@@ -1,6 +1,7 @@
 // src/engine/run-registry.ts
 import type { FleetRunStatus } from "../todo-sync/port.ts";
 import type { LiveSessionHandle } from "./spawnSubagent.ts";
+import type { BackendId } from "../lifecycle/lifecycle-types.ts";
 
 export interface RunRecord {
   runId: string;
@@ -29,6 +30,12 @@ export interface RunRecord {
   contextTokens?: number;
   /** SPEC-6-1: the tier name this run used (for Tiers-view "used by" + per-tier spend). */
   tier?: string;
+  /** SPEC-6-2: the cwd this run belongs to (widget cross-cwd filter + reconcile ownership). */
+  cwd: string;
+  /** SPEC-6-2: the backend (probe dispatch: pi→handle, claude→pid). */
+  backend: BackendId;
+  /** SPEC-6-2: claude-backend child PID (cross-process liveness probe). */
+  pid?: number;
   /** SPEC-5b-4: live session handle while status === "running"; cleared by finishRun.
    *  Transient, in-memory only — never written to RunLog (the journal append constructs
    *  a plain object, not RunRecord). */

package/src/engine/spawnSubagent.ts

@@ -54,6 +54,8 @@ export interface ChildSession {
   steer?(text: string): Promise<void>;
   /** SPEC-5b-4: optional live streaming flag. Pi backend forwards the native SDK getter; claude omits. */
   readonly isStreaming?: boolean;
+  /** SPEC-6-2: is the underlying session still active (not disposed/ended/killed)? */
+  isAlive?(): boolean;
 }
 
 /** SPEC-5b-4: narrow live-session handle retained on RunRecord while status === "running".
@@ -65,6 +67,8 @@ export interface LiveSessionHandle {
   subscribe(handler: (e: ChildSessionEvent) => void): () => void;
   readonly isStreaming: boolean;
   readonly supportsSteer: boolean;
+  /** SPEC-6-2: is the underlying session still active (not disposed/ended/killed)? */
+  isAlive(): boolean;
 }
 
 /** SPEC-5b-4: wrap a ChildSession into a narrow LiveSessionHandle for the panel.
@@ -76,6 +80,8 @@ export function toLiveHandle(session: ChildSession): LiveSessionHandle {
     subscribe: (h) => session.subscribe(h),
     get isStreaming() { return session.isStreaming ?? false; },
     get supportsSteer() { return typeof session.steer === "function"; },
+    isAlive: () => typeof (session as { isAlive?: () => boolean }).isAlive === "function"
+      ? (session as { isAlive: () => boolean }).isAlive() : true,
   };
 }
 
@@ -212,10 +218,8 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
       runId, agent: agentDef.name, model, task: opts.task, track,
       todoId: null, status: "running", startedAt,
       tier: tier?.name, costTotal: 0, contextTokens: 0,
+      cwd: opts.parentCwd, backend: backendId,
     });
-    try {
-      opts.runLog?.append(runId, { type: "run:meta", runId, agent: agentDef.name, model, task: opts.task, startedAt, track, todoId: null });
-    } catch { /* best-effort: journal is the index, not the product */ }
 
     // todo-sync (before) — only when both caller tracks AND agent allows todoSync
     let priorStatus: string | undefined;
@@ -280,7 +284,7 @@ export async function spawnSubagent(opts: SpawnOptions): Promise<SpawnResult> {
       if (e.type === "session_init" && e.backendSessionId) {
         opts.runRegistry.update(runId, { backendSessionId: e.backendSessionId, sessionKey: agentDef.sessionKey });
         try {
-          opts.runLog?.append(runId, { type: "run:meta", runId, agent: agentDef.name, model, task: opts.task, startedAt, track, todoId, backendSessionId: e.backendSessionId, sessionKey: agentDef.sessionKey });
+          opts.runLog?.append(runId, { type: "run:meta", runId, agent: agentDef.name, model, task: opts.task, startedAt, track, todoId, backendSessionId: e.backendSessionId, sessionKey: agentDef.sessionKey, cwd: opts.parentCwd, pid: (session as { proc?: { pid?: number } }).proc?.pid });
         } catch { /* best-effort */ }
       } else if (e.type === "turn_start") {
         turnIdx++;
@@ -355,11 +359,26 @@ function fail(runId: string, startedAt: number, message: string, agent: string):
   };
 }
 
+/** SPEC-6-2: guard against double-finishRun (abort-then-complete). */
+const finalizedRunIds = new Set<string>();
+
 async function finishRun(
   opts: SpawnOptions, runId: string, startedAt: number,
   status: FleetRunStatus, finalText: string, todoId: string | null, priorStatus: string | undefined,
   error: string | undefined, agentName: string, model: string, tokenTotal = 0, costTotal = 0, contextTokens = 0,
 ): Promise<SpawnResult> {
+  if (finalizedRunIds.has(runId)) {
+    // Already finalized — return the existing registry record's result without re-appending.
+    const existing = opts.runRegistry.get(runId);
+    return {
+      status: existing?.status ?? status, finalText: existing?.resultSummary ?? finalText,
+      runId, todoId, agent: agentName, model,
+      durationMs: existing?.endedAt ? existing.endedAt - startedAt : Date.now() - startedAt,
+      tokenTotal, costTotal, contextTokens, error,
+    };
+  }
+  finalizedRunIds.add(runId);
+
   const endedAt = Date.now();
   opts.runRegistry.update(runId, {
     status, endedAt, resultSummary: finalText.slice(0, 120),

package/src/index.ts

@@ -42,6 +42,8 @@ import { reconcileRuns } from "./runtime/reconcile.ts";
 import { Scheduler } from "./scheduling/scheduler.ts";
 import { createFleetResultsTool } from "./tools/fleet-results.ts";
 import { BgRunsStore } from "./panel/bg-runs-store.ts";
+import { GateRegistry } from "./lifecycle/gates/registry.ts";
+import { registerBuiltinGates } from "./lifecycle/gates/builtin.ts";
 import { FleetWidgetController } from "./panel/fleet-widget.ts";
 import { TierRegistry, mergeTiers } from "./tiers/tier-registry.ts";
 import { BUILTIN_TIERS } from "./tiers/builtin.ts";
@@ -177,6 +179,20 @@ export default async function (pi: ExtensionAPI): Promise<void> {
   // Builtin-only placeholder tier registry so spawn works before session_start rebuilds with merged tiers.
   deps.tierRegistry = new TierRegistry({ tiers: BUILTIN_TIERS, agents: deps.registry });
 
+  // SPEC-6-2: gate registry + builtin gate registration.
+  const gateRegistry = new GateRegistry();
+  registerBuiltinGates(gateRegistry);
+  // Wire gate deps into lifecycleDeps (both the async + foreground lifecycle sites spread from lifecycleDeps).
+  deps.lifecycleDeps.gateRegistry = gateRegistry;
+  deps.lifecycleDeps.getGateCtxState = (todoId: string, _agentName: string) => {
+    const runs = deps.runRegistry.list().filter((r) => r.todoId === todoId);
+    const lifecycleCost = runs.reduce((s, r) => s + (r.costTotal ?? 0), 0);
+    const contextTokens = runs.reduce((max, r) => Math.max(max, r.contextTokens ?? 0), 0);
+    const tierName = runs.find((r) => r.tier)?.tier;
+    const tier = tierName ? deps.tierRegistry?.get(tierName) : undefined;
+    return { lifecycleCost, contextTokens, tier };
+  };
+
   // ── SPEC-5a: operational runtime (async/bg + scheduling + worktree isolation) ──
   const fleetDir = (cwd: string) => join(cwd, ".pi", "fleet");
   const bgRuns = new BgRunsStore();
@@ -274,6 +290,7 @@ export default async function (pi: ExtensionAPI): Promise<void> {
       notify: (m, lvl) => ctx.ui.notify(m, lvl),
       genRunId: () => "fl-" + Date.now().toString(36) + "-" + Math.random().toString(36).slice(2, 8),
       onProgress: (runId, status) => { bgRuns.set(runId, status); },
+      runRegistry: deps.runRegistry,
     };
     deps.scheduler = new Scheduler({
       storePath: join(dir, "schedules.json"),
@@ -295,12 +312,16 @@ export default async function (pi: ExtensionAPI): Promise<void> {
       return sharedModelRegistry.find(provider, id)?.contextWindow;
     };
     deps.getModelContextWindow = getModelContextWindow;
+    // SPEC-6-2: thread getModelContextWindow into lifecycle deps for gate ctx.
+    deps.lifecycleDeps.getModelContextWindow = getModelContextWindow;
     fleetWidget = new FleetWidgetController({
       runRegistry: deps.runRegistry,
       bgRuns,
       ui: ctx.ui as never,
       getTheme: () => ctx.ui.theme,
       getModelContextWindow,
+      cwd: ctx.cwd,
+      runLog: deps.runLog,
     });
     fleetWidget.start();
 
@@ -390,4 +411,13 @@ export default async function (pi: ExtensionAPI): Promise<void> {
       ctx.ui.notify(`lifecycle ${res.status}: ${res.runId}${res.error ? " — " + res.error : ""}`, res.status === "completed" ? "info" : "warning");
     },
   });
+
+  // SPEC-6-2: gate extensibility — pi doesn't expose registerGate, so we provide a command
+  // so other extensions can register custom gates at runtime.
+  pi.registerCommand("fleet-register-gate", {
+    description: "Register a custom gate on the fleet gate registry (extensibility path).",
+    handler: async (_args, ctx) => {
+      ctx.ui.notify("fleet-register-gate: custom gates must be registered via the GateRegistry module export (see src/lifecycle/gates/registry.ts).", "info");
+    },
+  });
 }

package/src/lifecycle/default.ts

@@ -24,10 +24,12 @@ phases:
     skills: [writing-plans]
     agent: general-purpose
     checkpoint: true
+    gates: [completenessCheck]
   - name: implement
     skills: [executing-plans, test-driven-development, verification-before-completion]
     agent: general-purpose
     checkpoint: false
+    gates: [verification-before-completion, completenessCheck, gate]
   - name: review
     skills: [requesting-code-review, receiving-code-review]
     agent: general-purpose
@@ -35,6 +37,7 @@ phases:
   - name: finish
     skills: [finishing-a-development-branch]
     agent: general-purpose
+    challengeStep: false
 ---
 
 ## brainstorm

package/src/lifecycle/gates/builtin.ts

@@ -0,0 +1,14 @@
+// src/lifecycle/gates/builtin.ts
+import type { GateRegistry } from "./registry.ts";
+import { verificationBeforeCompletionGate } from "./verification-before-completion.ts";
+import { completenessCheckGate } from "./completeness-check.ts";
+import { gateGate } from "./gate.ts";
+import { verifyGate } from "./verify.ts";
+
+/** Register the 4 builtin gates on a GateRegistry. */
+export function registerBuiltinGates(reg: GateRegistry): void {
+  reg.register(verificationBeforeCompletionGate);
+  reg.register(completenessCheckGate);
+  reg.register(gateGate);
+  reg.register(verifyGate);
+}

package/src/lifecycle/gates/chain-runner.ts

@@ -0,0 +1,37 @@
+import type { GateDef, GateCtx, GateResult } from "./registry.ts";
+
+export interface GateChainOutcome {
+  results: GateResult[];
+  shortCircuit?: { action: "revise" | "abort"; feedback?: string; reason?: string };
+}
+
+/** Run the gate chain left-to-right. Advise-failures continue; revise/abort short-circuit. */
+export async function runGateChain(opts: { gates: GateDef[]; ctx: GateCtx }): Promise<GateChainOutcome> {
+  const results: GateResult[] = [];
+  for (const gate of opts.gates) {
+    // Each gate sees its own params on ctx.gateParams (set per-gate by the caller/run-lifecycle).
+    const gateCtx: GateCtx = { ...opts.ctx, gateParams: gate.params };
+    const started = Date.now();
+    let result: GateResult;
+    let crashed = false;
+    try {
+      result = await gate.run(gateCtx);
+    } catch (e) {
+      // A throwing gate is treated as an advise-failure (never auto-revise on a crash).
+      crashed = true;
+      result = { gate: gate.name, kind: gate.kind, passed: false, evidence: `gate '${gate.name}' threw: ${(e as Error).message}`, onFail: "advise" };
+    }
+    result.durationMs = Date.now() - started;
+    results.push(result);
+    if (!crashed && !result.passed) {
+      if (gate.onFail === "revise") {
+        return { results, shortCircuit: { action: "revise", feedback: result.evidence } };
+      }
+      if (gate.onFail === "abort") {
+        return { results, shortCircuit: { action: "abort", reason: result.evidence } };
+      }
+      // advise → continue
+    }
+  }
+  return { results };
+}

package/src/lifecycle/gates/completeness-check.ts

@@ -0,0 +1,36 @@
+import { existsSync, statSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+import type { GateDef, GateCtx, GateResult } from "./registry.ts";
+
+export interface CompletenessResult { passed: boolean; evidence: string; }
+
+/** Pure-ish: stat every claimed path. Relative paths resolve against baseDir. */
+export function checkCompleteness(paths: string[], baseDir: string): CompletenessResult {
+  if (paths.length === 0) return { passed: true, evidence: "no claimed artifacts (terminal-phase exemption)" };
+  const missing: string[] = [];
+  let found = 0;
+  for (const p of paths) {
+    const abs = isAbsolute(p) ? p : resolve(baseDir, p);
+    try {
+      statSync(abs);
+      found++;
+    } catch {
+      missing.push(p);
+    }
+  }
+  if (missing.length > 0) {
+    return { passed: false, evidence: `missing: ${missing.join(", ")} (${found}/${paths.length} exist)` };
+  }
+  return { passed: true, evidence: `${paths.length}/${paths.length} artifacts exist` };
+}
+
+export const completenessCheckGate: GateDef = {
+  name: "completenessCheck",
+  kind: "predicate",
+  onFail: "revise",
+  run: async (ctx: GateCtx): Promise<GateResult> => {
+    const base = ctx.worktreePath ?? process.cwd();
+    const r = checkCompleteness(ctx.phaseRec.paths, base);
+    return { gate: "completenessCheck", kind: "predicate", passed: r.passed, evidence: r.evidence, onFail: "revise" };
+  },
+};

package/src/lifecycle/gates/gate.ts

@@ -0,0 +1,41 @@
+import type { GateDef, GateCtx, GateResult } from "./registry.ts";
+import type { Tier } from "../../tiers/tier-registry.ts";
+
+export interface BudgetInput {
+  lifecycleCost: number;
+  contextTokens: number;
+  tier?: Tier;
+  params?: Record<string, unknown>;
+}
+export interface BudgetResult { passed: boolean; evidence: string; }
+
+/** Pure: assert cost < cap and context < floor. Missing tier/caps → skip (pass). */
+export function assertBudget(input: BudgetInput): BudgetResult {
+  const { lifecycleCost, contextTokens, tier, params } = input;
+  if (!tier) return { passed: true, evidence: "no tier → no caps to assert (skip)" };
+  const costCap = typeof (params as { costCap?: number } | undefined)?.costCap === "number"
+    ? (params as { costCap: number }).costCap : tier.costCap;
+  const contextFloor = typeof (params as { contextFloor?: number } | undefined)?.contextFloor === "number"
+    ? (params as { contextFloor: number }).contextFloor : tier.contextFloor;
+  const parts: string[] = [];
+  if (typeof costCap === "number") {
+    if (lifecycleCost > costCap) return { passed: false, evidence: `cost $${lifecycleCost.toFixed(2)} > cap $${costCap.toFixed(2)}` };
+    parts.push(`cost $${lifecycleCost.toFixed(2)} < cap $${costCap.toFixed(2)}`);
+  }
+  if (typeof contextFloor === "number") {
+    if (contextTokens > contextFloor) return { passed: false, evidence: `context ${contextTokens} > floor ${contextFloor}` };
+    parts.push(`ctx ${contextTokens} < floor ${contextFloor}`);
+  }
+  if (parts.length === 0) return { passed: true, evidence: "tier has no costCap/contextFloor → nothing to assert" };
+  return { passed: true, evidence: parts.join("; ") };
+}
+
+export const gateGate: GateDef = {
+  name: "gate",
+  kind: "predicate",
+  onFail: "abort",
+  run: async (ctx: GateCtx): Promise<GateResult> => {
+    const r = assertBudget({ lifecycleCost: ctx.lifecycleCost, contextTokens: ctx.contextTokens, tier: ctx.tier, params: ctx.gateParams });
+    return { gate: "gate", kind: "predicate", passed: r.passed, evidence: r.evidence, onFail: "abort" };
+  },
+};

package/src/lifecycle/gates/registry.ts

@@ -0,0 +1,75 @@
+import type { PhaseRecord } from "../lifecycle-types.ts";
+import type { SpawnResult } from "../../engine/spawnSubagent.ts";
+import type { SpawnFn } from "../run-lifecycle.ts";
+import type { BackendId } from "../lifecycle-types.ts";
+import type { Tier } from "../../tiers/tier-registry.ts";
+
+export type GateKind = "agent" | "predicate";
+export type GateOnFail = "advise" | "revise" | "abort";
+
+/** What a phase declares in frontmatter. String = name only; object = name + overrides. */
+export type GateRef = string | { name: string; onFail?: GateOnFail; params?: Record<string, unknown> };
+
+/** A resolved gate definition (registry entry + phase overrides applied). */
+export interface GateDef {
+  name: string;
+  kind: GateKind;
+  onFail: GateOnFail;
+  params?: Record<string, unknown>;
+  run: (ctx: GateCtx) => Promise<GateResult>;
+}
+
+export interface GateCtx {
+  phaseRec: PhaseRecord;
+  spawnRes: SpawnResult;
+  lifecycle: { name: string; task: string; todoId: string; backend: BackendId };
+  tier?: Tier;
+  /** Sum of costTotal across all runs linked to this lifecycle's todoId. */
+  lifecycleCost: number;
+  contextTokens: number;
+  worktreePath?: string;
+  /** Agent gates use this to spawn the reviewer subagent. */
+  spawn: SpawnFn;
+  getModelContextWindow: (model: string) => number | undefined;
+  /** Per-gate params from the resolved GateDef (set by the chain runner). */
+  gateParams?: Record<string, unknown>;
+}
+
+export interface GateResult {
+  gate: string;
+  kind: GateKind;
+  passed: boolean;
+  evidence: string;
+  onFail: GateOnFail;
+  /** Agent gates only — the spawned run's costTotal. */
+  cost?: number;
+  /** Agent gates only — links to the /fleet row. */
+  runId?: string;
+  durationMs?: number;
+}
+
+export class GateRegistry {
+  private readonly byName = new Map<string, GateDef>();
+  register(def: GateDef): void {
+    if (this.byName.has(def.name)) throw new Error(`duplicate gate name '${def.name}'`);
+    this.byName.set(def.name, def);
+  }
+  get(name: string): GateDef | undefined { return this.byName.get(name); }
+  list(): GateDef[] { return [...this.byName.values()]; }
+}
+
+/** Resolve phase-declared GateRefs into GateDefs, applying per-phase onFail/params overrides. */
+export function resolveGates(refs: GateRef[] | undefined, reg: GateRegistry): GateDef[] {
+  if (!refs || refs.length === 0) return [];
+  return refs.map((ref) => {
+    const name = typeof ref === "string" ? ref : ref.name;
+    const base = reg.get(name);
+    if (!base) throw new Error(`unknown gate '${name}' (not in registry)`);
+    if (typeof ref === "string") return base;
+    return {
+      ...base,
+      ...(ref.onFail ? { onFail: ref.onFail } : {}),
+      ...(ref.params ? { params: { ...base.params, ...ref.params } } : {}),
+    };
+  });
+}

package/src/lifecycle/gates/verification-before-completion.ts

@@ -0,0 +1,50 @@
+import type { GateDef, GateCtx, GateResult } from "./registry.ts";
+
+/** Default patterns: a verification command invocation AND a result signal.
+ *  A command alone (no result) is a claim, not evidence. */
+const DEFAULT_COMMAND_PATTERNS: RegExp[] = [
+  /\b(pnpm|npm|yarn)\s+(test|test:run|typecheck|lint|build)\b/i,
+  /\b(typecheck|tsc|eslint|prettier)\b/i,
+  /\bgo\s+(test|build)\b/i, /\bcargo\s+(test|build)\b/i, /\brustc\b/i,
+  /\bpytest\b/i, /\bmvn\s+test\b/i,
+];
+const DEFAULT_RESULT_PATTERNS: RegExp[] = [
+  /\b\d+\s*(\/|of)?\s*\d*\s*(pass|passing)\b/i,
+  /\b0\s*(fail|failing|errors?|error)\b/i,
+  /\bexit\s*(code\s*)?(:|=|→)?\s*0\b/i,
+  /\bclean\b/i, /\bgreen\b/i, /\bok\b/i,
+  /\b\d+\s*pass(?:ing)?(?:[,\s]+0\s*fail)?\b/i,
+];
+
+export interface ScanResult { passed: boolean; evidence: string; }
+
+/** Pure: scan phase output for verification evidence (command + result). */
+export function scanVerificationEvidence(
+  text: string,
+  opts: { patterns?: RegExp[] } = {},
+): ScanResult {
+  const commands = opts.patterns ?? DEFAULT_COMMAND_PATTERNS;
+  // Custom patterns replace the command set; result detection stays the default unless
+  // the caller wants full control (they pass patterns that already encode the result).
+  const cmdMatch = commands.find((p) => p.test(text));
+  if (!cmdMatch) return { passed: false, evidence: "no verification command output found in phase output" };
+  // If custom patterns are provided, treat a command match as sufficient (the pattern encodes the result).
+  if (opts.patterns) return { passed: true, evidence: `found evidence matching ${cmdMatch}` };
+  const resultMatch = DEFAULT_RESULT_PATTERNS.find((p) => p.test(text));
+  if (!resultMatch) return { passed: false, evidence: `verification command found (${cmdMatch}) but no pass/exit result signal — show the command output` };
+  // Extract a compact snippet around the command.
+  const idx = text.search(cmdMatch);
+  const snippet = text.slice(Math.max(0, idx - 10), Math.min(text.length, idx + 80)).replace(/\s+/g, " ").trim();
+  return { passed: true, evidence: `found: ${snippet}` };
+}
+
+export const verificationBeforeCompletionGate: GateDef = {
+  name: "verification-before-completion",
+  kind: "predicate",
+  onFail: "revise",
+  run: async (ctx: GateCtx): Promise<GateResult> => {
+    const patterns = (ctx.gateParams as { patterns?: RegExp[] } | undefined)?.patterns;
+    const r = scanVerificationEvidence(ctx.spawnRes.finalText, patterns ? { patterns } : {});
+    return { gate: "verification-before-completion", kind: "predicate", passed: r.passed, evidence: r.evidence, onFail: "revise" };
+  },
+};

package/src/lifecycle/gates/verify.ts

@@ -0,0 +1,47 @@
+import type { GateDef, GateCtx, GateResult } from "./registry.ts";
+import type { SpawnResult } from "../../engine/spawnSubagent.ts";
+
+const FAILURE_MARKERS = /\b(does not meet|not meet|missing|incomplete|not addressed|fails?|broken|incorrect)\b/i;
+
+/** Pure: judge a reviewer's text for a passed/failed verdict. */
+export function judgeReview(text: string): { passed: boolean } {
+  return { passed: !FAILURE_MARKERS.test(text) };
+}
+
+/** Pure: build the reviewer subagent prompt. */
+export function buildVerifyPrompt(ctx: GateCtx): string {
+  return [
+    "You are an independent reviewer. Review this phase's output against the task + plan.",
+    `Task: ${ctx.lifecycle.task}`,
+    `Phase: ${ctx.phaseRec.name}`,
+    `Phase summary: ${ctx.phaseRec.summary}`,
+    `Artifacts: ${ctx.phaseRec.paths.join(", ") || "(none)"}`,
+    "Did it meet the requirement? What's missing? Be specific. End with a verdict: 'meets the requirement' or 'does not meet the requirement'.",
+  ].join("\n");
+}
+
+export const verifyGate: GateDef = {
+  name: "verify",
+  kind: "agent",
+  onFail: "advise",
+  run: async (ctx: GateCtx): Promise<GateResult> => {
+    const reviewerAgent = (ctx.gateParams as { agent?: string } | undefined)?.agent ?? "reviewer";
+    const prompt = buildVerifyPrompt(ctx);
+    let spawnRes: SpawnResult;
+    try {
+      spawnRes = await ctx.spawn({ agent: reviewerAgent, task: prompt, lifecycleTodoId: ctx.lifecycle.todoId, skills: [], backend: ctx.lifecycle.backend });
+    } catch (e) {
+      return { gate: "verify", kind: "agent", passed: false, evidence: `reviewer spawn failed: ${(e as Error).message}`, onFail: "advise" };
+    }
+    if (spawnRes.status === "failed") {
+      return { gate: "verify", kind: "agent", passed: false, evidence: `reviewer spawn failed: ${spawnRes.error ?? spawnRes.finalText.slice(0, 120)}`, onFail: "advise" };
+    }
+    const verdict = judgeReview(spawnRes.finalText);
+    return {
+      gate: "verify", kind: "agent", passed: verdict.passed,
+      evidence: spawnRes.finalText.slice(0, 2000), onFail: "advise",
+      ...(spawnRes.costTotal != null ? { cost: spawnRes.costTotal } : {}),
+      runId: spawnRes.runId,
+    };
+  },
+};

package/src/lifecycle/lifecycle-types.ts

@@ -1,6 +1,7 @@
 // src/lifecycle/lifecycle-types.ts
 import type { FleetRunStatus } from "../todo-sync/port.ts";
 import type { AgentSource } from "../registry/frontmatter.ts";
+import type { GateRef, GateResult } from "./gates/registry.ts";
 
 /** Backend id (mirrors SPEC-3 AgentDef.backend). */
 export type BackendId = "pi" | "claude";
@@ -22,6 +23,10 @@ export interface PhaseDef {
   checkpoint?: boolean;
   /** The phase prompt template (parsed from the `## <name>` body section). */
   promptTemplate: string;
+  /** SPEC-6-2: opt out of the lifecycle-wide challenge-step prompt injection. Default true. */
+  challengeStep?: boolean;
+  /** SPEC-6-2: gates to run after this phase (before checkpoint). Array of GateRef. */
+  gates?: GateRef[];
 }
 
 export interface LifecycleDef {
@@ -41,6 +46,8 @@ export interface PhaseRecord {
   paths: string[];
   status: FleetRunStatus;
   reviseCount: number;
+  /** SPEC-6-2: gate results from this phase's gate chain (for panel rendering). */
+  gateResults?: GateResult[];
 }
 
 export interface LifecycleRunRecord {

package/src/lifecycle/prompt-template.ts

@@ -1,6 +1,15 @@
 // src/lifecycle/prompt-template.ts
 import type { PhaseRecord } from "./lifecycle-types.ts";
 
+export const CHALLENGE_STEP_BLOCK = [
+  "",
+  "## Challenge Step",
+  "After completing significant work, actively challenge your own output before presenting it.",
+  'Ask: "What could break? What did I miss? What would a critical reviewer flag?"',
+  "Fix what you find — don't just note it. Small single-line changes are exempt.",
+  "",
+].join("\n");
+
 export interface PromptVars {
   task: string;
   lifecycle: string;
@@ -9,6 +18,8 @@ export interface PromptVars {
   prev?: { name: string; summary: string; paths: string[] };
   /** On Revise only: human feedback + prior-attempt digest. */
   feedback?: string;
+  /** SPEC-6-2: opt out of challenge-step prompt injection. Default true (append). */
+  challengeStep?: boolean;
 }
 
 /** Render a phase prompt template. Supports {{task}}, {{lifecycle}}, {{phase}},
@@ -36,5 +47,6 @@ export function renderPhasePrompt(template: string, vars: PromptVars): string {
     .replace(/{{\s*prev\.paths\s*}}/g, pathsStr)
     .replace(/{{\s*feedback\s*}}/g, vars.feedback ?? "");
 
-  return out;
+  const challengeStep = vars.challengeStep !== false;  // default true
+  return challengeStep ? out + CHALLENGE_STEP_BLOCK : out;
 }

package/src/lifecycle/registry.ts

@@ -70,7 +70,22 @@ export function parseLifecycleFile(content: string, filePath: string, source: Ag
       pbackend = b as BackendId;
     }
     const checkpoint = po.checkpoint === undefined ? true : Boolean(po.checkpoint);
-    return { name: pname, skills, agent, backend: pbackend, checkpoint };
+    const challengeStep = po.challengeStep === undefined ? undefined : !po.challengeStep ? false : true;
+    let gates: import("./gates/registry.ts").GateRef[] | undefined;
+    if (po.gates !== undefined) {
+      if (!Array.isArray(po.gates)) {
+        throw new LifecycleParseError(`${filePath}: phase '${pname}' gates must be an array`);
+      }
+      gates = po.gates.map((g: unknown) => {
+        if (typeof g === "string") return g;
+        if (g && typeof g === "object") {
+          const go = g as Record<string, unknown>;
+          return { name: String(go.name), ...(go.onFail ? { onFail: String(go.onFail) as import("./gates/registry.ts").GateOnFail } : {}), ...(go.params ? { params: go.params as Record<string, unknown> } : {}) };
+        }
+        throw new LifecycleParseError(`${filePath}: phase '${pname}' gate entry must be string or object`);
+      });
+    }
+    return { name: pname, skills, agent, backend: pbackend, checkpoint, ...(challengeStep !== undefined ? { challengeStep } : {}), ...(gates ? { gates } : {}) };
   });
 
   // Split body into `## <phase>` sections. A phase with no matching section = error.

package/src/lifecycle/run-lifecycle.ts

@@ -5,6 +5,10 @@ import type { SpawnResult } from "../engine/spawnSubagent.ts";
 import type {
   BackendId, LifecycleDef, LifecycleMode, LifecycleStatus, PhaseRecord, CheckpointDecision,
 } from "./lifecycle-types.ts";
+import type { GateDef, GateCtx, GateResult, GateRegistry } from "./gates/registry.ts";
+import type { Tier } from "../tiers/tier-registry.ts";
+import { resolveGates } from "./gates/registry.ts";
+import { runGateChain } from "./gates/chain-runner.ts";
 import { renderPhasePrompt } from "./prompt-template.ts";
 import { parseArtifacts, MAX_REVISE } from "./artifacts-parser.ts";
 import {
@@ -36,6 +40,12 @@ export interface LifecycleRunDeps {
   /** SPEC-5a (Q3=A): when present, isolated runs use worktree-diff artifact discovery
    *  instead of the prompt-baked `Artifacts:` block parser. Foreground runs leave this undefined. */
   artifactDiscovery?: (o: { finalText: string; cwd: string; baseRef: string; terminal: boolean }) => { summary: string; paths: string[] } | { error: string };
+  /** SPEC-6-2: gate registry — when present + a phase has gates, the gate chain runs between parse-artifacts and checkpoint. */
+  gateRegistry?: GateRegistry;
+  /** SPEC-6-2: provides the gate chain's ctx extras (lifecycle cost, context tokens, tier). When absent, defaults to zeros. */
+  getGateCtxState?: (todoId: string, agentName: string) => { lifecycleCost: number; contextTokens: number; tier?: Tier };
+  /** SPEC-6-2: resolve a model's context window for the gate ctx. Optional — absent → undefined. */
+  getModelContextWindow?: (model: string) => number | undefined;
 }
 
 export interface LifecycleRunOpts {
@@ -63,8 +73,8 @@ export interface LifecycleRunResult {
   error?: string;
 }
 
-/** Human (or auto) decision at a checkpoint. */
-export type CheckpointFn = (phase: PhaseRecord) => Promise<CheckpointDecision>;
+/** Human (or auto) decision at a checkpoint. SPEC-6-2: widened to include gate results. */
+export type CheckpointFn = (phase: PhaseRecord, gateResults: GateResult[]) => Promise<CheckpointDecision>;
 
 export async function runLifecycle(task: string, lifecycleName: string, opts: LifecycleRunOpts): Promise<LifecycleRunResult> {
   const { deps } = opts;
@@ -133,6 +143,7 @@ export async function runLifecycle(task: string, lifecycleName: string, opts: Li
         task, lifecycle: lifecycleName, phase: phaseDef.name,
         prev: prev ? { name: prev.name, summary: prev.summary, paths: prev.paths } : undefined,
         feedback,
+        challengeStep: phaseDef.challengeStep,
       });
 
       // e/f: spawn the phase child (links to the lifecycle todo; skips mark-done/revert — Task 8).
@@ -171,6 +182,48 @@ export async function runLifecycle(task: string, lifecycleName: string, opts: Li
       // Capture this attempt's summary for the next revise iteration's feedback digest.
       priorAttemptSummary = phaseRec.summary;
 
+      // SPEC-6-2: gate chain — runs between parse-artifacts and checkpoint.
+      // If the gate chain short-circuits (revise/abort), we handle it here BEFORE the checkpoint.
+      let gateResults: GateResult[] = [];
+      if (phaseDef.gates && phaseDef.gates.length > 0 && deps.gateRegistry) {
+        const gates = resolveGates(phaseDef.gates, deps.gateRegistry);
+        const gateCtxState = deps.getGateCtxState?.(todoId, agentName) ?? { lifecycleCost: 0, contextTokens: 0 };
+        const gateCtx: GateCtx = {
+          phaseRec, spawnRes,
+          lifecycle: { name: lifecycleName, task, todoId, backend: lifecycleBackend },
+          tier: gateCtxState.tier,
+          lifecycleCost: gateCtxState.lifecycleCost,
+          contextTokens: gateCtxState.contextTokens,
+          worktreePath: opts.worktreePath,
+          spawn: deps.spawn,
+          getModelContextWindow: deps.getModelContextWindow ?? (() => undefined),
+        };
+        const outcome = await runGateChain({ gates, ctx: gateCtx });
+        gateResults = outcome.results;
+        phaseRec.gateResults = gateResults;
+        if (outcome.shortCircuit?.action === "revise") {
+          reviseCount++;
+          lastFeedback = outcome.shortCircuit.feedback;
+          if (reviseCount > MAX_REVISE) {
+            await updateProgress(deps.todoPort, todoId, {
+              phase: phaseDef.name, done: false, last: `gate revise budget exhausted (${MAX_REVISE})`, revising: false, attempt: reviseCount,
+            }, { lifecycle: lifecycleName, task, backend: lifecycleBackend, mode: opts.mode, phases: progressPhases });
+            phaseRecords.push(phaseRec);
+            return doneResult(runId, startedAt, "failed", lifecycleName, task, lifecycleBackend, opts.mode, phaseRecords, todoId,
+              `gate revise budget exhausted (${MAX_REVISE})`);
+          }
+          await updateProgress(deps.todoPort, todoId, {
+            phase: phaseDef.name, done: false, last: `gate revise (attempt ${reviseCount}/${MAX_REVISE}): ${outcome.shortCircuit.feedback?.slice(0, 80)}`, revising: true, attempt: reviseCount,
+          }, { lifecycle: lifecycleName, task, backend: lifecycleBackend, mode: opts.mode, phases: progressPhases });
+          continue; // re-run the phase
+        }
+        if (outcome.shortCircuit?.action === "abort") {
+          await revertLifecycleTodo(deps.todoPort, todoId, `gate aborted: ${outcome.shortCircuit.reason}`);
+          phaseRecords.push(phaseRec);
+          return doneResult(runId, startedAt, "failed", lifecycleName, task, lifecycleBackend, opts.mode, phaseRecords, todoId, outcome.shortCircuit.reason);
+        }
+      }
+
       // h: update the lifecycle todo progress block.
       await updateProgress(deps.todoPort, todoId, {
         phase: phaseDef.name, done: phaseRec.status === "completed",
@@ -186,7 +239,7 @@ export async function runLifecycle(task: string, lifecycleName: string, opts: Li
         break; // advance to next phase
       }
 
-      const decision = await opts.onCheckpoint(phaseRec);
+      const decision = await opts.onCheckpoint(phaseRec, gateResults);
       if (decision.action === "continue") {
         if (forceCheckpoint) {
           // cannot continue past a failure — treat as abort (guard against a misbehaving checkpoint fn)

package/src/panel/fleet-panel.ts

@@ -358,7 +358,7 @@ export class FleetPanel extends Container {
       this.fullMessageEvent
         ? "  esc:Back"
         : this.infoAgent || this.selectedBackend || this.selectedLifecycle || this.selectedSchedule || this.selectedRun
-          ? (this.selectedRun ? "  enter:Full-message  esc:Back" : "  esc:Back")
+          ? (this.selectedRun ? "  enter:Full-message  esc:Back" : this.selectedLifecycle ? "  v:View-evidence  g:Re-run-gate  esc:Back" : "  esc:Back")
         : this.pendingCheckpoint
           ? "  c:Continue  v:Revise  a:Abort"
           : this.lcRevising
@@ -474,7 +474,42 @@ export class FleetPanel extends Container {
       return;
     }
     if (this.selectedLifecycle) {
-      if (matchesKey(data, "escape")) { this.selectedLifecycle = null; this.renderShell(); }
+      if (matchesKey(data, "escape")) { this.selectedLifecycle = null; this.renderShell(); return; }
+      // SPEC-6-2: v:View-evidence — open the conversation viewer on the first agent gate's runId.
+      if (matchesKey(data, "v")) {
+        const agentGate = this.selectedLifecycle.phases
+          .flatMap((p) => p.gateResults ?? [])
+          .find((gr) => gr.runId);
+        if (agentGate?.runId && this.deps.runLog) {
+          this.selectedRun = buildRunsIndex(this.deps.runLog.dir).find((r) => r.runId === agentGate.runId) ?? null;
+          this.runTimeline = this.deps.runLog.replay(agentGate.runId);
+          this.selectedLifecycle = null;
+          this.view = "runs";
+          this.renderShell();
+        } else if (agentGate) {
+          this.onNotify(`Gate '${agentGate.gate}' evidence: ${agentGate.evidence.slice(0, 200)}`, "info");
+        } else {
+          const predGate = this.selectedLifecycle.phases
+            .flatMap((p) => p.gateResults ?? [])
+            .find((gr) => !gr.passed && gr.evidence);
+          if (predGate) {
+            this.onNotify(`Gate '${predGate.gate}' evidence: ${predGate.evidence.slice(0, 200)}`, "info");
+          } else {
+            this.onNotify("No gate evidence available for this lifecycle.", "info");
+          }
+        }
+        return;
+      }
+      // SPEC-6-2: g:Re-run-gate — requires the GateCtx which the runtime holds, not the panel.
+      // Full re-run from the panel is a post-v0.11.0 enhancement (the panel doesn't have the GateCtx).
+      if (matchesKey(data, "g")) {
+        if (this.selectedLifecycle.status === "checkpoint") {
+          this.onNotify("Gate re-run from the panel is not yet supported — use the fleet tool or revise at the checkpoint to re-trigger gates.", "info");
+        } else {
+          this.onNotify("Gate re-run requires a checkpointed lifecycle (current status: " + this.selectedLifecycle.status + ").", "warning");
+        }
+        return;
+      }
       return;
     }
     if (this.selectedSchedule) {

package/src/panel/fleet-widget.ts

@@ -17,6 +17,7 @@
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import type { RunRegistry } from "../engine/run-registry.ts";
 import type { BgRunsStore } from "./bg-runs-store.ts";
+import { reconcileRuns } from "../runtime/reconcile.ts";
 import {
   toWidgetRun, toWidgetRunFromBg, renderWidgetLines,
 } from "./widget-rows.ts";
@@ -41,6 +42,10 @@ export interface FleetWidgetDeps {
   clearInterval?: (id: unknown) => void;
   /** SPEC-6-1: resolve a model's context window for the ctx% widget segment. Optional — absent → no ctx%. */
   getModelContextWindow?: (model: string) => number | undefined;
+  /** SPEC-6-2: the session's cwd — only runs from this cwd are shown in the widget (cross-cwd filter). */
+  cwd?: string;
+  /** SPEC-6-2: RunLog for the periodic liveness probe (reconcileRuns). Optional — absent → no periodic probe. */
+  runLog?: import("../runtime/run-log.ts").RunLog;
 }
 
 export class FleetWidgetController {
@@ -50,6 +55,7 @@ export class FleetWidgetController {
   private readonly clearIntervalFn: (id: unknown) => void;
   private readonly unsubs: (() => void)[] = [];
   private timerId: unknown | null = null;
+  private livenessTimerId: unknown | null = null;
   private disposed = false;
 
   constructor(deps: FleetWidgetDeps) {
@@ -62,11 +68,20 @@ export class FleetWidgetController {
   start(): void {
     this.unsubs.push(this.deps.runRegistry.subscribe(() => this.render()));
     if (this.deps.bgRuns) this.unsubs.push(this.deps.bgRuns.subscribe(() => this.render()));
+    // SPEC-6-2: periodic liveness probe — reconciles dead orphans every 60s.
+    if (this.deps.runLog) {
+      this.livenessTimerId = this.setIntervalFn(() => {
+        reconcileRuns(this.deps.runLog!, { runRegistry: this.deps.runRegistry });
+      }, 60_000);
+      (this.livenessTimerId as { unref?: () => void }).unref?.();
+    }
     this.render(); // initial — shows any runs already active on session_start (e.g. a survived bg run)
   }
 
   private activeRuns() {
-    const fg = this.deps.runRegistry.list().map((r) => {
+    const fg = this.deps.runRegistry.list()
+      .filter((r) => !this.deps.cwd || r.cwd === this.deps.cwd)
+      .map((r) => {
       const w = toWidgetRun(r);
       w.maxContext = this.deps.getModelContextWindow?.(r.model);
       return w;
@@ -105,6 +120,10 @@ export class FleetWidgetController {
       this.clearIntervalFn(this.timerId);
       this.timerId = null;
     }
+    if (this.livenessTimerId !== null) {
+      this.clearIntervalFn(this.livenessTimerId);
+      this.livenessTimerId = null;
+    }
   }
 
   /** Unsubscribe + clear timer + clear the widget. Idempotent. */

package/src/panel/gate-line.ts

@@ -0,0 +1,22 @@
+import type { GateResult } from "../lifecycle/gates/registry.ts";
+
+export function gateGlyph(r: GateResult): string {
+  if (r.passed) return "✅";
+  if (r.onFail === "abort") return "⛔";
+  if (r.onFail === "revise") return "↻";
+  return "⚠"; // advise
+}
+
+/** Pure: build the compact gate line for a Lifecycle view phase row. */
+export function buildGateLine(results: GateResult[]): string {
+  if (results.length === 0) return "";
+  const parts = results.map((r) => `${gateGlyph(r)}${r.gate}`);
+  // If the last failing gate short-circuited, append the action.
+  const lastFail = [...results].reverse().find((r) => !r.passed);
+  let suffix = "";
+  if (lastFail) {
+    if (lastFail.onFail === "abort") suffix = " → aborted";
+    else if (lastFail.onFail === "revise") suffix = " → revising";
+  }
+  return `gates: ${parts.join("  ")}${suffix}`;
+}

package/src/panel/rows.ts

@@ -92,6 +92,7 @@ export function backendInfo(b: Backend): string {
 }
 
 import type { LifecycleRunRecord, LifecycleStatus } from "../lifecycle/lifecycle-types.ts";
+import { buildGateLine } from "./gate-line.ts";
 
 
 // SPEC-5a §11 — bg run row status (Q8=A). The fleet tab gains live status icons + phase progress
@@ -174,6 +175,8 @@ export function lifecyclePhaseTimeline(r: LifecycleRunRecord): string {
     const mark = p.reviseCount > 0 ? "[~]" : p.status === "completed" ? "[x]" : "[ ]";
     const art = p.paths.length ? ` → ${p.paths.join(", ")}` : "";
     lines.push(`  ${mark} ${p.name}  ${p.status}${art}${p.paths.length ? "  [Open]" : ""}`);
+    const gateLine = buildGateLine(p.gateResults ?? []);
+    if (gateLine) lines.push(`      ${gateLine}`);
   }
   if (r.status === "checkpoint") {
     lines.push("", "── Checkpoint ──", "[Continue]  [Revise]  [Abort]");

package/src/panel/runs-rows.ts

@@ -10,7 +10,9 @@ const STATUS_GLYPH: Record<RunMeta["status"], string> = {
 
 export function runsRow(r: RunMeta, getModelContextWindow?: (model: string) => number | undefined): string {
   const dur = r.endedAt ? fmtDuration(r.endedAt - r.startedAt) : "—";
-  const tok = r.tokenTotal > 0 ? `  ${fmtTokens(r.tokenTotal)} tok` : "";
+  // SPEC-6-1 fix: "tok" is the final context snapshot (contextTokens), NOT cumulative
+  // tokenTotal — it pairs with the ctx% segment (same metric).
+  const tok = r.contextTokens != null && r.contextTokens > 0 ? `  ${fmtTokens(r.contextTokens)} tok` : "";
   const maxCtx = getModelContextWindow?.(r.model);
   const ctx = (r.contextTokens != null && maxCtx != null && maxCtx > 0) ? `  ${Math.round(r.contextTokens / maxCtx * 100)}%` : "";
   const cost = r.costTotal ? `  $${r.costTotal.toFixed(4)}` : "";

package/src/panel/widget-rows.ts

@@ -72,7 +72,10 @@ const STATUS_GLYPH: Record<WidgetRun["status"], string> = {
 function widgetLine(r: WidgetRun, now: number): string {
   const glyph = STATUS_GLYPH[r.status];
   const dur = typeof r.startedAt === "number" ? `  ${fmtDuration(now - r.startedAt)}` : "";
-  const tok = r.tokenTotal ? `  ${fmtTokens(r.tokenTotal)} tok` : "";
+  // SPEC-6-1 fix: "tok" is the live context snapshot (contextTokens), NOT cumulative
+  // tokenTotal — it pairs with the ctx% segment (same metric). Showing tokenTotal here
+  // ballooned to 6.7M on long runs (cumulative re-sends) next to a 35% ctx, looking broken.
+  const tok = r.contextTokens != null ? `  ${fmtTokens(r.contextTokens)} tok` : "";
   const ctx = (r.contextTokens != null && r.maxContext != null && r.maxContext > 0) ? `  ${Math.round(r.contextTokens / r.maxContext * 100)}%` : "";
   const cost = r.costTotal ? `  $${r.costTotal.toFixed(4)}` : "";
 

package/src/runtime/async-runner.ts

@@ -41,6 +41,8 @@ export interface AsyncRunnerDeps {
   genRunId: () => string;
   /** SPEC-5a: called at each run/phase transition so the host (index.ts) can update the live bgRuns map. */
   onProgress?: (runId: string, status: import("../panel/rows.ts").BgRunStatus) => void;
+  /** SPEC-6-2: the RunRegistry so emitProgress can read the run's actual backend. */
+  runRegistry?: import("../engine/run-registry.ts").RunRegistry;
 }
 
 export interface RunBackgroundOpts {
@@ -60,7 +62,7 @@ function emitProgress(deps: AsyncRunnerDeps, runId: string, partial: Partial<imp
     runId,
     lifecycle: "",
     mode: "auto",
-    backend: "pi",
+    backend: deps.runRegistry?.get(runId)?.backend ?? "pi",
     task: "",
     ...partial,
   });

package/src/runtime/reconcile.ts

@@ -3,27 +3,36 @@
 // is gone) as aborted so the Runs tab doesn't show stale "running" rows across restarts.
 // Foreground orphans; bg/lifecycle orphans are already handled by scanResumeCandidates (SPEC-5a).
 //
-// v0.10.2 patch: reconcile now ALSO syncs the in-memory RunRegistry (opts.runRegistry). Before this,
-// reconcile only wrote run:ended: aborted to the durable RunLog — the in-memory RunRegistry kept
-// status:"running", so the live above-editor widget (filterActive keeps running|queued|paused)
-// rendered a stale ▶ row that ticked forever for every orphaned (process-gone) run.
+// SPEC-6-2: rewritten to be probe-driven — uses `probeRun` (handle/pid/age-fallback) instead of
+// age+grace alone. This catches orphans whose process died but whose startedAt is within grace
+// (e.g. a crash seconds after start), and avoids aborting runs whose process is alive but old
+// (e.g. a long-running build).
 import type { RunLog } from "./run-log.ts";
-import type { RunRegistry } from "../engine/run-registry.ts";
+import type { RunRegistry, RunRecord } from "../engine/run-registry.ts";
+
+export type Liveness = "alive" | "dead";
+
+/** SPEC-6-2: real probe first (handle / pid), age+grace fallback for cross-process pi-backend orphans. */
+export function probeRun(rec: { status: string; session?: { isAlive?: () => boolean }; pid?: number; startedAt: number }, now: number, grace: number): Liveness {
+  // 1. in-process handle
+  if (rec.session && typeof rec.session.isAlive === "function") {
+    return rec.session.isAlive() ? "alive" : "dead";
+  }
+  // 2. pid (works cross-process — system-wide)
+  if (typeof rec.pid === "number") {
+    try { process.kill(rec.pid, 0); return "alive"; } catch { return "dead"; }
+  }
+  // 3. fallback — cross-process pi-backend orphan, no reachable probe
+  return (now - rec.startedAt > grace) ? "dead" : "alive";
+}
 
 export interface ReconcileOpts {
-  /** Orphans whose startedAt is older than (now - graceMs) are marked aborted. Default 60000. */
   graceMs?: number;
-  /** Test injection. Default Date.now(). */
   now?: number;
-  /**
-   * v0.10.2: the in-memory RunRegistry to sync alongside the durable log. When set, each orphan
-   * reconciled in the log is also transitioned to status:"aborted" in memory so the live widget
-   * clears its stale ▶ row. Optional — existing callers that pass only a RunLog are unaffected.
-   */
   runRegistry?: RunRegistry;
 }
 
-/** Returns the runIds it marked aborted. Idempotent: a run already ended is skipped. */
+/** Returns the runIds it marked aborted. Probe-driven (SPEC-6-2); idempotent. */
 export function reconcileRuns(log: RunLog, opts: ReconcileOpts = {}): string[] {
   const grace = opts.graceMs ?? 60_000;
   const now = opts.now ?? Date.now();
@@ -31,14 +40,14 @@ export function reconcileRuns(log: RunLog, opts: ReconcileOpts = {}): string[] {
   const aborted: string[] = [];
   for (const meta of log.scanMeta()) {
     if (meta.status !== "running") continue;
-    if (now - meta.startedAt <= grace) continue;
+    // The in-memory record (if present) carries the live handle/pid; the log meta carries pid for cross-process.
+    const memRec = reg?.get(meta.runId);
+    const probeRec = memRec ?? { status: meta.status, pid: (meta as { pid?: number }).pid, startedAt: meta.startedAt };
+    if (probeRun(probeRec, now, grace) !== "dead") continue;
     log.append(meta.runId, {
       type: "run:ended", runId: meta.runId, status: "aborted",
-      endedAt: now, resultSummary: "process-gone", tokenTotal: meta.tokenTotal,
+      endedAt: now, resultSummary: "process-gone (probe)", tokenTotal: meta.tokenTotal,
     });
-    // v0.10.2: sync the in-memory registry so the live widget (which reads runRegistry.list(),
-    // not the RunLog) clears the orphan's stale ▶ row. No-op when the run isn't in the registry
-    // (e.g. a cross-cwd orphan from another session — out of scope for this patch).
     reg?.update(meta.runId, { status: "aborted", endedAt: now });
     aborted.push(meta.runId);
   }

package/src/runtime/run-log.ts

@@ -11,6 +11,10 @@ export interface RunMetaEvent {
   type: "run:meta"; runId: string; agent: string; model: string; task: string;
   startedAt: number; track: boolean; todoId: string | null;
   backendSessionId?: string; sessionKey?: string;
+  /** SPEC-6-2: claude child PID (cross-process liveness probe). */
+  pid?: number;
+  /** SPEC-6-2: the cwd this run belongs to. */
+  cwd?: string;
 }
 export interface MessageEvent {
   type: "message"; role: string; text: string;
@@ -41,6 +45,10 @@ export interface RunMeta {
   costTotal?: number;
   /** SPEC-6-1: latest context-token snapshot at run end. */
   contextTokens?: number;
+  /** SPEC-6-2: claude child PID. */
+  pid?: number;
+  /** SPEC-6-2: the cwd this run belongs to. */
+  cwd?: string;
 }
 
 const ARGS_LIMIT = 200;
@@ -96,7 +104,7 @@ export class RunLog {
           if (!meta) {
             meta = { runId: e.runId, agent: e.agent, model: e.model, task: e.task, startedAt: e.startedAt,
               track: e.track, todoId: e.todoId, backendSessionId: e.backendSessionId, sessionKey: e.sessionKey,
-              status: "running", tokenTotal: 0 };
+              status: "running", tokenTotal: 0, pid: e.pid, cwd: e.cwd };
           } else {
             // latest binding wins
             if (e.backendSessionId) meta.backendSessionId = e.backendSessionId;