@try-works/dsh-recursive-mode 0.1.0

package/lib/client.js

@@ -0,0 +1,490 @@
+window.__ModuleLoader__.load({
+	id: "@try-works/dsh-recursive-mode",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		let react = require("react");
+		//#region src/client/derive.ts
+		const KANBAN_LANES = [
+			{
+				id: "0",
+				label: "Worktree & Requirements",
+				groups: ["00"]
+			},
+			{
+				id: "1/1.5",
+				label: "Analysis",
+				groups: ["01", "01.5"]
+			},
+			{
+				id: "2",
+				label: "TO-BE Plan",
+				groups: ["02"]
+			},
+			{
+				id: "3/3.5",
+				label: "Implementation + Code Review",
+				groups: ["03", "03.5"]
+			},
+			{
+				id: "4",
+				label: "Tests",
+				groups: ["04"]
+			},
+			{
+				id: "5",
+				label: "Manual QA",
+				groups: ["05"]
+			},
+			{
+				id: "6-8",
+				label: "Closeout",
+				groups: [
+					"06",
+					"07",
+					"08"
+				]
+			}
+		];
+		const GROUP_ORDER = [
+			"00",
+			"01",
+			"01.5",
+			"02",
+			"03",
+			"03.5",
+			"04",
+			"05",
+			"06",
+			"07",
+			"08"
+		];
+		/** Mandatory phase groups: a run is only 'locked'-valid when every one of these is present and LOCKED (01.5 is optional). */
+		const MANDATORY_GROUPS = [
+			"00",
+			"01",
+			"02",
+			"03",
+			"03.5",
+			"04",
+			"05",
+			"06",
+			"07",
+			"08"
+		];
+		/** Map a group id to its ordinal for stable ordering. */
+		const GROUP_INDEX$1 = new Map(GROUP_ORDER.map((g, i) => [g, i]));
+		/** Group id for a phase filename (e.g. '03.5-code-review.md' -> '03.5'); null for non-phase names. */
+		function phaseGroupOf$1(phase) {
+			const m = /^(\d{2}(?:\.\d)?)(?:-|$)/.exec(phase);
+			if (m === null) return null;
+			const g = m[1];
+			return GROUP_INDEX$1.has(g) ? g : null;
+		}
+		/** Kanban lane id for a phase filename. */
+		function laneOf(phase) {
+			const g = phaseGroupOf$1(phase);
+			if (g === null) return null;
+			for (const lane of KANBAN_LANES) if (lane.groups.includes(g)) return lane.id;
+			return null;
+		}
+		/**
+		* The run's current-phase lane: the highest-ordered phase group present in the
+		* card wins (a run is "at" its furthest phase). No phases -> lane 0.
+		*/
+		function columnForRun(card) {
+			let best = null;
+			let bestIndex = -1;
+			for (const key of Object.keys(card.phases)) {
+				const g = phaseGroupOf$1(key);
+				if (g === null) continue;
+				const idx = GROUP_INDEX$1.get(g) ?? -1;
+				if (idx > bestIndex) {
+					bestIndex = idx;
+					best = g;
+				}
+			}
+			if (best === null) return "0";
+			return laneOf(best + "-x") ?? "0";
+		}
+		/** Derive §11.4 presentation facts from one card (no fs, no session). */
+		function cardFacts(card) {
+			const groups = /* @__PURE__ */ new Set();
+			for (const key of Object.keys(card.phases)) {
+				const g = phaseGroupOf$1(key);
+				if (g !== null) groups.add(g);
+			}
+			const lockedGroups = /* @__PURE__ */ new Set();
+			for (const key of Object.keys(card.phases)) {
+				const g = phaseGroupOf$1(key);
+				if (g !== null && card.phases[key].status === "LOCKED") lockedGroups.add(g);
+			}
+			const lockedCount = lockedGroups.size;
+			const totalPhases = groups.size;
+			const subagents = Object.values(card.subagents).map((s) => ({
+				childId: s.childId,
+				role: s.role,
+				provider: s.provider,
+				status: s.status ?? "done"
+			}));
+			let currentPhase = null;
+			let currentIdx = -1;
+			for (const key of Object.keys(card.phases)) {
+				const g = phaseGroupOf$1(key);
+				if (g === null) continue;
+				const idx = GROUP_INDEX$1.get(g) ?? -1;
+				if (idx > currentIdx) {
+					currentIdx = idx;
+					currentPhase = key;
+				}
+			}
+			const tampered = Object.keys(card.tampers).length > 0;
+			const allMandatoryLocked = MANDATORY_GROUPS.every((g) => {
+				const row = Object.entries(card.phases).find(([key]) => phaseGroupOf$1(key) === g);
+				return row !== void 0 && row[1].status === "LOCKED";
+			});
+			const lockValidity = tampered ? "tampered" : allMandatoryLocked ? "locked" : "in-progress";
+			return {
+				runId: card.runId,
+				worktreeRoot: card.worktreeRoot,
+				repo: card.repo,
+				template: card.template,
+				state: card.state,
+				stateReason: card.stateReason,
+				lockedCount,
+				totalPhases,
+				progress: totalPhases === 0 ? 0 : lockedCount / totalPhases,
+				tampered,
+				gateBlocked: card.gateBlocked !== void 0,
+				gateKind: card.gateBlocked?.kind,
+				merged: card.mergedToRepoRoot !== void 0,
+				mergedToRepoRoot: card.mergedToRepoRoot,
+				lockValidity,
+				currentPhase,
+				subagents
+			};
+		}
+		/**
+		* Expand a card's phase chain into full inspector rows: the always-shown
+		* '03.5' slot (§11.10 mandatory deviation) plus 01.5 when present, and
+		* 06/07/08 as three distinct rows (never one merged lane).
+		*/
+		function expandPhaseRows(card) {
+			const byGroup = /* @__PURE__ */ new Map();
+			for (const [fileName, row] of Object.entries(card.phases)) {
+				const g = phaseGroupOf$1(fileName);
+				if (g !== null) byGroup.set(g, row);
+			}
+			const rows = [];
+			for (const g of GROUP_ORDER) {
+				if (g === "01.5" && !byGroup.has(g)) continue;
+				const row = byGroup.get(g);
+				if (row === void 0) {
+					if (g === "03.5") rows.push({
+						phase: g,
+						fileName: null,
+						status: "—",
+						present: false
+					});
+					continue;
+				}
+				rows.push({
+					phase: g,
+					fileName: row.phase,
+					status: row.status,
+					lockedAt: row.lockedAt,
+					lockHash: row.lockHash,
+					present: true
+				});
+			}
+			return rows;
+		}
+		//#endregion
+		//#region src/client/board.tsx
+		/**
+		* Board overlay (Phase D R5, §11.8): the kanban view over the 'recursive'
+		* projection. Pure read-only renderer — no filesystem, no run-file scraping.
+		* Cards are grouped by worktree root (the projection's outer key) and mapped
+		* to their current-phase lane via derive.columnForRun.
+		*/
+		/** Flatten the worktree-grouped projection into a stable run list. */
+		function listRuns(projection) {
+			if (projection === void 0) return [];
+			const runs = [];
+			for (const worktreeRoot of Object.keys(projection)) for (const runId of Object.keys(projection[worktreeRoot])) runs.push(projection[worktreeRoot][runId]);
+			return runs;
+		}
+		function Board({ useProjection }) {
+			const runs = listRuns(useProjection("recursive"));
+			if (runs.length === 0) return (0, react.createElement)("div", {
+				className: "rec-board",
+				"data-empty": true
+			}, (0, react.createElement)("p", { className: "rec-board-empty" }, "No recursive runs in this workspace yet."));
+			return (0, react.createElement)("div", { className: "rec-board" }, KANBAN_LANES.map((lane) => {
+				const laneRuns = runs.filter((r) => columnForRun(r) === lane.id);
+				return (0, react.createElement)("section", {
+					key: lane.id,
+					className: "rec-lane"
+				}, (0, react.createElement)("h2", { className: "rec-lane-title" }, lane.label), laneRuns.map((run) => {
+					const facts = cardFacts(run);
+					return (0, react.createElement)("article", {
+						key: run.worktreeRoot + "\0" + run.runId,
+						className: "rec-card"
+					}, (0, react.createElement)("div", { className: "rec-card-head" }, (0, react.createElement)("strong", {}, run.runId), facts.tampered && (0, react.createElement)("span", {
+						className: "rec-badge rec-badge-tamper",
+						title: "tampered"
+					}, "!")), (0, react.createElement)("div", { className: "rec-card-progress" }, (0, react.createElement)("div", {
+						className: "rec-card-progress-fill",
+						style: { width: Math.round(facts.progress * 100) + "%" }
+					})), (0, react.createElement)("div", { className: "rec-card-meta" }, (0, react.createElement)("span", {}, facts.currentPhase ?? "no phases"), (0, react.createElement)("span", { className: "rec-badge" }, facts.state)));
+				}));
+			}));
+		}
+		//#endregion
+		//#region src/client/strip.tsx
+		/**
+		* Status strip (Phase D R7, §11.6): a thin glance at the active run's phase,
+		* gate state, and tamper badge, docked at conversation.input.dock. Renders
+		* nothing when no run is current.
+		*/
+		function StatusStrip({ useProjection }) {
+			const runs = listRuns(useProjection("recursive"));
+			if (runs.length === 0) return null;
+			const active = runs[runs.length - 1];
+			const facts = cardFacts(active);
+			return (0, react.createElement)("div", { className: "rec-strip" }, (0, react.createElement)("span", { className: "rec-strip-run" }, active.runId), (0, react.createElement)("span", { className: "rec-badge" }, facts.currentPhase ?? "no phases"), facts.gateBlocked && (0, react.createElement)("span", { className: "rec-badge rec-badge-gate" }, "gate blocked"), facts.tampered && (0, react.createElement)("span", { className: "rec-badge rec-badge-tamper" }, "tampered"));
+		}
+		//#endregion
+		//#region src/client/settings.tsx
+		/**
+		* Recursive settings page (Phase D R8, §11.8): a settings.section list entry
+		* surfacing the host-owned enforcement config. The client is read-mostly; all
+		* writes ride the host config path (never run files).
+		*/
+		function RecursiveSettings({ close }) {
+			return (0, react.createElement)("div", { className: "rec-settings" }, (0, react.createElement)("h2", {}, "Recursive"), (0, react.createElement)("p", {}, "Enforcement policy, scratch format, provider defaults, and preset install path are configured on the host. The client is read-only (§11.9)."), (0, react.createElement)("button", { onClick: close }, "Close"));
+		}
+		//#endregion
+		//#region src/client/slots.ts
+		/**
+		* Slot registrations (Phase D R5/R6/R7/R8, §11.8): the sidebar launcher, the
+		* shell.overlay board, the conversation.input.dock status strip, and the
+		* settings.section page. The details-seat inspector is a swap driven by the
+		* board cards' click (R6); the strip + board + settings are additive seats.
+		*
+		* Self-contained structural seam: the real slot registry + runtime standard
+		* kit arrive from @deepseek-ai/dsh-client-ui-slots + @deepseek-ai/dsh-client-runtime
+		* at compose time; this module consumes the minimal ClientContext shape
+		* (contract.ts). The client is READ-ONLY (R9) — no filesystem, no mutation.
+		*/
+		function registerSlots(ctx) {
+			const disposers = [];
+			disposers.push(ctx.slots.inject("sidebar.footer.action", () => ctx.slots.register({
+				name: "sidebar.footer.action",
+				id: "recursive",
+				order: 50,
+				label: "Recursive runs"
+			}, () => (0, react.createElement)("button", {
+				className: "rec-launcher",
+				title: "Recursive runs"
+			}, "⧉"))));
+			disposers.push(ctx.slots.inject("shell.overlay", () => ctx.slots.register({
+				name: "shell.overlay",
+				id: "recursive-board",
+				order: 10
+			}, (props) => {
+				if (props?.useProjection === void 0) return null;
+				return (0, react.createElement)(Board, { useProjection: props.useProjection });
+			})));
+			disposers.push(ctx.slots.inject("conversation.input.dock", () => ctx.slots.register({
+				name: "conversation.input.dock",
+				id: "recursive-strip",
+				order: 20
+			}, (props) => {
+				if (props?.useProjection === void 0) return null;
+				return (0, react.createElement)(StatusStrip, { useProjection: props.useProjection });
+			})));
+			disposers.push(ctx.slots.inject("settings.section", () => ctx.slots.register({
+				name: "settings.section",
+				id: "recursive",
+				order: 90,
+				label: "Recursive"
+			}, (props) => (0, react.createElement)(RecursiveSettings, { close: props.close }))));
+			return () => {
+				for (const d of disposers) d();
+			};
+		}
+		//#endregion
+		//#region src/client/node.ts
+		const RECURSIVE_NODE_KIND = "recursive/run";
+		const GROUP_INDEX = new Map([
+			"00",
+			"01",
+			"01.5",
+			"02",
+			"03",
+			"03.5",
+			"04",
+			"05",
+			"06",
+			"07",
+			"08"
+		].map((g, i) => [g, i]));
+		function phaseGroupOf(phase) {
+			const m = /^(\d{2}(?:\.\d)?)(?:-|$)/.exec(phase);
+			return m ? m[1] : null;
+		}
+		function currentPhaseOf(phases) {
+			let best = null;
+			let bestIdx = -1;
+			for (const key of Object.keys(phases)) {
+				const g = phaseGroupOf(key);
+				if (g === null) continue;
+				const idx = GROUP_INDEX.get(g) ?? -1;
+				if (idx > bestIdx) {
+					bestIdx = idx;
+					best = key;
+				}
+			}
+			return best;
+		}
+		function nodeDataOf(s) {
+			const lockedCount = Object.values(s.phases).filter((p) => p.status === "LOCKED").length;
+			return {
+				runId: s.runId,
+				worktreeRoot: s.worktreeRoot,
+				state: s.state,
+				currentPhase: currentPhaseOf(s.phases),
+				lockedCount,
+				totalPhases: Object.keys(s.phases).length,
+				tampered: s.tampered,
+				gateBlocked: s.gateBlocked,
+				...s.mergedToRepoRoot === void 0 ? {} : { mergedToRepoRoot: s.mergedToRepoRoot }
+			};
+		}
+		/** Extract a stable (runId, worktreeRoot) business id + lifecycle role from one event. */
+		function matchRecursiveNode(event) {
+			if (typeof event.type !== "string" || !event.type.startsWith("recursive/")) return null;
+			const data = event.data ?? {};
+			const runId = typeof data.runId === "string" ? data.runId : "";
+			const worktreeRoot = typeof data.worktreeRoot === "string" ? data.worktreeRoot : "";
+			if (runId === "" || worktreeRoot === "") return null;
+			return {
+				id: worktreeRoot + "\0" + runId,
+				role: event.type === "recursive/run-created" ? "start" : "update"
+			};
+		}
+		/** Fold one recursive/* event into the node state. */
+		function foldRecursiveNode(s, event) {
+			const data = event.data ?? {};
+			const runId = typeof data.runId === "string" ? data.runId : "";
+			const worktreeRoot = typeof data.worktreeRoot === "string" ? data.worktreeRoot : "";
+			const base = s ?? {
+				runId,
+				worktreeRoot,
+				state: "active",
+				phases: {},
+				tampered: false,
+				gateBlocked: false
+			};
+			switch (event.type) {
+				case "recursive/run-created":
+					base.runId = runId;
+					base.worktreeRoot = worktreeRoot;
+					return base;
+				case "recursive/phase": {
+					const phase = String(data.phase ?? "");
+					if (phase !== "") base.phases[phase] = {
+						phase,
+						status: String(data.status ?? "")
+					};
+					return base;
+				}
+				case "recursive/phase-locked": {
+					const phase = String(data.phase ?? "");
+					if (phase !== "") base.phases[phase] = {
+						phase,
+						status: "LOCKED"
+					};
+					return base;
+				}
+				case "recursive/gate-blocked":
+					base.gateBlocked = true;
+					return base;
+				case "recursive/tamper":
+					base.tampered = true;
+					return base;
+				case "recursive/run-state":
+					base.state = typeof data.state === "string" ? data.state : base.state;
+					return base;
+				case "recursive/run-merged": {
+					const repoRoot = typeof data.repoRoot === "string" ? data.repoRoot : "";
+					if (repoRoot !== "") {
+						base.mergedToRepoRoot = repoRoot;
+						base.worktreeRoot = repoRoot;
+					}
+					return base;
+				}
+				default: return base;
+			}
+		}
+		/** The structural ConversationNodeDefinition (host links to the real contract). */
+		const recursiveNodeDefinition = {
+			kind: RECURSIVE_NODE_KIND,
+			target: "chat",
+			match: matchRecursiveNode,
+			start: (_ctx, match) => foldRecursiveNode(void 0, match.event),
+			update: (ctx, match) => foldRecursiveNode(ctx.state, match.event),
+			buildViewNode: (ctx) => {
+				const state = ctx.state;
+				if (state === void 0) return null;
+				return {
+					key: ctx.key,
+					kind: RECURSIVE_NODE_KIND,
+					id: ctx.id,
+					target: "chat",
+					data: nodeDataOf(state)
+				};
+			}
+		};
+		//#endregion
+		//#region src/client/inspector.tsx
+		/**
+		* Drill-down inspector (Phase D R6, §11.5): the details-seat swap rendering
+		* one run's phase chain (with the always-shown 3.5 row + full 6/7/8 rows),
+		* lock badges, and tamper/gate facts — all from the projection, never disk.
+		*/
+		function Inspector({ runId, worktreeRoot, useProjection, onBackToToolDetails }) {
+			const card = useProjection("recursive")?.[worktreeRoot]?.[runId];
+			if (card === void 0) return (0, react.createElement)("div", { className: "rec-inspector" }, (0, react.createElement)("p", {}, "Run not found: " + runId));
+			const facts = cardFacts(card);
+			const rows = expandPhaseRows(card);
+			return (0, react.createElement)("div", { className: "rec-inspector" }, (0, react.createElement)("div", { className: "rec-inspector-head" }, (0, react.createElement)("button", {
+				onClick: onBackToToolDetails,
+				className: "rec-back"
+			}, "← back to tool details"), (0, react.createElement)("h2", {}, runId), (0, react.createElement)("span", { className: "rec-badge" }, facts.state), facts.tampered && (0, react.createElement)("span", { className: "rec-badge rec-badge-tamper" }, "tampered")), (0, react.createElement)("section", { className: "rec-inspector-section" }, (0, react.createElement)("h3", {}, "Phases"), rows.map((row) => (0, react.createElement)("div", {
+				key: row.phase,
+				className: "rec-phase-row"
+			}, (0, react.createElement)("span", { className: "rec-phase-id" }, row.phase), (0, react.createElement)("span", { className: "rec-phase-name" }, row.fileName ?? "—"), (0, react.createElement)("span", { className: "rec-badge" }, row.status), row.lockHash !== void 0 && (0, react.createElement)("code", { className: "rec-lockhash" }, "#" + row.lockHash.slice(0, 8))))), facts.gateBlocked && (0, react.createElement)("section", { className: "rec-inspector-section" }, (0, react.createElement)("h3", {}, "Gate"), (0, react.createElement)("p", {}, "Blocked (" + (facts.gateKind ?? "") + ")")));
+		}
+		//#endregion
+		//#region src/client/index.ts
+		/** Browser-half plugin entry (R4). */
+		function apply(ctx) {
+			registerSlots(ctx);
+		}
+		//#endregion
+		exports.Board = Board;
+		exports.Inspector = Inspector;
+		exports.RECURSIVE_NODE_KIND = RECURSIVE_NODE_KIND;
+		exports.RecursiveSettings = RecursiveSettings;
+		exports.StatusStrip = StatusStrip;
+		exports.apply = apply;
+		exports.foldRecursiveNode = foldRecursiveNode;
+		exports.listRuns = listRuns;
+		exports.matchRecursiveNode = matchRecursiveNode;
+		exports.recursiveNodeDefinition = recursiveNodeDefinition;
+		return module.exports;
+	}
+});

