@agentvault/claude-bridge 0.7.7 → 0.7.9

package/dist/index.js

@@ -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 {
@@ -80864,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
   };
@@ -81335,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;
         }
       }
@@ -81366,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";
@@ -82522,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);
@@ -82533,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);
@@ -92020,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" } = {}) {
@@ -92141,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) {
@@ -93758,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() {
@@ -93780,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() {
@@ -93807,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})`;
           }
         }
       }
@@ -93820,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({
@@ -94447,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));
         }
@@ -119180,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) {
@@ -119286,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",
@@ -119304,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 };
@@ -130202,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
   };
@@ -130583,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;
     }
   }
@@ -130614,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";
@@ -131804,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);
@@ -131815,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);
@@ -132795,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());
         }
       }
@@ -133165,6 +133175,28 @@ var PersistentClaudeSession = class {
    *  #416 fallback delivery (which delivers via `void reply(...)` WITHOUT setting
    *  saidThisTurn, so !saidThisTurn alone would false-flag it). */
   sawResultThisTurn = false;
+  /**
+   * Per-turn telemetry lifted off the SDK's `result` message.
+   *
+   * The message arrives on EVERY turn and we kept one boolean from it
+   * (`sawResultThisTurn`), discarding the rest. That is the #791 shape: data
+   * delivered on the healthy path that nothing reads.
+   *
+   * It costs us a real answer. A turn that produced nothing (`composed=0,
+   * said=false`) could be the model choosing silence, the turn cap being hit, or
+   * the provider returning 429 — three different bugs with one symptom, and
+   * `subtype`/`apiErrorStatus` are what separate them. 4 of 12 turns on
+   * 2026-08-07 were silent and could not be attributed.
+   *
+   * `durationApiMs` vs `durationMs` also gives the model-time / SDK-overhead
+   * split directly. That split previously had to be reconstructed by joining
+   * `WorkerIncident.ranMs` against SDK transcripts on disk by wall clock.
+   *
+   * Every field is OPTIONAL and left undefined when no result arrives (abort or
+   * crash mid-turn): absent must read as absent, never as a zero that looks like
+   * a real measurement.
+   */
+  resultTelemetry = {};
   /** In-process room MCP server — hoisted so buildSdkOptions can reference it. */
   roomServer;
   /** AbortController for the in-flight query(); abort() triggers it (queue timeout). */
@@ -133229,7 +133261,8 @@ var PersistentClaudeSession = class {
     return {
       composedChars: this.turnText.length,
       sawResult: this.sawResultThisTurn,
-      said: this.saidThisTurn
+      said: this.saidThisTurn,
+      ...this.resultTelemetry
     };
   }
   async *input() {
@@ -133251,6 +133284,7 @@ var PersistentClaudeSession = class {
       this.saidThisTurn = false;
       this.turnText = "";
       this.sawResultThisTurn = false;
+      this.resultTelemetry = {};
       yield item.msg;
     }
   }
@@ -133319,7 +133353,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 {
@@ -133360,7 +133394,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({
@@ -133381,12 +133427,23 @@ var PersistentClaudeSession = class {
           }
         } else if (m6.type === "result") {
           this.sawResultThisTurn = true;
+          const r7 = m6;
+          const num = (k2) => typeof r7[k2] === "number" ? r7[k2] : void 0;
+          const str = (k2) => typeof r7[k2] === "string" ? r7[k2] : void 0;
+          this.resultTelemetry = {
+            durationMs: num("duration_ms"),
+            durationApiMs: num("duration_api_ms"),
+            numTurns: num("num_turns"),
+            subtype: str("subtype"),
+            stopReason: str("stop_reason"),
+            apiErrorStatus: num("api_error_status")
+          };
           const reply = this.activeReply;
           if (this.currentReplyExpected && !this.saidThisTurn && this.turnText.trim()) {
             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`
               );
             }
@@ -133395,7 +133452,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)`
         );
       }
@@ -134087,22 +134144,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.7" : "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.9" : "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.'
     );
   }
@@ -134133,7 +134190,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;
@@ -134142,7 +134199,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.
@@ -134165,7 +134222,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
@@ -134173,7 +134230,7 @@ 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(
+      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 {
@@ -134181,7 +134238,7 @@ async function main() {
         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}`);
       }
     }
   });
@@ -134193,7 +134250,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,
@@ -134209,21 +134266,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/session.d.ts

@@ -143,6 +143,28 @@ export declare class PersistentClaudeSession {
      *  #416 fallback delivery (which delivers via `void reply(...)` WITHOUT setting
      *  saidThisTurn, so !saidThisTurn alone would false-flag it). */
     private sawResultThisTurn;
+    /**
+     * Per-turn telemetry lifted off the SDK's `result` message.
+     *
+     * The message arrives on EVERY turn and we kept one boolean from it
+     * (`sawResultThisTurn`), discarding the rest. That is the #791 shape: data
+     * delivered on the healthy path that nothing reads.
+     *
+     * It costs us a real answer. A turn that produced nothing (`composed=0,
+     * said=false`) could be the model choosing silence, the turn cap being hit, or
+     * the provider returning 429 — three different bugs with one symptom, and
+     * `subtype`/`apiErrorStatus` are what separate them. 4 of 12 turns on
+     * 2026-08-07 were silent and could not be attributed.
+     *
+     * `durationApiMs` vs `durationMs` also gives the model-time / SDK-overhead
+     * split directly. That split previously had to be reconstructed by joining
+     * `WorkerIncident.ranMs` against SDK transcripts on disk by wall clock.
+     *
+     * Every field is OPTIONAL and left undefined when no result arrives (abort or
+     * crash mid-turn): absent must read as absent, never as a zero that looks like
+     * a real measurement.
+     */
+    private resultTelemetry;
     /** In-process room MCP server — hoisted so buildSdkOptions can reference it. */
     private roomServer;
     /** AbortController for the in-flight query(); abort() triggers it (queue timeout). */
@@ -185,6 +207,12 @@ export declare class PersistentClaudeSession {
         composedChars: number;
         sawResult: boolean;
         said: boolean;
+        durationMs?: number;
+        durationApiMs?: number;
+        numTurns?: number;
+        subtype?: string;
+        stopReason?: string;
+        apiErrorStatus?: number;
     };
     private input;
     /**

package/dist/worker-queue.d.ts

@@ -61,11 +61,27 @@ export type WorkerIncident = {
      * could not separate them.
      */
     replyExpected?: boolean;
-    /** What the worker had produced when it died, when the session can report it. */
+    /**
+     * What the worker had produced when it died, when the session can report it.
+     *
+     * The `duration*`/`numTurns`/`subtype`/`stopReason`/`apiErrorStatus` fields are
+     * lifted off the SDK's `result` message (see `PersistentClaudeSession`). They
+     * are what makes a SILENT turn attributable: `composed=0, said=false` is
+     * produced identically by the model choosing silence (`subtype: success`), the
+     * turn cap (`error_max_turns`) and a provider error (`apiErrorStatus: 429`).
+     * Absent on any turn that never reached a result boundary — undefined means
+     * "no result arrived", never zero.
+     */
     session?: {
         composedChars: number;
         sawResult: boolean;
         said: boolean;
+        durationMs?: number;
+        durationApiMs?: number;
+        numTurns?: number;
+        subtype?: string;
+        stopReason?: string;
+        apiErrorStatus?: number;
     };
 };
 export interface WorkerQueueDeps {

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@agentvault/claude-bridge",
-  "version": "0.7.7",
+  "version": "0.7.9",
   "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": {