@atbash/sdk 0.10.13-dev.0 → 0.13.0-dev.0

package/dist/browser.mjs

@@ -37,7 +37,7 @@ var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__
 var define_ATBASH_CHROMIA_NODE_URLS_default;
 var init_define_ATBASH_CHROMIA_NODE_URLS = __esm({
   "<define:__ATBASH_CHROMIA_NODE_URLS__>"() {
-    define_ATBASH_CHROMIA_NODE_URLS_default = ["https://node0.testnet.chromia.com:7740", "https://node1.testnet.chromia.com:7740", "https://node3.testnet.chromia.com:7740"];
+    define_ATBASH_CHROMIA_NODE_URLS_default = ["https://node0.testnet.chromia.com:7740", "https://node1.testnet.chromia.com:7740"];
   }
 });
 
@@ -45,7 +45,7 @@ var init_define_ATBASH_CHROMIA_NODE_URLS = __esm({
 var define_ATBASH_PRIVATE_NODE_URLS_default;
 var init_define_ATBASH_PRIVATE_NODE_URLS = __esm({
   "<define:__ATBASH_PRIVATE_NODE_URLS__>"() {
-    define_ATBASH_PRIVATE_NODE_URLS_default = ["https://node0-pvn-testnet.dynamic.chromia.dev"];
+    define_ATBASH_PRIVATE_NODE_URLS_default = ["https://node0-pvn-testnet.dynamic.chromia.dev:7740", "https://node1-pvn-testnet.dynamic.chromia.dev:7740", "https://node2-pvn-testnet.dynamic.chromia.dev:7740"];
   }
 });
 
@@ -43478,9 +43478,10 @@ var native = {
   validateMemoryId: stub("validateMemoryId"),
   validateRollbackReason: stub("validateRollbackReason"),
   validateMemoryNonce: stub("validateMemoryNonce"),
+  validateFilePath: stub("validateFilePath"),
   buildGetActiveMemoryIdQuery: stub("buildGetActiveMemoryIdQuery"),
-  buildGetAgentMemoryQuery: stub("buildGetAgentMemoryQuery"),
-  buildGetAllAgentMemoryQuery: stub("buildGetAllAgentMemoryQuery"),
+  buildGetRecentAgentMemoryQuery: stub("buildGetRecentAgentMemoryQuery"),
+  buildGetActiveAgentMemoryQuery: stub("buildGetActiveAgentMemoryQuery"),
   buildGetAgentMemoryHistoryQuery: stub("buildGetAgentMemoryHistoryQuery"),
   buildGetAgentMemoryRollbackHistoryQuery: stub("buildGetAgentMemoryRollbackHistoryQuery"),
   buildGetAgentMemoryByIdQuery: stub("buildGetAgentMemoryByIdQuery"),
@@ -43499,13 +43500,14 @@ var native = {
   OP_ROLLBACK_AGENT_MEMORY: "rollback_agent_memory",
   OP_LOG_ENCRYPTED_TOOL_CALL: "log_encrypted_tool_call",
   QUERY_GET_ACTIVE_MEMORY_ID: "get_active_memory_id",
-  QUERY_GET_AGENT_MEMORY: "get_agent_memory",
-  QUERY_GET_ALL_AGENT_MEMORY: "get_all_agent_memory",
+  QUERY_GET_RECENT_AGENT_MEMORY: "get_recent_agent_memory",
+  QUERY_GET_ACTIVE_AGENT_MEMORY: "get_active_agent_memory",
   QUERY_GET_AGENT_MEMORY_HISTORY: "get_agent_memory_history",
   QUERY_GET_AGENT_MEMORY_BY_ID: "get_agent_memory_by_id",
   QUERY_GET_AGENT_MEMORY_ROLLBACK_HISTORY: "get_agent_memory_rollback_history",
   ARG_AGENT_PUBKEY: "agent_pubkey",
-  ARG_ID: "id"
+  ARG_ID: "id",
+  ARG_FILE_PATH: "file_path"
 };
 
 // src-ts/client.ts
@@ -43557,6 +43559,9 @@ var PRIVATE_CHAIN = {
   blockchainRid: DEFAULT_PRIVATE_BLOCKCHAIN_RID,
   nodeUrls: DEFAULT_PRIVATE_NODE_URLS
 };
+function chainForNetwork(network) {
+  return network === "private" ? PRIVATE_CHAIN : PUBLIC_CHAIN;
+}
 
 // src-ts/browser/encrypted-toolcall.ts
 init_define_ATBASH_CHROMIA_NODE_URLS();
@@ -44610,11 +44615,36 @@ function saveUserConfig(_) {
 function resolve(_key, flagValue) {
   return flagValue ?? "";
 }
+function forcedChainNetwork(flagValue) {
+  return flagValue === "public" || flagValue === "private" ? flagValue : void 0;
+}
+function warnDeprecatedEnvVarsOnce(_log) {
+}
 
 // src-ts/client.ts
 function generateToolCallId() {
   return `tc-${Date.now()}-${randomHex(4)}`;
 }
+function resolveConstructorChain(options) {
+  if (options.chain) return options.chain;
+  const hasNodeUrls = options.nodeUrls !== void 0;
+  const hasBrid = options.blockchainRid !== void 0;
+  if (hasNodeUrls !== hasBrid) {
+    throw new Error(
+      'nodeUrls and blockchainRid must be provided together \u2014 passing one without the other 404s every chain request. Prefer `chain: PUBLIC_CHAIN | PRIVATE_CHAIN` or `network: "public" | "private"`.'
+    );
+  }
+  if (hasNodeUrls && hasBrid) {
+    const brid = options.blockchainRid;
+    const derivedNetwork = options.network ?? (brid === PUBLIC_CHAIN.blockchainRid ? "public" : brid === PRIVATE_CHAIN.blockchainRid ? "private" : "private");
+    return {
+      network: derivedNetwork,
+      blockchainRid: brid,
+      nodeUrls: options.nodeUrls
+    };
+  }
+  return chainForNetwork(options.network ?? forcedChainNetwork() ?? "private");
+}
 var Atbash = class _Atbash {
   auth;
   endpoint;
@@ -44638,6 +44668,27 @@ var Atbash = class _Atbash {
    * calls don't re-hit the dashboard. Cleared by `clearChainCache()`.
    */
   _chainCache = /* @__PURE__ */ new Map();
+  /**
+   * The chain the constructor settled on. Used only where a lookup returns no
+   * answer — see {@link resolveChainFromMap}.
+   */
+  _defaultChain;
+  /**
+   * True when the caller named a chain outright — `chain`, `network`, or the
+   * paired `blockchainRid` + `nodeUrls`.
+   *
+   * Such a client is never re-pointed: not by the migration switch, and not by
+   * where an org turns out to live. Naming a chain is the caller saying "talk
+   * to this one", and silently routing elsewhere would make the argument a
+   * suggestion. A client that names nothing is the one that follows the org.
+   */
+  _explicitChain;
+  /**
+   * The fleet-wide chain switch, read once at construction. `resolve()` hits
+   * the config file on disk, so re-reading it per call would put a file read
+   * on every judge.
+   */
+  _forcedNetwork;
   /**
    * Short-TTL cache for `/api/ai/exists`. The `registered` field is
    * monotonic (once true, stays true), so most calls in a burst re-fetch
@@ -44662,11 +44713,23 @@ var Atbash = class _Atbash {
   static environmentLogged = false;
   constructor(privkey, options = {}) {
     this.auth = native.loadAgent(privkey);
-    this.endpoint = (options.endpoint ?? DEFAULT_ENDPOINT).replace(/\/+$/, "") || DEFAULT_ENDPOINT;
-    this.nodeUrls = options.nodeUrls ? [...options.nodeUrls] : DEFAULT_CHROMIA_NODE_URLS;
-    this.blockchainRid = options.blockchainRid ?? native.DEFAULT_BLOCKCHAIN_RID;
+    const validated = validateJudgeEndpoint(
+      options.verifyPubKey ? {
+        policy: "self-hosted",
+        endpoint: options.endpoint ?? DEFAULT_ENDPOINT,
+        verifyPubKey: options.verifyPubKey
+      } : { endpoint: options.endpoint }
+    );
+    this.endpoint = validated.url;
+    const resolvedChain = resolveConstructorChain(options);
+    this.nodeUrls = [...resolvedChain.nodeUrls];
+    this.blockchainRid = resolvedChain.blockchainRid;
+    this._defaultChain = resolvedChain;
+    this._explicitChain = options.chain !== void 0 || options.network !== void 0 || options.blockchainRid !== void 0 && options.nodeUrls !== void 0;
+    this._forcedNetwork = forcedChainNetwork();
+    warnDeprecatedEnvVarsOnce((msg) => options.logger?.warn?.(msg));
     this.orgName = options.orgName;
-    this.verifyPubKey = options.verifyPubKey;
+    this.verifyPubKey = validated.verifyPubKey ?? void 0;
     this.orgEncryptionPubKey = options.orgEncryptionPubKey;
     this.failClosed = options.failClosed !== false;
     this.debug = options.debug === true;
@@ -44724,15 +44787,27 @@ var Atbash = class _Atbash {
    * self-hosted endpoint's `verifyPubKey` becomes the client default.
    */
   static fromConfig(options = {}) {
+    const configuredEndpoint = resolve("judgeEndpoint") || void 0;
+    const configuredVerifyPubKey = resolve("judgeVerifyPubKey") || void 0;
+    if (!options.judge && configuredVerifyPubKey && !configuredEndpoint) {
+      throw new Error(
+        "judgeVerifyPubKey / ATBASH_JUDGE_VERIFY_PUBKEY is set but no judge endpoint is configured: set judgeEndpoint / ATBASH_ENDPOINT to the self-hosted judge"
+      );
+    }
     const validated = validateJudgeEndpoint(
-      options.judge ?? { endpoint: resolve("judgeEndpoint") || void 0 }
+      options.judge ?? (configuredVerifyPubKey && configuredEndpoint ? {
+        policy: "self-hosted",
+        endpoint: configuredEndpoint,
+        verifyPubKey: configuredVerifyPubKey
+      } : { endpoint: configuredEndpoint })
     );
     const agentKey = resolve("agentKey", options.agentKey);
     const auth = agentKey ? native.loadAgent(agentKey) : loadAgentFromFile(options.keyPath);
-    const blockchainRid = resolve("blockchainRid", options.blockchainRid) || void 0;
     return new _Atbash(auth.privkey, {
       endpoint: validated.url,
-      blockchainRid,
+      chain: options.chain,
+      network: options.network,
+      blockchainRid: options.blockchainRid,
       timeoutMs: options.timeoutMs,
       nodeUrls: options.nodeUrls,
       orgName: options.orgName,
@@ -44773,7 +44848,7 @@ var Atbash = class _Atbash {
     return this.track("checkAgentExists", pk, async () => {
       const query = { pubkey: pk };
       if (network) query.network = network;
-      const brid = this.bridFromChainOpts(network ? { network } : void 0);
+      const brid = network ? this.bridFromChainOpts({ network }) : await this.defaultOrgBrid();
       const resp = await this.http.get(
         "/api/ai/exists",
         query,
@@ -44824,7 +44899,7 @@ var Atbash = class _Atbash {
       };
     }
     const toolCallId = generateToolCallId();
-    const brid = this.bridFromChainOpts(options.chainOpts);
+    const brid = options.chainOpts?.blockchainRid || options.chainOpts?.network ? this.bridFromChainOpts(options.chainOpts) : await this.defaultOrgBrid() ?? this.blockchainRid;
     const orgKey = options.orgEncryptionPubKey ?? this.orgEncryptionPubKey ?? this._orgKeyFromChain;
     try {
       const signedHex = orgKey ? signEncryptedToolCall(
@@ -44875,7 +44950,11 @@ var Atbash = class _Atbash {
       throw new Error("action is required and cannot be empty.");
     }
     let chainOpts = options.chainOpts;
-    if (options.orgName) {
+    if (options.orgName && this._explicitChain) {
+      chainOpts = options.chainOpts ?? { network: this._defaultChain.network };
+    } else if (options.orgName && this.forcedNetwork()) {
+      chainOpts = { network: this.forcedNetwork() };
+    } else if (options.orgName) {
       const cached = this._chainCache.get(options.orgName);
       if (cached) {
         chainOpts = { network: cached.network };
@@ -45109,7 +45188,7 @@ var Atbash = class _Atbash {
       const resp = await this.http.get(
         "/api/v1/judge",
         { tool_call_id: judgmentId, agent_pubkey: pk },
-        this.authHeaders()
+        this.authHeaders(await this.defaultOrgBrid())
       );
       await this.raiseIfError(resp);
       const data = await this.json(resp) ?? {};
@@ -45129,7 +45208,11 @@ var Atbash = class _Atbash {
     return this.track(
       "getToolCalls",
       void 0,
-      () => this.riskEngineRecords("tool-calls", { limit: maxCount })
+      async () => this.riskEngineRecords(
+        "tool-calls",
+        { limit: maxCount },
+        await this.defaultOrgBrid()
+      )
     );
   }
   async getOrgToolCalls(orgName, maxCount) {
@@ -45146,24 +45229,31 @@ var Atbash = class _Atbash {
     return this.track(
       "getAgentToolCalls",
       agentPubkey,
-      () => this.riskEngineRecords("agent-tool-calls", {
-        agent: agentPubkey,
-        limit: maxCount
-      })
+      async () => this.riskEngineRecords(
+        "agent-tool-calls",
+        { agent: agentPubkey, limit: maxCount },
+        await this.defaultOrgBrid()
+      )
     );
   }
   async getToolCallCount() {
     return this.track("getToolCallCount", void 0, async () => {
-      const raw2 = await this.riskEngineGet("tool-call-count", {});
+      const raw2 = await this.riskEngineGet(
+        "tool-call-count",
+        {},
+        await this.defaultOrgBrid()
+      );
       const n = Number(raw2);
       return Number.isFinite(n) ? n : 0;
     });
   }
   async getToolCallFull(toolCallId) {
     return this.track("getToolCallFull", void 0, async () => {
-      const raw2 = await this.riskEngineGet("tool-call-full", {
-        tool_call_id: toolCallId
-      });
+      const raw2 = await this.riskEngineGet(
+        "tool-call-full",
+        { tool_call_id: toolCallId },
+        await this.defaultOrgBrid()
+      );
       if (!isRecord(raw2)) return null;
       return toToolCallFull(raw2);
     });
@@ -45249,7 +45339,7 @@ var Atbash = class _Atbash {
       const resp = await this.http.get(
         "/api/insurance",
         { action: "safety-stats" },
-        this.authHeaders()
+        this.authHeaders(await this.defaultOrgBrid())
       );
       await this.raiseIfError(resp);
       const data = await this.json(resp) ?? {};
@@ -45281,21 +45371,22 @@ var Atbash = class _Atbash {
    * entry (caller falls back to per-chain subscription resolution).
    */
   async getActiveNetworkForOrg(orgName) {
+    let resp;
     try {
-      const resp = await this.http.get(
+      resp = await this.http.get(
         "/api/org-network",
-        { org: orgName },
+        { org: orgName.trim() },
         this.authHeaders()
       );
-      if (resp.status !== 200) return null;
-      const data = await this.json(resp);
-      if (data?.network === "public" || data?.network === "private") {
-        return data.network;
-      }
-      return null;
-    } catch {
-      return null;
+    } catch (err) {
+      throw this.transportError(err);
+    }
+    if (resp.status !== 200) throw await this.httpError(resp);
+    const data = await this.json(resp);
+    if (data?.network === "public" || data?.network === "private") {
+      return data.network;
     }
+    return null;
   }
   /**
    * Resolve which chain an org's actions should run against. Cached
@@ -45304,13 +45395,19 @@ var Atbash = class _Atbash {
    *   2. Per-chain subscription fallback — public + private records
    *      are fetched in parallel, with `is_private_blockchain` and
    *      `assigned_at` reconciling mixed states.
-   * Defaults to the public chain when nothing else resolves.
+   * A lookup that names exactly one chain wins outright. Where it names
+   * neither (a brand-new org) or cannot choose between them, the client's
+   * configured default decides.
    */
   async resolveChainForOrg(orgName) {
-    const cached = this._chainCache.get(orgName);
+    const name2 = orgName.trim();
+    if (this._explicitChain) return this._defaultChain;
+    const forced = this.forcedNetwork();
+    if (forced) return chainForNetwork(forced);
+    const cached = this._chainCache.get(name2);
     if (cached) return cached;
-    const mapNetwork = await this.getActiveNetworkForOrg(orgName);
-    return this.resolveChainFromMap(orgName, mapNetwork);
+    const mapNetwork = await this.getActiveNetworkForOrg(name2);
+    return this.resolveChainFromMap(name2, mapNetwork);
   }
   /**
    * Resolve a chain given an already-fetched `org_networks` map result.
@@ -45326,32 +45423,41 @@ var Atbash = class _Atbash {
       this._chainCache.set(orgName, chain);
       return chain;
     }
-    try {
-      const [pubSub, privSub] = await Promise.all([
-        this.getOrgSubscription(orgName, "public").catch(() => null),
-        this.getOrgSubscription(orgName, "private").catch(() => null)
-      ]);
-      if (pubSub?.is_private_blockchain) {
-        this._chainCache.set(orgName, PRIVATE_CHAIN);
-        return PRIVATE_CHAIN;
-      }
-      if (pubSub && privSub) {
-        const chain = privSub.assigned_at > pubSub.assigned_at ? PRIVATE_CHAIN : PUBLIC_CHAIN;
-        this._chainCache.set(orgName, chain);
-        return chain;
-      }
-      if (pubSub) {
-        this._chainCache.set(orgName, PUBLIC_CHAIN);
-        return PUBLIC_CHAIN;
-      }
-      if (privSub?.is_private_blockchain) {
-        this._chainCache.set(orgName, PRIVATE_CHAIN);
-        return PRIVATE_CHAIN;
-      }
-    } catch {
+    const [pubRes, privRes] = await Promise.allSettled([
+      this.getOrgSubscription(orgName, "public"),
+      this.getOrgSubscription(orgName, "private")
+    ]);
+    const pubSub = pubRes.status === "fulfilled" ? pubRes.value : null;
+    const privSub = privRes.status === "fulfilled" ? privRes.value : null;
+    const failure = pubRes.status === "rejected" ? pubRes.reason : privRes.status === "rejected" ? privRes.reason : null;
+    if (pubSub?.is_private_blockchain) {
+      this._chainCache.set(orgName, PRIVATE_CHAIN);
+      return PRIVATE_CHAIN;
+    }
+    if (pubSub && privSub) {
+      const chain = privSub.assigned_at === pubSub.assigned_at ? this._defaultChain : privSub.assigned_at > pubSub.assigned_at ? PRIVATE_CHAIN : PUBLIC_CHAIN;
+      this._chainCache.set(orgName, chain);
+      return chain;
+    }
+    if (pubSub) {
+      this._chainCache.set(orgName, PUBLIC_CHAIN);
+      return PUBLIC_CHAIN;
+    }
+    if (privSub?.is_private_blockchain) {
+      this._chainCache.set(orgName, PRIVATE_CHAIN);
+      return PRIVATE_CHAIN;
+    }
+    if (failure) {
+      const detail = failure instanceof Error ? failure.message : String(failure);
+      throw new AtbashAPIError(
+        failure instanceof AtbashAPIError ? failure.status : 0,
+        `could not resolve the chain for org "${orgName}": ${detail}`,
+        "",
+        this.endpoint
+      );
     }
-    this._chainCache.set(orgName, PUBLIC_CHAIN);
-    return PUBLIC_CHAIN;
+    this._chainCache.set(orgName, this._defaultChain);
+    return this._defaultChain;
   }
   /** Drop any cached chain resolutions. Useful in tests. */
   clearChainCache() {
@@ -45402,6 +45508,7 @@ var Atbash = class _Atbash {
   async resolveAgentLookupNetwork(options) {
     if (options.chainOpts?.network) return options.chainOpts.network;
     if (options.chainOpts?.blockchainRid) return void 0;
+    if (this._explicitChain) return this._defaultChain.network;
     const orgName = options.orgName ?? this.orgName;
     if (!orgName) return void 0;
     return (await this.resolveChainForOrg(orgName)).network;
@@ -45477,6 +45584,30 @@ var Atbash = class _Atbash {
       return void 0;
     }
   }
+  /**
+   * BRID for the client's configured default org, if it has one.
+   *
+   * Calls that carry no `orgName` argument are not chain-less: they still
+   * belong to `this.orgName`, and that org lives on exactly one chain. Routing
+   * them by the constructor's chain instead means a client configured
+   * `network: "private"` reads the private chain for an org that lives on
+   * public, and gets an empty answer rather than an error. So where an org is
+   * known the org decides the chain, and the constructor's chain is what is
+   * left when no org is known at all — the order `resolveAgentLookupNetwork`
+   * already applies to agent metadata reads, and the order the dashboard
+   * applies in `resolveChainForWallet`.
+   *
+   * Undefined when there is no default org, so callers keep falling back to
+   * the client default.
+   */
+  /** The switch's chain, unless this client named one of its own. */
+  forcedNetwork() {
+    return this._explicitChain ? void 0 : this._forcedNetwork;
+  }
+  async defaultOrgBrid() {
+    if (this._explicitChain || !this.orgName) return void 0;
+    return this.bridForOrg(this.orgName);
+  }
   async raiseIfError(resp) {
     if (resp.ok) return;
     throw await this.httpError(resp);
@@ -45842,11 +45973,11 @@ async function commitMemoryVersion(_plaintext, _auth, _opts) {
 async function getActiveMemoryId(_auth, _chainOpts) {
   throw new Error(`getActiveMemoryId ${STUB_MSG3}`);
 }
-async function getActiveMemory(_auth, _chainOpts) {
-  throw new Error(`getActiveMemory ${STUB_MSG3}`);
+async function getRecentAgentMemory(_auth, _chainOpts) {
+  throw new Error(`getRecentAgentMemory ${STUB_MSG3}`);
 }
-async function getAllAgentMemory(_auth, _chainOpts) {
-  throw new Error(`getAllAgentMemory ${STUB_MSG3}`);
+async function getActiveAgentMemory(_auth, _chainOpts) {
+  throw new Error(`getActiveAgentMemory ${STUB_MSG3}`);
 }
 async function getMemoryHistory(_auth, _chainOpts) {
   throw new Error(`getMemoryHistory ${STUB_MSG3}`);
@@ -45925,8 +46056,7 @@ async function guardMemoryWrite(input) {
     toolNames,
     enforce = true,
     debug: debug2 = false,
-    logger: logger2,
-    memoryFilePath
+    logger: logger2
   } = input;
   const memEntry = classifyMemoryWrite(event, ctx, { patterns, toolNames });
   if (debug2) emitDebugProbe(event, ctx, memEntry, logger2);
@@ -45962,37 +46092,35 @@ async function guardMemoryWrite(input) {
       committed: false
     };
   }
-  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
-      });
+  const filePath = path3.basename(memEntry.key);
+  commitMemoryVersion(memEntry.value, auth, {
+    score: scanResult.score,
+    filePath,
+    orgName,
+    endpoint,
+    verifyPubKey
+  }).catch((err) => {
+    const reason = err instanceof Error ? err.message : String(err);
+    logger2?.warn?.("[atbash] memory commit to chain failed", {
+      path: memEntry.key,
+      filePath,
+      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 }
+    {
+      path: memEntry.key,
+      filePath,
+      score: scanResult.score,
+      reason: scanResult.reason
+    }
   );
   return {
     handled: true,
     decision: { allow: true },
     scanResult,
-    committed: isManagedMemoryFile
+    committed: true
   };
 }
 
@@ -46172,10 +46300,13 @@ export {
   KEY_FILENAMES,
   MemoryGuardManager,
   MemoryIntegrityError,
+  PRIVATE_CHAIN,
+  PUBLIC_CHAIN,
   PointerStore,
   SignatureVerificationError,
   bootSyncFailureLine,
   buildAllowedJudgeHosts,
+  chainForNetwork,
   chooseKeyPath,
   claimHashHex,
   classifyMemoryRead,
@@ -46199,13 +46330,13 @@ export {
   encryptedLength,
   flushTelemetry,
   generateKeypair2 as generateKeypair,
-  getActiveMemory,
+  getActiveAgentMemory,
   getActiveMemoryId,
-  getAllAgentMemory,
   getConfigDir,
   getConfigPath,
   getMemoryById,
   getMemoryHistory,
+  getRecentAgentMemory,
   getRollbackHistory,
   guardMemoryWrite,
   isEnvelope,