@iowarp/clio-coder 0.4.1 → 0.4.2

package/src/cli/trace.ts

@@ -3,6 +3,8 @@ import { access } from "node:fs/promises";
 import { resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { clioStatePath } from "../core/xdg.js";
+import type { CodeStepRecord } from "../domains/dispatch/code-step.js";
+import { codeStepDir, readCodeStepRecords } from "../domains/dispatch/code-step-store.js";
 import {
 	assertTraceSelectOnly,
 	DEFAULT_TRACE_RETENTION_POLICY,
@@ -24,12 +26,16 @@ const HELP = `Usage:
   clio-coder trace phases <runId> [--db PATH]
   clio-coder trace tail <runId> [--follow] [--db PATH]
   clio-coder trace procs <runId> [--db PATH]
+  clio-coder trace code-steps <rootId> [--json]   deterministic code steps of one fleet root
   clio-coder trace prune [--max-age-days N] [--max-bytes N] [--db PATH] [--json]
   clio-coder trace sql <SELECT query> [--db PATH]
   clio-coder trace ui [--db PATH] [--port N]        source checkout only
 
 The viewer ships with the repository, not the npm package, so from an installed
-Clio the subcommands above are the way in. They read the same database.
+Clio the subcommands above are the way in. They read the same database, except
+code-steps, which reads the per-root record files under the state directory's
+code-steps/ tree (a code step is a subprocess, not a model run, so it never
+enters the SQLite mirror).
 Pruning keeps ${DEFAULT_TRACE_RETENTION_POLICY.maxAgeDays} days and at most ${DEFAULT_TRACE_RETENTION_POLICY.maxBytes} bytes by default. Set
 CLIO_CODER_TRACE_RETENTION_DAYS or CLIO_CODER_TRACE_MAX_BYTES to change the automatic
 policy; prune flags override those values for one command.
@@ -97,7 +103,7 @@ function parseTraceArgs(args: string[]): ParsedTraceArgs {
 }
 
 /** Every subcommand `trace` answers to. Anything else is a usage error. */
-const TRACE_COMMANDS = new Set(["runs", "inspect", "phases", "tail", "procs", "prune", "sql", "ui"]);
+const TRACE_COMMANDS = new Set(["runs", "inspect", "phases", "tail", "procs", "code-steps", "prune", "sql", "ui"]);
 
 /** The subcommands whose first positional is a run id. */
 const TRACE_COMMANDS_NEEDING_RUN_ID = new Set(["phases", "tail", "procs"]);
@@ -119,6 +125,10 @@ function invocationError(command: string, runId: string | undefined): number | n
 		return 2;
 	}
 	if (TRACE_COMMANDS_NEEDING_RUN_ID.has(command) && !runId) return missingRunId(command);
+	if (command === "code-steps" && !runId) {
+		process.stderr.write("trace code-steps requires a fleet root id\n");
+		return 2;
+	}
 	return null;
 }
 
@@ -161,6 +171,12 @@ export async function runTraceCommand(args: string[]): Promise<number> {
 
 	if (command === "ui") return runTraceUi(parsed.db, parsed.port);
 
+	// Code-step records live in flat per-root JSON files beside the ledger, not
+	// in the SQLite mirror, so this answers before the database is consulted and
+	// ignores --db. An absent root directory is the empty state: the root either
+	// never ran a code step or its records were pruned with the state tree.
+	if (command === "code-steps") return runTraceCodeSteps(runId ?? "", parsed.json);
+
 	// `inspect` answers ahead of the no-database courtesy below, because its
 	// answer to a state tree nothing has written to is a JSON snapshot saying
 	// the trace database is unavailable, not a sentence on stdout.
@@ -242,6 +258,41 @@ export async function runTraceCommand(args: string[]): Promise<number> {
 	}
 }
 
+/**
+ * Print every `CodeStepRecord` one fleet root wrote, oldest first. The record
+ * is the code step's stand-in for a receipt (argv, cwd, env names, exit code,
+ * duration, output digest, artifact paths), and until this command nothing
+ * read it back. JSON is the record verbatim; the table keeps the fields an
+ * operator scans for and leaves argv last because it is the widest.
+ */
+function runTraceCodeSteps(rootId: string, json: boolean): number {
+	let records: CodeStepRecord[];
+	try {
+		records = readCodeStepRecords(rootId);
+	} catch (error) {
+		process.stderr.write(`code-step records: ${error instanceof Error ? error.message : String(error)}\n`);
+		return 1;
+	}
+	if (json) {
+		process.stdout.write(`${JSON.stringify(records, null, 2)}\n`);
+		return 0;
+	}
+	if (records.length === 0) {
+		process.stdout.write(
+			`no code-step records for fleet root ${rootId} under ${codeStepDir(rootId)}. a record is written when a fleet plan runs a deterministic code step.\n`,
+		);
+		return 0;
+	}
+	process.stdout.write("EXIT  DURATION STARTED                  STEP                 COMMAND              ARGV\n");
+	for (const record of records) {
+		const exit = record.timedOut ? "timeout" : record.signal !== null ? `sig:${record.signal}` : String(record.exitCode);
+		process.stdout.write(
+			`${exit.padEnd(5)} ${`${record.durationMs}ms`.padStart(8)} ${record.startedAt.padEnd(24)} ${record.stepId.slice(0, 20).padEnd(20)} ${record.commandId.slice(0, 20).padEnd(20)} ${record.argv.join(" ")}\n`,
+		);
+	}
+	return 0;
+}
+
 function runTracePrune(parsed: ParsedTraceArgs): number {
 	let policy: ReturnType<typeof resolveTraceRetentionPolicy>;
 	try {
@@ -302,10 +353,10 @@ function formatEvent(row: TraceEventRow): string {
 }
 
 function printRuns(rows: TraceRunRow[]): void {
-	process.stdout.write("STATUS   STARTED                      TOKENS       COST RUN\n");
+	process.stdout.write("STATUS   SOURCE   STARTED                      TOKENS       COST RUN\n");
 	for (const row of rows) {
 		process.stdout.write(
-			`${row.status.padEnd(8)} ${row.started_at.padEnd(28)} ${formatNumber(row.total_tokens).padStart(8)} ${formatCost(row.total_cost_usd).padStart(10)} ${row.run_id}\n`,
+			`${row.status.padEnd(8)} ${row.source.padEnd(8)} ${row.started_at.padEnd(28)} ${formatNumber(row.total_tokens).padStart(8)} ${formatCost(row.total_cost_usd).padStart(10)} ${row.run_id}\n`,
 		);
 	}
 }

package/src/cli/wiki-generate.ts

@@ -236,7 +236,7 @@ async function runWikiDispatch(input: {
 	} catch (err) {
 		return { ok: false, detail: err instanceof Error ? err.message : String(err) };
 	}
-	const deadline = armInternalDispatchDeadline(input.dispatch, handle.runId, input.label, process.env, input.deadlineMs);
+	const deadline = armInternalDispatchDeadline(input.dispatch, handle.runId, input.label, input.deadlineMs);
 	let lastHeartbeatAt = startedAtClock;
 	try {
 		const summary = await drainDispatchEvents(handle.events, (tools) => {

package/src/core/artifact-paths.ts

@@ -15,7 +15,7 @@
  * be checking a path the tool never writes. One artifact per kind is therefore
  * the contract; keep several by passing explicit paths.
  *
- * See docs/artifact-placement.md for the full taxonomy.
+ * See docs/architecture/artifact-placement.md for the full taxonomy.
  */
 
 /** Project-local directory holding everything Clio generates for one repo. */

package/src/core/bash-exec.ts

@@ -18,7 +18,7 @@ export { clampTimerDelayMs as clampTimeoutMs } from "./timers.js";
 // (failing assertion, compiler error, exit summary) must survive.
 export const BASH_HARD_CAP_BYTES = 16 * 1024 * 1024;
 
-const CLIO_CONTROL_ENV_KEYS = ["CLIO_CODER_INTERACTIVE", "CLIO_CODER_RESUME_SESSION_ID"] as const;
+const CLIO_CONTROL_ENV_KEYS = ["CLIO_CODER_INTERACTIVE"] as const;
 
 export interface BashCommandResult {
 	error: NodeJS.ErrnoException | null;
@@ -52,6 +52,129 @@ export interface RunBashCommandOptions {
 
 const BASH_UPDATE_THROTTLE_MS = 100;
 
+export interface BashProgressScheduler {
+	now(): number;
+	setTimeout(callback: () => void, delayMs: number): unknown;
+	clearTimeout(timer: unknown): void;
+}
+
+export interface BashOutputProgressController {
+	/** Emit the initial empty cumulative snapshot, when a callback is configured. */
+	start(): void;
+	/** Accept one stream chunk. Returns true only when this chunk reaches the hard cap. */
+	append(target: "stdout" | "stderr", chunk: Buffer): boolean;
+	/** Seal output, cancel progress work, emit the final snapshot, and return the result fields. */
+	settle(): Pick<BashCommandResult, "stdout" | "stderr" | "outputBytes" | "outputCapped">;
+}
+
+const SYSTEM_PROGRESS_SCHEDULER: BashProgressScheduler = {
+	now: Date.now,
+	setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),
+	clearTimeout: (timer) => clearTimeout(timer as ReturnType<typeof setTimeout>),
+};
+
+/**
+ * Cumulative stdout/stderr fold shared by the child stream handlers and a
+ * deterministic contract-test seam. Settlement is a phase, not just a final
+ * boolean: once it starts, re-entrant or queued stream work is rejected while
+ * the one final advisory snapshot is still allowed to publish.
+ */
+export function createBashOutputProgressController(
+	onUpdate?: (progress: BashCommandProgress) => void,
+	scheduler: BashProgressScheduler = SYSTEM_PROGRESS_SCHEDULER,
+): BashOutputProgressController {
+	let phase: "active" | "settling" | "settled" = "active";
+	let stdout = "";
+	let stderr = "";
+	const stdoutDecoder = new StringDecoder("utf8");
+	const stderrDecoder = new StringDecoder("utf8");
+	let decodersFinished = false;
+	let outputBytes = 0;
+	let outputCapped = false;
+	let updateTimer: unknown = null;
+	let updateDirty = false;
+	let lastUpdateAt = 0;
+
+	const snapshot = (): BashCommandProgress => ({ stdout, stderr, outputBytes });
+
+	const finishDecoders = (): void => {
+		if (decodersFinished) return;
+		decodersFinished = true;
+		// A hard byte cap may bisect a multibyte code point. Discard the
+		// decoder's incomplete suffix instead of manufacturing U+FFFD.
+		if (outputCapped) return;
+		stdout += stdoutDecoder.end();
+		stderr += stderrDecoder.end();
+	};
+
+	const emitUpdate = (final = false): void => {
+		if (onUpdate === undefined || !updateDirty) return;
+		if (phase !== "active" && !(final && phase === "settling")) return;
+		updateDirty = false;
+		lastUpdateAt = scheduler.now();
+		try {
+			onUpdate(snapshot());
+		} catch {
+			// Rendering progress is advisory and must never change command execution.
+		}
+	};
+
+	const clearUpdateTimer = (): void => {
+		if (updateTimer === null) return;
+		scheduler.clearTimeout(updateTimer);
+		updateTimer = null;
+	};
+
+	const scheduleUpdate = (): void => {
+		if (onUpdate === undefined || phase !== "active") return;
+		updateDirty = true;
+		const delay = BASH_UPDATE_THROTTLE_MS - (scheduler.now() - lastUpdateAt);
+		if (delay <= 0) {
+			clearUpdateTimer();
+			emitUpdate();
+			return;
+		}
+		updateTimer ??= scheduler.setTimeout(() => {
+			updateTimer = null;
+			// A timer already queued by the event loop may still invoke its callback
+			// after clearTimeout. The phase check makes that callback inert.
+			emitUpdate();
+		}, delay);
+	};
+
+	return {
+		start(): void {
+			if (phase !== "active" || onUpdate === undefined) return;
+			updateDirty = true;
+			emitUpdate();
+		},
+		append(target, chunk): boolean {
+			if (phase !== "active" || outputCapped) return false;
+			const remaining = BASH_HARD_CAP_BYTES - outputBytes;
+			const accepted = chunk.byteLength <= remaining ? chunk : chunk.subarray(0, Math.max(0, remaining));
+			outputBytes += accepted.byteLength;
+			if (accepted.byteLength > 0) {
+				const decoded = target === "stdout" ? stdoutDecoder.write(accepted) : stderrDecoder.write(accepted);
+				if (target === "stdout") stdout += decoded;
+				else stderr += decoded;
+			}
+			if (accepted.byteLength < chunk.byteLength) outputCapped = true;
+			scheduleUpdate();
+			return outputCapped;
+		},
+		settle() {
+			if (phase === "settled") return { ...snapshot(), outputCapped };
+			if (phase === "settling") return { ...snapshot(), outputCapped };
+			phase = "settling";
+			clearUpdateTimer();
+			finishDecoders();
+			emitUpdate(true);
+			phase = "settled";
+			return { ...snapshot(), outputCapped };
+		},
+	};
+}
+
 function buildToolEnv(): NodeJS.ProcessEnv {
 	const env = { ...process.env };
 	env.AI_AGENT = AI_AGENT_NAME;
@@ -152,16 +275,7 @@ export async function runBashCommand(command: string, options: RunBashCommandOpt
 		let timeoutId: ReturnType<typeof setTimeout> | null = null;
 		let killGraceTimer: ReturnType<typeof setTimeout> | null = null;
 		let killSent = false;
-		let stdout = "";
-		let stderr = "";
-		const stdoutDecoder = new StringDecoder("utf8");
-		const stderrDecoder = new StringDecoder("utf8");
-		let decodersFinished = false;
-		let outputBytes = 0;
-		let outputCapped = false;
-		let updateTimer: ReturnType<typeof setTimeout> | null = null;
-		let updateDirty = false;
-		let lastUpdateAt = 0;
+		const output = createBashOutputProgressController(options.onUpdate);
 
 		const child = spawn("/bin/bash", [plan.mode, command], {
 			...(options.cwd === undefined ? {} : { cwd: options.cwd }),
@@ -170,53 +284,7 @@ export async function runBashCommand(command: string, options: RunBashCommandOpt
 			stdio: ["ignore", "pipe", "pipe"],
 		});
 
-		const finishDecoders = (): void => {
-			if (decodersFinished) return;
-			decodersFinished = true;
-			// A hard byte cap may bisect a multibyte code point. Discard the
-			// decoder's incomplete suffix instead of manufacturing U+FFFD.
-			if (outputCapped) return;
-			stdout += stdoutDecoder.end();
-			stderr += stderrDecoder.end();
-		};
-
-		const emitUpdate = (): void => {
-			if (options.onUpdate === undefined || !updateDirty) return;
-			updateDirty = false;
-			lastUpdateAt = Date.now();
-			try {
-				options.onUpdate({ stdout, stderr, outputBytes: Math.min(outputBytes, BASH_HARD_CAP_BYTES) });
-			} catch {
-				// Rendering progress is advisory and must never change command execution.
-			}
-		};
-		const clearUpdateTimer = (): void => {
-			if (updateTimer === null) return;
-			clearTimeout(updateTimer);
-			updateTimer = null;
-		};
-		const scheduleUpdate = (): void => {
-			if (options.onUpdate === undefined) return;
-			updateDirty = true;
-			const delay = BASH_UPDATE_THROTTLE_MS - (Date.now() - lastUpdateAt);
-			if (delay <= 0) {
-				clearUpdateTimer();
-				emitUpdate();
-				return;
-			}
-			updateTimer ??= setTimeout(() => {
-				updateTimer = null;
-				emitUpdate();
-			}, delay);
-		};
-		const finishUpdates = (): void => {
-			clearUpdateTimer();
-			emitUpdate();
-		};
-		if (options.onUpdate !== undefined) {
-			updateDirty = true;
-			emitUpdate();
-		}
+		output.start();
 
 		const clearKillGraceTimer = (): void => {
 			if (!killGraceTimer) return;
@@ -265,22 +333,7 @@ export async function runBashCommand(command: string, options: RunBashCommandOpt
 		}
 
 		const appendChunk = (target: "stdout" | "stderr", chunk: Buffer): void => {
-			if (outputCapped) return;
-			const remaining = BASH_HARD_CAP_BYTES - outputBytes;
-			const accepted = chunk.byteLength <= remaining ? chunk : chunk.subarray(0, Math.max(0, remaining));
-			outputBytes += accepted.byteLength;
-			if (accepted.byteLength > 0) {
-				const decoded = target === "stdout" ? stdoutDecoder.write(accepted) : stderrDecoder.write(accepted);
-				if (target === "stdout") stdout += decoded;
-				else stderr += decoded;
-			}
-			if (accepted.byteLength < chunk.byteLength) {
-				outputCapped = true;
-				scheduleUpdate();
-				killChild();
-				return;
-			}
-			scheduleUpdate();
+			if (output.append(target, chunk)) killChild();
 		};
 
 		child.stdout?.on("data", (chunk: Buffer) => appendChunk("stdout", chunk));
@@ -290,19 +343,15 @@ export async function runBashCommand(command: string, options: RunBashCommandOpt
 			settled = true;
 			if (timeoutId) clearTimeout(timeoutId);
 			clearKillGraceTimer();
-			finishDecoders();
-			finishUpdates();
+			const finalOutput = output.settle();
 			options.signal?.removeEventListener("abort", onAbort);
 			resolve({
 				error: error as NodeJS.ErrnoException,
-				stdout,
-				stderr,
+				...finalOutput,
 				exitCode: null,
 				signal: null,
 				aborted,
 				timedOut,
-				outputCapped,
-				outputBytes,
 			});
 		});
 		child.on("close", (code, signalName) => {
@@ -310,8 +359,7 @@ export async function runBashCommand(command: string, options: RunBashCommandOpt
 			settled = true;
 			if (timeoutId) clearTimeout(timeoutId);
 			clearKillGraceTimer();
-			finishDecoders();
-			finishUpdates();
+			const finalOutput = output.settle();
 			options.signal?.removeEventListener("abort", onAbort);
 			const error =
 				code === 0 && signalName === null
@@ -324,14 +372,11 @@ export async function runBashCommand(command: string, options: RunBashCommandOpt
 						} as NodeJS.ErrnoException);
 			resolve({
 				error,
-				stdout,
-				stderr,
+				...finalOutput,
 				exitCode: code,
 				signal: signalName,
 				aborted,
 				timedOut,
-				outputCapped,
-				outputBytes,
 			});
 		});
 	});

package/src/core/bus-events.ts

@@ -24,6 +24,7 @@ import type {
 	ToolActivitySummary,
 } from "../domains/dispatch/types.js";
 import type { MiddlewareHook } from "../domains/middleware/types.js";
+import type { ObservabilityRunEvidence } from "../domains/observability/contract.js";
 import type { TargetStatus } from "../domains/providers/contract.js";
 import type { CostProvenance } from "../domains/providers/index.js";
 import type { ClioSettings } from "./config.js";
@@ -58,9 +59,11 @@ export const BusChannels = {
 	DispatchProgress: "dispatch.progress",
 	DispatchCompleted: "dispatch.completed",
 	DispatchFailed: "dispatch.failed",
+	AccountabilityEvidenceReady: "accountability.evidenceReady",
 	CompactionBegin: "compaction.begin",
 	CompactionEnd: "compaction.end",
 	MiddlewareHookFailed: "middleware.hookFailed",
+	ExtensionsReloaded: "extensions.reloaded",
 	ContextActivity: "context.activity",
 	ContextWarning: "context.warning",
 	ContextPruned: "context.pruned",
@@ -628,8 +631,8 @@ export interface DispatchTerminalStats {
 	exitCode: number;
 	/** Honest activity record aggregated from the run's tool telemetry; null when the receipt predates it. */
 	toolActivity: ToolActivitySummary | null;
-	/** Host-run declared verification status when the request included checks. */
-	hostVerification?: "verified" | "rejected" | "skipped";
+	/** Host-run declared verification status when the request included checks; `not_implicated` is a batch member the failure was charged away from. */
+	hostVerification?: "verified" | "rejected" | "skipped" | "not_implicated";
 }
 
 /** Published on {@link BusChannels.DispatchCompleted} when a run finalizes as succeeded. */
@@ -667,6 +670,24 @@ export interface DispatchFailedPayload extends DispatchRunIdentity, Partial<Disp
 	skillActivations?: ReadonlyArray<SkillActivation>;
 }
 
+// ---------------------------------------------------------------------------
+// Accountability
+// ---------------------------------------------------------------------------
+
+/**
+ * Published on {@link BusChannels.AccountabilityEvidenceReady} by the
+ * observability extension once a finalized run's evidence bundle and its
+ * sidecar index row have landed. The evidence fields are exactly
+ * {@link ObservabilityRunEvidence}, the shape the projection already attaches
+ * to the run summary, so the bus and the snapshot cannot describe the same
+ * moment two ways. A failed build publishes nothing here: the projection's
+ * notice is the failure surface, and a client that never receives this event
+ * has learned only that no bundle is ready, which is the truth.
+ */
+export interface AccountabilityEvidenceReadyPayload extends ObservabilityRunEvidence {
+	runId: string;
+}
+
 // ---------------------------------------------------------------------------
 // Compaction
 // ---------------------------------------------------------------------------
@@ -677,6 +698,26 @@ export interface CompactionPayload {
 	at: number;
 }
 
+// ---------------------------------------------------------------------------
+// Extensions
+// ---------------------------------------------------------------------------
+
+/**
+ * Published on {@link BusChannels.ExtensionsReloaded} by the composition
+ * root after a new extension generation and its user-hook registrations
+ * have both been committed. Consumers that cache extension-sourced data
+ * (prompt fragments, agent recipes, the session prompt) refresh on
+ * `changed`; an unchanged generation carries the previous digest and needs
+ * no work. Never published between the two commits.
+ */
+export interface ExtensionsReloadedPayload {
+	generation: number;
+	previousGeneration: number;
+	changed: boolean;
+	/** Content identity of the committed snapshot. */
+	digest: string;
+}
+
 // ---------------------------------------------------------------------------
 // Middleware
 // ---------------------------------------------------------------------------
@@ -685,15 +726,17 @@ export interface CompactionPayload {
  * Published on {@link BusChannels.MiddlewareHookFailed} when a middleware hook
  * registration misbehaves: `hook_failed` for a thrown evaluate (its effects
  * are discarded and the turn proceeds), `budget_exceeded` for a soft
- * wall-time overrun (effects still apply). Diagnostics only; nothing
- * subscribing here may decide anything.
+ * wall-time overrun (effects still apply), `registration_conflict` when an
+ * owned registration set (user hooks) offered an id a builtin or host
+ * registration holds, or a host registration evicted an owned one.
+ * Diagnostics only; nothing subscribing here may decide anything.
  */
 export interface MiddlewareHookFailedPayload {
-	kind: "hook_failed" | "budget_exceeded";
+	kind: "hook_failed" | "budget_exceeded" | "registration_conflict";
 	registrationId: string;
 	hook: MiddlewareHook;
 	at: number;
-	/** Error text; hook_failed only. */
+	/** Error text for hook_failed; one formatted line for registration_conflict. */
 	message?: string | undefined;
 	/** Measured and allowed wall time in ms; budget_exceeded only. */
 	elapsedMs?: number | undefined;
@@ -798,9 +841,11 @@ export type BusPayloadMap = {
 	[BusChannels.DispatchProgress]: DispatchProgressPayload;
 	[BusChannels.DispatchCompleted]: DispatchCompletedPayload;
 	[BusChannels.DispatchFailed]: DispatchFailedPayload;
+	[BusChannels.AccountabilityEvidenceReady]: AccountabilityEvidenceReadyPayload;
 	[BusChannels.CompactionBegin]: CompactionPayload;
 	[BusChannels.CompactionEnd]: CompactionPayload;
 	[BusChannels.MiddlewareHookFailed]: MiddlewareHookFailedPayload;
+	[BusChannels.ExtensionsReloaded]: ExtensionsReloadedPayload;
 	[BusChannels.ContextActivity]: ContextActivityPayload;
 	[BusChannels.ContextWarning]: ContextWarningPayload;
 	[BusChannels.ContextPruned]: ContextPrunedPayload;

package/src/core/config.ts

@@ -1486,7 +1486,11 @@ export function validateSettings(raw: unknown): SettingsValidationResult {
 		if (!isPlainObject(raw.context)) issues.add("context", `expected a map, got ${describe(raw.context)}`);
 		else {
 			const context = raw.context;
-			issues.unknownKeys("context", context, ["workingSet", "compaction", "memory"]);
+			issues.unknownKeys("context", context, ["toolResultMaxBytes", "workingSet", "compaction", "memory"]);
+			if ("toolResultMaxBytes" in context) {
+				const parsed = expectInteger(issues, "context.toolResultMaxBytes", context.toolResultMaxBytes, { min: 4096 });
+				if (parsed !== undefined) settings.context.toolResultMaxBytes = parsed;
+			}
 			if ("workingSet" in context) {
 				if (!isPlainObject(context.workingSet))
 					issues.add("context.workingSet", `expected a map, got ${describe(context.workingSet)}`);

package/src/core/defaults.ts

@@ -412,6 +412,7 @@ export interface MemorySettings {
 }
 
 export interface ContextSettings {
+	toolResultMaxBytes: number;
 	workingSet: WorkingSetSettings;
 	compaction: DurableCompactionSettings;
 	memory: MemorySettings;
@@ -447,13 +448,13 @@ export const DEFAULT_SETTINGS = {
 	chat: {
 		target: null as string | null,
 		model: null as string | null,
-		thinkingLevel: "off" as ThinkingLevel,
+		thinkingLevel: "low" as ThinkingLevel,
 		modelPicker: {
 			cycleSet: [] as string[],
 			favorites: [] as string[],
 			recentLimit: 12,
 		} as ModelSelectorSettings,
-		maxOutputTokens: 32768,
+		maxOutputTokens: 0,
 		prewarm: true,
 		retry: {
 			enabled: true,
@@ -491,6 +492,7 @@ export const DEFAULT_SETTINGS = {
 		history: { maxRuns: GUARDRAIL_DEFAULTS.maxDispatchRuns, journal: true },
 	} as FleetSettings,
 	context: {
+		toolResultMaxBytes: 65536,
 		workingSet: DEFAULT_WORKING_SET_SETTINGS,
 		compaction: {
 			auto: true,
@@ -582,12 +584,12 @@ targets: []
 chat:
   target: null
   model: null
-  thinkingLevel: off
+  thinkingLevel: low
   modelPicker:
     cycleSet: []
     favorites: []
     recentLimit: 12
-  maxOutputTokens: 32768
+  maxOutputTokens: 0
   prewarm: true
   retry:
     enabled: true
@@ -626,6 +628,7 @@ fleet:
     journal: true
 
 context:
+  toolResultMaxBytes: 65536
   workingSet:
     enabled: true
     policy: structural-v1

package/src/core/dispatch-outcome.ts

@@ -0,0 +1,16 @@
+/**
+ * Shared mapping from a `DispatchFailed` payload's `reason` field to the
+ * terminal status it implies. Both the observability projection's run
+ * summary (src/domains/observability/projection.ts) and the interactive
+ * dispatch board (src/interactive/dispatch-board.ts) derive a run's status
+ * from the same DispatchCompleted/DispatchFailed bus events; before this
+ * module existed they each carried their own copy of this exact mapping,
+ * kept in sync only by a comment asking the next editor to remember to.
+ */
+export type DispatchFailureStatus = "dead" | "aborted" | "failed";
+
+export function resolveDispatchFailureStatus(reason: unknown): DispatchFailureStatus {
+	if (reason === "dead" || reason === "stalled") return "dead";
+	if (reason === "interrupted" || reason === "canceled") return "aborted";
+	return "failed";
+}