package/lib/closeout.d.ts

@@ -0,0 +1,23 @@
+export interface CloseoutPhaseConfig {
+    file: string;
+    label: string;
+    scopeNote: string;
+    todoItems: string[];
+}
+export declare const PHASE_CONFIG: Record<string, CloseoutPhaseConfig>;
+export interface CloseoutResult {
+    phase: string;
+    file: string;
+    created: string[];
+    existing: string[];
+}
+export interface CloseoutOptions {
+    /** Enforce prerequisite-lock gating (default true). */
+    strict?: boolean;
+}
+/**
+ * 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).
+ */
+export declare function closeoutPhase(runDir: string, phase: string, opts?: CloseoutOptions): CloseoutResult;

package/lib/commands.d.ts

@@ -0,0 +1,51 @@
+import type { RecursiveRuntime } from './runtime.ts';
+export type RecursiveVerb = 'status' | 'spec' | 'worktree' | 'init' | 'lock' | 'qa' | 'closeout' | 'addendum' | 'review' | 'scratch' | 'bootstrap' | 'list' | 'help';
+export declare const PRESET_VERBS: RecursiveVerb[];
+export declare const GLOBAL_VERBS: RecursiveVerb[];
+export declare const ALL_VERBS: RecursiveVerb[];
+export interface ParsedRecursiveCommand {
+    verb: string;
+    arg: string;
+}
+export declare function parseRecursiveCommand(rawInput: string): ParsedRecursiveCommand;
+export type RecursiveCommandResult = {
+    kind: 'success';
+    text?: string;
+} | {
+    kind: 'error';
+    text: string;
+};
+/**
+ * Execute a /recursive command line against a workspace root (the session's
+ * control-plane root). Pure + workspace-scoped: runId outside root errors.
+ */
+export declare function executeRecursiveCommand(root: string, rawInput: string): RecursiveCommandResult;
+export interface RecursiveCommandDefinition {
+    name: string;
+    description: string;
+    input: {
+        hint: string;
+    };
+    handler: (inv: RecursiveCommandInvocation) => RecursiveCommandResult | Promise<RecursiveCommandResult>;
+}
+export interface RecursiveCommandInvocation {
+    rawInput: string;
+    agent?: {
+        session?: {
+            header?: {
+                cwd?: string;
+            };
+        };
+    } | null;
+}
+export interface RecursiveCommandRuntime {
+    register(def: RecursiveCommandDefinition): () => void;
+}
+/**
+ * Register the /recursive command on a context with commands (Stage A).
+ * The handler resolves the session workspace root via the agent's cwd and
+ * executes scoped to that root only (R1).
+ */
+export declare function registerRecursiveCommand(ctx: {
+    commands: RecursiveCommandRuntime;
+}, recursive: RecursiveRuntime): () => void;

