@iowarp/clio-coder 0.3.6 → 0.3.8

package/src/domains/agents/registry.ts

@@ -1,5 +1,8 @@
-import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, realpathSync } from "node:fs";
 import path from "node:path";
+import { resolvePackageRoot } from "../../core/package-root.js";
+import { clioConfigDir } from "../../core/xdg.js";
+import { enabledExtensionResourceRoots } from "../extensions/index.js";
 import { loadSkills } from "../resources/skills/loader.js";
 import { parseFrontmatter } from "./frontmatter.js";
 import { type AgentRecipe, type RecipeSource, recipeIdFromPath } from "./recipe.js";
@@ -20,10 +23,29 @@ function resolveBoundSkills(recipe: AgentRecipe, source: RecipeSource): AgentRec
 	// only the operator's discovered skill roots; a recipe cannot smuggle an
 	// arbitrary filesystem path into worker context through a skill name.
 	const packageSkills = path.resolve(source.dir, "..", "..", "..", "..", "skills");
-	const skills = loadSkills({
-		cwd: process.cwd(),
-		...(source.source === "builtin" && existsSync(packageSkills) ? { explicitSkillPaths: [packageSkills] } : {}),
-	});
+	if (source.source === "extension" && source.skillRoot === undefined) {
+		throw new Error(`agent recipe: ${recipe.filepath}: extension declares bound skills but no skills resource root`);
+	}
+	const skills =
+		source.source === "extension"
+			? loadSkills({
+					cwd: source.cwd ?? process.cwd(),
+					disableDiscovery: true,
+					explicitSkillPaths: source.skillRoot === undefined ? [] : [source.skillRoot],
+				})
+			: loadSkills({
+					cwd: source.cwd ?? process.cwd(),
+					...(source.source === "builtin" && existsSync(packageSkills) ? { explicitSkillPaths: [packageSkills] } : {}),
+				});
+	if (source.source === "extension" && source.skillRoot !== undefined) {
+		const canonicalRoot = realpathSync(source.skillRoot);
+		for (const skill of skills.items) {
+			const relative = path.relative(canonicalRoot, realpathSync(skill.filePath));
+			if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+				throw new Error(`agent recipe: ${recipe.filepath}: bound skill escapes its extension: ${skill.filePath}`);
+			}
+		}
+	}
 	const byName = new Map(skills.items.map((skill) => [skill.name, skill.filePath]));
 	const missing = recipe.skills.filter((skill) => !byName.has(skill));
 	if (missing.length > 0) {
@@ -95,6 +117,10 @@ export function mergeRecipes(...sources: ReadonlyArray<ReadonlyArray<AgentRecipe
 				continue;
 			}
 			const builtin = builtinById.get(recipe.id);
+			if (recipe.source === "extension" && builtin) {
+				process.stderr.write(`[clio:agents] ignore override id=${recipe.id} by=extension reason=reserved-builtin\n`);
+				continue;
+			}
 			if (recipe.source === "user" && builtin && isShadowAgent(normalizeAgentSpec(builtin))) {
 				process.stderr.write(`[clio:agents] ignore override id=${recipe.id} by=user reason=reserved-shadow\n`);
 				continue;
@@ -109,3 +135,45 @@ export function mergeRecipes(...sources: ReadonlyArray<ReadonlyArray<AgentRecipe
 	}
 	return Array.from(byId.values()).sort((left, right) => left.id.localeCompare(right.id));
 }
+
+/**
+ * Discover the one native-agent catalog used by listing, fleet admission, and
+ * dispatch. Extension recipes occupy the same precedence slot as extension
+ * fleets: after builtins and before operator/user and project recipes. Their
+ * skill bindings remain constrained to the declaring extension's skill root.
+ */
+export function discoverAgentRecipes(
+	cwd = process.cwd(),
+	diagnostics: AgentRecipeDiagnostic[] = [],
+): ReadonlyArray<AgentRecipe> {
+	const builtin = loadRecipesFromDir(
+		{
+			dir: path.join(resolvePackageRoot(), "src", "domains", "agents", "builtins"),
+			source: "builtin",
+			cwd,
+		},
+		diagnostics,
+	);
+	const skillRoots = new Map(enabledExtensionResourceRoots("skills", cwd).map((root) => [root.source, root.path]));
+	const extensionRecipes = enabledExtensionResourceRoots("agents", cwd)
+		.sort((left, right) => left.source.localeCompare(right.source))
+		.map((root) => {
+			const skillRoot = skillRoots.get(root.source);
+			return loadRecipesFromDir(
+				{
+					dir: root.path,
+					source: "extension",
+					cwd,
+					origin: root.source,
+					...(skillRoot === undefined ? {} : { skillRoot }),
+				},
+				diagnostics,
+			);
+		});
+	const user = loadRecipesFromDir({ dir: path.join(clioConfigDir(), "agents"), source: "user", cwd }, diagnostics);
+	const project = loadRecipesFromDir(
+		{ dir: path.join(cwd, ".clio-coder", "agents"), source: "project", cwd },
+		diagnostics,
+	);
+	return mergeRecipes(builtin, ...extensionRecipes, user, project);
+}

package/src/domains/agents/result-contract.ts

@@ -7,10 +7,42 @@ export type ResultContract =
 	| { kind: "architect-plan"; path: string }
 	| { kind: "scout-report" }
 	| { kind: "verifier-report" }
+	| { kind: "council-report" }
+	/**
+	 * One council member's ballot under `synthesis: "vote"`.
+	 *
+	 * The vote is a strict majority over the members' `verdict` fields, computed
+	 * by the coordinator with no model call. Nothing asked a member for that
+	 * field before this kind existed, and nothing could: an unnamed council
+	 * seats the builtin `researcher`, whose `research-report` accepts only
+	 * `source` and `findings`, so a member that emitted a verdict failed its own
+	 * postcondition and a member that obeyed its postcondition emitted no
+	 * verdict. Every vote therefore resolved to `no_verdict_field` with an empty
+	 * tally, on every input (#230).
+	 *
+	 * The ballot is the coordinator's postcondition for that slot, not the
+	 * recipe's, in the same way `reviewer` and the compete `judge` answer the
+	 * gate that dispatched them. It rides in as a `resultContractOverride` on
+	 * the member request, so the seated recipe keeps its persona and any recipe
+	 * can be voted with. No recipe may declare it: `parseResultContract` rejects
+	 * the kind, and a Scout subtask may not request it, because it is a
+	 * topology's ballot rather than an agent's work product.
+	 */
+	| { kind: "council-ballot" }
 	| { kind: "debugger-report" }
 	| { kind: "research-report" }
 	| { kind: "mutation-report" }
 	| { kind: "provenance-report" }
+	| { kind: "delegation-plan" }
+	/**
+	 * The advisory answer `/oracle` asks for. It exists as its own kind because
+	 * the answer shape is the whole point of the command: a verdict, the
+	 * strongest challenge the advisor can mount, the evidence that would change
+	 * its mind, and the prior decisions it read. Folding it onto
+	 * `research-report` would ask for claims and evidence instead, and the
+	 * challenge and the reversal condition would have nowhere to go.
+	 */
+	| { kind: "oracle-report" }
 	| { kind: "external-delegation" }
 	/**
 	 * The run's postcondition is the artifact it left on disk, so its terminal
@@ -58,6 +90,7 @@ export interface ResultContractValidation {
 	scout?: ScoutResult;
 	/** Parsed Verifier data for the dispatch review-gate projection. */
 	verifier?: VerifierResult;
+	delegationPlan?: DelegationPlanResult;
 	reason?: string;
 }
 
