@phi-code-admin/phi-code 0.86.0 → 0.88.0

package/CHANGELOG.md

@@ -1,5 +1,109 @@
 # Changelog
 
+## [0.88.0] - 2026-07-10
+
+### Changed
+
+- **The /plan phase contract is now structured-primary with a text fallback**
+  (see `docs/adr/0001-phase-contract.md`). A phase agent CALLS a new
+  `phase_result` tool to emit its verdict / blocking / handoff as data;
+  `resolvePhaseOutcome` merges that structured emission field-by-field with the
+  regex-scraped markdown report, preferring the structured value. TEST and
+  REVIEW are instructed to call it. When a model does not call the tool,
+  behavior is identical to the previous text-only path — the change cannot make
+  any run worse. This replaces "regex luck" with an exact machine-read path for
+  the control-flow-critical signals (verdict, BLOCKED, the review-fix cycle).
+
+### Added
+
+- **End-to-end integration test of the orchestrator.** The real orchestrator
+  extension is now driven through a full multi-phase run against a simulated Pi
+  runtime (`test/orchestrator-integration.test.ts`): phase progression, handoff
+  propagation, the review-FAIL → fix → re-review cycle, and the BLOCKED pause
+  are all exercised together, not just the pure decision function. (Scripted
+  phase outcomes — deterministic, no live model.)
+- **An eval harness** (`evals/`) — the measurement infrastructure that did not
+  exist. Tasks with deterministic pass/fail verifiers, a runnable baseline
+  strategy (`npx tsx evals/run.ts`), unit-tested scoring/aggregation
+  (`test/evals-lib.test.ts`), and a demonstrated real run (2/2 baseline tasks on
+  a live model). `evals/README.md` documents the methodology and is honest that
+  the /plan-vs-baseline head-to-head is not yet a single number.
+- **Two ADRs** documenting the phase-contract decision and the independent-review
+  release gate (`docs/adr/`).
+
+### Fixed
+
+- Bugs found by an **independent adversarial review** of the phase-contract
+  change (see `docs/adr/0002-independent-review.md`), each now pinned by a
+  regression test:
+  - **State leak between runs**: `currentPhaseResult` was reset only in
+    `sendNextPhase`, but the first phase of each `/plan` run launches directly —
+    a stale structured result (e.g. a BLOCKED verdict) from a previous run could
+    abort a fresh run at phase 1. Reset on every run start + a phase-identity
+    stamp so a stale/late result is never mistaken for the current phase.
+  - **Field erasure on multi-call**: a second `phase_result` call replaced the
+    whole object, wiping a verdict set by the first; it now merges only the
+    fields each call sets.
+  - **Dead text fallback for PLAN/CODE**: `readPhaseReport` looked for
+    `<key>-<ts>.md` but PLAN writes `todo-<ts>.md` and CODE `progress-<ts>.md`,
+    so their handoff blocks were never read. Mapped key → report file.
+  - **`extractSection` over-matching**: a prose line starting with a section
+    word (e.g. "Blocking issues remain: 2") could be read as that section's
+    header. The plain-label form now requires `:` or end-of-line.
+- A TEST/REVIEW phase that finished with tool work but emitted no verdict at all
+  (neither structured nor a VERDICT line) is now surfaced instead of silently
+  passing.
+- **The eval runner** had two Windows bugs its first real run caught: temp-dir
+  cleanup raced `EPERM` (now retries), and `shell:true` with an args array
+  mangled the prompt (now a single quoted command string).
+
+### Tooling
+
+- Biome now also lints `evals/`.
+
+## [0.87.0] - 2026-07-10
+
+### Added
+
+- **The /plan orchestrator's phase state machine is now unit-tested.** Its
+  decision core — what to do after each phase given the messages and the report
+  (user abort > auth error > transient retry > BLOCKED pause > review-FAIL fix
+  cycle > continue) — is extracted into a pure module
+  (`extensions/phi/providers/phase-machine.ts`) and covered by 32 tests,
+  including the cases where a model deviates from the text contract: a missing
+  or unparseable `VERDICT:` line is now surfaced to the user instead of being
+  silently treated as a pass, and zero-tool-call / queue-race paths are pinned.
+  The `agent_end` hook keeps the exact same behavior but now only interprets
+  the decision (I/O), it no longer decides.
+- **Section parsing tolerates the header shapes models actually emit.**
+  `extractSection` (HANDOFF / BLOCKING) now handles a markdown heading, a
+  standalone bold label (`**HANDOFF**`) or a plain `LABEL:` line, and splits a
+  report written entirely with bold labels — previously a bold-only `**HANDOFF**`
+  returned nothing. Added regression tests for these deviations.
+
+### Changed
+
+- **extensions/ and the sigma-\* packages are now linted.** Biome previously
+  skipped them entirely (typecheck covered them, lint did not); they are in the
+  linted set and the whole repo is clean (`biome ci .` passes on 752 files,
+  zero warnings). Idiomatic-but-flagged regex-exec loops in web-search were
+  rewritten through an `execAll` generator rather than silenced with rule
+  overrides.
+- **Releases are reproducible.** `npm run build` no longer regenerates the
+  model catalog from models.dev — the committed `packages/ai/src/*.generated.ts`
+  is the source of truth and `build` just compiles it, so a publish ships
+  exactly what is in git. Regeneration is an explicit `npm run generate
+  --workspace=packages/ai` step; a scheduled `refresh-models.yml` workflow
+  opens a PR weekly so the catalog still stays fresh with a human in the loop.
+
+### CI / process
+
+- **CI now gates lint, format, types and catalog-cleanliness on every PR**
+  (`biome ci`, `tsgo --noEmit`, and `git diff --exit-code` on the generated
+  catalog), not just build + test — fork PRs that bypass the local pre-commit
+  hook are covered. A pull-request template makes the discipline checklist
+  explicit, and `docs/fork-policy.md` documents the reproducible-catalog flow.
+
 ## [0.86.0] - 2026-07-10
 
 ### Changed

