@agentvault/claude-bridge 0.7.6 → 0.7.8

package/dist/index.js

@@ -453,12 +453,12 @@ import { join as join11 } from "node:path";
 // ../plugin/dist/index.js
 import * as nc from "node:crypto";
 import { chmod, mkdir, writeFile } from "node:fs/promises";
-import { readFile, rm } from "node:fs/promises";
+import { readdir, readFile, rename, rm } from "node:fs/promises";
 import { join } from "node:path";
-import { readFile as readFile2, rename, rm as rm2 } from "node:fs/promises";
+import { readFile as readFile2, rename as rename2, rm as rm2 } from "node:fs/promises";
 import { join as join2 } from "node:path";
 import { Readable } from "node:stream";
-import { readdir, readFile as readFile3, writeFile as writeFile2, rename as rename2, stat, unlink, mkdir as mkdir2 } from "node:fs/promises";
+import { readdir as readdir2, readFile as readFile3, writeFile as writeFile2, rename as rename3, stat, unlink, mkdir as mkdir2 } from "node:fs/promises";
 import { join as join3 } from "node:path";
 import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
@@ -53073,8 +53073,8 @@ var init_dhkem = __esm2({
       async deserializePrivateKey(key) {
         return await this._prim.deserializePrivateKey(toArrayBuffer(key));
       }
-      async importKey(format, key, isPublic = true) {
-        return await this._prim.importKey(format, key, isPublic);
+      async importKey(format2, key, isPublic = true) {
+        return await this._prim.importKey(format2, key, isPublic);
       }
       async generateKeyPair() {
         return await this._prim.generateKeyPair();
@@ -53717,10 +53717,10 @@ var init_ec = __esm2({
           throw new DeserializeError(e7);
         }
       }
-      async importKey(format, key, isPublic) {
+      async importKey(format2, key, isPublic) {
         await this._setup();
         try {
-          if (format === "raw") {
+          if (format2 === "raw") {
             return await this._importRawKey(key, isPublic);
           }
           if (key instanceof ArrayBuffer) {
@@ -55107,10 +55107,10 @@ var init_x25519 = __esm2({
           throw new DeserializeError(e7);
         }
       }
-      async importKey(format, key, isPublic) {
+      async importKey(format2, key, isPublic) {
         await this._setup();
         try {
-          if (format === "raw") {
+          if (format2 === "raw") {
             return await this._importRawKey(key, isPublic);
           }
           if (key instanceof ArrayBuffer) {
@@ -60045,10 +60045,10 @@ function _splitEndoScalar(k2, basis, n22) {
   }
   return { k1neg, k1: k12, k2neg, k2: k22 };
 }
-function validateSigFormat(format) {
-  if (!["compact", "recovered", "der"].includes(format))
+function validateSigFormat(format2) {
+  if (!["compact", "recovered", "der"].includes(format2))
     throw new Error('Signature format must be "compact", "recovered", or "der"');
-  return format;
+  return format2;
 }
 function validateSigOpts(opts, def) {
   const optsn = {};
@@ -60736,11 +60736,11 @@ function ecdsa(Point, hash22, ecdsaOpts = {}) {
       throw new Error(`invalid signature ${title}: out of range 1..Point.Fn.ORDER`);
     return num;
   }
-  function validateSigLength(bytes, format) {
-    validateSigFormat(format);
+  function validateSigLength(bytes, format2) {
+    validateSigFormat(format2);
     const size = lengths.signature;
-    const sizer = format === "compact" ? size : format === "recovered" ? size + 1 : void 0;
-    return _abytes2(bytes, sizer, `${format} signature`);
+    const sizer = format2 === "compact" ? size : format2 === "recovered" ? size + 1 : void 0;
+    return _abytes2(bytes, sizer, `${format2} signature`);
   }
   class Signature {
     constructor(r22, s22, recovery) {
@@ -60750,16 +60750,16 @@ function ecdsa(Point, hash22, ecdsaOpts = {}) {
         this.recovery = recovery;
       Object.freeze(this);
     }
-    static fromBytes(bytes, format = defaultSigOpts_format) {
-      validateSigLength(bytes, format);
+    static fromBytes(bytes, format2 = defaultSigOpts_format) {
+      validateSigLength(bytes, format2);
       let recid;
-      if (format === "der") {
+      if (format2 === "der") {
         const { r: r32, s: s32 } = DER.toSig(_abytes2(bytes));
         return new Signature(r32, s32);
       }
-      if (format === "recovered") {
+      if (format2 === "recovered") {
         recid = bytes[0];
-        format = "compact";
+        format2 = "compact";
         bytes = bytes.subarray(1);
       }
       const L22 = Fn3.BYTES;
@@ -60767,8 +60767,8 @@ function ecdsa(Point, hash22, ecdsaOpts = {}) {
       const s22 = bytes.subarray(L22, L22 * 2);
       return new Signature(Fn3.fromBytes(r22), Fn3.fromBytes(s22), recid);
     }
-    static fromHex(hex32, format) {
-      return this.fromBytes(hexToBytes4(hex32), format);
+    static fromHex(hex32, format2) {
+      return this.fromBytes(hexToBytes4(hex32), format2);
     }
     addRecoveryBit(recovery) {
       return new Signature(this.r, this.s, recovery);
@@ -60800,21 +60800,21 @@ function ecdsa(Point, hash22, ecdsaOpts = {}) {
     hasHighS() {
       return isBiggerThanHalfOrder(this.s);
     }
-    toBytes(format = defaultSigOpts_format) {
-      validateSigFormat(format);
-      if (format === "der")
+    toBytes(format2 = defaultSigOpts_format) {
+      validateSigFormat(format2);
+      if (format2 === "der")
         return hexToBytes4(DER.hexFromSig(this));
       const r22 = Fn3.toBytes(this.r);
       const s22 = Fn3.toBytes(this.s);
-      if (format === "recovered") {
+      if (format2 === "recovered") {
         if (this.recovery == null)
           throw new Error("recovery bit must be present");
         return concatBytes2(Uint8Array.of(this.recovery), r22, s22);
       }
       return concatBytes2(r22, s22);
     }
-    toHex(format) {
-      return bytesToHex4(this.toBytes(format));
+    toHex(format2) {
+      return bytesToHex4(this.toBytes(format2));
     }
     // TODO: remove
     assertValidity() {
@@ -60931,12 +60931,12 @@ function ecdsa(Point, hash22, ecdsaOpts = {}) {
     return sig;
   }
   function verify(signature, message, publicKey, opts = {}) {
-    const { lowS, prehash, format } = validateSigOpts(opts, defaultSigOpts);
+    const { lowS, prehash, format: format2 } = validateSigOpts(opts, defaultSigOpts);
     publicKey = ensureBytes("publicKey", publicKey);
     message = validateMsgAndHash(ensureBytes("message", message), prehash);
     if ("strict" in opts)
       throw new Error("options.strict was renamed to lowS");
-    const sig = format === void 0 ? tryParsingSig(signature) : Signature.fromBytes(ensureBytes("sig", signature), format);
+    const sig = format2 === void 0 ? tryParsingSig(signature) : Signature.fromBytes(ensureBytes("sig", signature), format2);
     if (sig === false)
       return false;
     try {
@@ -63991,7 +63991,7 @@ async function backupState(dataDir) {
   try {
     const data = await readFile2(src, "utf-8");
     await writeSecureFile(tmp, data);
-    await rename(tmp, bak);
+    await rename2(tmp, bak);
   } catch {
   }
 }
@@ -64126,19 +64126,30 @@ var init_transport2 = __esm2({
 });
 var openclaw_compat_exports = {};
 __export2(openclaw_compat_exports, {
+  AGENT_EVENT_CANDIDATES: () => AGENT_EVENT_CANDIDATES,
+  HEARTBEAT_CANDIDATES: () => HEARTBEAT_CANDIDATES,
+  TRANSCRIPT_CANDIDATES: () => TRANSCRIPT_CANDIDATES,
+  _resetCompatCacheForTest: () => _resetCompatCacheForTest,
   onAgentEvent: () => onAgentEvent,
   onSessionTranscriptUpdate: () => onSessionTranscriptUpdate,
-  requestHeartbeatNow: () => requestHeartbeatNow
+  requestHeartbeatNow: () => requestHeartbeatNow,
+  resolveSdkFn: () => resolveSdkFn
 });
-async function requestHeartbeatNow(opts) {
-  if (_heartbeatFn === null) {
+async function resolveSdkFn(candidates, importer = defaultImporter) {
+  for (const { specifier, symbol: symbol22 } of candidates) {
     try {
-      const mod4 = await import("openclaw/dist/plugin-sdk/infra/heartbeat-wake.js");
-      _heartbeatFn = mod4.requestHeartbeatNow ?? mod4.default?.requestHeartbeatNow ?? false;
+      const mod4 = await importer(specifier);
+      const found = mod4?.[symbol22] ?? mod4?.default?.[symbol22];
+      if (typeof found === "function") return found;
     } catch {
-      _heartbeatFn = false;
     }
   }
+  return false;
+}
+async function requestHeartbeatNow(opts) {
+  if (_heartbeatFn === null) {
+    _heartbeatFn = await resolveSdkFn(HEARTBEAT_CANDIDATES);
+  }
   if (typeof _heartbeatFn === "function") {
     try {
       await _heartbeatFn(opts);
@@ -64151,12 +64162,7 @@ async function requestHeartbeatNow(opts) {
 }
 async function onAgentEvent(callback) {
   if (_agentEventFn === null) {
-    try {
-      const mod4 = await import("openclaw/dist/plugin-sdk/infra/agent-events.js");
-      _agentEventFn = mod4.onAgentEvent ?? mod4.default?.onAgentEvent ?? false;
-    } catch {
-      _agentEventFn = false;
-    }
+    _agentEventFn = await resolveSdkFn(AGENT_EVENT_CANDIDATES);
   }
   if (typeof _agentEventFn === "function") {
     try {
@@ -64171,12 +64177,7 @@ async function onAgentEvent(callback) {
 }
 async function onSessionTranscriptUpdate(callback) {
   if (_transcriptFn === null) {
-    try {
-      const mod4 = await import("openclaw/dist/plugin-sdk/sessions/transcript-events.js");
-      _transcriptFn = mod4.onSessionTranscriptUpdate ?? mod4.default?.onSessionTranscriptUpdate ?? false;
-    } catch {
-      _transcriptFn = false;
-    }
+    _transcriptFn = await resolveSdkFn(TRANSCRIPT_CANDIDATES);
   }
   if (typeof _transcriptFn === "function") {
     try {
@@ -64189,12 +64190,45 @@ async function onSessionTranscriptUpdate(callback) {
   return () => {
   };
 }
+function _resetCompatCacheForTest() {
+  _heartbeatFn = null;
+  _agentEventFn = null;
+  _transcriptFn = null;
+}
+var defaultImporter;
+var HEARTBEAT_CANDIDATES;
+var AGENT_EVENT_CANDIDATES;
+var TRANSCRIPT_CANDIDATES;
 var _heartbeatFn;
 var _agentEventFn;
 var _transcriptFn;
 var init_openclaw_compat = __esm2({
   "src/openclaw-compat.ts"() {
     "use strict";
+    defaultImporter = (specifier) => import(
+      /* @vite-ignore */
+      specifier
+    );
+    HEARTBEAT_CANDIDATES = [
+      // 2026.7.x — exported subpath, and the symbol lost its `Now` suffix.
+      { specifier: "openclaw/plugin-sdk/heartbeat-runtime", symbol: "requestHeartbeat" },
+      // <=2026.6.x — deep dist path, original name.
+      { specifier: "openclaw/dist/plugin-sdk/infra/heartbeat-wake.js", symbol: "requestHeartbeatNow" }
+    ];
+    AGENT_EVENT_CANDIDATES = [
+      { specifier: "openclaw/plugin-sdk/agent-harness", symbol: "onAgentEvent" },
+      { specifier: "openclaw/dist/plugin-sdk/infra/agent-events.js", symbol: "onAgentEvent" }
+    ];
+    TRANSCRIPT_CANDIDATES = [
+      {
+        specifier: "openclaw/plugin-sdk/memory-core-host-engine-foundation",
+        symbol: "onSessionTranscriptUpdate"
+      },
+      {
+        specifier: "openclaw/dist/plugin-sdk/sessions/transcript-events.js",
+        symbol: "onSessionTranscriptUpdate"
+      }
+    ];
     _heartbeatFn = null;
     _agentEventFn = null;
     _transcriptFn = null;
@@ -64509,7 +64543,7 @@ async function handleWorkspaceUpload(data, workspaceDir) {
   const tempPath = join3(workspaceDir, `.tmp_${randomUUID()}_${data.filename}`);
   try {
     await writeFile2(tempPath, data.content, "utf-8");
-    await rename2(tempPath, targetPath);
+    await rename3(tempPath, targetPath);
   } catch (err) {
     try {
       await unlink(tempPath);
@@ -64526,7 +64560,7 @@ async function handleWorkspaceUpload(data, workspaceDir) {
 }
 async function handleWorkspaceList(workspaceDir) {
   try {
-    const entries = await readdir(workspaceDir);
+    const entries = await readdir2(workspaceDir);
     const files = [];
     for (const entry of entries) {
       if (!entry.endsWith(".md")) continue;
@@ -65687,7 +65721,7 @@ var init_channel = __esm2({
        */
       sendActivitySpan(spanData) {
         if (!this._ws || this._ws.readyState !== WebSocket2.OPEN) return;
-        const pluginVersion = true ? "0.23.18" : "0.0.0-dev";
+        const pluginVersion = true ? "0.23.19" : "0.0.0-dev";
         const agentName = this.config.agentName ?? "Agent";
         const resource = {
           "service.name": "agentvault-agent",
@@ -67552,7 +67586,7 @@ var init_channel = __esm2({
                 agentVersion: this.config.agentVersion ?? "0.0.0",
                 // __AV_VERSION__ is injected by esbuild from package.json at build time.
                 // Falls back to "0.0.0-dev" in non-bundled contexts (tests).
-                pluginVersion: true ? "0.23.18" : "0.0.0-dev"
+                pluginVersion: true ? "0.23.19" : "0.0.0-dev"
               });
               this._telemetryReporter.startAutoFlush(3e4);
             }
@@ -67875,7 +67909,7 @@ var init_channel = __esm2({
                     agentVersion: this.config.agentVersion ?? "0.0.0",
                     // __AV_VERSION__ is injected by esbuild from package.json at build time.
                     // Falls back to "0.0.0-dev" in non-bundled contexts (tests).
-                    pluginVersion: true ? "0.23.18" : "0.0.0-dev"
+                    pluginVersion: true ? "0.23.19" : "0.0.0-dev"
                   });
                   this._telemetryReporter.startAutoFlush(3e4);
                 }
@@ -71697,6 +71731,11 @@ var init_tool_audit = __esm2({
     "use strict";
   }
 });
+var init_harness_compat = __esm2({
+  "src/harness-compat.ts"() {
+    "use strict";
+  }
+});
 var isUsingManagedRoutes;
 var init_openclaw_entry = __esm2({
   "src/openclaw-entry.ts"() {
@@ -71707,6 +71746,7 @@ var init_openclaw_entry = __esm2({
     init_openclaw_compat();
     init_lifecycle();
     init_tool_audit();
+    init_harness_compat();
     init_types();
     isUsingManagedRoutes = false;
   }
@@ -80824,13 +80864,13 @@ function _stringbool(Classes, _params) {
   return codec22;
 }
 // @__NO_SIDE_EFFECTS__
-function _stringFormat(Class22, format, fnOrRegex, _params = {}) {
+function _stringFormat(Class22, format2, fnOrRegex, _params = {}) {
   const params = normalizeParams(_params);
   const def = {
     ...normalizeParams(_params),
     check: "string_format",
     type: "string",
-    format,
+    format: format2,
     fn: typeof fnOrRegex === "function" ? fnOrRegex : (val) => fnOrRegex.test(val),
     ...params
   };
@@ -81295,16 +81335,16 @@ var init_json_schema_processors = __esm2({
     stringProcessor = (schema, ctx, _json, _params) => {
       const json22 = _json;
       json22.type = "string";
-      const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag;
+      const { minimum, maximum, format: format2, patterns, contentEncoding } = schema._zod.bag;
       if (typeof minimum === "number")
         json22.minLength = minimum;
       if (typeof maximum === "number")
         json22.maxLength = maximum;
-      if (format) {
-        json22.format = formatMap[format] ?? format;
+      if (format2) {
+        json22.format = formatMap[format2] ?? format2;
         if (json22.format === "")
           delete json22.format;
-        if (format === "time") {
+        if (format2 === "time") {
           delete json22.format;
         }
       }
@@ -81326,8 +81366,8 @@ var init_json_schema_processors = __esm2({
     };
     numberProcessor = (schema, ctx, _json, _params) => {
       const json22 = _json;
-      const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
-      if (typeof format === "string" && format.includes("int"))
+      const { minimum, maximum, format: format2, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
+      if (typeof format2 === "string" && format2.includes("int"))
         json22.type = "integer";
       else
         json22.type = "number";
@@ -82482,8 +82522,8 @@ function e1642(params) {
 function jwt(params) {
   return /* @__PURE__ */ _jwt(ZodJWT, params);
 }
-function stringFormat(format, fnOrRegex, _params = {}) {
-  return /* @__PURE__ */ _stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params);
+function stringFormat(format2, fnOrRegex, _params = {}) {
+  return /* @__PURE__ */ _stringFormat(ZodCustomStringFormat, format2, fnOrRegex, _params);
 }
 function hostname2(_params) {
   return /* @__PURE__ */ _stringFormat(ZodCustomStringFormat, "hostname", regexes_exports.hostname, _params);
@@ -82493,11 +82533,11 @@ function hex2(_params) {
 }
 function hash(alg, params) {
   const enc = params?.enc ?? "hex";
-  const format = `${alg}_${enc}`;
-  const regex = regexes_exports[format];
+  const format2 = `${alg}_${enc}`;
+  const regex = regexes_exports[format2];
   if (!regex)
-    throw new Error(`Unrecognized hash format: ${format}`);
-  return /* @__PURE__ */ _stringFormat(ZodCustomStringFormat, format, regex, params);
+    throw new Error(`Unrecognized hash format: ${format2}`);
+  return /* @__PURE__ */ _stringFormat(ZodCustomStringFormat, format2, regex, params);
 }
 function number2(params) {
   return /* @__PURE__ */ _number(ZodNumber2, params);
@@ -91980,10 +92020,10 @@ var require_core = __commonJS({
         return this;
       }
       // Add format
-      addFormat(name, format) {
-        if (typeof format == "string")
-          format = new RegExp(format);
-        this.formats[name] = format;
+      addFormat(name, format2) {
+        if (typeof format2 == "string")
+          format2 = new RegExp(format2);
+        this.formats[name] = format2;
         return this;
       }
       errorsText(errors = this.errors, { separator = ", ", dataVar = "data" } = {}) {
@@ -92101,9 +92141,9 @@ var require_core = __commonJS({
     }
     function addInitialFormats() {
       for (const name in this.opts.formats) {
-        const format = this.opts.formats[name];
-        if (format)
-          this.addFormat(name, format);
+        const format2 = this.opts.formats[name];
+        if (format2)
+          this.addFormat(name, format2);
       }
     }
     function addInitialKeywords(defs) {
@@ -93718,18 +93758,18 @@ var require_format = __commonJS({
           });
           const fDef = gen.const("fDef", (0, codegen_1._)`${fmts}[${schemaCode}]`);
           const fType = gen.let("fType");
-          const format = gen.let("format");
-          gen.if((0, codegen_1._)`typeof ${fDef} == "object" && !(${fDef} instanceof RegExp)`, () => gen.assign(fType, (0, codegen_1._)`${fDef}.type || "string"`).assign(format, (0, codegen_1._)`${fDef}.validate`), () => gen.assign(fType, (0, codegen_1._)`"string"`).assign(format, fDef));
+          const format2 = gen.let("format");
+          gen.if((0, codegen_1._)`typeof ${fDef} == "object" && !(${fDef} instanceof RegExp)`, () => gen.assign(fType, (0, codegen_1._)`${fDef}.type || "string"`).assign(format2, (0, codegen_1._)`${fDef}.validate`), () => gen.assign(fType, (0, codegen_1._)`"string"`).assign(format2, fDef));
           cxt.fail$data((0, codegen_1.or)(unknownFmt(), invalidFmt()));
           function unknownFmt() {
             if (opts.strictSchema === false)
               return codegen_1.nil;
-            return (0, codegen_1._)`${schemaCode} && !${format}`;
+            return (0, codegen_1._)`${schemaCode} && !${format2}`;
           }
           function invalidFmt() {
-            const callFormat = schemaEnv.$async ? (0, codegen_1._)`(${fDef}.async ? await ${format}(${data}) : ${format}(${data}))` : (0, codegen_1._)`${format}(${data})`;
-            const validData = (0, codegen_1._)`(typeof ${format} == "function" ? ${callFormat} : ${format}.test(${data}))`;
-            return (0, codegen_1._)`${format} && ${format} !== true && ${fType} === ${ruleType} && !${validData}`;
+            const callFormat = schemaEnv.$async ? (0, codegen_1._)`(${fDef}.async ? await ${format2}(${data}) : ${format2}(${data}))` : (0, codegen_1._)`${format2}(${data})`;
+            const validData = (0, codegen_1._)`(typeof ${format2} == "function" ? ${callFormat} : ${format2}.test(${data}))`;
+            return (0, codegen_1._)`${format2} && ${format2} !== true && ${fType} === ${ruleType} && !${validData}`;
           }
         }
         function validateFormat() {
@@ -93740,7 +93780,7 @@ var require_format = __commonJS({
           }
           if (formatDef === true)
             return;
-          const [fmtType, format, fmtRef] = getFormat(formatDef);
+          const [fmtType, format2, fmtRef] = getFormat(formatDef);
           if (fmtType === ruleType)
             cxt.pass(validCondition());
           function unknownFormat() {
@@ -93767,7 +93807,7 @@ var require_format = __commonJS({
                 throw new Error("async format in sync schema");
               return (0, codegen_1._)`await ${fmtRef}(${data})`;
             }
-            return typeof format == "function" ? (0, codegen_1._)`${fmtRef}(${data})` : (0, codegen_1._)`${fmtRef}.test(${data})`;
+            return typeof format2 == "function" ? (0, codegen_1._)`${fmtRef}(${data})` : (0, codegen_1._)`${fmtRef}.test(${data})`;
           }
         }
       }
@@ -93780,8 +93820,8 @@ var require_format2 = __commonJS({
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     var format_1 = require_format();
-    var format = [format_1.default];
-    exports.default = format;
+    var format2 = [format_1.default];
+    exports.default = format2;
   }
 });
 var require_metadata = __commonJS({
@@ -94407,17 +94447,17 @@ var require_limit = __commonJS({
           cxt.fail$data((0, codegen_1.or)((0, codegen_1._)`typeof ${fmt} != "object"`, (0, codegen_1._)`${fmt} instanceof RegExp`, (0, codegen_1._)`typeof ${fmt}.compare != "function"`, compareCode(fmt)));
         }
         function validateFormat() {
-          const format = fCxt.schema;
-          const fmtDef = self2.formats[format];
+          const format2 = fCxt.schema;
+          const fmtDef = self2.formats[format2];
           if (!fmtDef || fmtDef === true)
             return;
           if (typeof fmtDef != "object" || fmtDef instanceof RegExp || typeof fmtDef.compare != "function") {
-            throw new Error(`"${keyword}": format "${format}" does not define "compare" function`);
+            throw new Error(`"${keyword}": format "${format2}" does not define "compare" function`);
           }
           const fmt = gen.scopeValue("formats", {
-            key: format,
+            key: format2,
             ref: fmtDef,
-            code: opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(format)}` : void 0
+            code: opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(format2)}` : void 0
           });
           cxt.fail$data(compareCode(fmt));
         }
@@ -97758,7 +97798,7 @@ var init_index = __esm2({
     init_skill_invoker();
     await init_skill_telemetry();
     await init_policy_enforcer();
-    VERSION = true ? "0.23.18" : "0.0.0-dev";
+    VERSION = true ? "0.23.19" : "0.0.0-dev";
   }
 });
 await init_index();
@@ -119140,6 +119180,16 @@ function readDeviceId(dataDir) {
   );
 }
 
+// src/log.ts
+import { format } from "node:util";
+function stamp(message) {
+  const ts2 = (/* @__PURE__ */ new Date()).toISOString();
+  return message.split("\n").map((line) => `${ts2} ${line}`).join("\n");
+}
+function logLine(...args) {
+  console.error(stamp(format(...args)));
+}
+
 // src/worker-permission.ts
 var PATH_FIELDS = ["file_path", "path", "notebook_path"];
 function canonical(p2) {
@@ -119246,7 +119296,7 @@ function makeWorkerPreToolUseHook(opts) {
           }
         }
         if (verdict.deny) {
-          console.error(`[worker-gate] DENY ${toolName} \u2014 ${verdict.reason}`);
+          logLine(`[worker-gate] DENY ${toolName} \u2014 ${verdict.reason}`);
           return {
             hookSpecificOutput: {
               hookEventName: "PreToolUse",
@@ -119264,7 +119314,7 @@ function makeWorkerPermission(opts) {
   return async (toolName, input) => {
     const verdict = gateDecision(toolName, input, opts);
     if (verdict.deny) {
-      console.error(`[worker-gate] DENY ${toolName} \u2014 ${verdict.reason}`);
+      logLine(`[worker-gate] DENY ${toolName} \u2014 ${verdict.reason}`);
       return { behavior: "deny", message: verdict.reason };
     }
     return { behavior: "allow", updatedInput: input };
@@ -130162,13 +130212,13 @@ function _stringbool2(Classes, _params) {
   return codec3;
 }
 // @__NO_SIDE_EFFECTS__
-function _stringFormat2(Class3, format, fnOrRegex, _params = {}) {
+function _stringFormat2(Class3, format2, fnOrRegex, _params = {}) {
   const params = normalizeParams2(_params);
   const def = {
     ...normalizeParams2(_params),
     check: "string_format",
     type: "string",
-    format,
+    format: format2,
     fn: typeof fnOrRegex === "function" ? fnOrRegex : (val) => fnOrRegex.test(val),
     ...params
   };
@@ -130543,16 +130593,16 @@ var formatMap2 = {
 var stringProcessor2 = (schema, ctx, _json, _params) => {
   const json3 = _json;
   json3.type = "string";
-  const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag;
+  const { minimum, maximum, format: format2, patterns, contentEncoding } = schema._zod.bag;
   if (typeof minimum === "number")
     json3.minLength = minimum;
   if (typeof maximum === "number")
     json3.maxLength = maximum;
-  if (format) {
-    json3.format = formatMap2[format] ?? format;
+  if (format2) {
+    json3.format = formatMap2[format2] ?? format2;
     if (json3.format === "")
       delete json3.format;
-    if (format === "time") {
+    if (format2 === "time") {
       delete json3.format;
     }
   }
@@ -130574,8 +130624,8 @@ var stringProcessor2 = (schema, ctx, _json, _params) => {
 };
 var numberProcessor2 = (schema, ctx, _json, _params) => {
   const json3 = _json;
-  const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
-  if (typeof format === "string" && format.includes("int"))
+  const { minimum, maximum, format: format2, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
+  if (typeof format2 === "string" && format2.includes("int"))
     json3.type = "integer";
   else
     json3.type = "number";
@@ -131764,8 +131814,8 @@ var ZodCustomStringFormat2 = /* @__PURE__ */ $constructor2("ZodCustomStringForma
   $ZodCustomStringFormat2.init(inst, def);
   ZodStringFormat2.init(inst, def);
 });
-function stringFormat2(format, fnOrRegex, _params = {}) {
-  return _stringFormat2(ZodCustomStringFormat2, format, fnOrRegex, _params);
+function stringFormat2(format2, fnOrRegex, _params = {}) {
+  return _stringFormat2(ZodCustomStringFormat2, format2, fnOrRegex, _params);
 }
 function hostname5(_params) {
   return _stringFormat2(ZodCustomStringFormat2, "hostname", regexes_exports2.hostname, _params);
@@ -131775,11 +131825,11 @@ function hex4(_params) {
 }
 function hash2(alg, params) {
   const enc = params?.enc ?? "hex";
-  const format = `${alg}_${enc}`;
-  const regex = regexes_exports2[format];
+  const format2 = `${alg}_${enc}`;
+  const regex = regexes_exports2[format2];
   if (!regex)
-    throw new Error(`Unrecognized hash format: ${format}`);
-  return _stringFormat2(ZodCustomStringFormat2, format, regex, params);
+    throw new Error(`Unrecognized hash format: ${format2}`);
+  return _stringFormat2(ZodCustomStringFormat2, format2, regex, params);
 }
 var ZodNumber3 = /* @__PURE__ */ $constructor2("ZodNumber", (inst, def) => {
   $ZodNumber2.init(inst, def);
@@ -132755,52 +132805,52 @@ function convertBaseSchema(schema, ctx) {
     case "string": {
       let stringSchema = z4.string();
       if (schema.format) {
-        const format = schema.format;
-        if (format === "email") {
+        const format2 = schema.format;
+        if (format2 === "email") {
           stringSchema = stringSchema.check(z4.email());
-        } else if (format === "uri" || format === "uri-reference") {
+        } else if (format2 === "uri" || format2 === "uri-reference") {
           stringSchema = stringSchema.check(z4.url());
-        } else if (format === "uuid" || format === "guid") {
+        } else if (format2 === "uuid" || format2 === "guid") {
           stringSchema = stringSchema.check(z4.uuid());
-        } else if (format === "date-time") {
+        } else if (format2 === "date-time") {
           stringSchema = stringSchema.check(z4.iso.datetime());
-        } else if (format === "date") {
+        } else if (format2 === "date") {
           stringSchema = stringSchema.check(z4.iso.date());
-        } else if (format === "time") {
+        } else if (format2 === "time") {
           stringSchema = stringSchema.check(z4.iso.time());
-        } else if (format === "duration") {
+        } else if (format2 === "duration") {
           stringSchema = stringSchema.check(z4.iso.duration());
-        } else if (format === "ipv4") {
+        } else if (format2 === "ipv4") {
           stringSchema = stringSchema.check(z4.ipv4());
-        } else if (format === "ipv6") {
+        } else if (format2 === "ipv6") {
           stringSchema = stringSchema.check(z4.ipv6());
-        } else if (format === "mac") {
+        } else if (format2 === "mac") {
           stringSchema = stringSchema.check(z4.mac());
-        } else if (format === "cidr") {
+        } else if (format2 === "cidr") {
           stringSchema = stringSchema.check(z4.cidrv4());
-        } else if (format === "cidr-v6") {
+        } else if (format2 === "cidr-v6") {
           stringSchema = stringSchema.check(z4.cidrv6());
-        } else if (format === "base64") {
+        } else if (format2 === "base64") {
           stringSchema = stringSchema.check(z4.base64());
-        } else if (format === "base64url") {
+        } else if (format2 === "base64url") {
           stringSchema = stringSchema.check(z4.base64url());
-        } else if (format === "e164") {
+        } else if (format2 === "e164") {
           stringSchema = stringSchema.check(z4.e164());
-        } else if (format === "jwt") {
+        } else if (format2 === "jwt") {
           stringSchema = stringSchema.check(z4.jwt());
-        } else if (format === "emoji") {
+        } else if (format2 === "emoji") {
           stringSchema = stringSchema.check(z4.emoji());
-        } else if (format === "nanoid") {
+        } else if (format2 === "nanoid") {
           stringSchema = stringSchema.check(z4.nanoid());
-        } else if (format === "cuid") {
+        } else if (format2 === "cuid") {
           stringSchema = stringSchema.check(z4.cuid());
-        } else if (format === "cuid2") {
+        } else if (format2 === "cuid2") {
           stringSchema = stringSchema.check(z4.cuid2());
-        } else if (format === "ulid") {
+        } else if (format2 === "ulid") {
           stringSchema = stringSchema.check(z4.ulid());
-        } else if (format === "xid") {
+        } else if (format2 === "xid") {
           stringSchema = stringSchema.check(z4.xid());
-        } else if (format === "ksuid") {
+        } else if (format2 === "ksuid") {
           stringSchema = stringSchema.check(z4.ksuid());
         }
       }
@@ -133279,7 +133329,7 @@ var PersistentClaudeSession = class {
         });
       }
     };
-    console.error(
+    logLine(
       `[worker-gate] active \u2014 1:1 owner DM: FULL access, no allowlist, no workspace fence. Armed room: FULL access whenever "Remove all gates" is on (live, owner-controlled, off by default); otherwise allowlist, workspace=${this.opts.workspaceDir ?? "(none: file tools disabled)"}, bash=${this.opts.osIsolated ? "enabled (OS-isolated)" : "disabled"}`
     );
     return {
@@ -133320,7 +133370,19 @@ var PersistentClaudeSession = class {
     this.roomServer = _s({
       name: "room",
       version: "0.2.0",
-      tools: [makeRoomSayTool((text) => this.deliver(text))]
+      tools: [makeRoomSayTool((text) => this.deliver(text))],
+      // LOAD-BEARING for turn latency. The SDK defers MCP tools behind tool
+      // search by default, so the WORKER (which gets the full built-in toolset
+      // for owner DMs) could not see its own voice without first spending a
+      // model round-trip on `ToolSearch {"query":"select:mcp__room__say"}` —
+      // measured on 175 of 175 worker sessions, ~2-5s of a ~20s turn, for a tool
+      // already in `allowedTools`. The listener escaped it only by accident, via
+      // `tools: []`. Set on BOTH lanes so the listener stays correct if its
+      // toolset ever widens.
+      //
+      // NOT a permission change: room_say is already allowed on every session.
+      // This stops HIDING it, it does not grant it.
+      alwaysLoad: true
     });
     const sdkOptions = this.buildSdkOptions();
     const q10 = this.opts.queryImpl ? this.opts.queryImpl({
@@ -133346,7 +133408,7 @@ var PersistentClaudeSession = class {
             if (reply) {
               void reply(this.turnText);
             } else {
-              console.error(
+              logLine(
                 `[drop-probe] BLOCKED at result: composed ${this.turnText.length} chars, reply expected but activeReply unset \u2014 reply DROPPED`
               );
             }
@@ -133355,7 +133417,7 @@ var PersistentClaudeSession = class {
       }
     } finally {
       if (this.currentReplyExpected && !this.saidThisTurn && !this.sawResultThisTurn && this.turnText.trim()) {
-        console.error(
+        logLine(
           `[drop-probe] STREAM ENDED before result: composed ${this.turnText.length} chars, reply expected, said=false \u2014 reply DROPPED (no result event)`
         );
       }
@@ -133398,6 +133460,16 @@ var WorkerQueue = class {
       this.running = false;
     }
   }
+  /**
+   * What the worker had produced, when the session can report it. Read on BOTH the
+   * clean and the failing path: on a clean turn `said: false` with a non-zero
+   * `composedChars` is the "composed but could never ship it" signature (agent-
+   * authored room traffic, where `replyExpected` is false), which is otherwise
+   * indistinguishable from a turn that did nothing.
+   */
+  snapshotOf(session) {
+    return session?.snapshot?.();
+  }
   /** Best-effort trap emit. A broken sink must never break the queue. */
   emitIncident(rec) {
     try {
@@ -133429,10 +133501,23 @@ var WorkerQueue = class {
         }, this.deps.timeoutMs);
       });
       await Promise.race([session.start(), timeout]);
+      const okSnap = this.snapshotOf(session);
+      this.emitIncident({
+        at: new Date(startedAt).toISOString(),
+        outcome: "ok",
+        waitedMs,
+        ranMs: Date.now() - startedAt,
+        timeoutMs: this.deps.timeoutMs,
+        queueDepthAtEnqueue: entry.queueDepthAtEnqueue,
+        queueDepthAtStart,
+        instructionChars: task.instruction.length,
+        replyExpected: task.replyExpected,
+        ...okSnap ? { session: okSnap } : {}
+      });
     } catch (e7) {
       const err = e7;
       this.deps.log(`[worker-queue] task failed: ${err.message}`);
-      const snap = session?.snapshot?.();
+      const snap = this.snapshotOf(session);
       this.emitIncident({
         at: new Date(startedAt).toISOString(),
         outcome: timedOut ? "timeout" : "error",
@@ -133443,6 +133528,7 @@ var WorkerQueue = class {
         queueDepthAtEnqueue: entry.queueDepthAtEnqueue,
         queueDepthAtStart,
         instructionChars: task.instruction.length,
+        replyExpected: task.replyExpected,
         ...snap ? { session: snap } : {}
       });
       session?.abort();
@@ -133464,7 +133550,7 @@ function makeRouter(deps) {
       const replySink = reply ?? (() => {
       });
       const isOwnerDm = opts?.autoReplyOnText === true && opts?.armed === void 0 && deps.workAllowed();
-      const isArmedRoom = opts?.armed?.() === true && deps.workAllowed();
+      const isArmedRoom = opts?.armed?.() === true && deps.workAllowed() && opts?.replyExpected !== false;
       if (isOwnerDm) {
         deps.queue.enqueue({
           instruction: text,
@@ -134023,22 +134109,22 @@ async function main() {
   const cfg = loadConfig(process.env, process.argv.slice(2));
   const firstArg = process.argv.slice(2)[0];
   if (firstArg && !firstArg.startsWith("-") && firstArg === cfg.inviteToken) {
-    console.error(
+    logLine(
       "[bridge] warning: passing the invite token on the command line is visible to other local users via 'ps'. Prefer: AV_INVITE_TOKEN=\u2026 npx @agentvault/claude-bridge"
     );
   }
-  console.error(`[bridge] version: ${true ? "0.7.6" : "dev"}`);
-  console.error(`[bridge] data dir: ${cfg.dataDir} (${cfg.dataDirSource})`);
-  console.error(`[bridge] workspace: ${cfg.workspaceDir} \xB7 permissions: ${cfg.permissionMode} \xB7 enclave dir fenced`);
+  logLine(`[bridge] version: ${true ? "0.7.8" : "dev"}`);
+  logLine(`[bridge] data dir: ${cfg.dataDir} (${cfg.dataDirSource})`);
+  logLine(`[bridge] workspace: ${cfg.workspaceDir} \xB7 permissions: ${cfg.permissionMode} \xB7 enclave dir fenced`);
   if (cfg.armRoom) {
-    console.error(
+    logLine(
       `[bridge] ARMED ROOM ${cfg.roomFilter} \u2014 worker tools are enabled on this room's turns. The enclave key dir stays fenced; the workspace dir is ADVISORY (the SDK does not confine file ops to it \u2014 they root in $HOME). Blast radius = whatever this host/environment exposes.`
     );
-    console.error(
+    logLine(
       "[bridge] ARMED ROOM WARNING: this room contains agents you do not control. A room peer's message can drive your agent's tools. The directory is NOT a sandbox \u2014 run this bridge in an owner-provisioned confined environment (dedicated droplet / container / OS-user) with no connected accounts or ambient credentials. See the Slice 2 hardening guide."
     );
   } else {
-    console.error(
+    logLine(
       '[bridge] 1:1 owner DMs run with FULL tool access when "Allow tools" is on for this agent (dashboard switch, default off): any command, any file this user account can reach, network, skills and subagents \u2014 equivalent to a terminal on this machine, with no per-action prompt. Rooms are NOT affected: they stay say-only unless armed (AV_ARM_ROOM=1 with a pinned AV_ROOM_ID), and an armed room keeps the confined allowlist. Each tool-enabled turn runs in a fresh session seeded with only that one message, so room text cannot leak into a DM turn.'
     );
   }
@@ -134069,7 +134155,7 @@ async function main() {
     // per-message binding is what prevents a private 1:1 reply from leaking into a
     // room when room traffic arrives mid-compose.
     // Assistant reasoning that wasn't sent — log a short trace only.
-    onObserve: (text) => console.error(`[bridge] observed (${text.length} chars, not sent)`),
+    onObserve: (text) => logLine(`[bridge] observed (${text.length} chars, not sent)`),
     worker: false
   });
   const WORKER_MAX_TURNS = 20;
@@ -134078,7 +134164,7 @@ async function main() {
     makeSession: (task) => new PersistentClaudeSession({
       model: cfg.model,
       systemPrompt: agentSystemPrompt,
-      onObserve: (text) => console.error(`[worker] observed (${text.length} chars, not sent)`),
+      onObserve: (text) => logLine(`[worker] observed (${text.length} chars, not sent)`),
       worker: true,
       // Task 4: the hard backstop — no tool runs on any worker turn (owner DM or
       // armed room) unless Work is on. Read live per tool decision.
@@ -134101,7 +134187,7 @@ async function main() {
       deviceJwt
     }),
     timeoutMs: WORKER_TIMEOUT_MS,
-    log: (m6) => console.error(m6),
+    log: (m6) => logLine(m6),
     // TRAP (2026-07-25). The 07-24 five-minute silence was diagnosable only by
     // luck — the drop-trap happened to record a reply landing 300.016s after the
     // ack, and 300s is WORKER_TIMEOUT_MS exactly. Nothing recorded WHY the worker
@@ -134109,15 +134195,15 @@ async function main() {
     // Append-only JSONL beside the logs, plus one stamped console line so the
     // incident is visible in bridge.error.log at the moment it happens.
     onIncident: (rec) => {
-      console.error(
-        `[worker-trap] ${rec.at} ${rec.outcome} after ${rec.ranMs}ms (waited ${rec.waitedMs}ms behind ${rec.queueDepthAtEnqueue}, ${rec.queueDepthAtStart} still queued)` + (rec.session ? ` composed=${rec.session.composedChars} result=${rec.session.sawResult} said=${rec.session.said}` : "")
+      logLine(
+        `[worker-trap] ${rec.at} ${rec.outcome} after ${rec.ranMs}ms (waited ${rec.waitedMs}ms behind ${rec.queueDepthAtEnqueue}, ${rec.queueDepthAtStart} still queued) replyExpected=${rec.replyExpected}` + (rec.session ? ` composed=${rec.session.composedChars} result=${rec.session.sawResult} said=${rec.session.said}` : "")
       );
       try {
         const dir = join11(cfg.dataDir, "logs");
         mkdirSync6(dir, { recursive: true });
         appendFileSync2(join11(dir, "worker-incidents.jsonl"), JSON.stringify(rec) + "\n");
       } catch (err) {
-        console.error(`[worker-trap] could not persist incident: ${err.message}`);
+        logLine(`[worker-trap] could not persist incident: ${err.message}`);
       }
     }
   });
@@ -134129,7 +134215,7 @@ async function main() {
     {
       roomFilter: cfg.roomFilter,
       armRoom: cfg.armRoom,
-      log: (m6) => console.error("[bridge] " + m6),
+      log: (m6) => logLine("[bridge] " + m6),
       // Slice 2 Plan C (T11): live arm/disarm + local-approval poll + heartbeat.
       workspaceDir: cfg.workspaceDir,
       dataDir: cfg.dataDir,
@@ -134145,21 +134231,21 @@ async function main() {
     }
   );
   attachLifecycle2(channel, {
-    log: (m6) => console.error("[bridge] " + m6)
+    log: (m6) => logLine("[bridge] " + m6)
   });
-  channel.on("state", (s10) => console.error(`[bridge] channel state: ${JSON.stringify(s10)}`));
+  channel.on("state", (s10) => logLine(`[bridge] channel state: ${JSON.stringify(s10)}`));
   channel.on(
     "room_joined",
-    (e7) => console.error(`[bridge] joined room ${e7.name} (${e7.roomId})`)
+    (e7) => logLine(`[bridge] joined room ${e7.name} (${e7.roomId})`)
   );
   listener.start().catch((err) => {
-    console.error("[bridge] fatal:", err);
+    logLine("[bridge] fatal:", err);
     process.exit(1);
   });
   await channel.start();
 }
 main().catch((err) => {
-  console.error("[bridge] fatal:", err);
+  logLine("[bridge] fatal:", err);
   process.exit(1);
 });
 /*! Bundled license information:

package/dist/log.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Prefix every line of `message` with an ISO-8601 UTC timestamp.
+ *
+ * Per-LINE, not per-call, on purpose: `logLine("[bridge] fatal:", err)` renders a
+ * multi-line stack trace, and a first-line-only stamp would leave every frame
+ * unanchored — the case where the clock matters most. The acceptance criterion
+ * on #790 is "every line in the file", so this reads it literally.
+ */
+export declare function stamp(message: string): string;
+/**
+ * Write one stamped record to stderr.
+ *
+ * stderr (not stdout) because the launchd/systemd unit routes both, and the
+ * bridge's existing sinks were already `console.error` — keeping the stream the
+ * same means this change alters the CONTENT of the logs and nothing else.
+ *
+ * Multi-arg is supported via `util.format`, which is what `console.error` uses
+ * internally, so `logLine("[bridge] fatal:", err)` renders exactly as before —
+ * just anchored to a clock.
+ */
+export declare function logLine(...args: unknown[]): void;
+//# sourceMappingURL=log.d.ts.map

package/dist/worker-queue.d.ts

@@ -17,19 +17,27 @@ export type WorkerTask = {
     armed?: () => boolean;
 };
 /**
- * Forensic record of a task that did NOT complete cleanly.
+ * Forensic record of EVERY task the queue runs — clean or not.
  *
  * Exists because the 2026-07-24 "loopita went quiet for 5 minutes" incident was
  * diagnosable only by coincidence: the drop-trap happened to capture that the
  * reply landed 300.016s after the ack, and 300s is `WORKER_TIMEOUT_MS` exactly.
  * Nothing in the bridge recorded WHY the worker hung, and the logs carry no
  * timestamps at all, so the evidence was gone by the time we looked.
+ *
+ * 2026-08-06: widened from failures-only to every turn. Recording only failures
+ * made the SLOW case unmeasurable, and slow is the common case: loopita answered
+ * Ballroom2 in 21s when the room was quiet and 81s when a second agent was
+ * talking, and nothing said whether the extra 60s was `waitedMs` or `ranMs`.
+ * Those are different bugs with identical symptoms. A trap that only reports
+ * when it breaks cannot tell you it is the reason things are slow.
  */
 export type WorkerIncident = {
     /** ISO timestamp — the bridge's own logs are unstamped, so this is the anchor. */
     at: string;
-    outcome: "timeout" | "error";
-    error: string;
+    outcome: "ok" | "timeout" | "error";
+    /** Absent on a clean turn — its presence is what marks a real incident. */
+    error?: string;
     /**
      * enqueue -> start. THE load-bearing field: it separates "this task hung" from
      * "this task was stuck behind one that hung". Both look identical to the owner
@@ -44,6 +52,15 @@ export type WorkerIncident = {
     /** Depth still waiting when this task began — the blast radius of this hang. */
     queueDepthAtStart: number;
     instructionChars: number;
+    /**
+     * Whether a reply was expected of this turn — mirrors `WorkerTask.replyExpected`,
+     * i.e. `senderIsAgent === false` upstream. Without it a silent turn
+     * (composed=0, said=false) is unattributable: it could be agent-authored traffic
+     * that was never going to answer, or a turn that waited so long the previous one
+     * already answered. Ballroom2 on 2026-08-06 produced both readings and the record
+     * could not separate them.
+     */
+    replyExpected?: boolean;
     /** What the worker had produced when it died, when the session can report it. */
     session?: {
         composedChars: number;
@@ -91,6 +108,14 @@ export declare class WorkerQueue {
     /** Resolves when the queue has processed everything enqueued so far. */
     whenDrained(): Promise<void>;
     private drain;
+    /**
+     * What the worker had produced, when the session can report it. Read on BOTH the
+     * clean and the failing path: on a clean turn `said: false` with a non-zero
+     * `composedChars` is the "composed but could never ship it" signature (agent-
+     * authored room traffic, where `replyExpected` is false), which is otherwise
+     * indistinguishable from a turn that did nothing.
+     */
+    private snapshotOf;
     /** Best-effort trap emit. A broken sink must never break the queue. */
     private emitIncident;
     private runOne;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@agentvault/claude-bridge",
-  "version": "0.7.6",
+  "version": "0.7.8",
   "type": "module",
-  "description": "AgentVault Claude Bridge — daemon for bridging a Claude agent into secure E2E-encrypted AgentVault 1:1 direct messages and rooms.",
+  "description": "AgentVault Claude Bridge \u2014 daemon for bridging a Claude agent into secure E2E-encrypted AgentVault 1:1 direct messages and rooms.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {