@tablation/crew 0.76.0 → 0.77.0

package/dist/cli.js

@@ -4853,6 +4853,158 @@ function renderEnvironment(i) {
   return lines.join("\n");
 }
 
+// src/contract.ts
+var DEFAULT_CONTRACT = {
+  columns: {
+    key: "issue_id",
+    tag: "issue_tag",
+    title: "title",
+    status: "status",
+    assignee: "assignee_id",
+    priority: "priority",
+    severity: "severity",
+    slice: "project_id",
+    repo: "repo_id",
+    parent: "parent_id",
+    blockedBy: "blocked_by",
+    updatedAt: "updated_at",
+    needsDesign: "needs_design",
+    attachments: "attachments",
+    workMode: "work_mode",
+    reportType: "report_type",
+    epic: "epic_id",
+    author: "filed_by_id",
+    ship: "ship_id",
+    heldBy: "held_by_ship_id",
+    resolutionNote: "resolution_note",
+    verifiedSha: "verified_sha",
+    prRef: "pr_ref",
+    externalId: "external_id",
+    position: "position",
+    agentRuns: "agent_runs",
+    tokensIn: "tokens_in",
+    tokensOut: "tokens_out",
+    cacheReadTokens: "cache_read_tokens",
+    cacheWriteTokens: "cache_write_tokens",
+    costUsd: "cost_usd"
+  },
+  comments: {
+    parent: "ticket_id",
+    body: "body",
+    author: "team_member_id",
+    createdAt: "created_at",
+    ship: "ship_id",
+    publicReply: "is_public_reply",
+    authorName: "author_name"
+  },
+  statuses: {
+    open: ["new", "accepted", "blocked", "in_progress", "needs_info", "fixed", "qa", "verified"],
+    resolved: [
+      "verified",
+      "closed_deployed",
+      "closed_wont_fix",
+      "closed_duplicate",
+      "closed_completed",
+      "closed_cant_reproduce"
+    ],
+    approved: "accepted",
+    parked: "blocked",
+    building: "in_progress",
+    handoff: "fixed",
+    verifying: "qa",
+    verified: "verified",
+    deployed: "closed_deployed",
+    needsHuman: "needs_info",
+    reviewing: null,
+    wontFix: "closed_wont_fix",
+    draft: "draft"
+  },
+  epics: {
+    statusColumn: "status",
+    keyColumn: "epic_id",
+    statuses: { planned: "planned", building: "in_progress", done: "done", cancelled: "cancelled" }
+  },
+  priorityOrder: ["p0", "p1", "p2", "p3"],
+  severityOrder: ["s1", "s2", "s3", "s4"],
+  unknownPriorityRank: 2,
+  coordinatingValue: "coordinating",
+  manualWorkMode: "manual",
+  hybridWorkMode: "hybrid",
+  repoExemptReportTypes: ["coordinating", "question", "investigation"]
+};
+function closedStatuses(c) {
+  return c.statuses.resolved.filter((s) => s !== c.statuses.verified);
+}
+function resolveContract(override) {
+  if (!override) return DEFAULT_CONTRACT;
+  return {
+    columns: { ...DEFAULT_CONTRACT.columns, ...override.columns },
+    comments: { ...DEFAULT_CONTRACT.comments, ...override.comments },
+    statuses: { ...DEFAULT_CONTRACT.statuses, ...override.statuses },
+    epics: {
+      ...DEFAULT_CONTRACT.epics,
+      ...override.epics,
+      statuses: { ...DEFAULT_CONTRACT.epics.statuses, ...override.epics?.statuses }
+    },
+    priorityOrder: override.priorityOrder ?? DEFAULT_CONTRACT.priorityOrder,
+    severityOrder: override.severityOrder ?? DEFAULT_CONTRACT.severityOrder,
+    unknownPriorityRank: override.unknownPriorityRank ?? DEFAULT_CONTRACT.unknownPriorityRank,
+    coordinatingValue: override.coordinatingValue ?? DEFAULT_CONTRACT.coordinatingValue,
+    manualWorkMode: override.manualWorkMode ?? DEFAULT_CONTRACT.manualWorkMode,
+    hybridWorkMode: override.hybridWorkMode ?? DEFAULT_CONTRACT.hybridWorkMode,
+    // A workspace overriding `coordinatingValue` alone (renaming the rollup
+    // marker) still gets that renamed value exempted here by default,
+    // without also having to repeat it — only an explicit
+    // `repoExemptReportTypes` overrides this derived default.
+    repoExemptReportTypes: override.repoExemptReportTypes ?? (override.coordinatingValue ? [override.coordinatingValue, "question", "investigation"] : DEFAULT_CONTRACT.repoExemptReportTypes)
+  };
+}
+function validateContract(c) {
+  const problems = [];
+  const open = new Set(c.statuses.open);
+  const resolved = new Set(c.statuses.resolved);
+  for (const role of ["approved", "parked", "building", "handoff", "verifying", "needsHuman"]) {
+    const v = c.statuses[role];
+    if (!open.has(v)) problems.push(`statuses.${role} ("${v}") is not listed in statuses.open`);
+  }
+  if (c.statuses.reviewing && !open.has(c.statuses.reviewing)) {
+    problems.push(`statuses.reviewing ("${c.statuses.reviewing}") is not listed in statuses.open`);
+  }
+  if (!resolved.has(c.statuses.deployed)) {
+    problems.push(`statuses.deployed ("${c.statuses.deployed}") is not listed in statuses.resolved`);
+  }
+  if (resolved.has(c.statuses.handoff)) {
+    problems.push(
+      `statuses.handoff ("${c.statuses.handoff}") is listed as resolved \u2014 it means built-but-unchecked, so a ticket blocked by it is still blocked; calling it resolved would build on unverified work`
+    );
+  }
+  if (!resolved.has(c.statuses.wontFix)) {
+    problems.push(`statuses.wontFix ("${c.statuses.wontFix}") is not listed in statuses.resolved`);
+  }
+  if (c.statuses.reviewing && resolved.has(c.statuses.reviewing)) {
+    problems.push(
+      `statuses.reviewing ("${c.statuses.reviewing}") is listed as resolved \u2014 it is unmerged work under review, so a ticket blocked by it is still blocked`
+    );
+  }
+  if (resolved.has(c.statuses.approved)) {
+    problems.push(`statuses.approved ("${c.statuses.approved}") is listed as resolved`);
+  }
+  if (c.statuses.parked === c.statuses.approved) {
+    problems.push("statuses.parked and statuses.approved are the same value \u2014 parking would be a no-op");
+  }
+  const epicValues = Object.values(c.epics.statuses);
+  if (new Set(epicValues).size !== epicValues.length) {
+    problems.push("epics.statuses names the same value twice \u2014 the epic sync could not tell those states apart");
+  }
+  if (c.priorityOrder.length === 0) problems.push("priorityOrder is empty");
+  if (c.severityOrder.length === 0) problems.push("severityOrder is empty");
+  for (const [name, order] of [["priorityOrder", c.priorityOrder], ["severityOrder", c.severityOrder]]) {
+    if (new Set(order).size !== order.length) problems.push(`${name} contains duplicates`);
+  }
+  return problems;
+}
+var EVENT_LOG_MISSING = "the Issues table has no event log \u2014 crew writes its audit trail there (CREW-1574). In the app, open the Issues table's Data & lifecycle tab and turn on Event log, then rerun.";
+
 // src/agent-log.ts
 import { existsSync as existsSync11, mkdirSync as mkdirSync6, readdirSync as readdirSync4, readFileSync as readFileSync11, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "fs";
 import { join as join12 } from "path";
@@ -4870,6 +5022,61 @@ var AgentLogHttpError = class extends Error {
     this.status = status2;
   }
 };
