@rulvar/core 1.53.0 → 1.55.0

package/dist/index.js

@@ -1,13 +1,13 @@
 import { createHash, getRandomValues, randomUUID } from "node:crypto";
-import { appendFileSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { dirname, join, resolve, sep } from "node:path";
+import { appendFileSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import path, { dirname, join, resolve, sep } from "node:path";
 import { Client } from "@modelcontextprotocol/sdk/client";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
 import { ToolListChangedNotificationSchema } from "@modelcontextprotocol/sdk/types.js";
 import { execFile } from "node:child_process";
-import { mkdtemp, rm } from "node:fs/promises";
+import { mkdtemp, readFile, readdir, realpath, rm, stat } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { promisify } from "node:util";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -3297,6 +3297,650 @@ var GitWorktreeProvider = class {
 	}
 };
 //#endregion
+//#region src/tools/research.ts
+/**
+* The standard repository research toolset (RV-210 remainder): paginated
+* list/search/read tools over a confined directory root with STABLE
+* keyset cursors, plus an evidence collector that verifies citations at
+* collection time. Design contract:
+*
+* - Responses are CANONICAL: a page is a pure function of (root
+*   filesystem state, logical window), never of how the window was
+*   addressed, so reading the same page through a cursor and through
+*   fresh arguments returns byte-identical results. That is what makes
+*   the RV-210 `maxNoNewEvidenceCalls` guard measure duplicate-page
+*   reads correctly, and the `maxRepeatedToolSignature` guard already
+*   denies byte-identical repeat calls: deduplication is composition,
+*   not a marker field.
+* - Cursors are keyset cursors (the last path / line, not an offset), so
+*   a page boundary never shifts when unrelated entries appear or
+*   disappear, and every cursor embeds the query identity: replaying a
+*   cursor against different arguments is a typed error result.
+* - Ordering is deterministic byte order (UTF-16 code unit sort), never
+*   locale collation.
+* - The root confines everything: relative paths only, `..` escapes and
+*   symlink escapes are typed error results, symlinked directories are
+*   never walked.
+* - User-level failures (bad path, binary file, oversized file, invalid
+*   cursor, an unverifiable citation) are RETURNED `{ error }` values,
+*   deterministic and visible to the model; only host misconfiguration
+*   throws (ConfigError at construction).
+* - Tool results are journaled at execution time, so replay never
+*   touches the filesystem; live pages read the live tree.
+*
+* Public docs: https://docs.rulvar.com/guide/tools
+*/
+const DEFAULT_PAGE_SIZE = 50;
+const DEFAULT_READ_PAGE_CHARS = 4e3;
+const DEFAULT_MAX_FILE_BYTES = 262144;
+const DEFAULT_MAX_SCANNED_FILES = 2e4;
+const ALWAYS_IGNORED = [".git", "node_modules"];
+const SEARCH_SNIPPET_CHARS = 200;
+const BINARY_SNIFF_BYTES = 8192;
+const LIST_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		dir: {
+			type: "string",
+			description: "Root-relative directory to list; default the root."
+		},
+		cursor: {
+			type: "string",
+			description: "Opaque cursor from a previous page."
+		}
+	}
+};
+const SEARCH_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	required: ["query"],
+	properties: {
+		query: {
+			type: "string",
+			minLength: 1,
+			description: "Literal substring to find."
+		},
+		dir: {
+			type: "string",
+			description: "Root-relative directory to search; default the root."
+		},
+		cursor: {
+			type: "string",
+			description: "Opaque cursor from a previous page."
+		}
+	}
+};
+const READ_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	required: ["path"],
+	properties: {
+		path: {
+			type: "string",
+			minLength: 1,
+			description: "Root-relative file path."
+		},
+		cursor: {
+			type: "string",
+			description: "Opaque cursor from a previous page."
+		}
+	}
+};
+const RECORD_EVIDENCE_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	required: ["claim", "file"],
+	properties: {
+		claim: {
+			type: "string",
+			minLength: 1,
+			description: "The claim this evidence supports."
+		},
+		file: {
+			type: "string",
+			minLength: 1,
+			description: "Root-relative file the claim cites."
+		},
+		lines: {
+			type: "string",
+			description: "Cited line or range, 1-based: '12' or '12-40'."
+		},
+		quote: {
+			type: "string",
+			minLength: 1,
+			description: "Verbatim quote; verified to appear in the file."
+		}
+	}
+};
+const LIST_EVIDENCE_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	properties: { cursor: {
+		type: "string",
+		description: "Opaque cursor from a previous page."
+	} }
+};
+function encodeCursor(payload) {
+	return Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
+}
+function decodeCursor(raw) {
+	try {
+		return JSON.parse(Buffer.from(raw, "base64url").toString("utf8"));
+	} catch {
+		return;
+	}
+}
+function isBinary(buffer) {
+	return buffer.subarray(0, BINARY_SNIFF_BYTES).includes(0);
+}
+/** Split into lines on LF; a trailing CR per line is presentation, not content. */
+function splitLines(text) {
+	return text.split("\n").map((line) => line.endsWith("\r") ? line.slice(0, -1) : line);
+}
+function repositoryResearchToolset(options) {
+	if (typeof options.root !== "string" || options.root.length === 0) throw new ConfigError("repositoryResearchToolset root must be a non-empty string");
+	let realRoot;
+	try {
+		realRoot = realpathSync(path.resolve(options.root));
+	} catch {
+		throw new ConfigError(`repositoryResearchToolset root '${options.root}' does not exist`);
+	}
+	if (!statSync(realRoot).isDirectory()) throw new ConfigError(`repositoryResearchToolset root '${options.root}' is not a directory`);
+	for (const [name, value] of [
+		["pageSize", options.pageSize],
+		["readPageChars", options.readPageChars],
+		["maxFileBytes", options.maxFileBytes],
+		["maxScannedFiles", options.maxScannedFiles]
+	]) if (value !== void 0 && (!Number.isSafeInteger(value) || value < 1)) throw new ConfigError(`repositoryResearchToolset ${name} must be a positive integer; got ${String(value)}`);
+	const pageSize = options.pageSize ?? DEFAULT_PAGE_SIZE;
+	const readPageChars = options.readPageChars ?? DEFAULT_READ_PAGE_CHARS;
+	const maxFileBytes = options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
+	const maxScannedFiles = options.maxScannedFiles ?? DEFAULT_MAX_SCANNED_FILES;
+	const includeHidden = options.includeHidden ?? false;
+	const ignored = /* @__PURE__ */ new Set([...ALWAYS_IGNORED, ...options.ignore ?? []]);
+	const evidence = [];
+	/**
+	* Resolves a root-relative POSIX path and confines it: absolute paths,
+	* `..` escapes, and symlink escapes are error strings, never throws.
+	* `mustExist` additionally resolves symlinks and re-checks containment
+	* of the REAL path (the FileTranscriptStore traversal lesson).
+	*/
+	const resolveWithin = async (rel, kind) => {
+		const normalizedInput = rel.replaceAll("\\", "/");
+		if (path.posix.isAbsolute(normalizedInput) || path.isAbsolute(rel)) return { error: `path must be relative to the research root; got '${rel}'` };
+		const normalized = path.posix.normalize(normalizedInput);
+		if (normalized === ".." || normalized.startsWith("../")) return { error: `path escapes the research root: '${rel}'` };
+		const cleaned = normalized === "." ? "" : normalized;
+		if (kind === "file" && cleaned === "") return { error: "path must name a file inside the research root" };
+		const abs = path.resolve(realRoot, cleaned);
+		let real;
+		try {
+			real = await realpath(abs);
+		} catch {
+			return { error: `no such ${kind} under the research root: '${cleaned === "" ? "." : cleaned}'` };
+		}
+		if (real !== realRoot && !real.startsWith(realRoot + path.sep)) return { error: `path escapes the research root: '${rel}'` };
+		try {
+			const info = await stat(real);
+			if (kind === "file" && !info.isFile()) return { error: `not a regular file: '${cleaned}'` };
+			if (kind === "dir" && !info.isDirectory()) return { error: `not a directory: '${cleaned === "" ? "." : cleaned}'` };
+		} catch {
+			return { error: `no such ${kind} under the research root: '${cleaned === "" ? "." : cleaned}'` };
+		}
+		return {
+			abs: real,
+			rel: cleaned
+		};
+	};
+	/**
+	* Deterministic recursive walk: sorted entries, ignored and hidden
+	* names skipped, symlinks never followed, regular files only. Returns
+	* root-relative POSIX paths in byte order, or an error when the walk
+	* exceeds maxScannedFiles.
+	*/
+	const walkFiles = async (absDir, relDir) => {
+		const files = [];
+		let visited = 0;
+		const recurse = async (dirAbs, dirRel) => {
+			let entries;
+			try {
+				entries = await readdir(dirAbs, { withFileTypes: true });
+			} catch {
+				return `directory disappeared during the walk: '${dirRel === "" ? "." : dirRel}'`;
+			}
+			const sorted = [...entries].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+			for (const entry of sorted) {
+				const name = entry.name;
+				if (ignored.has(name)) continue;
+				if (!includeHidden && name.startsWith(".")) continue;
+				const childRel = dirRel === "" ? name : `${dirRel}/${name}`;
+				if (entry.isDirectory()) {
+					const failure = await recurse(path.join(dirAbs, name), childRel);
+					if (failure !== void 0) return failure;
+					continue;
+				}
+				if (!entry.isFile()) continue;
+				visited += 1;
+				if (visited > maxScannedFiles) return `the walk exceeded maxScannedFiles (${String(maxScannedFiles)}); narrow dir or raise the limit`;
+				files.push(childRel);
+			}
+		};
+		const failure = await recurse(absDir, relDir);
+		if (failure !== void 0) return { error: failure };
+		return { files };
+	};
+	const loadTextFile = async (abs, rel) => {
+		let info;
+		try {
+			info = await stat(abs);
+		} catch {
+			return { error: `no such file under the research root: '${rel}'` };
+		}
+		if (info.size > maxFileBytes) return { error: `file '${rel}' is ${String(info.size)} bytes, over the maxFileBytes limit (${String(maxFileBytes)})` };
+		const buffer = await readFile(abs);
+		if (isBinary(buffer)) return { error: `file '${rel}' is binary` };
+		return { text: buffer.toString("utf8") };
+	};
+	return {
+		tools: [
+			tool({
+				name: "list_files",
+				description: "List files under a directory of the research root, recursively, in deterministic byte order, one page at a time. Returns { files, totalFiles, nextCursor? }; pass cursor to continue where the last page ended (the cursor is stable: unrelated changes never shift the boundary).",
+				parameters: LIST_SCHEMA,
+				risk: "read",
+				execute: async (input) => {
+					const params = input;
+					let dir = params.dir ?? "";
+					let after;
+					if (params.cursor !== void 0) {
+						const payload = decodeCursor(params.cursor);
+						if (payload === void 0 || payload.t !== "list" || typeof payload.dir !== "string" || typeof payload.after !== "string" || params.dir !== void 0 && params.dir !== payload.dir) return { error: "invalid cursor: pass the nextCursor of a previous list_files page" };
+						dir = payload.dir;
+						after = payload.after;
+					}
+					const resolved = await resolveWithin(dir, "dir");
+					if ("error" in resolved) return resolved;
+					const walked = await walkFiles(resolved.abs, resolved.rel);
+					if ("error" in walked) return walked;
+					const remaining = after === void 0 ? walked.files : walked.files.filter((file) => file > after);
+					const page = remaining.slice(0, pageSize);
+					const more = remaining.length > pageSize;
+					return {
+						files: page,
+						totalFiles: walked.files.length,
+						...more ? { nextCursor: encodeCursor({
+							t: "list",
+							dir: resolved.rel,
+							after: page[page.length - 1]
+						}) } : {}
+					};
+				}
+			}),
+			tool({
+				name: "search_files",
+				description: "Search files under the research root for a literal substring (case-sensitive, never a regex), one page of matches at a time in deterministic (path, line) order. Returns { matches: [{ file, line, text }], filesScanned, filesSkipped, nextCursor? }; binary and oversized files are skipped and counted.",
+				parameters: SEARCH_SCHEMA,
+				risk: "read",
+				execute: async (input) => {
+					const params = input;
+					let dir = params.dir ?? "";
+					let query = params.query;
+					let after;
+					if (params.cursor !== void 0) {
+						const payload = decodeCursor(params.cursor);
+						if (payload === void 0 || payload.t !== "search" || typeof payload.query !== "string" || typeof payload.dir !== "string" || typeof payload.file !== "string" || typeof payload.line !== "number" || payload.query !== params.query || params.dir !== void 0 && params.dir !== payload.dir) return { error: "invalid cursor: pass the nextCursor of a previous search_files page with the same query and dir" };
+						dir = payload.dir;
+						query = payload.query;
+						after = {
+							file: payload.file,
+							line: payload.line
+						};
+					}
+					if (query.length === 0) return { error: "query must be a non-empty literal substring" };
+					const resolved = await resolveWithin(dir, "dir");
+					if ("error" in resolved) return resolved;
+					const walked = await walkFiles(resolved.abs, resolved.rel);
+					if ("error" in walked) return walked;
+					const matches = [];
+					let filesScanned = 0;
+					let filesSkipped = 0;
+					for (const file of walked.files) {
+						const loaded = await loadTextFile(path.join(realRoot, file), file);
+						if ("error" in loaded) {
+							filesSkipped += 1;
+							continue;
+						}
+						filesScanned += 1;
+						const lines = splitLines(loaded.text);
+						for (let index = 0; index < lines.length; index += 1) if (lines[index].includes(query)) matches.push({
+							file,
+							line: index + 1,
+							text: lines[index].trim().slice(0, SEARCH_SNIPPET_CHARS)
+						});
+					}
+					const remaining = after === void 0 ? matches : matches.filter((match) => match.file > after.file || match.file === after.file && match.line > after.line);
+					const page = remaining.slice(0, pageSize);
+					const more = remaining.length > pageSize;
+					const last = page[page.length - 1];
+					return {
+						matches: page,
+						filesScanned,
+						filesSkipped,
+						...more && last !== void 0 ? { nextCursor: encodeCursor({
+							t: "search",
+							query,
+							dir: resolved.rel,
+							file: last.file,
+							line: last.line
+						}) } : {}
+					};
+				}
+			}),
+			tool({
+				name: "read_file",
+				description: "Read a file of the research root as numbered lines, one page at a time (whole lines up to the page character budget). Returns { path, totalLines, fromLine, toLine, content, nextCursor? }; the same page reads byte-identically however it is addressed, so duplicate reads are visible to the exploration guards.",
+				parameters: READ_SCHEMA,
+				risk: "read",
+				execute: async (input) => {
+					const params = input;
+					let rel = params.path;
+					let fromLine = 1;
+					if (params.cursor !== void 0) {
+						const payload = decodeCursor(params.cursor);
+						if (payload === void 0 || payload.t !== "read" || typeof payload.path !== "string" || typeof payload.after !== "number" || payload.path !== params.path) return { error: "invalid cursor: pass the nextCursor of a previous read_file page for the same path" };
+						rel = payload.path;
+						fromLine = payload.after + 1;
+					}
+					const resolved = await resolveWithin(rel, "file");
+					if ("error" in resolved) return resolved;
+					const loaded = await loadTextFile(resolved.abs, resolved.rel);
+					if ("error" in loaded) return loaded;
+					const lines = splitLines(loaded.text);
+					const totalLines = lines.length;
+					if (fromLine > totalLines) return { error: `fromLine ${String(fromLine)} is past the end of '${resolved.rel}' (${String(totalLines)} lines)` };
+					const rendered = [];
+					let used = 0;
+					let toLine = fromLine - 1;
+					for (let index = fromLine - 1; index < totalLines; index += 1) {
+						const row = `${String(index + 1)}: ${lines[index]}`;
+						if (rendered.length > 0 && used + 1 + row.length > readPageChars) break;
+						rendered.push(row);
+						used += (rendered.length > 1 ? 1 : 0) + row.length;
+						toLine = index + 1;
+					}
+					const more = toLine < totalLines;
+					return {
+						path: resolved.rel,
+						totalLines,
+						fromLine,
+						toLine,
+						content: rendered.join("\n"),
+						...more ? { nextCursor: encodeCursor({
+							t: "read",
+							path: resolved.rel,
+							after: toLine
+						}) } : {}
+					};
+				}
+			}),
+			tool({
+				name: "record_evidence",
+				description: "Record one evidence entry supporting a claim. The citation is VERIFIED at record time: the file must exist under the research root, lines must be a valid 1-based line or range inside it ('12' or '12-40'), and quote (when given) must appear verbatim in the file. Returns { recorded, duplicate, totalEvidence }.",
+				parameters: RECORD_EVIDENCE_SCHEMA,
+				risk: "read",
+				execute: async (input) => {
+					const params = input;
+					if (params.claim.trim().length === 0) return { error: "claim must be a non-empty string" };
+					const resolved = await resolveWithin(params.file, "file");
+					if ("error" in resolved) return resolved;
+					const loaded = await loadTextFile(resolved.abs, resolved.rel);
+					if ("error" in loaded) return loaded;
+					const lines = splitLines(loaded.text);
+					if (params.lines !== void 0) {
+						const match = /^(\d+)(?:-(\d+))?$/u.exec(params.lines);
+						if (match === null) return { error: "lines must be '12' or '12-40' (1-based)" };
+						const from = Number(match[1]);
+						const to = match[2] === void 0 ? from : Number(match[2]);
+						if (from < 1 || to < from || to > lines.length) return { error: `lines '${params.lines}' is outside '${resolved.rel}' (${String(lines.length)} lines)` };
+					}
+					if (params.quote !== void 0 && !loaded.text.includes(params.quote)) return { error: `quote not found verbatim in '${resolved.rel}'; cite what the file actually says` };
+					const entry = {
+						claim: params.claim,
+						file: resolved.rel,
+						...params.lines === void 0 ? {} : { lines: params.lines },
+						...params.quote === void 0 ? {} : { quote: params.quote }
+					};
+					const duplicate = evidence.some((existing) => existing.claim === entry.claim && existing.file === entry.file && existing.lines === entry.lines && existing.quote === entry.quote);
+					if (!duplicate) evidence.push(entry);
+					return {
+						recorded: !duplicate,
+						duplicate,
+						totalEvidence: evidence.length
+					};
+				}
+			}),
+			tool({
+				name: "list_evidence",
+				description: "List the evidence recorded so far, one page at a time in record order. Returns { evidence, totalEvidence, nextCursor? }.",
+				parameters: LIST_EVIDENCE_SCHEMA,
+				risk: "read",
+				execute: (input) => {
+					const params = input;
+					let from = 0;
+					if (params.cursor !== void 0) {
+						const payload = decodeCursor(params.cursor);
+						if (payload === void 0 || payload.t !== "evidence" || typeof payload.after !== "number") return Promise.resolve({ error: "invalid cursor: pass the nextCursor of a previous list_evidence page" });
+						from = payload.after;
+					}
+					const page = evidence.slice(from, from + pageSize);
+					const more = from + pageSize < evidence.length;
+					return Promise.resolve({
+						evidence: page,
+						totalEvidence: evidence.length,
+						...more ? { nextCursor: encodeCursor({
+							t: "evidence",
+							after: from + pageSize
+						}) } : {}
+					});
+				}
+			})
+		],
+		evidence: () => evidence.map((entry) => ({ ...entry }))
+	};
+}
+//#endregion
+//#region src/tools/progress.ts
+/** The stock progress tool name the engine scans terminals for. */
+const PROGRESS_REPORT_TOOL_NAME = "report_progress";
+const PROGRESS_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	required: ["facts"],
+	properties: {
+		facts: {
+			type: "array",
+			items: { type: "string" },
+			description: "New facts established since the last report; may be empty early on."
+		},
+		evidence: {
+			type: "array",
+			items: { type: "string" },
+			description: "Evidence references backing the facts (file:line or recorded evidence ids)."
+		},
+		questions: {
+			type: "array",
+			items: { type: "string" },
+			description: "Remaining unresolved questions."
+		},
+		note: {
+			type: "string",
+			description: "Optional short status note."
+		}
+	}
+};
+/**
+* The stock progress-report tool. Stateless and deterministic: the
+* result echoes the counts, so a verbatim repeated report is a
+* duplicate result digest to the exploration guards. The value is the
+* side contract: the engine captures the LAST successful call of this
+* tool as the structured terminal partial of a 'limit' invocation, so
+* an agent that reports after every batch never loses its collected
+* work to a budget expiry.
+*/
+function progressReportTool() {
+	return tool({
+		name: PROGRESS_REPORT_TOOL_NAME,
+		description: "Report research progress after every batch of tool calls: the new facts you established, the evidence references backing them, and the questions still open. If the invocation ends at a limit, your LAST report is returned to the caller as the structured partial result, so report before the budget runs out.",
+		parameters: PROGRESS_SCHEMA,
+		risk: "read",
+		execute: (input) => {
+			const report = input;
+			return Promise.resolve({
+				recorded: true,
+				facts: report.facts?.length ?? 0,
+				evidence: report.evidence?.length ?? 0,
+				questions: report.questions?.length ?? 0
+			});
+		}
+	});
+}
+function stringArray(value) {
+	return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+/**
+* The deterministic terminal scan: pairs `report_progress` tool calls
+* with their SUCCESSFUL results by id (a denied or failed call never
+* counts, mirroring the exploration guard's restore) and normalizes the
+* last one into a {@link ProgressReport}. Pure over the message window
+* it is given: the live loop hands its own history, the replay path
+* hands the terminal checkpoint's messages, and a compaction naturally
+* narrows the window to what the model itself still sees.
+*/
+function latestProgressReport(messages) {
+	const callsById = /* @__PURE__ */ new Map();
+	let latest;
+	for (const msg of messages) for (const part of msg.parts) if (part.type === "tool-call" && part.name === "report_progress") callsById.set(part.id, part.args);
+	else if (part.type === "tool-result" && part.name === "report_progress" && part.isError !== true && callsById.has(part.id)) {
+		const args = callsById.get(part.id);
+		if (typeof args === "object" && args !== null && !Array.isArray(args)) {
+			const record = args;
+			const report = {
+				facts: stringArray(record.facts),
+				evidence: stringArray(record.evidence),
+				questions: stringArray(record.questions)
+			};
+			if (typeof record.note === "string") report.note = record.note;
+			latest = report;
+		}
+	}
+	return latest;
+}
+//#endregion
+//#region src/engine/profile-templates.ts
+/**
+* The research template's stop conditions: a weighted unit budget over
+* the research tools (bookkeeping tools are free), per-tool caps, both
+* repetition guards, and soft budget notices. Exported so hosts and
+* tests can read the exact defaults they are overriding.
+*/
+const RESEARCH_PROFILE_LIMITS = {
+	maxTurns: 24,
+	maxToolCalls: 48,
+	toolBudgetNotices: true,
+	maxRepeatedToolSignature: 2,
+	maxNoNewEvidenceCalls: 6,
+	maxCallsPerTool: {
+		list_files: 12,
+		search_files: 20,
+		read_file: 30
+	},
+	toolUnits: {
+		max: 64,
+		costs: {
+			list_files: 1,
+			search_files: 2,
+			read_file: 2,
+			record_evidence: 0,
+			list_evidence: 0,
+			report_progress: 0
+		}
+	}
+};
+/** The implementation template's stop conditions. */
+const IMPLEMENTATION_PROFILE_LIMITS = {
+	maxTurns: 32,
+	maxToolCalls: 64,
+	toolBudgetNotices: true,
+	maxRepeatedToolSignature: 3,
+	noProgressTurns: 3
+};
+/** The review template's stop conditions. */
+const REVIEW_PROFILE_LIMITS = {
+	maxTurns: 16,
+	maxToolCalls: 32,
+	toolBudgetNotices: true,
+	maxRepeatedToolSignature: 2,
+	maxNoNewEvidenceCalls: 8
+};
+function mergeLimits(template, overrides) {
+	return {
+		...template,
+		...overrides ?? {}
+	};
+}
+/**
+* The batteries-included research child: the confined
+* {@link repositoryResearchToolset} over `root`, the stock
+* report_progress tool, and {@link RESEARCH_PROFILE_LIMITS} as the stop
+* conditions. A child spawned from this profile that runs out of budget
+* settles 'limit' WITH its last progress report as the structured
+* partial, and the recorded evidence stays readable host-side through
+* `evidence()`.
+*/
+function researchAgentProfile(options) {
+	const { description, limits, extraTools, ...toolsetOptions } = options;
+	const kit = repositoryResearchToolset(toolsetOptions);
+	return {
+		profile: {
+			description: description ?? "Repository research over a confined root: paginated list_files/search_files/read_file with stable cursors, record_evidence verifying every citation, and report_progress after every batch. Stop conditions built in: weighted tool units, per-tool caps, repetition and no-new-evidence guards, budget notices. On limit the last progress report is the structured partial.",
+			tools: [
+				...kit.tools,
+				progressReportTool(),
+				...extraTools ?? []
+			],
+			limits: mergeLimits(RESEARCH_PROFILE_LIMITS, limits)
+		},
+		evidence: () => kit.evidence()
+	};
+}
+/**
+* The implementation child template: the caller's task tools plus the
+* progress contract, with {@link IMPLEMENTATION_PROFILE_LIMITS} as the
+* stop conditions (a no-progress detector instead of the research
+* no-new-evidence guard: implementation legitimately re-reads state).
+*/
+function implementationAgentProfile(options = {}) {
+	return {
+		description: options.description ?? "Implementation work with built-in stop conditions: tool budget with notices, repeated-call guard, no-progress detector. Report progress with report_progress after every batch; on limit the last report is the structured partial.",
+		tools: [progressReportTool(), ...options.tools ?? []],
+		limits: mergeLimits(IMPLEMENTATION_PROFILE_LIMITS, options.limits)
+	};
+}
+/**
+* The review child template: the caller's task tools plus the progress
+* contract, with {@link REVIEW_PROFILE_LIMITS} as the stop conditions
+* (a tighter turn budget and the no-new-evidence guard: a reviewer
+* circling over the same pages should stop, not spin).
+*/
+function reviewAgentProfile(options = {}) {
+	return {
+		description: options.description ?? "Focused review with built-in stop conditions: tight turn and tool budgets with notices, repetition and no-new-evidence guards. Report findings with report_progress after every batch; on limit the last report is the structured partial.",
+		tools: [progressReportTool(), ...options.tools ?? []],
+		limits: mergeLimits(REVIEW_PROFILE_LIMITS, options.limits)
+	};
+}
+//#endregion
 //#region src/journal/identity.ts
 /**
 * Content-addressed entry identity (M1-T04): IdentityInput records per
@@ -8008,6 +8652,10 @@ function mergeUsageLimits(call, profile, engine) {
 	if (maxRepeatedToolSignature !== void 0) merged.maxRepeatedToolSignature = maxRepeatedToolSignature;
 	const maxNoNewEvidenceCalls = pick("maxNoNewEvidenceCalls");
 	if (maxNoNewEvidenceCalls !== void 0) merged.maxNoNewEvidenceCalls = maxNoNewEvidenceCalls;
+	const maxCallsPerTool = pick("maxCallsPerTool");
+	if (maxCallsPerTool !== void 0) merged.maxCallsPerTool = maxCallsPerTool;
+	const toolUnits = pick("toolUnits");
+	if (toolUnits !== void 0) merged.toolUnits = toolUnits;
 	return merged;
 }
 /**
@@ -8032,6 +8680,21 @@ function validateUsageLimits(limits, site) {
 	if (limits.toolBudgetNotices !== void 0 && typeof limits.toolBudgetNotices !== "boolean") throw new ConfigError(`${site}.toolBudgetNotices must be a boolean; got ${typeof limits.toolBudgetNotices}`);
 	if (limits.maxRepeatedToolSignature !== void 0) requirePositiveInteger(limits.maxRepeatedToolSignature, `${site}.maxRepeatedToolSignature`);
 	if (limits.maxNoNewEvidenceCalls !== void 0) requirePositiveInteger(limits.maxNoNewEvidenceCalls, `${site}.maxNoNewEvidenceCalls`);
+	if (limits.maxCallsPerTool !== void 0) {
+		const caps = limits.maxCallsPerTool;
+		if (typeof caps !== "object" || caps === null || Array.isArray(caps)) throw new ConfigError(`${site}.maxCallsPerTool must be a record of per-tool caps`);
+		for (const [name, cap] of Object.entries(caps)) requireNonNegativeInteger(cap, `${site}.maxCallsPerTool['${name}']`);
+	}
+	if (limits.toolUnits !== void 0) {
+		const units = limits.toolUnits;
+		if (typeof units !== "object" || units === null || Array.isArray(units)) throw new ConfigError(`${site}.toolUnits must be { max, costs? }`);
+		const { max, costs } = units;
+		requirePositiveInteger(max, `${site}.toolUnits.max`);
+		if (costs !== void 0) {
+			if (typeof costs !== "object" || costs === null || Array.isArray(costs)) throw new ConfigError(`${site}.toolUnits.costs must be a record of per-tool costs`);
+			for (const [name, cost] of Object.entries(costs)) requireNonNegativeInteger(cost, `${site}.toolUnits.costs['${name}']`);
+		}
+	}
 }
 //#endregion
 //#region src/runtime/model-retry.ts
@@ -8566,7 +9229,7 @@ function formatRePrompt(issues, attempt, maxAttempts) {
 const GUARD_DOCS_URL = "https://docs.rulvar.com/guide/agents#exploration-guards";
 /** True when any exploration guard field asks for tracking. */
 function explorationTrackingEnabled(limits) {
-	return limits.maxRepeatedToolSignature !== void 0 || limits.maxNoNewEvidenceCalls !== void 0 || limits.toolBudgetNotices === true;
+	return limits.maxRepeatedToolSignature !== void 0 || limits.maxNoNewEvidenceCalls !== void 0 || limits.toolBudgetNotices === true || limits.maxCallsPerTool !== void 0 || limits.toolUnits !== void 0;
 }
 function digestOf$1(value) {
 	try {
@@ -8585,6 +9248,8 @@ var ExplorationGuard = class {
 	repeated = 0;
 	duplicateResults = 0;
 	denied = 0;
+	deniedToolCap = 0;
+	unitsUsed = 0;
 	unserializableSeq = 0;
 	constructor(config) {
 		this.config = config;
@@ -8622,10 +9287,25 @@ var ExplorationGuard = class {
 		}
 	}
 	/**
-	* The pre-dispatch verdict: denies the call that would exceed
-	* maxRepeatedToolSignature executions of the same signature.
+	* The pre-dispatch verdict: denies the call that would exceed its
+	* tool's maxCallsPerTool cap, then the call that would exceed
+	* maxRepeatedToolSignature executions of the same signature. A denial
+	* never consumes maxToolCalls or tool units.
 	*/
 	beforeExecute(name, args) {
+		const cap = this.config.maxCallsPerTool?.[name];
+		if (cap !== void 0) {
+			const executions = this.byTool.get(name) ?? 0;
+			if (executions >= cap) {
+				this.deniedToolCap += 1;
+				return {
+					deny: true,
+					guard: "per-tool-cap",
+					executions,
+					reason: `exploration guard: '${name}' already executed ${String(executions)} time(s) this invocation (maxCallsPerTool ${String(cap)}). Use what you have or a different tool (${GUARD_DOCS_URL}).`
+				};
+			}
+		}
 		const max = this.config.maxRepeatedToolSignature;
 		if (max === void 0) return { deny: false };
 		const executions = this.signatureExecutions.get(this.signatureOf(name, args)) ?? 0;
@@ -8633,6 +9313,7 @@ var ExplorationGuard = class {
 		this.denied += 1;
 		return {
 			deny: true,
+			guard: "repeated-signature",
 			executions,
 			reason: `exploration guard: this exact '${name}' call already executed ${String(executions)} time(s) this invocation (maxRepeatedToolSignature ${String(max)}). Reuse the earlier result or change the arguments (${GUARD_DOCS_URL}).`
 		};
@@ -8650,6 +9331,7 @@ var ExplorationGuard = class {
 	recordExecution(name, args, result, successful) {
 		this.executed += 1;
 		this.byTool.set(name, (this.byTool.get(name) ?? 0) + 1);
+		if (this.config.toolUnits !== void 0) this.unitsUsed += this.config.toolUnits.costs?.[name] ?? 1;
 		const signature = this.signatureOf(name, args);
 		const prior = this.signatureExecutions.get(signature) ?? 0;
 		if (prior > 0) this.repeated += 1;
@@ -8666,6 +9348,14 @@ var ExplorationGuard = class {
 		const max = this.config.maxNoNewEvidenceCalls;
 		return max !== void 0 && this.noNewEvidenceStreak >= max;
 	}
+	/**
+	* True once the spent tool units reached the weighted budget: the
+	* loop's pre-dispatch check, mirroring maxToolCalls (terminal 'limit',
+	* paid partial work). Never true without toolUnits configured.
+	*/
+	unitsExhausted() {
+		return this.config.toolUnits !== void 0 && this.unitsUsed >= this.config.toolUnits.max;
+	}
 	/** The abort message for a tripped no-new-evidence guard. */
 	describeTrip() {
 		return `exploration guard: ${String(this.noNewEvidenceStreak)} consecutive tool calls returned no new evidence (maxNoNewEvidenceCalls ${String(this.config.maxNoNewEvidenceCalls ?? this.noNewEvidenceStreak)}; every result was already seen this invocation). The executed work is kept; narrow the scope, vary the queries, or raise the limit (${GUARD_DOCS_URL}).`;
@@ -8680,7 +9370,9 @@ var ExplorationGuard = class {
 			repeatedCalls: this.repeated,
 			duplicateResultCalls: this.duplicateResults,
 			deniedRepeats: this.denied,
-			byTool
+			byTool,
+			...this.config.maxCallsPerTool === void 0 ? {} : { deniedToolCap: this.deniedToolCap },
+			...this.config.toolUnits === void 0 ? {} : { toolUnitsUsed: this.unitsUsed }
 		};
 	}
 };
@@ -9290,6 +9982,10 @@ async function runAgent(options) {
 				parts,
 				limitHit: true
 			};
+			if (guard !== void 0 && guard.unitsExhausted()) return {
+				parts,
+				limitHit: true
+			};
 			const def = runtime.defs.find((candidate) => candidate.name === call.name);
 			events?.emit({
 				type: "tool:start",
@@ -9445,11 +10141,11 @@ async function runAgent(options) {
 						toolName: gatedCall.name,
 						outcome: "denied",
 						durationMs: now() - gateStartedAt,
-						guard: "repeated-signature"
+						guard: guardVerdict.guard
 					});
 					parts.push(errorPart(call, {
 						error: guardVerdict.reason,
-						guard: "repeated-signature"
+						guard: guardVerdict.guard
 					}));
 					continue;
 				}
@@ -10298,6 +10994,8 @@ async function runAgent(options) {
 		}
 		endPhase(extractPhase, phaseOutcome(), extractServed);
 	}
+	const limitPartial = status === "limit" ? latestProgressReport(messages) : void 0;
+	if (limitPartial !== void 0) await saveBoundary();
 	let transcriptRef = "";
 	if (options.transcript !== void 0) {
 		transcriptRef = options.transcript.mintRef();
@@ -10320,6 +11018,7 @@ async function runAgent(options) {
 	if (abortClass !== void 0) result.abortClass = abortClass;
 	if (errorMessage !== void 0) result.errorMessage = errorMessage;
 	if (guard !== void 0) result.exploration = guard.summary(toolCallsUsed);
+	if (limitPartial !== void 0) result.partial = limitPartial;
 	if (usageApprox) result.usageApprox = true;
 	if (transportRetries > 0) result.transportRetries = transportRetries;
 	return result;
@@ -11291,7 +11990,13 @@ const WAKE_SUMMARY_RENDER_BUDGET_CHARS = 400;
 * spawn ordinal; the LLM distillation upgrade is M7 territory).
 */
 function summarizeOutput(result) {
-	return truncateToBudget(result.status === "ok" ? typeof result.output === "string" ? result.output : JSON.stringify(result.output ?? null) : result.errorMessage ?? `terminal status ${result.status}`, 400);
+	let raw;
+	if (result.status === "ok") raw = typeof result.output === "string" ? result.output : JSON.stringify(result.output ?? null);
+	else {
+		raw = result.errorMessage ?? `terminal status ${result.status}`;
+		if (result.partial !== void 0) raw = `${raw}; partial: ${JSON.stringify(result.partial)}`;
+	}
+	return truncateToBudget(raw, 400);
 }
 /** Folds one settled child into its digest (spawn-ordinal ordering is the caller's). */
 function digestOf(record, result) {
@@ -12164,6 +12869,10 @@ function createCtx(internals, rootWorkflow) {
 				const checkpoint = blob === null ? void 0 : decodeCheckpoint(blob);
 				if (checkpoint !== void 0) {
 					result.turns = checkpoint.turns;
+					if (result.status === "limit") {
+						const partialReport = latestProgressReport(checkpoint.messages);
+						if (partialReport !== void 0) result.partial = partialReport;
+					}
 					replayedToolResults = checkpoint.messages.filter((msg) => msg.role === "tool").flatMap((msg) => msg.parts).filter((part) => part.type === "tool-result").map((part) => ({
 						name: part.name,
 						isError: part.isError === true
@@ -13265,6 +13974,52 @@ async function executeWorkflow(internals, wf, args) {
 	}
 }
 //#endregion
+//#region src/orchestrator/claims.ts
+/** The conservative matching key: trim plus inner-whitespace collapse. */
+function claimKey(line) {
+	return line.trim().replace(/\s+/gu, " ");
+}
+/**
+* Removes later occurrences of repeated claim lines across the rows and
+* indexes each repeated claim with its reporters. Deterministic: output
+* depends only on the input order and bytes.
+*/
+function dedupeRepeatedClaims(rows) {
+	const seen = /* @__PURE__ */ new Map();
+	const order = [];
+	return {
+		rows: rows.map((row) => {
+			const kept = [];
+			for (const line of row.text.split("\n")) {
+				const key = claimKey(line);
+				if (key === "") {
+					kept.push(line);
+					continue;
+				}
+				const prior = seen.get(key);
+				if (prior === void 0) {
+					const entry = {
+						claim: line,
+						nodeIds: [row.nodeId],
+						count: 1
+					};
+					seen.set(key, entry);
+					order.push(entry);
+					kept.push(line);
+					continue;
+				}
+				prior.count += 1;
+				if (!prior.nodeIds.includes(row.nodeId)) prior.nodeIds.push(row.nodeId);
+			}
+			return {
+				nodeId: row.nodeId,
+				text: kept.join("\n")
+			};
+		}),
+		repeated: order.filter((entry) => entry.count > 1)
+	};
+}
+//#endregion
 //#region src/orchestrator/orchestrate.ts
 /**
 * The mode (c) dynamic orchestrator (M6-T07/T08).
@@ -13291,6 +14046,12 @@ const DEFAULT_FINISH_MAX_REPAIRS = 1;
 * call plus headroom for one validator repair exchange.
 */
 const DEFAULT_SYNTHESIS_MAX_TURNS = 4;
+/**
+* Default maxTurns of ONE incremental synthesis note (RV-211 remainder):
+* a note summarizes a single settled child into a bounded finish call,
+* so it needs less headroom than the full synthesis invocation.
+*/
+const DEFAULT_SYNTHESIS_NOTE_MAX_TURNS = 2;
 const ORCHESTRATE_WORKFLOW_NAME = "rulvar-orchestrate";
 /**
 * One page of a string, for the child result evidence tools: maxChars is
@@ -13312,7 +14073,14 @@ function pageOf(content, rawOffset, rawMaxChars) {
 }
 /** The serialized full result of a settled child: the raw string, or JSON. */
 function serializeChildOutput(result) {
-	if (result.status !== "ok") return result.errorMessage ?? `terminal status ${result.status}`;
+	if (result.status !== "ok") {
+		const base = result.errorMessage ?? `terminal status ${result.status}`;
+		if (result.partial !== void 0) return JSON.stringify({
+			error: base,
+			partial: result.partial
+		});
+		return base;
+	}
 	return typeof result.output === "string" ? result.output : JSON.stringify(result.output ?? null);
 }
 /**
@@ -13334,6 +14102,8 @@ function validateOrchestrateOptions(opts) {
 		const minSuccessful = typeof policy === "object" && policy !== null && !Array.isArray(policy) ? policy.minSuccessful : void 0;
 		if (policy !== "all-ok" && minSuccessful === void 0) throw new ConfigError(`orchestrate acceptance.childPolicy must be 'all-ok' or { minSuccessful: N }; got ${JSON.stringify(policy)}`);
 		if (policy !== "all-ok") requirePositiveInteger(minSuccessful, "orchestrate acceptance.childPolicy.minSuccessful");
+		const acceptPartial = opts.acceptance.acceptPartialChildren;
+		if (acceptPartial !== void 0 && typeof acceptPartial !== "boolean") throw new ConfigError(`orchestrate acceptance.acceptPartialChildren must be a boolean; got ${typeof acceptPartial}`);
 	}
 	if (opts.finishValidation !== void 0) {
 		const fv = opts.finishValidation;
@@ -13350,6 +14120,10 @@ function validateOrchestrateOptions(opts) {
 	}
 	if (opts.synthesis !== void 0) {
 		const synthesis = opts.synthesis;
+		if (synthesis.mode !== void 0 && synthesis.mode !== "single" && synthesis.mode !== "incremental") throw new ConfigError("orchestrate synthesis.mode must be 'single' or 'incremental'; got " + JSON.stringify(synthesis.mode));
+		if (synthesis.mode === "incremental" && opts.finishValidation !== void 0) throw new ConfigError("orchestrate synthesis.mode 'incremental' reconciles deterministically and has no model-composed final finish for finishValidation to bind; configure validators with mode 'single', or drop them");
+		if (synthesis.dedupeClaims !== void 0 && typeof synthesis.dedupeClaims !== "boolean") throw new ConfigError("orchestrate synthesis.dedupeClaims must be a boolean; got " + typeof synthesis.dedupeClaims);
+		if (synthesis.noteLimits !== void 0) validateUsageLimits(synthesis.noteLimits, "orchestrate synthesis.noteLimits");
 		if (synthesis.effort !== void 0 && ![
 			"low",
 			"medium",
@@ -13394,6 +14168,16 @@ function finishValidationPromptLines(spec) {
 	return [`The host validates every finish({ result }) with deterministic validators: ${names}.`, "A rejected finish returns the failure reasons as the tool error result; repair the result and call finish again. " + (repairs === 0 ? "No repair attempt is granted: the first rejected finish fails the run." : repairs === 1 ? "At most one repair attempt is granted before the run fails." : `At most ${String(repairs)} repair attempts are granted before the run fails.`)];
 }
 /**
+* The partial-salvage contract rides the PROMPT exactly like finish
+* validation (RV-210 close-out): present only when
+* acceptance.acceptPartialChildren is set, so every other configuration
+* keeps byte-identical coordination prompts.
+*/
+function acceptancePromptLines(acceptance) {
+	if (acceptance?.acceptPartialChildren !== true) return [];
+	return ["Partial salvage is on: a child that ends at its limit AFTER recording progress with report_progress counts as a partial success for acceptance; its digest carries the partial and get_child_result (when enabled) pages the full report. When the gap matters, respawn a NARROWED child carrying the partial instead of repeating the task."];
+}
+/**
 * Resolves per-spawn dispatch options against the engine registries
 * (registered SchemaSpec and tool profile names; M7-T05). An
 * unknown ref is a typed ConfigError, surfaced as a tool error to the
@@ -13551,6 +14335,22 @@ function makeOrchestratorWorkflow(goal, opts) {
 		const recoveryDone = new Promise((resolve) => {
 			releaseRecovery = resolve;
 		});
+		/**
+		* Incremental synthesis notes (RV-211 remainder): one bounded
+		* synthesize-role invocation per settled child, keyed by nodeId so a
+		* note can never double-dispatch. The settle hook fires the note the
+		* moment its child settles (overlapping the still-running fan-out);
+		* the deterministic reconciliation is the completeness backstop and
+		* dispatches any note the hook missed. The dispatcher installs right
+		* before the coordination loop because it closes over runtime pieces
+		* built below; these bindings are declared HERE, before
+		* dispatchChild, so a recovered child's settle hook (which can fire
+		* during the recovery scan) never touches a binding in its temporal
+		* dead zone.
+		*/
+		const synthesisNotes = /* @__PURE__ */ new Map();
+		let synthesisNoteDispatcher;
+		let synthesisSettleFrozen = false;
 		let activityChain = Promise.resolve();
 		const childScopeOf = () => {
 			if (orchSeq === void 0) throw new ConfigError("orchestrator dispatch seq unknown before the loop started");
@@ -13636,6 +14436,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 			};
 			settledResult.then(async (settled) => {
 				record.settled = settled;
+				if (!synthesisSettleFrozen) synthesisNoteDispatcher?.(record);
 				await runExtensionActivity();
 				for (const listener of [...settleListeners]) listener();
 			});
@@ -14425,33 +15226,198 @@ function makeOrchestratorWorkflow(goal, opts) {
 			};
 		};
 		/**
+		* One incremental synthesis note (RV-211 remainder): a FRESH agent
+		* entry with role 'synthesize' on the finish-only toolset whose
+		* prompt derives deterministically from the goal and the ONE settled
+		* child's digest, so a resume replays it by identity with zero paid
+		* calls. The invocation itself never throws out of here: an infra
+		* failure settles as a synthesized error result and the
+		* reconciliation falls back to the raw digest summary.
+		*/
+		const runSynthesisNote = async (record) => {
+			const spec = opts?.synthesis;
+			const finishOnly = buildOrchestratorTools(orchestratorRuntime, fullCardText).filter((tool) => tool.name === FINISH_TOOL_NAME);
+			const digest = digestOf(record, record.settled);
+			const prompt = [
+				"You are an incremental synthesis note of an orchestrated run. Digest the SINGLE settled child below into a self-contained note for the final deterministic reconciliation by calling finish({ result }) EXACTLY once, where result is a STRING. Preserve concrete evidence and citations; do not invent findings. No other tool exists.",
+				...spec.instructions === void 0 ? [] : [spec.instructions],
+				`GOAL: ${goal}`,
+				`CHILD: ${JSON.stringify(digest)}`
+			].join("\n");
+			const noteState = { ...callingState };
+			if (orchestratorAccount !== void 0) noteState.budgetScope = orchestratorAccount;
+			const noteOpts = {
+				role: "synthesize",
+				result: "full",
+				tools: finishOnly,
+				limits: spec.noteLimits ?? { maxTurns: 2 },
+				...spec.model === void 0 ? {} : { model: spec.model },
+				...spec.effort === void 0 ? {} : { effort: spec.effort },
+				...spec.estCost === void 0 ? {} : { estCost: spec.estCost },
+				[kTerminalTool]: { name: FINISH_TOOL_NAME }
+			};
+			return runtime.runInScope(noteState, () => ctx.agent(prompt, noteOpts));
+		};
+		/**
+		* Note dispatch is idempotent per child: the settle hook and the
+		* reconciliation both come through here, and the map guarantees one
+		* dispatch per nodeId (a concurrent identical dispatch would mint a
+		* second occurrence and PAY twice: the v1.32.0 lesson).
+		*/
+		const ensureSynthesisNote = (record) => {
+			const existing = synthesisNotes.get(record.nodeId);
+			if (existing !== void 0) return existing;
+			const note = runSynthesisNote(record).catch((thrown) => ({
+				status: "error",
+				output: null,
+				usage: {
+					inputTokens: 0,
+					outputTokens: 0,
+					cacheReadTokens: 0,
+					cacheWriteTokens: 0
+				},
+				costUsd: 0,
+				turns: 0,
+				servedBy: "unknown:unknown",
+				transcriptRef: "",
+				errorMessage: thrown instanceof Error ? thrown.message : String(thrown)
+			}));
+			synthesisNotes.set(record.nodeId, note);
+			return note;
+		};
+		if (opts?.synthesis?.mode === "incremental" && capDecisionRef === void 0) synthesisNoteDispatcher = ensureSynthesisNote;
+		/**
+		* The deterministic reconciliation of 'incremental' synthesis: the
+		* final result is a PURE fold of the journaled draft and the note
+		* results in spawn order, never another model call. A note that died
+		* falls back to the child's raw digest summary under a journaled
+		* per-child decision and a warn log. With dedupeClaims, repeated
+		* claim lines keep their first occurrence and the envelope carries
+		* the repeatedClaims index.
+		*/
+		const reconcileIncremental = async (draft, spec) => {
+			synthesisSettleFrozen = true;
+			const settledRecords = [...records.values()].filter((record) => record.settled !== void 0).sort((a, b) => a.spawnOrdinal - b.spawnOrdinal);
+			const sections = [];
+			for (const record of settledRecords) {
+				const settled = record.settled;
+				const note = await ensureSynthesisNote(record);
+				let noteText;
+				if (note.status === "ok") noteText = typeof note.output === "string" ? note.output : JSON.stringify(note.output ?? null);
+				else {
+					const fallbackKey = deriverV2.deriveKey({
+						kind: "orchestrator-synthesis-note-fallback",
+						nodeId: record.nodeId
+					});
+					if (!internals.replayer.snapshot().some((entry) => entry.kind === "decision" && entry.key === fallbackKey)) await internals.replayer.appendSinglePhase({
+						scope: callingState.scope,
+						key: fallbackKey,
+						kind: "decision",
+						status: "ok",
+						spanId: internals.spans.mint(callingState.spanId),
+						site: "orchestrator-synthesis",
+						value: {
+							decisionType: "orchestrator_synthesis_note_fallback",
+							nodeId: record.nodeId,
+							status: note.status,
+							turnsUsed: note.turns
+						}
+					});
+					internals.events.emit({
+						type: "log",
+						level: "warn",
+						msg: `the synthesis note for child '${record.nodeId}' terminated with status '${note.status}'; falling back to the raw digest summary (journaled decision 'orchestrator_synthesis_note_fallback')`
+					}, callingState.spanId);
+					noteText = digestOf(record, settled).outputSummary;
+				}
+				sections.push({
+					nodeId: record.nodeId,
+					logicalTaskId: record.logicalTaskId,
+					status: settled.status,
+					noteStatus: note.status,
+					note: noteText
+				});
+			}
+			let repeatedClaims;
+			if (spec.dedupeClaims === true) {
+				const deduped = dedupeRepeatedClaims(sections.map((section) => ({
+					nodeId: section.nodeId,
+					text: section.note
+				})));
+				const textByNode = new Map(deduped.rows.map((row) => [row.nodeId, row.text]));
+				for (const section of sections) section.note = textByNode.get(section.nodeId) ?? section.note;
+				repeatedClaims = deduped.repeated;
+			}
+			const draftJson = JSON.stringify(draft ?? null);
+			internals.events.emit({
+				type: "log",
+				level: "debug",
+				msg: "orchestrator synthesis reconciliation",
+				data: {
+					children: sections.length,
+					draftChars: draftJson.length,
+					notesChars: sections.reduce((sum, section) => sum + section.note.length, 0),
+					perChild: sections.map((section) => ({
+						nodeId: section.nodeId,
+						chars: section.note.length
+					})),
+					...repeatedClaims === void 0 ? {} : { repeatedClaims: repeatedClaims.length }
+				}
+			}, callingState.spanId);
+			return {
+				synthesis: "incremental",
+				draft,
+				sections,
+				...repeatedClaims === void 0 ? {} : { repeatedClaims }
+			};
+		};
+		/**
 		* The post-fan-in synthesis invocation (RV-211): a FRESH agent entry
 		* with role 'synthesize' on the finish-only toolset (a distinct
 		* toolsetHash, the reserved-finalizer precedent), its prompt derived
 		* deterministically from the goal, the journaled coordination draft,
 		* and the settled child digest, so a resume replays it by identity
 		* with zero paid calls. Runs strictly AFTER the acceptance verdict
-		* (a rejected run never pays for synthesis) and owns the finish
-		* validators when they are configured. Failure posture: with
-		* validators the run fails typed (the validated path is mandatory);
-		* without them the run falls back to the draft under a journaled
-		* decision and a warn log, never silently.
+		* (a rejected run never pays for synthesis; in 'incremental' mode
+		* the per-child notes are paid DURING the run, so only the
+		* reconciliation itself is deferred) and owns the finish validators
+		* when they are configured. Failure posture: with validators the run
+		* fails typed (the validated path is mandatory); without them the
+		* run falls back to the draft under a journaled decision and a warn
+		* log, never silently.
 		*/
 		const runSynthesis = async (draft) => {
 			const spec = opts?.synthesis;
 			if (spec === void 0) return draft;
 			await recoveryDone;
+			if (spec.mode === "incremental") return await reconcileIncremental(draft, spec);
 			const finishOnly = buildOrchestratorTools(orchestratorRuntime, fullCardText).filter((tool) => tool.name === FINISH_TOOL_NAME);
 			const settledDigests = [...records.values()].filter((record) => record.settled !== void 0).sort((a, b) => a.spawnOrdinal - b.spawnOrdinal).map((record) => digestOf(record, record.settled));
+			let digestRows = settledDigests;
+			let repeatedClaims;
+			if (spec.dedupeClaims === true) {
+				const deduped = dedupeRepeatedClaims(settledDigests.map((row) => ({
+					nodeId: row.nodeId,
+					text: row.outputSummary
+				})));
+				const textByNode = new Map(deduped.rows.map((row) => [row.nodeId, row.text]));
+				digestRows = settledDigests.map((row) => ({
+					...row,
+					outputSummary: textByNode.get(row.nodeId) ?? row.outputSummary
+				}));
+				repeatedClaims = deduped.repeated;
+			}
 			const draftJson = JSON.stringify(draft ?? null);
-			const digestJson = JSON.stringify(settledDigests);
+			const digestJson = JSON.stringify(digestRows);
 			const prompt = [
 				"You are the synthesis invocation of an orchestrated run. Compose the FINAL result of the run from the goal, the coordination draft, and the settled child evidence below by calling finish({ result }) EXACTLY once. Preserve the evidence and citations the draft relies on; do not invent findings. No other tool exists.",
+				...repeatedClaims === void 0 ? [] : ["Repeated claims across children were deduplicated before this prompt: only the first occurrence of each repeated line remains in the digest, and the REPEATED CLAIMS index below lists each one with its reporters."],
 				...spec.instructions === void 0 ? [] : [spec.instructions],
 				...finishValidationPromptLines(validationSpec),
 				`GOAL: ${goal}`,
 				`DRAFT: ${draftJson}`,
-				`DIGEST: ${digestJson}`
+				`DIGEST: ${digestJson}`,
+				...repeatedClaims === void 0 ? [] : [`REPEATED CLAIMS: ${JSON.stringify(repeatedClaims)}`]
 			].join("\n");
 			internals.events.emit({
 				type: "log",
@@ -14462,10 +15428,11 @@ function makeOrchestratorWorkflow(goal, opts) {
 					draftChars: draftJson.length,
 					digestChars: digestJson.length,
 					promptChars: prompt.length,
-					perChild: settledDigests.map((entry) => ({
+					perChild: digestRows.map((entry) => ({
 						nodeId: entry.nodeId,
 						chars: JSON.stringify(entry).length
-					}))
+					})),
+					...repeatedClaims === void 0 ? {} : { repeatedClaims: repeatedClaims.length }
 				}
 			}, callingState.spanId);
 			const synthesisState = { ...callingState };
@@ -14540,7 +15507,11 @@ function makeOrchestratorWorkflow(goal, opts) {
 			const priorRejection = validationDecisions().find((decision) => decision.verdict === "rejected");
 			if (priorRejection !== void 0) throw finishValidationError(priorRejection);
 		}
-		const promptLines = [...extension?.promptLines?.() ?? [], ...finishValidationPromptLines(validationSpec)];
+		const promptLines = [
+			...extension?.promptLines?.() ?? [],
+			...finishValidationPromptLines(validationSpec),
+			...acceptancePromptLines(opts?.acceptance)
+		];
 		const result = await runtime.runInScope(orchestratorState, () => ctx.agent(orchestratorPrompt(goal, opts?.maxSpawns, promptLines.length === 0 ? void 0 : promptLines), agentOpts));
 		const liveTermination = extensionTermination;
 		if (liveTermination !== void 0) throw liveTermination;
@@ -14556,21 +15527,32 @@ function makeOrchestratorWorkflow(goal, opts) {
 		else {
 			const childStatusCounts = {};
 			const degradedReasons = [];
+			const salvaged = [];
+			let hardDegraded = 0;
+			const acceptPartial = opts.acceptance.acceptPartialChildren === true;
 			const sortedRecords = [...records.values()].sort((a, b) => a.spawnOrdinal - b.spawnOrdinal);
 			for (const record of sortedRecords) {
 				const status = record.settled?.status ?? "running";
 				childStatusCounts[status] = (childStatusCounts[status] ?? 0) + 1;
-				if (status !== "ok") degradedReasons.push(status === "running" ? `child ${record.nodeId} was still running when finish validated` : `child ${record.nodeId} settled '${status}'`);
+				if (status === "ok") continue;
+				if (acceptPartial && status === "limit" && record.settled?.partial !== void 0) {
+					salvaged.push(record.nodeId);
+					degradedReasons.push(`child ${record.nodeId} accepted as partial (settled 'limit' with a structured partial)`);
+					continue;
+				}
+				hardDegraded += 1;
+				degradedReasons.push(status === "running" ? `child ${record.nodeId} was still running when finish validated` : `child ${record.nodeId} settled '${status}'`);
 			}
 			const childPolicy = opts.acceptance.childPolicy;
-			const accepted = childPolicy === "all-ok" ? degradedReasons.length === 0 : (childStatusCounts.ok ?? 0) >= childPolicy.minSuccessful;
+			const accepted = childPolicy === "all-ok" ? hardDegraded === 0 : (childStatusCounts.ok ?? 0) + salvaged.length >= childPolicy.minSuccessful;
 			decision = {
 				decisionType: "orchestrator_acceptance",
 				verdict: accepted ? "accepted" : "rejected",
 				completion: !accepted ? "rejected" : degradedReasons.length === 0 ? "complete" : "partial",
 				childPolicy,
 				childStatusCounts,
-				degradedReasons
+				degradedReasons,
+				...salvaged.length === 0 ? {} : { salvagedPartialChildren: salvaged }
 			};
 			await internals.replayer.appendSinglePhase({
 				scope: callingState.scope,
@@ -14586,16 +15568,19 @@ function makeOrchestratorWorkflow(goal, opts) {
 			const required = decision.childPolicy === "all-ok" ? "every child ok" : `at least ${String(decision.childPolicy.minSuccessful)} children ok`;
 			throw new FailRunError(`the orchestrator acceptance policy rejected the finish: ${String(decision.childStatusCounts.ok ?? 0)} children settled 'ok' but the policy requires ${required}; degraded: ${decision.degradedReasons.join("; ")}`, { data: {
 				source: "orchestrator_acceptance",
+				completion: "rejected",
 				childPolicy: decision.childPolicy,
 				childStatusCounts: decision.childStatusCounts,
-				degradedReasons: decision.degradedReasons
+				degradedReasons: decision.degradedReasons,
+				...decision.salvagedPartialChildren === void 0 ? {} : { salvagedPartialChildren: decision.salvagedPartialChildren }
 			} });
 		}
 		return {
 			result: await runSynthesis(result.output),
 			completion: decision.completion,
 			childStatusCounts: decision.childStatusCounts,
-			degradedReasons: decision.degradedReasons
+			degradedReasons: decision.degradedReasons,
+			...decision.salvagedPartialChildren === void 0 ? {} : { salvagedPartialChildren: decision.salvagedPartialChildren }
 		};
 	});
 }
@@ -15243,6 +16228,32 @@ function workflowSourceRef(runId) {
 	return `${runId}/workflow-source`;
 }
 /**
+* The completion envelope contract (RV-207 tail): a workflow reports
+* SEMANTIC completion by returning an object result carrying a
+* `completion` literal (and optionally `childStatusCounts`), or by
+* throwing a typed RulvarError whose `data` carries them; the engine
+* lifts the validated fields onto the `run:end` event so telemetry
+* consumers read completeness without parsing workflow-specific result
+* shapes. The orchestrator acceptance path emits this envelope. Pure
+* shape validation: anything malformed is silently absent (the event is
+* telemetry, never authority), and an invalid counts record drops the
+* counts while keeping a valid completion.
+*/
+function liftRunCompletion(candidate) {
+	if (typeof candidate !== "object" || candidate === null || Array.isArray(candidate)) return;
+	const completion = candidate.completion;
+	if (completion !== "complete" && completion !== "partial" && completion !== "rejected") return;
+	const counts = candidate.childStatusCounts;
+	if (typeof counts === "object" && counts !== null && !Array.isArray(counts)) {
+		const entries = Object.entries(counts);
+		if (entries.every(([, value]) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0)) return {
+			completion,
+			childStatusCounts: Object.fromEntries(entries)
+		};
+	}
+	return { completion };
+}
+/**
 * sha256 hex over the JCS canonical serialization of a run's args: the
 * value the engine records as `RunMeta.argsHash` at genesis, exposed so
 * hosts can verify re-supplied resume args against the recorded hash
@@ -15613,11 +16624,13 @@ function createEngine(options) {
 				}
 			}
 			await putMeta(status).catch(() => void 0);
+			const lifted = liftRunCompletion(status === "ok" || status === "exhausted" ? outcome.value : status === "error" ? wireError?.data : void 0);
 			bus.emit({
 				type: "run:end",
 				status,
 				totalUsd: ledger.usd,
-				...outcome.cost.usageApprox === true ? { usageApprox: true } : {}
+				...outcome.cost.usageApprox === true ? { usageApprox: true } : {},
+				...lifted === void 0 ? {} : lifted
 			}, rootSpanId);
 			bus.end();
 			resumeCtx?.previewResolve({
@@ -16089,4 +17102,4 @@ function createSandboxBridge(ctx, options) {
 	};
 }
 //#endregion
-export { AWAIT_SCHEMA, AdmissionController, AdmissionRejectedError, AgentCallError, BUDGET_ABORT_REASON, BudgetExhaustedError, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, ConfigError, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_DEPTH, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DEFAULT_SYNTHESIS_MAX_TURNS, DedupIndex, DeterminismError, EMIT_RESULT_TOOL, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EscalationDecisionAbortedError, EventBus, ExternalRegistry, FINALIZE_SYNTHESIS_INSTRUCTION, FINISH_SCHEMA, FINISH_TOOL_NAME, FailRunError, FileModelKnowledgeStore, FileTranscriptStore, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GitWorktreeProvider, INBOX_PROPOSAL_TTL_DAYS, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, InvalidResolutionError, JournalCompatibilityError, JournalMatcher, JournalMissError, JournalOrderViolation, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, KeyedLimiter, KnowledgeCasError, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LeaseHeldError, LineageIndex, MASKED_SECRET, MAX_CHILD_RESULT_PAGE_CHARS, MAX_DEPTH_CEILING, ModelRetry, NoProgressDetector, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OrchestratorCapConfigError, PARALLEL_AGENTS_SCHEMA, ParallelSiteCounter, PlanInvariantError, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, ReplayPlanHashMismatch, Replayer, ResolutionArbiter, ResolutionFold, RulvarError, RunBudget, SANDBOX_AGENT_OPT_KEYS, SPAWN_AGENT_SCHEMA, SandboxError, ScriptRejected, Semaphore, SpanRegistry, TOOL_NAME_PATTERN, TerminationAccount, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, atCompactionThreshold, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, claimExpired, claimExpiry, claimIssues, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compilePermissionChain, compilePermissionPreset, compileVerifiedLayer, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createSandboxBridge, currentOnlyKeyRing, decodeCheckpoint, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidencePreservedValidator, executeWorkflow, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, foldTermination, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, identityJcs, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, lexShellCommand, liftRetainedParts, lineageWeightOf, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, parallelScope, parseModelRef, parseScopePath, phiInitialOf, pipelineScope, planNodeScope, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, readRunMeta, readTerminationInit, reconcileRunMeta, reduceCriticalPath, reduceInvocationTable, registryKeyRing, remeasureQueue, replayDisposition, requiredFieldsValidator, requiredSectionsValidator, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, selectStructuredOutputTier, shouldCompact, snapshotUsage, spawnDepthOf, summarizeInstruction, summarizeOutput, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolContract, toolsetHash, ttlState, usageViolations, validateEditorialCommit, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateUsageLimits, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };
+export { AWAIT_SCHEMA, AdmissionController, AdmissionRejectedError, AgentCallError, BUDGET_ABORT_REASON, BudgetExhaustedError, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, ConfigError, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_DEPTH, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DedupIndex, DeterminismError, EMIT_RESULT_TOOL, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EscalationDecisionAbortedError, EventBus, ExternalRegistry, FINALIZE_SYNTHESIS_INSTRUCTION, FINISH_SCHEMA, FINISH_TOOL_NAME, FailRunError, FileModelKnowledgeStore, FileTranscriptStore, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GitWorktreeProvider, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, InvalidResolutionError, JournalCompatibilityError, JournalMatcher, JournalMissError, JournalOrderViolation, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, KeyedLimiter, KnowledgeCasError, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LeaseHeldError, LineageIndex, MASKED_SECRET, MAX_CHILD_RESULT_PAGE_CHARS, MAX_DEPTH_CEILING, ModelRetry, NoProgressDetector, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OrchestratorCapConfigError, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, PlanInvariantError, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, ReplayPlanHashMismatch, Replayer, ResolutionArbiter, ResolutionFold, RulvarError, RunBudget, SANDBOX_AGENT_OPT_KEYS, SPAWN_AGENT_SCHEMA, SandboxError, ScriptRejected, Semaphore, SpanRegistry, TOOL_NAME_PATTERN, TerminationAccount, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, atCompactionThreshold, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, claimExpired, claimExpiry, claimIssues, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compilePermissionChain, compilePermissionPreset, compileVerifiedLayer, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createSandboxBridge, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidencePreservedValidator, executeWorkflow, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, foldTermination, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, identityJcs, implementationAgentProfile, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, parallelScope, parseModelRef, parseScopePath, phiInitialOf, pipelineScope, planNodeScope, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, readRunMeta, readTerminationInit, reconcileRunMeta, reduceCriticalPath, reduceInvocationTable, registryKeyRing, remeasureQueue, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredSectionsValidator, researchAgentProfile, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, selectStructuredOutputTier, shouldCompact, snapshotUsage, spawnDepthOf, summarizeInstruction, summarizeOutput, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolContract, toolsetHash, ttlState, usageViolations, validateEditorialCommit, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateUsageLimits, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };