@iowarp/clio-coder 0.4.0 → 0.4.1

package/src/tools/context/index.ts

@@ -1,7 +1,13 @@
 import { type Dirent, readdirSync } from "node:fs";
 import path from "node:path";
 import type { ContextRecalledPayload } from "../../core/bus-events.js";
-import { SKILL_SUGGESTION_ANCHOR } from "../../core/skill-activation.js";
+import {
+	SKILL_INSTALL_OFFER_OPTION_NEVER,
+	SKILL_INSTALL_OFFER_OPTION_NOT_NOW,
+	SKILL_INSTALL_OFFER_OPTION_PROJECT,
+	SKILL_INSTALL_OFFER_OPTION_USER,
+	SKILL_SUGGESTION_ANCHOR,
+} from "../../core/skill-activation.js";
 import { ToolNames } from "../../core/tool-names.js";
 import { foldWorkingSet } from "../../domains/context/working-set/fold.js";
 import {
@@ -289,6 +295,14 @@ function renderSkillsList(
 		"",
 		`If one skill above matches the current task, begin your reply with the line \`${SKILL_SUGGESTION_ANCHOR}\` (a comma-separated sequence, in order, when several compose), then continue the task in the same turn without it; only the operator can run it. If none match, do not mention skills.`,
 	);
+	if (marketplace.length > 0) {
+		// The offer protocol mirrors the marketplace-offer middleware: fixed
+		// option labels so the harness recognizes the answer, and the model
+		// never performs an install itself.
+		lines.push(
+			`When no installed skill serves the task but a marketplace skill above genuinely does, you may instead ask the operator with ask_user (mode=single_question, header "Install skill") whether to install it, offering exactly: "${SKILL_INSTALL_OFFER_OPTION_PROJECT}", "${SKILL_INSTALL_OFFER_OPTION_USER}", "${SKILL_INSTALL_OFFER_OPTION_NOT_NOW}", "${SKILL_INSTALL_OFFER_OPTION_NEVER}". The harness handles the answer and any install; never install or load a skill yourself.`,
+		);
+	}
 	return lines.join("\n");
 }
 

package/src/tools/dispatch-admission.ts

@@ -456,10 +456,12 @@ export function createDispatchAdmissionController(deps: DispatchToolDeps): Dispa
 				return shapeRejection(args, "dispatch: apply_winner must be an options object");
 			}
 			const branch = stringArg(args.apply_winner, "branch");
