@iowarp/clio-coder 0.4.0 → 0.4.2

package/src/domains/safety/finish-contract.ts

@@ -490,9 +490,10 @@ function bashExecutionEvidence(entry: unknown): FinishContractEvidence | null {
 	if (record.exitCode !== 0) return null;
 	const detected = detectValidationCommand(record.command);
 	if (detected.kind !== "validation") return null;
+	const contextMarker = record.excludeFromContext === true ? " [not sent to model]" : "";
 	const evidence: FinishContractEvidence = {
 		kind: "validation_command",
-		summary: `validation command passed: ${detected.matched}`,
+		summary: `validation command passed: ${detected.matched}${contextMarker}`,
 	};
 	const turnId = turnIdOf(entry);
 	if (turnId !== null) evidence.turnId = turnId;

package/src/domains/safety/loop-detector.ts

@@ -33,10 +33,12 @@ const DEFAULT_WINDOW_MS = 30_000;
 // stops them before they burn a turn. Callers that need a different cadence
 // pass `maxRepeats` explicitly.
 const DEFAULT_MAX_REPEATS = 3;
-// Sized so a consecutive or single-interleaved verbatim spiral still counts
-// its third repeat at any call latency, while an identical check separated by
-// two or more other calls (a fix-verify loop) stays below the threshold.
-const DEFAULT_KEEP_LAST_ATTEMPTS = 4;
+// Sized so a batch-shaped spiral still counts its third repeat at any call
+// latency: a model that re-emits the same parallel batch of up to sixteen
+// calls three times has every key inside the retained tail. Fix-verify loops
+// are not this detector's concern any more; the loop guard keys attempts by
+// the turn's write/edit epoch, so a check rerun after a change is a new key.
+const DEFAULT_KEEP_LAST_ATTEMPTS = 48;
 
 export function createLoopState(opts?: {
 	windowMs?: number;
@@ -138,6 +140,7 @@ export function observe(state: LoopDetectorState, key: string, now: number): [Lo
 		recent: next,
 		windowMs: state.windowMs,
 		maxRepeats: state.maxRepeats,
+		keepLastAttempts: keepLast,
 	};
 	return [newState, { looping, key, count }];
 }

package/src/domains/safety/run-effects.ts

@@ -140,7 +140,7 @@ const ENUMERABLE_ACTION_CLASSES: ReadonlySet<string> = new Set(["read", "write"]
  * `unknown` and is opaque, which is the fail-closed answer for a tool whose
  * arguments this process has no schema for.
  */
-export function toolWritesOpaquely(toolName: string): boolean {
+function toolWritesOpaquely(toolName: string): boolean {
 	return !ENUMERABLE_ACTION_CLASSES.has(classify({ tool: toolName }).actionClass);
 }
 

package/src/domains/scheduling/extension.ts

@@ -28,14 +28,14 @@ export function createSchedulingBundle(context: DomainContext): DomainBundle<Sch
 	const observability = context.getContract<ObservabilityContract>("observability");
 
 	const settings = config.get();
-	let budget = createBudgetState(settings.budget.sessionCeilingUsd);
+	let budget = createBudgetState(settings.safety.limits.sessionCostUsd);
 	const fleet = createFleetRegistry(() => config.get().fleet?.nodes ?? [], {
-		localMaxWorkers: () => resolveMaxWorkers(config.get().budget.concurrency),
+		localMaxWorkers: () => resolveMaxWorkers(config.get().fleet.concurrency),
 	});
 	const unsubscribes: Array<() => void> = [];
 
 	function syncBudget(): void {
-		const nextCeiling = config.get().budget.sessionCeilingUsd;
+		const nextCeiling = config.get().safety.limits.sessionCostUsd;
 		if (nextCeiling === budget.ceilingUsd) return;
 		budget = createBudgetState(nextCeiling);
 	}
@@ -83,7 +83,7 @@ export function createSchedulingBundle(context: DomainContext): DomainBundle<Sch
 			const { verdict, currentUsd } = evaluate();
 			return { verdict, currentUsd, ceilingUsd: budget.ceilingUsd };
 		},
-		maxWorkers: () => resolveMaxWorkers(config.get().budget.concurrency),
+		maxWorkers: () => resolveMaxWorkers(config.get().fleet.concurrency),
 		fleet,
 	};
 

package/src/domains/session/archive-readers.ts

@@ -42,6 +42,14 @@ export interface SessionLedgerRef {
 	path: string;
 }
 
+const ROUTING_NOTICE_CUSTOM_TYPE = "clio-coder.routing-notice";
+const LEGACY_ROUTING_NOTICE_CUSTOM_TYPE = "clio.routing-notice";
+
+function normalizeReleasedCustomType(entry: SessionEntry): SessionEntry {
+	if (entry.kind !== "custom" || entry.customType !== LEGACY_ROUTING_NOTICE_CUSTOM_TYPE) return entry;
+	return { ...entry, customType: ROUTING_NOTICE_CUSTOM_TYPE };
+}
+
 /**
  * Read every `<stateDir>/audit/<date>.jsonl` row. Malformed lines are skipped
  * and reported in `errors` instead of failing the read.
@@ -157,7 +165,7 @@ export function parseSessionEntries(raw: string, source: string): SessionReadRes
 		}
 		if (isSessionHeader(parsed)) continue;
 		if (isSessionEntry(parsed)) {
-			entries.push(parsed);
+			entries.push(normalizeReleasedCustomType(parsed));
 			continue;
 		}
 		errors.push(

package/src/domains/session/compaction/branch-summary.ts

@@ -162,6 +162,10 @@ export function serializeConversation(entries: ReadonlyArray<SessionEntry>): str
 			continue;
 		}
 		if (entry.kind === "bashExecution") {
+			// `!!` is an operator-private terminal command. Its immutable ledger
+			// entry remains available to transcript replay, but neither its command
+			// nor its output may cross a model boundary through compaction.
+			if (entry.excludeFromContext === true) continue;
 			parts.push(`[Bash]: $ ${entry.command}\n${truncate(entry.output, TOOL_RESULT_MAX_CHARS)}`);
 			continue;
 		}

package/src/domains/session/compaction/compact.ts

@@ -497,7 +497,7 @@ interface TextBlock {
 	text: string;
 }
 
-export function textFromAssistant(message: unknown): string {
+function textFromAssistant(message: unknown): string {
 	if (!message || typeof message !== "object" || !("content" in message)) return "";
 	const content = (message as { content: unknown }).content;
 	if (typeof content === "string") return content;

package/src/domains/session/compaction/tokens.ts

@@ -49,6 +49,10 @@ function estimateMessage(entry: MessageEntry): number {
 }
 
 function estimateBashExecution(entry: BashExecutionEntry): number {
+	// `!!` rows are transcript-only and never become provider input, including
+	// through a later compaction prompt. Charging their bytes to the model
+	// context would make the context meter claim the model can see private output.
+	if (entry.excludeFromContext === true) return 0;
 	return ceilChars(entry.command.length + entry.output.length);
 }
 

package/src/domains/session/context-accounting.ts

@@ -370,7 +370,7 @@ export function lastLoadedContextWindow(meta: SessionMeta, providerId: string, m
 	return null;
 }
 
-export function buildSnapshotCategories(inputs: {
+function buildSnapshotCategories(inputs: {
 	systemPrompt?: string | undefined;
 	promptSegments?: ReadonlyArray<{ id: string; tokenEstimate: number }> | undefined;
 	tools?: ReadonlyArray<unknown> | undefined;

package/src/domains/session/decision-board.ts

@@ -54,7 +54,7 @@ function answeredAtForDecision(policy: AskUserToolPolicy, sourceQuestion: string
  * The policy already keeps last-value-wins decisions; the defensive map also
  * makes conversion deterministic for hand-built policies and older callers.
  */
-export function finalizedInterviewEntryFields(policy: AskUserToolPolicy): DecisionLedgerEntryFields | null {
+function finalizedInterviewEntryFields(policy: AskUserToolPolicy): DecisionLedgerEntryFields | null {
 	if (policy.rounds.length === 0 && policy.decisions.length === 0) return null;
 	if (!policy.turnId) throw new Error(`decision board: interview ${policy.id} has no originating user turn`);
 	if (policy.status !== "complete" && policy.status !== "cancelled") {

package/src/domains/session/extension.ts

@@ -392,7 +392,7 @@ export function createSessionBundle(context: DomainContext): DomainBundle<Sessio
 				await performCheckpoint(state, "shutdown");
 			} catch (err) {
 				process.stderr.write(
-					`[clio:session] shutdown checkpoint failed: ${err instanceof Error ? err.message : String(err)}\n`,
+					`[clio-coder:session] shutdown checkpoint failed: ${err instanceof Error ? err.message : String(err)}\n`,
 				);
 			}
 			await closeCurrent("shutdown");

package/src/domains/session/handoff.ts

@@ -176,7 +176,7 @@ function isRecord(value: unknown): value is Record<string, unknown> {
  * ceiling, so the returned string is never longer than the bound, and the cut
  * lands on a whole code point rather than mid-sequence.
  */
-export function boundHandoffString(value: string): { text: string; truncated: boolean } {
+function boundHandoffString(value: string): { text: string; truncated: boolean } {
 	const text = value.trim();
 	const bytes = Buffer.byteLength(text, "utf8");
 	if (bytes <= HANDOFF_MAX_STRING_BYTES) return { text, truncated: false };
@@ -343,7 +343,7 @@ export interface HandoffReadLedgerOptions {
  * absolute form, which is what makes it fail the ledger check against paths
  * recorded relative to the workspace root.
  */
-export function normalizeHandoffPath(value: string, cwd: string | null): string {
+function normalizeHandoffPath(value: string, cwd: string | null): string {
 	const trimmed = value.trim().replace(/[\\/]+$/u, "");
 	if (trimmed.length === 0) return "";
 	const absolute = isAbsolute(trimmed) ? normalize(trimmed) : cwd === null ? normalize(trimmed) : resolve(cwd, trimmed);

package/src/domains/session/prompt-manifest.ts

@@ -155,11 +155,6 @@ function isSessionPromptCompileRecord(value: unknown): value is SessionPromptCom
 	);
 }
 
-/** A record written before the field existed describes the 0.3.8 layout. */
-export function promptManifestVersion(record: SessionPromptCompileRecord): number {
-	return record.version ?? 1;
-}
-
 export function getPromptManifestFilePath(meta: SessionMeta, stateDir?: string): string {
 	const safeMeta = {
 		...meta,

package/src/domains/session/protected-artifact-journal.ts

@@ -63,9 +63,12 @@ function artifactPayload(artifact: ProtectedArtifact): Record<string, unknown> {
 	};
 }
 
-function recordPayload(record: Omit<PendingProtectedArtifactRecord, "integrity">): Record<string, unknown> {
+function recordPayload(
+	record: Omit<PendingProtectedArtifactRecord, "integrity">,
+	legacyNaming = false,
+): Record<string, unknown> {
 	return {
-		contract: "clio.protectedArtifact.pending",
+		contract: legacyNaming ? "clio.protectedArtifact.pending" : "clio-coder.protectedArtifact.pending",
 		version: record.version,
 		id: record.id,
 		sessionId: record.sessionId,
@@ -81,9 +84,9 @@ function recordPayload(record: Omit<PendingProtectedArtifactRecord, "integrity">
 	};
 }
 
-function digest(record: Omit<PendingProtectedArtifactRecord, "integrity">): string {
+function digest(record: Omit<PendingProtectedArtifactRecord, "integrity">, legacyNaming = false): string {
 	return createHash("sha256")
-		.update(JSON.stringify(recordPayload(record)), "utf8")
+		.update(JSON.stringify(recordPayload(record, legacyNaming)), "utf8")
 		.digest("hex");
 }
 
@@ -153,7 +156,10 @@ function parseRecord(value: unknown, sessionId: string): PendingProtectedArtifac
 		createdAt: value.createdAt,
 		integrity: { algorithm: "sha256", digest: value.integrity.digest },
 	};
-	return digest(withoutIntegrity(parsed)) === parsed.integrity.digest ? parsed : null;
+	const without = withoutIntegrity(parsed);
+	return digest(without) === parsed.integrity.digest || digest(without, true) === parsed.integrity.digest
+		? parsed
+		: null;
 }
 
 export function stagePendingProtectedArtifact(
@@ -190,7 +196,7 @@ export function clearPendingProtectedArtifact(handle: PendingProtectedArtifactHa
 	rmSync(handle.path, { force: true });
 }
 
-export function readPendingProtectedArtifacts(sessionId: string): PendingProtectedArtifactReadResult {
+function readPendingProtectedArtifacts(sessionId: string): PendingProtectedArtifactReadResult {
 	const directory = journalDirectory(sessionId);
 	if (!existsSync(directory)) return { records: [], errors: [] };
 	const records: PendingProtectedArtifactHandle[] = [];

package/src/domains/session/retry.ts

@@ -70,7 +70,7 @@ const MODEL_LOADING_MIN_DELAY_MS = 15000;
  * True when the error says the target is loading the model, so the wait should
  * be sized for disk and VRAM rather than for a provider backing off.
  */
-export function isModelLoadingErrorMessage(errorMessage: string | null | undefined): boolean {
+function isModelLoadingErrorMessage(errorMessage: string | null | undefined): boolean {
 	if (!errorMessage || errorMessage.length === 0) return false;
 	return MODEL_LOADING_PATTERN.test(errorMessage);
 }

package/src/domains/session/task-board.ts

@@ -421,10 +421,8 @@ function applyMutation(
 	// Completion is the ledger's only load-bearing claim, so it carries two
 	// structural conditions rather than a bare status flip. Evidence is
 	// mandatory: a completed row becomes a passed validation record, and a row
-	// without evidence would assert a validation that nobody performed. The
-	// task must also have been started, because work that was never entered
-	// cannot have produced a result; the honest closes for it are block and
-	// drop, which record a reason instead.
+	// without evidence would assert a validation that nobody performed. Work
+	// that did not happen is closed with block or drop, which record a reason.
 	if (mutation.op === "done") {
 		if (mutation.evidence.trim().length === 0) {
 			return {
@@ -432,13 +430,16 @@ function applyMutation(
 					"done requires note as the evidence that the task actually finished (the command you ran, the file:line you verified). If the work did not happen, use block with a reason or drop it.",
 			};
 		}
-		if (target.status === "pending") {
-			return {
-				error: `task ${target.id} was never started, so it cannot be completed. Start it and do the work, or record the truth with block (reason) or drop.`,
-			};
-		}
 	}
 	const notes: string[] = [];
+	// A model that did the work without announcing it on the board closes
+	// several tasks in a row at the end of the turn. Refusing done on a pending
+	// task cost a live session six start/done pairs of pure ceremony; the
+	// evidence note is the load-bearing claim, so the start is recorded
+	// implicitly and named in the notes.
+	if (mutation.op === "done" && target.status === "pending") {
+		notes.push(`started ${target.id} implicitly: done on a pending task records the start and the completion together`);
+	}
 	const tasks = board.tasks.map((task): TaskBoardTask => {
 		if (task.id !== target.id) {
 			// One active task at a time: starting a task parks any other active