pi-oxidized 0.1.1

package/.references/pi/scripts/sync-versions.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+
+/**
+ * Syncs all workspace package dependency versions to match their current versions.
+ * This ensures lockstep versioning across the monorepo.
+ */
+
+import { readFileSync, writeFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+
+const packagesDir = join(process.cwd(), 'packages');
+const packageDirs = readdirSync(packagesDir, { withFileTypes: true })
+	.filter(dirent => dirent.isDirectory())
+	.map(dirent => dirent.name);
+
+// Read all package.json files and build version map
+const packages = {};
+const versionMap = {};
+
+for (const dir of packageDirs) {
+	const pkgPath = join(packagesDir, dir, 'package.json');
+	try {
+		const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+		packages[dir] = { path: pkgPath, data: pkg };
+		versionMap[pkg.name] = pkg.version;
+	} catch (e) {
+		console.error(`Failed to read ${pkgPath}:`, e.message);
+	}
+}
+
+console.log('Current versions:');
+for (const [name, version] of Object.entries(versionMap).sort()) {
+	console.log(`  ${name}: ${version}`);
+}
+
+// Verify all versions are the same (lockstep)
+const versions = new Set(Object.values(versionMap));
+if (versions.size > 1) {
+	console.error('\n❌ ERROR: Not all packages have the same version!');
+	console.error('Expected lockstep versioning. Run one of:');
+	console.error('  npm run version:patch');
+	console.error('  npm run version:minor');
+	console.error('  npm run version:major');
+	process.exit(1);
+}
+
+console.log('\n✅ All packages at same version (lockstep)');
+
+// Update all inter-package dependencies
+let totalUpdates = 0;
+for (const [dir, pkg] of Object.entries(packages)) {
+	let updated = false;
+	
+	// Check dependencies
+	if (pkg.data.dependencies) {
+		for (const [depName, currentVersion] of Object.entries(pkg.data.dependencies)) {
+			if (versionMap[depName]) {
+				const newVersion = `^${versionMap[depName]}`;
+				if (currentVersion !== newVersion) {
+					console.log(`\n${pkg.data.name}:`);
+					console.log(`  ${depName}: ${currentVersion} → ${newVersion}`);
+					pkg.data.dependencies[depName] = newVersion;
+					updated = true;
+					totalUpdates++;
+				}
+			}
+		}
+	}
+	
+	// Check devDependencies
+	if (pkg.data.devDependencies) {
+		for (const [depName, currentVersion] of Object.entries(pkg.data.devDependencies)) {
+			if (versionMap[depName]) {
+				const newVersion = `^${versionMap[depName]}`;
+				if (currentVersion !== newVersion) {
+					console.log(`\n${pkg.data.name}:`);
+					console.log(`  ${depName}: ${currentVersion} → ${newVersion} (devDependencies)`);
+					pkg.data.devDependencies[depName] = newVersion;
+					updated = true;
+					totalUpdates++;
+				}
+			}
+		}
+	}
+	
+	// Write if updated
+	if (updated) {
+		writeFileSync(pkg.path, JSON.stringify(pkg.data, null, '\t') + '\n');
+	}
+}
+
+if (totalUpdates === 0) {
+	console.log('\nAll inter-package dependencies already in sync.');
+} else {
+	console.log(`\n✅ Updated ${totalUpdates} dependency version(s)`);
+}

package/.references/pi/scripts/tool-stats.ts

@@ -0,0 +1,232 @@
+#!/usr/bin/env node
+
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { openBrowser } from "../packages/coding-agent/src/utils/open-browser.ts";
+
+interface TextContent { type: "text"; text: string }
+interface ImageContent { type: "image"; data: string; mimeType?: string }
+interface ToolCallContent { type: "toolCall"; id: string; name: string; arguments?: Record<string, unknown> }
+type Content = TextContent | ImageContent | ToolCallContent | { type: string; [key: string]: unknown };
+interface Message { role?: string; content?: string | Content[]; toolCallId?: string; toolName?: string; details?: unknown }
+interface Entry { type?: string; message?: Message }
+interface ToolStats { calls: number; results: number; estimatedTokens: number; samples: number[]; errors: number }
+interface BashCommandStats { calls: number; estimatedTokens: number; samples: number[] }
+interface ToolCallInfo { toolName: string; bashCommand?: string }
+
+const BUCKETS = [0, 50, 100, 250, 500, 1000, 2000, 4000, 8000, 16000, 32000, Number.POSITIVE_INFINITY];
+
+function parseArgs(): { sessionsDir: string; output: string } {
+	let sessionsDir = join(homedir(), ".pi", "agent", "sessions");
+	let output = join(tmpdir(), "pi-tool-stats.html");
+	const args = process.argv.slice(2);
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--sessions-dir" && args[i + 1]) sessionsDir = resolve(args[++i]);
+		else if ((arg === "--output" || arg === "-o") && args[i + 1]) output = resolve(args[++i]);
+		else if (arg === "--help" || arg === "-h") {
+			console.log(`Usage: scripts/tool-stats.ts [--sessions-dir <dir>] [--output <file.html>]`);
+			process.exit(0);
+		}
+	}
+	return { sessionsDir, output };
+}
+
+function jsonlFiles(dir: string): string[] {
+	const out: string[] = [];
+	for (const entry of readdirSync(dir, { withFileTypes: true })) {
+		const path = join(dir, entry.name);
+		if (entry.isDirectory()) out.push(...jsonlFiles(path));
+		else if (entry.isFile() && entry.name.endsWith(".jsonl")) out.push(path);
+	}
+	return out;
+}
+
+function getStats<T>(map: Map<string, T>, key: string, create: () => T): T {
+	let stats = map.get(key);
+	if (!stats) {
+		stats = create();
+		map.set(key, stats);
+	}
+	return stats;
+}
+
+function createToolStats(): ToolStats {
+	return { calls: 0, results: 0, estimatedTokens: 0, samples: [], errors: 0 };
+}
+
+function createBashStats(): BashCommandStats {
+	return { calls: 0, estimatedTokens: 0, samples: [] };
+}
+
+function estimateTokenCount(text: string): number {
+	return Math.ceil(text.length / 4);
+}
+
+function contentText(content: Message["content"]): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content.map((block) => {
+		if (block.type === "text" && "text" in block && typeof block.text === "string") return block.text;
+		if (block.type === "image" && "data" in block && typeof block.data === "string") return block.data;
+		return JSON.stringify(block);
+	}).join("\n");
+}
+
+function getBashCommand(args: Record<string, unknown> | undefined): string | undefined {
+	const command = args?.command;
+	return typeof command === "string" ? command : undefined;
+}
+
+function commandKey(command: string): string {
+	const first = command.split(/\n|&&|\|\||;|\|/)[0]?.trim() ?? command.trim();
+	const match = first.match(/^(?:\w+=\S+\s+)*(?:sudo\s+)?([^\s]+)(?:\s+([^\s]+))?/);
+	if (!match) return "unknown";
+	const bin = match[1] ?? "unknown";
+	const sub = match[2] && !match[2].startsWith("-") ? ` ${match[2]}` : "";
+	return `${bin}${sub}`;
+}
+
+function bucketCounts(samples: number[]): number[] {
+	const counts = new Array(BUCKETS.length - 1).fill(0) as number[];
+	for (const sample of samples) {
+		const index = BUCKETS.findIndex((max, i) => i > 0 && sample <= max) - 1;
+		counts[Math.max(0, index)]++;
+	}
+	return counts;
+}
+
+function bucketLabels(): string[] {
+	return BUCKETS.slice(0, -1).map((min, i) => {
+		const max = BUCKETS[i + 1];
+		return Number.isFinite(max) ? `${min}-${max}` : `${min}+`;
+	});
+}
+
+const { sessionsDir, output } = parseArgs();
+if (!existsSync(sessionsDir)) throw new Error(`Sessions directory not found: ${sessionsDir}`);
+
+const tools = new Map<string, ToolStats>();
+const bashCommands = new Map<string, BashCommandStats>();
+const callsById = new Map<string, ToolCallInfo>();
+let parseErrors = 0;
+const files = jsonlFiles(sessionsDir);
+
+for (const file of files) {
+	for (const line of readFileSync(file, "utf8").split("\n")) {
+		if (!line.trim()) continue;
+		let entry: Entry;
+		try { entry = JSON.parse(line) as Entry; } catch { parseErrors++; continue; }
+		if (entry.type !== "message") continue;
+		const message = entry.message;
+		if (!message) continue;
+		if (message.role === "assistant" && Array.isArray(message.content)) {
+			for (const block of message.content) {
+				if (block.type !== "toolCall" || !("name" in block) || typeof block.name !== "string") continue;
+				const stats = getStats(tools, block.name, createToolStats);
+				stats.calls++;
+				const bashCommand = block.name === "bash" ? getBashCommand(block.arguments) : undefined;
+				callsById.set(block.id, { toolName: block.name, bashCommand });
+				if (bashCommand) getStats(bashCommands, commandKey(bashCommand), createBashStats).calls++;
+			}
+		} else if (message.role === "toolResult" && message.toolName) {
+			const text = contentText(message.content);
+			const tokens = estimateTokenCount(text);
+			const stats = getStats(tools, message.toolName, createToolStats);
+			stats.results++;
+			stats.estimatedTokens += tokens;
+			stats.samples.push(tokens);
+			if ("isError" in message && message.isError === true) stats.errors++;
+			const call = message.toolCallId ? callsById.get(message.toolCallId) : undefined;
+			if (call?.bashCommand) {
+				const bash = getStats(bashCommands, commandKey(call.bashCommand), createBashStats);
+				bash.estimatedTokens += tokens;
+				bash.samples.push(tokens);
+			}
+		}
+	}
+}
+
+const toolRows = [...tools.entries()].map(([name, s]) => ({ name, ...s, avg: s.results ? s.estimatedTokens / s.results : 0, histogram: bucketCounts(s.samples) })).sort((a, b) => b.estimatedTokens - a.estimatedTokens);
+const bashRows = [...bashCommands.entries()].map(([name, s]) => ({ name, ...s, avg: s.samples.length ? s.estimatedTokens / s.samples.length : 0, histogram: bucketCounts(s.samples) })).sort((a, b) => b.estimatedTokens - a.estimatedTokens).slice(0, 50);
+const data = { generatedAt: new Date().toISOString(), sessionsDir, files: files.length, parseErrors, bucketLabels: bucketLabels(), tools: toolRows, bashCommands: bashRows };
+
+const html = `<!doctype html>
+<html>
+<head>
+	<meta charset="utf-8">
+	<title>Pi Tool Stats</title>
+	<script src="https://cdn.jsdelivr.net/npm/@tailwindcss/browser@4"></script>
+	<script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.9/dist/chart.umd.min.js"></script>
+</head>
+<body class="bg-zinc-950 text-zinc-100 p-6">
+	<main class="max-w-7xl mx-auto space-y-6">
+		<h1 class="text-3xl font-bold">Pi Tool Stats</h1>
+		<p class="text-zinc-400">${data.files} session files from <code>${sessionsDir}</code>. Generated ${data.generatedAt}.</p>
+		<section class="grid md:grid-cols-2 gap-6">
+			<div class="bg-zinc-900 rounded p-4"><h2 class="font-semibold mb-3">Estimated result tokens by tool</h2><canvas id="tokens"></canvas></div>
+			<div class="bg-zinc-900 rounded p-4"><h2 class="font-semibold mb-3">Tool calls</h2><canvas id="calls"></canvas></div>
+		</section>
+		<section class="grid md:grid-cols-2 gap-6">
+			<div class="bg-zinc-900 rounded p-4">
+				<div class="flex items-center justify-between gap-4 mb-3">
+					<h2 class="font-semibold">Tool result token histogram</h2>
+					<select id="toolSelect" class="bg-zinc-800 rounded px-2 py-1 text-sm"></select>
+				</div>
+				<p id="toolSummary" class="text-sm text-zinc-400 mb-3"></p>
+				<canvas id="toolHistogram" height="120"></canvas>
+			</div>
+			<div class="bg-zinc-900 rounded p-4">
+				<div class="flex items-center justify-between gap-4 mb-3">
+					<h2 class="font-semibold">Bash result token histogram</h2>
+					<select id="bashSelect" class="bg-zinc-800 rounded px-2 py-1 text-sm"></select>
+				</div>
+				<p id="bashSummary" class="text-sm text-zinc-400 mb-3"></p>
+				<canvas id="bashHistogram" height="120"></canvas>
+			</div>
+		</section>
+		<section class="bg-zinc-900 rounded p-4"><h2 class="font-semibold mb-3">Tools</h2><div id="tools"></div></section>
+		<section class="bg-zinc-900 rounded p-4">
+			<h2 class="font-semibold mb-3">Bash common commands (best effort)</h2>
+			<div id="bash" class="mt-4"></div>
+		</section>
+	</main>
+	<script>
+		const data=${JSON.stringify(data)};
+		function fmt(n){return Math.round(n).toLocaleString()}
+		function esc(s){return String(s).replace(/[&<>\"]/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}[c]))}
+		function table(rows,el){
+			document.getElementById(el).innerHTML='<table class="w-full text-sm"><thead class="text-zinc-400"><tr><th class="text-left p-2">Name</th><th class="text-right p-2">Calls</th><th class="text-right p-2">Results</th><th class="text-right p-2">Est. tokens</th><th class="text-right p-2">Avg/result</th><th class="text-left p-2 w-64">Histogram</th></tr></thead><tbody>'+rows.map((r,i)=>'<tr class="border-t border-zinc-800 hover:bg-zinc-800/50 cursor-pointer" data-row="'+i+'"><td class="p-2 font-mono">'+esc(r.name)+'</td><td class="p-2 text-right">'+fmt(r.calls)+'</td><td class="p-2 text-right">'+fmt(r.results??r.samples.length)+'</td><td class="p-2 text-right">'+fmt(r.estimatedTokens)+'</td><td class="p-2 text-right">'+fmt(r.avg)+'</td><td class="p-2"><canvas id="'+el+'Hist'+i+'" height="34"></canvas></td></tr>').join('')+'</tbody></table>';
+			rows.forEach((r,i)=>new Chart(document.getElementById(el+'Hist'+i),{type:'bar',data:{labels:data.bucketLabels,datasets:[{data:r.histogram,label:r.name,backgroundColor:'#60a5fa'}]},options:{responsive:true,maintainAspectRatio:false,plugins:{legend:{display:false},tooltip:{callbacks:{title:(items)=>data.bucketLabels[items[0].dataIndex]+' tokens'}}},scales:{x:{display:false},y:{display:false}}}}));
+			document.querySelectorAll('#'+el+' tr[data-row]').forEach(row=>row.addEventListener('click',()=>document.getElementById(el==='tools'?'toolSelect':'bashSelect').value=row.dataset.row,document.getElementById(el==='tools'?'toolSelect':'bashSelect').dispatchEvent(new Event('change'))));
+		}
+		function fillSelect(id,rows){document.getElementById(id).innerHTML=rows.map((r,i)=>'<option value="'+i+'">'+esc(r.name)+'</option>').join('')}
+		function summary(r){return fmt(r.calls)+' calls, '+fmt(r.results??r.samples.length)+' results, '+fmt(r.estimatedTokens)+' estimated result tokens, '+fmt(r.avg)+' avg/result'}
+		function singleHistogram(canvasId,summaryId,selectId,rows){
+			let chart;
+			function update(){
+				const row=rows[Number(document.getElementById(selectId).value)]??rows[0];
+				document.getElementById(summaryId).textContent=row?summary(row):'No data';
+				if(chart)chart.destroy();
+				chart=new Chart(document.getElementById(canvasId),{type:'bar',data:{labels:data.bucketLabels,datasets:[{label:row?.name??'',data:row?.histogram??[],backgroundColor:'#60a5fa'}]},options:{plugins:{legend:{display:false},tooltip:{callbacks:{title:(items)=>data.bucketLabels[items[0].dataIndex]+' tokens',label:(item)=>fmt(item.raw)+' results'}}},scales:{y:{beginAtZero:true,title:{display:true,text:'result count'}},x:{title:{display:true,text:'estimated tokens/result'}}}}});
+			}
+			document.getElementById(selectId).addEventListener('change',update);
+			update();
+		}
+		table(data.tools,'tools');
+		table(data.bashCommands,'bash');
+		fillSelect('toolSelect',data.tools);
+		fillSelect('bashSelect',data.bashCommands);
+		singleHistogram('toolHistogram','toolSummary','toolSelect',data.tools);
+		singleHistogram('bashHistogram','bashSummary','bashSelect',data.bashCommands);
+		new Chart(document.getElementById('tokens'),{type:'bar',data:{labels:data.tools.map(r=>r.name),datasets:[{label:'estimated tokens',data:data.tools.map(r=>r.estimatedTokens)}]},options:{plugins:{legend:{display:false}}}});
+		new Chart(document.getElementById('calls'),{type:'bar',data:{labels:data.tools.map(r=>r.name),datasets:[{label:'calls',data:data.tools.map(r=>r.calls)}]},options:{plugins:{legend:{display:false}}}});
+	</script>
+</body>
+</html>`;
+
+mkdirSync(resolve(output, ".."), { recursive: true });
+writeFileSync(output, html);
+console.log(`Wrote ${output}`);
+openBrowser(output);

