@tablation/crew 0.28.0 → 0.29.0

package/dist/cli.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { resolve as resolve4, dirname as dirname11, join as join20, basename as basename8 } from "path";
+import { resolve as resolve4, dirname as dirname11, join as join20, basename as basename9 } from "path";
 import { fileURLToPath } from "url";
 import { hostname as hostname2, homedir as homedir5 } from "os";
 import { spawnSync as spawnSync3 } from "child_process";
 
 // src/config.ts
 import { readFileSync as readFileSync4, existsSync as existsSync3 } from "fs";
-import { resolve, dirname as dirname2, isAbsolute, join as join4, basename as basename2 } from "path";
+import { resolve, dirname as dirname2, isAbsolute, join as join4, basename as basename3 } from "path";
 import { homedir as homedir2, tmpdir } from "os";
 import { parse as parse2 } from "yaml";
 
@@ -157,6 +157,9 @@ var Emitter = class _Emitter {
 };
 var eventFileFor = (stateDir) => join(stateDir, "events.jsonl");
 
+// src/toolchain.ts
+import { basename } from "path";
+
 // src/stream.ts
 function toolTarget(name, input) {
   if (!input) return void 0;
@@ -312,12 +315,22 @@ function allowedTools(role) {
 var claudeAdapter = {
   harness: "claude",
   displayName: "Claude Code",
+  vendor: "anthropic",
+  ownsModel: (model) => model.startsWith("claude-"),
+  // The tier's reasoning is the extended-thinking budget; it supersedes the
+  // toolchain's `maxThinkingTokens` (0 disables). A non-numeric value is ignored.
+  applyReasoning(spec, reasoning) {
+    const n = Number(reasoning);
+    return Number.isInteger(n) && n >= 0 ? { ...spec, maxThinkingTokens: n } : spec;
+  },
   defaultBin: "claude",
   defaultModel: "claude-sonnet-5",
   defaultTiers: {
-    light: { model: "claude-haiku-4-5-20251001" },
+    // `standard` carries no reasoning: it defers to the toolchain's own
+    // `maxThinkingTokens`, which is what a persona with no tier gets today.
+    light: { model: "claude-haiku-4-5-20251001", reasoning: "2048" },
     standard: { model: "claude-sonnet-5-5" },
-    deep: { model: "claude-opus-5-5" }
+    deep: { model: "claude-opus-5-5", reasoning: "16384" }
   },
   limitations: [
     "Bash is not sandboxed: the deny list refuses known destructive patterns, but a one-liner reaching the same end another way is not caught",
@@ -411,6 +424,52 @@ function resolveToolchain(ship, route) {
   if (!found) throw new Error(`toolchain "${name}" is not defined (have: ${shipToolchains(ship).map((t) => t.name).join(", ")})`);
   return found;
 }
+function toolchainVendor(spec) {
+  if (spec.launcher && basename(spec.launcher) === "ori") return "openrouter";
+  return adapterFor(spec.harness).vendor;
+}
+function resolveSeat(ship, route, role, persona = {}) {
+  const warnings = [];
+  const base = resolveToolchain(ship, route);
+  const baseVendor = toolchainVendor(base);
+  const baseWhy = route?.toolchain ? `route toolchain ${base.name}` : ship.toolchain ? `ship default ${base.name}` : `default ${base.name}`;
+  let chosen = base;
+  let toolchainWhy = baseWhy;
+  if (persona.vendor && persona.vendor !== baseVendor) {
+    const match = shipToolchains(ship).find((t) => toolchainVendor(t) === persona.vendor);
+    if (match) {
+      chosen = match;
+      toolchainWhy = `persona vendor ${persona.vendor} \u2192 ${match.name}`;
+    } else {
+      warnings.push(`seat ${role}: persona vendor "${persona.vendor}" has no toolchain on this ship; running ${base.name} (${baseVendor}) instead`);
+      toolchainWhy = `${baseWhy} (persona vendor ${persona.vendor} has no toolchain)`;
+    }
+  } else if (persona.vendor) {
+    toolchainWhy = `${baseWhy} (serves persona vendor ${persona.vendor})`;
+  }
+  const vendor = toolchainVendor(chosen);
+  const adapter = adapterFor(chosen.harness);
+  let model = chosen.model;
+  let modelWhy = `toolchain ${chosen.name} model`;
+  let reasoning = chosen.tiers.standard?.reasoning;
+  const explicit = persona.model;
+  const explicitOk = explicit !== void 0 && (vendor === "openrouter" || adapter.ownsModel(explicit));
+  if (explicit !== void 0 && !explicitOk) {
+    warnings.push(`seat ${role}: persona model "${explicit}" does not belong to vendor "${vendor}" (toolchain ${chosen.name}); ignored`);
+  }
+  if (explicit !== void 0 && explicitOk) {
+    model = explicit;
+    modelWhy = "persona model";
+    reasoning = void 0;
+  } else if (persona.tier && persona.tier !== "standard" && chosen.tiers[persona.tier]) {
+    const t = chosen.tiers[persona.tier];
+    model = t.model;
+    reasoning = t.reasoning;
+    modelWhy = `persona tier ${persona.tier} via ${chosen.name}`;
+  }
+  const toolchain = reasoning !== void 0 && adapter.applyReasoning ? adapter.applyReasoning(chosen, reasoning) : chosen;
+  return { toolchain, model, toolchainWhy, modelWhy, warnings };
+}
 
 // src/config.ts
 import { getSessionStore, hostFromUrl } from "@tablation/client";
@@ -453,7 +512,7 @@ function explain(ship, required) {
 
 // src/repo-config.ts
 import { readFileSync as readFileSync3, existsSync as existsSync2 } from "fs";
-import { join as join3, basename } from "path";
+import { join as join3, basename as basename2 } from "path";
 import { parse } from "yaml";
 var SPEC_VERSION = 1;
 var REPO_CONFIG_FILENAMES = [".crew.yaml", ".crew.yml", ".crew.json"];
@@ -792,7 +851,7 @@ function renderWorktreeName(template, ctx) {
   return renderBranchName(template.replace(/\{dir\}/g, ctx.dir).replace(/\{issue\}/g, issue), ctx);
 }
 function defaultWorktreePrefix(dir) {
-  const name = basename(dir.replace(/[/\\]+$/, ""));
+  const name = basename2(dir.replace(/[/\\]+$/, ""));
   return name ? `${name}-issue-` : "issue-";
 }
 var DEFAULTS = {
@@ -966,7 +1025,7 @@ function effectiveBranchTemplate(cfg, prefix) {
 function effectiveWorktreeDirName(cfg, dir, branchName, number, renderName) {
   if (cfg.worktrees.name && renderName) return renderName(cfg.worktrees.name);
   if (cfg.provenance["worktrees.prefix"] !== "default") return `${cfg.worktrees.prefix}${number}`;
-  return `${basename(dir.replace(/[/\\]+$/, ""))}-${branchName}`;
+  return `${basename2(dir.replace(/[/\\]+$/, ""))}-${branchName}`;
 }
 function validateEffective(cfg) {
   const problems = [];
@@ -1571,7 +1630,7 @@ function dirForRepo(r, repoId) {
 }
 function repoTargetFor(r, repoId) {
   const names = r.resolved?.repoNames;
-  if (!repoId || !names) return Object.keys(r.repos).length ? null : { name: basename2(r.dir), dir: r.dir };
+  if (!repoId || !names) return Object.keys(r.repos).length ? null : { name: basename3(r.dir), dir: r.dir };
   const name = names[repoId];
   if (!name) return null;
   return reposOf(r).find((t) => t.name === name) ?? null;
@@ -1654,7 +1713,7 @@ function reposOf(r) {
   const named = Object.entries(r.repos);
   if (named.length > 0) return named.map(([name, dir]) => ({ name, dir }));
   const trackerNames = r.resolved?.repoNames ? Object.values(r.resolved.repoNames) : [];
-  if (trackerNames.length <= 1) return [{ name: basename2(r.dir), dir: r.dir }];
+  if (trackerNames.length <= 1) return [{ name: basename3(r.dir), dir: r.dir }];
   const remotes = r.resolved?.repoRemotes ?? {};
   const remoteByName = {};
   for (const [id, name] of Object.entries(r.resolved.repoNames)) {
@@ -3040,7 +3099,7 @@ import {
   statSync as statSync4,
   unlinkSync as unlinkSync2
 } from "fs";
-import { dirname as dirname4, basename as basename3 } from "path";
+import { dirname as dirname4, basename as basename4 } from "path";
 var GitError = class extends Error {
 };
 function gitRaw(cwd, args) {
@@ -3136,7 +3195,7 @@ function deleteRemoteBranch(cwd, remote, branch) {
 }
 function worktreeForNumber(cwd, num) {
   const re = new RegExp(`(?:^|-)${num}$`);
-  return worktrees(cwd).find((w) => re.test(basename3(w.path))) ?? null;
+  return worktrees(cwd).find((w) => re.test(basename4(w.path))) ?? null;
 }
 var commitBodies = (cwd, range) => gitOk(cwd, ["log", range, "--format=%B"]) ?? "";
 var resolve2 = (cwd, ref) => gitOk(cwd, ["rev-parse", "-q", "--verify", `${ref}^{commit}`]);
@@ -5090,7 +5149,7 @@ ${waiting.map((t) => `| ${displayKey2(t)} | ${t.status} | ${blockers(t, i)} |`).
 }
 
 // src/ticket-branch.ts
-import { basename as basename4 } from "path";
+import { basename as basename5 } from "path";
 function branchRenderer(t, role) {
   const { tag, prefix } = ticketBranchContext(t);
   return (template) => renderBranchName(template, { key: t.issue_id, title: t.title ?? void 0, role, tag, prefix });
@@ -5101,7 +5160,7 @@ function worktreeForTicket(dir, cfg, t, role) {
   const number = t.issue_id.replace(/^\D+/, "");
   const { tag } = ticketBranchContext(t);
   return effectiveWorktreeDirName(cfg, dir, branchName, number, (template) => renderWorktreeName(template, {
-    dir: basename4(dir.replace(/[/\\]+$/, "")),
+    dir: basename5(dir.replace(/[/\\]+$/, "")),
     key: t.issue_id,
     title: t.title ?? void 0,
     role,
@@ -5790,7 +5849,7 @@ import { join as join8, dirname as dirname5 } from "path";
 import { createHash as createHash2 } from "crypto";
 
 // src/environment.ts
-import { basename as basename5 } from "path";
+import { basename as basename6 } from "path";
 var API_KEY_VAR = "CREW_API_KEY";
 function authorshipBullets(a, contract) {
   if (!a) return [];
@@ -5841,7 +5900,7 @@ function repoSection(r, key, heading) {
   const repo = r.config;
   const branchTemplate = effectiveBranchTemplate(repo, repoPrefix(repo));
   const branchName = branchExample(repo, key);
-  const checkoutName = basename5(r.dir.replace(/[/\\]+$/, ""));
+  const checkoutName = basename6(r.dir.replace(/[/\\]+$/, ""));
   const worktreeName = effectiveWorktreeDirName(
     repo,
     r.dir,
@@ -6198,9 +6257,9 @@ function planAgentRun(o) {
   const promptSha = createHash2("sha256").update(`${effectiveCommon}${effectiveBrief}`).digest("hex");
   const streamsDir = join8(o.stateDir, "streams");
   const base = `${routeLabel}-${o.role}-${o.cycle}`;
-  const toolchain = resolveToolchain(o.ship, o.route);
+  const seat = resolveSeat(o.ship, o.route, o.role, o.agentPersona ?? (o.agentModel ? { model: o.agentModel } : {}));
+  const { toolchain, model } = seat;
   const adapter = adapterFor(toolchain.harness);
-  const model = o.agentModel ?? toolchain.model;
   const invocation = adapter.invocation(toolchain, {
     role: o.role,
     model,
@@ -6229,6 +6288,8 @@ function planAgentRun(o) {
     args: invocation.args,
     toolchain: toolchain.name,
     harness: toolchain.harness,
+    resolution: { toolchain: seat.toolchainWhy, model: seat.modelWhy },
+    warnings: seat.warnings,
     prompt,
     promptBytes: Buffer.byteLength(prompt, "utf8"),
     unsetEnv: adapter.unsetEnv,
@@ -6259,6 +6320,8 @@ function planAgentRun(o) {
 function describePlan(p) {
   return [
     `role:    ${p.role}`,
+    ...p.resolution ? [`resolved: toolchain ${p.toolchain} \u2190 ${p.resolution.toolchain}; model ${p.model} \u2190 ${p.resolution.model}`] : [],
+    ...(p.warnings ?? []).map((w) => `warning: ${w}`),
     // Only for a non-default toolchain, so a plain Claude run's output is unchanged.
     ...p.toolchain && p.toolchain !== "claude" ? [`toolchain: ${p.toolchain} (${p.harness ?? "claude"})`] : [],
     `cwd:     ${p.cwd}`,
@@ -6289,6 +6352,7 @@ function spawnAgent(plan, emit) {
   const adapter = adapterFor(plan.harness ?? LEGACY_TOOLCHAIN_HARNESS);
   const started = Date.now();
   const startedAt = new Date(started).toISOString();
+  for (const w of plan.warnings ?? []) emit.warn(w, { step: "agent", role: plan.role });
   const rawSink = openSink(plan.streamPath);
   const eventsSink = openSink(plan.eventsPath);
   return new Promise((resolve5, reject) => {
@@ -8577,7 +8641,11 @@ async function fetchLastSyncedPrompt(route, agentsModelId, recordId, historyId,
     return void 0;
   }
 }
-async function fetchSeatAgentModel(route, role, opts) {
+function choiceValue(v) {
+  const raw = typeof v === "string" ? v : v && typeof v === "object" ? v.value ?? v.key : void 0;
+  return typeof raw === "string" && raw.trim() ? raw.trim().toLowerCase() : void 0;
+}
+async function fetchSeatPersona(route, role, opts) {
   const agentId = await resolveAgentId(route, role, opts);
   if (!agentId || !route.resolved) return void 0;
   const client2 = new TablationClient2({
@@ -8588,7 +8656,14 @@ async function fetchSeatAgentModel(route, role, opts) {
   try {
     const agentsModel = await client2.dataModels.get("agents", route.resolved.workspaceId);
     const row = await client2.records.get(agentsModel.id, agentId);
-    return row.model ?? void 0;
+    const tier = choiceValue(row.tier);
+    const vendor = choiceValue(row.vendor);
+    const persona = {
+      ...row.model ? { model: row.model } : {},
+      ...tier && TIERS.includes(tier) ? { tier } : {},
+      ...vendor ? { vendor } : {}
+    };
+    return Object.keys(persona).length > 0 ? persona : void 0;
   } catch {
     return void 0;
   }
@@ -9392,7 +9467,7 @@ async function showLogEntry(route, entryId, opts = {}) {
 
 // src/repos-cmd.ts
 import { homedir as homedir4 } from "os";
-import { basename as basename6, resolve as resolve3 } from "path";
+import { basename as basename7, resolve as resolve3 } from "path";
 import { isMap, isSeq, parseDocument, stringify as stringify2 } from "yaml";
 var ReposError = class extends Error {
 };
@@ -9464,7 +9539,7 @@ function configuredRepos(text, route, base) {
     });
   }
   const dir = m.get("dir");
-  return dir ? [{ name: basename6(String(dir)), dir: expandDir(String(dir), base) }] : [];
+  return dir ? [{ name: basename7(String(dir)), dir: expandDir(String(dir), base) }] : [];
 }
 function planRepoAdd(i) {
   const doc = parseDocument(i.text);
@@ -9476,7 +9551,7 @@ function planRepoAdd(i) {
     throw new ReposError(`${target} is already configured on route ${i.route}`);
   }
   const matched = matchRepoName(i.origin, i.resolved);
-  const name = matched ?? i.name ?? normalizeRemote(i.origin)?.split("/").pop() ?? basename6(target);
+  const name = matched ?? i.name ?? normalizeRemote(i.origin)?.split("/").pop() ?? basename7(target);
   let warning;
   if (!matched) {
     const known = Object.values(i.resolved?.repoNames ?? {});
@@ -9574,14 +9649,14 @@ function schedulerInstalled(plan, exists, crontab) {
 
 // src/worktree-sweep.ts
 import { existsSync as existsSync15 } from "fs";
-import { basename as basename7 } from "path";
+import { basename as basename8 } from "path";
 function planWorktreeSweep(target, tickets, contract) {
   const terminal = new Set(contract.statuses.resolved.filter((s) => s !== contract.statuses.verified));
   const verified = contract.statuses.verified;
   const byNumber = new Map(tickets.map((t) => [t.issue_id.replace(/^\D+/, ""), t]));
   const actions = [];
   for (const w of worktrees(target.dir)) {
-    const m = /(?:^|-)(\d+)$/.exec(basename7(w.path));
+    const m = /(?:^|-)(\d+)$/.exec(basename8(w.path));
     if (!m) continue;
     const ticket = byNumber.get(m[1]);
     if (!ticket) continue;
@@ -10746,7 +10821,7 @@ async function runRoleAgent(role, decision, ctx) {
     cycle: emit.cycle,
     ticket: ticketHint,
     divergedPrompt: await fetchDivergedPrompt(route, role, { userAgent: ship.userAgent }),
-    agentModel: await fetchSeatAgentModel(route, role, { userAgent: ship.userAgent }),
+    agentPersona: await fetchSeatPersona(route, role, { userAgent: ship.userAgent }),
     resolvedAgentId: await resolveAgentId(route, role, { userAgent: ship.userAgent })
   });
   emit.enter("agent", role);
@@ -11832,7 +11907,7 @@ ${changed2.map((c) => `  - ${c}
             cycle: wemit.cycle,
             ticket: w.decision.actionable.top?.issue_id,
             divergedPrompt: await fetchDivergedPrompt(w.route, w.role, { userAgent: cfg.ship.userAgent }),
-            agentModel: await fetchSeatAgentModel(w.route, w.role, { userAgent: cfg.ship.userAgent }),
+            agentPersona: await fetchSeatPersona(w.route, w.role, { userAgent: cfg.ship.userAgent }),
             resolvedAgentId: await resolveAgentId(w.route, w.role, { userAgent: cfg.ship.userAgent })
           });
           process.stdout.write(`${describePlan(fleetPlan2)}
@@ -11925,7 +12000,7 @@ ${changed2.map((c) => `  - ${c}
           cycle: wemit.cycle,
           ticket: fleetTicketHint,
           divergedPrompt: await fetchDivergedPrompt(w.route, w.role, { userAgent: cfg.ship.userAgent }),
-          agentModel: await fetchSeatAgentModel(w.route, w.role, { userAgent: cfg.ship.userAgent }),
+          agentPersona: await fetchSeatPersona(w.route, w.role, { userAgent: cfg.ship.userAgent }),
           resolvedAgentId: await resolveAgentId(w.route, w.role, { userAgent: cfg.ship.userAgent })
         });
         wemit.enter("agent", w.role);
@@ -12130,7 +12205,7 @@ ${changed2.map((c) => `  - ${c}
           cycle: emit.cycle,
           ticket: ticketHint,
           divergedPrompt: await fetchDivergedPrompt(route, current, { userAgent: cfg.ship.userAgent }),
-          agentModel: await fetchSeatAgentModel(route, current, { userAgent: cfg.ship.userAgent }),
+          agentPersona: await fetchSeatPersona(route, current, { userAgent: cfg.ship.userAgent }),
           resolvedAgentId: await resolveAgentId(route, current, { userAgent: cfg.ship.userAgent })
         });
         if (dryRun) {
@@ -13534,7 +13609,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
               // `synthesis-tabl-123`. `worktreePrefix` above is kept for
               // config-provenance display; this is the field that actually
               // describes where a worktree lands by default.
-              worktreeDirPattern: r.config.worktrees.name ?? (r.config.provenance["worktrees.prefix"] !== "default" ? `${r.config.worktrees.prefix}<number>` : `${basename8(r.dir.replace(/[/\\]+$/, ""))}-<branch>`),
+              worktreeDirPattern: r.config.worktrees.name ?? (r.config.provenance["worktrees.prefix"] !== "default" ? `${r.config.worktrees.prefix}<number>` : `${basename9(r.dir.replace(/[/\\]+$/, ""))}-<branch>`),
               worktreeParent: resolvePath(r.dir, "..")
             })),
             waiting: waiting ? { ticket: waiting.ticket, since: waiting.since, streak: fairness.streak() } : null
@@ -13642,7 +13717,7 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
       );
       for (const r of await resolvedRepos(route)) {
         const { config } = r;
-        const worktreePattern = config.worktrees.name ?? (config.provenance["worktrees.prefix"] !== "default" ? `${config.worktrees.prefix}<number>` : `${basename8(r.dir.replace(/[/\\]+$/, ""))}-${effectiveBranchTemplate(config, void 0)}`);
+        const worktreePattern = config.worktrees.name ?? (config.provenance["worktrees.prefix"] !== "default" ? `${config.worktrees.prefix}<number>` : `${basename9(r.dir.replace(/[/\\]+$/, ""))}-${effectiveBranchTemplate(config, void 0)}`);
         process.stdout.write(
           `${`repo ${r.name}:`.padEnd(19)}${r.dir}
                    worktrees at ../${worktreePattern} (${config.provenance["worktrees.name"] ?? config.provenance["worktrees.prefix"] ?? "default"}), branch ${config.branch.name}
@@ -13786,6 +13861,19 @@ crew manifest:     ${seats2.length ? seats2.map((c) => c.name).join(", ") : "non
           );
         }
       }
+      const shipVendors = new Set(shipToolchains(cfg.ship).map(toolchainVendor));
+      if (route.apiKey && route.resolved) {
+        let flagged = 0;
+        for (const role of ROLE_NAMES) {
+          const persona = await fetchSeatPersona(route, role, { userAgent: cfg.ship.userAgent });
+          if (persona?.vendor && !shipVendors.has(persona.vendor)) {
+            flagged++;
+            process.stdout.write(`seat vendor:       ${role} persona wants "${persona.vendor}" \u2014 no toolchain on this ship serves it (have: ${[...shipVendors].join(", ")}); it will run ${resolveSeat(cfg.ship, route, role).toolchain.name} with a warning
+`);
+          }
+        }
+        if (flagged === 0) process.stdout.write("seat vendor:       OK (every persona vendor has a toolchain on this ship)\n");
+      }
       for (const c of cfg.routes.filter((r) => r.enabled)) {
         let repos;
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablation/crew",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "description": "A standing team of headless agents that picks work off a Tablation board, does it on a machine you control, and reports back.",
   "type": "module",
   "license": "MIT",