flavor-code 1.3.4 → 1.3.7

package/dist/{chunk-YKSMZDUZ.js → chunk-K2AOT2BI.js}

@@ -3517,6 +3517,8 @@ var FlavorSession = class {
     this.#activeSubmission = submission;
     this.#interrupted = false;
     let outcome = "completed";
+    let assistantSummary = "";
+    let deliverables = [];
     try {
       const decision = await this.#services.hooks.emit({
         version: 1,
@@ -3543,6 +3545,8 @@ var FlavorSession = class {
         ...submission.initialUserMessage === void 0 ? {} : { initialUserMessage: submission.initialUserMessage }
       })) {
         this.#services.output(event);
+        if (event.type === "text") assistantSummary = `${assistantSummary}${event.text}`.slice(-2e3);
+        if (event.type === "deliverables") deliverables = event.files.slice(0, 100);
         if (event.type === "error") outcome = "failed";
       }
       if (controller.signal.aborted) outcome = "cancelled";
@@ -3567,7 +3571,15 @@ var FlavorSession = class {
         this.#activeSubmission = void 0;
         if (submission.coWorkPlanningKey !== void 0) this.#finishActivePlanning(submission.coWorkPlanningKey);
         try {
-          await this.#services.hooks.emit({ version: 1, type: "Stop", payload: { outcome } });
+          await this.#services.hooks.emit({
+            version: 1,
+            type: "Stop",
+            payload: {
+              outcome,
+              ...assistantSummary.trim() ? { summary: assistantSummary.trim() } : {},
+              ...deliverables.length === 0 ? {} : { deliverables }
+            }
+          });
         } catch (error) {
           try {
             this.#services.output({ type: "error", error: { code: "unknown", message: message(error) } });
@@ -5006,9 +5018,9 @@ async function ensureOnce(options) {
 
 // src/production.ts
 import { readFile as readFile22 } from "fs/promises";
-import { createHash as createHash17, randomUUID as randomUUID18 } 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";
+import { createHash as createHash18, randomUUID as randomUUID20 } from "crypto";
+import { homedir as homedir2, release as osRelease, tmpdir as tmpdir4, version as osVersion } from "os";
+import { basename as basename6, join as join25, relative as relative20, resolve as resolve27, sep as sep20 } from "path";
 
 // src/agent/subagents.ts
 import { z as z5 } from "zod";
@@ -6973,6 +6985,7 @@ var AgentLoop = class {
           attempt,
           messages: modelRequest.messages
         });
+        const modelStartedAt = Date.now();
         yield { type: "model-start", id: modelCallId };
         try {
           for await (const event of adapter.stream(modelRequest)) {
@@ -7031,6 +7044,13 @@ var AgentLoop = class {
                 completed,
                 agent: this.#options.agent,
                 providerError,
+                durationMs: Math.max(0, Date.now() - modelStartedAt),
+                ...usage === void 0 ? {} : {
+                  inputTokens: usage.inputTokens,
+                  outputTokens: usage.outputTokens,
+                  ...usage.cacheReadTokens === void 0 ? {} : { cacheReadTokens: usage.cacheReadTokens },
+                  ...usage.cacheCreationTokens === void 0 ? {} : { cacheCreationTokens: usage.cacheCreationTokens }
+                },
                 ...terminalError === void 0 ? {} : {
                   errorCode: terminalError.code,
                   errorMessage: terminalError.message
@@ -7484,11 +7504,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 +7632,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 +7667,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 +7690,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 +7713,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 +7738,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 +7749,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 +7759,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 +7807,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 {
     }
@@ -8398,6 +8434,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";
@@ -8464,6 +8501,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 };
@@ -8500,7 +8542,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();
@@ -8515,8 +8559,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 = {
@@ -8533,6 +8577,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]);
@@ -8544,6 +8597,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 ?? []], {
@@ -8736,19 +8792,155 @@ function createIncidentReporter(options) {
   };
 }
 
+// src/island/control-server.ts
+import { createHash as createHash7, randomUUID as randomUUID10 } from "crypto";
+import { chmod as chmod3, unlink as unlink4 } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join9 } from "path";
+import { createServer as createServer2 } from "net";
+var MAX_REQUEST_BYTES = 64 * 1024;
+var SOCKET_TIMEOUT_MS = 1e4;
+function islandControlEndpoint(sessionId, platform = process.platform) {
+  const digest = createHash7("sha256").update(`${process.pid}\0${sessionId}`).digest("hex").slice(0, 20);
+  if (platform === "win32") return `\\\\.\\pipe\\flavor-island-control-${digest}`;
+  const uid = typeof process.getuid === "function" ? process.getuid() : 0;
+  return join9(tmpdir2(), `flavor-island-control-${uid}-${digest}.sock`);
+}
+async function createIslandControlServer(options) {
+  const platform = options.platform ?? process.platform;
+  const endpoint = options.endpoint ?? islandControlEndpoint(options.sessionId, platform);
+  const token = options.token ?? randomUUID10();
+  const capabilities = [
+    "abort",
+    "steer",
+    "follow_up",
+    ...options.focus === void 0 ? [] : ["focus"]
+  ];
+  if (platform !== "win32") await unlink4(endpoint).catch(() => void 0);
+  const sockets = /* @__PURE__ */ new Set();
+  const server = createServer2((socket) => {
+    sockets.add(socket);
+    socket.setTimeout(SOCKET_TIMEOUT_MS, () => socket.destroy());
+    socket.on("close", () => sockets.delete(socket));
+    socket.on("error", () => void 0);
+    let buffer = Buffer.alloc(0);
+    let handled = false;
+    socket.on("data", (chunk) => {
+      if (handled) return;
+      const bytes = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+      if (buffer.length + bytes.length > MAX_REQUEST_BYTES) {
+        handled = true;
+        write(socket, { ok: false, error: "request_too_large" });
+        return;
+      }
+      buffer = Buffer.concat([buffer, bytes]);
+      const newline = buffer.indexOf(10);
+      if (newline < 0) return;
+      handled = true;
+      const line = buffer.subarray(0, newline).toString("utf8");
+      void dispatch(line, socket, options, token);
+    });
+  });
+  await new Promise((resolve28, reject) => {
+    const onError = (error) => {
+      server.removeListener("listening", onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      server.removeListener("error", onError);
+      resolve28();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(endpoint);
+  });
+  if (platform !== "win32") await chmod3(endpoint, 384).catch(() => void 0);
+  let closed = false;
+  return {
+    endpoint,
+    token,
+    capabilities,
+    async close() {
+      if (closed) return;
+      closed = true;
+      for (const socket of sockets) socket.destroy();
+      await closeServer(server);
+      if (platform !== "win32") await unlink4(endpoint).catch(() => void 0);
+    }
+  };
+}
+async function dispatch(line, socket, options, token) {
+  let request;
+  try {
+    const parsed = JSON.parse(line);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("invalid request");
+    request = parsed;
+  } catch {
+    write(socket, { ok: false, error: "invalid_json" });
+    return;
+  }
+  if (request.token !== token) {
+    write(socket, { ok: false, error: "unauthorized" });
+    return;
+  }
+  const command = request.command;
+  try {
+    if (command === "abort") {
+      write(socket, { ok: true, result: options.session.interrupt() });
+    } else if (command === "steer" || command === "follow_up") {
+      const message2 = typeof request.message === "string" ? request.message.trim() : "";
+      if (!message2 || message2.length > 1e5) {
+        write(socket, { ok: false, error: "invalid_message" });
+        return;
+      }
+      if (command === "steer") options.session.steer(message2);
+      else options.session.followUp(message2);
+      write(socket, { ok: true });
+    } else if (command === "focus") {
+      if (options.focus === void 0) {
+        write(socket, { ok: false, error: "focus_unavailable" });
+        return;
+      }
+      await options.focus();
+      write(socket, { ok: true });
+    } else {
+      write(socket, { ok: false, error: "unknown_command" });
+    }
+  } catch (error) {
+    write(socket, { ok: false, error: error instanceof Error ? error.message : String(error) });
+  }
+}
+function write(socket, payload) {
+  try {
+    socket.end(`${JSON.stringify(payload)}
+`);
+  } catch {
+    socket.destroy();
+  }
+}
+function closeServer(server) {
+  return new Promise((resolve28) => {
+    try {
+      server.close(() => resolve28());
+    } catch {
+      resolve28();
+    }
+  });
+}
+
 // src/evolve/service.ts
 import { spawn as spawn5 } from "child_process";
 import { writeFile as writeFile8 } from "fs/promises";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 import { z as z14 } from "zod";
 
 // src/evolve/loader.ts
 import { cp, mkdir as mkdir8, mkdtemp, readdir as readdir4, rm as rm2, stat as stat4, writeFile as writeFile6 } from "fs/promises";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join9, resolve as resolve10 } from "path";
+import { tmpdir as tmpdir3 } from "os";
+import { join as join10, resolve as resolve10 } from "path";
 
 // src/plugins/host.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 import { lstatSync, realpathSync as realpathSync3 } from "fs";
 import { lstat as lstat5, open as open5, readFile as readFile7, readdir as readdir3, realpath as realpath4, stat as stat3, writeFile as writeFile5 } from "fs/promises";
 import { isAbsolute as isAbsolute5, relative as relative8, resolve as resolve9, sep as sep8 } from "path";
@@ -9109,7 +9301,7 @@ var PluginHost = class {
       const manifest = PluginManifestSchema.parse(rawManifest);
       const entry2 = resolveContained(root, manifest.main, "Plugin entry");
       const entrySnapshot = await snapshotEntry(root, entry2);
-      const fingerprint2 = createHash7("sha256").update(JSON.stringify(manifest)).update(await readFile7(entrySnapshot.physicalPath)).digest("hex");
+      const fingerprint2 = createHash8("sha256").update(JSON.stringify(manifest)).update(await readFile7(entrySnapshot.physicalPath)).digest("hex");
       return { manifest, root, source, entry: entry2, entrySnapshot, fingerprint: fingerprint2 };
     } catch (error) {
       this.#diagnose(diagnosticLabel, error, inputRoot);
@@ -9468,8 +9660,8 @@ function compare(left, right) {
 }
 
 // src/evolve/loader.ts
-var PLUGIN_DIR = join9(".flavor", "plugins");
-var VERSIONS_DIR = join9(".flavor", "plugins", ".versions");
+var PLUGIN_DIR = join10(".flavor", "plugins");
+var VERSIONS_DIR = join10(".flavor", "plugins", ".versions");
 function sanitizePluginName(tool) {
   const base = String(tool ?? "fix").replace(/[^a-z0-9-]/gi, "-").toLowerCase();
   return base.startsWith("fix-") ? base : `fix-${base}`;
@@ -9513,8 +9705,8 @@ export function activate(ctx) {
 async function scaffoldFixPlugin(workspace, name) {
   const dir = fixPluginDir(workspace, name);
   await mkdir8(dir, { recursive: true });
-  const manifestPath = join9(dir, "flavor-plugin.json");
-  const entryPath = join9(dir, "index.js");
+  const manifestPath = join10(dir, "flavor-plugin.json");
+  const entryPath = join10(dir, "index.js");
   try {
     await writeFile6(manifestPath, SCAFFOLD_MANIFEST(name), { encoding: "utf8", flag: "wx" });
     await writeFile6(entryPath, SCAFFOLD_ENTRY(name), { encoding: "utf8", flag: "wx" });
@@ -9534,9 +9726,9 @@ async function verifyFixPlugin(workspace, name) {
     return { ok: false, provided: [], tools: [], commands: [], error: `Plugin "${name}" not found.` };
   }
   const collected = { tools: [], commands: [] };
-  const sandbox = await mkdtemp(join9(tmpdir2(), "flavor-evolve-verify-"));
+  const sandbox = await mkdtemp(join10(tmpdir3(), "flavor-evolve-verify-"));
   try {
-    await cp(pluginRoot, join9(sandbox, name), { recursive: true });
+    await cp(pluginRoot, join10(sandbox, name), { recursive: true });
     const host = new PluginHost({
       projectPluginDirs: [sandbox],
       sandbox: true,
@@ -9587,7 +9779,7 @@ async function verifyFixPlugin(workspace, name) {
 }
 async function snapshotFixPlugin(workspace, name) {
   const pluginRoot = fixPluginDir(workspace, name);
-  const snapshotRoot = join9(versionsDirFor(workspace, name), timestamp());
+  const snapshotRoot = join10(versionsDirFor(workspace, name), timestamp());
   await mkdir8(snapshotRoot, { recursive: true });
   await cp(pluginRoot, snapshotRoot, { recursive: true });
   return snapshotRoot;
@@ -9608,7 +9800,7 @@ async function revertFixPlugin(workspace, name) {
   }
   const snapshots = entries.filter((entry2) => !entry2.startsWith(".")).sort();
   if (snapshots.length === 0) throw new Error(`Plugin "${name}" has no snapshot to restore.`);
-  const latest = join9(versionsRoot, snapshots[snapshots.length - 1]);
+  const latest = join10(versionsRoot, snapshots[snapshots.length - 1]);
   await rm2(pluginRoot, { recursive: true, force: true });
   await mkdir8(pluginRoot, { recursive: true });
   await cp(latest, pluginRoot, { recursive: true });
@@ -9616,14 +9808,14 @@ async function revertFixPlugin(workspace, name) {
 }
 
 // src/evolve/store.ts
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 import { appendFile, mkdir as mkdir9, readFile as readFile8, rm as rm3, writeFile as writeFile7 } from "fs/promises";
-import { dirname as dirname11, join as join10 } from "path";
+import { dirname as dirname11, join as join11 } from "path";
 function normalizeError(message2) {
   return String(message2 ?? "").replace(/\s+/g, " ").replace(/"[^"]*"/g, '"\u2026"').replace(/`[^`]*`/g, '"\u2026"').trim().slice(0, 160);
 }
 function fingerprint(tool, errorCode, error) {
-  return createHash8("sha1").update(`${tool}::${errorCode ?? ""}::${normalizeError(error)}`).digest("hex").slice(0, 12);
+  return createHash9("sha1").update(`${tool}::${errorCode ?? ""}::${normalizeError(error)}`).digest("hex").slice(0, 12);
 }
 function argKeys(args) {
   if (args === null || typeof args !== "object") return [];
@@ -9691,12 +9883,12 @@ var EvolveStore = class {
   #queue = Promise.resolve();
   constructor(options) {
     const { workspace, maxSignals = 400, maxRules = 20 } = options;
-    this.dir = join10(workspace, ".flavor", "evolve");
-    this.signalsFile = join10(this.dir, "signals.jsonl");
-    this.reflectionsFile = join10(this.dir, "reflections.jsonl");
-    this.doneFile = join10(this.dir, "done.json");
-    this.verifiedFile = join10(this.dir, "verified.json");
-    this.rulesFile = join10(this.dir, "rules.json");
+    this.dir = join11(workspace, ".flavor", "evolve");
+    this.signalsFile = join11(this.dir, "signals.jsonl");
+    this.reflectionsFile = join11(this.dir, "reflections.jsonl");
+    this.doneFile = join11(this.dir, "done.json");
+    this.verifiedFile = join11(this.dir, "verified.json");
+    this.rulesFile = join11(this.dir, "rules.json");
     this.maxSignals = maxSignals;
     this.maxRules = maxRules;
   }
@@ -10235,7 +10427,7 @@ function createEvolveService(options) {
         if (suggestion === void 0) return `No open suggestion with id "${suggestionId}". Use /evolve suggest to list them.`;
         const name = sanitizePluginName(suggestion.tool);
         const dir = await scaffoldFixPlugin(workspace, name);
-        await writeFile8(join11(dir, "PLAN.md"), buildPlan(suggestion, name, "See the repeated failure below; describe your fix in PLAN.md."), "utf8");
+        await writeFile8(join12(dir, "PLAN.md"), buildPlan(suggestion, name, "See the repeated failure below; describe your fix in PLAN.md."), "utf8");
         await snapshotFixPlugin(workspace, name);
         return [
           `suggestion ${suggestion.id}: ${suggestion.tool} x${suggestion.count} \u2014 ${suggestion.error}`,
@@ -10326,7 +10518,7 @@ ${result.stderr.slice(-4e3)}` : ""}`;
           }
           const name = sanitizePluginName(suggestion.tool);
           const dir = await scaffoldFixPlugin(workspace, name);
-          await writeFile8(join11(dir, "PLAN.md"), buildPlan(suggestion, name, implementation), "utf8");
+          await writeFile8(join12(dir, "PLAN.md"), buildPlan(suggestion, name, implementation), "utf8");
           await snapshotFixPlugin(workspace, name);
           return [
             `Scaffolded fix plugin at ${dir} for suggestion [${suggestion.id}] (${suggestion.tool} x${suggestion.count}).`,
@@ -10747,9 +10939,9 @@ ${evidence.summary}`;
 };
 
 // src/goal/orchestrator.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 import { writeFile as writeFile9, mkdir as mkdir10 } from "fs/promises";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 
 // src/goal/types.ts
 import { z as z16 } from "zod";
@@ -10912,9 +11104,9 @@ function extractJson(text) {
 }
 
 // src/goal/classifier.ts
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 import { readFile as readFile9 } from "fs/promises";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 function buildSkepticPrompt(evidence, plan, index) {
   const criteriaList = plan.criteria.map((c) => `  ${c.id}. [${c.type}] ${c.description}`).join("\n");
   return [
@@ -11087,11 +11279,11 @@ function deduplicateGaps(gaps) {
 }
 function computeFingerprint(gaps) {
   const content = gaps.map((g) => `${g.criterion}:${g.description}`).sort().join("\n");
-  return createHash9("sha256").update(content).digest("hex").slice(0, 16);
+  return createHash10("sha256").update(content).digest("hex").slice(0, 16);
 }
-async function collectEvidence(workspace, objective, finalResponse, priorGaps, contractHash2 = createHash9("sha256").update(objective).digest("hex"), hostVerification) {
+async function collectEvidence(workspace, objective, finalResponse, priorGaps, contractHash2 = createHash10("sha256").update(objective).digest("hex"), hostVerification) {
   const workspaceState = await collectWorkspaceState(workspace);
-  const planPath = join12(workspace, ".flavor", "goal-plan.md");
+  const planPath = join13(workspace, ".flavor", "goal-plan.md");
   let planFile = null;
   try {
     planFile = await readFile9(planPath, "utf8");
@@ -11118,7 +11310,7 @@ async function collectWorkspaceState(workspace) {
     return {
       changedFiles: [],
       status: ["not-a-git-worktree"],
-      diffHash: createHash9("sha256").update("not-a-git-worktree").digest("hex")
+      diffHash: createHash10("sha256").update("not-a-git-worktree").digest("hex")
     };
   }
   const status = statusResult.stdout.split(/\r?\n/).map((line) => line.trimEnd()).filter(Boolean);
@@ -11135,7 +11327,7 @@ async function collectWorkspaceState(workspace) {
   return {
     changedFiles,
     status,
-    diffHash: createHash9("sha256").update(diff.stdout).update("\nUNTRACKED\n").update(untracked).digest("hex")
+    diffHash: createHash10("sha256").update(diff.stdout).update("\nUNTRACKED\n").update(untracked).digest("hex")
   };
 }
 
@@ -11267,7 +11459,7 @@ var GoalOrchestrator = class {
             type: "not_achieved",
             gaps,
             summary: hostVerification.summary,
-            fingerprint: createHash10("sha256").update(hostVerification.summary).digest("hex").slice(0, 16)
+            fingerprint: createHash11("sha256").update(hostVerification.summary).digest("hex").slice(0, 16)
           };
         }
       } else try {
@@ -11341,11 +11533,11 @@ var GoalOrchestrator = class {
   }
 };
 function contractHash(objective, plan) {
-  return createHash10("sha256").update(JSON.stringify({ objective, plan })).digest("hex");
+  return createHash11("sha256").update(JSON.stringify({ objective, plan })).digest("hex");
 }
 async function writePlanFile(workspace, plan) {
-  const dir = join13(workspace, ".flavor");
-  const planPath = join13(dir, "goal-plan.md");
+  const dir = join14(workspace, ".flavor");
+  const planPath = join14(dir, "goal-plan.md");
   await mkdir10(dir, { recursive: true });
   const criteriaText = plan.criteria.map((c) => `- [${c.type}] AC-${c.id}: ${c.description}`).join("\n");
   const content = [
@@ -11421,9 +11613,9 @@ function formatPriorGaps(gaps) {
 
 // src/goal/store.ts
 import { constants as constants2 } from "fs";
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID11 } 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";
+import { dirname as dirname12, join as join15, relative as relative9, resolve as resolve11, sep as sep9 } from "path";
 var DEFAULT_MAX_BYTES = 1024 * 1024;
 var GoalStore = class {
   #workspace;
@@ -11431,7 +11623,7 @@ var GoalStore = class {
   #maxBytes;
   constructor(options) {
     this.#workspace = resolve11(options.workspace);
-    this.#root = join14(this.#workspace, ".flavor", "goals");
+    this.#root = join15(this.#workspace, ".flavor", "goals");
     this.#maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
   }
   async save(input) {
@@ -11439,13 +11631,13 @@ var GoalStore = class {
     await assertNoSymlink(this.#workspace, dirname12(this.#root));
     await mkdir11(this.#root, { recursive: true, mode: 448 });
     await assertNoSymlink(this.#workspace, this.#root);
-    const target = join14(this.#root, `${state.id}.json`);
+    const target = join15(this.#root, `${state.id}.json`);
     const body = `${JSON.stringify(state, null, 2)}
 `;
     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 = join15(this.#root, `.${state.id}.${process.pid}.${randomUUID11()}.tmp`);
     let handle;
     try {
       handle = await open6(temporary, constants2.O_CREAT | constants2.O_EXCL | constants2.O_WRONLY, 384);
@@ -11486,7 +11678,7 @@ function isCode3(error, code) {
 
 // src/loop/isolation.ts
 import { appendFile as appendFile2, mkdir as mkdir12, readFile as readFile10 } from "fs/promises";
-import { join as join15, resolve as resolve12 } from "path";
+import { join as join16, resolve as resolve12 } from "path";
 var CODE_CHANGE = /\b(?:fix|implement|add|update|change|modify|refactor|build|create|remove|delete|write|migrate)\b|修复|实现|添加|更新|修改|重构|创建|删除|迁移/i;
 var READ_ONLY = /\b(?:review|analy[sz]e|inspect|explain|research|investigate|audit|summari[sz]e|report)\b|调研|分析|审查|检查|解释|研究|总结|报告/i;
 function inferGoalIntent(goal) {
@@ -11509,8 +11701,8 @@ async function prepareLoopWorkspace(options) {
     return { kind: "needs_human", reason: "The workspace has uncommitted changes that a new worktree would omit." };
   }
   options.signal?.throwIfAborted();
-  const worktrees = join15(root, ".worktrees");
-  const path = join15(worktrees, `loop-${options.loopId}`);
+  const worktrees = join16(root, ".worktrees");
+  const path = join16(worktrees, `loop-${options.loopId}`);
   const branch = `loop/${options.loopId}`;
   try {
     await ensureWorktreeDirectoryIgnored(root);
@@ -11540,8 +11732,8 @@ async function ensureWorktreeDirectoryIgnored(root) {
   const commonDirectory = await git(root, ["rev-parse", "--git-common-dir"]);
   if (commonDirectory.code !== 0) throw new Error(commonDirectory.stderr.trim() || "Git common directory is unavailable");
   const gitDirectory = resolve12(root, commonDirectory.stdout.trim());
-  const infoDirectory = join15(gitDirectory, "info");
-  const excludePath = join15(infoDirectory, "exclude");
+  const infoDirectory = join16(gitDirectory, "info");
+  const excludePath = join16(infoDirectory, "exclude");
   await mkdir12(infoDirectory, { recursive: true });
   let existing = "";
   try {
@@ -11557,8 +11749,8 @@ async function ensureWorktreeDirectoryIgnored(root) {
 // src/loop/store.ts
 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 { dirname as dirname13, join as join17, relative as relative10, resolve as resolve13, sep as sep10 } from "path";
+import { randomUUID as randomUUID12 } 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 {
@@ -11568,7 +11760,7 @@ var LoopStore = class {
   #appendTails = /* @__PURE__ */ new Map();
   constructor(options) {
     this.#workspace = resolve13(options.workspace);
-    this.#root = join16(this.#workspace, ".flavor", "loops");
+    this.#root = join17(this.#workspace, ".flavor", "loops");
     this.#maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES2;
   }
   async create(state) {
@@ -11585,11 +11777,11 @@ var LoopStore = class {
     const state = LoopStateSchema.parse(input);
     await this.#assertWorkspace(state.workspace);
     const directory = await this.#prepare(state.loopId);
-    const target = join16(directory, "state.json");
+    const target = join17(directory, "state.json");
     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 = join17(directory, `.state.${process.pid}.${randomUUID12()}.tmp`);
     let handle;
     try {
       handle = await open7(temporary, constants3.O_CREAT | constants3.O_EXCL | constants3.O_WRONLY, 384);
@@ -11605,7 +11797,7 @@ var LoopStore = class {
   }
   async load(loopId) {
     const directory = await this.#safeExisting(loopId);
-    const target = join16(directory, "state.json");
+    const target = join17(directory, "state.json");
     try {
       const metadata = await stat5(target);
       if (!metadata.isFile() || metadata.size > this.#maxBytes) throw new Error("Loop state is not a bounded regular file");
@@ -11615,7 +11807,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()}-${randomUUID12().slice(0, 8)}`;
       await rename5(target, quarantine).catch(() => void 0);
       throw new Error(`Loop "${loopId}" is corrupt and was quarantined: ${message(error)}`);
     }
@@ -11625,7 +11817,7 @@ var LoopStore = class {
     const previous = this.#appendTails.get(event.loopId) ?? Promise.resolve();
     const next = previous.catch(() => void 0).then(async () => {
       const directory = await this.#prepare(event.loopId);
-      const path = join16(directory, "events.jsonl");
+      const path = join17(directory, "events.jsonl");
       const handle = await open7(path, constants3.O_CREAT | constants3.O_APPEND | constants3.O_WRONLY, 384);
       try {
         await handle.writeFile(`${JSON.stringify(event)}
@@ -11642,7 +11834,7 @@ var LoopStore = class {
     await assertNoSymlink2(this.#workspace, dirname13(this.#root));
     await mkdir13(this.#root, { recursive: true, mode: 448 });
     await assertNoSymlink2(this.#workspace, this.#root);
-    const directory = join16(this.#root, loopId);
+    const directory = join17(this.#root, loopId);
     await mkdir13(directory, { recursive: true, mode: 448 });
     await assertNoSymlink2(this.#workspace, directory);
     return directory;
@@ -11650,7 +11842,7 @@ var LoopStore = class {
   async #safeExisting(loopId) {
     validateId(loopId);
     await assertNoSymlink2(this.#workspace, this.#root);
-    const directory = join16(this.#root, loopId);
+    const directory = join17(this.#root, loopId);
     await assertNoSymlink2(this.#workspace, directory);
     return directory;
   }
@@ -11699,7 +11891,7 @@ function isCode4(error, code) {
 
 // src/loop/verifier.ts
 import { readFile as readFile12 } from "fs/promises";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 
 // src/tools/shell.ts
 import { spawn as spawn6, spawnSync } from "child_process";
@@ -12257,13 +12449,13 @@ var SCRIPT_PRIORITY = ["test", "typecheck", "lint", "build", "smoke:install"];
 async function inferVerificationPlan(workspace) {
   const commands = [];
   const seen = /* @__PURE__ */ new Set();
-  const packageJson = await optionalJson(join17(workspace, "package.json"));
+  const packageJson = await optionalJson(join18(workspace, "package.json"));
   const scripts = isRecord2(packageJson?.scripts) ? packageJson.scripts : {};
   for (const name of SCRIPT_PRIORITY) {
     if (typeof scripts[name] !== "string" || isUnconditionalPassThrough(scripts[name])) continue;
     add(commands, seen, npmScript(name));
   }
-  const flavor = await optionalText(join17(workspace, "FLAVOR.md"));
+  const flavor = await optionalText(join18(workspace, "FLAVOR.md"));
   if (flavor !== void 0) {
     for (const match of flavor.matchAll(/^- `([^`]+)`\s*$/gm)) {
       const parsed = parseTrustedCommand(match[1] ?? "");
@@ -12966,7 +13158,7 @@ var ModelRegistry = class {
 };
 
 // src/mcp/client.ts
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 import { z as z19 } from "zod";
 var McpManager = class {
   #workspace;
@@ -13133,7 +13325,7 @@ function mcpToolName(serverName, remoteName) {
   const safe = remoteName.replace(/[^A-Za-z0-9_-]/g, "_") || "tool";
   const direct = `${prefix}${safe}`;
   if (direct.length <= 64 && safe === remoteName) return direct;
-  const suffix = `__${createHash11("sha256").update(remoteName).digest("hex").slice(0, 8)}`;
+  const suffix = `__${createHash12("sha256").update(remoteName).digest("hex").slice(0, 8)}`;
   return `${prefix}${safe.slice(0, Math.max(1, 64 - prefix.length - suffix.length))}${suffix}`;
 }
 function mcpErrorText(content) {
@@ -13199,14 +13391,14 @@ async function connectSdkMcpClient(input, dependencies = DEFAULT_DEPENDENCIES) {
 }
 
 // src/auth/oauth.ts
-import { randomBytes as randomBytes2, createHash as createHash13 } from "crypto";
-import { createServer as createServer2 } from "http";
+import { randomBytes as randomBytes2, createHash as createHash14 } from "crypto";
+import { createServer as createServer3 } from "http";
 import { URL as URL2, URLSearchParams } from "url";
 
 // src/auth/oauth-config.ts
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash13 } from "crypto";
 function oauthCredentialId(tokenUrl, clientId) {
-  const digest = createHash12("sha256").update(`${tokenUrl}\0${clientId}`, "utf8").digest("base64url");
+  const digest = createHash13("sha256").update(`${tokenUrl}\0${clientId}`, "utf8").digest("base64url");
   return `oauth:${digest}`;
 }
 function parseOAuthLlmConfig(value) {
@@ -13383,7 +13575,7 @@ var OAuthCallbackAuthProvider = class {
       serverResolve = resolve28;
       serverReject = reject;
     });
-    const server = createServer2((req, res) => {
+    const server = createServer3((req, res) => {
       const url = new URL2(req.url ?? "/", `http://${this.#callbackHost}:${server.address().port}`);
       if (url.searchParams.has("error")) {
         const error = url.searchParams.get("error") ?? "access_denied";
@@ -13463,7 +13655,7 @@ var OAuthCallbackAuthProvider = class {
     return randomBytes2(32).toString("base64url");
   }
   #computeCodeChallenge(verifier) {
-    return createHash13("sha256").update(verifier).digest("base64url");
+    return createHash14("sha256").update(verifier).digest("base64url");
   }
   #generateState() {
     return randomBytes2(32).toString("base64url");
@@ -13574,7 +13766,7 @@ function isStoredToken(value) {
 
 // src/permissions/policy.ts
 import { readFile as readFile15 } from "fs/promises";
-import { join as join18, resolve as resolve16 } from "path";
+import { join as join19, resolve as resolve16 } from "path";
 import { z as z20 } from "zod";
 var DecisionSchema2 = z20.enum(["allow", "ask", "deny"]);
 var PrefixSchema = z20.array(z20.string().min(1).max(1024)).min(1).max(64);
@@ -13611,9 +13803,9 @@ var CompiledPermissionPolicy = class {
 async function loadPermissionPolicy(options) {
   const sources = [
     ...options.managedPath === void 0 ? [] : [{ tier: "managed", path: resolve16(options.managedPath) }],
-    { tier: "user", path: join18(resolve16(options.home), ".flavor-code", "permissions.json") },
-    { tier: "project", path: join18(resolve16(options.workspace), ".flavor", "permissions.json") },
-    { tier: "local", path: join18(resolve16(options.workspace), ".flavor", "permissions.local.json") }
+    { tier: "user", path: join19(resolve16(options.home), ".flavor-code", "permissions.json") },
+    { tier: "project", path: join19(resolve16(options.workspace), ".flavor", "permissions.json") },
+    { tier: "local", path: join19(resolve16(options.workspace), ".flavor", "permissions.local.json") }
   ];
   const rules = [];
   for (const source of sources) {
@@ -14382,8 +14574,8 @@ function createSkillResourceTool(registry) {
 // src/session/store.ts
 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 { basename as basename3, dirname as dirname15, join as join20, relative as relative13, resolve as resolve18, sep as sep13 } from "path";
+import { randomUUID as randomUUID13 } from "crypto";
 import { z as z22 } from "zod";
 var SESSION_VERSION = 4;
 var DEFAULT_MAX_SESSION_BYTES = 5 * 1024 * 1024;
@@ -14509,7 +14701,7 @@ var SessionStore = class {
   #maxSessions;
   constructor(options) {
     this.#workspace = resolve18(options.workspace);
-    this.#sessions = join19(this.#workspace, ".flavor", "sessions");
+    this.#sessions = join20(this.#workspace, ".flavor", "sessions");
     this.#maxBytes = options.maxBytes ?? DEFAULT_MAX_SESSION_BYTES;
     if (!Number.isSafeInteger(this.#maxBytes) || this.#maxBytes < 256) throw new Error("maxBytes must be an integer of at least 256");
     this.#maxSessions = options.maxSessions ?? 50;
@@ -14541,7 +14733,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 = join20(this.#sessions, `.${document.sessionId}.${process.pid}.${randomUUID13()}.tmp`);
     let handle;
     try {
       handle = await open8(temporary, constants5.O_CREAT | constants5.O_EXCL | constants5.O_WRONLY, 384);
@@ -14658,7 +14850,7 @@ var SessionStore = class {
       const metadata = await lstat9(path);
       if (!metadata.isFile()) throw new Error("Session path is not a regular file");
       await rm6(path);
-      await rm6(join19(this.#sessions, `${sessionId}.events.jsonl`), { force: true }).catch(() => void 0);
+      await rm6(join20(this.#sessions, `${sessionId}.events.jsonl`), { force: true }).catch(() => void 0);
     } catch (error) {
       if (!isCode7(error, "ENOENT")) throw error;
     }
@@ -14675,7 +14867,7 @@ var SessionStore = class {
     const excess = entries.slice(this.#maxSessions);
     for (const entry2 of excess) {
       await rm6(this.#path(entry2.sessionId), { force: true }).catch(() => void 0);
-      await rm6(join19(this.#sessions, `${entry2.sessionId}.events.jsonl`), { force: true }).catch(() => void 0);
+      await rm6(join20(this.#sessions, `${entry2.sessionId}.events.jsonl`), { force: true }).catch(() => void 0);
     }
   }
   async #assertWorkspace(stored) {
@@ -14697,7 +14889,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()}-${randomUUID13().slice(0, 8)}`;
     await rename6(path, target);
     return target;
   }
@@ -14917,9 +15109,9 @@ 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 randomUUID14 } 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 { isAbsolute as isAbsolute8, join as join21, relative as relative14, resolve as resolve19, sep as sep14 } from "path";
 import { z as z23 } from "zod";
 var DateKeySchema = z23.string().regex(/^\d{4}-\d{2}-\d{2}$/);
 var ReviewSchema = z23.object({
@@ -14974,7 +15166,7 @@ var ProjectSleepOrganizer = class {
   #generate;
   constructor(options) {
     this.#workspace = resolve19(options.workspace);
-    this.#sleepDirectory = join20(this.#workspace, ".flavor", "sleep");
+    this.#sleepDirectory = join21(this.#workspace, ".flavor", "sleep");
     this.#sessions = options.sessions ?? new SessionStore({ workspace: this.#workspace });
     this.#generate = options.generate;
   }
@@ -14983,7 +15175,7 @@ var ProjectSleepOrganizer = class {
     signal.throwIfAborted();
     await this.#prepareDirectory();
     if (await this.#hasReport(date)) return { status: "exists", date };
-    const lockPath = join20(this.#sleepDirectory, `.${date}.lock`);
+    const lockPath = join21(this.#sleepDirectory, `.${date}.lock`);
     let lock;
     try {
       lock = await open9(lockPath, constants6.O_CREAT | constants6.O_EXCL | constants6.O_WRONLY, 384);
@@ -15018,7 +15210,7 @@ Previous output was invalid. Repair it and return strict JSON only.`;
       }
       if (review === void 0) throw lastError;
       const filename2 = `${date}-${filenameSummary(review.title)}.md`;
-      const path = join20(this.#sleepDirectory, filename2);
+      const path = join21(this.#sleepDirectory, filename2);
       const markdown = renderSleepReport(date, review, documents);
       await this.#atomicWrite(path, markdown);
       return { status: "written", date, path, sessionCount: documents.length };
@@ -15060,7 +15252,7 @@ Previous output was invalid. Repair it and return strict JSON only.`;
     });
   }
   async #prepareDirectory() {
-    const flavorDirectory = join20(this.#workspace, ".flavor");
+    const flavorDirectory = join21(this.#workspace, ".flavor");
     await assertNotSymlink(flavorDirectory);
     await mkdir15(flavorDirectory, { recursive: true, mode: 448 });
     await assertNotSymlink(this.#sleepDirectory);
@@ -15074,7 +15266,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 = join21(this.#sleepDirectory, `.${randomUUID14()}.tmp`);
     let handle;
     try {
       handle = await open9(temporary, constants6.O_CREAT | constants6.O_EXCL | constants6.O_WRONLY, 384);
@@ -15450,7 +15642,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 randomUUID15 } from "crypto";
 import { z as z24 } from "zod";
 
 // src/tools/file-diff.ts
@@ -15803,7 +15995,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}.${randomUUID15()}.tmp`;
   try {
     const handle = await open10(temporary, constants7.O_CREAT | constants7.O_EXCL | constants7.O_WRONLY, 384);
     try {
@@ -17200,18 +17392,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 });
@@ -17220,12 +17434,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);
         }
@@ -17311,9 +17527,9 @@ function createTodoWriteTool() {
 }
 
 // src/tools/managed.ts
-import { randomUUID as randomUUID14 } 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 { randomUUID as randomUUID16 } from "crypto";
+import { link as link2, lstat as lstat11, mkdir as mkdir17, readFile as readFile19, readdir as readdir8, unlink as unlink5, writeFile as writeFile10 } from "fs/promises";
+import { dirname as dirname18, join as join22, resolve as resolve22 } from "path";
 import { z as z31 } from "zod";
 var MANAGED_TOOL_VERSION = 1;
 var MAX_RECORD_BYTES = 256 * 1024;
@@ -17356,8 +17572,8 @@ var ManagedToolStore = class {
   #diagnostics = [];
   constructor(options) {
     this.#workspace = resolve22(options.workspace);
-    this.#projectRoot = join21(this.#workspace, ".flavor", "tools");
-    this.#globalRoot = join21(resolve22(options.home), ".flavor-code", "tools");
+    this.#projectRoot = join22(this.#workspace, ".flavor", "tools");
+    this.#globalRoot = join22(resolve22(options.home), ".flavor-code", "tools");
     this.#now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   }
   get diagnostics() {
@@ -17404,7 +17620,7 @@ var ManagedToolStore = class {
       version: MANAGED_TOOL_VERSION,
       createdAt: this.#now()
     });
-    const path = join21(this.directory(input.scope), filename(input.name));
+    const path = join22(this.directory(input.scope), filename(input.name));
     const definition = compileDefinition(record, input.scope, this.#workspace);
     await writeExclusive(path, `${JSON.stringify(record, void 0, 2)}
 `);
@@ -17420,7 +17636,7 @@ var ManagedToolStore = class {
     const entry2 = matches[0];
     const info = await lstat11(entry2.path);
     if (!info.isFile() || info.isSymbolicLink()) throw new Error(`Managed tool path is no longer a regular file: ${entry2.path}`);
-    await unlink4(entry2.path);
+    await unlink5(entry2.path);
     this.#entries.delete(scopedKey(entry2.scope, entry2.record.name));
     return summary(entry2, false);
   }
@@ -17429,7 +17645,7 @@ var ManagedToolStore = class {
     if (!parsed.success) return [];
     const matches = this.#matching(parsed.data.name).filter((entry2) => parsed.data.scope === void 0 || entry2.scope === parsed.data.scope);
     if (matches.length > 0) return matches.map((entry2) => entry2.path);
-    return [join21(this.directory(parsed.data.scope ?? "project"), filename(parsed.data.name))];
+    return [join22(this.directory(parsed.data.scope ?? "project"), filename(parsed.data.name))];
   }
   async #loadDirectory(scope2) {
     const root = this.directory(scope2);
@@ -17442,7 +17658,7 @@ var ManagedToolStore = class {
       return;
     }
     for (const name of names) {
-      const path = join21(root, name);
+      const path = join22(root, name);
       try {
         const info = await lstat11(path);
         if (!info.isFile() || info.isSymbolicLink()) throw new Error("Managed tool record must be a regular file");
@@ -17598,13 +17814,13 @@ ${sourceUrl}`
 }
 async function writeExclusive(path, content) {
   await mkdir17(dirname18(path), { recursive: true });
-  const temporary = `${path}.${randomUUID14()}.tmp`;
+  const temporary = `${path}.${randomUUID16()}.tmp`;
   try {
     await writeFile10(temporary, content, { encoding: "utf8", flag: "wx", mode: 384 });
     await link2(temporary, path);
   } finally {
     try {
-      await unlink4(temporary);
+      await unlink5(temporary);
     } catch {
     }
   }
@@ -17988,7 +18204,7 @@ function buildWarningMessages(report, languageTag) {
 }
 
 // src/hallucination/sliding-window.ts
-import { createHash as createHash14 } from "crypto";
+import { createHash as createHash15 } from "crypto";
 var SlidingWindow = class {
   #windowSize;
   #threshold;
@@ -18004,7 +18220,7 @@ var SlidingWindow = class {
   }
   hash(toolName, params) {
     const sorted = JSON.stringify(params, sortedKeys(params));
-    return createHash14("sha256").update(`${toolName}:${sorted}`).digest("hex");
+    return createHash15("sha256").update(`${toolName}:${sorted}`).digest("hex");
   }
   push(toolName, params) {
     const hash = this.hash(toolName, params);
@@ -18359,9 +18575,9 @@ ${total}`;
 }
 
 // src/memory/store.ts
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 import { readFile as readFile20, rm as rm9 } from "fs/promises";
-import { resolve as resolve23, join as join22, relative as relative17, sep as sep17 } from "path";
+import { resolve as resolve23, join as join23, relative as relative17, sep as sep17 } from "path";
 
 // src/memory/similarity.ts
 function normalizeForSimilarity(value) {
@@ -18464,9 +18680,9 @@ var MemoryStore = class {
     if (!Number.isSafeInteger(options.maxEntries) || options.maxEntries < 1) throw new Error("maxEntries must be an integer of at least 1");
     if (!Number.isSafeInteger(options.maxEntryChars) || options.maxEntryChars < 1) throw new Error("maxEntryChars must be an integer of at least 1");
     this.workspace = resolve23(options.workspace);
-    this.#memoryRoot = join22(this.workspace, ".flavor", "memory");
-    this.path = join22(this.#memoryRoot, "MEMORY.md");
-    this.#behaviorPath = join22(this.#memoryRoot, "behavior.json");
+    this.#memoryRoot = join23(this.workspace, ".flavor", "memory");
+    this.path = join23(this.#memoryRoot, "MEMORY.md");
+    this.#behaviorPath = join23(this.#memoryRoot, "behavior.json");
     this.#maxEntries = options.maxEntries;
     this.#maxEntryChars = options.maxEntryChars;
   }
@@ -18845,7 +19061,7 @@ function sanitizeTopicKey(value) {
   return value.normalize("NFKC").toLocaleLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 128);
 }
 function memoryId(type, content) {
-  return createHash15("sha256").update(`${type}\0${normalizeMemoryContent(content).toLocaleLowerCase()}`, "utf8").digest("hex").slice(0, 12);
+  return createHash16("sha256").update(`${type}\0${normalizeMemoryContent(content).toLocaleLowerCase()}`, "utf8").digest("hex").slice(0, 12);
 }
 function assertTaskId(taskId) {
   if (!TASK_ID.test(taskId)) throw new Error(`Invalid memory task id: ${taskId}`);
@@ -19161,7 +19377,7 @@ function createExecutionEnvironment(workspace, config) {
 
 // src/ide/client.ts
 import { readFile as readFile21, readdir as readdir9, stat as stat8 } from "fs/promises";
-import { basename as basename5, join as join23, relative as relative18, resolve as resolve24, sep as sep18 } from "path";
+import { basename as basename5, join as join24, relative as relative18, resolve as resolve24, sep as sep18 } from "path";
 var FlavorIdeClient = class {
   #workspace;
   #home;
@@ -19257,7 +19473,7 @@ var FlavorIdeClient = class {
       };
       if (await this.#healthy(configured)) return configured;
     }
-    const directory = join23(this.#home, ".flavor-code", "ide");
+    const directory = join24(this.#home, ".flavor-code", "ide");
     let entries;
     try {
       entries = (await readdir9(directory)).filter((name) => name.endsWith(".lock"));
@@ -19265,7 +19481,7 @@ var FlavorIdeClient = class {
       return void 0;
     }
     const candidates = (await Promise.all(entries.map(async (name) => {
-      const path = join23(directory, name);
+      const path = join24(directory, name);
       try {
         const [contents, info] = await Promise.all([readFile21(path, "utf8"), stat8(path)]);
         const lock = parseLockfile(contents);
@@ -19385,7 +19601,7 @@ function relativeDisplay(workspace, filePath) {
 }
 
 // src/jobs/registry.ts
-import { randomUUID as randomUUID15 } from "crypto";
+import { randomUUID as randomUUID17 } from "crypto";
 var JobRegistry = class {
   #jobs = /* @__PURE__ */ new Map();
   #maxOutputChars;
@@ -19399,7 +19615,7 @@ var JobRegistry = class {
   }
   create(input) {
     this.#pruneCompleted();
-    const id = `job-${randomUUID15().slice(0, 12)}`;
+    const id = `job-${randomUUID17().slice(0, 12)}`;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     let settle;
     const done = new Promise((resolve28) => {
@@ -19525,7 +19741,7 @@ function snapshot2(job) {
 }
 
 // src/terminal/service.ts
-import { randomUUID as randomUUID16 } from "crypto";
+import { randomUUID as randomUUID18 } 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 {
@@ -19543,7 +19759,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-${randomUUID18().slice(0, 12)}`;
     const pty = this.#factory(shell, input.args ?? [], {
       cwd,
       cols: input.columns ?? 100,
@@ -19753,10 +19969,10 @@ function createTerminalTools(terminals, workspace = process.cwd()) {
 }
 
 // src/pals/address.ts
-import { createHash as createHash16 } from "crypto";
+import { createHash as createHash17 } from "crypto";
 function opaqueUserScope(userScope) {
   if (userScope.length === 0) throw new Error("User scope must not be empty");
-  const digest = createHash16("sha256").update(userScope, "utf8").digest("hex").slice(0, 16);
+  const digest = createHash17("sha256").update(userScope, "utf8").digest("hex").slice(0, 16);
   return `u-${digest}`;
 }
 function palSocketAddress(options) {
@@ -19769,7 +19985,7 @@ function palSocketAddress(options) {
 }
 
 // src/pals/client.ts
-import { randomUUID as randomUUID17 } from "crypto";
+import { randomUUID as randomUUID19 } from "crypto";
 import { Socket as Socket3 } from "net";
 var DEFAULT_REQUEST_TIMEOUT_MS = 5e3;
 var DEFAULT_HEARTBEAT_INTERVAL_MS = 1e4;
@@ -19845,7 +20061,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: randomUUID19() });
     return PalPresenceListSchema.parse(data2);
   }
   async rename(alias) {
@@ -19858,38 +20074,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 = randomUUID19()) {
+    const data2 = await this.request({ version: 1, type: "task", requestId: randomUUID19(), 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 = randomUUID19()) {
+    const data2 = await this.request({ version: 1, type: "chat", requestId: randomUUID19(), 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: randomUUID19(),
+      coWorkId: input.coWorkId ?? randomUUID19(),
       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: randomUUID19(), ...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: randomUUID19(), 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: randomUUID19(), coWorkId, reason });
     return CoWorkSnapshotSchema.parse(data2);
   }
   subscribe(listener) {
@@ -19901,7 +20117,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: randomUUID19() }).catch(() => void 0),
         new Promise((resolve28) => {
           disconnectTimer = setTimeout(resolve28, Math.min(this.requestTimeoutMs, 250));
         })
@@ -19992,7 +20208,7 @@ var PalClient = class {
     const data2 = await this.request({
       version: 1,
       type: "register",
-      requestId: randomUUID17(),
+      requestId: randomUUID19(),
       authToken: this.authToken,
       presence: { version: 1, ...this.registration, connectedAt: now, lastSeenAt: now }
     });
@@ -20104,7 +20320,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: randomUUID19() }).catch(() => void 0).finally(() => {
         this.heartbeatPending = false;
       });
     }, this.heartbeatIntervalMs);
@@ -20391,7 +20607,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: randomUUID20(), ...request };
     this.#onChange?.();
     return new Promise((resolvePromise) => {
       this.#settle = resolvePromise;
@@ -20510,7 +20726,20 @@ 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;
+  let islandControlMetadata;
+  const hooks = new HookBus({
+    eventContext: () => ({
+      protocolVersion: 2,
+      workspace,
+      ...hookSessionId === void 0 ? {} : { sessionId: hookSessionId },
+      ...islandControlMetadata === void 0 ? {} : {
+        islandControlEndpoint: islandControlMetadata.endpoint,
+        islandControlToken: islandControlMetadata.token,
+        islandControlCapabilities: islandControlMetadata.capabilities
+      }
+    })
+  });
   hooks.on(
     "PostToolUseFailure",
     createIncidentReporter({
@@ -20530,8 +20759,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;
@@ -20549,8 +20777,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 });
@@ -20622,8 +20852,8 @@ async function createProductionRuntime(options) {
   const registeredProviders = registration.registered;
   let effectiveLlm = registration.effectiveLlm;
   const pluginHost = new PluginHost({
-    globalPluginDirs: [join24(home, ".flavor-code", "plugins")],
-    projectPluginDirs: [join24(workspace, ".flavor", "plugins")],
+    globalPluginDirs: [join25(home, ".flavor-code", "plugins")],
+    projectPluginDirs: [join25(workspace, ".flavor", "plugins")],
     config,
     // Existing project plugins (including astgraph and superharness) use Node.js
     // built-ins. The Worker/vm sandbox deliberately blocks those imports, so it
@@ -20697,6 +20927,7 @@ async function createProductionRuntime(options) {
   const pendingCollaborationEvents = [];
   let collaborationEventPump;
   let collaborationEventsOpen = true;
+  let islandControlServer;
   const pumpCollaborationEvents = () => {
     if (collaborationEventPump !== void 0 || collaborationSession === void 0 || deliverCollaborationEvent === void 0) return;
     collaborationEventPump = (async () => {
@@ -20730,7 +20961,7 @@ async function createProductionRuntime(options) {
       const address = palSocketAddress({
         platform: process.platform,
         userScope: home,
-        runtimeDir: join24(tmpdir3(), `flavor-code-pals-${createHash17("sha256").update(home).digest("hex").slice(0, 16)}`)
+        runtimeDir: join25(tmpdir4(), `flavor-code-pals-${createHash18("sha256").update(home).digest("hex").slice(0, 16)}`)
       });
       const baseCollaborationClient = collaboration.client ?? collaboration.createClient?.({
         instanceId: collaboration.instanceId,
@@ -20841,8 +21072,8 @@ async function createProductionRuntime(options) {
       diagnostics.push(`MCP servers could not start: ${message(error)}`);
     });
     const skills = new SkillRegistry({
-      globalRoots: [join24(home, ".flavor-code", "skills")],
-      projectRoots: [join24(workspace, ".flavor", "skills"), ...pluginSkillRoots],
+      globalRoots: [join25(home, ".flavor-code", "skills")],
+      projectRoots: [join25(workspace, ".flavor", "skills"), ...pluginSkillRoots],
       authorizeResource: async () => true,
       disabledNames: config.skills.disabled
     });
@@ -20850,7 +21081,7 @@ async function createProductionRuntime(options) {
     skillsReady.catch(() => void 0);
     tools.push(createSkillTool(skills), createSkillResourceTool(skills));
     if (options.extraTools !== void 0) tools.push(...options.extraTools);
-    const flavor = await optionalText2(join24(workspace, "FLAVOR.md"));
+    const flavor = await optionalText2(join25(workspace, "FLAVOR.md"));
     const instructionBaseline = await workspaceInstructions.baseline();
     let memoryContext;
     if (memoryStore !== void 0) {
@@ -20874,7 +21105,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)}-${randomUUID20().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) {
@@ -20958,7 +21190,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,
@@ -21377,7 +21615,7 @@ async function createProductionRuntime(options) {
         evolveService.toolDefinition(),
         ...mcpTools
       ];
-      const loopFlavor = await optionalText2(join24(input.workspace, "FLAVOR.md"));
+      const loopFlavor = await optionalText2(join25(input.workspace, "FLAVOR.md"));
       const loopInstructionBaseline = await loopInstructions.baseline();
       const loopEnvironment = createPromptEnvironment({
         now: /* @__PURE__ */ new Date(),
@@ -21516,7 +21754,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)}-${randomUUID20().slice(0, 8)}`
     });
     const goalStore = new GoalStore({ workspace });
     const goalOrchestrator = new GoalOrchestrator({
@@ -21535,7 +21773,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)}-${randomUUID20().slice(0, 8)}`,
       runWorker: ({ workspace: goalWorkspace, prompt, signal }) => runLoopWorker({ workspace: goalWorkspace, prompt, signal })
     });
     let sessionHistory = await SessionHistory.open({
@@ -21648,7 +21886,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();
@@ -21806,7 +22044,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)}-${randomUUID20().slice(0, 8)}`;
+        hookSessionId = sessionId;
         harnessJournal = new HarnessJournal({ workspace, sessionId });
         setUsageSession(sessionId);
         ideSessionId = sessionId;
@@ -21906,7 +22145,7 @@ ${renderMemoryDocument(entries)}`;
           return `Provider "${providerName}" is missing authorizationUrl, tokenUrl, or clientId.`;
         }
         try {
-          const tokenStore = createFileTokenStore(join24(home, ".flavor-code", "auth.json"));
+          const tokenStore = createFileTokenStore(join25(home, ".flavor-code", "auth.json"));
           const credentialId = oauthCredentialId(oauthConfig.tokenUrl, oauthConfig.clientId);
           await migrateLegacyOAuthToken(tokenStore, providerName, credentialId);
           const oauth = new OAuthCallbackAuthProvider({
@@ -21949,7 +22188,7 @@ ${renderMemoryDocument(entries)}`;
         }
       },
       async logout() {
-        const tokenStore = createFileTokenStore(join24(home, ".flavor-code", "auth.json"));
+        const tokenStore = createFileTokenStore(join25(home, ".flavor-code", "auth.json"));
         const tokens = await tokenStore.load();
         const hadCredentials = Object.keys(tokens).length > 0 || effectiveLlm !== void 0;
         if (!hadCredentials) {
@@ -22006,6 +22245,22 @@ ${renderMemoryDocument(entries)}`;
       sleepScheduler.start();
     }
     const session = new FlavorSession(services);
+    if (pluginHost.loadedPlugins.some((plugin) => plugin.name === "flavor-island")) {
+      try {
+        islandControlServer = await createIslandControlServer({
+          sessionId,
+          session,
+          ...options.islandControl?.focus === void 0 ? {} : { focus: options.islandControl.focus }
+        });
+        islandControlMetadata = {
+          endpoint: islandControlServer.endpoint,
+          token: islandControlServer.token,
+          capabilities: islandControlServer.capabilities
+        };
+      } catch (error) {
+        diagnostics.push(`Flavor Island control channel unavailable: ${message(error)}`);
+      }
+    }
     collaborationSession = session;
     pumpCollaborationEvents();
     const authorization = {
@@ -22041,6 +22296,7 @@ ${renderMemoryDocument(entries)}`;
         if (persistTail !== void 0) await boundedStep(stepTimeoutMs, diagnostics, "persist-tail", persistTail);
         if (ideSessionId !== void 0) await boundedStep(stepTimeoutMs, diagnostics, "ide-end-session", ide.endSession(ideSessionId));
         if (executionEnvironment !== void 0) await boundedStep(stepTimeoutMs, diagnostics, "execution-environment", executionEnvironment.dispose());
+        if (islandControlServer !== void 0) await boundedStep(stepTimeoutMs, diagnostics, "island-control", islandControlServer.close());
         terminals.dispose();
         await boundedStep(stepTimeoutMs, diagnostics, "jobs", jobs.dispose());
         auditLogger.close();
@@ -22054,6 +22310,7 @@ ${renderMemoryDocument(entries)}`;
     collaborationEventsOpen = false;
     mcpDiscarded = true;
     memoryReviews.dispose();
+    await islandControlServer?.close().catch(() => void 0);
     try {
       const stepTimeoutMs = options.shutdownStepTimeoutMs ?? DEFAULT_SHUTDOWN_STEP_TIMEOUT_MS;
       if (ideSessionId !== void 0) await boundedStep(stepTimeoutMs, diagnostics, "ide-end-session", ide.endSession(ideSessionId));
@@ -22105,9 +22362,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") {
@@ -22121,8 +22379,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 } };
     }
   }
@@ -22179,7 +22448,7 @@ function terminalProgressState(status) {
   return "failed";
 }
 async function workspaceFingerprint(workspace) {
-  const hash = createHash17("sha256");
+  const hash = createHash18("sha256");
   const diff = await execFileNoThrow(
     "git",
     ["-C", workspace, "diff", "--no-ext-diff", "--binary", "HEAD"],
@@ -22414,7 +22683,7 @@ async function registerConfiguredAdapters(providers, registry, environment, diag
   const configured = { ...providers };
   if (configured.openai === void 0 && environment.OPENAI_API_KEY) configured.openai = { type: "openai", apiKey: environment.OPENAI_API_KEY };
   if (configured.anthropic === void 0 && environment.ANTHROPIC_API_KEY) configured.anthropic = { type: "anthropic", apiKey: environment.ANTHROPIC_API_KEY };
-  const oauthTokenStore = createFileTokenStore(join24(home, ".flavor-code", "auth.json"));
+  const oauthTokenStore = createFileTokenStore(join25(home, ".flavor-code", "auth.json"));
   const registered = [];
   let effectiveLlm;
   for (const [name, provider] of Object.entries(configured)) {
@@ -22833,10 +23102,10 @@ async function* runGoalSession(orchestrator, goal, signal) {
 }
 function memoryTranscriptHash(messages) {
   const visible = messages.filter((item) => item.role === "user" || item.role === "assistant").map((item) => `${item.role}\0${modelContentText(item.content).trim()}`).join("\n");
-  return createHash17("sha256").update(visible, "utf8").digest("hex");
+  return createHash18("sha256").update(visible, "utf8").digest("hex");
 }
 function createMemoryTaskId() {
-  return `memory-${randomUUID18()}`;
+  return `memory-${randomUUID20()}`;
 }
 
 export {