@integrity-labs/agt-cli 0.24.5 → 0.24.7

package/dist/{chunk-QWMGMV4N.js → chunk-FK6BJWEC.js}

@@ -8,7 +8,7 @@ import {
   parseDeliveryTarget,
   registerFramework,
   wrapScheduledTaskPrompt
-} from "./chunk-ECDTRQLA.js";
+} from "./chunk-53TCAGCM.js";
 
 // ../../packages/core/dist/integrations/registry.js
 var INTEGRATION_REGISTRY = [
@@ -6710,4 +6710,4 @@ export {
   managerInstallSystemUnitCommand,
   managerUninstallSystemUnitCommand
 };
-//# sourceMappingURL=chunk-QWMGMV4N.js.map
+//# sourceMappingURL=chunk-FK6BJWEC.js.map

package/dist/{claude-pair-runtime-ZQAJOQPN.js → claude-pair-runtime-4F53C7RB.js}

@@ -100,7 +100,7 @@ async function spawnPairSession(session) {
     return { ok: true };
   } catch {
   }
-  const { resolveClaudeBinary } = await import("./persistent-session-JUJY46HW.js");
+  const { resolveClaudeBinary } = await import("./persistent-session-XJYOPFIP.js");
   const claudeBin = resolveClaudeBinary();
   const pairEnv = {
     ...process.env,
@@ -373,4 +373,4 @@ export {
   startClaudePair,
   submitClaudePairCode
 };
-//# sourceMappingURL=claude-pair-runtime-ZQAJOQPN.js.map
+//# sourceMappingURL=claude-pair-runtime-4F53C7RB.js.map

package/dist/lib/manager-worker.js

@@ -12,7 +12,7 @@ import {
   provisionOrientHook,
   provisionStopHook,
   requireHost
-} from "../chunk-QWMGMV4N.js";
+} from "../chunk-FK6BJWEC.js";
 import {
   findTaskByTemplate,
   getProjectDir as getProjectDir2,
@@ -48,13 +48,15 @@ import {
   stopAllSessionsAndWait,
   stopPersistentSession,
   takeZombieDetection
-} from "../chunk-PNTLQKLO.js";
+} from "../chunk-3A2PMQM4.js";
 import {
   KANBAN_CHECK_COMMAND,
   appendDmFooter,
+  attributeTranscriptUsageByRun,
   classifyOutput,
   extractFrontmatter,
   formatActorId,
+  formatRunMarker,
   getFramework,
   isEmptyTotals,
   isParseError,
@@ -66,7 +68,7 @@ import {
   resolveChannels,
   resolveDmTarget,
   wrapScheduledTaskPrompt
-} from "../chunk-ECDTRQLA.js";
+} from "../chunk-53TCAGCM.js";
 
 // src/lib/manager-worker.ts
 import { createHash as createHash3 } from "crypto";
@@ -534,7 +536,7 @@ function reapMissingMcpSessions(args) {
       );
     }
   }
-  stopSession(codeName);
+  stopSession(codeName, { activeKeys: active });
   return {
     missing,
     restarted: true,
@@ -572,6 +574,9 @@ function decideChannelRestart(input) {
 }
 
 // src/lib/restart-breaker.ts
+function reaperRestartBreakerReason(activeKeys) {
+  return activeKeys.length >= 2 ? "mcp-presence-reaper" : void 0;
+}
 var DEFAULT_MAX = 2;
 var DEFAULT_WINDOW_MS = 6e5;
 function readEnvNumber(name, fallback) {
@@ -754,6 +759,7 @@ async function maybeReportTokenUsage(args) {
     return;
   }
   const pending = [];
+  const pendingRuns = [];
   for (const name of dirEntries) {
     if (!name.endsWith(".jsonl")) continue;
     const sessionId = name.slice(0, -".jsonl".length);
@@ -797,6 +803,18 @@ async function maybeReportTokenUsage(args) {
         }
       });
     }
+    for (const r of attributeTranscriptUsageByRun(content).perRunModel) {
+      if (r.runId === null || isEmptyTotals(r.totals)) continue;
+      pendingRuns.push({
+        run_id: r.runId,
+        model: r.model,
+        input_tokens: r.totals.inputTokens,
+        output_tokens: r.totals.outputTokens,
+        cache_creation_tokens: r.totals.cacheCreationTokens,
+        cache_read_tokens: r.totals.cacheReadTokens,
+        last_observed_at: parsed.lastObservedAt
+      });
+    }
     if (![...parsed.byModel.values()].some((t) => !isEmptyTotals(t))) {
       files.set(sessionId, fp);
     }
