@iowarp/clio-coder 0.4.3 → 0.4.4

package/src/cli/evidence-detail.ts

@@ -1,78 +1,4 @@
-/**
- * Fixed machine-readable projection of one evidence bundle's trust record.
- *
- * `evidence inspect <id>` prints an operator record that quotes the task text,
- * the bundle's file list, and per-finding prose. This is the same bundle read
- * down to the one thing a GUI can carry safely and usefully: which runs the
- * bundle covers, what verdict each run earned, and which axis produced it.
- *
- * Every value here comes from a closed vocabulary. The axis names, the axis
- * states, and the verdicts are all enumerations the harness owns, so there is
- * no free-form text on this surface at all, which is what lets it answer the
- * question the inventory raises without reopening the boundary the inventory
- * closed.
- *
- * Unlike the other fixed reads this one takes an identifier, because an
- * operator names the bundle. The GUI host may only pass back an id it served
- * inside its current bounded window; see `apps/workbench/artifact-allowlist.ts`.
- */
-
-import { clioDataDir } from "../core/xdg.js";
-import {
-	inspectEvidence,
-	TRUST_STATUS_AXES,
-	type TrustStatusAxis,
-	type TrustVerdict,
-	trustVerdict,
-} from "../domains/evidence/index.js";
-
-export const EVIDENCE_DETAIL_MAX_RUNS = 16;
-
-export interface EvidenceDetailRun {
-	readonly runId: string;
-	readonly verdict: TrustVerdict;
-	/** Every axis, always all six, so an absent axis is stated rather than missing. */
-	readonly axes: Readonly<Record<TrustStatusAxis, string>>;
-}
-
-export interface EvidenceDetailSnapshot {
-	readonly version: 1;
-	readonly generatedAt: string;
-	readonly evidenceId: string;
-	readonly sourceKind: "run" | "session" | "eval";
-	/** False when the bundle predates the canonical trust projection. */
-	readonly canonical: boolean;
-	readonly runs: readonly EvidenceDetailRun[];
-	readonly runsTruncated: boolean;
-}
-
-async function evidenceDetailSnapshot(
-	evidenceId: string,
-	now: () => number = Date.now,
-	dataDir: string = clioDataDir(),
-): Promise<EvidenceDetailSnapshot> {
-	const inspected = await inspectEvidence(dataDir, evidenceId);
-	const all = inspected.trustStatus.runs;
-	const window = all.slice(0, EVIDENCE_DETAIL_MAX_RUNS);
-	return {
-		version: 1,
-		generatedAt: new Date(now()).toISOString(),
-		evidenceId: inspected.overview.evidenceId,
-		sourceKind: inspected.overview.source.kind,
-		canonical: inspected.trustStatus.projection === "canonical",
-		runs: window.map(
-			(run): EvidenceDetailRun => ({
-				runId: run.runId,
-				verdict: trustVerdict(run.status),
-				axes: Object.fromEntries(TRUST_STATUS_AXES.map((axis) => [axis, run.status[axis].state])) as Record<
-					TrustStatusAxis,
-					string
-				>,
-			}),
-		),
-		runsTruncated: all.length > window.length,
-	};
-}
+import { evidenceDetailSnapshot } from "../domains/evidence/detail.js";
 
 /**
  * `clio-coder evidence inspect <id> --json`.

package/src/cli/evidence-inventory.ts

@@ -1,170 +1,4 @@
-/**
- * Fixed machine-readable projection of recent evidence artifacts.
- *
- * `evidence list` is an operator table and `evidence inspect <id>` needs an id,
- * so neither is a transport a GUI host can invoke blind. This command accepts
- * no identifier, path, or limit, selects a bounded newest-first window itself,
- * and emits provenance, tags, totals, and a trust verdict.
- *
- * An overview carries the working directories the runs executed in, the task
- * text the operator typed, and the file names inside the bundle. None of that
- * appears here. What does is the shape of the artifact and how far it can be
- * trusted, which is what an operator picks a bundle by.
- */
-
-import { clioDataDir } from "../core/xdg.js";
-import {
-	EVIDENCE_TAGS,
-	type EvidenceOverview,
-	type EvidenceTag,
-	listEvidenceOverviews,
-	loadEvidenceTrustStatus,
-	type TrustVerdict,
-	trustVerdict,
-} from "../domains/evidence/index.js";
-import { sanitizeCallTargetText } from "../domains/safety/call-target.js";
-import { truncateToWidth } from "../engine/tui-primitives.js";
-
-export const EVIDENCE_INVENTORY_MAX_ARTIFACTS = 12;
-export const EVIDENCE_INVENTORY_MAX_IDS = 8;
-
-const IDENTITY_WIDTH = 128;
-
-/**
- * Worst verdict first.
- *
- * An artifact covering several runs is only as trustworthy as its weakest run,
- * so the fold takes the worst rather than the newest or the most common. A
- * `compromised` run inside an otherwise clean bundle is the fact the operator
- * needs, and averaging it away would be the one summary worth not printing.
- */
-const VERDICT_SEVERITY: ReadonlyArray<TrustVerdict> = ["compromised", "unverified", "unknown", "grounded", "reviewed"];
-
-export interface EvidenceInventoryArtifact {
-	readonly evidenceId: string;
-	readonly sourceKind: "run" | "session" | "eval";
-	readonly generatedAt: string;
-	readonly startedAt: string | null;
-	readonly endedAt: string | null;
-	readonly runIds: readonly string[];
-	readonly runIdsTruncated: boolean;
-	readonly agentIds: readonly string[];
-	readonly statuses: readonly string[];
-	readonly tags: readonly EvidenceTag[];
-	readonly totals: Readonly<{
-		runs: number;
-		receipts: number;
-		toolCalls: number;
-		toolErrors: number;
-		blockedToolCalls: number;
-		protectedArtifacts: number;
-		tokens: number;
-		costUsd: number;
-		wallTimeMs: number;
-	}>;
-	/** Secret-shaped values the builder replaced across the bundle's exports. */
-	readonly redactionCount: number;
-	readonly trust: Readonly<{
-		verdict: TrustVerdict;
-		/** Runs whose canonical trust status the bundle actually recorded. */
-		runsCovered: number;
-		/** True when the bundle predates the canonical trust projection. */
-		historical: boolean;
-	}>;
-}
-
-export interface EvidenceInventorySnapshot {
-	readonly version: 1;
-	readonly generatedAt: string;
-	readonly artifacts: readonly EvidenceInventoryArtifact[];
-	readonly truncated: boolean;
-}
-
-function bounded(value: string, width: number): string {
-	const sanitized = sanitizeCallTargetText(value);
-	if (sanitized.length === 0) return "unavailable";
-	return sanitizeCallTargetText(truncateToWidth(sanitized, width, "…", false));
-}
-
-/** Distinct, sanitized, bounded, in first-seen order. */
-function identities(values: ReadonlyArray<string>): string[] {
-	const seen: string[] = [];
-	for (const value of values) {
-		const text = bounded(value, IDENTITY_WIDTH);
-		if (!seen.includes(text)) seen.push(text);
-		if (seen.length >= EVIDENCE_INVENTORY_MAX_IDS) break;
-	}
-	return seen;
-}
-
-function tally(value: number | undefined): number {
-	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.trunc(value) : 0;
-}
-
-function amount(value: number | undefined): number {
-	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
-}
-
-/** Newest generation first. An unparseable stamp sorts oldest rather than throwing. */
-function byNewest(a: EvidenceOverview, b: EvidenceOverview): number {
-	return (Date.parse(b.generatedAt) || 0) - (Date.parse(a.generatedAt) || 0);
-}
-
-async function evidenceInventorySnapshot(
-	now: () => number = Date.now,
-	dataDir: string = clioDataDir(),
-): Promise<EvidenceInventorySnapshot> {
-	const all = (await listEvidenceOverviews(dataDir)).sort(byNewest);
-	const window = all.slice(0, EVIDENCE_INVENTORY_MAX_ARTIFACTS);
-	const artifacts: EvidenceInventoryArtifact[] = [];
-	for (const overview of window) {
-		// One unreadable trust file costs that artifact its verdict, never the
-		// whole inventory: the bundle itself is still the thing being listed.
-		let verdict: TrustVerdict = "unknown";
-		let runsCovered = 0;
-		let historical = true;
-		try {
-			const status = await loadEvidenceTrustStatus(dataDir, overview.evidenceId);
-			historical = status.projection !== "canonical";
-			runsCovered = status.runs.length;
-			const verdicts = status.runs.map((run) => trustVerdict(run.status));
-			verdict = VERDICT_SEVERITY.find((candidate) => verdicts.includes(candidate)) ?? "unknown";
-		} catch {
-			verdict = "unknown";
-		}
-		artifacts.push({
-			evidenceId: bounded(overview.evidenceId, IDENTITY_WIDTH),
-			sourceKind: overview.source.kind,
-			generatedAt: overview.generatedAt,
-			startedAt: overview.startedAt,
-			endedAt: overview.endedAt,
-			runIds: identities(overview.runIds),
-			runIdsTruncated: overview.runIds.length > EVIDENCE_INVENTORY_MAX_IDS,
-			agentIds: identities(overview.agentIds),
-			statuses: identities(overview.statuses),
-			tags: overview.tags.filter((tag) => EVIDENCE_TAGS.includes(tag)),
-			totals: {
-				runs: tally(overview.totals.runs),
-				receipts: tally(overview.totals.receipts),
-				toolCalls: tally(overview.totals.toolCalls),
-				toolErrors: tally(overview.totals.toolErrors),
-				blockedToolCalls: tally(overview.totals.blockedToolCalls),
-				protectedArtifacts: tally(overview.totals.protectedArtifacts),
-				tokens: tally(overview.totals.tokens),
-				costUsd: amount(overview.totals.costUsd),
-				wallTimeMs: tally(overview.totals.wallTimeMs),
-			},
-			redactionCount: tally(overview.redactionCount),
-			trust: { verdict, runsCovered, historical },
-		});
-	}
-	return {
-		version: 1,
-		generatedAt: new Date(now()).toISOString(),
-		artifacts,
-		truncated: all.length > window.length,
-	};
-}
+import { evidenceInventorySnapshot } from "../domains/evidence/inventory.js";
 
 /**
  * `clio-coder evidence inventory --json`, and nothing else.

package/src/cli/index.ts

@@ -71,6 +71,7 @@ Usage:
   clio-coder extensions           install, list, enable, disable, or remove extension packages
   clio-coder skills               list, inspect, validate, or install skills
   clio-coder library              list, search, add, or sync agents, prompts, fleets, and skills from catalogs
+  clio-coder tasks                list, add, hand, finish, or drop project operator tasks
   clio-coder verifiers            discover, inspect, author, validate, edit, or dry-run project checks
   clio-coder tools list|status|install|remove <id>  pinned external programs Clio can drive
   clio-coder interop inspect --json  detected external coding agents and how far each one is wired
@@ -259,6 +260,7 @@ const COMMAND_HANDLERS = new Map<string, CommandHandler>([
 	["fleet", async (subArgs) => (await import("./fleet.js")).runFleetCommand(subArgs)],
 	["skills", async (subArgs) => (await import("./skills.js")).runSkillsCommand(subArgs)],
 	["library", async (subArgs) => (await import("./library.js")).runLibraryCommand(subArgs)],
+	["tasks", async (subArgs) => (await import("./tasks.js")).runTasksCommand(subArgs)],
 	["verifiers", async (subArgs) => (await import("./verifiers.js")).runVerifiersCommand(subArgs)],
 	["docs", async (subArgs) => (await import("./docs.js")).runDocsCommand(subArgs)],
 	["share", async (subArgs) => (await import("./share.js")).runShareCommand(subArgs)],

package/src/cli/run.ts

@@ -62,7 +62,6 @@ Flags:
   --frequency-penalty <N>   one-run frequency penalty override
   --repeat-penalty <N>      one-run repeat penalty override
   --max-context-tokens <N>  one-run context-window override for supported local runtimes
-  --kv-cache-mode <mode>    one-run KV-cache mode override: f16|f32|none|false|q8_0|q4_0|q4_1|iq4_nl|q5_0|q5_1
   --json                    stream JSONL events for the main-agent path; dispatch streams events and receipt JSON
   --json-events <mode>      main-agent JSON stream mode: full|terminal; implies --json
   --steer-channel <path>    read live steering lines from a FIFO or appended regular file
@@ -213,7 +212,6 @@ export async function runClioRun(
 	return withRunOverrides(
 		{
 			...(parsed.maxContextTokens !== undefined ? { maxContextTokens: parsed.maxContextTokens } : {}),
-			...(parsed.kvCacheMode !== undefined ? { kvCacheMode: parsed.kvCacheMode } : {}),
 		},
 		async () => {
 			if (parsed.help) {

package/src/cli/targets.ts

@@ -1003,7 +1003,7 @@ function formatUrl(status: TargetStatus): string {
 
 function formatAuth(providers: ProvidersContract, status: TargetStatus): string {
 	if (!status.runtime) return "-";
-	if (status.runtime.externalAgentLoop !== undefined) return "operator session";
+	if (status.runtime.externalAgentLoop !== undefined && status.runtime.auth !== "claude-cli") return "operator session";
 	if (status.runtime.auth !== "api-key" && status.runtime.auth !== "oauth") return status.runtime.auth;
 	const auth = providers.auth.statusForTarget(status.target, status.runtime);
 	if (!auth.available) return "disconnected";

package/src/cli/tasks.ts

@@ -0,0 +1,84 @@
+import { normalizeIntentExpectedOutputs, normalizeIntentVerification } from "../domains/dispatch/intent.js";
+import type { UserTaskAcceptance } from "../domains/user-tasks/acceptance.js";
+import { createUserTasksStore } from "../domains/user-tasks/store.js";
+import { packageDeclaredCheck } from "../tools/verify/catalog.js";
+import { discoverDeclaredChecksAtRoot, discoverDeclaredProjectEntriesAtRoot } from "../tools/verify/scripts.js";
+import { printError } from "./argv.js";
+
+/** Operator flags use the same bounds and normalization as dispatch intent. */
+export function acceptanceFromTaskFlags(
+	cwd: string,
+	expectedOutputs: string[],
+	verify: string[],
+): UserTaskAcceptance | undefined {
+	if (expectedOutputs.length === 0 && verify.length === 0) return undefined;
+	const discovery = discoverDeclaredChecksAtRoot(cwd, undefined);
+	if (!discovery.ok) throw new Error(discovery.reason);
+	const checks = new Map(
+		discovery.sources.flatMap((source) => source.checks.map((check) => [check.id, check] as const)),
+	);
+	for (const entry of discoverDeclaredProjectEntriesAtRoot(cwd)) {
+		if (entry.kind === "package-script" && !checks.has(entry.id))
+			checks.set(entry.id, packageDeclaredCheck(entry.id, entry.path, ".", []));
+	}
+	const verification = verify.map((value) => {
+		const suffix = checks.has(value) ? null : /^(.*):([0-9]+)$/.exec(value);
+		const check = suffix?.[1] ?? value;
+		if (!checks.has(check))
+			throw new Error(
+				`Unknown verification check '${check}'. Known ids: ${[...checks.keys()].sort().join(", ") || "(none)"}`,
+			);
+		return { check, ...(suffix ? { timeout_ms: Number(suffix[2]) } : {}) };
+	});
+	const outputs = normalizeIntentExpectedOutputs(expectedOutputs);
+	if (!Array.isArray(outputs)) throw new Error(outputs.ok ? "invalid expected outputs" : outputs.message);
+	const normalized = normalizeIntentVerification(verification, checks);
+	if (!Array.isArray(normalized)) throw new Error(normalized.ok ? "invalid verification" : normalized.message);
+	return { expectedOutputs: outputs, verification: normalized };
+}
+
+const HELP = `Usage:
+  clio-coder tasks [list]
+  clio-coder tasks add [--expect <path>] [--verify <checkId>[:timeoutMs]] <text>
+  clio-coder tasks hand|done|drop <uN>
+
+--expect and --verify are repeatable. Check ids must be declared in package.json or .clio-coder/verifiers.yaml.`;
+
+export function runTasksCommand(args: string[]): number {
+	try {
+		if (args.includes("--help") || args.includes("-h")) {
+			console.log(HELP);
+			return 0;
+		}
+		const store = createUserTasksStore({ cwd: process.cwd() });
+		const [action = "list", ...rest] = args;
+		if (action === "add") {
+			const expected: string[] = [],
+				verify: string[] = [],
+				title: string[] = [];
+			for (let index = 0; index < rest.length; index++) {
+				const token = rest[index] ?? "";
+				if (token === "--") {
+					title.push(...rest.slice(index + 1));
+					break;
+				}
+				if (token === "--expect" || token === "--verify") {
+					const value = rest[++index];
+					if (!value || value.startsWith("--")) throw new Error(`${token} requires a value`);
+					(token === "--expect" ? expected : verify).push(value);
+				} else if (token.startsWith("--")) throw new Error(`Unknown flag ${token}`);
+				else title.push(token);
+			}
+			const task = store.add(title.join(" "), undefined, acceptanceFromTaskFlags(process.cwd(), expected, verify));
+			console.log(`logged operator task ${task.id}: ${task.title}`);
+		} else if (action === "list" && rest.length === 0) {
+			console.log(JSON.stringify(store.snapshot(), null, 2));
+		} else if ((action === "hand" || action === "done" || action === "drop") && rest.length === 1) {
+			console.log(JSON.stringify(store[action](rest[0] ?? ""), null, 2));
+		} else throw new Error(HELP);
+		return 0;
+	} catch (error) {
+		printError(error instanceof Error ? error.message : String(error));
+		return 1;
+	}
+}

