flavor-code 1.2.18 → 1.2.20

package/dist/desktop/main.js

@@ -1,7 +1,7 @@
 // src/desktop/main.ts
 import { appendFileSync } from "fs";
 import { readFile as readFile34, stat as stat15, writeFile as writeFile18 } from "fs/promises";
-import { dirname as dirname23, join as join41 } from "path";
+import { dirname as dirname24, join as join41 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { app, BrowserWindow as BrowserWindow2, dialog, ipcMain, Menu, nativeImage, shell } from "electron";
 
@@ -2612,11 +2612,11 @@ function hexToLab(hex) {
   const b = linearize(channels[2]);
   const x = (0.4124564 * r + 0.3575761 * g + 0.1804375 * b) / 0.95047;
   const y = 0.2126729 * r + 0.7151522 * g + 0.072175 * b;
-  const z43 = (0.0193339 * r + 0.119192 * g + 0.9503041 * b) / 1.08883;
+  const z44 = (0.0193339 * r + 0.119192 * g + 0.9503041 * b) / 1.08883;
   const f = (t) => t > 8856e-6 ? Math.cbrt(t) : 7.787 * t + 16 / 116;
   const fx = f(x);
   const fy = f(y);
-  const fz = f(z43);
+  const fz = f(z44);
   return [116 * fy - 16, 500 * (fx - fy), 200 * (fy - fz)];
 }
 function deltaE76(left, right) {
@@ -8103,7 +8103,7 @@ function createIncidentReporter(options) {
 import { spawn as spawn2 } from "child_process";
 import { writeFile as writeFile7 } from "fs/promises";
 import { join as join10 } from "path";
-import { z as z17 } from "zod";
+import { z as z18 } 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";
@@ -8112,9 +8112,10 @@ import { join as join8, resolve as resolve9 } from "path";
 
 // src/plugins/host.ts
 import { lstatSync, realpathSync as realpathSync2 } from "fs";
-import { lstat as lstat3, open as open4, readdir as readdir2, realpath as realpath5, stat as stat4, writeFile as writeFile4 } from "fs/promises";
+import { lstat as lstat3, open as open4, readdir as readdir2, realpath as realpath6, stat as stat4, writeFile as writeFile4 } from "fs/promises";
 import { isAbsolute as isAbsolute6, relative as relative6, resolve as resolve8, sep as sep6 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
+import { z as z17 } from "zod";
 
 // src/plugins/types.ts
 import { z as z16 } from "zod";
@@ -8144,10 +8145,188 @@ var PluginManifestSchema = z16.object({
   }).strict()
 }).strict();
 
+// src/plugins/worker-host.ts
+import { realpath as realpath5 } from "fs/promises";
+import { dirname as dirname7 } from "path";
+import { Worker as Worker2 } from "worker_threads";
+var DEFAULT_ACTIVATION_TIMEOUT_MS = 1e4;
+var DEFAULT_INVOCATION_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_OLD_SPACE_MB = 128;
+var DEFAULT_SHUTDOWN_TIMEOUT_MS = 5e3;
+async function startPluginSandbox(options) {
+  const entryPath = await realpath5(options.entryPath);
+  const pluginRoot = await realpath5(options.pluginRoot ?? dirname7(entryPath));
+  const activationTimeoutMs = options.activationTimeoutMs ?? DEFAULT_ACTIVATION_TIMEOUT_MS;
+  const invocationTimeoutMs = options.invocationTimeoutMs ?? DEFAULT_INVOCATION_TIMEOUT_MS;
+  let configJson;
+  try {
+    configJson = JSON.stringify(options.config ?? {});
+  } catch (error) {
+    throw new Error(`Plugin sandbox config is not serializable: ${String(error)}`);
+  }
+  const workerEntry = new URL(import.meta.url.endsWith(".ts") ? "./plugin-worker-entry.ts" : "./plugin-worker-entry.js", import.meta.url);
+  const worker = new Worker2(workerEntry, {
+    workerData: { entryPath, pluginRoot, pluginName: options.pluginName, pluginVersion: options.pluginVersion, configJson },
+    execArgv: ["--experimental-vm-modules", "--no-warnings"],
+    resourceLimits: {
+      maxOldGenerationSizeMb: options.maxOldSpaceMb ?? DEFAULT_MAX_OLD_SPACE_MB,
+      maxYoungGenerationSizeMb: 16,
+      codeRangeSizeMb: 16,
+      stackSizeMb: 4
+    }
+  });
+  let closed = false;
+  let nextId = 1;
+  const pending2 = /* @__PURE__ */ new Map();
+  let disposeResolve;
+  let disposeReject;
+  let failWorker;
+  const ready = await new Promise((resolveReady, rejectReady) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      settled = true;
+      closed = true;
+      void worker.terminate();
+      rejectReady(new Error(`Plugin activation sandbox timed out after ${activationTimeoutMs}ms`));
+    }, activationTimeoutMs);
+    const fail = (error) => {
+      if (closed && settled) return;
+      closed = true;
+      clearTimeout(timer);
+      for (const request of pending2.values()) {
+        clearTimeout(request.timer);
+        request.reject(error);
+      }
+      pending2.clear();
+      disposeReject?.(error);
+      if (!settled) {
+        settled = true;
+        rejectReady(error);
+      }
+      void worker.terminate();
+    };
+    failWorker = fail;
+    worker.on("message", (raw) => {
+      if (!isWorkerMessage(raw)) {
+        fail(new Error("Plugin sandbox sent an invalid protocol message"));
+        return;
+      }
+      const message2 = raw;
+      if (message2.type === "fatal") {
+        fail(new Error(message2.error));
+        return;
+      }
+      if (message2.type === "ready") {
+        if (settled || !isSandboxResult(message2.result)) {
+          fail(new Error("Plugin sandbox sent an invalid or duplicate ready message"));
+          return;
+        }
+        settled = true;
+        clearTimeout(timer);
+        resolveReady(message2.result);
+        return;
+      }
+      if (!settled) {
+        fail(new Error(`Plugin sandbox sent ${message2.type} before ready`));
+        return;
+      }
+      if (message2.type === "response") {
+        const request = pending2.get(message2.id);
+        if (request === void 0) {
+          fail(new Error("Plugin sandbox sent a response for an unknown request"));
+          return;
+        }
+        pending2.delete(message2.id);
+        clearTimeout(request.timer);
+        if (message2.ok) {
+          try {
+            request.resolve(JSON.parse(message2.valueJson));
+          } catch {
+            fail(new Error("Plugin sandbox returned invalid JSON"));
+          }
+        } else request.reject(new Error(message2.error));
+        return;
+      }
+      if (message2.type === "disposed") {
+        closed = true;
+        disposeResolve?.();
+        void worker.terminate();
+      }
+    });
+    worker.once("error", fail);
+    worker.once("exit", (code) => {
+      if (!closed) fail(new Error(`Plugin worker exited with code ${code}`));
+    });
+  });
+  return {
+    result: ready,
+    invoke(kind, name, args) {
+      if (closed) return Promise.reject(new Error("Plugin sandbox is closed"));
+      let argsJson;
+      try {
+        argsJson = JSON.stringify(args);
+      } catch (error) {
+        return Promise.reject(new Error(`Plugin sandbox arguments are not serializable: ${String(error)}`));
+      }
+      const id = nextId++;
+      return new Promise((resolveInvoke, rejectInvoke) => {
+        const timer = setTimeout(() => {
+          const error = new Error(`Plugin sandbox invocation timed out after ${invocationTimeoutMs}ms`);
+          failWorker(error);
+        }, invocationTimeoutMs);
+        pending2.set(id, { resolve: (value) => resolveInvoke(value), reject: rejectInvoke, timer });
+        worker.postMessage({ type: "invoke", id, kind, name, argsJson });
+      });
+    },
+    dispose() {
+      if (closed) return Promise.resolve();
+      return new Promise((resolveDispose, rejectDispose) => {
+        const timer = setTimeout(() => {
+          const error = new Error(`Plugin sandbox shutdown timed out after ${DEFAULT_SHUTDOWN_TIMEOUT_MS}ms`);
+          failWorker(error);
+        }, DEFAULT_SHUTDOWN_TIMEOUT_MS);
+        disposeResolve = () => {
+          clearTimeout(timer);
+          resolveDispose();
+        };
+        disposeReject = (error) => {
+          clearTimeout(timer);
+          rejectDispose(error);
+        };
+        worker.postMessage({ type: "shutdown" });
+      });
+    }
+  };
+}
+function isWorkerMessage(value) {
+  if (typeof value !== "object" || value === null || !("type" in value)) return false;
+  const type = value.type;
+  if (type === "disposed") return true;
+  if (type === "fatal") return typeof value.error === "string";
+  if (type === "ready") return "result" in value;
+  if (type !== "response") return false;
+  const response2 = value;
+  return Number.isSafeInteger(response2.id) && typeof response2.ok === "boolean" && (response2.ok ? typeof response2.valueJson === "string" : typeof response2.error === "string");
+}
+function isSandboxResult(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const result = value;
+  if (!(result.ok === true && typeof result.name === "string" && typeof result.version === "string" && Array.isArray(result.registeredTools) && result.registeredTools.every((item) => typeof item === "string") && Array.isArray(result.registeredCommands) && result.registeredCommands.every((item) => typeof item === "string") && Array.isArray(result.registeredHooks) && result.registeredHooks.every((item) => typeof item === "string") && Array.isArray(result.registeredSkillRoots) && result.registeredSkillRoots.every((item) => typeof item === "string") && Array.isArray(result.registeredModelAdapters) && result.registeredModelAdapters.every((item) => typeof item === "string") && typeof result.contributions === "object" && result.contributions !== null)) return false;
+  const contributions = result.contributions;
+  const named = (item) => typeof item === "object" && item !== null && typeof item.name === "string";
+  if (!Array.isArray(contributions.commands) || !contributions.commands.every((item) => named(item) && (item.description === void 0 || typeof item.description === "string"))) return false;
+  if (!Array.isArray(contributions.tools) || !contributions.tools.every((item) => named(item) && typeof item.toolName === "string" && typeof item.description === "string" && (item.modelInputSchema === void 0 || typeof item.modelInputSchema === "object" && item.modelInputSchema !== null) && (item.readOnly === void 0 || typeof item.readOnly === "boolean"))) return false;
+  if (!Array.isArray(contributions.hooks) || !contributions.hooks.every(named)) return false;
+  if (!Array.isArray(contributions.skillRoots) || !contributions.skillRoots.every((item) => named(item) && typeof item.root === "string")) return false;
+  if (!Array.isArray(contributions.modelAdapters) || !contributions.modelAdapters.every(named)) return false;
+  const same = (left, right) => left.length === right.length && left.every((name, index) => name === right[index]?.name);
+  return same(result.registeredCommands, contributions.commands) && same(result.registeredTools, contributions.tools) && same(result.registeredHooks, contributions.hooks) && same(result.registeredSkillRoots, contributions.skillRoots) && same(result.registeredModelAdapters, contributions.modelAdapters);
+}
+
 // src/plugins/host.ts
 var MANIFEST = "flavor-plugin.json";
 var MAX_MANIFEST_BYTES = 64 * 1024;
