poe-code 3.0.237 → 3.0.238

package/dist/index.js

@@ -1492,11 +1492,11 @@ function mergeLayers(layers) {
   }
   return mergeObjectLayers(layers, []);
 }
-function mergeObjectLayers(layers, path154) {
+function mergeObjectLayers(layers, path155) {
   const data = {};
   const sources = {};
   for (const key2 of collectKeys(layers)) {
-    const resolved = resolveKey(layers, key2, path154);
+    const resolved = resolveKey(layers, key2, path155);
     if (resolved === void 0) {
       continue;
     }
@@ -1516,7 +1516,7 @@ function collectKeys(layers) {
   }
   return [...keys];
 }
-function resolveKey(layers, key2, path154) {
+function resolveKey(layers, key2, path155) {
   let winningSource;
   let winningValue;
   const objectLayers = [];
@@ -1546,9 +1546,9 @@ function resolveKey(layers, key2, path154) {
   if (winningSource === void 0) {
     return void 0;
   }
-  const fullPath = buildPath(path154, key2);
+  const fullPath = buildPath(path155, key2);
   if (isPlainObject(winningValue)) {
-    const merged = mergeObjectLayers(objectLayers, [...path154, key2]);
+    const merged = mergeObjectLayers(objectLayers, [...path155, key2]);
     return {
       value: merged.data,
       sources: {
@@ -1573,8 +1573,8 @@ function isWinningCandidate(key2, value) {
   }
   return true;
 }
-function buildPath(path154, key2) {
-  return [...path154, key2].map(escapePathSegment).join(".");
+function buildPath(path155, key2) {
+  return [...path155, key2].map(escapePathSegment).join(".");
 }
 function escapePathSegment(segment) {
   return segment.replaceAll("\\", "\\\\").replaceAll(".", "\\.");
@@ -13231,16 +13231,16 @@ function getConfigFormat(pathOrFormat) {
   }
   return formatRegistry[formatName];
 }
-function detectFormat2(path154) {
-  const ext = getExtension(path154);
+function detectFormat2(path155) {
+  const ext = getExtension(path155);
   return extensionMap[ext];
 }
-function getExtension(path154) {
-  const lastDot = path154.lastIndexOf(".");
+function getExtension(path155) {
+  const lastDot = path155.lastIndexOf(".");
   if (lastDot === -1) {
     return "";
   }
-  return path154.slice(lastDot).toLowerCase();
+  return path155.slice(lastDot).toLowerCase();
 }
 var formatRegistry, extensionMap;
 var init_formats = __esm({
@@ -14516,7 +14516,7 @@ function mergeScope(scope, baseScope, overrideScope) {
     ...Object.fromEntries(scopeEntries)
   };
 }
-function mergeRuntimeScope(baseScope, overrideScope, path154 = []) {
+function mergeRuntimeScope(baseScope, overrideScope, path155 = []) {
   const merged = {};
   const keys = /* @__PURE__ */ new Set([...Object.keys(baseScope), ...Object.keys(overrideScope)]);
   for (const key2 of keys) {
@@ -14528,20 +14528,20 @@ function mergeRuntimeScope(baseScope, overrideScope, path154 = []) {
       }
       continue;
     }
-    if (isRuntimeConcatenativeArray([...path154, key2]) && Array.isArray(baseValue) && Array.isArray(overrideValue)) {
+    if (isRuntimeConcatenativeArray([...path155, key2]) && Array.isArray(baseValue) && Array.isArray(overrideValue)) {
       merged[key2] = [...baseValue, ...overrideValue];
       continue;
     }
     if (isRecord4(baseValue) && isRecord4(overrideValue)) {
-      merged[key2] = mergeRuntimeScope(baseValue, overrideValue, [...path154, key2]);
+      merged[key2] = mergeRuntimeScope(baseValue, overrideValue, [...path155, key2]);
       continue;
     }
     merged[key2] = overrideValue;
   }
   return merged;
 }
-function isRuntimeConcatenativeArray(path154) {
-  return path154.join(".") === "mounts" || path154.join(".") === "runner.workspace.exclude";
+function isRuntimeConcatenativeArray(path155) {
+  return path155.join(".") === "mounts" || path155.join(".") === "runner.workspace.exclude";
 }
 function isRecord4(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -15864,53 +15864,53 @@ import { createTwoFilesPatch } from "diff";
 import chalk from "chalk";
 function createDryRunFileSystem(base, recorder) {
   const proxy = {
-    async readFile(path154, encoding) {
+    async readFile(path155, encoding) {
       if (encoding) {
-        return base.readFile(path154, encoding);
+        return base.readFile(path155, encoding);
       }
-      return base.readFile(path154);
+      return base.readFile(path155);
     },
-    async writeFile(path154, data, options) {
-      const previousContent = await tryReadText(base, path154);
+    async writeFile(path155, data, options) {
+      const previousContent = await tryReadText(base, path155);
       const nextContent = formatData(data, options?.encoding);
       recorder.record({
         type: "writeFile",
-        path: path154,
+        path: path155,
         nextContent,
         previousContent
       });
     },
-    async symlink(target, path154) {
-      recorder.record({ type: "symlink", target, path: path154 });
+    async symlink(target, path155) {
+      recorder.record({ type: "symlink", target, path: path155 });
     },
-    async readlink(path154) {
-      return base.readlink(path154);
+    async readlink(path155) {
+      return base.readlink(path155);
     },
-    async realpath(path154) {
-      return base.realpath(path154);
+    async realpath(path155) {
+      return base.realpath(path155);
     },
-    async mkdir(path154, options) {
-      recorder.record({ type: "mkdir", path: path154, options });
+    async mkdir(path155, options) {
+      recorder.record({ type: "mkdir", path: path155, options });
     },
-    async stat(path154) {
-      return base.stat(path154);
+    async stat(path155) {
+      return base.stat(path155);
     },
-    async lstat(path154) {
-      return base.lstat(path154);
+    async lstat(path155) {
+      return base.lstat(path155);
     },
     async rename(from, to) {
       recorder.record({ type: "rename", from, to });
     },
-    async unlink(path154) {
-      recorder.record({ type: "unlink", path: path154 });
+    async unlink(path155) {
+      recorder.record({ type: "unlink", path: path155 });
     },
-    async readdir(path154) {
-      return base.readdir(path154);
+    async readdir(path155) {
+      return base.readdir(path155);
     }
   };
   if (typeof base.rm === "function") {
-    proxy.rm = async (path154, options) => {
-      recorder.record({ type: "rm", path: path154, options });
+    proxy.rm = async (path155, options) => {
+      recorder.record({ type: "rm", path: path155, options });
     };
   }
   if (typeof base.copyFile === "function") {
@@ -16012,8 +16012,8 @@ function describeWriteChange(previous, next) {
   }
   return "update";
 }
-function renderWriteCommand(path154, change) {
-  const command = `cat > ${path154}`;
+function renderWriteCommand(path155, change) {
+  const command = `cat > ${path155}`;
   if (change === "create") {
     return renderOperationCommand(command, chalk.green, "# create");
   }
@@ -16175,9 +16175,9 @@ function redactTomlLine(line) {
   }
   return line;
 }
-async function tryReadText(base, path154) {
+async function tryReadText(base, path155) {
   try {
-    return await base.readFile(path154, "utf8");
+    return await base.readFile(path155, "utf8");
   } catch (error3) {
     if (isNotFound(error3)) {
       return null;
@@ -24085,7 +24085,7 @@ function shellQuote4(value) {
   return `'${value.replaceAll("'", "'\\''")}'`;
 }
 function createE2bWorkspaceFileSystem(sandbox) {
-  async function readFile56(targetPath, encoding) {
+  async function readFile57(targetPath, encoding) {
     const contents = Buffer.from(await sandbox.files.read(targetPath, { format: "bytes" }));
     return encoding === void 0 ? contents : contents.toString(encoding);
   }
@@ -24100,7 +24100,7 @@ function createE2bWorkspaceFileSystem(sandbox) {
         isDirectory: () => entry.type === "dir"
       }));
     },
-    readFile: readFile56,
+    readFile: readFile57,
     async writeFile(targetPath, data) {
       await sandbox.files.write(targetPath, typeof data === "string" ? data : toArrayBuffer(data));
     },
@@ -27322,21 +27322,21 @@ async function* adaptClaude(lines) {
         if (blockType !== "tool_result") continue;
         const kind = toolKindsById.get(item.tool_use_id);
         toolKindsById.delete(item.tool_use_id);
-        let path154;
+        let path155;
         if (typeof item.content === "string") {
-          path154 = item.content;
+          path155 = item.content;
         } else {
           try {
-            path154 = JSON.stringify(item.content);
+            path155 = JSON.stringify(item.content);
           } catch {
-            path154 = String(item.content);
+            path155 = String(item.content);
           }
         }
         yield {
           event: "tool_complete",
           id: item.tool_use_id,
           kind,
-          path: path154
+          path: path155
         };
       }
     }
@@ -27459,10 +27459,10 @@ async function* adaptCodex(lines) {
         const kindFromStart = toolKindById.get(item.id);
         const kind = kindFromStart ?? (itemType === "command_execution" ? "exec" : itemType === "file_edit" ? "edit" : "other");
         const titleFromEvent = isNonEmptyString(item.path) ? item.path : itemType === "mcp_tool_call" ? `${isNonEmptyString(item.server) ? item.server : "unknown"}.${isNonEmptyString(item.tool) ? item.tool : "unknown"}` : void 0;
-        const path154 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
+        const path155 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
         toolTitleById.delete(item.id);
         toolKindById.delete(item.id);
-        yield { event: "tool_complete", id: item.id, kind, path: path154 };
+        yield { event: "tool_complete", id: item.id, kind, path: path155 };
       }
     }
   }
@@ -29688,8 +29688,8 @@ function resourceNotFound(resource) {
     `Resource not found: ${resource}`
   );
 }
-function assertAbsolutePath(path154) {
-  if (!isAbsolute(path154)) {
+function assertAbsolutePath(path155) {
+  if (!isAbsolute(path155)) {
     throw invalidParams('"path" must be an absolute path');
   }
 }
@@ -30925,7 +30925,7 @@ function updateSessionFromEvent(ctx, event, toolCallsById) {
   }
   const id = readString2(event.id);
   const kind = readString2(event.kind);
-  const path154 = readString2(event.path);
+  const path155 = readString2(event.path);
   let toolCall = id ? toolCallsById.get(id) : void 0;
   if (!toolCall) {
     toolCall = {};
@@ -30940,8 +30940,8 @@ function updateSessionFromEvent(ctx, event, toolCallsById) {
   if (kind) {
     toolCall.kind = kind;
   }
-  if (path154) {
-    toolCall.path = path154;
+  if (path155) {
+    toolCall.path = path155;
   }
 }
 var sessionCapture;
@@ -43204,17 +43204,17 @@ function validate(schema2, value) {
   }
   return { ok: true, value: result.present ? result.value : void 0 };
 }
-function walkSchema(schema2, value, path154, state) {
+function walkSchema(schema2, value, path155, state) {
   if (schema2.kind === "optional") {
-    return walkOptional(schema2, value, path154, state);
+    return walkOptional(schema2, value, path155, state);
   }
   if (value === missingValue) {
     addIssue(
       state,
-      path154,
+      path155,
       expectedFor(schema2),
       "missing",
-      `Expected ${expectedFor(schema2)} at ${formatPath(path154)}`
+      `Expected ${expectedFor(schema2)} at ${formatPath(path155)}`
     );
     return { present: false };
   }
@@ -43223,149 +43223,149 @@ function walkSchema(schema2, value, path154, state) {
   }
   switch (schema2.kind) {
     case "string":
-      return walkString(schema2, value, path154, state);
+      return walkString(schema2, value, path155, state);
     case "number":
-      return walkNumber(schema2, value, path154, state);
+      return walkNumber(schema2, value, path155, state);
     case "boolean":
-      return walkBoolean(value, path154, state);
+      return walkBoolean(value, path155, state);
     case "enum":
-      return walkEnum(schema2, value, path154, state);
+      return walkEnum(schema2, value, path155, state);
     case "array":
-      return walkArray(schema2, value, path154, state);
+      return walkArray(schema2, value, path155, state);
     case "object":
-      return walkObject(schema2, value, path154, state);
+      return walkObject(schema2, value, path155, state);
     case "oneOf":
-      return walkOneOf(schema2, value, path154, state);
+      return walkOneOf(schema2, value, path155, state);
     case "union":
-      return walkUnion(schema2, value, path154, state);
+      return walkUnion(schema2, value, path155, state);
     case "record":
-      return walkRecord(schema2, value, path154, state);
+      return walkRecord(schema2, value, path155, state);
     case "json":
-      return walkJson(value, path154, state);
+      return walkJson(value, path155, state);
   }
 }
-function walkOptional(schema2, value, path154, state) {
+function walkOptional(schema2, value, path155, state) {
   if (value === missingValue || value === void 0) {
     const defaultValue = getDefault(schema2.inner);
     if (defaultValue.present) {
-      return walkSchema(schema2.inner, cloneDefault(defaultValue.value), path154, state);
+      return walkSchema(schema2.inner, cloneDefault(defaultValue.value), path155, state);
     }
     return { present: false };
   }
-  return walkSchema(schema2.inner, value, path154, state);
+  return walkSchema(schema2.inner, value, path155, state);
 }
-function walkString(schema2, value, path154, state) {
+function walkString(schema2, value, path155, state) {
   if (typeof value !== "string") {
-    addExpectedIssue(state, path154, "string", value);
+    addExpectedIssue(state, path155, "string", value);
     return { present: true, value };
   }
   if (schema2.minLength !== void 0 && value.length < schema2.minLength) {
     const expected = `string with length at least ${schema2.minLength}`;
     addIssue(
       state,
-      path154,
+      path155,
       expected,
       `string with length ${value.length}`,
-      `Expected ${expected} at ${formatPath(path154)}`
+      `Expected ${expected} at ${formatPath(path155)}`
     );
   }
   if (schema2.maxLength !== void 0 && value.length > schema2.maxLength) {
     const expected = `string with length at most ${schema2.maxLength}`;
     addIssue(
       state,
-      path154,
+      path155,
       expected,
       `string with length ${value.length}`,
-      `Expected ${expected} at ${formatPath(path154)}`
+      `Expected ${expected} at ${formatPath(path155)}`
     );
   }
   if (schema2.pattern !== void 0) {
     const pattern = compilePattern(schema2.pattern);
     if (pattern === void 0 || !pattern.test(value)) {
       const expected = `string matching pattern ${schema2.pattern}`;
-      addIssue(state, path154, expected, value, `Expected ${expected} at ${formatPath(path154)}`);
+      addIssue(state, path155, expected, value, `Expected ${expected} at ${formatPath(path155)}`);
     }
   }
   return { present: true, value };
 }
-function walkNumber(schema2, value, path154, state) {
+function walkNumber(schema2, value, path155, state) {
   if (typeof value !== "number" || !Number.isFinite(value)) {
-    addExpectedIssue(state, path154, schema2.jsonType === "integer" ? "integer" : "number", value);
+    addExpectedIssue(state, path155, schema2.jsonType === "integer" ? "integer" : "number", value);
     return { present: true, value };
   }
   if (schema2.jsonType === "integer" && !Number.isInteger(value)) {
-    addExpectedIssue(state, path154, "integer", value);
+    addExpectedIssue(state, path155, "integer", value);
   }
   if (schema2.minimum !== void 0 && value < schema2.minimum) {
     const expected = `number greater than or equal to ${schema2.minimum}`;
-    addIssue(state, path154, expected, String(value), `Expected ${expected} at ${formatPath(path154)}`);
+    addIssue(state, path155, expected, String(value), `Expected ${expected} at ${formatPath(path155)}`);
   }
   if (schema2.maximum !== void 0 && value > schema2.maximum) {
     const expected = `number less than or equal to ${schema2.maximum}`;
-    addIssue(state, path154, expected, String(value), `Expected ${expected} at ${formatPath(path154)}`);
+    addIssue(state, path155, expected, String(value), `Expected ${expected} at ${formatPath(path155)}`);
   }
   return { present: true, value };
 }
-function walkBoolean(value, path154, state) {
+function walkBoolean(value, path155, state) {
   if (typeof value !== "boolean") {
-    addExpectedIssue(state, path154, "boolean", value);
+    addExpectedIssue(state, path155, "boolean", value);
   }
   return { present: true, value };
 }
-function walkEnum(schema2, value, path154, state) {
+function walkEnum(schema2, value, path155, state) {
   if (!schema2.values.includes(value)) {
     const expected = `one of ${schema2.values.join(", ")}`;
     addIssue(
       state,
-      path154,
+      path155,
       expected,
       receivedValue(value),
-      `Expected ${expected} at ${formatPath(path154)}`
+      `Expected ${expected} at ${formatPath(path155)}`
     );
   }
   return { present: true, value };
 }
-function walkArray(schema2, value, path154, state) {
+function walkArray(schema2, value, path155, state) {
   if (!Array.isArray(value)) {
-    addExpectedIssue(state, path154, "array", value);
+    addExpectedIssue(state, path155, "array", value);
     return { present: true, value };
   }
   if (schema2.minItems !== void 0 && value.length < schema2.minItems) {
     const expected = `array with at least ${schema2.minItems} items`;
     addIssue(
       state,
-      path154,
+      path155,
       expected,
       `array with ${value.length} items`,
-      `Expected ${expected} at ${formatPath(path154)}`
+      `Expected ${expected} at ${formatPath(path155)}`
     );
   }
   if (schema2.maxItems !== void 0 && value.length > schema2.maxItems) {
     const expected = `array with at most ${schema2.maxItems} items`;
     addIssue(
       state,
-      path154,
+      path155,
       expected,
       `array with ${value.length} items`,
-      `Expected ${expected} at ${formatPath(path154)}`
+      `Expected ${expected} at ${formatPath(path155)}`
     );
   }
   const nextValue = value.map((item, index) => {
-    const result = walkSchema(schema2.item, item, [...path154, String(index)], state);
+    const result = walkSchema(schema2.item, item, [...path155, String(index)], state);
     return result.present ? result.value : item;
   });
   return { present: true, value: nextValue };
 }
-function walkObject(schema2, value, path154, state, injectedProperties = {}) {
+function walkObject(schema2, value, path155, state, injectedProperties = {}) {
   if (!isPlainRecord(value)) {
-    addExpectedIssue(state, path154, "object", value);
+    addExpectedIssue(state, path155, "object", value);
     return { present: true, value };
   }
   const nextValue = {};
   const allowedKeys = /* @__PURE__ */ new Set([...Object.keys(schema2.shape), ...Object.keys(injectedProperties)]);
   for (const [key2, propertySchema] of Object.entries(schema2.shape)) {
     const propertyValue = Object.hasOwn(value, key2) ? value[key2] : missingValue;
-    const result = walkSchema(propertySchema, propertyValue, [...path154, key2], state);
+    const result = walkSchema(propertySchema, propertyValue, [...path155, key2], state);
     if (result.present) {
       setOwnValue2(nextValue, key2, result.value);
     }
@@ -43384,18 +43384,18 @@ function walkObject(schema2, value, path154, state, injectedProperties = {}) {
     if (schema2.additionalProperties === true) {
       setOwnValue2(nextValue, key2, propertyValue);
     } else {
-      addUnexpectedPropertyIssue(state, [...path154, key2]);
+      addUnexpectedPropertyIssue(state, [...path155, key2]);
     }
   }
   return { present: true, value: nextValue };
 }
-function walkOneOf(schema2, value, path154, state) {
+function walkOneOf(schema2, value, path155, state) {
   if (!isPlainRecord(value)) {
-    addExpectedIssue(state, path154, "object", value);
+    addExpectedIssue(state, path155, "object", value);
     return { present: true, value };
   }
   const discriminatorValue = value[schema2.discriminator];
-  const discriminatorPath = [...path154, schema2.discriminator];
+  const discriminatorPath = [...path155, schema2.discriminator];
   const branchValues = Object.keys(schema2.branches);
   const expected = `one of ${branchValues.join(", ")}`;
   if (!Object.hasOwn(value, schema2.discriminator)) {
@@ -43404,7 +43404,7 @@ function walkOneOf(schema2, value, path154, state) {
       discriminatorPath,
       expected,
       "missing",
-      `Missing discriminator "${schema2.discriminator}" at ${formatPath(path154)}. Expected one of: ${branchValues.join(", ")}.`
+      `Missing discriminator "${schema2.discriminator}" at ${formatPath(path155)}. Expected one of: ${branchValues.join(", ")}.`
     );
     return { present: true, value };
   }
@@ -43418,21 +43418,21 @@ function walkOneOf(schema2, value, path154, state) {
     );
     return { present: true, value };
   }
-  return walkObject(schema2.branches[discriminatorValue], value, path154, state, {
+  return walkObject(schema2.branches[discriminatorValue], value, path155, state, {
     [schema2.discriminator]: discriminatorValue
   });
 }
-function walkUnion(schema2, value, path154, state) {
+function walkUnion(schema2, value, path155, state) {
   if (isPlainRecord(value)) {
     const candidateBranches = schema2.branches.filter((branch) => hasRequiredKeys(branch, value));
     if (candidateBranches.length === 1) {
-      return walkObject(candidateBranches[0], value, path154, state);
+      return walkObject(candidateBranches[0], value, path155, state);
     }
   }
   const matches = [];
   for (const branch of schema2.branches) {
     const branchState = { issues: [] };
-    const result = walkObject(branch, value, path154, branchState);
+    const result = walkObject(branch, value, path155, branchState);
     if (branchState.issues.length === 0 && result.present) {
       matches.push({ fingerprint: getRequiredKeyFingerprint(branch), value: result.value });
     }
@@ -43444,19 +43444,19 @@ function walkUnion(schema2, value, path154, state) {
     const branchDescriptions = schema2.branches.map((branch) => getRequiredKeyFingerprint(branch));
     addIssueWithMessage(
       state,
-      path154,
+      path155,
       "exactly one union branch",
       "0 matching branches",
-      `No union branch matched at ${formatPath(path154)}. Tried ${schema2.branches.length} branches. Expected one of: ${branchDescriptions.join(" | ")}.`
+      `No union branch matched at ${formatPath(path155)}. Tried ${schema2.branches.length} branches. Expected one of: ${branchDescriptions.join(" | ")}.`
     );
     return { present: true, value };
   }
   addIssueWithMessage(
     state,
-    path154,
+    path155,
     "exactly one union branch",
     `${matches.length} matching branches`,
-    `Expected exactly one union branch at ${formatPath(path154)}, but matched more than one branch: ${matches.map((match) => match.fingerprint).join(" | ")}`
+    `Expected exactly one union branch at ${formatPath(path155)}, but matched more than one branch: ${matches.map((match) => match.fingerprint).join(" | ")}`
   );
   return { present: true, value };
 }
@@ -43468,25 +43468,25 @@ function hasRequiredKeys(schema2, value) {
   }
   return true;
 }
-function walkRecord(schema2, value, path154, state) {
+function walkRecord(schema2, value, path155, state) {
   if (!isPlainRecord(value)) {
-    addExpectedIssue(state, path154, "object", value);
+    addExpectedIssue(state, path155, "object", value);
     return { present: true, value };
   }
   const nextValue = {};
   for (const [key2, propertyValue] of Object.entries(value)) {
-    const result = walkSchema(schema2.value, propertyValue, [...path154, key2], state);
+    const result = walkSchema(schema2.value, propertyValue, [...path155, key2], state);
     if (result.present) {
       setOwnValue2(nextValue, key2, result.value);
     }
   }
   return { present: true, value: nextValue };
 }
-function walkJson(value, path154, state) {
+function walkJson(value, path155, state) {
   if (isJsonValue(value)) {
     return { present: true, value };
   }
-  addExpectedIssue(state, path154, "JSON value", value);
+  addExpectedIssue(state, path155, "JSON value", value);
   return { present: true, value };
 }
 function getDefault(schema2) {
@@ -43564,45 +43564,45 @@ function expectedFor(schema2) {
       return expectedFor(schema2.inner);
   }
 }
-function addExpectedIssue(state, path154, expected, value) {
+function addExpectedIssue(state, path155, expected, value) {
   addIssue(
     state,
-    path154,
+    path155,
     expected,
     receivedType(value),
-    `Expected ${expected} at ${formatPath(path154)}`
+    `Expected ${expected} at ${formatPath(path155)}`
   );
 }
-function addUnexpectedPropertyIssue(state, path154) {
+function addUnexpectedPropertyIssue(state, path155) {
   addIssue(
     state,
-    path154,
+    path155,
     "no additional properties",
     "unknown property",
-    `Unexpected property ${formatPath(path154)}`
+    `Unexpected property ${formatPath(path155)}`
   );
 }
-function addIssue(state, path154, expected, received, _message) {
+function addIssue(state, path155, expected, received, _message) {
   state.issues.push({
-    path: path154,
+    path: path155,
     expected,
     received,
-    message: formatIssueMessage(expected, path154, received)
+    message: formatIssueMessage(expected, path155, received)
   });
 }
-function addIssueWithMessage(state, path154, expected, received, message2) {
+function addIssueWithMessage(state, path155, expected, received, message2) {
   state.issues.push({
-    path: path154,
+    path: path155,
     expected,
     received,
     message: message2
   });
 }
-function formatIssueMessage(expected, path154, received) {
-  return `Expected ${expected} at ${formatPath(path154)}, got ${received}`;
+function formatIssueMessage(expected, path155, received) {
+  return `Expected ${expected} at ${formatPath(path155)}, got ${received}`;
 }
-function formatPath(path154) {
-  return path154.length === 0 ? "value" : path154.join(".");
+function formatPath(path155) {
+  return path155.length === 0 ? "value" : path155.join(".");
 }
 function compilePattern(pattern) {
   try {
@@ -47714,10 +47714,10 @@ function parseReviewDiff(diffText) {
       finalizeFile();
       const paths = parseDiffGitPaths(line);
       const previousPath = paths?.previousPath ?? "";
-      const path154 = paths?.path ?? previousPath;
+      const path155 = paths?.path ?? previousPath;
       currentFile = {
-        path: path154,
-        previousPath: previousPath && previousPath !== path154 ? previousPath : null,
+        path: path155,
+        previousPath: previousPath && previousPath !== path155 ? previousPath : null,
         status: "modified",
         hunks: [],
         reviewableLines: [],
@@ -47745,9 +47745,9 @@ function parseReviewDiff(diffText) {
       continue;
     }
     if (line.startsWith("+++ ")) {
-      const path154 = normalizeDiffPath(line.slice(4).trim());
-      if (path154) {
-        currentFile.path = path154;
+      const path155 = normalizeDiffPath(line.slice(4).trim());
+      if (path155) {
+        currentFile.path = path155;
       }
       continue;
     }
@@ -47802,20 +47802,20 @@ function validateInlineComments(comments, context) {
   const accepted = [];
   const seen = /* @__PURE__ */ new Set();
   for (const comment of comments) {
-    const path154 = comment.path.trim();
+    const path155 = comment.path.trim();
     const body = comment.body.trim();
-    if (!path154 || !body || !Number.isInteger(comment.line) || comment.line < 1) {
+    if (!path155 || !body || !Number.isInteger(comment.line) || comment.line < 1) {
       throw new Error("Inline review comments require path, positive line, and body.");
     }
-    if (!context.reviewableLinesByPath.get(path154)?.has(comment.line)) {
+    if (!context.reviewableLinesByPath.get(path155)?.has(comment.line)) {
       throw new Error(
-        `Inline comment target ${path154}:${comment.line} is not a valid right-side diff target.`
+        `Inline comment target ${path155}:${comment.line} is not a valid right-side diff target.`
       );
     }
-    const key2 = `${path154}\0${comment.line}\0${body}`;
+    const key2 = `${path155}\0${comment.line}\0${body}`;
     if (!seen.has(key2)) {
       seen.add(key2);
-      accepted.push({ path: path154, line: comment.line, body });
+      accepted.push({ path: path155, line: comment.line, body });
     }
   }
   accepted.sort((left, right) => {
@@ -48586,10 +48586,10 @@ var init_review_history = __esm({
           kind,
           body
         };
-        const path154 = text5(record, "path");
+        const path155 = text5(record, "path");
         const line = integer(record, "line") ?? integer(record, "original_line");
         const diffHunk = text5(record, "diff_hunk");
-        if (path154) normalized.path = path154;
+        if (path155) normalized.path = path155;
         if (line !== null) normalized.line = line;
         if (diffHunk) normalized.diffHunk = diffHunk;
         return normalized;
@@ -49533,9 +49533,9 @@ function containedPath(directory, name) {
   }
   return target;
 }
-async function pathExists7(path154) {
+async function pathExists7(path155) {
   try {
-    await access(path154);
+    await access(path155);
     return true;
   } catch (error3) {
     if (isMissingFileError2(error3)) {
@@ -52182,13 +52182,13 @@ function convertJsonSchema(schema2) {
   }
   return convertSchema(schema2, schema2, []);
 }
-function convertSchema(schema2, root, path154) {
-  const resolvedSchema = resolveReferencedSchema(schema2, root, path154);
+function convertSchema(schema2, root, path155) {
+  const resolvedSchema = resolveReferencedSchema(schema2, root, path155);
   const normalizedSchema = normalizeNullability(resolvedSchema);
   const composition = getComposition(normalizedSchema.schema);
   if (Array.isArray(normalizedSchema.schema.type)) {
     throw new Error(
-      `JSON Schema "${formatJsonSchemaPath(path154)}" has an unsupported type "${formatJsonSchemaType(
+      `JSON Schema "${formatJsonSchemaPath(path155)}" has an unsupported type "${formatJsonSchemaType(
         normalizedSchema.schema.type
       )}". Supported: string, number, integer, boolean, array, object.`
     );
@@ -52200,13 +52200,13 @@ function convertSchema(schema2, root, path154) {
     return convertEnumSchema(resolvedSchema, normalizedSchema.nullable);
   }
   if (composition !== void 0) {
-    return convertCompositionSchema(normalizedSchema.schema, root, normalizedSchema.nullable, path154);
+    return convertCompositionSchema(normalizedSchema.schema, root, normalizedSchema.nullable, path155);
   }
   if (isRecordSchema(normalizedSchema.schema)) {
     return applyMetadata(
       S.Record(
         convertSchema(normalizedSchema.schema.additionalProperties, root, [
-          ...path154,
+          ...path155,
           "additionalProperties"
         ])
       ),
@@ -52255,12 +52255,12 @@ function convertSchema(schema2, root, path154) {
       if (normalizedSchema.schema.items === void 0) {
         throw new Error(
           `JSON Schema "${formatJsonSchemaPath(
-            path154
+            path155
           )}" is an array but is missing the "items" field. Add "items": { ... } to declare the element type.`
         );
       }
       return S.Array(
-        convertSchema(normalizedSchema.schema.items, root, [...path154, "items"]),
+        convertSchema(normalizedSchema.schema.items, root, [...path155, "items"]),
         createCommonOptions(
           normalizedSchema.schema,
           normalizedSchema.nullable,
@@ -52270,7 +52270,7 @@ function convertSchema(schema2, root, path154) {
     case "object":
       return convertObjectSchema(normalizedSchema.schema, root, {
         nullable: normalizedSchema.nullable,
-        path: path154
+        path: path155
       });
     case "null":
       return applyMetadata(S.Json(), normalizedSchema.schema, {
@@ -52285,12 +52285,12 @@ function convertSchema(schema2, root, path154) {
       }
       throw new Error(
         `JSON Schema "${formatJsonSchemaPath(
-          path154
+          path155
         )}" must declare one of: "type", "enum", "const", "oneOf", "anyOf", or "allOf".`
       );
   }
   throw new Error(
-    `JSON Schema "${formatJsonSchemaPath(path154)}" has an unsupported type "${formatJsonSchemaType(
+    `JSON Schema "${formatJsonSchemaPath(path155)}" has an unsupported type "${formatJsonSchemaType(
       normalizedSchema.schema.type
     )}". Supported: string, number, integer, boolean, array, object.`
   );
@@ -52334,21 +52334,21 @@ function convertEnumSchema(schema2, nullable) {
     )
   });
 }
-function convertCompositionSchema(schema2, root, nullable, path154) {
+function convertCompositionSchema(schema2, root, nullable, path155) {
   const composition = getComposition(schema2);
   const branchSchemas = composition?.branches ?? [];
   const keyword = composition?.keyword ?? "oneOf";
   const branches = branchSchemas.map(
-    (branch, index) => resolveReferencedSchema(branch, root, [...path154, keyword, String(index)])
+    (branch, index) => resolveReferencedSchema(branch, root, [...path155, keyword, String(index)])
   );
-  const discriminator = findDiscriminator(branches, root, path154);
+  const discriminator = findDiscriminator(branches, root, path155);
   if (discriminator !== void 0) {
     const convertedBranches = Object.fromEntries(
       branches.map((branch, index) => [
         getDiscriminatorLiteral(branch, discriminator, root),
         convertObjectSchema(branch, root, {
           omitProperty: discriminator,
-          path: [...path154, keyword, String(index)]
+          path: [...path155, keyword, String(index)]
         })
       ])
     );
@@ -52367,7 +52367,7 @@ function convertCompositionSchema(schema2, root, nullable, path154) {
     S.Union(
       branches.map(
         (branch, index) => convertObjectSchema(branch, root, {
-          path: [...path154, keyword, String(index)]
+          path: [...path155, keyword, String(index)]
         })
       )
     ),
@@ -52469,11 +52469,11 @@ function getComposition(schema2) {
   }
   return void 0;
 }
-function formatJsonSchemaPath(path154) {
-  if (path154.length === 0) {
+function formatJsonSchemaPath(path155) {
+  if (path155.length === 0) {
     return "#";
   }
-  return `#/${path154.map(escapeJsonPointerSegment).join("/")}`;
+  return `#/${path155.map(escapeJsonPointerSegment).join("/")}`;
 }
 function formatJsonSchemaType(type2) {
   return Array.isArray(type2) ? JSON.stringify(type2) : String(type2);
@@ -52489,11 +52489,11 @@ function isRecordSchema(schema2) {
   const propertyKeys = Object.keys(schema2.properties ?? {});
   return schema2.type === "object" && propertyKeys.length === 0 && typeof schema2.additionalProperties === "object" && schema2.additionalProperties !== null;
 }
-function findDiscriminator(branches, root, path154) {
+function findDiscriminator(branches, root, path155) {
   const [firstBranch] = branches;
   if (firstBranch === void 0) {
     throw new Error(
-      `JSON Schema "${formatJsonSchemaPath(path154)}" uses oneOf/anyOf/allOf but has no branches.`
+      `JSON Schema "${formatJsonSchemaPath(path155)}" uses oneOf/anyOf/allOf but has no branches.`
     );
   }
   const candidateKeys = Object.keys(firstBranch.properties ?? {});
@@ -52533,19 +52533,19 @@ function getDiscriminatorLiteral(branch, key2, root) {
   }
   return void 0;
 }
-function resolveReferencedSchema(schema2, root, path154) {
+function resolveReferencedSchema(schema2, root, path155) {
   if (schema2.$ref === void 0) {
     return schema2;
   }
   const resolvedTarget = resolveLocalRef(root, schema2.$ref);
   if (resolvedTarget === void 0) {
     throw new Error(
-      `JSON Schema "${formatJsonSchemaPath(path154)}" uses "$ref": ${schema2.$ref}. toolcraft only supports internal refs like "#/components/schemas/Foo".`
+      `JSON Schema "${formatJsonSchemaPath(path155)}" uses "$ref": ${schema2.$ref}. toolcraft only supports internal refs like "#/components/schemas/Foo".`
     );
   }
   const { $ref: ignoredRef, ...siblingKeywords } = schema2;
   void ignoredRef;
-  const resolvedSchema = resolveReferencedSchema(resolvedTarget, root, path154);
+  const resolvedSchema = resolveReferencedSchema(resolvedTarget, root, path155);
   if (Object.keys(siblingKeywords).length === 0) {
     return resolvedSchema;
   }
@@ -52569,9 +52569,9 @@ function mergeJsonSchemas(base, overlay) {
     ...mergedRequired === void 0 ? {} : { required: mergedRequired }
   };
 }
-function hasSelfReferencingRef(schema2, root, path154 = "#", activePaths = /* @__PURE__ */ new Set()) {
+function hasSelfReferencingRef(schema2, root, path155 = "#", activePaths = /* @__PURE__ */ new Set()) {
   const nextActivePaths = new Set(activePaths);
-  nextActivePaths.add(path154);
+  nextActivePaths.add(path155);
   const localRefPath = getLocalRefPath(schema2.$ref);
   if (localRefPath !== void 0) {
     if (nextActivePaths.has(localRefPath)) {
@@ -52582,13 +52582,13 @@ function hasSelfReferencingRef(schema2, root, path154 = "#", activePaths = /* @_
       return true;
     }
   }
-  if (schema2.items !== void 0 && hasSelfReferencingRef(schema2.items, root, `${path154}/items`, nextActivePaths)) {
+  if (schema2.items !== void 0 && hasSelfReferencingRef(schema2.items, root, `${path155}/items`, nextActivePaths)) {
     return true;
   }
   if (typeof schema2.additionalProperties === "object" && schema2.additionalProperties !== null && hasSelfReferencingRef(
     schema2.additionalProperties,
     root,
-    `${path154}/additionalProperties`,
+    `${path155}/additionalProperties`,
     nextActivePaths
   )) {
     return true;
@@ -52597,7 +52597,7 @@ function hasSelfReferencingRef(schema2, root, path154 = "#", activePaths = /* @_
     if (hasSelfReferencingRef(
       childSchema,
       root,
-      `${path154}/properties/${escapeJsonPointerSegment(key2)}`,
+      `${path155}/properties/${escapeJsonPointerSegment(key2)}`,
       nextActivePaths
     )) {
       return true;
@@ -52607,24 +52607,24 @@ function hasSelfReferencingRef(schema2, root, path154 = "#", activePaths = /* @_
     if (hasSelfReferencingRef(
       childSchema,
       root,
-      `${path154}/$defs/${escapeJsonPointerSegment(key2)}`,
+      `${path155}/$defs/${escapeJsonPointerSegment(key2)}`,
       nextActivePaths
     )) {
       return true;
     }
   }
   for (const [index, childSchema] of (schema2.oneOf ?? []).entries()) {
-    if (hasSelfReferencingRef(childSchema, root, `${path154}/oneOf/${index}`, nextActivePaths)) {
+    if (hasSelfReferencingRef(childSchema, root, `${path155}/oneOf/${index}`, nextActivePaths)) {
       return true;
     }
   }
   for (const [index, childSchema] of (schema2.anyOf ?? []).entries()) {
-    if (hasSelfReferencingRef(childSchema, root, `${path154}/anyOf/${index}`, nextActivePaths)) {
+    if (hasSelfReferencingRef(childSchema, root, `${path155}/anyOf/${index}`, nextActivePaths)) {
       return true;
     }
   }
   for (const [index, childSchema] of (schema2.allOf ?? []).entries()) {
-    if (hasSelfReferencingRef(childSchema, root, `${path154}/allOf/${index}`, nextActivePaths)) {
+    if (hasSelfReferencingRef(childSchema, root, `${path155}/allOf/${index}`, nextActivePaths)) {
       return true;
     }
   }
@@ -52640,14 +52640,14 @@ function getLocalRefPath(ref) {
   return ref.startsWith("#/") ? ref : void 0;
 }
 function resolveLocalRef(root, ref) {
-  const path154 = getLocalRefPath(ref);
-  if (path154 === void 0) {
+  const path155 = getLocalRefPath(ref);
+  if (path155 === void 0) {
     return void 0;
   }
-  if (path154 === "#") {
+  if (path155 === "#") {
     return root;
   }
-  const segments = path154.slice(2).split("/").map(unescapeJsonPointerSegment);
+  const segments = path155.slice(2).split("/").map(unescapeJsonPointerSegment);
   let current = root;
   for (const segment of segments) {
     if (Array.isArray(current)) {
@@ -54112,13 +54112,13 @@ function formatAvailableApprovalCommandPaths(root) {
 }
 function enumerateApprovalCommandPaths(root) {
   const paths = [];
-  const visit = (node, path154) => {
+  const visit = (node, path155) => {
     if (node.kind === "command") {
-      paths.push(path154.join("."));
+      paths.push(path155.join("."));
       return;
     }
     for (const child of getVisibleCliChildren(node)) {
-      visit(child, [...path154, child.name]);
+      visit(child, [...path155, child.name]);
     }
   };
   if (root.kind === "command") {
@@ -54153,21 +54153,21 @@ function createHandlerContext(command, params) {
 }
 function createFs() {
   return {
-    readFile: async (path154, encoding = "utf8") => readFile12(path154, { encoding }),
-    writeFile: async (path154, contents) => {
-      await writeFile9(path154, contents);
+    readFile: async (path155, encoding = "utf8") => readFile12(path155, { encoding }),
+    writeFile: async (path155, contents) => {
+      await writeFile9(path155, contents);
     },
-    exists: async (path154) => {
+    exists: async (path155) => {
       try {
-        await access2(path154);
+        await access2(path155);
         return true;
       } catch {
         return false;
       }
     },
-    lstat: async (path154) => lstat11(path154),
+    lstat: async (path155) => lstat11(path155),
     rename: async (fromPath, toPath) => rename10(fromPath, toPath),
-    unlink: async (path154) => unlink7(path154)
+    unlink: async (path155) => unlink7(path155)
   };
 }
 function createEnv(values = process.env) {
@@ -54696,21 +54696,21 @@ function isPlainObject5(value) {
 }
 function createFs2() {
   return {
-    readFile: async (path154, encoding = "utf8") => readFile13(path154, { encoding }),
-    writeFile: async (path154, contents) => {
-      await writeFile10(path154, contents);
+    readFile: async (path155, encoding = "utf8") => readFile13(path155, { encoding }),
+    writeFile: async (path155, contents) => {
+      await writeFile10(path155, contents);
     },
-    exists: async (path154) => {
+    exists: async (path155) => {
       try {
-        await access3(path154);
+        await access3(path155);
         return true;
       } catch {
         return false;
       }
     },
-    lstat: async (path154) => lstat12(path154),
+    lstat: async (path155) => lstat12(path155),
     rename: async (fromPath, toPath) => rename11(fromPath, toPath),
-    unlink: async (path154) => unlink8(path154)
+    unlink: async (path155) => unlink8(path155)
   };
 }
 function createEnv2(values = process.env) {
@@ -54755,11 +54755,11 @@ function applySchemaCasing(schema2, casing) {
     ...required === void 0 ? {} : { required }
   };
 }
-function collectParamSummaries(schema2, casing, path154 = [], inheritedOptional = false) {
+function collectParamSummaries(schema2, casing, path155 = [], inheritedOptional = false) {
   const summaries = [];
   for (const [key2, rawChildSchema] of Object.entries(schema2.shape)) {
     const childSchema = unwrapOptional3(rawChildSchema);
-    const nextPath = [...path154, formatSegment(key2, casing)];
+    const nextPath = [...path155, formatSegment(key2, casing)];
     const optional = inheritedOptional || isOptional(rawChildSchema);
     if (childSchema.kind === "object") {
       summaries.push(...collectParamSummaries(childSchema, casing, nextPath, optional));
@@ -54788,8 +54788,8 @@ function matchesAllowlist(toolName, allowlist) {
   const candidates = segments.map((_segment, index) => segments.slice(0, index + 1).join("__"));
   return candidates.some((candidate) => allowlist.includes(candidate));
 }
-function formatToolName(path154) {
-  return path154.map((segment) => formatSegment(segment, "snake")).join("__");
+function formatToolName(path155) {
+  return path155.map((segment) => formatSegment(segment, "snake")).join("__");
 }
 function validateUniqueMCPParameterFields(schema2, casing) {
   const sourceKeysByField = /* @__PURE__ */ new Map();
@@ -56824,14 +56824,14 @@ function parseDockerLocator(input) {
     throw new Error(`Invalid docker workspace locator "${input}".`);
   }
   const container = input.slice(0, slashIndex);
-  const path154 = input.slice(slashIndex);
-  if (container.length === 0 || path154.length === 0) {
+  const path155 = input.slice(slashIndex);
+  if (container.length === 0 || path155.length === 0) {
     throw new Error(`Invalid docker workspace locator "${input}".`);
   }
   return {
     scheme: "docker",
     container,
-    path: path154
+    path: path155
   };
 }
 function splitOnce(input, separator) {
@@ -57562,8 +57562,8 @@ async function checkAuth(options) {
 }
 function createCurrentBalanceUrl(baseUrl) {
   const url = new URL(baseUrl);
-  const path154 = url.pathname.endsWith("/") ? url.pathname.slice(0, -1) : url.pathname;
-  url.pathname = `${path154}/usage/current_balance`;
+  const path155 = url.pathname.endsWith("/") ? url.pathname.slice(0, -1) : url.pathname;
+  url.pathname = `${path155}/usage/current_balance`;
   return url.toString();
 }
 function isCurrentBalanceResponse(value) {
@@ -59135,26 +59135,26 @@ function createSdkContainer(options) {
   });
   loggerFactory.setErrorLogger(errorLogger);
   const asyncFs = {
-    readFile: ((path154, encoding) => {
+    readFile: ((path155, encoding) => {
       if (encoding) {
-        return fs7.readFile(path154, encoding);
+        return fs7.readFile(path155, encoding);
       }
-      return fs7.readFile(path154);
+      return fs7.readFile(path155);
     }),
-    symlink: (target, path154) => fs7.symlink(target, path154),
-    readlink: (path154) => fs7.readlink(path154, { encoding: "utf8" }),
-    realpath: (path154) => fs7.realpath(path154),
-    writeFile: (path154, data, opts) => fs7.writeFile(path154, data, opts),
-    mkdir: (path154, opts) => fs7.mkdir(path154, opts).then(() => {
+    symlink: (target, path155) => fs7.symlink(target, path155),
+    readlink: (path155) => fs7.readlink(path155, { encoding: "utf8" }),
+    realpath: (path155) => fs7.realpath(path155),
+    writeFile: (path155, data, opts) => fs7.writeFile(path155, data, opts),
+    mkdir: (path155, opts) => fs7.mkdir(path155, opts).then(() => {
     }),
-    stat: (path154) => fs7.stat(path154),
-    lstat: (path154) => fs7.lstat(path154),
+    stat: (path155) => fs7.stat(path155),
+    lstat: (path155) => fs7.lstat(path155),
     rename: (oldPath, newPath) => fs7.rename(oldPath, newPath),
-    rm: (path154, opts) => fs7.rm(path154, opts),
-    unlink: (path154) => fs7.unlink(path154),
-    readdir: (path154) => fs7.readdir(path154),
+    rm: (path155, opts) => fs7.rm(path155, opts),
+    unlink: (path155) => fs7.unlink(path155),
+    readdir: (path155) => fs7.readdir(path155),
     copyFile: (src, dest) => fs7.copyFile(src, dest),
-    chmod: (path154, mode) => fs7.chmod(path154, mode)
+    chmod: (path155, mode) => fs7.chmod(path155, mode)
   };
   const contextFactory = createCommandContextFactory({ fs: asyncFs });
   const authFs = {
@@ -60835,7 +60835,7 @@ function selectNextExecution(plan, taskId) {
 function describeExecutionContext(selection) {
   return selection.stepName ? `task "${selection.task.id}" step "${selection.stepName}"` : `task "${selection.task.id}"`;
 }
-async function resolveFileIncludes(template2, cwd, readFile56) {
+async function resolveFileIncludes(template2, cwd, readFile57) {
   const matches = [...template2.matchAll(FILE_INCLUDE_PATTERN)];
   if (matches.length === 0) {
     return template2;
@@ -60847,7 +60847,7 @@ async function resolveFileIncludes(template2, cwd, readFile56) {
     if (relativePath === ".." || relativePath.startsWith(`..${path70.sep}`) || path70.isAbsolute(relativePath)) {
       throw new Error(`Pipeline file include resolves outside the project root: ${match[1]}`);
     }
-    const content = await readFile56(absolutePath, "utf8");
+    const content = await readFile57(absolutePath, "utf8");
     result = result.replace(match[0], content);
   }
   return result;
@@ -60915,15 +60915,15 @@ async function resolveDocVarFromPath(options) {
     );
   }
 }
-async function resolvePipelineVars(vars, cwd, readFile56) {
+async function resolvePipelineVars(vars, cwd, readFile57) {
   const resolved = {};
   for (const [key2, value] of Object.entries(vars)) {
     if (key2.endsWith("_doc") && looksLikeDocPath(value)) {
-      const docContent = await resolveDocVarFromPath({ key: key2, value, cwd, readFile: readFile56 });
-      defineRecordEntry2(resolved, key2, await resolveFileIncludes(docContent, cwd, readFile56));
+      const docContent = await resolveDocVarFromPath({ key: key2, value, cwd, readFile: readFile57 });
+      defineRecordEntry2(resolved, key2, await resolveFileIncludes(docContent, cwd, readFile57));
       continue;
     }
-    defineRecordEntry2(resolved, key2, await resolveFileIncludes(value, cwd, readFile56));
+    defineRecordEntry2(resolved, key2, await resolveFileIncludes(value, cwd, readFile57));
   }
   return resolved;
 }
@@ -69839,7 +69839,7 @@ var init_frontmatter4 = __esm({
 });
 
 // packages/github-workflows/src/discover.ts
-import { readdir as readdir21, readFile as readFile26 } from "node:fs/promises";
+import { readdir as readdir21, readFile as readFile27 } from "node:fs/promises";
 import { join as join5 } from "node:path";
 async function discoverAutomations(builtInDir, ...projectDirs) {
   const directories = [builtInDir, ...projectDirs];
@@ -69883,7 +69883,7 @@ async function listMarkdownFiles(dir) {
 }
 async function readAutomation(dir, fileName, baseName, baseDirs) {
   const filePath = join5(dir, fileName);
-  const content = await readFile26(filePath, "utf8");
+  const content = await readFile27(filePath, "utf8");
   const resolved = await resolve(
     [
       {
@@ -69904,7 +69904,7 @@ async function readAutomation(dir, fileName, baseName, baseDirs) {
       }
     ],
     {
-      fs: { readFile: readFile26 }
+      fs: { readFile: readFile27 }
     }
   );
   const name = stripPrefix(fileName.slice(0, -3));
@@ -70126,7 +70126,7 @@ var init_require_comment_prefix = __esm({
 });
 
 // packages/github-workflows/src/exec/trufflehog-pr-scan.ts
-import { appendFile as appendFile4, lstat as lstat22, readFile as readFile27, rename as rename19, rm as rm5, writeFile as writeFile18 } from "node:fs/promises";
+import { appendFile as appendFile4, lstat as lstat22, readFile as readFile28, rename as rename19, rm as rm5, writeFile as writeFile18 } from "node:fs/promises";
 import { randomUUID as randomUUID11 } from "node:crypto";
 async function runTruffleHogPrScanCommand(command, env, options = {}) {
   if (options.dryRun === true) {
@@ -70357,15 +70357,15 @@ async function publishFiles(fs27, files) {
     await Promise.all(stagedFiles.map((file) => fs27.rm(file.stagedPath, { force: true })));
   }
 }
-async function assertNotSymbolicLinkIfSet(fs27, path154) {
-  if (path154 !== void 0 && path154 !== "") {
-    await assertNotSymbolicLink2(fs27, path154);
+async function assertNotSymbolicLinkIfSet(fs27, path155) {
+  if (path155 !== void 0 && path155 !== "") {
+    await assertNotSymbolicLink2(fs27, path155);
   }
 }
-async function assertNotSymbolicLink2(fs27, path154) {
+async function assertNotSymbolicLink2(fs27, path155) {
   try {
-    if ((await fs27.lstat(path154)).isSymbolicLink()) {
-      throw new UserError(`Refusing to use symbolic link path: ${path154}`);
+    if ((await fs27.lstat(path155)).isSymbolicLink()) {
+      throw new UserError(`Refusing to use symbolic link path: ${path155}`);
     }
   } catch (error3) {
     if (isMissingFileError6(error3)) {
@@ -70479,7 +70479,7 @@ var init_trufflehog_pr_scan = __esm({
     DEFAULT_STDERR_FILE = "/tmp/trufflehog-stderr.log";
     COMMENT_MARKER = "<!-- trufflehog-pr-scan -->";
     FIX_MESSAGE = "Fix: remove the value, rotate it if it was real, and push a cleanup commit.";
-    defaultFileSystem = { appendFile: appendFile4, lstat: lstat22, readFile: readFile27, rename: rename19, rm: rm5, writeFile: writeFile18 };
+    defaultFileSystem = { appendFile: appendFile4, lstat: lstat22, readFile: readFile28, rename: rename19, rm: rm5, writeFile: writeFile18 };
   }
 });
 
@@ -70550,8 +70550,8 @@ var init_setup_agent = __esm({
 });
 
 // packages/github-workflows/src/variables.ts
-import path97 from "node:path";
-import { readFile as readFile28 } from "node:fs/promises";
+import path98 from "node:path";
+import { readFile as readFile29 } from "node:fs/promises";
 import { isMap as isMap4, parseDocument as parseDocument10, stringify as stringify6 } from "yaml";
 function isRecord33(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -70642,7 +70642,7 @@ function extractUserOverrideBlocks(filePath, content) {
 }
 async function readOptionalVariablesContent(filePath) {
   try {
-    return await readFile28(filePath, "utf8");
+    return await readFile29(filePath, "utf8");
   } catch (error3) {
     if (error3 instanceof Error && error3.code === "ENOENT") {
       return void 0;
@@ -70670,9 +70670,9 @@ function formatCommentedBlock(name, value) {
   return formatVariableBlock(name, value).split("\n").map((line) => `# ${line}`).join("\n");
 }
 async function loadVariableSources(builtInDir, projectDir) {
-  const builtInPath = path97.join(builtInDir, VARIABLES_FILE_NAME);
-  const builtInVariables = parseVariables(builtInPath, await readFile28(builtInPath, "utf8"));
-  const projectVariablesPath = projectDir === void 0 ? void 0 : path97.join(projectDir, VARIABLES_FILE_NAME);
+  const builtInPath = path98.join(builtInDir, VARIABLES_FILE_NAME);
+  const builtInVariables = parseVariables(builtInPath, await readFile29(builtInPath, "utf8"));
+  const projectVariablesPath = projectDir === void 0 ? void 0 : path98.join(projectDir, VARIABLES_FILE_NAME);
   const projectVariablesContent = projectVariablesPath === void 0 ? void 0 : await readOptionalVariablesContent(projectVariablesPath);
   if (projectVariablesPath === void 0 || projectVariablesContent === void 0) {
     return { builtInVariables, extendsBuiltIns: true, projectVariables: {} };
@@ -70684,13 +70684,13 @@ async function loadVariableSources(builtInDir, projectDir) {
   return { builtInVariables, extendsBuiltIns, projectVariables };
 }
 async function loadVariables(builtInDir, projectDir) {
-  const builtInPath = path97.join(builtInDir, VARIABLES_FILE_NAME);
-  const builtInContent = await readFile28(builtInPath, "utf8");
+  const builtInPath = path98.join(builtInDir, VARIABLES_FILE_NAME);
+  const builtInContent = await readFile29(builtInPath, "utf8");
   const builtInVariables = parseVariables(builtInPath, builtInContent);
   if (projectDir === void 0) {
     return filterDisabledVariables(builtInVariables);
   }
-  const projectVariablesPath = path97.join(projectDir, VARIABLES_FILE_NAME);
+  const projectVariablesPath = path98.join(projectDir, VARIABLES_FILE_NAME);
   const projectVariablesContent = await readOptionalVariablesContent(projectVariablesPath);
   if (projectVariablesContent === void 0) {
     return filterDisabledVariables(builtInVariables);
@@ -70709,7 +70709,7 @@ async function loadVariables(builtInDir, projectDir) {
       }
     ],
     {
-      fs: { readFile: readFile28 },
+      fs: { readFile: readFile29 },
       autoExtend: true
     }
   );
@@ -70723,7 +70723,7 @@ async function loadVariableStatuses(builtInDir, projectDir) {
       (key2) => !extendsBuiltIns || !Object.prototype.hasOwnProperty.call(builtInVariables, key2)
     )
   ];
-  const projectVariablesPath = projectDir === void 0 ? void 0 : path97.join(projectDir, VARIABLES_FILE_NAME);
+  const projectVariablesPath = projectDir === void 0 ? void 0 : path98.join(projectDir, VARIABLES_FILE_NAME);
   return orderedNames.map((name) => {
     if (!Object.prototype.hasOwnProperty.call(projectVariables, name)) {
       return {
@@ -70788,8 +70788,8 @@ var init_variables2 = __esm({
 });
 
 // packages/github-workflows/src/commands.ts
-import { access as access4, lstat as lstat23, mkdir as mkdir23, readFile as readFile29, unlink as unlink15, writeFile as writeFile19 } from "node:fs/promises";
-import path98 from "node:path";
+import { access as access4, lstat as lstat23, mkdir as mkdir23, readFile as readFile30, unlink as unlink15, writeFile as writeFile19 } from "node:fs/promises";
+import path99 from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 function formatLabel(name) {
   const capitalize2 = (s) => s.charAt(0).toUpperCase() + s.slice(1);
@@ -70811,7 +70811,7 @@ async function loadNamedAutomation(name, cwd) {
 }
 async function readBuiltInPromptFile(name) {
   try {
-    return await readFile29(path98.join(await resolveBuiltInPromptsDir(), `${name}.md`), "utf8");
+    return await readFile30(path99.join(await resolveBuiltInPromptsDir(), `${name}.md`), "utf8");
   } catch (error3) {
     if (isMissingPathError3(error3)) {
       throw new UserError(`Automation "${name}" was not found.`);
@@ -70820,11 +70820,11 @@ async function readBuiltInPromptFile(name) {
   }
 }
 async function readBuiltInWorkflowTemplate(name, variant, automationName = name, promptPath) {
-  const templatePath = path98.join(await resolveBuiltInWorkflowTemplatesDir(), `${name}.${variant}.yml`);
+  const templatePath = path99.join(await resolveBuiltInWorkflowTemplatesDir(), `${name}.${variant}.yml`);
   try {
-    const content = await readFile29(templatePath, "utf8");
+    const content = await readFile30(templatePath, "utf8");
     const header = promptPath !== void 0 ? `# Auto-generated by: poe-code github-workflows install ${name}
-# Edit ${path98.relative(process.cwd(), promptPath)} to customize the prompt.
+# Edit ${path99.relative(process.cwd(), promptPath)} to customize the prompt.
 ` : `# Auto-generated by: poe-code github-workflows install ${name}
 `;
     const processedContent = content.replaceAll(` ${name}`, ` ${automationName}`).replaceAll("__UPSTREAM_REPO__", UPSTREAM_REPO);
@@ -70853,7 +70853,7 @@ function projectPromptDirs(cwd) {
   return [projectWorkflowDir(cwd)];
 }
 function projectWorkflowDir(cwd) {
-  return path98.join(cwd, ".github", "workflows");
+  return path99.join(cwd, ".github", "workflows");
 }
 function projectGitHubWorkflowsDir(cwd) {
   return projectWorkflowDir(cwd);
@@ -70872,7 +70872,7 @@ async function resolveBuiltInPromptsDir() {
   return builtInPromptsDirCandidates[0];
 }
 async function resolveBuiltInAssetsDir() {
-  return path98.dirname(await resolveBuiltInPromptsDir());
+  return path99.dirname(await resolveBuiltInPromptsDir());
 }
 function resolveCwd(cwd) {
   return cwd ?? process.cwd();
@@ -71049,19 +71049,19 @@ function addPromptHeader(content, name) {
 async function installAutomation(name, cwd, isEject, dryRun = false, writtenFiles = []) {
   const variant = isEject ? "ejected" : "caller";
   const localAutomationName = isEject ? `poe-code-${name}` : name;
-  const promptPath = isEject ? path98.join(projectWorkflowDir(cwd), `${localAutomationName}.md`) : void 0;
+  const promptPath = isEject ? path99.join(projectWorkflowDir(cwd), `${localAutomationName}.md`) : void 0;
   const [workflowTemplate, rawPrompt] = await Promise.all([
     readBuiltInWorkflowTemplate(name, variant, localAutomationName, promptPath),
     readBuiltInPromptFile(name)
   ]);
-  const workflowPath = path98.join(cwd, ".github", "workflows", `poe-code-${name}.yml`);
+  const workflowPath = path99.join(cwd, ".github", "workflows", `poe-code-${name}.yml`);
   if (!dryRun) {
-    await mkdir23(path98.dirname(workflowPath), { recursive: true });
+    await mkdir23(path99.dirname(workflowPath), { recursive: true });
     await assertWritableWorkflowDestination(workflowPath);
     await writeTrackedFile(workflowPath, workflowTemplate, writtenFiles);
   }
   if (promptPath !== void 0 && !dryRun) {
-    await mkdir23(path98.dirname(promptPath), { recursive: true });
+    await mkdir23(path99.dirname(promptPath), { recursive: true });
     await assertWritableWorkflowDestination(promptPath);
     await writeTrackedFile(promptPath, addPromptHeader(rawPrompt, name), writtenFiles);
   }
@@ -71076,14 +71076,14 @@ async function installAutomation(name, cwd, isEject, dryRun = false, writtenFile
 function resolveProjectSupportFilePaths(cwd) {
   const projectDir = projectGitHubWorkflowsDir(cwd);
   return {
-    variablesPath: path98.join(projectDir, "variables.yaml"),
-    readmePath: path98.join(projectDir, "README.md")
+    variablesPath: path99.join(projectDir, "variables.yaml"),
+    readmePath: path99.join(projectDir, "README.md")
   };
 }
 async function ensureProjectSupportFiles(cwd, builtInVariables, writtenFiles = []) {
   const projectDir = projectGitHubWorkflowsDir(cwd);
-  const variablesPath = path98.join(projectDir, "variables.yaml");
-  const readmePath = path98.join(projectDir, "README.md");
+  const variablesPath = path99.join(projectDir, "variables.yaml");
+  const readmePath = path99.join(projectDir, "README.md");
   await mkdir23(projectDir, { recursive: true });
   await assertWritableWorkflowDestination(variablesPath);
   await assertWritableWorkflowDestination(readmePath);
@@ -71129,7 +71129,7 @@ async function assertWritableWorkflowDestination(filePath) {
 }
 async function readOptionalFile3(filePath) {
   try {
-    return await readFile29(filePath, "utf8");
+    return await readFile30(filePath, "utf8");
   } catch (error3) {
     if (isMissingPathError3(error3)) {
       return void 0;
@@ -71451,7 +71451,7 @@ var init_commands2 = __esm({
       scope: ["cli"],
       handler: async ({ params }) => {
         const name = params.name;
-        const workflowPath = path98.join(resolveCwd(), ".github", "workflows", `poe-code-${name}.yml`);
+        const workflowPath = path99.join(resolveCwd(), ".github", "workflows", `poe-code-${name}.yml`);
         if (params.dryRun !== true) {
           try {
             await unlink15(workflowPath);
@@ -71580,7 +71580,7 @@ var init_commands2 = __esm({
         return (await loadVariableStatuses(await resolveBuiltInAssetsDir(), projectGitHubWorkflowsDir(cwd))).map(
           (status) => ({
             ...status,
-            source: status.source === "built-in" ? status.source : path98.relative(cwd, status.source)
+            source: status.source === "built-in" ? status.source : path99.relative(cwd, status.source)
           })
         );
       },
@@ -71636,7 +71636,7 @@ var init_src37 = __esm({
 });
 
 // packages/agent-eval/src/schema.ts
-import path99 from "node:path";
+import path100 from "node:path";
 function validateEvalYaml(value, filePath = "eval.yaml") {
   const result = validate(evalYamlSchema, value);
   if (result.ok) {
@@ -71653,12 +71653,12 @@ function validateEvalYaml(value, filePath = "eval.yaml") {
 }
 function validateTarget(target) {
   const destination = target.plan_dest ?? "docs/plans/eval-task.md";
-  if (path99.isAbsolute(destination)) {
+  if (path100.isAbsolute(destination)) {
     return [invalidPlanDestination(destination)];
   }
-  const resolved = path99.resolve("/clone", destination);
-  const relative6 = path99.relative("/clone", resolved);
-  return relative6 === ".." || relative6.startsWith(`..${path99.sep}`) ? [invalidPlanDestination(destination)] : [];
+  const resolved = path100.resolve("/clone", destination);
+  const relative6 = path100.relative("/clone", resolved);
+  return relative6 === ".." || relative6.startsWith(`..${path100.sep}`) ? [invalidPlanDestination(destination)] : [];
 }
 function invalidPlanDestination(destination) {
   return {
@@ -71699,8 +71699,8 @@ function validateMetrics(metrics) {
 function formatIssues(filePath, issues) {
   return issues.map((issue) => `${filePath} (${formatPath2(issue.path)}): ${issue.message}`).join("\n");
 }
-function formatPath2(path154) {
-  return path154.join(".") || "value";
+function formatPath2(path155) {
+  return path155.join(".") || "value";
 }
 var metricEvaluatorSchema, metricSchema, evalYamlSchema, EvalYamlValidationError;
 var init_schema4 = __esm({
@@ -71785,21 +71785,21 @@ var init_schema4 = __esm({
 });
 
 // packages/agent-eval/src/path-boundary.ts
-import { realpath as realpath5 } from "node:fs/promises";
-import path100 from "node:path";
+import { realpath as realpath6 } from "node:fs/promises";
+import path101 from "node:path";
 function resolveContainedPath(rootDir, configuredPath, field) {
-  const absoluteRootDir = path100.resolve(rootDir);
-  const resolved = path100.resolve(absoluteRootDir, configuredPath);
+  const absoluteRootDir = path101.resolve(rootDir);
+  const resolved = path101.resolve(absoluteRootDir, configuredPath);
   assertWithin(absoluteRootDir, resolved, field, false);
   return resolved;
 }
 async function assertCanonicalContainedPath(rootDir, targetPath, field) {
-  const canonicalRoot = await realpath5(path100.resolve(rootDir));
-  const canonicalTarget = await realpath5(targetPath);
+  const canonicalRoot = await realpath6(path101.resolve(rootDir));
+  const canonicalTarget = await realpath6(targetPath);
   assertWithin(canonicalRoot, canonicalTarget, field, true);
 }
 async function assertFsCanonicalContainedPath(fs27, rootDir, targetPath, field) {
-  const canonicalRoot = await fs27.realpath(path100.resolve(rootDir));
+  const canonicalRoot = await fs27.realpath(path101.resolve(rootDir));
   const canonicalTarget = await fs27.realpath(targetPath);
   assertWithin(canonicalRoot, canonicalTarget, field, true);
 }
@@ -71815,11 +71815,11 @@ async function assertFsCanonicalContainedPathIfPresent(fs27, rootDir, targetPath
   }
 }
 async function assertCanonicalDestinationPath(rootDir, targetPath, field) {
-  const canonicalRoot = await realpath5(path100.resolve(rootDir));
-  let current = path100.resolve(targetPath);
+  const canonicalRoot = await realpath6(path101.resolve(rootDir));
+  let current = path101.resolve(targetPath);
   while (true) {
     try {
-      const canonicalAncestor = await realpath5(current);
+      const canonicalAncestor = await realpath6(current);
       assertWithin(canonicalRoot, canonicalAncestor, field, true);
       return;
     } catch (error3) {
@@ -71827,7 +71827,7 @@ async function assertCanonicalDestinationPath(rootDir, targetPath, field) {
         throw error3;
       }
     }
-    const parent = path100.dirname(current);
+    const parent = path101.dirname(current);
     if (parent === current) {
       throw new Error(`${field} must stay within the canonical ${fieldRootDescription(field)}.`);
     }
@@ -71835,8 +71835,8 @@ async function assertCanonicalDestinationPath(rootDir, targetPath, field) {
   }
 }
 function assertWithin(rootDir, targetPath, field, canonical) {
-  const relative6 = path100.relative(rootDir, targetPath);
-  if (relative6 === ".." || relative6.startsWith(`..${path100.sep}`)) {
+  const relative6 = path101.relative(rootDir, targetPath);
+  if (relative6 === ".." || relative6.startsWith(`..${path101.sep}`)) {
     const prefix = canonical ? "canonical " : "";
     throw new Error(`${field} must stay within the ${prefix}${fieldRootDescription(field)}.`);
   }
@@ -72037,9 +72037,9 @@ async function loadEval(source, id, fs27 = nodeFs12) {
     plan
   };
 }
-async function isFile2(path154, fs27) {
+async function isFile2(path155, fs27) {
   try {
-    const stat33 = await fs27.stat(path154);
+    const stat33 = await fs27.stat(path155);
     return typeof stat33.isFile === "function" ? stat33.isFile() : !stat33.isDirectory();
   } catch (error3) {
     if (isMissingPath4(error3)) {
@@ -72389,7 +72389,7 @@ var init_aggregate = __esm({
 // packages/agent-eval/src/run/clone.ts
 import { createHash as createHash7 } from "node:crypto";
 import { access as access5, mkdir as mkdir24, rm as rm6 } from "node:fs/promises";
-import path101 from "node:path";
+import path102 from "node:path";
 import { simpleGit } from "simple-git";
 async function cloneTarget(input) {
   throwIfAborted6(input.signal);
@@ -72421,7 +72421,7 @@ async function cloneDirect(input) {
 }
 async function cloneFromCache(input) {
   await mkdir24(input.cacheDir, { recursive: true });
-  const cachedRepo = path101.join(input.cacheDir, `${hashRepo(input.repo)}.git`);
+  const cachedRepo = path102.join(input.cacheDir, `${hashRepo(input.repo)}.git`);
   if (await exists2(cachedRepo)) {
     await git(cachedRepo, input.signal).raw([
       "fetch",
@@ -72463,7 +72463,7 @@ var init_clone2 = __esm({
 });
 
 // packages/agent-eval/src/types.ts
-import path102 from "node:path";
+import path103 from "node:path";
 function resolveScorer(evalDef) {
   if (evalDef.scorer !== void 0) {
     return {
@@ -72473,7 +72473,7 @@ function resolveScorer(evalDef) {
   }
   return {
     kind: "vitest",
-    testsDir: path102.resolve(path102.join(evalDef.rootDir, evalDef.oracle.path, "tests"))
+    testsDir: path103.resolve(path103.join(evalDef.rootDir, evalDef.oracle.path, "tests"))
   };
 }
 var init_types9 = __esm({
@@ -72484,15 +72484,15 @@ var init_types9 = __esm({
 
 // packages/agent-eval/src/run/vitest-runner.ts
 import { randomUUID as randomUUID12 } from "node:crypto";
-import { readFile as readFile30, unlink as unlink16 } from "node:fs/promises";
+import { readFile as readFile31, unlink as unlink16 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import path103 from "node:path";
+import path104 from "node:path";
 import { createRequire } from "node:module";
 async function runVitest(input) {
   return runVitestWithRunner(createHostRunner(), input);
 }
 async function runVitestWithRunner(runner, input) {
-  const outputFile = path103.join(tmpdir2(), `poe-code-vitest-${process.pid}-${randomUUID12()}.json`);
+  const outputFile = path104.join(tmpdir2(), `poe-code-vitest-${process.pid}-${randomUUID12()}.json`);
   const timeoutMs = input.timeoutMs ?? defaultTimeoutMs;
   assertValidTimeout2(timeoutMs);
   const handle = runner.exec(createVitestRunSpec(input, outputFile));
@@ -72501,8 +72501,8 @@ async function runVitestWithRunner(runner, input) {
   try {
     const runResult = await waitForVitest(handle, timeoutMs, input.signal);
     await Promise.all([stdout, stderr]);
-    const raw = await readFile30(outputFile, "utf8");
-    const cases = mapVitestCases(JSON.parse(raw), path103.resolve(input.testsDir));
+    const raw = await readFile31(outputFile, "utf8");
+    const cases = mapVitestCases(JSON.parse(raw), path104.resolve(input.testsDir));
     if (runResult.exitCode !== 0 && cases.every((result) => result.passed)) {
       throw new VitestError(`Vitest exited with code ${runResult.exitCode}.`);
     }
@@ -72528,13 +72528,13 @@ function createVitestRunSpec(input, outputFile) {
       resolveVitestBin(),
       "run",
       "--root",
-      path103.resolve(input.testsDir),
+      path104.resolve(input.testsDir),
       "--reporter=json",
       "--outputFile",
       outputFile
     ],
-    cwd: path103.resolve(input.testsDir),
-    env: createVitestEnv(path103.resolve(input.cloneDir), path103.resolve(input.oracleDir)),
+    cwd: path104.resolve(input.testsDir),
+    env: createVitestEnv(path104.resolve(input.cloneDir), path104.resolve(input.oracleDir)),
     stdout: "pipe",
     stderr: "pipe",
     signal: input.signal
@@ -72542,7 +72542,7 @@ function createVitestRunSpec(input, outputFile) {
 }
 function resolveVitestBin() {
   const packageJsonPath = require2.resolve("vitest/package.json");
-  return path103.join(path103.dirname(path103.dirname(packageJsonPath)), ".bin", "vitest");
+  return path104.join(path104.dirname(path104.dirname(packageJsonPath)), ".bin", "vitest");
 }
 function createVitestEnv(cloneDir, oracleDir) {
   const env = Object.fromEntries(
@@ -72618,8 +72618,8 @@ function formatFileName(fileName, testsDir) {
   if (typeof fileName !== "string" || fileName.length === 0) {
     return "<unknown>";
   }
-  const relative6 = path103.relative(testsDir, fileName);
-  if (relative6.length === 0 || relative6.startsWith("..") || path103.isAbsolute(relative6)) {
+  const relative6 = path104.relative(testsDir, fileName);
+  if (relative6.length === 0 || relative6.startsWith("..") || path104.isAbsolute(relative6)) {
     return normalizePath2(fileName);
   }
   return normalizePath2(relative6);
@@ -72640,7 +72640,7 @@ function failureMessage(assertion) {
   return typeof assertion.message === "string" && assertion.message.length > 0 ? assertion.message : void 0;
 }
 function normalizePath2(fileName) {
-  return fileName.split(path103.sep).join("/");
+  return fileName.split(path104.sep).join("/");
 }
 function drainStream(stream) {
   if (stream === null) {
@@ -72684,17 +72684,17 @@ var init_vitest_runner = __esm({
 });
 
 // packages/agent-eval/src/run/scorer.ts
-import { readFile as readFile31 } from "node:fs/promises";
-import path104 from "node:path";
+import { readFile as readFile32 } from "node:fs/promises";
+import path105 from "node:path";
 async function runScorer(input) {
   const scorer = resolveScorer(input.evalDef);
-  const absoluteEvalDir = path104.resolve(input.evalDir);
-  const absoluteCloneDir = path104.resolve(input.cloneDir);
+  const absoluteEvalDir = path105.resolve(input.evalDir);
+  const absoluteCloneDir = path105.resolve(input.cloneDir);
   const oracleDir = resolveContainedPath(absoluteEvalDir, input.evalDef.oracle.path, "oracle.path");
   await assertCanonicalContainedPath(absoluteEvalDir, oracleDir, "oracle.path");
   if (scorer.kind === "vitest") {
     return runVitest({
-      testsDir: path104.join(oracleDir, "tests"),
+      testsDir: path105.join(oracleDir, "tests"),
       cloneDir: absoluteCloneDir,
       oracleDir,
       timeoutMs: defaultVitestTimeoutMs,
@@ -72785,7 +72785,7 @@ function createScorerEnv(cloneDir, oracleDir) {
 }
 async function readScorerResult(resultPath, result) {
   try {
-    return await readFile31(resultPath, "utf8");
+    return await readFile32(resultPath, "utf8");
   } catch (error3) {
     if (isMissingFileError7(error3)) {
       if (result.exitCode !== 0) {
@@ -72923,16 +72923,16 @@ var init_scorer = __esm({
 
 // packages/agent-eval/src/check/check.ts
 import { cp, mkdir as mkdir25, stat as stat21 } from "node:fs/promises";
-import path105 from "node:path";
+import path106 from "node:path";
 async function evalCheck(opts) {
   const startedAt = Date.now();
   const source = await openSource(opts.sourceDir);
   const evalDef = await loadEval(source, opts.evalId);
   const config = await loadSourceConfig(source);
   const outDir = resolveOutputDirectory(source.rootDir, config.out);
-  const cloneDir = path105.join(outDir, ".check", opts.evalId, isoUtcSafe(/* @__PURE__ */ new Date()), "clone");
+  const cloneDir = path106.join(outDir, ".check", opts.evalId, isoUtcSafe(/* @__PURE__ */ new Date()), "clone");
   opts.signal?.throwIfAborted();
-  await mkdir25(path105.dirname(cloneDir), { recursive: true });
+  await mkdir25(path106.dirname(cloneDir), { recursive: true });
   await cloneTarget({
     repo: evalDef.target.repo,
     ref: evalDef.target.ref,
@@ -72940,12 +72940,12 @@ async function evalCheck(opts) {
     signal: opts.signal
   });
   opts.signal?.throwIfAborted();
-  const evalDir = path105.join(source.rootDir, opts.evalId);
+  const evalDir = path106.join(source.rootDir, opts.evalId);
   const oracleDir = resolveContainedPath(evalDir, evalDef.oracle.path, "oracle.path");
-  await copyDirectoryIfPresent(path105.join(evalDir, "starter"), cloneDir);
+  await copyDirectoryIfPresent(path106.join(evalDir, "starter"), cloneDir);
   opts.signal?.throwIfAborted();
   await copyOracleSolution({
-    solutionDir: path105.join(oracleDir, "solution"),
+    solutionDir: path106.join(oracleDir, "solution"),
     cloneDir,
     solutionDest: evalDef.oracle.solutionDest
   });
@@ -72964,7 +72964,7 @@ async function evalCheck(opts) {
   };
 }
 function resolveOutputDirectory(sourceDir, outDir) {
-  return path105.isAbsolute(outDir) ? outDir : path105.resolve(sourceDir, outDir);
+  return path106.isAbsolute(outDir) ? outDir : path106.resolve(sourceDir, outDir);
 }
 function isoUtcSafe(now) {
   return now.toISOString().replace(/[:.]/g, "-");
@@ -72996,12 +72996,12 @@ async function copyOracleSolution(input) {
   });
 }
 function resolveCloneRelativePath(cloneDir, relativePath) {
-  if (path105.isAbsolute(relativePath)) {
+  if (path106.isAbsolute(relativePath)) {
     throw new Error(`oracle.solution_dest must be relative to the clone root.`);
   }
-  const resolved = path105.resolve(cloneDir, relativePath);
-  const relative6 = path105.relative(cloneDir, resolved);
-  if (relative6 === ".." || relative6.startsWith(`..${path105.sep}`)) {
+  const resolved = path106.resolve(cloneDir, relativePath);
+  const relative6 = path106.relative(cloneDir, resolved);
+  if (relative6 === ".." || relative6.startsWith(`..${path106.sep}`)) {
     throw new Error(`oracle.solution_dest must stay within the clone root.`);
   }
   return resolved;
@@ -73023,15 +73023,15 @@ var init_check = __esm({
 
 // packages/agent-eval/src/init/init.ts
 import { lstat as lstat24, mkdir as mkdir26, rm as rm7, writeFile as writeFile20 } from "node:fs/promises";
-import path106 from "node:path";
+import path107 from "node:path";
 import { stringify as stringifyYaml3 } from "yaml";
 async function evalInit(opts) {
   validateInitName(opts.name);
-  if (!path106.isAbsolute(opts.sourceDir)) {
+  if (!path107.isAbsolute(opts.sourceDir)) {
     throw new Error("sourceDir must be absolute.");
   }
   await assertSafeSourceDirectory(opts.sourceDir);
-  const evalDir = path106.join(opts.sourceDir, opts.name);
+  const evalDir = path107.join(opts.sourceDir, opts.name);
   try {
     await mkdir26(evalDir);
   } catch (error3) {
@@ -73041,15 +73041,15 @@ async function evalInit(opts) {
     throw error3;
   }
   try {
-    await mkdir26(path106.join(evalDir, "oracle", "tests"), { recursive: true });
-    await mkdir26(path106.join(evalDir, "oracle", "solution"), { recursive: true });
-    await mkdir26(path106.join(evalDir, "starter"), { recursive: true });
+    await mkdir26(path107.join(evalDir, "oracle", "tests"), { recursive: true });
+    await mkdir26(path107.join(evalDir, "oracle", "solution"), { recursive: true });
+    await mkdir26(path107.join(evalDir, "starter"), { recursive: true });
     const writes = await Promise.allSettled([
-      writeFile20(path106.join(evalDir, "eval.yaml"), renderEvalYaml(opts)),
-      writeFile20(path106.join(evalDir, "plan.md"), renderPlanMarkdown(opts.kind)),
-      writeFile20(path106.join(evalDir, "oracle", "tests", "example.test.ts"), renderExampleTest()),
-      writeFile20(path106.join(evalDir, "oracle", "solution", "OUTPUT.md"), "ok\n"),
-      writeFile20(path106.join(evalDir, "starter", ".gitkeep"), "")
+      writeFile20(path107.join(evalDir, "eval.yaml"), renderEvalYaml(opts)),
+      writeFile20(path107.join(evalDir, "plan.md"), renderPlanMarkdown(opts.kind)),
+      writeFile20(path107.join(evalDir, "oracle", "tests", "example.test.ts"), renderExampleTest()),
+      writeFile20(path107.join(evalDir, "oracle", "solution", "OUTPUT.md"), "ok\n"),
+      writeFile20(path107.join(evalDir, "starter", ".gitkeep"), "")
     ]);
     const failedWrite = writes.find((result) => result.status === "rejected");
     if (failedWrite !== void 0) {
@@ -73228,12 +73228,12 @@ var init_init = __esm({
 
 // packages/agent-eval/src/lint/lint.ts
 import nodeFs14 from "node:fs/promises";
-import path107 from "node:path";
+import path108 from "node:path";
 import { parse as parseYaml6 } from "yaml";
 async function evalLint(input) {
   assertSafeEvalId(input.evalId);
   const fs27 = nodeFs14;
-  const evalDir = path107.join(input.sourceDir, input.evalId);
+  const evalDir = path108.join(input.sourceDir, input.evalId);
   const issues = [];
   const parsedEvalYaml = await lintEvalYaml(evalDir, issues, fs27);
   const frontmatter = await lintPlan(evalDir, issues, fs27);
@@ -73243,10 +73243,10 @@ async function evalLint(input) {
       severity: "error",
       code: "E003",
       message: `plan.md frontmatter kind must be one of: ${allowedPlanKinds2.join(", ")}.`,
-      path: path107.join(evalDir, "plan.md")
+      path: path108.join(evalDir, "plan.md")
     });
   }
-  const oracleDir = path107.join(evalDir, oraclePath);
+  const oracleDir = path108.join(evalDir, oraclePath);
   if (!await isDirectory3(oracleDir, fs27)) {
     issues.push({
       severity: "error",
@@ -73256,24 +73256,24 @@ async function evalLint(input) {
     });
   }
   const hasScorerCommand = readScorerCommand(parsedEvalYaml.valid, parsedEvalYaml.raw) !== void 0;
-  const hasOracleTests = await hasDefaultOracleTests(path107.join(oracleDir, "tests"), fs27);
+  const hasOracleTests = await hasDefaultOracleTests(path108.join(oracleDir, "tests"), fs27);
   if (!hasScorerCommand && !hasOracleTests) {
     issues.push({
       severity: "error",
       code: "E005",
       message: "No scorer.command and no oracle/tests/*.test.ts files found.",
-      path: path107.join(oracleDir, "tests")
+      path: path108.join(oracleDir, "tests")
     });
   }
-  if (!await hasDirectoryEntries(path107.join(oracleDir, "solution"), fs27)) {
+  if (!await hasDirectoryEntries(path108.join(oracleDir, "solution"), fs27)) {
     issues.push({
       severity: "warning",
       code: "W001",
       message: `${oraclePath}/solution/ is missing or empty; eval check will fail.`,
-      path: path107.join(oracleDir, "solution")
+      path: path108.join(oracleDir, "solution")
     });
   }
-  const starterDir = path107.join(evalDir, "starter");
+  const starterDir = path108.join(evalDir, "starter");
   if (await isDirectory3(starterDir, fs27) && !await hasDirectoryEntries(starterDir, fs27)) {
     issues.push({
       severity: "warning",
@@ -73288,7 +73288,7 @@ async function evalLint(input) {
       severity: "warning",
       code: "W003",
       message: "budget.wall_clock_ms is below 60000 and is likely too short.",
-      path: path107.join(evalDir, "eval.yaml")
+      path: path108.join(evalDir, "eval.yaml")
     });
   }
   const targetRef = readTargetRef(parsedEvalYaml.valid, parsedEvalYaml.raw);
@@ -73297,7 +73297,7 @@ async function evalLint(input) {
       severity: "warning",
       code: "W004",
       message: `target.ref "${targetRef}" is not a full commit SHA; pin it to a commit SHA.`,
-      path: path107.join(evalDir, "eval.yaml")
+      path: path108.join(evalDir, "eval.yaml")
     });
   }
   return {
@@ -73306,8 +73306,8 @@ async function evalLint(input) {
   };
 }
 async function lintEvalYaml(evalDir, issues, fs27) {
-  const evalYamlPath = path107.join(evalDir, "eval.yaml");
-  if (!await assertFsCanonicalContainedPathIfPresent(fs27, path107.dirname(evalDir), evalYamlPath, "eval.yaml")) {
+  const evalYamlPath = path108.join(evalDir, "eval.yaml");
+  if (!await assertFsCanonicalContainedPathIfPresent(fs27, path108.dirname(evalDir), evalYamlPath, "eval.yaml")) {
     issues.push({ severity: "error", code: "E001", message: "eval.yaml is missing.", path: evalYamlPath });
     return { raw: void 0, valid: void 0 };
   }
@@ -73339,8 +73339,8 @@ async function lintEvalYaml(evalDir, issues, fs27) {
   }
 }
 async function lintPlan(evalDir, issues, fs27) {
-  const planPath = path107.join(evalDir, "plan.md");
-  if (!await assertFsCanonicalContainedPathIfPresent(fs27, path107.dirname(evalDir), planPath, "plan.md")) {
+  const planPath = path108.join(evalDir, "plan.md");
+  if (!await assertFsCanonicalContainedPathIfPresent(fs27, path108.dirname(evalDir), planPath, "plan.md")) {
     issues.push({ severity: "error", code: "E002", message: "plan.md is missing.", path: planPath });
     return void 0;
   }
@@ -73527,11 +73527,11 @@ var init_lint = __esm({
 });
 
 // packages/agent-eval/src/report/load.ts
-import { readdir as readdir22, readFile as readFile32, realpath as realpath6 } from "node:fs/promises";
-import path108 from "node:path";
+import { readdir as readdir22, readFile as readFile33, realpath as realpath7 } from "node:fs/promises";
+import path109 from "node:path";
 async function loadRunResult(runId, outDir = defaultOutDir) {
   assertValidRunId(runId);
-  const directPath = path108.join(outDir, runId, resultFileName);
+  const directPath = path109.join(outDir, runId, resultFileName);
   try {
     await assertCanonicalOutputFile(outDir, directPath);
     return enrichMatchedRunResult(runId, directPath);
@@ -73562,7 +73562,7 @@ async function loadLatestMatrix(outDir = defaultOutDir) {
     if (!entry.isDirectory() || !hasTimestampPrefix(entry.name)) {
       continue;
     }
-    const matrixDir = path108.join(outDir, entry.name);
+    const matrixDir = path109.join(outDir, entry.name);
     const aggregateFiles = await listAggregateFiles(matrixDir);
     if (aggregateFiles.length > 0) {
       matrices.push({
@@ -73577,9 +73577,9 @@ async function loadLatestMatrix(outDir = defaultOutDir) {
   }
   const cells = await Promise.all(
     latest.aggregateFiles.map(async (fileName) => {
-      const filePath = path108.join(outDir, latest.matrixId, fileName);
-      const cell = parseJson2(await readFile32(filePath, "utf8"), filePath);
-      return enrichAggregatedCell(cell, path108.join(outDir, latest.matrixId));
+      const filePath = path109.join(outDir, latest.matrixId, fileName);
+      const cell = parseJson2(await readFile33(filePath, "utf8"), filePath);
+      return enrichAggregatedCell(cell, path109.join(outDir, latest.matrixId));
     })
   );
   return {
@@ -73603,11 +73603,11 @@ async function enrichAggregatedCell(cell, outDir) {
   }
 }
 async function enrichMatchedRunResult(runId, resultPath) {
-  const result = parseJson2(await readFile32(resultPath, "utf8"), resultPath);
+  const result = parseJson2(await readFile33(resultPath, "utf8"), resultPath);
   if (result.runId !== runId) {
     throw new Error(`Run result "${runId}" embeds mismatched runId "${result.runId}"`);
   }
-  return enrichRunResult(result, path108.dirname(resultPath));
+  return enrichRunResult(result, path109.dirname(resultPath));
 }
 function matchesCell(result, cell) {
   return result.eval === cell.eval && result.agent === cell.agent && result.model === cell.model && result.planKind === cell.planKind;
@@ -73622,8 +73622,8 @@ async function collectRunResults(dir, entries, results) {
   const hasResult = entries.some((entry) => entry.isFile() && entry.name === resultFileName);
   if (hasResult) {
     results.push({
-      runId: path108.basename(dir),
-      resultPath: path108.join(dir, resultFileName)
+      runId: path109.basename(dir),
+      resultPath: path109.join(dir, resultFileName)
     });
     return;
   }
@@ -73631,7 +73631,7 @@ async function collectRunResults(dir, entries, results) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const childDir = path108.join(dir, entry.name);
+    const childDir = path109.join(dir, entry.name);
     const childEntries = await readDir(childDir);
     await collectRunResults(childDir, childEntries, results);
   }
@@ -73669,13 +73669,13 @@ async function enrichRunResult(result, runDir) {
   }
   return {
     ...result,
-    trace: await loadTraceSummary(path108.join(runDir, "trace.json"), path108.dirname(runDir))
+    trace: await loadTraceSummary(path109.join(runDir, "trace.json"), path109.dirname(runDir))
   };
 }
 async function loadTraceSummary(tracePath, outDir) {
   try {
     await assertCanonicalOutputFile(outDir, tracePath);
-    const trace = parseJson2(await readFile32(tracePath, "utf8"), tracePath);
+    const trace = parseJson2(await readFile33(tracePath, "utf8"), tracePath);
     return {
       available: true,
       eventCount: trace.events.length,
@@ -73690,15 +73690,15 @@ async function loadTraceSummary(tracePath, outDir) {
   }
 }
 async function assertCanonicalOutputFile(outDir, filePath) {
-  const canonicalOutDir = await realpath6(path108.resolve(outDir));
-  const canonicalFilePath = await realpath6(filePath);
-  const relative6 = path108.relative(canonicalOutDir, canonicalFilePath);
-  if (relative6 === ".." || relative6.startsWith(`..${path108.sep}`)) {
+  const canonicalOutDir = await realpath7(path109.resolve(outDir));
+  const canonicalFilePath = await realpath7(filePath);
+  const relative6 = path109.relative(canonicalOutDir, canonicalFilePath);
+  if (relative6 === ".." || relative6.startsWith(`..${path109.sep}`)) {
     throw new Error("run result must stay within the canonical output directory.");
   }
 }
 function assertValidRunId(runId) {
-  if (runId.length === 0 || runId === "." || runId === ".." || path108.isAbsolute(runId) || path108.win32.isAbsolute(runId) || runId.includes("/") || runId.includes("\\")) {
+  if (runId.length === 0 || runId === "." || runId === ".." || path109.isAbsolute(runId) || path109.win32.isAbsolute(runId) || runId.includes("/") || runId.includes("\\")) {
     throw new Error(`Invalid run id "${runId}"`);
   }
 }
@@ -73867,14 +73867,14 @@ var init_budget = __esm({
 
 // packages/agent-eval/src/run/cheat.ts
 import os14 from "node:os";
-import path109 from "node:path";
+import path110 from "node:path";
 function canContainNewEvidence(event) {
   return event.id !== void 0 || event.phase === "start" || event.paths.length > 0 || event.inspection !== void 0;
 }
 function defaultAllowedPaths() {
   const allowedPaths = [
     os14.tmpdir(),
-    path109.join(os14.homedir(), ".cache"),
+    path110.join(os14.homedir(), ".cache"),
     "/usr/bin",
     "/usr/local/bin",
     "/bin"
@@ -73891,17 +73891,17 @@ function isUninspectableOperation(operation) {
   return isObservedOperation(operation);
 }
 function resolveAgainstClone(cloneDir, targetPath) {
-  if (path109.isAbsolute(targetPath)) {
-    return path109.resolve(targetPath);
+  if (path110.isAbsolute(targetPath)) {
+    return path110.resolve(targetPath);
   }
-  return path109.resolve(cloneDir, targetPath);
+  return path110.resolve(cloneDir, targetPath);
 }
 function isUnderAny(targetPath, roots) {
   return roots.some((root) => isUnderPath(targetPath, root));
 }
 function isUnderPath(targetPath, rootPath) {
-  const relative6 = path109.relative(rootPath, targetPath);
-  return relative6 === "" || !relative6.startsWith("..") && !path109.isAbsolute(relative6);
+  const relative6 = path110.relative(rootPath, targetPath);
+  return relative6 === "" || !relative6.startsWith("..") && !path110.isAbsolute(relative6);
 }
 var CheatFilter;
 var init_cheat = __esm({
@@ -73914,8 +73914,8 @@ var init_cheat = __esm({
       uninspectable = [];
       observedEvidence = /* @__PURE__ */ new Set();
       constructor(input) {
-        this.cloneDir = path109.resolve(input.cloneDir);
-        this.allowedPaths = defaultAllowedPaths().concat(input.allowedPaths ?? []).map((allowedPath) => path109.resolve(allowedPath));
+        this.cloneDir = path110.resolve(input.cloneDir);
+        this.allowedPaths = defaultAllowedPaths().concat(input.allowedPaths ?? []).map((allowedPath) => path110.resolve(allowedPath));
       }
       onEvent(event) {
         if (!isObservedOperation(event.operation) || !canContainNewEvidence(event)) {
@@ -74032,7 +74032,7 @@ var init_dispatch = __esm({
 
 // packages/agent-eval/src/run/judge.ts
 import * as fs10 from "node:fs/promises";
-import path110 from "node:path";
+import path111 from "node:path";
 async function judgeRun(input) {
   const judgeAgent = input.spec.agent === input.agentUnderTest ? "codex" : input.spec.agent;
   const rubric = [...input.spec.rubric];
@@ -74118,7 +74118,7 @@ async function buildMetricJudgePrompt(input) {
   ].join("\n");
 }
 async function listFilesWithSizes(cloneDir) {
-  const absoluteCloneDir = path110.resolve(cloneDir);
+  const absoluteCloneDir = path111.resolve(cloneDir);
   const files = [];
   await collectFiles(absoluteCloneDir, absoluteCloneDir, files);
   return files.sort((left, right) => left.path.localeCompare(right.path));
@@ -74126,7 +74126,7 @@ async function listFilesWithSizes(cloneDir) {
 async function collectFiles(rootDir, currentDir2, files) {
   const entries = await fs10.readdir(currentDir2, { withFileTypes: true });
   for (const entry of entries) {
-    const absolutePath = path110.join(currentDir2, entry.name);
+    const absolutePath = path111.join(currentDir2, entry.name);
     if (entry.isDirectory()) {
       await collectFiles(rootDir, absolutePath, files);
       continue;
@@ -74136,7 +74136,7 @@ async function collectFiles(rootDir, currentDir2, files) {
     }
     const stat33 = await fs10.stat(absolutePath);
     files.push({
-      path: path110.relative(rootDir, absolutePath),
+      path: path111.relative(rootDir, absolutePath),
       bytes: stat33.size
     });
   }
@@ -74409,7 +74409,7 @@ var init_metrics = __esm({
 });
 
 // packages/agent-eval/src/run/oracle.ts
-import path111 from "node:path";
+import path112 from "node:path";
 async function verifyOracle(source, id) {
   const evalDef = await loadEval(source, id);
   if (evalDef.verify === void 0) {
@@ -74418,8 +74418,8 @@ async function verifyOracle(source, id) {
       output: "no verify command configured"
     };
   }
-  const evalDir = path111.resolve(source.rootDir, id);
-  const oracleDir = path111.join(evalDir, "oracle");
+  const evalDir = path112.resolve(source.rootDir, id);
+  const oracleDir = path112.join(evalDir, "oracle");
   await assertCanonicalContainedPath(evalDir, oracleDir, "oracle.path");
   const result = await runVerifyCommand(createHostRunner(), {
     command: evalDef.verify.command,
@@ -74920,17 +74920,17 @@ var init_normalize = __esm({
 
 // packages/agent-eval/src/run/result-writer.ts
 import { randomUUID as randomUUID13 } from "node:crypto";
-import { lstat as lstat25, mkdir as mkdir27, readFile as readFile33, rename as rename20, rm as rm8, writeFile as writeFile21 } from "node:fs/promises";
-import path112 from "node:path";
+import { lstat as lstat25, mkdir as mkdir27, readFile as readFile34, rename as rename20, rm as rm8, writeFile as writeFile21 } from "node:fs/promises";
+import path113 from "node:path";
 async function writeRunEvidence(runDir, parts) {
   await assertSafeRunDirectory(runDir);
   await mkdir27(runDir, { recursive: true });
   const filePaths = [
-    path112.join(runDir, "events.jsonl"),
-    path112.join(runDir, "trace.json"),
-    path112.join(runDir, "cheat-report.json"),
-    path112.join(runDir, "plan.md"),
-    path112.join(runDir, "eval.yaml")
+    path113.join(runDir, "events.jsonl"),
+    path113.join(runDir, "trace.json"),
+    path113.join(runDir, "cheat-report.json"),
+    path113.join(runDir, "plan.md"),
+    path113.join(runDir, "eval.yaml")
   ];
   const priorContents = await Promise.all(filePaths.map((filePath) => readExistingFile(filePath)));
   const committedPaths = [];
@@ -74967,12 +74967,12 @@ async function assertSafeRunDirectory(runDir) {
   }
 }
 async function writeRunCompletion(runDir, parts) {
-  const resultPath = path112.join(runDir, "result.json");
+  const resultPath = path113.join(runDir, "result.json");
   const priorResult = await readExistingFile(resultPath);
   await writeRunResult(runDir, parts.result);
   try {
     if (parts.judge !== void 0) {
-      await atomicWrite(path112.join(runDir, "judge.json"), `${JSON.stringify(parts.judge, null, 2)}
+      await atomicWrite(path113.join(runDir, "judge.json"), `${JSON.stringify(parts.judge, null, 2)}
 `);
     }
   } catch (error3) {
@@ -74981,13 +74981,13 @@ async function writeRunCompletion(runDir, parts) {
   }
 }
 async function writeRunResult(runDir, result) {
-  await atomicWrite(path112.join(runDir, "result.json"), `${JSON.stringify(result, null, 2)}
+  await atomicWrite(path113.join(runDir, "result.json"), `${JSON.stringify(result, null, 2)}
 `);
 }
 async function atomicWrite(filePath, content) {
-  const tempPath = path112.join(
-    path112.dirname(filePath),
-    `.${path112.basename(filePath)}.${process.pid}.${randomUUID13()}.tmp`
+  const tempPath = path113.join(
+    path113.dirname(filePath),
+    `.${path113.basename(filePath)}.${process.pid}.${randomUUID13()}.tmp`
   );
   try {
     await writeFile21(tempPath, content, "utf8");
@@ -75009,7 +75009,7 @@ function isMissingPath10(error3) {
 }
 async function readExistingFile(filePath) {
   try {
-    return await readFile33(filePath, "utf8");
+    return await readFile34(filePath, "utf8");
   } catch (error3) {
     if (isMissingPath10(error3)) {
       return void 0;
@@ -75031,8 +75031,8 @@ var init_result_writer = __esm({
 });
 
 // packages/agent-eval/src/run/run.ts
-import { cp as cp2, mkdir as mkdir28, readFile as readFile34, stat as stat23 } from "node:fs/promises";
-import path113 from "node:path";
+import { cp as cp2, mkdir as mkdir28, readFile as readFile35, stat as stat23 } from "node:fs/promises";
+import path114 from "node:path";
 async function runEval(opts) {
   const startedAt = Date.now();
   const source = await openSource(opts.sourceDir);
@@ -75051,12 +75051,12 @@ ${oracleVerification.output}`);
     repeatIndex: opts.repeatIndex,
     now: /* @__PURE__ */ new Date()
   });
-  const runDir = path113.join(opts.outDir ?? "runs", runId);
-  await mkdir28(path113.dirname(runDir), { recursive: true });
+  const runDir = path114.join(opts.outDir ?? "runs", runId);
+  await mkdir28(path114.dirname(runDir), { recursive: true });
   {
     await mkdir28(runDir, { recursive: true });
     const controller = new AbortController();
-    const cloneDir = path113.join(runDir, "clone");
+    const cloneDir = path114.join(runDir, "clone");
     await cloneTarget({
       repo: evalDef.target.repo,
       ref: evalDef.target.ref,
@@ -75064,13 +75064,13 @@ ${oracleVerification.output}`);
       cacheDir: opts.cloneCacheDir,
       signal: controller.signal
     });
-    await copyStarterIfPresent(path113.join(source.rootDir, opts.evalId, "starter"), cloneDir);
-    const sourcePlanPath = path113.join(source.rootDir, opts.evalId, "plan.md");
-    const sourceEvalYamlPath = path113.join(source.rootDir, opts.evalId, "eval.yaml");
-    const planMd = await readFile34(sourcePlanPath, "utf8");
-    const evalYaml = await readFile34(sourceEvalYamlPath, "utf8");
-    const clonedPlanPath = path113.join(cloneDir, evalDef.target.planDest);
-    await mkdir28(path113.dirname(clonedPlanPath), { recursive: true });
+    await copyStarterIfPresent(path114.join(source.rootDir, opts.evalId, "starter"), cloneDir);
+    const sourcePlanPath = path114.join(source.rootDir, opts.evalId, "plan.md");
+    const sourceEvalYamlPath = path114.join(source.rootDir, opts.evalId, "eval.yaml");
+    const planMd = await readFile35(sourcePlanPath, "utf8");
+    const evalYaml = await readFile35(sourceEvalYamlPath, "utf8");
+    const clonedPlanPath = path114.join(cloneDir, evalDef.target.planDest);
+    await mkdir28(path114.dirname(clonedPlanPath), { recursive: true });
     await cp2(sourcePlanPath, clonedPlanPath);
     const events = [];
     const traceNormalizer = createTraceNormalizer();
@@ -75133,7 +75133,7 @@ ${oracleVerification.output}`);
     try {
       testsResult = await runScorer({
         evalDef,
-        evalDir: path113.join(source.rootDir, opts.evalId),
+        evalDir: path114.join(source.rootDir, opts.evalId),
         cloneDir
       });
     } catch (error3) {
@@ -75153,7 +75153,7 @@ ${oracleVerification.output}`);
           judgeResult = await judgeRun({
             evalDef,
             cloneDir,
-            traceJsonPath: path113.join(runDir, "trace.json"),
+            traceJsonPath: path114.join(runDir, "trace.json"),
             trace,
             testsResult,
             spec: judgeSpec,
@@ -75177,7 +75177,7 @@ ${oracleVerification.output}`);
       metricResults = await executeMetrics({
         evalDef,
         cloneDir,
-        traceJsonPath: path113.join(runDir, "trace.json"),
+        traceJsonPath: path114.join(runDir, "trace.json"),
         trace,
         oracleOutcome: testsResult,
         agentUnderTest: opts.agent,
@@ -75572,7 +75572,7 @@ var init_run3 = __esm({
 
 // packages/agent-eval/src/run/matrix.ts
 import { mkdir as mkdir29, writeFile as writeFile22 } from "node:fs/promises";
-import path114 from "node:path";
+import path115 from "node:path";
 async function* runMatrix(opts) {
   assertNonEmpty("agents", opts.agents);
   assertNonEmpty("models", opts.models);
@@ -75581,7 +75581,7 @@ async function* runMatrix(opts) {
   const evalIds = opts.evalIds ?? await listEvals(source);
   const repeats = opts.repeats ?? defaultRepeats;
   assertPositiveInteger("repeats", repeats);
-  const matrixDir = path114.join(opts.outDir ?? "runs", matrixId);
+  const matrixDir = path115.join(opts.outDir ?? "runs", matrixId);
   await mkdir29(matrixDir, { recursive: true });
   for (const evalId of evalIds) {
     const evalDef = await loadEval(source, evalId);
@@ -75628,7 +75628,7 @@ async function runSingle(opts, context) {
       durationMs: Date.now() - startedAt,
       error: getErrorMessage5(error3)
     });
-    const runDir = path114.join(opts.outDir ?? "runs", result.runId);
+    const runDir = path115.join(opts.outDir ?? "runs", result.runId);
     await mkdir29(runDir, { recursive: true });
     await writeRunResult(runDir, result);
     return result;
@@ -75688,7 +75688,7 @@ function createErrorResult(opts, context) {
 }
 async function writeAggregate(matrixDir, evalId, agent3, model, aggregate) {
   await writeFile22(
-    path114.join(
+    path115.join(
       matrixDir,
       `aggregate-${evalId}-${safePathSegment(agent3)}-${safePathSegment(model)}.json`
     ),
@@ -75735,11 +75735,11 @@ var init_matrix = __esm({
 });
 
 // packages/agent-eval/src/cli/init.ts
-import path115 from "node:path";
+import path116 from "node:path";
 async function runInitCli(input) {
   try {
     validateInitName(input.name);
-    const sourceDir = path115.resolve(input.sourceDir ?? process.cwd());
+    const sourceDir = path116.resolve(input.sourceDir ?? process.cwd());
     const result = await evalInit({
       sourceDir,
       name: input.name,
@@ -75747,7 +75747,7 @@ async function runInitCli(input) {
       targetRepo: input.targetRepo,
       targetRef: input.targetRef
     });
-    process.stdout.write(`${path115.relative(sourceDir, result.evalDir)}
+    process.stdout.write(`${path116.relative(sourceDir, result.evalDir)}
 `);
     process.stdout.write(`next: poe-code eval check ${input.name}
 `);
@@ -75766,18 +75766,18 @@ var init_init2 = __esm({
 });
 
 // packages/agent-eval/src/cli/target.ts
-import path116 from "node:path";
+import path117 from "node:path";
 function resolveEvalCliTarget(input) {
   if (input.evalId !== ".") {
     return {
-      sourceDir: path116.resolve(input.sourceDir ?? process.cwd()),
+      sourceDir: path117.resolve(input.sourceDir ?? process.cwd()),
       evalId: input.evalId
     };
   }
-  const evalDir = path116.resolve(input.sourceDir ?? process.cwd());
+  const evalDir = path117.resolve(input.sourceDir ?? process.cwd());
   return {
-    sourceDir: path116.dirname(evalDir),
-    evalId: path116.basename(evalDir)
+    sourceDir: path117.dirname(evalDir),
+    evalId: path117.basename(evalDir)
   };
 }
 var init_target = __esm({
@@ -75865,7 +75865,7 @@ var init_check2 = __esm({
 
 // packages/agent-eval/src/cli/lint.ts
 import nodeFs15 from "node:fs/promises";
-import path117 from "node:path";
+import path118 from "node:path";
 async function runLintCli(input) {
   try {
     const target = resolveEvalCliTarget(input);
@@ -75929,7 +75929,7 @@ function formatIssuePath(issuePath, sourceDir) {
   if (issuePath === void 0 || sourceDir === void 0) {
     return issuePath ?? "";
   }
-  const relative6 = path117.relative(sourceDir, issuePath);
+  const relative6 = path118.relative(sourceDir, issuePath);
   if (relative6.length === 0) {
     return ".";
   }
@@ -76306,9 +76306,9 @@ var init_render_table = __esm({
 });
 
 // packages/agent-eval/src/cli/commands.ts
-import path118 from "node:path";
+import path119 from "node:path";
 function resolveOutputDirectory2(sourceDir, outDir) {
-  return path118.isAbsolute(outDir) ? outDir : path118.resolve(sourceDir, outDir);
+  return path119.isAbsolute(outDir) ? outDir : path119.resolve(sourceDir, outDir);
 }
 function readNoJudge(params) {
   return params.noJudge === true || params.judge === true;
@@ -76509,7 +76509,7 @@ var init_commands3 = __esm({
           );
           return null;
         }
-        const sourceDir = path118.resolve(params.cwd ?? process.cwd());
+        const sourceDir = path119.resolve(params.cwd ?? process.cwd());
         const source = await openSource(sourceDir);
         const config = await loadSourceConfig(source);
         const evalIds = params.eval ?? [...await listEvals(source)];
@@ -76549,7 +76549,7 @@ var init_commands3 = __esm({
         if (params.runId !== void 0 && params.allRuns === true) {
           throw new UserError("Use either run-id or --all-runs, not both.");
         }
-        const sourceDir = path118.resolve(params.cwd ?? process.cwd());
+        const sourceDir = path119.resolve(params.cwd ?? process.cwd());
         const source = await openSource(sourceDir);
         const config = await loadSourceConfig(source);
         const outDir = resolveOutputDirectory2(source.rootDir, params.out ?? config.out);
@@ -76852,7 +76852,7 @@ var init_execution_context = __esm({
 });
 
 // src/sdk/launch.ts
-import path119 from "node:path";
+import path120 from "node:path";
 import { spawnSync as spawnSync3 } from "node:child_process";
 async function startLaunch(options) {
   const homeDir = resolveHomeDir(options.homeDir);
@@ -76958,7 +76958,7 @@ async function runLaunchDaemon(options) {
   });
 }
 function resolveLaunchBaseDir(homeDir) {
-  return path119.join(homeDir, ".poe-code", "launch");
+  return path120.join(homeDir, ".poe-code", "launch");
 }
 function resolveHomeDir(homeDir) {
   if (homeDir) {
@@ -76974,7 +76974,7 @@ function normalizeLaunchSpec(spec10, baseDir) {
   if (locator.scheme !== "local") {
     return spec10;
   }
-  const cwd = path119.isAbsolute(locator.path) ? locator.path : path119.resolve(baseDir, locator.path);
+  const cwd = path120.isAbsolute(locator.path) ? locator.path : path120.resolve(baseDir, locator.path);
   return {
     ...spec10,
     cwd
@@ -78140,8 +78140,8 @@ var init_source_snippet = __esm({
 });
 
 // packages/toolcraft/src/cli.ts
-import { access as access6, lstat as lstat26, readFile as readFile35, rename as rename21, unlink as unlink17, writeFile as writeFile23 } from "node:fs/promises";
-import path121 from "node:path";
+import { access as access6, lstat as lstat26, readFile as readFile36, rename as rename21, unlink as unlink17, writeFile as writeFile23 } from "node:fs/promises";
+import path122 from "node:path";
 import {
   Command as CommanderCommand,
   CommanderError as CommanderError2,
@@ -78153,7 +78153,7 @@ function inferProgramName(argv) {
   if (typeof entrypoint !== "string" || entrypoint.length === 0) {
     return "toolcraft";
   }
-  const parsed = path121.parse(entrypoint);
+  const parsed = path122.parse(entrypoint);
   return parsed.name.length > 0 ? parsed.name : "toolcraft";
 }
 function normalizeRoots2(roots, argv) {
@@ -78210,11 +78210,11 @@ function formatSegment2(segment, casing) {
   const separator = casing === "snake" ? "_" : "-";
   return splitWords4(segment).join(separator);
 }
-function toOptionFlag(path154, casing) {
-  return `--${path154.map((segment) => formatSegment2(segment, casing)).join(".")}`;
+function toOptionFlag(path155, casing) {
+  return `--${path155.map((segment) => formatSegment2(segment, casing)).join(".")}`;
 }
-function toOptionAttribute(path154, casing) {
-  return path154.map((segment) => {
+function toOptionAttribute(path155, casing) {
+  return path155.map((segment) => {
     const formatted = formatSegment2(segment, casing);
     if (casing === "snake") {
       return formatted;
@@ -78225,23 +78225,23 @@ function toOptionAttribute(path154, casing) {
     ).join("");
   }).join(".");
 }
-function toDisplayPath(path154) {
-  return path154.join(".");
+function toDisplayPath(path155) {
+  return path155.join(".");
 }
-function toUnionKindControlPath(path154) {
-  if (path154.length === 0) {
+function toUnionKindControlPath(path155) {
+  if (path155.length === 0) {
     return ["kind"];
   }
-  const head = path154.slice(0, -1);
-  const tail = path154[path154.length - 1] ?? "";
+  const head = path155.slice(0, -1);
+  const tail = path155[path155.length - 1] ?? "";
   return [...head, `${tail}Kind`];
 }
-function toUnionKindDisplayPath(path154) {
-  if (path154.length === 0) {
+function toUnionKindDisplayPath(path155) {
+  if (path155.length === 0) {
     return "kind";
   }
-  const head = path154.slice(0, -1);
-  const tail = path154[path154.length - 1] ?? "";
+  const head = path155.slice(0, -1);
+  const tail = path155[path155.length - 1] ?? "";
   return [...head, `${tail}-kind`].join(".");
 }
 function createSyntheticEnumSchema(values) {
@@ -78257,14 +78257,14 @@ function getRequiredBranchFingerprint(branch, casing) {
   const requiredKeys = Object.entries(branch.shape).filter(([, schema2]) => schema2.kind !== "optional").map(([key2]) => formatSegment2(key2, casing)).sort();
   return requiredKeys.join("+");
 }
-function collectFields(schema2, casing, globalLongOptionFlags, path154 = [], inheritedOptional = false, variantContext) {
+function collectFields(schema2, casing, globalLongOptionFlags, path155 = [], inheritedOptional = false, variantContext) {
   const collected = {
     dynamicFields: [],
     fields: [],
     variants: []
   };
   for (const [key2, rawChildSchema] of Object.entries(schema2.shape)) {
-    const nextPath = [...path154, key2];
+    const nextPath = [...path155, key2];
     const runtimeOptional = inheritedOptional || rawChildSchema.kind === "optional";
     const childSchema = unwrapOptional4(rawChildSchema);
     const requiredWhenActive = rawChildSchema.kind !== "optional" && childSchema.default === void 0;
@@ -78445,9 +78445,9 @@ function collectFields(schema2, casing, globalLongOptionFlags, path154 = [], inh
   }
   return collected;
 }
-function toCommanderOptionAttribute(path154, casing, globalLongOptionFlags) {
-  const optionAttribute = toOptionAttribute(path154, casing);
-  const optionFlag = toOptionFlag(path154, casing);
+function toCommanderOptionAttribute(path155, casing, globalLongOptionFlags) {
+  const optionAttribute = toOptionAttribute(path155, casing);
+  const optionFlag = toOptionFlag(path155, casing);
   if (!globalLongOptionFlags.has(optionFlag)) {
     return optionAttribute;
   }
@@ -79415,10 +79415,10 @@ function parseDebugStackMode(value) {
     formatInvalidEnumMessage("--debug", String(value), ["raw"], { candidates: ["raw"] })
   );
 }
-function setNestedValue(target, path154, value) {
+function setNestedValue(target, path155, value) {
   let cursor = target;
-  for (let index = 0; index < path154.length - 1; index += 1) {
-    const segment = path154[index] ?? "";
+  for (let index = 0; index < path155.length - 1; index += 1) {
+    const segment = path155[index] ?? "";
     const existing = Object.prototype.hasOwnProperty.call(cursor, segment) ? cursor[segment] : void 0;
     if (typeof existing === "object" && existing !== null) {
       cursor = existing;
@@ -79433,7 +79433,7 @@ function setNestedValue(target, path154, value) {
     });
     cursor = next;
   }
-  const leaf = path154[path154.length - 1];
+  const leaf = path155[path155.length - 1];
   if (leaf !== void 0) {
     Object.defineProperty(cursor, leaf, {
       value,
@@ -79538,21 +79538,21 @@ async function withOutputFormat2(output, fn) {
 }
 function createFs3() {
   return {
-    readFile: async (path154, encoding = "utf8") => readFile35(path154, { encoding }),
-    writeFile: async (path154, contents) => {
-      await writeFile23(path154, contents);
+    readFile: async (path155, encoding = "utf8") => readFile36(path155, { encoding }),
+    writeFile: async (path155, contents) => {
+      await writeFile23(path155, contents);
     },
-    exists: async (path154) => {
+    exists: async (path155) => {
       try {
-        await access6(path154);
+        await access6(path155);
         return true;
       } catch {
         return false;
       }
     },
-    lstat: async (path154) => lstat26(path154),
+    lstat: async (path155) => lstat26(path155),
     rename: async (fromPath, toPath) => rename21(fromPath, toPath),
-    unlink: async (path154) => unlink17(path154)
+    unlink: async (path155) => unlink17(path155)
   };
 }
 function createEnv3(values = process.env) {
@@ -79568,9 +79568,9 @@ function isPlainObject6(value) {
 function hasFieldValue(value) {
   return value !== void 0;
 }
-function hasNestedField(fields, path154) {
+function hasNestedField(fields, path155) {
   return fields.some(
-    (field) => path154.length < field.path.length && path154.every((segment, index) => field.path[index] === segment)
+    (field) => path155.length < field.path.length && path155.every((segment, index) => field.path[index] === segment)
   );
 }
 function describeExpectedPresetValue(schema2) {
@@ -79650,7 +79650,7 @@ function validatePresetFieldValue(value, field, presetPath) {
 async function loadPresetValues(fields, presetPath) {
   let rawPreset;
   try {
-    rawPreset = await readFile35(presetPath, {
+    rawPreset = await readFile36(presetPath, {
       encoding: "utf8"
     });
   } catch (error3) {
@@ -79676,9 +79676,9 @@ async function loadPresetValues(fields, presetPath) {
   }
   const fieldByPath = new Map(fields.map((field) => [field.displayPath, field]));
   const presetValues = {};
-  function visitObject(current, path154) {
+  function visitObject(current, path155) {
     for (const [key2, value] of Object.entries(current)) {
-      const nextPath = [...path154, key2];
+      const nextPath = [...path155, key2];
       const displayPath = toDisplayPath(nextPath);
       const field = fieldByPath.get(displayPath);
       if (field !== void 0) {
@@ -79885,8 +79885,8 @@ function createFixtureService(definition) {
   );
 }
 function resolveFixturePath(commandPath) {
-  const parsed = path121.parse(commandPath);
-  return path121.join(parsed.dir, `${parsed.name}.fixture.json`);
+  const parsed = path122.parse(commandPath);
+  return path122.join(parsed.dir, `${parsed.name}.fixture.json`);
 }
 function selectFixtureScenario(scenarios, selector, fixturePath) {
   if (isNumericFixtureSelector(selector)) {
@@ -79917,7 +79917,7 @@ async function loadFixtureScenario(command, selector) {
   const fixturePath = resolveFixturePath(commandPath);
   let rawFixture;
   try {
-    rawFixture = await readFile35(fixturePath, {
+    rawFixture = await readFile36(fixturePath, {
       encoding: "utf8"
     });
   } catch {
@@ -80020,8 +80020,8 @@ function validateServices2(services) {
     }
   }
 }
-function getNestedValue(target, path154) {
-  return path154.reduce(
+function getNestedValue(target, path155) {
+  return path155.reduce(
     (current, segment) => current !== null && typeof current === "object" ? current[segment] : void 0,
     target
   );
@@ -81551,7 +81551,7 @@ var init_explorer_config2 = __esm({
 });
 
 // packages/maestro-tui/src/run.ts
-import path122 from "node:path";
+import path123 from "node:path";
 async function runMaestroTui(options = {}) {
   if (options.workflowPath !== void 0 && options.name !== void 0) {
     throw new Error("Cannot specify both workflowPath and name for Maestro.");
@@ -81570,7 +81570,7 @@ async function runMaestroTui(options = {}) {
 }
 async function openWorkflowTaskList(workflowPath) {
   const workflow = await loadWorkflow(workflowPath);
-  const cfg = resolveConfig2(workflow.config, path122.dirname(workflow.sourcePath));
+  const cfg = resolveConfig2(workflow.config, path123.dirname(workflow.sourcePath));
   return openTaskList(resolveConfiguredTaskListOptions(cfg));
 }
 var init_run4 = __esm({
@@ -81841,7 +81841,7 @@ var init_container2 = __esm({
 });
 
 // src/cli/commands/configure.ts
-import path123 from "node:path";
+import path124 from "node:path";
 function registerConfigureCommand(program, container) {
   const serviceNames = listServiceNames(container.registry.list());
   const serviceDescription = `Tool to configure${formatServiceList(serviceNames)}`;
@@ -82053,12 +82053,12 @@ function createOverlayFileSystem(base) {
     }
     return base.readFile(filePath, "utf8");
   };
-  async function readFile56(filePath, encoding) {
+  async function readFile57(filePath, encoding) {
     const content = await readOverlayText(filePath);
     return encoding ? content : Buffer.from(content);
   }
   const fs27 = {
-    readFile: readFile56,
+    readFile: readFile57,
     async writeFile(filePath, content, options) {
       await assertOverlayParentDirectory(filePath);
       if (options?.flag === "wx" && await overlayPathExists(filePath)) {
@@ -82080,7 +82080,7 @@ function createOverlayFileSystem(base) {
         let currentPath = directoryPath;
         while (!await overlayPathExists(currentPath)) {
           directories.add(currentPath);
-          const parentPath = path123.dirname(currentPath);
+          const parentPath = path124.dirname(currentPath);
           if (parentPath === currentPath) {
             break;
           }
@@ -82142,18 +82142,18 @@ function createOverlayFileSystem(base) {
         throw error3;
       }));
       for (const directory of directories) {
-        if (path123.dirname(directory) === directoryPath) {
-          entries.add(path123.basename(directory));
+        if (path124.dirname(directory) === directoryPath) {
+          entries.add(path124.basename(directory));
         }
       }
       for (const [filePath, content] of writes) {
-        if (path123.dirname(filePath) !== directoryPath) {
+        if (path124.dirname(filePath) !== directoryPath) {
           continue;
         }
         if (content === null) {
-          entries.delete(path123.basename(filePath));
+          entries.delete(path124.basename(filePath));
         } else {
-          entries.add(path123.basename(filePath));
+          entries.add(path124.basename(filePath));
         }
       }
       return [...entries];
@@ -82177,7 +82177,7 @@ function createOverlayFileSystem(base) {
     }
   };
   const assertOverlayParentDirectory = async (filePath) => {
-    const parentPath = path123.dirname(filePath);
+    const parentPath = path124.dirname(filePath);
     try {
       const parent = await fs27.stat(parentPath);
       if (!parent.isDirectory()) {
@@ -82192,14 +82192,14 @@ function createOverlayFileSystem(base) {
   };
   const assertNoOverlayFileAncestor = async (directoryPath) => {
     let currentPath = directoryPath;
-    while (currentPath !== path123.dirname(currentPath)) {
+    while (currentPath !== path124.dirname(currentPath)) {
       if (await overlayPathExists(currentPath)) {
         if (!(await fs27.stat(currentPath)).isDirectory()) {
           throw createFsError("ENOTDIR", currentPath);
         }
         return;
       }
-      currentPath = path123.dirname(currentPath);
+      currentPath = path124.dirname(currentPath);
     }
   };
   return {
@@ -82229,7 +82229,7 @@ function createOverlayFileSystem(base) {
     },
     async commit() {
       const sortedDirectories = [...directories].sort(
-        (left, right) => left.split(path123.sep).length - right.split(path123.sep).length
+        (left, right) => left.split(path124.sep).length - right.split(path124.sep).length
       );
       const createdDirectories = [];
       const originals = /* @__PURE__ */ new Map();
@@ -82633,7 +82633,7 @@ var init_runtime_options = __esm({
 });
 
 // src/cli/commands/spawn.ts
-import path124 from "node:path";
+import path125 from "node:path";
 import { Option as Option3 } from "commander";
 function registerSpawnCommand(program, container, options = {}) {
   const spawnServices = container.registry.list().filter((service) => typeof service.spawn === "function" || getSpawnConfig(service.name));
@@ -82974,7 +82974,7 @@ async function resolvePromptInput(input, fs27, baseDir) {
   if (rawPath.length === 0) {
     throw new ValidationError("prompt @<path> requires a file path after '@'");
   }
-  const filePath = path124.isAbsolute(rawPath) ? rawPath : path124.join(baseDir, rawPath);
+  const filePath = path125.isAbsolute(rawPath) ? rawPath : path125.join(baseDir, rawPath);
   try {
     const contents = await fs27.readFile(filePath, "utf8");
     return contents.trim();
@@ -82995,7 +82995,7 @@ async function resolveMcpSpawnInput(input, fs27, baseDir) {
   if (rawPath.length === 0) {
     throw new ValidationError("--mcp-servers @<path> requires a file path after '@'");
   }
-  const filePath = path124.isAbsolute(rawPath) ? rawPath : path124.join(baseDir, rawPath);
+  const filePath = path125.isAbsolute(rawPath) ? rawPath : path125.join(baseDir, rawPath);
   try {
     return await fs27.readFile(filePath, "utf8");
   } catch (error3) {
@@ -84019,9 +84019,9 @@ var init_command_not_found = __esm({
 
 // src/cli/commands/utils-symlink-ops.ts
 import { dirname as dirname7 } from "node:path";
-async function tryLstat(fs27, path154) {
+async function tryLstat(fs27, path155) {
   try {
-    return await fs27.lstat(path154);
+    return await fs27.lstat(path155);
   } catch (error3) {
     if (isNotFound(error3)) {
       return null;
@@ -84089,13 +84089,13 @@ async function rollbackSymlinkOps(fs27, appliedOps) {
     await fs27.rename(op.to, op.from);
   }
 }
-async function isSymlinkPointingTo(fs27, path154, expectedTarget) {
+async function isSymlinkPointingTo(fs27, path155, expectedTarget) {
   try {
-    const stats2 = await fs27.lstat(path154);
+    const stats2 = await fs27.lstat(path155);
     if (!stats2.isSymbolicLink()) {
       return false;
     }
-    return await fs27.readlink(path154) === expectedTarget;
+    return await fs27.readlink(path155) === expectedTarget;
   } catch (error3) {
     if (isNotFound(error3)) {
       return false;
@@ -84620,7 +84620,7 @@ var init_media_download = __esm({
 });
 
 // src/cli/commands/generate.ts
-import path125 from "node:path";
+import path126 from "node:path";
 function registerGenerateCommand(program, container) {
   const generate2 = program.command("generate").alias("g").description("Generate content via Poe API.").option("--model <model>", `Model identifier (default: ${DEFAULT_TEXT_MODEL})`).option(
     "--param <key=value>",
@@ -84893,11 +84893,11 @@ function getDefaultMimeType(type2) {
   return defaults[type2];
 }
 function resolveOutputPath(filename, cwd) {
-  if (path125.isAbsolute(filename)) {
+  if (path126.isAbsolute(filename)) {
     return { path: filename, label: filename };
   }
   return {
-    path: path125.join(cwd, filename),
+    path: path126.join(cwd, filename),
     label: `./${filename}`
   };
 }
@@ -85504,10 +85504,10 @@ var init_shapes = __esm({
 });
 
 // packages/agent-mcp-config/src/apply.ts
-import path126 from "node:path";
+import path127 from "node:path";
 import { isDeepStrictEqual } from "node:util";
 function getConfigDirectory(configPath) {
-  return path126.dirname(configPath);
+  return path127.dirname(configPath);
 }
 function isConfigObject6(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -86820,8 +86820,8 @@ var init_dashboard_loop_shared = __esm({
 });
 
 // src/cli/commands/pipeline.ts
-import path127 from "node:path";
-import { readFile as readFile36, stat as stat24 } from "node:fs/promises";
+import path128 from "node:path";
+import { readFile as readFile37, stat as stat24 } from "node:fs/promises";
 import { fileURLToPath as fileURLToPath10 } from "node:url";
 async function resolvePipelineCommandConfig(container, options = {}) {
   const [configDoc, pipelineYamlConfig] = await Promise.all([
@@ -86880,11 +86880,11 @@ function resolveMaxRuns(value) {
   return parsed;
 }
 function resolvePipelineInitSourcePath(container, sourcePath) {
-  const absolutePath = sourcePath.startsWith("~/") ? path127.join(container.env.homeDir, sourcePath.slice(2)) : path127.isAbsolute(sourcePath) ? sourcePath : path127.resolve(container.env.cwd, sourcePath);
+  const absolutePath = sourcePath.startsWith("~/") ? path128.join(container.env.homeDir, sourcePath.slice(2)) : path128.isAbsolute(sourcePath) ? sourcePath : path128.resolve(container.env.cwd, sourcePath);
   return {
     absolutePath,
     relativePath: sourcePath,
-    title: path127.basename(sourcePath, path127.extname(sourcePath))
+    title: path128.basename(sourcePath, path128.extname(sourcePath))
   };
 }
 function isActivityTimeoutError4(error3) {
@@ -87277,12 +87277,12 @@ async function runPipelineWithIntegrations(integrations, name, options) {
   return integrations?.traceRun("pipeline", name, () => runPipeline2(options)) ?? runPipeline2(options);
 }
 function resolvePipelinePaths(scope, cwd, homeDir) {
-  const rootPath = scope === "global" ? path127.join(homeDir, ".poe-code", "pipeline") : path127.join(cwd, ".poe-code", "pipeline");
+  const rootPath = scope === "global" ? path128.join(homeDir, ".poe-code", "pipeline") : path128.join(cwd, ".poe-code", "pipeline");
   const displayRoot = scope === "global" ? "~/.poe-code/pipeline" : ".poe-code/pipeline";
   return {
-    plansPath: path127.join(rootPath, "plans"),
-    stepsPath: path127.join(rootPath, "steps.yaml"),
-    legacyDefaultStepsPath: path127.join(rootPath, "steps", "default.yaml"),
+    plansPath: path128.join(rootPath, "plans"),
+    stepsPath: path128.join(rootPath, "steps.yaml"),
+    legacyDefaultStepsPath: path128.join(rootPath, "steps", "default.yaml"),
     displayPlansPath: `${displayRoot}/plans`,
     displayStepsPath: `${displayRoot}/steps.yaml`
   };
@@ -87293,16 +87293,16 @@ async function loadPipelineTemplates() {
   }
   const packageRoot = await findPackageRoot3(fileURLToPath10(import.meta.url));
   const templateRoots = [
-    path127.join(packageRoot, "src", "templates", "pipeline"),
-    path127.join(packageRoot, "dist", "templates", "pipeline")
+    path128.join(packageRoot, "src", "templates", "pipeline"),
+    path128.join(packageRoot, "dist", "templates", "pipeline")
   ];
   for (const templateRoot of templateRoots) {
     if (!await pathExistsOnDisk(templateRoot)) {
       continue;
     }
     const [skillPlan, steps] = await Promise.all([
-      readFile36(path127.join(templateRoot, "SKILL_plan.md"), "utf8"),
-      readFile36(path127.join(templateRoot, "steps.yaml.mustache"), "utf8")
+      readFile37(path128.join(templateRoot, "SKILL_plan.md"), "utf8"),
+      readFile37(path128.join(templateRoot, "steps.yaml.mustache"), "utf8")
     ]);
     pipelineTemplatesCache = { skillPlan, steps };
     return pipelineTemplatesCache;
@@ -87321,12 +87321,12 @@ async function pathExistsOnDisk(targetPath) {
   }
 }
 async function findPackageRoot3(entryFilePath) {
-  let currentPath = path127.dirname(entryFilePath);
+  let currentPath = path128.dirname(entryFilePath);
   while (true) {
-    if (await pathExistsOnDisk(path127.join(currentPath, "package.json"))) {
+    if (await pathExistsOnDisk(path128.join(currentPath, "package.json"))) {
       return currentPath;
     }
-    const parentPath = path127.dirname(currentPath);
+    const parentPath = path128.dirname(currentPath);
     if (parentPath === currentPath) {
       throw new Error("Unable to locate package root for Pipeline templates.");
     }
@@ -87664,11 +87664,11 @@ function registerPipelineCommand(program, container) {
         if (typeof t.status === "string") return t.status === "done";
         return Object.values(t.status).every((s) => s === "done");
       }).length;
-      const readFile56 = container.fs.readFile.bind(container.fs);
+      const readFile57 = container.fs.readFile.bind(container.fs);
       const resolvedVars = await resolvePipelineVars(
         plan.vars ?? {},
         container.env.cwd,
-        readFile56
+        readFile57
       );
       const resolvedSetup = plan.setup === null ? void 0 : plan.setup ?? steps.setup;
       const resolvedTeardown = plan.teardown === null ? void 0 : plan.teardown ?? steps.teardown;
@@ -87690,7 +87690,7 @@ function registerPipelineCommand(program, container) {
       if (opts.preview) {
         if (resolvedSetup) {
           const raw = interpolatePipelineVars(resolvedSetup.prompt, resolvedVars, "setup");
-          const expanded = await resolveFileIncludes(raw, container.env.cwd, readFile56);
+          const expanded = await resolveFileIncludes(raw, container.env.cwd, readFile57);
           resources.logger.resolved("setup", expanded);
         }
         for (const task of plan.tasks) {
@@ -87703,7 +87703,7 @@ function registerPipelineCommand(program, container) {
                 vars: resolvedVars
               }),
               container.env.cwd,
-              readFile56
+              readFile57
             );
             resources.logger.resolved(`task: ${task.id} \u2014 ${task.title}`, expanded);
           } else {
@@ -87716,7 +87716,7 @@ function registerPipelineCommand(program, container) {
                   vars: resolvedVars
                 }),
                 container.env.cwd,
-                readFile56
+                readFile57
               );
               resources.logger.resolved(`task: ${task.id} / ${stepName}`, expanded);
             }
@@ -87724,7 +87724,7 @@ function registerPipelineCommand(program, container) {
         }
         if (resolvedTeardown) {
           const raw = interpolatePipelineVars(resolvedTeardown.prompt, resolvedVars, "teardown");
-          const expanded = await resolveFileIncludes(raw, container.env.cwd, readFile56);
+          const expanded = await resolveFileIncludes(raw, container.env.cwd, readFile57);
           resources.logger.resolved("teardown", expanded);
         }
       }
@@ -87793,7 +87793,7 @@ function registerPipelineCommand(program, container) {
       const templates = await loadPipelineTemplates();
       const pipelinePaths = resolvePipelinePaths(scope, container.env.cwd, container.env.homeDir);
       const skillDisplayPath = `${scope === "global" ? support.config.globalSkillDir : support.config.localSkillDir}/poe-code-pipeline-plan/SKILL.md`;
-      const skillPath = path127.join(
+      const skillPath = path128.join(
         resolveSkillDir(support.config, scope, container.env.cwd, container.env.homeDir),
         "poe-code-pipeline-plan",
         "SKILL.md"
@@ -87835,7 +87835,7 @@ function registerPipelineCommand(program, container) {
             `Would ${finalStepsExists ? "overwrite" : "create"}: ${pipelinePaths.displayStepsPath}`
           );
         } else {
-          await container.fs.mkdir(path127.dirname(pipelinePaths.stepsPath), {
+          await container.fs.mkdir(path128.dirname(pipelinePaths.stepsPath), {
             recursive: true
           });
           await container.fs.writeFile(pipelinePaths.stepsPath, templates.steps, {
@@ -87935,7 +87935,7 @@ var init_pipeline5 = __esm({
 });
 
 // src/cli/commands/ralph.ts
-import path128 from "node:path";
+import path129 from "node:path";
 function formatRalphAgentSummary(agent3) {
   return Array.isArray(agent3) ? agent3.join(", ") : agent3;
 }
@@ -88121,9 +88121,9 @@ function normalizeConfiguredIterations(value) {
 }
 function resolveAbsoluteDocPath(container, docPath) {
   if (docPath.startsWith("~/")) {
-    return path128.join(container.env.homeDir, docPath.slice(2));
+    return path129.join(container.env.homeDir, docPath.slice(2));
   }
-  return path128.isAbsolute(docPath) ? docPath : path128.resolve(container.env.cwd, docPath);
+  return path129.isAbsolute(docPath) ? docPath : path129.resolve(container.env.cwd, docPath);
 }
 async function resolveRalphCommandConfig(container) {
   const configDoc = await readMergedDocument(
@@ -88453,7 +88453,7 @@ function registerRalphCommand(program, container) {
       if (maxIterations2 == null) {
         return;
       }
-      const runCwd = options.cwd ? path128.resolve(container.env.cwd, options.cwd) : container.env.cwd;
+      const runCwd = options.cwd ? path129.resolve(container.env.cwd, options.cwd) : container.env.cwd;
       const runOptions = {
         agent: agent3,
         cwd: runCwd,
@@ -88535,11 +88535,11 @@ var init_ralph4 = __esm({
 });
 
 // src/cli/commands/experiment.ts
-import path129 from "node:path";
-import { readFile as readFile37, stat as stat25 } from "node:fs/promises";
+import path130 from "node:path";
+import { readFile as readFile38, stat as stat25 } from "node:fs/promises";
 import { fileURLToPath as fileURLToPath11 } from "node:url";
 function resolveExperimentPaths(scope, cwd, homeDir) {
-  const rootPath = scope === "global" ? path129.join(homeDir, ".poe-code", "experiments") : path129.join(cwd, ".poe-code", "experiments");
+  const rootPath = scope === "global" ? path130.join(homeDir, ".poe-code", "experiments") : path130.join(cwd, ".poe-code", "experiments");
   const displayRoot = scope === "global" ? "~/.poe-code/experiments" : ".poe-code/experiments";
   return {
     experimentsPath: rootPath,
@@ -88558,12 +88558,12 @@ async function pathExistsOnDisk2(targetPath) {
   }
 }
 async function findPackageRoot4(entryFilePath) {
-  let currentPath = path129.dirname(entryFilePath);
+  let currentPath = path130.dirname(entryFilePath);
   while (true) {
-    if (await pathExistsOnDisk2(path129.join(currentPath, "package.json"))) {
+    if (await pathExistsOnDisk2(path130.join(currentPath, "package.json"))) {
       return currentPath;
     }
-    const parentPath = path129.dirname(currentPath);
+    const parentPath = path130.dirname(currentPath);
     if (parentPath === currentPath) {
       throw new Error("Unable to locate package root for Experiment templates.");
     }
@@ -88576,16 +88576,16 @@ async function loadExperimentTemplates() {
   }
   const packageRoot = await findPackageRoot4(fileURLToPath11(import.meta.url));
   const templateRoots = [
-    path129.join(packageRoot, "src", "templates", "experiment"),
-    path129.join(packageRoot, "dist", "templates", "experiment")
+    path130.join(packageRoot, "src", "templates", "experiment"),
+    path130.join(packageRoot, "dist", "templates", "experiment")
   ];
   for (const templateRoot of templateRoots) {
     if (!await pathExistsOnDisk2(templateRoot)) {
       continue;
     }
     const [skillPlan, runYaml] = await Promise.all([
-      readFile37(path129.join(templateRoot, "SKILL_experiment.md"), "utf8"),
-      readFile37(path129.join(templateRoot, "run.yaml.mustache"), "utf8")
+      readFile38(path130.join(templateRoot, "SKILL_experiment.md"), "utf8"),
+      readFile38(path130.join(templateRoot, "run.yaml.mustache"), "utf8")
     ]);
     experimentTemplatesCache = { skillPlan, runYaml };
     return experimentTemplatesCache;
@@ -89305,8 +89305,8 @@ function registerExperimentCommand(program, container) {
         container.env.cwd,
         container.env.homeDir
       );
-      const runYamlPath = path129.join(experimentPaths.experimentsPath, "run.yaml");
-      const runYamlDisplayPath = path129.join(experimentPaths.displayExperimentsPath, "run.yaml");
+      const runYamlPath = path130.join(experimentPaths.experimentsPath, "run.yaml");
+      const runYamlDisplayPath = path130.join(experimentPaths.displayExperimentsPath, "run.yaml");
       const experimentsPathExisted = await pathExists11(
         container.fs,
         experimentPaths.experimentsPath
@@ -89846,9 +89846,9 @@ var init_launch2 = __esm({
 
 // packages/memory/src/paths.ts
 import * as fs11 from "node:fs/promises";
-import path130 from "node:path";
+import path131 from "node:path";
 function resolveMemoryRoot(cwd) {
-  return path130.resolve(cwd, ".poe-code", "memory");
+  return path131.resolve(cwd, ".poe-code", "memory");
 }
 function assertSafeRelPath(input) {
   const trimmed = input.trim();
@@ -89856,10 +89856,10 @@ function assertSafeRelPath(input) {
     throw new MemoryPathError("Expected a non-empty relative path.");
   }
   const slashNormalized = trimmed.replaceAll("\\", "/");
-  if (path130.posix.isAbsolute(slashNormalized) || path130.win32.isAbsolute(slashNormalized)) {
+  if (path131.posix.isAbsolute(slashNormalized) || path131.win32.isAbsolute(slashNormalized)) {
     throw new MemoryPathError(`Expected a relative path, received absolute path "${input}".`);
   }
-  const normalized = path130.posix.normalize(slashNormalized);
+  const normalized = path131.posix.normalize(slashNormalized);
   if (normalized === "." || normalized.length === 0) {
     throw new MemoryPathError("Expected a relative path to a file or directory.");
   }
@@ -89872,7 +89872,7 @@ async function assertNoSymlinkSegments(root, relPath) {
   const normalizedRelPath = assertSafeRelPath(relPath);
   let currentPath = root;
   for (const segment of normalizedRelPath.split("/")) {
-    currentPath = path130.join(currentPath, segment);
+    currentPath = path131.join(currentPath, segment);
     try {
       const stat33 = await fs11.lstat(currentPath);
       if (stat33.isSymbolicLink()) {
@@ -89921,7 +89921,7 @@ var init_paths2 = __esm({
 });
 
 // packages/memory/src/resolve-root.ts
-import path131 from "node:path";
+import path132 from "node:path";
 async function resolveConfiguredMemoryRoot(options) {
   const envOverride = options.env[MEMORY_ROOT_ENV_VAR]?.trim();
   if (envOverride && envOverride.length > 0) {
@@ -89944,7 +89944,7 @@ function readMemoryRoot(document) {
   return typeof root === "string" ? root : void 0;
 }
 function resolveAgainstCwd(cwd, value) {
-  return path131.isAbsolute(value) ? value : path131.resolve(cwd, value);
+  return path132.isAbsolute(value) ? value : path132.resolve(cwd, value);
 }
 var MEMORY_ROOT_ENV_VAR;
 var init_resolve_root = __esm({
@@ -89958,14 +89958,14 @@ var init_resolve_root = __esm({
 
 // packages/memory/src/init.ts
 import * as fs12 from "node:fs/promises";
-import path132 from "node:path";
+import path133 from "node:path";
 async function initMemory(root) {
   await assertMemoryRootIsNotSymlink(root);
   const rootExisted = await pathExists12(root);
-  const pagesPath = path132.join(root, MEMORY_PAGES_DIR_RELPATH);
+  const pagesPath = path133.join(root, MEMORY_PAGES_DIR_RELPATH);
   const pagesExisted = await pathExists12(pagesPath);
-  const indexPath = path132.join(root, MEMORY_INDEX_RELPATH);
-  const logPath = path132.join(root, MEMORY_LOG_RELPATH);
+  const indexPath = path133.join(root, MEMORY_INDEX_RELPATH);
+  const logPath = path133.join(root, MEMORY_LOG_RELPATH);
   let indexCreated = false;
   let logCreated = false;
   try {
@@ -90198,10 +90198,10 @@ function parseSources(value) {
     if (!isRecord38(item)) {
       throw new Error('Invalid "sources" frontmatter. Expected each source to be a string or object.');
     }
-    const path154 = readRequiredString(item.path, "sources[].path");
+    const path155 = readRequiredString(item.path, "sources[].path");
     const startLine = readOptionalPositiveInteger(item.startLine, "sources[].startLine");
     const endLine = readOptionalPositiveInteger(item.endLine, "sources[].endLine");
-    return parseSourceRef(serializeSourceRef({ path: path154, ...startLine === void 0 ? {} : { startLine }, ...endLine === void 0 ? {} : { endLine } }));
+    return parseSourceRef(serializeSourceRef({ path: path155, ...startLine === void 0 ? {} : { startLine }, ...endLine === void 0 ? {} : { endLine } }));
   });
 }
 function readOptionalString4(value, field) {
@@ -90245,7 +90245,7 @@ var init_frontmatter5 = __esm({
 
 // packages/memory/src/pages.ts
 import * as fs13 from "node:fs/promises";
-import path133 from "node:path";
+import path134 from "node:path";
 async function listPages(root) {
   const relPaths = await collectMarkdownRelPaths(root, MEMORY_PAGES_DIR_RELPATH);
   const pages = await Promise.all(relPaths.map(async (relPath) => readPage(root, relPath)));
@@ -90254,7 +90254,7 @@ async function listPages(root) {
 async function readPage(root, relPath) {
   const normalizedRelPath = assertMarkdownRelPath(relPath);
   await assertNoSymlinkSegments(root, normalizedRelPath);
-  const absPath = path133.join(root, normalizedRelPath);
+  const absPath = path134.join(root, normalizedRelPath);
   const [content, stat33] = await Promise.all([fs13.readFile(absPath, "utf8"), fs13.stat(absPath)]);
   try {
     const parsed = parseFrontmatter4(content);
@@ -90283,7 +90283,7 @@ async function collectMarkdownRelPaths(root, startRelPath = "") {
   return relPaths.sort((left, right) => left.localeCompare(right));
 }
 async function collectMarkdownRelPathsInto(root, currentRelPath, relPaths) {
-  const absPath = path133.join(root, currentRelPath);
+  const absPath = path134.join(root, currentRelPath);
   let entryNames;
   try {
     entryNames = await fs13.readdir(absPath);
@@ -90294,8 +90294,8 @@ async function collectMarkdownRelPathsInto(root, currentRelPath, relPaths) {
     throw error3;
   }
   for (const entryName of entryNames.sort((left, right) => left.localeCompare(right))) {
-    const entryRelPath = currentRelPath.length === 0 ? entryName : path133.posix.join(currentRelPath, entryName);
-    const entryAbsPath = path133.join(root, entryRelPath);
+    const entryRelPath = currentRelPath.length === 0 ? entryName : path134.posix.join(currentRelPath, entryName);
+    const entryAbsPath = path134.join(root, entryRelPath);
     const entryStat = await fs13.lstat(entryAbsPath);
     if (entryStat.isSymbolicLink()) {
       continue;
@@ -90325,7 +90325,7 @@ function assertMarkdownRelPath(relPath) {
   return normalizedRelPath;
 }
 function isMarkdownPath(relPath) {
-  return path133.posix.extname(relPath).toLowerCase() === ".md";
+  return path134.posix.extname(relPath).toLowerCase() === ".md";
 }
 function isMissing2(error3) {
   return typeof error3 === "object" && error3 !== null && "code" in error3 && error3.code === "ENOENT";
@@ -90340,7 +90340,7 @@ var init_pages = __esm({
 
 // packages/memory/src/search.ts
 import * as fs14 from "node:fs/promises";
-import path134 from "node:path";
+import path135 from "node:path";
 async function searchMemory(root, query) {
   const normalizedQuery = query.trim();
   if (normalizedQuery.length === 0) {
@@ -90349,7 +90349,7 @@ async function searchMemory(root, query) {
   const relPaths = await collectMarkdownRelPaths(root);
   const hits = [];
   for (const relPath of relPaths) {
-    const content = await fs14.readFile(path134.join(root, relPath), "utf8");
+    const content = await fs14.readFile(path135.join(root, relPath), "utf8");
     if (content.length === 0) {
       continue;
     }
@@ -90376,9 +90376,9 @@ var init_search = __esm({
 
 // packages/memory/src/status.ts
 import * as fs15 from "node:fs/promises";
-import path135 from "node:path";
+import path136 from "node:path";
 async function statusOf(root) {
-  if (!await pathExists13(root) || !await pathExists13(path135.join(root, MEMORY_INDEX_RELPATH)) || !await pathExists13(path135.join(root, MEMORY_LOG_RELPATH)) || !await pathExists13(path135.join(root, MEMORY_PAGES_DIR_RELPATH))) {
+  if (!await pathExists13(root) || !await pathExists13(path136.join(root, MEMORY_INDEX_RELPATH)) || !await pathExists13(path136.join(root, MEMORY_LOG_RELPATH)) || !await pathExists13(path136.join(root, MEMORY_PAGES_DIR_RELPATH))) {
     return {
       pageCount: 0,
       totalBytes: 0,
@@ -90393,7 +90393,7 @@ async function statusOf(root) {
   let totalBytes = 0;
   let lastWriteAtMs = Number.NEGATIVE_INFINITY;
   for (const relPath of markdownRelPaths) {
-    const stat33 = await fs15.stat(path135.join(root, relPath));
+    const stat33 = await fs15.stat(path136.join(root, relPath));
     totalBytes += stat33.size;
     lastWriteAtMs = Math.max(lastWriteAtMs, stat33.mtimeMs);
   }
@@ -90647,13 +90647,13 @@ var init_confidence = __esm({
 // packages/memory/src/reconcile.ts
 import { createHash as createHash8 } from "node:crypto";
 import * as fs17 from "node:fs/promises";
-import path136 from "node:path";
+import path137 from "node:path";
 async function snapshot(root) {
   const pages = Object.fromEntries(
     await Promise.all(
       (await collectMarkdownRelPaths(root, MEMORY_PAGES_DIR_RELPATH)).map(async (relPath) => [
         relPath,
-        hashContent(await fs17.readFile(path136.join(root, relPath), "utf8"))
+        hashContent(await fs17.readFile(path137.join(root, relPath), "utf8"))
       ])
     )
   );
@@ -90662,13 +90662,13 @@ async function snapshot(root) {
 async function reconcile(root, before, _verb, detail) {
   await assertNoSymlinkSegments(root, MEMORY_INDEX_RELPATH);
   await assertNoSymlinkSegments(root, MEMORY_LOG_RELPATH);
-  const originalIndex = await readFileIfPresent(path136.join(root, MEMORY_INDEX_RELPATH));
-  const originalLog = await readFileIfPresent(path136.join(root, MEMORY_LOG_RELPATH));
+  const originalIndex = await readFileIfPresent(path137.join(root, MEMORY_INDEX_RELPATH));
+  const originalLog = await readFileIfPresent(path137.join(root, MEMORY_LOG_RELPATH));
   await initMemory(root);
   const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
   const currentPages = await Promise.all(
     (await collectMarkdownRelPaths(root, MEMORY_PAGES_DIR_RELPATH)).map(async (relPath) => {
-      const absPath = path136.join(root, relPath);
+      const absPath = path137.join(root, relPath);
       const markdown = await fs17.readFile(absPath, "utf8");
       const parsed = parsePageMarkdown(relPath, markdown);
       const normalizedFrontmatter = withDenormalizedSources(parsed.frontmatter, parsed.body);
@@ -90691,7 +90691,7 @@ async function reconcile(root, before, _verb, detail) {
   );
   try {
     await Promise.all(
-      currentPages.filter((page) => page.currentMarkdown !== page.nextMarkdown).map((page) => writeFileAtomically3(path136.join(root, page.relPath), page.nextMarkdown))
+      currentPages.filter((page) => page.currentMarkdown !== page.nextMarkdown).map((page) => writeFileAtomically3(path137.join(root, page.relPath), page.nextMarkdown))
     );
     const diff2 = diffSnapshots(before, await snapshot(root));
     await writeIndex(root);
@@ -90699,10 +90699,10 @@ async function reconcile(root, before, _verb, detail) {
     return diff2;
   } catch (error3) {
     await Promise.all(
-      currentPages.filter((page) => page.currentMarkdown !== page.nextMarkdown).map((page) => writeFileAtomically3(path136.join(root, page.relPath), page.currentMarkdown).catch(() => void 0))
+      currentPages.filter((page) => page.currentMarkdown !== page.nextMarkdown).map((page) => writeFileAtomically3(path137.join(root, page.relPath), page.currentMarkdown).catch(() => void 0))
     );
-    await restoreGeneratedFile(path136.join(root, MEMORY_INDEX_RELPATH), originalIndex);
-    await restoreGeneratedFile(path136.join(root, MEMORY_LOG_RELPATH), originalLog);
+    await restoreGeneratedFile(path137.join(root, MEMORY_INDEX_RELPATH), originalIndex);
+    await restoreGeneratedFile(path137.join(root, MEMORY_LOG_RELPATH), originalLog);
     throw error3;
   }
 }
@@ -90730,7 +90730,7 @@ async function appendLogEntries(root, diff2, detail, timestamp2 = (/* @__PURE__
     return;
   }
   await assertNoSymlinkSegments(root, MEMORY_LOG_RELPATH);
-  const logPath = path136.join(root, MEMORY_LOG_RELPATH);
+  const logPath = path137.join(root, MEMORY_LOG_RELPATH);
   const existing = await fs17.readFile(logPath, "utf8");
   const separator = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
   await writeFileAtomically3(logPath, `${existing}${separator}${entries.join("\n")}
@@ -90755,7 +90755,7 @@ async function writeIndex(root) {
       description: page.frontmatter.description ?? ""
     }))
   );
-  await writeFileAtomically3(path136.join(root, MEMORY_INDEX_RELPATH), index);
+  await writeFileAtomically3(path137.join(root, MEMORY_INDEX_RELPATH), index);
 }
 async function readFileIfPresent(filePath) {
   try {
@@ -90829,14 +90829,14 @@ var init_reconcile2 = __esm({
 // packages/memory/src/write.ts
 import { randomUUID as randomUUID15 } from "node:crypto";
 import * as fs18 from "node:fs/promises";
-import path137 from "node:path";
+import path138 from "node:path";
 async function writePage(root, relPath, body, opts) {
   const pageRelPath = assertPageRelPath(relPath);
   await assertNoSymlinkSegments(root, pageRelPath);
-  const pagePath = path137.join(root, pageRelPath);
+  const pagePath = path138.join(root, pageRelPath);
   const originalPage = await readMarkdownIfPresent(pagePath);
   const before = await snapshot(root);
-  await fs18.mkdir(path137.dirname(pagePath), { recursive: true });
+  await fs18.mkdir(path138.dirname(pagePath), { recursive: true });
   try {
     await writeFileAtomically3(pagePath, serializeFrontmatter(opts.frontmatter ?? {}, body));
     return await reconcile(root, before, "update", opts.reason);
@@ -90848,10 +90848,10 @@ async function writePage(root, relPath, body, opts) {
 async function appendToPage(root, relPath, content, opts) {
   const pageRelPath = assertPageRelPath(relPath);
   await assertNoSymlinkSegments(root, pageRelPath);
-  const pagePath = path137.join(root, pageRelPath);
+  const pagePath = path138.join(root, pageRelPath);
   const originalPage = await readMarkdownIfPresent(pagePath);
   const before = await snapshot(root);
-  await fs18.mkdir(path137.dirname(pagePath), { recursive: true });
+  await fs18.mkdir(path138.dirname(pagePath), { recursive: true });
   const parsed = originalPage === void 0 ? { frontmatter: {}, body: "" } : parseFrontmatter4(originalPage);
   try {
     await writeFileAtomically3(
@@ -90885,7 +90885,7 @@ async function clearMemory(root) {
 }
 function assertPageRelPath(relPath) {
   const normalizedRelPath = assertSafeRelPath(relPath);
-  if (!normalizedRelPath.startsWith(`${MEMORY_PAGES_DIR_RELPATH}/`) || path137.posix.extname(normalizedRelPath).toLowerCase() !== ".md") {
+  if (!normalizedRelPath.startsWith(`${MEMORY_PAGES_DIR_RELPATH}/`) || path138.posix.extname(normalizedRelPath).toLowerCase() !== ".md") {
     throw new Error(`Expected a markdown page path under "${MEMORY_PAGES_DIR_RELPATH}/".`);
   }
   return normalizedRelPath;
@@ -90920,16 +90920,16 @@ var init_write2 = __esm({
 
 // packages/memory/src/edit.ts
 import * as fs19 from "node:fs/promises";
-import path138 from "node:path";
+import path139 from "node:path";
 async function editPage(root, relPath, opts) {
   const normalizedRelPath = assertSafeRelPath(relPath);
-  const pagePath = path138.join(root, normalizedRelPath);
+  const pagePath = path139.join(root, normalizedRelPath);
   const original = await readIfPresent(pagePath);
-  const tempRoot = path138.join(root, ".tmp");
+  const tempRoot = path139.join(root, ".tmp");
   await assertNoSymlinkSegments(root, ".tmp");
   await fs19.mkdir(tempRoot, { recursive: true });
-  const tempDir = await fs19.mkdtemp(path138.join(tempRoot, "poe-code-memory-edit-"));
-  const tempPath = path138.join(tempDir, path138.basename(normalizedRelPath));
+  const tempDir = await fs19.mkdtemp(path139.join(tempRoot, "poe-code-memory-edit-"));
+  const tempPath = path139.join(tempDir, path139.basename(normalizedRelPath));
   try {
     await fs19.writeFile(tempPath, original ?? "", "utf8");
     await opts.launchEditor(tempPath);
@@ -90971,7 +90971,7 @@ var init_edit = __esm({
 
 // packages/memory/src/audit.ts
 import * as fs20 from "node:fs/promises";
-import path139 from "node:path";
+import path140 from "node:path";
 async function auditClaims(root, repoRoot, options = {}) {
   const minInferredConfidence = options.minInferredConfidence ?? DEFAULT_MIN_INFERRED_CONFIDENCE;
   const rejectUntagged = options.rejectUntagged ?? DEFAULT_REJECT_UNTAGGED;
@@ -91023,10 +91023,10 @@ async function auditSourceRef(source, claimLineNumber, repoRoot, sourceCache) {
   if (isUrlLike(source.path)) {
     return void 0;
   }
-  if (path139.isAbsolute(source.path)) {
+  if (path140.isAbsolute(source.path)) {
     return `Claim on line ${claimLineNumber} cites "${serializeSourceRef(source)}", but source paths must be repo-relative or URLs.`;
   }
-  const absPath = path139.resolve(repoRoot, source.path);
+  const absPath = path140.resolve(repoRoot, source.path);
   if (!isWithinRoot(repoRoot, absPath)) {
     return `Claim on line ${claimLineNumber} cites "${serializeSourceRef(source)}", which resolves outside the repo root.`;
   }
@@ -91108,8 +91108,8 @@ function isUrlLike(value) {
   return /^[a-z][a-z\d+.-]*:\/\//i.test(value);
 }
 function isWithinRoot(root, absPath) {
-  const relative6 = path139.relative(root, absPath);
-  return relative6 === "" || !relative6.startsWith("..") && !path139.isAbsolute(relative6);
+  const relative6 = path140.relative(root, absPath);
+  return relative6 === "" || !relative6.startsWith("..") && !path140.isAbsolute(relative6);
 }
 var DEFAULT_MIN_INFERRED_CONFIDENCE, DEFAULT_REJECT_UNTAGGED, DEFAULT_UNTAGGED_BODY_THRESHOLD_CHARS;
 var init_audit = __esm({
@@ -91127,7 +91127,7 @@ var init_audit = __esm({
 // packages/memory/src/cache.ts
 import { createHash as createHash9 } from "node:crypto";
 import * as fs21 from "node:fs/promises";
-import path140 from "node:path";
+import path141 from "node:path";
 function computeIngestKey(input) {
   const hash = createHash9("sha256");
   hash.update(input.sourceBytes);
@@ -91140,7 +91140,7 @@ function computeIngestKey(input) {
   return hash.digest("hex");
 }
 async function readCacheEntry(root, key2) {
-  const cachePath = path140.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH, `${assertSafeRelPath(key2)}.json`);
+  const cachePath = path141.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH, `${assertSafeRelPath(key2)}.json`);
   let raw;
   try {
     raw = await fs21.readFile(cachePath, "utf8");
@@ -91160,18 +91160,18 @@ async function readCacheEntry(root, key2) {
 }
 async function writeCacheEntry(root, entry) {
   const key2 = assertSafeRelPath(entry.key);
-  await fs21.mkdir(path140.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH), { recursive: true });
+  await fs21.mkdir(path141.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH), { recursive: true });
   await writeFileAtomically3(
-    path140.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH, `${key2}.json`),
+    path141.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH, `${key2}.json`),
     `${JSON.stringify(entry)}
 `
   );
 }
 async function cacheStatus(root) {
-  const ingestDir = path140.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH);
+  const ingestDir = path141.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH);
   const fileNames = await readCacheFileNames(ingestDir);
   const sizes = await Promise.all(
-    fileNames.map(async (fileName) => (await fs21.stat(path140.join(ingestDir, fileName))).size)
+    fileNames.map(async (fileName) => (await fs21.stat(path141.join(ingestDir, fileName))).size)
   );
   return {
     entries: fileNames.length,
@@ -91179,8 +91179,8 @@ async function cacheStatus(root) {
   };
 }
 async function clearCache(root, opts = {}) {
-  const ingestDir = path140.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH);
-  const cacheDir = path140.join(root, MEMORY_CACHE_DIR_RELPATH);
+  const ingestDir = path141.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH);
+  const cacheDir = path141.join(root, MEMORY_CACHE_DIR_RELPATH);
   const fileNames = await readCacheFileNames(ingestDir);
   if (fileNames.length === 0) {
     if (opts.olderThanMs === void 0) {
@@ -91200,7 +91200,7 @@ async function clearCache(root, opts = {}) {
     if (entry === null || Date.parse(entry.ingestedAt) > cutoff) {
       continue;
     }
-    const filePath = path140.join(ingestDir, fileName);
+    const filePath = path141.join(ingestDir, fileName);
     expiredEntries.push({ filePath, content: await fs21.readFile(filePath, "utf8") });
   }
   try {
@@ -91266,7 +91266,7 @@ function expectStringArray2(value, field) {
 }
 async function readCacheFileNames(ingestDir) {
   try {
-    return (await fs21.readdir(ingestDir)).filter((fileName) => path140.posix.extname(fileName).toLowerCase() === ".json").sort((left, right) => left.localeCompare(right));
+    return (await fs21.readdir(ingestDir)).filter((fileName) => path141.posix.extname(fileName).toLowerCase() === ".json").sort((left, right) => left.localeCompare(right));
   } catch (error3) {
     if (isMissing5(error3)) {
       return [];
@@ -91437,7 +91437,7 @@ var init_src41 = __esm({
 
 // packages/memory/src/tokens.ts
 import * as fs22 from "node:fs/promises";
-import path141 from "node:path";
+import path142 from "node:path";
 async function computeTokenStats(root) {
   if (!await pathExists14(root)) {
     return {
@@ -91459,18 +91459,18 @@ async function computeTokenStats(root) {
       }
     }
   }
-  const repoRoot = path141.resolve(root, "..", "..");
+  const repoRoot = path142.resolve(root, "..", "..");
   let sourceTokens = 0;
   const missingSources = [];
   for (const sourcePath of sourcePaths) {
     if (isUrlLike2(sourcePath)) {
       continue;
     }
-    if (path141.isAbsolute(sourcePath)) {
+    if (path142.isAbsolute(sourcePath)) {
       missingSources.push(sourcePath);
       continue;
     }
-    const absPath = path141.resolve(repoRoot, sourcePath);
+    const absPath = path142.resolve(repoRoot, sourcePath);
     if (!isWithinRoot2(repoRoot, absPath)) {
       missingSources.push(sourcePath);
       continue;
@@ -91523,8 +91523,8 @@ function isUrlLike2(value) {
   }
 }
 function isWithinRoot2(root, absPath) {
-  const relative6 = path141.relative(root, absPath);
-  return relative6 === "" || !relative6.startsWith("..") && !path141.isAbsolute(relative6);
+  const relative6 = path142.relative(root, absPath);
+  return relative6 === "" || !relative6.startsWith("..") && !path142.isAbsolute(relative6);
 }
 var init_tokens2 = __esm({
   "packages/memory/src/tokens.ts"() {
@@ -91536,7 +91536,7 @@ var init_tokens2 = __esm({
 
 // packages/memory/src/ingest.ts
 import * as fs23 from "node:fs/promises";
-import path142 from "node:path";
+import path143 from "node:path";
 function resolveRunners2(overrides) {
   return {
     computeIngestKey: overrides?.computeIngestKey ?? computeIngestKey,
@@ -91550,11 +91550,11 @@ function resolveRunners2(overrides) {
 async function ingest(root, opts, runners) {
   const resolved = resolveRunners2(runners);
   const source = await materializeSource(opts.source);
-  const indexMdBytes = await fs23.readFile(path142.join(root, MEMORY_INDEX_RELPATH));
+  const indexMdBytes = await fs23.readFile(path143.join(root, MEMORY_INDEX_RELPATH));
   const configOptions = {
     fs: fs23,
-    filePath: path142.join(inferRepoRoot(root), "poe-code.json"),
-    projectFilePath: path142.join(inferRepoRoot(root), ".poe-code", "config.json")
+    filePath: path143.join(inferRepoRoot(root), "poe-code.json"),
+    projectFilePath: path143.join(inferRepoRoot(root), ".poe-code", "config.json")
   };
   const agentId = await resolveAgent(configOptions, opts.agent ?? null) ?? opts.agent ?? "claude-code";
   const key2 = resolved.computeIngestKey({
@@ -91655,7 +91655,7 @@ async function materializeSource(source) {
   };
 }
 function inferRepoRoot(root) {
-  return path142.resolve(root, "..", "..");
+  return path143.resolve(root, "..", "..");
 }
 async function runWithTimeout(promise, timeoutMs, onTimeout) {
   return await new Promise((resolve10, reject) => {
@@ -91774,7 +91774,7 @@ var init_mcp5 = __esm({
 });
 
 // packages/memory/src/install.ts
-import path143 from "node:path";
+import path144 from "node:path";
 async function installMemory(options) {
   if (options.skillOnly && options.mcpOnly) {
     throw new Error("--skill-only and --mcp-only cannot be combined.");
@@ -91838,12 +91838,12 @@ async function installMemory(options) {
 async function removeInstalledSkill(options, skillPath) {
   const baseDir = options.scope === "global" ? options.homeDir : options.cwd;
   const displayPath = skillPath.startsWith("~/") ? skillPath.slice(2) : skillPath;
-  const skillDirectory = path143.join(baseDir, path143.dirname(displayPath));
+  const skillDirectory = path144.join(baseDir, path144.dirname(displayPath));
   if (options.fs.rm !== void 0) {
     await options.fs.rm(skillDirectory, { recursive: true, force: true });
     return;
   }
-  await options.fs.unlink(path143.join(skillDirectory, "SKILL.md"));
+  await options.fs.unlink(path144.join(skillDirectory, "SKILL.md"));
 }
 var SKILL_NAME;
 var init_install3 = __esm({
@@ -91857,7 +91857,7 @@ var init_install3 = __esm({
 
 // packages/memory/src/query.ts
 import * as fs24 from "node:fs/promises";
-import path144 from "node:path";
+import path145 from "node:path";
 async function queryMemory(root, options) {
   const pages = await listPages(root);
   if (pages.length === 0) {
@@ -91871,8 +91871,8 @@ async function queryMemory(root, options) {
   }
   const configOptions = {
     fs: fs24,
-    filePath: path144.join(inferRepoRoot2(root), "poe-code.json"),
-    projectFilePath: path144.join(inferRepoRoot2(root), ".poe-code", "config.json")
+    filePath: path145.join(inferRepoRoot2(root), "poe-code.json"),
+    projectFilePath: path145.join(inferRepoRoot2(root), ".poe-code", "config.json")
   };
   const agentId = await resolveAgent(configOptions, options.agent ?? null) ?? options.agent ?? "claude-code";
   const context = await selectQueryContext(root, options.question, options.budget);
@@ -91911,7 +91911,7 @@ async function selectQueryContext(root, question, budget) {
     throw new Error("budget must be a finite non-negative number");
   }
   const [indexText, pages] = await Promise.all([
-    fs24.readFile(path144.join(root, MEMORY_INDEX_RELPATH), "utf8"),
+    fs24.readFile(path145.join(root, MEMORY_INDEX_RELPATH), "utf8"),
     listPages(root)
   ]);
   const indexTokens = countTokens(indexText);
@@ -91990,7 +91990,7 @@ function tokenize2(text6) {
   return text6.toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length > 0);
 }
 function inferRepoRoot2(root) {
-  return path144.resolve(root, "..", "..");
+  return path145.resolve(root, "..", "..");
 }
 var init_query = __esm({
   "packages/memory/src/query.ts"() {
@@ -92005,7 +92005,7 @@ var init_query = __esm({
 
 // packages/memory/src/explain.ts
 import * as fs25 from "node:fs/promises";
-import path145 from "node:path";
+import path146 from "node:path";
 async function explainPage(root, options) {
   const targetPage = await readPageIfPresent(root, options.relPath);
   if (targetPage === void 0) {
@@ -92028,8 +92028,8 @@ async function explainPage(root, options) {
   }
   const configOptions = {
     fs: fs25,
-    filePath: path145.join(inferRepoRoot3(root), "poe-code.json"),
-    projectFilePath: path145.join(inferRepoRoot3(root), ".poe-code", "config.json")
+    filePath: path146.join(inferRepoRoot3(root), "poe-code.json"),
+    projectFilePath: path146.join(inferRepoRoot3(root), ".poe-code", "config.json")
   };
   const agentId = await resolveAgent(configOptions, options.agent ?? null) ?? options.agent ?? "claude-code";
   const spawned = await spawn5(agentId, { prompt });
@@ -92099,7 +92099,7 @@ async function readPageIfPresent(root, relPath) {
   }
 }
 function inferRepoRoot3(root) {
-  return path145.resolve(root, "..", "..");
+  return path146.resolve(root, "..", "..");
 }
 var init_explain = __esm({
   "packages/memory/src/explain.ts"() {
@@ -92121,9 +92121,9 @@ var init_explain_cli = __esm({
 });
 
 // packages/memory/src/handle.ts
-import path146 from "node:path";
+import path147 from "node:path";
 function openMemory(opts) {
-  if (!path146.isAbsolute(opts.root)) {
+  if (!path147.isAbsolute(opts.root)) {
     throw new Error(`openMemory: root must be absolute, got ${opts.root}`);
   }
   const root = opts.root;
@@ -92205,7 +92205,7 @@ var init_SKILL_memory = __esm({
 });
 
 // src/cli/commands/memory.ts
-import path147 from "node:path";
+import path148 from "node:path";
 import * as fs26 from "node:fs/promises";
 import { execSync as execSync4 } from "node:child_process";
 async function resolveRoot(container) {
@@ -92223,8 +92223,8 @@ function resolvePageRelPath(input) {
     throw new ValidationError("Missing page path.");
   }
   const normalized = trimmed.replaceAll("\\", "/");
-  const withExt = path147.posix.extname(normalized).length === 0 ? `${normalized}.md` : normalized;
-  const relPath = path147.posix.normalize(withExt.startsWith("pages/") ? withExt : `pages/${withExt}`);
+  const withExt = path148.posix.extname(normalized).length === 0 ? `${normalized}.md` : normalized;
+  const relPath = path148.posix.normalize(withExt.startsWith("pages/") ? withExt : `pages/${withExt}`);
   if (!relPath.startsWith("pages/") || relPath === "pages/.." || relPath.includes("/../")) {
     throw new ValidationError("Page path must remain under memory pages/.");
   }
@@ -92283,7 +92283,7 @@ function resolveIngestSource(cwd, input) {
       throw error3;
     }
   }
-  return { kind: "file", absPath: path147.resolve(cwd, input) };
+  return { kind: "file", absPath: path148.resolve(cwd, input) };
 }
 function registerMemoryCommand(program, container) {
   const memory = program.command("memory").description("Persistent memory directory commands.").allowExcessArguments().action(function() {
@@ -92309,8 +92309,8 @@ function registerMemoryCommand(program, container) {
     }
     await initMemory(root);
     resources.context.complete({
-      success: `Initialized memory at ${path147.relative(container.env.cwd, root)}`,
-      dry: `Would initialize memory at ${path147.relative(container.env.cwd, root)}`
+      success: `Initialized memory at ${path148.relative(container.env.cwd, root)}`,
+      dry: `Would initialize memory at ${path148.relative(container.env.cwd, root)}`
     });
     resources.context.finalize();
   });
@@ -92342,7 +92342,7 @@ function registerMemoryCommand(program, container) {
     resources.logger.intro("memory show");
     await assertInitialized(mem);
     const relPath = resolvePageRelPath(pagePath);
-    const absPath = path147.join(mem.root, relPath);
+    const absPath = path148.join(mem.root, relPath);
     try {
       await mem.readPage(relPath);
       const content = await fs26.readFile(absPath, "utf8");
@@ -93036,7 +93036,7 @@ var init_provider = __esm({
 });
 
 // src/cli/commands/runtime/build.ts
-import path148 from "node:path";
+import path149 from "node:path";
 function registerRuntimeBuildCommand(runtime, root, container) {
   const cmd = runtime.command("build").description("Build the configured runtime template.").option("--force", "Ignore the local template cache and rebuild.");
   addRuntimeOptions(cmd).action(async (options) => {
@@ -93125,16 +93125,16 @@ async function executeRuntimeBuild(program, container, options) {
   });
 }
 async function requireRuntimeBuildPaths(container, runtime, label) {
-  const dockerfilePath = path148.resolve(
+  const dockerfilePath = path149.resolve(
     container.env.cwd,
-    runtime.dockerfile ?? path148.join(".poe-code", "Dockerfile")
+    runtime.dockerfile ?? path149.join(".poe-code", "Dockerfile")
   );
   if (!await pathExists(container.fs, dockerfilePath)) {
     throw new Error(`${label} runtime requires a Dockerfile at ${dockerfilePath}.`);
   }
   return {
     dockerfilePath,
-    buildContext: path148.resolve(container.env.cwd, runtime.build_context ?? ".")
+    buildContext: path149.resolve(container.env.cwd, runtime.build_context ?? ".")
   };
 }
 async function loadE2bRunnerModule() {
@@ -93175,9 +93175,9 @@ var init_build = __esm({
 });
 
 // src/cli/commands/runtime/shared.ts
-import path149 from "node:path";
+import path150 from "node:path";
 function resolveDockerfilePath(container) {
-  return path149.join(container.env.cwd, ".poe-code", "Dockerfile");
+  return path150.join(container.env.cwd, ".poe-code", "Dockerfile");
 }
 async function resolveRuntimeType(input) {
   if (input.value !== void 0) {
@@ -93219,7 +93219,7 @@ async function writeDefaultDockerfileIfNeeded(input) {
   if (await pathExists(input.container.fs, dockerfilePath)) {
     return false;
   }
-  await input.container.fs.mkdir(path149.dirname(dockerfilePath), { recursive: true });
+  await input.container.fs.mkdir(path150.dirname(dockerfilePath), { recursive: true });
   await input.container.fs.writeFile(dockerfilePath, defaultDockerfile, { encoding: "utf8" });
   return true;
 }
@@ -106185,9 +106185,9 @@ function findPathToModule(currentModuleName, targetModuleName, dependencyGraph,
   }
   visited.add(currentModuleName);
   for (const dependencyModuleName of dependencyGraph.get(currentModuleName) ?? []) {
-    const path154 = findPathToModule(dependencyModuleName, targetModuleName, dependencyGraph, visited);
-    if (path154 !== void 0) {
-      return [currentModuleName, ...path154];
+    const path155 = findPathToModule(dependencyModuleName, targetModuleName, dependencyGraph, visited);
+    if (path155 !== void 0) {
+      return [currentModuleName, ...path155];
     }
   }
   visited.delete(currentModuleName);
@@ -110883,7 +110883,7 @@ function createDumpFile(snapshot2) {
   }
   return dumped;
 }
-function serializeDumpValue(value, path154, state) {
+function serializeDumpValue(value, path155, state) {
   if (value === null || typeof value === "string" || typeof value === "boolean") {
     return value;
   }
@@ -110900,22 +110900,22 @@ function serializeDumpValue(value, path154, state) {
     return SKIP_VALUE;
   }
   if (Array.isArray(value)) {
-    const reference2 = serializeHeapReference(value, path154, state);
+    const reference2 = serializeHeapReference(value, path155, state);
     if (reference2 !== void 0) {
       return reference2;
     }
-    return serializeArrayItems(value, path154, state);
+    return serializeArrayItems(value, path155, state);
   }
   if (!isPlainObject7(value)) {
     return SKIP_VALUE;
   }
-  const reference = serializeHeapReference(value, path154, state);
+  const reference = serializeHeapReference(value, path155, state);
   if (reference !== void 0) {
     return reference;
   }
-  return serializeObjectEntries(value, path154, state);
+  return serializeObjectEntries(value, path155, state);
 }
-function serializeHeapReference(value, path154, state) {
+function serializeHeapReference(value, path155, state) {
   const id = state.heapIds.get(value);
   if (id === void 0) {
     return void 0;
@@ -110925,12 +110925,12 @@ function serializeHeapReference(value, path154, state) {
     if (Array.isArray(value)) {
       state.heap[String(id)] = {
         kind: "array",
-        items: serializeArrayItems(value, path154, state)
+        items: serializeArrayItems(value, path155, state)
       };
     } else {
       state.heap[String(id)] = {
         kind: "object",
-        entries: serializeObjectEntries(value, path154, state)
+        entries: serializeObjectEntries(value, path155, state)
       };
     }
   }
@@ -110939,10 +110939,10 @@ function serializeHeapReference(value, path154, state) {
     id
   };
 }
-function serializeObjectEntries(value, path154, state) {
+function serializeObjectEntries(value, path155, state) {
   const serialized = {};
   for (const [key2, entry] of getEnumerableDataEntries(value)) {
-    const dumped = serializeDumpValue(entry, `${path154}.${key2}`, state);
+    const dumped = serializeDumpValue(entry, `${path155}.${key2}`, state);
     if (dumped !== SKIP_VALUE) {
       serialized[key2] = dumped;
     }
@@ -111004,9 +111004,9 @@ function isPlainObject7(value) {
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
-function serializeArrayItems(value, path154, state) {
+function serializeArrayItems(value, path155, state) {
   return getArrayDataItems(value).map((entry, index) => {
-    const serialized = serializeDumpValue(entry, `${path154}[${index}]`, state);
+    const serialized = serializeDumpValue(entry, `${path155}[${index}]`, state);
     return serialized === SKIP_VALUE ? { kind: "undefined" } : serialized;
   });
 }
@@ -111405,7 +111405,7 @@ function deepCopyFromSandbox(value, options = {}) {
     options
   );
 }
-function copyToSandbox(value, state, path154 = "<root>") {
+function copyToSandbox(value, state, path155 = "<root>") {
   if (isSandboxPrimitive(value)) {
     return value;
   }
@@ -111432,11 +111432,11 @@ function copyToSandbox(value, state, path154 = "<root>") {
     }
     const copy = new Array(value.length);
     state.seen.set(value, copy);
-    for (const entry of getEnumerableArrayEntries(value, path154)) {
+    for (const entry of getEnumerableArrayEntries(value, path155)) {
       defineOwnDataProperty(
         copy,
         entry.key,
-        copyToSandbox(entry.value, state, joinArrayPath(path154, entry.key))
+        copyToSandbox(entry.value, state, joinArrayPath(path155, entry.key))
       );
     }
     return copy;
@@ -111448,18 +111448,18 @@ function copyToSandbox(value, state, path154 = "<root>") {
     }
     const copy = createPlainObject(Object.getPrototypeOf(value) === null);
     state.seen.set(value, copy);
-    for (const entry of getEnumerableObjectEntries(value, path154)) {
+    for (const entry of getEnumerableObjectEntries(value, path155)) {
       defineOwnDataProperty(
         copy,
         entry.key,
-        copyToSandbox(entry.value, state, joinPath(path154, entry.key))
+        copyToSandbox(entry.value, state, joinPath(path155, entry.key))
       );
     }
     return copy;
   }
-  throw new TypeError(`Unsupported sandbox value at ${path154}: ${describeValue(value)}`);
+  throw new TypeError(`Unsupported sandbox value at ${path155}: ${describeValue(value)}`);
 }
-function copyFromSandbox(value, state, path154 = "<root>", options) {
+function copyFromSandbox(value, state, path155 = "<root>", options) {
   if (isSandboxPrimitive(value)) {
     return value;
   }
@@ -111490,11 +111490,11 @@ function copyFromSandbox(value, state, path154 = "<root>", options) {
     }
     const copy = new Array(value.length);
     state.seen.set(value, copy);
-    for (const entry of getEnumerableArrayEntries(value, path154)) {
+    for (const entry of getEnumerableArrayEntries(value, path155)) {
       defineOwnDataProperty(
         copy,
         entry.key,
-        copyFromSandbox(entry.value, state, joinArrayPath(path154, entry.key), options)
+        copyFromSandbox(entry.value, state, joinArrayPath(path155, entry.key), options)
       );
     }
     return copy;
@@ -111506,16 +111506,16 @@ function copyFromSandbox(value, state, path154 = "<root>", options) {
     }
     const copy = createPlainObject(Object.getPrototypeOf(value) === null);
     state.seen.set(value, copy);
-    for (const entry of getEnumerableObjectEntries(value, path154)) {
+    for (const entry of getEnumerableObjectEntries(value, path155)) {
       defineOwnDataProperty(
         copy,
         entry.key,
-        copyFromSandbox(entry.value, state, joinPath(path154, entry.key), options)
+        copyFromSandbox(entry.value, state, joinPath(path155, entry.key), options)
       );
     }
     return copy;
   }
-  throw new TypeError(`Unsupported sandbox value at ${path154}: ${describeValue(value)}`);
+  throw new TypeError(`Unsupported sandbox value at ${path155}: ${describeValue(value)}`);
 }
 function isSandboxPrimitive(value) {
   return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
@@ -111544,7 +111544,7 @@ function defineOwnDataProperty(target, key2, value) {
     value
   });
 }
-function getEnumerableObjectEntries(value, path154) {
+function getEnumerableObjectEntries(value, path155) {
   const descriptors = Object.getOwnPropertyDescriptors(value);
   const entries = [];
   for (const [key2, descriptor] of Object.entries(descriptors)) {
@@ -111552,7 +111552,7 @@ function getEnumerableObjectEntries(value, path154) {
       continue;
     }
     if ("get" in descriptor || "set" in descriptor) {
-      throw new TypeError(`Unsupported sandbox value at ${joinPath(path154, key2)}: accessor property`);
+      throw new TypeError(`Unsupported sandbox value at ${joinPath(path155, key2)}: accessor property`);
     }
     entries.push({
       key: key2,
@@ -111561,7 +111561,7 @@ function getEnumerableObjectEntries(value, path154) {
   }
   return entries;
 }
-function getEnumerableArrayEntries(value, path154) {
+function getEnumerableArrayEntries(value, path155) {
   const descriptors = Object.getOwnPropertyDescriptors(value);
   const entries = [];
   for (const [key2, descriptor] of Object.entries(descriptors)) {
@@ -111570,7 +111570,7 @@ function getEnumerableArrayEntries(value, path154) {
     }
     if ("get" in descriptor || "set" in descriptor) {
       throw new TypeError(
-        `Unsupported sandbox value at ${joinArrayPath(path154, key2)}: accessor property`
+        `Unsupported sandbox value at ${joinArrayPath(path155, key2)}: accessor property`
       );
     }
     entries.push({
@@ -111599,11 +111599,11 @@ function describeValue(value) {
   }
   return typeof value;
 }
-function joinPath(path154, key2) {
-  return path154 === "<root>" ? `<root>.${key2}` : `${path154}.${key2}`;
+function joinPath(path155, key2) {
+  return path155 === "<root>" ? `<root>.${key2}` : `${path155}.${key2}`;
 }
-function joinArrayPath(path154, key2) {
-  return isArrayIndexKey(key2) ? `${path154}[${key2}]` : joinPath(path154, key2);
+function joinArrayPath(path155, key2) {
+  return isArrayIndexKey(key2) ? `${path155}[${key2}]` : joinPath(path155, key2);
 }
 var sandboxClosureBrand, sandboxPromiseBrand;
 var init_values = __esm({
@@ -113354,7 +113354,7 @@ function wrapHostPromiseWithSignal(promise, signal) {
     );
   });
 }
-function copyHostValueToSandbox(value, stackFrames, options, state, path154) {
+function copyHostValueToSandbox(value, stackFrames, options, state, path155) {
   const { budget } = options;
   if (value === null || value === void 0 || typeof value === "number" || typeof value === "boolean") {
     return value;
@@ -113371,7 +113371,7 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path154) {
     if (existing !== void 0) {
       return existing;
     }
-    const properties = copyFunctionProperties(callable, stackFrames, options, state, path154);
+    const properties = copyFunctionProperties(callable, stackFrames, options, state, path155);
     const wrapped = createSandboxClosure({
       ...isAsyncFunction(callable) ? { async: true } : {},
       call: (args, context) => {
@@ -113394,7 +113394,7 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path154) {
           throw createHostErrorValue(error3, context?.stack ?? [], budget, context?.span);
         }
       },
-      name: callable.name.length > 0 ? callable.name : readPathName(path154),
+      name: callable.name.length > 0 ? callable.name : readPathName(path155),
       ...properties ? { properties } : {}
     });
     state.seen.set(value, wrapped);
@@ -113444,7 +113444,7 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path154) {
     state.seen.set(value, copy);
     budget.allocateArrayLength(value.length);
     value.forEach((entry, index) => {
-      copy[index] = copyHostValueToSandbox(entry, stackFrames, options, state, `${path154}[${index}]`);
+      copy[index] = copyHostValueToSandbox(entry, stackFrames, options, state, `${path155}[${index}]`);
     });
     return copy;
   }
@@ -113461,7 +113461,7 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path154) {
       }
       if ("get" in descriptor || "set" in descriptor) {
         throw new TypeError(
-          `Unsupported sandbox value at ${joinPath2(path154, key2)}: accessor property`
+          `Unsupported sandbox value at ${joinPath2(path155, key2)}: accessor property`
         );
       }
       Object.defineProperty(copy, key2, {
@@ -113473,13 +113473,13 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path154) {
           stackFrames,
           options,
           state,
-          joinPath2(path154, key2)
+          joinPath2(path155, key2)
         )
       });
     }
     return copy;
   }
-  throw new TypeError(`Unsupported sandbox value at ${path154}: ${describeValue2(value)}`);
+  throw new TypeError(`Unsupported sandbox value at ${path155}: ${describeValue2(value)}`);
 }
 function readAbortReason2(signal) {
   return signal.reason ?? createAbortError12();
@@ -113528,7 +113528,7 @@ function readStringProperty(value, key2) {
   const entry = value[key2];
   return typeof entry === "string" ? entry : void 0;
 }
-function copyFunctionProperties(callable, stackFrames, options, state, path154) {
+function copyFunctionProperties(callable, stackFrames, options, state, path155) {
   const properties = {};
   for (const key2 of Object.keys(callable)) {
     const descriptor = Object.getOwnPropertyDescriptor(callable, key2);
@@ -113546,7 +113546,7 @@ function copyFunctionProperties(callable, stackFrames, options, state, path154)
       stackFrames,
       options,
       state,
-      joinPath2(path154, key2)
+      joinPath2(path155, key2)
     );
   }
   return Object.keys(properties).length > 0 ? properties : void 0;
@@ -113558,11 +113558,11 @@ function isPlainObject10(value) {
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
-function joinPath2(path154, key2) {
-  return /^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(key2) ? `${path154}.${key2}` : `${path154}[${JSON.stringify(key2)}]`;
+function joinPath2(path155, key2) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(key2) ? `${path155}.${key2}` : `${path155}[${JSON.stringify(key2)}]`;
 }
-function readPathName(path154) {
-  const segment = path154.replace(/^.*\./u, "");
+function readPathName(path155) {
+  const segment = path155.replace(/^.*\./u, "");
   return segment === "<root>" ? "host" : segment;
 }
 function describeValue2(value) {
@@ -116483,7 +116483,7 @@ var init_dump = __esm({
 
 // packages/agent-script/src/snapshot/backend.ts
 import { randomUUID as randomUUID16 } from "node:crypto";
-import { readFile as readFile49, rename as rename24, stat as stat31, unlink as unlink22, writeFile as writeFile27 } from "node:fs/promises";
+import { readFile as readFile50, rename as rename24, stat as stat31, unlink as unlink22, writeFile as writeFile27 } from "node:fs/promises";
 import { dirname as dirname9 } from "node:path";
 async function writeSnapshotAtomically(snapshotPath, snapshot2, options) {
   const parentPath = dirname9(snapshotPath);
@@ -116542,16 +116542,16 @@ async function writeSnapshotOnce(temporaryPath, snapshotPath, contents) {
     }
   }
 }
-async function enqueueOperation(path154, operation) {
-  const previous = pendingOperations.get(path154) ?? Promise.resolve();
+async function enqueueOperation(path155, operation) {
+  const previous = pendingOperations.get(path155) ?? Promise.resolve();
   const pending = previous.catch(() => void 0).then(operation);
   const queued = pending.catch(() => void 0);
-  pendingOperations.set(path154, queued);
+  pendingOperations.set(path155, queued);
   try {
     await pending;
   } finally {
-    if (pendingOperations.get(path154) === queued) {
-      pendingOperations.delete(path154);
+    if (pendingOperations.get(path155) === queued) {
+      pendingOperations.delete(path155);
     }
   }
 }
@@ -116590,8 +116590,8 @@ var init_backend = __esm({
     LOCKED_FILE_ERROR_CODES = /* @__PURE__ */ new Set(["EACCES", "EBUSY", "EPERM"]);
     pendingOperations = /* @__PURE__ */ new Map();
     FileSnapshotBackend = class {
-      constructor(path154, options = {}) {
-        this.path = path154;
+      constructor(path155, options = {}) {
+        this.path = path155;
         this.#writeMaxAttempts = options.writeMaxAttempts ?? DEFAULT_WRITE_MAX_ATTEMPTS;
         this.#writeRetryDelayMs = options.writeRetryDelayMs ?? DEFAULT_WRITE_RETRY_DELAY_MS;
       }
@@ -116600,7 +116600,7 @@ var init_backend = __esm({
       #writeRetryDelayMs;
       async read() {
         try {
-          return JSON.parse(await readFile49(this.path, "utf8"));
+          return JSON.parse(await readFile50(this.path, "utf8"));
         } catch (error3) {
           if (hasErrorCode4(error3, "ENOENT")) {
             return void 0;
@@ -119786,7 +119786,7 @@ var init_runtime_modules = __esm({
 });
 
 // packages/agent-script/src/runner/run-harness.ts
-import { readFile as readFile50, stat as stat32 } from "node:fs/promises";
+import { readFile as readFile51, stat as stat32 } from "node:fs/promises";
 import { extname as extname2 } from "node:path";
 var init_run_harness = __esm({
   "packages/agent-script/src/runner/run-harness.ts"() {
@@ -120274,7 +120274,7 @@ var init_fail = __esm({
 
 // packages/agent-script/src/modules/git.ts
 import { execFile as execFile3 } from "node:child_process";
-import { mkdir as mkdir34, realpath as realpath9, rm as rm12 } from "node:fs/promises";
+import { mkdir as mkdir34, realpath as realpath10, rm as rm12 } from "node:fs/promises";
 import { basename as basename7, dirname as dirname10, isAbsolute as isAbsolute6, relative as relative5, resolve as resolve8, sep as sep6 } from "node:path";
 function makeGitModule(cwd) {
   const normalizedCwd = readNonEmptyString6(cwd, "Git module cwd");
@@ -120381,9 +120381,9 @@ function makeGitModule(cwd) {
         branch: normalizedBranch
       };
     },
-    async worktreeRemove(path154) {
+    async worktreeRemove(path155) {
       const repoRoot = await getRepoRoot(normalizedCwd);
-      const worktreePath = await resolveWorktreePath(repoRoot, path154, "Git worktree path");
+      const worktreePath = await resolveWorktreePath(repoRoot, path155, "Git worktree path");
       const worktrees = await listWorktrees(normalizedCwd);
       if (!worktrees.some((worktree) => resolve8(worktree.path) === worktreePath)) {
         return;
@@ -120489,10 +120489,10 @@ function parseBranchRef(ref) {
   const branchPrefix = "refs/heads/";
   return ref.startsWith(branchPrefix) ? ref.slice(branchPrefix.length) : ref;
 }
-async function resolveWorktreePath(repoRoot, path154, label) {
+async function resolveWorktreePath(repoRoot, path155, label) {
   const resolvedRoot = resolve8(repoRoot);
-  const resolvedPath = isAbsolute6(path154) ? resolve8(path154) : resolve8(resolvedRoot, path154);
-  const canonicalRoot = await realpath9(resolvedRoot);
+  const resolvedPath = isAbsolute6(path155) ? resolve8(path155) : resolve8(resolvedRoot, path155);
+  const canonicalRoot = await realpath10(resolvedRoot);
   const canonicalPath = await resolveCanonicalPath(resolvedPath);
   const relativePath = relative5(canonicalRoot, canonicalPath);
   if (relativePath.length === 0 || relativePath === ".." || relativePath.startsWith(`..${sep6}`) || isAbsolute6(relativePath)) {
@@ -120500,12 +120500,12 @@ async function resolveWorktreePath(repoRoot, path154, label) {
   }
   return canonicalPath;
 }
-async function resolveCanonicalPath(path154) {
+async function resolveCanonicalPath(path155) {
   const missingSegments = [];
-  let current = path154;
+  let current = path155;
   while (true) {
     try {
-      const canonicalCurrent = await realpath9(current);
+      const canonicalCurrent = await realpath10(current);
       return resolve8(canonicalCurrent, ...missingSegments.reverse());
     } catch (error3) {
       if (!isNotFoundError9(error3)) {
@@ -120513,7 +120513,7 @@ async function resolveCanonicalPath(path154) {
       }
       const parent = dirname10(current);
       if (parent === current) {
-        return resolve8(path154);
+        return resolve8(path155);
       }
       missingSegments.push(basename7(current));
       current = parent;
@@ -121053,7 +121053,7 @@ var init_extract_schema = __esm({
 
 // packages/agent-harness/src/codegen/emit-schemas.ts
 import * as nodeFs16 from "node:fs/promises";
-import path150 from "node:path";
+import path151 from "node:path";
 import { fileURLToPath as fileURLToPath13 } from "node:url";
 var init_emit_schemas = __esm({
   "packages/agent-harness/src/codegen/emit-schemas.ts"() {
@@ -121108,21 +121108,21 @@ var init_pair = __esm({
     MissingPairError = class extends Error {
       side;
       path;
-      constructor(side, path154) {
-        super(`Missing harness ${side} file: ${path154}`);
+      constructor(side, path155) {
+        super(`Missing harness ${side} file: ${path155}`);
         this.name = "MissingPairError";
         this.side = side;
-        this.path = path154;
+        this.path = path155;
       }
     };
     InvalidPairExtensionError = class extends Error {
       extension;
       path;
-      constructor(path154, extension) {
-        super(`Harness pair input must be a .md or .ajs file: ${path154}`);
+      constructor(path155, extension) {
+        super(`Harness pair input must be a .md or .ajs file: ${path155}`);
         this.name = "InvalidPairExtensionError";
         this.extension = extension;
-        this.path = path154;
+        this.path = path155;
       }
     };
   }
@@ -121188,8 +121188,8 @@ function validateFrontmatter(schema2, frontmatter, mdPath) {
 function formatIssues2(mdPath, issues) {
   return issues.map((issue) => `${mdPath} (${formatPath3(issue.path)}): ${issue.message}`).join("\n");
 }
-function formatPath3(path154) {
-  return path154.join(".") || "frontmatter";
+function formatPath3(path155) {
+  return path155.join(".") || "frontmatter";
 }
 var FrontmatterValidationError;
 var init_validate4 = __esm({
@@ -121209,7 +121209,7 @@ var init_validate4 = __esm({
 
 // packages/agent-harness/src/loader/run.ts
 import { createHash as createHash10 } from "node:crypto";
-import { lstat as lstat29, mkdir as mkdir35, readFile as readFile52, rename as rename25, unlink as unlink23, writeFile as writeFile28 } from "node:fs/promises";
+import { lstat as lstat29, mkdir as mkdir35, readFile as readFile53, rename as rename25, unlink as unlink23, writeFile as writeFile28 } from "node:fs/promises";
 import os17 from "node:os";
 import { dirname as dirname12, join as join13, parse as parse15, resolve as resolve9, sep as sep7 } from "node:path";
 async function runHarnessPair2(mdPath, options) {
@@ -121554,7 +121554,7 @@ async function createHostCallReplay(snapshotPath, statefulBindings = {}) {
 }
 async function readHostCallRecords(storePath) {
   try {
-    const parsed = JSON.parse(await readFile52(storePath, "utf8"));
+    const parsed = JSON.parse(await readFile53(storePath, "utf8"));
     return Array.isArray(parsed) ? parsed : [];
   } catch (error3) {
     if (hasErrorCode5(error3, "ENOENT")) {
@@ -121583,9 +121583,9 @@ async function writeHostCallRecords(storePath, records) {
 async function cleanupCompletedSnapshot(snapshotBackend, snapshotPath) {
   await Promise.all([snapshotBackend.remove(), unlinkIfExists(hostCallStorePath(snapshotPath))]);
 }
-async function unlinkIfExists(path154) {
+async function unlinkIfExists(path155) {
   try {
-    await unlink23(path154);
+    await unlink23(path155);
   } catch (error3) {
     if (!hasErrorCode5(error3, "ENOENT")) {
       throw error3;
@@ -121646,8 +121646,8 @@ async function assertDefaultSnapshotPathIsRegular(snapshotPath) {
     }
   }
 }
-async function readTextFile(path154) {
-  const source = await readFile52(path154, "utf8");
+async function readTextFile(path155) {
+  const source = await readFile53(path155, "utf8");
   return source.startsWith("\uFEFF") ? source.slice(1) : source;
 }
 function formatLintErrorMessage(diagnostics) {
@@ -121704,7 +121704,7 @@ var init_run6 = __esm({
 });
 
 // packages/agent-harness/src/testing/replay-equivalence.ts
-import { mkdir as mkdir36, readFile as readFile53, rm as rm13, writeFile as writeFile29 } from "node:fs/promises";
+import { mkdir as mkdir36, readFile as readFile54, rm as rm13, writeFile as writeFile29 } from "node:fs/promises";
 import os18 from "node:os";
 import { join as join14 } from "node:path";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
@@ -121756,8 +121756,8 @@ var init_src44 = __esm({
 });
 
 // src/cli/commands/harness.ts
-import path151 from "node:path";
-import { readFile as readFile54 } from "node:fs/promises";
+import path152 from "node:path";
+import { readFile as readFile55 } from "node:fs/promises";
 function registerHarnessCommand(program, container) {
   const harness = program.command("harness").description("Run and manage agent harness pairs.");
   harness.command("run").description("Run a harness pair.").argument("[md-path]", "Path to the harness .md file").option("--fix", "Apply supported lint fixes to the harness .ajs file before running.").option("--snapshot-path <path>", "File to write/read harness snapshots.").option("--resume", "Resume from the snapshot file when it exists.").option(
@@ -121782,7 +121782,7 @@ function registerHarnessCommand(program, container) {
 async function executeHarnessRun(program, container, mdPath, options) {
   const flags = resolveHarnessFlags(program, options.yes);
   const resources = createExecutionResources(container, flags, "harness:run");
-  const selectedPath = mdPath ? path151.resolve(container.env.cwd, mdPath) : (await resolveDiscoveredHarness(container, flags.assumeYes)).mdPath;
+  const selectedPath = mdPath ? path152.resolve(container.env.cwd, mdPath) : (await resolveDiscoveredHarness(container, flags.assumeYes)).mdPath;
   if (flags.dryRun) {
     resources.logger.dryRun(
       `Dry run: would run ${formatDisplayPath2(container, selectedPath)} without executing its script or applying fixes.`
@@ -121848,10 +121848,10 @@ function buildAgentFrontmatterOverrides(options) {
 }
 function resolveRunSnapshotPath(container, mdPath, snapshotPath) {
   if (snapshotPath !== void 0) {
-    return path151.resolve(container.env.cwd, snapshotPath);
+    return path152.resolve(container.env.cwd, snapshotPath);
   }
-  const basename9 = path151.basename(mdPath, path151.extname(mdPath));
-  return path151.join(container.env.cwd, ".poe-code", "harnesses", basename9, "snapshot.json");
+  const basename9 = path152.basename(mdPath, path152.extname(mdPath));
+  return path152.join(container.env.cwd, ".poe-code", "harnesses", basename9, "snapshot.json");
 }
 async function prepareHarnessSnapshot(container, mdPath, snapshotPath, resumeRequested) {
   const snapshotExists = await pathExists15(container, snapshotPath);
@@ -121920,8 +121920,8 @@ function formatRunMessage(baseMessage, progress) {
   return progress === void 0 ? baseMessage : `${baseMessage} (${progress})`;
 }
 function resolveAjsPath(mdPath) {
-  const parsed = path151.parse(mdPath);
-  return path151.join(parsed.dir, `${parsed.name}.ajs`);
+  const parsed = path152.parse(mdPath);
+  return path152.join(parsed.dir, `${parsed.name}.ajs`);
 }
 async function pathExists15(container, targetPath) {
   try {
@@ -121945,14 +121945,14 @@ async function executeHarnessNew(program, container, kind, basename9, options) {
   if (!template2) {
     throw new ValidationError(`Unknown harness template "${kind}".`);
   }
-  if (basename9.length === 0 || basename9 === "." || basename9 === ".." || path151.basename(basename9) !== basename9) {
+  if (basename9.length === 0 || basename9 === "." || basename9 === ".." || path152.basename(basename9) !== basename9) {
     throw new ValidationError(`Invalid harness basename "${basename9}". Use a single directory name.`);
   }
-  const defaultDir = path151.join(".poe-code", "harnesses", basename9);
+  const defaultDir = path152.join(".poe-code", "harnesses", basename9);
   const outputDir = options.dir ?? await resolveOutputDir(defaultDir, flags.assumeYes);
-  const resolvedDir = path151.resolve(container.env.cwd, outputDir);
-  const mdPath = path151.join(resolvedDir, `${basename9}.md`);
-  const ajsPath = path151.join(resolvedDir, `${basename9}.ajs`);
+  const resolvedDir = path152.resolve(container.env.cwd, outputDir);
+  const mdPath = path152.join(resolvedDir, `${basename9}.md`);
+  const ajsPath = path152.join(resolvedDir, `${basename9}.ajs`);
   await assertFilesDoNotExist(container, [mdPath, ajsPath]);
   if (flags.dryRun) {
     resources.logger.dryRun(`Would create ${formatDisplayPath2(container, mdPath)}`);
@@ -121960,8 +121960,8 @@ async function executeHarnessNew(program, container, kind, basename9, options) {
     return;
   }
   const [mdSource, ajsSource] = await Promise.all([
-    readFile54(template2.mdPath, "utf8"),
-    readFile54(template2.ajsPath, "utf8")
+    readFile55(template2.mdPath, "utf8"),
+    readFile55(template2.ajsPath, "utf8")
   ]);
   await container.fs.mkdir(resolvedDir, { recursive: true });
   try {
@@ -122054,8 +122054,8 @@ async function resolveDiscoveredHarness(container, assumeYes) {
 }
 async function discoverProjectThenUserHarnesses(container) {
   const roots = [
-    path151.join(container.env.cwd, ".poe-code", "harnesses"),
-    path151.join(container.env.homeDir, ".poe-code", "harnesses")
+    path152.join(container.env.cwd, ".poe-code", "harnesses"),
+    path152.join(container.env.homeDir, ".poe-code", "harnesses")
   ];
   const discovered = [];
   for (const root of roots) {
@@ -122067,7 +122067,7 @@ async function discoverProjectThenUserHarnesses(container) {
       const stat33 = await container.fs.stat(pair.mdPath);
       discovered.push({
         ...pair,
-        dir: path151.dirname(pair.mdPath),
+        dir: path152.dirname(pair.mdPath),
         mdMtimeMs: stat33.mtimeMs
       });
     }
@@ -122172,8 +122172,8 @@ function toModuleExports(moduleExports) {
   return new Map(Object.entries(moduleExports));
 }
 function formatDisplayPath2(container, filePath) {
-  const relative6 = path151.relative(container.env.cwd, filePath);
-  return relative6.length > 0 && !relative6.startsWith("..") && !path151.isAbsolute(relative6) ? relative6 : filePath.replace(container.env.homeDir, "~");
+  const relative6 = path152.relative(container.env.cwd, filePath);
+  return relative6.length > 0 && !relative6.startsWith("..") && !path152.isAbsolute(relative6) ? relative6 : filePath.replace(container.env.homeDir, "~");
 }
 var init_harness3 = __esm({
   async "src/cli/commands/harness.ts"() {
@@ -122252,7 +122252,7 @@ var init_braintrust = __esm({
 
 // src/cli/commands/tasks-options.ts
 import * as fsPromises23 from "node:fs/promises";
-import path152 from "node:path";
+import path153 from "node:path";
 async function resolveWorkflowTaskListOptions(workflowPath) {
   const frontmatter = await readWorkflowFrontmatter(workflowPath);
   return readTaskListOptions(frontmatter, workflowPath);
@@ -122476,7 +122476,7 @@ function resolveStringValue2(value) {
   return process.env[value.slice(envPrefix.length)] ?? value;
 }
 function resolveWorkflowRelativePath(value, workflowPath) {
-  return path152.isAbsolute(value) ? value : path152.resolve(path152.dirname(workflowPath), value);
+  return path153.isAbsolute(value) ? value : path153.resolve(path153.dirname(workflowPath), value);
 }
 function asRecord5(value) {
   return isPlainRecord3(value) ? value : void 0;
@@ -122513,7 +122513,7 @@ var init_tasks_options = __esm({
 });
 
 // src/cli/commands/tasks.ts
-import path153 from "node:path";
+import path154 from "node:path";
 function registerTasksCommand(program, container) {
   const tasks = program.command("tasks").description("Read and mutate configured workflow tasks.");
   tasks.command("verify").description("Verify a task GitHub Project.").argument("<list>", "Project list in <owner>/<number> format.").option("--workflow <path>", "Workflow file path.", "./WORKFLOW.md").option("--repo <owner/name>", "GitHub repository owner/name.").option("--project <owner/number>", "GitHub project owner/number.").option("--states <csv>", "Required task state names.").option("--json", "Print the verification report as JSON.").action(async (list, options, command) => {
@@ -122643,7 +122643,7 @@ async function runImport(options, container) {
     const limit = options.limit === void 0 ? void 0 : parseNonNegativeInteger3(options.limit, "--limit");
     const source = {
       type: "markdown-dir",
-      path: path153.resolve(options.from),
+      path: path154.resolve(options.from),
       singleList: "import",
       frontmatterMode: "passthrough"
     };
@@ -122997,7 +122997,7 @@ var init_package2 = __esm({
   "package.json"() {
     package_default2 = {
       name: "poe-code",
-      version: "3.0.237",
+      version: "3.0.238",
       description: "CLI tool to configure Poe API for developer workflows.",
       type: "module",
       main: "./dist/index.js",
@@ -123243,22 +123243,22 @@ function formatCommandHeader(cmd) {
   }
   return `Poe - ${parts.reverse().join(" ")}`;
 }
-function findCommandByPath(root, path154) {
+function findCommandByPath(root, path155) {
   let current = root;
-  for (const segment of path154) {
+  for (const segment of path155) {
     const next = current.commands.find(
       (command) => Reflect.get(command, "_hidden") !== true && command.name() === segment
     );
     if (!next) {
-      throw new Error(`Root help command is missing: ${path154.join(" ")}`);
+      throw new Error(`Root help command is missing: ${path155.join(" ")}`);
     }
     current = next;
   }
   return current;
 }
-function formatRootHelpCommandName(path154, command) {
+function formatRootHelpCommandName(path155, command) {
   const leaf = [command.name(), ...command.aliases()].join(", ");
-  return path154.length > 1 ? [...path154.slice(0, -1), leaf].join(" ") : leaf;
+  return path155.length > 1 ? [...path155.slice(0, -1), leaf].join(" ") : leaf;
 }
 function splitUsageParts(usage) {
   return usage.split(" ").map((part) => part.trim()).filter((part) => part.length > 0);
@@ -123524,8 +123524,8 @@ function registerMaestroCommand(program, container) {
       "--log-level <level>",
       maestroCommandSchema.shape.logLevel.description ?? "Log level"
     ).choices(maestroCommandSchema.shape.logLevel.values.map(String)).default(maestroCommandSchema.shape.logLevel.default)
-  ).action(async (path154, options, command) => {
-    if (path154 === "tui") {
+  ).action(async (path155, options, command) => {
+    if (path155 === "tui") {
       throw new ValidationError(
         "`poe-code maestro tui` only accepts --config, --workflow, or --name."
       );
@@ -123535,7 +123535,7 @@ function registerMaestroCommand(program, container) {
       ...command.optsWithGlobals()
     };
     await runMaestro({
-      workflowPath: path154,
+      workflowPath: path155,
       maxConcurrent: mergedOptions.maxConcurrent,
       pollIntervalMs: mergedOptions.pollIntervalMs,
       list: mergedOptions.list,
@@ -124159,14 +124159,14 @@ function createCliMain(programFactory) {
     }
   };
 }
-function isCliInvocation(argv, moduleUrl, realpath10 = realpathSync) {
+function isCliInvocation(argv, moduleUrl, realpath11 = realpathSync) {
   const entry = argv.at(1);
   if (typeof entry !== "string") {
     return false;
   }
   const candidates = [pathToFileURL2(entry).href];
   try {
-    candidates.push(pathToFileURL2(realpath10(entry)).href);
+    candidates.push(pathToFileURL2(realpath11(entry)).href);
   } catch {
   }
   return candidates.includes(moduleUrl);
@@ -124322,6 +124322,91 @@ var planDocumentSchema = {
   additionalProperties: true
 };
 
+// src/sdk/prompt-document.ts
+init_src4();
+import { readFile as readFile26, realpath as realpath5 } from "node:fs/promises";
+import path97 from "node:path";
+var nativeFs = { readFile: readFile26, realpath: realpath5 };
+async function resolvePromptDocument(input) {
+  const cwd = path97.resolve(input.cwd);
+  const filePath = path97.resolve(cwd, input.filePath);
+  assertInsideRoot(filePath, cwd, "Prompt document path must remain inside cwd");
+  const basePaths = (input.basePaths ?? []).map((basePath) => {
+    if (!path97.isAbsolute(basePath)) {
+      throw new Error(`Prompt document base paths must be absolute: ${basePath}`);
+    }
+    return path97.resolve(basePath);
+  });
+  const fs27 = createRootedFileSystem(input.fs ?? nativeFs, [cwd, ...basePaths]);
+  const content = input.content ?? await readDocumentContent2(fs27, filePath, input.optional);
+  const chain = [
+    { source: "document", filePath, content },
+    ...basePaths.map((basePath, index) => ({ source: `base-${index + 1}`, path: basePath }))
+  ];
+  const composed = await resolve(chain, { fs: fs27 });
+  const rendered = await resolve(chain, {
+    fs: fs27,
+    view: input.variables ?? {},
+    validate: input.validate ?? true
+  });
+  const template2 = requirePrompt(composed.data.prompt, filePath);
+  const prompt = requirePrompt(rendered.data.prompt, filePath);
+  const { prompt: _ignored, ...metadata } = rendered.data;
+  void _ignored;
+  return {
+    template: template2,
+    prompt,
+    metadata,
+    sources: rendered.sources,
+    source: filePath,
+    chain: rendered.chain
+  };
+}
+async function readDocumentContent2(fs27, filePath, optional) {
+  try {
+    return await fs27.readFile(filePath, "utf8");
+  } catch (error3) {
+    if (optional && hasCode7(error3, "ENOENT")) {
+      return "---\nextends: true\n---\n";
+    }
+    throw error3;
+  }
+}
+function createRootedFileSystem(fs27, roots) {
+  return {
+    async readFile(filePath, encoding) {
+      await assertRealPathInsideOriginalRoot(fs27, filePath, roots);
+      return fs27.readFile(filePath, encoding);
+    },
+    realpath: (filePath) => fs27.realpath(filePath)
+  };
+}
+async function assertRealPathInsideOriginalRoot(fs27, filePath, roots) {
+  const resolvedPath = path97.resolve(await fs27.realpath(filePath));
+  const originalRoot = roots.find((root) => isInsideRoot(filePath, root));
+  if (!originalRoot || !isInsideRoot(resolvedPath, originalRoot)) {
+    throw new Error(`Prompt document path escapes configured root: ${filePath}`);
+  }
+}
+function assertInsideRoot(filePath, root, message2) {
+  if (!isInsideRoot(filePath, root)) {
+    throw new Error(`${message2}: ${filePath}`);
+  }
+}
+function isInsideRoot(filePath, root) {
+  const relativePath = path97.relative(path97.resolve(root), path97.resolve(filePath));
+  return relativePath === "" || relativePath !== ".." && !relativePath.startsWith(`..${path97.sep}`) && !path97.isAbsolute(relativePath);
+}
+function requirePrompt(value, filePath) {
+  if (typeof value !== "string") {
+    throw new Error(`Prompt document does not resolve to a Markdown prompt: ${filePath}`);
+  }
+  return value;
+}
+function hasCode7(error3, code) {
+  return typeof error3 === "object" && error3 !== null && "code" in error3 && error3.code === code;
+}
+
 // src/index.ts
 init_src37();
 init_src38();
@@ -124337,7 +124422,7 @@ init_config5();
 init_constants();
 init_errors2();
 import os16 from "node:os";
-import path120 from "node:path";
+import path121 from "node:path";
 import fsPromises22 from "node:fs/promises";
 import { Command } from "commander";
 function parseMcpSpawnConfig(input) {
@@ -124409,10 +124494,10 @@ function resolveWorkingDirectory(baseDir, candidate) {
   if (!candidate || candidate.trim().length === 0) {
     return void 0;
   }
-  if (path120.isAbsolute(candidate)) {
+  if (path121.isAbsolute(candidate)) {
     return candidate;
   }
-  return path120.resolve(baseDir, candidate);
+  return path121.resolve(baseDir, candidate);
 }
 function configurePoeAgentRunOptions(command) {
   return command.option("-y, --yes", "Accept configured defaults without prompting").option("--model <model>", "Model identifier override").option("--prompt <text>", "Prompt text to send").option("-C, --cwd <path>", "Working directory for the agent").option("--stdin", "Read the prompt from stdin").option(
@@ -124533,14 +124618,14 @@ async function main() {
   const runCli = createCliMain2(createProgram2);
   await runCli();
 }
-function isCliInvocation2(argv, moduleUrl, realpath10 = realpathSync2) {
+function isCliInvocation2(argv, moduleUrl, realpath11 = realpathSync2) {
   const entry = argv.at(1);
   if (typeof entry !== "string") {
     return false;
   }
   const candidates = [pathToFileURL3(entry).href];
   try {
-    candidates.push(pathToFileURL3(realpath10(entry)).href);
+    candidates.push(pathToFileURL3(realpath11(entry)).href);
   } catch {
   }
   return candidates.includes(moduleUrl);
@@ -124589,6 +124674,7 @@ export {
   readExperimentJournal,
   readLaunchLogs,
   removeLaunch,
+  resolvePromptDocument,
   restartLaunch,
   runCheckCli,
   runCodeReview,