bearings 0.5.3 → 0.5.4

package/dist/chunk-MOZJECCW.js

@@ -0,0 +1,1823 @@
+#!/usr/bin/env node
+
+// src/paths.ts
+import { fileURLToPath } from "url";
+import { dirname, join, sep } from "path";
+var CHECKLIST_PAYLOAD_PATH = ".agents/skills/checklist/previewer/data.generated.js";
+function isChecklistPayload(path) {
+  return path === CHECKLIST_PAYLOAD_PATH || path.endsWith(`${sep}${CHECKLIST_PAYLOAD_PATH.split("/").join(sep)}`);
+}
+function templatesDir() {
+  return join(dirname(fileURLToPath(import.meta.url)), "..", "templates");
+}
+var STARTER_SKILL_NAMES = [
+  "commit-convention",
+  "defer-work",
+  "resurface-deferred-work",
+  "recording-decisions"
+];
+var SKILLS = STARTER_SKILL_NAMES;
+var MANUAL_TESTPLAN_FILES = [
+  "SKILL.md"
+];
+var ORCHESTRATE_FILES = [
+  "SKILL.md"
+];
+var FORGE_A_SKILL_FILES = [
+  "SKILL.md",
+  "templates/guardrail.md",
+  "templates/probe-set.json"
+];
+var CHECKLIST_FILES = [
+  "SKILL.md",
+  "schema.reference.json",
+  "scripts/validate.mjs",
+  "scripts/build.mjs",
+  "previewer/index.html",
+  "previewer/viewer.css",
+  "previewer/viewer.js"
+];
+function starterSkillNameFromTarget(targetPath) {
+  return STARTER_SKILL_NAMES.find((skillName) => targetPath === `.agents/skills/${skillName}/SKILL.md`);
+}
+function isStarterSkillTarget(targetPath) {
+  return starterSkillNameFromTarget(targetPath) !== void 0;
+}
+function skillBaselinePath(skillName) {
+  return `.agents/.bearings-baseline/skills/${skillName}/SKILL.md`;
+}
+function skillIncomingPath(skillName) {
+  return `.agents/.bearings-incoming/skills/${skillName}/SKILL.md`;
+}
+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/update-bearings-setup.md", target: ".agents/commands/update-bearings-setup.md", owner: "bearings" },
+  ...SKILLS.map((skill) => ({
+    template: `agents/skills/${skill}/SKILL.md`,
+    target: `.agents/skills/${skill}/SKILL.md`,
+    owner: "bearings"
+  })),
+  ...MANUAL_TESTPLAN_FILES.map((file) => ({
+    template: `agents/skills/manual-testplan/${file}`,
+    target: `.agents/skills/manual-testplan/${file}`,
+    owner: "bearings"
+  })),
+  ...ORCHESTRATE_FILES.map((file) => ({
+    template: `agents/skills/orchestrate/${file}`,
+    target: `.agents/skills/orchestrate/${file}`,
+    owner: "bearings"
+  })),
+  ...FORGE_A_SKILL_FILES.map((file) => ({
+    template: `agents/skills/forge-a-skill/${file}`,
+    target: `.agents/skills/forge-a-skill/${file}`,
+    owner: "bearings"
+  })),
+  ...CHECKLIST_FILES.map((file) => ({
+    template: `agents/skills/checklist/${file}`,
+    target: `.agents/skills/checklist/${file}`,
+    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", "skill-update"];
+var SETUP_PENDING_KINDS = ["init", "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 || /[\\\x00-\x1f]/.test(value)) return false;
+  if (value.startsWith("/") || /^[A-Za-z]:\//.test(value) || 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", "update-merge", or "skill-update"`);
+  }
+  if (reason === "skill-update") {
+    const { basePath, incomingPath, baseHash } = value;
+    if (!isSafeManifestPath(basePath)) fail(`${context}.basePath is unsafe: ${String(basePath)}`);
+    if (!isSafeManifestPath(incomingPath)) fail(`${context}.incomingPath is unsafe: ${String(incomingPath)}`);
+    if (!isHash(baseHash)) fail(`${context}.baseHash must match sha256 format`);
+    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, basePath, incomingPath, baseHash, sourceHash, incomingTemplateVersion, incomingHash };
+  }
+  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, lastTemplateHash, 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 (lastTemplateHash !== void 0 && !isHash(lastTemplateHash)) {
+    fail(`${context}.lastTemplateHash must match sha256 format`);
+  }
+  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,
+    ...lastTemplateHash !== void 0 ? { lastTemplateHash } : {},
+    ...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 validateArtifacts(value, context) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value)) fail(`${context} must be an array`);
+  const artifacts = value.map((artifact, index) => {
+    const item = `${context}[${index}]`;
+    if (!isPlainObject(artifact) || !isSafeManifestPath(artifact.path)) fail(`${item}.path is unsafe`);
+    if (!isHash(artifact.hash)) fail(`${item}.hash is invalid`);
+    if (!["backup", "incoming", "base"].includes(String(artifact.kind))) fail(`${item}.kind is invalid`);
+    return { path: artifact.path, hash: artifact.hash, kind: artifact.kind };
+  });
+  assertUniquePaths(artifacts.map((artifact) => artifact.path));
+  return artifacts;
+}
+function validateTaskValidation(value, context) {
+  if (value === void 0) return void 0;
+  if (!isPlainObject(value)) fail(`${context} must be an object`);
+  if (value.kind !== "checklist-repair") fail(`${context}.kind is invalid`);
+  if (!isSafeManifestPath(value.source)) fail(`${context}.source is unsafe`);
+  return { kind: value.kind, source: value.source };
+}
+function validateTask(value, context) {
+  if (!isPlainObject(value) || !isSafeManifestPath(value.path)) fail(`${context} path is unsafe`);
+  if (!["tailor", "map", "reconcile"].includes(String(value.reason))) fail(`${context} reason is invalid`);
+  let acknowledged;
+  if (value.acknowledged !== void 0) {
+    if (!isPlainObject(value.acknowledged)) fail(`${context}.acknowledged must be an object`);
+    const artifacts = validateArtifacts(value.acknowledged.artifacts, `${context}.acknowledged.artifacts`);
+    const decision = value.acknowledged.decision;
+    if (decision !== void 0 && decision !== "keep-local" && decision !== "discard") fail(`${context}.acknowledged.decision is invalid`);
+    const validation = validateTaskValidation(value.acknowledged.validation, `${context}.acknowledged.validation`);
+    acknowledged = {
+      ...artifacts ? { artifacts } : {},
+      ...decision ? { decision } : {},
+      ...validation ? { validation } : {}
+    };
+    if (!acknowledged.artifacts?.length && !acknowledged.decision && !acknowledged.validation) {
+      fail(`${context}.acknowledged must record an artifact, decision, or validation`);
+    }
+  }
+  return {
+    path: value.path,
+    reason: value.reason,
+    ...acknowledged ? { acknowledged } : {}
+  };
+}
+function validateCompletedTask(value, context) {
+  if (!isPlainObject(value) || !isSafeManifestPath(value.path)) fail(`${context} path is unsafe`);
+  if (!["tailor", "map", "reconcile"].includes(String(value.reason))) fail(`${context} reason is invalid`);
+  const { outputHash, decision } = value;
+  if (outputHash !== void 0 && !isHash(outputHash)) fail(`${context}.outputHash is invalid`);
+  if (decision !== void 0 && decision !== "keep-local" && decision !== "discard") fail(`${context}.decision is invalid`);
+  if (decision === "discard" ? outputHash !== void 0 : outputHash === void 0) {
+    fail(`${context} must record either outputHash or discard`);
+  }
+  const artifacts = validateArtifacts(value.artifacts, `${context}.artifacts`);
+  const validation = validateTaskValidation(value.validation, `${context}.validation`);
+  return {
+    path: value.path,
+    reason: value.reason,
+    ...outputHash ? { outputHash } : {},
+    ...decision ? { decision } : {},
+    ...artifacts?.length ? { artifacts } : {},
+    ...validation ? { validation } : {}
+  };
+}
+function validateSetupHeader(value, context) {
+  const { kind, fromVersion, toVersion } = value;
+  if (typeof kind !== "string" || !SETUP_PENDING_KINDS.includes(kind)) {
+    fail(`${context}.kind must be "init", "update", or "reconstruction"`);
+  }
+  if (fromVersion !== void 0 && !isNonEmptyString(fromVersion)) fail(`${context}.fromVersion must be a string`);
+  if (!isNonEmptyString(toVersion)) fail(`${context}.toVersion must be a string`);
+  return { kind, ...fromVersion !== void 0 ? { fromVersion } : {}, toVersion };
+}
+function validateSetupPending(value) {
+  if (!isPlainObject(value)) fail("setupPending must be an object");
+  const header = validateSetupHeader(value, "setupPending");
+  const { tasks, completedTasks, protectedSkills } = value;
+  let normalizedTasks;
+  if (tasks !== void 0) {
+    if (!Array.isArray(tasks)) fail("setupPending.tasks must be an array");
+    normalizedTasks = tasks.map((task, index) => validateTask(task, `setupPending.tasks[${index}]`));
+    assertUniquePaths(normalizedTasks.map((task) => task.path));
+  }
+  let normalizedCompleted;
+  if (completedTasks !== void 0) {
+    if (!Array.isArray(completedTasks)) fail("setupPending.completedTasks must be an array");
+    normalizedCompleted = completedTasks.map((task, index) => validateCompletedTask(task, `setupPending.completedTasks[${index}]`));
+    assertUniquePaths(normalizedCompleted.map((task) => task.path));
+    if (normalizedCompleted.some((task) => normalizedTasks?.some((pending) => pending.path === task.path))) {
+      fail("setup task cannot also be completed");
+    }
+  }
+  let normalizedProtected;
+  if (protectedSkills !== void 0) {
+    if (!Array.isArray(protectedSkills)) fail("setupPending.protectedSkills must be an array");
+    normalizedProtected = protectedSkills.map((file) => {
+      if (!isPlainObject(file) || !isSafeManifestPath(file.path) || !file.path.startsWith(".agents/skills/")) {
+        fail("setupPending.protectedSkills path is unsafe");
+      }
+      if (!isHash(file.hash)) fail("setupPending.protectedSkills hash is invalid");
+      if (normalizedTasks?.some((task) => task.path === file.path)) fail("protected skill is also a setup task");
+      return { path: file.path, hash: file.hash };
+    });
+    assertUniquePaths(normalizedProtected.map((file) => file.path));
+  }
+  return {
+    ...header,
+    ...normalizedTasks ? { tasks: normalizedTasks } : {},
+    ...normalizedCompleted ? { completedTasks: normalizedCompleted } : {},
+    ...normalizedProtected ? { protectedSkills: normalizedProtected } : {}
+  };
+}
+function validateCompletedSetup(value) {
+  if (!isPlainObject(value)) fail("completedSetup must be an object");
+  const header = validateSetupHeader(value, "completedSetup");
+  if (!Array.isArray(value.tasks) || value.tasks.length === 0) fail("completedSetup.tasks must be a non-empty array");
+  const tasks = value.tasks.map((task, index) => validateCompletedTask(task, `completedSetup.tasks[${index}]`));
+  assertUniquePaths(tasks.map((task) => task.path));
+  return { ...header, tasks };
+}
+function validateMigrationReconciliation(value, index) {
+  const context = `migrationReconciliations[${index}]`;
+  if (!isPlainObject(value)) fail(`${context} must be an object`);
+  const { kind, source, target, backup, sourceHash, incomingHash } = value;
+  if (kind !== "testplan-collision" && kind !== "invalid-testplan") {
+    fail(`${context}.kind must be "testplan-collision" or "invalid-testplan"`);
+  }
+  if (!isSafeManifestPath(source)) fail(`${context}.source is unsafe: ${String(source)}`);
+  if (!isSafeManifestPath(backup)) fail(`${context}.backup is unsafe: ${String(backup)}`);
+  if (!isHash(sourceHash)) fail(`${context}.sourceHash must match sha256 format`);
+  if (kind === "testplan-collision") {
+    if (!isSafeManifestPath(target)) fail(`${context}.target is unsafe: ${String(target)}`);
+    if (!isHash(incomingHash)) fail(`${context}.incomingHash must match sha256 format`);
+    return { kind, source, target, backup, sourceHash, incomingHash };
+  }
+  if (target !== void 0 && !isSafeManifestPath(target)) fail(`${context}.target is unsafe: ${String(target)}`);
+  return { kind, source, ...target !== void 0 ? { target } : {}, backup, sourceHash };
+}
+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, completedSetup, migrationReconciliations } = raw;
+    if (setupPending !== void 0 && completedSetup !== void 0) fail("setupPending and completedSetup cannot coexist");
+    if (migrationReconciliations !== void 0 && !Array.isArray(migrationReconciliations)) {
+      fail("migrationReconciliations must be an array");
+    }
+    return {
+      version: 2,
+      bearingsVersion,
+      harnesses,
+      exposure,
+      ...setupPending !== void 0 ? { setupPending: validateSetupPending(setupPending) } : {},
+      ...completedSetup !== void 0 ? { completedSetup: validateCompletedSetup(completedSetup) } : {},
+      ...migrationReconciliations !== void 0 ? {
+        migrationReconciliations: migrationReconciliations.map(validateMigrationReconciliation)
+      } : {},
+      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 requireValidManifest(repoDir) {
+  const state = await inspectManifest(repoDir);
+  if (state.kind === "absent") fail("No bearings manifest found.");
+  if (state.kind === "invalid") fail(`Invalid manifest: ${state.message}`);
+  return state.manifest;
+}
+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/setup-journal.ts
+import { lstat as lstat3, readFile as readFile3, readdir as readdir2, realpath, stat as stat2 } from "fs/promises";
+import { join as join5 } from "path";
+import { isDeepStrictEqual } from "util";
+
+// src/setup-checklist-repair.ts
+import { lstat } from "fs/promises";
+import { join as join3 } from "path";
+import { pathToFileURL } from "url";
+async function validateChecklistRepair(repoDir, target, validation, content) {
+  const validator = await import(pathToFileURL(join3(templatesDir(), "agents/skills/checklist/scripts/validate.mjs")).href);
+  let result;
+  try {
+    result = validator.validateChecklist(JSON.parse(content));
+  } catch {
+    throw new Error(`Invalid repaired checklist ${target}: invalid JSON`);
+  }
+  if (result.length) throw new Error(`Invalid repaired checklist ${target}: ${result.join("; ")}`);
+  if (await lstat(join3(repoDir, validation.source)).catch(() => null)) {
+    throw new Error(`Legacy source still needs resolution: ${validation.source}. Preserve its content in ${target}, then remove the resolved source.`);
+  }
+}
+
+// src/verifier.ts
+import { access as access2, lstat as lstat2, readFile as readFile2, readdir, readlink, stat } from "fs/promises";
+import { dirname as dirname2, join as join4, resolve } from "path";
+var KINDS = ["skills", "commands"];
+var PLACEHOLDER = /<agent:[^>\n]*>/;
+async function exists(p) {
+  try {
+    await access2(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function verify(repoDir) {
+  const failures = [];
+  const warnings = [];
+  const missingSkillBaselines = /* @__PURE__ */ new Set();
+  async function warnMissingSkillBaseline(baseline) {
+    if (missingSkillBaselines.has(baseline) || await exists(join4(repoDir, baseline))) return;
+    missingSkillBaselines.add(baseline);
+    warnings.push({ code: "missing-skill-baseline", path: baseline, message: "use /update-bearings-setup for a scoped skill baseline repair" });
+  }
+  const state = await inspectManifest(repoDir);
+  if (state.kind === "absent") {
+    return { failures: [{ code: "no-manifest", path: ".agents/bearings.json", message: "run bearings init first" }], warnings };
+  }
+  if (state.kind === "invalid") {
+    return { failures: [{ code: "invalid-manifest", path: ".agents/bearings.json", message: state.message }], warnings };
+  }
+  const m = state.manifest;
+  const setup = m.version === 2 && m.setupPending?.kind === "init" ? "bearings init" : "/update-bearings-setup";
+  if ("setupPending" in m && m.setupPending) {
+    warnings.push({ code: "setup-pending", path: ".agents/bearings.json", message: `run bearings init to resume pending setup${m.setupPending.tasks?.length ? ": " + m.setupPending.tasks.map((task) => task.path).join(", ") : ""}` });
+  }
+  for (const f of m.files) {
+    const retired = "retired" in f && f.retired === true;
+    if (!retired) {
+      const abs = join4(repoDir, f.path);
+      if (!await exists(abs)) {
+        failures.push({ code: "missing-file", path: f.path, message: "managed file deleted" });
+      } else {
+        const content = await readFile2(abs, "utf8");
+        if ((f.owner === "agent" || isStarterSkillTarget(f.path)) && PLACEHOLDER.test(content)) {
+          warnings.push({ code: "unfilled-placeholder", path: f.path, message: `fill through ${setup} when this path is in scope` });
+        }
+      }
+    }
+    if (!retired && f.owner === "agent" && isStarterSkillTarget(f.path)) {
+      const skillName = starterSkillNameFromTarget(f.path);
+      await warnMissingSkillBaseline(skillBaselinePath(skillName));
+    }
+    if ("backup" in f && f.backup && await exists(join4(repoDir, f.backup))) {
+      warnings.push({ code: "unreviewed-backup", path: f.backup, message: `review during ${setup}; completion CLI handles cleanup` });
+    }
+    if ("reconciliations" in f && f.reconciliations) {
+      for (const r of f.reconciliations) {
+        if (r.reason === "skill-update") await warnMissingSkillBaseline(r.basePath);
+        if (await exists(join4(repoDir, r.backup))) {
+          warnings.push({ code: "pending-reconciliation", path: r.backup, message: `review during ${setup}; completion CLI handles cleanup` });
+        }
+        if (r.reason === "skill-update" && await exists(join4(repoDir, r.incomingPath))) {
+          warnings.push({ code: "pending-reconciliation", path: r.incomingPath, message: `review during ${setup}; completion CLI handles cleanup` });
+        }
+      }
+    }
+  }
+  if ("migrationReconciliations" in m && m.migrationReconciliations) {
+    for (const reconciliation of m.migrationReconciliations) {
+      if (await exists(join4(repoDir, reconciliation.backup))) {
+        warnings.push({
+          code: "pending-reconciliation",
+          path: reconciliation.backup,
+          message: reconciliation.kind === "invalid-testplan" ? "repair with the checklist skill during /update-bearings-setup; completion CLI handles cleanup" : "review during /update-bearings-setup; completion CLI handles cleanup"
+        });
+      }
+    }
+  }
+  for (const kind of KINDS) {
+    const srcDir = join4(repoDir, ".agents", kind);
+    let entries = [];
+    try {
+      entries = await readdir(srcDir);
+    } catch {
+    }
+    for (const h of m.harnesses) {
+      for (const name of entries) {
+        const exposurePath = join4(`.${h}`, kind, name);
+        const dst = join4(repoDir, `.${h}`, kind, name);
+        const l = await lstat2(dst).catch(() => null);
+        if (!l) {
+          failures.push({ code: "missing-exposure", path: exposurePath, message: `not exposed to ${h}` });
+          continue;
+        }
+        if (l.isSymbolicLink()) {
+          if (!await stat(dst).catch(() => null)) {
+            failures.push({ code: "broken-symlink", path: exposurePath, message: "symlink target missing" });
+          } else {
+            const target = await readlink(dst);
+            if (resolve(dirname2(dst), target) !== resolve(srcDir, name)) {
+              failures.push({ code: "missing-exposure", path: exposurePath, message: `not exposed to ${h}` });
+            }
+          }
+        } else if (m.exposure === "symlink") {
+          failures.push({ code: "missing-exposure", path: exposurePath, message: `not exposed to ${h}` });
+        } else {
+          const src = join4(srcDir, name);
+          if (await copyDrifted(src, dst)) {
+            failures.push({ code: "copy-drift", path: exposurePath, message: "diverged from .agents source" });
+          }
+        }
+      }
+    }
+  }
+  return { failures, warnings };
+}
+async function copyDrifted(src, dst) {
+  const s = await stat(src);
+  if (s.isDirectory()) {
+    const [srcChildren, dstChildren] = (await Promise.all([
+      readdir(src),
+      readdir(dst).catch(() => null)
+    ])).map((names) => names?.filter((name) => !isChecklistPayload(join4(src, name))) ?? null);
+    if (srcChildren === null) return true;
+    if (dstChildren === null) return true;
+    const srcNames = new Set(srcChildren);
+    for (const child of dstChildren) {
+      if (!srcNames.has(child)) return true;
+    }
+    for (const child of srcChildren) {
+      if (await copyDrifted(join4(src, child), join4(dst, child))) return true;
+    }
+    return false;
+  }
+  const [a, b] = await Promise.all([
+    readFile2(src, "utf8"),
+    readFile2(dst, "utf8").catch(() => null)
+  ]);
+  return b === null || sha256(a) !== sha256(b);
+}
+
+// src/setup-journal.ts
+var C4_COMPONENT_PATH = "docs/diagrams/c4-component.puml";
+var MAP_PATHS = /* @__PURE__ */ new Set([
+  ...SCAFFOLD.filter((entry) => ["docs/DOMAIN.md", "docs/ARCHITECTURE.md", "docs/CODEBASE_MAP.md"].includes(entry.target)).map((entry) => entry.target),
+  C4_COMPONENT_PATH
+]);
+var OBSOLETE_SEED_SECTION = /^## (?:Setup Required|Pending bearings Setup)\s*$/m;
+function tailoringTask(file, content = "", initial = false) {
+  if (MAP_PATHS.has(file.path)) return { path: file.path, reason: "map" };
+  if (initial && file.path === "AGENTS.md" || (file.owner === "agent" || isStarterSkillTarget(file.path)) && PLACEHOLDER.test(content)) {
+    return { path: file.path, reason: "tailor" };
+  }
+}
+function migrationTarget(record) {
+  return record.target ?? `checklists/repairs/${sha256(JSON.stringify([record.source, record.sourceHash])).slice(7, 23)}.json`;
+}
+function reconciliationTasks(manifest) {
+  return uniqueSetupTasks([
+    ...manifest.files.filter((file) => file.reconciliations?.length).map((file) => ({ path: file.path, reason: "reconcile" })),
+    ...(manifest.migrationReconciliations ?? []).map((record) => ({ path: migrationTarget(record), reason: "reconcile" }))
+  ]);
+}
+function uniqueSetupTasks(tasks) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    if (MAP_PATHS.has(task.path)) byPath.set(task.path, { ...task, reason: "map" });
+    else if (!byPath.has(task.path) || task.reason === "reconcile") byPath.set(task.path, task);
+  }
+  return [...byPath.values()];
+}
+function isKnownSetupTask(task, manifest) {
+  return task.path === C4_COMPONENT_PATH && task.reason === "map" || manifest.files.some((file) => file.path === task.path) || manifest.migrationReconciliations?.some((record) => migrationTarget(record) === task.path) === true || task.acknowledged !== void 0;
+}
+async function skillFiles(repoDir, directory = ".agents/skills", ancestors = []) {
+  const paths = [];
+  const absolute = await realpath(join5(repoDir, directory)).catch((error) => {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  });
+  if (absolute === null) return paths;
+  if (ancestors.includes(absolute)) throw new Error(`Cyclic skill directory: ${directory}`);
+  for (const entry of await readdir2(join5(repoDir, directory), { withFileTypes: true }).catch((error) => {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  })) {
+    const path = `${directory}/${entry.name}`;
+    const directoryEntry = entry.isDirectory() || entry.isSymbolicLink() && (await stat2(join5(repoDir, path))).isDirectory();
+    if (directoryEntry) paths.push(...await skillFiles(repoDir, path, [...ancestors, absolute]));
+    else paths.push(path);
+  }
+  return paths;
+}
+async function protectSkills(repoDir, tasks, actions = [], artifacts = []) {
+  const scope = /* @__PURE__ */ new Set([...tasks.map((task) => task.path), ...artifacts]);
+  const hashes = /* @__PURE__ */ new Map();
+  for (const path of await skillFiles(repoDir)) {
+    if (!scope.has(path) && !isChecklistPayload(path)) hashes.set(path, sha256(await readFile3(join5(repoDir, path))));
+  }
+  for (const action of actions) {
+    if (action.kind === "keep" || !action.path.startsWith(".agents/skills/") || scope.has(action.path) || isChecklistPayload(action.path)) continue;
+    if (action.kind === "delete") hashes.delete(action.path);
+    else if (action.kind === "write" || action.kind === "merge") hashes.set(action.path, sha256(action.content));
+  }
+  return [...hashes].map(([path, hash]) => ({ path, hash }));
+}
+async function readSetupTaskContent(repoDir, task) {
+  const content = await readFile3(join5(repoDir, task.path), "utf8").catch((error) => {
+    if (error.code === "ENOENT") throw new Error(`Setup task file is missing: ${task.path}`);
+    throw error;
+  });
+  if (!content.trim() || PLACEHOLDER.test(content)) throw new Error(`Setup task still has unfilled content: ${task.path}`);
+  if (task.path === "AGENTS.md" && OBSOLETE_SEED_SECTION.test(content)) {
+    throw new Error("Remove the obsolete setup section from AGENTS.md before acknowledging setup.");
+  }
+  if (task.reason === "map") {
+    const marker = task.path === C4_COMPONENT_PATH ? /' repo-map-synced: [^<>\r\n]+\s*$/ : /<!-- repo-map-synced: [^<>\r\n]+ -->\s*$/;
+    if (!marker.test(content) || task.path === C4_COMPONENT_PATH && (!/^@startuml\b/m.test(content) || !/^@enduml\s*$/m.test(content))) {
+      throw new Error(`Setup map has an invalid sync-marker contract: ${task.path}`);
+    }
+  }
+  return content;
+}
+function acknowledgedTask(receipt) {
+  const artifacts = receipt.artifacts;
+  const { decision, validation } = receipt;
+  const acknowledged = artifacts?.length || decision || validation ? {
+    ...artifacts?.length ? { artifacts } : {},
+    ...decision ? { decision } : {},
+    ...validation ? { validation } : {}
+  } : void 0;
+  return { path: receipt.path, reason: receipt.reason, ...acknowledged ? { acknowledged } : {} };
+}
+async function checkpointIsCurrent(repoDir, task) {
+  try {
+    for (const artifact of task.artifacts ?? []) {
+      if (artifact.kind !== "base" && await lstat3(join5(repoDir, artifact.path)).catch(() => null)) return false;
+    }
+    if (task.decision === "discard") return true;
+    const content = await readSetupTaskContent(repoDir, task);
+    if (sha256(content) !== task.outputHash) return false;
+    if (task.validation) await validateChecklistRepair(repoDir, task.path, task.validation, content);
+    const starter = starterSkillNameFromTarget(task.path);
+    if (starter) {
+      const baseline = await readFile3(join5(repoDir, skillBaselinePath(starter)), "utf8").catch(() => null);
+      if (baseline !== content) return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function normalizeSetup(repoDir, manifest) {
+  const artifacts = new Set(setupArtifacts(manifest));
+  const seed = manifest.files.find((file) => file.path === "AGENTS.md" && !file.retired);
+  const seedContent = seed ? await readFile3(join5(repoDir, seed.path), "utf8").catch((error) => {
+    if (error.code === "ENOENT") return "";
+    throw error;
+  }) : "";
+  const legacyGate = OBSOLETE_SEED_SECTION.test(seedContent);
+  const gateTasks = legacyGate ? [{ path: "AGENTS.md", reason: "tailor" }] : [];
+  const priorCompleted = manifest.setupPending?.completedTasks ?? [];
+  const completed = [];
+  const requeued = [];
+  for (const task of priorCompleted) {
+    if (await checkpointIsCurrent(repoDir, task)) completed.push(task);
+    else requeued.push(acknowledgedTask(task));
+  }
+  let tasks;
+  if (manifest.setupPending?.tasks?.length || priorCompleted.length) {
+    tasks = uniqueSetupTasks([...manifest.setupPending?.tasks ?? [], ...requeued, ...gateTasks]);
+  } else {
+    tasks = [...reconciliationTasks(manifest), ...gateTasks];
+    for (const file of manifest.files) {
+      if (file.retired) continue;
+      const content = await readFile3(join5(repoDir, file.path), "utf8").catch((error) => {
+        if (error.code === "ENOENT") return "";
+        throw error;
+      });
+      const task = tailoringTask(file, content);
+      if (task && PLACEHOLDER.test(content)) tasks.push(task);
+    }
+    tasks = uniqueSetupTasks(tasks);
+  }
+  const next = { ...manifest };
+  if (tasks.length || completed.length) {
+    const taskPaths = new Set(tasks.map((task) => task.path));
+    const protectedSkills = manifest.setupPending?.protectedSkills?.filter((file) => !artifacts.has(file.path) && !isChecklistPayload(file.path) && !taskPaths.has(file.path));
+    const { completedTasks: _oldCompleted, ...pending } = manifest.setupPending ?? {
+      kind: legacyGate ? "init" : "update",
+      toVersion: manifest.bearingsVersion
+    };
+    next.setupPending = {
+      ...pending,
+      tasks,
+      ...completed.length ? { completedTasks: completed } : {},
+      ...protectedSkills ? { protectedSkills } : {
+        protectedSkills: await protectSkills(repoDir, tasks, [], [...artifacts])
+      }
+    };
+    delete next.completedSetup;
+  } else {
+    delete next.setupPending;
+  }
+  return isDeepStrictEqual(next, manifest) ? manifest : next;
+}
+function renderSetupScope(manifest) {
+  const pending = manifest.setupPending;
+  if (!pending) return "No pending setup tasks.";
+  const lines = [`Pending setup (${pending.kind}):`, ...(pending.tasks ?? []).map((task) => `  ${task.reason}: ${task.path}${task.acknowledged?.decision ? `; retained choice: ${task.acknowledged.decision}` : ""}`)];
+  if (pending.completedTasks?.length) lines.push("Completed checkpoints:", ...pending.completedTasks.map((task) => `  ${task.reason}: ${task.path} (${task.outputHash ?? "discarded"})`));
+  for (const file of manifest.files) {
+    for (const record of file.reconciliations ?? []) {
+      lines.push(`  ${file.path}: ${record.reason}; backup: ${record.backup}`);
+      if (record.reason === "skill-update") lines.push(`    base: ${record.basePath}; incoming: ${record.incomingPath}`);
+    }
+    if (file.retired) lines.push(`  Retired: ${file.path}. Ask the developer before selecting this path to discard its preserved reconciliation content; no live file is required.`);
+  }
+  for (const record of manifest.migrationReconciliations ?? []) {
+    lines.push(`  ${migrationTarget(record)}: ${record.kind}; source: ${record.source}; backup: ${record.backup}`);
+    lines.push("    Read any existing repair target before replacing it; resolve its content with the developer.");
+  }
+  lines.push(
+    "Checkpoint completed tasks: bearings init --complete-setup --setup-path <path...>",
+    "Omit --setup-path to acknowledge all remaining tasks. Unchecked outputs stay pending.",
+    "For a skill-update Keep local/decline choice, add --keep-local <path...>; otherwise completion accepts the incoming template lineage.",
+    "When the historical base is missing, offer Take new template, Keep local, or Freeform; do not fabricate a historical base."
+  );
+  if (pending.protectedSkills?.length) lines.push("Protected skills \u2014 preserve these files:", ...pending.protectedSkills.map((file) => `  ${file.path} (${file.hash})`));
+  return lines.join("\n");
+}
+function pendingSetupReport(manifest) {
+  const pending = manifest.setupPending;
+  if (!pending) return "No pending setup tasks.";
+  return [
+    `Pending setup (${pending.kind}):`,
+    ...(pending.tasks ?? []).map((task) => `  ${task.reason}: ${task.path}`),
+    "",
+    `Run bearings init to resume ${pending.kind === "init" ? "initial setup" : "/update-bearings-setup"}.`
+  ].join("\n");
+}
+function setupArtifacts(manifest) {
+  return [
+    ...manifest.files.flatMap((file) => (file.reconciliations ?? []).flatMap((record) => record.reason === "skill-update" ? [record.backup, record.incomingPath] : [record.backup])),
+    ...(manifest.migrationReconciliations ?? []).map((record) => record.backup)
+  ];
+}
+
+// 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 initial setup:`);
+    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}`)
+  );
+  if (m.version === 2 && m.setupPending) lines.push("", pendingSetupReport(m));
+  return lines.join("\n");
+}
+function categorizeActions(actions) {
+  const result = {
+    added: [],
+    restored: [],
+    replaced: [],
+    merged: [],
+    skillHandoffs: [],
+    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 === "skill-handoff") {
+      result.skillHandoffs.push(action.path);
+    } 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, "Skill handoff \u2192 /update-bearings-setup", categories.skillHandoffs);
+  pushSection(lines, "Skipped", categories.skipped);
+  pushSection(lines, "Removed", categories.removed);
+  pushSection(lines, "Kept and untracked", categories.keptUntracked);
+  pushMigrationSections(lines, input.migrationActions ?? []);
+  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, "Skill handoff \u2192 /update-bearings-setup", categories.skillHandoffs);
+  pushSection(lines, "Skipped", categories.skipped);
+  pushSection(lines, "Removed", categories.removed);
+  pushSection(lines, "Kept and untracked", categories.keptUntracked);
+  pushMigrationSections(lines, input.migrationActions ?? []);
+  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("", input.manifest ? pendingSetupReport(input.manifest) : "Run bearings init to resume /update-bearings-setup.");
+  } else {
+    lines.push("", "Finish by running: bearings verify");
+  }
+  return lines.join("\n");
+}
+function pushMigrationSections(lines, actions) {
+  pushSection(lines, "Migrated legacy test plans", actions.filter((action) => action.kind === "migrate-testplan").map((action) => `${action.source} -> ${action.target}`));
+  pushSection(lines, "Migration collisions backed up -> /update-bearings-setup", actions.flatMap((action) => action.kind === "migrate-testplan" && action.backup !== void 0 ? [`${action.target} -> ${action.backup}`] : []));
+  pushSection(lines, "Invalid legacy test plans preserved -> /update-bearings-setup", actions.filter((action) => action.kind === "preserve-invalid-testplan").map((action) => `${action.source} -> ${action.backup}`));
+  pushSection(lines, "Removed empty legacy plan directories", actions.filter((action) => action.kind === "remove-empty-testplan-dir").map((action) => action.path));
+}
+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/update/transaction.ts
+import { randomUUID } from "crypto";
+import { cp, lstat as lstat4, mkdir as mkdir3, readFile as readFile4, readdir as readdir3, rename, rm as rm2, rmdir, symlink, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname4, join as join7, relative, sep as sep2 } from "path";
+
+// src/backup-path.ts
+import { access as access3, mkdir as mkdir2, open, rm } from "fs/promises";
+import { dirname as dirname3, join as join6 } from "path";
+async function freeBackupPath(repoDir, target) {
+  let candidate = `${target}.bkp`;
+  for (let index = 1; await access3(join6(repoDir, candidate)).then(() => true, () => false); index++) {
+    candidate = `${target}.bkp.${index}`;
+  }
+  return candidate;
+}
+async function writeBackup(repoDir, target, content, options = {}) {
+  let candidate = options.path ?? `${target}.bkp`;
+  for (let index = 1; ; index++) {
+    await options.beforeCreate?.(candidate);
+    const absolute = join6(repoDir, candidate);
+    await mkdir2(dirname3(absolute), { recursive: true });
+    let handle;
+    try {
+      handle = await open(absolute, "wx");
+    } catch (error) {
+      if (!options.path && error.code === "EEXIST") {
+        candidate = `${target}.bkp.${index}`;
+        continue;
+      }
+      throw error;
+    }
+    try {
+      await handle.writeFile(content);
+      await handle.close();
+      return candidate;
+    } catch (error) {
+      await handle.close().catch(() => {
+      });
+      await rm(absolute, { force: true }).catch(() => {
+      });
+      throw error;
+    }
+  }
+}
+
+// src/update/transaction.ts
+var MANIFEST_RELATIVE = join7(".agents", "bearings.json");
+async function capture(repoDir, txDir, relativePath, snapshots) {
+  const target = join7(repoDir, relativePath);
+  const stat3 = await lstat4(target).catch(() => null);
+  if (!stat3) {
+    snapshots.push({ target });
+    return;
+  }
+  const stored = join7(txDir, "snapshots", String(snapshots.length));
+  await mkdir3(dirname4(stored), { recursive: true });
+  await rename(target, stored);
+  snapshots.push({ target, stored });
+}
+async function captureToBackup(repoDir, txDir, relativePath, backupRelativePath, snapshots) {
+  await capture(repoDir, txDir, relativePath, snapshots);
+  const sourceSnapshot = snapshots.at(-1);
+  if (!sourceSnapshot?.stored) throw new Error(`Cannot back up missing path: ${relativePath}`);
+  await writeBackup(repoDir, relativePath, await readFile4(sourceSnapshot.stored), { path: backupRelativePath });
+  snapshots.push({ target: join7(repoDir, backupRelativePath) });
+}
+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(sep2)) {
+    current = join7(current, part);
+    const stat3 = await lstat4(current).catch(() => null);
+    if (!stat3) {
+      await mkdir3(current);
+      createdDirs.push(current);
+    }
+  }
+}
+async function writeContent(repoDir, txDir, relativePath, content, snapshots, createdDirs) {
+  await capture(repoDir, txDir, relativePath, snapshots);
+  const target = join7(repoDir, relativePath);
+  await ensureDir(repoDir, dirname4(target), createdDirs);
+  await writeFile2(target, content);
+}
+async function restore(snapshots, hooks, txDir) {
+  for (const snapshot of [...snapshots].reverse()) {
+    try {
+      await hooks.beforeRollbackRestore?.(snapshot.target);
+      await rm2(snapshot.target, { recursive: true, force: true });
+      if (snapshot.stored) {
+        await mkdir3(dirname4(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 readdir3(dir);
+      if (entries.length === 0) await rmdir(dir);
+    } catch {
+    }
+  }
+}
+async function removeEmptyCanonicalParents(repoDir, paths) {
+  const skillsRoot = join7(repoDir, ".agents", "skills");
+  const candidates = /* @__PURE__ */ new Set();
+  for (const path of paths) {
+    let current = dirname4(join7(repoDir, path));
+    while (current.startsWith(`${skillsRoot}${sep2}`)) {
+      candidates.add(current);
+      current = dirname4(current);
+    }
+  }
+  for (const dir of [...candidates].sort((a, b) => b.length - a.length)) {
+    try {
+      await rmdir(dir);
+    } catch (error) {
+      const code = error.code;
+      if (code !== "ENOENT" && code !== "ENOTEMPTY") throw error;
+    }
+  }
+}
+async function applyUpdate(repoDir, plan, hooks = {}) {
+  const txDir = join7(repoDir, ".agents", `.bearings-txn-${randomUUID()}`);
+  const snapshots = [];
+  const createdDirs = [];
+  const abs = (relativePath) => join7(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 writeContent(repoDir, txDir, action.path, action.content, snapshots, createdDirs);
+        if (isStarterSkillTarget(action.path)) {
+          await writeContent(
+            repoDir,
+            txDir,
+            skillBaselinePath(starterSkillNameFromTarget(action.path)),
+            action.content,
+            snapshots,
+            createdDirs
+          );
+        }
+        await afterOp();
+      } else if (action.kind === "merge") {
+        await captureToBackup(repoDir, txDir, action.path, action.backup, snapshots);
+        await writeFile2(abs(action.path), action.content);
+        await afterOp();
+      } else if (action.kind === "skill-handoff") {
+        await writeBackup(repoDir, action.path, await readFile4(abs(action.path)), { path: action.backup });
+        snapshots.push({ target: abs(action.backup) });
+        await writeContent(repoDir, txDir, action.incomingPath, action.content, snapshots, createdDirs);
+        await afterOp();
+      } else if (action.kind === "delete") {
+        await capture(repoDir, txDir, action.path, snapshots);
+        await afterOp();
+      }
+    }
+    await removeEmptyCanonicalParents(
+      repoDir,
+      plan.files.filter((action) => action.kind === "delete").map((action) => action.path)
+    );
+    for (const action of plan.migrations ?? []) {
+      if (action.kind === "migrate-testplan") {
+        if (action.backup) await captureToBackup(repoDir, txDir, action.target, action.backup, snapshots);
+        else await capture(repoDir, txDir, action.target, snapshots);
+        await capture(repoDir, txDir, action.source, snapshots);
+        await ensureDir(repoDir, dirname4(abs(action.target)), createdDirs);
+        await writeFile2(abs(action.target), action.content);
+        await afterOp();
+      } else if (action.kind === "preserve-invalid-testplan") {
+        await captureToBackup(repoDir, txDir, action.source, action.backup, snapshots);
+        await afterOp();
+      } else {
+        const entries = await readdir3(abs(action.path));
+        if (entries.length === 0) 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, dirname4(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, dirname4(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, dirname4(abs(MANIFEST_RELATIVE)), createdDirs);
+    await writeFile2(abs(MANIFEST_RELATIVE), JSON.stringify(plan.manifest, null, 2) + "\n");
+    await afterOp();
+  } catch (error) {
+    await restore(snapshots, hooks, txDir);
+    await removeEmptyDirs(createdDirs);
+    await rm2(txDir, { recursive: true, force: true }).catch(() => {
+    });
+    throw error;
+  }
+  try {
+    await hooks.beforeCleanup?.();
+    await rm2(txDir, { recursive: true, force: true });
+  } catch {
+  }
+}
+
+// src/commands/init.ts
+import { lstat as lstat7, readFile as readFile8, readdir as readdir6 } from "fs/promises";
+import { join as join12 } from "path";
+
+// src/scanner.ts
+import { access as access4, symlink as symlink2, rm as rm3 } from "fs/promises";
+import { join as join8 } from "path";
+async function exists2(p) {
+  try {
+    await access4(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function scan(repoDir) {
+  const collisions = [];
+  for (const e of SCAFFOLD) if (await exists2(join8(repoDir, e.target))) collisions.push(e.target);
+  const harnessDirsPresent = [];
+  for (const h of ["claude", "opencode"])
+    if (await exists2(join8(repoDir, `.${h}`))) harnessDirsPresent.push(h);
+  let symlinksSupported = true;
+  const probe = join8(repoDir, ".bearings-symlink-probe");
+  try {
+    await symlink2(".", probe);
+    await rm3(probe);
+  } catch {
+    symlinksSupported = false;
+  }
+  return { collisions, harnessDirsPresent, symlinksSupported };
+}
+
+// src/generator.ts
+import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile3, access as access5 } from "fs/promises";
+import { dirname as dirname5, join as join9 } from "path";
+async function exists3(p) {
+  try {
+    await access5(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function generate(repoDir, bearingsVersion, hooks = {}) {
+  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 = join9(repoDir, entry.target);
+    const templateContent = await readFile5(join9(templatesDir(), entry.template), "utf8");
+    const priorEntry = prior?.files.find((f) => f.path === entry.target);
+    let backup;
+    let currentContent;
+    if (await exists3(abs)) {
+      const currentBytes = await readFile5(abs);
+      currentContent = currentBytes.toString("utf8");
+      if (priorEntry && sha256(currentContent) === priorEntry.hash) {
+        const skillName2 = starterSkillNameFromTarget(entry.target);
+        if (skillName2) {
+          const baseline = join9(repoDir, skillBaselinePath(skillName2));
+          if (!await exists3(baseline)) {
+            await mkdir4(dirname5(baseline), { recursive: true });
+            await writeFile3(baseline, currentContent);
+          }
+        }
+        result.skippedUnchanged.push(entry.target);
+        result.files.push(priorEntry);
+        continue;
+      }
+      backup = await writeBackup(repoDir, entry.target, currentBytes, {
+        beforeCreate: hooks.beforeBackupCreate
+      });
+      result.backedUp.push({ path: entry.target, backup });
+    }
+    await mkdir4(dirname5(abs), { recursive: true });
+    await writeFile3(abs, templateContent);
+    result.written.push(entry.target);
+    const incomingHash = sha256(templateContent);
+    const skillName = starterSkillNameFromTarget(entry.target);
+    if (skillName) {
+      const baseline = join9(repoDir, skillBaselinePath(skillName));
+      await mkdir4(dirname5(baseline), { recursive: true });
+      await writeFile3(baseline, 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,
+      ...isStarterSkillTarget(entry.target) ? { lastTemplateHash: incomingHash } : {},
+      ...reconciliation ? { reconciliations: [reconciliation] } : {}
+    });
+  }
+  return result;
+}
+
+// src/adapters.ts
+import { mkdir as mkdir5, readdir as readdir4, symlink as symlink3, lstat as lstat5, readlink as readlink2, rm as rm4, cp as cp2, readFile as readFile6 } from "fs/promises";
+import { join as join10 } from "path";
+var ADAPTER_KINDS = ["skills", "commands"];
+async function canonicalAdapterEntries(repoDir) {
+  const entries = /* @__PURE__ */ new Map();
+  for (const kind of ADAPTER_KINDS) {
+    const directory = join10(repoDir, ".agents", kind);
+    for (const name of await readdir4(directory).catch(() => [])) {
+      entries.set(`${kind}/${name}`, join10(directory, name));
+    }
+  }
+  return entries;
+}
+async function entriesMatch(src, dst) {
+  const srcStat = await lstat5(src).catch(() => null);
+  const dstStat = await lstat5(dst).catch(() => null);
+  if (!srcStat || !dstStat) return false;
+  if (srcStat.isSymbolicLink() || dstStat.isSymbolicLink()) {
+    return srcStat.isSymbolicLink() && dstStat.isSymbolicLink() && await readlink2(src) === await readlink2(dst);
+  }
+  if (srcStat.isDirectory() || dstStat.isDirectory()) {
+    if (!srcStat.isDirectory() || !dstStat.isDirectory()) return false;
+    const [srcEntries, dstEntries] = (await Promise.all([readdir4(src), readdir4(dst)])).map((names) => names.filter((name) => !isChecklistPayload(join10(src, name))));
+    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(join10(src, srcEntries[i]), join10(dst, dstEntries[i]))) return false;
+    }
+    return true;
+  }
+  if (srcStat.isFile() || dstStat.isFile()) {
+    return srcStat.isFile() && dstStat.isFile() && (await readFile6(src)).equals(await readFile6(dst));
+  }
+  return false;
+}
+async function expose(repoDir, harness, mode) {
+  const created = [];
+  for (const kind of ADAPTER_KINDS) {
+    const srcDir = join10(repoDir, ".agents", kind);
+    let entries;
+    try {
+      entries = await readdir4(srcDir);
+    } catch {
+      continue;
+    }
+    const dstDir = join10(repoDir, `.${harness}`, kind);
+    await mkdir5(dstDir, { recursive: true });
+    for (const name of entries) {
+      const dst = join10(dstDir, name);
+      const adapterPath = join10(`.${harness}`, kind, name);
+      const relTarget = join10("..", "..", ".agents", kind, name);
+      const stat3 = await lstat5(dst).catch(() => null);
+      if (mode === "symlink") {
+        if (stat3?.isSymbolicLink() && await readlink2(dst) === relTarget) continue;
+        if (stat3 && !stat3.isSymbolicLink()) throw new Error(`Refusing to replace existing adapter entry: ${adapterPath}`);
+        if (stat3) await rm4(dst, { recursive: true });
+        await symlink3(relTarget, dst);
+      } else {
+        const src = join10(srcDir, name);
+        if (stat3 && await entriesMatch(src, dst)) continue;
+        if (stat3 && !stat3.isSymbolicLink()) throw new Error(`Refusing to replace existing adapter entry: ${adapterPath}`);
+        if (stat3) await rm4(dst, { recursive: true });
+        await cp2(src, dst, { recursive: true });
+      }
+      created.push(adapterPath);
+    }
+  }
+  return created;
+}
+
+// src/setup-completion.ts
+import { lstat as lstat6, readFile as readFile7, readdir as readdir5, readlink as readlink3 } from "fs/promises";
+import { join as join11, resolve as resolve2 } from "path";
+import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
+async function validateProtectedSkills(repoDir, files) {
+  for (const file of files) {
+    if (isChecklistPayload(file.path)) continue;
+    const actual = await readFile7(join11(repoDir, file.path)).catch(() => null);
+    if (!actual || sha256(actual) !== file.hash) throw new Error(`Protected skill changed during setup: ${file.path}`);
+  }
+}
+function resolvedRecord(file, content, keepLocal) {
+  const { reconciliations, retired: _retired, ...resolved } = file;
+  if (isStarterSkillTarget(file.path)) {
+    const incoming = reconciliations?.findLast((record) => record.reason === "skill-update");
+    resolved.owner = "agent";
+    resolved.hash = sha256(content);
+    resolved.lastTemplateHash = keepLocal ? file.lastTemplateHash ?? file.hash : incoming?.incomingHash ?? file.lastTemplateHash ?? file.hash;
+    if (keepLocal && incoming) resolved.skippedTemplate = { templateVersion: incoming.incomingTemplateVersion, hash: incoming.incomingHash };
+    else if (!keepLocal) delete resolved.skippedTemplate;
+  }
+  return resolved;
+}
+function addArtifact(artifacts, artifact) {
+  const existing = artifacts.get(artifact.path);
+  if (existing && !isDeepStrictEqual2(existing, artifact)) throw new Error(`Conflicting setup artifact receipt: ${artifact.path}`);
+  artifacts.set(artifact.path, artifact);
+}
+async function requireArtifact(repoDir, artifact) {
+  const bytes = await readFile7(join11(repoDir, artifact.path)).catch((error) => {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  });
+  if (bytes === null) throw new Error(`Selected setup artifact is missing: ${artifact.path}`);
+  if (sha256(bytes) !== artifact.hash) throw new Error(`Selected setup artifact hash changed: ${artifact.path}`);
+}
+async function validateSelectedOutputs(repoDir, manifest, tasks, mode) {
+  const contents = /* @__PURE__ */ new Map();
+  const receipts = [];
+  for (const task of tasks) {
+    const file = manifest.files.find((entry) => entry.path === task.path);
+    const migration = manifest.migrationReconciliations?.find((record) => migrationTarget(record) === task.path);
+    if (!isKnownSetupTask(task, manifest) || task.reason === "reconcile" && !file?.reconciliations?.length && !migration && !task.acknowledged) {
+      throw new Error(`Setup task has no resolution record: ${task.path}`);
+    }
+    const expectedArtifacts = /* @__PURE__ */ new Map();
+    const migrationValidation = migration ? { kind: "checklist-repair", source: migration.source } : void 0;
+    if (task.acknowledged?.validation && migrationValidation && !isDeepStrictEqual2(task.acknowledged.validation, migrationValidation)) {
+      throw new Error(`Setup task has conflicting validation: ${task.path}`);
+    }
+    const validation = task.acknowledged?.validation ?? migrationValidation;
+    for (const artifact of task.acknowledged?.artifacts ?? []) addArtifact(expectedArtifacts, artifact);
+    for (const record of file?.reconciliations ?? []) {
+      addArtifact(expectedArtifacts, { path: record.backup, hash: record.sourceHash, kind: "backup" });
+      if (record.reason === "skill-update") {
+        addArtifact(expectedArtifacts, { path: record.incomingPath, hash: record.incomingHash, kind: "incoming" });
+        const base = { path: record.basePath, hash: record.baseHash, kind: "base" };
+        if (mode.kind === "before-cleanup") {
+          const exists4 = await lstat6(join11(repoDir, base.path)).catch(() => null);
+          if (exists4) addArtifact(expectedArtifacts, base);
+        } else {
+          const actualBase = mode.receipts.get(task.path)?.artifacts?.find((artifact) => artifact.kind === "base" && artifact.path === base.path);
+          if (actualBase) addArtifact(expectedArtifacts, base);
+        }
+      }
+    }
+    if (migration) addArtifact(expectedArtifacts, { path: migration.backup, hash: migration.sourceHash, kind: "backup" });
+    const suppliedReceipt = mode.kind === "after-cleanup" ? mode.receipts.get(task.path) : void 0;
+    const lockedReceipt = mode.kind === "after-cleanup" ? mode.locked.get(task.path) : void 0;
+    let content;
+    let discarded = false;
+    const retainedDiscard = task.acknowledged?.decision === "discard" || lockedReceipt?.decision === "discard" || mode.kind === "after-cleanup" && file?.retired && suppliedReceipt?.decision === "discard";
+    if (retainedDiscard) {
+      discarded = true;
+    } else if (file?.retired) {
+      content = await readFile7(join11(repoDir, task.path), "utf8").catch((error) => {
+        if (error.code === "ENOENT") return void 0;
+        throw error;
+      });
+      discarded = content === void 0;
+      if (content !== void 0) content = await readSetupTaskContent(repoDir, task);
+    } else {
+      content = await readSetupTaskContent(repoDir, task);
+    }
+    if (content !== void 0) contents.set(task.path, content);
+    if (validation) await validateChecklistRepair(repoDir, task.path, validation, content);
+    if (mode.kind === "before-cleanup") {
+      for (const artifact of expectedArtifacts.values()) {
+        const acknowledged = task.acknowledged?.artifacts?.some((prior) => prior.path === artifact.path);
+        if (!acknowledged) await requireArtifact(repoDir, artifact);
+        else if (artifact.kind !== "base" && await lstat6(join11(repoDir, artifact.path)).catch(() => null)) {
+          throw new Error(`Previously cleaned setup artifact returned: ${artifact.path}`);
+        }
+      }
+      const decision = discarded ? "discard" : mode.keepLocal.has(task.path) || task.acknowledged?.decision === "keep-local" ? "keep-local" : void 0;
+      receipts.push({
+        path: task.path,
+        reason: task.reason,
+        ...content === void 0 ? {} : { outputHash: sha256(content) },
+        ...decision ? { decision } : {},
+        ...expectedArtifacts.size ? { artifacts: [...expectedArtifacts.values()] } : {},
+        ...validation ? { validation } : {}
+      });
+      continue;
+    }
+    const receipt = suppliedReceipt;
+    if (!receipt) throw new Error(`Setup completion receipt is missing task: ${task.path}`);
+    const locked = mode.locked.get(task.path);
+    if (locked && !isDeepStrictEqual2(receipt, locked)) throw new Error(`Setup completion receipt changed a prior checkpoint: ${task.path}`);
+    if (discarded ? receipt.decision !== "discard" || receipt.outputHash !== void 0 : receipt.outputHash !== sha256(content)) {
+      throw new Error(`Setup completion receipt does not match output: ${task.path}`);
+    }
+    const actualArtifacts = new Map((receipt.artifacts ?? []).map((artifact) => [artifact.path, artifact]));
+    if (actualArtifacts.size !== expectedArtifacts.size || [...expectedArtifacts].some(([path, artifact]) => !isDeepStrictEqual2(actualArtifacts.get(path), artifact))) {
+      throw new Error(`Setup completion receipt does not match artifacts: ${task.path}`);
+    }
+    if (!isDeepStrictEqual2(receipt.validation, validation)) throw new Error(`Setup completion receipt does not match validation: ${task.path}`);
+    const expectedDecision = discarded ? "discard" : task.acknowledged?.decision === "keep-local" || file?.reconciliations?.some((record) => record.reason === "skill-update") && receipt.decision === "keep-local" ? receipt.decision : void 0;
+    if (receipt.decision !== expectedDecision) throw new Error(`Setup completion receipt has an invalid decision: ${task.path}`);
+    for (const artifact of receipt.artifacts ?? []) {
+      if (artifact.kind === "base") continue;
+      if (await lstat6(join11(repoDir, artifact.path)).catch(() => null)) throw new Error(`Setup artifact was not cleaned up: ${artifact.path}`);
+      if (!/^\.agents\/(skills|commands)\//.test(artifact.path)) continue;
+      for (const harness of manifest.harnesses) {
+        const adapter = artifact.path.replace(/^\.agents\//, `.${harness}/`);
+        if (await lstat6(join11(repoDir, adapter)).catch(() => null)) throw new Error(`Setup artifact exposure was not cleaned up: ${adapter}`);
+      }
+    }
+    receipts.push(receipt);
+  }
+  return { contents, receipts };
+}
+async function completeSetup(repoDir, options = {}) {
+  const loaded = await requireValidManifest(repoDir);
+  const manifest = await normalizeSetup(repoDir, loaded.version === 1 ? await migrateV1(repoDir, loaded) : loaded);
+  if (!manifest.setupPending) {
+    if (options.paths !== void 0 || options.keepLocal?.length) throw new Error("No current setup tasks to select.");
+    if (loaded.version === 2 && loaded.setupPending) {
+      await applyUpdate(repoDir, { files: [], adapters: [], manifest });
+    }
+    return { manifest, report: "bearings setup: already complete." };
+  }
+  const allTasks = manifest.setupPending.tasks ?? [];
+  if (!allTasks.length) throw new Error("Pending setup has no task scope. Resume bearings init first.");
+  const pendingScope = new Set(allTasks.map((task) => task.path));
+  const selected = options.paths ?? [...pendingScope];
+  if (!selected.length || new Set(selected).size !== selected.length || selected.some((path) => !pendingScope.has(path))) {
+    throw new Error("Select unique current setup task paths.");
+  }
+  const scope = new Set(selected);
+  const tasks = allTasks.filter((task) => scope.has(task.path));
+  const remaining = allTasks.filter((task) => !scope.has(task.path));
+  const keepLocal = new Set(options.keepLocal ?? []);
+  if (keepLocal.size !== (options.keepLocal?.length ?? 0) || [...keepLocal].some((path) => !scope.has(path) || !isStarterSkillTarget(path) || !tasks.find((task) => task.path === path && (task.acknowledged?.decision === "keep-local" || manifest.files.find((file) => file.path === path && !file.retired)?.reconciliations?.some((record) => record.reason === "skill-update"))))) {
+    throw new Error("--keep-local requires unique selected skill-update task paths.");
+  }
+  for (const task of reconciliationTasks(manifest)) {
+    if (!pendingScope.has(task.path)) throw new Error(`Reconciliation is outside setup scope: ${task.path}`);
+  }
+  const { contents, receipts } = await validateSelectedOutputs(repoDir, manifest, tasks, { kind: "before-cleanup", keepLocal });
+  await validateProtectedSkills(repoDir, manifest.setupPending.protectedSkills ?? []);
+  const writes = [];
+  const files = [];
+  const receiptsByPath = new Map(receipts.map((receipt) => [receipt.path, receipt]));
+  for (const file of manifest.files) {
+    if (!scope.has(file.path)) {
+      files.push(file);
+      continue;
+    }
+    for (const record of file.reconciliations ?? []) {
+      writes.push({ kind: "delete", path: record.backup, previous: file });
+      if (record.reason === "skill-update") writes.push({ kind: "delete", path: record.incomingPath, previous: file });
+    }
+    if (file.retired) continue;
+    const resolvedFile = resolvedRecord(file, contents.get(file.path), receiptsByPath.get(file.path)?.decision === "keep-local");
+    if (isStarterSkillTarget(file.path)) {
+      writes.push({ kind: "write", reason: "replace", path: skillBaselinePath(starterSkillNameFromTarget(file.path)), content: contents.get(file.path), record: resolvedFile });
+    }
+    files.push(resolvedFile);
+  }
+  for (const record of manifest.migrationReconciliations ?? []) {
+    if (scope.has(migrationTarget(record))) writes.push({ kind: "delete", path: record.backup, previous: manifest.files[0] });
+  }
+  const cleanup = new Set(writes.filter((action) => action.kind === "delete").map((action) => action.path));
+  const check = await verify(repoDir);
+  for (const issue of check.failures) {
+    const canonicalRoot = issue.path.replace(/^\.(claude|opencode)\//, ".agents/");
+    if (cleanup.has(canonicalRoot) && issue.code === "missing-exposure") continue;
+    const authorized = allTasks.filter((task) => task.path === canonicalRoot || task.path.startsWith(`${canonicalRoot}/`));
+    if (authorized.length && authorized.every((task) => !scope.has(task.path))) continue;
+    if (issue.code !== "copy-drift" || !authorized.length) throw new Error(`Setup validation failed: ${issue.path}: ${issue.message}`);
+    const compare = async (source, copy) => {
+      const relativePath = source.slice(resolve2(repoDir).length + 1);
+      if (isChecklistPayload(relativePath)) return;
+      if (pendingScope.has(relativePath) && !scope.has(relativePath)) return;
+      const sourceStat = await lstat6(source).catch(() => null);
+      const copyStat = await lstat6(copy).catch(() => null);
+      const file = manifest.files.find((entry) => entry.path === relativePath);
+      if (!sourceStat && file?.retired && scope.has(relativePath)) {
+        if (copyStat) {
+          if (!copyStat.isFile() || ![file.hash, ...(file.reconciliations ?? []).map((record) => record.sourceHash)].includes(sha256(await readFile7(copy)))) throw new Error(`Copy adapter drift: ${copy}`);
+          writes.push({ kind: "delete", path: copy.slice(resolve2(repoDir).length + 1), previous: file });
+        }
+        return;
+      }
+      if (!sourceStat || !copyStat || sourceStat.isSymbolicLink() || copyStat.isSymbolicLink()) throw new Error(`Copy adapter drift: ${copy}`);
+      if (sourceStat.isDirectory()) {
+        if (!copyStat.isDirectory()) throw new Error(`Copy adapter drift: ${copy}`);
+        const names = /* @__PURE__ */ new Set([...await readdir5(source), ...await readdir5(copy)]);
+        for (const name of names) await compare(join11(source, name), join11(copy, name));
+      } else if (!await entriesMatch(source, copy)) {
+        const handoff = file?.reconciliations?.findLast((record) => record.reason === "skill-update");
+        const expected = handoff?.sourceHash ?? file?.hash;
+        if (!pendingScope.has(relativePath) || sha256(await readFile7(copy)) !== expected) throw new Error(`Copy adapter drift: ${copy}`);
+        const path = copy.slice(resolve2(repoDir).length + 1);
+        if (scope.has(relativePath)) writes.push({ kind: "write", reason: "replace", path, content: contents.get(relativePath), record: file });
+      }
+    };
+    await compare(resolve2(repoDir, canonicalRoot), resolve2(repoDir, issue.path));
+  }
+  for (const action of [...writes]) {
+    if (action.kind !== "delete" || !/^\.agents\/(skills|commands)\//.test(action.path)) continue;
+    if (manifest.exposure === "symlink" && !action.path.startsWith(".agents/commands/")) continue;
+    for (const harness of manifest.harnesses) {
+      const path = action.path.replace(/^\.agents\//, `.${harness}/`);
+      const existing = await lstat6(join11(repoDir, path)).catch(() => null);
+      if (existing) {
+        const matches = manifest.exposure === "symlink" ? existing.isSymbolicLink() && await readlink3(join11(repoDir, path)) === join11("..", "..", action.path) : !existing.isSymbolicLink() && await entriesMatch(join11(repoDir, action.path), join11(repoDir, path));
+        if (!matches) throw new Error(`Artifact adapter drift: ${path}`);
+        writes.push({ kind: "delete", path, previous: action.previous });
+      }
+    }
+  }
+  const { setupPending: _pending, completedSetup: _oldReceipt, migrationReconciliations: _migrations, ...rest } = manifest;
+  const completed = { ...rest, files };
+  const migrations = manifest.migrationReconciliations?.filter((record) => !scope.has(migrationTarget(record)));
+  if (migrations?.length) completed.migrationReconciliations = migrations;
+  if (remaining.length) {
+    const removed = new Set(writes.filter((action) => action.kind === "delete").map((action) => action.path));
+    const protectedSkills = (manifest.setupPending.protectedSkills ?? []).filter((file) => !removed.has(file.path));
+    completed.setupPending = {
+      ...manifest.setupPending,
+      tasks: remaining,
+      completedTasks: [...manifest.setupPending.completedTasks ?? [], ...receipts],
+      protectedSkills
+    };
+  } else completed.completedSetup = {
+    kind: manifest.setupPending.kind,
+    ...manifest.setupPending.fromVersion ? { fromVersion: manifest.setupPending.fromVersion } : {},
+    toVersion: manifest.setupPending.toVersion,
+    tasks: [...manifest.setupPending.completedTasks ?? [], ...receipts]
+  };
+  await applyUpdate(repoDir, { files: writes, adapters: [], manifest: completed });
+  if (remaining.length) return { manifest: completed, report: `Checkpointed tasks (${tasks.length}):
+${tasks.map((task) => `  ${task.path}`).join("\n")}
+
+${pendingSetupReport(completed)}` };
+  return { manifest: completed, report: `bearings setup complete.
+Resolved tasks (${tasks.length}):
+${tasks.map((task) => `  ${task.path}`).join("\n")}
+Finish by running: bearings verify` };
+}
+async function verifySetupOutcome(repoDir, expected) {
+  const manifest = await requireValidManifest(repoDir);
+  if (manifest.version !== 2 || manifest.setupPending || manifest.migrationReconciliations?.length || manifest.files.some((file) => file.reconciliations?.length)) {
+    throw new Error("Setup outcome is still pending or has unresolved records.");
+  }
+  if (!manifest.completedSetup) throw new Error("Setup outcome has no durable completion receipt.");
+  if (manifest.bearingsVersion !== expected.bearingsVersion || manifest.exposure !== expected.exposure || !isDeepStrictEqual2(manifest.harnesses, expected.harnesses)) {
+    throw new Error("Setup outcome changed the expected manifest configuration.");
+  }
+  if (!expected.setupPending || !(expected.setupPending.tasks?.length || expected.setupPending.completedTasks?.length)) {
+    throw new Error("Expected setup journal has no task scope. Resume bearings init before launch.");
+  }
+  const tasks = expected.setupPending.tasks ?? [];
+  const completedTasks = expected.setupPending.completedTasks ?? [];
+  const allTasks = [
+    ...completedTasks.map(acknowledgedTask),
+    ...tasks
+  ];
+  const scope = new Set(tasks.map((task) => task.path));
+  for (const task of reconciliationTasks(expected)) {
+    if (!scope.has(task.path)) throw new Error(`Expected reconciliation is outside setup scope: ${task.path}`);
+  }
+  const artifacts = new Set(setupArtifacts(expected));
+  await validateProtectedSkills(repoDir, (expected.setupPending?.protectedSkills ?? []).filter((file) => !artifacts.has(file.path)));
+  const receipt = manifest.completedSetup;
+  if (receipt.kind !== expected.setupPending.kind || receipt.fromVersion !== expected.setupPending.fromVersion || receipt.toVersion !== expected.setupPending.toVersion) {
+    throw new Error("Setup completion receipt does not match the original setup journal.");
+  }
+  const receiptMap = new Map(receipt.tasks.map((task) => [task.path, task]));
+  if (receiptMap.size !== allTasks.length) throw new Error("Setup completion receipt does not match the original task scope.");
+  const { contents } = await validateSelectedOutputs(repoDir, expected, allTasks, {
+    kind: "after-cleanup",
+    receipts: receiptMap,
+    locked: new Map(completedTasks.map((task) => [task.path, task]))
+  });
+  for (const file of expected.files) {
+    const actual = manifest.files.find((record) => record.path === file.path);
+    if (scope.has(file.path) && file.retired) {
+      if (actual) throw new Error(`Retired setup record was not resolved: ${file.path}`);
+      continue;
+    }
+    if (!actual) throw new Error(`Setup outcome is missing its file record: ${file.path}`);
+    let required = file;
+    if (scope.has(file.path)) {
+      const declined = receiptMap.get(file.path)?.decision === "keep-local";
+      required = resolvedRecord(file, contents.get(file.path), declined);
+    }
+    if (!isDeepStrictEqual2(actual, required)) throw new Error(`Setup outcome has invalid claims or template lineage: ${file.path}`);
+  }
+  if (manifest.files.some((file) => !expected.files.some((record) => record.path === file.path))) throw new Error("Setup outcome added unexpected managed file records.");
+  for (const task of allTasks) {
+    if (!isStarterSkillTarget(task.path)) continue;
+    const baseline = skillBaselinePath(starterSkillNameFromTarget(task.path));
+    const bytes = await readFile7(join11(repoDir, baseline), "utf8").catch(() => null);
+    if (bytes !== contents.get(task.path)) throw new Error(`Setup skill baseline does not match live content: ${baseline}`);
+  }
+  const check = await verify(repoDir);
+  if (check.failures.length) throw new Error(`Setup outcome validation failed: ${check.failures.map((issue) => `${issue.path}: ${issue.message}`).join("; ")}`);
+  return manifest;
+}
+
+// src/commands/init.ts
+var VALID_HARNESSES = ["claude", "opencode"];
+var KINDS2 = ["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 KINDS2) {
+      const prefix = `.agents/${kind}/`;
+      if (entry.target.startsWith(prefix)) {
+        const name = entry.target.slice(prefix.length).split("/")[0];
+        sources[kind].set(name, join12(templatesDir(), "agents", kind, name));
+      }
+    }
+  }
+  for (const kind of KINDS2) {
+    const srcDir = join12(repoDir, ".agents", kind);
+    for (const name of await readdir6(srcDir).catch(() => [])) {
+      if (!sources[kind].has(name)) sources[kind].set(name, join12(srcDir, name));
+    }
+  }
+  return sources;
+}
+async function preflightAdapterCollisions(repoDir, harnesses, exposure) {
+  const sources = await plannedAdapterSources(repoDir);
+  for (const h of harnesses) {
+    for (const kind of KINDS2) {
+      for (const [name, source] of sources[kind]) {
+        const adapterPath = join12(`.${h}`, kind, name);
+        const target = join12(repoDir, adapterPath);
+        const stat3 = await lstat7(target).catch(() => null);
+        if (!stat3 || stat3.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
+  };
+  const tailored = (await Promise.all(gen.files.map(async (file) => tailoringTask(file, await readFile8(join12(repoDir, file.path), "utf8"), true)))).filter((task) => task !== void 0);
+  const seedAndMaps = tailored.filter((task) => task.path === "AGENTS.md" || task.reason === "map");
+  const starterTasks = tailored.filter((task) => task.path !== "AGENTS.md" && task.reason !== "map");
+  const tasks = uniqueSetupTasks([
+    ...seedAndMaps,
+    { path: C4_COMPONENT_PATH, reason: "map" },
+    ...starterTasks,
+    ...reconciliationTasks(manifest)
+  ]);
+  manifest.setupPending = { kind: "init", toVersion: version, tasks, protectedSkills: await protectSkills(repoDir, tasks, [], setupArtifacts(manifest)) };
+  await saveManifest(repoDir, manifest);
+  return { manifest, report: renderInitReport(gen, exposed, manifest) };
+}
+async function runInit(repoDir, flags, version) {
+  if (flags.completeSetup) return completeSetup(repoDir, { paths: flags.setupPaths, keepLocal: flags.keepLocal });
+  if (flags.keepLocal !== void 0 || flags.setupPaths !== void 0) throw new Error("--keep-local and --setup-path require --complete-setup.");
+  const state = await inspectManifest(repoDir);
+  if (state.kind === "absent") return runFreshInit(repoDir, flags, version);
+  const { runUpdate } = await import("./update-YY5SLPDF.js");
+  return runUpdate(repoDir, flags, version, state);
+}
+
+export {
+  isChecklistPayload,
+  templatesDir,
+  starterSkillNameFromTarget,
+  isStarterSkillTarget,
+  skillBaselinePath,
+  skillIncomingPath,
+  SCAFFOLD,
+  sha256,
+  saveManifest,
+  inspectManifest,
+  migrateV1,
+  freeBackupPath,
+  ADAPTER_KINDS,
+  canonicalAdapterEntries,
+  entriesMatch,
+  PLACEHOLDER,
+  verify,
+  tailoringTask,
+  reconciliationTasks,
+  uniqueSetupTasks,
+  protectSkills,
+  normalizeSetup,
+  renderSetupScope,
+  pendingSetupReport,
+  setupArtifacts,
+  renderUpdatePlan,
+  renderUpdateReport,
+  renderVerifyReport,
+  applyUpdate,
+  verifySetupOutcome,
+  validateHarnesses,
+  runInit
+};