@@ -211,6 +244,220 @@ export interface VerifierResult {
 	checks: ReadonlyArray<VerifierCheck>;
 }
 
+export interface DelegationPlanResultTask {
+	id: string;
+	agent: string;
+	description: string;
+	depends_on: ReadonlyArray<string>;
+	writes: ReadonlyArray<string>;
+	mode?: "sequential" | "parallel";
+}
+
+export interface DelegationPlanResult {
+	tasks: ReadonlyArray<DelegationPlanResultTask>;
+}
+
+export function parseDelegationPlanResult(output: string | null): DelegationPlanResult | null {
+	const parsed = parseJson(output);
+	if (
+		!parsed.ok ||
+		!hasOnlyKeys(parsed.value, ["tasks"]) ||
+		!Array.isArray(parsed.value.tasks) ||
+		parsed.value.tasks.length === 0
+	)
+		return null;
+	const tasks: DelegationPlanResultTask[] = [];
+	for (const raw of parsed.value.tasks) {
+		if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return null;
+		const task = raw as Record<string, unknown>;
+		if (
+			!hasOnlyKeys(task, ["id", "agent", "description", "depends_on", "writes", "mode"]) ||
+			!string(task.id) ||
+			!string(task.agent) ||
+			!string(task.description) ||
+			!Array.isArray(task.depends_on) ||
+			task.depends_on.some((entry) => !string(entry)) ||
+			!Array.isArray(task.writes) ||
+			task.writes.some((entry) => !string(entry)) ||
+			(task.mode !== undefined && task.mode !== "sequential" && task.mode !== "parallel")
+		)
+			return null;
+		tasks.push({
+			id: task.id,
+			agent: task.agent,
+			description: task.description,
+			depends_on: [...task.depends_on] as string[],
+			writes: [...task.writes] as string[],
+			...(task.mode !== undefined ? { mode: task.mode as "sequential" | "parallel" } : {}),
+		});
+	}
+	return { tasks };
+}
+
+/**
+ * Longest verdict token a ballot may cast, in bytes.
+ *
+ * A tally groups members by their exact verdict string, so a verdict that is a
+ * sentence can only ever tie with itself and a council of any size reports
+ * `no_majority`. The bound is what makes a majority reachable: it forces the
+ * decision into a token members can match (`yes`, `no`, `keep`, an option
+ * name) and pushes the reasoning into `text`, where the report already reads
+ * it. A newline is refused for the same reason.
+ */
+export const COUNCIL_BALLOT_VERDICT_MAX_BYTES = 64;
+
+/**
+ * The ballot's wire shape, quoted verbatim to the member that must cast it and
+ * by the repair round that corrects it. Exported because the council composes
+ * the member's ask from it, which is the rule this module already states: a
+ * contract's example is written once so a prompt cannot drift from its
+ * validator.
+ */
+export const COUNCIL_BALLOT_SHAPE = '{"verdict":"yes","text":"the answer and the evidence behind it"}';
+
+interface CouncilBallot {
+	/** The comparable token the tally counts. */
+	verdict: string;
+	/** The member's answer in prose, which is what the council report shows. */
+	text: string;
+}
+
+/**
+ * Read a council member's ballot. The council reads a verdict out of the
+ * member's terminal text with its own reader, because the judge synthesis
+ * carries the same two fields under no contract at all; this one is what
+ * decides whether the member is allowed to seal that text as its result.
+ */
+function parseCouncilBallot(output: string | null): CouncilBallot | null {
+	const parsed = parseJson(output);
+	if (!parsed.ok) return null;
+	const value = parsed.value;
+	if (!hasOnlyKeys(value, ["verdict", "text"]) || !string(value.verdict) || !string(value.text)) return null;
+	const verdict = value.verdict.trim();
+	if (verdict.includes("\n") || Buffer.byteLength(verdict, "utf8") > COUNCIL_BALLOT_VERDICT_MAX_BYTES) return null;
+	return { verdict, text: value.text.trim() };
+}
+
+function validateCouncilBallot(contract: ResultContract, output: string | null): ResultContractValidation {
+	const parsed = parseJson(output);
+	if (!parsed.ok) return failure(contract, "unmeasured", parsed.reason);
+	const ballot = parseCouncilBallot(output);
+	if (ballot === null) {
+		return failure(
+			contract,
+			"unmeasured",
+			`A council ballot must carry only verdict and text, both non-empty strings, with verdict a single line of at most ${COUNCIL_BALLOT_VERDICT_MAX_BYTES} bytes so the tally can match it against the other members`,
+		);
+	}
+	// Unmeasured, like every other contract whose shape carries no correctness
+	// claim: casting a well-formed ballot says nothing about whether the member
+	// was right, and the tally is a count of opinions rather than a check.
+	return success(contract, "unmeasured", ballot);
+}
+
+export interface CouncilReportMember {
+	label: string;
+	runId: string;
+	round: number;
+	answer: string;
+	verdict?: string;
+	failed?: { reason: string };
+}
+
+export interface CouncilReport {
+	members: CouncilReportMember[];
+	synthesis: {
+		kind: "none" | "judge" | "vote";
+		text?: string;
+		verdict?: string;
+		tally?: Record<string, number>;
+		judgeRunId?: string;
+	};
+}
+
+export function parseCouncilReport(output: string | null): CouncilReport | null {
+	if (output === null) return null;
+	const parsed = parseJsonObjectPayload(output);
+	if (!parsed.ok) return null;
+	const value = parsed.value;
+	if (!hasOnlyKeys(value, ["members", "synthesis"]) || !Array.isArray(value.members) || value.members.length === 0) {
+		return null;
+	}
+	const members: CouncilReportMember[] = [];
+	for (const raw of value.members) {
+		if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return null;
+		const member = raw as Record<string, unknown>;
+		if (
+			!hasOnlyKeys(member, ["label", "runId", "round", "answer", "verdict", "failed"]) ||
+			!string(member.label) ||
+			!string(member.runId) ||
+			!Number.isInteger(member.round) ||
+			Number(member.round) < 1 ||
+			typeof member.answer !== "string" ||
+			(member.verdict !== undefined && !string(member.verdict))
+		)
+			return null;
+		let failed: { reason: string } | undefined;
+		if (member.failed !== undefined) {
+			if (
+				member.failed === null ||
+				typeof member.failed !== "object" ||
+				Array.isArray(member.failed) ||
+				!hasOnlyKeys(member.failed as Record<string, unknown>, ["reason"]) ||
+				!string((member.failed as Record<string, unknown>).reason)
+			)
+				return null;
+			failed = { reason: (member.failed as { reason: string }).reason };
+		}
+		members.push({
+			label: member.label,
+			runId: member.runId,
+			round: Number(member.round),
+			answer: member.answer,
+			...(member.verdict !== undefined ? { verdict: member.verdict as string } : {}),
+			...(failed !== undefined ? { failed } : {}),
+		});
+	}
+	if (value.synthesis === null || typeof value.synthesis !== "object" || Array.isArray(value.synthesis)) return null;
+	const rawSynthesis = value.synthesis as Record<string, unknown>;
+	if (!hasOnlyKeys(rawSynthesis, ["kind", "text", "verdict", "tally", "judgeRunId"])) return null;
+	if (rawSynthesis.kind !== "none" && rawSynthesis.kind !== "judge" && rawSynthesis.kind !== "vote") return null;
+	for (const key of ["text", "verdict", "judgeRunId"] as const) {
+		if (rawSynthesis[key] !== undefined && !string(rawSynthesis[key])) return null;
+	}
+	let tally: Record<string, number> | undefined;
+	if (rawSynthesis.tally !== undefined) {
+		if (rawSynthesis.tally === null || typeof rawSynthesis.tally !== "object" || Array.isArray(rawSynthesis.tally))
+			return null;
+		tally = {};
+		for (const [key, count] of Object.entries(rawSynthesis.tally as Record<string, unknown>)) {
+			if (!key || !Number.isInteger(count) || Number(count) < 0) return null;
+			tally[key] = Number(count);
+		}
+	}
+	return {
+		members,
+		synthesis: {
+			kind: rawSynthesis.kind,
+			...(rawSynthesis.text !== undefined ? { text: rawSynthesis.text as string } : {}),
+			...(rawSynthesis.verdict !== undefined ? { verdict: rawSynthesis.verdict as string } : {}),
+			...(tally !== undefined ? { tally } : {}),
+			...(rawSynthesis.judgeRunId !== undefined ? { judgeRunId: rawSynthesis.judgeRunId as string } : {}),
+		},
+	};
+}
+
+/**
+ * Parsed `oracle-report` payload. `/oracle` renders these four fields into the
+ * operator note it hands the main agent, so the shape is the answer shape.
+ */
+export interface OracleResult {
+	verdict: string;
+	challenge: string;
+	changesMyMind: string;
+	citedDecisions: ReadonlyArray<string>;
+}
+
 /**
  * Parsed `code-report` payload. `passed` restates `exitCode === 0` so a
  * downstream reader never has to know a runner's exit conventions, and
@@ -269,7 +516,7 @@ function success(
 	contract: ResultContract,
 	quality: ResultContractQuality,
 	value: unknown,
-	extra: Pick<ResultContractValidation, "scout" | "verifier" | "reason"> = {},
+	extra: Pick<ResultContractValidation, "scout" | "verifier" | "delegationPlan" | "reason"> = {},
 ): ResultContractValidation {
 	return {
 		conformance: "pass",
@@ -335,6 +582,7 @@ const RESULT_CONTRACT_KINDS: ReadonlyArray<ResultContract["kind"]> = [
 	"architect-plan",
 	"scout-report",
 	"verifier-report",
+	"council-report",
 	"debugger-report",
 	"research-report",
 	"mutation-report",
@@ -664,6 +912,47 @@ export function parseVerifierResult(output: string | null): VerifierResult | nul
 	return validation.verifier ?? null;
 }
 
+/**
+ * An advisory opinion is never a correctness signal about the route that
+ * produced it, so conformance is judged on the shape alone and quality stays
+ * `unmeasured`. `citedDecisions` may be empty: an honest advisor that found no
+ * settled decision bearing on the question must be able to say so.
+ */
+function validateOracle(contract: ResultContract, output: string | null): ResultContractValidation {
+	const parsed = parseJson(output);
+	if (!parsed.ok) return failure(contract, "unmeasured", parsed.reason);
+	const value = parsed.value;
+	if (
+		!hasOnlyKeys(value, ["verdict", "challenge", "changesMyMind", "citedDecisions"]) ||
+		!string(value.verdict) ||
+		!string(value.challenge) ||
+		!string(value.changesMyMind) ||
+		!Array.isArray(value.citedDecisions) ||
+		value.citedDecisions.some((entry) => !string(entry))
+	) {
+		return failure(
+			contract,
+			"unmeasured",
+			'Oracle result must carry verdict, challenge, changesMyMind, and a citedDecisions array of strings, for example {"verdict":"consistent with decision routing.target","challenge":"...","changesMyMind":"...","citedDecisions":["routing.target"]}',
+		);
+	}
+	return success(contract, "unmeasured", value);
+}
+
+/** Parse an oracle answer under the same schema its recipe contract enforces. */
+export function parseOracleResult(output: string | null): OracleResult | null {
+	const validation = validateOracle({ kind: "oracle-report" }, output);
+	if (validation.conformance !== "pass") return null;
+	const parsed = parseJson(output);
+	if (!parsed.ok) return null;
+	return {
+		verdict: String(parsed.value.verdict),
+		challenge: String(parsed.value.challenge),
+		changesMyMind: String(parsed.value.changesMyMind),
+		citedDecisions: (parsed.value.citedDecisions as ReadonlyArray<string>).map((entry) => String(entry)),
+	};
+}
+
 /**
  * A code step's result is always `unmeasured` for routing quality. A red suite
  * is evidence about the repository, not about the route that ran the command,
@@ -1036,6 +1325,14 @@ export function validateResultContract(input: ResultContractValidationInput): Re
 		}
 		case "verifier-report":
 			return validateVerifier(input.contract, input.output);
+		case "council-report": {
+			const report = parseCouncilReport(input.output);
+			return report === null
+				? failure(input.contract, "fail", "council-report is malformed")
+				: success(input.contract, "unmeasured", { council: report });
+		}
+		case "council-ballot":
+			return validateCouncilBallot(input.contract, input.output);
 		case "debugger-report":
 			return validateDebugger(input.contract, input.output);
 		case "research-report":
@@ -1044,6 +1341,18 @@ export function validateResultContract(input: ResultContractValidationInput): Re
 			return validateMutation(input.contract, input);
 		case "provenance-report":
 			return validateProvenance(input.contract, input.output);
+		case "delegation-plan": {
+			const plan = parseDelegationPlanResult(input.output);
+			return plan === null
+				? failure(
+						input.contract,
+						"fail",
+						"delegation-plan must carry tasks with id, agent, description, depends_on, writes, and optional mode",
+					)
+				: success(input.contract, "unmeasured", plan, { delegationPlan: plan });
+		}
+		case "oracle-report":
+			return validateOracle(input.contract, input.output);
 		case "external-delegation":
 			return success(input.contract, "unmeasured", { external: true });
 		case "artifact-report":
@@ -1120,6 +1429,10 @@ function resultContractShape(contract: ResultContract): string {
 			return '{"findings":[{"claim":"what you observed","path":"src/file.ts","line":1}],"needsSplit":false,"proposedSubtasks":[]} or {"findings":[],"needsSplit":true,"proposedSubtasks":[{"id":"inspect","task":"Inspect the boundary","dependencies":[],"expectedResultContract":"scout-report","requestedAuthority":"read-only"}]} or, if you cannot produce a citation you are sure of, at least {"findings":[{"claim":"what you observed"}]}, which is accepted as an ungrounded lead rather than losing the run';
 		case "verifier-report":
 			return '{"verdict":"pass","checks":[{"name":"npm run typecheck","passed":true,"evidence":"exit 0"}]}';
+		case "council-report":
+			return '{"members":[{"label":"alpha","runId":"run-1","round":1,"answer":"..."}],"synthesis":{"kind":"none"}}';
+		case "council-ballot":
+			return COUNCIL_BALLOT_SHAPE;
 		case "debugger-report":
 			return '{"diagnosis":"...","reproduction":"reproduced","evidence":["..."]}';
 		case "research-report":
@@ -1128,6 +1441,10 @@ function resultContractShape(contract: ResultContract): string {
 			return '{"mutatedPaths":["src/file.ts"],"validations":[{"name":"npm test","passed":true,"evidence":"exit 0"}],"commitMessage":"optional: the commit message for this change","summary":"optional: one line"}';
 		case "provenance-report":
 			return '{"confirmedFacts":["..."],"missingEvidence":["..."],"nextInspections":["..."]}';
+		case "delegation-plan":
+			return '{"tasks":[{"id":"build","agent":"coder","description":"Implement the change","depends_on":[],"writes":["src"],"mode":"parallel"}]}';
+		case "oracle-report":
+			return '{"verdict":"one line","challenge":"the strongest objection you can mount","changesMyMind":"the evidence that would reverse the verdict","citedDecisions":["decision key or task id you relied on"]}';
 		case "external-delegation":
 			return "any final text";
 		case "artifact-report":
@@ -1232,8 +1549,31 @@ export function resultContractRepairMessages(
 	] as const;
 }
 
-/** Strict frontmatter parser for the one recipe result-contract schema. */
-export function parseResultContract(value: unknown, sourcePath: string): ResultContract {
+/** Kinds an agent recipe may declare in its frontmatter. */
+const RECIPE_DECLARABLE_KINDS = [
+	"scout-report",
+	"verifier-report",
+	"council-report",
+	"debugger-report",
+	"research-report",
+	"mutation-report",
+	"provenance-report",
+	"oracle-report",
+	"external-delegation",
+	"artifact-report",
+	"context-handbook",
+	"delegation-plan",
+] as const;
+
+/**
+ * Kinds the coordinator authors and hands to a worker on the wire, which no
+ * recipe may declare. A council ballot is the topology's postcondition for a
+ * vote member's slot, so it arrives as a `resultContractOverride` on the
+ * request and never out of frontmatter.
+ */
+const COORDINATOR_AUTHORED_KINDS = ["council-ballot"] as const;
+
+function parseContract(value: unknown, sourcePath: string, kinds: ReadonlyArray<string>): ResultContract {
 	if (value === null || typeof value !== "object" || Array.isArray(value)) {
 		throw new Error(`agent recipe: ${sourcePath}: resultContract must be an object`);
 	}
@@ -1250,19 +1590,24 @@ export function parseResultContract(value: unknown, sourcePath: string): ResultC
 		}
 		return { kind: "architect-plan", path: record.path };
 	}
