@integrity-labs/agt-cli 0.28.416 → 0.28.418

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

@@ -8054,9 +8054,9 @@ var FLAG_REGISTRY = [
   },
   {
     key: "compaction-notice",
-    description: 'Compaction courtesy notice (ENG-7339): when a managed Claude Code session compacts its context, the persistent session pauses and stops replying for a stretch, which looks identical to a dead agent from the channel. When ON, the generated PreCompact hook finds the conversation the user is actively on (the last <channel ...> tag in the transcript) and drops a notice into the matching <channel>-notice-outbox; the channel MCP server (alive while the Claude process compacts) posts a short "reorganizing my memory, back shortly" line. The notice path never clears the pending-inbound marker, so the genuine reply the agent still owes after compaction is unaffected. No active channel tag \u21D2 silent (idle agents never broadcast). Boolean gate; ships dark, canary per host before any fleet flip. When OFF the hook writes nothing and the consumer drops any stray notice unsent.',
+    description: 'Compaction courtesy notice (ENG-7339): when a managed Claude Code session compacts its context, the persistent session pauses and stops replying for a stretch, which looks identical to a dead agent from the channel. When ON, the generated PreCompact hook finds the conversation the user is actively on (the last <channel ...> tag in the transcript) and drops a notice into the matching <channel>-notice-outbox; the channel MCP server (alive while the Claude process compacts) posts a short "reorganizing my memory, back shortly" line. The notice path never clears the pending-inbound marker, so the genuine reply the agent still owes after compaction is unaffected. No active channel tag \u21D2 silent (idle agents never broadcast). Default ON (ENG-8040: introduced dark on 2026-07-23 via ENG-7339, never activated in prod; Brad Bond reported Sherlock went silent mid-compaction with no notice). Set AGT_COMPACTION_NOTICE_ENABLED=false or override via the Feature Flags admin page to disable per-host. When OFF the hook writes nothing and the consumer drops any stray notice unsent.',
     flagType: "boolean",
-    defaultValue: false,
+    defaultValue: true,
     envVar: "AGT_COMPACTION_NOTICE_ENABLED"
   },
   {
@@ -8230,6 +8230,21 @@ var FLAG_REGISTRY = [
     // AGT_CONV_EVAL_BACKEND keeps that value until the env var is retired.
     envVar: "AGT_CONV_EVAL_BACKEND"
   },
+  {
+    key: "synthetic-probe-enabled",
+    description: 'Global gate for the agent synthetic-liveness cron (ENG-8074). When OFF, the cron exits after reading the flag \u2014 no probes sent, no metrics emitted, no CloudWatch alarms fired, near-zero DB footprint. Ships dark (OFF) because the probe cron was generating false positives (probe_timeout on angie for 7+ days while healthy, ENG-8048) and had open cron_invocation_errors alarms (since 2026-07-23). Flip ON per-environment via the admin Feature Flags page once the reliability issues are resolved. The existing AUGMENTED_SYNTHETIC_PROBE_ENABLED env var is the declared envVar for this flag (ADR-0022): set it to "true"/"1" to force-enable (env takes precedence over the DB stage value), or "false"/"0" to force-disable without a DB lookup. Evaluated as a global stage value by the central cron (no per-org targeting). Boolean gate.',
+    flagType: "boolean",
+    // Safe/dark default: false = probe off. This encodes the ENG-8074 intent (disable
+    // in prod until reliability issues are resolved) and is the fail-safe direction for
+    // a flag-DB read error — a hiccup degrades to keeping the cron dormant rather than
+    // silently re-arming a broken probe fleet-wide.
+    // The env var AUGMENTED_SYNTHETIC_PROBE_ENABLED was the pre-flag emergency kill switch
+    // (read as `!== 'false'`, so unset = probe ON). The flag inverts this: unset env var
+    // now resolves to the flag default (OFF). Set AUGMENTED_SYNTHETIC_PROBE_ENABLED=true to
+    // explicitly re-arm the probe via env, or flip the flag ON from the admin UI.
+    defaultValue: false,
+    envVar: "AUGMENTED_SYNTHETIC_PROBE_ENABLED"
+  },
   {
     key: "synthetic-probe-on-metered-hosts",
     description: "Synthetic liveness probing of OpenRouter-metered agents (ENG-7235). On a host whose claude_auth_mode='openrouter' every model call is per-token cost, so the hourly synthetic probe (a full inbound\u2192session\u2192model\u2192outbound round-trip whose only output is a probe_ack) is real spend for zero deliverable - unlike a Max-subscription host where it is effectively free. When OFF (default) the synthetic-probe cron skips OpenRouter-mode agents entirely; their liveness falls back to the zero-token signals (pane-activity ENG-5399 + manager heartbeat + inbound-loop liveness ENG-5614). When ON, metered agents are probed like every other agent (the pre-ENG-7235 behaviour) - the explicit opt-in for an operator who wants the end-to-end check and accepts the cost. Subscription / api_key hosts are unaffected either way. Evaluated as a global stage value by the central cron (no per-org targeting in v1). Boolean gate.",
@@ -10295,12 +10310,66 @@ var TurnOutcomeTracker = class {
   }
 };
 
+// src/lib/opencode-activity-tracker.ts
+var OpencodeActivityTracker = class {
+  state = /* @__PURE__ */ new Map();
+  entry(codeName) {
+    let cur = this.state.get(codeName);
+    if (!cur) {
+      cur = { inFlight: 0, lastActiveAt: null };
+      this.state.set(codeName, cur);
+    }
+    return cur;
+  }
+  /** A turn has been dispatched to the serve. Call BEFORE awaiting it. */
+  beginTurn(codeName) {
+    this.entry(codeName).inFlight += 1;
+  }
+  /**
+   * A dispatched turn has resolved. Call in a `finally`, so a throw cannot
+   * strand the agent permanently "busy" — a leaked in-flight count would pin
+   * the age at 0 forever and bill the agent around the clock.
+   *
+   * `counted` is false for a gate decline: it occupied the agent for the
+   * microseconds the gate took, and nothing more.
+   */
+  endTurn(codeName, counted, now = Date.now()) {
+    const cur = this.entry(codeName);
+    cur.inFlight = Math.max(0, cur.inFlight - 1);
+    if (counted) cur.lastActiveAt = now;
+  }
+  /**
+   * Seconds since this agent was last doing work, or null if it never has been
+   * in this manager generation.
+   *
+   * 0 while any turn is in flight — see the interval rationale above. Null is
+   * "no signal", NOT "idle": the API omits the field entirely so a mixed-version
+   * fleet cannot have a silent old CLI read as a busy agent (or vice versa).
+   */
+  activityAgeSeconds(codeName, now = Date.now()) {
+    const cur = this.state.get(codeName);
+    if (!cur) return null;
+    if (cur.inFlight > 0) return 0;
+    if (cur.lastActiveAt == null) return null;
+    return Math.max(0, Math.floor((now - cur.lastActiveAt) / 1e3));
+  }
+  /**
+   * Drop all state for an agent, so a fresh serve is not born holding the dead
+   * one's in-flight count. Called from the same teardown path that resets turn
+   * health.
+   */
+  reset(codeName) {
+    this.state.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 activityTracker = new OpencodeActivityTracker();
 var bridges = /* @__PURE__ */ new Map();
 function opencodeTmuxSession(codeName) {
   return `agt-oc-${codeName}`;
@@ -10641,18 +10710,28 @@ async function injectOpencodeMessage(codeName, msg, opts = {}) {
     return { status: "declined", reason: "server_not_running" };
   }
   const bridge = getBridge(codeName, session.port, session.password);
+  activityTracker.beginTurn(codeName);
+  let occupied = true;
   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";
+    occupied = outcome !== "declined";
     noteOpencodeTurnOutcome(codeName, outcome, session);
     return result;
   } catch (err) {
     noteOpencodeTurnOutcome(codeName, "failed", session);
     throw err;
+  } finally {
+    if (isLiveOpencodeSession(codeName, session)) {
+      activityTracker.endTurn(codeName, occupied);
+    }
   }
 }
+function isLiveOpencodeSession(codeName, startedOn) {
+  return sessions.get(codeName) === startedOn && startedOn.status === "running";
+}
 function noteOpencodeTurnOutcome(codeName, outcome, startedOn) {
-  if (sessions.get(codeName) !== startedOn || startedOn.status !== "running") return;
+  if (!isLiveOpencodeSession(codeName, startedOn)) return;
   const { health, shouldWarn, recovered } = turnOutcomeTracker.record(codeName, outcome);
   const log2 = loggers.get(codeName);
   if (!log2) return;
@@ -10748,6 +10827,7 @@ function stopOpencodeSession(codeName, log2) {
   stopTranscriptRefresher(codeName);
   bridges.delete(codeName);
   turnOutcomeTracker.reset(codeName);
+  activityTracker.reset(codeName);
   loggers.delete(codeName);
   const session = sessions.get(codeName);
   if (session) {
@@ -10762,6 +10842,9 @@ function getOpencodeSessionState(codeName) {
 function getOpencodeTurnHealth(codeName) {
   return turnOutcomeTracker.get(codeName);
 }
+function getOpencodeActivityAgeSeconds(codeName, now = Date.now()) {
+  return activityTracker.activityAgeSeconds(codeName, now);
+}
 function stripUndefined(env2) {
   const out = {};
   for (const [k, v] of Object.entries(env2)) if (v !== void 0) out[k] = v;
@@ -12558,6 +12641,8 @@ export {
   injectOpencodeMessage,
   stopOpencodeSession,
   getOpencodeSessionState,
+  getOpencodeTurnHealth,
+  getOpencodeActivityAgeSeconds,
   sessionTranscriptDir,
   transcriptActivityAgeSeconds,
   subagentActivityAgeSeconds,
@@ -12606,4 +12691,4 @@ export {
   stopAllSessionsAndWait,
   getProjectDir
 };
-//# sourceMappingURL=chunk-QZUKHEMO.js.map
+//# sourceMappingURL=chunk-IE7ZJKF3.js.map