-			const match = branch ? /^clio\/compete\/([A-Za-z0-9][A-Za-z0-9._-]{0,127})\/([1-9]\d*)$/.exec(branch) : null;
+			const match = branch
+				? /^(?:clio-coder|clio)\/compete\/([A-Za-z0-9][A-Za-z0-9._-]{0,127})\/([1-9]\d*)$/.exec(branch)
+				: null;
 			if (branch === undefined) return shapeRejection(args, "dispatch: apply_winner.branch is required");
 			if (match === null) {
-				return shapeRejection(args, "dispatch: apply_winner.branch must be a clio/compete/<group>/<n> branch");
+				return shapeRejection(args, "dispatch: apply_winner.branch must be a clio-coder/compete/<group>/<n> branch");
 			}
 			try {
 				const cwd = resolve(stringArg(args.apply_winner, "cwd") ?? process.cwd());

package/src/tools/dispatch-arguments.ts

@@ -62,7 +62,7 @@ const AUTO_BASELINE_FALLBACK_AGENT_ID = "scout";
  * the mapped recipe is not present in this install, so a trimmed recipe set
  * can never produce a dispatch against an agent id that does not resolve.
  */
-export function autoBaselineAgentId(task: string, hasAgent?: (id: string) => boolean): string {
+function autoBaselineAgentId(task: string, hasAgent?: (id: string) => boolean): string {
 	const mapped = AUTO_BASELINE_BY_TASK_TYPE[classifyAgentTask(task).taskType] ?? AUTO_BASELINE_FALLBACK_AGENT_ID;
 	if (hasAgent === undefined) return mapped;
 	if (hasAgent(mapped)) return mapped;

package/src/tools/dispatch-plan.ts

@@ -900,14 +900,3 @@ export function describeDispatchPlan(rawArgs: Record<string, unknown> | undefine
 		...(confirmation !== undefined ? { confirmation } : {}),
 	};
 }
-
-/** Registry-side predicate: does this dispatch call require plan approval at supervised levels? */
-export function isPlanScaleDispatchArgs(rawArgs: Record<string, unknown> | undefined): boolean {
-	try {
-		return describeDispatchPlan(rawArgs).planScale;
-	} catch {
-		// A malformed call fails closed as NOT plan-scale; the dispatch tool's
-		// own validation rejects it with a real error message.
-		return false;
-	}
-}

package/src/tools/dispatch-run-events.ts

@@ -1,5 +1,6 @@
 import { BusChannels } from "../core/bus-events.js";
 import type { SafeEventBus } from "../core/event-bus.js";
+import { normalizeClioCoderEventRecord, normalizeClioCoderEventType } from "../core/naming-events.js";
 import type { DispatchContract } from "../domains/dispatch/contract.js";
 import { durableAssistantTextFromEvent } from "../domains/dispatch/event-pump.js";
 import { defaultRunEventJournal, type RunEventJournalSink } from "../domains/dispatch/run-event-journal.js";
@@ -61,18 +62,19 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 }
 
 function eventDetail(event: unknown): string | undefined {
-	const text = assistantTextFromEvent(event);
+	const normalized = isRecord(event) ? normalizeClioCoderEventRecord(event) : event;
+	const text = assistantTextFromEvent(normalized);
 	if (text.length > 0) return truncateUtf8(text, RUN_TAIL_TEXT_LIMIT, "...");
-	if (!isRecord(event)) return undefined;
-	if (event.type === "clio_tool_finish" && isRecord(event.payload)) {
-		const tool = typeof event.payload.tool === "string" ? event.payload.tool : "tool";
-		const outcome = typeof event.payload.outcome === "string" ? event.payload.outcome : "";
+	if (!isRecord(normalized)) return undefined;
+	if (normalized.type === "clio_coder_tool_finish" && isRecord(normalized.payload)) {
+		const tool = typeof normalized.payload.tool === "string" ? normalized.payload.tool : "tool";
+		const outcome = typeof normalized.payload.outcome === "string" ? normalized.payload.outcome : "";
 		return `${tool} ${outcome}`.trim();
 	}
-	if (event.type === "attempt_start") {
-		const attempt = typeof event.attempt === "number" ? event.attempt : "?";
-		const runId = typeof event.runId === "string" ? event.runId : "?";
-		const reason = typeof event.reason === "string" ? event.reason : "retry";
+	if (normalized.type === "attempt_start") {
+		const attempt = typeof normalized.attempt === "number" ? normalized.attempt : "?";
+		const runId = typeof normalized.runId === "string" ? normalized.runId : "?";
+		const reason = typeof normalized.reason === "string" ? normalized.reason : "retry";
 		return truncateUtf8(`attempt ${attempt} -> ${runId}: ${reason}`, RUN_TAIL_TEXT_LIMIT, "...");
 	}
 	return undefined;
@@ -89,7 +91,7 @@ function eventDetail(event: unknown): string | undefined {
  * (src/domains/dispatch/run-event-journal-bridge.ts) call it.
  */
 export function runTailEntryFromEvent(event: unknown, at: string = new Date().toISOString()): RunTailEntry | null {
-	const type = isRecord(event) && typeof event.type === "string" ? event.type : "unknown";
+	const type = isRecord(event) && typeof event.type === "string" ? normalizeClioCoderEventType(event.type) : "unknown";
 	if (type === "heartbeat" || type === "message_update") return null;
 	const entry: RunTailEntry = { at, type };
 	const detail = eventDetail(event);

package/src/tools/dispatch-runner.ts

@@ -57,6 +57,7 @@ import {
 	claimCompeteGroup,
 	cleanupCompeteGroup,
 	commitCandidateWork,
+	competeBranchForCandidate,
 	createCandidateWorktreeMapped,
 	isGitRepository,
 	loadCompeteGroup,
@@ -964,6 +965,8 @@ function recoverPendingGateEvidence(deps: DispatchToolDeps): void {
 		const pick = judged?.ok ? judged.result.winner : null;
 		const pickedSubject = pick === null ? undefined : record.subjects[pick - 1];
 		const candidateReceipt = pickedSubject === undefined ? null : readVerifiedGateReceipt(deps, pickedSubject.runId);
+		const root = record.resourceRoot ?? process.cwd();
+		const pickedBranch = pick === null ? null : competeBranchForCandidate(root, record.group, pick);
 		if (pickedSubject !== undefined && candidateReceipt === null) {
 			throw new Error(
 				`pending compete decision ${record.id} has no verified candidate receipt for ${pickedSubject.runId}`,
@@ -971,11 +974,10 @@ function recoverPendingGateEvidence(deps: DispatchToolDeps): void {
 		}
 		let blockedProtected: string[] = [];
 		if (pick !== null && pickedSubject !== undefined && candidateReceipt !== null) {
-			const root = record.resourceRoot ?? process.cwd();
 			const protectedPaths = deps.dispatch.protectedArtifactState?.().artifacts.map((artifact) => artifact.path) ?? [];
 			blockedProtected = protectedPathsChangedByCompeteBranch(
 				root,
-				`clio/compete/${record.group}/${pick}`,
+				pickedBranch ?? `clio-coder/compete/${record.group}/${pick}`,
 				protectedPaths,
 			);
 		}
@@ -985,7 +987,7 @@ function recoverPendingGateEvidence(deps: DispatchToolDeps): void {
 			candidateReceipt !== null &&
 			!isPipelineStepFailure(candidateReceipt) &&
 			blockedProtected.length === 0;
-		if (validWinner && pick !== null && pickedSubject !== undefined) {
+		if (validWinner && pick !== null && pickedSubject !== undefined && pickedBranch !== null) {
 			draft = {
 				group: record.group,
 				topology: "compete",
@@ -997,7 +999,7 @@ function recoverPendingGateEvidence(deps: DispatchToolDeps): void {
 				winner: {
 					index: pick,
 					subject: pickedSubject,
-					branch: `clio/compete/${record.group}/${pick}`,
+					branch: pickedBranch,
 				},
 			};
 		} else {
@@ -1599,9 +1601,12 @@ function runApplyWinner(
 		};
 	}
 	const branch = input.branch;
-	const match = /^clio\/compete\/([A-Za-z0-9][A-Za-z0-9._-]{0,127})\/([1-9]\d*)$/.exec(branch);
+	const match = /^(?:clio-coder|clio)\/compete\/([A-Za-z0-9][A-Za-z0-9._-]{0,127})\/([1-9]\d*)$/.exec(branch);
 	if (!match) {
-		return { kind: "error", message: "dispatch: apply_winner.branch must be a clio/compete/<group>/<n> branch" };
+		return {
+			kind: "error",
+			message: "dispatch: apply_winner.branch must be a clio-coder/compete/<group>/<n> branch",
+		};
 	}
 	const group = match[1] ?? "";
 	const winnerIndex = Number.parseInt(match[2] ?? "", 10);

package/src/tools/dispatch.ts

@@ -252,7 +252,7 @@ export function createDispatchTool(
 			apply_winner: Type.Optional(
 				Type.Object(
 					{
-						branch: Type.String({ description: "Preserved winner branch: clio/compete/<group>/<n>." }),
+						branch: Type.String({ description: "Preserved winner branch: clio-coder/compete/<group>/<n>." }),
 						cwd: Type.Optional(Type.String({ description: "Repository root (default: current directory)." })),
 					},
 					{

package/src/tools/find.ts

@@ -31,12 +31,7 @@ type FindOrder = "path" | "mtime";
 // Build fd's argv. Ignore semantics (hidden files, .gitignore honoring,
 // generated-dir excludes, include_ignored) come entirely from the shared
 // ignore policy so grep and find never disagree about tree visibility.
-export function buildFdArgs(
-	pattern: string,
-	searchPath: string,
-	maxResults: number,
-	includeIgnored: boolean,
-): string[] {
+function buildFdArgs(pattern: string, searchPath: string, maxResults: number, includeIgnored: boolean): string[] {
 	const args = ["--glob", "--color=never", ...fdIgnoreArgs(searchPath, includeIgnored)];
 	args.push("--max-results", String(maxResults));
 	let effectivePattern = pattern;

package/src/tools/monitor.ts

@@ -214,16 +214,16 @@ const TOOLS_MAX_BYTES = 8 * 1024;
 const TOOLS_ARGUMENTS_CHARS = 160;
 
 /**
- * Tail event types that describe one tool call. `clio_tool_finish` is the
+ * Tail event types that describe one tool call. `clio_coder_tool_finish` is the
  * authoritative per-call outcome (it distinguishes a permission block from a
  * command that ran and exited nonzero); the engine's own `tool_execution_end`
  * is kept only when the tail recorded a detail for it, since a bare type line
  * says nothing the finish event does not.
  */
 const TOOL_CALL_EVENT_TYPES: ReadonlySet<string> = new Set([
-	"clio_tool_finish",
-	"clio_permission_resolved",
-	"clio_permission_escalated",
+	"clio_coder_tool_finish",
+	"clio_coder_permission_resolved",
+	"clio_coder_permission_escalated",
 ]);
 
 function toolCallLines(entries: ReadonlyArray<{ at: string; type: string; detail?: string }>): string[] {

package/src/tools/observers.ts

@@ -44,39 +44,6 @@ export interface FileMutationEvent {
 	toolName: string;
 }
 
-/**
- * Defers file-mutation sinks off the after_tool hot path and coalesces rapid
- * events into one best-effort batch. Lifecycle-owned sinks that must drain at
- * shutdown should admit work synchronously instead of using this convenience.
- */
-export function coalescePathSink(sink: (paths: string[]) => void): (event: FileMutationEvent) => void {
-	const pending = new Set<string>();
-	let flushScheduled = false;
-
-	const scheduleFlush = (): void => {
-		if (flushScheduled) return;
-		flushScheduled = true;
-		setImmediate(() => {
-			flushScheduled = false;
-			if (pending.size === 0) return;
-			const paths = [...pending];
-			pending.clear();
-			try {
-				sink(paths);
-			} catch {
-				// Incremental indexing is best-effort and must not change tool execution.
-			}
-			if (pending.size > 0) scheduleFlush();
-		});
-	};
-
-	return (event) => {
-		if (event.paths.length === 0) return;
-		for (const path of event.paths) pending.add(path);
-		scheduleFlush();
-	};
-}
-
 /** Notifies the caller after a successful file-mutating tool, for incremental indexing. */
 export function createFileMutationObserver(sink: (event: FileMutationEvent) => void): MiddlewareHookRegistration {
 	return {

package/src/tools/task-worktree.ts

@@ -1,6 +1,6 @@
 import { execFileSync } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
-import { existsSync, mkdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 
 export type TaskWorktreeApply = "merge" | "preserve";
@@ -25,7 +25,9 @@ export interface TaskWorktreeReceipt {
 
 const SAFE_RUN_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
 const OWNER_FILE_SUFFIX = ".task-owner.json";
-const COMMIT_IDENTITY = "clio-task";
+const TASK_WORKTREE_KIND = "clio-coder-task-worktree";
+const LEGACY_TASK_WORKTREE_KIND = "clio-task-worktree";
+const COMMIT_IDENTITY = "clio-coder-task";
 
 function gitBytes(root: string, args: string[]): Buffer {
 	return execFileSync("git", ["-C", root, ...args], {
@@ -160,7 +162,7 @@ export function createTaskWorktree(root: string, runId: string, base?: string):
 	const resolvedBase = base ?? git(canonical, ["rev-parse", "HEAD"]);
 	const parent = join(canonical, ".clio-coder", "worktrees");
 	const path = join(parent, runId);
-	const branch = `clio/task/${runId}`;
+	const branch = `clio-coder/task/${runId}`;
 	mkdirSync(parent, { recursive: true });
 	if (!isCanonicalWorktreePathInside(parent, path))
 		throw new Error(`task worktree path escapes its parent for run ${runId}`);
@@ -168,7 +170,7 @@ export function createTaskWorktree(root: string, runId: string, base?: string):
 	const ownerToken = randomBytes(16).toString("hex");
 	writeFileSync(
 		`${path}${OWNER_FILE_SUFFIX}`,
-		`${JSON.stringify({ version: 1, kind: "clio-task-worktree", root: canonical, runId, branch, base: resolvedBase, ownerToken }, null, 2)}\n`,
+		`${JSON.stringify({ version: 1, kind: TASK_WORKTREE_KIND, root: canonical, runId, branch, base: resolvedBase, ownerToken }, null, 2)}\n`,
 		{ encoding: "utf8", flag: "wx" },
 	);
 	return { root: canonical, runId, path, branch, base: resolvedBase, ownerToken };
@@ -182,11 +184,30 @@ function assertOwnership(worktree: TaskWorktree): void {
 	) {
 		throw new Error(`task worktree ${worktree.runId} has an invalid ownership path`);
 	}
-	if (!existsSync(`${worktree.path}${OWNER_FILE_SUFFIX}`))
-		throw new Error(`task worktree ${worktree.runId} has no ownership file`);
+	const ownerPath = `${worktree.path}${OWNER_FILE_SUFFIX}`;
+	if (!existsSync(ownerPath)) throw new Error(`task worktree ${worktree.runId} has no ownership file`);
+	let marker: Record<string, unknown>;
+	try {
+		const value = JSON.parse(readFileSync(ownerPath, "utf8")) as unknown;
+		if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("not an object");
+		marker = value as Record<string, unknown>;
+	} catch {
+		throw new Error(`task worktree ${worktree.runId} has an invalid ownership file`);
+	}
+	if (
+		marker.version !== 1 ||
+		(marker.kind !== TASK_WORKTREE_KIND && marker.kind !== LEGACY_TASK_WORKTREE_KIND) ||
+		marker.root !== worktree.root ||
+		marker.runId !== worktree.runId ||
+		marker.branch !== worktree.branch ||
+		marker.base !== worktree.base ||
+		marker.ownerToken !== worktree.ownerToken
+	) {
+		throw new Error(`task worktree ${worktree.runId} ownership facts do not match`);
+	}
 }
 
-function commitTaskWorktree(worktree: TaskWorktree, message = `Clio task ${worktree.runId}`): boolean {
+function commitTaskWorktree(worktree: TaskWorktree, message = `Clio Coder task ${worktree.runId}`): boolean {
 	assertOwnership(worktree);
 	return commitWorktreePath(worktree.path, COMMIT_IDENTITY, message);
 }

package/src/tools/verify/authoring.ts

@@ -234,7 +234,7 @@ function boundedId(base: string, suffix = ""): string {
 }
 
 /** Allocate the same stable suffix for the same ordered set of occupied IDs. */
-export function deterministicVerifierId(preferredId: string, occupied: ReadonlySet<string>): string {
+function deterministicVerifierId(preferredId: string, occupied: ReadonlySet<string>): string {
 	const base = boundedId(slug(preferredId, "check"));
 	if (!occupied.has(base) && base !== "frontend") return base;
 	for (let index = 2; index <= PROJECT_VERIFIER_CATALOG_CAPS.checks + 2; index += 1) {
@@ -892,7 +892,7 @@ function serializeVerifierDraft(draft: VerifierDraft): string {
 }
 
 /** Validate with the same production parser used by verify(). */
-export function validateVerifierDraft(draft: VerifierDraft): VerifierDraftValidation {
+function validateVerifierDraft(draft: VerifierDraft): VerifierDraftValidation {
 	const text = serializeVerifierDraft(draft);
 	const parsed = parseProjectVerifierCatalogText(text, draft.workspaceRoot, draft.catalogPath);
 	if (!parsed.ok) return { ok: false, reason: parsed.reason, text };
@@ -944,10 +944,7 @@ function cloneDraft(draft: VerifierDraft): VerifierDraft {
 }
 
 /** Apply edits to a copy so a collision or schema failure leaves the prior draft intact. */
-export function reviseVerifierDraft(
-	draft: VerifierDraft,
-	revisions: ReadonlyArray<VerifierRevision>,
-): VerifierRevisionResult {
+function reviseVerifierDraft(draft: VerifierDraft, revisions: ReadonlyArray<VerifierRevision>): VerifierRevisionResult {
 	const next = cloneDraft(draft);
 	const diagnostics: string[] = [];
 	for (const revision of revisions) {

package/src/tools/verify/frontend.ts

@@ -447,7 +447,7 @@ async function checkModuleJavaScript(
 	label: string,
 	options: ValidationOptions,
 ): Promise<string | null> {
-	const dir = mkdtempSync(path.join(tmpdir(), "clio-frontend-check-"));
+	const dir = mkdtempSync(path.join(tmpdir(), "clio-coder-frontend-check-"));
 	const file = path.join(dir, "module.mjs");
 	try {
 		writeFileSync(file, source, "utf8");

package/src/tools/web-fetch.ts

@@ -256,7 +256,7 @@ function htmlToMarkdown(html: string, baseUrl: string): string {
 		.trim();
 }
 
-export function extractWebFetchContent(
+function extractWebFetchContent(
 	rawText: string,
 	contentType: string,
 	finalUrl: string,

package/src/worker/entry.ts

@@ -122,7 +122,7 @@ async function main(): Promise<number> {
 	setResidencyNoticeSink((notice) => {
 		process.stderr.write(`[worker] residency ${notice.kind}: ${notice.message}\n`);
 		if (notice.kind === "will-not-fit") {
-			emitEvent({ type: "clio_run_outcome", payload: { outcomeCode: "vram_capacity_fit_failure" } });
+			emitEvent({ type: "clio_coder_run_outcome", payload: { outcomeCode: "vram_capacity_fit_failure" } });
 		}
 	});
 	const demux = createWorkerStdinDemux();
@@ -227,12 +227,13 @@ async function main(): Promise<number> {
 	const handle = startWorkerRun(input, (event) => emitEvent(projectWorkerEventForStdout(event)));
 	// The demux buffers lines that landed before the runtime handle existed.
 	// Single-shot subprocesses expose no steer method, and an SDK query can race
-	// completion. The runtime emits the receipt-bearing clio_steer_received event
+	// completion. The runtime emits the receipt-bearing clio_coder_steer_received event
 	// only after it accepts the message; rejected input is diagnostic-only.
 	demux.onSteer(
 		createOrderedSteerHandler(
 			(text) => handle.steer?.(text) ?? false,
-			({ text, sequence }) => emitEvent({ type: "clio_steer_received", payload: { chars: text.trim().length, sequence } }),
+			({ text, sequence }) =>
+				emitEvent({ type: "clio_coder_steer_received", payload: { chars: text.trim().length, sequence } }),
 			(reason) => process.stderr.write(`[worker] dropped steer: ${reason}\n`),
 		),
 	);

package/src/worker/protocol.ts

@@ -22,6 +22,7 @@
  */
 
 import { createHash } from "node:crypto";
+import { normalizeClioCoderEventRecord } from "../core/naming-events.js";
 
 /** Current wire protocol. A peer announcing anything else is not executed. */
 export const WORKER_PROTOCOL_VERSION = 1;
@@ -291,7 +292,7 @@ const HEX_64 = /^[0-9a-f]{64}$/;
  * always present and never leaks absence as an empty string.
  */
 export function endpointIdentityHash(url: string | undefined): string {
-	if (url === undefined || url.trim().length === 0) return sha256Hex("clio.endpoint:none");
+	if (url === undefined || url.trim().length === 0) return sha256Hex("clio-coder.endpoint:none");
 	const raw = url.trim();
 	let canonical: string;
 	try {
@@ -301,17 +302,17 @@ export function endpointIdentityHash(url: string | undefined): string {
 	} catch {
 		canonical = raw.replace(/\/+$/u, "");
 	}
-	return sha256Hex(`clio.endpoint:${canonical}`);
+	return sha256Hex(`clio-coder.endpoint:${canonical}`);
 }
 
 /** Digest of one WorkerSpec document, computed identically on both ends. */
 export function workerSpecDigest(spec: unknown): string {
-	return sha256Hex(`clio.workerSpec:${canonicalJson(spec)}`);
+	return sha256Hex(`clio-coder.workerSpec:${canonicalJson(spec)}`);
 }
 
 /** Stable signature of the effective tool surface a worker will expose. */
 export function toolSignatureOf(names: ReadonlyArray<string>): string {
-	return sha256Hex(`clio.tools:${[...names].sort().join(",")}`);
+	return sha256Hex(`clio-coder.tools:${[...names].sort().join(",")}`);
 }
 
 /**
@@ -365,7 +366,8 @@ function parseJsonObject(line: string, maxBytes: number, lane: string): FramePar
 
 /** Parse one bulk stdout line under the bulk ceiling. */
 export function parseBulkFrame(line: string): FrameParseResult<Record<string, unknown>> {
-	return parseJsonObject(line, WORKER_BULK_FRAME_MAX_BYTES, "bulk");
+	const parsed = parseJsonObject(line, WORKER_BULK_FRAME_MAX_BYTES, "bulk");
+	return parsed.ok ? { ok: true, value: normalizeClioCoderEventRecord(parsed.value) } : parsed;
 }
 
 /** True when a raw stderr line belongs to the structured control lane. */
@@ -507,15 +509,15 @@ export function parseControlFrame(line: string): FrameParseResult<WorkerControlF
  */
 const RECEIPT_BEARING_BULK_TYPES = new Set([
 	"message_end",
-	"clio_run_outcome",
-	"clio_permission_escalated",
-	"clio_permission_resolved",
-	"clio_steer_received",
-	"clio_tool_activity",
-	"clio_skill_activation",
-	"clio_safety_decision",
-	"clio_verification",
-	"clio_usage",
+	"clio_coder_run_outcome",
+	"clio_coder_permission_escalated",
+	"clio_coder_permission_resolved",
+	"clio_coder_steer_received",
+	"clio_coder_tool_activity",
+	"clio_coder_skill_activation",
+	"clio_coder_safety_decision",
+	"clio_coder_verification",
+	"clio_coder_usage",
 	"tool_execution_end",
 	"spawn_error",
 ]);

package/src/worker/spec-contract.ts

@@ -143,7 +143,7 @@ interface WorkerSpecFields {
 	 * Non-stall posture for permission-requiring tool calls. "deny" converts
 	 * the call into a structured tool denial and the run continues; "fail"
 	 * aborts the run, which then exits with WORKER_EXIT_PERMISSION_REQUIRED;
-	 * "escalate" parks the call, emits clio_permission_escalated, and waits for
+	 * "escalate" parks the call, emits clio_coder_permission_escalated, and waits for
 	 * an operator permission_decision on stdin (falling back to the configured
 	 * deny/fail on timeout). Default "deny".
 	 */
@@ -229,7 +229,7 @@ const TOOL_PROFILE_NAMES = [
 	"council-read-only",
 ] as const satisfies ReadonlyArray<ToolProfileName>;
 const WORKER_PRODUCTS = ["orientation"] as const satisfies ReadonlyArray<AgentProduct>;
-const TARGET_LIFECYCLES = ["user-managed", "clio-managed"] as const;
+const TARGET_LIFECYCLES = ["user-managed", "clio-coder-managed"] as const;
 const RESIDENCY_ROLES = ["chat", "memory", "worker", "target-default"] as const satisfies ReadonlyArray<ResidencyRole>;
 const MIDDLEWARE_HOOKS = ["before_tool", "after_tool", "turn_start", "turn_end", "on_compaction"] as const;
 const MIDDLEWARE_EFFECT_KINDS = [

package/src/worker/stdin-demux.ts

@@ -13,7 +13,7 @@ export interface WorkerStdinDemux {
 	/**
 	 * Register the handler for post-spec steer lines
 	 * (`{"type":"steer","text":"...","sequence":1}`). The sequence is assigned by
-	 * the parent and is what lets `clio_steer_received` acknowledge one exact
+	 * the parent and is what lets `clio_coder_steer_received` acknowledge one exact
 	 * receipt entry, so a line without a positive integer sequence is dropped
 	 * rather than delivered unattributed. Steers that arrive before registration
 	 * are buffered in order and flushed to the handler. Single handler; a second
@@ -54,7 +54,7 @@ export interface WorkerSteerMessage {
 
 /**
  * Preserve stdin order while a runtime accepts guidance asynchronously.
- * `clio_steer_received` echoes the parent-assigned sequence, so an
+ * `clio_coder_steer_received` echoes the parent-assigned sequence, so an
  * acknowledgement closes out one exact receipt entry. Ordering still matters
  * for the runtime itself: a later steer must never reach it ahead of an earlier
  * pending one, or the guidance arrives out of the order the operator sent it.