poe-code 10.0.3 → 11.0.0

package/dist/index.js

@@ -67,9 +67,9 @@ function applyStyles(text5, styles) {
   if (!supportsColor() || styles.length === 0) {
     return text5;
   }
-  const open8 = styles.map((style) => style.open).join("");
-  const output = text5.includes(reset) ? replaceAll(text5, reset, `${reset}${open8}`) : text5;
-  return `${open8}${output}${reset}`;
+  const open9 = styles.map((style) => style.open).join("");
+  const output = text5.includes(reset) ? replaceAll(text5, reset, `${reset}${open9}`) : text5;
+  return `${open9}${output}${reset}`;
 }
 function clampRgb(value) {
   if (Number.isNaN(value)) {
@@ -1867,14 +1867,14 @@ function parseTemplate(template2) {
   let tokens = root;
   let index = 0;
   while (index < template2.length) {
-    const open8 = template2.indexOf("{{", index);
-    if (open8 === -1) {
+    const open9 = template2.indexOf("{{", index);
+    if (open9 === -1) {
       appendText(tokens, template2.slice(index), index);
       break;
     }
-    appendText(tokens, template2.slice(index, open8), index);
-    const parsed = parseTag(template2, open8);
-    const standalone = getStandalone(template2, open8, parsed.end, parsed.kind);
+    appendText(tokens, template2.slice(index, open9), index);
+    const parsed = parseTag(template2, open9);
+    const standalone = getStandalone(template2, open9, parsed.end, parsed.kind);
     if (standalone !== void 0) {
       trimTextAfter(tokens, standalone.lineStart);
     }
@@ -1891,7 +1891,7 @@ function parseTemplate(template2) {
         name: parsed.name,
         children: [],
         rawStart: parsed.end,
-        rawEnd: standalone?.lineStart ?? open8
+        rawEnd: standalone?.lineStart ?? open9
       };
       tokens.push(token);
       stack.push({ token, parent: tokens });
@@ -1903,7 +1903,7 @@ function parseTemplate(template2) {
       tokens.push({
         type: "partial",
         name: parsed.name,
-        indent: standalone === void 0 ? "" : template2.slice(standalone.lineStart, open8)
+        indent: standalone === void 0 ? "" : template2.slice(standalone.lineStart, open9)
       });
       index = standalone?.nextIndex ?? parsed.end;
       continue;
@@ -1916,12 +1916,12 @@ function parseTemplate(template2) {
       if (frame2.token.name !== parsed.name) {
         throw new Error(`Unclosed section "${frame2.token.name}" before closing "${parsed.name}"`);
       }
-      frame2.token.rawEnd = open8;
+      frame2.token.rawEnd = open9;
       tokens = frame2.parent;
       index = standalone?.nextIndex ?? parsed.end;
       continue;
     }
-    tokens.push({ type: parsed.kind, name: parsed.name, raw: template2.slice(open8, parsed.end) });
+    tokens.push({ type: parsed.kind, name: parsed.name, raw: template2.slice(open9, parsed.end) });
     index = parsed.end;
   }
   const frame = stack.pop();
@@ -1930,19 +1930,19 @@ function parseTemplate(template2) {
   }
   return root;
 }
-function parseTag(template2, open8) {
-  if (template2.startsWith("{{{", open8)) {
-    const close2 = template2.indexOf("}}}", open8 + 3);
+function parseTag(template2, open9) {
+  if (template2.startsWith("{{{", open9)) {
+    const close2 = template2.indexOf("}}}", open9 + 3);
     if (close2 === -1) {
-      throw unclosedTagError(template2, open8, "}}}");
+      throw unclosedTagError(template2, open9, "}}}");
     }
-    return { kind: "unescaped", name: template2.slice(open8 + 3, close2).trim(), end: close2 + 3 };
+    return { kind: "unescaped", name: template2.slice(open9 + 3, close2).trim(), end: close2 + 3 };
   }
-  const close = template2.indexOf("}}", open8 + 2);
+  const close = template2.indexOf("}}", open9 + 2);
   if (close === -1) {
-    throw unclosedTagError(template2, open8, "}}");
+    throw unclosedTagError(template2, open9, "}}");
   }
-  const raw = template2.slice(open8 + 2, close).trim();
+  const raw = template2.slice(open9 + 2, close).trim();
   const sigil = raw[0];
   const name = sigil === void 0 ? "" : raw.slice(1).trim();
   const end = close + 2;
@@ -1955,14 +1955,14 @@ function parseTag(template2, open8) {
   if (sigil === "=" && raw.endsWith("=")) return { kind: "delimiter", name, end };
   return { kind: "name", name: raw, end };
 }
-function unclosedTagError(template2, open8, expected) {
-  const before = template2.slice(0, open8);
-  const lineEnd = template2.indexOf("\n", open8);
-  const opened = template2.slice(open8, lineEnd === -1 ? template2.length : lineEnd).trimEnd();
+function unclosedTagError(template2, open9, expected) {
+  const before = template2.slice(0, open9);
+  const lineEnd = template2.indexOf("\n", open9);
+  const opened = template2.slice(open9, lineEnd === -1 ? template2.length : lineEnd).trimEnd();
   const tag = opened.length > MAX_TAG_EXCERPT_LENGTH ? `${opened.slice(0, MAX_TAG_EXCERPT_LENGTH)}...` : opened;
   return new TemplateParseError(`Unclosed tag "${tag}": expected "${expected}"`, {
     line: before.split("\n").length,
-    column: open8 - (before.lastIndexOf("\n") + 1) + 1
+    column: open9 - (before.lastIndexOf("\n") + 1) + 1
   });
 }
 function getStandalone(template2, tagStart, tagEnd, kind) {
@@ -2170,12 +2170,12 @@ function expandTemplatePartials(template2, partials, partialStack) {
   let output = "";
   let index = 0;
   while (index < template2.length) {
-    const open8 = template2.indexOf("{{", index);
-    if (open8 === -1) {
+    const open9 = template2.indexOf("{{", index);
+    if (open9 === -1) {
       output += template2.slice(index);
       break;
     }
-    const parsed = parseTag(template2, open8);
+    const parsed = parseTag(template2, open9);
     if (parsed.kind !== "partial") {
       output += template2.slice(index, parsed.end);
       index = parsed.end;
@@ -2192,9 +2192,9 @@ function expandTemplatePartials(template2, partials, partialStack) {
     if (partialStack.length >= MAX_PARTIAL_DEPTH) {
       throw new Error(`Maximum partial depth exceeded (${MAX_PARTIAL_DEPTH}).`);
     }
-    const standalone = getStandalone(template2, open8, parsed.end, parsed.kind);
-    const beforePartial = standalone === void 0 ? template2.slice(index, open8) : template2.slice(index, standalone.lineStart);
-    const indent = standalone === void 0 ? "" : template2.slice(standalone.lineStart, open8);
+    const standalone = getStandalone(template2, open9, parsed.end, parsed.kind);
+    const beforePartial = standalone === void 0 ? template2.slice(index, open9) : template2.slice(index, standalone.lineStart);
+    const indent = standalone === void 0 ? "" : template2.slice(standalone.lineStart, open9);
     const partial = indentPartial(partials[parsed.name], indent);
     output += beforePartial + expandTemplatePartials(partial, partials, [...partialStack, parsed.name]);
     index = standalone?.nextIndex ?? parsed.end;
@@ -2826,11 +2826,11 @@ function parseInline(raw, options = {}) {
         index = footnoteReference.end;
         continue;
       }
-      const link3 = parseLink(raw, index, footnoteLabels, offsets);
-      if (link3 !== null) {
+      const link4 = parseLink(raw, index, footnoteLabels, offsets);
+      if (link4 !== null) {
         flushText();
-        nodes.push(link3.node);
-        index = link3.end;
+        nodes.push(link4.node);
+        index = link4.end;
         continue;
       }
     }
@@ -10694,7 +10694,7 @@ function createFrameWriter(stream, options = {}) {
     close();
     process.kill(process.pid, signal);
   }
-  function open8() {
+  function open9() {
     if (opened) return;
     opened = true;
     stream.write(`${OPEN}${options.mouse === false ? CLOSE_MOUSE : OPEN_MOUSE}\x1B[?7l`);
@@ -10711,7 +10711,7 @@ function createFrameWriter(stream, options = {}) {
     stream.write(`\x1B[0m\x1B[?7h${options.mouse === false ? "" : CLOSE_MOUSE}${CLOSE}`);
   }
   return {
-    open: open8,
+    open: open9,
     close,
     writeFrame(ansi) {
       if (!opened || ansi.length === 0) return;
@@ -16370,17 +16370,17 @@ function validate(schema, value) {
   }
   return { ok: true, value: result.present ? result.value : void 0 };
 }
-function walkSchema(schema, value, path190, state) {
+function walkSchema(schema, value, path191, state) {
   if (schema.kind === "optional") {
-    return walkOptional(schema, value, path190, state);
+    return walkOptional(schema, value, path191, state);
   }
   if (value === missingValue) {
     addIssue(
       state,
-      path190,
+      path191,
       expectedFor(schema),
       "missing",
-      `Expected ${expectedFor(schema)} at ${formatPath(path190)}`
+      `Expected ${expectedFor(schema)} at ${formatPath(path191)}`
     );
     return { present: false };
   }
@@ -16389,149 +16389,149 @@ function walkSchema(schema, value, path190, state) {
   }
   switch (schema.kind) {
     case "string":
-      return walkString(schema, value, path190, state);
+      return walkString(schema, value, path191, state);
     case "number":
-      return walkNumber(schema, value, path190, state);
+      return walkNumber(schema, value, path191, state);
     case "boolean":
-      return walkBoolean(value, path190, state);
+      return walkBoolean(value, path191, state);
     case "enum":
-      return walkEnum(schema, value, path190, state);
+      return walkEnum(schema, value, path191, state);
     case "array":
-      return walkArray(schema, value, path190, state);
+      return walkArray(schema, value, path191, state);
     case "object":
-      return walkObject(schema, value, path190, state);
+      return walkObject(schema, value, path191, state);
     case "oneOf":
-      return walkOneOf(schema, value, path190, state);
+      return walkOneOf(schema, value, path191, state);
     case "union":
-      return walkUnion(schema, value, path190, state);
+      return walkUnion(schema, value, path191, state);
     case "record":
-      return walkRecord(schema, value, path190, state);
+      return walkRecord(schema, value, path191, state);
     case "json":
-      return walkJson(value, path190, state);
+      return walkJson(value, path191, state);
   }
 }
-function walkOptional(schema, value, path190, state) {
+function walkOptional(schema, value, path191, state) {
   if (value === missingValue || value === void 0) {
     const defaultValue = getDefault(schema.inner);
     if (defaultValue.present) {
-      return walkSchema(schema.inner, cloneDefault(defaultValue.value), path190, state);
+      return walkSchema(schema.inner, cloneDefault(defaultValue.value), path191, state);
     }
     return { present: false };
   }
-  return walkSchema(schema.inner, value, path190, state);
+  return walkSchema(schema.inner, value, path191, state);
 }
-function walkString(schema, value, path190, state) {
+function walkString(schema, value, path191, state) {
   if (typeof value !== "string") {
-    addExpectedIssue(state, path190, "string", value);
+    addExpectedIssue(state, path191, "string", value);
     return { present: true, value };
   }
   if (schema.minLength !== void 0 && value.length < schema.minLength) {
     const expected = `string with length at least ${schema.minLength}`;
     addIssue(
       state,
-      path190,
+      path191,
       expected,
       `string with length ${value.length}`,
-      `Expected ${expected} at ${formatPath(path190)}`
+      `Expected ${expected} at ${formatPath(path191)}`
     );
   }
   if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
     const expected = `string with length at most ${schema.maxLength}`;
     addIssue(
       state,
-      path190,
+      path191,
       expected,
       `string with length ${value.length}`,
-      `Expected ${expected} at ${formatPath(path190)}`
+      `Expected ${expected} at ${formatPath(path191)}`
     );
   }
   if (schema.pattern !== void 0) {
     const pattern = compilePattern(schema.pattern);
     if (pattern === void 0 || !pattern.test(value)) {
       const expected = `string matching pattern ${schema.pattern}`;
-      addIssue(state, path190, expected, value, `Expected ${expected} at ${formatPath(path190)}`);
+      addIssue(state, path191, expected, value, `Expected ${expected} at ${formatPath(path191)}`);
     }
   }
   return { present: true, value };
 }
-function walkNumber(schema, value, path190, state) {
+function walkNumber(schema, value, path191, state) {
   if (typeof value !== "number" || !Number.isFinite(value)) {
-    addExpectedIssue(state, path190, schema.jsonType === "integer" ? "integer" : "number", value);
+    addExpectedIssue(state, path191, schema.jsonType === "integer" ? "integer" : "number", value);
     return { present: true, value };
   }
   if (schema.jsonType === "integer" && !Number.isInteger(value)) {
-    addExpectedIssue(state, path190, "integer", value);
+    addExpectedIssue(state, path191, "integer", value);
   }
   if (schema.minimum !== void 0 && value < schema.minimum) {
     const expected = `number greater than or equal to ${schema.minimum}`;
-    addIssue(state, path190, expected, String(value), `Expected ${expected} at ${formatPath(path190)}`);
+    addIssue(state, path191, expected, String(value), `Expected ${expected} at ${formatPath(path191)}`);
   }
   if (schema.maximum !== void 0 && value > schema.maximum) {
     const expected = `number less than or equal to ${schema.maximum}`;
-    addIssue(state, path190, expected, String(value), `Expected ${expected} at ${formatPath(path190)}`);
+    addIssue(state, path191, expected, String(value), `Expected ${expected} at ${formatPath(path191)}`);
   }
   return { present: true, value };
 }
-function walkBoolean(value, path190, state) {
+function walkBoolean(value, path191, state) {
   if (typeof value !== "boolean") {
-    addExpectedIssue(state, path190, "boolean", value);
+    addExpectedIssue(state, path191, "boolean", value);
   }
   return { present: true, value };
 }
-function walkEnum(schema, value, path190, state) {
+function walkEnum(schema, value, path191, state) {
   if (!schema.values.includes(value)) {
     const expected = `one of ${schema.values.join(", ")}`;
     addIssue(
       state,
-      path190,
+      path191,
       expected,
       receivedValue(value),
-      `Expected ${expected} at ${formatPath(path190)}`
+      `Expected ${expected} at ${formatPath(path191)}`
     );
   }
   return { present: true, value };
 }
-function walkArray(schema, value, path190, state) {
+function walkArray(schema, value, path191, state) {
   if (!Array.isArray(value)) {
-    addExpectedIssue(state, path190, "array", value);
+    addExpectedIssue(state, path191, "array", value);
     return { present: true, value };
   }
   if (schema.minItems !== void 0 && value.length < schema.minItems) {
     const expected = `array with at least ${schema.minItems} items`;
     addIssue(
       state,
-      path190,
+      path191,
       expected,
       `array with ${value.length} items`,
-      `Expected ${expected} at ${formatPath(path190)}`
+      `Expected ${expected} at ${formatPath(path191)}`
     );
   }
   if (schema.maxItems !== void 0 && value.length > schema.maxItems) {
     const expected = `array with at most ${schema.maxItems} items`;
     addIssue(
       state,
-      path190,
+      path191,
       expected,
       `array with ${value.length} items`,
-      `Expected ${expected} at ${formatPath(path190)}`
+      `Expected ${expected} at ${formatPath(path191)}`
     );
   }
   const nextValue = value.map((item, index) => {
-    const result = walkSchema(schema.item, item, [...path190, String(index)], state);
+    const result = walkSchema(schema.item, item, [...path191, String(index)], state);
     return result.present ? result.value : item;
   });
   return { present: true, value: nextValue };
 }
-function walkObject(schema, value, path190, state, injectedProperties = {}) {
+function walkObject(schema, value, path191, state, injectedProperties = {}) {
   if (!isPlainRecord3(value)) {
-    addExpectedIssue(state, path190, "object", value);
+    addExpectedIssue(state, path191, "object", value);
     return { present: true, value };
   }
   const nextValue = {};
   const allowedKeys = /* @__PURE__ */ new Set([...Object.keys(schema.shape), ...Object.keys(injectedProperties)]);
   for (const [key3, propertySchema] of Object.entries(schema.shape)) {
     const propertyValue = Object.hasOwn(value, key3) ? value[key3] : missingValue;
-    const result = walkSchema(propertySchema, propertyValue, [...path190, key3], state);
+    const result = walkSchema(propertySchema, propertyValue, [...path191, key3], state);
     if (result.present) {
       setOwnValue(nextValue, key3, result.value);
     }
@@ -16550,18 +16550,18 @@ function walkObject(schema, value, path190, state, injectedProperties = {}) {
     if (schema.additionalProperties === true) {
       setOwnValue(nextValue, key3, propertyValue);
     } else {
-      addUnexpectedPropertyIssue(state, [...path190, key3]);
+      addUnexpectedPropertyIssue(state, [...path191, key3]);
     }
   }
   return { present: true, value: nextValue };
 }
-function walkOneOf(schema, value, path190, state) {
+function walkOneOf(schema, value, path191, state) {
   if (!isPlainRecord3(value)) {
-    addExpectedIssue(state, path190, "object", value);
+    addExpectedIssue(state, path191, "object", value);
     return { present: true, value };
   }
   const discriminatorValue = value[schema.discriminator];
-  const discriminatorPath = [...path190, schema.discriminator];
+  const discriminatorPath = [...path191, schema.discriminator];
   const branchValues = Object.keys(schema.branches);
   const expected = `one of ${branchValues.join(", ")}`;
   if (!Object.hasOwn(value, schema.discriminator)) {
@@ -16570,7 +16570,7 @@ function walkOneOf(schema, value, path190, state) {
       discriminatorPath,
       expected,
       "missing",
-      `Missing discriminator "${schema.discriminator}" at ${formatPath(path190)}. Expected one of: ${branchValues.join(", ")}.`
+      `Missing discriminator "${schema.discriminator}" at ${formatPath(path191)}. Expected one of: ${branchValues.join(", ")}.`
     );
     return { present: true, value };
   }
@@ -16584,21 +16584,21 @@ function walkOneOf(schema, value, path190, state) {
     );
     return { present: true, value };
   }
-  return walkObject(schema.branches[discriminatorValue], value, path190, state, {
+  return walkObject(schema.branches[discriminatorValue], value, path191, state, {
     [schema.discriminator]: discriminatorValue
   });
 }
-function walkUnion(schema, value, path190, state) {
+function walkUnion(schema, value, path191, state) {
   if (isPlainRecord3(value)) {
     const candidateBranches = schema.branches.filter((branch) => hasRequiredKeys(branch, value));
     if (candidateBranches.length === 1) {
-      return walkObject(candidateBranches[0], value, path190, state);
+      return walkObject(candidateBranches[0], value, path191, state);
     }
   }
   const matches = [];
   for (const branch of schema.branches) {
     const branchState = { issues: [] };
-    const result = walkObject(branch, value, path190, branchState);
+    const result = walkObject(branch, value, path191, branchState);
     if (branchState.issues.length === 0 && result.present) {
       matches.push({ fingerprint: getRequiredKeyFingerprint(branch), value: result.value });
     }
@@ -16610,19 +16610,19 @@ function walkUnion(schema, value, path190, state) {
     const branchDescriptions = schema.branches.map((branch) => getRequiredKeyFingerprint(branch));
     addIssueWithMessage(
       state,
-      path190,
+      path191,
       "exactly one union branch",
       "0 matching branches",
-      `No union branch matched at ${formatPath(path190)}. Tried ${schema.branches.length} branches. Expected one of: ${branchDescriptions.join(" | ")}.`
+      `No union branch matched at ${formatPath(path191)}. Tried ${schema.branches.length} branches. Expected one of: ${branchDescriptions.join(" | ")}.`
     );
     return { present: true, value };
   }
   addIssueWithMessage(
     state,
-    path190,
+    path191,
     "exactly one union branch",
     `${matches.length} matching branches`,
-    `Expected exactly one union branch at ${formatPath(path190)}, but matched more than one branch: ${matches.map((match) => match.fingerprint).join(" | ")}`
+    `Expected exactly one union branch at ${formatPath(path191)}, but matched more than one branch: ${matches.map((match) => match.fingerprint).join(" | ")}`
   );
   return { present: true, value };
 }
@@ -16634,25 +16634,25 @@ function hasRequiredKeys(schema, value) {
   }
   return true;
 }
-function walkRecord(schema, value, path190, state) {
+function walkRecord(schema, value, path191, state) {
   if (!isPlainRecord3(value)) {
-    addExpectedIssue(state, path190, "object", value);
+    addExpectedIssue(state, path191, "object", value);
     return { present: true, value };
   }
   const nextValue = {};
   for (const [key3, propertyValue] of Object.entries(value)) {
-    const result = walkSchema(schema.value, propertyValue, [...path190, key3], state);
+    const result = walkSchema(schema.value, propertyValue, [...path191, key3], state);
     if (result.present) {
       setOwnValue(nextValue, key3, result.value);
     }
   }
   return { present: true, value: nextValue };
 }
-function walkJson(value, path190, state) {
+function walkJson(value, path191, state) {
   if (isJsonValue(value)) {
     return { present: true, value };
   }
-  addExpectedIssue(state, path190, "JSON value", value);
+  addExpectedIssue(state, path191, "JSON value", value);
   return { present: true, value };
 }
 function getDefault(schema) {
@@ -16730,45 +16730,45 @@ function expectedFor(schema) {
       return expectedFor(schema.inner);
   }
 }
-function addExpectedIssue(state, path190, expected, value) {
+function addExpectedIssue(state, path191, expected, value) {
   addIssue(
     state,
-    path190,
+    path191,
     expected,
     receivedType(value),
-    `Expected ${expected} at ${formatPath(path190)}`
+    `Expected ${expected} at ${formatPath(path191)}`
   );
 }
-function addUnexpectedPropertyIssue(state, path190) {
+function addUnexpectedPropertyIssue(state, path191) {
   addIssue(
     state,
-    path190,
+    path191,
     "no additional properties",
     "unknown property",
-    `Unexpected property ${formatPath(path190)}`
+    `Unexpected property ${formatPath(path191)}`
   );
 }
-function addIssue(state, path190, expected, received, _message) {
+function addIssue(state, path191, expected, received, _message) {
   state.issues.push({
-    path: path190,
+    path: path191,
     expected,
     received,
-    message: formatIssueMessage(expected, path190, received)
+    message: formatIssueMessage(expected, path191, received)
   });
 }
-function addIssueWithMessage(state, path190, expected, received, message2) {
+function addIssueWithMessage(state, path191, expected, received, message2) {
   state.issues.push({
-    path: path190,
+    path: path191,
     expected,
     received,
     message: message2
   });
 }
-function formatIssueMessage(expected, path190, received) {
-  return `Expected ${expected} at ${formatPath(path190)}, got ${received}`;
+function formatIssueMessage(expected, path191, received) {
+  return `Expected ${expected} at ${formatPath(path191)}, got ${received}`;
 }
-function formatPath(path190) {
-  return path190.length === 0 ? "value" : path190.join(".");
+function formatPath(path191) {
+  return path191.length === 0 ? "value" : path191.join(".");
 }
 function compilePattern(pattern) {
   try {
@@ -16882,8 +16882,8 @@ function receivedType2(value) {
   }
   return typeof value;
 }
-function issue(path190, expected, value, message2, keyword = keywordFor(expected)) {
-  return { path: path190, expected, received: receivedType2(value), message: message2, keyword };
+function issue(path191, expected, value, message2, keyword = keywordFor(expected)) {
+  return { path: path191, expected, received: receivedType2(value), message: message2, keyword };
 }
 function keywordFor(expected) {
   if (["null", "boolean", "object", "array", "number", "integer", "string"].includes(expected)) {
@@ -17715,44 +17715,44 @@ function evaluateArrayApplicators(graph, node, schema, value, context) {
   }
   return results;
 }
-function evaluateValidationKeywords(node, schema, value, path190) {
+function evaluateValidationKeywords(node, schema, value, path191) {
   const results = [];
   if (schema.nullable === true && value === null) {
     return results;
   }
   const types2 = typeof schema.type === "string" ? [schema.type] : Array.isArray(schema.type) ? schema.type : [];
   if (types2.length > 0 && !types2.some((type) => typeof type === "string" && typeMatches(type, value))) {
-    results.push(invalidResult(issue(path190, types2.join(","), value, `must be ${types2.join(",")}`)));
+    results.push(invalidResult(issue(path191, types2.join(","), value, `must be ${types2.join(",")}`)));
     return results;
   }
   if (schema.const !== void 0 && !deepEqual(schema.const, value)) {
-    results.push(invalidResult(issue(path190, "const", value, "must be equal to constant")));
+    results.push(invalidResult(issue(path191, "const", value, "must be equal to constant")));
   }
   if (Array.isArray(schema.enum) && !schema.enum.some((entry) => deepEqual(entry, value))) {
     results.push(
-      invalidResult(issue(path190, "enum", value, "must be equal to one of the allowed values"))
+      invalidResult(issue(path191, "enum", value, "must be equal to one of the allowed values"))
     );
   }
   if (typeof value === "number" && Number.isFinite(value)) {
-    evaluateNumberKeywords(schema, value, path190, results);
+    evaluateNumberKeywords(schema, value, path191, results);
   }
   if (typeof value === "string") {
-    evaluateStringKeywords(schema, value, path190, results);
+    evaluateStringKeywords(schema, value, path191, results);
   }
   if (Array.isArray(value)) {
-    evaluateArrayKeywords(schema, value, path190, results);
+    evaluateArrayKeywords(schema, value, path191, results);
   }
   if (isObject(value)) {
-    evaluateObjectKeywords(node, schema, value, path190, results);
+    evaluateObjectKeywords(node, schema, value, path191, results);
   }
   return results;
 }
-function evaluateNumberKeywords(schema, value, path190, results) {
+function evaluateNumberKeywords(schema, value, path191, results) {
   if (typeof schema.multipleOf === "number" && !isMultipleOf(value, schema.multipleOf)) {
     results.push(
       invalidResult(
         issue(
-          path190,
+          path191,
           `multiple of ${schema.multipleOf}`,
           value,
           `must be multiple of ${schema.multipleOf}`
@@ -17762,36 +17762,36 @@ function evaluateNumberKeywords(schema, value, path190, results) {
   }
   if (typeof schema.maximum === "number" && value > schema.maximum) {
     results.push(
-      invalidResult(issue(path190, `<= ${schema.maximum}`, value, `must be <= ${schema.maximum}`))
+      invalidResult(issue(path191, `<= ${schema.maximum}`, value, `must be <= ${schema.maximum}`))
     );
   }
   if (typeof schema.minimum === "number" && value < schema.minimum) {
     results.push(
-      invalidResult(issue(path190, `>= ${schema.minimum}`, value, `must be >= ${schema.minimum}`))
+      invalidResult(issue(path191, `>= ${schema.minimum}`, value, `must be >= ${schema.minimum}`))
     );
   }
   if (typeof schema.exclusiveMaximum === "number" && value >= schema.exclusiveMaximum) {
     results.push(
       invalidResult(
-        issue(path190, `< ${schema.exclusiveMaximum}`, value, `must be < ${schema.exclusiveMaximum}`)
+        issue(path191, `< ${schema.exclusiveMaximum}`, value, `must be < ${schema.exclusiveMaximum}`)
       )
     );
   }
   if (typeof schema.exclusiveMinimum === "number" && value <= schema.exclusiveMinimum) {
     results.push(
       invalidResult(
-        issue(path190, `> ${schema.exclusiveMinimum}`, value, `must be > ${schema.exclusiveMinimum}`)
+        issue(path191, `> ${schema.exclusiveMinimum}`, value, `must be > ${schema.exclusiveMinimum}`)
       )
     );
   }
 }
-function evaluateStringKeywords(schema, value, path190, results) {
+function evaluateStringKeywords(schema, value, path191, results) {
   const length = unicodeLength(value);
   if (typeof schema.maxLength === "number" && length > schema.maxLength) {
     results.push(
       invalidResult(
         issue(
-          path190,
+          path191,
           `length <= ${schema.maxLength}`,
           value,
           `must NOT have more than ${schema.maxLength} characters`
@@ -17803,7 +17803,7 @@ function evaluateStringKeywords(schema, value, path190, results) {
     results.push(
       invalidResult(
         issue(
-          path190,
+          path191,
           `length >= ${schema.minLength}`,
           value,
           `must NOT have fewer than ${schema.minLength} characters`
@@ -17814,17 +17814,17 @@ function evaluateStringKeywords(schema, value, path190, results) {
   if (typeof schema.pattern === "string" && !new RegExp(schema.pattern, "u").test(value)) {
     results.push(
       invalidResult(
-        issue(path190, `pattern ${schema.pattern}`, value, `must match pattern ${schema.pattern}`)
+        issue(path191, `pattern ${schema.pattern}`, value, `must match pattern ${schema.pattern}`)
       )
     );
   }
 }
-function evaluateArrayKeywords(schema, value, path190, results) {
+function evaluateArrayKeywords(schema, value, path191, results) {
   if (typeof schema.maxItems === "number" && value.length > schema.maxItems) {
     results.push(
       invalidResult(
         issue(
-          path190,
+          path191,
           `items <= ${schema.maxItems}`,
           value,
           `must NOT have more than ${schema.maxItems} items`
@@ -17836,7 +17836,7 @@ function evaluateArrayKeywords(schema, value, path190, results) {
     results.push(
       invalidResult(
         issue(
-          path190,
+          path191,
           `items >= ${schema.minItems}`,
           value,
           `must NOT have fewer than ${schema.minItems} items`
@@ -17849,7 +17849,7 @@ function evaluateArrayKeywords(schema, value, path190, results) {
       for (let right = left + 1; right < value.length; right += 1) {
         if (deepEqual(value[left], value[right])) {
           results.push(
-            invalidResult(issue(path190, "unique items", value, "must NOT have duplicate items"))
+            invalidResult(issue(path191, "unique items", value, "must NOT have duplicate items"))
           );
           return;
         }
@@ -17857,13 +17857,13 @@ function evaluateArrayKeywords(schema, value, path190, results) {
     }
   }
 }
-function evaluateObjectKeywords(node, schema, value, path190, results) {
+function evaluateObjectKeywords(node, schema, value, path191, results) {
   const keys = Object.keys(value);
   if (typeof schema.maxProperties === "number" && keys.length > schema.maxProperties) {
     results.push(
       invalidResult(
         issue(
-          path190,
+          path191,
           `properties <= ${schema.maxProperties}`,
           value,
           `must NOT have more than ${schema.maxProperties} properties`
@@ -17875,7 +17875,7 @@ function evaluateObjectKeywords(node, schema, value, path190, results) {
     results.push(
       invalidResult(
         issue(
-          path190,
+          path191,
           `properties >= ${schema.minProperties}`,
           value,
           `must NOT have fewer than ${schema.minProperties} properties`
@@ -17888,7 +17888,7 @@ function evaluateObjectKeywords(node, schema, value, path190, results) {
       if (typeof key3 === "string" && !Object.prototype.hasOwnProperty.call(value, key3)) {
         results.push(
           invalidResult(
-            issue([...path190, key3], "required", void 0, `must have required property '${key3}'`)
+            issue([...path191, key3], "required", void 0, `must have required property '${key3}'`)
           )
         );
       }
@@ -17897,24 +17897,24 @@ function evaluateObjectKeywords(node, schema, value, path190, results) {
   const dependentRequired = isObject(schema.dependentRequired) ? schema.dependentRequired : {};
   for (const [key3, dependencies] of Object.entries(dependentRequired)) {
     if (Object.prototype.hasOwnProperty.call(value, key3) && Array.isArray(dependencies)) {
-      addMissingDependencies(value, dependencies, path190, results);
+      addMissingDependencies(value, dependencies, path191, results);
     }
   }
   if (node.dialect === "draft7" && isObject(schema.dependencies)) {
     for (const [key3, dependencies] of Object.entries(schema.dependencies)) {
       if (Object.prototype.hasOwnProperty.call(value, key3) && Array.isArray(dependencies)) {
-        addMissingDependencies(value, dependencies, path190, results);
+        addMissingDependencies(value, dependencies, path191, results);
       }
     }
   }
 }
-function addMissingDependencies(value, dependencies, path190, results) {
+function addMissingDependencies(value, dependencies, path191, results) {
   for (const dependency of dependencies) {
     if (typeof dependency === "string" && !Object.prototype.hasOwnProperty.call(value, dependency)) {
       results.push(
         invalidResult(
           issue(
-            [...path190, dependency],
+            [...path191, dependency],
             "dependency",
             void 0,
             `must have property '${dependency}'`
@@ -18036,8 +18036,8 @@ function compileJsonSchema(schema, options = {}) {
 }
 function formatIssues(issues) {
   return issues.map((current) => {
-    const path190 = current.path.length === 0 ? "data" : `data/${current.path.join("/")}`;
-    return `${path190} ${current.message}`;
+    const path191 = current.path.length === 0 ? "data" : `data/${current.path.join("/")}`;
+    return `${path191} ${current.message}`;
   }).join(", ");
 }
 var init_json_schema = __esm({
@@ -18547,11 +18547,11 @@ function mergeLayers(layers) {
   }
   return mergeObjectLayers(layers, []);
 }
-function mergeObjectLayers(layers, path190) {
+function mergeObjectLayers(layers, path191) {
   const data = {};
   const sources = {};
   for (const key3 of collectKeys(layers)) {
-    const resolved = resolveKey(layers, key3, path190);
+    const resolved = resolveKey(layers, key3, path191);
     if (resolved === void 0) {
       continue;
     }
@@ -18571,7 +18571,7 @@ function collectKeys(layers) {
   }
   return [...keys];
 }
-function resolveKey(layers, key3, path190) {
+function resolveKey(layers, key3, path191) {
   let winningSource;
   let winningValue;
   const objectLayers = [];
@@ -18604,9 +18604,9 @@ function resolveKey(layers, key3, path190) {
   if (winningValue === null) {
     return void 0;
   }
-  const fullPath = buildPath(path190, key3);
+  const fullPath = buildPath(path191, key3);
   if (isPlainObject(winningValue)) {
-    const merged = mergeObjectLayers(objectLayers, [...path190, key3]);
+    const merged = mergeObjectLayers(objectLayers, [...path191, key3]);
     return {
       value: merged.data,
       sources: {
@@ -18634,8 +18634,8 @@ function isWinningCandidate(key3, value) {
 function getOwnEntry2(record2, key3) {
   return Object.prototype.hasOwnProperty.call(record2, key3) ? record2[key3] : void 0;
 }
-function buildPath(path190, key3) {
-  return [...path190, key3].map(escapePathSegment).join(".");
+function buildPath(path191, key3) {
+  return [...path191, key3].map(escapePathSegment).join(".");
 }
 function escapePathSegment(segment) {
   return segment.replaceAll("\\", "\\\\").replaceAll(".", "\\.");
@@ -19499,22 +19499,22 @@ function prune2(obj, shape) {
   }
   return { changed, result };
 }
-function modifyAtPath(content, path190, value) {
+function modifyAtPath(content, path191, value) {
   const indent = detectIndent(content);
   const formattingOptions = {
     tabSize: indent === "	" ? 1 : indent.length,
     insertSpaces: indent !== "	",
     eol: "\n"
   };
-  const edits = jsonc.modify(content, path190, value, { formattingOptions });
+  const edits = jsonc.modify(content, path191, value, { formattingOptions });
   let result = jsonc.applyEdits(content, edits);
   if (!result.endsWith("\n")) {
     result += "\n";
   }
   return result;
 }
-function removeAtPath(content, path190) {
-  return modifyAtPath(content, path190, void 0);
+function removeAtPath(content, path191) {
+  return modifyAtPath(content, path191, void 0);
 }
 function serializeUpdate(content, current, next) {
   let result = content || "{}";
@@ -19524,15 +19524,15 @@ function serializeUpdate(content, current, next) {
   }
   return result;
 }
-function applyObjectUpdate(content, path190, current, next) {
+function applyObjectUpdate(content, path191, current, next) {
   let result = content;
   for (const key3 of Object.keys(current)) {
     if (!hasConfigEntry(next, key3)) {
-      result = removeAtPath(result, [...path190, key3]);
+      result = removeAtPath(result, [...path191, key3]);
     }
   }
   for (const [key3, nextValue] of Object.entries(next)) {
-    const nextPath = [...path190, key3];
+    const nextPath = [...path191, key3];
     const hasCurrent = hasConfigEntry(current, key3);
     const currentValue = hasCurrent ? current[key3] : void 0;
     if (hasCurrent && isConfigObject(currentValue) && isConfigObject(nextValue)) {
@@ -19739,16 +19739,16 @@ function getConfigFormat(pathOrFormat) {
   }
   return formatRegistry[formatName];
 }
-function detectFormat2(path190) {
-  const ext = getExtension(path190);
+function detectFormat2(path191) {
+  const ext = getExtension(path191);
   return extensionMap[ext];
 }
-function getExtension(path190) {
-  const lastDot = path190.lastIndexOf(".");
+function getExtension(path191) {
+  const lastDot = path191.lastIndexOf(".");
   if (lastDot === -1) {
     return "";
   }
-  return path190.slice(lastDot).toLowerCase();
+  return path191.slice(lastDot).toLowerCase();
 }
 var formatRegistry, extensionMap;
 var init_formats = __esm({
@@ -21138,7 +21138,7 @@ function mergeScope(scope, baseScope, overrideScope) {
   }
   return merged;
 }
-function mergeRuntimeScope(baseScope, overrideScope, path190 = []) {
+function mergeRuntimeScope(baseScope, overrideScope, path191 = []) {
   const merged = {};
   const keys = /* @__PURE__ */ new Set([...Object.keys(baseScope), ...Object.keys(overrideScope)]);
   for (const key3 of keys) {
@@ -21151,7 +21151,7 @@ function mergeRuntimeScope(baseScope, overrideScope, path190 = []) {
       continue;
     }
     if (isRecord4(baseValue) && isRecord4(overrideValue)) {
-      setOwnEntry(merged, key3, mergeRuntimeScope(baseValue, overrideValue, [...path190, key3]));
+      setOwnEntry(merged, key3, mergeRuntimeScope(baseValue, overrideValue, [...path191, key3]));
       continue;
     }
     setOwnEntry(merged, key3, overrideValue);
@@ -22742,45 +22742,45 @@ import { createTwoFilesPatch } from "diff";
 import chalk from "chalk";
 function createDryRunFileSystem(base, recorder) {
   const proxy = {
-    async readFile(path190, encoding) {
+    async readFile(path191, encoding) {
       if (encoding) {
-        return base.readFile(path190, encoding);
+        return base.readFile(path191, encoding);
       }
-      return base.readFile(path190);
+      return base.readFile(path191);
     },
-    async writeFile(path190, data, options) {
-      const previousContent = await tryReadText(base, path190);
+    async writeFile(path191, data, options) {
+      const previousContent = await tryReadText(base, path191);
       const nextContent = formatData(data, options?.encoding);
       recorder.record({
         type: "writeFile",
-        path: path190,
+        path: path191,
         nextContent,
         previousContent
       });
     },
-    async symlink(target, path190) {
-      recorder.record({ type: "symlink", target, path: path190 });
+    async symlink(target, path191) {
+      recorder.record({ type: "symlink", target, path: path191 });
     },
-    async readlink(path190) {
-      return base.readlink(path190);
+    async readlink(path191) {
+      return base.readlink(path191);
     },
-    async realpath(path190) {
-      return base.realpath(path190);
+    async realpath(path191) {
+      return base.realpath(path191);
     },
-    async mkdir(path190, options) {
+    async mkdir(path191, options) {
       recorder.record({
         type: "mkdir",
-        path: path190,
+        path: path191,
         options,
         // Matches how the mutation layer itself decides the mkdir is a no-op.
-        existing: await pathExists(base, path190)
+        existing: await pathExists(base, path191)
       });
     },
-    async stat(path190) {
-      return base.stat(path190);
+    async stat(path191) {
+      return base.stat(path191);
     },
-    async lstat(path190) {
-      return base.lstat(path190);
+    async lstat(path191) {
+      return base.lstat(path191);
     },
     async rename(from, to) {
       const staged = recorder.takeStagedWrite(from);
@@ -22795,16 +22795,16 @@ function createDryRunFileSystem(base, recorder) {
       }
       recorder.record({ type: "rename", from, to });
     },
-    async unlink(path190) {
-      recorder.record({ type: "unlink", path: path190 });
+    async unlink(path191) {
+      recorder.record({ type: "unlink", path: path191 });
     },
-    async readdir(path190) {
-      return base.readdir(path190);
+    async readdir(path191) {
+      return base.readdir(path191);
     }
   };
   if (typeof base.rm === "function") {
-    proxy.rm = async (path190, options) => {
-      recorder.record({ type: "rm", path: path190, options });
+    proxy.rm = async (path191, options) => {
+      recorder.record({ type: "rm", path: path191, options });
     };
   }
   if (typeof base.copyFile === "function") {
@@ -22949,8 +22949,8 @@ function describeWriteChange(previous, next) {
   }
   return "update";
 }
-function renderWriteCommand(path190, change) {
-  const command = `cat > ${quoteShellArgument(path190)}`;
+function renderWriteCommand(path191, change) {
+  const command = `cat > ${quoteShellArgument(path191)}`;
   if (change === "create") {
     return renderOperationCommand(command, chalk.green, "# create");
   }
@@ -23157,9 +23157,9 @@ function describesChange(operation) {
   }
   return true;
 }
-async function tryReadText(base, path190) {
+async function tryReadText(base, path191) {
   try {
-    return await base.readFile(path190, "utf8");
+    return await base.readFile(path191, "utf8");
   } catch (error3) {
     if (isNotFound(error3)) {
       return null;
@@ -23213,10 +23213,10 @@ var init_dry_run = __esm({
       // Atomic writers stage content in a temp file and rename it over the target.
       // Pulling the staged write back out lets the rename re-record it against the
       // real target, so the preview diffs the delta instead of the whole file.
-      takeStagedWrite(path190) {
+      takeStagedWrite(path191) {
         for (let index = this.operations.length - 1; index >= 0; index -= 1) {
           const operation = this.operations[index];
-          if (operation.type === "writeFile" && operation.path === path190) {
+          if (operation.type === "writeFile" && operation.path === path191) {
             this.operations.splice(index, 1);
             return operation;
           }
@@ -34906,21 +34906,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 path190;
+        let path191;
         if (typeof item.content === "string") {
-          path190 = item.content;
+          path191 = item.content;
         } else {
           try {
-            path190 = JSON.stringify(item.content);
+            path191 = JSON.stringify(item.content);
           } catch {
-            path190 = String(item.content);
+            path191 = String(item.content);
           }
         }
         yield {
           event: "tool_complete",
           id: item.tool_use_id,
           kind,
-          path: path190
+          path: path191
         };
       }
     }
@@ -35043,10 +35043,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 path190 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
+        const path191 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
         toolTitleById.delete(item.id);
         toolKindById.delete(item.id);
-        yield { event: "tool_complete", id: item.id, kind, path: path190 };
+        yield { event: "tool_complete", id: item.id, kind, path: path191 };
       }
     }
   }
@@ -35425,14 +35425,14 @@ function toolInfo(event) {
   const [toolName = "tool", rawTool = {}] = Object.entries(toolCall)[0] ?? [];
   const tool = asObject2(rawTool) ?? {};
   const args = asObject2(tool.args) ?? asObject2(tool.arguments) ?? tool;
-  const path190 = typeof args.path === "string" ? args.path : "";
+  const path191 = typeof args.path === "string" ? args.path : "";
   const kinds = {
     editToolCall: "edit",
     readToolCall: "read",
     shellToolCall: "exec",
     bashToolCall: "exec"
   };
-  return { kind: kinds[toolName] ?? "other", title: path190 || toolName, path: path190 };
+  return { kind: kinds[toolName] ?? "other", title: path191 || toolName, path: path191 };
 }
 async function* adaptCursor(lines) {
   for await (const rawLine of lines) {
@@ -37783,8 +37783,8 @@ function resourceNotFound(resource) {
     `Resource not found: ${resource}`
   );
 }
-function assertAbsolutePath(path190) {
-  if (!isAbsolute(path190)) {
+function assertAbsolutePath(path191) {
+  if (!isAbsolute(path191)) {
     throw invalidParams('"path" must be an absolute path');
   }
 }
@@ -39196,7 +39196,7 @@ function updateSessionFromEvent(ctx, event, toolCallsById) {
   }
   const id = readString(event.id);
   const kind = readString(event.kind);
-  const path190 = readString(event.path);
+  const path191 = readString(event.path);
   let toolCall = id ? toolCallsById.get(id) : void 0;
   if (!toolCall) {
     toolCall = {};
@@ -39211,8 +39211,8 @@ function updateSessionFromEvent(ctx, event, toolCallsById) {
   if (kind) {
     toolCall.kind = kind;
   }
-  if (path190) {
-    toolCall.path = path190;
+  if (path191) {
+    toolCall.path = path191;
   }
 }
 var sessionCapture;
@@ -55184,7 +55184,7 @@ function isWorktree(value) {
     return false;
   }
   const name = getOwnEntry18(value, "name");
-  const path190 = getOwnEntry18(value, "path");
+  const path191 = getOwnEntry18(value, "path");
   const branch = getOwnEntry18(value, "branch");
   const baseBranch = getOwnEntry18(value, "baseBranch");
   const createdAt2 = getOwnEntry18(value, "createdAt");
@@ -55198,7 +55198,7 @@ function isWorktree(value) {
   const baseHead = getOwnEntry18(value, "baseHead");
   const reconciledAt = getOwnEntry18(value, "reconciledAt");
   const reconciliation = getOwnEntry18(value, "reconciliation");
-  return typeof name === "string" && typeof path190 === "string" && typeof branch === "string" && typeof baseBranch === "string" && typeof createdAt2 === "string" && typeof source === "string" && typeof agent3 === "string" && (status === "active" || status === "reconciling" || status === "conflicted" || status === "cleanup_failed" || status === "done" || status === "failed" || status === "removing") && (storyId === void 0 || typeof storyId === "string") && (planPath === void 0 || typeof planPath === "string") && (prompt === void 0 || typeof prompt === "string") && (sourceCwd === void 0 || typeof sourceCwd === "string") && (baseHead === void 0 || typeof baseHead === "string") && (reconciledAt === void 0 || typeof reconciledAt === "string") && (reconciliation === void 0 || isReconciliationSummary(reconciliation));
+  return typeof name === "string" && typeof path191 === "string" && typeof branch === "string" && typeof baseBranch === "string" && typeof createdAt2 === "string" && typeof source === "string" && typeof agent3 === "string" && (status === "active" || status === "reconciling" || status === "conflicted" || status === "cleanup_failed" || status === "done" || status === "failed" || status === "removing") && (storyId === void 0 || typeof storyId === "string") && (planPath === void 0 || typeof planPath === "string") && (prompt === void 0 || typeof prompt === "string") && (sourceCwd === void 0 || typeof sourceCwd === "string") && (baseHead === void 0 || typeof baseHead === "string") && (reconciledAt === void 0 || typeof reconciledAt === "string") && (reconciliation === void 0 || isReconciliationSummary(reconciliation));
 }
 function isReconciliationSummary(value) {
   if (typeof value !== "object" || value === null) {
@@ -55639,9 +55639,9 @@ function parsePorcelainPaths(output) {
   const entries = output.split("\0").filter((entry) => entry.length > 0);
   for (let index = 0; index < entries.length; index += 1) {
     const entry = entries[index];
-    const path190 = entry.length > 3 ? entry.slice(3) : entry;
-    if (path190.length > 0) {
-      paths.push(path190);
+    const path191 = entry.length > 3 ? entry.slice(3) : entry;
+    if (path191.length > 0) {
+      paths.push(path191);
     }
     if ((entry.startsWith("R ") || entry.startsWith("C ")) && index + 1 < entries.length) {
       const sourcePath = entries[index + 1];
@@ -57992,14 +57992,14 @@ function formatTimestamp2(timestamp) {
 }
 function editPlan(dashboard, absolutePath, env, openInEditor) {
   const editor = resolveEditor(env);
-  const open8 = openInEditor ?? openInEditorWithSystem;
+  const open9 = openInEditor ?? openInEditorWithSystem;
   if (editor.mode === "gui") {
-    open8(absolutePath, env);
+    open9(absolutePath, env);
     return;
   }
   dashboard.stop();
   try {
-    open8(absolutePath, env);
+    open9(absolutePath, env);
   } finally {
     dashboard.start();
   }
@@ -59063,10 +59063,10 @@ function parseReviewDiff(diffText) {
       finalizeFile();
       const paths = parseDiffGitPaths(line);
       const previousPath = paths?.previousPath ?? "";
-      const path190 = paths?.path ?? previousPath;
+      const path191 = paths?.path ?? previousPath;
       currentFile = {
-        path: path190,
-        previousPath: previousPath && previousPath !== path190 ? previousPath : null,
+        path: path191,
+        previousPath: previousPath && previousPath !== path191 ? previousPath : null,
         status: "modified",
         hunks: [],
         reviewableLines: [],
@@ -59096,9 +59096,9 @@ function parseReviewDiff(diffText) {
       continue;
     }
     if (line.startsWith("+++ ")) {
-      const path190 = normalizeDiffPath(line.slice(4).trim());
-      if (path190) {
-        currentFile.path = path190;
+      const path191 = normalizeDiffPath(line.slice(4).trim());
+      if (path191) {
+        currentFile.path = path191;
       }
       continue;
     }
@@ -59157,31 +59157,31 @@ function validateInlineComments(comments, context) {
   const accepted = [];
   const seen = /* @__PURE__ */ new Set();
   for (const comment of comments) {
-    const path190 = comment.path;
+    const path191 = comment.path;
     const body = comment.body.trim();
-    if (path190.length === 0 || !body || !Number.isInteger(comment.line) || comment.line < 1) {
+    if (path191.length === 0 || !body || !Number.isInteger(comment.line) || comment.line < 1) {
       throw new Error("Inline review comments require path, positive line, and body.");
     }
     if (comment.side === "LEFT") {
       throw new Error(
-        `Inline comment target ${path190}:${comment.line} is a left-side diff target; only right-side comments are supported.`
+        `Inline comment target ${path191}:${comment.line} is a left-side diff target; only right-side comments are supported.`
       );
     }
-    if (!context.reviewableLinesByPath.get(path190)?.has(comment.line)) {
+    if (!context.reviewableLinesByPath.get(path191)?.has(comment.line)) {
       throw new Error(
-        `Inline comment target ${path190}:${comment.line} is not a valid right-side diff target.`
+        `Inline comment target ${path191}:${comment.line} is not a valid right-side diff target.`
       );
     }
-    if (!comment.side && context.leftLinesByPath.get(path190)?.has(comment.line) && context.rightContextLinesByPath.get(path190)?.has(comment.line)) {
+    if (!comment.side && context.leftLinesByPath.get(path191)?.has(comment.line) && context.rightContextLinesByPath.get(path191)?.has(comment.line)) {
       throw new Error(
-        `Inline comment target ${path190}:${comment.line} is ambiguous; specify side RIGHT to target the right-side diff line.`
+        `Inline comment target ${path191}:${comment.line} is ambiguous; specify side RIGHT to target the right-side diff line.`
       );
     }
-    const key3 = `${path190}\0${comment.line}\0${body}`;
+    const key3 = `${path191}\0${comment.line}\0${body}`;
     if (!seen.has(key3)) {
       seen.add(key3);
       accepted.push({
-        path: path190,
+        path: path191,
         line: comment.line,
         ...comment.side ? { side: comment.side } : {},
         body
@@ -59682,9 +59682,9 @@ function reviewEndpoint(prUrl) {
 }
 function normalizeReviewComments(comments) {
   return comments.map((comment) => {
-    const path190 = comment.path.trim();
+    const path191 = comment.path.trim();
     const body = comment.body.trim();
-    if (!path190) {
+    if (!path191) {
       throw new Error("Review comment path must be non-empty.");
     }
     if (!Number.isSafeInteger(comment.line) || comment.line <= 0) {
@@ -59693,7 +59693,7 @@ function normalizeReviewComments(comments) {
     if (!body) {
       throw new Error("Review comment body must be non-empty.");
     }
-    return { path: path190, line: comment.line, body };
+    return { path: path191, line: comment.line, body };
   });
 }
 function submissionFromResponse(response) {
@@ -59988,10 +59988,10 @@ var init_review_history = __esm({
           kind,
           body
         };
-        const path190 = text4(record2, "path");
+        const path191 = text4(record2, "path");
         const line = integer(record2, "line") ?? integer(record2, "original_line");
         const diffHunk = text4(record2, "diff_hunk");
-        if (path190) normalized.path = path190;
+        if (path191) normalized.path = path191;
         if (line !== null) normalized.line = line;
         if (diffHunk) normalized.diffHunk = diffHunk;
         return normalized;
@@ -60701,9 +60701,9 @@ function containedPath(directory, name) {
   }
   return target;
 }
-async function pathExists7(path190) {
+async function pathExists7(path191) {
   try {
-    await access(path190);
+    await access(path191);
     return true;
   } catch (error3) {
     if (isMissingFileError4(error3)) {
@@ -64100,9 +64100,9 @@ function normalizeToolResult2(handlerResult, outputSchema) {
     structuredContent
   };
 }
-function assertObjectRootSchema(schema, path190) {
+function assertObjectRootSchema(schema, path191) {
   if (schema.type !== "object") {
-    throw new Error(`${path190} root type must be "object"`);
+    throw new Error(`${path191} root type must be "object"`);
   }
 }
 function isJsonObject(value) {
@@ -64441,23 +64441,23 @@ function extractFieldErrors(body) {
   const flattened = candidates.flatMap((candidate) => flattenFieldErrors(candidate, []));
   return flattened.length === 0 ? void 0 : flattened;
 }
-function flattenFieldErrors(value, path190) {
+function flattenFieldErrors(value, path191) {
   if (typeof value === "string") {
-    return [{ path: formatPath2(path190), message: value }];
+    return [{ path: formatPath2(path191), message: value }];
   }
   if (Array.isArray(value)) {
     if (value.every((entry) => typeof entry === "string")) {
-      return value.map((message2) => ({ path: formatPath2(path190), message: message2 }));
+      return value.map((message2) => ({ path: formatPath2(path191), message: message2 }));
     }
-    return value.flatMap((entry, index) => flattenFieldErrors(entry, [...path190, String(index)]));
+    return value.flatMap((entry, index) => flattenFieldErrors(entry, [...path191, String(index)]));
   }
   if (!isPlainObject4(value)) {
     return [];
   }
-  return Object.entries(value).flatMap(([key3, nested]) => flattenFieldErrors(nested, [...path190, key3]));
+  return Object.entries(value).flatMap(([key3, nested]) => flattenFieldErrors(nested, [...path191, key3]));
 }
-function formatPath2(path190) {
-  return path190.length === 0 ? "error" : path190.join(".");
+function formatPath2(path191) {
+  return path191.length === 0 ? "error" : path191.join(".");
 }
 function extractFirstString(body, fields) {
   if (!isPlainObject4(body)) {
@@ -64999,12 +64999,12 @@ function mergeApprovalsRoot(root, options) {
   }
   return options.humanInLoop.mergeApprovalsGroup(root);
 }
-function findHumanInLoopCommandPath(node, path190) {
+function findHumanInLoopCommandPath(node, path191) {
   if (node.kind === "command") {
-    return node.humanInLoop ? path190.join(".") || node.name : void 0;
+    return node.humanInLoop ? path191.join(".") || node.name : void 0;
   }
   for (const child of node.children) {
-    const found = findHumanInLoopCommandPath(child, [...path190, child.name]);
+    const found = findHumanInLoopCommandPath(child, [...path191, child.name]);
     if (found !== void 0) {
       return found;
     }
@@ -65039,13 +65039,13 @@ function convertJsonSchema(schema) {
   }
   return convertSchema(schema, schema, []);
 }
-function convertSchema(schema, root, path190) {
-  const resolvedSchema = resolveReferencedSchema(schema, root, path190);
+function convertSchema(schema, root, path191) {
+  const resolvedSchema = resolveReferencedSchema(schema, root, path191);
   const normalizedSchema = normalizeNullability(resolvedSchema);
   const composition = getComposition(normalizedSchema.schema);
   if (Array.isArray(normalizedSchema.schema.type)) {
     throw new Error(
-      `JSON Schema "${formatJsonSchemaPath(path190)}" has an unsupported type "${formatJsonSchemaType(
+      `JSON Schema "${formatJsonSchemaPath(path191)}" has an unsupported type "${formatJsonSchemaType(
         normalizedSchema.schema.type
       )}". Supported: string, number, integer, boolean, array, object.`
     );
@@ -65057,13 +65057,13 @@ function convertSchema(schema, root, path190) {
     return convertEnumSchema(resolvedSchema, normalizedSchema.nullable);
   }
   if (composition !== void 0) {
-    return convertCompositionSchema(normalizedSchema.schema, root, normalizedSchema.nullable, path190);
+    return convertCompositionSchema(normalizedSchema.schema, root, normalizedSchema.nullable, path191);
   }
   if (isRecordSchema(normalizedSchema.schema)) {
     return applyMetadata(
       S.Record(
         convertSchema(normalizedSchema.schema.additionalProperties, root, [
-          ...path190,
+          ...path191,
           "additionalProperties"
         ])
       ),
@@ -65112,12 +65112,12 @@ function convertSchema(schema, root, path190) {
       if (normalizedSchema.schema.items === void 0) {
         throw new Error(
           `JSON Schema "${formatJsonSchemaPath(
-            path190
+            path191
           )}" is an array but is missing the "items" field. Add "items": { ... } to declare the element type.`
         );
       }
       return S.Array(
-        convertSchema(normalizedSchema.schema.items, root, [...path190, "items"]),
+        convertSchema(normalizedSchema.schema.items, root, [...path191, "items"]),
         createCommonOptions(
           normalizedSchema.schema,
           normalizedSchema.nullable,
@@ -65127,7 +65127,7 @@ function convertSchema(schema, root, path190) {
     case "object":
       return convertObjectSchema(normalizedSchema.schema, root, {
         nullable: normalizedSchema.nullable,
-        path: path190
+        path: path191
       });
     case "null":
       return applyMetadata(S.Json(), normalizedSchema.schema, {
@@ -65142,12 +65142,12 @@ function convertSchema(schema, root, path190) {
       }
       throw new Error(
         `JSON Schema "${formatJsonSchemaPath(
-          path190
+          path191
         )}" must declare one of: "type", "enum", "const", "oneOf", "anyOf", or "allOf".`
       );
   }
   throw new Error(
-    `JSON Schema "${formatJsonSchemaPath(path190)}" has an unsupported type "${formatJsonSchemaType(
+    `JSON Schema "${formatJsonSchemaPath(path191)}" has an unsupported type "${formatJsonSchemaType(
       normalizedSchema.schema.type
     )}". Supported: string, number, integer, boolean, array, object.`
   );
@@ -65191,21 +65191,21 @@ function convertEnumSchema(schema, nullable) {
     )
   });
 }
-function convertCompositionSchema(schema, root, nullable, path190) {
+function convertCompositionSchema(schema, root, nullable, path191) {
   const composition = getComposition(schema);
   const branchSchemas = composition?.branches ?? [];
   const keyword = composition?.keyword ?? "oneOf";
   const branches = branchSchemas.map(
-    (branch, index) => resolveReferencedSchema(branch, root, [...path190, keyword, String(index)])
+    (branch, index) => resolveReferencedSchema(branch, root, [...path191, keyword, String(index)])
   );
-  const discriminator = findDiscriminator(branches, root, path190);
+  const discriminator = findDiscriminator(branches, root, path191);
   if (discriminator !== void 0) {
     const convertedBranches = Object.fromEntries(
       branches.map((branch, index) => [
         getDiscriminatorLiteral(branch, discriminator, root),
         convertObjectSchema(branch, root, {
           omitProperty: discriminator,
-          path: [...path190, keyword, String(index)]
+          path: [...path191, keyword, String(index)]
         })
       ])
     );
@@ -65224,7 +65224,7 @@ function convertCompositionSchema(schema, root, nullable, path190) {
     S.Union(
       branches.map(
         (branch, index) => convertObjectSchema(branch, root, {
-          path: [...path190, keyword, String(index)]
+          path: [...path191, keyword, String(index)]
         })
       )
     ),
@@ -65338,11 +65338,11 @@ function getComposition(schema) {
   }
   return void 0;
 }
-function formatJsonSchemaPath(path190) {
-  if (path190.length === 0) {
+function formatJsonSchemaPath(path191) {
+  if (path191.length === 0) {
     return "#";
   }
-  return `#/${path190.map(escapeJsonPointerSegment).join("/")}`;
+  return `#/${path191.map(escapeJsonPointerSegment).join("/")}`;
 }
 function formatJsonSchemaType(type) {
   return Array.isArray(type) ? JSON.stringify(type) : String(type);
@@ -65358,11 +65358,11 @@ function isRecordSchema(schema) {
   const propertyKeys = Object.keys(schema.properties ?? {});
   return schema.type === "object" && propertyKeys.length === 0 && typeof schema.additionalProperties === "object" && schema.additionalProperties !== null;
 }
-function findDiscriminator(branches, root, path190) {
+function findDiscriminator(branches, root, path191) {
   const [firstBranch] = branches;
   if (firstBranch === void 0) {
     throw new Error(
-      `JSON Schema "${formatJsonSchemaPath(path190)}" uses oneOf/anyOf/allOf but has no branches.`
+      `JSON Schema "${formatJsonSchemaPath(path191)}" uses oneOf/anyOf/allOf but has no branches.`
     );
   }
   const candidateKeys = Object.keys(firstBranch.properties ?? {});
@@ -65402,19 +65402,19 @@ function getDiscriminatorLiteral(branch, key3, root) {
   }
   return void 0;
 }
-function resolveReferencedSchema(schema, root, path190) {
+function resolveReferencedSchema(schema, root, path191) {
   if (schema.$ref === void 0) {
     return schema;
   }
   const resolvedTarget = resolveLocalRef(root, schema.$ref);
   if (resolvedTarget === void 0) {
     throw new Error(
-      `JSON Schema "${formatJsonSchemaPath(path190)}" uses "$ref": ${schema.$ref}. toolcraft only supports internal refs like "#/components/schemas/Foo".`
+      `JSON Schema "${formatJsonSchemaPath(path191)}" uses "$ref": ${schema.$ref}. toolcraft only supports internal refs like "#/components/schemas/Foo".`
     );
   }
   const { $ref: ignoredRef, ...siblingKeywords } = schema;
   void ignoredRef;
-  const resolvedSchema = resolveReferencedSchema(resolvedTarget, root, path190);
+  const resolvedSchema = resolveReferencedSchema(resolvedTarget, root, path191);
   if (Object.keys(siblingKeywords).length === 0) {
     return resolvedSchema;
   }
@@ -65438,9 +65438,9 @@ function mergeJsonSchemas(base, overlay) {
     ...mergedRequired === void 0 ? {} : { required: mergedRequired }
   };
 }
-function hasSelfReferencingRef(schema, root, path190 = "#", activePaths = /* @__PURE__ */ new Set()) {
+function hasSelfReferencingRef(schema, root, path191 = "#", activePaths = /* @__PURE__ */ new Set()) {
   const nextActivePaths = new Set(activePaths);
-  nextActivePaths.add(path190);
+  nextActivePaths.add(path191);
   const localRefPath = getLocalRefPath(schema.$ref);
   if (localRefPath !== void 0) {
     if (nextActivePaths.has(localRefPath)) {
@@ -65451,13 +65451,13 @@ function hasSelfReferencingRef(schema, root, path190 = "#", activePaths = /* @__
       return true;
     }
   }
-  if (schema.items !== void 0 && hasSelfReferencingRef(schema.items, root, `${path190}/items`, nextActivePaths)) {
+  if (schema.items !== void 0 && hasSelfReferencingRef(schema.items, root, `${path191}/items`, nextActivePaths)) {
     return true;
   }
   if (typeof schema.additionalProperties === "object" && schema.additionalProperties !== null && hasSelfReferencingRef(
     schema.additionalProperties,
     root,
-    `${path190}/additionalProperties`,
+    `${path191}/additionalProperties`,
     nextActivePaths
   )) {
     return true;
@@ -65466,7 +65466,7 @@ function hasSelfReferencingRef(schema, root, path190 = "#", activePaths = /* @__
     if (hasSelfReferencingRef(
       childSchema,
       root,
-      `${path190}/properties/${escapeJsonPointerSegment(key3)}`,
+      `${path191}/properties/${escapeJsonPointerSegment(key3)}`,
       nextActivePaths
     )) {
       return true;
@@ -65476,24 +65476,24 @@ function hasSelfReferencingRef(schema, root, path190 = "#", activePaths = /* @__
     if (hasSelfReferencingRef(
       childSchema,
       root,
-      `${path190}/$defs/${escapeJsonPointerSegment(key3)}`,
+      `${path191}/$defs/${escapeJsonPointerSegment(key3)}`,
       nextActivePaths
     )) {
       return true;
     }
   }
   for (const [index, childSchema] of (schema.oneOf ?? []).entries()) {
-    if (hasSelfReferencingRef(childSchema, root, `${path190}/oneOf/${index}`, nextActivePaths)) {
+    if (hasSelfReferencingRef(childSchema, root, `${path191}/oneOf/${index}`, nextActivePaths)) {
       return true;
     }
   }
   for (const [index, childSchema] of (schema.anyOf ?? []).entries()) {
-    if (hasSelfReferencingRef(childSchema, root, `${path190}/anyOf/${index}`, nextActivePaths)) {
+    if (hasSelfReferencingRef(childSchema, root, `${path191}/anyOf/${index}`, nextActivePaths)) {
       return true;
     }
   }
   for (const [index, childSchema] of (schema.allOf ?? []).entries()) {
-    if (hasSelfReferencingRef(childSchema, root, `${path190}/allOf/${index}`, nextActivePaths)) {
+    if (hasSelfReferencingRef(childSchema, root, `${path191}/allOf/${index}`, nextActivePaths)) {
       return true;
     }
   }
@@ -65509,14 +65509,14 @@ function getLocalRefPath(ref) {
   return ref.startsWith("#/") ? ref : void 0;
 }
 function resolveLocalRef(root, ref) {
-  const path190 = getLocalRefPath(ref);
-  if (path190 === void 0) {
+  const path191 = getLocalRefPath(ref);
+  if (path191 === void 0) {
     return void 0;
   }
-  if (path190 === "#") {
+  if (path191 === "#") {
     return root;
   }
-  const segments = path190.slice(2).split("/").map(unescapeJsonPointerSegment);
+  const segments = path191.slice(2).split("/").map(unescapeJsonPointerSegment);
   let current = root;
   for (const segment of segments) {
     if (Array.isArray(current)) {
@@ -66269,21 +66269,21 @@ function createFs(fs31) {
     return fs31;
   }
   return {
-    readFile: async (path190, encoding = "utf8") => readFile13(path190, { encoding }),
-    writeFile: async (path190, contents, options) => {
-      await writeFile9(path190, contents, options);
+    readFile: async (path191, encoding = "utf8") => readFile13(path191, { encoding }),
+    writeFile: async (path191, contents, options) => {
+      await writeFile9(path191, contents, options);
     },
-    exists: async (path190) => {
+    exists: async (path191) => {
       try {
-        await access2(path190);
+        await access2(path191);
         return true;
       } catch {
         return false;
       }
     },
-    lstat: async (path190) => lstat12(path190),
+    lstat: async (path191) => lstat12(path191),
     rename: async (fromPath, toPath) => rename10(fromPath, toPath),
-    unlink: async (path190) => unlink9(path190)
+    unlink: async (path191) => unlink9(path191)
   };
 }
 function createEnv(values = process.env) {
@@ -66421,11 +66421,11 @@ function applySchemaCasing(schema, casing) {
     ...oneOf === void 0 ? {} : { oneOf }
   };
 }
-function collectParamSummaries(schema, casing, path190 = [], inheritedOptional = false) {
+function collectParamSummaries(schema, casing, path191 = [], inheritedOptional = false) {
   const summaries = [];
   for (const [key3, rawChildSchema] of Object.entries(schema.shape)) {
     const childSchema = unwrapOptional3(rawChildSchema);
-    const nextPath = [...path190, formatSegment(key3, casing)];
+    const nextPath = [...path191, formatSegment(key3, casing)];
     const optional = inheritedOptional || isOptional(rawChildSchema);
     if (childSchema.kind === "object") {
       summaries.push(...collectParamSummaries(childSchema, casing, nextPath, optional));
@@ -66469,8 +66469,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(path190) {
-  return path190.map((segment) => formatSegment(segment, "snake")).join("__");
+function formatToolName(path191) {
+  return path191.map((segment) => formatSegment(segment, "snake")).join("__");
 }
 function validateUniqueMCPParameterFields(schema, casing) {
   const sourceKeysByField = /* @__PURE__ */ new Map();
@@ -69066,14 +69066,14 @@ function parseDockerLocator(input) {
     throw new Error(`Invalid docker workspace locator "${input}".`);
   }
   const container = input.slice(0, slashIndex);
-  const path190 = input.slice(slashIndex);
-  if (container.length === 0 || path190.length === 0) {
+  const path191 = input.slice(slashIndex);
+  if (container.length === 0 || path191.length === 0) {
     throw new Error(`Invalid docker workspace locator "${input}".`);
   }
   return {
     scheme: "docker",
     container,
-    path: path190
+    path: path191
   };
 }
 function splitOnce(input, separator) {
@@ -69937,8 +69937,8 @@ async function checkAuth(options) {
 }
 function createCurrentBalanceUrl(baseUrl) {
   const url = new URL(baseUrl);
-  const path190 = url.pathname.endsWith("/") ? url.pathname.slice(0, -1) : url.pathname;
-  url.pathname = `${path190}/usage/current_balance`;
+  const path191 = url.pathname.endsWith("/") ? url.pathname.slice(0, -1) : url.pathname;
+  url.pathname = `${path191}/usage/current_balance`;
   return url.toString();
 }
 function isCurrentBalanceResponse(value) {
@@ -71404,26 +71404,26 @@ function createSdkContainer(options) {
   });
   loggerFactory.setErrorLogger(errorLogger);
   const asyncFs = {
-    readFile: ((path190, encoding) => {
+    readFile: ((path191, encoding) => {
       if (encoding) {
-        return fs9.readFile(path190, encoding);
+        return fs9.readFile(path191, encoding);
       }
-      return fs9.readFile(path190);
+      return fs9.readFile(path191);
     }),
-    symlink: (target, path190) => fs9.symlink(target, path190),
-    readlink: (path190) => fs9.readlink(path190, { encoding: "utf8" }),
-    realpath: (path190) => fs9.realpath(path190),
-    writeFile: (path190, data, opts) => fs9.writeFile(path190, data, opts),
-    mkdir: (path190, opts) => fs9.mkdir(path190, opts).then(() => {
+    symlink: (target, path191) => fs9.symlink(target, path191),
+    readlink: (path191) => fs9.readlink(path191, { encoding: "utf8" }),
+    realpath: (path191) => fs9.realpath(path191),
+    writeFile: (path191, data, opts) => fs9.writeFile(path191, data, opts),
+    mkdir: (path191, opts) => fs9.mkdir(path191, opts).then(() => {
     }),
-    stat: (path190) => fs9.stat(path190),
-    lstat: (path190) => fs9.lstat(path190),
+    stat: (path191) => fs9.stat(path191),
+    lstat: (path191) => fs9.lstat(path191),
     rename: (oldPath, newPath) => fs9.rename(oldPath, newPath),
-    rm: (path190, opts) => fs9.rm(path190, opts),
-    unlink: (path190) => fs9.unlink(path190),
-    readdir: (path190) => fs9.readdir(path190),
+    rm: (path191, opts) => fs9.rm(path191, opts),
+    unlink: (path191) => fs9.unlink(path191),
+    readdir: (path191) => fs9.readdir(path191),
     copyFile: (src, dest) => fs9.copyFile(src, dest),
-    chmod: (path190, mode) => fs9.chmod(path190, mode)
+    chmod: (path191, mode) => fs9.chmod(path191, mode)
   };
   const contextFactory = createCommandContextFactory({ fs: asyncFs });
   const authProviders = allAuthProviders;
@@ -73574,7 +73574,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, readFile59) {
+async function resolveFileIncludes(template2, cwd, readFile60) {
   const matches = [...template2.matchAll(FILE_INCLUDE_PATTERN)];
   if (matches.length === 0) {
     return template2;
@@ -73586,7 +73586,7 @@ async function resolveFileIncludes(template2, cwd, readFile59) {
     if (relativePath === ".." || relativePath.startsWith(`..${path82.sep}`) || path82.isAbsolute(relativePath)) {
       throw new Error(`Pipeline file include resolves outside the project root: ${match[1]}`);
     }
-    const content = await readFile59(absolutePath, "utf8");
+    const content = await readFile60(absolutePath, "utf8");
     result = result.replace(match[0], content);
   }
   return result;
@@ -73660,15 +73660,15 @@ async function resolveDocVarFromPath(options) {
     );
   }
 }
-async function resolvePipelineVars(vars, cwd, readFile59) {
+async function resolvePipelineVars(vars, cwd, readFile60) {
   const resolved = {};
   for (const [key3, value] of Object.entries(vars)) {
     if (key3.endsWith("_doc") && looksLikeDocPath(value)) {
-      const docContent = await resolveDocVarFromPath({ key: key3, value, cwd, readFile: readFile59 });
-      defineRecordEntry3(resolved, key3, await resolveFileIncludes(docContent, cwd, readFile59));
+      const docContent = await resolveDocVarFromPath({ key: key3, value, cwd, readFile: readFile60 });
+      defineRecordEntry3(resolved, key3, await resolveFileIncludes(docContent, cwd, readFile60));
       continue;
     }
-    defineRecordEntry3(resolved, key3, await resolveFileIncludes(value, cwd, readFile59));
+    defineRecordEntry3(resolved, key3, await resolveFileIncludes(value, cwd, readFile60));
   }
   return resolved;
 }
@@ -84438,9 +84438,9 @@ async function openTraceIndex(options) {
         stats2.removed += shard.count;
         delete manifest.shards[directory];
         manifestDirty = true;
-        const unlink26 = fs31.unlink;
-        if (typeof unlink26 === "function") {
-          await unlink26.call(fs31, path112.join(shardsDir, shard.file)).catch(() => void 0);
+        const unlink27 = fs31.unlink;
+        if (typeof unlink27 === "function") {
+          await unlink27.call(fs31, path112.join(shardsDir, shard.file)).catch(() => void 0);
         }
       }
     }
@@ -84484,13 +84484,13 @@ async function openTraceIndex(options) {
     return results.map(referenceFromRecord);
   };
   const rebuild = async (syncOptions) => {
-    const unlink26 = fs31.unlink;
-    if (typeof unlink26 === "function") {
+    const unlink27 = fs31.unlink;
+    if (typeof unlink27 === "function") {
       const names = await fs31.readdir(shardsDir).catch(() => []);
       for (const name of names) {
-        await unlink26.call(fs31, path112.join(shardsDir, name)).catch(() => void 0);
+        await unlink27.call(fs31, path112.join(shardsDir, name)).catch(() => void 0);
       }
-      await unlink26.call(fs31, manifestPath).catch(() => void 0);
+      await unlink27.call(fs31, manifestPath).catch(() => void 0);
     } else {
       await writeAtomic(manifestPath, JSON.stringify({ version: MANIFEST_VERSION, shards: {} }));
     }
@@ -88043,15 +88043,15 @@ async function publishFiles(fs31, files) {
 function isAlreadyExistsError12(error3) {
   return hasOwnErrorCode24(error3, "EEXIST");
 }
-async function assertNotSymbolicLinkIfSet(fs31, path190) {
-  if (path190 !== void 0 && path190 !== "") {
-    await assertNotSymbolicLink2(fs31, path190);
+async function assertNotSymbolicLinkIfSet(fs31, path191) {
+  if (path191 !== void 0 && path191 !== "") {
+    await assertNotSymbolicLink2(fs31, path191);
   }
 }
-async function assertNotSymbolicLink2(fs31, path190) {
+async function assertNotSymbolicLink2(fs31, path191) {
   try {
-    if ((await fs31.lstat(path190)).isSymbolicLink()) {
-      throw new UserError2(`Refusing to use symbolic link path: ${path190}`);
+    if ((await fs31.lstat(path191)).isSymbolicLink()) {
+      throw new UserError2(`Refusing to use symbolic link path: ${path191}`);
     }
   } catch (error3) {
     if (isMissingFileError8(error3)) {
@@ -89459,12 +89459,12 @@ function validateNonBlankStrings(value) {
   }
   return issues;
 }
-function blankStringIssue(path190, value) {
+function blankStringIssue(path191, value) {
   return {
-    path: path190,
+    path: path191,
     expected: "non-blank string",
     received: JSON.stringify(value),
-    message: `${path190.join(".")} must not be blank.`
+    message: `${path191.join(".")} must not be blank.`
   };
 }
 function validateTarget(target) {
@@ -89515,8 +89515,8 @@ function validateMetrics(metrics) {
 function formatIssues2(filePath, issues) {
   return issues.map((issue2) => `${filePath} (${formatPath3(issue2.path)}): ${issue2.message}`).join("\n");
 }
-function formatPath3(path190) {
-  return path190.join(".") || "value";
+function formatPath3(path191) {
+  return path191.join(".") || "value";
 }
 var nonEmptyString2, positiveInteger, nonNegativeInteger, scoringWeight, metricEvaluatorSchema, metricSchema, evalYamlSchema, EvalYamlValidationError;
 var init_schema5 = __esm({
@@ -89920,9 +89920,9 @@ async function loadEval(source, id, fs31 = nodeFs17) {
     plan
   };
 }
-async function isFile2(path190, fs31) {
+async function isFile2(path191, fs31) {
   try {
-    const stat36 = await fs31.stat(path190);
+    const stat36 = await fs31.stat(path191);
     return typeof stat36.isFile === "function" ? stat36.isFile() : !stat36.isDirectory();
   } catch (error3) {
     if (isMissingPath4(error3)) {
@@ -91805,19 +91805,19 @@ function validateRunResult(value, filePath) {
   requireRecord2(result.cheatReport, filePath, "result.json", ["cheatReport"]);
   return result;
 }
-function validateScoringComponent(value, filePath, path190) {
-  const component = requireRecord2(value, filePath, "result.json", path190);
-  requireBoolean(component.configured, filePath, "result.json", [...path190, "configured"]);
-  requireBoolean(component.required, filePath, "result.json", [...path190, "required"]);
+function validateScoringComponent(value, filePath, path191) {
+  const component = requireRecord2(value, filePath, "result.json", path191);
+  requireBoolean(component.configured, filePath, "result.json", [...path191, "configured"]);
+  requireBoolean(component.required, filePath, "result.json", [...path191, "required"]);
   requireRange(component.configuredWeight, 0, 1, filePath, "result.json", [
-    ...path190,
+    ...path191,
     "configuredWeight"
   ]);
   requireRange(component.effectiveWeight, 0, 1, filePath, "result.json", [
-    ...path190,
+    ...path191,
     "effectiveWeight"
   ]);
-  requireString(component.status, filePath, "result.json", [...path190, "status"]);
+  requireString(component.status, filePath, "result.json", [...path191, "status"]);
 }
 function validateTrace(value, filePath) {
   const trace = requireRecord2(value, filePath, "trace.json", []);
@@ -91826,48 +91826,48 @@ function validateTrace(value, filePath) {
   }
   return trace;
 }
-function requireRecord2(value, filePath, artifact, path190) {
+function requireRecord2(value, filePath, artifact, path191) {
   if (typeof value === "object" && value !== null && !Array.isArray(value)) {
     return value;
   }
-  throw invalidArtifactField(filePath, artifact, path190, "object", value);
+  throw invalidArtifactField(filePath, artifact, path191, "object", value);
 }
-function requireString(value, filePath, artifact, path190) {
+function requireString(value, filePath, artifact, path191) {
   if (typeof value === "string" && value.length > 0) {
     return value;
   }
-  throw invalidArtifactField(filePath, artifact, path190, "non-empty string", value);
+  throw invalidArtifactField(filePath, artifact, path191, "non-empty string", value);
 }
-function requireBoolean(value, filePath, artifact, path190) {
+function requireBoolean(value, filePath, artifact, path191) {
   if (typeof value !== "boolean") {
-    throw invalidArtifactField(filePath, artifact, path190, "boolean", value);
+    throw invalidArtifactField(filePath, artifact, path191, "boolean", value);
   }
 }
-function requireNonNegativeInteger2(value, filePath, artifact, path190) {
+function requireNonNegativeInteger2(value, filePath, artifact, path191) {
   if (typeof value === "number" && Number.isInteger(value) && value >= 0) {
     return value;
   }
-  throw invalidArtifactField(filePath, artifact, path190, "non-negative integer", value);
+  throw invalidArtifactField(filePath, artifact, path191, "non-negative integer", value);
 }
-function requireNonNegativeNumber(value, filePath, artifact, path190) {
+function requireNonNegativeNumber(value, filePath, artifact, path191) {
   if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
     return value;
   }
-  throw invalidArtifactField(filePath, artifact, path190, "non-negative number", value);
+  throw invalidArtifactField(filePath, artifact, path191, "non-negative number", value);
 }
-function requireRange(value, min, max, filePath, artifact, path190) {
+function requireRange(value, min, max, filePath, artifact, path191) {
   if (typeof value === "number" && Number.isFinite(value) && value >= min && value <= max) {
     return;
   }
-  throw invalidArtifactField(filePath, artifact, path190, `number from ${min} through ${max}`, value);
+  throw invalidArtifactField(filePath, artifact, path191, `number from ${min} through ${max}`, value);
 }
-function invalidArtifactField(filePath, artifact, path190, expected, received) {
+function invalidArtifactField(filePath, artifact, path191, expected, received) {
   return new Error(
-    `Invalid ${artifact} in ${filePath} (${formatIssuePath(path190)}): expected ${expected}, received ${formatReceived2(received)}.`
+    `Invalid ${artifact} in ${filePath} (${formatIssuePath(path191)}): expected ${expected}, received ${formatReceived2(received)}.`
   );
 }
-function formatIssuePath(path190) {
-  return path190.join(".") || "value";
+function formatIssuePath(path191) {
+  return path191.join(".") || "value";
 }
 function formatReceived2(value) {
   if (typeof value === "string") {
@@ -96660,11 +96660,11 @@ function formatSegment2(segment, casing) {
   const separator = casing === "snake" ? "_" : "-";
   return splitWords4(segment).join(separator);
 }
-function toOptionFlag(path190, casing) {
-  return `--${path190.map((segment) => formatSegment2(segment, casing)).join(".")}`;
+function toOptionFlag(path191, casing) {
+  return `--${path191.map((segment) => formatSegment2(segment, casing)).join(".")}`;
 }
-function toOptionAttribute(path190, casing) {
-  return path190.map((segment) => {
+function toOptionAttribute(path191, casing) {
+  return path191.map((segment) => {
     const formatted = formatSegment2(segment, casing);
     if (casing === "snake") {
       return formatted;
@@ -96675,23 +96675,23 @@ function toOptionAttribute(path190, casing) {
     ).join("");
   }).join(".");
 }
-function toDisplayPath(path190) {
-  return path190.join(".");
+function toDisplayPath(path191) {
+  return path191.join(".");
 }
-function toUnionKindControlPath(path190) {
-  if (path190.length === 0) {
+function toUnionKindControlPath(path191) {
+  if (path191.length === 0) {
     return ["kind"];
   }
-  const head = path190.slice(0, -1);
-  const tail = path190[path190.length - 1] ?? "";
+  const head = path191.slice(0, -1);
+  const tail = path191[path191.length - 1] ?? "";
   return [...head, `${tail}Kind`];
 }
-function toUnionKindDisplayPath(path190) {
-  if (path190.length === 0) {
+function toUnionKindDisplayPath(path191) {
+  if (path191.length === 0) {
     return "kind";
   }
-  const head = path190.slice(0, -1);
-  const tail = path190[path190.length - 1] ?? "";
+  const head = path191.slice(0, -1);
+  const tail = path191[path191.length - 1] ?? "";
   return [...head, `${tail}-kind`].join(".");
 }
 function createSyntheticEnumSchema(values) {
@@ -96707,14 +96707,14 @@ function getRequiredBranchFingerprint(branch, casing) {
   const requiredKeys = Object.entries(branch.shape).filter(([, schema]) => schema.kind !== "optional").map(([key3]) => formatSegment2(key3, casing)).sort();
   return requiredKeys.join("+");
 }
-function collectFields(schema, casing, globalLongOptionFlags, path190 = [], inheritedOptional = false, variantContext) {
+function collectFields(schema, casing, globalLongOptionFlags, path191 = [], inheritedOptional = false, variantContext) {
   const collected = {
     dynamicFields: [],
     fields: [],
     variants: []
   };
   for (const [key3, rawChildSchema] of Object.entries(schema.shape)) {
-    const nextPath = [...path190, key3];
+    const nextPath = [...path191, key3];
     const runtimeOptional = inheritedOptional || rawChildSchema.kind === "optional";
     const childSchema = unwrapOptional4(rawChildSchema);
     const requiredWhenActive = rawChildSchema.kind !== "optional" && childSchema.default === void 0;
@@ -96900,9 +96900,9 @@ function collectFields(schema, casing, globalLongOptionFlags, path190 = [], inhe
   }
   return collected;
 }
-function toCommanderOptionAttribute(path190, casing, globalLongOptionFlags) {
-  const optionAttribute = toOptionAttribute(path190, casing);
-  const optionFlag = toOptionFlag(path190, casing);
+function toCommanderOptionAttribute(path191, casing, globalLongOptionFlags) {
+  const optionAttribute = toOptionAttribute(path191, casing);
+  const optionFlag = toOptionFlag(path191, casing);
   if (!globalLongOptionFlags.has(optionFlag)) {
     return optionAttribute;
   }
@@ -98496,10 +98496,10 @@ function writeCLIDiagnosticEvent(event) {
   process.stderr.write(`${event.message}
 `);
 }
-function setNestedValue(target, path190, value) {
+function setNestedValue(target, path191, value) {
   let cursor2 = target;
-  for (let index = 0; index < path190.length - 1; index += 1) {
-    const segment = path190[index] ?? "";
+  for (let index = 0; index < path191.length - 1; index += 1) {
+    const segment = path191[index] ?? "";
     const existing = Object.prototype.hasOwnProperty.call(cursor2, segment) ? cursor2[segment] : void 0;
     if (typeof existing === "object" && existing !== null) {
       cursor2 = existing;
@@ -98514,7 +98514,7 @@ function setNestedValue(target, path190, value) {
     });
     cursor2 = next;
   }
-  const leaf = path190[path190.length - 1];
+  const leaf = path191[path191.length - 1];
   if (leaf !== void 0) {
     Object.defineProperty(cursor2, leaf, {
       value,
@@ -98696,9 +98696,9 @@ function isPlainObject8(value) {
 function hasFieldValue(value) {
   return value !== void 0;
 }
-function hasNestedField(fields, path190) {
+function hasNestedField(fields, path191) {
   return fields.some(
-    (field) => path190.length < field.path.length && path190.every((segment, index) => field.path[index] === segment)
+    (field) => path191.length < field.path.length && path191.every((segment, index) => field.path[index] === segment)
   );
 }
 function describeExpectedPresetValue(schema) {
@@ -98827,9 +98827,9 @@ async function loadPresetValues(fields, presetPath) {
   }
   const fieldByPath = new Map(fields.map((field) => [field.displayPath, field]));
   const presetValues = {};
-  function visitObject(current, path190) {
+  function visitObject(current, path191) {
     for (const [key3, value] of Object.entries(current)) {
-      const nextPath = [...path190, key3];
+      const nextPath = [...path191, key3];
       const displayPath = toDisplayPath(nextPath);
       const field = fieldByPath.get(displayPath);
       if (field !== void 0) {
@@ -99212,8 +99212,8 @@ This is a bug in toolcraft or in the command definition; it cannot be worked aro
   }
   process.exitCode = 1;
 }
-function getNestedValue(target, path190) {
-  return path190.reduce(
+function getNestedValue(target, path191) {
+  return path191.reduce(
     (current, segment) => current !== null && typeof current === "object" ? current[segment] : void 0,
     target
   );
@@ -101277,13 +101277,13 @@ function formatAvailableApprovalCommandPaths(root) {
 }
 function enumerateApprovalCommandPaths(root) {
   const paths = [];
-  const visit = (node, path190) => {
+  const visit = (node, path191) => {
     if (node.kind === "command") {
-      paths.push(path190.join("."));
+      paths.push(path191.join("."));
       return;
     }
     for (const child of getVisibleCliChildren(node)) {
-      visit(child, [...path190, child.name]);
+      visit(child, [...path191, child.name]);
     }
   };
   if (root.kind === "command") {
@@ -102799,12 +102799,12 @@ function createOverlayFileSystem(base) {
     }
     return { kind: "file", content: await base.readFile(filePath, "utf8") };
   };
-  async function readFile59(filePath, encoding) {
+  async function readFile60(filePath, encoding) {
     const content = await readOverlayText(filePath);
     return encoding ? content : Buffer.from(content);
   }
   const fs31 = {
-    readFile: readFile59,
+    readFile: readFile60,
     async writeFile(filePath, content, options) {
       await assertOverlayParentDirectory(filePath);
       if (options?.flag === "wx" && await overlayPathExists(filePath)) {
@@ -105158,9 +105158,9 @@ var init_config8 = __esm({
 
 // src/cli/commands/utils-symlink-ops.ts
 import { dirname as dirname10 } from "node:path";
-async function tryLstat(fs31, path190) {
+async function tryLstat(fs31, path191) {
   try {
-    return await fs31.lstat(path190);
+    return await fs31.lstat(path191);
   } catch (error3) {
     if (isNotFound(error3)) {
       return null;
@@ -105244,13 +105244,13 @@ function formatUnknownError6(error3) {
   }
   return String(error3);
 }
-async function isSymlinkPointingTo(fs31, path190, expectedTarget) {
+async function isSymlinkPointingTo(fs31, path191, expectedTarget) {
   try {
-    const stats2 = await fs31.lstat(path190);
+    const stats2 = await fs31.lstat(path191);
     if (!stats2.isSymbolicLink()) {
       return false;
     }
-    return await fs31.readlink(path190) === expectedTarget;
+    return await fs31.readlink(path191) === expectedTarget;
   } catch (error3) {
     if (isNotFound(error3)) {
       return false;
@@ -108716,11 +108716,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 readFile59 = container.fs.readFile.bind(container.fs);
+      const readFile60 = container.fs.readFile.bind(container.fs);
       const resolvedVars = await resolvePipelineVars(
         plan.vars ?? {},
         container.env.cwd,
-        readFile59
+        readFile60
       );
       const resolvedSetup = plan.setup === null ? void 0 : plan.setup ?? steps.setup;
       const resolvedTeardown = plan.teardown === null ? void 0 : plan.teardown ?? steps.teardown;
@@ -108742,7 +108742,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, readFile59);
+          const expanded = await resolveFileIncludes(raw, container.env.cwd, readFile60);
           resources.logger.resolved("setup", expanded);
         }
         for (const task of plan.tasks) {
@@ -108755,7 +108755,7 @@ function registerPipelineCommand(program, container) {
                 vars: resolvedVars
               }),
               container.env.cwd,
-              readFile59
+              readFile60
             );
             resources.logger.resolved(`task: ${task.id} \u2014 ${task.title}`, expanded);
           } else {
@@ -108768,7 +108768,7 @@ function registerPipelineCommand(program, container) {
                   vars: resolvedVars
                 }),
                 container.env.cwd,
-                readFile59
+                readFile60
               );
               resources.logger.resolved(`task: ${task.id} / ${stepName}`, expanded);
             }
@@ -108776,7 +108776,7 @@ function registerPipelineCommand(program, container) {
         }
         if (resolvedTeardown) {
           const raw = interpolatePipelineVars(resolvedTeardown.prompt, resolvedVars, "teardown");
-          const expanded = await resolveFileIncludes(raw, container.env.cwd, readFile59);
+          const expanded = await resolveFileIncludes(raw, container.env.cwd, readFile60);
           resources.logger.resolved("teardown", expanded);
         }
       }
@@ -109721,28 +109721,28 @@ function detectTraceFile(firstLine) {
   }
   return void 0;
 }
-async function loadTraceFromFile(path190, options) {
-  const stat36 = await options.fs.stat(path190).catch(() => void 0);
+async function loadTraceFromFile(path191, options) {
+  const stat36 = await options.fs.stat(path191).catch(() => void 0);
   if (stat36 === void 0) {
     throw new UserError(
-      `Trace file not found: ${path190}
+      `Trace file not found: ${path191}
 Pass a path to an existing trace file, or run "poe-code traces" to list the traces found.`
     );
   }
   if (stat36.isDirectory()) {
     throw new UserError(
-      `Trace path is a directory: ${path190}
+      `Trace path is a directory: ${path191}
 Pass a path to a trace file, or run "poe-code traces" to list the traces found.`
     );
   }
-  const contents = await options.fs.readFile(path190, "utf8");
+  const contents = await options.fs.readFile(path191, "utf8");
   const firstLineEnd = contents.indexOf("\n");
   const firstLine = firstLineEnd === -1 ? contents : contents.slice(0, firstLineEnd);
   const source = detectTraceFile(firstLine);
   if (source === void 0) {
-    throw new Error(`Unable to detect trace source for file: ${path190}`);
+    throw new Error(`Unable to detect trace source for file: ${path191}`);
   }
-  return loadTrace({ source, id: path190, path: path190 }, options);
+  return loadTrace({ source, id: path191, path: path191 }, options);
 }
 function dateValue(date) {
   return date?.getTime() ?? 0;
@@ -111255,8 +111255,8 @@ var init_write_html = __esm({
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 async function openTraceHtml(tree, options) {
   const written = await writeTraceHtml(tree, options);
-  const open8 = options.open ?? ((target) => openExternal(target));
-  await open8(pathToFileURL2(written.path).href);
+  const open9 = options.open ?? ((target) => openExternal(target));
+  await open9(pathToFileURL2(written.path).href);
   return written;
 }
 var init_open_html = __esm({
@@ -111658,9 +111658,9 @@ async function exportTraceHtml(tree, options, output) {
     writeLine5(output, `Wrote ${written.path}`);
     return;
   }
-  const open8 = options.openExternal ?? ((target) => openExternal(target));
+  const open9 = options.openExternal ?? ((target) => openExternal(target));
   try {
-    await open8(pathToFileURL3(written.path).href);
+    await open9(pathToFileURL3(written.path).href);
     writeLine5(output, `Opened ${written.path}`);
   } catch (error3) {
     writeLine5(output, `Wrote ${written.path}`);
@@ -111745,16 +111745,16 @@ function registerTracesCommand(program, container) {
     const options = this.opts();
     const flags = resolveCommandFlags(program);
     const json = options.json === true;
-    const open8 = options.open === true;
+    const open9 = options.open === true;
     const htmlOut = options.htmlOut;
-    if ((open8 || htmlOut !== void 0) && pathArg === void 0) {
+    if ((open9 || htmlOut !== void 0) && pathArg === void 0) {
       throw new ValidationError(
-        open8 ? "--open requires a trace path." : "--html-out requires a trace path."
+        open9 ? "--open requires a trace path." : "--html-out requires a trace path."
       );
     }
-    if ((open8 || htmlOut !== void 0) && json) {
+    if ((open9 || htmlOut !== void 0) && json) {
       throw new ValidationError(
-        open8 ? "--open cannot be used with --json." : "--html-out cannot be used with --json."
+        open9 ? "--open cannot be used with --json." : "--html-out cannot be used with --json."
       );
     }
     const viewerOptions = {
@@ -111768,7 +111768,7 @@ function registerTracesCommand(program, container) {
       limit: parseLimit2(options.limit),
       json,
       fullTitles: options.fullTitles === true,
-      open: open8,
+      open: open9,
       htmlOut,
       rebuildIndex: options.rebuildIndex === true
     };
@@ -111784,11 +111784,11 @@ function registerTracesCommand(program, container) {
         if (pathArg === void 0 && viewerOptions.rebuildIndex) {
           logger2.dryRun("Dry run: would rebuild the trace index.");
         }
-        if (open8 || htmlOut !== void 0) {
+        if (open9 || htmlOut !== void 0) {
           logger2.dryRun(
             `Dry run: would export trace ${pathArg} as HTML${htmlOut !== void 0 ? ` to ${htmlOut}` : ""}.`
           );
-          if (open8) {
+          if (open9) {
             logger2.dryRun("Dry run: would open the HTML in a browser.");
           }
         } else {
@@ -114351,7 +114351,7 @@ function parseSources(value) {
         'Invalid "sources" frontmatter. Expected each source to be a string or object.'
       );
     }
-    const path190 = readRequiredString(getOwnEntry35(item, "path"), "sources[].path");
+    const path191 = readRequiredString(getOwnEntry35(item, "path"), "sources[].path");
     const startLine = readOptionalPositiveInteger(
       getOwnEntry35(item, "startLine"),
       "sources[].startLine"
@@ -114359,7 +114359,7 @@ function parseSources(value) {
     const endLine = readOptionalPositiveInteger(getOwnEntry35(item, "endLine"), "sources[].endLine");
     return parseSourceRef(
       serializeSourceRef({
-        path: path190,
+        path: path191,
         ...startLine === void 0 ? {} : { startLine },
         ...endLine === void 0 ? {} : { endLine }
       })
@@ -130879,9 +130879,9 @@ function findPathToModule(currentModuleName, targetModuleName, dependencyGraph,
   }
   visited.add(currentModuleName);
   for (const dependencyModuleName of dependencyGraph.get(currentModuleName) ?? []) {
-    const path190 = findPathToModule(dependencyModuleName, targetModuleName, dependencyGraph, visited);
-    if (path190 !== void 0) {
-      return [currentModuleName, ...path190];
+    const path191 = findPathToModule(dependencyModuleName, targetModuleName, dependencyGraph, visited);
+    if (path191 !== void 0) {
+      return [currentModuleName, ...path191];
     }
   }
   visited.delete(currentModuleName);
@@ -136264,11 +136264,11 @@ function assertSandboxDataDepth(depth) {
     throw new SandboxError({ budget: "dataDepth", current: depth, limit: MAX_DATA_DEPTH });
   }
 }
-function assertSnapshotDataDepth(depth, path190) {
-  if (depth > MAX_DATA_DEPTH) throw new SnapshotBudgetError(path190, depth);
+function assertSnapshotDataDepth(depth, path191) {
+  if (depth > MAX_DATA_DEPTH) throw new SnapshotBudgetError(path191, depth);
 }
 function assertSnapshotGraphDepth(value, rootPath = "$") {
-  walkGraphDepth(value, rootPath, (depth, path190) => assertSnapshotDataDepth(depth, path190));
+  walkGraphDepth(value, rootPath, (depth, path191) => assertSnapshotDataDepth(depth, path191));
 }
 function assertSandboxGraphDepth(value) {
   walkGraphDepth(value, "<root>", (depth) => assertSandboxDataDepth(depth));
@@ -136335,12 +136335,12 @@ var init_graph_depth = __esm({
       current;
       limit;
       path;
-      constructor(path190, current, limit = MAX_DATA_DEPTH) {
-        super(`Snapshot budget exceeded for dataDepth at ${path190}: ${current} > ${limit}.`);
+      constructor(path191, current, limit = MAX_DATA_DEPTH) {
+        super(`Snapshot budget exceeded for dataDepth at ${path191}: ${current} > ${limit}.`);
         this.name = "SnapshotBudgetError";
         this.current = current;
         this.limit = limit;
-        this.path = path190;
+        this.path = path191;
         replaceErrorStack(this);
       }
     };
@@ -136423,7 +136423,7 @@ function createDumpFile(snapshot2) {
   }
   return dumped;
 }
-function serializeDumpValue(value, path190, state) {
+function serializeDumpValue(value, path191, state) {
   if (value === null || typeof value === "string" || typeof value === "boolean") {
     return value;
   }
@@ -136440,22 +136440,22 @@ function serializeDumpValue(value, path190, state) {
     return SKIP_VALUE;
   }
   if (Array.isArray(value)) {
-    const reference2 = serializeHeapReference(value, path190, state);
+    const reference2 = serializeHeapReference(value, path191, state);
     if (reference2 !== void 0) {
       return reference2;
     }
-    return serializeArrayItems(value, path190, state);
+    return serializeArrayItems(value, path191, state);
   }
   if (!isPlainObject9(value)) {
     return SKIP_VALUE;
   }
-  const reference = serializeHeapReference(value, path190, state);
+  const reference = serializeHeapReference(value, path191, state);
   if (reference !== void 0) {
     return reference;
   }
-  return serializeObjectEntries(value, path190, state);
+  return serializeObjectEntries(value, path191, state);
 }
-function serializeHeapReference(value, path190, state) {
+function serializeHeapReference(value, path191, state) {
   const id = state.heapIds.get(value);
   if (id === void 0) {
     return void 0;
@@ -136464,19 +136464,19 @@ function serializeHeapReference(value, path190, state) {
     state.serializedHeapIds.add(id);
     if (isSandboxArguments(value)) {
       state.heap[String(id)] = serializeArguments(value, (entry, key3) => {
-        const serialized = serializeDumpValue(entry, `${path190}.${key3}`, state);
+        const serialized = serializeDumpValue(entry, `${path191}.${key3}`, state);
         return serialized === SKIP_VALUE ? { kind: "undefined" } : serialized;
       });
     } else if (Array.isArray(value)) {
       state.heap[String(id)] = {
         kind: "array",
-        items: serializeArrayItems(value, path190, state)
+        items: serializeArrayItems(value, path191, state)
       };
     } else {
       const errorType = sandboxErrorTypes.get(value);
       state.heap[String(id)] = {
         kind: "object",
-        entries: serializeObjectEntries(value, path190, state),
+        entries: serializeObjectEntries(value, path191, state),
         ...errorType === void 0 ? {} : { errorType }
       };
     }
@@ -136486,10 +136486,10 @@ function serializeHeapReference(value, path190, state) {
     id
   };
 }
-function serializeObjectEntries(value, path190, state) {
+function serializeObjectEntries(value, path191, state) {
   const serialized = {};
   for (const [key3, entry] of getEnumerableDataEntries(value)) {
-    const dumped = serializeDumpValue(entry, `${path190}.${key3}`, state);
+    const dumped = serializeDumpValue(entry, `${path191}.${key3}`, state);
     if (dumped !== SKIP_VALUE) {
       serialized[key3] = dumped;
     }
@@ -136551,9 +136551,9 @@ function isPlainObject9(value) {
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
-function serializeArrayItems(value, path190, state) {
+function serializeArrayItems(value, path191, state) {
   return getArrayDataItems(value).map((entry, index) => {
-    const serialized = serializeDumpValue(entry, `${path190}[${index}]`, state);
+    const serialized = serializeDumpValue(entry, `${path191}[${index}]`, state);
     return serialized === SKIP_VALUE ? { kind: "undefined" } : serialized;
   });
 }
@@ -136587,7 +136587,7 @@ var init_dump_format = __esm({
     init_arguments();
     init_arguments2();
     DUMP_FORMAT_VERSION = 1;
-    EXECUTION_SEMANTICS = "jobs-v5";
+    EXECUTION_SEMANTICS = "jobs-v6";
     SKIP_VALUE = /* @__PURE__ */ Symbol("SafeJS.skip-dump-value");
   }
 });
@@ -136634,44 +136634,44 @@ function validateDumpHeap(root, state) {
   const heap = root.heap === void 0 ? /* @__PURE__ */ Object.create(null) : requireRecord3(root.heap, "$.heap");
   const heapIds = /* @__PURE__ */ new Set();
   for (const [key3, value] of Object.entries(heap)) {
-    const path190 = `$.heap${formatKey(key3)}`;
-    const id = parseHeapId(key3, path190);
-    addUnique2(heapIds, id, path190);
-    const entry = requireRecord3(value, path190);
-    validateErrorType(entry, path190);
+    const path191 = `$.heap${formatKey(key3)}`;
+    const id = parseHeapId(key3, path191);
+    addUnique2(heapIds, id, path191);
+    const entry = requireRecord3(value, path191);
+    validateErrorType(entry, path191);
     if (entry.kind === "arguments") {
-      validateArgumentsProperties(entry, path190);
+      validateArgumentsProperties(entry, path191);
       continue;
     }
     if (entry.kind === "array") {
-      requireArray(entry.items, `${path190}.items`, state);
+      requireArray(entry.items, `${path191}.items`, state);
       continue;
     }
     if (entry.kind === "object") {
-      requireRecord3(entry.entries, `${path190}.entries`);
+      requireRecord3(entry.entries, `${path191}.entries`);
       continue;
     }
-    fail2("unknownTag", `${path190}.kind`, "unknown dump heap tag");
+    fail2("unknownTag", `${path191}.kind`, "unknown dump heap tag");
   }
   validateDumpReferences(root, "$", 0, state, heapIds);
 }
-function validateDumpReferences(value, path190, depth, state, heapIds) {
+function validateDumpReferences(value, path191, depth, state, heapIds) {
   if (value === null || typeof value !== "object") return;
   if (depth > state.limits.maxDepth)
-    fail2("budgetExceeded", path190, `exceeds nesting limit ${state.limits.maxDepth}`);
+    fail2("budgetExceeded", path191, `exceeds nesting limit ${state.limits.maxDepth}`);
   if (Array.isArray(value)) {
     value.forEach(
-      (entry, index) => validateDumpReferences(entry, `${path190}[${index}]`, depth + 1, state, heapIds)
+      (entry, index) => validateDumpReferences(entry, `${path191}[${index}]`, depth + 1, state, heapIds)
     );
     return;
   }
   const record2 = value;
   if (record2.kind === "ref") {
-    const id = requireSafeInteger(record2.id, `${path190}.id`, 1);
-    if (!heapIds.has(id)) fail2("danglingReference", `${path190}.id`, `unknown heap value ${id}`);
+    const id = requireSafeInteger(record2.id, `${path191}.id`, 1);
+    if (!heapIds.has(id)) fail2("danglingReference", `${path191}.id`, `unknown heap value ${id}`);
   }
   for (const [key3, entry] of Object.entries(record2)) {
-    validateDumpReferences(entry, `${path190}${formatKey(key3)}`, depth + 1, state, heapIds);
+    validateDumpReferences(entry, `${path191}${formatKey(key3)}`, depth + 1, state, heapIds);
   }
 }
 function validateRunSnapshotState(root, state) {
@@ -136690,64 +136690,64 @@ function validateRunSnapshotState(root, state) {
   if (root.loopIterations !== void 0) {
     const iterations = requireRecord3(root.loopIterations, "$.loopIterations");
     for (const [nodeId, value] of Object.entries(iterations)) {
-      const path190 = `$.loopIterations${formatKey(nodeId)}`;
-      requireSafeInteger(Number(nodeId), `${path190}#key`, 0);
+      const path191 = `$.loopIterations${formatKey(nodeId)}`;
+      requireSafeInteger(Number(nodeId), `${path191}#key`, 0);
       if (typeof value === "number") {
-        requireSafeInteger(value, path190, 0);
+        requireSafeInteger(value, path191, 0);
         continue;
       }
-      const iteration = requireRecord3(value, path190);
-      requireSafeInteger(iteration.index, `${path190}.index`, 0);
-      requireArray(iteration.values, `${path190}.values`, state);
+      const iteration = requireRecord3(value, path191);
+      requireSafeInteger(iteration.index, `${path191}.index`, 0);
+      requireArray(iteration.values, `${path191}.values`, state);
     }
   }
   if (root.pendingAwaits !== void 0) {
     const pendingAwaits = requireArray(root.pendingAwaits, "$.pendingAwaits", state);
     pendingAwaits.forEach((value, index) => {
-      const path190 = `$.pendingAwaits[${index}]`;
-      const pending = requireRecord3(value, path190);
-      if (pending.nodeId !== void 0) requireSafeInteger(pending.nodeId, `${path190}.nodeId`, 0);
-      const span = requireRecord3(pending.span, `${path190}.span`);
-      const start = validatePosition(span.start, `${path190}.span.start`);
-      const end = validatePosition(span.end, `${path190}.span.end`);
+      const path191 = `$.pendingAwaits[${index}]`;
+      const pending = requireRecord3(value, path191);
+      if (pending.nodeId !== void 0) requireSafeInteger(pending.nodeId, `${path191}.nodeId`, 0);
+      const span = requireRecord3(pending.span, `${path191}.span`);
+      const start = validatePosition(span.start, `${path191}.span.start`);
+      const end = validatePosition(span.end, `${path191}.span.end`);
       if (start > end) {
-        fail2("invalidValue", `${path190}.span`, "start must not exceed end");
+        fail2("invalidValue", `${path191}.span`, "start must not exceed end");
       }
     });
   }
 }
-function validatePosition(value, path190) {
-  const position = requireRecord3(value, path190);
-  requireSafeInteger(position.line, `${path190}.line`, 1);
-  requireSafeInteger(position.column, `${path190}.column`, 0);
-  return requireSafeInteger(position.offset, `${path190}.offset`, 0);
+function validatePosition(value, path191) {
+  const position = requireRecord3(value, path191);
+  requireSafeInteger(position.line, `${path191}.line`, 1);
+  requireSafeInteger(position.column, `${path191}.column`, 0);
+  return requireSafeInteger(position.offset, `${path191}.offset`, 0);
 }
-function validateTaggedValue(record2, path190, state) {
+function validateTaggedValue(record2, path191, state) {
   switch (record2.kind) {
     case "undefined":
       return;
     case "number":
       if (!["-Infinity", "Infinity", "NaN"].includes(String(record2.value))) {
-        fail2("invalidValue", `${path190}.value`, "unknown non-finite number value");
+        fail2("invalidValue", `${path191}.value`, "unknown non-finite number value");
       }
       return;
     case "fn":
-      requireSafeInteger(record2.astNodeId, `${path190}.astNodeId`, 0);
-      requireSnapshotId(record2.capturedScopeId, `${path190}.capturedScopeId`);
+      requireSafeInteger(record2.astNodeId, `${path191}.astNodeId`, 0);
+      requireSnapshotId(record2.capturedScopeId, `${path191}.capturedScopeId`);
       return;
     case "generator":
-      validateGeneratorShape(record2, path190, state);
+      validateGeneratorShape(record2, path191, state);
       return;
     case "promise":
-      requireSnapshotId(record2.id, `${path190}.id`);
+      requireSnapshotId(record2.id, `${path191}.id`);
       return;
     case "ref":
-      requireSafeInteger(record2.id, `${path190}.id`, 1);
+      requireSafeInteger(record2.id, `${path191}.id`, 1);
       return;
     case "regex":
-      requireString2(record2.source, `${path190}.source`, state.limits);
-      requireString2(record2.flags, `${path190}.flags`, state.limits);
-      requireSafeInteger(record2.lastIndex, `${path190}.lastIndex`, 0);
+      requireString2(record2.source, `${path191}.source`, state.limits);
+      requireString2(record2.flags, `${path191}.flags`, state.limits);
+      requireSafeInteger(record2.lastIndex, `${path191}.lastIndex`, 0);
       return;
     case "array":
     case "arguments":
@@ -136757,28 +136757,28 @@ function validateTaggedValue(record2, path190, state) {
       return;
   }
 }
-function validateGeneratorShape(record2, path190, state) {
+function validateGeneratorShape(record2, path191, state) {
   if (!["start", "suspended", "done"].includes(String(record2.state))) {
-    fail2("invalidState", `${path190}.state`, "unknown generator state");
+    fail2("invalidState", `${path191}.state`, "unknown generator state");
   }
   if (record2.state === "done") {
     if (record2.astNodeId !== void 0 || record2.capturedScopeId !== void 0 || record2.sent !== void 0 || record2.yieldNodeId !== void 0) {
-      fail2("invalidState", path190, "done generator cannot contain resume state");
+      fail2("invalidState", path191, "done generator cannot contain resume state");
     }
     return;
   }
-  requireSafeInteger(record2.astNodeId, `${path190}.astNodeId`, 0);
-  requireSnapshotId(record2.capturedScopeId, `${path190}.capturedScopeId`);
+  requireSafeInteger(record2.astNodeId, `${path191}.astNodeId`, 0);
+  requireSnapshotId(record2.capturedScopeId, `${path191}.capturedScopeId`);
   if (record2.state === "start") {
     if (record2.sent !== void 0 || record2.yieldNodeId !== void 0) {
-      fail2("invalidState", path190, "unstarted generator cannot contain a resume cursor");
+      fail2("invalidState", path191, "unstarted generator cannot contain a resume cursor");
     }
     return;
   }
-  requireSafeInteger(record2.yieldNodeId, `${path190}.yieldNodeId`, 0);
-  const sent = requireArray(record2.sent, `${path190}.sent`, state);
+  requireSafeInteger(record2.yieldNodeId, `${path191}.yieldNodeId`, 0);
+  const sent = requireArray(record2.sent, `${path191}.sent`, state);
   sent.forEach((completion, index) => {
-    const completionPath = `${path190}.sent[${index}]`;
+    const completionPath = `${path191}.sent[${index}]`;
     const candidate = requireRecord3(completion, completionPath);
     if (!Object.hasOwn(candidate, "type")) {
       fail2("invalidValue", `${completionPath}.type`, "completion type is required");
@@ -136791,41 +136791,41 @@ function validateGeneratorShape(record2, path190, state) {
     }
   });
 }
-function validateErrorType(record2, path190) {
+function validateErrorType(record2, path191) {
   if (!Object.hasOwn(record2, "errorType")) return;
   if (record2.kind !== "object" || !sandboxErrorNames.includes(record2.errorType)) {
-    fail2("invalidValue", `${path190}.errorType`, "invalid error metadata");
+    fail2("invalidValue", `${path191}.errorType`, "invalid error metadata");
   }
 }
-function validateArgumentsProperties(record2, path190) {
+function validateArgumentsProperties(record2, path191) {
   if (typeof record2.extensible !== "boolean") {
-    fail2("invalidType", `${path190}.extensible`, "expected boolean");
+    fail2("invalidType", `${path191}.extensible`, "expected boolean");
   }
   if (typeof record2.lengthBeforeCallee !== "boolean") {
-    fail2("invalidType", `${path190}.lengthBeforeCallee`, "expected boolean");
+    fail2("invalidType", `${path191}.lengthBeforeCallee`, "expected boolean");
   }
-  const properties = requireRecord3(record2.properties, `${path190}.properties`);
+  const properties = requireRecord3(record2.properties, `${path191}.properties`);
   if (record2.iterator !== null) {
-    const iterator = requireRecord3(record2.iterator, `${path190}.iterator`);
+    const iterator = requireRecord3(record2.iterator, `${path191}.iterator`);
     for (const key3 of Object.keys(iterator)) {
       if (!["configurable", "enumerable", "writable"].includes(key3)) {
         fail2(
           "invalidValue",
-          `${path190}.iterator${formatKey(key3)}`,
+          `${path191}.iterator${formatKey(key3)}`,
           "unknown iterator descriptor field"
         );
       }
     }
     for (const flag of ["configurable", "enumerable", "writable"]) {
       if (typeof iterator[flag] !== "boolean")
-        fail2("invalidType", `${path190}.iterator.${flag}`, "expected boolean");
+        fail2("invalidType", `${path191}.iterator.${flag}`, "expected boolean");
     }
   }
   if (record2.lengthBeforeCallee && !Object.hasOwn(properties, "length")) {
-    fail2("invalidValue", `${path190}.properties`, "initial length property is required");
+    fail2("invalidValue", `${path191}.properties`, "initial length property is required");
   }
   for (const [key3, value] of Object.entries(properties)) {
-    const propertyPath = `${path190}.properties${formatKey(key3)}`;
+    const propertyPath = `${path191}.properties${formatKey(key3)}`;
     if (key3 === "callee")
       fail2("invalidValue", propertyPath, "strict callee accessor cannot be replaced");
     const descriptor = requireRecord3(value, propertyPath);
@@ -136846,71 +136846,68 @@ function validateArgumentsProperties(record2, path190) {
     }
   }
 }
-function validateGenericValue(value, path190, depth, state) {
+function validateGenericValue(value, path191, depth, state) {
   if (state.dataPropertiesOnly && types.isProxy(value)) {
-    fail2("invalidType", path190, "proxy objects are not snapshot data");
+    fail2("invalidType", path191, "proxy objects are not snapshot data");
   }
   if (depth > state.limits.maxDepth)
-    fail2("budgetExceeded", path190, `exceeds nesting limit ${state.limits.maxDepth}`);
+    fail2("budgetExceeded", path191, `exceeds nesting limit ${state.limits.maxDepth}`);
   state.entries += 1;
   if (state.entries > state.limits.maxAggregateEntries)
     fail2(
       "budgetExceeded",
-      path190,
+      path191,
       `exceeds aggregate entry limit ${state.limits.maxAggregateEntries}`
     );
   if (typeof value === "string") {
-    requireString2(value, path190, state.limits);
+    requireString2(value, path191, state.limits);
     state.dataSize += value.length;
-  } else if (typeof value === "number") {
-    if (Number.isInteger(value) && !Number.isSafeInteger(value))
-      fail2("invalidValue", path190, "integer must be safe");
   } else if (Array.isArray(value)) {
-    if (value.length > state.limits.maxEntries) fail2("budgetExceeded", path190, "array is too large");
+    if (value.length > state.limits.maxEntries) fail2("budgetExceeded", path191, "array is too large");
     if (state.dataPropertiesOnly) {
-      const entries = snapshotDataEntries(value, path190).filter(([key3]) => key3 !== "length");
+      const entries = snapshotDataEntries(value, path191).filter(([key3]) => key3 !== "length");
       if (entries.length !== value.length)
-        fail2("invalidType", path190, "snapshot arrays must be dense");
+        fail2("invalidType", path191, "snapshot arrays must be dense");
       for (const [key3, entry] of entries) {
         const index = Number(key3);
         if (!Number.isInteger(index) || index < 0 || index >= value.length || String(index) !== key3) {
-          fail2("invalidType", path190, "snapshot arrays cannot have named properties");
+          fail2("invalidType", path191, "snapshot arrays cannot have named properties");
         }
-        validateGenericValue(entry, `${path190}[${key3}]`, depth + 1, state);
+        validateGenericValue(entry, `${path191}[${key3}]`, depth + 1, state);
       }
     } else {
       value.forEach(
-        (entry, index) => validateGenericValue(entry, `${path190}[${index}]`, depth + 1, state)
+        (entry, index) => validateGenericValue(entry, `${path191}[${index}]`, depth + 1, state)
       );
     }
   } else if (value !== null && typeof value === "object") {
     const record2 = value;
     if (state.validateTaggedPayloads && isTaggedValueShape(record2)) {
-      validateTaggedValue(record2, path190, state);
+      validateTaggedValue(record2, path191, state);
     }
-    const entries = state.dataPropertiesOnly ? snapshotDataEntries(value, path190) : Object.entries(value);
+    const entries = state.dataPropertiesOnly ? snapshotDataEntries(value, path191) : Object.entries(value);
     for (const [key3, entry] of entries) {
-      requireString2(key3, `${path190}${formatKey(key3)}`, state.limits);
+      requireString2(key3, `${path191}${formatKey(key3)}`, state.limits);
       state.dataSize += key3.length;
-      validateGenericValue(entry, `${path190}${formatKey(key3)}`, depth + 1, state);
+      validateGenericValue(entry, `${path191}${formatKey(key3)}`, depth + 1, state);
     }
   } else if (!["boolean", "number"].includes(typeof value) && !(state.allowFunctions && typeof value === "function") && !(state.allowUndefined && value === void 0) && value !== null) {
-    fail2("invalidType", path190, "contains an unsupported value");
+    fail2("invalidType", path191, "contains an unsupported value");
   }
   if (state.dataSize > state.limits.maxDataSize)
-    fail2("budgetExceeded", path190, `exceeds aggregate data limit ${state.limits.maxDataSize}`);
+    fail2("budgetExceeded", path191, `exceeds aggregate data limit ${state.limits.maxDataSize}`);
 }
-function snapshotDataEntries(value, path190) {
+function snapshotDataEntries(value, path191) {
   const prototype = Object.getPrototypeOf(value);
   if (prototype !== null && prototype !== (Array.isArray(value) ? Array.prototype : Object.prototype)) {
-    fail2("invalidType", path190, "snapshot data must not have a custom prototype");
+    fail2("invalidType", path191, "snapshot data must not have a custom prototype");
   }
   if (Object.getOwnPropertySymbols(value).length > 0) {
-    fail2("invalidType", path190, "snapshot data must not have symbol properties");
+    fail2("invalidType", path191, "snapshot data must not have symbol properties");
   }
   return Object.entries(Object.getOwnPropertyDescriptors(value)).map(([key3, descriptor]) => {
     if (!("value" in descriptor))
-      fail2("invalidType", `${path190}${formatKey(key3)}`, "snapshot data must not have accessors");
+      fail2("invalidType", `${path191}${formatKey(key3)}`, "snapshot data must not have accessors");
     return [key3, descriptor.value];
   });
 }
@@ -136924,48 +136921,48 @@ function defaultLimits() {
     maxDataSize: DEFAULT_MAX_DATA_SIZE
   };
 }
-function requireArray(value, path190, state) {
-  if (!Array.isArray(value)) fail2("invalidType", path190, "must be an array");
+function requireArray(value, path191, state) {
+  if (!Array.isArray(value)) fail2("invalidType", path191, "must be an array");
   if (value.length > state.limits.maxEntries)
-    fail2("budgetExceeded", path190, `exceeds collection entry limit ${state.limits.maxEntries}`);
+    fail2("budgetExceeded", path191, `exceeds collection entry limit ${state.limits.maxEntries}`);
   return value;
 }
-function requireRecord3(value, path190) {
+function requireRecord3(value, path191) {
   if (typeof value !== "object" || value === null || Array.isArray(value))
-    fail2("invalidType", path190, "must be an object");
+    fail2("invalidType", path191, "must be an object");
   return value;
 }
-function requireSnapshotId(value, path190) {
+function requireSnapshotId(value, path191) {
   if (typeof value === "string") {
-    if (value.length === 0) fail2("invalidValue", path190, "id must not be empty");
+    if (value.length === 0) fail2("invalidValue", path191, "id must not be empty");
     return value;
   }
-  return requireSafeInteger(value, path190, 0);
+  return requireSafeInteger(value, path191, 0);
 }
-function requireSafeInteger(value, path190, minimum) {
+function requireSafeInteger(value, path191, minimum) {
   if (typeof value !== "number" || !Number.isSafeInteger(value) || value < minimum)
-    fail2("invalidValue", path190, `must be a safe integer >= ${minimum}`);
+    fail2("invalidValue", path191, `must be a safe integer >= ${minimum}`);
   return value;
 }
-function requireNonEmptyString5(value, path190, limits) {
-  const text5 = requireString2(value, path190, limits);
-  if (text5.length === 0) fail2("invalidValue", path190, "must not be empty");
+function requireNonEmptyString5(value, path191, limits) {
+  const text5 = requireString2(value, path191, limits);
+  if (text5.length === 0) fail2("invalidValue", path191, "must not be empty");
   return text5;
 }
-function requireString2(value, path190, limits) {
-  if (typeof value !== "string") fail2("invalidType", path190, "must be a string");
+function requireString2(value, path191, limits) {
+  if (typeof value !== "string") fail2("invalidType", path191, "must be a string");
   if (value.length > limits.maxStringLength)
-    fail2("budgetExceeded", path190, `exceeds string limit ${limits.maxStringLength}`);
+    fail2("budgetExceeded", path191, `exceeds string limit ${limits.maxStringLength}`);
   return value;
 }
-function addUnique2(values, value, path190) {
-  if (values.has(value)) fail2("duplicateId", path190, `duplicate id ${String(value)}`);
+function addUnique2(values, value, path191) {
+  if (values.has(value)) fail2("duplicateId", path191, `duplicate id ${String(value)}`);
   values.add(value);
 }
-function parseHeapId(value, path190) {
+function parseHeapId(value, path191) {
   if (String(Number(value)) !== value)
-    fail2("invalidValue", path190, "heap key must be a canonical positive integer");
-  return requireSafeInteger(Number(value), path190, 1);
+    fail2("invalidValue", path191, "heap key must be a canonical positive integer");
+  return requireSafeInteger(Number(value), path191, 1);
 }
 function formatKey(key3) {
   return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key3) ? `.${key3}` : `[${JSON.stringify(key3)}]`;
@@ -136973,8 +136970,8 @@ function formatKey(key3) {
 function isTaggedValueShape(value) {
   return typeof value.kind === "string" && TAGGED_VALUE_KINDS.has(value.kind);
 }
-function fail2(code, path190, detail) {
-  throw new SnapshotValidationError(code, path190, detail);
+function fail2(code, path191, detail) {
+  throw new SnapshotValidationError(code, path191, detail);
 }
 var DEFAULT_MAX_DEPTH, DEFAULT_MAX_ENTRIES, DEFAULT_MAX_STRING_LENGTH, DEFAULT_MAX_DATA_SIZE, TAGGED_VALUE_KINDS, SnapshotValidationError;
 var init_validation = __esm({
@@ -137005,11 +137002,11 @@ var init_validation = __esm({
     SnapshotValidationError = class extends Error {
       code;
       path;
-      constructor(code, path190, detail) {
-        super(`Invalid snapshot at ${path190}: ${detail}`);
+      constructor(code, path191, detail) {
+        super(`Invalid snapshot at ${path191}: ${detail}`);
         this.name = "SnapshotValidationError";
         this.code = code;
-        this.path = path190;
+        this.path = path191;
         replaceErrorStack(this);
       }
     };
@@ -137374,7 +137371,7 @@ var init_promise_replay = __esm({
 function encodeReplayData(value, options = {}) {
   const nodes = [];
   const seen = /* @__PURE__ */ new WeakMap();
-  const encode = (entry, depth, path190) => {
+  const encode = (entry, depth, path191) => {
     if (depth > MAX_DATA_DEPTH) throw new TypeError("Replay data exceeds the nesting limit.");
     if (entry === null || typeof entry === "boolean" || typeof entry === "string") return entry;
     if (entry === void 0) return { tag: "undefined" };
@@ -137387,12 +137384,12 @@ function encodeReplayData(value, options = {}) {
       };
     }
     if (isSandboxPromise(entry)) {
-      const id2 = options.identifyPromise?.(entry, path190);
+      const id2 = options.identifyPromise?.(entry, path191);
       if (typeof id2 === "string" && id2.length > 0) return { tag: "promise-capability", id: id2 };
     }
     let capabilityId;
     if (isSandboxClosure(entry)) {
-      capabilityId = options.identifyCapability?.(entry, path190);
+      capabilityId = options.identifyCapability?.(entry, path191);
       if (typeof capabilityId !== "string" || capabilityId.length === 0)
         throw new MissingReplayCapabilityError("A callable needs an explicit resume capability.");
       if (!options.captureCapabilityProperties) return { tag: "capability", id: capabilityId };
@@ -137407,7 +137404,7 @@ function encodeReplayData(value, options = {}) {
     const id = nodes.length;
     seen.set(entry, id);
     nodes.push(void 0);
-    const child = (value2, key3) => encode(value2, depth + 1, [...path190, key3]);
+    const child = (value2, key3) => encode(value2, depth + 1, [...path191, key3]);
     if (isSandboxClosure(entry)) {
       nodes[id] = {
         kind: "capability",
@@ -137725,8 +137722,8 @@ function restoreReplayCalls(input, encodedOutcomes, callbackSizes, requiredHostC
   }
   const resolveCapability = (id) => {
     if (!capabilities.has(id) && id.startsWith("host:")) {
-      const path190 = JSON.parse(id.slice(5));
-      if (!Array.isArray(path190) || path190.length < 2 || path190.some((value) => typeof value !== "string"))
+      const path191 = JSON.parse(id.slice(5));
+      if (!Array.isArray(path191) || path191.length < 2 || path191.some((value) => typeof value !== "string"))
         throw new TypeError("Invalid host capability identity.");
       requiredHostCapabilities.add(id);
       capabilities.set(
@@ -138125,8 +138122,8 @@ var init_host_call = __esm({
         if (!this.capabilityIds.has(closure)) this.capabilityIds.set(closure, identity);
         this.nativeClosures.set(native, closure);
       }
-      registerHostCapability(path190, closure, native) {
-        const identity = `host:${path190}`;
+      registerHostCapability(path191, closure, native) {
+        const identity = `host:${path191}`;
         const existing = this.capabilities.get(identity);
         if (existing !== void 0 && existing !== closure)
           throw new TypeError(`Conflicting replay capability '${identity}'.`);
@@ -140082,7 +140079,7 @@ function deepCopyFromSandbox(value, options = {}) {
     options
   );
 }
-function copyToSandbox(value, state, path190 = "<root>", cloneSandboxCollections = false, depth = 0) {
+function copyToSandbox(value, state, path191 = "<root>", cloneSandboxCollections = false, depth = 0) {
   assertSandboxDataDepth(depth);
   if (isSandboxPrimitive(value)) {
     return value;
@@ -140098,8 +140095,8 @@ function copyToSandbox(value, state, path190 = "<root>", cloneSandboxCollections
     state.seen.set(value, copy);
     for (const [key3, entry] of value.entries) {
       copy.entries.set(
-        copyToSandbox(key3, state, `${path190}.<key>`, true, depth + 1),
-        copyToSandbox(entry, state, `${path190}.<value>`, true, depth + 1)
+        copyToSandbox(key3, state, `${path191}.<key>`, true, depth + 1),
+        copyToSandbox(entry, state, `${path191}.<value>`, true, depth + 1)
       );
     }
     return copy;
@@ -140111,7 +140108,7 @@ function copyToSandbox(value, state, path190 = "<root>", cloneSandboxCollections
     const copy = createSandboxSet();
     state.seen.set(value, copy);
     for (const entry of value.values) {
-      copy.values.add(copyToSandbox(entry, state, `${path190}.<value>`, true, depth + 1));
+      copy.values.add(copyToSandbox(entry, state, `${path191}.<value>`, true, depth + 1));
     }
     return copy;
   }
@@ -140137,8 +140134,8 @@ function copyToSandbox(value, state, path190 = "<root>", cloneSandboxCollections
     state.seen.set(value, copy);
     for (const [key3, entry] of value) {
       copy.entries.set(
-        copyToSandbox(key3, state, `${path190}.<key>`, cloneSandboxCollections, depth + 1),
-        copyToSandbox(entry, state, `${path190}.<value>`, cloneSandboxCollections, depth + 1)
+        copyToSandbox(key3, state, `${path191}.<key>`, cloneSandboxCollections, depth + 1),
+        copyToSandbox(entry, state, `${path191}.<value>`, cloneSandboxCollections, depth + 1)
       );
     }
     return copy;
@@ -140152,7 +140149,7 @@ function copyToSandbox(value, state, path190 = "<root>", cloneSandboxCollections
     state.seen.set(value, copy);
     for (const entry of value) {
       copy.values.add(
-        copyToSandbox(entry, state, `${path190}.<value>`, cloneSandboxCollections, depth + 1)
+        copyToSandbox(entry, state, `${path191}.<value>`, cloneSandboxCollections, depth + 1)
       );
     }
     return copy;
@@ -140164,14 +140161,14 @@ function copyToSandbox(value, state, path190 = "<root>", cloneSandboxCollections
     }
     const copy = new Array(value.length);
     state.seen.set(value, copy);
-    for (const entry of getEnumerableArrayEntries(value, path190)) {
+    for (const entry of getEnumerableArrayEntries(value, path191)) {
       defineOwnDataProperty(
         copy,
         entry.key,
         copyToSandbox(
           entry.value,
           state,
-          joinArrayPath(path190, entry.key),
+          joinArrayPath(path191, entry.key),
           cloneSandboxCollections,
           depth + 1
         )
@@ -140187,7 +140184,7 @@ function copyToSandbox(value, state, path190 = "<root>", cloneSandboxCollections
     copySandboxArgumentProperties(
       value,
       copy,
-      (entry, key3) => copyToSandbox(entry, state, joinPath(path190, key3), cloneSandboxCollections, depth + 1)
+      (entry, key3) => copyToSandbox(entry, state, joinPath(path191, key3), cloneSandboxCollections, depth + 1)
     );
     return copy;
   }
@@ -140200,14 +140197,14 @@ function copyToSandbox(value, state, path190 = "<root>", cloneSandboxCollections
     state.seen.set(value, copy);
     const errorType = sandboxErrorTypes.get(value);
     if (errorType !== void 0) sandboxErrorTypes.set(copy, errorType);
-    for (const entry of getEnumerableObjectEntries(value, path190)) {
+    for (const entry of getEnumerableObjectEntries(value, path191)) {
       defineOwnDataProperty(
         copy,
         entry.key,
         copyToSandbox(
           entry.value,
           state,
-          joinPath(path190, entry.key),
+          joinPath(path191, entry.key),
           cloneSandboxCollections,
           depth + 1
         )
@@ -140215,9 +140212,9 @@ function copyToSandbox(value, state, path190 = "<root>", cloneSandboxCollections
     }
     return copy;
   }
-  throw new TypeError(`Unsupported sandbox value at ${path190}: ${describeValue(value)}`);
+  throw new TypeError(`Unsupported sandbox value at ${path191}: ${describeValue(value)}`);
 }
-function copyFromSandbox(value, state, path190 = "<root>", options, depth = 0) {
+function copyFromSandbox(value, state, path191 = "<root>", options, depth = 0) {
   assertSandboxDataDepth(depth);
   if (isSandboxPrimitive(value)) {
     return value;
@@ -140262,8 +140259,8 @@ function copyFromSandbox(value, state, path190 = "<root>", options, depth = 0) {
     state.seen.set(value, copy);
     for (const [key3, entry] of value.entries) {
       copy.set(
-        copyFromSandbox(key3, state, `${path190}.<key>`, options, depth + 1),
-        copyFromSandbox(entry, state, `${path190}.<value>`, options, depth + 1)
+        copyFromSandbox(key3, state, `${path191}.<key>`, options, depth + 1),
+        copyFromSandbox(entry, state, `${path191}.<value>`, options, depth + 1)
       );
     }
     return copy;
@@ -140276,7 +140273,7 @@ function copyFromSandbox(value, state, path190 = "<root>", options, depth = 0) {
     const copy = /* @__PURE__ */ new Set();
     state.seen.set(value, copy);
     for (const entry of value.values) {
-      copy.add(copyFromSandbox(entry, state, `${path190}.<value>`, options, depth + 1));
+      copy.add(copyFromSandbox(entry, state, `${path191}.<value>`, options, depth + 1));
     }
     return copy;
   }
@@ -140287,11 +140284,11 @@ function copyFromSandbox(value, state, path190 = "<root>", options, depth = 0) {
     }
     const copy = new Array(value.length);
     state.seen.set(value, copy);
-    for (const entry of getEnumerableArrayEntries(value, path190)) {
+    for (const entry of getEnumerableArrayEntries(value, path191)) {
       defineOwnDataProperty(
         copy,
         entry.key,
-        copyFromSandbox(entry.value, state, joinArrayPath(path190, entry.key), options, depth + 1)
+        copyFromSandbox(entry.value, state, joinArrayPath(path191, entry.key), options, depth + 1)
       );
     }
     return copy;
@@ -140304,7 +140301,7 @@ function copyFromSandbox(value, state, path190 = "<root>", options, depth = 0) {
     copySandboxArgumentProperties(
       value,
       copy,
-      (entry, key3) => copyFromSandbox(entry, state, joinPath(path190, key3), options, depth + 1)
+      (entry, key3) => copyFromSandbox(entry, state, joinPath(path191, key3), options, depth + 1)
     );
     return copy;
   }
@@ -140315,16 +140312,16 @@ function copyFromSandbox(value, state, path190 = "<root>", options, depth = 0) {
     }
     const copy = createPlainObject(Object.getPrototypeOf(value) === null);
     state.seen.set(value, copy);
-    for (const entry of getEnumerableObjectEntries(value, path190)) {
+    for (const entry of getEnumerableObjectEntries(value, path191)) {
       defineOwnDataProperty(
         copy,
         entry.key,
-        copyFromSandbox(entry.value, state, joinPath(path190, entry.key), options, depth + 1)
+        copyFromSandbox(entry.value, state, joinPath(path191, entry.key), options, depth + 1)
       );
     }
     return copy;
   }
-  throw new TypeError(`Unsupported sandbox value at ${path190}: ${describeValue(value)}`);
+  throw new TypeError(`Unsupported sandbox value at ${path191}: ${describeValue(value)}`);
 }
 function isSandboxPrimitive(value) {
   return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
@@ -140404,7 +140401,7 @@ function defineOwnDataProperty(target, key3, value) {
     value
   });
 }
-function getEnumerableObjectEntries(value, path190) {
+function getEnumerableObjectEntries(value, path191) {
   const descriptors = Object.getOwnPropertyDescriptors(value);
   const entries = [];
   for (const [key3, descriptor] of Object.entries(descriptors)) {
@@ -140412,7 +140409,7 @@ function getEnumerableObjectEntries(value, path190) {
       continue;
     }
     if ("get" in descriptor || "set" in descriptor) {
-      throw new TypeError(`Unsupported sandbox value at ${joinPath(path190, key3)}: accessor property`);
+      throw new TypeError(`Unsupported sandbox value at ${joinPath(path191, key3)}: accessor property`);
     }
     entries.push({
       key: key3,
@@ -140421,7 +140418,7 @@ function getEnumerableObjectEntries(value, path190) {
   }
   return entries;
 }
-function getEnumerableArrayEntries(value, path190) {
+function getEnumerableArrayEntries(value, path191) {
   const descriptors = Object.getOwnPropertyDescriptors(value);
   const entries = [];
   for (const [key3, descriptor] of Object.entries(descriptors)) {
@@ -140430,7 +140427,7 @@ function getEnumerableArrayEntries(value, path190) {
     }
     if ("get" in descriptor || "set" in descriptor) {
       throw new TypeError(
-        `Unsupported sandbox value at ${joinArrayPath(path190, key3)}: accessor property`
+        `Unsupported sandbox value at ${joinArrayPath(path191, key3)}: accessor property`
       );
     }
     entries.push({
@@ -140459,11 +140456,11 @@ function describeValue(value) {
   }
   return typeof value;
 }
-function joinPath(path190, key3) {
-  return path190 === "<root>" ? `<root>.${key3}` : `${path190}.${key3}`;
+function joinPath(path191, key3) {
+  return path191 === "<root>" ? `<root>.${key3}` : `${path191}.${key3}`;
 }
-function joinArrayPath(path190, key3) {
-  return isArrayIndexKey(key3) ? `${path190}[${key3}]` : joinPath(path190, key3);
+function joinArrayPath(path191, key3) {
+  return isArrayIndexKey(key3) ? `${path191}[${key3}]` : joinPath(path191, key3);
 }
 var sandboxClosureBrand, sandboxGeneratorBrand, sandboxMapBrand, sandboxPromiseBrand, sandboxRegexBrand, sandboxRegexPattern, sandboxSetBrand, sandboxRetainedValues;
 var init_values = __esm({
@@ -140601,10 +140598,102 @@ var init_random = __esm({
   }
 });
 
+// packages/safejs/src/snapshot/migration.ts
+function validateMigrationSemantics(value) {
+  if (!["jobs-v1", "jobs-v2", "jobs-v3", "jobs-v4", "jobs-v5", "jobs-v6"].includes(value))
+    throw new TypeError(
+      "Migration requires a supported execution-semantics marker (jobs-v1 through jobs-v6)."
+    );
+}
+function validateMigrationJournal(sourceHash, replay, hostCalls = []) {
+  if (replay === void 0)
+    throw new TypeError("Migration requires a complete host replay journal.");
+  if (!Array.isArray(hostCalls)) throw new TypeError("Invalid migration hostCalls.");
+  const journal = new HostCallJournal(sourceHash, hostCalls, void 0, replay);
+  try {
+    const restored = journal.snapshotReplay();
+    for (const call of restored.calls) {
+      if (["created", "running"].includes(call.lifecycle) && call.outcome !== void 0)
+        throw new TypeError("Unresolved migration calls cannot contain a recorded outcome.");
+      for (const callback of call.callbacks ?? []) {
+        if (!call.functions?.includes(callback.id))
+          throw new TypeError("Migration callback has no registered source function.");
+      }
+    }
+    return restored;
+  } finally {
+    journal.dispose();
+  }
+}
+function validateMigrationReconciliation(value, checkpointDigest, calls) {
+  validateSnapshotData(value);
+  const receipt = value;
+  if (receipt === null || typeof receipt !== "object" || receipt.checkpointDigest !== checkpointDigest || !isCheckpointDigest(receipt.checkpointDigest))
+    throw new TypeError("Migration reconciliation must identify this exact checkpoint digest.");
+  if (receipt.quiescent !== true)
+    throw new TypeError(
+      "Migration requires explicit host confirmation that execution, operations, and callbacks are quiescent."
+    );
+  if (!Array.isArray(receipt.calls))
+    throw new TypeError("Migration reconciliation calls must be an array.");
+  const pending = new Map(
+    calls.filter((call) => !["settled", "consumed"].includes(call.lifecycle)).map((call) => [call.id, call])
+  );
+  for (const resolution of receipt.calls) {
+    if (resolution === null || typeof resolution !== "object" || !pending.has(resolution.callId))
+      throw new TypeError("Migration contains an unknown or duplicate call resolution.");
+    if (!["not-performed", "fulfilled", "rejected"].includes(resolution.disposition) || resolution.disposition === "fulfilled" && !Object.hasOwn(resolution, "value") || resolution.disposition === "rejected" && !Object.hasOwn(resolution, "reason"))
+      throw new TypeError(
+        "Migration call resolution requires a reconciled outcome or confirmed non-performance."
+      );
+    pending.delete(resolution.callId);
+  }
+  if (pending.size > 0)
+    throw new TypeError(
+      `Migration requires external reconciliation for: ${[...pending.keys()].join(", ")}`
+    );
+}
+function validateSnapshotMigration(value, sourceHash) {
+  if (value === void 0) return void 0;
+  validateSnapshotData(value);
+  const migration = value;
+  if (migration === null || typeof migration !== "object" || migration.version !== 1 || !Array.isArray(migration.history) || migration.history.length === 0)
+    throw new TypeError("Invalid snapshot migration history.");
+  decodeReplayData(migration.state);
+  let previousTarget;
+  for (const entry of migration.history) {
+    if (entry === null || typeof entry !== "object" || typeof entry.sourceHash !== "string" || entry.sourceHash.length === 0 || typeof entry.targetSourceHash !== "string" || entry.targetSourceHash.length === 0 || previousTarget !== void 0 && previousTarget !== entry.sourceHash)
+      throw new TypeError("Invalid snapshot migration ancestry.");
+    validateMigrationSemantics(entry.executionSemantics);
+    const replay = validateMigrationJournal(entry.sourceHash, entry.replay);
+    validateMigrationReconciliation(
+      entry.reconciliation,
+      entry.reconciliation?.checkpointDigest,
+      replay.calls
+    );
+    previousTarget = entry.targetSourceHash;
+  }
+  if (previousTarget !== sourceHash)
+    throw new TypeError("Migration ancestry does not match the target source.");
+  return migration;
+}
+function isCheckpointDigest(value) {
+  return typeof value === "string" && value.length === 64 && [...value].every((character2) => "0123456789abcdef".includes(character2));
+}
+var init_migration = __esm({
+  "packages/safejs/src/snapshot/migration.ts"() {
+    "use strict";
+    init_host_call();
+    init_replay_data();
+    init_validation();
+  }
+});
+
 // packages/safejs/src/restore.ts
 function restore2(snapshot2, options) {
   assertSnapshotInactive(snapshot2);
   validateDumpEnvelope(snapshot2);
+  validateSnapshotMigration(snapshot2.migration, snapshot2.sourceHash);
   if (snapshot2.executionSemantics !== EXECUTION_SEMANTICS && (snapshot2.executionSemantics !== void 0 || snapshot2.promiseReplay !== void 0 || snapshot2.replay !== void 0 || snapshot2.initialInputs !== void 0)) {
     throw new SnapshotValidationError(
       "unsupportedVersion",
@@ -140627,6 +140716,7 @@ var init_restore = __esm({
     init_validation();
     init_dump_format();
     init_running_state();
+    init_migration();
     SnapshotMismatchError = class extends Error {
       actualHash;
       expectedHash;
@@ -141791,7 +141881,7 @@ function wrapHostPromiseWithSignal(promise, signal) {
     );
   });
 }
-function copyHostValueToSandbox(value, stackFrames, options, state, path190) {
+function copyHostValueToSandbox(value, stackFrames, options, state, path191) {
   const { budget } = options;
   if (value === null || value === void 0 || typeof value === "number" || typeof value === "boolean") {
     return value;
@@ -141817,11 +141907,11 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path190) {
       return existing;
     }
     return wrapCallerInjectedFunction(
-      callable.name.length > 0 ? callable.name : readPathName(path190),
+      callable.name.length > 0 ? callable.name : readPathName(path191),
       callable,
       {
         ...options,
-        operation: path190.startsWith("<root>") ? `${options.operation ?? "<root>"}${path190.slice(6)}` : path190
+        operation: path191.startsWith("<root>") ? `${options.operation ?? "<root>"}${path191.slice(6)}` : path191
       },
       state
     );
@@ -141873,14 +141963,14 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path190) {
       const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
       if (descriptor === void 0) continue;
       if (!("value" in descriptor)) {
-        throw new TypeError(`Unsupported sandbox value at ${path190}[${index}]: accessor property`);
+        throw new TypeError(`Unsupported sandbox value at ${path191}[${index}]: accessor property`);
       }
       copy[index] = copyHostValueToSandbox(
         descriptor.value,
         stackFrames,
         { ...options, capabilityPath: [...options.capabilityPath ?? [], String(index)] },
         state,
-        `${path190}[${index}]`
+        `${path191}[${index}]`
       );
     }
     return copy;
@@ -141901,14 +141991,14 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path190) {
           stackFrames,
           { ...options, capabilityPath: [...options.capabilityPath ?? [], `key:${ordinal}`] },
           state,
-          `${path190}.<key>`
+          `${path191}.<key>`
         ),
         copyHostValueToSandbox(
           entry,
           stackFrames,
           { ...options, capabilityPath: [...options.capabilityPath ?? [], `value:${ordinal}`] },
           state,
-          `${path190}.<value>`
+          `${path191}.<value>`
         )
       );
     }
@@ -141932,7 +142022,7 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path190) {
             capabilityPath: [...options.capabilityPath ?? [], String(copy.values.size)]
           },
           state,
-          `${path190}.<value>`
+          `${path191}.<value>`
         )
       );
     }
@@ -141951,7 +142041,7 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path190) {
       }
       if ("get" in descriptor || "set" in descriptor) {
         throw new TypeError(
-          `Unsupported sandbox value at ${joinPath2(path190, key3)}: accessor property`
+          `Unsupported sandbox value at ${joinPath2(path191, key3)}: accessor property`
         );
       }
       Object.defineProperty(copy, budget.allocateString(key3), {
@@ -141963,13 +142053,13 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path190) {
           stackFrames,
           { ...options, capabilityPath: [...options.capabilityPath ?? [], key3] },
           state,
-          joinPath2(path190, key3)
+          joinPath2(path191, key3)
         )
       });
     }
     return copy;
   }
-  throw new TypeError(`Unsupported sandbox value at ${path190}: ${describeValue2(value)}`);
+  throw new TypeError(`Unsupported sandbox value at ${path191}: ${describeValue2(value)}`);
 }
 function readAbortReason2(signal) {
   return signal.reason ?? createAbortError11();
@@ -142018,7 +142108,7 @@ function readStringProperty(value, key3) {
   const entry = value[key3];
   return typeof entry === "string" ? entry : void 0;
 }
-function copyFunctionProperties(callable, stackFrames, options, state, path190) {
+function copyFunctionProperties(callable, stackFrames, options, state, path191) {
   const properties = {};
   for (const key3 of Object.getOwnPropertyNames(callable)) {
     const descriptor = Object.getOwnPropertyDescriptor(callable, key3);
@@ -142036,7 +142126,7 @@ function copyFunctionProperties(callable, stackFrames, options, state, path190)
       stackFrames,
       { ...options, capabilityPath: [...options.capabilityPath ?? [], key3] },
       state,
-      joinPath2(path190, key3)
+      joinPath2(path191, key3)
     );
   }
   return Object.keys(properties).length > 0 ? properties : void 0;
@@ -142048,11 +142138,11 @@ function isPlainObject11(value) {
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
-function joinPath2(path190, key3) {
-  return /^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(key3) ? `${path190}.${key3}` : `${path190}[${JSON.stringify(key3)}]`;
+function joinPath2(path191, key3) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(key3) ? `${path191}.${key3}` : `${path191}[${JSON.stringify(key3)}]`;
 }
-function readPathName(path190) {
-  const segment = path190.replace(/^.*\./u, "");
+function readPathName(path191) {
+  const segment = path191.replace(/^.*\./u, "");
   return segment === "<root>" ? "host" : segment;
 }
 function describeValue2(value) {
@@ -144536,15 +144626,15 @@ var init_scope = __esm({
           throw new ReferenceError(`Cannot assign to undeclared binding '${name}'.`);
         }
         const binding = scope.#bindings.get(name);
-        if (binding?.kind === "const") {
-          throw new TypeError(`Cannot assign to const binding '${name}'.`);
-        }
         if (binding === void 0) {
           throw new ReferenceError(`Cannot assign to undeclared binding '${name}'.`);
         }
         if (binding.value === uninitialized) {
           throw new ReferenceError(`Cannot access '${name}' before initialization.`);
         }
+        if (binding.kind === "const") {
+          throw new TypeError(`Cannot assign to const binding '${name}'.`);
+        }
         scope.#bindings.set(name, {
           kind: binding.kind,
           value
@@ -145009,39 +145099,37 @@ async function evaluateAssignmentExpression(node, context) {
       )
     };
   }
-  const binding = context.scope.lookup(node.left.name);
-  if (!binding.found) {
+  const binding = node.operator === "=" ? void 0 : context.scope.lookup(node.left.name);
+  if (binding?.found === false) {
     throw new ReferenceError(`Cannot assign to undeclared binding '${node.left.name}'.`);
   }
-  if (binding.kind === "const") {
-    throw new TypeError(`Cannot assign to const '${node.left.name}'`);
-  }
-  if (node.operator === "&&=" && !isTruthy(binding.value)) {
+  const current = binding?.value;
+  if (node.operator === "&&=" && !isTruthy(current)) {
     return {
       kind: "normal",
       hasValue: true,
-      value: binding.value
+      value: current
     };
   }
-  if (node.operator === "||=" && isTruthy(binding.value)) {
+  if (node.operator === "||=" && isTruthy(current)) {
     return {
       kind: "normal",
       hasValue: true,
-      value: binding.value
+      value: current
     };
   }
-  if (node.operator === "??=" && binding.value !== null && binding.value !== void 0) {
+  if (node.operator === "??=" && current !== null && current !== void 0) {
     return {
       kind: "normal",
       hasValue: true,
-      value: binding.value
+      value: current
     };
   }
   const right = await evaluateNode2(node.right, context);
   if (right.kind !== "normal") {
     return right;
   }
-  const value = node.operator === "=" || node.operator === "&&=" || node.operator === "||=" || node.operator === "??=" ? right.value : applyCompoundAssignmentOperator(node.operator, binding.value, right.value, context);
+  const value = node.operator === "=" || node.operator === "&&=" || node.operator === "||=" || node.operator === "??=" ? right.value : await applyCompoundAssignmentOperator(node.operator, current, right.value, context);
   context.scope.assign(node.left.name, value);
   return {
     kind: "normal",
@@ -145063,45 +145151,33 @@ async function evaluateMemberAssignmentExpression(node, context) {
   if (member.kind === "nullish") {
     throw new TypeError("Cannot assign properties of null or undefined.");
   }
-  if (isSandboxRegex(member.object)) {
-    if (node.operator !== "=") {
-      throw new TypeError("RegExp properties only support direct assignment.");
-    }
-    const right2 = await evaluateNode2(node.right, context);
-    if (right2.kind !== "normal") return right2;
-    setRegexMember(member.object, member.property, right2.value);
-    return { kind: "normal", hasValue: true, value: right2.value };
-  }
-  if (!isIndexableSandboxValue(member.object)) {
-    throw new TypeError("Assignment expressions require a sandbox object property.");
-  }
-  if (node.operator === "&&=" && !isTruthy(getMemberValue(member.object, member.property, context))) {
+  const current = node.operator === "=" ? void 0 : getPropertyValue(member.object, member.property, context);
+  if (node.operator === "&&=" && !isTruthy(current)) {
     return {
       kind: "normal",
       hasValue: true,
-      value: getMemberValue(member.object, member.property, context)
+      value: current
     };
   }
-  if (node.operator === "||=" && isTruthy(getMemberValue(member.object, member.property, context))) {
+  if (node.operator === "||=" && isTruthy(current)) {
     return {
       kind: "normal",
       hasValue: true,
-      value: getMemberValue(member.object, member.property, context)
+      value: current
     };
   }
-  if (node.operator === "??=" && getMemberValue(member.object, member.property, context) !== null && getMemberValue(member.object, member.property, context) !== void 0) {
+  if (node.operator === "??=" && current !== null && current !== void 0) {
     return {
       kind: "normal",
       hasValue: true,
-      value: getMemberValue(member.object, member.property, context)
+      value: current
     };
   }
   const right = await evaluateNode2(node.right, context);
   if (right.kind !== "normal") {
     return right;
   }
-  const current = getMemberValue(member.object, member.property, context);
-  const value = node.operator === "=" || node.operator === "&&=" || node.operator === "||=" || node.operator === "??=" ? right.value : applyCompoundAssignmentOperator(node.operator, current, right.value, context);
+  const value = node.operator === "=" || node.operator === "&&=" || node.operator === "||=" || node.operator === "??=" ? right.value : await applyCompoundAssignmentOperator(node.operator, current, right.value, context);
   setSandboxProperty(member.object, member.property, value);
   return {
     kind: "normal",
@@ -146068,10 +146144,7 @@ async function evaluateIdentifierUpdateExpression(node, context) {
       )
     };
   }
-  if (binding.kind === "const") {
-    throw new TypeError(`Cannot assign to const '${node.argument.name}'`);
-  }
-  const current = Number(binding.value);
+  const current = toNumber(await toNumericPrimitive(binding.value, context));
   const next = node.operator === "++" ? current + 1 : current - 1;
   context.scope.assign(node.argument.name, next);
   return {
@@ -146094,10 +146167,9 @@ async function evaluateMemberUpdateExpression(node, context) {
   if (member.kind === "nullish") {
     throw new TypeError("Cannot update properties of null or undefined.");
   }
-  if (!isIndexableSandboxValue(member.object)) {
-    throw new TypeError("Update expressions require a sandbox object property.");
-  }
-  const current = Number(getMemberValue(member.object, member.property, context));
+  const current = toNumber(
+    await toNumericPrimitive(getPropertyValue(member.object, member.property, context), context)
+  );
   const next = node.operator === "++" ? current + 1 : current - 1;
   setSandboxProperty(member.object, member.property, next);
   return {
@@ -146108,93 +146180,32 @@ async function evaluateMemberUpdateExpression(node, context) {
 }
 async function evaluateMemberExpression(node, context) {
   const member = await evaluateMemberAccess(node, context);
-  if (member.kind === "error") {
-    return member;
-  }
-  if (member.kind === "completion") {
-    return member.result;
-  }
+  if (member.kind === "error") return member;
+  if (member.kind === "completion") return member.result;
   if (member.kind === "nullish") {
-    if (node.optional) {
-      return {
-        kind: "normal",
-        hasValue: true,
-        value: void 0
-      };
-    }
+    if (node.optional) return { kind: "normal", hasValue: true, value: void 0 };
     throw new TypeError("Cannot read properties of null or undefined.");
   }
-  if (typeof member.object === "string") {
-    return {
-      kind: "normal",
-      hasValue: true,
-      value: getStringMember(member.object, member.property, context.budget)
-    };
-  }
-  if (typeof member.object === "number") {
-    return {
-      kind: "normal",
-      hasValue: true,
-      value: getNumberMember(member.object, member.property, context.budget)
-    };
-  }
-  if (Array.isArray(member.object)) {
-    return {
-      kind: "normal",
-      hasValue: true,
-      value: getArrayMemberValue(member.object, member.property, context)
-    };
-  }
-  if (isSandboxMap(member.object)) {
-    return {
-      kind: "normal",
-      hasValue: true,
-      value: getMapMember(member.object, member.property, createMapMethodOptions(context))
-    };
-  }
-  if (isSandboxSet(member.object)) {
-    return {
-      kind: "normal",
-      hasValue: true,
-      value: getSetMember(member.object, member.property, createSetMethodOptions(context))
-    };
-  }
-  if (isSandboxGenerator(member.object)) {
-    return {
-      kind: "normal",
-      hasValue: true,
-      value: getGeneratorMember(member.object, member.property, context.budget)
-    };
-  }
-  if (isSandboxClosure(member.object)) {
-    return {
-      kind: "normal",
-      hasValue: true,
-      value: getClosureMemberValue(member.object, member.property, context)
-    };
-  }
-  if (isSandboxPromise(member.object)) {
-    return {
-      kind: "normal",
-      hasValue: true,
-      value: getPromiseMember(member.property, context.budget)
-    };
-  }
-  if (isSandboxRegex(member.object)) {
-    return {
-      kind: "normal",
-      hasValue: true,
-      value: getRegexMember(member.object, member.property)
-    };
-  }
-  if (!isIndexableSandboxValue(member.object)) {
-    throw new TypeError("Attempted to read a property from a non-object value.");
-  }
   return {
     kind: "normal",
     hasValue: true,
-    value: getMemberValue(member.object, member.property, context)
-  };
+    value: getPropertyValue(member.object, member.property, context)
+  };
+}
+function getPropertyValue(target, property, context) {
+  if (typeof target === "string") return getStringMember(target, property, context.budget);
+  if (typeof target === "number") return getNumberMember(target, property, context.budget);
+  if (typeof target === "boolean") return void 0;
+  if (isSandboxMap(target)) return getMapMember(target, property, createMapMethodOptions(context));
+  if (isSandboxSet(target)) return getSetMember(target, property, createSetMethodOptions(context));
+  if (isSandboxGenerator(target)) return getGeneratorMember(target, property, context.budget);
+  if (isSandboxClosure(target)) return getClosureMemberValue(target, property, context);
+  if (isSandboxPromise(target)) return getPromiseMember(property, context.budget);
+  if (isSandboxRegex(target)) return getRegexMember(target, property);
+  if (!isIndexableSandboxValue(target)) {
+    throw new TypeError("Attempted to read a property from a non-object value.");
+  }
+  return getMemberValue(target, property, context);
 }
 async function evaluateCallExpression(node, context) {
   if (node.callee.type === "MemberExpression") {
@@ -146671,7 +146682,9 @@ function applyBinaryOperator(node, left, right, context) {
       throw createError("UNSUPPORTED_NODE", node, "Binary operator 'in' is not supported.");
   }
 }
-function applyCompoundAssignmentOperator(operator, left, right, context) {
+async function applyCompoundAssignmentOperator(operator, left, right, context) {
+  left = await toNumericPrimitive(left, context);
+  right = await toNumericPrimitive(right, context);
   switch (operator) {
     case "+=":
       return applyAdditionOperator(left, right, context);
@@ -146798,6 +146811,9 @@ async function toNumericPrimitive(value, context) {
   if (isIndexableSandboxValue(value)) {
     for (const methodName of ["valueOf", "toString"]) {
       const method = getMemberValue(value, methodName, context);
+      if (methodName === "toString" && method === void 0 && !Object.hasOwn(value, methodName)) {
+        return toString(value);
+      }
       if (!isSandboxClosure(method)) {
         continue;
       }
@@ -146813,6 +146829,7 @@ async function toNumericPrimitive(value, context) {
         return result;
       }
     }
+    throw new TypeError("Cannot convert object to primitive value.");
   }
   return toString(value);
 }
@@ -146867,17 +146884,30 @@ function getArrayMemberValue(target, property, context) {
   return getArrayMember(target, property, createArrayMethodOptions(context));
 }
 function setSandboxProperty(target, property, value) {
+  if (isSandboxRegex(target)) {
+    setRegexMember(target, property, value);
+    return;
+  }
+  if (!isIndexableSandboxValue(target)) {
+    throw new TypeError("Assignment expressions require a sandbox object property.");
+  }
+  const key3 = String(property);
   if (Array.isArray(target)) {
     assertCollectionMutable(target);
-    const key3 = String(property);
     if (key3 === "length" || isArrayIndexKey3(key3)) {
       target[key3] = value;
       return;
     }
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(target, key3);
+  if (descriptor !== void 0) {
+    if (descriptor.writable !== true) {
+      throw new TypeError(`Cannot assign to read only property '${key3}'.`);
+    }
+    Object.defineProperty(target, key3, { value });
+  } else {
     defineSandboxProperty(target, key3, value);
-    return;
   }
-  defineSandboxProperty(target, String(property), value);
 }
 function deleteSandboxProperty(target, property) {
   if (Array.isArray(target)) {
@@ -147568,16 +147598,16 @@ async function writeSnapshotOnce(temporaryPath, snapshotPath, contents) {
     }
   }
 }
-async function enqueueOperation(path190, operation) {
-  const previous = pendingOperations.get(path190) ?? Promise.resolve();
+async function enqueueOperation(path191, operation) {
+  const previous = pendingOperations.get(path191) ?? Promise.resolve();
   const pending = previous.catch(() => void 0).then(operation);
   const queued = pending.catch(() => void 0);
-  pendingOperations.set(path190, queued);
+  pendingOperations.set(path191, queued);
   try {
     await pending;
   } finally {
-    if (pendingOperations.get(path190) === queued) {
-      pendingOperations.delete(path190);
+    if (pendingOperations.get(path191) === queued) {
+      pendingOperations.delete(path191);
     }
   }
 }
@@ -147614,8 +147644,8 @@ var init_backend = __esm({
     LOCKED_FILE_ERROR_CODES = /* @__PURE__ */ new Set(["EACCES", "EBUSY", "EPERM"]);
     pendingOperations = /* @__PURE__ */ new Map();
     FileSnapshotBackend = class {
-      constructor(path190, options = {}) {
-        this.path = path190;
+      constructor(path191, options = {}) {
+        this.path = path191;
         this.#writeMaxAttempts = options.writeMaxAttempts ?? DEFAULT_WRITE_MAX_ATTEMPTS;
         this.#writeRetryDelayMs = options.writeRetryDelayMs ?? DEFAULT_WRITE_RETRY_DELAY_MS;
       }
@@ -147763,12 +147793,12 @@ var init_serialize = __esm({
     init_values();
     UnsnapshotableValueError = class extends Error {
       path;
-      constructor(path190) {
+      constructor(path191) {
         super(
           "Cannot snapshot a generator suspended mid-iteration; drain or discard it before the await boundary."
         );
         this.name = "UnsnapshotableValueError";
-        this.path = path190;
+        this.path = path191;
       }
     };
   }
@@ -147782,15 +147812,15 @@ function prepareReplayInputs(current, saved, preparePromise, onCapabilityRestore
   if (saved === void 0) {
     const snapshot2 = encodeReplayData(current, {
       captureCapabilityProperties: true,
-      identifyCapability: (closure, path190) => {
-        const id = identities.get(closure) ?? JSON.stringify(path190);
+      identifyCapability: (closure, path191) => {
+        const id = identities.get(closure) ?? JSON.stringify(path191);
         identities.set(closure, id);
         capabilities.set(id, closure);
         return id;
       },
-      identifyPromise: (promise, path190) => {
+      identifyPromise: (promise, path191) => {
         if (preparePromise === void 0) return void 0;
-        const id = identities.get(promise) ?? JSON.stringify(path190);
+        const id = identities.get(promise) ?? JSON.stringify(path191);
         identities.set(promise, id);
         if (!promises.has(id)) promises.set(id, preparePromise(promise, id));
         return id;
@@ -147805,11 +147835,11 @@ function prepareReplayInputs(current, saved, preparePromise, onCapabilityRestore
     };
   }
   const readCapability = (id) => {
-    const path190 = JSON.parse(id);
-    if (!Array.isArray(path190) || path190.length === 0 || path190.some((key3) => typeof key3 !== "string"))
+    const path191 = JSON.parse(id);
+    if (!Array.isArray(path191) || path191.length === 0 || path191.some((key3) => typeof key3 !== "string"))
       throw new TypeError("Invalid replay input capability path.");
     let value = current;
-    for (const key3 of path190) {
+    for (const key3 of path191) {
       if (isSandboxMap(value)) {
         const [kind, ordinal] = key3.split(":");
         const index = Number(ordinal);
@@ -147960,6 +147990,17 @@ function run(source, options = {}) {
           }),
           ...createRegexGlobals()
         };
+        const importMeta = deepCopyToSandbox(options.importMeta ?? {});
+        if (restoredSnapshot?.migration !== void 0) {
+          if (Object.hasOwn(importMeta, "migration"))
+            throw new TypeError("import.meta.migration is reserved for migrated checkpoint state.");
+          Object.defineProperty(importMeta, "migration", {
+            value: decodeReplayData(restoredSnapshot.migration.state),
+            enumerable: true,
+            configurable: true,
+            writable: true
+          });
+        }
         const initialInputs = prepareReplayInputs(
           {
             bindings: callerBindings,
@@ -147970,7 +148011,7 @@ function run(source, options = {}) {
               allowMissing: restoredSnapshot?.initialInputs !== void 0
             }),
             entryPointArgs: options.entryPointArgs === void 0 ? void 0 : deepCopyToSandbox([...options.entryPointArgs]),
-            importMeta: deepCopyToSandbox(options.importMeta ?? {})
+            importMeta
           },
           restoredSnapshot?.initialInputs,
           (promise, id) => {
@@ -148035,6 +148076,7 @@ function run(source, options = {}) {
         });
         snapshotScheduler = activeSnapshotScheduler;
         createFailureSnapshot = () => createRunSnapshot({
+          migration: restoredSnapshot?.migration,
           bindings: executionScope.snapshot().bindings,
           clock: options.clock,
           hostCalls: hostCalls.snapshot(),
@@ -148060,6 +148102,7 @@ function run(source, options = {}) {
               }
               const interpreterSnapshot2 = yieldPoint.snapshot();
               snapshot3 = createRunSnapshot({
+                migration: restoredSnapshot?.migration,
                 bindings: interpreterSnapshot2.bindings,
                 clock: options.clock,
                 hostCalls: hostCalls.snapshot(),
@@ -148101,6 +148144,7 @@ function run(source, options = {}) {
               }
               const interpreterSnapshot2 = yieldPoint.snapshot();
               snapshot3 = createRunSnapshot({
+                migration: restoredSnapshot?.migration,
                 bindings: interpreterSnapshot2.bindings,
                 clock: options.clock,
                 hostCalls: hostCalls.snapshot(),
@@ -148134,6 +148178,7 @@ function run(source, options = {}) {
           replayError = error3.message;
         }
         const snapshot2 = createRunSnapshot({
+          migration: restoredSnapshot?.migration,
           bindings: executionScope.snapshot().bindings,
           clock: options.clock,
           hostCalls: hostCalls.snapshot(),
@@ -148303,6 +148348,7 @@ function createRunSnapshot(input) {
     version: DUMP_FORMAT_VERSION,
     executionSemantics: EXECUTION_SEMANTICS,
     sourceHash: input.sourceHash,
+    ...input.migration === void 0 ? {} : { migration: structuredClone(input.migration) },
     bindings: input.bindings,
     clock: input.clock?.snapshot(),
     ...input.hostCalls === void 0 || input.hostCalls.length === 0 ? {} : { hostCalls: input.hostCalls },
@@ -148423,6 +148469,173 @@ var init_dump2 = __esm({
   }
 });
 
+// packages/safejs/src/migrate.ts
+import { createHash as createHash14 } from "node:crypto";
+function inspectSnapshotMigration(snapshot2, options) {
+  assertSnapshotInactive(snapshot2);
+  validateSnapshotData(snapshot2);
+  validateDumpEnvelope(snapshot2);
+  validateMigrationSemantics(snapshot2.executionSemantics);
+  const sourceHash = hashSource(options.source);
+  if (snapshot2.sourceHash !== sourceHash)
+    throw new TypeError(
+      `Migration requires the original executable source (checkpoint hash ${snapshot2.sourceHash}, supplied ${sourceHash}). Preserve the checkpoint; do not replace its hash.`
+    );
+  validateSnapshotMigration(snapshot2.migration, sourceHash);
+  const replay = validateMigrationJournal(sourceHash, snapshot2.replay, snapshot2.hostCalls);
+  return {
+    checkpointDigest: createHash14("sha256").update(canonicalData(snapshot2)).digest("hex"),
+    sourceHash,
+    executionSemantics: snapshot2.executionSemantics,
+    calls: replay.calls,
+    unresolvedCalls: replay.calls.filter(
+      (call) => !["settled", "consumed"].includes(call.lifecycle)
+    )
+  };
+}
+function migrateSnapshot(snapshot2, options) {
+  if (!Object.hasOwn(options, "state"))
+    throw new TypeError("Migration requires explicit application state.");
+  const inspection = inspectSnapshotMigration(snapshot2, { source: options.source });
+  parseModule(options.targetSource);
+  const targetSourceHash = hashSource(options.targetSource);
+  validateMigrationReconciliation(
+    options.reconciliation,
+    inspection.checkpointDigest,
+    inspection.calls
+  );
+  const state = encodeReplayData(deepCopyToSandbox(options.state));
+  const previous = snapshot2.migration;
+  const migration = {
+    version: 1,
+    state,
+    history: [
+      ...structuredClone(previous?.history ?? []),
+      {
+        sourceHash: inspection.sourceHash,
+        targetSourceHash,
+        executionSemantics: inspection.executionSemantics,
+        replay: { version: 1, calls: inspection.calls },
+        reconciliation: structuredClone(options.reconciliation)
+      }
+    ]
+  };
+  validateSnapshotMigration(migration, targetSourceHash);
+  return {
+    version: DUMP_FORMAT_VERSION,
+    executionSemantics: EXECUTION_SEMANTICS,
+    sourceHash: targetSourceHash,
+    bindings: {},
+    replay: { version: 1, calls: [] },
+    migration
+  };
+}
+function canonicalData(value) {
+  if (Array.isArray(value)) return `[${value.map(canonicalData).join(",")}]`;
+  if (value !== null && typeof value === "object")
+    return `{${Object.keys(value).sort().map(
+      (key3) => `${JSON.stringify(key3)}:${canonicalData(value[key3])}`
+    ).join(",")}}`;
+  return JSON.stringify(value);
+}
+var init_migrate = __esm({
+  "packages/safejs/src/migrate.ts"() {
+    "use strict";
+    init_running_state();
+    init_values();
+    init_hash();
+    init_parser3();
+    init_dump_format();
+    init_migration();
+    init_replay_data();
+    init_validation();
+  }
+});
+
+// packages/safejs/src/migration-file.ts
+import { randomUUID as randomUUID51 } from "node:crypto";
+import { link as link3, open as open8, readFile as readFile53, unlink as unlink25 } from "node:fs/promises";
+import path184 from "node:path";
+async function migrateSnapshotFile(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const resolvePath3 = (value, label) => {
+    if (typeof value !== "string" || value.trim().length === 0)
+      throw new TypeError(`Migration requires ${label}.`);
+    return path184.resolve(cwd, value);
+  };
+  const snapshotPath = resolvePath3(options.snapshotPath, "a snapshot path");
+  const sourcePath = resolvePath3(options.sourcePath, "--from <original.ajs>");
+  if (options.inspect && [options.targetSourcePath, options.planPath, options.outputPath].some(
+    (value) => value !== void 0
+  ))
+    throw new TypeError("Migration --inspect cannot be combined with --to, --plan, or --output.");
+  const outputPath = options.inspect ? void 0 : resolvePath3(options.outputPath, "--output <new-checkpoint.json>");
+  const targetSourcePath = options.inspect ? void 0 : resolvePath3(options.targetSourcePath, "--to <continuation.ajs>");
+  const planPath = options.inspect ? void 0 : resolvePath3(options.planPath, "--plan <migration.json>");
+  for (const filepath of [sourcePath, targetSourcePath]) {
+    if (filepath !== void 0 && ![".ajs", ".safejs"].includes(path184.extname(filepath)))
+      throw new TypeError(
+        "Migration source paths must name executable .ajs or .safejs files, not harness Markdown."
+      );
+  }
+  const snapshot2 = JSON.parse(await readFile53(snapshotPath, "utf8"));
+  const source = await readFile53(sourcePath, "utf8");
+  const inspection = inspectSnapshotMigration(snapshot2, { source });
+  if (options.inspect) return { inspection };
+  const plan = JSON.parse(await readFile53(planPath, "utf8"));
+  if (plan === null || typeof plan !== "object" || !Object.hasOwn(plan, "state") || !Object.hasOwn(plan, "reconciliation"))
+    throw new TypeError("Migration plan requires explicit state and reconciliation fields.");
+  const targetSource = await readFile53(targetSourcePath, "utf8");
+  const migrated = migrateSnapshot(snapshot2, {
+    source,
+    targetSource,
+    state: plan.state,
+    reconciliation: plan.reconciliation
+  });
+  const contents = serializeSafeJSSnapshot(migrated);
+  if (!options.dryRun) {
+    const temporaryPath = path184.join(
+      path184.dirname(outputPath),
+      `.safejs-migration-${randomUUID51()}.tmp`
+    );
+    let created = false;
+    try {
+      const handle = await open8(temporaryPath, "wx", 384);
+      created = true;
+      try {
+        await handle.writeFile(contents, "utf8");
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+      try {
+        await link3(temporaryPath, outputPath);
+      } catch (error3) {
+        if (hasOwnErrorCode29(error3, "EEXIST"))
+          throw Object.assign(
+            new Error(
+              `Migration output already exists: ${JSON.stringify(outputPath)}. Choose a new output path; existing files are never overwritten.`,
+              { cause: error3 }
+            ),
+            { code: "EEXIST" }
+          );
+        throw error3;
+      }
+    } finally {
+      if (created) await unlink25(temporaryPath);
+    }
+  }
+  return { inspection, outputPath, dryRun: options.dryRun === true };
+}
+var init_migration_file = __esm({
+  "packages/safejs/src/migration-file.ts"() {
+    "use strict";
+    init_error_codes22();
+    init_migrate();
+    init_dump_format();
+  }
+});
+
 // packages/safejs/src/error/format.ts
 var init_format3 = __esm({
   "packages/safejs/src/error/format.ts"() {
@@ -148512,7 +148725,7 @@ var init_runtime_modules = __esm({
 });
 
 // packages/safejs/src/runner/run-harness.ts
-import { readFile as readFile53, stat as stat34 } from "node:fs/promises";
+import { readFile as readFile54, stat as stat34 } from "node:fs/promises";
 import { extname } from "node:path";
 var init_run_harness = __esm({
   "packages/safejs/src/runner/run-harness.ts"() {
@@ -149606,9 +149819,9 @@ var init_fail = __esm({
 
 // packages/safejs/src/modules/canonical-path.ts
 import { basename as basename8, dirname as dirname13, isAbsolute as isAbsolute9, relative as relative7, resolve as resolve13, sep as sep6 } from "node:path";
-async function resolveCanonicalPath({ realpath: realpath20, readlink: readlink5 }, path190) {
+async function resolveCanonicalPath({ realpath: realpath20, readlink: readlink5 }, path191) {
   const missingSegments = [];
-  let current = path190;
+  let current = path191;
   let follows = 0;
   while (true) {
     try {
@@ -149621,23 +149834,23 @@ async function resolveCanonicalPath({ realpath: realpath20, readlink: readlink5
       const target = await readSymlinkTarget2(readlink5, current);
       if (target !== void 0) {
         if (++follows > MAX_SYMLINK_FOLLOWS) {
-          throw createLoopError(path190);
+          throw createLoopError(path191);
         }
         current = isAbsolute9(target) ? resolve13(target) : resolve13(dirname13(current), target);
         continue;
       }
       const parent = dirname13(current);
       if (parent === current) {
-        return resolve13(path190);
+        return resolve13(path191);
       }
       missingSegments.push(basename8(current));
       current = parent;
     }
   }
 }
-async function readSymlinkTarget2(readlink5, path190) {
+async function readSymlinkTarget2(readlink5, path191) {
   try {
-    return await readlink5(path190);
+    return await readlink5(path191);
   } catch (error3) {
     if (NOT_A_SYMLINK_CODES.includes(getOwnErrorCode2(error3) ?? "")) {
       return void 0;
@@ -149645,9 +149858,9 @@ async function readSymlinkTarget2(readlink5, path190) {
     throw error3;
   }
 }
-function createLoopError(path190) {
+function createLoopError(path191) {
   const error3 = new Error(
-    `ELOOP: too many symbolic links encountered, realpath '${path190}'`
+    `ELOOP: too many symbolic links encountered, realpath '${path191}'`
   );
   error3.code = "ELOOP";
   return error3;
@@ -149690,9 +149903,9 @@ async function descendsFromRoot(stat36, canonicalRoot, canonicalPath) {
     current = parent;
   }
 }
-async function readIdentity(stat36, path190) {
+async function readIdentity(stat36, path191) {
   try {
-    const { dev, ino } = await stat36(path190);
+    const { dev, ino } = await stat36(path191);
     return { dev, ino };
   } catch (error3) {
     if (MISSING_PATH_CODES.includes(getOwnErrorCode2(error3) ?? "")) {
@@ -149840,32 +150053,32 @@ async function resolvePathArguments(fs31, root, name, args) {
     return resolved;
   }
   const paths = FS_PATH_ARGUMENTS[name].map((_, index) => {
-    const path190 = readPath(canonicalRoot, args[index]);
-    resolved[index] = path190;
-    return path190;
+    const path191 = readPath(canonicalRoot, args[index]);
+    resolved[index] = path191;
+    return path191;
   });
   await assertInsideRoot2(fs31, canonicalRoot, name, paths);
   return resolved;
 }
 async function assertInsideRoot2(fs31, canonicalRoot, name, paths) {
-  for (const path190 of paths) {
-    if (await escapesRoot(fs31, canonicalRoot, path190)) {
+  for (const path191 of paths) {
+    if (await escapesRoot(fs31, canonicalRoot, path191)) {
       throw createAccessDeniedError(name, paths[0], paths[1]);
     }
   }
 }
-async function escapesRoot(fs31, canonicalRoot, path190) {
-  const canonicalPath = await resolveCanonicalPath(readCanonicalPathFs(fs31), path190);
+async function escapesRoot(fs31, canonicalRoot, path191) {
+  const canonicalPath = await resolveCanonicalPath(readCanonicalPathFs(fs31), path191);
   return !await containsPath(readStat(fs31), canonicalRoot, canonicalPath);
 }
 function readCanonicalPathFs(fs31) {
   return {
-    realpath: async (path190) => await invoke(fs31, "realpath", [path190]),
-    readlink: async (path190) => await invoke(fs31, "readlink", [path190])
+    realpath: async (path191) => await invoke(fs31, "realpath", [path191]),
+    readlink: async (path191) => await invoke(fs31, "readlink", [path191])
   };
 }
 function readStat(fs31) {
-  return async (path190) => await invoke(fs31, "stat", [path190]);
+  return async (path191) => await invoke(fs31, "stat", [path191]);
 }
 function assertSupportedPath(name, argument, value) {
   if (typeof value === "string") {
@@ -149916,19 +150129,19 @@ function describeReceivedValue(value) {
   return `type ${typeof value} (${inspect(value)})`;
 }
 function readPath(base, value) {
-  const path190 = value;
-  return isAbsolute10(path190) ? resolve14(path190) : resolve14(base, path190);
+  const path191 = value;
+  return isAbsolute10(path191) ? resolve14(path191) : resolve14(base, path191);
 }
-function createAccessDeniedError(name, path190, dest) {
+function createAccessDeniedError(name, path191, dest) {
   const syscall = FS_SYSCALLS[name];
-  const target = dest === void 0 ? `'${path190}'` : `'${path190}' -> '${dest}'`;
+  const target = dest === void 0 ? `'${path191}'` : `'${path191}' -> '${dest}'`;
   const error3 = new Error(
     `${ACCESS_DENIED_CODE}: ${ACCESS_DENIED_MESSAGE}, ${syscall} ${target}`
   );
   error3.code = ACCESS_DENIED_CODE;
   error3.errno = ACCESS_DENIED_ERRNO;
   error3.syscall = syscall;
-  error3.path = path190;
+  error3.path = path191;
   if (dest !== void 0) {
     error3.dest = dest;
   }
@@ -150286,9 +150499,9 @@ function makeGitModule(cwd) {
         branch: normalizedBranch
       };
     },
-    async worktreeRemove(path190) {
+    async worktreeRemove(path191) {
       const repoRoot = await getRepoRoot(normalizedCwd);
-      const worktreePath = await resolveWorktreePath(repoRoot, path190, "Git worktree path");
+      const worktreePath = await resolveWorktreePath(repoRoot, path191, "Git worktree path");
       const worktrees = await listWorktrees2(normalizedCwd);
       if (!worktrees.some((worktree) => resolve15(worktree.path) === worktreePath)) {
         return;
@@ -150335,10 +150548,10 @@ function normalizeWorktreeCreateOptions(options) {
     throw new Error("Git worktree create options must be an object.");
   }
   const base = getOwnProperty8(options, "base");
-  const path190 = getOwnProperty8(options, "path");
+  const path191 = getOwnProperty8(options, "path");
   return {
     base: base === void 0 ? "HEAD" : readNonEmptyString6(base, "Git worktree create options base"),
-    path: path190 === void 0 ? void 0 : readNonEmptyString6(path190, "Git worktree create options path")
+    path: path191 === void 0 ? void 0 : readNonEmptyString6(path191, "Git worktree create options path")
   };
 }
 function createSavepointRef() {
@@ -150398,9 +150611,9 @@ function parseBranchRef(ref) {
   const branchPrefix = "refs/heads/";
   return ref.startsWith(branchPrefix) ? ref.slice(branchPrefix.length) : ref;
 }
-async function resolveWorktreePath(repoRoot, path190, label) {
+async function resolveWorktreePath(repoRoot, path191, label) {
   const resolvedRoot = resolve15(repoRoot);
-  const resolvedPath = isAbsolute11(path190) ? resolve15(path190) : resolve15(resolvedRoot, path190);
+  const resolvedPath = isAbsolute11(path191) ? resolve15(path191) : resolve15(resolvedRoot, path191);
   const canonicalRoot = await realpath19(resolvedRoot);
   const canonicalPath = await resolveCanonicalPath({ realpath: realpath19, readlink: readlink4 }, resolvedPath);
   const [inside, isRootItself] = await Promise.all([
@@ -150768,7 +150981,7 @@ var init_metric = __esm({
 
 // packages/safejs/src/modules/mcp-transport.ts
 import { spawn as spawn11 } from "node:child_process";
-import path184 from "node:path";
+import path185 from "node:path";
 function parseMcpConfig3(source, directory) {
   const parsed = JSON.parse(source);
   const options = normalizeMcpOptions(parsed, [
@@ -150779,9 +150992,9 @@ function parseMcpConfig3(source, directory) {
   ]);
   for (const server of Object.values(options.servers)) {
     if ("command" in server) {
-      server.cwd = path184.resolve(directory, server.cwd ?? ".");
+      server.cwd = path185.resolve(directory, server.cwd ?? ".");
       if (server.command.includes("/") || server.command.includes("\\")) {
-        server.command = path184.resolve(directory, server.command);
+        server.command = path185.resolve(directory, server.command);
       }
     }
   }
@@ -151506,6 +151719,8 @@ var init_src49 = __esm({
     init_policy();
     init_dump2();
     init_restore();
+    init_migrate();
+    init_migration_file();
     init_validation();
     init_budget2();
     init_format3();
@@ -151647,9 +151862,9 @@ var init_extract_schema = __esm({
 });
 
 // packages/agent-harness/src/codegen/emit-schemas.ts
-import { randomUUID as randomUUID51 } from "node:crypto";
+import { randomUUID as randomUUID52 } from "node:crypto";
 import * as nodeFs21 from "node:fs/promises";
-import path185 from "node:path";
+import path186 from "node:path";
 import { fileURLToPath as fileURLToPath14 } from "node:url";
 var init_emit_schemas = __esm({
   "packages/agent-harness/src/codegen/emit-schemas.ts"() {
@@ -151707,23 +151922,23 @@ var init_pair = __esm({
     MissingPairError = class extends UserError {
       side;
       path;
-      constructor(side, path190) {
+      constructor(side, path191) {
         super(
-          `Missing harness ${side} file: ${path190}
+          `Missing harness ${side} file: ${path191}
 Run \`poe-code harness list\` to see available harnesses, or \`poe-code harness new <name>\` to scaffold this pair.`
         );
         this.side = side;
-        this.path = path190;
+        this.path = path191;
       }
     };
     InvalidPairExtensionError = class extends Error {
       extension;
       path;
-      constructor(path190, extension) {
-        super(`Harness pair input must be a .md or .ajs file: ${path190}`);
+      constructor(path191, extension) {
+        super(`Harness pair input must be a .md or .ajs file: ${path191}`);
         this.name = "InvalidPairExtensionError";
         this.extension = extension;
-        this.path = path190;
+        this.path = path191;
       }
     };
   }
@@ -151790,8 +152005,8 @@ function validateFrontmatter(schema, frontmatter, mdPath) {
 function formatIssues3(mdPath, issues) {
   return issues.map((issue2) => `${mdPath} (${formatPath4(issue2.path)}): ${issue2.message}`).join("\n");
 }
-function formatPath4(path190) {
-  return path190.join(".") || "frontmatter";
+function formatPath4(path191) {
+  return path191.join(".") || "frontmatter";
 }
 var FrontmatterValidationError;
 var init_validate4 = __esm({
@@ -151810,8 +152025,8 @@ var init_validate4 = __esm({
 });
 
 // packages/agent-harness/src/loader/run.ts
-import { createHash as createHash14, randomUUID as randomUUID52 } from "node:crypto";
-import { lstat as lstat34, mkdir as mkdir39, readFile as readFile55, rename as rename28, unlink as unlink25, writeFile as writeFile29 } from "node:fs/promises";
+import { createHash as createHash15, randomUUID as randomUUID53 } from "node:crypto";
+import { lstat as lstat34, mkdir as mkdir39, readFile as readFile56, rename as rename28, unlink as unlink26, writeFile as writeFile29 } from "node:fs/promises";
 import os25 from "node:os";
 import { dirname as dirname17, join as join17, parse as parse16, resolve as resolve16, sep as sep7 } from "node:path";
 async function runHarnessPair2(mdPath, options) {
@@ -151932,7 +152147,9 @@ async function runHarnessPair2(mdPath, options) {
       throw error3;
     }
     await hostCallReplay.flush();
-    if (result.ok && options.preserveSnapshotOnSuccess !== true) {
+    if (result.ok && result.snapshot.migration !== void 0) {
+      await snapshotBackend.write(result.snapshot);
+    } else if (result.ok && options.preserveSnapshotOnSuccess !== true) {
       await cleanupCompletedSnapshot(snapshotBackend, snapshotPath);
     }
     const usage = usageAccumulator.snapshot();
@@ -152141,7 +152358,7 @@ async function createHostCallReplay(snapshotPath, statefulBindings = {}, opts =
 }
 async function readHostCallRecords(storePath) {
   try {
-    const parsed = JSON.parse(await readFile55(storePath, "utf8"));
+    const parsed = JSON.parse(await readFile56(storePath, "utf8"));
     return Array.isArray(parsed) ? parsed : [];
   } catch (error3) {
     if (hasErrorCode6(error3, "ENOENT")) {
@@ -152161,7 +152378,7 @@ async function writeHostCallRecords(storePath, records) {
   await writeTextFileAtomically2(storePath, serialized);
 }
 async function writeTextFileAtomically2(filePath, content) {
-  const temporaryPath = `${filePath}.${process.pid}.${randomUUID52()}.tmp`;
+  const temporaryPath = `${filePath}.${process.pid}.${randomUUID53()}.tmp`;
   let temporaryCreated = false;
   try {
     await writeFile29(temporaryPath, content, { encoding: "utf8", flag: "wx" });
@@ -152177,9 +152394,9 @@ async function writeTextFileAtomically2(filePath, content) {
 async function cleanupCompletedSnapshot(snapshotBackend, snapshotPath) {
   await Promise.all([snapshotBackend.remove(), unlinkIfExists(hostCallStorePath(snapshotPath))]);
 }
-async function unlinkIfExists(path190) {
+async function unlinkIfExists(path191) {
   try {
-    await unlink25(path190);
+    await unlink26(path191);
   } catch (error3) {
     if (!hasErrorCode6(error3, "ENOENT")) {
       throw error3;
@@ -152215,7 +152432,7 @@ function listModuleExports(moduleExports) {
   return exportNames.filter((exportName) => exportName.length > 0).sort((left, right) => left.localeCompare(right));
 }
 function resolveSnapshotPath(mdPath, snapshotPath) {
-  const documentKey = createHash14("sha256").update(resolve16(mdPath)).digest("hex").slice(0, 12);
+  const documentKey = createHash15("sha256").update(resolve16(mdPath)).digest("hex").slice(0, 12);
   return snapshotPath ?? join17(
     resolveRunLogDir({
       planPath: mdPath,
@@ -152243,8 +152460,8 @@ async function assertDefaultSnapshotPathIsRegular(snapshotPath) {
     }
   }
 }
-async function readTextFile(path190) {
-  const source = await readFile55(path190, "utf8");
+async function readTextFile(path191) {
+  const source = await readFile56(path191, "utf8");
   return source.startsWith("\uFEFF") ? source.slice(1) : source;
 }
 function formatLintErrorMessage(diagnostics) {
@@ -152302,7 +152519,7 @@ var init_run8 = __esm({
 });
 
 // packages/agent-harness/src/testing/replay-equivalence.ts
-import { mkdir as mkdir40, readFile as readFile56, rm as rm17, writeFile as writeFile30 } from "node:fs/promises";
+import { mkdir as mkdir40, readFile as readFile57, rm as rm17, writeFile as writeFile30 } from "node:fs/promises";
 import os26 from "node:os";
 import { join as join18 } from "node:path";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
@@ -152399,8 +152616,8 @@ var init_harness_spawn_retry = __esm({
 });
 
 // src/cli/commands/harness.ts
-import path186 from "node:path";
-import { readFile as readFile57 } from "node:fs/promises";
+import path187 from "node:path";
+import { readFile as readFile58 } from "node:fs/promises";
 import { Argument } from "commander";
 function registerHarnessCommand(program, container) {
   const harness = program.command("harness").description("Run and manage agent harness pairs.");
@@ -152426,6 +152643,26 @@ function registerHarnessCommand(program, container) {
       await executeHarnessRun(program, container, mdPath, options);
     }
   });
+  harness.command("migrate").description("Inspect or explicitly migrate a checkpoint to continuation source.").argument("<snapshot-path>", "Original checkpoint JSON; never overwritten").requiredOption("--from <path>", "Original executable .ajs source").option("--inspect", "Inspect identities and unresolved calls without writing").option("--to <path>", "New continuation .ajs source").option("--plan <path>", "JSON application state and digest-bound reconciliation").option("--output <path>", "New checkpoint path; must not already exist").action(
+    async (snapshotPath, options) => {
+      const flags = resolveHarnessFlags(program, void 0);
+      const result = await withSpinner({
+        message: options.inspect ? "Inspecting checkpoint" : "Validating checkpoint migration",
+        fn: () => migrateSnapshotFile({
+          snapshotPath,
+          sourcePath: options.from,
+          targetSourcePath: options.to,
+          planPath: options.plan,
+          outputPath: options.output,
+          inspect: options.inspect,
+          dryRun: flags.dryRun,
+          cwd: container.env.cwd
+        })
+      });
+      process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+    }
+  );
   harness.command("new").description("Scaffold a harness pair from a built-in template.").addArgument(new Argument("<kind>", "Built-in template kind").choices(builtinKinds())).argument("<basename>", "New harness basename").option("--dir <path>", "Output directory for the harness pair").option("-y, --yes", "Accept defaults without prompting.").action(async (kind, basename10, options) => {
     await executeHarnessNew(program, container, kind, basename10, options);
   });
@@ -152441,20 +152678,20 @@ async function executeHarnessRun(program, container, mdPath, options) {
   if (options.envConfig !== void 0) {
     if (options.envConfig.trim().length === 0)
       throw new ValidationError("--env-config needs a JSON file path.");
-    const configPath = path186.resolve(container.env.cwd, options.envConfig);
+    const configPath = path187.resolve(container.env.cwd, options.envConfig);
     envOptions = parseEnvConfig(await container.fs.readFile(configPath, "utf8"));
   }
   let mcpOptions;
   if (options.mcpConfig !== void 0) {
     if (options.mcpConfig.trim().length === 0)
       throw new ValidationError("--mcp-config needs a JSON file path.");
-    const configPath = path186.resolve(container.env.cwd, options.mcpConfig);
+    const configPath = path187.resolve(container.env.cwd, options.mcpConfig);
     mcpOptions = parseMcpConfig3(
       await container.fs.readFile(configPath, "utf8"),
-      path186.dirname(configPath)
+      path187.dirname(configPath)
     );
   }
-  const selectedPath = mdPath ? path186.resolve(container.env.cwd, mdPath) : (await resolveDiscoveredHarness(container, options.dir, flags.assumeYes)).mdPath;
+  const selectedPath = mdPath ? path187.resolve(container.env.cwd, mdPath) : (await resolveDiscoveredHarness(container, options.dir, flags.assumeYes)).mdPath;
   if (flags.dryRun) {
     await resolvePair(selectedPath, container.fs);
     resources.logger.dryRun(
@@ -152462,7 +152699,7 @@ async function executeHarnessRun(program, container, mdPath, options) {
     );
     if (fsOptions !== void 0) {
       resources.logger.dryRun(
-        `Dry run: would enable the fs module rooted at ${formatDisplayPath3(container, resolveFsRoot(fsOptions, path186.dirname(selectedPath)))}.`
+        `Dry run: would enable the fs module rooted at ${formatDisplayPath3(container, resolveFsRoot(fsOptions, path187.dirname(selectedPath)))}.`
       );
     }
     return;
@@ -152578,9 +152815,9 @@ async function resolveHarnessWorktreeAgent(container, selectedPath, options) {
   );
 }
 function mapSourcePathIntoWorktree3(sourceCwd, sourcePath, worktreeCwd) {
-  const relativePath = path186.relative(sourceCwd, sourcePath);
-  if (relativePath === "" || !relativePath.startsWith("..") && !path186.isAbsolute(relativePath)) {
-    return path186.join(worktreeCwd, relativePath);
+  const relativePath = path187.relative(sourceCwd, sourcePath);
+  if (relativePath === "" || !relativePath.startsWith("..") && !path187.isAbsolute(relativePath)) {
+    return path187.join(worktreeCwd, relativePath);
   }
   return sourcePath;
 }
@@ -152731,10 +152968,10 @@ function buildAgentFrontmatterOverrides(options) {
 }
 function resolveRunSnapshotPath(container, mdPath, snapshotPath) {
   if (snapshotPath !== void 0) {
-    return path186.resolve(container.env.cwd, snapshotPath);
+    return path187.resolve(container.env.cwd, snapshotPath);
   }
-  const basename10 = path186.basename(mdPath, path186.extname(mdPath));
-  return path186.join(container.env.cwd, ".poe-code", "harnesses", basename10, "snapshot.json");
+  const basename10 = path187.basename(mdPath, path187.extname(mdPath));
+  return path187.join(container.env.cwd, ".poe-code", "harnesses", basename10, "snapshot.json");
 }
 async function prepareHarnessSnapshot(container, mdPath, snapshotPath, resumeRequested) {
   const snapshotExists = await pathExists17(container, snapshotPath);
@@ -152803,8 +153040,8 @@ function formatRunMessage(baseMessage, progress) {
   return progress === void 0 ? baseMessage : `${baseMessage} (${progress})`;
 }
 function resolveAjsPath(mdPath) {
-  const parsed = path186.parse(mdPath);
-  return path186.join(parsed.dir, `${parsed.name}.ajs`);
+  const parsed = path187.parse(mdPath);
+  return path187.join(parsed.dir, `${parsed.name}.ajs`);
 }
 async function pathExists17(container, targetPath) {
   try {
@@ -152830,16 +153067,16 @@ async function executeHarnessNew(program, container, kind, basename10, options)
       `Unknown harness template "${kind}". Available kinds: ${builtinKinds().join(", ")}.`
     );
   }
-  if (basename10.length === 0 || basename10 === "." || basename10 === ".." || path186.basename(basename10) !== basename10) {
+  if (basename10.length === 0 || basename10 === "." || basename10 === ".." || path187.basename(basename10) !== basename10) {
     throw new ValidationError(
       `Invalid harness basename "${basename10}". Use a single directory name.`
     );
   }
-  const defaultDir = path186.join(".poe-code", "harnesses", basename10);
+  const defaultDir = path187.join(".poe-code", "harnesses", basename10);
   const outputDir = options.dir ?? await resolveOutputDir(defaultDir, flags.assumeYes);
-  const resolvedDir = path186.resolve(container.env.cwd, outputDir);
-  const mdPath = path186.join(resolvedDir, `${basename10}.md`);
-  const ajsPath = path186.join(resolvedDir, `${basename10}.ajs`);
+  const resolvedDir = path187.resolve(container.env.cwd, outputDir);
+  const mdPath = path187.join(resolvedDir, `${basename10}.md`);
+  const ajsPath = path187.join(resolvedDir, `${basename10}.ajs`);
   await assertFilesDoNotExist(container, [mdPath, ajsPath]);
   if (flags.dryRun) {
     resources.logger.dryRun(`Would create ${formatDisplayPath3(container, mdPath)}`);
@@ -152847,8 +153084,8 @@ async function executeHarnessNew(program, container, kind, basename10, options)
     return;
   }
   const [mdSource, ajsSource] = await Promise.all([
-    readFile57(template2.mdPath, "utf8"),
-    readFile57(template2.ajsPath, "utf8")
+    readFile58(template2.mdPath, "utf8"),
+    readFile58(template2.ajsPath, "utf8")
   ]);
   await container.fs.mkdir(resolvedDir, { recursive: true });
   const createdPaths = [];
@@ -152957,10 +153194,10 @@ async function resolveDiscoveredHarness(container, dir, assumeYes) {
 }
 function harnessDiscoveryRoots(container, dir) {
   const roots = [
-    path186.join(container.env.cwd, ".poe-code", "harnesses"),
-    path186.join(container.env.homeDir, ".poe-code", "harnesses")
+    path187.join(container.env.cwd, ".poe-code", "harnesses"),
+    path187.join(container.env.homeDir, ".poe-code", "harnesses")
   ];
-  return dir === void 0 ? roots : [path186.resolve(container.env.cwd, dir), ...roots];
+  return dir === void 0 ? roots : [path187.resolve(container.env.cwd, dir), ...roots];
 }
 function formatSearchedRoots(container, dir) {
   return harnessDiscoveryRoots(container, dir).map((root) => formatDisplayPath3(container, root)).join(", ");
@@ -152982,7 +153219,7 @@ async function discoverPairsDirectlyIn(container, root) {
   for (const entry of entries.filter((name) => name.endsWith(".md")).sort()) {
     try {
       pairs.push(
-        await resolvePair(path186.join(root, entry), container.fs)
+        await resolvePair(path187.join(root, entry), container.fs)
       );
     } catch (error3) {
       if (error3 instanceof MissingPairError) {
@@ -153004,7 +153241,7 @@ async function discoverProjectThenUserHarnesses(container, dir) {
       const stat36 = await container.fs.stat(pair.mdPath);
       discovered.push({
         ...pair,
-        dir: path186.dirname(pair.mdPath),
+        dir: path187.dirname(pair.mdPath),
         mdMtimeMs: stat36.mtimeMs
       });
     }
@@ -153060,7 +153297,7 @@ function resolveHarnessFsOptions(container, options) {
       "--fs-root needs a directory path. Pass --fs-root <path> to confine the harness to that directory, or drop --fs-root to confine it to the harness directory."
     );
   }
-  return { root: path186.resolve(container.env.cwd, options.fsRoot) };
+  return { root: path187.resolve(container.env.cwd, options.fsRoot) };
 }
 function resolveFsRoot(fsOptions, harnessDir) {
   return fsOptions.root ?? harnessDir;
@@ -153220,8 +153457,8 @@ function toModuleExports(moduleExports) {
   return new Map(Object.entries(moduleExports));
 }
 function formatDisplayPath3(container, filePath) {
-  const relative8 = path186.relative(container.env.cwd, filePath);
-  return relative8.length > 0 && !relative8.startsWith("..") && !path186.isAbsolute(relative8) ? relative8 : filePath.replace(container.env.homeDir, "~");
+  const relative8 = path187.relative(container.env.cwd, filePath);
+  return relative8.length > 0 && !relative8.startsWith("..") && !path187.isAbsolute(relative8) ? relative8 : filePath.replace(container.env.homeDir, "~");
 }
 var init_harness3 = __esm({
   async "src/cli/commands/harness.ts"() {
@@ -153528,7 +153765,7 @@ import { Argument as Argument2 } from "commander";
 function isVisible(command) {
   return Reflect.get(command, "_hidden") !== true;
 }
-function collectNodes(command, path190 = []) {
+function collectNodes(command, path191 = []) {
   const children2 = command.commands.filter(isVisible).map((child) => ({
     name: child.name(),
     aliases: [...child.aliases()],
@@ -153559,10 +153796,10 @@ function collectNodes(command, path190 = []) {
     return [];
   }
   return [
-    { path: path190, children: children2, options, requiredValueFlags, isPositionalLeaf, positionalChildren },
+    { path: path191, children: children2, options, requiredValueFlags, isPositionalLeaf, positionalChildren },
     ...command.commands.filter(isVisible).flatMap(
       (child) => [child.name(), ...child.aliases()].flatMap(
-        (name) => collectNodes(child, [...path190, name])
+        (name) => collectNodes(child, [...path191, name])
       )
     )
   ];
@@ -153694,8 +153931,8 @@ function renderZsh(nodes) {
 function quoteFish(value) {
   return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
 }
-function fishCondition(path190) {
-  return path190.length === 0 ? '"__fish_use_subcommand"' : `"__fish_seen_subcommand_from ${path190.at(-1)}"`;
+function fishCondition(path191) {
+  return path191.length === 0 ? '"__fish_use_subcommand"' : `"__fish_seen_subcommand_from ${path191.at(-1)}"`;
 }
 function renderFish(nodes) {
   const lines = nodes.flatMap((node) => {
@@ -153752,7 +153989,7 @@ var init_completion = __esm({
 
 // src/cli/commands/tasks-options.ts
 import * as fsPromises27 from "node:fs/promises";
-import path187 from "node:path";
+import path188 from "node:path";
 async function resolveWorkflowTaskListOptions(workflowPath) {
   const frontmatter = await readWorkflowFrontmatter(workflowPath);
   return readTaskListOptions(frontmatter, workflowPath);
@@ -153990,7 +154227,7 @@ function resolveStringValue2(value) {
   return process.env[value.slice(envPrefix.length)] ?? value;
 }
 function resolveWorkflowRelativePath(value, workflowPath) {
-  return path187.isAbsolute(value) ? value : path187.resolve(path187.dirname(workflowPath), value);
+  return path188.isAbsolute(value) ? value : path188.resolve(path188.dirname(workflowPath), value);
 }
 function asRecord6(value) {
   return isPlainRecord6(value) ? value : void 0;
@@ -154035,7 +154272,7 @@ var init_tasks_options = __esm({
 });
 
 // src/cli/commands/tasks.ts
-import path188 from "node:path";
+import path189 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", jsonOptionDescription).action(async (list2, options, command) => {
@@ -154185,7 +154422,7 @@ async function runImport(options, container) {
     const limit = options.limit === void 0 ? void 0 : parseNonNegativeInteger3(options.limit, "--limit");
     const source = {
       type: "markdown-dir",
-      path: path188.resolve(options.from),
+      path: path189.resolve(options.from),
       singleList: "import",
       frontmatterMode: "passthrough"
     };
@@ -154619,7 +154856,7 @@ var init_tasks2 = __esm({
 });
 
 // src/cli/commands/gaslight.ts
-import path189 from "node:path";
+import path190 from "node:path";
 import { Option as Option10 } from "commander";
 async function resolveGaslightCommandConfig(container) {
   const configDoc = await readMergedDocumentReadonly(
@@ -154638,9 +154875,9 @@ async function resolveGaslightCommandConfig(container) {
 }
 function resolveConfiguredPath(cwd, homeDir, value) {
   if (value.startsWith("~/")) {
-    return path189.join(homeDir, value.slice(2));
+    return path190.join(homeDir, value.slice(2));
   }
-  return path189.isAbsolute(value) ? value : path189.resolve(cwd, value);
+  return path190.isAbsolute(value) ? value : path190.resolve(cwd, value);
 }
 function formatPlanDirectoryDetails(container, planDirectory, absoluteDirectory) {
   return [
@@ -154755,7 +154992,7 @@ function formatCompletedPlans(result) {
   return [
     "Completed plans:",
     ...result.plans.map(
-      (plan) => `- ${path189.basename(plan.planPath)}${plan.durationMs === void 0 ? "" : ` \xB7 ${formatDuration3(plan.durationMs)}`}`
+      (plan) => `- ${path190.basename(plan.planPath)}${plan.durationMs === void 0 ? "" : ` \xB7 ${formatDuration3(plan.durationMs)}`}`
     )
   ].join("\n");
 }
@@ -154821,8 +155058,8 @@ async function resolveInstallScope(options, assumeYes) {
 }
 async function scaffoldConfig(container, scope, force, dryRun) {
   const root = scope === "global" ? container.env.homeDir : container.env.cwd;
-  const configPath = path189.join(root, ".poe-code", "gaslight.yaml");
-  const configDirectory = path189.dirname(configPath);
+  const configPath = path190.join(root, ".poe-code", "gaslight.yaml");
+  const configDirectory = path190.dirname(configPath);
   try {
     const stats2 = await container.fs.lstat(configDirectory);
     if (stats2.isSymbolicLink()) {
@@ -155217,7 +155454,7 @@ var init_package2 = __esm({
   "package.json"() {
     package_default2 = {
       name: "poe-code",
-      version: "10.0.3",
+      version: "11.0.0",
       description: "CLI tool to configure Poe API for developer workflows.",
       license: "MIT",
       type: "module",
@@ -155851,11 +156088,11 @@ function readCommandTreeOption(command, optionName) {
   }
   return void 0;
 }
-function assertPathIsNotOptionName(path190, command) {
-  const named = command.options.find((option) => option.long === `--${path190}`);
+function assertPathIsNotOptionName(path191, command) {
+  const named = command.options.find((option) => option.long === `--${path191}`);
   if (named !== void 0) {
     throw new ValidationError(
-      `\`${path190}\` is not a workflow path. Did you mean \`${named.long}\`?`
+      `\`${path191}\` is not a workflow path. Did you mean \`${named.long}\`?`
     );
   }
 }
@@ -155916,14 +156153,14 @@ 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 (path190, options, command) => {
-    assertPathIsNotOptionName(path190, command);
+  ).action(async (path191, options, command) => {
+    assertPathIsNotOptionName(path191, command);
     const mergedOptions = {
       ...options,
       ...command.optsWithGlobals()
     };
     await runMaestro({
-      workflowPath: mergedOptions.config ?? path190,
+      workflowPath: mergedOptions.config ?? path191,
       maxConcurrent: mergedOptions.maxConcurrent,
       pollIntervalMs: mergedOptions.pollIntervalMs,
       list: mergedOptions.list,
@@ -156084,7 +156321,7 @@ function createProgram(dependencies) {
 }
 function assertKnownHelpPath(program, container, argv) {
   let target = program;
-  const path190 = [];
+  const path191 = [];
   for (const token of argv.filter((arg) => !arg.startsWith("-"))) {
     if (target.commands.length === 0) {
       return;
@@ -156092,7 +156329,7 @@ function assertKnownHelpPath(program, container, argv) {
     const child = findCommand2(target, token);
     if (child !== void 0) {
       target = child;
-      path190.push(token);
+      path191.push(token);
       continue;
     }
     if (target !== program && target.registeredArguments.length > 0) {
@@ -156102,7 +156339,7 @@ function assertKnownHelpPath(program, container, argv) {
       container,
       scope: target === program ? "cli" : target.name(),
       unknownCommand: token,
-      helpArgs: [...path190, "--help"],
+      helpArgs: [...path191, "--help"],
       candidates: commandCandidates(target),
       moduleUrl: import.meta.url
     });
@@ -156133,16 +156370,16 @@ function commandCandidates(parent) {
   return parent.commands.flatMap((command) => [command.name(), ...command.aliases()]);
 }
 function registerHelpCommand(program, container) {
-  program.command("help").description("Display help for a command.").argument("[command...]", "Command path to describe, for example `maestro tui`.").action((path190) => {
+  program.command("help").description("Display help for a command.").argument("[command...]", "Command path to describe, for example `maestro tui`.").action((path191) => {
     let target = program;
-    for (const name of path190) {
+    for (const name of path191) {
       const child = findCommand2(target, name);
       if (child === void 0) {
         throwCommandNotFound({
           container,
           scope: "cli",
           unknownCommand: name,
-          helpArgs: [...path190.slice(0, path190.indexOf(name)), "--help"],
+          helpArgs: [...path191.slice(0, path191.indexOf(name)), "--help"],
           candidates: commandCandidates(target),
           moduleUrl: import.meta.url
         });