package/docs/adr/0001-phase-contract.md

@@ -0,0 +1,57 @@
+# ADR 0001 — Structured-primary phase contract for /plan
+
+Status: accepted (2026-07-10)
+
+## Context
+
+The /plan orchestrator chains five agent phases (explore → plan → code → test
+→ review). Each phase must report two things the orchestrator acts on:
+
+- a **verdict** (TEST/REVIEW): PASS / FAIL / BLOCKED / SKIP, and
+- a **handoff** (+ BLOCKING findings for REVIEW) carried to the next phase.
+
+Originally this was communicated **only** as markdown the model wrote to
+`.phi/plans/<phase>-<ts>.md`, which the orchestrator scraped with regexes
+(`## VERDICT:`, `## HANDOFF`, `## BLOCKING`). That is fragile: models phrase
+headers inconsistently (`**HANDOFF**`, `HANDOFF:`, mid-sentence "verdict"), and
+a mis-scrape silently degrades control flow — a missed REVIEW FAIL skips the fix
+cycle; a missed BLOCKED keeps a doomed run going. The original justification for
+text-only was that the upstream proxy did not guarantee valid structured tool
+output.
+
+## Decision
+
+Keep the markdown report (it is the human-readable artifact) but make the
+**machine-read path structured and primary**:
+
+- The orchestrator registers a `phase_result` tool. TEST and REVIEW phases are
+  instructed to call it with `{verdict, blocking, handoff}`; any phase may call
+  it to hand off.
+- `resolvePhaseOutcome(structured, reportText)` (pure, unit-tested) merges the
+  two sources **field by field**, preferring the structured value and falling
+  back to the regex-scraped report per field. When the model calls the tool the
+  outcome is exact; when it does not, behavior is byte-for-byte the pre-existing
+  text path.
+- The text parser was hardened anyway (`extractSection` accepts heading, bold,
+  and plain-label forms) so the fallback is as robust as possible.
+
+## Why not go structured-only
+
+Two reasons the text path stays as a fallback rather than being removed:
+
+1. **Provider variance.** Not every provider/proxy reliably emits tool calls on
+   every turn; a model that writes a good report but forgets the tool call must
+   still drive the pipeline correctly.
+2. **Zero-regression migration.** Making structured additive means the change
+   cannot make any existing run worse — the worst case equals the old behavior.
+
+## Consequences
+
+- Robustness of control flow (verdict/BLOCKED/fix-cycle) now depends on a
+  structured emission when available, not on regex luck.
+- Two code paths must stay in sync; `resolvePhaseOutcome` centralizes the merge
+  and is covered by unit tests, and `orchestrator-integration.test.ts` drives
+  the whole chain via the structured path.
+- Follow-up (not done here): once telemetry shows the structured path is taken
+  reliably across the providers phi ships, the text fallback can be demoted to a
+  warning-only safety net.

