@jwilger/pi-development-system 0.44.0 → 0.45.1

package/agents/implementer.md

@@ -37,7 +37,7 @@ You are an implementer. You receive exactly one task record and nothing else: do
 
 End with evidence the coordinator can check, one block per command you ran:
 
-```
+```text
 Run: <exact command>
 Expected: <what the task said>
 Actual: <what you saw, quoted>

package/extensions/development-system.ts

@@ -148,8 +148,9 @@ export function createDevelopmentSystem(pi: ExtensionAPI) {
 
   pi.registerCommand("devsys-status", {
     description: "Show development-system phase, sizing, slice, departures and Jev status",
-    handler: async (_args, ctx) => {
+    handler: (_args, ctx) => {
       ctx.ui.notify(renderStatus(state.get(), jevModel), "info");
+      return Promise.resolve();
     },
   });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jwilger/pi-development-system",
-  "version": "0.44.0",
+  "version": "0.45.1",
   "description": "A pi extension package representing a seasoned approach to software development using a full AI SDLC.",
   "keywords": [
     "pi-package"
@@ -51,6 +51,8 @@
     "@types/node": "^26.6.4",
     "@types/shell-quote": "^1.7.5",
     "@typesafe-ai/sdk": "^0.6.0",
+    "knip": "^6.40.0",
+    "markdownlint-cli2": "^0.23.3",
     "typescript": "^7.0.2"
   },
   "scripts": {
@@ -61,6 +63,8 @@
     "lint": "biome check .",
     "lint:fix": "biome check --write .",
     "check:build-gate": "node scripts/build-gate.ts",
-    "check:version": "node scripts/check-version.ts"
+    "check:version": "node scripts/check-version.ts",
+    "lint:knip": "knip",
+    "lint:md": "markdownlint-cli2"
   }
 }

package/principles/NON-NEGOTIABLES.md

@@ -5,31 +5,41 @@ Departing from any item below requires an explicit decision from the author
 departure is warranted: stop, say which item and why, and ask.
 
 ## 1. Never rewrite pushed history or force-push
+
 Amend/rebase/reset of pushed refs, `--force*`, deleting shared branches. Because it destroys other people's basis for trust.
 
 ## 2. Never weaken verification to make a gate pass
+
 Deleting, skipping or loosening tests; suppressing a lint; editing expected values to match output; `--no-verify`. Because a green gate must mean the same thing afterwards. (Changing a test because the *requirement* changed is a recorded departure, not this.)
 
 ## 3. Never claim something was verified, run, or green that was not
+
 Because the record of evidence is the product. Evidence comes before claims.
 
 ## 4. Never push on a red trunk
+
 Except a change whose purpose is fixing that failure. Because unrelated work on red hides the signal.
 
 ## 5. Never work around an unresolved gate
+
 Stop, record, ask. Because a gate you can route around is not a gate.
 
 ## 6. Never violate repo-local delivery policy
+
 Delivery mode, protected branches, required reviews. Because the repo, not this tool, owns policy.
 
 ## 7. Never let secrets leave the machine without sanitisation
+
 In commits, logs, eval cases, or subagent prompts. Because exfiltration is irreversible.
 
 ## 8. Never commit without a rationale-bearing Conventional Commit, or add AI attribution trailers
+
 No `Co-Authored-By`, no `Generated-by`. Because the message is the durable why; attribution noise is not.
 
 ## 9. Never make an architecture-shaping decision without an ADR
+
 New dependency class, boundary change, persistence model, public contract. Because "Revisit when" is how decisions stay honest.
 
 ## 10. Never ship model-visible instructions without an evidence check
+
 Skills, prompts, Jev questions need a fixture or eval. Because effectiveness is eval-driven, not vibes.

package/src/context/model-advice.ts

@@ -56,6 +56,6 @@ export function registerModelAdvice(deps: ModelAdviceDeps): void {
   deps.state.onChange((state) => {
     if (state.phase === phase) return;
     phase = state.phase;
-    if (last !== undefined) void check(last).catch(() => undefined);
+    if (last !== undefined) check(last).catch(() => undefined);
   });
 }

package/src/context/status.ts

@@ -13,7 +13,7 @@ const ciLabel = (state: DevsysState): string | undefined => {
   return `ci ${ci.status}${sha}`;
 };
 
-export const activeReview = (state: DevsysState): string | undefined => {
+const activeReview = (state: DevsysState): string | undefined => {
   // Without an active slice (before /devsys-start exists) show the most recent review instead of nothing.
   const review =
     state.activeSlice === undefined ? state.reviews?.at(-1) : reviewOf(state, state.activeSlice);

package/src/context/system-prompt.ts

@@ -1,7 +1,7 @@
 import type { BeforeAgentStartEvent } from "@earendil-works/pi-coding-agent";
 import type { DevsysState } from "../core/types.ts";
 
-export const PROMPT_SECTION_NAME = "development-system";
+const PROMPT_SECTION_NAME = "development-system";
 
 /** Pure: renders the system-prompt section from current state. */
 export function buildPromptSection(state: DevsysState, nonNegotiables: string): string {

package/src/context/turn-verifier.ts

@@ -7,9 +7,9 @@ import type { Jev } from "../jev/client.ts";
 import { judgeTurn, type ToolEvidence } from "../jev/questions/turn.ts";
 import type { SessionState } from "../state/session-state.ts";
 
-export const VERIFIER_THRESHOLD = 0.75;
+const VERIFIER_THRESHOLD = 0.75;
 export const DEFAULT_VERIFIER_MAX = 6;
-export const VERIFIER_ENTRY_TYPE = "devsys-verifier";
+const VERIFIER_ENTRY_TYPE = "devsys-verifier";
 const VERIFIED_PHASES: ReadonlySet<Phase> = new Set(["implementing", "reviewing", "delivering"]);
 const MAX_EVIDENCE = 60;
 
@@ -23,7 +23,7 @@ export type TurnVerifierDeps = {
 type Parts = { text: string; callsTools: boolean };
 
 /** Text and tool-call presence of an assistant message; undefined for any other role. */
-export function assistantParts(message: AgentMessage): Parts | undefined {
+function assistantParts(message: AgentMessage): Parts | undefined {
   if (message.role !== "assistant") return undefined;
   const text = message.content.flatMap((c) => (c.type === "text" ? [c.text] : [])).join("\n");
   return { text, callsTools: message.content.some((c) => c.type === "toolCall") };

package/src/core/departure.ts

@@ -1,3 +1,4 @@
+import { assertNever } from "./exhaustive.ts";
 import {
   type Departure,
   type DepartureId,
@@ -69,6 +70,8 @@ function renderScope(scope: DepartureScope): string {
       return "session";
     case "once":
       return `once (${scope.toolCallId})`;
+    default:
+      return assertNever(scope);
   }
 }
 
@@ -76,7 +79,8 @@ function renderScope(scope: DepartureScope): string {
 export function renderDepartureMarkdown(d: Departure): string {
   const revisit = d.revisitWhen !== undefined ? ` · **Revisit when:** ${d.revisitWhen}` : "";
   return [
-    `### ${d.recordedAt} · ${d.gate} · ${d.tier} · ${d.approver}`,
+    `## ${d.recordedAt} · ${d.gate} · ${d.tier} · ${d.approver}`,
+    "",
     `- **Default:** ${d.default}`,
     `- **Chosen:** ${d.chosen}`,
     `- **Why:** ${d.why}`,

package/src/core/exhaustive.ts

@@ -0,0 +1,4 @@
+/** Compile-time proof that a switch covered every case; a runtime hit means a parse boundary let an impossible value through. */
+export function assertNever(value: never): never {
+  throw new Error(`unhandled case: ${JSON.stringify(value)}`);
+}

package/src/core/gates.ts

@@ -3,7 +3,7 @@ import type { Tier } from "./types.ts";
 export type GateInfo = { readonly tier: Tier; readonly default: string };
 
 /** Registered gate ids (plan Appendix A); grows per increment. Qualified ids use their base entry. */
-export const GATES: Readonly<Record<string, GateInfo>> = {
+const GATES: Readonly<Record<string, GateInfo>> = {
   "git.history-rewrite": { tier: "hard", default: "never rewrite published history" },
   "git.force-push": { tier: "hard", default: "never force-push" },
   "git.branch-delete-remote": { tier: "hard", default: "never delete remote branches" },

package/src/core/git-intent.ts

@@ -24,6 +24,7 @@ const worst = (a: GitIntent, b: GitIntent): GitIntent =>
   SEVERITY.indexOf(a) <= SEVERITY.indexOf(b) ? a : b;
 
 /** Splits a command string on newlines that are outside quotes; backslash-newline is a continuation. */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: a shell lexer is one flat branch per character class; splitting it would scatter a single state machine across helpers
 export function splitLines(command: string): string[] {
   const lines: string[] = [];
   let current = "";
@@ -63,7 +64,7 @@ export function segments(line: string): string[][] {
   const result: string[][] = [[]];
   let skipOperand = false;
   for (const token of parseShell(line, (name) => `$${name}`)) {
-    const current = result[result.length - 1];
+    const current = result.at(-1);
     if (typeof token === "string" || "pattern" in token) {
       const text = typeof token === "string" ? token : token.pattern;
       if (!skipOperand) current?.push(text);
@@ -179,26 +180,50 @@ function classifyGitArgs(globals: string[], sub: string | undefined, args: strin
   }
 }
 
-function classifySegment(tokens: string[]): GitIntent {
+/** Skips leading `NAME=value` words, wrappers and shell keywords; `index` is the command word (-1: none). */
+function skipPrefix(tokens: string[]): { index: number; hookSkip: boolean } {
   let hookSkip = false;
-  let i = 0;
+  let index = 0;
   for (;;) {
-    const t = tokens[i];
-    if (t === undefined) return "ordinary";
+    const t = tokens[index];
+    if (t === undefined) return { index: -1, hookSkip };
     if (isAssignment(t)) {
       if (HOOK_SKIP_ENV.has(t)) hookSkip = true;
-      i++;
-    } else if (WRAPPERS.has(t) || KEYWORDS.has(t)) {
-      i++;
+    } else if (!(WRAPPERS.has(t) || KEYWORDS.has(t))) {
+      return { index, hookSkip };
+    }
+    index++;
+  }
+}
+
+/** Git's global options (`-c k=v`, `-C dir`, flags) before the subcommand. */
+function splitGlobals(rest: string[]): {
+  globals: string[];
+  sub: string | undefined;
+  args: string[];
+} {
+  const globals: string[] = [];
+  let j = 0;
+  while (j < rest.length && (rest[j] ?? "").startsWith("-")) {
+    const opt = rest[j] ?? "";
+    if (GLOBAL_WITH_VALUE.has(opt)) {
+      globals.push(rest[j + 1] ?? "");
+      j += 2;
     } else {
-      break;
+      j++;
     }
   }
+  return { globals, sub: rest[j], args: rest.slice(j + 1) };
+}
+
+function classifySegment(tokens: string[]): GitIntent {
+  const { index: i, hookSkip } = skipPrefix(tokens);
+  if (i < 0) return "ordinary";
   const head = tokens[i] ?? "";
   const rest = tokens.slice(i + 1);
   const base = basename(head);
-  const withHookSkip = (intent: GitIntent): GitIntent =>
-    hookSkip ? worst(intent, "no-verify") : intent;
+  const withHookSkip = (found: GitIntent): GitIntent =>
+    hookSkip ? worst(found, "no-verify") : found;
   if (head.startsWith("$") || base === "$GIT") return "unknown";
   if (SHELLS.has(base)) {
     const c = rest.findIndex((t) => /^-[A-Za-z]*c[A-Za-z]*$/.test(t));
@@ -213,19 +238,7 @@ function classifySegment(tokens: string[]): GitIntent {
     const at = rest.findIndex((t) => basename(t) === "git");
     return at >= 0 ? withHookSkip(classifySegment(rest.slice(at))) : "ordinary";
   }
-  const globals: string[] = [];
-  let j = 0;
-  while (j < rest.length && (rest[j] ?? "").startsWith("-")) {
-    const opt = rest[j] ?? "";
-    if (GLOBAL_WITH_VALUE.has(opt)) {
-      globals.push(rest[j + 1] ?? "");
-      j += 2;
-    } else {
-      j++;
-    }
-  }
-  const sub = rest[j];
-  const args = rest.slice(j + 1);
+  const { globals, sub, args } = splitGlobals(rest);
   const dynamic =
     (sub ?? "").startsWith("$") ||
     (["push", "reset", "rebase"].includes(sub ?? "") &&

package/src/core/git-invocations.ts

@@ -15,7 +15,7 @@ import {
 } from "./git-intent.ts";
 import { stripHeredocs } from "./heredoc.ts";
 
-export type GitInvocation = {
+type GitInvocation = {
   readonly sub: string;
   readonly args: readonly string[];
   /** Directory the command runs in, relative to the starting one (from `cd` and `git -C`), when it moved. */

package/src/core/model-advice.ts

@@ -9,7 +9,7 @@ import {
 import type { Phase } from "./types.ts";
 
 /** Highest first. */
-export const TIERS = ["frontier", "strong", "fast"] as const;
+const TIERS = ["frontier", "strong", "fast"] as const;
 export type Tier = (typeof TIERS)[number];
 
 const PHASE_SLOT: Partial<Record<Phase, Slot>> = {

package/src/core/profile.ts

@@ -4,14 +4,14 @@ import { isParseError, type ParseError, type Profile, parseError } from "./types
 
 export type { Profile };
 
-export const PROFILES: readonly Profile[] = ["rust", "typescript"];
+const PROFILES: readonly Profile[] = ["rust", "typescript"];
 
 const MARKERS: ReadonlyArray<{ profile: Profile; files: readonly string[] }> = [
   { profile: "rust", files: ["Cargo.toml"] },
   { profile: "typescript", files: ["package.json", "tsconfig.json"] },
 ];
 
-export const isProfile = (value: string): value is Profile => PROFILES.some((p) => p === value);
+const isProfile = (value: string): value is Profile => PROFILES.some((p) => p === value);
 
 /** Boundary parse for configured profile names. */
 export function parseProfiles(names: readonly string[]): Profile[] | ParseError {

package/src/core/review-flow.ts

@@ -1,3 +1,4 @@
+import { assertNever } from "./exhaustive.ts";
 import {
   cleanStreak,
   type Finding,
@@ -47,7 +48,8 @@ export function reviewGap(state: DevsysState, slice: SliceRef, now: DiffNow): st
   if (review === undefined || review.rounds.length === 0) {
     return `no review has been recorded for slice ${slice}`;
   }
-  switch (nextAction(review, now.digest)) {
+  const action = nextAction(review, now.digest);
+  switch (action) {
     case "done":
       return undefined;
     case "fix-findings":
@@ -58,6 +60,8 @@ export function reviewGap(state: DevsysState, slice: SliceRef, now: DiffNow): st
       return `the diff has changed since slice ${slice} was last reviewed; review it again`;
     case "review":
       return `slice ${slice} has ${cleanStreak(review)}/${review.required} clean review rounds`;
+    default:
+      return assertNever(action);
   }
 }
 
@@ -106,7 +110,7 @@ export function combinePackets(packets: readonly ReviewPacket[]): {
 }
 
 /** Jev confidence needed before its severity replaces the reviewer's. */
-export const SEVERITY_ADOPT_CONFIDENCE = 0.8;
+const SEVERITY_ADOPT_CONFIDENCE = 0.8;
 
 const counts = (severity: Severity): boolean =>
   severity === "blocking" || severity === "should-fix";

package/src/core/review.ts

@@ -90,7 +90,7 @@ export const LENSES = [
   "performance",
 ] as const;
 export type Lens = (typeof LENSES)[number];
-export const LENS_THRESHOLD = 0.5;
+const LENS_THRESHOLD = 0.5;
 
 /** Lenses that apply when Jev is offline: the ones every change deserves. */
 export const DEFAULT_LENSES: ReadonlyArray<Lens> = ["types", "tests"];
@@ -141,7 +141,7 @@ function parseRound(input: unknown): ReviewRound | ParseError {
   if (typeof n !== "number" || typeof reviewedAt !== "string" || typeof diffDigest !== "string") {
     return parseError("round needs number n and string reviewedAt and diffDigest");
   }
-  if (!Array.isArray(lenses) || !lenses.every((l) => typeof l === "string")) {
+  if (!(Array.isArray(lenses) && lenses.every((l) => typeof l === "string"))) {
     return parseError("round lenses must be an array of strings");
   }
   if (!Array.isArray(findings)) return parseError("round findings must be an array");

package/src/core/test-weakening.ts

@@ -125,6 +125,7 @@ type Segment = { words: string[]; truncates: string[] };
 type Token = { kind: "word"; value: string } | { kind: "op"; op: string };
 
 /** Turns unquoted newlines into `;` (and joins backslash continuations) so shell-quote sees every command. */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: a shell lexer is one flat branch per character class; splitting it would scatter a single state machine across helpers
 function splitLines(command: string): string {
   let out = "";
   let quote: "'" | '"' | undefined;

package/src/core/types.ts

@@ -22,12 +22,6 @@ export function parseGateId(input: string): GateId | ParseError {
     : parseError(`invalid gate id "${input}": expected dotted kebab-case like "git.force-push"`);
 }
 
-export type GateDecision =
-  | { readonly kind: "allow" }
-  | { readonly kind: "block"; readonly reason: string }
-  | { readonly kind: "require-departure"; readonly gate: GateId; readonly reason: string }
-  | { readonly kind: "require-user"; readonly gate: GateId; readonly reason: string };
-
 export type Phase = "intake" | "planning" | "implementing" | "reviewing" | "delivering" | "idle";
 
 export type Sizing = "fix" | "change" | "capability" | "product";

package/src/gates/approvals.ts

@@ -6,7 +6,7 @@ import { type GateId, isParseError } from "../core/types.ts";
 import { appendDecision } from "../state/decision-log.ts";
 import { DEPARTURE_ENTRY_TYPE } from "./record-departure-tool.ts";
 
-export const APPROVAL_ENTRY_TYPE = "devsys-approval";
+const APPROVAL_ENTRY_TYPE = "devsys-approval";
 
 type Approval = { id: string; gate: string; command: string; used: boolean };
 

package/src/gates/git-guard.ts

@@ -26,6 +26,35 @@ export type GitGuardDeps = {
   now?: () => Date;
 };
 
+type Resolved = { intent: GitIntent } | { block: true; reason: string };
+
+/** An unclassifiable command: Jev may classify it; otherwise the user decides (headless: blocked). */
+async function resolveUnknown(
+  deps: GitGuardDeps,
+  ctx: ExtensionContext,
+  command: string,
+): Promise<Resolved> {
+  const judged =
+    deps.jev === undefined ? undefined : await judgeShellIntent(deps.jev(ctx), command);
+  if (judged?.ok === true && judged.value.intent !== "unknown") {
+    return { intent: judged.value.intent };
+  }
+  const why = judged?.ok === false ? `unavailable: ${judged.error.kind}` : "not confident";
+  const approved = ctx.hasUI
+    ? await ctx.ui.confirm(
+        "Development system — unclassified command",
+        `${redactSecrets(command)}\nCould not classify this command (Jev ${why}). It may run an irreversible git operation. Approve?`,
+      )
+    : false;
+  if (approved) return { intent: "ordinary" };
+  return {
+    block: true,
+    reason: ctx.hasUI
+      ? "the user declined an unclassifiable command; propose a simpler, explicit git command"
+      : "could not classify this command and Jev is unavailable or unsure; run interactively or use an explicit git command",
+  };
+}
+
 /** Registers the `tool_call` hard stop for irreversible git operations in bash. */
 export function registerGitGuard(deps: GitGuardDeps): void {
   deps.pi.on("tool_call", async (event, ctx) => {
@@ -33,26 +62,9 @@ export function registerGitGuard(deps: GitGuardDeps): void {
     const command = event.input.command;
     let intent = classifyGitCommand(command);
     if (intent === "unknown") {
-      const judged =
-        deps.jev === undefined ? undefined : await judgeShellIntent(deps.jev(ctx), command);
-      if (judged?.ok === true && judged.value.intent !== "unknown") {
-        intent = judged.value.intent;
-      } else {
-        const approved = ctx.hasUI
-          ? await ctx.ui.confirm(
-              "Development system — unclassified command",
-              `${redactSecrets(command)}\nCould not classify this command (Jev ${judged?.ok === false ? `unavailable: ${judged.error.kind}` : "not confident"}). It may run an irreversible git operation. Approve?`,
-            )
-          : false;
-        return approved
-          ? undefined
-          : {
-              block: true,
-              reason: ctx.hasUI
-                ? "the user declined an unclassifiable command; propose a simpler, explicit git command"
-                : "could not classify this command and Jev is unavailable or unsure; run interactively or use an explicit git command",
-            };
-      }
+      const resolved = await resolveUnknown(deps, ctx, command);
+      if ("block" in resolved) return resolved;
+      intent = resolved.intent;
     }
     if (!HARD.has(intent)) return undefined;
     const gate = parseGateId(`git.${intent}`);

package/src/gates/lint-suppression-guard.ts

@@ -31,7 +31,8 @@ function resultingText(
   event: ToolCallEvent,
   cwd: string,
 ): { path: string; before: string; after: string } | undefined {
-  if (!isToolCallEventType("write", event) && !isToolCallEventType("edit", event)) return undefined;
+  if (!(isToolCallEventType("write", event) || isToolCallEventType("edit", event)))
+    return undefined;
   const path = normalizeRepoPath(cwd, event.input.path, homedir());
   const class_ = classifyPath(path);
   if (class_ !== "source" && class_ !== "test") return undefined;
@@ -74,7 +75,7 @@ export function registerLintSuppressionGuard(deps: LintSuppressionGuardDeps): vo
         `${GATE_ID}: ${change.path} adds a suppression without a reason: ${list}. A suppression hides a ` +
         `finding from every later reader, so it must say why (at least ${MIN_RATIONALE} characters, on the ` +
         `same line or the next, e.g. "// biome-ignore lint/x: boundary parse of foreign JSON"). Add the ` +
-        `reason, or fix the finding instead. If a bare suppression is truly right, call ` +
+        "reason, or fix the finding instead. If a bare suppression is truly right, call " +
         `devsys_record_departure with gate "${GATE_ID}", what you are doing, why, and the cost if wrong; then retry.`,
     };
   });

package/src/gates/red-first-guard.ts

@@ -69,7 +69,7 @@ export function registerRedFirstGuard(deps: RedFirstGuardDeps): void {
   const departure = departureUse(deps.state, gate);
 
   deps.pi.on("tool_call", (event, ctx) => {
-    if (!isToolCallEventType("edit", event) && !isToolCallEventType("write", event))
+    if (!(isToolCallEventType("edit", event) || isToolCallEventType("write", event)))
       return undefined;
     const { phase, lastTestRun, activeSlice } = deps.state.get();
     if (phase !== "implementing") return undefined;

package/src/gates/test-guard.ts

@@ -75,8 +75,7 @@ const NO_SIGNALS: WeakeningSignals = { addsSkip: false, emptied: false, commente
 
 /** Adding lines never weakens a test unless an added line itself disables something. */
 const isHarmlessAddition = (before: string, after: string, signals: WeakeningSignals): boolean =>
-  !signals.addsSkip &&
-  !signals.commentedOut &&
+  !(signals.addsSkip || signals.commentedOut) &&
   isPureAddition(before, after) &&
   !addedLines(before, after).some((line) => RISKY_ADDITION.test(line));
 
@@ -134,19 +133,24 @@ export function registerTestGuard(deps: TestGuardDeps): void {
   const collectChanges = (event: ToolCallEvent, ctx: ExtensionContext): Change[] => {
     if (isToolCallEventType("bash", event)) {
       const { command } = event.input;
-      return bashMutations(command).flatMap(({ path: raw, kind }): Change[] => {
-        const path = repoPath(ctx.cwd, raw);
+      return bashMutations(command).flatMap(({ path: written, kind }): Change[] => {
+        const target = repoPath(ctx.cwd, written);
         // Missing plain paths have nothing to weaken; globs and directories may still hide tests.
-        const touched = GLOB.test(path) || existsSync(join(ctx.cwd, path));
-        if (!isTestPath(path) || !touched) return [];
+        const touched = GLOB.test(target) || existsSync(join(ctx.cwd, target));
+        if (!(isTestPath(target) && touched)) return [];
         const rewritten =
           kind === "overwrite" ? `(rewritten by shell command) ${command}` : undefined;
         return [
-          { path, before: readIfExists(join(ctx.cwd, path)) ?? "", after: undefined, rewritten },
+          {
+            path: target,
+            before: readIfExists(join(ctx.cwd, target)) ?? "",
+            after: undefined,
+            rewritten,
+          },
         ];
       });
     }
-    if (!isToolCallEventType("write", event) && !isToolCallEventType("edit", event)) return [];
+    if (!(isToolCallEventType("write", event) || isToolCallEventType("edit", event))) return [];
     const path = repoPath(ctx.cwd, event.input.path);
     const raw = isTestPath(path) ? readIfExists(join(ctx.cwd, path)) : undefined;
     if (raw === undefined) return [];
@@ -215,7 +219,7 @@ export function registerTestGuard(deps: TestGuardDeps): void {
       block: true,
       reason:
         `${GATE_ID}: ${first.why} (${needing.map((n) => n.change.path).join(", ")}). Tests are the oracle; ` +
-        `weakening them needs a recorded decision. If this is deliberate, call devsys_record_departure ` +
+        "weakening them needs a recorded decision. If this is deliberate, call devsys_record_departure " +
         `with gate "${GATE_ID}", what you are doing instead, why, and the cost if wrong; then retry. ` +
         "Otherwise fix the code, not the test.",
     };

package/src/jev/questions/shell-intent.ts

@@ -4,7 +4,7 @@ import { redactSecrets } from "../../core/redact.ts";
 import { err, ok, type Result } from "../../core/result.ts";
 import type { Jev, JevError } from "../client.ts";
 
-export const SHELL_INTENT_THRESHOLD = 0.6;
+const SHELL_INTENT_THRESHOLD = 0.6;
 
 export const SHELL_INTENT_QUESTION: ClassifierChoiceQuestion = {
   type: "choice",

package/src/review/digest.ts

@@ -20,6 +20,23 @@ export type DiffSnapshot = {
 
 const MAX_UNTRACKED = 200;
 
+const PLAIN_DIFF = [
+  "-c",
+  "core.quotePath=false",
+  "diff",
+  "--no-ext-diff",
+  "--no-color",
+  // diff.mnemonicPrefix / diff.noprefix change the `a/` `b/` header prefixes the file keys are cut from.
+  "--src-prefix=a/",
+  "--dst-prefix=b/",
+  // Every changed path gets a `diff --git` section: no submodule log summaries, no textconv that
+  // can hide an edit whose converted text is unchanged.
+  "--submodule=short",
+  "--no-textconv",
+  // diff.ignoreSubmodules=all would hide a bump that `git add` still stages.
+  "--ignore-submodules=dirty",
+];
+
 /**
  * The change in `range` (default `HEAD`: everything not yet committed) with its digest. `git diff`
  * leaves out untracked files, so for a range that includes the work tree they are listed and
@@ -33,25 +50,9 @@ export async function snapshotDiff(
   try {
     // Plain, parseable output whatever the user's git config says: an external diff driver or
     // forced colour removes the `diff --git` headers the per-file digests are cut from.
-    const plain = [
-      "-c",
-      "core.quotePath=false",
-      "diff",
-      "--no-ext-diff",
-      "--no-color",
-      // diff.mnemonicPrefix / diff.noprefix change the `a/` `b/` header prefixes the file keys are cut from.
-      "--src-prefix=a/",
-      "--dst-prefix=b/",
-      // Every changed path gets a `diff --git` section: no submodule log summaries, no textconv that
-      // can hide an edit whose converted text is unchanged.
-      "--submodule=short",
-      "--no-textconv",
-      // diff.ignoreSubmodules=all would hide a bump that `git add` still stages.
-      "--ignore-submodules=dirty",
-    ];
     const [diff, stat, others] = await Promise.all([
-      exec("git", [...plain, "--full-index", "--no-renames", range], { cwd, timeout: 15_000 }),
-      exec("git", [...plain, "--stat", range], { cwd, timeout: 15_000 }),
+      exec("git", [...PLAIN_DIFF, "--full-index", "--no-renames", range], { cwd, timeout: 15_000 }),
+      exec("git", [...PLAIN_DIFF, "--stat", range], { cwd, timeout: 15_000 }),
       // Any range that ends in the work tree (HEAD, HEAD~1, a branch) leaves untracked files out of git diff.
       !range.includes("..")
         ? exec(
@@ -79,30 +80,10 @@ export async function snapshotDiff(
     if (diff.stdout.trim() !== "" && Object.keys(files).length === 0) {
       return err("could not read the diff: no per-file sections were found");
     }
-    if (untracked.length > 0) {
-      const links = new Set<string>();
-      for (const path of untracked) {
-        const target = await linkTarget(cwd, path);
-        if (target !== undefined) {
-          files[path] = `new:${blobOf(target)}`;
-          links.add(path);
-        }
-      }
-      // `git hash-object <path>` follows symlinks (and fails on dangling ones), so links are hashed above.
-      const regular = untracked.filter((p) => !links.has(p));
-      if (regular.length > 0) {
-        const hashes = await exec("git", ["hash-object", "--", ...regular], {
-          cwd,
-          timeout: 15_000,
-        });
-        const lines = hashes.stdout.split("\n").filter((l) => l !== "");
-        if (hashes.code !== 0 || lines.length !== regular.length) {
-          return err(hashes.stderr.trim() || "git hash-object could not hash every untracked file");
-        }
-        for (const [i, path] of regular.entries()) files[path] = `new:${lines[i]}`;
-      }
-    }
-    const names = Object.keys(files).sort();
+    const hashed = await hashUntracked(exec, cwd, untracked);
+    if (!hashed.ok) return hashed;
+    Object.assign(files, hashed.value);
+    const names = Object.keys(files).sort((a, b) => a.localeCompare(b));
     const untrackedStat = [
       ...untracked.map((p) => ` ${p} (untracked)`),
       ...nested.map((p) => ` ${p} (nested repository, not reviewable)`),
@@ -118,6 +99,33 @@ export async function snapshotDiff(
   }
 }
 
+/** Content digests (`new:<blob>`) of untracked files; symlinks are hashed by target, not followed. */
+async function hashUntracked(
+  exec: Exec,
+  cwd: string,
+  untracked: string[],
+): Promise<Result<Record<string, string>, string>> {
+  const files: Record<string, string> = {};
+  const links = new Set<string>();
+  for (const path of untracked) {
+    const target = await linkTarget(cwd, path);
+    if (target !== undefined) {
+      files[path] = `new:${blobOf(target)}`;
+      links.add(path);
+    }
+  }
+  // `git hash-object <path>` follows symlinks (and fails on dangling ones), so links are hashed above.
+  const regular = untracked.filter((p) => !links.has(p));
+  if (regular.length === 0) return ok(files);
+  const hashes = await exec("git", ["hash-object", "--", ...regular], { cwd, timeout: 15_000 });
+  const lines = hashes.stdout.split("\n").filter((l) => l !== "");
+  if (hashes.code !== 0 || lines.length !== regular.length) {
+    return err(hashes.stderr.trim() || "git hash-object could not hash every untracked file");
+  }
+  for (const [i, path] of regular.entries()) files[path] = `new:${lines[i]}`;
+  return ok(files);
+}
+
 const NEW_FILE = /^new file mode .*\nindex 0+\.\.([0-9a-f]+)/m;
 
 /** A new file digests as its blob, the same form an untracked file gets, so `git add` changes nothing. */

package/src/review/review-tools.ts

@@ -2,6 +2,7 @@ import type { ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding
 import { type Static, Type } from "typebox";
 import type { Exec } from "../core/exec.ts";
 import { resolveSlot } from "../core/models.ts";
+import type { Lens } from "../core/review.ts";
 import {
   addRound,
   DEFAULT_LENSES,
@@ -72,6 +73,51 @@ const pathSafe = (slice: string): string =>
     .replace(/^-+|-+$/g, "")
     .slice(0, 32);
 
+type LensJudgement = Awaited<ReturnType<typeof judgeLenses>>;
+
+/** Jev's lenses for the diff, or the defaults (with the reason) when Jev is offline or names none. */
+function chooseLenses(judged: LensJudgement): { lenses: Lens[]; basis: string } {
+  if (!judged.ok) {
+    return {
+      lenses: [...DEFAULT_LENSES],
+      basis: `Jev unavailable (${judged.error.kind}); using the default lenses.`,
+    };
+  }
+  const selected = selectLenses(judged.value);
+  if (selected.length === 0) {
+    return {
+      lenses: [...DEFAULT_LENSES],
+      basis: "Jev found no specific lens; using the defaults.",
+    };
+  }
+  return { lenses: selected, basis: "Jev chose the lenses." };
+}
+
+/** The agent_spawn arguments for one reviewer round. */
+function spawnPayload(input: {
+  slice: SliceRef;
+  round: number;
+  lenses: Lens[];
+  range: string;
+  model: ReturnType<typeof resolveSlot>;
+  now: Date;
+}): Record<string, unknown> {
+  return {
+    // A fresh path per attempt: a failed spawn must not leave a thread that blocks the retry.
+    path: `/review-${pathSafe(input.slice)}-r${input.round}-${input.now.getTime().toString(36)}`,
+    type: "reviewer",
+    task: reviewerTask({
+      slice: input.slice,
+      round: input.round,
+      lenses: input.lenses,
+      diffRange: input.range,
+    }),
+    ...(input.model.ok ? { model: input.model.value.model } : {}),
+    thinkingLevel: "high",
+    wait: true,
+  };
+}
+
 /** `devsys_review_start`: Jev picks lenses for the diff; the reply carries the agent_spawn payload for a fresh reviewer. */
 export function createReviewStartTool(
   deps: ReviewToolDeps,
@@ -106,13 +152,7 @@ export function createReviewStartTool(
         diffSample: snap.value.sample,
         profiles: deps.state.get().profiles ?? [],
       });
-      const selected = judged.ok ? selectLenses(judged.value) : [];
-      const lenses = selected.length > 0 ? selected : [...DEFAULT_LENSES];
-      const basis = judged.ok
-        ? selected.length > 0
-          ? "Jev chose the lenses."
-          : "Jev found no specific lens; using the defaults."
-        : `Jev unavailable (${judged.error.kind}); using the default lenses.`;
+      const { lenses, basis } = chooseLenses(judged);
 
       const required = Math.max(
         config.value.review.requiredCleanRounds,
@@ -137,20 +177,14 @@ export function createReviewStartTool(
       }
 
       const round = review.rounds.length + 1;
-      const resolved = resolveSlot(
-        config.value.models,
-        "reviewer",
-        availableModels(ctx.modelRegistry),
-      );
-      const spawn = {
-        // A fresh path per attempt: a failed spawn must not leave a thread that blocks the retry.
-        path: `/review-${pathSafe(slice)}-r${round}-${(deps.now?.() ?? new Date()).getTime().toString(36)}`,
-        type: "reviewer",
-        task: reviewerTask({ slice, round, lenses, diffRange: range }),
-        ...(resolved.ok ? { model: resolved.value.model } : {}),
-        thinkingLevel: "high",
-        wait: true,
-      };
+      const spawn = spawnPayload({
+        slice,
+        round,
+        lenses,
+        range,
+        model: resolveSlot(config.value.models, "reviewer", availableModels(ctx.modelRegistry)),
+        now: deps.now?.() ?? new Date(),
+      });
       return reply(
         [
           `${reviewLabel(review)}; round ${round}; diff ${snap.value.digest}. ${basis}`,

package/src/state/ci-command.ts

@@ -68,7 +68,7 @@ export async function runCiWatch(
 export function registerCiCommand(deps: CiCommandDeps): void {
   deps.pi.registerCommand("devsys-ci", {
     description: "Watch CI on the trunk and show its state in the status line",
-    handler: async (_args, ctx) => {
+    handler: (_args, ctx) => {
       ctx.ui.notify("watching CI on the trunk…", "info");
       runCiWatch(deps, ctx).catch((cause: unknown) => {
         // ctx goes stale if the session is replaced or reloaded mid-watch; there is nobody left to tell.
@@ -81,6 +81,7 @@ export function registerCiCommand(deps: CiCommandDeps): void {
           // stale context
         }
       });
+      return Promise.resolve();
     },
   });
 }

package/src/state/config.ts

@@ -11,8 +11,8 @@ export const CONFIG_FILE = ".development-system.toml";
 const DELIVERY_MODES = ["trunk", "pull-request", "local-only"] as const;
 const TRACKER_KINDS = ["repo-files", "github", "jira", "linear"] as const;
 
-export type DeliveryMode = (typeof DELIVERY_MODES)[number];
-export type TrackerKind = (typeof TRACKER_KINDS)[number];
+type DeliveryMode = (typeof DELIVERY_MODES)[number];
+type TrackerKind = (typeof TRACKER_KINDS)[number];
 
 export type ConfigError = {
   readonly kind: "config-error";
@@ -280,31 +280,32 @@ export function parseConfig(source: string): Result<DevsysConfig, ConfigError> {
   const delivery = deliveryAndReview(root);
   const lim = limits(root);
   const matrix = models(root);
-  const route = routing(root);
+  const routes = routing(root);
   const prof = profiles(root);
   if (!delivery.ok) return delivery;
   if (!lim.ok) return lim;
   if (!matrix.ok) return matrix;
-  if (!route.ok) return route;
+  if (!routes.ok) return routes;
   if (!prof.ok) return prof;
   return ok({
     ...delivery.value,
     ...lim.value,
     profiles: { override: prof.value },
     models: matrix.value,
-    routing: route.value,
+    routing: routes.value,
   });
 }
 
+const isMissingFile = (cause: unknown): boolean =>
+  cause instanceof Error && "code" in cause && String(cause.code) === "ENOENT";
+
 /** Reads `<repoRoot>/.development-system.toml`; a missing file means all defaults. */
 export async function loadConfig(repoRoot: string): Promise<Result<DevsysConfig, ConfigError>> {
   let source: string;
   try {
     source = await readFile(join(repoRoot, CONFIG_FILE), "utf8");
   } catch (cause) {
-    if (typeof cause === "object" && cause !== null && "code" in cause && cause.code === "ENOENT") {
-      return parseConfig("");
-    }
+    if (isMissingFile(cause)) return parseConfig("");
     return fail(
       `cannot read ${CONFIG_FILE}: ${cause instanceof Error ? cause.message : String(cause)}`,
     );

package/src/state/models-command.ts

@@ -19,7 +19,7 @@ import {
 } from "../core/models.ts";
 import { CONFIG_FILE, loadConfig } from "./config.ts";
 
-export const CONFIG_ENTRY_TYPE = "devsys-config";
+const CONFIG_ENTRY_TYPE = "devsys-config";
 
 export type CatalogModel = Available & {
   readonly cost?: { readonly input: number; readonly output: number };
@@ -32,7 +32,7 @@ export interface ModelCatalog {
   hasConfiguredAuth(model: CatalogModel): boolean;
 }
 
-export type SlotRow = {
+type SlotRow = {
   readonly slot: Slot;
   readonly resolution: Resolution | undefined;
 };
@@ -45,7 +45,7 @@ export function availableModels(catalog: ModelCatalog): CatalogModel[] {
   return [...catalog.getAvailable(), ...classifiers];
 }
 
-export function resolveRows(matrix: ModelMatrix, available: readonly Available[]): SlotRow[] {
+function resolveRows(matrix: ModelMatrix, available: readonly Available[]): SlotRow[] {
   return SLOTS.map((slot) => {
     const r = resolveSlot(matrix, slot, available);
     return { slot, resolution: r.ok ? r.value : undefined };
@@ -62,10 +62,7 @@ function priceOf(model: string, available: readonly CatalogModel[]): string {
 }
 
 /** One line per slot: `slot → provider/id (via candidate) · $in/$out per M`, or `UNRESOLVED`. */
-export function renderModelsTable(
-  rows: readonly SlotRow[],
-  available: readonly CatalogModel[],
-): string {
+function renderModelsTable(rows: readonly SlotRow[], available: readonly CatalogModel[]): string {
   const width = Math.max(...SLOTS.map((s) => s.length));
   return rows
     .map(({ slot, resolution }) =>

package/src/state/session-state.ts

@@ -19,7 +19,7 @@ import {
   type TestRun,
 } from "../core/types.ts";
 
-export const STATE_ENTRY_TYPE = "devsys-state";
+const STATE_ENTRY_TYPE = "devsys-state";
 
 const PHASES: ReadonlyArray<Phase> = [
   "intake",
@@ -77,30 +77,45 @@ function parseReviews(input: unknown): ReviewState[] | ParseError {
   return out;
 }
 
+type Nested = Pick<DevsysState, "ci" | "profiles" | "lastTestRun" | "reviews">;
+
+/** Parses each optional nested field that is present; the first malformed one is the error. */
+function parseNested(input: Record<string, unknown>): Nested | ParseError {
+  const out: Record<string, unknown> = {};
+  const fields = [
+    ["ci", parseCi],
+    ["profiles", parseProfileList],
+    ["lastTestRun", parseTestRun],
+    ["reviews", parseReviews],
+  ] as const;
+  for (const [key, parse] of fields) {
+    if (input[key] === undefined) continue;
+    const parsed = parse(input[key]);
+    if (isParseError(parsed)) return parsed;
+    out[key] = parsed;
+  }
+  return out as Nested;
+}
+
+function parseDepartures(raw: unknown): Departure[] | ParseError {
+  if (!Array.isArray(raw)) return parseError("openDepartures must be an array");
+  const departures: Departure[] = [];
+  for (const item of raw) {
+    const departure = parseDeparture(item);
+    if (isParseError(departure)) return departure;
+    departures.push(departure);
+  }
+  return departures;
+}
+
 /** Boundary parse for persisted state: the only place state is cast from `unknown`. */
 export function parseDevsysState(input: unknown): DevsysState | ParseError {
   if (!isRecord(input)) return parseError("devsys state must be an object");
-  const {
-    phase,
-    sizing,
-    activeSlice,
-    openDepartures,
-    jev,
-    lastPushAt,
-    ci,
-    profiles,
-    lastTestRun,
-    reviews,
-  } = input;
+  const { phase, sizing, activeSlice, openDepartures, jev, lastPushAt } = input;
   if (!PHASES.includes(phase as Phase)) return parseError(`unknown phase: ${String(phase)}`);
   if (!JEV.includes(jev as JevStatus)) return parseError(`unknown jev status: ${String(jev)}`);
-  if (!Array.isArray(openDepartures)) return parseError("openDepartures must be an array");
-  const departures: Departure[] = [];
-  for (const raw of openDepartures) {
-    const departure = parseDeparture(raw);
-    if (isParseError(departure)) return departure;
-    departures.push(departure);
-  }
+  const departures = parseDepartures(openDepartures);
+  if (isParseError(departures)) return departures;
   if (sizing !== undefined && !SIZINGS.includes(sizing as Sizing)) {
     return parseError(`unknown sizing: ${String(sizing)}`);
   }
@@ -110,14 +125,8 @@ export function parseDevsysState(input: unknown): DevsysState | ParseError {
   if (lastPushAt !== undefined && typeof lastPushAt !== "string") {
     return parseError("lastPushAt must be a string");
   }
-  const parsedCi = ci === undefined ? undefined : parseCi(ci);
-  if (isParseError(parsedCi)) return parsedCi;
-  const parsedProfiles = profiles === undefined ? undefined : parseProfileList(profiles);
-  if (isParseError(parsedProfiles)) return parsedProfiles;
-  const parsedRun = lastTestRun === undefined ? undefined : parseTestRun(lastTestRun);
-  if (isParseError(parsedRun)) return parsedRun;
-  const parsedReviews = reviews === undefined ? undefined : parseReviews(reviews);
-  if (isParseError(parsedReviews)) return parsedReviews;
+  const nested = parseNested(input);
+  if (isParseError(nested)) return nested;
   return {
     phase: phase as Phase,
     jev: jev as JevStatus,
@@ -125,10 +134,7 @@ export function parseDevsysState(input: unknown): DevsysState | ParseError {
     ...(sizing !== undefined ? { sizing: sizing as Sizing } : {}),
     ...(activeSlice !== undefined ? { activeSlice: activeSlice as SliceRef } : {}),
     ...(lastPushAt !== undefined ? { lastPushAt } : {}),
-    ...(parsedCi !== undefined ? { ci: parsedCi } : {}),
-    ...(parsedProfiles !== undefined ? { profiles: parsedProfiles } : {}),
-    ...(parsedRun !== undefined ? { lastTestRun: parsedRun } : {}),
-    ...(parsedReviews !== undefined ? { reviews: parsedReviews } : {}),
+    ...nested,
   };
 }
 

package/src/subagents/orch/mailbox.ts

@@ -2,11 +2,11 @@
 import { randomUUID } from "node:crypto";
 import type { SessionEntry, SessionManager } from "@earendil-works/pi-coding-agent";
 
-export const LEGACY_QUEUE_TYPE = "pi-subagent:queue:v1";
+const LEGACY_QUEUE_TYPE = "pi-subagent:queue:v1";
 const ACCEPTED_TYPE = "pi-subagent:mailbox:accepted:v2";
 const CONSUMED_TYPE = "pi-subagent:mailbox:consumed:v2";
 const MIGRATION_TYPE = "pi-subagent:mailbox:migration:v2";
-export const MAILBOX_FIELD = "piSubagentMailbox";
+const MAILBOX_FIELD = "piSubagentMailbox";
 export const BOOTSTRAP_MESSAGE = "Subagent session initialized; awaiting parent input.";
 
 export type AcceptedKind = "steer" | "followUp" | "update";

package/src/subagents/prefs/agent-import.ts

@@ -12,7 +12,7 @@ import { dialogText } from "../ui/dialog.ts";
 export const IMPORT_REQUEST_PREFIX =
   "Import ONLY the agents I selected in the pi-subagent-manager migration picker.";
 
-export const IMPORT_CHILD_TOOLS = [
+const IMPORT_CHILD_TOOLS = [
   "read",
   "bash",
   "powershell",
@@ -61,7 +61,7 @@ function stateDirectory(agentDir: string, create: boolean): string | undefined {
   return directory;
 }
 
-export function importWasOffered(agentDir: string): boolean {
+function importWasOffered(agentDir: string): boolean {
   const directory = stateDirectory(agentDir, false);
   if (!directory) return false;
   const stat = statIfPresent(join(directory, OFFER_MARKER));
@@ -89,7 +89,7 @@ export function markImportOffered(agentDir: string): void {
   }
 }
 
-export function buildImportPrompt(options: {
+function buildImportPrompt(options: {
   candidates: readonly ImportCandidate[];
   agentDir: string;
   cwd: string;

package/src/subagents/prefs/settings.ts

@@ -14,16 +14,16 @@ import {
 } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 
-export const SUBAGENT_MODES = ["off", "opportunistic", "orchestration"] as const;
+const SUBAGENT_MODES = ["off", "opportunistic", "orchestration"] as const;
 export type SubagentMode = (typeof SUBAGENT_MODES)[number];
 
-export const WIDGET_MODES = ["full", "minimal"] as const;
+const WIDGET_MODES = ["full", "minimal"] as const;
 export type WidgetMode = (typeof WIDGET_MODES)[number];
 
-export const TOOL_FILTERING_MODES = ["allowed", "all-except-blocked", "all"] as const;
+const TOOL_FILTERING_MODES = ["allowed", "all-except-blocked", "all"] as const;
 export type ToolFilteringMode = (typeof TOOL_FILTERING_MODES)[number];
 
-export const MODEL_SELECTION_MODES = [
+const MODEL_SELECTION_MODES = [
   "pick-first-available",
   "pick-first-scoped",
   "use-current",

package/src/subagents/types.ts

@@ -44,7 +44,7 @@ export interface AgentType {
   /** File path of the base definition under the customization, if any. */
   baseFilePath?: string;
 }
-export type ThreadState = "starting" | "running" | "paused" | "completed" | "failed" | "stopped";
+type ThreadState = "starting" | "running" | "paused" | "completed" | "failed" | "stopped";
 export interface ThreadView {
   path: string;
   parent: string | null;
@@ -71,7 +71,7 @@ export interface ThreadView {
   /** devsys: per-spawn model/thinkingLevel pin requested through agent_spawn, when any. */
   pinned?: { model?: string; thinkingLevel?: ThinkingLevel };
 }
-export type DriverEvent =
+type DriverEvent =
   | { kind: "activity" | "error"; text: string }
   | {
       kind: "checkpoint";

package/src/subagents/ui/dialog.ts

@@ -24,7 +24,7 @@ export interface DialogHost {
   requestRender(force?: boolean): void;
   terminal?: { rows: number };
 }
-export interface DialogEditorHost extends DialogHost {
+interface DialogEditorHost extends DialogHost {
   terminal: { rows: number };
 }
 export interface DialogRow {
@@ -97,7 +97,7 @@ export function frameDialog(
 }
 
 /** A multiline editor inside the same bounded shell as the surrounding form. */
-export class DialogEditor {
+class DialogEditor {
   private editor: Editor;
   private initialText: string;
   constructor(
@@ -180,7 +180,7 @@ export function dialogEditor(
 }
 
 /** Bounded, two-column menu shared by settings and agent definitions. */
-export class DialogMenu {
+class DialogMenu {
   private selected = 0;
   private viewport = 1;
   constructor(

package/src/subagents/ui/import-picker.ts

@@ -71,7 +71,7 @@ function wrapText(text: string, columns: number): string[] {
  * Checkbox dialog for choosing external agents to migrate.
  * Selection only — the caller imports; this does not read or write agent files.
  */
-export class ImportPicker {
+class ImportPicker {
   private cursor = 0;
   private viewport = 1;
   private readonly checked = new Set<string>();

package/src/subagents/ui/model-picker.ts

@@ -84,7 +84,7 @@ function describeModel(model: AvailableModel, scopedIdentities: ReadonlySet<stri
   return [name, annotation].filter(Boolean).join(" · ");
 }
 
-export class OrderedModelEditorComponent extends Container {
+class OrderedModelEditorComponent extends Container {
   private readonly tui: {
     requestRender(force?: boolean): void;
     terminal?: { rows: number };

package/src/subagents/ui/status-ui.ts

@@ -31,7 +31,6 @@ import {
 } from "./ui.ts";
 import { LiveAgentView, fillViewport, type AgentViewportState } from "./live-agent-view.ts";
 
-export { buildStatusTree, type StatusRow };
 
 const ROOT = "/root";
 const INACTIVE_STATES = new Set(["paused", "stopped", "failed", "completed"]);
@@ -81,7 +80,7 @@ export interface AgentTreeState {
   collapsed: Set<string>;
 }
 
-export class StatusDialog {
+class StatusDialog {
   private state: AgentTreeState;
   private get selectedPath(): string {
     return this.state.selectedPath;
@@ -530,7 +529,7 @@ export class AgentNavigationController {
 
 const navigationByService = new WeakMap<ThreadService, AgentNavigationController>();
 
-export async function showAgentTree(
+async function showAgentTree(
   ctx: ExtensionContext,
   service: ThreadService,
   selectedPath?: string,

package/src/subagents/ui/ui.ts

@@ -55,7 +55,7 @@ export type ThreadController = Pick<
 >;
 
 /** Plain terminal-safe text: never pass agent-supplied terminal commands through. */
-export function sanitizeText(text: string): string {
+function sanitizeText(text: string): string {
   return stripTerminalSequences(text).replace(/[\x00-\x1f\x7f-\x9f]/g, " ");
 }
 
@@ -200,7 +200,7 @@ function isLive(thread: ThreadView): boolean {
   );
 }
 
-export function renderThreads(
+function renderThreads(
   threads: ThreadView[],
   width: number,
   theme: AgentBadgeTheme,
@@ -453,7 +453,7 @@ function takeWidgetRows(rows: StatusRow[], budget: number): StatusRow[] {
 }
 
 /** Themed agent tree above the editor. Synthetic /root is the main conversation and is omitted. */
-export function renderAgentTree(
+function renderAgentTree(
   threads: ThreadView[],
   width: number,
   theme: AgentBadgeTheme,
@@ -493,7 +493,7 @@ export function renderAgentTree(
 }
 
 /** One-line counts for real agents; starting agents count as running, including tokens. */
-export function renderAgentSummary(
+function renderAgentSummary(
   threads: ThreadView[],
   width: number,
   theme: Pick<Theme, "fg">,
@@ -682,7 +682,7 @@ export async function showThreads(
 }
 
 /** Parse editor argv, rejecting shell operators instead of evaluating a shell command. */
-export function editorArguments(command: string): string[] {
+function editorArguments(command: string): string[] {
   const args = parseShell(command, process.env);
   if (!args.length || args.some((arg) => typeof arg !== "string") || !args[0]) {
     throw new Error(