bearings 0.2.0 → 0.3.1

package/dist/chunk-VRWQ3OWC.js

@@ -0,0 +1,654 @@
+#!/usr/bin/env node
+
+// src/paths.ts
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+function templatesDir() {
+  return join(dirname(fileURLToPath(import.meta.url)), "..", "templates");
+}
+var SKILLS = [
+  "commit-convention",
+  "defer-work",
+  "resurface-deferred-work",
+  "recording-decisions"
+];
+var SCAFFOLD = [
+  { template: "AGENTS.md", target: "AGENTS.md", owner: "agent" },
+  { template: "CLAUDE.md", target: "CLAUDE.md", owner: "bearings" },
+  { template: "docs/DOMAIN.md", target: "docs/DOMAIN.md", owner: "agent" },
+  { template: "docs/ARCHITECTURE.md", target: "docs/ARCHITECTURE.md", owner: "agent" },
+  { template: "docs/CODEBASE_MAP.md", target: "docs/CODEBASE_MAP.md", owner: "agent" },
+  { template: "docs/adr/INDEX.md", target: "docs/adr/INDEX.md", owner: "agent" },
+  { template: "docs/adr/0000-template.md", target: "docs/adr/0000-template.md", owner: "bearings" },
+  { template: "docs/deferred/INDEX.md", target: "docs/deferred/INDEX.md", owner: "agent" },
+  { template: "agents/commands/refresh-repo-map.md", target: ".agents/commands/refresh-repo-map.md", owner: "bearings" },
+  { template: "agents/commands/setup-repo.md", target: ".agents/commands/setup-repo.md", owner: "bearings" },
+  ...SKILLS.map((skill) => ({
+    template: `agents/skills/${skill}/SKILL.md`,
+    target: `.agents/skills/${skill}/SKILL.md`,
+    owner: "bearings"
+  }))
+];
+
+// src/manifest.ts
+import { createHash } from "crypto";
+import { access, mkdir, readFile, writeFile } from "fs/promises";
+import { join as join2 } from "path";
+function sha256(content) {
+  return "sha256:" + createHash("sha256").update(content).digest("hex");
+}
+function manifestPath(repoDir) {
+  return join2(repoDir, ".agents", "bearings.json");
+}
+async function saveManifest(repoDir, m) {
+  await mkdir(join2(repoDir, ".agents"), { recursive: true });
+  await writeFile(manifestPath(repoDir), JSON.stringify(m, null, 2) + "\n");
+}
+var HASH = /^sha256:[0-9a-f]{64}$/;
+var HARNESSES = ["claude", "opencode"];
+var EXPOSURES = ["symlink", "copy"];
+var OWNERS = ["bearings", "agent"];
+var RECONCILIATION_REASONS = ["init-collision", "update-merge"];
+var SETUP_PENDING_KINDS = ["update", "reconstruction"];
+function fail(message) {
+  throw new Error(message);
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSafeManifestPath(value) {
+  if (typeof value !== "string" || !value || value.includes("\\")) return false;
+  if (value.startsWith("/") || value.split("/").some((part) => !part || part === "." || part === "..")) return false;
+  return true;
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isHash(value) {
+  return typeof value === "string" && HASH.test(value);
+}
+function isHarnessArray(value) {
+  return Array.isArray(value) && value.every((h) => HARNESSES.includes(h));
+}
+function isExposure(value) {
+  return typeof value === "string" && EXPOSURES.includes(value);
+}
+function isOwner(value) {
+  return typeof value === "string" && OWNERS.includes(value);
+}
+function validateReconciliation(value, context) {
+  if (!isPlainObject(value)) fail(`${context} must be an object`);
+  const { backup, reason, sourceHash, incomingTemplateVersion, incomingHash } = value;
+  if (!isSafeManifestPath(backup)) fail(`${context}.backup is unsafe: ${String(backup)}`);
+  if (typeof reason !== "string" || !RECONCILIATION_REASONS.includes(reason)) {
+    fail(`${context}.reason must be "init-collision" or "update-merge"`);
+  }
+  if (!isHash(sourceHash)) fail(`${context}.sourceHash must match sha256 format`);
+  if (!isNonEmptyString(incomingTemplateVersion)) fail(`${context}.incomingTemplateVersion must be a string`);
+  if (!isHash(incomingHash)) fail(`${context}.incomingHash must match sha256 format`);
+  return {
+    backup,
+    reason,
+    sourceHash,
+    incomingTemplateVersion,
+    incomingHash
+  };
+}
+function validateFileV1(value, index) {
+  const context = `files[${index}]`;
+  if (!isPlainObject(value)) fail(`${context} must be an object`);
+  const { path, template, templateVersion, hash, owner, backup } = value;
+  if (!isSafeManifestPath(path)) fail(`${context}.path is unsafe: ${String(path)}`);
+  if (!isNonEmptyString(template)) fail(`${context}.template must be a string`);
+  if (!isNonEmptyString(templateVersion)) fail(`${context}.templateVersion must be a string`);
+  if (!isHash(hash)) fail(`${context}.hash must match sha256 format`);
+  if (!isOwner(owner)) fail(`${context}.owner must be "bearings" or "agent"`);
+  if (backup !== void 0 && !isSafeManifestPath(backup)) fail(`${context}.backup is unsafe: ${String(backup)}`);
+  return {
+    path,
+    template,
+    templateVersion,
+    hash,
+    owner,
+    ...backup !== void 0 ? { backup } : {}
+  };
+}
+function validateFileV2(value, index) {
+  const context = `files[${index}]`;
+  if (!isPlainObject(value)) fail(`${context} must be an object`);
+  const { path, template, templateVersion, hash, owner, retired, skippedTemplate, reconciliations } = value;
+  if (!isSafeManifestPath(path)) fail(`${context}.path is unsafe: ${String(path)}`);
+  if (!isNonEmptyString(template)) fail(`${context}.template must be a string`);
+  if (!isNonEmptyString(templateVersion)) fail(`${context}.templateVersion must be a string`);
+  if (!isHash(hash)) fail(`${context}.hash must match sha256 format`);
+  if (!isOwner(owner)) fail(`${context}.owner must be "bearings" or "agent"`);
+  if (retired !== void 0 && retired !== true) fail(`${context}.retired must be true when present`);
+  let normalizedSkippedTemplate;
+  if (skippedTemplate !== void 0) {
+    if (!isPlainObject(skippedTemplate)) fail(`${context}.skippedTemplate must be an object`);
+    const { templateVersion: skippedVersion, hash: skippedHash } = skippedTemplate;
+    if (!isNonEmptyString(skippedVersion)) fail(`${context}.skippedTemplate.templateVersion must be a string`);
+    if (!isHash(skippedHash)) fail(`${context}.skippedTemplate.hash must match sha256 format`);
+    normalizedSkippedTemplate = { templateVersion: skippedVersion, hash: skippedHash };
+  }
+  let normalizedReconciliations;
+  if (reconciliations !== void 0) {
+    if (!Array.isArray(reconciliations)) fail(`${context}.reconciliations must be an array`);
+    normalizedReconciliations = reconciliations.map((entry, reconciliationIndex) => validateReconciliation(entry, `${context}.reconciliations[${reconciliationIndex}]`));
+  }
+  if (retired === true && !normalizedReconciliations?.length) {
+    fail(`${context}.retired requires at least one reconciliation`);
+  }
+  return {
+    path,
+    template,
+    templateVersion,
+    hash,
+    owner,
+    ...retired === true ? { retired: true } : {},
+    ...normalizedSkippedTemplate ? { skippedTemplate: normalizedSkippedTemplate } : {},
+    ...normalizedReconciliations ? { reconciliations: normalizedReconciliations } : {}
+  };
+}
+function assertUniquePaths(paths) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const path of paths) {
+    if (seen.has(path)) fail(`duplicate managed path: ${path}`);
+    seen.add(path);
+  }
+}
+function validateSetupPending(value) {
+  if (!isPlainObject(value)) fail("setupPending must be an object");
+  const { kind, fromVersion, toVersion } = value;
+  if (typeof kind !== "string" || !SETUP_PENDING_KINDS.includes(kind)) {
+    fail('setupPending.kind must be "update" or "reconstruction"');
+  }
+  if (fromVersion !== void 0 && !isNonEmptyString(fromVersion)) fail("setupPending.fromVersion must be a string");
+  if (!isNonEmptyString(toVersion)) fail("setupPending.toVersion must be a string");
+  return {
+    kind,
+    ...fromVersion !== void 0 ? { fromVersion } : {},
+    toVersion
+  };
+}
+function parseManifest(raw) {
+  if (!isPlainObject(raw)) fail("manifest must be an object");
+  const { version, bearingsVersion, harnesses, exposure, files } = raw;
+  if (!isNonEmptyString(bearingsVersion)) fail("bearingsVersion must be a string");
+  if (!isHarnessArray(harnesses)) fail('harnesses must contain only "claude" or "opencode"');
+  if (!isExposure(exposure)) fail('exposure must be "symlink" or "copy"');
+  if (!Array.isArray(files)) fail("files must be an array");
+  if (version === 1) {
+    const validatedFiles = files.map((file, index) => validateFileV1(file, index));
+    assertUniquePaths(validatedFiles.map((file) => file.path));
+    return { version: 1, bearingsVersion, harnesses, exposure, files: validatedFiles };
+  }
+  if (version === 2) {
+    const validatedFiles = files.map((file, index) => validateFileV2(file, index));
+    assertUniquePaths(validatedFiles.map((file) => file.path));
+    const { setupPending } = raw;
+    return {
+      version: 2,
+      bearingsVersion,
+      harnesses,
+      exposure,
+      ...setupPending !== void 0 ? { setupPending: validateSetupPending(setupPending) } : {},
+      files: validatedFiles
+    };
+  }
+  fail(`unsupported manifest version: ${String(version)}`);
+}
+async function inspectManifest(repoDir) {
+  let raw;
+  try {
+    raw = await readFile(manifestPath(repoDir), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return { kind: "absent" };
+    return { kind: "invalid", message: error.message };
+  }
+  try {
+    return { kind: "valid", manifest: parseManifest(JSON.parse(raw)) };
+  } catch (error) {
+    return { kind: "invalid", message: error.message };
+  }
+}
+async function migrateV1(repoDir, manifest) {
+  const files = await Promise.all(manifest.files.map(async (file) => {
+    const backupExists = file.backup ? await access(join2(repoDir, file.backup)).then(() => true, () => false) : false;
+    const reconciliation = backupExists && file.backup ? {
+      backup: file.backup,
+      reason: "init-collision",
+      sourceHash: sha256(await readFile(join2(repoDir, file.backup), "utf8")),
+      incomingTemplateVersion: file.templateVersion,
+      incomingHash: file.hash
+    } : void 0;
+    return {
+      path: file.path,
+      template: file.template,
+      templateVersion: file.templateVersion,
+      hash: file.hash,
+      owner: file.owner,
+      ...reconciliation ? { reconciliations: [reconciliation] } : {}
+    };
+  }));
+  return { version: 2, bearingsVersion: manifest.bearingsVersion, harnesses: manifest.harnesses, exposure: manifest.exposure, files };
+}
+
+// src/report.ts
+function renderInitReport(r, exposed, m) {
+  const lines = ["bearings init complete.", ""];
+  lines.push(`Written (${r.written.length}):`, ...r.written.map((p) => `  + ${p}`));
+  if (r.backedUp.length) {
+    lines.push("", `Backed up (${r.backedUp.length}) \u2014 review during /setup-repo:`);
+    lines.push(...r.backedUp.map((b) => `  \u26A0 ${b.path} -> ${b.backup}`));
+  }
+  if (r.skippedUnchanged.length) {
+    lines.push(
+      "",
+      `Skipped, unchanged (${r.skippedUnchanged.length}):`,
+      ...r.skippedUnchanged.map((p) => `  = ${p}`)
+    );
+  }
+  lines.push(
+    "",
+    `Exposed to harnesses [${m.harnesses.join(", ")}] via ${m.exposure}:`,
+    ...exposed.map((p) => `  ~ ${p}`)
+  );
+  lines.push(
+    "",
+    "Next step \u2014 finish setup with your AI agent:",
+    "  Open your agent (Claude Code, OpenCode, ...) in this repo and run:",
+    "    /setup-repo",
+    "  It will review any backups, interview you, and tailor the setup.",
+    "  Finish by running: bearings verify"
+  );
+  return lines.join("\n");
+}
+function categorizeActions(actions) {
+  const result = {
+    added: [],
+    restored: [],
+    replaced: [],
+    merged: [],
+    skipped: [],
+    removed: [],
+    keptUntracked: []
+  };
+  for (const action of actions) {
+    if (action.kind === "write") {
+      if (action.reason === "add") result.added.push(action.path);
+      else if (action.reason === "restore") result.restored.push(action.path);
+      else result.replaced.push(action.path);
+    } else if (action.kind === "merge") {
+      result.merged.push(`${action.path} -> ${action.backup}`);
+    } else if (action.kind === "skip") {
+      result.skipped.push(action.path);
+    } else if (action.kind === "delete") {
+      result.removed.push(action.path);
+    } else if (action.kind === "keep-untracked") {
+      result.keptUntracked.push(action.path);
+    }
+  }
+  return result;
+}
+function pushSection(lines, title, items) {
+  if (!items.length) return;
+  lines.push("", `${title} (${items.length}):`, ...items.map((i) => `  ${i}`));
+}
+function renderUpdatePlan(input) {
+  const categories = categorizeActions(input.actions);
+  const lines = [input.reconstruction ? "bearings init: reconstruction plan" : "bearings init: update plan"];
+  pushSection(lines, "Added", categories.added);
+  pushSection(lines, "Restored", categories.restored);
+  pushSection(lines, "Replaced", categories.replaced);
+  pushSection(lines, "Merged", categories.merged);
+  pushSection(lines, "Skipped", categories.skipped);
+  pushSection(lines, "Removed", categories.removed);
+  pushSection(lines, "Kept and untracked", categories.keptUntracked);
+  if (input.adapterActions.length) {
+    lines.push("", `Adapter changes (${input.adapterActions.length}):`);
+    for (const a of input.adapterActions) lines.push(`  ${a.kind} ${a.path}`);
+  }
+  lines.push(
+    "",
+    `Manifest changes: schema ${input.fromSchema ?? "\u2014"} -> ${input.toSchema}, version ${input.fromVersion ?? "\u2014"} -> ${input.toVersion}`
+  );
+  lines.push("", "Proceed?");
+  return lines.join("\n");
+}
+function renderUpdateReport(input) {
+  const categories = categorizeActions(input.actions);
+  const lines = [
+    input.reconstruction ? "bearings init: reconstruction complete." : "bearings init: update complete."
+  ];
+  pushSection(lines, "Added", categories.added);
+  pushSection(lines, "Restored", categories.restored);
+  pushSection(lines, "Replaced", categories.replaced);
+  pushSection(lines, "Merged", categories.merged);
+  pushSection(lines, "Skipped", categories.skipped);
+  pushSection(lines, "Removed", categories.removed);
+  pushSection(lines, "Kept and untracked", categories.keptUntracked);
+  if (input.adapterActions.length) {
+    lines.push("", `Adapter changes (${input.adapterActions.length}):`);
+    for (const a of input.adapterActions) lines.push(`  ${a.kind} ${a.path}`);
+  }
+  lines.push(
+    "",
+    `Manifest changes: schema ${input.fromSchema ?? "\u2014"} -> ${input.toSchema}, version ${input.fromVersion ?? "\u2014"} -> ${input.toVersion}`
+  );
+  if (input.setupRequired) {
+    lines.push(
+      "",
+      "Next step \u2014 finish setup with your AI agent:",
+      "  Open your agent (Claude Code, OpenCode, ...) in this repo and run:",
+      "    /setup-repo",
+      "  It will review any backups, interview you, and tailor the setup.",
+      "  Finish by running: bearings verify"
+    );
+  } else {
+    lines.push("", "Finish by running: bearings verify");
+  }
+  return lines.join("\n");
+}
+function renderVerifyReport(v) {
+  const lines = [];
+  for (const f of v.failures) lines.push(`FAIL ${f.code} ${f.path} \u2014 ${f.message}`);
+  for (const w of v.warnings) lines.push(`warn ${w.code} ${w.path} \u2014 ${w.message}`);
+  lines.push(v.failures.length ? `
+${v.failures.length} failure(s).` : "\nbearings verify: OK");
+  return lines.join("\n");
+}
+
+// src/commands/init.ts
+import { lstat as lstat2, readdir as readdir2 } from "fs/promises";
+import { join as join6 } from "path";
+
+// src/scanner.ts
+import { access as access2, symlink, rm } from "fs/promises";
+import { join as join3 } from "path";
+async function exists(p) {
+  try {
+    await access2(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function scan(repoDir) {
+  const collisions = [];
+  for (const e of SCAFFOLD) if (await exists(join3(repoDir, e.target))) collisions.push(e.target);
+  const harnessDirsPresent = [];
+  for (const h of ["claude", "opencode"])
+    if (await exists(join3(repoDir, `.${h}`))) harnessDirsPresent.push(h);
+  let symlinksSupported = true;
+  const probe = join3(repoDir, ".bearings-symlink-probe");
+  try {
+    await symlink(".", probe);
+    await rm(probe);
+  } catch {
+    symlinksSupported = false;
+  }
+  return { collisions, harnessDirsPresent, symlinksSupported };
+}
+
+// src/generator.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2, rename, access as access3 } from "fs/promises";
+import { dirname as dirname2, join as join4 } from "path";
+async function exists2(p) {
+  try {
+    await access3(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function freeBackupPath(repoDir, target) {
+  let candidate = `${target}.bkp`;
+  for (let i = 1; await exists2(join4(repoDir, candidate)); i++) candidate = `${target}.bkp.${i}`;
+  return candidate;
+}
+async function generate(repoDir, bearingsVersion) {
+  const priorState = await inspectManifest(repoDir);
+  if (priorState.kind === "invalid") throw new Error(`Invalid manifest: ${priorState.message}`);
+  const prior = priorState.kind === "valid" ? priorState.manifest.version === 1 ? await migrateV1(repoDir, priorState.manifest) : priorState.manifest : null;
+  const result = { written: [], backedUp: [], skippedUnchanged: [], files: [] };
+  for (const entry of SCAFFOLD) {
+    const abs = join4(repoDir, entry.target);
+    const templateContent = await readFile2(join4(templatesDir(), entry.template), "utf8");
+    const priorEntry = prior?.files.find((f) => f.path === entry.target);
+    let backup;
+    let currentContent;
+    if (await exists2(abs)) {
+      currentContent = await readFile2(abs, "utf8");
+      if (priorEntry && sha256(currentContent) === priorEntry.hash) {
+        result.skippedUnchanged.push(entry.target);
+        result.files.push(priorEntry);
+        continue;
+      }
+      backup = await freeBackupPath(repoDir, entry.target);
+      await rename(abs, join4(repoDir, backup));
+      result.backedUp.push({ path: entry.target, backup });
+    }
+    await mkdir2(dirname2(abs), { recursive: true });
+    await writeFile2(abs, templateContent);
+    result.written.push(entry.target);
+    const incomingHash = sha256(templateContent);
+    const reconciliation = backup && currentContent !== void 0 ? {
+      backup,
+      reason: "init-collision",
+      sourceHash: sha256(currentContent),
+      incomingTemplateVersion: bearingsVersion,
+      incomingHash
+    } : void 0;
+    result.files.push({
+      path: entry.target,
+      template: entry.template,
+      templateVersion: bearingsVersion,
+      hash: incomingHash,
+      owner: entry.owner,
+      ...reconciliation ? { reconciliations: [reconciliation] } : {}
+    });
+  }
+  return result;
+}
+
+// src/adapters.ts
+import { mkdir as mkdir3, readdir, symlink as symlink2, lstat, readlink, rm as rm2, cp, readFile as readFile3 } from "fs/promises";
+import { join as join5 } from "path";
+var ADAPTER_KINDS = ["skills", "commands"];
+async function canonicalAdapterEntries(repoDir) {
+  const entries = /* @__PURE__ */ new Map();
+  for (const kind of ADAPTER_KINDS) {
+    const directory = join5(repoDir, ".agents", kind);
+    for (const name of await readdir(directory).catch(() => [])) {
+      entries.set(`${kind}/${name}`, join5(directory, name));
+    }
+  }
+  return entries;
+}
+async function entriesMatch(src, dst) {
+  const srcStat = await lstat(src).catch(() => null);
+  const dstStat = await lstat(dst).catch(() => null);
+  if (!srcStat || !dstStat) return false;
+  if (srcStat.isSymbolicLink() || dstStat.isSymbolicLink()) {
+    return srcStat.isSymbolicLink() && dstStat.isSymbolicLink() && await readlink(src) === await readlink(dst);
+  }
+  if (srcStat.isDirectory() || dstStat.isDirectory()) {
+    if (!srcStat.isDirectory() || !dstStat.isDirectory()) return false;
+    const [srcEntries, dstEntries] = await Promise.all([readdir(src), readdir(dst)]);
+    if (srcEntries.length !== dstEntries.length) return false;
+    srcEntries.sort();
+    dstEntries.sort();
+    for (let i = 0; i < srcEntries.length; i++) {
+      if (srcEntries[i] !== dstEntries[i]) return false;
+      if (!await entriesMatch(join5(src, srcEntries[i]), join5(dst, dstEntries[i]))) return false;
+    }
+    return true;
+  }
+  if (srcStat.isFile() || dstStat.isFile()) {
+    return srcStat.isFile() && dstStat.isFile() && (await readFile3(src)).equals(await readFile3(dst));
+  }
+  return false;
+}
+async function expose(repoDir, harness, mode) {
+  const created = [];
+  for (const kind of ADAPTER_KINDS) {
+    const srcDir = join5(repoDir, ".agents", kind);
+    let entries;
+    try {
+      entries = await readdir(srcDir);
+    } catch {
+      continue;
+    }
+    const dstDir = join5(repoDir, `.${harness}`, kind);
+    await mkdir3(dstDir, { recursive: true });
+    for (const name of entries) {
+      const dst = join5(dstDir, name);
+      const adapterPath = join5(`.${harness}`, kind, name);
+      const relTarget = join5("..", "..", ".agents", kind, name);
+      const stat = await lstat(dst).catch(() => null);
+      if (mode === "symlink") {
+        if (stat?.isSymbolicLink() && await readlink(dst) === relTarget) continue;
+        if (stat && !stat.isSymbolicLink()) throw new Error(`Refusing to replace existing adapter entry: ${adapterPath}`);
+        if (stat) await rm2(dst, { recursive: true });
+        await symlink2(relTarget, dst);
+      } else {
+        const src = join5(srcDir, name);
+        if (stat && await entriesMatch(src, dst)) continue;
+        if (stat && !stat.isSymbolicLink()) throw new Error(`Refusing to replace existing adapter entry: ${adapterPath}`);
+        if (stat) await rm2(dst, { recursive: true });
+        await cp(src, dst, { recursive: true });
+      }
+      created.push(adapterPath);
+    }
+  }
+  return created;
+}
+
+// src/commands/init.ts
+var VALID_HARNESSES = ["claude", "opencode"];
+var KINDS = ["skills", "commands"];
+function validateHarnesses(harnesses) {
+  if (!harnesses) return void 0;
+  for (const harness of harnesses) {
+    if (!VALID_HARNESSES.includes(harness)) {
+      throw new Error(`Invalid harness: ${String(harness)}`);
+    }
+  }
+  return harnesses;
+}
+function cancelInit(p) {
+  p.cancel("Init cancelled.");
+  throw new Error("Init cancelled.");
+}
+async function plannedAdapterSources(repoDir) {
+  const sources = { skills: /* @__PURE__ */ new Map(), commands: /* @__PURE__ */ new Map() };
+  for (const entry of SCAFFOLD) {
+    for (const kind of KINDS) {
+      const prefix = `.agents/${kind}/`;
+      if (entry.target.startsWith(prefix)) {
+        const name = entry.target.slice(prefix.length).split("/")[0];
+        sources[kind].set(name, join6(templatesDir(), "agents", kind, name));
+      }
+    }
+  }
+  for (const kind of KINDS) {
+    const srcDir = join6(repoDir, ".agents", kind);
+    for (const name of await readdir2(srcDir).catch(() => [])) {
+      if (!sources[kind].has(name)) sources[kind].set(name, join6(srcDir, name));
+    }
+  }
+  return sources;
+}
+async function preflightAdapterCollisions(repoDir, harnesses, exposure) {
+  const sources = await plannedAdapterSources(repoDir);
+  for (const h of harnesses) {
+    for (const kind of KINDS) {
+      for (const [name, source] of sources[kind]) {
+        const adapterPath = join6(`.${h}`, kind, name);
+        const target = join6(repoDir, adapterPath);
+        const stat = await lstat2(target).catch(() => null);
+        if (!stat || stat.isSymbolicLink()) continue;
+        if (exposure === "copy" && await entriesMatch(source, target)) continue;
+        throw new Error(`Refusing to replace existing adapter entry: ${adapterPath}`);
+      }
+    }
+  }
+}
+async function runFreshInit(repoDir, flags, version) {
+  const s = await scan(repoDir);
+  let harnesses = validateHarnesses(flags.harnesses);
+  let exposure = flags.exposure;
+  if (!harnesses || !exposure) {
+    if (flags.yes || !process.stdin.isTTY) {
+      harnesses ??= s.harnessDirsPresent.length ? s.harnessDirsPresent : ["claude", "opencode"];
+      exposure ??= s.symlinksSupported ? "symlink" : "copy";
+    } else {
+      const p = await import("@clack/prompts");
+      if (!harnesses) {
+        const selectedHarnesses = await p.multiselect({
+          message: "Expose skills/commands to which harnesses?",
+          options: [
+            { value: "claude", label: "Claude Code (.claude/)" },
+            { value: "opencode", label: "OpenCode (.opencode/)" }
+          ],
+          initialValues: s.harnessDirsPresent.length ? s.harnessDirsPresent : ["claude", "opencode"]
+        });
+        if (p.isCancel(selectedHarnesses)) {
+          cancelInit(p);
+        }
+        harnesses = validateHarnesses(selectedHarnesses);
+      }
+      if (!exposure && s.symlinksSupported) {
+        const selectedExposure = await p.select({
+          message: "Exposure mode?",
+          options: [
+            { value: "symlink", label: "Symlinks (recommended)" },
+            { value: "copy", label: "Copies (verify checks drift)" }
+          ]
+        });
+        if (p.isCancel(selectedExposure)) {
+          cancelInit(p);
+        }
+        exposure = selectedExposure;
+      } else {
+        exposure ??= "copy";
+      }
+    }
+  }
+  await preflightAdapterCollisions(repoDir, harnesses, exposure);
+  const gen = await generate(repoDir, version);
+  const exposed = [];
+  for (const h of harnesses) exposed.push(...await expose(repoDir, h, exposure));
+  const manifest = {
+    version: 2,
+    bearingsVersion: version,
+    harnesses,
+    exposure,
+    files: gen.files
+  };
+  await saveManifest(repoDir, manifest);
+  return { manifest, report: renderInitReport(gen, exposed, manifest) };
+}
+async function runInit(repoDir, flags, version) {
+  const state = await inspectManifest(repoDir);
+  if (state.kind === "absent") return runFreshInit(repoDir, flags, version);
+  const { runUpdate } = await import("./update-5F7TZEUH.js");
+  return runUpdate(repoDir, flags, version, state);
+}
+
+export {
+  templatesDir,
+  SCAFFOLD,
+  sha256,
+  inspectManifest,
+  migrateV1,
+  ADAPTER_KINDS,
+  canonicalAdapterEntries,
+  entriesMatch,
+  renderUpdatePlan,
+  renderUpdateReport,
+  renderVerifyReport,
+  validateHarnesses,
+  runInit
+};