package/.references/pi/scripts/update-source-imports-to-ts.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Rewrites relative source import specifiers in package source directories from .js to .ts.
+# TypeScript's rewriteRelativeImportExtensions option rewrites these back to .js in emitted output.
+find packages -mindepth 2 -maxdepth 2 -type d -name src -print0 |
+	while IFS= read -r -d '' src_dir; do
+		find "$src_dir" -type f -name '*.ts' -print0
+	done |
+	xargs -0 perl -0pi -e 's/(\b(?:from|import)\b\s*\(?\s*["\x27])(\.{1,2}\/[^"\x27\r\n]+)\.js(["\x27]\s*\)?)/$1$2.ts$3/g; s/(\bdeclare\s+module\s+["\x27])(\.{1,2}\/[^"\x27\r\n]+)\.js(["\x27])/$1$2.ts$3/g; s/(\bimportNodeOnlyProvider\(\s*["\x27])(\.{1,2}\/[^"\x27\r\n]+)\.js(["\x27]\s*\))/$1$2.ts$3/g'

package/.references/pi/test.sh

@@ -0,0 +1,81 @@
+#!/usr/bin/env bash
+set -e
+
+AUTH_FILE="$HOME/.pi/agent/auth.json"
+AUTH_BACKUP="$HOME/.pi/agent/auth.json.bak"
+
+# Restore auth.json on exit (success or failure)
+cleanup() {
+    if [[ -f "$AUTH_BACKUP" ]]; then
+        mv "$AUTH_BACKUP" "$AUTH_FILE"
+        echo "Restored auth.json"
+    fi
+}
+trap cleanup EXIT
+
+# Move auth.json out of the way
+if [[ -f "$AUTH_FILE" ]]; then
+    mv "$AUTH_FILE" "$AUTH_BACKUP"
+    echo "Moved auth.json to backup"
+fi
+
+# Skip local LLM tests (ollama, lmstudio)
+export PI_NO_LOCAL_LLM=1
+
+# Unset API keys (see packages/ai/src/stream.ts getEnvApiKey)
+unset ANTHROPIC_API_KEY
+unset ANTHROPIC_OAUTH_TOKEN
+unset ANT_LING_API_KEY
+unset NVIDIA_API_KEY
+unset OPENAI_API_KEY
+unset AZURE_OPENAI_API_KEY
+unset DEEPSEEK_API_KEY
+unset GEMINI_API_KEY
+unset GOOGLE_CLOUD_API_KEY
+unset GROQ_API_KEY
+unset CEREBRAS_API_KEY
+unset XAI_API_KEY
+unset OPENROUTER_API_KEY
+unset ZAI_API_KEY
+unset ZAI_CODING_CN_API_KEY
+unset MISTRAL_API_KEY
+unset MINIMAX_API_KEY
+unset MINIMAX_CN_API_KEY
+unset MOONSHOT_API_KEY
+unset KIMI_API_KEY
+unset HF_TOKEN
+unset FIREWORKS_API_KEY
+unset TOGETHER_API_KEY
+unset AI_GATEWAY_API_KEY
+unset OPENCODE_API_KEY
+unset CLOUDFLARE_API_KEY
+unset CLOUDFLARE_ACCOUNT_ID
+unset CLOUDFLARE_GATEWAY_ID
+unset XIAOMI_API_KEY
+unset XIAOMI_TOKEN_PLAN_CN_API_KEY
+unset XIAOMI_TOKEN_PLAN_AMS_API_KEY
+unset XIAOMI_TOKEN_PLAN_SGP_API_KEY
+unset RADIUS_API_KEY
+unset PI_GATEWAY
+unset PI_EXPERIMENTAL
+unset COPILOT_GITHUB_TOKEN
+unset GH_TOKEN
+unset GITHUB_TOKEN
+unset GOOGLE_APPLICATION_CREDENTIALS
+unset GOOGLE_CLOUD_PROJECT
+unset GCLOUD_PROJECT
+unset GOOGLE_CLOUD_LOCATION
+unset AWS_PROFILE
+unset AWS_ACCESS_KEY_ID
+unset AWS_SECRET_ACCESS_KEY
+unset AWS_SESSION_TOKEN
+unset AWS_REGION
+unset AWS_DEFAULT_REGION
+unset AWS_BEARER_TOKEN_BEDROCK
+unset AWS_CONTAINER_CREDENTIALS_RELATIVE_URI
+unset AWS_CONTAINER_CREDENTIALS_FULL_URI
+unset AWS_WEB_IDENTITY_TOKEN_FILE
+unset BEDROCK_EXTENSIVE_MODEL_TEST
+
+echo "Running tests without API keys..."
+npm test

