@oevery/rsp 4.0.0 → 4.2.0

package/dist/chunk-P3KO3GZW.mjs

@@ -0,0 +1,1023 @@
+#!/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 { stringify } from "yaml";
+
+// src/core/markdown.mjs
+import { fromHtml } from "hast-util-from-html";
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { frontmatterFromMarkdown } from "mdast-util-frontmatter";
+import { gfmFromMarkdown } from "mdast-util-gfm";
+import { frontmatter } from "micromark-extension-frontmatter";
+import { gfm } from "micromark-extension-gfm";
+var htmlTokenAnalyses = /* @__PURE__ */ new WeakMap();
+var matters = ["yaml", { type: "yaml", fence: { open: "---", close: "..." } }];
+var extensions = [gfm(), frontmatter(matters)];
+var mdastExtensions = [gfmFromMarkdown(), frontmatterFromMarkdown(matters)];
+function parseMarkdown(input, options = {}) {
+  if (typeof input !== "string")
+    return input;
+  const syntax = options.frontmatter === false ? { extensions: [gfm()], mdastExtensions: [gfmFromMarkdown()] } : { extensions, mdastExtensions };
+  return { source: input, root: fromMarkdown(input, syntax), start: 0, end: input.length };
+}
+function walkMarkdown(node, visit) {
+  if (visit(node) === false)
+    return;
+  if ("children" in node) {
+    for (const child of node.children)
+      walkMarkdown(child, visit);
+  }
+}
+function markdownNodeSource(input, node) {
+  const { source } = parseMarkdown(input);
+  return source.slice(node.position?.start.offset ?? 0, node.position?.end.offset ?? 0);
+}
+function isMarkdownComment(node) {
+  return node.type === "html" && !readHtmlToken(node, node.value).maskedSource.trim();
+}
+function htmlComments(value) {
+  if (!value.includes("<!--"))
+    return [];
+  const comments = [];
+  function visit(node, topLevel) {
+    if (node.type === "comment" && node.position)
+      comments.push({ start: node.position.start.offset ?? 0, end: node.position.end.offset ?? value.length, topLevel });
+    if ("children" in node)
+      node.children.forEach((child) => visit(child, node.type === "root"));
+  }
+  visit(fromHtml(value, { fragment: true }), false);
+  return comments;
+}
+function readHtmlToken(node, value) {
+  let analyses = htmlTokenAnalyses.get(node);
+  const cached = analyses?.get(value);
+  if (cached)
+    return cached;
+  const comments = htmlComments(value);
+  const analysis = {
+    comments,
+    maskedSource: maskSourceRanges(value, comments.map((comment) => [comment.start, comment.end]), 0, value.length)
+  };
+  if (!analyses) {
+    analyses = /* @__PURE__ */ new Map();
+    htmlTokenAnalyses.set(node, analyses);
+  }
+  analyses.set(value, analysis);
+  return analysis;
+}
+function markdownTopLevelComments(input) {
+  const document = parseMarkdown(input);
+  return document.root.children.flatMap((node) => {
+    if (node.type !== "html")
+      return [];
+    const source = markdownNodeSource(document, node);
+    const offset = node.position?.start.offset ?? document.start;
+    return readHtmlToken(node, source).comments.filter((comment) => comment.topLevel).map((comment) => ({
+      start: offset + comment.start,
+      end: offset + comment.end,
+      source: source.slice(comment.start, comment.end)
+    }));
+  });
+}
+function maskSourceRanges(source, ranges, start, end) {
+  let result = "";
+  let offset = start;
+  for (const [from, until] of ranges.sort((a, b) => a[0] - b[0])) {
+    result += source.slice(offset, from);
+    result += source.slice(from, until).replace(/[^\r\n]/g, " ");
+    offset = until;
+  }
+  return result + source.slice(offset, end);
+}
+function markdownText(node) {
+  if (node.type === "yaml")
+    return "";
+  if (node.type === "html")
+    return readHtmlToken(node, node.value).maskedSource;
+  if (node.type === "image" || node.type === "imageReference")
+    return node.alt ?? "";
+  if ("value" in node)
+    return node.value;
+  if ("children" in node) {
+    const separator = ["root", "list", "listItem", "blockquote"].includes(node.type) ? "\n" : "";
+    return node.children.map((child) => markdownText(child)).filter(Boolean).join(separator);
+  }
+  return node.type === "break" ? "\n" : "";
+}
+function markdownSection(document, nodes, start, end) {
+  return { source: document.source, root: { type: "root", children: nodes }, start, end };
+}
+function visibleMarkdownSource(input, options = {}) {
+  const document = parseMarkdown(input);
+  const visibleNodes = /* @__PURE__ */ new Set();
+  function markVisibleContent(node) {
+    if (node.type === "yaml" || node.type === "code" && !options.includeCode)
+      return false;
+    let visible = false;
+    if (node.type === "image" || node.type === "imageReference" || node.type === "footnoteReference")
+      visible = true;
+    else if (node.type === "html")
+      visible = !isMarkdownComment(node);
+    else if ("value" in node)
+      visible = Boolean(node.value.trim());
+    else if ("children" in node)
+      visible = node.children.map(markVisibleContent).some(Boolean);
+    if (visible)
+      visibleNodes.add(node);
+    return visible;
+  }
+  markVisibleContent(document.root);
+  const ranges = [];
+  walkMarkdown(document.root, (node) => {
+    if (!visibleNodes.has(node)) {
+      const start = Math.max(document.start, node.position?.start.offset ?? document.start);
+      const end = Math.min(document.end, node.position?.end.offset ?? document.end);
+      if (end > start)
+        ranges.push([start, end]);
+      return false;
+    }
+    if (node.type === "html") {
+      const nodeStart = node.position?.start.offset ?? document.start;
+      for (const comment of readHtmlToken(node, markdownNodeSource(document, node)).comments)
+        ranges.push([nodeStart + comment.start, nodeStart + comment.end]);
+      return false;
+    }
+  });
+  return maskSourceRanges(document.source, ranges, document.start, document.end);
+}
+function visibleMarkdownLines(input) {
+  return visibleMarkdownSource(input).split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+}
+function markdownListItems(input) {
+  const document = parseMarkdown(input);
+  const items = [];
+  walkMarkdown(document.root, (node) => {
+    if (node.type === "blockquote" || node.type === "footnoteDefinition")
+      return false;
+    if (node.type === "listItem") {
+      const source = markdownNodeSource(document, node);
+      items.push({ node, line: source.split(/\r?\n/, 1)[0].trim() });
+    }
+  });
+  return items;
+}
+function markdownFrontmatter(input) {
+  const document = parseMarkdown(input);
+  const node = document.root.children[0];
+  if (node?.type !== "yaml" || node.position?.start.offset !== 0)
+    return null;
+  const raw = markdownNodeSource(document, node);
+  const lines = raw.split(/\r?\n/);
+  if (lines[0] !== "---" || !["---", "..."].includes(lines.at(-1) ?? ""))
+    return null;
+  let end = node.position.end.offset ?? raw.length;
+  if (document.source.slice(end, end + 2) === "\r\n")
+    end += 2;
+  else if (document.source[end] === "\n")
+    end++;
+  return { node, value: node.value, end };
+}
+function markdownProse(input) {
+  const document = parseMarkdown(input);
+  const fragments = [];
+  walkMarkdown(document.root, (node) => {
+    if (node.type === "text" || node.type === "html")
+      fragments.push({ value: markdownText(node), line: node.position?.start.line ?? 1 });
+  });
+  return fragments;
+}
+
+// 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(input, schema) {
+  const markdown = parseMarkdown(input);
+  const source = markdown.source;
+  const definitionsByHeading = new Map(schema.sections.map((definition) => [definition.heading, definition]));
+  const observedHeadings = collectLevelTwoHeadings(markdown);
+  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,
+      bodyEnd,
+      markdown: markdownSection(markdown, markdown.root.children.filter((node) => (node.position?.start.offset ?? 0) >= observed.end && (node.position?.end.offset ?? source.length) <= bodyEnd), 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(markdown, schema.titlePrefix);
+  const titles = titleOccurrences.map((title) => title.value);
+  return {
+    source,
+    markdown,
+    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 getDocumentSectionMarkdown(document, sectionId) {
+  return getDocumentSection(document, sectionId)?.markdown ?? markdownSection(document.markdown, [], 0, 0);
+}
+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(document) {
+  const headings = [];
+  for (const node of document.root.children) {
+    if (node.type !== "heading" || node.depth !== 2 || node.position?.start.column !== 1)
+      continue;
+    const raw = markdownNodeSource(document, node);
+    if (!raw.startsWith("## ") || raw.includes("\n"))
+      continue;
+    const value = raw.slice(3);
+    const heading = value.trimEnd();
+    headings.push({
+      heading,
+      canonical: heading === value,
+      start: node.position.start.offset,
+      end: node.position.end.offset
+    });
+  }
+  return headings;
+}
+function collectDocumentTitles(document, prefix) {
+  const titles = [];
+  for (const node of document.root.children) {
+    if (node.type !== "heading" || node.depth !== 1)
+      continue;
+    const start = node.position.start.offset;
+    const lineStart = document.source.lastIndexOf("\n", start - 1) + 1;
+    const line = document.source.slice(lineStart, node.position.end.offset);
+    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/yaml.mjs
+import { parseDocument } from "yaml";
+function parseYamlDocument(source) {
+  const document = parseDocument(source, { keepSourceTokens: true });
+  if (document.errors.length)
+    throw new Error(document.errors.map((error) => error.message).join("; "));
+  return document;
+}
+function yamlMapping(document) {
+  const value = document.toJS();
+  if (value === null || value === void 0)
+    return {};
+  if (typeof value !== "object" || Array.isArray(value))
+    throw new Error("YAML document must be a mapping/object");
+  return value;
+}
+
+// src/core/content.ts
+function parseYamlText(text) {
+  return yamlMapping(parseYamlDocument(text));
+}
+function parseFrontmatter(content) {
+  const matter = markdownFrontmatter(content);
+  return matter ? parseYamlText(matter.value) : null;
+}
+function checkboxItem(line) {
+  const marker = line.match(/^[-*+]\s+\[([ /x-])\]/i);
+  return marker ? { state: marker[1].toLowerCase(), line } : null;
+}
+function collectCheckboxItems(content) {
+  return markdownListItems(content).flatMap(({ line }) => {
+    const item = checkboxItem(line);
+    return item ? [item] : [];
+  });
+}
+function countCheckboxItems(items) {
+  const count = { todo: 0, progress: 0, done: 0, dropped: 0, total: items.length };
+  for (const { state } of items) {
+    if (state === " ")
+      count.todo++;
+    else if (state === "/")
+      count.progress++;
+    else if (state === "x")
+      count.done++;
+    else
+      count.dropped++;
+  }
+  return count;
+}
+function countCheckboxes(content) {
+  return countCheckboxItems(collectCheckboxItems(content));
+}
+function collectVerifyCheckboxes(content) {
+  const document = parseMarkdown(content);
+  const buckets = { required: [], optional: [], unclassified: [] };
+  let current = "unclassified";
+  let sawClassificationHeading = false;
+  walkMarkdown(document.root, (node) => {
+    if (node.type === "blockquote" || node.type === "footnoteDefinition")
+      return false;
+    if (node.type === "heading" && node.depth === 3 && node.position?.start.column === 1) {
+      const heading = markdownNodeSource(document, node).match(/^###\s+(Required|Optional)\s*$/i);
+      if (heading) {
+        current = heading[1].toLowerCase();
+        sawClassificationHeading = true;
+      }
+    }
+    if (node.type === "listItem") {
+      const line = markdownNodeSource(document, node).split(/\r?\n/, 1)[0].trim();
+      const item = checkboxItem(line);
+      if (item)
+        buckets[current].push(item);
+    }
+  });
+  return { ...buckets, legacy: buckets.unclassified.length > 0 || !sawClassificationHeading };
+}
+function summarizeVerifyCheckboxes(buckets) {
+  return {
+    required: countCheckboxItems([...buckets.required, ...buckets.unclassified]),
+    optional: countCheckboxItems(buckets.optional),
+    unclassified: countCheckboxItems(buckets.unclassified),
+    legacy: buckets.legacy
+  };
+}
+function openCheckboxLines(items) {
+  return items.filter((item) => item.state === " " || item.state === "/").map((item) => item.line);
+}
+function getOpenCheckboxes(content) {
+  return openCheckboxLines(collectCheckboxItems(content));
+}
+function changeDocument(content) {
+  return typeof content === "string" ? parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA) : content;
+}
+function hasMeaningfulBlockerBody(body) {
+  return readBlockerEntries(body).length > 0;
+}
+function getVisibleBodyLines(body) {
+  return visibleMarkdownLines(body);
+}
+function hasMeaningfulBlockers(content) {
+  return hasMeaningfulBlockerBody(getDocumentSectionMarkdown(changeDocument(content), "blockers"));
+}
+function isEmptyBlockerLine(line) {
+  const normalized = line.trim();
+  return /^none[.。]?$/i.test(normalized) || /^[-*]\s*(?:none[.。]?)?$/i.test(normalized);
+}
+var REQUIRES_RE = /^[-*]\s+requires\s+`([^`]+)`:[ \t]*(\S.*)$/i;
+function readBlockerEntries(input) {
+  const document = parseMarkdown(input);
+  const entries = [];
+  const nodeLines = (node, start = node.position.start.offset) => getVisibleBodyLines(
+    markdownSection(document, [node], start, node.position.end.offset)
+  );
+  const text = (line) => line.replace(/^[-*]\s+/, "").trim();
+  const appendExternal = (lines) => {
+    for (const line of lines) {
+      if (!isEmptyBlockerLine(line))
+        entries.push({ kind: "external", line, text: text(line) });
+    }
+  };
+  const visit = (node) => {
+    if (node.type === "code")
+      return;
+    if (node.type !== "list") {
+      appendExternal(nodeLines(node));
+      return;
+    }
+    for (const item of node.children) {
+      for (const [index, child] of item.children.entries()) {
+        if (child.type === "list" || child.type === "code") {
+          visit(child);
+          continue;
+        }
+        const lines = nodeLines(child, index === 0 ? item.position.start.offset : child.position.start.offset);
+        if (index === 0 && child.type === "paragraph") {
+          const line = lines[0] ?? "";
+          const dependency = line.match(REQUIRES_RE);
+          if (dependency) {
+            entries.push({ kind: "dependency", line, text: text(line), name: dependency[1], reason: dependency[2] });
+            lines.shift();
+          } else if (/^[-*]\s+requires\b/i.test(line)) {
+            entries.push({ kind: "malformed-dependency", line, text: text(line) });
+            lines.shift();
+          }
+        }
+        appendExternal(lines);
+      }
+    }
+  };
+  document.root.children.forEach(visit);
+  return entries;
+}
+function detectDeltaSections(content) {
+  const body = getDocumentSectionMarkdown(changeDocument(content), "spec");
+  const labels = new Set(body.root.children.filter((node) => node.type === "heading" && node.depth === 3).map((node) => markdownText(node).trim().toUpperCase()));
+  return { added: labels.has("ADDED"), modified: labels.has("MODIFIED"), removed: labels.has("REMOVED") };
+}
+function parseScenarios(content) {
+  const document = parseMarkdown(content);
+  const scenarios = [];
+  let scenario = null;
+  for (const node of document.root.children) {
+    if (node.type === "heading" && node.depth <= 4) {
+      const title = markdownText(node);
+      scenario = (node.depth === 3 || node.depth === 4) && /^Scenario:\s*\S/i.test(title) ? { heading: title.slice(title.indexOf(":") + 1).trim(), steps: [] } : null;
+      if (scenario)
+        scenarios.push(scenario);
+      continue;
+    }
+    if (scenario && node.type === "list") {
+      for (const item of node.children) {
+        const line = markdownNodeSource(document, item).split(/\r?\n/, 1)[0].trim();
+        const step = line.replace(/^[-*+]\s+/, "");
+        if (/^(?:GIVEN|WHEN|THEN|AND|BUT)\b/i.test(step))
+          scenario.steps.push(step);
+      }
+    }
+  }
+  return scenarios.filter((item) => item.steps.length > 0);
+}
+
+// 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, options.includeHidden);
+  result.files.sort();
+  return result;
+}
+async function collectManagedFiles(directory, label, result, includeHidden = false) {
+  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 (!includeHidden && entry.name.startsWith("."))
+      continue;
+    const path = join(directory, entry.name);
+    if (entry.isDirectory()) {
+      await collectManagedFiles(path, label, result, includeHidden);
+      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 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 DEFAULT_WORKFLOW_POLICY = { delegation: "off", closeout: "ask" };
+var INVALID_CONFIG_WORKFLOW_POLICY = { delegation: "off", closeout: "manual" };
+var CONFIG_DEFAULTS = {
+  kinds: [],
+  decisions: { path: ".rsp/specs/decisions" },
+  language: { default: "en" },
+  workflow: { delegation: "off", closeout: "ask" }
+};
+function generateConfigTemplate(config = {}) {
+  const kinds = config.kinds ?? CONFIG_DEFAULTS.kinds;
+  const decisions = { ...CONFIG_DEFAULTS.decisions, ...config.decisions };
+  const workflow = { ...CONFIG_DEFAULTS.workflow, ...config.workflow };
+  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()}
+
+# Automatic delegation is off; explicit worker requests remain allowed.
+# Closeout applies only to established final delivery: ask, auto, or manual.
+# Ordinary completion and checkpoint commits keep work open. No setting grants Git authority.
+workflow:
+  delegation: ${workflow.delegation}
+  closeout: ${workflow.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 DELEGATION_POLICIES = ["off", "auto"];
+var CLOSEOUT_POLICIES = ["ask", "auto", "manual"];
+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 workflowValue = parsed.workflow && typeof parsed.workflow === "object" && !Array.isArray(parsed.workflow) ? parsed.workflow : void 0;
+  const languageValue = parsed.language && typeof parsed.language === "object" && !Array.isArray(parsed.language) ? parsed.language : void 0;
+  const delegation = DELEGATION_POLICIES.includes(workflowValue?.delegation) ? workflowValue?.delegation : void 0;
+  const closeout = CLOSEOUT_POLICIES.includes(workflowValue?.closeout) ? workflowValue?.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,
+      workflow: workflowValue ? { delegation, closeout } : void 0,
+      language: parseLanguageConfig(languageValue)
+    },
+    issues
+  };
+  _configCache = { cwd, inspection };
+  return inspection;
+}
+function validateRspConfig(parsed) {
+  const issues = [];
+  const supported = /* @__PURE__ */ new Set(["kinds", "decisions", "workflow", "language"]);
+  for (const key of Object.keys(parsed)) {
+    if (key === "manage") {
+      issues.push('config.yaml field "manage" requires explicit migration: remove manage and choose workflow.delegation (off | auto) and workflow.closeout (ask | auto | manual); recommended defaults are off/ask. Old local closeout no longer grants Git authority. rsp update will not convert it automatically');
+    } else 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 ("workflow" in parsed) {
+    if (!parsed.workflow || typeof parsed.workflow !== "object" || Array.isArray(parsed.workflow)) {
+      issues.push('config.yaml field "workflow" must be a YAML mapping');
+    } else {
+      const workflow = parsed.workflow;
+      const supportedWorkflowFields = /* @__PURE__ */ new Set(["delegation", "closeout"]);
+      for (const key of Object.keys(workflow)) {
+        if (!supportedWorkflowFields.has(key))
+          issues.push(`config.yaml field "workflow.${key}" is not supported`);
+      }
+      if ("delegation" in workflow && !DELEGATION_POLICIES.includes(workflow.delegation))
+        issues.push('config.yaml field "workflow.delegation" must be one of: off, auto');
+      if ("closeout" in workflow && !CLOSEOUT_POLICIES.includes(workflow.closeout))
+        issues.push('config.yaml field "workflow.closeout" must be one of: ask, auto, manual');
+    }
+  }
+  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 resolveWorkflowPolicy(config, options = {}) {
+  if (options.configValid === false)
+    return { ...INVALID_CONFIG_WORKFLOW_POLICY };
+  return {
+    delegation: config.workflow?.delegation ?? DEFAULT_WORKFLOW_POLICY.delegation,
+    closeout: config.workflow?.closeout ?? DEFAULT_WORKFLOW_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;
+}
+
+export {
+  parseMarkdown,
+  walkMarkdown,
+  isMarkdownComment,
+  markdownTopLevelComments,
+  markdownText,
+  visibleMarkdownSource,
+  markdownListItems,
+  markdownProse,
+  CHANGE_DOCUMENT_SCHEMA,
+  GROUP_BRIEF_DOCUMENT_SCHEMA,
+  DocumentSectionCardinalityError,
+  parseRspDocument,
+  getDocumentTitles,
+  getDocumentTitle,
+  getDocumentSections,
+  getDocumentSectionMarkdown,
+  getDocumentSectionDefinitionByHeading,
+  getCanonicalSectionHeadings,
+  renderDocumentSectionHeading,
+  renderDocumentTitle,
+  appendDocumentSectionItem,
+  parseFrontmatter,
+  countCheckboxes,
+  collectVerifyCheckboxes,
+  summarizeVerifyCheckboxes,
+  openCheckboxLines,
+  getOpenCheckboxes,
+  hasMeaningfulBlockerBody,
+  getVisibleBodyLines,
+  hasMeaningfulBlockers,
+  readBlockerEntries,
+  detectDeltaSections,
+  parseScenarios,
+  ManagedPathError,
+  inspectManagedDirectory,
+  requireManagedDirectory,
+  inspectManagedFile,
+  requireManagedFile,
+  ensureManagedFile,
+  writeManagedFile,
+  resolveManagedDirectoryChain,
+  inspectManagedFileTree,
+  DEFAULT_DECISION_RECORDS_PATH,
+  resolveDecisionRecordsPath,
+  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,
+  loadRspConfig,
+  inspectRspConfig,
+  clearConfigCache,
+  resolveKinds,
+  resolveRequiredSections,
+  resolveWorkflowPolicy,
+  resolveLanguagePolicy,
+  getVersion
+};