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

package/lib/client.js

@@ -153,6 +153,10 @@ window.__ModuleLoader__.load({
 			if (best === null) return "0";
 			return laneOf(best + "-x") ?? "0";
 		}
+		/** T21: the single derived positions present on a card's rows, in phase order. */
+		function rowPositions(card) {
+			return Object.values(card.phases).map((row) => row.position).filter((p) => p !== void 0);
+		}
 		/** Derive §11.4 presentation facts from one card (no fs, no session). */
 		function cardFacts(card) {
 			const groups = /* @__PURE__ */ new Set();
@@ -184,10 +188,13 @@ window.__ModuleLoader__.load({
 					currentPhase = key;
 				}
 			}
-			const tampered = Object.keys(card.tampers).length > 0;
+			const tampered = Object.keys(card.tampers).length > 0 || rowPositions(card).includes("tampered");
 			const allMandatoryLocked = MANDATORY_GROUPS.every((g) => {
 				const row = Object.entries(card.phases).find(([key]) => phaseGroupOf(key) === g);
-				return row !== void 0 && row[1].status === "LOCKED";
+				if (row === void 0) return false;
+				const phase = row[1];
+				if (phase.position !== void 0) return phase.position === "locked";
+				return phase.status === "LOCKED";
 			});
 			const lockValidity = tampered ? "tampered" : allMandatoryLocked ? "locked" : "in-progress";
 			return {

package/lib/closeout-report.d.ts

@@ -0,0 +1,113 @@
+/** The phase → artifact map. A LOOKUP, not a template: nothing here is ever rendered into a file. */
+export declare const CLOSEOUT_PHASE_FILES: Record<string, {
+    file: string;
+    label: string;
+}>;
+/** One thing the agent must add or fix before the artifact can lock. */
+export interface CloseoutFinding {
+    kind: 'missing-artifact' | 'missing-section' | 'gate-not-passing';
+    /** Directory-ready: what is wrong, in the words the agent should act on. */
+    detail: string;
+}
+export interface CloseoutReport {
+    phase: string;
+    artifact: string;
+    label: string;
+    exists: boolean;
+    /** `LOCKED`, `DRAFT`, `STALE_LOCK`, `MISSING` — from the same reader the lock tool uses. */
+    status: string;
+    /** Empty means the artifact fits the standard; the caller tells the agent only when it is not. */
+    findings: CloseoutFinding[];
+    /**
+     * Advisory only: earlier artifacts that are not yet LOCKED. **Not a refusal** — the reference treats these
+     * as warnings (*"hard enforcement happens at lock time"*), and a closeout that refuses here cannot do the
+     * one thing it exists for.
+     */
+    prerequisites: Array<{
+        artifact: string;
+        status: string;
+    }>;
+    /** The rules text to hand the agent, straight from the rules module. */
+    guidance: string[];
+    /** Addenda found anywhere in the run tree — cited as evidence, never written to. */
+    addenda: string[];
+}
+export interface CloseoutReportOptions {
+    workflowProfile?: string;
+    /** Include the advisory prerequisite list. Default true. */
+    checkPrerequisites?: boolean;
+}
+/**
+ * Examine one phase artifact and report what it is missing. **Reads only.**
+ *
+ * An absent artifact is a finding rather than an error: the closeout's job is to say what should be there,
+ * and "not written yet" is the most useful thing it can tell an agent at phase entry.
+ */
+export declare function closeoutReport(runDir: string, phase: string, options?: CloseoutReportOptions): CloseoutReport;
+/** Anything in the run's artifact sequence that this report does not cover, for a whole-run sweep. */
+export declare function uncoveredArtifacts(): string[];
+/**
+ * Where a closeout receipt lives: **its own file, beside the lock receipts, never over the artifact.**
+ *
+ * ⚠ FOLLOWS `lock.ts`'s `receiptPath`, which is the convention this plugin already has: a receipt is a JSON
+ * file under `<runDir>/locks/` named after the artifact stem. The closeout receipt deliberately does NOT
+ * reuse `<stem>.receipt.json` — that name belongs to the LOCK receipt, which carries a hash and is read by
+ * `getLockStatus`. A distinct suffix keeps them together without a collision.
+ */
+export declare function closeoutReceiptPath(runDir: string, phase: string): string;
+/**
+ * Record the report as a closeout receipt. **The only write in this module, and it is never the artifact.**
+ *
+ * ⚠ WHY A RECEIPT AT ALL, in the user's words: a closeout *"should potentially create a close out receipt,
+ * that is ok and valuable, as long as it doesnt overwrite the phase docs."* So the durable trace of "the
+ * closeout examined this phase" is a file of its own, and the phase document is read and reported on but
+ * never touched.
+ *
+ * The JSON is a plain projection of the report — no timestamp, so the receipt is a pure function of the run
+ * state and two calls on the same run produce identical bytes.
+ */
+export declare function writeCloseoutReceipt(runDir: string, phase: string, options?: CloseoutReportOptions): {
+    path: string;
+    report: CloseoutReport;
+    runReceipt: {
+        path: string;
+        report: RunCloseoutReport;
+    } | null;
+};
+/** Where the RUN-level closeout receipt lives: the run root, one per run. */
+export declare function runCloseoutReceiptPath(runDir: string): string;
+/** One artifact's line in the run-level receipt. */
+export interface RunArtifactState {
+    artifact: string;
+    exists: boolean;
+    /** `LOCKED`, `DRAFT`, `STALE_LOCK` — or `ABSENT` when the artifact was never written. */
+    status: string;
+    /** Empty when this artifact fits the standard. */
+    findings: CloseoutFinding[];
+}
+export interface RunCloseoutReport {
+    /** Every artifact in the run's sequence, in order — 00 through 08, not only the closeout phases. */
+    artifacts: RunArtifactState[];
+    /** How many of them fit the standard, for a one-line summary. */
+    conforming: number;
+}
+/**
+ * The RUN-level report: every artifact in the run, not just the phases the closeout reports on.
+ *
+ * ⚠ WHY IT SPANS 00–08: the user's point, and it is the right one — a receipt *"represents what was done in
+ * the run"*, so it must include the early artifacts. The earlier correction still holds and is not undone by
+ * this: the closeout must never WRITE those documents (`recursive_init` owns them). It READS them, holds them
+ * to the same standard, and records their state. Reading a broad set and writing a narrow one is exactly the
+ * distinction that was missing.
+ */
+export declare function runCloseoutReport(runDir: string, options?: CloseoutReportOptions): RunCloseoutReport;
+/**
+ * Record the run-level receipt. **Its own file at the run root**, never a phase document.
+ *
+ * The JSON is a pure projection of the run state — no timestamp — so two calls on the same run produce
+ * identical bytes, which is what makes it comparable between runs.
+ */
+export declare function writeRunCloseoutReceipt(runDir: string, options?: CloseoutReportOptions): {
+    path: string;
+    report: RunCloseoutReport;
+};

package/lib/closeout-standards.d.ts

@@ -0,0 +1,35 @@
+export interface StandardViolation {
+    /** Run-relative artifact name, or the sequence entry that was absent. */
+    artifact: string;
+    kind: 'missing-artifact' | 'missing-section' | 'gate-not-passing' | 'not-locked';
+    /** What is wrong, spelled so a caller can print it without re-deriving anything. */
+    detail: string;
+}
+export interface StandardsReport {
+    /** How many artifacts from the sequence were present and examined. */
+    checked: number;
+    /** Artifacts in the sequence that do not exist yet — informational, not necessarily a failure. */
+    absent: string[];
+    violations: StandardViolation[];
+}
+export interface StandardsOptions {
+    /** Workflow profile whose rules apply; defaults to the current one, as every caller does. */
+    workflowProfile?: string;
+    /**
+     * Report artifacts that are present but not LOCKED. **OFF by default**: a closeout runs mid-run and a DRAFT
+     * artifact is the normal state, so treating it as a violation would make the check useless exactly when it
+     * is most wanted. Callers that need an all-locked assertion ask for it.
+     */
+    requireLocked?: boolean;
+}
+/**
+ * Examine every artifact in the run against the phase rules.
+ *
+ * Reports, per present artifact: required headings that are missing, gate lines that are missing or FAIL, and
+ * (only when `requireLocked`) a status that is not LOCKED. Absent artifacts are listed separately — during a
+ * closeout most of the sequence legitimately does not exist yet, and conflating "not written yet" with
+ * "written wrong" would bury the findings that matter.
+ */
+export declare function verifyRunStandards(runDir: string, options?: StandardsOptions): StandardsReport;
+/** One line per violation, for a tool result or a CLI print. Empty when the run fits the standard. */
+export declare function formatStandardsReport(report: StandardsReport): string[];

package/lib/closeout.d.ts

@@ -10,6 +10,12 @@ export interface CloseoutResult {
     file: string;
     created: string[];
     existing: string[];
+    /**
+     * Every addendum found anywhere in the run tree, as run-relative paths — and cited in the scaffolded
+     * receipt. Optional on the TYPE so a caller that builds its own result literal still compiles; the
+     * closeout itself always populates it.
+     */
+    addenda?: string[];
 }
 export interface CloseoutOptions {
     /** Enforce prerequisite-lock gating (default true). */
@@ -19,5 +25,11 @@ export interface CloseoutOptions {
  * Create or update a closeout receipt stub for the given phase.
  * Returns the file + created/existing lists. When strict, refuses phases whose
  * prerequisite artifacts are not all LOCKED (reuses lock.ts chain validation).
+ *
+ * ⚠ ADDENDA ARE PART OF THE CLOSEOUT WORK, and they are CITED, never written. An addendum closes a gap in
+ * an artifact that is already locked, which is precisely the kind of thing a receipt must account for — and
+ * they are not always in `addenda/`: the real ones sit beside the artifact they close, in the run ROOT. So
+ * the receipt lists every addendum in the run tree (see {@link getRunTreeAddenda}), and says so explicitly
+ * when there are none, because "we looked and found none" and "we never looked" must not read alike.
  */
 export declare function closeoutPhase(runDir: string, phase: string, opts?: CloseoutOptions): CloseoutResult;

package/lib/commands.d.ts

@@ -1,5 +1,5 @@
 import type { RecursiveRuntime } from './runtime.ts';
-export type RecursiveVerb = 'status' | 'spec' | 'worktree' | 'init' | 'lock' | 'qa' | 'closeout' | 'addendum' | 'review' | 'scratch' | 'bootstrap' | 'list' | 'help';
+export type RecursiveVerb = 'status' | 'spec' | 'worktree' | 'init' | 'lock' | 'qa' | 'closeout' | 'addendum' | 'review' | 'scratch' | 'memory' | 'model' | 'bootstrap' | 'list' | 'help';
 export declare const PRESET_VERBS: RecursiveVerb[];
 export declare const GLOBAL_VERBS: RecursiveVerb[];
 export declare const ALL_VERBS: RecursiveVerb[];

package/lib/config.d.ts

@@ -0,0 +1,202 @@
+/**
+ * T7 — the plugin's Config: the `recursive` settings namespace.
+ *
+ * HOW THE SETTINGS SERVICE ACTUALLY SEES THIS, measured against
+ * `@deepseek-ai/dsh-settings`'s own types rather than assumed: `describe()` "read[s]
+ * active plugin schemas and their live values", and `update(ns, patch, expectedRevision)`
+ * "merge[s] editable fields into an entry's config". There is **no `register(...)` call
+ * for a plugin to make** — the item's `registerEnforcementSettings(settings)` wording
+ * describes a seam that does not exist. **Declaring this schema IS the registration:**
+ * the Loader owns the profile entry, the service projects the schema into a form, and an
+ * edit re-applies the plugin with the new config. That re-application IS the hot reload,
+ * which is why there is no watcher here to keep in sync.
+ *
+ * VALIDATION IS NOT DUPLICATED. The schema is what the UI reads and what gives the form
+ * its shape; `resolveEnforcementConfig` remains the STRICT validator (unknown keys
+ * rejected, budgets required to be positive integers, fail-loud at load). A schema that
+ * silently coerced a bad value would be a second, weaker contract beside the real one.
+ */
+import z from '@deepseek-ai/schemastery';
+export interface RecursiveModeBudgets {
+    maxAuditRounds?: number;
+    maxRepairAttempts?: number;
+    maxDelegationDepth?: number;
+    maxChildrenPerPhase?: number;
+    maxResultBytes?: number;
+}
+export interface RecursiveModeEnforcement {
+    preStep?: 'strict' | 'advisory';
+    toolGuards?: 'strict' | 'advisory';
+    tamper?: 'strict' | 'advisory';
+    budgets?: RecursiveModeBudgets;
+}
+export interface RecursiveModeConfig {
+    /** R4 shell split: expose ONLY the client bundle, registering nothing server-side. */
+    shellOnly?: boolean;
+    repoRoot?: string;
+    /** T7/T28: the enforcement modes and the budgets, editable live. */
+    enforcement?: RecursiveModeEnforcement;
+    /** T7: overrides for the workspace router file — see the schema comment on defaults. */
+    router?: {
+        defaults?: Record<string, string | number | boolean | undefined>;
+    };
+}
+/**
+ * The schema the settings service discovers. Field descriptions are the form's help
+ * text, so they are written for the person toggling them, not for the reader of this file.
+ */
+export declare const Config: z<Schemastery.ObjectS<NoInfer<{
+    shellOnly: z<boolean, boolean, "defined">;
+    repoRoot: z<string, string, "plain">;
+    enforcement: z<Schemastery.ObjectS<NoInfer<{
+        preStep: z<"strict" | "advisory", "strict" | "advisory", "defined">;
+        toolGuards: z<"strict" | "advisory", "strict" | "advisory", "defined">;
+        tamper: z<"strict" | "advisory", "strict" | "advisory", "defined">;
+        budgets: z<Schemastery.ObjectS<NoInfer<{
+            maxAuditRounds: z<number, number, "defined">;
+            maxRepairAttempts: z<number, number, "defined">;
+            maxDelegationDepth: z<number, number, "defined">;
+            maxChildrenPerPhase: z<number, number, "defined">;
+            maxResultBytes: z<number, number, "defined">;
+        }>>, Schemastery.ObjectT<NoInfer<{
+            maxAuditRounds: z<number, number, "defined">;
+            maxRepairAttempts: z<number, number, "defined">;
+            maxDelegationDepth: z<number, number, "defined">;
+            maxChildrenPerPhase: z<number, number, "defined">;
+            maxResultBytes: z<number, number, "defined">;
+        }>>, "plain">;
+    }>>, Schemastery.ObjectT<NoInfer<{
+        preStep: z<"strict" | "advisory", "strict" | "advisory", "defined">;
+        toolGuards: z<"strict" | "advisory", "strict" | "advisory", "defined">;
+        tamper: z<"strict" | "advisory", "strict" | "advisory", "defined">;
+        budgets: z<Schemastery.ObjectS<NoInfer<{
+            maxAuditRounds: z<number, number, "defined">;
+            maxRepairAttempts: z<number, number, "defined">;
+            maxDelegationDepth: z<number, number, "defined">;
+            maxChildrenPerPhase: z<number, number, "defined">;
+            maxResultBytes: z<number, number, "defined">;
+        }>>, Schemastery.ObjectT<NoInfer<{
+            maxAuditRounds: z<number, number, "defined">;
+            maxRepairAttempts: z<number, number, "defined">;
+            maxDelegationDepth: z<number, number, "defined">;
+            maxChildrenPerPhase: z<number, number, "defined">;
+            maxResultBytes: z<number, number, "defined">;
+        }>>, "plain">;
+    }>>, "plain">;
+    /**
+     * T7 — the ROUTER overrides. Deliberately NO defaults on these fields: `.default()`
+     * would make every field present, and a present field overrides the workspace's
+     * `recursive-router.json` — so defaulting them would silently shadow the declarative
+     * file forever. Absent means "defer to the file"; present means "override it".
+     */
+    router: z<Schemastery.ObjectS<NoInfer<{
+        defaults: z<Schemastery.ObjectS<NoInfer<{
+            when_role_unconfigured: z<"ask" | "fallback-local", "ask" | "fallback-local", "plain">;
+            when_cli_unavailable: z<"ask" | "fallback-local", "ask" | "fallback-local", "plain">;
+            when_model_unknown: z<"ask" | "fallback-local", "ask" | "fallback-local", "plain">;
+            allow_auto_assign_if_single_cli: z<boolean, boolean, "plain">;
+            probe_timeout_ms: z<number, number, "plain">;
+            invoke_timeout_ms: z<number, number, "plain">;
+        }>>, Schemastery.ObjectT<NoInfer<{
+            when_role_unconfigured: z<"ask" | "fallback-local", "ask" | "fallback-local", "plain">;
+            when_cli_unavailable: z<"ask" | "fallback-local", "ask" | "fallback-local", "plain">;
+            when_model_unknown: z<"ask" | "fallback-local", "ask" | "fallback-local", "plain">;
+            allow_auto_assign_if_single_cli: z<boolean, boolean, "plain">;
+            probe_timeout_ms: z<number, number, "plain">;
+            invoke_timeout_ms: z<number, number, "plain">;
+        }>>, "plain">;
+    }>>, Schemastery.ObjectT<NoInfer<{
+        defaults: z<Schemastery.ObjectS<NoInfer<{
+            when_role_unconfigured: z<"ask" | "fallback-local", "ask" | "fallback-local", "plain">;
+            when_cli_unavailable: z<"ask" | "fallback-local", "ask" | "fallback-local", "plain">;
+            when_model_unknown: z<"ask" | "fallback-local", "ask" | "fallback-local", "plain">;
+            allow_auto_assign_if_single_cli: z<boolean, boolean, "plain">;
+            probe_timeout_ms: z<number, number, "plain">;
+            invoke_timeout_ms: z<number, number, "plain">;
+        }>>, Schemastery.ObjectT<NoInfer<{
+            when_role_unconfigured: z<"ask" | "fallback-local", "ask" | "fallback-local", "plain">;
+            when_cli_unavailable: z<"ask" | "fallback-local", "ask" | "fallback-local", "plain">;
+            when_model_unknown: z<"ask" | "fallback-local", "ask" | "fallback-local", "plain">;
+            allow_auto_assign_if_single_cli: z<boolean, boolean, "plain">;
+            probe_timeout_ms: z<number, number, "plain">;
+            invoke_timeout_ms: z<number, number, "plain">;
+        }>>, "plain">;
+    }>>, "plain">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    shellOnly: z<boolean, boolean, "defined">;
+    repoRoot: z<string, string, "plain">;
+    enforcement: z<Schemastery.ObjectS<NoInfer<{
+        preStep: z<"strict" | "advisory", "strict" | "advisory", "defined">;
+        toolGuards: z<"strict" | "advisory", "strict" | "advisory", "defined">;
+        tamper: z<"strict" | "advisory", "strict" | "advisory", "defined">;
+        budgets: z<Schemastery.ObjectS<NoInfer<{
+            maxAuditRounds: z<number, number, "defined">;
+            maxRepairAttempts: z<number, number, "defined">;
+            maxDelegationDepth: z<number, number, "defined">;
+            maxChildrenPerPhase: z<number, number, "defined">;
+            maxResultBytes: z<number, number, "defined">;
+        }>>, Schemastery.ObjectT<NoInfer<{
+            maxAuditRounds: z<number, number, "defined">;
+            maxRepairAttempts: z<number, number, "defined">;
+            maxDelegationDepth: z<number, number, "defined">;
+            maxChildrenPerPhase: z<number, number, "defined">;
+            maxResultBytes: z<number, number, "defined">;
+        }>>, "plain">;
+    }>>, Schemastery.ObjectT<NoInfer<{
+        preStep: z<"strict" | "advisory", "strict" | "advisory", "defined">;
+        toolGuards: z<"strict" | "advisory", "strict" | "advisory", "defined">;
+        tamper: z<"strict" | "advisory", "strict" | "advisory", "defined">;
+        budgets: z<Schemastery.ObjectS<NoInfer<{
+            maxAuditRounds: z<number, number, "defined">;
+            maxRepairAttempts: z<number, number, "defined">;
+            maxDelegationDepth: z<number, number, "defined">;
+            maxChildrenPerPhase: z<number, number, "defined">;
+            maxResultBytes: z<number, number, "defined">;
+        }>>, Schemastery.ObjectT<NoInfer<{
+            maxAuditRounds: z<number, number, "defined">;
+            maxRepairAttempts: z<number, number, "defined">;
+            maxDelegationDepth: z<number, number, "defined">;
+            maxChildrenPerPhase: z<number, number, "defined">;
+            maxResultBytes: z<number, number, "defined">;
+        }>>, "plain">;
+    }>>, "plain">;
+    /**
+     * T7 — the ROUTER overrides. Deliberately NO defaults on these fields: `.default()`
+     * would make every field present, and a present field overrides the workspace's
+     * `recursive-router.json` — so defaulting them would silently shadow the declarative
+     * file forever. Absent means "defer to the file"; present means "override it".
+     */
+    router: z<Schemastery.ObjectS<NoInfer<{
+        defaults: z<Schemastery.ObjectS<NoInfer<{
+            when_role_unconfigured: z<"ask" | "fallback-local", "ask" | "fallback-local", "plain">;
+            when_cli_unavailable: z<"ask" | "fallback-local", "ask" | "fallback-local", "plain">;
+            when_model_unknown: z<"ask" | "fallback-local", "ask" | "fallback-local", "plain">;
+            allow_auto_assign_if_single_cli: z<boolean, boolean, "plain">;
+            probe_timeout_ms: z<number, number, "plain">;
+            invoke_timeout_ms: z<number, number, "plain">;
+        }>>, Schemastery.ObjectT<NoInfer<{
+            when_role_unconfigured: z<"ask" | "fallback-local", "ask" | "fallback-local", "plain">;
+            when_cli_unavailable: z<"ask" | "fallback-local", "ask" | "fallback-local", "plain">;
+            when_model_unknown: z<"ask" | "fallback-local", "ask" | "fallback-local", "plain">;
+            allow_auto_assign_if_single_cli: z<boolean, boolean, "plain">;
+            probe_timeout_ms: z<number, number, "plain">;
+            invoke_timeout_ms: z<number, number, "plain">;
+        }>>, "plain">;
+    }>>, Schemastery.ObjectT<NoInfer<{
+        defaults: z<Schemastery.ObjectS<NoInfer<{
+            when_role_unconfigured: z<"ask" | "fallback-local", "ask" | "fallback-local", "plain">;
+            when_cli_unavailable: z<"ask" | "fallback-local", "ask" | "fallback-local", "plain">;
+            when_model_unknown: z<"ask" | "fallback-local", "ask" | "fallback-local", "plain">;
+            allow_auto_assign_if_single_cli: z<boolean, boolean, "plain">;
+            probe_timeout_ms: z<number, number, "plain">;
+            invoke_timeout_ms: z<number, number, "plain">;
+        }>>, Schemastery.ObjectT<NoInfer<{
+            when_role_unconfigured: z<"ask" | "fallback-local", "ask" | "fallback-local", "plain">;
+            when_cli_unavailable: z<"ask" | "fallback-local", "ask" | "fallback-local", "plain">;
+            when_model_unknown: z<"ask" | "fallback-local", "ask" | "fallback-local", "plain">;
+            allow_auto_assign_if_single_cli: z<boolean, boolean, "plain">;
+            probe_timeout_ms: z<number, number, "plain">;
+            invoke_timeout_ms: z<number, number, "plain">;
+        }>>, "plain">;
+    }>>, "plain">;
+}>>, "plain">;

package/lib/delegation.d.ts

@@ -57,6 +57,18 @@ export interface SubagentStartRequestLike {
     persona?: string;
     parent?: unknown;
     signal?: unknown;
+    /**
+     * T9 — the child's provider/model overrides.
+     *
+     * ⚠ `SubagentStartRequest.agentOptions` is only valid for a provider that DECLARES
+     * `capabilities.agentOptions`; the harness REJECTS a start that sends it otherwise. Passing
+     * it unconditionally would therefore BREAK delegations on providers that do not support it,
+     * which is why the caller gates on the capability rather than on the model being non-null.
+     */
+    agentOptions?: {
+        model?: string;
+        provider?: string;
+    };
 }
 export interface SubagentResultLike {
     output?: string;
@@ -155,13 +167,77 @@ export interface ContinuableDelegationLike {
     accepted: boolean;
     /** True when the fallback one-shot `delegate()` was used (no continuable seam). */
     fellBackToOneShot?: boolean;
+    /**
+     * True when the round ended because NO settlement has landed yet — the caller's
+     * signal to resume on a later turn with the SAME `childId`, not a failure. The
+     * harness offers no parent-side await-settlement promise, so this is the honest
+     * report of "the child is still working".
+     */
+    parked?: boolean;
 }
 /** Verdict vocabulary shared by T3/T4 (matches the delegated review schema). */
 export type DelegationVerdict = 'APPROVE' | 'REVISE' | 'REJECT';
+/**
+ * T28 — how much delegation depth is left for a child of a parent at `parentDepth`.
+ *
+ * The configured maximum is a ceiling for the WHOLE recursion, not a fresh allowance
+ * at every level. Passing the configured maximum down unchanged at each level is how
+ * a "depth 3" budget silently permits 3^depth children, which bounds nothing.
+ *
+ * A caller may ask for LESS than what remains (`requested`) and never for more:
+ * `min(remaining, requested)`. A parent already at or past the cap yields **0** —
+ * "delegate no further" — never a negative that some downstream comparison could read
+ * as permission.
+ */
+export declare function remainingDepthFor(budgets: {
+    maxDelegationDepth: number;
+}, parentDepth: number, requested?: number): number;
 /** Read the verdict from a review-schema structured result (pure). */
 export declare function readVerdictFromStructured(result: SubagentResultLike): DelegationVerdict;
 /** Read the repair instruction from a review-schema structured result (pure). */
 export declare function readRepairFromStructured(result: SubagentResultLike): string;
+/** What a delegated child's `reply.md` said, as far as the plugin can tell. */
+export interface ReplyVerdict {
+    /** The verdict the reply STATES, or null when it states none. */
+    verdict: DelegationVerdict | null;
+    /** Finding titles, when the reply carried review-schema JSON. */
+    findings: string[];
+    /** Why no verdict was read, for the repair instruction. Null when one was. */
+    problem: string | null;
+}
+/**
+ * Read a verdict out of a child's `reply.md`, FAILING CLOSED.
+ *
+ * WHY THIS EXISTS RATHER THAN `readVerdictFromStructured`. The settlement's closing
+ * text is free-form — a child may report prose, a fenced JSON block, or a bare
+ * field line — and the structured reader's fallback for "no verdict" is
+ * `APPROVE`. That default is defensible where the caller re-evaluates the result,
+ * but it is the wrong default for a REVIEW ROUND: a child that answered with prose,
+ * or answered the wrong question, or wrote nothing parseable, must never be read as
+ * having approved the work. Verification that fails open is not verification.
+ *
+ * So this reader accepts exactly three things — review-schema JSON (fenced or
+ * bare), or an explicit `Verdict:` field — and reports `verdict: null` plus a
+ * `problem` for anything else. The caller turns that into a REVISE with a repair
+ * instruction that says what was wrong, so an unreadable reply costs a round rather
+ * than a false approval.
+ */
+export declare function parseReplyVerdict(replyText: string): ReplyVerdict;
+/**
+ * The verdict for one round, from the child's reply text, FAILING CLOSED: an
+ * unreadable reply becomes `REVISE`, never `APPROVE`.
+ */
+export declare function readVerdictFromReply(replyText: string): DelegationVerdict;
+/**
+ * The repair instruction for a round whose reply did not approve.
+ *
+ * Findings drive it when the reply carried them (and are the ONLY source of
+ * instruction text — a child cannot inject instructions, since only the titles
+ * travel). When there is nothing to quote, the instruction states the contract
+ * violation instead of asking vaguely for "improvement", because a repair request
+ * that does not say what was wrong cannot be acted on.
+ */
+export declare function readRepairFromReply(replyText: string): string;
 /**
  * Run a multi-round delegated task on ONE durable continuable child:
  * 1. `startContinuable` (initial prompt) — `start()` is never called.
@@ -183,10 +259,22 @@ export declare function delegateContinuable(input: {
     toolFilter?: unknown;
     maxDepth?: number;
     childId?: ContinuableChildId;
+    /**
+     * T36: RESUME an existing durable child instead of starting one. The turn-shaped
+     * caller passes the childId from a previous `parked` round, which is what makes
+     * the loop resumable across turns — `startContinuable` is not called, so a parked
+     * round does not create a second child.
+     */
+    resumeChild?: ContinuableChildId;
     maxRounds?: number;
     readVerdict?: (result: SubagentResultLike) => DelegationVerdict;
     readRepair?: (result: SubagentResultLike) => string | undefined;
     awaitRoundResult?: (childId: ContinuableChildId, messageId: ContinuableMessageId) => Promise<SubagentResultLike | null>;
+    /** T9: the child's provider/model overrides, forwarded onto the start request verbatim. */
+    agentOptions?: {
+        model?: string;
+        provider?: string;
+    };
 }): Promise<ContinuableDelegationLike>;
 /**
  * T4 kill switch: interrupt one live continuable child's current turn. Admission
@@ -243,11 +331,27 @@ export interface ActionRecordInput {
     findings?: string[];
     success: boolean;
     stopReason?: string;
+    /**
+     * ⚠ FU-9 — WHY IT FAILED, when it did. `success` is a boolean, so a record could say `Status: failed` and
+     * nothing else: a delegation that FAILED and a delegation that NEVER HAPPENED read identically, which is what
+     * let me conclude for three rounds that the host was not scheduling children. The caller ALREADY passed
+     * `stopReason`, and the live record said `n/a` — because there was no result to take a stop reason from.
+     */
+    failure?: string;
 }
 /**
- * Write a durable action record under subagents/ with the canonical sections
- * (matches recursive-subagent-action.py). A success:false attempt is written
- * with a failed status and is NOT accepted.
+ * Write a durable action record under subagents/ in the shape this repo's own
+ * linter accepts (ts-lint.ts lintSubagentActionRecordFile — every top-level .md
+ * under a run's subagents/ is linted as one):
+ *   - the literal title `# Subagent Action Record`;
+ *   - `Run ID` and `Timestamp` in ## Metadata (Run ID must equal the run dir name);
+ *   - `Current Artifact`, `Artifact Content Hash` (the artifact's LF-normalized
+ *     sha256, derived from the artifact itself — no extra caller input), `Diff
+ *     Basis`, `Review Bundle`, and the NAMED fields `Upstream Artifacts` /
+ *     `Code Refs` strictly inside ## Inputs Provided. The linter resolves each of
+ *     those through the heading body, so a field under another heading is not
+ *     found at all.
+ * A success:false attempt is written with a failed status and is NOT accepted.
  */
 export declare function writeActionRecord(input: ActionRecordInput): string;
 /**
@@ -258,3 +362,19 @@ export declare function evaluateDelegationResult(result: SubagentResultLike): {
     accepted: boolean;
     reason: string;
 };
+/**
+ * T8 — the child's CLAIMED references, read from wherever the delegation put them.
+ *
+ * The review output schema requires `references`, so a reviewer states which files back its
+ * verdict — and NOTHING read that field: `evaluateDelegationResult` looks only at
+ * `success`/`stopReason`, so a review citing files that do not exist was indistinguishable
+ * from one citing real evidence. This reads the claims so they can be checked.
+ *
+ * Both carriers are tried, because a delegation may return structured output or the raw
+ * JSON text: `structured` first (the native path), then `output` parsed as JSON. A result
+ * that carries neither yields `[]` — "no claims" — which the caller treats as NOTHING TO
+ * CHECK rather than as a pass, so an unparseable result can never be mistaken for a
+ * verified one. Malformed entries are dropped rather than thrown on: this reads a model's
+ * output, which is untrusted.
+ */
+export declare function referencesFromResult(result: SubagentResultLike): Reference[];