codesteward 0.0.1

package/dist/main.js

@@ -0,0 +1,2711 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/main.ts
+var main_exports = {};
+__export(main_exports, {
+  bootstrapCommand: () => bootstrapCommand,
+  main: () => main,
+  runBootstrapCommand: () => runBootstrapCommand
+});
+module.exports = __toCommonJS(main_exports);
+var import_node_child_process = require("node:child_process");
+var fs6 = __toESM(require("node:fs/promises"));
+var path5 = __toESM(require("node:path"));
+
+// src/core/candidates.ts
+var fs4 = __toESM(require("node:fs/promises"));
+var path3 = __toESM(require("node:path"));
+
+// src/core/dr.ts
+var fs2 = __toESM(require("node:fs/promises"));
+var path2 = __toESM(require("node:path"));
+
+// src/core/store.ts
+var fs = __toESM(require("node:fs/promises"));
+var path = __toESM(require("node:path"));
+
+// src/core/harnesses.ts
+function selectedHarnessInstallers(options) {
+  const installers = [];
+  if (options.claude === true) {
+    installers.push(claudeInstaller);
+  }
+  if (options.codex === true) {
+    installers.push(codexInstaller);
+  }
+  return installers;
+}
+var claudeInstaller = {
+  name: "claude",
+  root: ".claude",
+  async install(context) {
+    await context.ensureManagedInstructions({
+      relativePath: ".claude/CLAUDE.md",
+      title: "Claude Code Instructions"
+    });
+    await context.ensureSkillTemplates({
+      root: ".claude",
+      preferredTemplateSet: "claude"
+    });
+  },
+  async update(context) {
+    await context.ensureManagedInstructions({
+      relativePath: ".claude/CLAUDE.md",
+      title: "Claude Code Instructions"
+    });
+    await context.updateSkillTemplates({
+      root: ".claude",
+      preferredTemplateSet: "claude"
+    });
+  }
+};
+var codexInstaller = {
+  name: "codex",
+  root: ".agents",
+  async install(context) {
+    await context.ensureManagedInstructions({
+      relativePath: "AGENTS.md",
+      title: "Agent Instructions"
+    });
+    await context.ensureSkillTemplates({
+      root: ".agents",
+      preferredTemplateSet: "codex"
+    });
+  },
+  async update(context) {
+    await context.ensureManagedInstructions({
+      relativePath: "AGENTS.md",
+      title: "Agent Instructions"
+    });
+    await context.updateSkillTemplates({
+      root: ".agents",
+      preferredTemplateSet: "codex"
+    });
+  }
+};
+
+// src/core/store.ts
+var storeDirectoryName = ".codesteward";
+var codestewardInstructionStartMarker = "<!-- codesteward:agent-instructions -->";
+var codestewardInstructionEndMarker = "<!-- /codesteward:agent-instructions -->";
+var legacyCodestewardInstructionStartMarker = "<!-- codesteward:correction-feedback-loop -->";
+var legacyCodestewardInstructionEndMarker = "<!-- /codesteward:correction-feedback-loop -->";
+var directoryLayout = [
+  "drs/candidates",
+  "drs/accepted",
+  "drs/rejected",
+  "drs/retired",
+  "sessions"
+];
+var skillTemplateFiles = [
+  "decision-aware-design/SKILL.md",
+  "decision-aware-implement/SKILL.md"
+];
+var decisionRecordStatuses = ["candidate", "accepted", "rejected", "retired"];
+function getStorePaths(projectRoot) {
+  const root = path.resolve(projectRoot);
+  const store = path.join(root, storeDirectoryName);
+  return {
+    root,
+    store,
+    config: path.join(store, "config.json"),
+    tags: path.join(store, "tags.md")
+  };
+}
+async function discoverStore(startDirectory) {
+  let current = path.resolve(startDirectory);
+  for (; ; ) {
+    const paths = getStorePaths(current);
+    if (await pathExists(paths.store)) {
+      return paths;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return void 0;
+    }
+    current = parent;
+  }
+}
+async function initStore(projectRoot, options = {}) {
+  const paths = getStorePaths(projectRoot);
+  const created = [];
+  const existing = [];
+  const updated = [];
+  await ensureDirectory(paths.store, created, existing, paths.root);
+  for (const relativeDirectory of directoryLayout) {
+    await ensureDirectory(path.join(paths.store, relativeDirectory), created, existing, paths.root);
+  }
+  await ensureFile(paths.config, defaultConfig(), created, existing, paths.root);
+  await ensureFile(paths.tags, defaultTags(), created, existing, paths.root);
+  const harnessInstallers = selectedHarnessInstallers(options);
+  const context = createHarnessInstallContext(paths, harnessInstallers, created, existing, updated);
+  for (const installer of harnessInstallers) {
+    await installer.install(context);
+  }
+  return { paths, created, existing, updated };
+}
+async function updateRuntimeAssets(projectRoot, options) {
+  const paths = getStorePaths(projectRoot);
+  const created = [];
+  const existing = [];
+  const updated = [];
+  const harnessInstallers = selectedHarnessInstallers(options);
+  const context = createHarnessInstallContext(paths, harnessInstallers, created, existing, updated);
+  for (const installer of harnessInstallers) {
+    await installer.update(context);
+  }
+  return { paths, created, existing, updated };
+}
+async function pathExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function countDecisionRecords(paths, status) {
+  const directory = decisionRecordDirectory(paths, status);
+  if (!await pathExists(directory)) {
+    return 0;
+  }
+  const entries = await fs.readdir(directory, { withFileTypes: true });
+  return entries.filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".md")).length;
+}
+function decisionRecordDirectory(paths, status) {
+  const directoryName = status === "candidate" ? "candidates" : status;
+  return path.join(paths.store, "drs", directoryName);
+}
+async function ensureDirectory(directoryPath, created, existing, projectRoot) {
+  if (await pathExists(directoryPath)) {
+    existing.push(formatRelative(projectRoot, directoryPath));
+    return;
+  }
+  await fs.mkdir(directoryPath, { recursive: true });
+  created.push(formatRelative(projectRoot, directoryPath));
+}
+async function ensureFile(filePath, contents, created, existing, projectRoot) {
+  if (await pathExists(filePath)) {
+    existing.push(formatRelative(projectRoot, filePath));
+    return;
+  }
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, contents, "utf8");
+  created.push(formatRelative(projectRoot, filePath));
+}
+function defaultConfig() {
+  return `${JSON.stringify({
+    version: 1,
+    store: storeDirectoryName
+  }, void 0, 2)}
+`;
+}
+function defaultTags() {
+  return [
+    "# CodeSteward Vocabulary",
+    "",
+    "Domains are broad applicability scopes. Use lowercase dot-separated hierarchy paths. A domain query matches ancestors, the exact domain, and descendants, but not sibling branches.",
+    "",
+    "Tags are concern filters used within matching domains. Apply every applicable tag when it helps retrieval; omit tags only when a DR should match every tag query in its domain.",
+    "",
+    "## Domains",
+    "",
+    "### all",
+    "",
+    "Global guidance that applies across the project.",
+    "",
+    "### cli",
+    "",
+    "Command-line behavior and CLI-owned workflows.",
+    "",
+    "## Tags",
+    "",
+    "### architecture",
+    "",
+    "Project-level architecture choices and system boundaries.",
+    ""
+  ].join("\n");
+}
+function createHarnessInstallContext(paths, harnessInstallers, created, existing, updated) {
+  const processedInstructionTargets = /* @__PURE__ */ new Set();
+  let sharedSkillTargets;
+  async function selectedSkillTemplateSet(input) {
+    sharedSkillTargets ??= selectedHarnessesShareSkillTargets(paths.root, harnessInstallers);
+    return await sharedSkillTargets ? "generic" : input.preferredTemplateSet;
+  }
+  return {
+    async ensureManagedInstructions(target) {
+      const rule = await renderTemplate("instructions/agent-instructions.md");
+      await ensureManagedInstructionBlock(
+        path.join(paths.root, target.relativePath),
+        target.title,
+        rule,
+        created,
+        existing,
+        updated,
+        paths.root,
+        processedInstructionTargets
+      );
+    },
+    async ensureSkillTemplates(input) {
+      const templateSet = await selectedSkillTemplateSet(input);
+      for (const asset of skillTemplateAssets(input.root, templateSet)) {
+        await ensureFile(path.join(paths.root, asset.relativePath), await renderTemplate(asset.templatePath), created, existing, paths.root);
+      }
+    },
+    async updateSkillTemplates(input) {
+      const templateSet = await selectedSkillTemplateSet(input);
+      for (const asset of skillTemplateAssets(input.root, templateSet)) {
+        await updateFile(path.join(paths.root, asset.relativePath), await renderTemplate(asset.templatePath), created, existing, updated, paths.root);
+      }
+    }
+  };
+}
+async function ensureManagedInstructionBlock(target, title, rule, created, existing, updated, projectRoot, processedTargets) {
+  if (!await pathExists(target)) {
+    await fs.mkdir(path.dirname(target), { recursive: true });
+    await fs.writeFile(target, `# ${title}
+
+${rule}`, "utf8");
+    processedTargets.add(await physicalPathIdentity(target));
+    created.push(formatRelative(projectRoot, target));
+    return;
+  }
+  const identity = await physicalPathIdentity(target);
+  if (processedTargets.has(identity)) {
+    const current2 = await fs.readFile(target, "utf8");
+    const repaired2 = repairManagedInstructionBlock(current2, rule);
+    if (repaired2 === current2) {
+      existing.push(formatRelative(projectRoot, target));
+      return;
+    }
+    await fs.writeFile(target, repaired2, "utf8");
+    updated.push(formatRelative(projectRoot, target));
+    return;
+  }
+  const current = await fs.readFile(target, "utf8");
+  const repaired = repairManagedInstructionBlock(current, rule);
+  if (repaired === current) {
+    processedTargets.add(identity);
+    existing.push(formatRelative(projectRoot, target));
+    return;
+  }
+  await fs.writeFile(target, repaired, "utf8");
+  processedTargets.add(await physicalPathIdentity(target));
+  updated.push(formatRelative(projectRoot, target));
+}
+function repairManagedInstructionBlock(current, rule) {
+  const marker = findManagedInstructionMarker(current);
+  const start = marker.start;
+  if (start === -1) {
+    const separator = current.endsWith("\n") ? "\n" : "\n\n";
+    return `${current}${separator}${rule}`;
+  }
+  const end = current.indexOf(marker.endMarker, start);
+  if (end === -1) {
+    return `${current.slice(0, start)}${rule}`;
+  }
+  const endAfterMarker = end + marker.endMarker.length;
+  const afterEnd = current.slice(endAfterMarker).startsWith("\n") ? current.slice(endAfterMarker + 1) : current.slice(endAfterMarker);
+  return `${current.slice(0, start)}${rule}${afterEnd}`;
+}
+function findManagedInstructionMarker(current) {
+  const start = current.indexOf(codestewardInstructionStartMarker);
+  if (start !== -1) {
+    return { start, endMarker: codestewardInstructionEndMarker };
+  }
+  return {
+    start: current.indexOf(legacyCodestewardInstructionStartMarker),
+    endMarker: legacyCodestewardInstructionEndMarker
+  };
+}
+async function selectedHarnessesShareSkillTargets(projectRoot, harnessInstallers) {
+  if (harnessInstallers.length < 2) {
+    return false;
+  }
+  for (const skillFile of skillTemplateFiles) {
+    const identities = /* @__PURE__ */ new Map();
+    for (const installer of harnessInstallers) {
+      const skillPath = path.join(projectRoot, installer.root, "skills", ...skillFile.split("/"));
+      const identity = await physicalPathIdentity(skillPath);
+      const existingRoot = identities.get(identity);
+      if (existingRoot !== void 0 && existingRoot !== installer.root) {
+        return true;
+      }
+      identities.set(identity, installer.root);
+    }
+  }
+  return false;
+}
+async function physicalPathIdentity(filePath) {
+  const missingParts = [];
+  let current = path.resolve(filePath);
+  for (; ; ) {
+    try {
+      return path.join(await fs.realpath(current), ...missingParts.reverse());
+    } catch (error) {
+      if (!isNodeError(error) || error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return path.resolve(filePath);
+    }
+    missingParts.push(path.basename(current));
+    current = parent;
+  }
+}
+async function updateFile(filePath, contents, created, existing, updated, projectRoot) {
+  if (!await pathExists(filePath)) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, contents, "utf8");
+    created.push(formatRelative(projectRoot, filePath));
+    return;
+  }
+  const current = await fs.readFile(filePath, "utf8");
+  if (current === contents) {
+    existing.push(formatRelative(projectRoot, filePath));
+    return;
+  }
+  await fs.writeFile(filePath, contents, "utf8");
+  updated.push(formatRelative(projectRoot, filePath));
+}
+function skillTemplateAssets(root, templateSet) {
+  return skillTemplateFiles.map((skillFile) => ({
+    relativePath: `${root}/skills/${skillFile}`,
+    templatePath: `skills/${templateSet}/${skillFile}`
+  }));
+}
+var templateIncludes = {
+  crHowTo: "include/crHowTo.md"
+};
+async function renderTemplate(relativePath, seen = []) {
+  if (seen.includes(relativePath)) {
+    throw new Error(`Circular CodeSteward template include: ${[...seen, relativePath].join(" -> ")}`);
+  }
+  let contents = await readTemplate(relativePath);
+  for (const [name, includePath] of Object.entries(templateIncludes)) {
+    const token = `{{${name}}}`;
+    if (contents.includes(token)) {
+      const include = (await renderTemplate(includePath, [...seen, relativePath])).trimEnd();
+      contents = contents.replaceAll(token, include);
+    }
+  }
+  return ensureTrailingNewline(contents);
+}
+async function readTemplate(relativePath) {
+  const errors = [];
+  for (const candidate of templatePathCandidates(relativePath)) {
+    try {
+      return await fs.readFile(candidate, "utf8");
+    } catch (error) {
+      if (isNodeError(error) && error.code === "ENOENT") {
+        errors.push(candidate);
+        continue;
+      }
+      throw error;
+    }
+  }
+  throw new Error(`CodeSteward template not found: ${relativePath} (searched ${errors.join(", ")})`);
+}
+function templatePathCandidates(relativePath) {
+  const parts = relativePath.split("/");
+  return [
+    path.join(__dirname, "templates", ...parts),
+    path.join(__dirname, "..", "src", "core", "templates", ...parts),
+    path.join(__dirname, "..", "..", "src", "core", "templates", ...parts)
+  ];
+}
+function ensureTrailingNewline(contents) {
+  return contents.endsWith("\n") ? contents : `${contents}
+`;
+}
+function formatRelative(projectRoot, targetPath) {
+  const relativePath = path.relative(projectRoot, targetPath);
+  return relativePath.length === 0 ? "." : relativePath.split(path.sep).join("/");
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/core/dr.ts
+var statusValues = new Set(decisionRecordStatuses);
+var drIdPattern = /^DR-\d{4}$/;
+var candidateIdPattern = /^CAND-\d{4}$/;
+var isoDatePattern = /^\d{4}-\d{2}-\d{2}$/;
+var domainPattern = /^(?:all|[a-z0-9]+(?:-[a-z0-9]+)*(?:\.[a-z0-9]+(?:-[a-z0-9]+)*)*)$/;
+async function readDecisionRecord(filePath, expectedStatus) {
+  const markdown = await fs2.readFile(filePath, "utf8");
+  return parseDecisionRecord(markdown, filePath, expectedStatus);
+}
+function parseDecisionRecord(markdown, filePath, expectedStatus) {
+  const frontmatterMatch = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)([\s\S]*)$/.exec(markdown);
+  if (frontmatterMatch === null) {
+    return {
+      filePath,
+      expectedStatus,
+      markdown,
+      frontmatter: {},
+      body: markdown,
+      sections: parseSections(markdown)
+    };
+  }
+  const [, frontmatterText, body] = frontmatterMatch;
+  return {
+    filePath,
+    expectedStatus,
+    markdown,
+    frontmatter: parseFrontmatter(frontmatterText),
+    body,
+    sections: parseSections(body)
+  };
+}
+async function listDecisionRecords(paths, status) {
+  const statuses = status === void 0 ? decisionRecordStatuses : [status];
+  const records = [];
+  for (const item of statuses) {
+    const directory = decisionRecordDirectory(paths, item);
+    const entries = await safeReadDirectory(directory);
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.toLowerCase().endsWith(".md")) {
+        continue;
+      }
+      records.push(await readDecisionRecord(path2.join(directory, entry.name), item));
+    }
+  }
+  return records.sort((left, right) => getRequiredString(left, "id").localeCompare(getRequiredString(right, "id")));
+}
+function validateDecisionRecord(record, vocabulary) {
+  const errors = [];
+  const warnings = [];
+  const frontmatter = record.frontmatter;
+  const status = getRequiredString(record, "status");
+  for (const field of ["id", "title", "status", "created"]) {
+    if (!hasFrontmatterValue(frontmatter, field)) {
+      errors.push(`Missing required field "${field}".`);
+    }
+  }
+  if (status.length > 0 && !statusValues.has(status)) {
+    errors.push(`Invalid status "${status}".`);
+  }
+  if (record.expectedStatus !== void 0 && status.length > 0 && record.expectedStatus !== status) {
+    errors.push(`Status "${status}" does not match ${record.expectedStatus} folder.`);
+  }
+  validateId(record, errors);
+  validateDate(record, "created", errors);
+  validateDate(record, "updated", errors);
+  validateBoolean(record, "enabled", errors);
+  validateDomain(record, vocabulary, errors, warnings);
+  validateTags(record, vocabulary, errors, warnings);
+  validateRemovedRetrievalFields(record, errors);
+  if (status === "accepted") {
+    for (const field of ["updated", "author"]) {
+      if (!hasFrontmatterValue(frontmatter, field)) {
+        errors.push(`Missing required accepted-DR field "${field}".`);
+      }
+    }
+    if (!record.sections.has("decision")) {
+      errors.push('Missing required "## Decision" section.');
+    }
+  }
+  return {
+    path: record.filePath,
+    errors,
+    warnings
+  };
+}
+function getRecordTags(record) {
+  return getStringList(record, "tags");
+}
+function getRecordId(record) {
+  return getRequiredString(record, "id");
+}
+function getRecordTitle(record) {
+  return getRequiredString(record, "title");
+}
+function getRecordStatus(record) {
+  return getRequiredString(record, "status");
+}
+function getRecordEnabled(record) {
+  return getOptionalString(record, "enabled") !== "false";
+}
+function getRecordDomain(record) {
+  return getOptionalString(record, "domain") ?? "all";
+}
+function getRecordReferences(record) {
+  return getStringList(record, "references");
+}
+function getRecordSection(record, title) {
+  return record.sections.get(sectionKey(title));
+}
+function getRecordDecision(record) {
+  return getRecordSection(record, "Decision") ?? "";
+}
+function isValidRecordDomain(domain) {
+  return domainPattern.test(domain);
+}
+function parseFrontmatter(frontmatter) {
+  const result = {};
+  const lines = frontmatter.split(/\r?\n/);
+  let currentListKey;
+  let currentObjectKey;
+  for (const line of lines) {
+    const listItem = /^\s*-\s*(.*?)\s*$/.exec(line);
+    if (listItem !== null && currentListKey !== void 0) {
+      const value2 = listItem[1];
+      result[currentListKey] = [...asStringList(result[currentListKey]), unquote(value2)];
+      continue;
+    }
+    const objectProperty = /^\s+([A-Za-z0-9_.-]+):\s*(.*?)\s*$/.exec(line);
+    if (objectProperty !== null && currentObjectKey !== void 0) {
+      const [, property, value2] = objectProperty;
+      result[currentObjectKey] = {
+        ...asStringRecord(result[currentObjectKey]),
+        [property]: unquote(value2)
+      };
+      continue;
+    }
+    const keyValue = /^([A-Za-z0-9_-]+):(?:\s*(.*?))?\s*$/.exec(line);
+    if (keyValue === null) {
+      currentListKey = void 0;
+      currentObjectKey = void 0;
+      continue;
+    }
+    const [, key, rawValue = ""] = keyValue;
+    const value = rawValue.trim();
+    if (value.length === 0) {
+      result[key] = [];
+      currentListKey = key;
+      currentObjectKey = key;
+    } else {
+      result[key] = unquote(value);
+      currentListKey = void 0;
+      currentObjectKey = void 0;
+    }
+  }
+  return result;
+}
+function parseSections(markdown) {
+  const sections = /* @__PURE__ */ new Map();
+  const lines = markdown.split(/\r?\n/);
+  let currentTitle;
+  let currentLines = [];
+  for (const line of lines) {
+    const heading = /^##\s+(.+?)\s*$/.exec(line);
+    if (heading !== null) {
+      if (currentTitle !== void 0) {
+        sections.set(sectionKey(currentTitle), currentLines.join("\n").trim());
+      }
+      currentTitle = heading[1];
+      currentLines = [];
+      continue;
+    }
+    if (currentTitle !== void 0) {
+      currentLines.push(line);
+    }
+  }
+  if (currentTitle !== void 0) {
+    sections.set(sectionKey(currentTitle), currentLines.join("\n").trim());
+  }
+  return sections;
+}
+async function safeReadDirectory(directory) {
+  try {
+    return await fs2.readdir(directory, { withFileTypes: true });
+  } catch (error) {
+    if (isNodeError2(error) && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+function validateId(record, errors) {
+  const id = getRequiredString(record, "id");
+  const status = getRequiredString(record, "status");
+  if (id.length === 0) {
+    return;
+  }
+  const allowed = status === "candidate" ? candidateIdPattern : status === "accepted" ? drIdPattern : /^(?:DR|CAND)-\d{4}$/;
+  if (!allowed.test(id)) {
+    errors.push(`Invalid id "${id}" for status "${status}".`);
+  }
+  if (!path2.basename(record.filePath).startsWith(id)) {
+    errors.push(`Filename must start with id "${id}".`);
+  }
+}
+function validateDate(record, field, errors) {
+  const value = getOptionalString(record, field);
+  if (value !== void 0 && !isoDatePattern.test(value)) {
+    errors.push(`Field "${field}" must use YYYY-MM-DD.`);
+  }
+}
+function validateBoolean(record, field, errors) {
+  const value = getOptionalString(record, field);
+  if (value !== void 0 && value !== "true" && value !== "false") {
+    errors.push(`Field "${field}" must be true or false.`);
+  }
+}
+function validateDomain(record, vocabulary, errors, warnings) {
+  if (Object.prototype.hasOwnProperty.call(record.frontmatter, "dimension")) {
+    errors.push('Field "dimension" is no longer supported; use "domain".');
+  }
+  if (!Object.prototype.hasOwnProperty.call(record.frontmatter, "domain")) {
+    return;
+  }
+  const value = record.frontmatter.domain;
+  if (typeof value !== "string" || value.length === 0) {
+    errors.push('Field "domain" must be a non-empty string.');
+    return;
+  }
+  if (!isValidRecordDomain(value)) {
+    errors.push('Field "domain" must be "all" or a lowercase dot-separated kebab-case path.');
+    return;
+  }
+  if (vocabulary.domains.length === 0) {
+    return;
+  }
+  const status = getRequiredString(record, "status");
+  const knownDomains = new Set(vocabulary.domains.map((domain) => domain.name));
+  knownDomains.add("all");
+  if (!knownDomains.has(value)) {
+    const message = `Unknown domain "${value}".`;
+    if (status === "candidate") {
+      warnings.push(message);
+    } else {
+      errors.push(message);
+    }
+  }
+}
+function validateTags(record, vocabulary, errors, warnings) {
+  const tags = getStringList(record, "tags");
+  const status = getRequiredString(record, "status");
+  const knownTags = new Set(vocabulary.tags.map((tag) => tag.name));
+  for (const tag of tags) {
+    if (!knownTags.has(tag)) {
+      const message = `Unknown tag "${tag}".`;
+      if (status === "candidate") {
+        warnings.push(message);
+      } else {
+        errors.push(message);
+      }
+    }
+  }
+}
+function validateRemovedRetrievalFields(record, errors) {
+  if (Object.prototype.hasOwnProperty.call(record.frontmatter, "summary")) {
+    errors.push('Field "summary" is no longer supported; short detail uses "title".');
+  }
+  if (Object.prototype.hasOwnProperty.call(record.frontmatter, "guidance")) {
+    errors.push('Field "guidance" is no longer supported; medium detail uses "## Decision".');
+  }
+}
+function getRequiredString(record, key) {
+  return getOptionalString(record, key) ?? "";
+}
+function getOptionalString(record, key) {
+  const value = record.frontmatter[key];
+  return typeof value === "string" ? value : void 0;
+}
+function getStringList(record, key) {
+  return asStringList(record.frontmatter[key]);
+}
+function hasFrontmatterValue(frontmatter, key) {
+  const value = frontmatter[key];
+  if (value === void 0) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.trim().length > 0;
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  return Object.keys(value).length > 0;
+}
+function asStringList(value) {
+  return Array.isArray(value) ? value.filter((item) => item.length > 0) : [];
+}
+function asStringRecord(value) {
+  return isStringRecord(value) ? value : {};
+}
+function isStringRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sectionKey(title) {
+  return title.trim().toLowerCase().replace(/\s+/g, "-");
+}
+function unquote(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function isNodeError2(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/core/tags.ts
+var fs3 = __toESM(require("node:fs/promises"));
+var tagNamePattern = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+var domainNamePattern = /^(?:all|[a-z][a-z0-9]*(?:-[a-z0-9]+)*(?:\.[a-z][a-z0-9]*(?:-[a-z0-9]+)*)*)$/;
+async function readTagVocabulary(tagsPath) {
+  const markdown = await fs3.readFile(tagsPath, "utf8");
+  return parseTagVocabulary(markdown);
+}
+async function acceptVocabularyProposals(tagsPath, proposals) {
+  const markdown = await fs3.readFile(tagsPath, "utf8");
+  const vocabulary = parseTagVocabulary(markdown);
+  let updated = markdown;
+  const knownDomains = new Set(vocabulary.domains.map((domain) => domain.name));
+  knownDomains.add("all");
+  const domainEntries = Object.entries(proposals.domains).filter(([name]) => !knownDomains.has(name)).map(([name, description]) => ({ name, description }));
+  updated = appendEntries(updated, "Domains", domainEntries);
+  const knownTags = new Set(vocabulary.tags.map((tag) => tag.name));
+  const tagEntries = Object.entries(proposals.tags).filter(([name]) => !knownTags.has(name)).map(([name, description]) => ({ name, description }));
+  updated = appendEntries(updated, "Tags", tagEntries);
+  const updatedVocabulary = parseTagVocabulary(updated);
+  if (updatedVocabulary.errors.length > 0) {
+    throw new Error(`Vocabulary proposals failed validation: ${updatedVocabulary.errors.join("; ")}`);
+  }
+  if (updated !== markdown) {
+    await fs3.writeFile(tagsPath, updated, "utf8");
+  }
+  return updatedVocabulary;
+}
+function parseTagVocabulary(markdown) {
+  return hasStructuredVocabulary(markdown) ? parseStructuredVocabulary(markdown) : parseLegacyTagVocabulary(markdown);
+}
+function parseStructuredVocabulary(markdown) {
+  const lines = markdown.split(/\r?\n/);
+  const domains = [];
+  const tags = [];
+  const errors = [];
+  let currentSection;
+  let current;
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    const sectionHeading = /^##\s+(.+?)\s*$/.exec(line);
+    if (sectionHeading !== null) {
+      finishCurrent(current, domains, tags);
+      current = void 0;
+      const section = sectionKey2(sectionHeading[1]);
+      currentSection = section === "domains" || section === "tags" ? section : void 0;
+      continue;
+    }
+    const entryHeading = /^###\s+(.+?)\s*$/.exec(line);
+    if (entryHeading !== null && currentSection !== void 0) {
+      finishCurrent(current, domains, tags);
+      const name = entryHeading[1].trim();
+      current = {
+        section: currentSection,
+        name,
+        line: index + 1,
+        descriptionLines: []
+      };
+      if (currentSection === "domains" && !domainNamePattern.test(name)) {
+        errors.push(`Invalid domain "${name}" at line ${index + 1}; use "all" or lowercase dot-separated kebab-case.`);
+      }
+      if (currentSection === "tags" && !tagNamePattern.test(name)) {
+        errors.push(`Invalid tag "${name}" at line ${index + 1}; use lowercase kebab-case.`);
+      }
+      continue;
+    }
+    if (current !== void 0) {
+      current.descriptionLines.push(line);
+    }
+  }
+  finishCurrent(current, domains, tags);
+  addDuplicateErrors(domains, "domain", errors);
+  addDuplicateErrors(tags, "tag", errors);
+  return { domains, tags, errors };
+}
+function parseLegacyTagVocabulary(markdown) {
+  const lines = markdown.split(/\r?\n/);
+  const tags = [];
+  const errors = [];
+  let current;
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    const heading = /^##\s+(.+?)\s*$/.exec(line);
+    if (heading !== null) {
+      finishCurrent(current, [], tags);
+      const name = heading[1].trim();
+      current = {
+        section: "tags",
+        name,
+        line: index + 1,
+        descriptionLines: []
+      };
+      if (!tagNamePattern.test(name)) {
+        errors.push(`Invalid tag "${name}" at line ${index + 1}; use lowercase kebab-case.`);
+      }
+      continue;
+    }
+    if (current !== void 0) {
+      current.descriptionLines.push(line);
+    }
+  }
+  finishCurrent(current, [], tags);
+  addDuplicateErrors(tags, "tag", errors);
+  return { domains: [], tags, errors };
+}
+function finishDefinition(definition) {
+  return {
+    name: definition.name,
+    description: definition.descriptionLines.join("\n").trim(),
+    line: definition.line
+  };
+}
+function finishCurrent(current, domains, tags) {
+  if (current === void 0) {
+    return;
+  }
+  if (current.section === "domains") {
+    domains.push(finishDefinition(current));
+    return;
+  }
+  tags.push(finishDefinition(current));
+}
+function addDuplicateErrors(definitions, label, errors) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const definition of definitions) {
+    if (seen.has(definition.name)) {
+      errors.push(`Duplicate ${label} "${definition.name}" at line ${definition.line}.`);
+    }
+    seen.add(definition.name);
+  }
+}
+function hasStructuredVocabulary(markdown) {
+  return /^##\s+(?:Domains|Tags)\s*$/im.test(markdown);
+}
+function appendEntries(markdown, sectionTitle, entries) {
+  if (entries.length === 0) {
+    return markdown;
+  }
+  const lines = markdown.trimEnd().split(/\r?\n/);
+  const sectionIndex = lines.findIndex((line) => sectionKey2(line.replace(/^##\s+/, "")) === sectionKey2(sectionTitle));
+  const rendered = entries.flatMap((entry) => [
+    `### ${entry.name}`,
+    "",
+    entry.description.trim().length === 0 ? `TODO: describe ${entry.name}.` : entry.description.trim(),
+    ""
+  ]);
+  if (sectionIndex === -1) {
+    return [
+      ...lines,
+      "",
+      `## ${sectionTitle}`,
+      "",
+      ...rendered
+    ].join("\n");
+  }
+  const nextSectionIndex = lines.findIndex((line, index) => index > sectionIndex && /^##\s+/.test(line));
+  const insertIndex = nextSectionIndex === -1 ? lines.length : nextSectionIndex;
+  const prefix = lines.slice(0, insertIndex);
+  const suffix = lines.slice(insertIndex);
+  return [
+    ...prefix,
+    ...prefix[prefix.length - 1]?.trim() === "" ? [] : [""],
+    ...rendered,
+    ...suffix
+  ].join("\n");
+}
+function sectionKey2(title) {
+  return title.trim().toLowerCase().replace(/\s+/g, "-");
+}
+
+// src/core/candidates.ts
+async function createCandidate(paths, vocabulary, input) {
+  const knownDomainNames = new Set(vocabulary.domains.map((domain) => domain.name));
+  knownDomainNames.add("all");
+  const knownTagNames = new Set(vocabulary.tags.map((tag) => tag.name));
+  const knownTags = input.tags.filter((tag) => knownTagNames.has(tag));
+  const proposedTags = input.tags.filter((tag) => !knownTagNames.has(tag));
+  const proposedDomains = knownDomainNames.has(input.domain) || vocabulary.domains.length === 0 ? [] : [input.domain];
+  const id = await nextRecordId(paths, "CAND");
+  const filePath = path3.join(decisionRecordDirectory(paths, "candidate"), `${id}-${slugify(input.title)}.md`);
+  const frontmatter = {
+    id,
+    title: input.title,
+    status: "candidate",
+    domain: input.domain,
+    created: input.created,
+    created_by: input.author,
+    tags: knownTags
+  };
+  if (proposedTags.length > 0) {
+    frontmatter.proposed_tags = Object.fromEntries(proposedTags.map((tag) => [
+      tag,
+      input.proposedTagDescriptions?.[tag] ?? `TODO: describe ${tag}.`
+    ]));
+  }
+  if (proposedDomains.length > 0) {
+    frontmatter.proposed_domains = {
+      [input.domain]: input.proposedDomainDescription ?? `TODO: describe ${input.domain}.`
+    };
+  }
+  if (input.affectedFiles.length > 0) {
+    frontmatter.affected_files = input.affectedFiles;
+  }
+  if (input.references.length > 0) {
+    frontmatter.references = input.references;
+  }
+  const markdown = [
+    renderFrontmatter(frontmatter),
+    "",
+    "## Decision",
+    "",
+    input.decision,
+    ...input.appendix === void 0 ? [] : ["", "## Appendix", "", input.appendix],
+    ""
+  ].join("\n");
+  await fs4.writeFile(filePath, markdown, "utf8");
+  return {
+    record: await readDecisionRecord(filePath, "candidate"),
+    knownTags,
+    proposedTags,
+    proposedDomains
+  };
+}
+async function findCandidate(paths, id) {
+  const records = await listDecisionRecords(paths);
+  return records.find((record) => getRecordId(record) === id);
+}
+async function acceptCandidate(paths, vocabulary, id, updated) {
+  const candidate = await requireCandidateInFolder(paths, id, "candidate");
+  return acceptCandidateRecord(paths, vocabulary, candidate, updated);
+}
+async function promoteDecisionRecord(paths, vocabulary, id, from, updated) {
+  const record = await requireRecordInFolder(paths, id, from);
+  if (getRecordId(record).startsWith("CAND-") || getString(record, "kind") === "dr") {
+    return acceptCandidateRecord(paths, vocabulary, record, updated);
+  }
+  const frontmatter = {
+    ...record.frontmatter,
+    status: "accepted",
+    updated,
+    author: getString(record, "author") || getString(record, "created_by") || "agent"
+  };
+  delete frontmatter.rejection_reason;
+  delete frontmatter.retired_by;
+  delete frontmatter.retirement_reason;
+  delete frontmatter.summary;
+  delete frontmatter.guidance;
+  const markdown = `${renderFrontmatter(frontmatter)}
+${record.body.trimStart()}`;
+  const to = path3.join(decisionRecordDirectory(paths, "accepted"), path3.basename(record.filePath));
+  await fs4.writeFile(to, markdown.endsWith("\n") ? markdown : `${markdown}
+`, "utf8");
+  await fs4.unlink(record.filePath);
+  const accepted = await readDecisionRecord(to, "accepted");
+  const validation = validateDecisionRecord(accepted, vocabulary);
+  if (validation.errors.length > 0) {
+    throw new Error(`Promoted DR failed validation: ${validation.errors.join("; ")}`);
+  }
+  return { from: record.filePath, to, record: accepted };
+}
+async function deleteDecisionRecord(paths, id, from) {
+  const record = await requireRecordInFolder(paths, id, from);
+  await fs4.unlink(record.filePath);
+  return {
+    from: record.filePath,
+    id: getRecordId(record),
+    title: getRecordTitle(record),
+    status: from
+  };
+}
+async function retireDecisionRecord(paths, id, retiredBy) {
+  const record = await requireRecordInFolder(paths, id, "accepted");
+  const frontmatter = {
+    ...record.frontmatter,
+    status: "retired",
+    ...retiredBy === void 0 ? {} : { retired_by: retiredBy }
+  };
+  delete frontmatter.summary;
+  delete frontmatter.guidance;
+  const markdown = `${renderFrontmatter(frontmatter)}
+${record.body.trimStart()}`;
+  const to = path3.join(decisionRecordDirectory(paths, "retired"), path3.basename(record.filePath));
+  await fs4.writeFile(to, markdown.endsWith("\n") ? markdown : `${markdown}
+`, "utf8");
+  await fs4.unlink(record.filePath);
+  return {
+    from: record.filePath,
+    to,
+    record: await readDecisionRecord(to, "retired")
+  };
+}
+async function setDecisionRecordEnabled(paths, id, enabled) {
+  const record = await requireRecordInFolder(paths, id, "accepted");
+  const frontmatter = {
+    ...record.frontmatter,
+    enabled: enabled ? "true" : "false"
+  };
+  delete frontmatter.summary;
+  delete frontmatter.guidance;
+  const markdown = `${renderFrontmatter(frontmatter)}
+${record.body.trimStart()}`;
+  await fs4.writeFile(record.filePath, markdown.endsWith("\n") ? markdown : `${markdown}
+`, "utf8");
+  return {
+    from: record.filePath,
+    to: record.filePath,
+    record: await readDecisionRecord(record.filePath, "accepted")
+  };
+}
+async function acceptCandidateRecord(paths, vocabulary, candidate, updated) {
+  const kind = getString(candidate, "kind");
+  if (kind.length > 0 && kind !== "dr") {
+    throw new Error(`Candidate ${getRecordId(candidate)} is kind "${kind}"; only kind "dr" can be accepted as precedent.`);
+  }
+  const proposedTags = getProposalRecord(candidate, "proposed_tags");
+  const proposedDomains = getProposalRecord(candidate, "proposed_domains");
+  const acceptedVocabulary = Object.keys(proposedTags).length === 0 && Object.keys(proposedDomains).length === 0 ? vocabulary : await acceptVocabularyProposals(paths.tags, {
+    tags: proposedTags,
+    domains: proposedDomains
+  });
+  const acceptedTags = uniqueStrings([...getStringList2(candidate, "tags"), ...Object.keys(proposedTags)]);
+  const nextId = await nextRecordId(paths, "DR");
+  const frontmatter = {
+    ...candidate.frontmatter,
+    id: nextId,
+    status: "accepted",
+    updated,
+    author: getString(candidate, "author") || getString(candidate, "created_by") || "agent",
+    tags: acceptedTags
+  };
+  delete frontmatter.kind;
+  delete frontmatter.created_by;
+  delete frontmatter.proposed_tags;
+  delete frontmatter.proposed_domains;
+  delete frontmatter.rejection_reason;
+  delete frontmatter.retired_by;
+  delete frontmatter.retirement_reason;
+  delete frontmatter.summary;
+  delete frontmatter.guidance;
+  const acceptedMarkdown = `${renderFrontmatter(frontmatter)}
+${candidate.body.trimStart()}`;
+  const to = path3.join(decisionRecordDirectory(paths, "accepted"), `${nextId}-${slugify(getRecordTitle(candidate))}.md`);
+  await fs4.writeFile(to, acceptedMarkdown.endsWith("\n") ? acceptedMarkdown : `${acceptedMarkdown}
+`, "utf8");
+  await fs4.unlink(candidate.filePath);
+  const record = await readDecisionRecord(to, "accepted");
+  const validation = validateDecisionRecord(record, acceptedVocabulary);
+  if (validation.errors.length > 0) {
+    throw new Error(`Accepted candidate failed validation: ${validation.errors.join("; ")}`);
+  }
+  return { from: candidate.filePath, to, record };
+}
+async function rejectCandidate(paths, id, reason) {
+  return moveCandidate(paths, id, "rejected", reason === void 0 ? {} : { rejection_reason: reason });
+}
+async function retireCandidate(paths, id, retiredBy) {
+  return moveCandidate(paths, id, "retired", retiredBy === void 0 ? {} : { retired_by: retiredBy });
+}
+function renderFrontmatter(frontmatter) {
+  const lines = ["---"];
+  for (const [key, value] of Object.entries(frontmatter)) {
+    if (Array.isArray(value)) {
+      lines.push(`${key}:`);
+      for (const item of value) {
+        lines.push(`  - ${item}`);
+      }
+      continue;
+    }
+    if (isStringRecord2(value)) {
+      lines.push(`${key}:`);
+      for (const [nestedKey, nestedValue] of Object.entries(value)) {
+        lines.push(`  ${nestedKey}: ${nestedValue}`);
+      }
+      continue;
+    }
+    lines.push(`${key}: ${value}`);
+  }
+  lines.push("---");
+  return lines.join("\n");
+}
+async function moveCandidate(paths, id, status, frontmatterPatch) {
+  const candidate = await requireCandidateInFolder(paths, id, "candidate");
+  const frontmatter = {
+    ...candidate.frontmatter,
+    status,
+    ...frontmatterPatch
+  };
+  delete frontmatter.summary;
+  delete frontmatter.guidance;
+  const markdown = `${renderFrontmatter(frontmatter)}
+${candidate.body.trimStart()}`;
+  const to = path3.join(decisionRecordDirectory(paths, status), path3.basename(candidate.filePath));
+  await fs4.writeFile(to, markdown.endsWith("\n") ? markdown : `${markdown}
+`, "utf8");
+  await fs4.unlink(candidate.filePath);
+  return {
+    from: candidate.filePath,
+    to,
+    record: await readDecisionRecord(to, status)
+  };
+}
+async function requireCandidateInFolder(paths, id, folder) {
+  return requireRecordInFolder(paths, id, folder);
+}
+async function requireRecordInFolder(paths, id, folder) {
+  const records = await listDecisionRecords(paths, folder);
+  const candidate = records.find((record) => getRecordId(record) === id);
+  if (candidate === void 0) {
+    throw new Error(`No ${folder} DR found with id "${id}".`);
+  }
+  return candidate;
+}
+async function nextRecordId(paths, prefix) {
+  const records = await listDecisionRecords(paths);
+  let max = 0;
+  for (const record of records) {
+    const id = getRecordId(record);
+    if (!id.startsWith(`${prefix}-`)) {
+      continue;
+    }
+    const value = Number(id.slice(prefix.length + 1));
+    if (Number.isInteger(value)) {
+      max = Math.max(max, value);
+    }
+  }
+  return `${prefix}-${String(max + 1).padStart(4, "0")}`;
+}
+function getString(record, key) {
+  const value = record.frontmatter[key];
+  return typeof value === "string" ? value : "";
+}
+function getStringList2(record, key) {
+  const value = record.frontmatter[key];
+  return Array.isArray(value) ? value : [];
+}
+function getProposalRecord(record, key) {
+  const value = record.frontmatter[key];
+  if (isStringRecord2(value)) {
+    return { ...value };
+  }
+  if (Array.isArray(value)) {
+    return Object.fromEntries(value.map((item) => [item, `TODO: describe ${item}.`]));
+  }
+  return {};
+}
+function uniqueStrings(values) {
+  return [...new Set(values)];
+}
+function slugify(title) {
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug.length === 0 ? "candidate" : slug;
+}
+function isStringRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/core/validation.ts
+var fs5 = __toESM(require("node:fs/promises"));
+var path4 = __toESM(require("node:path"));
+async function validateStore(paths) {
+  const vocabulary = await readTagVocabulary(paths.tags);
+  const records = await listDecisionRecords(paths);
+  const validationResults = await Promise.all(records.map(async (record) => {
+    const validation = validateDecisionRecord(record, vocabulary);
+    const referenceWarnings = await brokenReferenceWarnings(paths, record);
+    return {
+      ...validation,
+      warnings: [...validation.warnings, ...referenceWarnings]
+    };
+  }));
+  return {
+    validationResults,
+    vocabularyErrors: vocabulary.errors
+  };
+}
+async function brokenReferenceWarnings(paths, record) {
+  const warnings = [];
+  for (const reference of getRecordReferences(record)) {
+    if (reference.includes("://")) {
+      continue;
+    }
+    const filePart = reference.split("#")[0];
+    if (filePart.length === 0) {
+      continue;
+    }
+    try {
+      await fs5.access(path4.resolve(paths.root, filePart));
+    } catch (error) {
+      if (isNodeError3(error) && error.code === "ENOENT") {
+        warnings.push(`Reference target does not exist: ${reference}`);
+        continue;
+      }
+      throw error;
+    }
+  }
+  return warnings;
+}
+function isNodeError3(error) {
+  return error instanceof Error && "code" in error;
+}
+function validationErrorCount(result) {
+  return result.vocabularyErrors.length + result.validationResults.reduce((sum, item) => sum + item.errors.length, 0);
+}
+function validationWarningCount(result) {
+  return result.validationResults.reduce((sum, item) => sum + item.warnings.length, 0);
+}
+
+// src/main.ts
+var usage = `CodeSteward CLI
+
+Usage:
+  codesteward [--cwd <path>] [--quiet] [--no-session-log] <command>
+
+Commands:
+  init        Create or update the project-local .codesteward store at an explicit root
+  update      Update installed skill files for the discovered or explicit project root
+  status      Report store health, counts, and validation state
+  bootstrap   Run an LLM-backed bootstrap that creates candidates via the CLI
+  tags        List known domains and tags from .codesteward/tags.md
+  dr retrieve Retrieve visible accepted DRs by domain and optional tag
+  dr get      Cat DR markdown files by id
+  dr list     List DRs by status or tag
+  dr enable   Include an accepted DR in retrieval results
+  dr disable  Suppress an accepted DR from retrieval results
+  dr retire   Move an accepted DR to retired history
+  dr promote  Move a rejected or retired DR back to accepted precedent
+  dr delete   Remove a rejected or retired DR file from disk
+  candidate   Create, list, show, accept, reject, or retire candidates
+  help        Show this help
+`;
+var defaultRecordRenderOptions = {
+  showStatus: true,
+  showEnabled: true,
+  showPath: true
+};
+var retrieveRecordRenderOptions = {
+  showStatus: false,
+  showEnabled: false,
+  showPath: false
+};
+async function main(argv, io) {
+  const parsed = parseArguments(argv, io.cwd());
+  if (parsed.command.length === 0 || parsed.command[0] === "help" || parsed.command[0] === "--help") {
+    write(io.stdout, usage);
+    return;
+  }
+  const [command, ...commandArgs] = parsed.command;
+  if (command === "init") {
+    await runInit(parsed, commandArgs, io);
+    return;
+  }
+  if (command === "tags") {
+    await runTags(parsed, commandArgs, io);
+    return;
+  }
+  if (command === "status") {
+    await runStatus(parsed, commandArgs, io);
+    return;
+  }
+  if (command === "update") {
+    await runUpdate(parsed, commandArgs, io);
+    return;
+  }
+  if (command === "bootstrap") {
+    await runBootstrap(parsed, commandArgs, io);
+    return;
+  }
+  if (command === "dr") {
+    await runDr(parsed, commandArgs, io);
+    return;
+  }
+  if (command === "candidate") {
+    await runCandidate(parsed, commandArgs, io);
+    return;
+  }
+  write(io.stderr, `Unknown command: ${command}
+
+${usage}`);
+  io.exitCode = 64;
+}
+async function runBootstrap(options, args, io) {
+  const parsed = parseBootstrapArgs(args, io);
+  if (parsed === void 0) {
+    return;
+  }
+  const paths = await requireStore(options.cwd, io);
+  if (paths === void 0) {
+    return;
+  }
+  const prompt = bootstrapPrompt(paths);
+  const command = bootstrapCommand(parsed.provider, paths.root, prompt);
+  try {
+    if (!options.quiet) {
+      write(io.stdout, `Starting bootstrap with ${parsed.provider}: ${formatBootstrapCommand(command)}
+`);
+    }
+    await runBootstrapCommand(command, paths.root, options.quiet ? void 0 : io);
+    if (!options.quiet) {
+      write(io.stdout, `Bootstrap completed with ${parsed.provider}.
+`);
+    }
+  } catch (error) {
+    writeError(error, io);
+  }
+}
+async function runCandidate(options, args, io) {
+  const [subcommand, ...subcommandArgs] = args;
+  if (subcommand === "create") {
+    await runCandidateCreate(options, subcommandArgs, io);
+    return;
+  }
+  if (subcommand === "list") {
+    await runCandidateList(options, subcommandArgs, io);
+    return;
+  }
+  if (subcommand === "show") {
+    await runCandidateShow(options, subcommandArgs, io);
+    return;
+  }
+  if (subcommand === "accept") {
+    await runCandidateAccept(options, subcommandArgs, io);
+    return;
+  }
+  if (subcommand === "reject") {
+    await runCandidateReject(options, subcommandArgs, io);
+    return;
+  }
+  if (subcommand === "retire") {
+    await runCandidateRetire(options, subcommandArgs, io);
+    return;
+  }
+  write(io.stderr, "Usage: codesteward candidate (create | list | show | accept | reject | retire)\n");
+  io.exitCode = 64;
+}
+async function runCandidateCreate(options, args, io) {
+  const parsed = parseCandidateCreateArgs(args, io);
+  if (parsed === void 0) {
+    return;
+  }
+  const paths = await requireStore(options.cwd, io);
+  if (paths === void 0) {
+    return;
+  }
+  const vocabulary = await readTagVocabulary(paths.tags);
+  const result = await createCandidate(paths, vocabulary, {
+    ...parsed,
+    author: defaultAuthor(),
+    created: today()
+  });
+  if (options.quiet) {
+    return;
+  }
+  write(io.stdout, `Created ${getRecordId(result.record)} ${getRecordTitle(result.record)}
+`);
+  write(io.stdout, `Path: ${formatRecordPath(paths, result.record)}
+`);
+  if (result.proposedTags.length > 0) {
+    write(io.stdout, `Proposed tags: ${result.proposedTags.join(", ")}
+`);
+  }
+  if (result.proposedDomains.length > 0) {
+    write(io.stdout, `Proposed domains: ${result.proposedDomains.join(", ")}
+`);
+  }
+}
+async function runCandidateList(options, args, io) {
+  const parsed = parseCandidateListArgs(args, io);
+  if (parsed === void 0) {
+    return;
+  }
+  const paths = await requireStore(options.cwd, io);
+  if (paths === void 0) {
+    return;
+  }
+  const records = await listDecisionRecords(paths, parsed.status);
+  const matches = records.filter((record) => getRecordId(record).startsWith("CAND-"));
+  if (options.quiet) {
+    return;
+  }
+  for (const record of matches) {
+    write(io.stdout, `${getRecordId(record)} ${getRecordTitle(record)} (${getRecordStatus(record)})
+`);
+  }
+}
+async function runCandidateShow(options, args, io) {
+  if (args.length !== 1) {
+    write(io.stderr, "Usage: codesteward candidate show <id>\n");
+    io.exitCode = 64;
+    return;
+  }
+  const paths = await requireStore(options.cwd, io);
+  if (paths === void 0) {
+    return;
+  }
+  const record = await findCandidate(paths, args[0]);
+  if (record === void 0) {
+    write(io.stderr, `No candidate found with id "${args[0]}".
+`);
+    io.exitCode = 1;
+    return;
+  }
+  if (!options.quiet) {
+    renderRecord(record, "full", paths, io);
+  }
+}
+async function runCandidateAccept(options, args, io) {
+  if (args.length !== 1) {
+    write(io.stderr, "Usage: codesteward candidate accept <id>\n");
+    io.exitCode = 64;
+    return;
+  }
+  const paths = await requireStore(options.cwd, io);
+  if (paths === void 0) {
+    return;
+  }
+  try {
+    const result = await acceptCandidate(paths, await readTagVocabulary(paths.tags), args[0], today());
+    if (!options.quiet) {
+      write(io.stdout, `Accepted ${args[0]} as ${getRecordId(result.record)}
+`);
+      write(io.stdout, `Path: ${formatRecordPath(paths, result.record)}
+`);
+    }
+  } catch (error) {
+    writeError(error, io);
+  }
+}
+async function runCandidateReject(options, args, io) {
+  const parsed = parseCandidateRejectArgs(args, io);
+  if (parsed === void 0) {
+    return;
+  }
+  const paths = await requireStore(options.cwd, io);
+  if (paths === void 0) {
+    return;
+  }
+  try {
+    const result = await rejectCandidate(paths, parsed.id, parsed.reason);
+    if (!options.quiet) {
+      write(io.stdout, `Rejected ${parsed.id}
+`);
+      write(io.stdout, `Path: ${formatRecordPath(paths, result.record)}
+`);
+    }
+  } catch (error) {
+    writeError(error, io);
+  }
+}
+async function runCandidateRetire(options, args, io) {
+  const parsed = parseCandidateRetireArgs(args, io);
+  if (parsed === void 0) {
+    return;
+  }
+  const paths = await requireStore(options.cwd, io);
+  if (paths === void 0) {
+    return;
+  }
+  try {
+    const result = await retireCandidate(paths, parsed.id, parsed.by);
+    if (!options.quiet) {
+      write(io.stdout, `Retired ${parsed.id}${parsed.by === void 0 ? "" : ` by ${parsed.by}`}
+`);
+      write(io.stdout, `Path: ${formatRecordPath(paths, result.record)}
+`);
+    }
+  } catch (error) {
+    writeError(error, io);
+  }
+}
+async function runDr(options, args, io) {
+  const [subcommand, ...subcommandArgs] = args;
+  if (subcommand === "retrieve") {
+    await runDrRetrieve(options, subcommandArgs, io);
+    return;
+  }
+  if (subcommand === "get") {
+    await runDrGet(options, subcommandArgs, io);
+    return;
+  }
+  if (subcommand === "list") {
+    await runDrList(options, subcommandArgs, io);
+    return;
+  }
+  if (subcommand === "enable") {
+    await runDrSetEnabled(options, subcommandArgs, true, io);
+    return;
+  }
+  if (subcommand === "disable") {
+    await runDrSetEnabled(options, subcommandArgs, false, io);
+    return;
+  }
+  if (subcommand === "retire") {
+    await runDrRetire(options, subcommandArgs, io);
+    return;
+  }
+  if (subcommand === "promote") {
+    await runDrPromote(options, subcommandArgs, io);
+    return;
+  }
+  if (subcommand === "delete") {
+    await runDrDelete(options, subcommandArgs, io);
+    return;
+  }
+  write(io.stderr, "Usage: codesteward dr (retrieve | get | list | enable | disable | retire | promote | delete)\n");
+  io.exitCode = 64;
+}
+async function runDrRetrieve(options, args, io) {
+  if (args.includes("--help") || args.includes("-h")) {
+    write(io.stdout, retrieveHelp());
+    return;
+  }
+  const parsed = parseRetrieveArgs(args, io);
+  if (parsed === void 0) {
+    return;
+  }
+  const paths = await requireStore(options.cwd, io);
+  if (paths === void 0) {
+    return;
+  }
+  const vocabulary = await readTagVocabulary(paths.tags);
+  const knownTags = new Set(vocabulary.tags.map((tag) => tag.name));
+  const unknownTags = parsed.tags.filter((tag) => !knownTags.has(tag));
+  const unknownDomain = unknownQueryDomain(vocabulary.domains, parsed.domain);
+  if (unknownDomain !== void 0 || unknownTags.length > 0) {
+    if (unknownDomain !== void 0) {
+      write(io.stderr, `Unknown domain "${unknownDomain}".
+`);
+    }
+    for (const tag of unknownTags) {
+      write(io.stderr, `Unknown tag "${tag}".
+`);
+    }
+    io.exitCode = 1;
+    return;
+  }
+  const records = await listDecisionRecords(paths, "accepted");
+  const matches = records.filter((record) => recordMatches(record, parsed.tags, parsed.domain));
+  if (options.quiet) {
+    return;
+  }
+  renderRecords(matches, "medium", paths, io, retrieveRecordRenderOptions);
+}
+async function runDrGet(options, args, io) {
+  const parsed = parseGetArgs(args, io);
+  if (parsed === void 0) {
+    return;
+  }
+  const paths = await requireStore(options.cwd, io);
+  if (paths === void 0) {
+    return;
+  }
+  const byId = await findDecisionRecordFilesById(paths, parsed.ids);
+  for (const id of parsed.ids) {
+    if (!byId.has(id)) {
+      write(io.stderr, `No DR found with id "${id}".
+`);
+      io.exitCode = 1;
+    }
+  }
+  if (options.quiet) {
+    return;
+  }
+  for (const id of parsed.ids) {
+    const record = byId.get(id);
+    if (record === void 0) {
+      continue;
+    }
+    write(io.stdout, await fs6.readFile(record, "utf8"));
+  }
+}
+async function findDecisionRecordFilesById(paths, ids) {
+  const wanted = new Set(ids);
+  const found = /* @__PURE__ */ new Map();
+  for (const status of decisionRecordStatuses) {
+    const directory = decisionRecordDirectory(paths, status);
+    let entries;
+    try {
+      entries = await fs6.readdir(directory);
+    } catch (error) {
+      if (isNodeError4(error) && error.code === "ENOENT") {
+        continue;
+      }
+      throw error;
+    }
+    for (const name of [...entries].sort()) {
+      if (!name.toLowerCase().endsWith(".md")) {
+        continue;
+      }
+      for (const id of wanted) {
+        if (!found.has(id) && (name === `${id}.md` || name.startsWith(`${id}-`))) {
+          found.set(id, path5.join(directory, name));
+        }
+      }
+    }
+  }
+  return found;
+}
+async function runDrList(options, args, io) {
+  const parsed = parseListArgs(args, io);
+  if (parsed === void 0) {
+    return;
+  }
+  const paths = await requireStore(options.cwd, io);
+  if (paths === void 0) {
+    return;
+  }
+  const records = await listDecisionRecords(paths, parsed.status);
+  const matches = parsed.tag === void 0 ? records : records.filter((record) => getRecordTags(record).includes(parsed.tag ?? ""));
+  if (options.quiet) {
+    return;
+  }
+  renderRecordList(matches, io);
+}
+async function runDrSetEnabled(options, args, enabled, io) {
+  if (args.length !== 1) {
+    write(io.stderr, `Usage: codesteward dr ${enabled ? "enable" : "disable"} <id>
+`);
+    io.exitCode = 64;
+    return;
+  }
+  const paths = await requireStore(options.cwd, io);
+  if (paths === void 0) {
+    return;
+  }
+  try {
+    const result = await setDecisionRecordEnabled(paths, args[0], enabled);
+    if (!options.quiet) {
+      write(io.stdout, `${enabled ? "Enabled" : "Disabled"} ${getRecordId(result.record)}
+`);
+      write(io.stdout, `Path: ${formatRecordPath(paths, result.record)}
+`);
+    }
+  } catch (error) {
+    writeError(error, io);
+  }
+}
+async function runDrRetire(options, args, io) {
+  const parsed = parseDrRetireArgs(args, io);
+  if (parsed === void 0) {
+    return;
+  }
+  const paths = await requireStore(options.cwd, io);
+  if (paths === void 0) {
+    return;
+  }
+  try {
+    const result = await retireDecisionRecord(paths, parsed.id, parsed.by);
+    if (!options.quiet) {
+      write(io.stdout, `Retired ${parsed.id}${parsed.by === void 0 ? "" : ` by ${parsed.by}`}
+`);
+      write(io.stdout, `Path: ${formatRecordPath(paths, result.record)}
+`);
+    }
+  } catch (error) {
+    writeError(error, io);
+  }
+}
+async function runDrPromote(options, args, io) {
+  const parsed = parseDrPromoteArgs(args, io);
+  if (parsed === void 0) {
+    return;
+  }
+  const paths = await requireStore(options.cwd, io);
+  if (paths === void 0) {
+    return;
+  }
+  const from = parsed.from ?? await findHistoricalRecordStatus(paths, parsed.id);
+  if (from === void 0) {
+    write(io.stderr, `No rejected or retired DR found with id "${parsed.id}".
+`);
+    io.exitCode = 1;
+    return;
+  }
+  try {
+    const result = await promoteDecisionRecord(paths, await readTagVocabulary(paths.tags), parsed.id, from, today());
+    if (!options.quiet) {
+      write(io.stdout, `Promoted ${parsed.id} as ${getRecordId(result.record)}
+`);
+      write(io.stdout, `Path: ${formatRecordPath(paths, result.record)}
+`);
+    }
+  } catch (error) {
+    writeError(error, io);
+  }
+}
+async function runDrDelete(options, args, io) {
+  const parsed = parseDrDeleteArgs(args, io);
+  if (parsed === void 0) {
+    return;
+  }
+  const paths = await requireStore(options.cwd, io);
+  if (paths === void 0) {
+    return;
+  }
+  const from = parsed.from ?? await findHistoricalRecordStatus(paths, parsed.id);
+  if (from === void 0) {
+    write(io.stderr, `No rejected or retired DR found with id "${parsed.id}".
+`);
+    io.exitCode = 1;
+    return;
+  }
+  try {
+    const result = await deleteDecisionRecord(paths, parsed.id, from);
+    if (!options.quiet) {
+      write(io.stdout, `Deleted ${result.id} ${result.title} (${result.status})
+`);
+      write(io.stdout, `Removed: ${formatPath(paths, result.from)}
+`);
+    }
+  } catch (error) {
+    writeError(error, io);
+  }
+}
+function renderValidationResults(results, io) {
+  for (const result of results) {
+    if (result.errors.length === 0 && result.warnings.length === 0) {
+      continue;
+    }
+    write(io.stdout, `${result.path}
+`);
+    for (const error of result.errors) {
+      write(io.stdout, `  error: ${error}
+`);
+    }
+    for (const warning of result.warnings) {
+      write(io.stdout, `  warning: ${warning}
+`);
+    }
+  }
+}
+function renderStoreValidationResult(result, io) {
+  for (const error of result.vocabularyErrors) {
+    write(io.stdout, `Vocabulary error: ${error}
+`);
+  }
+  renderValidationResults(result.validationResults, io);
+}
+function parseRetrieveArgs(args, io) {
+  const tags = [];
+  let domain;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--tag") {
+      const value = args[index + 1];
+      if (value === void 0) {
+        return usageError(retrieveUsage(), io);
+      }
+      tags.push(value);
+      index += 1;
+      continue;
+    }
+    if (arg === "--domain") {
+      const value = args[index + 1];
+      if (value === void 0 || !isValidRecordDomain(value)) {
+        return usageError(retrieveUsage(), io);
+      }
+      domain = value;
+      index += 1;
+      continue;
+    }
+    return usageError(retrieveUsage(), io);
+  }
+  return { tags, domain };
+}
+function parseGetArgs(args, io) {
+  const ids = [];
+  for (const arg of args) {
+    if (arg.startsWith("-")) {
+      return usageError("Usage: codesteward dr get <id> [<id>]\n", io);
+    }
+    ids.push(arg);
+  }
+  if (ids.length === 0) {
+    return usageError("Usage: codesteward dr get <id> [<id>]\n", io);
+  }
+  return { ids };
+}
+function parseListArgs(args, io) {
+  let status;
+  let tag;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--status") {
+      const value = args[index + 1];
+      if (!isDecisionRecordStatus(value)) {
+        return usageError("Usage: codesteward dr list [--status candidate|accepted|rejected|retired] [--tag <tag>]\n", io);
+      }
+      status = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--tag") {
+      const value = args[index + 1];
+      if (value === void 0) {
+        return usageError("Usage: codesteward dr list [--status candidate|accepted|rejected|retired] [--tag <tag>]\n", io);
+      }
+      tag = value;
+      index += 1;
+      continue;
+    }
+    return usageError("Usage: codesteward dr list [--status candidate|accepted|rejected|retired] [--tag <tag>]\n", io);
+  }
+  return { status, tag };
+}
+function parseCandidateCreateArgs(args, io) {
+  let title;
+  let domain = "all";
+  let domainSetBy;
+  let decision;
+  let appendix;
+  const affectedFiles = [];
+  const tags = [];
+  const proposedTagDescriptions = {};
+  let proposedDomainDescription;
+  const references = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    const value = args[index + 1];
+    if (arg === "--title") {
+      if (value === void 0) {
+        return usageError(candidateCreateUsage(), io);
+      }
+      title = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--domain") {
+      if (value === void 0 || !isValidRecordDomain(value) || domainSetBy !== void 0) {
+        return usageError(candidateCreateUsage(), io);
+      }
+      domain = value;
+      domainSetBy = "domain";
+      index += 1;
+      continue;
+    }
+    if (arg === "--proposed-domain") {
+      const description = args[index + 2];
+      if (value === void 0 || description === void 0 || !isValidRecordDomain(value) || domainSetBy !== void 0) {
+        return usageError(candidateCreateUsage(), io);
+      }
+      domain = value;
+      domainSetBy = "proposed-domain";
+      proposedDomainDescription = description;
+      index += 2;
+      continue;
+    }
+    if (arg === "--decision") {
+      if (value === void 0) {
+        return usageError(candidateCreateUsage(), io);
+      }
+      decision = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--appendix") {
+      if (value === void 0) {
+        return usageError(candidateCreateUsage(), io);
+      }
+      appendix = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--affected") {
+      if (value === void 0) {
+        return usageError(candidateCreateUsage(), io);
+      }
+      affectedFiles.push(value);
+      index += 1;
+      continue;
+    }
+    if (arg === "--tag") {
+      if (value === void 0) {
+        return usageError(candidateCreateUsage(), io);
+      }
+      tags.push(value);
+      index += 1;
+      continue;
+    }
+    if (arg === "--proposed-tag") {
+      const description = args[index + 2];
+      if (value === void 0 || description === void 0) {
+        return usageError(candidateCreateUsage(), io);
+      }
+      tags.push(value);
+      proposedTagDescriptions[value] = description;
+      index += 2;
+      continue;
+    }
+    if (arg === "--ref") {
+      if (value === void 0) {
+        return usageError(candidateCreateUsage(), io);
+      }
+      references.push(value);
+      index += 1;
+      continue;
+    }
+    return usageError(candidateCreateUsage(), io);
+  }
+  if (title === void 0 || decision === void 0) {
+    return usageError(candidateCreateUsage(), io);
+  }
+  return {
+    title,
+    domain,
+    decision,
+    appendix: appendix?.trim() || void 0,
+    affectedFiles,
+    tags,
+    proposedTagDescriptions,
+    proposedDomainDescription,
+    references
+  };
+}
+function parseCandidateListArgs(args, io) {
+  let status = "candidate";
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--status") {
+      const value = args[index + 1];
+      if (!isDecisionRecordStatus(value)) {
+        return usageError("Usage: codesteward candidate list [--status candidate|rejected|retired]\n", io);
+      }
+      status = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--all") {
+      status = void 0;
+      continue;
+    }
+    return usageError("Usage: codesteward candidate list [--status candidate|rejected|retired]\n", io);
+  }
+  return { status };
+}
+function parseCandidateRejectArgs(args, io) {
+  const [id, ...rest] = args;
+  let reason;
+  if (id === void 0) {
+    return usageError("Usage: codesteward candidate reject <id> [--reason <text>]\n", io);
+  }
+  for (let index = 0; index < rest.length; index += 1) {
+    const arg = rest[index];
+    if (arg !== "--reason") {
+      return usageError("Usage: codesteward candidate reject <id> [--reason <text>]\n", io);
+    }
+    const value = rest[index + 1];
+    if (value === void 0) {
+      return usageError("Usage: codesteward candidate reject <id> [--reason <text>]\n", io);
+    }
+    reason = value;
+    index += 1;
+  }
+  return { id, reason };
+}
+function parseCandidateRetireArgs(args, io) {
+  return parseRetireArgs(args, "candidate retire", io);
+}
+function parseDrRetireArgs(args, io) {
+  return parseRetireArgs(args, "dr retire", io);
+}
+function parseRetireArgs(args, command, io) {
+  const [id, ...rest] = args;
+  let by;
+  const usage2 = `Usage: codesteward ${command} <id> [--by <id>]
+`;
+  if (id === void 0) {
+    return usageError(usage2, io);
+  }
+  for (let index = 0; index < rest.length; index += 1) {
+    const arg = rest[index];
+    if (arg !== "--by") {
+      return usageError(usage2, io);
+    }
+    const value = rest[index + 1];
+    if (value === void 0) {
+      return usageError(usage2, io);
+    }
+    by = value;
+    index += 1;
+  }
+  return { id, by };
+}
+function parseDrPromoteArgs(args, io) {
+  return parseHistoricalDrArgs(args, "promote", io);
+}
+function parseDrDeleteArgs(args, io) {
+  return parseHistoricalDrArgs(args, "delete", io);
+}
+function parseHistoricalDrArgs(args, command, io) {
+  const [id, ...rest] = args;
+  let from;
+  const usage2 = `Usage: codesteward dr ${command} <id> [--from rejected|retired]
+`;
+  if (id === void 0) {
+    return usageError(usage2, io);
+  }
+  for (let index = 0; index < rest.length; index += 1) {
+    const arg = rest[index];
+    if (arg !== "--from") {
+      return usageError(usage2, io);
+    }
+    const value = rest[index + 1];
+    if (value !== "rejected" && value !== "retired") {
+      return usageError(usage2, io);
+    }
+    from = value;
+    index += 1;
+  }
+  return { id, from };
+}
+function parseBootstrapArgs(args, io) {
+  let provider;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg !== "--provider") {
+      return usageError(bootstrapUsage(), io);
+    }
+    const value = args[index + 1];
+    if (value !== "claude" && value !== "codex") {
+      return usageError(bootstrapUsage(), io);
+    }
+    provider = value;
+    index += 1;
+  }
+  if (provider === void 0) {
+    return usageError(bootstrapUsage(), io);
+  }
+  return { provider };
+}
+function bootstrapUsage() {
+  return "Usage: codesteward bootstrap --provider claude|codex\n";
+}
+function bootstrapCommand(provider, root, prompt) {
+  if (provider === "claude") {
+    return {
+      file: "claude",
+      args: [
+        "--print",
+        "--permission-mode",
+        "acceptEdits",
+        "--allowedTools",
+        [
+          "Read",
+          "Glob",
+          "Grep",
+          "Bash(codesteward --cwd * candidate create *)",
+          "Bash(codesteward --cwd * tags)",
+          "Bash(codesteward --cwd * dr list *)"
+        ].join(","),
+        prompt
+      ]
+    };
+  }
+  return {
+    file: "codex",
+    args: [
+      "exec",
+      "--cd",
+      root,
+      "--full-auto",
+      "--skip-git-repo-check",
+      prompt
+    ]
+  };
+}
+async function runBootstrapCommand(command, cwd, io) {
+  await new Promise((resolve3, reject) => {
+    const child = (0, import_node_child_process.spawn)(command.file, command.args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let settled = false;
+    child.stdout.on("data", (chunk) => {
+      io?.stdout.write(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      io?.stderr.write(chunk);
+    });
+    child.on("error", (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      reject(error);
+    });
+    child.on("close", (code, signal) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (code === 0) {
+        resolve3();
+        return;
+      }
+      if (signal !== null) {
+        reject(new Error(`Command failed with signal ${signal}: ${formatBootstrapCommand(command)}`));
+        return;
+      }
+      reject(new Error(`Command failed with exit code ${code ?? "unknown"}: ${formatBootstrapCommand(command)}`));
+    });
+  });
+}
+function formatBootstrapCommand(command) {
+  const args = command.args.map((arg, index) => {
+    const isPrompt = index === command.args.length - 1;
+    return isPrompt ? "<prompt>" : shellQuote(arg);
+  });
+  return [shellQuote(command.file), ...args].join(" ");
+}
+function bootstrapPrompt(paths) {
+  const root = paths.root;
+  return [
+    "You are running a CodeSteward bootstrap.",
+    "",
+    `Project root: ${root}`,
+    "",
+    "Goal:",
+    "- Inspect existing project instructions, markdown documentation, and representative source code.",
+    "- Find consequential project-specific decisions that should become CodeSteward Decision Record candidates.",
+    "- Create candidates only by running the public CodeSteward CLI. Do not write .codesteward files directly.",
+    "",
+    "Important candidate creation contract:",
+    `- Use this command shape: codesteward --cwd ${shellQuote(root)} candidate create --title "<title>" --domain "<domain>" --decision "<terse guidance>"`,
+    '- Use --proposed-domain <domain> "<description>" instead of --domain when the domain is not already listed in .codesteward/tags.md.',
+    "- Add --tag <known-tag> when a known tag applies.",
+    '- Use --proposed-tag <tag> "<description>" when a new tag is truly useful.',
+    '- Add --appendix "<human-facing context>" only when explanatory background helps reviewers; do not put governing guidance there.',
+    "- Add --affected <path> and --ref <path-or-symbol> when useful.",
+    "- Use existing domains and tags from .codesteward/tags.md when possible. Proposed vocabulary is for truly useful missing terms.",
+    "- Every DR candidate must go through `codesteward candidate create`; do not create markdown files manually.",
+    "",
+    "What to inspect:",
+    "- AGENTS.md, AGENT.md, CLAUDE.md, .agents/**, .claude/**.",
+    "- README files, architecture/design/ADR docs, implementation plans, and other meaningful markdown.",
+    "- Source tree structure and representative implementation files that reveal project conventions.",
+    "- Existing accepted and candidate DRs, so you do not duplicate them.",
+    "",
+    "What to avoid:",
+    "- Do not create candidates for generic best practices, obvious framework behavior, style preferences with no architectural consequence, or speculation.",
+    "- Do not edit application source, docs, tags, or accepted DRs.",
+    "- Prefer fewer, high-signal candidates.",
+    "",
+    "After creating candidates, summarize what you created. If no DR-worthy decisions exist, say that and create nothing."
+  ].join("\n");
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function candidateCreateUsage() {
+  return "Usage: codesteward candidate create --title <title> [--domain <domain> | --proposed-domain <domain> <description>] --decision <text> [--appendix <text>] [--tag <tag>] [--proposed-tag <tag> <description>] [--affected <path>] [--ref <ref>]\n";
+}
+function retrieveUsage() {
+  return "Usage: codesteward dr retrieve [--domain <domain>] [--tag <tag>...]\n";
+}
+function retrieveHelp() {
+  return `Usage: codesteward dr retrieve [--domain <domain>] [--tag <tag>...]
+
+Retrieve visible accepted Decision Records.
+
+Options:
+  --domain <domain>  Filter by domain. Matches the exact domain, its ancestors, and its descendants. Omit to match every domain.
+  --tag <tag>        Filter by tag. Repeat for multiple tags. A DR matches when any provided tag is on it; DRs with no tags always match.
+`;
+}
+function renderRecords(records, detail, paths, io, options = defaultRecordRenderOptions) {
+  if (records.length === 0) {
+    write(io.stdout, "No matching DRs.\n");
+    return;
+  }
+  for (const [index, record] of records.entries()) {
+    if (index > 0) {
+      write(io.stdout, "\n");
+    }
+    renderRecord(record, detail, paths, io, options);
+  }
+}
+function renderRecord(record, detail, paths, io, options = defaultRecordRenderOptions) {
+  if (detail === "full") {
+    write(io.stdout, record.markdown.trimEnd());
+    write(io.stdout, "\n");
+    return;
+  }
+  write(io.stdout, `${getRecordId(record)} ${getRecordTitle(record)}
+`);
+  if (options.showStatus) {
+    write(io.stdout, `Status: ${getRecordStatus(record)}
+`);
+  }
+  if (options.showEnabled && !getRecordEnabled(record)) {
+    write(io.stdout, "Enabled: false\n");
+  }
+  write(io.stdout, `Domain: ${getRecordDomain(record)}
+`);
+  write(io.stdout, `Tags: ${formatRecordTags(record)}
+`);
+  if (detail === "medium") {
+    write(io.stdout, `Decision:
+${getRecordDecision(record)}
+`);
+    renderOptionalSection(record, "Applies When", "Applies when", io);
+    renderOptionalSection(record, "Does Not Apply When", "Does not apply when", io);
+    const references = getRecordReferences(record);
+    if (references.length > 0) {
+      write(io.stdout, "References:\n");
+      for (const reference of references) {
+        write(io.stdout, `- ${reference}
+`);
+      }
+    }
+  }
+  if (options.showPath) {
+    write(io.stdout, `Path: ${formatRecordPath(paths, record)}
+`);
+  }
+}
+function renderOptionalSection(record, sectionTitle, outputTitle, io) {
+  const section = getRecordSection(record, sectionTitle);
+  if (section === void 0 || section.length === 0) {
+    return;
+  }
+  write(io.stdout, `${outputTitle}:
+${section}
+`);
+}
+function recordMatches(record, tags, domain) {
+  return getRecordEnabled(record) && recordMatchesTags(record, tags) && recordMatchesDomain(record, domain);
+}
+function recordMatchesTags(record, tags) {
+  if (tags.length === 0) {
+    return true;
+  }
+  const recordTagsList = getRecordTags(record);
+  if (recordTagsList.length === 0) {
+    return true;
+  }
+  const recordTags = new Set(recordTagsList);
+  return tags.some((tag) => recordTags.has(tag));
+}
+function recordMatchesDomain(record, domain) {
+  if (domain === void 0 || domain === "all") {
+    return true;
+  }
+  const recordDomain = getRecordDomain(record);
+  if (recordDomain === "all") {
+    return true;
+  }
+  return recordDomain === domain || recordDomain.startsWith(`${domain}.`) || domain.startsWith(`${recordDomain}.`);
+}
+function formatRecordTags(record) {
+  const tags = getRecordTags(record);
+  return tags.length === 0 ? "(wildcard)" : tags.join(", ");
+}
+function formatRecordListItem(record) {
+  return `${getRecordId(record)} ${getRecordTitle(record)} Domain: ${getRecordDomain(record)} Tags: ${formatRecordTags(record)}`;
+}
+function renderRecordList(records, io) {
+  const groups = [
+    { heading: "Rejected", records: records.filter((record) => getRecordStatus(record) === "rejected") },
+    { heading: "Candidate", records: records.filter((record) => getRecordStatus(record) === "candidate") },
+    { heading: "Retired", records: records.filter((record) => getRecordStatus(record) === "retired") },
+    { heading: "Active", records: records.filter((record) => getRecordStatus(record) === "accepted" && getRecordEnabled(record)) },
+    { heading: "Active(hidden)", records: records.filter((record) => getRecordStatus(record) === "accepted" && !getRecordEnabled(record)) }
+  ];
+  let renderedAnyGroup = false;
+  for (const group of groups) {
+    if (group.records.length === 0) {
+      continue;
+    }
+    if (renderedAnyGroup) {
+      write(io.stdout, "\n");
+    }
+    write(io.stdout, `${group.heading}:
+`);
+    for (const record of group.records) {
+      write(io.stdout, `${formatRecordListItem(record)}
+`);
+    }
+    renderedAnyGroup = true;
+  }
+}
+async function findHistoricalRecordStatus(paths, id) {
+  for (const status of ["rejected", "retired"]) {
+    const records = await listDecisionRecords(paths, status);
+    if (records.some((record) => getRecordId(record) === id)) {
+      return status;
+    }
+  }
+  return void 0;
+}
+function formatRecordPath(paths, record) {
+  return formatPath(paths, record.filePath);
+}
+function formatPath(paths, targetPath) {
+  const relativePath = path5.relative(paths.root, targetPath);
+  return relativePath.split(path5.sep).join("/");
+}
+function usageError(message, io) {
+  write(io.stderr, message);
+  io.exitCode = 64;
+  return void 0;
+}
+function isDecisionRecordStatus(value) {
+  return value === "candidate" || value === "accepted" || value === "rejected" || value === "retired";
+}
+function today() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function defaultAuthor() {
+  return process.env.USER ?? process.env.USERNAME ?? "agent";
+}
+function writeError(error, io) {
+  const message = error instanceof Error ? error.message : String(error);
+  write(io.stderr, `${message}
+`);
+  io.exitCode = 1;
+}
+async function runStatus(options, args, io) {
+  if (args.length > 0) {
+    write(io.stderr, `Unexpected arguments for status: ${args.join(" ")}
+`);
+    io.exitCode = 64;
+    return;
+  }
+  const paths = await requireStore(options.cwd, io);
+  if (paths === void 0) {
+    return;
+  }
+  const vocabulary = await readTagVocabulary(paths.tags);
+  const validation = await validateStore(paths);
+  const errorCount = validationErrorCount(validation);
+  const warningCount = validationWarningCount(validation);
+  const counts = await Promise.all(
+    decisionRecordStatuses.map(async (status) => ({
+      status,
+      count: await countDecisionRecords(paths, status)
+    }))
+  );
+  if (options.quiet) {
+    if (errorCount > 0) {
+      io.exitCode = 1;
+    }
+    return;
+  }
+  write(io.stdout, `CodeSteward store: ${paths.store}
+`);
+  write(io.stdout, `Domains: ${vocabulary.domains.length}
+`);
+  write(io.stdout, `Tags: ${vocabulary.tags.length}
+`);
+  for (const item of counts) {
+    write(io.stdout, `${formatStatusLabel(item.status)} DRs: ${item.count}
+`);
+  }
+  write(io.stdout, "\n");
+  renderStoreValidationResult(validation, io);
+  write(io.stdout, `Validation: ${errorCount} error${errorCount === 1 ? "" : "s"}, ${warningCount} warning${warningCount === 1 ? "" : "s"}.
+`);
+  if (errorCount > 0) {
+    io.exitCode = 1;
+  }
+}
+async function runUpdate(options, args, io) {
+  const parsed = parseUpdateArgs(args, io);
+  if (parsed === void 0) {
+    return;
+  }
+  const paths = parsed.root === void 0 ? await requireStore(options.cwd, io) : await requireStoreAtRoot(parsed.root, io);
+  if (paths === void 0) {
+    return;
+  }
+  try {
+    const result = await updateRuntimeAssets(paths.root, parsed);
+    if (options.quiet) {
+      return;
+    }
+    write(io.stdout, `Updated CodeSteward skill files at ${result.paths.root}
+`);
+    renderPathGroup("Created", result.created, io);
+    renderPathGroup("Already current", result.existing, io);
+    renderPathGroup("Updated", result.updated, io);
+  } catch (error) {
+    writeError(error, io);
+  }
+}
+function parseUpdateArgs(args, io) {
+  let root;
+  let claude = false;
+  let codex = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--root") {
+      const value = args[index + 1];
+      if (value === void 0) {
+        return updateUsageError(io);
+      }
+      root = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--claude") {
+      claude = true;
+      continue;
+    }
+    if (arg === "--codex") {
+      codex = true;
+      continue;
+    }
+    return updateUsageError(io);
+  }
+  if (!claude && !codex) {
+    return updateUsageError(io);
+  }
+  return { root, claude, codex };
+}
+function updateUsageError(io) {
+  write(io.stderr, "Usage: codesteward update [--root <path>] --claude|--codex\n");
+  io.exitCode = 64;
+  return void 0;
+}
+function parseArguments(argv, defaultCwd) {
+  const command = [];
+  let cwd = defaultCwd;
+  let quiet = false;
+  let noSessionLog = false;
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (command.length > 0) {
+      command.push(arg);
+      continue;
+    }
+    if (arg === "--cwd") {
+      const value = argv[index + 1];
+      if (value === void 0) {
+        throw new CliUsageError("--cwd requires a path");
+      }
+      cwd = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--quiet") {
+      quiet = true;
+      continue;
+    }
+    if (arg === "--no-session-log") {
+      noSessionLog = true;
+      continue;
+    }
+    command.push(arg);
+  }
+  return { cwd, quiet, noSessionLog, command };
+}
+async function runInit(options, args, io) {
+  const parsed = parseInitArgs(args, io);
+  if (parsed === void 0) {
+    return;
+  }
+  const result = await initStore(parsed.root, {
+    claude: parsed.claude,
+    codex: parsed.codex
+  });
+  if (options.quiet) {
+    return;
+  }
+  write(io.stdout, `Initialized CodeSteward store at ${result.paths.store}
+`);
+  if (!parsed.claude && !parsed.codex) {
+    write(io.stdout, "Agent runtime bootstrap skipped. Pass --claude, --codex, or both to install runtime assets.\n");
+  }
+  if (result.created.length > 0) {
+    renderPathGroup("Created", result.created, io);
+  }
+  if (result.existing.length > 0) {
+    renderPathGroup("Already present", result.existing, io);
+  }
+  if (result.updated.length > 0) {
+    renderPathGroup("Updated", result.updated, io);
+  }
+}
+function renderPathGroup(title, items, io) {
+  if (items.length === 0) {
+    return;
+  }
+  write(io.stdout, `
+${title}:
+`);
+  for (const item of items) {
+    write(io.stdout, `- ${item}
+`);
+  }
+}
+function parseInitArgs(args, io) {
+  let root;
+  let claude = false;
+  let codex = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--root") {
+      const value = args[index + 1];
+      if (value === void 0) {
+        return initUsageError(io);
+      }
+      root = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--claude") {
+      claude = true;
+      continue;
+    }
+    if (arg === "--codex") {
+      codex = true;
+      continue;
+    }
+    return initUsageError(io);
+  }
+  if (root === void 0) {
+    return initUsageError(io);
+  }
+  return { root, claude, codex };
+}
+function initUsageError(io) {
+  write(io.stderr, "Usage: codesteward init --root <path> [--claude] [--codex]\n");
+  io.exitCode = 64;
+  return void 0;
+}
+async function runTags(options, args, io) {
+  if (args.length > 0) {
+    write(io.stderr, `Usage: codesteward tags
+`);
+    io.exitCode = 64;
+    return;
+  }
+  const paths = await requireStore(options.cwd, io);
+  if (paths === void 0) {
+    return;
+  }
+  const vocabulary = await readTagVocabulary(paths.tags);
+  if (!validateVocabularyForListing(vocabulary.errors, io)) {
+    return;
+  }
+  if (options.quiet) {
+    return;
+  }
+  write(io.stdout, "Domains:\n");
+  renderVocabularyDefinitions(vocabulary.domains, "domains", io);
+  write(io.stdout, "\nTags:\n");
+  renderVocabularyDefinitions(vocabulary.tags, "tags", io);
+}
+function validateVocabularyForListing(errors, io) {
+  if (errors.length === 0) {
+    return true;
+  }
+  for (const error of errors) {
+    write(io.stderr, `${error}
+`);
+  }
+  io.exitCode = 1;
+  return false;
+}
+function renderVocabularyDefinitions(definitions, label, io) {
+  if (definitions.length === 0) {
+    write(io.stdout, `No ${label} defined.
+`);
+    return;
+  }
+  for (const definition of definitions) {
+    write(io.stdout, `${definition.name}`);
+    if (definition.description.length > 0) {
+      write(io.stdout, ` - ${definition.description.replace(/\s+/g, " ")}`);
+    }
+    write(io.stdout, "\n");
+  }
+}
+function unknownQueryDomain(domains, domain) {
+  if (domain === void 0 || domain === "all" || domains.length === 0) {
+    return void 0;
+  }
+  const knownDomains = new Set(domains.map((item) => item.name));
+  return knownDomains.has(domain) ? void 0 : domain;
+}
+async function requireStore(cwd, io) {
+  const paths = await discoverStore(cwd);
+  if (paths === void 0) {
+    write(io.stderr, "No .codesteward store found. Run codesteward init --root <path> first.\n");
+    io.exitCode = 1;
+    return void 0;
+  }
+  return paths;
+}
+async function requireStoreAtRoot(root, io) {
+  const paths = getStorePaths(root);
+  if (!await pathExists(paths.store)) {
+    write(io.stderr, `No .codesteward store found at ${paths.root}. Run codesteward init --root ${paths.root} first.
+`);
+    io.exitCode = 1;
+    return void 0;
+  }
+  return paths;
+}
+var CliUsageError = class extends Error {
+};
+function write(stream, text) {
+  stream.write(text);
+}
+function formatStatusLabel(status) {
+  return `${status.slice(0, 1).toUpperCase()}${status.slice(1)}`;
+}
+function isNodeError4(error) {
+  return error instanceof Error && "code" in error;
+}
+if (require.main === module) {
+  main(process.argv.slice(2), process).catch((error) => {
+    if (error instanceof CliUsageError) {
+      process.stderr.write(`${error.message}
+
+${usage}`);
+      process.exitCode = 64;
+      return;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${message}
+`);
+    process.exitCode = 1;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bootstrapCommand,
+  main,
+  runBootstrapCommand
+});
+//# sourceMappingURL=main.js.map