package/lib/delegation.d.ts

@@ -0,0 +1,92 @@
+/** Minimal host-realm contract for ctx.subagents (the seam we call). */
+export interface SubagentsRuntimeLike {
+    start(name: string, request: SubagentStartRequestLike): Promise<SubagentResultLike>;
+    getProvider?(name: string): unknown;
+    list?(): unknown;
+}
+export interface SubagentStartRequestLike {
+    prompt: unknown[];
+    label?: string;
+    outputSchema?: Record<string, unknown>;
+    toolFilter?: unknown;
+    maxDepth?: number;
+    persona?: string;
+    parent?: unknown;
+    signal?: unknown;
+}
+export interface SubagentResultLike {
+    output?: string;
+    structured?: unknown;
+    stopReason?: string;
+    success?: boolean;
+}
+export interface DelegationError extends Error {
+    code?: string;
+}
+export declare function delegationError(message: string, code: string): DelegationError;
+/** Object-rooted output schema for a delegated review. */
+export declare function reviewOutputSchema(): Record<string, unknown>;
+/** Default toolFilter for a delegated reviewer (run-relevant, workspace-scoped). */
+export declare function defaultReviewToolFilter(): unknown;
+/**
+ * Call ctx.subagents.start() with the full request. Fail loud on capability
+ * mismatch, missing provider, or unsupported schema (never silent).
+ */
+export declare function delegate(input: {
+    subagents: SubagentsRuntimeLike;
+    provider: string;
+    request: SubagentStartRequestLike;
+}): Promise<SubagentResultLike>;
+export interface Reference {
+    path: string;
+    lineRange?: string;
+}
+export interface ReferenceCheck {
+    ok: boolean;
+    failures: string[];
+    checked: {
+        path: string;
+        ok: boolean;
+        reason?: string;
+    }[];
+}
+/**
+ * Validate every claimed reference: the path exists under root, and a line
+ * range (e.g. '10-20' or '10') is within the file's line count.
+ */
+export declare function validateReferences(root: string, references: Reference[]): ReferenceCheck;
+export interface ActionRecordInput {
+    root: string;
+    runId: string;
+    subagentId: string;
+    phase: string;
+    purpose: string;
+    executionMode: string;
+    artifactPath?: string;
+    upstreamArtifacts?: string[];
+    reviewBundle?: string;
+    diffBasis?: string;
+    codeRefs?: string[];
+    auditQuestions?: string[];
+    actionsTaken?: string[];
+    createdFiles?: string[];
+    modifiedFiles?: string[];
+    reviewedFiles?: string[];
+    findings?: string[];
+    success: boolean;
+    stopReason?: 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.
+ */
+export declare function writeActionRecord(input: ActionRecordInput): string;
+/**
+ * Accept/reject a delegation result: a success:false or non-completed
+ * stopReason is a failed attempt (diagnostics preserved, NOT accepted).
+ */
+export declare function evaluateDelegationResult(result: SubagentResultLike): {
+    accepted: boolean;
+    reason: string;
+};