@wrongstack/core 0.313.0 → 0.316.1

package/dist/chunk-4SJNS7OB.js

@@ -0,0 +1,217 @@
+// src/wiring/proxy-rewrite.ts
+var PROXY_PATH_PREFIX = "/proxy/";
+var PROXY_EXCLUDED_PROVIDERS = /* @__PURE__ */ new Set(["openai-codex"]);
+function isProxyEligible(providerId) {
+  if (!providerId) return false;
+  if (PROXY_EXCLUDED_PROVIDERS.has(providerId)) return false;
+  return true;
+}
+function rewriteBaseUrl(originalBaseUrl, proxyUrl) {
+  if (!originalBaseUrl) return void 0;
+  if (!proxyUrl) return originalBaseUrl;
+  if (!isProxyEligibleForRewrite(originalBaseUrl, proxyUrl)) return originalBaseUrl;
+  return composeRewrittenUrl(originalBaseUrl, proxyUrl);
+}
+function isProxyEligibleForRewrite(originalBaseUrl, proxyUrl) {
+  if (!originalBaseUrl.includes("://")) return false;
+  if (!proxyUrl.includes("://")) return false;
+  const normalizedProxy = proxyUrl.replace(/\/+$/, "");
+  if (originalBaseUrl.startsWith(`${normalizedProxy}${PROXY_PATH_PREFIX}`)) {
+    return false;
+  }
+  try {
+    const parsed = new URL(originalBaseUrl);
+    const isLoopback = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || // WHATWG URL serializes IPv6 hosts with brackets — `[::1]`, not `::1`.
+    parsed.hostname === "[::1]";
+    if (isLoopback && parsed.port !== "") return false;
+  } catch {
+  }
+  return true;
+}
+function composeRewrittenUrl(originalBaseUrl, proxyUrl) {
+  let parsedOriginal;
+  try {
+    parsedOriginal = new URL(originalBaseUrl);
+  } catch {
+    return originalBaseUrl;
+  }
+  const hostAndPath = `${parsedOriginal.host}${parsedOriginal.pathname}`;
+  const trailingQuery = parsedOriginal.search || "";
+  const trailingHash = parsedOriginal.hash || "";
+  const proxyRoot = proxyUrl.replace(/\/+$/, "");
+  return `${proxyRoot}${PROXY_PATH_PREFIX}${hostAndPath}${trailingQuery}${trailingHash}`;
+}
+var DEFAULT_PROXY_CONFIG = { enabled: false, url: "", active: false };
+var currentConfig = { ...DEFAULT_PROXY_CONFIG };
+var proxyTransitionLogger;
+function setProxyTransitionLogger(logger) {
+  proxyTransitionLogger = logger;
+}
+function sanitizeUrlForLog(raw) {
+  if (!raw) return "";
+  try {
+    const parsed = new URL(raw);
+    return `${parsed.protocol}//${parsed.host}${parsed.pathname}`;
+  } catch {
+    const cut = raw.search(/[?#\x00-\x1f\x7f]/);
+    return cut >= 0 ? raw.slice(0, cut) : raw;
+  }
+}
+function logProxyTransition(next, reason) {
+  const log = proxyTransitionLogger;
+  if (!log) return;
+  const url = sanitizeUrlForLog(currentConfig.url) || "<unset>";
+  const line = next ? `WrongProxy active=true (${reason}) \u2014 base-URL rewrites ON, proxy=${url}` : `WrongProxy active=false (${reason}) \u2014 base-URL rewrites OFF, proxy=${url}`;
+  try {
+    if (next) log.info(line);
+    else log.warn(line);
+  } catch {
+  }
+}
+function getProxyConfig() {
+  return currentConfig;
+}
+var listeners = /* @__PURE__ */ new Set();
+function subscribeToProxyConfig(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+function applyProxyConfig(next) {
+  const previous = currentConfig;
+  currentConfig = {
+    enabled: next.enabled ?? previous.enabled,
+    url: next.url ?? previous.url,
+    active: next.active ?? previous.active
+  };
+  const materialChange = currentConfig.enabled !== previous.enabled || currentConfig.url !== previous.url || currentConfig.active !== previous.active;
+  if (materialChange) {
+    for (const listener of listeners) {
+      try {
+        listener(currentConfig, previous);
+      } catch {
+      }
+    }
+  }
+  return previous;
+}
+function shouldRewriteFor(providerId) {
+  const cfg = currentConfig;
+  if (!cfg.enabled || !cfg.active || !cfg.url) return false;
+  return isProxyEligible(providerId);
+}
+function deactivateProxyOnConnectionFailure(err) {
+  const cfg = currentConfig;
+  if (!cfg.enabled || !cfg.active) return false;
+  const msg = (err instanceof Error ? `${err.name} ${err.message} ${err.code ?? ""}` : String(err)).toLowerCase();
+  let isProxyFail = false;
+  if (cfg.url) {
+    try {
+      const parsed = new URL(cfg.url);
+      if (msg.includes(parsed.host.toLowerCase())) isProxyFail = true;
+    } catch {
+    }
+  }
+  if (!isProxyFail && (msg.includes("econnrefused") || msg.includes("ehostunreach") || msg.includes("enetunreach") || msg.includes("fetch failed") || msg.includes("failed to fetch") || msg.includes("connect error") || msg.includes("proxy error") || msg.includes("502") || msg.includes("503") || msg.includes("504"))) {
+    isProxyFail = true;
+  }
+  if (isProxyFail) {
+    applyProxyConfig({ active: false });
+    return true;
+  }
+  return false;
+}
+function __resetProxyConfigForTests() {
+  currentConfig = { ...DEFAULT_PROXY_CONFIG };
+  proxyTransitionLogger = void 0;
+  listeners.clear();
+  instantApplyChains.clear();
+}
+var PROXY_ROUTING_SETTLE_CAP_MS = 2e3;
+var instantApplyChains = /* @__PURE__ */ new Set();
+async function waitForProxyRoutingSettle(timeoutMs = PROXY_ROUTING_SETTLE_CAP_MS, signal) {
+  if (signal?.aborted) return;
+  const chains = [...instantApplyChains].map((get) => get());
+  if (chains.length === 0) return;
+  let timer;
+  let onAbort;
+  try {
+    await Promise.race([
+      Promise.allSettled(chains),
+      new Promise((resolve) => {
+        onAbort = () => resolve();
+        timer = setTimeout(resolve, Math.max(0, timeoutMs));
+        signal?.addEventListener("abort", onAbort, { once: true });
+      })
+    ]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+    if (onAbort !== void 0) signal?.removeEventListener("abort", onAbort);
+  }
+}
+function effectiveBaseUrlFor(cfg, providerId, rawBaseUrl) {
+  if (!rawBaseUrl) return void 0;
+  const active = cfg.enabled && cfg.active && !!cfg.url && isProxyEligible(providerId);
+  return active ? rewriteBaseUrl(rawBaseUrl, cfg.url) : rawBaseUrl;
+}
+function effectiveBaseUrl(providerId, rawBaseUrl) {
+  return effectiveBaseUrlFor(currentConfig, providerId, rawBaseUrl);
+}
+function createProxyInstantApply(deps) {
+  const { getActiveProviderId, getRawBaseUrl, rebuildProvider, logger } = deps;
+  let lastProviderId = getActiveProviderId();
+  let lastEffectiveUrl = effectiveBaseUrl(lastProviderId, getRawBaseUrl(lastProviderId));
+  let disposed = false;
+  let rebuildChain = Promise.resolve();
+  const chainGetter = () => rebuildChain;
+  instantApplyChains.add(chainGetter);
+  const unsubscribe = subscribeToProxyConfig((next, previous) => {
+    if (disposed) return;
+    const providerId = getActiveProviderId();
+    const raw = getRawBaseUrl(providerId);
+    const nextUrl = effectiveBaseUrlFor(next, providerId, raw);
+    const baselineUrl = providerId === lastProviderId ? lastEffectiveUrl : effectiveBaseUrlFor(previous, providerId, raw);
+    lastProviderId = providerId;
+    lastEffectiveUrl = nextUrl;
+    if (nextUrl === baselineUrl) return;
+    rebuildChain = rebuildChain.then(() => rebuildProvider(providerId)).then(() => {
+      if (!disposed) {
+        logger.info(`WrongProxy routing changed \u2014 live provider rebuilt (${providerId})`);
+      }
+    }).catch((err) => {
+      if (!disposed) {
+        logger.warn(
+          `WrongProxy instant-apply: provider rebuild failed for ${providerId}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    });
+  });
+  return {
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      instantApplyChains.delete(chainGetter);
+      unsubscribe();
+    }
+  };
+}
+
+export {
+  PROXY_EXCLUDED_PROVIDERS,
+  isProxyEligible,
+  rewriteBaseUrl,
+  setProxyTransitionLogger,
+  sanitizeUrlForLog,
+  logProxyTransition,
+  getProxyConfig,
+  subscribeToProxyConfig,
+  applyProxyConfig,
+  shouldRewriteFor,
+  deactivateProxyOnConnectionFailure,
+  __resetProxyConfigForTests,
+  PROXY_ROUTING_SETTLE_CAP_MS,
+  waitForProxyRoutingSettle,
+  createProxyInstantApply
+};
+//# sourceMappingURL=chunk-4SJNS7OB.js.map

package/dist/chunk-4VWO3ZXL.js

@@ -0,0 +1,342 @@
+// src/utils/term.ts
+var hasStdout = () => typeof process !== "undefined" && !!process.stdout;
+var hasStdin = () => typeof process !== "undefined" && !!process.stdin;
+function isStdoutTTY() {
+  return hasStdout() && Boolean(process.stdout.isTTY);
+}
+function isStdinTTY() {
+  return hasStdin() && Boolean(process.stdin.isTTY);
+}
+function isInteractive() {
+  return isStdinTTY() && isStdoutTTY();
+}
+function getTermSize() {
+  if (!hasStdout()) return { rows: 24, cols: 80 };
+  return {
+    rows: process.stdout.rows ?? 24,
+    cols: process.stdout.columns ?? 80
+  };
+}
+function onResize(cb, stream = process.stdout) {
+  if (!stream || typeof stream.on !== "function") return () => {
+  };
+  const handler = () => {
+    cb({
+      rows: stream.rows ?? 24,
+      cols: stream.columns ?? 80
+    });
+  };
+  stream.on("resize", handler);
+  return () => {
+    stream.off("resize", handler);
+  };
+}
+function setRawMode(input, mode) {
+  if (input?.isTTY !== true) return false;
+  if (typeof input.setRawMode !== "function") return false;
+  input.setRawMode(mode);
+  return true;
+}
+var activeOutputGuard = null;
+function setOutputLineGuard(guard) {
+  activeOutputGuard = guard;
+}
+function writeTo(s, stream) {
+  if (!stream || typeof stream.write !== "function") return false;
+  const guard = activeOutputGuard;
+  if (!guard) {
+    stream.write(s);
+    return true;
+  }
+  guard.suspend();
+  stream.write(s);
+  guard.resume();
+  return true;
+}
+function writeOut(s, stream = process.stdout) {
+  return writeTo(s, stream);
+}
+function writeErr(s, stream = process.stderr) {
+  return writeTo(s, stream);
+}
+function parseColorDepth(env) {
+  if (env.FORCE_COLOR === "0") return 0;
+  if (env.FORCE_COLOR !== void 0) return 3;
+  if (typeof env.NO_COLOR === "string" && env.NO_COLOR !== "") return 0;
+  const colorterm = (env.COLORTERM ?? "").toLowerCase();
+  if (colorterm === "truecolor" || colorterm === "24bit") return 3;
+  const term = (env.TERM ?? "").toLowerCase();
+  if (term.includes("truecolor") || term.includes("24bit")) return 3;
+  if (term.includes("256color")) return 2;
+  if (term === "dumb") return 0;
+  return 1;
+}
+function parseMouseProtocol(term) {
+  const t = term.toLowerCase();
+  if (t.startsWith("xterm") || t.startsWith("tmux") || t.startsWith("screen") || t.includes("rxvt-unicode") || t.includes("urxvt") || t.includes("konsole") || t.includes("gnome") || t.includes("foot") || t.includes("alacritty") || t.includes("wezterm") || t.includes("kitty") || t.includes("vscode") || t.includes("Apple_Terminal")) {
+    return "sgr";
+  }
+  if (t.startsWith("rxvt") || t.startsWith("linux") || t.includes("Eterm")) {
+    return "urxvt";
+  }
+  if (t === "vt100" || t === "dumb") return "none";
+  return "sgr";
+}
+function detectTerminal(opts = {}) {
+  const stdin = opts.stdin ?? process.stdin;
+  const stdout = opts.stdout ?? process.stdout;
+  const env = opts.env ?? process.env;
+  const isRealTTY = (stdin?.isTTY ?? false) && (stdout?.isTTY ?? false);
+  const stdoutWritable = isRealTTY && typeof stdout?.write === "function";
+  const term = env.TERM ?? "";
+  const isTmux = term.toLowerCase().startsWith("tmux");
+  const isWindowsConhost = isRealTTY && process.platform === "win32" && typeof stdout.getColorDepth !== "function";
+  return {
+    isRealTTY,
+    colorDepth: isRealTTY ? parseColorDepth(env) : 0,
+    stdoutWritable,
+    mouseProtocol: parseMouseProtocol(term),
+    canSetTitle: isRealTTY && term !== "dumb",
+    isTmux,
+    isWindowsConhost
+  };
+}
+var TerminalLifecycle = class {
+  _active = false;
+  /**
+   * The stdin stream we took raw mode on. Set by `acquire()`; undefined before
+   * first call. Used by `release()` and by the ConPTY race-closer in
+   * `acquire()`.
+   */
+  _stdin;
+  /**
+   * The `isRaw` snapshot captured before the first `acquire()` call, so
+   * `release()` restores to the pre-TUI state rather than blindly disabling
+   * raw mode. Null when `acquire()` has never been called.
+   */
+  _wasRaw = null;
+  /**
+   * Whether stdin was paused before the TUI took ownership. Readline closes
+   * its interface by pausing the shared process stream, so raw mode alone is
+   * not enough to make Ink receive bytes during the boot-prompt -> TUI handoff.
+   */
+  _wasPaused = null;
+  /**
+   * Request the process to exit. Set the flag, trigger any registered
+   * `onRequestExit` callback (typically Ink's `unmount()`), and arm a
+   * deadline timer.  When the timer fires the process is hard-exited.
+   *
+   * Safe to call multiple times: subsequent calls no-op after the first.
+   */
+  requestExit;
+  /**
+   * Callback invoked when `requestExit` is called. Registered by the Ink
+   * mount point so unmount() runs before the deadline timer fires.
+   */
+  onRequestExit = null;
+  constructor() {
+    let exitCode = 0;
+    let requested = false;
+    this.requestExit = (code = 0) => {
+      exitCode = code;
+      if (requested) return;
+      requested = true;
+      try {
+        this.onRequestExit?.();
+      } catch {
+      }
+      setTimeout(() => process.exit(exitCode), 5e3).unref();
+    };
+  }
+  /** True while raw mode is held. */
+  get active() {
+    return this._active;
+  }
+  /**
+   * Acquire raw mode on `stdin`. Idempotent — calling twice is safe; only the
+   * first call has any effect.
+   *
+   * On Windows ConPTY, calls `setRawMode` twice: once immediately, then again
+   * after the next event-loop tick. This closes the ConPTY race where
+   * `readline`'s cleanup (registered before this class is constructed) can
+   * restore the original cooked mode after we set raw mode but before Ink's
+   * render loop takes over the stdin fd. The double-call ensures the last
+   * writer wins.
+   *
+   * @param stdin - The stdin stream (defaults to `process.stdin`).
+   * @returns `true` if raw mode was acquired; `false` if stdin is not a TTY
+   *          or already shut down.
+   */
+  acquire(stdin = process.stdin) {
+    if (this._active) return false;
+    if (stdin?.isTTY !== true) return false;
+    if (typeof stdin.setRawMode !== "function") return false;
+    this._wasRaw = stdin.isRaw ?? false;
+    this._wasPaused = stdin.isPaused();
+    this._stdin = stdin;
+    stdin.setRawMode(true);
+    stdin.resume();
+    this._active = true;
+    if (process.platform === "win32") {
+      setImmediate(() => {
+        if (this._active && this._stdin?.isTTY) {
+          this._stdin.setRawMode?.(true);
+        }
+      });
+    }
+    return true;
+  }
+  /**
+   * Release raw mode and restore the terminal to the state it was in before
+   * `acquire()` was called. Idempotent — subsequent calls are no-ops.
+   *
+   * Call this on: SIGINT, SIGTERM, SIGHUP, SIGBREAK, and `process.exit`.
+   *
+   * ⚠ **Windows caveat**: `setRawMode(false)` on ConPTY restores the original
+   * console mode captured when the process started — not the mode captured by
+   * `acquire()`. On ConPTY, the original mode was already raw (ConPTY starts
+   * raw), so this call is typically a no-op on Windows Terminal. On conhost.exe
+   * it may restore cooked mode, which is correct for that backend.
+   */
+  release() {
+    if (!this._active) return;
+    this._active = false;
+    const stdin = this._stdin;
+    if (stdin?.isTTY === true) {
+      stdin.setRawMode?.(this._wasRaw ?? false);
+      if (this._wasPaused) stdin.pause();
+    }
+    this._stdin = void 0;
+    this._wasRaw = null;
+    this._wasPaused = null;
+  }
+  /**
+   * Synchronously reset all terminal state written by the TUI layer:
+   * raw mode, SGR attributes, cursor visibility, and mouse tracking.
+   *
+   * Intended for the final `process.on('exit')` handler where async is
+   * impossible. Uses `\x1b[0m` (SGR reset), `\x1b[?25h` (cursor show),
+   * and `\x1b[?9l` (mouse off) — all safe to emit even if the terminal does
+   * not understand them (unknown CSI sequences are silently ignored).
+   *
+   * Safe to call multiple times from multiple exit paths because each write
+   * is a constant-time synchronous stream write.
+   *
+   * @param stdout - Stream to reset (defaults to `process.stdout`).
+   */
+  reset(stdout = process.stdout) {
+    if (typeof stdout?.write !== "function") return;
+    stdout.write("\x1B[0m");
+    stdout.write("\x1B[?25h");
+    stdout.write("\x1B[?1003l\x1B[?1002l\x1B[?1000l");
+  }
+};
+var ESCAPE_TERMINATOR = Object.freeze({
+  BEL: "\x07",
+  // OSC 0 / OSC 2 (title)
+  ST: "\x1B\\"
+  // DCS / strict OSC
+});
+function safeEmit(sequence, stdout = process.stdout) {
+  const raw = typeof sequence === "string" ? sequence : sequence.raw;
+  const term = typeof sequence === "string" ? void 0 : sequence.terminator;
+  if (!raw) {
+    return { ok: false, reason: "empty" };
+  }
+  if (stdout?.isTTY !== true) {
+    return { ok: false, reason: "not_a_tty" };
+  }
+  if (raw.startsWith("\x1B]") || raw.startsWith("\x1BP")) {
+    if (!term) {
+      void term;
+      const safe = `${raw}\x07`;
+      try {
+        stdout.write(safe);
+      } catch {
+        return { ok: false, reason: "unwritable" };
+      }
+      return { ok: true, reason: "empty" };
+    }
+    try {
+      stdout.write(`${raw}${term}`);
+    } catch {
+      return { ok: false, reason: "unwritable" };
+    }
+    return { ok: true, reason: "empty" };
+  }
+  try {
+    stdout.write(raw);
+  } catch {
+    return { ok: false, reason: "unwritable" };
+  }
+  return { ok: true, reason: "empty" };
+}
+function buildTitleSequence(title, terminator = ESCAPE_TERMINATOR.BEL) {
+  return {
+    raw: `\x1B]0;${title.replace(/\x07/g, "")}`,
+    terminator
+  };
+}
+function buildSgrSequence(...codes) {
+  return { raw: `\x1B[${codes.join(";")}m` };
+}
+function setTitle(title, stdout = process.stdout) {
+  return safeEmit(buildTitleSequence(title), stdout).ok;
+}
+
+// src/utils/color.ts
+var isColorTty = () => {
+  if (envFlag(process.env.NO_COLOR)) return false;
+  if (envFlag(process.env.FORCE_COLOR)) return true;
+  return isStdoutTTY();
+};
+function envFlag(value) {
+  if (value === void 0) return false;
+  if (value.trim() === "") return false;
+  return !/^(0|false|no|off)$/i.test(value.trim());
+}
+var COLOR = isColorTty();
+var wrap = (open, close) => (s) => COLOR ? `\x1B[${open}m${s}\x1B[${close}m` : s;
+var color = {
+  reset: wrap("0", "0"),
+  bold: wrap("1", "22"),
+  dim: wrap("2", "22"),
+  italic: wrap("3", "23"),
+  underline: wrap("4", "24"),
+  red: wrap("31", "39"),
+  green: wrap("32", "39"),
+  yellow: wrap("33", "39"),
+  blue: wrap("34", "39"),
+  magenta: wrap("35", "39"),
+  cyan: wrap("36", "39"),
+  gray: wrap("90", "39"),
+  amber: wrap("38;5;214", "39"),
+  pink: wrap("38;5;205", "39"),
+  bgRed: wrap("41", "49"),
+  bgGreen: wrap("42", "49")
+};
+function stripAnsi(s) {
+  return s.replace(/\x1b\[[0-9;]*[A-Za-z]/g, "");
+}
+
+export {
+  isStdoutTTY,
+  isStdinTTY,
+  isInteractive,
+  getTermSize,
+  onResize,
+  setRawMode,
+  setOutputLineGuard,
+  writeOut,
+  writeErr,
+  detectTerminal,
+  TerminalLifecycle,
+  ESCAPE_TERMINATOR,
+  safeEmit,
+  buildTitleSequence,
+  buildSgrSequence,
+  setTitle,
+  color,
+  stripAnsi
+};
+//# sourceMappingURL=chunk-4VWO3ZXL.js.map

package/dist/chunk-57GEWK5X.js

@@ -0,0 +1,26 @@
+// src/types/memory.ts
+var MEMORY_TYPE_LABELS = {
+  fact: "Fact",
+  decision: "Decision",
+  convention: "Convention",
+  preference: "Preference",
+  reference: "Reference",
+  anti_pattern: "Anti-pattern"
+};
+function defineMemoryCapability(id) {
+  return Object.freeze({
+    id,
+    /** Identity function that makes the brand a real runtime value so
+     *  `defineMemoryCapability<A>('x')` and `defineMemoryCapability<B>('x')`
+     *  produce structurally distinct objects. Capability lookup is still
+     *  keyed by `id` only — the brand prevents accidental cross-type casts
+     *  at the type level. */
+    __memoryCapabilityType: (v) => v
+  });
+}
+
+export {
+  MEMORY_TYPE_LABELS,
+  defineMemoryCapability
+};
+//# sourceMappingURL=chunk-57GEWK5X.js.map

package/dist/chunk-5BMIE7QG.js

@@ -0,0 +1,46 @@
+import {
+  ERROR_CODES,
+  FsError
+} from "./chunk-25LSLC3G.js";
+
+// src/utils/session-scoped-path.ts
+import * as path from "node:path";
+function sessionScopedPath(dir, sessionId, suffix) {
+  if (!sessionId || sessionId.includes("..") || sessionId.includes("\\")) {
+    throw invalid(sessionId);
+  }
+  const resolved = path.resolve(dir, `${sessionId}${suffix}`);
+  const rel = path.relative(path.resolve(dir), resolved);
+  if (rel.startsWith("..") || path.isAbsolute(rel)) {
+    throw invalid(sessionId);
+  }
+  return resolved;
+}
+var SESSION_SIDECAR_JSONL_SUFFIXES = [
+  ".replay.jsonl",
+  ".audit.jsonl",
+  ".annotations.jsonl"
+];
+var RESERVED_SESSION_JSONL_NAMES = /* @__PURE__ */ new Set([
+  "_index.jsonl",
+  "_mailbox.jsonl"
+]);
+function isSessionTranscriptFileName(name) {
+  if (!name.endsWith(".jsonl")) return false;
+  if (RESERVED_SESSION_JSONL_NAMES.has(name)) return false;
+  return !SESSION_SIDECAR_JSONL_SUFFIXES.some((suffix) => name.endsWith(suffix));
+}
+function invalid(sessionId) {
+  return new FsError({
+    message: `Invalid sessionId: ${sessionId}`,
+    code: ERROR_CODES.FS_DELETE_FAILED,
+    path: sessionId,
+    context: { reason: "path_traversal" }
+  });
+}
+
+export {
+  sessionScopedPath,
+  isSessionTranscriptFileName
+};
+//# sourceMappingURL=chunk-5BMIE7QG.js.map

package/dist/chunk-5S437PRC.js

@@ -0,0 +1,50 @@
+// src/utils/instruction-file.ts
+import { readFileSync, statSync } from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+var textCache = /* @__PURE__ */ new Map();
+var rootCandidates;
+function readBundledInstructionText(relativePath) {
+  const cached = textCache.get(relativePath);
+  if (cached !== void 0) return cached;
+  let resolved = "";
+  for (const root of instructionRootCandidates()) {
+    try {
+      resolved = readFileSync(path.join(root, relativePath), "utf8").trimEnd();
+      break;
+    } catch {
+    }
+  }
+  textCache.set(relativePath, resolved);
+  return resolved;
+}
+function renderInstructionTemplate(template, values) {
+  return template.replace(
+    /\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g,
+    (match, key) => Object.hasOwn(values, key) ? values[key] ?? "" : match
+  );
+}
+function instructionRootCandidates() {
+  if (rootCandidates !== void 0) return rootCandidates;
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path.resolve(here, "../../instructions"),
+    path.resolve(here, "../instructions"),
+    path.resolve(here, "instructions")
+  ];
+  rootCandidates = candidates.sort((a, b) => Number(!isDirectory(a)) - Number(!isDirectory(b)));
+  return rootCandidates;
+}
+function isDirectory(candidate) {
+  try {
+    return statSync(candidate).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+export {
+  readBundledInstructionText,
+  renderInstructionTemplate
+};
+//# sourceMappingURL=chunk-5S437PRC.js.map