@oevery/rsp 3.3.0 → 4.0.0

package/dist/{chunk-TSUDEX5Y.mjs → chunk-HFSTLCCK.mjs}

@@ -1,80 +1,1004 @@
 #!/usr/bin/env node
-import {
-  ARCHIVES_DIR,
-  CHANGES_DIR,
-  CHANGE_DOCUMENT_SCHEMA,
-  CONFIG_PATH,
-  DEFAULT_DECISION_RECORDS_PATH,
-  FOCUS_DIR,
-  GROUP_BRIEF_DOCUMENT_SCHEMA,
-  ManagedPathError,
-  OBSOLETE_RSP_RULES_PATH,
-  RSP_DIR,
-  RSP_RULES_PATH,
-  classifyVerifyCheckboxes,
-  collectVerifyCheckboxLines,
-  countCheckboxes,
-  extractBlockerLines,
-  getCanonicalSectionHeadings,
-  getDocumentSectionBody,
-  getDocumentTitle,
-  getDocumentTitles,
-  getOpenCheckboxes,
-  hasMeaningfulBlockerBody,
-  hasMeaningfulBlockers,
-  inspectManagedDirectory,
-  inspectManagedFile,
-  inspectManagedFileTree,
-  inspectRspConfig,
-  isEmptyBlockerLine,
-  parseFrontmatter,
-  parseRspDocument,
-  parseScenarios,
-  pc,
-  renderDocumentSectionHeading,
-  renderDocumentTitle,
-  requireManagedDirectory,
-  requireManagedFile,
-  resolveDecisionRecordsPath,
-  resolveLanguagePolicy,
-  resolveManagePolicy,
-  toErrorMessage,
-  validateDecisionRecordsFilesystemPath
-} from "./chunk-7HXQNBIG.mjs";
+
+// 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;
+}
 
 // src/status/inspect.ts
-import { readFile as readFile4, stat } from "fs/promises";
+import { readFile as readFile5, stat as stat2 } from "fs/promises";
 
 // src/core/change-group.ts
