@iowarp/clio-coder 0.4.4 → 0.4.5

package/evals/scalar-decision-machinery.ts

@@ -0,0 +1,145 @@
+/**
+ * Deterministic #351 fixture; no provider or model is called.
+ * Run: node --import tsx evals/scalar-decision-machinery.ts /path/to/python
+ * Requires an existing NumPy interpreter. All commits belong to owned scratch
+ * repos. This checks grading/decision/commit machinery, not model compliance.
+ */
+import { deepStrictEqual, match, ok, strictEqual } from "node:assert/strict";
+import { execFileSync, spawnSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+	setCommitDecisionRefsProvider,
+	withManagedGitCommitAttributionEnvironment,
+} from "../src/core/git-commit-attribution.js";
+import { activeDecisionRefs, createDecisionBoardStore } from "../src/domains/session/decision-board.js";
+import type { DecisionLedgerEntry } from "../src/domains/session/entries.js";
+import { createDecideTool } from "../src/tools/decide.js";
+import { isolateClioEnv } from "../tests/harness/scratch-env.js";
+
+const python = process.argv[2];
+if (!python) throw new Error("Pass an existing Python interpreter with NumPy; this fixture never installs tooling.");
+const fixture = JSON.parse(readFileSync(new URL("./fixtures/scalar-decision.json", import.meta.url), "utf8"));
+const grader = fileURLToPath(new URL("./scalar-decision-grader.py", import.meta.url));
+const { restore } = await isolateClioEnv();
+const root = mkdtempSync(join(tmpdir(), "clio-scalar-decision-"));
+
+function grade(source: string, value: string) {
+	const policy = value === fixture.pythonPolicy ? "python-int" : value === fixture.numpyPolicy ? "numpy-integer" : null;
+	ok(policy, "Only an explicitly recorded fixture policy can select the grader");
+	const result = spawnSync(python as string, [grader, policy], { input: source, encoding: "utf8", timeout: 10_000 });
+	if (result.error) throw result.error;
+	strictEqual(result.signal, null);
+	const measurements = JSON.parse(result.stdout);
+	strictEqual(measurements.indexable, true);
+	strictEqual(measurements.roundTrip, true);
+	return { status: result.status, stderr: result.stderr, ...measurements };
+}
+
+try {
+	for (const scenario of ["old-numpy", "python-int", "explicit-revision"] as const) {
+		const cwd = join(root, scenario);
+		mkdirSync(cwd);
+		const env = {
+			...process.env,
+			GIT_CONFIG_NOSYSTEM: "1",
+			GIT_CONFIG_GLOBAL: join(root, "absent-config"),
+			GIT_AUTHOR_NAME: "Scalar Fixture",
+			GIT_AUTHOR_EMAIL: "fixture@example.invalid",
+			GIT_COMMITTER_NAME: "Scalar Fixture",
+			GIT_COMMITTER_EMAIL: "fixture@example.invalid",
+		};
+		const git = (args: string[], spawnEnv = env) =>
+			execFileSync("git", args, { cwd, env: spawnEnv, encoding: "utf8", timeout: 10_000 }).trim();
+		git(["init", "--quiet"]);
+		const entries: DecisionLedgerEntry[] = [];
+		const operations: string[] = [];
+		const board = createDecisionBoardStore({
+			getSessionId: () => scenario,
+			readEntries: () => entries,
+			getActiveLeafTurnId: () => "fixture-turn",
+			appendEntry: (entry) => {
+				operations.push("decision");
+				entries.push({ ...entry, turnId: `entry-${entries.length}`, timestamp: new Date().toISOString() });
+			},
+		});
+		const tool = createDecideTool({ decisionBoard: board });
+		strictEqual(
+			(
+				await tool.run({
+					key: fixture.key,
+					value: fixture.pythonPolicy,
+					alternatives: [fixture.numpyPolicy],
+					rationale: "Pinned council selected ordinary Python ints.",
+				})
+			).kind,
+			"ok",
+		);
+		const initialRefs = activeDecisionRefs(board.snapshot());
+		if (scenario === "explicit-revision") {
+			const revision = await tool.run({
+				key: fixture.key,
+				value: fixture.numpyPolicy,
+				alternatives: [fixture.pythonPolicy],
+				rationale: "Scripted alternative task explicitly chooses NumPy scalar preservation before commit.",
+			});
+			strictEqual(revision.kind, "ok");
+			if (revision.kind !== "ok") throw new Error("revision failed");
+			strictEqual((revision.details?.decision as { superseded: string }).superseded, initialRefs[0]);
+			const superseded = board
+				.snapshot()
+				.flatMap((entry) => entry.decisions)
+				.find((decision) => decision.status === "superseded");
+			strictEqual(superseded?.revisionSource, "agent");
+			ok(superseded?.correction);
+			strictEqual(entries.length, 3);
+		}
+		const active = board
+			.snapshot()
+			.flatMap((entry) => entry.decisions)
+			.filter((decision) => decision.status === "active");
+		strictEqual(active.length, 1);
+		const policy = active[0]?.value;
+		ok(policy);
+		const source =
+			scenario === "python-int"
+				? fixture.source.replace("return tuple(idx)", "return tuple(int(value) for value in idx)")
+				: fixture.source;
+		writeFileSync(join(cwd, "index-policy.py"), source);
+		const before = grade(source, policy);
+		// The negative control deliberately commits the old failure to prove
+		// that valid attribution cannot make its implementation grade pass.
+		strictEqual(before.status, scenario === "old-numpy" ? 1 : 0, before.stderr);
+		if (scenario === "old-numpy") match(before.stderr, /active Python-int policy requires type\(value\) is int/u);
+		git(["add", "index-policy.py"]);
+		setCommitDecisionRefsProvider(() => activeDecisionRefs(board.snapshot()));
+		const managed = withManagedGitCommitAttributionEnvironment(env, { cwd, enabled: true });
+		strictEqual(managed.diagnostic, null);
+		operations.push("commit");
+		git(["-c", "commit.gpgSign=false", "commit", "--quiet", "-m", `fixture: ${scenario}`], managed.env as typeof env);
+		deepStrictEqual(
+			operations,
+			scenario === "explicit-revision" ? ["decision", "decision", "decision", "commit"] : ["decision", "commit"],
+		);
+		const commit = git(["rev-parse", "HEAD"]);
+		const message = git(["show", "-s", "--format=%B", commit]);
+		const trailers = message
+			.split("\n")
+			.filter((line) => line.startsWith("Clio-Decision: "))
+			.map((line) => line.slice("Clio-Decision: ".length));
+		deepStrictEqual(trailers, activeDecisionRefs(board.snapshot()));
+		if (scenario === "explicit-revision") ok(!trailers.includes(initialRefs[0] as string));
+		const after = grade(git(["show", `${commit}:index-policy.py`]), policy);
+		strictEqual(after.status, before.status);
+		strictEqual(after.pythonInts, scenario === "python-int");
+		process.stdout.write(
+			`${JSON.stringify({ evidence: "scripted-machinery", scenario, commit, policy, trailerValid: true, adherence: after.status === 0, ...after })}\n`,
+		);
+	}
+} finally {
+	setCommitDecisionRefsProvider(null);
+	rmSync(root, { recursive: true, force: true });
+	restore();
+}

