poe-code 8.0.1 → 9.0.1

package/packages/safejs/dist/chunks/chunk-AVDRLE3Y.js

@@ -1,3461 +0,0 @@
-import {
-  SandboxError,
-  activateOtelSpan,
-  bindOtelSpan,
-  declareHostOperation,
-  deepCopyToSandbox,
-  getActiveOtelSink,
-  getOwnErrorCode,
-  hasOwnErrorCode,
-  hostErrorData,
-  isSandboxClosure,
-  safeAddEvent,
-  safeEndSpan,
-  safeRecordException,
-  safeStartSpan
-} from "./chunk-ME5BTAZT.js";
-
-// packages/safejs/src/error/format.ts
-var DEFAULT_MAX_MESSAGE_LENGTH = 1e4;
-var MAX_CAUSE_DEPTH = 20;
-function formatInterpreterError(first, second) {
-  if (typeof first === "string" && isInterpreterDiagnostic(second)) {
-    return formatSourceDiagnostic(first, second, {
-      maxMessageLength: DEFAULT_MAX_MESSAGE_LENGTH
-    });
-  }
-  const options = second;
-  const formatted = formatTopLevelError(first, normalizeOptions(options));
-  if (options?.hostCallName === void 0) {
-    return formatted;
-  }
-  return wrapHostCall(formatted, options.hostCallName);
-}
-function normalizeOptions(options) {
-  return {
-    filename: options?.filename ?? "<input>",
-    hostCallName: options?.hostCallName ?? "",
-    maxMessageLength: options?.maxMessageLength ?? DEFAULT_MAX_MESSAGE_LENGTH,
-    source: options?.source ?? ""
-  };
-}
-function formatTopLevelError(error, options) {
-  if (isParseDiagnostic(error)) {
-    return formatParseDiagnostic(error, options.maxMessageLength);
-  }
-  if (error instanceof SandboxError) {
-    return formatSandboxError(error, options.maxMessageLength);
-  }
-  if (isSpanDiagnostic(error)) {
-    if (options.source === "") {
-      return truncate(error.message, options.maxMessageLength);
-    }
-    return formatSourceDiagnostic(options.source, {
-      kind: "InterpreterError",
-      filename: options.filename,
-      line: error.span.start.line,
-      column: error.span.start.column,
-      message: error.message
-    });
-  }
-  if (isErrorLike(error)) {
-    return formatErrorLike(error, options.maxMessageLength);
-  }
-  return `Thrown value: ${truncate(describeThrownValue(error), options.maxMessageLength)}`;
-}
-function formatParseDiagnostic(error, maxMessageLength) {
-  return [
-    `${error.kind}: ${error.filename}:${error.line}:${error.column}`,
-    "",
-    error.excerpt,
-    error.caret,
-    "",
-    truncate(error.message, maxMessageLength)
-  ].join("\n");
-}
-function formatSandboxError(error, maxMessageLength) {
-  const lines = [formatErrorSummary(error, maxMessageLength)];
-  if (error.code === "budgetExceeded" && error.budget !== void 0) {
-    lines.push("", `Budget exceeded: ${error.budget} (${error.current} > ${error.limit})`);
-  }
-  return lines.join("\n");
-}
-function formatErrorLike(error, maxMessageLength) {
-  const stack = formatSandboxStack(error, maxMessageLength);
-  const causes = formatCauses(error, maxMessageLength);
-  if (causes.length === 0) {
-    return stack;
-  }
-  return [stack, "", ...causes].join("\n");
-}
-function formatSandboxStack(error, maxMessageLength) {
-  if (typeof error.stack !== "string") {
-    return formatErrorSummary(error, maxMessageLength);
-  }
-  const stackLines = splitLines(error.stack);
-  const header = stackLines[0] === void 0 || stackLines[0] === "" ? void 0 : stackLines[0];
-  const sandboxFrames = stackLines.slice(1).filter(isSandboxStackFrame);
-  if (sandboxFrames.length === 0) {
-    return formatErrorSummary(error, maxMessageLength);
-  }
-  return [
-    truncate(header ?? formatErrorSummary(error, maxMessageLength), maxMessageLength),
-    ...sandboxFrames
-  ].join("\n");
-}
-function isSandboxStackFrame(line) {
-  const trimmed = line.trimStart();
-  return trimmed.startsWith("at ") && trimmed.includes("(line ") && trimmed.includes(", column ") && trimmed.endsWith(")");
-}
-function formatCauses(error, maxMessageLength) {
-  const causes = [];
-  const seen = /* @__PURE__ */ new Set();
-  let current = readCause(error);
-  for (let depth = 0; depth < MAX_CAUSE_DEPTH && current !== void 0; depth += 1) {
-    if (seen.has(current)) {
-      causes.push("Caused by: [Circular cause]");
-      break;
-    }
-    seen.add(current);
-    causes.push(`Caused by: ${formatCause(current, maxMessageLength)}`);
-    current = isObject(current) ? readCause(current) : void 0;
-  }
-  return causes;
-}
-function formatCause(cause, maxMessageLength) {
-  if (cause instanceof SandboxError) {
-    return formatErrorSummary(cause, maxMessageLength);
-  }
-  if (isErrorLike(cause)) {
-    return formatErrorSummary(cause, maxMessageLength);
-  }
-  return truncate(describeThrownValue(cause), maxMessageLength);
-}
-function readCause(value) {
-  return Object.prototype.hasOwnProperty.call(value, "cause") ? value.cause : void 0;
-}
-function wrapHostCall(formatted, hostCallName) {
-  const lines = splitLines(formatted);
-  const [firstLine = "", ...rest] = lines;
-  return [`Host call ${hostCallName} failed: ${firstLine}`, ...rest].join("\n");
-}
-function formatSourceDiagnostic(source, error, options = {}) {
-  const lines = splitLines(source);
-  const excerpt = createExcerpt(lines, error.line);
-  const lineNumberWidth = String(
-    excerpt[excerpt.length - 1]?.number ?? Math.max(error.line, 1)
-  ).length;
-  const reportedLine = excerpt.find((line) => line.number === Math.max(error.line, 1)) ?? excerpt[excerpt.length - 1];
-  const caretPadding = createCaretPadding(
-    reportedLine?.content ?? "",
-    error.column,
-    reportedLine?.hasSource === true
-  );
-  return [
-    `${error.kind}: ${error.filename}:${error.line}:${error.column}`,
-    "",
-    ...excerpt.map((line) => `${String(line.number).padStart(lineNumberWidth)} | ${line.content}`),
-    `${" ".repeat(lineNumberWidth)} | ${caretPadding}^`,
-    "",
-    truncate(error.message, options.maxMessageLength ?? DEFAULT_MAX_MESSAGE_LENGTH)
-  ].join("\n");
-}
-function formatErrorSummary(error, maxMessageLength) {
-  const name = typeof error.name === "string" && error.name !== "" ? error.name : "Error";
-  const message = typeof error.message === "string" ? error.message : "";
-  if (message === "") {
-    return name;
-  }
-  return `${name}: ${truncate(message, maxMessageLength)}`;
-}
-function truncate(message, maxLength) {
-  if (message.length <= maxLength) {
-    return message;
-  }
-  return `${message.slice(0, maxLength)}... [truncated ${message.length - maxLength} chars]`;
-}
-function describeThrownValue(value) {
-  if (typeof value === "string") {
-    return JSON.stringify(value);
-  }
-  if (value === void 0 || value === null || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
-    return String(value);
-  }
-  if (typeof value === "symbol" || typeof value === "function") {
-    return safeString(value, "[Unserializable thrown value]");
-  }
-  return stringifyJsonish(value);
-}
-function stringifyJsonish(value) {
-  const seen = /* @__PURE__ */ new WeakSet();
-  try {
-    return JSON.stringify(value, (_key, nested) => {
-      if (typeof nested === "bigint") {
-        return String(nested);
-      }
-      if (!isObject(nested)) {
-        return nested;
-      }
-      if (seen.has(nested)) {
-        return "[Circular]";
-      }
-      seen.add(nested);
-      return nested;
-    });
-  } catch {
-    return safeString(value, "[Unserializable thrown value]");
-  }
-}
-function safeString(value, fallback) {
-  try {
-    return String(value);
-  } catch {
-    return fallback;
-  }
-}
-function isInterpreterDiagnostic(value) {
-  return isObject(value) && typeof value.kind === "string" && typeof value.filename === "string" && typeof value.line === "number" && typeof value.column === "number" && typeof value.message === "string";
-}
-function isParseDiagnostic(value) {
-  return isInterpreterDiagnostic(value) && value.kind === "ParseError" && typeof value.excerpt === "string" && typeof value.caret === "string";
-}
-function isSpanDiagnostic(value) {
-  return isObject(value) && typeof value.message === "string" && isObject(value.span) && isObject(value.span.start) && typeof value.span.start.line === "number" && typeof value.span.start.column === "number";
-}
-function isErrorLike(value) {
-  if (!isObject(value)) {
-    return false;
-  }
-  return value instanceof Error || typeof value.name === "string" || typeof value.message === "string" || typeof value.stack === "string";
-}
-function isObject(value) {
-  return typeof value === "object" && value !== null;
-}
-function createExcerpt(sourceLines, reportedLine) {
-  const safeLineNumber = Math.max(reportedLine, 1);
-  if (safeLineNumber > sourceLines.length) {
-    return [
-      {
-        number: safeLineNumber,
-        content: "",
-        hasSource: false
-      }
-    ];
-  }
-  const excerpt = [];
-  const startLine = Math.max(1, safeLineNumber - 2);
-  const endLine = Math.min(sourceLines.length, safeLineNumber + 1);
-  for (let line = startLine; line <= endLine; line += 1) {
-    excerpt.push({
-      number: line,
-      content: sourceLines[line - 1] ?? "",
-      hasSource: true
-    });
-  }
-  return excerpt;
-}
-function splitLines(source) {
-  return source.split(/\r\n|\n|\r/);
-}
-function createCaretPadding(line, column, hasSource) {
-  let padding = "";
-  const maxColumn = hasSource ? Math.max(Math.min(column - 1, line.length), 0) : Math.max(column - 1, 0);
-  for (const character of line.slice(0, maxColumn)) {
-    padding += character === "	" ? "	" : " ";
-  }
-  if (maxColumn > line.length) {
-    padding += " ".repeat(maxColumn - line.length);
-  }
-  return padding;
-}
-
-// packages/safejs/src/loader/extract-block.ts
-function extractBlock(markdown, startLine = 1) {
-  let index = 0;
-  let line = startLine;
-  const blocks = [];
-  while (index < markdown.length) {
-    const lineStart = index;
-    const lineEnd = findLineEnd(markdown, index);
-    const lineContent = markdown.slice(lineStart, lineEnd.index);
-    const fence = readOpeningFence(lineContent);
-    if (fence !== void 0) {
-      const blockStart = lineEnd.index + lineEnd.lineBreakLength;
-      const closingFence = findClosingFence(markdown, blockStart, fence);
-      if (matchesScriptInfo(fence.info)) {
-        if (!closingFence.found) {
-          throw new Error(
-            `Unclosed ${readInfoWord(fence.info)} fenced block opened at line ${line}.`
-          );
-        }
-        blocks.push({ start: blockStart, end: closingFence.start, line });
-      }
-      const resumeIndex = findBlockResumeIndex(markdown, closingFence);
-      line += countLineBreaks(markdown, index, resumeIndex);
-      index = resumeIndex;
-      continue;
-    }
-    if (lineEnd.lineBreakLength === 0) {
-      break;
-    }
-    index = lineEnd.index + lineEnd.lineBreakLength;
-    line += 1;
-  }
-  if (blocks.length === 0)
-    return {
-      endOffset: markdown.length,
-      lineOffset: 1,
-      source: markdown,
-      startOffset: 0,
-      ranges: [[0, markdown.length]]
-    };
-  const first = blocks[0];
-  const parts = [];
-  let cursor = first.start;
-  for (const block of blocks) {
-    let gap = "";
-    for (let offset = cursor; offset < block.start; offset++) {
-      const character = markdown[offset];
-      gap += character === "\n" || character === "\r" ? character : " ";
-    }
-    parts.push(gap, markdown.slice(block.start, block.end));
-    cursor = block.end;
-  }
-  return {
-    endOffset: cursor,
-    lineOffset: first.line,
-    source: parts.join(""),
-    startOffset: first.start,
-    ranges: blocks.map((block) => [block.start, block.end])
-  };
-}
-function readOpeningFence(line) {
-  const fenceStart = readFenceStart(line);
-  if (fenceStart === void 0) {
-    return void 0;
-  }
-  let markerEnd = fenceStart.indentLength;
-  while (line[markerEnd] === fenceStart.markerCharacter) {
-    markerEnd += 1;
-  }
-  const marker = line.slice(fenceStart.indentLength, markerEnd);
-  if (marker.length < 3) {
-    return void 0;
-  }
-  const info = line.slice(markerEnd).trimStart();
-  return {
-    indent: line.slice(0, fenceStart.indentLength),
-    marker,
-    markerCharacter: fenceStart.markerCharacter,
-    info
-  };
-}
-function readFenceStart(line) {
-  let index = 0;
-  while (index < line.length && line[index] === " ") {
-    index += 1;
-  }
-  const markerCharacter = line[index];
-  return markerCharacter === "`" || markerCharacter === "~" ? {
-    indentLength: index,
-    markerCharacter
-  } : void 0;
-}
-function matchesScriptInfo(info) {
-  const infoWord = readInfoWord(info);
-  return infoWord === "js" || infoWord === "javascript" || infoWord === "ajs";
-}
-function readInfoWord(info) {
-  let index = 0;
-  while (index < info.length && !isWhitespace(info[index])) {
-    index += 1;
-  }
-  return info.slice(0, index);
-}
-function isWhitespace(character) {
-  return character === " " || character === "	";
-}
-function findBlockResumeIndex(markdown, closingFence) {
-  if (!closingFence.found || closingFence.start >= markdown.length) {
-    return markdown.length;
-  }
-  const closingLineEnd = findLineEnd(markdown, closingFence.start);
-  return closingLineEnd.index + closingLineEnd.lineBreakLength;
-}
-function countLineBreaks(markdown, start = 0, end = markdown.length) {
-  let count = 0;
-  let index = start;
-  while (index < end) {
-    const character = markdown[index];
-    if (character === "\n") {
-      count += 1;
-      index += 1;
-      continue;
-    }
-    if (character === "\r") {
-      count += 1;
-      index += markdown[index + 1] === "\n" ? 2 : 1;
-      continue;
-    }
-    index += 1;
-  }
-  return count;
-}
-function findClosingFence(markdown, searchStart, fence) {
-  let lineStart = searchStart;
-  while (lineStart <= markdown.length) {
-    const lineEnd = findLineEnd(markdown, lineStart);
-    const lineContent = markdown.slice(lineStart, lineEnd.index);
-    if (isClosingFence(lineContent, fence)) {
-      return {
-        found: true,
-        start: lineStart
-      };
-    }
-    if (lineEnd.lineBreakLength === 0) {
-      return {
-        found: false,
-        start: markdown.length
-      };
-    }
-    lineStart = lineEnd.index + lineEnd.lineBreakLength;
-  }
-  return {
-    found: false,
-    start: markdown.length
-  };
-}
-function isClosingFence(line, fence) {
-  const fenceStart = readFenceStart(line);
-  if (fenceStart === void 0 || fenceStart.markerCharacter !== fence.markerCharacter) {
-    return false;
-  }
-  const { indentLength } = fenceStart;
-  if (line.slice(0, indentLength) !== fence.indent) {
-    return false;
-  }
-  let markerEnd = indentLength;
-  while (line[markerEnd] === fence.markerCharacter) {
-    markerEnd += 1;
-  }
-  const closingMarker = line.slice(indentLength, markerEnd);
-  if (closingMarker.length < fence.marker.length) {
-    return false;
-  }
-  for (let index = markerEnd; index < line.length; index += 1) {
-    if (line[index] !== " ") {
-      return false;
-    }
-  }
-  return true;
-}
-function findLineEnd(markdown, start) {
-  let index = start;
-  while (index < markdown.length) {
-    const character = markdown[index];
-    if (character === "\n") {
-      return {
-        index,
-        lineBreakLength: 1
-      };
-    }
-    if (character === "\r") {
-      if (markdown[index + 1] === "\n") {
-        return {
-          index,
-          lineBreakLength: 2
-        };
-      }
-      return {
-        index,
-        lineBreakLength: 1
-      };
-    }
-    index += 1;
-  }
-  return {
-    index: markdown.length,
-    lineBreakLength: 0
-  };
-}
-
-// packages/frontmatter/src/fences.ts
-var MISSING_END_DELIMITER_MESSAGE = "Missing YAML frontmatter end delimiter (---).";
-function inspectFrontmatterBlock(source) {
-  const content = source.startsWith("\uFEFF") ? source.slice(1) : source;
-  const sourceOffset = source.length - content.length;
-  const opening = readOpeningFence2(content);
-  if (opening === void 0) {
-    return { kind: "body", body: source };
-  }
-  const closing = findClosingFence2(content, opening.next);
-  if (closing === void 0) {
-    return {
-      kind: "missing-closing-fence",
-      raw: content.slice(opening.next),
-      rawStart: sourceOffset + opening.next,
-      rawEnd: source.length,
-      body: "",
-      message: MISSING_END_DELIMITER_MESSAGE,
-      position: source.length
-    };
-  }
-  return {
-    kind: "frontmatter",
-    raw: content.slice(opening.next, closing.index),
-    rawStart: sourceOffset + opening.next,
-    rawEnd: sourceOffset + closing.index,
-    body: content.slice(closing.end + closing.lineBreakLength)
-  };
-}
-function readOpeningFence2(source) {
-  if (!source.startsWith("---")) {
-    return void 0;
-  }
-  const lineEnd = findLineEnd2(source, 0);
-  if (lineEnd.lineBreakLength === 0 || !isFenceLine(source.slice(0, lineEnd.index))) {
-    return void 0;
-  }
-  return { next: lineEnd.index + lineEnd.lineBreakLength };
-}
-function findClosingFence2(source, start) {
-  let lineStart = start;
-  while (lineStart <= source.length) {
-    const lineEnd = findLineEnd2(source, lineStart);
-    if (isFenceLine(source.slice(lineStart, lineEnd.index))) {
-      return {
-        index: lineStart,
-        end: lineEnd.index,
-        lineBreakLength: lineEnd.lineBreakLength
-      };
-    }
-    if (lineEnd.lineBreakLength === 0) {
-      break;
-    }
-    lineStart = lineEnd.index + lineEnd.lineBreakLength;
-  }
-  return void 0;
-}
-function isFenceLine(line) {
-  if (!line.startsWith("---")) {
-    return false;
-  }
-  for (let index = 3; index < line.length; index += 1) {
-    const character = line[index];
-    if (character !== " " && character !== "	") {
-      return false;
-    }
-  }
-  return true;
-}
-function findLineEnd2(source, start) {
-  let index = start;
-  while (index < source.length) {
-    const character = source[index];
-    if (character === "\n") {
-      return { index, lineBreakLength: 1 };
-    }
-    if (character === "\r") {
-      return {
-        index,
-        lineBreakLength: source[index + 1] === "\n" ? 2 : 1
-      };
-    }
-    index += 1;
-  }
-  return { index: source.length, lineBreakLength: 0 };
-}
-
-// packages/frontmatter/src/parse.ts
-import { LineCounter, parse, parseDocument } from "yaml";
-var FrontmatterParseError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "FrontmatterParseError";
-  }
-};
-function parseFrontmatterDocument(source, options = {}) {
-  const split = inspectFrontmatterBlock(source);
-  const lineCounter = createSourceLineCounter(source);
-  if (split.kind === "body") {
-    return {
-      frontmatter: {},
-      body: split.body,
-      errors: [],
-      lineCounter
-    };
-  }
-  if (split.kind === "missing-closing-fence") {
-    return {
-      frontmatter: {},
-      body: split.body,
-      errors: [{ message: split.message, pos: [split.position, split.position] }],
-      lineCounter
-    };
-  }
-  const yamlLineCounter = new LineCounter();
-  const normalizedYaml = normalizeYamlLineEndings(split.raw);
-  const document = parseDocument(normalizedYaml, {
-    lineCounter: yamlLineCounter,
-    prettyErrors: false,
-    uniqueKeys: options.uniqueKeys ?? false
-  });
-  const errors = document.errors.map((error) => ({
-    message: error.message,
-    ...error.pos === void 0 ? {} : { pos: translateYamlErrorPosition(error.pos, split) }
-  }));
-  if (errors.length > 0) {
-    return {
-      frontmatter: {},
-      body: split.body,
-      errors,
-      lineCounter
-    };
-  }
-  try {
-    return {
-      frontmatter: normalizeYamlFrontmatter(document.toJSON()),
-      body: split.body,
-      errors,
-      lineCounter
-    };
-  } catch (error) {
-    if (error instanceof FrontmatterParseError) {
-      return {
-        frontmatter: {},
-        body: split.body,
-        errors: [{ message: error.message }],
-        lineCounter
-      };
-    }
-    throw error;
-  }
-}
-function createSourceLineCounter(source) {
-  const lineCounter = new LineCounter();
-  lineCounter.addNewLine(0);
-  for (let index = 0; index < source.length; index += 1) {
-    const character = source[index];
-    if (character === "\n") {
-      lineCounter.addNewLine(index + 1);
-      continue;
-    }
-    if (character === "\r") {
-      lineCounter.addNewLine(index + (source[index + 1] === "\n" ? 2 : 1));
-      if (source[index + 1] === "\n") {
-        index += 1;
-      }
-    }
-  }
-  return lineCounter;
-}
-function translateYamlErrorPosition(pos, split) {
-  return pos.map((offset) => split.rawStart + normalizeYamlErrorOffset(split.raw, offset));
-}
-function normalizeYamlErrorOffset(raw, offset) {
-  if (offset >= raw.length && endsWithLineBreak(raw)) {
-    return findPreviousLineStart(raw, raw.length);
-  }
-  return offset;
-}
-function endsWithLineBreak(value) {
-  return value.endsWith("\n") || value.endsWith("\r");
-}
-function findPreviousLineStart(value, end) {
-  let index = end - 1;
-  if (value[index] === "\n") {
-    index -= 1;
-  }
-  if (value[index] === "\r") {
-    index -= 1;
-  }
-  while (index >= 0) {
-    const character = value[index];
-    if (character === "\n" || character === "\r") {
-      return index + 1;
-    }
-    index -= 1;
-  }
-  return 0;
-}
-function normalizeYamlLineEndings(value) {
-  if (!value.includes("\r")) {
-    return value;
-  }
-  let normalized = "";
-  for (let index = 0; index < value.length; index += 1) {
-    const character = value[index];
-    if (character !== "\r") {
-      normalized += character;
-      continue;
-    }
-    if (value[index + 1] === "\n") {
-      normalized += "\r\n";
-      index += 1;
-      continue;
-    }
-    normalized += "\n";
-  }
-  return normalized;
-}
-function normalizeYamlFrontmatter(value) {
-  if (value === null || value === void 0) {
-    return {};
-  }
-  if (!isPlainRecord(value)) {
-    throw new FrontmatterParseError("YAML frontmatter must parse to an object.");
-  }
-  return normalizeYamlValue(value);
-}
-function normalizeYamlValue(value) {
-  if (Array.isArray(value)) {
-    return value.map((item) => normalizeYamlValue(item));
-  }
-  if (!isPlainRecord(value)) {
-    return value;
-  }
-  const normalized = {};
-  for (const [key, entryValue] of Object.entries(value)) {
-    Object.defineProperty(normalized, key, {
-      configurable: true,
-      enumerable: true,
-      value: normalizeYamlValue(entryValue),
-      writable: true
-    });
-  }
-  return normalized;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isPlainRecord(value) {
-  if (!isRecord(value)) {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-
-// packages/frontmatter/src/stringify.ts
-import { stringify } from "yaml";
-
-// packages/safejs/src/loader/frontmatter.ts
-function splitFrontmatter(markdown) {
-  try {
-    const parsed = parseFrontmatterDocument(markdown);
-    if (parsed.errors.length > 0) {
-      const firstError = parsed.errors[0];
-      const line = firstError?.pos === void 0 ? 2 : parsed.lineCounter.linePos(firstError.pos[0]).line;
-      const message = firstError?.message ?? "unknown YAML parse error";
-      throw toSafeJSDiagnosticError(line, message);
-    }
-    return {
-      frontmatter: parsed.frontmatter,
-      body: parsed.body
-    };
-  } catch (error) {
-    if (error instanceof FrontmatterParseError) {
-      throw toSafeJSFrontmatterError(markdown, error);
-    }
-    throw error;
-  }
-}
-function toSafeJSDiagnosticError(line, message) {
-  if (message === "Missing YAML frontmatter end delimiter (---).") {
-    return new Error(`Invalid frontmatter at line ${line}: missing closing delimiter (---).`);
-  }
-  if (message === "YAML frontmatter must parse to an object.") {
-    return new Error(`Invalid frontmatter at line ${line}: expected a YAML mapping.`);
-  }
-  return new Error(`Invalid YAML frontmatter at line ${line}: ${message}`);
-}
-function toSafeJSFrontmatterError(markdown, error) {
-  if (error.message === "Missing YAML frontmatter end delimiter (---).") {
-    return new Error(
-      `Invalid frontmatter at line ${countLines(stripByteOrderMark(markdown))}: missing closing delimiter (---).`
-    );
-  }
-  if (error.message === "YAML frontmatter must parse to an object.") {
-    return new Error("Invalid frontmatter at line 2: expected a YAML mapping.");
-  }
-  if (error.message.startsWith("Invalid YAML frontmatter: ")) {
-    return new Error(`Invalid YAML frontmatter at line 2: ${error.message.slice(26)}`);
-  }
-  return error;
-}
-function stripByteOrderMark(value) {
-  return value.startsWith("\uFEFF") ? value.slice(1) : value;
-}
-function countLines(value) {
-  let count = 1;
-  for (const character of value) {
-    if (character === "\n") {
-      count += 1;
-    }
-  }
-  return count;
-}
-
-// packages/safejs/src/lint/runtime-modules.ts
-var AsyncFunction = (async () => void 0).constructor;
-function createLintModulesFromRuntimeRegistry(modules) {
-  const entries = modules instanceof Map ? [...modules.entries()] : Object.entries(modules);
-  return new Map(
-    entries.map(([moduleName, moduleExports]) => [
-      moduleName,
-      {
-        exports: createLintModuleExports(moduleExports)
-      }
-    ])
-  );
-}
-function createLintModuleExports(moduleExports) {
-  const entries = moduleExports instanceof Map ? [...moduleExports.entries()] : Object.entries(moduleExports);
-  return new Map(
-    entries.filter(([exportName]) => exportName.length > 0).map(([exportName, value]) => [exportName, createLintModuleExport(value)]).sort(([left], [right]) => left.localeCompare(right))
-  );
-}
-function createLintModuleExport(value) {
-  return isAsyncRuntimeExport(value) ? { async: true } : {};
-}
-function isAsyncRuntimeExport(value) {
-  if (isSandboxClosure(value)) {
-    return value.async === true;
-  }
-  return typeof value === "function" && value.constructor === AsyncFunction;
-}
-
-// packages/safejs/src/modules/agent.ts
-import { AsyncLocalStorage } from "node:async_hooks";
-
-// packages/agent-defs/src/agents/claude-code.ts
-var claudeCodeAgent = {
-  id: "claude-code",
-  name: "claude-code",
-  label: "Claude Code",
-  summary: "Anthropic's agentic coding tool for the terminal.",
-  aliases: ["claude"],
-  binaryName: "claude",
-  apiShapes: ["anthropic-messages"],
-  otelCapture: {
-    env: {
-      CLAUDE_CODE_ENABLE_TELEMETRY: "1"
-    }
-  },
-  configPath: "~/.claude.json",
-  capabilities: ["spawn", "configure", "install", "test", "skill", "mcp"],
-  branding: {
-    colors: {
-      dark: "#C15F3C",
-      light: "#C15F3C"
-    }
-  }
-};
-
-// packages/agent-defs/src/agents/claude-desktop.ts
-var claudeDesktopAgent = {
-  id: "claude-desktop",
-  name: "claude-desktop",
-  label: "Claude Desktop",
-  summary: "Anthropic's official desktop application for Claude",
-  configPath: "~/.config/Claude/claude_desktop_config.json",
-  configPaths: {
-    darwin: "~/Library/Application Support/Claude/claude_desktop_config.json",
-    linux: "~/.config/Claude/claude_desktop_config.json",
-    win32: "~/AppData/Roaming/Claude/claude_desktop_config.json"
-  },
-  capabilities: ["mcp"],
-  branding: {
-    colors: {
-      dark: "#D97757",
-      light: "#D97757"
-    }
-  }
-};
-
-// packages/agent-defs/src/agents/codex.ts
-var codexAgent = {
-  id: "codex",
-  name: "codex",
-  label: "Codex",
-  summary: "OpenAI's coding agent for the terminal.",
-  binaryName: "codex",
-  apiShapes: ["openai-responses"],
-  otelCapture: {
-    args: (endpoint, content) => [
-      "-c",
-      `otel.trace_exporter={"otlp-http"={endpoint=${JSON.stringify(`${endpoint}/v1/traces`)},protocol="json"}}`,
-      "-c",
-      `otel.exporter={"otlp-http"={endpoint=${JSON.stringify(`${endpoint}/v1/logs`)},protocol="json"}}`,
-      "-c",
-      `otel.log_user_prompt=${content}`
-    ]
-  },
-  configPath: "~/.codex/config.toml",
-  capabilities: ["spawn", "configure", "install", "test", "skill", "mcp"],
-  branding: {
-    colors: {
-      dark: "#D5D9DF",
-      light: "#7A7F86"
-    }
-  }
-};
-
-// packages/agent-defs/src/agents/cursor.ts
-var cursorAgent = {
-  id: "cursor",
-  name: "cursor",
-  aliases: ["cursor-agent"],
-  label: "Cursor",
-  summary: "Cursor's CLI coding agent.",
-  binaryName: "cursor-agent",
-  configPath: "~/.cursor/mcp.json",
-  capabilities: ["spawn", "configure", "install", "test", "skill", "mcp"],
-  branding: {
-    colors: {
-      dark: "#FFFFFF",
-      light: "#000000"
-    }
-  }
-};
-
-// packages/agent-defs/src/agents/gemini-cli.ts
-var geminiCliAgent = {
-  id: "gemini-cli",
-  name: "gemini-cli",
-  aliases: ["gemini"],
-  label: "Gemini CLI",
-  summary: "Google's open-source AI agent for the terminal.",
-  binaryName: "gemini",
-  configPath: "~/.gemini/settings.json",
-  apiShapes: ["google-generations"],
-  capabilities: ["spawn", "configure", "install", "test", "skill"],
-  branding: {
-    colors: {
-      dark: "#8AB4F8",
-      light: "#1A73E8"
-    }
-  }
-};
-
-// packages/agent-defs/src/agents/opencode.ts
-var openCodeAgent = {
-  id: "opencode",
-  name: "opencode",
-  label: "OpenCode CLI",
-  summary: "Open-source AI coding agent for the terminal.",
-  binaryName: "opencode",
-  apiShapes: ["openai-chat-completions"],
-  otelCapture: {
-    env: {
-      OPENCODE_CONFIG_CONTENT: '{"experimental":{"openTelemetry":true}}'
-    }
-  },
-  configPath: "~/.config/opencode/opencode.json",
-  capabilities: ["spawn", "configure", "install", "test", "skill", "mcp"],
-  branding: {
-    colors: {
-      dark: "#4A4F55",
-      light: "#2F3338"
-    }
-  }
-};
-
-// packages/agent-defs/src/agents/kimi.ts
-var kimiAgent = {
-  id: "kimi",
-  name: "kimi",
-  label: "Kimi",
-  summary: "Moonshot AI's coding agent for the terminal.",
-  aliases: ["kimi-cli"],
-  binaryName: "kimi",
-  apiShapes: ["openai-chat-completions"],
-  configPath: "~/.kimi/mcp.json",
-  capabilities: ["spawn", "configure", "install", "test", "mcp"],
-  branding: {
-    colors: {
-      dark: "#7B68EE",
-      light: "#6A5ACD"
-    }
-  }
-};
-
-// packages/agent-defs/src/agents/goose.ts
-var gooseAgent = {
-  id: "goose",
-  name: "goose",
-  label: "Goose",
-  summary: "Block's open-source AI agent with ACP support.",
-  binaryName: "goose",
-  apiShapes: ["openai-chat-completions"],
-  otelCapture: {},
-  configPath: "~/.config/goose/config.yaml",
-  capabilities: ["spawn", "configure", "install", "test", "skill", "mcp"],
-  branding: {
-    colors: {
-      dark: "#FF6B35",
-      light: "#E85D26"
-    }
-  }
-};
-
-// packages/agent-defs/src/agents/pi.ts
-var piAgent = {
-  id: "pi",
-  name: "pi",
-  aliases: ["pi-agent"],
-  label: "Pi",
-  summary: "Minimal AI coding agent for the terminal.",
-  binaryName: "pi",
-  capabilities: ["spawn"],
-  branding: {
-    colors: {
-      dark: "#F2F2F2",
-      light: "#242424"
-    }
-  }
-};
-
-// packages/agent-defs/src/agents/poe-agent.ts
-var poeAgentAgent = {
-  id: "poe-agent",
-  name: "poe-agent",
-  label: "Poe Agent",
-  summary: "Run one-shot prompts with the built-in Poe agent runtime.",
-  apiShapes: ["openai-responses", "openai-chat-completions"],
-  configPath: "~/.poe-code/config.json",
-  capabilities: ["configure"],
-  branding: {
-    colors: {
-      dark: "#A465F7",
-      light: "#7A3FD3"
-    }
-  }
-};
-
-// packages/agent-defs/src/registry.ts
-function freezeAgent(agent) {
-  if (agent.aliases !== void 0) {
-    Object.freeze(agent.aliases);
-  }
-  if (agent.apiShapes !== void 0) {
-    Object.freeze(agent.apiShapes);
-  }
-  if (agent.capabilities !== void 0) {
-    Object.freeze(agent.capabilities);
-  }
-  if (agent.otelCapture?.env !== void 0) {
-    Object.freeze(agent.otelCapture.env);
-  }
-  if (agent.otelCapture !== void 0) {
-    Object.freeze(agent.otelCapture);
-  }
-  Object.freeze(agent.branding.colors);
-  Object.freeze(agent.branding);
-  return Object.freeze(agent);
-}
-var allAgents = Object.freeze([
-  freezeAgent(claudeCodeAgent),
-  freezeAgent(claudeDesktopAgent),
-  freezeAgent(codexAgent),
-  freezeAgent(cursorAgent),
-  freezeAgent(geminiCliAgent),
-  freezeAgent(openCodeAgent),
-  freezeAgent(kimiAgent),
-  freezeAgent(gooseAgent),
-  freezeAgent(piAgent),
-  freezeAgent(poeAgentAgent)
-]);
-var lookup = /* @__PURE__ */ new Map();
-for (const agent of allAgents) {
-  const values = [agent.id, agent.name, ...agent.aliases ?? []];
-  for (const value of values) {
-    const normalized = value.toLowerCase();
-    if (!lookup.has(normalized)) {
-      lookup.set(normalized, agent.id);
-    }
-  }
-}
-function resolveAgentId(input) {
-  if (!input) {
-    return void 0;
-  }
-  return lookup.get(input.trim().toLowerCase());
-}
-
-// packages/agent-spawn/src/configs/mcp.ts
-function toJsonMcpServers(servers) {
-  validateMcpSpawnConfig(servers);
-  const out = /* @__PURE__ */ Object.create(null);
-  for (const [name, server] of Object.entries(servers)) {
-    const mapped = { command: server.command };
-    if (server.args && server.args.length > 0) {
-      mapped.args = server.args;
-    }
-    if (server.env && Object.keys(server.env).length > 0) {
-      mapped.env = server.env;
-    }
-    if (server.timeout !== void 0) {
-      mapped.timeout = server.timeout;
-    }
-    out[name] = mapped;
-  }
-  return out;
-}
-function toTomlString(value) {
-  return JSON.stringify(value);
-}
-function toTomlArray(values) {
-  const serialized = values.map((value) => toTomlString(value));
-  return `[${serialized.join(", ")}]`;
-}
-function toTomlInlineTable(values) {
-  const parts = [];
-  for (const [key, value] of Object.entries(values)) {
-    parts.push(`${JSON.stringify(key)}=${toTomlString(value)}`);
-  }
-  return `{${parts.join(", ")}}`;
-}
-function isTomlBareKeySegment(value) {
-  if (value.length === 0) {
-    return false;
-  }
-  for (const char of value) {
-    const code = char.charCodeAt(0);
-    const isDigit = code >= 48 && code <= 57;
-    const isUpperAlpha = code >= 65 && code <= 90;
-    const isLowerAlpha = code >= 97 && code <= 122;
-    if (!isDigit && !isUpperAlpha && !isLowerAlpha && char !== "_" && char !== "-") {
-      return false;
-    }
-  }
-  return true;
-}
-function toTomlKeySegment(value) {
-  return isTomlBareKeySegment(value) ? value : JSON.stringify(value);
-}
-function validateMcpSpawnConfig(servers) {
-  for (const [name, server] of Object.entries(servers)) {
-    if (name.trim().length === 0) {
-      throw new Error("MCP server name must be a non-empty string.");
-    }
-    if (typeof server.command !== "string" || server.command.trim().length === 0) {
-      throw new Error(`MCP server "${name}" command must be a non-empty string.`);
-    }
-  }
-}
-function serializeJsonMcpArgs(servers) {
-  return ["--mcp-config", JSON.stringify({ mcpServers: toJsonMcpServers(servers) })];
-}
-function serializeOpenCodeMcpEnv(servers) {
-  validateMcpSpawnConfig(servers);
-  const mcp = /* @__PURE__ */ Object.create(null);
-  for (const [name, server] of Object.entries(servers)) {
-    if (server.timeout !== void 0) {
-      throw new Error(`OpenCode MCP server "${name}" does not support timeout.`);
-    }
-    const entry = { type: "local", command: [server.command, ...server.args ?? []] };
-    if (server.env && Object.keys(server.env).length > 0) {
-      entry.environment = server.env;
-    }
-    mcp[name] = entry;
-  }
-  return { OPENCODE_CONFIG_CONTENT: JSON.stringify({ mcp }) };
-}
-function serializeCodexMcpArgs(servers) {
-  validateMcpSpawnConfig(servers);
-  const args = [];
-  for (const [name, server] of Object.entries(servers)) {
-    const prefix = `mcp_servers.${toTomlKeySegment(name)}`;
-    args.push("-c", `${prefix}.command=${toTomlString(server.command)}`);
-    if (server.autoApprove !== false) {
-      args.push("-c", `${prefix}.default_tools_approval_mode=${toTomlString("approve")}`);
-    }
-    if (server.args && server.args.length > 0) {
-      args.push("-c", `${prefix}.args=${toTomlArray(server.args)}`);
-    }
-    if (server.env && Object.keys(server.env).length > 0) {
-      args.push("-c", `${prefix}.env=${toTomlInlineTable(server.env)}`);
-    }
-    if (server.timeout !== void 0) {
-      args.push("-c", `${prefix}.timeout=${server.timeout}`);
-    }
-  }
-  return args;
-}
-function serializeGooseMcpArgs(servers) {
-  validateMcpSpawnConfig(servers);
-  return Object.entries(servers).flatMap(([name, server]) => {
-    if (server.env && Object.keys(server.env).length > 0) {
-      throw new Error(`Goose MCP server "${name}" does not support env through --with-extension.`);
-    }
-    if (server.timeout !== void 0) {
-      throw new Error(
-        `Goose MCP server "${name}" does not support timeout through --with-extension.`
-      );
-    }
-    return ["--with-extension", [server.command, ...server.args ?? []].join(" ")];
-  });
-}
-
-// packages/agent-spawn/src/configs/claude-code.ts
-var claudeCodeSpawnConfig = {
-  kind: "cli",
-  agentId: "claude-code",
-  // ACP adapter support: yes (adapter: "claude")
-  adapter: "claude",
-  promptFlag: "-p",
-  modelFlag: "--model",
-  modelStripProviderPrefix: true,
-  modelTransform: (model) => model.replaceAll(".", "-"),
-  defaultArgs: [
-    "--output-format",
-    "stream-json",
-    "--verbose"
-  ],
-  mcpArgs: serializeJsonMcpArgs,
-  modes: {
-    yolo: ["--dangerously-skip-permissions"],
-    auto: ["--permission-mode", "auto"],
-    edit: ["--permission-mode", "acceptEdits", "--allowedTools", "Bash,Read,Write,Edit,Glob,Grep,NotebookEdit"],
-    // Plan mode alone still permits writes, so read mode pins a read-only
-    // allowlist and hard-denies every mutating tool.
-    read: [
-      "--permission-mode",
-      "plan",
-      "--allowedTools",
-      "Read,Glob,Grep",
-      "--disallowedTools",
-      "Bash,Write,Edit,MultiEdit,NotebookEdit"
-    ]
-  },
-  stdinMode: {
-    omitPrompt: true,
-    extraArgs: ["--input-format", "text"]
-  },
-  interactive: {
-    defaultArgs: []
-  },
-  resume: {
-    args: (threadId) => ["--resume", threadId]
-  }
-};
-
-// packages/agent-spawn/src/configs/codex.ts
-var codexSpawnConfig = {
-  kind: "cli",
-  agentId: "codex",
-  // ACP adapter support: yes (adapter: "codex")
-  adapter: "codex",
-  promptFlag: "exec",
-  modelFlag: "--model",
-  modelStripProviderPrefix: true,
-  defaultArgs: ["--skip-git-repo-check", "--json"],
-  mcpArgs: serializeCodexMcpArgs,
-  mcpArgsBeforeCommand: true,
-  modes: {
-    yolo: ["--dangerously-bypass-approvals-and-sandbox"],
-    auto: [
-      "-s",
-      "danger-full-access",
-      "-c",
-      'approval_policy="on-request"',
-      "-c",
-      'approvals_reviewer="auto_review"'
-    ],
-    edit: ["-s", "workspace-write"],
-    read: ["-s", "read-only"]
-  },
-  stdinMode: {
-    omitPrompt: true,
-    extraArgs: ["-"]
-  },
-  interactive: {
-    defaultArgs: ["-a", "never"]
-  },
-  resume: {
-    args: (threadId) => ["resume", threadId],
-    position: "beforePrompt",
-    commandOptionsPosition: "beforeResume",
-    hintArgs: (threadId, cwd) => ["resume", "-C", cwd, threadId]
-  }
-};
-
-// packages/agent-spawn/src/configs/opencode.ts
-var openCodeSpawnConfig = {
-  kind: "cli",
-  agentId: "opencode",
-  // ACP adapter support: yes (adapter: "opencode").
-  // OpenCode's `--format json` emits NDJSON events with `{ type, sessionID, part }`
-  // (no `{ event, ... }` field), so it needs the OpenCode adapter (not "native").
-  adapter: "opencode",
-  promptFlag: "run",
-  modelFlag: "--model",
-  modelStripProviderPrefix: false,
-  modelTransform: (model) => {
-    return model.startsWith("poe/") ? model : `poe/${model}`;
-  },
-  defaultArgs: ["--format", "json"],
-  modes: {
-    // No auto: `opencode run` never asks; permissions come from opencode.json.
-    yolo: [],
-    edit: [],
-    read: ["--agent", "plan"]
-  },
-  interactive: {
-    defaultArgs: [],
-    promptFlag: "--prompt"
-  },
-  resume: {
-    args: (threadId) => ["--session", threadId],
-    hintArgs: (threadId, cwd) => [cwd, "--session", threadId]
-  },
-  mcpEnv: serializeOpenCodeMcpEnv
-};
-var openCodeAcpSpawnConfig = {
-  kind: "acp",
-  agentId: "opencode",
-  acpArgs: ["acp"],
-  skipAuth: true,
-  mcpEnv: serializeOpenCodeMcpEnv
-};
-
-// packages/agent-spawn/src/configs/kimi.ts
-var kimiSpawnConfig = {
-  kind: "cli",
-  agentId: "kimi",
-  // ACP adapter support: yes (adapter: "kimi").
-  // Kimi's `--output-format stream-json` emits OpenAI-style `{ role, content }` JSON
-  // (no `{ event, ... }` field), so it needs the Kimi adapter (not "native").
-  adapter: "kimi",
-  promptFlag: "-p",
-  modelStripProviderPrefix: true,
-  defaultArgs: ["--print", "--output-format", "stream-json"],
-  mcpArgs: serializeJsonMcpArgs,
-  modes: {
-    // No auto: kimi --print mode has no approval channel.
-    yolo: ["--yolo"],
-    edit: [],
-    read: []
-  },
-  stdinMode: {
-    omitPrompt: true,
-    extraArgs: ["--input-format", "stream-json"],
-    automaticFallback: false
-  },
-  interactive: {
-    defaultArgs: [],
-    promptFlag: "-p"
-  },
-  resume: {
-    args: (threadId, cwd) => ["--session", threadId, "--work-dir", cwd]
-  }
-};
-var kimiAcpSpawnConfig = {
-  kind: "acp",
-  agentId: "kimi",
-  acpArgs: ["acp"],
-  supportsMcpServers: false
-};
-
-// packages/agent-spawn/src/configs/goose.ts
-var gooseFileSecretsEnv = { GOOSE_DISABLE_KEYRING: "1" };
-var gooseSpawnConfig = {
-  kind: "cli",
-  agentId: "goose",
-  adapter: "native",
-  promptFlag: "--text",
-  modelFlag: "--model",
-  modelStripProviderPrefix: false,
-  defaultArgs: ["run", "--output-format", "stream-json"],
-  defaultArgsPosition: "beforePrompt",
-  mcpArgs: serializeGooseMcpArgs,
-  mcpArgsPosition: "beforePrompt",
-  modes: {
-    // No auto: GOOSE_MODE=approve prompts on the TTY and would hang a headless run.
-    yolo: { env: { ...gooseFileSecretsEnv, GOOSE_MODE: "auto" } },
-    edit: { env: { ...gooseFileSecretsEnv, GOOSE_MODE: "smart_approve" } },
-    read: { env: { ...gooseFileSecretsEnv, GOOSE_MODE: "chat" } }
-  },
-  stdinMode: {
-    omitPrompt: true,
-    extraArgs: ["--instructions", "-"],
-    automaticFallback: false
-  },
-  interactive: {
-    defaultArgs: ["session"],
-    defaultArgsPosition: "beforePrompt"
-  },
-  resume: {
-    args: (threadId) => ["--resume", "--session-id", threadId],
-    hintArgs: (threadId) => ["run", "--resume", "--session-id", threadId, "--text", "continue"]
-  }
-};
-var gooseAcpSpawnConfig = {
-  kind: "acp",
-  agentId: "goose",
-  acpArgs: ["acp"],
-  env: gooseFileSecretsEnv,
-  skipAuth: true
-};
-
-// packages/agent-spawn/src/types.ts
-var SPAWN_MODES = ["yolo", "auto", "edit", "read"];
-var DEFAULT_SPAWN_MODE = "auto";
-
-// packages/agent-spawn/src/configs/gemini-cli.ts
-var geminiApprovalModes = {
-  yolo: "yolo",
-  auto: "default",
-  edit: "auto_edit",
-  read: "plan"
-};
-var geminiCliAcpSpawnConfig = {
-  kind: "acp",
-  agentId: "gemini-cli",
-  acpArgs: ({ model, mode, mcpServers }) => [
-    "--acp",
-    ...model ? ["--model", model] : [],
-    ...mcpServers ? ["--allowed-mcp-server-names", Object.keys(mcpServers).join(",")] : [],
-    ...mcpServers ? ["--skip-trust"] : [],
-    "--approval-mode",
-    geminiApprovalModes[mode ?? DEFAULT_SPAWN_MODE]
-  ],
-  env: {
-    GEMINI_SANDBOX: "false"
-  },
-  skipAuth: true
-};
-
-// packages/agent-spawn/src/configs/cursor.ts
-var cursorSpawnConfig = {
-  kind: "cli",
-  agentId: "cursor",
-  adapter: "cursor",
-  promptFlag: "-p",
-  modelFlag: "--model",
-  modelStripProviderPrefix: true,
-  modelTransform: (model) => model.startsWith("claude-opus-") || model.startsWith("claude-sonnet-") || model.startsWith("claude-haiku-") ? model.replaceAll(".", "-") : model,
-  defaultArgs: ["--output-format", "stream-json", "--trust", "--approve-mcps"],
-  defaultArgsPosition: "beforePrompt",
-  modes: {
-    // No auto: cursor-agent print mode has no approval channel.
-    yolo: ["--force", "--sandbox", "disabled"],
-    edit: ["--force"],
-    read: ["--mode", "plan"]
-  },
-  stdinMode: { omitPrompt: true, extraArgs: [] },
-  mcpFile: {
-    relativePath: ".cursor/mcp.json",
-    content: (servers) => ({ mcpServers: toJsonMcpServers(servers) })
-  },
-  interactive: { defaultArgs: [] },
-  resume: {
-    args: (threadId) => ["--resume", threadId],
-    position: "beforePrompt"
-  }
-};
-
-// packages/agent-spawn/src/configs/pi.ts
-var ALL_BUILTIN_TOOLS = "read,bash,edit,write,grep,find,ls";
-var EDIT_TOOLS = "read,edit,write,grep,find,ls";
-var READ_ONLY_TOOLS = "read,grep,find,ls";
-var piSpawnConfig = {
-  kind: "cli",
-  agentId: "pi",
-  adapter: "pi",
-  defaultArgs: ["--mode", "json", "--print"],
-  defaultArgsPosition: "beforePrompt",
-  modelFlag: "--model",
-  modelStripProviderPrefix: false,
-  modes: {
-    yolo: ["--tools", ALL_BUILTIN_TOOLS, "--approve"],
-    edit: ["--tools", EDIT_TOOLS, "--no-approve"],
-    read: ["--tools", READ_ONLY_TOOLS, "--no-approve"]
-  },
-  stdinMode: {
-    omitPrompt: true,
-    extraArgs: []
-  },
-  interactive: {
-    defaultArgs: []
-  },
-  resume: {
-    args: (threadId) => ["--session", threadId],
-    position: "beforePrompt"
-  }
-};
-
-// packages/agent-spawn/src/configs/index.ts
-function freezeConfig(config) {
-  freezeValue(config);
-  return config;
-}
-function freezeValue(value) {
-  if (!value || typeof value !== "object" || Object.isFrozen(value)) {
-    return;
-  }
-  for (const nested of Object.values(value)) {
-    freezeValue(nested);
-  }
-  Object.freeze(value);
-}
-var allSpawnConfigs = Object.freeze([
-  freezeConfig(claudeCodeSpawnConfig),
-  freezeConfig(codexSpawnConfig),
-  freezeConfig(cursorSpawnConfig),
-  freezeConfig(piSpawnConfig),
-  freezeConfig(openCodeSpawnConfig),
-  freezeConfig(kimiSpawnConfig),
-  freezeConfig(gooseSpawnConfig)
-]);
-var lookup2 = /* @__PURE__ */ new Map();
-for (const config of allSpawnConfigs) {
-  lookup2.set(config.agentId, config);
-}
-var acpLookup = /* @__PURE__ */ new Map();
-acpLookup.set(openCodeAcpSpawnConfig.agentId, freezeConfig(openCodeAcpSpawnConfig));
-acpLookup.set(kimiAcpSpawnConfig.agentId, freezeConfig(kimiAcpSpawnConfig));
-acpLookup.set(gooseAcpSpawnConfig.agentId, freezeConfig(gooseAcpSpawnConfig));
-acpLookup.set(geminiCliAcpSpawnConfig.agentId, freezeConfig(geminiCliAcpSpawnConfig));
-function getSpawnConfig(input) {
-  const resolvedId = resolveAgentId(input);
-  if (!resolvedId) {
-    return void 0;
-  }
-  return lookup2.get(resolvedId);
-}
-function supportsSpawnMode(input, mode) {
-  const config = getSpawnConfig(input);
-  if (config && config.kind === "cli") {
-    return config.modes[mode] !== void 0;
-  }
-  return true;
-}
-
-// packages/agent-spawn/src/parallel.ts
-var SpawnParallelError = class extends Error {
-  index;
-  result;
-  results;
-  constructor(index, result, results) {
-    super(`spawn.parallel call ${index} failed with exit code ${result.exitCode}.`);
-    this.name = "SpawnParallelError";
-    this.index = index;
-    this.result = result;
-    this.results = results;
-  }
-};
-function createSpawnParallel(spawnOnce) {
-  return async function parallel(calls, options = {}) {
-    const maxConcurrent = normalizeMaxConcurrent(options.maxConcurrent);
-    const failFast = options.failFast ?? true;
-    const requestedCheck = Object.hasOwn(options, "check") ? options.check : void 0;
-    const check = requestedCheck === void 0 ? failFast : requestedCheck;
-    if (typeof check !== "boolean") {
-      throw new Error("spawn.parallel check must be a boolean.");
-    }
-    if (calls.length === 0) {
-      return [];
-    }
-    const group = new AbortController();
-    const results = new Array(calls.length);
-    const errors = [];
-    let nextIndex = 0;
-    let primaryFailure;
-    const removeParentAbort = linkParentAbort(options.signal, group, (error) => {
-      primaryFailure ??= { reason: error };
-    });
-    const worker = async () => {
-      while (primaryFailure === void 0) {
-        const index = nextIndex;
-        nextIndex += 1;
-        if (index >= calls.length) {
-          return;
-        }
-        try {
-          const result = await runParallelCall(calls[index], spawnOnce, group.signal);
-          results[index] = result;
-          if (check && failFast && result.exitCode !== 0) {
-            const error = new SpawnParallelError(index, result, results);
-            primaryFailure ??= { reason: error };
-            group.abort(error);
-            return;
-          }
-        } catch (error) {
-          if (failFast || group.signal.aborted) {
-            primaryFailure ??= { reason: error };
-            group.abort(error);
-            return;
-          }
-          errors.push(error);
-        }
-      }
-    };
-    try {
-      await Promise.allSettled(
-        Array.from({ length: Math.min(maxConcurrent, calls.length) }, () => worker())
-      );
-    } finally {
-      removeParentAbort();
-    }
-    if (primaryFailure !== void 0) {
-      throw primaryFailure.reason;
-    }
-    if (errors.length > 0) {
-      throw new AggregateError(
-        errors,
-        "spawn.parallel failed before every call returned a result."
-      );
-    }
-    if (check) {
-      const failedIndex = results.findIndex(
-        (result) => result !== void 0 && result.exitCode !== 0
-      );
-      if (failedIndex >= 0) {
-        throw new SpawnParallelError(failedIndex, results[failedIndex], results);
-      }
-    }
-    return results;
-  };
-}
-async function runParallelCall(call, spawnOnce, signal) {
-  throwIfAborted(signal);
-  if (typeof call === "function") {
-    const handle = call(signal);
-    const [result] = await Promise.all([handle.result, drainEvents(handle.events)]);
-    return result;
-  }
-  if (!isSpawnTuple(call)) {
-    throw new Error("spawn.parallel calls must be [service, options] tuples or spawn thunks.");
-  }
-  const { options, cleanup } = withAbortSignal(call[1], signal);
-  try {
-    const handle = spawnOnce(call[0], options);
-    const [result] = await Promise.all([handle.result, drainEvents(handle.events)]);
-    return result;
-  } finally {
-    cleanup();
-  }
-}
-async function drainEvents(events) {
-  for await (const ignoredEvent of events) {
-    void ignoredEvent;
-  }
-}
-function normalizeMaxConcurrent(maxConcurrent) {
-  const value = maxConcurrent ?? 4;
-  if (!Number.isInteger(value) || value < 1) {
-    throw new Error("spawn.parallel maxConcurrent must be an integer greater than or equal to 1.");
-  }
-  return value;
-}
-function isSpawnTuple(call) {
-  return Array.isArray(call) && call.length === 2;
-}
-function withAbortSignal(options, signal) {
-  if (!options.signal) {
-    return {
-      options: { ...options, signal },
-      cleanup() {
-      }
-    };
-  }
-  const controller = new AbortController();
-  const callSignal = options.signal;
-  const abortGroup = () => controller.abort(signal.reason);
-  const abortCall = () => controller.abort(callSignal.reason);
-  if (signal.aborted) {
-    abortGroup();
-  } else if (callSignal.aborted) {
-    abortCall();
-  } else {
-    signal.addEventListener("abort", abortGroup, { once: true });
-    callSignal.addEventListener("abort", abortCall, { once: true });
-  }
-  return {
-    options: { ...options, signal: controller.signal },
-    cleanup() {
-      signal.removeEventListener("abort", abortGroup);
-      callSignal.removeEventListener("abort", abortCall);
-    }
-  };
-}
-function linkParentAbort(parentSignal, group, setFailure) {
-  if (!parentSignal) {
-    return () => {
-    };
-  }
-  const abort = () => {
-    const error = parentSignal.reason;
-    setFailure(error);
-    group.abort(error);
-  };
-  if (parentSignal.aborted) {
-    abort();
-    return () => {
-    };
-  }
-  parentSignal.addEventListener("abort", abort, { once: true });
-  return () => parentSignal.removeEventListener("abort", abort);
-}
-function throwIfAborted(signal) {
-  if (signal.aborted) {
-    throw signal.reason;
-  }
-}
-
-// packages/safejs/src/modules/agent.ts
-var AgentSpawnError = class extends Error {
-  result;
-  constructor(result) {
-    super(createSpawnFailureMessage(result));
-    this.name = "AgentSpawnError";
-    this.result = result;
-    hostErrorData.set(this, { result });
-  }
-};
-var activeUsageAccumulator = new AsyncLocalStorage();
-function createSpawnUsageAccumulator() {
-  let inputTokens = 0;
-  let outputTokens = 0;
-  let cachedTokens = 0;
-  let costUsd;
-  let spawnCount = 0;
-  let attemptCount = 0;
-  return {
-    beginAttempt() {
-      attemptCount += 1;
-    },
-    beginSpawn() {
-      spawnCount += 1;
-    },
-    record(usage) {
-      if (usage === void 0) {
-        return;
-      }
-      inputTokens += usage.inputTokens;
-      outputTokens += usage.outputTokens;
-      cachedTokens += usage.cachedTokens ?? 0;
-      if (usage.costUsd !== void 0) {
-        costUsd = (costUsd ?? 0) + usage.costUsd;
-      }
-    },
-    reset() {
-      inputTokens = 0;
-      outputTokens = 0;
-      cachedTokens = 0;
-      costUsd = void 0;
-      spawnCount = 0;
-      attemptCount = 0;
-    },
-    snapshot() {
-      return {
-        inputTokens,
-        outputTokens,
-        cachedTokens,
-        ...costUsd === void 0 ? {} : { costUsd },
-        spawnCount,
-        ...attemptCount === spawnCount ? {} : { attemptCount }
-      };
-    }
-  };
-}
-async function runWithSpawnUsageAccumulator(accumulator, operation) {
-  accumulator.reset();
-  return await activeUsageAccumulator.run(accumulator, operation);
-}
-function makeAgentModule(spawnAgent, moduleOptions = {}) {
-  const defaultRetry = moduleOptions.defaultRetry === void 0 ? void 0 : normalizeRetryOptions(moduleOptions.defaultRetry);
-  let nextSpawnId = 1;
-  const spawnOnce = async (agentDef, options) => {
-    const input = resolveSpawnInput(agentDef, options);
-    const spawnId = nextSpawnId;
-    nextSpawnId += 1;
-    recordActiveSpawnStart();
-    return runObservedSpawn(moduleOptions.otelSink, input, async () => {
-      return defaultRetry === void 0 ? runSpawnAttempt(spawnAgent, input, moduleOptions.onEvent, spawnId) : runSpawnRetry(spawnAgent, input, defaultRetry, moduleOptions.onEvent, spawnId);
-    });
-  };
-  return {
-    spawn: Object.assign(spawnOnce, {
-      async retry(agentDef, options, retryOptions) {
-        const input = resolveSpawnInput(agentDef, options);
-        const normalizedRetry = normalizeRetryOptions(retryOptions);
-        const spawnId = nextSpawnId;
-        nextSpawnId += 1;
-        recordActiveSpawnStart();
-        return await runObservedSpawn(
-          moduleOptions.otelSink,
-          input,
-          () => runSpawnRetry(
-            spawnAgent,
-            input,
-            normalizedRetry,
-            moduleOptions.onEvent,
-            spawnId
-          )
-        );
-      },
-      async parallel(calls, options = {}) {
-        const check = readOptionalBoolean(getOwnProperty(options, "check"), "Agent parallel options check") ?? false;
-        const parallel = createSpawnParallel((agentDef, spawnOptions) => ({
-          events: (async function* () {
-          })(),
-          result: (() => {
-            const input = resolveSpawnInput(agentDef, spawnOptions);
-            const spawnId = nextSpawnId;
-            nextSpawnId += 1;
-            recordActiveSpawnStart();
-            return runObservedSpawn(
-              moduleOptions.otelSink,
-              input,
-              () => runSpawnRetry(
-                spawnAgent,
-                input,
-                defaultRetry ?? oneAttemptRetryOptions,
-                (event) => moduleOptions.onEvent?.(
-                  event.type === "spawn.failed" ? { ...event, checked: event.checked || check } : event
-                ),
-                spawnId
-              )
-            );
-          })()
-        }));
-        try {
-          return await parallel(calls, { ...options, check });
-        } catch (error) {
-          if (error instanceof SpawnParallelError) {
-            hostErrorData.set(error, {
-              index: error.index,
-              result: error.result,
-              results: error.results
-            });
-          }
-          throw error;
-        }
-      }
-    })
-  };
-}
-async function runSpawnAttempt(spawnAgent, input, onEvent, spawnId) {
-  const task = resolveTaskLabel(input);
-  const startedAt = Date.now();
-  try {
-    throwIfAborted2(input.signal);
-  } catch (error) {
-    emitSpawnCancelled(onEvent, spawnId, input.agent, task, 1, 1, Date.now() - startedAt, error);
-    throw error;
-  }
-  emitSpawnEvent(onEvent, {
-    type: "spawn.started",
-    spawnId,
-    agent: input.agent,
-    task,
-    attempt: 1,
-    maxAttempts: 1
-  });
-  try {
-    recordActiveSpawnAttempt();
-    const result = validateSpawnResult(await spawnAgent(toProviderSpawnInput(input)));
-    throwIfAborted2(input.signal);
-    recordActiveSpawnUsage(result.usage);
-    if (result.exitCode !== 0) {
-      const error = new AgentSpawnError(result);
-      if (input.check) {
-        throw error;
-      }
-      emitFinalSpawnFailure(
-        onEvent,
-        spawnId,
-        input.agent,
-        task,
-        1,
-        1,
-        result.durationMs,
-        error,
-        false
-      );
-      return result;
-    }
-    emitSpawnEvent(onEvent, {
-      type: "spawn.succeeded",
-      spawnId,
-      agent: input.agent,
-      task,
-      attempt: 1,
-      maxAttempts: 1,
-      durationMs: result.durationMs
-    });
-    return result;
-  } catch (error) {
-    if (isAbortError(error, input.signal)) {
-      const reason = input.signal?.aborted ? readAbortReason(input.signal) : error;
-      emitSpawnCancelled(onEvent, spawnId, input.agent, task, 1, 1, Date.now() - startedAt, reason);
-      throw reason;
-    }
-    emitSpawnEvent(onEvent, {
-      type: "spawn.failed",
-      checked: true,
-      spawnId,
-      agent: input.agent,
-      task,
-      attempt: 1,
-      maxAttempts: 1,
-      durationMs: Date.now() - startedAt,
-      error: formatSpawnError(error)
-    });
-    throw error;
-  }
-}
-function runObservedSpawn(moduleSink, input, operation) {
-  const otelSink = input.otelSink ?? moduleSink ?? getActiveOtelSink();
-  const cwd = input.cwd ?? readCurrentWorkingDirectory();
-  const span = safeStartSpan(otelSink, "agent.spawn", {
-    agent: input.agent,
-    mode: input.mode ?? DEFAULT_SPAWN_MODE,
-    cwd
-  });
-  const deactivateSpan = activateOtelSpan(span);
-  safeAddEvent(span, "prompt", { prompt: input.prompt });
-  const promise = (async () => {
-    try {
-      const result = await operation();
-      safeAddEvent(span, "summary", { summary: result.summary });
-      safeAddEvent(span, "exit", {
-        exitCode: result.exitCode,
-        durationMs: result.durationMs
-      });
-      return result;
-    } catch (error) {
-      safeRecordException(otelSink, span, error);
-      throw error;
-    } finally {
-      deactivateSpan();
-      safeEndSpan(span);
-    }
-  })();
-  bindOtelSpan(promise, span);
-  return promise;
-}
-function readCurrentWorkingDirectory() {
-  try {
-    return process.cwd();
-  } catch (error) {
-    throw new Error(`Unable to resolve current working directory: ${formatSpawnError(error)}`);
-  }
-}
-async function runSpawnRetry(spawnAgent, input, retryOptions, onEvent, spawnId) {
-  const task = resolveTaskLabel(input);
-  const startedAt = Date.now();
-  for (let attempt = 1; attempt <= retryOptions.maxAttempts; attempt += 1) {
-    try {
-      throwIfAborted2(input.signal);
-    } catch (error2) {
-      emitSpawnCancelled(
-        onEvent,
-        spawnId,
-        input.agent,
-        task,
-        attempt,
-        retryOptions.maxAttempts,
-        Date.now() - startedAt,
-        error2
-      );
-      throw error2;
-    }
-    emitSpawnEvent(onEvent, {
-      type: "spawn.started",
-      spawnId,
-      agent: input.agent,
-      task,
-      attempt,
-      maxAttempts: retryOptions.maxAttempts
-    });
-    let result;
-    try {
-      recordActiveSpawnAttempt();
-      result = validateSpawnResult(await spawnAgent(toProviderSpawnInput(input)));
-      throwIfAborted2(input.signal);
-    } catch (error2) {
-      if (isAbortError(error2, input.signal)) {
-        const reason = input.signal?.aborted ? readAbortReason(input.signal) : error2;
-        emitSpawnCancelled(
-          onEvent,
-          spawnId,
-          input.agent,
-          task,
-          attempt,
-          retryOptions.maxAttempts,
-          Date.now() - startedAt,
-          reason
-        );
-        throw reason;
-      }
-      if (attempt >= retryOptions.maxAttempts) {
-        emitFinalSpawnFailure(
-          onEvent,
-          spawnId,
-          input.agent,
-          task,
-          attempt,
-          retryOptions.maxAttempts,
-          Date.now() - startedAt,
-          error2
-        );
-        throw error2;
-      }
-      let retryable2;
-      try {
-        retryable2 = retryOptions.isErrorRetryable(error2);
-      } catch (classifierError) {
-        emitFinalSpawnFailure(
-          onEvent,
-          spawnId,
-          input.agent,
-          task,
-          attempt,
-          retryOptions.maxAttempts,
-          Date.now() - startedAt,
-          classifierError
-        );
-        throw classifierError;
-      }
-      if (!retryable2) {
-        emitFinalSpawnFailure(
-          onEvent,
-          spawnId,
-          input.agent,
-          task,
-          attempt,
-          retryOptions.maxAttempts,
-          Date.now() - startedAt,
-          error2
-        );
-        throw error2;
-      }
-      try {
-        await retryOrThrow(
-          error2,
-          input,
-          retryOptions,
-          onEvent,
-          spawnId,
-          task,
-          attempt,
-          Date.now() - startedAt
-        );
-      } catch (retryError) {
-        if (isAbortError(retryError, input.signal)) {
-          emitSpawnCancelled(
-            onEvent,
-            spawnId,
-            input.agent,
-            task,
-            attempt,
-            retryOptions.maxAttempts,
-            Date.now() - startedAt,
-            retryError
-          );
-        }
-        throw retryError;
-      }
-      continue;
-    }
-    recordActiveSpawnUsage(result.usage);
-    if (result.exitCode === 0) {
-      emitSpawnEvent(onEvent, {
-        type: "spawn.succeeded",
-        spawnId,
-        agent: input.agent,
-        task,
-        attempt,
-        maxAttempts: retryOptions.maxAttempts,
-        durationMs: Date.now() - startedAt
-      });
-      return result;
-    }
-    const error = new AgentSpawnError(result);
-    if (attempt >= retryOptions.maxAttempts) {
-      emitFinalSpawnFailure(
-        onEvent,
-        spawnId,
-        input.agent,
-        task,
-        attempt,
-        retryOptions.maxAttempts,
-        Date.now() - startedAt,
-        error,
-        input.check
-      );
-      if (input.check) {
-        throw error;
-      }
-      return result;
-    }
-    let retryable;
-    try {
-      retryable = retryOptions.isRetryable(result);
-    } catch (classifierError) {
-      emitFinalSpawnFailure(
-        onEvent,
-        spawnId,
-        input.agent,
-        task,
-        attempt,
-        retryOptions.maxAttempts,
-        Date.now() - startedAt,
-        classifierError
-      );
-      throw classifierError;
-    }
-    if (!retryable) {
-      emitFinalSpawnFailure(
-        onEvent,
-        spawnId,
-        input.agent,
-        task,
-        attempt,
-        retryOptions.maxAttempts,
-        Date.now() - startedAt,
-        error,
-        input.check
-      );
-      if (input.check) {
-        throw error;
-      }
-      return result;
-    }
-    try {
-      await scheduleRetry(error, input, retryOptions, onEvent, spawnId, task, attempt);
-    } catch (retryError) {
-      if (isAbortError(retryError, input.signal)) {
-        emitSpawnCancelled(
-          onEvent,
-          spawnId,
-          input.agent,
-          task,
-          attempt,
-          retryOptions.maxAttempts,
-          Date.now() - startedAt,
-          retryError
-        );
-      }
-      throw retryError;
-    }
-  }
-  throw new Error("agent.spawn.retry reached an unreachable retry state.");
-}
-function emitSpawnCancelled(onEvent, spawnId, agent, task, attempt, maxAttempts, durationMs, error) {
-  emitSpawnEvent(onEvent, {
-    type: "spawn.cancelled",
-    spawnId,
-    agent,
-    task,
-    attempt,
-    maxAttempts,
-    durationMs,
-    reason: formatSpawnError(error)
-  });
-}
-async function retryOrThrow(error, input, retryOptions, onEvent, spawnId, task, attempt, durationMs) {
-  if (attempt >= retryOptions.maxAttempts) {
-    emitFinalSpawnFailure(
-      onEvent,
-      spawnId,
-      input.agent,
-      task,
-      attempt,
-      retryOptions.maxAttempts,
-      durationMs,
-      error
-    );
-    throw error;
-  }
-  await scheduleRetry(error, input, retryOptions, onEvent, spawnId, task, attempt);
-}
-async function scheduleRetry(error, input, retryOptions, onEvent, spawnId, task, attempt) {
-  const delayMs = calculateBackoffMs(retryOptions.backoffMs, attempt);
-  emitSpawnEvent(onEvent, {
-    type: "spawn.retry",
-    spawnId,
-    agent: input.agent,
-    task,
-    attempt,
-    maxAttempts: retryOptions.maxAttempts,
-    delayMs,
-    error: formatSpawnError(error)
-  });
-  await sleep(delayMs, input.signal);
-}
-function emitFinalSpawnFailure(onEvent, spawnId, agent, task, attempt, maxAttempts, durationMs, error, checked = true) {
-  emitSpawnEvent(onEvent, {
-    type: "spawn.failed",
-    checked,
-    spawnId,
-    agent,
-    task,
-    attempt,
-    maxAttempts,
-    durationMs,
-    error: formatSpawnError(error)
-  });
-}
-function emitSpawnEvent(onEvent, event) {
-  try {
-    const agent = sanitizeLifecycleText(event.agent, 48) || "agent";
-    const result = onEvent?.({ ...event, agent });
-    if (isPromiseLike(result)) {
-      void result.catch((error) => warnSpawnEventObserverFailure(error));
-    }
-  } catch (error) {
-    warnSpawnEventObserverFailure(error);
-  }
-}
-function isPromiseLike(value) {
-  return typeof value === "object" && value !== null && "catch" in value && typeof value.catch === "function";
-}
-function warnSpawnEventObserverFailure(error) {
-  console.warn(`Agent spawn event observer failed: ${formatSpawnError(error)}`);
-}
-function createTaskLabel(prompt) {
-  const lines = prompt.split("\n").map((line) => line.trim());
-  const taskHeadingIndex = lines.indexOf("# Task");
-  const relevantLines = taskHeadingIndex < 0 ? lines : lines.slice(taskHeadingIndex + 1);
-  const firstLine = sanitizeLifecycleText(
-    relevantLines.find((line) => line.length > 0) ?? "agent task",
-    72
-  );
-  if (firstLine.length === 0) {
-    return "agent task";
-  }
-  return firstLine.length > 72 ? `${firstLine.slice(0, 71)}\u2026` : firstLine;
-}
-function resolveTaskLabel(input) {
-  return input.label ?? createTaskLabel(input.prompt);
-}
-function isAbortError(error, signal) {
-  return signal?.aborted === true || readErrorField(error, "name") === "AbortError";
-}
-function formatSpawnError(error) {
-  return sanitizeLifecycleText(readErrorField(error, "message") ?? String(error), 400);
-}
-function sanitizeLifecycleText(value, maxLength) {
-  let sanitized = "";
-  for (const character of value) {
-    const code = character.charCodeAt(0);
-    if (character === "\n" || character === "\r" || character === "	" || code < 32 || code === 127) {
-      sanitized += " ";
-    } else {
-      sanitized += character;
-    }
-  }
-  const compact = sanitized.split(" ").filter((part) => part.length > 0).join(" ");
-  return compact.length > maxLength ? `${compact.slice(0, maxLength - 1)}\u2026` : compact;
-}
-function readErrorField(error, field) {
-  if (typeof error !== "object" || error === null || !(field in error)) {
-    return void 0;
-  }
-  const value = error[field];
-  return typeof value === "string" ? value : void 0;
-}
-function normalizeRetryOptions(retryOptions) {
-  if (!isRecord2(retryOptions)) {
-    throw new Error("Agent spawn retry options must be an object.");
-  }
-  const maxAttempts = readFiniteNumber(
-    getOwnProperty(retryOptions, "maxAttempts"),
-    "Agent spawn retry maxAttempts"
-  );
-  if (!Number.isInteger(maxAttempts) || maxAttempts < 1) {
-    throw new Error("Agent spawn retry maxAttempts must be an integer greater than or equal to 1.");
-  }
-  if (maxAttempts > 5) {
-    throw new Error("Agent spawn retry maxAttempts must not exceed 5.");
-  }
-  const backoffMs = readNonNegativeFiniteNumber(
-    getOwnProperty(retryOptions, "backoffMs"),
-    "Agent spawn retry backoffMs"
-  );
-  const isRetryableValue = getOwnProperty(retryOptions, "isRetryable");
-  if (isRetryableValue !== void 0 && typeof isRetryableValue !== "function") {
-    throw new Error("Agent spawn retry isRetryable must be a function.");
-  }
-  const isRetryable = isRetryableValue === void 0 ? defaultIsRetryable : isRetryableValue;
-  const isErrorRetryableValue = getOwnProperty(retryOptions, "isErrorRetryable");
-  if (isErrorRetryableValue !== void 0 && typeof isErrorRetryableValue !== "function") {
-    throw new Error("Agent spawn retry isErrorRetryable must be a function.");
-  }
-  return createNullRecord({
-    maxAttempts,
-    backoffMs,
-    isErrorRetryable: isErrorRetryableValue === void 0 ? () => true : isErrorRetryableValue,
-    isRetryable
-  });
-}
-function defaultIsRetryable(result) {
-  return result.exitCode === 1 || result.exitCode === 124 || result.exitCode === 125 || result.exitCode === 137;
-}
-var oneAttemptRetryOptions = {
-  maxAttempts: 1,
-  backoffMs: 0,
-  isErrorRetryable: () => false,
-  isRetryable: () => false
-};
-function calculateBackoffMs(baseBackoffMs, completedAttempt) {
-  return Math.min(baseBackoffMs * 2 ** (completedAttempt - 1), 3e4);
-}
-function sleep(delayMs, signal) {
-  throwIfAborted2(signal);
-  return new Promise((resolve3, reject) => {
-    const timeout = setTimeout(() => {
-      signal?.removeEventListener("abort", onAbort);
-      resolve3();
-    }, delayMs);
-    const onAbort = () => {
-      clearTimeout(timeout);
-      reject(readAbortReason(signal));
-    };
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}
-function throwIfAborted2(signal) {
-  if (signal?.aborted) {
-    throw readAbortReason(signal);
-  }
-}
-function readAbortReason(signal) {
-  if (signal?.reason !== void 0) return signal.reason;
-  const error = new Error("Agent spawn retry aborted");
-  error.name = "AbortError";
-  return error;
-}
-function resolveSpawnInput(agentDef, options) {
-  const definition = normalizeAgentDefinition(agentDef);
-  const normalizedOptions = normalizeSpawnOptions(options);
-  const mode = normalizedOptions.mode ?? definition.mode;
-  if (mode !== void 0 && !supportsSpawnMode(definition.agent, mode)) {
-    throw new Error(`Agent "${definition.agent}" does not support mode "${mode}".`);
-  }
-  return createNullRecord({
-    agent: definition.agent,
-    prompt: prependSystemPrompt(definition.prompt, normalizedOptions.prompt),
-    check: normalizedOptions.check ?? false,
-    ...normalizedOptions.label !== void 0 ? { label: normalizedOptions.label } : {},
-    ...normalizedOptions.model ?? definition.model ? { model: normalizedOptions.model ?? definition.model } : {},
-    ...normalizedOptions.mode ?? definition.mode ? { mode: normalizedOptions.mode ?? definition.mode } : {},
-    ...normalizedOptions.cwd ?? definition.cwd ? { cwd: normalizedOptions.cwd ?? definition.cwd } : {},
-    ...normalizedOptions.otelSink !== void 0 ? { otelSink: normalizedOptions.otelSink } : {},
-    ...normalizedOptions.mcp ?? definition.mcp ? { mcp: normalizedOptions.mcp ?? definition.mcp } : {},
-    ...normalizedOptions.timeoutMs !== void 0 ? { timeoutMs: normalizedOptions.timeoutMs } : {},
-    ...normalizedOptions.signal !== void 0 ? { signal: normalizedOptions.signal } : {}
-  });
-}
-function normalizeAgentDefinition(agentDef) {
-  if (typeof agentDef === "string") {
-    return createNullRecord({
-      agent: readRequiredAgent(agentDef)
-    });
-  }
-  if (!isRecord2(agentDef)) {
-    throw new Error("Agent definition must be a string or object.");
-  }
-  const prompt = getOwnProperty(agentDef, "prompt");
-  const model = getOwnProperty(agentDef, "model");
-  const mode = getOwnProperty(agentDef, "mode");
-  const cwd = getOwnProperty(agentDef, "cwd");
-  const mcp = getOwnProperty(agentDef, "mcp");
-  return createNullRecord({
-    agent: readRequiredAgent(getOwnProperty(agentDef, "agent")),
-    ...prompt === void 0 ? {} : { prompt: readOptionalString(prompt, "Agent definition prompt") },
-    ...model === void 0 ? {} : { model: readOptionalString(model, "Agent definition model") },
-    ...mode === void 0 ? {} : { mode: readSpawnMode(mode, "Agent definition mode") },
-    ...cwd === void 0 ? {} : { cwd: readOptionalString(cwd, "Agent definition cwd") },
-    ...mcp === void 0 ? {} : { mcp: readMcpConfig(mcp, "Agent definition mcp") }
-  });
-}
-function normalizeSpawnOptions(options) {
-  if (!isRecord2(options)) {
-    throw new Error("Agent spawn options must be an object.");
-  }
-  const label = getOwnProperty(options, "label");
-  const model = getOwnProperty(options, "model");
-  const mode = getOwnProperty(options, "mode");
-  const cwd = getOwnProperty(options, "cwd");
-  const otelSink = getOwnProperty(options, "otelSink");
-  const mcp = getOwnProperty(options, "mcp");
-  const timeoutMs = getOwnProperty(options, "timeoutMs");
-  const signal = getOwnProperty(options, "signal");
-  return createNullRecord({
-    prompt: readRequiredPrompt(getOwnProperty(options, "prompt")),
-    check: readOptionalBoolean(getOwnProperty(options, "check"), "Agent spawn options check"),
-    ...label === void 0 ? {} : { label: readRequiredString(label, "Agent spawn options label") },
-    ...model === void 0 ? {} : { model: readOptionalString(model, "Agent spawn options model") },
-    ...mode === void 0 ? {} : { mode: readSpawnMode(mode, "Agent spawn options mode") },
-    ...cwd === void 0 ? {} : { cwd: readOptionalString(cwd, "Agent spawn options cwd") },
-    ...otelSink === void 0 ? {} : { otelSink: readOtelSink(otelSink) },
-    ...mcp === void 0 ? {} : { mcp: readMcpConfig(mcp, "Agent spawn options mcp") },
-    ...timeoutMs === void 0 ? {} : {
-      timeoutMs: readNonNegativeFiniteNumber(timeoutMs, "Agent spawn options timeoutMs")
-    },
-    ...signal === void 0 ? {} : { signal: readAbortSignal(signal, "Agent spawn options signal") }
-  });
-}
-function toProviderSpawnInput(input) {
-  const { label: ignoredLabel, check: ignoredCheck, ...providerInput } = input;
-  void ignoredLabel;
-  void ignoredCheck;
-  return providerInput;
-}
-function readOptionalBoolean(value, label) {
-  if (value === void 0) return void 0;
-  if (typeof value !== "boolean") throw new Error(`${label} must be a boolean.`);
-  return value;
-}
-function validateSpawnResult(result) {
-  if (!isRecord2(result)) {
-    throw new Error("spawnAgent must resolve to an object result.");
-  }
-  const usage = getOwnProperty(result, "usage");
-  return createNullRecord({
-    exitCode: readFiniteNumber(getOwnProperty(result, "exitCode"), "spawnAgent result exitCode"),
-    stdout: readOptionalString(getOwnProperty(result, "stdout"), "spawnAgent result stdout") ?? "",
-    stderr: readOptionalString(getOwnProperty(result, "stderr"), "spawnAgent result stderr") ?? "",
-    summary: readOptionalString(getOwnProperty(result, "summary"), "spawnAgent result summary") ?? "",
-    durationMs: readNonNegativeFiniteNumber(
-      getOwnProperty(result, "durationMs"),
-      "spawnAgent result durationMs"
-    ),
-    ...usage === void 0 ? {} : { usage: readSpawnUsage(usage) }
-  });
-}
-function recordActiveSpawnUsage(usage) {
-  activeUsageAccumulator.getStore()?.record(usage);
-}
-function recordActiveSpawnAttempt() {
-  activeUsageAccumulator.getStore()?.beginAttempt?.();
-}
-function recordActiveSpawnStart() {
-  activeUsageAccumulator.getStore()?.beginSpawn?.();
-}
-function readSpawnUsage(value) {
-  if (!isRecord2(value)) {
-    throw new Error("spawnAgent result usage must be an object.");
-  }
-  const cachedTokens = getOwnProperty(value, "cachedTokens");
-  const costUsd = getOwnProperty(value, "costUsd");
-  return createNullRecord({
-    inputTokens: readNonNegativeFiniteNumber(
-      getOwnProperty(value, "inputTokens"),
-      "spawnAgent result usage inputTokens"
-    ),
-    outputTokens: readNonNegativeFiniteNumber(
-      getOwnProperty(value, "outputTokens"),
-      "spawnAgent result usage outputTokens"
-    ),
-    ...cachedTokens === void 0 ? {} : {
-      cachedTokens: readNonNegativeFiniteNumber(
-        cachedTokens,
-        "spawnAgent result usage cachedTokens"
-      )
-    },
-    ...costUsd === void 0 ? {} : {
-      costUsd: readNonNegativeFiniteNumber(costUsd, "spawnAgent result usage costUsd")
-    }
-  });
-}
-function prependSystemPrompt(systemPrompt, userPrompt) {
-  if (systemPrompt === void 0 || systemPrompt.trim().length === 0) {
-    return userPrompt;
-  }
-  return `${systemPrompt}
-
-# Task
-
-${userPrompt}`;
-}
-function createSpawnFailureMessage(result) {
-  const stderr = result.stderr.trim();
-  const summary = result.summary.trim();
-  return stderr.length > 0 ? `Agent spawn failed with exit code ${result.exitCode}: ${stderr}` : summary.length > 0 ? `Agent spawn failed with exit code ${result.exitCode}: ${summary}` : `Agent spawn failed with exit code ${result.exitCode}.`;
-}
-function readRequiredAgent(value) {
-  const agent = readOptionalString(value, "Agent definition agent")?.trim();
-  if (agent === void 0 || agent.length === 0) {
-    throw new Error("Agent definition must define a non-empty agent.");
-  }
-  return agent;
-}
-function readRequiredString(value, label) {
-  const text = readOptionalString(value, label)?.trim();
-  if (text === void 0 || text.length === 0) {
-    throw new Error(`${label} must be a non-empty string.`);
-  }
-  return text;
-}
-function readRequiredPrompt(value) {
-  const prompt = readOptionalString(value, "Agent spawn options prompt");
-  if (prompt === void 0 || prompt.trim().length === 0) {
-    throw new Error("Agent spawn options must define a non-empty prompt.");
-  }
-  return prompt;
-}
-function readSpawnMode(value, label) {
-  if (value === "read" || value === "edit" || value === "auto" || value === "yolo") {
-    return value;
-  }
-  throw new Error(`${label} must be one of: read, edit, auto, yolo.`);
-}
-function readMcpConfig(value, label) {
-  if (!isRecord2(value)) {
-    throw new Error(`${label} must be an object.`);
-  }
-  const entries = Object.entries(value).map(
-    ([name, server]) => [name, readMcpServer(server, `${label}.${name}`)]
-  );
-  return createNullRecord(Object.fromEntries(entries));
-}
-function readMcpServer(value, label) {
-  if (!isRecord2(value)) {
-    throw new Error(`${label} must be an object.`);
-  }
-  const args = getOwnProperty(value, "args");
-  const env = getOwnProperty(value, "env");
-  const timeout = getOwnProperty(value, "timeout");
-  return createNullRecord({
-    command: readNonEmptyString(getOwnProperty(value, "command"), `${label}.command`),
-    ...args === void 0 ? {} : { args: readStringArray(args, `${label}.args`) },
-    ...env === void 0 ? {} : { env: readStringRecord(env, `${label}.env`) },
-    ...timeout === void 0 ? {} : { timeout: readPositiveFiniteNumber(timeout, `${label}.timeout`) }
-  });
-}
-function readStringArray(value, label) {
-  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
-    throw new Error(`${label} must be an array of strings.`);
-  }
-  return [...value];
-}
-function readStringRecord(value, label) {
-  if (!isRecord2(value)) {
-    throw new Error(`${label} must be an object.`);
-  }
-  const entries = Object.entries(value);
-  if (entries.some(([, entry]) => typeof entry !== "string")) {
-    throw new Error(`${label} must be a string record.`);
-  }
-  return Object.fromEntries(entries);
-}
-function readOptionalString(value, label) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (typeof value !== "string") {
-    throw new Error(`${label} must be a string.`);
-  }
-  return value;
-}
-function readNonEmptyString(value, label) {
-  const text = readOptionalString(value, label);
-  if (text === void 0 || text.trim().length === 0) {
-    throw new Error(`${label} must be a non-empty string.`);
-  }
-  return text;
-}
-function readFiniteNumber(value, label) {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    throw new Error(`${label} must be a finite number.`);
-  }
-  return value;
-}
-function readNonNegativeFiniteNumber(value, label) {
-  const number = readFiniteNumber(value, label);
-  if (number < 0) {
-    throw new Error(`${label} must be a non-negative finite number.`);
-  }
-  return number;
-}
-function readPositiveFiniteNumber(value, label) {
-  const number = readFiniteNumber(value, label);
-  if (number <= 0) {
-    throw new Error(`${label} must be a positive finite number.`);
-  }
-  return number;
-}
-function readAbortSignal(value, label) {
-  if (typeof value !== "object" || value === null || typeof value.aborted !== "boolean" || typeof value.addEventListener !== "function" || typeof value.removeEventListener !== "function") {
-    throw new Error(`${label} must be an AbortSignal.`);
-  }
-  return value;
-}
-function readOtelSink(value) {
-  if (!isRecord2(value) || typeof value.startSpan !== "function" || typeof value.recordException !== "function") {
-    throw new Error("Agent spawn options otelSink must be an OtelSink.");
-  }
-  return value;
-}
-function getOwnProperty(value, name) {
-  return hasOwnProperty(value, name) ? value[name] : void 0;
-}
-function hasOwnProperty(value, name) {
-  return Object.prototype.hasOwnProperty.call(value, name);
-}
-function createNullRecord(value) {
-  return Object.assign(/* @__PURE__ */ Object.create(null), value);
-}
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-// packages/safejs/src/modules/fail.ts
-var HarnessFailure = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "HarnessFailure";
-  }
-};
-function makeFailModule() {
-  function fail(message) {
-    throw new HarnessFailure(readNonEmptyString2(message, "Harness failure message"));
-  }
-  return {
-    default: fail
-  };
-}
-function readNonEmptyString2(value, label) {
-  if (typeof value !== "string") {
-    throw new Error(`${label} must be a non-empty string.`);
-  }
-  if (value.trim().length === 0) {
-    throw new Error(`${label} must be a non-empty string.`);
-  }
-  return value;
-}
-
-// packages/safejs/src/modules/fs.ts
-import { constants as nodeFsConstants } from "node:fs";
-import * as nodeFsPromises from "node:fs/promises";
-import { dirname as dirname2, isAbsolute as isAbsolute2, resolve as resolve2 } from "node:path";
-import { inspect } from "node:util";
-import * as nodeUtil from "node:util";
-
-// packages/safejs/src/modules/canonical-path.ts
-import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
-var MISSING_PATH_CODES = ["ENOENT", "ENOTDIR"];
-var NOT_A_SYMLINK_CODES = [...MISSING_PATH_CODES, "EINVAL"];
-var MAX_SYMLINK_FOLLOWS = 32;
-async function resolveCanonicalPath({ realpath, readlink }, path) {
-  const missingSegments = [];
-  let current = path;
-  let follows = 0;
-  while (true) {
-    try {
-      const canonicalCurrent = await realpath(current);
-      return resolve(canonicalCurrent, ...missingSegments.reverse());
-    } catch (error) {
-      if (!MISSING_PATH_CODES.includes(getOwnErrorCode(error) ?? "")) {
-        throw error;
-      }
-      const target = await readSymlinkTarget(readlink, current);
-      if (target !== void 0) {
-        if (++follows > MAX_SYMLINK_FOLLOWS) {
-          throw createLoopError(path);
-        }
-        current = isAbsolute(target) ? resolve(target) : resolve(dirname(current), target);
-        continue;
-      }
-      const parent = dirname(current);
-      if (parent === current) {
-        return resolve(path);
-      }
-      missingSegments.push(basename(current));
-      current = parent;
-    }
-  }
-}
-async function readSymlinkTarget(readlink, path) {
-  try {
-    return await readlink(path);
-  } catch (error) {
-    if (NOT_A_SYMLINK_CODES.includes(getOwnErrorCode(error) ?? "")) {
-      return void 0;
-    }
-    throw error;
-  }
-}
-function createLoopError(path) {
-  const error = new Error(
-    `ELOOP: too many symbolic links encountered, realpath '${path}'`
-  );
-  error.code = "ELOOP";
-  return error;
-}
-async function containsPath(stat, canonicalRoot, canonicalPath) {
-  if (containsCanonicalSpelling(canonicalRoot, canonicalPath)) {
-    return true;
-  }
-  return descendsFromRoot(stat, canonicalRoot, canonicalPath);
-}
-async function isSamePath(stat, canonicalLeft, canonicalRight) {
-  if (canonicalLeft === canonicalRight) {
-    return true;
-  }
-  const [left, right] = await Promise.all([
-    readIdentity(stat, canonicalLeft),
-    readIdentity(stat, canonicalRight)
-  ]);
-  return left !== void 0 && right !== void 0 && left.dev === right.dev && left.ino === right.ino;
-}
-function containsCanonicalSpelling(canonicalRoot, canonicalPath) {
-  const relativePath = relative(canonicalRoot, canonicalPath);
-  return !(relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath));
-}
-async function descendsFromRoot(stat, canonicalRoot, canonicalPath) {
-  const root = await readIdentity(stat, canonicalRoot);
-  if (root === void 0) {
-    return false;
-  }
-  let current = canonicalPath;
-  while (true) {
-    const identity = await readIdentity(stat, current);
-    if (identity !== void 0 && identity.dev === root.dev && identity.ino === root.ino) {
-      return true;
-    }
-    const parent = dirname(current);
-    if (parent === current) {
-      return false;
-    }
-    current = parent;
-  }
-}
-async function readIdentity(stat, path) {
-  try {
-    const { dev, ino } = await stat(path);
-    return { dev, ino };
-  } catch (error) {
-    if (MISSING_PATH_CODES.includes(getOwnErrorCode(error) ?? "")) {
-      return void 0;
-    }
-    throw error;
-  }
-}
-
-// packages/safejs/src/modules/fs.ts
-var BUFFER_BY_DEFAULT = {
-  readFile: true,
-  readdir: false,
-  readlink: false,
-  realpath: false,
-  mkdtemp: false
-};
-var REFUSED_OPTION_REASONS = {
-  signal: "the sandbox has no AbortController, and cancelling a run is the host's to request rather than the script's",
-  // @types/node declares this on fs/promises stat and lstat and types
-  // `throwIfNoEntry: false` as answering `Stats | undefined`, but the typings are
-  // ahead of node: only the synchronous API reads the option. Forwarding it would
-  // leave a script holding the ENOENT rejection the typings told it to expect
-  // undefined for, so it is refused rather than dropped.
-  throwIfNoEntry: "only node's synchronous stat reads it and fs/promises rejects a missing path whatever it says, so catch the ENOENT rejection instead",
-  // cp's filter is a callback the host would invoke, which a sandbox closure can cross the
-  // bridge to serve. It is refused for what happens around the call rather than during it:
-  // the digest that identifies a host call across a snapshot is built by stringifying the
-  // arguments, and a function does not survive that, so cp(filter: keep) and
-  // cp(filter: drop) are one call to the resume machinery.
-  filter: "a closure is dropped from the digest that identifies a host call across a snapshot, so a resumed run could reconcile against a copy that took a different set of files, and under a root it would read the rewritten host paths rather than the ones the script wrote \u2014 walk the tree with readdir and copy the entries you want instead"
-};
-var UNKNOWN_OPTION_REASON = "node declares no such option for it, and an unrecognised option is refused rather than silently ignored";
-var ROOT_REFUSED_DEREFERENCE_REASON = "a root canonicalizes cp's src and dest but never the paths nested inside the tree, so node would copy an escaping link's target inside root where the script could read it \u2014 copy without dereference and a nested link stays a link the root still refuses to read through";
-var FS_OPTION_SURFACE = {
-  appendFile: {
-    argument: 2,
-    honoured: ["encoding", "mode", "flag", "flush"],
-    // node's appendFile forwards to writeFile, so it honours a signal even though
-    // @types/node does not declare one for it.
-    refused: ["signal"]
-  },
-  // node reads cp's bag from a parameter it names opts rather than options, and validates
-  // every key it knows — while still ignoring one it does not, which is what the unknown
-  // refusal covers. mode is copyFile's flag set rather than a permission.
-  cp: {
-    argument: 2,
-    honoured: [
-      "dereference",
-      "errorOnExist",
-      "force",
-      "mode",
-      "preserveTimestamps",
-      "recursive",
-      "verbatimSymlinks"
-    ],
-    refused: ["filter"]
-  },
-  lstat: { argument: 1, honoured: ["bigint"], refused: ["throwIfNoEntry"] },
-  mkdir: { argument: 1, honoured: ["recursive", "mode"], refused: [] },
-  mkdtemp: { argument: 1, honoured: ["encoding"], refused: [] },
-  readFile: { argument: 1, honoured: ["encoding", "flag"], refused: ["signal"] },
-  readdir: { argument: 1, honoured: ["encoding", "withFileTypes", "recursive"], refused: [] },
-  readlink: { argument: 1, honoured: ["encoding"], refused: [] },
-  realpath: { argument: 1, honoured: ["encoding"], refused: [] },
-  rm: { argument: 1, honoured: ["force", "recursive", "maxRetries", "retryDelay"], refused: [] },
-  rmdir: { argument: 1, honoured: ["recursive", "maxRetries", "retryDelay"], refused: [] },
-  stat: { argument: 1, honoured: ["bigint"], refused: ["throwIfNoEntry"] },
-  writeFile: { argument: 2, honoured: ["encoding", "mode", "flag", "flush"], refused: ["signal"] }
-};
-var STAT_NUMBER_FIELDS = [
-  "dev",
-  "mode",
-  "nlink",
-  "uid",
-  "gid",
-  "rdev",
-  "blksize",
-  "ino",
-  "size",
-  "blocks",
-  "atimeMs",
-  "mtimeMs",
-  "ctimeMs",
-  "birthtimeMs"
-];
-var FILE_TYPE_PREDICATES = [
-  "isFile",
-  "isDirectory",
-  "isSymbolicLink",
-  "isBlockDevice",
-  "isCharacterDevice",
-  "isFIFO",
-  "isSocket"
-];
-var BUFFER_ENCODING = "buffer";
-var FS_SYSCALLS = {
-  access: "access",
-  appendFile: "open",
-  chmod: "chmod",
-  copyFile: "copyfile",
-  // node's cp is its own JavaScript layer rather than a syscall wrapper, so it blames the
-  // fs function by name: its ERR_FS_CP_* errors carry syscall 'cp'.
-  cp: "cp",
-  link: "link",
-  lstat: "lstat",
-  mkdir: "mkdir",
-  mkdtemp: "mkdtemp",
-  readFile: "open",
-  readdir: "scandir",
-  readlink: "readlink",
-  realpath: "realpath",
-  rename: "rename",
-  rm: "lstat",
-  rmdir: "rmdir",
-  stat: "stat",
-  symlink: "symlink",
-  truncate: "open",
-  utimes: "utime",
-  writeFile: "open"
-};
-var FS_PATH_ARGUMENTS = {
-  access: ["path"],
-  appendFile: ["path"],
-  chmod: ["path"],
-  copyFile: ["src", "dest"],
-  // node blames these by the same names it uses for copyFile's two paths.
-  cp: ["src", "dest"],
-  link: ["existingPath", "newPath"],
-  lstat: ["path"],
-  mkdir: ["path"],
-  mkdtemp: ["prefix"],
-  readFile: ["path"],
-  readdir: ["path"],
-  readlink: ["oldPath"],
-  realpath: ["path"],
-  rename: ["oldPath", "newPath"],
-  rm: ["path"],
-  rmdir: ["path"],
-  stat: ["path"],
-  symlink: ["target", "path"],
-  truncate: ["path"],
-  utimes: ["path"],
-  writeFile: ["path"]
-};
-var ACCESS_DENIED_CODE = "EACCES";
-var INVALID_ARGUMENT_CODE = "ERR_INVALID_ARG_VALUE";
-var INVALID_ARGUMENT_TYPE_CODE = "ERR_INVALID_ARG_TYPE";
-var NULL_BYTE = "\0";
-var [ACCESS_DENIED_ERRNO, ACCESS_DENIED_MESSAGE] = readSystemError(ACCESS_DENIED_CODE);
-function makeFsModule(options = {}) {
-  assertSupportedPlatform();
-  const implementation = options.fs ?? nodeFsPromises;
-  const fs = options.root === void 0 ? implementation : makeRootedFs(implementation, options.root);
-  return {
-    access: bind(fs, "access", "re-issue"),
-    appendFile: bind(fs, "appendFile", "read-side-effect"),
-    chmod: bind(fs, "chmod", "read-side-effect"),
-    copyFile: bind(fs, "copyFile", "read-side-effect"),
-    cp: bind(fs, "cp", "read-side-effect"),
-    link: bind(fs, "link", "read-side-effect"),
-    lstat: bindStat(fs, "lstat"),
-    mkdir: bind(fs, "mkdir", "read-side-effect"),
-    // Creates a directory, so it cannot be re-issued on resume like the other
-    // string-result operations, but its name still crosses as a Buffer for a buffer
-    // encoding and so goes through the same guard.
-    mkdtemp: bindStringResult(fs, "mkdtemp", "read-side-effect"),
-    readFile: bindStringResult(fs, "readFile"),
-    readdir: bindReaddir(fs),
-    readlink: bindStringResult(fs, "readlink"),
-    realpath: bindStringResult(fs, "realpath"),
-    rename: bind(fs, "rename", "read-side-effect"),
-    rm: bind(fs, "rm", "read-side-effect"),
-    rmdir: bind(fs, "rmdir", "read-side-effect"),
-    stat: bindStat(fs, "stat"),
-    symlink: bind(fs, "symlink", "read-side-effect"),
-    truncate: bind(fs, "truncate", "read-side-effect"),
-    utimes: bind(fs, "utimes", "read-side-effect"),
-    writeFile: bind(fs, "writeFile", "read-side-effect"),
-    constants: {
-      F_OK: nodeFsConstants.F_OK,
-      R_OK: nodeFsConstants.R_OK,
-      W_OK: nodeFsConstants.W_OK,
-      X_OK: nodeFsConstants.X_OK,
-      COPYFILE_EXCL: nodeFsConstants.COPYFILE_EXCL
-    }
-  };
-}
-function assertSupportedPlatform() {
-  if (process.platform !== "win32") {
-    return;
-  }
-  throw new Error(
-    "SafeJS's fs module does not support win32: node's fs answers a different code there (EPERM or UNKNOWN where darwin and linux answer EISDIR or ENOTEMPTY), a path carries a drive letter that root confinement has no rule for, and a symlink needs a privilege a script cannot hold. Run on darwin or linux, or build a host module for the surface you need."
-  );
-}
-function bind(fs, name, policy) {
-  return declare(
-    name,
-    policy,
-    (...args) => invoke(fs, name, args)
-  );
-}
-function bindStringResult(fs, name, policy = "re-issue") {
-  return declare(name, policy, async (...args) => {
-    assertNoBufferResult(name, args[1]);
-    return await invoke(fs, name, args);
-  });
-}
-function bindReaddir(fs) {
-  return declare("readdir", "re-issue", async (...args) => {
-    assertNoBufferResult("readdir", args[1]);
-    const entries = await invoke(fs, "readdir", args);
-    return entries.map((entry) => typeof entry === "string" ? entry : toSandboxDirent(entry));
-  });
-}
-function bindStat(fs, name) {
-  return declare(name, "re-issue", async (...args) => {
-    assertNoBigIntResult(name, args[1]);
-    return toSandboxStats(await invoke(fs, name, args));
-  });
-}
-function declare(name, policy, operation) {
-  const validated = async (...args) => {
-    FS_PATH_ARGUMENTS[name].forEach(
-      (argument, index) => assertSupportedPath(name, argument, args[index])
-    );
-    assertSupportedOptions(name, args);
-    return await operation(...args);
-  };
-  Object.defineProperty(validated, "name", { value: name });
-  declareHostOperation(validated, policy);
-  return validated;
-}
-function invoke(fs, name, args) {
-  return Reflect.apply(fs[name], fs, args);
-}
-function makeRootedFs(fs, root) {
-  if (root.trim().length === 0) {
-    throw new Error("fs module root must be a non-empty string.");
-  }
-  const rooted = {};
-  for (const name of Object.keys(FS_SYSCALLS)) {
-    rooted[name] = async (...args) => {
-      assertRootCanConfineOptions(name, args);
-      return invoke(fs, name, await resolvePathArguments(fs, root, name, args));
-    };
-  }
-  return rooted;
-}
-function assertRootCanConfineOptions(name, args) {
-  if (name !== "cp") {
-    return;
-  }
-  const options = args[FS_OPTION_SURFACE.cp.argument];
-  if (isObjectLike(options) && options.dereference === true) {
-    throw createUnsupportedOptionError("cp", "dereference", ROOT_REFUSED_DEREFERENCE_REASON);
-  }
-}
-async function resolvePathArguments(fs, root, name, args) {
-  const canonicalRoot = await resolveCanonicalPath(readCanonicalPathFs(fs), resolve2(root));
-  const resolved = [...args];
-  if (name === "symlink") {
-    const linkPath = readPath(canonicalRoot, args[1]);
-    resolved[1] = linkPath;
-    await assertInsideRoot(fs, canonicalRoot, name, [
-      readPath(dirname2(linkPath), args[0]),
-      linkPath
-    ]);
-    return resolved;
-  }
-  const paths = FS_PATH_ARGUMENTS[name].map((_, index) => {
-    const path = readPath(canonicalRoot, args[index]);
-    resolved[index] = path;
-    return path;
-  });
-  await assertInsideRoot(fs, canonicalRoot, name, paths);
-  return resolved;
-}
-async function assertInsideRoot(fs, canonicalRoot, name, paths) {
-  for (const path of paths) {
-    if (await escapesRoot(fs, canonicalRoot, path)) {
-      throw createAccessDeniedError(name, paths[0], paths[1]);
-    }
-  }
-}
-async function escapesRoot(fs, canonicalRoot, path) {
-  const canonicalPath = await resolveCanonicalPath(readCanonicalPathFs(fs), path);
-  return !await containsPath(readStat(fs), canonicalRoot, canonicalPath);
-}
-function readCanonicalPathFs(fs) {
-  return {
-    realpath: async (path) => await invoke(fs, "realpath", [path]),
-    readlink: async (path) => await invoke(fs, "readlink", [path])
-  };
-}
-function readStat(fs) {
-  return async (path) => await invoke(fs, "stat", [path]);
-}
-function assertSupportedPath(name, argument, value) {
-  if (typeof value === "string") {
-    if (value.includes(NULL_BYTE)) {
-      throw createNullByteError(argument, value);
-    }
-    return;
-  }
-  const form = readUnsupportedPathForm(value);
-  throw form === void 0 ? createInvalidPathTypeError(argument, value) : createUnsupportedPathError(name, argument, form);
-}
-function readUnsupportedPathForm(value) {
-  if (value instanceof Uint8Array) {
-    return "a Buffer or Uint8Array";
-  }
-  return value instanceof URL ? "a URL" : void 0;
-}
-function createNullByteError(argument, value) {
-  const error = new TypeError(
-    `The argument '${argument}' must be a string, Uint8Array, or URL without null bytes. Received ${inspect(value)}`
-  );
-  error.code = INVALID_ARGUMENT_CODE;
-  return error;
-}
-function createInvalidPathTypeError(argument, value) {
-  const error = new TypeError(
-    `The "${argument}" argument must be of type string or an instance of Buffer or URL. Received ${describeReceivedValue(value)}`
-  );
-  error.code = INVALID_ARGUMENT_TYPE_CODE;
-  return error;
-}
-function createUnsupportedPathError(name, argument, form) {
-  return new TypeError(
-    `fs.${name} cannot accept ${form} as the '${argument}' argument inside SafeJS; pass the path as a string.`
-  );
-}
-function describeReceivedValue(value) {
-  if (value === null || value === void 0) {
-    return String(value);
-  }
-  if (typeof value === "function") {
-    return `function ${value.name}`;
-  }
-  if (typeof value === "object") {
-    const constructorName = value.constructor?.name;
-    return constructorName === void 0 ? inspect(value, { depth: -1 }) : `an instance of ${constructorName}`;
-  }
-  return `type ${typeof value} (${inspect(value)})`;
-}
-function readPath(base, value) {
-  const path = value;
-  return isAbsolute2(path) ? resolve2(path) : resolve2(base, path);
-}
-function createAccessDeniedError(name, path, dest) {
-  const syscall = FS_SYSCALLS[name];
-  const target = dest === void 0 ? `'${path}'` : `'${path}' -> '${dest}'`;
-  const error = new Error(
-    `${ACCESS_DENIED_CODE}: ${ACCESS_DENIED_MESSAGE}, ${syscall} ${target}`
-  );
-  error.code = ACCESS_DENIED_CODE;
-  error.errno = ACCESS_DENIED_ERRNO;
-  error.syscall = syscall;
-  error.path = path;
-  if (dest !== void 0) {
-    error.dest = dest;
-  }
-  return error;
-}
-function readSystemError(code) {
-  const fallback = /* @__PURE__ */ new Map([
-    [process.platform === "win32" ? -4092 : -13, ["EACCES", "permission denied"]]
-  ]);
-  const systemErrors = nodeUtil.getSystemErrorMap?.() ?? fallback;
-  for (const [errno, [name, message]] of systemErrors) {
-    if (name === code) {
-      return [errno, message];
-    }
-  }
-  throw new Error(`node does not define the ${code} system error.`);
-}
-function assertSupportedOptions(name, args) {
-  const surface = FS_OPTION_SURFACE[name];
-  if (surface === void 0 || !isObjectLike(args[surface.argument])) {
-    return;
-  }
-  const options = args[surface.argument];
-  for (const option of surface.refused) {
-    if (option in options) {
-      throw createUnsupportedOptionError(name, option, REFUSED_OPTION_REASONS[option]);
-    }
-  }
-  for (const option in options) {
-    if (!surface.honoured.includes(option)) {
-      throw createUnsupportedOptionError(name, option, UNKNOWN_OPTION_REASON);
-    }
-  }
-}
-function assertNoBufferResult(operation, options) {
-  if (readsBuffer(options, BUFFER_BY_DEFAULT[operation])) {
-    throw createUnsupportedCapabilityError(
-      operation,
-      "return a Buffer",
-      'pass a string encoding such as "utf8"'
-    );
-  }
-}
-function assertNoBigIntResult(operation, options) {
-  if (isObjectLike(options) && options.bigint === true) {
-    throw createUnsupportedCapabilityError(
-      operation,
-      "return BigInt fields",
-      "omit bigint and read the *Ms timestamps instead"
-    );
-  }
-}
-function createUnsupportedOptionError(operation, option, reason) {
-  return createUnsupportedCapabilityError(operation, `honour the '${option}' option`, reason);
-}
-function createUnsupportedCapabilityError(operation, capability, remedy) {
-  return new TypeError(`fs.${operation} cannot ${capability} inside SafeJS; ${remedy}.`);
-}
-function readsBuffer(options, bufferByDefault) {
-  if (typeof options === "string") {
-    return options === BUFFER_ENCODING;
-  }
-  if (options === void 0 || options === null) {
-    return bufferByDefault;
-  }
-  if (!isObjectLike(options)) {
-    return false;
-  }
-  const { encoding } = options;
-  if (encoding === BUFFER_ENCODING) {
-    return true;
-  }
-  return (encoding === void 0 || encoding === null) && bufferByDefault;
-}
-function toSandboxStats(stats) {
-  const numbers = {};
-  for (const field of STAT_NUMBER_FIELDS) {
-    numbers[field] = stats[field];
-  }
-  return { ...numbers, ...toFileTypePredicates(stats) };
-}
-function toSandboxDirent(dirent) {
-  return {
-    name: dirent.name,
-    parentPath: dirent.parentPath,
-    ...toFileTypePredicates(dirent)
-  };
-}
-function toFileTypePredicates(source) {
-  const predicates = {};
-  for (const predicate of FILE_TYPE_PREDICATES) {
-    const result = source[predicate]();
-    predicates[predicate] = () => result;
-  }
-  return predicates;
-}
-function isObjectLike(value) {
-  return typeof value === "object" && value !== null || typeof value === "function";
-}
-
-// packages/safejs/src/modules/harness.ts
-function makeHarnessModule(frontmatter, meta) {
-  const copiedFrontmatter = copyHarnessValue(frontmatter);
-  const constraints = readConstraints(copiedFrontmatter);
-  return {
-    tasks: copyHarnessValue(copiedFrontmatter.tasks),
-    agents: copyHarnessValue(copiedFrontmatter.agents),
-    meta: {
-      kind: copyHarnessValue(meta.kind),
-      version: copyHarnessValue(meta.version),
-      filepath: meta.filepath,
-      frontmatter: copiedFrontmatter
-    },
-    applyConstraints: (prompt) => applyConstraints(prompt, constraints)
-  };
-}
-function copyHarnessValue(value) {
-  return deepCopyToSandbox(value);
-}
-function readConstraints(frontmatter) {
-  const constraints = /* @__PURE__ */ new Set();
-  appendConstraintValues(constraints, frontmatter.principles);
-  appendConstraintValues(constraints, frontmatter.constraints);
-  return [...constraints];
-}
-function appendConstraintValues(constraints, value) {
-  if (!Array.isArray(value)) {
-    return;
-  }
-  for (const item of value) {
-    if (typeof item !== "string") {
-      throw new Error("constraints/principles must be strings");
-    }
-    constraints.add(item);
-  }
-}
-function applyConstraints(prompt, constraints) {
-  if (constraints.length === 0) {
-    return prompt;
-  }
-  const preamble = `CONSTRAINTS (hard rules, honor all):
-${constraints.map((constraint) => `- ${constraint}`).join("\n")}`;
-  return prompt.length === 0 ? preamble : `${preamble}
-
-${prompt}`;
-}
-
-// packages/safejs/src/output-stream.ts
-function createBrokenPipeState() {
-  return { closed: false };
-}
-function createSafeOutputStream(stream, brokenPipe) {
-  return {
-    write(chunk) {
-      if (brokenPipe.closed) {
-        return;
-      }
-      try {
-        stream.write(chunk);
-      } catch (error) {
-        if (isBrokenPipeError(error)) {
-          brokenPipe.closed = true;
-          return;
-        }
-        throw error;
-      }
-    }
-  };
-}
-async function withBrokenPipeGuard(streams, brokenPipe, callback) {
-  const removeListeners = streams.map((stream) => addBrokenPipeListener(stream, brokenPipe));
-  try {
-    return await callback();
-  } finally {
-    for (const removeListener of removeListeners) {
-      removeListener();
-    }
-  }
-}
-function addBrokenPipeListener(stream, brokenPipe) {
-  const onError = (error) => {
-    if (isBrokenPipeError(error)) {
-      brokenPipe.closed = true;
-      return;
-    }
-    throw error;
-  };
-  stream.on?.("error", onError);
-  return () => {
-    stream.off?.("error", onError);
-  };
-}
-function isBrokenPipeError(error) {
-  return hasOwnErrorCode(error, "EPIPE");
-}
-
-// packages/safejs/src/modules/log.ts
-function makeLogModule(sink = createJsonlStdoutSink()) {
-  const normalizedSink = readSink(sink);
-  return {
-    info(...args) {
-      normalizedSink({
-        ts: (/* @__PURE__ */ new Date()).toISOString(),
-        type: "info",
-        args
-      });
-    },
-    error(...args) {
-      normalizedSink({
-        ts: (/* @__PURE__ */ new Date()).toISOString(),
-        type: "error",
-        args
-      });
-    },
-    event(name, payload) {
-      normalizedSink({
-        ts: (/* @__PURE__ */ new Date()).toISOString(),
-        type: "event",
-        name: readNonEmptyString3(name, "Event name"),
-        payload
-      });
-    }
-  };
-}
-function createJsonlStdoutSink() {
-  const brokenPipe = createBrokenPipeState();
-  const stdout = createSafeOutputStream(process.stdout, brokenPipe);
-  addBrokenPipeListener(process.stdout, brokenPipe);
-  return (entry) => {
-    stdout.write(`${JSON.stringify(toJsonValue(entry, /* @__PURE__ */ new WeakSet()))}
-`);
-  };
-}
-function readNonEmptyString3(value, label) {
-  if (typeof value !== "string") {
-    throw new Error(`${label} must be a non-empty string.`);
-  }
-  const normalizedValue = value.trim();
-  if (normalizedValue.length === 0) {
-    throw new Error(`${label} must be a non-empty string.`);
-  }
-  return normalizedValue;
-}
-function readSink(value) {
-  if (typeof value !== "function") {
-    throw new Error("Log sink must be a function.");
-  }
-  return value;
-}
-function toJsonValue(value, seen) {
-  if (value === void 0) {
-    return null;
-  }
-  if (value === null || typeof value === "string" || typeof value === "boolean") {
-    return value;
-  }
-  if (typeof value === "number") {
-    return Number.isFinite(value) ? value : String(value);
-  }
-  if (typeof value === "bigint" || typeof value === "symbol") {
-    return String(value);
-  }
-  if (typeof value === "function") {
-    return `[Function ${value.name || "anonymous"}]`;
-  }
-  if (value instanceof Date) {
-    return Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString();
-  }
-  if (value instanceof Error) {
-    const serializedError = {
-      name: value.name,
-      message: value.message
-    };
-    if (typeof value.stack === "string" && value.stack.length > 0) {
-      serializedError.stack = value.stack;
-    }
-    if (Object.prototype.hasOwnProperty.call(value, "cause")) {
-      serializedError.cause = toJsonValue(value.cause, seen);
-    }
-    return serializedError;
-  }
-  if (Array.isArray(value)) {
-    if (seen.has(value)) {
-      return "[Circular]";
-    }
-    seen.add(value);
-    const normalized = value.map((entry) => toJsonValue(entry, seen));
-    seen.delete(value);
-    return normalized;
-  }
-  if (typeof value === "object") {
-    if (seen.has(value)) {
-      return "[Circular]";
-    }
-    seen.add(value);
-    const normalized = /* @__PURE__ */ Object.create(null);
-    for (const [key, entry] of Object.entries(value)) {
-      normalized[key] = toJsonValue(entry, seen);
-    }
-    seen.delete(value);
-    return normalized;
-  }
-  return String(value);
-}
-
-// packages/safejs/src/modules/metric.ts
-function makeMetricModule(npmRunner) {
-  return {
-    async run(name) {
-      const metricName = readNonEmptyString4(name, "Metric name");
-      const scriptName = `metric:${metricName}`;
-      const stdout = await npmRunner(scriptName);
-      const score = parseMetricScore(stdout, scriptName);
-      return score;
-    }
-  };
-}
-function parseMetricScore(stdout, scriptName) {
-  if (typeof stdout !== "string") {
-    throw new Error(`Metric runner for "${scriptName}" must resolve to a stdout string.`);
-  }
-  const scoreLine = stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).at(-1);
-  if (scoreLine === void 0) {
-    throw new Error(`Metric script "${scriptName}" must print a numeric score.`);
-  }
-  const score = Number(scoreLine);
-  if (!Number.isFinite(score)) {
-    throw new Error(`Metric script "${scriptName}" must print a numeric score.`);
-  }
-  return score;
-}
-function readNonEmptyString4(value, label) {
-  if (typeof value !== "string") {
-    throw new Error(`${label} must be a non-empty string.`);
-  }
-  const normalizedValue = value.trim();
-  if (normalizedValue.length === 0) {
-    throw new Error(`${label} must be a non-empty string.`);
-  }
-  return normalizedValue;
-}
-
-export {
-  formatInterpreterError,
-  SPAWN_MODES,
-  supportsSpawnMode,
-  extractBlock,
-  countLineBreaks,
-  splitFrontmatter,
-  createLintModulesFromRuntimeRegistry,
-  AgentSpawnError,
-  createSpawnUsageAccumulator,
-  runWithSpawnUsageAccumulator,
-  makeAgentModule,
-  makeFailModule,
-  resolveCanonicalPath,
-  containsPath,
-  isSamePath,
-  makeFsModule,
-  makeHarnessModule,
-  createBrokenPipeState,
-  createSafeOutputStream,
-  withBrokenPipeGuard,
-  makeLogModule,
-  makeMetricModule
-};
-//# sourceMappingURL=chunk-AVDRLE3Y.js.map