trantor 0.18.106 → 0.18.108

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.18.106",
+  "version": "0.18.108",
   "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/crew-runner.mjs

@@ -39,13 +39,13 @@ import {
 } from "../lib/duty-nudges.mjs";
 import { reserveNudgeIds, releaseNudgeIds } from "../lib/nudge-ledger.mjs";
 import { dutyRecipientResolver } from "../lib/duty-recipient.mjs";
-import { cliEffortFlag, contextWindow } from "../lib/model-catalog.mjs";
+import { cliEffortFlag, contextWindow, effortForTurn } from "../lib/model-catalog.mjs";
 import {
   BREAKER_WINDOW, STATE_ENV, TURN_RESULT_SCHEMA,
   breakerVerdict, describeTurn, hasJsonSchemaFlag, parseEnvelope, renderCardTail, runStep,
 } from "../lib/state/driver.mjs";
 import { costLine } from "../lib/state/cost.mjs";
-import { resolveStateFlags } from "../lib/state/flags.mjs";
+import { resolveStateFlags, stateFeatureOn } from "../lib/state/flags.mjs";
 
 import { awaitSwapRelease } from "./crew/stage.mjs";
 
@@ -660,7 +660,8 @@ const stateFlags = resolveStateFlags();
 for (const [name, flag] of Object.entries(stateFlags)) {
   if (flag.value && process.env[name] === undefined) process.env[name] = flag.value;
 }
