@atbash/sdk 0.9.0 → 0.9.2

package/dist/index.mjs

@@ -2930,6 +2930,13 @@ function buildAllowedJudgeHosts() {
   ]);
 }
 var ALLOWED_JUDGE_HOSTS = buildAllowedJudgeHosts();
+function isAllowlistedJudgeHost(endpoint) {
+  try {
+    return ALLOWED_JUDGE_HOSTS.has(new URL(endpoint).hostname.toLowerCase());
+  } catch {
+    return false;
+  }
+}
 function validateJudgeEndpoint(judge) {
   const policy = judge?.policy === "self-hosted" ? "self-hosted" : "default";
   const candidate = judge?.endpoint?.trim() || DEFAULT_ENDPOINT;
@@ -2977,11 +2984,23 @@ var AtbashAPIError = class extends Error {
   status;
   /** Raw response body text (may be empty). */
   body;
-  constructor(status, body, statusText = "", endpoint = DEFAULT_ENDPOINT) {
-    super(enrich(status, body, statusText, endpoint));
+  /**
+   * Request path this status came from, e.g. `/api/v1/judge` — absent when the
+   * request never reached a response (transport failures carry status 0).
+   *
+   * A status alone does not say what failed. Several routes answer one call, and
+   * more than one of them can 404: a caller reading only `404` cannot tell "this
+   * agent is not registered" from "the chain-routing lookup did not resolve", and
+   * has to guess from the body's prose — which a 404 raised before any handler
+   * ran does not carry. The path is the fact that settles it.
+   */
+  path;
+  constructor(status, body, statusText = "", endpoint = DEFAULT_ENDPOINT, path7) {
+    super(enrich(status, body, statusText, endpoint, path7));
     this.name = "AtbashAPIError";
     this.status = status;
     this.body = body;
+    this.path = path7;
   }
 };
 var SignatureVerificationError = class extends Error {
@@ -2990,9 +3009,9 @@ var SignatureVerificationError = class extends Error {
     this.name = "SignatureVerificationError";
   }
 };
-function enrich(status, body, statusText, endpoint) {
+function enrich(status, body, statusText, endpoint, path7) {
   const dashboard = endpoint.replace(/\/+$/, "") || DEFAULT_ENDPOINT;
-  let msg = `API error ${status}: ${body || statusText}`;
+  let msg = `API error ${status}${path7 ? ` from ${path7}` : ""}: ${body || statusText}`;
   const lowered = body.toLowerCase();
   if (lowered.includes("agent not registered")) {
     msg += `
@@ -3082,6 +3101,13 @@ function classifyTransportError(err, url, method, timeoutMs) {
       { cause: err }
     );
   }
+  if (code2 === "UND_ERR_CONNECT_TIMEOUT") {
+    return new HttpTransportError(
+      "timeout",
+      `${method} ${url} could not establish a connection before the transport deadline \u2014 check the endpoint and network`,
+      { cause: err }
+    );
+  }
   if (code2 === "ENOTFOUND" || code2 === "EAI_AGAIN") {
     return new HttpTransportError(
       "dns",
@@ -3239,7 +3265,10 @@ function canonicalAllow(data) {
 import { readFileSync as readFileSync2 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
-import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import {
+  AggregationTemporalityPreference,
+  OTLPMetricExporter
+} from "@opentelemetry/exporter-metrics-otlp-http";
 import { resourceFromAttributes } from "@opentelemetry/resources";
 import {
   MeterProvider,
@@ -3249,6 +3278,8 @@ var meterProvider = null;
 var callCounter = null;
 var durationHistogram = null;
 var defaultSource = "sdk";
+var sourceExplicitlySet = false;
+var requestedExportIntervalMs;
 function isTelemetryOptedOut() {
   const disabled = process.env.ATBASH_TELEMETRY_DISABLED?.trim().toLowerCase();
   if (disabled && ["1", "true", "yes", "on"].includes(disabled)) {
@@ -3272,20 +3303,41 @@ function autoInit() {
 }
 function setupTelemetry(config2) {
   if (!config2.enabled) return;
-  if (meterProvider) return;
   if (isTelemetryOptedOut()) return;
+  if (config2.source && !sourceExplicitlySet) {
+    defaultSource = config2.source;
+    sourceExplicitlySet = true;
+  }
+  if (config2.exportIntervalMs !== void 0 && requestedExportIntervalMs === void 0) {
+    requestedExportIntervalMs = config2.exportIntervalMs;
+  }
+  if (meterProvider) return;
   if (!config2.endpoint || !config2.getAuthHeaders) return;
-  if (/^https?:\/\/(localhost|127\.0\.0\.1|0\.0\.0\.0)(:|\/|$)/i.test(config2.endpoint)) return;
-  defaultSource = config2.source ?? "sdk";
+  if (/^https?:\/\/(localhost|127\.0\.0\.1|0\.0\.0\.0)(:|\/|$)/i.test(
+    config2.endpoint
+  ))
+    return;
   const proxyUrl = `${config2.endpoint.replace(/\/+$/, "")}/api/telemetry`;
   const getAuthHeaders = config2.getAuthHeaders;
   const exporter = new OTLPMetricExporter({
     url: proxyUrl,
-    headers: async () => getAuthHeaders()
+    headers: async () => getAuthHeaders(),
+    // DELTA, not the OTel default of CUMULATIVE.
+    //
+    // A cumulative counter reports a running total, and the backend recovers
+    // the increment by differencing consecutive points of a series. That needs
+    // at least two points. Most Atbash callers are short-lived — a CLI run
+    // exports once and exits — so their series has exactly one point, nothing
+    // to difference against, and the usage board reads them as zero: the calls
+    // arrive, carry the right `source`, and still count for nothing.
+    //
+    // A delta counter reports the increment itself, so a single export is a
+    // whole truthful datapoint and SUM over any window is the real call count.
+    temporalityPreference: AggregationTemporalityPreference.DELTA
   });
   const reader = new PeriodicExportingMetricReader({
     exporter,
-    exportIntervalMillis: config2.exportIntervalMs ?? 6e4
+    exportIntervalMillis: requestedExportIntervalMs ?? 6e4
   });
   meterProvider = new MeterProvider({
     resource: resourceFromAttributes({
@@ -3329,6 +3381,9 @@ async function shutdownTelemetry() {
   meterProvider = null;
   callCounter = null;
   durationHistogram = null;
+  defaultSource = "sdk";
+  sourceExplicitlySet = false;
+  requestedExportIntervalMs = void 0;
 }
 
 // src-ts/userConfig.ts
@@ -3522,17 +3577,23 @@ 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) }
+    if (isAllowlistedJudgeHost(this.endpoint)) {
+      try {
+        setupTelemetry({
+          enabled: true,
+          endpoint: this.endpoint,
+          getAuthHeaders: () => this.authHeaders()
+        });
+      } catch (err) {
+        this.logger.warn?.(
+          "[atbash] telemetry setup failed \u2014 continuing without metrics",
+          { error: String(err) }
+        );
+      }
+    } else {
+      this.logger.info?.(
+        "[atbash] telemetry disabled \u2014 the agent bearer is only sent to hosts that already receive it, and this judge endpoint is not one",
+        { endpoint: this.endpoint }
       );
     }
   }
@@ -4413,7 +4474,8 @@ var Atbash = class _Atbash {
       resp.status,
       await safeText(resp),
       resp.statusText,
-      this.endpoint
+      this.endpoint,
+      requestPath(resp.url)
     );
   }
   /**
@@ -4555,6 +4617,14 @@ function parseJson(bytes) {
   const parsed = tryParseJson(bytes.toString("utf-8"));
   return parsed === void 0 ? {} : parsed;
 }
+function requestPath(url) {
+  if (!url) return void 0;
+  try {
+    return new URL(url).pathname || void 0;
+  } catch {
+    return void 0;
+  }
+}
 async function safeText(resp) {
   try {
     return await resp.text();
@@ -35212,9 +35282,9 @@ var ZodUnion = class extends ZodType {
   }
 };
 types.ZodUnion = ZodUnion;
-ZodUnion.create = (types2, params) => {
+ZodUnion.create = (types3, params) => {
   return new ZodUnion({
-    options: types2,
+    options: types3,
     typeName: ZodFirstPartyTypeKind.ZodUnion,
     ...processCreateParams(params)
   });
@@ -38671,9 +38741,9 @@ _nodeUtil.exports;
   var freeProcess = moduleExports && freeGlobal2.process;
   var nodeUtil2 = (function() {
     try {
-      var types2 = freeModule && freeModule.require && freeModule.require("util").types;
-      if (types2) {
-        return types2;
+      var types3 = freeModule && freeModule.require && freeModule.require("util").types;
+      if (types3) {
+        return types3;
       }
       return freeProcess && freeProcess.binding && freeProcess.binding("util");
     } catch (e) {
@@ -42921,7 +42991,7 @@ async function commitMemoryVersion(plaintext, auth, opts) {
   const chainOpts = await resolveChainOptsForOrg(opts, auth);
   const client = await buildChainClient(chainOpts);
   const { sigProvider } = buildSigner(auth);
-  await client.signAndSendUniqueTransaction(
+  const receipt = await client.signAndSendUniqueTransaction(
     {
       name: native.OP_ADD_AGENT_MEMORY,
       args: [
@@ -42934,6 +43004,9 @@ async function commitMemoryVersion(plaintext, auth, opts) {
     },
     sigProvider
   );
+  if (receipt.status !== index.ResponseStatus.Confirmed) {
+    throw new Error(`Memory transaction was not confirmed (status=${receipt.status})`);
+  }
 }
 async function decryptRow(row, key3) {
   const parsed = native.parseMemoryRow(gtvToFfiSafe(row));
@@ -43043,22 +43116,109 @@ async function rollbackMemory(toId, reason, auth, opts) {
   const chainOpts = await resolveChainOptsForOrg(opts, auth);
   const client = await buildChainClient(chainOpts);
   const { sigProvider } = buildSigner(auth);
-  await client.signAndSendUniqueTransaction(
+  const receipt = await client.signAndSendUniqueTransaction(
     {
       name: native.OP_ROLLBACK_AGENT_MEMORY,
       args: [toGtxBytes(args.agent_pubkey), args.to_id, args.reason]
     },
     sigProvider
   );
+  if (receipt.status !== index.ResponseStatus.Confirmed) {
+    throw new Error(`Memory rollback was not confirmed (status=${receipt.status})`);
+  }
 }
 
 // src-ts/memory/_json_safe.ts
+import { types as types2 } from "util";
+var replacementKeys = [
+  "newText",
+  "new_string",
+  "new_str",
+  "newStr",
+  "replacement"
+];
+var argumentKeys = [
+  "file_path",
+  "path",
+  "filename",
+  "target",
+  "file",
+  "filePath",
+  "content",
+  ...replacementKeys,
+  "value",
+  "text"
+];
+var maxPrototypeDepth = 32;
+var maxEditSlots = 65536;
+var maxTextUnits = 16 * 1024 * 1024;
+function invalid() {
+  throw new TypeError("Unreadable or unsupported memory classifier input");
+}
+function dataProperty(value, key3) {
+  let current = value;
+  for (let depth = 0; current !== null; depth++) {
+    if (depth >= maxPrototypeDepth || types2.isProxy(current)) invalid();
+    const descriptor = Object.getOwnPropertyDescriptor(current, key3);
+    if (descriptor) {
+      if (!("value" in descriptor)) invalid();
+      return descriptor.value;
+    }
+    current = Object.getPrototypeOf(current);
+  }
+  return void 0;
+}
 function toJsonSafe(value) {
-  try {
-    return JSON.parse(JSON.stringify(value ?? null));
-  } catch {
-    return null;
+  let textUnits = 0;
+  function scalar(input) {
+    if (input == null) return null;
+    if (typeof input === "string") {
+      textUnits += input.length;
+      if (textUnits > maxTextUnits) invalid();
+      return input;
+    }
+    if (typeof input === "boolean") return input;
+    if (typeof input === "number" && Number.isFinite(input)) return input;
+    return invalid();
+  }
+  function project(input, shape) {
+    if (input == null || typeof input !== "object") return scalar(input);
+    if (types2.isProxy(input) || Array.isArray(input)) invalid();
+    const output = /* @__PURE__ */ Object.create(null);
+    const keys2 = shape === "envelope" ? ["toolName", "name"] : shape === "tool" ? ["name"] : shape === "args" ? argumentKeys : replacementKeys;
+    for (const key3 of keys2) {
+      const field = dataProperty(input, key3);
+      if (field !== void 0) output[key3] = scalar(field);
+    }
+    if (shape === "envelope") {
+      for (const key3 of ["params", "args", "arguments", "tool"]) {
+        const field = dataProperty(input, key3);
+        if (field !== void 0)
+          output[key3] = project(field, key3 === "tool" ? "tool" : "args");
+      }
+    }
+    if (shape === "args") {
+      const edits = dataProperty(input, "edits");
+      if (edits !== void 0) {
+        if (edits !== null && typeof edits === "object" && types2.isProxy(edits))
+          invalid();
+        if (Array.isArray(edits)) {
+          const length = dataProperty(edits, "length");
+          if (typeof length !== "number" || !Number.isInteger(length) || length < 0 || length > maxEditSlots)
+            invalid();
+          const entries = [];
+          for (let index2 = 0; index2 < length; index2++) {
+            entries.push(project(dataProperty(edits, String(index2)), "edit"));
+          }
+          output.edits = entries;
+        } else {
+          output.edits = scalar(edits);
+        }
+      }
+    }
+    return output;
   }
+  return project(value, "envelope");
 }
 
 // src-ts/memory/classifier.ts
@@ -43104,6 +43264,7 @@ async function guardMemoryWrite(input) {
     endpoint,
     verifyPubKey,
     orgName,
+    chainOpts,
     threshold,
     patterns,
     toolNames,
@@ -43111,7 +43272,22 @@ async function guardMemoryWrite(input) {
     debug: debug2 = false,
     logger: logger2
   } = input;
-  const memEntry = classifyMemoryWrite(event, ctx, { patterns, toolNames });
+  let memEntry;
+  try {
+    memEntry = classifyMemoryWrite(event, ctx, { patterns, toolNames });
+  } catch (err) {
+    const why = err instanceof Error ? err.message : String(err);
+    logger2?.warn?.("[atbash] memory classifier refused this tool call's input", { reason: why });
+    if (!enforce) return { handled: false };
+    return {
+      handled: true,
+      decision: {
+        allow: false,
+        block: true,
+        reason: `Memory protection could not read this tool call (${why}); blocked because it could not be checked.`
+      }
+    };
+  }
   if (debug2) emitDebugProbe(event, ctx, memEntry, logger2);
   if (!memEntry) return { handled: false };
   let scanResult;
@@ -43145,23 +43321,41 @@ async function guardMemoryWrite(input) {
       committed: false
     };
   }
+  if (scanResult.verdict !== "green" && scanResult.verdict !== "yellow") {
+    const reason = "Memory scan returned an unrecognized verdict.";
+    return {
+      handled: true,
+      decision: enforce ? { allow: false, block: true, reason } : { allow: true, reason },
+      scanResult,
+      committed: false
+    };
+  }
   const filePath = path3.basename(memEntry.key);
-  commitMemoryVersion(memEntry.value, auth, {
-    score: scanResult.score,
-    filePath,
-    orgName,
-    endpoint,
-    verifyPubKey
-  }).catch((err) => {
+  try {
+    await commitMemoryVersion(memEntry.value, auth, {
+      score: scanResult.score,
+      filePath,
+      orgName,
+      endpoint,
+      verifyPubKey,
+      chainOpts
+    });
+  } catch (err) {
     const reason = err instanceof Error ? err.message : String(err);
     logger2?.warn?.("[atbash] memory commit to chain failed", {
       path: memEntry.key,
       filePath,
       reason
     });
-  });
+    return {
+      handled: true,
+      decision: enforce ? { allow: false, block: true, reason: `Memory commit failed: ${reason}` } : { allow: true, reason: `Memory commit failed: ${reason}` },
+      scanResult,
+      committed: false
+    };
+  }
   logger2?.info?.(
-    scanResult.verdict === "yellow" ? "[atbash] memory HOLD" : "[atbash] memory ALLOW",
+    scanResult.verdict === "yellow" ? "[atbash] memory ALLOW (yellow, low score)" : "[atbash] memory ALLOW",
     {
       path: memEntry.key,
       filePath,
@@ -43194,7 +43388,7 @@ async function syncLocalMemory(auth, pointer, opts = {}) {
   if (withinTtl) {
     return { drifted: false, checked: false, pointer };
   }
-  const currentId = await getActiveMemoryId(auth, opts.chainOpts);
+  const currentId = await getActiveMemoryId(auth, opts.chainOpts, opts.filePath);
   const nextPointer = { activeId: currentId, checkedAt: now };
   if (currentId === pointer.activeId) {
     return { drifted: false, checked: true, pointer: nextPointer };
@@ -43276,13 +43470,16 @@ function formatMeta(meta) {
 }
 function createFileLogger(filePath, upstream) {
   let queue = Promise.resolve();
+  let writeError;
   async function ensureDir() {
     await fs2.mkdir(path5.dirname(filePath), { recursive: true });
   }
   function append(level, message, meta) {
     const line = `${(/* @__PURE__ */ new Date()).toISOString()} [${level}] ${message}${formatMeta(meta)}
 `;
-    queue = queue.then(ensureDir).then(() => fs2.appendFile(filePath, line, "utf8")).catch(() => {
+    queue = queue.then(ensureDir).then(() => fs2.appendFile(filePath, line, "utf8")).catch((error4) => {
+      writeError = error4 instanceof Error ? error4 : new Error(String(error4));
+      upstream?.warn("[atbash] plugin log write failed", { error: writeError.message });
     });
   }
   return {
@@ -43293,6 +43490,10 @@ function createFileLogger(filePath, upstream) {
     warn(message, meta) {
       upstream?.warn(message, meta ?? {});
       append("warn", message, meta);
+    },
+    async flush() {
+      await queue;
+      if (writeError) throw writeError;
     }
   };
 }
@@ -43382,7 +43583,15 @@ var MemoryGuardManager = class {
           orgName: this.opts.orgName
         });
         const resolved = await atbash.resolveChainForOrg(this.opts.orgName);
-        const chainOpts = { ...this.opts.chainOpts, network: resolved.network };
+        if (!await atbash.checkAgentExists(this.agentPubkeyHex, { network: resolved.network })) {
+          throw new Error(`agent is not registered on the resolved ${resolved.network} chain`);
+        }
+        const chainOpts = {
+          ...this.opts.chainOpts,
+          network: resolved.network,
+          blockchainRid: resolved.blockchainRid,
+          nodeUrls: this.opts.chainOpts?.nodeUrls ?? resolved.nodeUrls
+        };
         this._resolvedChainOpts = chainOpts;
         this.logger.info(
           `[atbash] resolved org \u2192 chain \u2014 org=${this.opts.orgName} network=${resolved.network}`
@@ -43391,9 +43600,9 @@ var MemoryGuardManager = class {
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         this.logger.warn(
-          `[atbash] org \u2192 chain resolution failed (falling back to SDK default): ${msg}`
+          `[atbash] org \u2192 chain resolution failed (memory read will be blocked): ${msg}`
         );
-        return this.opts.chainOpts;
+        throw err;
       } finally {
         this._resolveChainInflight = void 0;
       }
@@ -43412,13 +43621,18 @@ var MemoryGuardManager = class {
       const result = await syncLocalMemory(this.opts.auth, seed, {
         ttlMs: 0,
         force: true,
-        chainOpts
+        chainOpts,
+        filePath: path6.basename(this.memoryFilePath)
       });
       if (!result.drifted && result.pointer.activeId == null) {
         this.logger.info(
           `[atbash] no active memory on chain for agent=${this.agentPubkeyHex.slice(0, 16)}\u2026 org=${this.opts.orgName ?? "(none)"} \u2014 either the agent isn't registered on this chain or hasn't written any memory. Sync will remain a no-op until a write lands.`
         );
       } else if (result.drifted && result.current) {
+        if (result.current.filePath !== path6.basename(this.memoryFilePath) || result.current.isActive !== true || result.current.decryptError) {
+          this.logger.warn("[atbash] boot sync REFUSED mismatched memory version");
+          return;
+        }
         if (result.current.score < this.rollbackMinScore) {
           this.logger.warn(
             `[atbash] boot sync REFUSED refresh \u2014 id=${result.current.id} score=${result.current.score} below threshold ${this.rollbackMinScore}. Leaving MEMORY.md and pointer untouched; next memory read will be blocked.`
@@ -43432,7 +43646,8 @@ var MemoryGuardManager = class {
           await this.writeMemoryAtomic(result.current.content);
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
-          this.logger.warn("[atbash] boot sync write failed (serving whatever's on disk)", { error: msg });
+          this.logger.warn("[atbash] boot sync write failed; pointer remains unchanged", { error: msg });
+          return;
         }
       }
       await this.pointerStore.set(this.agentPubkeyHex, result.pointer);
@@ -43446,16 +43661,30 @@ var MemoryGuardManager = class {
   }
   /**
    * Returns a `HookDecision` when the guard reached a decision about this event.
-   * Returns `null` when it did not — either the event isn't memory-related, or it
-   * is but the guard could not check it. In both cases the host falls through to
-   * its own audit.
+   * Returns `null` for non-memory events, other files this manager does not
+   * own, or unverified observe-mode reads. An enforced read of the managed
+   * file blocks when verification cannot complete.
    *
    * A returned decision carries `audited` (see `HookDecision`). Only
    * `{ allow: true, audited: true }` means "checked and cleared"; anything else
    * that allows is a call the host still needs to judge.
    */
   async handleBeforeToolCall(event, ctx) {
-    if (classifyMemoryRead(event, ctx, this.opts.memoryReadClassifier)) {
+    let isMemoryRead;
+    try {
+      isMemoryRead = classifyMemoryRead(event, ctx, this.opts.memoryReadClassifier);
+    } catch (err) {
+      const why = err instanceof Error ? err.message : String(err);
+      this.logger.warn("[atbash] memory classifier refused this tool call's input", { reason: why });
+      if (!this.enforce) return null;
+      return {
+        allow: false,
+        block: true,
+        blockReason: `Memory protection could not read this tool call (${why}); blocked because it could not be checked.`,
+        audited: true
+      };
+    }
+    if (isMemoryRead) {
       this.logger.info("[atbash] memory read intercepted \u2014 running sync check");
       return await this.handleMemoryRead(event, ctx);
     }
@@ -43470,6 +43699,7 @@ var MemoryGuardManager = class {
       endpoint: this.opts.judgeEndpoint,
       verifyPubKey: this.opts.judgeVerifyPubKey,
       orgName: this.opts.orgName,
+      chainOpts: this.opts.chainOpts,
       patterns: this.opts.memoryPathPatterns,
       toolNames: this.opts.memoryWriteToolNames,
       enforce: this.enforce,
@@ -43514,6 +43744,14 @@ var MemoryGuardManager = class {
         reason: `memory scan returned ${sr2.verdict} but this guard is not enforcing it`
       };
     }
+    if (guard.committed !== true) {
+      return {
+        allow: true,
+        audited: false,
+        verdict: sr2.verdict,
+        reason: "memory scan passed but chain commit did not confirm"
+      };
+    }
     return { allow: true, audited: true, verdict: sr2.verdict };
   }
   /**
@@ -43548,62 +43786,73 @@ var MemoryGuardManager = class {
     return found.every((p) => path6.resolve(p) === managed);
   }
   async handleMemoryRead(event, ctx) {
+    if (!this.vouchesForTarget(event, ctx)) return null;
     const pointer = await this.pointerStore.get(this.agentPubkeyHex);
     let result;
+    let chainOpts;
     try {
-      const chainOpts = await this.resolveChainOpts();
+      chainOpts = await this.resolveChainOpts();
       result = await syncLocalMemory(this.opts.auth, pointer, {
         ttlMs: this.ttlMs,
-        chainOpts
+        force: this.enforce,
+        chainOpts,
+        filePath: path6.basename(this.memoryFilePath)
       });
     } catch (err) {
       if (err instanceof MemoryIntegrityError) {
         const reason = `Memory integrity check failed on id ${err.id} \u2014 read blocked.`;
         this.logger.warn("[atbash] MEMORY INTEGRITY FAILURE", { id: err.id, error: err.message });
-        if (!this.enforce) return null;
-        return { block: true, blockReason: reason, allow: false, reason, audited: true };
+        return this.unverifiedRead(reason);
       }
       const msg = err instanceof Error ? err.message : String(err);
-      this.logger.warn("[atbash] memory sync failed (serving local copy)", { error: msg });
-      return null;
+      this.logger.warn("[atbash] memory sync failed", { error: msg });
+      return this.unverifiedRead(`Memory chain sync failed: ${msg}`);
     }
-    let onDiskIsCurrent = result.checked;
-    if (result.drifted) {
-      const fresh = result.current;
-      if (fresh) {
-        if (fresh.score < this.rollbackMinScore) {
-          const reason = `Rolled-back memory version #${fresh.id} scored ${fresh.score} (below threshold ${this.rollbackMinScore}) \u2014 read blocked.`;
-          this.logger.warn("[atbash] blocking read on low-score rollback", { id: fresh.id, score: fresh.score });
-          if (!this.enforce) return null;
-          return { block: true, blockReason: reason, allow: false, reason, audited: true };
-        }
-        this.logger.info("[atbash] memory drift detected \u2014 refreshing local file", {
-          id: fresh.id,
-          score: fresh.score
-        });
-        try {
-          await this.writeMemoryAtomic(fresh.content);
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          this.logger.warn("[atbash] failed to write refreshed memory (serving old)", { error: msg });
-          onDiskIsCurrent = false;
-        }
-      } else {
-        this.logger.info("[atbash] active memory removed on chain", { pubkey: this.agentPubkeyHex });
-        onDiskIsCurrent = false;
-      }
+    if (!result.checked) return this.unverifiedRead("Memory chain state was not checked.");
+    const activeId = result.pointer.activeId;
+    if (activeId === null) {
+      return this.unverifiedRead("No active chain version exists for the managed memory file.");
     }
-    if (onDiskIsCurrent) {
-      await this.pointerStore.set(this.agentPubkeyHex, result.pointer);
-    } else {
-      this.logger.warn(
-        "[atbash] not advancing memory pointer \u2014 local file is stale or revoked; reads stay unaudited until it is refreshed"
-      );
+    let active;
+    try {
+      active = result.drifted ? result.current : await getMemoryById(activeId, this.opts.auth, chainOpts);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.logger.warn("[atbash] active memory row could not be verified", { error: msg });
+      return this.unverifiedRead(`Memory version could not be verified: ${msg}`);
     }
-    if (!onDiskIsCurrent) return null;
-    if (!this.vouchesForTarget(event, ctx)) return null;
+    const filePath = path6.basename(this.memoryFilePath);
+    if (!active || active.id !== activeId || active.filePath !== filePath || active.isActive !== true || active.decryptError) {
+      return this.unverifiedRead("Active memory version does not match the managed file.");
+    }
+    if (active.score < this.rollbackMinScore) {
+      return this.unverifiedRead(`Memory version #${active.id} is below the minimum safety score.`);
+    }
+    try {
+      if (result.drifted) {
+        this.logger.info("[atbash] memory drift detected \u2014 refreshing local file", { id: active.id });
+        await this.writeMemoryAtomic(active.content);
+      }
+      const onDisk = await fs3.readFile(this.memoryFilePath, "utf8");
+      if (onDisk !== active.content) {
+        return this.unverifiedRead("Local memory bytes do not match the active chain version.");
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.logger.warn("[atbash] managed memory file could not be verified", { error: msg });
+      return this.unverifiedRead(`Managed memory file could not be verified: ${msg}`);
+    }
+    await this.pointerStore.set(this.agentPubkeyHex, result.pointer);
     return { allow: true, audited: true };
   }
+  /** Complete queued audit-log writes before a host shuts down or removes its workspace. */
+  async flushLogs() {
+    await this.logger.flush();
+  }
+  unverifiedRead(reason) {
+    if (!this.enforce) return null;
+    return { block: true, blockReason: reason, allow: false, reason, audited: true };
+  }
   async writeMemoryAtomic(content) {
     await fs3.mkdir(path6.dirname(this.memoryFilePath), { recursive: true });
     const tmp = `${this.memoryFilePath}.${process.pid}.tmp`;