bearings 0.2.0 → 0.3.0

package/dist/update-GAIUBEGX.js

@@ -0,0 +1,799 @@
+#!/usr/bin/env node
+import {
+  ADAPTER_KINDS,
+  SCAFFOLD,
+  canonicalAdapterEntries,
+  entriesMatch,
+  migrateV1,
+  renderUpdatePlan,
+  renderUpdateReport,
+  sha256,
+  templatesDir,
+  validateHarnesses
+} from "./chunk-GUIHDRBB.js";
+
+// src/semver.ts
+function parseSemver(value) {
+  const [withoutBuild, ...build] = value.split("+");
+  if (build.length > 1 || build.some((part) => !/^[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*$/.test(part))) {
+    throw new Error(`Invalid semantic version: ${value}`);
+  }
+  const [coreText, ...preParts] = withoutBuild.split("-");
+  const core = coreText.split(".");
+  if (core.length !== 3 || core.some((part) => !/^(0|[1-9]\d*)$/.test(part))) {
+    throw new Error(`Invalid semantic version: ${value}`);
+  }
+  const prerelease = preParts.length ? preParts.join("-").split(".") : [];
+  if (prerelease.some((part) => !/^[0-9A-Za-z-]+$/.test(part) || /^\d+$/.test(part) && !/^(0|[1-9]\d*)$/.test(part))) {
+    throw new Error(`Invalid semantic version: ${value}`);
+  }
+  return { core, prerelease };
+}
+function compareNumeric(left, right) {
+  if (left.length !== right.length) return left.length < right.length ? -1 : 1;
+  return left === right ? 0 : left < right ? -1 : 1;
+}
+function compareIdentifier(left, right) {
+  const leftNumeric = /^\d+$/.test(left);
+  const rightNumeric = /^\d+$/.test(right);
+  if (leftNumeric && rightNumeric) return compareNumeric(left, right);
+  if (leftNumeric !== rightNumeric) return leftNumeric ? -1 : 1;
+  return left === right ? 0 : left < right ? -1 : 1;
+}
+function compareSemver(left, right) {
+  const a = parseSemver(left);
+  const b = parseSemver(right);
+  for (let index = 0; index < 3; index++) {
+    const compared = compareNumeric(a.core[index], b.core[index]);
+    if (compared) return compared;
+  }
+  if (!a.prerelease.length || !b.prerelease.length) {
+    return a.prerelease.length === b.prerelease.length ? 0 : a.prerelease.length ? -1 : 1;
+  }
+  for (let index = 0; index < Math.max(a.prerelease.length, b.prerelease.length); index++) {
+    if (a.prerelease[index] === void 0) return -1;
+    if (b.prerelease[index] === void 0) return 1;
+    const compared = compareIdentifier(a.prerelease[index], b.prerelease[index]);
+    if (compared) return compared;
+  }
+  return 0;
+}
+
+// src/update/planner.ts
+import { access, readFile } from "fs/promises";
+import { join } from "path";
+var SETUP_COMMAND_PATH = ".agents/commands/setup-repo.md";
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function freeBackupPath(repoDir, target) {
+  let candidate = `${target}.bkp`;
+  for (let i = 1; await exists(join(repoDir, candidate)); i++) candidate = `${target}.bkp.${i}`;
+  return candidate;
+}
+function lineDiffStats(current, incoming) {
+  const left = current.split("\n");
+  const right = incoming.split("\n");
+  let previous = new Uint32Array(right.length + 1);
+  for (const line of left) {
+    const next = new Uint32Array(right.length + 1);
+    for (let index = 1; index <= right.length; index++) {
+      next[index] = line === right[index - 1] ? previous[index - 1] + 1 : Math.max(previous[index], next[index - 1]);
+    }
+    previous = next;
+  }
+  const common = previous[right.length];
+  return { added: right.length - common, removed: left.length - common };
+}
+async function planFiles(input) {
+  const { repoDir, previous, source, reconstruction } = input;
+  const actions = [];
+  const consumedPaths = /* @__PURE__ */ new Set();
+  for (const entry of source.scaffold) {
+    consumedPaths.add(entry.target);
+    const abs = join(repoDir, entry.target);
+    const currentExists = await exists(abs);
+    const currentContent = currentExists ? await readFile(abs, "utf8") : void 0;
+    const currentHash = currentContent !== void 0 ? sha256(currentContent) : void 0;
+    const templateContent = await readFile(join(source.templatesDir, entry.template), "utf8");
+    const incomingHash = sha256(templateContent);
+    const incomingRecord = {
+      path: entry.target,
+      template: entry.template,
+      templateVersion: source.bearingsVersion,
+      hash: incomingHash,
+      owner: entry.owner
+    };
+    const prevRecord = previous?.files.find((file) => file.path === entry.target);
+    const canSkip = entry.target !== SETUP_COMMAND_PATH;
+    if (!currentExists) {
+      actions.push({
+        kind: "write",
+        reason: prevRecord ? "restore" : "add",
+        path: entry.target,
+        content: templateContent,
+        record: incomingRecord
+      });
+      continue;
+    }
+    if (!prevRecord && reconstruction && currentHash === incomingHash) {
+      actions.push({ kind: "keep", record: incomingRecord });
+      continue;
+    }
+    if (!prevRecord) {
+      actions.push({
+        kind: "conflict",
+        reason: "new-path",
+        path: entry.target,
+        content: templateContent,
+        currentHash,
+        record: incomingRecord,
+        stats: lineDiffStats(currentContent, templateContent),
+        canSkip
+      });
+      continue;
+    }
+    if (prevRecord.skippedTemplate?.hash === incomingHash) {
+      actions.push({ kind: "keep", record: prevRecord });
+      continue;
+    }
+    if (incomingHash === prevRecord.hash) {
+      actions.push({ kind: "keep", record: prevRecord });
+      continue;
+    }
+    if (currentHash === prevRecord.hash) {
+      actions.push({
+        kind: "write",
+        reason: "replace",
+        path: entry.target,
+        content: templateContent,
+        record: incomingRecord
+      });
+      continue;
+    }
+    actions.push({
+      kind: "conflict",
+      reason: "changed",
+      path: entry.target,
+      content: templateContent,
+      currentHash,
+      record: incomingRecord,
+      previous: prevRecord,
+      stats: lineDiffStats(currentContent, templateContent),
+      canSkip
+    });
+  }
+  if (previous) {
+    for (const prevRecord of previous.files) {
+      if (consumedPaths.has(prevRecord.path)) continue;
+      const abs = join(repoDir, prevRecord.path);
+      if (!await exists(abs)) {
+        actions.push({ kind: "untrack-missing", path: prevRecord.path, previous: prevRecord });
+        continue;
+      }
+      const currentContent = await readFile(abs, "utf8");
+      const currentHash = sha256(currentContent);
+      if (currentHash === prevRecord.hash) {
+        actions.push({ kind: "delete", path: prevRecord.path, previous: prevRecord });
+      } else {
+        actions.push({ kind: "removed-conflict", path: prevRecord.path, previous: prevRecord });
+      }
+    }
+  }
+  return {
+    fromVersion: previous?.bearingsVersion,
+    toVersion: source.bearingsVersion,
+    reconstruction,
+    actions
+  };
+}
+function fail(message) {
+  throw new Error(message);
+}
+function resolveConflict(action, decision) {
+  if (decision.action !== "replace" && decision.action !== "skip") {
+    fail(`Invalid decision for ${action.path}: ${decision.action}`);
+  }
+  if (decision.action === "skip" && !action.canSkip) {
+    fail(`Cannot skip required path: ${action.path}`);
+  }
+  if (decision.action === "replace") {
+    return {
+      resolved: { kind: "write", reason: "replace", path: action.path, content: action.content, record: action.record },
+      record: action.record
+    };
+  }
+  const baseline = action.previous ?? { ...action.record, hash: action.currentHash };
+  const record = {
+    ...baseline,
+    skippedTemplate: { templateVersion: action.record.templateVersion, hash: action.record.hash }
+  };
+  return { resolved: { kind: "skip", path: action.path, record }, record };
+}
+async function resolveMerge(repoDir, action) {
+  const backup = await freeBackupPath(repoDir, action.path);
+  const reconciliation = {
+    backup,
+    reason: "update-merge",
+    sourceHash: action.currentHash,
+    incomingTemplateVersion: action.record.templateVersion,
+    incomingHash: action.record.hash
+  };
+  const record = {
+    ...action.record,
+    reconciliations: [...action.previous?.reconciliations ?? [], reconciliation]
+  };
+  return { resolved: { kind: "merge", path: action.path, content: action.content, backup, record }, record };
+}
+function resolveRemovedConflict(action, decision) {
+  if (decision.action !== "remove" && decision.action !== "keep-untracked") {
+    fail(`Invalid decision for ${action.path}: ${decision.action}`);
+  }
+  if (decision.action === "remove") {
+    return { resolved: { kind: "delete", path: action.path, previous: action.previous } };
+  }
+  const resolved = { kind: "keep-untracked", path: action.path, previous: action.previous };
+  if (action.previous.reconciliations?.length) {
+    return { resolved, record: { ...action.previous, retired: true } };
+  }
+  return { resolved };
+}
+async function resolveFilePlan(repoDir, draft, decisions) {
+  const decisionsByPath = /* @__PURE__ */ new Map();
+  for (const decision of decisions) {
+    if (decisionsByPath.has(decision.path)) fail(`Duplicate decision for path: ${decision.path}`);
+    decisionsByPath.set(decision.path, decision);
+  }
+  const actions = [];
+  const files = [];
+  let setupRequired = draft.reconstruction;
+  for (const action of draft.actions) {
+    if (action.kind === "keep") {
+      actions.push(action);
+      files.push(action.record);
+      continue;
+    }
+    if (action.kind === "write") {
+      actions.push(action);
+      files.push(action.record);
+      setupRequired = true;
+      continue;
+    }
+    if (action.kind === "delete") {
+      actions.push(action);
+      setupRequired = true;
+      continue;
+    }
+    if (action.kind === "untrack-missing") {
+      actions.push(action);
+      if (action.previous.reconciliations?.length) {
+        files.push({ ...action.previous, retired: true });
+        setupRequired = true;
+      }
+      continue;
+    }
+    if (action.kind === "conflict") {
+      const decision2 = decisionsByPath.get(action.path);
+      if (!decision2) fail(`Missing decision for path: ${action.path}`);
+      decisionsByPath.delete(action.path);
+      if (decision2.action === "merge") {
+        const { resolved: resolved2, record: record2 } = await resolveMerge(repoDir, action);
+        actions.push(resolved2);
+        files.push(record2);
+      } else {
+        const { resolved: resolved2, record: record2 } = resolveConflict(action, decision2);
+        actions.push(resolved2);
+        if (record2) files.push(record2);
+      }
+      setupRequired = true;
+      continue;
+    }
+    const decision = decisionsByPath.get(action.path);
+    if (!decision) fail(`Missing decision for path: ${action.path}`);
+    decisionsByPath.delete(action.path);
+    const { resolved, record } = resolveRemovedConflict(action, decision);
+    actions.push(resolved);
+    if (record) files.push(record);
+    setupRequired = true;
+  }
+  if (decisionsByPath.size > 0) {
+    const [leftoverPath] = decisionsByPath.keys();
+    fail(`Unexpected decision for path: ${leftoverPath}`);
+  }
+  return { actions, files, setupRequired };
+}
+
+// src/update/adapter-plan.ts
+import { lstat, readdir, readFile as readFile2, readlink } from "fs/promises";
+import { join as join2 } from "path";
+var HARNESSES = ["claude", "opencode"];
+function driftError(adapterPath) {
+  throw new Error(`Adapter drift must be resolved before update: ${adapterPath}`);
+}
+function parseAdapterRoot(path) {
+  for (const kind of ADAPTER_KINDS) {
+    const prefix = `.agents/${kind}/`;
+    if (!path.startsWith(prefix)) continue;
+    const rest = path.slice(prefix.length);
+    const name = kind === "skills" ? rest.split("/")[0] : rest;
+    if (!name) continue;
+    return `${kind}/${name}`;
+  }
+  return void 0;
+}
+function splitRoot(root) {
+  const index = root.indexOf("/");
+  return [root.slice(0, index), root.slice(index + 1)];
+}
+function filesUnderRoot(files, kind, name) {
+  if (kind === "commands") {
+    return files.filter((file) => file.path === `.agents/commands/${name}`);
+  }
+  const prefix = `.agents/${kind}/${name}/`;
+  return files.filter((file) => file.path.startsWith(prefix));
+}
+async function listFilesRecursive(dir, prefix = "") {
+  const entries = await readdir(dir).catch(() => []);
+  const files = [];
+  for (const entry of entries) {
+    const abs = join2(dir, entry);
+    const rel = prefix ? `${prefix}/${entry}` : entry;
+    const stat = await lstat(abs);
+    if (stat.isDirectory()) {
+      files.push(...await listFilesRecursive(abs, rel));
+    } else {
+      files.push(rel);
+    }
+  }
+  return files;
+}
+async function detectHarnessExposure(repoDir, harness) {
+  for (const kind of ADAPTER_KINDS) {
+    const dir = join2(repoDir, `.${harness}`, kind);
+    for (const name of await readdir(dir).catch(() => [])) {
+      const stat = await lstat(join2(dir, name)).catch(() => null);
+      if (stat) return stat.isSymbolicLink() ? "symlink" : "copy";
+    }
+  }
+  return void 0;
+}
+async function detectAdapterConfig(repoDir) {
+  const detected = [];
+  for (const harness of HARNESSES) {
+    const exposure = await detectHarnessExposure(repoDir, harness);
+    if (exposure) detected.push({ harness, exposure });
+  }
+  if (detected.length === 0) {
+    return { harnesses: [...HARNESSES], exposure: "symlink", mixed: false };
+  }
+  const exposures = new Set(detected.map((entry) => entry.exposure));
+  const mixed = exposures.size > 1;
+  return {
+    harnesses: detected.map((entry) => entry.harness),
+    exposure: mixed ? "copy" : detected[0].exposure,
+    mixed
+  };
+}
+async function preflightAdapters(repoDir, manifest) {
+  const rootKeys = /* @__PURE__ */ new Set();
+  for (const file of manifest.files) {
+    const root = parseAdapterRoot(file.path);
+    if (root) rootKeys.add(root);
+  }
+  for (const harness of manifest.harnesses) {
+    for (const root of rootKeys) {
+      const [kind, name] = splitRoot(root);
+      const canonicalAbs = join2(repoDir, ".agents", kind, name);
+      const adapterRel = join2(`.${harness}`, kind, name);
+      const adapterAbs = join2(repoDir, adapterRel);
+      const adapterStat = await lstat(adapterAbs).catch(() => null);
+      if (!adapterStat) continue;
+      const canonicalStat = await lstat(canonicalAbs).catch(() => null);
+      if (canonicalStat) {
+        if (manifest.exposure === "symlink") {
+          const relTarget = join2("..", "..", ".agents", kind, name);
+          if (!adapterStat.isSymbolicLink() || await readlink(adapterAbs) !== relTarget) driftError(adapterRel);
+        } else if (adapterStat.isSymbolicLink() || !await entriesMatch(canonicalAbs, adapterAbs)) {
+          driftError(adapterRel);
+        }
+        continue;
+      }
+      if (manifest.exposure === "symlink" || adapterStat.isSymbolicLink()) driftError(adapterRel);
+      if (kind === "commands") {
+        if (adapterStat.isDirectory()) driftError(adapterRel);
+        const record = manifest.files.find((file) => file.path === `.agents/commands/${name}`);
+        const content = await readFile2(adapterAbs, "utf8");
+        if (!record || sha256(content) !== record.hash) driftError(adapterRel);
+        continue;
+      }
+      if (!adapterStat.isDirectory()) driftError(adapterRel);
+      const expected = filesUnderRoot(manifest.files, kind, name);
+      const actualRelFiles = await listFilesRecursive(adapterAbs);
+      if (actualRelFiles.length !== expected.length) driftError(adapterRel);
+      for (const relFile of actualRelFiles) {
+        const record = expected.find((file) => file.path === `.agents/${kind}/${name}/${relFile}`);
+        if (!record) driftError(adapterRel);
+        const content = await readFile2(join2(adapterAbs, relFile), "utf8");
+        if (sha256(content) !== record.hash) driftError(adapterRel);
+      }
+    }
+  }
+}
+async function preflightAdapterCollisions(input) {
+  const { repoDir, currentHarnesses, desiredHarnesses, scaffold } = input;
+  const previousRootKeys = new Set((await canonicalAdapterEntries(repoDir)).keys());
+  const candidateRoots = new Set(previousRootKeys);
+  for (const entry of scaffold) {
+    const root = parseAdapterRoot(entry.target);
+    if (root) candidateRoots.add(root);
+  }
+  const currentHarnessSet = new Set(currentHarnesses);
+  for (const harness of desiredHarnesses) {
+    for (const root of candidateRoots) {
+      if (currentHarnessSet.has(harness) && previousRootKeys.has(root)) continue;
+      const [kind, name] = splitRoot(root);
+      const adapterRel = join2(`.${harness}`, kind, name);
+      if (await lstat(join2(repoDir, adapterRel)).catch(() => null)) {
+        throw new Error(`Adapter collision: ${adapterRel} already exists and is not managed by bearings`);
+      }
+    }
+  }
+}
+function actionPath(action) {
+  return action.kind === "keep" ? action.record.path : action.path;
+}
+async function planAdapterActions(input) {
+  const { repoDir, currentHarnesses, currentExposure, desiredHarnesses, desiredExposure, fileActions } = input;
+  const previousRootKeys = new Set((await canonicalAdapterEntries(repoDir)).keys());
+  const currentHarnessSet = new Set(currentHarnesses);
+  const desiredHarnessSet = new Set(desiredHarnesses);
+  const exposureChanged = currentExposure !== desiredExposure;
+  const desiredRootState = /* @__PURE__ */ new Map();
+  const affectedRootKeys = /* @__PURE__ */ new Set();
+  for (const action of fileActions) {
+    const root = parseAdapterRoot(actionPath(action));
+    if (!root) continue;
+    if (action.kind === "delete") {
+      if (!desiredRootState.has(root)) desiredRootState.set(root, false);
+    } else {
+      desiredRootState.set(root, true);
+    }
+    if (action.kind === "write" || action.kind === "merge" || action.kind === "delete") {
+      affectedRootKeys.add(root);
+    }
+  }
+  const desiredRootKeys = /* @__PURE__ */ new Set();
+  for (const [root, present] of desiredRootState) {
+    if (present) desiredRootKeys.add(root);
+  }
+  for (const root of previousRootKeys) {
+    if (desiredRootState.get(root) !== false) desiredRootKeys.add(root);
+  }
+  const actions = [];
+  for (const harness of currentHarnesses) {
+    if (desiredHarnessSet.has(harness)) continue;
+    for (const root of previousRootKeys) {
+      const [kind, name] = splitRoot(root);
+      const adapterRel = join2(`.${harness}`, kind, name);
+      if (await lstat(join2(repoDir, adapterRel)).catch(() => null)) {
+        actions.push({ kind: "remove", path: adapterRel });
+      }
+    }
+  }
+  for (const root of previousRootKeys) {
+    if (desiredRootKeys.has(root)) continue;
+    const [kind, name] = splitRoot(root);
+    for (const harness of currentHarnesses) {
+      if (!desiredHarnessSet.has(harness)) continue;
+      const adapterRel = join2(`.${harness}`, kind, name);
+      if (await lstat(join2(repoDir, adapterRel)).catch(() => null)) {
+        actions.push({ kind: "remove", path: adapterRel });
+      }
+    }
+  }
+  for (const root of desiredRootKeys) {
+    const [kind, name] = splitRoot(root);
+    const canonicalAbs = join2(repoDir, ".agents", kind, name);
+    const relTarget = join2("..", "..", ".agents", kind, name);
+    for (const harness of desiredHarnessSet) {
+      const adapterRel = join2(`.${harness}`, kind, name);
+      const adapterAbs = join2(repoDir, adapterRel);
+      const wasManagedBefore = currentHarnessSet.has(harness) && previousRootKeys.has(root);
+      const needsWrite = !wasManagedBefore || affectedRootKeys.has(root) || exposureChanged;
+      if (!needsWrite) continue;
+      if (!wasManagedBefore && await lstat(adapterAbs).catch(() => null)) {
+        throw new Error(`Adapter collision: ${adapterRel} already exists and is not managed by bearings`);
+      }
+      actions.push(
+        desiredExposure === "symlink" ? { kind: "write-symlink", path: adapterRel, target: relTarget } : { kind: "write-copy", path: adapterRel, source: canonicalAbs }
+      );
+    }
+  }
+  return actions;
+}
+
+// src/update/transaction.ts
+import { randomUUID } from "crypto";
+import { cp, lstat as lstat2, mkdir, readdir as readdir2, rename, rm, rmdir, symlink, writeFile } from "fs/promises";
+import { dirname, join as join3, relative, sep } from "path";
+var MANIFEST_RELATIVE = join3(".agents", "bearings.json");
+async function capture(repoDir, txDir, relativePath, snapshots) {
+  const target = join3(repoDir, relativePath);
+  const stat = await lstat2(target).catch(() => null);
+  if (!stat) {
+    snapshots.push({ target });
+    return;
+  }
+  const stored = join3(txDir, "snapshots", String(snapshots.length));
+  await mkdir(dirname(stored), { recursive: true });
+  await rename(target, stored);
+  snapshots.push({ target, stored });
+}
+async function captureToBackup(repoDir, relativePath, backupRelativePath, snapshots) {
+  const target = join3(repoDir, relativePath);
+  const stored = join3(repoDir, backupRelativePath);
+  await mkdir(dirname(stored), { recursive: true });
+  await rename(target, stored);
+  snapshots.push({ target, stored });
+}
+async function ensureDir(repoDir, absDir, createdDirs) {
+  const rel = relative(repoDir, absDir);
+  if (!rel || rel.startsWith("..")) return;
+  let current = repoDir;
+  for (const part of rel.split(sep)) {
+    current = join3(current, part);
+    const stat = await lstat2(current).catch(() => null);
+    if (!stat) {
+      await mkdir(current);
+      createdDirs.push(current);
+    }
+  }
+}
+async function restore(snapshots, hooks, txDir) {
+  for (const snapshot of [...snapshots].reverse()) {
+    try {
+      await hooks.beforeRollbackRestore?.(snapshot.target);
+      await rm(snapshot.target, { recursive: true, force: true });
+      if (snapshot.stored) {
+        await mkdir(dirname(snapshot.target), { recursive: true });
+        await rename(snapshot.stored, snapshot.target);
+      }
+    } catch (error) {
+      throw new Error(
+        `Rollback failed while restoring ${snapshot.target}; transaction data retained at ${txDir}. Underlying error: ${error.message}`
+      );
+    }
+  }
+}
+async function removeEmptyDirs(createdDirs) {
+  for (const dir of [...createdDirs].reverse()) {
+    try {
+      const entries = await readdir2(dir);
+      if (entries.length === 0) await rmdir(dir);
+    } catch {
+    }
+  }
+}
+async function applyUpdate(repoDir, plan, hooks = {}) {
+  const txDir = join3(repoDir, ".agents", `.bearings-txn-${randomUUID()}`);
+  const snapshots = [];
+  const createdDirs = [];
+  const abs = (relativePath) => join3(repoDir, relativePath);
+  let opIndex = 0;
+  const afterOp = async () => {
+    const current = opIndex;
+    opIndex += 1;
+    await hooks.afterOperation?.(current);
+  };
+  try {
+    for (const action of plan.files) {
+      if (action.kind === "write") {
+        await capture(repoDir, txDir, action.path, snapshots);
+        await ensureDir(repoDir, dirname(abs(action.path)), createdDirs);
+        await writeFile(abs(action.path), action.content);
+        await afterOp();
+      } else if (action.kind === "merge") {
+        await captureToBackup(repoDir, action.path, action.backup, snapshots);
+        await writeFile(abs(action.path), action.content);
+        await afterOp();
+      } else if (action.kind === "delete") {
+        await capture(repoDir, txDir, action.path, snapshots);
+        await afterOp();
+      }
+    }
+    for (const action of plan.adapters) {
+      if (action.kind === "write-symlink") {
+        await capture(repoDir, txDir, action.path, snapshots);
+        await ensureDir(repoDir, dirname(abs(action.path)), createdDirs);
+        await symlink(action.target, abs(action.path));
+        await afterOp();
+      } else if (action.kind === "write-copy") {
+        await capture(repoDir, txDir, action.path, snapshots);
+        await ensureDir(repoDir, dirname(abs(action.path)), createdDirs);
+        await cp(action.source, abs(action.path), { recursive: true });
+        await afterOp();
+      } else {
+        await capture(repoDir, txDir, action.path, snapshots);
+        await afterOp();
+      }
+    }
+    await capture(repoDir, txDir, MANIFEST_RELATIVE, snapshots);
+    await ensureDir(repoDir, dirname(abs(MANIFEST_RELATIVE)), createdDirs);
+    await writeFile(abs(MANIFEST_RELATIVE), JSON.stringify(plan.manifest, null, 2) + "\n");
+    await afterOp();
+  } catch (error) {
+    await restore(snapshots, hooks, txDir);
+    await removeEmptyDirs(createdDirs);
+    await rm(txDir, { recursive: true, force: true }).catch(() => {
+    });
+    throw error;
+  }
+  try {
+    await hooks.beforeCleanup?.();
+    await rm(txDir, { recursive: true, force: true });
+  } catch {
+  }
+}
+
+// src/update/prompts.ts
+function cancelUpdate(p) {
+  p.cancel("Init cancelled.");
+  throw new Error("Init cancelled.");
+}
+async function chooseConflict(p, action) {
+  const options = [
+    { value: "replace", label: "Replace", hint: "discard current content" },
+    { value: "merge", label: "Merge", hint: "back up current content for /setup-repo" },
+    ...action.canSkip ? [{ value: "skip", label: "Skip", hint: "decline this template revision" }] : []
+  ];
+  const selected = await p.select({
+    message: `${action.path}: incoming +${action.stats.added} -${action.stats.removed}`,
+    options
+  });
+  if (p.isCancel(selected)) cancelUpdate(p);
+  return { path: action.path, action: selected };
+}
+async function chooseRemovedConflict(p, action) {
+  const selected = await p.select({
+    message: `${action.path}: removed from the package but locally modified`,
+    options: [
+      { value: "remove", label: "Remove", hint: "delete the file" },
+      { value: "keep-untracked", label: "Keep and untrack", hint: "preserve the file, stop managing it" }
+    ]
+  });
+  if (p.isCancel(selected)) cancelUpdate(p);
+  return { path: action.path, action: selected };
+}
+async function confirmReconstructionConfig(p, detected, flags) {
+  let harnesses = flags.harnesses;
+  if (!harnesses) {
+    const selected = await p.multiselect({
+      message: `Detected harnesses [${detected.harnesses.join(", ") || "none"}] \u2014 confirm or correct.`,
+      options: [
+        { value: "claude", label: "Claude Code (.claude/)" },
+        { value: "opencode", label: "OpenCode (.opencode/)" }
+      ],
+      initialValues: detected.harnesses
+    });
+    if (p.isCancel(selected)) cancelUpdate(p);
+    harnesses = selected;
+  }
+  let exposure = flags.exposure;
+  if (!exposure) {
+    const selected = await p.select({
+      message: detected.mixed ? "Detected mixed exposure \u2014 choose one consistent mode." : `Detected ${detected.exposure} exposure \u2014 confirm or correct.`,
+      options: [
+        { value: "symlink", label: "Symlinks (recommended)" },
+        { value: "copy", label: "Copies (verify checks drift)" }
+      ],
+      initialValue: detected.exposure
+    });
+    if (p.isCancel(selected)) cancelUpdate(p);
+    exposure = selected;
+  }
+  return { harnesses, exposure };
+}
+async function confirmUpdatePlan(p, message) {
+  const selected = await p.confirm({ message });
+  if (p.isCancel(selected) || !selected) cancelUpdate(p);
+}
+
+// src/commands/update.ts
+async function runUpdate(repoDir, flags, version, state) {
+  if (!process.stdin.isTTY) {
+    throw new Error("Updating an initialized repository requires an interactive terminal.");
+  }
+  const migratedFromV1 = state.kind === "valid" && state.manifest.version === 1;
+  const current = state.kind === "valid" ? migratedFromV1 ? await migrateV1(repoDir, state.manifest) : state.manifest : null;
+  if (!migratedFromV1 && (current?.setupPending || current?.files.some((file) => file.reconciliations?.length))) {
+    throw new Error("Finish the pending /setup-repo handoff before running bearings init again.");
+  }
+  if (current && compareSemver(version, current.bearingsVersion) < 0) {
+    throw new Error(`Refusing to downgrade bearings from ${current.bearingsVersion} to ${version}.`);
+  }
+  const reconstruction = state.kind === "invalid";
+  const p = await import("@clack/prompts");
+  let harnesses;
+  let exposure;
+  let currentHarnesses;
+  let currentExposure;
+  if (reconstruction) {
+    const detected = await detectAdapterConfig(repoDir);
+    ({ harnesses, exposure } = await confirmReconstructionConfig(p, detected, {
+      harnesses: validateHarnesses(flags.harnesses),
+      exposure: flags.exposure
+    }));
+    currentHarnesses = detected.harnesses;
+    currentExposure = detected.exposure;
+  } else {
+    await preflightAdapters(repoDir, current);
+    harnesses = validateHarnesses(flags.harnesses) ?? current.harnesses;
+    exposure = flags.exposure === "copy" ? "copy" : current.exposure;
+    currentHarnesses = current.harnesses;
+    currentExposure = current.exposure;
+  }
+  await preflightAdapterCollisions({ repoDir, currentHarnesses, desiredHarnesses: harnesses, scaffold: SCAFFOLD });
+  const draft = await planFiles({
+    repoDir,
+    previous: current,
+    source: { bearingsVersion: version, scaffold: SCAFFOLD, templatesDir: templatesDir() },
+    reconstruction
+  });
+  const decisions = [];
+  for (const action of draft.actions) {
+    if (action.kind === "conflict") decisions.push(await chooseConflict(p, action));
+    else if (action.kind === "removed-conflict") decisions.push(await chooseRemovedConflict(p, action));
+  }
+  const resolved = await resolveFilePlan(repoDir, draft, decisions);
+  const adapterActions = await planAdapterActions({
+    repoDir,
+    currentHarnesses,
+    currentExposure,
+    desiredHarnesses: harnesses,
+    desiredExposure: exposure,
+    fileActions: resolved.actions
+  });
+  const harnessesUnchanged = current ? current.harnesses.length === harnesses.length && current.harnesses.every((h) => harnesses.includes(h)) : false;
+  const exposureUnchanged = current ? current.exposure === exposure : false;
+  const noArtifactChanges = resolved.actions.every((a) => a.kind === "keep") && adapterActions.length === 0;
+  const versionUnchanged = !!current && version === current.bearingsVersion;
+  if (!reconstruction && !migratedFromV1 && noArtifactChanges && versionUnchanged && harnessesUnchanged && exposureUnchanged) {
+    return { manifest: current, report: "bearings init: already up to date." };
+  }
+  const migratedAbsorbedBackup = migratedFromV1 && (current?.files.some((file) => file.reconciliations?.length) ?? false);
+  const setupRequired = resolved.setupRequired || adapterActions.length > 0 || migratedAbsorbedBackup;
+  const finalManifest = {
+    version: 2,
+    bearingsVersion: version,
+    harnesses,
+    exposure,
+    ...setupRequired ? {
+      setupPending: {
+        kind: reconstruction ? "reconstruction" : "update",
+        ...current ? { fromVersion: current.bearingsVersion } : {},
+        toVersion: version
+      }
+    } : {},
+    files: [...resolved.files]
+  };
+  const summaryInput = {
+    actions: resolved.actions,
+    adapterActions,
+    fromVersion: current?.bearingsVersion,
+    toVersion: version,
+    fromSchema: state.kind === "valid" ? state.manifest.version : void 0,
+    toSchema: 2,
+    reconstruction
+  };
+  await confirmUpdatePlan(p, renderUpdatePlan(summaryInput));
+  await applyUpdate(repoDir, { files: resolved.actions, adapters: adapterActions, manifest: finalManifest });
+  return { manifest: finalManifest, report: renderUpdateReport({ ...summaryInput, setupRequired }) };
+}
+export {
+  runUpdate
+};