@iowarp/clio-coder 0.4.0 → 0.4.2

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";
@@ -72,8 +73,10 @@ import { startClaudeSdkWorkerRun } from "./claude/sdk-runtime.js";
 import { startClaudeCodeWorkerRun } from "./claude/subprocess-runtime.js";
 import {
 	createLoopGuardRegistration,
+	isLockedSynthesisFallbackOnly,
 	isLoopGuardSynthesisBackstopReason,
 	lockedSynthesisFallbackText,
+	lockedSynthesisRepromptMessages,
 	resolveDeliveryTools,
 	sanitizeLockedSynthesisMessage,
 	workerLoopBlockBudget,
@@ -376,11 +379,10 @@ 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);
-	// 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);
+	setGlobalDefaultMaxOutputTokens(workerSettings.chat.maxOutputTokens);
+	// Same mirroring for guardrail policy: the fresh process needs its settings
+	// projection installed before any registry or tool construction reads it.
+	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
@@ -411,8 +413,10 @@ export function startWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): Wo
 			: {}),
 	});
 	// Flipped by the loop guard's lockout callback; read by onPayload below to
-	// force the remaining model rounds text-only via tool_choice none.
+	// force the remaining model rounds text-only by removing the tool surface
+	// (tool_choice none on Anthropic; see patchToolSurfaceLockedPayload).
 	let synthesisToolLock = false;
+	let lockedSynthesisReprompts = 0;
 	let workerBoundFailure: string | null = null;
 	let workerBoundAborted = false;
 	let abortWorkerForBound: (() => void) | null = null;
@@ -548,17 +552,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 +575,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"
@@ -595,6 +599,7 @@ export function startWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): Wo
 		includeInteractiveTools: false,
 		invokeOptions: () => ({
 			correlationId: `worker-model-round-${workerModelRound}`,
+			toolResultMaxBytes: workerSettings.context.toolResultMaxBytes,
 			...(agentSkillPolicy ? { pendingSkillPolicy: agentSkillPolicy } : {}),
 		}),
 	});
@@ -660,13 +665,38 @@ export function startWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): Wo
 			pendingReadCitations.delete(event.toolCallId);
 			if (request !== undefined && event.isError !== true) recordObservedRead(request, event.result);
 		}
-		// Synthesis-locked run: a model that ignores tool_choice none emits its
-		// chat template's tool-call syntax as plain text. Sanitize the finished
-		// message in place before it hits stdout; pi stores this same object in
-		// agent state, so the NDJSON event, the dispatch consumer's answer
-		// reconstruction, and any later provider round all see the same text.
+		// Synthesis-locked run: the round ships no tool surface, so a model that
+		// calls a tool anyway lands its chat template's tool-call syntax in the
+		// reply as plain text. Sanitize the finished message in place before it
+		// hits stdout; pi stores this same object in agent state, so the NDJSON
+		// event, the dispatch consumer's answer reconstruction, and any later
+		// provider round all see the same text.
+		// A markup-only locked reply re-prompted this round; the result-contract
+		// check below stands aside so the round costs the one re-prompt, not one
+		// of the contract's bounded repair slots (on ornith both were queued for
+		// the same message and the run then ran out of repairs on a later
+		// grounding violation).
+		let repromptedThisMessage = false;
 		if (synthesisToolLock && event.type === "message_end") {
-			sanitizeLockedSynthesisMessage(event.message);
+			const stripped = sanitizeLockedSynthesisMessage(event.message);
+			// A model that calls a tool anyway hands its markup back as text and
+			// the sanitizer leaves only the fallback notice: the training habit
+			// survives the strip (Qwen3.8 did it in 1 of 5 stripped runs). One
+			// re-prompt, delivered as a tool exchange like the result-contract
+			// repair, asks for the answer in prose; a second markup-only reply
+			// keeps the notice.
+			if (stripped && lockedSynthesisReprompts < 1 && isLockedSynthesisFallbackOnly(event.message)) {
+				lockedSynthesisReprompts += 1;
+				repromptedThisMessage = true;
+				process.stderr.write("[worker] synthesis lock: reply was tool-call markup only; re-prompting once for prose\n");
+				for (const message of lockedSynthesisRepromptMessages(lockedSynthesisReprompts, {
+					provider: model.provider,
+					api: model.api,
+					model: model.id,
+				})) {
+					agent.followUp(message as unknown as AgentMessage);
+				}
+			}
 		}
 		// Bounded terminal-contract repair, on whichever message ends the run.
 		// A worker that finishes inside its budget never trips the synthesis
@@ -675,7 +705,7 @@ export function startWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): Wo
 		// same contract against the sealed receipt; this is the only point at
 		// which the model can still act on the validator's reason.
 		const contract = input.resultContract;
-		if (contract && event.type === "message_end" && isTerminalAssistantMessage(event.message)) {
+		if (contract && !repromptedThisMessage && event.type === "message_end" && isTerminalAssistantMessage(event.message)) {
 			const violation = terminalContractViolation(
 				contract,
 				event.message,
@@ -717,7 +747,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 +832,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 +861,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 +887,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 +912,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 +946,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 +967,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,

package/src/engine/worker-tools.ts

@@ -155,8 +155,10 @@ export function createWorkerToolRegistry(
 	// The ledger tool registers unconditionally. attestedToolSignature signs the
 	// names a bare registry produces, so a conditional registration would drift
 	// the signature and fail admission; only the injected port varies, and a run
-	// without one answers that it has no coordination ledger.
+	// without one answers that it has no coordination ledger. The explicit flag
+	// is what keeps that true now that the session registry omits the tool.
 	const registration = registerCoreTools(registry, {
+		includeLedgerTools: true,
 		...(agentLedger ? { agentLedger } : {}),
 		// A worker cannot install a skill or reach the operator who could, so
 		// its skill listing carries installed (or bound) skills only; the

package/src/entry/extension-hook-sources.ts

@@ -0,0 +1,28 @@
+import type { ExtensionSnapshot } from "../domains/extensions/index.js";
+import type { CapturedHookSourceSet } from "../domains/middleware/index.js";
+
+/**
+ * Adapt an extension snapshot's captured hook declarations to the
+ * middleware-native captured source set. This is the only place the two
+ * domains' shapes meet; middleware never imports extension types.
+ */
+export function capturedHookSourcesFor(
+	snapshot: Pick<ExtensionSnapshot, "generation" | "hookSources">,
+): CapturedHookSourceSet {
+	return {
+		generation: snapshot.generation,
+		sources: snapshot.hookSources.map((source) => ({
+			provenance: {
+				id: source.provenance.id,
+				scope: source.provenance.scope,
+				...(source.provenance.sourcePath !== undefined ? { sourcePath: source.provenance.sourcePath } : {}),
+				canonicalRoot: source.provenance.canonicalRoot,
+				manifestDigest: source.provenance.manifestDigest,
+				contentDigest: source.provenance.contentDigest,
+			},
+			declarationsDigest: source.declarationsDigest,
+			declarations: source.declarations,
+			...(source.parseError !== undefined ? { parseError: source.parseError } : {}),
+		})),
+	};
+}