@stringsync/splates 0.0.61 → 1.13.3

package/vendor/@stringsync/splates-server/index-acbcm66f.js

@@ -0,0 +1,1468 @@
+import {
+  thinkingOf2,
+  effortsOf2,
+  effortSettings2,
+  pickSettings2,
+  CAP_PREFIX2,
+  body,
+  FsStorage2,
+  Prices,
+  inputKey,
+  textOf2,
+  Spend,
+  treeOf2,
+  modelOption2,
+  Offered2,
+  Roster2,
+  traitsOf2,
+  splatesHome2
+} from "./index-caep3sde.js";
+import {
+  Exit2,
+  fail2
+} from "./index-t9w5a8ed.js";
+import {
+  Plans2,
+  goalOf2
+} from "./index-0jttnv86.js";
+
+// auto-pick/classes.ts
+var KIND_IDS = ["bugfix", "design", "open"];
+var DEPTH_IDS = ["shallow", "moderate", "deep"];
+var KINDS = [
+  question("bugfix", "Bugfix", "Does the task ask to find and fix a defect: something that fails, crashes or behaves other than it should?"),
+  question("design", "Design", "Does implementing the task require choosing between approaches, shaping an API or data model, or weighing trade-offs? Describing an already chosen solution carefully is not itself a design decision."),
+  question("open", "Open-ended", "Is the task open-ended or research-like, with investigation needed before the desired outcome is clear?")
+];
+var DEPTHS = [
+  {
+    id: "shallow",
+    label: "Shallow",
+    noul: {
+      type: "noul",
+      instructions: "Is the task's reasoning depth shallow: the hardest step is applying a known, direct change? Judge the work requested, not the length or care of the message, number of files, or amount of testing.",
+      criteria: {
+        true: "A long, careful message asking for a one-spot change is shallow. So are a specified CSS/layout adjustment, renaming across many files, wiring an existing pattern, or applying an explicit solution. Copying an existing page behavior into a CLI command, or bumping a dependency and threading a specified option through existing calls, is shallow even with tests in several files. Reading nearby code to find the spot does not alone make it moderate.",
+        false: "The solution needs tracing interacting behavior or deriving an approach (moderate), or resolving subtle competing constraints or an elusive cause (deep)."
+      }
+    }
+  },
+  {
+    id: "moderate",
+    label: "Moderate",
+    noul: {
+      type: "noul",
+      instructions: "Is the task's reasoning depth moderate: its hardest step needs tracing behavior or working out an implementation using familiar patterns? Judge reasoning, not the number of files, request length, stakes, or verification effort.",
+      criteria: {
+        true: "Trace ordinary synchronous behavior, find a localized ordinary bug, or work out how a feature fits existing behavior. Several related constraints need connecting, with a clear approach once understood.",
+        false: "Applying a specified solution or straightforward existing pattern is shallow, even over many files. Novel architecture, subtle invariants or an elusive failure needing competing hypotheses is deep."
+      }
+    }
+  },
+  {
+    id: "deep",
+    label: "Deep",
+    noul: {
+      type: "noul",
+      instructions: "Is the task's reasoning depth deep: its hardest step requires sustained reasoning about subtle invariants, competing hypotheses, or architectural trade-offs? Size, polished prose, unfamiliar code, high stakes and screenshots alone do not imply deep reasoning.",
+      criteria: {
+        true: "A concurrency or ordering failure involving asynchronous ownership, teardown, atomicity or persistence; reconciling lifecycle or consistency guarantees; designing a policy that must bound autonomous work and preserve user approval. Even with a suspected cause, proving the fix covers interleavings takes deep reasoning. Architectural or policy trade-offs left unresolved can require deep reasoning. The solution cannot be obtained just by tracing ordinary behavior or following a given plan.",
+        false: "A routine feature or ordinary bug whose approach emerges by tracing existing behavior is moderate. A specified change or direct pattern is shallow, even if its request is long or many files change."
+      }
+    }
+  }
+];
+var BREADTHS = [
+  question("spot", "One spot", "Is the code the task must read and change confined to one small spot, even if its message is long? Use any file paths supplied in the state as evidence, not as the only files it may touch."),
+  question("module", "One module", "Does the task need reading and changing several related pieces within one module or feature?"),
+  question("system", "Across modules", "Does the task need reading and changing several modules or packages? A mechanical rename can have this breadth and still have shallow reasoning depth.")
+];
+var CLARITY_IDS = ["settled", "unresolved"];
+var CLARITIES = [
+  question("settled", "Calls settled", "Has the user settled the desired behavior or approach and its consequential choices, leaving implementation calls to the agent? Look for explicit decisions and concrete requirements, not an assertive tone, polished wording or message length. A tentative voice can describe a settled solution. Settled behavior can still require deep reasoning to implement safely."),
+  question("unresolved", "Calls unresolved", "Is the user exploring what should happen or asking for help choosing an approach, leaving consequential product or behavior choices open? Confident phrasing alone does not settle these choices. Do not count routine implementation choices or uncertainty about a bug cause when the desired behavior is clear.")
+];
+var STAKES = [
+  question("routine", "Routine", "Is the task a reversible code or presentation change without material risk to stored data, security, migrations or releases?"),
+  question("sensitive", "Sensitive", "Does the task involve migrations, stored data integrity, security or credentials, publishing or releases, where an incorrect change has material consequences?")
+];
+var VERIFICATIONS = [
+  question("automated", "Automated", "Can the requested behavior be checked adequately with tests, types or other automated checks, without visually inspecting UI, layout or screenshots?"),
+  question("visual", "Needs eyes", "Does checking the requested result need visual inspection, such as UI, layout, styling, screenshots or video? Use attachment kinds and names as context, never assume their contents are visible.")
+];
+var CONTEXT_CLASSES = {
+  breadth: BREADTHS,
+  clarity: CLARITIES,
+  stakes: STAKES,
+  verification: VERIFICATIONS
+};
+function question(id, label, instructions) {
+  return { id, label, noul: { type: "noul", instructions } };
+}
+// auto-pick/classify.ts
+import { aborts } from "../../core/abort/index.js";
+import { Duration } from "../../core/time/index.js";
+
+// auto-pick/system-one.ts
+import { z } from "zod";
+async function askSystemOne(name, url, token, body, opts) {
+  const response = await (opts.fetch ?? fetch)(url, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${token}`,
+      "content-type": "application/json"
+    },
+    body: JSON.stringify(body),
+    signal: opts.signal
+  });
+  if (!response.ok) {
+    await response.body?.cancel();
+    throw new Error(`${name} answered ${response.status}`);
+  }
+  const json = await response.json().catch(() => {
+    return;
+  });
+  const inner = typeof json === "object" && json !== null && "result" in json ? json.result : json;
+  const reply = REPLY.safeParse(inner);
+  if (!reply.success) {
+    throw new Error(`${name} answered with no answers in it`);
+  }
+  const { usage } = reply.data;
+  return {
+    answers: new Map(Object.entries(reply.data.answers).map(([id, probability]) => [
+      id,
+      Math.min(1, Math.max(0, probability))
+    ])),
+    ...usage === undefined ? {} : { usage: { input: usage.input_tokens, output: usage.output_tokens } }
+  };
+}
+var REPLY = z.object({
+  answers: z.record(z.string(), z.union([
+    z.number(),
+    z.object({ noul: z.number() }).transform((answer) => answer.noul)
+  ])),
+  usage: z.object({ input_tokens: z.number(), output_tokens: z.number() }).optional().catch(undefined)
+});
+
+// auto-pick/clef.ts
+var MODEL = "clef-flash";
+
+class Clef {
+  account;
+  token;
+  opts;
+  constructor(account, token, opts = {}) {
+    this.account = account;
+    this.token = token;
+    this.opts = opts;
+  }
+  judge(judgment, opts = {}) {
+    return askSystemOne("Clef", `${this.opts.origin ?? "https://api.cloudflare.com"}/client/v4/accounts/${this.account}/ai/run/@cf/cloudflare/${MODEL}`, this.token, judgment, { ...opts, fetch: this.opts.fetch });
+  }
+}
+
+// auto-pick/jev.ts
+var MODEL2 = "jev-latest";
+var JEV_INPUT_PRICE = 0.042;
+
+class Jev {
+  token;
+  opts;
+  constructor(token, opts = {}) {
+    this.token = token;
+    this.opts = opts;
+  }
+  async judge(judgment, opts = {}) {
+    const verdict = await askSystemOne("Jev", `${this.opts.origin ?? "https://api.typesafe.ai"}/v1/systemone`, this.token, { model: MODEL2, ...judgment }, { ...opts, fetch: this.opts.fetch });
+    if (verdict.usage === undefined) {
+      return verdict;
+    }
+    const dollars = verdict.usage.input * JEV_INPUT_PRICE / 1e6;
+    if (this.opts.spend !== undefined) {
+      await this.opts.spend.record({
+        at: (this.opts.now?.() ?? new Date).toISOString(),
+        provider: "typesafe",
+        service: this.opts.attribution?.purpose === undefined ? MODEL2 : `${MODEL2} ${this.opts.attribution.purpose}`,
+        kind: "billed",
+        dollars,
+        project: this.opts.attribution?.project ?? null,
+        task: this.opts.attribution?.task ?? null,
+        conversation: this.opts.attribution?.conversation ?? null
+      }).catch(() => {});
+    }
+    return { ...verdict, dollars };
+  }
+}
+
+// auto-pick/judge.ts
+var JUDGE_CREDS = {
+  jev: ["TYPESAFE_API_KEY"],
+  clef: ["CLOUDFLARE_ACCOUNT_ID", "CLOUDFLARE_API_TOKEN"]
+};
+async function judgeFrom(credentials, opts = {}) {
+  const typesafe = await credentials.get("TYPESAFE_API_KEY");
+  if (typesafe) {
+    return new Jev(typesafe, opts);
+  }
+  const id = await credentials.get("CLOUDFLARE_ACCOUNT_ID");
+  const token = await credentials.get("CLOUDFLARE_API_TOKEN");
+  return id && token ? new Clef(id, token) : null;
+}
+async function projectJudge(project, slug, who = {}) {
+  return judgeFrom(project.creds.credentials, {
+    spend: new Spend(new FsStorage2(splatesHome2(project.ps), project.fs)),
+    attribution: {
+      project: await slug(),
+      task: who.task ?? null,
+      conversation: who.conversation ?? null,
+      ...who.purpose === undefined ? {} : { purpose: who.purpose }
+    }
+  });
+}
+
+// auto-pick/classify.ts
+async function classify(input) {
+  if (input.judge === null) {
+    return {
+      ok: false,
+      reason: `no judge: keep ${JUDGE_CREDS.jev.join(", ")} for Jev, or ${JUDGE_CREDS.clef.join(" and ")} for Clef`
+    };
+  }
+  const timeout = input.timeout ?? DEFAULT_TIMEOUT;
+  const signals = [AbortSignal.timeout(timeout.ms)];
+  if (input.signal !== undefined) {
+    signals.push(input.signal);
+  }
+  const signal = AbortSignal.any(signals);
+  try {
+    const verdict = await aborts.race(signal, input.judge.judge({
+      state: {
+        subject: input.subject,
+        detail: input.detail.slice(0, DETAIL_CHARS),
+        paths: namedPaths(`${input.subject}
+${input.detail}`),
+        attachments: attachmentSummary(input.attachments ?? [])
+      },
+      questions: {
+        ...questions("kind", KINDS),
+        ...questions("depth", DEPTHS),
+        ...Object.fromEntries(Object.entries(CONTEXT_CLASSES).flatMap(([group, classes]) => Object.entries(questions(group, classes))))
+      }
+    }, { signal }));
+    return {
+      ok: true,
+      classification: {
+        kinds: answers(verdict, "kind", KINDS),
+        depth: answers(verdict, "depth", DEPTHS),
+        breadth: answers(verdict, "breadth", CONTEXT_CLASSES.breadth),
+        clarity: answers(verdict, "clarity", CONTEXT_CLASSES.clarity),
+        stakes: answers(verdict, "stakes", CONTEXT_CLASSES.stakes),
+        verification: answers(verdict, "verification", CONTEXT_CLASSES.verification)
+      }
+    };
+  } catch (error) {
+    if (input.signal?.aborted) {
+      throw input.signal.reason;
+    }
+    return {
+      ok: false,
+      reason: signal.aborted ? `the judge took over ${timeout.ms / 1000}s` : `the judge failed (${error instanceof Error ? error.message : String(error)})`
+    };
+  }
+}
+function questions(group, classes) {
+  return Object.fromEntries(classes.map((each) => [`${group}:${each.id}`, each.noul]));
+}
+function answers(verdict, group, classes) {
+  return Object.fromEntries(classes.map((each) => [
+    each.id,
+    verdict.answers.get(`${group}:${each.id}`) ?? 0.5
+  ]));
+}
+function namedPaths(words) {
+  return [
+    ...new Set(words.match(/(?:[\w@.~+-]+\/)+[\w.*@+-]+(?:\/[\w.*@+-]+)*\/?/g) ?? [])
+  ];
+}
+function attachmentSummary(files) {
+  const groups = new Map;
+  for (const file of files) {
+    const kind = file.mimeType.startsWith("image/") ? "image" : file.mimeType.startsWith("video/") ? "video" : file.mimeType.startsWith("audio/") ? "audio file" : "file";
+    const names = groups.get(kind) ?? [];
+    names.push(file.name);
+    groups.set(kind, names);
+  }
+  return [...groups].map(([kind, names]) => `${names.length} ${kind}${names.length === 1 ? "" : "s"} (${names.join(", ")})`).join(", ") || "none";
+}
+var DEFAULT_TIMEOUT = Duration.secs(5);
+var DETAIL_CHARS = 4000;
+// auto-pick/rules.ts
+import { z as z2 } from "zod";
+
+// auto-pick/rule-names.ts
+var RULES_FORMAT = 2;
+var ANY = "*";
+var DEFAULT_PACE = { on: true, slack: 0.1, spent: 0.95 };
+function ruleLabel(rule) {
+  const kind = rule.kind === ANY ? "any kind" : KINDS.find((each) => each.id === rule.kind)?.label ?? rule.kind;
+  const depth = rule.depth === ANY ? "any depth" : DEPTHS.find((each) => each.id === rule.depth)?.label ?? rule.depth;
+  const clarity = rule.clarity === undefined || rule.clarity === ANY ? "" : `, ${CLARITIES.find((each) => each.id === rule.clarity)?.label ?? rule.clarity}`;
+  return `${kind}, ${depth}${clarity}`;
+}
+
+// auto-pick/rules.ts
+function checkRules(value) {
+  const parsed = AUTO_PICK_RULES.safeParse(migrateRules(value));
+  if (parsed.success) {
+    return { ok: true, rules: parsed.data };
+  }
+  const issue = parsed.error.issues[0];
+  return {
+    ok: false,
+    problem: `${issue?.path.join(".") || "the rules"}: ${issue?.message}`
+  };
+}
+var PICK = z2.object({
+  agent: z2.string().min(1),
+  model: z2.string().min(1).optional(),
+  effort: z2.string().min(1).optional()
+});
+var RULE = z2.object({
+  kind: z2.enum([ANY, ...KIND_IDS]),
+  depth: z2.enum([ANY, ...DEPTH_IDS]),
+  clarity: z2.enum([ANY, ...CLARITY_IDS]).optional(),
+  picks: z2.array(PICK).min(1, "a rule picks at least one agent").superRefine((picks, ctx) => {
+    const at = picks.findIndex((pick, index) => picks.findIndex((each) => each.agent === pick.agent && each.model === pick.model) !== index);
+    if (at >= 0) {
+      ctx.addIssue({
+        code: "custom",
+        path: [at],
+        message: "a rule names the same agent and model once"
+      });
+    }
+  })
+});
+var AUTO_PICK_RULES = z2.object({
+  format: z2.literal(RULES_FORMAT),
+  threshold: z2.number().min(0).max(1),
+  rules: z2.array(RULE).min(1, "the rules list at least one rule"),
+  pace: z2.object({
+    on: z2.boolean(),
+    slack: z2.number().min(0).max(1),
+    spent: z2.number().min(0).max(1)
+  }).optional()
+}).superRefine((value, ctx) => {
+  const last = value.rules.at(-1);
+  if (last !== undefined && (last.kind !== ANY || last.depth !== ANY || last.clarity !== undefined && last.clarity !== ANY)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["rules", value.rules.length - 1],
+      message: "the last rule must be kind * and depth * with any certainty, so every task maps to a pick"
+    });
+  }
+});
+function migrateRules(value) {
+  if (value === null || typeof value !== "object" || !("format" in value) || value.format !== 1 || !("rules" in value) || !Array.isArray(value.rules)) {
+    return value;
+  }
+  const depths = {
+    easy: "shallow",
+    medium: "moderate",
+    hard: "deep",
+    "*": "*"
+  };
+  return {
+    ...value,
+    format: 2,
+    rules: value.rules.map((rule) => {
+      if (rule === null || typeof rule !== "object") {
+        return rule;
+      }
+      const { difficulty, ...rest } = rule;
+      return {
+        ...rest,
+        kind: rest.kind === "lookup" || rest.kind === "mechanical" ? "*" : rest.kind,
+        depth: rest.depth ?? (typeof difficulty === "string" ? difficulty === "*" && rest.kind === "lookup" ? "shallow" : difficulty === "*" && rest.kind === "mechanical" ? "moderate" : depths[difficulty] ?? difficulty : difficulty)
+      };
+    })
+  };
+}
+
+// auto-pick/decide.ts
+function decide(input) {
+  const { threshold } = input.rules;
+  const kind = likeliest(KINDS, input.classification.kinds, threshold);
+  const depth = likeliest(DEPTHS, input.classification.depth, threshold);
+  const answers = input.classification.clarity;
+  const clarity = answers === undefined || answers.settled === answers.unresolved || Math.max(answers.settled, answers.unresolved) <= 0.5 ? null : likeliest(CLARITIES, answers, threshold).id;
+  const decision = choose(input, kind.id, depth.id, `judged: ${kind.said}, ${depth.said}`, answers === undefined ? undefined : clarity);
+  for (const [group, classes] of Object.entries(CONTEXT_CLASSES)) {
+    const answers = input.classification[group];
+    if (answers !== undefined) {
+      decision.reasons.push(`${group}: ${classes.map((each) => `${each.label} ${Math.round((answers[each.id] ?? 0.5) * 100)}%`).join(", ")}`);
+    }
+  }
+  return decision;
+}
+function decideWithout(input) {
+  return choose(input, null, null, input.reason);
+}
+function decideDeeper(input, set, why) {
+  const at = DEPTHS.findIndex((each) => each.id === set.depth);
+  const deeper = DEPTHS[Math.max(at, 0) + 1];
+  if (deeper === undefined) {
+    return null;
+  }
+  const kind = KINDS.find((each) => each.id === set.kind)?.id ?? null;
+  return choose(input, kind, deeper.id, `${why}, so ${deeper.label.toLowerCase()}`, set.clarity === undefined ? undefined : CLARITIES.find((each) => each.id === set.clarity)?.id ?? null);
+}
+function choose(input, kind, depth, judged, clarity) {
+  const index = input.rules.rules.findIndex((each) => (each.kind === ANY || each.kind === kind) && (each.depth === ANY || each.depth === depth) && (each.clarity === undefined || each.clarity === ANY || each.clarity === clarity));
+  const matched = input.rules.rules[index];
+  if (matched === undefined) {
+    throw new Error("no Auto pick rule matches: the last must be * *");
+  }
+  const reasons = [judged, `rule ${index + 1}: ${ruleLabel(matched)}`];
+  const pace = input.rules.pace ?? DEFAULT_PACE;
+  const blind = [];
+  const picks = matched.picks.flatMap((pick) => {
+    const agent = input.agents.find((each) => each.id === pick.agent);
+    if (agent === undefined) {
+      reasons.push(`passed over ${pick.agent}: not on the roster`);
+      return [];
+    }
+    if (!input.runnable.includes(agent.id)) {
+      reasons.push(`passed over ${agent.name}: can't run here`);
+      return [];
+    }
+    const model = modelOf(agent, pick.model);
+    if (model === null) {
+      reasons.push(`passed over ${agent.name}: no model '${pick.model}' on the roster`);
+      return [];
+    }
+    const { model: _, ...rest } = pick;
+    const limits = (input.limits[agent.id] ?? []).filter((each) => !each.window.startsWith(CAP_PREFIX2) || each.window === `${CAP_PREFIX2}${model ?? ""}`);
+    const candidate = {
+      pick: model === undefined ? rest : { ...rest, model },
+      agent,
+      pressure: pressed(limits, input.now),
+      fast: pace.on ? fastest(limits, input.now, pace.slack) : undefined
+    };
+    if (input.images === true) {
+      const sees = seesImages(input, agent, model);
+      if (sees === false) {
+        reasons.push(`passed over ${agent.name}: can't see images`);
+        blind.push(candidate);
+        return [];
+      }
+      if (sees === null) {
+        reasons.push(`${agent.name} stays a pick: image support unknown`);
+      }
+    }
+    return [candidate];
+  });
+  let usable = picks;
+  if (picks.length === 0 && blind[0] !== undefined) {
+    reasons.push(`none of rule ${index + 1}'s picks can see images, so the first: ${blind[0].agent.name}`);
+    usable = [blind[0]];
+  }
+  const left = usable.filter((each) => (each.pressure?.used ?? 0) < pace.spent);
+  const paced = left.find((each) => each.fast === undefined);
+  let chosen = paced ?? left[0];
+  for (const each of usable.slice(0, chosen === undefined ? 0 : usable.indexOf(chosen))) {
+    reasons.push(`passed over ${each.agent.name}: ${(each.pressure?.used ?? 0) < pace.spent ? ahead(each.fast) : plan(each.pressure)}`);
+  }
+  if (chosen !== undefined && paced === undefined) {
+    reasons.push(`every pick with plan left is ahead of pace, so the first: ${chosen.agent.name}, ${ahead(chosen.fast)}`);
+  }
+  if (chosen === undefined) {
+    chosen = [...usable].sort((left, right) => (left.pressure?.used ?? 0) - (right.pressure?.used ?? 0))[0];
+    if (chosen !== undefined) {
+      reasons.push(`every pick is past ${Math.round(pace.spent * 100)}% of a plan, so the least used: ${chosen.agent.name}, ${plan(chosen.pressure)}`);
+    }
+  }
+  if (chosen === undefined) {
+    const first = input.agents.find((each) => input.runnable.includes(each.id));
+    if (first === undefined) {
+      throw new Error("the roster lists no agent splates can run here");
+    }
+    reasons.push(`no pick of rule ${index + 1} can run here, so ${first.name} on its default`);
+    chosen = {
+      pick: { agent: first.id },
+      agent: first,
+      pressure: undefined,
+      fast: undefined
+    };
+  }
+  const pick = withEffort(chosen.pick, chosen.agent, input.offered[chosen.agent.id], reasons);
+  reasons.unshift(headline(pick, chosen.agent));
+  return {
+    pick,
+    rule: index,
+    kind,
+    depth,
+    ...clarity === undefined ? {} : { clarity },
+    reasons
+  };
+}
+function seesImages(input, agent, model) {
+  const said = input.sights?.[agent.id];
+  const name = agent.models.find((each) => each.id === model)?.name ?? null;
+  const key = inputKey(agent.id, model ?? null, name);
+  const inputs = key === null ? undefined : input.catalog?.[key]?.inputs;
+  const listed = inputs?.includes("image");
+  if (said === false || listed === false) {
+    return false;
+  }
+  return said === true && listed === true ? true : null;
+}
+function likeliest(classes, answers, threshold) {
+  const best = classes.reduce((most, each) => most === undefined || answers[each.id] > answers[most.id] ? each : most, undefined);
+  if (best === undefined) {
+    return { id: null, said: "none" };
+  }
+  const said = `${best.label} ${Math.round(answers[best.id] * 100)}%`;
+  return answers[best.id] >= threshold ? { id: best.id, said } : { id: null, said: `unsure (${said})` };
+}
+function modelOf(agent, wanted) {
+  if (wanted === undefined || agent.models.length === 0) {
+    return wanted;
+  }
+  const lower = wanted.toLowerCase();
+  return agent.models.find((each) => each.id === wanted || each.id.toLowerCase() === lower || each.name.toLowerCase() === lower)?.id ?? null;
+}
+function withEffort(pick, agent, offered, reasons) {
+  if (pick.effort === undefined || offered === undefined) {
+    return pick;
+  }
+  const { effort, ...rest } = pick;
+  const setting = offered.find((each) => each.category === "thought_level");
+  if (setting === undefined) {
+    reasons.push(`${agent.name} offers no thinking level, so its own`);
+    return rest;
+  }
+  const lower = effort.toLowerCase();
+  const level = setting.options.find((each) => each.value.toLowerCase() === lower || each.name.toLowerCase() === lower);
+  if (level === undefined) {
+    reasons.push(`${agent.name} offers no ${effort} thinking, so its own`);
+    return rest;
+  }
+  return { ...rest, effort: level.value };
+}
+function headline(pick, agent) {
+  const model = pick.model === undefined ? `${agent.name} on its default model` : agent.models.find((each) => each.id === pick.model)?.name ?? `${agent.name} ${pick.model}`;
+  return pick.effort === undefined ? model : `${model}, ${pick.effort} effort`;
+}
+function pressed(limits, now) {
+  return limits.filter((each) => !(Date.parse(each.resets) <= now.getTime())).reduce((most, each) => most === undefined || each.used > most.used ? { used: each.used, window: each.window } : most, undefined);
+}
+function fastest(limits, now, slack) {
+  return limits.flatMap((each) => {
+    const length = lengthOf(each.window);
+    const resets = Date.parse(each.resets);
+    if (length === null || !(resets > now.getTime())) {
+      return [];
+    }
+    const read = each.at === null ? now.getTime() : Date.parse(each.at);
+    const elapsed = Math.min(1, Math.max(0, 1 - (resets - read) / length));
+    return each.used > elapsed + slack ? [{ window: each.window, used: each.used, elapsed }] : [];
+  }).reduce((most, each) => most === undefined || each.used - each.elapsed > most.used - most.elapsed ? each : most, undefined);
+}
+var COUNTS = {
+  one: 1,
+  two: 2,
+  three: 3,
+  four: 4,
+  five: 5,
+  six: 6,
+  seven: 7,
+  eight: 8,
+  nine: 9,
+  ten: 10,
+  twelve: 12,
+  thirty: 30
+};
+var UNITS = {
+  minute: 60000,
+  hour: 3600000,
+  day: 86400000,
+  week: 604800000
+};
+function lengthOf(window) {
+  const [count, unit] = window.toLowerCase().split("_");
+  const times = /^\d+$/.test(count ?? "") ? Number(count) : COUNTS[count ?? ""];
+  const each = UNITS[unit?.replace(/s$/, "") ?? ""];
+  return times === undefined || each === undefined || times === 0 ? null : times * each;
+}
+function ahead(pace) {
+  return pace === undefined ? "within its pace" : `${Math.round(pace.used * 100)}% of ${pace.window} used, ${Math.round(pace.elapsed * 100)}% of it gone`;
+}
+function plan(most) {
+  return most === undefined ? "no plan limits" : `${Math.round(most.used * 100)}% of ${most.window} used`;
+}
+// auto-pick/defaults.ts
+var DEFAULT_RULES = {
+  format: RULES_FORMAT,
+  threshold: 0.5,
+  rules: [
+    shallow(),
+    designModerate("design"),
+    designModerate("open"),
+    moderate(),
+    deepBugfix(),
+    designDeep("design"),
+    designDeep("open"),
+    deep(),
+    fallback()
+  ],
+  pace: DEFAULT_PACE
+};
+function shallow() {
+  return {
+    kind: ANY,
+    depth: "shallow",
+    picks: [
+      { agent: "claude", model: "sonnet", effort: "low" },
+      { agent: "codex", model: "gpt-6.1-sol", effort: "low" },
+      { agent: "claude", model: "haiku", effort: "low" }
+    ]
+  };
+}
+function designModerate(kind) {
+  return {
+    kind,
+    depth: "moderate",
+    picks: [
+      { agent: "claude", model: "sonnet", effort: "high" },
+      { agent: "claude", model: "opus", effort: "medium" },
+      { agent: "codex", model: "gpt-6.1-sol", effort: "medium" }
+    ]
+  };
+}
+function moderate() {
+  return {
+    kind: ANY,
+    depth: "moderate",
+    picks: [
+      { agent: "claude", model: "sonnet", effort: "medium" },
+      { agent: "codex", model: "gpt-6.1-sol", effort: "medium" },
+      { agent: "claude", model: "opus", effort: "medium" }
+    ]
+  };
+}
+function deepBugfix() {
+  return {
+    kind: "bugfix",
+    depth: "deep",
+    picks: [
+      { agent: "claude", model: "opus", effort: "high" },
+      { agent: "kimi", model: "kimi-code/k3.1-pro", effort: "max" },
+      { agent: "codex", model: "gpt-6-astra", effort: "high" }
+    ]
+  };
+}
+function designDeep(kind) {
+  return {
+    kind,
+    depth: "deep",
+    picks: [
+      { agent: "claude", model: "opus", effort: "high" },
+      { agent: "kimi", model: "kimi-code/k3.1-pro", effort: "high" },
+      { agent: "codex", model: "gpt-6-astra", effort: "high" }
+    ]
+  };
+}
+function deep() {
+  return {
+    kind: ANY,
+    depth: "deep",
+    picks: [
+      { agent: "kimi", model: "kimi-code/k3.1-pro", effort: "max" },
+      { agent: "claude", model: "opus", effort: "high" },
+      { agent: "codex", model: "gpt-6-astra", effort: "high" }
+    ]
+  };
+}
+function fallback() {
+  return {
+    kind: ANY,
+    depth: ANY,
+    picks: [
+      { agent: "claude", model: "sonnet", effort: "medium" },
+      { agent: "claude", model: "opus", effort: "medium" },
+      { agent: "codex", model: "gpt-6.1-sol", effort: "medium" }
+    ]
+  };
+}
+// auto-pick/key.ts
+function classificationKey(subject, detail, attachments = []) {
+  return Bun.hash(JSON.stringify([
+    3,
+    subject,
+    detail.slice(0, DETAIL_CHARS),
+    namedPaths(`${subject}
+${detail}`),
+    attachments
+  ])).toString(36);
+}
+// auto-pick/follow-up.ts
+function wordsToJudge(messages) {
+  const person = messages.filter((each) => each.role === "user" && each.told === undefined).map(textOf2).filter((each) => !each.startsWith("[SPLATES"));
+  return person.length < 2 ? null : split(person.join(`
+
+`));
+}
+function wordsSoFar(messages) {
+  const person = messages.filter((each) => each.role === "user" && each.told === undefined).map(textOf2).filter((each) => !each.startsWith("[SPLATES"));
+  const words = person.join(`
+
+`).trim();
+  return words === "" ? null : split(words);
+}
+function split(words) {
+  const [first = "", ...rest] = words.trim().split(`
+`);
+  return {
+    subject: first.trim(),
+    detail: rest.join(`
+`).trim().slice(-DETAIL_CHARS)
+  };
+}
+function askedBack(messages, said) {
+  const prompts = messages.flatMap((each, at) => each.role === "user" ? [at] : []);
+  const [first, answer] = prompts;
+  const reply = answer === undefined ? undefined : messages[answer];
+  if (first === undefined || reply === undefined || reply.told !== undefined || !said.includes(reply)) {
+    return false;
+  }
+  return messages.slice(first, answer).filter((each) => each.role === "agent").map(textOf2).join("").trim().endsWith("?");
+}
+
+// auto-pick/judged.ts
+async function decideFor({
+  subject,
+  detail,
+  attachments,
+  cached,
+  judge,
+  who,
+  context
+}) {
+  if (cached !== null) {
+    return {
+      decision: decide({ ...context, classification: cached }),
+      classification: cached,
+      judged: true
+    };
+  }
+  const asked = await judge(who ?? {});
+  const classified = await classify({
+    subject,
+    detail,
+    attachments,
+    judge: asked
+  });
+  return classified.ok ? {
+    decision: decide({
+      ...context,
+      classification: classified.classification
+    }),
+    classification: classified.classification,
+    judged: true
+  } : {
+    decision: decideWithout({ ...context, reason: classified.reason }),
+    classification: null,
+    judged: asked !== null
+  };
+}
+function cachedFor(record, key) {
+  const kept = record.autoPick?.classified;
+  return kept?.key === key ? kept.classification : null;
+}
+function autoPicked({ decision, classification }, key, at) {
+  return {
+    ...decision,
+    at: at.toISOString(),
+    ...classification === null ? {} : { classified: { key, classification } }
+  };
+}
+
+// auto-pick/rank.ts
+function higher(agents, from, to) {
+  if (to.agent !== from.agent) {
+    return false;
+  }
+  if ((to.model ?? null) !== from.model) {
+    const was = traitsOf2(agents, pickOf(from))?.tier;
+    const now = traitsOf2(agents, to)?.tier;
+    return was !== undefined && now !== undefined && now > was;
+  }
+  return rank(from.effort) < rank(to.effort ?? null);
+}
+var EFFORTS = ["minimal", "low", "medium", "high", "xhigh", "max"];
+function rank(effort) {
+  return effort === null ? -1 : EFFORTS.indexOf(effort.toLowerCase());
+}
+function pickOf(set) {
+  return {
+    agent: set.agent,
+    ...set.model === null ? {} : { model: set.model },
+    ...set.effort === null ? {} : { effort: set.effort }
+  };
+}
+
+// auto-pick/store.ts
+class AutoPickStore {
+  path;
+  deps;
+  constructor(path, deps) {
+    this.path = path;
+    this.deps = deps;
+  }
+  async rules() {
+    const raw = await this.deps.fs.read(this.path).catch(() => null);
+    if (raw === null) {
+      return DEFAULT_RULES;
+    }
+    let json;
+    try {
+      json = JSON.parse(raw);
+    } catch {
+      fail2("usage", `${this.path} is not JSON: fix or delete it`, {
+        path: this.path
+      });
+    }
+    const format = json?.format;
+    if (typeof format === "number" && format > RULES_FORMAT) {
+      fail2("outdated", [
+        `${this.path} is in format ${format}, written by a newer splates; this one understands up to ${RULES_FORMAT}, so it leaves it alone.`,
+        "Run `bunx @stringsync/splates@latest` instead."
+      ].join(`
+`), { path: this.path, format, understood: RULES_FORMAT });
+    }
+    const checked = checkRules(json);
+    if (!checked.ok) {
+      fail2("usage", `${this.path} is not Auto pick rules: ${checked.problem}. Fix it, or delete it for the defaults`, { path: this.path });
+    }
+    return checked.rules;
+  }
+  async save(rules) {
+    const checked = checkRules(rules);
+    if (!checked.ok) {
+      fail2("usage", `not Auto pick rules: ${checked.problem}`, {
+        path: this.path
+      });
+    }
+    await this.write(checked.rules);
+  }
+  async reset() {
+    await this.write(DEFAULT_RULES);
+    return DEFAULT_RULES;
+  }
+  async remove() {
+    await this.deps.fs.rm(this.path, { force: true });
+  }
+  async write(rules) {
+    await this.deps.fs.mkdir(this.path.slice(0, this.path.lastIndexOf("/")), {
+      recursive: true
+    });
+    const tmp = `${this.path}.${crypto.randomUUID()}.tmp`;
+    await this.deps.fs.write(tmp, `${JSON.stringify(rules, null, "\t")}
+`);
+    await this.deps.fs.rename(tmp, this.path);
+  }
+}
+
+// auto-pick/start.ts
+var JUDGE_KEY = JUDGE_CREDS.jev[0];
+var PURPOSE = "Auto pick asks TypeSafe's Jev what kind of work a task is and how deeply it needs to reason, to start it on the agent, model and thinking level your Auto pick rules give that; without a key every Auto pick takes the rule for any kind and depth.";
+var INSTRUCTIONS = `1. Open [TypeSafe](https://typesafe.ai) and sign in.
+2. Create an API key.
+3. Paste it here.`;
+async function startAutoPick({
+  project,
+  conversations,
+  target,
+  start,
+  slug = async () => null,
+  judge = (who) => projectJudge(project, slug, who),
+  now = () => new Date
+}) {
+  const record = "words" in target ? null : await recordOf(project, target);
+  const { subject, detail } = record === null ? wordsOfMessage("words" in target ? target.words : "") : await wordsOf(project, record);
+  const attachments = "words" in target ? target.attachments ?? [] : (record?.files ?? []).map((name) => ({
+    name,
+    mimeType: Bun.file(name).type
+  }));
+  const key = classificationKey(subject, detail, attachments);
+  const context = await contextOf(project, conversations, now(), attachments);
+  const { offered } = context;
+  const cached = record === null ? null : cachedFor(record, key);
+  const fallback = cached === null ? decideWithout({ ...context, reason: "the judge has yet to answer" }) : decide({ ...context, classification: cached });
+  const deciding = decideFor({
+    subject,
+    detail,
+    attachments,
+    cached,
+    judge,
+    who: "words" in target ? {} : { task: "task" in target ? target.task : `#${target.todo}` },
+    context
+  });
+  const opened = ({ pick }) => ({
+    agent: pick.agent,
+    ...pick.model === undefined ? {} : { model: pick.model },
+    settings: pickSettings2(pick.effort, offered[pick.agent] ?? [])
+  });
+  const starting = opened(fallback);
+  const conversation = start(starting.agent, {
+    ...starting,
+    picking: deciding.then(async (judged) => {
+      const picked = autoPicked(judged, key, now());
+      await (record === null ? announce(project, conversation, picked, judged.judged) : settle(project, record.id, picked, {
+        conversation,
+        judged: judged.judged
+      }));
+      return opened(judged.decision);
+    }, (error) => {
+      project.log.error(`Auto pick could not decide: ${String(error)}`);
+      return starting;
+    })
+  });
+  return conversation;
+}
+async function contextOf(project, conversations, now, attachments = []) {
+  const home = splatesHome2(project.ps);
+  const images = attachments.some((each) => each.mimeType.startsWith("image/"));
+  return {
+    images,
+    catalog: images ? await new Prices(new FsStorage2(home, project.fs)).catalog() : null,
+    sights: await conversations.sights(),
+    rules: await new AutoPickStore(`${home}/auto-pick.json`, {
+      fs: project.fs
+    }).rules(),
+    agents: await Roster2.in(new FsStorage2(home, project.fs)).agents(),
+    runnable: conversations.agents.map((each) => each.id),
+    limits: await conversations.limits(),
+    offered: await conversations.settings(),
+    now
+  };
+}
+async function recordOf(project, target) {
+  const { store } = project.tasks;
+  const record = "todo" in target ? await store.read(target.todo) : await store.find(target.task);
+  if (record === null) {
+    const named = "todo" in target ? `#${target.todo}` : `'${target.task}'`;
+    fail2("not_found", `no task ${named}: run \`splates task list\` to see what there is`, target);
+  }
+  return record;
+}
+async function wordsOf(project, record) {
+  if (record.text !== "" || record.task === undefined) {
+    return { subject: record.subject, detail: record.text };
+  }
+  const worktree = await project.service.find(record.task);
+  const plan = worktree.exists ? await new Plans2(project.fs).read(worktree.path) : null;
+  return { subject: record.subject, detail: goalOf2(plan ?? "") };
+}
+function wordsOfMessage(message) {
+  const [first = "", ...rest] = message.trim().split(`
+`);
+  return { subject: first.trim(), detail: rest.join(`
+`).trim() };
+}
+async function settle(project, id, picked, {
+  conversation,
+  judged
+}) {
+  await keep(project, id, picked).catch((error) => project.log.error(`Auto pick could not keep its decision on task ${id}: ${String(error)}`));
+  if (conversation !== null) {
+    await announce(project, conversation, picked, judged);
+  }
+}
+async function announce(project, conversation, picked, judged) {
+  await conversation.then((started) => logPick(project, started, picked, judged ? null : JUDGE_KEY)).catch((error) => project.log.error(String(error)));
+}
+async function keep(project, id, picked) {
+  const { store } = project.tasks;
+  await store.locked(async () => {
+    const record = await store.read(id);
+    if (record !== null) {
+      await store.write({ ...record, autoPick: picked });
+    }
+  });
+}
+async function logPick(project, conversation, picked, asking) {
+  conversation.autoPicked(setOf(picked));
+  const journal = project.journal.in(conversation.id);
+  await journalPick(journal, conversation.state.task, picked);
+  if (asking !== null) {
+    await offerJudge(project, journal, conversation.state.task, asking);
+  }
+}
+function setOf({
+  pick,
+  rule,
+  kind,
+  depth,
+  clarity
+}) {
+  return {
+    rule,
+    kind,
+    depth,
+    ...clarity === undefined ? {} : { clarity },
+    agent: pick.agent,
+    model: pick.model ?? null,
+    effort: pick.effort ?? null
+  };
+}
+async function journalPick(journal, task, picked, lifted) {
+  const classification = picked.classified?.classification;
+  await journal.record("auto", task, async () => {}, {
+    agent: picked.pick.agent,
+    model: picked.pick.model ?? null,
+    effort: picked.pick.effort ?? null,
+    reasons: picked.reasons,
+    signs: classification === undefined ? null : [
+      likeliest2(KINDS, classification.kinds),
+      likeliest2(DEPTHS, classification.depth)
+    ],
+    lifted: lifted ?? null
+  });
+}
+function likeliest2(classes, answers) {
+  const best = classes.reduce((most, each) => answers[each.id] > answers[most.id] ? each : most);
+  return `${best.label} ${Math.round(answers[best.id] * 100)}%`;
+}
+async function offerJudge(project, journal, task, name) {
+  const asked = (await project.creds.requests()).some((each) => each.name === name);
+  if (asked) {
+    return;
+  }
+  await journal.record("creds request", task, () => project.creds.request(name, {
+    scope: "device",
+    purpose: PURPOSE,
+    instructions: INSTRUCTIONS,
+    task
+  }), (request) => ({ name, asked: request !== null }));
+}
+
+// auto-pick/lift.ts
+function lifting(project, conversations, {
+  slug = async () => null,
+  judge = (who) => projectJudge(project, slug, who),
+  now = () => new Date
+} = {}) {
+  return async (conversation, said) => {
+    const { state } = conversation;
+    const on = state.autoPick;
+    if (on === null || on.overridden || on.agent !== state.agent) {
+      return;
+    }
+    if (on.rejudge) {
+      await rejudging(conversation, {
+        project,
+        conversations,
+        judge,
+        now: now()
+      });
+      return;
+    }
+    const words = wordsToJudge(state.messages);
+    const asked = askedBack(state.messages, said);
+    if (words === null && !asked) {
+      return;
+    }
+    const context = await contextOf(project, conversations, now());
+    const judged = await rejudged(words, context, judge, {
+      task: state.task,
+      conversation: state.id
+    });
+    const decision = judged !== null && higher(context.agents, on, judged.decision.pick) ? judged.decision : asked ? decideDeeper(context, on, ASKED_BACK) : null;
+    const agent = context.agents.find((each) => each.id === on.agent);
+    if (decision === null || agent === undefined || !higher(context.agents, on, decision.pick)) {
+      return;
+    }
+    const settings = settingsFor(state.settings, decision.pick);
+    if (Object.keys(settings).length === 0) {
+      return;
+    }
+    const undo = Object.fromEntries(Object.keys(settings).flatMap((id) => {
+      const current = state.settings.find((each) => each.id === id)?.current;
+      return current === undefined ? [] : [[id, current]];
+    }));
+    await conversation.lift(settings, setOf(decision));
+    await journalPick(project.journal.in(state.id), state.task, autoPicked({
+      decision,
+      classification: decision === judged?.decision ? judged.classification : null,
+      judged: true
+    }, judged?.key ?? "", now()), { from: headline(pickOf(on), agent), undo }).catch((error) => project.log.error(String(error)));
+  };
+}
+async function rejudging(conversation, {
+  project,
+  conversations,
+  judge,
+  now
+}) {
+  const { state } = conversation;
+  const words = wordsSoFar(state.messages);
+  const context = await contextOf(project, conversations, now);
+  const judged = await rejudged(words, { ...context, runnable: [state.agent] }, judge, { task: state.task, conversation: state.id });
+  if (judged === null || judged.decision.pick.agent !== state.agent) {
+    return;
+  }
+  const { decision } = judged;
+  const settings = settingsFor(state.settings, decision.pick);
+  const undo = Object.fromEntries(Object.keys(settings).flatMap((id) => {
+    const current = state.settings.find((each) => each.id === id)?.current;
+    return current === undefined ? [] : [[id, current]];
+  }));
+  const from = heldOn(state.settings);
+  await conversation.lift(settings, setOf(decision));
+  await journalPick(project.journal.in(state.id), state.task, autoPicked({ decision, classification: judged.classification, judged: true }, judged.key, now), Object.keys(settings).length === 0 ? undefined : { from, undo, switched: true }).catch((error) => project.log.error(String(error)));
+}
+function heldOn(settings) {
+  const named = (setting) => setting?.options.find((each) => each.value === setting.current)?.name ?? setting?.current ?? null;
+  const model = named(settings.find((each) => each.category === "model" || each.id === "model"));
+  const effort = named(settings.find((each) => each.category === "thought_level"));
+  const said = model ?? "its default model";
+  return effort === null ? said : `${said}, ${effort.toLowerCase()} effort`;
+}
+var ASKED_BACK = "its first answer asked back";
+async function rejudged(words, context, judge, who) {
+  if (words === null) {
+    return null;
+  }
+  const classified = await classify({ ...words, judge: await judge(who) });
+  if (!classified.ok) {
+    return null;
+  }
+  return {
+    decision: decide({
+      ...context,
+      classification: classified.classification
+    }),
+    classification: classified.classification,
+    key: classificationKey(words.subject, words.detail, [])
+  };
+}
+function settingsFor(settings, pick) {
+  const model = pick.model === undefined ? null : modelOption2(settings, pick.model);
+  const effort = effortSettings2(pick.effort, settings);
+  const levels = thinkingOf2(settings).map((each) => each.value);
+  const wanted = {
+    ...model === null ? {} : { [model.setting]: model.value },
+    ...Object.fromEntries(Object.entries(effort).filter(([, value]) => levels.includes(value)))
+  };
+  return Object.fromEntries(Object.entries(wanted).filter(([id, value]) => settings.find((each) => each.id === id)?.current !== value));
+}
+// auto-pick/queue.ts
+class QueueAutoPick {
+  #project;
+  #conversations;
+  #judge;
+  #now;
+  #judging = new Map;
+  #tried = new Map;
+  constructor(project, conversations, {
+    slug = async () => null,
+    judge = (who) => projectJudge(project, slug, who),
+    now = () => new Date
+  } = {}) {
+    this.#project = project;
+    this.#conversations = conversations;
+    this.#judge = judge;
+    this.#now = now;
+  }
+  async ahead(queued) {
+    for (const each of queued) {
+      const { subject, detail } = await wordsOf(this.#project, each);
+      const attachments = each.files.map((name) => ({
+        name,
+        mimeType: Bun.file(name).type
+      }));
+      const key = classificationKey(subject, detail, attachments);
+      if (cachedFor(each, key) !== null || this.#tried.get(each.id) === key) {
+        continue;
+      }
+      this.#tried.set(each.id, key);
+      const run = (this.#judging.get(each.id) ?? Promise.resolve()).then(() => this.#judgeAhead(each.id, { subject, detail, attachments, key }));
+      this.#judging.set(each.id, run);
+      run.finally(() => {
+        if (this.#judging.get(each.id) === run) {
+          this.#judging.delete(each.id);
+        }
+      });
+    }
+  }
+  judging(id) {
+    return this.#judging.has(id);
+  }
+  async settled() {
+    while (this.#judging.size > 0) {
+      await Promise.all(this.#judging.values());
+    }
+  }
+  async guess(queued) {
+    const guessed = new Map;
+    for (const each of queued) {
+      const { subject, detail } = await wordsOf(this.#project, each);
+      const attachments = each.files.map((name) => ({
+        name,
+        mimeType: Bun.file(name).type
+      }));
+      const context = await this.#context(attachments);
+      const cached = cachedFor(each, classificationKey(subject, detail, attachments));
+      try {
+        const { pick } = cached === null ? decideWithout({ ...context, reason: "not judged yet" }) : decide({ ...context, classification: cached });
+        guessed.set(each.id, pick);
+      } catch {
+        guessed.set(each.id, firstOf(context));
+      }
+    }
+    return guessed;
+  }
+  async decide(queued) {
+    const judging = this.#judging.get(queued.id);
+    if (judging !== undefined) {
+      await judging;
+      queued = await this.#project.tasks.store.read(queued.id) ?? queued;
+    }
+    const { subject, detail } = await wordsOf(this.#project, queued);
+    const attachments = queued.files.map((name) => ({
+      name,
+      mimeType: Bun.file(name).type
+    }));
+    const context = await this.#context(attachments);
+    const key = classificationKey(subject, detail, attachments);
+    try {
+      const judged = await decideFor({
+        subject,
+        detail,
+        attachments,
+        cached: cachedFor(queued, key),
+        judge: this.#judge,
+        who: { task: `#${queued.id}` },
+        context
+      });
+      const picked = autoPicked(judged, key, this.#now());
+      await settle(this.#project, queued.id, picked, {
+        conversation: null,
+        judged: judged.judged
+      });
+      return {
+        pick: judged.decision.pick,
+        tell: (id) => announce(this.#project, this.#conversations.find(id), picked, judged.judged)
+      };
+    } catch (error) {
+      this.#project.log.error(`Auto pick could not decide for task ${queued.id}: ${String(error)}`);
+      return { pick: firstOf(context), tell: async () => {} };
+    }
+  }
+  async#judgeAhead(id, {
+    subject,
+    detail,
+    attachments,
+    key
+  }) {
+    if (this.#tried.get(id) !== key) {
+      return;
+    }
+    try {
+      const judged = await decideFor({
+        subject,
+        detail,
+        attachments,
+        cached: null,
+        judge: this.#judge,
+        who: { task: `#${id}` },
+        context: await this.#context(attachments)
+      });
+      await settle(this.#project, id, autoPicked(judged, key, this.#now()), {
+        conversation: null,
+        judged: judged.judged
+      });
+    } catch (error) {
+      this.#project.log.error(`Auto pick could not judge task ${id} ahead: ${String(error)}`);
+    }
+  }
+  async#context(attachments) {
+    return contextOf(this.#project, this.#conversations, this.#now(), attachments);
+  }
+}
+function firstOf(context) {
+  return { agent: context.agents[0]?.id ?? "claude" };
+}
+// auto-pick/trial.ts
+async function tryAutoPick({
+  project,
+  conversations,
+  target,
+  slug = async () => null,
+  judge = (who) => projectJudge(project, slug, who),
+  now = () => new Date
+}) {
+  const record = await recordOf(project, target);
+  const { subject, detail } = await wordsOf(project, record);
+  const attachments = record.files.map((name) => ({
+    name,
+    mimeType: Bun.file(name).type
+  }));
+  const context = await contextOf(project, conversations, now(), attachments);
+  const kept = record.autoPick?.classified;
+  if (kept?.key === classificationKey(subject, detail, attachments)) {
+    return {
+      subject,
+      decision: decide({ ...context, classification: kept.classification }),
+      classification: kept.classification,
+      cached: true
+    };
+  }
+  const classified = await classify({
+    subject,
+    detail,
+    attachments,
+    judge: await judge({
+      task: "task" in target ? target.task : `#${target.todo}`
+    })
+  });
+  return classified.ok ? {
+    subject,
+    decision: decide({
+      ...context,
+      classification: classified.classification
+    }),
+    classification: classified.classification,
+    cached: false
+  } : {
+    subject,
+    decision: decideWithout({ ...context, reason: classified.reason }),
+    classification: null,
+    cached: false
+  };
+}
+
+// auto-pick/routes.ts
+class AutoPickRoutes {
+  #project;
+  #conversations;
+  #watch;
+  #slug;
+  constructor(project, conversations, watch, slug = async () => null) {
+    this.#slug = slug;
+    this.#project = project;
+    this.#conversations = conversations;
+    this.#watch = watch;
+  }
+  startAutoPick = async (request) => {
+    const conversations = this.#conversations;
+    if (conversations === null) {
+      fail2("not_found", "conversations are off", {});
+    }
+    const { id, task, todo, words, attachments, ship } = await body(request);
+    const target = typeof words === "string" ? { words, attachments: attachmentInfos(attachments) } : targetOf(task, todo);
+    const [named, cwd, base, caller] = await treeOf2(this.#project.service, "words" in target ? task : ("task" in target) ? target.task : null);
+    const conversation = await startAutoPick({
+      project: this.#project,
+      slug: this.#slug,
+      conversations,
+      target,
+      start: (agent, { model, settings, picking }) => conversations.start(agent, {
+        id: typeof id === "string" ? id : undefined,
+        task: named,
+        base,
+        caller,
+        cwd,
+        model,
+        settings,
+        assigned: true,
+        ...typeof ship === "string" ? { ship } : {},
+        picking: picking.finally(() => this.#watch.changed())
+      })
+    });
+    return Response.json(conversation.state);
+  };
+  tryAutoPick = async (request) => {
+    const conversations = this.#conversations;
+    if (conversations === null) {
+      fail2("not_found", "conversations are off", {});
+    }
+    const { task, todo } = await body(request);
+    return Response.json(await tryAutoPick({
+      project: this.#project,
+      slug: this.#slug,
+      conversations,
+      target: targetOf(task, todo)
+    }));
+  };
+}
+function targetOf(task, todo) {
+  if (typeof task === "string" && task !== "") {
+    return { task };
+  }
+  if (typeof todo === "number" && Number.isInteger(todo) && todo > 0) {
+    return { todo };
+  }
+  fail2("usage", "name a task, by `task` or by `todo` number, to Auto pick", {});
+}
+function attachmentInfos(value) {
+  if (value === undefined) {
+    return [];
+  }
+  if (!Array.isArray(value) || value.some((file) => file === null || typeof file !== "object" || typeof file.name !== "string" || typeof file.mimeType !== "string")) {
+    fail2("usage", "attachments must give each file's name and mimeType", {});
+  }
+  return value.map((file) => ({ name: file.name, mimeType: file.mimeType }));
+}
+// auto-pick/rules-routes.ts
+class AutoPickRulesRoutes {
+  #fs;
+  #home;
+  constructor({ fs, home }) {
+    this.#fs = fs;
+    this.#home = home;
+  }
+  read = async () => Response.json(await this.#view());
+  save = async (request) => {
+    const { rules } = await body(request);
+    await this.#store.save(rules);
+    return Response.json(await this.#view());
+  };
+  reset = async () => {
+    await this.#store.reset();
+    return Response.json(await this.#view());
+  };
+  get #store() {
+    return new AutoPickStore(`${this.#home}/auto-pick.json`, { fs: this.#fs });
+  }
+  async#view() {
+    let rules = DEFAULT_RULES;
+    let problem = null;
+    try {
+      rules = await this.#store.rules();
+    } catch (error) {
+      if (!(error instanceof Exit2)) {
+        throw error;
+      }
+      problem = error.message;
+    }
+    return {
+      rules,
+      problem,
+      agents: await pickableAgents(this.#fs, this.#home)
+    };
+  }
+}
+async function pickableAgents(fs, home) {
+  const machine = new FsStorage2(home, fs);
+  const offered = await new Offered2(machine.document("offered.json")).all();
+  const roster = await Roster2.in(machine).agents();
+  return roster.map((agent) => ({
+    id: agent.id,
+    name: agent.name,
+    models: agent.models.map(({ id, name }) => ({ id, name })),
+    efforts: offered[agent.id] === undefined ? null : effortsOf2(offered[agent.id] ?? [])
+  }));
+}
+export { JUDGE_CREDS, judgeFrom, AutoPickStore, lifting, QueueAutoPick, AutoPickRoutes, AutoPickRulesRoutes, pickableAgents };