@massa-ai/mcp-client 1.54.1 → 1.56.0

package/dist/config-cli.js

@@ -601,15 +601,18 @@ var init_massa_ai_config = __esm(() => {
     security: {
       corsOrigins: []
     },
-    scheduler: DEFAULT_SCHEDULER_CONFIG
+    scheduler: DEFAULT_SCHEDULER_CONFIG,
+    bootstrap: { rules: {} }
   };
 });
 
 // ../../packages/shared/dist/config/config-loader.js
 var exports_config_loader = {};
 __export(exports_config_loader, {
+  writeRawConfig: () => writeRawConfig,
   writeFileAtomically: () => writeFileAtomically,
   saveConfig: () => saveConfig,
+  readRawConfigStrict: () => readRawConfigStrict,
   migrateDataDirOnce: () => migrateDataDirOnce,
   mergeSchedulerSection: () => mergeSchedulerSection,
   loadRawUserConfig: () => loadRawUserConfig,
@@ -620,12 +623,23 @@ __export(exports_config_loader, {
   getConfigForEnv: () => getConfigForEnv,
   getConfigDir: () => getConfigDir,
   configExists: () => configExists,
-  __resetMigrationForTests: () => __resetMigrationForTests
+  __resetMigrationForTests: () => __resetMigrationForTests,
+  ConfigWriteConflictError: () => ConfigWriteConflictError,
+  ConfigParseError: () => ConfigParseError
 });
 import fs from "fs";
 import path3 from "path";
 import os2 from "os";
 import crypto2 from "crypto";
+function readConfigFileOrEmpty() {
+  try {
+    return fs.readFileSync(CONFIG_FILE, "utf-8");
+  } catch (error) {
+    if (error?.code === "ENOENT")
+      return "";
+    throw error;
+  }
+}
 function getConfigDir() {
   return CONFIG_DIR;
 }
@@ -692,6 +706,21 @@ function loadRawUserConfig() {
     return {};
   }
 }
+function readRawConfigStrict() {
+  const raw2 = readConfigFileOrEmpty();
+  if (raw2 === "")
+    return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(raw2);
+  } catch (error) {
+    throw new ConfigParseError(CONFIG_FILE, error);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new ConfigParseError(CONFIG_FILE, new Error("parsed value is not a JSON object"));
+  }
+  return parsed;
+}
 function loadConfigSafe() {
   try {
     return loadConfig();
@@ -746,6 +775,43 @@ function writeFileAtomically(targetPath, content) {
 function saveConfig(config) {
   writeFileAtomically(CONFIG_FILE, JSON.stringify(config, null, 2));
 }
+function writeRawConfig(doc, opts) {
+  const onDiskAtStart = readConfigFileOrEmpty();
+  if (onDiskAtStart === opts.expectedBytes) {
+    writeFileAtomically(CONFIG_FILE, JSON.stringify(doc, null, 2));
+    return;
+  }
+  let original;
+  let current;
+  try {
+    original = opts.expectedBytes === "" ? {} : JSON.parse(opts.expectedBytes);
+  } catch (error) {
+    throw new ConfigParseError(`${CONFIG_FILE} (caller-supplied expectedBytes)`, error);
+  }
+  try {
+    current = onDiskAtStart === "" ? {} : JSON.parse(onDiskAtStart);
+  } catch (error) {
+    throw new ConfigParseError(CONFIG_FILE, error);
+  }
+  const reapplied = { ...current };
+  const touchedKeys = new Set([...Object.keys(original), ...Object.keys(doc)]);
+  for (const key of touchedKeys) {
+    const before = JSON.stringify(original[key]);
+    const after = JSON.stringify(doc[key]);
+    if (before === after)
+      continue;
+    if (Object.prototype.hasOwnProperty.call(doc, key)) {
+      reapplied[key] = doc[key];
+    } else {
+      delete reapplied[key];
+    }
+  }
+  const onDiskImmediatelyBeforeWrite = readConfigFileOrEmpty();
+  if (onDiskImmediatelyBeforeWrite !== onDiskAtStart) {
+    throw new ConfigWriteConflictError(CONFIG_FILE);
+  }
+  writeFileAtomically(CONFIG_FILE, JSON.stringify(reapplied, null, 2));
+}
 function initConfig() {
   if (!fs.existsSync(CONFIG_FILE)) {
     saveConfig(defaultMassaAiConfig);
@@ -772,12 +838,25 @@ function getConfigForEnv() {
   env.ENABLE_METRICS = String(config.logging.enableMetrics);
   return env;
 }
-var CONFIG_DIR, CONFIG_FILE, migrationAttempted = false, tempFileCounter = 0;
+var CONFIG_DIR, CONFIG_FILE, ConfigParseError, ConfigWriteConflictError, migrationAttempted = false, tempFileCounter = 0;
 var init_config_loader = __esm(() => {
   init_massa_ai_config();
   init_xdg();
   CONFIG_DIR = configDir("massa-ai");
   CONFIG_FILE = path3.join(CONFIG_DIR, "config.json");
+  ConfigParseError = class ConfigParseError extends Error {
+    constructor(filePath, cause) {
+      const reason = cause instanceof Error ? cause.message : String(cause);
+      super(`Failed to parse ${filePath}: ${reason}`);
+      this.name = "ConfigParseError";
+    }
+  };
+  ConfigWriteConflictError = class ConfigWriteConflictError extends Error {
+    constructor(filePath) {
+      super(`${filePath} changed on disk twice while writing \u2014 refusing to overwrite a ` + `concurrent update. Re-read the file and retry.`);
+      this.name = "ConfigWriteConflictError";
+    }
+  };
 });
 
 // ../../packages/shared/dist/env.js
@@ -2910,6 +2989,608 @@ function findRepoRootWithMarker(startDir, marker, maxLevels) {
 }
 var init_repo_root = () => {};
 
+// ../../packages/shared/dist/bootstrap/rules.js
+function isBootstrapRuleId(value) {
+  return typeof value === "string" && BOOTSTRAP_RULE_IDS.includes(value);
+}
+function bootstrapRuleDefaults() {
+  const defaults = {};
+  for (const rule of BOOTSTRAP_RULES)
+    defaults[rule.id] = rule.defaultEnabled;
+  return defaults;
+}
+function namedError4(name, message) {
+  const err = new BootstrapRuleError(message);
+  err.name = name;
+  return err;
+}
+function assertKnownRuleId(id) {
+  if (!isBootstrapRuleId(id))
+    throw UnknownRuleError(id, BOOTSTRAP_RULE_IDS);
+}
+var BOOTSTRAP_RULE_IDS, BOOTSTRAP_RULES, RULES_BY_ID, BootstrapRuleError, UnknownRuleError = (id, known = BOOTSTRAP_RULE_IDS) => namedError4("UnknownRuleError", `unknown bootstrap rule "${id}" \u2014 valid ids: ${known.join(", ")}`);
+var init_rules = __esm(() => {
+  BOOTSTRAP_RULE_IDS = [
+    "caveman",
+    "massa-ai-router",
+    "persona-router",
+    "dedupe-guardrails",
+    "plan-challenge",
+    "conversation-feedback",
+    "indexing-hygiene",
+    "english-code",
+    "code-comments"
+  ];
+  BOOTSTRAP_RULES = [
+    {
+      id: "caveman",
+      defaultEnabled: true,
+      description: "Keep communication compressed while preserving technical accuracy."
+    },
+    {
+      id: "massa-ai-router",
+      defaultEnabled: true,
+      description: "Load the massa-ai skill as the workflow router before substantive work."
+    },
+    {
+      id: "persona-router",
+      defaultEnabled: true,
+      description: "Select one cataloged specialist persona after massa-ai context is available."
+    },
+    {
+      id: "dedupe-guardrails",
+      defaultEnabled: true,
+      description: "Reuse already-loaded massa-ai context instead of bulk-loading workflows or references."
+    },
+    {
+      id: "plan-challenge",
+      defaultEnabled: true,
+      description: "Run The Fool as a post-plan challenge gate per the configured policy."
+    },
+    {
+      id: "conversation-feedback",
+      defaultEnabled: true,
+      description: "Emit chat-visible status updates for massa-ai workflow progress."
+    },
+    {
+      id: "indexing-hygiene",
+      defaultEnabled: true,
+      description: "Ignore build output, dependency, and secret paths during indexing and context loading."
+    },
+    {
+      id: "english-code",
+      defaultEnabled: true,
+      description: "Write generated code, identifiers, comments, and commit-facing artifacts in English regardless of conversational language."
+    },
+    {
+      id: "code-comments",
+      defaultEnabled: false,
+      description: "Require API doc blocks and rationale comments on generated code, per code-annotation.md \xA71/\xA72."
+    }
+  ];
+  RULES_BY_ID = new Map(BOOTSTRAP_RULES.map((rule) => [rule.id, rule]));
+  BootstrapRuleError = class BootstrapRuleError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "BootstrapRuleError";
+    }
+  };
+});
+
+// ../../packages/shared/dist/bootstrap/state.js
+import fs9 from "fs";
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolveBootstrapState(doc) {
+  const document2 = doc ?? readRawConfigStrict();
+  const state = bootstrapRuleDefaults();
+  const ignored = [];
+  const bootstrap = document2[BOOTSTRAP_STATE_KEY];
+  if (bootstrap === undefined)
+    return { state, ignoredStateKeys: [] };
+  if (!isPlainObject2(bootstrap)) {
+    return { state, ignoredStateKeys: [BOOTSTRAP_STATE_KEY] };
+  }
+  const rules = bootstrap[BOOTSTRAP_RULES_KEY];
+  if (rules === undefined)
+    return { state, ignoredStateKeys: [] };
+  if (!isPlainObject2(rules)) {
+    return { state, ignoredStateKeys: [BOOTSTRAP_STATE_PATH] };
+  }
+  for (const [key, value] of Object.entries(rules)) {
+    if (!isBootstrapRuleId(key) || typeof value !== "boolean") {
+      ignored.push(key);
+      continue;
+    }
+    state[key] = value;
+  }
+  return { state, ignoredStateKeys: ignored.sort() };
+}
+function readConfigBytes() {
+  try {
+    return fs9.readFileSync(getConfigPath(), "utf-8");
+  } catch (error) {
+    if (error?.code === "ENOENT")
+      return "";
+    throw error;
+  }
+}
+function setBootstrapRuleEnabled(id, enabled) {
+  assertKnownRuleId(id);
+  const expectedBytes = readConfigBytes();
+  let document2;
+  if (expectedBytes === "") {
+    document2 = {};
+  } else {
+    let parsed;
+    try {
+      parsed = JSON.parse(expectedBytes);
+    } catch (error) {
+      throw new ConfigParseError(getConfigPath(), error);
+    }
+    if (!isPlainObject2(parsed)) {
+      throw new ConfigParseError(getConfigPath(), new Error("parsed value is not a JSON object"));
+    }
+    document2 = parsed;
+  }
+  const before = resolveBootstrapState(document2);
+  const bootstrap = document2[BOOTSTRAP_STATE_KEY];
+  const bootstrapSubtree = isPlainObject2(bootstrap) ? bootstrap : {};
+  const rules = bootstrapSubtree[BOOTSTRAP_RULES_KEY];
+  const rulesSubtree = isPlainObject2(rules) ? rules : {};
+  const next = {
+    ...document2,
+    [BOOTSTRAP_STATE_KEY]: {
+      ...bootstrapSubtree,
+      [BOOTSTRAP_RULES_KEY]: { ...rulesSubtree, [id]: enabled }
+    }
+  };
+  writeRawConfig(next, { expectedBytes });
+  const after = resolveBootstrapState(next);
+  return {
+    id,
+    enabled,
+    changed: before.state[id] !== enabled,
+    state: after.state,
+    ignoredStateKeys: after.ignoredStateKeys
+  };
+}
+var BOOTSTRAP_STATE_KEY = "bootstrap", BOOTSTRAP_RULES_KEY = "rules", BOOTSTRAP_STATE_PATH;
+var init_state2 = __esm(() => {
+  init_config_loader();
+  init_rules();
+  BOOTSTRAP_STATE_PATH = `${BOOTSTRAP_STATE_KEY}.${BOOTSTRAP_RULES_KEY}`;
+});
+
+// ../../packages/shared/dist/bootstrap/render.js
+import path13 from "path";
+function wrapBootstrapBlock(body) {
+  return `${BOOTSTRAP_BLOCK_START}
+${body.replace(/\n+$/, "")}
+${BOOTSTRAP_BLOCK_END}
+`;
+}
+function ruleMarker(id, suffix) {
+  return `<!-- massa-ai:rule:${id}:${suffix} -->`;
+}
+function resolveHostRoot(host, targetHome, hostRoot) {
+  requireAbsoluteTargetHome(targetHome);
+  if (hostRoot === undefined)
+    return path13.join(targetHome, ...HOST_CONFIG_DIR[host]);
+  const relative = path13.relative(targetHome, hostRoot);
+  if (!path13.isAbsolute(hostRoot) || relative === "" || relative.startsWith("..") || path13.isAbsolute(relative)) {
+    throw new BootstrapRenderError("HostRootOutsideTargetHomeError", `hostRoot must be an absolute directory inside targetHome, got "${hostRoot}" for targetHome "${targetHome}"`, [hostRoot, targetHome]);
+  }
+  return hostRoot;
+}
+function bootstrapContractPath(host, targetHome, hostRoot) {
+  return path13.join(resolveHostRoot(host, targetHome, hostRoot), CONTRACT_FILENAME);
+}
+function bootstrapStateFilePath(targetHome) {
+  requireAbsoluteTargetHome(targetHome);
+  return path13.join(targetHome, ".config", "massa-ai", "config.json");
+}
+function renderBootstrap(options) {
+  const { source, state, host, targetHome, hostRoot } = options;
+  requireAbsoluteTargetHome(targetHome);
+  requireTotalState(state);
+  const body = applyRuleState(extractBootstrapBlock(source), state);
+  const contract = `${renderHeader(state, targetHome)}
+
+${body}`;
+  const pointer = renderPointer(host, targetHome, hostRoot);
+  const emitted = [
+    ...contract.split(`
+`).filter((line) => ANY_MASSA_AI_MARKER.test(line)),
+    ...pointer.split(`
+`).filter((line) => ANY_MASSA_AI_MARKER.test(line))
+  ].map((line) => line.trim());
+  if (emitted.length > 0) {
+    throw new BootstrapRenderError("MarkerInInterpolatedPathError", `rendered output carries a massa-ai marker, which can only have come from an interpolated path: ${emitted.join(", ")}`, emitted);
+  }
+  return { contract, pointer };
+}
+function requireAbsoluteTargetHome(targetHome) {
+  if (!path13.isAbsolute(targetHome)) {
+    throw new BootstrapRenderError("TargetHomeNotAbsoluteError", `targetHome must be an absolute path, got "${targetHome}"`, [targetHome]);
+  }
+}
+function requireTotalState(state) {
+  const missing = BOOTSTRAP_RULES.filter((rule) => typeof state[rule.id] !== "boolean").map((rule) => rule.id);
+  if (missing.length > 0) {
+    throw new BootstrapRenderError("IncompleteBootstrapStateError", `bootstrap state is missing a boolean for: ${missing.join(", ")} \u2014 pass a state resolved by resolveBootstrapState`, missing);
+  }
+}
+function extractBootstrapBlock(source) {
+  const startCount = countOccurrences(source, BOOTSTRAP_BLOCK_START);
+  const endCount = countOccurrences(source, BOOTSTRAP_BLOCK_END);
+  const startIndex = source.indexOf(BOOTSTRAP_BLOCK_START);
+  const endIndex = source.indexOf(BOOTSTRAP_BLOCK_END);
+  if (startCount !== 1 || endCount !== 1 || startIndex > endIndex) {
+    throw new BootstrapRenderError("BootstrapSourceError", `source must contain exactly one well-formed bootstrap block \u2014 found ${startCount} start and ${endCount} end marker(s)`, [`start=${startCount}`, `end=${endCount}`]);
+  }
+  return source.slice(startIndex + BOOTSTRAP_BLOCK_START.length, endIndex);
+}
+function findMarker(lines, marker) {
+  let index = -1;
+  let count = 0;
+  for (let i = 0;i < lines.length; i++) {
+    if (lines[i]?.trim() === marker) {
+      if (count === 0)
+        index = i;
+      count++;
+    }
+  }
+  return { index, count };
+}
+function countOccurrences(haystack, needle) {
+  let count = 0;
+  let from = 0;
+  for (;; ) {
+    const at = haystack.indexOf(needle, from);
+    if (at === -1)
+      return count;
+    count++;
+    from = at + needle.length;
+  }
+}
+function splitOffSpan(inner, id) {
+  const offStart = findMarker(inner, ruleMarker(id, "off"));
+  const offEnd = findMarker(inner, ruleMarker(id, "off-end"));
+  if (offStart.count === 0 && offEnd.count === 0)
+    return { on: inner, off: [] };
+  if (offStart.count !== 1 || offEnd.count !== 1 || offStart.index > offEnd.index) {
+    throw new BootstrapRenderError("MalformedOffSpanError", `rule "${id}" has a malformed off-text span \u2014 found ${offStart.count} ":off" and ${offEnd.count} ":off-end" marker(s)`, [id]);
+  }
+  return {
+    on: [...inner.slice(0, offStart.index), ...inner.slice(offEnd.index + 1)],
+    off: inner.slice(offStart.index + 1, offEnd.index)
+  };
+}
+function applyRuleState(block, state) {
+  const lines = block.split(`
+`);
+  const missingSpans = [];
+  for (const rule of BOOTSTRAP_RULES) {
+    const start = findMarker(lines, ruleMarker(rule.id, "start"));
+    const end = findMarker(lines, ruleMarker(rule.id, "end"));
+    if (start.count !== 1 || end.count !== 1 || start.index > end.index) {
+      missingSpans.push(rule.id);
+      continue;
+    }
+    const span = splitOffSpan(lines.slice(start.index + 1, end.index), rule.id);
+    const replacement = state[rule.id] ? span.on : span.off;
+    lines.splice(start.index, end.index - start.index + 1, ...replacement);
+  }
+  if (missingSpans.length > 0) {
+    throw new BootstrapRenderError("MissingRuleSpanError", `source has no well-formed span for rule(s): ${missingSpans.join(", ")}`, missingSpans);
+  }
+  const leftovers = lines.filter((line) => ANY_MASSA_AI_MARKER.test(line)).map((line) => line.trim());
+  if (leftovers.length > 0) {
+    throw new BootstrapRenderError("UnknownRuleMarkerError", `source carries marker(s) no registry rule consumed: ${leftovers.join(", ")}`, leftovers);
+  }
+  return normalizeBlankLines(lines);
+}
+function normalizeBlankLines(lines) {
+  const out = [];
+  let inFence = false;
+  for (const line of lines) {
+    if (line.trimStart().startsWith("```")) {
+      inFence = !inFence;
+      out.push(line);
+      continue;
+    }
+    if (inFence) {
+      out.push(line);
+      continue;
+    }
+    const previous = out[out.length - 1];
+    const isBlank = line.trim() === "";
+    if (isBlank && (previous === undefined || previous.trim() === ""))
+      continue;
+    if (/^#{1,6} /.test(line) && previous !== undefined && previous.trim() !== "")
+      out.push("");
+    out.push(line);
+  }
+  return `${out.join(`
+`).trimEnd()}
+`;
+}
+function renderHeader(state, targetHome) {
+  const lines = [
+    "> Generated by massa-ai from `skills/AGENTS.md`. Edits made here are lost on",
+    "> the next `scripts/install-skills.sh --apply` or",
+    "> `massa-ai-config bootstrap enable|disable <rule-id>` run.",
+    ">",
+    `> Rule state lives in \`${bootstrapStateFilePath(targetHome)}\` under the`,
+    `> \`${BOOTSTRAP_STATE_PATH}\` key. List every rule and its state with`,
+    "> `massa-ai-config bootstrap list`; switch one back on with",
+    "> `massa-ai-config bootstrap enable <rule-id>`. That command is a binary and",
+    "> not a rule, so it keeps working with every rule below disabled \u2014",
+    "> `massa-ai-config bootstrap enable massa-ai-router` is the way back when the",
+    "> router rule itself is off."
+  ];
+  if (BOOTSTRAP_RULES.every((rule) => !state[rule.id])) {
+    lines.push("", "**Every massa-ai bootstrap rule is disabled.** The contract below carries no", "rule to activate, and nothing in this file changes agent behavior until at", "least one rule is enabled again.");
+  }
+  return lines.join(`
+`);
+}
+function renderPointer(host, targetHome, hostRoot) {
+  return [
+    "## massa-ai Startup Contract",
+    "",
+    "Before substantive work in this session, read",
+    `\`${bootstrapContractPath(host, targetHome, hostRoot)}\``,
+    "with your Read tool and follow it. This block is a pointer only: it states no",
+    "rule of its own, and massa-ai overwrites it on the next install.",
+    ""
+  ].join(`
+`);
+}
+var BOOTSTRAP_BLOCK_START = "<!-- massa-ai:bootstrap:start -->", BOOTSTRAP_BLOCK_END = "<!-- massa-ai:bootstrap:end -->", CONTRACT_FILENAME = "MASSA-AI.md", ANY_MASSA_AI_MARKER, BootstrapRenderError, HOST_CONFIG_DIR;
+var init_render = __esm(() => {
+  init_rules();
+  init_state2();
+  ANY_MASSA_AI_MARKER = /<!--\s*massa-ai:(?:rule|bootstrap):[^>]*-->/;
+  BootstrapRenderError = class BootstrapRenderError extends Error {
+    details;
+    constructor(name, message, details = []) {
+      super(message);
+      this.name = name;
+      this.details = details;
+    }
+  };
+  HOST_CONFIG_DIR = {
+    claude: [".claude"],
+    codex: [".codex"],
+    cursor: [".cursor"],
+    opencode: [".config", "opencode"]
+  };
+});
+
+// ../../packages/shared/dist/bootstrap/report.js
+function bootstrapReportSucceeded(report) {
+  return report.rows.every((row) => CLEAN_STATUSES.has(row.status));
+}
+function buildBootstrapReport(input) {
+  const restartRequired = !input.dryRun && input.rows.some((row) => row.status === "written");
+  return {
+    rows: input.rows,
+    restartRequired,
+    dryRun: input.dryRun,
+    ignoredStateKeys: input.ignoredStateKeys
+  };
+}
+var CLEAN_STATUSES;
+var init_report = __esm(() => {
+  CLEAN_STATUSES = new Set(["written", "skipped"]);
+});
+
+// ../../packages/shared/dist/bootstrap/engine.js
+import fs10 from "fs";
+import path14 from "path";
+function applyBootstrapState(options) {
+  const { targetHome } = options;
+  const dryRun = options.dryRun ?? false;
+  const warn = options.onWarning ?? ((message) => console.warn(message));
+  const configPath = bootstrapStateFilePath(targetHome);
+  const installStatePath = path14.join(path14.dirname(configPath), INSTALL_STATE_FILENAME);
+  const { platforms } = readInstallState(installStatePath);
+  const installed = HOSTS.filter((host) => platforms[host] !== undefined);
+  if (installed.length === 0) {
+    return buildBootstrapReport({ rows: [], dryRun, ignoredStateKeys: [] });
+  }
+  const resolved = resolveRuleState(configPath, warn);
+  const source = readSource(options);
+  const rows = installed.map((host) => applyHost({
+    host,
+    source,
+    state: resolved.state,
+    targetHome,
+    hostRoot: recordedHostRoot(platforms[host]),
+    dryRun
+  }));
+  return buildBootstrapReport({
+    rows,
+    dryRun,
+    ignoredStateKeys: resolved.ignoredStateKeys
+  });
+}
+function recordedHostRoot(record) {
+  const root = record?.root;
+  return typeof root === "string" && root.length > 0 ? root : undefined;
+}
+function resolveRuleState(configPath, warn) {
+  const raw2 = readFileOrNull(configPath);
+  if (raw2 === null)
+    return resolveBootstrapState({});
+  let parsed;
+  try {
+    parsed = JSON.parse(raw2);
+  } catch (error) {
+    warn(degradeWarning(configPath, error));
+    return resolveBootstrapState({});
+  }
+  if (!isPlainObject3(parsed)) {
+    warn(degradeWarning(configPath, new Error("parsed value is not a JSON object")));
+    return resolveBootstrapState({});
+  }
+  return resolveBootstrapState(parsed);
+}
+function degradeWarning(configPath, cause) {
+  const error = new ConfigParseError(configPath, cause);
+  return `${error.name}: ${error.message} \u2014 rendering the registry bootstrap defaults; ${configPath} was not written`;
+}
+function readSource(options) {
+  if (options.source !== undefined)
+    return options.source;
+  if (options.sourcePath !== undefined) {
+    const text = readFileOrNull(options.sourcePath);
+    if (text === null) {
+      throw new BootstrapEngineError("BootstrapSourceUnreadableError", `could not read the bootstrap source at ${options.sourcePath}`, [options.sourcePath]);
+    }
+    return text;
+  }
+  throw new BootstrapEngineError("BootstrapSourceUnavailableError", "no bootstrap source given \u2014 pass `source` (the skills/AGENTS.md text) or `sourcePath`", ["source", "sourcePath"]);
+}
+function applyHost(input) {
+  const { host, source, state, targetHome, hostRoot, dryRun } = input;
+  let contractPath;
+  let document2;
+  try {
+    contractPath = bootstrapContractPath(host, targetHome, hostRoot);
+    document2 = wrapBootstrapBlock(renderBootstrap({ source, state, host, targetHome, hostRoot }).contract);
+  } catch (error) {
+    return { host, status: "failed", reason: error.message };
+  }
+  const wired = isWired(host, targetHome, hostRoot);
+  const notWired = () => ({
+    host,
+    status: "written-not-wired",
+    reason: notWiredReason(host, targetHome, hostRoot)
+  });
+  if (readFileOrNull(contractPath) === document2) {
+    return wired ? { host, status: "skipped", reason: `${contractPath} is already up to date` } : notWired();
+  }
+  if (!dryRun) {
+    try {
+      writeFileAtomically(contractPath, document2);
+    } catch (error) {
+      return {
+        host,
+        status: "failed",
+        reason: `could not write ${contractPath}: ${error.message}`
+      };
+    }
+  }
+  return wired ? { host, status: "written" } : notWired();
+}
+function wiringArtifact(host, targetHome, hostRoot) {
+  const root = resolveHostRoot(host, targetHome, hostRoot);
+  const contractPath = path14.join(root, CONTRACT_FILENAME);
+  switch (host) {
+    case "claude":
+      return { file: path14.join(root, "CLAUDE.md"), token: `@${CONTRACT_FILENAME}` };
+    case "codex":
+    case "cursor":
+      return { file: path14.join(root, "AGENTS.md"), token: contractPath };
+    case "opencode":
+      return { file: openCodeConfigPath(root), token: `"${contractPath}"` };
+  }
+}
+function openCodeConfigPath(root) {
+  const json = path14.join(root, "opencode.json");
+  if (fs10.existsSync(json))
+    return json;
+  return path14.join(root, "opencode.jsonc");
+}
+function isWired(host, targetHome, hostRoot) {
+  const artifact = wiringArtifact(host, targetHome, hostRoot);
+  const text = readFileOrNull(artifact.file);
+  return text !== null && text.includes(artifact.token);
+}
+function notWiredReason(host, targetHome, hostRoot) {
+  const artifact = wiringArtifact(host, targetHome, hostRoot);
+  return `contract written, but ${host} has no artifact that loads it \u2014 expected ${artifact.token} in ${artifact.file}; run ${WIRING_REMEDY} to add the wiring`;
+}
+function readFileOrNull(filePath) {
+  try {
+    return fs10.readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function isPlainObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var INSTALL_STATE_FILENAME = "install-state.json", WIRING_REMEDY = "scripts/install-skills.sh --apply", BootstrapEngineError;
+var init_engine2 = __esm(() => {
+  init_config_loader();
+  init_hosts();
+  init_state();
+  init_render();
+  init_report();
+  init_state2();
+  BootstrapEngineError = class BootstrapEngineError extends Error {
+    details;
+    constructor(name, message, details = []) {
+      super(message);
+      this.name = name;
+      this.details = details;
+    }
+  };
+});
+
+// ../../packages/shared/dist/bootstrap/format.js
+function enabledWord(enabled) {
+  return enabled ? "enabled" : "disabled";
+}
+function formatBootstrapInventory(state) {
+  return BOOTSTRAP_RULES.map((rule) => {
+    const current = enabledWord(state[rule.id]);
+    const fallback = enabledWord(rule.defaultEnabled);
+    return `  ${rule.id}: ${current} (default: ${fallback}) \u2014 ${rule.description}`;
+  }).join(`
+`);
+}
+function formatBootstrapReport(report) {
+  const dryRunSuffix = report.dryRun ? " (dry run \u2014 no files changed)" : "";
+  const lines = [];
+  if (report.rows.length === 0) {
+    lines.push(`bootstrap: no host installed${dryRunSuffix}`);
+  } else {
+    lines.push(`bootstrap: ${report.rows.length} host(s)${dryRunSuffix}`);
+    for (const row of report.rows) {
+      const detail = row.reason ? `: ${row.reason}` : "";
+      lines.push(`  ${row.host}: ${row.status}${detail}`);
+    }
+  }
+  if (report.ignoredStateKeys.length > 0) {
+    lines.push("", `Ignored persisted rule state: ${report.ignoredStateKeys.join(", ")} \u2014 not a known rule id with a boolean value.`);
+  }
+  if (report.restartRequired) {
+    lines.push("", "A host session restart is required for the change to take effect.");
+  }
+  return lines.join(`
+`);
+}
+var init_format = __esm(() => {
+  init_rules();
+});
+
+// ../../packages/shared/dist/bootstrap/index.js
+var init_bootstrap = __esm(() => {
+  init_rules();
+  init_state2();
+  init_render();
+  init_report();
+  init_engine2();
+  init_format();
+  init_config_loader();
+});
+
 // ../../packages/shared/dist/index.js
 var init_dist = __esm(() => {
   init_env();
@@ -2920,6 +3601,7 @@ var init_dist = __esm(() => {
   init_engine();
   init_variant_sync();
   init_repo_root();
+  init_bootstrap();
   init_types();
   init_interfaces();
   init_utils();
@@ -4441,7 +5123,7 @@ var import_brace_expansion, minimatch = (p, pattern, options = {}) => {
 }, qmarksTestNoExtDot = ([$0]) => {
   const len = $0.length;
   return (f) => f.length === len && f !== "." && f !== "..";
-}, defaultPlatform, path13, sep, GLOBSTAR, qmark2 = "[^/]", star2, twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?", filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options), ext = (a, b = {}) => Object.assign({}, a, b), defaults = (def) => {
+}, defaultPlatform, path15, sep, GLOBSTAR, qmark2 = "[^/]", star2, twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?", filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options), ext = (a, b = {}) => Object.assign({}, a, b), defaults = (def) => {
   if (!def || typeof def !== "object" || !Object.keys(def).length) {
     return minimatch;
   }
@@ -4499,11 +5181,11 @@ var init_esm = __esm(() => {
   starRE = /^\*+$/;
   qmarksRE = /^\?+([^+@!?\*\[\(]*)?$/;
   defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-  path13 = {
+  path15 = {
     win32: { sep: "\\" },
     posix: { sep: "/" }
   };
-  sep = defaultPlatform === "win32" ? path13.win32.sep : path13.posix.sep;
+  sep = defaultPlatform === "win32" ? path15.win32.sep : path15.posix.sep;
   minimatch.sep = sep;
   GLOBSTAR = Symbol("globstar **");
   minimatch.GLOBSTAR = GLOBSTAR;
@@ -6469,12 +7151,12 @@ var init_esm4 = __esm(() => {
     childrenCache() {
       return this.#children;
     }
-    resolve(path14) {
-      if (!path14) {
+    resolve(path16) {
+      if (!path16) {
         return this;
       }
-      const rootPath = this.getRootString(path14);
-      const dir = path14.substring(rootPath.length);
+      const rootPath = this.getRootString(path16);
+      const dir = path16.substring(rootPath.length);
       const dirParts = dir.split(this.splitSep);
       const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
       return result;
@@ -7002,8 +7684,8 @@ var init_esm4 = __esm(() => {
     newChild(name, type = UNKNOWN, opts = {}) {
       return new PathWin32(name, type, this.root, this.roots, this.nocase, this.childrenCache(), opts);
     }
-    getRootString(path14) {
-      return win32.parse(path14).root;
+    getRootString(path16) {
+      return win32.parse(path16).root;
     }
     getRoot(rootPath) {
       rootPath = uncToDrive(rootPath.toUpperCase());
@@ -7028,8 +7710,8 @@ var init_esm4 = __esm(() => {
     constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
       super(name, type, root, roots, nocase, children, opts);
     }
-    getRootString(path14) {
-      return path14.startsWith("/") ? "/" : "";
+    getRootString(path16) {
+      return path16.startsWith("/") ? "/" : "";
     }
     getRoot(_rootPath) {
       return this.root;
@@ -7048,8 +7730,8 @@ var init_esm4 = __esm(() => {
     #children;
     nocase;
     #fs;
-    constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs9 = defaultFS } = {}) {
-      this.#fs = fsFromOption(fs9);
+    constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs11 = defaultFS } = {}) {
+      this.#fs = fsFromOption(fs11);
       if (cwd instanceof URL || cwd.startsWith("file://")) {
         cwd = fileURLToPath(cwd);
       }
@@ -7085,11 +7767,11 @@ var init_esm4 = __esm(() => {
       }
       this.cwd = prev;
     }
-    depth(path14 = this.cwd) {
-      if (typeof path14 === "string") {
-        path14 = this.cwd.resolve(path14);
+    depth(path16 = this.cwd) {
+      if (typeof path16 === "string") {
+        path16 = this.cwd.resolve(path16);
       }
-      return path14.depth();
+      return path16.depth();
     }
     childrenCache() {
       return this.#children;
@@ -7505,9 +8187,9 @@ var init_esm4 = __esm(() => {
       process2();
       return results;
     }
-    chdir(path14 = this.cwd) {
+    chdir(path16 = this.cwd) {
       const oldCwd = this.cwd;
-      this.cwd = typeof path14 === "string" ? this.cwd.resolve(path14) : path14;
+      this.cwd = typeof path16 === "string" ? this.cwd.resolve(path16) : path16;
       this.cwd[setAsCwd](oldCwd);
     }
   };
@@ -7524,8 +8206,8 @@ var init_esm4 = __esm(() => {
     parseRootPath(dir) {
       return win32.parse(dir).root.toUpperCase();
     }
-    newRoot(fs9) {
-      return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs9 });
+    newRoot(fs11) {
+      return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs11 });
     }
     isAbsolute(p) {
       return p.startsWith("/") || p.startsWith("\\") || /^[a-z]:(\/|\\)/i.test(p);
@@ -7541,8 +8223,8 @@ var init_esm4 = __esm(() => {
     parseRootPath(_dir) {
       return "/";
     }
-    newRoot(fs9) {
-      return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs9 });
+    newRoot(fs11) {
+      return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs11 });
     }
     isAbsolute(p) {
       return p.startsWith("/");
@@ -7799,8 +8481,8 @@ class MatchRecord {
     this.store.set(target, current === undefined ? n : n & current);
   }
   entries() {
-    return [...this.store.entries()].map(([path14, n]) => [
-      path14,
+    return [...this.store.entries()].map(([path16, n]) => [
+      path16,
       !!(n & 2),
       !!(n & 1)
     ]);
@@ -8004,9 +8686,9 @@ class GlobUtil {
   signal;
   maxDepth;
   includeChildMatches;
-  constructor(patterns, path14, opts) {
+  constructor(patterns, path16, opts) {
     this.patterns = patterns;
-    this.path = path14;
+    this.path = path16;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -8025,11 +8707,11 @@ class GlobUtil {
       });
     }
   }
-  #ignored(path14) {
-    return this.seen.has(path14) || !!this.#ignore?.ignored?.(path14);
+  #ignored(path16) {
+    return this.seen.has(path16) || !!this.#ignore?.ignored?.(path16);
   }
-  #childrenIgnored(path14) {
-    return !!this.#ignore?.childrenIgnored?.(path14);
+  #childrenIgnored(path16) {
+    return !!this.#ignore?.childrenIgnored?.(path16);
   }
   pause() {
     this.paused = true;
@@ -8246,8 +8928,8 @@ var init_walker = __esm(() => {
   init_processor();
   GlobWalker = class GlobWalker extends GlobUtil {
     matches = new Set;
-    constructor(patterns, path14, opts) {
-      super(patterns, path14, opts);
+    constructor(patterns, path16, opts) {
+      super(patterns, path16, opts);
     }
     matchEmit(e) {
       this.matches.add(e);
@@ -8284,8 +8966,8 @@ var init_walker = __esm(() => {
   };
   GlobStream = class GlobStream extends GlobUtil {
     results;
-    constructor(patterns, path14, opts) {
-      super(patterns, path14, opts);
+    constructor(patterns, path16, opts) {
+      super(patterns, path16, opts);
       this.results = new Minipass({
         signal: this.signal,
         objectMode: true
@@ -8713,20 +9395,20 @@ var require_ignore = __commonJS((exports, module) => {
   var throwError = (message, Ctor) => {
     throw new Ctor(message);
   };
-  var checkPath = (path14, originalPath, doThrow) => {
-    if (!isString(path14)) {
+  var checkPath = (path16, originalPath, doThrow) => {
+    if (!isString(path16)) {
       return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
     }
-    if (!path14) {
+    if (!path16) {
       return doThrow(`path must not be empty`, TypeError);
     }
-    if (checkPath.isNotRelative(path14)) {
+    if (checkPath.isNotRelative(path16)) {
       const r = "`path.relative()`d";
       return doThrow(`path should be a ${r} string, but got "${originalPath}"`, RangeError);
     }
     return true;
   };
-  var isNotRelative = (path14) => REGEX_TEST_INVALID_PATH.test(path14);
+  var isNotRelative = (path16) => REGEX_TEST_INVALID_PATH.test(path16);
   checkPath.isNotRelative = isNotRelative;
   checkPath.convert = (p) => p;
 
@@ -8769,7 +9451,7 @@ var require_ignore = __commonJS((exports, module) => {
     addPattern(pattern) {
       return this.add(pattern);
     }
-    _testOne(path14, checkUnignored) {
+    _testOne(path16, checkUnignored) {
       let ignored = false;
       let unignored = false;
       this._rules.forEach((rule) => {
@@ -8777,7 +9459,7 @@ var require_ignore = __commonJS((exports, module) => {
         if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
           return;
         }
-        const matched = rule.regex.test(path14);
+        const matched = rule.regex.test(path16);
         if (matched) {
           ignored = !negative;
           unignored = negative;
@@ -8789,39 +9471,39 @@ var require_ignore = __commonJS((exports, module) => {
       };
     }
     _test(originalPath, cache, checkUnignored, slices) {
-      const path14 = originalPath && checkPath.convert(originalPath);
-      checkPath(path14, originalPath, this._allowRelativePaths ? RETURN_FALSE : throwError);
-      return this._t(path14, cache, checkUnignored, slices);
+      const path16 = originalPath && checkPath.convert(originalPath);
+      checkPath(path16, originalPath, this._allowRelativePaths ? RETURN_FALSE : throwError);
+      return this._t(path16, cache, checkUnignored, slices);
     }
-    _t(path14, cache, checkUnignored, slices) {
-      if (path14 in cache) {
-        return cache[path14];
+    _t(path16, cache, checkUnignored, slices) {
+      if (path16 in cache) {
+        return cache[path16];
       }
       if (!slices) {
-        slices = path14.split(SLASH);
+        slices = path16.split(SLASH);
       }
       slices.pop();
       if (!slices.length) {
-        return cache[path14] = this._testOne(path14, checkUnignored);
+        return cache[path16] = this._testOne(path16, checkUnignored);
       }
       const parent = this._t(slices.join(SLASH) + SLASH, cache, checkUnignored, slices);
-      return cache[path14] = parent.ignored ? parent : this._testOne(path14, checkUnignored);
+      return cache[path16] = parent.ignored ? parent : this._testOne(path16, checkUnignored);
     }
-    ignores(path14) {
-      return this._test(path14, this._ignoreCache, false).ignored;
+    ignores(path16) {
+      return this._test(path16, this._ignoreCache, false).ignored;
     }
     createFilter() {
-      return (path14) => !this.ignores(path14);
+      return (path16) => !this.ignores(path16);
     }
     filter(paths) {
       return makeArray(paths).filter(this.createFilter());
     }
-    test(path14) {
-      return this._test(path14, this._testCache, true);
+    test(path16) {
+      return this._test(path16, this._testCache, true);
     }
   }
   var factory = (options) => new Ignore2(options);
-  var isPathValid = (path14) => checkPath(path14 && checkPath.convert(path14), path14, RETURN_FALSE);
+  var isPathValid = (path16) => checkPath(path16 && checkPath.convert(path16), path16, RETURN_FALSE);
   factory.isPathValid = isPathValid;
   factory.default = factory;
   module.exports = factory;
@@ -8829,7 +9511,7 @@ var require_ignore = __commonJS((exports, module) => {
     const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
     checkPath.convert = makePosix;
     const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-    checkPath.isNotRelative = (path14) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path14) || isNotRelative(path14);
+    checkPath.isNotRelative = (path16) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path16) || isNotRelative(path16);
   }
 });
 
@@ -8891,13 +9573,13 @@ function validatePolicy(policy, opts = {}) {
     }
   }
 }
-function matchesGlob2(path14, pattern) {
+function matchesGlob2(path16, pattern) {
   let re = regexCache.get(pattern);
   if (!re) {
     re = globToRegex(pattern);
     regexCache.set(pattern, re);
   }
-  return re.test(path14);
+  return re.test(path16);
 }
 var DEFAULT_POLICY, applyPolicy = (filePath, policy) => {
   const normalized = filePath.trim();
@@ -8914,8 +9596,8 @@ var init_capture_policy = __esm(() => {
 });
 
 // ../../packages/core/dist/services/search/ignore-patterns.js
-import fs9 from "fs/promises";
-import path14 from "path";
+import fs11 from "fs/promises";
+import path16 from "path";
 function buildExtensionGlob(extensions) {
   return extensions.map((ext2) => `**/*${ext2}`);
 }
@@ -8938,8 +9620,8 @@ async function loadProjectIgnore(projectPath) {
   const ig = ignore();
   ig.add(DEFAULT_IGNORES);
   try {
-    const gitignorePath = path14.join(projectPath, ".gitignore");
-    const gitignoreContent = await fs9.readFile(gitignorePath, "utf8");
+    const gitignorePath = path16.join(projectPath, ".gitignore");
+    const gitignoreContent = await fs11.readFile(gitignorePath, "utf8");
     const rules = gitignoreContent.split(`
 `).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
     ig.add(rules);
@@ -10535,15 +11217,15 @@ var require_pg_connection_string = __commonJS((exports, module) => {
     if (config2.sslnegotiation === "direct" && config2.ssl === undefined) {
       config2.ssl = true;
     }
-    const fs10 = config2.sslcert || config2.sslkey || config2.sslrootcert ? __require("fs") : null;
+    const fs12 = config2.sslcert || config2.sslkey || config2.sslrootcert ? __require("fs") : null;
     if (config2.sslcert) {
-      config2.ssl.cert = fs10.readFileSync(config2.sslcert).toString();
+      config2.ssl.cert = fs12.readFileSync(config2.sslcert).toString();
     }
     if (config2.sslkey) {
-      config2.ssl.key = fs10.readFileSync(config2.sslkey).toString();
+      config2.ssl.key = fs12.readFileSync(config2.sslkey).toString();
     }
     if (config2.sslrootcert) {
-      config2.ssl.ca = fs10.readFileSync(config2.sslrootcert).toString();
+      config2.ssl.ca = fs12.readFileSync(config2.sslrootcert).toString();
     }
     if (options.useLibpqCompat && config2.uselibpqcompat) {
       throw new Error("Both useLibpqCompat and uselibpqcompat are set. Please use only one of them.");
@@ -12257,7 +12939,7 @@ var require_split2 = __commonJS((exports, module) => {
 
 // ../../node_modules/pgpass/lib/helper.js
 var require_helper = __commonJS((exports, module) => {
-  var path15 = __require("path");
+  var path17 = __require("path");
   var Stream2 = __require("stream").Stream;
   var split = require_split2();
   var util = __require("util");
@@ -12297,7 +12979,7 @@ var require_helper = __commonJS((exports, module) => {
   };
   exports.getFileName = function(rawEnv) {
     var env = rawEnv || process.env;
-    var file = env.PGPASSFILE || (isWin ? path15.join(env.APPDATA || "./", "postgresql", "pgpass.conf") : path15.join(env.HOME || "./", ".pgpass"));
+    var file = env.PGPASSFILE || (isWin ? path17.join(env.APPDATA || "./", "postgresql", "pgpass.conf") : path17.join(env.HOME || "./", ".pgpass"));
     return file;
   };
   exports.usePgPass = function(stats, fname) {
@@ -12421,16 +13103,16 @@ var require_helper = __commonJS((exports, module) => {
 
 // ../../node_modules/pgpass/lib/index.js
 var require_lib = __commonJS((exports, module) => {
-  var path15 = __require("path");
-  var fs10 = __require("fs");
+  var path17 = __require("path");
+  var fs12 = __require("fs");
   var helper = require_helper();
   module.exports = function(connInfo, cb) {
     var file = helper.getFileName();
-    fs10.stat(file, function(err, stat) {
+    fs12.stat(file, function(err, stat) {
       if (err || !helper.usePgPass(stat, file)) {
         return cb(undefined);
       }
-      var st = fs10.createReadStream(file);
+      var st = fs12.createReadStream(file);
       helper.getPassword(connInfo, st, cb);
     });
   };
@@ -14129,8 +14811,8 @@ var init_alias_resolver = __esm(() => {
 });
 
 // ../../packages/core/dist/services/search/index-manager.js
-import fs10 from "fs";
-import path15 from "path";
+import fs12 from "fs";
+import path17 from "path";
 
 class IndexManager {
   metadataCache = new Map;
@@ -14223,9 +14905,9 @@ class IndexManager {
       const fileMetadata = {};
       let totalSize = 0;
       for (const filePath of indexedFiles) {
-        const fullPath = path15.join(projectPath, filePath);
+        const fullPath = path17.join(projectPath, filePath);
         try {
-          const stat = await fs10.promises.stat(fullPath);
+          const stat = await fs12.promises.stat(fullPath);
           fileMetadata[filePath] = {
             path: filePath,
             mtime: stat.mtimeMs,
@@ -14276,9 +14958,9 @@ class IndexManager {
         if (ig.ignores(match2)) {
           continue;
         }
-        const fullPath = path15.join(projectPath, match2);
+        const fullPath = path17.join(projectPath, match2);
         try {
-          const stat = await fs10.promises.stat(fullPath);
+          const stat = await fs12.promises.stat(fullPath);
           files.set(match2, {
             path: match2,
             mtime: stat.mtimeMs,
@@ -14597,7 +15279,7 @@ __export(exports_util, {
   jsonStringifyReplacer: () => jsonStringifyReplacer,
   joinValues: () => joinValues,
   issue: () => issue,
-  isPlainObject: () => isPlainObject2,
+  isPlainObject: () => isPlainObject4,
   isObject: () => isObject,
   hexToUint8Array: () => hexToUint8Array,
   getSizableOrigin: () => getSizableOrigin,
@@ -14729,10 +15411,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path16) {
-  if (!path16)
+function getElementAtPath(obj, path18) {
+  if (!path18)
     return obj;
-  return path16.reduce((acc, key) => acc?.[key], obj);
+  return path18.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -14762,7 +15444,7 @@ function slugify(input) {
 function isObject(data) {
   return typeof data === "object" && data !== null && !Array.isArray(data);
 }
-function isPlainObject2(o) {
+function isPlainObject4(o) {
   if (isObject(o) === false)
     return false;
   const ctor = o.constructor;
@@ -14779,7 +15461,7 @@ function isPlainObject2(o) {
   return true;
 }
 function shallowClone(o) {
-  if (isPlainObject2(o))
+  if (isPlainObject4(o))
     return { ...o };
   if (Array.isArray(o))
     return [...o];
@@ -14919,7 +15601,7 @@ function omit(schema, mask) {
   return clone(schema, def);
 }
 function extend(schema, shape) {
-  if (!isPlainObject2(shape)) {
+  if (!isPlainObject4(shape)) {
     throw new Error("Invalid input to extend: expected a plain object");
   }
   const checks = schema._zod.def.checks;
@@ -14942,7 +15624,7 @@ function extend(schema, shape) {
   return clone(schema, def);
 }
 function safeExtend(schema, shape) {
-  if (!isPlainObject2(shape)) {
+  if (!isPlainObject4(shape)) {
     throw new Error("Invalid input to safeExtend: expected a plain object");
   }
   const def = mergeDefs(schema._zod.def, {
@@ -15060,11 +15742,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path16, issues) {
+function prefixIssues(path18, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path16);
+    iss.path.unshift(path18);
     return iss;
   });
 }
@@ -15277,16 +15959,16 @@ function flattenError(error, mapper = (issue2) => issue2.message) {
 }
 function formatError(error, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error2, path16 = []) => {
+  const processError = (error2, path18 = []) => {
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path16, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path18, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
       } else {
-        const fullpath = [...path16, ...issue2.path];
+        const fullpath = [...path18, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -15313,17 +15995,17 @@ function formatError(error, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error2, path16 = []) => {
+  const processError = (error2, path18 = []) => {
     var _a3, _b;
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path16, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path18, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
       } else {
-        const fullpath = [...path16, ...issue2.path];
+        const fullpath = [...path18, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -15355,8 +16037,8 @@ function treeifyError(error, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path16 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path16) {
+  const path18 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path18) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -16425,7 +17107,7 @@ function mergeValues(a, b) {
   if (a instanceof Date && b instanceof Date && +a === +b) {
     return { valid: true, data: a };
   }
-  if (isPlainObject2(a) && isPlainObject2(b)) {
+  if (isPlainObject4(a) && isPlainObject4(b)) {
     const bKeys = Object.keys(b);
     const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
     const newObj = { ...a, ...b };
@@ -17682,7 +18364,7 @@ var init_schemas = __esm(() => {
     $ZodType.init(inst, def);
     inst._zod.parse = (payload, ctx) => {
       const input = payload.value;
-      if (!isPlainObject2(input)) {
+      if (!isPlainObject4(input)) {
         payload.issues.push({
           expected: "record",
           code: "invalid_type",
@@ -28359,13 +29041,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path16 = ref.slice(1).split("/").filter(Boolean);
-  if (path16.length === 0) {
+  const path18 = ref.slice(1).split("/").filter(Boolean);
+  if (path18.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path16[0] === defsKey) {
-    const key = path16[1];
+  if (path18[0] === defsKey) {
+    const key = path18[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -29854,8 +30536,8 @@ class ParseStatus {
   }
 }
 var makeIssue = (params) => {
-  const { data, path: path16, errorMaps, issueData } = params;
-  const fullPath = [...path16, ...issueData.path || []];
+  const { data, path: path18, errorMaps, issueData } = params;
+  const fullPath = [...path18, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -29900,11 +30582,11 @@ var init_errorUtil = __esm(() => {
 
 // ../../node_modules/zod/v3/types.js
 class ParseInputLazyPath {
-  constructor(parent, value, path16, key) {
+  constructor(parent, value, path18, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path16;
+    this._path = path18;
     this._key = key;
   }
   get path() {
@@ -35901,19 +36583,19 @@ var require_token_io = __commonJS((exports, module) => {
     getUserDataDir: () => getUserDataDir
   });
   module.exports = __toCommonJS2(token_io_exports);
-  var import_path9 = __toESM2(__require("path"));
-  var import_fs6 = __toESM2(__require("fs"));
+  var import_path11 = __toESM2(__require("path"));
+  var import_fs8 = __toESM2(__require("fs"));
   var import_os3 = __toESM2(__require("os"));
   var import_token_error = require_token_error();
   function findRootDir() {
     try {
       let dir = process.cwd();
-      while (dir !== import_path9.default.dirname(dir)) {
-        const pkgPath = import_path9.default.join(dir, ".vercel");
-        if (import_fs6.default.existsSync(pkgPath)) {
+      while (dir !== import_path11.default.dirname(dir)) {
+        const pkgPath = import_path11.default.join(dir, ".vercel");
+        if (import_fs8.default.existsSync(pkgPath)) {
           return dir;
         }
-        dir = import_path9.default.dirname(dir);
+        dir = import_path11.default.dirname(dir);
       }
     } catch (e) {
       throw new import_token_error.VercelOidcTokenError("Token refresh only supported in node server environments");
@@ -35926,9 +36608,9 @@ var require_token_io = __commonJS((exports, module) => {
     }
     switch (import_os3.default.platform()) {
       case "darwin":
-        return import_path9.default.join(import_os3.default.homedir(), "Library/Application Support");
+        return import_path11.default.join(import_os3.default.homedir(), "Library/Application Support");
       case "linux":
-        return import_path9.default.join(import_os3.default.homedir(), ".local/share");
+        return import_path11.default.join(import_os3.default.homedir(), ".local/share");
       case "win32":
         if (process.env.LOCALAPPDATA) {
           return process.env.LOCALAPPDATA;
@@ -35969,23 +36651,23 @@ var require_auth_config = __commonJS((exports, module) => {
     writeAuthConfig: () => writeAuthConfig
   });
   module.exports = __toCommonJS2(auth_config_exports);
-  var fs11 = __toESM2(__require("fs"));
-  var path16 = __toESM2(__require("path"));
+  var fs13 = __toESM2(__require("fs"));
+  var path18 = __toESM2(__require("path"));
   var import_token_util = require_token_util();
   function getAuthConfigPath() {
     const dataDir = (0, import_token_util.getVercelDataDir)();
     if (!dataDir) {
       throw new Error(`Unable to find Vercel CLI data directory. Your platform: ${process.platform}. Supported: darwin, linux, win32.`);
     }
-    return path16.join(dataDir, "auth.json");
+    return path18.join(dataDir, "auth.json");
   }
   function readAuthConfig() {
     try {
       const authPath = getAuthConfigPath();
-      if (!fs11.existsSync(authPath)) {
+      if (!fs13.existsSync(authPath)) {
         return null;
       }
-      const content = fs11.readFileSync(authPath, "utf8");
+      const content = fs13.readFileSync(authPath, "utf8");
       if (!content) {
         return null;
       }
@@ -35996,11 +36678,11 @@ var require_auth_config = __commonJS((exports, module) => {
   }
   function writeAuthConfig(config3) {
     const authPath = getAuthConfigPath();
-    const authDir = path16.dirname(authPath);
-    if (!fs11.existsSync(authDir)) {
-      fs11.mkdirSync(authDir, { mode: 504, recursive: true });
+    const authDir = path18.dirname(authPath);
+    if (!fs13.existsSync(authDir)) {
+      fs13.mkdirSync(authDir, { mode: 504, recursive: true });
     }
-    fs11.writeFileSync(authPath, JSON.stringify(config3, null, 2), { mode: 384 });
+    fs13.writeFileSync(authPath, JSON.stringify(config3, null, 2), { mode: 384 });
   }
   function isValidAccessToken(authConfig, expirationBufferMs = 0) {
     if (!authConfig.token)
@@ -36175,8 +36857,8 @@ var require_token_util = __commonJS((exports, module) => {
     saveToken: () => saveToken
   });
   module.exports = __toCommonJS2(token_util_exports);
-  var path16 = __toESM2(__require("path"));
-  var fs11 = __toESM2(__require("fs"));
+  var path18 = __toESM2(__require("path"));
+  var fs13 = __toESM2(__require("fs"));
   var import_token_error = require_token_error();
   var import_token_io = require_token_io();
   var import_auth_config = require_auth_config();
@@ -36188,7 +36870,7 @@ var require_token_util = __commonJS((exports, module) => {
     if (!dataDir) {
       return null;
     }
-    return path16.join(dataDir, vercelFolder);
+    return path18.join(dataDir, vercelFolder);
   }
   async function getVercelToken2(options) {
     const authConfig = (0, import_auth_config.readAuthConfig)();
@@ -36256,11 +36938,11 @@ var require_token_util = __commonJS((exports, module) => {
     if (!dir) {
       throw new import_token_error.VercelOidcTokenError("Unable to find project root directory. Have you linked your project with `vc link?`");
     }
-    const prjPath = path16.join(dir, ".vercel", "project.json");
-    if (!fs11.existsSync(prjPath)) {
+    const prjPath = path18.join(dir, ".vercel", "project.json");
+    if (!fs13.existsSync(prjPath)) {
       throw new import_token_error.VercelOidcTokenError("project.json not found, have you linked your project with `vc link?`");
     }
-    const prj = JSON.parse(fs11.readFileSync(prjPath, "utf8"));
+    const prj = JSON.parse(fs13.readFileSync(prjPath, "utf8"));
     if (typeof prj.projectId !== "string" && typeof prj.orgId !== "string") {
       throw new TypeError("Expected a string-valued projectId property. Try running `vc link` to re-link your project.");
     }
@@ -36271,11 +36953,11 @@ var require_token_util = __commonJS((exports, module) => {
     if (!dir) {
       throw new import_token_error.VercelOidcTokenError("Unable to find user data directory. Please reach out to Vercel support.");
     }
-    const tokenPath = path16.join(dir, "com.vercel.token", `${projectId}.json`);
+    const tokenPath = path18.join(dir, "com.vercel.token", `${projectId}.json`);
     const tokenJson = JSON.stringify(token);
-    fs11.mkdirSync(path16.dirname(tokenPath), { mode: 504, recursive: true });
-    fs11.writeFileSync(tokenPath, tokenJson);
-    fs11.chmodSync(tokenPath, 432);
+    fs13.mkdirSync(path18.dirname(tokenPath), { mode: 504, recursive: true });
+    fs13.writeFileSync(tokenPath, tokenJson);
+    fs13.chmodSync(tokenPath, 432);
     return;
   }
   function loadToken(projectId) {
@@ -36283,11 +36965,11 @@ var require_token_util = __commonJS((exports, module) => {
     if (!dir) {
       throw new import_token_error.VercelOidcTokenError("Unable to find user data directory. Please reach out to Vercel support.");
     }
-    const tokenPath = path16.join(dir, "com.vercel.token", `${projectId}.json`);
-    if (!fs11.existsSync(tokenPath)) {
+    const tokenPath = path18.join(dir, "com.vercel.token", `${projectId}.json`);
+    if (!fs13.existsSync(tokenPath)) {
       return null;
     }
-    const token = JSON.parse(fs11.readFileSync(tokenPath, "utf8"));
+    const token = JSON.parse(fs13.readFileSync(tokenPath, "utf8"));
     assertVercelOidcTokenResponse(token);
     return token;
   }
@@ -47129,37 +47811,37 @@ function createOpenAI(options = {}) {
   }, `ai-sdk/openai/${VERSION4}`);
   const createChatModel = (modelId) => new OpenAIChatLanguageModel(modelId, {
     provider: `${providerName}.chat`,
-    url: ({ path: path16 }) => `${baseURL}${path16}`,
+    url: ({ path: path18 }) => `${baseURL}${path18}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createCompletionModel = (modelId) => new OpenAICompletionLanguageModel(modelId, {
     provider: `${providerName}.completion`,
-    url: ({ path: path16 }) => `${baseURL}${path16}`,
+    url: ({ path: path18 }) => `${baseURL}${path18}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createEmbeddingModel = (modelId) => new OpenAIEmbeddingModel(modelId, {
     provider: `${providerName}.embedding`,
-    url: ({ path: path16 }) => `${baseURL}${path16}`,
+    url: ({ path: path18 }) => `${baseURL}${path18}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createImageModel = (modelId) => new OpenAIImageModel(modelId, {
     provider: `${providerName}.image`,
-    url: ({ path: path16 }) => `${baseURL}${path16}`,
+    url: ({ path: path18 }) => `${baseURL}${path18}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createTranscriptionModel = (modelId) => new OpenAITranscriptionModel(modelId, {
     provider: `${providerName}.transcription`,
-    url: ({ path: path16 }) => `${baseURL}${path16}`,
+    url: ({ path: path18 }) => `${baseURL}${path18}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createSpeechModel = (modelId) => new OpenAISpeechModel(modelId, {
     provider: `${providerName}.speech`,
-    url: ({ path: path16 }) => `${baseURL}${path16}`,
+    url: ({ path: path18 }) => `${baseURL}${path18}`,
     headers: getHeaders,
     fetch: options.fetch
   });
@@ -47172,7 +47854,7 @@ function createOpenAI(options = {}) {
   const createResponsesModel = (modelId) => {
     return new OpenAIResponsesLanguageModel(modelId, {
       provider: `${providerName}.responses`,
-      url: ({ path: path16 }) => `${baseURL}${path16}`,
+      url: ({ path: path18 }) => `${baseURL}${path18}`,
       headers: getHeaders,
       fetch: options.fetch,
       fileIdPrefixes: ["file-"]
@@ -63717,26 +64399,26 @@ var require_process = __commonJS((exports, module) => {
 
 // ../../node_modules/detect-libc/lib/filesystem.js
 var require_filesystem = __commonJS((exports, module) => {
-  var fs11 = __require("fs");
+  var fs13 = __require("fs");
   var LDD_PATH = "/usr/bin/ldd";
   var SELF_PATH = "/proc/self/exe";
   var MAX_LENGTH = 2048;
-  var readFileSync2 = (path16) => {
-    const fd = fs11.openSync(path16, "r");
+  var readFileSync2 = (path18) => {
+    const fd = fs13.openSync(path18, "r");
     const buffer = Buffer.alloc(MAX_LENGTH);
-    const bytesRead = fs11.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-    fs11.close(fd, () => {});
+    const bytesRead = fs13.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+    fs13.close(fd, () => {});
     return buffer.subarray(0, bytesRead);
   };
-  var readFile = (path16) => new Promise((resolve4, reject) => {
-    fs11.open(path16, "r", (err, fd) => {
+  var readFile = (path18) => new Promise((resolve4, reject) => {
+    fs13.open(path18, "r", (err, fd) => {
       if (err) {
         reject(err);
       } else {
         const buffer = Buffer.alloc(MAX_LENGTH);
-        fs11.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+        fs13.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
           resolve4(buffer.subarray(0, bytesRead));
-          fs11.close(fd, () => {});
+          fs13.close(fd, () => {});
         });
       }
     });
@@ -63841,11 +64523,11 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     return null;
   };
-  var familyFromInterpreterPath = (path16) => {
-    if (path16) {
-      if (path16.includes("/ld-musl-")) {
+  var familyFromInterpreterPath = (path18) => {
+    if (path18) {
+      if (path18.includes("/ld-musl-")) {
         return MUSL;
-      } else if (path16.includes("/ld-linux-")) {
+      } else if (path18.includes("/ld-linux-")) {
         return GLIBC;
       }
     }
@@ -63890,8 +64572,8 @@ var require_detect_libc = __commonJS((exports, module) => {
     cachedFamilyInterpreter = null;
     try {
       const selfContent = await readFile(SELF_PATH);
-      const path16 = interpreterPath(selfContent);
-      cachedFamilyInterpreter = familyFromInterpreterPath(path16);
+      const path18 = interpreterPath(selfContent);
+      cachedFamilyInterpreter = familyFromInterpreterPath(path18);
     } catch (e) {}
     return cachedFamilyInterpreter;
   };
@@ -63902,8 +64584,8 @@ var require_detect_libc = __commonJS((exports, module) => {
     cachedFamilyInterpreter = null;
     try {
       const selfContent = readFileSync2(SELF_PATH);
-      const path16 = interpreterPath(selfContent);
-      cachedFamilyInterpreter = familyFromInterpreterPath(path16);
+      const path18 = interpreterPath(selfContent);
+      cachedFamilyInterpreter = familyFromInterpreterPath(path18);
     } catch (e) {}
     return cachedFamilyInterpreter;
   };
@@ -65565,18 +66247,18 @@ var require_sharp = __commonJS((exports, module) => {
     `@img/sharp-${runtimePlatform}/sharp.node`,
     "@img/sharp-wasm32/sharp.node"
   ];
-  var path16;
+  var path18;
   var sharp;
   var errors4 = [];
-  for (path16 of paths) {
+  for (path18 of paths) {
     try {
-      sharp = __require(path16);
+      sharp = __require(path18);
       break;
     } catch (err) {
       errors4.push(err);
     }
   }
-  if (sharp && path16.startsWith("@img/sharp-linux-x64") && !sharp._isUsingX64V2()) {
+  if (sharp && path18.startsWith("@img/sharp-linux-x64") && !sharp._isUsingX64V2()) {
     const err = new Error("Prebuilt binaries for linux-x64 require v2 microarchitecture");
     err.code = "Unsupported CPU";
     errors4.push(err);
@@ -68438,15 +69120,15 @@ var require_color = __commonJS((exports, module) => {
     };
   }
   function wrapConversion(toModel, graph) {
-    const path16 = [graph[toModel].parent, toModel];
+    const path18 = [graph[toModel].parent, toModel];
     let fn = conversions_default[graph[toModel].parent][toModel];
     let cur = graph[toModel].parent;
     while (graph[cur].parent) {
-      path16.unshift(graph[cur].parent);
+      path18.unshift(graph[cur].parent);
       fn = link(conversions_default[graph[cur].parent][cur], fn);
       cur = graph[cur].parent;
     }
-    fn.conversion = path16;
+    fn.conversion = path18;
     return fn;
   }
   function route(fromModel) {
@@ -69051,7 +69733,7 @@ var require_output = __commonJS((exports, module) => {
     Copyright 2013 Lovell Fuller and others.
     SPDX-License-Identifier: Apache-2.0
   */
-  var path16 = __require("path");
+  var path18 = __require("path");
   var is = require_is();
   var sharp = require_sharp();
   var formats = new Map([
@@ -69082,9 +69764,9 @@ var require_output = __commonJS((exports, module) => {
     let err;
     if (!is.string(fileOut)) {
       err = new Error("Missing output file path");
-    } else if (is.string(this.options.input.file) && path16.resolve(this.options.input.file) === path16.resolve(fileOut)) {
+    } else if (is.string(this.options.input.file) && path18.resolve(this.options.input.file) === path18.resolve(fileOut)) {
       err = new Error("Cannot use same file for input and output");
-    } else if (jp2Regex.test(path16.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
+    } else if (jp2Regex.test(path18.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
       err = errJp2Save();
     }
     if (err) {
@@ -76331,11 +77013,11 @@ var init_transformers_node = __esm(() => {
             throw new Error(`The number of external data chunks (${num_chunks}) exceeds the maximum allowed value (${_utils_hub_js__WEBPACK_IMPORTED_MODULE_5__.MAX_EXTERNAL_DATA_CHUNKS}).`);
           }
           for (let i = 0;i < num_chunks; ++i) {
-            const path16 = `${baseName}_data${i === 0 ? "" : "_" + i}`;
-            const fullPath = `${options.subfolder ?? ""}/${path16}`;
+            const path18 = `${baseName}_data${i === 0 ? "" : "_" + i}`;
+            const fullPath = `${options.subfolder ?? ""}/${path18}`;
             externalDataPromises.push(new Promise(async (resolve4, reject) => {
               const data = await (0, _utils_hub_js__WEBPACK_IMPORTED_MODULE_5__.getModelFile)(pretrained_model_name_or_path, fullPath, true, options, return_path);
-              resolve4(data instanceof Uint8Array ? { path: path16, data } : path16);
+              resolve4(data instanceof Uint8Array ? { path: path18, data } : path18);
             }));
           }
         } else if (session_options.externalData !== undefined) {
@@ -89399,7 +90081,7 @@ ${fake_token_around_image}` + `${global_img_token}` + image_token.repeat(image_s
           const blob = new Blob([wav], { type: "audio/wav" });
           return blob;
         }
-        async save(path16) {
+        async save(path18) {
           let fn;
           if (_env_js__WEBPACK_IMPORTED_MODULE_3__.apis.IS_BROWSER_ENV) {
             if (_env_js__WEBPACK_IMPORTED_MODULE_3__.apis.IS_WEBWORKER_ENV) {
@@ -89407,14 +90089,14 @@ ${fake_token_around_image}` + `${global_img_token}` + image_token.repeat(image_s
             }
             fn = _core_js__WEBPACK_IMPORTED_MODULE_2__.saveBlob;
           } else if (_env_js__WEBPACK_IMPORTED_MODULE_3__.apis.IS_FS_AVAILABLE) {
-            fn = async (path17, blob) => {
+            fn = async (path19, blob) => {
               let buffer = await blob.arrayBuffer();
-              node_fs__WEBPACK_IMPORTED_MODULE_5__["default"].writeFileSync(path17, Buffer.from(buffer));
+              node_fs__WEBPACK_IMPORTED_MODULE_5__["default"].writeFileSync(path19, Buffer.from(buffer));
             };
           } else {
             throw new Error("Unable to save because filesystem is disabled in this environment.");
           }
-          await fn(path16, this.toBlob());
+          await fn(path18, this.toBlob());
         }
       }
     },
@@ -89510,11 +90192,11 @@ ${fake_token_around_image}` + `${global_img_token}` + image_token.repeat(image_s
       function calculateReflectOffset(i, w) {
         return Math.abs((i + w) % (2 * w) - w);
       }
-      function saveBlob(path16, blob) {
+      function saveBlob(path18, blob) {
         const dataURL = URL.createObjectURL(blob);
         const downloadLink = document.createElement("a");
         downloadLink.href = dataURL;
-        downloadLink.download = path16;
+        downloadLink.download = path18;
         downloadLink.click();
         downloadLink.remove();
         URL.revokeObjectURL(dataURL);
@@ -90115,8 +90797,8 @@ ${fake_token_around_image}` + `${global_img_token}` + image_token.repeat(image_s
       }
 
       class FileCache {
-        constructor(path16) {
-          this.path = path16;
+        constructor(path18) {
+          this.path = path18;
         }
         async match(request) {
           let filePath = node_path__WEBPACK_IMPORTED_MODULE_1__["default"].join(this.path, request);
@@ -90872,20 +91554,20 @@ ${fake_token_around_image}` + `${global_img_token}` + image_token.repeat(image_s
           }
           return this;
         }
-        async save(path16) {
+        async save(path18) {
           if (IS_BROWSER_OR_WEBWORKER) {
             if (_env_js__WEBPACK_IMPORTED_MODULE_2__.apis.IS_WEBWORKER_ENV) {
               throw new Error("Unable to save an image from a Web Worker.");
             }
-            const extension = path16.split(".").pop().toLowerCase();
+            const extension = path18.split(".").pop().toLowerCase();
             const mime = CONTENT_TYPE_MAP.get(extension) ?? "image/png";
             const blob = await this.toBlob(mime);
-            (0, _core_js__WEBPACK_IMPORTED_MODULE_0__.saveBlob)(path16, blob);
+            (0, _core_js__WEBPACK_IMPORTED_MODULE_0__.saveBlob)(path18, blob);
           } else if (!_env_js__WEBPACK_IMPORTED_MODULE_2__.apis.IS_FS_AVAILABLE) {
             throw new Error("Unable to save the image because filesystem is disabled in this environment.");
           } else {
             const img = this.toSharp();
-            return await img.toFile(path16);
+            return await img.toFile(path18);
           }
         }
         toSharp() {
@@ -100416,10 +101098,10 @@ Note that ${s.bold("include")} statements only accept relation fields.`, a;
       super(t, "P2023", r);
     }
   };
-  var fs11 = new WeakMap;
+  var fs13 = new WeakMap;
   function Ep(e) {
-    let t = fs11.get(e);
-    return t || (t = Object.entries(e), fs11.set(e, t)), t;
+    let t = fs13.get(e);
+    return t || (t = Object.entries(e), fs13.set(e, t)), t;
   }
   function hs(e, t, r) {
     switch (t.type) {
@@ -104387,7 +105069,7 @@ var require_prisma = __commonJS((exports) => {
   Prisma.JsonNull = JsonNull2;
   Prisma.AnyNull = AnyNull2;
   Prisma.NullTypes = NullTypes2;
-  var path16 = __require("path");
+  var path18 = __require("path");
   exports.Prisma.TransactionIsolationLevel = makeStrictEnum2({
     ReadUncommitted: "ReadUncommitted",
     ReadCommitted: "ReadCommitted",
@@ -117260,10 +117942,10 @@ var init_chunker_code = __esm(() => {
 });
 
 // ../../packages/core/dist/services/search/smart-chunker.js
-import path16 from "path";
+import path18 from "path";
 function smartChunk(content, filePath, config3 = {}) {
   const cfg = { ...DEFAULT_CONFIG, ...config3 };
-  const ext2 = path16.extname(filePath).toLowerCase();
+  const ext2 = path18.extname(filePath).toLowerCase();
   const relativePath = filePath;
   const fileImports = isCodeFile(ext2) ? extractFileImports(content, ext2) : undefined;
   let chunks;
@@ -117570,8 +118252,8 @@ var init_managed_run_repository_pg = __esm(() => {
 });
 
 // ../../packages/core/dist/services/search/project-indexer.js
-import fs11 from "fs/promises";
-import path17 from "path";
+import fs13 from "fs/promises";
+import path19 from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 async function runWithIndexLock(lockMap, projectId, work) {
   const prevLock = lockMap.get(projectId);
@@ -117614,7 +118296,7 @@ async function indexProjectInternal(deps, projectPath, projectId, options = {})
       dot: false
     });
     const filteredFiles = files.filter((file2) => {
-      const relativePath = path17.relative(projectPath, file2);
+      const relativePath = path19.relative(projectPath, file2);
       const shouldIgnore = ig.ignores(relativePath);
       if (shouldIgnore) {
         logger.debug("Ignoring file per .gitignore during indexing", {
@@ -117654,7 +118336,7 @@ async function indexProjectInternal(deps, projectPath, projectId, options = {})
         });
       }
     }
-    const indexedFilesList = filteredFiles.map((f) => path17.relative(projectPath, f));
+    const indexedFilesList = filteredFiles.map((f) => path19.relative(projectPath, f));
     await deps.indexManager.updateIndexMetadata(projectId, projectPath, indexedFilesList);
     logger.info("Project indexing completed", {
       projectId,
@@ -117779,7 +118461,7 @@ async function ensureFreshIndex(deps, projectId, projectPath, options = {}) {
   let errors4 = 0;
   for (const relativeFilePath of filesToReindex) {
     try {
-      const fullPath = path17.join(projectPath, relativeFilePath);
+      const fullPath = path19.join(projectPath, relativeFilePath);
       const result = await deps.indexFile(fullPath, projectId, projectPath, centralityMap);
       filesIndexed++;
       chunksIndexed += result.chunks;
@@ -117830,8 +118512,8 @@ async function checkSearchAdmission(deps, projectId, projectPath) {
 }
 async function indexFile(deps, filePath, projectId, projectRoot, centralityMap) {
   projectId = await getProjectIdentityAliasResolver().resolve(projectId);
-  const content = await fs11.readFile(filePath, "utf-8");
-  const relativePath = path17.relative(projectRoot, filePath);
+  const content = await fs13.readFile(filePath, "utf-8");
+  const relativePath = path19.relative(projectRoot, filePath);
   const maxFileSize = config.get("security").maxFileSize || 1024 * 1024;
   if (content.length > maxFileSize) {
     logger.warn("File too large, skipping", {
@@ -117851,7 +118533,7 @@ async function indexFile(deps, filePath, projectId, projectRoot, centralityMap)
       chunkIndex: i,
       totalChunks: chunks.length,
       type: chunk.type,
-      language: path17.extname(filePath).slice(1),
+      language: path19.extname(filePath).slice(1),
       lineStart: chunk.lineStart,
       lineEnd: chunk.lineEnd,
       label: chunk.label,
@@ -121182,16 +121864,16 @@ function detectRoutes(httpEdges, defs, opts = {}) {
   const seen = new Set;
   const out = [];
   for (const e of httpEdges) {
-    const path18 = e.route;
-    if (!path18)
+    const path20 = e.route;
+    if (!path20)
       continue;
     const method = (e.method ?? "ANY").toUpperCase();
-    const key = method + " " + path18;
+    const key = method + " " + path20;
     if (seen.has(key))
       continue;
     seen.add(key);
     out.push({
-      path: path18,
+      path: path20,
       method: e.method,
       file: e.fromFile,
       handler: e.targetFqn ?? e.symbolName
@@ -121202,12 +121884,12 @@ function detectRoutes(httpEdges, defs, opts = {}) {
       continue;
     const parsed = parseRouteName(d.name);
     const method = parsed?.method ?? "ANY";
-    const path18 = parsed?.path ?? d.name;
-    const key = method + " " + path18;
+    const path20 = parsed?.path ?? d.name;
+    const key = method + " " + path20;
     if (seen.has(key))
       continue;
     seen.add(key);
-    out.push({ path: path18, method: parsed?.method, file: d.filePath, handler: d.name });
+    out.push({ path: path20, method: parsed?.method, file: d.filePath, handler: d.name });
   }
   for (const d of defs) {
     const parsed = parseRouteName(d.name);
@@ -121428,8 +122110,8 @@ __export(exports_symbol_graph_service, {
   symbolGraphService: () => symbolGraphService,
   SymbolGraphService: () => SymbolGraphService
 });
-import path18 from "path";
-import fs12 from "fs/promises";
+import path20 from "path";
+import fs14 from "fs/promises";
 
 class SymbolGraphService {
   identityLookup;
@@ -121757,7 +122439,7 @@ class SymbolGraphService {
   async readSnippet(relativePath, lineStart, lineEnd, projectId) {
     try {
       const absolutePath = await this.resolveToAbsolute(relativePath, projectId);
-      const content = await fs12.readFile(absolutePath, "utf-8");
+      const content = await fs14.readFile(absolutePath, "utf-8");
       const lines = content.split(`
 `);
       return lines.slice(Math.max(0, lineStart - 1), Math.min(lines.length, lineEnd)).join(`
@@ -121769,7 +122451,7 @@ class SymbolGraphService {
   async readContext(relativePath, lineNumber, contextLines, projectId) {
     try {
       const absolutePath = await this.resolveToAbsolute(relativePath, projectId);
-      const content = await fs12.readFile(absolutePath, "utf-8");
+      const content = await fs14.readFile(absolutePath, "utf-8");
       const lines = content.split(`
 `);
       const start = Math.max(0, lineNumber - contextLines - 1);
@@ -121782,7 +122464,7 @@ class SymbolGraphService {
   }
   async resolveToAbsolute(relativePath, projectId) {
     const root = await this.getProjectRoot(projectId);
-    return root ? path18.resolve(root, relativePath) : relativePath;
+    return root ? path20.resolve(root, relativePath) : relativePath;
   }
   async getProjectRoot(projectId) {
     const cached2 = this.projectRootCache.get(projectId);
@@ -123560,31 +124242,31 @@ class TracePathService {
     const chains = [];
     const seen = new Set;
     let walks = 0;
-    const walk = (fqn, path19) => {
+    const walk = (fqn, path21) => {
       if (chains.length >= CHAIN_CAP)
         return;
       if (walks >= MAX_WALKS)
         return;
       walks++;
-      const key = path19.join("\u2192");
+      const key = path21.join("\u2192");
       if (seen.has(key))
         return;
       seen.add(key);
       const next = adj.get(fqn);
       if (!next || next.length === 0 || !whoHasChild.has(fqn)) {
-        if (path19.length > 1)
-          chains.push(path19.map((n) => this.fqnToName(n)).join(" \u2192 "));
+        if (path21.length > 1)
+          chains.push(path21.map((n) => this.fqnToName(n)).join(" \u2192 "));
         return;
       }
       for (const child of next) {
         if (chains.length >= CHAIN_CAP || walks >= MAX_WALKS)
           return;
-        if (path19.includes(child)) {
-          const cycled = [...path19, `${this.fqnToName(child)}\u21BA`];
+        if (path21.includes(child)) {
+          const cycled = [...path21, `${this.fqnToName(child)}\u21BA`];
           chains.push(cycled.map((n) => n).join(" \u2192 "));
           continue;
         }
-        walk(child, [...path19, child]);
+        walk(child, [...path21, child]);
       }
     };
     for (const seed of seeds) {
@@ -125578,9 +126260,9 @@ var init_l1_memory_cache = __esm(() => {
 });
 
 // ../../packages/core/dist/services/health/local-health-checker.js
-import fs13 from "fs/promises";
+import fs15 from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
-import path19 from "path";
+import path21 from "path";
 
 class LocalHealthChecker {
   ollamaBaseUrl = process.env.OLLAMA_BASE_URL || "http://localhost:11434";
@@ -125614,10 +126296,10 @@ class LocalHealthChecker {
     const start = Date.now();
     try {
       if (!existsSync3(this.dataDir))
-        await fs13.mkdir(this.dataDir, { recursive: true });
-      const probe = path19.join(this.dataDir, ".health-check-test");
-      await fs13.writeFile(probe, "ok");
-      await fs13.unlink(probe);
+        await fs15.mkdir(this.dataDir, { recursive: true });
+      const probe = path21.join(this.dataDir, ".health-check-test");
+      await fs15.writeFile(probe, "ok");
+      await fs15.unlink(probe);
       return { available: true, latency: Date.now() - start, details: { path: this.dataDir, writable: true } };
     } catch (error51) {
       return { available: false, latency: Date.now() - start, error: `Data directory error: ${error51.message}` };
@@ -128895,9 +129577,9 @@ var init_scheduler2 = __esm(() => {
 });
 
 // ../../packages/core/dist/services/pricing/models-dev-client.js
-import fs14 from "fs/promises";
+import fs16 from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import path20 from "path";
+import path22 from "path";
 function getModelsDevClient() {
   if (!clientInstance) {
     clientInstance = new ModelsDevClient;
@@ -128917,7 +129599,7 @@ var init_models_dev_client = __esm(() => {
     memoryCacheTimestamp = 0;
     getLocalCachePath() {
       const dataDir = config.get("dataDir");
-      return path20.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
+      return path22.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
     }
     async loadLocalCache() {
       const cachePath = this.getLocalCachePath();
@@ -128925,7 +129607,7 @@ var init_models_dev_client = __esm(() => {
         if (!existsSync4(cachePath)) {
           return null;
         }
-        const content = await fs14.readFile(cachePath, "utf-8");
+        const content = await fs16.readFile(cachePath, "utf-8");
         const data = JSON.parse(content);
         const age = Date.now() - data.timestamp;
         if (age > ModelsDevClient.LOCAL_CACHE_TTL) {
@@ -128952,14 +129634,14 @@ var init_models_dev_client = __esm(() => {
     async saveLocalCache(models) {
       const cachePath = this.getLocalCachePath();
       try {
-        const dir = path20.dirname(cachePath);
-        await fs14.mkdir(dir, { recursive: true });
+        const dir = path22.dirname(cachePath);
+        await fs16.mkdir(dir, { recursive: true });
         const data = {
           timestamp: Date.now(),
           version: "1.0.0",
           models: Object.fromEntries(models)
         };
-        await fs14.writeFile(cachePath, JSON.stringify(data), "utf-8");
+        await fs16.writeFile(cachePath, JSON.stringify(data), "utf-8");
         logger.debug("Saved pricing to local cache", {
           models: models.size,
           path: cachePath
@@ -129288,7 +129970,7 @@ var init_models_dev_client = __esm(() => {
       const cachePath = this.getLocalCachePath();
       try {
         if (existsSync4(cachePath)) {
-          await fs14.unlink(cachePath);
+          await fs16.unlink(cachePath);
           logger.debug("Local pricing cache file deleted");
         }
       } catch (error51) {
@@ -129891,8 +130573,8 @@ function stripNul(content) {
 }
 
 // ../../packages/core/dist/services/etl/stages/discover.js
-import fs15 from "fs/promises";
-import path21 from "path";
+import fs17 from "fs/promises";
+import path23 from "path";
 import { createHash as createHash8 } from "crypto";
 
 class DiscoverStage {
@@ -129918,7 +130600,7 @@ class DiscoverStage {
         dot: false,
         absolute: false
       });
-      relPaths = found.map((p) => path21.isAbsolute(p) ? path21.relative(ctx.projectPath, p) : p).filter((p) => !ig.ignores(p) && applyPolicy(p, policy) !== "Drop");
+      relPaths = found.map((p) => path23.isAbsolute(p) ? path23.relative(ctx.projectPath, p) : p).filter((p) => !ig.ignores(p) && applyPolicy(p, policy) !== "Drop");
     }
     if (ctx.resumeCursor?.path) {
       const cursorPath = ctx.resumeCursor.path;
@@ -129977,10 +130659,10 @@ class DiscoverStage {
     return discovered;
   }
   async processFile(ctx, relativePath, forceReindex) {
-    const absolutePath = path21.join(ctx.projectPath, relativePath);
+    const absolutePath = path23.join(ctx.projectPath, relativePath);
     try {
-      const stat = await fs15.stat(absolutePath);
-      const content = stripNul(await fs15.readFile(absolutePath, "utf-8"));
+      const stat = await fs17.stat(absolutePath);
+      const content = stripNul(await fs17.readFile(absolutePath, "utf-8"));
       const contentHash = createHash8("sha256").update(content).digest("hex");
       let needsReparse = forceReindex;
       if (!forceReindex) {
@@ -130023,8 +130705,8 @@ class DiscoverStage {
       ig.add(pattern);
     }
     try {
-      const gitignorePath = path21.join(projectPath, ".gitignore");
-      const gitignoreContent = await fs15.readFile(gitignorePath, "utf8");
+      const gitignorePath = path23.join(projectPath, ".gitignore");
+      const gitignoreContent = await fs17.readFile(gitignorePath, "utf8");
       const rules = gitignoreContent.split(`
 `).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
       ig.add(rules);
@@ -131379,8 +132061,8 @@ function rustUseLeaves(node, source, prefix = []) {
   }
   if (node.type === "use_wildcard")
     return [{ path: [...prefix, "*"], glob: true }];
-  const path22 = rustPathSegments(node, source);
-  return path22.length ? [{ path: [...prefix, ...path22] }] : [];
+  const path24 = rustPathSegments(node, source);
+  return path24.length ? [{ path: [...prefix, ...path24] }] : [];
 }
 function functionalCaptures(captures, source, family) {
   if (family !== "clojure")
@@ -132352,8 +133034,8 @@ var init_structural_runtime = __esm(() => {
 });
 
 // ../../packages/core/dist/services/etl/stages/parse.js
-import path22 from "path";
-import fs16 from "fs/promises";
+import path24 from "path";
+import fs18 from "fs/promises";
 function resolveChunkerMaxChars() {
   const global2 = Number(process.env.EMBEDDING_MAX_CHARS);
   if (Number.isFinite(global2) && global2 > 0)
@@ -132381,8 +133063,8 @@ class ParseStage {
     const results = new Map;
     let processed = 0;
     const phases = [
-      files.filter((file2) => path22.extname(file2.relativePath).toLowerCase() !== ".h"),
-      files.filter((file2) => path22.extname(file2.relativePath).toLowerCase() === ".h")
+      files.filter((file2) => path24.extname(file2.relativePath).toLowerCase() !== ".h"),
+      files.filter((file2) => path24.extname(file2.relativePath).toLowerCase() === ".h")
     ];
     const batches = phases.flatMap((phase) => Array.from({ length: Math.ceil(phase.length / BATCH_SIZE) }, (_, index) => phase.slice(index * BATCH_SIZE, (index + 1) * BATCH_SIZE)));
     for (const batch of batches) {
@@ -132420,19 +133102,19 @@ class ParseStage {
     return files.map((file2) => results.get(file2.relativePath));
   }
   recordHeaderImporterEvidence(ctx, files, parsedFiles) {
-    const knownHeaders = new Set(files.filter((file2) => path22.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path22.posix.normalize(file2.relativePath)));
+    const knownHeaders = new Set(files.filter((file2) => path24.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path24.posix.normalize(file2.relativePath)));
     const mutable = {
       ...ctx.structuralHeaderEvidenceByFile
     };
     for (const parsed of parsedFiles) {
-      const extension = path22.extname(parsed.file.relativePath).toLowerCase();
+      const extension = path24.extname(parsed.file.relativePath).toLowerCase();
       const key = extension === ".c" ? "cImporters" : [".cpp", ".hpp"].includes(extension) ? "cppImporters" : undefined;
       if (!key)
         continue;
       for (const imported of parsed.rawImports) {
         if (!["c_include", "cpp_include"].includes(imported.form) || imported.specifier.startsWith("<"))
           continue;
-        const header = path22.posix.normalize(path22.posix.join(path22.posix.dirname(parsed.file.relativePath), imported.specifier));
+        const header = path24.posix.normalize(path24.posix.join(path24.posix.dirname(parsed.file.relativePath), imported.specifier));
         if (!knownHeaders.has(header))
           continue;
         const existing = mutable[header] ?? {};
@@ -132443,9 +133125,9 @@ class ParseStage {
   }
   async parseFile(ctx, file2) {
     if (!file2.needsReparse) {
-      const extension = path22.extname(file2.relativePath).toLowerCase();
+      const extension = path24.extname(file2.relativePath).toLowerCase();
       if ([".c", ".cpp", ".hpp"].includes(extension)) {
-        const content = file2.snapshotContent ?? await fs16.readFile(file2.absolutePath, "utf8");
+        const content = file2.snapshotContent ?? await fs18.readFile(file2.absolutePath, "utf8");
         const outcome = await this.runtime.parse({ extension, source: Buffer.from(content) });
         if (outcome.status === "failed")
           throw new StructuralEtlParseError(file2.relativePath, outcome.failureKind, `Structural evidence parse failed (${outcome.failureKind})`, outcome.diagnosticCount, outcome.diagnostics.slice(0, 10));
@@ -132457,8 +133139,8 @@ class ParseStage {
       return { file: file2, chunks: [], symbols: [], rawImports: [], rawEdges: [] };
     }
     try {
-      const content = file2.snapshotContent ?? await fs16.readFile(file2.absolutePath, "utf-8");
-      const ext2 = path22.extname(file2.relativePath).toLowerCase();
+      const content = file2.snapshotContent ?? await fs18.readFile(file2.absolutePath, "utf-8");
+      const ext2 = path24.extname(file2.relativePath).toLowerCase();
       const chunkerMaxChars = resolveChunkerMaxChars();
       const chunks = smartChunk(content, file2.relativePath, chunkerMaxChars ? { maxChunkChars: chunkerMaxChars } : {});
       let symbols;
@@ -133012,7 +133694,7 @@ var init_resolver = __esm(() => {
 });
 
 // ../../packages/core/dist/services/structural/resolvers/typescript.js
-import path23 from "path";
+import path25 from "path";
 function candidates(identities) {
   return Object.freeze(identities.map((identity) => Object.freeze({
     fqn: identity.fqn,
@@ -133107,7 +133789,7 @@ function probe(base, known, dialect = "typescript") {
   const bases = /\.[cm]?jsx?$/u.test(base) ? [base.replace(/\.[cm]?jsx?$/u, ".ts"), base.replace(/\.[cm]?jsx?$/u, ".tsx"), base] : [base];
   for (const candidateBase of bases)
     for (const suffix of DIALECT_PROBES[dialect] ?? [""]) {
-      const value = path23.posix.normalize(`${candidateBase}${suffix}`);
+      const value = path25.posix.normalize(`${candidateBase}${suffix}`);
       if (!value.startsWith("../") && value !== ".." && known.has(value))
         return value;
     }
@@ -133116,7 +133798,7 @@ function probe(base, known, dialect = "typescript") {
 function resolveStructuralSpecifier(specifier, fromFile, build, dialect = "typescript") {
   const known = new Set(build.knownFiles.map(normalizeStructuralFile));
   if (specifier.startsWith("./") || specifier.startsWith("../")) {
-    return probe(path23.posix.join(path23.posix.dirname(fromFile), specifier), known, dialect);
+    return probe(path25.posix.join(path25.posix.dirname(fromFile), specifier), known, dialect);
   }
   const aliases = build.pathAliasesByFile?.[normalizeStructuralFile(fromFile)] ?? build.pathAliases ?? [];
   for (const alias of aliases) {
@@ -133380,7 +134062,7 @@ var init_scripting2 = __esm(() => {
 });
 
 // ../../packages/core/dist/services/structural/resolvers/systems.js
-import path24 from "path";
+import path26 from "path";
 var DIALECTS, SYSTEMS_LANGUAGE_RESOLVER;
 var init_systems2 = __esm(() => {
   init_typescript2();
@@ -133399,7 +134081,7 @@ var init_systems2 = __esm(() => {
           const bindings = item.bindings.map((binding) => binding.imported === "*" && binding.local === "*" && unresolvedTarget && !unresolvedTarget.qualifier ? { ...binding, imported: unresolvedTarget.name, local: unresolvedTarget.name } : binding);
           if (item.specifier === "crate" || item.specifier.startsWith("crate/")) {
             const crateRoot = file2.file.startsWith("src/") ? "src" : "";
-            return { ...item, bindings, specifier: `./${path24.posix.relative(path24.posix.dirname(file2.file), path24.posix.join(crateRoot, item.specifier.replace(/^crate\/?/u, "")))}` };
+            return { ...item, bindings, specifier: `./${path26.posix.relative(path26.posix.dirname(file2.file), path26.posix.join(crateRoot, item.specifier.replace(/^crate\/?/u, "")))}` };
           }
           if (item.specifier === "self" || item.specifier.startsWith("self/"))
             return { ...item, bindings, specifier: `./${item.specifier.replace(/^self\/?/u, "")}` };
@@ -133497,8 +134179,8 @@ var init_data_document2 = __esm(() => {
 });
 
 // ../../packages/core/dist/services/etl/stages/resolve.js
-import path25 from "path";
-import fs17 from "fs";
+import path27 from "path";
+import fs19 from "fs";
 
 class ResolveStage {
   symbolRepository;
@@ -133522,7 +134204,7 @@ class ResolveStage {
     const structuralDocuments = files.flatMap((file2) => {
       if (!file2.structure)
         return [];
-      const language = resolveStructuralLanguage(path25.extname(file2.file.relativePath));
+      const language = resolveStructuralLanguage(path27.extname(file2.file.relativePath));
       if (language.status !== "supported")
         throw new Error(`structural_manifest_missing:${file2.file.relativePath}`);
       return [{
@@ -133534,13 +134216,13 @@ class ResolveStage {
       }];
     });
     const currentStructuralFiles = new Set(structuralDocuments.map((document2) => document2.file));
-    const skippedStructuralFiles = new Set(files.filter((item) => !item.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path25.extname(item.file.relativePath).toLowerCase())).map((item) => item.file.relativePath));
+    const skippedStructuralFiles = new Set(files.filter((item) => !item.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path27.extname(item.file.relativePath).toLowerCase())).map((item) => item.file.relativePath));
     const pathAliasesByFile = Object.fromEntries([...knownRelPaths].map((file2) => [
       file2,
       this.structuralAliasesFor(file2, rootAliases, monorepoPackages)
     ]));
     const buildMetadata = { knownFiles: [...knownRelPaths], pathAliasesByFile };
-    const seedRows = repositoryDefinitions.filter((definition) => STRUCTURAL_SEED_EXTENSIONS.has(path25.extname(definition.file_path).toLowerCase())).filter((definition) => knownRelPaths.has(definition.file_path) && skippedStructuralFiles.has(definition.file_path)).filter((definition) => !currentStructuralFiles.has(definition.file_path));
+    const seedRows = repositoryDefinitions.filter((definition) => STRUCTURAL_SEED_EXTENSIONS.has(path27.extname(definition.file_path).toLowerCase())).filter((definition) => knownRelPaths.has(definition.file_path) && skippedStructuralFiles.has(definition.file_path)).filter((definition) => !currentStructuralFiles.has(definition.file_path));
     const seedIds = new Set;
     for (const definition of seedRows) {
       if (seedIds.has(definition.id))
@@ -133633,7 +134315,7 @@ class ResolveStage {
     if (parsed.file !== definition.file_path) {
       throw new Error(`structural_repository_seed_file_mismatch:${definition.id}`);
     }
-    const language = resolveStructuralLanguage(path25.extname(definition.file_path));
+    const language = resolveStructuralLanguage(path27.extname(definition.file_path));
     if (language.status !== "supported")
       throw new Error(`structural_repository_seed_language:${definition.id}`);
     let identity;
@@ -133685,7 +134367,7 @@ class ResolveStage {
     });
   }
   resolveFile(parsed, projectPath, knownRelPaths, rootAliases, monorepoPackages, symbolIndex, knownFqns) {
-    const fromDir = path25.dirname(path25.join(projectPath, parsed.file.relativePath));
+    const fromDir = path27.dirname(path27.join(projectPath, parsed.file.relativePath));
     const packageAliases = this.getPackageAliases(parsed.file.relativePath, monorepoPackages);
     const allAliases = [...packageAliases, ...rootAliases];
     const resolvedImports = parsed.rawImports.map((raw2) => {
@@ -133756,7 +134438,7 @@ class ResolveStage {
         index.set(def.name, `${def.file_path}#${def.name}`);
       }
     } catch (err) {
-      const skippedStructural = files.some((file2) => !file2.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path25.extname(file2.file.relativePath).toLowerCase()));
+      const skippedStructural = files.some((file2) => !file2.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path27.extname(file2.file.relativePath).toLowerCase()));
       if (skippedStructural)
         throw new Error("structural_repository_seed_failed", { cause: err });
       logger.warn("buildSymbolIndex: repo seed failed, in-batch only", {
@@ -133780,7 +134462,7 @@ class ResolveStage {
   }
   resolveSpecifier(specifier, fromDir, projectPath, knownRelPaths, aliases) {
     if (specifier.startsWith("./") || specifier.startsWith("../")) {
-      const resolved = this.probeExtensions(path25.resolve(fromDir, specifier), projectPath, knownRelPaths);
+      const resolved = this.probeExtensions(path27.resolve(fromDir, specifier), projectPath, knownRelPaths);
       return { resolvedPath: resolved, external: false };
     }
     for (const alias of aliases) {
@@ -133788,8 +134470,8 @@ class ResolveStage {
         const suffix = specifier.slice(alias.prefix.length);
         for (const target of alias.targets) {
           const cleanTarget = target.replace(/\/\*$/, "");
-          const basePath = alias.packagePath ? path25.join(projectPath, alias.packagePath) : projectPath;
-          const absPath = path25.join(basePath, cleanTarget + suffix);
+          const basePath = alias.packagePath ? path27.join(projectPath, alias.packagePath) : projectPath;
+          const absPath = path27.join(basePath, cleanTarget + suffix);
           const resolved = this.probeExtensions(absPath, projectPath, knownRelPaths);
           if (resolved)
             return { resolvedPath: resolved, external: false };
@@ -133805,7 +134487,7 @@ class ResolveStage {
       ...TS_EXTENSIONS.map((ext2) => absPath.replace(/\.[^.]+$/, ext2))
     ];
     for (const candidate2 of candidates2) {
-      const rel = path25.relative(projectPath, candidate2).replace(/\\/g, "/");
+      const rel = path27.relative(projectPath, candidate2).replace(/\\/g, "/");
       if (knownRelPaths.has(rel))
         return rel;
     }
@@ -133813,9 +134495,9 @@ class ResolveStage {
   }
   loadTsConfigPaths(projectPath, packageBase) {
     const aliases = [];
-    const tsconfigPath = path25.join(projectPath, "tsconfig.json");
+    const tsconfigPath = path27.join(projectPath, "tsconfig.json");
     try {
-      const raw2 = fs17.readFileSync(tsconfigPath, "utf-8");
+      const raw2 = fs19.readFileSync(tsconfigPath, "utf-8");
       const stripped = raw2.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
       const tsconfig = JSON.parse(stripped);
       const paths = tsconfig?.compilerOptions?.paths ?? {};
@@ -133844,7 +134526,7 @@ class ResolveStage {
       }
     }
     for (const packageRelPath of packagePaths) {
-      const absPackagePath = path25.join(projectPath, packageRelPath);
+      const absPackagePath = path27.join(projectPath, packageRelPath);
       const aliases = this.loadTsConfigPaths(absPackagePath, packageRelPath);
       if (aliases.length > 0) {
         packages.push({
@@ -133874,7 +134556,7 @@ class ResolveStage {
   structuralAliasesFor(filePath, rootAliases, packages) {
     return [...this.getPackageAliases(filePath, packages), ...rootAliases].map((alias) => ({
       pattern: alias.prefix + (alias.targets.some((target) => target.includes("*")) ? "/*" : ""),
-      targets: alias.targets.map((target) => alias.packagePath ? path25.posix.join(alias.packagePath, target) : target)
+      targets: alias.targets.map((target) => alias.packagePath ? path27.posix.join(alias.packagePath, target) : target)
     }));
   }
 }
@@ -133938,7 +134620,7 @@ var init_with_deadlock_retry = __esm(() => {
 });
 
 // ../../packages/core/dist/services/etl/stages/load.js
-import path26 from "path";
+import path28 from "path";
 function formatDuration(ms) {
   const totalSec = Math.max(0, Math.round(ms / 1000));
   if (totalSec < 60)
@@ -134215,7 +134897,7 @@ class LoadStage {
     const filePath = file2.file.relativePath;
     const batch = buildSymbolPersistenceBatch(ctx.projectId, file2);
     if (ctx.graphGenerationLease) {
-      const manifest = getLanguageManifestEntry(path26.extname(filePath));
+      const manifest = getLanguageManifestEntry(path28.extname(filePath));
       const diagnostics2 = (file2.structuralDiagnostics ?? []).slice(0, 10).map((diagnostic2) => ({
         code: diagnostic2.code,
         severity: diagnostic2.severity,
@@ -134672,9 +135354,9 @@ var init_graph_generation_coordinator = __esm(() => {
 // ../../packages/core/dist/services/etl/pipeline.js
 import { createHash as createHash10 } from "crypto";
 import { setTimeout as delay2 } from "timers/promises";
-import path27 from "path";
+import path29 from "path";
 function buildHeaderLanguageEvidence(files) {
-  const headers = new Set(files.filter((file2) => path27.posix.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path27.posix.normalize(file2.relativePath)));
+  const headers = new Set(files.filter((file2) => path29.posix.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path29.posix.normalize(file2.relativePath)));
   const mutable = new Map;
   const entry2 = (header) => {
     let value = mutable.get(header);
@@ -134685,7 +135367,7 @@ function buildHeaderLanguageEvidence(files) {
     return value;
   };
   for (const file2 of files) {
-    if (path27.posix.basename(file2.relativePath) !== "compile_commands.json" || file2.snapshotContent === undefined)
+    if (path29.posix.basename(file2.relativePath) !== "compile_commands.json" || file2.snapshotContent === undefined)
       continue;
     let commands;
     try {
@@ -134701,11 +135383,11 @@ function buildHeaderLanguageEvidence(files) {
       const record2 = command;
       if (typeof record2.file !== "string")
         continue;
-      const projectRoot = path27.resolve(file2.absolutePath, ...file2.relativePath.split("/").map(() => ".."));
-      const commandDirectory = typeof record2.directory === "string" ? path27.resolve(projectRoot, record2.directory) : projectRoot;
-      const absoluteInput = path27.resolve(commandDirectory, record2.file);
-      const relative3 = path27.relative(projectRoot, absoluteInput);
-      const header = path27.posix.normalize(relative3.replaceAll(path27.sep, "/"));
+      const projectRoot = path29.resolve(file2.absolutePath, ...file2.relativePath.split("/").map(() => ".."));
+      const commandDirectory = typeof record2.directory === "string" ? path29.resolve(projectRoot, record2.directory) : projectRoot;
+      const absoluteInput = path29.resolve(commandDirectory, record2.file);
+      const relative3 = path29.relative(projectRoot, absoluteInput);
+      const header = path29.posix.normalize(relative3.replaceAll(path29.sep, "/"));
       if (!headers.has(header))
         continue;
       const invocation = typeof record2.command === "string" ? record2.command : Array.isArray(record2.arguments) ? record2.arguments.join(" ") : "";
@@ -140571,33 +141253,33 @@ var require_URL = __commonJS((exports, module) => {
         else
           return basepath.substring(0, lastslash + 1) + refpath;
       }
-      function remove_dot_segments(path28) {
-        if (!path28)
-          return path28;
+      function remove_dot_segments(path30) {
+        if (!path30)
+          return path30;
         var output = "";
-        while (path28.length > 0) {
-          if (path28 === "." || path28 === "..") {
-            path28 = "";
+        while (path30.length > 0) {
+          if (path30 === "." || path30 === "..") {
+            path30 = "";
             break;
           }
-          var twochars = path28.substring(0, 2);
-          var threechars = path28.substring(0, 3);
-          var fourchars = path28.substring(0, 4);
+          var twochars = path30.substring(0, 2);
+          var threechars = path30.substring(0, 3);
+          var fourchars = path30.substring(0, 4);
           if (threechars === "../") {
-            path28 = path28.substring(3);
+            path30 = path30.substring(3);
           } else if (twochars === "./") {
-            path28 = path28.substring(2);
+            path30 = path30.substring(2);
           } else if (threechars === "/./") {
-            path28 = "/" + path28.substring(3);
-          } else if (twochars === "/." && path28.length === 2) {
-            path28 = "/";
-          } else if (fourchars === "/../" || threechars === "/.." && path28.length === 3) {
-            path28 = "/" + path28.substring(4);
+            path30 = "/" + path30.substring(3);
+          } else if (twochars === "/." && path30.length === 2) {
+            path30 = "/";
+          } else if (fourchars === "/../" || threechars === "/.." && path30.length === 3) {
+            path30 = "/" + path30.substring(4);
             output = output.replace(/\/?[^\/]*$/, "");
           } else {
-            var segment = path28.match(/(\/?([^\/]*))/)[0];
+            var segment = path30.match(/(\/?([^\/]*))/)[0];
             output += segment;
-            path28 = path28.substring(segment.length);
+            path30 = path30.substring(segment.length);
           }
         }
         return output;
@@ -152667,21 +153349,21 @@ function jsonToKeyPathChunks(value, label = "$") {
   walk(value, label, out);
   return out;
 }
-function walk(val, path28, out) {
+function walk(val, path30, out) {
   if (val === null || val === undefined)
     return;
   if (Array.isArray(val)) {
     if (val.length === 0) {
-      out.push({ path: path28, content: `**${path28}** = _[]_` });
+      out.push({ path: path30, content: `**${path30}** = _[]_` });
       return;
     }
     if (val.every((v) => v !== null && typeof v === "object")) {
-      val.forEach((v, i) => walk(v, `${path28}[${i}]`, out));
+      val.forEach((v, i) => walk(v, `${path30}[${i}]`, out));
       return;
     }
     const items = val.map((v) => `- \`${String(v)}\``).join(`
 `);
-    out.push({ path: path28, content: `**${path28}**
+    out.push({ path: path30, content: `**${path30}**
 
 ${items}` });
     return;
@@ -152689,16 +153371,16 @@ ${items}` });
   if (typeof val === "object") {
     const entries = Object.entries(val);
     if (entries.length === 0) {
-      out.push({ path: path28, content: `**${path28}** = _{}_` });
+      out.push({ path: path30, content: `**${path30}** = _{}_` });
       return;
     }
     for (const [k, v] of entries) {
       const safeKey = /^[A-Za-z_$][\w$]*$/.test(k) ? k : JSON.stringify(k);
-      walk(v, `${path28}.${safeKey}`, out);
+      walk(v, `${path30}.${safeKey}`, out);
     }
     return;
   }
-  out.push({ path: path28, content: `**${path28}** = \`${String(val)}\`` });
+  out.push({ path: path30, content: `**${path30}** = \`${String(val)}\`` });
 }
 var gfm, STRIP_SELECTORS, tdCache = null;
 var init_html_to_md = __esm(() => {
@@ -153122,6 +153804,8 @@ var init_recover_project = __esm(() => {
 // src/config-cli.ts
 init_config();
 init_dist();
+import os8 from "os";
+import path30 from "path";
 var GENERATOR_MARKER = "scripts/generate-subagent-artifacts.ts";
 var GENERATOR_MARKER_MAX_LEVELS = 6;
 function formatVariantSync(results) {
@@ -153161,6 +153845,13 @@ Commands:
   profile set <name> [--host <h>] [--dry-run]
                     Switch installed agents to a profile (restart required after)
 
+  bootstrap list    List every startup-contract rule: state, default, description
+  bootstrap show    Same as 'bootstrap list'
+  bootstrap enable <rule-id> [--target <dir> --yes] [--dry-run]
+  bootstrap disable <rule-id> [--target <dir> --yes] [--dry-run]
+                    Toggle one rule and re-render MASSA-AI.md for every
+                    recorded host (restart required after)
+
 Examples:
   massa-ai-config init
   massa-ai-config init --mistral your-api-key
@@ -153169,6 +153860,8 @@ Examples:
   massa-ai-config set embedding.dimensions 1024
   massa-ai-config recover my-project --path /home/user/renamed-dir
   massa-ai-config profile set work --dry-run
+  massa-ai-config bootstrap list
+  massa-ai-config bootstrap disable caveman
 `);
 }
 function parseOptions(args) {
@@ -153392,6 +154085,62 @@ Using defaults:`);
       console.error("Usage: massa-ai-config profile <list|show|set> ...");
       return 1;
     }
+    case "bootstrap": {
+      const subcommand = args[1];
+      if (subcommand === "list" || subcommand === "show") {
+        try {
+          console.log(formatBootstrapInventory(resolveBootstrapState().state));
+        } catch (e) {
+          console.error(`Error: ${e.message}`);
+          return 1;
+        }
+        return 0;
+      }
+      if (subcommand === "enable" || subcommand === "disable") {
+        const ruleId = args[2];
+        if (!ruleId) {
+          console.error("Usage: massa-ai-config bootstrap <enable|disable> <rule-id> [--target <dir> --yes] [--dry-run]");
+          return 1;
+        }
+        try {
+          assertKnownRuleId(ruleId);
+        } catch (e) {
+          console.error(`Error: ${e.message}`);
+          return 1;
+        }
+        const targetOpt = typeof options.target === "string" ? options.target : undefined;
+        const targetHome = targetOpt === undefined ? os8.homedir() : path30.resolve(targetOpt);
+        if (targetHome !== os8.homedir() && options.yes !== true) {
+          console.error(`Error: --target ${targetHome} is not your home (${os8.homedir()}) \u2014 pass --yes to confirm writing there`);
+          return 1;
+        }
+        const dryRun = options["dry-run"] === true;
+        try {
+          if (dryRun) {
+            console.log(`bootstrap ${subcommand} ${ruleId}: dry run \u2014 ${getConfigPath()} was not written`);
+          } else {
+            setBootstrapRuleEnabled(ruleId, subcommand === "enable");
+          }
+          const stateFile = bootstrapStateFilePath(targetHome);
+          if (stateFile !== getConfigPath()) {
+            console.error(`Warning: the rule state is persisted to ${getConfigPath()}, but --target renders from ${stateFile} \u2014 set XDG_CONFIG_HOME to move the persisted state`);
+          }
+          const repoRoot = findRepoRootWithMarker(import.meta.dirname, GENERATOR_MARKER, GENERATOR_MARKER_MAX_LEVELS);
+          const report = applyBootstrapState({
+            targetHome,
+            dryRun,
+            sourcePath: repoRoot === null ? undefined : path30.join(repoRoot, "skills", "AGENTS.md")
+          });
+          console.log(formatBootstrapReport(report));
+          return bootstrapReportSucceeded(report) ? 0 : 1;
+        } catch (e) {
+          console.error(`Error: ${e.message}`);
+          return 1;
+        }
+      }
+      console.error("Usage: massa-ai-config bootstrap <list|show|enable|disable> ...");
+      return 1;
+    }
     default:
       console.error(`Unknown command: ${command}`);
       help();