-const STATE_FLAG_ON = process.env[STATE_ENV] === "1";
+// TRANTOR_STATE=0 is the master kill switch (#12070): it beats an ASSEMBLE=1 from any layer.
+const STATE_FLAG_ON = stateFeatureOn(STATE_ENV, stateFlags, ["1"]);
 const STATE_SCHEMA_FILE = join(homedir(), ".agent-bus", `state-schema-${PERSONA}-${PROJ}.json`);
 const STATE_MODE = (() => {
   if (!STATE_FLAG_ON) return false;
@@ -837,12 +838,13 @@ async function runTurn(prompt, isFirst, trigger = "kickoff", opts = {}) {
   // #10197: the card status snapshot the turn is judged against at its end — a move to
   // testing/done under the turn is delivery even without a commit. null = the hub read failed:
   // the delivery check stands down rather than claim no-delivery on a transport error.
-  let cardStatusBefore = null, cardLogBefore = [];
+  let cardStatusBefore = null, cardLogBefore = [], cardDifficulty = "";
   if (!opts.state && sessionCard > 0) {
     try {
       const { task } = await api(`/card?project=${encodeURIComponent(PROJ)}&id=${sessionCard}`);
       cardStatusBefore = task ? String(task.status || "") : null;
       cardLogBefore = task?.log || [];
+      cardDifficulty = task?.difficulty || "";
     } catch { cardStatusBefore = null; }
   }
   // #9778: the docker snapshot the turn is judged against — containers the CLI spawns are recorded
@@ -857,7 +859,9 @@ 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}` : "") + EFFORT_FLAG.flag;
+  // Effort follows the bound card's difficulty each turn; kickoff, pulse and unreadable cards keep the launch effort.
+  const turnEffort = effortForTurn({ agent: DRIVER, model: MODEL, launchEffort: EFFORT, cardDifficulty });
+  const mfrag = (MODEL && cli.mflag ? `${cli.mflag}${MODEL}` : "") + turnEffort.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
@@ -869,7 +873,8 @@ async function runTurn(prompt, isFirst, trigger = "kickoff", opts = {}) {
   cmd = withEnvFiles(withSecretExports(seatSignalPrefix(TURN_DIR) + cmd, Object.keys(secrets)), 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);
+  if (turnEffort.changed) log(`effort: ${turnEffort.effort.difficulty} for #${sessionCard} (launch ${EFFORT?.difficulty || "none"}) — ${turnEffort.text}`);
+  else if (EFFORT && EFFORT_FLAG.text) log(EFFORT_FLAG.text);
   // #11559: the one compaction line — only where the block actually rides the spawn.
   if (cli.pinned && OC_COMPACTION) log(ocCompactionLogLine(OC_COMPACTION_WINDOW));
   cmuxStatus("building", "#4a90d9", "hammer", { priority: 50 }); herdrAgent("working");

package/bin/doctor.mjs

@@ -14,6 +14,7 @@ import { sfetchJson } from "../lib/signed-fetch.mjs";
 import { scan } from "../lib/splitbrain.mjs";
 import { resolveSecrets, envFileSecrets, backendFor } from "../lib/secrets.mjs";
 import { resolveStateFlags } from "../lib/state/flags.mjs";
+import { probeClaudeIntegration, HERDR_CLAUDE_INSTALL } from "../lib/herdr-integration.mjs";
 
 const H = homedir();
 const ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
@@ -182,6 +183,17 @@ else {
     : warn("plugin not installed", "claude plugin marketplace add sashabogi/trantor && claude plugin install trantor");
 }
 
+// herdr's own claude integration reports the session id at SessionStart; without it the desktop app
+// cannot tell which session a pane is running. Read-only probe, and an odd answer is "unknown".
+section("herdr (session identity)");
+{
+  const h = probeClaudeIntegration();
+  if (h.state === "absent") note("herdr: skipped (not installed)");
+  else if (h.state === "installed") ok(`herdr claude integration installed (${h.detail})`);
+  else if (h.state === "unknown") note(`herdr claude integration: unknown (${h.detail})`);
+  else warn(h.state === "outdated" ? `herdr claude integration is outdated (${h.detail})` : "herdr claude integration is not installed", HERDR_CLAUDE_INSTALL);
+}
+
 // crew CLIs: installed / wired / authenticated
 section("crew CLIs (install any subset — seats follow the work)");
 const CLIS = [

package/hooks/lib/handoff.mjs

@@ -18,6 +18,7 @@ import { resolveProject, orchSessionsPath, hostId } from "../../lib/project.mjs"
 // attachState async on a path that is deliberately synchronous.
 import { statePath, readState } from "../../lib/state/store.mjs";
 import { stateError } from "../../lib/state/schema.mjs";
+import { resolveStateFlags, stateFeatureOn } from "../../lib/state/flags.mjs";
 import { deriveState } from "../../lib/state/derive.mjs";
 
 // Writer and reader MUST resolve the same directory — see lib/project.mjs busDir(). This used to
@@ -59,6 +60,7 @@ export function contextUsage(transcriptPath, conf = readConfig()) {
   let model = "";
   for (const line of lines) {
     let r; try { r = JSON.parse(line); } catch { continue; }
+    if (r?.type === "system" && r?.subtype === "compact_boundary") { rows.push("compact"); continue; }
     const u = r?.message?.usage;
     if (r?.type !== "assistant" || !u) continue;
     const tokens = (u.input_tokens || 0) + (u.cache_read_input_tokens || 0) + (u.cache_creation_input_tokens || 0);
@@ -78,6 +80,8 @@ export function guardContextTokens(rows) {
   let max = 0;
   const recent = [];
   for (const t of rows) {
+    // a compaction starts the session over: readings before it say nothing about the window now
+    if (t === "compact") { max = 0; recent.length = 0; continue; }
     if (!t || t <= 0) continue;
     recent.push(t);
     if (recent.length > 5) recent.shift();
@@ -441,9 +445,11 @@ export function capSummary(text, cap = 4096) {
 // `state` rides beside it, validated on write and NEVER capped, so capSummary cannot eat a member (#6528).
 
 /** Dark by default. The prose path is untouched either way; this flag only decides whether the
- *  structured field is built and rendered (TDD §4.5, "Fallback"). */
-export function stateHandoffEnabled(env = process.env) {
-  return ["1", "true", "on", "yes"].includes(String(env.TRANTOR_STATE_HANDOFF || "").toLowerCase());
+ *  structured field is built and rendered (TDD §4.5, "Fallback"). The hooks never source
+ *  ~/.agent-bus/.env, so the flag resolves like the runner's: process env first, that file second
+ *  (#12069), and a TRANTOR_STATE=0 master switch turns it off (#12070). */
+export function stateHandoffEnabled(env = process.env, file) {
+  return stateFeatureOn("TRANTOR_STATE_HANDOFF", resolveStateFlags(env, file));
 }
 
 /** The bus id of the seat writing this handoff — the same resolution sessionstart.mjs uses, so a

package/lib/herdr-integration.mjs

@@ -0,0 +1,28 @@
+// Is herdr's own claude integration installed? Session identity in the desktop app relies on it
+// reporting the session at SessionStart (pane.report_agent_session), and nothing else checks it.
+import { spawnSync } from "node:child_process";
+
+export const HERDR_CLAUDE_INSTALL = "herdr integration install claude";
+
+/** Decide from `herdr integration status` output (pure; `ran` false = herdr would not start).
+ *  Returns { state: absent | installed | outdated | missing | unknown, detail }; an unrecognised
+ *  shape is "unknown", never an error. */
+export function claudeIntegrationState({ ran, status = 0, stdout = "" } = {}) {
+  if (!ran) return { state: "absent", detail: "herdr is not installed" };
+  if (status !== 0) return { state: "unknown", detail: `herdr integration status exited ${status}` };
+  const line = String(stdout).split("\n").map((l) => l.trim()).find((l) => l.startsWith("claude:"));
+  if (!line) return { state: "unknown", detail: "no claude line in the herdr integration status output" };
+  const rest = line.slice("claude:".length).trim();
+  if (/^not installed\b/i.test(rest)) return { state: "missing", detail: rest };
+  if (/^outdated\b/i.test(rest)) return { state: "outdated", detail: rest };
+  if (/^current\b/i.test(rest)) return { state: "installed", detail: rest };
+  return { state: "unknown", detail: rest };
+}
+
+/** Run the read-only probe. A missing binary, a timeout or a crash all fold into the decision. */
+export function probeClaudeIntegration(run = spawnSync) {
+  const r = run("herdr", ["integration", "status"], { encoding: "utf8", timeout: 5000 });
+  if (r.error?.code === "ENOENT") return claudeIntegrationState({ ran: false });
+  if (r.error) return { state: "unknown", detail: String(r.error.message || r.error) };
+  return claudeIntegrationState({ ran: true, status: r.status ?? 1, stdout: r.stdout });
+}

package/lib/model-catalog.mjs

@@ -119,3 +119,17 @@ export function cliEffortFlag(agent, effort) {
   }
   return { flag: "", text: `effort(${difficulty}): ${model} in catalog — no per-request effort parameters (provider default)` };
 }
+
+// effortForTurn: the effort a single turn runs at. A bound card's easy/medium/hard difficulty wins
+// over the launch effort; anything else (no card, unknown value, CLI with no flag) keeps launch.
+export function effortForTurn({ agent, model, launchEffort, cardDifficulty }, cat = loadCatalog()) {
+  const launch = { effort: launchEffort || null, ...(launchEffort ? cliEffortFlag(agent, launchEffort) : { flag: "", text: "" }) };
+  const d = String(cardDifficulty || "").toLowerCase();
+  if (!["easy", "medium", "hard"].includes(d) || d === launchEffort?.difficulty) return { ...launch, changed: false };
+  try {
+    const effort = resolveEffort(agent, model || launchEffort?.model || "", d, cat);
+    const cli = cliEffortFlag(agent, effort);
+    if (!cli.flag) return { ...launch, changed: false };
+    return { effort, ...cli, changed: true };
+  } catch { return { ...launch, changed: false }; }
+}

package/lib/state/flags.mjs

@@ -14,9 +14,15 @@ export const STATE_ENV = "TRANTOR_STATE_ASSEMBLE";
 // resolution cannot drift apart.
 export const STATE_FLAGS = ["TRANTOR_STATE", "TRANTOR_STATE_ASSEMBLE", "TRANTOR_STATE_HANDOFF", "TRANTOR_STATE_GATE"];
 
+/** The crew .env. AGENT_BUS_DIR (already how tests and the handoff dir are redirected) moves it too,
+ *  so a run pointed at a scratch bus never reads the operator's real file. */
+export function defaultFlagsFile(env = process.env) {
+  return join(env.AGENT_BUS_DIR || join(homedir(), ".agent-bus"), ".env");
+}
+
 /** `{ [name]: { value, layer } }` per flag; layer is "process env", "~/.agent-bus/.env (crew)" or
  *  "unset". Pure — env in, no writes — so the doctor reports the same answer the runner got. */
-export function resolveStateFlags(env = process.env, file = join(homedir(), ".agent-bus", ".env")) {
+export function resolveStateFlags(env = process.env, file = defaultFlagsFile(env)) {
   const fromFile = parseEnvFile(file);   // a missing file parses to {}
   return Object.fromEntries(STATE_FLAGS.map((name) => {
     if (env[name] !== undefined) return [name, { value: env[name], layer: "process env" }];
@@ -24,3 +30,18 @@ export function resolveStateFlags(env = process.env, file = join(homedir(), ".ag
     return [name, { value: "", layer: "unset" }];
   }));
 }
+
+const OFF_VALUES = ["0", "false", "off", "no"];
+
+/** True when TRANTOR_STATE resolved to an explicit off value: the master kill switch. Unset or any
+ *  other value leaves the sub-flags in charge. */
+export function stateMasterOff(resolved) {
+  return OFF_VALUES.includes(String(resolved?.TRANTOR_STATE?.value ?? "").trim().toLowerCase());
+}
+
+/** Whether one state sub-feature (e.g. TRANTOR_STATE_HANDOFF) is on: the master switch wins, then
+ *  the sub-flag's own value. `on` lists the values that count as on (ASSEMBLE accepts only "1"). */
+export function stateFeatureOn(name, resolved, on = ["1", "true", "on", "yes"]) {
+  if (stateMasterOff(resolved)) return false;
+  return on.includes(String(resolved?.[name]?.value ?? "").trim().toLowerCase());
+}

package/package.json

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