@iowarp/clio-coder 0.3.1 → 0.3.2

package/src/tools/truncate.ts

@@ -1,38 +1,25 @@
-// Per-observation source cap. One tool result must stay proportional to the
-// question asked: ~16k chars ≈ 4k tokens, enough to read a typical source file
-// or doc section in one call while a local backend still prefills it quickly.
-// Truncated output always says how to continue (offset/limit or a narrower
-// query), so larger requests cost extra calls, not a blown context. The
-// per-turn observation budget (see read.ts) bounds how much these calls add up
-// to within a single turn.
+import {
+	formatSize,
+	GREP_MAX_LINE_LENGTH,
+	type TruncationOptions,
+	type TruncationResult,
+	truncateLine,
+	truncateHead as truncatePiHead,
+	truncateTail as truncatePiTail,
+} from "../engine/truncate.js";
+
+// Per-observation source cap. Pi defaults to 50 KiB; Clio deliberately keeps
+// one result proportional to its per-turn observation budget at 16 KiB. The
+// wrappers below retain only that product-level delta while Pi owns UTF-8-safe
+// head/tail truncation, line limits, grep-line clipping, and size formatting.
 export const DEFAULT_MAX_LINES = 2000;
 export const DEFAULT_MAX_BYTES = 16 * 1024;
-export const GREP_MAX_LINE_LENGTH = 500;
+export type { TruncationResult };
+export { formatSize, GREP_MAX_LINE_LENGTH, truncateLine };
 
