@getpipher/armory-fleet 0.10.3 → 0.11.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpipher/armory-fleet",
-  "version": "0.10.3",
+  "version": "0.11.1",
   "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();
@@ -196,17 +212,20 @@ export default async function (pi: ExtensionAPI): Promise<void> {
     // foreground subagent holding deps.lock made every bg run's first-phase spawn fail fast
     // (tryAcquire → "concurrency lock unexpectedly unavailable" → 6ms run:aborted).
     const bgLock = createSingleSlotLock();
+    // v0.11.1: isolated runs use worktree-diff artifact discovery + the worktree as spawn cwd;
+    // in-place runs (worktreePath undefined) use the prompt-baked parser + the session cwd.
+    const isolated = !!opts.worktreePath;
     const lifecycleFullDeps: LifecycleRunDeps = {
       ...deps.lifecycleDeps,
       genRunId: () => opts.runId,   // override: use the async runner's runId
-      // SPEC-5a (Q3=A): isolated run — worktree-diff artifact discovery instead of the prompt-baked block.
-      artifactDiscovery: ({ finalText, cwd, baseRef }) => (deps.asyncRunner as AsyncRunnerDeps).diff.diffPhase(cwd, baseRef, finalText),
+      ...(isolated ? { artifactDiscovery: ({ finalText, cwd, baseRef }: { finalText: string; cwd: string; baseRef: string }) => (deps.asyncRunner as AsyncRunnerDeps).diff.diffPhase(cwd, baseRef, finalText) } : {}),
       spawn: async (o) => spawnSubagent({
         agent: o.agent, task: o.task, lifecycleTodoId: o.lifecycleTodoId, model: o.model,
         skillsOverride: o.skills, backendOverride: o.backend,
         registry: deps.registry, todoSync: deps.todoSync, runRegistry: deps.runRegistry, lock: bgLock,
-        backendRegistry: deps.backendRegistry, parentModel: deps.parentModel, parentCwd: opts.worktreePath, runLog: deps.runLog,
-        tierRegistry: deps.tierRegistry, modelRegistry: deps.modelRegistry,  // SPEC-6-1
+        backendRegistry: deps.backendRegistry, parentModel: deps.parentModel,
+        parentCwd: isolated ? opts.worktreePath! : deps.parentCwd,
+        runLog: deps.runLog, tierRegistry: deps.tierRegistry, modelRegistry: deps.modelRegistry,
       }),
     };
     const res = await runLifecycle(task, lifecycleName, { deps: lifecycleFullDeps, mode: opts.mode, worktreePath: opts.worktreePath, baseRef: "HEAD", onCheckpoint: async (p) => p.status === "failed" ? { action: "abort" } : { action: "continue" } });
@@ -274,13 +293,14 @@ 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"),
       lockPath: join(dir, "schedules.lock"),
       onFire: (spec) => {
         if (!deps.asyncRunner) return;
-        runBackground(spec.task, { deps: deps.asyncRunner, lifecycle: spec.lifecycle ?? "default", mode: spec.auto ? "auto" : "checkpointed" });
+        runBackground(spec.task, { deps: deps.asyncRunner, lifecycle: spec.lifecycle ?? "default", mode: spec.auto ? "auto" : "checkpointed", isolation: spec.isolation });
       },
     });
     deps.scheduler.start();
@@ -295,12 +315,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 +414,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.