@oevery/rsp 3.3.0 → 4.1.0

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

@@ -1,163 +1,62 @@
 #!/usr/bin/env node
+import {
+  SpecsQueryError,
+  normalizeLogicalPath,
+  readSpecsDetail,
+  searchSpecs,
+  specsInspectionComplete,
+  toErrorMessage
+} from "./chunk-LGDCIQYL.mjs";
 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,
+  collectVerifyCheckboxes,
   countCheckboxes,
-  extractBlockerLines,
   getCanonicalSectionHeadings,
-  getDocumentSectionBody,
+  getDocumentSectionMarkdown,
   getDocumentTitle,
   getDocumentTitles,
   getOpenCheckboxes,
+  getVisibleBodyLines,
   hasMeaningfulBlockerBody,
   hasMeaningfulBlockers,
   inspectManagedDirectory,
-  inspectManagedFile,
-  inspectManagedFileTree,
   inspectRspConfig,
-  isEmptyBlockerLine,
+  markdownListItems,
+  markdownText,
+  openCheckboxLines,
   parseFrontmatter,
+  parseMarkdown,
   parseRspDocument,
   parseScenarios,
-  pc,
+  readBlockerEntries,
   renderDocumentSectionHeading,
   renderDocumentTitle,
   requireManagedDirectory,
   requireManagedFile,
-  resolveDecisionRecordsPath,
   resolveLanguagePolicy,
-  resolveManagePolicy,
-  toErrorMessage,
-  validateDecisionRecordsFilesystemPath
-} from "./chunk-7HXQNBIG.mjs";
+  resolveWorkflowPolicy,
+  summarizeVerifyCheckboxes,
+  visibleMarkdownSource
+} from "./chunk-P3KO3GZW.mjs";
 
 // src/status/inspect.ts
-import { readFile as readFile4, stat } from "fs/promises";
+import { readFile as readFile3, stat } 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";
-
-// 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 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);
-  return {
-    entries,
-    diagnostics,
-    directoryRemaining: existsSync(rulesDir) && (!obsoleteFallbackPresent || entries.length > 0)
-  };
-}
-async function walkAllEntries(dir, diagnostics) {
-  const entries = [];
-  try {
-    const items = await readdir(dir, { withFileTypes: true });
-    for (const item of items) {
-      const path = join(dir, item.name);
-      const kind = item.isDirectory() ? "directory" : "file";
-      entries.push({ path, kind });
-      if (kind === "directory")
-        entries.push(...await walkAllEntries(path, diagnostics));
-    }
-  } catch (error) {
-    if (error.code !== "ENOENT") {
-      diagnostics.push({ code: "walk_failed", operation: "readdir", path: dir, message: toErrorMessage(error) });
-    }
-  }
-  return entries;
-}
-async function walkFiles(dir, options = {}) {
-  const files = [];
-  try {
-    const items = await readdir(dir, { withFileTypes: true });
-    for (const item of items) {
-      if (item.name.startsWith("."))
-        continue;
-      const filePath = join(dir, item.name);
-      if (item.isDirectory())
-        files.push(...await walkFiles(filePath, options));
-      else
-        files.push(filePath);
-    }
-  } catch (error) {
-    if (error.code !== "ENOENT") {
-      options.onError?.({ code: "walk_failed", operation: "readdir", path: dir, message: toErrorMessage(error) });
-    }
-  }
-  return files;
-}
-function normalizeLogicalPath(pathValue) {
-  return pathValue.split(sep).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 });
-  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")}`);
-    process.exit(1);
-  }
-}
-async function cleanupEmptyParentDirs(path, stopDir) {
-  let parent = dirname(path);
-  while (parent !== stopDir) {
-    try {
-      const remaining = await readdir(parent);
-      if (remaining.length === 0)
-        await rmdir(parent);
-      else
-        break;
-    } catch {
-      break;
-    }
-    parent = dirname(parent);
-  }
-}
-async function detectProjectName() {
-  try {
-    if (existsSync("package.json")) {
-      const raw = await readFile("package.json", "utf-8");
-      const pkg = JSON.parse(raw);
-      if (pkg.name && pkg.name !== "")
-        return pkg.name;
-    }
-  } catch {
-  }
-  return basename(process.cwd());
-}
+import { readFile } from "fs/promises";
+import { dirname, join as join2, relative as relative2 } from "path";
 
 // 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 { readdir } from "fs/promises";