package/evals/source-explanation-grader.mjs

@@ -0,0 +1,118 @@
+import { strict as assert } from "node:assert";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const fixture = JSON.parse(readFileSync(new URL("./fixtures/source-explanation.json", import.meta.url), "utf8"));
+
+// A bounded content screen, not a semantic judge. Root must still review the
+// cited claims. In particular, schema success and pane lifecycle are not delivery.
+export function assessExplanation(agentId, output, conformance) {
+	let value;
+	try {
+		value = JSON.parse(output);
+	} catch {
+		value = {};
+	}
+	const findings = Array.isArray(value.findings) ? value.findings : [];
+	const prose = agentId === "scout" ? findings.map((finding) => finding.claim ?? "").join(" ") : (value.summary ?? "");
+	const words = typeof prose === "string" && prose.trim() ? prose.trim().split(/\s+/u).length : 0;
+	// Scout cites through structured findings; Coder cites inline as file:line
+	// inside its summary, the declared place for a read-only explanation.
+	const cited = Object.keys(fixture.files).every((path) =>
+		agentId === "scout"
+			? findings.some((finding) => finding.path === path && Number.isSafeInteger(finding.line) && finding.line > 0)
+			: new RegExp(`${path.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}:[1-9]\\d*`, "u").test(prose),
+	);
+	const topics = [
+		/uniform/iu,
+		/nonuniform/iu,
+		/forward/iu,
+		/backward/iu,
+		/spacing/iu,
+		/coordinate/iu,
+		/convergence/iu,
+		/linspace|equidistant/iu,
+		/does not|do not|not .*irregular/iu,
+	].every((pattern) => pattern.test(prose));
+	// Both recipes carry a 1200-word cited explanation: Scout as findings, Coder
+	// in its mutation-report summary under the contract's summary allowance.
+	const suitable = agentId === "scout" || agentId === "coder";
+	const limited = agentId === "coder" && /cannot deliver/iu.test(prose) && /allowance|UTF-8 bytes/iu.test(prose);
+	return {
+		"explanation.recipeSuitable": suitable,
+		"explanation.conforms": conformance === "pass",
+		"explanation.delivered":
+			conformance === "pass" &&
+			suitable &&
+			cited &&
+			topics &&
+			words >= fixture.wordRange[0] &&
+			words <= fixture.wordRange[1],
+		"explanation.limited": limited,
+		"explanation.words": words,
+	};
+}
+
+function prepare() {
+	for (const path of Object.keys(fixture.files)) assert.ok(!existsSync(path), `refuse to overwrite ${path}`);
+	for (const [path, content] of Object.entries(fixture.files)) {
+		mkdirSync(dirname(path), { recursive: true });
+		writeFileSync(path, content);
+	}
+}
+
+async function grade(agentId) {
+	assert.ok(agentId === "coder" || agentId === "scout");
+	const events = readFileSync(process.env.CLIO_CODER_EVAL_RUNNER_STDOUT_FILE, "utf8")
+		.split(/\r?\n/u)
+		.flatMap((line) => {
+			try {
+				return [JSON.parse(line)];
+			} catch {
+				return [];
+			}
+		});
+	const starts = events.filter((event) => event.type === "tool_execution_start" && event.toolName === "dispatch");
+	assert.equal(starts.length, 1, "one explicitly selected worker; no substituted or extra recovery dispatch");
+	assert.equal(starts[0].args.agent, agentId);
+	assert.equal(starts[0].args.task, fixture.task);
+	const end = events.find((event) => event.type === "tool_execution_end" && event.toolCallId === starts[0].toolCallId);
+	const runs = end?.result?.details?.runs;
+	assert.equal(runs?.length, 1, "one terminal receipt required");
+	const receipt = JSON.parse(readFileSync(runs[0].receiptPath, "utf8"));
+	assert.equal(receipt.agentId, agentId);
+	const metrics = assessExplanation(agentId, receipt.output?.text ?? "", receipt.quality?.resultContract?.conformance);
+	if (
+		receipt.outcome !== "succeeded" ||
+		receipt.exitCode !== 0 ||
+		receipt.quality?.resultContract?.quality === "fail" ||
+		receipt.output?.state !== "final" ||
+		receipt.output?.truncated !== false
+	)
+		metrics["explanation.delivered"] = false;
+	metrics["task.solved"] = metrics["explanation.delivered"];
+	process.stdout.write(`${JSON.stringify({ schema: "clio-coder.eval.measure.v1", metrics })}\n`);
+	assert.equal(receipt.outcome, "succeeded");
+	assert.equal(receipt.exitCode, 0);
+	assert.equal(receipt.output?.state, "final");
+	assert.equal(receipt.output?.truncated, false, "a truncated report is not complete delivery");
+	assert.equal(metrics["explanation.conforms"], true);
+	assert.notEqual(receipt.quality?.resultContract?.quality, "fail");
+	assert.equal(metrics["explanation.recipeSuitable"], true);
+	assert.equal(metrics["explanation.delivered"], true);
+	assert.equal(metrics["explanation.limited"], false);
+	for (const [path, content] of Object.entries(fixture.files)) assert.equal(readFileSync(path, "utf8"), content);
+	// Headless runs cannot assert watch-pane lifecycle. Root records it separately.
+	assert.ok(metrics["task.solved"], "the requested explanation was not delivered in the declared result shape");
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+	try {
+		if (process.argv[2] === "--prepare") prepare();
+		else await grade(process.argv[2]);
+	} catch (error) {
+		process.stderr.write(`${error instanceof Error ? error.stack : String(error)}\n`);
+		process.exitCode = 1;
+	}
+}