package/src/cli/upgrade.ts

@@ -88,12 +88,17 @@ type RegistryLookup =
 	| { asked: false; reason: "source checkout" | "network checks are disabled" }
 	| { asked: true; version: string | null };
 
+function testSeam(name: string): string | undefined {
+	if (process.env.NODE_ENV !== "test") return undefined;
+	return process.env[name];
+}
+
 async function lookUpAvailableVersion(
 	channel: Channel,
 	method: "source" | "npm",
 	noNetwork: boolean,
 ): Promise<RegistryLookup> {
-	const seam = process.env.CLIO_CODER_TEST_UPGRADE_AVAILABLE;
+	const seam = testSeam("CLIO_CODER_TEST_UPGRADE_AVAILABLE");
 	// `unreachable` stands in for a registry that answered nothing, which is the
 	// only way to reach that branch without a network in the test.
 	if (seam) return { asked: true, version: seam === "unreachable" ? null : seam };
@@ -143,14 +148,14 @@ async function runChild(command: string, args: ReadonlyArray<string>, label: str
 }
 
 async function runNpmInstall(channel: Channel): Promise<void> {
-	if (process.env.CLIO_CODER_TEST_UPGRADE_FAIL === "npm") {
+	if (testSeam("CLIO_CODER_TEST_UPGRADE_FAIL") === "npm") {
 		throw new Error("npm ERR! 404 Not Found (mock failure)");
 	}
 	await runChild("npm", ["install", "-g", `@iowarp/clio-coder@${channel}`], "npm install");
 }
 
 async function runDoctorFixAfterInstall(): Promise<void> {
-	if (process.env.CLIO_CODER_TEST_UPGRADE_FAIL === "doctor") {
+	if (testSeam("CLIO_CODER_TEST_UPGRADE_FAIL") === "doctor") {
 		throw new Error("mock doctor fix failure");
 	}
 	await runChild("clio-coder", ["doctor", "--fix"], "clio-coder doctor --fix");
@@ -184,7 +189,7 @@ export async function runUpgradeCommand(argv: ReadonlyArray<string>): Promise<nu
 	const methodLabel = method === "source" ? "source checkout" : "npm global";
 	presenter.setMethod(methodLabel);
 
-	const noNetwork = Boolean(process.env.CLIO_CODER_TEST_UPGRADE_NO_NETWORK);
+	const noNetwork = Boolean(testSeam("CLIO_CODER_TEST_UPGRADE_NO_NETWORK"));
 	const lookup = await lookUpAvailableVersion(opts.channel, method, noNetwork);
 	const availableVersion = lookup.asked ? lookup.version : null;
 
@@ -285,7 +290,7 @@ export async function runUpgradeCommand(argv: ReadonlyArray<string>): Promise<nu
 	} else {
 		let result: Awaited<ReturnType<typeof runPending>>;
 		try {
-			if (process.env.CLIO_CODER_TEST_UPGRADE_FAIL === "migration") {
+			if (testSeam("CLIO_CODER_TEST_UPGRADE_FAIL") === "migration") {
 				throw new Error("mock migration failure in 2026-09-01-settings-v2");
 			}
 			result = await runPending(stateDir);

package/src/cli/usage.ts

@@ -8,6 +8,7 @@ import {
 } from "../core/response-model-id.js";
 import { clioDataDir, clioStateDir } from "../core/xdg.js";
 import { loadMemoryRecordsSync, type MemoryRecord } from "../domains/memory/index.js";
+import { summarizeEvidenceIndex } from "../domains/observability/accountability.js";
 import { summarizeFailedCompactionUsage } from "../domains/observability/compaction-usage.js";
 import { readEvidenceIndex } from "../domains/observability/evidence-index.js";
 import { type OutOfTurnUsageRow, readOutOfTurnUsageRows } from "../domains/observability/out-of-turn-usage.js";
@@ -358,6 +359,7 @@ export async function runUsageCommand(argv: ReadonlyArray<string>): Promise<numb
 		return decision === "blocked" || decision === "denied";
 	});
 	const evidenceRows = readEvidenceIndex(stateDir).filter((row) => inWindow(row.generatedAt, windowStart, now));
+	const accountability = summarizeEvidenceIndex(evidenceRows);
 	let memoryRecords: MemoryRecord[] = [];
 	try {
 		memoryRecords = loadMemoryRecordsSync(clioDataDir());
@@ -559,6 +561,8 @@ export async function runUsageCommand(argv: ReadonlyArray<string>): Promise<numb
 		else emit({ kind: "fact", fact: "session-store-missing", path: presence.sessionsPath });
 		if (presence.receiptsPresent) emit({ kind: "fact", fact: "dispatch-runs", value: receipts.length });
 		else emit({ kind: "fact", fact: "receipt-store-missing", path: presence.receiptsPath });
+		emit({ kind: "fact", fact: "unverified-successes", value: accountability.unverifiedSuccesses });
+		emit({ kind: "fact", fact: "ungrounded-claims", value: accountability.ungroundedClaims });
 		emit({ kind: "fact", fact: "audit-tool-calls", value: auditToolCalls.length, blocked: auditBlocked.length });
 		if (usageMeasurable) {
 			// The origin split is emitted only when something out of turn was
@@ -806,6 +810,8 @@ export async function runUsageCommand(argv: ReadonlyArray<string>): Promise<numb
 			),
 		);
 	}
+	out(`  unverified successes: ${accountability.unverifiedSuccesses}`);
+	out(`  ungrounded claims: ${accountability.ungroundedClaims}`);
 	if (tagCounts.size > 0) {
 		out("");
 		out("  failure tags (from evidence index)");