flavor-code 1.3.4 → 1.3.7

package/dist/desktop/main.js

@@ -1,8 +1,8 @@
 // src/desktop/main.ts
 import { appendFileSync } from "fs";
-import { createHash as createHash27, randomUUID as randomUUID27 } from "crypto";
+import { createHash as createHash28, randomUUID as randomUUID29 } 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 { basename as basename11, dirname as dirname24, join as join47, resolve as resolve40 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { app, BrowserWindow as BrowserWindow2, clipboard, dialog, ipcMain, Menu, nativeImage, Notification, shell } from "electron";
 
@@ -4218,9 +4218,9 @@ ${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 { 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";
+import { createHash as createHash21, randomUUID as randomUUID25 } from "crypto";
+import { homedir as homedir2, release as osRelease, tmpdir as tmpdir4, version as osVersion } from "os";
+import { basename as basename8, join as join32, relative as relative23, resolve as resolve32, sep as sep23 } from "path";
 
 // src/agent/subagents.ts
 import { z as z10 } from "zod";
@@ -6568,6 +6568,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)) {
@@ -6626,6 +6627,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
@@ -7524,11 +7532,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 +7660,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 +7695,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 +7718,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 +7741,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 +7766,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 +7777,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 +7787,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 +7835,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 {
     }
@@ -8438,6 +8462,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";
@@ -8504,6 +8529,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 };
@@ -8540,7 +8570,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();
@@ -8555,8 +8587,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 = {
@@ -8573,6 +8605,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]);
@@ -8584,6 +8625,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 ?? []], {
@@ -8798,19 +8842,155 @@ function createIncidentReporter(options) {
   };
 }
 
+// src/island/control-server.ts
+import { createHash as createHash7, randomUUID as randomUUID10 } from "crypto";
+import { chmod, unlink as unlink2 } from "fs/promises";
+import { tmpdir } 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(tmpdir(), `flavor-island-control-${uid}-${digest}.sock`);
+}
+async function createIslandControlServer(options) {
+  const platform = options.platform ?? process.platform;
+  const endpoint2 = 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 unlink2(endpoint2).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((resolve41, reject) => {
+    const onError = (error) => {
+      server.removeListener("listening", onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      server.removeListener("error", onError);
+      resolve41();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(endpoint2);
+  });
+  if (platform !== "win32") await chmod(endpoint2, 384).catch(() => void 0);
+  let closed = false;
+  return {
+    endpoint: endpoint2,
+    token,
+    capabilities,
+    async close() {
+      if (closed) return;
+      closed = true;
+      for (const socket of sockets) socket.destroy();
+      await closeServer(server);
+      if (platform !== "win32") await unlink2(endpoint2).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((resolve41) => {
+    try {
+      server.close(() => resolve41());
+    } catch {
+      resolve41();
+    }
+  });
+}
+
 // src/evolve/service.ts
 import { spawn as spawn2 } from "child_process";
 import { writeFile as writeFile7 } from "fs/promises";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 import { z as z19 } from "zod";
 
 // src/evolve/loader.ts
 import { cp as cp2, mkdir as mkdir7, mkdtemp, readdir as readdir3, rm as rm4, stat as stat5, writeFile as writeFile5 } from "fs/promises";
-import { tmpdir } from "os";
-import { join as join9, resolve as resolve10 } from "path";
+import { tmpdir as tmpdir2 } 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 lstat3, open as open4, readFile as readFile7, readdir as readdir2, realpath as realpath6, stat as stat4, writeFile as writeFile4 } from "fs/promises";
 import { isAbsolute as isAbsolute6, relative as relative7, resolve as resolve9, sep as sep7 } from "path";
@@ -9171,7 +9351,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);
@@ -9530,8 +9710,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}`;
@@ -9575,8 +9755,8 @@ export function activate(ctx) {
 async function scaffoldFixPlugin(workspace, name) {
   const dir = fixPluginDir(workspace, name);
   await mkdir7(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 writeFile5(manifestPath, SCAFFOLD_MANIFEST(name), { encoding: "utf8", flag: "wx" });
     await writeFile5(entryPath, SCAFFOLD_ENTRY(name), { encoding: "utf8", flag: "wx" });
@@ -9596,9 +9776,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(tmpdir(), "flavor-evolve-verify-"));
+  const sandbox = await mkdtemp(join10(tmpdir2(), "flavor-evolve-verify-"));
   try {
-    await cp2(pluginRoot, join9(sandbox, name), { recursive: true });
+    await cp2(pluginRoot, join10(sandbox, name), { recursive: true });
     const host = new PluginHost({
       projectPluginDirs: [sandbox],
       sandbox: true,
@@ -9649,7 +9829,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 mkdir7(snapshotRoot, { recursive: true });
   await cp2(pluginRoot, snapshotRoot, { recursive: true });
   return snapshotRoot;
@@ -9670,7 +9850,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 rm4(pluginRoot, { recursive: true, force: true });
   await mkdir7(pluginRoot, { recursive: true });
   await cp2(latest, pluginRoot, { recursive: true });
@@ -9678,14 +9858,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 mkdir8, readFile as readFile8, rm as rm5, writeFile as writeFile6 } from "fs/promises";
-import { dirname as dirname8, join as join10 } from "path";
+import { dirname as dirname8, 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 [];
@@ -9753,12 +9933,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;
   }
@@ -10297,7 +10477,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 writeFile7(join11(dir, "PLAN.md"), buildPlan(suggestion, name, "See the repeated failure below; describe your fix in PLAN.md."), "utf8");
+        await writeFile7(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}`,
@@ -10388,7 +10568,7 @@ ${result.stderr.slice(-4e3)}` : ""}`;
           }
           const name = sanitizePluginName(suggestion.tool);
           const dir = await scaffoldFixPlugin(workspace, name);
-          await writeFile7(join11(dir, "PLAN.md"), buildPlan(suggestion, name, implementation), "utf8");
+          await writeFile7(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}).`,
@@ -10413,7 +10593,7 @@ ${result.stderr.slice(-4e3)}` : ""}`;
 // src/init/project.ts
 import { lstat as lstat4, mkdir as mkdir9, readdir as readdir4, readFile as readFile9, realpath as realpath7, writeFile as writeFile8 } from "fs/promises";
 import { copyFileSync, mkdirSync as mkdirSync2, readdirSync } from "fs";
-import { basename as basename4, dirname as dirname9, isAbsolute as isAbsolute7, join as join12, relative as relative8, sep as sep8 } from "path";
+import { basename as basename4, dirname as dirname9, isAbsolute as isAbsolute7, join as join13, relative as relative8, sep as sep8 } from "path";
 import { fileURLToPath } from "url";
 var GENERATED_START = "<!-- flavor-code:start -->";
 var GENERATED_END = "<!-- flavor-code:end -->";
@@ -10535,7 +10715,7 @@ async function sampleSourceExtensions(cwd, root, directories) {
   const extensions = /* @__PURE__ */ new Set();
   const sampleDirectories = ["", ...directories].slice(0, 12);
   for (const relativeDirectory of sampleDirectories) {
-    const absoluteDirectory = join12(cwd, relativeDirectory);
+    const absoluteDirectory = join13(cwd, relativeDirectory);
     if (!isContainedPath(root, await realpath7(absoluteDirectory))) continue;
     let entries;
     try {
@@ -10556,15 +10736,15 @@ async function inspectProject(cwd) {
   const root = await realpath7(cwd);
   const sourceDirectories = [];
   for (const directory of SOURCE_DIRECTORIES) {
-    if (await pathKind(join12(cwd, directory), root) === "directory") sourceDirectories.push(directory);
+    if (await pathKind(join13(cwd, directory), root) === "directory") sourceDirectories.push(directory);
   }
   const instructionFiles = [];
   for (const file of INSTRUCTION_FILES) {
-    if (await pathKind(join12(cwd, file), root) === "file") instructionFiles.push(file);
+    if (await pathKind(join13(cwd, file), root) === "file") instructionFiles.push(file);
   }
   const configFiles = [];
   for (const file of CONFIG_FILES) {
-    if (await pathKind(join12(cwd, file), root) === "file") configFiles.push(file);
+    if (await pathKind(join13(cwd, file), root) === "file") configFiles.push(file);
   }
   const manifestNames = [
     "package.json",
@@ -10577,7 +10757,7 @@ async function inspectProject(cwd) {
   ];
   const present = /* @__PURE__ */ new Set();
   for (const manifest of manifestNames) {
-    if (await pathKind(join12(cwd, manifest), root) === "file") present.add(manifest);
+    if (await pathKind(join13(cwd, manifest), root) === "file") present.add(manifest);
   }
   const detectedLockfiles = JAVASCRIPT_LOCKFILES.filter(({ name }) => present.has(name));
   const detectedJsManagers = [
@@ -10603,7 +10783,7 @@ async function inspectProject(cwd) {
   let projectName = sanitizeProjectName(basename4(cwd)) ?? "project";
   let declaredJsManager;
   if (present.has("package.json")) {
-    const text = await readTextIfSmall(join12(cwd, "package.json"), root);
+    const text = await readTextIfSmall(join13(cwd, "package.json"), root);
     if (text === void 0) {
       cautions.push("package.json was too large to inspect; its scripts were ignored.");
     } else {
@@ -10657,8 +10837,8 @@ async function inspectProject(cwd) {
   addScriptCommand(testCommands, scripts, jsManager, ["test"]);
   addScriptCommand(lintCommands, scripts, jsManager, ["lint"]);
   addScriptCommand(formatCommands, scripts, jsManager, ["format", "format:check"]);
-  const pyproject = present.has("pyproject.toml") ? await readTextIfSmall(join12(cwd, "pyproject.toml"), root) : void 0;
-  const requirements = present.has("requirements.txt") ? await readTextIfSmall(join12(cwd, "requirements.txt"), root) : void 0;
+  const pyproject = present.has("pyproject.toml") ? await readTextIfSmall(join13(cwd, "pyproject.toml"), root) : void 0;
+  const requirements = present.has("requirements.txt") ? await readTextIfSmall(join13(cwd, "requirements.txt"), root) : void 0;
   const pythonTools = detectPythonTools(pyproject, requirements, configFiles);
   const pythonManager = pythonManagers[0];
   const pythonPrefix = pythonManager === "uv" ? "uv run " : pythonManager === "poetry" ? "poetry run " : pythonManager === "pipenv" ? "pipenv run " : "";
@@ -10676,8 +10856,8 @@ async function inspectProject(cwd) {
   if (present.has("pyproject.toml") || present.has("requirements.txt") || extensions.has("py")) {
     languages.add("Python");
   }
-  const gitignorePath = await pathKind(join12(cwd, ".gitignore"), root) === "file" ? ".gitignore" : void 0;
-  const hasCodeGraph = await pathKind(join12(cwd, ".flavor", "astgraph", "index.db"), root) === "file";
+  const gitignorePath = await pathKind(join13(cwd, ".gitignore"), root) === "file" ? ".gitignore" : void 0;
+  const hasCodeGraph = await pathKind(join13(cwd, ".flavor", "astgraph", "index.db"), root) === "file";
   return {
     cwd,
     projectName,
@@ -10786,7 +10966,7 @@ function isEntryIgnored(lines, entry2) {
   });
 }
 async function addSessionsToGitignore(cwd) {
-  const path = join12(cwd, ".gitignore");
+  const path = join13(cwd, ".gitignore");
   const root = await realpath7(cwd);
   await assertSafeManagedPath(path, root);
   let existing;
@@ -10820,9 +11000,9 @@ async function assertSafeManagedPath(path, root) {
 }
 async function ensureFlavorDirectories(cwd) {
   const root = await realpath7(cwd);
-  const sessionsDir = join12(cwd, ".flavor", "sessions");
-  const skillsDir = join12(cwd, ".flavor", "skills");
-  const pluginsDir = join12(cwd, ".flavor", "plugins");
+  const sessionsDir = join13(cwd, ".flavor", "sessions");
+  const skillsDir = join13(cwd, ".flavor", "skills");
+  const pluginsDir = join13(cwd, ".flavor", "plugins");
   await mkdir9(sessionsDir, { recursive: true, mode: 448 });
   await mkdir9(skillsDir, { recursive: true, mode: 448 });
   await mkdir9(pluginsDir, { recursive: true, mode: 448 });
@@ -10835,7 +11015,7 @@ async function ensureFlavorDirectories(cwd) {
   }
 }
 async function createExampleFlavorConfig(cwd) {
-  const configPath = join12(cwd, ".flavor", "flavor.json");
+  const configPath = join13(cwd, ".flavor", "flavor.json");
   const root = await realpath7(cwd);
   await assertSafeManagedPath(configPath, root);
   try {
@@ -10865,9 +11045,9 @@ async function createExampleFlavorConfig(cwd) {
   };
   await writeFile8(configPath, JSON.stringify(example, null, 2) + "\n");
 }
-var ASTGRAPH_SRC_DIR = join12(dirname9(fileURLToPath(import.meta.url)), "astgraph");
+var ASTGRAPH_SRC_DIR = join13(dirname9(fileURLToPath(import.meta.url)), "astgraph");
 async function copyAstgraphPlugin(cwd) {
-  const pluginDir = join12(cwd, ".flavor", "plugins", "astgraph");
+  const pluginDir = join13(cwd, ".flavor", "plugins", "astgraph");
   try {
     await lstat4(pluginDir);
     return;
@@ -10879,8 +11059,8 @@ async function copyAstgraphPlugin(cwd) {
 function copyDirectory(from, to) {
   mkdirSync2(to, { recursive: true, mode: 448 });
   for (const entry2 of readdirSync(from, { withFileTypes: true })) {
-    const source = join12(from, entry2.name);
-    const target = join12(to, entry2.name);
+    const source = join13(from, entry2.name);
+    const target = join13(to, entry2.name);
     if (entry2.isDirectory()) copyDirectory(source, target);
     else if (entry2.isFile()) copyFileSync(source, target);
   }
@@ -10890,7 +11070,7 @@ async function initializeFlavor(cwd) {
   await copyAstgraphPlugin(cwd);
   await createExampleFlavorConfig(cwd);
   const facts = await inspectProject(cwd);
-  const path = join12(cwd, "FLAVOR.md");
+  const path = join13(cwd, "FLAVOR.md");
   const root = await realpath7(cwd);
   await assertSafeManagedPath(path, root);
   let existing;
@@ -11306,9 +11486,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 join14 } from "path";
+import { join as join15 } from "path";
 
 // src/goal/types.ts
 import { z as z21 } from "zod";
@@ -11471,9 +11651,9 @@ function extractJson(text) {
 }
 
 // src/goal/classifier.ts
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 import { readFile as readFile10 } from "fs/promises";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 function buildSkepticPrompt(evidence, plan, index) {
   const criteriaList = plan.criteria.map((c) => `  ${c.id}. [${c.type}] ${c.description}`).join("\n");
   return [
@@ -11646,11 +11826,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 planPath2 = join13(workspace, ".flavor", "goal-plan.md");
+  const planPath2 = join14(workspace, ".flavor", "goal-plan.md");
   let planFile = null;
   try {
     planFile = await readFile10(planPath2, "utf8");
@@ -11677,7 +11857,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);
@@ -11694,7 +11874,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")
   };
 }
 
@@ -11826,7 +12006,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 {
@@ -11900,11 +12080,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 = join14(workspace, ".flavor");
-  const planPath2 = join14(dir, "goal-plan.md");
+  const dir = join15(workspace, ".flavor");
+  const planPath2 = join15(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 = [
@@ -11980,9 +12160,9 @@ function formatPriorGaps(gaps) {
 
 // src/goal/store.ts
 import { constants as constants3 } from "fs";
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID11 } 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";
+import { dirname as dirname10, join as join16, relative as relative9, resolve as resolve11, sep as sep9 } from "path";
 var DEFAULT_MAX_BYTES = 1024 * 1024;
 var GoalStore = class {
   #workspace;
@@ -11990,7 +12170,7 @@ var GoalStore = class {
   #maxBytes;
   constructor(options) {
     this.#workspace = resolve11(options.workspace);
-    this.#root = join15(this.#workspace, ".flavor", "goals");
+    this.#root = join16(this.#workspace, ".flavor", "goals");
     this.#maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
   }
   async save(input) {
@@ -11998,13 +12178,13 @@ var GoalStore = class {
     await assertNoSymlink(this.#workspace, dirname10(this.#root));
     await mkdir11(this.#root, { recursive: true, mode: 448 });
     await assertNoSymlink(this.#workspace, this.#root);
-    const target = join15(this.#root, `${state.id}.json`);
+    const target = join16(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 = join15(this.#root, `.${state.id}.${process.pid}.${randomUUID9()}.tmp`);
+    const temporary = join16(this.#root, `.${state.id}.${process.pid}.${randomUUID11()}.tmp`);
     let handle;
     try {
       handle = await open5(temporary, constants3.O_CREAT | constants3.O_EXCL | constants3.O_WRONLY, 384);
@@ -12045,7 +12225,7 @@ function isCode4(error, code) {
 
 // src/loop/isolation.ts
 import { appendFile as appendFile2, mkdir as mkdir12, readFile as readFile11 } from "fs/promises";
-import { join as join16, resolve as resolve12 } from "path";
+import { join as join17, 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) {
@@ -12068,8 +12248,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 = join16(root, ".worktrees");
-  const path = join16(worktrees, `loop-${options.loopId}`);
+  const worktrees = join17(root, ".worktrees");
+  const path = join17(worktrees, `loop-${options.loopId}`);
   const branch = `loop/${options.loopId}`;
   try {
     await ensureWorktreeDirectoryIgnored(root);
@@ -12099,8 +12279,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 = join16(gitDirectory, "info");
-  const excludePath = join16(infoDirectory, "exclude");
+  const infoDirectory = join17(gitDirectory, "info");
+  const excludePath = join17(infoDirectory, "exclude");
   await mkdir12(infoDirectory, { recursive: true });
   let existing = "";
   try {
@@ -12116,8 +12296,8 @@ async function ensureWorktreeDirectoryIgnored(root) {
 // src/loop/store.ts
 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 { dirname as dirname11, join as join18, 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 {
@@ -12127,7 +12307,7 @@ var LoopStore = class {
   #appendTails = /* @__PURE__ */ new Map();
   constructor(options) {
     this.#workspace = resolve13(options.workspace);
-    this.#root = join17(this.#workspace, ".flavor", "loops");
+    this.#root = join18(this.#workspace, ".flavor", "loops");
     this.#maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES2;
   }
   async create(state) {
@@ -12144,11 +12324,11 @@ var LoopStore = class {
     const state = LoopStateSchema.parse(input);
     await this.#assertWorkspace(state.workspace);
     const directory = await this.#prepare(state.loopId);
-    const target = join17(directory, "state.json");
+    const target = join18(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 = join17(directory, `.state.${process.pid}.${randomUUID10()}.tmp`);
+    const temporary = join18(directory, `.state.${process.pid}.${randomUUID12()}.tmp`);
     let handle;
     try {
       handle = await open6(temporary, constants4.O_CREAT | constants4.O_EXCL | constants4.O_WRONLY, 384);
@@ -12164,7 +12344,7 @@ var LoopStore = class {
   }
   async load(loopId) {
     const directory = await this.#safeExisting(loopId);
-    const target = join17(directory, "state.json");
+    const target = join18(directory, "state.json");
     try {
       const metadata = await stat6(target);
       if (!metadata.isFile() || metadata.size > this.#maxBytes) throw new Error("Loop state is not a bounded regular file");
@@ -12174,7 +12354,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()}-${randomUUID12().slice(0, 8)}`;
       await rename5(target, quarantine).catch(() => void 0);
       throw new Error(`Loop "${loopId}" is corrupt and was quarantined: ${message(error)}`);
     }
