pi-t3-pstack 0.0.0-stage → 0.1.0

package/src/models.ts

@@ -0,0 +1,1249 @@
+import { readFileSync } from "node:fs";
+
+import { Type } from "@earendil-works/pi-ai";
+import type { Static, UserMessage } from "@earendil-works/pi-ai";
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+  ExtensionToolContext,
+} from "@earendil-works/pi-coding-agent";
+import { Value } from "typebox/value";
+
+import {
+  family,
+  parseEntry,
+  parseSheet,
+} from "../pstack/skills/setup-pstack/scripts/t3-sheet.mjs";
+import {
+  familyAvailable,
+  readAccounts,
+  registerAccounts,
+  settleChildren,
+  unavailableReason,
+} from "./accounts.ts";
+import {
+  APPROVAL_LINE,
+  briefProblems,
+  parseBrief,
+  PSTACK_COMMAND,
+  sessionBrief,
+} from "./brief.ts";
+import { policyPath } from "./resources.ts";
+import { modelSheetPath } from "./session.ts";
+import { t3Json, t3Text } from "./t3-json.ts";
+
+const OptionValueSchema = Type.Union([Type.String(), Type.Boolean()]);
+
+const CatalogOptionSchema = Type.Object({
+  id: Type.String(),
+  values: Type.Array(OptionValueSchema),
+});
+
+const CatalogModelSchema = Type.Object({
+  id: Type.String(),
+  options: Type.Optional(Type.Array(CatalogOptionSchema)),
+});
+
+const CatalogProviderSchema = Type.Object({
+  canRunChildTask: Type.Boolean(),
+  canRunCrossProviderChildTask: Type.Optional(Type.Boolean()),
+  models: Type.Array(CatalogModelSchema),
+  providerInstanceId: Type.String(),
+});
+
+const CatalogSchema = Type.Object({
+  inheritedModel: Type.Union([Type.String(), Type.Null()]),
+  inheritedProviderInstanceId: Type.Union([Type.String(), Type.Null()]),
+  providers: Type.Array(CatalogProviderSchema),
+});
+
+const ComplexitySchema = Type.Union([
+  Type.Literal("groundwork"),
+  Type.Literal("bounded"),
+  Type.Literal("general"),
+]);
+
+const SizesSchema = Type.Object({
+  bounded: Type.String(),
+  general: Type.String(),
+  groundwork: Type.String(),
+});
+
+const GuardedWordsSchema = Type.Array(Type.String(), { minItems: 1 });
+
+const JobTargetSchema = Type.Object({
+  model: Type.String(),
+  reasoning: Type.String(),
+});
+
+const JobSchema = Type.Union([
+  Type.Object({ M: JobTargetSchema, S: JobTargetSchema }),
+  Type.Object({ panel: Type.Array(JobTargetSchema, { minItems: 2 }) }),
+]);
+
+const PolicySchema = Type.Object({
+  briefs: Type.Object({
+    gpt: Type.Object({
+      diskMb: Type.Number(),
+      family: Type.String(),
+      minutes: Type.Number(),
+      size: Type.String(),
+    }),
+    noWrites: Type.Array(Type.String()),
+    redBeforeGreen: Type.Array(Type.String()),
+    sizes: Type.Record(
+      Type.String(),
+      Type.Object({ files: Type.Number(), minutes: Type.Number() })
+    ),
+  }),
+  jobs: Type.Record(Type.String(), JobSchema),
+  roles: Type.Array(
+    Type.Object({
+      alias: Type.Optional(Type.String()),
+      role: Type.String(),
+      skill: Type.String(),
+      tier: Type.Union([Type.Literal("single"), Type.Literal("panel")]),
+    })
+  ),
+  routing: Type.Object({
+    aboveHigh: Type.Array(
+      Type.Object({ level: Type.String(), words: GuardedWordsSchema })
+    ),
+    approval: Type.Record(Type.String(), Type.Array(Type.String())),
+    families: Type.Record(Type.String(), SizesSchema),
+    fast: Type.Object({
+      options: Type.Array(Type.String()),
+      words: GuardedWordsSchema,
+    }),
+    levels: Type.Array(Type.String()),
+    panel: Type.Array(Type.String(), { minItems: 2 }),
+    reasoning: SizesSchema,
+    reserved: Type.Array(
+      Type.Object({ model: Type.String(), words: GuardedWordsSchema })
+    ),
+  }),
+});
+
+type CatalogOption = Static<typeof CatalogOptionSchema>;
+
+type CatalogModel = Static<typeof CatalogModelSchema>;
+
+type CatalogProvider = Static<typeof CatalogProviderSchema>;
+
+type Catalog = Static<typeof CatalogSchema>;
+
+type Complexity = Static<typeof ComplexitySchema>;
+
+type Policy = Static<typeof PolicySchema>;
+
+type Role = Policy["roles"][number];
+
+type OptionValue = Static<typeof OptionValueSchema>;
+
+type TargetOptions = Readonly<Record<string, OptionValue>>;
+
+const TargetSchema = Type.Object({
+  model: Type.String(),
+  options: Type.Record(Type.String(), OptionValueSchema),
+  providerInstanceId: Type.String(),
+});
+
+type Target = Static<typeof TargetSchema>;
+
+type Entry = Target | null;
+
+interface ResolveContext {
+  readonly available: (modelFamily: string) => boolean;
+  readonly catalog: Catalog;
+  readonly notes: string[];
+  readonly policy: Policy;
+}
+
+const ResolutionSchema = Type.Union([
+  Type.Object({
+    kind: Type.Literal("targets"),
+    notes: Type.Array(Type.String()),
+    role: Type.String(),
+    targets: Type.Array(TargetSchema),
+  }),
+  Type.Object({
+    kind: Type.Literal("inherit-parent"),
+    notes: Type.Array(Type.String()),
+    role: Type.String(),
+  }),
+  Type.Object({
+    kind: Type.Literal("blocked"),
+    notes: Type.Array(Type.String()),
+    reason: Type.String(),
+    role: Type.String(),
+  }),
+]);
+
+type Resolution = Static<typeof ResolutionSchema>;
+
+const ORCHESTRATOR_CAPABILITIES_TOOLS = [
+  "mcp__t3-code__orchestrator_capabilities",
+  "mcp__t3__orchestrator_capabilities",
+] as const;
+
+const RESOLVED_ENTRY = "t3-pstack-resolved";
+
+const DELEGATE_TOOLS: ReadonlySet<string> = new Set([
+  "mcp__t3-code__delegate_task",
+  "mcp__t3__delegate_task",
+]);
+
+const SIZE_FALLBACK: Readonly<Record<Complexity, readonly Complexity[]>> = {
+  bounded: ["bounded", "groundwork", "general"],
+  general: ["general", "bounded", "groundwork"],
+  groundwork: ["groundwork", "bounded", "general"],
+};
+
+const lastSegment = (model: string): string => model.split("/").pop() ?? model;
+
+const describe = (target: Target): string => {
+  const options = Object.entries(target.options)
+    .map(([id, value]) => ` ${id}=${value}`)
+    .join("");
+
+  return `${target.providerInstanceId}/${target.model}${options}`;
+};
+
+const runnableProviders = (catalog: Catalog): CatalogProvider[] => {
+  const runnable = catalog.providers.filter(
+    (provider) =>
+      provider.canRunChildTask &&
+      (provider.canRunCrossProviderChildTask !== false ||
+        provider.providerInstanceId === catalog.inheritedProviderInstanceId)
+  );
+
+  const rank = (provider: CatalogProvider): number =>
+    provider.providerInstanceId === catalog.inheritedProviderInstanceId ? 0 : 1;
+
+  return runnable.toSorted((left, right) => rank(left) - rank(right));
+};
+
+const optionValues = (option: CatalogOption): readonly string[] =>
+  option.values.map(String);
+
+const isSwitch = (option: CatalogOption): boolean =>
+  option.values.every((value) => Value.Check(Type.Boolean(), value));
+
+const translateOptions = (
+  wanted: TargetOptions,
+  model: CatalogModel,
+  notes: string[]
+): TargetOptions => {
+  const known = model.options ?? [];
+  const translated = new Map<string, OptionValue>();
+
+  for (const [id, wantedValue] of Object.entries(wanted)) {
+    const value = String(wantedValue);
+
+    const sameId = known.find(
+      (option) => option.id === id && optionValues(option).includes(value)
+    );
+
+    const sameValue = known.find(
+      (option) => !isSwitch(option) && optionValues(option).includes(value)
+    );
+
+    const match = sameId ?? sameValue;
+
+    if (match === undefined) {
+      notes.push(`${model.id} has no option that accepts ${id}=${value}`);
+    } else {
+      translated.set(
+        match.id,
+        match.values.find((choice) => String(choice) === value) ?? value
+      );
+    }
+  }
+
+  return Object.fromEntries(translated);
+};
+
+const placeEntry = (
+  entry: Target,
+  catalog: Catalog,
+  notes: string[]
+): Target | undefined => {
+  const providers = runnableProviders(catalog);
+
+  const exact = providers.find(
+    (provider) => provider.providerInstanceId === entry.providerInstanceId
+  );
+
+  const ordered = exact === undefined ? providers : [exact, ...providers];
+
+  for (const provider of ordered) {
+    const model =
+      provider.models.find((candidate) => candidate.id === entry.model) ??
+      provider.models.find(
+        (candidate) => lastSegment(candidate.id) === lastSegment(entry.model)
+      );
+
+    if (model !== undefined) {
+      return {
+        model: model.id,
+        options: translateOptions(entry.options, model, notes),
+        providerInstanceId: provider.providerInstanceId,
+      };
+    }
+  }
+
+  return undefined;
+};
+
+const placeRouted = (
+  modelFamily: string,
+  complexity: Complexity,
+  {
+    catalog,
+    notes,
+    policy,
+  }: { catalog: Catalog; notes: string[]; policy: Policy }
+): Target | undefined => {
+  const sizes = policy.routing.families[modelFamily];
+
+  if (sizes === undefined) {
+    return undefined;
+  }
+
+  for (const size of SIZE_FALLBACK[complexity]) {
+    const placed = placeEntry(
+      {
+        model: sizes[size],
+        options: { reasoning: policy.routing.reasoning[complexity] },
+        providerInstanceId: catalog.inheritedProviderInstanceId ?? "",
+      },
+      catalog,
+      notes
+    );
+
+    if (placed !== undefined) {
+      if (size !== complexity) {
+        notes.push(
+          `${sizes[complexity]} cannot run here, so ${modelFamily} ${complexity} work uses ${placed.model}`
+        );
+      }
+
+      return placed;
+    }
+  }
+
+  notes.push(`no ${modelFamily} model can run here`);
+
+  return undefined;
+};
+
+const withJobReasoning = (
+  entry: Target,
+  complexity: Complexity,
+  policy: Policy
+): Target => ({
+  ...entry,
+  options: {
+    reasoning: policy.routing.reasoning[complexity],
+    ...entry.options,
+  },
+});
+
+const sheetEntries = (sheet: string, role: Role): Entry[] | undefined => {
+  const value = parseSheet(sheet).find(
+    (line: { key?: string }) =>
+      line.key === role.role || line.key === role.alias
+  )?.value;
+
+  return value === undefined
+    ? undefined
+    : String(value).split(",").map(parseEntry);
+};
+
+const resolveSingle = (
+  role: Role,
+  explicit: Entry,
+  complexity: Complexity,
+  { available, catalog, notes, policy }: ResolveContext
+): Resolution => {
+  if (explicit !== null && !available(family(explicit.model))) {
+    notes.push(
+      `${describe(explicit)} from the model sheet is on an exhausted account`
+    );
+  }
+
+  if (explicit !== null && available(family(explicit.model))) {
+    const placed = placeEntry(
+      withJobReasoning(explicit, complexity, policy),
+      catalog,
+      notes
+    );
+
+    if (placed !== undefined) {
+      notes.push("the model sheet names this target");
+
+      return { kind: "targets", notes, role: role.role, targets: [placed] };
+    }
+
+    notes.push(`${describe(explicit)} from the model sheet cannot run here`);
+  }
+
+  if (catalog.inheritedModel === null) {
+    return { kind: "inherit-parent", notes, role: role.role };
+  }
+
+  const parentFamily = family(catalog.inheritedModel);
+
+  const familyOrder = [
+    parentFamily,
+    ...policy.routing.panel.filter((name) => name !== parentFamily),
+  ].filter((name) => {
+    const open = available(name);
+
+    if (!open) {
+      notes.push(`${name} is on an exhausted account`);
+    }
+
+    return open;
+  });
+
+  const routed = familyOrder
+    .values()
+    .map((name) => placeRouted(name, complexity, { catalog, notes, policy }))
+    .find((target) => target !== undefined);
+
+  if (routed === undefined && !available(parentFamily)) {
+    return {
+      kind: "blocked",
+      notes,
+      reason: `Every model family that can run here is on an exhausted account. Wait for a reset or for /pstack-recovered.`,
+      role: role.role,
+    };
+  }
+
+  if (routed === undefined) {
+    notes.push("the role runs on the parent model");
+
+    return { kind: "inherit-parent", notes, role: role.role };
+  }
+
+  return { kind: "targets", notes, role: role.role, targets: [routed] };
+};
+
+const resolvePanel = (
+  role: Role,
+  explicit: readonly Entry[],
+  complexity: Complexity,
+  { available, catalog, notes, policy }: ResolveContext
+): Resolution => {
+  const targets: Target[] = [];
+
+  const families = (): Set<string> =>
+    new Set(targets.map((target) => family(target.model)));
+
+  const seat = (target: Target | undefined): void => {
+    if (
+      target !== undefined &&
+      !targets.some((seated) => describe(seated) === describe(target))
+    ) {
+      targets.push(target);
+    }
+  };
+
+  for (const entry of explicit) {
+    seat(
+      entry === null || !available(family(entry.model))
+        ? undefined
+        : placeEntry(
+            withJobReasoning(entry, complexity, policy),
+            catalog,
+            notes
+          )
+    );
+  }
+
+  for (const modelFamily of policy.routing.panel.filter(available)) {
+    if (explicit.length === 0 || families().size < 2) {
+      const placed = families().has(modelFamily)
+        ? undefined
+        : placeRouted(modelFamily, complexity, { catalog, notes, policy });
+
+      seat(placed);
+    }
+  }
+
+  if (families().size < 2) {
+    return {
+      kind: "blocked",
+      notes,
+      reason: `BLOCKED: independent review. The panel needs two model families that can run on this T3, and found ${[...families()].join(", ") || "none"}.`,
+      role: role.role,
+    };
+  }
+
+  return { kind: "targets", notes, role: role.role, targets };
+};
+
+const findRole = (policy: Policy, roleName: string): Role => {
+  const role = policy.roles.find(
+    (candidate) => candidate.role === roleName || candidate.alias === roleName
+  );
+
+  if (role === undefined) {
+    throw new Error(
+      `"${roleName}" is not a pstack role. Roles: ${policy.roles.map((candidate) => candidate.role).join("; ")}.`
+    );
+  }
+
+  return role;
+};
+
+export type JobSize = "S" | "M" | "L";
+
+const tierOf = (policy: Policy, model: string): Complexity | undefined => {
+  const sizes = policy.routing.families[family(model)];
+
+  // SAFETY: SIZE_FALLBACK is keyed by every Complexity value.
+  return (Object.keys(SIZE_FALLBACK) as Complexity[]).find(
+    (size) => sizes?.[size] === model
+  );
+};
+
+const jobSpec = (policy: Policy, job: string) => {
+  const spec = policy.jobs[job];
+
+  if (spec === undefined) {
+    throw new Error(
+      `"${job}" is not a job type. Jobs: ${Object.keys(policy.jobs).join(", ")}.`
+    );
+  }
+
+  return spec;
+};
+
+const resolvePanelJob = (
+  role: Role,
+  job: string,
+  panel: readonly { model: string; reasoning: string }[],
+  { available, catalog, notes }: ResolveContext
+): Resolution => {
+  const targets: Target[] = [];
+
+  for (const seat of panel) {
+    if (available(family(seat.model))) {
+      const placed = placeEntry(
+        {
+          model: seat.model,
+          options: { reasoning: seat.reasoning },
+          providerInstanceId: catalog.inheritedProviderInstanceId ?? "",
+        },
+        catalog,
+        notes
+      );
+
+      if (placed !== undefined) {
+        targets.push(placed);
+      }
+    } else {
+      notes.push(`${family(seat.model)} is on an exhausted account`);
+    }
+  }
+
+  if (new Set(targets.map((target) => family(target.model))).size < 2) {
+    return {
+      kind: "blocked",
+      notes,
+      reason: `BLOCKED: independent review. The ${job} panel needs two model families that can run here.`,
+      role: role.role,
+    };
+  }
+
+  return { kind: "targets", notes, role: role.role, targets };
+};
+
+// The routing table: a job type and size pick the tier, model and reasoning.
+// When that model's family is out, the same tier in the next family takes it,
+// except that GPT only ever takes size S work.
+const resolveJob = (
+  role: Role,
+  job: string,
+  size: JobSize | undefined,
+  explicit: readonly Entry[],
+  { available, catalog, notes, policy }: ResolveContext
+): Resolution => {
+  const spec = jobSpec(policy, job);
+
+  if ("panel" in spec) {
+    if (explicit.some((entry) => entry !== null)) {
+      return resolvePanel(role, explicit, "general", {
+        available,
+        catalog,
+        notes,
+        policy,
+      });
+    }
+
+    return resolvePanelJob(role, job, spec.panel, {
+      available,
+      catalog,
+      notes,
+      policy,
+    });
+  }
+
+  if (size === "L") {
+    throw new Error(
+      "Size L is too large to delegate: split the job into S or M tasks, or do it yourself."
+    );
+  }
+
+  if (size === undefined) {
+    throw new Error(`Job "${job}" needs a size: S or M.`);
+  }
+
+  const wanted = spec[size];
+  const sheetEntry = explicit[0] ?? null;
+
+  if (sheetEntry !== null && available(family(sheetEntry.model))) {
+    const placed = placeEntry(
+      {
+        ...sheetEntry,
+        options: { reasoning: wanted.reasoning, ...sheetEntry.options },
+      },
+      catalog,
+      notes
+    );
+
+    if (placed !== undefined) {
+      notes.push("the model sheet names this target");
+
+      return { kind: "targets", notes, role: role.role, targets: [placed] };
+    }
+  }
+
+  const wantedFamily = family(wanted.model);
+  const tier = tierOf(policy, wanted.model) ?? "bounded";
+  const { gpt } = policy.briefs;
+
+  const families = [
+    wantedFamily,
+    ...policy.routing.panel.filter((name) => name !== wantedFamily),
+  ].filter((name) => name !== gpt.family || size === gpt.size);
+
+  for (const name of families) {
+    if (available(name)) {
+      const model =
+        name === wantedFamily
+          ? wanted.model
+          : policy.routing.families[name]?.[tier];
+
+      const placed =
+        model === undefined
+          ? undefined
+          : placeEntry(
+              {
+                model,
+                options: { reasoning: wanted.reasoning },
+                providerInstanceId: catalog.inheritedProviderInstanceId ?? "",
+              },
+              catalog,
+              notes
+            );
+
+      if (placed !== undefined) {
+        if (name !== wantedFamily) {
+          notes.push(
+            `${wanted.model} is unavailable, so this ${job} ${size} job runs on ${placed.model}`
+          );
+        }
+
+        return { kind: "targets", notes, role: role.role, targets: [placed] };
+      }
+    } else {
+      notes.push(`${name} is on an exhausted account`);
+    }
+  }
+
+  return {
+    kind: "blocked",
+    notes,
+    reason: `No family that can take ${job} ${size} work is available. Wait for a reset or for /pstack-recovered.`,
+    role: role.role,
+  };
+};
+
+const resolveRole = (
+  roleName: string,
+  complexity: Complexity,
+  {
+    available,
+    catalog,
+    job,
+    policy,
+    sheet,
+    size,
+  }: {
+    available: (modelFamily: string) => boolean;
+    catalog: Catalog;
+    job?: string | undefined;
+    policy: Policy;
+    sheet: string;
+    size?: JobSize | undefined;
+  }
+): Resolution => {
+  const role = findRole(policy, roleName);
+  const notes: string[] = [];
+  const configured = sheetEntries(sheet, role) ?? [];
+  const context = { available, catalog, notes, policy };
+
+  if (job !== undefined) {
+    return resolveJob(role, job, size, configured, context);
+  }
+
+  if (role.tier === "panel") {
+    return resolvePanel(role, configured, complexity, context);
+  }
+
+  return resolveSingle(role, configured[0] ?? null, complexity, context);
+};
+
+const readPolicy = (): Policy => {
+  const policy = JSON.parse(readFileSync(policyPath(), "utf-8"));
+
+  if (!Value.Check(PolicySchema, policy)) {
+    throw new TypeError("models.json does not have the expected shape.");
+  }
+
+  return policy;
+};
+
+const readSheet = (): string => {
+  try {
+    return readFileSync(modelSheetPath(), "utf-8");
+  } catch {
+    return "";
+  }
+};
+
+const readCatalog = async (ctx: ExtensionToolContext): Promise<Catalog> => {
+  const name = ORCHESTRATOR_CAPABILITIES_TOOLS.find((candidate) =>
+    ctx.tools.some((tool) => tool.name === candidate)
+  );
+
+  if (name === undefined) {
+    throw new Error(
+      "T3's orchestrator_capabilities tool is not available in this session."
+    );
+  }
+
+  const outcome = await ctx.executeTool(name, {});
+
+  if (outcome.isError) {
+    throw new TypeError(
+      `orchestrator_capabilities failed: ${t3Text(outcome.result)}`
+    );
+  }
+
+  const catalog = t3Json(CatalogSchema, outcome.result);
+
+  if (catalog === undefined) {
+    throw new TypeError(
+      "orchestrator_capabilities did not return the expected shape."
+    );
+  }
+
+  return catalog;
+};
+
+const TextPartSchema = Type.Object({ text: Type.String() });
+
+const partText = (part: string | UserMessage["content"][number]): string => {
+  if (Value.Check(Type.String(), part)) {
+    return part;
+  }
+
+  return Value.Check(TextPartSchema, part) ? part.text : "";
+};
+
+const textOf = (content: UserMessage["content"]): string =>
+  [content].flat().map(partText).join(" ");
+
+const userWords = (ctx: ExtensionContext): string =>
+  ctx.sessionManager
+    .getBranch()
+    .map((entry) =>
+      entry.type === "message" && entry.message.role === "user"
+        ? textOf(entry.message.content)
+        : ""
+    )
+    .join(" ")
+    .toLowerCase();
+
+const sheetText = (): string => readSheet().toLowerCase();
+
+const RequestedTargetSchema = Type.Object({
+  model: Type.String(),
+  options: Type.Optional(
+    Type.Union([
+      Type.Array(
+        Type.Object({
+          id: Type.String(),
+          value: Type.Union([Type.String(), Type.Boolean()]),
+        })
+      ),
+      Type.Record(Type.String(), Type.Union([Type.String(), Type.Boolean()])),
+    ])
+  ),
+  providerInstanceId: Type.Optional(Type.Unknown()),
+});
+
+const requestedOptions = (
+  options: Static<typeof RequestedTargetSchema>["options"]
+): [string, string][] => {
+  if (options === undefined) {
+    return [];
+  }
+
+  if (Array.isArray(options)) {
+    return options.map((option) => [option.id, String(option.value)]);
+  }
+
+  return Object.entries(options).map(([id, value]) => [id, String(value)]);
+};
+
+const allowedBy = (
+  words: readonly string[],
+  sheetMention: string,
+  { sheet, user }: { sheet: string; user: string }
+): boolean =>
+  sheet.includes(sheetMention.toLowerCase()) ||
+  words.some((word) => user.includes(word.toLowerCase()));
+
+// The user's latest message, if it is exactly an approval line such as
+// "allow xhigh", unlocks those reasoning levels until their next message. A
+// delegated child never unlocks them: its user messages come from the parent.
+const approvedLevels = (
+  ctx: ExtensionContext,
+  policy: Policy
+): readonly string[] => {
+  if (sessionBrief(ctx) !== undefined) {
+    return [];
+  }
+
+  const latest = ctx.sessionManager
+    .getBranch()
+    .findLast(
+      (entry) => entry.type === "message" && entry.message.role === "user"
+    );
+
+  if (latest?.type !== "message" || latest.message.role !== "user") {
+    return [];
+  }
+
+  const said = textOf(latest.message.content)
+    .replaceAll(/<!--[\s\S]*?-->/gu, "")
+    .replaceAll(/<t3_context[\s\S]*?<\/t3_context>/gu, "")
+    .trim()
+    .toLowerCase()
+    .replace(/[.!]+$/u, "");
+
+  return policy.routing.approval[said] ?? [];
+};
+
+const reasoningOf = (
+  options: TargetOptions | [string, string][]
+): string | undefined => {
+  const pairs = Array.isArray(options) ? options : Object.entries(options);
+
+  const reasoning = pairs.find(([id]) =>
+    /thinking|effort|reasoning/iu.test(id)
+  )?.[1];
+
+  return reasoning === undefined ? undefined : String(reasoning);
+};
+
+const routingViolation = (
+  target: Static<typeof RequestedTargetSchema>,
+  policy: Policy,
+  allow: { approved: readonly string[]; sheet: string; user: string }
+): string | undefined => {
+  const model = lastSegment(target.model);
+
+  const reserved = policy.routing.reserved.find(
+    (entry) => entry.model === model
+  );
+
+  if (reserved !== undefined && !allowedBy(reserved.words, model, allow)) {
+    return `${model} is reserved for work where the user asked for it by name. Use pstack_model, or ask the user.`;
+  }
+
+  for (const [id, value] of requestedOptions(target.options)) {
+    if (
+      policy.routing.aboveHigh.some((entry) => entry.level === value) &&
+      !allow.approved.includes(value)
+    ) {
+      return `Reasoning above high (${id}=${value}) needs the user to send "allow xhigh" as their message in this chat. Use high or lower, or ask the user.`;
+    }
+
+    const fast =
+      policy.routing.fast.options.includes(id) &&
+      value !== "false" &&
+      value !== "default";
+
+    if (
+      fast &&
+      !allowedBy(policy.routing.fast.words, `${id}=${value}`, allow)
+    ) {
+      return `${id}=${value} is a speed option, and standard speed applies unless the user asks for fast mode.`;
+    }
+  }
+
+  return undefined;
+};
+
+const ComplexityOrJob = Type.Object({
+  complexity: Type.Optional(ComplexitySchema),
+  job: Type.Optional(
+    Type.String({
+      description:
+        "The job type from the routing table: mechanical, check, research, implement, hard, review, or design.",
+    })
+  ),
+  role: Type.String({ description: "The pstack role name.", minLength: 1 }),
+  size: Type.Optional(
+    Type.Union([Type.Literal("S"), Type.Literal("M"), Type.Literal("L")], {
+      description:
+        "S: 30 min or less and 5 files or fewer. M: 90 min or less and 15 files or fewer. L is refused: split it.",
+    })
+  ),
+});
+
+const modelTool = (pi: ExtensionAPI) =>
+  defineTool({
+    annotations: { readOnlyHint: true },
+    description:
+      "Resolve the delegate_task target for a pstack role. Pass the role name with the job and size from the routing table, or the complexity when there is no job. Pass each returned target as delegate_task's target. kind inherit-parent means omit target, and kind blocked means the role cannot run.",
+    execute: async (_toolCallId, params, _signal, _onUpdate, ctx) => {
+      await settleChildren(pi, ctx);
+
+      const accounts = readAccounts(ctx);
+
+      const resolution = resolveRole(
+        params.role,
+        params.complexity ?? "general",
+        {
+          available: (modelFamily) => familyAvailable(accounts, modelFamily),
+          catalog: await readCatalog(ctx),
+          job: params.job,
+          policy: readPolicy(),
+          sheet: readSheet(),
+          size: params.size,
+        }
+      );
+
+      if (resolution.kind === "targets") {
+        pi.appendEntry(RESOLVED_ENTRY, {
+          targets: resolution.targets.map((target) => ({
+            model: target.model,
+            options: target.options,
+            providerInstanceId: target.providerInstanceId,
+          })),
+        });
+      }
+
+      return {
+        content: [{ text: JSON.stringify(resolution, null, 2), type: "text" }],
+        details: resolution,
+        structuredContent: resolution,
+      };
+    },
+    label: "Pstack model",
+    name: "pstack_model",
+    outputSchema: ResolutionSchema,
+    parameters: ComplexityOrJob,
+    promptSnippet: "Resolve the delegate_task target for a pstack role.",
+  });
+
+const ResolvedSchema = Type.Object({
+  targets: Type.Array(
+    Type.Object({
+      model: Type.String(),
+      options: Type.Optional(Type.Record(Type.String(), OptionValueSchema)),
+      providerInstanceId: Type.String(),
+    })
+  ),
+});
+
+// The reasoning levels pstack_model returned for this target, or undefined
+// when it never returned the target.
+const resolvedReasoning = (
+  ctx: ExtensionContext,
+  target: Static<typeof RequestedTargetSchema>
+): (string | undefined)[] | undefined => {
+  const matches = ctx.sessionManager
+    .getBranch()
+    .flatMap((entry) =>
+      entry.type === "custom" &&
+      entry.customType === RESOLVED_ENTRY &&
+      Value.Check(ResolvedSchema, entry.data)
+        ? entry.data.targets.filter(
+            (resolved) =>
+              resolved.model === target.model &&
+              resolved.providerInstanceId === target.providerInstanceId
+          )
+        : []
+    );
+
+  return matches.length === 0
+    ? undefined
+    : matches.map((resolved) => reasoningOf(resolved.options ?? {}));
+};
+
+const namedByUser = (
+  target: Static<typeof RequestedTargetSchema>,
+  policy: Policy,
+  allow: { sheet: string; user: string }
+): boolean => {
+  const model = lastSegment(target.model).toLowerCase();
+
+  const words = [
+    model,
+    ...(policy.routing.reserved.find((entry) => entry.model === model)?.words ??
+      []),
+  ];
+
+  return allowedBy(words, model, allow);
+};
+
+const aboveResolved = (
+  requested: string | undefined,
+  resolved: readonly (string | undefined)[],
+  policy: Policy
+): string | undefined => {
+  if (requested === undefined || resolved.includes(undefined)) {
+    return undefined;
+  }
+
+  const rank = (level: string | undefined) =>
+    level === undefined ? -1 : policy.routing.levels.indexOf(level);
+
+  let [ceiling] = resolved;
+
+  for (const level of resolved) {
+    if (rank(level) > rank(ceiling)) {
+      ceiling = level;
+    }
+  }
+
+  return rank(requested) > rank(ceiling) ? ceiling : undefined;
+};
+
+const targetProblems = (
+  target: Static<typeof RequestedTargetSchema>,
+  ctx: ExtensionContext,
+  policy: Policy,
+  allow: { approved: readonly string[]; sheet: string; user: string }
+): string | undefined => {
+  const unavailable = unavailableReason(
+    readAccounts(ctx),
+    family(target.model)
+  );
+
+  if (unavailable !== undefined) {
+    return unavailable;
+  }
+
+  const violation = routingViolation(target, policy, allow);
+
+  if (violation !== undefined) {
+    return violation;
+  }
+
+  const resolved = resolvedReasoning(ctx, target);
+
+  if (resolved === undefined) {
+    return namedByUser(target, policy, allow)
+      ? undefined
+      : `${target.providerInstanceId}/${target.model} did not come from pstack_model, and the user did not name it. Call pstack_model for the job, or omit target to run on the parent model.`;
+  }
+
+  const requested = reasoningOf(requestedOptions(target.options));
+  const ceiling = aboveResolved(requested, resolved, policy);
+
+  if (ceiling !== undefined && !allow.approved.includes(requested ?? "")) {
+    return `Reasoning ${requested} is above what pstack_model returned for this job (${ceiling}). Use ${ceiling} or lower, or ask the user to send "allow xhigh".`;
+  }
+
+  return undefined;
+};
+
+const DelegateArgsSchema = Type.Object({
+  isolation: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+  mode: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+  task: Type.String(),
+});
+
+// GPT drifts on long or open work and leaves files behind, so it only gets
+// small, bounded jobs in a worktree of its own.
+const gptProblems = (
+  args: Static<typeof DelegateArgsSchema>,
+  policy: Policy
+): string[] => {
+  const rules = policy.briefs.gpt;
+  const brief = parseBrief(args.task);
+  const problems: string[] = [];
+
+  if (args.isolation !== "worktree") {
+    problems.push(
+      'GPT work runs in its own checkout: set isolation: "worktree".'
+    );
+  }
+
+  if (args.mode === "wait") {
+    problems.push('GPT work runs with mode: "async".');
+  }
+
+  if (brief === undefined) {
+    return problems;
+  }
+
+  if (brief.size !== undefined && brief.size !== rules.size) {
+    problems.push(
+      `GPT takes only size ${rules.size} work. Route this job with pstack_model.`
+    );
+  }
+
+  if (brief.minutes !== undefined && brief.minutes > rules.minutes) {
+    problems.push(`GPT work allows at most ${rules.minutes} min.`);
+  }
+
+  if (brief.diskMb !== undefined && brief.diskMb > rules.diskMb) {
+    problems.push(`GPT work allows at most ${rules.diskMb} MB of disk.`);
+  }
+
+  if (
+    brief.files.some((file) => file.startsWith("/") || file.startsWith("~"))
+  ) {
+    problems.push(
+      'GPT file paths in "Files you may write" must be relative to its worktree.'
+    );
+  }
+
+  return problems;
+};
+
+const SEND_TOOLS: ReadonlySet<string> = new Set([
+  "mcp__t3-code__t3_thread_send",
+  "mcp__t3__t3_thread_send",
+]);
+
+const policyFamilies = (): readonly string[] =>
+  Object.keys(readPolicy().routing.families);
+
+const TargetInputSchema = Type.Object({ target: RequestedTargetSchema });
+
+const SendInputSchema = Type.Object({ message: Type.String() });
+
+const requestedFamily = (
+  requested: Static<typeof RequestedTargetSchema> | undefined,
+  ctx: ExtensionContext
+): string | undefined => {
+  if (requested !== undefined) {
+    return family(requested.model);
+  }
+
+  return ctx.model === undefined ? undefined : family(ctx.model.id);
+};
+
+interface DelegateRequest {
+  readonly args: Static<typeof DelegateArgsSchema> | undefined;
+  readonly requested: Static<typeof RequestedTargetSchema> | undefined;
+}
+
+const delegateProblems = (
+  { args, requested }: DelegateRequest,
+  ctx: ExtensionContext
+): string[] => {
+  const policy = readPolicy();
+
+  const allow = {
+    approved: approvedLevels(ctx, policy),
+    sheet: sheetText(),
+    user: userWords(ctx),
+  };
+
+  const problems: string[] = [];
+
+  if (requested !== undefined) {
+    const problem = targetProblems(requested, ctx, policy, allow);
+
+    if (problem !== undefined) {
+      problems.push(problem);
+    }
+  }
+
+  if (args === undefined) {
+    return [...problems, "delegate_task needs a task brief."];
+  }
+
+  problems.push(
+    ...briefProblems(args.task, {
+      jobs: Object.keys(policy.jobs),
+      noWrites: policy.briefs.noWrites,
+      sizes: policy.briefs.sizes,
+    })
+  );
+
+  const childFamily = requestedFamily(requested, ctx);
+
+  if (childFamily === policy.briefs.gpt.family) {
+    problems.push(...gptProblems(args, policy));
+  }
+
+  return problems;
+};
+
+export const registerModelRouting = (pi: ExtensionAPI): void => {
+  pi.registerTool(modelTool(pi));
+  registerAccounts(pi, policyFamilies);
+
+  pi.on("tool_call", (event, ctx) => {
+    const { input } = event;
+
+    if (SEND_TOOLS.has(event.toolName)) {
+      const message = Value.Check(SendInputSchema, input) ? input.message : "";
+
+      if (APPROVAL_LINE.test(message) || PSTACK_COMMAND.test(message)) {
+        return {
+          block: true,
+          reason:
+            'A message to a child cannot carry the user\'s approval ("allow xhigh") or /pstack- commands.',
+        };
+      }
+
+      return;
+    }
+
+    if (!DELEGATE_TOOLS.has(event.toolName)) {
+      return;
+    }
+
+    const problems = delegateProblems(
+      {
+        args: Value.Check(DelegateArgsSchema, input) ? input : undefined,
+        requested: Value.Check(TargetInputSchema, input)
+          ? input.target
+          : undefined,
+      },
+      ctx
+    );
+
+    if (problems.length > 0) {
+      return {
+        block: true,
+        reason: `delegate_task refused. Fix all of these and call it again:\n- ${problems.join("\n- ")}`,
+      };
+    }
+  });
+};