@iowarp/clio-coder 0.4.2 → 0.4.4

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

@@ -1,10 +1,12 @@
+import { randomUUID } from "node:crypto";
 import type { AskUserToolPolicy } from "../../tools/registry.js";
 import type { AutonomyExposure } from "../safety/autonomy.js";
-import type { DecisionLedgerEntry, DecisionRecord } from "./entries.js";
+import { type DecisionLedgerEntry, type DecisionRecord, decisionRef } from "./entries.js";
 
 export interface DecisionLedgerEntryFields {
 	kind: "decisionLedger";
 	parentTurnId: string;
+	origin?: "interview" | "agent";
 	interviewId: string;
 	interviewStatus: "complete" | "cancelled";
 	startedAt: string;
@@ -28,11 +30,35 @@ export interface DecisionBoardStoreDeps {
 	now?: () => Date;
 }
 
+/** One design choice the model records itself through the `decide` tool. */
+export interface AgentDecisionInput {
+	key: string;
+	value: string;
+	alternatives: ReadonlyArray<string>;
+	rationale: string;
+	label?: string;
+}
+
+export interface AgentDecisionOutcome {
+	/** The appended agent decision set; `decisionRef(entry.interviewId, key)` cites it. */
+	entry: DecisionLedgerEntryFields;
+	/** The earlier active record with the same key that this decision superseded, when there was one. */
+	superseded: { interviewId: string; key: string } | null;
+}
+
 export interface DecisionBoardStore {
 	/** Latest snapshot per interview, newest interview first. */
 	snapshot(): ReadonlyArray<DecisionLedgerEntry>;
 	/** Persist the one host-finalized snapshot for a settled interview. */
 	recordFinalizedInterview(policy: AskUserToolPolicy): boolean;
+	/**
+	 * Append one agent-recorded decision as its own complete set
+	 * (`origin: "agent"`, `interviewId: "agent:<uuid>"`, `roundCount: 0`). An
+	 * earlier active agent decision with the same key is superseded first with
+	 * the new rationale as its correction. An active operator decision with the
+	 * same key is never overwritten by the model; that throws.
+	 */
+	recordAgentDecision(input: AgentDecisionInput): AgentDecisionOutcome;
 	/** Append an operator revision snapshot anchored to the active branch leaf. */
 	supersede(interviewId: string, key: string, correction?: string): DecisionLedgerEntryFields;
 	/** Force the next read to refold, including after a same-session tree switch. */
@@ -90,6 +116,24 @@ function finalizedInterviewEntryFields(policy: AskUserToolPolicy): DecisionLedge
 	};
 }
 
+/** Most decision refs one dispatch request, envelope, or receipt carries. */
+export const DECISION_REFS_CAP = 32;
+
+/**
+ * Refs of every active decision on a board snapshot, sorted and capped at
+ * {@link DECISION_REFS_CAP}. Dispatch seals this onto each request it builds;
+ * an empty board yields an empty list, which callers leave off the request.
+ */
+export function activeDecisionRefs(board: ReadonlyArray<DecisionLedgerEntry>): string[] {
+	const refs = new Set<string>();
+	for (const entry of board) {
+		for (const decision of entry.decisions) {
+			if (decision.status === "active") refs.add(decisionRef(entry.interviewId, decision.key));
+		}
+	}
+	return [...refs].sort().slice(0, DECISION_REFS_CAP);
+}
+
 function isDecisionLedgerEntry(value: unknown): value is DecisionLedgerEntry {
 	return !!value && typeof value === "object" && (value as { kind?: unknown }).kind === "decisionLedger";
 }
@@ -143,7 +187,7 @@ export function createDecisionBoardStore(deps: DecisionBoardStoreDeps = {}): Dec
 		dirty = true;
 	};
 
