@integrity-labs/agt-cli 0.28.1112 → 0.28.1114

package/dist/{chunk-TJUDOE53.js → chunk-J3L66T65.js}

@@ -16,7 +16,7 @@ import {
   parseEnvFileEntries,
   parseEnvIntegrations,
   shellQuote
-} from "./chunk-5EYINOIW.js";
+} from "./chunk-2XQPQOJX.js";
 import {
   BIND_FAILURE_QUARANTINE_THRESHOLD,
   INTEGRATIONS_SECTION_END,
@@ -79,7 +79,7 @@ import {
   sessionTranscriptDir,
   worseConnectivityOutcome,
   wrapScheduledTaskPrompt
-} from "./chunk-NO57I56V.js";
+} from "./chunk-OBZB6MUE.js";
 import {
   classifyUnanswerablePane,
   isConsumerTermsDialogVisible,
@@ -7518,7 +7518,7 @@ function exchangeFailureKind(err) {
 }
 
 // src/lib/api-client.ts
-var agtCliVersion = true ? "0.28.1112" : "dev";
+var agtCliVersion = true ? "0.28.1114" : "dev";
 var lastConfigHash = null;
 function setConfigHash(hash) {
   lastConfigHash = hash && hash.length > 0 ? hash : null;
@@ -7818,7 +7818,8 @@ function atomicWriteFileSync(path, data) {
 }
 
 // src/lib/feature-flags-host.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6, statSync as statSync2 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync6, rmSync as rmSync3, statSync as statSync2 } from "fs";
+import { homedir as homedir5 } from "os";
 import { join as join6 } from "path";
 function defaultFlagsCachePath(configDir) {
   return join6(configDir, "flags-cache.json");
@@ -7896,9 +7897,14 @@ var HostFlagStore = class {
    * `getBooleanForAgent` reads so a boolean gate (today only
    * `id-keyed-layout-migration`) can be armed one agent at a time. Held in
    * memory only and re-sent every heartbeat - deliberately NOT persisted to the
-   * flags cache (which is a host-wide map), so a restart cleanly falls back to
-   * the host-wide value until the next heartbeat rather than pinning a stale
-   * per-agent opt-in. Empty until the API sends `feature_flags_by_agent` (the
+   * HOST-WIDE flags cache, so a restart cleanly falls back to the host-wide
+   * value until the next heartbeat rather than pinning a stale per-agent opt-in.
+   *
+   * ENG-11436: it IS folded into each agent's own mirror (see
+   * {@link mirrorAgentIds}), because that file is this agent's resolved view and
+   * an override absent from it would resolve to the host-wide value inside the
+   * container - which is the bug, not the design. A mirror is rewritten from
+   * memory on every heartbeat, so it pins nothing across a restart either. Empty until the API sends `feature_flags_by_agent` (the
    * flag ships dark, so it stays empty and every agent resolves host-wide).
    */
   booleanFlagsByAgent = {};
@@ -7909,7 +7915,58 @@ var HostFlagStore = class {
    * clobbering it to empty. Hydrated from the cache on init().
    */
   lastSchemaVersion = "";
+  /**
+   * ENG-11436: the `updated_at` to stamp, meaning WHEN THE FLAG DATA LAST
+   * CHANGED — not when a file was last written.
+   *
+   * `setMirrorAgentIds` persists on a roster change, and a roster change is not
+   * a flag refresh. Stamping `new Date()` there restamped a possibly-days-old
+   * map as current: on boot `init()` hydrates the last-known-good cache, the
+   * first poll moves the roster from [] to N agents, and the stale map is
+   * written out as fresh. `flagsCacheAgeSeconds` is built on `updated_at`, so
+   * `agt flags` then reported a stale cache as current — and the runbook's new
+   * "confirm `updated_at` is recent" check became a false trust signal exactly
+   * when heartbeats were failing. Obi Wan `c9d73bded1eb` on #6918.
+   *
+   * Hydrated from the cache on init and advanced only when the flag data
+   * ACTUALLY CHANGES (see `noteFlagDataChange`), so neither a roster-only write
+   * nor the every-heartbeat no-op clear of an already-empty per-agent map
+   * restamps a stale map as current.
+   */
+  lastFlagsUpdatedAt = "";
   cachePath;
+  /**
+   * ENG-11436: agent ids to MIRROR the resolved flag map to, as
+   * `~/.augmented/<agentId>/flags-cache.json` — the HOME-based root, which is
+   * where the MCP reader looks and what Docker mounts, and which is therefore
+   * NOT derived from `cachePath` (those diverge under `--config-dir`).
+   *
+   * WHY A SECOND COPY EXISTS AT ALL. The host-wide cache this class writes is
+   * `~/.augmented/flags-cache.json`, and a Docker-isolated agent's container
+   * does NOT mount it — the file is host-global, so bind-mounting it would hand
+   * one agent every other agent's per-agent overrides (the ADR-0014 cross-agent
+   * boundary). The consequence was silent and total: every flag read through
+   * `packages/mcp`'s flags-cache reader pinned to its COMPILED DEFAULT for every
+   * isolated agent, so a central flip appeared to work in the admin UI and
+   * reached none of the isolated fleet. Measured 2026-10-10 on a
+   * `platform-maintenance-mode=tools-offline` flip: the agent kept every write
+   * tool and filed a kanban task mid-window.
+   *
+   * `~/.augmented/<agentId>/` IS mounted (and is created by us before `docker
+   * run`, ENG-8854), so a copy there is visible inside the container.
+   *
+   * WHY NOT MATERIALISE THE VALUE INTO THE SPAWN ENV, like `notify-dispatch` and
+   * `wedge-transient-notice` do. Env is the HIGHEST precedence layer (ADR-0022)
+   * and is fixed at spawn, so a materialised mode would mask a later central
+   * flip until the agent respawned — including a DISARM. That is acceptable for
+   * a notice; it is not acceptable for a control an operator arms during an
+   * incident and may need to revoke in seconds. A file keeps the per-call
+   * re-read, so arming AND disarming both land on the next tool call.
+   *
+   * Each file carries ONLY that agent's resolved values, so it is not a copy of
+   * the host-wide map and crosses no boundary.
+   */
+  mirrorAgentIds = [];
   log;
   env;
   initialised = false;
@@ -7944,6 +8001,7 @@ var HostFlagStore = class {
     this.heartbeatFlags = { ...cached.flags };
     this.notifyDispatchByAgent = { ...cached.notify_dispatch_by_agent ?? {} };
     this.lastSchemaVersion = cached.schema_version || "";
+    this.lastFlagsUpdatedAt = cached.updated_at || "";
     const ageSeconds = flagsCacheAgeSeconds(cached, this.cachePath, now);
     const age = ageSeconds === null ? "unknown" : `${Math.round(ageSeconds)}s`;
     const schema = cached.schema_version || "unknown";
@@ -7985,6 +8043,7 @@ var HostFlagStore = class {
     }
     this.heartbeatFlags = { ...map };
     this.lastSchemaVersion = schemaVersion ?? "";
+    this.lastFlagsUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
     this.persistCache();
   }
   /**
@@ -7994,17 +8053,120 @@ var HostFlagStore = class {
    * changes either map. A write failure is logged and swallowed: the in-memory
    * state stays authoritative and the next successful heartbeat re-persists.
    */
+  /**
+   * Advance the data-age stamp ONLY if the map actually moved.
+   *
+   * Both per-agent mutators are called on EVERY heartbeat — unconditionally,
+   * unlike `applyHeartbeat`, which `manager-worker.ts` calls only
+   * `if (hbResp?.feature_flags)`. The API legitimately omits `feature_flags`
+   * (when `getEvaluatedFlags` throws, and on every heartbeat while
+   * `hostIdentityProven` is false), so an unconditional stamp here restamped a
+   * STALE flag map as current on exactly those cycles — the defect the stamp was
+   * introduced to remove. Found independently by CodeRabbit and Obi Wan
+   * (`MAJOR · claim`) on #6918, against a commit of mine claiming it fixed.
+   *
+   * Clearing a map that was ALREADY empty is the common no-op case and must not
+   * count; clearing a populated one is a real change and must.
+   */
+  noteFlagDataChange(before, after) {
+    if (JSON.stringify(before) === JSON.stringify(after)) return;
+    this.lastFlagsUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
   persistCache() {
+    const updatedAt = this.lastFlagsUpdatedAt || (/* @__PURE__ */ new Date()).toISOString();
     try {
       writeFlagsCache(this.cachePath, {
         schema_version: this.lastSchemaVersion,
-        updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+        updated_at: updatedAt,
         flags: this.heartbeatFlags,
         notify_dispatch_by_agent: this.notifyDispatchByAgent
       });
     } catch (err) {
       this.log(`[flags] cache write failed: ${err.message}`);
     }
+    this.persistPerAgentCaches(updatedAt);
+  }
+  /**
+   * Mirror the resolved map into each agent's own id-keyed dir — the copy an
+   * isolated agent's container can actually see. See {@link mirrorAgentIds}.
+   *
+   * Deliberately per-agent-isolated in its failure handling: one unwritable dir
+   * (a half-provisioned agent, a stale roster entry) must not cost every OTHER
+   * agent its flags, and must not cost the host-wide write either — which is
+   * why this runs AFTER that write and swallows per-agent errors individually.
+   * The in-memory state stays authoritative and the next heartbeat retries.
+   */
+  persistPerAgentCaches(updatedAt) {
+    const root = join6(homedir5(), ".augmented");
+    for (const agentId of this.mirrorAgentIds) {
+      try {
+        const dir = join6(root, agentId);
+        if (!existsSync6(dir)) continue;
+        writeFlagsCache(join6(dir, "flags-cache.json"), {
+          schema_version: this.lastSchemaVersion,
+          updated_at: updatedAt,
+          flags: this.flagsForAgent(agentId),
+          // EMPTY, not `this.notifyDispatchByAgent`. That map is keyed by
+          // agent_id across every agent on the host, so copying it here would
+          // put other agents' values inside this agent's container — the exact
+          // boundary that stops the host-wide cache being mounted. This agent's
+          // own notify-dispatch value is already folded into `flags` below.
+          notify_dispatch_by_agent: {}
+        });
+      } catch (err) {
+        let removed = "left in place";
+        try {
+          rmSync3(join6(root, agentId, "flags-cache.json"), { force: true, recursive: true });
+          removed = "stale mirror removed";
+        } catch (rmErr) {
+          removed = `stale mirror could NOT be removed: ${rmErr.message}`;
+        }
+        this.log(
+          `[flags] per-agent cache write failed for ${agentId}: ${err.message} (${removed})`
+        );
+      }
+    }
+  }
+  /**
+   * The flag map as THIS agent resolves it: the host-wide heartbeat map with the
+   * agent's own per-agent overrides folded in.
+   *
+   * Env overrides are deliberately NOT applied. They are a property of the
+   * process that reads the flag, and the reader applies its own env layer for
+   * the flags that declare one — baking this manager's env into the file would
+   * make an operator's host-level pin follow the value into the container, where
+   * it was never set.
+   */
+  flagsForAgent(agentId) {
+    const flags = { ...this.heartbeatFlags };
+    const booleans = this.booleanFlagsByAgent[agentId];
+    if (booleans) for (const [key, value] of Object.entries(booleans)) flags[key] = value;
+    const notify = this.notifyDispatchByAgent[agentId];
+    if (notify !== void 0) flags["notify-dispatch"] = notify;
+    return flags;
+  }
+  /**
+   * Declare which agents this host runs, so their mirrors are written and kept
+   * current. Called from the manager's poll cycle with the roster the control
+   * plane returned.
+   *
+   * Re-persists whenever the roster CHANGES, so a newly assigned agent does not
+   * wait for the next flag CHANGE — and an unchanged roster writes nothing, which
+   * is why this is cheap to call every cycle.
+   *
+   * It does NOT mean the new agent has a mirror immediately. If it is isolated,
+   * its id-keyed directory does not exist until spawn, later in this same cycle,
+   * and `persistPerAgentCaches` skips an agent whose directory is absent — see
+   * the gap recorded there. A removed agent's file is left where it is; it is inert once the
+   * agent is gone, and deleting another agent's state from here would be a
+   * worse failure than a stale file nothing reads.
+   */
+  setMirrorAgentIds(agentIds) {
+    const next = [...new Set(agentIds.filter((id) => typeof id === "string" && id.length > 0))].sort();
+    const same = next.length === this.mirrorAgentIds.length && next.every((id, i) => id === this.mirrorAgentIds[i]);
+    if (same) return;
+    this.mirrorAgentIds = next;
+    this.persistCache();
   }
   /** Resolve one flag, or `undefined` if the key isn't registered. */
   resolve(key) {
@@ -8070,7 +8232,9 @@ var HostFlagStore = class {
   applyNotifyDispatchByAgent(map) {
     const definition = getFlagDefinition("notify-dispatch");
     if (!map || typeof map !== "object" || !definition) {
+      const before = this.notifyDispatchByAgent;
       this.notifyDispatchByAgent = {};
+      this.noteFlagDataChange(before, this.notifyDispatchByAgent);
       this.persistCache();
       return;
     }
@@ -8079,7 +8243,9 @@ var HostFlagStore = class {
       const value = normalizeFlagValue(definition, raw);
       if (value !== void 0) next[agentId] = value;
     }
+    const beforeNotify = this.notifyDispatchByAgent;
     this.notifyDispatchByAgent = next;
+    this.noteFlagDataChange(beforeNotify, next);
     this.persistCache();
   }
   /**
@@ -8095,7 +8261,10 @@ var HostFlagStore = class {
    */
   applyBooleanFlagsByAgent(map) {
     if (!map || typeof map !== "object") {
+      const before = this.booleanFlagsByAgent;
       this.booleanFlagsByAgent = {};
+      this.noteFlagDataChange(before, this.booleanFlagsByAgent);
+      this.persistCache();
       return;
     }
     const next = {};
@@ -8108,7 +8277,10 @@ var HostFlagStore = class {
         (next[agentId] ??= {})[key] = raw;
       }
     }
+    const beforeBooleans = this.booleanFlagsByAgent;
     this.booleanFlagsByAgent = next;
+    this.noteFlagDataChange(beforeBooleans, next);
+    this.persistCache();
   }
   /**
    * ENG-7682 follow-up: resolve an enum flag FOR A SPECIFIC AGENT. Precedence:
@@ -9842,7 +10014,7 @@ function verdictForUnavailableMcpConfig(cause, ctx) {
 // src/lib/connectivity-probe-context.ts
 import { delimiter as pathDelimiter, join as join7 } from "path";
 import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
-import { homedir as homedir5 } from "os";
+import { homedir as homedir6 } from "os";
 
 // src/lib/mcp-stdio-probe.ts
 import { spawn } from "child_process";
@@ -10664,7 +10836,7 @@ function deriveMcpServerKey(input) {
 }
 var SYSTEM_PATH_FLOOR = PROBE_SYSTEM_PATH_FLOOR;
 function toolkitPathDirs() {
-  const home = process.env.HOME?.trim() || homedir5();
+  const home = process.env.HOME?.trim() || homedir6();
   return [
     ...PROBE_TOOLKIT_PATH_DIRS,
     ...PROBE_HOME_RELATIVE_PATH_SEGMENTS.map((seg) => join7(home, seg))
@@ -11282,7 +11454,7 @@ function describeWorkerModuleFailure(err) {
 
 // src/lib/drain-transcript-flush.ts
 import { existsSync as existsSync8, readdirSync as readdirSync2 } from "fs";
-import { homedir as homedir6 } from "os";
+import { homedir as homedir7 } from "os";
 import { dirname as dirname6, join as join9, relative as relative2, sep } from "path";
 import { spawn as spawn2 } from "child_process";
 
@@ -11327,7 +11499,7 @@ function readHostArchiveAddress(path) {
 
 // src/lib/drain-transcript-flush.ts
 function sessionsBaseDir() {
-  return join9(homedir6(), ".claude", "projects");
+  return join9(homedir7(), ".claude", "projects");
 }
 var PER_FILE_UPLOAD_TIMEOUT_MS = 3e4;
 var UPLOAD_CONCURRENCY = 4;
@@ -11507,7 +11679,7 @@ function drainTranscriptFlushDeps(log2) {
     // tree — the thing host-archive-address.ts's header warns about.
     readSourceLayout: (codeName) => {
       const agentDir = dirname6(getProjectDir(codeName));
-      const codeNameDir = join9(homedir6(), ".augmented", codeName);
+      const codeNameDir = join9(homedir7(), ".augmented", codeName);
       return { layout: agentDir === codeNameDir ? "codename-keyed" : "id-keyed", agentDir };
     },
     readSessionPin: (codeName) => readDailySessionPin(codeName),
@@ -11596,7 +11768,7 @@ function decidePin(opts) {
 import chalk3 from "chalk";
 import { existsSync as existsSync10, realpathSync as realpathSync2 } from "fs";
 import { join as join11 } from "path";
-import { homedir as homedir7, userInfo } from "os";
+import { homedir as homedir8, userInfo } from "os";
 import { spawn as spawn4 } from "child_process";
 
 // src/lib/watchdog.ts
@@ -11830,7 +12002,7 @@ function normalizePinInEnv(env) {
 function managerStartCommand(opts) {
   const json = isJsonMode();
   if (!process.env.HOME || !process.env.HOME.trim()) {
-    const fallback = homedir7();
+    const fallback = homedir8();
     process.env.HOME = fallback;
     if (!json) {
       info(`HOME was not set in the manager env \u2014 defaulting to ${fallback}.`);
@@ -11864,7 +12036,7 @@ function managerStartCommand(opts) {
     process.exitCode = 1;
     return;
   }
-  const configDir = opts.configDir ?? join11(homedir7(), ".augmented");
+  const configDir = opts.configDir ?? join11(homedir8(), ".augmented");
   if (opts.supervise) {
     if (json) {
       jsonOutput({ ok: false, error: "--supervise is not supported with --json" });
@@ -11960,7 +12132,7 @@ function runSupervisorLoop(intervalSec, configDir) {
 }
 async function managerStopCommand(opts = {}) {
   const json = isJsonMode();
-  const configDir = opts.configDir ?? join11(homedir7(), ".augmented");
+  const configDir = opts.configDir ?? join11(homedir8(), ".augmented");
   try {
     const result = await stopWatchdog(configDir);
     if (!result.stopped && !result.pid) {
@@ -11988,7 +12160,7 @@ async function managerStopCommand(opts = {}) {
 }
 function managerStatusCommand(opts = {}) {
   const json = isJsonMode();
-  const configDir = opts.configDir ?? join11(homedir7(), ".augmented");
+  const configDir = opts.configDir ?? join11(homedir8(), ".augmented");
   const status = getManagerStatus(configDir);
   if (!status) {
     if (json) {
@@ -12098,7 +12270,7 @@ async function managerInstallCommand(opts = {}) {
     process.exitCode = 1;
     return;
   }
-  const configDir = opts.configDir ?? join11(homedir7(), ".augmented");
+  const configDir = opts.configDir ?? join11(homedir8(), ".augmented");
   const rawAgtBin = process.argv[1];
   if (!rawAgtBin) {
     const msg = "Could not resolve the agt binary path from argv. Re-run via the installed `agt` command.";
@@ -12109,7 +12281,7 @@ async function managerInstallCommand(opts = {}) {
   }
   const agtBin = resolveStableAgtBin(rawAgtBin);
   if (process.platform === "darwin") {
-    const home = homedir7();
+    const home = homedir8();
     const protectedRoots = ["Documents", "Downloads", "Desktop", "Movies", "Music", "Pictures"];
     const offending = protectedRoots.map((r) => join11(home, r)).find((p) => agtBin === p || agtBin.startsWith(`${p}/`));
     if (offending) {
@@ -12124,7 +12296,7 @@ async function managerInstallCommand(opts = {}) {
     AGT_HOST: getHost(),
     // ?? alone wouldn't catch `HOME=""` from a stripped systemd env.
     // Treat empty / whitespace-only as missing.
-    HOME: process.env.HOME?.trim() || homedir7(),
+    HOME: process.env.HOME?.trim() || homedir8(),
     USER: process.env.USER?.trim() || userInfo().username
   };
   const apiKey = getApiKey();
@@ -12492,4 +12664,4 @@ export {
   managerInstallSystemUnitCommand,
   managerUninstallSystemUnitCommand
 };
-//# sourceMappingURL=chunk-TJUDOE53.js.map
+//# sourceMappingURL=chunk-J3L66T65.js.map