package/docs/adr/0002-independent-review.md

@@ -0,0 +1,47 @@
+# ADR 0002 — Independent adversarial review as a release gate
+
+Status: accepted (2026-07-10)
+
+## Context
+
+phi-code is largely built by a single author, who is also the only reviewer.
+Self-review misses the bugs the author's mental model is blind to — the code
+does what the author *thinks* it does, and they test that. There is no external
+human reviewer on hand for every change.
+
+## Decision
+
+Before shipping a non-trivial change to a load-bearing subsystem (the /plan
+orchestrator, the model/provider layer, compaction, the extension runtime), run
+an **independent adversarial review**: a reviewer with fresh context that did
+not write the code, prompted to *refute* — to find state leaks, races, contract
+mismatches, and edge cases — not to approve.
+
+Findings are triaged (verify each against the code, discard false positives),
+the real ones are fixed, and each fix is pinned with a regression test before
+the change ships.
+
+## Evidence this works
+
+The structured-phase-contract change (ADR 0001) passed the author's own unit
+and integration tests. An independent review of that change then found four
+real defects the author's tests missed:
+
+- a structured result leaking from one `/plan` run into the next (a stale
+  BLOCKED verdict could abort a fresh run at phase 1);
+- a second `phase_result` call erasing fields set by the first;
+- no phase-identity guard against a late tool call landing after a transition;
+- the text HANDOFF fallback being dead for two phases due to a report-file name
+  mismatch.
+
+All four are now fixed and covered by regression tests
+(`orchestrator-integration.test.ts`, `phase-machine.test.ts`).
+
+## Consequences
+
+- "Green tests" is necessary but not sufficient for a load-bearing change; an
+  independent refutation pass is part of the definition of done.
+- The reviewer need not be human to be useful — it needs to be *independent of
+  the authoring context* and prompted adversarially. This is not a substitute
+  for real external users, whose absence remains an honest limitation of the
+  project's validation.

package/docs/fork-policy.md

@@ -61,3 +61,21 @@ use these constants, never a hardcoded "pi" or "phi".**
 `agents/`, `skills/`, `config/`, the `sigma-*` packages, and the browser and
 camoufox packages are phi-code territory: normal engineering rules apply,
 no merge constraints.
+
+## Reproducible releases: the generated model catalog
+
+`packages/ai/src/models.generated.ts` (and `image-models.generated.ts`) are
+**committed source files and the source of truth for every build**. `npm run
+build` compiles them with `tsgo`; it does NOT fetch models.dev, so a build/
+publish always ships exactly what is in git — releases are reproducible.
+
+Refreshing the catalog is a separate, explicit action:
+
+- `npm run generate --workspace=packages/ai` regenerates from models.dev.
+- The maintainer reviews the diff, commits it, and bumps `packages/ai`.
+- `.github/workflows/refresh-models.yml` does this weekly and opens a PR, so the
+  catalog never rots without a human in the loop.
+
+CI enforces the invariant: the `check` job fails if the committed catalog
+differs from a clean checkout (`git diff --exit-code`), catching both a stray
+hand-edit and any build that regenerated it.

package/extensions/phi/agents.ts

