@iowarp/clio-coder 0.4.3 → 0.4.4

package/src/interactive/fleet-run-preview.ts

@@ -38,6 +38,7 @@ import {
 } from "../domains/dispatch/execution-role.js";
 import { compileFleetExecutionPlan } from "../domains/dispatch/fleet-plan.js";
 import { preflightWriteBoundaries } from "../domains/dispatch/write-boundary-enforcer.js";
+import { formatUsd } from "./footer/widgets.js";
 
 /** Where a step would run, as the dispatch domain resolves it today. */
 export interface FleetRunPreviewRoute {
@@ -263,7 +264,7 @@ export function compileFleetRunPreview(input: FleetRunPreviewInput): FleetRunPre
 	};
 	if (input.budget) {
 		if (input.budget.verdict === "over" || input.budget.verdict === "at") {
-			diagnostics.push(`budget ceiling crossed: $${budget.currentUsd.toFixed(4)} / $${budget.ceilingUsd.toFixed(4)}`);
+			diagnostics.push(`budget ceiling crossed: ${formatUsd(budget.currentUsd)} / ${formatUsd(budget.ceilingUsd)}`);
 		} else if (contract.budgetUsd !== null) {
 			const remaining = budget.ceilingUsd - budget.currentUsd;
 			if (contract.budgetUsd > remaining) {

package/src/interactive/interactive-application.ts

@@ -228,8 +228,8 @@ export interface InteractiveDeps {
 	onNewSession?: () => void;
 	/**
 	 * Fork from a parent assistant turn picked in /fork. Default wiring
-	 * delegates to session.fork(parentTurnId); the override exists so
-	 * future slices can layer telemetry or settings merging on top.
+	 * delegates to session.fork(parentTurnId); the override exists so a
+	 * host can layer telemetry or settings merging on top.
 	 */
 	onForkSession?: (parentTurnId: string) => void;
 	/**
@@ -583,6 +583,7 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 			: {}),
 		...(deps.getSettings ? { getSettings: deps.getSettings } : {}),
 		...(deps.resources ? { resources: deps.resources } : {}),
+		...(deps.agents ? { agents: deps.agents } : {}),
 		...(deps.session ? { session: deps.session } : {}),
 		...(deps.getSessionId ? { getSessionId: deps.getSessionId } : {}),
 		...(deps.getTaskBoard ? { getTaskBoard: deps.getTaskBoard } : {}),

package/src/interactive/interactive-presentation.ts

@@ -2,6 +2,8 @@ import { performance } from "node:perf_hooks";
 import type { ClioSettings } from "../core/config.js";
 import { DEFAULT_SETTINGS } from "../core/defaults.js";
 import type { SafeEventBus } from "../core/event-bus.js";
+import type { AgentsContract } from "../domains/agents/contract.js";
+import { isUserVisibleAgent } from "../domains/agents/spec.js";
 import type { ContextState } from "../domains/context/index.js";
 import type { DispatchContract } from "../domains/dispatch/contract.js";
 import type { TaskMemoryOperatorStatus } from "../domains/memory/index.js";
@@ -12,7 +14,6 @@ import type {
 } from "../domains/observability/index.js";
 import { type ProvidersContract, resolveModelRuntimeCapabilitiesForProviders } from "../domains/providers/index.js";
 import type { ResourcesContract } from "../domains/resources/index.js";
-import { getMarketplaceSkills } from "../domains/resources/skills/marketplace.js";
 import { ceilChars, contentChars } from "../domains/session/context-accounting.js";
 import type { SessionContract, TaskBoardSnapshot } from "../domains/session/index.js";
 import type { Component, TUI } from "../engine/tui.js";
@@ -88,6 +89,7 @@ export interface InteractivePresentationDeps {
 	bootPending?: Component;
 	getSettings?: () => Readonly<ClioSettings>;
 	resources?: Pick<ResourcesContract, "skills">;
+	agents?: Pick<AgentsContract, "listSpecs">;
 	session?: Pick<SessionContract, "current">;
 	getSessionId?: () => string | null;
 	getTaskBoard?: () => TaskBoardSnapshot | null;
@@ -248,13 +250,11 @@ export function createInteractivePresentation(deps: InteractivePresentationDeps)
 		bus: deps.bus,
 		...(deps.getSettings ? { getSettings: deps.getSettings } : {}),
 	});
-	// The board settles a finished run on the same sealed receipt the transcript
-	// block reads, so the two surfaces agree on a worker's terminal answer.
-	const dispatchBoardStore = factories.createDispatchBoardStore(
-		deps.bus,
-		() => deps.dispatch.snapshot(),
-		(runId) => readWorkerReceiptFacts(runId),
-	);
+	const unbindRunReaders = deps.observability.bindRunReaders({
+		dispatchSnapshot: () => deps.dispatch.snapshot(),
+		readReceipt: (runId) => readWorkerReceiptFacts(runId),
+	});
+	const dispatchBoardStore = factories.createDispatchBoardStore(deps.observability);
 	const contextActivityStore = factories.createContextActivityStore(deps.bus);
 
 	const footerToolCounts = new Map<string, number>();
@@ -434,10 +434,52 @@ export function createInteractivePresentation(deps: InteractivePresentationDeps)
 	const editor = deps.editor ?? factories.createEditor(deps.tui, editorChrome);
 	editor.focused = true;
 	const autocomplete: AutocompleteProvider = factories.createAutocomplete({
-		listSkills: () => ({
-			installed: deps.resources?.skills(getCwd()).items ?? [],
-			marketplace: getMarketplaceSkills(),
-		}),
+		completionSources: {
+			agents: async () =>
+				(deps.agents?.listSpecs() ?? []).filter(isUserVisibleAgent).map((agent) => ({
+					id: agent.id,
+					value: agent.id,
+					label: agent.id,
+					description: agent.description,
+				})),
+			targets: async () =>
+				deps.providers.list().map(({ target, reason }) => ({
+					id: target.id,
+					value: target.id,
+					label: target.id,
+					description: reason,
+				})),
+			models: async () =>
+				deps.providers.list().flatMap(({ target, discoveredModels, discoveredModelLabels }) =>
+					[
+						...new Set([
+							...(target.defaultModel ? [target.defaultModel] : []),
+							...(target.wireModels ?? []),
+							...discoveredModels,
+						]),
+					].map((model) => ({
+						id: `${target.id}/${model}`,
+						value: model,
+						label: discoveredModelLabels?.[model] ?? model,
+						description: target.id,
+					})),
+				),
+			skills: async () =>
+				(deps.resources?.skills(getCwd()).items ?? []).map((skill) => ({
+					id: skill.name,
+					value: skill.name,
+					label: skill.name,
+					description: skill.description,
+				})),
+			tasks: async () =>
+				(deps.getTaskBoard?.()?.tasks ?? []).map((task) => ({
+					id: task.id,
+					value: task.id,
+					label: task.title,
+					description: task.status,
+				})),
+			// Other slots remain empty when this presentation has no read-only catalog for them.
+		},
 	});
 	editor.setAutocompleteProvider(autocomplete);
 
@@ -539,6 +581,7 @@ export function createInteractivePresentation(deps: InteractivePresentationDeps)
 		unsubscribeObservability();
 		contextActivityStore.unsubscribe();
 		dispatchBoardStore.unsubscribe();
+		unbindRunReaders();
 	};
 	const disposeStatus = (): void => {
 		if (statusDisposed) return;

package/src/interactive/interactive-slash-runtime.ts

@@ -24,6 +24,7 @@ import type { SessionContract, SessionEntry } from "../domains/session/index.js"
 import { foldTaskBoard } from "../domains/session/task-board.js";
 import { filterEntriesToActivePath } from "../domains/session/tree/active-path.js";
 import type { ShareContract } from "../domains/share/index.js";
+import type { UserTaskAcceptance } from "../domains/user-tasks/acceptance.js";
 import type { UserTasksStore } from "../domains/user-tasks/store.js";
 import { stripTerminalSequences } from "../engine/tui.js";
 import type { ImageContent } from "../engine/types.js";
@@ -432,7 +433,7 @@ export function createInteractiveSlashRuntime(deps: InteractiveSlashRuntimeDeps)
 		...(userTasks
 			? {
 					userTasks: {
-						add: (title: string) => userTasks.add(title),
+						add: (title: string, acceptance?: UserTaskAcceptance) => userTasks.add(title, undefined, acceptance),
 						hand: (id: string) => userTasks.hand(id, deps.chat.getSessionId() ?? undefined),
 						done: (id: string) => userTasks.done(id),
 						drop: (id: string) => userTasks.drop(id),

package/src/interactive/oracle.ts

@@ -13,6 +13,7 @@
  */
 
 import type { OracleResult } from "../domains/agents/index.js";
+import { decisionRationale } from "../domains/session/decision-board.js";
 import type { DecisionLedgerEntry } from "../domains/session/entries.js";
 import type { TaskBoardTask } from "../domains/session/task-board.js";
 
@@ -89,12 +90,14 @@ function clamp(text: string, maxBytes: number): { text: string; truncated: boole
 
 /** One decision line. Superseded decisions carry their correction so a reversal is visible. */
 function decisionLine(decision: DecisionLedgerEntry["decisions"][number]): string {
+	const argument = decisionRationale(decision);
+	const details = argument ? `\n  ${argument}` : "";
 	const label = decision.label ? ` (${decision.label})` : "";
 	if (decision.status === "superseded") {
 		const correction = decision.correction ? `; corrected to ${decision.correction}` : "";
-		return `- ${decision.key}${label}: ${decision.value} [superseded${correction}]`;
+		return `- ${decision.key}${label}: ${decision.value} [superseded${correction}]${details}`;
 	}
-	return `- ${decision.key}${label}: ${decision.value}`;
+	return `- ${decision.key}${label}: ${decision.value}${details}`;
 }
 
 function taskLine(task: TaskBoardTask): string {

package/src/interactive/overlays/fleet-run-approval.ts

@@ -21,6 +21,7 @@ import {
 	wrapTextWithAnsi,
 } from "../../engine/tui.js";
 import type { FleetRunPreview, FleetRunPreviewStep } from "../fleet-run-preview.js";
+import { formatUsd } from "../footer/widgets.js";
 import { buildResponsiveHint, FocusBox, showClioOverlayFrame } from "../overlay-frame.js";
 import { clioTheme, rule } from "../theme/index.js";
 
@@ -83,12 +84,12 @@ function formatFleetRunPreviewStep(step: FleetRunPreviewStep): string {
 	return `agent ${step.stepId}${loop} · ${step.agentId ?? "?"} · ${route}${node}${declaredRoute}${gate}${dynamicPlan} · ${step.scope} · ${formatWriteBoundary(step.writes)}`;
 }
 
-function formatBudgetLine(preview: FleetRunPreview): string {
+export function formatBudgetLine(preview: FleetRunPreview): string {
 	const contract =
 		preview.budget.contractUsd === null
 			? "contract declares no ceiling"
 			: `contract ceiling $${preview.budget.contractUsd.toFixed(2)}`;
-	return `budget: admitted under $${preview.budget.ceilingUsd.toFixed(2)} session ceiling, $${preview.budget.currentUsd.toFixed(4)} spent, ${contract}`;
+	return `budget: admitted under $${preview.budget.ceilingUsd.toFixed(2)} session ceiling, ${formatUsd(preview.budget.currentUsd)} spent, ${contract}`;
 }
 
 /**

package/src/interactive/overlays/message-picker.ts

@@ -25,8 +25,8 @@ const PREVIEW_WIDTH = 60;
  * calls onFork(parentTurnId); the caller wires that through
  * SessionContract.fork(parentTurnId).
  *
- * Phase 12 slice 12b-3 scope: current-session turns only. Multi-session picker
- * lives in a later slice once TreeSnapshot grows a payload preview field.
+ * Scope: current-session turns only. A multi-session picker is not
+ * implemented; it would need TreeSnapshot to carry a payload preview field.
  */
 export interface OpenMessagePickerOverlayDeps {
 	session: SessionContract;

package/src/interactive/overlays/settings.ts

@@ -600,10 +600,10 @@ const SETTINGS_VALUE_HELP_BY_ID: Partial<Record<EditableSettingId, Record<string
 		false: "context is only compacted when you run /context compact",
 	},
 	// `embedded` is a declared rung with no implementation behind it yet; it
-	// runs as `auto` until Clio can own a pane host, and the hint says so.
+	// refuses until Clio can own a pane host, and the hint says so.
 	"panes.enabled": {
 		auto: "detect a herdr session and join it as a guest; no pane host, no panes",
-		embedded: "not implemented yet; behaves as auto (guest mode inside herdr) until Clio can own a pane host",
+		embedded: "not implemented yet; use auto or guest",
 		off: "never detect or open a pane",
 	},
 	"retry.enabled": {

package/src/interactive/overlays/tree-selector.ts

@@ -16,14 +16,14 @@ export const TREE_OVERLAY_WIDTH = 88;
 const VISIBLE_ROWS = 16;
 
 /**
- * /tree navigator overlay. Phase 12 slice 12b-2 behaviors only:
+ * /tree navigator overlay. Behaviors:
  *   - One row per node, indented two spaces per branch level (not per message)
  *   - Shift+T toggles operator-local timestamps on/off
  *   - `e` enters label edit submode (Enter commits, Esc cancels)
  *   - Enter on a row switches the active append point to that turn id
  *   - Esc closes the overlay
  *
- * Cwd-toggle (`p`) and sort-order (`s`) land in Phase 18.
+ * Cwd-toggle (`p`) and sort-order (`s`) are not implemented.
  *
  * The overlay queries `session.tree()` on open and after any mutation so
  * label edits are reflected without a close/reopen cycle.

package/src/interactive/renderers/branch-summary.ts

@@ -1,5 +1,5 @@
 /**
- * Renderer for BranchSummary session entries (Phase 12 / slice 12b).
+ * Renderer for BranchSummary session entries.
  *
  * A branchSummary entry is produced when a fork inherits a compacted parent
  * context: the new session opens with a single summary block standing in for

package/src/interactive/slash-autocomplete.ts

@@ -69,16 +69,14 @@ export interface SlashCompletionItem extends AutocompleteItem {
 export interface SlashAutocompleteOptions {
 	basePath?: string;
 	fdPath?: string | null;
-	/** Slice 11 replaces the named no-op sources with read-only runtime sources. */
+	/** Read-only runtime values for the named grammar slots. */
 	completionSources?: CompletionSources;
 	/** Replace the default workspace-aware `@` source without adding a second composer provider. */
 	fileReferenceSource?: FileReferenceCompletionSource;
-	/** @deprecated Dynamic skill values move to the named `skills` slot in slice 11. */
-	listSkills?: () => unknown;
 }
 
-/** Complete provider surface now, deliberately inert until slice 11 wiring. */
-function stubCompletionSources(): Record<CompletionSlotName, CompletionSource> {
+/** Slots without an in-app source return no dynamic values. */
+function emptyCompletionSources(): Record<CompletionSlotName, CompletionSource> {
 	const sources = {} as Record<CompletionSlotName, CompletionSource>;
 	for (const slot of COMPLETION_SLOT_NAMES) sources[slot] = async () => [];
 	return sources;
@@ -308,7 +306,7 @@ class ClioAutocompleteProvider implements AutocompleteProvider {
 	) {
 		this.files = new CombinedAutocompleteProvider([], basePath, fdPath);
 		this.fileReferences = fileReferenceSource ?? createFileReferenceCompletionSource({ basePath });
-		this.sourceBySlot = { ...stubCompletionSources(), ...sources };
+		this.sourceBySlot = { ...emptyCompletionSources(), ...sources };
 	}
 
 	async getSuggestions(

package/src/interactive/slash-commands.ts

@@ -1,3 +1,4 @@
+import { acceptanceFromTaskFlags } from "../cli/tasks.js";
 import { BusChannels } from "../core/bus-events.js";
 import { THINKING_LEVELS } from "../core/defaults.js";
 import type { SafeEventBus } from "../core/event-bus.js";
@@ -30,6 +31,7 @@ import type {
 } from "../domains/resources/index.js";
 import { parseSkillCommand, SKILL_SURFACE_CLEAR_ARG } from "../domains/resources/index.js";
 import type { ShareImportPlan } from "../domains/share/index.js";
+import type { UserTaskAcceptance } from "../domains/user-tasks/acceptance.js";
 import type { UserTask } from "../domains/user-tasks/store.js";
 import type { ExtensionReloadOutcome } from "../entry/extension-reload.js";
 import { isToolProfileName, TOOL_PROFILE_NAMES, type ToolProfileName } from "../tools/profiles.js";
@@ -146,7 +148,7 @@ type SlashCommandVariant =
 	| { kind: "context-view" }
 	| { kind: "tasks" }
 	| { kind: "decisions" }
-	| { kind: "tasks-add"; text: string }
+	| { kind: "tasks-add"; text: string; expectedOutputs?: string[]; verification?: string[] }
 	| { kind: "tasks-hand"; id: string }
 	| { kind: "tasks-done"; id: string }
 	| { kind: "tasks-drop"; id: string }
@@ -690,7 +692,7 @@ export interface SlashCommandContext {
 	openDecisions: () => void;
 	/** Project-scoped operator task inbox backing `/tasks` mutations. */
 	userTasks?: {
-		add(title: string): UserTask;
+		add(title: string, acceptance?: UserTaskAcceptance): UserTask;
 		hand(id: string): UserTask;
 		done(id: string): UserTask;
 		drop(id: string): UserTask;
@@ -790,9 +792,10 @@ function formatReceiptVerificationBlock(runId: string, result: SlashReceiptVerif
 }
 
 /** The one operator-authored turn used by slash and overlay handoff paths. */
-export function formatUserTaskHandoff(task: Pick<UserTask, "id" | "title" | "note">): string {
+export function formatUserTaskHandoff(task: Pick<UserTask, "id" | "title" | "note" | "acceptance">): string {
 	const note = task.note ? ` ${task.note}.` : "";
-	return `Operator task ${task.id}: ${task.title}.${note} Pick it up with tasks action="pick" id="${task.id}" and work it when appropriate.`;
+	const acceptance = task.acceptance ? ` Acceptance: ${JSON.stringify(task.acceptance)}.` : "";
+	return `Operator task ${task.id}: ${task.title}.${note}${acceptance} Pick it up with tasks action="pick" id="${task.id}" and work it when appropriate.`;
 }
 
 /** The verb a command performs, in the order /help lists the groups. */
@@ -1519,7 +1522,14 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 		},
 		args: {
 			subcommands: {
-				add: { positionals: [{ name: "text", required: true, rest: true }] },
+				add: {
+					parseFlagsInRest: true,
+					flags: [
+						{ name: "--expect", takesValue: true, repeatable: true, valueName: "path" },
+						{ name: "--verify", takesValue: true, repeatable: true, valueName: "checkId[:timeoutMs]" },
+					],
+					positionals: [{ name: "text", required: true, rest: true }],
+				},
 				hand: { positionals: [{ name: "id", required: true }] },
 				done: { positionals: [{ name: "id", required: true }] },
 				drop: { positionals: [{ name: "id", required: true }] },
@@ -1530,7 +1540,12 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 			switch (parsed.subcommand) {
 				case "add":
 					return parsed.rest
-						? { kind: "tasks-add", text: parsed.rest }
+						? {
+								kind: "tasks-add",
+								text: parsed.rest,
+								...(parsed.flagValues.has("--expect") ? { expectedOutputs: parsed.flagValues.get("--expect") ?? [] } : {}),
+								...(parsed.flagValues.has("--verify") ? { verification: parsed.flagValues.get("--verify") ?? [] } : {}),
+							}
 						: { kind: "usage-error", command: "tasks", reason: "add requires task text" };
 				case "hand":
 				case "done":
@@ -1558,7 +1573,10 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 			}
 			try {
 				if (command.kind === "tasks-add") {
-					const task = ctx.userTasks.add(command.text);
+					const task = ctx.userTasks.add(
+						command.text,
+						acceptanceFromTaskFlags(process.cwd(), command.expectedOutputs ?? [], command.verification ?? []),
+					);
 					ctx.notice("success", `logged operator task ${task.id}: ${task.title}`);
 					return;
 				}
@@ -2142,32 +2160,6 @@ const COMMAND_SHAPED_TOKEN = /^[A-Za-z][A-Za-z0-9:-]*$/u;
  */
 const COMMAND_ESCAPE = "\\/";
 
-const RETIRED_COMMAND_HINTS: Readonly<Record<string, string>> = Object.freeze({
-	status: "Use the footer or Alt+U for status; /cost, /context, and /fleet inspect their own domains.",
-	receipts: "Use /view or /view verify <run-id>.",
-	"context-init": "Use /context init.",
-	"context-clear": "Use /context reset for project context or /new for a fresh session.",
-	"context-view": "Use /context.",
-	compact: "Use /context compact [instructions].",
-	skills: "Use /skill or /resources skills.",
-	exit: "Use /quit.",
-	config: "Use /settings.",
-	ctx: "Use /context.",
-	models: "Use /model.",
-	clear: "Use /new for a fresh session or /context reset for project context.",
-	library: "Use /resources library [kind].",
-	prompts: "Use /resources prompts.",
-	extensions: "Use /resources extensions.",
-	interop: "Use /agents connect.",
-	targets: "Use /settings targets.",
-	"scoped-models": "Use /settings chat model-picker.",
-});
-
-function retiredCommandHint(token: string): string | undefined {
-	if (/^skills?:[^\s]+$/u.test(token)) return "Use /skill <name> [task].";
-	return RETIRED_COMMAND_HINTS[token];
-}
-
 /** Pure slash-command parser: no I/O, no side effects. Walks the registry in order. */
 /**
  * One notice line for a reload outcome. Success when the generation committed
@@ -2230,12 +2222,6 @@ export function dispatchSlashCommand(command: SlashCommand, ctx: SlashCommandCon
 		return "accepted";
 	}
 	if (command.kind === "unknown-command") {
-		const retiredHint = retiredCommandHint(command.token);
-		if (retiredHint) {
-			ctx.notice("error", `/${command.token} is retired and did not run. ${retiredHint}`);
-			ctx.render();
-			return "rejected";
-		}
 		// The registry does not own the token, but a prompt template might. The
 		// parser stays pure, so the lookup happens here, and only for a spelling
 		// that matched no command: `/name` is how every other agent invokes the

package/src/interactive/slash-spec.ts

@@ -72,6 +72,8 @@ export interface CommandArgsSpec {
 	 * keep their byte-for-byte parsing.
 	 */
 	parseFlagsBeforeRest?: boolean;
+	/** Recognize flags throughout a rest positional (operator task acceptance). */
+	parseFlagsInRest?: boolean;
 }
 
 export interface ParsedArgs {
@@ -260,6 +262,32 @@ export function parseArgs(spec: CommandArgsSpec, argsLine: string): ParsedArgs {
 	while (index < argsLine.length) {
 		const currentPositionalSpec = positionalSpecs[positionalIndex];
 		if (currentPositionalSpec?.rest) {
+			if (currentSpec.parseFlagsInRest) {
+				const text: string[] = [];
+				while (index < argsLine.length) {
+					const start = index;
+					const read = readToken();
+					if (!read) break;
+					if (read.token === "--") {
+						text.push(argsLine.slice(index).trim());
+						index = argsLine.length;
+						break;
+					}
+					const flag = flagSpecs.find((item) => item.name === read.token);
+					if (flag) {
+						const error = consumeFlag(flag, read.token);
+						if (error) return errorResult(error);
+					} else if (read.token.startsWith("--")) return errorResult(`Unknown flag: ${read.token}`);
+					else text.push(argsLine.slice(start, index));
+					skipWhitespace();
+				}
+				const restVal = text.join(" ").trim();
+				if (!restVal) return errorResult(`Missing required argument: ${currentPositionalSpec.name}`);
+				positionals.push(restVal);
+				rest = restVal;
+				positionalIndex++;
+				break;
+			}
 			if (currentSpec.parseFlagsBeforeRest) {
 				while (index < argsLine.length) {
 					const tokenStart = index;

package/src/interactive/view/artifacts.ts

@@ -1382,6 +1382,8 @@ function renderAccountabilitySummary(summary: AccountabilitySummary): string[] {
 		"# Accountability",
 		"",
 		`first-pass success: ${summary.firstPassRuns}/${summary.totalRuns} (${pct}%)`,
+		`unverified successes: ${summary.unverifiedSuccesses}`,
+		`ungrounded claims: ${summary.ungroundedClaims}`,
 		"",
 		"## Top failure causes",
 		"",

package/src/interactive/worker-stream.ts

@@ -9,7 +9,7 @@
  * I/O, so every sequence below is testable as a pure fold.
  *
  * What a worker is saying and doing is not decided here. That is the canonical
- * {@link WorkerProgressSnapshot} projection in `worker-progress.ts`, which the
+ * {@link WorkerProgressSnapshot} projection in `src/domains/observability/worker-progress.ts`, which the
  * Fleet Runs board reads from the same events, so the two surfaces cannot drift
  * on the answer tail, the tool names, or what a call is touching. This module
  * owns the half the board has no use for: which assignment an event belongs to,
@@ -43,14 +43,18 @@ import type {
 } from "../core/bus-events.js";
 import type { RunKind } from "../domains/dispatch/types.js";
 import type { CanonicalTrustStatus } from "../domains/evidence/trust-status.js";
+import {
+	createWorkerProgressFold,
+	type WorkerProgressFold,
+	type WorkerProgressSnapshot,
+} from "../domains/observability/worker-progress.js";
 import type { WorkerRunOrigin, WorkerRunRuntime, WorkerRunRuntimeKind } from "../domains/session/index.js";
-import { createWorkerProgressFold, type WorkerProgressFold, type WorkerProgressSnapshot } from "./worker-progress.js";
 
 export {
 	boundSettledText,
 	WORKER_LIVE_TAIL_LINES,
 	WORKER_TOOL_NAME_LIMIT,
-} from "./worker-progress.js";
+} from "../domains/observability/worker-progress.js";
 export type { WorkerProgressSnapshot };
 
 export interface WorkerAttempt {

package/src/tools/bootstrap.ts

@@ -5,6 +5,7 @@ import type { DispatchContract } from "../domains/dispatch/contract.js";
 import type { AgentRoleFactsResolver } from "../domains/dispatch/execution-role.js";
 import type { PanesOperations } from "../domains/mux/operations.js";
 import type { AutonomyLevel } from "../domains/safety/autonomy.js";
+import type { DecisionLedgerEntry } from "../domains/session/entries.js";
 import { builtin, toolPromptHintsForNames } from "./builtin-tool-catalog.js";
 import type { CompeteMuxWorktrees } from "./compete-worktrees.js";
 import { assertRegisteredBuiltinTools, type CoreToolBootstrapDeps, registerCoreTools } from "./core-bootstrap.js";
@@ -31,6 +32,8 @@ export interface ToolBootstrapDeps extends CoreToolBootstrapDeps {
 	/** Which optional `dispatch` schema blocks this session advertises; absent means every block. */
 	getDispatchSchemaComposition?: () => DispatchSchemaComposition;
 	dispatchBackground?: DispatchBackgroundRegistry;
+	/** Live decision board snapshot; dispatch seals its active refs onto every request. */
+	getDecisionBoard?: () => ReadonlyArray<DecisionLedgerEntry>;
 	/** Optional herdr worktree lifecycle for compete candidates. */
 	competeMuxWorktrees?: CompeteMuxWorktrees;
 	/**
@@ -66,6 +69,7 @@ export function registerAllTools(registry: ToolRegistry, deps: ToolBootstrapDeps
 			...(deps.getWorkerRosters ? { getWorkerRosters: deps.getWorkerRosters } : {}),
 			...(deps.getDispatchSchemaComposition ? { getSchemaComposition: deps.getDispatchSchemaComposition } : {}),
 			...(deps.dispatchBackground ? { background: deps.dispatchBackground } : {}),
+			...(deps.getDecisionBoard ? { getDecisionBoard: deps.getDecisionBoard } : {}),
 			...(deps.competeMuxWorktrees ? { competeWorktrees: { mux: deps.competeMuxWorktrees } } : {}),
 		};
 		registry.register({

package/src/tools/builtin-tool-catalog.ts

@@ -45,6 +45,13 @@ const exactMutationPolicy = {
 // declares its posture explicitly.
 const TOOL_METADATA: Readonly<Record<string, ToolMetadata>> = {
 	// OBSERVE: read-class, parallel, envelope + shared turn budget.
+	[ToolNames.Evidence]: {
+		objective: "Inspect canonical evidence, trust status, gate decisions, and findings.",
+		uiLabel: "Evidence",
+		retrySafety: "idempotent",
+		resultSizePolicy: summaryPolicy("Inspect one run with evidence(mode=run, runId=<id>) to narrow the output."),
+		costLatency: "local_medium",
+	},
 	[ToolNames.Read]: {
 		objective: "Read exact UTF-8 file content with line and byte bounds.",
 		uiLabel: "Read",
@@ -240,6 +247,30 @@ const TOOL_METADATA: Readonly<Record<string, ToolMetadata>> = {
 		promptHint:
 			'When the operator asks to see a dispatched agent ("show me the tester"), call panes(action="show", target=<agent id>).',
 	},
+	[ToolNames.Limitation]: {
+		objective: "Record what the turn could not verify and why as a ledger receipt.",
+		uiLabel: "Limitation",
+		retrySafety: "idempotent",
+		resultSizePolicy: {
+			kind: "exact",
+			maxBytes: 4_096,
+			followUpHint: "Call limitation again with a narrower scope if the first call was rejected.",
+		},
+		costLatency: "local_fast",
+	},
+	[ToolNames.Decide]: {
+		objective: "Record a design decision with its rejected alternatives and rationale on the session decision board.",
+		uiLabel: "Decide",
+		// A repeated call with the same key supersedes the earlier record, so
+		// the surface as a whole is not retry safe.
+		retrySafety: "not_retry_safe",
+		resultSizePolicy: {
+			kind: "exact",
+			maxBytes: 4_096,
+			followUpHint: "The decision ref in the result is what receipts and commits cite.",
+		},
+		costLatency: "local_fast",
+	},
 	// RETRIEVE: network-class.
 	[ToolNames.WebFetch]: {
 		objective: "Fetch HTTP(S) text for explicit external research.",

package/src/tools/compete-worktrees.ts

@@ -616,7 +616,13 @@ export async function createCandidateWorktreeMapped(
  * builder changed nothing (an empty candidate is a legitimate ranking fact).
  */
 export function commitCandidateWork(worktree: CandidateWorktree, message: string): boolean {
-	return commitWorktreePath(worktree.path, COMPETE_COMMIT_IDENTITY, message);
+	// Context reads refresh these runtime files even in a read-only worker.
+	// The caller's pending .gitignore update is not part of the candidate base;
+	// exclude the exact files, while keeping operator-owned project assets.
+	return commitWorktreePath(worktree.path, COMPETE_COMMIT_IDENTITY, message, [
+		".clio-coder/codewiki.json",
+		".clio-coder/state.json",
+	]);
 }
 
 /** One-line stat summary of what a candidate branch changed relative to HEAD. */

package/src/tools/core-bootstrap.ts

@@ -1,6 +1,7 @@
 import type { ContextRecalledPayload } from "../core/bus-events.js";
 import type { LoadSkillsInput } from "../domains/resources/index.js";
 import type { SessionContract } from "../domains/session/contract.js";
+import type { DecisionBoardStore } from "../domains/session/decision-board.js";
 import type { SessionEntry } from "../domains/session/entries.js";
 import { createTaskBoardStore, type TaskBoardStore } from "../domains/session/task-board.js";
 import type { UserTasksStore } from "../domains/user-tasks/store.js";
@@ -12,11 +13,14 @@ import { builtin } from "./builtin-tool-catalog.js";
 import { codeNavToolSurface } from "./codewiki/code-nav-surface.js";
 import { contextToolSurface } from "./context/surface.js";
 import { credentialPresentTool } from "./credential-present.js";
+import { createDecideTool } from "./decide.js";
 import { editTool } from "./edit.js";
+import { evidenceTool } from "./evidence.js";
 import { findTool } from "./find.js";
 import { grepTool } from "./grep.js";
 import { lazyTool } from "./lazy-tool.js";
 import { createLedgerTool } from "./ledger.js";
+import { limitationTool } from "./limitation.js";
 import { lsTool } from "./ls.js";
 import { networkToolsDisabled } from "./network-policy.js";
 import { assertBuiltinToolPolicy } from "./policy.js";
@@ -36,6 +40,8 @@ export interface CoreToolBootstrapDeps {
 	onContextRecalled?: (payload: ContextRecalledPayload) => void;
 	askUser?: AskUserHandler;
 	taskBoard?: TaskBoardStore;
+	/** The session decision board the `decide` tool appends to; absent in worker registries, where the tool refuses. */
+	decisionBoard?: DecisionBoardStore;
 	userTasks?: UserTasksStore;
 	agentLedger?: AgentLedgerPort;
 	/**
@@ -65,6 +71,7 @@ export interface CoreToolRegistration {
 
 export function registerCoreTools(registry: ToolRegistry, deps: CoreToolBootstrapDeps = {}): CoreToolRegistration {
 	const includeNetworkTools = !networkToolsDisabled();
+	registry.register(builtin(evidenceTool, { path: "src/tools/evidence.ts", scope: "core" }));
 	registry.register({
 		...builtin(readTool, { path: "src/tools/read.ts", scope: "core" }),
 	});
@@ -125,6 +132,15 @@ export function registerCoreTools(registry: ToolRegistry, deps: CoreToolBootstra
 	registry.register({
 		...builtin(credentialPresentTool, { path: "src/tools/credential-present.ts", scope: "core" }),
 	});
+	registry.register({
+		...builtin(limitationTool, { path: "src/tools/limitation.ts", scope: "core" }),
+	});
+	registry.register({
+		...builtin(createDecideTool(deps.decisionBoard ? { decisionBoard: deps.decisionBoard } : {}), {
+			path: "src/tools/decide.ts",
+			scope: "core",
+		}),
+	});
 	const session = deps.session;
 	const readSessionEntries = deps.readSessionEntries;
 	registry.register({