@iowarp/clio-coder 0.3.1 → 0.3.3

package/src/domains/context/wiki/generate.ts

@@ -16,14 +16,9 @@ import { dirname, join } from "node:path";
 import type { ContextActivityPayload } from "../../../core/bus-events.js";
 import { detectProjectType } from "../../session/workspace/project-type.js";
 import type { BootstrapProgressSink } from "../bootstrap.js";
-import {
-	buildCodewiki,
-	type Codewiki,
-	codewikiNeedsBackfill,
-	readCodewiki,
-	writeCodewiki,
-} from "../codewiki/indexer.js";
-import { computeFingerprint, isStale } from "../fingerprint.js";
+import { coordinateCodewikiWrite } from "../codewiki/coordinator.js";
+import type { Codewiki } from "../codewiki/schema.js";
+import type { Fingerprint } from "../fingerprint.js";
 import { readClioState, writeClioState } from "../state.js";
 import { assembleWikiTree, normalizeRepoPath, pageSourceIndex } from "./assemble.js";
 import { isGeneratedWikiFile, listWikiPagesInDir, WIKI_PLAN_FILE, wikiDir, wikiMarkdownFilesInDir } from "./layout.js";
@@ -108,32 +103,42 @@ function indexedSourceFileCount(codewiki: Codewiki): number {
 	return codewiki.files.filter((file) => file.lang !== "config").length;
 }
 