@@ -23,15 +23,18 @@ export default function agentsExtension(pi: ExtensionAPI) {
 			const arg = args.trim().toLowerCase();
 
 			if (agents.length === 0) {
-				ctx.ui.notify("No agent definitions found.\n\nCreate agent files in:\n- `.phi/agents/` (project)\n- `~/.phi/agent/agents/` (global)\n\nFormat: Markdown with YAML frontmatter (name, description, tools, model).", "info");
+				ctx.ui.notify(
+					"No agent definitions found.\n\nCreate agent files in:\n- `.phi/agents/` (project)\n- `~/.phi/agent/agents/` (global)\n\nFormat: Markdown with YAML frontmatter (name, description, tools, model).",
+					"info",
+				);
 				return;
 			}
 
 			// Show specific agent details
 			if (arg && arg !== "list") {
-				const agent = agents.find(a => a.name.toLowerCase() === arg);
+				const agent = agents.find((a) => a.name.toLowerCase() === arg);
 				if (!agent) {
-					ctx.ui.notify(`Agent "${arg}" not found. Available: ${agents.map(a => a.name).join(", ")}`, "warning");
+					ctx.ui.notify(`Agent "${arg}" not found. Available: ${agents.map((a) => a.name).join(", ")}`, "warning");
 					return;
 				}
 
@@ -39,7 +42,7 @@ export default function agentsExtension(pi: ExtensionAPI) {
 
 📝 ${agent.description}
 🤖 Model: \`${agent.model}\`
-🔧 Tools: ${agent.tools.map(t => `\`${t}\``).join(", ")}
+🔧 Tools: ${agent.tools.map((t) => `\`${t}\``).join(", ")}
 📁 Source: ${agent.source} (\`${agent.filePath}\`)
 
 **System Prompt:**

package/extensions/phi/benchmark.ts

@@ -17,10 +17,10 @@
  * - /benchmark clear      — Clear all results
  */
 
-import type { ExtensionAPI, ExtensionContext } from "phi-code";
-import { writeFile, mkdir, readFile, access } from "node:fs/promises";
-import { join } from "node:path";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
+import { join } from "node:path";
+import type { ExtensionAPI, ExtensionContext } from "phi-code";
 
 // ─── Types ───────────────────────────────────────────────────────────────
 
@@ -88,12 +88,12 @@ Respond with ONLY the function code, no explanations.`,
 					{ test: /(<=\s*0|===?\s*0|<\s*1)/.test(code), detail: "Handles edge case n=0" },
 					{ test: /(===?\s*1|<=\s*1)/.test(code), detail: "Handles edge case n=1" },
 				];
-				const passed = checks.filter(c => c.test).length;
+				const passed = checks.filter((c) => c.test).length;
 				const total = checks.length;
 				return {
 					passed: passed >= 5,
 					score: Math.round((passed / total) * 100),
-					details: checks.map(c => `${c.test ? "✅" : "❌"} ${c.detail}`).join("\n"),
+					details: checks.map((c) => `${c.test ? "✅" : "❌"} ${c.detail}`).join("\n"),
 				};
 			},
 		},
@@ -125,16 +125,29 @@ Explain the bug and provide the fixed code.`,
 			validate: (response: string) => {
 				const lower = response.toLowerCase();
 				const checks = [
-					{ test: /reference|shallow|copy|spread|\[\.\.\./.test(lower), detail: "Identifies reference/copy issue" },
-					{ test: /\[\.\.\.arr1\]|\[\.\.\.arr1,|Array\.from|\.slice\(\)|structuredClone|concat/.test(response), detail: "Uses spread/copy/concat fix" },
+					{
+						test: /reference|shallow|copy|spread|\[\.\.\./.test(lower),
+						detail: "Identifies reference/copy issue",
+					},
+					{
+						test: /\[\.\.\.arr1\]|\[\.\.\.arr1,|Array\.from|\.slice\(\)|structuredClone|concat/.test(response),
+						detail: "Uses spread/copy/concat fix",
+					},
 					{ test: /mutate|modify|original|side.?effect/.test(lower), detail: "Explains the mutation problem" },
-					{ test: /const result\s*=\s*\[/.test(response) || /\.slice\(/.test(response) || /\.concat\(/.test(response) || /Array\.from/.test(response), detail: "Creates new array in fix" },
+					{
+						test:
+							/const result\s*=\s*\[/.test(response) ||
+							/\.slice\(/.test(response) ||
+							/\.concat\(/.test(response) ||
+							/Array\.from/.test(response),
+						detail: "Creates new array in fix",
+					},
 				];
-				const passed = checks.filter(c => c.test).length;
+				const passed = checks.filter((c) => c.test).length;
 				return {
 					passed: passed >= 3,
 					score: Math.round((passed / checks.length) * 100),
-					details: checks.map(c => `${c.test ? "✅" : "❌"} ${c.detail}`).join("\n"),
+					details: checks.map((c) => `${c.test ? "✅" : "❌"} ${c.detail}`).join("\n"),
 				};
 			},
 		},
@@ -170,11 +183,11 @@ Provide a structured plan with specific files to create/modify, dependencies to
 					{ test: /env|secret|config/.test(lower), detail: "Addresses secret management" },
 					{ test: /step|phase|\d\.|create|modify|add/.test(lower), detail: "Provides structured steps" },
 				];
-				const passed = checks.filter(c => c.test).length;
+				const passed = checks.filter((c) => c.test).length;
 				return {
 					passed: passed >= 6,
 					score: Math.round((passed / checks.length) * 100),
-					details: checks.map(c => `${c.test ? "✅" : "❌"} ${c.detail}`).join("\n"),
+					details: checks.map((c) => `${c.test ? "✅" : "❌"} ${c.detail}`).join("\n"),
 				};
 			},
 		},
@@ -219,9 +232,15 @@ Output ONLY the JSON.`,
 					checks.push({ test: obj?.name?.first === "Alice", detail: 'name.first = "Alice"' });
 					checks.push({ test: obj?.name?.last === "Smith", detail: 'name.last = "Smith"' });
 					checks.push({ test: obj?.email === "alice@example.com", detail: "Correct email" });
