@tablation/crew 0.78.0 → 0.78.1

package/dist/cli.js

@@ -230,6 +230,13 @@ function extractTurnTokens(line) {
   if (!usage2) return void 0;
   return (usage2.input_tokens ?? 0) + (usage2.output_tokens ?? 0) + (usage2.cache_read_input_tokens ?? 0) + (usage2.cache_creation_input_tokens ?? 0);
 }
+function extractPrefixTokens(line) {
+  const obj = line;
+  if (!obj || obj.type !== "assistant") return void 0;
+  const usage2 = obj.message?.usage;
+  if (!usage2) return void 0;
+  return (usage2.input_tokens ?? 0) + (usage2.cache_creation_input_tokens ?? 0);
+}
 function extractResult(line) {
   const obj = line;
   if (!obj || obj.type !== "result") return void 0;
@@ -580,6 +587,7 @@ var claudeAdapter = {
   mapStreamLine,
   extractResult,
   extractTurnTokens,
+  extractPrefixTokens,
   inspectMcp(o) {
     const s = inspectClaudeMcp(o);
     return s.state === "no-claude" ? { state: "no-binary" } : s;
@@ -5114,6 +5122,8 @@ async function reportAgentRun(target, run2) {
     cacheReadTokens: run2.cacheReadTokens,
     cacheWriteTokens: run2.cacheWriteTokens,
     costUsd: run2.costUsd,
+    numTurns: run2.numTurns,
+    prefixTokens: run2.prefixTokens,
     promptVersion: run2.promptVersion,
     promptSha: run2.promptSha
   };
@@ -5271,24 +5281,31 @@ function ticketMentions(text) {
 }
 var TicketAttributionTracker = class {
   #tokensByTicket = /* @__PURE__ */ new Map();
+  #turns = 0;
   #current;
   /** Tracker record uuid → ticket key, learned when a write names both (a claim resolves the key from the last mention). */
   #keyByRecord = /* @__PURE__ */ new Map();
   #lastBy = {};
-  /** The ticket key most recently named in the transcript, or undefined before any. */
+  /**
+   * The ticket key most recently named in the transcript, or undefined before any.
+   * Only the FIRST key in a turn counts: a closing summary names its own
+   * ticket first and then lists others ("Other tickets", "Blocked by", "See
+   * also"), and those trailing keys are not what the run worked (CREW-2598).
+   */
   get current() {
     return this.#current;
   }
   /** Record the mentions in `text` without crediting tokens (a claim needs "which ticket" before the turn's usage line arrives). */
   note(text) {
     const mentions = ticketMentions(text);
-    if (mentions.length > 0) this.#current = mentions[mentions.length - 1];
+    if (mentions.length > 0) this.#current = mentions[0];
   }
   /** One assistant turn: its combined visible text (thinking + text blocks) and its own token cost. */
   add(text, tokens) {
     const mentions = ticketMentions(text);
-    if (mentions.length > 0) this.#current = mentions[mentions.length - 1];
+    if (mentions.length > 0) this.#current = mentions[0];
     if (this.#current === void 0 || tokens <= 0) return;
+    this.#turns++;
     this.#tokensByTicket.set(this.#current, (this.#tokensByTicket.get(this.#current) ?? 0) + tokens);
   }
   /**
@@ -5310,16 +5327,31 @@ var TicketAttributionTracker = class {
   /**
    * How the attribution is decided: a hand-off write beats a claim, a claim
    * beats a comment (so a follow-up ticket filed or commented on while
-   * working never displaces the claimed one), and any write beats the
-   * mention-token heuristic, which is only the fallback for runs that made
-   * no ticket-targeted write. The pre-run hint is last.
+   * working never displaces the claimed one), and any write beats everything
+   * below. Next, `hintMoved` — the post-run read-back showed the hinted
+   * ticket changed status or assignee during the run — is a hand-off signal
+   * for a run that wrote through MCP tools crew cannot see. Then the
+   * mention-token heuristic, which with a hint may override it only when a
+   * different ticket holds a strict majority of the credited tokens (a single
+   * credited turn, like a lone end-of-run summary naming another ticket,
+   * must not). A run with no hint
+   * keeps the plain winner. The pre-run hint is last.
    */
-  decide(hint) {
+  decide(hint, opts = {}) {
     for (const by of ["handoff", "claim", "comment"]) {
       const ticket = this.#lastBy[by];
       if (ticket) return { ticket, by };
     }
-    if (this.#tokensByTicket.size > 0) return { ticket: this.winner(hint), by: "mentions" };
+    if (hint && opts.hintMoved) return { ticket: hint, by: "readback" };
+    if (this.#tokensByTicket.size > 0) {
+      if (!hint) return { ticket: this.winner(), by: "mentions" };
+      const winner = this.winner(hint);
+      if (winner === hint) return { ticket: hint, by: "mentions" };
+      let total = 0;
+      for (const n of this.#tokensByTicket.values()) total += n;
+      const share = (this.#tokensByTicket.get(winner) ?? 0) / total;
+      return share > 0.5 && this.#turns > 1 ? { ticket: winner, by: "mentions" } : { ticket: hint, by: "hint" };
+    }
     return { ticket: hint, by: "hint" };
   }
   /**
@@ -8467,6 +8499,8 @@ var RunObserver = class {
   /** Hand-off writes and their outcomes, to tell a run whose hand-off never landed (CREW-2363). */
   handoff = new HandoffTranscriptTracker();
   result;
+  /** Prefix tokens of the first assistant call that carried usage; kept once. */
+  prefixTokens;
   /** Set once the stream carries the harness's final result (turn count or cost). */
   sawResult = false;
   muted = false;
@@ -8593,6 +8627,7 @@ var RunObserver = class {
         }
       }
     }
+    if (this.prefixTokens === void 0 && parsed !== void 0) this.prefixTokens = this.adapter.extractPrefixTokens?.(parsed);
     const turnTokens = parsed === void 0 ? void 0 : this.adapter.extractTurnTokens(parsed);
     if (turnTokens !== void 0) this.attribution.add(turnText, turnTokens);
   }
@@ -8616,8 +8651,15 @@ function writeRunMeta(id, startedAt, liveTicket, extra) {
   } catch {
   }
 }
-async function finishRun(id, obs, emit, startedAt, end, agentLogKey) {
-  const { ticket: attributedTicket, by: attributedBy } = obs.attribution.decide(obs.liveTicket);
+async function finishRun(id, obs, emit, startedAt, end, agentLogKey, hintMoved) {
+  let moved = false;
+  if (hintMoved) {
+    try {
+      moved = await hintMoved();
+    } catch {
+    }
+  }
+  const { ticket: attributedTicket, by: attributedBy } = obs.attribution.decide(obs.liveTicket, { hintMoved: moved });
   const identity = { toolchain: id.toolchain, harness: id.harness, provider: id.provider };
   const { result } = obs;
   const pending = end.interrupted ? null : obs.handoff.pending();
@@ -8649,6 +8691,7 @@ async function finishRun(id, obs, emit, startedAt, end, agentLogKey) {
       ...pending ? { handoff: "pending" } : {},
       sessionId: result?.sessionId ?? null,
       numTurns: result?.numTurns ?? null,
+      prefixTokens: obs.prefixTokens ?? null,
       totalCostUsd: result?.costUsd ?? null
     });
   } catch {
@@ -8661,6 +8704,8 @@ async function finishRun(id, obs, emit, startedAt, end, agentLogKey) {
       ...pending ? { handoff: "pending" } : {},
       ...end.interrupted ? { interrupted: end.interrupted } : {},
       ...identity,
+      attributedTicket: attributedTicket ?? null,
+      attributedBy,
       ...result?.sessionId ? { sessionId: result.sessionId } : {},
       ...result?.numTurns !== void 0 ? { numTurns: result.numTurns } : {},
       ...result?.costUsd !== void 0 ? { totalCostUsd: result.costUsd } : {}
@@ -8679,6 +8724,9 @@ async function finishRun(id, obs, emit, startedAt, end, agentLogKey) {
       cacheReadTokens: result?.cacheReadTokens,
       cacheWriteTokens: result?.cacheWriteTokens,
       costUsd: result?.costUsd,
+      // Both come from a finished run: without the result line (interrupted) neither is trustworthy.
+      ...result?.numTurns !== void 0 ? { numTurns: result.numTurns } : {},
+      ...result?.numTurns !== void 0 && obs.prefixTokens !== void 0 ? { prefixTokens: obs.prefixTokens } : {},
       harness: identity.harness,
       provider: identity.provider,
       promptVersion: id.promptVersion,
@@ -8723,7 +8771,7 @@ async function finishRun(id, obs, emit, startedAt, end, agentLogKey) {
   }
   return { ms: ms2, ticket: attributedTicket, handoffPending: !!pending };
 }
-function spawnAgent(plan, emit) {
+function spawnAgent(plan, emit, hintMoved) {
   const adapter = adapterFor(plan.harness ?? LEGACY_TOOLCHAIN_HARNESS);
   const started = Date.now();
   const startedAt = new Date(started).toISOString();
@@ -8788,7 +8836,7 @@ function spawnAgent(plan, emit) {
       obs.end();
       await endSink(eventsSink);
       if (spawnFailed) return;
-      const { ms: ms2, handoffPending } = await finishRun(id, obs, emit, startedAt, { code: code ?? 1 }, plan.agentLog?.apiKey);
+      const { ms: ms2, handoffPending } = await finishRun(id, obs, emit, startedAt, { code: code ?? 1 }, plan.agentLog?.apiKey, hintMoved);
       resolve6({ code: code ?? 1, ms: ms2, ...handoffPending ? { handoffPending } : {} });
     });
     child.stdin?.on("error", (err) => {
@@ -16914,7 +16962,19 @@ async function runRoleAgent(role, decision, ctx) {
   }
   try {
     const runStart = (/* @__PURE__ */ new Date()).toISOString();
-    await spawnAgent(plan, emit);
+    let hintMoved;
+    if (workingId) {
+      try {
+        const before = await tracker.ticket(workingId);
+        const col = tracker.contract.columns;
+        hintMoved = async () => {
+          const after = await tracker.ticket(workingId);
+          return after[col.status] !== before[col.status] || after[col.assignee] !== before[col.assignee];
+        };
+      } catch {
+      }
+    }
+    await spawnAgent(plan, emit, hintMoved);
     await guardRunHandoff(route, ship, tracker, role, workingId, emit, runStart);
   } finally {
     if (memberId) {
@@ -19383,7 +19443,7 @@ ${changed2.map((c) => `  - ${c}
           }
           for (const e of entries) {
             process.stdout.write(
-              `${e.id}  ${e.started_at ?? "?"}  ${e.outcome ?? "?"}${e.ticket_reference ? `  ${e.ticket_reference}` : ""}${e.model ? `  ${e.model}` : ""}${e.harness || e.provider ? `  (${[e.harness, e.provider].filter(Boolean).join(" \xB7 ")})` : ""}
+              `${e.id}  ${e.started_at ?? "?"}  ${e.outcome ?? "?"}${e.ticket_reference ? `  ${e.ticket_reference}` : ""}${e.model ? `  ${e.model}` : ""}${e.harness || e.provider ? `  (${[e.harness, e.provider].filter(Boolean).join(" \xB7 ")})` : ""}${e.num_turns != null ? `  turns ${e.num_turns}` : ""}${e.prefix_tokens != null ? `  prefix ${e.prefix_tokens}` : ""}
 `
             );
           }
@@ -19401,7 +19461,9 @@ ticket:     ${entry.ticket_reference ?? "(none)"}
 model:      ${entry.model ?? "?"}
 harness:    ${entry.harness ?? "?"}
 provider:   ${entry.provider ?? "?"}
-`
+` + (entry.num_turns != null ? `turns:      ${entry.num_turns}
+` : "") + (entry.prefix_tokens != null ? `prefix:     ${entry.prefix_tokens} tokens
+` : "")
           );
           if (flag("prompt")) {
             process.stdout.write(`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablation/crew",
-  "version": "0.78.0",
+  "version": "0.78.1",
   "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",