@@ -12184,7 +12364,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 = join17(directory, "events.jsonl");
+      const path = join18(directory, "events.jsonl");
       const handle = await open6(path, constants4.O_CREAT | constants4.O_APPEND | constants4.O_WRONLY, 384);
       try {
         await handle.writeFile(`${JSON.stringify(event)}
@@ -12201,7 +12381,7 @@ var LoopStore = class {
     await assertNoSymlink2(this.#workspace, dirname11(this.#root));
     await mkdir13(this.#root, { recursive: true, mode: 448 });
     await assertNoSymlink2(this.#workspace, this.#root);
-    const directory = join17(this.#root, loopId);
+    const directory = join18(this.#root, loopId);
     await mkdir13(directory, { recursive: true, mode: 448 });
     await assertNoSymlink2(this.#workspace, directory);
     return directory;
@@ -12209,7 +12389,7 @@ var LoopStore = class {
   async #safeExisting(loopId) {
     validateId(loopId);
     await assertNoSymlink2(this.#workspace, this.#root);
-    const directory = join17(this.#root, loopId);
+    const directory = join18(this.#root, loopId);
     await assertNoSymlink2(this.#workspace, directory);
     return directory;
   }
@@ -12258,7 +12438,7 @@ function isCode5(error, code) {
 
 // src/loop/verifier.ts
 import { readFile as readFile13 } from "fs/promises";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 
 // src/tools/shell.ts
 import { spawn as spawn3, spawnSync } from "child_process";
@@ -12816,13 +12996,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(join18(workspace, "package.json"));
+  const packageJson = await optionalJson(join19(workspace, "package.json"));
   const scripts = isRecord3(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(join18(workspace, "FLAVOR.md"));
+  const flavor = await optionalText(join19(workspace, "FLAVOR.md"));
   if (flavor !== void 0) {
     for (const match of flavor.matchAll(/^- `([^`]+)`\s*$/gm)) {
       const parsed = parseTrustedCommand(match[1] ?? "");
@@ -12959,11 +13139,11 @@ function isEnvTruthy(value) {
 
 // src/utils/log.ts
 import { appendFile as appendFile3, mkdir as mkdir14 } from "fs/promises";
-import { dirname as dirname12, join as join19, resolve as resolve15 } from "path";
+import { dirname as dirname12, join as join20, resolve as resolve15 } from "path";
 var pending = Promise.resolve();
 var usagePending = Promise.resolve();
 function usageLogPath() {
-  return process.env.FLAVOR_USAGE_FILE ?? join19(process.cwd(), ".flavor", "usage.jsonl");
+  return process.env.FLAVOR_USAGE_FILE ?? join20(process.cwd(), ".flavor", "usage.jsonl");
 }
 var usageSessionId = "unknown";
 var truncateOnNextAppend = false;
@@ -12992,7 +13172,7 @@ var AuditLogger = class {
   #path;
   #closed = false;
   constructor(workspace) {
-    this.#path = join19(resolve15(workspace), ".flavor", "audit.jsonl");
+    this.#path = join20(resolve15(workspace), ".flavor", "audit.jsonl");
   }
   get path() {
     return this.#path;
@@ -13590,7 +13770,7 @@ var ModelRegistry = class {
 };
 
 // src/mcp/client.ts
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 import { z as z24 } from "zod";
 var McpManager = class {
   #workspace;
@@ -13757,7 +13937,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) {
@@ -13788,7 +13968,7 @@ import {
 
 // src/utils/version.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname13, join as join20 } from "path";
+import { dirname as dirname13, join as join21 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var cached;
 function packageVersion() {
@@ -13796,7 +13976,7 @@ function packageVersion() {
   let directory = dirname13(fileURLToPath2(import.meta.url));
   for (; ; ) {
     try {
-      const manifest = JSON.parse(readFileSync2(join20(directory, "package.json"), "utf8"));
+      const manifest = JSON.parse(readFileSync2(join21(directory, "package.json"), "utf8"));
       if (typeof manifest.version === "string" && manifest.version.length > 0) {
         cached = manifest.version;
         return cached;
@@ -13849,14 +14029,14 @@ async function connectSdkMcpClient(input, dependencies2 = 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) {
@@ -14033,7 +14213,7 @@ var OAuthCallbackAuthProvider = class {
       serverResolve = resolve41;
       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";
@@ -14113,7 +14293,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");
@@ -14224,7 +14404,7 @@ function isStoredToken(value) {
 
 // src/permissions/policy.ts
 import { readFile as readFile16 } from "fs/promises";
-import { join as join21, resolve as resolve17 } from "path";
+import { join as join22, resolve as resolve17 } from "path";
 import { z as z25 } from "zod";
 var DecisionSchema2 = z25.enum(["allow", "ask", "deny"]);
 var PrefixSchema = z25.array(z25.string().min(1).max(1024)).min(1).max(64);
@@ -14261,9 +14441,9 @@ var CompiledPermissionPolicy = class {
 async function loadPermissionPolicy(options) {
   const sources = [
     ...options.managedPath === void 0 ? [] : [{ tier: "managed", path: resolve17(options.managedPath) }],
-    { tier: "user", path: join21(resolve17(options.home), ".flavor-code", "permissions.json") },
-    { tier: "project", path: join21(resolve17(options.workspace), ".flavor", "permissions.json") },
-    { tier: "local", path: join21(resolve17(options.workspace), ".flavor", "permissions.local.json") }
+    { tier: "user", path: join22(resolve17(options.home), ".flavor-code", "permissions.json") },
+    { tier: "project", path: join22(resolve17(options.workspace), ".flavor", "permissions.json") },
+    { tier: "local", path: join22(resolve17(options.workspace), ".flavor", "permissions.local.json") }
   ];
   const rules = [];
   for (const source of sources) {
@@ -15032,8 +15212,8 @@ function createSkillResourceTool(registry) {
 // src/session/store.ts
 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 { basename as basename5, dirname as dirname15, join as join23, relative as relative13, resolve as resolve19, sep as sep13 } from "path";
+import { randomUUID as randomUUID13 } from "crypto";
 import { z as z27 } from "zod";
 
 // src/ui/transcript.ts
@@ -15689,7 +15869,7 @@ var SessionStore = class {
   #maxSessions;
   constructor(options) {
     this.#workspace = resolve19(options.workspace);
-    this.#sessions = join22(this.#workspace, ".flavor", "sessions");
+    this.#sessions = join23(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;
@@ -15721,7 +15901,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 = join23(this.#sessions, `.${document.sessionId}.${process.pid}.${randomUUID13()}.tmp`);
     let handle;
     try {
       handle = await open7(temporary, constants6.O_CREAT | constants6.O_EXCL | constants6.O_WRONLY, 384);
@@ -15838,7 +16018,7 @@ var SessionStore = class {
       const metadata = await lstat8(path);
       if (!metadata.isFile()) throw new Error("Session path is not a regular file");
       await rm8(path);
-      await rm8(join22(this.#sessions, `${sessionId}.events.jsonl`), { force: true }).catch(() => void 0);
+      await rm8(join23(this.#sessions, `${sessionId}.events.jsonl`), { force: true }).catch(() => void 0);
     } catch (error) {
       if (!isCode8(error, "ENOENT")) throw error;
     }
@@ -15855,7 +16035,7 @@ var SessionStore = class {
     const excess = entries.slice(this.#maxSessions);
     for (const entry2 of excess) {
       await rm8(this.#path(entry2.sessionId), { force: true }).catch(() => void 0);
-      await rm8(join22(this.#sessions, `${entry2.sessionId}.events.jsonl`), { force: true }).catch(() => void 0);
+      await rm8(join23(this.#sessions, `${entry2.sessionId}.events.jsonl`), { force: true }).catch(() => void 0);
     }
   }
   async #assertWorkspace(stored) {
@@ -15877,7 +16057,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;
   }
@@ -16096,15 +16276,15 @@ function sanitize2(input, seen = /* @__PURE__ */ new WeakSet()) {
 }
 
 // src/session/tree.ts
-import { randomUUID as randomUUID13 } from "crypto";
+import { randomUUID as randomUUID15 } 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";
+import { dirname as dirname17, join as join25, resolve as resolve21 } from "path";
 
 // src/session/checkpoint.ts
-import { createHash as createHash14, randomUUID as randomUUID12 } from "crypto";
+import { createHash as createHash15, randomUUID as randomUUID14 } 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";
+import { dirname as dirname16, join as join24, relative as relative14, resolve as resolve20, sep as sep14 } from "path";
 var EXCLUDED = /* @__PURE__ */ new Set([".git", ".flavor", "node_modules", "dist", "build", "release", ".worktrees"]);
 var MAX_FILE_BYTES = 16 * 1024 * 1024;
 var MAX_TOTAL_BYTES = 128 * 1024 * 1024;
@@ -16117,9 +16297,9 @@ var WorkspaceCheckpointStore = class {
   #maxTotalBytes;
   constructor(options) {
     this.#workspace = resolve20(options.workspace);
-    this.#root = join23(this.#workspace, ".flavor", "checkpoints");
-    this.#objects = join23(this.#root, "objects");
-    this.#manifests = join23(this.#root, "manifests");
+    this.#root = join24(this.#workspace, ".flavor", "checkpoints");
+    this.#objects = join24(this.#root, "objects");
+    this.#manifests = join24(this.#root, "manifests");
     this.#maxFileBytes = options.maxFileBytes ?? MAX_FILE_BYTES;
     this.#maxTotalBytes = options.maxTotalBytes ?? MAX_TOTAL_BYTES;
   }
@@ -16138,8 +16318,8 @@ var WorkspaceCheckpointStore = class {
       total += info.size;
       if (total > this.#maxTotalBytes) throw new Error("Checkpoint exceeds total size limit");
       const content = await readFile18(absolute);
-      const digest = createHash14("sha256").update(content).digest("hex");
-      const objectPath = join23(this.#objects, digest);
+      const digest = createHash15("sha256").update(content).digest("hex");
+      const objectPath = join24(this.#objects, digest);
       try {
         const handle = await open8(objectPath, "wx");
         try {
@@ -16154,17 +16334,17 @@ var WorkspaceCheckpointStore = class {
     }
     const checkpoint = {
       version: 1,
-      id: `checkpoint-${Date.now()}-${randomUUID12().slice(0, 8)}`,
+      id: `checkpoint-${Date.now()}-${randomUUID14().slice(0, 8)}`,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       ...label === void 0 || label.trim().length === 0 ? {} : { label: label.trim() },
       files
     };
-    await atomicJson(join23(this.#manifests, `${checkpoint.id}.json`), checkpoint);
+    await atomicJson(join24(this.#manifests, `${checkpoint.id}.json`), checkpoint);
     return checkpoint;
   }
   async load(id) {
     if (!/^checkpoint-[A-Za-z0-9-]+$/.test(id)) throw new Error("Invalid checkpoint id");
-    const value = JSON.parse(await readFile18(join23(this.#manifests, `${id}.json`), "utf8"));
+    const value = JSON.parse(await readFile18(join24(this.#manifests, `${id}.json`), "utf8"));
     if (value.version !== 1 || value.id !== id || !Array.isArray(value.files)) throw new Error("Invalid checkpoint manifest");
     for (const file of value.files) {
       contained(this.#workspace, file.path);
@@ -16176,8 +16356,8 @@ var WorkspaceCheckpointStore = class {
     const checkpoint = await this.load(id);
     const objects = /* @__PURE__ */ new Map();
     for (const file of checkpoint.files) {
-      const object = await readFile18(join23(this.#objects, file.digest));
-      if (object.length !== file.size || createHash14("sha256").update(object).digest("hex") !== file.digest) {
+      const object = await readFile18(join24(this.#objects, file.digest));
+      if (object.length !== file.size || createHash15("sha256").update(object).digest("hex") !== file.digest) {
         throw new Error(`Checkpoint object is corrupt: ${file.digest}`);
       }
       objects.set(file.digest, object);
@@ -16191,7 +16371,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}.${randomUUID14()}.tmp`;
       await writeFile10(temporary, object, { mode: file.mode });
       await rename7(temporary, target);
     }
@@ -16199,7 +16379,7 @@ var WorkspaceCheckpointStore = class {
   }
 };
 async function discoverFiles(workspace) {
-  if (await exists2(join23(workspace, ".git"))) {
+  if (await exists2(join24(workspace, ".git"))) {
     const listed = await gitFiles(workspace);
     return listed.filter((path) => !EXCLUDED.has(path.split("/")[0] ?? "")).sort();
   }
@@ -16208,7 +16388,7 @@ async function discoverFiles(workspace) {
     const entries = await readdir7(directory, { withFileTypes: true });
     for (const entry2 of entries) {
       if (EXCLUDED.has(entry2.name)) continue;
-      const absolute = join23(directory, entry2.name);
+      const absolute = join24(directory, entry2.name);
       const path = normalizeRelative(relative14(workspace, absolute));
       if (entry2.isSymbolicLink()) throw new Error(`Checkpoint refuses symbolic link: ${path}`);
       if (entry2.isDirectory()) await walk(absolute);
@@ -16263,7 +16443,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}.${randomUUID14()}.tmp`;
   await writeFile10(temporary, `${JSON.stringify(value)}
 `, { encoding: "utf8", mode: 384 });
   await rename7(temporary, path);
@@ -16281,14 +16461,14 @@ var SessionHistory = class _SessionHistory {
   #leafId;
   #unrevert;
   constructor(options, document) {
-    this.#path = join24(resolve21(options.workspace), ".flavor", "session-trees", options.sessionId, "tree.json");
+    this.#path = join25(resolve21(options.workspace), ".flavor", "session-trees", options.sessionId, "tree.json");
     this.#checkpoints = new WorkspaceCheckpointStore({ workspace: options.workspace });
     this.#restoreContext = options.restoreContext;
     this.#nodes = document.nodes;
     this.#leafId = document.leafId;
   }
   static async open(options) {
-    const path = join24(resolve21(options.workspace), ".flavor", "session-trees", options.sessionId, "tree.json");
+    const path = join25(resolve21(options.workspace), ".flavor", "session-trees", options.sessionId, "tree.json");
     let document = { version: 1, sessionId: options.sessionId, leafId: null, nodes: [] };
     try {
       const parsed = JSON.parse(await readFile19(path, "utf8"));
@@ -16308,7 +16488,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()}-${randomUUID15().slice(0, 8)}`,
       parentId: this.#leafId,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       prompt: input.prompt,
@@ -16366,7 +16546,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}.${randomUUID15()}.tmp`;
     await writeFile11(temporary, `${JSON.stringify(document)}
 `, { encoding: "utf8", mode: 384 });
     await rename8(temporary, this.#path);
@@ -16392,9 +16572,9 @@ function isCode10(error, code) {
 
 // src/sleep/organizer.ts
 import { constants as constants7 } from "fs";
-import { randomUUID as randomUUID14 } from "crypto";
+import { randomUUID as randomUUID16 } 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 { isAbsolute as isAbsolute10, join as join26, relative as relative15, resolve as resolve22, sep as sep15 } from "path";
 import { z as z28 } from "zod";
 var DateKeySchema = z28.string().regex(/^\d{4}-\d{2}-\d{2}$/);
 var ReviewSchema = z28.object({
@@ -16449,7 +16629,7 @@ var ProjectSleepOrganizer = class {
   #generate;
   constructor(options) {
     this.#workspace = resolve22(options.workspace);
-    this.#sleepDirectory = join25(this.#workspace, ".flavor", "sleep");
+    this.#sleepDirectory = join26(this.#workspace, ".flavor", "sleep");
     this.#sessions = options.sessions ?? new SessionStore({ workspace: this.#workspace });
     this.#generate = options.generate;
   }
@@ -16458,7 +16638,7 @@ var ProjectSleepOrganizer = class {
     signal.throwIfAborted();
     await this.#prepareDirectory();
     if (await this.#hasReport(date)) return { status: "exists", date };
-    const lockPath = join25(this.#sleepDirectory, `.${date}.lock`);
+    const lockPath = join26(this.#sleepDirectory, `.${date}.lock`);
     let lock;
     try {
       lock = await open9(lockPath, constants7.O_CREAT | constants7.O_EXCL | constants7.O_WRONLY, 384);
@@ -16493,7 +16673,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 = join25(this.#sleepDirectory, filename2);
+      const path = join26(this.#sleepDirectory, filename2);
       const markdown = renderSleepReport(date, review, documents);
       await this.#atomicWrite(path, markdown);
       return { status: "written", date, path, sessionCount: documents.length };
@@ -16535,7 +16715,7 @@ Previous output was invalid. Repair it and return strict JSON only.`;
     });
   }
   async #prepareDirectory() {
-    const flavorDirectory = join25(this.#workspace, ".flavor");
+    const flavorDirectory = join26(this.#workspace, ".flavor");
     await assertNotSymlink(flavorDirectory);
     await mkdir18(flavorDirectory, { recursive: true, mode: 448 });
     await assertNotSymlink(this.#sleepDirectory);
@@ -16549,7 +16729,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 = join26(this.#sleepDirectory, `.${randomUUID16()}.tmp`);
     let handle;
     try {
       handle = await open9(temporary, constants7.O_CREAT | constants7.O_EXCL | constants7.O_WRONLY, 384);
@@ -16925,7 +17105,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 randomUUID17 } from "crypto";
 import { z as z29 } from "zod";
 
 // src/tools/file-diff.ts
@@ -17278,7 +17458,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}.${randomUUID17()}.tmp`;
   try {
     const handle = await open10(temporary, constants8.O_CREAT | constants8.O_EXCL | constants8.O_WRONLY, 384);
     try {
@@ -19340,18 +19520,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 });
@@ -19360,12 +19562,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);
         }
@@ -19451,9 +19655,9 @@ function createTodoWriteTool() {
 }
 
 // src/tools/managed.ts
-import { randomUUID as randomUUID16 } 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 { randomUUID as randomUUID18 } from "crypto";
+import { link, lstat as lstat11, mkdir as mkdir20, readFile as readFile22, readdir as readdir9, unlink as unlink3, writeFile as writeFile12 } from "fs/promises";
+import { dirname as dirname21, join as join27, resolve as resolve26 } from "path";
 import { z as z37 } from "zod";
 var MANAGED_TOOL_VERSION = 1;
 var MAX_RECORD_BYTES = 256 * 1024;
@@ -19496,8 +19700,8 @@ var ManagedToolStore = class {
   #diagnostics = [];
   constructor(options) {
     this.#workspace = resolve26(options.workspace);
-    this.#projectRoot = join26(this.#workspace, ".flavor", "tools");
-    this.#globalRoot = join26(resolve26(options.home), ".flavor-code", "tools");
+    this.#projectRoot = join27(this.#workspace, ".flavor", "tools");
+    this.#globalRoot = join27(resolve26(options.home), ".flavor-code", "tools");
     this.#now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   }
   get diagnostics() {
@@ -19544,7 +19748,7 @@ var ManagedToolStore = class {
       version: MANAGED_TOOL_VERSION,
       createdAt: this.#now()
     });
-    const path = join26(this.directory(input.scope), filename(input.name));
+    const path = join27(this.directory(input.scope), filename(input.name));
     const definition = compileDefinition(record3, input.scope, this.#workspace);
     await writeExclusive(path, `${JSON.stringify(record3, void 0, 2)}
 `);
@@ -19560,7 +19764,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 unlink2(entry2.path);
+    await unlink3(entry2.path);
     this.#entries.delete(scopedKey(entry2.scope, entry2.record.name));
     return summary(entry2, false);
   }
@@ -19569,7 +19773,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 [join26(this.directory(parsed.data.scope ?? "project"), filename(parsed.data.name))];
+    return [join27(this.directory(parsed.data.scope ?? "project"), filename(parsed.data.name))];
   }
   async #loadDirectory(scope2) {
     const root = this.directory(scope2);
@@ -19582,7 +19786,7 @@ var ManagedToolStore = class {
       return;
     }
     for (const name of names) {
-      const path = join26(root, name);
+      const path = join27(root, name);
       try {
         const info = await lstat11(path);
         if (!info.isFile() || info.isSymbolicLink()) throw new Error("Managed tool record must be a regular file");
@@ -19738,13 +19942,13 @@ ${sourceUrl}`
 }
 async function writeExclusive(path, content) {
   await mkdir20(dirname21(path), { recursive: true });
-  const temporary = `${path}.${randomUUID16()}.tmp`;
+  const temporary = `${path}.${randomUUID18()}.tmp`;
   try {
     await writeFile12(temporary, content, { encoding: "utf8", flag: "wx", mode: 384 });
     await link(temporary, path);
   } finally {
     try {
-      await unlink2(temporary);
+      await unlink3(temporary);
     } catch {
     }
   }
@@ -20692,6 +20896,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,
@@ -20718,6 +20924,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 (controller2.signal.aborted) outcome = "cancelled";
@@ -20742,7 +20950,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) } });
@@ -21475,7 +21691,7 @@ function buildWarningMessages(report, languageTag) {
 }
 
 // src/hallucination/sliding-window.ts
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 var SlidingWindow = class {
   #windowSize;
   #threshold;
@@ -21491,7 +21707,7 @@ var SlidingWindow = class {
   }
   hash(toolName, params) {
     const sorted = JSON.stringify(params, sortedKeys(params));
-    return createHash15("sha256").update(`${toolName}:${sorted}`).digest("hex");
+    return createHash16("sha256").update(`${toolName}:${sorted}`).digest("hex");
   }
   push(toolName, params) {
     const hash = this.hash(toolName, params);
@@ -21846,9 +22062,9 @@ ${total}`;
 }
 
 // src/memory/store.ts
-import { createHash as createHash16 } from "crypto";
+import { createHash as createHash17 } from "crypto";
 import { readFile as readFile23, rm as rm12 } from "fs/promises";
-import { resolve as resolve27, join as join27, relative as relative19, sep as sep19 } from "path";
+import { resolve as resolve27, join as join28, relative as relative19, sep as sep19 } from "path";
 
 // src/memory/similarity.ts
 function normalizeForSimilarity(value) {
@@ -21951,9 +22167,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 = resolve27(options.workspace);
-    this.#memoryRoot = join27(this.workspace, ".flavor", "memory");
-    this.path = join27(this.#memoryRoot, "MEMORY.md");
-    this.#behaviorPath = join27(this.#memoryRoot, "behavior.json");
+    this.#memoryRoot = join28(this.workspace, ".flavor", "memory");
+    this.path = join28(this.#memoryRoot, "MEMORY.md");
+    this.#behaviorPath = join28(this.#memoryRoot, "behavior.json");
     this.#maxEntries = options.maxEntries;
     this.#maxEntryChars = options.maxEntryChars;
   }
@@ -22332,7 +22548,7 @@ function sanitizeTopicKey(value) {
   return value.normalize("NFKC").toLocaleLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 128);
 }
 function memoryId(type, content) {
-  return createHash16("sha256").update(`${type}\0${normalizeMemoryContent(content).toLocaleLowerCase()}`, "utf8").digest("hex").slice(0, 12);
+  return createHash17("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}`);
@@ -22742,7 +22958,7 @@ function createExecutionEnvironment(workspace, config) {
 
 // src/ide/client.ts
 import { readFile as readFile24, readdir as readdir10, stat as stat10 } from "fs/promises";
-import { basename as basename7, join as join28, relative as relative21, resolve as resolve29, sep as sep21 } from "path";
+import { basename as basename7, join as join29, relative as relative21, resolve as resolve29, sep as sep21 } from "path";
 var FlavorIdeClient = class {
   #workspace;
   #home;
@@ -22838,7 +23054,7 @@ var FlavorIdeClient = class {
       };
       if (await this.#healthy(configured)) return configured;
     }
-    const directory = join28(this.#home, ".flavor-code", "ide");
+    const directory = join29(this.#home, ".flavor-code", "ide");
     let entries;
     try {
       entries = (await readdir10(directory)).filter((name) => name.endsWith(".lock"));
@@ -22846,7 +23062,7 @@ var FlavorIdeClient = class {
       return void 0;
     }
     const candidates = (await Promise.all(entries.map(async (name) => {
-      const path = join28(directory, name);
+      const path = join29(directory, name);
       try {
         const [contents, info] = await Promise.all([readFile24(path, "utf8"), stat10(path)]);
         const lock = parseLockfile(contents);
@@ -22966,7 +23182,7 @@ function relativeDisplay(workspace, filePath) {
 }
 
 // src/jobs/registry.ts
-import { randomUUID as randomUUID17 } from "crypto";
+import { randomUUID as randomUUID19 } from "crypto";
 var JobRegistry = class {
   #jobs = /* @__PURE__ */ new Map();
   #maxOutputChars;
@@ -22980,7 +23196,7 @@ var JobRegistry = class {
   }
   create(input) {
     this.#pruneCompleted();
-    const id = `job-${randomUUID17().slice(0, 12)}`;
+    const id = `job-${randomUUID19().slice(0, 12)}`;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     let settle;
     const done = new Promise((resolve41) => {
@@ -23106,7 +23322,7 @@ function snapshot2(job) {
 }
 
 // src/terminal/service.ts
-import { randomUUID as randomUUID18 } from "crypto";
+import { randomUUID as randomUUID20 } 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 {
@@ -23124,7 +23340,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-${randomUUID20().slice(0, 12)}`;
     const pty = this.#factory(shell2, input.args ?? [], {
       cwd,
       cols: input.columns ?? 100,
@@ -23334,10 +23550,10 @@ function createTerminalTools(terminals, workspace = process.cwd()) {
 }
 
 // src/pals/address.ts
-import { createHash as createHash17 } from "crypto";
+import { createHash as createHash18 } from "crypto";
 function opaqueUserScope(userScope) {
   if (userScope.length === 0) throw new Error("User scope must not be empty");
-  const digest = createHash17("sha256").update(userScope, "utf8").digest("hex").slice(0, 16);
+  const digest = createHash18("sha256").update(userScope, "utf8").digest("hex").slice(0, 16);
   return `u-${digest}`;
 }
 function palSocketAddress(options) {
@@ -23350,32 +23566,32 @@ function palSocketAddress(options) {
 }
 
 // src/pals/broker-cli.ts
-import { createHash as createHash19 } from "crypto";
+import { createHash as createHash20 } from "crypto";
 import { Socket as Socket2 } from "net";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join30 } from "path";
+import { tmpdir as tmpdir3 } from "os";
+import { join as join31 } from "path";
 import { spawn as spawn7 } from "child_process";
 
 // src/pals/broker.ts
-import { createHash as createHash18, randomUUID as randomUUID21, 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 { createHash as createHash19, randomUUID as randomUUID23, timingSafeEqual } from "crypto";
+import { chmod as chmod3, lstat as lstat12, mkdir as mkdir23, unlink as unlink6 } from "fs/promises";
+import { createServer as createServer4, Socket } from "net";
 import { dirname as dirname23 } from "path";
 
 // src/pals/auth.ts
-import { randomBytes as randomBytes3, randomUUID as randomUUID19 } from "crypto";
-import { chmod, link as link2, mkdir as mkdir21, open as open12, readFile as readFile25, unlink as unlink3 } from "fs/promises";
+import { randomBytes as randomBytes3, randomUUID as randomUUID21 } from "crypto";
+import { chmod as chmod2, link as link2, mkdir as mkdir21, open as open12, readFile as readFile25, unlink as unlink4 } from "fs/promises";
 import { homedir } from "os";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 var PAL_AUTH_TOKEN_BYTES = 32;
 var TOKEN_PATTERN = /^[a-f0-9]{64}$/;
 async function loadOrCreatePalAuthToken(options = {}) {
-  const directory = join29(options.home ?? homedir(), ".flavor-code", "pals");
-  const tokenPath = join29(directory, "auth-token");
+  const directory = join30(options.home ?? homedir(), ".flavor-code", "pals");
+  const tokenPath = join30(directory, "auth-token");
   await mkdir21(directory, { recursive: true, mode: 448 });
-  await chmod(directory, 448);
+  await chmod2(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 = join30(directory, `.auth-token-${process.pid}-${randomUUID21()}.tmp`);
   let handle;
   try {
     handle = await open12(temporaryPath, "wx", 384);
@@ -23394,13 +23610,13 @@ async function loadOrCreatePalAuthToken(options = {}) {
     }
   } finally {
     await handle?.close();
-    await unlink3(temporaryPath).catch((error) => {
+    await unlink4(temporaryPath).catch((error) => {
       if (error.code !== "ENOENT") throw error;
     });
   }
   const stored = (await readFile25(tokenPath, "utf8")).trim();
   if (!TOKEN_PATTERN.test(stored)) throw new Error("Pals authentication token store is invalid");
-  await chmod(tokenPath, 384);
+  await chmod2(tokenPath, 384);
   return stored;
 }
 function validatePalAuthToken(token) {
@@ -23409,8 +23625,8 @@ function validatePalAuthToken(token) {
 }
 
 // src/pals/lifecycle.ts
-import { randomUUID as randomUUID20 } 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 { randomUUID as randomUUID22 } from "crypto";
+import { mkdir as mkdir22, open as open13, readFile as readFile26, rename as rename11, stat as stat11, unlink as unlink5 } from "fs/promises";
 import { dirname as dirname22 } from "path";
 function defaultProcessAlive(pid) {
   if (!Number.isSafeInteger(pid) || pid <= 0) return true;
@@ -23435,7 +23651,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 = randomUUID22();
   const metadata = { pid, createdAt: now(), nonce };
   let handle;
   try {
@@ -23460,7 +23676,7 @@ async function acquirePalFileLock(options) {
       if (openError.code !== "EEXIST") throw openError;
       return void 0;
     } finally {
-      await unlink4(tombstone).catch((unlinkError) => {
+      await unlink5(tombstone).catch((unlinkError) => {
         if (unlinkError.code !== "ENOENT") throw unlinkError;
       });
     }
@@ -23474,7 +23690,7 @@ async function acquirePalFileLock(options) {
   const release = async () => {
     const current = parseMetadata(await readFile26(options.path, "utf8").catch(() => ""));
     if (current?.nonce !== nonce) return;
-    await unlink4(options.path).catch((error) => {
+    await unlink5(options.path).catch((error) => {
       if (error.code !== "ENOENT") throw error;
     });
   };
@@ -23504,8 +23720,8 @@ function canConnect(address) {
   });
 }
 function startupLockPath(address) {
-  const digest = createHash19("sha256").update(address, "utf8").digest("hex").slice(0, 24);
-  return join30(tmpdir2(), `flavor-code-pals-${digest}.startup.lock`);
+  const digest = createHash20("sha256").update(address, "utf8").digest("hex").slice(0, 24);
+  return join31(tmpdir3(), `flavor-code-pals-${digest}.startup.lock`);
 }
 async function spawnProductionBroker(address) {
   const entry2 = process.argv[1];
@@ -23554,7 +23770,7 @@ async function ensureOnce(options) {
 }
 
 // src/pals/client.ts
-import { randomUUID as randomUUID22 } from "crypto";
+import { randomUUID as randomUUID24 } from "crypto";
 import { Socket as Socket3 } from "net";
 var DEFAULT_REQUEST_TIMEOUT_MS = 5e3;
 var DEFAULT_HEARTBEAT_INTERVAL_MS = 1e4;
@@ -23630,7 +23846,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: randomUUID24() });
     return PalPresenceListSchema.parse(data2);
   }
   async rename(alias) {
@@ -23643,38 +23859,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 = randomUUID24()) {
+    const data2 = await this.request({ version: 1, type: "task", requestId: randomUUID24(), 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 = randomUUID24()) {
+    const data2 = await this.request({ version: 1, type: "chat", requestId: randomUUID24(), 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: randomUUID24(),
+      coWorkId: input.coWorkId ?? randomUUID24(),
       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: randomUUID24(), ...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: randomUUID24(), 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: randomUUID24(), coWorkId, reason });
     return CoWorkSnapshotSchema.parse(data2);
   }
   subscribe(listener) {
@@ -23686,7 +23902,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: randomUUID24() }).catch(() => void 0),
         new Promise((resolve41) => {
           disconnectTimer = setTimeout(resolve41, Math.min(this.requestTimeoutMs, 250));
         })
@@ -23777,7 +23993,7 @@ var PalClient = class {
     const data2 = await this.request({
       version: 1,
       type: "register",
-      requestId: randomUUID22(),
+      requestId: randomUUID24(),
       authToken: this.authToken,
       presence: { version: 1, ...this.registration, connectedAt: now, lastSeenAt: now }
     });
@@ -23889,7 +24105,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: randomUUID24() }).catch(() => void 0).finally(() => {
         this.heartbeatPending = false;
       });
     }, this.heartbeatIntervalMs);
@@ -24176,7 +24392,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: randomUUID25(), ...request };
     this.#onChange?.();
     return new Promise((resolvePromise) => {
       this.#settle = resolvePromise;
@@ -24295,7 +24511,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({
@@ -24315,8 +24544,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;
@@ -24334,8 +24562,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 });
@@ -24407,8 +24637,8 @@ async function createProductionRuntime(options) {
   const registeredProviders = registration.registered;
   let effectiveLlm = registration.effectiveLlm;
   const pluginHost = new PluginHost({
-    globalPluginDirs: [join31(home, ".flavor-code", "plugins")],
-    projectPluginDirs: [join31(workspace, ".flavor", "plugins")],
+    globalPluginDirs: [join32(home, ".flavor-code", "plugins")],
+    projectPluginDirs: [join32(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
@@ -24482,6 +24712,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 () => {
@@ -24515,7 +24746,7 @@ async function createProductionRuntime(options) {
       const address = palSocketAddress({
         platform: process.platform,
         userScope: home,
-        runtimeDir: join31(tmpdir3(), `flavor-code-pals-${createHash20("sha256").update(home).digest("hex").slice(0, 16)}`)
+        runtimeDir: join32(tmpdir4(), `flavor-code-pals-${createHash21("sha256").update(home).digest("hex").slice(0, 16)}`)
       });
       const baseCollaborationClient = collaboration.client ?? collaboration.createClient?.({
         instanceId: collaboration.instanceId,
@@ -24626,8 +24857,8 @@ async function createProductionRuntime(options) {
       diagnostics.push(`MCP servers could not start: ${message(error)}`);
     });
     const skills = new SkillRegistry({
-      globalRoots: [join31(home, ".flavor-code", "skills")],
-      projectRoots: [join31(workspace, ".flavor", "skills"), ...pluginSkillRoots],
+      globalRoots: [join32(home, ".flavor-code", "skills")],
+      projectRoots: [join32(workspace, ".flavor", "skills"), ...pluginSkillRoots],
       authorizeResource: async () => true,
       disabledNames: config.skills.disabled
     });
@@ -24635,7 +24866,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(join31(workspace, "FLAVOR.md"));
+    const flavor = await optionalText2(join32(workspace, "FLAVOR.md"));
     const instructionBaseline = await workspaceInstructions.baseline();
     let memoryContext;
     if (memoryStore !== void 0) {
@@ -24659,7 +24890,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)}-${randomUUID25().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) {
@@ -24743,7 +24975,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,
@@ -25162,7 +25400,7 @@ async function createProductionRuntime(options) {
         evolveService.toolDefinition(),
         ...mcpTools
       ];
-      const loopFlavor = await optionalText2(join31(input.workspace, "FLAVOR.md"));
+      const loopFlavor = await optionalText2(join32(input.workspace, "FLAVOR.md"));
       const loopInstructionBaseline = await loopInstructions.baseline();
       const loopEnvironment = createPromptEnvironment({
         now: /* @__PURE__ */ new Date(),
@@ -25301,7 +25539,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)}-${randomUUID25().slice(0, 8)}`
     });
     const goalStore = new GoalStore({ workspace });
     const goalOrchestrator = new GoalOrchestrator({
@@ -25320,7 +25558,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)}-${randomUUID25().slice(0, 8)}`,
       runWorker: ({ workspace: goalWorkspace, prompt, signal }) => runLoopWorker({ workspace: goalWorkspace, prompt, signal })
     });
     let sessionHistory = await SessionHistory.open({
@@ -25433,7 +25671,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();
@@ -25591,7 +25829,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)}-${randomUUID25().slice(0, 8)}`;
+        hookSessionId = sessionId;
         harnessJournal = new HarnessJournal({ workspace, sessionId });
         setUsageSession(sessionId);
         ideSessionId = sessionId;
@@ -25691,7 +25930,7 @@ ${renderMemoryDocument(entries)}`;
           return `Provider "${providerName}" is missing authorizationUrl, tokenUrl, or clientId.`;
         }
         try {
-          const tokenStore = createFileTokenStore(join31(home, ".flavor-code", "auth.json"));
+          const tokenStore = createFileTokenStore(join32(home, ".flavor-code", "auth.json"));
           const credentialId = oauthCredentialId(oauthConfig.tokenUrl, oauthConfig.clientId);
           await migrateLegacyOAuthToken(tokenStore, providerName, credentialId);
           const oauth = new OAuthCallbackAuthProvider({
@@ -25734,7 +25973,7 @@ ${renderMemoryDocument(entries)}`;
         }
       },
       async logout() {
-        const tokenStore = createFileTokenStore(join31(home, ".flavor-code", "auth.json"));
+        const tokenStore = createFileTokenStore(join32(home, ".flavor-code", "auth.json"));
         const tokens2 = await tokenStore.load();
         const hadCredentials = Object.keys(tokens2).length > 0 || effectiveLlm !== void 0;
         if (!hadCredentials) {
@@ -25791,6 +26030,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 = {
@@ -25826,6 +26081,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();
@@ -25839,6 +26095,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));
@@ -25890,9 +26147,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") {
@@ -25906,8 +26164,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 } };
     }
   }
@@ -25964,7 +26233,7 @@ function terminalProgressState(status) {
   return "failed";
 }
 async function workspaceFingerprint(workspace) {
-  const hash = createHash20("sha256");
+  const hash = createHash21("sha256");
   const diff = await execFileNoThrow(
     "git",
     ["-C", workspace, "diff", "--no-ext-diff", "--binary", "HEAD"],
@@ -26199,7 +26468,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(join31(home, ".flavor-code", "auth.json"));
+  const oauthTokenStore = createFileTokenStore(join32(home, ".flavor-code", "auth.json"));
   const registered = [];
   let effectiveLlm;
   for (const [name, provider] of Object.entries(configured)) {
@@ -26618,21 +26887,21 @@ 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 createHash20("sha256").update(visible, "utf8").digest("hex");
+  return createHash21("sha256").update(visible, "utf8").digest("hex");
 }
 function createMemoryTaskId() {
-  return `memory-${randomUUID23()}`;
+  return `memory-${randomUUID25()}`;
 }
 
 // src/desktop/runtime-controller.ts
-import { createHash as createHash26 } from "crypto";
+import { createHash as createHash27 } from "crypto";
 import { mkdir as mkdir27, readFile as readFile35, readdir as readdir12, rm as rm15, stat as stat14, writeFile as writeFile17 } from "fs/promises";
 import { homedir as homedir4 } from "os";
-import { basename as basename9, join as join41, resolve as resolve35 } from "path";
+import { basename as basename9, join as join42, resolve as resolve35 } from "path";
 
 // src/d2c/workflow.ts
-import { createHash as createHash21 } from "crypto";
-import { join as join32 } from "path";
+import { createHash as createHash22 } from "crypto";
+import { join as join33 } from "path";
 import { z as z42 } from "zod";
 
 // src/d2c/workflow-shared.ts
@@ -26746,7 +27015,7 @@ function pageId(report) {
   return report.page?.id ?? "index";
 }
 function issueSignature(issue, kind) {
-  return createHash21("sha256").update(JSON.stringify({ kind, ...issue })).digest("hex");
+  return createHash22("sha256").update(JSON.stringify({ kind, ...issue })).digest("hex");
 }
 function reviewsFor(report, previous) {
   const prior = new Map(previous?.reviews.map((item) => [`${item.pageId}:${item.fingerprint}`, item]) ?? []);
@@ -26778,7 +27047,7 @@ function reviewsFor(report, previous) {
 function implementationDirectory(report) {
   const source = report.implementation.source;
   if (!/^https?:\/\//i.test(source)) return source;
-  return join32("src", "d2c-output", report.task);
+  return join33("src", "d2c-output", report.task);
 }
 function createWorkflow(report, framework) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -26902,7 +27171,7 @@ function applyQualityIssueDecision(workflow, issueId2, decision) {
   };
 }
 function workflowPath(workspace, task) {
-  return join32(taskDir(workspace, task), "workflow.json");
+  return join33(taskDir(workspace, task), "workflow.json");
 }
 async function readWorkflow(workspace, task) {
   return (await readRecoverableFile(workflowPath(workspace, task), decodeWorkflow))?.value;
@@ -27156,7 +27425,7 @@ function confirmApiMapping(mapping, operationKey, operations) {
 
 // src/d2c/modules.ts
 import { readFile as readFile28 } from "fs/promises";
-import { isAbsolute as isAbsolute15, join as join33, normalize as normalize2, posix, sep as sep24, win32 as win322 } from "path";
+import { isAbsolute as isAbsolute15, join as join34, normalize as normalize2, posix, sep as sep24, win32 as win322 } from "path";
 import { z as z43 } from "zod";
 var ModuleSchema = z43.object({
   id: z43.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/),
@@ -27175,13 +27444,13 @@ function safeSource(path) {
 }
 function d2cOutputDirectory(workspace, task) {
   if (!D2C_TASK_PATTERN.test(task)) throw new Error(`Invalid D2C task: ${task}`);
-  return join33(workspace, "src", "d2c-output", task);
+  return join34(workspace, "src", "d2c-output", task);
 }
 async function readD2cModules(workspace, task) {
   const project = d2cOutputDirectory(workspace, task);
   let raw;
   try {
-    raw = await readFile28(join33(project, "d2c.modules.json"), "utf8");
+    raw = await readFile28(join34(project, "d2c.modules.json"), "utf8");
   } catch {
     return [{ id: "page", label: task, sourceFiles: ["src/App.vue", "src/App.jsx"], keywords: [task] }];
   }
@@ -27202,7 +27471,7 @@ async function readD2cModules(workspace, task) {
 
 // src/d2c/integration.ts
 import { mkdir as mkdir24, readFile as readFile29, writeFile as writeFile13 } from "fs/promises";
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 function record2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
@@ -27338,7 +27607,7 @@ async def reset_acceptance(request: Request):
 }
 async function generateIntegrationArtifacts(projectDir, document, mappings, options = {}) {
   if (mappings.some((mapping) => mapping.status === "needs-confirmation")) throw new Error("Confirm every uncertain OpenAPI mapping before generating integration code");
-  const packagePath = join34(projectDir, "package.json");
+  const packagePath = join35(projectDir, "package.json");
   let pkg;
   try {
     pkg = JSON.parse(await readFile29(packagePath, "utf8"));
@@ -27348,9 +27617,9 @@ async function generateIntegrationArtifacts(projectDir, document, mappings, opti
   const scripts = options.pythonServer ? { ...record2(pkg.scripts) ?? {} } : { ...record2(pkg.scripts) ?? {}, mock: "node mock/server.mjs" };
   const dependencies2 = options.pythonServer ? { ...record2(pkg.dependencies) ?? {}, axios: "^1.7.9" } : { ...record2(pkg.dependencies) ?? {}, axios: "^1.7.9", express: "^5.2.1" };
   const selected = [...new Set(mappings.map((mapping) => mapping.operationKey))].map((key) => document.operations.find((operation) => operation.id === key)).filter((operation) => operation !== void 0);
-  const apiDir = join34(projectDir, "src", "api");
-  const mockDir = join34(projectDir, "mock");
-  const serverDir = join34(projectDir, "server");
+  const apiDir = join35(projectDir, "src", "api");
+  const mockDir = join35(projectDir, "mock");
+  const serverDir = join35(projectDir, "server");
   await Promise.all([
     mkdir24(apiDir, { recursive: true }),
     ...options.pythonServer ? [] : [mkdir24(mockDir, { recursive: true })],
@@ -27360,23 +27629,23 @@ async function generateIntegrationArtifacts(projectDir, document, mappings, opti
   if (options.pythonServer) files.push("server/main.py", "server/requirements.txt", "server/README.md", "server/flavor-runtime.json");
   else files.push("mock/server.mjs");
   await Promise.all([
-    writeFile13(join34(apiDir, "http.js"), `import axios from "axios";
+    writeFile13(join35(apiDir, "http.js"), `import axios from "axios";
 
 export const http = axios.create({ baseURL: import.meta.env.VITE_API_BASE_URL || ${JSON.stringify(document.baseUrl ?? "")}, timeout: 15000 });
 
 http.interceptors.response.use((response) => response, (error) => Promise.reject({ name: "ApiError", status: error.response?.status, message: error.response?.data?.message || error.message, cause: error }));
 `),
-    writeFile13(join34(apiDir, "d2c-api.js"), apiModule(selected)),
-    writeFile13(join34(apiDir, "d2c-bindings.json"), `${JSON.stringify({ schema: 1, generatedAt: (/* @__PURE__ */ new Date()).toISOString(), mappings }, null, 2)}
+    writeFile13(join35(apiDir, "d2c-api.js"), apiModule(selected)),
+    writeFile13(join35(apiDir, "d2c-bindings.json"), `${JSON.stringify({ schema: 1, generatedAt: (/* @__PURE__ */ new Date()).toISOString(), mappings }, null, 2)}
 `),
-    ...options.pythonServer ? [] : [writeFile13(join34(mockDir, "server.mjs"), mockModule({ ...document, operations: selected }))],
+    ...options.pythonServer ? [] : [writeFile13(join35(mockDir, "server.mjs"), mockModule({ ...document, operations: selected }))],
     writeFile13(packagePath, `${JSON.stringify({ ...pkg, scripts, dependencies: dependencies2 }, null, 2)}
 `),
     ...options.pythonServer ? [
-      writeFile13(join34(serverDir, "main.py"), pythonServerModule({ ...document, operations: selected })),
-      writeFile13(join34(serverDir, "requirements.txt"), "fastapi>=0.116,<1\nuvicorn[standard]>=0.35,<1\nsqlalchemy>=2.0,<3\n"),
-      writeFile13(join34(serverDir, "README.md"), "# Python API service\n\nThis is the real integration service, not a mock. Development defaults to SQLite through `DATABASE_URL=sqlite:///./data/app.db`. Set the same environment variable to a SQLAlchemy MySQL or PostgreSQL URL for deployment; keep schema changes in migrations instead of database-specific SQL. Flavor Code starts the service automatically for acceptance.\n"),
-      writeFile13(join34(serverDir, "flavor-runtime.json"), `${JSON.stringify({
+      writeFile13(join35(serverDir, "main.py"), pythonServerModule({ ...document, operations: selected })),
+      writeFile13(join35(serverDir, "requirements.txt"), "fastapi>=0.116,<1\nuvicorn[standard]>=0.35,<1\nsqlalchemy>=2.0,<3\n"),
+      writeFile13(join35(serverDir, "README.md"), "# Python API service\n\nThis is the real integration service, not a mock. Development defaults to SQLite through `DATABASE_URL=sqlite:///./data/app.db`. Set the same environment variable to a SQLAlchemy MySQL or PostgreSQL URL for deployment; keep schema changes in migrations instead of database-specific SQL. Flavor Code starts the service automatically for acceptance.\n"),
+      writeFile13(join35(serverDir, "flavor-runtime.json"), `${JSON.stringify({
         schema: 1,
         kind: "python-fastapi",
         cwd: "server",
@@ -27396,8 +27665,8 @@ http.interceptors.response.use((response) => response, (error) => Promise.reject
 // src/d2c/mock-runner.ts
 import { spawn as spawn8 } from "child_process";
 import { access as access3, readFile as readFile30 } from "fs/promises";
-import { createServer as createServer4 } from "net";
-import { join as join35 } from "path";
+import { createServer as createServer5 } from "net";
+import { join as join36 } from "path";
 async function exists3(path) {
   try {
     await access3(path);
@@ -27408,7 +27677,7 @@ async function exists3(path) {
 }
 async function port() {
   return new Promise((resolvePromise, rejectPromise) => {
-    const server = createServer4();
+    const server = createServer5();
     server.once("error", rejectPromise);
     server.listen(0, "127.0.0.1", () => {
       const address = server.address();
@@ -27505,7 +27774,7 @@ ${output.trim()}` : ""}`);
   }
 }
 async function runPythonBackend(projectDir, options) {
-  const serverDir = join35(projectDir, "server");
+  const serverDir = join36(projectDir, "server");
   if (options.installDependencies !== false) await installPython(serverDir, options.signal);
   const selectedPort = await port();
   const url = `http://127.0.0.1:${selectedPort}`;
@@ -27551,7 +27820,7 @@ ${managed.output().slice(-4e3)}`);
   };
 }
 async function runD2cMockServer(projectDir, options = {}) {
-  const runtimePath = join35(projectDir, "server", "flavor-runtime.json");
+  const runtimePath = join36(projectDir, "server", "flavor-runtime.json");
   if (await exists3(runtimePath)) {
     let runtime;
     try {
@@ -27562,9 +27831,9 @@ async function runD2cMockServer(projectDir, options = {}) {
     if (runtime.schema !== 1 || runtime.kind !== "python-fastapi") throw new Error("Unsupported E2E backend runtime manifest");
     return runPythonBackend(projectDir, options);
   }
-  const serverPath = join35(projectDir, "mock", "server.mjs");
+  const serverPath = join36(projectDir, "mock", "server.mjs");
   if (!await exists3(serverPath)) throw new Error(`D2C mock server is not generated at ${serverPath}`);
-  if (options.installDependencies === false && !await exists3(join35(projectDir, "node_modules", "express", "package.json"))) {
+  if (options.installDependencies === false && !await exists3(join36(projectDir, "node_modules", "express", "package.json"))) {
     throw new Error("D2C mock server dependencies are not installed");
   }
   if (options.installDependencies !== false) await install(projectDir, options.signal);
@@ -27605,16 +27874,16 @@ ${managed.output().slice(-4e3)}`);
 }
 
 // src/d2c/product.ts
-import { createHash as createHash23, randomUUID as randomUUID25 } 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 { createHash as createHash24, randomUUID as randomUUID27 } from "crypto";
+import { copyFile as copyFile2, mkdir as mkdir25, readFile as readFile32, rename as rename13, stat as stat12, unlink as unlink7, writeFile as writeFile15 } from "fs/promises";
+import { join as join37 } 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 createHash23, randomUUID as randomUUID26 } 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");
+  return createHash23("sha256").update(markdown, "utf8").digest("hex");
 }
 function parsePrdSections(markdown) {
   const headings = [...markdown.matchAll(/^(#{2,6})[ \t]+(.+?)[ \t]*$/gm)];
@@ -27711,7 +27980,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}.${randomUUID26()}.tmp`;
   try {
     await writeFile14(temporary, markdown, { encoding: "utf8", flag: "wx", mode: 384 });
     await rename12(temporary, path);
@@ -27725,7 +27994,7 @@ ${body}
 var RelativePrdPath = "product/prd.md";
 var RelativePrototypePath = "product/prototype/index.html";
 var RelativeInteractionPath = "product/prototype/interaction-manifest.json";
-var defaultPlanFileOperations = { rename: rename13, copyFile: copyFile2, unlink: unlink6 };
+var defaultPlanFileOperations = { rename: rename13, copyFile: copyFile2, unlink: unlink7 };
 var planWriteQueues = /* @__PURE__ */ new Map();
 var PlanSchema2 = z44.object({
   schema: z44.literal(1),
@@ -27762,13 +28031,13 @@ var PlanSchema2 = z44.object({
 }).strict();
 function d2cProductDirectory(workspace, task) {
   if (!D2C_TASK_PATTERN.test(task)) throw new Error("Invalid D2C task name");
-  return join36(taskDir(workspace, task), "product");
+  return join37(taskDir(workspace, task), "product");
 }
 function d2cProductPrototypeDirectory(workspace, task) {
-  return join36(d2cProductDirectory(workspace, task), "prototype");
+  return join37(d2cProductDirectory(workspace, task), "prototype");
 }
 function planPath(workspace, task) {
-  return join36(taskDir(workspace, task), "product-plan.json");
+  return join37(taskDir(workspace, task), "product-plan.json");
 }
 function resolveD2cProductTechnology(requirement, fallbackFramework = "vue") {
   const frontendCandidates = [
@@ -27864,7 +28133,7 @@ async function fileHash(path) {
     if (error.code === "ENOENT") return void 0;
     throw error;
   });
-  return buffer === void 0 ? void 0 : createHash23("sha256").update(buffer).digest("hex");
+  return buffer === void 0 ? void 0 : createHash24("sha256").update(buffer).digest("hex");
 }
 async function validateAndNormalizePrototypeManifest(path) {
   const raw = await readFile32(path, "utf8").catch((error) => {
@@ -27911,7 +28180,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}.${randomUUID27()}.tmp`;
     await writeFile15(temporary, `${JSON.stringify(parsed, null, 2)}
 `, { encoding: "utf8", mode: 384 });
     await replaceD2cProductPlanFile(temporary, target, operations);
@@ -27951,16 +28220,16 @@ async function readD2cProductPlan(workspace, task) {
 }
 async function discoverD2cProductArtifacts(workspace, plan) {
   const product = d2cProductDirectory(workspace, plan.task);
-  const prdUpdatedAt = await fileTimestamp(join36(product, "prd.md"));
-  const prdHash = await fileHash(join36(product, "prd.md"));
-  const prototypeUpdatedAt = await fileTimestamp(join36(product, "prototype", "index.html"));
-  const prototypeHash = await fileHash(join36(product, "prototype", "index.html"));
-  const expectedManifest = join36(product, "prototype", "interaction-manifest.json");
+  const prdUpdatedAt = await fileTimestamp(join37(product, "prd.md"));
+  const prdHash = await fileHash(join37(product, "prd.md"));
+  const prototypeUpdatedAt = await fileTimestamp(join37(product, "prototype", "index.html"));
+  const prototypeHash = await fileHash(join37(product, "prototype", "index.html"));
+  const expectedManifest = join37(product, "prototype", "interaction-manifest.json");
   let manifestUpdatedAt = await fileTimestamp(expectedManifest);
   if (manifestUpdatedAt === void 0) {
-    const misplacedManifest = join36(product, "interaction-manifest.json");
+    const misplacedManifest = join37(product, "interaction-manifest.json");
     if (await fileTimestamp(misplacedManifest) !== void 0) {
-      await mkdir25(join36(product, "prototype"), { recursive: true });
+      await mkdir25(join37(product, "prototype"), { recursive: true });
       await copyFile2(misplacedManifest, expectedManifest);
       manifestUpdatedAt = await fileTimestamp(expectedManifest);
     }
@@ -27993,8 +28262,8 @@ async function readD2cProductPlanView(workspace, task) {
   if (stored === void 0) return void 0;
   const plan = await discoverD2cProductArtifacts(workspace, stored);
   if (plan.revision !== stored.revision) await writeD2cProductPlan(workspace, plan);
-  const prdMarkdown = plan.prd === void 0 ? void 0 : await readFile32(join36(taskDir(workspace, task), plan.prd.path), "utf8");
-  const manifestPath = join36(d2cProductDirectory(workspace, task), "prototype", "interaction-manifest.json");
+  const prdMarkdown = plan.prd === void 0 ? void 0 : await readFile32(join37(taskDir(workspace, task), plan.prd.path), "utf8");
+  const manifestPath = join37(d2cProductDirectory(workspace, task), "prototype", "interaction-manifest.json");
   const validationError = plan.phase === "design-generating" && await fileTimestamp(manifestPath) !== void 0 ? await validateAndNormalizePrototypeManifest(manifestPath) : void 0;
   return {
     plan,
@@ -28083,11 +28352,11 @@ ${prdMarkdown.slice(0, 2e4)}`
 }
 
 // src/e2e/acceptance-baseline.ts
-import { createHash as createHash24 } from "crypto";
+import { createHash as createHash25 } from "crypto";
 import { readFile as readFile33 } from "fs/promises";
 async function fileArtifact(path) {
   const content = await readFile33(path);
-  return { path, hash: createHash24("sha256").update(content).digest("hex"), bytes: content.byteLength };
+  return { path, hash: createHash25("sha256").update(content).digest("hex"), bytes: content.byteLength };
 }
 async function verifyAcceptanceArtifact(path, expected, label) {
   const current = await fileArtifact(path);
@@ -28152,8 +28421,8 @@ function createAcceptanceEvidence(coverage, run, now = /* @__PURE__ */ new Date(
 }
 
 // src/e2e/delivery-run.ts
-import { createHash as createHash25 } from "crypto";
-import { join as join37 } from "path";
+import { createHash as createHash26 } from "crypto";
+import { join as join38 } from "path";
 import { z as z45 } from "zod";
 var DELIVERY_NODE_IDS = ["requirement", "prd", "design", "d2c", "api", "acceptance", "delivery"];
 var ArtifactSchema = z45.object({
@@ -28191,7 +28460,7 @@ var dependencies = {
 };
 function artifactRef(path, content, now = /* @__PURE__ */ new Date()) {
   const bytes = typeof content === "string" ? Buffer.from(content, "utf8") : Buffer.from(content);
-  return { path, hash: createHash25("sha256").update(bytes).digest("hex"), bytes: bytes.byteLength, createdAt: now.toISOString() };
+  return { path, hash: createHash26("sha256").update(bytes).digest("hex"), bytes: bytes.byteLength, createdAt: now.toISOString() };
 }
 function emptyNode(id) {
   return { id, status: "pending", attempt: 0, inputs: [], outputs: [] };
@@ -28270,7 +28539,7 @@ function completeDeliveryNode(run, node, outputs, now = /* @__PURE__ */ new Date
   return { ...run, nodes, updatedAt: timestamp2 };
 }
 function deliveryRunPath(workspace, task) {
-  return join37(taskDir(workspace, task), "delivery-run.json");
+  return join38(taskDir(workspace, task), "delivery-run.json");
 }
 function decodeDeliveryRun(raw) {
   return DeliveryRunSchema.parse(JSON.parse(raw));
@@ -28313,7 +28582,7 @@ async function updateDeliveryRun(workspace, task, expectedRevision, mutation) {
 // src/skills/manager.ts
 import { lstat as lstat13, mkdir as mkdir26, readFile as readFile34, readdir as readdir11, realpath as realpath13, rm as rm14, writeFile as writeFile16 } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { isAbsolute as isAbsolute16, join as join38, relative as relative24, resolve as resolve33, sep as sep25 } from "path";
+import { isAbsolute as isAbsolute16, join as join39, relative as relative24, resolve as resolve33, sep as sep25 } from "path";
 import { stringify } from "yaml";
 var SkillManager = class {
   #workspace;
@@ -28336,7 +28605,7 @@ var SkillManager = class {
   async create(draft) {
     const value = parseDraft(draft);
     const projectRoot = this.#projectRoot();
-    const directory = join38(projectRoot, value.name);
+    const directory = join39(projectRoot, value.name);
     await mkdir26(projectRoot, { recursive: true, mode: 448 });
     try {
       await mkdir26(directory, { mode: 448 });
@@ -28345,7 +28614,7 @@ var SkillManager = class {
       throw error;
     }
     try {
-      await writeFile16(join38(directory, "SKILL.md"), renderSkill(value), { encoding: "utf8", flag: "wx", mode: 384 });
+      await writeFile16(join39(directory, "SKILL.md"), renderSkill(value), { encoding: "utf8", flag: "wx", mode: 384 });
       await this.#persistEnabled(value.name, true);
       return this.get(value.name);
     } catch (error) {
@@ -28363,7 +28632,7 @@ var SkillManager = class {
       throw error;
     });
     if (!info.isDirectory() || info.isSymbolicLink()) throw new Error(`Project skill path is not a real directory: ${validName}`);
-    const skillFile = join38(directory, "SKILL.md");
+    const skillFile = join39(directory, "SKILL.md");
     const fileInfo = await lstat13(skillFile);
     if (!fileInfo.isFile() || fileInfo.isSymbolicLink()) throw new Error(`Project skill file is not a real file: ${validName}`);
     await writeFile16(skillFile, renderSkill(value), { encoding: "utf8", mode: 384 });
@@ -28395,12 +28664,12 @@ var SkillManager = class {
   async #registry() {
     const loaded = await loadConfig({ cwd: this.#workspace, home: this.#home });
     const [globalPluginRoots, projectPluginRoots] = await Promise.all([
-      discoverPluginSkillRoots(join38(this.#home, ".flavor-code", "plugins")),
-      discoverPluginSkillRoots(join38(this.#workspace, ".flavor", "plugins"))
+      discoverPluginSkillRoots(join39(this.#home, ".flavor-code", "plugins")),
+      discoverPluginSkillRoots(join39(this.#workspace, ".flavor", "plugins"))
     ]);
     return {
       registry: new SkillRegistry({
-        globalRoots: [join38(this.#home, ".flavor-code", "skills"), ...globalPluginRoots],
+        globalRoots: [join39(this.#home, ".flavor-code", "skills"), ...globalPluginRoots],
         projectRoots: [this.#projectRoot(), ...projectPluginRoots]
       }),
       disabled: new Set(loaded.config.skills.disabled)
@@ -28416,10 +28685,10 @@ var SkillManager = class {
     };
   }
   #projectRoot() {
-    return join38(this.#workspace, ".flavor", "skills");
+    return join39(this.#workspace, ".flavor", "skills");
   }
   #projectSkillDirectory(name) {
-    return join38(this.#projectRoot(), name);
+    return join39(this.#projectRoot(), name);
   }
 };
 function parseName(value) {
@@ -28460,9 +28729,9 @@ async function discoverPluginSkillRoots(directory) {
   const roots = [];
   for (const entry2 of entries) {
     if (!entry2.isDirectory() || entry2.isSymbolicLink()) continue;
-    const pluginRoot = await realpath13(join38(directory, entry2.name));
+    const pluginRoot = await realpath13(join39(directory, entry2.name));
     try {
-      const manifest = PluginManifestSchema.parse(JSON.parse(await readFile34(join38(pluginRoot, "flavor-plugin.json"), "utf8")));
+      const manifest = PluginManifestSchema.parse(JSON.parse(await readFile34(join39(pluginRoot, "flavor-plugin.json"), "utf8")));
       for (const contribution of manifest.contributes.skillRoots) {
         const candidate = resolve33(pluginRoot, contribution.path);
         const info = await lstat13(candidate);
@@ -28537,11 +28806,11 @@ async function createProjectMemoryManager(options) {
 }
 
 // src/mcp/config-manager.ts
-import { join as join39 } from "path";
+import { join as join40 } from "path";
 var ProjectMcpConfigManager = class {
   path;
   constructor(workspace) {
-    this.path = join39(workspace, ".flavor", "flavor.json");
+    this.path = join40(workspace, ".flavor", "flavor.json");
   }
   async list() {
     const document = await readRecoverableFile(this.path, (raw) => parseDocument2(this.path, raw));
@@ -28638,7 +28907,7 @@ function isRecord7(value) {
 }
 
 // src/desktop/model-config.ts
-import { join as join40 } from "path";
+import { join as join41 } from "path";
 var DEFAULT_DESKTOP_MODELS = [
   {
     id: "anthropic:deepseek-v4-pro",
@@ -28659,7 +28928,7 @@ var DEFAULT_DESKTOP_MODELS = [
 ];
 async function loadDesktopModels(workspace, home) {
   try {
-    const tokens2 = await createFileTokenStore(join40(home, ".flavor-code", "auth.json")).load();
+    const tokens2 = await createFileTokenStore(join41(home, ".flavor-code", "auth.json")).load();
     const pkceModels = [];
     const knownPkce = /* @__PURE__ */ new Set();
     for (const token of Object.values(tokens2)) {
@@ -28728,7 +28997,7 @@ function protocolLabel(type) {
 // src/desktop/d2c-product-preview.ts
 import { createReadStream as createReadStream2 } from "fs";
 import { realpath as realpath14, stat as stat13 } from "fs/promises";
-import { createServer as createServer5 } from "http";
+import { createServer as createServer6 } from "http";
 import { extname as extname3, isAbsolute as isAbsolute17, relative as relative25, resolve as resolve34, sep as sep26 } from "path";
 var MIME_TYPES = {
   ".css": "text/css; charset=utf-8",
@@ -28754,7 +29023,7 @@ async function startD2cProductPreview(rootDirectory) {
   const root = await realpath14(resolve34(rootDirectory));
   const rootInfo = await stat13(root);
   if (!rootInfo.isDirectory()) throw new Error("D2C product prototype directory is unavailable");
-  const server = createServer5(async (request, response2) => {
+  const server = createServer6(async (request, response2) => {
     response2.setHeader("cache-control", "no-store");
     response2.setHeader("x-content-type-options", "nosniff");
     response2.setHeader("content-security-policy", "default-src 'self' data: blob:; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob:; font-src 'self' data:; connect-src 'none'; object-src 'none'; base-uri 'none'; form-action 'none'");
@@ -28804,37 +29073,37 @@ function pngDataUrl(png) {
 }
 async function detectD2cFramework(workspace, task) {
   try {
-    const pkg = JSON.parse(await readFile35(join41(d2cOutputDirectory(workspace, task), "package.json"), "utf8"));
+    const pkg = JSON.parse(await readFile35(join42(d2cOutputDirectory(workspace, task), "package.json"), "utf8"));
     return pkg.dependencies?.react === void 0 ? "vue" : "react";
   } catch {
     return "vue";
   }
 }
 function integrationDirectory(workspace, task) {
-  return join41(workspace, ".flavor", "d2c", task, "integration");
+  return join42(workspace, ".flavor", "d2c", task, "integration");
 }
 var D2C_BACKEND_SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".cfg", ".env", ".ini", ".js", ".json", ".lock", ".mjs", ".py", ".toml", ".txt", ".yaml", ".yml"]);
 var D2C_BACKEND_IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([".git", ".venv", "__pycache__", "data", "node_modules", "venv"]);
 async function d2cBackendSourceFingerprint(project) {
-  const runtimeManifest = join41(project, "server", "flavor-runtime.json");
+  const runtimeManifest = join42(project, "server", "flavor-runtime.json");
   const realBackend = (await stat14(runtimeManifest).catch(() => void 0))?.isFile() === true;
-  const root = realBackend ? join41(project, "server") : join41(project, "mock");
+  const root = realBackend ? join42(project, "server") : join42(project, "mock");
   if ((await stat14(root).catch(() => void 0))?.isDirectory() !== true) return void 0;
   const files = [];
   const visit = async (directory) => {
     const entries = await readdir12(directory, { withFileTypes: true });
     for (const entry2 of entries) {
       if (entry2.isDirectory()) {
-        if (!D2C_BACKEND_IGNORED_DIRECTORIES.has(entry2.name)) await visit(join41(directory, entry2.name));
+        if (!D2C_BACKEND_IGNORED_DIRECTORIES.has(entry2.name)) await visit(join42(directory, entry2.name));
         continue;
       }
       if (!entry2.isFile()) continue;
       const extension2 = entry2.name.includes(".") ? `.${entry2.name.split(".").pop().toLowerCase()}` : "";
-      if (D2C_BACKEND_SOURCE_EXTENSIONS.has(extension2)) files.push(join41(directory, entry2.name));
+      if (D2C_BACKEND_SOURCE_EXTENSIONS.has(extension2)) files.push(join42(directory, entry2.name));
     }
   };
   await visit(root);
-  const hash = createHash26("sha256");
+  const hash = createHash27("sha256");
   for (const path of files.sort()) {
     hash.update(path.slice(root.length));
     hash.update("\0");
@@ -29380,7 +29649,7 @@ var DesktopRuntimeController = class {
     if (workflow === void 0 || !reviewProgress(workflow).complete || workflow.stage === "visual-review") {
       throw new Error("Complete visual review before importing OpenAPI");
     }
-    const moduleManifest = join41(d2cOutputDirectory(workspace, task), "d2c.modules.json");
+    const moduleManifest = join42(d2cOutputDirectory(workspace, task), "d2c.modules.json");
     const moduleManifestInfo = await stat14(moduleManifest).catch(() => void 0);
     if (moduleManifestInfo === void 0 || !moduleManifestInfo.isFile()) {
       throw new Error("D2C implementation must write d2c.modules.json before API mapping; ask the agent to split the project into modules first");
@@ -29391,10 +29660,10 @@ var DesktopRuntimeController = class {
     const mappings = generated ? matched.map((mapping) => ({ ...mapping, status: "confirmed" })) : matched;
     const dir = integrationDirectory(workspace, task);
     await mkdir27(dir, { recursive: true });
-    const hash = createHash26("sha256").update(raw).digest("hex");
+    const hash = createHash27("sha256").update(raw).digest("hex");
     await Promise.all([
-      writeFile17(join41(dir, "swagger.json"), raw),
-      writeFile17(join41(dir, "openapi.normalized.json"), `${JSON.stringify(document, null, 2)}
+      writeFile17(join42(dir, "swagger.json"), raw),
+      writeFile17(join42(dir, "openapi.normalized.json"), `${JSON.stringify(document, null, 2)}
 `)
     ]);
     const next = {
@@ -29429,7 +29698,7 @@ var DesktopRuntimeController = class {
     let workflow = await readWorkflow(workspace, task);
     if (workflow?.openapi === void 0 && workflow !== void 0 && reviewProgress(workflow).complete && await readD2cProductPlanView(workspace, task) !== void 0) {
       const modules = await readD2cModules(workspace, task);
-      const productOpenApiPath = join41(taskDir(workspace, task), "product", "openapi.json");
+      const productOpenApiPath = join42(taskDir(workspace, task), "product", "openapi.json");
       const authored = await readFile35(productOpenApiPath, "utf8").catch(() => void 0);
       const generated = authored === void 0;
       const prepared = await this.#storeD2cOpenApi(
@@ -29442,7 +29711,7 @@ var DesktopRuntimeController = class {
       return prepared;
     }
     if (workflow?.openapi === void 0 || workflow.mappings === void 0) return void 0;
-    const document = JSON.parse(await readFile35(join41(integrationDirectory(workspace, task), "openapi.normalized.json"), "utf8"));
+    const document = JSON.parse(await readFile35(join42(integrationDirectory(workspace, task), "openapi.normalized.json"), "utf8"));
     return { workflow, document, mappings: workflow.mappings };
   }
   async confirmD2cMapping(task, moduleId, operationKey) {
@@ -29509,7 +29778,7 @@ var DesktopRuntimeController = class {
     ].join("\n");
     const delivery = await readDeliveryRun(workspace, task);
     if (delivery?.nodes.api.status === "running") {
-      const apiArtifacts = await Promise.all(generated.files.map(async (file) => artifactRef(file, await readFile35(join41(project, file)))));
+      const apiArtifacts = await Promise.all(generated.files.map(async (file) => artifactRef(file, await readFile35(join42(project, file)))));
       const completed = await updateDeliveryRun(
         workspace,
         task,
@@ -29536,7 +29805,7 @@ var DesktopRuntimeController = class {
     try {
       const fingerprint2 = await d2cBackendSourceFingerprint(project);
       if (fingerprint2 !== void 0) this.#d2cMockSourceFingerprints.set(task, fingerprint2);
-      const environmentPath = join41(project, ".env.local");
+      const environmentPath = join42(project, ".env.local");
       const existingEnvironment = await readFile35(environmentPath, "utf8").catch(() => "");
       const environment = `${existingEnvironment.split(/\r?\n/).filter((line) => !/^\s*VITE_API_BASE_URL\s*=/.test(line)).join("\n").trim()}
 VITE_API_BASE_URL=${running.url}
@@ -29617,7 +29886,7 @@ VITE_API_BASE_URL=${running.url}
     const readyPreview = this.#d2cPreviews.get(task);
     const readyMock = this.#d2cMocks.get(task);
     if (readyPreview === void 0 || readyMock === void 0) throw new Error("D2C preview or backend service is unavailable after synchronization");
-    const manifestPath = join41(taskDir(workspace, task), "design", "interaction-manifest.json");
+    const manifestPath = join42(taskDir(workspace, task), "design", "interaction-manifest.json");
     const manifest = parseInteractionManifest(await readFile35(manifestPath, "utf8"));
     const baseline = await this.#verifyAcceptanceBaseline(workspace, task);
     const coverage = baseline === void 0 ? void 0 : verifyRequirementCoverage(baseline.approvedPrd.criteria, manifest);
@@ -29629,7 +29898,7 @@ VITE_API_BASE_URL=${running.url}
       await mkdir27(planDir, { recursive: true });
       try {
         const observations = await this.#observeD2cPages(manifest, readyPreview.url);
-        const prd = await readFile35(join41(taskDir(workspace, task), "product", "prd.md"), "utf8").catch(() => void 0);
+        const prd = await readFile35(join42(taskDir(workspace, task), "product", "prd.md"), "utf8").catch(() => void 0);
         const apiContext = JSON.stringify({ openapi: workflow.openapi, mappings: workflow.mappings }, null, 2);
         const plan = await this.#d2cJudge.planInteractions({ task, seed: manifest, observations, ...prd === void 0 ? {} : { prd }, apiContext });
         executableManifest = mergeInteractionManifests(manifest, plan.manifest);
@@ -29640,9 +29909,9 @@ VITE_API_BASE_URL=${running.url}
           plannedScenarios: executableManifest.pages.reduce((total, page) => total + page.scenarios.length, 0),
           pageAnalyses: plan.pageAnalyses
         };
-        await writeFile17(join41(planDir, "autonomous-interaction-plan.json"), `${JSON.stringify({ ...plan, manifest: executableManifest }, null, 2)}
+        await writeFile17(join42(planDir, "autonomous-interaction-plan.json"), `${JSON.stringify({ ...plan, manifest: executableManifest }, null, 2)}
 `, { encoding: "utf8", mode: 384 });
-        await rm15(join41(planDir, "autonomous-interaction-diagnostic.json"), { force: true });
+        await rm15(join42(planDir, "autonomous-interaction-diagnostic.json"), { force: true });
       } catch (cause) {
         const detail = message(cause);
         review = {
@@ -29650,8 +29919,8 @@ VITE_API_BASE_URL=${running.url}
           plannedScenarios: manifest.pages.reduce((total, page) => total + page.scenarios.length, 0),
           warning: `\u591A\u6A21\u6001\u81EA\u4E3B\u89C4\u5212\u5931\u8D25\uFF0C\u5DF2\u7EE7\u7EED\u6267\u884C\u5DF2\u786E\u8BA4\u7684\u8BBE\u8BA1\u5951\u7EA6\uFF1A${detail}`
         };
-        await rm15(join41(planDir, "autonomous-interaction-plan.json"), { force: true });
-        await writeFile17(join41(planDir, "autonomous-interaction-diagnostic.json"), `${JSON.stringify({
+        await rm15(join42(planDir, "autonomous-interaction-plan.json"), { force: true });
+        await writeFile17(join42(planDir, "autonomous-interaction-diagnostic.json"), `${JSON.stringify({
           schema: 1,
           stage: "planning",
           occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -29665,13 +29934,13 @@ VITE_API_BASE_URL=${running.url}
     let result = { ...rawResult, evidenceMode: review.mode };
     if (coverage !== void 0) {
       const evidence = createAcceptanceEvidence(coverage, result);
-      await writeFile17(join41(taskDir(workspace, task), "acceptance-evidence.json"), `${JSON.stringify({ ...evidence, baseline }, null, 2)}
+      await writeFile17(join42(taskDir(workspace, task), "acceptance-evidence.json"), `${JSON.stringify({ ...evidence, baseline }, null, 2)}
 `, { encoding: "utf8", mode: 384 });
       if (!evidence.passed) result = { ...result, passed: false, failures: Math.max(1, result.failures) };
     }
     const dir = integrationDirectory(workspace, task);
     await mkdir27(dir, { recursive: true });
-    await writeFile17(join41(dir, "interaction-results.json"), `${JSON.stringify(result, null, 2)}
+    await writeFile17(join42(dir, "interaction-results.json"), `${JSON.stringify(result, null, 2)}
 `);
     const next = await updateWorkflow(workspace, task, workflow.revision, (current) => applyInteractionRun(current, result));
     return { workflow: next, result, review };
@@ -29684,7 +29953,7 @@ VITE_API_BASE_URL=${running.url}
     if (mock === void 0 || !mock.exited() || result.failures === 0) return result;
     const output = mock.output().trim();
     try {
-      const dir = join41(d2cOutputDirectory(workspace, task), "mock-server.log");
+      const dir = join42(d2cOutputDirectory(workspace, task), "mock-server.log");
       await writeFile17(dir, `${output}
 `);
     } catch {
@@ -29779,7 +30048,7 @@ VITE_API_BASE_URL=${running.url}
     if (current === void 0) throw new Error("D2C product plan is unavailable");
     if (current.plan.approvedPrd !== void 0) throw new Error("The approved PRD is immutable and cannot be edited");
     if (current.plan.phase !== "prd-review") throw new Error("PRD sections can only be edited during PRD review");
-    const path = join41(taskDir(workspace, task), "product", "prd.md");
+    const path = join42(taskDir(workspace, task), "product", "prd.md");
     const updated = await updatePrdSectionFile(path, { sectionId, body, expectedHash });
     const now = (/* @__PURE__ */ new Date()).toISOString();
     await writeD2cProductPlan(workspace, {
@@ -29799,15 +30068,15 @@ VITE_API_BASE_URL=${running.url}
   async #assertProductPrdLocked(workspace, task) {
     const current = await readD2cProductPlanView(workspace, task);
     if (current?.plan.approvedPrd === void 0) return;
-    await assertApprovedPrd(join41(taskDir(workspace, task), "product", "prd.md"), current.plan.approvedPrd);
+    await assertApprovedPrd(join42(taskDir(workspace, task), "product", "prd.md"), current.plan.approvedPrd);
   }
   async #acceptancePaths(workspace, task) {
-    const product = join41(taskDir(workspace, task), "product");
-    const openapi = join41(product, "openapi.json");
+    const product = join42(taskDir(workspace, task), "product");
+    const openapi = join42(product, "openapi.json");
     return {
-      prd: join41(product, "prd.md"),
-      prototype: join41(product, "prototype", "index.html"),
-      interaction: join41(product, "prototype", "interaction-manifest.json"),
+      prd: join42(product, "prd.md"),
+      prototype: join42(product, "prototype", "index.html"),
+      interaction: join42(product, "prototype", "interaction-manifest.json"),
       ...await stat14(openapi).catch(() => void 0) === void 0 ? {} : { openapi }
     };
   }
@@ -29815,17 +30084,17 @@ VITE_API_BASE_URL=${running.url}
     const product = await readD2cProductPlanView(workspace, task);
     if (product?.plan.approvedPrd === void 0) return void 0;
     await this.#assertProductPrdLocked(workspace, task);
-    const baseline = JSON.parse(await readFile35(join41(taskDir(workspace, task), "acceptance-baseline.json"), "utf8"));
+    const baseline = JSON.parse(await readFile35(join42(taskDir(workspace, task), "acceptance-baseline.json"), "utf8"));
     await verifyAcceptanceBaseline(await this.#acceptancePaths(workspace, task), baseline);
-    const design = join41(taskDir(workspace, task), "design");
+    const design = join42(taskDir(workspace, task), "design");
     await Promise.all([
-      verifyAcceptanceArtifact(join41(design, "index.html"), baseline.artifacts.prototype, "runtime prototype"),
-      verifyAcceptanceArtifact(join41(design, "interaction-manifest.json"), baseline.artifacts.interaction, "runtime interaction contract")
+      verifyAcceptanceArtifact(join42(design, "index.html"), baseline.artifacts.prototype, "runtime prototype"),
+      verifyAcceptanceArtifact(join42(design, "interaction-manifest.json"), baseline.artifacts.interaction, "runtime interaction contract")
     ]);
     const workflow = await readWorkflow(workspace, task);
     if (workflow?.openapi !== void 0) {
       await verifyAcceptanceArtifact(
-        join41(taskDir(workspace, task), "integration", "swagger.json"),
+        join42(taskDir(workspace, task), "integration", "swagger.json"),
         { hash: workflow.openapi.hash },
         "runtime OpenAPI contract"
       );
@@ -29846,14 +30115,14 @@ VITE_API_BASE_URL=${running.url}
       throw new Error("D2C PRD is empty and cannot be accepted");
     }
     if (stage === "design" && accepted) {
-      const manifest = join41(d2cProductPrototypeDirectory(workspace, task), "interaction-manifest.json");
+      const manifest = join42(d2cProductPrototypeDirectory(workspace, task), "interaction-manifest.json");
       const normalizedManifest = parseInteractionManifest(await readFile35(manifest, "utf8"));
       if (current.plan.approvedPrd === void 0) throw new Error("Approve the PRD before confirming the design");
       verifyRequirementCoverage(current.plan.approvedPrd.criteria, normalizedManifest);
       await writeFile17(manifest, `${JSON.stringify(normalizedManifest, null, 2)}
 `, { encoding: "utf8", mode: 384 });
       const baseline = await captureAcceptanceBaseline(await this.#acceptancePaths(workspace, task), current.plan.approvedPrd);
-      await writeFile17(join41(taskDir(workspace, task), "acceptance-baseline.json"), `${JSON.stringify(baseline, null, 2)}
+      await writeFile17(join42(taskDir(workspace, task), "acceptance-baseline.json"), `${JSON.stringify(baseline, null, 2)}
 `, { encoding: "utf8", mode: 384 });
     }
     const plan = await writeD2cProductPlan(
@@ -29887,8 +30156,8 @@ VITE_API_BASE_URL=${running.url}
     const imported = await this.importD2cDesign(task, d2cProductPrototypeDirectory(workspace, task));
     const delivery = await readDeliveryRun(workspace, task);
     if (delivery !== void 0) {
-      const prototype = await readFile35(join41(d2cProductPrototypeDirectory(workspace, task), "index.html"), "utf8");
-      const interaction = await readFile35(join41(d2cProductPrototypeDirectory(workspace, task), "interaction-manifest.json"), "utf8");
+      const prototype = await readFile35(join42(d2cProductPrototypeDirectory(workspace, task), "index.html"), "utf8");
+      const interaction = await readFile35(join42(d2cProductPrototypeDirectory(workspace, task), "interaction-manifest.json"), "utf8");
       const completed = await updateDeliveryRun(workspace, task, delivery.revision, (run) => completeDeliveryNode(run, "design", [
         artifactRef("product/prototype/index.html", prototype),
         artifactRef("product/prototype/interaction-manifest.json", interaction)
@@ -29972,10 +30241,10 @@ VITE_API_BASE_URL=${running.url}
     const next = await updateWorkflow(workspace, task, workflow.revision, (current) => applyQualityJudgment(current, judgment));
     const qualityContent = `${JSON.stringify(judgment, null, 2)}
 `;
-    await writeFile17(join41(taskDir(workspace, task), "quality-judge.json"), qualityContent, { encoding: "utf8", mode: 384 });
+    await writeFile17(join42(taskDir(workspace, task), "quality-judge.json"), qualityContent, { encoding: "utf8", mode: 384 });
     const delivery = await readDeliveryRun(workspace, task);
     if (next.stage === "completed" && delivery?.nodes.acceptance.status === "running") {
-      const interactionContent = await readFile35(join41(integrationDirectory(workspace, task), "interaction-results.json"), "utf8");
+      const interactionContent = await readFile35(join42(integrationDirectory(workspace, task), "interaction-results.json"), "utf8");
       const accepted = await updateDeliveryRun(workspace, task, delivery.revision, (run) => completeDeliveryNode(run, "acceptance", [
         artifactRef("integration/interaction-results.json", interactionContent),
         artifactRef("quality-judge.json", qualityContent)
@@ -30157,14 +30426,14 @@ function desktopWindowChrome(platform = process.platform) {
 
 // src/utils/crash-guard.ts
 import { mkdirSync as mkdirSync3, writeFileSync } from "fs";
-import { join as join42 } from "path";
+import { join as join43 } from "path";
 var installed = false;
 function installCrashGuard(options = {}) {
   if (installed) return;
   installed = true;
   const crashLogDir = () => {
     try {
-      return join42((options.workspace ?? process.cwd)(), ".flavor");
+      return join43((options.workspace ?? process.cwd)(), ".flavor");
     } catch {
       return process.cwd();
     }
@@ -30173,7 +30442,7 @@ function installCrashGuard(options = {}) {
     try {
       const dir = crashLogDir();
       mkdirSync3(dir, { recursive: true });
-      const path = join42(dir, `crash-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "")}-${process.pid}.log`);
+      const path = join43(dir, `crash-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "")}-${process.pid}.log`);
       writeFileSync(path, [
         `kind: ${kind}`,
         `version: ${process.version}`,
@@ -30364,9 +30633,9 @@ function safeGitTarget(value) {
 }
 
 // src/desktop/worktree-manager.ts
-import { randomUUID as randomUUID26 } from "crypto";
+import { randomUUID as randomUUID28 } 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";
+import { basename as basename10, isAbsolute as isAbsolute19, join as join44, relative as relative27, resolve as resolve37, sep as sep27 } from "path";
 var DesktopWorktreeManager = class {
   #repository;
   #storage;
@@ -30377,7 +30646,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 = randomUUID28().slice(0, 8);
     const id = `worktree-${safe}-${suffix}`;
     const branch = `flavor/desktop-${safe}-${suffix}`;
     const path = this.#safeStoragePath(id);
@@ -30412,7 +30681,7 @@ var DesktopWorktreeManager = class {
     }
     const values = await Promise.all(names.filter((name) => name.endsWith(".json")).map(async (name) => {
       try {
-        const stored = validateStored(JSON.parse(await readFile37(join43(this.#storage, name), "utf8")), this.#repository, this.#storage);
+        const stored = validateStored(JSON.parse(await readFile37(join44(this.#storage, name), "utf8")), this.#repository, this.#storage);
         if ((await stat15(stored.path).catch(() => void 0))?.isDirectory() !== true) return void 0;
         const status = await git2(stored.path, ["status", "--porcelain"]);
         const merged = await git2(this.#repository, ["merge-base", "--is-ancestor", stored.branch, "HEAD"]);
@@ -30476,7 +30745,7 @@ function validateStored(value, repository, storage) {
 // src/desktop/workbench-service.ts
 import { readFile as readFile38, readdir as readdir14, stat as stat16 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { join as join44, resolve as resolve38 } from "path";
+import { join as join45, resolve as resolve38 } from "path";
 var MAX_TEXT = 128e3;
 var MAX_ITEMS = 200;
 var DesktopWorkbenchService = class {
@@ -30509,11 +30778,11 @@ var DesktopWorkbenchService = class {
     return url.toString().replace(/\/$/, input.trim().endsWith("/") ? "/" : "");
   }
   async #goals() {
-    const root = join44(this.#workspace, ".flavor", "goals");
+    const root = join45(this.#workspace, ".flavor", "goals");
     const names = await readdir14(root).catch((error) => error.code === "ENOENT" ? [] : Promise.reject(error));
     const values = await Promise.all(names.filter((name) => /^goal-[A-Za-z0-9._-]+\.json$/.test(name)).slice(0, MAX_ITEMS).map(async (name) => {
       try {
-        return GoalStateSchema.parse(JSON.parse(await boundedRead2(join44(root, name))));
+        return GoalStateSchema.parse(JSON.parse(await boundedRead2(join45(root, name))));
       } catch {
         return void 0;
       }
@@ -30523,7 +30792,7 @@ var DesktopWorkbenchService = class {
   async #instructions() {
     const names = ["FLAVOR.md", "AGENTS.md", "CLAUDE.md", "AGENTS.local.md", "CLAUDE.local.md"];
     const items = await Promise.all(names.map(async (name) => {
-      const path = join44(this.#workspace, name);
+      const path = join45(this.#workspace, name);
       try {
         return { name, path, content: redactErrorText(await boundedRead2(path)) };
       } catch (error) {
@@ -30536,9 +30805,9 @@ var DesktopWorkbenchService = class {
   async #permissionFiles() {
     const candidates = [
       ...process.env.FLAVOR_MANAGED_PERMISSIONS ? [{ tier: "managed", path: resolve38(process.env.FLAVOR_MANAGED_PERMISSIONS), content: "" }] : [],
-      { tier: "user", path: join44(this.#home, ".flavor-code", "permissions.json"), content: "" },
-      { tier: "project", path: join44(this.#workspace, ".flavor", "permissions.json"), content: "" },
-      { tier: "local", path: join44(this.#workspace, ".flavor", "permissions.local.json"), content: "" }
+      { tier: "user", path: join45(this.#home, ".flavor-code", "permissions.json"), content: "" },
+      { tier: "project", path: join45(this.#workspace, ".flavor", "permissions.json"), content: "" },
+      { tier: "local", path: join45(this.#workspace, ".flavor", "permissions.local.json"), content: "" }
     ];
     const values = await Promise.all(candidates.map(async (item) => {
       try {
@@ -30553,7 +30822,7 @@ var DesktopWorkbenchService = class {
   async #audit() {
     let raw;
     try {
-      raw = await boundedRead2(join44(this.#workspace, ".flavor", "audit.jsonl"));
+      raw = await boundedRead2(join45(this.#workspace, ".flavor", "audit.jsonl"));
     } catch (error) {
       if (error.code === "ENOENT") return [];
       throw error;
@@ -30568,7 +30837,7 @@ var DesktopWorkbenchService = class {
     }).reverse();
   }
   async #context(sessionId) {
-    const usage = await readJsonLines2(join44(this.#workspace, ".flavor", "usage.jsonl"));
+    const usage = await readJsonLines2(join45(this.#workspace, ".flavor", "usage.jsonl"));
     if (sessionId === void 0) return { visibility: [], usage };
     try {
       const document = await new SessionStore({ workspace: this.#workspace }).load(sessionId);
@@ -30609,12 +30878,12 @@ function redact2(value, key = "") {
 // src/desktop/astgraph-service.ts
 import { stat as stat17 } from "fs/promises";
 import { createRequire as nodeCreateRequire2 } from "module";
-import { join as join45, resolve as resolve39 } from "path";
+import { join as join46, resolve as resolve39 } from "path";
 var FIELDS = "id, kind, name, qualified_name, file_path, language, start_line, end_line, signature";
 var DesktopAstGraphService = class {
   #path;
   constructor(workspace) {
-    this.#path = join45(resolve39(workspace), ".flavor", "astgraph", "index.db");
+    this.#path = join46(resolve39(workspace), ".flavor", "astgraph", "index.db");
   }
   async status() {
     if ((await stat17(this.#path).catch(() => void 0))?.isFile() !== true) {
@@ -30691,7 +30960,7 @@ var appMenu;
 var quitting = false;
 function logStartup(step, detail) {
   try {
-    const logPath = join46(dirname24(process.execPath), "flavor-code-startup.log");
+    const logPath = join47(dirname24(process.execPath), "flavor-code-startup.log");
     const ts = (/* @__PURE__ */ new Date()).toISOString();
     appendFileSync(logPath, `[${ts}] ${step}${detail ? ` | ${detail}` : ""}
 `);
@@ -30716,7 +30985,7 @@ var d2cEmbedded = createEmbeddedD2cAutomation(() => {
   };
 });
 var d2cJudgeClient = createD2cJudgeClient();
-var judgeStore = () => createD2cJudgeConfigStore(join46(app.getPath("userData"), "d2c-judge.json"));
+var judgeStore = () => createD2cJudgeConfigStore(join47(app.getPath("userData"), "d2c-judge.json"));
 function judgeImage(png) {
   const image = nativeImage.createFromBuffer(png);
   const size = image.getSize();
@@ -30741,8 +31010,8 @@ function sessionMetaKey(workspace, sessionId) {
   return `${workspace}\0${sessionId}`;
 }
 function worktreeManager(workspace) {
-  const key = createHash27("sha256").update(resolve40(workspace)).digest("hex").slice(0, 20);
-  return new DesktopWorktreeManager({ repository: workspace, storage: join46(app.getPath("userData"), "task-worktrees", key) });
+  const key = createHash28("sha256").update(resolve40(workspace)).digest("hex").slice(0, 20);
+  return new DesktopWorktreeManager({ repository: workspace, storage: join47(app.getPath("userData"), "task-worktrees", key) });
 }
 function activeWorkingDirectory() {
   if (activeWorkspace === void 0) throw new Error("\u8BF7\u5148\u6253\u5F00\u9879\u76EE");
@@ -30841,7 +31110,7 @@ function emitManagedDesktopEvent(workspace, owner2, event) {
   }
 }
 function createDesktopController(workspace, owner2) {
-  const collaborationId = randomUUID27();
+  const collaborationId = randomUUID29();
   return new DesktopRuntimeController({
     emit: (event) => emitManagedDesktopEvent(workspace, owner2, event),
     runD2cInteractionTests: (manifest, baseUrl, mockUrl) => d2cEmbedded.run(manifest, baseUrl, mockUrl),
@@ -30873,12 +31142,21 @@ function createDesktopController(workspace, owner2) {
     },
     createRuntime: async (runtimeOptions) => createProductionRuntime({
       ...runtimeOptions,
+      islandControl: {
+        focus: () => {
+          const target = mainWindow;
+          if (target === void 0 || target.isDestroyed()) return;
+          if (target.isMinimized()) target.restore();
+          target.show();
+          target.focus();
+        }
+      },
       collaboration: {
         instanceId: collaborationId,
         alias: `desktop-${basename11(workspace ?? runtimeOptions.workspace ?? "flavor")}`.slice(0, 64),
         optional: true,
         startBroker: (address) => {
-          const entry2 = app.isPackaged ? join46(process.resourcesPath, "app.asar.unpacked", "dist", "desktop", "pals-broker-entry.js") : join46(moduleDirectory, "pals-broker-entry.js");
+          const entry2 = app.isPackaged ? join47(process.resourcesPath, "app.asar.unpacked", "dist", "desktop", "pals-broker-entry.js") : join47(moduleDirectory, "pals-broker-entry.js");
           return spawnPalBrokerProcess({
             address,
             executable: process.execPath,
@@ -30900,7 +31178,7 @@ function createDesktopController(workspace, owner2) {
 var detachedController = createDesktopController();
 var controller = detachedController;
 function statePath() {
-  return join46(app.getPath("userData"), "desktop-state.json");
+  return join47(app.getPath("userData"), "desktop-state.json");
 }
 async function loadPersistedProjects() {
   try {
@@ -31073,7 +31351,7 @@ async function chooseAndOpenWorkspace() {
 var cachedAppIconDataUrl;
 function appIconDataUrl() {
   if (cachedAppIconDataUrl !== void 0) return cachedAppIconDataUrl;
-  const icon = nativeImage.createFromPath(join46(app.getAppPath(), "assets", "icon.png"));
+  const icon = nativeImage.createFromPath(join47(app.getAppPath(), "assets", "icon.png"));
   if (icon.isEmpty()) return void 0;
   cachedAppIconDataUrl = icon.toDataURL();
   return cachedAppIconDataUrl;
@@ -31491,7 +31769,7 @@ function applicationMenu() {
   ]);
 }
 async function createWindow() {
-  const rendererPath = join46(app.getAppPath(), "dist", "desktop-renderer", "index.html");
+  const rendererPath = join47(app.getAppPath(), "dist", "desktop-renderer", "index.html");
   mainWindow = new BrowserWindow2({
     title: "Flavor Code",
     width: 1280,
@@ -31502,14 +31780,14 @@ async function createWindow() {
     show: false,
     ...desktopWindowChrome(),
     webPreferences: {
-      preload: join46(moduleDirectory, "preload.cjs"),
+      preload: join47(moduleDirectory, "preload.cjs"),
       contextIsolation: true,
       nodeIntegration: false,
       sandbox: false,
       webSecurity: true
     }
   });
-  const iconPath = join46(app.getAppPath(), "assets", "icon.png");
+  const iconPath = join47(app.getAppPath(), "assets", "icon.png");
   const icon = nativeImage.createFromPath(iconPath);
   if (!icon.isEmpty()) {
     mainWindow.setIcon(icon);