-import { readFile as readFile2 } from "fs/promises";
-import { dirname as dirname2, join as join3, relative as relative3 } from "path";
+import { readFile as readFile3 } from "fs/promises";
+import { dirname as dirname4, join as join6, relative as relative4 } from "path";
+
+// src/core/filesystem.ts
+import { existsSync as existsSync2 } from "fs";
+import { readdir as readdir3, readFile as readFile2, rmdir } from "fs/promises";
+import { basename, dirname as dirname3, join as join4, relative as relative2, sep as sep2 } from "path";
+
+// 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)}
+`);
+}
 
 // src/core/filesystem.ts
-import { existsSync } from "fs";
-import { readdir, readFile, rmdir } from "fs/promises";
-import { basename, dirname, join, relative, sep } from "path";
 async function walkMarkdownFiles(dir, options = {}) {
   const all = await walkFiles(dir, options);
   return all.filter((f) => f.endsWith(".md"));
 }
 async function inspectUnsupportedRules() {
-  const rulesDir = join(RSP_DIR, "rules");
+  const rulesDir = join4(RSP_DIR, "rules");
   const diagnostics = [];
   const rawEntries = await walkAllEntries(rulesDir, diagnostics);
-  const entries = rawEntries.filter((entry) => entry.path !== OBSOLETE_RSP_RULES_PATH).map((entry) => ({ path: normalizeLogicalPath(relative(rulesDir, entry.path)), kind: entry.kind }));
-  const obsoleteFallbackPresent = existsSync(OBSOLETE_RSP_RULES_PATH);
+  const entries = rawEntries.filter((entry) => entry.path !== OBSOLETE_RSP_RULES_PATH).map((entry) => ({ path: normalizeLogicalPath(relative2(rulesDir, entry.path)), kind: entry.kind }));
   return {
     entries,
     diagnostics,
-    directoryRemaining: existsSync(rulesDir) && (!obsoleteFallbackPresent || entries.length > 0)
+    directoryRemaining: entries.length > 0
   };
 }
 async function walkAllEntries(dir, diagnostics) {
   const entries = [];
   try {
-    const items = await readdir(dir, { withFileTypes: true });
+    const items = await readdir3(dir, { withFileTypes: true });
     for (const item of items) {
-      const path = join(dir, item.name);
+      const path = join4(dir, item.name);
       const kind = item.isDirectory() ? "directory" : "file";
       entries.push({ path, kind });
       if (kind === "directory")
@@ -90,11 +1014,11 @@ async function walkAllEntries(dir, diagnostics) {
 async function walkFiles(dir, options = {}) {
   const files = [];
   try {
-    const items = await readdir(dir, { withFileTypes: true });
+    const items = await readdir3(dir, { withFileTypes: true });
     for (const item of items) {
       if (item.name.startsWith("."))
         continue;
-      const filePath = join(dir, item.name);
+      const filePath = join4(dir, item.name);
       if (item.isDirectory())
         files.push(...await walkFiles(filePath, options));
       else
@@ -108,28 +1032,35 @@ async function walkFiles(dir, options = {}) {
   return files;
 }
 function normalizeLogicalPath(pathValue) {
-  return pathValue.split(sep).join("/").replace(/\\/g, "/");
+  return pathValue.split(sep2).join("/").replace(/\\/g, "/");
 }
 var SPEC_NAME_RE = /^[a-z0-9-]+(?:\/[a-z0-9-]+)*$/;
 function isValidSpecName(name) {
   return SPEC_NAME_RE.test(name);
 }
-function guardRspInitialized() {
-  const designPath = join(RSP_DIR, "specs", "design.md");
-  const rules = inspectManagedFile(RSP_RULES_PATH, "fallback protocol", { allowMissing: true });
+function inspectRspInitialization() {
+  const designPath = join4(RSP_DIR, "specs", "design.md");
   const design = inspectManagedFile(designPath, "design Spec", { allowMissing: true });
-  if (rules.issue || design.issue || !rules.exists || !design.exists) {
-    const initialized = existsSync(RSP_DIR);
-    console.error(`  ${pc.red("Error:")} ${initialized ? "RSP project requires an update" : "RSP is not initialized in this project"}`);
-    console.error(`  ${pc.dim(initialized ? "Run: rsp update" : "Run: rsp init")}`);
+  if (design.issue)
+    return `${design.issue.message}
+  Check path types and permissions; init/update do not repair existing user content.`;
+  if (design.exists)
+    return void 0;
+  return existsSync2(RSP_DIR) ? `${designPath} is missing.
+  Restore your design file, or run rsp init to create missing scaffolding.` : "RSP is not initialized in this project\n  Run: rsp init";
+}
+function guardRspInitialized() {
+  const issue = inspectRspInitialization();
+  if (issue) {
+    console.error(`  ${pc.red("Error:")} ${issue}`);
     process.exit(1);
   }
 }
 async function cleanupEmptyParentDirs(path, stopDir) {
-  let parent = dirname(path);
+  let parent = dirname3(path);
   while (parent !== stopDir) {
     try {
-      const remaining = await readdir(parent);
+      const remaining = await readdir3(parent);
       if (remaining.length === 0)
         await rmdir(parent);
       else
@@ -137,13 +1068,13 @@ async function cleanupEmptyParentDirs(path, stopDir) {
     } catch {
       break;
     }
-    parent = dirname(parent);
+    parent = dirname3(parent);
   }
 }
 async function detectProjectName() {
   try {
-    if (existsSync("package.json")) {
-      const raw = await readFile("package.json", "utf-8");
+    if (existsSync2("package.json")) {
+      const raw = await readFile2("package.json", "utf-8");
       const pkg = JSON.parse(raw);
       if (pkg.name && pkg.name !== "")
         return pkg.name;
@@ -155,9 +1086,9 @@ async function detectProjectName() {
 
 // src/core/work-ref.ts
 import { Buffer } from "buffer";
-import { lstatSync, readdirSync } from "fs";
-import { readdir as readdir2 } from "fs/promises";
-import { isAbsolute, join as join2, relative as relative2 } from "path";
+import { lstatSync as lstatSync2, readdirSync } from "fs";
+import { readdir as readdir4 } from "fs/promises";
+import { isAbsolute as isAbsolute2, join as join5, relative as relative3 } from "path";
 var WORK_SEGMENT_RE = /^[\p{Ll}\p{Lo}\p{Lm}\p{M}\p{Nd}]+(?:-[\p{Ll}\p{Lo}\p{Lm}\p{M}\p{Nd}]+)*$/u;
 var WORK_SEGMENT_MAX_CODE_POINTS = 100;
 var WORK_SEGMENT_MAX_UTF8_BYTES = 200;
@@ -215,7 +1146,7 @@ function resolveWorkRef(name, options = {}) {
   assertValidWorkRoot(changesDir, normalizedName);
   assertNoNormalizationCollision(changesDir, segments, normalizedName, isGroupBrief);
   assertNoIdentityCollision(changesDir, segments, normalizedName, isGroupBrief ? GROUP_BRIEF_FILENAME : void 0);
-  const path = join2(changesDir, ...segments.slice(0, -1), isGroupBrief ? GROUP_BRIEF_FILENAME : `${segments.at(-1)}.md`);
+  const path = join5(changesDir, ...segments.slice(0, -1), isGroupBrief ? GROUP_BRIEF_FILENAME : `${segments.at(-1)}.md`);
   const ref = segments.length === 1 ? { kind: "change", name: normalizedName, path, group: null } : isGroupBrief ? { kind: "group-brief", name: normalizedName, path, group: segments[0] } : { kind: "group-change", name: normalizedName, path, group: segments[0] };
   if (ref.kind === "group-change" && options.executable !== false)
     assertGroupBrief(changesDir, ref);
@@ -230,7 +1161,7 @@ function resolveWorkRef(name, options = {}) {
   return ref;
 }
 function assertGroupBrief(changesDir, ref) {
-  const briefPath = join2(changesDir, ref.group, GROUP_BRIEF_FILENAME);
+  const briefPath = join5(changesDir, ref.group, GROUP_BRIEF_FILENAME);
   const kind = getPathKind(briefPath, ref.name);
   if (kind === "missing") {
     throw new WorkRefError(
@@ -250,7 +1181,7 @@ function assertGroupBrief(changesDir, ref) {
 function assertRegularWorkFile(ref, mustExist) {
   let stats;
   try {
-    stats = lstatSync(ref.path);
+    stats = lstatSync2(ref.path);
   } catch (error) {
     if (error.code === "ENOENT") {
       if (mustExist) {
@@ -274,8 +1205,8 @@ function assertRegularWorkFile(ref, mustExist) {
 }
 function resolveWorkRefPath(path, options = {}) {
   const changesDir = options.changesDir ?? CHANGES_DIR;
-  const logicalPath = normalizeLogicalPath2(relative2(changesDir, path));
-  if (isAbsolute(logicalPath) || logicalPath === ".." || logicalPath.startsWith("../") || !logicalPath.endsWith(".md")) {
+  const logicalPath = normalizeLogicalPath2(relative3(changesDir, path));
+  if (isAbsolute2(logicalPath) || logicalPath === ".." || logicalPath.startsWith("../") || !logicalPath.endsWith(".md")) {
     throw new WorkRefError(
       "invalid_work_ref_path",
       `work path must be a Markdown file inside ${changesDir}: ${path}`,
@@ -302,13 +1233,13 @@ function resolveFocusMarkerPath(ref, options = {}) {
   assertNoManagedNormalizationCollision(focusDir, ref.name.split("/"), ref.name, "invalid_focus_path");
   if (ref.group) {
     assertOptionalManagedDirectory(
-      join2(focusDir, ref.group),
+      join5(focusDir, ref.group),
       ref.name,
       "invalid_focus_path",
       "focus path"
     );
   }
-  const markerPath = join2(focusDir, ...ref.name.split("/"));
+  const markerPath = join5(focusDir, ...ref.name.split("/"));
   try {
     requireManagedFile(markerPath, "focus marker", { allowMissing: true });
   } catch (error) {
@@ -324,7 +1255,7 @@ function resolveArchiveDirectory(ref, options = {}) {
   if (!ref.group)
     return archivesDir;
   assertNoManagedNormalizationCollision(archivesDir, [ref.group], ref.name, "invalid_archive_path");
-  const groupPath = join2(archivesDir, ref.group);
+  const groupPath = join5(archivesDir, ref.group);
   assertOptionalManagedDirectory(groupPath, ref.name, "invalid_archive_path", "archive path");
   return groupPath;
 }
@@ -343,7 +1274,7 @@ async function inspectFocusTree(options = {}) {
   if (!rootEntries)
     return result;
   for (const entry of rootEntries) {
-    const path = join2(focusDir, entry.name);
+    const path = join5(focusDir, entry.name);
     if (entry.name === ".gitkeep" && entry.isFile())
       continue;
     if (entry.isDirectory()) {
@@ -386,7 +1317,7 @@ async function inspectArchiveTree(options = {}) {
   if (!rootEntries)
     return result;
   for (const entry of rootEntries) {
-    const path = join2(archivesDir, entry.name);
+    const path = join5(archivesDir, entry.name);
     if (entry.name === "INDEX.md" && entry.isFile())
       continue;
     if (entry.isDirectory()) {
@@ -424,7 +1355,7 @@ async function inspectWorkTree(options = {}) {
   const rootMarkdownNames = new Set(rootEntries.filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => entry.name.slice(0, -3)));
   const collidingGroups = new Set([...rootDirectories].filter((name) => rootMarkdownNames.has(name)));
   for (const entry of rootEntries) {
-    const path = join2(changesDir, entry.name);
+    const path = join5(changesDir, entry.name);
     if (entry.name === ".gitkeep" && entry.isFile())
       continue;
     if (entry.isDirectory()) {
@@ -471,17 +1402,17 @@ async function inspectGroupDirectory(group, groupPath, changesDir, result, colli
       "group_brief_missing",
       `Change Group "${group}" requires a Group Brief; run: rsp group create ${group}`,
       group
-    ), join2(groupPath, GROUP_BRIEF_FILENAME));
+    ), join5(groupPath, GROUP_BRIEF_FILENAME));
   } else if (!briefEntry.isFile()) {
     addDiagnostic(result, new WorkRefError(
       "work_ref_not_file",
-      `Group Brief must be a regular file: ${join2(groupPath, GROUP_BRIEF_FILENAME)}`,
+      `Group Brief must be a regular file: ${join5(groupPath, GROUP_BRIEF_FILENAME)}`,
       group
-    ), join2(groupPath, GROUP_BRIEF_FILENAME));
+    ), join5(groupPath, GROUP_BRIEF_FILENAME));
   }
   for (const entry of entries) {
     const input = `${group}/${entry.name}`;
-    const path = join2(groupPath, entry.name);
+    const path = join5(groupPath, entry.name);
     if (entry.name === GROUP_BRIEF_FILENAME && !entry.isFile())
       continue;
     if (entry.name === "brief.md") {
@@ -510,7 +1441,7 @@ async function inspectFocusGroup(group, groupPath, changesDir, result) {
     return;
   for (const entry of entries) {
     const input = `${group}/${entry.name}`;
-    const path = join2(groupPath, entry.name);
+    const path = join5(groupPath, entry.name);
     if (entry.isDirectory()) {
       addDiagnostic(result, new WorkRefError(
         "unsupported_work_depth",
@@ -536,7 +1467,7 @@ async function inspectArchiveGroup(group, groupPath, result) {
     return;
   for (const entry of entries) {
     const input = `${group}/${entry.name}`;
-    const path = join2(groupPath, entry.name);
+    const path = join5(groupPath, entry.name);
     if (!entry.isFile() || !entry.name.endsWith(".md")) {
       addArchivePathDiagnostic(result, input, path);
       continue;
@@ -569,7 +1500,7 @@ function collectResolvedPath(path, changesDir, result) {
 }
 async function readDirectory(path, input, result) {
   try {
-    return (await readdir2(path, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
+    return (await readdir4(path, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
   } catch (error) {
     addDiagnostic(result, asReadFailure(path, input, error), path);
     return null;
@@ -630,7 +1561,7 @@ function normalizeWorkRefName(name, allowGroupBrief) {
 }
 function assertNoNormalizationCollision(changesDir, segments, input, isGroupBrief) {
   for (let depth = 0; depth < segments.length; depth++) {
-    const parent = join2(changesDir, ...segments.slice(0, depth));
+    const parent = join5(changesDir, ...segments.slice(0, depth));
     const parentKind = getPathKind(parent, input);
     if (parentKind === "missing")
       return;
@@ -663,7 +1594,7 @@ function assertNoNormalizationCollision(changesDir, segments, input, isGroupBrie
 }
 function assertNoManagedNormalizationCollision(root, segments, input, code) {
   for (let depth = 0; depth < segments.length; depth++) {
-    const parent = join2(root, ...segments.slice(0, depth));
+    const parent = join5(root, ...segments.slice(0, depth));
     const parentKind = getPathKind(parent, input);
     if (parentKind === "missing")
       return;
@@ -688,8 +1619,8 @@ function assertNoManagedNormalizationCollision(root, segments, input, code) {
 }
 function assertNoIdentityCollision(changesDir, segments, input, finalFilename) {
   for (let depth = 1; depth <= segments.length; depth++) {
-    const identityPath = join2(changesDir, ...segments.slice(0, depth));
-    const filePath = finalFilename && depth === segments.length ? join2(changesDir, ...segments.slice(0, -1), finalFilename) : `${identityPath}.md`;
+    const identityPath = join5(changesDir, ...segments.slice(0, depth));
+    const filePath = finalFilename && depth === segments.length ? join5(changesDir, ...segments.slice(0, -1), finalFilename) : `${identityPath}.md`;
     const fileKind = getPathKind(filePath, input);
     const identityKind = getPathKind(identityPath, input);
     const isPrefix = depth < segments.length;
@@ -755,7 +1686,7 @@ function assertOptionalManagedDirectory(path, input, code, label) {
 }
 function getPathKind(path, input) {
   try {
-    const stats = lstatSync(path);
+    const stats = lstatSync2(path);
     if (stats.isFile())
       return "file";
     if (stats.isDirectory())
@@ -783,13 +1714,13 @@ function normalizeLogicalPath2(path) {
 var PLACEHOLDER_SUMMARY = "<\u2026>";
 function extractChangeSummary(content, document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA), options = {}) {
   try {
-    const frontmatter = parseFrontmatter(content);
-    const frontmatterSummary = meaningfulSummary(frontmatter?.summary, options);
+    const frontmatter2 = parseFrontmatter(document.markdown);
+    const frontmatterSummary = meaningfulSummary(frontmatter2?.summary, options);
     if (frontmatterSummary)
       return frontmatterSummary;
   } catch {
   }
-  const proposalLines = getDocumentSectionBody(document, "proposal").split("\n").map((line) => line.trim());
+  const proposalLines = visibleSummaryItemLines(getDocumentSectionMarkdown(document, "proposal"));
   for (const field of ["Outcome", "Summary"]) {
     const prefix = `- ${field}:`;
     for (const line of proposalLines) {
@@ -801,7 +1732,7 @@ function extractChangeSummary(content, document = parseRspDocument(content, CHAN
   return null;
 }
 function extractGroupSummary(content, document = parseRspDocument(content, GROUP_BRIEF_DOCUMENT_SCHEMA)) {
-  for (const line of getDocumentSectionBody(document, "goal").split("\n")) {
+  for (const line of visibleSummaryItemLines(getDocumentSectionMarkdown(document, "goal"))) {
     const trimmed = line.trim();
     const summary = trimmed.startsWith("- ") || trimmed.startsWith("* ") ? meaningfulSummary(trimmed.slice(2)) : null;
     if (summary)
@@ -809,6 +1740,10 @@ function extractGroupSummary(content, document = parseRspDocument(content, GROUP
   }
   return null;
 }
+function visibleSummaryItemLines(document) {
+  const source = visibleMarkdownSource(document);
+  return markdownListItems(document).map(({ node }) => source.slice(node.position.start.offset - document.start, node.position.end.offset - document.start).split(/\r?\n/, 1)[0].trim());
+}
 function meaningfulSummary(value, options = {}) {
   if (typeof value !== "string")
     return null;
@@ -843,12 +1778,15 @@ ${groupSectionHeading("sharedConstraints")}
 - ${placeholder}
 
 ${groupSectionHeading("slices")}
+<!-- Declare at least two independently executable direct child WorkRefs before creating them; keep their Tasks and evidence in each Change. -->
 - \`${name}/<change>\`: ${placeholder}
 
 ${groupSectionHeading("completionConditions")}
+<!-- State shared completion conditions. For Group-level verification, name an Integration: condition and retain its acceptance and evidence here; child passes alone do not prove it. -->
 - [ ] ${placeholder}
 
 ${groupSectionHeading("durableOutcomes")}
+<!-- Identify current-fact and lasting-rationale owners only when an update is needed; do not duplicate child results, current Specs or execution history. -->
 - Current facts: ${placeholder}
 - Lasting rationale: ${placeholder}
 
@@ -868,12 +1806,12 @@ async function inspectChangeGroups(options = {}) {
   const archivedGroupBriefPaths = /* @__PURE__ */ new Map();
   const openGroupNames = new Set(workTree.briefs.map((brief) => brief.group));
   for (const path of archiveTree.files) {
-    const archivePath = normalizeLogicalPath(relative3(ARCHIVES_DIR, path));
+    const archivePath = normalizeLogicalPath(relative4(ARCHIVES_DIR, path));
     const archiveGroup = archivePath.includes("/") ? archivePath.split("/")[0] : null;
     if (!archiveGroup || !openGroupNames.has(archiveGroup))
       continue;
     try {
-      const content = await readFile2(path, "utf-8");
+      const content = await readFile3(path, "utf-8");
       const archivedChange = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
       const identity = getDocumentTitle(archivedChange, "identity");
       if (identity?.includes("/")) {
@@ -891,10 +1829,11 @@ async function inspectChangeGroups(options = {}) {
           archivedSlicesByGroup.set(archiveGroup, groupSlices);
         }
       }
-      if (getDocumentTitle(parseRspDocument(content, GROUP_BRIEF_DOCUMENT_SCHEMA), "identity") === archiveGroup) {
+      const archivedBrief = parseRspDocument(archivedChange.markdown, GROUP_BRIEF_DOCUMENT_SCHEMA);
+      if (getDocumentTitle(archivedBrief, "identity") === archiveGroup) {
         archivedGroups.add(archiveGroup);
         const evidence = archivedGroupReopenEvidence.get(archiveGroup) ?? /* @__PURE__ */ new Set();
-        for (const item of getGroupReopenEvidence(content))
+        for (const item of getGroupReopenEvidence(archivedBrief))
           evidence.add(item.key);
         archivedGroupReopenEvidence.set(archiveGroup, evidence);
         const retainedPaths = archivedGroupBriefPaths.get(archiveGroup) ?? /* @__PURE__ */ new Set();
@@ -914,7 +1853,7 @@ async function inspectChangeGroups(options = {}) {
   for (const brief of workTree.briefs) {
     let content;
     try {
-      content = await readFile2(brief.path, "utf-8");
+      content = await readFile3(brief.path, "utf-8");
     } catch (error) {
       diagnostics.push({
         severity: "error",
@@ -925,10 +1864,11 @@ async function inspectChangeGroups(options = {}) {
       });
       continue;
     }
-    const parsed = parseGroupBrief(brief.group, content);
+    const document = parseRspDocument(content, GROUP_BRIEF_DOCUMENT_SCHEMA);
+    const parsed = parseGroupBrief(brief.group, document);
     diagnostics.push(...parsed.diagnostics.map((diagnostic) => ({ ...diagnostic, path: brief.path })));
     if (archivedGroups.has(brief.group) && !hasExplicitGroupReopenEvidence(
-      content,
+      document,
       archivedGroupReopenEvidence.get(brief.group) ?? /* @__PURE__ */ new Set(),
       archivedGroupBriefPaths.get(brief.group) ?? /* @__PURE__ */ new Set()
     )) {
@@ -943,7 +1883,7 @@ async function inspectChangeGroups(options = {}) {
     for (const diagnostic of archiveTree.diagnostics.filter((item) => {
       if (item.code === "invalid_archive_root")
         return true;
-      const archivePath = normalizeLogicalPath(relative3(ARCHIVES_DIR, item.path));
+      const archivePath = normalizeLogicalPath(relative4(ARCHIVES_DIR, item.path));
       return archivePath === brief.group || archivePath.startsWith(`${brief.group}/`);
     })) {
       diagnostics.push({
@@ -1011,7 +1951,7 @@ async function inspectChangeGroups(options = {}) {
     const readyToClose = diagnostics.every((diagnostic) => diagnostic.change !== brief.group || diagnostic.severity !== "error") && slices.length >= 2 && slices.every((slice) => slice.state === "archived") && parsed.completion.total > 0 && parsed.completion.done === parsed.completion.total && !parsed.blockers;
     groups.push({
       name: brief.group,
-      summary: extractGroupSummary(content),
+      summary: extractGroupSummary(content, document),
       path: normalizeLogicalPath(brief.path),
       slices,
       completion: parsed.completion,
@@ -1024,25 +1964,27 @@ async function inspectChangeGroups(options = {}) {
   return { groups, diagnostics };
 }
 function getGroupReopenEvidence(content) {
-  const completion = getDocumentSectionBody(parseRspDocument(content, GROUP_BRIEF_DOCUMENT_SCHEMA), "completionConditions");
-  return completion.split("\n").flatMap((line) => {
-    const match = line.trim().match(/^-\s+\[([ /xX-])\]\s+(Resolve reopened concern from `(\.rsp\/archives\/[^`]+)`: \S.*)$/);
-    return match ? [{ active: match[1] !== "-", key: match[2], sourcePath: match[3] }] : [];
+  const document = typeof content === "string" ? parseRspDocument(content, GROUP_BRIEF_DOCUMENT_SCHEMA) : content;
+  const completion = getDocumentSectionMarkdown(document, "completionConditions");
+  return markdownListItems(completion).flatMap(({ line }) => {
+    const match = line.trim().match(/^-\s+\[([ /xX-])\]\s+(Resolve reopened concern from `(\.rsp\/archives\/[^`]+)`: (\S.*))$/);
+    const reason = match?.[4];
+    return match && reason && markdownText(parseMarkdown(reason).root).trim() ? [{ active: match[1] !== "-", key: match[2], sourcePath: match[3] }] : [];
   });
 }
 function hasExplicitGroupReopenEvidence(content, retainedEvidence, retainedGroupBriefPaths) {
   return getGroupReopenEvidence(content).some((item) => item.active && retainedGroupBriefPaths.has(item.sourcePath) && !retainedEvidence.has(item.key));
 }
 async function requireDeclaredGroupSlice(ref) {
-  const briefPath = join3(dirname2(ref.path), GROUP_BRIEF_FILENAME);
+  const briefPath = join6(dirname4(ref.path), GROUP_BRIEF_FILENAME);
   let content;
   try {
-    content = await readFile2(briefPath, "utf-8");
+    content = await readFile3(briefPath, "utf-8");
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new WorkRefError("work_tree_read_failed", `unable to read Group Brief ${briefPath}: ${message}`, ref.name);
   }
-  const parsed = parseGroupBrief(ref.group, content);
+  const parsed = parseGroupBrief(ref.group, parseRspDocument(content, GROUP_BRIEF_DOCUMENT_SCHEMA));
   const errors = parsed.diagnostics.filter((diagnostic) => diagnostic.severity === "error");
   if (errors.length > 0) {
     throw new WorkRefError(
@@ -1067,11 +2009,11 @@ async function hasArchivedGroupBrief(group) {
   }
   const groupPrefix = `${group}/`;
   for (const path of archiveTree.files) {
-    if (!normalizeLogicalPath(relative3(ARCHIVES_DIR, path)).startsWith(groupPrefix))
+    if (!normalizeLogicalPath(relative4(ARCHIVES_DIR, path)).startsWith(groupPrefix))
       continue;
     let content;
     try {
-      content = await readFile2(path, "utf-8");
+      content = await readFile3(path, "utf-8");
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       throw new WorkRefError("work_tree_read_failed", `unable to inspect archived Change Group identity at ${path}: ${message}`, group);
@@ -1081,26 +2023,25 @@ async function hasArchivedGroupBrief(group) {
   }
   return false;
 }
-function parseGroupBrief(group, content) {
+function parseGroupBrief(group, document) {
   const diagnostics = [];
-  const document = parseRspDocument(content, GROUP_BRIEF_DOCUMENT_SCHEMA);
-  let frontmatter;
+  let frontmatter2;
   try {
-    frontmatter = parseFrontmatter(content);
+    frontmatter2 = parseFrontmatter(document.markdown);
   } catch (error) {
     diagnostics.push({ severity: "error", code: "group_frontmatter_invalid", change: group, message: error instanceof Error ? error.message : String(error) });
   }
-  if (frontmatter?.kind !== "group")
+  if (frontmatter2?.kind !== "group")
     diagnostics.push({ severity: "error", code: "group_kind_invalid", change: group, message: "Group Brief frontmatter must declare kind: group" });
   if (getDocumentTitle(document, "identity") !== group)
     diagnostics.push({ severity: "error", code: "group_heading_mismatch", change: group, message: `Group Brief heading must be: # Change Group: ${group}` });
   for (const definition of GROUP_BRIEF_DOCUMENT_SCHEMA.sections) {
-    if (!getDocumentSectionBody(document, definition.id))
+    if (getVisibleBodyLines(getDocumentSectionMarkdown(document, definition.id)).length === 0)
       diagnostics.push({ severity: "error", code: "group_section_missing", change: group, message: `Group Brief missing required section: ${definition.heading}` });
   }
   const slices = [];
   const seen = /* @__PURE__ */ new Set();
-  for (const line of getDocumentSectionBody(document, "slices").split("\n")) {
+  for (const { line } of markdownListItems(getDocumentSectionMarkdown(document, "slices"))) {
     const trimmed = line.trim();
     const identity = trimmed.match(/^-\s+`(\S+)`/);
     if (!identity || identity[1].includes("<"))
@@ -1129,13 +2070,13 @@ function parseGroupBrief(group, content) {
   }
   if (slices.length < 2)
     diagnostics.push({ severity: "warning", code: "group_slices_incomplete", change: group, message: "Change Group must declare at least two direct child slices" });
-  const completion = countCheckboxes(getDocumentSectionBody(document, "completionConditions"));
+  const completion = countCheckboxes(getDocumentSectionMarkdown(document, "completionConditions"));
   if (completion.total === 0)
     diagnostics.push({ severity: "warning", code: "group_completion_missing", change: group, message: "Change Group must declare at least one completion condition" });
   return {
     slices,
     completion: { done: completion.done + completion.dropped, total: completion.total },
-    blockers: hasMeaningfulBlockerBody(getDocumentSectionBody(document, "blockers")),
+    blockers: hasMeaningfulBlockerBody(getDocumentSectionMarkdown(document, "blockers")),
     diagnostics
   };
 }
@@ -1144,13 +2085,13 @@ function groupSectionHeading(sectionId) {
 }
 
 // src/core/dependency-plan.ts
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
 
 // src/history/current-file.ts
 import { Buffer as Buffer2 } from "buffer";
 import { constants } from "fs";
-import { lstat, open, realpath } from "fs/promises";
-import { isAbsolute as isAbsolute2, relative as relative4, resolve, sep as sep2 } from "path";
+import { lstat, open, realpath as realpath2 } from "fs/promises";
+import { isAbsolute as isAbsolute3, relative as relative5, resolve as resolve3, sep as sep3 } from "path";
 
 // src/history/model.ts
 var HISTORY_DEFAULT_LIMIT = 20;
@@ -1179,10 +2120,10 @@ var ArchiveHistoryError = class extends Error {
 // src/history/current-file.ts
 var READ_NO_FOLLOW_FLAGS = constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0);
 async function readCurrentArchiveFile(options) {
-  const sourcePath = resolve(options.sourcePath);
-  const archivesDir = resolve(options.archivesDir);
-  const relativePath = relative4(archivesDir, sourcePath);
-  if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep2}`) || isAbsolute2(relativePath)) {
+  const sourcePath = resolve3(options.sourcePath);
+  const archivesDir = resolve3(options.archivesDir);
+  const relativePath = relative5(archivesDir, sourcePath);
+  if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep3}`) || isAbsolute3(relativePath)) {
     throw changed(options.projectPath);
   }
   let inspectedRoot;
@@ -1193,9 +2134,9 @@ async function readCurrentArchiveFile(options) {
     if (!inspectedRoot.isDirectory())
       throw changed(options.projectPath);
     inspected = await lstat(sourcePath, { bigint: true });
-    realArchivesDir = await realpath(archivesDir);
-    const resolvedSource = await realpath(sourcePath);
-    const expectedSource = resolve(realArchivesDir, relativePath);
+    realArchivesDir = await realpath2(archivesDir);
+    const resolvedSource = await realpath2(sourcePath);
+    const expectedSource = resolve3(realArchivesDir, relativePath);
     if (!inspected.isFile() || resolvedSource !== expectedSource || !isContained(realArchivesDir, resolvedSource)) {
       throw changed(options.projectPath);
     }
@@ -1216,9 +2157,9 @@ async function readCurrentArchiveFile(options) {
   }
   try {
     const opened = await handle.stat({ bigint: true });
-    const currentRoot = await realpath(archivesDir);
-    const currentSource = await realpath(sourcePath);
-    if (!opened.isFile() || currentRoot !== realArchivesDir || currentSource !== resolve(currentRoot, relativePath) || !isContained(currentRoot, currentSource) || !sameIdentity(inspected, opened) || !sameSnapshot(inspected, opened)) {
+    const currentRoot = await realpath2(archivesDir);
+    const currentSource = await realpath2(sourcePath);
+    if (!opened.isFile() || currentRoot !== realArchivesDir || currentSource !== resolve3(currentRoot, relativePath) || !isContained(currentRoot, currentSource) || !sameIdentity(inspected, opened) || !sameSnapshot(inspected, opened)) {
       throw changed(options.projectPath);
     }
     if (opened.size > BigInt(options.maxFileBytes))
@@ -1281,9 +2222,9 @@ async function readBoundedArchive(handle, opened, projectPath, maxFileBytes) {
 async function validateCurrentArchivePath(options) {
   const currentRoot = await lstat(options.archivesDir, { bigint: true });
   const currentSource = await lstat(options.sourcePath, { bigint: true });
-  const realCurrentRoot = await realpath(options.archivesDir);
-  const realCurrentSource = await realpath(options.sourcePath);
-  if (!currentRoot.isDirectory() || !currentSource.isFile() || !sameIdentity(options.inspectedRoot, currentRoot) || realCurrentRoot !== options.realArchivesDir || realCurrentSource !== resolve(realCurrentRoot, options.relativePath) || !isContained(realCurrentRoot, realCurrentSource) || !sameIdentity(currentSource, options.finalHandle) || !sameSnapshot(currentSource, options.finalHandle)) {
+  const realCurrentRoot = await realpath2(options.archivesDir);
+  const realCurrentSource = await realpath2(options.sourcePath);
+  if (!currentRoot.isDirectory() || !currentSource.isFile() || !sameIdentity(options.inspectedRoot, currentRoot) || realCurrentRoot !== options.realArchivesDir || realCurrentSource !== resolve3(realCurrentRoot, options.relativePath) || !isContained(realCurrentRoot, realCurrentSource) || !sameIdentity(currentSource, options.finalHandle) || !sameSnapshot(currentSource, options.finalHandle)) {
     throw changed(options.projectPath);
   }
 }
@@ -1297,8 +2238,8 @@ function sameFileSnapshot(left, right) {
   return left.device === right.dev && left.inode === right.ino && left.size === right.size && left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs;
 }
 function isContained(root, path) {
-  const candidate = relative4(root, path);
-  return candidate !== "" && candidate !== ".." && !candidate.startsWith(`..${sep2}`) && !isAbsolute2(candidate);
+  const candidate = relative5(root, path);
+  return candidate !== "" && candidate !== ".." && !candidate.startsWith(`..${sep3}`) && !isAbsolute3(candidate);
 }
 function changed(projectPath) {
   return new ArchiveHistoryError(
@@ -1324,7 +2265,7 @@ function isPermissionError(error) {
 }
 
 // src/history/inspect.ts
-import { basename as basename2, dirname as dirname3, relative as relative5, resolve as resolve2 } from "path";
+import { basename as basename2, dirname as dirname5, relative as relative6, resolve as resolve4 } from "path";
 
 // src/core/issue-relationship.ts
 var ISSUE_RELATIONS = /* @__PURE__ */ new Set(["relates", "closes"]);
@@ -1337,13 +2278,13 @@ var IssueRelationshipError = class extends Error {
   }
   code;
 };
-function parseIssueRelationships(frontmatter) {
-  if (!frontmatter || !("issues" in frontmatter))
+function parseIssueRelationships(frontmatter2) {
+  if (!frontmatter2 || !("issues" in frontmatter2))
     return [];
-  if (!Array.isArray(frontmatter.issues))
+  if (!Array.isArray(frontmatter2.issues))
     throw new IssueRelationshipError("invalid_issue_shape", 'frontmatter field "issues" must be a list');
   const seen = /* @__PURE__ */ new Set();
-  return frontmatter.issues.map((value, index) => {
+  return frontmatter2.issues.map((value, index) => {
     if (!isPlainObject(value))
       throw new IssueRelationshipError("invalid_issue_shape", `issues[${index}] must be a mapping with url and relation`);
     const fields = Object.keys(value);
@@ -1392,7 +2333,7 @@ function isPlainObject(value) {
 // src/history/inspect.ts
 var ARCHIVE_NAME_RE = /^(\d{4}-\d{2}-\d{2})_(.+)\.md$/;
 async function inspectArchiveHistory(options = {}) {
-  const archivesDir = resolve2(options.archivesDir ?? ARCHIVES_DIR);
+  const archivesDir = resolve4(options.archivesDir ?? ARCHIVES_DIR);
   const maxFileBytes = options.maxFileBytes ?? HISTORY_MAX_FILE_BYTES;
   const tree = options.archiveTree ?? await inspectArchiveTree({ archivesDir });
   const diagnostics = tree.diagnostics.map((diagnostic) => ({
@@ -1462,36 +2403,36 @@ function parseArchiveEntry(current, path, maxFileBytes) {
   }
   const date = nameMatch[1];
   const archiveStem = nameMatch[2];
-  const relativeDirectory = normalizeLogicalPath(relative5(archivesDir, dirname3(sourcePath)));
+  const relativeDirectory = normalizeLogicalPath(relative6(archivesDir, dirname5(sourcePath)));
   const archiveGroup = relativeDirectory === "." || relativeDirectory === "" ? null : relativeDirectory;
   if (archiveGroup && !isCanonicalWorkRefSegment(archiveGroup))
     return { diagnostic: errorDiagnostic("archive_identity_mismatch", path, "archive group path is not a valid one-segment Group identity") };
-  const changeDocument = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
-  const groupDocument = parseRspDocument(content, GROUP_BRIEF_DOCUMENT_SCHEMA);
-  const changeHeadings = getDocumentTitles(changeDocument, "identity");
+  const changeDocument2 = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
+  const groupDocument = parseRspDocument(changeDocument2.markdown, GROUP_BRIEF_DOCUMENT_SCHEMA);
+  const changeHeadings = getDocumentTitles(changeDocument2, "identity");
   const groupHeadings = getDocumentTitles(groupDocument, "identity");
   if (changeHeadings.length + groupHeadings.length !== 1) {
     return { diagnostic: errorDiagnostic("archive_heading_invalid", path, "archive must contain exactly one Change or Change Group identity heading") };
   }
-  let frontmatter;
+  let frontmatter2;
   try {
-    frontmatter = parseFrontmatter(content);
+    frontmatter2 = parseFrontmatter(changeDocument2.markdown);
   } catch (error) {
     return { diagnostic: errorDiagnostic("archive_frontmatter_invalid", path, `archive frontmatter could not be parsed: ${toErrorMessage(error)}`) };
   }
-  if (typeof frontmatter?.kind !== "string" || frontmatter.kind.trim() === "")
+  if (typeof frontmatter2?.kind !== "string" || frontmatter2.kind.trim() === "")
     return { diagnostic: errorDiagnostic("archive_kind_invalid", path, "archive frontmatter must declare a non-empty kind") };
   if (groupHeadings.length === 1) {
     const group = groupHeadings[0];
-    if (!archiveGroup || group !== archiveGroup || frontmatter.kind !== "group" || !matchesArchiveStem(archiveStem, "brief")) {
+    if (!archiveGroup || group !== archiveGroup || frontmatter2.kind !== "group" || !matchesArchiveStem(archiveStem, "brief")) {
       return { diagnostic: errorDiagnostic("archive_identity_mismatch", path, `archived Change Group identity ${group} does not match its archive path`) };
     }
     return { groupBrief: { date, group, path, sourcePath } };
   }
   let issues;
-  if ("issues" in frontmatter) {
+  if ("issues" in frontmatter2) {
     try {
-      issues = parseIssueRelationships(frontmatter);
+      issues = parseIssueRelationships(frontmatter2);
     } catch {
       issues = void 0;
     }
@@ -1506,7 +2447,7 @@ function parseArchiveEntry(current, path, maxFileBytes) {
   if (!isCanonicalExecutableWorkRef(workRef) || expectedGroup !== archiveGroup || !matchesArchiveStem(archiveStem, expectedBase)) {
     return { diagnostic: errorDiagnostic("archive_identity_mismatch", path, `archived Change identity ${workRef} does not match its archive path`) };
   }
-  const rawSummary = extractChangeSummary(content, changeDocument, { preservePlaceholder: true });
+  const rawSummary = extractChangeSummary(content, changeDocument2, { preservePlaceholder: true });
   if (!rawSummary)
     return { diagnostic: errorDiagnostic("archive_summary_missing", path, "archived Change must contain frontmatter summary, Proposal Outcome, or Proposal Summary") };
   const summary = boundText(rawSummary);
@@ -1515,7 +2456,7 @@ function parseArchiveEntry(current, path, maxFileBytes) {
       date,
       workRef,
       group: expectedGroup,
-      kind: frontmatter.kind.trim(),
+      kind: frontmatter2.kind.trim(),
       summary: summary.value,
       summaryTruncated: summary.truncated,
       path,
@@ -1540,10 +2481,10 @@ function isCalendarDate(value) {
   return Number.isFinite(parsed.getTime()) && parsed.toISOString().slice(0, 10) === value;
 }
 function archiveOutputPath(sourcePath, archivesDir) {
-  return `.rsp/archives/${normalizeLogicalPath(relative5(resolve2(archivesDir), resolve2(sourcePath)))}`;
+  return `.rsp/archives/${normalizeLogicalPath(relative6(resolve4(archivesDir), resolve4(sourcePath)))}`;
 }
 function normalizeOutputPath(path, archivesDir) {
-  const relativePath = normalizeLogicalPath(relative5(resolve2(archivesDir), resolve2(path)));
+  const relativePath = normalizeLogicalPath(relative6(resolve4(archivesDir), resolve4(path)));
   return relativePath === "" ? ".rsp/archives" : `.rsp/archives/${relativePath}`;
 }
 function errorDiagnostic(code, path, message) {
@@ -1642,20 +2583,20 @@ async function readArchiveHistoryDocument(record) {
     throw new ArchiveHistoryError("archive_read_failed", `unable to read archived Change ${record.path}: ${error instanceof Error ? error.message : String(error)}`);
   }
   const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
-  const tasks = getDocumentSectionBody(document, "tasks");
-  const verify = getDocumentSectionBody(document, "verify");
-  const blockers = getDocumentSectionBody(document, "blockers");
+  const tasks = getDocumentSectionMarkdown(document, "tasks");
+  const verify = getDocumentSectionMarkdown(document, "verify");
+  const blockers = getDocumentSectionMarkdown(document, "blockers");
   const detail = {
     ...toOutputRecord(record),
-    scenarioCount: parseScenarios(content).length,
+    scenarioCount: parseScenarios(document.markdown).length,
     checkboxes: {
       tasks: countCheckboxes(tasks),
       verify: countCheckboxes(verify)
     },
     evidence: {
-      tasks: boundEvidence(tasks),
-      verify: boundEvidence(verify),
-      blockers: boundEvidence(blockers, true)
+      tasks: boundEvidence(getVisibleBodyLines(tasks)),
+      verify: boundEvidence(getVisibleBodyLines(verify)),
+      blockers: boundEvidence(readBlockerEntries(blockers).map((entry) => entry.line))
     }
   };
   return { content, detail };
@@ -1674,8 +2615,7 @@ function toOutputRecord(record) {
   } = record;
   return output;
 }
-function boundEvidence(section, omitNone = false) {
-  const rawItems = section.split("\n").map((line) => line.trim()).filter(Boolean).filter((line) => !omitNone || !/^[-*]\s*(?:none)?$/i.test(line) && !/^none$/i.test(line));
+function boundEvidence(rawItems) {
   const boundedItems = rawItems.slice(0, HISTORY_MAX_EVIDENCE_ITEMS).map((item) => boundText(item));
   return {
     items: boundedItems.map((item) => item.value),
@@ -1693,7 +2633,6 @@ function compareHistoryRecords2(left, right) {
 }
 
 // src/core/dependency-plan.ts
-var REQUIRES_RE = /^[-*]\s+requires\s+`([^`]+)`:[ \t]*(\S.*)$/i;
 async function inspectChangeDependencies(options = {}) {
   const workTree = options.workTree ?? await inspectWorkTree();
   const archiveTree = options.archiveTree ?? await inspectArchiveTree();
@@ -1714,7 +2653,7 @@ async function inspectChangeDependencies(options = {}) {
     diagnostics.push(...archiveHistory.diagnostics);
   for (const brief of workTree.briefs) {
     try {
-      if (hasMeaningfulBlockers(await readFile3(brief.path, "utf-8")))
+      if (hasMeaningfulBlockers(await readFile4(brief.path, "utf-8")))
         blockedGroups.add(brief.group);
     } catch (error) {
       diagnostics.push({
@@ -1728,7 +2667,7 @@ async function inspectChangeDependencies(options = {}) {
   }
   for (const ref of workTree.changes) {
     try {
-      const parsed = parseDependencyBlockers(await readFile3(ref.path, "utf-8"));
+      const parsed = parseDependencyBlockers(await readFile4(ref.path, "utf-8"));
       if (ref.group && blockedGroups.has(ref.group))
         parsed.external = true;
       parsedByName.set(ref.name, parsed);
@@ -1833,18 +2772,16 @@ function parseDependencyBlockers(content) {
   const requires = /* @__PURE__ */ new Map();
   let external = false;
   const malformed = [];
-  for (const line of extractBlockerLines(content)) {
-    if (!line || isEmptyBlockerLine(line))
-      continue;
-    const dependency = line.match(REQUIRES_RE);
-    if (dependency) {
-      if (!requires.has(dependency[1]))
-        requires.set(dependency[1], dependency[2]);
-    } else if (/^[-*]\s+requires\b/i.test(line)) {
-      malformed.push(line);
-      external = true;
+  const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
+  const blockers = getDocumentSectionMarkdown(document, "blockers");
+  for (const entry of readBlockerEntries(blockers)) {
+    if (entry.kind === "dependency") {
+      if (!requires.has(entry.name))
+        requires.set(entry.name, entry.reason);
     } else {
       external = true;
+      if (entry.kind === "malformed-dependency")
+        malformed.push(entry.line);
     }
   }
   return {
@@ -1947,29 +2884,32 @@ function collectArchiveReadiness(content, options = {}) {
   const warnings = [];
   const documentDiagnostics = options.documentDiagnostics ?? [];
   warnings.push(...documentDiagnostics.map((diagnostic) => diagnostic.message));
-  const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
-  const tasksSection = getDocumentSectionBody(document, "tasks");
-  const verifySection = getDocumentSectionBody(document, "verify");
+  const document = typeof content === "string" ? parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA) : content;
+  const missingSummary = !extractChangeSummary(document.source, document, { preservePlaceholder: true });
+  if (missingSummary)
+    warnings.push("archived Change must contain frontmatter summary, Proposal Outcome, or Proposal Summary");
+  const tasksSection = getDocumentSectionMarkdown(document, "tasks");
+  const verifySection = getDocumentSectionMarkdown(document, "verify");
   const taskTodos = getOpenCheckboxes(tasksSection);
   if (taskTodos.length > 0)
     warnings.push(`${taskTodos.length} task item(s) still incomplete`);
-  const verifyCriticality = classifyVerifyCheckboxes(verifySection);
-  const verifyLines = collectVerifyCheckboxLines(verifySection);
-  const requiredVerifyTodos = getOpenCheckboxes([...verifyLines.required, ...verifyLines.unclassified].join("\n"));
-  const optionalVerifyTodos = getOpenCheckboxes(verifyLines.optional.join("\n"));
+  const verifyItems = collectVerifyCheckboxes(verifySection);
+  const verifyCriticality = summarizeVerifyCheckboxes(verifyItems);
+  const requiredVerifyTodos = openCheckboxLines([...verifyItems.required, ...verifyItems.unclassified]);
+  const optionalVerifyTodos = openCheckboxLines(verifyItems.optional);
   const verifyTodos = [...requiredVerifyTodos, ...optionalVerifyTodos];
   if (requiredVerifyTodos.length > 0)
     warnings.push(`${requiredVerifyTodos.length} required Verify item(s) are still incomplete`);
   if (optionalVerifyTodos.length > 0)
     warnings.push(`${optionalVerifyTodos.length} optional Verify item(s) are still incomplete`);
-  const activeBlockers = options.activeBlockers ?? hasMeaningfulBlockers(content);
+  const activeBlockers = options.activeBlockers ?? hasMeaningfulBlockers(document);
   if (activeBlockers)
     warnings.push("active blockers are present in the change file");
-  const scenarios = parseScenarios(content);
+  const scenarios = parseScenarios(document.markdown);
   const missingScenarios = scenarios.length === 0;
   if (missingScenarios)
     warnings.push("no Scenario blocks found (some changes do not need them)");
-  const archiveReady = documentDiagnostics.some((diagnostic) => diagnostic.severity === "error") || activeBlockers || taskTodos.length > 0 || requiredVerifyTodos.length > 0 ? "no" : "yes";
+  const archiveReady = documentDiagnostics.some((diagnostic) => diagnostic.severity === "error") || missingSummary || activeBlockers || taskTodos.length > 0 || requiredVerifyTodos.length > 0 ? "no" : "yes";
   return {
     taskTodos,
     verifyTodos,
@@ -2022,12 +2962,12 @@ function getDurableReviewCandidateTargets() {
 async function inspectProjectStatus(options = {}) {
   const runtime = [];
   const diagnostics = [];
-  let manage = resolveManagePolicy({});
+  let workflow = resolveWorkflowPolicy({});
   let language = resolveLanguagePolicy({});
   try {
     const configInspection = await inspectRspConfig();
     const configValid = configInspection.issues.length === 0;
-    manage = resolveManagePolicy(configInspection.config, { configValid });
+    workflow = resolveWorkflowPolicy(configInspection.config, { configValid });
     language = resolveLanguagePolicy(configInspection.config, { configValid });
     if (!configValid) {
       diagnostics.push({
@@ -2038,7 +2978,7 @@ async function inspectProjectStatus(options = {}) {
       });
     }
   } catch (error) {
-    manage = resolveManagePolicy({}, { configValid: false });
+    workflow = resolveWorkflowPolicy({}, { configValid: false });
     language = resolveLanguagePolicy({}, { configValid: false });
     diagnostics.push({
       severity: "error",
@@ -2105,7 +3045,7 @@ async function inspectProjectStatus(options = {}) {
     let kind = "\u2014";
     let summary = null;
     let title = name;
-    let blockerEntries = [];
+    let externalBlockers = [];
     let readiness = emptyReadiness(false);
     let ageDays = null;
     const isFocused = focusedSet.has(name);
@@ -2116,14 +3056,15 @@ async function inspectProjectStatus(options = {}) {
     let issues = [];
     if (path) {
       try {
-        const content = await readFile4(path, "utf-8");
-        title = extractChangeTitle(content) ?? name;
-        summary = extractChangeSummary(content);
-        blockerEntries = extractBlockerEntries(content);
+        const content = await readFile5(path, "utf-8");
+        const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
+        title = getDocumentTitle(document, "spaced") ?? name;
+        summary = extractChangeSummary(content, document);
+        externalBlockers = readBlockerEntries(getDocumentSectionMarkdown(document, "blockers")).filter((entry) => entry.kind !== "dependency").map((entry) => entry.text);
         try {
-          const frontmatter = parseFrontmatter(content);
-          kind = frontmatter?.kind ? String(frontmatter.kind) : "\u2014";
-          issues = parseIssueRelationships(frontmatter);
+          const frontmatter2 = parseFrontmatter(document.markdown);
+          kind = frontmatter2?.kind ? String(frontmatter2.kind) : "\u2014";
+          issues = parseIssueRelationships(frontmatter2);
         } catch (error) {
           kind = "(invalid)";
           const issueError = error instanceof IssueRelationshipError;
@@ -2143,10 +3084,9 @@ async function inspectProjectStatus(options = {}) {
             message: toErrorMessage(error)
           });
         }
-        isBlocked = dependencyInspection.activeBlockers.get(name) ?? hasMeaningfulBlockers(content);
-        const details = collectArchiveReadiness(content, { activeBlockers: isBlocked });
-        const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
-        const taskCheckboxes = countCheckboxes(getDocumentSectionBody(document, "tasks"));
+        isBlocked = dependencyInspection.activeBlockers.get(name) ?? hasMeaningfulBlockers(document);
+        const details = collectArchiveReadiness(document, { activeBlockers: isBlocked });
+        const taskCheckboxes = countCheckboxes(getDocumentSectionMarkdown(document, "tasks"));
         done = taskCheckboxes.done + details.verifyCriticality.required.done;
         total = taskCheckboxes.total + details.verifyCriticality.required.total;
         progressKnown = true;
@@ -2168,7 +3108,7 @@ async function inspectProjectStatus(options = {}) {
         });
       }
       try {
-        const metadata = await stat(path);
+        const metadata = await stat2(path);
         ageDays = Math.floor((nowMs - metadata.mtime.getTime()) / (1e3 * 60 * 60 * 24));
       } catch (error) {
         diagnostics.push({
@@ -2217,12 +3157,12 @@ async function inspectProjectStatus(options = {}) {
       },
       progressKnown,
       title,
-      blockerEntries,
+      externalBlockers,
       readiness
     });
   }
   return {
-    manage,
+    workflow,
     language,
     focused: [...focusedSet].sort(),
     records,
@@ -2251,13 +3191,6 @@ function emptyReadiness(activeBlockers) {
     archiveReady: activeBlockers ? "no" : "judgment"
   };
 }
-function extractChangeTitle(content) {
-  return getDocumentTitle(parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA), "spaced");
-}
-function extractBlockerEntries(content) {
-  const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
-  return getDocumentSectionBody(document, "blockers").split("\n").map((line) => line.trim()).filter((line) => /^[-*]\s+/.test(line)).map((line) => line.replace(/^[-*]\s+/, "").trim()).filter((line) => line.toLowerCase() !== "none");
-}
 function deriveArchiveTrend(records) {
   const counts = /* @__PURE__ */ new Map();
   for (const record of records) {
@@ -2280,9 +3213,9 @@ var SPECS_MAX_DIAGNOSTICS = 20;
 import { Buffer as Buffer3 } from "buffer";
 import { spawnSync } from "child_process";
 import { constants as constants2 } from "fs";
-import { lstat as lstat2, open as open2, realpath as realpath2 } from "fs/promises";
-import { basename as basename3, dirname as dirname4, isAbsolute as isAbsolute3, join as join4, relative as relative6, resolve as resolve3, sep as sep3 } from "path";
-var SPECS_ROOT = join4(RSP_DIR, "specs");
+import { lstat as lstat2, open as open2, realpath as realpath3 } from "fs/promises";
+import { basename as basename3, dirname as dirname6, isAbsolute as isAbsolute4, join as join7, relative as relative7, resolve as resolve5, sep as sep4 } from "path";
+var SPECS_ROOT = join7(RSP_DIR, "specs");
 var GENERATED_INDEX_FILENAME = "00-index.md";
 var LEGACY_GENERATED_INDEX_FILENAME = "INDEX.md";
 var READ_NO_FOLLOW_FLAGS2 = constants2.O_RDONLY | (constants2.O_NOFOLLOW ?? 0);
@@ -2295,8 +3228,8 @@ var SpecsQueryError = class extends Error {
   code;
 };
 async function inspectSpecs(options = {}) {
-  const projectRoot = await realpath2(resolve3(options.cwd ?? process.cwd()));
-  const specsRoot = resolve3(projectRoot, SPECS_ROOT);
+  const projectRoot = await realpath3(resolve5(options.cwd ?? process.cwd()));
+  const specsRoot = resolve5(projectRoot, SPECS_ROOT);
   const maxCandidates = options.maxCandidates ?? SPECS_MAX_CANDIDATES;
   const maxFileBytes = options.maxFileBytes ?? SPECS_MAX_FILE_BYTES;
   validatePositiveBound(maxCandidates, "maxCandidates");
@@ -2308,7 +3241,7 @@ async function inspectSpecs(options = {}) {
   const decisionPathIssue = await validateDecisionRecordsFilesystemPath(decisionRecordsPath, projectRoot);
   if (decisionPathIssue)
     throw new SpecsQueryError("invalid_decision_records_path", decisionPathIssue);
-  const decisionRecordsRoot = resolve3(projectRoot, decisionRecordsPath);
+  const decisionRecordsRoot = resolve5(projectRoot, decisionRecordsPath);
   const accumulator = {
     documents: [],
     generatedIndexes: [],
@@ -2316,7 +3249,7 @@ async function inspectSpecs(options = {}) {
     candidateCount: 0,
     candidateLimitReported: false
   };
-  const excludedSpecDirectories = [DEFAULT_DECISION_RECORDS_PATH, decisionRecordsPath].map((path) => resolve3(projectRoot, path)).filter((path) => isInside(specsRoot, path));
+  const excludedSpecDirectories = [DEFAULT_DECISION_RECORDS_PATH, decisionRecordsPath].map((path) => resolve5(projectRoot, path)).filter((path) => isInside(specsRoot, path));
   await inspectDocumentRoot({
     projectRoot,
     root: specsRoot,
@@ -2386,14 +3319,14 @@ async function readCurrentSpecsDocument(inspection, projectPath) {
   const document = inspection.documents.find((candidate) => candidate.path === normalized);
   if (!document)
     throw new SpecsQueryError("specs_document_not_found", `Specs document not found: ${projectPath}`);
-  const sourcePath = resolve3(inspection.source.root, normalized);
+  const sourcePath = resolve5(inspection.source.root, normalized);
   const current = await readCurrentDocument(
     sourcePath,
     inspection.source.root,
     document.path,
     inspection.limits.fileBytes
   );
-  const currentDocument = parseDocumentRecord(current.content, current.bytes, document.path, document.kind);
+  const currentDocument = parseDocumentRecord(parseMarkdown(current.content), current.bytes, document.path, document.kind);
   return {
     ...currentDocument,
     content: current.content
@@ -2418,18 +3351,17 @@ async function searchSpecsWithSources(inspection, literal, options = {}) {
   let matched = 0;
   for (const document of inspection.documents) {
     const current = await readCurrentDocument(
-      resolve3(inspection.source.root, document.path),
+      resolve5(inspection.source.root, document.path),
       inspection.source.root,
       document.path,
       inspection.limits.fileBytes
     );
-    const currentDocument = parseDocumentRecord(current.content, current.bytes, document.path, document.kind);
+    const currentDocument = parseDocumentRecord(parseMarkdown(current.content), current.bytes, document.path, document.kind);
     const lines = current.content.split(/\r?\n/);
+    const headingsByLine = new Map(currentDocument.headings.map((item) => [item.line, item.title]));
     let heading = null;
     for (let index = 0; index < lines.length; index++) {
-      const parsedHeading = parseMarkdownHeading(lines[index]);
-      if (parsedHeading)
-        heading = parsedHeading.title;
+      heading = headingsByLine.get(index + 1) ?? heading;
       const position = lines[index].toLowerCase().indexOf(lowered);
       if (position < 0)
         continue;
@@ -2543,18 +3475,19 @@ async function classifyGeneratedIndex(path, projectRoot, projectPath, maxFileByt
 }
 function isRecognizedGeneratedSpecsIndex(content, projectPath) {
   const metadata = parseFrontmatter(content);
-  const expectedSourceDirectory = normalizeLogicalPath(dirname4(projectPath));
+  const expectedSourceDirectory = normalizeLogicalPath(dirname6(projectPath));
   return metadata?.kind === "generated-index" && metadata.index_type === "specs" && metadata.source_dir === expectedSourceDirectory;
 }
 async function inspectDocument(path, projectRoot, projectPath, kind, maxFileBytes, accumulator) {
   try {
     const current = await readCurrentDocument(path, projectRoot, projectPath, maxFileBytes);
-    const metadata = parseFrontmatter(current.content);
+    const document = parseMarkdown(current.content);
+    const metadata = parseFrontmatter(document);
     if (metadata?.kind === "generated-index")
       return;
     accumulator.documents.push({
       sourcePath: path,
-      ...parseDocumentRecord(current.content, current.bytes, projectPath, kind)
+      ...parseDocumentRecord(document, current.bytes, projectPath, kind, metadata)
     });
   } catch (error) {
     accumulator.diagnostics.push({
@@ -2599,8 +3532,8 @@ function buildDirectoryTree(projectRoot, root, kind, documents) {
     documents: []
   };
   for (const document of documents.filter((candidate) => candidate.kind === kind)) {
-    const rel = relative6(root, document.sourcePath);
-    if (rel === ".." || rel.startsWith(`..${sep3}`) || isAbsolute3(rel))
+    const rel = relative7(root, document.sourcePath);
+    if (rel === ".." || rel.startsWith(`..${sep4}`) || isAbsolute4(rel))
       continue;
     const segments = normalizeLogicalPath(rel).split("/");
     let current = tree;
@@ -2623,64 +3556,18 @@ function buildDirectoryTree(projectRoot, root, kind, documents) {
   }
   return tree;
 }
-function extractHeadings(content) {
-  const headings = [];
-  const lines = content.split(/\r?\n/);
-  for (let index = 0; index < lines.length; index++) {
-    const heading = parseMarkdownHeading(lines[index]);
-    if (!heading)
-      continue;
-    headings.push({
-      depth: heading.depth,
-      title: heading.title,
-      line: index + 1
-    });
-  }
-  return headings;
+function extractHeadings(document) {
+  return document.root.children.flatMap((node) => node.type === "heading" ? [{ depth: node.depth, title: markdownText(node), line: node.position.start.line }] : []);
 }
-function parseMarkdownHeading(line) {
-  let depth = 0;
-  while (depth < 6 && line[depth] === "#")
-    depth += 1;
-  if (depth === 0 || line[depth] === "#" || !isWhitespace(line[depth]))
-    return null;
-  let contentStart = depth;
-  while (contentStart < line.length && isWhitespace(line[contentStart]))
-    contentStart += 1;
-  if (contentStart === line.length)
-    return null;
-  const rawTitle = line.slice(contentStart);
-  let titleEnd = rawTitle.length;
-  while (titleEnd > 0 && isSpaceOrTab(rawTitle[titleEnd - 1]))
-    titleEnd -= 1;
-  let closingStart = titleEnd;
-  while (closingStart > 0 && rawTitle[closingStart - 1] === "#")
-    closingStart -= 1;
-  const closingPredecessor = closingStart === 0 ? line[contentStart - 1] : rawTitle[closingStart - 1];
-  if (closingStart < titleEnd && isSpaceOrTab(closingPredecessor)) {
-    titleEnd = closingStart;
-    while (titleEnd > 0 && isSpaceOrTab(rawTitle[titleEnd - 1]))
-      titleEnd -= 1;
-  }
-  const title = rawTitle.slice(0, titleEnd).trim();
-  return { depth, title };
-}
-function isWhitespace(character) {
-  return character !== void 0 && character.trim() === "";
-}
-function isSpaceOrTab(character) {
-  return character === " " || character === "	";
-}
-function extractSummary(content, frontmatterSummary) {
+function extractSummary(document, frontmatterSummary) {
   if (typeof frontmatterSummary === "string" && frontmatterSummary.trim() !== "")
     return frontmatterSummary.trim();
-  const frontmatter = content.match(/^---\r?\n[\s\S]*?\r?\n(?:---|\.\.\.)\r?\n/);
-  const body = frontmatter ? content.slice(frontmatter[0].length) : content;
-  for (const rawLine of body.split(/\r?\n/)) {
-    const line = rawLine.trim();
-    if (line === "" || line.startsWith("#") || line.startsWith("<!--"))
+  for (const node of document.root.children) {
+    if (node.type !== "paragraph" && node.type !== "list")
       continue;
-    return line.replace(/^[-*]\s*/, "").trim() || null;
+    const text = markdownText(node).split("\n", 1)[0].trim();
+    if (text)
+      return text;
   }
   return null;
 }
@@ -2709,14 +3596,14 @@ function normalizeRequestedPath(pathValue) {
   if (trimmed === "")
     throw new SpecsQueryError("invalid_specs_path", "Specs detail path must be non-empty");
   const normalized = normalizeLogicalPath(trimmed.replace(/^\.\//, ""));
-  if (isAbsolute3(trimmed) || normalized === ".." || normalized.startsWith("../"))
+  if (isAbsolute4(trimmed) || normalized === ".." || normalized.startsWith("../"))
     throw new SpecsQueryError("invalid_specs_path", "Specs detail path must be one project-relative path returned by rsp specs");
   return normalized;
 }
 function reservedIndexKind(root, path) {
   if (basename3(path) === GENERATED_INDEX_FILENAME)
     return "current";
-  if (path === join4(root, LEGACY_GENERATED_INDEX_FILENAME))
+  if (path === join7(root, LEGACY_GENERATED_INDEX_FILENAME))
     return "legacy";
   return null;
 }
@@ -2730,10 +3617,10 @@ function excerptAround(line, matchStart, matchLength, limit) {
 }
 async function readCurrentDocument(path, root, projectPath, maxFileBytes) {
   const changed2 = () => new SpecsQueryError("specs_file_changed", `Specs document is no longer a readable regular file: ${projectPath}`);
-  const sourcePath = resolve3(path);
-  const sourceRoot = resolve3(root);
-  const relativePath = relative6(sourceRoot, sourcePath);
-  if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep3}`) || isAbsolute3(relativePath)) {
+  const sourcePath = resolve5(path);
+  const sourceRoot = resolve5(root);
+  const relativePath = relative7(sourceRoot, sourcePath);
+  if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep4}`) || isAbsolute4(relativePath)) {
     throw changed2();
   }
   const inspection = inspectManagedFile(sourcePath, "Specs document");
@@ -2745,9 +3632,9 @@ async function readCurrentDocument(path, root, projectPath, maxFileBytes) {
   try {
     inspectedRoot = await lstat2(sourceRoot, { bigint: true });
     inspected = await lstat2(sourcePath, { bigint: true });
-    realRoot = await realpath2(sourceRoot);
-    const resolvedPath = await realpath2(sourcePath);
-    if (!inspectedRoot.isDirectory() || !inspected.isFile() || resolvedPath !== resolve3(realRoot, relativePath) || !isContained2(realRoot, resolvedPath)) {
+    realRoot = await realpath3(sourceRoot);
+    const resolvedPath = await realpath3(sourcePath);
+    if (!inspectedRoot.isDirectory() || !inspected.isFile() || resolvedPath !== resolve5(realRoot, relativePath) || !isContained2(realRoot, resolvedPath)) {
       throw changed2();
     }
   } catch (error) {
@@ -2763,9 +3650,9 @@ async function readCurrentDocument(path, root, projectPath, maxFileBytes) {
   }
   try {
     const opened = await handle.stat({ bigint: true });
-    const currentRoot = await realpath2(sourceRoot);
-    const currentPath = await realpath2(sourcePath);
-    if (!opened.isFile() || currentRoot !== realRoot || currentPath !== resolve3(currentRoot, relativePath) || !isContained2(currentRoot, currentPath) || !sameIdentity2(inspected, opened) || !sameSnapshot2(inspected, opened)) {
+    const currentRoot = await realpath3(sourceRoot);
+    const currentPath = await realpath3(sourcePath);
+    if (!opened.isFile() || currentRoot !== realRoot || currentPath !== resolve5(currentRoot, relativePath) || !isContained2(currentRoot, currentPath) || !sameIdentity2(inspected, opened) || !sameSnapshot2(inspected, opened)) {
       throw changed2();
     }
     if (opened.size > BigInt(maxFileBytes))
@@ -2818,9 +3705,9 @@ async function validateCurrentSpecsPath(options) {
   try {
     const currentRoot = await lstat2(options.sourceRoot, { bigint: true });
     const currentPath = await lstat2(options.sourcePath, { bigint: true });
-    const realCurrentRoot = await realpath2(options.sourceRoot);
-    const realCurrentPath = await realpath2(options.sourcePath);
-    if (!currentRoot.isDirectory() || !currentPath.isFile() || !sameIdentity2(options.inspectedRoot, currentRoot) || realCurrentRoot !== options.realRoot || realCurrentPath !== resolve3(realCurrentRoot, options.relativePath) || !isContained2(realCurrentRoot, realCurrentPath) || !sameIdentity2(currentPath, options.finalHandle) || !sameSnapshot2(currentPath, options.finalHandle)) {
+    const realCurrentRoot = await realpath3(options.sourceRoot);
+    const realCurrentPath = await realpath3(options.sourcePath);
+    if (!currentRoot.isDirectory() || !currentPath.isFile() || !sameIdentity2(options.inspectedRoot, currentRoot) || realCurrentRoot !== options.realRoot || realCurrentPath !== resolve5(realCurrentRoot, options.relativePath) || !isContained2(realCurrentRoot, realCurrentPath) || !sameIdentity2(currentPath, options.finalHandle) || !sameSnapshot2(currentPath, options.finalHandle)) {
       throw changed2();
     }
   } catch (error) {
@@ -2836,8 +3723,8 @@ function sameSnapshot2(left, right) {
   return left.size === right.size && left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs;
 }
 function isContained2(root, path) {
-  const candidate = relative6(root, path);
-  return candidate !== "" && candidate !== ".." && !candidate.startsWith(`..${sep3}`) && !isAbsolute3(candidate);
+  const candidate = relative7(root, path);
+  return candidate !== "" && candidate !== ".." && !candidate.startsWith(`..${sep4}`) && !isAbsolute4(candidate);
 }
 function boundCodePoints(value, limit) {
   const codePoints = [...value];
@@ -2850,14 +3737,13 @@ function stripSource(document) {
   const { sourcePath: _sourcePath, ...record } = document;
   return record;
 }
-function parseDocumentRecord(content, bytes, path, kind) {
-  const metadata = parseFrontmatter(content);
-  const headings = extractHeadings(content);
+function parseDocumentRecord(document, bytes, path, kind, metadata = parseFrontmatter(document)) {
+  const headings = extractHeadings(document);
   return {
     path,
     kind,
     title: typeof metadata?.title === "string" && metadata.title.trim() !== "" ? metadata.title.trim() : headings.find((heading) => heading.depth === 1)?.title ?? basename3(path, ".md"),
-    summary: extractSummary(content, metadata?.summary),
+    summary: extractSummary(document, metadata?.summary),
     bytes,
     headings
   };
@@ -2870,11 +3756,11 @@ function validatePositiveBound(value, label) {
     throw new SpecsQueryError("invalid_specs_bound", `${label} must be a positive integer`);
 }
 function isInside(directory, path) {
-  const rel = relative6(directory, path);
-  return rel === "" || !isAbsolute3(rel) && rel !== ".." && !rel.startsWith(`..${sep3}`);
+  const rel = relative7(directory, path);
+  return rel === "" || !isAbsolute4(rel) && rel !== ".." && !rel.startsWith(`..${sep4}`);
 }
 function toProjectPath(projectRoot, path) {
-  return normalizeLogicalPath(relative6(projectRoot, path)) || ".";
+  return normalizeLogicalPath(relative7(projectRoot, path)) || ".";
 }
 
 // src/specs/projection.ts
@@ -2967,13 +3853,70 @@ function projectDependencyForest(plan, requestedRoots = defaultRoots(plan)) {
 }
 
 export {
+  parseMarkdown,
+  isMarkdownComment,
+  markdownTopLevelComments,
+  markdownText,
+  markdownProse,
+  CHANGE_DOCUMENT_SCHEMA,
+  GROUP_BRIEF_DOCUMENT_SCHEMA,
+  DocumentSectionCardinalityError,
+  parseRspDocument,
+  getDocumentTitles,
+  getDocumentSections,
+  getDocumentSectionMarkdown,
+  getDocumentSectionDefinitionByHeading,
+  renderDocumentSectionHeading,
+  renderDocumentTitle,
+  appendDocumentSectionItem,
+  parseFrontmatter,
+  countCheckboxes,
+  getVisibleBodyLines,
+  hasMeaningfulBlockers,
+  detectDeltaSections,
+  parseScenarios,
   IssueRelationshipError,
   parseIssueRelationships,
   createIssueRelationship,
+  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,
+  toErrorMessage,
+  emitJson,
   walkMarkdownFiles,
   inspectUnsupportedRules,
   normalizeLogicalPath,
   isValidSpecName,
+  inspectRspInitialization,
   guardRspInitialized,
   cleanupEmptyParentDirs,
   detectProjectName,
@@ -3007,7 +3950,6 @@ export {
   inspectChangeDependencies,
   SPECS_DEFAULT_RESULT_LIMIT,
   SPECS_MAX_RESULT_LIMIT,
-  SPECS_MAX_FILE_BYTES,
   SPECS_SEARCH_EXCERPT_CODE_POINTS,
   SPECS_DETAIL_CONTENT_CODE_POINTS,
   SpecsQueryError,