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

package/dist/index.mjs

@@ -3311,11 +3311,36 @@ var ENV_MAP = {
   agentKey: "ATBASH_AGENT_KEY",
   orgName: "ATBASH_ORG_NAME",
   judgeEndpoint: "ATBASH_ENDPOINT",
-  blockchainRid: "ATBASH_BLOCKCHAIN_RID",
+  // Same variable name the Hermes plugin already documents.
+  judgeVerifyPubKey: "ATBASH_JUDGE_VERIFY_PUBKEY",
+  defaultChainNetwork: "ATBASH_DEFAULT_CHAIN_NETWORK",
   provider: "ATBASH_PROVIDER",
   providerModel: "ATBASH_PROVIDER_MODEL",
   debug: "ATBASH_DEBUG"
 };
+var DEPRECATED_ENV_VARS = ["ATBASH_BLOCKCHAIN_RID"];
+var DEPRECATED_CONFIG_FIELDS = ["blockchainRid"];
+var deprecatedWarned = false;
+function warnDeprecatedEnvVarsOnce(log = console.warn) {
+  if (deprecatedWarned) return;
+  for (const name2 of DEPRECATED_ENV_VARS) {
+    if (process.env[name2]) {
+      deprecatedWarned = true;
+      log(
+        `[atbash] ${name2} is ignored \u2014 each org's chain is resolved from the dashboard; set ATBASH_DEFAULT_CHAIN_NETWORK=private only to pin everything to private`
+      );
+    }
+  }
+  const fileConfig = loadUserConfig();
+  for (const field of DEPRECATED_CONFIG_FIELDS) {
+    if (fileConfig[field]) {
+      deprecatedWarned = true;
+      log(
+        `[atbash] "${field}" in ${getConfigPath()} is ignored \u2014 pass \`chain\` or \`network\` at construction instead`
+      );
+    }
+  }
+}
 function getConfigDir() {
   const home2 = process.env.HOME || homedir3() || "";
   return join3(home2, ".config", "atbash");
@@ -3357,11 +3382,41 @@ function resolve(key3, flagValue) {
   if (fileVal != null) return String(fileVal);
   return "";
 }
+function forcedChainNetwork(flagValue) {
+  const raw2 = resolve("defaultChainNetwork", flagValue);
+  if (!raw2) return void 0;
+  if (raw2 !== "public" && raw2 !== "private") {
+    throw new Error(
+      `ATBASH_DEFAULT_CHAIN_NETWORK / defaultChainNetwork must be "public" or "private", got ${JSON.stringify(raw2)} \u2014 unset it to let each org's chain decide.`
+    );
+  }
+  return raw2;
+}
 
 // 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;
@@ -3385,6 +3440,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
@@ -3409,11 +3485,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;
@@ -3471,15 +3559,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,
@@ -3520,7 +3620,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,
@@ -3571,7 +3671,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(
@@ -3622,7 +3722,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 };
@@ -3856,7 +3960,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) ?? {};
@@ -3876,7 +3980,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) {
@@ -3893,24 +4001,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);
     });
@@ -3996,7 +4111,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) ?? {};
@@ -4028,21 +4143,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
@@ -4051,13 +4167,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.
@@ -4073,32 +4195,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;
     }