+async function request(target, method, path, body) {
+  const url = `${target.baseUrl.replace(/\/+$/, "")}/api${path}`;
+  const res = await fetch(url, {
+    method,
+    headers: {
+      Authorization: `Bearer ${target.apiKey}`,
+      "User-Agent": target.userAgent,
+      ...body === void 0 ? {} : { "Content-Type": "application/json" }
+    },
+    body: body === void 0 ? void 0 : JSON.stringify(body)
+  });
+  if (!res.ok) throw new AgentLogHttpError(`${path}: ${res.status} ${res.statusText}`, res.status);
+  return await res.json();
+}
+var issueColumns = /* @__PURE__ */ new Map();
+function columnsOf(target, modelId) {
+  const key = `${target.baseUrl}|${target.workspaceId}|${modelId}`;
+  let p = issueColumns.get(key);
+  if (!p) {
+    p = request(target, "GET", `/data-models/${modelId}`).then((m) => new Set((m.fields ?? []).map((f) => f.columnName)));
+    p.catch(() => issueColumns.delete(key));
+    issueColumns.set(key, p);
+  }
+  return p;
+}
+async function findTicketRecord(target, t, ref) {
+  const filters = {
+    combinator: "OR",
+    conditions: [
+      { columnName: t.keyColumn, operator: "EQ", value: ref },
+      { columnName: t.tagColumn, operator: "EQ", value: ref }
+    ]
+  };
+  const rows = await request(
+    target,
+    "GET",
+    `/data-models/${t.issuesModelId}/records?limit=2&filters=${encodeURIComponent(JSON.stringify(filters))}`
+  );
+  return rows.length === 1 ? rows[0].id : void 0;
+}
+function counterIncrements(run2, cols, have) {
+  const figures = [
+    [cols.agentRuns, 1],
+    [cols.tokensIn, run2.tokensIn],
+    [cols.tokensOut, run2.tokensOut],
+    [cols.cacheReadTokens, run2.cacheReadTokens],
+    [cols.cacheWriteTokens, run2.cacheWriteTokens],
+    [cols.costUsd, run2.costUsd]
+  ];
+  const out = {};
+  for (const [column, value2] of figures) {
+    if (value2 !== void 0 && Number.isFinite(value2) && have.has(column)) out[column] = { $op: "increment", value: value2 };
+  }
+  return out;
+}
 async function post(target, path, body) {
   const url = `${target.baseUrl.replace(/\/+$/, "")}/api/workspaces/${target.workspaceId}${path}`;
   const res = await fetch(url, {
@@ -4886,6 +5093,13 @@ async function post(target, path, body) {
   return await res.json();
 }
 async function reportAgentRun(target, run2) {
+  let ticketRecordId;
+  if (target.tickets && run2.ticketReference) {
+    try {
+      ticketRecordId = await findTicketRecord(target, target.tickets, run2.ticketReference);
+    } catch {
+    }
+  }
   const body = {
     agentId: target.agentId,
     ticketReference: run2.ticketReference,
@@ -4903,13 +5117,14 @@ async function reportAgentRun(target, run2) {
     promptVersion: run2.promptVersion,
     promptSha: run2.promptSha
   };
+  const workItem = target.tickets && ticketRecordId ? { workItemTable: target.tickets.issuesModelId, workItemRecordId: ticketRecordId } : {};
   let entry;
   try {
-    entry = await post(target, "/agents/log", { ...body, harness: run2.harness, provider: run2.provider });
+    entry = await post(target, "/agents/log", { ...body, ...workItem, harness: run2.harness, provider: run2.provider });
   } catch (e) {
     if (!(e instanceof AgentLogHttpError)) throw new AgentLogUnreachableError(e.message);
     if (e.status >= 500) throw new AgentLogUnreachableError(e.message);
-    if (!(e instanceof AgentLogHttpError) || e.status !== 400 || !run2.harness && !run2.provider) throw e;
+    if (e.status !== 400 || !run2.harness && !run2.provider && !ticketRecordId) throw e;
     entry = await post(target, "/agents/log", body);
   }
   for (const cycle of run2.cycles) {
@@ -4920,7 +5135,37 @@ async function reportAgentRun(target, run2) {
       ...cycle.role ? { role: cycle.role } : {}
     });
   }
-  return { agentLogId: entry.id };
+  const counters = target.tickets && ticketRecordId ? await addRunToTicket(target, target.tickets, ticketRecordId, run2) : void 0;
+  return {
+    agentLogId: entry.id,
+    ...counters?.warning ? { counterWarning: counters.warning } : {},
+    ...counters?.retry ? { counterRetry: counters.retry } : {}
+  };
+}
+var isRetryable = (e) => !(e instanceof AgentLogHttpError) || e.status >= 500;
+async function writeCounters(target, w) {
+  const have = await columnsOf(target, w.issuesModelId);
+  const body = Object.fromEntries(Object.entries(w.body).filter(([column]) => have.has(column)));
+  if (Object.keys(body).length === 0) return;
+  await request(target, "PATCH", `/data-models/${w.issuesModelId}/records/${w.recordId}`, body);
+}
+async function addRunToTicket(target, t, recordId, run2) {
+  const write = {
+    issuesModelId: t.issuesModelId,
+    recordId,
+    ticketReference: run2.ticketReference,
+    counters: t.counters,
+    body: counterIncrements(run2, t.counters, new Set(Object.values(t.counters)))
+  };
+  try {
+    await writeCounters(target, write);
+    return {};
+  } catch (e) {
+    return {
+      warning: `could not add run spend to ${run2.ticketReference}: ${e.message}`,
+      ...isRetryable(e) ? { retry: write } : {}
+    };
+  }
 }
 var queueDir = (stateDir) => join12(stateDir, "pending-agent-logs");
 function queueAgentRun(stateDir, name, q) {
@@ -4943,7 +5188,17 @@ async function replayQueuedAgentRuns(stateDir, route, keyFor, log, now = /* @__P
     try {
       const apiKey = await keyFor(q.role);
       if (!apiKey) continue;
-      await reportAgentRun({ ...q.target, apiKey }, q.report);
+      const sentRun = await reportAgentRun({ ...q.target, apiKey }, q.report);
+      if (sentRun.counterWarning) log.warn(sentRun.counterWarning);
+      if (sentRun.counterRetry) queueTicketCounters(stateDir, f.replace(/\.json$/, ""), {
+        version: 1,
+        route: q.route,
+        role: q.role,
+        target: q.target,
+        write: sentRun.counterRetry,
+        attempts: 0,
+        nextAttemptAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
       rmSync6(path, { force: true });
       sent += 1;
       log.emit(`sent a queued Agent Log report (${f})`);
@@ -4965,6 +5220,49 @@ async function replayQueuedAgentRuns(stateDir, route, keyFor, log, now = /* @__P
   }
   return sent;
 }
+var countersDir = (stateDir) => join12(stateDir, "pending-ticket-counters");
+function queueTicketCounters(stateDir, name, q) {
+  mkdirSync6(countersDir(stateDir), { recursive: true });
+  writeFileSync7(join12(countersDir(stateDir), `${name}.json`), JSON.stringify(q));
+}
+async function replayQueuedTicketCounters(stateDir, route, keyFor, log, now = /* @__PURE__ */ new Date()) {
+  const dir = countersDir(stateDir);
+  if (!existsSync11(dir)) return 0;
+  let sent = 0;
+  for (const f of readdirSync4(dir).filter((n) => n.endsWith(".json")).sort()) {
+    const path = join12(dir, f);
+    let q;
+    try {
+      q = JSON.parse(readFileSync11(path, "utf8"));
+    } catch {
+      continue;
+    }
+    if (q.version !== 1 || q.route !== route || now.toISOString() < q.nextAttemptAt) continue;
+    try {
+      const apiKey = await keyFor(q.role);
+      if (!apiKey) continue;
+      await writeCounters({ ...q.target, apiKey }, q.write);
+      rmSync6(path, { force: true });
+      sent += 1;
+      log.emit(`added a queued run's spend to ${q.write.ticketReference ?? q.write.recordId} (${f})`);
+    } catch (e) {
+      if (!isRetryable(e)) {
+        rmSync6(path, { force: true });
+        log.warn(`dropped a queued ticket counter update (${f}): ${e.message}`);
+        continue;
+      }
+      const attempts = q.attempts + 1;
+      writeFileSync7(path, JSON.stringify({
+        ...q,
+        attempts,
+        warned: true,
+        nextAttemptAt: new Date(now.getTime() + sleepBackoff(attempts)).toISOString()
+      }));
+      if (!q.warned) log.warn(`a queued ticket counter update could not be sent yet (${e.message}); will retry`);
+    }
+  }
+  return sent;
+}
 
 // src/ticket-attribution.ts
 var TICKET_KEY_RE = /\b[A-Z][A-Z0-9]{1,9}-\d+\b/g;
@@ -5145,152 +5443,6 @@ import { basename as basename6 } from "path";
 import { hostname } from "os";
 import { TablationClient } from "@tablation/client";
 
-// src/contract.ts
-var DEFAULT_CONTRACT = {
-  columns: {
-    key: "issue_id",
-    tag: "issue_tag",
-    title: "title",
-    status: "status",
-    assignee: "assignee_id",
-    priority: "priority",
-    severity: "severity",
-    slice: "project_id",
-    repo: "repo_id",
-    parent: "parent_id",
-    blockedBy: "blocked_by",
-    updatedAt: "updated_at",
-    needsDesign: "needs_design",
-    attachments: "attachments",
-    workMode: "work_mode",
-    reportType: "report_type",
-    epic: "epic_id",
-    author: "filed_by_id",
-    ship: "ship_id",
-    heldBy: "held_by_ship_id",
-    resolutionNote: "resolution_note",
-    verifiedSha: "verified_sha",
-    prRef: "pr_ref",
-    externalId: "external_id",
-    position: "position"
-  },
-  comments: {
-    parent: "ticket_id",
-    body: "body",
-    author: "team_member_id",
-    createdAt: "created_at",
-    ship: "ship_id",
-    publicReply: "is_public_reply",
-    authorName: "author_name"
-  },
-  statuses: {
-    open: ["new", "accepted", "blocked", "in_progress", "needs_info", "fixed", "qa", "verified"],
-    resolved: [
-      "verified",
-      "closed_deployed",
-      "closed_wont_fix",
-      "closed_duplicate",
-      "closed_completed",
-      "closed_cant_reproduce"
-    ],
-    approved: "accepted",
-    parked: "blocked",
-    building: "in_progress",
-    handoff: "fixed",
-    verifying: "qa",
-    verified: "verified",
-    deployed: "closed_deployed",
-    needsHuman: "needs_info",
-    reviewing: null,
-    wontFix: "closed_wont_fix",
-    draft: "draft"
-  },
-  epics: {
-    statusColumn: "status",
-    keyColumn: "epic_id",
-    statuses: { planned: "planned", building: "in_progress", done: "done", cancelled: "cancelled" }
-  },
-  priorityOrder: ["p0", "p1", "p2", "p3"],
-  severityOrder: ["s1", "s2", "s3", "s4"],
-  unknownPriorityRank: 2,
-  coordinatingValue: "coordinating",
-  manualWorkMode: "manual",
-  hybridWorkMode: "hybrid",
-  repoExemptReportTypes: ["coordinating", "question", "investigation"]
-};
-function closedStatuses(c) {
-  return c.statuses.resolved.filter((s) => s !== c.statuses.verified);
-}
-function resolveContract(override) {
-  if (!override) return DEFAULT_CONTRACT;
-  return {
-    columns: { ...DEFAULT_CONTRACT.columns, ...override.columns },
-    comments: { ...DEFAULT_CONTRACT.comments, ...override.comments },
-    statuses: { ...DEFAULT_CONTRACT.statuses, ...override.statuses },
-    epics: {
-      ...DEFAULT_CONTRACT.epics,
-      ...override.epics,
-      statuses: { ...DEFAULT_CONTRACT.epics.statuses, ...override.epics?.statuses }
-    },
-    priorityOrder: override.priorityOrder ?? DEFAULT_CONTRACT.priorityOrder,
-    severityOrder: override.severityOrder ?? DEFAULT_CONTRACT.severityOrder,
-    unknownPriorityRank: override.unknownPriorityRank ?? DEFAULT_CONTRACT.unknownPriorityRank,
-    coordinatingValue: override.coordinatingValue ?? DEFAULT_CONTRACT.coordinatingValue,
-    manualWorkMode: override.manualWorkMode ?? DEFAULT_CONTRACT.manualWorkMode,
-    hybridWorkMode: override.hybridWorkMode ?? DEFAULT_CONTRACT.hybridWorkMode,
-    // A workspace overriding `coordinatingValue` alone (renaming the rollup
-    // marker) still gets that renamed value exempted here by default,
-    // without also having to repeat it — only an explicit
-    // `repoExemptReportTypes` overrides this derived default.
-    repoExemptReportTypes: override.repoExemptReportTypes ?? (override.coordinatingValue ? [override.coordinatingValue, "question", "investigation"] : DEFAULT_CONTRACT.repoExemptReportTypes)
-  };
-}
-function validateContract(c) {
-  const problems = [];
-  const open = new Set(c.statuses.open);
-  const resolved = new Set(c.statuses.resolved);
-  for (const role of ["approved", "parked", "building", "handoff", "verifying", "needsHuman"]) {
-    const v = c.statuses[role];
-    if (!open.has(v)) problems.push(`statuses.${role} ("${v}") is not listed in statuses.open`);
-  }
-  if (c.statuses.reviewing && !open.has(c.statuses.reviewing)) {
-    problems.push(`statuses.reviewing ("${c.statuses.reviewing}") is not listed in statuses.open`);
-  }
-  if (!resolved.has(c.statuses.deployed)) {
-    problems.push(`statuses.deployed ("${c.statuses.deployed}") is not listed in statuses.resolved`);
-  }
-  if (resolved.has(c.statuses.handoff)) {
-    problems.push(
-      `statuses.handoff ("${c.statuses.handoff}") is listed as resolved \u2014 it means built-but-unchecked, so a ticket blocked by it is still blocked; calling it resolved would build on unverified work`
-    );
-  }
-  if (!resolved.has(c.statuses.wontFix)) {
-    problems.push(`statuses.wontFix ("${c.statuses.wontFix}") is not listed in statuses.resolved`);
-  }
-  if (c.statuses.reviewing && resolved.has(c.statuses.reviewing)) {
-    problems.push(
-      `statuses.reviewing ("${c.statuses.reviewing}") is listed as resolved \u2014 it is unmerged work under review, so a ticket blocked by it is still blocked`
-    );
-  }
-  if (resolved.has(c.statuses.approved)) {
-    problems.push(`statuses.approved ("${c.statuses.approved}") is listed as resolved`);
-  }
-  if (c.statuses.parked === c.statuses.approved) {
-    problems.push("statuses.parked and statuses.approved are the same value \u2014 parking would be a no-op");
-  }
-  const epicValues = Object.values(c.epics.statuses);
-  if (new Set(epicValues).size !== epicValues.length) {
-    problems.push("epics.statuses names the same value twice \u2014 the epic sync could not tell those states apart");
-  }
-  if (c.priorityOrder.length === 0) problems.push("priorityOrder is empty");
-  if (c.severityOrder.length === 0) problems.push("severityOrder is empty");
-  for (const [name, order] of [["priorityOrder", c.priorityOrder], ["severityOrder", c.severityOrder]]) {
-    if (new Set(order).size !== order.length) problems.push(`${name} contains duplicates`);
-  }
-  return problems;
-}
-var EVENT_LOG_MISSING = "the Issues table has no event log \u2014 crew writes its audit trail there (CREW-1574). In the app, open the Issues table's Data & lifecycle tab and turn on Event log, then rerun.";
-
 // src/state.ts
 import { readFileSync as readFileSync12, writeFileSync as writeFileSync8, existsSync as existsSync12, mkdirSync as mkdirSync7, rmSync as rmSync7, statSync as statSync4 } from "fs";
 import { join as join13 } from "path";
@@ -8144,12 +8296,26 @@ function planAgentRun(o) {
     // resolved yet has nothing to authenticate the MCP connection with either.
     mcp: o.apiKey ? { url: `${o.route.baseUrl}/api/mcp`, keyVar: API_KEY_VAR } : void 0
   });
+  const columns = resolveContract(o.route.contract).columns;
   const agentLog = o.route.resolved && o.apiKey ? {
     baseUrl: o.route.baseUrl,
     workspaceId: o.route.resolved.workspaceId,
     apiKey: o.apiKey,
     userAgent: o.ship.userAgent,
-    agentId: o.resolvedAgentId
+    agentId: o.resolvedAgentId,
+    ...o.route.resolved.models?.issues ? { tickets: {
+      issuesModelId: o.route.resolved.models.issues,
+      keyColumn: columns.key,
+      tagColumn: columns.tag,
+      counters: {
+        agentRuns: columns.agentRuns,
+        tokensIn: columns.tokensIn,
+        tokensOut: columns.tokensOut,
+        cacheReadTokens: columns.cacheReadTokens,
+        cacheWriteTokens: columns.cacheWriteTokens,
+        costUsd: columns.costUsd
+      }
+    } } : {}
   } : void 0;
   return {
     role: o.role,
@@ -8519,7 +8685,22 @@ async function finishRun(id, obs, emit, startedAt, end, agentLogKey) {
       promptSha: id.promptSha
     };
     try {
-      await reportAgentRun({ ...id.agentLog, apiKey: agentLogKey }, report);
+      const sent = await reportAgentRun({ ...id.agentLog, apiKey: agentLogKey }, report);
+      if (sent.counterWarning) emit.warn(sent.counterWarning, { step: "agent" });
+      if (sent.counterRetry) {
+        try {
+          queueTicketCounters(stateDirOfStream(id.streamPath), basename7(id.streamPath, ".jsonl"), {
+            version: 1,
+            route: id.route,
+            role: id.role,
+            target: id.agentLog,
+            write: sent.counterRetry,
+            attempts: 0,
+            nextAttemptAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        } catch {
+        }
+      }
     } catch (e) {
       if (e instanceof AgentLogUnreachableError) {
         try {
@@ -16467,6 +16648,12 @@ async function replayPendingWrites(ctx) {
       async (role) => (await resolveSeatKey(route, role, ctx.getSessionStore)).apiKey,
       emit
     );
+    await replayQueuedTicketCounters(
+      ship.stateDir,
+      routeSlug(route.route),
+      async (role) => (await resolveSeatKey(route, role, ctx.getSessionStore)).apiKey,
+      emit
+    );
   } catch (e) {
     emit.warn(`could not replay pending writes: ${e.message}`, { step: "agent" });
   }

package/package.json

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