@oevery/rsp 3.3.0 → 4.1.0

package/dist/{chunk-7HXQNBIG.mjs → chunk-P3KO3GZW.mjs}

@@ -5,10 +5,191 @@ 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";
+import { stringify } from "yaml";
 
-// src/core/content.ts
-import { parse } 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 = {
@@ -44,9 +225,11 @@ var DocumentSectionCardinalityError = class extends Error {
   sectionId;
   count;
 };
-function parseRspDocument(source, schema) {
+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(source);
+  const observedHeadings = collectLevelTwoHeadings(markdown);
   const sections = /* @__PURE__ */ new Map();
   const unknownHeadings = [];
   for (let index = 0; index < observedHeadings.length; index++) {
@@ -62,11 +245,8 @@ function parseRspDocument(source, schema) {
       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
+      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);
@@ -74,10 +254,11 @@ function parseRspDocument(source, schema) {
   }
   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 titleOccurrences = collectDocumentTitles(markdown, schema.titlePrefix);
   const titles = titleOccurrences.map((title) => title.value);
   return {
     source,
+    markdown,
     schema,
     title: titles[0] ?? null,
     titles,
@@ -102,8 +283,8 @@ function getDocumentSections(document, sectionId) {
 function getDocumentSection(document, sectionId) {
   return getDocumentSections(document, sectionId)[0];
 }
-function getDocumentSectionBody(document, sectionId) {
-  return getDocumentSection(document, sectionId)?.body ?? "";
+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);
@@ -130,24 +311,33 @@ function appendDocumentSectionItem(document, sectionId, item) {
   return `${before}${separator}${item}
 ${document.source.slice(insertAt)}`;
 }
-function collectLevelTwoHeadings(source) {
+function collectLevelTwoHeadings(document) {
   const headings = [];
-  const pattern = /^## ([^\r\n]+)\r?$/gm;
-  let match;
-  while ((match = pattern.exec(source)) !== null) {
-    const heading = match[1].trimEnd();
+  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 === match[1],
-      start: match.index,
-      end: match.index + match[0].length
+      canonical: heading === value,
+      start: node.position.start.offset,
+      end: node.position.end.offset
     });
   }
   return headings;
 }
-function collectDocumentTitles(source, prefix) {
+function collectDocumentTitles(document, prefix) {
   const titles = [];
-  for (const line of source.split(/\r?\n/)) {
+  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;
@@ -166,110 +356,185 @@ function lineBreakStart(source, headingStart) {
   return headingStart;
 }
 
-// src/core/content.ts
-function parseYamlText(text) {
-  const parsed = parse(text);
-  if (parsed === null || parsed === void 0)
+// 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 parsed !== "object" || Array.isArray(parsed))
+  if (typeof value !== "object" || Array.isArray(value))
     throw new Error("YAML document must be a mapping/object");
-  return parsed;
+  return value;
+}
+
+// src/core/content.ts
+function parseYamlText(text) {
+  return yamlMapping(parseYamlDocument(text));
 }
 function parseFrontmatter(content) {
-  const m = content.match(/^---\r?\n([\s\S]*?)\r?\n(?:---|\.\.\.)\r?\n/);
-  if (!m)
-    return null;
-  return parseYamlText(m[1]);
+  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) {
-  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
-  };
+  return countCheckboxItems(collectCheckboxItems(content));
 }
-function collectVerifyCheckboxLines(sectionText) {
-  const required = [];
-  const optional = [];
-  const unclassified = [];
+function collectVerifyCheckboxes(content) {
+  const document = parseMarkdown(content);
+  const buckets = { required: [], optional: [], 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;
+  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 (!/^- \[[ /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 };
+    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(sectionText) {
-  return sectionText.split("\n").map((line) => line.trim()).filter((line) => /^- \[[ /]\]/.test(line));
+function getOpenCheckboxes(content) {
+  return openCheckboxLines(collectCheckboxItems(content));
 }
-function extractBlockerLines(content) {
-  const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
-  return normalizeBlockerBody(getDocumentSectionBody(document, "blockers"));
+function changeDocument(content) {
+  return typeof content === "string" ? parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA) : content;
 }
 function hasMeaningfulBlockerBody(body) {
-  return hasMeaningfulBlockerLines(normalizeBlockerBody(body));
+  return readBlockerEntries(body).length > 0;
 }
-function normalizeBlockerBody(body) {
-  return body.replace(/<!--[\s\S]*?-->/g, "").split("\n").map((line) => line.trim()).filter(Boolean);
+function getVisibleBodyLines(body) {
+  return visibleMarkdownLines(body);
 }
 function hasMeaningfulBlockers(content) {
-  return hasMeaningfulBlockerLines(extractBlockerLines(content));
+  return hasMeaningfulBlockerBody(getDocumentSectionMarkdown(changeDocument(content), "blockers"));
 }
 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));
+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 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)
-  };
+  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 = [];
-  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 });
+  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;
+  return scenarios.filter((item) => item.steps.length > 0);
 }
 
 // src/core/decisions.ts
@@ -385,11 +650,11 @@ async function inspectManagedFileTree(root, label, options = {}) {
   if (!rootInspection.exists)
     return result;
   result.rootExists = true;
-  await collectManagedFiles(root, label, result);
+  await collectManagedFiles(root, label, result, options.includeHidden);
   result.files.sort();
   return result;
 }
-async function collectManagedFiles(directory, label, result) {
+async function collectManagedFiles(directory, label, result, includeHidden = false) {
   let entries;
   try {
     entries = await readdir(directory, { withFileTypes: true });
@@ -399,11 +664,11 @@ async function collectManagedFiles(directory, label, result) {
     return;
   }
   for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-    if (entry.name.startsWith("."))
+    if (!includeHidden && entry.name.startsWith("."))
       continue;
     const path = join(directory, entry.name);
     if (entry.isDirectory()) {
-      await collectManagedFiles(path, label, result);
+      await collectManagedFiles(path, label, result, includeHidden);
       continue;
     }
     if (entry.isFile()) {
@@ -448,21 +713,6 @@ 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);
@@ -496,18 +746,18 @@ 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 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" },
-  manage: { activation: "auto", closeout: "local" }
+  workflow: { delegation: "off", closeout: "ask" }
 };
 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 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:
@@ -528,12 +778,12 @@ ${renderedKinds}
 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}
+# 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.
@@ -543,102 +793,8 @@ ${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 DELEGATION_POLICIES = ["off", "auto"];
+var CLOSEOUT_POLICIES = ["ask", "auto", "manual"];
 var _configCache = null;
 async function loadRspConfig() {
   const inspection = await inspectRspConfig();
@@ -664,17 +820,17 @@ async function inspectRspConfig(cwd = process.cwd()) {
   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 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 activation = MANAGE_ACTIVATIONS.includes(manageValue?.activation) ? manageValue?.activation : void 0;
-  const closeout = MANAGE_CLOSEOUTS.includes(manageValue?.closeout) ? manageValue?.closeout : 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,
-      manage: manageValue ? { activation, closeout } : void 0,
+      workflow: workflowValue ? { delegation, closeout } : void 0,
       language: parseLanguageConfig(languageValue)
     },
     issues
@@ -684,9 +840,11 @@ async function inspectRspConfig(cwd = process.cwd()) {
 }
 function validateRspConfig(parsed) {
   const issues = [];
-  const supported = /* @__PURE__ */ new Set(["kinds", "decisions", "manage", "language"]);
+  const supported = /* @__PURE__ */ new Set(["kinds", "decisions", "workflow", "language"]);
   for (const key of Object.keys(parsed)) {
-    if (key === "required_sections") {
+    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`);
@@ -707,20 +865,20 @@ function validateRspConfig(parsed) {
   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');
+  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 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`);
+      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 ("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 ("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) {
@@ -752,12 +910,12 @@ function resolveKinds(config) {
 function resolveRequiredSections(_config) {
   return [...DEFAULT_REQUIRED_SECTIONS];
 }
-function resolveManagePolicy(config, options = {}) {
+function resolveWorkflowPolicy(config, options = {}) {
   if (options.configValid === false)
-    return { ...INVALID_CONFIG_MANAGE_POLICY };
+    return { ...INVALID_CONFIG_WORKFLOW_POLICY };
   return {
-    activation: config.manage?.activation ?? LEGACY_MISSING_CONFIG_MANAGE_POLICY.activation,
-    closeout: config.manage?.closeout ?? LEGACY_MISSING_CONFIG_MANAGE_POLICY.closeout
+    delegation: config.workflow?.delegation ?? DEFAULT_WORKFLOW_POLICY.delegation,
+    closeout: config.workflow?.closeout ?? DEFAULT_WORKFLOW_POLICY.closeout
   };
 }
 function resolveLanguagePolicy(config, options = {}) {
@@ -796,18 +954,15 @@ async function getVersion() {
   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 {
+  parseMarkdown,
+  walkMarkdown,
+  isMarkdownComment,
+  markdownTopLevelComments,
+  markdownText,
+  visibleMarkdownSource,
+  markdownListItems,
+  markdownProse,
   CHANGE_DOCUMENT_SCHEMA,
   GROUP_BRIEF_DOCUMENT_SCHEMA,
   DocumentSectionCardinalityError,
@@ -815,7 +970,7 @@ export {
   getDocumentTitles,
   getDocumentTitle,
   getDocumentSections,
-  getDocumentSectionBody,
+  getDocumentSectionMarkdown,
   getDocumentSectionDefinitionByHeading,
   getCanonicalSectionHeadings,
   renderDocumentSectionHeading,
@@ -823,13 +978,14 @@ export {
   appendDocumentSectionItem,
   parseFrontmatter,
   countCheckboxes,
-  classifyVerifyCheckboxes,
-  collectVerifyCheckboxLines,
+  collectVerifyCheckboxes,
+  summarizeVerifyCheckboxes,
+  openCheckboxLines,
   getOpenCheckboxes,
-  extractBlockerLines,
   hasMeaningfulBlockerBody,
+  getVisibleBodyLines,
   hasMeaningfulBlockers,
-  isEmptyBlockerLine,
+  readBlockerEntries,
   detectDeltaSections,
   parseScenarios,
   ManagedPathError,
@@ -843,7 +999,6 @@ export {
   inspectManagedFileTree,
   DEFAULT_DECISION_RECORDS_PATH,
   resolveDecisionRecordsPath,
-  ensureDecisionRecordsDirectory,
   validateDecisionRecordsFilesystemPath,
   pc,
   PKG_ROOT,
@@ -857,15 +1012,12 @@ export {
   LOCK_PATH,
   CONFIG_PATH,
   generateConfigTemplate,
-  reconcileRspConfigDefaults,
   loadRspConfig,
   inspectRspConfig,
   clearConfigCache,
   resolveKinds,
   resolveRequiredSections,
-  resolveManagePolicy,
+  resolveWorkflowPolicy,
   resolveLanguagePolicy,
-  getVersion,
-  toErrorMessage,
-  emitJson
+  getVersion
 };