@integrity-labs/agt-cli 0.28.410 → 0.28.412

package/dist/bin/agt.js

@@ -40,7 +40,7 @@ import {
   success,
   table,
   warn
-} from "../chunk-QZEA7FWB.js";
+} from "../chunk-5ES25OE6.js";
 import {
   AnchorSessionClient,
   CHANNEL_REGISTRY,
@@ -70,7 +70,7 @@ import {
   renderTemplate,
   resolveChannels,
   serializeManifestForSlackCli
-} from "../chunk-YLLK4G3B.js";
+} from "../chunk-QZUKHEMO.js";
 import "../chunk-XWVM4KPK.js";
 
 // src/bin/agt.ts
@@ -4829,7 +4829,7 @@ import { execFileSync, execSync } from "child_process";
 import { existsSync as existsSync10, realpathSync as realpathSync2 } from "fs";
 import chalk18 from "chalk";
 import ora16 from "ora";
-var cliVersion = true ? "0.28.410" : "dev";
+var cliVersion = true ? "0.28.412" : "dev";
 async function fetchLatestVersion() {
   const host2 = getHost();
   if (!host2) return null;
@@ -6001,7 +6001,7 @@ function handleError(err) {
 }
 
 // src/bin/agt.ts
-var cliVersion2 = true ? "0.28.410" : "dev";
+var cliVersion2 = true ? "0.28.412" : "dev";
 var program = new Command();
 program.name("agt").description("Augmented CLI \u2014 agent provisioning and management").version(cliVersion2).option("--json", "Emit machine-readable JSON output (suppress spinners and colors)").option("--skip-update-check", "Skip the automatic update check on startup");
 program.hook("preAction", async (thisCommand, actionCommand) => {

package/dist/{chunk-QZEA7FWB.js → chunk-5ES25OE6.js}

@@ -25,7 +25,7 @@ import {
   resolveConnectivityProbe,
   worseConnectivityOutcome,
   wrapScheduledTaskPrompt
-} from "./chunk-YLLK4G3B.js";
+} from "./chunk-QZUKHEMO.js";
 import {
   parsePsRows
 } from "./chunk-XWVM4KPK.js";
@@ -6247,7 +6247,7 @@ function requireHost() {
 }
 
 // src/lib/api-client.ts
-var agtCliVersion = true ? "0.28.410" : "dev";
+var agtCliVersion = true ? "0.28.412" : "dev";
 var lastConfigHash = null;
 function setConfigHash(hash) {
   lastConfigHash = hash && hash.length > 0 ? hash : null;
@@ -8751,4 +8751,4 @@ export {
   managerInstallSystemUnitCommand,
   managerUninstallSystemUnitCommand
 };
-//# sourceMappingURL=chunk-QZEA7FWB.js.map
+//# sourceMappingURL=chunk-5ES25OE6.js.map

package/dist/{chunk-YLLK4G3B.js → chunk-QZUKHEMO.js}

@@ -10242,10 +10242,65 @@ async function execFilePromiseLong(cmd, args, opts) {
   });
 }
 
+// src/lib/turn-outcome-tracker.ts
+function isFailure(outcome) {
+  return outcome === "no_reply" || outcome === "failed";
+}
+function emptyHealth() {
+  return { lastOutcome: null, lastRepliedAt: null, lastAttemptAt: null, consecutiveFailures: 0 };
+}
+var DEFAULT_TURN_FAILURE_WARN_THRESHOLD = 3;
+var TurnOutcomeTracker = class {
+  health = /* @__PURE__ */ new Map();
+  warned = /* @__PURE__ */ new Set();
+  threshold;
+  constructor(threshold = DEFAULT_TURN_FAILURE_WARN_THRESHOLD) {
+    if (!Number.isInteger(threshold) || threshold < 1) {
+      throw new Error(`turn-outcome threshold must be an integer >= 1 (got ${threshold})`);
+    }
+    this.threshold = threshold;
+  }
+  /** Record one observed turn outcome for one agent. */
+  record(codeName, outcome, now = Date.now()) {
+    const current = this.health.get(codeName) ?? emptyHealth();
+    const next = {
+      lastOutcome: outcome,
+      lastAttemptAt: now,
+      lastRepliedAt: outcome === "replied" ? now : current.lastRepliedAt,
+      // Only a real reply clears the streak. A `declined` or a fire-and-forget
+      // `admitted` leaves it exactly where it was: neither proves the agent can
+      // answer, so neither should be able to mask an ongoing wedge.
+      consecutiveFailures: isFailure(outcome) ? current.consecutiveFailures + 1 : outcome === "replied" ? 0 : current.consecutiveFailures
+    };
+    this.health.set(codeName, next);
+    if (outcome === "replied") {
+      const wasWarned = this.warned.delete(codeName);
+      return { health: next, shouldWarn: false, recovered: wasWarned };
+    }
+    const crossed = next.consecutiveFailures >= this.threshold && !this.warned.has(codeName);
+    if (crossed) this.warned.add(codeName);
+    return { health: next, shouldWarn: crossed, recovered: false };
+  }
+  /** Current turn health for an agent, or null if no turn has been observed. */
+  get(codeName) {
+    return this.health.get(codeName) ?? null;
+  }
+  /**
+   * Drop all state for an agent. Called when its serve is torn down, so a fresh
+   * serve is not born already carrying the dead one's failure streak.
+   */
+  reset(codeName) {
+    this.health.delete(codeName);
+    this.warned.delete(codeName);
+  }
+};
+
 // src/lib/opencode-session.ts
 var OPENCODE_BIN = process.env["AGT_OPENCODE_BIN"]?.trim() || "opencode";
 var OPENCODE_RUN_TIMEOUT_MS = Number(process.env["AGT_OPENCODE_RUN_TIMEOUT_MS"]) || 18e4;
 var sessions = /* @__PURE__ */ new Map();
+var loggers = /* @__PURE__ */ new Map();
+var turnOutcomeTracker = new TurnOutcomeTracker();
 var bridges = /* @__PURE__ */ new Map();
 function opencodeTmuxSession(codeName) {
   return `agt-oc-${codeName}`;
@@ -10425,7 +10480,19 @@ function findFreePort() {
 }
 async function startOpencodeSession(config) {
   const { codeName, log: log2 } = config;
+  loggers.set(codeName, log2);
   const existing = sessions.get(codeName);
+  if (existing && existing.status === "running" && !isOpencodeSessionHealthy(codeName)) {
+    log2(
+      `[opencode-session] '${codeName}' stopped out-of-band (tmux session gone, in-memory state pinned to port ${existing.port ?? "?"}) \u2014 respawning on a fresh port (ENG-7995)`
+    );
+    existing.status = "crashed";
+    existing.restartCount++;
+    existing.port = null;
+    existing.password = null;
+    bridges.delete(codeName);
+    stopTranscriptRefresher(codeName);
+  }
   if (existing && existing.status === "running") return existing;
   const restartCount = existing?.restartCount ?? 0;
   if (existing?.status === "crashed" && existing.startedAt) {
@@ -10574,7 +10641,29 @@ async function injectOpencodeMessage(codeName, msg, opts = {}) {
     return { status: "declined", reason: "server_not_running" };
   }
   const bridge = getBridge(codeName, session.port, session.password);
-  return bridge.handleInbound(msg, { gate: opts.gate, awaitReply: opts.awaitReply });
+  try {
+    const result = await bridge.handleInbound(msg, { gate: opts.gate, awaitReply: opts.awaitReply });
+    const outcome = result.status === "declined" ? "declined" : result.status === "replied" && result.reply ? "replied" : opts.awaitReply === false ? "admitted" : "no_reply";
+    noteOpencodeTurnOutcome(codeName, outcome, session);
+    return result;
+  } catch (err) {
+    noteOpencodeTurnOutcome(codeName, "failed", session);
+    throw err;
+  }
+}
+function noteOpencodeTurnOutcome(codeName, outcome, startedOn) {
+  if (sessions.get(codeName) !== startedOn || startedOn.status !== "running") return;
+  const { health, shouldWarn, recovered } = turnOutcomeTracker.record(codeName, outcome);
+  const log2 = loggers.get(codeName);
+  if (!log2) return;
+  if (shouldWarn) {
+    const lastOk = health.lastRepliedAt ? `${Math.round((Date.now() - health.lastRepliedAt) / 1e3)}s ago` : "never";
+    log2(
+      `[turn-health] WARN: '${codeName}' has ${health.consecutiveFailures} consecutive turns with no reply (last successful turn: ${lastOk}; serve process alive=${isOpencodeSessionHealthy(codeName)}) \u2014 the serve is up but not completing turns (ENG-7996)`
+    );
+  } else if (recovered) {
+    log2(`[turn-health] '${codeName}' completed a turn again after a no-reply streak (ENG-7996)`);
+  }
 }
 function getBridge(codeName, port, password) {
   const cached = bridges.get(codeName);
@@ -10658,6 +10747,8 @@ function stopOpencodeSession(codeName, log2) {
   }
   stopTranscriptRefresher(codeName);
   bridges.delete(codeName);
+  turnOutcomeTracker.reset(codeName);
+  loggers.delete(codeName);
   const session = sessions.get(codeName);
   if (session) {
     session.status = "stopped";
@@ -10668,6 +10759,9 @@ function stopOpencodeSession(codeName, log2) {
 function getOpencodeSessionState(codeName) {
   return sessions.get(codeName) ?? null;
 }
+function getOpencodeTurnHealth(codeName) {
+  return turnOutcomeTracker.get(codeName);
+}
 function stripUndefined(env2) {
   const out = {};
   for (const [k, v] of Object.entries(env2)) if (v !== void 0) out[k] = v;
@@ -12254,6 +12348,7 @@ function collectDiagnostics(codeNames, quarantineEntriesFor) {
     if (oc) {
       const serveAlive = isOpencodeSessionHealthy(codeName);
       const status = serveAlive ? oc.status : oc.status === "running" ? "crashed" : oc.status;
+      const turn = getOpencodeTurnHealth(codeName);
       return {
         codeName,
         framework: "opencode",
@@ -12267,7 +12362,15 @@ function collectDiagnostics(codeNames, quarantineEntriesFor) {
         launchArgs: null,
         channelStatus: null,
         isolated: isolationMode(codeName) === "docker",
-        quarantinedChannels
+        quarantinedChannels,
+        ...turn ? {
+          turnHealth: {
+            lastOutcome: turn.lastOutcome,
+            lastRepliedAt: turn.lastRepliedAt ? new Date(turn.lastRepliedAt).toISOString() : null,
+            lastAttemptAt: turn.lastAttemptAt ? new Date(turn.lastAttemptAt).toISOString() : null,
+            consecutiveFailures: turn.consecutiveFailures
+          }
+        } : {}
       };
     }
     const session = sessions2.get(codeName);
@@ -12454,6 +12557,7 @@ export {
   isOpencodeSessionHealthy,
   injectOpencodeMessage,
   stopOpencodeSession,
+  getOpencodeSessionState,
   sessionTranscriptDir,
   transcriptActivityAgeSeconds,
   subagentActivityAgeSeconds,
@@ -12502,4 +12606,4 @@ export {
   stopAllSessionsAndWait,
   getProjectDir
 };
-//# sourceMappingURL=chunk-YLLK4G3B.js.map
+//# sourceMappingURL=chunk-QZUKHEMO.js.map