flavor-code 1.3.3 → 1.3.6

package/dist/{chunk-YY5H6GFN.js → chunk-BR3CWUYR.js}

@@ -5006,7 +5006,7 @@ async function ensureOnce(options) {
 
 // src/production.ts
 import { readFile as readFile22 } from "fs/promises";
-import { createHash as createHash17, randomUUID as randomUUID18 } from "crypto";
+import { createHash as createHash17, randomUUID as randomUUID19 } from "crypto";
 import { homedir as homedir2, release as osRelease, tmpdir as tmpdir3, version as osVersion } from "os";
 import { basename as basename6, join as join24, relative as relative20, resolve as resolve27, sep as sep20 } from "path";
 
@@ -7484,11 +7484,18 @@ var DEFAULT_TOOL_OUTPUT_LIMITS = Object.freeze({
   perTurnChars: 2e5
 });
 var PreToolUsePayload = z9.object({
+  // Optional for backwards-compatible hook updatedInput payloads; runtime
+  // emissions always populate it.
+  toolCallId: z9.string().optional(),
   tool: z9.string(),
   input: z9.unknown(),
   agent: z9.enum(["main", "subagent"])
 });
-var PermissionRequestPayload = PreToolUsePayload.extend({ reason: z9.string().optional() });
+var PermissionRequestPayload = PreToolUsePayload.extend({
+  reason: z9.string().optional(),
+  toolCategory: z9.string(),
+  allowAlways: z9.boolean()
+});
 var PostToolUsePayload = PreToolUsePayload.extend({ output: z9.unknown() });
 var PostToolUseFailurePayload = PreToolUsePayload.extend({
   error: z9.object({ code: z9.string(), message: z9.string() })
@@ -7605,30 +7612,31 @@ var ToolRuntime = class {
     const tool = this.#tools.get(call.name);
     if (tool === void 0) return { ok: false, error: { code: "unknown_tool", message: `Unknown tool: ${call.name}` } };
     const signal = context.signal ?? new AbortController().signal;
+    const toolCallId = call.id ?? randomUUID7();
     const validation = this.validate(call);
     if (!validation.ok) {
-      return this.#fail(call.name, call.input, context.agent, validation.error.code, validation.error.message);
+      return this.#fail(toolCallId, call.name, call.input, context.agent, validation.error.code, validation.error.message);
     }
     let input = validation.input;
     try {
       const pre = await this.#hooks.emit({
         version: 1,
         type: "PreToolUse",
-        payload: { tool: tool.name, input, agent: context.agent }
+        payload: { toolCallId, tool: tool.name, input, agent: context.agent }
       });
       if (pre.updatedInput !== void 0) {
         const payload = PreToolUsePayload.parse(pre.updatedInput);
         if (payload.tool !== tool.name || payload.agent !== context.agent) {
-          return this.#fail(tool.name, input, context.agent, "invalid_input", "PreToolUse cannot change the tool or agent");
+          return this.#fail(toolCallId, tool.name, input, context.agent, "invalid_input", "PreToolUse cannot change the tool or agent");
         }
         try {
           input = tool.inputSchema.parse(payload.input);
         } catch (error) {
-          return this.#fail(tool.name, payload.input, context.agent, "invalid_input", message(error));
+          return this.#fail(toolCallId, tool.name, payload.input, context.agent, "invalid_input", message(error));
         }
       }
       if (pre.decision === "deny") {
-        return this.#fail(tool.name, input, context.agent, "hook_denied", pre.reason ?? "Tool use denied by hook");
+        return this.#fail(toolCallId, tool.name, input, context.agent, "hook_denied", pre.reason ?? "Tool use denied by hook");
       }
       const request = {
         agent: context.agent,
@@ -7639,13 +7647,13 @@ var ToolRuntime = class {
       let permission = this.#permissions.decide(request);
       const nonCacheableApproval = request.allowAlways === false || permission.allowAlways === false;
       if (permission.decision === "deny") {
-        return this.#fail(tool.name, input, context.agent, "permission_denied", permission.reason ?? "Tool use denied");
+        return this.#fail(toolCallId, tool.name, input, context.agent, "permission_denied", permission.reason ?? "Tool use denied");
       }
       if (permission.decision === "ask" && context.agent === "main" && !nonCacheableApproval && this.#permissions.mode === "auto" && this.#permissions.profile === "standard" && this.#classify !== void 0) {
         try {
           const classified = await this.#classify(request, signal);
           if (classified.decision === "deny") {
-            return this.#fail(tool.name, input, context.agent, "permission_denied", classified.reason ?? "Auto classifier denied tool use");
+            return this.#fail(toolCallId, tool.name, input, context.agent, "permission_denied", classified.reason ?? "Auto classifier denied tool use");
           }
           if (classified.decision === "allow") permission = classified;
           else {
@@ -7662,13 +7670,21 @@ var ToolRuntime = class {
         const requestDecision = await this.#hooks.emit({
           version: 1,
           type: "PermissionRequest",
-          payload: { tool: tool.name, input: tool.permissionInput?.(input) ?? input, agent: context.agent, reason }
+          payload: {
+            toolCallId,
+            tool: tool.name,
+            input: tool.permissionInput?.(input) ?? input,
+            agent: context.agent,
+            reason,
+            toolCategory: getToolCategory(tool.name),
+            allowAlways
+          }
         });
         if (requestDecision.decision === "deny") {
-          return this.#fail(tool.name, input, context.agent, "permission_denied", requestDecision.reason ?? "Permission request denied");
+          return this.#fail(toolCallId, tool.name, input, context.agent, "permission_denied", requestDecision.reason ?? "Permission request denied");
         }
         if (requestDecision.updatedInput !== void 0) {
-          return this.#fail(tool.name, input, context.agent, "invalid_input", "PermissionRequest cannot modify an already-authorized tool call");
+          return this.#fail(toolCallId, tool.name, input, context.agent, "invalid_input", "PermissionRequest cannot modify an already-authorized tool call");
         }
         if (this.#hooks.hasListeners("PermissionRequest") && requestDecision.decision === "allow") {
           const ctx = requestDecision.additionalContext ?? "";
@@ -7677,18 +7693,18 @@ var ToolRuntime = class {
             if (allowAlways && category !== "destructive") this.#alwaysAllowed.add(category);
           }
         } else if (context.agent !== "main" && this.#permissions.mode !== "bubble") {
-          return this.#fail(tool.name, input, context.agent, "approval_required", reason);
+          return this.#fail(toolCallId, tool.name, input, context.agent, "approval_required", reason);
         } else if (signal.aborted) {
           throw signal.reason;
         } else {
           const category = getToolCategory(tool.name);
           if (allowAlways && this.#alwaysAllowed.has(category)) {
           } else if (this.#approve === void 0) {
-            return this.#fail(tool.name, input, context.agent, "permission_denied", reason);
+            return this.#fail(toolCallId, tool.name, input, context.agent, "permission_denied", reason);
           } else {
             const decision = await this.#approve({ ...request, reason, ...allowAlways ? {} : { allowAlways: false } }, signal);
             if (decision === "deny") {
-              return this.#fail(tool.name, input, context.agent, "user_denied", reason);
+              return this.#fail(toolCallId, tool.name, input, context.agent, "user_denied", reason);
             }
             if (decision === "always" && allowAlways && category !== "destructive") {
               this.#alwaysAllowed.add(category);
@@ -7702,7 +7718,7 @@ var ToolRuntime = class {
       try {
         rawOutput = tool.outputSchema === void 0 ? executed : tool.outputSchema.parse(executed);
       } catch (error) {
-        return this.#fail(tool.name, input, context.agent, "invalid_output", message(error));
+        return this.#fail(toolCallId, tool.name, input, context.agent, "invalid_output", message(error));
       }
       const declaredPresentation = tool.presentResult?.(rawOutput, input);
       const presentation = declaredPresentation ?? getToolPresentation(rawOutput);
@@ -7713,7 +7729,7 @@ var ToolRuntime = class {
       await this.#hooks.emit({
         version: 1,
         type: "PostToolUse",
-        payload: { tool: tool.name, input, agent: context.agent, output }
+        payload: { toolCallId, tool: tool.name, input, agent: context.agent, output }
       });
       return {
         ok: true,
@@ -7723,7 +7739,7 @@ var ToolRuntime = class {
         ...additionalContext === void 0 || additionalContext.length === 0 ? {} : { additionalContext }
       };
     } catch (error) {
-      return this.#fail(tool.name, input, context.agent, "tool_error", message(error));
+      return this.#fail(toolCallId, tool.name, input, context.agent, "tool_error", message(error));
     }
   }
   async #limitOutput(tool, output) {
@@ -7771,13 +7787,13 @@ var ToolRuntime = class {
     const limited = await this.#limitOutput(tool, content);
     return typeof limited === "string" ? limited : serializeToolOutput(limited);
   }
-  async #fail(tool, input, agent, code, errorMessage2) {
+  async #fail(toolCallId, tool, input, agent, code, errorMessage2) {
     const result = { ok: false, error: { code, message: errorMessage2 } };
     try {
       await this.#hooks.emit({
         version: 1,
         type: "PostToolUseFailure",
-        payload: { tool, input, agent, error: result.error }
+        payload: { toolCallId, tool, input, agent, error: result.error }
       });
     } catch {
     }
@@ -7985,7 +8001,7 @@ function toModelTool(tool) {
 
 // src/harness/journal.ts
 import { createHash as createHash6, randomUUID as randomUUID8 } from "crypto";
-import { closeSync, constants, existsSync as existsSync2, fsyncSync, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync2, realpathSync as realpathSync2, statSync, truncateSync, writeSync } from "fs";
+import { closeSync, constants, existsSync as existsSync2, fsyncSync, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync2, realpathSync as realpathSync2, renameSync, statSync, truncateSync, unlinkSync, writeSync } from "fs";
 import { join as join8, relative as relative7, resolve as resolve8, sep as sep7 } from "path";
 import { z as z10 } from "zod";
 
@@ -7996,8 +8012,10 @@ function harnessInvariantViolations(records) {
   const tools = /* @__PURE__ */ new Set();
   const models = /* @__PURE__ */ new Set();
   const turns = /* @__PURE__ */ new Set();
+  const firstSequence = records[0]?.sequence ?? 1;
   records.forEach((record, index) => {
-    if (record.sequence !== index + 1) violations.push(`sequence ${record.sequence} is not ${index + 1}`);
+    const expectedSequence = firstSequence + index;
+    if (record.sequence !== expectedSequence) violations.push(`sequence ${record.sequence} is not ${expectedSequence}`);
     const id = typeof record.payload.id === "string" ? record.payload.id : "";
     if (record.type === "queue.admitted") {
       if (queues.has(id)) violations.push(`queue ${id} was admitted twice`);
@@ -8013,13 +8031,13 @@ function harnessInvariantViolations(records) {
       if (!tools.delete(id)) violations.push(`${record.type} references unknown tool ${id}`);
     } else if (record.type === "model.requested") {
       if (models.has(id)) violations.push(`model ${id} was requested twice`);
-      if (!Array.isArray(record.payload.messages)) violations.push(`model ${id} has no replayable messages`);
+      if (!isHash(record.payload.messagesHash)) violations.push(`model ${id} has no valid messages hash`);
       models.add(id);
     } else if (record.type === "model.completed") {
       if (!models.delete(id)) violations.push(`model.completed references unknown model ${id}`);
     } else if (record.type === "turn.started") {
       if (turns.has(id)) violations.push(`turn ${id} was started twice`);
-      if (!("prompt" in record.payload)) violations.push(`turn ${id} has no replayable prompt`);
+      if (!isHash(record.payload.promptHash)) violations.push(`turn ${id} has no valid prompt hash`);
       turns.add(id);
     } else if (record.type === "turn.completed" || record.type === "turn.interrupted") {
       if (!turns.delete(id)) violations.push(`${record.type} references unknown turn ${id}`);
@@ -8027,6 +8045,9 @@ function harnessInvariantViolations(records) {
   });
   return violations;
 }
+function isHash(value) {
+  return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+}
 function assertHarnessInvariants(records) {
   const violations = harnessInvariantViolations(records);
   if (violations.length > 0) throw new Error(`Harness invariant violation: ${violations.join("; ")}`);
@@ -8107,7 +8128,7 @@ var HarnessJournal = class {
   }
   startTurn(config, prompt) {
     const id = randomUUID8();
-    this.#append("turn.started", { id, config: structuredClone(config), configHash: hashJson(config), prompt: structuredClone(prompt), promptHash: hashJson(prompt) });
+    this.#append("turn.started", { id, configHash: hashJson(config), promptHash: hashJson(prompt) });
     return id;
   }
   completeTurn(id) {
@@ -8118,7 +8139,14 @@ var HarnessJournal = class {
   }
   startModel(input) {
     const id = randomUUID8();
-    this.#append("model.requested", { id, ...structuredClone(input), messagesHash: hashJson(input.messages) });
+    this.#append("model.requested", {
+      id,
+      agent: input.agent,
+      model: input.model,
+      iteration: input.iteration,
+      attempt: input.attempt,
+      messagesHash: hashJson(input.messages)
+    });
     return id;
   }
   completeModel(id, completed, error) {
@@ -8126,11 +8154,11 @@ var HarnessJournal = class {
   }
   startTool(tool, input, retrySafe) {
     const id = randomUUID8();
-    this.#append("tool.started", { id, tool, input: structuredClone(input), inputHash: hashJson(input), retrySafe });
+    this.#append("tool.started", { id, tool, inputHash: hashJson(input), retrySafe });
     return id;
   }
   completeTool(id, result) {
-    this.#append("tool.completed", { id, result: structuredClone(result) });
+    this.#append("tool.completed", { id, resultHash: hashJson(result) });
   }
   interruptTool(id, reason) {
     this.#append("tool.interrupted", { id, reason });
@@ -8207,47 +8235,153 @@ var HarnessJournal = class {
     const committed = raw.endsWith("\n") ? raw : raw.slice(0, Math.max(0, raw.lastIndexOf("\n") + 1));
     if (committed.length !== raw.length) truncateSync(this.#path, Buffer.byteLength(committed));
     const lines = committed.split("\n").filter(Boolean);
-    let previousHash = null;
+    let previousHash;
+    let expectedSequence;
     for (const line of lines) {
       const record = JournalRecordSchema.parse(JSON.parse(line));
-      if (record.sequence !== this.#records.length + 1) throw new Error("Harness journal sequence is not contiguous");
+      expectedSequence ??= record.sequence;
+      previousHash ??= record.previousHash;
+      if (record.sequence !== expectedSequence) throw new Error("Harness journal sequence is not contiguous");
       if (record.previousHash !== previousHash) throw new Error("Harness journal hash chain is broken");
       if (record.hash !== recordHash(record)) throw new Error("Harness journal record hash is invalid");
       this.#records.push(record);
       previousHash = record.hash;
+      expectedSequence += 1;
     }
-    this.#sequence = this.#records.length;
-    this.#lastHash = previousHash;
+    this.#sequence = this.#records.at(-1)?.sequence ?? 0;
+    this.#lastHash = previousHash ?? null;
     assertHarnessInvariants(this.#records);
+    const hasRotatedPrefix = (this.#records[0]?.sequence ?? 1) !== 1;
+    if (metadata.size > this.#maxBytes * 0.75 || hasRotatedPrefix || this.#records.some(hasLegacyPayload)) this.#compact();
   }
   #append(type, payload) {
     const normalizedPayload = jsonSafeRecord(payload);
+    let record = this.#createRecord(type, normalizedPayload);
+    let line = `${JSON.stringify(record)}
+`;
+    let priorBytes = existsSync2(this.#path) ? statSync(this.#path).size : 0;
+    if (priorBytes + Buffer.byteLength(line) > this.#maxBytes) {
+      this.#compact();
+      record = this.#createRecord(type, normalizedPayload);
+      line = `${JSON.stringify(record)}
+`;
+      priorBytes = existsSync2(this.#path) ? statSync(this.#path).size : 0;
+      if (priorBytes + Buffer.byteLength(line) > this.#maxBytes) {
+        throw new Error(`Harness journal event exceeds the ${this.#maxBytes} byte bounded journal capacity`);
+      }
+    }
+    const fd = openSync(this.#path, constants.O_CREAT | constants.O_APPEND | constants.O_WRONLY, 384);
+    try {
+      writeSync(fd, line, void 0, "utf8");
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+    this.#records.push(record);
+    this.#sequence = record.sequence;
+    this.#lastHash = record.hash;
+  }
+  #createRecord(type, payload) {
     const unsigned = {
       version: HARNESS_JOURNAL_VERSION,
       sequence: this.#sequence + 1,
       id: randomUUID8(),
       timestamp: this.#now(),
       type,
-      payload: normalizedPayload,
+      payload,
       previousHash: this.#lastHash
     };
-    const record = JournalRecordSchema.parse({ ...unsigned, hash: hashJson(unsigned) });
-    const line = `${JSON.stringify(record)}
-`;
-    const priorBytes = existsSync2(this.#path) ? statSync(this.#path).size : 0;
-    if (priorBytes + Buffer.byteLength(line) > this.#maxBytes) throw new Error(`Harness journal exceeds ${this.#maxBytes} bytes`);
-    const fd = openSync(this.#path, constants.O_CREAT | constants.O_APPEND | constants.O_WRONLY, 384);
+    return JournalRecordSchema.parse({ ...unsigned, hash: hashJson(unsigned) });
+  }
+  #compact() {
+    const queues = /* @__PURE__ */ new Map();
+    const claims = /* @__PURE__ */ new Map();
+    const tools = /* @__PURE__ */ new Map();
+    const models = /* @__PURE__ */ new Map();
+    const turns = /* @__PURE__ */ new Map();
+    let savepoint;
+    for (const record of this.#records) {
+      const id = typeof record.payload.id === "string" ? record.payload.id : "";
+      if (record.type === "queue.admitted") queues.set(id, record);
+      else if (record.type === "queue.claimed") claims.set(id, record);
+      else if (record.type === "queue.released") claims.delete(id);
+      else if (record.type === "queue.acked") {
+        queues.delete(id);
+        claims.delete(id);
+      } else if (record.type === "tool.started") tools.set(id, record);
+      else if (record.type === "tool.completed" || record.type === "tool.interrupted") tools.delete(id);
+      else if (record.type === "model.requested") models.set(id, record);
+      else if (record.type === "model.completed") models.delete(id);
+      else if (record.type === "turn.started") turns.set(id, record);
+      else if (record.type === "turn.completed" || record.type === "turn.interrupted") turns.delete(id);
+      else if (record.type === "savepoint.created") savepoint = record;
+    }
+    const retained = [
+      ...queues.values(),
+      ...claims.values(),
+      ...tools.values(),
+      ...models.values(),
+      ...turns.values(),
+      ...savepoint === void 0 ? [] : [savepoint]
+    ].sort((left, right) => left.sequence - right.sequence);
+    const compacted = [];
+    let previousHash = null;
+    for (const source of retained) {
+      const unsigned = {
+        version: HARNESS_JOURNAL_VERSION,
+        sequence: compacted.length + 1,
+        id: randomUUID8(),
+        timestamp: source.timestamp,
+        type: source.type,
+        payload: compactPayload(source),
+        previousHash
+      };
+      const record = JournalRecordSchema.parse({ ...unsigned, hash: hashJson(unsigned) });
+      compacted.push(record);
+      previousHash = record.hash;
+    }
+    const contents = compacted.map((record) => `${JSON.stringify(record)}
+`).join("");
+    if (Buffer.byteLength(contents) > this.#maxBytes) return;
+    const temporary = `${this.#path}.compact-${process.pid}-${randomUUID8()}`;
+    const fd = openSync(temporary, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 384);
     try {
-      writeSync(fd, line, void 0, "utf8");
+      writeSync(fd, contents, void 0, "utf8");
       fsyncSync(fd);
     } finally {
       closeSync(fd);
     }
-    this.#records.push(record);
-    this.#sequence = record.sequence;
-    this.#lastHash = record.hash;
+    try {
+      renameSync(temporary, this.#path);
+    } catch (error) {
+      if (existsSync2(temporary)) unlinkSync(temporary);
+      throw error;
+    }
+    this.#records = compacted;
+    this.#sequence = compacted.length;
+    this.#lastHash = previousHash;
   }
 };
+function compactPayload(record) {
+  const payload = record.payload;
+  if (record.type === "queue.admitted") return payload;
+  if (record.type === "queue.claimed") return { id: payload.id };
+  if (record.type === "tool.started") return pick(payload, ["id", "tool", "inputHash", "retrySafe"]);
+  if (record.type === "model.requested") return pick(payload, ["id", "agent", "model", "iteration", "attempt", "messagesHash"]);
+  if (record.type === "turn.started") return pick(payload, ["id", "configHash", "promptHash"]);
+  if (record.type === "savepoint.created") return pick(payload, ["id", "phase", "configHash"]);
+  return payload;
+}
+function hasLegacyPayload(record) {
+  if (record.type === "turn.started") return "config" in record.payload || "prompt" in record.payload;
+  if (record.type === "model.requested") return "messages" in record.payload;
+  if (record.type === "tool.started") return "input" in record.payload;
+  if (record.type === "tool.completed") return "result" in record.payload;
+  return false;
+}
+function pick(source, keys) {
+  return Object.fromEntries(keys.flatMap((key) => key in source ? [[key, source[key]]] : []));
+}
 function jsonSafeRecord(value) {
   const json = JSON.stringify(value, (_key, item) => typeof item === "bigint" ? `${item}n` : item);
   return JSON.parse(json);
@@ -8280,6 +8414,7 @@ function isWithin2(root, target) {
 
 // src/hooks/bus.ts
 import { spawn as spawn4 } from "child_process";
+import { randomUUID as randomUUID9 } from "crypto";
 
 // src/hooks/types.ts
 import { z as z11 } from "zod";
@@ -8346,6 +8481,11 @@ var DEFAULT_MAX_OUTPUT_BYTES = 1048576;
 var HookBus = class {
   #handlers = /* @__PURE__ */ new Map();
   #payloadSchemas = /* @__PURE__ */ new Map();
+  #options;
+  #sequence = 0;
+  constructor(options = {}) {
+    this.#options = options;
+  }
   registerPayloadSchema(type, schema) {
     const registrations = this.#payloadSchemas.get(type) ?? [];
     const registration = { schema };
@@ -8382,7 +8522,9 @@ var HookBus = class {
   async emit(rawEvent, externalSignal) {
     externalSignal?.throwIfAborted();
     let event = HookEventSchema.parse(rawEvent);
-    event = { ...event, payload: this.#validatePayload(event.type, event.payload) };
+    const validatedPayload = this.#validatePayload(event.type, event.payload);
+    const envelope = this.#eventEnvelope();
+    event = { ...event, payload: decoratePayload(validatedPayload, envelope) };
     let aggregate2 = { decision: "allow" };
     for (const registered of this.#handlers.get(event.type) ?? []) {
       externalSignal?.throwIfAborted();
@@ -8397,8 +8539,8 @@ var HookBus = class {
       externalSignal?.throwIfAborted();
       if (decision.updatedInput !== void 0) {
         const payload = this.#validatePayload(event.type, decision.updatedInput);
-        event = HookEventSchema.parse({ ...event, payload });
-        aggregate2 = { ...aggregate2, updatedInput: event.payload };
+        event = HookEventSchema.parse({ ...event, payload: decoratePayload(payload, envelope) });
+        aggregate2 = { ...aggregate2, updatedInput: payload };
       }
       if (decision.additionalContext !== void 0) {
         aggregate2 = {
@@ -8415,6 +8557,15 @@ var HookBus = class {
     const schema = this.#payloadSchemas.get(type)?.at(-1)?.schema;
     return schema ? schema.parse(payload) : zodRecord(payload);
   }
+  #eventEnvelope() {
+    if (this.#options.eventContext === void 0) return void 0;
+    return {
+      ...this.#options.eventContext(),
+      eventId: (this.#options.eventId ?? randomUUID9)(),
+      sequence: ++this.#sequence,
+      timestamp: (this.#options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()))()
+    };
+  }
   async #invoke(registered, event, externalSignal) {
     const timeoutSignal = AbortSignal.timeout(registered.timeoutMs);
     const signal = externalSignal === void 0 ? timeoutSignal : AbortSignal.any([timeoutSignal, externalSignal]);
@@ -8426,6 +8577,9 @@ var HookBus = class {
     return HookDecisionSchema.parse(await Promise.race([invocation, timeout]));
   }
 };
+function decoratePayload(payload, envelope) {
+  return envelope === void 0 ? payload : { ...payload, ...envelope };
+}
 function runShellHandler(descriptor, event, signal) {
   return new Promise((resolve28, reject) => {
     const child = spawn4(descriptor.command, [...descriptor.args ?? []], {
@@ -11303,7 +11457,7 @@ function formatPriorGaps(gaps) {
 
 // src/goal/store.ts
 import { constants as constants2 } from "fs";
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 import { lstat as lstat6, mkdir as mkdir11, open as open6, rename as rename4, rm as rm4 } from "fs/promises";
 import { dirname as dirname12, join as join14, relative as relative9, resolve as resolve11, sep as sep9 } from "path";
 var DEFAULT_MAX_BYTES = 1024 * 1024;
@@ -11327,7 +11481,7 @@ var GoalStore = class {
     if (Buffer.byteLength(body) > this.#maxBytes) {
       throw new Error(`Goal state exceeds maximum size of ${this.#maxBytes} bytes`);
     }
-    const temporary = join14(this.#root, `.${state.id}.${process.pid}.${randomUUID9()}.tmp`);
+    const temporary = join14(this.#root, `.${state.id}.${process.pid}.${randomUUID10()}.tmp`);
     let handle;
     try {
       handle = await open6(temporary, constants2.O_CREAT | constants2.O_EXCL | constants2.O_WRONLY, 384);
@@ -11440,7 +11594,7 @@ async function ensureWorktreeDirectoryIgnored(root) {
 import { constants as constants3 } from "fs";
 import { lstat as lstat7, mkdir as mkdir13, open as open7, readFile as readFile11, realpath as realpath5, rename as rename5, rm as rm5, stat as stat5 } from "fs/promises";
 import { dirname as dirname13, join as join16, relative as relative10, resolve as resolve13, sep as sep10 } from "path";
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 var LOOP_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 var DEFAULT_MAX_BYTES2 = 5 * 1024 * 1024;
 var LoopStore = class {
@@ -11471,7 +11625,7 @@ var LoopStore = class {
     const body = `${JSON.stringify(state, null, 2)}
 `;
     if (Buffer.byteLength(body) > this.#maxBytes) throw new Error(`Loop state exceeds maximum size of ${this.#maxBytes} bytes`);
-    const temporary = join16(directory, `.state.${process.pid}.${randomUUID10()}.tmp`);
+    const temporary = join16(directory, `.state.${process.pid}.${randomUUID11()}.tmp`);
     let handle;
     try {
       handle = await open7(temporary, constants3.O_CREAT | constants3.O_EXCL | constants3.O_WRONLY, 384);
@@ -11497,7 +11651,7 @@ var LoopStore = class {
       return state;
     } catch (error) {
       if (isCode4(error, "ENOENT")) throw new Error(`Loop "${loopId}" was not found`);
-      const quarantine = `${target}.corrupt-${Date.now()}-${randomUUID10().slice(0, 8)}`;
+      const quarantine = `${target}.corrupt-${Date.now()}-${randomUUID11().slice(0, 8)}`;
       await rename5(target, quarantine).catch(() => void 0);
       throw new Error(`Loop "${loopId}" is corrupt and was quarantined: ${message(error)}`);
     }
@@ -14265,7 +14419,7 @@ function createSkillResourceTool(registry) {
 import { constants as constants5 } from "fs";
 import { lstat as lstat9, mkdir as mkdir14, open as open8, readFile as readFile16, readdir as readdir6, realpath as realpath7, rename as rename6, rm as rm6, stat as stat6 } from "fs/promises";
 import { basename as basename3, dirname as dirname15, join as join19, relative as relative13, resolve as resolve18, sep as sep13 } from "path";
-import { randomUUID as randomUUID11 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
 import { z as z22 } from "zod";
 var SESSION_VERSION = 4;
 var DEFAULT_MAX_SESSION_BYTES = 5 * 1024 * 1024;
@@ -14423,7 +14577,7 @@ var SessionStore = class {
     const body = `${lines.join("\n")}
 `;
     if (Buffer.byteLength(body) > this.#maxBytes) throw new Error(`Session exceeds maximum size of ${this.#maxBytes} bytes`);
-    const temporary = join19(this.#sessions, `.${document.sessionId}.${process.pid}.${randomUUID11()}.tmp`);
+    const temporary = join19(this.#sessions, `.${document.sessionId}.${process.pid}.${randomUUID12()}.tmp`);
     let handle;
     try {
       handle = await open8(temporary, constants5.O_CREAT | constants5.O_EXCL | constants5.O_WRONLY, 384);
@@ -14579,7 +14733,7 @@ var SessionStore = class {
     if (!isWithin5(canonicalRoot, canonicalSessions)) throw new Error("Session directory escapes the workspace");
   }
   async #quarantine(path) {
-    const target = `${path}.corrupt-${Date.now()}-${randomUUID11().slice(0, 8)}`;
+    const target = `${path}.corrupt-${Date.now()}-${randomUUID12().slice(0, 8)}`;
     await rename6(path, target);
     return target;
   }
@@ -14799,7 +14953,7 @@ function sanitize2(input, seen = /* @__PURE__ */ new WeakSet()) {
 
 // src/sleep/organizer.ts
 import { constants as constants6 } from "fs";
-import { randomUUID as randomUUID12 } from "crypto";
+import { randomUUID as randomUUID13 } from "crypto";
 import { lstat as lstat10, mkdir as mkdir15, open as open9, readdir as readdir7, realpath as realpath8, rename as rename7, rm as rm7 } from "fs/promises";
 import { isAbsolute as isAbsolute8, join as join20, relative as relative14, resolve as resolve19, sep as sep14 } from "path";
 import { z as z23 } from "zod";
@@ -14956,7 +15110,7 @@ Previous output was invalid. Repair it and return strict JSON only.`;
     return (await readdir7(this.#sleepDirectory, { withFileTypes: true })).some((entry2) => entry2.isFile() && entry2.name.startsWith(prefix) && entry2.name.endsWith(".md"));
   }
   async #atomicWrite(path, content) {
-    const temporary = join20(this.#sleepDirectory, `.${randomUUID12()}.tmp`);
+    const temporary = join20(this.#sleepDirectory, `.${randomUUID13()}.tmp`);
     let handle;
     try {
       handle = await open9(temporary, constants6.O_CREAT | constants6.O_EXCL | constants6.O_WRONLY, 384);
@@ -15332,7 +15486,7 @@ function computeSessionStats(documents) {
 import { constants as constants7 } from "fs";
 import { mkdir as mkdir16, open as open10, readFile as readFile17, realpath as realpath9, rename as rename8, rm as rm8, stat as stat7 } from "fs/promises";
 import { dirname as dirname16, isAbsolute as isAbsolute9, relative as relative15, resolve as resolve20, sep as sep15 } from "path";
-import { randomUUID as randomUUID13 } from "crypto";
+import { randomUUID as randomUUID14 } from "crypto";
 import { z as z24 } from "zod";
 
 // src/tools/file-diff.ts
@@ -15685,7 +15839,7 @@ function createPathGuard(workspace) {
 async function atomicWrite(path, content, signal, expectedVersion) {
   abortIfNeeded(signal);
   await mkdir16(dirname16(path), { recursive: true });
-  const temporary = `${path}.${randomUUID13()}.tmp`;
+  const temporary = `${path}.${randomUUID14()}.tmp`;
   try {
     const handle = await open10(temporary, constants7.O_CREAT | constants7.O_EXCL | constants7.O_WRONLY, 384);
     try {
@@ -17082,18 +17236,40 @@ function hookAnswersFromUpdatedInput(updatedInput, questions) {
 var QuestionBridge = class {
   #pending;
   #onChange;
-  constructor(onChange) {
+  #relay;
+  #active = false;
+  constructor(onChange, relay) {
     this.#onChange = onChange;
+    this.#relay = relay;
   }
   get pending() {
     return this.#pending?.questions;
   }
   ask(questions, signal) {
-    if (this.#pending !== void 0) return Promise.reject(new Error("A question is already pending"));
+    if (this.#active) return Promise.reject(new Error("A question is already pending"));
     if (signal.aborted) return Promise.reject(signal.reason);
+    this.#active = true;
+    if (this.#relay !== void 0) return this.#askRelayed(questions, signal);
+    return this.#askLocally(questions, signal);
+  }
+  async #askRelayed(questions, signal) {
+    try {
+      const answers = await this.#relay(questions, signal);
+      if (answers !== void 0) {
+        this.#active = false;
+        return answers;
+      }
+      return await this.#askLocally(questions, signal);
+    } catch (error) {
+      this.#active = false;
+      throw error;
+    }
+  }
+  #askLocally(questions, signal) {
     return new Promise((resolve28, reject) => {
       const onAbort = () => {
         this.#pending = void 0;
+        this.#active = false;
         reject(signal.reason instanceof Error ? signal.reason : new Error(String(signal.reason)));
       };
       signal.addEventListener("abort", onAbort, { once: true });
@@ -17102,12 +17278,14 @@ var QuestionBridge = class {
         resolve: (answers) => {
           signal.removeEventListener("abort", onAbort);
           this.#pending = void 0;
+          this.#active = false;
           this.#onChange?.();
           resolve28(answers);
         },
         reject: (error) => {
           signal.removeEventListener("abort", onAbort);
           this.#pending = void 0;
+          this.#active = false;
           this.#onChange?.();
           reject(error);
         }
@@ -17193,7 +17371,7 @@ function createTodoWriteTool() {
 }
 
 // src/tools/managed.ts
-import { randomUUID as randomUUID14 } from "crypto";
+import { randomUUID as randomUUID15 } from "crypto";
 import { link as link2, lstat as lstat11, mkdir as mkdir17, readFile as readFile19, readdir as readdir8, unlink as unlink4, writeFile as writeFile10 } from "fs/promises";
 import { dirname as dirname18, join as join21, resolve as resolve22 } from "path";
 import { z as z31 } from "zod";
@@ -17480,7 +17658,7 @@ ${sourceUrl}`
 }
 async function writeExclusive(path, content) {
   await mkdir17(dirname18(path), { recursive: true });
-  const temporary = `${path}.${randomUUID14()}.tmp`;
+  const temporary = `${path}.${randomUUID15()}.tmp`;
   try {
     await writeFile10(temporary, content, { encoding: "utf8", flag: "wx", mode: 384 });
     await link2(temporary, path);
@@ -19267,7 +19445,7 @@ function relativeDisplay(workspace, filePath) {
 }
 
 // src/jobs/registry.ts
-import { randomUUID as randomUUID15 } from "crypto";
+import { randomUUID as randomUUID16 } from "crypto";
 var JobRegistry = class {
   #jobs = /* @__PURE__ */ new Map();
   #maxOutputChars;
@@ -19281,7 +19459,7 @@ var JobRegistry = class {
   }
   create(input) {
     this.#pruneCompleted();
-    const id = `job-${randomUUID15().slice(0, 12)}`;
+    const id = `job-${randomUUID16().slice(0, 12)}`;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     let settle;
     const done = new Promise((resolve28) => {
@@ -19407,7 +19585,7 @@ function snapshot2(job) {
 }
 
 // src/terminal/service.ts
-import { randomUUID as randomUUID16 } from "crypto";
+import { randomUUID as randomUUID17 } from "crypto";
 import { createRequire as nodeCreateRequire } from "module";
 import { isAbsolute as isAbsolute11, relative as relative19, resolve as resolve25, sep as sep19 } from "path";
 var TerminalService = class {
@@ -19425,7 +19603,7 @@ var TerminalService = class {
   open(input) {
     const cwd = workspacePath(this.#root, input.cwd ?? ".");
     const shell = input.shell ?? defaultShell();
-    const id = `term-${randomUUID16().slice(0, 12)}`;
+    const id = `term-${randomUUID17().slice(0, 12)}`;
     const pty = this.#factory(shell, input.args ?? [], {
       cwd,
       cols: input.columns ?? 100,
@@ -19651,7 +19829,7 @@ function palSocketAddress(options) {
 }
 
 // src/pals/client.ts
-import { randomUUID as randomUUID17 } from "crypto";
+import { randomUUID as randomUUID18 } from "crypto";
 import { Socket as Socket3 } from "net";
 var DEFAULT_REQUEST_TIMEOUT_MS = 5e3;
 var DEFAULT_HEARTBEAT_INTERVAL_MS = 1e4;
@@ -19727,7 +19905,7 @@ var PalClient = class {
     return this.starting;
   }
   async list() {
-    const data2 = await this.request({ version: 1, type: "list", requestId: randomUUID17() });
+    const data2 = await this.request({ version: 1, type: "list", requestId: randomUUID18() });
     return PalPresenceListSchema.parse(data2);
   }
   async rename(alias) {
@@ -19740,38 +19918,38 @@ var PalClient = class {
       throw error;
     }
   }
-  async sendTask(target, message2, messageId = randomUUID17()) {
-    const data2 = await this.request({ version: 1, type: "task", requestId: randomUUID17(), messageId, target, goal: message2 });
+  async sendTask(target, message2, messageId = randomUUID18()) {
+    const data2 = await this.request({ version: 1, type: "task", requestId: randomUUID18(), messageId, target, goal: message2 });
     return DeliveryReceiptSchema.parse(data2);
   }
-  async sendChat(target, message2, messageId = randomUUID17()) {
-    const data2 = await this.request({ version: 1, type: "chat", requestId: randomUUID17(), messageId, target, message: message2 });
+  async sendChat(target, message2, messageId = randomUUID18()) {
+    const data2 = await this.request({ version: 1, type: "chat", requestId: randomUUID18(), messageId, target, message: message2 });
     return DeliveryReceiptSchema.parse(data2);
   }
   async startCoWork(input) {
     const data2 = await this.request({
       version: 1,
       type: "cowork-propose",
-      requestId: randomUUID17(),
-      coWorkId: input.coWorkId ?? randomUUID17(),
+      requestId: randomUUID18(),
+      coWorkId: input.coWorkId ?? randomUUID18(),
       goal: input.goal,
       participants: input.participants
     });
     return CoWorkSnapshotSchema.parse(data2);
   }
   async coWorkAction(action) {
-    const request = { version: 1, requestId: randomUUID17(), ...action };
+    const request = { version: 1, requestId: randomUUID18(), ...action };
     return CoWorkSnapshotSchema.parse(await this.request(request));
   }
   async coWorkStatus(coWorkId) {
-    const data2 = await this.request({ version: 1, type: "cowork-get", requestId: randomUUID17(), coWorkId });
+    const data2 = await this.request({ version: 1, type: "cowork-get", requestId: randomUUID18(), coWorkId });
     return CoWorkSnapshotSchema.parse(data2);
   }
   async integrateCoWork(input) {
     return this.coWorkAction({ type: "cowork-integration", ...input });
   }
   async cancelCoWork(coWorkId, reason) {
-    const data2 = await this.request({ version: 1, type: "cowork-cancel", requestId: randomUUID17(), coWorkId, reason });
+    const data2 = await this.request({ version: 1, type: "cowork-cancel", requestId: randomUUID18(), coWorkId, reason });
     return CoWorkSnapshotSchema.parse(data2);
   }
   subscribe(listener) {
@@ -19783,7 +19961,7 @@ var PalClient = class {
     if (this.registered && this.socket !== void 0) {
       let disconnectTimer;
       await Promise.race([
-        this.request({ version: 1, type: "disconnect", requestId: randomUUID17() }).catch(() => void 0),
+        this.request({ version: 1, type: "disconnect", requestId: randomUUID18() }).catch(() => void 0),
         new Promise((resolve28) => {
           disconnectTimer = setTimeout(resolve28, Math.min(this.requestTimeoutMs, 250));
         })
@@ -19874,7 +20052,7 @@ var PalClient = class {
     const data2 = await this.request({
       version: 1,
       type: "register",
-      requestId: randomUUID17(),
+      requestId: randomUUID18(),
       authToken: this.authToken,
       presence: { version: 1, ...this.registration, connectedAt: now, lastSeenAt: now }
     });
@@ -19986,7 +20164,7 @@ var PalClient = class {
       if (!this.registered) return;
       if (this.heartbeatPending) return;
       this.heartbeatPending = true;
-      void this.request({ version: 1, type: "heartbeat", requestId: randomUUID17() }).catch(() => void 0).finally(() => {
+      void this.request({ version: 1, type: "heartbeat", requestId: randomUUID18() }).catch(() => void 0).finally(() => {
         this.heartbeatPending = false;
       });
     }, this.heartbeatIntervalMs);
@@ -20273,7 +20451,7 @@ var ApprovalBridge = class {
   request(request, signal = new AbortController().signal) {
     if (this.#settle !== void 0) return Promise.resolve("deny");
     if (signal.aborted) return Promise.resolve("deny");
-    this.#pending = { id: randomUUID18(), ...request };
+    this.#pending = { id: randomUUID19(), ...request };
     this.#onChange?.();
     return new Promise((resolvePromise) => {
       this.#settle = resolvePromise;
@@ -20392,7 +20570,14 @@ async function createProductionRuntime(options) {
     environment.OPENAI_API_KEY,
     environment.ANTHROPIC_API_KEY
   ].filter((value) => typeof value === "string" && value.length > 0);
-  const hooks = new HookBus();
+  let hookSessionId;
+  const hooks = new HookBus({
+    eventContext: () => ({
+      protocolVersion: 2,
+      workspace,
+      ...hookSessionId === void 0 ? {} : { sessionId: hookSessionId }
+    })
+  });
   hooks.on(
     "PostToolUseFailure",
     createIncidentReporter({
@@ -20412,8 +20597,7 @@ async function createProductionRuntime(options) {
   diagnostics.push(...permissionPolicy.diagnostics);
   const approvals = new ApprovalBridge(options.onApprovalChange);
   const resolveToolApproval = options.approvalPolicy === "deny" && options.rpcToolApprovals !== true ? () => "deny" : (request, signal) => approvals.request(request, signal);
-  const questions = new QuestionBridge(options.onApprovalChange);
-  const askUserQuestionHandler = async (qs, signal) => {
+  const relayQuestions = async (qs, signal) => {
     if (options.approvalPolicy === "deny") throw new Error("AskUserQuestion is not available in non-interactive mode");
     if (hooks.hasListeners("PermissionRequest")) {
       let decision;
@@ -20431,8 +20615,10 @@ async function createProductionRuntime(options) {
       const hookAnswers = hookAnswersFromUpdatedInput(decision.updatedInput, qs);
       if (hookAnswers !== void 0) return hookAnswers;
     }
-    return questions.ask(qs, signal);
+    return void 0;
   };
+  const questions = new QuestionBridge(options.onApprovalChange, relayQuestions);
+  const askUserQuestionHandler = (qs, signal) => questions.ask(qs, signal);
   const executionEnvironment = createExecutionEnvironment(workspace, config.execution);
   const jobs = new JobRegistry();
   const terminals = new TerminalService(workspace, { jobs });
@@ -20756,7 +20942,8 @@ async function createProductionRuntime(options) {
     let taskResults = { ...recovered?.tasks.results ?? {} };
     const subagentStartedAt = {};
     const subagentElapsedMs = {};
-    let sessionId = recovered?.sessionId ?? `session-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "").slice(0, 17)}-${randomUUID18().slice(0, 8)}`;
+    let sessionId = recovered?.sessionId ?? `session-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "").slice(0, 17)}-${randomUUID19().slice(0, 8)}`;
+    hookSessionId = sessionId;
     let harnessJournal = new HarnessJournal({ workspace, sessionId });
     const harnessRecovery = harnessJournal.recover();
     if (harnessRecovery.queue.length > 0 || harnessRecovery.incompleteTools.length > 0 || harnessRecovery.incompleteModelIds.length > 0 || harnessRecovery.interruptedTurnIds.length > 0) {
@@ -20840,7 +21027,13 @@ async function createProductionRuntime(options) {
     const publishTaskState = async () => {
       harness.main.context.updateTaskState(serializedTaskState());
       await persist();
-      emitOutput({ type: "tasks", snapshot: taskSnapshot() });
+      const snapshot4 = taskSnapshot();
+      emitOutput({ type: "tasks", snapshot: snapshot4 });
+      await hooks.emit({
+        version: 1,
+        type: "Notification",
+        payload: { kind: "task_snapshot", taskSnapshot: snapshot4 }
+      }).catch(() => void 0);
     };
     for (const tool of createTaskPlanTools({
       getPlan: () => taskPlan,
@@ -21398,7 +21591,7 @@ async function createProductionRuntime(options) {
         return answers[0] === "Continue" ? "approved" : "rejected";
       },
       fingerprint: workspaceFingerprint,
-      idFactory: () => `loop-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "").slice(0, 17)}-${randomUUID18().slice(0, 8)}`
+      idFactory: () => `loop-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "").slice(0, 17)}-${randomUUID19().slice(0, 8)}`
     });
     const goalStore = new GoalStore({ workspace });
     const goalOrchestrator = new GoalOrchestrator({
@@ -21417,7 +21610,7 @@ async function createProductionRuntime(options) {
         executionEnvironment
       ),
       now: () => (/* @__PURE__ */ new Date()).toISOString(),
-      idFactory: () => `goal-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "").slice(0, 17)}-${randomUUID18().slice(0, 8)}`,
+      idFactory: () => `goal-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "").slice(0, 17)}-${randomUUID19().slice(0, 8)}`,
       runWorker: ({ workspace: goalWorkspace, prompt, signal }) => runLoopWorker({ workspace: goalWorkspace, prompt, signal })
     });
     let sessionHistory = await SessionHistory.open({
@@ -21530,7 +21723,7 @@ async function createProductionRuntime(options) {
         runExplicitSkill(harness, skills, skill, prompt, signal, selectedModels.mainError),
         persist
       ),
-      runLoop: (goal, signal) => runLoopSession(loopOrchestrator, goal, signal),
+      runLoop: (goal, signal) => runLoopSession(loopOrchestrator, hooks, goal, signal),
       runGoal: (goal, signal) => persistEach(runGoalSession(goalOrchestrator, goal, signal), persist),
       mcp: async (command, signal) => {
         signal.throwIfAborted();
@@ -21688,7 +21881,8 @@ ${summary2}`;
         for (const key of Object.keys(subagentStartedAt)) delete subagentStartedAt[key];
         for (const key of Object.keys(subagentElapsedMs)) delete subagentElapsedMs[key];
         const previousIdeSessionId = ideSessionId;
-        sessionId = `session-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "").slice(0, 17)}-${randomUUID18().slice(0, 8)}`;
+        sessionId = `session-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "").slice(0, 17)}-${randomUUID19().slice(0, 8)}`;
+        hookSessionId = sessionId;
         harnessJournal = new HarnessJournal({ workspace, sessionId });
         setUsageSession(sessionId);
         ideSessionId = sessionId;
@@ -21987,9 +22181,10 @@ function formatMcpReconnect(server) {
   if (server.status === "disabled") return `MCP server "${server.name}" is disabled. Enable it before reconnecting.`;
   return `Failed to reconnect MCP server "${server.name}": ${server.error ?? "unknown error"}`;
 }
-async function* runLoopSession(orchestrator, goal, signal) {
+async function* runLoopSession(orchestrator, hooks, goal, signal) {
   let totalInputTokens = 0;
   let totalOutputTokens = 0;
+  let latestVerification;
   for await (const event of orchestrator.run({ goal, signal })) {
     if (event.type === "worker-event") {
       if (event.event.type === "usage") {
@@ -22003,8 +22198,19 @@ async function* runLoopSession(orchestrator, goal, signal) {
       } else if (event.event.type !== "done") yield event.event;
       continue;
     }
+    if (event.type === "loop-verification") latestVerification = event.evidence;
     yield loopProgressEvent(event);
     if (event.type === "loop-terminal") {
+      await hooks.emit({
+        version: 1,
+        type: "LoopEnd",
+        payload: {
+          loopId: event.loopId,
+          outcome: event.status,
+          reason: event.reason,
+          verification: latestVerification ?? null
+        }
+      }).catch(() => void 0);
       yield { type: "done", usage: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens } };
     }
   }
@@ -22718,7 +22924,7 @@ function memoryTranscriptHash(messages) {
   return createHash17("sha256").update(visible, "utf8").digest("hex");
 }
 function createMemoryTaskId() {
-  return `memory-${randomUUID18()}`;
+  return `memory-${randomUUID19()}`;
 }
 
 export {