-	const kinds = [
-		"scout-report",
-		"verifier-report",
-		"debugger-report",
-		"research-report",
-		"mutation-report",
-		"provenance-report",
-		"external-delegation",
-		"artifact-report",
-		"context-handbook",
-	] as const;
-	if (!(kinds as ReadonlyArray<string>).includes(record.kind) || !only("kind")) {
+	if (!kinds.includes(record.kind) || !only("kind")) {
 		throw new Error(`agent recipe: ${sourcePath}: resultContract.kind is unsupported or has unknown keys`);
 	}
 	return { kind: record.kind as Exclude<ResultContract["kind"], "architect-plan"> };
 }
+
+/** Strict frontmatter parser for the one recipe result-contract schema. */
+export function parseResultContract(value: unknown, sourcePath: string): ResultContract {
+	return parseContract(value, sourcePath, RECIPE_DECLARABLE_KINDS);
+}
+
+/**
+ * The same parser for a contract that arrived on a WorkerSpec. It admits what a
+ * recipe may declare plus what the coordinator may author, because a dispatch
+ * request can override the seated recipe's postcondition and the worker has to
+ * be able to read the contract it will be validated against. Keeping the recipe
+ * parser strict is the point: a recipe still cannot claim a coordinator's kind.
+ */
+export function parseWorkerResultContract(value: unknown, sourcePath: string): ResultContract {
+	return parseContract(value, sourcePath, [...RECIPE_DECLARABLE_KINDS, ...COORDINATOR_AUTHORED_KINDS]);
+}

