@jwilger/pi-development-system 0.44.0 → 0.44.1

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.44.1",
   "description": "A pi extension package representing a seasoned approach to software development using a full AI SDLC.",
   "keywords": [
     "pi-package"

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/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);
   }
 }
 

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/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/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);
   }
 }
 

package/src/core/review.ts

@@ -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/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/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

@@ -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/session-state.ts

@@ -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,
   };
 }