flavor-code 1.3.3 → 1.3.6

package/dist/desktop/main.js

@@ -1,6 +1,6 @@
 // src/desktop/main.ts
 import { appendFileSync } from "fs";
-import { createHash as createHash27, randomUUID as randomUUID27 } from "crypto";
+import { createHash as createHash27, randomUUID as randomUUID28 } from "crypto";
 import { readFile as readFile39, stat as stat18, writeFile as writeFile19 } from "fs/promises";
 import { basename as basename11, dirname as dirname24, join as join46, resolve as resolve40 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -4218,7 +4218,7 @@ ${summarizeReport(report2)}`).join("\n\n")
 
 // src/production.ts
 import { readFile as readFile27 } from "fs/promises";
-import { createHash as createHash20, randomUUID as randomUUID23 } from "crypto";
+import { createHash as createHash20, randomUUID as randomUUID24 } from "crypto";
 import { homedir as homedir2, release as osRelease, tmpdir as tmpdir3, version as osVersion } from "os";
 import { basename as basename8, join as join31, relative as relative23, resolve as resolve32, sep as sep23 } from "path";
 
@@ -7524,11 +7524,18 @@ var DEFAULT_TOOL_OUTPUT_LIMITS = Object.freeze({
   perTurnChars: 2e5
 });
 var PreToolUsePayload = z14.object({
+  // Optional for backwards-compatible hook updatedInput payloads; runtime
+  // emissions always populate it.
+  toolCallId: z14.string().optional(),
   tool: z14.string(),
   input: z14.unknown(),
   agent: z14.enum(["main", "subagent"])
 });
-var PermissionRequestPayload = PreToolUsePayload.extend({ reason: z14.string().optional() });
+var PermissionRequestPayload = PreToolUsePayload.extend({
+  reason: z14.string().optional(),
+  toolCategory: z14.string(),
+  allowAlways: z14.boolean()
+});
 var PostToolUsePayload = PreToolUsePayload.extend({ output: z14.unknown() });
 var PostToolUseFailurePayload = PreToolUsePayload.extend({
   error: z14.object({ code: z14.string(), message: z14.string() })
@@ -7645,30 +7652,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,
@@ -7679,13 +7687,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 {
@@ -7702,13 +7710,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 ?? "";
@@ -7717,18 +7733,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);
@@ -7742,7 +7758,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);
@@ -7753,7 +7769,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,
@@ -7763,7 +7779,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) {
@@ -7811,13 +7827,13 @@ var ToolRuntime = class {
     const limited = await this.#limitOutput(tool, content);
     return typeof limited === "string" ? limited : serializeToolOutput(limited);
   }
-  async #fail(tool, input, agent, code, errorMessage3) {
+  async #fail(toolCallId, tool, input, agent, code, errorMessage3) {
     const result = { ok: false, error: { code, message: errorMessage3 } };
     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 {
     }
@@ -8025,7 +8041,7 @@ function toModelTool(tool) {
 
 // src/harness/journal.ts
 import { createHash as createHash6, randomUUID as randomUUID8 } from "crypto";
-import { closeSync, constants as constants2, existsSync as existsSync2, fsyncSync, mkdirSync, openSync, readFileSync, realpathSync as realpathSync2, statSync, truncateSync, writeSync } from "fs";
+import { closeSync, constants as constants2, existsSync as existsSync2, fsyncSync, mkdirSync, openSync, readFileSync, realpathSync as realpathSync2, renameSync, statSync, truncateSync, unlinkSync, writeSync } from "fs";
 import { join as join8, relative as relative6, resolve as resolve8, sep as sep6 } from "path";
 import { z as z15 } from "zod";
 
@@ -8036,8 +8052,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((record3, index) => {
-    if (record3.sequence !== index + 1) violations.push(`sequence ${record3.sequence} is not ${index + 1}`);
+    const expectedSequence = firstSequence + index;
+    if (record3.sequence !== expectedSequence) violations.push(`sequence ${record3.sequence} is not ${expectedSequence}`);
     const id = typeof record3.payload.id === "string" ? record3.payload.id : "";
     if (record3.type === "queue.admitted") {
       if (queues.has(id)) violations.push(`queue ${id} was admitted twice`);
@@ -8053,13 +8071,13 @@ function harnessInvariantViolations(records) {
       if (!tools.delete(id)) violations.push(`${record3.type} references unknown tool ${id}`);
     } else if (record3.type === "model.requested") {
       if (models.has(id)) violations.push(`model ${id} was requested twice`);
-      if (!Array.isArray(record3.payload.messages)) violations.push(`model ${id} has no replayable messages`);
+      if (!isHash(record3.payload.messagesHash)) violations.push(`model ${id} has no valid messages hash`);
       models.add(id);
     } else if (record3.type === "model.completed") {
       if (!models.delete(id)) violations.push(`model.completed references unknown model ${id}`);
     } else if (record3.type === "turn.started") {
       if (turns.has(id)) violations.push(`turn ${id} was started twice`);
-      if (!("prompt" in record3.payload)) violations.push(`turn ${id} has no replayable prompt`);
+      if (!isHash(record3.payload.promptHash)) violations.push(`turn ${id} has no valid prompt hash`);
       turns.add(id);
     } else if (record3.type === "turn.completed" || record3.type === "turn.interrupted") {
       if (!turns.delete(id)) violations.push(`${record3.type} references unknown turn ${id}`);
@@ -8067,6 +8085,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("; ")}`);
@@ -8147,7 +8168,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) {
@@ -8158,7 +8179,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) {
@@ -8166,11 +8194,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 });
@@ -8247,47 +8275,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 record3 = JournalRecordSchema.parse(JSON.parse(line));
-      if (record3.sequence !== this.#records.length + 1) throw new Error("Harness journal sequence is not contiguous");
+      expectedSequence ??= record3.sequence;
+      previousHash ??= record3.previousHash;
+      if (record3.sequence !== expectedSequence) throw new Error("Harness journal sequence is not contiguous");
       if (record3.previousHash !== previousHash) throw new Error("Harness journal hash chain is broken");
       if (record3.hash !== recordHash(record3)) throw new Error("Harness journal record hash is invalid");
       this.#records.push(record3);
       previousHash = record3.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 record3 = this.#createRecord(type, normalizedPayload);
+    let line = `${JSON.stringify(record3)}
+`;
+    let priorBytes = existsSync2(this.#path) ? statSync(this.#path).size : 0;
+    if (priorBytes + Buffer.byteLength(line) > this.#maxBytes) {
+      this.#compact();
+      record3 = this.#createRecord(type, normalizedPayload);
+      line = `${JSON.stringify(record3)}
+`;
+      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, constants2.O_CREAT | constants2.O_APPEND | constants2.O_WRONLY, 384);
+    try {
+      writeSync(fd, line, void 0, "utf8");
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+    this.#records.push(record3);
+    this.#sequence = record3.sequence;
+    this.#lastHash = record3.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 record3 = JournalRecordSchema.parse({ ...unsigned, hash: hashJson(unsigned) });
-    const line = `${JSON.stringify(record3)}
-`;
-    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, constants2.O_CREAT | constants2.O_APPEND | constants2.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 record3 of this.#records) {
+      const id = typeof record3.payload.id === "string" ? record3.payload.id : "";
+      if (record3.type === "queue.admitted") queues.set(id, record3);
+      else if (record3.type === "queue.claimed") claims.set(id, record3);
+      else if (record3.type === "queue.released") claims.delete(id);
+      else if (record3.type === "queue.acked") {
+        queues.delete(id);
+        claims.delete(id);
+      } else if (record3.type === "tool.started") tools.set(id, record3);
+      else if (record3.type === "tool.completed" || record3.type === "tool.interrupted") tools.delete(id);
+      else if (record3.type === "model.requested") models.set(id, record3);
+      else if (record3.type === "model.completed") models.delete(id);
+      else if (record3.type === "turn.started") turns.set(id, record3);
+      else if (record3.type === "turn.completed" || record3.type === "turn.interrupted") turns.delete(id);
+      else if (record3.type === "savepoint.created") savepoint = record3;
+    }
+    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 record3 = JournalRecordSchema.parse({ ...unsigned, hash: hashJson(unsigned) });
+      compacted.push(record3);
+      previousHash = record3.hash;
+    }
+    const contents = compacted.map((record3) => `${JSON.stringify(record3)}
+`).join("");
+    if (Buffer.byteLength(contents) > this.#maxBytes) return;
+    const temporary = `${this.#path}.compact-${process.pid}-${randomUUID8()}`;
+    const fd = openSync(temporary, constants2.O_CREAT | constants2.O_EXCL | constants2.O_WRONLY, 384);
     try {
-      writeSync(fd, line, void 0, "utf8");
+      writeSync(fd, contents, void 0, "utf8");
       fsyncSync(fd);
     } finally {
       closeSync(fd);
     }
-    this.#records.push(record3);
-    this.#sequence = record3.sequence;
-    this.#lastHash = record3.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(record3) {
+  const payload = record3.payload;
+  if (record3.type === "queue.admitted") return payload;
+  if (record3.type === "queue.claimed") return { id: payload.id };
+  if (record3.type === "tool.started") return pick(payload, ["id", "tool", "inputHash", "retrySafe"]);
+  if (record3.type === "model.requested") return pick(payload, ["id", "agent", "model", "iteration", "attempt", "messagesHash"]);
+  if (record3.type === "turn.started") return pick(payload, ["id", "configHash", "promptHash"]);
+  if (record3.type === "savepoint.created") return pick(payload, ["id", "phase", "configHash"]);
+  return payload;
+}
+function hasLegacyPayload(record3) {
+  if (record3.type === "turn.started") return "config" in record3.payload || "prompt" in record3.payload;
+  if (record3.type === "model.requested") return "messages" in record3.payload;
+  if (record3.type === "tool.started") return "input" in record3.payload;
+  if (record3.type === "tool.completed") return "result" in record3.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);
@@ -8320,6 +8454,7 @@ function isWithin2(root, target) {
 
 // src/hooks/bus.ts
 import { spawn } from "child_process";
+import { randomUUID as randomUUID9 } from "crypto";
 
 // src/hooks/types.ts
 import { z as z16 } from "zod";
@@ -8386,6 +8521,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 };
@@ -8422,7 +8562,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();
@@ -8437,8 +8579,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 = {
@@ -8455,6 +8597,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]);
@@ -8466,6 +8617,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((resolve41, reject) => {
     const child = spawn(descriptor.command, [...descriptor.args ?? []], {
@@ -11862,7 +12016,7 @@ function formatPriorGaps(gaps) {
 
 // src/goal/store.ts
 import { constants as constants3 } from "fs";
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 import { lstat as lstat5, mkdir as mkdir11, open as open5, rename as rename4, rm as rm6 } from "fs/promises";
 import { dirname as dirname10, join as join15, relative as relative9, resolve as resolve11, sep as sep9 } from "path";
 var DEFAULT_MAX_BYTES = 1024 * 1024;
@@ -11886,7 +12040,7 @@ var GoalStore = class {
     if (Buffer.byteLength(body) > this.#maxBytes) {
       throw new Error(`Goal state exceeds maximum size of ${this.#maxBytes} bytes`);
     }
-    const temporary = join15(this.#root, `.${state.id}.${process.pid}.${randomUUID9()}.tmp`);
+    const temporary = join15(this.#root, `.${state.id}.${process.pid}.${randomUUID10()}.tmp`);
     let handle;
     try {
       handle = await open5(temporary, constants3.O_CREAT | constants3.O_EXCL | constants3.O_WRONLY, 384);
@@ -11999,7 +12153,7 @@ async function ensureWorktreeDirectoryIgnored(root) {
 import { constants as constants4 } from "fs";
 import { lstat as lstat6, mkdir as mkdir13, open as open6, readFile as readFile12, realpath as realpath8, rename as rename5, rm as rm7, stat as stat6 } from "fs/promises";
 import { dirname as dirname11, join as join17, 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 {
@@ -12030,7 +12184,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 = join17(directory, `.state.${process.pid}.${randomUUID10()}.tmp`);
+    const temporary = join17(directory, `.state.${process.pid}.${randomUUID11()}.tmp`);
     let handle;
     try {
       handle = await open6(temporary, constants4.O_CREAT | constants4.O_EXCL | constants4.O_WRONLY, 384);
@@ -12056,7 +12210,7 @@ var LoopStore = class {
       return state;
     } catch (error) {
       if (isCode5(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)}`);
     }
@@ -14915,7 +15069,7 @@ function createSkillResourceTool(registry) {
 import { constants as constants6 } from "fs";
 import { lstat as lstat8, mkdir as mkdir15, open as open7, readFile as readFile17, readdir as readdir6, realpath as realpath10, rename as rename6, rm as rm8, stat as stat7 } from "fs/promises";
 import { basename as basename5, dirname as dirname15, join as join22, relative as relative13, resolve as resolve19, sep as sep13 } from "path";
-import { randomUUID as randomUUID11 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
 import { z as z27 } from "zod";
 
 // src/ui/transcript.ts
@@ -15603,7 +15757,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 = join22(this.#sessions, `.${document.sessionId}.${process.pid}.${randomUUID11()}.tmp`);
+    const temporary = join22(this.#sessions, `.${document.sessionId}.${process.pid}.${randomUUID12()}.tmp`);
     let handle;
     try {
       handle = await open7(temporary, constants6.O_CREAT | constants6.O_EXCL | constants6.O_WRONLY, 384);
@@ -15759,7 +15913,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;
   }
@@ -15978,12 +16132,12 @@ function sanitize2(input, seen = /* @__PURE__ */ new WeakSet()) {
 }
 
 // src/session/tree.ts
-import { randomUUID as randomUUID13 } from "crypto";
+import { randomUUID as randomUUID14 } from "crypto";
 import { mkdir as mkdir17, readFile as readFile19, rename as rename8, writeFile as writeFile11 } from "fs/promises";
 import { dirname as dirname17, join as join24, resolve as resolve21 } from "path";
 
 // src/session/checkpoint.ts
-import { createHash as createHash14, randomUUID as randomUUID12 } from "crypto";
+import { createHash as createHash14, randomUUID as randomUUID13 } from "crypto";
 import { execFile as execFile2 } from "child_process";
 import { lstat as lstat9, mkdir as mkdir16, open as open8, readFile as readFile18, readdir as readdir7, rename as rename7, rm as rm9, writeFile as writeFile10 } from "fs/promises";
 import { dirname as dirname16, join as join23, relative as relative14, resolve as resolve20, sep as sep14 } from "path";
@@ -16036,7 +16190,7 @@ var WorkspaceCheckpointStore = class {
     }
     const checkpoint = {
       version: 1,
-      id: `checkpoint-${Date.now()}-${randomUUID12().slice(0, 8)}`,
+      id: `checkpoint-${Date.now()}-${randomUUID13().slice(0, 8)}`,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       ...label === void 0 || label.trim().length === 0 ? {} : { label: label.trim() },
       files
@@ -16073,7 +16227,7 @@ var WorkspaceCheckpointStore = class {
       const target = contained(this.#workspace, file.path);
       const object = objects.get(file.digest);
       await mkdir16(dirname16(target), { recursive: true });
-      const temporary = `${target}.${process.pid}.${randomUUID12()}.tmp`;
+      const temporary = `${target}.${process.pid}.${randomUUID13()}.tmp`;
       await writeFile10(temporary, object, { mode: file.mode });
       await rename7(temporary, target);
     }
@@ -16145,7 +16299,7 @@ function contained(workspace, path) {
 }
 async function atomicJson(path, value) {
   await mkdir16(dirname16(path), { recursive: true });
-  const temporary = `${path}.${process.pid}.${randomUUID12()}.tmp`;
+  const temporary = `${path}.${process.pid}.${randomUUID13()}.tmp`;
   await writeFile10(temporary, `${JSON.stringify(value)}
 `, { encoding: "utf8", mode: 384 });
   await rename7(temporary, path);
@@ -16190,7 +16344,7 @@ var SessionHistory = class _SessionHistory {
   async append(input) {
     const checkpoint = await this.#checkpoints.create(input.label);
     const node = {
-      id: `turn-${Date.now()}-${randomUUID13().slice(0, 8)}`,
+      id: `turn-${Date.now()}-${randomUUID14().slice(0, 8)}`,
       parentId: this.#leafId,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       prompt: input.prompt,
@@ -16248,7 +16402,7 @@ var SessionHistory = class _SessionHistory {
       nodes: this.#nodes
     };
     await mkdir17(dirname17(this.#path), { recursive: true });
-    const temporary = `${this.#path}.${process.pid}.${randomUUID13()}.tmp`;
+    const temporary = `${this.#path}.${process.pid}.${randomUUID14()}.tmp`;
     await writeFile11(temporary, `${JSON.stringify(document)}
 `, { encoding: "utf8", mode: 384 });
     await rename8(temporary, this.#path);
@@ -16274,7 +16428,7 @@ function isCode10(error, code) {
 
 // src/sleep/organizer.ts
 import { constants as constants7 } from "fs";
-import { randomUUID as randomUUID14 } from "crypto";
+import { randomUUID as randomUUID15 } from "crypto";
 import { lstat as lstat10, mkdir as mkdir18, open as open9, readdir as readdir8, realpath as realpath11, rename as rename9, rm as rm10 } from "fs/promises";
 import { isAbsolute as isAbsolute10, join as join25, relative as relative15, resolve as resolve22, sep as sep15 } from "path";
 import { z as z28 } from "zod";
@@ -16431,7 +16585,7 @@ Previous output was invalid. Repair it and return strict JSON only.`;
     return (await readdir8(this.#sleepDirectory, { withFileTypes: true })).some((entry2) => entry2.isFile() && entry2.name.startsWith(prefix) && entry2.name.endsWith(".md"));
   }
   async #atomicWrite(path, content) {
-    const temporary = join25(this.#sleepDirectory, `.${randomUUID14()}.tmp`);
+    const temporary = join25(this.#sleepDirectory, `.${randomUUID15()}.tmp`);
     let handle;
     try {
       handle = await open9(temporary, constants7.O_CREAT | constants7.O_EXCL | constants7.O_WRONLY, 384);
@@ -16807,7 +16961,7 @@ function computeSessionStats(documents) {
 import { constants as constants8 } from "fs";
 import { mkdir as mkdir19, open as open10, readFile as readFile20, realpath as realpath12, rename as rename10, rm as rm11, stat as stat8 } from "fs/promises";
 import { dirname as dirname18, isAbsolute as isAbsolute11, relative as relative16, resolve as resolve23, sep as sep16 } from "path";
-import { randomUUID as randomUUID15 } from "crypto";
+import { randomUUID as randomUUID16 } from "crypto";
 import { z as z29 } from "zod";
 
 // src/tools/file-diff.ts
@@ -17160,7 +17314,7 @@ function createPathGuard(workspace) {
 async function atomicWrite(path, content, signal, expectedVersion) {
   abortIfNeeded(signal);
   await mkdir19(dirname18(path), { recursive: true });
-  const temporary = `${path}.${randomUUID15()}.tmp`;
+  const temporary = `${path}.${randomUUID16()}.tmp`;
   try {
     const handle = await open10(temporary, constants8.O_CREAT | constants8.O_EXCL | constants8.O_WRONLY, 384);
     try {
@@ -19222,18 +19376,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((resolve41, 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 });
@@ -19242,12 +19418,14 @@ var QuestionBridge = class {
         resolve: (answers) => {
           signal.removeEventListener("abort", onAbort);
           this.#pending = void 0;
+          this.#active = false;
           this.#onChange?.();
           resolve41(answers);
         },
         reject: (error) => {
           signal.removeEventListener("abort", onAbort);
           this.#pending = void 0;
+          this.#active = false;
           this.#onChange?.();
           reject(error);
         }
@@ -19333,7 +19511,7 @@ function createTodoWriteTool() {
 }
 
 // src/tools/managed.ts
-import { randomUUID as randomUUID16 } from "crypto";
+import { randomUUID as randomUUID17 } from "crypto";
 import { link, lstat as lstat11, mkdir as mkdir20, readFile as readFile22, readdir as readdir9, unlink as unlink2, writeFile as writeFile12 } from "fs/promises";
 import { dirname as dirname21, join as join26, resolve as resolve26 } from "path";
 import { z as z37 } from "zod";
@@ -19620,7 +19798,7 @@ ${sourceUrl}`
 }
 async function writeExclusive(path, content) {
   await mkdir20(dirname21(path), { recursive: true });
-  const temporary = `${path}.${randomUUID16()}.tmp`;
+  const temporary = `${path}.${randomUUID17()}.tmp`;
   try {
     await writeFile12(temporary, content, { encoding: "utf8", flag: "wx", mode: 384 });
     await link(temporary, path);
@@ -22848,7 +23026,7 @@ function relativeDisplay(workspace, filePath) {
 }
 
 // src/jobs/registry.ts
-import { randomUUID as randomUUID17 } from "crypto";
+import { randomUUID as randomUUID18 } from "crypto";
 var JobRegistry = class {
   #jobs = /* @__PURE__ */ new Map();
   #maxOutputChars;
@@ -22862,7 +23040,7 @@ var JobRegistry = class {
   }
   create(input) {
     this.#pruneCompleted();
-    const id = `job-${randomUUID17().slice(0, 12)}`;
+    const id = `job-${randomUUID18().slice(0, 12)}`;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     let settle;
     const done = new Promise((resolve41) => {
@@ -22988,7 +23166,7 @@ function snapshot2(job) {
 }
 
 // src/terminal/service.ts
-import { randomUUID as randomUUID18 } from "crypto";
+import { randomUUID as randomUUID19 } from "crypto";
 import { createRequire as nodeCreateRequire } from "module";
 import { isAbsolute as isAbsolute14, relative as relative22, resolve as resolve30, sep as sep22 } from "path";
 var TerminalService = class {
@@ -23006,7 +23184,7 @@ var TerminalService = class {
   open(input) {
     const cwd = workspacePath(this.#root, input.cwd ?? ".");
     const shell2 = input.shell ?? defaultShell();
-    const id = `term-${randomUUID18().slice(0, 12)}`;
+    const id = `term-${randomUUID19().slice(0, 12)}`;
     const pty = this.#factory(shell2, input.args ?? [], {
       cwd,
       cols: input.columns ?? 100,
@@ -23239,13 +23417,13 @@ import { join as join30 } from "path";
 import { spawn as spawn7 } from "child_process";
 
 // src/pals/broker.ts
-import { createHash as createHash18, randomUUID as randomUUID21, timingSafeEqual } from "crypto";
+import { createHash as createHash18, randomUUID as randomUUID22, timingSafeEqual } from "crypto";
 import { chmod as chmod2, lstat as lstat12, mkdir as mkdir23, unlink as unlink5 } from "fs/promises";
 import { createServer as createServer3, Socket } from "net";
 import { dirname as dirname23 } from "path";
 
 // src/pals/auth.ts
-import { randomBytes as randomBytes3, randomUUID as randomUUID19 } from "crypto";
+import { randomBytes as randomBytes3, randomUUID as randomUUID20 } from "crypto";
 import { chmod, link as link2, mkdir as mkdir21, open as open12, readFile as readFile25, unlink as unlink3 } from "fs/promises";
 import { homedir } from "os";
 import { join as join29 } from "path";
@@ -23257,7 +23435,7 @@ async function loadOrCreatePalAuthToken(options = {}) {
   await mkdir21(directory, { recursive: true, mode: 448 });
   await chmod(directory, 448);
   const token = (options.random ?? randomBytes3)(PAL_AUTH_TOKEN_BYTES).toString("hex");
-  const temporaryPath = join29(directory, `.auth-token-${process.pid}-${randomUUID19()}.tmp`);
+  const temporaryPath = join29(directory, `.auth-token-${process.pid}-${randomUUID20()}.tmp`);
   let handle;
   try {
     handle = await open12(temporaryPath, "wx", 384);
@@ -23291,7 +23469,7 @@ function validatePalAuthToken(token) {
 }
 
 // src/pals/lifecycle.ts
-import { randomUUID as randomUUID20 } from "crypto";
+import { randomUUID as randomUUID21 } from "crypto";
 import { mkdir as mkdir22, open as open13, readFile as readFile26, rename as rename11, stat as stat11, unlink as unlink4 } from "fs/promises";
 import { dirname as dirname22 } from "path";
 function defaultProcessAlive(pid) {
@@ -23317,7 +23495,7 @@ async function acquirePalFileLock(options) {
   await mkdir22(dirname22(options.path), { recursive: true, mode: 448 });
   const pid = options.pid ?? process.pid;
   const now = options.now ?? Date.now;
-  const nonce = randomUUID20();
+  const nonce = randomUUID21();
   const metadata = { pid, createdAt: now(), nonce };
   let handle;
   try {
@@ -23436,7 +23614,7 @@ async function ensureOnce(options) {
 }
 
 // src/pals/client.ts
-import { randomUUID as randomUUID22 } from "crypto";
+import { randomUUID as randomUUID23 } from "crypto";
 import { Socket as Socket3 } from "net";
 var DEFAULT_REQUEST_TIMEOUT_MS = 5e3;
 var DEFAULT_HEARTBEAT_INTERVAL_MS = 1e4;
@@ -23512,7 +23690,7 @@ var PalClient = class {
     return this.starting;
   }
   async list() {
-    const data2 = await this.request({ version: 1, type: "list", requestId: randomUUID22() });
+    const data2 = await this.request({ version: 1, type: "list", requestId: randomUUID23() });
     return PalPresenceListSchema.parse(data2);
   }
   async rename(alias) {
@@ -23525,38 +23703,38 @@ var PalClient = class {
       throw error;
     }
   }
-  async sendTask(target, message2, messageId = randomUUID22()) {
-    const data2 = await this.request({ version: 1, type: "task", requestId: randomUUID22(), messageId, target, goal: message2 });
+  async sendTask(target, message2, messageId = randomUUID23()) {
+    const data2 = await this.request({ version: 1, type: "task", requestId: randomUUID23(), messageId, target, goal: message2 });
     return DeliveryReceiptSchema.parse(data2);
   }
-  async sendChat(target, message2, messageId = randomUUID22()) {
-    const data2 = await this.request({ version: 1, type: "chat", requestId: randomUUID22(), messageId, target, message: message2 });
+  async sendChat(target, message2, messageId = randomUUID23()) {
+    const data2 = await this.request({ version: 1, type: "chat", requestId: randomUUID23(), messageId, target, message: message2 });
     return DeliveryReceiptSchema.parse(data2);
   }
   async startCoWork(input) {
     const data2 = await this.request({
       version: 1,
       type: "cowork-propose",
-      requestId: randomUUID22(),
-      coWorkId: input.coWorkId ?? randomUUID22(),
+      requestId: randomUUID23(),
+      coWorkId: input.coWorkId ?? randomUUID23(),
       goal: input.goal,
       participants: input.participants
     });
     return CoWorkSnapshotSchema.parse(data2);
   }
   async coWorkAction(action) {
-    const request = { version: 1, requestId: randomUUID22(), ...action };
+    const request = { version: 1, requestId: randomUUID23(), ...action };
     return CoWorkSnapshotSchema.parse(await this.request(request));
   }
   async coWorkStatus(coWorkId) {
-    const data2 = await this.request({ version: 1, type: "cowork-get", requestId: randomUUID22(), coWorkId });
+    const data2 = await this.request({ version: 1, type: "cowork-get", requestId: randomUUID23(), 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: randomUUID22(), coWorkId, reason });
+    const data2 = await this.request({ version: 1, type: "cowork-cancel", requestId: randomUUID23(), coWorkId, reason });
     return CoWorkSnapshotSchema.parse(data2);
   }
   subscribe(listener) {
@@ -23568,7 +23746,7 @@ var PalClient = class {
     if (this.registered && this.socket !== void 0) {
       let disconnectTimer;
       await Promise.race([
-        this.request({ version: 1, type: "disconnect", requestId: randomUUID22() }).catch(() => void 0),
+        this.request({ version: 1, type: "disconnect", requestId: randomUUID23() }).catch(() => void 0),
         new Promise((resolve41) => {
           disconnectTimer = setTimeout(resolve41, Math.min(this.requestTimeoutMs, 250));
         })
@@ -23659,7 +23837,7 @@ var PalClient = class {
     const data2 = await this.request({
       version: 1,
       type: "register",
-      requestId: randomUUID22(),
+      requestId: randomUUID23(),
       authToken: this.authToken,
       presence: { version: 1, ...this.registration, connectedAt: now, lastSeenAt: now }
     });
@@ -23771,7 +23949,7 @@ var PalClient = class {
       if (!this.registered) return;
       if (this.heartbeatPending) return;
       this.heartbeatPending = true;
-      void this.request({ version: 1, type: "heartbeat", requestId: randomUUID22() }).catch(() => void 0).finally(() => {
+      void this.request({ version: 1, type: "heartbeat", requestId: randomUUID23() }).catch(() => void 0).finally(() => {
         this.heartbeatPending = false;
       });
     }, this.heartbeatIntervalMs);
@@ -24058,7 +24236,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: randomUUID23(), ...request };
+    this.#pending = { id: randomUUID24(), ...request };
     this.#onChange?.();
     return new Promise((resolvePromise) => {
       this.#settle = resolvePromise;
@@ -24177,7 +24355,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({
@@ -24197,8 +24382,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;
@@ -24216,8 +24400,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 });
@@ -24541,7 +24727,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)}-${randomUUID23().slice(0, 8)}`;
+    let sessionId = recovered?.sessionId ?? `session-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "").slice(0, 17)}-${randomUUID24().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) {
@@ -24625,7 +24812,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,
@@ -25183,7 +25376,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)}-${randomUUID23().slice(0, 8)}`
+      idFactory: () => `loop-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "").slice(0, 17)}-${randomUUID24().slice(0, 8)}`
     });
     const goalStore = new GoalStore({ workspace });
     const goalOrchestrator = new GoalOrchestrator({
@@ -25202,7 +25395,7 @@ async function createProductionRuntime(options) {
         executionEnvironment
       ),
       now: () => (/* @__PURE__ */ new Date()).toISOString(),
-      idFactory: () => `goal-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "").slice(0, 17)}-${randomUUID23().slice(0, 8)}`,
+      idFactory: () => `goal-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "").slice(0, 17)}-${randomUUID24().slice(0, 8)}`,
       runWorker: ({ workspace: goalWorkspace, prompt, signal }) => runLoopWorker({ workspace: goalWorkspace, prompt, signal })
     });
     let sessionHistory = await SessionHistory.open({
@@ -25315,7 +25508,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();
@@ -25473,7 +25666,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)}-${randomUUID23().slice(0, 8)}`;
+        sessionId = `session-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "").slice(0, 17)}-${randomUUID24().slice(0, 8)}`;
+        hookSessionId = sessionId;
         harnessJournal = new HarnessJournal({ workspace, sessionId });
         setUsageSession(sessionId);
         ideSessionId = sessionId;
@@ -25772,9 +25966,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") {
@@ -25788,8 +25983,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 } };
     }
   }
@@ -26503,7 +26709,7 @@ function memoryTranscriptHash(messages) {
   return createHash20("sha256").update(visible, "utf8").digest("hex");
 }
 function createMemoryTaskId() {
-  return `memory-${randomUUID23()}`;
+  return `memory-${randomUUID24()}`;
 }
 
 // src/desktop/runtime-controller.ts
@@ -27487,13 +27693,13 @@ ${managed.output().slice(-4e3)}`);
 }
 
 // src/d2c/product.ts
-import { createHash as createHash23, randomUUID as randomUUID25 } from "crypto";
+import { createHash as createHash23, randomUUID as randomUUID26 } from "crypto";
 import { copyFile as copyFile2, mkdir as mkdir25, readFile as readFile32, rename as rename13, stat as stat12, unlink as unlink6, writeFile as writeFile15 } from "fs/promises";
 import { join as join36 } from "path";
 import { z as z44 } from "zod";
 
 // src/e2e/prd-governance.ts
-import { createHash as createHash22, randomUUID as randomUUID24 } from "crypto";
+import { createHash as createHash22, randomUUID as randomUUID25 } from "crypto";
 import { readFile as readFile31, rename as rename12, rm as rm13, writeFile as writeFile14 } from "fs/promises";
 function hashPrd(markdown) {
   return createHash22("sha256").update(markdown, "utf8").digest("hex");
@@ -27593,7 +27799,7 @@ ${body}
 
 `;
   const markdown = `${current.slice(0, section.contentStart)}${replacement}${current.slice(section.contentEnd)}`;
-  const temporary = `${path}.${process.pid}.${randomUUID24()}.tmp`;
+  const temporary = `${path}.${process.pid}.${randomUUID25()}.tmp`;
   try {
     await writeFile14(temporary, markdown, { encoding: "utf8", flag: "wx", mode: 384 });
     await rename12(temporary, path);
@@ -27793,7 +27999,7 @@ async function writeD2cProductPlan(workspace, plan, operations = defaultPlanFile
   const target = planPath(workspace, parsed.task);
   await serializePlanWrite(target, async () => {
     await mkdir25(taskDir(workspace, parsed.task), { recursive: true });
-    const temporary = `${target}.${process.pid}.${randomUUID25()}.tmp`;
+    const temporary = `${target}.${process.pid}.${randomUUID26()}.tmp`;
     await writeFile15(temporary, `${JSON.stringify(parsed, null, 2)}
 `, { encoding: "utf8", mode: 384 });
     await replaceD2cProductPlanFile(temporary, target, operations);
@@ -30246,7 +30452,7 @@ function safeGitTarget(value) {
 }
 
 // src/desktop/worktree-manager.ts
-import { randomUUID as randomUUID26 } from "crypto";
+import { randomUUID as randomUUID27 } from "crypto";
 import { mkdir as mkdir28, readFile as readFile37, readdir as readdir13, rm as rm17, stat as stat15, writeFile as writeFile18 } from "fs/promises";
 import { basename as basename10, isAbsolute as isAbsolute19, join as join43, relative as relative27, resolve as resolve37, sep as sep27 } from "path";
 var DesktopWorktreeManager = class {
@@ -30259,7 +30465,7 @@ var DesktopWorktreeManager = class {
   async create(label) {
     if (!await isGitRepository(this.#repository)) throw new Error("Task worktrees require a Git repository");
     const safe = label.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 36) || "task";
-    const suffix = randomUUID26().slice(0, 8);
+    const suffix = randomUUID27().slice(0, 8);
     const id = `worktree-${safe}-${suffix}`;
     const branch = `flavor/desktop-${safe}-${suffix}`;
     const path = this.#safeStoragePath(id);
@@ -30723,7 +30929,7 @@ function emitManagedDesktopEvent(workspace, owner2, event) {
   }
 }
 function createDesktopController(workspace, owner2) {
-  const collaborationId = randomUUID27();
+  const collaborationId = randomUUID28();
   return new DesktopRuntimeController({
     emit: (event) => emitManagedDesktopEvent(workspace, owner2, event),
     runD2cInteractionTests: (manifest, baseUrl, mockUrl) => d2cEmbedded.run(manifest, baseUrl, mockUrl),