flavor-code 1.2.18 → 1.2.20

package/dist/{chunk-STZQ3Y3P.js → chunk-AXLUVJKC.js}

@@ -3449,7 +3449,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;
@@ -8057,7 +8058,7 @@ function createIncidentReporter(options) {
 import { spawn as spawn5 } from "child_process";
 import { writeFile as writeFile8 } from "fs/promises";
 import { join as join10 } from "path";
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 
 // src/evolve/loader.ts
 import { cp, mkdir as mkdir8, mkdtemp, readdir as readdir4, rm as rm2, stat as stat4, writeFile as writeFile6 } from "fs/promises";
@@ -8066,9 +8067,10 @@ import { join as join8, resolve as resolve9 } from "path";
 
 // src/plugins/host.ts
 import { lstatSync, realpathSync as realpathSync2 } from "fs";
-import { lstat as lstat5, open as open5, readdir as readdir3, realpath as realpath3, stat as stat3, writeFile as writeFile5 } from "fs/promises";
+import { lstat as lstat5, open as open5, readdir as readdir3, realpath as realpath4, stat as stat3, writeFile as writeFile5 } from "fs/promises";
 import { isAbsolute as isAbsolute5, relative as relative7, resolve as resolve8, sep as sep7 } from "path";
 import { pathToFileURL } from "url";
+import { z as z12 } from "zod";
 
 // src/plugins/types.ts
 import { z as z11 } from "zod";
@@ -8098,10 +8100,188 @@ var PluginManifestSchema = z11.object({
   }).strict()
 }).strict();
 
