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

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);
       }
@@ -43452,9 +43452,6 @@ var native = {
   DEFAULT_BLOCKCHAIN_RID: ATBASH_BLOCKCHAIN_RID,
   DEFAULT_PRIVATE_BLOCKCHAIN_RID: ATBASH_PRIVATE_BLOCKCHAIN_RID,
   DEFAULT_ENDPOINT: ATBASH_ENDPOINT,
-  // Browser has no NAPI channel to Rust's HONEYCOMB_KEY — telemetry
-  // silently no-ops. `HONEYCOMB_API_KEY` env var still overrides at runtime.
-  HONEYCOMB_KEY: "",
   defaultChromiaNodeUrls: () => [...DEFAULT_CHROMIA_NODE_URLS_ARR],
   defaultPrivateNodeUrls: () => [...DEFAULT_PRIVATE_NODE_URLS_ARR],
   // Server-only surfaces — throw at runtime, keep types satisfied.
@@ -44453,8 +44450,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 +44461,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 +44638,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
@@ -44668,6 +44675,16 @@ var Atbash = class _Atbash {
         verifying: this.verifyPubKey ? "with response-signature pubkey configured" : "without signature verification"
       });
     }
+    try {
+      setupTelemetry({
+        enabled: true,
+        source: "sdk",
+        endpoint: this.endpoint,
+        getAuthHeaders: () => this.authHeaders()
+      });
+    } catch (err) {
+      this.logger.warn?.("[atbash] telemetry setup failed \u2014 continuing without metrics", { error: String(err) });
+    }
   }
   /**
    * Say which environment this build talks to, once per process.
@@ -44740,9 +44757,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 +44776,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 +44871,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);
@@ -45155,19 +45198,25 @@ var Atbash = class _Atbash {
     });
   }
   /* ── risk-engine batched (action-dispatched POST) ──────────────────────── */
-  getAgentDetail(agentPubkey) {
-    return this.track(
-      "getAgentDetail",
-      agentPubkey,
-      () => this.riskEnginePost({ action: "agent-detail-batch", agent: agentPubkey })
-    );
+  async getAgentDetail(agentPubkey, options = {}) {
+    return this.track("getAgentDetail", agentPubkey, async () => {
+      const network = await this.resolveAgentLookupNetwork(options);
+      return this.riskEnginePost(
+        { action: "agent-detail-batch", agent: agentPubkey },
+        network
+      );
+    });
   }
-  async getAgentPolicy(agentPubkey) {
+  async getAgentPolicy(agentPubkey, options = {}) {
     return this.track("getAgentPolicy", agentPubkey, async () => {
-      const raw2 = await this.riskEnginePost({
-        action: "agent-policy-batch",
-        agent: agentPubkey
-      });
+      const network = await this.resolveAgentLookupNetwork(options);
+      const raw2 = await this.riskEnginePost(
+        {
+          action: "agent-policy-batch",
+          agent: agentPubkey
+        },
+        network
+      );
       return {
         policy: String(raw2.policy ?? ""),
         isJailed: Boolean(raw2.is_jailed),
@@ -45289,6 +45338,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
@@ -45320,6 +45373,20 @@ var Atbash = class _Atbash {
     if (chainOpts?.network === "public") return PUBLIC_CHAIN.blockchainRid;
     return this.blockchainRid;
   }
+  /**
+   * Resolve the dashboard chain used by agent metadata/policy reads.
+   * Explicit per-call network overrides win; otherwise use the supplied org
+   * or the client's configured default org. A custom BRID is intentionally
+   * left untouched because it cannot be represented by the dashboard's
+   * public/private query selector.
+   */
+  async resolveAgentLookupNetwork(options) {
+    if (options.chainOpts?.network) return options.chainOpts.network;
+    if (options.chainOpts?.blockchainRid) return void 0;
+    const orgName = options.orgName ?? this.orgName;
+    if (!orgName) return void 0;
+    return (await this.resolveChainForOrg(orgName)).network;
+  }
   /**
    * Get-or-create a Bearer token for dashboard reads. The token is a
    * signed `log_tool_call` op (locally signed, never submitted) — the
@@ -45362,10 +45429,11 @@ var Atbash = class _Atbash {
     if (resp.status !== 200) throw await this.httpError(resp);
     return this.json(resp);
   }
-  async riskEnginePost(body) {
+  async riskEnginePost(body, network) {
     let resp;
     try {
-      resp = await this.http.post("/api/risk-engine", body, this.authHeaders());
+      const path4 = network ? `/api/risk-engine?network=${encodeURIComponent(network)}` : "/api/risk-engine";
+      resp = await this.http.post(path4, body, this.authHeaders());
     } catch (err) {
       throw this.transportError(err);
     }
@@ -45789,6 +45857,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 +45894,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 +45931,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 +45961,7 @@ async function guardMemoryWrite(input) {
     handled: true,
     decision: { allow: true },
     scanResult,
-    committed: true
+    committed: isManagedMemoryFile
   };
 }
 
@@ -45901,21 +45982,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