package/.references/pi/tsconfig.base.json

@@ -0,0 +1,25 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "Node16",
+		"lib": ["ES2022"],
+		"strict": true,
+		"erasableSyntaxOnly": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"forceConsistentCasingInFileNames": true,
+		"declaration": true,
+		"declarationMap": true,
+		"sourceMap": true,
+		"inlineSources": true,
+		"inlineSourceMap": false,
+		"moduleResolution": "Node16",
+		"resolveJsonModule": true,
+		"allowImportingTsExtensions": true,
+		"rewriteRelativeImportExtensions": true,
+		"experimentalDecorators": true,
+		"emitDecoratorMetadata": true,
+		"useDefineForClassFields": false,
+		"types": ["node"]
+	}
+}

package/.references/pi/tsconfig.json

@@ -0,0 +1,27 @@
+{
+	"extends": "./tsconfig.base.json",
+	"compilerOptions": {
+		"noEmit": true,
+		"paths": {
+			"*": ["./*"],
+			"@earendil-works/pi-ai": ["./packages/ai/src/index.ts"],
+			"@earendil-works/pi-ai/oauth": ["./packages/ai/src/oauth.ts"],
+			"@earendil-works/pi-ai/*": ["./packages/ai/src/*.ts", "./packages/ai/src/providers/*.ts"],
+			"@earendil-works/pi-ai/dist/*": ["./packages/ai/src/*"],
+			"@earendil-works/pi-agent-core": ["./packages/agent/src/index.ts"],
+			"@earendil-works/pi-agent-core/*": ["./packages/agent/src/*"],
+			"@earendil-works/pi-coding-agent": ["./packages/coding-agent/src/index.ts"],
+			"@earendil-works/pi-coding-agent/hooks": ["./packages/coding-agent/src/core/hooks/index.ts"],
+			"@earendil-works/pi-coding-agent/*": ["./packages/coding-agent/src/*"],
+			"@earendil-works/pi-orchestrator": ["./packages/orchestrator/src/index.ts"],
+			"@earendil-works/pi-orchestrator/*": ["./packages/orchestrator/src/*"],
+			"typebox": ["./node_modules/typebox"],
+			"@earendil-works/pi-tui": ["./packages/tui/src/index.ts"],
+			"@earendil-works/pi-tui/*": ["./packages/tui/src/*"],
+			"@earendil-works/pi-agent-old": ["./packages/agent-old/src/index.ts"],
+			"@earendil-works/pi-agent-old/*": ["./packages/agent-old/src/*"]
+		}
+	},
+	"include": ["packages/*/src/**/*", "packages/*/test/**/*", "packages/coding-agent/examples/**/*"],
+	"exclude": ["**/dist/**", "packages/coding-agent/examples/extensions/gondolin/**"]
+}

