@atbash/sdk 0.10.9-dev.0 → 0.10.10-dev.0

package/dist/browser.d.mts

@@ -430,6 +430,16 @@ declare class Atbash {
      * calls don't re-hit the dashboard. Cleared by `clearChainCache()`.
      */
     private readonly _chainCache;
+    /**
+     * Short-TTL cache for `/api/ai/exists`. The `registered` field is
+     * monotonic (once true, stays true), so most calls in a burst re-fetch
+     * data that hasn't changed. The `org_encryption_pubkey` field CAN change
+     * — an org toggling encryption mid-session — so the TTL is deliberately
+     * short (see `AGENT_EXISTS_TTL_MS`). Keyed by (pubkey, network) so
+     * cross-agent / cross-network calls don't collide.
+     */
+    private _agentExistsCache;
+    private static readonly AGENT_EXISTS_TTL_MS;
     /**
      * Cached bearer token for risk-engine / insurance read calls. Built
      * lazily as a signed `log_tool_call` tx and refreshed every 4 min so
@@ -547,6 +557,8 @@ declare class Atbash {
     private resolveChainFromMap;
     /** Drop any cached chain resolutions. Useful in tests. */
     clearChainCache(): void;
+    /** Drop the short-TTL `/api/ai/exists` cache. Useful in tests. */
+    clearAgentExistsCache(): void;
     /**
      * Wrap an SDK method body in telemetry — records the call at start
      * and a success/error duration at end. Re-throws on failure so the
@@ -893,19 +905,6 @@ interface ClassifyMemoryWriteOptions {
  */
 declare function classifyMemoryWrite(event: unknown, ctx: unknown, opts?: ClassifyMemoryWriteOptions): MemoryEntry | null;
 
-/**
- * Plugin-agnostic memory-write guard.
- *
- * A single call that replaces the plugin's usual memory-write branch:
- *   classify → scan (Layer 1 regex + Layer 2 LLM) → gate on verdict →
- *   persist to chain (fire-and-forget when allowed) → return decision.
- *
- * Plugins call this from their `before_tool_call` hook. When it returns
- * `{ handled: false }` the call wasn't a memory write and the plugin
- * should fall through to its regular tool-call audit. When
- * `{ handled: true }` the plugin returns `decision` directly.
- */
-
 /**
  * Minimal logger accepted by `guardMemoryWrite`. Plugins pass their
  * host runtime's logger (openclaw's `api.logger`, MCP's console, etc.).
@@ -936,6 +935,8 @@ interface GuardMemoryWriteInput extends ClassifyMemoryWriteOptions {
     debug?: boolean;
     /** Optional logger for debug probe + persist-failure warnings. */
     logger?: GuardLogger;
+    /** Absolute path of the agent's managed memory file. Required for chain commits — omitted skips them. */
+    memoryFilePath?: string;
 }
 /** Plugin-facing decision. Shape mirrors what plugins return from `before_tool_call`. */
 interface GuardMemoryDecision {
@@ -1000,12 +1001,19 @@ interface SyncMemoryOptions {
  * `drifted: false` — pointer is still valid; caller can keep serving the local copy.
  * `drifted: true`  — active id changed on chain; `current` is the fresh decrypted row
  *                    (or `null` if active memory was removed entirely).
+ *
+ * `checked` — whether this call actually queried chain. `false` means the TTL
+ * window was still open and the pointer was trusted without contacting chain, so
+ * `drifted: false` carries no evidence about the current state. Callers that
+ * vouch for content to a third party must not treat an unchecked result as proof.
  */
 type SyncMemoryResult = {
     drifted: false;
+    checked: boolean;
     pointer: MemoryPointer;
 } | {
     drifted: true;
+    checked: true;
     current: AgentMemoryEntry | null;
     pointer: MemoryPointer;
 };
@@ -1067,12 +1075,42 @@ interface ClassifyMemoryReadOptions {
  */
 declare function classifyMemoryRead(event: unknown, ctx: unknown, opts?: ClassifyMemoryReadOptions): boolean;
 
-/** Decision the manager returns to the plugin's `before_tool_call` handler. */
+/**
+ * Decision the manager returns to the plugin's `before_tool_call` handler.
+ *
+ * `allow: true` alone is NOT evidence that anything was checked. Read `audited`
+ * to tell the two apart, and route un-audited calls to your own judge — see the
+ * field docs below.
+ */
 interface HookDecision {
     allow?: boolean;
     block?: boolean;
     blockReason?: string;
     reason?: string;
+    /**
+     * Whether the guard reached an enforcement decision about *this* call.
+     *
+     * Note this describes whether the guard **decided**, not whether it allowed.
+     * Every `block` is `audited: true` — a blocked call is the most thoroughly
+     * checked outcome the guard produces (a red scan, a ciphertext integrity
+     * failure, a rolled-back version), and a host must never re-judge its way past
+     * one.
+     *
+     * Absent or false means the guard reached no decision — it was inside its cache
+     * window, chain was unreachable, the scan never ran, the file it can vouch for
+     * is not the file being read, or it is in observe mode. Those calls are
+     * unaudited: fall through to your own judge exactly as for a `null` return.
+     *
+     * So the host rule is:
+     *   `if (d.block) deny;  else if (d.audited) allow;  else judge it yourself;`
+     *
+     * Treating a bare `allow: true` as a completed audit is what this field exists
+     * to prevent. A host that ignores it and returns the decision verbatim will
+     * execute unaudited tool calls.
+     */
+    audited?: boolean;
+    /** Scan verdict when one was produced (`green` | `yellow` | `red`). Absent when no scan ran. */
+    verdict?: string;
 }
 interface MemoryGuardManagerOptions {
     auth: AgentAuth;
@@ -1095,6 +1133,13 @@ interface MemoryGuardManagerOptions {
     rollbackMinScore?: number;
     /** True → return `{block:true}` on defense triggers. False → log and return `null` (audit-only). Default true. */
     enforce?: boolean;
+    /**
+     * Chain targeting for the pointer sync (network, blockchainRid, nodeUrls).
+     * Defaults to the SDK's configured chain. Without this the manager could only
+     * ever talk to the default chain, which left the whole memory-read path
+     * untestable — `syncLocalMemory` already accepted these options.
+     */
+    chainOpts?: ChainOpts;
     /** Host-specific tuning of what counts as a memory read. */
     memoryReadClassifier?: ClassifyMemoryReadOptions;
     /** Passed through to `guardMemoryWrite`. Host memory-write tool names override. */
@@ -1131,12 +1176,33 @@ declare class MemoryGuardManager {
      */
     runBootProbe(): Promise<void>;
     /**
-     * Returns a `HookDecision` when the event is a memory read or write
-     * (host returns it verbatim to its runtime). Returns `null` when the
-     * event isn't memory-related — host falls through to its own audit.
+     * Returns a `HookDecision` when the guard reached a decision about this event.
+     * Returns `null` when it did not — either the event isn't memory-related, or it
+     * is but the guard could not check it. In both cases the host falls through to
+     * its own audit.
+     *
+     * A returned decision carries `audited` (see `HookDecision`). Only
+     * `{ allow: true, audited: true }` means "checked and cleared"; anything else
+     * that allows is a call the host still needs to judge.
      */
     handleBeforeToolCall(event: unknown, ctx: unknown): Promise<HookDecision | null>;
     private mapGuardResult;
+    /**
+     * Whether the pointer state this manager tracks actually describes the file
+     * this call is about to read.
+     *
+     * The classifier fires on nine patterns — including the bare tokens
+     * `"memory/"`, `"CLAUDE.md"` and `"AGENTS.md"` — but the sync path only ever
+     * reads, refreshes, or vouches for `this.memoryFilePath`. Without this check a
+     * read of `/repo/CLAUDE.md` (or any path merely containing `memory/`) would
+     * receive an `audited: true` for a file the guard never opened.
+     *
+     * Conservative on purpose: every path-shaped value found must resolve to the
+     * managed file. If none is found, or any one differs, the answer is no. That
+     * also covers events carrying two different path keys, where the classifier
+     * and the host could otherwise disagree about which one is authoritative.
+     */
+    private vouchesForTarget;
     private handleMemoryRead;
     private writeMemoryAtomic;
 }

package/dist/browser.mjs

@@ -10054,8 +10054,8 @@ Reporter$3.prototype.wrapResult = function wrapResult(result) {
     errors: state2.errors
   };
 };
-function ReporterError$1(path3, msg) {
-  this.path = path3;
+function ReporterError$1(path4, msg) {
+  this.path = path4;
   this.rethrow(msg);
 }
 inherits$v(ReporterError$1, Error);
@@ -30276,8 +30276,8 @@ Reporter.prototype.wrapResult = function wrapResult2(result) {
     errors: state2.errors
   };
 };
-function ReporterError(path3, msg) {
-  this.path = path3;
+function ReporterError(path4, msg) {
+  this.path = path4;
   this.rethrow(msg);
 }
 inherits(ReporterError, Error);
@@ -33307,8 +33307,8 @@ var parseUtil = {};
   const errors_js_12 = errors$3;
   const en_js_12 = __importDefault2(en);
   const makeIssue = (params) => {
-    const { data, path: path3, errorMaps, issueData } = params;
-    const fullPath = [...path3, ...issueData.path || []];
+    const { data, path: path4, errorMaps, issueData } = params;
+    const fullPath = [...path4, ...issueData.path || []];
     const fullIssue = {
       ...issueData,
       path: fullPath
@@ -33445,11 +33445,11 @@ var errorUtil_js_1 = errorUtil$1;
 var parseUtil_js_1 = parseUtil;
 var util_js_1 = util;
 var ParseInputLazyPath = class {
-  constructor(parent, value, path3, key3) {
+  constructor(parent, value, path4, key3) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path3;
+    this._path = path4;
     this._key = key3;
   }
   get path() {
@@ -40355,21 +40355,21 @@ function createTimeoutController(timeout) {
   const timeoutId = setTimeout(() => controller.abort(timeoutError), timeout);
   return { controller, timeoutId };
 }
-function handleRequest(method, path3, endpoint, timeout, postObject) {
+function handleRequest(method, path4, endpoint, timeout, postObject) {
   return __awaiter$2(this, void 0, void 0, function* () {
     if (method == enums_1$2.Method.GET) {
-      return yield get(path3, endpoint, timeout);
+      return yield get(path4, endpoint, timeout);
     } else {
-      return yield post(path3, endpoint, timeout, postObject);
+      return yield post(path4, endpoint, timeout, postObject);
     }
   });
 }
-function get(path3, endpoint, timeout) {
+function get(path4, endpoint, timeout) {
   return __awaiter$2(this, void 0, void 0, function* () {
-    logger.debug(`GET URL ${new URL(path3, endpoint).href}`);
+    logger.debug(`GET URL ${new URL(path4, endpoint).href}`);
     try {
       const { controller, timeoutId } = createTimeoutController(timeout);
-      const response = yield fetch(new URL(path3, endpoint).href, {
+      const response = yield fetch(new URL(path4, endpoint).href, {
         signal: controller === null || controller === void 0 ? void 0 : controller.signal
       });
       if (timeoutId)
@@ -40407,9 +40407,9 @@ function constructBufferResponseBody(response) {
     return responseText ? responseText : response.statusText;
   });
 }
-function post(path3, endpoint, timeout, requestBody) {
+function post(path4, endpoint, timeout, requestBody) {
   return __awaiter$2(this, void 0, void 0, function* () {
-    logger.debug(`POST URL ${new URL(path3, endpoint).href}`);
+    logger.debug(`POST URL ${new URL(path4, endpoint).href}`);
     logger.debug(`POST body ${JSON.stringify(requestBody)}`);
     if (buffer_1.Buffer.isBuffer(requestBody)) {
       try {
@@ -40423,7 +40423,7 @@ function post(path3, endpoint, timeout, requestBody) {
           },
           signal: controller === null || controller === void 0 ? void 0 : controller.signal
         };
-        const response = yield fetch(new URL(path3, endpoint).href, requestOptions);
+        const response = yield fetch(new URL(path4, endpoint).href, requestOptions);
         if (timeoutId)
           clearTimeout(timeoutId);
         const transactionTimestamp = response.headers.get("X-Transaction-Timestamp");
@@ -40434,7 +40434,7 @@ function post(path3, endpoint, timeout, requestBody) {
     } else {
       try {
         const { controller, timeoutId } = createTimeoutController(timeout);
-        const response = yield fetch(new URL(path3, endpoint).href, {
+        const response = yield fetch(new URL(path4, endpoint).href, {
           method: "post",
           body: JSON.stringify(requestBody),
           headers: {
@@ -40614,10 +40614,10 @@ function requireFailoverStrategies() {
       }
     }
     function abortOnError(_a2) {
-      return __awaiter2(this, arguments, void 0, function* ({ method, path: path3, config: config2, postObject, timeoutOverride }) {
+      return __awaiter2(this, arguments, void 0, function* ({ method, path: path4, config: config2, postObject, timeoutOverride }) {
         return yield retryRequest({
           method,
-          path: path3,
+          path: path4,
           config: config2,
           postObject,
           timeoutOverride,
@@ -40628,10 +40628,10 @@ function requireFailoverStrategies() {
       });
     }
     function tryNextOnError(_a2) {
-      return __awaiter2(this, arguments, void 0, function* ({ method, path: path3, config: config2, postObject, timeoutOverride }) {
+      return __awaiter2(this, arguments, void 0, function* ({ method, path: path4, config: config2, postObject, timeoutOverride }) {
         return yield retryRequest({
           method,
-          path: path3,
+          path: path4,
           config: config2,
           postObject,
           timeoutOverride,
@@ -40647,7 +40647,7 @@ function requireFailoverStrategies() {
       return endpointPoolLength - (endpointPoolLength - 1) / 3;
     }
     function queryMajority(_a2) {
-      return __awaiter2(this, arguments, void 0, function* ({ method, path: path3, config: config2, postObject, timeoutOverride }) {
+      return __awaiter2(this, arguments, void 0, function* ({ method, path: path4, config: config2, postObject, timeoutOverride }) {
         var _b;
         const bftMajorityThreshold = calculateBftMajorityThreshold(config2.endpointPool.length);
         const failureThreshold = config2.endpointPool.length - bftMajorityThreshold + 1;
@@ -40658,7 +40658,7 @@ function requireFailoverStrategies() {
         const promises = availableNodes.map((node2) => __awaiter2(this, void 0, void 0, function* () {
           try {
             const requestTimeout = timeoutOverride !== null && timeoutOverride !== void 0 ? timeoutOverride : config2.responseTimeout;
-            const response = yield (0, httpUtil_1.handleRequest)(method, path3, node2.url, requestTimeout, postObject);
+            const response = yield (0, httpUtil_1.handleRequest)(method, path4, node2.url, requestTimeout, postObject);
             const { statusCode } = response;
             if (statusCode && (0, http_utils_1.isSuccessfulStatusCode)(statusCode)) {
               outcomes.push({ type: "SUCCESS", result: response });
@@ -40705,7 +40705,7 @@ function requireFailoverStrategies() {
       });
     }
     function singleEndpoint(_a2) {
-      return __awaiter2(this, arguments, void 0, function* ({ method, path: path3, config: config2, postObject, timeoutOverride }) {
+      return __awaiter2(this, arguments, void 0, function* ({ method, path: path4, config: config2, postObject, timeoutOverride }) {
         let statusCode = null;
         let rspBody = null;
         let error4 = null;
@@ -40716,7 +40716,7 @@ function requireFailoverStrategies() {
         }
         for (let attempt = 0; attempt < config2.attemptsPerEndpoint; attempt++) {
           const requestTimeout = timeoutOverride !== null && timeoutOverride !== void 0 ? timeoutOverride : config2.responseTimeout;
-          const response = yield (0, httpUtil_1.handleRequest)(method, path3, endpoint.url, requestTimeout, postObject);
+          const response = yield (0, httpUtil_1.handleRequest)(method, path4, endpoint.url, requestTimeout, postObject);
           if (response) {
             ({ error: error4, statusCode, rspBody, transactionTimestamp } = response);
           }
@@ -40731,7 +40731,7 @@ function requireFailoverStrategies() {
       });
     }
     function retryRequest(_a2) {
-      return __awaiter2(this, arguments, void 0, function* ({ method, path: path3, config: config2, postObject, useNextNodeOnError, recoveryThreshold, timeoutOverride }) {
+      return __awaiter2(this, arguments, void 0, function* ({ method, path: path4, config: config2, postObject, useNextNodeOnError, recoveryThreshold, timeoutOverride }) {
         var _b, _c, _d;
         let statusCode = null;
         let rspBody = null;
@@ -40742,7 +40742,7 @@ function requireFailoverStrategies() {
         for (const node2 of availableNodes) {
           for (let attempt = 0; attempt < config2.attemptsPerEndpoint; attempt++) {
             const requestTimeout = timeoutOverride !== null && timeoutOverride !== void 0 ? timeoutOverride : config2.responseTimeout;
-            const response = yield (0, httpUtil_1.handleRequest)(method, path3, node2.url, requestTimeout, postObject);
+            const response = yield (0, httpUtil_1.handleRequest)(method, path4, node2.url, requestTimeout, postObject);
             error4 = (_b = response === null || response === void 0 ? void 0 : response.error) !== null && _b !== void 0 ? _b : null;
             statusCode = (_c = response === null || response === void 0 ? void 0 : response.statusCode) !== null && _c !== void 0 ? _c : null;
             rspBody = (_d = response === null || response === void 0 ? void 0 : response.rspBody) !== null && _d !== void 0 ? _d : null;
@@ -40885,19 +40885,19 @@ function requireRequestWithFailoverStrategy() {
   const enums_12 = enums;
   const failoverStrategies_1 = requireFailoverStrategies();
   function requestWithFailoverStrategy$1(method_1, path_1, config_1, postObject_1) {
-    return __awaiter2(this, arguments, void 0, function* (method, path3, config2, postObject, forceSingleEndpoint = false, timeoutOverride) {
+    return __awaiter2(this, arguments, void 0, function* (method, path4, config2, postObject, forceSingleEndpoint = false, timeoutOverride) {
       switch (config2.failoverStrategy) {
         case enums_12.FailoverStrategy.AbortOnError:
-          return yield (0, failoverStrategies_1.abortOnError)({ method, path: path3, config: config2, postObject, timeoutOverride });
+          return yield (0, failoverStrategies_1.abortOnError)({ method, path: path4, config: config2, postObject, timeoutOverride });
         case enums_12.FailoverStrategy.TryNextOnError:
-          return yield (0, failoverStrategies_1.tryNextOnError)({ method, path: path3, config: config2, postObject, timeoutOverride });
+          return yield (0, failoverStrategies_1.tryNextOnError)({ method, path: path4, config: config2, postObject, timeoutOverride });
         case enums_12.FailoverStrategy.SingleEndpoint:
-          return yield (0, failoverStrategies_1.singleEndpoint)({ method, path: path3, config: config2, postObject, timeoutOverride });
+          return yield (0, failoverStrategies_1.singleEndpoint)({ method, path: path4, config: config2, postObject, timeoutOverride });
         case enums_12.FailoverStrategy.QueryMajority:
           if (forceSingleEndpoint) {
-            return yield (0, failoverStrategies_1.singleEndpoint)({ method, path: path3, config: config2, postObject, timeoutOverride });
+            return yield (0, failoverStrategies_1.singleEndpoint)({ method, path: path4, config: config2, postObject, timeoutOverride });
           }
-          return yield (0, failoverStrategies_1.queryMajority)({ method, path: path3, config: config2, postObject, timeoutOverride });
+          return yield (0, failoverStrategies_1.queryMajority)({ method, path: path4, config: config2, postObject, timeoutOverride });
         default:
           throw new Error(`Unsupported failover strategy: ${config2.failoverStrategy}`);
       }
@@ -42096,7 +42096,7 @@ var networkSettings = {};
     const restNetworkSettingsValidationContext = RestNetworkSettingsSchema.safeParse(networkSettings2);
     if ("error" in restNetworkSettingsValidationContext) {
       const { error: { issues } = {} } = restNetworkSettingsValidationContext;
-      const errorMessage2 = issues === null || issues === void 0 ? void 0 : issues.map(({ message, path: path3 }) => `${path3[0]}: ${message}`).join(", ");
+      const errorMessage2 = issues === null || issues === void 0 ? void 0 : issues.map(({ message, path: path4 }) => `${path4[0]}: ${message}`).join(", ");
       if (throwOnError) {
         throw new Error(errorMessage2);
       }
@@ -44453,8 +44453,8 @@ var HttpClient = class {
     this.baseUrl = baseUrl.replace(/\/+$/, "");
     this.timeoutMs = timeoutMs;
   }
-  buildUrl(path3, query) {
-    const url = new URL(this.baseUrl + path3);
+  buildUrl(path4, query) {
+    const url = new URL(this.baseUrl + path4);
     if (query) {
       for (const [k, v] of Object.entries(query)) {
         if (v !== void 0 && v !== null && v !== "") {
@@ -44464,14 +44464,14 @@ var HttpClient = class {
     }
     return url.toString();
   }
-  async get(path3, query, headers) {
-    return this.fetch(this.buildUrl(path3, query), {
+  async get(path4, query, headers) {
+    return this.fetch(this.buildUrl(path4, query), {
       method: "GET",
       ...headers && { headers }
     });
   }
-  async post(path3, body, headers) {
-    return this.fetch(this.buildUrl(path3), {
+  async post(path4, body, headers) {
+    return this.fetch(this.buildUrl(path4), {
       method: "POST",
       headers: { "Content-Type": "application/json", ...headers },
       body: JSON.stringify(body)
@@ -44641,6 +44641,16 @@ var Atbash = class _Atbash {
    * calls don't re-hit the dashboard. Cleared by `clearChainCache()`.
    */
   _chainCache = /* @__PURE__ */ new Map();
+  /**
+   * Short-TTL cache for `/api/ai/exists`. The `registered` field is
+   * monotonic (once true, stays true), so most calls in a burst re-fetch
+   * data that hasn't changed. The `org_encryption_pubkey` field CAN change
+   * — an org toggling encryption mid-session — so the TTL is deliberately
+   * short (see `AGENT_EXISTS_TTL_MS`). Keyed by (pubkey, network) so
+   * cross-agent / cross-network calls don't collide.
+   */
+  _agentExistsCache = null;
+  static AGENT_EXISTS_TTL_MS = 5e3;
   /**
    * Cached bearer token for risk-engine / insurance read calls. Built
    * lazily as a signed `log_tool_call` tx and refreshed every 4 min so
@@ -44740,9 +44750,18 @@ var Atbash = class _Atbash {
    */
   async checkAgentExists(pubkey, opts) {
     const pk = pubkey ?? this.auth.pubkey;
+    const network = opts?.network;
+    const now = Date.now();
+    const cached = this._agentExistsCache;
+    if (cached && cached.pubkey === pk && cached.network === network && cached.expiresAt > now) {
+      if (pk === this.auth.pubkey) {
+        this._orgKeyFromChain = cached.orgKey;
+      }
+      return cached.registered;
+    }
     return this.track("checkAgentExists", pk, async () => {
       const query = { pubkey: pk };
-      if (opts?.network) query.network = opts.network;
+      if (network) query.network = network;
       const resp = await this.http.get(
         "/api/ai/exists",
         query,
@@ -44750,11 +44769,21 @@ var Atbash = class _Atbash {
       );
       await this.raiseIfError(resp);
       const data = await this.json(resp);
+      const registered = Boolean(data?.registered);
+      const orgKey = typeof data?.org_encryption_pubkey === "string" && data.org_encryption_pubkey ? data.org_encryption_pubkey : null;
+      if (registered) {
+        this._agentExistsCache = {
+          pubkey: pk,
+          network,
+          expiresAt: Date.now() + _Atbash.AGENT_EXISTS_TTL_MS,
+          registered,
+          orgKey
+        };
+      }
       if (pk === this.auth.pubkey) {
-        const key3 = data?.org_encryption_pubkey;
-        this._orgKeyFromChain = typeof key3 === "string" && key3 ? key3 : null;
+        this._orgKeyFromChain = orgKey;
       }
-      return Boolean(data?.registered);
+      return registered;
     });
   }
   /* ── log_tool_call (sign-only) ─────────────────────────────────────────── */
@@ -44835,12 +44864,19 @@ var Atbash = class _Atbash {
     }
     let chainOpts = options.chainOpts;
     if (options.orgName) {
-      const mapNetwork = await this.getActiveNetworkForOrg(options.orgName);
-      if (mapNetwork) {
-        chainOpts = { network: mapNetwork };
-      } else if (!chainOpts?.blockchainRid) {
-        const resolved = await this.resolveChainFromMap(options.orgName, null);
-        chainOpts = { ...chainOpts, network: resolved.network };
+      const cached = this._chainCache.get(options.orgName);
+      if (cached) {
+        chainOpts = { network: cached.network };
+      } else {
+        const mapNetwork = await this.getActiveNetworkForOrg(options.orgName);
+        if (mapNetwork) {
+          const chain = mapNetwork === "private" ? PRIVATE_CHAIN : PUBLIC_CHAIN;
+          this._chainCache.set(options.orgName, chain);
+          chainOpts = { network: mapNetwork };
+        } else if (!chainOpts?.blockchainRid) {
+          const resolved = await this.resolveChainFromMap(options.orgName, null);
+          chainOpts = { ...chainOpts, network: resolved.network };
+        }
       }
     }
     const brid = this.bridFromChainOpts(chainOpts);
@@ -45289,6 +45325,10 @@ var Atbash = class _Atbash {
   clearChainCache() {
     this._chainCache.clear();
   }
+  /** Drop the short-TTL `/api/ai/exists` cache. Useful in tests. */
+  clearAgentExistsCache() {
+    this._agentExistsCache = null;
+  }
   /* ── internals ─────────────────────────────────────────────────────────── */
   /**
    * Wrap an SDK method body in telemetry — records the call at start
@@ -45789,6 +45829,7 @@ function classifyMemoryWrite(_event, _ctx, _opts = {}) {
 // src-ts/memory/guard.ts
 init_define_ATBASH_CHROMIA_NODE_URLS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
+import path3 from "path";
 function emitDebugProbe(event, ctx, memEntry, logger2) {
   if (!logger2?.info) return;
   const ev = event ?? {};
@@ -45825,7 +45866,8 @@ async function guardMemoryWrite(input) {
     toolNames,
     enforce = true,
     debug: debug2 = false,
-    logger: logger2
+    logger: logger2,
+    memoryFilePath
   } = input;
   const memEntry = classifyMemoryWrite(event, ctx, { patterns, toolNames });
   if (debug2) emitDebugProbe(event, ctx, memEntry, logger2);
@@ -45861,17 +45903,28 @@ async function guardMemoryWrite(input) {
       committed: false
     };
   }
-  commitMemoryVersion(memEntry.value, auth, {
-    score: scanResult.score,
-    orgName,
-    endpoint
-  }).catch((err) => {
-    const reason = err instanceof Error ? err.message : String(err);
-    logger2?.warn?.("[atbash] memory commit to chain failed", {
-      path: memEntry.key,
-      reason
+  const isManagedMemoryFile = memoryFilePath !== void 0 && path3.resolve(memEntry.key) === path3.resolve(memoryFilePath);
+  if (isManagedMemoryFile) {
+    commitMemoryVersion(memEntry.value, auth, {
+      score: scanResult.score,
+      orgName,
+      endpoint
+    }).catch((err) => {
+      const reason = err instanceof Error ? err.message : String(err);
+      logger2?.warn?.("[atbash] memory commit to chain failed", {
+        path: memEntry.key,
+        reason
+      });
     });
-  });
+  } else {
+    logger2?.info?.(
+      "[atbash] scanned but not committed \u2014 not the managed memory file",
+      {
+        path: memEntry.key,
+        memoryFilePath: memoryFilePath ?? "(not configured)"
+      }
+    );
+  }
   logger2?.info?.(
     scanResult.verdict === "yellow" ? "[atbash] memory HOLD" : "[atbash] memory ALLOW",
     { path: memEntry.key, score: scanResult.score, reason: scanResult.reason }
@@ -45880,7 +45933,7 @@ async function guardMemoryWrite(input) {
     handled: true,
     decision: { allow: true },
     scanResult,
-    committed: true
+    committed: isManagedMemoryFile
   };
 }
 
@@ -45901,21 +45954,21 @@ async function syncLocalMemory(auth, pointer, opts = {}) {
   const now = Date.now();
   const withinTtl = !opts.force && now - pointer.checkedAt < ttl;
   if (withinTtl) {
-    return { drifted: false, pointer };
+    return { drifted: false, checked: false, pointer };
   }
   const currentId = await getActiveMemoryId(auth, opts.chainOpts);
   const nextPointer = { activeId: currentId, checkedAt: now };
   if (currentId === pointer.activeId) {
-    return { drifted: false, pointer: nextPointer };
+    return { drifted: false, checked: true, pointer: nextPointer };
   }
   if (currentId === null) {
-    return { drifted: true, current: null, pointer: nextPointer };
+    return { drifted: true, checked: true, current: null, pointer: nextPointer };
   }
   const row = await getMemoryById(currentId, auth, opts.chainOpts);
   if (row.decryptError) {
     throw new MemoryIntegrityError(currentId, row.decryptError);
   }
-  return { drifted: true, current: row, pointer: nextPointer };
+  return { drifted: true, checked: true, current: row, pointer: nextPointer };
 }
 
 // src-ts/browser/memory-pointer-store.ts