package/src/domains/agents/write-boundary.ts

@@ -1,3 +1,12 @@
+import {
+	normalizePathBoundary,
+	normalizePathBoundaryEntry,
+	PATH_BOUNDARY_MAX_ENTRIES,
+	type PathBoundary,
+	pathBoundariesOverlap,
+	pathBoundaryCovers,
+} from "../../core/path-boundary.js";
+
 /**
  * Declared write boundaries: the repo paths a fleet step is allowed to change.
  *
@@ -30,37 +39,14 @@
  * a step that needs more of the tree than that should say `workspace` and mean
  * it in a contract that does not claim a boundary.
  */
-export const WRITE_BOUNDARY_MAX_ENTRIES = 32;
+export const WRITE_BOUNDARY_MAX_ENTRIES = PATH_BOUNDARY_MAX_ENTRIES;
 
 /** A normalized allowlist. Empty means "changes nothing", which is `readonly`. */
-export type WriteBoundary = ReadonlyArray<string>;
-
-const GLOB_CHARACTERS = /[*?[\]{}]/u;
+export type WriteBoundary = PathBoundary;
 
 /** Normalize one declared entry, or throw explaining exactly what is wrong. */
 export function normalizeWriteBoundaryEntry(entry: string): string {
-	const raw = entry.trim();
-	if (raw.length === 0) throw new Error("write boundary: entry must be a non-empty path");
-	if (raw.includes("\\")) {
-		throw new Error(`write boundary: entry '${entry}' must use '/' separators`);
-	}
-	if (GLOB_CHARACTERS.test(raw)) {
-		throw new Error(`write boundary: entry '${entry}' looks like a glob, which v1 does not support`);
-	}
-	if (raw.startsWith("/") || /^[A-Za-z]:/u.test(raw)) {
-		throw new Error(`write boundary: entry '${entry}' must be repository-relative, not absolute`);
-	}
-	const subtree = raw.endsWith("/");
-	const segments = raw.split("/").filter((segment) => segment.length > 0);
-	if (segments.length === 0) {
-		throw new Error(`write boundary: entry '${entry}' must name a path inside the repository`);
-	}
-	for (const segment of segments) {
-		if (segment === "..") throw new Error(`write boundary: entry '${entry}' must not contain '..'`);
-		if (segment === ".") throw new Error(`write boundary: entry '${entry}' must not contain '.' segments`);
-	}
-	const joined = segments.join("/");
-	return subtree ? `${joined}/` : joined;
+	return normalizePathBoundaryEntry(entry);
 }
 
 /**
@@ -69,38 +55,17 @@ export function normalizeWriteBoundaryEntry(entry: string): string {
  * and a sealed verdict can both carry.
  */
 export function normalizeWriteBoundary(entries: ReadonlyArray<string>): string[] {
-	if (entries.length > WRITE_BOUNDARY_MAX_ENTRIES) {
-		throw new Error(`write boundary: at most ${WRITE_BOUNDARY_MAX_ENTRIES} entries may be declared`);
-	}
-	const normalized = new Set(entries.map(normalizeWriteBoundaryEntry));
-	// A file entry covered by a declared subtree is redundant, not an error: the
-	// operator said the directory, and saying one of its files again changes
-	// nothing about what is allowed.
-	return [...normalized].sort();
-}
-
-/** Repo-relative path with the separators this grammar speaks. */
-function toRepoRelativePosix(path: string): string {
-	return path.split("\\").join("/");
+	return normalizePathBoundary(entries);
 }
 
 /** Whether the boundary permits a change to one repo-relative path. */
 export function writeBoundaryCovers(boundary: WriteBoundary, path: string): boolean {
-	const candidate = toRepoRelativePosix(path);
-	return boundary.some((entry) => (entry.endsWith("/") ? candidate.startsWith(entry) : candidate === entry));
-}
-
-/** Whether two declared entries can describe the same path. */
-function entriesOverlap(left: string, right: string): boolean {
-	if (left === right) return true;
-	if (left.endsWith("/") && right.startsWith(left)) return true;
-	if (right.endsWith("/") && left.startsWith(right)) return true;
-	return false;
+	return pathBoundaryCovers(boundary, path);
 }
 
 /** Whether two boundaries share any path. Empty boundaries never overlap. */
 export function writeBoundariesOverlap(left: WriteBoundary, right: WriteBoundary): boolean {
-	return left.some((entry) => right.some((other) => entriesOverlap(entry, other)));
+	return pathBoundariesOverlap(left, right);
 }
 
 /** Operator-facing rendering, used verbatim in violation messages. */

package/src/domains/config/classify.ts

@@ -28,6 +28,10 @@ const HOT_RELOAD_FIELDS = new Set<string>([
 	"modelSelector",
 	"terminal.smoothStreaming",
 	"attribution.gitCommits",
+	// The watchdog registration reads its settings live on every trigger, so
+	// enabling it, retargeting it, or changing its cadence takes effect on the
+	// next turn boundary without a restart or a session-routing patch.
+	"watchdog",
 ]);
 
 const NEXT_TURN_FIELDS = new Set<string>([