-	return {
+	const store: DecisionBoardStore = {
 		snapshot(): ReadonlyArray<DecisionLedgerEntry> {
 			syncToSession();
 			return interviews;
@@ -154,6 +198,51 @@ export function createDecisionBoardStore(deps: DecisionBoardStoreDeps = {}): Dec
 			append(entry);
 			return true;
 		},
+		recordAgentDecision(input: AgentDecisionInput): AgentDecisionOutcome {
+			syncToSession();
+			let superseded: AgentDecisionOutcome["superseded"] = null;
+			for (const interview of interviews) {
+				const prior = interview.decisions.find((decision) => decision.key === input.key && decision.status === "active");
+				if (prior === undefined) continue;
+				if (interview.origin !== "agent" || prior.source !== "agent") {
+					throw new Error(
+						`decision board: '${input.key}' is an operator decision (${interview.interviewId}); it can only be revised through ask_user`,
+					);
+				}
+				superseded = { interviewId: interview.interviewId, key: prior.key };
+				break;
+			}
+			if (superseded !== null) store.supersede(superseded.interviewId, superseded.key, input.rationale);
+			const now = (deps.now?.() ?? new Date()).toISOString();
+			const entries = deps.readEntries?.() ?? [];
+			const parentTurnId = deps.getActiveLeafTurnId?.() ?? activeLeafFromEntries(entries);
+			if (!parentTurnId) throw new Error("decision board: no active branch leaf is available for the decision");
+			const entry: DecisionLedgerEntryFields = {
+				kind: "decisionLedger",
+				parentTurnId,
+				origin: "agent",
+				interviewId: `agent:${randomUUID()}`,
+				interviewStatus: "complete",
+				startedAt: now,
+				endedAt: now,
+				roundCount: 0,
+				exposure: "local",
+				decisions: [
+					{
+						key: input.key,
+						value: input.value,
+						...(input.label ? { label: input.label } : {}),
+						status: "active",
+						decidedAt: now,
+						source: "agent",
+						alternatives: [...input.alternatives],
+						rationale: input.rationale,
+					},
+				],
+			};
+			append(entry);
+			return { entry, superseded };
+		},
 		supersede(interviewId: string, key: string, correction?: string): DecisionLedgerEntryFields {
 			syncToSession();
 			const interview = interviews.find((candidate) => candidate.interviewId === interviewId);
@@ -191,4 +280,14 @@ export function createDecisionBoardStore(deps: DecisionBoardStoreDeps = {}): Dec
 			dirty = true;
 		},
 	};
+	return store;
+}
+
+/** Preserve the recorded argument wherever a decision is carried into another prompt. */
+export function decisionRationale(decision: DecisionRecord): string | undefined {
+	const parts: string[] = [];
+	if (decision.alternatives?.length) parts.push(`Alternatives: ${decision.alternatives.join("; ")}`);
+	if (decision.rationale) parts.push(`Rationale: ${decision.rationale}`);
+	if (parts.length > 0) return parts.join(". ");
+	return decision.source_question ?? decision.correction;
 }

package/src/domains/session/entries.ts

@@ -5,10 +5,13 @@
  * carries its `kind` discriminant, a `turnId` (uuid v7 where possible so
  * entries sort by creation), a parent pointer, and an ISO timestamp.
  *
- * Later slices extend this union:
- *   - compactionSummary is produced by compaction/compact.ts (slice 12c).
- *   - branchSummary is produced by the fork path (slice 12b).
- *   - bashExecution / fileEntry become the wire shape for Phase 14 extensions.
+ * Non-message kinds and where they come from:
+ *   - compactionSummary is produced by compaction/compact.ts.
+ *   - branchSummary is produced by the fork path.
+ *   - bashExecution is produced by the editor bash path
+ *     (interactive/editor-bash.ts).
+ *   - fileEntry is consumed by the renderer, compaction, handoff, and
+ *     evidence builders but has no in-tree producer.
  */
 
 import { isSkillActivation, type SkillActivation } from "../../core/skill-activation.js";
