@integrity-labs/agt-cli 0.28.315 → 0.28.317

package/dist/{chunk-PNE62JL3.js → chunk-OYOZL3N4.js}

@@ -18,7 +18,7 @@ import {
   resolveConnectivityProbe,
   worseConnectivityOutcome,
   wrapScheduledTaskPrompt
-} from "./chunk-H6GG7WM3.js";
+} from "./chunk-ORTMG5E3.js";
 import {
   parsePsRows
 } from "./chunk-XWVM4KPK.js";
@@ -5900,7 +5900,7 @@ function requireHost() {
 }
 
 // src/lib/api-client.ts
-var agtCliVersion = true ? "0.28.315" : "dev";
+var agtCliVersion = true ? "0.28.317" : "dev";
 var lastConfigHash = null;
 function setConfigHash(hash) {
   lastConfigHash = hash && hash.length > 0 ? hash : null;
@@ -6135,10 +6135,12 @@ function readFlagsCache(path) {
     const obj = parsed;
     const flags = obj["flags"];
     if (!flags || typeof flags !== "object") return null;
+    const perAgent = obj["notify_dispatch_by_agent"];
     return {
       schema_version: typeof obj["schema_version"] === "string" ? obj["schema_version"] : "",
       updated_at: typeof obj["updated_at"] === "string" ? obj["updated_at"] : "",
-      flags: { ...flags }
+      flags: { ...flags },
+      notify_dispatch_by_agent: perAgent && typeof perAgent === "object" ? { ...perAgent } : {}
     };
   } catch {
     return null;
@@ -6183,6 +6185,22 @@ function resolveAllFlags(heartbeatFlags, env = process.env) {
 }
 var HostFlagStore = class {
   heartbeatFlags = {};
+  /**
+   * ENG-7682 follow-up: per-agent notify-dispatch values from the heartbeat,
+   * keyed by agent_id. Only agents whose resolved value DIFFERS from the
+   * host-wide value appear here; everyone else falls back to the host-wide
+   * `notify-dispatch` entry. This is what stops one agent's opt-in from fanning
+   * out to every agent the host runs. Held in memory only (re-sent every
+   * heartbeat), not persisted to the flags cache, which is a host-wide map.
+   */
+  notifyDispatchByAgent = {};
+  /**
+   * The `flags_schema_version` from the most recent heartbeat, retained so a
+   * per-agent-map write (which carries no schema version of its own) persists
+   * the same schema string the host-wide map was last written with rather than
+   * clobbering it to empty. Hydrated from the cache on init().
+   */
+  lastSchemaVersion = "";
   cachePath;
   log;
   env;
@@ -6216,6 +6234,8 @@ var HostFlagStore = class {
       return;
     }
     this.heartbeatFlags = { ...cached.flags };
+    this.notifyDispatchByAgent = { ...cached.notify_dispatch_by_agent ?? {} };
+    this.lastSchemaVersion = cached.schema_version || "";
     const ageSeconds = flagsCacheAgeSeconds(cached, this.cachePath, now);
     const age = ageSeconds === null ? "unknown" : `${Math.round(ageSeconds)}s`;
     const schema = cached.schema_version || "unknown";
@@ -6256,11 +6276,23 @@ var HostFlagStore = class {
       }
     }
     this.heartbeatFlags = { ...map };
+    this.lastSchemaVersion = schemaVersion ?? "";
+    this.persistCache();
+  }
+  /**
+   * Persist the host-wide flag map AND the per-agent notify-dispatch map to the
+   * last-known-good cache in a single atomic write, so a restart hydrates both
+   * from the same snapshot (ENG-7682 follow-up). Called by every mutator that
+   * changes either map. A write failure is logged and swallowed: the in-memory
+   * state stays authoritative and the next successful heartbeat re-persists.
+   */
+  persistCache() {
     try {
       writeFlagsCache(this.cachePath, {
-        schema_version: schemaVersion ?? "",
+        schema_version: this.lastSchemaVersion,
         updated_at: (/* @__PURE__ */ new Date()).toISOString(),
-        flags: this.heartbeatFlags
+        flags: this.heartbeatFlags,
+        notify_dispatch_by_agent: this.notifyDispatchByAgent
       });
     } catch (err) {
       this.log(`[flags] cache write failed: ${err.message}`);
@@ -6296,6 +6328,53 @@ var HostFlagStore = class {
     if (resolved && typeof resolved.value === "string") return resolved.value;
     return definition?.flagType === "enum" ? definition.defaultValue : "";
   }
+  /**
+   * ENG-7682 follow-up: merge the heartbeat's per-agent notify-dispatch map.
+   * A missing/non-object map REPLACES with an empty map so a clear (agent
+   * override removed → API stops sending the entry) takes effect within one
+   * poll rather than pinning a stale opt-in. Values that aren't valid
+   * notify-dispatch members are dropped (registry skew / malformed payload).
+   */
+  applyNotifyDispatchByAgent(map) {
+    const definition = getFlagDefinition("notify-dispatch");
+    if (!map || typeof map !== "object" || !definition) {
+      this.notifyDispatchByAgent = {};
+      this.persistCache();
+      return;
+    }
+    const next = {};
+    for (const [agentId, raw] of Object.entries(map)) {
+      const value = normalizeFlagValue(definition, raw);
+      if (value !== void 0) next[agentId] = value;
+    }
+    this.notifyDispatchByAgent = next;
+    this.persistCache();
+  }
+  /**
+   * ENG-7682 follow-up: resolve an enum flag FOR A SPECIFIC AGENT. Precedence:
+   *
+   *   env override  ->  per-agent heartbeat value  ->  host-wide value (getString)
+   *
+   * The env override still wins (AGT_NOTIFY_DISPATCH stays the per-process
+   * operator escape hatch); otherwise a per-agent heartbeat value beats the
+   * host-wide one, and an agent with no per-agent entry inherits the host-wide
+   * value unchanged. Only notify-dispatch is threaded per-agent today; other
+   * enum flags stay host-wide, so a non-notify key just delegates to getString.
+   */
+  getStringForAgent(key, agentId) {
+    const definition = getFlagDefinition(key);
+    if (!definition || definition.flagType !== "enum") return this.getString(key);
+    const envValue = definition.envVar ? coerceEnvValue(definition, this.env[definition.envVar]) : void 0;
+    if (envValue !== void 0 && typeof envValue === "string") return envValue;
+    if (agentId && key === "notify-dispatch") {
+      const perAgent = this.notifyDispatchByAgent[agentId];
+      if (typeof perAgent === "string") {
+        const normalized = normalizeFlagValue(definition, perAgent);
+        if (typeof normalized === "string") return normalized;
+      }
+    }
+    return this.getString(key);
+  }
 };
 
 // src/lib/stale-mcp-reaper.ts
@@ -8199,4 +8278,4 @@ export {
   managerInstallSystemUnitCommand,
   managerUninstallSystemUnitCommand
 };
-//# sourceMappingURL=chunk-PNE62JL3.js.map
+//# sourceMappingURL=chunk-OYOZL3N4.js.map