@@ -823,6 +841,19 @@ async function maybeReportTokenUsage(args) {
       log2(`[token-usage] POST failed for '${codeName}': ${err.message}`);
     }
   }
+  for (let i = 0; i < pendingRuns.length; i += MAX_ENTRIES_PER_POST) {
+    const batch = pendingRuns.slice(i, i + MAX_ENTRIES_PER_POST);
+    try {
+      await api2.post("/host/run-token-usage", {
+        agent_id: agentId,
+        framework: "claude-code",
+        source: "transcript_jsonl",
+        entries: batch
+      });
+    } catch (err) {
+      log2(`[token-usage] run-usage POST failed for '${codeName}': ${err.message}`);
+    }
+  }
   if (reported > 0) {
     log2(`[token-usage] reported ${reported} entr${reported === 1 ? "y" : "ies"} for '${codeName}'`);
   }
@@ -2663,6 +2694,7 @@ function stopPersistentSessionAndForgetMcpBaseline(codeName, breakerReason) {
   stopPersistentSession(codeName, log);
   runningMcpHashes.delete(codeName);
   runningMcpServerKeys.delete(codeName);
+  closeInjectedRunIfOpen(codeName, "cancelled", `session stopped (${breakerReason ?? "deprovision"})`);
   if (breakerReason) {
     recordRestartForBreaker(codeName, breakerReason);
   }
@@ -2806,7 +2838,7 @@ var cachedFrameworkVersion = null;
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.24.5" : "dev";
+var agtCliVersion = true ? "0.24.7" : "dev";
 function resolveBrewPath(execFileSync4) {
   try {
     const out = execFileSync4("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -3765,7 +3797,7 @@ async function pollCycle() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-6PDFG7F5.js");
-      const { collectDiagnostics } = await import("../persistent-session-JUJY46HW.js");
+      const { collectDiagnostics } = await import("../persistent-session-XJYOPFIP.js");
       const diagCodeNames = [...persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames) : void 0;
       let tailscaleHostname;
@@ -3816,7 +3848,7 @@ async function pollCycle() {
       const {
         collectResponsivenessProbes,
         getResponsivenessIntervalMs
-      } = await import("../responsiveness-probe-XOEC7J5D.js");
+      } = await import("../responsiveness-probe-EWZNGMTX.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
         const probeCodeNames = [...persistentSessionAgents];
@@ -5092,7 +5124,9 @@ async function processAgent(agent, agentStates) {
       const actionableCount = hybridBoard.filter(
         (i) => HYBRID_ACTIONABLE_STATUSES.has(i.status)
       ).length;
-      void maybeInjectKanbanCheck(agent.code_name, actionableCount);
+      void maybeInjectKanbanCheck(agent.code_name, agent.agent_id, actionableCount);
+    } else {
+      closeInjectedRunIfOpen(agent.code_name, "completed", "kanban board drained");
     }
   }
   if (agentFw === "claude-code" && sessionMode === "persistent") {
@@ -5149,12 +5183,17 @@ async function processAgent(agent, agentStates) {
         codeName: agent.code_name,
         mcpJson: mcpJsonParsed,
         sessionStartedAt: sess?.startedAt ?? null,
-        // ENG-5441: mcp-presence-reaper-driven restart counts against
-        // the breaker. Each declared MCP has its own ENG-5279 give-up
-        // cap (~3 cycles per server), but a thrashing collection of
-        // MCPs can still rotate restarts of the whole session. The
-        // breaker catches the rotating case the per-MCP cap can't see.
-        stopSession: (codeName) => stopPersistentSessionAndForgetMcpBaseline(codeName, "mcp-presence-reaper"),
+        // ENG-5441 / ENG-5547: a mcp-presence-reaper restart counts against
+        // the agent-wide breaker ONLY when several distinct MCP servers are
+        // missing at once — a thrashing collection that rotates restarts of
+        // the whole session, which the per-MCP cap can't see. A restart
+        // driven by a SINGLE persistently-failing server is left to that
+        // server's own ENG-5279 give-up cap (→ marked unhealthy via onGiveUp
+        // → dropped from the next .mcp.json), so one bad integration is
+        // isolated and the agent keeps running degraded instead of being
+        // paused wholesale. reaperRestartBreakerReason() encodes that
+        // single-vs-multi decision; undefined means "restart, don't count".
+        stopSession: (codeName, ctx) => stopPersistentSessionAndForgetMcpBaseline(codeName, reaperRestartBreakerReason(ctx.activeKeys)),
         // ENG-5292: when the reaper gives up on a managed MCP (cap from
         // ENG-5279 + state-preservation from ENG-5285 both said "this
         // MCP keeps failing after 3 restart cycles"), mark the matching
@@ -6670,13 +6709,23 @@ function hasHybridActionableItems(items) {
   return items.some((item) => HYBRID_ACTIONABLE_STATUSES.has(item.status));
 }
 var lastKanbanInjectAt = /* @__PURE__ */ new Map();
+var openInjectedRunByCode = /* @__PURE__ */ new Map();
+function isSlashCommand(command) {
+  return command.trimStart().startsWith("/");
+}
+function closeInjectedRunIfOpen(codeName, outcome, outcomeMessage) {
+  const runId = openInjectedRunByCode.get(codeName);
+  if (!runId) return;
+  openInjectedRunByCode.delete(codeName);
+  void finishRun(runId, outcome, { outcomeMessage });
+}
 var KANBAN_HYBRID_DEBOUNCE_MS = (() => {
   const raw = process.env["AGT_KANBAN_HYBRID_DEBOUNCE_SECONDS"];
   const parsed = raw ? parseInt(raw, 10) : NaN;
   if (Number.isFinite(parsed) && parsed > 0) return Math.max(parsed, 10) * 1e3;
   return 6e4;
 })();
-async function maybeInjectKanbanCheck(codeName, actionableCount) {
+async function maybeInjectKanbanCheck(codeName, agentId, actionableCount) {
   const lastAt = lastKanbanInjectAt.get(codeName) ?? 0;
   if (Date.now() - lastAt < KANBAN_HYBRID_DEBOUNCE_MS) {
     return;
@@ -6695,13 +6744,30 @@ async function maybeInjectKanbanCheck(codeName, actionableCount) {
     lastKanbanInjectAt.delete(codeName);
     return;
   }
-  const sent = sendToAgent(tmuxSession, KANBAN_CHECK_COMMAND);
-  if (sent) {
+  closeInjectedRunIfOpen(codeName, "completed", "kanban inject superseded by next inject");
+  const { run_id } = await startRun({
+    agent_id: agentId,
+    source_type: "kanban",
+    metadata: { injected: "kanban-check", actionable_count: actionableCount }
+  });
+  let delivered;
+  if (isSlashCommand(KANBAN_CHECK_COMMAND)) {
+    delivered = sendToAgent(tmuxSession, KANBAN_CHECK_COMMAND);
+  } else {
+    const content = run_id ? `${KANBAN_CHECK_COMMAND}
+${formatRunMarker(run_id)}` : KANBAN_CHECK_COMMAND;
+    delivered = await injectMessage(codeName, "system", content, void 0, log);
+  }
+  if (delivered) {
+    if (run_id) openInjectedRunByCode.set(codeName, run_id);
     log(
-      `[manager-worker] Injected kanban check for '${codeName}' (${actionableCount} actionable items)`
+      `[manager-worker] Injected kanban check for '${codeName}' (${actionableCount} actionable items)${run_id ? ` run_id=${run_id}` : ""}`
     );
   } else {
-    log(`[manager-worker] kanban inject failed (tmux send) for '${codeName}'`);
+    if (run_id) {
+      void finishRun(run_id, "failed", { outcomeMessage: "kanban inject delivery failed" });
+    }
+    log(`[manager-worker] kanban inject failed for '${codeName}'`);
   }
 }
 function warnOnConflictingKanbanModes() {
@@ -7553,7 +7619,7 @@ async function processClaudePairSessions(agents) {
     killPairSession,
     pairTmuxSession,
     finalizeClaudePairOnboarding
-  } = await import("../claude-pair-runtime-ZQAJOQPN.js");
+  } = await import("../claude-pair-runtime-4F53C7RB.js");
   for (const pairId of pendingResp.cancelled_pair_ids ?? []) {
     log(`[claude-pair] sweeping orphan tmux session for pair ${pairId.slice(0, 8)}`);
     const killed = await killPairSession(pairTmuxSession(pairId));