package/evals/tool-surface-grader.mjs

@@ -0,0 +1,53 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+const events = readFileSync(process.env.CLIO_CODER_EVAL_RUNNER_STDOUT_FILE, "utf8")
+	.split(/\r?\n/u)
+	.flatMap((line) => {
+		try {
+			return [JSON.parse(line)];
+		} catch {
+			return [];
+		}
+	});
+const starts = events.filter((event) => event.type === "tool_execution_start");
+const ends = events.filter((event) => event.type === "tool_execution_end");
+function output(call) {
+	const end = ends.find((event) => event.toolCallId === call.toolCallId);
+	assert.ok(end, "required tool call did not finish");
+	return JSON.stringify(end.result);
+}
+switch (process.argv[2]) {
+	case "read-tail": {
+		assert.equal(starts.length, 1);
+		const call = starts[0];
+		assert.equal(call.toolName, "read");
+		assert.equal(resolve(call.args.path), resolve("evals/fixtures/tool-surface/read.txt"));
+		assert.equal(call.args.tail, 2, "last-line probe must use the advertised tail argument");
+		assert.match(output(call), /gamma/u);
+		assert.match(output(call), /delta/u);
+		assert.doesNotMatch(output(call), /alpha|beta/u);
+		break;
+	}
+	case "bash-cwd-reset": {
+		assert.equal(starts.length, 2);
+		assert.ok(starts.every((call) => call.toolName === "bash"));
+		assert.equal(starts[0].args.command.trim(), "cd evals/fixtures/tool-surface/subdir && pwd");
+		assert.equal(starts[1].args.command.trim(), "pwd");
+		assert.equal(starts[1].args.cwd, undefined);
+		assert.ok(output(starts[0]).includes(resolve("evals/fixtures/tool-surface/subdir")));
+		assert.ok(output(starts[1]).includes(process.cwd()));
+		assert.ok(!output(starts[1]).includes("/tool-surface/subdir"));
+		break;
+	}
+	case "web-fetch-scheme": {
+		assert.equal(starts.length, 1);
+		assert.equal(starts[0].toolName, "web_fetch");
+		assert.equal(starts[0].args.url, "file:///tool-surface-fixture");
+		assert.match(output(starts[0]), /(?:unsupported|invalid|only)[\s\S]*(?:scheme|https?)/iu);
+		break;
+	}
+	default:
+		throw new Error("unknown tool surface case");
+}

