@try-works/dsh-recursive-mode 0.2.3 → 0.3.0

package/lib/live-route.d.ts

@@ -40,7 +40,7 @@ export interface RecursiveStatePayload {
     revision: number;
 }
 /**
- * Build the two read-only routes. Returns [state, events] in registration order.
+ * Build the read-only routes. Returns [state, events, doc] in registration order.
  * @param host - the resolved-root + fs-fold seam (the RecursiveRuntime adapter).
  */
 export declare function makeRecursiveRoutes(host: RecursiveRouteHost): readonly {

package/lib/recursive_audit_team.tool.d.ts

@@ -0,0 +1,2 @@
+import type { TeamRuntimeLike } from './teams-loop.ts';
+export declare function createRecursiveAuditTeamTool(teams: TeamRuntimeLike | null): import("@deepseek-ai/dsh-tools").ToolDefinition;

package/lib/runtime.d.ts

@@ -5,10 +5,13 @@ import { type PhaseRules } from './phase-rules.ts';
 import { type ScratchTarget } from './scratch.ts';
 import { type ReviewBundleInput } from './review.ts';
 import { type SubagentProviderLike, type RouteDecision, type CapabilityProbe } from './router.ts';
-import { type SubagentsRuntimeLike, type SubagentStartRequestLike, type SubagentResultLike, type Reference } from './delegation.ts';
+import { type SubagentsRuntimeLike, type SubagentStartRequestLike, type SubagentResultLike, type Reference, type SubagentParentHandle } from './delegation.ts';
 import { type RecursivePhaseState } from './lifecycle.ts';
 import { type EnforcementConfig, type ToolGuardDecision, type ToolExecLike } from './enforcement.ts';
 import { type CreateWorktreeResult, type PromoteBranchResult } from './worktree.ts';
+import { syncRunGoal, type GoalServiceLike } from './goals-projection.ts';
+import { type TeamRuntimeLike, type AuditToPassResult, type TeamCallerHandle, type TeamTaskViewLike, type AuditRoundOutcome } from './teams-loop.ts';
+import type { ContinuableChildId, ContinuableMessageId } from './delegation.ts';
 declare module '@deepseek-ai/cordis' {
     interface Context {
         recursive: RecursiveRuntime;
@@ -35,10 +38,98 @@ export declare class RecursiveRuntime extends Service {
     constructor(ctx: Context, config?: {
         repoRoot?: string;
         workspaceRegistry?: WorkspaceRegistryLike;
+        goals?: GoalServiceLike | null;
     });
     private readonly repoRoot;
     private readonly workspaceRegistry;
+    private readonly goalsService;
     private _enforcementConfig;
+    /**
+     * T3 (agentTeams task loop): run the audit→repair→re-audit state machine on
+     * ONE durable team task. The `teams` seam (live `ctx.agentTeams`) is injected
+     * per-call so the loop stays unit-testable; `runAuditRound` is the caller's
+     * round executor (live usage wires T4's continuable delegation). Locking the
+     * phase artifact is `lockPhase` — the loop NEVER locks before an APPROVE.
+     */
+    auditToPass(input: {
+        teams: TeamRuntimeLike;
+        caller: TeamCallerHandle;
+        root: string;
+        runId: string;
+        phase: string;
+        artifact: string;
+        agent?: {
+            session?: {
+                header?: {
+                    cwd?: string;
+                };
+            };
+        } | null;
+        runAuditRound: (round: number, task: TeamTaskViewLike) => Promise<AuditRoundOutcome>;
+        blockedBy?: readonly string[];
+        writeScopes?: readonly string[];
+        reviewerName?: string;
+        maxRounds?: number;
+        waitTimeoutMs?: number;
+    }): Promise<AuditToPassResult & {
+        history?: string;
+        lock?: LockArtifactResult;
+    }>;
+    /**
+     * T1 (goals projection): project the run into the native goals service so it is
+     * a first-class durable, resumable, blockable object. Best-effort — the run's
+     * filesystem state is the source of truth; a goal is the durable projection.
+     */
+    projectRunToGoal(agent: {
+        session?: {
+            header?: {
+                cwd?: string;
+            };
+        };
+    } | null | undefined, runId: string, state?: Parameters<typeof syncRunGoal>[3]): {
+        ok: true;
+        phase: import("./goals-projection.ts").GoalPhase;
+        ref?: import("./goals-projection.ts").GoalRefLike;
+        created?: boolean;
+    } | {
+        ok: boolean;
+        reason: string;
+    };
+    /** T1: block the run's goal on a gate-block (durable + UI-visible). */
+    blockRunToGoal(agent: {
+        session?: {
+            header?: {
+                cwd?: string;
+            };
+        };
+    } | null | undefined, runId: string, reason: {
+        code: string;
+        message: string;
+    }): {
+        ok: true;
+        phase: import("./goals-projection.ts").GoalPhase;
+        ref?: import("./goals-projection.ts").GoalRefLike;
+        created?: boolean;
+    } | {
+        ok: boolean;
+        reason: string;
+    };
+    /** T1: re-arm the run's goal on a reopen (blocked/paused -> active). */
+    resumeRunToGoal(agent: {
+        session?: {
+            header?: {
+                cwd?: string;
+            };
+        };
+    } | null | undefined, runId: string): {
+        ok: true;
+        phase: import("./goals-projection.ts").GoalPhase;
+        ref?: import("./goals-projection.ts").GoalRefLike;
+        created?: boolean;
+    } | {
+        ok: boolean;
+        reason: string;
+    };
     /**
      * Workspace-scoped control-plane root (R1 binding invariant).
      * Resolves the session agent's canonical cwd -> workspace path via the
@@ -94,8 +185,16 @@ export declare class RecursiveRuntime extends Service {
     /**
      * Phase B (native delegation): build a review bundle (R1) + file-backed
      * handoff docs (R2), resolve the role via the router policy (R3), and call
-     * ctx.subagents.start() with the full request (R4). Workspace-scoped: every
-     * path resolves under the session's control-plane root.
+     * ctx.subagents with the full request (R4). Workspace-scoped: every path
+     * resolves under the session's control-plane root.
+     *
+     * `mode: 'continuable'` (T4) runs the audit→repair→re-audit loop on ONE
+     * durable continuable child (startContinuable → followup with the repair
+     * instruction → settle) and drains the child on closeout. It requires an
+     * `awaitRoundResult` observer (the parent-side settlement seam) AND the exact
+     * live `parent` Agent (continuable followup is object-identity authority);
+     * when either is absent it falls back to one-shot `delegate()` with a flag —
+     * never silently. One-shot `start()` is never called on the continuable path.
      */
     delegateReview(input: {
         root: string;
@@ -116,6 +215,11 @@ export declare class RecursiveRuntime extends Service {
         subagents?: SubagentsRuntimeLike;
         maxDepth?: number;
         toolFilter?: unknown;
+        mode?: 'one-shot' | 'continuable';
+        awaitRoundResult?: (childId: ContinuableChildId, messageId: ContinuableMessageId) => Promise<SubagentResultLike | null>;
+        maxRounds?: number;
+        /** T4: the exact live direct-parent Agent (object-identity authority). */
+        parent?: SubagentParentHandle;
     }): Promise<{
         decision: RouteDecision;
         probe: CapabilityProbe;
@@ -133,6 +237,11 @@ export declare class RecursiveRuntime extends Service {
         };
         actionRecordPath: string;
         error: string | null;
+        continuable: {
+            rounds: import("./delegation.ts").ContinuableRoundLike[];
+            childId: string | undefined;
+            fellBackToOneShot: boolean | undefined;
+        } | null;
     }>;
     /** R6: validate a child's claimed references against actual files. */
     validateReferences(root: string, references: Reference[]): import("./delegation.ts").ReferenceCheck;

package/lib/teams-loop.d.ts

@@ -0,0 +1,160 @@
+/**
+ * T3: model the audit→repair→re-audit loop as agentTeams Tasks.
+ *
+ * The recursion concept's core state machine, expressed over the native
+ * `agentTeams` service: ONE durable task per phase carries the loop —
+ * createTask (pending) → claim (in_progress) → audit round → on REVISE
+ * updateTask(edit, repair instruction) → re-audit the SAME task → on APPROVE
+ * updateTask(complete) → lock. A stuck reviewer is interrupted through the
+ * team's own kill switch; a REJECT or round-cap releases the task and fails
+ * loud — a lock NEVER happens before an APPROVE verdict.
+ *
+ * Everything here is a structural seam (TeamRuntimeLike / TeamTaskViewLike)
+ * so the whole loop is unit-testable with a fake team; the live `agentTeams`
+ * service satisfies the seam without an adapter. The caller Agent passes
+ * through as an opaque `TeamCallerHandle` (never serialized; workspace-scoped
+ * invariant).
+ */
+/** Verdict vocabulary shared with T4 (matches the delegated review schema). */
+export type AuditVerdict = 'APPROVE' | 'REVISE' | 'REJECT';
+/**
+ * Opaque handle to the live Team member/lead Agent authorizing task mutations.
+ * The seam uses it only for identity/authority and never inspects or serializes it.
+ */
+export interface TeamCallerHandle {
+    readonly id?: string;
+    readonly session?: {
+        readonly header?: {
+            readonly cwd?: string;
+        };
+    };
+}
+/** Minimal cancellation shape (a live AbortSignal satisfies it). */
+export interface TeamAbortSignalLike {
+    readonly throwIfAborted: () => void;
+}
+/** Task identity: a branded string in the live service. */
+export type TeamTaskIdLike = string;
+/** Task status vocabulary (mirrors the live TeamTaskStatus). */
+export type TeamTaskStatusLike = 'pending' | 'in_progress' | 'completed' | 'deleted';
+/** Task action vocabulary (mirrors the live TeamTaskAction; the loop uses a subset). */
+export type TeamTaskActionLike = 'claim' | 'release' | 'edit' | 'complete';
+/** One runtime-enriched task view (the fields the loop reads/writes). */
+export interface TeamTaskViewLike {
+    readonly id: TeamTaskIdLike;
+    readonly revision: number;
+    readonly subject: string;
+    readonly description: string;
+    readonly status: TeamTaskStatusLike;
+    readonly blockedBy: TeamTaskIdLike[];
+    readonly writeScopes: string[];
+    readonly ownerName?: string;
+    readonly ready: boolean;
+    readonly writeScopeWarnings: string[];
+}
+/** A wait observation (mirrors TeamWaitResult). */
+export interface TeamWaitResultLike {
+    readonly timedOut: boolean;
+}
+/** Create-task request (mirrors CreateTeamTaskRequest). */
+export interface CreateTeamTaskRequestLike {
+    subject: string;
+    description: string;
+    blockedBy?: readonly TeamTaskIdLike[];
+    writeScopes?: readonly string[];
+}
+/** Compare-and-set task transition (mirrors UpdateTeamTaskRequest). */
+export interface UpdateTeamTaskRequestLike {
+    taskId: TeamTaskIdLike;
+    expectedRevision: number;
+    action: TeamTaskActionLike;
+    subject?: string;
+    description?: string;
+    blockedBy?: readonly TeamTaskIdLike[];
+    writeScopes?: readonly string[];
+    owner?: string;
+}
+/**
+ * The agentTeams seam the loop calls. `waitForChange`/`interrupt`/`getTask`/
+ * `listTasks` are optional (loops degrade: no wait, no kill switch, no board
+ * re-read) — `createTask`/`updateTask` are hard requirements.
+ */
+export interface TeamRuntimeLike {
+    createTask(caller: TeamCallerHandle, request: CreateTeamTaskRequestLike): Promise<TeamTaskViewLike>;
+    updateTask(caller: TeamCallerHandle, request: UpdateTeamTaskRequestLike): Promise<TeamTaskViewLike>;
+    getTask?(caller: TeamCallerHandle, id: TeamTaskIdLike): TeamTaskViewLike;
+    listTasks?(caller: TeamCallerHandle): TeamTaskViewLike[];
+    waitForChange?(caller: TeamCallerHandle, timeoutMs: number, signal: TeamAbortSignalLike | undefined): Promise<TeamWaitResultLike>;
+    interrupt?(caller: TeamCallerHandle, targetName: string): {
+        previousStatus: 'running' | 'idle' | 'inactive';
+    };
+}
+/** One audit round's outcome (the verdict + synthesized repair + acceptance). */
+export interface AuditRoundOutcome {
+    readonly verdict: AuditVerdict;
+    /** Repair instruction synthesized from findings (REVISE only). */
+    readonly repair?: string;
+    /** Whether the underlying delegation result itself was accepted. */
+    readonly accepted: boolean;
+    readonly reason?: string;
+}
+/** One completed loop round (the task revision trail for the board history). */
+export interface AuditLoopRound {
+    readonly round: number;
+    readonly verdict: AuditVerdict;
+    readonly repair?: string;
+    readonly taskRevision: number;
+}
+/** The auditToPass result. */
+export interface AuditToPassResult {
+    readonly ok: boolean;
+    readonly reason?: string;
+    /** The durable task the loop ran on (revision trail lives on the team log). */
+    readonly taskId?: TeamTaskIdLike;
+    readonly rounds: AuditLoopRound[];
+    /** True only when an APPROVE verdict completed the task and locked the phase. */
+    readonly locked: boolean;
+    /** Latest task view (board-facing per-phase history). */
+    readonly taskView?: TeamTaskViewLike;
+}
+/** Inputs for one audit-to-pass loop. */
+export interface AuditToPassInput {
+    /** The agentTeams seam. */
+    readonly teams: TeamRuntimeLike;
+    /** Exact live Team member/lead authorizing the task mutations. */
+    readonly caller: TeamCallerHandle;
+    /** Phase + run identity (task subject/description vocabulary). */
+    readonly runId: string;
+    readonly phase: string;
+    /** Optional task blockers (previous-phase task ids). */
+    readonly blockedBy?: readonly TeamTaskIdLike[];
+    /** Write scopes for the phase artifact (advisory, overlap-warned). */
+    readonly writeScopes?: readonly string[];
+    /** Run ONE audit round for the current task; live usage delegates (T4). */
+    readonly runAuditRound: (round: number, task: TeamTaskViewLike) => Promise<AuditRoundOutcome>;
+    /** Lock the phase artifact — called ONLY after an APPROVE verdict. */
+    readonly lockPhase: () => Promise<void>;
+    /** Team member name to interrupt on a stuck reviewer (defaults to the role). */
+    readonly reviewerName?: string;
+    /** Round cap (fail loud past it; no lock). */
+    readonly maxRounds?: number;
+    /** Per-round wait timeout before the audit round runs (skipped without the seam). */
+    readonly waitTimeoutMs?: number;
+}
+/**
+ * Render a per-phase task history (board-facing; pure). One line per round plus
+ * the final task status — no live data, no mutation.
+ */
+export declare function renderTaskHistory(task: TeamTaskViewLike | undefined, rounds: readonly AuditLoopRound[]): string;
+/**
+ * T3 driver: audit the phase until it passes, on ONE durable team task.
+ *
+ * Transition trail (the fake records exactly this order):
+ *   createTask(pending) → claim(in_progress) → waitForChange → audit round
+ *   → REVISE: updateTask(edit, repair) → waitForChange → re-audit SAME task
+ *   → APPROVE: updateTask(complete) → lockPhase()
+ *   → REJECT / cap / stuck: updateTask(release) + interrupt, NO lock.
+ */
+export declare function auditToPass(input: AuditToPassInput): Promise<AuditToPassResult>;
+/** Whether a task view is currently claimed by the named owner (board-facing). */
+export declare function isTaskClaimedBy(task: TeamTaskViewLike, ownerName: string): boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@try-works/dsh-recursive-mode",
   "description": "recursive-mode workflow as a DeepSeek Harness bundle: RecursiveRuntime service + recursive_status tool",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/scripts/test-recursive-mode-smoke.ts

@@ -24,11 +24,12 @@ import { createHandoff, createChildBrief, replyPath, childScratchPath, buildDele
 import { resolveRole, capabilityProbe, loadRouterPolicy } from '../src/router.ts'
 import { validateReferences, writeActionRecord, reviewOutputSchema } from '../src/delegation.ts'
 import { writeChildScratch, readParentScratch } from '../src/scratch.ts'
-import { foldRecursivePhase, validateTransition, LifecycleDriver, coupleGateBlockToGoal, type SessionEventLike, type PhaseTransitionIntent } from '../src/lifecycle.ts'
+import { validateTransition, coupleGateBlockToGoal, type PhaseTransitionIntent } from '../src/lifecycle.ts'
 import { snapshotWorkspace } from '../src/snapshot.ts'
 import { RECURSIVE_API_PREFIX, makeRecursiveRoutes, mountRecursiveRoutesOnce } from '../src/live-route.ts'
 import { columnForRun, cardFacts, nodeKeyOf, expandPhaseRows } from '../src/client/derive.ts'
-import { evaluatePreStepGate, evaluateToolGuard, resolveEnforcementConfig, DEFAULT_ENFORCEMENT, detectTamper } from '../src/enforcement.ts'
+import { evaluateToolGuard, coerceAskToDecision, resolveEnforcementConfig, DEFAULT_ENFORCEMENT, detectTamper } from '../src/enforcement.ts'
+import { syncRunGoal, blockRunGoal, type GoalServiceLike, type GoalViewLike } from '../src/goals-projection.ts'
 import { renderRecursivePolicy } from '../src/policy.ts'
 
 let failures = 0
@@ -136,25 +137,35 @@ async function main() {
     const arec = writeActionRecord({ root: wsA, runId: '10-smoke', subagentId: 'c1', phase: '03.5', purpose: 'review', executionMode: 'self-audit', success: false, stopReason: 'none' })
     check('R6 action record', existsSync(arec) && readFileSync(arec, 'utf8').includes('## Verification Handoff'))
 
-    // Phase C (run 05) smoke: lifecycle fold + transition, pre-step gate, tool guard, policy, tamper, goal coupling
-    const lifeEvents: SessionEventLike[] = [
-      { type: 'recursive/phase', data: { runId: '10-smoke', phase: '03', status: 'LOCKED' } },
-      { type: 'recursive/run-state', data: { runId: '10-smoke', state: 'active' } },
-    ]
-    const folded = foldRecursivePhase(lifeEvents)
-    check('R1 fold last-wins phase', folded?.phase === '03' && folded?.runState === 'active')
+    // Phase C (run 05) smoke: transition gate (zero-emission surface), tool
+    // guard, T6 ask->policy bridge, policy, tamper, T1 goals projection.
     const gatedIntent: PhaseTransitionIntent = { runId: '10-smoke', worktreeRoot: wsA, targetArtifact: '03-implementation-summary.md', kind: 'lock' }
-    const gate = evaluatePreStepGate([{ type: 'recursive/phase-intent', data: gatedIntent }], 'advisory')
-    check('R3 pre-step advisory warns (gateBlocked)', gate.gateBlocked === true && gate.kind === 'enter')
-    const gateStrict = evaluatePreStepGate([{ type: 'recursive/phase-intent', data: gatedIntent }], 'strict')
-    check('R3 pre-step strict rejects', gateStrict.kind === 'reject' && gateStrict.gateBlocked === true)
-    check('R3 pre-step no intent enters', evaluatePreStepGate([], 'strict').kind === 'enter')
+    const gateCheck = validateTransition(gatedIntent)
+    check('R1 transition gate reads the lock chain', gateCheck.passed === false && gateCheck.failures.length > 0, gateCheck.failures.join(';'))
     const tddContent = 'Run: 10-smoke\nPhase: 3\nStatus: DRAFT\nTDD Mode: strict\nRED: evidence/logs/red/tdd-red.md\nGREEN: evidence/logs/green/tdd-green.md\n'
     writeFileSync(join(runDir, '03-implementation-summary.md'), tddContent, 'utf8')
+    // Lock 03's prerequisites so the in-order lock guard passes (monotonic chain).
+    // 01/02 are audited phases: the fold requires Audit: PASS for lock-valid.
+    for (const [file, phase, audited] of [['00-worktree.md', '0 (Worktree)', false], ['01-as-is.md', '1 (AS-IS)', true], ['02-to-be-plan.md', '2 (TO-BE Plan)', true]] as const) {
+      const doc = [
+        'Run: 10-smoke', 'Phase: ' + phase, 'Status: `LOCKED`', 'Workflow version: recursive-mode-audit-v2', '',
+        '## TODO', '', '- [x] done', '', 'Coverage: PASS', 'Approval: PASS',
+        ...(audited ? ['Audit: PASS'] : []),
+        'LockedAt: `2026-01-15T10:00:00Z`', 'LockHash: `PLACEHOLDER`', '',
+      ].join('\n')
+      const docHash = lockHashFromContent(doc.replace('PLACEHOLDER', '0'.repeat(64)))
+      writeFileSync(join(runDir, file), doc.replace('PLACEHOLDER', docHash), 'utf8')
+    }
     const lockGuard = evaluateToolGuard({ name: 'recursive_lock', arguments: { artifact: '03-implementation-summary.md' } }, wsA, '10-smoke', 'strict')
     check('R4 tool guard allows in-order lock', lockGuard.kind === 'allow')
     const outOfOrder = evaluateToolGuard({ name: 'recursive_lock', arguments: { artifact: '05-manual-qa.md' } }, wsA, '10-smoke', 'strict')
     check('R4 tool guard denies out-of-order lock', outOfOrder.kind === 'deny' && (outOfOrder as { reason: string }).reason.includes('monotonic'))
+    const askDecision = evaluateToolGuard({ name: 'recursive_lock', arguments: { artifact: '05-manual-qa.md' } }, wsA, '10-smoke', 'advisory')
+    check('T6 advisory guard asks', askDecision.kind === 'ask')
+    const coercedStrict = coerceAskToDecision(askDecision, 'strict')
+    const coercedAdvisory = coerceAskToDecision(askDecision, 'advisory')
+    check('T6 ask->deny under strict', coercedStrict.kind === 'deny')
+    check('T6 ask->allow+warn under advisory (never silent)', coercedAdvisory.kind === 'allow' && typeof (coercedAdvisory as { warn?: string }).warn === 'string')
     check('R7 config default advisory', JSON.stringify(resolveEnforcementConfig(undefined)) === JSON.stringify(DEFAULT_ENFORCEMENT))
     let configError = ''
     try { resolveEnforcementConfig({ bogus: 1 }) } catch (err) { configError = (err as Error).message }
@@ -163,6 +174,21 @@ async function main() {
     check('R5 policy renders contract', policyText.includes('recursive-mode session') && policyText.includes('Current phase'))
     check('R8 tamper clean', detectTamper(join(runDir, '03-implementation-summary.md'), wsA, '10-smoke') === null)
     check('R6 goal coupling no-op', coupleGateBlockToGoal(null, {}, { id: 'g' }, { code: 'G', message: 'x' }) === false)
+    // T1 (goals projection): structural fake of the live goals service.
+    let goalCurrent: GoalViewLike | undefined
+    const goalService: GoalServiceLike = {
+      get: () => goalCurrent,
+      create: (_agent, req) => { goalCurrent = { id: 'g1', revision: 1, objective: req.objective, phase: 'active' }; return goalCurrent },
+      block: (_agent, ref) => { if (!goalCurrent || goalCurrent.id !== ref.id) throw new Error('mismatch'); goalCurrent = { ...goalCurrent, phase: 'blocked', revision: ref.revision + 1 }; return goalCurrent },
+      pause: (_agent, ref) => { goalCurrent = { ...(goalCurrent ?? { id: ref.id, revision: ref.revision }), phase: 'paused', revision: ref.revision + 1 }; return goalCurrent },
+      resume: (_agent, ref) => { goalCurrent = { ...(goalCurrent ?? { id: ref.id, revision: ref.revision }), phase: 'active', revision: ref.revision + 1 }; return goalCurrent },
+      complete: (_agent, ref) => { goalCurrent = { ...(goalCurrent ?? { id: ref.id, revision: ref.revision }), phase: 'complete', revision: ref.revision + 1 }; return goalCurrent },
+      clear: (_agent, ref) => { goalCurrent = undefined; return { id: ref.id, revision: ref.revision + 1 } },
+    }
+    const goalSync = syncRunGoal(goalService, {}, '10-smoke', 'active')
+    check('T1 run goal armed', goalSync.ok === true && goalCurrent?.objective === 'recursive-run:10-smoke · active')
+    const goalBlock = blockRunGoal(goalService, {}, '10-smoke', { code: 'prerequisite-blockers', message: 'monotonic lock-order' })
+    check('T1 gate-block blocks the run goal', goalBlock.ok === true && goalCurrent?.phase === 'blocked')
 
 
     // ---- Phase D checks (SP2 R1 live route, replaces the session projection) ----
@@ -179,21 +205,21 @@ async function main() {
     // R5/R6 derive over the snapshot card (furthest present phase is 06 -> closeout lane).
     check('R5 columnForRun maps to the furthest present phase', columnForRun(card as never) === '6-8')
     const facts = cardFacts(card as never)
-    // 00-requirements.md is LOCKED (written above); 03 is DRAFT; no tamper;
-    // no gate-block (the fs carries none of the transient event facts).
-    check('R5 cardFacts progress + tampered + gateBlocked', facts.lockedCount === 1 && facts.tampered === false && facts.gateBlocked === false)
+    // Locked groups: 00 (requirements+worktree share one group), 01, 02.
+    // 03 is DRAFT; no tamper; no gate-block (the fs carries no transient facts).
+    check('R5 cardFacts progress + tampered + gateBlocked', facts.lockedCount === 3 && facts.tampered === false && facts.gateBlocked === false)
     // R7 node key
     check('R7 nodeKeyOf includes worktreeRoot', nodeKeyOf('10-smoke', wsA).includes(wsA))
     check('R6 expandPhaseRows always shows 3.5', expandPhaseRows(card as never).some(r => r.phase === '03.5'))
     // R2 route: prefix + mountOnce-global (second mount no-ops)
     check('R2 route prefix', RECURSIVE_API_PREFIX === '/.recursive/api')
     const routes = makeRecursiveRoutes({ resolveRoot: async () => wsA, snapshot: async (root: string) => snapshotWorkspace(root), revision: () => 1 })
-    check('R2 route count', routes.length === 2 && routes[0].kind === 'exact' && routes[1].kind === 'exact')
+    check('R2 route count (state, events, doc)', routes.length === 3 && routes[0].kind === 'exact' && routes[1].kind === 'exact' && routes[2].kind === 'exact')
     let registerCount = 0
     const fakeServer = { register: () => { registerCount++; return () => {} } }
     const mk = () => mountRecursiveRoutesOnce('@try-works/dsh-recursive-mode', () => makeRecursiveRoutes({ resolveRoot: async () => wsA, snapshot: async (root: string) => snapshotWorkspace(root), revision: () => 1 }), fakeServer)
     mk(); mk()
-    check('R2 mountOnce-global (second mount no-ops)', registerCount === 2)
+    check('R2 mountOnce-global (second mount no-ops)', registerCount === 3)
 
     console.log(failures === 0 ? 'SMOKE PASS' : 'SMOKE FAIL (' + failures + ' failures)')
     process.exitCode = failures === 0 ? 0 : 1