-async function loadOrBuildCodewiki(cwd: string): Promise<Codewiki> {
-	const existing = readCodewiki(cwd);
-	const prev = readClioState(cwd);
-	// Mirror the code_nav demand-load freshness check: a stale index must never
-	// ground the wiki writer prompt, so drift forces a rebuild here too.
-	if (existing && !codewikiNeedsBackfill(existing)) {
-		const fingerprint = computeFingerprint(cwd, existing);
-		if (prev && !isStale(prev.fingerprint, fingerprint)) return existing;
-	}
+async function loadOrBuildCodewiki(cwd: string): Promise<{
+	codewiki: Codewiki;
+	fingerprint: Fingerprint;
+}> {
 	const generatedAt = new Date().toISOString();
 	const projectType = detectProjectType(cwd);
-	const rebuilt = await buildCodewiki({ cwd, language: projectType, generatedAt });
-	writeCodewiki(cwd, rebuilt);
-	writeClioState(cwd, {
-		version: 1,
-		projectType: prev?.projectType ?? projectType,
-		fingerprint: computeFingerprint(cwd, rebuilt),
-		codewikiVersion: rebuilt.version,
-		...(prev?.contextSources ? { contextSources: prev.contextSources } : {}),
-		...(prev?.contextSourceHash ? { contextSourceHash: prev.contextSourceHash } : {}),
-		...(prev?.lastBootstrap ? { lastBootstrap: prev.lastBootstrap } : {}),
-		...(prev?.lastInitAt ? { lastInitAt: prev.lastInitAt } : {}),
-		lastSessionAt: prev?.lastSessionAt ?? generatedAt,
-		lastIndexedAt: generatedAt,
-	});
-	return rebuilt;
+	const coordinated = await coordinateCodewikiWrite(
+		cwd,
+		(current, workspace) => ({
+			kind: "ensure",
+			cwd: workspace,
+			language: projectType,
+			current,
+			previous: readClioState(workspace)?.fingerprint ?? null,
+		}),
+		{
+			afterCommit: ({ codewiki, fingerprint, changed }, workspace) => {
+				const prev = readClioState(workspace);
+				if (!changed && prev) return;
+				writeClioState(workspace, {
+					version: 1,
+					projectType: prev?.projectType ?? projectType,
+					fingerprint,
+					codewikiVersion: codewiki.version,
+					...(prev?.contextSources ? { contextSources: prev.contextSources } : {}),
+					...(prev?.contextSourceHash ? { contextSourceHash: prev.contextSourceHash } : {}),
+					...(prev?.lastBootstrap ? { lastBootstrap: prev.lastBootstrap } : {}),
+					...(prev?.lastInitAt ? { lastInitAt: prev.lastInitAt } : {}),
+					lastSessionAt: prev?.lastSessionAt ?? generatedAt,
+					lastIndexedAt: generatedAt,
+				});
+			},
+		},
+	);
+	if (!coordinated) throw new Error("codewiki wiki transaction did not commit");
+	return { codewiki: coordinated.codewiki, fingerprint: coordinated.worker.fingerprint };
 }
 
 function failed(problems: string[], pages: number): RunWikiGenerateResult {
@@ -411,8 +416,8 @@ export async function runWikiGenerate(
 
 	try {
 		progress(input, { phase: "codewiki", status: "started", message: "loading codewiki for wiki generation" });
-		const codewiki = await loadOrBuildCodewiki(cwd);
-		const sourceTreeHash = computeFingerprint(cwd, codewiki).treeHash;
+		const { codewiki, fingerprint } = await loadOrBuildCodewiki(cwd);
+		const sourceTreeHash = fingerprint.treeHash;
 		const generation = planWikiGeneration(codewiki, input.depth ?? "auto");
 		progress(input, {
 			phase: "codewiki",

package/src/domains/context/wiki/plan.ts

@@ -16,7 +16,7 @@
  * index finds at the requested depth.
  */
 
-import type { Codewiki, CodewikiFile } from "../codewiki/indexer.js";
+import type { Codewiki, CodewikiFile } from "../codewiki/schema.js";
 
 export type WikiDepth = "auto" | "simple" | "medium" | "detailed";
 export type ResolvedWikiDepth = Exclude<WikiDepth, "auto">;

package/src/domains/context/wiki/prompts.ts

@@ -11,11 +11,11 @@
  */
 
 import { execFileSync } from "node:child_process";
-import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { existsSync, realpathSync, statSync } from "node:fs";
 import { isAbsolute, join, relative } from "node:path";
-import { resolvePackageRoot } from "../../../core/package-root.js";
+import { loadFragments } from "../../prompts/fragment-loader.js";
 import { renderCodewikiDigest } from "../codewiki/digest.js";
-import type { Codewiki } from "../codewiki/indexer.js";
+import type { Codewiki } from "../codewiki/schema.js";
 import { WIKI_PLAN_FILE } from "./layout.js";
 import type { WikiGenerationPlan, WikiPlan, WikiPlanPage } from "./plan.js";
 
@@ -23,12 +23,25 @@ export type WikiGenerateMode = "init" | "update";
 
 type WikiFragment = "plan" | "page";
 
-function fragmentPath(fragment: WikiFragment): string {
-	return join(resolvePackageRoot(), "src", "domains", "prompts", "fragments", "wiki", `${fragment}.md`);
-}
-
+/**
+ * `wiki.plan` and `wiki.page` load through the same fragment loader every
+ * other prompt fragment does (`prompts/fragments/wiki/*.md`), so their
+ * content participates in the same id/version/content-hash contract. What
+ * this module owns and the loader does not is `{{token}}` substitution: each
+ * fragment carries per-dispatch values (a page's path, title, relative path;
+ * the plan file's path) the loader has no way to supply, the same division
+ * `identity.self-awareness` uses for its own `{TOKEN}` placeholders in
+ * `prompts/compiler.ts`. Loaded fresh on every call rather than cached, so a
+ * fragment edit or config hot-reload is visible on the next dispatch with no
+ * separate subscription to wire.
+ */
 function readWikiFragment(fragment: WikiFragment, substitutions: Record<string, string>): string {
-	let text = readFileSync(fragmentPath(fragment), "utf8").trim();
+	const id = `wiki.${fragment}`;
+	const loaded = loadFragments().byId.get(id);
+	if (!loaded) {
+		throw new Error(`context/wiki: fragment "${id}" not found; check prompts/fragments/wiki/${fragment}.md frontmatter`);
+	}
+	let text = loaded.body.trim();
 	for (const [token, value] of Object.entries(substitutions)) {
 		text = text.split(`{{${token}}}`).join(value);
 	}

package/src/domains/dispatch/code-step.ts

@@ -17,6 +17,13 @@ import { execFileSync, spawn } from "node:child_process";
 import { createHash } from "node:crypto";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { isAbsolute, join, resolve } from "node:path";
+import { AI_AGENT_NAME } from "../../core/agent-environment.js";
+import type { CommitAttributionEvidence } from "../../core/commit-attribution.js";
+import {
+	gitCommitAttributionEnabled,
+	reportCommitAttributionDiagnostic,
+	withManagedGitCommitAttributionEnvironment,
+} from "../../core/git-commit-attribution.js";
 import { FLEET_COMMAND_BASE_ENV, type FleetCommand } from "../agents/fleet-commands.js";
 import type { CodeReportResult } from "../agents/result-contract.js";
 
@@ -59,6 +66,11 @@ export interface CodeStepRunInput {
 	 * a failure, not a no-op: it means the step it describes produced nothing.
 	 */
 	requireWorkspaceChanges?: boolean;
+	/** Trusted attribution facts for a commit command; omitted uses Clio-authored child-process defaults. */
+	commitAttribution?: {
+		enabled: boolean;
+		evidence: Readonly<CommitAttributionEvidence>;
+	};
 	signal?: AbortSignal;
 }
 
@@ -140,6 +152,7 @@ export function codeStepEnv(command: FleetCommand, source: NodeJS.ProcessEnv): N
 		const value = source[name];
 		if (value !== undefined) env[name] = value;
 	}
+	env.AI_AGENT = AI_AGENT_NAME;
 	return env;
 }
 
@@ -206,6 +219,12 @@ async function spawnCommand(input: CodeStepRunInput, cwd: string, argv: Readonly
 	const [executable, ...args] = argv;
 	if (executable === undefined) throw new Error(`code step: command '${command.id}' has no executable`);
 	return await new Promise<SpawnOutcome>((resolvePromise) => {
+		const attribution = withManagedGitCommitAttributionEnvironment(codeStepEnv(command, input.env ?? process.env), {
+			cwd,
+			enabled: input.commitAttribution?.enabled ?? gitCommitAttributionEnabled(process.env),
+			...(input.commitAttribution?.evidence === undefined ? {} : { evidence: input.commitAttribution.evidence }),
+		});
+		reportCommitAttributionDiagnostic(attribution.diagnostic);
 		const chunks: Buffer[] = [];
 		let outputBytes = 0;
 		let captured = 0;
@@ -214,7 +233,7 @@ async function spawnCommand(input: CodeStepRunInput, cwd: string, argv: Readonly
 		let spawnError: string | null = null;
 		const child = spawn(executable, args, {
 			cwd,
-			env: codeStepEnv(command, input.env ?? process.env),
+			env: attribution.env,
 			stdio: ["ignore", "pipe", "pipe"],
 			// The command leads its own process group, so a timeout kills the
 			// whole tree rather than orphaning a test runner's children.

package/src/domains/dispatch/extension.ts

@@ -35,8 +35,8 @@ import {
 import { antigravitySubprocessConfigForAutonomy } from "../../engine/antigravity/subprocess-runtime.js";
 import { claudeSubprocessPermissionConfigForAutonomy } from "../../engine/claude/subprocess-runtime.js";
 import { isClaudeCanonicalTool } from "../../engine/claude/tool-safety.js";
-import { WORKER_RUNTIME_MEDIATES_CLIO_DISPATCH } from "../../engine/worker-tools.js";
-import { toolPromptHintsForNames } from "../../tools/bootstrap.js";
+import { WORKER_RUNTIME_MEDIATES_CLIO_DISPATCH } from "../../engine/worker-runtime-capabilities.js";
+import { toolPromptHintsForNames } from "../../tools/builtin-tool-catalog.js";
 import { networkToolsDisabled } from "../../tools/network-policy.js";
 import { applyToolProfile, assertToolProfileEnforceable, type ToolProfileName } from "../../tools/profiles.js";
 import { truncateUtf8 } from "../../tools/truncate-utf8.js";
@@ -73,6 +73,7 @@ import {
 	isDispatchEligibleRuntime,
 	type ProvidersContract,
 	type ResolvedRuntimeTarget,
+	type RuntimeApiFamily,
 	type RuntimeDescriptor,
 	resolveModelCapabilities,
 	resolveRuntimeTarget,
@@ -372,6 +373,14 @@ const DEFAULT_ACP_STALL_TIMEOUT_MS = 300_000;
 const ADMISSION_INPUT_TOKEN_ESTIMATE = 4096;
 const ACP_TOOL_SIGNATURE = "acp:unobservable";
 const ACP_SPEC_FINGERPRINT = "acp:unobservable";
+/**
+ * Where the worker process ran when no fleet placement chose a node. This is the
+ * worker's own host, never the host serving the model: a run against a remote
+ * target from this machine is still a local node. Emitted on every run so a
+ * receipt has one node shape, rather than carrying the block only on the paths
+ * that happened to have a placement object.
+ */
+const LOCAL_RUN_NODE: RunNodeIdentity = { id: "local", kind: "local" };
 function sealRouteDecision(draft: RunReceiptDraft, decision: RouteDecisionV1): RunReceiptDraft {
 	return { ...draft, routeDecision: decision };
 }
@@ -980,8 +989,14 @@ function personaOverrideFor(req: DispatchRequest, staticCompositionHash: string
 
 /**
  * Per-run context for the dynamic worker prompt messages. Everything here
- * flows through dynamic messages, never through the stable system prompt, so
- * `staticCompositionHash` stays byte-identical run over run.
+ * flows through dynamic messages, never through the system prompt. The system
+ * prompt itself is stable per recipe and tool surface with one exception: the
+ * operator-editable layer (`additionalFragments`) folds in path-scoped project
+ * rules selected by `workerWorkingContextPaths`, which are recalled from the
+ * task and briefing text, so `staticCompositionHash` can differ between two
+ * runs of one recipe when a rule's glob matches one task and not the other.
+ * A local model's worker prefix cache misses on that flip; the trade was made
+ * deliberately in #96 to keep rules scoped rather than shipped wholesale.
  */
 export interface WorkerDynamicContext {
 	/** Used only for the verification-section inclusion rule, never for tier policy. */
@@ -1048,6 +1063,35 @@ function workerProjectContextIncludesVerification(body: string): boolean {
 	return body.includes("\nVerification expectations:\n");
 }
 
+/**
+ * Path-like tokens in free text: a slash-separated segment, or a bare
+ * `name.ext` token. The model-facing dispatch tool has no structured
+ * path/file field, so a worker's task text is the only working-context
+ * signal available at compile time; this is best-effort recall, not a
+ * parser. A false-positive token is harmless because `selectActiveRules`
+ * only activates a rule when the token matches that rule's own glob.
+ */
+const PATH_TOKEN_RE = /(?:[\w.-]+\/)+[\w.-]+|\b[\w-]+\.[A-Za-z0-9]{1,8}\b/g;
+
+/**
+ * Best-effort working-context paths for a dispatched worker: `writeRoots`
+ * when the caller set them (the precise signal, for internal/programmatic
+ * callers), plus path-like tokens recalled from the task and briefing text.
+ * Feeds the same `selectActiveRules` a session uses, so a worker whose task
+ * touches a ruled path reads that rule instead of never hearing about it.
+ */
+function workerWorkingContextPaths(req: DispatchRequest): string[] {
+	const out = new Set<string>();
+	for (const root of req.writeRoots ?? []) out.add(root);
+	const text = `${req.task}\n${req.briefing ?? ""}`;
+	for (const match of text.matchAll(PATH_TOKEN_RE)) {
+		const token = match[0];
+		if (token.startsWith("http://") || token.startsWith("https://")) continue;
+		out.add(token);
+	}
+	return [...out];
+}
+
 export function buildDynamicPromptMessages(
 	req: DispatchRequest,
 	dynamicContext: WorkerDynamicContext = {},
@@ -1122,6 +1166,15 @@ interface ResolvedTarget {
 	thinkingLevel: ThinkingLevel;
 	capabilities: CapabilityFlags | null;
 	modelCapabilities: CapabilityFlags | null;
+	/**
+	 * What actually answered the tool-support question for this wire model: the
+	 * operator's own target override, else the knowledge-base entry, else null
+	 * when nothing named it. The merged `modelCapabilities` cannot express this,
+	 * because a runtime default of `tools: false` is indistinguishable there
+	 * from a measurement, and a knowledge-base miss on a local model id is
+	 * routine rather than an answer. See {@link targetToolCapability}.
+	 */
+	toolsCapabilityExplicit: boolean | null;
 	runtimeResolution: ResolvedRuntimeTarget;
 	effectivePricing: EffectivePricing;
 	/** Why the route this run got is not the route it asked for. Belongs in the outcome. */
@@ -1226,6 +1279,10 @@ interface DispatchLifecycleStage {
 	briefing: RunBriefingProvenance | null;
 	personaOverride: RunPersonaOverride | null;
 	projectContext: RunProjectContextProvenance;
+	/** Rule ids the worker prompt compiler selected into this run's system prompt; [] when none matched. */
+	rulesApplied: string[];
+	/** Whether the operator profile rendered non-empty content into this run's system prompt. */
+	operatorProfileApplied: boolean;
 	/** Read-only recipe admitted against a mutating task; null when the pairing was sound. */
 	capabilityMismatch: CapabilityMismatch | null;
 	effectiveAutonomy: AutonomyLevel;
@@ -1252,6 +1309,10 @@ interface AcpDelegationLifecycleStage {
 	briefing: RunBriefingProvenance | null;
 	personaOverride: RunPersonaOverride | null;
 	projectContext: RunProjectContextProvenance;
+	/** ACP delegation bypasses the worker prompt compiler entirely, so this is always []. */
+	rulesApplied: string[];
+	/** ACP delegation bypasses the worker prompt compiler entirely, so this is always false. */
+	operatorProfileApplied: boolean;
 	sessionAutonomy: AutonomyLevel;
 	autonomy: AutonomyLevel;
 }
@@ -1307,16 +1368,6 @@ function runtimeLimitations(runtimeKind: RunKind, runtimeId: string): string[] {
 			"Claude CLI subprocess executes Claude Code tools; Clio constrains permission mode and forbids dangerous bypass unless explicitly gated",
 		];
 	}
-	if (runtimeId === "lmstudio-native") {
-		// The SDK owns model management only. Predictions go over the same
-		// server's OpenAI-compatible port, which is the surface that carries a
-		// thinking control, so the resolved level does reach the wire. What the
-		// SDK still cannot do is unload a model another client loaded outside
-		// Clio's residency plan, which is the one dispatch-visible limit left.
-		return [
-			"LM Studio residency is reconciled through the native SDK; models loaded outside Clio are observed rather than evicted",
-		];
-	}
 	// HTTP/native runtimes run through pi-agent-core, which Clio observes and
 	// controls directly, so there are no runtime-imposed dispatch limitations.
 	return [];
@@ -1364,8 +1415,65 @@ function assertWorkerBudgetEnforceable(runtime: RuntimeDescriptor, hasDeclaredBu
 	);
 }
 
+/**
+ * API families whose wire protocol carries tool calls. Membership is a property
+ * of the protocol, not of any one model: every server speaking one of these can
+ * express a tool call, so a model served over it is presumed able to take one
+ * until something says otherwise. The excluded families (`embeddings-http`,
+ * `rerank-http`) have no tool surface to offer at all.
+ */
+const TOOL_CARRYING_API_FAMILIES: ReadonlySet<RuntimeApiFamily> = new Set([
+	"openai-completions",
+	"openai-responses",
+	"openai-codex-responses",
+	"azure-openai-responses",
+	"anthropic-messages",
+	"bedrock-converse-stream",
+	"google-generative-ai",
+	"google-vertex",
+	"mistral-conversations",
+	"ollama-native",
+	"claude-agent-sdk",
+	"claude-code-subprocess",
+]);
+
+/**
+ * Whether this run may be offered tools at all.
+ *
+ * A runtime default of `tools: false` on a protocol runtime is a placeholder,
+ * not a measurement: the generic `openai-compat` descriptor cannot know what an
+ * arbitrary local server has loaded, so it declares the conservative value and
+ * leaves the answer to the knowledge base. A knowledge-base miss on a local
+ * model id is routine (a new quant, a renamed GGUF, a model newer than the
+ * catalog), so reading that miss as "no tools" denied every dispatch against
+ * every unlisted local model while the same target answered tool calls fine on
+ * the chat path. Only an explicit `false`, from the operator's target override
+ * or from a knowledge-base entry that names the model, denies now; an unanswered
+ * question lets a tool-carrying protocol try and surface a real provider error
+ * if the server genuinely cannot.
+ */
 function targetToolCapability(target: ResolvedTarget): boolean {
-	return target.modelCapabilities?.tools ?? target.runtime.defaultCapabilities.tools === true;
+	if (target.modelCapabilities?.tools === true) return true;
+	if (target.runtime.defaultCapabilities.tools === true) return true;
+	if (target.toolsCapabilityExplicit === false) return false;
+	return TOOL_CARRYING_API_FAMILIES.has(target.runtime.apiFamily);
+}
+
+/**
+ * The only two sources that can actually answer "does this model take tools":
+ * the operator's own target override, which wins, and the knowledge-base entry
+ * for the wire model. Null means nothing named it, which is the common case for
+ * a local model id the catalog has never seen.
+ */
+function explicitToolCapability(
+	providers: ProvidersContract,
+	target: TargetDescriptor,
+	wireModelId: string,
+): boolean | null {
+	if (typeof target.capabilities?.tools === "boolean") return target.capabilities.tools;
+	const hit = providers.knowledgeBase?.lookup(wireModelId) ?? null;
+	const fromKnowledgeBase = hit?.entry.capabilities?.tools;
+	return typeof fromKnowledgeBase === "boolean" ? fromKnowledgeBase : null;
 }
 
 function writeConfinedRequest(req: DispatchRequest): boolean {
@@ -1674,7 +1782,10 @@ function buildDispatchWorkerSpec(input: DispatchWorkerSpecInput, config?: Config
 		...(input.dynamicHash !== null ? { dynamicHash: input.dynamicHash } : {}),
 		agentId: input.req.agentId,
 		task: input.req.task,
-		target: input.target.target,
+		// The configured target may name its runtime by a legacy alias. The attested
+		// document records the resolved runtime instead, so what the worker reads
+		// and what the orchestrator routed on are the same id.
+		target: { ...input.target.target, runtime: input.target.runtime.id },
 		runtime: serializeWorkerRuntimeDescriptor(input.target.runtime),
 		runtimeId: input.target.runtime.id,
 		wireModelId: input.target.wireModelId,
@@ -1705,7 +1816,18 @@ function buildDispatchWorkerSpec(input: DispatchWorkerSpecInput, config?: Config
 	}
 	const product = input.req.product ?? input.recipe?.product;
 	if (product) spec.product = product;
-	spec.runtimeResolution = runtimeTargetSnapshot(input.target.runtimeResolution);
+	// The orchestrator's tool decision is the one the run was admitted under and
+	// the one the approved tool signature was computed from, so it travels on the
+	// snapshot rather than being re-derived worker-side. The worker's
+	// workerProviderSupportsTools reads this field first; letting it recompute
+	// from the merged capability decision made an unanswered tool question
+	// resolve differently in the two processes, and the announcement was then
+	// refused for tool surface drift.
+	const resolutionSnapshot = runtimeTargetSnapshot(input.target.runtimeResolution);
+	spec.runtimeResolution = {
+		...resolutionSnapshot,
+		capabilities: { ...resolutionSnapshot.capabilities, tools: targetToolCapability(input.target) },
+	};
 	if (input.target.modelCapabilities) spec.modelCapabilities = input.target.modelCapabilities;
 	// Configured model ids with the role each serves, so the worker's empty
 	// residency registry evicts nothing and names what it must touch.
@@ -1730,6 +1852,7 @@ function buildDispatchWorkerSpec(input: DispatchWorkerSpecInput, config?: Config
 	} else if (settings) {
 		spec.trustProjectCompatRoots = settings.skills.trustProjectCompatRoots === true;
 	}
+	spec.gitCommitAttribution = settings?.attribution.gitCommits ?? true;
 	// Non-stall posture (Symphony §10.5): a dispatched worker has no operator
 	// to answer a permission prompt by default, so the resolution policy ships
 	// with the spec and the worker enforces it within bounded time. Under the
@@ -2023,6 +2146,7 @@ function resolveSelectedDispatchTarget(
 		thinkingLevel: resolved.target.effectiveThinkingLevel,
 		capabilities: capabilityInfoForTarget(providers, target.id),
 		modelCapabilities,
+		toolsCapabilityExplicit: explicitToolCapability(providers, target, wireModelId),
 		runtimeResolution: resolved.target,
 		effectivePricing: resolveEffectivePricing(target, runtime.id, wireModelId),
 	};
@@ -3103,6 +3227,8 @@ export function createDispatchBundle(
 				contentHash: sha256(personaBody),
 				dynamic: false,
 			},
+			cwd,
+			workingContextPaths: workerWorkingContextPaths(req),
 		});
 		const systemPrompt = compiledWorkerPrompt.systemPrompt;
 		const budget = resolveEffectiveWorkerBudget({ declared: spec.budget, allowedTools: effectiveTools, settings });
@@ -3161,6 +3287,8 @@ export function createDispatchBundle(
 			briefing: briefingProvenanceFor(req),
 			personaOverride,
 			projectContext: projectContextProvenance,
+			rulesApplied: compiledWorkerPrompt.rulesApplied ?? [],
+			operatorProfileApplied: compiledWorkerPrompt.operatorProfileApplied ?? false,
 			capabilityMismatch,
 			effectiveAutonomy,
 			budget,
@@ -3250,6 +3378,8 @@ export function createDispatchBundle(
 			briefing: briefingProvenanceFor(req),
 			personaOverride,
 			projectContext: projectContextProvenance,
+			rulesApplied: [],
+			operatorProfileApplied: false,
 			sessionAutonomy,
 			autonomy,
 		};
@@ -3485,6 +3615,7 @@ export function createDispatchBundle(
 				heartbeatAt: heartbeatIso(acp.heartbeatAt.current),
 				lineage,
 				identity,
+				node: LOCAL_RUN_NODE,
 				...(lifecycle.pipeline ? { pipeline: lifecycle.pipeline } : {}),
 				...(lifecycle.briefing ? { briefing: lifecycle.briefing } : {}),
 				...(req.gate !== undefined ? { gate: req.gate } : {}),
@@ -3639,12 +3770,16 @@ export function createDispatchBundle(
 				outcomeDetail,
 				lineage,
 				identity,
+				// An ACP peer is spawned by this process, so the run's node is this host.
+				node: LOCAL_RUN_NODE,
 				...(lifecycle.pipeline ? { pipeline: lifecycle.pipeline } : {}),
 				...(lifecycle.briefing ? { briefing: lifecycle.briefing } : {}),
 				...(req.gate !== undefined ? { gate: req.gate } : {}),
 				...(req.plan !== undefined ? { plan: req.plan } : {}),
 				...(lifecycle.personaOverride ? { personaOverride: lifecycle.personaOverride } : {}),
 				projectContext: lifecycle.projectContext,
+				rulesApplied: lifecycle.rulesApplied,
+				operatorProfileApplied: lifecycle.operatorProfileApplied,
 				startedAt,
 				endedAt,
 				exitCode:
@@ -4479,7 +4614,7 @@ export function createDispatchBundle(
 				pid,
 				lineage,
 				identity,
-				...(placement ? { node: placement.node } : {}),
+				node: placement?.node ?? LOCAL_RUN_NODE,
 				...(placement?.reroutes !== undefined && placement.reroutes.length > 0
 					? { reroutes: [...placement.reroutes] }
 					: {}),
@@ -4690,7 +4825,7 @@ export function createDispatchBundle(
 				outcomeCode,
 				lineage,
 				identity,
-				...(placement ? { node: placement.node } : {}),
+				node: placement?.node ?? LOCAL_RUN_NODE,
 				...receiptAttestationFields(worker.attestation?.() ?? null),
 				...(placement?.reroutes !== undefined && placement.reroutes.length > 0
 					? { reroutes: [...placement.reroutes] }
@@ -4702,6 +4837,8 @@ export function createDispatchBundle(
 				...(req.plan !== undefined ? { plan: req.plan } : {}),
 				...(lifecycle.personaOverride ? { personaOverride: lifecycle.personaOverride } : {}),
 				projectContext: lifecycle.projectContext,
+				rulesApplied: lifecycle.rulesApplied,
+				operatorProfileApplied: lifecycle.operatorProfileApplied,
 				...(validationGrounding !== null ? { validationGrounding } : {}),
 				...(ledgerContribution !== null ? { ledgerContribution } : {}),
 				...(lifecycle.capabilityMismatch !== null
@@ -5534,11 +5671,11 @@ export function createDispatchBundle(
 			// recordReceipt() and persist(); quarantine tampered ones.
 			try {
 				const recovery = recoverOrphanReceipts(ledger);
-				if (recovery.recovered > 0 || recovery.corrupt > 0 || recovery.abandoned > 0) {
+				if (recovery.recovered > 0 || recovery.corrupt > 0 || recovery.abandoned > 0 || recovery.sealed > 0) {
 					await ledger.persist();
 					if (process.env.CLIO_CODER_INTERACTIVE !== "1") {
 						process.stderr.write(
-							`[dispatch] ledger recovery: recovered=${recovery.recovered} corrupt=${recovery.corrupt} abandoned=${recovery.abandoned} skipped=${recovery.skipped}\n`,
+							`[dispatch] ledger recovery: recovered=${recovery.recovered} sealed=${recovery.sealed} corrupt=${recovery.corrupt} abandoned=${recovery.abandoned} skipped=${recovery.skipped}\n`,
 						);
 					}
 				}

package/src/domains/dispatch/failure-classification.ts

@@ -61,6 +61,12 @@ export function classifyFailure(
 	// healthy endpoint for every other run in the window. Deterministic ends the
 	// attempt here and leaves the caller free to redispatch without the schema.
 	if (isResponseSchemaRejection(diagnostic)) return "deterministic-task";
+	// The worker rejected the specification the orchestrator wrote. A retry sends
+	// a document built the same way from the same settings and earns the same
+	// rejection, so three attempts only tripled the cost of one configuration
+	// error. Ending it here surfaces the contract message the operator has to act
+	// on instead of burying it under two more identical failures.
+	if (/\[worker\] fatal: workerspec/.test(diagnostic)) return "deterministic-task";
 	if (/\b(?:401|403)\b|unauthorized|forbidden|invalid api key|authentication/.test(diagnostic)) return "target-auth";
 	if (/\b429\b|rate[ -]?limit|too many requests/.test(diagnostic)) return "target-rate-limit";
 	if (/\bvram\b|\bgpu\b|\bcuda\b|\boom\b|out of memory/.test(diagnostic)) return "node-resource";

package/src/domains/dispatch/fleet-commit-attribution.ts

@@ -0,0 +1,56 @@
+import type { CommitAttributionEvidence } from "../../core/commit-attribution.js";
+import type { ExecutionPlan, ExecutionPlanCodeStep } from "./execution-plan.js";
+import { RUN_RECEIPT_INTEGRITY_ALGORITHM, RUN_RECEIPT_INTEGRITY_VERSION } from "./receipt-integrity.js";
+
+export interface FleetCommitPriorResult {
+	succeeded: boolean;
+	integrityValid: boolean;
+	receiptDigest: string;
+}
+
+/**
+ * Derive one fleet commit's semantic attribution from scheduler-owned facts.
+ * Agent output text is deliberately absent from this input: prose cannot turn
+ * into testing or review evidence.
+ */
+export function deriveFleetCommitAttribution(input: {
+	plan: ExecutionPlan;
+	step: ExecutionPlanCodeStep;
+	priorResults: ReadonlyMap<string, FleetCommitPriorResult>;
+	validationFresh: boolean;
+	independentReviewFresh: boolean;
+}): CommitAttributionEvidence {
+	const byId = new Map(input.plan.steps.map((step) => [step.id, step] as const));
+	let materiallyAuthored = false;
+	let receipt: CommitAttributionEvidence["receipt"];
+	for (const candidate of input.step.commitFrom ?? []) {
+		const source = byId.get(candidate);
+		const result = input.priorResults.get(candidate);
+		if (
+			source?.kind !== "agent" ||
+			source.scope !== "workspace" ||
+			result?.succeeded !== true ||
+			result.integrityValid !== true
+		) {
+			continue;
+		}
+		materiallyAuthored = true;
+		if (/^[0-9a-f]{64}$/u.test(result.receiptDigest)) {
+			receipt = {
+				version: RUN_RECEIPT_INTEGRITY_VERSION,
+				algorithm: RUN_RECEIPT_INTEGRITY_ALGORITHM,
+				digest: result.receiptDigest,
+				integrityValid: true,
+				directlyRelevant: true,
+			};
+		}
+		break;
+	}
+	return {
+		materiallyAssisted: materiallyAuthored,
+		materiallyAuthored,
+		validationSucceeded: input.validationFresh,
+		independentReviewPassed: input.independentReviewFresh,
+		...(receipt === undefined ? {} : { receipt }),
+	};
+}