@jwilger/pi-development-system 0.10.6 → 0.12.0

package/agents/tasker.md

@@ -0,0 +1,58 @@
+---
+name: tasker
+icon: ''
+description: Complete short, bounded jobs with clear acceptance criteria, including diagnostics, extraction, mechanical edits, a few tool steps, or a targeted repository lookup. Not for ambiguous features, sustained implementation, or complex code understanding.
+thinkingLevel: low
+color: success
+modelSuggestions:
+  - gpt-6-luna
+  - deepseek-v4.1-flash
+  - gemini-3.5-flash-lite
+  - gemini-3.8-flash
+tools:
+  allow:
+    - read
+    - bash
+    - edit
+    - write
+    - grep
+    - find
+    - ls
+    - agent_update
+    - agent_pause
+---
+
+You are a tasker. Do one bounded, well-specified job: a command or diagnostic, a data extraction, a stated rename, a one-site fix, an explicit patch, or a targeted repository lookup. Do exactly that, in a few tool steps, and return a compact answer. Not every job needs a file change.
+
+## Before you start
+
+Name the result, the authorized scope, and a cheap check that proves it done. Infer routine details from context. If a missing decision would change the result or the permission boundary, call agent_pause and name it.
+
+## Lookups
+
+- Start with the most discriminating query (exact symbol, string, or path glob). grep/find before opening files; open only hits that confirm or kill the lead. Do not walk the repo to get oriented.
+- Cite path:line or a short quoted span. If two sites disagree, report both. A miss is a miss; do not fill it with plausible architecture.
+- Do not modify files for a lookup.
+
+## Edits
+
+Read the target and its surroundings, match local style, and change only what the criteria require: no refactors, taste renames, helpers, or nearby fixes. Other agents may be editing this tree; leave unrelated changes alone.
+
+## Stop and pause instead of expanding
+
+If the job turns into complex code understanding, a design choice, an audit, interconnected behavior changes, or sustained debugging, it is no longer a tasker job. Call agent_pause, say what expanded and any edit already made, and suggest architect or coder. Also pause before any check that would install packages, write outside scope, or run a long build. You cannot delegate; finish or pause, never leave unexplained partial edits.
+
+## Shell
+
+bash is not a sandbox. Use it only for the authorized operation, the completion check, or a read-only look. Do not commit, push, install, or delete unless the task says so.
+
+## Verify and hand back
+
+Run a proportionate check: the one the task specifies, else a focused test, command status, record validation, or a diff read-back. Then report briefly:
+
+- **Result**: the answer, output, or change made (files touched).
+- **Evidence**: citations, or the check run and its outcome (not raw logs). If you did not run a check, say so.
+- **Coverage** (lookups): queries run, files opened, what you did not search.
+- **Gaps**: anything unverified or left for another role.
+
+Send agent_update only when criteria are met, a check fails, or scope is expanding. If blocked, call agent_pause with the blocker and stop.

package/agents/writer.md

@@ -0,0 +1,39 @@
+---
+name: writer
+icon: ''
+description: Draft or revise original long-form prose for a stated audience and voice. Not for source changes, code review, or UI design, and not for inventing facts, citations, or testimonials.
+thinkingLevel: medium
+color: mdQuote
+modelSuggestions:
+  - opus-5.5
+  - gemini-4-argon
+  - gemini-3.8-flash
+  - fable-5.1
+  - muse-spark-1.3
+tools:
+  allow:
+    - read
+    - edit
+    - write
+    - grep
+    - find
+    - ls
+    - agent_update
+    - agent_pause
+---
+
+You are the writer. You draft and edit prose for a stated reader: docs, READMEs, changelogs, release notes, posts, copy, and fiction. You do not change source code, review diffs, or research beyond local files.
+
+Before drafting, settle audience, purpose, form, voice, and length. A requested voice or format wins; otherwise match the conventions of neighboring docs in the project.
+
+When editing someone else's text, keep their voice, vocabulary, and emphasis. Do not flatten it into generic professional tone. Fix what is wrong or unclear, and restructure only where the argument fails.
+
+In factual writing, every fact, number, date, quote, citation, testimonial, command, flag, and API name must come from the brief or a file you actually opened. When documenting code, check names and signatures against the source. For a missing detail, leave a visible placeholder such as `[TK: confirm release date]`, never a plausible guess. In fiction, invent freely within the brief.
+
+Cut throat-clearing openers, recap closers, sections that only announce what comes next, and lists that repeat the paragraph above them.
+
+Write or edit only the named files. Other agents share this tree; do not overwrite unrelated edits. You have no shell, so never claim you ran a linter, build, or preview.
+
+Hand back the text itself, or the paths you changed, followed by brief assumptions and every placeholder you left. No memo about the writing unless asked.
+
+Send agent_update only when a missing fact or ambiguous form changes the draft. If you cannot write an honest draft without an input, call agent_pause, name that input, and stop. A placeholder covers a small gap; pause when the gap would hollow out the piece.