+import { isAbsolute, join, relative } 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 +114,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 = join(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 +129,7 @@ function resolveWorkRef(name, options = {}) {
   return ref;
 }
 function assertGroupBrief(changesDir, ref) {
-  const briefPath = join2(changesDir, ref.group, GROUP_BRIEF_FILENAME);
+  const briefPath = join(changesDir, ref.group, GROUP_BRIEF_FILENAME);
   const kind = getPathKind(briefPath, ref.name);
   if (kind === "missing") {
     throw new WorkRefError(
@@ -274,7 +173,7 @@ function assertRegularWorkFile(ref, mustExist) {
 }
 function resolveWorkRefPath(path, options = {}) {
   const changesDir = options.changesDir ?? CHANGES_DIR;
-  const logicalPath = normalizeLogicalPath2(relative2(changesDir, path));
+  const logicalPath = normalizeLogicalPath2(relative(changesDir, path));
   if (isAbsolute(logicalPath) || logicalPath === ".." || logicalPath.startsWith("../") || !logicalPath.endsWith(".md")) {
     throw new WorkRefError(
       "invalid_work_ref_path",
@@ -302,13 +201,13 @@ function resolveFocusMarkerPath(ref, options = {}) {
   assertNoManagedNormalizationCollision(focusDir, ref.name.split("/"), ref.name, "invalid_focus_path");
   if (ref.group) {
     assertOptionalManagedDirectory(
-      join2(focusDir, ref.group),
+      join(focusDir, ref.group),
       ref.name,
       "invalid_focus_path",
       "focus path"
     );
   }
-  const markerPath = join2(focusDir, ...ref.name.split("/"));
+  const markerPath = join(focusDir, ...ref.name.split("/"));
   try {
     requireManagedFile(markerPath, "focus marker", { allowMissing: true });
   } catch (error) {
@@ -324,7 +223,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 = join(archivesDir, ref.group);
   assertOptionalManagedDirectory(groupPath, ref.name, "invalid_archive_path", "archive path");
   return groupPath;
 }
@@ -343,7 +242,7 @@ async function inspectFocusTree(options = {}) {
   if (!rootEntries)
     return result;
   for (const entry of rootEntries) {
-    const path = join2(focusDir, entry.name);
+    const path = join(focusDir, entry.name);
     if (entry.name === ".gitkeep" && entry.isFile())
       continue;
     if (entry.isDirectory()) {
@@ -386,7 +285,7 @@ async function inspectArchiveTree(options = {}) {
   if (!rootEntries)
     return result;
   for (const entry of rootEntries) {
-    const path = join2(archivesDir, entry.name);
+    const path = join(archivesDir, entry.name);
     if (entry.name === "INDEX.md" && entry.isFile())
       continue;
     if (entry.isDirectory()) {
@@ -424,7 +323,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 = join(changesDir, entry.name);
     if (entry.name === ".gitkeep" && entry.isFile())
       continue;
     if (entry.isDirectory()) {
@@ -471,17 +370,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));
+    ), join(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: ${join(groupPath, GROUP_BRIEF_FILENAME)}`,
       group
-    ), join2(groupPath, GROUP_BRIEF_FILENAME));
+    ), join(groupPath, GROUP_BRIEF_FILENAME));
   }
   for (const entry of entries) {
     const input = `${group}/${entry.name}`;
-    const path = join2(groupPath, entry.name);
+    const path = join(groupPath, entry.name);
     if (entry.name === GROUP_BRIEF_FILENAME && !entry.isFile())
       continue;
     if (entry.name === "brief.md") {
@@ -510,7 +409,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 = join(groupPath, entry.name);
     if (entry.isDirectory()) {
       addDiagnostic(result, new WorkRefError(
         "unsupported_work_depth",
@@ -536,7 +435,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 = join(groupPath, entry.name);
     if (!entry.isFile() || !entry.name.endsWith(".md")) {
       addArchivePathDiagnostic(result, input, path);
       continue;
@@ -569,7 +468,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 readdir(path, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
   } catch (error) {
     addDiagnostic(result, asReadFailure(path, input, error), path);
     return null;
@@ -630,7 +529,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 = join(changesDir, ...segments.slice(0, depth));
     const parentKind = getPathKind(parent, input);
     if (parentKind === "missing")
       return;
@@ -663,7 +562,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 = join(root, ...segments.slice(0, depth));
     const parentKind = getPathKind(parent, input);
     if (parentKind === "missing")
       return;
@@ -688,8 +587,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 = join(changesDir, ...segments.slice(0, depth));
+    const filePath = finalFilename && depth === segments.length ? join(changesDir, ...segments.slice(0, -1), finalFilename) : `${identityPath}.md`;
     const fileKind = getPathKind(filePath, input);
     const identityKind = getPathKind(identityPath, input);
     const isPrefix = depth < segments.length;
@@ -783,13 +682,13 @@ function normalizeLogicalPath2(path) {
 var PLACEHOLDER_SUMMARY = "<\u2026>";
 function extractChangeSummary(content, document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA), options = {}) {
   try {
-    const frontmatter = parseFrontmatter(content);
+    const frontmatter = parseFrontmatter(document.markdown);
     const frontmatterSummary = meaningfulSummary(frontmatter?.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 +700,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 +708,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 +746,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 +774,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(relative2(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 readFile(path, "utf-8");
       const archivedChange = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
       const identity = getDocumentTitle(archivedChange, "identity");
       if (identity?.includes("/")) {
@@ -891,10 +797,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 +821,7 @@ async function inspectChangeGroups(options = {}) {
   for (const brief of workTree.briefs) {
     let content;
     try {
-      content = await readFile2(brief.path, "utf-8");
+      content = await readFile(brief.path, "utf-8");
     } catch (error) {
       diagnostics.push({
         severity: "error",
@@ -925,10 +832,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 +851,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(relative2(ARCHIVES_DIR, item.path));
       return archivePath === brief.group || archivePath.startsWith(`${brief.group}/`);
     })) {
       diagnostics.push({
@@ -1011,7 +919,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 +932,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 = join2(dirname(ref.path), GROUP_BRIEF_FILENAME);
   let content;
   try {
-    content = await readFile2(briefPath, "utf-8");
+    content = await readFile(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 +977,11 @@ async function hasArchivedGroupBrief(group) {
   }
   const groupPrefix = `${group}/`;
   for (const path of archiveTree.files) {
-    if (!normalizeLogicalPath(relative3(ARCHIVES_DIR, path)).startsWith(groupPrefix))
+    if (!normalizeLogicalPath(relative2(ARCHIVES_DIR, path)).startsWith(groupPrefix))
       continue;
     let content;
     try {
-      content = await readFile2(path, "utf-8");
+      content = await readFile(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,12 +991,11 @@ 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;
   try {
-    frontmatter = parseFrontmatter(content);
+    frontmatter = parseFrontmatter(document.markdown);
   } catch (error) {
     diagnostics.push({ severity: "error", code: "group_frontmatter_invalid", change: group, message: error instanceof Error ? error.message : String(error) });
   }
@@ -1095,12 +1004,12 @@ function parseGroupBrief(group, content) {
   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 +1038,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 +1053,13 @@ function groupSectionHeading(sectionId) {
 }
 
 // src/core/dependency-plan.ts
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile2 } 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 { isAbsolute as isAbsolute2, relative as relative3, resolve, sep } from "path";
 
 // src/history/model.ts
 var HISTORY_DEFAULT_LIMIT = 20;
@@ -1181,8 +1090,8 @@ 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 relativePath = relative3(archivesDir, sourcePath);
+  if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute2(relativePath)) {
     throw changed(options.projectPath);
   }
   let inspectedRoot;
@@ -1297,8 +1206,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 = relative3(root, path);
+  return candidate !== "" && candidate !== ".." && !candidate.startsWith(`..${sep}`) && !isAbsolute2(candidate);
 }
 function changed(projectPath) {
   return new ArchiveHistoryError(
@@ -1324,7 +1233,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, dirname as dirname2, relative as relative4, resolve as resolve2 } from "path";
 
 // src/core/issue-relationship.ts
 var ISSUE_RELATIONS = /* @__PURE__ */ new Set(["relates", "closes"]);
@@ -1456,18 +1365,18 @@ async function inspectArchiveHistory(options = {}) {
 }
 function parseArchiveEntry(current, path, maxFileBytes) {
   const { sourcePath, archivesDir, content } = current;
-  const nameMatch = basename2(sourcePath).match(ARCHIVE_NAME_RE);
+  const nameMatch = basename(sourcePath).match(ARCHIVE_NAME_RE);
   if (!nameMatch || !isCalendarDate(nameMatch[1])) {
     return { diagnostic: errorDiagnostic("archive_name_invalid", path, "archive filename must use a valid YYYY-MM-DD_name.md date") };
   }
   const date = nameMatch[1];
   const archiveStem = nameMatch[2];
-  const relativeDirectory = normalizeLogicalPath(relative5(archivesDir, dirname3(sourcePath)));
+  const relativeDirectory = normalizeLogicalPath(relative4(archivesDir, dirname2(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 groupDocument = parseRspDocument(changeDocument.markdown, GROUP_BRIEF_DOCUMENT_SCHEMA);
   const changeHeadings = getDocumentTitles(changeDocument, "identity");
   const groupHeadings = getDocumentTitles(groupDocument, "identity");
   if (changeHeadings.length + groupHeadings.length !== 1) {
@@ -1475,7 +1384,7 @@ function parseArchiveEntry(current, path, maxFileBytes) {
   }
   let frontmatter;
   try {
-    frontmatter = parseFrontmatter(content);
+    frontmatter = parseFrontmatter(changeDocument.markdown);
   } catch (error) {
     return { diagnostic: errorDiagnostic("archive_frontmatter_invalid", path, `archive frontmatter could not be parsed: ${toErrorMessage(error)}`) };
   }
@@ -1540,10 +1449,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(relative4(resolve2(archivesDir), resolve2(sourcePath)))}`;
 }
 function normalizeOutputPath(path, archivesDir) {
-  const relativePath = normalizeLogicalPath(relative5(resolve2(archivesDir), resolve2(path)));
+  const relativePath = normalizeLogicalPath(relative4(resolve2(archivesDir), resolve2(path)));
   return relativePath === "" ? ".rsp/archives" : `.rsp/archives/${relativePath}`;
 }
 function errorDiagnostic(code, path, message) {
@@ -1642,20 +1551,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 +1583,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 +1601,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 +1621,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 readFile2(brief.path, "utf-8")))
         blockedGroups.add(brief.group);
     } catch (error) {
       diagnostics.push({
@@ -1728,7 +1635,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 readFile2(ref.path, "utf-8"));
       if (ref.group && blockedGroups.has(ref.group))
         parsed.external = true;
       parsedByName.set(ref.name, parsed);
@@ -1833,18 +1740,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 +1852,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 +1930,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 +1946,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 +2013,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,12 +2024,13 @@ 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 readFile3(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);
+          const frontmatter = parseFrontmatter(document.markdown);
           kind = frontmatter?.kind ? String(frontmatter.kind) : "\u2014";
           issues = parseIssueRelationships(frontmatter);
         } catch (error) {
@@ -2143,10 +2052,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;
@@ -2217,12 +2125,12 @@ async function inspectProjectStatus(options = {}) {
       },
       progressKnown,
       title,
-      blockerEntries,
+      externalBlockers,
       readiness
     });
   }
   return {
-    manage,
+    workflow,
     language,
     focused: [...focusedSet].sort(),
     records,
@@ -2251,13 +2159,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) {
@@ -2267,616 +2168,6 @@ function deriveArchiveTrend(records) {
   return [...counts].sort(([left], [right]) => left.localeCompare(right)).map(([month, count]) => ({ month, count }));
 }
 
-// src/specs/model.ts
-var SPECS_DEFAULT_RESULT_LIMIT = 20;
-var SPECS_MAX_RESULT_LIMIT = 100;
-var SPECS_MAX_CANDIDATES = 1e3;
-var SPECS_MAX_FILE_BYTES = 512 * 1024;
-var SPECS_SEARCH_EXCERPT_CODE_POINTS = 240;
-var SPECS_DETAIL_CONTENT_CODE_POINTS = 12e3;
-var SPECS_MAX_DIAGNOSTICS = 20;
-
-// src/specs/query.ts
-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");
-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);
-var SpecsQueryError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "SpecsQueryError";
-  }
-  code;
-};
-async function inspectSpecs(options = {}) {
-  const projectRoot = await realpath2(resolve3(options.cwd ?? process.cwd()));
-  const specsRoot = resolve3(projectRoot, SPECS_ROOT);
-  const maxCandidates = options.maxCandidates ?? SPECS_MAX_CANDIDATES;
-  const maxFileBytes = options.maxFileBytes ?? SPECS_MAX_FILE_BYTES;
-  validatePositiveBound(maxCandidates, "maxCandidates");
-  validatePositiveBound(maxFileBytes, "maxFileBytes");
-  const configInspection = await inspectRspConfig(projectRoot);
-  if (configInspection.issues.length > 0)
-    throw new SpecsQueryError("invalid_config", configInspection.issues.join("; "));
-  const decisionRecordsPath = resolveDecisionRecordsPath(configInspection.config);
-  const decisionPathIssue = await validateDecisionRecordsFilesystemPath(decisionRecordsPath, projectRoot);
-  if (decisionPathIssue)
-    throw new SpecsQueryError("invalid_decision_records_path", decisionPathIssue);
-  const decisionRecordsRoot = resolve3(projectRoot, decisionRecordsPath);
-  const accumulator = {
-    documents: [],
-    generatedIndexes: [],
-    diagnostics: [],
-    candidateCount: 0,
-    candidateLimitReported: false
-  };
-  const excludedSpecDirectories = [DEFAULT_DECISION_RECORDS_PATH, decisionRecordsPath].map((path) => resolve3(projectRoot, path)).filter((path) => isInside(specsRoot, path));
-  await inspectDocumentRoot({
-    projectRoot,
-    root: specsRoot,
-    label: "Specs",
-    kind: "spec",
-    excludedDirectories: excludedSpecDirectories,
-    accumulator,
-    maxCandidates,
-    maxFileBytes,
-    allowMissing: false
-  });
-  await inspectDocumentRoot({
-    projectRoot,
-    root: decisionRecordsRoot,
-    label: "Decision Records",
-    kind: "decision-record",
-    excludedDirectories: [],
-    accumulator,
-    maxCandidates,
-    maxFileBytes,
-    allowMissing: options.allowMissingDecisionRecords === true
-  });
-  detectPathCollisions(accumulator);
-  accumulator.documents.sort(compareDocument);
-  accumulator.generatedIndexes.sort((left, right) => left.path.localeCompare(right.path));
-  const boundedDiagnostics = accumulator.diagnostics.slice(0, SPECS_MAX_DIAGNOSTICS);
-  return {
-    source: await inspectSourceIdentity(projectRoot),
-    roots: {
-      specs: toProjectPath(projectRoot, specsRoot),
-      decisions: toProjectPath(projectRoot, decisionRecordsRoot)
-    },
-    tree: buildDirectoryTree(projectRoot, specsRoot, "spec", accumulator.documents),
-    decisionRecords: buildDirectoryTree(projectRoot, decisionRecordsRoot, "decision-record", accumulator.documents),
-    documents: accumulator.documents.map(stripSource),
-    generatedIndexes: accumulator.generatedIndexes,
-    diagnostics: boundedDiagnostics,
-    diagnosticSummary: {
-      total: accumulator.diagnostics.length,
-      returned: boundedDiagnostics.length,
-      hasMore: accumulator.diagnostics.length > boundedDiagnostics.length
-    },
-    runtime: [],
-    limits: {
-      candidates: maxCandidates,
-      fileBytes: maxFileBytes,
-      results: SPECS_MAX_RESULT_LIMIT,
-      searchExcerptCodePoints: SPECS_SEARCH_EXCERPT_CODE_POINTS,
-      detailContentCodePoints: SPECS_DETAIL_CONTENT_CODE_POINTS
-    }
-  };
-}
-function specsInspectionComplete(inspection) {
-  return inspection.diagnostics.every((diagnostic) => diagnostic.severity !== "error");
-}
-async function readSpecsDetail(inspection, projectPath) {
-  const current = await readCurrentSpecsDocument(inspection, projectPath);
-  const bounded = boundCodePoints(current.content, SPECS_DETAIL_CONTENT_CODE_POINTS);
-  return {
-    ...current,
-    content: bounded.value,
-    contentTruncated: bounded.truncated
-  };
-}
-async function readCurrentSpecsDocument(inspection, projectPath) {
-  const normalized = normalizeRequestedPath(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 current = await readCurrentDocument(
-    sourcePath,
-    inspection.source.root,
-    document.path,
-    inspection.limits.fileBytes
-  );
-  const currentDocument = parseDocumentRecord(current.content, current.bytes, document.path, document.kind);
-  return {
-    ...currentDocument,
-    content: current.content
-  };
-}
-async function searchSpecs(inspection, literal, options = {}) {
-  return (await searchSpecsWithSources(inspection, literal, options)).result;
-}
-async function searchSpecsWithSources(inspection, literal, options = {}) {
-  const query = literal.trim();
-  if (query === "")
-    throw new SpecsQueryError("invalid_specs_search", "Specs search literal must be non-empty");
-  const limit = options.limit ?? 20;
-  if (!Number.isInteger(limit) || limit < 1 || limit > SPECS_MAX_RESULT_LIMIT)
-    throw new SpecsQueryError("invalid_specs_limit", `Specs search limit must be an integer from 1 through ${SPECS_MAX_RESULT_LIMIT}`);
-  const excerptCodePoints = options.excerptCodePoints ?? SPECS_SEARCH_EXCERPT_CODE_POINTS;
-  if (!Number.isInteger(excerptCodePoints) || excerptCodePoints < 40 || excerptCodePoints > 1e3)
-    throw new SpecsQueryError("invalid_specs_excerpt", "Specs search excerpt must be an integer from 40 through 1000 code points");
-  const lowered = query.toLowerCase();
-  const matches = [];
-  const documents = /* @__PURE__ */ new Map();
-  let matched = 0;
-  for (const document of inspection.documents) {
-    const current = await readCurrentDocument(
-      resolve3(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 lines = current.content.split(/\r?\n/);
-    let heading = null;
-    for (let index = 0; index < lines.length; index++) {
-      const parsedHeading = parseMarkdownHeading(lines[index]);
-      if (parsedHeading)
-        heading = parsedHeading.title;
-      const position = lines[index].toLowerCase().indexOf(lowered);
-      if (position < 0)
-        continue;
-      matched += 1;
-      if (matches.length < limit) {
-        if (!documents.has(document.path)) {
-          documents.set(document.path, {
-            ...currentDocument,
-            content: current.content
-          });
-        }
-        matches.push({
-          path: document.path,
-          kind: document.kind,
-          title: currentDocument.title,
-          heading,
-          line: index + 1,
-          excerpt: excerptAround(
-            lines[index],
-            [...lines[index].slice(0, position)].length,
-            [...query].length,
-            excerptCodePoints
-          )
-        });
-      }
-    }
-  }
-  return {
-    result: {
-      matches,
-      summary: {
-        candidates: inspection.documents.length,
-        searched: inspection.documents.length,
-        matched,
-        returned: matches.length,
-        hasMore: matched > matches.length
-      }
-    },
-    documents
-  };
-}
-async function inspectDocumentRoot(options) {
-  const inspection = await inspectManagedFileTree(options.root, options.label, { allowMissing: options.allowMissing });
-  for (const issue of inspection.issues) {
-    options.accumulator.diagnostics.push({
-      severity: "error",
-      code: "specs_tree_invalid",
-      path: toProjectPath(options.projectRoot, issue.path),
-      message: issue.message
-    });
-  }
-  if (!inspection.rootExists)
-    return;
-  for (const path of inspection.files) {
-    if (options.excludedDirectories.some((directory) => isInside(directory, path)))
-      continue;
-    const projectPath = toProjectPath(options.projectRoot, path);
-    const reserved = reservedIndexKind(options.root, path);
-    if (reserved) {
-      await classifyGeneratedIndex(path, options.projectRoot, projectPath, options.maxFileBytes, options.accumulator);
-      continue;
-    }
-    if (!path.endsWith(".md"))
-      continue;
-    options.accumulator.candidateCount += 1;
-    if (options.accumulator.candidateCount > options.maxCandidates) {
-      if (!options.accumulator.candidateLimitReported) {
-        options.accumulator.diagnostics.push({
-          severity: "error",
-          code: "specs_candidate_limit_exceeded",
-          path: projectPath,
-          message: `Specs candidate limit exceeded (${options.maxCandidates})`
-        });
-        options.accumulator.candidateLimitReported = true;
-      }
-      continue;
-    }
-    await inspectDocument(path, options.projectRoot, projectPath, options.kind, options.maxFileBytes, options.accumulator);
-  }
-}
-async function classifyGeneratedIndex(path, projectRoot, projectPath, maxFileBytes, accumulator) {
-  try {
-    const current = await readCurrentDocument(path, projectRoot, projectPath, maxFileBytes);
-    const recognized = isRecognizedGeneratedSpecsIndex(current.content, projectPath);
-    accumulator.generatedIndexes.push({
-      path: projectPath,
-      classification: recognized ? "safe-removal" : "owner-controlled",
-      reason: recognized ? "metadata recognizes the reserved path as a generated Specs index" : "reserved path content is not recognized generated Specs-index output"
-    });
-    if (!recognized) {
-      accumulator.diagnostics.push({
-        severity: "error",
-        code: "unrecognized_reserved_specs_index",
-        path: projectPath,
-        message: `reserved Specs index is owner-controlled and cannot be treated as generated content: ${projectPath}`
-      });
-    }
-  } catch (error) {
-    accumulator.generatedIndexes.push({
-      path: projectPath,
-      classification: "owner-controlled",
-      reason: "reserved path could not be boundedly inspected as generated Specs-index output"
-    });
-    accumulator.diagnostics.push({
-      severity: "error",
-      code: error instanceof SpecsQueryError ? error.code : "specs_index_read_failed",
-      path: projectPath,
-      message: `unable to inspect reserved Specs index ${projectPath}: ${error instanceof Error ? error.message : String(error)}`
-    });
-  }
-}
-function isRecognizedGeneratedSpecsIndex(content, projectPath) {
-  const metadata = parseFrontmatter(content);
-  const expectedSourceDirectory = normalizeLogicalPath(dirname4(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);
-    if (metadata?.kind === "generated-index")
-      return;
-    accumulator.documents.push({
-      sourcePath: path,
-      ...parseDocumentRecord(current.content, current.bytes, projectPath, kind)
-    });
-  } catch (error) {
-    accumulator.diagnostics.push({
-      severity: "error",
-      code: error instanceof SpecsQueryError ? error.code : "specs_file_read_failed",
-      path: projectPath,
-      message: `unable to read Specs document ${projectPath}: ${error instanceof Error ? error.message : String(error)}`
-    });
-  }
-}
-function detectPathCollisions(accumulator) {
-  const seen = /* @__PURE__ */ new Map();
-  for (const document of accumulator.documents) {
-    const canonical = document.path.normalize("NFC");
-    const existing = seen.get(canonical);
-    if (existing && existing !== document.path) {
-      accumulator.diagnostics.push({
-        severity: "error",
-        code: "specs_path_collision",
-        path: document.path,
-        message: `Specs path normalization collision: ${existing} and ${document.path}`
-      });
-    } else {
-      seen.set(canonical, document.path);
-    }
-    if (canonical !== document.path) {
-      accumulator.diagnostics.push({
-        severity: "error",
-        code: "specs_path_not_canonical",
-        path: document.path,
-        message: `Specs path must use canonical NFC form: ${document.path}`
-      });
-    }
-  }
-}
-function buildDirectoryTree(projectRoot, root, kind, documents) {
-  const rootPath = toProjectPath(projectRoot, root);
-  const tree = {
-    name: basename3(root),
-    path: rootPath,
-    directories: [],
-    documents: []
-  };
-  for (const document of documents.filter((candidate) => candidate.kind === kind)) {
-    const rel = relative6(root, document.sourcePath);
-    if (rel === ".." || rel.startsWith(`..${sep3}`) || isAbsolute3(rel))
-      continue;
-    const segments = normalizeLogicalPath(rel).split("/");
-    let current = tree;
-    for (const segment of segments.slice(0, -1)) {
-      let child = current.directories.find((directory) => directory.name === segment);
-      if (!child) {
-        child = {
-          name: segment,
-          path: `${current.path}/${segment}`,
-          directories: [],
-          documents: []
-        };
-        current.directories.push(child);
-        current.directories.sort((left, right) => left.name.localeCompare(right.name));
-      }
-      current = child;
-    }
-    current.documents.push(stripSource(document));
-    current.documents.sort(compareDocument);
-  }
-  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 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) {
-  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("<!--"))
-      continue;
-    return line.replace(/^[-*]\s*/, "").trim() || null;
-  }
-  return null;
-}
-async function inspectSourceIdentity(projectRoot) {
-  const root = normalizeLogicalPath(projectRoot);
-  const head = runGit(["rev-parse", "HEAD"], projectRoot);
-  const branch = runGit(["symbolic-ref", "--quiet", "--short", "HEAD"], projectRoot);
-  const status = spawnSync("git", ["status", "--porcelain=v1", "--untracked-files=normal"], {
-    cwd: root,
-    encoding: "utf-8",
-    maxBuffer: 256 * 1024
-  });
-  return {
-    root,
-    gitHead: head,
-    gitBranch: branch,
-    dirty: status.status === 0 ? status.stdout.trim() !== "" : status.error && status.error.code === "ENOBUFS" ? true : null
-  };
-}
-function runGit(args, cwd) {
-  const result = spawnSync("git", args, { cwd, encoding: "utf-8", maxBuffer: 64 * 1024 });
-  return result.status === 0 ? result.stdout.trim() || null : null;
-}
-function normalizeRequestedPath(pathValue) {
-  const trimmed = pathValue.trim();
-  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("../"))
-    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))
-    return "legacy";
-  return null;
-}
-function excerptAround(line, matchStart, matchLength, limit) {
-  const codePoints = [...line];
-  if (codePoints.length <= limit)
-    return codePoints.join("").trim();
-  const before = Math.max(0, matchStart - Math.floor((limit - matchLength) / 2));
-  const value = codePoints.slice(before, before + limit).join("").trim();
-  return `${before > 0 ? "\u2026" : ""}${value}${before + limit < codePoints.length ? "\u2026" : ""}`;
-}
-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)) {
-    throw changed2();
-  }
-  const inspection = inspectManagedFile(sourcePath, "Specs document");
-  if (inspection.issue)
-    throw changed2();
-  let inspectedRoot;
-  let inspected;
-  let realRoot;
-  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)) {
-      throw changed2();
-    }
-  } catch (error) {
-    if (error instanceof SpecsQueryError)
-      throw error;
-    throw changed2();
-  }
-  let handle;
-  try {
-    handle = await open2(sourcePath, READ_NO_FOLLOW_FLAGS2);
-  } catch {
-    throw changed2();
-  }
-  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)) {
-      throw changed2();
-    }
-    if (opened.size > BigInt(maxFileBytes))
-      throw new SpecsQueryError("specs_file_too_large", `Specs document exceeds the ${maxFileBytes}-byte inspection limit: ${projectPath}`);
-    const current = await readBoundedDocument(handle, opened, projectPath, maxFileBytes);
-    await validateCurrentSpecsPath({
-      sourcePath,
-      sourceRoot,
-      relativePath,
-      realRoot,
-      inspectedRoot,
-      finalHandle: current.final,
-      projectPath
-    });
-    return {
-      content: current.content,
-      bytes: current.bytes
-    };
-  } catch (error) {
-    if (error instanceof SpecsQueryError)
-      throw error;
-    throw changed2();
-  } finally {
-    await handle.close();
-  }
-}
-async function readBoundedDocument(handle, opened, projectPath, maxFileBytes) {
-  const buffer = Buffer3.allocUnsafe(maxFileBytes + 1);
-  let bytes = 0;
-  while (bytes < buffer.length) {
-    const result = await handle.read(buffer, bytes, buffer.length - bytes, bytes);
-    if (result.bytesRead === 0)
-      break;
-    bytes += result.bytesRead;
-  }
-  const final = await handle.stat({ bigint: true });
-  if (bytes > maxFileBytes || final.size > BigInt(maxFileBytes))
-    throw new SpecsQueryError("specs_file_too_large", `Specs document exceeds the ${maxFileBytes}-byte inspection limit: ${projectPath}`);
-  if (!sameIdentity2(opened, final) || !sameSnapshot2(opened, final) || final.size !== BigInt(bytes)) {
-    throw new SpecsQueryError("specs_file_changed", `Specs document is no longer a readable regular file: ${projectPath}`);
-  }
-  return {
-    content: buffer.subarray(0, bytes).toString("utf-8"),
-    bytes,
-    final
-  };
-}
-async function validateCurrentSpecsPath(options) {
-  const changed2 = () => new SpecsQueryError("specs_file_changed", `Specs document is no longer a readable regular file: ${options.projectPath}`);
-  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)) {
-      throw changed2();
-    }
-  } catch (error) {
-    if (error instanceof SpecsQueryError)
-      throw error;
-    throw changed2();
-  }
-}
-function sameIdentity2(left, right) {
-  return left.dev === right.dev && left.ino === right.ino;
-}
-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);
-}
-function boundCodePoints(value, limit) {
-  const codePoints = [...value];
-  return {
-    value: codePoints.slice(0, limit).join(""),
-    truncated: codePoints.length > limit
-  };
-}
-function stripSource(document) {
-  const { sourcePath: _sourcePath, ...record } = document;
-  return record;
-}
-function parseDocumentRecord(content, bytes, path, kind) {
-  const metadata = parseFrontmatter(content);
-  const headings = extractHeadings(content);
-  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),
-    bytes,
-    headings
-  };
-}
-function compareDocument(left, right) {
-  return left.path.localeCompare(right.path);
-}
-function validatePositiveBound(value, label) {
-  if (!Number.isInteger(value) || value < 1)
-    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}`);
-}
-function toProjectPath(projectRoot, path) {
-  return normalizeLogicalPath(relative6(projectRoot, path)) || ".";
-}
-
 // src/specs/projection.ts
 function projectSpecsTree(inspection) {
   assertCompleteInspection(inspection);
@@ -2970,13 +2261,6 @@ export {
   IssueRelationshipError,
   parseIssueRelationships,
   createIssueRelationship,
-  walkMarkdownFiles,
-  inspectUnsupportedRules,
-  normalizeLogicalPath,
-  isValidSpecName,
-  guardRspInitialized,
-  cleanupEmptyParentDirs,
-  detectProjectName,
   GROUP_BRIEF_FILENAME,
   WorkRefError,
   normalizeWorkRefSegment,
@@ -3005,15 +2289,6 @@ export {
   readArchiveHistoryDocument,
   historyInspectionComplete,
   inspectChangeDependencies,
-  SPECS_DEFAULT_RESULT_LIMIT,
-  SPECS_MAX_RESULT_LIMIT,
-  SPECS_MAX_FILE_BYTES,
-  SPECS_SEARCH_EXCERPT_CODE_POINTS,
-  SPECS_DETAIL_CONTENT_CODE_POINTS,
-  SpecsQueryError,
-  inspectSpecs,
-  specsInspectionComplete,
-  isRecognizedGeneratedSpecsIndex,
   collectArchiveReadiness,
   toArchiveReadinessOutput,
   buildDurableReviewGuidance,