@oevery/rsp 3.3.0 → 4.0.0

package/dist/chunk-7HXQNBIG.mjs

@@ -1,871 +0,0 @@
-#!/usr/bin/env node
-
-// src/core/config.ts
-import { readFile } from "fs/promises";
-import { dirname as dirname2, join as join3, resolve as resolve2 } from "path";
-import { fileURLToPath } from "url";
-import pc from "picocolors";
-import { parseDocument, stringify, visit } from "yaml";
-
-// src/core/content.ts
-import { parse } from "yaml";
-
-// src/core/document-model.ts
-var CHANGE_DOCUMENT_SCHEMA = {
-  titlePrefix: "# Change:",
-  sections: [
-    { id: "proposal", heading: "Proposal" },
-    { id: "spec", heading: "Spec" },
-    { id: "design", heading: "Design" },
-    { id: "tasks", heading: "Tasks" },
-    { id: "verify", heading: "Verify" },
-    { id: "blockers", heading: "Blockers" }
-  ]
-};
-var GROUP_BRIEF_DOCUMENT_SCHEMA = {
-  titlePrefix: "# Change Group:",
-  sections: [
-    { id: "goal", heading: "Goal" },
-    { id: "scope", heading: "Scope" },
-    { id: "sharedConstraints", heading: "Shared Constraints" },
-    { id: "slices", heading: "Slices" },
-    { id: "completionConditions", heading: "Completion Conditions" },
-    { id: "durableOutcomes", heading: "Durable Outcomes" },
-    { id: "blockers", heading: "Blockers" }
-  ]
-};
-var DocumentSectionCardinalityError = class extends Error {
-  constructor(sectionId, count) {
-    super(`document must contain exactly one ${sectionId} section; found ${count}`);
-    this.sectionId = sectionId;
-    this.count = count;
-    this.name = "DocumentSectionCardinalityError";
-  }
-  sectionId;
-  count;
-};
-function parseRspDocument(source, schema) {
-  const definitionsByHeading = new Map(schema.sections.map((definition) => [definition.heading, definition]));
-  const observedHeadings = collectLevelTwoHeadings(source);
-  const sections = /* @__PURE__ */ new Map();
-  const unknownHeadings = [];
-  for (let index = 0; index < observedHeadings.length; index++) {
-    const observed = observedHeadings[index];
-    const definition = definitionsByHeading.get(observed.heading);
-    if (!definition) {
-      unknownHeadings.push(observed.heading);
-      continue;
-    }
-    const nextHeading = observedHeadings[index + 1];
-    const bodyEnd = nextHeading ? lineBreakStart(source, nextHeading.start) : source.length;
-    const section = {
-      id: definition.id,
-      heading: definition.heading,
-      canonical: observed.canonical,
-      body: source.slice(observed.end, bodyEnd).trim(),
-      headingStart: observed.start,
-      headingEnd: observed.end,
-      bodyStart: observed.end,
-      bodyEnd
-    };
-    const matches = sections.get(definition.id) ?? [];
-    matches.push(section);
-    sections.set(definition.id, matches);
-  }
-  const missingSections = schema.sections.filter((definition) => !sections.has(definition.id)).map((definition) => definition.id);
-  const duplicateSections = schema.sections.filter((definition) => (sections.get(definition.id)?.length ?? 0) > 1).map((definition) => definition.id);
-  const titleOccurrences = collectDocumentTitles(source, schema.titlePrefix);
-  const titles = titleOccurrences.map((title) => title.value);
-  return {
-    source,
-    schema,
-    title: titles[0] ?? null,
-    titles,
-    titleOccurrences,
-    sections,
-    unknownHeadings,
-    missingSections,
-    duplicateSections
-  };
-}
-function getDocumentTitles(document, compatibility = "broad") {
-  if (compatibility === "broad")
-    return document.titles;
-  return document.titleOccurrences.filter((title) => compatibility === "identity" ? title.identityCompatible : title.spaced).map((title) => title.value);
-}
-function getDocumentTitle(document, compatibility = "broad") {
-  return getDocumentTitles(document, compatibility)[0] ?? null;
-}
-function getDocumentSections(document, sectionId) {
-  return document.sections.get(sectionId) ?? [];
-}
-function getDocumentSection(document, sectionId) {
-  return getDocumentSections(document, sectionId)[0];
-}
-function getDocumentSectionBody(document, sectionId) {
-  return getDocumentSection(document, sectionId)?.body ?? "";
-}
-function getDocumentSectionDefinitionByHeading(schema, heading) {
-  return schema.sections.find((candidate) => candidate.heading === heading);
-}
-function getCanonicalSectionHeadings(schema) {
-  return schema.sections.map((section) => section.heading);
-}
-function renderDocumentSectionHeading(schema, sectionId) {
-  const definition = schema.sections.find((candidate) => candidate.id === sectionId);
-  if (!definition)
-    throw new Error(`unknown document section: ${sectionId}`);
-  return `## ${definition.heading}`;
-}
-function renderDocumentTitle(schema, title) {
-  return `${schema.titlePrefix} ${title}`;
-}
-function appendDocumentSectionItem(document, sectionId, item) {
-  const matches = getDocumentSections(document, sectionId);
-  if (matches.length !== 1)
-    throw new DocumentSectionCardinalityError(sectionId, matches.length);
-  const insertAt = matches[0].bodyEnd;
-  const before = document.source.slice(0, insertAt);
-  const separator = before.endsWith("\n\n") ? "" : before.endsWith("\n") ? "\n" : "\n\n";
-  return `${before}${separator}${item}
-${document.source.slice(insertAt)}`;
-}
-function collectLevelTwoHeadings(source) {
-  const headings = [];
-  const pattern = /^## ([^\r\n]+)\r?$/gm;
-  let match;
-  while ((match = pattern.exec(source)) !== null) {
-    const heading = match[1].trimEnd();
-    headings.push({
-      heading,
-      canonical: heading === match[1],
-      start: match.index,
-      end: match.index + match[0].length
-    });
-  }
-  return headings;
-}
-function collectDocumentTitles(source, prefix) {
-  const titles = [];
-  for (const line of source.split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (!trimmed.startsWith(prefix))
-      continue;
-    const identity = line.startsWith(prefix) ? line.slice(prefix.length).match(/^\s+(\S+)\s*$/) : null;
-    titles.push({
-      value: trimmed.slice(prefix.length).trim(),
-      identityCompatible: identity !== null,
-      spaced: line.startsWith(`${prefix} `)
-    });
-  }
-  return titles;
-}
-function lineBreakStart(source, headingStart) {
-  if (headingStart > 0 && source[headingStart - 1] === "\n")
-    return headingStart - 1;
-  return headingStart;
-}
-
-// src/core/content.ts
-function parseYamlText(text) {
-  const parsed = parse(text);
-  if (parsed === null || parsed === void 0)
-    return {};
-  if (typeof parsed !== "object" || Array.isArray(parsed))
-    throw new Error("YAML document must be a mapping/object");
-  return parsed;
-}
-function parseFrontmatter(content) {
-  const m = content.match(/^---\r?\n([\s\S]*?)\r?\n(?:---|\.\.\.)\r?\n/);
-  if (!m)
-    return null;
-  return parseYamlText(m[1]);
-}
-function countCheckboxes(content) {
-  const todo = (content.match(/\[ \]/g) || []).length;
-  const progress = (content.match(/\[\/\]/g) || []).length;
-  const done = (content.match(/\[x\]/g) || []).length;
-  const dropped = (content.match(/\[-\]/g) || []).length;
-  return { todo, progress, done, dropped, total: todo + progress + done + dropped };
-}
-function classifyVerifyCheckboxes(sectionText) {
-  const buckets = collectVerifyCheckboxLines(sectionText);
-  return {
-    required: countCheckboxes([...buckets.required, ...buckets.unclassified].join("\n")),
-    optional: countCheckboxes(buckets.optional.join("\n")),
-    unclassified: countCheckboxes(buckets.unclassified.join("\n")),
-    legacy: buckets.legacy
-  };
-}
-function collectVerifyCheckboxLines(sectionText) {
-  const required = [];
-  const optional = [];
-  const unclassified = [];
-  let current = "unclassified";
-  let sawClassificationHeading = false;
-  for (const line of sectionText.split("\n")) {
-    const heading = line.match(/^###\s+(Required|Optional)\s*$/i);
-    if (heading) {
-      current = heading[1].toLowerCase();
-      sawClassificationHeading = true;
-      continue;
-    }
-    if (!/^- \[[ /x-]\]/i.test(line.trim()))
-      continue;
-    if (current === "required")
-      required.push(line);
-    else if (current === "optional")
-      optional.push(line);
-    else
-      unclassified.push(line);
-  }
-  return { required, optional, unclassified, legacy: unclassified.length > 0 || !sawClassificationHeading };
-}
-function getOpenCheckboxes(sectionText) {
-  return sectionText.split("\n").map((line) => line.trim()).filter((line) => /^- \[[ /]\]/.test(line));
-}
-function extractBlockerLines(content) {
-  const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
-  return normalizeBlockerBody(getDocumentSectionBody(document, "blockers"));
-}
-function hasMeaningfulBlockerBody(body) {
-  return hasMeaningfulBlockerLines(normalizeBlockerBody(body));
-}
-function normalizeBlockerBody(body) {
-  return body.replace(/<!--[\s\S]*?-->/g, "").split("\n").map((line) => line.trim()).filter(Boolean);
-}
-function hasMeaningfulBlockers(content) {
-  return hasMeaningfulBlockerLines(extractBlockerLines(content));
-}
-function isEmptyBlockerLine(line) {
-  const normalized = line.trim();
-  return /^none[.。]?$/i.test(normalized) || /^[-*]\s*(?:none[.。]?)?$/i.test(normalized);
-}
-function hasMeaningfulBlockerLines(lines) {
-  if (lines.length === 0)
-    return false;
-  return lines.some((line) => !isEmptyBlockerLine(line));
-}
-function detectDeltaSections(content) {
-  const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
-  const body = getDocumentSectionBody(document, "spec");
-  return {
-    added: /^###\s*ADDED/im.test(body),
-    modified: /^###\s*MODIFIED/im.test(body),
-    removed: /^###\s*REMOVED/im.test(body)
-  };
-}
-function parseScenarios(content) {
-  const scenarios = [];
-  const regex = /^#{3,4}\s*Scenario:\s*(.+)$/gim;
-  let match;
-  while ((match = regex.exec(content)) !== null) {
-    const heading = match[1].trim();
-    const startPos = match.index + match[0].length;
-    const restContent = content.slice(startPos);
-    const nextSection = restContent.match(/^#{3,4}\s/m);
-    const block = nextSection ? restContent.slice(0, nextSection.index) : restContent;
-    const steps = block.split("\n").map((s) => s.trim()).filter((s) => s.startsWith("-") && /GIVEN|WHEN|THEN|AND|BUT/i.test(s)).map((s) => s.replace(/^[-*]\s*/, ""));
-    if (steps.length > 0)
-      scenarios.push({ heading, steps });
-  }
-  return scenarios;
-}
-
-// src/core/decisions.ts
-import { existsSync } from "fs";
-import { mkdir, readdir as readdir2, realpath, stat } from "fs/promises";
-import { dirname, isAbsolute, join as join2, posix, relative, resolve, sep } from "path";
-
-// src/core/managed-path.ts
-import { lstatSync } from "fs";
-import { readdir, writeFile } from "fs/promises";
-import { join } from "path";
-var ManagedPathError = class extends Error {
-  constructor(path, message) {
-    super(message);
-    this.path = path;
-    this.name = "ManagedPathError";
-  }
-  path;
-};
-function inspectManagedDirectory(path, label, options = {}) {
-  try {
-    const stats = lstatSync(path);
-    if (stats.isDirectory())
-      return { exists: true, issue: null };
-    return {
-      exists: true,
-      issue: new ManagedPathError(path, `${label} must be a real directory: ${path}`)
-    };
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      if (options.allowMissing)
-        return { exists: false, issue: null };
-      return {
-        exists: false,
-        issue: new ManagedPathError(path, `${label} must be a real directory: ${path}`)
-      };
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      exists: false,
-      issue: new ManagedPathError(path, `unable to inspect ${label} ${path}: ${message}`)
-    };
-  }
-}
-function requireManagedDirectory(path, label, options = {}) {
-  const inspection = inspectManagedDirectory(path, label, options);
-  if (inspection.issue)
-    throw inspection.issue;
-  return inspection.exists;
-}
-function inspectManagedFile(path, label, options = {}) {
-  try {
-    const stats = lstatSync(path);
-    if (stats.isFile())
-      return { exists: true, issue: null };
-    return {
-      exists: true,
-      issue: new ManagedPathError(path, `${label} must be a regular file: ${path}`)
-    };
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      if (options.allowMissing)
-        return { exists: false, issue: null };
-      return {
-        exists: false,
-        issue: new ManagedPathError(path, `${label} must be a regular file: ${path}`)
-      };
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      exists: false,
-      issue: new ManagedPathError(path, `unable to inspect ${label} ${path}: ${message}`)
-    };
-  }
-}
-function requireManagedFile(path, label, options = {}) {
-  const inspection = inspectManagedFile(path, label, options);
-  if (inspection.issue)
-    throw inspection.issue;
-  return inspection.exists;
-}
-async function ensureManagedFile(path, content, label) {
-  if (requireManagedFile(path, label, { allowMissing: true }))
-    return false;
-  await writeFile(path, content, { flag: "wx" });
-  return true;
-}
-async function writeManagedFile(path, content, label) {
-  const exists = requireManagedFile(path, label, { allowMissing: true });
-  if (exists)
-    await writeFile(path, content);
-  else
-    await writeFile(path, content, { flag: "wx" });
-}
-function resolveManagedDirectoryChain(root, segments, label) {
-  requireManagedDirectory(root, `${label} root`);
-  let current = root;
-  for (const segment of segments) {
-    if (!segment || segment === "." || segment === ".." || segment.includes("/") || segment.includes("\\"))
-      throw new ManagedPathError(current, `${label} contains an invalid directory segment: ${segment}`);
-    current = join(current, segment);
-    requireManagedDirectory(current, label, { allowMissing: true });
-  }
-  return current;
-}
-async function inspectManagedFileTree(root, label, options = {}) {
-  const result = { rootExists: false, files: [], issues: [] };
-  const rootInspection = inspectManagedDirectory(root, `${label} root`, options);
-  if (rootInspection.issue) {
-    result.issues.push(rootInspection.issue);
-    return result;
-  }
-  if (!rootInspection.exists)
-    return result;
-  result.rootExists = true;
-  await collectManagedFiles(root, label, result);
-  result.files.sort();
-  return result;
-}
-async function collectManagedFiles(directory, label, result) {
-  let entries;
-  try {
-    entries = await readdir(directory, { withFileTypes: true });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    result.issues.push(new ManagedPathError(directory, `unable to inspect the ${label} tree at ${directory}: ${message}`));
-    return;
-  }
-  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-    if (entry.name.startsWith("."))
-      continue;
-    const path = join(directory, entry.name);
-    if (entry.isDirectory()) {
-      await collectManagedFiles(path, label, result);
-      continue;
-    }
-    if (entry.isFile()) {
-      result.files.push(path);
-      continue;
-    }
-    result.issues.push(new ManagedPathError(path, `unsupported entry in the ${label} tree: ${path}`));
-  }
-}
-
-// src/core/decisions.ts
-var DEFAULT_DECISION_RECORDS_PATH = ".rsp/specs/decisions";
-function normalizeDecisionRecordsPath(pathValue) {
-  return posix.normalize(pathValue.trim().replace(/\\/g, "/")).replace(/^\.\//, "").replace(/\/$/, "");
-}
-function validateDecisionRecordsPath(pathValue) {
-  if (typeof pathValue !== "string" || pathValue.trim() === "")
-    return 'config.yaml field "decisions.path" must be a non-empty string';
-  const raw = pathValue.trim();
-  const portable = raw.replace(/\\/g, "/");
-  if (isAbsolute(raw) || posix.isAbsolute(portable) || /^[a-z]:[\\/]/i.test(raw))
-    return 'config.yaml field "decisions.path" must be project-relative';
-  const normalized = normalizeDecisionRecordsPath(raw);
-  if (normalized === "." || normalized === ".." || normalized.startsWith("../"))
-    return 'config.yaml field "decisions.path" must stay inside the Host Project';
-  if ((normalized === ".rsp" || normalized.startsWith(".rsp/")) && normalized !== DEFAULT_DECISION_RECORDS_PATH)
-    return `config.yaml field "decisions.path" must use ${DEFAULT_DECISION_RECORDS_PATH} or a path outside .rsp/`;
-  return null;
-}
-function getDecisionRecordsConfigIssue(config) {
-  if (!("decisions" in config))
-    return null;
-  const decisions = config.decisions;
-  if (!decisions || typeof decisions !== "object" || Array.isArray(decisions))
-    return 'config.yaml field "decisions" must be a mapping with one path';
-  const keys = Object.keys(decisions);
-  if (keys.length !== 1 || keys[0] !== "path")
-    return 'config.yaml field "decisions" supports only "path"';
-  return validateDecisionRecordsPath(decisions.path);
-}
-function resolveDecisionRecordsPath(config) {
-  const configured = config.decisions?.path;
-  return configured && validateDecisionRecordsPath(configured) === null ? normalizeDecisionRecordsPath(configured) : DEFAULT_DECISION_RECORDS_PATH;
-}
-async function ensureDecisionRecordsDirectory(pathValue) {
-  const filesystemError = await validateDecisionRecordsFilesystemPath(pathValue);
-  if (filesystemError)
-    throw new Error(filesystemError);
-  const existed = existsSync(pathValue);
-  await mkdir(pathValue, { recursive: true });
-  const entries = await readdir2(pathValue);
-  if (entries.length === 0) {
-    await ensureManagedFile(join2(pathValue, ".gitkeep"), "", "Decision Record placeholder");
-    return true;
-  }
-  if (entries.includes(".gitkeep"))
-    requireManagedFile(join2(pathValue, ".gitkeep"), "Decision Record placeholder");
-  return !existed;
-}
-async function validateDecisionRecordsFilesystemPath(pathValue, cwd = process.cwd()) {
-  const projectRoot = await realpath(cwd);
-  const targetPath = resolve(projectRoot, pathValue);
-  let existingAncestor = targetPath;
-  while (!existsSync(existingAncestor)) {
-    const parent = dirname(existingAncestor);
-    if (parent === existingAncestor)
-      return `Decision Record path "${pathValue}" has no accessible Host Project ancestor`;
-    existingAncestor = parent;
-  }
-  const resolvedAncestor = await realpath(existingAncestor);
-  const rel = relative(projectRoot, resolvedAncestor);
-  if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel))
-    return `Decision Record path "${pathValue}" resolves outside the Host Project through ${existingAncestor}`;
-  if (existsSync(targetPath) && !(await stat(targetPath)).isDirectory())
-    return `Decision Record path "${pathValue}" must be a directory`;
-  return null;
-}
-
-// src/core/config.ts
-var __dirname = dirname2(fileURLToPath(import.meta.url));
-var PKG_ROOT = join3(__dirname, "..");
-var RSP_DIR = ".rsp";
-var RSP_RULES_PATH = join3(RSP_DIR, "rsp-rules.md");
-var OBSOLETE_RSP_RULES_PATH = join3(RSP_DIR, "rules", "rsp-rules.md");
-var CHANGES_DIR = join3(RSP_DIR, "changes");
-var FOCUS_DIR = join3(RSP_DIR, "focus.d");
-var MAX_FOCUS_CAPSULE_BYTES = 4096;
-var ARCHIVES_DIR = join3(RSP_DIR, "archives");
-var LOCK_PATH = join3(RSP_DIR, ".lock");
-var CONFIG_PATH = join3(RSP_DIR, "config.yaml");
-var VALID_KINDS = ["feature", "fix", "refactor", "docs", "ops", "research"];
-var DEFAULT_REQUIRED_SECTIONS = getCanonicalSectionHeadings(CHANGE_DOCUMENT_SCHEMA);
-var LEGACY_MISSING_CONFIG_MANAGE_POLICY = { activation: "explicit", closeout: "local" };
-var INVALID_CONFIG_MANAGE_POLICY = { activation: "explicit", closeout: "manual" };
-var CONFIG_DEFAULTS = {
-  kinds: [],
-  decisions: { path: ".rsp/specs/decisions" },
-  language: { default: "en" },
-  manage: { activation: "auto", closeout: "local" }
-};
-function generateConfigTemplate(config = {}) {
-  const kinds = config.kinds ?? CONFIG_DEFAULTS.kinds;
-  const decisions = { ...CONFIG_DEFAULTS.decisions, ...config.decisions };
-  const manage = { ...CONFIG_DEFAULTS.manage, ...config.manage };
-  const language = { ...CONFIG_DEFAULTS.language, ...config.language };
-  const kindsYaml = stringify(kinds).trimEnd();
-  const renderedKinds = kinds.length === 0 ? `kinds: ${kindsYaml}` : `kinds:
-${kindsYaml.split("\n").map((line) => `  ${line}`).join("\n")}`;
-  const artifactsLine = language.artifacts ? `  artifacts: ${stringify(language.artifacts).trim()}` : "  # artifacts: zh-CN";
-  const commitLine = language.commit ? `  commit: ${stringify(language.commit).trim()}` : "  # commit: zh-CN";
-  return `# RSP project configuration
-# An empty kinds list retains the built-in defaults.
-# A non-empty kinds list replaces the built-in defaults; it does not extend them.
-# Every entry must be a unique non-empty string.
-#
-# Built-in defaults:
-#   kinds:               ${VALID_KINDS.join(", ")}
-#
-${renderedKinds}
-
-# Decision Records default to .rsp/specs/decisions.
-decisions:
-  path: ${stringify(decisions.path).trim()}
-
-# New projects default to automatic Manage routing with local closeout.
-# Use activation: explicit to require a named managed request.
-# closeout accepts manual, lifecycle, or local; local routes a qualified clean terminal non-small boundary to one local commit but never push or publication.
-manage:
-  activation: ${manage.activation}
-  closeout: ${manage.closeout}
-
-# Set one shared project default for durable artifact and commit prose.
-# Response language remains user/session-owned and is never read from this project mapping.
-language:
-  default: ${stringify(language.default).trim()}
-${artifactsLine}
-${commitLine}
-`;
-}
-var MANAGE_ACTIVATIONS = ["explicit", "auto"];
-var MANAGE_CLOSEOUTS = ["manual", "lifecycle", "local"];
-function reconcileRspConfigDefaults(raw) {
-  const document = parseDocument(raw);
-  if (document.errors.length > 0)
-    throw new Error(document.errors.map((error) => error.message).join("; "));
-  const parsed = parseYamlText(raw);
-  const issues = validateRspConfig(parsed);
-  if (issues.length > 0)
-    throw new Error(issues.join("; "));
-  const added = collectMissingConfigDefaults(parsed);
-  const customComments = hasCustomConfigComments(document, parsed);
-  if (customComments) {
-    backfillConfigDocument(document, parsed);
-  }
-  if (customComments && added.length === 0)
-    return { content: raw, added, changed: false };
-  const content = customComments ? String(document) : generateConfigTemplate(parsed);
-  return { content, added, changed: content !== raw };
-}
-function collectMissingConfigDefaults(parsed) {
-  const added = [];
-  if (!("kinds" in parsed))
-    added.push("kinds");
-  if (!("decisions" in parsed) || !hasNestedKey(parsed.decisions, "path"))
-    added.push("decisions.path");
-  if (!("language" in parsed))
-    added.push("language.default");
-  if (!("manage" in parsed)) {
-    added.push("manage.activation", "manage.closeout");
-  } else {
-    if (!hasNestedKey(parsed.manage, "activation"))
-      added.push("manage.activation");
-    if (!hasNestedKey(parsed.manage, "closeout"))
-      added.push("manage.closeout");
-  }
-  return added;
-}
-function backfillConfigDocument(document, parsed) {
-  if (!("kinds" in parsed))
-    document.set("kinds", [...CONFIG_DEFAULTS.kinds]);
-  if (!("decisions" in parsed))
-    document.set("decisions", { path: CONFIG_DEFAULTS.decisions.path });
-  else if (!hasNestedKey(parsed.decisions, "path"))
-    document.setIn(["decisions", "path"], CONFIG_DEFAULTS.decisions.path);
-  if (!("language" in parsed))
-    document.set("language", { default: CONFIG_DEFAULTS.language.default });
-  if (!("manage" in parsed)) {
-    document.set("manage", { ...CONFIG_DEFAULTS.manage });
-  } else {
-    if (!hasNestedKey(parsed.manage, "activation"))
-      document.setIn(["manage", "activation"], CONFIG_DEFAULTS.manage.activation);
-    if (!hasNestedKey(parsed.manage, "closeout"))
-      document.setIn(["manage", "closeout"], CONFIG_DEFAULTS.manage.closeout);
-  }
-}
-function hasNestedKey(value, key) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value) && key in value);
-}
-var LEGACY_GENERATED_CONFIG_COMMENTS = /* @__PURE__ */ new Set([
-  "Omit kinds or use [] to retain the built-in defaults.",
-  "New projects default to automatic Manage routing with lifecycle-only closeout.",
-  "Self-host automatic Manage routing with bounded deterministic local commits; push and publication stay explicit.",
-  "Set exactly one project-relative authoritative directory when the Host Project already owns Decision Records elsewhere.",
-  "kinds:",
-  "decisions:",
-  "path: docs/adr",
-  ...VALID_KINDS.map((kind) => `- ${kind}`)
-]);
-function hasCustomConfigComments(document, parsed) {
-  const generated = new Set(collectConfigComments(parseDocument(generateConfigTemplate(parsed))));
-  for (const comment of LEGACY_GENERATED_CONFIG_COMMENTS)
-    generated.add(comment);
-  return collectConfigComments(document).some((comment) => !generated.has(comment));
-}
-function collectConfigComments(document) {
-  const comments = [];
-  const append = (value) => {
-    if (!value)
-      return;
-    for (const line of value.split("\n")) {
-      const comment = line.trim();
-      if (comment)
-        comments.push(comment);
-    }
-  };
-  append(document.commentBefore);
-  append(document.comment);
-  visit(document, {
-    Node(_key, node) {
-      append(node.commentBefore);
-      append(node.comment);
-    }
-  });
-  return comments;
-}
-var _configCache = null;
-async function loadRspConfig() {
-  const inspection = await inspectRspConfig();
-  if (inspection.issues.length > 0)
-    throw new Error(inspection.issues.join("; "));
-  return inspection.config;
-}
-async function inspectRspConfig(cwd = process.cwd()) {
-  cwd = resolve2(cwd);
-  if (_configCache?.cwd === cwd)
-    return _configCache.inspection;
-  const configPath = join3(cwd, CONFIG_PATH);
-  const configFile = inspectManagedFile(configPath, "config file", { allowMissing: true });
-  if (configFile.issue)
-    throw configFile.issue;
-  if (!configFile.exists) {
-    const inspection2 = { config: {}, issues: [] };
-    _configCache = { cwd, inspection: inspection2 };
-    return inspection2;
-  }
-  const raw = await readFile(configPath, "utf-8");
-  const parsed = parseYamlText(raw);
-  const issues = validateRspConfig(parsed);
-  const decisions = parsed.decisions && typeof parsed.decisions === "object" && !Array.isArray(parsed.decisions) ? parsed.decisions : void 0;
-  const decisionPath = decisions?.path;
-  const manageValue = parsed.manage && typeof parsed.manage === "object" && !Array.isArray(parsed.manage) ? parsed.manage : void 0;
-  const languageValue = parsed.language && typeof parsed.language === "object" && !Array.isArray(parsed.language) ? parsed.language : void 0;
-  const activation = MANAGE_ACTIVATIONS.includes(manageValue?.activation) ? manageValue?.activation : void 0;
-  const closeout = MANAGE_CLOSEOUTS.includes(manageValue?.closeout) ? manageValue?.closeout : void 0;
-  const kinds = Array.isArray(parsed.kinds) && parsed.kinds.every((value) => typeof value === "string" && value.trim() !== "") ? parsed.kinds.map((value) => value.trim()) : void 0;
-  const decisionRecordsIssue = getDecisionRecordsConfigIssue(parsed);
-  const inspection = {
-    config: {
-      kinds,
-      decisions: decisionRecordsIssue === null && validateDecisionRecordsPath(decisionPath) === null ? { path: normalizeDecisionRecordsPath(String(decisionPath)) } : void 0,
-      manage: manageValue ? { activation, closeout } : void 0,
-      language: parseLanguageConfig(languageValue)
-    },
-    issues
-  };
-  _configCache = { cwd, inspection };
-  return inspection;
-}
-function validateRspConfig(parsed) {
-  const issues = [];
-  const supported = /* @__PURE__ */ new Set(["kinds", "decisions", "manage", "language"]);
-  for (const key of Object.keys(parsed)) {
-    if (key === "required_sections") {
-      issues.push('config.yaml field "required_sections" is no longer supported');
-    } else if (!supported.has(key)) {
-      issues.push(`config.yaml field "${key}" is not supported`);
-    }
-  }
-  if ("kinds" in parsed) {
-    if (!Array.isArray(parsed.kinds)) {
-      issues.push('config.yaml field "kinds" must be a YAML list');
-    } else if (!parsed.kinds.every((value) => typeof value === "string" && value.trim() !== "")) {
-      issues.push('config.yaml field "kinds" must contain only non-empty strings');
-    } else {
-      const kinds = parsed.kinds.map((value) => value.trim());
-      const duplicates = [...new Set(kinds.filter((value, index) => kinds.indexOf(value) !== index))];
-      if (duplicates.length > 0)
-        issues.push(`config.yaml field "kinds" contains duplicate entries: ${duplicates.join(", ")}`);
-    }
-  }
-  const decisionRecordsIssue = getDecisionRecordsConfigIssue(parsed);
-  if (decisionRecordsIssue)
-    issues.push(decisionRecordsIssue);
-  if ("manage" in parsed) {
-    if (!parsed.manage || typeof parsed.manage !== "object" || Array.isArray(parsed.manage)) {
-      issues.push('config.yaml field "manage" must be a YAML mapping');
-    } else {
-      const manage = parsed.manage;
-      const supportedManageFields = /* @__PURE__ */ new Set(["activation", "closeout"]);
-      for (const key of Object.keys(manage)) {
-        if (!supportedManageFields.has(key))
-          issues.push(`config.yaml field "manage.${key}" is not supported`);
-      }
-      if ("activation" in manage && !MANAGE_ACTIVATIONS.includes(manage.activation))
-        issues.push('config.yaml field "manage.activation" must be one of: explicit, auto');
-      if ("closeout" in manage && !MANAGE_CLOSEOUTS.includes(manage.closeout))
-        issues.push('config.yaml field "manage.closeout" must be one of: manual, lifecycle, local');
-    }
-  }
-  if ("language" in parsed) {
-    if (!parsed.language || typeof parsed.language !== "object" || Array.isArray(parsed.language)) {
-      issues.push('config.yaml field "language" must be a YAML mapping');
-    } else {
-      const language = parsed.language;
-      const supportedLanguageFields = /* @__PURE__ */ new Set(["default", "artifacts", "commit"]);
-      for (const key of Object.keys(language)) {
-        if (!supportedLanguageFields.has(key))
-          issues.push(`config.yaml field "language.${key}" is not supported`);
-      }
-      if (!("default" in language))
-        issues.push('config.yaml field "language.default" is required when language is configured');
-      for (const key of supportedLanguageFields) {
-        if (key in language && canonicalizeLanguageTag(language[key]) === null)
-          issues.push(`config.yaml field "language.${key}" must be a non-empty valid BCP 47 language tag`);
-      }
-    }
-  }
-  return issues;
-}
-function clearConfigCache() {
-  _configCache = null;
-}
-function resolveKinds(config) {
-  return config.kinds && config.kinds.length > 0 ? config.kinds : [...VALID_KINDS];
-}
-function resolveRequiredSections(_config) {
-  return [...DEFAULT_REQUIRED_SECTIONS];
-}
-function resolveManagePolicy(config, options = {}) {
-  if (options.configValid === false)
-    return { ...INVALID_CONFIG_MANAGE_POLICY };
-  return {
-    activation: config.manage?.activation ?? LEGACY_MISSING_CONFIG_MANAGE_POLICY.activation,
-    closeout: config.manage?.closeout ?? LEGACY_MISSING_CONFIG_MANAGE_POLICY.closeout
-  };
-}
-function resolveLanguagePolicy(config, options = {}) {
-  if (options.configValid === false || !config.language)
-    return { artifacts: null, commit: null };
-  return {
-    artifacts: config.language.artifacts ?? config.language.default,
-    commit: config.language.commit ?? config.language.default
-  };
-}
-function parseLanguageConfig(value) {
-  if (!value)
-    return void 0;
-  const defaultLanguage = canonicalizeLanguageTag(value.default);
-  if (defaultLanguage === null)
-    return void 0;
-  const artifacts = canonicalizeLanguageTag(value.artifacts);
-  const commit = canonicalizeLanguageTag(value.commit);
-  return {
-    default: defaultLanguage,
-    artifacts: artifacts ?? void 0,
-    commit: commit ?? void 0
-  };
-}
-function canonicalizeLanguageTag(value) {
-  if (typeof value !== "string" || value.trim() === "")
-    return null;
-  try {
-    return Intl.getCanonicalLocales(value.trim())[0] ?? null;
-  } catch {
-    return null;
-  }
-}
-async function getVersion() {
-  const { version } = JSON.parse(await readFile(join3(PKG_ROOT, "package.json"), "utf-8"));
-  return version;
-}
-
-// src/core/output.ts
-import pc2 from "picocolors";
-function toErrorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function emitJson(data, options = {}) {
-  const indentation = options.compact ? void 0 : 2;
-  process.stdout.write(`${JSON.stringify(data, null, indentation)}
-`);
-}
-
-export {
-  CHANGE_DOCUMENT_SCHEMA,
-  GROUP_BRIEF_DOCUMENT_SCHEMA,
-  DocumentSectionCardinalityError,
-  parseRspDocument,
-  getDocumentTitles,
-  getDocumentTitle,
-  getDocumentSections,
-  getDocumentSectionBody,
-  getDocumentSectionDefinitionByHeading,
-  getCanonicalSectionHeadings,
-  renderDocumentSectionHeading,
-  renderDocumentTitle,
-  appendDocumentSectionItem,
-  parseFrontmatter,
-  countCheckboxes,
-  classifyVerifyCheckboxes,
-  collectVerifyCheckboxLines,
-  getOpenCheckboxes,
-  extractBlockerLines,
-  hasMeaningfulBlockerBody,
-  hasMeaningfulBlockers,
-  isEmptyBlockerLine,
-  detectDeltaSections,
-  parseScenarios,
-  ManagedPathError,
-  inspectManagedDirectory,
-  requireManagedDirectory,
-  inspectManagedFile,
-  requireManagedFile,
-  ensureManagedFile,
-  writeManagedFile,
-  resolveManagedDirectoryChain,
-  inspectManagedFileTree,
-  DEFAULT_DECISION_RECORDS_PATH,
-  resolveDecisionRecordsPath,
-  ensureDecisionRecordsDirectory,
-  validateDecisionRecordsFilesystemPath,
-  pc,
-  PKG_ROOT,
-  RSP_DIR,
-  RSP_RULES_PATH,
-  OBSOLETE_RSP_RULES_PATH,
-  CHANGES_DIR,
-  FOCUS_DIR,
-  MAX_FOCUS_CAPSULE_BYTES,
-  ARCHIVES_DIR,
-  LOCK_PATH,
-  CONFIG_PATH,
-  generateConfigTemplate,
-  reconcileRspConfigDefaults,
-  loadRspConfig,
-  inspectRspConfig,
-  clearConfigCache,
-  resolveKinds,
-  resolveRequiredSections,
-  resolveManagePolicy,
-  resolveLanguagePolicy,
-  getVersion,
-  toErrorMessage,
-  emitJson
-};