@atbash/sdk 0.21.0-dev.0 → 0.23.0-dev.0

package/dist/index.mjs

@@ -104,6 +104,23 @@ function isAllowlistedJudgeHost(endpoint) {
     return false;
   }
 }
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]", "::1"]);
+var loopbackJudgePins = [];
+function setLoopbackJudgePinsForTests(keys) {
+  loopbackJudgePins = keys.map((k) => k.trim().toLowerCase());
+}
+function judgeVerifyKeys(endpoint, configuredKey) {
+  const host = new URL(endpoint).hostname.toLowerCase();
+  const pins = LOOPBACK_HOSTS.has(host) ? loopbackJudgePins : native.pinnedJudgeVerifyKeys(host);
+  const key = configuredKey?.trim().toLowerCase();
+  if (pins.length === 0) return key ? [key] : [];
+  if (key && !pins.includes(key)) {
+    throw new Error(
+      `[atbash] verifyPubKey ${key} is not the response-signing key pinned for ${host}. Refusing to load \u2014 an Atbash host's replies are checked against the key built into the SDK; remove verifyPubKey, or set it to the pinned key.`
+    );
+  }
+  return pins;
+}
 function validateJudgeEndpoint(judge) {
   const policy = judge?.policy === "self-hosted" ? "self-hosted" : "default";
   const candidate = judge?.endpoint?.trim() || DEFAULT_ENDPOINT;
@@ -218,7 +235,7 @@ function isJailHeld(pubkey) {
   return holds.has(pubkey);
 }
 function recordBlock(pubkey) {
-  const now = Date.now();
+  const now = performance.now();
   for (const [key, at] of blockedAt) if (now - at > BLOCK_MEMORY_MS) blockedAt.delete(key);
   blockedAt.set(pubkey, now);
 }
@@ -613,7 +630,7 @@ import {
 import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
 import { BatchLogRecordProcessor, LoggerProvider } from "@opentelemetry/sdk-logs";
 import { createHash } from "crypto";
-var SDK_VERSION = true ? "0.21.0-dev.0" : "";
+var SDK_VERSION = true ? "0.23.0-dev.0" : "";
 var SDK_LANGUAGE = "node";
 function sdkResourceAttributes() {
   const attrs = {
@@ -884,7 +901,10 @@ function forcedChainNetwork(flagValue) {
 
 // src-ts/client.ts
 var AGENT_NOT_REGISTERED = "Agent not registered. Onboard the agent at the dashboard before submitting actions.";
+var TOOL_CALL_IDS_FOR_TESTS = /* @__PURE__ */ Symbol.for("@atbash/sdk.toolCallIdsForTests");
 function generateToolCallId() {
+  const fixed = globalThis[TOOL_CALL_IDS_FOR_TESTS];
+  if (fixed && fixed.ids.length > 0) return fixed.ids[fixed.next++ % fixed.ids.length];
   return `tc-${Date.now()}-${randomHex(4)}`;
 }
 function resolveConstructorChain(options) {
@@ -921,12 +941,21 @@ var Atbash = class _Atbash {
   orgName;
   /** Default judge response-signing pubkey, if configured (see fromConfig). */
   verifyPubKey;
+  /**
+   * The keys every judge reply must be signed by: the host's pinned keys, or
+   * the configured `verifyPubKey` on a host with none. Empty means unchecked.
+   */
+  verifyKeys;
   /** Default org encryption key — see {@link AtbashOptions.orgEncryptionPubKey}. */
   orgEncryptionPubKey;
   /** When true (default), `auditToolCall` denies on any error. */
   failClosed;
   /** When true (default), an unenforced (audit-tier) answer is refused. */
   requireEnforcement;
+  /** When true, a signed non-enforcing mode never relaxes a verdict. */
+  enforceLocally;
+  /** Results whose enforcement mode came signed and bound to their call. */
+  modeTrusted = /* @__PURE__ */ new WeakSet();
   /** Overall deadline for one auditToolCall decision, in ms. */
   decisionTimeoutMs;
   /** Org key learned from the last agent-exists check, for this agent only. */
@@ -990,9 +1019,11 @@ var Atbash = class _Atbash {
     this._forcedNetwork = forcedChainNetwork();
     this.orgName = options.orgName;
     this.verifyPubKey = validated.verifyPubKey ?? void 0;
+    this.verifyKeys = judgeVerifyKeys(this.endpoint, this.verifyPubKey);
     this.orgEncryptionPubKey = options.orgEncryptionPubKey;
     this.failClosed = options.failClosed !== false;
     this.requireEnforcement = options.requireEnforcement !== false;
+    this.enforceLocally = options.enforceLocally === true;
     this.decisionTimeoutMs = options.decisionTimeoutMs ?? DEFAULT_DECISION_TIMEOUT_MS;
     this.debug = options.debug === true;
     this.logger = options.logger ?? {};
@@ -1001,7 +1032,7 @@ var Atbash = class _Atbash {
     if (this.endpoint !== DEFAULT_ENDPOINT) {
       this.logger.warn?.("[atbash] running on non-default judge endpoint", {
         endpoint: this.endpoint,
-        verifying: this.verifyPubKey ? "with response-signature pubkey configured" : "without signature verification"
+        verifying: this.verifyKeys.length > 0 ? "with response-signature pubkey configured" : "without signature verification"
       });
     }
     if (isAllowlistedJudgeHost(this.endpoint)) {
@@ -1039,12 +1070,12 @@ var Atbash = class _Atbash {
     _Atbash.environmentLogged = true;
     const brief = (rid) => rid ? `${rid.slice(0, 8)}\u2026` : "(unset)";
     this.logger.info?.(
-      `[atbash] environment \u2014 judge=${this.endpoint} privateChain=${brief(native.DEFAULT_PRIVATE_BLOCKCHAIN_RID)} activeChain=${brief(this.blockchainRid)} responseSignatureCheck=${this.verifyPubKey ? "on" : "off"}`,
+      `[atbash] environment \u2014 judge=${this.endpoint} privateChain=${brief(native.DEFAULT_PRIVATE_BLOCKCHAIN_RID)} activeChain=${brief(this.blockchainRid)} responseSignatureCheck=${this.verifyKeys.length > 0 ? "on" : "off"}`,
       {
         judgeEndpoint: this.endpoint,
         privateBlockchainRid: native.DEFAULT_PRIVATE_BLOCKCHAIN_RID,
         activeBlockchainRid: this.blockchainRid,
-        responseSignatureCheck: Boolean(this.verifyPubKey)
+        responseSignatureCheck: this.verifyKeys.length > 0
       }
     );
   }
@@ -1162,6 +1193,7 @@ config.json still holds an "agentKey" (${identity}), but a settings file no long
       verifyPubKey: validated.verifyPubKey ?? void 0,
       failClosed: options.failClosed,
       requireEnforcement: options.requireEnforcement,
+      enforceLocally: options.enforceLocally,
       decisionTimeoutMs: options.decisionTimeoutMs,
       // ATBASH_DEBUG lets an operator turn diagnostics on without editing a
       // host's plugin config, which is usually the harder half.
@@ -1296,22 +1328,34 @@ config.json still holds an "agentKey" (${identity}), but a settings file no long
    * response bytes via the Rust core's `verifySignature`.
    */
   async judgeAction(action, context = "", options = {}) {
+    return this.judgeTracked(action, context, options, false);
+  }
+  /**
+   * judgeAction, optionally asking the judge for the true verdict and the
+   * organisation's enforcement mode so this client applies the mode itself.
+   *
+   * Only auditToolCall opts in: judgeAction's callers keep the server-side
+   * downgrade they gate on today.
+   *
+   * @param clientEnforces - Send `X-Atbash-Client-Enforcement` when the reply can be trusted.
+   */
+  judgeTracked(action, context, options, clientEnforces) {
     return this.track("judgeAction", this.auth.pubkey, async () => {
       try {
-        return await this._judgeAction(action, context, options);
+        return await this._judgeAction(action, context, options, clientEnforces);
       } catch (err) {
         if (!isEncryptionStateMismatch(err)) throw err;
         this._orgKeyFromChain = null;
-        return await this._judgeAction(action, context, options);
+        return await this._judgeAction(action, context, options, clientEnforces);
       }
     });
   }
-  async _judgeAction(action, context, options) {
+  async _judgeAction(action, context, options, clientEnforces = false) {
     if (!action?.trim()) {
       throw new Error("action is required and cannot be empty.");
     }
     if (isJailHeld(this.auth.pubkey)) return this.localJailBlock();
-    const startedAt = Date.now();
+    const startedAt = performance.now();
     let chainOpts = options.chainOpts;
     if (options.orgName && this._explicitChain) {
       chainOpts = options.chainOpts ?? {
@@ -1368,17 +1412,23 @@ config.json still holds an "agentKey" (${identity}), but a settings file no long
     if (options.toolArgsJson) body.tool_args_json = options.toolArgsJson;
     if (options.resolved) body.resolved = options.resolved;
     if (options.mode) body.mode = options.mode;
+    const verifyKeys = this.effectiveVerifyKeys(options.verifyPubKey);
+    const optIn = clientEnforces && (verifyKeys.length > 0 || this.enforceLocally);
+    const optInValue = this.enforceLocally ? "strict" : "1";
     let resp;
     try {
-      resp = await this.http.post("/api/v1/judge", body);
+      resp = await this.http.post(
+        "/api/v1/judge",
+        body,
+        optIn ? { "X-Atbash-Client-Enforcement": optInValue } : void 0
+      );
     } catch (err) {
       throw this.transportError(err);
     }
     if (!resp.ok) throw await this.httpError(resp);
     const bodyBytes = Buffer.from(await resp.arrayBuffer());
-    const verifyPubKey = this.effectiveVerifyKey(options.verifyPubKey);
-    if (verifyPubKey !== void 0) {
-      verifyResponseSignature(bodyBytes, resp, verifyPubKey);
+    if (verifyKeys.length > 0) {
+      verifyResponseSignature(bodyBytes, resp, verifyKeys);
     }
     const parsed = tryParseJson(bodyBytes.toString("utf-8"));
     if (!isRecord2(parsed)) {
@@ -1398,6 +1448,7 @@ config.json still holds an "agentKey" (${identity}), but a settings file no long
       provider: wireText(data.provider),
       latencyMs: wireNumber(data.latency_ms),
       toolCallId: wireText(data.tool_call_id, logResult.toolCallId),
+      ...wireText(data.judgment_id) ? { judgmentId: wireText(data.judgment_id) } : {},
       onChain: Boolean(data.on_chain),
       enforced: Boolean(data.enforced),
       enforcementMode: wireText(data.enforcement_mode),
@@ -1405,23 +1456,46 @@ config.json still holds an "agentKey" (${identity}), but a settings file no long
       score,
       refusal: explicitRefusal(data)
     };
-    return this.applyJailHold(result, startedAt);
+    if (optIn) {
+      const echo = data.client_enforcement;
+      if (echo !== void 0 && echo !== optInValue || echo === void 0 && this.enforceLocally) {
+        throw new SignatureVerificationError(
+          "the reply does not confirm the enforcement this client asked for"
+        );
+      }
+      if (verifyKeys.length > 0) {
+        const statedId = wireText(data.tool_call_id);
+        const statedJudgment = wireText(data.judgment_id);
+        if (statedId && statedId !== logResult.toolCallId && statedId !== judgmentId || statedJudgment && statedJudgment !== judgmentId) {
+          throw new SignatureVerificationError(
+            `the signed reply is for call ${statedJudgment || statedId}, not this one`
+          );
+        }
+        if (statedId && echo === optInValue) this.modeTrusted.add(result);
+      }
+    }
+    return this.applyJailHold(result, startedAt, wireText(data.on_chain_status));
   }
   /**
-   * Start a local hold on an enforced, on-chain BLOCK (the verdict that jails).
-   * Refuse any other result that lands while the agent is held, or whose
-   * request was already in flight when the block arrived: the server judged it
-   * on pre-jail state.
+   * Start a local hold on an enforced BLOCK that jails: one already on chain,
+   * or one the judge answered before its chain write landed
+   * (`on_chain_status: "pending"`), which jails once it lands. Refuse any other
+   * result that lands while the agent is held, or whose request was already in
+   * flight when the block arrived: the server judged it on pre-jail state.
+   *
+   * @param onChainStatus - The reply's `on_chain_status`; empty when absent.
    */
-  applyJailHold(result, startedAt) {
+  applyJailHold(result, startedAt, onChainStatus = "") {
     const pubkey = this.auth.pubkey;
-    if (result.verdict === "BLOCK" && result.enforced && result.onChain) {
+    if (result.verdict === "BLOCK" && result.enforced) {
       recordBlock(pubkey);
-      holdJail(
-        pubkey,
-        () => this.getAgentPolicy(pubkey).then((p) => p.isJailed),
-        () => this.logger.warn?.("[atbash] local jail hold released: the chain did not confirm the jail in time")
-      );
+      if (result.onChain || onChainStatus === "pending") {
+        holdJail(
+          pubkey,
+          () => this.getAgentPolicy(pubkey).then((p) => p.isJailed),
+          () => this.logger.warn?.("[atbash] local jail hold released: the chain did not confirm the jail in time")
+        );
+      }
       return result;
     }
     return isJailHeld(pubkey) || blockedSince(pubkey, startedAt) ? this.localJailBlock(result.toolCallId) : result;
@@ -1476,13 +1550,18 @@ config.json still holds an "agentKey" (${identity}), but a settings file no long
     try {
       this.logger.info?.("[atbash] judge API called", { tool: toolName });
       const result = await withDeadline(
-        this.judgeAction(actionText, contextText, {
-          toolName,
-          toolArgsJson: argsJson,
-          orgName: this.orgName,
-          // Passed through unredacted — caller vouches for the contents.
-          resolved: input.resolved
-        }),
+        this.judgeTracked(
+          actionText,
+          contextText,
+          {
+            toolName,
+            toolArgsJson: argsJson,
+            orgName: this.orgName,
+            // Passed through unredacted — caller vouches for the contents.
+            resolved: input.resolved
+          },
+          true
+        ),
         this.decisionTimeoutMs
       );
       return this.decide(result);
@@ -1492,7 +1571,7 @@ config.json still holds an "agentKey" (${identity}), but a settings file no long
         return {
           allow: false,
           verdict: "ERROR",
-          reason: `The judge's reply failed its signature check (${errorMessage(err)}), so it was not trusted.`
+          reason: `The judge's reply was not trusted (${errorMessage(err)}).`
         };
       }
       if (err instanceof JudgeRefusalError || err instanceof AtbashAPIError && isRefusalStatus(err.status)) {
@@ -1502,20 +1581,20 @@ config.json still holds an "agentKey" (${identity}), but a settings file no long
     }
   }
   /**
-   * The verify key for one call (R4, governor tier-2 review). A per-call key
-   * may only narrow what the client accepts: on a client pinned to a judge
-   * key it must be that same key, never a replacement; on an unpinned client
-   * it adds the check.
+   * The verify keys for one call (R4, governor tier-2 review). A per-call key
+   * may only narrow what the client accepts: on a client pinned to judge keys
+   * it must be one of them, never a replacement; on an unpinned client it
+   * adds the check.
    */
-  effectiveVerifyKey(perCall) {
-    if (perCall === void 0) return this.verifyPubKey;
+  effectiveVerifyKeys(perCall) {
+    if (perCall === void 0) return this.verifyKeys;
     const key = perCall.trim().toLowerCase();
-    if (this.verifyPubKey !== void 0 && key !== this.verifyPubKey) {
+    if (this.verifyKeys.length > 0 && !this.verifyKeys.includes(key)) {
       throw new SignatureVerificationError(
         "a per-call verifyPubKey cannot replace the judge key this client is pinned to"
       );
     }
-    return key;
+    return [key];
   }
   /**
    * Collapse a judge result into a {@link Decision}. The most restrictive
@@ -1527,7 +1606,8 @@ config.json still holds an "agentKey" (${identity}), but a settings file no long
    * never overrides a refusal.
    */
   decide(result) {
-    const inner = this.decideInner(result);
+    const decided = this.applyMode(result);
+    const inner = result.judgmentId ? { ...decided, judgmentId: result.judgmentId } : decided;
     if (!result.enforcementMode) return inner;
     return {
       ...inner,
@@ -1535,6 +1615,50 @@ config.json still holds an "agentKey" (${identity}), but a settings file no long
       enforcementMode: result.enforcementMode
     };
   }
+  /**
+   * Apply the organisation's enforcement mode to the judge's true verdict.
+   *
+   * Only a mode that arrived signed and bound to this call counts; a missing,
+   * unsigned or unknown mode, or enforceLocally, means enforce. Under
+   * `shadow`, `monitor` or `off` a BLOCK or HOLD runs, reported in
+   * `wouldVerdict`. An ERROR stays an error: it is not a verdict.
+   */
+  applyMode(result) {
+    const mode = result.enforcementMode;
+    const relaxes = this.modeTrusted.has(result) && (mode === "shadow" || mode === "monitor" || mode === "off");
+    if (result.status === "shadow_recorded" && result.verdict === "No verdict") {
+      if (!relaxes || this.enforceLocally) {
+        return {
+          allow: false,
+          verdict: "ERROR",
+          reason: "Atbash recorded this action without judging it (the organisation is not enforcing), and this client requires a verdict.",
+          toolCallId: result.toolCallId
+        };
+      }
+      this.logger.info?.(`[atbash] recorded in ${mode} mode; not judged yet`, {
+        toolCallId: result.toolCallId
+      });
+      return {
+        allow: true,
+        verdict: "ALLOW",
+        reason: `Recorded in ${mode} mode; the verdict appears in the dashboard.`,
+        toolCallId: result.toolCallId
+      };
+    }
+    const inner = this.decideInner(result);
+    if (!relaxes || this.enforceLocally || inner.allow) return inner;
+    if (inner.verdict !== "BLOCK" && inner.verdict !== "HOLD") return inner;
+    this.logger.warn?.(`[atbash] would ${inner.verdict.toLowerCase()} (${mode} mode): ${inner.reason ?? ""}`, {
+      toolCallId: inner.toolCallId
+    });
+    return {
+      allow: true,
+      verdict: "ALLOW",
+      reason: inner.reason,
+      toolCallId: inner.toolCallId,
+      wouldVerdict: inner.verdict
+    };
+  }
   decideInner(result) {
     const toolCallId = result.toolCallId;
     const deny = (verdict, reason) => ({
@@ -1570,7 +1694,9 @@ config.json still holds an "agentKey" (${identity}), but a settings file no long
         return {
           allow: false,
           verdict: "ERROR",
-          reason: "Atbash logged this action but did not check it (audit-tier plan), and this client requires a checked decision. Upgrade the plan, or set requireEnforcement: false for log-only mode.",
+          // The judge's own reason says why it did not check (the plan, a
+          // deactivated agent); a fixed "audit-tier plan" hid which.
+          reason: result.reason ? `Atbash did not check this action, and this client requires a checked decision. The judge said: ${result.reason}` : "Atbash logged this action but did not check it (audit-tier plan), and this client requires a checked decision. Upgrade the plan, or set requireEnforcement: false for log-only mode.",
           toolCallId
         };
       }
@@ -1660,28 +1786,52 @@ config.json still holds an "agentKey" (${identity}), but a settings file no long
     const pk = agentPubkey ?? this.auth.pubkey;
     return this.track("getJudgmentStatus", pk, async () => {
       const brid = await this.callBrid(chainOpts);
+      const optIn = this.verifyKeys.length > 0 || this.enforceLocally;
+      const optInValue = this.enforceLocally ? "strict" : "1";
       const resp = await this.http.get(
         "/api/v1/judge",
         { tool_call_id: judgmentId, agent_pubkey: pk, brid },
-        this.authHeaders(brid)
+        {
+          ...this.authHeaders(brid),
+          ...optIn ? { "X-Atbash-Client-Enforcement": optInValue } : {}
+        }
       );
       await this.raiseIfError(resp);
       const bytes = Buffer.from(await resp.arrayBuffer());
-      if (this.verifyPubKey !== void 0) {
-        verifyResponseSignature(bytes, resp, this.verifyPubKey);
+      if (this.verifyKeys.length > 0) {
+        verifyResponseSignature(bytes, resp, this.verifyKeys);
       }
       const parsed = tryParseJson(bytes.toString("utf-8"));
       const data = isRecord2(parsed) ? parsed : {};
-      return {
+      const rawId = data.tool_call_id;
+      const statedId = wireText(rawId);
+      const sameCall = rawId === void 0 || rawId === null || statedId === judgmentId;
+      let modeTrusted = false;
+      if (optIn) {
+        const echo = data.client_enforcement;
+        if (echo !== void 0 && echo !== optInValue || echo === void 0 && this.enforceLocally) {
+          throw new SignatureVerificationError(
+            "the status does not confirm the enforcement this client asked for"
+          );
+        }
+        modeTrusted = this.verifyKeys.length > 0 && echo === optInValue && statedId === judgmentId;
+      }
+      const status = {
         status: normalizeStatus(data.status),
         verdict: normalizeVerdict(data.verdict),
-        allow: this.executable(data),
+        allow: sameCall && this.executable(data),
         reason: wireText(data.reason),
-        judgmentId: wireText(data.judgmentId, judgmentId),
-        onChain: optBool(data.onChain),
-        cached: optBool(data.cached),
-        responseTimeMs: optNumber(data.responseTimeMs)
+        judgmentId: statedId || judgmentId,
+        responseTimeMs: optNumber(data.response_time_ms)
       };
+      const mode = wireText(data.enforcement_mode);
+      if (!modeTrusted || this.enforceLocally || !(mode === "shadow" || mode === "monitor" || mode === "off") || status.verdict !== "BLOCK" && status.verdict !== "HOLD") {
+        return status;
+      }
+      this.logger.warn?.(`[atbash] would ${status.verdict.toLowerCase()} (${mode} mode): ${status.reason}`, {
+        toolCallId: judgmentId
+      });
+      return { ...status, verdict: "ALLOW", allow: true, wouldVerdict: status.verdict };
     });
   }
   /* ── risk-engine queries (action-dispatched GET) ───────────────────────── */
@@ -2183,14 +2333,14 @@ async function withDeadline(p, ms) {
     clearTimeout(timer);
   }
 }
-function verifyResponseSignature(bodyBytes, resp, verifyPubKey) {
+function verifyResponseSignature(bodyBytes, resp, verifyKeys) {
   const sig = resp.headers.get("X-Atbash-Signature");
   if (!sig) {
     throw new SignatureVerificationError("missing X-Atbash-Signature header");
   }
-  let ok;
+  let ok = false;
   try {
-    ok = native.verifySignature(bodyBytes, sig, verifyPubKey);
+    ok = verifyKeys.some((key) => native.verifySignature(bodyBytes, sig, key));
   } catch (err) {
     throw new SignatureVerificationError(
       `signature verification threw: ${errorMessage(err)}`
@@ -2282,10 +2432,6 @@ function optNumber(v) {
   const n = Number(v);
   return Number.isFinite(n) ? n : void 0;
 }
-function optBool(v) {
-  if (v === null || v === void 0) return void 0;
-  return Boolean(v);
-}
 function tryParseJson(text) {
   try {
     return JSON.parse(text);
@@ -2616,14 +2762,15 @@ async function decryptRow(row, key) {
     updatedAt: parsed.updated_at
   };
 }
-async function readRows(action, auth, chainOpts, filePath) {
+async function readRows(action, auth, chainOpts, filePath, extra = {}) {
   const key = await deriveMemoryKey(auth.privkey);
   const rows = await memoryQuery(
     action,
     auth,
     resolveBlockchainRid(chainOpts),
     chainOpts,
-    filePath
+    filePath,
+    extra
   );
   return Promise.all((rows ?? []).map((row) => decryptRow(row, key)));
 }
@@ -2643,8 +2790,29 @@ function getRecentAgentMemory(auth, chainOpts, filePath) {
 function getActiveAgentMemory(auth, chainOpts, filePath) {
   return readRows("memory-active", auth, chainOpts, filePath ?? null);
 }
-function getMemoryHistory(auth, chainOpts, filePath) {
-  return readRows("memory-history", auth, chainOpts, filePath ?? null);
+var MEMORY_HISTORY_MAX_COUNT = 200;
+function memoryHistoryPageArgs(page) {
+  const extra = {};
+  for (const [name, value] of [
+    ["max_count", page?.maxCount],
+    ["before_id", page?.beforeId]
+  ]) {
+    if (value === void 0) continue;
+    if (!Number.isSafeInteger(value) || value < 1) {
+      throw new Error(`getMemoryHistory: ${name} must be a positive integer`);
+    }
+    if (name === "max_count" && value > MEMORY_HISTORY_MAX_COUNT) {
+      throw new Error(`getMemoryHistory: max_count must be at most ${MEMORY_HISTORY_MAX_COUNT}`);
+    }
+    extra[name] = value;
+  }
+  return extra;
+}
+async function getMemoryHistory(auth, chainOpts, filePath, page) {
+  const rows = await readRows("memory-history", auth, chainOpts, filePath ?? null, memoryHistoryPageArgs(page));
+  const beforeId = page?.beforeId;
+  const older = beforeId === void 0 ? rows : rows.filter((row) => row.id < beforeId);
+  return page?.maxCount === void 0 ? older : older.slice(0, page.maxCount);
 }
 async function getMemoryById(id, auth, chainOpts) {
   native.validateMemoryId(id);
@@ -3942,6 +4110,7 @@ export {
   isEnvelope,
   isJailHeld,
   isValidPrivateKey,
+  judgeVerifyKeys,
   keyFingerprintOf,
   keyPathCandidates,
   loadAgent,
@@ -3968,6 +4137,7 @@ export {
   saveUserConfig,
   scanMemory,
   scanMemoryBatch,
+  setLoopbackJudgePinsForTests,
   setupTelemetry,
   shutdownTelemetry,
   signEncryptedToolCall,

package/dist/testing.d.mts

@@ -0,0 +1,15 @@
+/**
+ * Helpers for the SDK's own tests, published as `@atbash/sdk/testing` and kept
+ * out of the main entry: fixing the call ids in production would let an old
+ * signed reply pass as the answer to a new call.
+ */
+/**
+ * Fix the ids the client generates, handed out in turn, so a test can serve a
+ * judge reply signed for them. A judge call takes two: its call id, then its
+ * judgment id.
+ *
+ * @param ids - One id or several, used in turn; `undefined` restores random ids.
+ */
+declare function setToolCallIdForTests(ids: string | readonly string[] | undefined): void;
+
+export { setToolCallIdForTests };

package/dist/testing.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Helpers for the SDK's own tests, published as `@atbash/sdk/testing` and kept
+ * out of the main entry: fixing the call ids in production would let an old
+ * signed reply pass as the answer to a new call.
+ */
+/**
+ * Fix the ids the client generates, handed out in turn, so a test can serve a
+ * judge reply signed for them. A judge call takes two: its call id, then its
+ * judgment id.
+ *
+ * @param ids - One id or several, used in turn; `undefined` restores random ids.
+ */
+declare function setToolCallIdForTests(ids: string | readonly string[] | undefined): void;
+
+export { setToolCallIdForTests };

package/dist/testing.js

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src-ts/testing.ts
+var testing_exports = {};
+__export(testing_exports, {
+  setToolCallIdForTests: () => setToolCallIdForTests
+});
+module.exports = __toCommonJS(testing_exports);
+var TOOL_CALL_IDS_FOR_TESTS = /* @__PURE__ */ Symbol.for("@atbash/sdk.toolCallIdsForTests");
+function setToolCallIdForTests(ids) {
+  globalThis[TOOL_CALL_IDS_FOR_TESTS] = ids === void 0 ? void 0 : { ids: typeof ids === "string" ? [ids] : [...ids], next: 0 };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setToolCallIdForTests
+});

package/dist/testing.mjs

@@ -0,0 +1,8 @@
+// src-ts/testing.ts
+var TOOL_CALL_IDS_FOR_TESTS = /* @__PURE__ */ Symbol.for("@atbash/sdk.toolCallIdsForTests");
+function setToolCallIdForTests(ids) {
+  globalThis[TOOL_CALL_IDS_FOR_TESTS] = ids === void 0 ? void 0 : { ids: typeof ids === "string" ? [ids] : [...ids], next: 0 };
+}
+export {
+  setToolCallIdForTests
+};

package/index.d.ts

@@ -236,6 +236,9 @@ export declare function parseRollbackRows(value: any): Array<RawRollbackRowJs>
 
 export declare function parseScoreFromReason(reason: string): ParsedScoreJs
 
+/** The response-signing pubkeys pinned for a judge host; empty when it has none. */
+export declare function pinnedJudgeVerifyKeys(host: string): Array<string>
+
 export declare const QUERY_GET_ACTIVE_AGENT_MEMORY: string
 
 export declare const QUERY_GET_ACTIVE_MEMORY_ID: string