@getpipher/armory-fleet 0.10.3 → 0.11.1

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/runtime/async-runner.ts

@@ -23,8 +23,8 @@ export interface FakeLifecycleResult {
 
 export interface RunLifecycleOpts {
   runId: string;
-  worktreePath: string;
-  branch: string;
+  worktreePath?: string;
+  branch?: string;
   mode: "auto" | "checkpointed";
 }
 
@@ -41,18 +41,30 @@ 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 {
   deps: AsyncRunnerDeps;
   lifecycle: string;
   mode: "auto" | "checkpointed";
+  /** v0.11.1: edit isolation for background runs. Default "auto" (worktree when cwd is a git repo, in-place otherwise). */
+  isolation?: Isolation;
 }
 
-export interface RunBackgroundHandle {
-  runId: string;
-  status: "background";
-}
+/** The success shape (back-compat: existing external refs to RunBackgroundHandle still typecheck). */
+export interface RunBackgroundHandle { runId: string; status: "background"; }
+
+/** v0.11.1: a background dispatch either starts (runId + background) or fails synchronously (error, no runId). */
+export type RunBackgroundResult =
+  | { runId: string; status: "background" }
+  | { status: "failed"; error: string };
+
+export type Isolation = "worktree" | "none" | "auto";
+
+/** Per-session dedup flag for the auto-fallback in-place notify (resets on process restart = new session). */
+let inPlaceFallbackWarned = false;
 
 function emitProgress(deps: AsyncRunnerDeps, runId: string, partial: Partial<import("../panel/rows.ts").BgRunStatus> & { status: import("../panel/rows.ts").BgStatus; phase: string; phaseIndex: number; phaseTotal: number }): void {
   if (!deps.onProgress) return;
@@ -60,7 +72,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,
   });
