@iowarp/clio-coder 0.4.0 → 0.4.1

package/src/domains/mux/socket-client.ts

@@ -36,14 +36,18 @@ import {
 	MuxError,
 	type MuxEvent,
 	type MuxEventKind,
+	type MuxLayoutNode,
+	type MuxLayoutTree,
 	type MuxLog,
 	type MuxNotificationSound,
 	type MuxPane,
+	type MuxRect,
 	type MuxReportableAgentState,
 	MuxRequestTimeout,
 	type MuxServerInfo,
 	type MuxSnapshot,
 	type MuxTab,
+	type MuxTabGeometry,
 	type MuxWorktree,
 	type MuxWorktreeSource,
 	muxErrorKind,
@@ -192,8 +196,32 @@ export interface MuxClient {
 	/** Set the pane's operator-facing label. Available on herdr protocol 17. */
 	paneRename(paneId: string, label: string): Promise<void>;
 	paneClose(paneId: string): Promise<void>;
-	/** Pane ids sharing a tab with `paneId`, read off the tab's layout snapshot. */
-	paneLayout(paneId?: string): Promise<ReadonlyArray<string>>;
+	/**
+	 * Cell-precise geometry of the tab holding `paneId` (the server's focused
+	 * pane when omitted): outer area, pane rects, and live split ratios.
+	 */
+	paneLayout(paneId?: string): Promise<MuxTabGeometry>;
+	/**
+	 * Focus a pane. This switches the focused tab as well as the pane (verified
+	 * on 0.8.2), so it is only ever driven by an explicit "show me" request,
+	 * never by background bookkeeping.
+	 */
+	paneFocus(paneId: string): Promise<void>;
+	/** Zoom a pane. Zooming an unfocused pane steals focus; same rule as paneFocus. */
+	paneZoom(paneId: string, mode: "on" | "off" | "toggle"): Promise<{ changed: boolean; focusChanged: boolean }>;
+	/** Portable layout tree for a tab, or the tab holding `paneId`. */
+	layoutExport(request?: { tabId?: string; paneId?: string }): Promise<MuxLayoutTree>;
+	/**
+	 * Set one split's ratio, addressed by a boolean path from the root split
+	 * (`false` descends first, `true` second; `[]` is the root). Returns the
+	 * updated tree.
+	 */
+	layoutSetSplitRatio(request: {
+		tabId?: string;
+		paneId?: string;
+		path: ReadonlyArray<boolean>;
+		ratio: number;
+	}): Promise<MuxLayoutTree>;
 	worktreeList(request?: MuxWorktreeListRequest): Promise<MuxWorktreeListResult>;
 	worktreeCreate(request: MuxWorktreeCreateRequest): Promise<MuxWorktreeCreatedResult>;
 	worktreeOpen(request: MuxWorktreeOpenRequest): Promise<MuxWorktreeOpenedResult>;
@@ -410,8 +438,93 @@ function readSnapshot(value: unknown): MuxSnapshot {
 	};
 }
 
+function requireNumber(source: Record<string, unknown>, key: string, context: string): number {
+	const value = source[key];
+	if (typeof value !== "number") {
+		throw new MuxError("protocol", `mux ${context} response is missing number field ${key}`);
+	}
+	return value;
+}
+
+function readRect(value: unknown, context: string): MuxRect {
+	const source = asRecord(value);
+	if (!source) throw new MuxError("protocol", `mux ${context} rect is not an object`);
+	return {
+		x: requireNumber(source, "x", context),
+		y: requireNumber(source, "y", context),
+		width: requireNumber(source, "width", context),
+		height: requireNumber(source, "height", context),
+	};
+}
+
+function readSplitDirection(value: unknown, context: string): "right" | "down" {
+	if (value === "right" || value === "down") return value;
+	throw new MuxError("protocol", `mux ${context} split direction is not right/down`);
+}
+
+/** Parses a `PaneLayoutSnapshot`: the shape `pane.layout` and `layout_updated` both carry. */
+function readTabGeometry(value: unknown): MuxTabGeometry {
+	const source = asRecord(value);
+	if (!source) throw new MuxError("protocol", "mux layout snapshot is not an object");
+	return {
+		workspaceId: requireString(source, "workspace_id", "layout"),
+		tabId: requireString(source, "tab_id", "layout"),
+		zoomed: source.zoomed === true,
+		area: readRect(source.area, "layout"),
+		focusedPaneId: optionalString(source, "focused_pane_id"),
+		panes: readArray(source, "panes").map((entry) => {
+			const pane = asRecord(entry);
+			if (!pane) throw new MuxError("protocol", "mux layout pane entry is not an object");
+			return {
+				paneId: requireString(pane, "pane_id", "layout pane"),
+				focused: pane.focused === true,
+				rect: readRect(pane.rect, "layout pane"),
+			};
+		}),
+		splits: readArray(source, "splits").map((entry) => {
+			const split = asRecord(entry);
+			if (!split) throw new MuxError("protocol", "mux layout split entry is not an object");
+			return {
+				direction: readSplitDirection(split.direction, "layout"),
+				ratio: requireNumber(split, "ratio", "layout split"),
+				rect: readRect(split.rect, "layout split"),
+			};
+		}),
+	};
+}
+
+function readLayoutNode(value: unknown): MuxLayoutNode {
+	const source = asRecord(value);
+	if (!source) throw new MuxError("protocol", "mux layout node is not an object");
+	if (source.type === "pane") {
+		return { type: "pane", paneId: optionalString(source, "pane_id"), label: optionalString(source, "label") };
+	}
+	if (source.type === "split") {
+		return {
+			type: "split",
+			direction: readSplitDirection(source.direction, "layout tree"),
+			ratio: requireNumber(source, "ratio", "layout tree split"),
+			first: readLayoutNode(source.first),
+			second: readLayoutNode(source.second),
+		};
+	}
+	throw new MuxError("protocol", "mux layout node has an unknown type");
+}
+
+function readLayoutTree(value: unknown): MuxLayoutTree {
+	const source = asRecord(value);
+	if (!source) throw new MuxError("protocol", "mux layout tree is not an object");
+	return {
+		workspaceId: requireString(source, "workspace_id", "layout tree"),
+		tabId: requireString(source, "tab_id", "layout tree"),
+		zoomed: source.zoomed === true,
+		focusedPaneId: optionalString(source, "focused_pane_id"),
+		root: readLayoutNode(source.root),
+	};
+}
+
 /** herdr names lifecycle event kinds with underscores on the wire and dots in subscriptions. */
-const EVENT_KIND_BY_WIRE: Readonly<Record<string, MuxEventKind>> = {
+const PANE_LEAVE_KIND_BY_WIRE: Readonly<Record<string, "pane.closed" | "pane.exited">> = {
 	pane_closed: "pane.closed",
 	pane_exited: "pane.exited",
 };
@@ -419,14 +532,37 @@ const EVENT_KIND_BY_WIRE: Readonly<Record<string, MuxEventKind>> = {
 function readEvent(line: Record<string, unknown>): MuxEvent | null {
 	const wireKind = line.event;
 	if (typeof wireKind !== "string") return null;
-	const kind = EVENT_KIND_BY_WIRE[wireKind];
-	if (!kind) return null;
 	const data = asRecord(line.data);
 	if (!data) return null;
-	const paneId = data.pane_id;
-	const workspaceId = data.workspace_id;
-	if (typeof paneId !== "string" || typeof workspaceId !== "string") return null;
-	return { kind, paneId, workspaceId };
+	const leaveKind = PANE_LEAVE_KIND_BY_WIRE[wireKind];
+	if (leaveKind) {
+		const paneId = data.pane_id;
+		const workspaceId = data.workspace_id;
+		if (typeof paneId !== "string" || typeof workspaceId !== "string") return null;
+		return { kind: leaveKind, paneId, workspaceId };
+	}
+	if (wireKind === "pane_moved") {
+		// The move rewrites the pane id; the payload carries the new pane record
+		// plus the id it replaced, and consumers continue from the new one.
+		const pane = asRecord(data.pane);
+		const previousPaneId = data.previous_pane_id;
+		if (!pane || typeof previousPaneId !== "string") return null;
+		const paneId = pane.pane_id;
+		const tabId = pane.tab_id;
+		const workspaceId = pane.workspace_id;
+		if (typeof paneId !== "string" || typeof tabId !== "string" || typeof workspaceId !== "string") return null;
+		return { kind: "pane.moved", paneId, previousPaneId, tabId, workspaceId };
+	}
+	if (wireKind === "layout_updated") {
+		// The push already carries the full tab geometry, so a consumer never
+		// has to answer a layout event with a layout request.
+		try {
+			return { kind: "layout.updated", geometry: readTabGeometry(data.layout) };
+		} catch {
+			return null;
+		}
+	}
+	return null;
 }
 
 /** Drops undefined entries so an optional field is absent rather than `null` on the wire. */
@@ -693,17 +829,29 @@ export function createMuxClient(options: MuxClientOptions): MuxClient {
 		async paneClose(paneId: string): Promise<void> {
 			await call("pane.close", { pane_id: paneId });
 		},
-		async paneLayout(paneId?: string): Promise<ReadonlyArray<string>> {
+		async paneLayout(paneId?: string): Promise<MuxTabGeometry> {
 			const result = await callObject("pane.layout", params({ pane_id: paneId }));
-			const layout = asRecord(result.layout);
-			if (!layout) throw new MuxError("protocol", "mux pane.layout returned no layout");
-			const ids: string[] = [];
-			for (const entry of readArray(layout, "panes")) {
-				const pane = asRecord(entry);
-				const id = pane ? pane.pane_id : undefined;
-				if (typeof id === "string") ids.push(id);
-			}
-			return ids;
+			return readTabGeometry(result.layout);
+		},
+		async paneFocus(paneId: string): Promise<void> {
+			await call("pane.focus", { pane_id: paneId });
+		},
+		async paneZoom(paneId: string, mode: "on" | "off" | "toggle"): Promise<{ changed: boolean; focusChanged: boolean }> {
+			const result = await callObject("pane.zoom", { pane_id: paneId, mode });
+			const zoom = asRecord(result.zoom);
+			if (!zoom) throw new MuxError("protocol", "mux pane.zoom returned no zoom result");
+			return { changed: zoom.changed === true, focusChanged: zoom.focus_changed === true };
+		},
+		async layoutExport(request = {}): Promise<MuxLayoutTree> {
+			const result = await callObject("layout.export", params({ tab_id: request.tabId, pane_id: request.paneId }));
+			return readLayoutTree(result.layout);
+		},
+		async layoutSetSplitRatio(request): Promise<MuxLayoutTree> {
+			const result = await callObject(
+				"layout.set_split_ratio",
+				params({ tab_id: request.tabId, pane_id: request.paneId, path: [...request.path], ratio: request.ratio }),
+			);
+			return readLayoutTree(result.layout);
 		},
 		async worktreeList(request = {}): Promise<MuxWorktreeListResult> {
 			const result = await callObject("worktree.list", params({ workspace_id: request.workspaceId, cwd: request.cwd }));

package/src/domains/mux/types.ts

@@ -97,14 +97,57 @@ export interface MuxSnapshot {
 	tabs: ReadonlyArray<MuxTab>;
 }
 
-/** Lifecycle event kinds Phase 1 subscribes to. */
-export type MuxEventKind = "pane.closed" | "pane.exited";
+/** Lifecycle event kinds the pane layer can subscribe to. */
+export type MuxEventKind = "pane.closed" | "pane.exited" | "pane.moved" | "layout.updated";
 
-/** One pushed lifecycle event. */
-export interface MuxEvent {
-	kind: MuxEventKind;
-	paneId: string;
+/**
+ * One pushed lifecycle event. A discriminated union because the payloads
+ * differ: pane leave events carry the pane, a move carries the id rewrite
+ * herdr performs, and a layout update carries the whole tab geometry so a
+ * consumer does not have to turn around and fetch what the push already said.
+ */
+export type MuxEvent =
+	| { kind: "pane.closed" | "pane.exited"; paneId: string; workspaceId: string }
+	| { kind: "pane.moved"; paneId: string; previousPaneId: string; tabId: string; workspaceId: string }
+	| { kind: "layout.updated"; geometry: MuxTabGeometry };
+
+/** One rectangle in terminal cells, as herdr's layout snapshots report them. */
+export interface MuxRect {
+	x: number;
+	y: number;
+	width: number;
+	height: number;
+}
+
+/**
+ * Cell-precise geometry of one tab: the outer area, every pane's rect, and
+ * every split with its live ratio. This is what dock sizing converges on.
+ */
+export interface MuxTabGeometry {
+	workspaceId: string;
+	tabId: string;
+	zoomed: boolean;
+	area: MuxRect;
+	focusedPaneId: string | null;
+	panes: ReadonlyArray<{ paneId: string; focused: boolean; rect: MuxRect }>;
+	splits: ReadonlyArray<{ direction: "right" | "down"; ratio: number; rect: MuxRect }>;
+}
+
+/**
+ * One node of a portable tab layout tree, as `layout.export` describes it.
+ * Split ratio is the share of the axis the `first` child keeps.
+ */
+export type MuxLayoutNode =
+	| { type: "pane"; paneId: string | null; label: string | null }
+	| { type: "split"; direction: "right" | "down"; ratio: number; first: MuxLayoutNode; second: MuxLayoutNode };
+
+/** A whole tab's portable layout tree. */
+export interface MuxLayoutTree {
 	workspaceId: string;
+	tabId: string;
+	zoomed: boolean;
+	focusedPaneId: string | null;
+	root: MuxLayoutNode;
 }
 
 /** Where Clio's own pane lives, read from the herdr environment. */

package/src/domains/mux/yazi/event-stream.ts

@@ -3,6 +3,8 @@ import { StringDecoder } from "node:string_decoder";
 
 export const YAZI_STREAM_POLL_MS = 250;
 export const YAZI_STREAM_MAX_BYTES = 1024 * 1024;
+export const YAZI_PICK_EVENT = "clio-coder-pick";
+export const LEGACY_YAZI_PICK_EVENT = "clio-pick";
 
 export interface YaziCdEvent {
 	kind: "cd";
@@ -13,7 +15,7 @@ export interface YaziCdEvent {
 }
 
 export interface YaziPickEvent {
-	kind: "clio-pick";
+	kind: typeof YAZI_PICK_EVENT;
 	receiver: string;
 	sender: string;
 	values: ReadonlyArray<string>;
@@ -61,7 +63,7 @@ export function parseYaziEventLine(line: string): YaziEvent | null {
 	const third = second < 0 ? -1 : line.indexOf(",", second + 1);
 	if (first <= 0 || second <= first + 1 || third <= second + 1) return null;
 	const kind = line.slice(0, first);
-	if (kind !== "cd" && kind !== "clio-pick") return null;
+	if (kind !== "cd" && kind !== YAZI_PICK_EVENT && kind !== LEGACY_YAZI_PICK_EVENT) return null;
 	const receiver = line.slice(first + 1, second);
 	const sender = line.slice(second + 1, third);
 	try {
@@ -73,7 +75,7 @@ export function parseYaziEventLine(line: string): YaziEvent | null {
 			return { kind, receiver, sender, tab: String(tab), cwd: body.url };
 		}
 		if (!Array.isArray(body) || !body.every((value) => typeof value === "string")) return null;
-		return { kind, receiver, sender, values: body };
+		return { kind: YAZI_PICK_EVENT, receiver, sender, values: body };
 	} catch {
 		return null;
 	}
@@ -152,7 +154,7 @@ export function createYaziEventStream(options: YaziEventStreamOptions): YaziEven
 				const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
 				if (line.length === 0) continue;
 				const kind = line.slice(0, line.indexOf(","));
-				if (kind !== "cd" && kind !== "clio-pick") continue;
+				if (kind !== "cd" && kind !== YAZI_PICK_EVENT && kind !== LEGACY_YAZI_PICK_EVENT) continue;
 				const event = parseYaziEventLine(line);
 				if (!event) {
 					state.malformedLines += 1;

package/src/domains/mux/yazi/profile.ts

@@ -119,7 +119,7 @@ function shellQuote(value: string): string {
 
 /** Render the one Clio key chord, with an absolute `ya` path for vendored installs. */
 export function renderYaziKeymap(yaPath: string): string {
-	const command = `shell -- ${shellQuote(yaPath)} pub-to "$YAZI_ID" clio-pick --list "$CLIO_YAZI_PICK_TOKEN" %s`;
+	const command = `shell -- ${shellQuote(yaPath)} pub-to "$YAZI_ID" clio-coder-pick --list "$CLIO_CODER_YAZI_PICK_TOKEN" %s`;
 	return `# Generated by Clio Coder. Changes are replaced when the managed profile regenerates.
 
 [[mgr.prepend_keymap]]

package/src/domains/mux/yazi/session.ts

@@ -2,12 +2,20 @@ import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { namingCompatibilityEnvironment } from "../../../core/naming-compat.js";
 import { clioCacheDir } from "../../../core/xdg.js";
 import { findPinnedTool } from "../../toolchain/registry.js";
 import { describeResolution, resolveToolBinary, toolStatus } from "../../toolchain/resolve.js";
 import type { MuxContract } from "../contract.js";
 import type { MuxPaneRef } from "../types.js";
-import { createYaziEventStream, YAZI_STREAM_POLL_MS, type YaziEvent, type YaziEventStream } from "./event-stream.js";
+import {
+	createYaziEventStream,
+	LEGACY_YAZI_PICK_EVENT,
+	YAZI_PICK_EVENT,
+	YAZI_STREAM_POLL_MS,
+	type YaziEvent,
+	type YaziEventStream,
+} from "./event-stream.js";
 import { ensureYaziProfile, type YaziProfile, yaziProfileDir } from "./profile.js";
 
 export type YaziSessionMode = "companion" | "chooser";
@@ -55,6 +63,11 @@ export interface YaziSessionOptions {
 	mode: YaziSessionMode;
 	profileMode: YaziProfileMode;
 	cwd: string;
+	/**
+	 * Files-dock share of the height. Set by the interactive bridge from
+	 * `interface.panes.files.ratio`; absent it, the dock spec's default governs.
+	 */
+	dockShare?: number;
 	onEvent: (event: YaziEvent) => void;
 	onChooser: (result: YaziChooserResult) => void;
 	onStopped?: (reason: string) => void;
@@ -130,13 +143,19 @@ export async function createYaziSession(options: YaziSessionOptions): Promise<Ya
 	const token = options.mode === "companion" ? (options.pickToken ?? randomUUID()) : null;
 	const env: Record<string, string> = {
 		...(managedProfile ? { YAZI_CONFIG_HOME: managedProfile.dir } : {}),
-		...(token ? { CLIO_YAZI_PICK_TOKEN: token } : {}),
+		...(token ? namingCompatibilityEnvironment("CLIO_CODER_YAZI_PICK_TOKEN", "CLIO_YAZI_PICK_TOKEN", token) : {}),
 	};
 	let argv: ReadonlyArray<string>;
 	let stdoutPath: string | undefined;
 	if (options.mode === "companion") {
 		writeFileSync(streamPath, "");
-		argv = [binaries.yaziPath, "--local-events", "cd,clio-pick", "--remote-events", "clio-pick"];
+		argv = [
+			binaries.yaziPath,
+			"--local-events",
+			`cd,${YAZI_PICK_EVENT},${LEGACY_YAZI_PICK_EVENT}`,
+			"--remote-events",
+			`${YAZI_PICK_EVENT},${LEGACY_YAZI_PICK_EVENT}`,
+		];
 		stdoutPath = streamPath;
 	} else {
 		writeFileSync(chooserPath, "");
@@ -148,6 +167,10 @@ export async function createYaziSession(options: YaziSessionOptions): Promise<Ya
 		argv,
 		cwd: options.cwd,
 		label: "yazi",
+		// The files dock: split down from the anchor at the configured share.
+		// Degrades to a plain split inside the contract when the layout tier is
+		// absent.
+		dock: { slot: "files", ...(options.dockShare === undefined ? {} : { share: options.dockShare }) },
 		...(Object.keys(env).length > 0 ? { env } : {}),
 		...(stdoutPath ? { stdoutPath } : {}),
 	});

package/src/domains/observability/extension.ts

@@ -96,7 +96,7 @@ async function buildAndIndexEvidence(
 		});
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
-		process.stderr.write(`[clio:evidence] auto-build failed for run ${runId}: ${message}\n`);
+		process.stderr.write(`[clio-coder:evidence] auto-build failed for run ${runId}: ${message}\n`);
 		hooks.onFailed(runId, message);
 	}
 }

package/src/domains/observability/out-of-turn-usage.ts

@@ -130,7 +130,7 @@ export function appendOutOfTurnUsageRow(stateDir: string, row: OutOfTurnUsageRow
 			closeSync(fd);
 		}
 	} catch (error) {
-		process.stderr.write(`[clio:usage] out-of-turn usage row not written: ${messageOf(error)}\n`);
+		process.stderr.write(`[clio-coder:usage] out-of-turn usage row not written: ${messageOf(error)}\n`);
 		return;
 	}
 	appendsSinceBoundCheck += 1;
@@ -139,7 +139,7 @@ export function appendOutOfTurnUsageRow(stateDir: string, row: OutOfTurnUsageRow
 	try {
 		boundOutOfTurnUsageFile(path);
 	} catch (error) {
-		process.stderr.write(`[clio:usage] out-of-turn usage ring not bounded: ${messageOf(error)}\n`);
+		process.stderr.write(`[clio-coder:usage] out-of-turn usage ring not bounded: ${messageOf(error)}\n`);
 	}
 }
 

package/src/domains/observability/projection.ts

@@ -167,7 +167,7 @@ export function createObservabilityProjection(bus: SafeEventBus, deps: Projectio
 				listener(snapshot);
 			} catch (error) {
 				const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
-				console.error(`[clio:observability] projection listener crashed: ${message}`);
+				console.error(`[clio-coder:observability] projection listener crashed: ${message}`);
 			}
 		}
 	}

package/src/domains/observability/trace-store.ts

@@ -19,6 +19,7 @@ import type {
 	DispatchProgressPayload,
 	DispatchStartedPayload,
 } from "../../core/bus-events.js";
+import { normalizeClioCoderEventType } from "../../core/naming-events.js";
 import { processAlive, processBirthToken } from "../../core/process-identity.js";
 import { createRedactionTally, redactSecretsText } from "../evidence/redact.js";
 
@@ -110,7 +111,7 @@ function requireSqlite(): DatabaseSyncConstructor {
  * Exported for the contract test, which drives it with a load that emits both
  * warnings; production has exactly one caller.
  */
-export function loadWithSqliteWarningSuppressed<T>(load: () => T): T {
+function loadWithSqliteWarningSuppressed<T>(load: () => T): T {
 	if (warningTracingRequested()) return load();
 	const emitWarning = process.emitWarning;
 	const forward = emitWarning.bind(process) as (...args: unknown[]) => void;
@@ -1201,7 +1202,7 @@ export class TraceReader {
 	}
 
 	events(runId: string, afterRowid = 0, limit = TRACE_EVENT_POLL_LIMIT): TraceEventRow[] {
-		return this.db
+		const rows = this.db
 			.prepare(`SELECT rowid, event_id, run_id, phase_id, parent_id, type, name, payload_json,
         tokens, started_at, ended_at FROM events
         WHERE run_id = ? AND rowid > ? ORDER BY rowid LIMIT ?`)
@@ -1210,6 +1211,7 @@ export class TraceReader {
 				Math.max(0, Math.trunc(afterRowid)),
 				clampInt(limit, 1, TRACE_EVENT_POLL_LIMIT),
 			) as unknown as TraceEventRow[];
+		return rows.map((row) => ({ ...row, type: normalizeClioCoderEventType(row.type) }));
 	}
 
 	/**
@@ -1221,9 +1223,17 @@ export class TraceReader {
 	 * on the way to counting them.
 	 */
 	eventKindCounts(runId: string): Array<{ type: string; count: number }> {
-		return this.db
+		const rows = this.db
 			.prepare("SELECT type, COUNT(*) AS count FROM events WHERE run_id=? GROUP BY type ORDER BY count DESC, type")
 			.all(runId) as unknown as Array<{ type: string; count: number }>;
+		const counts = new Map<string, number>();
+		for (const row of rows) {
+			const type = normalizeClioCoderEventType(row.type);
+			counts.set(type, (counts.get(type) ?? 0) + row.count);
+		}
+		return [...counts]
+			.map(([type, count]) => ({ type, count }))
+			.sort((left, right) => right.count - left.count || left.type.localeCompare(right.type));
 	}
 
 	/** Total events and the wall span they cover, without reading one of them. */
@@ -1273,7 +1283,7 @@ export class TraceReader {
 	}
 
 	select(sql: string): Record<string, SQLInputValue>[] {
-		assertSelectOnly(sql);
+		assertTraceSelectOnly(sql);
 		return this.db.prepare(sql).all() as Record<string, SQLInputValue>[];
 	}
 }
@@ -1301,7 +1311,7 @@ export function createDispatchTraceMirror(
 	path: string,
 	options: { warn?: (message: string) => void; now?: () => string } = {},
 ): DispatchTraceMirror {
-	const warn = options.warn ?? ((message: string) => process.stderr.write(`[clio:trace] ${message}\n`));
+	const warn = options.warn ?? ((message: string) => process.stderr.write(`[clio-coder:trace] ${message}\n`));
 	const now = options.now ?? (() => new Date().toISOString());
 	let store: TraceStore | null = null;
 	let chain: Promise<void> = Promise.resolve();
@@ -1408,7 +1418,7 @@ function recordProgress(
 ): void {
 	if (!isRecord(payload.event)) return;
 	const event = payload.event;
-	const type = typeof event.type === "string" ? event.type : "progress";
+	const type = typeof event.type === "string" ? normalizeClioCoderEventType(event.type) : "progress";
 	const toolCallId = stringValue(event.toolCallId) ?? stringValue(event.tool_call_id);
 	if (
 		type === "message_end" &&
@@ -1442,7 +1452,7 @@ function recordProgress(
 			});
 		}
 	}
-	if ((type === "tool_execution_start" || type === "clio_tool_start") && toolCallId !== null) {
+	if ((type === "tool_execution_start" || type === "clio_coder_tool_start") && toolCallId !== null) {
 		starts.set(`${payload.runId}:${toolCallId}`, {
 			toolCallId,
 			tool: stringValue(event.toolName) ?? stringValue(event.tool) ?? "tool",
@@ -1451,7 +1461,7 @@ function recordProgress(
 		});
 		return;
 	}
-	if ((type === "tool_execution_end" || type === "clio_tool_finish") && toolCallId !== null) {
+	if ((type === "tool_execution_end" || type === "clio_coder_tool_finish") && toolCallId !== null) {
 		const key = `${payload.runId}:${toolCallId}`;
 		const start = starts.get(key);
 		// One clock frame per row. The worker measures `durationMs` on its own
@@ -1537,12 +1547,12 @@ function recordFailure(store: TraceStore, input: DispatchFailedPayload, at: stri
 function isCriticalTraceEvent(channel: string, raw: unknown): boolean {
 	if (channel !== "dispatch.progress") return true;
 	if (!isRecord(raw) || !isRecord(raw.event)) return false;
-	const type = raw.event.type;
+	const type = typeof raw.event.type === "string" ? normalizeClioCoderEventType(raw.event.type) : raw.event.type;
 	return (
 		type === "tool_execution_start" ||
 		type === "tool_execution_end" ||
-		type === "clio_tool_start" ||
-		type === "clio_tool_finish" ||
+		type === "clio_coder_tool_start" ||
+		type === "clio_coder_tool_finish" ||
 		type === "message_end" ||
 		type === "attempt_start"
 	);
@@ -1659,7 +1669,7 @@ function sha256(value: string): string {
 	return createHash("sha256").update(value, "utf8").digest("hex");
 }
 
-function assertSelectOnly(sql: string): void {
+export function assertTraceSelectOnly(sql: string): void {
 	const trimmed = sql.trim();
 	if (!/^(SELECT|WITH)\b/i.test(trimmed)) throw new Error("trace sql accepts SELECT or read-only WITH queries only");
 	if (trimmed.includes(";")) throw new Error("trace sql accepts exactly one statement");

package/src/domains/prompts/compiler.ts

@@ -180,7 +180,7 @@ function lookupFragment(table: FragmentTable, id: string, role: string): LoadedF
  * section and the dispatch worker safety-posture message must describe the
  * same enforced behavior, so neither side duplicates this switch.
  */
-export function safetyOneLiner(level: string): string {
+function safetyOneLiner(level: string): string {
 	switch (level) {
 		case "read-only":
 			return "inspect and answer; mutating calls are auto-denied, so propose changes instead.";
@@ -653,7 +653,7 @@ export function compileWorker(table: FragmentTable, inputs: WorkerPromptInputs):
 	if (inputs.hasBoundSkills && !inputs.hasCanonicalContext) {
 		throw new Error("prompts/compiler: bound skills require canonical context in the final attached tool surface");
 	}
-	const identity = lookupFragment(table, "identity.clio-worker", "worker identity");
+	const identity = lookupFragment(table, "identity.clio-coder-worker", "worker identity");
 	const operatingContract = lookupFragment(table, "operating.contract", "operating contract");
 	const workerContract = lookupFragment(table, "operating.worker", "worker contract");
 	const safety = lookupFragment(table, `safety.${inputs.autonomy}`, "safety");

package/src/domains/prompts/extension.ts

@@ -62,7 +62,7 @@ export function createPromptsBundle(
 			table = loadFragments();
 		} catch (err) {
 			const msg = err instanceof Error ? err.message : String(err);
-			process.stderr.write(`[clio:prompts] reload failed: ${msg}\n`);
+			process.stderr.write(`[clio-coder:prompts] reload failed: ${msg}\n`);
 		}
 	}
 
@@ -81,7 +81,7 @@ export function createPromptsBundle(
 			}
 			const configContract = config();
 			const settings: Readonly<ClioSettings> | undefined = configContract?.get();
-			const safety = input.autonomy ?? settings?.autonomy ?? "auto-edit";
+			const safety = input.autonomy ?? settings?.safety.autonomy ?? "auto-edit";
 			const cwd = input.cwd ?? process.cwd();
 			let contextFiles = "";
 			let projectPreload: ProjectPreloadClass | null = null;
@@ -147,7 +147,7 @@ export function createPromptsBundle(
 				table = loadFragments();
 			} catch (err) {
 				const msg = err instanceof Error ? err.message : String(err);
-				process.stderr.write(`[clio:prompts] initial load failed: ${msg}\n`);
+				process.stderr.write(`[clio-coder:prompts] initial load failed: ${msg}\n`);
 				table = { byId: new Map(), rootDir: "" };
 			}
 			unsubscribeHotReload = context.bus.on(BusChannels.ConfigHotReload, (payload: unknown) => {

package/src/domains/prompts/fragments/identity/clio-worker.md

@@ -1,5 +1,5 @@
 ---
-id: identity.clio-worker
+id: identity.clio-coder-worker
 version: 1
 description: Identity for a bounded Clio fleet worker
 ---