trantor 0.18.60 → 0.18.61

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.18.60",
+  "version": "0.18.61",
   "description": "Trantor — the hub-world for AI agent crews: live message bus, presence, project Kanban/flow board + crew orchestration for independent AI coding agents (Claude, Codex, Gemini, Kimi, DeepSeek)",
   "mcpServers": {
     "relay": {

package/bin/advise.mjs

@@ -15,7 +15,9 @@ import { join } from "node:path";
 import { homedir } from "node:os";
 import { execSync } from "node:child_process";
 import { pathToFileURL } from "node:url";
-import { busDir, readConfig } from "../lib/project.mjs";
+import { busDir, readConfig, resolveProject } from "../lib/project.mjs";
+import { loadCatalog, lookup as catalogLookup, effortParams, UNCATALOGUED_STATUS } from "../lib/model-catalog.mjs";
+import { benchedAt, loadSeatRecord } from "../lib/seat-record.mjs";
 
 const H = homedir();
 const read = (p, fb) => { try { return JSON.parse(readFileSync(p, "utf8")); } catch { return fb; } };
@@ -119,7 +121,7 @@ const FORECAST = { easy: 0.3e6, medium: 1.5e6, hard: 6e6 };  // tokens
 const CREW_PREF = { hard: ["codex", "glm", "kimi", "deepseek", "openrouter"], medium: ["kimi", "glm", "codex", "deepseek", "openrouter"], easy: ["deepseek", "kimi", "glm", "codex", "openrouter"] };
 
 export function advise(input, world = loadWorld()) {
-  const { profile, registry, caps, agents, scrooge, roster = BUILTIN_ROSTER } = world;
+  const { profile, registry, caps, agents, scrooge, roster = BUILTIN_ROSTER, record } = world;
   // brought (discovered) opencode providers extend the preference list — appended LAST in every
   // tier (unknown strength a priori, like openrouter), so they fill once the curated seats are
   // taken, and are the only option for a user who brought nothing but a custom provider.
@@ -148,17 +150,39 @@ export function advise(input, world = loadWorld()) {
 
   // ---- routing per package ----
   const used = {};
+  // #7762: seats benched by the record ride along so the recommendation says WHO was benched,
+  // at which difficulty, and what their producing nothing already cost (tokens the crew burned).
+  const seatFeedback = [];
   const routing = pkgs.map(p => {
     if ((mode === "hybrid" || mode === "scrooge") && p.difficulty === "easy" && scrooge) {
       const m = scroogeModelFor(registry, caps, p.kind, p.difficulty);
       const tok = FORECAST.easy;
       const cost = m ? +(tok * 0.6 * m.cost_in / 1e6 + tok * 0.4 * m.cost_out / 1e6).toFixed(3) : null;
-      return { ...p, executor: "scrooge", model: m?.model, pool: "api", est_cost_usd: cost,
+      // #7777: scores pick WHICH model; the catalog says HOW to call it — attach the per-difficulty
+      // request parameters so the executor does not have to look them up again.
+      const catEntry = catalogLookup(m?.model);
+      const catParams = catEntry.found ? effortParams(m.model, p.difficulty, "openai-chat") : null;
+      const effort = catEntry.found
+        ? { found: true, difficulty: p.difficulty, api: "openai-chat", params: catParams || {} }
+        : { found: false, difficulty: p.difficulty, params: null, status: UNCATALOGUED_STATUS };
+      return { ...p, executor: "scrooge", model: m?.model, pool: "api", est_cost_usd: cost, effort,
         reason: `easy + stateless → cheapest capable model (${m?.model}); not worth a crew seat` };
     }
     if (p.owner === "self") return { ...p, executor: "orchestrator", pool: tierOf(profile, "claude"), reason: "architect-owned (foundation/integration doctrine) — the orchestrator keeps the shared contract in its own hands" };
     if (mode === "solo") return { ...p, executor: "orchestrator", pool: tierOf(profile, "claude"), reason: "small enough to do inline" };
-    const pref = [...CREW_PREF[p.difficulty], ...broughtPref].filter(a => agents.includes(a));
+    const prefAll = [...CREW_PREF[p.difficulty], ...broughtPref].filter(a => agents.includes(a));
+    // #7762 feedback loop: a seat whose last 3 cards AT THIS DIFFICULTY in THIS project were
+    // empty/bounced is benched at that difficulty — the redone work counts against it, so it
+    // stops being "the cheap option". A bench never empties the pool (better a struck seat
+    // than no seat), and the record is per project — never global.
+    const struck = prefAll.map(a => [a, benchedAt(record, a, p.difficulty)]).filter(([, b]) => b);
+    const eligible = prefAll.filter(a => !benchedAt(record, a, p.difficulty));
+    const pref = eligible.length ? eligible : prefAll;
+    for (const [s, b] of struck) {
+      const wasted = b.wastedTokens ? ` ≈${(b.wastedTokens / 1e6).toFixed(1)}M tok burned` : "";
+      seatFeedback.push({ seat: s, difficulty: p.difficulty, streak: b.streak, cardIds: b.cardIds, wastedTokens: b.wastedTokens,
+        note: `${s} benched at ${p.difficulty}: last ${b.streak.length} cards ${b.streak.join("/")} (#${b.cardIds.join(" #")})${wasted}` });
+    }
     const agent = pref.sort((a, b) => (used[a] || 0) - (used[b] || 0))[0] || agents[0] || "deepseek";
     used[agent] = (used[agent] || 0) + 1;
     const pool = tierOf(profile, roster[agent]?.provider || agent);
@@ -176,6 +200,7 @@ export function advise(input, world = loadWorld()) {
     // has scored it (AA scores + price proxy + per-difficulty cost weighting → hard escalates to a
     // strong model, easy stays cheap). If it hasn't been run, routing falls back to cost-only.
     if (agent === "openrouter" && p.difficulty === "hard") why_r += ` — OpenRouter ranks capability×cost; run \`scrooge-capabilities\` to keep the catalog scored (or pin openrouter:openrouter/<vendor>/<model>)`;
+    if (struck.length && !struck.some(([s]) => s === agent)) why_r += ` — ${struck.map(([s]) => s).join("/")} benched at ${p.difficulty} here (last 3 cards empty/bounced; seat_feedback)`;
     return { ...p, executor: agent, pool, est_cost_usd: est, reason: why_r };
   });
   // crew-size rationale: seats are EMERGENT from the work, and we say so
@@ -188,11 +213,14 @@ export function advise(input, world = loadWorld()) {
 
   const apiCost = +(routing.reduce((s, r) => s + (r.est_cost_usd || 0), 0)).toFixed(2);
   const pools = [...new Set(routing.map(r => `${r.executor}:${r.pool}`))];
+  // One bench line per seat+difficulty, however many packages tripped it.
+  const feedback = [...new Map(seatFeedback.map(f => [`${f.seat}@${f.difficulty}`, f])).values()];
   const summary =
     `Recommendation: ${mode.toUpperCase()}. ${why.join("; ")}. ` +
     (mode === "crew" || mode === "hybrid"
       ? `Routing: ${routing.map(r => `${r.title}→${r.executor}${r.model ? `(${r.model})` : ""}`).join(", ")}. ` +
-        `Estimated real-money cost ≈ $${apiCost} (everything on a subscription pool is $0 marginal — quota pooling across ${pools.length} pools).`
+        `Estimated real-money cost ≈ $${apiCost} (everything on a subscription pool is $0 marginal — quota pooling across ${pools.length} pools).` +
+        (feedback.length ? ` Seat record (this project): ${feedback.map(f => f.note).join("; ")}.` : "")
       : "");
   const table = ["| package | diff | executor (model) | pool | est $ | reason |", "|---|---|---|---|---|---|",
     ...routing.map(r => `| ${r.title} | ${r.difficulty} | ${r.executor}${r.model ? ` (${r.model})` : ""} | ${r.pool} | ${r.est_cost_usd ?? "—"} | ${r.reason} |`)].join("\n");
@@ -221,7 +249,12 @@ export function advise(input, world = loadWorld()) {
       ? routing.map((x, j) => j + 1).filter(j => j !== i + 1)
       : (r.executor !== "orchestrator" ? foundationIdx.filter(f => f !== i + 1) : []) };
   });
-  return { mode, why, crew, routing, routing_table_md: table, card_args: cards, est_api_cost_usd: apiCost, quota_pools: pools, summary, orchestrator_tier: orchTier, agents_available: agents };
+  // #7777: crew-bound packages get their catalog effort attached at SPAWN, when the live model is
+  // known (bin/crew/models.mjs resolveSpec → CREW_EFFORT); the advisor only records that it is deferred.
+  const catalogMeta = (() => { const c = loadCatalog(); return { version: c.version, models: Object.keys(c.models).length, source: "configs/model-catalog.json" }; })();
+  const recommendation = { mode, why, crew, routing, routing_table_md: table, card_args: cards, est_api_cost_usd: apiCost, quota_pools: pools, summary, orchestrator_tier: orchTier, agents_available: agents, catalog: catalogMeta };
+  if (feedback.length) recommendation.seat_feedback = feedback;
+  return recommendation;
 }
 
 // ---- CLI ----
@@ -238,6 +271,10 @@ if (import.meta.url === pathToFileURL(process.argv[1]).href) {
     const stdin = readFileSync(0, "utf8").trim();
     input = stdin ? JSON.parse(stdin) : { packages: [] };
   }
-  const out = advise(input);
+  const world = loadWorld();
+  // #7762: fold this project's seat record into the routing (fail-open — no hub, no record,
+  // and the advice is exactly what it was before the feedback loop existed).
+  try { world.record = await loadSeatRecord({ project: resolveProject(process.cwd()) }); } catch {}
+  const out = advise(input, world);
   console.log(JSON.stringify(out, null, 2));
 }

package/bin/cli.mjs

@@ -99,6 +99,7 @@ switch (cmd) {
   case "state": run("bin/state.mjs"); break;
   case "seats": case "seat": run("bin/seats.mjs"); break;
   case "seat-why": case "why": run("bin/seat-why.mjs"); break;
+  case "seat-record": run("bin/seat-record.mjs"); break;
   case "orchestrate": run("bin/orchestrate.mjs"); break;
   case "app": run("bin/app.mjs"); break;
   case "patrol": run("bin/patrol.mjs"); break;
@@ -231,6 +232,7 @@ switch (cmd) {
                       seats: which project lives in which directory — seats · seats add · seats up · seats login install
   trantor state       a seat's working memory: show <seat> <card> [--json] · validate · reset --force · gc [--apply]
   trantor seat-why    WHY a seat is down (err file, logs, pids): seat-why <agent> [--json] — quota, auth, crash, or just no pane
+  trantor seat-record the per-project seat record the advisor benches from (✓/∅/↩ per difficulty) — [--project p] [--reset <seat>] [--json]
   trantor watch       live bus feed in the terminal
   trantor inbox       THIS session's unread bus messages, signed (works under enforce) — [--all] [--consume] [--json]
   trantor policy      the autonomy ladder: show | set <project> <1-4> | link <a> <b> --reason "<why>"

package/bin/connect.mjs

@@ -110,15 +110,28 @@ if (has("gemini")) {
   }), p);
 }
 
-// ---- Kimi CLI ----  (same refresh: the stale entry that caused #7893 was {RELAY_AGENT: kimi} only)
-if (has("kimi")) {
-  const p = join(homedir(), ".kimi", "mcp.json");
-  report("kimi", patchJson(p, d => {
-    d.mcpServers ||= {};
-    d.mcpServers.relay ||= { command: "node", args: [MCP], env: {} };
-    d.mcpServers.relay.env = { ...d.mcpServers.relay.env, ...relayEnv("kimi") };
-    if (HAS_GRAFT) d.mcpServers.graft ||= { command: GRAFT, args: ["mcp"] };
-  }), p);
+// ---- Kimi CLI + kimi-code ----  (same refresh: the stale entry that caused #7893 was {RELAY_AGENT: kimi} only)
+// kimi-code is a separate install reading ~/.kimi-code/mcp.json — wiring only the old file left the
+// running kimi seat on a hard-coded stale hub (#7938). Same shape and stamp; the dir is detected by
+// config.toml presence — existsSync only, the config itself is never read.
+const kimiRelay = (cli, p) => report(cli, patchJson(p, d => {
+  d.mcpServers ||= {};
+  d.mcpServers.relay ||= { command: "node", args: [MCP], env: {} };
+  d.mcpServers.relay.env = { ...d.mcpServers.relay.env, ...relayEnv("kimi") };
+  if (HAS_GRAFT) d.mcpServers.graft ||= { command: GRAFT, args: ["mcp"] };
+}), p);
+const kimiPaths = [join(homedir(), ".kimi", "mcp.json"), join(homedir(), ".kimi-code", "mcp.json")];
+const kimiWritten = new Set();
+if (has("kimi")) { kimiRelay("kimi", kimiPaths[0]); kimiWritten.add(kimiPaths[0]); }
+if (existsSync(join(homedir(), ".kimi-code", "config.toml"))) { kimiRelay("kimi-code", kimiPaths[1]); kimiWritten.add(kimiPaths[1]); }
+// A kimi-family config this run did NOT write still names a hub of its own; if it disagrees with
+// the pin, say so — one CLI of the pair would keep registering on a different bus (#7938).
+for (const p of kimiPaths) {
+  if (kimiWritten.has(p) || !existsSync(p)) continue;
+  try {
+    const u = JSON.parse(readFileSync(p, "utf8"))?.mcpServers?.relay?.env?.RELAY_URL;
+    if (u && u !== URL_) report("kimi", `WARN: ${p} still points at ${u} — re-run connect or refresh it by hand`);
+  } catch {}
 }
 
 // ---- OpenCode ----

package/bin/crew/cmux.mjs

@@ -109,7 +109,7 @@ export function spawnCmux(ctx, specs, resolve, prune) {
   for (let index = 0; index < specs.length; index += 1) {
     const seat = resolve(specs[index]);
     if (!seat) continue;
-    const launcher = seatLauncher(ctx, seat.agent, runnerCommand(ctx, seat.agent, seat.model));
+    const launcher = seatLauncher(ctx, seat.agent, runnerCommand(ctx, seat.agent, seat.model, seat.effort));
     const old = reuse ? readRows(ctx).filter(row => row.project === ctx.project && row.kind === "cmux" && row.agent === seat.agent).at(-1)?.handle || "" : "";
     let pane = "";
     if (reuse) {
@@ -149,7 +149,7 @@ function spawnAppleScript(ctx, specs, resolve) {
   for (let index = 0; index < specs.length; index += 1) {
     const seat = resolve(specs[index]);
     if (!seat) continue;
-    const launcher = seatLauncher(ctx, seat.agent, runnerCommand(ctx, seat.agent, seat.model));
+    const launcher = seatLauncher(ctx, seat.agent, runnerCommand(ctx, seat.agent, seat.model, seat.effort));
     const old = reuse ? readRows(ctx).filter(row => row.project === ctx.project && row.kind === "cmux" && row.agent === seat.agent).at(-1)?.handle || "" : "";
     let pane;
     if (!tab && index === 0) {

package/bin/crew/core.mjs

@@ -141,12 +141,15 @@ export function gridColumns(size) {
 // file that was never written and a runner still on the transcript path.
 const FORWARDED_ENV = ["TRANTOR_STATE", "TRANTOR_STATE_ASSEMBLE", "TRANTOR_STATE_HANDOFF", "TRANTOR_STATE_GATE"];
 
-export function runnerCommand(ctx, agent, model = "") {
+export function runnerCommand(ctx, agent, model = "", effort = null) {
   const forwarded = FORWARDED_ENV
     .filter((name) => process.env[name])
     .map((name) => `${name}=${shellQuote(process.env[name])} `)
     .join("");
-  return `cd ${shellQuote(ctx.dir)} && ${forwarded}CREW_MODEL=${shellQuote(model)} RELAY_PROJECT=${shellQuote(ctx.project)} RELAY_URL=${shellQuote(ctx.hub)} node ${shellQuote(join(ROOT, "bin/crew-runner.mjs"))} ${shellQuote(agent)} ${shellQuote(ctx.dir)}`;
+  // #7777: the launcher resolved the catalog's per-difficulty effort for this seat; the runner
+  // reads CREW_EFFORT, applies what the CLI accepts and logs the one-line summary.
+  const effortEnv = effort ? ` CREW_EFFORT=${shellQuote(JSON.stringify(effort))}` : "";
+  return `cd ${shellQuote(ctx.dir)} && ${forwarded}CREW_MODEL=${shellQuote(model)}${effortEnv} RELAY_PROJECT=${shellQuote(ctx.project)} RELAY_URL=${shellQuote(ctx.hub)} node ${shellQuote(join(ROOT, "bin/crew-runner.mjs"))} ${shellQuote(agent)} ${shellQuote(ctx.dir)}`;
 }
 
 export function listPids(pattern) {

package/bin/crew/herdr.mjs

@@ -165,7 +165,7 @@ function replacementPane(ctx, workspace, spec, hostPane, resolve) {
     pane = `%DRYT${spec.index}`;
   } else {
     pane = splitPane(ctx, hostPane, "right", ctx.dir);
-    runSeat(ctx, pane, seat.agent, runnerCommand(ctx, seat.agent, seat.model));
+    runSeat(ctx, pane, seat.agent, runnerCommand(ctx, seat.agent, seat.model, seat.effort));
   }
   if (old) {
     closePane(ctx, old);
@@ -202,7 +202,7 @@ export function spawnHerdr(ctx, specs, resolve, prune) {
 function freshPane(ctx, workspace, spec, panes, columns, resolve) {
   const seat = resolve(spec.value);
   if (!seat) return null;
-  const command = runnerCommand(ctx, seat.agent, seat.model);
+  const command = runnerCommand(ctx, seat.agent, seat.model, seat.effort);
   let pane = "";
   if (spec.index === 0) {
     if (ctx.dry) {

package/bin/crew/models.mjs

@@ -2,6 +2,7 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { call } from "./core.mjs";
 import { reapSeat } from "./state.mjs";
+import { resolveEffort } from "../../lib/model-catalog.mjs";
 
 function routeModel(ctx, provider, candidates, task, difficulty) {
   const bundled = join(ctx.root, "engine/bin/scrooge");
@@ -36,16 +37,22 @@ export function resolveSpec(ctx, spec, task, difficulty, skipped) {
     if (agent === "glm") field = "zai-coding-plan";
     else if (!["codex", "kimi", "claude", "gemini", "dsh", "opencode"].includes(agent)) field = agent;
   }
-  if (!field) return { agent, model: "" };
-  if (field.includes("/")) return { agent, model: field };
+  if (!field) {
+    // #7777: CLI-default seat (kimi/codex/claude/dsh) — the catalog finds the entry through the
+    // agent alias so the runner still gets a CREW_EFFORT record (or the uncatalogued line).
+    return { agent, model: "", effort: resolveEffort(agent, "", difficulty) };
+  }
+  if (field.includes("/")) return { agent, model: field, effort: resolveEffort(agent, field, difficulty) };
   if (["claude", "codex", "kimi", "gemini"].includes(agent)) {
     console.log(`  → ${agent}: model ${field} (native pin)`);
-    return { agent, model: field };
+    return { agent, model: field, effort: resolveEffort(agent, field, difficulty) };
   }
   try {
     const model = resolveModel(ctx, agent, field, task, difficulty);
+    // #7777: the live model is known — attach the catalog's per-difficulty effort parameters here
+    // so the runner applies them where the CLI accepts them (CREW_EFFORT, below).
     console.log(`  → ${agent}: live model ${model} (${field} · ${task}/${difficulty})`);
-    return { agent, model };
+    return { agent, model, effort: resolveEffort(agent, model, difficulty) };
   } catch (error) {
     console.error(error.message);
     console.error(`[crew] ✗ skipping seat '${agent}' — model resolution failed for ${field} (${task}/${difficulty}); remaining seats still launch`);

package/bin/crew/tmux.mjs

@@ -7,7 +7,7 @@ export function spawnTmux(ctx, specs, resolve) {
   for (const spec of specs) {
     const seat = resolve(spec);
     if (!seat) continue;
-    const command = runnerCommand(ctx, seat.agent, seat.model);
+    const command = runnerCommand(ctx, seat.agent, seat.model, seat.effort);
     let pane = ctx.dry ? "%DRY" : "";
     if (first) {
       run(ctx, "tmux", ["new-session", "-d", "-s", session, "-n", "crew", "-x", "260", "-y", "60"], { rendered: `tmux new-session -d -s '${session}' -n crew -x 260 -y 60` });
@@ -52,7 +52,7 @@ export function spawnTerminal(ctx, specs, resolve) {
       recordState(ctx, ctx.project, "win", seat.agent, `%DRYWIN${index}`);
       continue;
     }
-    const command = `clear && ${runnerCommand(ctx, seat.agent, seat.model)}`;
+    const command = `clear && ${runnerCommand(ctx, seat.agent, seat.model, seat.effort)}`;
     const title = `${ctx.project} · ${seat.agent.toUpperCase()}`;
     const result = appleScript(`tell application "Terminal"\nset w to do script "${appleScriptString(command)}"\nset custom title of w to "${appleScriptString(title)}"\nset theWin to first window whose tabs contains w\nset bounds of theWin to {${x}, ${y}, ${x + width}, ${y + height}}\nreturn id of theWin\nend tell\n`);
     if (result.stdout) {

package/bin/crew-runner.mjs

@@ -26,6 +26,7 @@ import {
   observedDutyNudgeIds, requeueMissingWakeMessages, shedExpiredHubAlerts,
 } from "../lib/duty-nudges.mjs";
 import { dutyRecipientResolver } from "../lib/duty-recipient.mjs";
+import { cliEffortFlag } from "../lib/model-catalog.mjs";
 import {
   BREAKER_WINDOW, STATE_ENV, TURN_RESULT_SCHEMA,
   breakerVerdict, describeTurn, hasJsonSchemaFlag, parseEnvelope, renderCardTail, runStep,
@@ -236,6 +237,13 @@ const cli = CLI[AGENT] || (NATIVE.has(AGENT) ? null : CLI.opencode);
 if (!cli) { console.error(`unknown agent '${AGENT}' (native: ${[...NATIVE].join(", ")}; any other name = an opencode provider seat)`); process.exit(1); }
 if (!CLI[AGENT]) log(`'${AGENT}' is not a built-in seat — running it as an opencode provider (BYOM)`);
 
+// #7777: the launcher resolved the model catalog's per-difficulty effort for this seat and sent
+// it as CREW_EFFORT (JSON from bin/crew/core.mjs runnerCommand). The runner applies the
+// parameters the CLI can carry (codex -c model_reasoning_effort / claude --effort / opencode
+// --variant) and logs ONE line saying what it set — or that the model is uncatalogued.
+const EFFORT = (() => { try { return JSON.parse(process.env.CREW_EFFORT || "null"); } catch { return null; } })();
+const EFFORT_FLAG = EFFORT ? cliEffortFlag(AGENT, EFFORT) : { flag: "", text: "" };
+
 // RUNNER_RULES / RUNNER_KICKOFF env overrides: the runner is also the substrate for non-crew
 // always-on seats (the fleet DUTY agent, bin/duty.mjs) whose doctrine is not "work your card".
 const RULES = process.env.RUNNER_RULES || `Rules: you are ${SESSION} on the trantor crew. Before starting a card, read YOUR card: relay_board with card:<id> (the card, its deps, its notes, and the last five done cards whose title shares a word); never the whole board. Work your assigned file(s), report on the bus (relay_send, <280 chars), move your Kanban card as you go with a NOTE saying what you did (doing -> testing -> done; in 'testing' run YOUR OWN test file — never the full npm test, suites collide across seats — plus \`node bin/slop-gate.mjs\` when the repo has one: it lints ONLY your changed files against the anti-slop rules, and a card must not reach done with slop-gate failing; use 'failed' + a report if anything breaks). If a contract omits a fact you cannot proceed without, ASK — never invent the value: relay_ask(<card>, <question>) blocks the card with your question, keeps the turn owed (no park, no failure), and resumes you when the assigner's answer lands; an invented value that reads as reasoned is the worst outcome this crew ships (#7756). If you need something from another session, message THAT SESSION (relay_peers to find its id, relay_send to reach it) — never ask the human to pass it along; carrying messages between agents is the job this bus exists to remove. When your work for THIS message is finished, END YOUR TURN — do NOT park, do NOT loop relay_wait; the runner waits for you and will wake you with the next message. Path discipline: build/test from your worktree root ${TURN_DIR} with absolute paths or --manifest-path/--prefix instead of cd-ing into subdirs, and put anything that must land outside the repo under ${TURN_DIR}/.agent-bus-out/ (gitignored) — never ~/.agent-bus. Realigning your seat branch after the orchestrator harvested your commits is \`trantor sync\` run from your worktree: it reads the harvest receipts and refuses when an unharvested commit would be lost, so never reset or rebase onto main by hand. A contract's \`base: <sha>\` line is the integration head: start your seat branch at that sha (\`git reset --hard <sha>\` on the fresh branch), never at origin/main, which trails the orchestrator's unpushed integration commits; the object is already here as the ref \`main\`. If \`git cat-file -e <sha>\` fails, say \`cannot resolve base <sha>\` on the bus and move the card to blocked instead of reasoning from origin/main. Every testing/done note names the sha you verified against as \`verified at <sha>\`; a note without it is flagged HOLLOW. Cross-project action is a breach: never \`trantor up\` a crew, register a seat, or send a card/contract into a project other than ${PROJ} unless the operator ran \`trantor policy link ${PROJ} <other> --reason "<why>"\` first — the hub, the CLI and this runner all refuse it mechanically, so ask the operator to link the projects instead of routing around the refusal.`;
@@ -657,7 +665,7 @@ async function runTurn(prompt, isFirst, trigger = "kickoff", opts = {}) {
   // The flagged row (TDD §4.6). `{S}` exists only in `stateNext`, so the replaceAll below is a
   // no-op on every other path — which is what "flag off = byte-identical" has to mean.
   if (opts.state && cli.stateNext) cmd = cli.stateNext;
-  const mfrag = MODEL && cli.mflag ? `${cli.mflag}${MODEL}` : "";
+  const mfrag = (MODEL && cli.mflag ? `${cli.mflag}${MODEL}` : "") + EFFORT_FLAG.flag;
   cmd = cmd.replaceAll("{M}", mfrag).replaceAll("{P}", pf).replaceAll("{SID}", sid).replaceAll("{DIR}", TURN_DIR)
     .replaceAll("{S}", STATE_SCHEMA_FILE);
   // PRECEDENCE: each file is PREPENDED, so the list is iterated in written order, highest priority
@@ -665,6 +673,8 @@ async function runTurn(prompt, isFirst, trigger = "kickoff", opts = {}) {
   const envs = [join(homedir(), ".agent-bus", ".env"), cli.env].filter(f => f && existsSync(f));
   cmd = withEnvFiles(cmd, envs);
   log(`turn starting (${isFirst ? "fresh session" : "resume"})${MODEL ? ` · model=${MODEL}` : ""}`);
+  // #7777: the one effort line — which effort parameters were set, or that the model is uncatalogued.
+  if (EFFORT && EFFORT_FLAG.text) log(EFFORT_FLAG.text);
   cmuxStatus("building", "#4a90d9", "hammer", { priority: 50 }); herdrAgent("working");
   // inherit stdio so the window shows the agent working live; also capture for sid-parsing.
   // Tee stderr to ERRF (still shown live in the window) so a failed turn can be classified.
@@ -852,7 +862,9 @@ exit $turn_exit`;
   // #6289: every ledger row names in ONE field what happened to the turn — cut (the box ended
   // it), stalled (the watchdog window ended it, #7752), api-error (the CLI failed), completed —
   // and what it cost in tokens, even when this CLI printed no usage line (0 means "not
-  // reported", never "free"). `cut` stays too: the drills read it.
+  // reported", never "free"). `cut` stays too: the drills read it. #7762: `card` binds the row
+  // to the card the turn was working (0 = kickoff/pulse, no card) so the seat record can
+  // attribute empty/stalled turns to the card that produced nothing.
   const outcome = cut ? (stallCut ? "stalled" : "cut") : (effExit !== 0 ? "api-error" : lastEmptyTurn ? "empty" : "completed");
   // #7756: a clean turn that ASKED its assigner is demoted-but-owed, not "completed". The judge
   // (deliverWake's /contracts read) renames the ledger row, so "asked" is what the log keeps.
@@ -860,7 +872,7 @@ exit $turn_exit`;
   if (outcome === "completed" && opts.judgeOutcome) {
     try { finalOutcome = (await opts.judgeOutcome()) || outcome; } catch {}
   }
-  const telemetryRow = { ts: Date.now(), agent: AGENT, project: PROJ, turn: TURN, trigger, model: MODEL || "cli-default", duration_ms: Date.now() - t0, exit: realExit, effExit, authFailed: effExit !== realExit, emptyOutput: lastEmptyOutput, emptyTurn: lastEmptyTurn, verdict, outcome: finalOutcome, tokens };
+  const telemetryRow = { ts: Date.now(), agent: AGENT, project: PROJ, turn: TURN, trigger, card: sessionCard || 0, model: MODEL || "cli-default", duration_ms: Date.now() - t0, exit: realExit, effExit, authFailed: effExit !== realExit, emptyOutput: lastEmptyOutput, emptyTurn: lastEmptyTurn, verdict, outcome: finalOutcome, tokens };
   if (cut) telemetryRow.cut = true;
   if (stallCut) telemetryRow.stalled = true;
   // #7752: a cut turn's 141 is the sweep's SIGPIPE, recorded as the cut signal — never read as

package/bin/seat-record.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+// trantor seat-record [--project p] [--reset <seat>] [--json]
+// #7762: the per-project seat record the advisor benches from — derived from board cards +
+// card-move events + runner ledgers, never a store of its own. --reset is the manual
+// forgiveness path: evidence at or before the stamp stops counting (new completed cards are
+// the organic one — they age the bad ones out of the 3-card window).
+import { resolveProject } from "../lib/project.mjs";
+import { loadSeatRecord, resetSeat, benchedAt, STRIKE, RECORD_LIMIT } from "../lib/seat-record.mjs";
+
+const args = process.argv.slice(2);
+const opt = (name) => { const i = args.indexOf(name); return i >= 0 ? args[i + 1] : undefined; };
+const project = opt("--project") || resolveProject(process.cwd());
+const reset = opt("--reset");
+
+if (reset) {
+  const okReset = resetSeat({ project, seat: reset });
+  console.log(okReset
+    ? `${reset} reset on ${project} — its earlier cards no longer count toward a bench; new completed cards still age in`
+    : `reset FAILED — could not write the resets file`);
+  process.exit(okReset ? 0 : 1);
+}
+
+const record = await loadSeatRecord({ project });
+if (args.includes("--json")) { console.log(JSON.stringify({ project, ...record }, null, 2)); process.exit(0); }
+
+const seats = Object.entries(record.seats);
+if (!seats.length) {
+  console.log(`no seat record for ${project} yet — it derives from board cards + runner ledgers once seats work cards`);
+  process.exit(0);
+}
+console.log(`seat record for ${project} — last ${RECORD_LIMIT} cards/seat (✓ completed · ∅ empty · ↩ bounced); a seat is benched at a difficulty after ${STRIKE} straight ∅/↩ there:`);
+const MARK = { completed: "✓", empty: "∅", bounced: "↩" };
+for (const [seat, s] of seats.sort(([a], [b]) => a.localeCompare(b))) {
+  const byDiff = {};
+  for (const c of s.cards) (byDiff[c.difficulty || "?"] ||= []).push(c);
+  const parts = Object.entries(byDiff).sort().map(([d, cs]) => `${d}:${cs.map(c => MARK[c.outcome] || c.outcome).join("")}`);
+  const bench = ["easy", "medium", "hard"].filter(d => benchedAt(record, seat, d));
+  const wasted = s.wastedTokens ? ` · wasted ≈${(s.wastedTokens / 1e6).toFixed(1)}M tok on ∅/↩` : "";
+  const hint = bench.length ? ` · BENCHED at ${bench.join(",")} — the advisor routes those elsewhere (forgive: trantor seat-record --project ${project} --reset ${seat})` : "";
+  console.log(`  ${seat.padEnd(12)} ${parts.join("  ")}${wasted}${hint}`);
+}

package/configs/model-catalog.json

@@ -0,0 +1,119 @@
+{
+  "version": 1,
+  "source": "card #7777 — model ids come from `trantor models` (opencode adapters) and the seat CLIs' defaults; limits and effort levels come from each provider's published docs, cited per entry. modalities = accepted inputs; every entry outputs text.",
+  "models": {
+    "zai-coding-plan/glm-5.3-flash": {
+      "api": ["openai-chat", "openai-responses", "anthropic-messages"],
+      "context": 1000000,
+      "maxOutput": 128000,
+      "modalities": ["text", "image", "video", "file"],
+      "url": "https://docs.z.ai/guides/vlm/glm-5.3-flash",
+      "notes": "docs: 1M context / 128K max output; thinking.type only supports enabled; reasoning_effort low|high|max (recommended max). GLM Coding Plan serves the OpenAI Chat Completion protocol only, so effort is keyed on openai-chat. The glm seat's easy/medium router pick (`trantor models glm`).",
+      "effort": {
+        "easy":   { "openai-chat": { "reasoning_effort": "low" } },
+        "medium": { "openai-chat": { "reasoning_effort": "high" } },
+        "hard":   { "openai-chat": { "reasoning_effort": "max" } }
+      }
+    },
+    "zai-coding-plan/glm-5.3": {
+      "api": ["openai-chat", "openai-responses", "anthropic-messages"],
+      "context": 1000000,
+      "maxOutput": 128000,
+      "modalities": ["text"],
+      "url": "https://docs.z.ai/guides/llm/glm-5.3",
+      "notes": "docs: 1M context / 128K max output; text-only input; reasoning always enabled (disabling not supported); reasoning_effort low|high|max, default max. The glm seat's hard router pick. Coding plan serves openai-chat only.",
+      "effort": {
+        "easy":   { "openai-chat": { "reasoning_effort": "low" } },
+        "medium": { "openai-chat": { "reasoning_effort": "high" } },
+        "hard":   { "openai-chat": { "reasoning_effort": "max" } }
+      }
+    },
+    "deepseek/deepseek-v4-flash": {
+      "api": ["openai-chat", "anthropic-messages", "openai-responses"],
+      "context": 1000000,
+      "maxOutput": 384000,
+      "modalities": ["text", "image"],
+      "url": "https://api-docs.deepseek.com/quick_start/pricing",
+      "notes": "Legacy id served by DeepSeek-V4.1-Flash at flash price (docs: 1M context, max output 384K, vision supported). Thinking mode is enabled by default with default effort high; legacy id still accepted by the API. The deepseek seat's easy/medium router pick.",
+      "effort": {
+        "easy":   { "openai-chat": { "thinking": { "type": "enabled" }, "reasoning_effort": "low" },
+                    "anthropic-messages": { "reasoning": { "effort": "low" } } },
+        "medium": { "openai-chat": { "thinking": { "type": "enabled" }, "reasoning_effort": "high" },
+                    "anthropic-messages": { "reasoning": { "effort": "high" } } },
+        "hard":   { "openai-chat": { "thinking": { "type": "enabled" }, "reasoning_effort": "max" },
+                    "anthropic-messages": { "reasoning": { "effort": "max" } } }
+      }
+    },
+    "deepseek/deepseek-v4-pro": {
+      "api": ["openai-chat", "anthropic-messages", "openai-responses"],
+      "context": 1000000,
+      "maxOutput": 384000,
+      "modalities": ["text"],
+      "url": "https://api-docs.deepseek.com/quick_start/pricing",
+      "notes": "DeepSeek-V4-Pro-0813 (docs: 1M context, max output 384K, no vision; API service continues past 2026-09-14). Thinking mode enabled by default, default effort high. The deepseek seat's hard router pick.",
+      "effort": {
+        "easy":   { "openai-chat": { "thinking": { "type": "enabled" }, "reasoning_effort": "low" },
+                    "anthropic-messages": { "reasoning": { "effort": "low" } } },
+        "medium": { "openai-chat": { "thinking": { "type": "enabled" }, "reasoning_effort": "high" },
+                    "anthropic-messages": { "reasoning": { "effort": "high" } } },
+        "hard":   { "openai-chat": { "thinking": { "type": "enabled" }, "reasoning_effort": "max" },
+                    "anthropic-messages": { "reasoning": { "effort": "max" } } }
+      }
+    },
+    "qwen/deepseek-v4-pro": {
+      "api": ["openai-chat"],
+      "context": 1000000,
+      "maxOutput": 384000,
+      "modalities": ["text"],
+      "url": "https://api-docs.deepseek.com/quick_start/pricing",
+      "notes": "DeepSeek V4-Pro served through the qwen opencode provider (Alibaba Model Studio openai-compatible endpoint, per the provider adapter). Model limits and effort levels per DeepSeek's own V4-Pro docs. The qwen seat's router pick at every difficulty.",
+      "effort": {
+        "easy":   { "openai-chat": { "thinking": { "type": "enabled" }, "reasoning_effort": "low" } },
+        "medium": { "openai-chat": { "thinking": { "type": "enabled" }, "reasoning_effort": "high" } },
+        "hard":   { "openai-chat": { "thinking": { "type": "enabled" }, "reasoning_effort": "max" } }
+      }
+    },
+    "kimi-code/default": {
+      "aliases": ["kimi"],
+      "api": ["openai-chat", "anthropic-messages"],
+      "context": 256000,
+      "maxOutput": 32768,
+      "modalities": ["text", "image", "video"],
+      "url": "https://platform.kimi.ai/docs/guide/kimi-k2-7-code-quickstart",
+      "notes": "kimi-code default — the kimi CLI's managed coding model (Kimi K2.7 Code family). docs: 256K context; max_tokens defaults to 32768 (no higher maximum published); thinking is always on and cannot be disabled; reasoning_effort is NOT supported on K2.7 Code — so no effort parameters are declarable and every level maps to provider default. Kimi API is OpenAI- and Anthropic-compatible.",
+      "effort": {
+        "easy":   { "openai-chat": {} },
+        "medium": { "openai-chat": {} },
+        "hard":   { "openai-chat": {} }
+      }
+    },
+    "codex/gpt-5.6-sol": {
+      "aliases": ["codex"],
+      "api": ["openai-responses", "openai-chat"],
+      "context": 1050000,
+      "maxOutput": 128000,
+      "modalities": ["text", "image"],
+      "url": "https://developers.openai.com/api/docs/models/gpt-5.6-sol",
+      "notes": "Codex CLI default model (codex docs name gpt-5.6-sol the replacement/default with default effort medium — https://developers.openai.com/codex/models). API docs: 1,050,000 context window / 128,000 max output; reasoning.effort supports none|low|medium(default)|high|xhigh|max. Codex applies effort via its model_reasoning_effort config key (codex exec -c model_reasoning_effort=...).",
+      "effort": {
+        "easy":   { "openai-responses": { "reasoning_effort": "low" } },
+        "medium": { "openai-responses": { "reasoning_effort": "medium" } },
+        "hard":   { "openai-responses": { "reasoning_effort": "high" } }
+      }
+    },
+    "anthropic/claude-sonnet-5": {
+      "aliases": ["claude", "sonnet"],
+      "api": ["anthropic-messages"],
+      "context": 1000000,
+      "maxOutput": 128000,
+      "modalities": ["text", "image"],
+      "url": "https://platform.claude.com/docs/en/models/overview",
+      "notes": "Claude Sonnet 5 (claude-sonnet-5) — the speed/intelligence default of the current lineup and the Claude Code default family. docs: 1M context, 128K max output, adaptive thinking with the effort parameter (default high; levels low|medium|high|xhigh|max). The claude CLI carries it per request via --effort.",
+      "effort": {
+        "easy":   { "anthropic-messages": { "effort": "low" } },
+        "medium": { "anthropic-messages": { "effort": "medium" } },
+        "hard":   { "anthropic-messages": { "effort": "high" } }
+      }
+    }
+  }
+}

package/hooks/ask-sidecar.mjs

@@ -45,6 +45,32 @@ function sameOpen(left, right) {
     JSON.stringify(left.questions) === JSON.stringify(right.questions);
 }
 
+// The declaration the Chat chips render from (#7776): the first question, its options as offered,
+// and whether several may be picked. Chips never invent an option that is not in this list.
+function declaredAsk(questions) {
+  const first = questions[0] ?? {};
+  const question = String(first.question ?? "");
+  if (!question) return null;
+  const options = (Array.isArray(first.options) ? first.options : [])
+    .map(o => ({ label: String(o?.label ?? ""), description: String(o?.description ?? "") }))
+    .filter(o => o.label)
+    .map(o => o.description ? o : { label: o.label });
+  return { question, options, multi: first.multiSelect === true };
+}
+
+function writeAtomic(sessionId, path, payload) {
+  const dir = join(busDir(), "asks");
+  mkdirSync(dir, { recursive: true });
+  const tmp = join(dir, `.${String(sessionId)}.${process.pid}.${Date.now()}.tmp`);
+  try {
+    writeFileSync(tmp, JSON.stringify(payload), { mode: 0o600 });
+    renameSync(tmp, path);
+  } catch (error) {
+    try { unlinkSync(tmp); } catch {}
+    throw error;
+  }
+}
+
 function writeOpen(input, path) {
   if (String(input.tool_name ?? "") !== "AskUserQuestion") return;
   const questions = input.tool_input?.questions;
@@ -61,22 +87,39 @@ function writeOpen(input, path) {
     project: ctx.project,
     cwd,
     tool_use_id: incomingId ?? stored?.tool_use_id ?? null,
+    kind: "AskUserQuestion",
+    ask: declaredAsk(questions),
     questions,
     event: visibleTs === null ? "PreToolUse" : "PermissionRequest",
     visible_ts: visibleTs,
     ts: stored?.ts ?? now,
   };
   if (stored && sameOpen(stored, payload)) return;
-  const dir = join(busDir(), "asks");
-  mkdirSync(dir, { recursive: true });
-  const tmp = join(dir, `.${String(input.session_id)}.${process.pid}.${Date.now()}.tmp`);
-  try {
-    writeFileSync(tmp, JSON.stringify(payload), { mode: 0o600 });
-    renameSync(tmp, path);
-  } catch (error) {
-    try { unlinkSync(tmp); } catch {}
-    throw error;
-  }
+  writeAtomic(input.session_id, path, payload);
+}
+
+// A relay_ask is the turn-ending ask (#7756): the question is out on the bus and the session
+// idles at its prompt until the answer lands, so the sidecar stays open past Stop and closes on
+// the next prompt. It offers no options: the card shows the question, chips show nothing.
+const isRelayAsk = name => /(^|__)relay_ask$/.test(String(name ?? ""));
+
+function writeRelayAsk(input, path) {
+  const question = String(input.tool_input?.question ?? "").trim();
+  if (!question) return;
+  const cwd = String(input.cwd ?? "");
+  const now = Date.now();
+  writeAtomic(input.session_id, path, {
+    session_id: String(input.session_id),
+    project: sessionContext(cwd).project,
+    cwd,
+    tool_use_id: toolUseId(input),
+    kind: "relay_ask",
+    ask: { question, options: [], multi: false },
+    questions: [{ question, header: "ask", multiSelect: false, options: [] }],
+    event: "PreToolUse",
+    visible_ts: now,
+    ts: now,
+  });
 }
 
 function closeTool(input, path) {
@@ -85,15 +128,24 @@ function closeTool(input, path) {
   if (storedId === null || storedId === toolUseId(input)) unlinkSync(path);
 }
 
+function closeTurn(path) {
+  let stored = null;
+  try { stored = JSON.parse(readFileSync(path, "utf8")); } catch {}
+  if (stored?.kind === "relay_ask") return;
+  try { unlinkSync(path); } catch {}
+}
+
 try {
   const raw = await readStdin();
   const input = JSON.parse(raw || "{}");
   const path = sidecarPath(input?.session_id);
   if (path) {
     const event = String(input.hook_event_name ?? "");
-    if (event === "PreToolUse" || event === "PermissionRequest") writeOpen(input, path);
+    if (event === "PreToolUse" && isRelayAsk(input.tool_name)) writeRelayAsk(input, path);
+    else if (event === "PreToolUse" || event === "PermissionRequest") writeOpen(input, path);
     else if (event === "PostToolUse" || event === "PostToolUseFailure") closeTool(input, path);
-    else if (event === "Stop") {
+    else if (event === "Stop") closeTurn(path);
+    else if (event === "UserPromptSubmit") {
       try { unlinkSync(path); } catch {}
     }
   }

package/hooks/hooks.json

@@ -25,6 +25,15 @@
             "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/prompt-focus.mjs"
           }
         ]
+      },
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/ask-sidecar.mjs"
+          }
+        ]
       }
     ],
     "PreToolUse": [
@@ -54,6 +63,15 @@
             "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/ask-sidecar.mjs"
           }
         ]
+      },
+      {
+        "matcher": "mcp__.*relay_ask",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/ask-sidecar.mjs"
+          }
+        ]
       }
     ],
     "PermissionRequest": [

package/lib/model-catalog.mjs

@@ -0,0 +1,123 @@
+// lib/model-catalog.mjs — the declarative model catalog (card #7777).
+//
+// configs/model-catalog.json records, per "<provider>/<model-id>": which API kinds it speaks,
+// context window, max output, input modalities, and — the part capabilities.json does not have —
+// an `effort` block mapping each crew difficulty (easy/medium/hard) to CONCRETE request
+// parameters PER API KIND (reasoning_effort, thinking, effort). Scores pick WHICH model; this
+// catalog says HOW to call it. A model missing from the catalog still works at its provider
+// default: lookup() returns an entry whose status says "not in catalog, provider default".
+//
+// Model ids come from `trantor models` / the provider adapters and CLI defaults — never typed
+// from memory — and every entry cites its limits with a url.
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
+export const CATALOG_PATH = process.env.TRANTOR_MODEL_CATALOG || join(ROOT, "configs", "model-catalog.json");
+export const UNCATALOGUED_STATUS = "not in catalog, provider default";
+
+let CACHE;
+export function loadCatalog(path = CATALOG_PATH) {
+  if (CACHE && path === CATALOG_PATH) return CACHE;
+  let cat;
+  try { cat = JSON.parse(readFileSync(path, "utf8")); } catch { cat = null; }
+  if (!cat || typeof cat !== "object") cat = { version: 0, models: {} };
+  if (!cat.models || typeof cat.models !== "object") cat.models = {};
+  if (path === CATALOG_PATH) CACHE = cat;
+  return cat;
+}
+
+const uncatalogued = (id) => ({ found: false, id, status: UNCATALOGUED_STATUS, api: [], effort: {} });
+
+// lookup(modelId) → the catalog entry (with found: true) or the uncatalogued default whose
+// status says "not in catalog, provider default". Matching order: exact key, then a seat/CLI
+// alias (kimi/codex/claude default entries carry `aliases`), then a bare id ("deepseek-v4-pro"
+// matches "deepseek/deepseek-v4-pro" — scrooge routes bare ids, the runner qualified ones).
+export function lookup(modelId, cat = loadCatalog()) {
+  const id = String(modelId || "").trim();
+  if (!id) return uncatalogued(id);
+  if (cat.models[id]) return { found: true, id, ...cat.models[id] };
+  for (const [key, entry] of Object.entries(cat.models)) {
+    if ((entry.aliases || []).includes(id)) return { found: true, id: key, ...entry };
+  }
+  const lower = id.toLowerCase();
+  for (const [key, entry] of Object.entries(cat.models)) {
+    if (key.toLowerCase().endsWith(`/${lower}`)) return { found: true, id: key, ...entry };
+  }
+  return uncatalogued(id);
+}
+
+// The request parameters one difficulty level maps to for one API kind. Returns null when the
+// model is uncatalogued (or the level is missing); an EMPTY object means catalogued but the
+// model takes no effort parameters (provider default — e.g. K2.7 Code thinks always).
+export function effortParams(modelId, difficulty, apiKind, cat = loadCatalog()) {
+  const entry = lookup(modelId, cat);
+  if (!entry.found) return null;
+  const level = entry.effort?.[difficulty];
+  if (!level) return null;
+  if (apiKind && level[apiKind] !== undefined) return level[apiKind];
+  const kinds = Object.keys(level);
+  return kinds.length === 1 ? level[kinds[0]] : null;
+}
+
+// Which wire API kind each delivery path speaks: codex talks the OpenAI Responses API, the
+// claude CLI talks anthropic-messages, every opencode-driven seat rides an openai-compatible
+// chat endpoint (the glm coding plan is openai-chat only, per its provider docs).
+const AGENT_API = { codex: "openai-responses", claude: "anthropic-messages", sonnet: "anthropic-messages" };
+const apiOfAgent = (agent) => AGENT_API[agent] || "openai-chat";
+
+// resolveEffort(agent, modelId, difficulty) → the launcher-side effort record that rides to the
+// runner as CREW_EFFORT. modelId may be empty for a CLI-default seat (kimi/codex/claude) — the
+// entry is then found through the agent alias. Always returns a record, so the runner can log
+// exactly one effort line per turn.
+export function resolveEffort(agent, modelId, difficulty, cat = loadCatalog()) {
+  const api = apiOfAgent(agent);
+  let entry = modelId ? lookup(modelId, cat) : uncatalogued("");
+  if (!entry.found && agent) {
+    const byAgent = lookup(agent, cat);
+    if (byAgent.found) entry = byAgent;
+  }
+  if (!entry.found) {
+    return { found: false, agent, model: modelId || agent || "", difficulty, api, status: UNCATALOGUED_STATUS };
+  }
+  const level = entry.effort?.[difficulty] || {};
+  let params = level[api];
+  if (params === undefined) {
+    const kinds = Object.keys(level);
+    params = kinds.length === 1 ? level[kinds[0]] : {};
+  }
+  return { found: true, agent, model: entry.id, difficulty, api, params: params && typeof params === "object" ? params : {} };
+}
+
+// cliEffortFlag(agent, effort) → { flag, text }: the per-CLI argument that carries the effort
+// parameters, plus the ONE log line the runner prints about it. Only the parameters a CLI can
+// actually carry are applied (codex: -c model_reasoning_effort; claude: --effort; opencode
+// seats: --variant, opencode's provider-specific reasoning effort); anything else stays at
+// provider default and the line says so.
+export function cliEffortFlag(agent, effort) {
+  if (!effort) return { flag: "", text: "" };
+  const difficulty = effort.difficulty || "?";
+  const model = effort.model || agent || "";
+  if (!effort.found) return { flag: "", text: `effort: ${model} ${UNCATALOGUED_STATUS}` };
+  const params = effort.params || {};
+  if (agent === "codex" && params.reasoning_effort) {
+    return {
+      flag: ` -c model_reasoning_effort="${params.reasoning_effort}"`,
+      text: `effort(${difficulty}): model_reasoning_effort=${params.reasoning_effort} set for ${model} (codex -c, catalog ${effort.api})`,
+    };
+  }
+  if ((agent === "claude" || agent === "sonnet") && params.effort) {
+    return {
+      flag: ` --effort ${params.effort}`,
+      text: `effort(${difficulty}): --effort ${params.effort} set for ${model} (catalog ${effort.api})`,
+    };
+  }
+  if (params.reasoning_effort) {
+    return {
+      flag: ` --variant ${params.reasoning_effort}`,
+      text: `effort(${difficulty}): --variant ${params.reasoning_effort} set for ${model} (opencode ${effort.api} reasoning_effort)`,
+    };
+  }
+  return { flag: "", text: `effort(${difficulty}): ${model} in catalog — no per-request effort parameters (provider default)` };
+}

package/lib/seat-record.mjs

@@ -0,0 +1,150 @@
+// #7762: the seat record is DERIVED, never a store. The hub already logs every card move
+// (/tasks cards carry history + the note log; /events keeps moves for aged-out cards) and the
+// runner's ledger rows (~/.agent-bus/logs/<seat>-<project>.jsonl) carry per-turn outcome +
+// tokens + card id. From those three this computes, PER PROJECT and PER SEAT, the last
+// RECORD_LIMIT cards as completed / empty / bounced:
+//   bounced — a testing→doing move by someone other than the seat (the assigner sent it back),
+//             or a HOLLOW: note on the card (#7750)
+//   completed — the card reached done with no bounce on its trail
+//   empty — the card never reached done and none of the seat's ledger turns on it completed
+//           (outcome empty/stalled/cut — the turn produced nothing)
+// relay_advise (bin/advise.mjs) benches a seat at a difficulty when its last STRIKE cards there
+// are all empty/bounced. The ONLY forgiveness paths: `trantor seat-record --reset <seat>`
+// (drops evidence older than the reset stamp) and new completed cards aging the bad ones out
+// of the STRIKE window — so no seat is blacklisted forever.
+import { readFileSync, writeFileSync, renameSync, readdirSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { busDir } from "./project.mjs";
+
+export const RECORD_LIMIT = 20;
+export const STRIKE = 3;
+
+// The roster token an assignee string routes by: "kimi:trantor" → "kimi".
+export const seatLabel = (assignee) => String(assignee || "").split(":")[0];
+
+const BAD_OUTCOMES = new Set(["empty", "bounced"]);
+// Turn outcomes that count as the seat having produced something. "asked" (#7756) is a real
+// answer-shaped turn, not a silent one; cut/stalled/empty produced nothing by definition.
+const PRODUCTIVE_OUTCOMES = new Set(["completed", "asked"]);
+
+export function resetsPathFor() {
+  return join(busDir(), "seat-record-resets.json");
+}
+
+// Pure. cards = full /tasks rows (history + log included — never fields=slim), events = /events
+// type=moved rows (bounce evidence for cards that aged off the board), ledger = runner jsonl
+// rows from every <seat>-<project>.jsonl, resets = { <seatLabel>: ts } for THIS project.
+export function computeSeatRecord({ cards = [], events = [], ledger = [], resets = {}, limit = RECORD_LIMIT } = {}) {
+  const byCard = new Map();
+  const ensure = (id) => {
+    let c = byCard.get(id);
+    if (!c) { c = { id, title: "", difficulty: "", seat: "", status: "", ts: 0, history: [], log: [] }; byCard.set(id, c); }
+    return c;
+  };
+  for (const t of cards) {
+    const c = ensure(t.id);
+    c.title = t.title || c.title;
+    c.difficulty = t.difficulty || c.difficulty;
+    c.seat = seatLabel(t.assignee) || c.seat;
+    c.status = t.status || c.status;
+    c.ts = Math.max(c.ts, Number(t.updated || t.ts) || 0);
+    if (Array.isArray(t.history)) c.history.push(...t.history);
+    if (Array.isArray(t.log)) c.log.push(...t.log);
+  }
+  // Moved events re-state what a live card's history already says (idempotent — classification
+  // is boolean) and are the only trail left for a card that aged out of the board's task cap.
+  for (const e of events) {
+    if (e?.type !== "moved" || !Number.isInteger(e.taskId)) continue;
+    const c = ensure(e.taskId);
+    c.title = c.title || e.title || "";
+    c.difficulty = c.difficulty || e.difficulty || "";
+    c.seat = c.seat || seatLabel(e.assignee);
+    c.ts = Math.max(c.ts, Number(e.ts) || 0);
+    c.history.push({ from: e.from, to: e.to, by: e.by, ts: e.ts });
+    if (e.to === "done") c.status = "done";
+  }
+  const rows = ledger.filter(r => r && Number.isInteger(r.card) && r.card > 0);
+  const seats = {};
+  for (const c of byCard.values()) {
+    if (!c.seat) continue;                       // unassigned cards say nothing about a seat
+    const resetTs = Number(resets[c.seat]) || 0;
+    const seatRows = rows.filter(r => seatLabel(r.agent) === c.seat && r.card === c.id && (Number(r.ts) || 0) > resetTs);
+    const bounced =
+      c.history.some(h => h.from === "testing" && h.to === "doing" && h.by && seatLabel(h.by) !== c.seat) ||
+      c.log.some(l => /^HOLLOW:/.test(String(l?.text || ""))) ||
+      c.history.some(h => /^HOLLOW:/.test(String(h?.note || "")));
+    let outcome = null;
+    if (bounced) outcome = "bounced";
+    else if (c.status === "done") outcome = "completed";
+    else if (seatRows.length && seatRows.every(r => !PRODUCTIVE_OUTCOMES.has(r.outcome))) outcome = "empty";
+    if (!outcome) continue;                      // in flight or no evidence — not a record entry
+    const ts = Math.max(c.ts, ...c.history.map(h => Number(h.ts) || 0), ...c.log.map(l => Number(l.ts) || 0), ...seatRows.map(r => Number(r.ts) || 0), 0);
+    if (ts <= resetTs) continue;                 // a reset wipes everything it postdates
+    const s = (seats[c.seat] ||= { cards: [], wastedTokens: 0 });
+    s.cards.push({ id: c.id, title: c.title, difficulty: c.difficulty, outcome, ts });
+    if (BAD_OUTCOMES.has(outcome)) s.wastedTokens += seatRows.reduce((sum, r) => sum + (Number(r.tokens) || 0), 0);
+  }
+  for (const s of Object.values(seats)) {
+    s.cards.sort((a, b) => a.ts - b.ts);
+    if (s.cards.length > limit) s.cards.splice(0, s.cards.length - limit);
+  }
+  return { seats };
+}
+
+// The bench rule: the seat's last STRIKE cards AT THIS DIFFICULTY were all empty/bounced.
+// Fewer than STRIKE cards is insufficient evidence — a new seat is never benched on one bad card.
+export function benchedAt(record, seat, difficulty) {
+  const atDiff = (record?.seats?.[seat]?.cards || []).filter(c => c.difficulty === difficulty).slice(-STRIKE);
+  if (atDiff.length < STRIKE || !atDiff.every(c => BAD_OUTCOMES.has(c.outcome))) return null;
+  return { streak: atDiff.map(c => c.outcome), cardIds: atDiff.map(c => c.id), wastedTokens: record.seats[seat].wastedTokens };
+}
+
+const readJson = (p, fb) => { try { return JSON.parse(readFileSync(p, "utf8")); } catch { return fb; } };
+
+// Reads the three live sources for `project` through hooks/lib/api.mjs signedGet (fail-open: any
+// unreachable piece yields an empty record — the advisor then routes exactly as before #7762).
+// `get` is injectable so the drill never touches a hub.
+export async function loadSeatRecord({ project, get, logDir, resetsPath } = {}) {
+  if (!project) return { seats: {} };
+  if (!get) {
+    try {
+      const { signedGet } = await import("../hooks/lib/api.mjs");
+      get = (path) => signedGet(path, { project });
+    } catch { return { seats: {} }; }
+  }
+  const [tasksR, eventsR] = await Promise.all([
+    get(`/tasks?project=${encodeURIComponent(project)}`),
+    get(`/events?project=${encodeURIComponent(project)}&type=moved&limit=2000`),
+  ]);
+  const cards = tasksR?.ok && Array.isArray(tasksR.json?.tasks) ? tasksR.json.tasks : [];
+  const events = eventsR?.ok && Array.isArray(eventsR.json?.events) ? eventsR.json.events : [];
+  const dir = logDir || join(homedir(), ".agent-bus", "logs");
+  const ledger = [];
+  try {
+    for (const f of readdirSync(dir)) {
+      if (!f.endsWith(`-${project}.jsonl`)) continue;
+      for (const line of readFileSync(join(dir, f), "utf8").split("\n")) {
+        if (!line.trim()) continue;
+        try { ledger.push(JSON.parse(line)); } catch {}
+      }
+    }
+  } catch {}
+  const resets = readJson(resetsPath || resetsPathFor(), {})?.[project] || {};
+  return computeSeatRecord({ cards, events, ledger, resets });
+}
+
+// The manual forgiveness path. Stamps now() for <seat> in <project>; evidence at or before the
+// stamp stops counting. Atomic write — a crash mid-reset must not corrupt every other project's.
+export function resetSeat({ project, seat, resetsPath, now = Date.now() } = {}) {
+  const p = resetsPath || resetsPathFor();
+  const all = readJson(p, {});
+  (all[project] ||= {})[seat] = now;
+  try {
+    mkdirSync(dirname(p), { recursive: true });
+    const tmp = `${p}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify(all, null, 2), { mode: 0o600 });
+    renameSync(tmp, p);
+    return true;
+  } catch { return false; }
+}

package/mcp.mjs

@@ -10,7 +10,8 @@ import { execSync, spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { createRequire } from "node:module";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { advise } from "./bin/advise.mjs";
+import { advise, loadWorld } from "./bin/advise.mjs";
+import { loadSeatRecord } from "./lib/seat-record.mjs";
 import { resolveProject, hostId, resolveHubInfo, nonSeatReason, handoffDir, orchWriterSid } from "./lib/project.mjs";
 import { signedPost, signedGet } from "./hooks/lib/api.mjs";
 import { anchorCursor } from "./hooks/lib/inbox-ledger.mjs";
@@ -258,7 +259,11 @@ server.tool("relay_advise", "THE ADVISOR — ask the brain how to execute a body
     packages: z.array(z.object({ title: z.string(), difficulty: z.enum(["easy","medium","hard"]).optional(), kind: z.string().optional() })).describe("the work packages you'd cut as cards"),
     horizon: z.enum(["short","medium","long"]).optional().describe("how long this build will run (default inferred from package count)") },
   async ({ task, packages, horizon }) => {
-    const out = advise({ task, packages, horizon });
+    // #7762: the advisor reads THIS project's seat record (derived, fail-open) so a seat whose
+    // recent cards produced nothing is benched at that difficulty instead of re-picked as cheap.
+    const world = loadWorld();
+    try { world.record = await loadSeatRecord({ project: PROJECT }); } catch {}
+    const out = advise({ task, packages, horizon }, world);
     return { content: [{ type: "text", text: JSON.stringify(out, null, 2) }] };
   });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.18.60",
+  "version": "0.18.61",
   "type": "module",
   "bin": {
     "trantor": "bin/cli.mjs"