@iowarp/clio-coder 0.4.0 → 0.4.1

package/src/engine/apis/lmstudio.ts

@@ -19,7 +19,7 @@ interface LmStudioModelMetadata {
 	clio?: {
 		targetId: string;
 		runtimeId: string;
-		lifecycle?: "user-managed" | "clio-managed";
+		lifecycle?: "user-managed" | "clio-coder-managed";
 		lmstudio?: TargetDescriptor["lmstudio"];
 		lmstudioDefaultModel?: string;
 	};
@@ -145,11 +145,6 @@ function emitResidencyNoticeOnce(key: string, notice: Parameters<typeof emitResi
 	emitResidencyNotice(notice);
 }
 
-/** Test seam: forget which residency facts were announced. */
-export function resetAnnouncedResidencyFacts(): void {
-	announcedResidencyFacts.clear();
-}
-
 export async function ensureLmStudioResidency(
 	model: Model<"openai-completions">,
 	options: { apiKey?: string; signal?: AbortSignal } = {},

package/src/engine/apis/ollama-native.ts

@@ -47,7 +47,7 @@ interface ClioRuntimeMetadata {
 		targetId: string;
 		runtimeId: string;
 		/** Present only when settings set the target lifecycle explicitly. */
-		lifecycle?: "user-managed" | "clio-managed";
+		lifecycle?: "user-managed" | "clio-coder-managed";
 		gateway?: boolean;
 		family?: string;
 		quirks?: LocalModelQuirks;
@@ -159,7 +159,7 @@ function userToOllama(content: string | (TextContent | ImageContent)[]): OllamaM
 	return out;
 }
 
-export function assistantToOllama(content: AssistantMessage["content"]): OllamaMessage {
+function assistantToOllama(content: AssistantMessage["content"]): OllamaMessage {
 	const textParts: string[] = [];
 	const toolCalls: OllamaToolCall[] = [];
 	const thinkingParts: string[] = [];
@@ -270,7 +270,7 @@ function ollamaEvictClient(baseUrl: string, headers?: Record<string, string>): O
  * Map an Ollama `/api/ps` response to the runtime-agnostic resident shape,
  * preserving the GPU/total footprint when the server reports it.
  */
-export async function listResidentOllamaModels(client: OllamaEvictClient): Promise<ResidentModelInfo[]> {
+async function listResidentOllamaModels(client: OllamaEvictClient): Promise<ResidentModelInfo[]> {
 	const resident = await client.ps();
 	return resident.models.map((entry) => {
 		const primary = entry.model || entry.name;

package/src/engine/apis/openai-completions.ts

@@ -64,7 +64,7 @@ interface ClioRuntimeMetadata {
 		targetId: string;
 		runtimeId: string;
 		/** Present only when settings set the target lifecycle explicitly. */
-		lifecycle?: "user-managed" | "clio-managed";
+		lifecycle?: "user-managed" | "clio-coder-managed";
 		gateway?: boolean;
 		quirks?: LocalModelQuirks;
 		chatTemplateKwargsUnsupported?: boolean;
@@ -679,7 +679,7 @@ function hasReportedReasoningUsage(usage: Usage): boolean {
  * upstream already reported reasoning usage, because ACP consumers accept all
  * three field spellings for cross-agent compatibility.
  */
-export function applyOpenAICompatReasoningEstimate(message: AssistantMessage): void {
+function applyOpenAICompatReasoningEstimate(message: AssistantMessage): void {
 	if (hasReportedReasoningUsage(message.usage)) return;
 	const estimated = estimateReasoningTokens(message.content);
 	const reportedOutput = message.usage.output;

package/src/engine/apis/residency.ts

@@ -130,7 +130,7 @@ export function residentTagProtected(tags: ReadonlyArray<string> | undefined): b
 const clioLoaded = new Map<string, Set<string>>();
 
 /** Record that Clio loaded `modelId` on the target identified by `targetKey`. */
-export function markClioLoaded(targetKey: string, modelId: string): void {
+function markClioLoaded(targetKey: string, modelId: string): void {
 	let set = clioLoaded.get(targetKey);
 	if (!set) {
 		set = new Set();
@@ -156,12 +156,6 @@ function isClioLoaded(targetKey: string, entry: ResidentModelInfo): boolean {
 export const RECONCILE_TTL_MS = 60_000;
 const reconcileCache = new Map<string, { modelId: string; decision: "reconcile" | "observe"; at: number }>();
 
-/** Test-only: clear the cross-call Clio-loaded registry and TTL cache. */
-export function resetResidencyState(): void {
-	clioLoaded.clear();
-	reconcileCache.clear();
-}
-
 // --- residency decision (pure) ----------------------------------------------
 
 /**
@@ -301,7 +295,7 @@ function evictionNotice(facts: ResidencyFacts, entry: ResidentClassified): Resid
  * tiers, eviction order, and every notice case directly testable without a
  * server.
  */
-export function decideResidency(facts: ResidencyFacts): ResidencyPlan {
+function decideResidency(facts: ResidencyFacts): ResidencyPlan {
 	const notices: ResidencyNotice[] = [];
 	const keepResident = facts.resident.some((entry) => residentMatchesKeep(entry, facts.keepModelId));
 	const others = facts.resident.filter((entry) => !residentMatchesKeep(entry, facts.keepModelId));
@@ -801,7 +795,7 @@ export function residencyManaged(env: NodeJS.ProcessEnv = process.env): boolean
  * only sets the metadata field when settings carry an explicit value.
  */
 export function residencyManagedFor(
-	lifecycle: "user-managed" | "clio-managed" | undefined,
+	lifecycle: "user-managed" | "clio-coder-managed" | undefined,
 	env: NodeJS.ProcessEnv = process.env,
 ): boolean {
 	if (lifecycle === "user-managed") return false;

package/src/engine/claude/sdk-module.ts

@@ -66,20 +66,9 @@ export type ClaudeAgentSdkLoader = () => Promise<ClaudeAgentSdkModule>;
 // runtime `import()`.
 const realLoader: ClaudeAgentSdkLoader = async () => await import("@anthropic-ai/claude-agent-sdk");
 
-let loader: ClaudeAgentSdkLoader = realLoader;
+const loader: ClaudeAgentSdkLoader = realLoader;
 let cached: ClaudeAgentSdkModule | null = null;
 
-/**
- * Swap the import used by {@link loadClaudeAgentSdk}. The absence of a 224MB
- * optional package cannot be staged inside a normal test process, so the
- * contract test intercepts the import here; passing `null` restores the real
- * one and clears the cache.
- */
-export function setClaudeAgentSdkLoader(next: ClaudeAgentSdkLoader | null): void {
-	loader = next ?? realLoader;
-	cached = null;
-}
-
 /**
  * Resolve the SDK, or fail with {@link ClaudeAgentSdkUnavailableError}. A load
  * error that is not a resolution failure (a broken install, a throwing module

package/src/engine/claude/sdk-runtime.ts

@@ -53,11 +53,11 @@ async function* oneSdkUserMessage(message: SDKUserMessage): AsyncIterable<SDKUse
 	yield message;
 }
 
-export function claudeSdkPermissionModeForAutonomy(_level: AutonomyLevel | undefined): PermissionMode {
+function claudeSdkPermissionModeForAutonomy(_level: AutonomyLevel | undefined): PermissionMode {
 	return "default";
 }
 
-export function claudeSdkToolsForAutonomy(_level: AutonomyLevel | undefined): NonNullable<Options["tools"]> {
+function claudeSdkToolsForAutonomy(_level: AutonomyLevel | undefined): NonNullable<Options["tools"]> {
 	return DEFAULT_CLAUDE_TOOLS;
 }
 
@@ -314,7 +314,7 @@ export interface ClaudeWorkerBudgetGate {
 }
 
 /** Canonical call counter shared by the SDK's PreToolUse/canUseTool mediation seam. */
-export function createClaudeWorkerBudgetGate(
+function createClaudeWorkerBudgetGate(
 	budget: WorkerBudget,
 	onBoundary: () => void,
 	onHardCap: () => void,
@@ -438,7 +438,7 @@ function decideToolUse(
 }
 
 /** Share one logical permission decision across the SDK hook/callback pair. */
-export function decideClaudeSdkToolUseOnce(
+function decideClaudeSdkToolUseOnce(
 	handled: Map<string, ClaudeToolPermissionDecision>,
 	toolUseID: string | undefined,
 	decide: () => ClaudeToolPermissionDecision,
@@ -536,7 +536,7 @@ export function startClaudeSdkWorkerRun(input: WorkerRunInput, emit: WorkerEvent
 				() => {},
 				() => {
 					budgetFailure = true;
-					emit({ type: "clio_run_outcome", payload: { outcomeCode: "worker_tool_call_cap_exhausted" } });
+					emit({ type: "clio_coder_run_outcome", payload: { outcomeCode: "worker_tool_call_cap_exhausted" } });
 					abort();
 				},
 				resolveDeliveryTools(allowedToolSet, input.product),
@@ -563,7 +563,7 @@ export function startClaudeSdkWorkerRun(input: WorkerRunInput, emit: WorkerEvent
 		if (hookInput.hook_event_name !== "PostToolBatch" || !budgetGate?.phaseReached()) return { continue: true };
 		if (input.budget?.synthesis === false) {
 			budgetFailure = true;
-			emit({ type: "clio_run_outcome", payload: { outcomeCode: "worker_tool_call_cap_exhausted" } });
+			emit({ type: "clio_coder_run_outcome", payload: { outcomeCode: "worker_tool_call_cap_exhausted" } });
 			return { continue: false, stopReason: `worker agent budget reached (${input.budget.toolCalls})` };
 		}
 		return {

package/src/engine/claude/subprocess-runtime.ts

@@ -54,7 +54,7 @@ function buildClaudeCodePrompt(input: WorkerRunInput): string {
 	return parts.join("\n\n");
 }
 
-export function buildClaudeCodeArgs(input: WorkerRunInput): string[] {
+function buildClaudeCodeArgs(input: WorkerRunInput): string[] {
 	assertToolProfileEnforceable(input.toolProfile, "claude-code");
 	const permission = claudeSubprocessPermissionConfigForAutonomy(input.autonomy);
 	const args = [

package/src/engine/claude/tool-safety.ts

@@ -227,7 +227,7 @@ function budgetDenial(
 	};
 }
 
-export function evaluateClaudeToolPermission(input: EvaluateClaudeToolPermissionInput): ClaudeToolPermissionDecision {
+function evaluateClaudeToolPermission(input: EvaluateClaudeToolPermissionInput): ClaudeToolPermissionDecision {
 	const mapped = mapClaudeToolCall(input.toolName, input.input, input.cwd);
 	const call: ClassifierCall = { tool: mapped.clioToolName, args: mapped.args };
 	const attempt = input.budgetGate?.attempt(mapped.clioToolName);
@@ -346,7 +346,7 @@ function emitToolFinish(
 	const finalReasonCode = reasonCode ?? decision.policy?.reasonCode;
 	if (finalReasonCode !== undefined) event.reasonCode = finalReasonCode;
 	if (decision.policy?.policySource !== undefined) event.policySource = decision.policy.policySource;
-	emit({ type: "clio_tool_finish", payload: event });
+	emit({ type: "clio_coder_tool_finish", payload: event });
 }
 
 export function emitClaudeToolPermissionDecision(input: EmitClaudeToolPermissionInput): ClaudeToolPermissionDecision {
@@ -366,7 +366,7 @@ export function emitClaudeToolPermissionDecision(input: EmitClaudeToolPermission
 		startedAt,
 		...(action !== null ? { action } : {}),
 	};
-	input.emit({ type: "clio_tool_start", payload: start });
+	input.emit({ type: "clio_coder_tool_start", payload: start });
 	if (decision.kind === "allow") {
 		emitToolFinish(
 			input.emit,
@@ -383,7 +383,7 @@ export function emitClaudeToolPermissionDecision(input: EmitClaudeToolPermission
 	if (decision.permissionRequired) {
 		const mode = input.onPermission ?? "deny";
 		input.emit({
-			type: "clio_permission_resolved",
+			type: "clio_coder_permission_resolved",
 			payload: {
 				tool: decision.mapped.clioToolName,
 				actionClass: decision.decision.classification.actionClass,

package/src/engine/loop-guard.ts

@@ -352,11 +352,6 @@ export function isLoopGuardSynthesisBackstopReason(reason: string): boolean {
 	return /^loop guard: tool calls stayed disabled and .+ was called again instead of answering/.test(reason);
 }
 
-/** Worker lifetime tool-call cap: env > settings guardrails > default. */
-export function readWorkerToolCallCap(env: NodeJS.ProcessEnv = process.env): number {
-	return resolveGuardrail("workerToolCallCap", env);
-}
-
 /** Soft/hard per-turn tool-call budget for the interactive orchestrator. */
 export interface OrchTurnToolCallBudget {
 	/** Distinct calls in a turn that trigger the re-plan nudge. */

package/src/engine/session.ts

@@ -39,6 +39,7 @@ import {
 } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { StringDecoder } from "node:string_decoder";
+import { normalizeClioCoderEventTree } from "../core/naming-events.js";
 import { readClioVersion, readPiMonoVersion } from "../core/package-root.js";
 import { assertSafeId } from "../core/safe-id.js";
 import { fsyncDirectory, safeResourceWrite } from "../core/safe-resource-write.js";
@@ -52,7 +53,7 @@ export interface ClioSessionMeta {
 	endedAt: string | null;
 	model: string | null;
 	target: string | null;
-	clioVersion: string;
+	clioCoderVersion: string;
 	piMonoVersion: string;
 	platform: string;
 	nodeVersion: string;
@@ -181,7 +182,7 @@ function defaultSessionJsonlWarning(warning: SessionJsonlWarning): void {
 	if (reportedSessionJsonlWarnings.has(key)) return;
 	if (reportedSessionJsonlWarnings.size >= REPORTED_SESSION_JSONL_WARNING_LIMIT) reportedSessionJsonlWarnings.clear();
 	reportedSessionJsonlWarnings.add(key);
-	process.stderr.write(`[clio:session] ${warning.path}:${warning.line}: ${warning.message}\n`);
+	process.stderr.write(`[clio-coder:session] ${warning.path}:${warning.line}: ${warning.message}\n`);
 }
 
 function serializeJsonl(entries: ReadonlyArray<unknown>): string {
@@ -201,7 +202,7 @@ function serializeJsonl(entries: ReadonlyArray<unknown>): string {
  * A crash or interruption before the rename leaves the original target
  * untouched; when no target exists yet, recovery readers can promote the tmp.
  */
-export function writeJsonlFileAtomic(
+function writeJsonlFileAtomic(
 	targetPath: string,
 	entries: ReadonlyArray<unknown>,
 	options: SessionJsonlWriteOptions = {},
@@ -246,7 +247,7 @@ function parseSessionJsonlLine(
 ): void {
 	if (line.trim().length === 0) return;
 	try {
-		entries.push(JSON.parse(line) as unknown);
+		entries.push(normalizeClioCoderEventTree(JSON.parse(line) as unknown));
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		warn({ path: readPath, line: lineNumber, message: `invalid JSON skipped: ${message}` });
@@ -319,7 +320,7 @@ function readExactAt(fd: number, buffer: Buffer, position: number, length: numbe
  * Behaviour matches `readSessionFileEntries` line-for-line over the tail it
  * returns: same `parseSessionJsonlLine` (torn-tail tolerant), same warning sink.
  */
-export function readSessionFileTailEntries(
+function readSessionFileTailEntries(
 	path: string,
 	maxEntries: number,
 	options: SessionJsonlReadOptions & { chunkBytes?: number } = {},
@@ -461,7 +462,7 @@ function buildMeta(input: { cwd: string; model?: string | null; target?: string
 		endedAt: null,
 		model: input.model ?? null,
 		target: input.target ?? null,
-		clioVersion: readClioVersion(),
+		clioCoderVersion: readClioVersion(),
 		piMonoVersion: readPiMonoVersion(),
 		platform: process.platform,
 		nodeVersion: process.version,
@@ -471,7 +472,13 @@ function buildMeta(input: { cwd: string; model?: string | null; target?: string
 
 function readMetaFile(path: string): ClioSessionMeta {
 	const raw = readFileSync(path, "utf8");
-	return JSON.parse(raw) as ClioSessionMeta;
+	const parsed = JSON.parse(raw) as Record<string, unknown>;
+	const clioCoderVersion = parsed.clioCoderVersion ?? parsed.clioVersion;
+	if (typeof clioCoderVersion !== "string" || clioCoderVersion.length === 0) {
+		throw new Error(`session metadata has no Clio Coder version: ${path}`);
+	}
+	const { clioVersion: _legacyVersion, ...canonical } = parsed;
+	return { ...canonical, clioCoderVersion } as unknown as ClioSessionMeta;
 }
 
 const TURN_KINDS: readonly ClioTurnRecord["kind"][] = [

package/src/engine/tui-primitives.ts

@@ -18,4 +18,4 @@
  * here and not in src/cli/.
  */
 
-export { ProcessTerminal, TuiAltScreen, truncateToWidth } from "@earendil-works/pi-tui";
+export { ProcessTerminal, TuiAltScreen, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";

package/src/engine/worker-events.ts

@@ -9,18 +9,18 @@ import type { RunOutcomeCode } from "../domains/dispatch/types.js";
 import type { ToolFinishEvent, ToolStartEvent } from "../tools/agent-tools.js";
 
 export interface ClioToolStartEvent {
-	type: "clio_tool_start";
+	type: "clio_coder_tool_start";
 	payload: ToolStartEvent;
 }
 
 export interface ClioToolFinishEvent {
-	type: "clio_tool_finish";
+	type: "clio_coder_tool_finish";
 	payload: ToolFinishEvent;
 }
 
 /** Emitted when the worker's non-stall policy resolves a permission-requiring tool call. */
 export interface ClioPermissionResolvedEvent {
-	type: "clio_permission_resolved";
+	type: "clio_coder_permission_resolved";
 	payload: {
 		tool: string;
 		actionClass: string;
@@ -47,7 +47,7 @@ export interface ClioPermissionResolvedEvent {
  * on stdin (or the timeout fallback) resolves it.
  */
 export interface ClioPermissionEscalatedEvent {
-	type: "clio_permission_escalated";
+	type: "clio_coder_permission_escalated";
 	payload: {
 		requestId: string;
 		tool: string;
@@ -78,7 +78,7 @@ export interface ClioPermissionEscalatedEvent {
  * is the delivery ack for operator surfaces.
  */
 export interface ClioSteerReceivedEvent {
-	type: "clio_steer_received";
+	type: "clio_coder_steer_received";
 	payload: {
 		chars: number;
 		/** Exact parent-side steering provenance entry this acceptance closes. */
@@ -88,7 +88,7 @@ export interface ClioSteerReceivedEvent {
 
 /** Machine-readable terminal classification, emitted where the condition is known. */
 export interface ClioRunOutcomeEvent {
-	type: "clio_run_outcome";
+	type: "clio_coder_run_outcome";
 	payload: { outcomeCode: RunOutcomeCode };
 }
 

package/src/engine/worker-runtime.ts

@@ -13,6 +13,7 @@ import path from "node:path";
 import { validateSettingsFile } from "../core/config.js";
 import {
 	configureGuardrails,
+	guardrailValuesFromSettings,
 	isWorkerToolCallCapExceededReason,
 	isWorkerToolCallCapSynthesisReason,
 } from "../core/guardrails.js";
@@ -376,11 +377,11 @@ export function startWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): Wo
 	// non-throwing read: a worker must not abort over a settings issue the parent
 	// already surfaced.
 	const workerSettings = validateSettingsFile().settings;
-	setGlobalDefaultMaxOutputTokens(workerSettings.defaults.maxTokens);
+	setGlobalDefaultMaxOutputTokens(workerSettings.chat.maxOutputTokens);
 	// Same mirroring for guardrail policy: the worker's loop-guard cap and tool
 	// byte caps resolve settings-first, so the fresh process needs the section
 	// installed before any registry or tool construction reads it.
-	configureGuardrails(workerSettings.guardrails);
+	configureGuardrails(guardrailValuesFromSettings(workerSettings));
 	const fauxModel = registerFauxFromEnv();
 	// Workers are bounded runs against an admission-verified recipe surface.
 	// They have no operator to widen a missing tool, so the active surface is
@@ -548,17 +549,17 @@ export function startWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): Wo
 		);
 	const telemetry: ToolTelemetry = {
 		onStart(event) {
-			emit({ type: "clio_tool_start", payload: event });
+			emit({ type: "clio_coder_tool_start", payload: event });
 		},
 		onFinish(event) {
-			emit({ type: "clio_tool_finish", payload: event });
+			emit({ type: "clio_coder_tool_finish", payload: event });
 			if (event.outcome !== "blocked" || typeof event.reason !== "string") return;
 			// Lifetime-cap lockout: record the bound (the run must not seal as an
 			// ordinary success) but do not abort. The loop guard has flipped the
 			// synthesis tool lock, so the next model round runs text-only and the
 			// synthesized answer still reaches message_end and the receipt.
 			if (isWorkerToolCallCapSynthesisReason(event.reason)) {
-				emit({ type: "clio_run_outcome", payload: { outcomeCode: "worker_tool_call_cap_exhausted" } });
+				emit({ type: "clio_coder_run_outcome", payload: { outcomeCode: "worker_tool_call_cap_exhausted" } });
 				if (workerBoundFailure === null) {
 					workerBoundFailure = event.reason;
 					process.stderr.write(`[worker] ${event.reason}\n`);
@@ -571,7 +572,7 @@ export function startWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): Wo
 			// receipt diagnostic.
 			if (isWorkerToolCallCapExceededReason(event.reason) || isLoopGuardSynthesisBackstopReason(event.reason)) {
 				emit({
-					type: "clio_run_outcome",
+					type: "clio_coder_run_outcome",
 					payload: {
 						outcomeCode: isLoopGuardSynthesisBackstopReason(event.reason)
 							? "loop_guard_tools_disabled_exhausted"
@@ -717,7 +718,7 @@ export function startWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): Wo
 					for (const message of repair) agent.followUp(message as unknown as AgentMessage);
 				} else if (workerBoundFailure === null) {
 					workerBoundFailure = `result contract failed after ${RESULT_CONTRACT_REPAIR_LIMIT} bounded repair rounds: ${violation}`;
-					emit({ type: "clio_run_outcome", payload: { outcomeCode: "result_contract_exhausted" } });
+					emit({ type: "clio_coder_run_outcome", payload: { outcomeCode: "result_contract_exhausted" } });
 					process.stderr.write(`[worker] ${workerBoundFailure}\n`);
 				}
 			}
@@ -802,7 +803,7 @@ export function startWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): Wo
 		answeredEscalations.set(active.callKey, { decision, requestId });
 		if (decision === "approve") {
 			emit({
-				type: "clio_permission_resolved",
+				type: "clio_coder_permission_resolved",
 				payload: {
 					tool: active.tool,
 					actionClass: active.actionClass,
@@ -831,7 +832,7 @@ export function startWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): Wo
 			? `permission required for ${active.tool} (${active.actionClass}); ${denialContext} and workers fallback=fail ends this run`
 			: `permission denied by ${source === "timeout" ? "escalation timeout fallback" : "operator"}: ${active.tool} requires ${active.actionClass} confirmation`;
 		emit({
-			type: "clio_permission_resolved",
+			type: "clio_coder_permission_resolved",
 			payload: {
 				tool: active.tool,
 				actionClass: active.actionClass,
@@ -857,7 +858,7 @@ export function startWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): Wo
 		const active = activeEscalation;
 		if (!active) return;
 		emit({
-			type: "clio_permission_resolved",
+			type: "clio_coder_permission_resolved",
 			payload: {
 				tool: active.tool,
 				actionClass: active.actionClass,
@@ -882,7 +883,7 @@ export function startWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): Wo
 					? `operator approved an identical ${call.tool} call earlier in this run (request ${remembered.requestId}); the answer stands without a new prompt`
 					: `permission denied by operator: an identical ${call.tool} call was already denied earlier in this run (request ${remembered.requestId}); the answer stands, so do not repeat this call`;
 				emit({
-					type: "clio_permission_resolved",
+					type: "clio_coder_permission_resolved",
 					payload: {
 						tool: call.tool,
 						actionClass,
@@ -916,7 +917,7 @@ export function startWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): Wo
 			// as type-and-size summaries, and the args stay inside the worker.
 			const target = describeCallTarget(call.tool, call.args);
 			emit({
-				type: "clio_permission_escalated",
+				type: "clio_coder_permission_escalated",
 				payload: {
 					requestId,
 					tool: call.tool,
@@ -937,7 +938,7 @@ export function startWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): Wo
 		}
 		const reason = onPermission === "fail" ? failReason(call.tool, actionClass) : denyReason(call.tool, actionClass);
 		emit({
-			type: "clio_permission_resolved",
+			type: "clio_coder_permission_resolved",
 			payload: {
 				tool: call.tool,
 				actionClass,