-export interface TruncationResult {
-	content: string;
-	truncated: boolean;
-	truncatedBy: "lines" | "bytes" | null;
-	totalLines: number;
-	totalBytes: number;
-	outputLines: number;
-	outputBytes: number;
-	lastLinePartial: boolean;
-	firstLineExceedsLimit: boolean;
-	maxLines: number;
-	maxBytes: number;
-}
-
-export interface TruncationOptions {
-	maxLines?: number;
-	maxBytes?: number;
-}
-
-// Count lines without a trailing-newline phantom entry. `"a\nb\n".split("\n")`
-// yields `["a","b",""]` (3 entries) for a 2-line file; dropping the final empty
-// element restores an honest count so continuation notices ("N more lines") do
-// not over-report by one on newline-terminated files. Ported from pi's
-// truncate.ts:47.
+// Count lines without a trailing-newline phantom entry. Pi uses the same
+// counting rule internally but does not export it; Clio's read continuation
+// notices need the total before selecting a slice.
 export function splitLinesForCounting(content: string): string[] {
 	if (content.length === 0) return [];
 	const lines = content.split("\n");
@@ -40,163 +27,17 @@ export function splitLinesForCounting(content: string): string[] {
 	return lines;
 }
 
-export function formatSize(bytes: number): string {
-	if (bytes < 1024) return `${bytes}B`;
-	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
-	return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
-}
-
-export function truncateHead(content: string, options: TruncationOptions = {}): TruncationResult {
-	const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
-	const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
-	const totalBytes = Buffer.byteLength(content, "utf8");
-	const lines = splitLinesForCounting(content);
-	const totalLines = lines.length;
-
-	if (totalLines <= maxLines && totalBytes <= maxBytes) {
-		return {
-			content,
-			truncated: false,
-			truncatedBy: null,
-			totalLines,
-			totalBytes,
-			outputLines: totalLines,
-			outputBytes: totalBytes,
-			lastLinePartial: false,
-			firstLineExceedsLimit: false,
-			maxLines,
-			maxBytes,
-		};
-	}
-
-	const firstLineBytes = Buffer.byteLength(lines[0] ?? "", "utf8");
-	if (firstLineBytes > maxBytes) {
-		return {
-			content: "",
-			truncated: true,
-			truncatedBy: "bytes",
-			totalLines,
-			totalBytes,
-			outputLines: 0,
-			outputBytes: 0,
-			lastLinePartial: false,
-			firstLineExceedsLimit: true,
-			maxLines,
-			maxBytes,
-		};
-	}
-
-	const out: string[] = [];
-	let outputBytes = 0;
-	let truncatedBy: "lines" | "bytes" = "lines";
-	for (let i = 0; i < lines.length && i < maxLines; i += 1) {
-		const line = lines[i] ?? "";
-		const lineBytes = Buffer.byteLength(line, "utf8") + (i > 0 ? 1 : 0);
-		if (outputBytes + lineBytes > maxBytes) {
-			truncatedBy = "bytes";
-			break;
-		}
-		out.push(line);
-		outputBytes += lineBytes;
-	}
-	if (out.length >= maxLines && outputBytes <= maxBytes) truncatedBy = "lines";
-	const output = out.join("\n");
+function withClioDefaults(options: TruncationOptions): Required<TruncationOptions> {
 	return {
-		content: output,
-		truncated: true,
-		truncatedBy,
-		totalLines,
-		totalBytes,
-		outputLines: out.length,
-		outputBytes: Buffer.byteLength(output, "utf8"),
-		lastLinePartial: false,
-		firstLineExceedsLimit: false,
-		maxLines,
-		maxBytes,
+		maxLines: options.maxLines ?? DEFAULT_MAX_LINES,
+		maxBytes: options.maxBytes ?? DEFAULT_MAX_BYTES,
 	};
 }
 
-// Keep the tail of a UTF-8 string within a byte budget, cutting at a valid
-// character boundary. Used when the last line alone exceeds the byte cap.
-function truncateStringToBytesFromEnd(str: string, maxBytes: number): string {
-	const buf = Buffer.from(str, "utf8");
-	if (buf.length <= maxBytes) return str;
-	let start = buf.length - maxBytes;
-	while (start < buf.length && ((buf[start] ?? 0) & 0xc0) === 0x80) start += 1;
-	return buf.subarray(start).toString("utf8");
+export function truncateHead(content: string, options: TruncationOptions = {}): TruncationResult {
+	return truncatePiHead(content, withClioDefaults(options));
 }
 
-// Keep the LAST N lines / bytes (whichever cap is hit first). Suitable for
-// shell/build/test output where the failing assertion, compiler error, and
-// exit summary live at the end. Ported from pi's truncate.ts:168, including the
-// partial-last-line edge case: when the final line alone exceeds maxBytes, the
-// end of that line is kept and lastLinePartial is set.
 export function truncateTail(content: string, options: TruncationOptions = {}): TruncationResult {
-	const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
-	const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
-	const totalBytes = Buffer.byteLength(content, "utf8");
-	const lines = splitLinesForCounting(content);
-	const totalLines = lines.length;
-
-	if (totalLines <= maxLines && totalBytes <= maxBytes) {
-		return {
-			content,
-			truncated: false,
-			truncatedBy: null,
-			totalLines,
-			totalBytes,
-			outputLines: totalLines,
-			outputBytes: totalBytes,
-			lastLinePartial: false,
-			firstLineExceedsLimit: false,
-			maxLines,
-			maxBytes,
-		};
-	}
-
-	const out: string[] = [];
-	let outputBytes = 0;
-	let truncatedBy: "lines" | "bytes" = "lines";
-	let lastLinePartial = false;
-	for (let i = lines.length - 1; i >= 0 && out.length < maxLines; i -= 1) {
-		const line = lines[i] ?? "";
-		const lineBytes = Buffer.byteLength(line, "utf8") + (out.length > 0 ? 1 : 0);
-		if (outputBytes + lineBytes > maxBytes) {
-			truncatedBy = "bytes";
-			// The final line alone overflows the budget: keep its tail so the
-			// last bytes (the exit summary) are still shown, flagged partial.
-			if (out.length === 0) {
-				const truncatedLine = truncateStringToBytesFromEnd(line, maxBytes);
-				out.unshift(truncatedLine);
-				outputBytes = Buffer.byteLength(truncatedLine, "utf8");
-				lastLinePartial = true;
-			}
-			break;
-		}
-		out.unshift(line);
-		outputBytes += lineBytes;
-	}
-	if (out.length >= maxLines && outputBytes <= maxBytes) truncatedBy = "lines";
-	const output = out.join("\n");
-	return {
-		content: output,
-		truncated: true,
-		truncatedBy,
-		totalLines,
-		totalBytes,
-		outputLines: out.length,
-		outputBytes: Buffer.byteLength(output, "utf8"),
-		lastLinePartial,
-		firstLineExceedsLimit: false,
-		maxLines,
-		maxBytes,
-	};
-}
-
-export function truncateLine(
-	line: string,
-	maxChars: number = GREP_MAX_LINE_LENGTH,
-): { text: string; wasTruncated: boolean } {
-	if (line.length <= maxChars) return { text: line, wasTruncated: false };
-	return { text: `${line.slice(0, maxChars)}... [truncated]`, wasTruncated: true };
+	return truncatePiTail(content, withClioDefaults(options));
 }

package/src/tools/verify/frontend.ts

@@ -9,8 +9,10 @@ import { resolveReadPath } from "../path-utils.js";
 import type { ToolResult, ToolResultDetails } from "../registry.js";
 import { maxOutputArg, timeoutArg } from "../safe-exec.js";
 import { truncateUtf8 } from "../truncate-utf8.js";
+import { BROWSER_MODES } from "./surface.js";
+
+export { BROWSER_MODES } from "./surface.js";
 
-export const BROWSER_MODES = ["auto", "required", "off"] as const;
 type BrowserMode = (typeof BROWSER_MODES)[number];
 
 type CheckStatus = "pass" | "warn" | "fail" | "skip";

package/src/tools/verify/index.ts

@@ -1,10 +1,8 @@
-import { Type } from "typebox";
-import { ToolNames } from "../../core/tool-names.js";
 import { isVerificationScriptName } from "../../core/verification-scripts.js";
 import type { ToolResult, ToolSpec } from "../registry.js";
-import { stringEnum } from "../string-enum.js";
-import { BROWSER_MODES, runFrontendCheck } from "./frontend.js";
+import { runFrontendCheck } from "./frontend.js";
 import { listChecks, runScriptCheck, VERIFICATION_SCRIPT_FAMILY_HINT } from "./scripts.js";
+import { prepareVerifyArguments, verifyToolSurface } from "./surface.js";
 
 /**
  * The verify tool: one EXECUTE entry point for declared verification.
@@ -13,41 +11,8 @@ import { listChecks, runScriptCheck, VERIFICATION_SCRIPT_FAMILY_HINT } from "./s
  * path=<file>) validates an HTML/CSS/JS artifact without shell access.
  */
 
-/** Tolerate the weak-model shape of `args` sent as a JSON string. */
-function prepareVerifyArguments(args: Record<string, unknown>): Record<string, unknown> {
-	if (!args || typeof args !== "object" || Array.isArray(args)) return args;
-	const next: Record<string, unknown> = { ...args };
-	if (typeof next.args === "string") {
-		try {
-			const parsed = JSON.parse(next.args) as unknown;
-			if (Array.isArray(parsed)) next.args = parsed;
-		} catch {
-			// Leave the malformed string; runScriptCheck ignores non-arrays.
-		}
-	}
-	return next;
-}
-
 export const verifyTool: ToolSpec = {
-	name: ToolNames.Verify,
-	description:
-		'Run a declared verification check: no arguments lists checks, check=<package.json script> runs it, check="frontend" with path validates an HTML/CSS/JS artifact.',
-	parameters: Type.Object({
-		check: Type.Optional(
-			Type.String({
-				description: `Declared script name (${VERIFICATION_SCRIPT_FAMILY_HINT}) or "frontend". Omit to list available checks.`,
-			}),
-		),
-		path: Type.Optional(Type.String({ description: "check=frontend: artifact file under the workspace root." })),
-		args: Type.Optional(Type.Array(Type.String(), { description: "Extra arguments passed after --." })),
-		browser: Type.Optional(stringEnum(BROWSER_MODES, "check=frontend: headless browser mode (default auto).")),
-		cwd: Type.Optional(Type.String({ description: "Working directory." })),
-		timeout_ms: Type.Optional(Type.Number({ description: "Timeout in ms (default 120000)." })),
-		max_output_bytes: Type.Optional(Type.Number({ description: "Output cap in bytes (default 600000)." })),
-	}),
-	baseActionClass: "execute",
-	executionMode: "sequential",
-	prepareArguments: prepareVerifyArguments,
+	...verifyToolSurface,
 	async run(rawArgs, options): Promise<ToolResult> {
 		const args = prepareVerifyArguments(rawArgs);
 		const check = typeof args.check === "string" ? args.check.trim() : "";

package/src/tools/verify/surface.ts

@@ -0,0 +1,46 @@
+import { Type } from "typebox";
+import { ToolNames } from "../../core/tool-names.js";
+import { VERIFICATION_SCRIPT_FAMILY_HINT } from "../../core/verification-scripts.js";
+import { StringEnum } from "../../engine/ai.js";
+import type { ToolSurface } from "../lazy-tool.js";
+
+export const BROWSER_MODES = ["auto", "required", "off"] as const;
+
+/** Tolerate the weak-model shape of `args` sent as a JSON string. */
+export function prepareVerifyArguments(args: Record<string, unknown>): Record<string, unknown> {
+	if (!args || typeof args !== "object" || Array.isArray(args)) return args;
+	const next: Record<string, unknown> = { ...args };
+	if (typeof next.args === "string") {
+		try {
+			const parsed = JSON.parse(next.args) as unknown;
+			if (Array.isArray(parsed)) next.args = parsed;
+		} catch {
+			// Leave the malformed string; runScriptCheck ignores non-arrays.
+		}
+	}
+	return next;
+}
+
+export const verifyToolSurface = {
+	name: ToolNames.Verify,
+	description:
+		'Run a declared verification check: no arguments lists checks, check=<package.json script> runs it, check="frontend" with path validates an HTML/CSS/JS artifact.',
+	parameters: Type.Object({
+		check: Type.Optional(
+			Type.String({
+				description: `Declared script name (${VERIFICATION_SCRIPT_FAMILY_HINT}) or "frontend". Omit to list available checks.`,
+			}),
+		),
+		path: Type.Optional(Type.String({ description: "check=frontend: artifact file under the workspace root." })),
+		args: Type.Optional(Type.Array(Type.String(), { description: "Extra arguments passed after --." })),
+		browser: Type.Optional(
+			StringEnum(BROWSER_MODES, { description: "check=frontend: headless browser mode (default auto)." }),
+		),
+		cwd: Type.Optional(Type.String({ description: "Working directory." })),
+		timeout_ms: Type.Optional(Type.Number({ description: "Timeout in ms (default 120000)." })),
+		max_output_bytes: Type.Optional(Type.Number({ description: "Output cap in bytes (default 600000)." })),
+	}),
+	baseActionClass: "execute",
+	executionMode: "sequential",
+	prepareArguments: prepareVerifyArguments,
+} satisfies ToolSurface;

package/src/tools/web-fetch-surface.ts

@@ -0,0 +1,23 @@
+import { Type } from "typebox";
+import { ToolNames } from "../core/tool-names.js";
+import type { ToolSurface } from "./lazy-tool.js";
+
+export const webFetchToolSurface = {
+	name: ToolNames.WebFetch,
+	description: "Fetch an http(s) URL; HTML is cleaned and converted to Markdown. Non-2xx responses are errors.",
+	parameters: Type.Object({
+		url: Type.String({ description: "Fully-qualified http(s) URL." }),
+		method: Type.Optional(Type.String({ description: "HTTP method (default GET)." })),
+		headers: Type.Optional(Type.Record(Type.String(), Type.String(), { description: "Request headers." })),
+		body: Type.Optional(Type.String({ description: "Request body (POST/PUT)." })),
+		timeout_ms: Type.Optional(Type.Number({ description: "Timeout ms (default 30000)." })),
+		max_bytes: Type.Optional(Type.Number({ description: "Max bytes returned (default 600000)." })),
+		format: Type.Optional(
+			Type.String({
+				description: "auto (default: HTML is cleaned to Markdown, other content passes through) or raw (no conversion).",
+			}),
+		),
+	}),
+	baseActionClass: "read",
+	executionMode: "parallel",
+} satisfies ToolSurface;

package/src/tools/web-fetch.ts

@@ -1,8 +1,6 @@
-import { Type } from "typebox";
-import { fetch } from "undici";
-import { ToolNames } from "../core/tool-names.js";
 import type { ToolResult, ToolSpec } from "./registry.js";
 import { truncateUtf8 } from "./truncate-utf8.js";
+import { webFetchToolSurface } from "./web-fetch-surface.js";
 
 const DEFAULT_TIMEOUT_MS = 30_000;
 const DEFAULT_MAX_BYTES = 600_000;
@@ -627,23 +625,7 @@ function formatOutput(args: {
 }
 
 export const webFetchTool: ToolSpec = {
-	name: ToolNames.WebFetch,
-	description: "Fetch an http(s) URL; HTML is cleaned and converted to Markdown. Non-2xx responses are errors.",
-	parameters: Type.Object({
-		url: Type.String({ description: "Fully-qualified http(s) URL." }),
-		method: Type.Optional(Type.String({ description: "HTTP method (default GET)." })),
-		headers: Type.Optional(Type.Record(Type.String(), Type.String(), { description: "Request headers." })),
-		body: Type.Optional(Type.String({ description: "Request body (POST/PUT)." })),
-		timeout_ms: Type.Optional(Type.Number({ description: "Timeout ms (default 30000)." })),
-		max_bytes: Type.Optional(Type.Number({ description: "Max bytes returned (default 600000)." })),
-		format: Type.Optional(
-			Type.String({
-				description: "auto (default: HTML is cleaned to Markdown, other content passes through) or raw (no conversion).",
-			}),
-		),
-	}),
-	baseActionClass: "read",
-	executionMode: "parallel",
+	...webFetchToolSurface,
 	async run(args, options): Promise<ToolResult> {
 		const urlArg = typeof args.url === "string" ? args.url : null;
 		if (!urlArg) return { kind: "error", message: "web_fetch: missing url argument" };

package/src/tools/write.ts

@@ -2,6 +2,7 @@ import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { Type } from "typebox";
 import { ToolNames } from "../core/tool-names.js";
+import { generateDiffString } from "./edit-diff.js";
 import { withFileMutationQueue } from "./file-mutation-queue.js";
 import { resolveToCwd } from "./path-utils.js";
 import type { ToolResult, ToolSpec } from "./registry.js";
@@ -25,16 +26,20 @@ export const writeTool: ToolSpec = {
 		const filePath = resolveToCwd(pathArg);
 		try {
 			let previousEndedWithNewline = false;
+			let previousContent = "";
 			await withFileMutationQueue(filePath, async () => {
 				try {
-					previousEndedWithNewline = readFileSync(filePath, "utf8").endsWith("\n");
+					previousContent = readFileSync(filePath, "utf8");
+					previousEndedWithNewline = previousContent.endsWith("\n");
 				} catch {
+					previousContent = "";
 					previousEndedWithNewline = false;
 				}
 				mkdirSync(dirname(filePath), { recursive: true });
 				writeFileSync(filePath, content, "utf8");
 			});
 			const bytes = Buffer.byteLength(content, "utf8");
+			const diff = generateDiffString(previousContent, content).diff;
 			let output = `wrote ${bytes}B to ${pathArg}`;
 			if (previousEndedWithNewline && !content.endsWith("\n")) {
 				output += `\nnote: ${pathArg} no longer ends with a newline; the previous content did`;
@@ -43,7 +48,7 @@ export const writeTool: ToolSpec = {
 			// before it falls back to the length of the returned text. A write's
 			// text is a confirmation sentence, so without this the ledger printed
 			// the sentence's length as the file size.
-			return { kind: "ok", output, details: { paths: [filePath], observation: { shownBytes: bytes } } };
+			return { kind: "ok", output, details: { diff, paths: [filePath], observation: { shownBytes: bytes } } };
 		} catch (err) {
 			const msg = err instanceof Error ? err.message : String(err);
 			return { kind: "error", message: `write: ${msg}` };

package/src/worker/entry.ts

@@ -14,7 +14,32 @@
 // id is appended once the spec is parsed.
 process.title = "clio-coder-worker";
 
-import { disposeLmStudioClients } from "../engine/apis/lmstudio-native.js";
+import { AI_AGENT_NAME } from "../core/agent-environment.js";
+import { deleteInjectedCompileCacheFrom } from "../core/compile-cache.js";
+import {
+	setGitCommitAttributionEnabled,
+	withManagedGitCommitAttributionEnvironment,
+} from "../core/git-commit-attribution.js";
+
+process.env.AI_AGENT = AI_AGENT_NAME;
+
+// Consume the compile-cache pair the dispatcher injected for THIS entry's
+// module graph. Node read NODE_COMPILE_CACHE at bootstrap, before any of this
+// ran, so the worker's own cache stays enabled; deleting the pair here is what
+// keeps it out of every child this process spawns: bash tool commands, hooks,
+// and external runtime subprocesses (claude, antigravity) that would otherwise
+// inherit the unfiltered environment and write into Clio's cache.
+deleteInjectedCompileCacheFrom(process.env);
+
+// Marks this process, and every child a worker's own bash tool spawns, as
+// running inside a dispatched worker rather than the operator's interactive
+// session. `installSkillFromSource` reads this to stamp skill provenance with
+// who performed the install, so a skill a worker drops into a trusted root
+// does not read as operator-installed. Set unconditionally at both local and
+// remote launch, since neither transport otherwise leaves a uniform signal on
+// the worker's own environment.
+process.env.CLIO_CODER_WORKER_RUN = "1";
+
 import { setProtectedModelsProvider, setResidencyNoticeSink } from "../engine/apis/residency.js";
 import { startWorkerRun, type WorkerRunInput, workerProviderSupportsTools } from "../engine/worker-runtime.js";
 import { attestedToolSignature } from "../engine/worker-tools.js";
@@ -109,6 +134,19 @@ async function main(): Promise<number> {
 
 	const spec = await demux.readSpec();
 	process.title = `clio-coder-worker:${spec.agentId}`;
+	const attributionEnabled = spec.gitCommitAttribution ?? true;
+	setGitCommitAttributionEnabled(attributionEnabled);
+	const attribution = withManagedGitCommitAttributionEnvironment(process.env, {
+		cwd: process.cwd(),
+		enabled: attributionEnabled,
+	});
+	for (const key of Object.keys(process.env)) {
+		if (!(key in attribution.env)) Reflect.deleteProperty(process.env, key);
+	}
+	Object.assign(process.env, attribution.env);
+	if (attribution.diagnostic !== null) {
+		process.stderr.write(`[worker] commit attribution: ${attribution.diagnostic}\n`);
+	}
 	// The worker has no settings view of its own; the dispatcher copied the
 	// operator's configured model ids onto the spec so this process protects
 	// the same residents as the orchestrator.
@@ -239,7 +277,6 @@ async function main(): Promise<number> {
 		// Best-effort dispose of any LMStudioClient instances cached by the
 		// engine so we close their WebSocket sessions cleanly before the worker
 		// process exits.
-		await disposeLmStudioClients();
 	}
 }
 

package/src/worker/spec-contract.ts

@@ -37,6 +37,8 @@ export interface SerializedWorkerRuntimeDescriptor {
 	kind: RuntimeKind;
 	apiFamily: RuntimeApiFamily;
 	auth: RuntimeAuth;
+	/** Legacy or alternate ids that resolve to this runtime; absent when it has none. */
+	aliases?: ReadonlyArray<string>;
 }
 
 /** Immutable, admission-time snapshot of the parent session's hard blocks. */
@@ -121,6 +123,8 @@ interface WorkerSpecFields {
 	/** Skill names the agent recipe binds to this run; context(scope=skills) admits exactly these. */
 	agentSkills?: ReadonlyArray<string>;
 	trustProjectCompatRoots?: boolean;
+	/** Effective commit-attribution setting inherited from the dispatching session. */
+	gitCommitAttribution?: boolean;
 	/**
 	 * Dispatch-time tool profile that narrowed `allowedTools`. Carried so
 	 * black-box external CLI runtimes that cannot mediate per-tool calls can
@@ -195,7 +199,6 @@ const RUNTIME_API_FAMILIES = [
 	"bedrock-converse-stream",
 	"google-generative-ai",
 	"google-vertex",
-	"lmstudio-native",
 	"mistral-conversations",
 	"ollama-native",
 	"rerank-http",
@@ -247,6 +250,10 @@ export function serializeWorkerRuntimeDescriptor(runtime: RuntimeDescriptor): Se
 		kind: runtime.kind,
 		apiFamily: runtime.apiFamily,
 		auth: runtime.auth,
+		// Carried so the target check can recognize a configured runtime id that
+		// resolves to this runtime through an alias. Without them the contract has
+		// no way to tell a legacy spelling from a genuinely wrong runtime.
+		...(runtime.aliases !== undefined && runtime.aliases.length > 0 ? { aliases: [...runtime.aliases] } : {}),
 	};
 }
 
@@ -335,12 +342,21 @@ function validateProtectedModels(value: unknown): void {
 	});
 }
 
-function validateTarget(value: unknown, runtimeId: string): void {
+/**
+ * The configured target names a runtime by whatever id the operator wrote, which
+ * may be an alias the registry resolves to the canonical id. Comparing the two
+ * spellings literally rejected every dispatch to a target whose settings still
+ * said `lmstudio-native`, because the settings migration that rewrites it runs
+ * only under `clio-coder upgrade`. An alias is the same runtime, so it passes.
+ */
+function validateTarget(value: unknown, runtimeId: string, runtimeAliases: ReadonlyArray<string>): void {
 	const target = readRecord(value, "WorkerSpec.target");
 	const targetId = readString(target.id, "WorkerSpec.target.id");
 	const targetRuntime = readString(target.runtime, "WorkerSpec.target.runtime");
-	if (targetRuntime !== runtimeId) {
-		throw new Error(`WorkerSpec target runtime mismatch: target.runtime=${targetRuntime} runtimeId=${runtimeId}`);
+	if (targetRuntime !== runtimeId && !runtimeAliases.includes(targetRuntime)) {
+		throw new Error(
+			`WorkerSpec target runtime mismatch: target.runtime=${targetRuntime} runtimeId=${runtimeId}. Set the target's runtime to '${runtimeId}' in settings.yaml, or run 'clio-coder upgrade' to migrate a legacy runtime id.`,
+		);
 	}
 	if (targetId.length === 0) throw new Error("WorkerSpec.target.id must be a non-empty string");
 	readOptionalString(target, "url", "WorkerSpec.target");
@@ -545,6 +561,8 @@ export function parseWorkerSpec(value: unknown): WorkerSpec {
 	if (runtimeId !== runtimeRefId) {
 		throw new Error(`WorkerSpec runtime id mismatch: runtimeId=${runtimeId} runtime.id=${runtimeRefId}`);
 	}
+	const runtimeAliases =
+		runtime.aliases === undefined ? [] : readStringArray(runtime.aliases, "WorkerSpec.runtime.aliases");
 	const runtimeKind = readEnum(runtime.kind, "WorkerSpec.runtime.kind", RUNTIME_KINDS);
 	const runtimeApiFamily = readEnum(runtime.apiFamily, "WorkerSpec.runtime.apiFamily", RUNTIME_API_FAMILIES);
 	readEnum(runtime.auth, "WorkerSpec.runtime.auth", RUNTIME_AUTHS);
@@ -555,7 +573,7 @@ export function parseWorkerSpec(value: unknown): WorkerSpec {
 	readOptionalString(spec, "dynamicHash", "WorkerSpec");
 	readString(spec.agentId, "WorkerSpec.agentId");
 	readString(spec.task, "WorkerSpec.task");
-	validateTarget(spec.target, runtimeId);
+	validateTarget(spec.target, runtimeId, runtimeAliases);
 	readString(spec.wireModelId, "WorkerSpec.wireModelId");
 	readOptionalString(spec, "sessionId", "WorkerSpec");
 	readOptionalString(spec, "apiKey", "WorkerSpec");
@@ -595,6 +613,9 @@ export function parseWorkerSpec(value: unknown): WorkerSpec {
 	if (spec.trustProjectCompatRoots !== undefined && typeof spec.trustProjectCompatRoots !== "boolean") {
 		throw new Error("WorkerSpec.trustProjectCompatRoots must be a boolean");
 	}
+	if (spec.gitCommitAttribution !== undefined && typeof spec.gitCommitAttribution !== "boolean") {
+		throw new Error("WorkerSpec.gitCommitAttribution must be a boolean");
+	}
 	readOptionalEnum(spec, "toolProfile", "WorkerSpec", TOOL_PROFILE_NAMES);
 	readOptionalEnum(spec, "product", "WorkerSpec", WORKER_PRODUCTS);
 	if (