+// src/plugins/worker-host.ts
+import { realpath as realpath3 } from "fs/promises";
+import { dirname as dirname10 } from "path";
+import { Worker } 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 realpath3(options.entryPath);
+  const pluginRoot = await realpath3(options.pluginRoot ?? dirname10(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 Worker(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 pending = /* @__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 pending.values()) {
+        clearTimeout(request.timer);
+        request.reject(error);
+      }
+      pending.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 = pending.get(message2.id);
+        if (request === void 0) {
+          fail(new Error("Plugin sandbox sent a response for an unknown request"));
+          return;
+        }
+        pending.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);
+        pending.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 response = value;
+  return Number.isSafeInteger(response.id) && typeof response.ok === "boolean" && (response.ok ? typeof response.valueJson === "string" : typeof response.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_BYTES2 = 64 * 1024;
-var DEFAULT_ACTIVATION_TIMEOUT_MS = 1e4;
+var DEFAULT_ACTIVATION_TIMEOUT_MS2 = 1e4;
 var DEFAULT_UNLOAD_TIMEOUT_MS = 5e3;
 var silentLogger = { debug() {
 }, info() {
@@ -8118,7 +8298,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() {
@@ -8232,7 +8412,7 @@ var PluginHost = class {
     try {
       const rootInfo = await lstat5(inputRoot);
       if (!rootInfo.isDirectory() || rootInfo.isSymbolicLink()) throw new Error("Plugin root must be a static directory");
-      const root = await realpath3(inputRoot);
+      const root = await realpath4(inputRoot);
       const rawManifest = await readManifest(resolve8(root, MANIFEST));
       if (typeof rawManifest === "object" && rawManifest !== null && "name" in rawManifest && typeof rawManifest.name === "string") {
         diagnosticLabel = rawManifest.name;
@@ -8252,18 +8432,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(`${pathToFileURL(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: z12.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(`${pathToFileURL(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 };
@@ -8427,7 +8668,7 @@ async function readManifest(path) {
 async function snapshotEntry(root, entry2) {
   const lexicalStats = await lstat5(entry2, { bigint: true });
   if (!lexicalStats.isFile() && !lexicalStats.isSymbolicLink()) throw new Error("Plugin entry must be a file");
-  const physicalPath = await realpath3(entry2);
+  const physicalPath = await realpath4(entry2);
   assertContained(root, physicalPath, "Plugin entry symlink");
   const physicalStats = await stat3(physicalPath, { bigint: true });
   if (!physicalStats.isFile()) throw new Error("Plugin entry must resolve to a regular file");
@@ -8543,6 +8784,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) => {
@@ -8582,7 +8825,9 @@ async function verifyFixPlugin(workspace, name) {
     await cp(pluginRoot, join8(sandbox, name), { recursive: true });
     const host = new PluginHost({
       projectPluginDirs: [sandbox],
+      sandbox: true,
       config: {},
+      activationTimeoutMs: 5e3,
       registrations: {
         command: (commandName) => {
           collected.commands.push(commandName);
@@ -8596,12 +8841,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;
@@ -8660,7 +8904,7 @@ async function revertFixPlugin(workspace, name) {
 // src/evolve/store.ts
 import { createHash as createHash5 } from "crypto";
 import { appendFile, mkdir as mkdir9, readFile as readFile7, rm as rm3, writeFile as writeFile7 } from "fs/promises";
-import { dirname as dirname10, join as join9 } from "path";
+import { dirname as dirname11, join as join9 } from "path";
 function normalizeError(message2) {
   return String(message2 ?? "").replace(/\s+/g, " ").replace(/"[^"]*"/g, '"\u2026"').replace(/`[^`]*`/g, '"\u2026"').trim().slice(0, 160);
 }
@@ -8689,7 +8933,7 @@ async function readJsonLines(file) {
   }
 }
 async function writeJsonLines(file, records) {
-  await mkdir9(dirname10(file), { recursive: true, mode: 448 });
+  await mkdir9(dirname11(file), { recursive: true, mode: 448 });
   const body = records.map((record) => JSON.stringify(record)).join("\n");
   await writeFile7(file, body.length > 0 ? `${body}
 ` : "", { encoding: "utf8", mode: 384 });
@@ -8717,7 +8961,7 @@ async function readRules(file) {
   }
 }
 async function writeRules(file, rules) {
-  await mkdir9(dirname10(file), { recursive: true, mode: 448 });
+  await mkdir9(dirname11(file), { recursive: true, mode: 448 });
   await writeFile7(file, JSON.stringify(rules, null, 2), { encoding: "utf8", mode: 384 });
 }
 var EvolveStore = class {
@@ -9339,10 +9583,10 @@ ${result.stderr.slice(-4e3)}` : ""}`;
       return USAGE;
     },
     toolDefinition() {
-      const inputSchema = z12.object({
-        suggestionId: z12.string().min(1).describe("Signal id from the evolve suggestions"),
-        implementation: z12.string().min(1).describe("Concise description of the fix to implement (plugin plan, or the guardrail rule text when kind is prompt_rule)"),
-        kind: z12.enum(["plugin", "prompt_rule"]).optional().describe(
+      const inputSchema = z13.object({
+        suggestionId: z13.string().min(1).describe("Signal id from the evolve suggestions"),
+        implementation: z13.string().min(1).describe("Concise description of the fix to implement (plugin plan, or the guardrail rule text when kind is prompt_rule)"),
+        kind: z13.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"
         )
       });
@@ -9408,8 +9652,8 @@ function buildLoopCyclePrompt(input) {
 }
 
 // src/loop/types.ts
-import { z as z13 } from "zod";
-var LoopStatusSchema = z13.enum([
+import { z as z14 } from "zod";
+var LoopStatusSchema = z14.enum([
   "running",
   "succeeded",
   "failed",
@@ -9419,65 +9663,65 @@ var LoopStatusSchema = z13.enum([
   "no_progress",
   "needs_human"
 ]);
-var LoopApprovalSchema = z13.object({
-  dimension: z13.enum(["cycles", "tokens"]),
-  previousCheckpoint: z13.number().int().nonnegative(),
-  newCheckpoint: z13.number().int().positive(),
-  usage: z13.number().int().nonnegative(),
-  approvedAt: z13.string().datetime({ offset: true })
+var LoopApprovalSchema = z14.object({
+  dimension: z14.enum(["cycles", "tokens"]),
+  previousCheckpoint: z14.number().int().nonnegative(),
+  newCheckpoint: z14.number().int().positive(),
+  usage: z14.number().int().nonnegative(),
+  approvedAt: z14.string().datetime({ offset: true })
 }).strict();
-var LoopVerificationCommandSchema = z13.object({
-  command: z13.string().min(1),
-  args: z13.array(z13.string()),
-  exitCode: z13.number().int().nullable(),
-  stdout: z13.string(),
-  stderr: z13.string(),
-  truncated: z13.boolean()
+var LoopVerificationCommandSchema = z14.object({
+  command: z14.string().min(1),
+  args: z14.array(z14.string()),
+  exitCode: z14.number().int().nullable(),
+  stdout: z14.string(),
+  stderr: z14.string(),
+  truncated: z14.boolean()
 }).strict();
-var LoopVerificationEvidenceSchema = z13.object({
-  passed: z13.boolean(),
-  commands: z13.array(LoopVerificationCommandSchema),
-  summary: z13.string()
+var LoopVerificationEvidenceSchema = z14.object({
+  passed: z14.boolean(),
+  commands: z14.array(LoopVerificationCommandSchema),
+  summary: z14.string()
 }).strict();
-var LoopCycleEvidenceSchema = z13.object({
-  cycle: z13.number().int().positive(),
-  startedAt: z13.string().datetime({ offset: true }),
-  completedAt: z13.string().datetime({ offset: true }),
-  inputTokens: z13.number().int().nonnegative(),
-  outputTokens: z13.number().int().nonnegative(),
-  workspaceFingerprint: z13.string(),
+var LoopCycleEvidenceSchema = z14.object({
+  cycle: z14.number().int().positive(),
+  startedAt: z14.string().datetime({ offset: true }),
+  completedAt: z14.string().datetime({ offset: true }),
+  inputTokens: z14.number().int().nonnegative(),
+  outputTokens: z14.number().int().nonnegative(),
+  workspaceFingerprint: z14.string(),
   verification: LoopVerificationEvidenceSchema
 }).strict();
-var LoopStateSchema = z13.object({
-  version: z13.literal(1),
-  loopId: z13.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/),
-  goal: z13.string().trim().min(1),
-  workspace: z13.string().min(1),
-  createdAt: z13.string().datetime({ offset: true }),
-  updatedAt: z13.string().datetime({ offset: true }),
+var LoopStateSchema = z14.object({
+  version: z14.literal(1),
+  loopId: z14.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/),
+  goal: z14.string().trim().min(1),
+  workspace: z14.string().min(1),
+  createdAt: z14.string().datetime({ offset: true }),
+  updatedAt: z14.string().datetime({ offset: true }),
   status: LoopStatusSchema,
-  config: z13.object({
-    cycleStep: z13.number().int().positive(),
-    tokenStep: z13.number().int().positive(),
-    isolation: z13.literal("auto")
+  config: z14.object({
+    cycleStep: z14.number().int().positive(),
+    tokenStep: z14.number().int().positive(),
+    isolation: z14.literal("auto")
   }).strict(),
-  budget: z13.object({
-    cyclesUsed: z13.number().int().nonnegative(),
-    inputTokens: z13.number().int().nonnegative(),
-    outputTokens: z13.number().int().nonnegative(),
-    cycleCheckpoint: z13.number().int().positive(),
-    tokenCheckpoint: z13.number().int().positive(),
-    approvals: z13.array(LoopApprovalSchema)
+  budget: z14.object({
+    cyclesUsed: z14.number().int().nonnegative(),
+    inputTokens: z14.number().int().nonnegative(),
+    outputTokens: z14.number().int().nonnegative(),
+    cycleCheckpoint: z14.number().int().positive(),
+    tokenCheckpoint: z14.number().int().positive(),
+    approvals: z14.array(LoopApprovalSchema)
   }).strict(),
-  cycles: z13.array(LoopCycleEvidenceSchema),
-  terminalReason: z13.string().optional()
+  cycles: z14.array(LoopCycleEvidenceSchema),
+  terminalReason: z14.string().optional()
 }).strict();
-var LoopEventSchema = z13.object({
-  version: z13.literal(1),
-  type: z13.enum(["created", "cycle_started", "cycle_completed", "verification", "budget_approved", "terminal"]),
-  timestamp: z13.string().datetime({ offset: true }),
-  loopId: z13.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/),
-  payload: z13.record(z13.string(), z13.unknown())
+var LoopEventSchema = z14.object({
+  version: z14.literal(1),
+  type: z14.enum(["created", "cycle_started", "cycle_completed", "verification", "budget_approved", "terminal"]),
+  timestamp: z14.string().datetime({ offset: true }),
+  loopId: z14.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/),
+  payload: z14.record(z14.string(), z14.unknown())
 }).strict();
 
 // src/loop/budget.ts
@@ -9793,15 +10037,15 @@ import { writeFile as writeFile9, mkdir as mkdir10 } from "fs/promises";
 import { join as join12 } from "path";
 
 // src/goal/types.ts
-import { z as z14 } from "zod";
-var GoalPhaseSchema = z14.enum([
+import { z as z15 } from "zod";
+var GoalPhaseSchema = z15.enum([
   "idle",
   "planning",
   "executing",
   "verifying",
   "complete"
 ]);
-var GoalStatusSchema = z14.enum([
+var GoalStatusSchema = z15.enum([
   "active",
   "paused",
   "achieved",
@@ -9809,43 +10053,43 @@ var GoalStatusSchema = z14.enum([
   "blocked",
   "failed"
 ]);
-var AcceptanceCriterionSchema = z14.object({
-  id: z14.number().int().positive(),
-  description: z14.string().min(1),
-  type: z14.enum(["gating", "evidence"])
+var AcceptanceCriterionSchema = z15.object({
+  id: z15.number().int().positive(),
+  description: z15.string().min(1),
+  type: z15.enum(["gating", "evidence"])
 }).strict();
-var PlanSchema = z14.object({
-  kind: z14.enum(["code-change", "analysis", "research"]),
-  criteria: z14.array(AcceptanceCriterionSchema).min(1).max(32),
-  verificationPlan: z14.string().min(1),
-  nonGoals: z14.array(z14.string()).max(16),
-  assumedScope: z14.array(z14.string()).max(16),
-  approach: z14.string().optional(),
-  checklist: z14.array(z14.string()).max(32).optional()
+var PlanSchema = z15.object({
+  kind: z15.enum(["code-change", "analysis", "research"]),
+  criteria: z15.array(AcceptanceCriterionSchema).min(1).max(32),
+  verificationPlan: z15.string().min(1),
+  nonGoals: z15.array(z15.string()).max(16),
+  assumedScope: z15.array(z15.string()).max(16),
+  approach: z15.string().optional(),
+  checklist: z15.array(z15.string()).max(32).optional()
 }).strict();
-var GapSchema = z14.object({
-  criterion: z14.string().min(1),
-  description: z14.string().min(1),
-  blocking: z14.enum(["model_fixable", "contradiction", "unverifiable"])
+var GapSchema = z15.object({
+  criterion: z15.string().min(1),
+  description: z15.string().min(1),
+  blocking: z15.enum(["model_fixable", "contradiction", "unverifiable"])
 }).strict();
-var VerdictSchema = z14.object({
-  refuted: z14.boolean(),
-  gaps: z14.array(GapSchema)
+var VerdictSchema = z15.object({
+  refuted: z15.boolean(),
+  gaps: z15.array(GapSchema)
 }).strict();
-var GoalStateSchema = z14.object({
-  id: z14.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/),
-  objective: z14.string().min(1),
+var GoalStateSchema = z15.object({
+  id: z15.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/),
+  objective: z15.string().min(1),
   phase: GoalPhaseSchema,
   status: GoalStatusSchema,
   plan: PlanSchema.nullable(),
-  planPath: z14.string().nullable(),
-  verifyRounds: z14.number().int().min(0),
-  workerRounds: z14.number().int().min(0),
-  lastGaps: z14.array(GapSchema),
-  gapFingerprint: z14.string(),
-  stallStreak: z14.number().int().min(0),
-  createdAt: z14.string().datetime({ offset: true }),
-  updatedAt: z14.string().datetime({ offset: true })
+  planPath: z15.string().nullable(),
+  verifyRounds: z15.number().int().min(0),
+  workerRounds: z15.number().int().min(0),
+  lastGaps: z15.array(GapSchema),
+  gapFingerprint: z15.string(),
+  stallStreak: z15.number().int().min(0),
+  createdAt: z15.string().datetime({ offset: true }),
+  updatedAt: z15.string().datetime({ offset: true })
 }).strict();
 
 // src/goal/planner.ts
@@ -10406,7 +10650,7 @@ function formatPriorGaps(gaps) {
 import { constants } from "fs";
 import { randomUUID as randomUUID7 } from "crypto";
 import { lstat as lstat6, mkdir as mkdir11, open as open6, rename as rename4, rm as rm4 } from "fs/promises";
-import { dirname as dirname11, join as join13, relative as relative9, resolve as resolve10, sep as sep8 } from "path";
+import { dirname as dirname12, join as join13, relative as relative9, resolve as resolve10, sep as sep8 } from "path";
 var DEFAULT_MAX_BYTES = 1024 * 1024;
 var GoalStore = class {
   #workspace;
@@ -10419,7 +10663,7 @@ var GoalStore = class {
   }
   async save(input) {
     const state = GoalStateSchema.parse(input);
-    await assertNoSymlink(this.#workspace, dirname11(this.#root));
+    await assertNoSymlink(this.#workspace, dirname12(this.#root));
     await mkdir11(this.#root, { recursive: true, mode: 448 });
     await assertNoSymlink(this.#workspace, this.#root);
     const target = join13(this.#root, `${state.id}.json`);
@@ -10453,7 +10697,7 @@ async function assertNoSymlink(root, target) {
   const chain = [];
   while (cursor !== stop) {
     chain.push(cursor);
-    cursor = dirname11(cursor);
+    cursor = dirname12(cursor);
   }
   for (const path of chain.reverse()) {
     try {
@@ -10539,8 +10783,8 @@ async function ensureWorktreeDirectoryIgnored(root) {
 
 // src/loop/store.ts
 import { constants as constants2 } from "fs";
-import { lstat as lstat7, mkdir as mkdir13, open as open7, readFile as readFile10, realpath as realpath4, rename as rename5, rm as rm5, stat as stat5 } from "fs/promises";
-import { dirname as dirname12, join as join15, relative as relative10, resolve as resolve12, sep as sep9 } from "path";
+import { lstat as lstat7, mkdir as mkdir13, open as open7, readFile as readFile10, realpath as realpath5, rename as rename5, rm as rm5, stat as stat5 } from "fs/promises";
+import { dirname as dirname13, join as join15, 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;
@@ -10622,7 +10866,7 @@ var LoopStore = class {
   }
   async #prepare(loopId) {
     validateId(loopId);
-    await assertNoSymlink2(this.#workspace, dirname12(this.#root));
+    await assertNoSymlink2(this.#workspace, dirname13(this.#root));
     await mkdir13(this.#root, { recursive: true, mode: 448 });
     await assertNoSymlink2(this.#workspace, this.#root);
     const directory = join15(this.#root, loopId);
@@ -10655,7 +10899,7 @@ async function assertNoSymlink2(root, target) {
   const chain = [];
   while (cursor !== stop) {
     chain.push(cursor);
-    cursor = dirname12(cursor);
+    cursor = dirname13(cursor);
   }
   for (const path of chain.reverse()) {
     try {
@@ -10671,7 +10915,7 @@ function isWithin2(root, path) {
 }
 async function canonical(path) {
   try {
-    return await realpath4(resolve12(path));
+    return await realpath5(resolve12(path));
   } catch {
     return resolve12(path);
   }
@@ -10687,19 +10931,19 @@ import { join as join16 } from "path";
 // src/tools/shell.ts
 import { spawn as spawn6, spawnSync } from "child_process";
 import { isAbsolute as isAbsolute6, relative as relative11, resolve as resolve13, sep as sep10 } from "path";
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 
 // src/tools/jobs.ts
-import { z as z15 } from "zod";
-var JobId = z15.string().regex(/^job-[a-f0-9-]+$/);
-var ReadInput = z15.object({ id: JobId, cursor: z15.coerce.number().int().min(0).optional() });
-var IdInput = z15.object({ id: JobId });
+import { z as z16 } from "zod";
+var JobId = z16.string().regex(/^job-[a-f0-9-]+$/);
+var ReadInput = z16.object({ id: JobId, cursor: z16.coerce.number().int().min(0).optional() });
+var IdInput = z16.object({ id: JobId });
 function createJobTools(registry) {
   const tools = [
     {
       name: "JobList",
       description: "List background jobs owned by this agent",
-      inputSchema: z15.object({}),
+      inputSchema: z16.object({}),
       paths: () => [],
       execute: async (_input, _signal, context) => registry.list(owner(context)),
       presentResult: (output) => jobListPresentation(output)
@@ -10774,14 +11018,14 @@ var ELLIPSIS = "\u2026";
 var TERMINATION_GRACE_MS = 250;
 var TERMINATION_FAILURE_MS = 5e3;
 var STREAM_CLOSE_GRACE_MS = 500;
-var ShellInput = z16.object({
-  command: z16.string().min(1),
-  args: z16.array(z16.string()),
-  cwd: z16.string().min(1).nullable().optional(),
-  timeoutMs: z16.coerce.number().int().positive().max(864e5).nullable().optional(),
+var ShellInput = z17.object({
+  command: z17.string().min(1),
+  args: z17.array(z17.string()),
+  cwd: z17.string().min(1).nullable().optional(),
+  timeoutMs: z17.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: z16.union([z16.boolean(), z16.string().refine((value) => value === "true" || value === "false")]).optional()
+  background: z17.union([z17.boolean(), z17.string().refine((value) => value === "true" || value === "false")]).optional()
 });
 function normalizeShellCommand(input) {
   const { command, args } = input;
@@ -11950,7 +12194,7 @@ var ModelRegistry = class {
 
 // src/mcp/client.ts
 import { createHash as createHash7 } from "crypto";
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var McpManager = class {
   #workspace;
   #clientFactory;
@@ -12086,7 +12330,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 (!isRecord3(remote.inputSchema)) throw new Error(`MCP tool "${remote.name}" has no JSON object input schema`);
-  const inputSchema = z17.fromJSONSchema(
+  const inputSchema = z18.fromJSONSchema(
     remote.inputSchema
   );
   return {
@@ -12496,7 +12740,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 tokens = await store.load();
   const retained = Object.fromEntries(Object.entries(tokens).filter(([id]) => id === keepCredentialId));
@@ -12507,7 +12751,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 tokens = result?.value ?? {};
       baseline = { ...tokens };
@@ -12515,7 +12759,7 @@ function createFileTokenStore(filePath) {
       return tokens;
     },
     async save(tokens) {
-      const key = await loadOrCreateConfigKey(dirname13(filePath));
+      const key = await loadOrCreateConfigKey(dirname14(filePath));
       const removals = Object.keys(baseline).filter((providerId) => !(providerId in tokens));
       const upserts = Object.fromEntries(Object.entries(tokens).filter(
         ([providerId, token]) => !sameToken(baseline[providerId], token)
@@ -12633,6 +12877,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.");
@@ -12681,7 +12926,7 @@ function data(value) {
 
 // src/skills/registry.ts
 import { constants as constants3 } from "fs";
-import { lstat as lstat8, open as defaultOpen, readdir as readdir6, realpath as realpath5 } from "fs/promises";
+import { lstat as lstat8, open as defaultOpen, readdir as readdir6, realpath as realpath6 } from "fs/promises";
 import { isAbsolute as isAbsolute7, relative as relative12, resolve as resolve15, sep as sep11 } from "path";
 import { marked } from "marked";
 import { parseDocument } from "yaml";
@@ -12848,7 +13093,7 @@ var SkillRegistry = class {
       try {
         const rootInfo = await lstat8(root);
         if (rootInfo.isSymbolicLink() || !rootInfo.isDirectory()) throw new Error("Skill root must be a real directory");
-        physicalRoot = await realpath5(root);
+        physicalRoot = await realpath6(root);
         entries = await readdir6(root, { withFileTypes: true });
       } catch (error) {
         if (isMissing2(error)) continue;
@@ -12861,7 +13106,7 @@ var SkillRegistry = class {
         try {
           if (entry2.isSymbolicLink()) throw new Error("Symlinked skill directories are not allowed");
           if (!entry2.isDirectory()) continue;
-          const physicalSkillRoot = await realpath5(skillRoot);
+          const physicalSkillRoot = await realpath6(skillRoot);
           if (!isWithin3(physicalRoot, physicalSkillRoot)) throw new Error("Skill directory escapes its registry root");
           const skillFile = resolve15(skillRoot, "SKILL.md");
           const parsed = await readFrontmatterFile(
@@ -13003,7 +13248,7 @@ async function openVerifiedFile(path, root, label, opener, expected) {
   const initial = await lstat8(path, { bigint: true });
   if (initial.isSymbolicLink()) throw new Error(`${label} symlinks are not allowed`);
   assertRegular(initial, label);
-  const canonical3 = await realpath5(path);
+  const canonical3 = await realpath6(path);
   if (!isWithin3(root, canonical3)) throw new Error(`${label} escapes the skill root`);
   const noFollow = typeof constants3.O_NOFOLLOW === "number" ? constants3.O_NOFOLLOW : 0;
   const handle = await opener(canonical3, constants3.O_RDONLY | noFollow);
@@ -13112,11 +13357,97 @@ function score(metadata, query) {
 }
 
 // src/skills/tool.ts
-import { z as z18 } from "zod";
-var SkillResourceInput = z18.object({
-  skill: z18.string().min(1),
-  reference: z18.string().min(1)
+import { z as z19 } 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 = z19.object({
+  skill: z19.string().min(1),
+  arguments: z19.string().optional()
 }).strict();
+var SkillResourceInput = z19.object({
+  skill: z19.string().min(1),
+  reference: z19.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",
@@ -13142,97 +13473,97 @@ function createSkillResourceTool(registry) {
 
 // src/session/store.ts
 import { constants as constants4 } from "fs";
-import { lstat as lstat9, mkdir as mkdir14, open as open8, readFile as readFile14, readdir as readdir7, realpath as realpath6, rename as rename6, rm as rm6, stat as stat6 } from "fs/promises";
-import { basename as basename3, dirname as dirname14, join as join17, relative as relative13, resolve as resolve16, sep as sep12 } from "path";
+import { lstat as lstat9, mkdir as mkdir14, open as open8, readFile as readFile14, readdir as readdir7, realpath as realpath7, rename as rename6, rm as rm6, stat as stat6 } from "fs/promises";
+import { basename as basename3, dirname as dirname15, join as join17, relative as relative13, resolve as resolve16, sep as sep12 } from "path";
 import { randomUUID as randomUUID9 } from "crypto";
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var SESSION_VERSION = 3;
 var DEFAULT_MAX_SESSION_BYTES = 5 * 1024 * 1024;
-var SessionIdSchema = z19.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/, "Invalid session id");
-var IsoDateSchema = z19.string().datetime({ offset: true });
-var ToolCallSchema = z19.object({
-  id: z19.string().min(1).max(256),
-  name: z19.string().min(1).max(256),
-  input: z19.unknown()
+var SessionIdSchema = z20.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/, "Invalid session id");
+var IsoDateSchema = z20.string().datetime({ offset: true });
+var ToolCallSchema = z20.object({
+  id: z20.string().min(1).max(256),
+  name: z20.string().min(1).max(256),
+  input: z20.unknown()
 }).strict();
-var TextContentBlockSchema = z19.object({
-  type: z19.literal("text"),
-  text: z19.string().max(DEFAULT_MAX_SESSION_BYTES)
+var TextContentBlockSchema = z20.object({
+  type: z20.literal("text"),
+  text: z20.string().max(DEFAULT_MAX_SESSION_BYTES)
 }).strict();
-var ImageContentBlockSchema = z19.object({
-  type: z19.literal("image"),
-  source: z19.object({ type: z19.literal("file"), path: z19.string().min(1).max(32768) }).strict(),
-  mediaType: z19.enum(["image/png", "image/jpeg", "image/webp"]),
-  sha256: z19.string().regex(/^[a-f0-9]{64}$/),
-  bytes: z19.number().int().positive().max(20 * 1024 * 1024),
-  name: z19.string().min(1).max(255).optional()
+var ImageContentBlockSchema = z20.object({
+  type: z20.literal("image"),
+  source: z20.object({ type: z20.literal("file"), path: z20.string().min(1).max(32768) }).strict(),
+  mediaType: z20.enum(["image/png", "image/jpeg", "image/webp"]),
+  sha256: z20.string().regex(/^[a-f0-9]{64}$/),
+  bytes: z20.number().int().positive().max(20 * 1024 * 1024),
+  name: z20.string().min(1).max(255).optional()
 }).strict();
-var UserContentSchema = z19.union([
-  z19.string().max(DEFAULT_MAX_SESSION_BYTES),
-  z19.array(z19.discriminatedUnion("type", [TextContentBlockSchema, ImageContentBlockSchema])).min(1).max(100)
+var UserContentSchema = z20.union([
+  z20.string().max(DEFAULT_MAX_SESSION_BYTES),
+  z20.array(z20.discriminatedUnion("type", [TextContentBlockSchema, ImageContentBlockSchema])).min(1).max(100)
 ]);
 var MessageMetadataShape = {
-  toolCallId: z19.string().min(1).max(256).optional(),
-  toolCalls: z19.array(ToolCallSchema).max(1e3).optional()
+  toolCallId: z20.string().min(1).max(256).optional(),
+  toolCalls: z20.array(ToolCallSchema).max(1e3).optional()
 };
-var MessageSchema = z19.discriminatedUnion("role", [
-  z19.object({ role: z19.literal("user"), content: UserContentSchema, ...MessageMetadataShape }).strict(),
-  z19.object({ role: z19.literal("assistant"), content: z19.string().max(DEFAULT_MAX_SESSION_BYTES), ...MessageMetadataShape }).strict(),
-  z19.object({ role: z19.literal("tool"), content: z19.string().max(DEFAULT_MAX_SESSION_BYTES), ...MessageMetadataShape }).strict()
+var MessageSchema = z20.discriminatedUnion("role", [
+  z20.object({ role: z20.literal("user"), content: UserContentSchema, ...MessageMetadataShape }).strict(),
+  z20.object({ role: z20.literal("assistant"), content: z20.string().max(DEFAULT_MAX_SESSION_BYTES), ...MessageMetadataShape }).strict(),
+  z20.object({ role: z20.literal("tool"), content: z20.string().max(DEFAULT_MAX_SESSION_BYTES), ...MessageMetadataShape }).strict()
 ]);
-var LegacySummarySchema = z19.object({ role: z19.literal("system"), content: z19.string().max(DEFAULT_MAX_SESSION_BYTES) }).strict();
-var CompactBoundarySchema = z19.object({
-  summary: z19.string().min(1).max(DEFAULT_MAX_SESSION_BYTES),
+var LegacySummarySchema = z20.object({ role: z20.literal("system"), content: z20.string().max(DEFAULT_MAX_SESSION_BYTES) }).strict();
+var CompactBoundarySchema = z20.object({
+  summary: z20.string().min(1).max(DEFAULT_MAX_SESSION_BYTES),
   compactedAt: IsoDateSchema
 }).strict();
-var StateSchema = z19.enum(["pending", "running", "completed", "failed", "blocked", "cancelled"]);
-var MemoryLifecycleSchema = z19.object({
-  status: z19.enum(["active", "completed", "abandoned"]),
-  taskId: z19.string().regex(/^memory-[A-Za-z0-9._-]{1,120}$/).optional(),
-  messageStart: z19.number().int().min(0).max(5e4).optional(),
+var StateSchema = z20.enum(["pending", "running", "completed", "failed", "blocked", "cancelled"]);
+var MemoryLifecycleSchema = z20.object({
+  status: z20.enum(["active", "completed", "abandoned"]),
+  taskId: z20.string().regex(/^memory-[A-Za-z0-9._-]{1,120}$/).optional(),
+  messageStart: z20.number().int().min(0).max(5e4).optional(),
   finalizedAt: IsoDateSchema.optional(),
-  transcriptHash: z19.string().regex(/^[a-f0-9]{64}$/).optional()
+  transcriptHash: z20.string().regex(/^[a-f0-9]{64}$/).optional()
 }).strict();
-var SessionBaseSchema = z19.object({
+var SessionBaseSchema = z20.object({
   sessionId: SessionIdSchema,
   createdAt: IsoDateSchema,
   updatedAt: IsoDateSchema,
-  workspace: z19.object({ path: z19.string().min(1).max(32768) }).strict(),
-  tasks: z19.object({
+  workspace: z20.object({ path: z20.string().min(1).max(32768) }).strict(),
+  tasks: z20.object({
     plan: TaskPlanSchema.optional(),
     graph: TaskGraphSchema.optional(),
-    states: z19.record(z19.string(), StateSchema),
-    results: z19.record(z19.string(), SubagentResultSchema)
+    states: z20.record(z20.string(), StateSchema),
+    results: z20.record(z20.string(), SubagentResultSchema)
   }).strict(),
-  models: z19.object({ main: z19.string().min(1).max(1024), subagent: z19.string().min(1).max(1024) }).strict(),
+  models: z20.object({ main: z20.string().min(1).max(1024), subagent: z20.string().min(1).max(1024) }).strict(),
   permissionMode: PermissionModeSchema,
   memory: MemoryLifecycleSchema.optional()
 }).strict();
 var SessionDocumentV1Schema = SessionBaseSchema.extend({
-  version: z19.literal(1),
-  conversation: z19.object({
+  version: z20.literal(1),
+  conversation: z20.object({
     summary: LegacySummarySchema.optional(),
-    messages: z19.array(MessageSchema).max(5e4)
+    messages: z20.array(MessageSchema).max(5e4)
   }).strict()
 }).strict();
-var ConversationSchema = z19.object({
+var ConversationSchema = z20.object({
   compact: CompactBoundarySchema.optional(),
-  messages: z19.array(MessageSchema).max(5e4)
+  messages: z20.array(MessageSchema).max(5e4)
 }).strict();
 var SessionDocumentV2Schema = SessionBaseSchema.extend({
-  version: z19.literal(2),
+  version: z20.literal(2),
   conversation: ConversationSchema
 }).strict();
-var TranscriptStateSchema = z19.custom(isTranscriptState, "Invalid transcript state");
-var TimelineSchema = z19.object({
-  version: z19.literal(1),
+var TranscriptStateSchema = z20.custom(isTranscriptState, "Invalid transcript state");
+var TimelineSchema = z20.object({
+  version: z20.literal(1),
   state: TranscriptStateSchema
 }).strict();
 var SessionDocumentSchema = SessionBaseSchema.extend({
-  version: z19.literal(SESSION_VERSION),
-  conversation: z19.object({
+  version: z20.literal(SESSION_VERSION),
+  conversation: z20.object({
     compact: CompactBoundarySchema.optional(),
-    messages: z19.array(MessageSchema).max(5e4)
+    messages: z20.array(MessageSchema).max(5e4)
   }).strict(),
   timeline: TimelineSchema
 }).strict();
@@ -13408,14 +13739,14 @@ var SessionStore = class {
     }
   }
   async #prepareDirectory() {
-    await assertNoSymlink3(this.#workspace, dirname14(this.#sessions));
+    await assertNoSymlink3(this.#workspace, dirname15(this.#sessions));
     await mkdir14(this.#sessions, { recursive: true, mode: 448 });
     await this.#assertSafeExistingDirectory();
   }
   async #assertSafeExistingDirectory() {
     await assertNoSymlink3(this.#workspace, this.#sessions);
-    const canonicalRoot = await realpath6(this.#workspace);
-    const canonicalSessions = await realpath6(this.#sessions);
+    const canonicalRoot = await realpath7(this.#workspace);
+    const canonicalSessions = await realpath7(this.#sessions);
     if (!isWithin4(canonicalRoot, canonicalSessions)) throw new Error("Session directory escapes the workspace");
   }
   async #quarantine(path) {
@@ -13572,7 +13903,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 {
@@ -13588,7 +13919,7 @@ function isWithin4(root, path) {
 }
 async function canonical2(path) {
   try {
-    return await realpath6(resolve16(path));
+    return await realpath7(resolve16(path));
   } catch {
     return resolve16(path);
   }
@@ -13617,45 +13948,45 @@ function sanitize2(input, seen = /* @__PURE__ */ new WeakSet()) {
 // src/sleep/organizer.ts
 import { constants as constants5 } from "fs";
 import { randomUUID as randomUUID10 } from "crypto";
-import { lstat as lstat10, mkdir as mkdir15, open as open9, readdir as readdir8, realpath as realpath7, rename as rename7, rm as rm7 } from "fs/promises";
+import { lstat as lstat10, mkdir as mkdir15, open as open9, readdir as readdir8, realpath as realpath8, rename as rename7, rm as rm7 } from "fs/promises";
 import { isAbsolute as isAbsolute8, join as join18, relative as relative14, resolve as resolve17, sep as sep13 } from "path";
-import { z as z20 } from "zod";
-var DateKeySchema = z20.string().regex(/^\d{4}-\d{2}-\d{2}$/);
-var ReviewSchema = z20.object({
-  title: z20.string().min(1).max(120),
-  taskSummary: z20.array(z20.string().min(1)).min(1).max(20),
-  executionReflection: z20.array(z20.string().min(1)).min(1).max(20),
-  decisionsAndLearnings: z20.array(z20.string().min(1)).max(20),
-  openQuestionsAndRisks: z20.array(z20.string().min(1)).max(20),
-  tomorrowPlan: z20.array(z20.string().min(1)).min(1).max(20),
-  toolUsage: z20.object({
-    totalCalls: z20.number().int().min(0),
-    shell: z20.number().int().min(0),
-    fileRead: z20.number().int().min(0),
-    fileWrite: z20.number().int().min(0),
-    search: z20.number().int().min(0),
-    lsp: z20.number().int().min(0),
-    subagent: z20.number().int().min(0),
-    other: z20.number().int().min(0)
+import { z as z21 } from "zod";
+var DateKeySchema = z21.string().regex(/^\d{4}-\d{2}-\d{2}$/);
+var ReviewSchema = z21.object({
+  title: z21.string().min(1).max(120),
+  taskSummary: z21.array(z21.string().min(1)).min(1).max(20),
+  executionReflection: z21.array(z21.string().min(1)).min(1).max(20),
+  decisionsAndLearnings: z21.array(z21.string().min(1)).max(20),
+  openQuestionsAndRisks: z21.array(z21.string().min(1)).max(20),
+  tomorrowPlan: z21.array(z21.string().min(1)).min(1).max(20),
+  toolUsage: z21.object({
+    totalCalls: z21.number().int().min(0),
+    shell: z21.number().int().min(0),
+    fileRead: z21.number().int().min(0),
+    fileWrite: z21.number().int().min(0),
+    search: z21.number().int().min(0),
+    lsp: z21.number().int().min(0),
+    subagent: z21.number().int().min(0),
+    other: z21.number().int().min(0)
   }).strict(),
-  tokenEstimate: z20.object({
-    estimatedInput: z20.number().int().min(0),
-    estimatedOutput: z20.number().int().min(0),
-    notes: z20.string().max(200)
+  tokenEstimate: z21.object({
+    estimatedInput: z21.number().int().min(0),
+    estimatedOutput: z21.number().int().min(0),
+    notes: z21.string().max(200)
   }).strict(),
-  humanIntervention: z20.object({
-    approvalRequests: z20.number().int().min(0),
-    questionsAsked: z20.number().int().min(0),
-    summary: z20.string().max(300)
+  humanIntervention: z21.object({
+    approvalRequests: z21.number().int().min(0),
+    questionsAsked: z21.number().int().min(0),
+    summary: z21.string().max(300)
   }).strict(),
-  qualityIndicators: z20.object({
-    hallucinationAlerts: z20.array(z20.string().min(1)).max(10),
-    failuresAndRetries: z20.array(z20.string().min(1)).max(10),
-    codeChangeSummary: z20.string().max(500),
-    overallAssessment: z20.string().max(200)
+  qualityIndicators: z21.object({
+    hallucinationAlerts: z21.array(z21.string().min(1)).max(10),
+    failuresAndRetries: z21.array(z21.string().min(1)).max(10),
+    codeChangeSummary: z21.string().max(500),
+    overallAssessment: z21.string().max(200)
   }).strict(),
-  knowledgeDeposits: z20.object({
-    worthRemembering: z20.array(z20.string().min(1)).max(10)
+  knowledgeDeposits: z21.object({
+    worthRemembering: z21.array(z21.string().min(1)).max(10)
   }).strict()
 }).strict();
 function localDateKey(date) {
@@ -13764,8 +14095,8 @@ Previous output was invalid. Repair it and return strict JSON only.`;
     await mkdir15(flavorDirectory, { recursive: true, mode: 448 });
     await assertNotSymlink(this.#sleepDirectory);
     await mkdir15(this.#sleepDirectory, { recursive: true, mode: 448 });
-    const root = await realpath7(this.#workspace);
-    const target = await realpath7(this.#sleepDirectory);
+    const root = await realpath8(this.#workspace);
+    const target = await realpath8(this.#sleepDirectory);
     if (!isWithin5(root, target)) throw new Error("Sleep directory escapes the workspace");
   }
   async #hasReport(date) {
@@ -14147,10 +14478,10 @@ function computeSessionStats(documents) {
 
 // src/tools/files.ts
 import { constants as constants6 } from "fs";
-import { mkdir as mkdir16, open as open10, readFile as readFile15, realpath as realpath8, rename as rename8, rm as rm8, stat as stat7 } from "fs/promises";
-import { dirname as dirname15, isAbsolute as isAbsolute9, relative as relative15, resolve as resolve18, sep as sep14 } from "path";
+import { mkdir as mkdir16, open as open10, readFile as readFile15, realpath as realpath9, rename as rename8, rm as rm8, stat as stat7 } from "fs/promises";
+import { dirname as dirname16, isAbsolute as isAbsolute9, relative as relative15, resolve as resolve18, sep as sep14 } from "path";
 import { randomUUID as randomUUID11 } from "crypto";
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 
 // src/tools/file-diff.ts
 var MAX_DIFF_PREVIEW_LINES = 120;
@@ -14256,18 +14587,18 @@ function truncateLines(lines) {
 
 // src/tools/files.ts
 var MAX_READ_BYTES = 1048576;
-var ReadInput2 = z21.object({
-  path: z21.string().min(1),
-  maxBytes: z21.coerce.number().int().positive().max(MAX_READ_BYTES).nullable().optional(),
-  startLine: z21.coerce.number().int().positive().nullable().optional(),
-  endLine: z21.coerce.number().int().positive().nullable().optional(),
+var ReadInput2 = z22.object({
+  path: z22.string().min(1),
+  maxBytes: z22.coerce.number().int().positive().max(MAX_READ_BYTES).nullable().optional(),
+  startLine: z22.coerce.number().int().positive().nullable().optional(),
+  endLine: z22.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: z21.union([z21.boolean(), z21.string().refine((value) => value === "true" || value === "false")]).nullable().optional()
+  force: z22.union([z22.boolean(), z22.string().refine((value) => value === "true" || value === "false")]).nullable().optional()
 });
-var WriteInput = z21.object({ path: z21.string().min(1), content: z21.string() });
-var EditInput = z21.object({ path: z21.string().min(1), oldText: z21.string().min(1), newText: z21.string() });
-var ApplyPatchInput = z21.object({ patch: z21.string().min(1) });
+var WriteInput = z22.object({ path: z22.string().min(1), content: z22.string() });
+var EditInput = z22.object({ path: z22.string().min(1), oldText: z22.string().min(1), newText: z22.string() });
+var ApplyPatchInput = z22.object({ patch: z22.string().min(1) });
 var FileObservationStore = class {
   #versions = /* @__PURE__ */ new Map();
   get(path) {
@@ -14475,22 +14806,22 @@ function createPathGuard(workspace) {
     lexical,
     existing: async (input) => {
       const candidate = lexical(input);
-      const physical = await realpath8(candidate);
-      if (!within2(await realpath8(root), physical)) throw new Error("Path escapes the workspace through a symlink");
+      const physical = await realpath9(candidate);
+      if (!within2(await realpath9(root), physical)) throw new Error("Path escapes the workspace through a symlink");
       return physical;
     },
     destination: async (input) => {
       const candidate = lexical(input);
-      const physicalRoot = await realpath8(root);
+      const physicalRoot = await realpath9(root);
       let ancestor = candidate;
       while (true) {
         try {
-          const physical = await realpath8(ancestor);
+          const physical = await realpath9(ancestor);
           if (!within2(physicalRoot, physical)) throw new Error("Path escapes the workspace through a symlink");
           break;
         } catch (error) {
           if (!isMissing3(error)) throw error;
-          const parent = dirname15(ancestor);
+          const parent = dirname16(ancestor);
           if (parent === ancestor) throw error;
           ancestor = parent;
         }
@@ -14501,7 +14832,7 @@ function createPathGuard(workspace) {
 }
 async function atomicWrite(path, content, signal, expectedVersion) {
   abortIfNeeded(signal);
-  await mkdir16(dirname15(path), { recursive: true });
+  await mkdir16(dirname16(path), { recursive: true });
   const temporary = `${path}.${randomUUID11()}.tmp`;
   try {
     const handle = await open10(temporary, constants6.O_CREAT | constants6.O_EXCL | constants6.O_WRONLY, 384);
@@ -14863,22 +15194,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 z22 } from "zod";
-var WebFetchInput = z22.object({
-  url: z22.string().url().max(8192),
-  timeoutMs: z22.coerce.number().int().positive().max(12e4).optional(),
-  maxBytes: z22.coerce.number().int().positive().max(10 * 1024 * 1024).optional()
+import { z as z23 } from "zod";
+var WebFetchInput = z23.object({
+  url: z23.string().url().max(8192),
+  timeoutMs: z23.coerce.number().int().positive().max(12e4).optional(),
+  maxBytes: z23.coerce.number().int().positive().max(10 * 1024 * 1024).optional()
 });
-var WebSearchInput = z22.object({
-  query: z22.string().trim().min(1).max(1e3),
-  maxResults: z22.coerce.number().int().min(1).max(20).optional()
+var WebSearchInput = z23.object({
+  query: z23.string().trim().min(1).max(1e3),
+  maxResults: z23.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: z22.object({ url: z22.string(), status: z22.number(), contentType: z22.string(), content: z22.string(), truncated: z22.boolean() }),
+    outputSchema: z23.object({ url: z23.string(), status: z23.number(), contentType: z23.string(), content: z23.string(), truncated: z23.boolean() }),
     paths: () => [],
     summarize: (input) => input.url,
     presentCall: (input) => ({ kind: "web", title: `Fetching ${new URL(input.url).hostname}`, url: input.url }),
@@ -14904,7 +15235,7 @@ function createWebSearchTool(provider = createDefaultWebSearchProvider()) {
     name: "WebSearch",
     description: "Search the public web and return titles, URLs, and snippets",
     inputSchema: WebSearchInput,
-    outputSchema: z22.object({ query: z22.string(), results: z22.array(z22.object({ title: z22.string(), url: z22.string(), snippet: z22.string() })) }),
+    outputSchema: z23.object({ query: z23.string(), results: z23.array(z23.object({ title: z23.string(), url: z23.string(), snippet: z23.string() })) }),
     paths: () => [],
     summarize: (input) => input.query,
     presentCall: (input) => ({ kind: "web", title: `Searching: ${input.query}` }),
@@ -15170,9 +15501,9 @@ function charset(contentType) {
 import { spawn as spawn7 } from "child_process";
 import { existsSync as existsSync2 } from "fs";
 import { access, constants as constants7, readFile as readFile16 } from "fs/promises";
-import { basename as basename4, dirname as dirname16, extname, isAbsolute as isAbsolute10, relative as relative16, resolve as resolve19, sep as sep15 } from "path";
+import { basename as basename4, dirname as dirname17, extname, isAbsolute as isAbsolute10, relative as relative16, resolve as resolve19, sep as sep15 } from "path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "url";
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var LSP_REQUEST_TIMEOUT_MS = 15e3;
 var LspConnection = class {
   #process;
@@ -15387,7 +15718,7 @@ var LspBuffer = class {
   }
 };
 var TYPESCRIPT_CLI = resolve19(
-  dirname16(fileURLToPath3(import.meta.resolve("typescript/package.json"))),
+  dirname17(fileURLToPath3(import.meta.resolve("typescript/package.json"))),
   "lib",
   "tsc.js"
 );
@@ -15506,18 +15837,18 @@ var RealLspManager = class {
     return connection;
   }
 };
-var LspFindRefsInput = z23.object({
-  file: z23.string().min(1),
-  line: z23.coerce.number().int().nonnegative(),
-  character: z23.coerce.number().int().nonnegative()
+var LspFindRefsInput = z24.object({
+  file: z24.string().min(1),
+  line: z24.coerce.number().int().nonnegative(),
+  character: z24.coerce.number().int().nonnegative()
 });
-var LspHoverInput = z23.object({
-  file: z23.string().min(1),
-  line: z23.coerce.number().int().nonnegative(),
-  character: z23.coerce.number().int().nonnegative()
+var LspHoverInput = z24.object({
+  file: z24.string().min(1),
+  line: z24.coerce.number().int().nonnegative(),
+  character: z24.coerce.number().int().nonnegative()
 });
-var LspDiagnosticsInput = z23.object({
-  file: z23.string().min(1)
+var LspDiagnosticsInput = z24.object({
+  file: z24.string().min(1)
 });
 function createLspTools(workspace, options = {}) {
   const root = resolve19(workspace);
@@ -15743,7 +16074,7 @@ async function gitMarker(workspace) {
 }
 
 // src/git/insights.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 async function suggestCommitMessage(options, input, signal) {
   const prompt = [
     "Write a git commit message for the staged changes below.",
@@ -15782,17 +16113,17 @@ function cleanCommitMessage(raw) {
   }
   return kept.join("\n").trim().slice(0, 2e3);
 }
-var ReviewFindingSchema = z24.object({
-  severity: z24.enum(["critical", "warning", "nit"]),
-  file: z24.string(),
-  line: z24.string().describe('Line number or hunk header the finding refers to, e.g. "42" or "@@ -10,4 +10,6 @@"'),
-  issue: z24.string(),
-  suggestion: z24.string()
+var ReviewFindingSchema = z25.object({
+  severity: z25.enum(["critical", "warning", "nit"]),
+  file: z25.string(),
+  line: z25.string().describe('Line number or hunk header the finding refers to, e.g. "42" or "@@ -10,4 +10,6 @@"'),
+  issue: z25.string(),
+  suggestion: z25.string()
 }).strict();
-var ReviewReportSchema = z24.object({
-  summary: z24.string().describe("One-paragraph overall assessment of the change"),
-  verdict: z24.enum(["ship", "ship-with-fixes", "needs-work"]),
-  findings: z24.array(ReviewFindingSchema).max(20)
+var ReviewReportSchema = z25.object({
+  summary: z25.string().describe("One-paragraph overall assessment of the change"),
+  verdict: z25.enum(["ship", "ship-with-fixes", "needs-work"]),
+  findings: z25.array(ReviewFindingSchema).max(20)
 }).strict();
 async function reviewDiff(options, input, signal) {
   const prompt = [
@@ -15836,10 +16167,10 @@ function formatReviewReport(report) {
 }
 
 // src/git/tools.ts
-import { z as z25 } from "zod";
-var GitHistoryInput = z25.object({
-  path: z25.string().describe("File to inspect; omit for the whole repository history").optional(),
-  limit: z25.number().int().min(1).max(50).describe("Maximum number of commits to return (default 20)").optional()
+import { z as z26 } from "zod";
+var GitHistoryInput = z26.object({
+  path: z26.string().describe("File to inspect; omit for the whole repository history").optional(),
+  limit: z26.number().int().min(1).max(50).describe("Maximum number of commits to return (default 20)").optional()
 });
 function createGitHistoryTool(workspace) {
   return {
@@ -15868,18 +16199,18 @@ function createGitHistoryTool(workspace) {
 }
 
 // src/tools/ask-user-question.ts
-import { z as z26 } from "zod";
-var QuestionOptionSchema = z26.object({
-  label: z26.string().trim().min(1),
-  description: z26.string().trim().min(1)
+import { z as z27 } from "zod";
+var QuestionOptionSchema = z27.object({
+  label: z27.string().trim().min(1),
+  description: z27.string().trim().min(1)
 });
-var QuestionSchema = z26.object({
-  question: z26.string().trim().min(1),
-  header: z26.string().trim().min(1),
-  options: z26.array(QuestionOptionSchema).min(1).max(4)
+var QuestionSchema = z27.object({
+  question: z27.string().trim().min(1),
+  header: z27.string().trim().min(1),
+  options: z27.array(QuestionOptionSchema).min(1).max(4)
 });
-var AskUserQuestionInput = z26.object({
-  questions: z26.array(QuestionSchema).min(1).max(4)
+var AskUserQuestionInput = z27.object({
+  questions: z27.array(QuestionSchema).min(1).max(4)
 });
 function hookAnswersFromUpdatedInput(updatedInput, questions) {
   if (typeof updatedInput !== "object" || updatedInput === null) return void 0;
@@ -15963,20 +16294,20 @@ function createAskUserQuestionTool(handler) {
 }
 
 // src/tools/todo-write.ts
-import { z as z27 } from "zod";
-var TodoStatusSchema = z27.enum([
+import { z as z28 } from "zod";
+var TodoStatusSchema = z28.enum([
   "pending",
   "in_progress",
   "completed",
   "cancelled"
 ]);
-var TodoItemSchema = z27.object({
-  content: z27.string().trim().min(1),
+var TodoItemSchema = z28.object({
+  content: z28.string().trim().min(1),
   status: TodoStatusSchema,
-  activeForm: z27.string().trim().min(1)
+  activeForm: z28.string().trim().min(1)
 });
-var TodoWriteInput = z27.object({
-  todos: z27.array(TodoItemSchema).min(1).max(50)
+var TodoWriteInput = z28.object({
+  todos: z28.array(TodoItemSchema).min(1).max(50)
 });
 function createTodoWriteTool() {
   return {
@@ -16012,37 +16343,37 @@ function createTodoWriteTool() {
 // src/tools/managed.ts
 import { randomUUID as randomUUID12 } from "crypto";
 import { link as link2, lstat as lstat11, mkdir as mkdir17, readFile as readFile17, readdir as readdir9, unlink as unlink4, writeFile as writeFile10 } from "fs/promises";
-import { dirname as dirname17, join as join19, resolve as resolve20 } from "path";
-import { z as z28 } from "zod";
+import { dirname as dirname18, join as join19, resolve as resolve20 } from "path";
+import { z as z29 } 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 = z28.record(z28.string(), z28.unknown()).superRefine((schema, context) => {
+var JsonSchemaObject = z29.record(z29.string(), z29.unknown()).superRefine((schema, context) => {
   if (schema.type !== "object") {
     context.addIssue({ code: "custom", message: "Tool input JSON Schema must have type object" });
   }
 });
-var RegisterManagedToolInputSchema = z28.object({
-  name: z28.string().regex(TOOL_NAME).describe("Unique callable tool name using letters, digits, and underscores"),
-  description: z28.string().min(1).max(4096).describe("Purpose and appropriate use of the generated tool"),
+var RegisterManagedToolInputSchema = z29.object({
+  name: z29.string().regex(TOOL_NAME).describe("Unique callable tool name using letters, digits, and underscores"),
+  description: z29.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: z28.string().min(1).max(64 * 1024).describe(
+  implementation: z29.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: z28.enum(["project", "global"]).default("project").describe(
+  scope: z29.enum(["project", "global"]).default("project").describe(
     "Project persists in the current workspace; global persists for every workspace"
   ),
-  agents: z28.array(z28.enum(["main", "subagent"])).min(1).max(2).optional().describe(
+  agents: z29.array(z29.enum(["main", "subagent"])).min(1).max(2).optional().describe(
     "Agent roles allowed to call the generated tool; omit to allow both"
   )
 }).strict();
-var RemoveManagedToolInputSchema = z28.object({
-  name: z28.string().regex(TOOL_NAME).describe("Managed tool name to remove"),
-  scope: z28.enum(["project", "global"]).optional().describe("Required only when the same name exists in both scopes")
+var RemoveManagedToolInputSchema = z29.object({
+  name: z29.string().regex(TOOL_NAME).describe("Managed tool name to remove"),
+  scope: z29.enum(["project", "global"]).optional().describe("Required only when the same name exists in both scopes")
 }).strict();
 var ManagedToolRecordSchema = RegisterManagedToolInputSchema.extend({
-  version: z28.literal(MANAGED_TOOL_VERSION),
-  createdAt: z28.string().datetime()
+  version: z29.literal(MANAGED_TOOL_VERSION),
+  createdAt: z29.string().datetime()
 }).strict();
 var AsyncFunction = Object.getPrototypeOf(async function() {
 }).constructor;
@@ -16229,7 +16560,7 @@ function createManagedToolManagementTools(options) {
   const listTools = {
     name: "ListRegisteredTools",
     description: "List durable tools created through RegisterTool, including scope, path, and active precedence",
-    inputSchema: z28.object({}).strict(),
+    inputSchema: z29.object({}).strict(),
     agents: mainOnly,
     paths: () => [],
     execute: async (_input, signal) => {
@@ -16242,7 +16573,7 @@ function createManagedToolManagementTools(options) {
 function compileDefinition(record, scope2, workspace) {
   let inputSchema;
   try {
-    inputSchema = z28.fromJSONSchema(record.inputSchema);
+    inputSchema = z29.fromJSONSchema(record.inputSchema);
   } catch (error) {
     throw new Error(`Invalid input schema for managed tool "${record.name}": ${message(error)}`);
   }
@@ -16296,7 +16627,7 @@ ${sourceUrl}`
   }
 }
 async function writeExclusive(path, content) {
-  await mkdir17(dirname17(path), { recursive: true });
+  await mkdir17(dirname18(path), { recursive: true });
   const temporary = `${path}.${randomUUID12()}.tmp`;
   try {
     await writeFile10(temporary, content, { encoding: "utf8", flag: "wx", mode: 384 });
@@ -16342,7 +16673,7 @@ function isMissing4(error) {
 }
 
 // src/hallucination/confidence.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 
 // src/hallucination/types.ts
 var DEFAULT_SLIDING_WINDOW_SIZE = 20;
@@ -16355,12 +16686,12 @@ var DEFAULT_EVALUATION_TIMEOUT_MS = 2e3;
 var MAX_QUERY_CHARS = 5e3;
 var MAX_OUTPUT_CHARS = 1e4;
 var MAX_EVIDENCE_CHARS = 6e3;
-var ConfidenceSchema = z29.object({
-  taskAlignment: z29.number(),
-  evidenceGrounding: z29.number(),
-  processReliability: z29.number(),
-  reason: z29.string(),
-  unsupportedClaims: z29.array(z29.string()).max(3)
+var ConfidenceSchema = z30.object({
+  taskAlignment: z30.number(),
+  evidenceGrounding: z30.number(),
+  processReliability: z30.number(),
+  reason: z30.string(),
+  unsupportedClaims: z30.array(z30.string()).max(3)
 });
 var PROMPT = `You are a fast, evidence-aware task-completion verifier.
 
@@ -18359,15 +18690,15 @@ function workspacePath(root, input) {
 }
 
 // src/tools/terminal.ts
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 import { resolve as resolve24 } from "path";
-var Id = z30.string().regex(/^term-[a-f0-9-]+$/);
-var OpenInput = z30.object({ cwd: z30.string().optional(), shell: z30.string().optional(), args: z30.array(z30.string()).optional(), columns: z30.coerce.number().int().min(10).max(500).optional(), rows: z30.coerce.number().int().min(2).max(300).optional() });
-var OptionalBoolean = z30.union([z30.boolean(), z30.string().refine((value) => value === "true" || value === "false")]);
-var WriteInput2 = z30.object({ id: Id, data: z30.string().max(1e5), enter: OptionalBoolean.optional() });
-var ReadInput3 = z30.object({ id: Id, cursor: z30.coerce.number().int().min(0).optional() });
-var ResizeInput = z30.object({ id: Id, columns: z30.coerce.number().int().min(10).max(500), rows: z30.coerce.number().int().min(2).max(300) });
-var CloseInput = z30.object({ id: Id });
+var Id = z31.string().regex(/^term-[a-f0-9-]+$/);
+var OpenInput = z31.object({ cwd: z31.string().optional(), shell: z31.string().optional(), args: z31.array(z31.string()).optional(), columns: z31.coerce.number().int().min(10).max(500).optional(), rows: z31.coerce.number().int().min(2).max(300).optional() });
+var OptionalBoolean = z31.union([z31.boolean(), z31.string().refine((value) => value === "true" || value === "false")]);
+var WriteInput2 = z31.object({ id: Id, data: z31.string().max(1e5), enter: OptionalBoolean.optional() });
+var ReadInput3 = z31.object({ id: Id, cursor: z31.coerce.number().int().min(0).optional() });
+var ResizeInput = z31.object({ id: Id, columns: z31.coerce.number().int().min(10).max(500), rows: z31.coerce.number().int().min(2).max(300) });
+var CloseInput = z31.object({ id: Id });
 function createTerminalTools(terminals, workspace = process.cwd()) {
   const tools = [
     {
@@ -18443,7 +18774,7 @@ function createTerminalTools(terminals, workspace = process.cwd()) {
     {
       name: "TerminalList",
       description: "List persistent terminals owned by this agent",
-      inputSchema: z30.object({}),
+      inputSchema: z31.object({}),
       paths: () => [],
       execute: async (_input, _signal, context) => terminals.list(owner(context))
     }
@@ -18822,7 +19153,7 @@ var PalClient = class {
 };
 
 // src/pals/tools.ts
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 var DEFAULT_SHARE_BUDGET_BYTES = 128 * 1024;
 var CollaborationShareGuard = class {
   redact;
@@ -18843,25 +19174,25 @@ var CollaborationShareGuard = class {
     return redacted;
   }
 };
-var Uuid = z31.uuid();
-var Hash = z31.string().regex(/^[a-f0-9]{64}$/);
+var Uuid = z32.uuid();
+var Hash = z32.string().regex(/^[a-f0-9]{64}$/);
 var Target = PalTargetSchema;
-var BoundedText = z31.string().trim().min(1).refine(
+var BoundedText = z32.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 = z31.string().trim().min(1).refine(
+var CompletionEvidence = z32.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 = z31.object({}).strict();
-var StateInput = z31.object({ coWorkId: Uuid }).strict();
-var TokenInput = z31.object({ coWorkId: Uuid, epoch: z31.number().int().positive(), planHash: Hash }).strict();
-var SendInput = z31.object({ target: Target, message: BoundedText, coWorkId: Uuid.optional() }).strict();
-var PlanInput = z31.object({ plan: CoWorkPlanSchema }).strict();
-var ProgressInput = z31.object({ coWorkId: Uuid, target: Target, detail: BoundedText }).strict();
-var CompleteInput = TokenInput.extend({ passed: z31.boolean(), detail: CompletionEvidence }).strict();
-var IntegrateInput = TokenInput.extend({ passed: z31.boolean(), evidence: CompletionEvidence }).strict();
+var EmptyInput = z32.object({}).strict();
+var StateInput = z32.object({ coWorkId: Uuid }).strict();
+var TokenInput = z32.object({ coWorkId: Uuid, epoch: z32.number().int().positive(), planHash: Hash }).strict();
+var SendInput = z32.object({ target: Target, message: BoundedText, coWorkId: Uuid.optional() }).strict();
+var PlanInput = z32.object({ plan: CoWorkPlanSchema }).strict();
+var ProgressInput = z32.object({ coWorkId: Uuid, target: Target, detail: BoundedText }).strict();
+var CompleteInput = TokenInput.extend({ passed: z32.boolean(), detail: CompletionEvidence }).strict();
+var IntegrateInput = TokenInput.extend({ passed: z32.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);
@@ -19478,7 +19809,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(join22(workspace, "FLAVOR.md"));
     const instructionBaseline = await workspaceInstructions.baseline();
@@ -20180,6 +20511,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;
@@ -20793,7 +21128,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,
@@ -20828,7 +21163,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) } };