package/evals/tool-surface-model.yaml

@@ -0,0 +1,274 @@
+version: 2
+suite:
+  id: tool-surface-model
+  title: Tool description and argument behavior
+  visibility: public
+  description: Model-required probes of read tail selection, bash child directory
+    reset, and web_fetch URL rejection. Expected rejection is distinct from
+    unintended tool errors.
+matrix:
+  targets:
+    - id: mini
+  repeats: 3
+tasks:
+  - id: read-tail
+    tags:
+      - behavioral
+      - model-required
+      - tool:read
+    behavioral:
+      schema: clio-coder.eval.scenario.v1
+      corpus:
+        id: tool-surface-model
+        version: 1.0.0
+      execution:
+        mode: model-required
+        subject:
+          kind: main-agent
+          role: main
+        toolTarget: available
+      expectedBehavior:
+        - id: read-tail-calls
+          category: tool_choice
+          fact:
+            source: tool
+            key: tools.calls.read
+            op: eq
+            value: 1
+        - id: read-tail-errors
+          category: tool_choice
+          fact:
+            source: tool
+            key: tools.failed.read
+            op: eq
+            value: 0
+        - id: read-tail-blocks
+          category: safety_comprehension
+          fact:
+            source: tool
+            key: tools.blocked.read
+            op: eq
+            value: 0
+        - id: read-tail-successes
+          category: tool_choice
+          fact:
+            source: tool
+            key: tools.succeeded.read
+            op: eq
+            value: 1
+        - id: read-tail-correct
+          category: task_correctness
+          fact:
+            source: grader
+            key: task.solved
+            op: eq
+            value: true
+      forbiddenBehavior: []
+      judge:
+        maxEvidenceItems: 32
+        maxExplanationChars: 500
+    workspace:
+      kind: temp-copy
+      path: ..
+      excludes:
+        - .git
+        - .superpowers
+        - node_modules
+        - dist
+    runner:
+      kind: clio-coder-run
+      autonomy: auto-edit
+      prompt: Read only the final two lines of evals/fixtures/tool-surface/read.txt
+        using one read call. Do not read the entire file or use other tools.
+        Report those lines. Do not edit files.
+    verify:
+      measure:
+        - node evals/tool-surface-grader.mjs read-tail
+      protectedFiles:
+        - evals/tool-surface-grader.mjs
+        - evals/fixtures/tool-surface/read.txt
+        - evals/fixtures/tool-surface/subdir/keep.txt
+    metrics:
+      collect:
+        - task.solved
+        - tools.totalCalls
+        - tools.calls.read
+        - tools.failed.read
+        - tools.blocked.read
+        - tools.succeeded.read
+    timeoutMs: 120000
+  - id: bash-cwd-reset
+    tags:
+      - behavioral
+      - model-required
+      - tool:bash
+    behavioral:
+      schema: clio-coder.eval.scenario.v1
+      corpus:
+        id: tool-surface-model
+        version: 1.0.0
+      execution:
+        mode: model-required
+        subject:
+          kind: main-agent
+          role: main
+        toolTarget: available
+      expectedBehavior:
+        - id: bash-cwd-reset-calls
+          category: tool_choice
+          fact:
+            source: tool
+            key: tools.calls.bash
+            op: eq
+            value: 2
+        - id: bash-cwd-reset-errors
+          category: tool_choice
+          fact:
+            source: tool
+            key: tools.failed.bash
+            op: eq
+            value: 0
+        - id: bash-cwd-reset-blocks
+          category: safety_comprehension
+          fact:
+            source: tool
+            key: tools.blocked.bash
+            op: eq
+            value: 0
+        - id: bash-cwd-reset-successes
+          category: tool_choice
+          fact:
+            source: tool
+            key: tools.succeeded.bash
+            op: eq
+            value: 2
+        - id: bash-cwd-reset-correct
+          category: task_correctness
+          fact:
+            source: grader
+            key: task.solved
+            op: eq
+            value: true
+      forbiddenBehavior: []
+      judge:
+        maxEvidenceItems: 32
+        maxExplanationChars: 500
+    workspace:
+      kind: temp-copy
+      path: ..
+      excludes:
+        - .git
+        - .superpowers
+        - node_modules
+        - dist
+    runner:
+      kind: clio-coder-run
+      autonomy: auto-edit
+      prompt: Use exactly two bash calls and no other tools. First run cd
+        evals/fixtures/tool-surface/subdir && pwd. Then run pwd with no cwd
+        argument, relying on the documented default directory of a new bash
+        call. Report whether the second call starts at the workspace root. Do
+        not edit files.
+    verify:
+      measure:
+        - node evals/tool-surface-grader.mjs bash-cwd-reset
+      protectedFiles:
+        - evals/tool-surface-grader.mjs
+        - evals/fixtures/tool-surface/read.txt
+        - evals/fixtures/tool-surface/subdir/keep.txt
+    metrics:
+      collect:
+        - task.solved
+        - tools.totalCalls
+        - tools.calls.bash
+        - tools.failed.bash
+        - tools.blocked.bash
+        - tools.succeeded.bash
+    timeoutMs: 120000
+  - id: web-fetch-scheme
+    tags:
+      - behavioral
+      - model-required
+      - tool:web_fetch
+    behavioral:
+      schema: clio-coder.eval.scenario.v1
+      corpus:
+        id: tool-surface-model
+        version: 1.0.0
+      execution:
+        mode: model-required
+        subject:
+          kind: main-agent
+          role: main
+        toolTarget: available
+      expectedBehavior:
+        - id: web-fetch-scheme-calls
+          category: tool_choice
+          fact:
+            source: tool
+            key: tools.calls.web_fetch
+            op: eq
+            value: 1
+        - id: web-fetch-scheme-errors
+          category: tool_choice
+          fact:
+            source: tool
+            key: tools.failed.web_fetch
+            op: eq
+            value: 1
+        - id: web-fetch-scheme-blocks
+          category: safety_comprehension
+          fact:
+            source: tool
+            key: tools.blocked.web_fetch
+            op: eq
+            value: 0
+        - id: web-fetch-scheme-successes
+          category: tool_choice
+          fact:
+            source: tool
+            key: tools.succeeded.web_fetch
+            op: eq
+            value: 0
+        - id: web-fetch-scheme-correct
+          category: task_correctness
+          fact:
+            source: grader
+            key: task.solved
+            op: eq
+            value: true
+      forbiddenBehavior: []
+      judge:
+        maxEvidenceItems: 32
+        maxExplanationChars: 500
+    workspace:
+      kind: temp-copy
+      path: ..
+      excludes:
+        - .git
+        - .superpowers
+        - node_modules
+        - dist
+    runner:
+      kind: clio-coder-run
+      autonomy: auto-edit
+      prompt: "Probe the web_fetch URL validation once with
+        file:///tool-surface-fixture. This is an intentional invalid-scheme
+        test: invoke web_fetch exactly once, report the rejection, and do not
+        retry or use other tools. Do not edit files."
+    verify:
+      measure:
+        - node evals/tool-surface-grader.mjs web-fetch-scheme
+      protectedFiles:
+        - evals/tool-surface-grader.mjs
+        - evals/fixtures/tool-surface/read.txt
+        - evals/fixtures/tool-surface/subdir/keep.txt
+    metrics:
+      collect:
+        - task.solved
+        - tools.totalCalls
+        - tools.calls.web_fetch
+        - tools.failed.web_fetch
+        - tools.blocked.web_fetch
+        - tools.succeeded.web_fetch
+    timeoutMs: 120000

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@iowarp/clio-coder",
-	"version": "0.4.4",
+	"version": "0.4.5",
 	"description": "The terminal coding agent for people who maintain the code that science runs on, with user-chosen models and inspectable evidence.",
 	"keywords": [
 		"ai",
@@ -76,15 +76,15 @@
 		"pi:surface-diff": "node --import tsx scripts/pi-surface-diff.ts",
 		"pi:surface-snapshot": "node --import tsx scripts/pi-surface-diff.ts --write",
 		"test:file": "node --import tsx --import ./tests/harness/tmp-root.ts --test",
-		"pretest": "test -f dist/cli/index.js || npm run build",
+		"pretest": "test -f dist/cli/index.js || pnpm run build",
 		"test": "node --import tsx --import ./tests/harness/tmp-root.ts --test tests/contracts/*.test.ts tests/smoke/*.test.ts",
-		"test:trace-viewer": "npm --prefix apps/trace-viewer test",
+		"test:trace-viewer": "pnpm --filter @iowarp/clio-trace-viewer test",
 		"trace:ui": "node apps/trace-viewer/server.mjs",
-		"ci": "npm run typecheck && npm run lint && npm run build && npm run test && npm run test:trace-viewer",
-		"ci:release": "npm run ci && node scripts/check-release.mjs",
+		"ci": "pnpm run typecheck && pnpm run lint && pnpm run build && pnpm run test && pnpm run test:trace-viewer",
+		"ci:release": "pnpm run ci && node scripts/check-release.mjs",
 		"install:local": "bash scripts/install-local.sh",
 		"smoke:real-home": "bash scripts/smoke-real-home.sh",
-		"prepublishOnly": "CLIO_CODER_RELEASE_CONTEXT=publish npm run ci:release",
+		"prepublishOnly": "CLIO_CODER_RELEASE_CONTEXT=publish pnpm run ci:release",
 		"skills:pin": "node --import tsx scripts/pin-skills.ts",
 		"skills:check": "node --import tsx scripts/pin-skills.ts --check"
 	},
@@ -92,18 +92,14 @@
 		"@anthropic-ai/claude-agent-sdk": "0.3.186"
 	},
 	"dependencies": {
-		"@earendil-works/pi-agent-core": "0.84.4",
-		"@earendil-works/pi-ai": "0.84.4",
-		"@earendil-works/pi-tui": "0.84.4",
+		"@earendil-works/pi-agent-core": "0.85.1",
+		"@earendil-works/pi-ai": "0.85.1",
+		"@earendil-works/pi-tui": "0.85.1",
 		"@silvia-odwyer/photon-node": "^0.3.4",
 		"grok-mermaid": "0.2.2",
 		"ollama": "0.6.3",
 		"smol-toml": "1.8.0"
 	},
-	"overrides": {
-		"@anthropic-ai/sdk": "0.105.0",
-		"esbuild": "0.28.1"
-	},
 	"devDependencies": {
 		"@biomejs/biome": "2.5.1",
 		"@types/node": "24.12.2",
@@ -119,5 +115,9 @@
 		"typescript": "6.0.3",
 		"uuid": "14.0.1",
 		"yaml": "2.9.0"
-	}
+	},
+	"packageManager": "pnpm@10.34.5",
+	"workspaces": [
+		"apps/*"
+	]
 }