@integrity-labs/agt-cli 0.23.1 → 0.23.2

package/dist/{chunk-TCCBS3PD.js → chunk-ZKQGDH3T.js}

@@ -1,6 +1,6 @@
 import {
   KANBAN_LOOP_COMMAND
-} from "./chunk-2TOCO5D2.js";
+} from "./chunk-HSIESZMZ.js";
 
 // src/lib/persistent-session.ts
 import { spawn, execSync, execFileSync as execFileSync2 } from "child_process";
@@ -1167,4 +1167,4 @@ export {
   stopAllSessionsAndWait,
   getProjectDir
 };
-//# sourceMappingURL=chunk-TCCBS3PD.js.map
+//# sourceMappingURL=chunk-ZKQGDH3T.js.map

package/dist/{claude-pair-runtime-KUWBZW33.js → claude-pair-runtime-XCFWTH6T.js}

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

package/dist/lib/manager-worker.js

@@ -1,6 +1,7 @@
 import {
   SUPERVISOR_RESTART_EXIT_CODE,
   api,
+  estimateActiveTasksTokens,
   exchangeApiKey,
   extractCommandNotFound,
   getApiKey,
@@ -11,7 +12,7 @@ import {
   provisionOrientHook,
   provisionStopHook,
   requireHost
-} from "../chunk-Q4QD3TAC.js";
+} from "../chunk-WUYKMPYW.js";
 import {
   findTaskByTemplate,
   getProjectDir as getProjectDir2,
@@ -46,7 +47,7 @@ import {
   stopAllSessionsAndWait,
   stopPersistentSession,
   takeZombieDetection
-} from "../chunk-TCCBS3PD.js";
+} from "../chunk-ZKQGDH3T.js";
 import {
   KANBAN_CHECK_COMMAND,
   appendDmFooter,
@@ -62,7 +63,7 @@ import {
   resolveChannels,
   resolveDmTarget,
   wrapScheduledTaskPrompt
-} from "../chunk-2TOCO5D2.js";
+} from "../chunk-HSIESZMZ.js";
 
 // src/lib/manager-worker.ts
 import { createHash as createHash2 } from "crypto";
@@ -552,6 +553,108 @@ function decideChannelRestart(input) {
   return { restart: true, added, removed };
 }
 