@@ -101,6 +104,10 @@ export type CompactionTrigger = "auto" | "force" | "overflow";
  * `usage` carries and the ledger usage fold reads both from one place.
  */
 export interface CompactionUsage {
+	/** Executing route; absent on legacy checkpoints that used the active chat model. */
+	targetId?: string;
+	/** Requested wire model ID, not a verified physical backend identity. */
+	modelId?: string;
 	input: number;
 	output: number;
 	cacheRead: number;
@@ -209,6 +216,14 @@ export interface TaskLedgerEntry extends BaseSessionEntry {
 
 export type DecisionStatus = "active" | "superseded";
 
+/**
+ * Who settled a decision. `operator` is an answer the operator gave in an
+ * `ask_user` interview. `agent` is a design choice the model recorded itself
+ * through the `decide` tool, with the alternatives it rejected and why. Absent
+ * on entries written before agent decisions existed, which were all operator.
+ */
+export type DecisionSource = "operator" | "agent";
+
 export interface DecisionRecord {
 	key: string;
 	value: string;
@@ -218,11 +233,33 @@ export interface DecisionRecord {
 	decidedAt: string;
 	revisedAt?: string;
 	correction?: string;
+	source?: DecisionSource;
+	/** Options considered and not taken. Only agent decisions carry these. */
+	alternatives?: string[];
+	/** Why `value` won over `alternatives`. Only agent decisions carry this. */
+	rationale?: string;
+}
+
+/**
+ * Stable reference to one decision: `<interviewId>/<key>`. Both halves are
+ * already unique on the active path, so the pair needs no third id. Run
+ * envelopes, receipts, and commit trailers cite decisions by this string.
+ */
+export type DecisionRef = string;
+
+export function decisionRef(interviewId: string, key: string): DecisionRef {
+	return `${interviewId}/${key}`;
 }
 
-/** One complete, branch-anchored snapshot of a settled operator interview. */
+/**
+ * One complete, branch-anchored snapshot of a settled decision set. An
+ * `interview` origin is an operator `ask_user` round; an `agent` origin is a
+ * set the model recorded with the `decide` tool, where `interviewId` is the
+ * agent decision set id and `roundCount` is 0. Absent origin means interview.
+ */
 export interface DecisionLedgerEntry extends BaseSessionEntry {
 	kind: "decisionLedger";
+	origin?: "interview" | "agent";
 	interviewId: string;
 	interviewStatus: "complete" | "cancelled";
 	startedAt: string;
@@ -499,11 +536,14 @@ function isTaskLedgerEvidence(value: unknown): value is TaskLedgerValidationEvid
 	);
 }
 
-function isDecisionRecord(value: unknown): value is DecisionRecord {
+export function isDecisionRecord(value: unknown): value is DecisionRecord {
 	if (!isRecord(value)) return false;
-	if (!isString(value.key) || !/^[a-z0-9]+(?:_[a-z0-9]+)*$/.test(value.key)) return false;
+	if (!isString(value.key) || !/^[a-z0-9]+(?:[_-][a-z0-9]+)*$/.test(value.key)) return false;
 	if (!isString(value.value) || !isOneOf(value.status, DECISION_STATUSES) || !isString(value.decidedAt)) return false;
 	if (!isOptionalString(value.label) || !isOptionalString(value.source_question)) return false;
+	if (value.source !== undefined && !isOneOf(value.source, ["operator", "agent"])) return false;
+	if (value.alternatives !== undefined && !isStringArray(value.alternatives)) return false;
+	if (!isOptionalString(value.rationale)) return false;
 	if (!isOptionalString(value.revisedAt) || !isOptionalString(value.correction)) return false;
 	return value.status === "superseded"
 		? isString(value.revisedAt)
@@ -515,6 +555,8 @@ function isOptionalCompactionUsage(value: unknown): boolean {
 	if (!isRecord(value)) return false;
 	const cost = value.cost;
 	return (
+		isOptionalString(value.targetId) &&
+		isOptionalString(value.modelId) &&
 		isNumber(value.input) &&
 		isNumber(value.output) &&
 		isNumber(value.cacheRead) &&
@@ -636,6 +678,7 @@ export function isSessionEntry(value: unknown): value is SessionEntry {
 			);
 		case "decisionLedger":
 			return (
+				(v.origin === undefined || isOneOf(v.origin, ["interview", "agent"])) &&
 				isString(v.interviewId) &&
 				isOneOf(v.interviewStatus, DECISION_INTERVIEW_STATUSES) &&
 				isString(v.startedAt) &&

package/src/domains/session/extension.ts

@@ -282,10 +282,10 @@ export function createSessionBundle(context: DomainContext): DomainBundle<Sessio
 			return snapshotFor(id);
 		},
 		switchBranch(sessionId) {
-			// /tree-driven branch switch currently delegates to resume. Kept as a
-			// distinct contract method so later slices can layer telemetry or
-			// chat-loop rewiring without changing resume's semantics. Same
-			// open-before-close ordering as resume() above and for the same reason.
+			// /tree-driven branch switch delegates to resume. Kept as a distinct
+			// contract method so telemetry or chat-loop rewiring can be layered on
+			// without changing resume's semantics. Same open-before-close ordering
+			// as resume() above and for the same reason.
 			if (state?.meta.id === sessionId) return state.meta;
 			const resumed = resumeSessionState(sessionId);
 			if (state) {

package/src/domains/session/handoff.ts

@@ -22,6 +22,7 @@
  */
 
 import { isAbsolute, normalize, relative, resolve } from "node:path";
+import { decisionRationale } from "./decision-board.js";
 import type { DecisionLedgerEntry, SessionEntry } from "./entries.js";
 import { filterEntriesToActivePath } from "./tree/active-path.js";
 
@@ -480,7 +481,7 @@ export function mergeHandoffDecisions(
 			if (decision.status !== "active") continue;
 			const name = decision.label ?? decision.key;
 			const summary = boundHandoffString(`${name}: ${decision.value}`).text;
-			const rationale = decision.source_question ?? decision.correction;
+			const rationale = decisionRationale(decision);
 			settled.push({
 				summary,
 				...(rationale ? { rationale: boundHandoffString(rationale).text } : {}),

package/src/domains/session/manager.ts

@@ -111,9 +111,8 @@ export function appendTurn(state: SessionManagerState, input: TurnInput): ClioTu
 
 /**
  * Append a rich SessionEntry via the engine writer. Non-message kinds are
- * written as JSON lines to current.jsonl; they do not project into tree.json
- * in slice 12a. Slice 12b extends the tree model so /fork can pick non-message
- * branch points too.
+ * written as JSON lines to current.jsonl and do not project into tree.json;
+ * the /fork picker offers assistant message turns only.
  */
 export function appendEntry(state: SessionManagerState, input: SessionEntryInput): SessionEntry {
 	const turnId = input.turnId ?? newTurnId();

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

@@ -29,6 +29,7 @@ export interface TaskBoardTask {
 	status: TaskLedgerStatus;
 	origin?: "agent" | "user";
 	userTaskId?: string;
+	requiredValidationEvidence?: TaskLedgerValidationEvidence[];
 	/** Block or drop reason; empty for pending/active/completed tasks. */
 	reason?: string;
 	/** Evidence note recorded when the task was completed. */
@@ -64,7 +65,7 @@ export interface TaskBoardCounts {
 export type TaskBoardMutation =
 	| { op: "plan"; title: string; tasks: ReadonlyArray<string> }
 	| { op: "add"; tasks: ReadonlyArray<string> }
-	| { op: "pick"; title: string; userTaskId: string }
+	| { op: "pick"; title: string; userTaskId: string; verification?: ReadonlyArray<{ check: string; timeoutMs: number }> }
 	| { op: "start"; id: string }
 	| { op: "done"; id: string; evidence: string }
 	| { op: "block"; id: string; reason: string }
@@ -179,6 +180,7 @@ function boardStatus(tasks: ReadonlyArray<TaskBoardTask>): TaskLedgerStatus {
 export function toTaskLedgerEntryFields(board: TaskBoardSnapshot, now: Date): TaskLedgerEntryFields {
 	const evidence: TaskLedgerValidationEvidence[] = [];
 	const subgoals: TaskLedgerGoal[] = board.tasks.map((task) => {
+		evidence.push(...(task.requiredValidationEvidence ?? []).map((item) => ({ ...item })));
 		if (task.status === "completed" && task.evidence) {
 			evidence.push({
 				id: `${task.id}.evidence`,
@@ -308,6 +310,8 @@ function toEntryView(entry: {
 				origin: goal.origin ?? "agent",
 			};
 			if (goal.userTaskId) task.userTaskId = goal.userTaskId;
+			const required = entry.requiredValidationEvidence.filter((item) => item.id.startsWith(`${goal.id}.acceptance.`));
+			if (required.length > 0) task.requiredValidationEvidence = required.map((item) => ({ ...item }));
 			if (goal.description) task.reason = goal.description;
 			const evidence = evidenceByTask.get(goal.id);
 			if (evidence) task.evidence = evidence;
@@ -390,6 +394,15 @@ function applyMutation(
 			origin: "user",
 			userTaskId: mutation.userTaskId,
 		};
+		if (mutation.verification && mutation.verification.length > 0) {
+			picked.requiredValidationEvidence = mutation.verification.map((item, index) => ({
+				id: `${picked.id}.acceptance.${index}`,
+				description: `Operator acceptance: ${item.check}`,
+				command: item.check,
+				status: "pending",
+				notes: `timeoutMs=${item.timeoutMs}`,
+			}));
+		}
 		return {
 			board: {
 				boardId: board?.boardId ?? "",

package/src/domains/session/tree/fork.ts

@@ -14,8 +14,7 @@ import { entryBelongsToPath } from "./active-path.js";
  * install it as current.
  *
  * Used by SessionContract.fork (current session) and the /fork message
- * picker path that lands in slice 12b-3. Kept out of extension.ts so the
- * bundle wiring stays thin.
+ * picker overlay. Kept out of extension.ts so the bundle wiring stays thin.
  */
 export interface ForkInput {
 	/** The state we are forking from. Must carry a live writer. */

package/src/domains/session/tree/navigator.ts

@@ -6,7 +6,7 @@ import type { ResolvedLabel } from "./manager.js";
  * Purely functional tree-walk helpers. Given the raw SessionTreeNode[] that
  * the engine persists plus a label map and a leaf pointer, produce a
  * render-friendly snapshot. No I/O. Used by SessionContract.tree() to
- * deliver a serializable structure to overlay renderers in slice 12b-2.
+ * deliver a serializable structure to the /tree overlay renderer.
  */
 
 /**

package/src/domains/session/usage.ts

@@ -101,9 +101,9 @@ export function ledgerUsageCalls(
 			const usage = entry.usage;
 			if (!usage || usage.totalTokens <= 0) continue;
 			calls.push({
-				providerId: currentTarget ?? "unknown",
-				attributedModelId: currentModel ?? "unknown",
-				requestedModelId: currentModel ?? "unknown",
+				providerId: usage.targetId ?? currentTarget ?? "unknown",
+				attributedModelId: usage.modelId ?? currentModel ?? "unknown",
+				requestedModelId: usage.modelId ?? currentModel ?? "unknown",
 				responseModelIdObservation: { state: "not-observed" },
 				input: usage.input,
 				output: usage.output,

package/src/domains/user-tasks/acceptance.ts

@@ -0,0 +1,56 @@
+import {
+	DISPATCH_INTENT_TIMEOUT_MIN_MS,
+	type DispatchIntentCheckBound,
+	type DispatchIntentVerification,
+	normalizeIntentExpectedOutputs,
+	normalizeIntentVerification,
+} from "../dispatch/intent.js";
+
+export interface UserTaskAcceptance {
+	expectedOutputs: string[];
+	verification: DispatchIntentVerification[];
+}
+
+/** Validate stored acceptance without consulting a catalog that may have changed. */
+export function normalizeUserTaskAcceptance(raw: unknown): UserTaskAcceptance {
+	if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+		throw new Error("acceptance must be an object");
+	}
+	const value = raw as Record<string, unknown>;
+	if (Object.keys(value).some((key) => key !== "expectedOutputs" && key !== "verification")) {
+		throw new Error("acceptance contains an unknown field");
+	}
+	if (!Array.isArray(value.expectedOutputs) || !Array.isArray(value.verification)) {
+		throw new Error("acceptance requires expectedOutputs and verification arrays");
+	}
+	const checks = new Map<string, DispatchIntentCheckBound>();
+	const rawVerification = value.verification.map((entry: unknown) => {
+		if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+			throw new Error("acceptance verification must contain check and timeoutMs");
+		}
+		const item = entry as Record<string, unknown>;
+		if (Object.keys(item).some((key) => key !== "check" && key !== "timeoutMs")) {
+			throw new Error("acceptance verification contains an unknown field");
+		}
+		if (
+			typeof item.check !== "string" ||
+			typeof item.timeoutMs !== "number" ||
+			!Number.isSafeInteger(item.timeoutMs) ||
+			item.timeoutMs <= 0
+		) {
+			throw new Error("acceptance verification requires a check and a positive integer timeoutMs");
+		}
+		checks.set(item.check.trim(), {
+			id: item.check.trim(),
+			timeoutMs: Math.max(DISPATCH_INTENT_TIMEOUT_MIN_MS, item.timeoutMs, checks.get(item.check.trim())?.timeoutMs ?? 0),
+		});
+		return { check: item.check, timeout_ms: item.timeoutMs };
+	});
+	const expectedOutputs = normalizeIntentExpectedOutputs(value.expectedOutputs);
+	if (!Array.isArray(expectedOutputs))
+		throw new Error(expectedOutputs.ok ? "invalid acceptance outputs" : expectedOutputs.message);
+	const verification = normalizeIntentVerification(rawVerification, checks);
+	if (!Array.isArray(verification))
+		throw new Error(verification.ok ? "invalid acceptance verification" : verification.message);
+	return { expectedOutputs, verification };
+}

package/src/domains/user-tasks/active-acceptance.ts

@@ -0,0 +1,40 @@
+import { isSessionEntry } from "../session/entries.js";
+import type { TaskBoardSnapshot } from "../session/task-board.js";
+import type { UserTaskAcceptance } from "./acceptance.js";
+import type { UserTask } from "./store.js";
+
+/** Keep a task's acceptance through the turn that finishes or blocks its board row. */
+export function activeUserTaskAcceptance(
+	tasks: ReadonlyArray<UserTask>,
+	board: TaskBoardSnapshot | null,
+	sessionId: string | null,
+	window: ReadonlyArray<unknown>,
+): UserTaskAcceptance | undefined {
+	if (!board || !sessionId) return undefined;
+	const touched = new Set<string>();
+	for (const entry of window) {
+		if (!isSessionEntry(entry) || entry.kind !== "message" || entry.role !== "tool_call") continue;
+		if (!entry.payload || typeof entry.payload !== "object") continue;
+		const payload = entry.payload as { name?: string; toolName?: string; args?: { action?: string; id?: string } };
+		if (
+			(payload.name ?? payload.toolName) === "tasks" &&
+			payload.args?.id &&
+			["done", "block", "drop"].includes(payload.args.action ?? "")
+		)
+			touched.add(payload.args.id);
+	}
+	const linked = new Set(
+		board.tasks
+			.filter((task) => task.status === "pending" || task.status === "active" || touched.has(task.id))
+			.map((task) => task.userTaskId),
+	);
+	const acceptance = tasks
+		.filter((task) => task.handedSessionId === sessionId && linked.has(task.id))
+		.flatMap((task) => (task.acceptance ? [task.acceptance] : []));
+	return acceptance.length > 0
+		? {
+				expectedOutputs: [...new Set(acceptance.flatMap((item) => item.expectedOutputs))],
+				verification: acceptance.flatMap((item) => item.verification),
+			}
+		: undefined;
+}

package/src/domains/user-tasks/store.ts

@@ -2,6 +2,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { CLIO_PROJECT_DIR } from "../../core/artifact-paths.js";
 import { atomicWrite } from "../../engine/session.js";
+import { normalizeUserTaskAcceptance, type UserTaskAcceptance } from "./acceptance.js";
 
 export const USER_TASKS_FILE_VERSION = 1 as const;
 export const USER_TASKS_RELATIVE_PATH = `${CLIO_PROJECT_DIR}/user-tasks.json`;
@@ -12,6 +13,7 @@ export interface UserTask {
 	id: string;
 	title: string;
 	note?: string;
+	acceptance?: UserTaskAcceptance;
 	status: UserTaskStatus;
 	createdAt: string;
 	updatedAt: string;
@@ -37,7 +39,8 @@ export interface UserTasksStore {
 	readonly path: string;
 	snapshot(): ReadonlyArray<UserTask>;
 	get(id: string): UserTask | null;
-	add(title: string, note?: string): UserTask;
+	add(title: string, note?: string, acceptance?: UserTaskAcceptance): UserTask;
+	setAcceptance(id: string, acceptance: UserTaskAcceptance): UserTask;
 	hand(id: string, sessionId?: string): UserTask;
 	done(id: string): UserTask;
 	drop(id: string): UserTask;
@@ -65,6 +68,7 @@ const TASK_KEYS = new Set([
 	"id",
 	"title",
 	"note",
+	"acceptance",
 	"status",
 	"createdAt",
 	"updatedAt",
@@ -86,6 +90,13 @@ function isOptionalString(value: unknown): boolean {
 
 function isUserTask(value: unknown): value is UserTask {
 	if (!isRecord(value) || !hasOnlyKeys(value, TASK_KEYS)) return false;
+	if (value.acceptance !== undefined) {
+		try {
+			normalizeUserTaskAcceptance(value.acceptance);
+		} catch {
+			return false;
+		}
+	}
 	return (
 		typeof value.id === "string" &&
 		/^u[1-9]\d*$/.test(value.id) &&
@@ -138,7 +149,7 @@ function parseFile(body: string, path: string): UserTasksFile {
 }
 
 function copyTask(task: UserTask): UserTask {
-	return { ...task };
+	return { ...task, ...(task.acceptance ? { acceptance: normalizeUserTaskAcceptance(task.acceptance) } : {}) };
 }
 
 function initialFile(): UserTasksFile {
@@ -219,7 +230,8 @@ export function createUserTasksStore(deps: UserTasksStoreDeps): UserTasksStore {
 			const task = load().tasks.find((candidate) => candidate.id === id);
 			return task ? copyTask(task) : null;
 		},
-		add(title: string, note?: string): UserTask {
+		add(title: string, note?: string, acceptance?: UserTaskAcceptance): UserTask {
+			const normalizedAcceptance = acceptance === undefined ? undefined : normalizeAcceptance(acceptance);
 			const normalizedTitle = title.trim();
 			if (normalizedTitle.length === 0) throw new UserTasksStoreError("operator task title cannot be empty");
 			const normalizedNote = note?.trim();
@@ -229,6 +241,7 @@ export function createUserTasksStore(deps: UserTasksStoreDeps): UserTasksStore {
 				id: `u${file.nextId}`,
 				title: normalizedTitle,
 				...(normalizedNote ? { note: normalizedNote } : {}),
+				...(normalizedAcceptance ? { acceptance: normalizedAcceptance } : {}),
 				status: "open",
 				createdAt: timestamp,
 				updatedAt: timestamp,
@@ -238,6 +251,16 @@ export function createUserTasksStore(deps: UserTasksStoreDeps): UserTasksStore {
 			save(file);
 			return copyTask(task);
 		},
+		setAcceptance(id: string, acceptance: UserTaskAcceptance): UserTask {
+			const normalized = normalizeAcceptance(acceptance);
+			const file = load();
+			const task = file.tasks.find((item) => item.id === id);
+			if (!task) throw new UserTasksStoreError(`operator task ${id} was not found`);
+			task.acceptance = normalized;
+			task.updatedAt = now();
+			save(file);
+			return copyTask(task);
+		},
 		hand(id: string, sessionId?: string): UserTask {
 			return mutate(id, ["open"], "handed", sessionId);
 		},
@@ -295,3 +318,11 @@ export function createUserTasksStore(deps: UserTasksStoreDeps): UserTasksStore {
 		},
 	};
 }
+
+function normalizeAcceptance(raw: unknown): UserTaskAcceptance {
+	try {
+		return normalizeUserTaskAcceptance(raw);
+	} catch (error) {
+		throw new UserTasksStoreError(error instanceof Error ? error.message : String(error), { cause: error });
+	}
+}

package/src/engine/acp/adapter.ts

@@ -134,13 +134,15 @@ function flattenPrompt(input: AcpDelegationRunInput): string {
 	return parts.join("\n\n");
 }
 
-function emptyUsage(): AcpDelegationUsage {
+export function emptyUsage(): AcpDelegationUsage {
 	return {
 		inputTokens: 0,
 		outputTokens: 0,
 		cacheReadTokens: 0,
 		cacheWriteTokens: 0,
 		reasoningTokens: 0,
+		totalTokens: 0,
+		costUsd: 0,
 	};
 }
 
@@ -148,13 +150,29 @@ function finite(value: unknown): number {
 	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
 }
 
-function mergeUsage(into: AcpDelegationUsage, raw: unknown): void {
+/** Same field the ACP server side and `sumRunUsage` read for a dollar figure; cost is never re-derived here. */
+function costTotal(raw: Record<string, unknown>): number {
+	const cost = raw.cost;
+	return isRecord(cost) ? finite(cost.total) : 0;
+}
+
+export function mergeUsage(into: AcpDelegationUsage, raw: unknown): void {
 	if (!isRecord(raw)) return;
-	into.inputTokens += finite(raw.input) + finite(raw.inputTokens) + finite(raw.input_tokens);
-	into.outputTokens += finite(raw.output) + finite(raw.outputTokens) + finite(raw.output_tokens);
-	into.cacheReadTokens += finite(raw.cacheRead) + finite(raw.cacheReadTokens) + finite(raw.cache_read_tokens);
-	into.cacheWriteTokens += finite(raw.cacheWrite) + finite(raw.cacheWriteTokens) + finite(raw.cache_write_tokens);
+	const input = finite(raw.input) + finite(raw.inputTokens) + finite(raw.input_tokens);
+	const output = finite(raw.output) + finite(raw.outputTokens) + finite(raw.output_tokens);
+	const cacheRead = finite(raw.cacheRead) + finite(raw.cacheReadTokens) + finite(raw.cache_read_tokens);
+	const cacheWrite = finite(raw.cacheWrite) + finite(raw.cacheWriteTokens) + finite(raw.cache_write_tokens);
+	into.inputTokens += input;
+	into.outputTokens += output;
+	into.cacheReadTokens += cacheRead;
+	into.cacheWriteTokens += cacheWrite;
 	into.reasoningTokens += finite(raw.reasoning) + finite(raw.reasoningTokens) + finite(raw.reasoning_tokens);
+	// Same rule as the ACP server accumulator: prefer the peer's explicit total,
+	// otherwise sum the four billed categories (reasoning excluded, since a peer
+	// that reports it separately still counts it inside output).
+	const explicitTotal = finite(raw.totalTokens) + finite(raw.total_tokens);
+	into.totalTokens += explicitTotal > 0 ? explicitTotal : input + output + cacheRead + cacheWrite;
+	into.costUsd += costTotal(raw);
 }
 
 function errorMessage(value: unknown): string {