@@ -70,54 +82,98 @@ function sh(cmd: string, cwd: string): void {
   execSync(cmd, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
 }
 
-export function runBackground(task: string, opts: RunBackgroundOpts): RunBackgroundHandle {
+/** The git-agnostic core: pool slot → journal → runLifecycle in ctx.cwd (or a worktree, when `isolated` is set) → inbox + notify.
+ *  Fire-and-forget. When `isolated` is present, journals the worktree field, commits on completion, and removes the worktree. */
+function runBackgroundInPlace(runId: string, task: string, opts: RunBackgroundOpts, isolated?: { worktreePath: string; branch: string }): void {
   const { deps } = opts;
-  const runId = deps.genRunId();
-  const baseRef = "HEAD";
-
-  // Fire-and-forget: the pool gates concurrency; the journal records the run.
   void deps.pool.withSlot(async () => {
-    let wt: { path: string; branch: string } | null = null;
     try {
-      wt = deps.worktree.create(runId, baseRef);
-      const ev0: JournalEvent = { type: "run:started", runId, task, lifecycle: opts.lifecycle, worktree: { path: wt.path, branch: wt.branch }, mode: opts.mode, ts: Date.now() };
+      const ev0: JournalEvent = isolated
+        ? { type: "run:started", runId, task, lifecycle: opts.lifecycle, worktree: { path: isolated.worktreePath, branch: isolated.branch }, mode: opts.mode, ts: Date.now() }
+        : { type: "run:started", runId, task, lifecycle: opts.lifecycle, mode: opts.mode, ts: Date.now() };
       deps.journal.append(runId, ev0);
       emitProgress(deps, runId, { status: "running", phase: "", phaseIndex: 0, phaseTotal: 0, lifecycle: opts.lifecycle, mode: opts.mode, task });
 
-      const res = await deps.runLifecycle(task, opts.lifecycle, { runId, worktreePath: wt.path, branch: wt.branch, mode: opts.mode });
+      const res = await deps.runLifecycle(task, opts.lifecycle, { runId, worktreePath: isolated?.worktreePath, branch: isolated?.branch, mode: opts.mode });
 
       if (res.status === "completed") {
-        // commit the worktree to the branch (lifecycle finish phase or single-delegate completion)
-        try { sh("git add -A && git commit -m 'fleet run complete'", wt.path); } catch { /* nothing to commit */ }
-        deps.journal.append(runId, { type: "run:completed", runId, branch: wt.branch, ts: Date.now() });
+        if (isolated) {
+          try { sh("git add -A && git commit -m 'fleet run complete'", isolated.worktreePath); } catch { /* nothing to commit */ }
+        }
+        deps.journal.append(runId, isolated
+          ? { type: "run:completed", runId, branch: isolated.branch, ts: Date.now() }
+          : { type: "run:completed", runId, ts: Date.now() });
         const total = res.phases.length;
-        const lastIdx = total; // completed = past the last phase
-        emitProgress(deps, runId, { status: "completed", phase: res.phases[total - 1]?.name ?? "finish", phaseIndex: lastIdx, phaseTotal: total, lifecycle: opts.lifecycle, mode: opts.mode, task, branch: wt.branch });
+        const lastIdx = total;
+        emitProgress(deps, runId, { status: "completed", phase: res.phases[total - 1]?.name ?? "finish", phaseIndex: lastIdx, phaseTotal: total, lifecycle: opts.lifecycle, mode: opts.mode, task, ...(isolated ? { branch: isolated.branch } : {}) });
         const lastPhase = res.phases[res.phases.length - 1];
         const result: RunResult = {
           runId, task, status: "completed",
           summary: lastPhase?.summary ?? "",
           paths: res.phases.flatMap((p) => p.paths),
-          branch: wt.branch, completedAt: Date.now(),
+          completedAt: Date.now(),
+          ...(isolated ? { branch: isolated.branch } : {}),
         };
         deps.inbox.push(result);
         deps.notify(`fleet run ${runId} completed`, "info");
-        // SPEC-5a: the worktree dir is temporary scaffolding; remove it but keep the branch for merge/inspection.
-        deps.worktree.removeWorktree(runId);
+        if (isolated) deps.worktree.removeWorktree(runId);
       } else {
         deps.journal.append(runId, { type: "run:aborted", runId, reason: res.error ?? res.status, ts: Date.now() });
-        deps.worktree.remove(runId);
+        if (isolated) deps.worktree.remove(runId);
         emitProgress(deps, runId, { status: "failed", phase: "", phaseIndex: 0, phaseTotal: res.phases.length, lifecycle: opts.lifecycle, mode: opts.mode, task });
         deps.notify(`fleet run ${runId} ${res.status}: ${res.error ?? ""}`, "warning");
       }
     } catch (e) {
       const msg = (e as Error).message;
       deps.journal.append(runId, { type: "run:aborted", runId, reason: msg, ts: Date.now() });
-      if (wt) deps.worktree.remove(runId);
+      if (isolated) deps.worktree.remove(runId);
       deps.notify(`fleet run ${runId} failed: ${msg}`, "error");
       emitProgress(deps, runId, { status: "failed", phase: "", phaseIndex: 0, phaseTotal: 0, lifecycle: opts.lifecycle, mode: opts.mode, task });
     }
   });
+}
 
+/** The worktree wrapper: SYNCHRONOUS pre-flight + worktree create, then core-with-isolation. */
+function runBackgroundIsolated(task: string, opts: RunBackgroundOpts): RunBackgroundResult {
+  const { deps } = opts;
+  if (!deps.worktree.isGitRepo()) {
+    return { status: "failed", error: "isolation: 'worktree' requires a git repo; cwd is not one — use isolation: 'none' or run in a git repo" };
+  }
+  const runId = deps.genRunId();
+  const baseRef = "HEAD";
+  let wt: { path: string; branch: string };
+  try {
+    wt = deps.worktree.create(runId, baseRef);
+  } catch (e) {
+    return { status: "failed", error: (e as Error).message };
+  }
+  runBackgroundInPlace(runId, task, opts, { worktreePath: wt.path, branch: wt.branch });
   return { runId, status: "background" };
+}
+
+/** The auto router: isolated when cwd is a git repo, in-place + one per-session notify when not. */
+function runBackgroundAuto(task: string, opts: RunBackgroundOpts): RunBackgroundResult {
+  const { deps } = opts;
+  if (deps.worktree.isGitRepo()) {
+    return runBackgroundIsolated(task, opts);
+  }
+  if (!inPlaceFallbackWarned) {
+    inPlaceFallbackWarned = true;
+    deps.notify("background run in-place (no worktree isolation — parallel edits may conflict)", "warning");
+  }
+  const runId = deps.genRunId();
+  runBackgroundInPlace(runId, task, opts);
+  return { runId, status: "background" };
+}
+
+/** Public dispatcher (keeps the `runBackground` name + RunBackgroundHandle success shape for back-compat). */
+export function runBackground(task: string, opts: RunBackgroundOpts): RunBackgroundResult {
+  const isolation = opts.isolation ?? "auto";
+  if (isolation === "worktree") return runBackgroundIsolated(task, opts);
+  if (isolation === "none") {
+    const runId = opts.deps.genRunId();
+    runBackgroundInPlace(runId, task, opts);
+    return { runId, status: "background" };
+  }
+  return runBackgroundAuto(task, opts);
 }

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/resume.ts

@@ -8,8 +8,10 @@ export interface ResumeCandidate {
   runId: string;
   task: string;
   lifecycle: string;
-  worktreePath: string;
-  branch: string;
+  /** Present only for isolated (worktree) runs. */
+  worktreePath?: string;
+  /** Present only for isolated (worktree) runs. */
+  branch?: string;
   lastPhase: string | null;
   canResume: boolean;
 }
@@ -26,23 +28,27 @@ export function scanResumeCandidates(_projectDir: string, opts: ScanResumeOpts):
   for (const runId of ids) {
     const events = journal.replay(runId);
     const started = events.find((e) => e.type === "run:started") as
-      | (JournalEvent & { type: "run:started" }) | undefined;
+      | (JournalEvent & { type: "run:started"; worktree?: { path: string; branch: string } }) | undefined;
     if (!started) continue;
     const phaseEvents = events.filter((e) => e.type === "phase:completed" || e.type === "phase:started" || e.type === "phase:failed") as Array<{ phase: string }>;
     const lastPhase = phaseEvents.length > 0 ? phaseEvents[phaseEvents.length - 1]!.phase : null;
-    const wtExists = opts.worktree.exists(runId);
-    if (!wtExists) {
-      journal.append(runId, { type: "run:aborted", runId, reason: "worktree-missing", ts: Date.now() });
+
+    if (started.worktree) {
+      // isolated run: resume iff the worktree still exists
+      const wtExists = opts.worktree.exists(runId);
+      if (!wtExists) {
+        journal.append(runId, { type: "run:aborted", runId, reason: "worktree-missing", ts: Date.now() });
+      }
+      cands.push({
+        runId, task: started.task, lifecycle: started.lifecycle,
+        worktreePath: started.worktree.path, branch: started.worktree.branch,
+        lastPhase, canResume: wtExists,
+      });
+    } else {
+      // v0.11.1: in-place interrupted run — no worktree to clean; abort (partial edits may remain in cwd).
+      journal.append(runId, { type: "run:aborted", runId, reason: "in-place interrupted (partial edits may remain in cwd)", ts: Date.now() });
+      cands.push({ runId, task: started.task, lifecycle: started.lifecycle, lastPhase, canResume: false });
     }
-    cands.push({
-      runId,
-      task: started.task,
-      lifecycle: started.lifecycle,
-      worktreePath: started.worktree.path,
-      branch: started.worktree.branch,
-      lastPhase,
-      canResume: wtExists,
-    });
   }
   return cands;
 }

package/src/runtime/run-journal.ts

@@ -4,12 +4,12 @@
 import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 
-export interface RunStartedEvent { type: "run:started"; runId: string; task: string; lifecycle: string; worktree: { path: string; branch: string }; mode: "auto" | "checkpointed"; ts: number; }
+export interface RunStartedEvent { type: "run:started"; runId: string; task: string; lifecycle: string; worktree?: { path: string; branch: string }; mode: "auto" | "checkpointed"; ts: number; }
 export interface PhaseStartedEvent { type: "phase:started"; phase: string; ts: number; }
 export interface PhaseCompletedEvent { type: "phase:completed"; phase: string; summary: string; paths: string[]; ts: number; }
 export interface PhaseFailedEvent { type: "phase:failed"; phase: string; error: string; ts: number; }
 export interface CheckpointEvent { type: "checkpoint"; phase: string; decision: "continue" | "revise" | "abort"; ts: number; }
-export interface RunCompletedEvent { type: "run:completed"; runId: string; branch: string; ts: number; }
+export interface RunCompletedEvent { type: "run:completed"; runId: string; branch?: string; ts: number; }
 export interface RunAbortedEvent { type: "run:aborted"; runId: string; reason: string; ts: number; }
 
 export type JournalEvent =

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;

package/src/scheduling/scheduler.ts

@@ -11,6 +11,8 @@ export interface ScheduleSpec {
   expression: string;
   lifecycle?: string; // default "default"
   auto?: boolean;
+  /** v0.11.1: edit isolation for the background run on fire. Default "auto". */
+  isolation?: "worktree" | "none" | "auto";
 }
 
 export interface Schedule extends ScheduleSpec {
@@ -71,6 +73,7 @@ export class Scheduler {
       expression: spec.expression,
       lifecycle: spec.lifecycle ?? "default",
       auto: spec.auto ?? true,
+      isolation: spec.isolation,
       paused: false,
     };
     this.schedules.set(id, { spec: stored, expr, timer: null });
@@ -86,6 +89,7 @@ export class Scheduler {
       expression: e.spec.expression,
       lifecycle: e.spec.lifecycle,
       auto: e.spec.auto,
+      isolation: e.spec.isolation,
       paused: e.spec.paused,
       nextFire: e.spec.paused ? null : e.expr.nextFire(new Date()),
     }));