+// src/lib/restart-breaker.ts
+var DEFAULT_MAX = 2;
+var DEFAULT_WINDOW_MS = 6e5;
+function readEnvNumber(name, fallback) {
+  const raw = process.env[name];
+  if (!raw) return fallback;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+var RestartBreaker = class {
+  max;
+  windowMs;
+  now;
+  events = /* @__PURE__ */ new Map();
+  trips = /* @__PURE__ */ new Map();
+  constructor(opts = {}) {
+    this.max = opts.max ?? readEnvNumber("AGT_RESTART_BREAKER_MAX", DEFAULT_MAX);
+    this.windowMs = opts.windowMs ?? readEnvNumber("AGT_RESTART_BREAKER_WINDOW_MS", DEFAULT_WINDOW_MS);
+    this.now = opts.now ?? Date.now;
+    if (!Number.isFinite(this.max) || this.max < 1) {
+      throw new Error("restart-breaker max must be a finite number >= 1");
+    }
+    if (!Number.isFinite(this.windowMs) || this.windowMs < 1e3) {
+      throw new Error("restart-breaker windowMs must be a finite number >= 1000");
+    }
+  }
+  /** True if this agent's breaker is currently tripped (manager must skip spawn). */
+  isTripped(codeName) {
+    return this.trips.has(codeName);
+  }
+  getTrip(codeName) {
+    return this.trips.get(codeName);
+  }
+  /**
+   * Record a restart event. If recording this event puts the count
+   * inside the window above `max`, the breaker trips and the call site
+   * should NOT respawn.
+   *
+   * Idempotent on already-tripped breakers: returns the existing trip
+   * without double-counting events. Callers may still record the reason
+   * via the decision-log for forensics.
+   */
+  record(codeName, reason) {
+    const existing = this.trips.get(codeName);
+    if (existing) {
+      return { tripped: false, trip: existing, windowCount: existing.eventsAtTrip.length };
+    }
+    const at = this.now();
+    const cutoff = at - this.windowMs;
+    const prior = (this.events.get(codeName) ?? []).filter((e) => e.at >= cutoff);
+    prior.push({ reason, at });
+    this.events.set(codeName, prior);
+    if (prior.length > this.max) {
+      const trip = {
+        trippedAt: at,
+        eventsAtTrip: [...prior],
+        statusMessage: formatStatusMessage(prior, this.windowMs)
+      };
+      this.trips.set(codeName, trip);
+      this.events.delete(codeName);
+      return { tripped: true, trip, windowCount: prior.length };
+    }
+    return { tripped: false, windowCount: prior.length };
+  }
+  /** Operator-initiated reset: drops the trip + the events log for this agent. */
+  clear(codeName) {
+    this.trips.delete(codeName);
+    this.events.delete(codeName);
+  }
+  /** Snapshot tripped agents for `manager-state.json`. */
+  serialize() {
+    return Object.fromEntries(this.trips.entries());
+  }
+  /**
+   * Rehydrate trip state from `manager-state.json`. Called once at
+   * worker startup. Window history is intentionally NOT persisted — only
+   * tripped state. A tripped breaker survives manager restart; an
+   * un-tripped one starts a fresh window in the new worker.
+   */
+  hydrate(saved) {
+    if (!saved) return;
+    for (const [codeName, trip] of Object.entries(saved)) {
+      if (trip && typeof trip.trippedAt === "number" && Array.isArray(trip.eventsAtTrip)) {
+        this.trips.set(codeName, trip);
+      }
+    }
+  }
+  /** Test helper — current in-window event count for `codeName`. */
+  windowCount(codeName) {
+    const cutoff = this.now() - this.windowMs;
+    return (this.events.get(codeName) ?? []).filter((e) => e.at >= cutoff).length;
+  }
+};
+function formatStatusMessage(events, windowMs) {
+  const last = events[events.length - 1];
+  const windowLabel = windowMs < 6e4 ? `${Math.round(windowMs / 1e3)}s` : `${(windowMs / 6e4).toFixed(1).replace(/\.0$/, "")}min`;
+  const reasonCounts = /* @__PURE__ */ new Map();
+  for (const e of events) reasonCounts.set(e.reason, (reasonCounts.get(e.reason) ?? 0) + 1);
+  const breakdown = Array.from(reasonCounts.entries()).map(([r, n]) => `${r}=${n}`).join(", ");
+  return `Circuit breaker tripped: ${events.length} restarts in ${windowLabel} (${breakdown}); most recent=${last.reason} at ${new Date(last.at).toISOString()}`;
+}
+
 // src/lib/usage-banner-monitor.ts
 var MIN_CHECK_INTERVAL_MS = 6e4;
 var PANE_TAIL_LINES_FOR_BANNER = 200;
@@ -2286,7 +2389,38 @@ var knownVersions = /* @__PURE__ */ new Map();
 var knownStatuses = /* @__PURE__ */ new Map();
 var knownChannels = /* @__PURE__ */ new Map();
 var pendingSessionRestarts = /* @__PURE__ */ new Map();
-function scheduleSessionRestart(codeName, delayMs, reason) {
+var restartBreaker = new RestartBreaker();
+var reportedTrips = /* @__PURE__ */ new Map();
+function recordRestartForBreaker(codeName, reason) {
+  const result = restartBreaker.record(codeName, reason);
+  if (!result.tripped || !result.trip) return;
+  const trip = result.trip;
+  log(
+    `[persistent-session-decision] agent=${codeName} decision=circuit-tripped detail=${JSON.stringify(trip.statusMessage)} (ENG-5441)`
+  );
+  maybeReportCurrentTrip(codeName);
+}
+async function reportCircuitTripped(codeName, trip) {
+  if (reportedTrips.get(codeName) === trip.trippedAt) return;
+  const agentId = codeNameToAgentId.get(codeName);
+  if (!agentId) throw new Error(`no agent_id known yet for '${codeName}' \u2014 will retry next poll`);
+  await api.post("/host/circuit-breaker/trip", {
+    agent_id: agentId,
+    status_message: trip.statusMessage,
+    tripped_at: new Date(trip.trippedAt).toISOString(),
+    events: trip.eventsAtTrip.map((e) => ({ reason: e.reason, at: new Date(e.at).toISOString() }))
+  });
+  reportedTrips.set(codeName, trip.trippedAt);
+}
+function maybeReportCurrentTrip(codeName) {
+  const trip = restartBreaker.getTrip(codeName);
+  if (!trip) return;
+  if (reportedTrips.get(codeName) === trip.trippedAt) return;
+  reportCircuitTripped(codeName, trip).catch((err) => {
+    log(`[circuit-breaker] Failed to report trip for '${codeName}' to API: ${err.message}`);
+  });
+}
+function scheduleSessionRestart(codeName, delayMs, reason, breakerReason = "hot-reload-mcp") {
   const existing = pendingSessionRestarts.get(codeName);
   if (existing) {
     clearTimeout(existing);
@@ -2296,6 +2430,7 @@ function scheduleSessionRestart(codeName, delayMs, reason) {
     pendingSessionRestarts.delete(codeName);
     stopPersistentSession(codeName, log);
     runningMcpHashes.delete(codeName);
+    recordRestartForBreaker(codeName, breakerReason);
     log(`[hot-reload] Session stopped for '${codeName}' \u2014 will respawn with ${reason}`);
   }, delayMs);
   timer.unref?.();
@@ -2331,11 +2466,14 @@ function projectMcpKeys(_codeName, projectDir) {
     return null;
   }
 }
-function stopPersistentSessionAndForgetMcpBaseline(codeName) {
+function stopPersistentSessionAndForgetMcpBaseline(codeName, breakerReason) {
   cancelPendingSessionRestart(codeName);
   stopPersistentSession(codeName, log);
   runningMcpHashes.delete(codeName);
   runningMcpServerKeys.delete(codeName);
+  if (breakerReason) {
+    recordRestartForBreaker(codeName, breakerReason);
+  }
 }
 function checkMcpConfigDriftAndScheduleRestart(codeName, projectDir) {
   const currentHash = projectMcpHash(codeName, projectDir);
@@ -2472,7 +2610,7 @@ var cachedFrameworkVersion = null;
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.23.1" : "dev";
+var agtCliVersion = true ? "0.23.2" : "dev";
 function resolveBrewPath(execFileSync4) {
   try {
     const out = execFileSync4("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -3368,7 +3506,7 @@ async function pollCycle() {
       log,
       resolveFramework: (codeName) => agentFrameworkCache.get(codeName) ?? null,
       stopSession: (codeName) => {
-        stopPersistentSessionAndForgetMcpBaseline(codeName);
+        stopPersistentSessionAndForgetMcpBaseline(codeName, "channel-set-change");
         persistentSessionAgents.delete(codeName);
         claudeAuthTupleBySession.delete(codeName);
       },
@@ -3429,7 +3567,7 @@ async function pollCycle() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-6PDFG7F5.js");
-      const { collectDiagnostics } = await import("../persistent-session-XEA4SPAN.js");
+      const { collectDiagnostics } = await import("../persistent-session-L4YIJJML.js");
       const diagCodeNames = [...persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames) : void 0;
       let tailscaleHostname;
@@ -3480,7 +3618,7 @@ async function pollCycle() {
       const {
         collectResponsivenessProbes,
         getResponsivenessIntervalMs
-      } = await import("../responsiveness-probe-VWPOCABI.js");
+      } = await import("../responsiveness-probe-YRLESO54.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
         const probeCodeNames = [...persistentSessionAgents];
@@ -3678,7 +3816,11 @@ async function pollCycle() {
       ...state2,
       lastPollAt: (/* @__PURE__ */ new Date()).toISOString(),
       pollCount: state2.pollCount + 1,
-      agents: agentStates
+      agents: agentStates,
+      // ENG-5441: serialise trip state on every poll so manager restarts
+      // never silently clear a tripped breaker. Cheap — only tripped
+      // entries are stored, and the typical state is zero entries.
+      circuitBreakerTrips: restartBreaker.serialize()
     };
     if (consecutivePollFailures > 0) {
       log(`[poll-backoff] recovered after ${consecutivePollFailures} failure(s), resuming normal interval`);
@@ -3713,6 +3855,7 @@ async function processAgent(agent, agentStates) {
   const previousKnownStatus = knownStatuses.get(agent.agent_id);
   agentDisplayNames.set(agent.code_name, agent.display_name);
   codeNameToAgentId.set(agent.code_name, agent.agent_id);
+  maybeReportCurrentTrip(agent.code_name);
   if (agent.framework) {
     agentFrameworkCache.set(agent.code_name, agent.framework);
   }
@@ -3825,6 +3968,11 @@ async function processAgent(agent, agentStates) {
   if (previousStatus && previousStatus !== agent.status) {
     log(`Agent '${agent.code_name}' status changed: ${previousStatus} \u2192 ${agent.status}`);
     knownVersions.delete(agent.agent_id);
+    if (previousStatus === "paused" && agent.status === "active" && restartBreaker.isTripped(agent.code_name)) {
+      restartBreaker.clear(agent.code_name);
+      reportedTrips.delete(agent.code_name);
+      log(`[circuit-breaker] Cleared trip for '${agent.code_name}' on operator resume (paused \u2192 active)`);
+    }
     let channelCacheMutated = false;
     for (const key of knownChannelConfigHashes.keys()) {
       if (key.startsWith(`${agent.agent_id}:`)) {
@@ -4756,7 +4904,12 @@ async function processAgent(agent, agentStates) {
         codeName: agent.code_name,
         mcpJson: mcpJsonParsed,
         sessionStartedAt: sess?.startedAt ?? null,
-        stopSession: (codeName) => stopPersistentSessionAndForgetMcpBaseline(codeName),
+        // 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-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
@@ -5545,6 +5698,15 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
   const projectDir = getProjectDir(codeName);
   const mcpConfigPath = join4(projectDir, ".mcp.json");
   const claudeMdPath = join4(projectDir, "CLAUDE.md");
+  if (restartBreaker.isTripped(codeName)) {
+    const trip = restartBreaker.getTrip(codeName);
+    return {
+      decision: "circuit-tripped",
+      spawnAttempted: false,
+      sessionHealthyAfter: isSessionHealthy(codeName),
+      detail: trip.statusMessage
+    };
+  }
   const teamSettingsForTz = refreshData.team?.settings;
   const agentTimezone = (() => {
     const tz = teamSettingsForTz?.["timezone"];
@@ -5627,7 +5789,7 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
   const recordedAuthTuple = claudeAuthTupleBySession.get(codeName);
   if (recordedAuthTuple && recordedAuthTuple !== currentAuthTuple && isSessionHealthy(codeName)) {
     log(`[persistent-session] Auth config changed for '${codeName}' (${recordedAuthTuple} \u2192 ${currentAuthTuple}) \u2014 restarting session`);
-    stopPersistentSessionAndForgetMcpBaseline(codeName);
+    stopPersistentSessionAndForgetMcpBaseline(codeName, "auth-tuple-change");
     persistentSessionAgents.delete(codeName);
     restartTrigger = "auth-tuple";
   }
@@ -5639,7 +5801,7 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
         log(
           `[persistent-session] Day rollover for '${codeName}' (yesterday=${current.date}) \u2014 agent idle, restarting to mint fresh session`
         );
-        stopPersistentSessionAndForgetMcpBaseline(codeName);
+        stopPersistentSessionAndForgetMcpBaseline(codeName, "day-rollover");
         persistentSessionAgents.delete(codeName);
         restartTrigger = "day-rollover";
       } else {
@@ -5650,6 +5812,15 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
       }
     }
   }
+  if (restartBreaker.isTripped(codeName)) {
+    const trip = restartBreaker.getTrip(codeName);
+    return {
+      decision: "circuit-tripped",
+      spawnAttempted: false,
+      sessionHealthyAfter: isSessionHealthy(codeName),
+      detail: trip.statusMessage
+    };
+  }
   if (!isSessionHealthy(codeName)) {
     if (persistentSessionAgents.has(codeName)) {
       const ctx = getLastFailureContext(codeName);
@@ -7136,7 +7307,7 @@ async function processClaudePairSessions(agents) {
     killPairSession,
     pairTmuxSession,
     finalizeClaudePairOnboarding
-  } = await import("../claude-pair-runtime-KUWBZW33.js");
+  } = await import("../claude-pair-runtime-XCFWTH6T.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));
@@ -7357,6 +7528,14 @@ function generateArtifacts(agent, refreshData, adapter) {
       };
     }
   }
+  const activeTasksInjectEnabled = process.env["AGT_ACTIVE_TASKS_INJECT"] === "1";
+  const activeTasksFromRefresh = activeTasksInjectEnabled ? refreshData.active_tasks ?? [] : void 0;
+  if (activeTasksInjectEnabled) {
+    const tokens = estimateActiveTasksTokens(activeTasksFromRefresh);
+    log(
+      `[provision/active-tasks] agent=${agent.code_name} count=${activeTasksFromRefresh?.length ?? 0} estimated_tokens=${tokens}`
+    );
+  }
   const provisionInput = {
     agent: refreshData.agent,
     charterFrontmatter,
@@ -7367,6 +7546,7 @@ function generateArtifacts(agent, refreshData, adapter) {
     deploymentTarget: "local_docker",
     gatewayPort: 9e3,
     team: refreshData.team ?? void 0,
+    activeTasks: activeTasksFromRefresh,
     // ENG-5009: org name for the identity-preamble. Only present when
     // /host/refresh ships the field — falls through cleanly for older
     // API payloads that don't carry it.
@@ -7715,6 +7895,11 @@ function startManager(opts) {
         state2.agents = parsed.agents;
         log(`[startup] rehydrated ${state2.agents.length} agent state(s) from ${stateFile}`);
       }
+      if (parsed.circuitBreakerTrips && typeof parsed.circuitBreakerTrips === "object") {
+        restartBreaker.hydrate(parsed.circuitBreakerTrips);
+        const n = Object.keys(parsed.circuitBreakerTrips).length;
+        if (n > 0) log(`[startup] rehydrated ${n} circuit-breaker trip(s) \u2014 agents will remain paused until manually resumed`);
+      }
     }
   } catch (err) {
     log(`[startup] state rehydration failed (continuing with empty state): ${err.message}`);