package/AGENTS.md

@@ -0,0 +1,8 @@
+- Keep exactly five root workspace crates with these dependency edges only: `pi-agent -> pi-ai`, `pi-ext -> {pi-ai, pi-agent, pi-tui}`, and `pi -> {pi-ai, pi-agent, pi-ext, pi-tui}`; `pi-ai` and `pi-tui` must have no workspace dependencies. This topology preserves the provider, agent, extension, terminal, and product ownership boundaries.
+- Add a dependency only with its first callsite, after rechecking the current crate release and upstream repository for maintenance, yank status, Rust 1.97.1 compatibility, and an allowed license. This prevents speculative edges and stale or unusable pins from entering the lockfile.
+- Keep `pi-tui` product-agnostic and free of workspace dependencies. Terminal components must remain reusable without provider, agent, extension, or product policy.
+- Define serializable UI values in `pi-tui` during Phase 4. This keeps the native UI contract owned by the crate that interprets and renders it.
+- Define the JSONL extension envelope once in `pi-ext` during Phase 6, and implement the TypeScript side as a portable protocol client rather than a second authority. This prevents the Rust and TypeScript wire contracts from drifting.
+- Keep Bun out of built-in provider requests and native paint. Bun is permitted only in the bundled TypeScript extension host and extension-defined custom providers so native operation does not inherit host latency or availability.
+- Preserve wire and behavior compatibility with `.references/pi/packages/{ai,agent,coding-agent,tui}` rather than object-order or implementation identity. Those four packages are the authority for serialized names and observable contracts.
+- Omit only the settled exclusions: experimental `orchestrator`, the duplicate unused `AgentHarness` surface, `armin.ts`, `daxnuts.ts`, `earendil-announcement.ts`, announcement animations and network fetches, decorative easter eggs, install telemetry, and modifyOtherKeys-only modified Enter on legacy non-Kitty terminals. Treat every other compatibility surface as required so omissions cannot expand by convenience.