-    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, this._defaultChain);
+    return this._defaultChain;
   }
   /** Drop any cached chain resolutions. Useful in tests. */
   clearChainCache() {
@@ -4149,6 +4280,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;
@@ -4224,6 +4356,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);
@@ -42664,6 +42820,7 @@ async function resolveChainOptsForOrg(opts, auth) {
   if (opts?.orgName && !opts.chainOpts?.blockchainRid && auth) {
     const atbash = new Atbash(auth.privkey, {
       endpoint: opts.endpoint,
+      verifyPubKey: opts.verifyPubKey,
       orgName: opts.orgName
     });
     const resolved = await atbash.resolveChainForOrg(opts.orgName);
@@ -42703,13 +42860,15 @@ function buildSigner(auth) {
 }
 async function commitMemoryVersion(plaintext, auth, opts) {
   const score = opts?.score ?? 5;
+  const filePath = opts?.filePath ?? "";
   const key3 = await deriveMemoryKey(auth.privkey);
   const { ciphertext, nonce } = await encryptMemoryContent(plaintext, key3);
   const args = native.buildAddAgentMemoryArgs(
     auth.pubkey,
     ciphertext,
     nonce,
-    score
+    score,
+    filePath
   );
   const chainOpts = await resolveChainOptsForOrg(opts, auth);
   const client = await buildChainClient(chainOpts);
@@ -42721,7 +42880,8 @@ async function commitMemoryVersion(plaintext, auth, opts) {
         toGtxBytes(args.agent_pubkey),
         toGtxBytes(args.content_cipher),
         toGtxBytes(args.nonce),
-        args.score
+        args.score,
+        args.file_path
       ]
     },
     sigProvider
@@ -42743,6 +42903,7 @@ async function decryptRow(row, key3) {
   }
   return {
     id: parsed.id,
+    filePath: parsed.file_path,
     content,
     decryptError,
     score: parsed.score,
@@ -42751,39 +42912,52 @@ async function decryptRow(row, key3) {
     updatedAt: parsed.updated_at
   };
 }
-async function getActiveMemoryId(auth, chainOpts) {
+function paramsWithOptionalFilePath(agentPubkeyHex, filePath) {
+  const params = {
+    [native.ARG_AGENT_PUBKEY]: agentPubkeyHex
+  };
+  if (filePath !== null) {
+    params[native.ARG_FILE_PATH] = filePath;
+  }
+  return params;
+}
+async function getActiveMemoryId(auth, chainOpts, filePath) {
   const client = await buildChainClient(chainOpts);
-  const q = native.buildGetActiveMemoryIdQuery(auth.pubkey);
-  const raw2 = await client.query(native.QUERY_GET_ACTIVE_MEMORY_ID, {
-    [native.ARG_AGENT_PUBKEY]: q.agent_pubkey_hex
-  });
+  const q = native.buildGetActiveMemoryIdQuery(auth.pubkey, filePath ?? null);
+  const raw2 = await client.query(
+    native.QUERY_GET_ACTIVE_MEMORY_ID,
+    paramsWithOptionalFilePath(q.agent_pubkey_hex, q.file_path)
+  );
   return native.parseActiveMemoryId(raw2);
 }
-async function getActiveMemory(auth, chainOpts) {
+async function getRecentAgentMemory(auth, chainOpts, filePath) {
   const client = await buildChainClient(chainOpts);
   const key3 = await deriveMemoryKey(auth.privkey);
-  const q = native.buildGetAgentMemoryQuery(auth.pubkey);
-  const rows = await client.query(native.QUERY_GET_AGENT_MEMORY, {
-    [native.ARG_AGENT_PUBKEY]: q.agent_pubkey_hex
-  });
+  const q = native.buildGetRecentAgentMemoryQuery(auth.pubkey, filePath ?? null);
+  const rows = await client.query(
+    native.QUERY_GET_RECENT_AGENT_MEMORY,
+    paramsWithOptionalFilePath(q.agent_pubkey_hex, q.file_path)
+  );
   return Promise.all((rows ?? []).map((r2) => decryptRow(r2, key3)));
 }
-async function getAllAgentMemory(auth, chainOpts) {
+async function getActiveAgentMemory(auth, chainOpts, filePath) {
   const client = await buildChainClient(chainOpts);
   const key3 = await deriveMemoryKey(auth.privkey);
-  const q = native.buildGetAllAgentMemoryQuery(auth.pubkey);
-  const rows = await client.query(native.QUERY_GET_ALL_AGENT_MEMORY, {
-    [native.ARG_AGENT_PUBKEY]: q.agent_pubkey_hex
-  });
+  const q = native.buildGetActiveAgentMemoryQuery(auth.pubkey, filePath ?? null);
+  const rows = await client.query(
+    native.QUERY_GET_ACTIVE_AGENT_MEMORY,
+    paramsWithOptionalFilePath(q.agent_pubkey_hex, q.file_path)
+  );
   return Promise.all((rows ?? []).map((r2) => decryptRow(r2, key3)));
 }
-async function getMemoryHistory(auth, chainOpts) {
+async function getMemoryHistory(auth, chainOpts, filePath) {
   const client = await buildChainClient(chainOpts);
   const key3 = await deriveMemoryKey(auth.privkey);
-  const q = native.buildGetAgentMemoryHistoryQuery(auth.pubkey);
-  const rows = await client.query(native.QUERY_GET_AGENT_MEMORY_HISTORY, {
-    [native.ARG_AGENT_PUBKEY]: q.agent_pubkey_hex
-  });
+  const q = native.buildGetAgentMemoryHistoryQuery(auth.pubkey, filePath ?? null);
+  const rows = await client.query(
+    native.QUERY_GET_AGENT_MEMORY_HISTORY,
+    paramsWithOptionalFilePath(q.agent_pubkey_hex, q.file_path)
+  );
   return Promise.all((rows ?? []).map((r2) => decryptRow(r2, key3)));
 }
 async function getMemoryById(id, auth, chainOpts) {
@@ -42796,17 +42970,21 @@ async function getMemoryById(id, auth, chainOpts) {
   });
   return decryptRow(row, key3);
 }
-async function getRollbackHistory(auth, chainOpts) {
+async function getRollbackHistory(auth, chainOpts, filePath) {
   const client = await buildChainClient(chainOpts);
-  const q = native.buildGetAgentMemoryRollbackHistoryQuery(auth.pubkey);
+  const q = native.buildGetAgentMemoryRollbackHistoryQuery(
+    auth.pubkey,
+    filePath ?? null
+  );
   const raw2 = await client.query(
     native.QUERY_GET_AGENT_MEMORY_ROLLBACK_HISTORY,
-    { [native.ARG_AGENT_PUBKEY]: q.agent_pubkey_hex }
+    paramsWithOptionalFilePath(q.agent_pubkey_hex, q.file_path)
   );
   const parsed = native.parseRollbackRows(raw2 ?? []);
   return parsed.map((r2) => ({
     fromId: r2.from_id,
     toId: r2.to_id,
+    filePath: r2.file_path,
     reason: r2.reason,
     signer: Buffer.from(r2.signer).toString("hex"),
     createdAt: r2.created_at
@@ -42874,8 +43052,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);
@@ -42911,37 +43088,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
   };
 }
 
@@ -43181,9 +43356,7 @@ var MemoryGuardManager = class {
       toolNames: this.opts.memoryWriteToolNames,
       enforce: this.enforce,
       debug: this.opts.debug,
-      logger: guardLogger,
-      // Only this file may reach the single, path-less chain memory slot.
-      memoryFilePath: this.memoryFilePath
+      logger: guardLogger
     });
     return this.mapGuardResult(guard);
   }
@@ -43456,10 +43629,13 @@ export {
   KEY_FILENAMES,
   MemoryGuardManager,
   MemoryIntegrityError,
+  PRIVATE_CHAIN,
+  PUBLIC_CHAIN,
   PointerStore,
   SignatureVerificationError,
   bootSyncFailureLine,
   buildAllowedJudgeHosts,
+  chainForNetwork,
   chooseKeyPath,
   claimHashHex,
   classifyMemoryRead,
@@ -43483,13 +43659,13 @@ export {
   encryptedLength,
   flushTelemetry,
   generateKeypair,
-  getActiveMemory,
+  getActiveAgentMemory,
   getActiveMemoryId,
-  getAllAgentMemory,
   getConfigDir,
   getConfigPath,
   getMemoryById,
   getMemoryHistory,
+  getRecentAgentMemory,
   getRollbackHistory,
   guardMemoryWrite,
   isEnvelope,