-var DEFAULT_ACTIVATION_TIMEOUT_MS = 1e4;
+var DEFAULT_ACTIVATION_TIMEOUT_MS2 = 1e4;
 var DEFAULT_UNLOAD_TIMEOUT_MS = 5e3;
 var silentLogger = { debug() {
 }, info() {
@@ -8164,7 +8343,7 @@ var PluginHost = class {
   #loaded = false;
   constructor(options) {
     this.#options = options;
-    this.#activationTimeoutMs = positiveTimeout(options.activationTimeoutMs, DEFAULT_ACTIVATION_TIMEOUT_MS, "activationTimeoutMs");
+    this.#activationTimeoutMs = positiveTimeout(options.activationTimeoutMs, DEFAULT_ACTIVATION_TIMEOUT_MS2, "activationTimeoutMs");
     this.#unloadTimeoutMs = positiveTimeout(options.unloadTimeoutMs, DEFAULT_UNLOAD_TIMEOUT_MS, "unloadTimeoutMs");
   }
   get diagnostics() {
@@ -8278,7 +8457,7 @@ var PluginHost = class {
     try {
       const rootInfo = await lstat3(inputRoot);
       if (!rootInfo.isDirectory() || rootInfo.isSymbolicLink()) throw new Error("Plugin root must be a static directory");
-      const root = await realpath5(inputRoot);
+      const root = await realpath6(inputRoot);
       const rawManifest = await readManifest2(resolve8(root, MANIFEST));
       if (typeof rawManifest === "object" && rawManifest !== null && "name" in rawManifest && typeof rawManifest.name === "string") {
         diagnosticLabel = rawManifest.name;
@@ -8298,18 +8477,79 @@ var PluginHost = class {
     const claimed = [];
     const state = { active: true, controller: new AbortController() };
     let activation;
+    const useSandbox = this.#options.sandbox === true;
     try {
       await verifyEntry(candidate.root, candidate.entry, candidate.entrySnapshot);
-      const imported = import(`${pathToFileURL2(candidate.entrySnapshot.physicalPath).href}?flavor=${encodeURIComponent(plugin)}&v=${Date.now()}`);
-      const module = await bounded(imported, this.#activationTimeoutMs, "Plugin import");
-      await verifyEntry(candidate.root, candidate.entry, candidate.entrySnapshot);
-      if (typeof module.activate !== "function") throw new Error("Plugin entry must export activate(context)");
-      const context = this.#context(candidate, disposers, claimed, state);
-      activation = Promise.resolve().then(() => module.activate(context));
-      const deactivate = await bounded(activation, this.#activationTimeoutMs, "Plugin activation");
-      if (deactivate !== void 0) {
-        if (typeof deactivate !== "function") throw new Error("Plugin activate result must be a disposer or undefined");
-        disposers.push(deactivate);
+      if (useSandbox) {
+        const session = await bounded(
+          startPluginSandbox({
+            entryPath: candidate.entrySnapshot.physicalPath,
+            pluginRoot: candidate.root,
+            pluginName: plugin,
+            pluginVersion: candidate.manifest.version,
+            config: redactConfig(this.#options.config ?? {}),
+            activationTimeoutMs: this.#activationTimeoutMs
+          }),
+          this.#activationTimeoutMs + 1e3,
+          "Plugin sandbox activation"
+        );
+        disposers.push(() => session.dispose());
+        const result = session.result;
+        if (!result.ok) throw new Error(result.error ?? `Plugin "${plugin}" sandbox execution failed`);
+        const context = this.#context(candidate, disposers, claimed, state);
+        for (const command of result.contributions.commands) {
+          context.registerCommand(command.name, (args, commandContext) => session.invoke("command", command.name, [
+            args,
+            { workspace: commandContext.workspace }
+          ]), command.description);
+        }
+        for (const contribution of result.contributions.tools) {
+          const tool = {
+            name: contribution.toolName,
+            description: contribution.description,
+            inputSchema: z17.unknown(),
+            ...contribution.modelInputSchema === void 0 ? {} : { modelInputSchema: contribution.modelInputSchema },
+            ...contribution.readOnly === void 0 ? {} : { readOnly: contribution.readOnly },
+            paths: () => [],
+            execute: (input, _signal, toolContext) => session.invoke("tool", contribution.name, [
+              input,
+              toolContext === void 0 ? void 0 : { agent: toolContext.agent, ownerId: toolContext.ownerId }
+            ])
+          };
+          context.registerTool(contribution.name, tool);
+        }
+        for (const hook of result.contributions.hooks) {
+          context.registerHook(
+            hook.name,
+            (event) => session.invoke("hook", hook.name, [event]),
+            hook.options
+          );
+        }
+        for (const skill of result.contributions.skillRoots) {
+          context.registerSkillRoot(skill.name, skill.root);
+        }
+        for (const adapter of result.contributions.modelAdapters) {
+          context.registerModelAdapter(adapter.name, {
+            async *stream(request) {
+              const safeRequest = { ...request, signal: void 0 };
+              const events = await session.invoke("modelAdapter", adapter.name, [safeRequest]);
+              for (const event of events) yield event;
+            }
+          });
+        }
+        await verifyEntry(candidate.root, candidate.entry, candidate.entrySnapshot);
+      } else {
+        const imported = import(`${pathToFileURL2(candidate.entrySnapshot.physicalPath).href}?flavor=${encodeURIComponent(plugin)}&v=${Date.now()}`);
+        const module = await bounded(imported, this.#activationTimeoutMs, "Plugin import");
+        await verifyEntry(candidate.root, candidate.entry, candidate.entrySnapshot);
+        if (typeof module.activate !== "function") throw new Error("Plugin entry must export activate(context)");
+        const context = this.#context(candidate, disposers, claimed, state);
+        activation = Promise.resolve().then(() => module.activate(context));
+        const deactivate = await bounded(activation, this.#activationTimeoutMs, "Plugin activation");
+        if (deactivate !== void 0) {
+          if (typeof deactivate !== "function") throw new Error("Plugin activate result must be a disposer or undefined");
+          disposers.push(deactivate);
+        }
       }
       this.#assertAllDeclaredRegistered(candidate, claimed);
       const metadata = { name: plugin, version: candidate.manifest.version, source: candidate.source, root: candidate.root };
@@ -8473,7 +8713,7 @@ async function readManifest2(path) {
 async function snapshotEntry(root, entry2) {
   const lexicalStats = await lstat3(entry2, { bigint: true });
   if (!lexicalStats.isFile() && !lexicalStats.isSymbolicLink()) throw new Error("Plugin entry must be a file");
-  const physicalPath = await realpath5(entry2);
+  const physicalPath = await realpath6(entry2);
   assertContained2(root, physicalPath, "Plugin entry symlink");
   const physicalStats = await stat4(physicalPath, { bigint: true });
   if (!physicalStats.isFile()) throw new Error("Plugin entry must resolve to a regular file");
@@ -8589,6 +8829,8 @@ var SCAFFOLD_ENTRY = (name) => `// ${name} \u2014 generated by /evolve improve <
 //   - context: { signal, config, logger, services, registerCommand,
 //                registerTool, registerHook, registerSkillRoot, registerModelAdapter }
 //   - every contribution you register MUST be declared in contributes
+//   - sandbox verification only permits relative JS modules inside this plugin root;
+//     Node.js built-ins, package imports, filesystem, and network APIs are unavailable
 //
 // Implement your fix here. Example \u2014 observe tool failures:
 //   ctx.registerHook("PostToolUseFailure", (event) => {
@@ -8628,7 +8870,9 @@ async function verifyFixPlugin(workspace, name) {
     await cp2(pluginRoot, join8(sandbox, name), { recursive: true });
     const host = new PluginHost({
       projectPluginDirs: [sandbox],
+      sandbox: true,
       config: {},
+      activationTimeoutMs: 5e3,
       registrations: {
         command: (commandName) => {
           collected.commands.push(commandName);
@@ -8642,12 +8886,11 @@ async function verifyFixPlugin(workspace, name) {
         skillRoot: () => () => void 0,
         modelAdapter: () => () => void 0
       },
-      logger: {
-        debug: () => void 0,
-        info: () => void 0,
-        warn: () => void 0,
-        error: () => void 0
-      }
+      logger: { debug() {
+      }, info() {
+      }, warn() {
+      }, error() {
+      } }
     });
     await host.loadAll();
     const loaded = host.loadedPlugins;
@@ -8706,7 +8949,7 @@ async function revertFixPlugin(workspace, name) {
 // src/evolve/store.ts
 import { createHash as createHash5 } from "crypto";
 import { appendFile, mkdir as mkdir8, readFile as readFile7, rm as rm5, writeFile as writeFile6 } from "fs/promises";
-import { dirname as dirname7, join as join9 } from "path";
+import { dirname as dirname8, join as join9 } from "path";
 function normalizeError(message2) {
   return String(message2 ?? "").replace(/\s+/g, " ").replace(/"[^"]*"/g, '"\u2026"').replace(/`[^`]*`/g, '"\u2026"').trim().slice(0, 160);
 }
@@ -8735,7 +8978,7 @@ async function readJsonLines(file) {
   }
 }
 async function writeJsonLines(file, records) {
-  await mkdir8(dirname7(file), { recursive: true, mode: 448 });
+  await mkdir8(dirname8(file), { recursive: true, mode: 448 });
   const body = records.map((record3) => JSON.stringify(record3)).join("\n");
   await writeFile6(file, body.length > 0 ? `${body}
 ` : "", { encoding: "utf8", mode: 384 });
@@ -8763,7 +9006,7 @@ async function readRules(file) {
   }
 }
 async function writeRules(file, rules) {
-  await mkdir8(dirname7(file), { recursive: true, mode: 448 });
+  await mkdir8(dirname8(file), { recursive: true, mode: 448 });
   await writeFile6(file, JSON.stringify(rules, null, 2), { encoding: "utf8", mode: 384 });
 }
 var EvolveStore = class {
@@ -9385,10 +9628,10 @@ ${result.stderr.slice(-4e3)}` : ""}`;
       return USAGE;
     },
     toolDefinition() {
-      const inputSchema = z17.object({
-        suggestionId: z17.string().min(1).describe("Signal id from the evolve suggestions"),
-        implementation: z17.string().min(1).describe("Concise description of the fix to implement (plugin plan, or the guardrail rule text when kind is prompt_rule)"),
-        kind: z17.enum(["plugin", "prompt_rule"]).optional().describe(
+      const inputSchema = z18.object({
+        suggestionId: z18.string().min(1).describe("Signal id from the evolve suggestions"),
+        implementation: z18.string().min(1).describe("Concise description of the fix to implement (plugin plan, or the guardrail rule text when kind is prompt_rule)"),
+        kind: z18.enum(["plugin", "prompt_rule"]).optional().describe(
           "plugin (default): scaffold a fix plugin; prompt_rule: store a guardrail rule that is injected into future system prompts"
         )
       });
@@ -9437,9 +9680,9 @@ ${result.stderr.slice(-4e3)}` : ""}`;
 }
 
 // src/init/project.ts
-import { lstat as lstat4, mkdir as mkdir9, readdir as readdir4, readFile as readFile8, realpath as realpath6, writeFile as writeFile8 } from "fs/promises";
+import { lstat as lstat4, mkdir as mkdir9, readdir as readdir4, readFile as readFile8, realpath as realpath7, writeFile as writeFile8 } from "fs/promises";
 import { copyFileSync, mkdirSync, readdirSync, readFileSync } from "fs";
-import { basename as basename4, dirname as dirname8, isAbsolute as isAbsolute7, join as join11, relative as relative7, sep as sep7 } from "path";
+import { basename as basename4, dirname as dirname9, isAbsolute as isAbsolute7, join as join11, relative as relative7, sep as sep7 } from "path";
 import { fileURLToPath } from "url";
 var GENERATED_START = "<!-- flavor-code:start -->";
 var GENERATED_END = "<!-- flavor-code:end -->";
@@ -9494,7 +9737,7 @@ function isContainedPath(root, candidate) {
 async function pathKind(path, root) {
   try {
     const details = await lstat4(path);
-    if (details.isSymbolicLink() || !isContainedPath(root, await realpath6(path))) return void 0;
+    if (details.isSymbolicLink() || !isContainedPath(root, await realpath7(path))) return void 0;
     if (details.isFile()) return "file";
     if (details.isDirectory()) return "directory";
     return void 0;
@@ -9511,7 +9754,7 @@ async function readTextIfSmall(path, root) {
     if (isMissingPathError(error)) return void 0;
     throw error;
   });
-  if (details === void 0 || !details.isFile() || details.isSymbolicLink() || details.size > MAX_MANIFEST_BYTES2 || !isContainedPath(root, await realpath6(path))) {
+  if (details === void 0 || !details.isFile() || details.isSymbolicLink() || details.size > MAX_MANIFEST_BYTES2 || !isContainedPath(root, await realpath7(path))) {
     return void 0;
   }
   return readFile8(path, "utf8");
@@ -9562,7 +9805,7 @@ async function sampleSourceExtensions(cwd, root, directories) {
   const sampleDirectories = ["", ...directories].slice(0, 12);
   for (const relativeDirectory of sampleDirectories) {
     const absoluteDirectory = join11(cwd, relativeDirectory);
-    if (!isContainedPath(root, await realpath6(absoluteDirectory))) continue;
+    if (!isContainedPath(root, await realpath7(absoluteDirectory))) continue;
     let entries;
     try {
       entries = await readdir4(absoluteDirectory, { withFileTypes: true });
@@ -9579,7 +9822,7 @@ async function sampleSourceExtensions(cwd, root, directories) {
   return extensions;
 }
 async function inspectProject(cwd) {
-  const root = await realpath6(cwd);
+  const root = await realpath7(cwd);
   const sourceDirectories = [];
   for (const directory of SOURCE_DIRECTORIES) {
     if (await pathKind(join11(cwd, directory), root) === "directory") sourceDirectories.push(directory);
@@ -9813,7 +10056,7 @@ function isEntryIgnored(lines, entry2) {
 }
 async function addSessionsToGitignore(cwd) {
   const path = join11(cwd, ".gitignore");
-  const root = await realpath6(cwd);
+  const root = await realpath7(cwd);
   await assertSafeManagedPath(path, root);
   let existing;
   try {
@@ -9836,7 +10079,7 @@ async function assertSafeManagedPath(path, root) {
     if (details.isSymbolicLink()) {
       throw new Error(`Refusing to overwrite managed file symbolic link: ${path}`);
     }
-    if (!isContainedPath(root, await realpath6(path))) {
+    if (!isContainedPath(root, await realpath7(path))) {
       throw new Error(`Refusing to overwrite managed file outside the project: ${path}`);
     }
   } catch (error) {
@@ -9845,16 +10088,16 @@ async function assertSafeManagedPath(path, root) {
   }
 }
 async function ensureFlavorDirectories(cwd) {
-  const root = await realpath6(cwd);
+  const root = await realpath7(cwd);
   const sessionsDir = join11(cwd, ".flavor", "sessions");
   const skillsDir = join11(cwd, ".flavor", "skills");
   const pluginsDir = join11(cwd, ".flavor", "plugins");
   await mkdir9(sessionsDir, { recursive: true, mode: 448 });
   await mkdir9(skillsDir, { recursive: true, mode: 448 });
   await mkdir9(pluginsDir, { recursive: true, mode: 448 });
-  const canonicalRoot = await realpath6(root);
+  const canonicalRoot = await realpath7(root);
   for (const dir of [sessionsDir, skillsDir, pluginsDir]) {
-    const canonical3 = await realpath6(dir);
+    const canonical3 = await realpath7(dir);
     if (!isContainedPath(canonicalRoot, canonical3)) {
       throw new Error(`Directory escapes the workspace: ${dir}`);
     }
@@ -9862,7 +10105,7 @@ async function ensureFlavorDirectories(cwd) {
 }
 async function createExampleFlavorConfig(cwd) {
   const configPath = join11(cwd, ".flavor", "flavor.json");
-  const root = await realpath6(cwd);
+  const root = await realpath7(cwd);
   await assertSafeManagedPath(configPath, root);
   try {
     await lstat4(configPath);
@@ -9891,7 +10134,7 @@ async function createExampleFlavorConfig(cwd) {
   };
   await writeFile8(configPath, JSON.stringify(example, null, 2) + "\n");
 }
-var CODEISLAND_SRC_DIR = join11(dirname8(fileURLToPath(import.meta.url)), "codeisland");
+var CODEISLAND_SRC_DIR = join11(dirname9(fileURLToPath(import.meta.url)), "codeisland");
 var CODEISLAND_FILES = ["flavor-plugin.json", "activate.mjs", "bridge.mjs"];
 async function copyCodeIslandPlugin(cwd) {
   const pluginDir = join11(cwd, ".flavor", "plugins", "codeisland");
@@ -9907,7 +10150,7 @@ async function copyCodeIslandPlugin(cwd) {
     await writeFile8(join11(pluginDir, name), content);
   }
 }
-var ASTGRAPH_SRC_DIR = join11(dirname8(fileURLToPath(import.meta.url)), "astgraph");
+var ASTGRAPH_SRC_DIR = join11(dirname9(fileURLToPath(import.meta.url)), "astgraph");
 async function copyAstgraphPlugin(cwd) {
   const pluginDir = join11(cwd, ".flavor", "plugins", "astgraph");
   try {
@@ -9934,7 +10177,7 @@ async function initializeFlavor(cwd) {
   await createExampleFlavorConfig(cwd);
   const facts = await inspectProject(cwd);
   const path = join11(cwd, "FLAVOR.md");
-  const root = await realpath6(cwd);
+  const root = await realpath7(cwd);
   await assertSafeManagedPath(path, root);
   let existing;
   try {
@@ -9968,8 +10211,8 @@ function buildLoopCyclePrompt(input) {
 }
 
 // src/loop/types.ts
-import { z as z18 } from "zod";
-var LoopStatusSchema = z18.enum([
+import { z as z19 } from "zod";
+var LoopStatusSchema = z19.enum([
   "running",
   "succeeded",
   "failed",
@@ -9979,65 +10222,65 @@ var LoopStatusSchema = z18.enum([
   "no_progress",
   "needs_human"
 ]);
-var LoopApprovalSchema = z18.object({
-  dimension: z18.enum(["cycles", "tokens"]),
-  previousCheckpoint: z18.number().int().nonnegative(),
-  newCheckpoint: z18.number().int().positive(),
-  usage: z18.number().int().nonnegative(),
-  approvedAt: z18.string().datetime({ offset: true })
+var LoopApprovalSchema = z19.object({
+  dimension: z19.enum(["cycles", "tokens"]),
+  previousCheckpoint: z19.number().int().nonnegative(),
+  newCheckpoint: z19.number().int().positive(),
+  usage: z19.number().int().nonnegative(),
+  approvedAt: z19.string().datetime({ offset: true })
 }).strict();
-var LoopVerificationCommandSchema = z18.object({
-  command: z18.string().min(1),
-  args: z18.array(z18.string()),
-  exitCode: z18.number().int().nullable(),
-  stdout: z18.string(),
-  stderr: z18.string(),
-  truncated: z18.boolean()
+var LoopVerificationCommandSchema = z19.object({
+  command: z19.string().min(1),
+  args: z19.array(z19.string()),
+  exitCode: z19.number().int().nullable(),
+  stdout: z19.string(),
+  stderr: z19.string(),
+  truncated: z19.boolean()
 }).strict();
-var LoopVerificationEvidenceSchema = z18.object({
-  passed: z18.boolean(),
-  commands: z18.array(LoopVerificationCommandSchema),
-  summary: z18.string()
+var LoopVerificationEvidenceSchema = z19.object({
+  passed: z19.boolean(),
+  commands: z19.array(LoopVerificationCommandSchema),
+  summary: z19.string()
 }).strict();
-var LoopCycleEvidenceSchema = z18.object({
-  cycle: z18.number().int().positive(),
-  startedAt: z18.string().datetime({ offset: true }),
-  completedAt: z18.string().datetime({ offset: true }),
-  inputTokens: z18.number().int().nonnegative(),
-  outputTokens: z18.number().int().nonnegative(),
-  workspaceFingerprint: z18.string(),
+var LoopCycleEvidenceSchema = z19.object({
+  cycle: z19.number().int().positive(),
+  startedAt: z19.string().datetime({ offset: true }),
+  completedAt: z19.string().datetime({ offset: true }),
+  inputTokens: z19.number().int().nonnegative(),
+  outputTokens: z19.number().int().nonnegative(),
+  workspaceFingerprint: z19.string(),
   verification: LoopVerificationEvidenceSchema
 }).strict();
-var LoopStateSchema = z18.object({
-  version: z18.literal(1),
-  loopId: z18.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/),
-  goal: z18.string().trim().min(1),
-  workspace: z18.string().min(1),
-  createdAt: z18.string().datetime({ offset: true }),
-  updatedAt: z18.string().datetime({ offset: true }),
+var LoopStateSchema = z19.object({
+  version: z19.literal(1),
+  loopId: z19.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/),
+  goal: z19.string().trim().min(1),
+  workspace: z19.string().min(1),
+  createdAt: z19.string().datetime({ offset: true }),
+  updatedAt: z19.string().datetime({ offset: true }),
   status: LoopStatusSchema,
-  config: z18.object({
-    cycleStep: z18.number().int().positive(),
-    tokenStep: z18.number().int().positive(),
-    isolation: z18.literal("auto")
+  config: z19.object({
+    cycleStep: z19.number().int().positive(),
+    tokenStep: z19.number().int().positive(),
+    isolation: z19.literal("auto")
   }).strict(),
-  budget: z18.object({
-    cyclesUsed: z18.number().int().nonnegative(),
-    inputTokens: z18.number().int().nonnegative(),
-    outputTokens: z18.number().int().nonnegative(),
-    cycleCheckpoint: z18.number().int().positive(),
-    tokenCheckpoint: z18.number().int().positive(),
-    approvals: z18.array(LoopApprovalSchema)
+  budget: z19.object({
+    cyclesUsed: z19.number().int().nonnegative(),
+    inputTokens: z19.number().int().nonnegative(),
+    outputTokens: z19.number().int().nonnegative(),
+    cycleCheckpoint: z19.number().int().positive(),
+    tokenCheckpoint: z19.number().int().positive(),
+    approvals: z19.array(LoopApprovalSchema)
   }).strict(),
-  cycles: z18.array(LoopCycleEvidenceSchema),
-  terminalReason: z18.string().optional()
+  cycles: z19.array(LoopCycleEvidenceSchema),
+  terminalReason: z19.string().optional()
 }).strict();
-var LoopEventSchema = z18.object({
-  version: z18.literal(1),
-  type: z18.enum(["created", "cycle_started", "cycle_completed", "verification", "budget_approved", "terminal"]),
-  timestamp: z18.string().datetime({ offset: true }),
-  loopId: z18.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/),
-  payload: z18.record(z18.string(), z18.unknown())
+var LoopEventSchema = z19.object({
+  version: z19.literal(1),
+  type: z19.enum(["created", "cycle_started", "cycle_completed", "verification", "budget_approved", "terminal"]),
+  timestamp: z19.string().datetime({ offset: true }),
+  loopId: z19.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/),
+  payload: z19.record(z19.string(), z19.unknown())
 }).strict();
 
 // src/loop/budget.ts
@@ -10353,15 +10596,15 @@ import { writeFile as writeFile9, mkdir as mkdir10 } from "fs/promises";
 import { join as join13 } from "path";
 
 // src/goal/types.ts
-import { z as z19 } from "zod";
-var GoalPhaseSchema = z19.enum([
+import { z as z20 } from "zod";
+var GoalPhaseSchema = z20.enum([
   "idle",
   "planning",
   "executing",
   "verifying",
   "complete"
 ]);
-var GoalStatusSchema = z19.enum([
+var GoalStatusSchema = z20.enum([
   "active",
   "paused",
   "achieved",
@@ -10369,43 +10612,43 @@ var GoalStatusSchema = z19.enum([
   "blocked",
   "failed"
 ]);
-var AcceptanceCriterionSchema = z19.object({
-  id: z19.number().int().positive(),
-  description: z19.string().min(1),
-  type: z19.enum(["gating", "evidence"])
+var AcceptanceCriterionSchema = z20.object({
+  id: z20.number().int().positive(),
+  description: z20.string().min(1),
+  type: z20.enum(["gating", "evidence"])
 }).strict();
-var PlanSchema = z19.object({
-  kind: z19.enum(["code-change", "analysis", "research"]),
-  criteria: z19.array(AcceptanceCriterionSchema).min(1).max(32),
-  verificationPlan: z19.string().min(1),
-  nonGoals: z19.array(z19.string()).max(16),
-  assumedScope: z19.array(z19.string()).max(16),
-  approach: z19.string().optional(),
-  checklist: z19.array(z19.string()).max(32).optional()
+var PlanSchema = z20.object({
+  kind: z20.enum(["code-change", "analysis", "research"]),
+  criteria: z20.array(AcceptanceCriterionSchema).min(1).max(32),
+  verificationPlan: z20.string().min(1),
+  nonGoals: z20.array(z20.string()).max(16),
+  assumedScope: z20.array(z20.string()).max(16),
+  approach: z20.string().optional(),
+  checklist: z20.array(z20.string()).max(32).optional()
 }).strict();
-var GapSchema = z19.object({
-  criterion: z19.string().min(1),
-  description: z19.string().min(1),
-  blocking: z19.enum(["model_fixable", "contradiction", "unverifiable"])
+var GapSchema = z20.object({
+  criterion: z20.string().min(1),
+  description: z20.string().min(1),
+  blocking: z20.enum(["model_fixable", "contradiction", "unverifiable"])
 }).strict();
-var VerdictSchema = z19.object({
-  refuted: z19.boolean(),
-  gaps: z19.array(GapSchema)
+var VerdictSchema = z20.object({
+  refuted: z20.boolean(),
+  gaps: z20.array(GapSchema)
 }).strict();
-var GoalStateSchema = z19.object({
-  id: z19.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/),
-  objective: z19.string().min(1),
+var GoalStateSchema = z20.object({
+  id: z20.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/),
+  objective: z20.string().min(1),
   phase: GoalPhaseSchema,
   status: GoalStatusSchema,
   plan: PlanSchema.nullable(),
-  planPath: z19.string().nullable(),
-  verifyRounds: z19.number().int().min(0),
-  workerRounds: z19.number().int().min(0),
-  lastGaps: z19.array(GapSchema),
-  gapFingerprint: z19.string(),
-  stallStreak: z19.number().int().min(0),
-  createdAt: z19.string().datetime({ offset: true }),
-  updatedAt: z19.string().datetime({ offset: true })
+  planPath: z20.string().nullable(),
+  verifyRounds: z20.number().int().min(0),
+  workerRounds: z20.number().int().min(0),
+  lastGaps: z20.array(GapSchema),
+  gapFingerprint: z20.string(),
+  stallStreak: z20.number().int().min(0),
+  createdAt: z20.string().datetime({ offset: true }),
+  updatedAt: z20.string().datetime({ offset: true })
 }).strict();
 
 // src/goal/planner.ts
@@ -10966,7 +11209,7 @@ function formatPriorGaps(gaps) {
 import { constants as constants2 } from "fs";
 import { randomUUID as randomUUID7 } from "crypto";
 import { lstat as lstat5, mkdir as mkdir11, open as open5, rename as rename4, rm as rm6 } from "fs/promises";
-import { dirname as dirname9, join as join14, relative as relative9, resolve as resolve10, sep as sep8 } from "path";
+import { dirname as dirname10, join as join14, relative as relative9, resolve as resolve10, sep as sep8 } from "path";
 var DEFAULT_MAX_BYTES = 1024 * 1024;
 var GoalStore = class {
   #workspace;
@@ -10979,7 +11222,7 @@ var GoalStore = class {
   }
   async save(input) {
     const state = GoalStateSchema.parse(input);
-    await assertNoSymlink(this.#workspace, dirname9(this.#root));
+    await assertNoSymlink(this.#workspace, dirname10(this.#root));
     await mkdir11(this.#root, { recursive: true, mode: 448 });
     await assertNoSymlink(this.#workspace, this.#root);
     const target = join14(this.#root, `${state.id}.json`);
@@ -11013,7 +11256,7 @@ async function assertNoSymlink(root, target) {
   const chain = [];
   while (cursor !== stop) {
     chain.push(cursor);
-    cursor = dirname9(cursor);
+    cursor = dirname10(cursor);
   }
   for (const path of chain.reverse()) {
     try {
@@ -11099,8 +11342,8 @@ async function ensureWorktreeDirectoryIgnored(root) {
 
 // src/loop/store.ts
 import { constants as constants3 } from "fs";
-import { lstat as lstat6, mkdir as mkdir13, open as open6, readFile as readFile11, realpath as realpath7, rename as rename5, rm as rm7, stat as stat6 } from "fs/promises";
-import { dirname as dirname10, join as join16, relative as relative10, resolve as resolve12, sep as sep9 } from "path";
+import { lstat as lstat6, mkdir as mkdir13, open as open6, readFile as readFile11, realpath as realpath8, rename as rename5, rm as rm7, stat as stat6 } from "fs/promises";
+import { dirname as dirname11, join as join16, relative as relative10, resolve as resolve12, sep as sep9 } from "path";
 import { randomUUID as randomUUID8 } from "crypto";
 var LOOP_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 var DEFAULT_MAX_BYTES2 = 5 * 1024 * 1024;
@@ -11182,7 +11425,7 @@ var LoopStore = class {
   }
   async #prepare(loopId) {
     validateId(loopId);
-    await assertNoSymlink2(this.#workspace, dirname10(this.#root));
+    await assertNoSymlink2(this.#workspace, dirname11(this.#root));
     await mkdir13(this.#root, { recursive: true, mode: 448 });
     await assertNoSymlink2(this.#workspace, this.#root);
     const directory = join16(this.#root, loopId);
@@ -11215,7 +11458,7 @@ async function assertNoSymlink2(root, target) {
   const chain = [];
   while (cursor !== stop) {
     chain.push(cursor);
-    cursor = dirname10(cursor);
+    cursor = dirname11(cursor);
   }
   for (const path of chain.reverse()) {
     try {
@@ -11231,7 +11474,7 @@ function isWithin2(root, path) {
 }
 async function canonical(path) {
   try {
-    return await realpath7(resolve12(path));
+    return await realpath8(resolve12(path));
   } catch {
     return resolve12(path);
   }
@@ -11247,19 +11490,19 @@ import { join as join17 } from "path";
 // src/tools/shell.ts
 import { spawn as spawn3, spawnSync } from "child_process";
 import { isAbsolute as isAbsolute8, relative as relative11, resolve as resolve13, sep as sep10 } from "path";
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 
 // src/tools/jobs.ts
-import { z as z20 } from "zod";
-var JobId = z20.string().regex(/^job-[a-f0-9-]+$/);
-var ReadInput = z20.object({ id: JobId, cursor: z20.coerce.number().int().min(0).optional() });
-var IdInput = z20.object({ id: JobId });
+import { z as z21 } from "zod";
+var JobId = z21.string().regex(/^job-[a-f0-9-]+$/);
+var ReadInput = z21.object({ id: JobId, cursor: z21.coerce.number().int().min(0).optional() });
+var IdInput = z21.object({ id: JobId });
 function createJobTools(registry) {
   const tools = [
     {
       name: "JobList",
       description: "List background jobs owned by this agent",
-      inputSchema: z20.object({}),
+      inputSchema: z21.object({}),
       paths: () => [],
       execute: async (_input, _signal, context) => registry.list(owner(context)),
       presentResult: (output) => jobListPresentation(output)
@@ -11334,14 +11577,14 @@ var ELLIPSIS = "\u2026";
 var TERMINATION_GRACE_MS = 250;
 var TERMINATION_FAILURE_MS = 5e3;
 var STREAM_CLOSE_GRACE_MS = 500;
-var ShellInput = z21.object({
-  command: z21.string().min(1),
-  args: z21.array(z21.string()),
-  cwd: z21.string().min(1).nullable().optional(),
-  timeoutMs: z21.coerce.number().int().positive().max(864e5).nullable().optional(),
+var ShellInput = z22.object({
+  command: z22.string().min(1),
+  args: z22.array(z22.string()),
+  cwd: z22.string().min(1).nullable().optional(),
+  timeoutMs: z22.coerce.number().int().positive().max(864e5).nullable().optional(),
   // Accepts booleans and their string forms (weak-typed models emit "true");
   // kept transform-free so the schema converts to JSON Schema for providers.
-  background: z21.union([z21.boolean(), z21.string().refine((value) => value === "true" || value === "false")]).optional()
+  background: z22.union([z22.boolean(), z22.string().refine((value) => value === "true" || value === "false")]).optional()
 });
 function normalizeShellCommand(input) {
   const { command, args } = input;
@@ -11943,7 +12186,7 @@ function isEnvTruthy(value) {
 
 // src/utils/log.ts
 import { appendFile as appendFile3, mkdir as mkdir14 } from "fs/promises";
-import { dirname as dirname11, join as join18, resolve as resolve14 } from "path";
+import { dirname as dirname12, join as join18, resolve as resolve14 } from "path";
 var pending = Promise.resolve();
 var usagePending = Promise.resolve();
 function usageLogPath() {
@@ -11962,7 +12205,7 @@ async function appendUsageLog(line) {
   usagePending = usagePending.catch(() => void 0).then(async () => {
     try {
       const path = usageLogPath();
-      await mkdir14(dirname11(path), { recursive: true, mode: 448 });
+      await mkdir14(dirname12(path), { recursive: true, mode: 448 });
       const flag = truncateOnNextAppend ? "w" : "a";
       truncateOnNextAppend = false;
       await appendFile3(path, `${line}
@@ -11990,7 +12233,7 @@ var AuditLogger = class {
   }
   async #write(line) {
     try {
-      await mkdir14(dirname11(this.#path), { recursive: true, mode: 448 });
+      await mkdir14(dirname12(this.#path), { recursive: true, mode: 448 });
       await appendFile3(this.#path, line, { encoding: "utf8", mode: 384, flag: "a" });
     } catch {
     }
@@ -12575,7 +12818,7 @@ var ModelRegistry = class {
 
 // src/mcp/client.ts
 import { createHash as createHash7 } from "crypto";
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var McpManager = class {
   #workspace;
   #clientFactory;
@@ -12711,7 +12954,7 @@ async function listAllTools(client) {
 function createMcpToolDefinition(serverName, timeoutMs, client, remote) {
   if (remote.name.length === 0) throw new Error("MCP tool name must not be empty");
   if (!isRecord4(remote.inputSchema)) throw new Error(`MCP tool "${remote.name}" has no JSON object input schema`);
-  const inputSchema = z22.fromJSONSchema(
+  const inputSchema = z23.fromJSONSchema(
     remote.inputSchema
   );
   return {
@@ -12772,12 +13015,12 @@ import {
 
 // src/utils/version.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname12, join as join19 } from "path";
+import { dirname as dirname13, join as join19 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var cached;
 function packageVersion() {
   if (cached !== void 0) return cached;
-  let directory = dirname12(fileURLToPath2(import.meta.url));
+  let directory = dirname13(fileURLToPath2(import.meta.url));
   for (; ; ) {
     try {
       const manifest = JSON.parse(readFileSync2(join19(directory, "package.json"), "utf8"));
@@ -12787,7 +13030,7 @@ function packageVersion() {
       }
     } catch {
     }
-    const parent = dirname12(directory);
+    const parent = dirname13(directory);
     if (parent === directory) break;
     directory = parent;
   }
@@ -13147,7 +13390,7 @@ function escapeHtml(text) {
 }
 
 // src/auth/store.ts
-import { dirname as dirname13 } from "path";
+import { dirname as dirname14 } from "path";
 async function retainOnlyCredentials(store, keepCredentialId) {
   const tokens2 = await store.load();
   const retained = Object.fromEntries(Object.entries(tokens2).filter(([id]) => id === keepCredentialId));
@@ -13158,7 +13401,7 @@ function createFileTokenStore(filePath) {
   const store = {
     tokens: {},
     async load() {
-      const key = await loadOrCreateConfigKey(dirname13(filePath));
+      const key = await loadOrCreateConfigKey(dirname14(filePath));
       const result = await readRecoverableFile(filePath, (raw) => parseTokens(decryptDocument(raw, key)));
       const tokens2 = result?.value ?? {};
       baseline = { ...tokens2 };
@@ -13166,7 +13409,7 @@ function createFileTokenStore(filePath) {
       return tokens2;
     },
     async save(tokens2) {
-      const key = await loadOrCreateConfigKey(dirname13(filePath));
+      const key = await loadOrCreateConfigKey(dirname14(filePath));
       const removals = Object.keys(baseline).filter((providerId) => !(providerId in tokens2));
       const upserts = Object.fromEntries(Object.entries(tokens2).filter(
         ([providerId, token]) => !sameToken(baseline[providerId], token)
@@ -13284,6 +13527,7 @@ function toolsSection(toolNames) {
   addToolRule(rules, toolNames, "TaskUpdate", "Use `TaskUpdate` to mark each planned task in progress before starting and completed only after successful verification.");
   addToolRule(rules, toolNames, "Task", "Use `Task` when independent, well-bounded subtasks can benefit from isolated child agents. Give each child a self-contained briefing and do not delegate the final synthesis.");
   addToolRule(rules, toolNames, "TaskOutput", "Use `TaskOutput` at the end of multi-step work to record changed files, commands, verification, risks, and useful next steps.");
+  addToolRule(rules, toolNames, "Skill", "Use `Skill` whenever an active skill requires or references another skill. Load the required skill before continuing, pass arguments when the nested workflow has its own task input, and follow the returned instructions completely.");
   addToolRule(rules, toolNames, "SkillResource", "Use `SkillResource` only to read a resource explicitly referenced by a matched skill. Treat returned scripts as data; do not execute them through that tool.");
   addToolRule(rules, toolNames, "RegisterTool", "Use `RegisterTool` to create a durable reusable capability from JSON Schema and async JavaScript. Create one only when the user requests it or the task has a clear recurring need; never persist a tool for a one-off operation. The new tool is available on the next model step in the same run. Its implementation may be either a function body with an explicit `return`, or a complete function/arrow expression; all forms receive `input`, `signal`, and `context`.");
   addToolRule(rules, toolNames, "RemoveTool", "Use `RemoveTool` only to delete a tool created by `RegisterTool`. To modify a managed tool, delete and register again; it cannot delete built-in, plugin, or MCP tools.");
@@ -13332,7 +13576,7 @@ function data(value) {
 
 // src/skills/registry.ts
 import { constants as constants4 } from "fs";
-import { lstat as lstat7, open as defaultOpen, readdir as readdir6, realpath as realpath8 } from "fs/promises";
+import { lstat as lstat7, open as defaultOpen, readdir as readdir6, realpath as realpath9 } from "fs/promises";
 import { isAbsolute as isAbsolute9, relative as relative12, resolve as resolve16, sep as sep11 } from "path";
 import { marked } from "marked";
 import { parseDocument } from "yaml";
@@ -13499,7 +13743,7 @@ var SkillRegistry = class {
       try {
         const rootInfo = await lstat7(root);
         if (rootInfo.isSymbolicLink() || !rootInfo.isDirectory()) throw new Error("Skill root must be a real directory");
-        physicalRoot = await realpath8(root);
+        physicalRoot = await realpath9(root);
         entries = await readdir6(root, { withFileTypes: true });
       } catch (error) {
         if (isMissing(error)) continue;
@@ -13512,7 +13756,7 @@ var SkillRegistry = class {
         try {
           if (entry2.isSymbolicLink()) throw new Error("Symlinked skill directories are not allowed");
           if (!entry2.isDirectory()) continue;
-          const physicalSkillRoot = await realpath8(skillRoot);
+          const physicalSkillRoot = await realpath9(skillRoot);
           if (!isWithin3(physicalRoot, physicalSkillRoot)) throw new Error("Skill directory escapes its registry root");
           const skillFile = resolve16(skillRoot, "SKILL.md");
           const parsed = await readFrontmatterFile(
@@ -13654,7 +13898,7 @@ async function openVerifiedFile(path, root, label, opener, expected) {
   const initial = await lstat7(path, { bigint: true });
   if (initial.isSymbolicLink()) throw new Error(`${label} symlinks are not allowed`);
   assertRegular(initial, label);
-  const canonical3 = await realpath8(path);
+  const canonical3 = await realpath9(path);
   if (!isWithin3(root, canonical3)) throw new Error(`${label} escapes the skill root`);
   const noFollow = typeof constants4.O_NOFOLLOW === "number" ? constants4.O_NOFOLLOW : 0;
   const handle = await opener(canonical3, constants4.O_RDONLY | noFollow);
@@ -13763,11 +14007,97 @@ function score(metadata, query) {
 }
 
 // src/skills/tool.ts
-import { z as z23 } from "zod";
-var SkillResourceInput = z23.object({
-  skill: z23.string().min(1),
-  reference: z23.string().min(1)
+import { z as z24 } from "zod";
+
+// src/skills/arguments.ts
+function expandSkillArguments(body, argumentsText) {
+  const values = splitSkillArguments(argumentsText);
+  const hasPlaceholder = /\$ARGUMENTS(?:\[\d+\])?|\$\d+/.test(body);
+  let expanded = body.replace(/\$ARGUMENTS\[(\d+)\]/g, (_match, index) => values[Number(index)] ?? "");
+  expanded = expanded.replace(/\$(\d+)/g, (_match, index) => values[Number(index)] ?? "");
+  expanded = expanded.replace(/\$ARGUMENTS/g, argumentsText);
+  if (!hasPlaceholder && argumentsText.trim() !== "") {
+    expanded = `${expanded.trimEnd()}
+
+ARGUMENTS: ${argumentsText}`;
+  }
+  return expanded;
+}
+function splitSkillArguments(input) {
+  const result = [];
+  let current = "";
+  let quote;
+  let started = false;
+  for (let index = 0; index < input.length; index += 1) {
+    const character = input[index] ?? "";
+    const next = input[index + 1];
+    if (character === "\\" && quote !== "'" && next !== void 0 && (/\s/u.test(next) || next === "\\" || next === '"' || quote === void 0 && next === "'")) {
+      current += next;
+      index += 1;
+      started = true;
+      continue;
+    }
+    if (quote !== void 0) {
+      if (character === quote) quote = void 0;
+      else current += character;
+      started = true;
+      continue;
+    }
+    if (character === "'" || character === '"') {
+      quote = character;
+      started = true;
+      continue;
+    }
+    if (/\s/u.test(character)) {
+      if (started) {
+        result.push(current);
+        current = "";
+        started = false;
+      }
+      continue;
+    }
+    current += character;
+    started = true;
+  }
+  if (started) result.push(current);
+  return result;
+}
+
+// src/skills/tool.ts
+var SkillInput = z24.object({
+  skill: z24.string().min(1),
+  arguments: z24.string().optional()
 }).strict();
+var SkillResourceInput = z24.object({
+  skill: z24.string().min(1),
+  reference: z24.string().min(1)
+}).strict();
+function createSkillTool(registry) {
+  return {
+    name: "Skill",
+    description: "Load another discovered skill by name so composable workflows can follow its complete instructions; optional arguments use Claude-compatible $ARGUMENTS substitution",
+    inputSchema: SkillInput,
+    readOnly: true,
+    paths: () => [],
+    summarize: ({ skill }) => skill,
+    renderForModel: (output) => {
+      const value = output;
+      return `Matched skill: ${value.skill}
+${value.content}`;
+    },
+    execute: async (input, signal) => {
+      signal.throwIfAborted();
+      const discovered = await registry.discover();
+      const requested = input.skill.trim();
+      const alias = requested.includes(":") ? requested.slice(requested.lastIndexOf(":") + 1) : requested;
+      const skill = discovered.find((candidate) => candidate.name === requested) ?? discovered.find((candidate) => candidate.name === alias);
+      if (skill === void 0) throw new Error(`Unknown skill: ${input.skill}`);
+      const content = expandSkillArguments(await registry.loadBody(skill), input.arguments ?? "");
+      signal.throwIfAborted();
+      return { skill: skill.name, content };
+    }
+  };
+}
 function createSkillResourceTool(registry) {
   return {
     name: "SkillResource",
@@ -13793,10 +14123,10 @@ function createSkillResourceTool(registry) {
 
 // src/session/store.ts
 import { constants as constants5 } from "fs";
-import { lstat as lstat8, mkdir as mkdir15, open as open7, readFile as readFile15, readdir as readdir7, realpath as realpath9, rename as rename6, rm as rm8, stat as stat7 } from "fs/promises";
-import { basename as basename5, dirname as dirname14, join as join20, relative as relative13, resolve as resolve17, sep as sep12 } from "path";
+import { lstat as lstat8, mkdir as mkdir15, open as open7, readFile as readFile15, readdir as readdir7, realpath as realpath10, rename as rename6, rm as rm8, stat as stat7 } from "fs/promises";
+import { basename as basename5, dirname as dirname15, join as join20, relative as relative13, resolve as resolve17, sep as sep12 } from "path";
 import { randomUUID as randomUUID9 } from "crypto";
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 
 // src/ui/transcript.ts
 function createTranscriptState() {
@@ -14329,91 +14659,91 @@ function addText(turn, text, onNewLine = false) {
 // src/session/store.ts
 var SESSION_VERSION = 3;
 var DEFAULT_MAX_SESSION_BYTES = 5 * 1024 * 1024;
-var SessionIdSchema = z24.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/, "Invalid session id");
-var IsoDateSchema = z24.string().datetime({ offset: true });
-var ToolCallSchema = z24.object({
-  id: z24.string().min(1).max(256),
-  name: z24.string().min(1).max(256),
-  input: z24.unknown()
+var SessionIdSchema = z25.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/, "Invalid session id");
+var IsoDateSchema = z25.string().datetime({ offset: true });
+var ToolCallSchema = z25.object({
+  id: z25.string().min(1).max(256),
+  name: z25.string().min(1).max(256),
+  input: z25.unknown()
 }).strict();
-var TextContentBlockSchema = z24.object({
-  type: z24.literal("text"),
-  text: z24.string().max(DEFAULT_MAX_SESSION_BYTES)
+var TextContentBlockSchema = z25.object({
+  type: z25.literal("text"),
+  text: z25.string().max(DEFAULT_MAX_SESSION_BYTES)
 }).strict();
-var ImageContentBlockSchema = z24.object({
-  type: z24.literal("image"),
-  source: z24.object({ type: z24.literal("file"), path: z24.string().min(1).max(32768) }).strict(),
-  mediaType: z24.enum(["image/png", "image/jpeg", "image/webp"]),
-  sha256: z24.string().regex(/^[a-f0-9]{64}$/),
-  bytes: z24.number().int().positive().max(20 * 1024 * 1024),
-  name: z24.string().min(1).max(255).optional()
+var ImageContentBlockSchema = z25.object({
+  type: z25.literal("image"),
+  source: z25.object({ type: z25.literal("file"), path: z25.string().min(1).max(32768) }).strict(),
+  mediaType: z25.enum(["image/png", "image/jpeg", "image/webp"]),
+  sha256: z25.string().regex(/^[a-f0-9]{64}$/),
+  bytes: z25.number().int().positive().max(20 * 1024 * 1024),
+  name: z25.string().min(1).max(255).optional()
 }).strict();
-var UserContentSchema = z24.union([
-  z24.string().max(DEFAULT_MAX_SESSION_BYTES),
-  z24.array(z24.discriminatedUnion("type", [TextContentBlockSchema, ImageContentBlockSchema])).min(1).max(100)
+var UserContentSchema = z25.union([
+  z25.string().max(DEFAULT_MAX_SESSION_BYTES),
+  z25.array(z25.discriminatedUnion("type", [TextContentBlockSchema, ImageContentBlockSchema])).min(1).max(100)
 ]);
 var MessageMetadataShape = {
-  toolCallId: z24.string().min(1).max(256).optional(),
-  toolCalls: z24.array(ToolCallSchema).max(1e3).optional()
+  toolCallId: z25.string().min(1).max(256).optional(),
+  toolCalls: z25.array(ToolCallSchema).max(1e3).optional()
 };
-var MessageSchema = z24.discriminatedUnion("role", [
-  z24.object({ role: z24.literal("user"), content: UserContentSchema, ...MessageMetadataShape }).strict(),
-  z24.object({ role: z24.literal("assistant"), content: z24.string().max(DEFAULT_MAX_SESSION_BYTES), ...MessageMetadataShape }).strict(),
-  z24.object({ role: z24.literal("tool"), content: z24.string().max(DEFAULT_MAX_SESSION_BYTES), ...MessageMetadataShape }).strict()
+var MessageSchema = z25.discriminatedUnion("role", [
+  z25.object({ role: z25.literal("user"), content: UserContentSchema, ...MessageMetadataShape }).strict(),
+  z25.object({ role: z25.literal("assistant"), content: z25.string().max(DEFAULT_MAX_SESSION_BYTES), ...MessageMetadataShape }).strict(),
+  z25.object({ role: z25.literal("tool"), content: z25.string().max(DEFAULT_MAX_SESSION_BYTES), ...MessageMetadataShape }).strict()
 ]);
-var LegacySummarySchema = z24.object({ role: z24.literal("system"), content: z24.string().max(DEFAULT_MAX_SESSION_BYTES) }).strict();
-var CompactBoundarySchema = z24.object({
-  summary: z24.string().min(1).max(DEFAULT_MAX_SESSION_BYTES),
+var LegacySummarySchema = z25.object({ role: z25.literal("system"), content: z25.string().max(DEFAULT_MAX_SESSION_BYTES) }).strict();
+var CompactBoundarySchema = z25.object({
+  summary: z25.string().min(1).max(DEFAULT_MAX_SESSION_BYTES),
   compactedAt: IsoDateSchema
 }).strict();
-var StateSchema = z24.enum(["pending", "running", "completed", "failed", "blocked", "cancelled"]);
-var MemoryLifecycleSchema = z24.object({
-  status: z24.enum(["active", "completed", "abandoned"]),
-  taskId: z24.string().regex(/^memory-[A-Za-z0-9._-]{1,120}$/).optional(),
-  messageStart: z24.number().int().min(0).max(5e4).optional(),
+var StateSchema = z25.enum(["pending", "running", "completed", "failed", "blocked", "cancelled"]);
+var MemoryLifecycleSchema = z25.object({
+  status: z25.enum(["active", "completed", "abandoned"]),
+  taskId: z25.string().regex(/^memory-[A-Za-z0-9._-]{1,120}$/).optional(),
+  messageStart: z25.number().int().min(0).max(5e4).optional(),
   finalizedAt: IsoDateSchema.optional(),
-  transcriptHash: z24.string().regex(/^[a-f0-9]{64}$/).optional()
+  transcriptHash: z25.string().regex(/^[a-f0-9]{64}$/).optional()
 }).strict();
-var SessionBaseSchema = z24.object({
+var SessionBaseSchema = z25.object({
   sessionId: SessionIdSchema,
   createdAt: IsoDateSchema,
   updatedAt: IsoDateSchema,
-  workspace: z24.object({ path: z24.string().min(1).max(32768) }).strict(),
-  tasks: z24.object({
+  workspace: z25.object({ path: z25.string().min(1).max(32768) }).strict(),
+  tasks: z25.object({
     plan: TaskPlanSchema.optional(),
     graph: TaskGraphSchema.optional(),
-    states: z24.record(z24.string(), StateSchema),
-    results: z24.record(z24.string(), SubagentResultSchema)
+    states: z25.record(z25.string(), StateSchema),
+    results: z25.record(z25.string(), SubagentResultSchema)
   }).strict(),
-  models: z24.object({ main: z24.string().min(1).max(1024), subagent: z24.string().min(1).max(1024) }).strict(),
+  models: z25.object({ main: z25.string().min(1).max(1024), subagent: z25.string().min(1).max(1024) }).strict(),
   permissionMode: PermissionModeSchema,
   memory: MemoryLifecycleSchema.optional()
 }).strict();
 var SessionDocumentV1Schema = SessionBaseSchema.extend({
-  version: z24.literal(1),
-  conversation: z24.object({
+  version: z25.literal(1),
+  conversation: z25.object({
     summary: LegacySummarySchema.optional(),
-    messages: z24.array(MessageSchema).max(5e4)
+    messages: z25.array(MessageSchema).max(5e4)
   }).strict()
 }).strict();
-var ConversationSchema = z24.object({
+var ConversationSchema = z25.object({
   compact: CompactBoundarySchema.optional(),
-  messages: z24.array(MessageSchema).max(5e4)
+  messages: z25.array(MessageSchema).max(5e4)
 }).strict();
 var SessionDocumentV2Schema = SessionBaseSchema.extend({
-  version: z24.literal(2),
+  version: z25.literal(2),
   conversation: ConversationSchema
 }).strict();
-var TranscriptStateSchema = z24.custom(isTranscriptState, "Invalid transcript state");
-var TimelineSchema = z24.object({
-  version: z24.literal(1),
+var TranscriptStateSchema = z25.custom(isTranscriptState, "Invalid transcript state");
+var TimelineSchema = z25.object({
+  version: z25.literal(1),
   state: TranscriptStateSchema
 }).strict();
 var SessionDocumentSchema = SessionBaseSchema.extend({
-  version: z24.literal(SESSION_VERSION),
-  conversation: z24.object({
+  version: z25.literal(SESSION_VERSION),
+  conversation: z25.object({
     compact: CompactBoundarySchema.optional(),
-    messages: z24.array(MessageSchema).max(5e4)
+    messages: z25.array(MessageSchema).max(5e4)
   }).strict(),
   timeline: TimelineSchema
 }).strict();
@@ -14589,14 +14919,14 @@ var SessionStore = class {
     }
   }
   async #prepareDirectory() {
-    await assertNoSymlink3(this.#workspace, dirname14(this.#sessions));
+    await assertNoSymlink3(this.#workspace, dirname15(this.#sessions));
     await mkdir15(this.#sessions, { recursive: true, mode: 448 });
     await this.#assertSafeExistingDirectory();
   }
   async #assertSafeExistingDirectory() {
     await assertNoSymlink3(this.#workspace, this.#sessions);
-    const canonicalRoot = await realpath9(this.#workspace);
-    const canonicalSessions = await realpath9(this.#sessions);
+    const canonicalRoot = await realpath10(this.#workspace);
+    const canonicalSessions = await realpath10(this.#sessions);
     if (!isWithin4(canonicalRoot, canonicalSessions)) throw new Error("Session directory escapes the workspace");
   }
   async #quarantine(path) {
@@ -14753,7 +15083,7 @@ async function assertNoSymlink3(root, target) {
   const chain = [];
   while (cursor !== stop) {
     chain.push(cursor);
-    cursor = dirname14(cursor);
+    cursor = dirname15(cursor);
   }
   for (const path of chain.reverse()) {
     try {
@@ -14769,7 +15099,7 @@ function isWithin4(root, path) {
 }
 async function canonical2(path) {
   try {
-    return await realpath9(resolve17(path));
+    return await realpath10(resolve17(path));
   } catch {
     return resolve17(path);
   }
@@ -14798,13 +15128,13 @@ function sanitize2(input, seen = /* @__PURE__ */ new WeakSet()) {
 // src/session/tree.ts
 import { randomUUID as randomUUID11 } from "crypto";
 import { mkdir as mkdir17, readFile as readFile17, rename as rename8, writeFile as writeFile11 } from "fs/promises";
-import { dirname as dirname16, join as join22, resolve as resolve19 } from "path";
+import { dirname as dirname17, join as join22, resolve as resolve19 } from "path";
 
 // src/session/checkpoint.ts
 import { createHash as createHash10, randomUUID as randomUUID10 } from "crypto";
 import { execFile as execFile2 } from "child_process";
 import { lstat as lstat9, mkdir as mkdir16, open as open8, readFile as readFile16, readdir as readdir8, rename as rename7, rm as rm9, writeFile as writeFile10 } from "fs/promises";
-import { dirname as dirname15, join as join21, relative as relative14, resolve as resolve18, sep as sep13 } from "path";
+import { dirname as dirname16, join as join21, relative as relative14, resolve as resolve18, sep as sep13 } 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;
@@ -14890,7 +15220,7 @@ var WorkspaceCheckpointStore = class {
     for (const file of checkpoint.files) {
       const target = contained(this.#workspace, file.path);
       const object = objects.get(file.digest);
-      await mkdir16(dirname15(target), { recursive: true });
+      await mkdir16(dirname16(target), { recursive: true });
       const temporary = `${target}.${process.pid}.${randomUUID10()}.tmp`;
       await writeFile10(temporary, object, { mode: file.mode });
       await rename7(temporary, target);
@@ -14962,7 +15292,7 @@ function contained(workspace, path) {
   return absolute;
 }
 async function atomicJson(path, value) {
-  await mkdir16(dirname15(path), { recursive: true });
+  await mkdir16(dirname16(path), { recursive: true });
   const temporary = `${path}.${process.pid}.${randomUUID10()}.tmp`;
   await writeFile10(temporary, `${JSON.stringify(value)}
 `, { encoding: "utf8", mode: 384 });
@@ -15065,7 +15395,7 @@ var SessionHistory = class _SessionHistory {
       leafId: this.#leafId,
       nodes: this.#nodes
     };
-    await mkdir17(dirname16(this.#path), { recursive: true });
+    await mkdir17(dirname17(this.#path), { recursive: true });
     const temporary = `${this.#path}.${process.pid}.${randomUUID11()}.tmp`;
     await writeFile11(temporary, `${JSON.stringify(document)}
 `, { encoding: "utf8", mode: 384 });
@@ -15093,45 +15423,45 @@ function isCode9(error, code) {
 // src/sleep/organizer.ts
 import { constants as constants6 } from "fs";
 import { randomUUID as randomUUID12 } from "crypto";
-import { lstat as lstat10, mkdir as mkdir18, open as open9, readdir as readdir9, realpath as realpath10, rename as rename9, rm as rm10 } from "fs/promises";
+import { lstat as lstat10, mkdir as mkdir18, open as open9, readdir as readdir9, realpath as realpath11, rename as rename9, rm as rm10 } from "fs/promises";
 import { isAbsolute as isAbsolute10, join as join23, relative as relative15, resolve as resolve20, sep as sep14 } from "path";
-import { z as z25 } from "zod";
-var DateKeySchema = z25.string().regex(/^\d{4}-\d{2}-\d{2}$/);
-var ReviewSchema = z25.object({
-  title: z25.string().min(1).max(120),
-  taskSummary: z25.array(z25.string().min(1)).min(1).max(20),
-  executionReflection: z25.array(z25.string().min(1)).min(1).max(20),
-  decisionsAndLearnings: z25.array(z25.string().min(1)).max(20),
-  openQuestionsAndRisks: z25.array(z25.string().min(1)).max(20),
-  tomorrowPlan: z25.array(z25.string().min(1)).min(1).max(20),
-  toolUsage: z25.object({
-    totalCalls: z25.number().int().min(0),
-    shell: z25.number().int().min(0),
-    fileRead: z25.number().int().min(0),
-    fileWrite: z25.number().int().min(0),
-    search: z25.number().int().min(0),
-    lsp: z25.number().int().min(0),
-    subagent: z25.number().int().min(0),
-    other: z25.number().int().min(0)
+import { z as z26 } from "zod";
+var DateKeySchema = z26.string().regex(/^\d{4}-\d{2}-\d{2}$/);
+var ReviewSchema = z26.object({
+  title: z26.string().min(1).max(120),
+  taskSummary: z26.array(z26.string().min(1)).min(1).max(20),
+  executionReflection: z26.array(z26.string().min(1)).min(1).max(20),
+  decisionsAndLearnings: z26.array(z26.string().min(1)).max(20),
+  openQuestionsAndRisks: z26.array(z26.string().min(1)).max(20),
+  tomorrowPlan: z26.array(z26.string().min(1)).min(1).max(20),
+  toolUsage: z26.object({
+    totalCalls: z26.number().int().min(0),
+    shell: z26.number().int().min(0),
+    fileRead: z26.number().int().min(0),
+    fileWrite: z26.number().int().min(0),
+    search: z26.number().int().min(0),
+    lsp: z26.number().int().min(0),
+    subagent: z26.number().int().min(0),
+    other: z26.number().int().min(0)
   }).strict(),
-  tokenEstimate: z25.object({
-    estimatedInput: z25.number().int().min(0),
-    estimatedOutput: z25.number().int().min(0),
-    notes: z25.string().max(200)
+  tokenEstimate: z26.object({
+    estimatedInput: z26.number().int().min(0),
+    estimatedOutput: z26.number().int().min(0),
+    notes: z26.string().max(200)
   }).strict(),
-  humanIntervention: z25.object({
-    approvalRequests: z25.number().int().min(0),
-    questionsAsked: z25.number().int().min(0),
-    summary: z25.string().max(300)
+  humanIntervention: z26.object({
+    approvalRequests: z26.number().int().min(0),
+    questionsAsked: z26.number().int().min(0),
+    summary: z26.string().max(300)
   }).strict(),
-  qualityIndicators: z25.object({
-    hallucinationAlerts: z25.array(z25.string().min(1)).max(10),
-    failuresAndRetries: z25.array(z25.string().min(1)).max(10),
-    codeChangeSummary: z25.string().max(500),
-    overallAssessment: z25.string().max(200)
+  qualityIndicators: z26.object({
+    hallucinationAlerts: z26.array(z26.string().min(1)).max(10),
+    failuresAndRetries: z26.array(z26.string().min(1)).max(10),
+    codeChangeSummary: z26.string().max(500),
+    overallAssessment: z26.string().max(200)
   }).strict(),
-  knowledgeDeposits: z25.object({
-    worthRemembering: z25.array(z25.string().min(1)).max(10)
+  knowledgeDeposits: z26.object({
+    worthRemembering: z26.array(z26.string().min(1)).max(10)
   }).strict()
 }).strict();
 function localDateKey(date) {
@@ -15240,8 +15570,8 @@ Previous output was invalid. Repair it and return strict JSON only.`;
     await mkdir18(flavorDirectory, { recursive: true, mode: 448 });
     await assertNotSymlink(this.#sleepDirectory);
     await mkdir18(this.#sleepDirectory, { recursive: true, mode: 448 });
-    const root = await realpath10(this.#workspace);
-    const target = await realpath10(this.#sleepDirectory);
+    const root = await realpath11(this.#workspace);
+    const target = await realpath11(this.#sleepDirectory);
     if (!isWithin5(root, target)) throw new Error("Sleep directory escapes the workspace");
   }
   async #hasReport(date) {
@@ -15623,10 +15953,10 @@ function computeSessionStats(documents) {
 
 // src/tools/files.ts
 import { constants as constants7 } from "fs";
-import { mkdir as mkdir19, open as open10, readFile as readFile18, realpath as realpath11, rename as rename10, rm as rm11, stat as stat8 } from "fs/promises";
-import { dirname as dirname17, isAbsolute as isAbsolute11, relative as relative16, resolve as resolve21, sep as sep15 } from "path";
+import { mkdir as mkdir19, open as open10, readFile as readFile18, 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 resolve21, sep as sep15 } from "path";
 import { randomUUID as randomUUID13 } from "crypto";
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 
 // src/tools/file-diff.ts
 var MAX_DIFF_PREVIEW_LINES = 120;
@@ -15732,18 +16062,18 @@ function truncateLines(lines) {
 
 // src/tools/files.ts
 var MAX_READ_BYTES = 1048576;
-var ReadInput2 = z26.object({
-  path: z26.string().min(1),
-  maxBytes: z26.coerce.number().int().positive().max(MAX_READ_BYTES).nullable().optional(),
-  startLine: z26.coerce.number().int().positive().nullable().optional(),
-  endLine: z26.coerce.number().int().positive().nullable().optional(),
+var ReadInput2 = z27.object({
+  path: z27.string().min(1),
+  maxBytes: z27.coerce.number().int().positive().max(MAX_READ_BYTES).nullable().optional(),
+  startLine: z27.coerce.number().int().positive().nullable().optional(),
+  endLine: z27.coerce.number().int().positive().nullable().optional(),
   // Accepts booleans and their string forms (weak-typed models emit "true");
   // kept transform-free so the schema converts to JSON Schema for providers.
-  force: z26.union([z26.boolean(), z26.string().refine((value) => value === "true" || value === "false")]).nullable().optional()
+  force: z27.union([z27.boolean(), z27.string().refine((value) => value === "true" || value === "false")]).nullable().optional()
 });
-var WriteInput = z26.object({ path: z26.string().min(1), content: z26.string() });
-var EditInput = z26.object({ path: z26.string().min(1), oldText: z26.string().min(1), newText: z26.string() });
-var ApplyPatchInput = z26.object({ patch: z26.string().min(1) });
+var WriteInput = z27.object({ path: z27.string().min(1), content: z27.string() });
+var EditInput = z27.object({ path: z27.string().min(1), oldText: z27.string().min(1), newText: z27.string() });
+var ApplyPatchInput = z27.object({ patch: z27.string().min(1) });
 var FileObservationStore = class {
   #versions = /* @__PURE__ */ new Map();
   get(path) {
@@ -15951,22 +16281,22 @@ function createPathGuard(workspace) {
     lexical,
     existing: async (input) => {
       const candidate = lexical(input);
-      const physical = await realpath11(candidate);
-      if (!within2(await realpath11(root), physical)) throw new Error("Path escapes the workspace through a symlink");
+      const physical = await realpath12(candidate);
+      if (!within2(await realpath12(root), physical)) throw new Error("Path escapes the workspace through a symlink");
       return physical;
     },
     destination: async (input) => {
       const candidate = lexical(input);
-      const physicalRoot = await realpath11(root);
+      const physicalRoot = await realpath12(root);
       let ancestor = candidate;
       while (true) {
         try {
-          const physical = await realpath11(ancestor);
+          const physical = await realpath12(ancestor);
           if (!within2(physicalRoot, physical)) throw new Error("Path escapes the workspace through a symlink");
           break;
         } catch (error) {
           if (!isMissing2(error)) throw error;
-          const parent = dirname17(ancestor);
+          const parent = dirname18(ancestor);
           if (parent === ancestor) throw error;
           ancestor = parent;
         }
@@ -15977,7 +16307,7 @@ function createPathGuard(workspace) {
 }
 async function atomicWrite(path, content, signal, expectedVersion) {
   abortIfNeeded(signal);
-  await mkdir19(dirname17(path), { recursive: true });
+  await mkdir19(dirname18(path), { recursive: true });
   const temporary = `${path}.${randomUUID13()}.tmp`;
   try {
     const handle = await open10(temporary, constants7.O_CREAT | constants7.O_EXCL | constants7.O_WRONLY, 384);
@@ -16337,10 +16667,10 @@ function matchesLines(source, start, expected) {
 // src/tools/search.ts
 import { spawn as spawn4 } from "child_process";
 import { open as open11, opendir, stat as stat9 } from "fs/promises";
-import { dirname as dirname18, isAbsolute as isAbsolute12, relative as relative17, resolve as resolve22, sep as sep16 } from "path";
+import { dirname as dirname19, isAbsolute as isAbsolute12, relative as relative17, resolve as resolve22, sep as sep16 } from "path";
 import { rgPath as bundledRgPath } from "@vscode/ripgrep";
 import createIgnore from "ignore";
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 var DEFAULT_RESULT_LIMIT = 1e3;
 var DEFAULT_MAX_FILE_BYTES = 1048576;
 var DEFAULT_MAX_SEARCH_BYTES = 16777216;
@@ -16414,18 +16744,18 @@ var FILE_TYPE_EXTENSIONS = {
   python: [".py", ".pyi"],
   typescript: [".ts", ".tsx", ".mts", ".cts"]
 };
-var GlobInput = z27.object({
-  pattern: z27.string().min(1),
-  path: z27.string().min(1).describe('Workspace-relative search directory. Use JSON null, not the string "null", for the workspace root.').nullable().optional(),
-  limit: z27.coerce.number().int().positive().max(1e5).nullable().optional()
+var GlobInput = z28.object({
+  pattern: z28.string().min(1),
+  path: z28.string().min(1).describe('Workspace-relative search directory. Use JSON null, not the string "null", for the workspace root.').nullable().optional(),
+  limit: z28.coerce.number().int().positive().max(1e5).nullable().optional()
 });
-var GrepInput = z27.object({
-  pattern: z27.string().min(1),
-  path: z27.string().min(1).describe('Workspace-relative search path. Use JSON null, not the string "null", for the workspace root.').nullable().optional(),
-  glob: z27.string().min(1).nullable().optional(),
-  fileType: z27.enum(FILE_TYPES).nullable().optional(),
-  context: z27.coerce.number().int().nonnegative().max(100).nullable().optional(),
-  limit: z27.coerce.number().int().positive().max(1e5).nullable().optional()
+var GrepInput = z28.object({
+  pattern: z28.string().min(1),
+  path: z28.string().min(1).describe('Workspace-relative search path. Use JSON null, not the string "null", for the workspace root.').nullable().optional(),
+  glob: z28.string().min(1).nullable().optional(),
+  fileType: z28.enum(FILE_TYPES).nullable().optional(),
+  context: z28.coerce.number().int().nonnegative().max(100).nullable().optional(),
+  limit: z28.coerce.number().int().positive().max(1e5).nullable().optional()
 });
 function createGlobTool(workspace, options = {}) {
   const root = resolve22(workspace);
@@ -16809,7 +17139,7 @@ async function resolveGrepPath(root, path = ".") {
   const candidate = scope(root, path);
   try {
     const info = await stat9(candidate);
-    if (info.isFile()) return dirname18(candidate);
+    if (info.isFile()) return dirname19(candidate);
   } catch {
   }
   return candidate;
@@ -17004,22 +17334,22 @@ import { lookup } from "dns/promises";
 import { isIP } from "net";
 import { request as httpRequest } from "http";
 import { request as httpsRequest } from "https";
-import { z as z28 } from "zod";
-var WebFetchInput = z28.object({
-  url: z28.string().url().max(8192),
-  timeoutMs: z28.coerce.number().int().positive().max(12e4).optional(),
-  maxBytes: z28.coerce.number().int().positive().max(10 * 1024 * 1024).optional()
+import { z as z29 } from "zod";
+var WebFetchInput = z29.object({
+  url: z29.string().url().max(8192),
+  timeoutMs: z29.coerce.number().int().positive().max(12e4).optional(),
+  maxBytes: z29.coerce.number().int().positive().max(10 * 1024 * 1024).optional()
 });
-var WebSearchInput = z28.object({
-  query: z28.string().trim().min(1).max(1e3),
-  maxResults: z28.coerce.number().int().min(1).max(20).optional()
+var WebSearchInput = z29.object({
+  query: z29.string().trim().min(1).max(1e3),
+  maxResults: z29.coerce.number().int().min(1).max(20).optional()
 });
 function createWebFetchTool() {
   return {
     name: "WebFetch",
     description: "Fetch a public HTTP(S) page with SSRF protection and return readable text",
     inputSchema: WebFetchInput,
-    outputSchema: z28.object({ url: z28.string(), status: z28.number(), contentType: z28.string(), content: z28.string(), truncated: z28.boolean() }),
+    outputSchema: z29.object({ url: z29.string(), status: z29.number(), contentType: z29.string(), content: z29.string(), truncated: z29.boolean() }),
     paths: () => [],
     summarize: (input) => input.url,
     presentCall: (input) => ({ kind: "web", title: `Fetching ${new URL(input.url).hostname}`, url: input.url }),
@@ -17045,7 +17375,7 @@ function createWebSearchTool(provider = createDefaultWebSearchProvider()) {
     name: "WebSearch",
     description: "Search the public web and return titles, URLs, and snippets",
     inputSchema: WebSearchInput,
-    outputSchema: z28.object({ query: z28.string(), results: z28.array(z28.object({ title: z28.string(), url: z28.string(), snippet: z28.string() })) }),
+    outputSchema: z29.object({ query: z29.string(), results: z29.array(z29.object({ title: z29.string(), url: z29.string(), snippet: z29.string() })) }),
     paths: () => [],
     summarize: (input) => input.query,
     presentCall: (input) => ({ kind: "web", title: `Searching: ${input.query}` }),
@@ -17311,9 +17641,9 @@ function charset(contentType) {
 import { spawn as spawn5 } from "child_process";
 import { existsSync as existsSync2 } from "fs";
 import { access as access2, constants as constants8, readFile as readFile19 } from "fs/promises";
-import { basename as basename6, dirname as dirname19, extname as extname2, isAbsolute as isAbsolute13, relative as relative18, resolve as resolve23, sep as sep17 } from "path";
+import { basename as basename6, dirname as dirname20, extname as extname2, isAbsolute as isAbsolute13, relative as relative18, resolve as resolve23, sep as sep17 } from "path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL3 } from "url";
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 var LSP_REQUEST_TIMEOUT_MS = 15e3;
 var LspConnection = class {
   #process;
@@ -17528,7 +17858,7 @@ var LspBuffer = class {
   }
 };
 var TYPESCRIPT_CLI = resolve23(
-  dirname19(fileURLToPath3(import.meta.resolve("typescript/package.json"))),
+  dirname20(fileURLToPath3(import.meta.resolve("typescript/package.json"))),
   "lib",
   "tsc.js"
 );
@@ -17647,18 +17977,18 @@ var RealLspManager = class {
     return connection;
   }
 };
-var LspFindRefsInput = z29.object({
-  file: z29.string().min(1),
-  line: z29.coerce.number().int().nonnegative(),
-  character: z29.coerce.number().int().nonnegative()
+var LspFindRefsInput = z30.object({
+  file: z30.string().min(1),
+  line: z30.coerce.number().int().nonnegative(),
+  character: z30.coerce.number().int().nonnegative()
 });
-var LspHoverInput = z29.object({
-  file: z29.string().min(1),
-  line: z29.coerce.number().int().nonnegative(),
-  character: z29.coerce.number().int().nonnegative()
+var LspHoverInput = z30.object({
+  file: z30.string().min(1),
+  line: z30.coerce.number().int().nonnegative(),
+  character: z30.coerce.number().int().nonnegative()
 });
-var LspDiagnosticsInput = z29.object({
-  file: z29.string().min(1)
+var LspDiagnosticsInput = z30.object({
+  file: z30.string().min(1)
 });
 function createLspTools(workspace, options = {}) {
   const root = resolve23(workspace);
@@ -17884,7 +18214,7 @@ async function gitMarker(workspace) {
 }
 
 // src/git/insights.ts
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 async function suggestCommitMessage(options, input, signal) {
   const prompt = [
     "Write a git commit message for the staged changes below.",
@@ -17923,17 +18253,17 @@ function cleanCommitMessage(raw) {
   }
   return kept.join("\n").trim().slice(0, 2e3);
 }
-var ReviewFindingSchema = z30.object({
-  severity: z30.enum(["critical", "warning", "nit"]),
-  file: z30.string(),
-  line: z30.string().describe('Line number or hunk header the finding refers to, e.g. "42" or "@@ -10,4 +10,6 @@"'),
-  issue: z30.string(),
-  suggestion: z30.string()
+var ReviewFindingSchema = z31.object({
+  severity: z31.enum(["critical", "warning", "nit"]),
+  file: z31.string(),
+  line: z31.string().describe('Line number or hunk header the finding refers to, e.g. "42" or "@@ -10,4 +10,6 @@"'),
+  issue: z31.string(),
+  suggestion: z31.string()
 }).strict();
-var ReviewReportSchema = z30.object({
-  summary: z30.string().describe("One-paragraph overall assessment of the change"),
-  verdict: z30.enum(["ship", "ship-with-fixes", "needs-work"]),
-  findings: z30.array(ReviewFindingSchema).max(20)
+var ReviewReportSchema = z31.object({
+  summary: z31.string().describe("One-paragraph overall assessment of the change"),
+  verdict: z31.enum(["ship", "ship-with-fixes", "needs-work"]),
+  findings: z31.array(ReviewFindingSchema).max(20)
 }).strict();
 async function reviewDiff(options, input, signal) {
   const prompt = [
@@ -17977,10 +18307,10 @@ function formatReviewReport(report) {
 }
 
 // src/git/tools.ts
-import { z as z31 } from "zod";
-var GitHistoryInput = z31.object({
-  path: z31.string().describe("File to inspect; omit for the whole repository history").optional(),
-  limit: z31.number().int().min(1).max(50).describe("Maximum number of commits to return (default 20)").optional()
+import { z as z32 } from "zod";
+var GitHistoryInput = z32.object({
+  path: z32.string().describe("File to inspect; omit for the whole repository history").optional(),
+  limit: z32.number().int().min(1).max(50).describe("Maximum number of commits to return (default 20)").optional()
 });
 function createGitHistoryTool(workspace) {
   return {
@@ -18009,18 +18339,18 @@ function createGitHistoryTool(workspace) {
 }
 
 // src/tools/ask-user-question.ts
-import { z as z32 } from "zod";
-var QuestionOptionSchema = z32.object({
-  label: z32.string().trim().min(1),
-  description: z32.string().trim().min(1)
+import { z as z33 } from "zod";
+var QuestionOptionSchema = z33.object({
+  label: z33.string().trim().min(1),
+  description: z33.string().trim().min(1)
 });
-var QuestionSchema = z32.object({
-  question: z32.string().trim().min(1),
-  header: z32.string().trim().min(1),
-  options: z32.array(QuestionOptionSchema).min(1).max(4)
+var QuestionSchema = z33.object({
+  question: z33.string().trim().min(1),
+  header: z33.string().trim().min(1),
+  options: z33.array(QuestionOptionSchema).min(1).max(4)
 });
-var AskUserQuestionInput = z32.object({
-  questions: z32.array(QuestionSchema).min(1).max(4)
+var AskUserQuestionInput = z33.object({
+  questions: z33.array(QuestionSchema).min(1).max(4)
 });
 function hookAnswersFromUpdatedInput(updatedInput, questions) {
   if (typeof updatedInput !== "object" || updatedInput === null) return void 0;
@@ -18104,20 +18434,20 @@ function createAskUserQuestionTool(handler) {
 }
 
 // src/tools/todo-write.ts
-import { z as z33 } from "zod";
-var TodoStatusSchema = z33.enum([
+import { z as z34 } from "zod";
+var TodoStatusSchema = z34.enum([
   "pending",
   "in_progress",
   "completed",
   "cancelled"
 ]);
-var TodoItemSchema = z33.object({
-  content: z33.string().trim().min(1),
+var TodoItemSchema = z34.object({
+  content: z34.string().trim().min(1),
   status: TodoStatusSchema,
-  activeForm: z33.string().trim().min(1)
+  activeForm: z34.string().trim().min(1)
 });
-var TodoWriteInput = z33.object({
-  todos: z33.array(TodoItemSchema).min(1).max(50)
+var TodoWriteInput = z34.object({
+  todos: z34.array(TodoItemSchema).min(1).max(50)
 });
 function createTodoWriteTool() {
   return {
@@ -18153,37 +18483,37 @@ function createTodoWriteTool() {
 // src/tools/managed.ts
 import { randomUUID as randomUUID14 } from "crypto";
 import { link, lstat as lstat11, mkdir as mkdir20, readFile as readFile20, readdir as readdir10, unlink as unlink2, writeFile as writeFile12 } from "fs/promises";
-import { dirname as dirname20, join as join24, resolve as resolve24 } from "path";
-import { z as z34 } from "zod";
+import { dirname as dirname21, join as join24, resolve as resolve24 } from "path";
+import { z as z35 } from "zod";
 var MANAGED_TOOL_VERSION = 1;
 var MAX_RECORD_BYTES = 256 * 1024;
 var TOOL_NAME = /^[A-Za-z][A-Za-z0-9_]{0,63}$/;
-var JsonSchemaObject = z34.record(z34.string(), z34.unknown()).superRefine((schema, context) => {
+var JsonSchemaObject = z35.record(z35.string(), z35.unknown()).superRefine((schema, context) => {
   if (schema.type !== "object") {
     context.addIssue({ code: "custom", message: "Tool input JSON Schema must have type object" });
   }
 });
-var RegisterManagedToolInputSchema = z34.object({
-  name: z34.string().regex(TOOL_NAME).describe("Unique callable tool name using letters, digits, and underscores"),
-  description: z34.string().min(1).max(4096).describe("Purpose and appropriate use of the generated tool"),
+var RegisterManagedToolInputSchema = z35.object({
+  name: z35.string().regex(TOOL_NAME).describe("Unique callable tool name using letters, digits, and underscores"),
+  description: z35.string().min(1).max(4096).describe("Purpose and appropriate use of the generated tool"),
   inputSchema: JsonSchemaObject.describe("Provider-facing JSON Schema with an object at the root"),
-  implementation: z34.string().min(1).max(64 * 1024).describe(
+  implementation: z35.string().min(1).max(64 * 1024).describe(
     "Async JavaScript function body, or complete function/arrow expression, receiving input, signal, and context; return the tool result"
   ),
-  scope: z34.enum(["project", "global"]).default("project").describe(
+  scope: z35.enum(["project", "global"]).default("project").describe(
     "Project persists in the current workspace; global persists for every workspace"
   ),
-  agents: z34.array(z34.enum(["main", "subagent"])).min(1).max(2).optional().describe(
+  agents: z35.array(z35.enum(["main", "subagent"])).min(1).max(2).optional().describe(
     "Agent roles allowed to call the generated tool; omit to allow both"
   )
 }).strict();
-var RemoveManagedToolInputSchema = z34.object({
-  name: z34.string().regex(TOOL_NAME).describe("Managed tool name to remove"),
-  scope: z34.enum(["project", "global"]).optional().describe("Required only when the same name exists in both scopes")
+var RemoveManagedToolInputSchema = z35.object({
+  name: z35.string().regex(TOOL_NAME).describe("Managed tool name to remove"),
+  scope: z35.enum(["project", "global"]).optional().describe("Required only when the same name exists in both scopes")
 }).strict();
 var ManagedToolRecordSchema = RegisterManagedToolInputSchema.extend({
-  version: z34.literal(MANAGED_TOOL_VERSION),
-  createdAt: z34.string().datetime()
+  version: z35.literal(MANAGED_TOOL_VERSION),
+  createdAt: z35.string().datetime()
 }).strict();
 var AsyncFunction = Object.getPrototypeOf(async function() {
 }).constructor;
@@ -18370,7 +18700,7 @@ function createManagedToolManagementTools(options) {
   const listTools = {
     name: "ListRegisteredTools",
     description: "List durable tools created through RegisterTool, including scope, path, and active precedence",
-    inputSchema: z34.object({}).strict(),
+    inputSchema: z35.object({}).strict(),
     agents: mainOnly,
     paths: () => [],
     execute: async (_input, signal) => {
@@ -18383,7 +18713,7 @@ function createManagedToolManagementTools(options) {
 function compileDefinition(record3, scope2, workspace) {
   let inputSchema;
   try {
-    inputSchema = z34.fromJSONSchema(record3.inputSchema);
+    inputSchema = z35.fromJSONSchema(record3.inputSchema);
   } catch (error) {
     throw new Error(`Invalid input schema for managed tool "${record3.name}": ${message(error)}`);
   }
@@ -18437,7 +18767,7 @@ ${sourceUrl}`
   }
 }
 async function writeExclusive(path, content) {
-  await mkdir20(dirname20(path), { recursive: true });
+  await mkdir20(dirname21(path), { recursive: true });
   const temporary = `${path}.${randomUUID14()}.tmp`;
   try {
     await writeFile12(temporary, content, { encoding: "utf8", flag: "wx", mode: 384 });
@@ -18483,7 +18813,7 @@ function isMissing4(error) {
 }
 
 // src/pals/protocol.ts
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 var PROTOCOL_VERSION = 1;
 var MAX_ALIAS_LENGTH = 64;
 var MAX_MESSAGE_BYTES = 32 * 1024;
@@ -18500,65 +18830,65 @@ var MIN_UUID_PREFIX_LENGTH = 8;
 function normalizePalIdentity(value) {
   return value.trim().toLocaleLowerCase("en-US");
 }
-var VersionSchema = z35.literal(PROTOCOL_VERSION);
-var UuidSchema = z35.uuid();
-var PrintableIdentitySchema = z35.string().trim().min(1).max(MAX_ALIAS_LENGTH).refine(
+var VersionSchema = z36.literal(PROTOCOL_VERSION);
+var UuidSchema = z36.uuid();
+var PrintableIdentitySchema = z36.string().trim().min(1).max(MAX_ALIAS_LENGTH).refine(
   (value) => !/[\p{Cc}\uD800-\uDFFF]/u.test(value),
   "Identity must contain only printable non-control Unicode"
 );
 var PalAliasSchema = PrintableIdentitySchema;
 var PalTargetSchema = PrintableIdentitySchema;
-var BoundedTextSchema = z35.string().refine(
+var BoundedTextSchema = z36.string().refine(
   (value) => Buffer.byteLength(value, "utf8") <= MAX_MESSAGE_BYTES,
   `Text must not exceed ${MAX_MESSAGE_BYTES} UTF-8 bytes`
 );
 var NonEmptyBoundedTextSchema = BoundedTextSchema.refine((value) => value.length > 0, "Text must not be empty");
-var CompletionDetailSchema = z35.string().trim().min(1).refine(
+var CompletionDetailSchema = z36.string().trim().min(1).refine(
   (value) => Buffer.byteLength(value, "utf8") <= MAX_COMPLETION_DETAIL_BYTES,
   `Completion evidence must not exceed ${MAX_COMPLETION_DETAIL_BYTES} UTF-8 bytes`
 );
-var PalPresenceSchema = z35.object({
+var PalPresenceSchema = z36.object({
   version: VersionSchema,
   id: UuidSchema,
   alias: PalAliasSchema,
-  projectPath: z35.string().min(1).refine(
+  projectPath: z36.string().min(1).refine(
     (value) => Buffer.byteLength(value, "utf8") <= MAX_PROJECT_PATH_BYTES,
     `Project path must not exceed ${MAX_PROJECT_PATH_BYTES} UTF-8 bytes`
   ),
-  connectedAt: z35.iso.datetime(),
-  lastSeenAt: z35.iso.datetime()
+  connectedAt: z36.iso.datetime(),
+  lastSeenAt: z36.iso.datetime()
 }).strict();
-var PalPresenceListSchema = z35.array(PalPresenceSchema).max(MAX_ACTIVE_PALS);
-var PalTaskMessageSchema = z35.object({
+var PalPresenceListSchema = z36.array(PalPresenceSchema).max(MAX_ACTIVE_PALS);
+var PalTaskMessageSchema = z36.object({
   version: VersionSchema,
-  type: z35.literal("task"),
+  type: z36.literal("task"),
   messageId: UuidSchema,
   target: PalTargetSchema,
   goal: NonEmptyBoundedTextSchema
 }).strict();
-var PalTaskEventSchema = z35.object({
+var PalTaskEventSchema = z36.object({
   version: VersionSchema,
-  type: z35.literal("task-event"),
+  type: z36.literal("task-event"),
   messageId: UuidSchema,
   taskId: UuidSchema,
   senderId: UuidSchema,
   recipientId: UuidSchema,
-  status: z35.enum(["accepted", "started", "progress", "completed", "failed", "cancelled"]),
+  status: z36.enum(["accepted", "started", "progress", "completed", "failed", "cancelled"]),
   detail: BoundedTextSchema.optional()
 }).strict();
-var DeliveryReceiptSchema = z35.object({
+var DeliveryReceiptSchema = z36.object({
   version: VersionSchema,
-  type: z35.literal("delivery-receipt"),
+  type: z36.literal("delivery-receipt"),
   messageId: UuidSchema,
-  status: z35.enum(["delivered", "duplicate", "rejected"]),
-  recipientIds: z35.array(UuidSchema).max(MAX_PARTICIPANTS),
+  status: z36.enum(["delivered", "duplicate", "rejected"]),
+  recipientIds: z36.array(UuidSchema).max(MAX_PARTICIPANTS),
   error: BoundedTextSchema.optional()
 }).strict();
-var CoWorkParticipantSchema = z35.object({
+var CoWorkParticipantSchema = z36.object({
   palId: UuidSchema,
-  required: z35.boolean()
+  required: z36.boolean()
 }).strict();
-var CoWorkProposalParticipantsSchema = z35.array(CoWorkParticipantSchema).min(2).max(MAX_PARTICIPANTS).superRefine((participants, context) => {
+var CoWorkProposalParticipantsSchema = z36.array(CoWorkParticipantSchema).min(2).max(MAX_PARTICIPANTS).superRefine((participants, context) => {
   const seen = /* @__PURE__ */ new Set();
   for (const [index, participant] of participants.entries()) {
     const id = participant.palId.toLowerCase();
@@ -18568,19 +18898,19 @@ var CoWorkProposalParticipantsSchema = z35.array(CoWorkParticipantSchema).min(2)
     seen.add(id);
   }
 });
-var CoWorkPlanTaskSchema = z35.object({
-  id: z35.string().min(1).max(128),
+var CoWorkPlanTaskSchema = z36.object({
+  id: z36.string().min(1).max(128),
   assigneeId: UuidSchema,
   description: NonEmptyBoundedTextSchema,
-  dependsOn: z35.array(z35.string().min(1).max(128)).max(MAX_PLAN_TASKS)
+  dependsOn: z36.array(z36.string().min(1).max(128)).max(MAX_PLAN_TASKS)
 }).strict();
-var CoWorkPlanSchema = z35.object({
+var CoWorkPlanSchema = z36.object({
   version: VersionSchema,
   coWorkId: UuidSchema,
-  epoch: z35.number().int().positive(),
+  epoch: z36.number().int().positive(),
   goal: NonEmptyBoundedTextSchema,
-  participants: z35.array(CoWorkParticipantSchema).min(1).max(MAX_PARTICIPANTS),
-  tasks: z35.array(CoWorkPlanTaskSchema).min(1).max(MAX_PLAN_TASKS)
+  participants: z36.array(CoWorkParticipantSchema).min(1).max(MAX_PARTICIPANTS),
+  tasks: z36.array(CoWorkPlanTaskSchema).min(1).max(MAX_PLAN_TASKS)
 }).strict().superRefine((plan, context) => {
   if (Buffer.byteLength(JSON.stringify(plan), "utf8") > MAX_PLAN_ENCODED_BYTES) {
     context.addIssue({ code: "custom", message: `Encoded plan must not exceed ${MAX_PLAN_ENCODED_BYTES} UTF-8 bytes` });
@@ -18630,7 +18960,7 @@ var CoWorkPlanSchema = z35.object({
     }
   }
 });
-var CoWorkPhaseSchema = z35.enum([
+var CoWorkPhaseSchema = z36.enum([
   "proposed",
   "planning",
   "prepared",
@@ -18640,30 +18970,30 @@ var CoWorkPhaseSchema = z35.enum([
   "failed",
   "cancelled"
 ]);
-var IntegrationResultSchema = z35.object({
-  passed: z35.boolean(),
+var IntegrationResultSchema = z36.object({
+  passed: z36.boolean(),
   evidence: CompletionDetailSchema
 }).strict();
-var CoWorkCompletionAssertionSchema = z35.object({
+var CoWorkCompletionAssertionSchema = z36.object({
   participantId: UuidSchema,
-  passed: z35.boolean(),
+  passed: z36.boolean(),
   detail: CompletionDetailSchema.optional()
 }).strict();
-var CoWorkSnapshotSchema = z35.object({
+var CoWorkSnapshotSchema = z36.object({
   version: VersionSchema,
   coWorkId: UuidSchema,
-  epoch: z35.number().int().positive(),
+  epoch: z36.number().int().positive(),
   phase: CoWorkPhaseSchema,
   goal: NonEmptyBoundedTextSchema,
-  participants: z35.array(CoWorkParticipantSchema).min(1).max(MAX_PARTICIPANTS),
+  participants: z36.array(CoWorkParticipantSchema).min(1).max(MAX_PARTICIPANTS),
   integrationOwnerId: UuidSchema,
-  acceptedParticipantIds: z35.array(UuidSchema).max(MAX_PARTICIPANTS),
-  planHash: z35.string().regex(/^[a-f0-9]{64}$/).nullable(),
+  acceptedParticipantIds: z36.array(UuidSchema).max(MAX_PARTICIPANTS),
+  planHash: z36.string().regex(/^[a-f0-9]{64}$/).nullable(),
   plan: CoWorkPlanSchema.nullable(),
-  planAcceptedParticipantIds: z35.array(UuidSchema).max(MAX_PARTICIPANTS),
-  readyParticipantIds: z35.array(UuidSchema).max(MAX_PARTICIPANTS),
-  completedParticipantIds: z35.array(UuidSchema).max(MAX_PARTICIPANTS),
-  completionAssertions: z35.array(CoWorkCompletionAssertionSchema).max(MAX_PARTICIPANTS),
+  planAcceptedParticipantIds: z36.array(UuidSchema).max(MAX_PARTICIPANTS),
+  readyParticipantIds: z36.array(UuidSchema).max(MAX_PARTICIPANTS),
+  completedParticipantIds: z36.array(UuidSchema).max(MAX_PARTICIPANTS),
+  completionAssertions: z36.array(CoWorkCompletionAssertionSchema).max(MAX_PARTICIPANTS),
   integration: IntegrationResultSchema.nullable()
 }).strict().superRefine((snapshot4, context) => {
   if (Buffer.byteLength(JSON.stringify(snapshot4), "utf8") > MAX_SNAPSHOT_ENCODED_BYTES) {
@@ -18694,87 +19024,87 @@ var RequestBase = {
   version: VersionSchema,
   requestId: UuidSchema
 };
-var RegisterRequestSchema = z35.object({
+var RegisterRequestSchema = z36.object({
   ...RequestBase,
-  type: z35.literal("register"),
-  authToken: z35.string().regex(/^[a-f0-9]{64}$/).optional(),
+  type: z36.literal("register"),
+  authToken: z36.string().regex(/^[a-f0-9]{64}$/).optional(),
   presence: PalPresenceSchema
 }).strict();
-var HeartbeatRequestSchema = z35.object({ ...RequestBase, type: z35.literal("heartbeat") }).strict();
-var ListRequestSchema = z35.object({ ...RequestBase, type: z35.literal("list") }).strict();
-var DisconnectRequestSchema = z35.object({ ...RequestBase, type: z35.literal("disconnect") }).strict();
-var ChatRequestSchema = z35.object({
+var HeartbeatRequestSchema = z36.object({ ...RequestBase, type: z36.literal("heartbeat") }).strict();
+var ListRequestSchema = z36.object({ ...RequestBase, type: z36.literal("list") }).strict();
+var DisconnectRequestSchema = z36.object({ ...RequestBase, type: z36.literal("disconnect") }).strict();
+var ChatRequestSchema = z36.object({
   ...RequestBase,
-  type: z35.literal("chat"),
+  type: z36.literal("chat"),
   messageId: UuidSchema,
   target: PalTargetSchema,
   message: NonEmptyBoundedTextSchema
 }).strict();
-var TaskRequestSchema = z35.object({
+var TaskRequestSchema = z36.object({
   ...RequestBase,
-  type: z35.literal("task"),
+  type: z36.literal("task"),
   messageId: UuidSchema,
   target: PalTargetSchema,
   goal: NonEmptyBoundedTextSchema
 }).strict();
-var CoWorkProposeRequestSchema = z35.object({
+var CoWorkProposeRequestSchema = z36.object({
   ...RequestBase,
-  type: z35.literal("cowork-propose"),
+  type: z36.literal("cowork-propose"),
   coWorkId: UuidSchema,
   goal: NonEmptyBoundedTextSchema,
   participants: CoWorkProposalParticipantsSchema
 }).strict();
-var CoWorkAcceptanceRequestSchema = z35.object({
+var CoWorkAcceptanceRequestSchema = z36.object({
   ...RequestBase,
-  type: z35.literal("cowork-accept"),
+  type: z36.literal("cowork-accept"),
   coWorkId: UuidSchema,
-  epoch: z35.number().int().positive()
+  epoch: z36.number().int().positive()
 }).strict();
-var CoWorkPlanRequestSchema = z35.object({ ...RequestBase, type: z35.literal("cowork-plan"), plan: CoWorkPlanSchema }).strict();
-var CoWorkPlanAcceptanceRequestSchema = z35.object({
+var CoWorkPlanRequestSchema = z36.object({ ...RequestBase, type: z36.literal("cowork-plan"), plan: CoWorkPlanSchema }).strict();
+var CoWorkPlanAcceptanceRequestSchema = z36.object({
   ...RequestBase,
-  type: z35.literal("cowork-plan-accept"),
+  type: z36.literal("cowork-plan-accept"),
   coWorkId: UuidSchema,
-  epoch: z35.number().int().positive(),
-  planHash: z35.string().regex(/^[a-f0-9]{64}$/)
+  epoch: z36.number().int().positive(),
+  planHash: z36.string().regex(/^[a-f0-9]{64}$/)
 }).strict();
-var CoWorkReadyRequestSchema = z35.object({
+var CoWorkReadyRequestSchema = z36.object({
   ...RequestBase,
-  type: z35.literal("cowork-ready"),
+  type: z36.literal("cowork-ready"),
   coWorkId: UuidSchema,
-  epoch: z35.number().int().positive(),
-  planHash: z35.string().regex(/^[a-f0-9]{64}$/)
+  epoch: z36.number().int().positive(),
+  planHash: z36.string().regex(/^[a-f0-9]{64}$/)
 }).strict();
-var CoWorkCompleteRequestSchema = z35.object({
+var CoWorkCompleteRequestSchema = z36.object({
   ...RequestBase,
-  type: z35.literal("cowork-complete"),
+  type: z36.literal("cowork-complete"),
   coWorkId: UuidSchema,
-  epoch: z35.number().int().positive(),
-  planHash: z35.string().regex(/^[a-f0-9]{64}$/),
-  passed: z35.boolean(),
+  epoch: z36.number().int().positive(),
+  planHash: z36.string().regex(/^[a-f0-9]{64}$/),
+  passed: z36.boolean(),
   detail: CompletionDetailSchema.optional()
 }).strict();
-var CoWorkIntegrationRequestSchema = z35.object({
+var CoWorkIntegrationRequestSchema = z36.object({
   ...RequestBase,
-  type: z35.literal("cowork-integration"),
+  type: z36.literal("cowork-integration"),
   coWorkId: UuidSchema,
-  epoch: z35.number().int().positive(),
-  planHash: z35.string().regex(/^[a-f0-9]{64}$/),
-  passed: z35.boolean(),
+  epoch: z36.number().int().positive(),
+  planHash: z36.string().regex(/^[a-f0-9]{64}$/),
+  passed: z36.boolean(),
   evidence: CompletionDetailSchema
 }).strict();
-var CoWorkGetRequestSchema = z35.object({
+var CoWorkGetRequestSchema = z36.object({
   ...RequestBase,
-  type: z35.literal("cowork-get"),
+  type: z36.literal("cowork-get"),
   coWorkId: UuidSchema
 }).strict();
-var CoWorkCancelRequestSchema = z35.object({
+var CoWorkCancelRequestSchema = z36.object({
   ...RequestBase,
-  type: z35.literal("cowork-cancel"),
+  type: z36.literal("cowork-cancel"),
   coWorkId: UuidSchema,
   reason: NonEmptyBoundedTextSchema
 }).strict();
-var BrokerRequestSchema = z35.discriminatedUnion("type", [
+var BrokerRequestSchema = z36.discriminatedUnion("type", [
   RegisterRequestSchema,
   HeartbeatRequestSchema,
   ListRequestSchema,
@@ -18791,49 +19121,49 @@ var BrokerRequestSchema = z35.discriminatedUnion("type", [
   CoWorkGetRequestSchema,
   CoWorkCancelRequestSchema
 ]);
-var BrokerOkResponseSchema = z35.object({
+var BrokerOkResponseSchema = z36.object({
   version: VersionSchema,
-  type: z35.literal("ok"),
+  type: z36.literal("ok"),
   requestId: UuidSchema,
-  data: z35.unknown()
+  data: z36.unknown()
 }).strict();
-var BrokerErrorResponseSchema = z35.object({
+var BrokerErrorResponseSchema = z36.object({
   version: VersionSchema,
-  type: z35.literal("error"),
+  type: z36.literal("error"),
   requestId: UuidSchema,
-  code: z35.enum(["invalid-request", "authentication-failed", "not-found", "ambiguous-target", "alias-conflict", "invalid-transition", "stale-epoch", "duplicate"]),
+  code: z36.enum(["invalid-request", "authentication-failed", "not-found", "ambiguous-target", "alias-conflict", "invalid-transition", "stale-epoch", "duplicate"]),
   message: BoundedTextSchema
 }).strict();
-var ChatEventSchema = z35.object({
+var ChatEventSchema = z36.object({
   version: VersionSchema,
-  type: z35.literal("chat-event"),
+  type: z36.literal("chat-event"),
   messageId: UuidSchema,
   senderId: UuidSchema,
   recipientId: UuidSchema,
   message: NonEmptyBoundedTextSchema
 }).strict();
-var CoWorkEventSchema = z35.object({
+var CoWorkEventSchema = z36.object({
   version: VersionSchema,
-  type: z35.literal("cowork-event"),
-  action: z35.enum(["PROPOSE", "PLAN", "START", "END", "FAIL", "CANCEL"]),
+  type: z36.literal("cowork-event"),
+  action: z36.enum(["PROPOSE", "PLAN", "START", "END", "FAIL", "CANCEL"]),
   actorId: UuidSchema,
   coWorkId: UuidSchema,
-  epoch: z35.number().int().positive(),
-  planHash: z35.string().regex(/^[a-f0-9]{64}$/).nullable(),
+  epoch: z36.number().int().positive(),
+  planHash: z36.string().regex(/^[a-f0-9]{64}$/).nullable(),
   snapshot: CoWorkSnapshotSchema
 }).strict();
-var BrokerEventSchema = z35.union([ChatEventSchema, PalTaskEventSchema, DeliveryReceiptSchema, CoWorkEventSchema]);
-var BrokerEventResponseSchema = z35.object({
+var BrokerEventSchema = z36.union([ChatEventSchema, PalTaskEventSchema, DeliveryReceiptSchema, CoWorkEventSchema]);
+var BrokerEventResponseSchema = z36.object({
   version: VersionSchema,
-  type: z35.literal("event"),
+  type: z36.literal("event"),
   event: BrokerEventSchema
 }).strict();
-var BrokerResponseSchema = z35.discriminatedUnion("type", [
+var BrokerResponseSchema = z36.discriminatedUnion("type", [
   BrokerOkResponseSchema,
   BrokerErrorResponseSchema,
   BrokerEventResponseSchema
 ]);
-var ControlFrameSchema = z35.string().refine(
+var ControlFrameSchema = z36.string().refine(
   (frame) => Buffer.byteLength(frame, "utf8") <= MAX_CONTROL_FRAME_BYTES,
   `Control frame must not exceed ${MAX_CONTROL_FRAME_BYTES} UTF-8 bytes`
 );
@@ -19317,7 +19647,8 @@ var FlavorSession = class {
       version: 1,
       type: "SessionStart",
       payload: { workspace: this.#services.workspace }
-    }).then(() => {
+    }).then(async (decision) => {
+      if (decision.additionalContext !== void 0) await this.#services.addContext?.(decision.additionalContext);
       this.#started = true;
     });
     return this.#startPromise;
@@ -19754,7 +20085,7 @@ var LANG_LABELS = /* @__PURE__ */ new Map([
 ]);
 
 // src/hallucination/confidence.ts
-import { z as z36 } from "zod";
+import { z as z37 } from "zod";
 
 // src/hallucination/types.ts
 var DEFAULT_SLIDING_WINDOW_SIZE = 20;
@@ -19767,12 +20098,12 @@ var DEFAULT_EVALUATION_TIMEOUT_MS = 2e3;
 var MAX_QUERY_CHARS = 5e3;
 var MAX_OUTPUT_CHARS = 1e4;
 var MAX_EVIDENCE_CHARS = 6e3;
-var ConfidenceSchema = z36.object({
-  taskAlignment: z36.number(),
-  evidenceGrounding: z36.number(),
-  processReliability: z36.number(),
-  reason: z36.string(),
-  unsupportedClaims: z36.array(z36.string()).max(3)
+var ConfidenceSchema = z37.object({
+  taskAlignment: z37.number(),
+  evidenceGrounding: z37.number(),
+  processReliability: z37.number(),
+  reason: z37.string(),
+  unsupportedClaims: z37.array(z37.string()).max(3)
 });
 var PROMPT = `You are a fast, evidence-aware task-completion verifier.
 
@@ -21865,15 +22196,15 @@ function workspacePath(root, input) {
 }
 
 // src/tools/terminal.ts
-import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 import { resolve as resolve29 } from "path";
-var Id = z37.string().regex(/^term-[a-f0-9-]+$/);
-var OpenInput = z37.object({ cwd: z37.string().optional(), shell: z37.string().optional(), args: z37.array(z37.string()).optional(), columns: z37.coerce.number().int().min(10).max(500).optional(), rows: z37.coerce.number().int().min(2).max(300).optional() });
-var OptionalBoolean = z37.union([z37.boolean(), z37.string().refine((value) => value === "true" || value === "false")]);
-var WriteInput2 = z37.object({ id: Id, data: z37.string().max(1e5), enter: OptionalBoolean.optional() });
-var ReadInput3 = z37.object({ id: Id, cursor: z37.coerce.number().int().min(0).optional() });
-var ResizeInput = z37.object({ id: Id, columns: z37.coerce.number().int().min(10).max(500), rows: z37.coerce.number().int().min(2).max(300) });
-var CloseInput = z37.object({ id: Id });
+var Id = z38.string().regex(/^term-[a-f0-9-]+$/);
+var OpenInput = z38.object({ cwd: z38.string().optional(), shell: z38.string().optional(), args: z38.array(z38.string()).optional(), columns: z38.coerce.number().int().min(10).max(500).optional(), rows: z38.coerce.number().int().min(2).max(300).optional() });
+var OptionalBoolean = z38.union([z38.boolean(), z38.string().refine((value) => value === "true" || value === "false")]);
+var WriteInput2 = z38.object({ id: Id, data: z38.string().max(1e5), enter: OptionalBoolean.optional() });
+var ReadInput3 = z38.object({ id: Id, cursor: z38.coerce.number().int().min(0).optional() });
+var ResizeInput = z38.object({ id: Id, columns: z38.coerce.number().int().min(10).max(500), rows: z38.coerce.number().int().min(2).max(300) });
+var CloseInput = z38.object({ id: Id });
 function createTerminalTools(terminals, workspace = process.cwd()) {
   const tools = [
     {
@@ -21949,7 +22280,7 @@ function createTerminalTools(terminals, workspace = process.cwd()) {
     {
       name: "TerminalList",
       description: "List persistent terminals owned by this agent",
-      inputSchema: z37.object({}),
+      inputSchema: z38.object({}),
       paths: () => [],
       execute: async (_input, _signal, context) => terminals.list(owner(context))
     }
@@ -21984,7 +22315,7 @@ import { spawn as spawn7 } from "child_process";
 import { createHash as createHash14, randomUUID as randomUUID19, timingSafeEqual } from "crypto";
 import { chmod as chmod2, lstat as lstat12, mkdir as mkdir23, unlink as unlink5 } from "fs/promises";
 import { createServer as createServer3, Socket } from "net";
-import { dirname as dirname22 } from "path";
+import { dirname as dirname23 } from "path";
 
 // src/pals/auth.ts
 import { randomBytes as randomBytes3, randomUUID as randomUUID17 } from "crypto";
@@ -22035,7 +22366,7 @@ function validatePalAuthToken(token) {
 // src/pals/lifecycle.ts
 import { randomUUID as randomUUID18 } from "crypto";
 import { mkdir as mkdir22, open as open13, readFile as readFile24, rename as rename11, stat as stat11, unlink as unlink4 } from "fs/promises";
-import { dirname as dirname21 } from "path";
+import { dirname as dirname22 } from "path";
 function defaultProcessAlive(pid) {
   if (!Number.isSafeInteger(pid) || pid <= 0) return true;
   try {
@@ -22056,7 +22387,7 @@ function parseMetadata(value) {
 }
 async function acquirePalFileLock(options) {
   if (await options.endpointLive()) return void 0;
-  await mkdir22(dirname21(options.path), { recursive: true, mode: 448 });
+  await mkdir22(dirname22(options.path), { recursive: true, mode: 448 });
   const pid = options.pid ?? process.pid;
   const now = options.now ?? Date.now;
   const nonce = randomUUID18();
@@ -22525,7 +22856,7 @@ var PalClient = class {
 };
 
 // src/pals/tools.ts
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 var DEFAULT_SHARE_BUDGET_BYTES = 128 * 1024;
 var CollaborationShareGuard = class {
   redact;
@@ -22546,25 +22877,25 @@ var CollaborationShareGuard = class {
     return redacted;
   }
 };
-var Uuid = z38.uuid();
-var Hash = z38.string().regex(/^[a-f0-9]{64}$/);
+var Uuid = z39.uuid();
+var Hash = z39.string().regex(/^[a-f0-9]{64}$/);
 var Target = PalTargetSchema;
-var BoundedText = z38.string().trim().min(1).refine(
+var BoundedText = z39.string().trim().min(1).refine(
   (value) => Buffer.byteLength(value, "utf8") <= MAX_MESSAGE_BYTES,
   `Text must not exceed ${MAX_MESSAGE_BYTES} UTF-8 bytes`
 );
-var CompletionEvidence = z38.string().trim().min(1).refine(
+var CompletionEvidence = z39.string().trim().min(1).refine(
   (value) => Buffer.byteLength(value, "utf8") <= MAX_COMPLETION_DETAIL_BYTES,
   `Completion evidence must not exceed ${MAX_COMPLETION_DETAIL_BYTES} UTF-8 bytes`
 );
-var EmptyInput = z38.object({}).strict();
-var StateInput = z38.object({ coWorkId: Uuid }).strict();
-var TokenInput = z38.object({ coWorkId: Uuid, epoch: z38.number().int().positive(), planHash: Hash }).strict();
-var SendInput = z38.object({ target: Target, message: BoundedText, coWorkId: Uuid.optional() }).strict();
-var PlanInput = z38.object({ plan: CoWorkPlanSchema }).strict();
-var ProgressInput = z38.object({ coWorkId: Uuid, target: Target, detail: BoundedText }).strict();
-var CompleteInput = TokenInput.extend({ passed: z38.boolean(), detail: CompletionEvidence }).strict();
-var IntegrateInput = TokenInput.extend({ passed: z38.boolean(), evidence: CompletionEvidence }).strict();
+var EmptyInput = z39.object({}).strict();
+var StateInput = z39.object({ coWorkId: Uuid }).strict();
+var TokenInput = z39.object({ coWorkId: Uuid, epoch: z39.number().int().positive(), planHash: Hash }).strict();
+var SendInput = z39.object({ target: Target, message: BoundedText, coWorkId: Uuid.optional() }).strict();
+var PlanInput = z39.object({ plan: CoWorkPlanSchema }).strict();
+var ProgressInput = z39.object({ coWorkId: Uuid, target: Target, detail: BoundedText }).strict();
+var CompleteInput = TokenInput.extend({ passed: z39.boolean(), detail: CompletionEvidence }).strict();
+var IntegrateInput = TokenInput.extend({ passed: z39.boolean(), evidence: CompletionEvidence }).strict();
 var sharedBytes = (...values) => values.reduce((total, value) => total + Buffer.byteLength(value, "utf8"), 0);
 function resolvePresence(presences, target) {
   const normalized = normalizePalIdentity(target);
@@ -23181,7 +23512,7 @@ async function createProductionRuntime(options) {
     });
     const skillsReady = skills.discover();
     skillsReady.catch(() => void 0);
-    tools.push(createSkillResourceTool(skills));
+    tools.push(createSkillTool(skills), createSkillResourceTool(skills));
     if (options.extraTools !== void 0) tools.push(...options.extraTools);
     const flavor = await optionalText2(join29(workspace, "FLAVOR.md"));
     const instructionBaseline = await workspaceInstructions.baseline();
@@ -23883,6 +24214,10 @@ async function createProductionRuntime(options) {
       subagentModel: () => childModel,
       llmServiceName: () => effectiveLlm?.serviceName,
       permissionMode: () => harness.permissionMode,
+      addContext: (content) => {
+        const duplicate = harness.main.context.snapshot().messages.some((entry2) => entry2.role === "system" && entry2.content === content);
+        if (!duplicate) harness.main.context.append({ role: "system", content });
+      },
       ...palServices === void 0 ? {} : { pals: palServices },
       run: (prompt, signal, runOptions) => {
         interruptedTaskPlanNeedsReassessment = false;
@@ -24496,7 +24831,7 @@ async function* runMain(harness, skills, prompt, signal, setupError, memory, get
     if (ideContext !== void 0) contexts.push(ideContext);
     const skill = await skills.match(prompt);
     if (skill !== void 0) contexts.push(`Matched skill: ${skill.name}
-${await skills.loadBody(skill)}`);
+${expandSkillArguments(await skills.loadBody(skill), prompt)}`);
     const additionalContext = contexts.length === 0 ? void 0 : contexts.join("\n\n");
     for await (const event of harness.main.loop.run({
       prompt,
@@ -24531,7 +24866,7 @@ async function* runExplicitSkill(harness, skills, skillName, prompt, signal, set
     }
     const userPrompt = prompt || `Apply the ${skillName} skill.`;
     const additionalContext = `Matched skill: ${skill.name}
-${await skills.loadBody(skill)}`;
+${expandSkillArguments(await skills.loadBody(skill), prompt)}`;
     yield* harness.main.loop.run({ prompt: userPrompt, signal, additionalContext });
   } catch (error) {
     yield { type: "error", error: { code: "unknown", message: message(error) } };
@@ -25087,7 +25422,7 @@ import { basename as basename9, join as join39, resolve as resolve33 } from "pat
 // src/d2c/workflow.ts
 import { createHash as createHash17 } from "crypto";
 import { join as join30 } from "path";
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 
 // src/d2c/workflow-shared.ts
 function reviewProgress(workflow) {
@@ -25110,91 +25445,91 @@ function buildD2cQualityRepairPrompt(task, issue) {
 }
 
 // src/d2c/workflow.ts
-var ReviewSchema2 = z39.object({
-  fingerprint: z39.string().min(1).max(256),
-  pageId: z39.string().min(1).max(128),
-  reportId: z39.string().min(1).max(128),
-  signature: z39.string().regex(/^[a-f0-9]{64}$/),
-  label: z39.string().min(1).max(1e3),
-  decision: z39.enum(["pending", "accepted", "needs-fix"]),
-  instruction: z39.string().max(1e4).optional(),
-  moduleId: z39.string().min(1).max(128).optional(),
-  moduleSourceFiles: z39.array(z39.string().min(1).max(2048)).max(64).optional(),
-  updatedAt: z39.iso.datetime()
+var ReviewSchema2 = z40.object({
+  fingerprint: z40.string().min(1).max(256),
+  pageId: z40.string().min(1).max(128),
+  reportId: z40.string().min(1).max(128),
+  signature: z40.string().regex(/^[a-f0-9]{64}$/),
+  label: z40.string().min(1).max(1e3),
+  decision: z40.enum(["pending", "accepted", "needs-fix"]),
+  instruction: z40.string().max(1e4).optional(),
+  moduleId: z40.string().min(1).max(128).optional(),
+  moduleSourceFiles: z40.array(z40.string().min(1).max(2048)).max(64).optional(),
+  updatedAt: z40.iso.datetime()
 }).strict();
-var InteractionRunSchema = z39.object({
-  schema: z39.literal(1),
-  runAt: z39.iso.datetime(),
-  baseUrl: z39.string().url().max(2048),
-  passed: z39.boolean(),
-  total: z39.number().int().nonnegative().max(5e4),
-  failures: z39.number().int().nonnegative().max(5e4),
-  apiRequestCount: z39.number().int().nonnegative().max(1e7),
-  scenarios: z39.array(z39.object({
-    id: z39.string().min(1).max(128),
-    pageUrl: z39.string().url().max(2048),
-    passed: z39.boolean(),
-    durationMs: z39.number().int().nonnegative().max(864e5),
-    apiRequestCount: z39.number().int().nonnegative().max(1e7),
-    failure: z39.string().max(2e4).optional(),
-    requests: z39.array(z39.object({ method: z39.string().min(1).max(16), path: z39.string().min(1).max(2048), status: z39.number().int().min(0).max(599) }).strict()).max(1e4).optional()
+var InteractionRunSchema = z40.object({
+  schema: z40.literal(1),
+  runAt: z40.iso.datetime(),
+  baseUrl: z40.string().url().max(2048),
+  passed: z40.boolean(),
+  total: z40.number().int().nonnegative().max(5e4),
+  failures: z40.number().int().nonnegative().max(5e4),
+  apiRequestCount: z40.number().int().nonnegative().max(1e7),
+  scenarios: z40.array(z40.object({
+    id: z40.string().min(1).max(128),
+    pageUrl: z40.string().url().max(2048),
+    passed: z40.boolean(),
+    durationMs: z40.number().int().nonnegative().max(864e5),
+    apiRequestCount: z40.number().int().nonnegative().max(1e7),
+    failure: z40.string().max(2e4).optional(),
+    requests: z40.array(z40.object({ method: z40.string().min(1).max(16), path: z40.string().min(1).max(2048), status: z40.number().int().min(0).max(599) }).strict()).max(1e4).optional()
   }).strict()).max(5e4),
-  evidenceMode: z39.enum(["contract", "autonomous", "contract-fallback"]).optional()
+  evidenceMode: z40.enum(["contract", "autonomous", "contract-fallback"]).optional()
 }).strict();
-var QualityJudgmentSchema = z39.object({
-  schema: z39.literal(1),
-  runAt: z39.iso.datetime(),
-  model: z39.string().min(1).max(256),
-  visualScore: z39.number().min(0).max(100),
-  interactionScore: z39.number().min(0).max(100),
-  rawVisualScore: z39.number().min(0).max(100).optional(),
-  rawInteractionScore: z39.number().min(0).max(100).optional(),
-  staticVisualScore: z39.number().min(0).max(100),
-  deterministicInteractionPassed: z39.boolean(),
-  overallScore: z39.number().min(0).max(100),
-  threshold: z39.number().min(0).max(100),
-  verdict: z39.enum(["pass", "fail"]),
-  confidence: z39.enum(["high", "medium", "low"]),
-  summary: z39.string().min(1).max(4e3),
-  strengths: z39.array(z39.string().min(1).max(1e3)).max(20),
-  evidenceMode: z39.enum(["contract", "autonomous", "contract-fallback"]).optional(),
-  issues: z39.array(z39.object({
-    category: z39.enum(["visual", "interaction", "accessibility", "reliability"]),
-    severity: z39.enum(["minor", "major", "critical"]),
-    description: z39.string().min(1).max(2e3),
-    evidence: z39.string().min(1).max(2e3).optional(),
-    recommendation: z39.string().min(1).max(2e3),
-    selector: z39.string().min(1).max(2048).optional(),
-    scoreImpact: z39.number().min(0).max(30).optional(),
-    id: z39.string().regex(/^quality-[a-f0-9]{20}$/).optional(),
-    decision: z39.enum(["pending", "skipped", "fixing"]).optional(),
-    updatedAt: z39.iso.datetime().optional()
+var QualityJudgmentSchema = z40.object({
+  schema: z40.literal(1),
+  runAt: z40.iso.datetime(),
+  model: z40.string().min(1).max(256),
+  visualScore: z40.number().min(0).max(100),
+  interactionScore: z40.number().min(0).max(100),
+  rawVisualScore: z40.number().min(0).max(100).optional(),
+  rawInteractionScore: z40.number().min(0).max(100).optional(),
+  staticVisualScore: z40.number().min(0).max(100),
+  deterministicInteractionPassed: z40.boolean(),
+  overallScore: z40.number().min(0).max(100),
+  threshold: z40.number().min(0).max(100),
+  verdict: z40.enum(["pass", "fail"]),
+  confidence: z40.enum(["high", "medium", "low"]),
+  summary: z40.string().min(1).max(4e3),
+  strengths: z40.array(z40.string().min(1).max(1e3)).max(20),
+  evidenceMode: z40.enum(["contract", "autonomous", "contract-fallback"]).optional(),
+  issues: z40.array(z40.object({
+    category: z40.enum(["visual", "interaction", "accessibility", "reliability"]),
+    severity: z40.enum(["minor", "major", "critical"]),
+    description: z40.string().min(1).max(2e3),
+    evidence: z40.string().min(1).max(2e3).optional(),
+    recommendation: z40.string().min(1).max(2e3),
+    selector: z40.string().min(1).max(2048).optional(),
+    scoreImpact: z40.number().min(0).max(30).optional(),
+    id: z40.string().regex(/^quality-[a-f0-9]{20}$/).optional(),
+    decision: z40.enum(["pending", "skipped", "fixing"]).optional(),
+    updatedAt: z40.iso.datetime().optional()
   }).strict()).max(100)
 }).strict();
-var WorkflowSchema = z39.object({
-  schema: z39.literal(1),
-  task: z39.string().regex(D2C_TASK_PATTERN),
-  revision: z39.number().int().nonnegative(),
-  stage: z39.enum(["visual-review", "api-mapping", "integrating", "interaction-review", "quality-judge", "completed"]),
-  framework: z39.enum(["vue", "react"]),
-  activeReportId: z39.string().min(1).max(128),
-  activeBatchId: z39.string().min(1).max(128).optional(),
-  implementationDir: z39.string().min(1).max(32768),
-  reviews: z39.array(ReviewSchema2).max(1e4),
-  openapi: z39.object({
-    sourceName: z39.string().min(1).max(255),
-    importedAt: z39.iso.datetime(),
-    hash: z39.string().regex(/^[a-f0-9]{64}$/),
-    version: z39.string().min(1).max(32),
-    title: z39.string().min(1).max(500),
-    baseUrl: z39.string().max(4096).optional()
+var WorkflowSchema = z40.object({
+  schema: z40.literal(1),
+  task: z40.string().regex(D2C_TASK_PATTERN),
+  revision: z40.number().int().nonnegative(),
+  stage: z40.enum(["visual-review", "api-mapping", "integrating", "interaction-review", "quality-judge", "completed"]),
+  framework: z40.enum(["vue", "react"]),
+  activeReportId: z40.string().min(1).max(128),
+  activeBatchId: z40.string().min(1).max(128).optional(),
+  implementationDir: z40.string().min(1).max(32768),
+  reviews: z40.array(ReviewSchema2).max(1e4),
+  openapi: z40.object({
+    sourceName: z40.string().min(1).max(255),
+    importedAt: z40.iso.datetime(),
+    hash: z40.string().regex(/^[a-f0-9]{64}$/),
+    version: z40.string().min(1).max(32),
+    title: z40.string().min(1).max(500),
+    baseUrl: z40.string().max(4096).optional()
   }).strict().optional(),
-  mappings: z39.array(z39.unknown()).max(5e3).optional(),
-  integrationFiles: z39.array(z39.string().min(1).max(2048)).max(1e3).optional(),
-  interaction: z39.object({ manualDecision: z39.enum(["pending", "accepted"]), automated: InteractionRunSchema.optional(), updatedAt: z39.iso.datetime() }).strict().optional(),
+  mappings: z40.array(z40.unknown()).max(5e3).optional(),
+  integrationFiles: z40.array(z40.string().min(1).max(2048)).max(1e3).optional(),
+  interaction: z40.object({ manualDecision: z40.enum(["pending", "accepted"]), automated: InteractionRunSchema.optional(), updatedAt: z40.iso.datetime() }).strict().optional(),
   quality: QualityJudgmentSchema.optional(),
-  qualityWaivers: z39.array(z39.object({ issueId: z39.string().regex(/^quality-[a-f0-9]{20}$/), updatedAt: z39.iso.datetime() }).strict()).max(100).optional(),
-  updatedAt: z39.iso.datetime()
+  qualityWaivers: z40.array(z40.object({ issueId: z40.string().regex(/^quality-[a-f0-9]{20}$/), updatedAt: z40.iso.datetime() }).strict()).max(100).optional(),
+  updatedAt: z40.iso.datetime()
 }).strict();
 function pageId(report) {
   return report.page?.id ?? "index";
@@ -25611,16 +25946,16 @@ function confirmApiMapping(mapping, operationKey, operations) {
 // src/d2c/modules.ts
 import { readFile as readFile26 } from "fs/promises";
 import { isAbsolute as isAbsolute15, join as join31, normalize as normalize2, posix, sep as sep23, win32 as win322 } from "path";
-import { z as z40 } from "zod";
-var ModuleSchema = z40.object({
-  id: z40.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/),
-  label: z40.string().trim().min(1).max(200),
-  sourceFiles: z40.array(z40.string().trim().min(1).max(2048)).min(1).max(64),
-  keywords: z40.array(z40.string().trim().min(1).max(100)).max(100).optional(),
-  dataNeeds: z40.array(z40.string().trim().min(1).max(100)).max(100).optional(),
-  actions: z40.array(z40.string().trim().min(1).max(100)).max(100).optional()
+import { z as z41 } from "zod";
+var ModuleSchema = z41.object({
+  id: z41.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/),
+  label: z41.string().trim().min(1).max(200),
+  sourceFiles: z41.array(z41.string().trim().min(1).max(2048)).min(1).max(64),
+  keywords: z41.array(z41.string().trim().min(1).max(100)).max(100).optional(),
+  dataNeeds: z41.array(z41.string().trim().min(1).max(100)).max(100).optional(),
+  actions: z41.array(z41.string().trim().min(1).max(100)).max(100).optional()
 }).strict();
-var ManifestSchema3 = z40.object({ schema: z40.literal(1), modules: z40.array(ModuleSchema).min(1).max(500) }).passthrough();
+var ManifestSchema3 = z41.object({ schema: z41.literal(1), modules: z41.array(ModuleSchema).min(1).max(500) }).passthrough();
 function safeSource(path) {
   if (isAbsolute15(path) || posix.isAbsolute(path) || win322.isAbsolute(path) || path.includes("\0")) return false;
   const value = normalize2(path);
@@ -26062,7 +26397,7 @@ ${managed.output().slice(-4e3)}`);
 import { createHash as createHash19, randomUUID as randomUUID23 } from "crypto";
 import { copyFile as copyFile2, mkdir as mkdir25, readFile as readFile30, rename as rename13, stat as stat12, unlink as unlink6, writeFile as writeFile15 } from "fs/promises";
 import { join as join34 } from "path";
-import { z as z41 } from "zod";
+import { z as z42 } from "zod";
 
 // src/e2e/prd-governance.ts
 import { createHash as createHash18, randomUUID as randomUUID22 } from "crypto";
@@ -26181,38 +26516,38 @@ var RelativePrototypePath = "product/prototype/index.html";
 var RelativeInteractionPath = "product/prototype/interaction-manifest.json";
 var defaultPlanFileOperations = { rename: rename13, copyFile: copyFile2, unlink: unlink6 };
 var planWriteQueues = /* @__PURE__ */ new Map();
-var PlanSchema2 = z41.object({
-  schema: z41.literal(1),
-  task: z41.string().regex(D2C_TASK_PATTERN),
-  revision: z41.number().int().nonnegative(),
-  phase: z41.enum(["prd-generating", "prd-review", "design-generating", "design-review", "ready-for-d2c"]),
-  framework: z41.enum(["vue", "react"]),
-  technology: z41.object({
-    frontend: z41.string().trim().min(1).max(64),
-    backend: z41.string().trim().min(1).max(64),
-    frontendSource: z41.enum(["default", "requirement"]),
-    backendSource: z41.enum(["default", "requirement"])
+var PlanSchema2 = z42.object({
+  schema: z42.literal(1),
+  task: z42.string().regex(D2C_TASK_PATTERN),
+  revision: z42.number().int().nonnegative(),
+  phase: z42.enum(["prd-generating", "prd-review", "design-generating", "design-review", "ready-for-d2c"]),
+  framework: z42.enum(["vue", "react"]),
+  technology: z42.object({
+    frontend: z42.string().trim().min(1).max(64),
+    backend: z42.string().trim().min(1).max(64),
+    frontendSource: z42.enum(["default", "requirement"]),
+    backendSource: z42.enum(["default", "requirement"])
   }).strict().optional(),
-  requirement: z41.string().trim().min(2).max(5e4),
-  prd: z41.object({ path: z41.literal(RelativePrdPath), updatedAt: z41.iso.datetime(), contentHash: z41.string().regex(/^[a-f0-9]{64}$/).optional() }).strict().optional(),
-  approvedPrd: z41.object({
-    hash: z41.string().regex(/^[a-f0-9]{64}$/),
-    approvedAt: z41.iso.datetime(),
-    criteria: z41.array(z41.object({ id: z41.string().regex(/^AC-\d{3,}$/), text: z41.string().trim().min(1).max(4e3) }).strict()).min(1).max(1e4)
+  requirement: z42.string().trim().min(2).max(5e4),
+  prd: z42.object({ path: z42.literal(RelativePrdPath), updatedAt: z42.iso.datetime(), contentHash: z42.string().regex(/^[a-f0-9]{64}$/).optional() }).strict().optional(),
+  approvedPrd: z42.object({
+    hash: z42.string().regex(/^[a-f0-9]{64}$/),
+    approvedAt: z42.iso.datetime(),
+    criteria: z42.array(z42.object({ id: z42.string().regex(/^AC-\d{3,}$/), text: z42.string().trim().min(1).max(4e3) }).strict()).min(1).max(1e4)
   }).strict().optional(),
-  prototype: z41.object({
-    entryHtml: z41.literal(RelativePrototypePath),
-    interactionManifest: z41.literal(RelativeInteractionPath),
-    updatedAt: z41.iso.datetime(),
-    contentHash: z41.string().regex(/^[a-f0-9]{64}$/).optional()
+  prototype: z42.object({
+    entryHtml: z42.literal(RelativePrototypePath),
+    interactionManifest: z42.literal(RelativeInteractionPath),
+    updatedAt: z42.iso.datetime(),
+    contentHash: z42.string().regex(/^[a-f0-9]{64}$/).optional()
   }).strict().optional(),
-  feedback: z41.object({
-    stage: z41.enum(["prd", "design"]),
-    message: z41.string().trim().min(1).max(1e4),
-    updatedAt: z41.iso.datetime()
+  feedback: z42.object({
+    stage: z42.enum(["prd", "design"]),
+    message: z42.string().trim().min(1).max(1e4),
+    updatedAt: z42.iso.datetime()
   }).strict().optional(),
-  createdAt: z41.iso.datetime(),
-  updatedAt: z41.iso.datetime()
+  createdAt: z42.iso.datetime(),
+  updatedAt: z42.iso.datetime()
 }).strict();
 function d2cProductDirectory(workspace, task) {
   if (!D2C_TASK_PATTERN.test(task)) throw new Error("Invalid D2C task name");
@@ -26373,10 +26708,10 @@ async function writeD2cProductPlan(workspace, plan, operations = defaultPlanFile
   return parsed;
 }
 async function createD2cProductPlan(workspace, input, now = () => /* @__PURE__ */ new Date()) {
-  const parsed = z41.object({
-    task: z41.string().regex(D2C_TASK_PATTERN),
-    framework: z41.enum(["vue", "react"]),
-    requirement: z41.string().trim().min(2).max(5e4)
+  const parsed = z42.object({
+    task: z42.string().regex(D2C_TASK_PATTERN),
+    framework: z42.enum(["vue", "react"]),
+    requirement: z42.string().trim().min(2).max(5e4)
   }).strict().parse(input);
   const timestamp2 = now().toISOString();
   if (await readD2cProductPlan(workspace, parsed.task) !== void 0) {
@@ -26608,31 +26943,31 @@ function createAcceptanceEvidence(coverage, run, now = /* @__PURE__ */ new Date(
 // src/e2e/delivery-run.ts
 import { createHash as createHash21 } from "crypto";
 import { join as join35 } from "path";
-import { z as z42 } from "zod";
+import { z as z43 } from "zod";
 var DELIVERY_NODE_IDS = ["requirement", "prd", "design", "d2c", "api", "acceptance", "delivery"];
-var ArtifactSchema = z42.object({
-  path: z42.string().min(1).max(32768),
-  hash: z42.string().regex(/^[a-f0-9]{64}$/),
-  bytes: z42.number().int().nonnegative(),
-  createdAt: z42.iso.datetime()
+var ArtifactSchema = z43.object({
+  path: z43.string().min(1).max(32768),
+  hash: z43.string().regex(/^[a-f0-9]{64}$/),
+  bytes: z43.number().int().nonnegative(),
+  createdAt: z43.iso.datetime()
 }).strict();
-var NodeSchema = z42.object({
-  id: z42.enum(DELIVERY_NODE_IDS),
-  status: z42.enum(["pending", "running", "waiting-approval", "succeeded", "failed", "stale"]),
-  attempt: z42.number().int().nonnegative(),
-  inputs: z42.array(ArtifactSchema).max(1e4),
-  outputs: z42.array(ArtifactSchema).max(1e4),
-  startedAt: z42.iso.datetime().optional(),
-  completedAt: z42.iso.datetime().optional(),
-  error: z42.string().max(2e4).optional()
+var NodeSchema = z43.object({
+  id: z43.enum(DELIVERY_NODE_IDS),
+  status: z43.enum(["pending", "running", "waiting-approval", "succeeded", "failed", "stale"]),
+  attempt: z43.number().int().nonnegative(),
+  inputs: z43.array(ArtifactSchema).max(1e4),
+  outputs: z43.array(ArtifactSchema).max(1e4),
+  startedAt: z43.iso.datetime().optional(),
+  completedAt: z43.iso.datetime().optional(),
+  error: z43.string().max(2e4).optional()
 }).strict();
-var DeliveryRunSchema = z42.object({
-  schema: z42.literal(1),
-  task: z42.string().regex(D2C_TASK_PATTERN),
-  revision: z42.number().int().nonnegative(),
-  nodes: z42.record(z42.enum(DELIVERY_NODE_IDS), NodeSchema),
-  createdAt: z42.iso.datetime(),
-  updatedAt: z42.iso.datetime()
+var DeliveryRunSchema = z43.object({
+  schema: z43.literal(1),
+  task: z43.string().regex(D2C_TASK_PATTERN),
+  revision: z43.number().int().nonnegative(),
+  nodes: z43.record(z43.enum(DELIVERY_NODE_IDS), NodeSchema),
+  createdAt: z43.iso.datetime(),
+  updatedAt: z43.iso.datetime()
 }).strict();
 var dependencies = {
   requirement: [],
@@ -26765,7 +27100,7 @@ async function updateDeliveryRun(workspace, task, expectedRevision, mutation) {
 }
 
 // src/skills/manager.ts
-import { lstat as lstat13, mkdir as mkdir26, readFile as readFile32, readdir as readdir12, realpath as realpath12, rm as rm14, writeFile as writeFile16 } from "fs/promises";
+import { lstat as lstat13, mkdir as mkdir26, readFile as readFile32, readdir as readdir12, realpath as realpath13, rm as rm14, writeFile as writeFile16 } from "fs/promises";
 import { homedir as homedir3 } from "os";
 import { isAbsolute as isAbsolute16, join as join36, relative as relative24, resolve as resolve31, sep as sep24 } from "path";
 import { stringify } from "yaml";
@@ -26862,7 +27197,7 @@ var SkillManager = class {
   }
   async #summary(metadata, disabled) {
     const expected = this.#projectSkillDirectory(metadata.name);
-    const editable = metadata.source === "project" && await realpath12(expected).then((physical) => physical === metadata.root).catch(() => false);
+    const editable = metadata.source === "project" && await realpath13(expected).then((physical) => physical === metadata.root).catch(() => false);
     return {
       ...metadata,
       enabled: !disabled.has(metadata.name),
@@ -26914,14 +27249,14 @@ async function discoverPluginSkillRoots(directory) {
   const roots = [];
   for (const entry2 of entries) {
     if (!entry2.isDirectory() || entry2.isSymbolicLink()) continue;
-    const pluginRoot = await realpath12(join36(directory, entry2.name));
+    const pluginRoot = await realpath13(join36(directory, entry2.name));
     try {
       const manifest = PluginManifestSchema.parse(JSON.parse(await readFile32(join36(pluginRoot, "flavor-plugin.json"), "utf8")));
       for (const contribution of manifest.contributes.skillRoots) {
         const candidate = resolve31(pluginRoot, contribution.path);
         const info = await lstat13(candidate);
         if (!info.isDirectory() || info.isSymbolicLink()) continue;
-        const physical = await realpath12(candidate);
+        const physical = await realpath13(candidate);
         const relation = relative24(pluginRoot, physical);
         if (relation === ".." || relation.startsWith(`..${sep24}`) || isAbsolute16(relation)) continue;
         roots.push(physical);
@@ -27166,7 +27501,7 @@ function protocolLabel(type) {
 
 // src/desktop/d2c-product-preview.ts
 import { createReadStream as createReadStream2 } from "fs";
-import { realpath as realpath13, stat as stat13 } from "fs/promises";
+import { realpath as realpath14, stat as stat13 } from "fs/promises";
 import { createServer as createServer5 } from "http";
 import { extname as extname3, isAbsolute as isAbsolute17, relative as relative25, resolve as resolve32, sep as sep25 } from "path";
 var MIME_TYPES = {
@@ -27190,7 +27525,7 @@ function isInside(root, candidate) {
   return delta === "" || !delta.startsWith(`..${sep25}`) && delta !== ".." && !isAbsolute17(delta);
 }
 async function startD2cProductPreview(rootDirectory) {
-  const root = await realpath13(resolve32(rootDirectory));
+  const root = await realpath14(resolve32(rootDirectory));
   const rootInfo = await stat13(root);
   if (!rootInfo.isDirectory()) throw new Error("D2C product prototype directory is unavailable");
   const server = createServer5(async (request, response2) => {
@@ -27204,7 +27539,7 @@ async function startD2cProductPreview(rootDirectory) {
       if (pathname.includes("\0")) return sendNotFound(response2);
       const unresolved = resolve32(root, `.${pathname}`);
       if (!isInside(root, unresolved)) return sendNotFound(response2);
-      const target = await realpath13(unresolved).catch(() => void 0);
+      const target = await realpath14(unresolved).catch(() => void 0);
       if (target === void 0 || !isInside(root, target)) return sendNotFound(response2);
       const info = await stat13(target);
       if (!info.isFile()) return sendNotFound(response2);
@@ -28541,14 +28876,14 @@ ${reason.stack ?? ""}`;
 
 // src/desktop/main.ts
 installCrashGuard();
-var moduleDirectory = dirname23(fileURLToPath4(import.meta.url));
+var moduleDirectory = dirname24(fileURLToPath4(import.meta.url));
 var developmentUrl = process.env.FLAVOR_DESKTOP_DEV_URL;
 var mainWindow;
 var appMenu;
 var quitting = false;
 function logStartup(step, detail) {
   try {
-    const logPath = join41(dirname23(process.execPath), "flavor-code-startup.log");
+    const logPath = join41(dirname24(process.execPath), "flavor-code-startup.log");
     const ts = (/* @__PURE__ */ new Date()).toISOString();
     appendFileSync(logPath, `[${ts}] ${step}${detail ? ` | ${detail}` : ""}
 `);