package/extensions/development-system.ts

@@ -17,8 +17,10 @@ import { createJevHolder } from "../src/jev/holder.ts";
 import { registerCiCommand } from "../src/state/ci-command.ts";
 import { loadConfig } from "../src/state/config.ts";
 import { createModelsTool, registerModelsCommand } from "../src/state/models-command.ts";
+import { createRouteTaskTool } from "../src/state/route-task-tool.ts";
 import { createSessionState } from "../src/state/session-state.ts";
 import { registerTestEvidence } from "../src/state/test-evidence.ts";
+import piSubagent from "../src/subagents/index.ts";
 
 const nonNegotiables = readFileSync(
   new URL("../principles/NON-NEGOTIABLES.md", import.meta.url),
@@ -100,7 +102,9 @@ export function createDevelopmentSystem(pi: ExtensionAPI) {
   pi.registerTool(createRecordDepartureTool({ pi, state }));
   pi.registerTool(createRequestApprovalTool({ pi, approvals }));
   pi.registerTool(createModelsTool());
+  pi.registerTool(createRouteTaskTool({ jev: (ctx) => jevHolder.forContext(ctx) }));
   registerModelsCommand(pi);
+  piSubagent(pi);
 
   pi.registerCommand("devsys-status", {
     description: "Show development-system phase, sizing, slice, departures and Jev status",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jwilger/pi-development-system",
-  "version": "0.10.6",
+  "version": "0.12.0",
   "description": "A pi extension package representing a seasoned approach to software development using a full AI SDLC.",
   "keywords": [
     "pi-package"
@@ -32,8 +32,10 @@
     ]
   },
   "dependencies": {
+    "fuzzysort": "^4.0.2",
     "shell-quote": "^1.12.0",
-    "smol-toml": "^1.4.0"
+    "smol-toml": "^1.4.0",
+    "yaml": "^2.9.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-agent-core": "*",
@@ -52,7 +54,7 @@
     "typescript": "^7.0.2"
   },
   "scripts": {
-    "test": "node --test \"test/**/*.test.ts\"",
+    "test": "node --experimental-transform-types --no-warnings --test \"test/**/*.test.ts\"",
     "typecheck": "tsc --noEmit",
     "lint": "biome check .",
     "lint:fix": "biome check --write .",

package/skills/delegation/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: delegation
+description: When and how to delegate work to subagents in this development system - advisor versus switching models, one task record per implementer, a fresh-context reviewer, and routing model and thinking level with devsys_route_task before agent_spawn. Use before spawning any subagent, when stuck on a decision, or when tempted to switch the coordinator's own model.
+---
+
+# Delegation
+
+Subagents come from the vendored `agent_spawn` family (tool names and agent files
+are the upstream ones; see `docs/subagents/custom-agents.md`). This system adds a
+per-spawn `model` and `thinkingLevel`, agent types for each role, and a router.
+
+## Decide first: do it, ask an advisor, or hand off
+
+- **Do it yourself** when the task is small and you already hold the context.
+- **Spawn `advisor`** when you are stuck on, or about to make, a design or
+  trade-off decision. It is read-only and returns a recommendation, the
+  alternatives it rejected and the cost if wrong. **Never switch the coordinator's
+  own model to get a better opinion**: switching loses context and cache and is not
+  recorded. If the matrix says a stronger model fits this phase, ask the advisor.
+- **Spawn `implementer`** for one well-bounded task from a task record.
+- **Spawn `reviewer`** for a diff, always with fresh context (see below).
+- **Spawn `researcher`** for evidence-backed questions about code or the web.
+
+## Route before you spawn
+
+Call `devsys_route_task({task, files, riskSignals})` before `agent_spawn` for
+implementer and reviewer work. It returns a slot, a thinking level and, when one
+resolves on this machine, a model. Pass them through:
+
+```text
+agent_spawn({path: "/root/add-flag", type: "implementer", task: "...",
+             model: "<from route>", thinkingLevel: "<from route>"})
+```
+
+- Jev judges difficulty and risk; the project's `[routing]` table (slots, never
+  model ids) decides. Jev offline means `routine/low`.
+- If the result says the slot is unresolvable, omit `model`: the agent type's own
+  preference list applies. Run `/devsys-models` to fix the matrix.
+- You may override the route. Say why in your reply; overriding downwards for
+  risky work is a judgement call worth a line in the decision log.
+
+## The implementer gets exactly one task record
+
+Give it the task, the files it may touch, the interfaces as signatures, the test to
+write first, and the `Run:` / `Expected:` pairs that prove it. Nothing else: no
+plan, no history. If it needs more it pauses and asks. It never commits or pushes;
+you deliver after review.
+
+## The reviewer is always fresh
+
+A reviewer that watched the work being written shares its blind spots. Spawn it
+with `/root/<name>` paths that do not inherit your reasoning, give it the diff
+range and the packet format (`agents/reviewer.md`), and never tell it what you
+concluded. Fix every blocking and should-fix finding, then ask for a new round.
+
+## Parallel work
+
+Spawn independent children with `wait: false` before waiting on any of them. Keep
+the number of concurrent agents small; each one costs context and money.
+
+## Do not
+
+- Switch the coordinator's model instead of spawning an advisor.
+- Spawn an implementer without a task record or a way to verify the result.
+- Reuse a reviewer thread for the next round; start a new one.
+- Hide a model downgrade for risky work; record it.

package/src/core/models.ts

@@ -148,6 +148,24 @@ export function resolveSlot(
   return resolveFrom(matrix, slot, available, []);
 }
 
+/** Every candidate of a slot in order with `@slot` references expanded and duplicates dropped; cycles are skipped. */
+export function flattenSlot(matrix: ModelMatrix, slot: Slot): string[] {
+  const seen = new Set<string>();
+  const walk = (current: Slot, trail: readonly Slot[]): void => {
+    if (trail.includes(current)) return;
+    for (const candidate of matrix[current]) {
+      if (!candidate.startsWith("@")) {
+        seen.add(candidate);
+        continue;
+      }
+      const target = candidate.slice(1);
+      if (isSlot(target)) walk(target, [...trail, current]);
+    }
+  };
+  walk(slot, []);
+  return [...seen];
+}
+
 /** Shipped defaults: model families only (no dated ids), so they roll forward as providers ship. */
 export function defaultMatrix(): ModelMatrix {
   return {

package/src/core/routing.ts

@@ -0,0 +1,67 @@
+import {
+  type Available,
+  type ModelMatrix,
+  type ModelRef,
+  resolveSlot,
+  type Slot,
+} from "./models.ts";
+import type { ThinkingLevel } from "./spawn-overrides.ts";
+
+export type Difficulty = "trivial" | "routine" | "complex" | "expert";
+export type RiskLevel = "low" | "medium" | "high";
+export const DIFFICULTIES: readonly Difficulty[] = ["trivial", "routine", "complex", "expert"];
+export const RISKS: readonly RiskLevel[] = ["low", "medium", "high"];
+
+export type Route = { readonly slot: Slot; readonly thinkingLevel: ThinkingLevel };
+export type RoutingTable = Readonly<Record<string, Route>>;
+
+// Most specific entry wins: exact `d/r`, then `d/*`, then `*` + `/r`, then `*` + `/*` (wildcards).
+export function pickRoute(
+  routing: RoutingTable,
+  difficulty: Difficulty,
+  risk: RiskLevel,
+): Route | undefined {
+  for (const key of [`${difficulty}/${risk}`, `${difficulty}/*`, `*/${risk}`, "*/*"]) {
+    const hit = routing[key];
+    if (hit !== undefined) return hit;
+  }
+  return undefined;
+}
+
+export type Recommendation = {
+  readonly slot: Slot;
+  readonly thinkingLevel: ThinkingLevel;
+  /** Absent when the slot resolves to nothing usable; the agent type's own defaults then apply. */
+  readonly model?: ModelRef;
+  readonly via?: string;
+  readonly note: string;
+};
+
+const FALLBACK: Route = { slot: "implementer", thinkingLevel: "medium" };
+
+/** Route → slot → a concrete model among those this machine can use. Pure. */
+export function recommendRoute(input: {
+  readonly routing: RoutingTable;
+  readonly matrix: ModelMatrix;
+  readonly available: readonly Available[];
+  readonly difficulty: Difficulty;
+  readonly risk: RiskLevel;
+}): Recommendation {
+  const picked = pickRoute(input.routing, input.difficulty, input.risk);
+  const route = picked ?? FALLBACK;
+  const prefix =
+    picked === undefined ? "No routing entry matched; using the implementer slot. " : "";
+  const resolved = resolveSlot(input.matrix, route.slot, input.available);
+  if (!resolved.ok) {
+    return {
+      ...route,
+      note: `${prefix}No model with credentials resolves slot "${route.slot}" (unresolvable); omit \`model\` so the agent type's defaults apply, or run /devsys-models.`,
+    };
+  }
+  return {
+    ...route,
+    model: resolved.value.model,
+    via: resolved.value.via,
+    note: `${prefix}Slot "${route.slot}" resolves to ${resolved.value.model} (via ${resolved.value.via}).`,
+  };
+}

package/src/core/spawn-overrides.ts

@@ -0,0 +1,59 @@
+import { type ParseError, parseError } from "./types.ts";
+
+/** Thinking levels pi accepts; kept equal to the vendored runtime's list by a test. */
+export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
+export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
+
+/** Per-spawn choices the coordinator makes; they beat agent-type preferences and inheritance. */
+export type SpawnOverrides = {
+  readonly model?: string;
+  readonly thinkingLevel?: ThinkingLevel;
+};
+
+export type Settings = {
+  readonly provider: string | undefined;
+  readonly id: string | undefined;
+  readonly thinkingLevel: ThinkingLevel;
+};
+
+const MODEL_REF = /^[^\s/]+\/\S+$/;
+
+const isLevel = (value: unknown): value is ThinkingLevel =>
+  THINKING_LEVELS.some((level) => level === value);
+
+/** Parses the optional `model`/`thinkingLevel` of an `agent_spawn` call; undefined when neither is given. */
+export function parseSpawnOverrides(input: {
+  readonly model?: unknown;
+  readonly thinkingLevel?: unknown;
+}): SpawnOverrides | undefined | ParseError {
+  const { model, thinkingLevel } = input;
+  if (model !== undefined && (typeof model !== "string" || !MODEL_REF.test(model))) {
+    return parseError(`model must be "provider/model-id", got ${JSON.stringify(model)}`);
+  }
+  if (thinkingLevel !== undefined && !isLevel(thinkingLevel)) {
+    return parseError(`thinkingLevel must be one of: ${THINKING_LEVELS.join(", ")}`);
+  }
+  if (model === undefined && thinkingLevel === undefined) return undefined;
+  return {
+    ...(model === undefined ? {} : { model }),
+    ...(thinkingLevel === undefined ? {} : { thinkingLevel }),
+  };
+}
+
+/** Overrides win; the provider is everything before the first slash, the model id the rest. */
+export function applySpawnOverrides(
+  base: Settings,
+  overrides: SpawnOverrides | undefined,
+): Settings {
+  if (overrides === undefined) return base;
+  const at = overrides.model?.indexOf("/") ?? -1;
+  const model =
+    overrides.model === undefined || at < 0
+      ? {}
+      : { provider: overrides.model.slice(0, at), id: overrides.model.slice(at + 1) };
+  return {
+    ...base,
+    ...model,
+    ...(overrides.thinkingLevel === undefined ? {} : { thinkingLevel: overrides.thinkingLevel }),
+  };
+}

package/src/jev/questions/route.ts

@@ -0,0 +1,93 @@
+import type { ClassifierChoiceQuestion } from "@earendil-works/pi-ai";
+import { redactSecrets } from "../../core/redact.ts";
+import { err, ok, type Result } from "../../core/result.ts";
+import { DIFFICULTIES, type Difficulty, RISKS, type RiskLevel } from "../../core/routing.ts";
+import type { Jev, JevError } from "../client.ts";
+
+export type RouteInput = {
+  task: string;
+  filesTouched: readonly string[];
+  riskSignals?: readonly string[];
+};
+export type RouteJudgement = { difficulty: Difficulty; risk: RiskLevel; confidence: number };
+
+export const DIFFICULTY_QUESTION: ClassifierChoiceQuestion = {
+  type: "choice",
+  instructions:
+    "How hard is the coding `task` for a capable engineer, given the `files` it touches? Judge the reasoning and design needed, not the amount of typing. A schema or data migration is at least complex; concurrency, cryptography and key handling are expert.",
+  criteria: {
+    trivial: "Mechanical and local: a rename, a typo, a one-line config, copy or style change",
+    routine:
+      "Well-understood change in one area following an existing pattern or adding a small self-contained function or flag, with a clear test",
+    complex:
+      "Several modules interact, a schema or data migration is involved, a new abstraction or state machine is needed, or behaviour is subtle",
+    expert:
+      "Concurrency, cryptography or key management, security protocols, or architecture decisions where a wrong choice is costly to find",
+  },
+};
+
+export const RISK_QUESTION: ClassifierChoiceQuestion = {
+  type: "choice",
+  instructions:
+    "How costly is it if the result of `task` (touching `files`, with `riskSignals`) is subtly wrong and ships? Consider data loss, security, money, irreversibility and how many users are affected. Authentication, secrets, payments, migrations and shared infrastructure are high; a new self-contained function with its own test, docs, styling and tests-only changes are low.",
+  criteria: {
+    low: "Easy to notice and revert: docs, styling, tests, internal tooling, or a new self-contained function with its own test",
+    medium:
+      "A defect would affect users or other code but is visible and recoverable; changes to existing shared behaviour",
+    high: "A defect could lose data, expose secrets, break authentication, authorisation or money flows, or be hard to undo",
+  },
+};
+
+const TASK_CLIP = 4000;
+const clip = (text: string, max: number): string =>
+  redactSecrets(text.slice(0, max * 2)).slice(0, max);
+
+/**
+ * Difficulty and risk are ordinal, so the label is the probability-weighted median, not the argmax:
+ * mass spread over neighbouring levels ("complex 0.33, expert 0.5") still lands on the right side.
+ * Falls back to the answer's own label when it carries no usable probabilities.
+ */
+export function medianLabel<T extends string>(
+  levels: readonly T[],
+  answer: { choice: string; probabilities: Readonly<Record<string, number>> },
+): T | undefined {
+  const total = levels.reduce((sum, level) => sum + (answer.probabilities[level] ?? 0), 0);
+  if (total > 0) {
+    let cumulative = 0;
+    for (const level of levels) {
+      cumulative += (answer.probabilities[level] ?? 0) / total;
+      if (cumulative >= 0.5) return level;
+    }
+  }
+  return levels.find((level) => level === answer.choice);
+}
+
+export async function judgeTaskRouting(
+  jev: Jev,
+  input: RouteInput,
+): Promise<Result<RouteJudgement, JevError>> {
+  const asked = await jev.ask(
+    {
+      task: clip(input.task, TASK_CLIP),
+      files: input.filesTouched.slice(0, 50).map((f) => clip(f, 200)),
+      riskSignals: (input.riskSignals ?? []).slice(0, 20).map((s) => clip(s, 200)),
+    },
+    { difficulty: DIFFICULTY_QUESTION, risk: RISK_QUESTION },
+  );
+  if (!asked.ok) return asked;
+  const difficulty = asked.value.difficulty;
+  const risk = asked.value.risk;
+  if (difficulty?.type !== "choice" || risk?.type !== "choice") {
+    return err({ kind: "provider", message: "missing routing answers" });
+  }
+  const d = medianLabel(DIFFICULTIES, difficulty);
+  const r = medianLabel(RISKS, risk);
+  if (d === undefined || r === undefined) {
+    return err({ kind: "provider", message: "unknown routing labels" });
+  }
+  return ok({
+    difficulty: d,
+    risk: r,
+    confidence: Math.min(difficulty.confidence, risk.confidence),
+  });
+}

package/src/state/config.ts

@@ -3,16 +3,16 @@ import { join } from "node:path";
 import { parse as parseToml } from "smol-toml";
 import { defaultMatrix, isSlot, type ModelMatrix, SLOTS, type Slot } from "../core/models.ts";
 import { err, ok, type Result } from "../core/result.ts";
+import type { Route } from "../core/routing.ts";
+import { THINKING_LEVELS } from "../core/spawn-overrides.ts";
 
 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;
-const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
 
 export type DeliveryMode = (typeof DELIVERY_MODES)[number];
 export type TrackerKind = (typeof TRACKER_KINDS)[number];
-export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
 
 export type ConfigError = {
   readonly kind: "config-error";
@@ -20,8 +20,6 @@ export type ConfigError = {
   readonly key?: string;
 };
 
-export type Route = { readonly slot: Slot; readonly thinkingLevel: ThinkingLevel };
-
 export type DevsysConfig = {
   readonly delivery: {
     readonly mode: DeliveryMode;

package/src/state/route-task-tool.ts

@@ -0,0 +1,74 @@
+import type { ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { type Static, Type } from "typebox";
+import { recommendRoute } from "../core/routing.ts";
+import type { Jev } from "../jev/client.ts";
+import { judgeTaskRouting } from "../jev/questions/route.ts";
+import { CONFIG_FILE, loadConfig } from "./config.ts";
+import { availableModels } from "./models-command.ts";
+
+const Parameters = Type.Object({
+  task: Type.String({ description: "The task the subagent will be given, in a sentence or two." }),
+  files: Type.Optional(
+    Type.Array(Type.String(), { description: "Files the task is expected to touch." }),
+  ),
+  riskSignals: Type.Optional(
+    Type.Array(Type.String(), {
+      description:
+        "Anything that raises the stakes: auth, money, migrations, shared infrastructure.",
+    }),
+  ),
+});
+
+const reply = (payload: string, isError = false) => ({
+  content: [{ type: "text" as const, text: payload }],
+  details: undefined,
+  isError,
+});
+
+/** `devsys_route_task`: Jev judges difficulty and risk; the project's routing table picks slot and effort. */
+export function createRouteTaskTool(deps: {
+  jev: (ctx: ExtensionContext) => Jev;
+}): ToolDefinition<typeof Parameters> {
+  return {
+    name: "devsys_route_task",
+    label: "Route task",
+    description:
+      "Recommend which model and thinking level a subagent should use for a task. Call before agent_spawn for implementer or reviewer work and pass the returned model and thinkingLevel.",
+    promptSnippet: "Recommend model and thinking level for a subagent task",
+    parameters: Parameters,
+    exposure: "direct",
+    async execute(
+      _id,
+      params: Static<typeof Parameters>,
+      _signal,
+      _onUpdate,
+      ctx: ExtensionContext,
+    ) {
+      if (params.task.trim() === "") return reply("task must not be empty", true);
+      const config = await loadConfig(ctx.cwd);
+      if (!config.ok) return reply(`${CONFIG_FILE}: ${config.error.message}`, true);
+      const judged = await judgeTaskRouting(deps.jev(ctx), {
+        task: params.task,
+        filesTouched: params.files ?? [],
+        riskSignals: params.riskSignals ?? [],
+      });
+      const judgement = judged.ok
+        ? { difficulty: judged.value.difficulty, risk: judged.value.risk }
+        : { difficulty: "routine" as const, risk: "low" as const };
+      const rec = recommendRoute({
+        routing: config.value.routing,
+        matrix: config.value.models,
+        available: availableModels(ctx.modelRegistry),
+        ...judgement,
+      });
+      const basis = judged.ok
+        ? `Jev judged ${judgement.difficulty}/${judgement.risk}.`
+        : `Jev unavailable (${judged.error.kind}); defaulted to ${judgement.difficulty}/${judgement.risk}.`;
+      const spawn = {
+        ...(rec.model === undefined ? {} : { model: rec.model }),
+        thinkingLevel: rec.thinkingLevel,
+      };
+      return reply(`${basis} ${rec.note}\nPass to agent_spawn: ${JSON.stringify(spawn)}`);
+    },
+  };
+}

package/src/subagents/VENDORED.md

@@ -0,0 +1,40 @@
+# Vendored: pi-subagent-manager
+
+- **Upstream:** `pi-subagent-manager` by Arnav Gupta, https://github.com/championswimmer/pi-subagent-manager
+- **Version:** 0.14.0 (from the npm tarball; no git commit is discoverable in the package)
+- **License:** MIT, Copyright (c) 2026 pi-subagent contributors. The notice is reproduced below and applies to this directory.
+- **Why vendored:** decision D6 / ADR-0003. This package needs per-spawn `model` and `thinkingLevel`, which upstream does not offer.
+- **Tool names and the `agents/*.md` format are kept unchanged** so existing habits and agent files keep working.
+- This package replaces `pi-subagent-manager`. Remove `npm:pi-subagent-manager` from `~/.pi/agent/settings.json`, or both register `agent_spawn` and pi refuses the duplicate.
+
+## Local modifications (keep this list current)
+
+1. Every `*.ts` file starts with `// @ts-nocheck`: upstream compiles under looser options than this repo's strict `tsconfig.json` (`exactOptionalPropertyTypes`, `erasableSyntaxOnly`). `biome.json` excludes `src/subagents`. Both are deliberate: the code is verbatim, and reformatting or retyping it would make upstream diffs unreadable.
+2. Relative `.js` import specifiers were rewritten to `.ts` (upstream relies on a TypeScript-aware loader; this repo's tests run under Node's native type stripping).
+3. `prefs/config.ts`: the bundled-agents directory is `../../../agents/` (was `../../agents/`) because the sources moved one level deeper.
+4. Per-spawn pins (I5.2): `types.ts` `AgentType.spawnOverrides` and `ThreadService.spawn` args gain `model`/`thinkingLevel`; `orch/tools.ts` `agent_spawn` schema exposes both; `orch/manager.ts` `spawn` validates them with `src/core/spawn-overrides.ts` and stores them on the cloned type (so saved threads keep them); `orch/runtime.ts` `resolveInitialSettings` applies them last for fresh spawns, and `createDriver` drops model preferences/scope policy when a model is pinned.
+5. Family preferences (I5.3): `prefs/models.ts` `selectPreferredModel` resolves each `models:` entry with `resolveCandidate` from `src/core/models.ts`, so `provider/gpt-*-sol` picks the newest available match; exact ids behave as before.
+
+## MIT notice
+
+MIT License
+
+Copyright (c) 2026 pi-subagent contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.