-					checks.push({ test: typeof obj?.profile?.age === "number" && obj.profile.age === 28, detail: "Age is number 28" });
+					checks.push({
+						test: typeof obj?.profile?.age === "number" && obj.profile.age === 28,
+						detail: "Age is number 28",
+					});
 					checks.push({ test: obj?.preferences?.theme === "dark", detail: 'theme = "dark"' });
-					checks.push({ test: obj?.preferences?.notifications?.email === true, detail: "email notifications = true" });
+					checks.push({
+						test: obj?.preferences?.notifications?.email === true,
+						detail: "email notifications = true",
+					});
 				} catch {
 					checks.push({ test: false, detail: "Valid JSON (parse failed)" });
 					checks.push({ test: false, detail: "name.first" });
@@ -232,11 +251,11 @@ Output ONLY the JSON.`,
 					checks.push({ test: false, detail: "notifications" });
 				}
 
-				const passed = checks.filter(c => c.test).length;
+				const passed = checks.filter((c) => c.test).length;
 				return {
 					passed: passed >= 5,
 					score: Math.round((passed / checks.length) * 100),
-					details: checks.map(c => `${c.test ? "✅" : "❌"} ${c.detail}`).join("\n"),
+					details: checks.map((c) => `${c.test ? "✅" : "❌"} ${c.detail}`).join("\n"),
 				};
 			},
 		},
@@ -248,7 +267,11 @@ Output ONLY the JSON.`,
 			weight: 1,
 			prompt: `Reply with exactly this text and nothing else: "Hello, World!"`,
 			validate: (response: string) => {
-				const trimmed = response.trim().replace(/^["']|["']$/g, "").replace(/```\w*\n?/g, "").trim();
+				const trimmed = response
+					.trim()
+					.replace(/^["']|["']$/g, "")
+					.replace(/```\w*\n?/g, "")
+					.trim();
 				const exact = trimmed === "Hello, World!";
 				const close = trimmed.toLowerCase().includes("hello, world");
 				return {
@@ -287,15 +310,23 @@ Be specific and technical.`,
 					{ test: /memory.?leak|leak/.test(lower), detail: "Identifies memory leak" },
 					{ test: /stream|buffer|file|upload|temp|cleanup/.test(lower), detail: "Links to file upload handling" },
 					{ test: /close|destroy|cleanup|dispose|gc|garbage/.test(lower), detail: "Suggests resource cleanup" },
-					{ test: /event.?listener|handler|remove|off/.test(lower) || /stream|pipe/.test(lower), detail: "Checks for handler/stream leaks" },
-					{ test: /heapdump|heap.?snapshot|inspect|profile|--max-old-space/.test(lower) || /process\.memoryUsage/.test(lower), detail: "Suggests debugging tools" },
+					{
+						test: /event.?listener|handler|remove|off/.test(lower) || /stream|pipe/.test(lower),
+						detail: "Checks for handler/stream leaks",
+					},
+					{
+						test:
+							/heapdump|heap.?snapshot|inspect|profile|--max-old-space/.test(lower) ||
+							/process\.memoryUsage/.test(lower),
+						detail: "Suggests debugging tools",
+					},
 					{ test: /monitor|alert|metric|prometheus|grafana|threshold/.test(lower), detail: "Suggests monitoring" },
 				];
-				const passed = checks.filter(c => c.test).length;
+				const passed = checks.filter((c) => c.test).length;
 				return {
 					passed: passed >= 4,
 					score: Math.round((passed / checks.length) * 100),
-					details: checks.map(c => `${c.test ? "✅" : "❌"} ${c.detail}`).join("\n"),
+					details: checks.map((c) => `${c.test ? "✅" : "❌"} ${c.detail}`).join("\n"),
 				};
 			},
 		},
@@ -322,7 +353,16 @@ function getProviderConfigs(): ProviderConfig[] {
 			name: "alibaba-codingplan",
 			envVar: "ALIBABA_CODING_PLAN_KEY",
 			baseUrl: "https://coding-intl.dashscope.aliyuncs.com/v1",
-			models: ["qwen3.5-plus", "qwen3-max-2026-01-23", "qwen3-coder-plus", "qwen3-coder-next", "kimi-k2.5", "glm-5", "glm-4.7", "MiniMax-M2.5"],
+			models: [
+				"qwen3.5-plus",
+				"qwen3-max-2026-01-23",
+				"qwen3-coder-plus",
+				"qwen3-coder-next",
+				"kimi-k2.5",
+				"glm-5",
+				"glm-4.7",
+				"MiniMax-M2.5",
+			],
 		},
 		{
 			name: "openai",
@@ -386,14 +426,16 @@ async function getAvailableModels(): Promise<Array<{ id: string; provider: strin
 						for (const m of providerConfig.models) {
 							const modelId = typeof m === "string" ? m : m.id;
 							// Skip if already added from env vars
-							if (!models.some(existing => existing.id === modelId && existing.baseUrl === baseUrl)) {
+							if (!models.some((existing) => existing.id === modelId && existing.baseUrl === baseUrl)) {
 								models.push({ id: modelId, provider: id, baseUrl, apiKey });
 							}
 						}
 					}
 				}
 			}
-		} catch { /* ignore parse errors */ }
+		} catch {
+			/* ignore parse errors */
+		}
 	}
 
 	// 3. Try to detect LM Studio (port 1234) and Ollama (port 11434) directly
@@ -402,7 +444,7 @@ async function getAvailableModels(): Promise<Array<{ id: string; provider: strin
 		{ name: "ollama", port: 11434, baseUrl: "http://localhost:11434/v1" },
 	]) {
 		// Skip if already discovered via models.json
-		if (models.some(m => m.baseUrl === local.baseUrl)) continue;
+		if (models.some((m) => m.baseUrl === local.baseUrl)) continue;
 
 		try {
 			const controller = new AbortController();
@@ -411,16 +453,18 @@ async function getAvailableModels(): Promise<Array<{ id: string; provider: strin
 			clearTimeout(timeout);
 
 			if (resp.ok) {
-				const data = await resp.json() as any;
+				const data = (await resp.json()) as any;
 				const modelList = data?.data || [];
 				for (const m of modelList) {
 					const modelId = m.id || m.name;
-					if (modelId && !models.some(existing => existing.id === modelId)) {
+					if (modelId && !models.some((existing) => existing.id === modelId)) {
 						models.push({ id: modelId, provider: local.name, baseUrl: local.baseUrl, apiKey: "local" });
 					}
 				}
 			}
-		} catch { /* not running */ }
+		} catch {
+			/* not running */
+		}
 	}
 
 	return models;
@@ -514,7 +558,7 @@ export default function benchmarkExtension(pi: ExtensionAPI) {
 		for (let testIdx = 0; testIdx < tests.length; testIdx++) {
 			const test = tests[testIdx];
 			// Rate limiting: 1.5s between API calls to avoid throttling
-			if (testIdx > 0) await new Promise(r => setTimeout(r, 1500));
+			if (testIdx > 0) await new Promise((r) => setTimeout(r, 1500));
 			ctx.ui.notify(`  ⏳ ${test.category}: ${test.name}...`, "info");
 
 			try {
@@ -586,15 +630,24 @@ export default function benchmarkExtension(pi: ExtensionAPI) {
 		report += "**Leaderboard:**\n";
 		sorted.forEach((r, i) => {
 			const medal = i === 0 ? "🥇" : i === 1 ? "🥈" : i === 2 ? "🥉" : `${i + 1}.`;
-			const tier = r.totalScore >= 80 ? "S" : r.totalScore >= 65 ? "A" : r.totalScore >= 50 ? "B" : r.totalScore >= 35 ? "C" : "D";
+			const tier =
+				r.totalScore >= 80
+					? "S"
+					: r.totalScore >= 65
+						? "A"
+						: r.totalScore >= 50
+							? "B"
+							: r.totalScore >= 35
+								? "C"
+								: "D";
 			report += `${medal} **${r.modelId}** — ${r.totalScore}/100 [${tier}] (avg ${r.avgTimeMs}ms)\n`;
 		});
 
 		// Category breakdown
 		report += "\n**Category Breakdown:**\n```\n";
-		const header = "Model".padEnd(25) + categories.map(c => c.substring(0, 8).padEnd(10)).join("") + "TOTAL\n";
+		const header = `${"Model".padEnd(25) + categories.map((c) => c.substring(0, 8).padEnd(10)).join("")}TOTAL\n`;
 		report += header;
-		report += "-".repeat(header.length) + "\n";
+		report += `${"-".repeat(header.length)}\n`;
 
 		for (const r of sorted) {
 			let line = r.modelId.substring(0, 24).padEnd(25);
@@ -603,7 +656,7 @@ export default function benchmarkExtension(pi: ExtensionAPI) {
 				line += String(score).padEnd(10);
 			}
 			line += String(r.totalScore);
-			report += line + "\n";
+			report += `${line}\n`;
 		}
 		report += "```\n";
 
@@ -627,7 +680,8 @@ export default function benchmarkExtension(pi: ExtensionAPI) {
 	// ─── Command ─────────────────────────────────────────────────────────
 
 	pi.registerCommand("benchmark", {
-		description: "Run AI model benchmarks (6 categories: code-gen, debug, planning, tool-calling, speed, orchestration)",
+		description:
+			"Run AI model benchmarks (6 categories: code-gen, debug, planning, tool-calling, speed, orchestration)",
 		handler: async (args, ctx) => {
 			const arg = args.trim().toLowerCase();
 
@@ -658,7 +712,8 @@ export default function benchmarkExtension(pi: ExtensionAPI) {
 
 			// Help
 			if (arg === "help" || arg === "?") {
-				ctx.ui.notify(`**Phi Code Benchmark** — 6 categories, real API calls
+				ctx.ui.notify(
+					`**Phi Code Benchmark** — 6 categories, real API calls
 
 Commands:
   /benchmark              Run on current model
@@ -676,7 +731,9 @@ Categories tested (weighted):
   ⏱️ speed (×1)          — Response latency
   🧩 orchestration (×2)  — Multi-step analysis
 
-Scoring: S (80+), A (65+), B (50+), C (35+), D (<35)`, "info");
+Scoring: S (80+), A (65+), B (50+), C (35+), D (<35)`,
+					"info",
+				);
 				return;
 			}
 
@@ -684,8 +741,13 @@ Scoring: S (80+), A (65+), B (50+), C (35+), D (<35)`, "info");
 			const available = await getAvailableModels();
 			if (available.length === 0) {
 				const providers = getProviderConfigs();
-				const hint = providers.map(p => `  ${p.envVar}: ${process.env[p.envVar] ? "set but no models configured" : "not set"}`).join("\n");
-				ctx.ui.notify(`❌ No benchmarkable models found.\n\nProvider status:\n${hint}\n\nSet at least one API key with known models.`, "warning");
+				const hint = providers
+					.map((p) => `  ${p.envVar}: ${process.env[p.envVar] ? "set but no models configured" : "not set"}`)
+					.join("\n");
+				ctx.ui.notify(
+					`❌ No benchmarkable models found.\n\nProvider status:\n${hint}\n\nSet at least one API key with known models.`,
+					"warning",
+				);
 				return;
 			}
 
@@ -700,7 +762,7 @@ Scoring: S (80+), A (65+), B (50+), C (35+), D (<35)`, "info");
 					const result = await benchmarkModel(model.id, model.provider, model.baseUrl, model.apiKey, ctx);
 
 					// Replace existing result for this model
-					store.results = store.results.filter(r => r.modelId !== model.id);
+					store.results = store.results.filter((r) => r.modelId !== model.id);
 					store.results.push(result);
 					await saveStore(store);
 				}
@@ -713,21 +775,27 @@ Scoring: S (80+), A (65+), B (50+), C (35+), D (<35)`, "info");
 			if (arg) {
 				// Benchmark specific model: prefer exact id match, then require an
 				// unambiguous substring match to avoid benchmarking the wrong model.
-				const exact = available.find(m => m.id.toLowerCase() === arg);
-				const matches = available.filter(m => m.id.toLowerCase().includes(arg));
+				const exact = available.find((m) => m.id.toLowerCase() === arg);
+				const matches = available.filter((m) => m.id.toLowerCase().includes(arg));
 				const model = exact ?? (matches.length === 1 ? matches[0] : undefined);
 				if (!model) {
 					if (!exact && matches.length > 1) {
-						ctx.ui.notify(`Model "${arg}" is ambiguous. Did you mean:\n${matches.map(m => `  - ${m.id} (${m.provider})`).join("\n")}`, "warning");
+						ctx.ui.notify(
+							`Model "${arg}" is ambiguous. Did you mean:\n${matches.map((m) => `  - ${m.id} (${m.provider})`).join("\n")}`,
+							"warning",
+						);
 						return;
 					}
-					ctx.ui.notify(`Model "${arg}" not found or no API key. Available:\n${available.map(m => `  - ${m.id} (${m.provider})`).join("\n")}`, "warning");
+					ctx.ui.notify(
+						`Model "${arg}" not found or no API key. Available:\n${available.map((m) => `  - ${m.id} (${m.provider})`).join("\n")}`,
+						"warning",
+					);
 					return;
 				}
 
 				ctx.ui.notify(`🧪 Benchmarking **${model.id}** (6 categories)...\n`, "info");
 				const result = await benchmarkModel(model.id, model.provider, model.baseUrl, model.apiKey, ctx);
-				store.results = store.results.filter(r => r.modelId !== model.id);
+				store.results = store.results.filter((r) => r.modelId !== model.id);
 				store.results.push(result);
 				await saveStore(store);
 
@@ -739,11 +807,17 @@ Scoring: S (80+), A (65+), B (50+), C (35+), D (<35)`, "info");
 			// Try to find current model in available list
 			const currentModel = ctx.model;
 			if (currentModel) {
-				const modelConfig = available.find(m => m.id === currentModel.id);
+				const modelConfig = available.find((m) => m.id === currentModel.id);
 				if (modelConfig) {
 					ctx.ui.notify(`🧪 Benchmarking current model **${currentModel.id}** (6 categories)...\n`, "info");
-					const result = await benchmarkModel(modelConfig.id, modelConfig.provider, modelConfig.baseUrl, modelConfig.apiKey, ctx);
-					store.results = store.results.filter(r => r.modelId !== modelConfig.id);
+					const result = await benchmarkModel(
+						modelConfig.id,
+						modelConfig.provider,
+						modelConfig.baseUrl,
+						modelConfig.apiKey,
+						ctx,
+					);
+					store.results = store.results.filter((r) => r.modelId !== modelConfig.id);
 					store.results.push(result);
 					await saveStore(store);
 					ctx.ui.notify(`\n✅ **${currentModel.id}** — Total: ${result.totalScore}/100`, "info");
@@ -752,7 +826,10 @@ Scoring: S (80+), A (65+), B (50+), C (35+), D (<35)`, "info");
 			}
 
 			// Fallback: show available models
-			ctx.ui.notify(`Available models for benchmark:\n${available.map(m => `  - ${m.id} (${m.provider})`).join("\n")}\n\nUsage: /benchmark <model-id> or /benchmark all`, "info");
+			ctx.ui.notify(
+				`Available models for benchmark:\n${available.map((m) => `  - ${m.id} (${m.provider})`).join("\n")}\n\nUsage: /benchmark <model-id> or /benchmark all`,
+				"info",
+			);
 		},
 	});
 
@@ -761,7 +838,10 @@ Scoring: S (80+), A (65+), B (50+), C (35+), D (<35)`, "info");
 		try {
 			const store = await loadStore();
 			if (store.results.length > 0) {
-				ctx.ui.notify(`🧪 ${store.results.length} benchmark results available. /benchmark results to view.`, "info");
+				ctx.ui.notify(
+					`🧪 ${store.results.length} benchmark results available. /benchmark results to view.`,
+					"info",
+				);
 			}
 		} catch {
 			// ignore