@integrity-labs/agt-cli 0.28.1137 → 0.28.1139

package/dist/{chunk-HZFUOGUV.js → chunk-PI2WUKWD.js}

@@ -16,7 +16,7 @@ import {
   parseEnvFileEntries,
   parseEnvIntegrations,
   shellQuote
-} from "./chunk-LQCWKNFX.js";
+} from "./chunk-7U4VSBOE.js";
 import {
   BIND_FAILURE_QUARANTINE_THRESHOLD,
   INTEGRATIONS_SECTION_END,
@@ -79,7 +79,7 @@ import {
   sessionTranscriptDir,
   worseConnectivityOutcome,
   wrapScheduledTaskPrompt
-} from "./chunk-WIU4HUHD.js";
+} from "./chunk-DYFE224A.js";
 import {
   classifyUnanswerablePane,
   isConsumerTermsDialogVisible,
@@ -8076,7 +8076,7 @@ function exchangeFailureKind(err) {
 }
 
 // src/lib/api-client.ts
-var agtCliVersion = true ? "0.28.1137" : "dev";
+var agtCliVersion = true ? "0.28.1139" : "dev";
 var lastConfigHash = null;
 function setConfigHash(hash) {
   lastConfigHash = hash && hash.length > 0 ? hash : null;
@@ -13227,4 +13227,4 @@ export {
   managerInstallSystemUnitCommand,
   managerUninstallSystemUnitCommand
 };
-//# sourceMappingURL=chunk-HZFUOGUV.js.map
+//# sourceMappingURL=chunk-PI2WUKWD.js.map

package/dist/{claude-pair-runtime-OZLZFJZR.js → claude-pair-runtime-BOTE3DRW.js}

@@ -269,7 +269,7 @@ async function spawnPairSession(session) {
     return { ok: true };
   } catch {
   }
-  const { resolveClaudeBinary } = await import("./persistent-session-2X3BCGV5.js");
+  const { resolveClaudeBinary } = await import("./persistent-session-6O66QEI4.js");
   const claudeBin = resolveClaudeBinary();
   const pairEnv = {
     ...process.env,
@@ -739,4 +739,4 @@ export {
   startClaudePair,
   submitClaudePairCode
 };
-//# sourceMappingURL=claude-pair-runtime-OZLZFJZR.js.map
+//# sourceMappingURL=claude-pair-runtime-BOTE3DRW.js.map

package/dist/lib/manager-worker.js

@@ -76,7 +76,7 @@ import {
   setConfigHash,
   shellGuard,
   tripClass
-} from "../chunk-HZFUOGUV.js";
+} from "../chunk-PI2WUKWD.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -163,7 +163,7 @@ import {
   webFetchBaselineValue,
   webFetchRestartNeeded,
   writeEgressAllowlist
-} from "../chunk-LQCWKNFX.js";
+} from "../chunk-7U4VSBOE.js";
 import {
   ACCOUNT_ENFORCEMENT_MARKER_FILENAME,
   AnchorSessionClient,
@@ -274,7 +274,7 @@ import {
   subagentActivityAgeSeconds,
   sumTranscriptUsageInWindow,
   transcriptActivityAgeSeconds
-} from "../chunk-WIU4HUHD.js";
+} from "../chunk-DYFE224A.js";
 import {
   classifyUnanswerablePane,
   focusedConfirmDialogBlock,
@@ -321,6 +321,173 @@ function defaultUnique() {
   return `${process.pid}-${seq}-${Date.now().toString(36)}`;
 }
 
+// src/lib/host-node-pin.ts
+var HOST_NODE_PIN_VERSION_RE = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+var HOST_NODE_PIN_MIN_MAJOR = 22;
+function normalizeHostNodePinVersion(raw) {
+  if (raw == null) return null;
+  const v = raw.trim().replace(/^v/, "");
+  if (!HOST_NODE_PIN_VERSION_RE.test(v)) return null;
+  const major = Number(v.split(".")[0]);
+  if (!Number.isInteger(major) || major < HOST_NODE_PIN_MIN_MAJOR) return null;
+  return v;
+}
+
+// src/lib/host-node-convergence.ts
+var HOST_NODE_RETRY_MS = 15 * 6e4;
+var HOST_NODE_MAX_FAILURES = 3;
+var HostNodeConvergence = class {
+  constructor(maxFailures = HOST_NODE_MAX_FAILURES, retryMs = HOST_NODE_RETRY_MS) {
+    this.maxFailures = maxFailures;
+    this.retryMs = retryMs;
+  }
+  converged = /* @__PURE__ */ new Set();
+  abandoned = /* @__PURE__ */ new Set();
+  failures = /* @__PURE__ */ new Map();
+  retryAfter = /* @__PURE__ */ new Map();
+  /**
+   * The ONE pin currently installing, or null. Deliberately a single slot
+   * rather than a per-pin set: see {@link shouldAttempt}.
+   */
+  inFlightPin = null;
+  lastDesired = null;
+  /**
+   * Record what the control plane currently wants, and discard stale
+   * conclusions when that changes.
+   *
+   * Keying per pin is necessary but NOT sufficient, which is the hole CodeRabbit
+   * found on #7088. Every state here is a claim about THIS HOST'S DISK at some
+   * past moment, and a pin change invalidates all of them: if the fleet moves
+   * 22.23.4 -> 22.23.5 and later back to 22.23.4, the disk now holds 22.23.5,
+   * while `converged` still asserts 22.23.4 from before. Without this the
+   * manager would skip the re-install forever on the strength of a measurement
+   * that a later install had already falsified - and 'converged' would once again
+   * mean something other than "this host is on the pin", which is the one thing
+   * this class exists to keep true.
+   *
+   * Clearing is cheap to be wrong about in the safe direction: a re-attempt
+   * reads `node --version` once and, if the disk already matches, records
+   * success immediately.
+   *
+   * `null` means NO pin is in force — the control plane sent none, or sent one
+   * this host refused as malformed. That must be recorded rather than ignored,
+   * which was the second hole on #7088: skipping the call left `lastDesired`
+   * pointing at the last pin seen, so clearing A and later restoring it looked
+   * like no change at all. Any drift on disk during the cleared window —
+   * an OS patch, an AMI replacement, a manual install — then survived
+   * indefinitely, because the restored pin's stale 'converged' suppressed the
+   * one disk read that would have caught it.
+   */
+  noteDesiredPin(pin) {
+    if (this.lastDesired === pin) return;
+    this.lastDesired = pin;
+    this.converged.clear();
+    this.abandoned.clear();
+    this.failures.clear();
+    this.retryAfter.clear();
+  }
+  /** The pin last passed to {@link noteDesiredPin}, for reporting. */
+  desiredPin() {
+    return this.lastDesired;
+  }
+  stateOf(pin, now = Date.now()) {
+    if (this.converged.has(pin)) return "converged";
+    if (this.abandoned.has(pin)) return "abandoned";
+    if ((this.retryAfter.get(pin) ?? 0) > now) return "cooling";
+    return "ready";
+  }
+  /**
+   * Whether to start an attempt now. False while ANY attempt is running —
+   * across pins, not just this one.
+   *
+   * Per-pin gating was the hole CodeRabbit found on #7088, and it is reachable
+   * because the caller is fire-and-forget while a `dnf install` may run for ten
+   * minutes. Sequence: A is converged; the pin moves to B and an install
+   * starts; the pin reverts to A. {@link noteDesiredPin} clears A's stale
+   * conclusion (correctly), a per-pin gate does not see B's attempt, so an A
+   * attempt starts WHILE B is installing. It reads the disk, which still says
+   * A, and records A as converged. B's install then lands, leaving B on disk
+   * with `converged` asserting A — and because that is terminal, every later
+   * poll skips the check. The host sits off-pin permanently while this class
+   * claims otherwise, which is the exact failure it was written to prevent.
+   *
+   * Serializing costs nothing in the steady state: convergence is a once-per
+   * -pin event, and a skipped poll retries ~10s later.
+   */
+  shouldAttempt(pin, now = Date.now()) {
+    if (this.inFlightPin !== null) return false;
+    return this.stateOf(pin, now) === "ready";
+  }
+  /** The pin currently installing, or null. For reporting and for tests. */
+  inFlight() {
+    return this.inFlightPin;
+  }
+  beginAttempt(pin) {
+    this.inFlightPin = pin;
+  }
+  endAttempt(pin) {
+    if (this.inFlightPin === pin) this.inFlightPin = null;
+  }
+  /**
+   * The on-disk version now equals the pin. Clears any failure history.
+   *
+   * A success for a pin that is no longer the desired one is DISCARDED. An
+   * attempt can outlive the pin that started it, and 'converged' is terminal —
+   * so recording it would suppress all future attempts on the strength of a
+   * measurement taken against a pin nobody wants any more. Dropping it costs
+   * one extra disk read if that pin is ever requested again.
+   *
+   * The guard is inactive until {@link noteDesiredPin} has been called at least
+   * once, so a caller that does not track a desired pin is unaffected.
+   */
+  recordSuccess(pin) {
+    if (this.lastDesired !== null && pin !== this.lastDesired) return;
+    this.converged.add(pin);
+    this.abandoned.delete(pin);
+    this.failures.delete(pin);
+    this.retryAfter.delete(pin);
+  }
+  /**
+   * An attempt failed. Returns the resulting state so the caller can log the
+   * right thing: 'cooling' means it will retry, 'abandoned' means it will not.
+   */
+  recordFailure(pin, now = Date.now()) {
+    const count = (this.failures.get(pin) ?? 0) + 1;
+    this.failures.set(pin, count);
+    if (count >= this.maxFailures) {
+      this.abandoned.add(pin);
+      this.retryAfter.delete(pin);
+      return "abandoned";
+    }
+    this.retryAfter.set(pin, now + this.retryMs);
+    return "cooling";
+  }
+  attemptCount(pin) {
+    return this.failures.get(pin) ?? 0;
+  }
+  /**
+   * Every pin this host stopped trying to reach. A non-empty result means "a
+   * patch the control plane asked for is NOT applied and nothing is retrying".
+   *
+   * BE PRECISE ABOUT WHO CAN SEE THAT, because this module's header argues for
+   * telling abandonment apart from success "from outside" and Obi Wan correctly
+   * pointed out (#7088) that the claim outruns the code. Nothing in production
+   * reads this method, `stateOf`, `desiredPin` or `inFlight`: the state is not
+   * reported to the API, the heartbeat, or any console surface. The only signal
+   * that leaves the host is one `[host-node] … GIVING UP` line in manager.log.
+   *
+   * So what this class actually buys today is that the DISTINCTION EXISTS and
+   * cannot collapse — `converged` can never come to mean "gave up", which is
+   * the `ensureIsolationImage` defect the header cites. Surfacing it is a
+   * separate, unbuilt piece of work (ENG-11617 acceptance criterion 6), and it
+   * matters most for a BYO host in a customer account, which is the one
+   * population we cannot inspect any other way.
+   */
+  abandonedPins() {
+    return [...this.abandoned];
+  }
+};
+
 // src/lib/manager-worker.ts
 import { execFileSync as syncExecFile } from "child_process";
 import { join as join43, dirname as dirname11, delimiter as pathDelimiter } from "path";
@@ -14491,7 +14658,7 @@ var pendingDayRolloverReset = /* @__PURE__ */ new Set();
 var dayRolloverInboundHold = /* @__PURE__ */ new Map();
 var INBOUND_HOLD_EPISODE_GAP_MS = 12e4;
 async function channelInboundActivityAgeSecondsFor(codeName) {
-  const { newestPendingInboundActivityMtimeMs } = await import("../responsiveness-probe-QFLFS5QX.js");
+  const { newestPendingInboundActivityMtimeMs } = await import("../responsiveness-probe-WGD3NDWG.js");
   const newest = newestPendingInboundActivityMtimeMs(dirname11(paneLogPath(codeName)));
   if (newest === null) return null;
   return Math.max(0, Math.floor((Date.now() - newest) / 1e3));
@@ -15249,7 +15416,7 @@ var agentRestartTimezoneInputs = /* @__PURE__ */ new Map();
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.28.1137" : "dev";
+var agtCliVersion = true ? "0.28.1139" : "dev";
 function resolveBrewPath(execFileSync3) {
   try {
     const out = execFileSync3("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -15413,6 +15580,81 @@ function recordIsolationImageFailure(imageUri, reason) {
     isolationImageRetryAfter.set(imageUri, Date.now() + ISOLATION_IMAGE_RETRY_MS);
   }
 }
+var hostNodeConvergence = new HostNodeConvergence();
+var hostNodeInvalidLogged = /* @__PURE__ */ new Set();
+var hostNodeNoDnfLogged = false;
+function recordHostNodeFailure(pin, reason) {
+  const outcome = hostNodeConvergence.recordFailure(pin);
+  const attempts = hostNodeConvergence.attemptCount(pin);
+  if (outcome === "abandoned") {
+    log(
+      `[host-node] ${reason} \u2014 GIVING UP after ${attempts} attempts. Host Node is NOT on ${pin} and nothing will retry until the manager restarts. This host remains unpatched (ENG-11617).`
+    );
+  } else {
+    log(`[host-node] ${reason} (attempt ${attempts}/${HOST_NODE_MAX_FAILURES}, retrying in ${HOST_NODE_RETRY_MS / 6e4}m)`);
+  }
+}
+async function diskNodeVersion() {
+  const probe = await runAsync("node", ["--version"], { timeout: 15e3 });
+  if (probe.code !== 0) return null;
+  const m = /^v?(\d+\.\d+\.\d+)/.exec(probe.stdout.trim());
+  return m?.[1] ?? null;
+}
+async function ensureHostNodeVersion(rawPin) {
+  const pin = normalizeHostNodePinVersion(rawPin);
+  if (!pin) {
+    const raw = rawPin == null ? "" : String(rawPin).trim();
+    if (raw !== "" && !hostNodeInvalidLogged.has(raw)) {
+      hostNodeInvalidLogged.add(raw);
+      log(`[host-node] ignoring malformed desired_node_version '${raw.slice(0, 40)}' - not an exact MAJOR.MINOR.PATCH at or above major ${HOST_NODE_PIN_MIN_MAJOR}`);
+    }
+    hostNodeConvergence.noteDesiredPin(null);
+    return;
+  }
+  hostNodeConvergence.noteDesiredPin(pin);
+  if (!hostNodeConvergence.shouldAttempt(pin)) return;
+  hostNodeConvergence.beginAttempt(pin);
+  try {
+    const current = await diskNodeVersion();
+    if (current === pin) {
+      hostNodeConvergence.recordSuccess(pin);
+      return;
+    }
+    const { execFileSync: execFileSync3 } = await import("child_process");
+    try {
+      execFileSync3("which", ["dnf"], { timeout: 5e3, stdio: "pipe" });
+    } catch {
+      if (!hostNodeNoDnfLogged) {
+        hostNodeNoDnfLogged = true;
+        log(`[host-node] 'dnf' not found - cannot converge host Node onto ${pin} on this platform (leaving ${current ?? "unknown"} in place)`);
+      }
+      hostNodeConvergence.recordSuccess(pin);
+      return;
+    }
+    const asRoot = typeof process.getuid === "function" && process.getuid() === 0;
+    const pkg = `nodejs-${pin}`;
+    const dnfArgs = ["-y", "--refresh", "install", pkg];
+    const bin = asRoot ? "dnf" : "sudo";
+    const argv = asRoot ? dnfArgs : ["-n", "dnf", ...dnfArgs];
+    log(`[host-node] converging host Node ${current ?? "unknown"} -> ${pin}\u2026`);
+    const res = await runAsync(bin, argv, { timeout: 6e5 });
+    if (res.code !== 0) {
+      recordHostNodeFailure(pin, `install of ${pkg} failed (exit ${res.code}): ${(res.stderr || res.stdout).slice(0, 300)}`);
+      return;
+    }
+    const after = await diskNodeVersion();
+    if (after !== pin) {
+      recordHostNodeFailure(pin, `installer reported success but on-disk Node is ${after ?? "unreadable"}, not ${pin}`);
+      return;
+    }
+    log(`[host-node] host Node is now ${pin} on disk. Running processes keep the previous binary until they restart - this does NOT restart the manager (ENG-11617).`);
+    hostNodeConvergence.recordSuccess(pin);
+  } catch (err) {
+    recordHostNodeFailure(pin, `install attempt threw: ${isolationImageErrDetail(err)}`);
+  } finally {
+    hostNodeConvergence.endAttempt(pin);
+  }
+}
 async function ensureIsolationImage(imageUri) {
   if (process.env.AGT_ISOLATION_IMAGE) return;
   if (!imageUri || isolationImageEnsured.has(imageUri)) return;
@@ -16879,7 +17121,7 @@ function flushRestartedAgentDiagnostics(hostId, codeNames) {
   if (codeNames.length === 0) return;
   void (async () => {
     try {
-      const { collectDiagnostics } = await import("../persistent-session-2X3BCGV5.js");
+      const { collectDiagnostics } = await import("../persistent-session-6O66QEI4.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics(codeNames, quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor, forwardedToolsFor, runtimeVersionFor)
@@ -17021,7 +17263,7 @@ async function pollCycleInner() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-KQYYZZVW.js");
-      const { collectDiagnostics } = await import("../persistent-session-2X3BCGV5.js");
+      const { collectDiagnostics } = await import("../persistent-session-6O66QEI4.js");
       const diagCodeNames = [...agentState.persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames, quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor, forwardedToolsFor, runtimeVersionFor) : void 0;
       let tailscaleHostname;
@@ -17229,7 +17471,7 @@ async function pollCycleInner() {
         collectPanelessActivityProbes,
         getResponsivenessIntervalMs,
         occupancyQualificationClassifications
-      } = await import("../responsiveness-probe-QFLFS5QX.js");
+      } = await import("../responsiveness-probe-WGD3NDWG.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
         const probeCodeNames = [...agentState.persistentSessionAgents];
@@ -17346,7 +17588,7 @@ async function pollCycleInner() {
           collectResponsivenessProbes,
           livePendingInboundOldestAgeSeconds,
           parkPendingInbound
-        } = await import("../responsiveness-probe-QFLFS5QX.js");
+        } = await import("../responsiveness-probe-WGD3NDWG.js");
         const { getProjectDir: wedgeProjectDir } = await import("../scheduler-engine-M6AFZWNU.js");
         const wedgeNow = /* @__PURE__ */ new Date();
         const liveAgents = agentState.persistentSessionAgents;
@@ -17632,7 +17874,7 @@ async function pollCycleInner() {
                 }
               }
             );
-            const { parkPendingInbound } = await import("../responsiveness-probe-QFLFS5QX.js");
+            const { parkPendingInbound } = await import("../responsiveness-probe-WGD3NDWG.js");
             const { parked, deadLettered } = parkPendingInbound(codeName, new Date(fatalNowMs));
             paneFatalStreak.delete(codeName);
             paneFatalRestarts.set(codeName, [...history, fatalNowMs]);
@@ -17663,7 +17905,7 @@ async function pollCycleInner() {
         TRANSCRIPT_MOUNT_ESCALATION_REFRESH_MS,
         bindSourceEscalations
       } = await import("../transcript-mount-health-OHE6IVJV.js");
-      const { transcriptBindSourcesFor, ensureTranscriptBindSources } = await import("../persistent-session-2X3BCGV5.js");
+      const { transcriptBindSourcesFor, ensureTranscriptBindSources } = await import("../persistent-session-6O66QEI4.js");
       const mountConfig = resolveTranscriptMountConfig();
       const liveAgents = agentState.persistentSessionAgents;
       for (const tracked of [
@@ -17828,7 +18070,7 @@ async function pollCycleInner() {
     }
     try {
       const { scrapeMcpFailedBannerCount } = await import("../pane-mcp-banner-scraper-VR5QGP3J.js");
-      const { probeSessionAuth } = await import("../session-auth-dead-QE7GT5Y5.js");
+      const { probeSessionAuth } = await import("../session-auth-dead-6N2AEFKX.js");
       const observations = [];
       const pendingCacheCommits = [];
       const modelApiErrorReportingOn = hostFlagStore().getBoolean("model-api-error-reporting");
@@ -20633,6 +20875,9 @@ async function processAgent(agent, agentStates, managedToolkits) {
           log(`[isolation-image] unexpected managed-pull failure: ${isolationImageErrDetail(err)}`);
         });
       }
+      void ensureHostNodeVersion(refreshAny.desired_node_version).catch((err) => {
+        log(`[host-node] unexpected convergence failure: ${isolationImageErrDetail(err)}`);
+      });
       const agentFw2 = agentFrameworkCache.get(agent.code_name) ?? DEFAULT_FRAMEWORK;
       if (agentFw2 === "claude-code" && installedIntegrationSkills.length > 0 && isSessionHealthy(agent.code_name)) {
         const names = installedIntegrationSkills.join(", ");
@@ -22423,7 +22668,7 @@ async function handleRestartDoorbell(agentId, requestedAt, restartReason) {
       try {
         const freshId = rotateSessionForWedge(codeName);
         consecutiveWedgeCycles.delete(codeName);
-        const { parkPendingInbound: parkForRestart } = await import("../responsiveness-probe-QFLFS5QX.js");
+        const { parkPendingInbound: parkForRestart } = await import("../responsiveness-probe-WGD3NDWG.js");
         const { parked, deadLettered } = parkForRestart(codeName, /* @__PURE__ */ new Date());
         const parkNote = parked > 0 ? `, ${parked} inbound parked` : "";
         const deadNote = deadLettered > 0 ? `, ${deadLettered} undeliverable dead-lettered` : "";
@@ -22466,7 +22711,7 @@ async function handleRestartDoorbell(agentId, requestedAt, restartReason) {
     void api.post("/host/restart-ack", { host_id: hostId, agent_id: agentId, restart_requested_at: requestedAt }).catch((err) => log(`[restart-lane] ack failed for '${codeName}': ${err.message}`));
     void (async () => {
       try {
-        const { collectDiagnostics } = await import("../persistent-session-2X3BCGV5.js");
+        const { collectDiagnostics } = await import("../persistent-session-6O66QEI4.js");
         await api.post("/host/heartbeat", {
           host_id: hostId,
           agent_diagnostics: collectDiagnostics([codeName], quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor, forwardedToolsFor, runtimeVersionFor)
@@ -22517,7 +22762,7 @@ async function respawnAgentAfterMcpStop(codeName, reason) {
     }
     try {
       const hostId = await getHostId();
-      const { collectDiagnostics } = await import("../persistent-session-2X3BCGV5.js");
+      const { collectDiagnostics } = await import("../persistent-session-6O66QEI4.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics([codeName], quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor, forwardedToolsFor, runtimeVersionFor)
@@ -23190,7 +23435,7 @@ async function processClaudePairSessions(agents) {
     // cannot take it for itself — by the time it runs, the write it is looking
     // for may already have happened.
     snapshotPairConfig
-  } = await import("../claude-pair-runtime-OZLZFJZR.js");
+  } = await import("../claude-pair-runtime-BOTE3DRW.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));