@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-NHNPEZS4.js

@@ -0,0 +1,1408 @@
+import {
+  LlmJudgeExecutor
+} from "./chunk-CFCVYHSW.js";
+import {
+  getUserBuildHome
+} from "./chunk-VCGSWN5M.js";
+import {
+  MANIFEST,
+  discoverAgentInstructionSources,
+  findPendingImport,
+  getImportsDir,
+  readInstructionsImportState,
+  recordImportOptimization,
+  recordInstructionsImportState
+} from "./chunk-IYY3HQAD.js";
+import {
+  markdownFenceLines
+} from "./chunk-UDNNAQN5.js";
+import {
+  CORE_DOCTRINE,
+  STEERING_PROVIDERS,
+  assessSteeringCap,
+  resolveSteeringChannelCaps
+} from "./chunk-HKO45NLZ.js";
+import {
+  ConfigManager,
+  writeJsoncEdits
+} from "./chunk-W4BAIQ6L.js";
+import {
+  readInstructionText,
+  userHomeDir
+} from "./chunk-S6I4KISU.js";
+import {
+  resolveJudgeConfig
+} from "./chunk-C3DH3NCY.js";
+import {
+  isYesAnswer
+} from "./chunk-O5X6BKAO.js";
+import {
+  safeRmDir
+} from "./chunk-ALDTFNZ3.js";
+import {
+  selectedBuildConfigCandidate
+} from "./chunk-FKCG7K6H.js";
+import {
+  isProviderCliResolvable
+} from "./chunk-KKQKWAMF.js";
+import {
+  byteLength,
+  getUserInstructionsPath,
+  getUserInstructionsTargetPath,
+  sha256Text
+} from "./chunk-RIMARPCF.js";
+import {
+  getUserConfigFile
+} from "./chunk-56WPYDJH.js";
+
+// src/core/instructions-import/plan.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+
+// src/core/instructions-import/secrets.ts
+var TOKEN_SHAPES = [
+  ["api key (sk-)", /\bsk-[A-Za-z0-9_-]{20,}/],
+  ["github token", /\b(?:gh[pousr]_[A-Za-z0-9]{30,}|github_pat_[A-Za-z0-9_]{30,})/],
+  ["gitlab token", /\bglpat-[A-Za-z0-9_-]{20,}/],
+  ["slack token", /\bxox[abeprs]-[A-Za-z0-9-]{10,}/],
+  ["aws access key id", /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/],
+  ["google api key", /\bAIza[0-9A-Za-z_-]{35}/],
+  ["xai api key", /\bxai-[A-Za-z0-9]{20,}/],
+  ["npm token", /\bnpm_[A-Za-z0-9]{36}/],
+  ["stripe key", /\b[rs]k_live_[A-Za-z0-9]{20,}/],
+  ["jwt", /\beyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/]
+];
+var KEY_VALUE = /(?:^|[^A-Za-z0-9])(password|passwd|pwd|secret|client[_-]?secret|token|access[_-]?token|auth[_-]?token|api[_-]?key|apikey|access[_-]?key|private[_-]?key)["']?\s*[:=]\s*["']?([^\s"',;]+)/i;
+var CONNECTION_STRING = /\b[a-z][a-z0-9+.-]*:\/\/[^\s:/@]+:[^\s@/]+@[^\s]+/i;
+var PRIVATE_KEY_BEGIN = /-----BEGIN [A-Z0-9 ]*PRIVATE KEY( BLOCK)?-----/;
+var PRIVATE_KEY_END = /-----END [A-Z0-9 ]*PRIVATE KEY( BLOCK)?-----/;
+function isPlaceholder(value) {
+  return /^<.*>$/.test(value) || /^\$\{?[A-Za-z_][A-Za-z0-9_]*\}?$/.test(value) || /^[*xX.]+$/.test(value) || /^(?:none|null|redacted|changeme|example)$/i.test(value);
+}
+function linePattern(line) {
+  for (const [name, shape] of TOKEN_SHAPES) {
+    if (shape.test(line)) return name;
+  }
+  const keyValue = KEY_VALUE.exec(line);
+  if (keyValue?.[1] && keyValue[2] && !isPlaceholder(keyValue[2])) {
+    return `${keyValue[1].toLowerCase()} value`;
+  }
+  if (CONNECTION_STRING.test(line)) return "connection string with password";
+  return void 0;
+}
+function withholdSecrets(text, source, dropLines = []) {
+  const drop = new Set(dropLines);
+  const kept = [];
+  const withheld = [];
+  let inKeyBlock = false;
+  text.split(/\r?\n/).forEach((line, index) => {
+    const lineNumber = index + 1;
+    if (inKeyBlock) {
+      if (PRIVATE_KEY_END.test(line)) inKeyBlock = false;
+      return;
+    }
+    if (PRIVATE_KEY_BEGIN.test(line)) {
+      withheld.push({ ...source, line: lineNumber, pattern: "private key" });
+      inKeyBlock = !PRIVATE_KEY_END.test(line);
+      return;
+    }
+    const pattern = linePattern(line);
+    if (pattern) {
+      withheld.push({ ...source, line: lineNumber, pattern });
+      return;
+    }
+    if (!drop.has(lineNumber)) kept.push(line);
+  });
+  return { text: kept.join("\n"), withheld };
+}
+
+// src/core/instructions-import/sections.ts
+import { createHash } from "crypto";
+var HEADING = /^ {0,3}#{1,6}(?:\s|$)/;
+function parseBlockMarker(line) {
+  const trimmed = line.trim();
+  const isComment = trimmed.startsWith("<!--") && trimmed.endsWith("-->");
+  const body = trimmed.replace(/^<!--|-->$/g, "").replace(/^[\s#=<>*/-]+|[\s#=<>*/-]+$/g, "");
+  if (!body) return void 0;
+  const colon = /^(\S+?):(start|begin|end)$/i.exec(body);
+  if (colon?.[1] && colon[2]) {
+    return { edge: colon[2].toLowerCase() === "end" ? "end" : "start", name: colon[1] };
+  }
+  const word = /^(BEGIN|START|END)\s+(.+)$/i.exec(body);
+  if (word?.[1] && word[2] && (isComment || word[1] === word[1].toUpperCase())) {
+    return { edge: word[1].toUpperCase() === "END" ? "end" : "start", name: word[2].trim() };
+  }
+  return void 0;
+}
+function normalizeName(name) {
+  return name.toLowerCase().replace(/\s+/g, " ");
+}
+function splitManagedRegions(lines, sourceId) {
+  const markers = lines.map((line) => parseBlockMarker(line));
+  const regions = [];
+  const blocks = [];
+  let current = { lines: [] };
+  for (let i = 0; i < lines.length; i++) {
+    const marker = markers[i];
+    if (marker?.edge === "start" && current.managedBy === void 0) {
+      const name = normalizeName(marker.name);
+      const end = markers.findIndex(
+        (m, j) => j > i && m?.edge === "end" && normalizeName(m.name) === name
+      );
+      if (end !== -1) {
+        regions.push(current);
+        blocks.push({ sourceId, name: marker.name, line: i + 1 });
+        regions.push({ lines: lines.slice(i + 1, end), managedBy: marker.name });
+        current = { lines: [] };
+        i = end;
+        continue;
+      }
+    }
+    current.lines.push(lines[i] ?? "");
+  }
+  regions.push(current);
+  return { regions: regions.filter((region) => region.lines.length > 0), blocks };
+}
+function splitSections(lines) {
+  const sections = [];
+  let current = { lines: [] };
+  const fenced = markdownFenceLines(lines);
+  lines.forEach((line, index) => {
+    if (!fenced[index] && HEADING.test(line)) {
+      sections.push(current);
+      current = { heading: line.trim(), lines: [] };
+    }
+    current.lines.push(line);
+  });
+  sections.push(current);
+  return sections.map((section) => ({
+    ...section.heading ? { heading: section.heading } : {},
+    text: section.lines.join("\n").trim()
+  })).filter((section) => section.text !== "");
+}
+function normalizeSectionText(text) {
+  return text.split("\n").map((line) => line.trimEnd()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function sectionKey(text) {
+  return createHash("sha256").update(normalizeSectionText(text)).digest("hex").slice(0, 16);
+}
+function dedupeSections(sources) {
+  const sections = [];
+  const managedBlocks = [];
+  const byKey = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    const { regions, blocks } = splitManagedRegions(source.text.split(/\r?\n/), source.sourceId);
+    managedBlocks.push(...blocks);
+    for (const region of regions) {
+      for (const { heading, text } of splitSections(region.lines)) {
+        const key = sectionKey(text);
+        const origin = { sourceId: source.sourceId, reaches: [...source.reaches] };
+        const existing = byKey.get(key);
+        if (existing) {
+          existing.origins.push(origin);
+          for (const agent of source.reaches) {
+            if (!existing.reaches.includes(agent)) existing.reaches.push(agent);
+          }
+          continue;
+        }
+        const section = {
+          key,
+          ...heading ? { heading } : {},
+          text,
+          origins: [origin],
+          reaches: [...source.reaches],
+          ...region.managedBy ? { managedBy: region.managedBy } : {}
+        };
+        byKey.set(key, section);
+        sections.push(section);
+      }
+    }
+  }
+  return { sections, managedBlocks };
+}
+
+// src/core/instructions-import/plan.ts
+var BUILD_AGENT = "build";
+function displayPath(path, env = process.env) {
+  const home = userHomeDir(env);
+  return path === home || path.startsWith(`${home}/`) ? `~${path.slice(home.length)}` : path;
+}
+function describeSource(source, env) {
+  const key = source.id.startsWith(`${source.path}#`) ? source.id.slice(source.path.length + 1) : "";
+  return key ? `${displayPath(source.path, env)} (${key})` : displayPath(source.path, env);
+}
+function legacyBuildSource() {
+  const inUse = getUserInstructionsPath();
+  if (inUse === getUserInstructionsTargetPath()) return void 0;
+  const read = readInstructionText(inUse);
+  if (!read.ok) return void 0;
+  return {
+    id: inUse,
+    path: inUse,
+    kind: "instructions",
+    reaches: [BUILD_AGENT],
+    text: read.text,
+    identity: read.identity
+  };
+}
+function itemName(raw, taken) {
+  const base = raw.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "rule";
+  let name = base;
+  for (let n = 2; taken.has(name); n++) name = `${base}-${n}`;
+  taken.add(name);
+  return name;
+}
+function readBuildFile(path) {
+  try {
+    return readFileSync(path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function itemStatus(target, sha256) {
+  if (!existsSync(target)) return "new";
+  const existing = readBuildFile(target);
+  return existing !== void 0 && sha256Text(existing) === sha256 ? "same" : "conflict";
+}
+function renderInstructions(sections, sources, env) {
+  const blocks = [];
+  for (const source of sources) {
+    const own = sections.filter((section) => section.origins[0]?.sourceId === source.id);
+    if (own.length === 0) continue;
+    blocks.push(`<!-- From ${describeSource(source, env)} (${source.reaches.join(", ")}) -->`);
+    let managed;
+    for (const section of own) {
+      if (section.managedBy && section.managedBy !== managed) {
+        blocks.push(
+          `<!-- Maintained by ${section.managedBy}; later changes there won't follow. -->`
+        );
+      }
+      managed = section.managedBy;
+      blocks.push(section.text);
+    }
+  }
+  return blocks.length > 0 ? `${blocks.join("\n\n")}
+` : "";
+}
+function planInstructions(text) {
+  const target = getUserInstructionsTargetPath();
+  const current = readBuildFile(target);
+  const existing = current !== void 0 ? { sha256: sha256Text(current), bytes: byteLength(current), empty: current.trim() === "" } : void 0;
+  const sha256 = sha256Text(text);
+  const status = text === "" ? "none" : existing?.sha256 === sha256 ? "same" : existing && !existing.empty ? "replace" : "new";
+  return {
+    target,
+    text,
+    sha256,
+    bytes: byteLength(text),
+    ...existing ? { existing } : {},
+    status
+  };
+}
+function runtimeSteeringBytes(bytes) {
+  return byteLength(CORE_DOCTRINE.map((entry) => entry.text).join("\n\n")) + 2 + bytes;
+}
+function steeringLimits(bytes) {
+  if (bytes === 0) return [];
+  return STEERING_PROVIDERS.map((provider) => ({
+    provider,
+    ...assessSteeringCap(provider, runtimeSteeringBytes(bytes))
+  })).filter((status) => status.status !== "ok");
+}
+function hashPlan(instructions, items) {
+  return createHash2("sha256").update(
+    JSON.stringify({
+      instructions: [instructions.target, instructions.sha256, instructions.existing?.sha256],
+      items: items.map((item) => [item.kind, item.name, item.sha256, item.status])
+    })
+  ).digest("hex");
+}
+function planInstructionsImport(options = {}) {
+  const env = options.env ?? process.env;
+  const discovered = discoverAgentInstructionSources(env);
+  const sources = [...discovered.sources];
+  const agents = discovered.agents.map((agent) => ({ ...agent }));
+  const legacy = legacyBuildSource();
+  if (legacy) {
+    const shared = sources.find((source) => source.identity === legacy.identity);
+    if (shared) shared.reaches.push(BUILD_AGENT);
+    else sources.unshift(legacy);
+    agents.unshift({ agent: BUILD_AGENT, home: dirname(legacy.path), homeFound: true });
+  }
+  const secretsWithheld = [];
+  const sectioned = [];
+  const items = [];
+  const takenNames = /* @__PURE__ */ new Set();
+  for (const source of sources) {
+    const cleaned = withholdSecrets(
+      source.text,
+      { sourceId: source.id, path: source.path },
+      source.includeLines
+    );
+    secretsWithheld.push(...cleaned.withheld);
+    if (source.pathScoped && source.ruleName) {
+      const name = itemName(source.ruleName, takenNames);
+      const target = join(getUserBuildHome(), "steering", `${name}.md`);
+      const text = `${cleaned.text.trim()}
+`;
+      const sha256 = sha256Text(text);
+      items.push({
+        kind: "steering",
+        name,
+        target,
+        sourceId: source.id,
+        text,
+        sha256,
+        status: itemStatus(target, sha256)
+      });
+      continue;
+    }
+    sectioned.push({ sourceId: source.id, reaches: source.reaches, text: cleaned.text });
+  }
+  const { sections, managedBlocks } = dedupeSections(sectioned);
+  const instructions = planInstructions(renderInstructions(sections, sources, env));
+  const byId = new Map(sources.map((source) => [source.id, source]));
+  const coverage = agents.map((agent) => ({
+    ...agent,
+    sources: sources.filter((source) => source.reaches.includes(agent.agent)).length,
+    sections: sections.filter((section) => section.reaches.includes(agent.agent)).length
+  }));
+  const fingerprints = Object.fromEntries(
+    sources.map((source) => [source.id, sha256Text(source.text)])
+  );
+  return {
+    version: "verbatim",
+    agents: coverage,
+    sources: sources.map((source) => ({
+      id: source.id,
+      path: source.path,
+      kind: source.kind,
+      reaches: [...source.reaches],
+      sha256: fingerprints[source.id] ?? "",
+      bytes: byteLength(source.text),
+      ...source.includedFrom ? { includedFrom: source.includedFrom } : {},
+      ...source.pathScoped ? { pathScoped: true } : {}
+    })),
+    issues: discovered.issues,
+    sections,
+    managedBlocks: managedBlocks.map((block) => ({
+      ...block,
+      path: byId.get(block.sourceId)?.path ?? block.sourceId
+    })),
+    secretsWithheld,
+    instructions,
+    items,
+    steeringLimits: steeringLimits(instructions.bytes),
+    fingerprints,
+    ...legacy ? { legacyInstructions: legacy.path } : {},
+    planHash: hashPlan(instructions, items)
+  };
+}
+function withOptimizedInstructions(plan, text) {
+  const instructions = planInstructions(text);
+  return {
+    ...plan,
+    version: "optimized",
+    instructions,
+    steeringLimits: steeringLimits(instructions.bytes),
+    planHash: hashPlan(instructions, plan.items),
+    basePlanHash: plan.basePlanHash ?? plan.planHash
+  };
+}
+function isImportUpToDate(plan) {
+  return (plan.instructions.status === "same" || plan.instructions.status === "none") && plan.items.every((item) => item.status !== "new");
+}
+function sameFingerprints(a, b) {
+  const keys = Object.keys(a);
+  return keys.length === Object.keys(b).length && keys.every((key) => a[key] === b[key]);
+}
+function isImportCurrent(plan, state) {
+  if (isImportUpToDate(plan)) return true;
+  return state?.status === "imported" && state.version === "optimized" && plan.instructions.existing?.empty === false && sameFingerprints(state.fingerprints, plan.fingerprints) && plan.items.every((item) => item.status !== "new");
+}
+function describeImportPlan(plan) {
+  const { text: _text, ...instructions } = plan.instructions;
+  return {
+    version: plan.version,
+    agents: plan.agents,
+    sources: plan.sources,
+    issues: plan.issues,
+    sections: plan.sections.map((section) => ({
+      heading: section.heading ?? null,
+      origins: section.origins.map((origin) => origin.sourceId),
+      reaches: section.reaches,
+      ...section.managedBy ? { managedBy: section.managedBy } : {}
+    })),
+    managedBlocks: plan.managedBlocks.map((block) => ({
+      path: block.path,
+      line: block.line,
+      name: block.name,
+      note: "later changes won't follow"
+    })),
+    // `source` is the file, or `<file>#<key>` for a settings value; `line` counts within it.
+    secretsWithheld: plan.secretsWithheld.map(({ sourceId, line, pattern }) => ({
+      source: sourceId,
+      line,
+      pattern
+    })),
+    instructions,
+    items: plan.items.map(({ text: _itemText, ...item }) => item),
+    conflicts: plan.items.filter((item) => item.status === "conflict").map(({ kind, name, target }) => ({ kind, name, target })),
+    steeringLimits: plan.steeringLimits,
+    ...plan.legacyInstructions ? { legacyInstructions: plan.legacyInstructions } : {}
+  };
+}
+
+// src/core/instructions-import/staging.ts
+import { randomBytes } from "crypto";
+import {
+  chmodSync,
+  closeSync,
+  existsSync as existsSync2,
+  mkdirSync,
+  openSync,
+  readFileSync as readFileSync2,
+  renameSync,
+  rmdirSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { basename, dirname as dirname2, join as join2 } from "path";
+import lockfile from "proper-lockfile";
+var ImportActivationError = class extends Error {
+  constructor(message, reason) {
+    super(message);
+    this.reason = reason;
+    this.name = "ImportActivationError";
+  }
+  reason;
+};
+var STAGED_INSTRUCTIONS = "instructions.md";
+var PREVIOUS_INSTRUCTIONS = "previous-instructions.md";
+var ACTIVATE_LOCK = ".activate.lock";
+var LOCK_STALE_MS = 6e4;
+function ensurePrivateDir(dir) {
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  chmodSync(dir, 448);
+}
+function writePrivateFile(path, text) {
+  mkdirSync(dirname2(path), { recursive: true, mode: 448 });
+  writeFileSync(path, text, { encoding: "utf8", flag: "wx", mode: 384 });
+}
+function replaceFileAtomically(path, text) {
+  mkdirSync(dirname2(path), { recursive: true });
+  const temp = join2(
+    dirname2(path),
+    `.${basename(path)}.${process.pid}-${randomBytes(4).toString("hex")}.tmp`
+  );
+  let mode;
+  try {
+    mode = statSync(path).mode & 511;
+  } catch {
+    mode = void 0;
+  }
+  writeFileSync(temp, text, { encoding: "utf8", flag: "wx", ...mode ? { mode } : {} });
+  try {
+    renameSync(temp, path);
+  } catch (error) {
+    try {
+      unlinkSync(temp);
+    } catch {
+    }
+    throw error;
+  }
+}
+function writeManifest(staged) {
+  staged.manifest.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const path = join2(staged.dir, MANIFEST);
+  const temp = `${path}.${process.pid}.tmp`;
+  writeFileSync(temp, `${JSON.stringify(staged.manifest, null, 2)}
+`, { mode: 384 });
+  renameSync(temp, path);
+}
+function importId(now) {
+  return now.toISOString().replace(/[-:.]/g, "");
+}
+function stageInstructionsImport(plan, optimization = { status: "none" }) {
+  const root = getImportsDir();
+  ensurePrivateDir(root);
+  const base = importId(/* @__PURE__ */ new Date());
+  let id = base;
+  let dir = join2(root, id);
+  for (let n = 2; ; n++) {
+    try {
+      mkdirSync(dir, { mode: 448 });
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      id = `${base}-${n}`;
+      dir = join2(root, id);
+    }
+  }
+  chmodSync(dir, 448);
+  const writesInstructions = plan.instructions.status === "new" || plan.instructions.status === "replace";
+  if (writesInstructions) writePrivateFile(join2(dir, STAGED_INSTRUCTIONS), plan.instructions.text);
+  const items = plan.items.filter((item) => item.status === "new").map((item) => {
+    const file = join2(
+      item.kind,
+      item.kind === "skills" ? `${item.name}/SKILL.md` : `${item.name}.md`
+    );
+    writePrivateFile(join2(dir, file), item.text);
+    return { kind: item.kind, name: item.name, target: item.target, file, sha256: item.sha256 };
+  });
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const staged = {
+    id,
+    dir,
+    manifest: {
+      schema: 1,
+      id,
+      status: "staged",
+      version: plan.version,
+      createdAt: now,
+      updatedAt: now,
+      planHash: plan.planHash,
+      ...plan.basePlanHash ? { basePlanHash: plan.basePlanHash } : {},
+      ...writesInstructions ? {
+        instructions: {
+          target: plan.instructions.target,
+          file: STAGED_INSTRUCTIONS,
+          sha256: plan.instructions.sha256,
+          expectedExistingSha256: plan.instructions.existing?.sha256 ?? null
+        }
+      } : {},
+      items,
+      fingerprints: plan.fingerprints,
+      secretsWithheld: plan.secretsWithheld,
+      optimization
+    }
+  };
+  writeManifest(staged);
+  return staged;
+}
+function readStagedInstructions(staged) {
+  const file = staged.manifest.instructions?.file;
+  return file ? readBuildFile(join2(staged.dir, file)) : void 0;
+}
+function canResumeImport(staged, plan) {
+  const { damaged, stale } = checkStagedImport(staged);
+  if (damaged.length > 0 || stale.length > 0) return false;
+  const instructions = staged.manifest.instructions;
+  return staged.manifest.planHash === plan.planHash || staged.manifest.basePlanHash === plan.planHash || instructions !== void 0 && currentSha(instructions.target) === instructions.sha256;
+}
+function markStagedImport(staged, status, error) {
+  staged.manifest.status = status;
+  if (error) staged.manifest.error = error;
+  writeManifest(staged);
+}
+function currentSha(path) {
+  const text = readBuildFile(path);
+  return text === void 0 ? null : sha256Text(text);
+}
+function checkStagedImport(staged) {
+  const damaged = [];
+  const stale = [];
+  if (staged.manifest.status !== "staged")
+    damaged.push(`import ${staged.id} is ${staged.manifest.status}`);
+  const files = [
+    ...staged.manifest.instructions ? [staged.manifest.instructions] : [],
+    ...staged.manifest.items
+  ];
+  for (const file of files) {
+    if (currentSha(join2(staged.dir, file.file)) !== file.sha256) {
+      damaged.push(`staged file ${file.file} is missing or changed`);
+    }
+  }
+  const instructions = staged.manifest.instructions;
+  const target = instructions ? currentSha(instructions.target) : null;
+  if (instructions && target !== instructions.expectedExistingSha256 && target !== instructions.sha256) {
+    stale.push(`${instructions.target} changed after this import was prepared`);
+  }
+  return { damaged, stale };
+}
+function acquireActivationLock() {
+  const target = join2(getImportsDir(), ACTIVATE_LOCK);
+  ensurePrivateDir(getImportsDir());
+  closeSync(openSync(target, "a", 384));
+  try {
+    return lockfile.lockSync(target, { stale: LOCK_STALE_MS, realpath: false });
+  } catch (error) {
+    if (error.code === "ELOCKED") {
+      throw new ImportActivationError("another import is being installed right now", "busy");
+    }
+    throw error;
+  }
+}
+var AUTOMATED_INHERITANCE = "inheritance.automated";
+async function setAutomatedInheritance() {
+  const manager = new ConfigManager();
+  const before = await manager.getConfigValue(AUTOMATED_INHERITANCE, "user");
+  const result = await manager.setConfigValue(AUTOMATED_INHERITANCE, "build", "user");
+  if (!result.success) {
+    throw new Error(`could not set ${AUTOMATED_INHERITANCE}: ${result.error ?? "unknown error"}`);
+  }
+  const undo = () => {
+    if (before === "build") return;
+    const file = selectedBuildConfigCandidate(getUserConfigFile());
+    const edit = { path: AUTOMATED_INHERITANCE.split("."), value: before };
+    const restored = writeJsoncEdits(file, [edit], process.cwd());
+    if (!restored.success) {
+      throw new Error(`could not restore ${AUTOMATED_INHERITANCE}: ${restored.error ?? "unknown"}`);
+    }
+  };
+  return {
+    inheritance: { path: getUserConfigFile(), setting: AUTOMATED_INHERITANCE, value: "build" },
+    undo
+  };
+}
+function createdFolders(dir, firstCreated) {
+  if (!firstCreated) return [];
+  const folders = [];
+  for (let current = dir; ; current = dirname2(current)) {
+    folders.push(current);
+    if (current === firstCreated || dirname2(current) === current) return folders;
+  }
+}
+async function activateStagedImport(staged) {
+  const { damaged, stale } = checkStagedImport(staged);
+  if (damaged.length > 0) throw new ImportActivationError(damaged.join("; "), "damaged");
+  if (stale.length > 0) throw new ImportActivationError(stale.join("; "), "stale");
+  const release = acquireActivationLock();
+  const changes = { created: [], folders: [] };
+  const created = changes.created;
+  const skipped = [];
+  try {
+    try {
+      for (const item of staged.manifest.items) {
+        const text = readFileSync2(join2(staged.dir, item.file), "utf8");
+        if (existsSync2(item.target)) {
+          const reason = currentSha(item.target) === item.sha256 ? "same" : "conflict";
+          skipped.push({ kind: item.kind, name: item.name, path: item.target, reason });
+          continue;
+        }
+        const folder = dirname2(item.target);
+        changes.folders.push(...createdFolders(folder, mkdirSync(folder, { recursive: true })));
+        writeFileSync(item.target, text, { encoding: "utf8", flag: "wx" });
+        created.push({ kind: item.kind, name: item.name, path: item.target });
+      }
+      let instructions;
+      const staging = staged.manifest.instructions;
+      if (staging) {
+        const previousCopy = join2(staged.dir, PREVIOUS_INSTRUCTIONS);
+        const before = staging.expectedExistingSha256 === null ? null : readBuildFile(previousCopy) ?? readBuildFile(staging.target) ?? null;
+        if (before !== null && !existsSync2(previousCopy)) writePrivateFile(previousCopy, before);
+        changes.previous = { target: staging.target, text: before };
+        replaceFileAtomically(staging.target, readFileSync2(join2(staged.dir, staging.file), "utf8"));
+        instructions = {
+          path: staging.target,
+          replaced: before !== null,
+          ...before !== null ? { previousCopy } : {}
+        };
+      }
+      const { inheritance, undo } = await setAutomatedInheritance();
+      changes.undoInheritance = undo;
+      const state = recordInstructionsImportState({
+        status: "imported",
+        version: staged.manifest.version,
+        importId: staged.id,
+        fingerprints: staged.manifest.fingerprints,
+        optimization: staged.manifest.optimization ?? { status: "none" }
+      });
+      staged.manifest.status = "activated";
+      writeManifest(staged);
+      return {
+        id: staged.id,
+        ...instructions ? { instructions } : {},
+        created,
+        skipped,
+        inheritance,
+        state
+      };
+    } catch (error) {
+      let message = errorText(error);
+      const failures = rollBack(changes, staged.dir);
+      if (failures.length > 0) message += `; ${failures.join("; ")}`;
+      const reason = failures.length > 0 ? "unrestored" : "failed";
+      try {
+        markStagedImport(staged, "failed", message);
+      } catch {
+      }
+      throw new ImportActivationError(message, reason);
+    }
+  } finally {
+    release();
+  }
+}
+function rollBack(changes, stagingDir) {
+  const failures = [];
+  for (const item of [...changes.created].reverse()) {
+    try {
+      unlinkSync(item.path);
+    } catch {
+    }
+  }
+  for (const folder of [...changes.folders].sort((a, b) => b.length - a.length)) {
+    try {
+      rmdirSync(folder);
+    } catch {
+    }
+  }
+  const previous = changes.previous;
+  try {
+    if (previous?.text === null) {
+      if (existsSync2(previous.target)) unlinkSync(previous.target);
+    } else if (previous) {
+      replaceFileAtomically(previous.target, previous.text);
+    }
+  } catch (error) {
+    failures.push(
+      `restoring the previous instructions failed (${errorText(error)}); a copy is in ${stagingDir}`
+    );
+  }
+  try {
+    changes.undoInheritance?.();
+  } catch (error) {
+    failures.push(errorText(error));
+  }
+  return failures;
+}
+function errorText(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function declineStagedImport(staged, fingerprints, version = "verbatim") {
+  if (staged) markStagedImport(staged, "declined");
+  if (readInstructionsImportState()?.status === "imported") return;
+  recordInstructionsImportState({ status: "declined", version, fingerprints });
+}
+
+// src/cli/commands/instructions-import.ts
+import chalk from "chalk";
+import { Command } from "commander";
+
+// src/core/instructions-import/optimize.ts
+import { mkdtempSync } from "fs";
+import { tmpdir } from "os";
+import { join as join3 } from "path";
+var OPTIMIZED_INSTRUCTIONS_BUDGET_BYTES = Math.min(
+  ...STEERING_PROVIDERS.map((provider) => resolveSteeringChannelCaps(provider).hardRefuseBytes)
+) - runtimeSteeringBytes(0);
+var OPTIMIZE_TIMEOUT_SECONDS = 600;
+var OPTIMIZE_AGENT_ROLE = "instructions-import";
+var OPEN_TAG = "<instructions>";
+var CLOSE_TAG = "</instructions>";
+var MAX_REASON_CHARS = 240;
+function shortReason(error) {
+  const text = (error instanceof Error ? error.message : String(error)).trim();
+  const line = text.split("\n")[0] ?? "";
+  return line.length > MAX_REASON_CHARS ? `${line.slice(0, MAX_REASON_CHARS - 3)}...` : line;
+}
+function resolveImportOptimizer(cwd = process.cwd()) {
+  let resolved;
+  try {
+    resolved = resolveJudgeConfig(void 0, cwd);
+  } catch (error) {
+    return { ready: false, reason: shortReason(error) };
+  }
+  const provider = resolved.provider.value;
+  if (!isProviderCliResolvable(provider)) {
+    return { ready: false, reason: `the ${provider} CLI was not found` };
+  }
+  return {
+    ready: true,
+    provider,
+    model: resolved.model.value,
+    ...resolved.reasoningEffort ? { reasoningEffort: resolved.reasoningEffort.value } : {}
+  };
+}
+function buildOptimizePrompt(plan, env = process.env) {
+  const budget = OPTIMIZED_INSTRUCTIONS_BUDGET_BYTES;
+  const sections = plan.sections.map((section) => {
+    const from = section.origins.map((origin) => displayPath(origin.sourceId, env)).join(", ");
+    return `<section from="${from}" agents="${section.reaches.join(", ")}">
+${section.text}
+</section>`;
+  });
+  return [
+    "Rewrite a person's global instructions for AI coding agents as one short instructions file.",
+    "",
+    "Build gives this file to every agent it launches, in place of the global instructions each agent loads on its own. The sections below are what those agents load today, already cleaned: exact duplicates removed and possible secrets left out. Each section names the files it came from and the agents that load it today.",
+    "",
+    "Write the file so that it:",
+    "- Keeps the meaning of every rule. Do not drop, weaken, or add a rule.",
+    "- Merges rules that say the same thing, and cuts repetition, filler, and examples that only restate a rule.",
+    '- Keeps a short scope note, such as "(Codex only)", on a rule that applies to only one agent: its text is about that agent, or only that agent loads it today.',
+    "- Uses plain markdown: short headings and bullet points.",
+    `- Fits in ${budget} bytes of UTF-8 text (about ${Math.floor(budget / 7)} words).`,
+    "- Contains no secrets, tokens, passwords, or keys.",
+    "",
+    `Reply with only the file, between a line ${OPEN_TAG} and a line ${CLOSE_TAG}.`,
+    "",
+    ...sections,
+    ""
+  ].join("\n");
+}
+function isPlainText(text) {
+  for (let i = 0; i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    if (code < 32 && code !== 9 && code !== 10 && code !== 13 || code === 127) {
+      return false;
+    }
+  }
+  return true;
+}
+function isMarkdownText(text) {
+  if (!isPlainText(text) || !new RegExp("\\p{L}", "u").test(text)) return false;
+  if (/^[{[]/.test(text)) {
+    try {
+      JSON.parse(text);
+      return false;
+    } catch {
+    }
+  }
+  return true;
+}
+function checkOptimizedReply(reply) {
+  const start = reply.indexOf(OPEN_TAG);
+  const end = reply.lastIndexOf(CLOSE_TAG);
+  if (start === -1 || end <= start) {
+    return { ok: false, reason: `the reply had no ${OPEN_TAG} block` };
+  }
+  let body = reply.slice(start + OPEN_TAG.length, end).trim();
+  const fenced = /^(```|~~~)[\w-]*\n([\s\S]*)\n\1$/.exec(body);
+  if (fenced?.[2] !== void 0) body = fenced[2].trim();
+  if (body === "") return { ok: false, reason: "the reply was empty" };
+  if (!isMarkdownText(body)) return { ok: false, reason: "the reply was not markdown text" };
+  const secret = withholdSecrets(body, { sourceId: "reply", path: "reply" }).withheld[0];
+  if (secret) {
+    return {
+      ok: false,
+      reason: `the reply had a possible secret (${secret.pattern}, line ${secret.line})`
+    };
+  }
+  const text = `${body}
+`;
+  const bytes = byteLength(text);
+  if (bytes > OPTIMIZED_INSTRUCTIONS_BUDGET_BYTES) {
+    return {
+      ok: false,
+      reason: `the reply was ${bytes} bytes, over the ${OPTIMIZED_INSTRUCTIONS_BUDGET_BYTES}-byte budget`
+    };
+  }
+  return { ok: true, text };
+}
+async function optimizeInstructionsImport(plan, options = {}) {
+  if (plan.instructions.text === "") {
+    return { ok: false, reason: "there are no instructions to optimize" };
+  }
+  const optimizer = options.optimizer ?? resolveImportOptimizer();
+  if (!optimizer.ready) return { ok: false, reason: `no ready provider (${optimizer.reason})` };
+  const scratchRoot = tmpdir();
+  const scratch = mkdtempSync(join3(scratchRoot, "build-instructions-optimize-"));
+  let reply;
+  try {
+    const result = await new LlmJudgeExecutor().evaluate(buildOptimizePrompt(plan, options.env), {
+      provider: optimizer.provider,
+      model: optimizer.model,
+      ...optimizer.reasoningEffort ? { reasoningEffort: optimizer.reasoningEffort } : {},
+      workingDir: scratch,
+      timeoutSeconds: OPTIMIZE_TIMEOUT_SECONDS,
+      // One call: a failure falls back to the verbatim version instead of retrying.
+      maxAttempts: 1,
+      requireThinking: false,
+      showProgress: false,
+      env: { BUILD_AGENT_ROLE: OPTIMIZE_AGENT_ROLE }
+    });
+    reply = result.output;
+  } catch (error) {
+    return { ok: false, reason: `the ${optimizer.provider} call failed: ${shortReason(error)}` };
+  } finally {
+    await safeRmDir(scratch, { protectedPaths: [scratchRoot], managedRoots: [scratchRoot] }).catch(
+      () => void 0
+    );
+  }
+  const checked = checkOptimizedReply(reply);
+  if (!checked.ok) return checked;
+  return {
+    ok: true,
+    plan: withOptimizedInstructions(plan, checked.text),
+    provider: optimizer.provider
+  };
+}
+async function prepareOptimizedImport(plan, options = {}) {
+  const result = await optimizeInstructionsImport(plan, options);
+  return result.ok ? { plan: result.plan, optimization: { status: "done", provider: result.provider } } : { plan, optimization: { status: "pending", reason: result.reason } };
+}
+
+// src/cli/utils/line-diff.ts
+function splitLinesForDiff(text) {
+  const normalized = text.replace(/\r\n/g, "\n");
+  const lines = normalized.split("\n");
+  if (lines.length > 0 && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  return lines;
+}
+function formatLineDiff(before, after, labels) {
+  const a = splitLinesForDiff(before);
+  const b = splitLinesForDiff(after);
+  const dp = Array.from(
+    { length: a.length + 1 },
+    () => Array.from({ length: b.length + 1 }, () => 0)
+  );
+  const score = (i2, j2) => dp[i2]?.[j2] ?? 0;
+  for (let i2 = a.length - 1; i2 >= 0; i2--) {
+    for (let j2 = b.length - 1; j2 >= 0; j2--) {
+      const beforeLine = a[i2] ?? "";
+      const afterLine = b[j2] ?? "";
+      const row = dp[i2];
+      if (!row) continue;
+      row[j2] = beforeLine === afterLine ? score(i2 + 1, j2 + 1) + 1 : Math.max(score(i2 + 1, j2), score(i2, j2 + 1));
+    }
+  }
+  const lines = [`--- ${labels.before}`, `+++ ${labels.after}`, "@@"];
+  let i = 0;
+  let j = 0;
+  while (i < a.length || j < b.length) {
+    if (i < a.length && j < b.length && a[i] === b[j]) {
+      lines.push(` ${a[i]}`);
+      i++;
+      j++;
+    } else if (j < b.length && (i === a.length || score(i, j + 1) >= score(i + 1, j))) {
+      lines.push(`+${b[j]}`);
+      j++;
+    } else if (i < a.length) {
+      lines.push(`-${a[i]}`);
+      i++;
+    }
+  }
+  return lines;
+}
+
+// src/cli/commands/instructions-import.ts
+var IMPORT_VERSIONS = ["optimized", "verbatim"];
+var OPTIMIZE_COMMAND = "build config instructions import --optimize";
+function hasNothingToImport(plan) {
+  return plan.instructions.status === "none" && plan.items.length === 0;
+}
+function planStatus(plan, state) {
+  if (hasNothingToImport(plan)) return "nothing-to-import";
+  return isImportCurrent(plan, state) ? "up-to-date" : "ready";
+}
+function steeringLimitLines(plan) {
+  const version = `With the ${plan.version} version`;
+  return plan.steeringLimits.map(
+    (limit) => limit.status === "hard-refuse" ? `Warning: ${version}, ${limit.provider} runtime steering would be ${limit.bytes} bytes, over its ${limit.hardRefuseBytes}-byte limit, so its runs would start with a size warning (see build config instructions lint).` : `Info: ${version}, ${limit.provider} runtime steering would be ${limit.bytes} bytes, over its ${limit.softWarnBytes}-byte soft limit.`
+  );
+}
+function renderPlan(plan) {
+  const show = (path) => displayPath(path);
+  console.log("Instructions import");
+  console.log("Sources:");
+  for (const source of plan.sources) {
+    const key = source.kind === "setting" ? ` ${source.id.slice(source.path.length + 1)}` : "";
+    const from = source.includedFrom ? `, included from ${show(source.includedFrom)}` : "";
+    console.log(`  ${show(source.path)}${key} (loaded by ${source.reaches.join(", ")}${from})`);
+  }
+  const duplicates = plan.sections.reduce((sum, section) => sum + section.origins.length - 1, 0);
+  console.log(`Sections: ${plan.sections.length} (${duplicates} duplicates removed)`);
+  console.log("Reaches today:");
+  for (const agent of plan.agents) {
+    const detail = agent.homeFound ? `${agent.sections} of ${plan.sections.length} sections` : `not set up (${show(agent.home)})`;
+    console.log(`  ${agent.agent}: ${detail}`);
+  }
+  if (plan.managedBlocks.length > 0) {
+    console.log("Maintained by another tool (later changes won't follow):");
+    for (const block of plan.managedBlocks) {
+      console.log(`  ${show(block.path)}:${block.line} ${block.name}`);
+    }
+  }
+  if (plan.secretsWithheld.length > 0) {
+    console.log("Left out as possible secrets:");
+    for (const secret of plan.secretsWithheld) {
+      console.log(`  ${show(secret.sourceId)}:${secret.line} ${secret.pattern}`);
+    }
+  }
+  if (plan.issues.length > 0) {
+    console.log("Not read:");
+    for (const issue of plan.issues) {
+      const from = issue.includedFrom ? ` (named in ${show(issue.includedFrom)})` : "";
+      console.log(`  ${show(issue.path)}: ${issue.problem}${from}`);
+    }
+  }
+  for (const item of plan.items) {
+    const note = item.status === "conflict" ? "conflict, left unchanged" : item.status;
+    console.log(`Adds ${item.kind} "${item.name}": ${show(item.target)} (${note})`);
+  }
+  if (plan.instructions.status !== "none") {
+    console.log(
+      `Writes: ${show(plan.instructions.target)} (${plan.instructions.status}; verbatim version ${plan.instructions.bytes} bytes)`
+    );
+  }
+  if (plan.legacyInstructions) {
+    console.log(
+      `Info: ${show(plan.legacyInstructions)} is included and stops being read once instructions.md exists.`
+    );
+  }
+  for (const line of steeringLimitLines(plan)) console.log(line);
+}
+function renderDifference(plan) {
+  const before = readBuildFile(plan.instructions.target) ?? "";
+  for (const line of formatLineDiff(before, plan.instructions.text, {
+    before: `${displayPath(plan.instructions.target)} (now)`,
+    after: `${displayPath(plan.instructions.target)} (after import)`
+  })) {
+    if (line.startsWith("+") && !line.startsWith("+++")) console.log(chalk.green(line));
+    else if (line.startsWith("-") && !line.startsWith("---")) console.log(chalk.red(line));
+    else console.log(line);
+  }
+}
+function resultLines(result, plan) {
+  const lines = [];
+  if (result.instructions) {
+    const verb = result.instructions.replaced ? "Replaced" : "Installed";
+    const copy = result.instructions.previousCopy ? ` (previous copy: ${displayPath(result.instructions.previousCopy)})` : "";
+    lines.push(
+      `OK: ${verb} ${displayPath(result.instructions.path)} with the ${result.state.version} version${copy}`
+    );
+  }
+  for (const item of result.created) {
+    lines.push(`OK: Added ${item.kind} "${item.name}": ${displayPath(item.path)}`);
+  }
+  for (const item of result.skipped.filter((skip) => skip.reason === "conflict")) {
+    lines.push(
+      `Warning: ${item.kind} "${item.name}" already exists at ${displayPath(item.path)}; left it unchanged.`
+    );
+  }
+  lines.push(
+    `Info: Set ${result.inheritance.setting} = ${result.inheritance.value} in ${displayPath(result.inheritance.path)}, so each agent Build launches gets these rules once, from Build.`
+  );
+  if (plan.legacyInstructions) {
+    lines.push(`Info: ${displayPath(plan.legacyInstructions)} is no longer read.`);
+  }
+  lines.push(...optimizationLines(result.state.optimization));
+  return lines;
+}
+function optimizationLines(optimization) {
+  if (optimization.status === "pending") {
+    return [
+      `Info: The optimized version is pending (${optimization.reason}). Run "${OPTIMIZE_COMMAND}" in a terminal to finish it.`
+    ];
+  }
+  if (optimization.status === "failed") {
+    return [
+      `Info: The last optimization failed (${optimization.reason}). Run "${OPTIMIZE_COMMAND}" in a terminal to try again.`
+    ];
+  }
+  return [];
+}
+async function askLine(question) {
+  const readline = await import("readline");
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return await new Promise((resolve) => rl.question(question, resolve));
+  } finally {
+    rl.close();
+  }
+}
+async function askYesNo(question) {
+  return isYesAnswer(await askLine(question));
+}
+async function askVersion(provider) {
+  const answer = (await askLine(
+    `Install which version? [O]ptimized (one ${provider} call, no tools) / [v]erbatim (no model call) / [n]either: `
+  )).trim().toLowerCase();
+  if (answer === "" || answer === "o" || answer === "optimized") return "optimized";
+  if (answer === "v" || answer === "verbatim") return "verbatim";
+  return void 0;
+}
+function planForStagedImport(staged, plan) {
+  const text = staged.manifest.version === "optimized" ? readStagedInstructions(staged) : void 0;
+  return text === void 0 ? plan : withOptimizedInstructions(plan, text);
+}
+function isInteractive() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+function refuseScriptedReplace(plan) {
+  const existing = plan.instructions.existing;
+  if (!existing || existing.empty) return false;
+  console.error(
+    `Error: ${displayPath(plan.instructions.target)} already has content, so the optimized version needs a shown difference and your confirmation. Run "build config instructions import" in a terminal.`
+  );
+  process.exitCode = 1;
+  return true;
+}
+function reportOptimized(optimized, verbatim) {
+  console.log(
+    `Info: Optimized version: ${optimized.instructions.bytes} bytes (verbatim version: ${verbatim.instructions.bytes} bytes).`
+  );
+}
+function runCheck(plan, state, json) {
+  const pending = findPendingImport();
+  const report = {
+    status: planStatus(plan, state),
+    ...describeImportPlan(plan),
+    pending: pending ? {
+      id: pending.id,
+      version: pending.manifest.version,
+      createdAt: pending.manifest.createdAt,
+      current: pending.manifest.planHash === plan.planHash || pending.manifest.basePlanHash === plan.planHash,
+      ...pending.manifest.optimization ? { optimization: pending.manifest.optimization } : {}
+    } : null,
+    state: state ?? null
+  };
+  if (json) {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+  renderPlan(plan);
+  if (report.pending) {
+    console.log(`Info: an unfinished import from ${report.pending.createdAt} is waiting.`);
+  }
+  for (const line of state ? optimizationLines(state.optimization) : []) console.log(line);
+  console.log(`Status: ${report.status}`);
+}
+async function reviewAndActivate(input) {
+  const { plan, staged, yes } = input;
+  const replacing = plan.instructions.status === "replace";
+  if (replacing || !yes && plan.version === "optimized") renderDifference(plan);
+  if (replacing && yes) {
+    console.error(
+      `Error: ${displayPath(plan.instructions.target)} already has content. Review the difference above, then run "build config instructions import" in a terminal to confirm. The prepared import is kept.`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  if (!yes && (replacing || plan.version === "optimized" || !input.agreed)) {
+    const instead = input.instead ? " instead" : "";
+    const question = replacing ? `Replace ${displayPath(plan.instructions.target)} with the ${plan.version} import${instead}? [y/N] ` : `Install the ${plan.version} import${instead}? [y/N] `;
+    if (!await askYesNo(question)) {
+      declineStagedImport(staged, input.verbatim.fingerprints, plan.version);
+      console.log("No changes made.");
+      return;
+    }
+  }
+  try {
+    for (const line of resultLines(await activateStagedImport(staged), plan)) console.log(line);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error: import not installed: ${message}`);
+    if (error instanceof ImportActivationError && error.reason === "failed") {
+      console.error("Your previous instructions are unchanged.");
+    }
+    process.exitCode = 1;
+  }
+}
+async function runOptimize(plan, state, yes) {
+  if (state?.status !== "imported") {
+    console.log('Info: Nothing is imported yet; run "build config instructions import".');
+    return;
+  }
+  if (state.version === "optimized") {
+    console.log("OK: The optimized version is already installed.");
+    return;
+  }
+  if (plan.instructions.text === "") {
+    console.log("No agent instruction files found; nothing to optimize.");
+    return;
+  }
+  if (!yes && !isInteractive()) {
+    console.error(`Error: confirmation needed. Run "${OPTIMIZE_COMMAND}" in a terminal.`);
+    process.exitCode = 1;
+    return;
+  }
+  if (yes && refuseScriptedReplace(plan)) return;
+  const pending = findPendingImport();
+  if (pending?.manifest.version === "optimized" && canResumeImport(pending, plan)) {
+    console.log(
+      `Info: finishing the import prepared ${pending.manifest.createdAt} (optimized version).`
+    );
+    const optimized = planForStagedImport(pending, plan);
+    await reviewAndActivate({
+      verbatim: plan,
+      plan: optimized,
+      staged: pending,
+      yes,
+      agreed: true
+    });
+    return;
+  }
+  const optimizer = resolveImportOptimizer();
+  if (optimizer.ready) {
+    console.log(
+      `Info: Making the optimized version with ${optimizer.provider} (one model call, no tools).`
+    );
+  }
+  const result = await optimizeInstructionsImport(plan, { optimizer });
+  if (!result.ok) {
+    recordImportOptimization({
+      status: "failed",
+      reason: result.reason,
+      date: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    console.error(
+      `Error: no optimized version: ${result.reason}. Your installed instructions are unchanged.`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  reportOptimized(result.plan, plan);
+  if (pending) markStagedImport(pending, "superseded");
+  const staged = stageInstructionsImport(result.plan, {
+    status: "done",
+    provider: result.provider
+  });
+  await reviewAndActivate({ verbatim: plan, plan: result.plan, staged, yes, agreed: true });
+}
+function readUseOption(options) {
+  if (options.use === void 0) return void 0;
+  const use = IMPORT_VERSIONS.find((version) => version === options.use);
+  if (!use) {
+    console.error(`Error: --use takes ${IMPORT_VERSIONS.join(" or ")}.`);
+    process.exitCode = 1;
+    return null;
+  }
+  return use;
+}
+async function runInstructionsImport(options) {
+  if (options.json && !options.check) {
+    console.error("Error: --json needs --check.");
+    process.exitCode = 1;
+    return;
+  }
+  if (options.check && options.yes) {
+    console.error("Error: --check writes nothing; drop --yes.");
+    process.exitCode = 1;
+    return;
+  }
+  if (options.check && (options.use !== void 0 || options.optimize)) {
+    console.error("Error: --check calls no model; drop --use and --optimize.");
+    process.exitCode = 1;
+    return;
+  }
+  const use = readUseOption(options);
+  if (use === null) return;
+  if (options.optimize && use === "verbatim") {
+    console.error("Error: --optimize installs the optimized version; drop --use verbatim.");
+    process.exitCode = 1;
+    return;
+  }
+  const plan = planInstructionsImport();
+  const state = readInstructionsImportState();
+  if (options.check) {
+    runCheck(plan, state, options.json === true);
+    return;
+  }
+  const yes = options.yes === true;
+  if (options.optimize) {
+    await runOptimize(plan, state, yes);
+    return;
+  }
+  const wanted = use ?? (yes ? "verbatim" : void 0);
+  const pending = findPendingImport();
+  const resumable = pending !== void 0 && (wanted === void 0 || pending.manifest.version === wanted) && canResumeImport(pending, plan);
+  if (!resumable && hasNothingToImport(plan)) {
+    console.log("No agent instruction files found; nothing to import.");
+    return;
+  }
+  if (!resumable && isImportCurrent(plan, state)) {
+    console.log("OK: Build already has these instructions.");
+    const owed = state ? optimizationLines(state.optimization) : [];
+    if (owed.length === 0 && wanted === "optimized" && state?.version === "verbatim") {
+      owed.push(`Info: Run "${OPTIMIZE_COMMAND}" to replace the verbatim version.`);
+    }
+    for (const line of owed) console.log(line);
+    return;
+  }
+  if (!yes && !isInteractive()) {
+    renderPlan(plan);
+    console.error(
+      "Error: confirmation needed. Run in a terminal, or add --yes to install the verbatim version."
+    );
+    process.exitCode = 1;
+    return;
+  }
+  renderPlan(plan);
+  if (resumable && pending) {
+    console.log(
+      `Info: finishing the import prepared ${pending.manifest.createdAt} (${pending.manifest.version} version).`
+    );
+    const resumed = planForStagedImport(pending, plan);
+    await reviewAndActivate({ verbatim: plan, plan: resumed, staged: pending, yes, agreed: false });
+    return;
+  }
+  let version = wanted;
+  let agreed = false;
+  const optimizer = version === "verbatim" ? void 0 : resolveImportOptimizer();
+  if (version === void 0 && optimizer?.ready) {
+    version = await askVersion(optimizer.provider);
+    if (version === void 0) {
+      declineStagedImport(void 0, plan.fingerprints);
+      console.log("No changes made.");
+      return;
+    }
+    agreed = true;
+  }
+  let install = plan;
+  let optimization = { status: "none" };
+  if (version !== "verbatim") {
+    if (yes && refuseScriptedReplace(plan)) return;
+    if (optimizer?.ready) {
+      console.log(
+        `Info: Making the optimized version with ${optimizer.provider} (one model call, no tools).`
+      );
+    }
+    ({ plan: install, optimization } = await prepareOptimizedImport(plan, { optimizer }));
+    if (optimization.status === "pending") {
+      console.error(
+        `Warning: no optimized version: ${optimization.reason}. ${yes ? "Installing" : "Offering"} the verbatim version instead.`
+      );
+      agreed = false;
+    } else {
+      reportOptimized(install, plan);
+    }
+  }
+  if (pending) markStagedImport(pending, "superseded");
+  const staged = stageInstructionsImport(install, optimization);
+  await reviewAndActivate({
+    verbatim: plan,
+    plan: install,
+    staged,
+    yes,
+    agreed,
+    instead: optimization.status === "pending"
+  });
+}
+function createInstructionsImportCommand() {
+  return new Command("import").description("Bring your agents' global instructions into Build").option(
+    "--yes",
+    "Install without prompting: the verbatim version, or the optimized one with --use optimized",
+    false
+  ).option("--use <version>", "Version to install: optimized or verbatim").option("--optimize", "Replace an installed verbatim version with the optimized one", false).option("--check", "Report what an import would do; writes nothing, calls no model", false).option("--json", "With --check, print the report as JSON", false).action(async (options) => {
+    await runInstructionsImport(options);
+  });
+}
+
+export {
+  displayPath,
+  planInstructionsImport,
+  isImportCurrent,
+  ImportActivationError,
+  stageInstructionsImport,
+  canResumeImport,
+  markStagedImport,
+  activateStagedImport,
+  declineStagedImport,
+  resolveImportOptimizer,
+  prepareOptimizedImport,
+  formatLineDiff,
+  hasNothingToImport,
+  steeringLimitLines,
+  renderDifference,
+  resultLines,
+  askYesNo,
+  planForStagedImport,
+  createInstructionsImportCommand
+};
+//# sourceMappingURL=chunk-NHNPEZS4.js.map