@oevery/rsp 4.0.0 → 4.2.0

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

@@ -1,1094 +1,62 @@
 #!/usr/bin/env node
-
-// src/core/config.ts
-import { readFile } from "fs/promises";
-import { dirname as dirname2, join as join3, resolve as resolve2 } from "path";
-import { fileURLToPath } from "url";
-import pc from "picocolors";
-import { stringify } from "yaml";
-
-// src/core/markdown.mjs
-import { fromHtml } from "hast-util-from-html";
-import { fromMarkdown } from "mdast-util-from-markdown";
-import { frontmatterFromMarkdown } from "mdast-util-frontmatter";
-import { gfmFromMarkdown } from "mdast-util-gfm";
-import { frontmatter } from "micromark-extension-frontmatter";
-import { gfm } from "micromark-extension-gfm";
-var htmlTokenAnalyses = /* @__PURE__ */ new WeakMap();
-var matters = ["yaml", { type: "yaml", fence: { open: "---", close: "..." } }];
-var extensions = [gfm(), frontmatter(matters)];
-var mdastExtensions = [gfmFromMarkdown(), frontmatterFromMarkdown(matters)];
-function parseMarkdown(input, options = {}) {
-  if (typeof input !== "string")
-    return input;
-  const syntax = options.frontmatter === false ? { extensions: [gfm()], mdastExtensions: [gfmFromMarkdown()] } : { extensions, mdastExtensions };
-  return { source: input, root: fromMarkdown(input, syntax), start: 0, end: input.length };
-}
-function walkMarkdown(node, visit) {
-  if (visit(node) === false)
-    return;
-  if ("children" in node) {
-    for (const child of node.children)
-      walkMarkdown(child, visit);
-  }
-}
-function markdownNodeSource(input, node) {
-  const { source } = parseMarkdown(input);
-  return source.slice(node.position?.start.offset ?? 0, node.position?.end.offset ?? 0);
-}
-function isMarkdownComment(node) {
-  return node.type === "html" && !readHtmlToken(node, node.value).maskedSource.trim();
-}
-function htmlComments(value) {
-  if (!value.includes("<!--"))
-    return [];
-  const comments = [];
-  function visit(node, topLevel) {
-    if (node.type === "comment" && node.position)
-      comments.push({ start: node.position.start.offset ?? 0, end: node.position.end.offset ?? value.length, topLevel });
-    if ("children" in node)
-      node.children.forEach((child) => visit(child, node.type === "root"));
-  }
-  visit(fromHtml(value, { fragment: true }), false);
-  return comments;
-}
-function readHtmlToken(node, value) {
-  let analyses = htmlTokenAnalyses.get(node);
-  const cached = analyses?.get(value);
-  if (cached)
-    return cached;
-  const comments = htmlComments(value);
-  const analysis = {
-    comments,
-    maskedSource: maskSourceRanges(value, comments.map((comment) => [comment.start, comment.end]), 0, value.length)
-  };
-  if (!analyses) {
-    analyses = /* @__PURE__ */ new Map();
-    htmlTokenAnalyses.set(node, analyses);
-  }
-  analyses.set(value, analysis);
-  return analysis;
-}
-function markdownTopLevelComments(input) {
-  const document = parseMarkdown(input);
-  return document.root.children.flatMap((node) => {
-    if (node.type !== "html")
-      return [];
-    const source = markdownNodeSource(document, node);
-    const offset = node.position?.start.offset ?? document.start;
-    return readHtmlToken(node, source).comments.filter((comment) => comment.topLevel).map((comment) => ({
-      start: offset + comment.start,
-      end: offset + comment.end,
-      source: source.slice(comment.start, comment.end)
-    }));
-  });
-}
-function maskSourceRanges(source, ranges, start, end) {
-  let result = "";
-  let offset = start;
-  for (const [from, until] of ranges.sort((a, b) => a[0] - b[0])) {
-    result += source.slice(offset, from);
-    result += source.slice(from, until).replace(/[^\r\n]/g, " ");
-    offset = until;
-  }
-  return result + source.slice(offset, end);
-}
-function markdownText(node) {
-  if (node.type === "yaml")
-    return "";
-  if (node.type === "html")
-    return readHtmlToken(node, node.value).maskedSource;
-  if (node.type === "image" || node.type === "imageReference")
-    return node.alt ?? "";
-  if ("value" in node)
-    return node.value;
-  if ("children" in node) {
-    const separator = ["root", "list", "listItem", "blockquote"].includes(node.type) ? "\n" : "";
-    return node.children.map((child) => markdownText(child)).filter(Boolean).join(separator);
-  }
-  return node.type === "break" ? "\n" : "";
-}
-function markdownSection(document, nodes, start, end) {
-  return { source: document.source, root: { type: "root", children: nodes }, start, end };
-}
-function visibleMarkdownSource(input, options = {}) {
-  const document = parseMarkdown(input);
-  const visibleNodes = /* @__PURE__ */ new Set();
-  function markVisibleContent(node) {
-    if (node.type === "yaml" || node.type === "code" && !options.includeCode)
-      return false;
-    let visible = false;
-    if (node.type === "image" || node.type === "imageReference" || node.type === "footnoteReference")
-      visible = true;
-    else if (node.type === "html")
-      visible = !isMarkdownComment(node);
-    else if ("value" in node)
-      visible = Boolean(node.value.trim());
-    else if ("children" in node)
-      visible = node.children.map(markVisibleContent).some(Boolean);
-    if (visible)
-      visibleNodes.add(node);
-    return visible;
-  }
-  markVisibleContent(document.root);
-  const ranges = [];
-  walkMarkdown(document.root, (node) => {
-    if (!visibleNodes.has(node)) {
-      const start = Math.max(document.start, node.position?.start.offset ?? document.start);
-      const end = Math.min(document.end, node.position?.end.offset ?? document.end);
-      if (end > start)
-        ranges.push([start, end]);
-      return false;
-    }
-    if (node.type === "html") {
-      const nodeStart = node.position?.start.offset ?? document.start;
-      for (const comment of readHtmlToken(node, markdownNodeSource(document, node)).comments)
-        ranges.push([nodeStart + comment.start, nodeStart + comment.end]);
-      return false;
-    }
-  });
-  return maskSourceRanges(document.source, ranges, document.start, document.end);
-}
-function visibleMarkdownLines(input) {
-  return visibleMarkdownSource(input).split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-}
-function markdownListItems(input) {
-  const document = parseMarkdown(input);
-  const items = [];
-  walkMarkdown(document.root, (node) => {
-    if (node.type === "blockquote" || node.type === "footnoteDefinition")
-      return false;
-    if (node.type === "listItem") {
-      const source = markdownNodeSource(document, node);
-      items.push({ node, line: source.split(/\r?\n/, 1)[0].trim() });
-    }
-  });
-  return items;
-}
-function markdownFrontmatter(input) {
-  const document = parseMarkdown(input);
-  const node = document.root.children[0];
-  if (node?.type !== "yaml" || node.position?.start.offset !== 0)
-    return null;
-  const raw = markdownNodeSource(document, node);
-  const lines = raw.split(/\r?\n/);
-  if (lines[0] !== "---" || !["---", "..."].includes(lines.at(-1) ?? ""))
-    return null;
-  let end = node.position.end.offset ?? raw.length;
-  if (document.source.slice(end, end + 2) === "\r\n")
-    end += 2;
-  else if (document.source[end] === "\n")
-    end++;
-  return { node, value: node.value, end };
-}
-function markdownProse(input) {
-  const document = parseMarkdown(input);
-  const fragments = [];
-  walkMarkdown(document.root, (node) => {
-    if (node.type === "text" || node.type === "html")
-      fragments.push({ value: markdownText(node), line: node.position?.start.line ?? 1 });
-  });
-  return fragments;
-}
-
-// src/core/document-model.ts
-var CHANGE_DOCUMENT_SCHEMA = {
-  titlePrefix: "# Change:",
-  sections: [
-    { id: "proposal", heading: "Proposal" },
-    { id: "spec", heading: "Spec" },
-    { id: "design", heading: "Design" },
-    { id: "tasks", heading: "Tasks" },
-    { id: "verify", heading: "Verify" },
-    { id: "blockers", heading: "Blockers" }
-  ]
-};
-var GROUP_BRIEF_DOCUMENT_SCHEMA = {
-  titlePrefix: "# Change Group:",
-  sections: [
-    { id: "goal", heading: "Goal" },
-    { id: "scope", heading: "Scope" },
-    { id: "sharedConstraints", heading: "Shared Constraints" },
-    { id: "slices", heading: "Slices" },
-    { id: "completionConditions", heading: "Completion Conditions" },
-    { id: "durableOutcomes", heading: "Durable Outcomes" },
-    { id: "blockers", heading: "Blockers" }
-  ]
-};
-var DocumentSectionCardinalityError = class extends Error {
-  constructor(sectionId, count) {
-    super(`document must contain exactly one ${sectionId} section; found ${count}`);
-    this.sectionId = sectionId;
-    this.count = count;
-    this.name = "DocumentSectionCardinalityError";
-  }
-  sectionId;
-  count;
-};
-function parseRspDocument(input, schema) {
-  const markdown = parseMarkdown(input);
-  const source = markdown.source;
-  const definitionsByHeading = new Map(schema.sections.map((definition) => [definition.heading, definition]));
-  const observedHeadings = collectLevelTwoHeadings(markdown);
-  const sections = /* @__PURE__ */ new Map();
-  const unknownHeadings = [];
-  for (let index = 0; index < observedHeadings.length; index++) {
-    const observed = observedHeadings[index];
-    const definition = definitionsByHeading.get(observed.heading);
-    if (!definition) {
-      unknownHeadings.push(observed.heading);
-      continue;
-    }
-    const nextHeading = observedHeadings[index + 1];
-    const bodyEnd = nextHeading ? lineBreakStart(source, nextHeading.start) : source.length;
-    const section = {
-      id: definition.id,
-      heading: definition.heading,
-      canonical: observed.canonical,
-      bodyEnd,
-      markdown: markdownSection(markdown, markdown.root.children.filter((node) => (node.position?.start.offset ?? 0) >= observed.end && (node.position?.end.offset ?? source.length) <= bodyEnd), observed.end, bodyEnd)
-    };
-    const matches = sections.get(definition.id) ?? [];
-    matches.push(section);
-    sections.set(definition.id, matches);
-  }
-  const missingSections = schema.sections.filter((definition) => !sections.has(definition.id)).map((definition) => definition.id);
-  const duplicateSections = schema.sections.filter((definition) => (sections.get(definition.id)?.length ?? 0) > 1).map((definition) => definition.id);
-  const titleOccurrences = collectDocumentTitles(markdown, schema.titlePrefix);
-  const titles = titleOccurrences.map((title) => title.value);
-  return {
-    source,
-    markdown,
-    schema,
-    title: titles[0] ?? null,
-    titles,
-    titleOccurrences,
-    sections,
-    unknownHeadings,
-    missingSections,
-    duplicateSections
-  };
-}
-function getDocumentTitles(document, compatibility = "broad") {
-  if (compatibility === "broad")
-    return document.titles;
-  return document.titleOccurrences.filter((title) => compatibility === "identity" ? title.identityCompatible : title.spaced).map((title) => title.value);
-}
-function getDocumentTitle(document, compatibility = "broad") {
-  return getDocumentTitles(document, compatibility)[0] ?? null;
-}
-function getDocumentSections(document, sectionId) {
-  return document.sections.get(sectionId) ?? [];
-}
-function getDocumentSection(document, sectionId) {
-  return getDocumentSections(document, sectionId)[0];
-}
-function getDocumentSectionMarkdown(document, sectionId) {
-  return getDocumentSection(document, sectionId)?.markdown ?? markdownSection(document.markdown, [], 0, 0);
-}
-function getDocumentSectionDefinitionByHeading(schema, heading) {
-  return schema.sections.find((candidate) => candidate.heading === heading);
-}
-function getCanonicalSectionHeadings(schema) {
-  return schema.sections.map((section) => section.heading);
-}
-function renderDocumentSectionHeading(schema, sectionId) {
-  const definition = schema.sections.find((candidate) => candidate.id === sectionId);
-  if (!definition)
-    throw new Error(`unknown document section: ${sectionId}`);
-  return `## ${definition.heading}`;
-}
-function renderDocumentTitle(schema, title) {
-  return `${schema.titlePrefix} ${title}`;
-}
-function appendDocumentSectionItem(document, sectionId, item) {
-  const matches = getDocumentSections(document, sectionId);
-  if (matches.length !== 1)
-    throw new DocumentSectionCardinalityError(sectionId, matches.length);
-  const insertAt = matches[0].bodyEnd;
-  const before = document.source.slice(0, insertAt);
-  const separator = before.endsWith("\n\n") ? "" : before.endsWith("\n") ? "\n" : "\n\n";
-  return `${before}${separator}${item}
-${document.source.slice(insertAt)}`;
-}
-function collectLevelTwoHeadings(document) {
-  const headings = [];
-  for (const node of document.root.children) {
-    if (node.type !== "heading" || node.depth !== 2 || node.position?.start.column !== 1)
-      continue;
-    const raw = markdownNodeSource(document, node);
-    if (!raw.startsWith("## ") || raw.includes("\n"))
-      continue;
-    const value = raw.slice(3);
-    const heading = value.trimEnd();
-    headings.push({
-      heading,
-      canonical: heading === value,
-      start: node.position.start.offset,
-      end: node.position.end.offset
-    });
-  }
-  return headings;
-}
-function collectDocumentTitles(document, prefix) {
-  const titles = [];
-  for (const node of document.root.children) {
-    if (node.type !== "heading" || node.depth !== 1)
-      continue;
-    const start = node.position.start.offset;
-    const lineStart = document.source.lastIndexOf("\n", start - 1) + 1;
-    const line = document.source.slice(lineStart, node.position.end.offset);
-    const trimmed = line.trim();
-    if (!trimmed.startsWith(prefix))
-      continue;
-    const identity = line.startsWith(prefix) ? line.slice(prefix.length).match(/^\s+(\S+)\s*$/) : null;
-    titles.push({
-      value: trimmed.slice(prefix.length).trim(),
-      identityCompatible: identity !== null,
-      spaced: line.startsWith(`${prefix} `)
-    });
-  }
-  return titles;
-}
-function lineBreakStart(source, headingStart) {
-  if (headingStart > 0 && source[headingStart - 1] === "\n")
-    return headingStart - 1;
-  return headingStart;
-}
-
-// src/core/yaml.mjs
-import { parseDocument } from "yaml";
-function parseYamlDocument(source) {
-  const document = parseDocument(source, { keepSourceTokens: true });
-  if (document.errors.length)
-    throw new Error(document.errors.map((error) => error.message).join("; "));
-  return document;
-}
-function yamlMapping(document) {
-  const value = document.toJS();
-  if (value === null || value === void 0)
-    return {};
-  if (typeof value !== "object" || Array.isArray(value))
-    throw new Error("YAML document must be a mapping/object");
-  return value;
-}
-
-// src/core/content.ts
-function parseYamlText(text) {
-  return yamlMapping(parseYamlDocument(text));
-}
-function parseFrontmatter(content) {
-  const matter = markdownFrontmatter(content);
-  return matter ? parseYamlText(matter.value) : null;
-}
-function checkboxItem(line) {
-  const marker = line.match(/^[-*+]\s+\[([ /x-])\]/i);
-  return marker ? { state: marker[1].toLowerCase(), line } : null;
-}
-function collectCheckboxItems(content) {
-  return markdownListItems(content).flatMap(({ line }) => {
-    const item = checkboxItem(line);
-    return item ? [item] : [];
-  });
-}
-function countCheckboxItems(items) {
-  const count = { todo: 0, progress: 0, done: 0, dropped: 0, total: items.length };
-  for (const { state } of items) {
-    if (state === " ")
-      count.todo++;
-    else if (state === "/")
-      count.progress++;
-    else if (state === "x")
-      count.done++;
-    else
-      count.dropped++;
-  }
-  return count;
-}
-function countCheckboxes(content) {
-  return countCheckboxItems(collectCheckboxItems(content));
-}
-function collectVerifyCheckboxes(content) {
-  const document = parseMarkdown(content);
-  const buckets = { required: [], optional: [], unclassified: [] };
-  let current = "unclassified";
-  let sawClassificationHeading = false;
-  walkMarkdown(document.root, (node) => {
-    if (node.type === "blockquote" || node.type === "footnoteDefinition")
-      return false;
-    if (node.type === "heading" && node.depth === 3 && node.position?.start.column === 1) {
-      const heading = markdownNodeSource(document, node).match(/^###\s+(Required|Optional)\s*$/i);
-      if (heading) {
-        current = heading[1].toLowerCase();
-        sawClassificationHeading = true;
-      }
-    }
-    if (node.type === "listItem") {
-      const line = markdownNodeSource(document, node).split(/\r?\n/, 1)[0].trim();
-      const item = checkboxItem(line);
-      if (item)
-        buckets[current].push(item);
-    }
-  });
-  return { ...buckets, legacy: buckets.unclassified.length > 0 || !sawClassificationHeading };
-}
-function summarizeVerifyCheckboxes(buckets) {
-  return {
-    required: countCheckboxItems([...buckets.required, ...buckets.unclassified]),
-    optional: countCheckboxItems(buckets.optional),
-    unclassified: countCheckboxItems(buckets.unclassified),
-    legacy: buckets.legacy
-  };
-}
-function openCheckboxLines(items) {
-  return items.filter((item) => item.state === " " || item.state === "/").map((item) => item.line);
-}
-function getOpenCheckboxes(content) {
-  return openCheckboxLines(collectCheckboxItems(content));
-}
-function changeDocument(content) {
-  return typeof content === "string" ? parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA) : content;
-}
-function hasMeaningfulBlockerBody(body) {
-  return readBlockerEntries(body).length > 0;
-}
-function getVisibleBodyLines(body) {
-  return visibleMarkdownLines(body);
-}
-function hasMeaningfulBlockers(content) {
-  return hasMeaningfulBlockerBody(getDocumentSectionMarkdown(changeDocument(content), "blockers"));
-}
-function isEmptyBlockerLine(line) {
-  const normalized = line.trim();
-  return /^none[.。]?$/i.test(normalized) || /^[-*]\s*(?:none[.。]?)?$/i.test(normalized);
-}
-var REQUIRES_RE = /^[-*]\s+requires\s+`([^`]+)`:[ \t]*(\S.*)$/i;
-function readBlockerEntries(input) {
-  const document = parseMarkdown(input);
-  const entries = [];
-  const nodeLines = (node, start = node.position.start.offset) => getVisibleBodyLines(
-    markdownSection(document, [node], start, node.position.end.offset)
-  );
-  const text = (line) => line.replace(/^[-*]\s+/, "").trim();
-  const appendExternal = (lines) => {
-    for (const line of lines) {
-      if (!isEmptyBlockerLine(line))
-        entries.push({ kind: "external", line, text: text(line) });
-    }
-  };
-  const visit = (node) => {
-    if (node.type === "code")
-      return;
-    if (node.type !== "list") {
-      appendExternal(nodeLines(node));
-      return;
-    }
-    for (const item of node.children) {
-      for (const [index, child] of item.children.entries()) {
-        if (child.type === "list" || child.type === "code") {
-          visit(child);
-          continue;
-        }
-        const lines = nodeLines(child, index === 0 ? item.position.start.offset : child.position.start.offset);
-        if (index === 0 && child.type === "paragraph") {
-          const line = lines[0] ?? "";
-          const dependency = line.match(REQUIRES_RE);
-          if (dependency) {
-            entries.push({ kind: "dependency", line, text: text(line), name: dependency[1], reason: dependency[2] });
-            lines.shift();
-          } else if (/^[-*]\s+requires\b/i.test(line)) {
-            entries.push({ kind: "malformed-dependency", line, text: text(line) });
-            lines.shift();
-          }
-        }
-        appendExternal(lines);
-      }
-    }
-  };
-  document.root.children.forEach(visit);
-  return entries;
-}
-function detectDeltaSections(content) {
-  const body = getDocumentSectionMarkdown(changeDocument(content), "spec");
-  const labels = new Set(body.root.children.filter((node) => node.type === "heading" && node.depth === 3).map((node) => markdownText(node).trim().toUpperCase()));
-  return { added: labels.has("ADDED"), modified: labels.has("MODIFIED"), removed: labels.has("REMOVED") };
-}
-function parseScenarios(content) {
-  const document = parseMarkdown(content);
-  const scenarios = [];
-  let scenario = null;
-  for (const node of document.root.children) {
-    if (node.type === "heading" && node.depth <= 4) {
-      const title = markdownText(node);
-      scenario = (node.depth === 3 || node.depth === 4) && /^Scenario:\s*\S/i.test(title) ? { heading: title.slice(title.indexOf(":") + 1).trim(), steps: [] } : null;
-      if (scenario)
-        scenarios.push(scenario);
-      continue;
-    }
-    if (scenario && node.type === "list") {
-      for (const item of node.children) {
-        const line = markdownNodeSource(document, item).split(/\r?\n/, 1)[0].trim();
-        const step = line.replace(/^[-*+]\s+/, "");
-        if (/^(?:GIVEN|WHEN|THEN|AND|BUT)\b/i.test(step))
-          scenario.steps.push(step);
-      }
-    }
-  }
-  return scenarios.filter((item) => item.steps.length > 0);
-}
-
-// src/core/decisions.ts
-import { existsSync } from "fs";
-import { mkdir, readdir as readdir2, realpath, stat } from "fs/promises";
-import { dirname, isAbsolute, join as join2, posix, relative, resolve, sep } from "path";
-
-// src/core/managed-path.ts
-import { lstatSync } from "fs";
-import { readdir, writeFile } from "fs/promises";
-import { join } from "path";
-var ManagedPathError = class extends Error {
-  constructor(path, message) {
-    super(message);
-    this.path = path;
-    this.name = "ManagedPathError";
-  }
-  path;
-};
-function inspectManagedDirectory(path, label, options = {}) {
-  try {
-    const stats = lstatSync(path);
-    if (stats.isDirectory())
-      return { exists: true, issue: null };
-    return {
-      exists: true,
-      issue: new ManagedPathError(path, `${label} must be a real directory: ${path}`)
-    };
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      if (options.allowMissing)
-        return { exists: false, issue: null };
-      return {
-        exists: false,
-        issue: new ManagedPathError(path, `${label} must be a real directory: ${path}`)
-      };
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      exists: false,
-      issue: new ManagedPathError(path, `unable to inspect ${label} ${path}: ${message}`)
-    };
-  }
-}
-function requireManagedDirectory(path, label, options = {}) {
-  const inspection = inspectManagedDirectory(path, label, options);
-  if (inspection.issue)
-    throw inspection.issue;
-  return inspection.exists;
-}
-function inspectManagedFile(path, label, options = {}) {
-  try {
-    const stats = lstatSync(path);
-    if (stats.isFile())
-      return { exists: true, issue: null };
-    return {
-      exists: true,
-      issue: new ManagedPathError(path, `${label} must be a regular file: ${path}`)
-    };
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      if (options.allowMissing)
-        return { exists: false, issue: null };
-      return {
-        exists: false,
-        issue: new ManagedPathError(path, `${label} must be a regular file: ${path}`)
-      };
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      exists: false,
-      issue: new ManagedPathError(path, `unable to inspect ${label} ${path}: ${message}`)
-    };
-  }
-}
-function requireManagedFile(path, label, options = {}) {
-  const inspection = inspectManagedFile(path, label, options);
-  if (inspection.issue)
-    throw inspection.issue;
-  return inspection.exists;
-}
-async function ensureManagedFile(path, content, label) {
-  if (requireManagedFile(path, label, { allowMissing: true }))
-    return false;
-  await writeFile(path, content, { flag: "wx" });
-  return true;
-}
-async function writeManagedFile(path, content, label) {
-  const exists = requireManagedFile(path, label, { allowMissing: true });
-  if (exists)
-    await writeFile(path, content);
-  else
-    await writeFile(path, content, { flag: "wx" });
-}
-function resolveManagedDirectoryChain(root, segments, label) {
-  requireManagedDirectory(root, `${label} root`);
-  let current = root;
-  for (const segment of segments) {
-    if (!segment || segment === "." || segment === ".." || segment.includes("/") || segment.includes("\\"))
-      throw new ManagedPathError(current, `${label} contains an invalid directory segment: ${segment}`);
-    current = join(current, segment);
-    requireManagedDirectory(current, label, { allowMissing: true });
-  }
-  return current;
-}
-async function inspectManagedFileTree(root, label, options = {}) {
-  const result = { rootExists: false, files: [], issues: [] };
-  const rootInspection = inspectManagedDirectory(root, `${label} root`, options);
-  if (rootInspection.issue) {
-    result.issues.push(rootInspection.issue);
-    return result;
-  }
-  if (!rootInspection.exists)
-    return result;
-  result.rootExists = true;
-  await collectManagedFiles(root, label, result, options.includeHidden);
-  result.files.sort();
-  return result;
-}
-async function collectManagedFiles(directory, label, result, includeHidden = false) {
-  let entries;
-  try {
-    entries = await readdir(directory, { withFileTypes: true });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    result.issues.push(new ManagedPathError(directory, `unable to inspect the ${label} tree at ${directory}: ${message}`));
-    return;
-  }
-  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-    if (!includeHidden && entry.name.startsWith("."))
-      continue;
-    const path = join(directory, entry.name);
-    if (entry.isDirectory()) {
-      await collectManagedFiles(path, label, result, includeHidden);
-      continue;
-    }
-    if (entry.isFile()) {
-      result.files.push(path);
-      continue;
-    }
-    result.issues.push(new ManagedPathError(path, `unsupported entry in the ${label} tree: ${path}`));
-  }
-}
-
-// src/core/decisions.ts
-var DEFAULT_DECISION_RECORDS_PATH = ".rsp/specs/decisions";
-function normalizeDecisionRecordsPath(pathValue) {
-  return posix.normalize(pathValue.trim().replace(/\\/g, "/")).replace(/^\.\//, "").replace(/\/$/, "");
-}
-function validateDecisionRecordsPath(pathValue) {
-  if (typeof pathValue !== "string" || pathValue.trim() === "")
-    return 'config.yaml field "decisions.path" must be a non-empty string';
-  const raw = pathValue.trim();
-  const portable = raw.replace(/\\/g, "/");
-  if (isAbsolute(raw) || posix.isAbsolute(portable) || /^[a-z]:[\\/]/i.test(raw))
-    return 'config.yaml field "decisions.path" must be project-relative';
-  const normalized = normalizeDecisionRecordsPath(raw);
-  if (normalized === "." || normalized === ".." || normalized.startsWith("../"))
-    return 'config.yaml field "decisions.path" must stay inside the Host Project';
-  if ((normalized === ".rsp" || normalized.startsWith(".rsp/")) && normalized !== DEFAULT_DECISION_RECORDS_PATH)
-    return `config.yaml field "decisions.path" must use ${DEFAULT_DECISION_RECORDS_PATH} or a path outside .rsp/`;
-  return null;
-}
-function getDecisionRecordsConfigIssue(config) {
-  if (!("decisions" in config))
-    return null;
-  const decisions = config.decisions;
-  if (!decisions || typeof decisions !== "object" || Array.isArray(decisions))
-    return 'config.yaml field "decisions" must be a mapping with one path';
-  const keys = Object.keys(decisions);
-  if (keys.length !== 1 || keys[0] !== "path")
-    return 'config.yaml field "decisions" supports only "path"';
-  return validateDecisionRecordsPath(decisions.path);
-}
-function resolveDecisionRecordsPath(config) {
-  const configured = config.decisions?.path;
-  return configured && validateDecisionRecordsPath(configured) === null ? normalizeDecisionRecordsPath(configured) : DEFAULT_DECISION_RECORDS_PATH;
-}
-async function validateDecisionRecordsFilesystemPath(pathValue, cwd = process.cwd()) {
-  const projectRoot = await realpath(cwd);
-  const targetPath = resolve(projectRoot, pathValue);
-  let existingAncestor = targetPath;
-  while (!existsSync(existingAncestor)) {
-    const parent = dirname(existingAncestor);
-    if (parent === existingAncestor)
-      return `Decision Record path "${pathValue}" has no accessible Host Project ancestor`;
-    existingAncestor = parent;
-  }
-  const resolvedAncestor = await realpath(existingAncestor);
-  const rel = relative(projectRoot, resolvedAncestor);
-  if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel))
-    return `Decision Record path "${pathValue}" resolves outside the Host Project through ${existingAncestor}`;
-  if (existsSync(targetPath) && !(await stat(targetPath)).isDirectory())
-    return `Decision Record path "${pathValue}" must be a directory`;
-  return null;
-}
-
-// src/core/config.ts
-var __dirname = dirname2(fileURLToPath(import.meta.url));
-var PKG_ROOT = join3(__dirname, "..");
-var RSP_DIR = ".rsp";
-var RSP_RULES_PATH = join3(RSP_DIR, "rsp-rules.md");
-var OBSOLETE_RSP_RULES_PATH = join3(RSP_DIR, "rules", "rsp-rules.md");
-var CHANGES_DIR = join3(RSP_DIR, "changes");
-var FOCUS_DIR = join3(RSP_DIR, "focus.d");
-var MAX_FOCUS_CAPSULE_BYTES = 4096;
-var ARCHIVES_DIR = join3(RSP_DIR, "archives");
-var LOCK_PATH = join3(RSP_DIR, ".lock");
-var CONFIG_PATH = join3(RSP_DIR, "config.yaml");
-var VALID_KINDS = ["feature", "fix", "refactor", "docs", "ops", "research"];
-var DEFAULT_REQUIRED_SECTIONS = getCanonicalSectionHeadings(CHANGE_DOCUMENT_SCHEMA);
-var DEFAULT_WORKFLOW_POLICY = { delegation: "off", closeout: "ask" };
-var INVALID_CONFIG_WORKFLOW_POLICY = { delegation: "off", closeout: "manual" };
-var CONFIG_DEFAULTS = {
-  kinds: [],
-  decisions: { path: ".rsp/specs/decisions" },
-  language: { default: "en" },
-  workflow: { delegation: "off", closeout: "ask" }
-};
-function generateConfigTemplate(config = {}) {
-  const kinds = config.kinds ?? CONFIG_DEFAULTS.kinds;
-  const decisions = { ...CONFIG_DEFAULTS.decisions, ...config.decisions };
-  const workflow = { ...CONFIG_DEFAULTS.workflow, ...config.workflow };
-  const language = { ...CONFIG_DEFAULTS.language, ...config.language };
-  const kindsYaml = stringify(kinds).trimEnd();
-  const renderedKinds = kinds.length === 0 ? `kinds: ${kindsYaml}` : `kinds:
-${kindsYaml.split("\n").map((line) => `  ${line}`).join("\n")}`;
-  const artifactsLine = language.artifacts ? `  artifacts: ${stringify(language.artifacts).trim()}` : "  # artifacts: zh-CN";
-  const commitLine = language.commit ? `  commit: ${stringify(language.commit).trim()}` : "  # commit: zh-CN";
-  return `# RSP project configuration
-# An empty kinds list retains the built-in defaults.
-# A non-empty kinds list replaces the built-in defaults; it does not extend them.
-# Every entry must be a unique non-empty string.
-#
-# Built-in defaults:
-#   kinds:               ${VALID_KINDS.join(", ")}
-#
-${renderedKinds}
-
-# Decision Records default to .rsp/specs/decisions.
-decisions:
-  path: ${stringify(decisions.path).trim()}
-
-# Automatic delegation is off; explicit worker requests remain allowed.
-# Closeout applies only to established final delivery: ask, auto, or manual.
-# Ordinary completion and checkpoint commits keep work open. No setting grants Git authority.
-workflow:
-  delegation: ${workflow.delegation}
-  closeout: ${workflow.closeout}
-
-# Set one shared project default for durable artifact and commit prose.
-# Response language remains user/session-owned and is never read from this project mapping.
-language:
-  default: ${stringify(language.default).trim()}
-${artifactsLine}
-${commitLine}
-`;
-}
-var DELEGATION_POLICIES = ["off", "auto"];
-var CLOSEOUT_POLICIES = ["ask", "auto", "manual"];
-var _configCache = null;
-async function loadRspConfig() {
-  const inspection = await inspectRspConfig();
-  if (inspection.issues.length > 0)
-    throw new Error(inspection.issues.join("; "));
-  return inspection.config;
-}
-async function inspectRspConfig(cwd = process.cwd()) {
-  cwd = resolve2(cwd);
-  if (_configCache?.cwd === cwd)
-    return _configCache.inspection;
-  const configPath = join3(cwd, CONFIG_PATH);
-  const configFile = inspectManagedFile(configPath, "config file", { allowMissing: true });
-  if (configFile.issue)
-    throw configFile.issue;
-  if (!configFile.exists) {
-    const inspection2 = { config: {}, issues: [] };
-    _configCache = { cwd, inspection: inspection2 };
-    return inspection2;
-  }
-  const raw = await readFile(configPath, "utf-8");
-  const parsed = parseYamlText(raw);
-  const issues = validateRspConfig(parsed);
-  const decisions = parsed.decisions && typeof parsed.decisions === "object" && !Array.isArray(parsed.decisions) ? parsed.decisions : void 0;
-  const decisionPath = decisions?.path;
-  const workflowValue = parsed.workflow && typeof parsed.workflow === "object" && !Array.isArray(parsed.workflow) ? parsed.workflow : void 0;
-  const languageValue = parsed.language && typeof parsed.language === "object" && !Array.isArray(parsed.language) ? parsed.language : void 0;
-  const delegation = DELEGATION_POLICIES.includes(workflowValue?.delegation) ? workflowValue?.delegation : void 0;
-  const closeout = CLOSEOUT_POLICIES.includes(workflowValue?.closeout) ? workflowValue?.closeout : void 0;
-  const kinds = Array.isArray(parsed.kinds) && parsed.kinds.every((value) => typeof value === "string" && value.trim() !== "") ? parsed.kinds.map((value) => value.trim()) : void 0;
-  const decisionRecordsIssue = getDecisionRecordsConfigIssue(parsed);
-  const inspection = {
-    config: {
-      kinds,
-      decisions: decisionRecordsIssue === null && validateDecisionRecordsPath(decisionPath) === null ? { path: normalizeDecisionRecordsPath(String(decisionPath)) } : void 0,
-      workflow: workflowValue ? { delegation, closeout } : void 0,
-      language: parseLanguageConfig(languageValue)
-    },
-    issues
-  };
-  _configCache = { cwd, inspection };
-  return inspection;
-}
-function validateRspConfig(parsed) {
-  const issues = [];
-  const supported = /* @__PURE__ */ new Set(["kinds", "decisions", "workflow", "language"]);
-  for (const key of Object.keys(parsed)) {
-    if (key === "manage") {
-      issues.push('config.yaml field "manage" requires explicit migration: remove manage and choose workflow.delegation (off | auto) and workflow.closeout (ask | auto | manual); recommended defaults are off/ask. Old local closeout no longer grants Git authority. rsp update will not convert it automatically');
-    } else if (key === "required_sections") {
-      issues.push('config.yaml field "required_sections" is no longer supported');
-    } else if (!supported.has(key)) {
-      issues.push(`config.yaml field "${key}" is not supported`);
-    }
-  }
-  if ("kinds" in parsed) {
-    if (!Array.isArray(parsed.kinds)) {
-      issues.push('config.yaml field "kinds" must be a YAML list');
-    } else if (!parsed.kinds.every((value) => typeof value === "string" && value.trim() !== "")) {
-      issues.push('config.yaml field "kinds" must contain only non-empty strings');
-    } else {
-      const kinds = parsed.kinds.map((value) => value.trim());
-      const duplicates = [...new Set(kinds.filter((value, index) => kinds.indexOf(value) !== index))];
-      if (duplicates.length > 0)
-        issues.push(`config.yaml field "kinds" contains duplicate entries: ${duplicates.join(", ")}`);
-    }
-  }
-  const decisionRecordsIssue = getDecisionRecordsConfigIssue(parsed);
-  if (decisionRecordsIssue)
-    issues.push(decisionRecordsIssue);
-  if ("workflow" in parsed) {
-    if (!parsed.workflow || typeof parsed.workflow !== "object" || Array.isArray(parsed.workflow)) {
-      issues.push('config.yaml field "workflow" must be a YAML mapping');
-    } else {
-      const workflow = parsed.workflow;
-      const supportedWorkflowFields = /* @__PURE__ */ new Set(["delegation", "closeout"]);
-      for (const key of Object.keys(workflow)) {
-        if (!supportedWorkflowFields.has(key))
-          issues.push(`config.yaml field "workflow.${key}" is not supported`);
-      }
-      if ("delegation" in workflow && !DELEGATION_POLICIES.includes(workflow.delegation))
-        issues.push('config.yaml field "workflow.delegation" must be one of: off, auto');
-      if ("closeout" in workflow && !CLOSEOUT_POLICIES.includes(workflow.closeout))
-        issues.push('config.yaml field "workflow.closeout" must be one of: ask, auto, manual');
-    }
-  }
-  if ("language" in parsed) {
-    if (!parsed.language || typeof parsed.language !== "object" || Array.isArray(parsed.language)) {
-      issues.push('config.yaml field "language" must be a YAML mapping');
-    } else {
-      const language = parsed.language;
-      const supportedLanguageFields = /* @__PURE__ */ new Set(["default", "artifacts", "commit"]);
-      for (const key of Object.keys(language)) {
-        if (!supportedLanguageFields.has(key))
-          issues.push(`config.yaml field "language.${key}" is not supported`);
-      }
-      if (!("default" in language))
-        issues.push('config.yaml field "language.default" is required when language is configured');
-      for (const key of supportedLanguageFields) {
-        if (key in language && canonicalizeLanguageTag(language[key]) === null)
-          issues.push(`config.yaml field "language.${key}" must be a non-empty valid BCP 47 language tag`);
-      }
-    }
-  }
-  return issues;
-}
-function clearConfigCache() {
-  _configCache = null;
-}
-function resolveKinds(config) {
-  return config.kinds && config.kinds.length > 0 ? config.kinds : [...VALID_KINDS];
-}
-function resolveRequiredSections(_config) {
-  return [...DEFAULT_REQUIRED_SECTIONS];
-}
-function resolveWorkflowPolicy(config, options = {}) {
-  if (options.configValid === false)
-    return { ...INVALID_CONFIG_WORKFLOW_POLICY };
-  return {
-    delegation: config.workflow?.delegation ?? DEFAULT_WORKFLOW_POLICY.delegation,
-    closeout: config.workflow?.closeout ?? DEFAULT_WORKFLOW_POLICY.closeout
-  };
-}
-function resolveLanguagePolicy(config, options = {}) {
-  if (options.configValid === false || !config.language)
-    return { artifacts: null, commit: null };
-  return {
-    artifacts: config.language.artifacts ?? config.language.default,
-    commit: config.language.commit ?? config.language.default
-  };
-}
-function parseLanguageConfig(value) {
-  if (!value)
-    return void 0;
-  const defaultLanguage = canonicalizeLanguageTag(value.default);
-  if (defaultLanguage === null)
-    return void 0;
-  const artifacts = canonicalizeLanguageTag(value.artifacts);
-  const commit = canonicalizeLanguageTag(value.commit);
-  return {
-    default: defaultLanguage,
-    artifacts: artifacts ?? void 0,
-    commit: commit ?? void 0
-  };
-}
-function canonicalizeLanguageTag(value) {
-  if (typeof value !== "string" || value.trim() === "")
-    return null;
-  try {
-    return Intl.getCanonicalLocales(value.trim())[0] ?? null;
-  } catch {
-    return null;
-  }
-}
-async function getVersion() {
-  const { version } = JSON.parse(await readFile(join3(PKG_ROOT, "package.json"), "utf-8"));
-  return version;
-}
+import {
+  SpecsQueryError,
+  normalizeLogicalPath,
+  readSpecsDetail,
+  searchSpecs,
+  specsInspectionComplete,
+  toErrorMessage
+} from "./chunk-LGDCIQYL.mjs";
+import {
+  ARCHIVES_DIR,
+  CHANGES_DIR,
+  CHANGE_DOCUMENT_SCHEMA,
+  CONFIG_PATH,
+  FOCUS_DIR,
+  GROUP_BRIEF_DOCUMENT_SCHEMA,
+  ManagedPathError,
+  collectVerifyCheckboxes,
+  countCheckboxes,
+  getCanonicalSectionHeadings,
+  getDocumentSectionMarkdown,
+  getDocumentTitle,
+  getDocumentTitles,
+  getOpenCheckboxes,
+  getVisibleBodyLines,
+  hasMeaningfulBlockerBody,
+  hasMeaningfulBlockers,
+  inspectManagedDirectory,
+  inspectRspConfig,
+  markdownListItems,
+  markdownText,
+  openCheckboxLines,
+  parseFrontmatter,
+  parseMarkdown,
+  parseRspDocument,
+  parseScenarios,
+  readBlockerEntries,
+  renderDocumentSectionHeading,
+  renderDocumentTitle,
+  requireManagedDirectory,
+  requireManagedFile,
+  resolveLanguagePolicy,
+  resolveWorkflowPolicy,
+  summarizeVerifyCheckboxes,
+  visibleMarkdownSource
+} from "./chunk-P3KO3GZW.mjs";
 
 // src/status/inspect.ts
-import { readFile as readFile5, stat as stat2 } from "fs/promises";
+import { readFile as readFile3, stat } from "fs/promises";
 
 // src/core/change-group.ts
-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
-async function walkMarkdownFiles(dir, options = {}) {
-  const all = await walkFiles(dir, options);
-  return all.filter((f) => f.endsWith(".md"));
-}
-async function inspectUnsupportedRules() {
-  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(relative2(rulesDir, entry.path)), kind: entry.kind }));
-  return {
-    entries,
-    diagnostics,
-    directoryRemaining: entries.length > 0
-  };
-}
-async function walkAllEntries(dir, diagnostics) {
-  const entries = [];
-  try {
-    const items = await readdir3(dir, { withFileTypes: true });
-    for (const item of items) {
-      const path = join4(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 readdir3(dir, { withFileTypes: true });
-    for (const item of items) {
-      if (item.name.startsWith("."))
-        continue;
-      const filePath = join4(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(sep2).join("/").replace(/\\/g, "/");
-}
-var SPEC_NAME_RE = /^[a-z0-9-]+(?:\/[a-z0-9-]+)*$/;
-function isValidSpecName(name) {
-  return SPEC_NAME_RE.test(name);
-}
-function inspectRspInitialization() {
-  const designPath = join4(RSP_DIR, "specs", "design.md");
-  const design = inspectManagedFile(designPath, "design Spec", { allowMissing: true });
-  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 = dirname3(path);
-  while (parent !== stopDir) {
-    try {
-      const remaining = await readdir3(parent);
-      if (remaining.length === 0)
-        await rmdir(parent);
-      else
-        break;
-    } catch {
-      break;
-    }
-    parent = dirname3(parent);
-  }
-}
-async function detectProjectName() {
-  try {
-    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;
-    }
-  } 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 as lstatSync2, readdirSync } from "fs";
-import { readdir as readdir4 } from "fs/promises";
-import { isAbsolute as isAbsolute2, join as join5, relative as relative3 } from "path";
+import { lstatSync, readdirSync } from "fs";
+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;
@@ -1146,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 = join5(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);
@@ -1161,7 +129,7 @@ function resolveWorkRef(name, options = {}) {
   return ref;
 }
 function assertGroupBrief(changesDir, ref) {
-  const briefPath = join5(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(
@@ -1181,7 +149,7 @@ function assertGroupBrief(changesDir, ref) {
 function assertRegularWorkFile(ref, mustExist) {
   let stats;
   try {
-    stats = lstatSync2(ref.path);
+    stats = lstatSync(ref.path);
   } catch (error) {
     if (error.code === "ENOENT") {
       if (mustExist) {
@@ -1205,8 +173,8 @@ function assertRegularWorkFile(ref, mustExist) {
 }
 function resolveWorkRefPath(path, options = {}) {
   const changesDir = options.changesDir ?? CHANGES_DIR;
-  const logicalPath = normalizeLogicalPath2(relative3(changesDir, path));
-  if (isAbsolute2(logicalPath) || logicalPath === ".." || logicalPath.startsWith("../") || !logicalPath.endsWith(".md")) {
+  const logicalPath = normalizeLogicalPath2(relative(changesDir, path));
+  if (isAbsolute(logicalPath) || logicalPath === ".." || logicalPath.startsWith("../") || !logicalPath.endsWith(".md")) {
     throw new WorkRefError(
       "invalid_work_ref_path",
       `work path must be a Markdown file inside ${changesDir}: ${path}`,
@@ -1233,13 +201,13 @@ function resolveFocusMarkerPath(ref, options = {}) {
   assertNoManagedNormalizationCollision(focusDir, ref.name.split("/"), ref.name, "invalid_focus_path");
   if (ref.group) {
     assertOptionalManagedDirectory(
-      join5(focusDir, ref.group),
+      join(focusDir, ref.group),
       ref.name,
       "invalid_focus_path",
       "focus path"
     );
   }
-  const markerPath = join5(focusDir, ...ref.name.split("/"));
+  const markerPath = join(focusDir, ...ref.name.split("/"));
   try {
     requireManagedFile(markerPath, "focus marker", { allowMissing: true });
   } catch (error) {
@@ -1255,7 +223,7 @@ function resolveArchiveDirectory(ref, options = {}) {
   if (!ref.group)
     return archivesDir;
   assertNoManagedNormalizationCollision(archivesDir, [ref.group], ref.name, "invalid_archive_path");
-  const groupPath = join5(archivesDir, ref.group);
+  const groupPath = join(archivesDir, ref.group);
   assertOptionalManagedDirectory(groupPath, ref.name, "invalid_archive_path", "archive path");
   return groupPath;
 }
@@ -1274,7 +242,7 @@ async function inspectFocusTree(options = {}) {
   if (!rootEntries)
     return result;
   for (const entry of rootEntries) {
-    const path = join5(focusDir, entry.name);
+    const path = join(focusDir, entry.name);
     if (entry.name === ".gitkeep" && entry.isFile())
       continue;
     if (entry.isDirectory()) {
@@ -1317,7 +285,7 @@ async function inspectArchiveTree(options = {}) {
   if (!rootEntries)
     return result;
   for (const entry of rootEntries) {
-    const path = join5(archivesDir, entry.name);
+    const path = join(archivesDir, entry.name);
     if (entry.name === "INDEX.md" && entry.isFile())
       continue;
     if (entry.isDirectory()) {
@@ -1355,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 = join5(changesDir, entry.name);
+    const path = join(changesDir, entry.name);
     if (entry.name === ".gitkeep" && entry.isFile())
       continue;
     if (entry.isDirectory()) {
@@ -1402,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
-    ), join5(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: ${join5(groupPath, GROUP_BRIEF_FILENAME)}`,
+      `Group Brief must be a regular file: ${join(groupPath, GROUP_BRIEF_FILENAME)}`,
       group
-    ), join5(groupPath, GROUP_BRIEF_FILENAME));
+    ), join(groupPath, GROUP_BRIEF_FILENAME));
   }
   for (const entry of entries) {
     const input = `${group}/${entry.name}`;
-    const path = join5(groupPath, entry.name);
+    const path = join(groupPath, entry.name);
     if (entry.name === GROUP_BRIEF_FILENAME && !entry.isFile())
       continue;
     if (entry.name === "brief.md") {
@@ -1441,7 +409,7 @@ async function inspectFocusGroup(group, groupPath, changesDir, result) {
     return;
   for (const entry of entries) {
     const input = `${group}/${entry.name}`;
-    const path = join5(groupPath, entry.name);
+    const path = join(groupPath, entry.name);
     if (entry.isDirectory()) {
       addDiagnostic(result, new WorkRefError(
         "unsupported_work_depth",
@@ -1467,7 +435,7 @@ async function inspectArchiveGroup(group, groupPath, result) {
     return;
   for (const entry of entries) {
     const input = `${group}/${entry.name}`;
-    const path = join5(groupPath, entry.name);
+    const path = join(groupPath, entry.name);
     if (!entry.isFile() || !entry.name.endsWith(".md")) {
       addArchivePathDiagnostic(result, input, path);
       continue;
@@ -1500,7 +468,7 @@ function collectResolvedPath(path, changesDir, result) {
 }
 async function readDirectory(path, input, result) {
   try {
-    return (await readdir4(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;
@@ -1561,7 +529,7 @@ function normalizeWorkRefName(name, allowGroupBrief) {
 }
 function assertNoNormalizationCollision(changesDir, segments, input, isGroupBrief) {
   for (let depth = 0; depth < segments.length; depth++) {
-    const parent = join5(changesDir, ...segments.slice(0, depth));
+    const parent = join(changesDir, ...segments.slice(0, depth));
     const parentKind = getPathKind(parent, input);
     if (parentKind === "missing")
       return;
@@ -1594,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 = join5(root, ...segments.slice(0, depth));
+    const parent = join(root, ...segments.slice(0, depth));
     const parentKind = getPathKind(parent, input);
     if (parentKind === "missing")
       return;
@@ -1619,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 = join5(changesDir, ...segments.slice(0, depth));
-    const filePath = finalFilename && depth === segments.length ? join5(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;
@@ -1686,7 +654,7 @@ function assertOptionalManagedDirectory(path, input, code, label) {
 }
 function getPathKind(path, input) {
   try {
-    const stats = lstatSync2(path);
+    const stats = lstatSync(path);
     if (stats.isFile())
       return "file";
     if (stats.isDirectory())
@@ -1714,8 +682,8 @@ function normalizeLogicalPath2(path) {
 var PLACEHOLDER_SUMMARY = "<\u2026>";
 function extractChangeSummary(content, document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA), options = {}) {
   try {
-    const frontmatter2 = parseFrontmatter(document.markdown);
-    const frontmatterSummary = meaningfulSummary(frontmatter2?.summary, options);
+    const frontmatter = parseFrontmatter(document.markdown);
+    const frontmatterSummary = meaningfulSummary(frontmatter?.summary, options);
     if (frontmatterSummary)
       return frontmatterSummary;
   } catch {
@@ -1806,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(relative4(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 readFile3(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("/")) {
@@ -1853,7 +821,7 @@ async function inspectChangeGroups(options = {}) {
   for (const brief of workTree.briefs) {
     let content;
     try {
-      content = await readFile3(brief.path, "utf-8");
+      content = await readFile(brief.path, "utf-8");
     } catch (error) {
       diagnostics.push({
         severity: "error",
@@ -1883,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(relative4(ARCHIVES_DIR, item.path));
+      const archivePath = normalizeLogicalPath(relative2(ARCHIVES_DIR, item.path));
       return archivePath === brief.group || archivePath.startsWith(`${brief.group}/`);
     })) {
       diagnostics.push({
@@ -1976,10 +944,10 @@ function hasExplicitGroupReopenEvidence(content, retainedEvidence, retainedGroup
   return getGroupReopenEvidence(content).some((item) => item.active && retainedGroupBriefPaths.has(item.sourcePath) && !retainedEvidence.has(item.key));
 }
 async function requireDeclaredGroupSlice(ref) {
-  const briefPath = join6(dirname4(ref.path), GROUP_BRIEF_FILENAME);
+  const briefPath = join2(dirname(ref.path), GROUP_BRIEF_FILENAME);
   let content;
   try {
-    content = await readFile3(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);
@@ -2009,11 +977,11 @@ async function hasArchivedGroupBrief(group) {
   }
   const groupPrefix = `${group}/`;
   for (const path of archiveTree.files) {
-    if (!normalizeLogicalPath(relative4(ARCHIVES_DIR, path)).startsWith(groupPrefix))
+    if (!normalizeLogicalPath(relative2(ARCHIVES_DIR, path)).startsWith(groupPrefix))
       continue;
     let content;
     try {
-      content = await readFile3(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);
@@ -2025,13 +993,13 @@ async function hasArchivedGroupBrief(group) {
 }
 function parseGroupBrief(group, document) {
   const diagnostics = [];
-  let frontmatter2;
+  let frontmatter;
   try {
-    frontmatter2 = parseFrontmatter(document.markdown);
+    frontmatter = parseFrontmatter(document.markdown);
   } catch (error) {
     diagnostics.push({ severity: "error", code: "group_frontmatter_invalid", change: group, message: error instanceof Error ? error.message : String(error) });
   }
-  if (frontmatter2?.kind !== "group")
+  if (frontmatter?.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}` });
@@ -2085,13 +1053,13 @@ function groupSectionHeading(sectionId) {
 }
 
 // src/core/dependency-plan.ts
-import { readFile as readFile4 } 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 as realpath2 } from "fs/promises";
-import { isAbsolute as isAbsolute3, relative as relative5, resolve as resolve3, sep as sep3 } from "path";
+import { lstat, open, realpath } from "fs/promises";
+import { isAbsolute as isAbsolute2, relative as relative3, resolve, sep } from "path";
 
 // src/history/model.ts
 var HISTORY_DEFAULT_LIMIT = 20;
@@ -2120,10 +1088,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 = resolve3(options.sourcePath);
-  const archivesDir = resolve3(options.archivesDir);
-  const relativePath = relative5(archivesDir, sourcePath);
-  if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep3}`) || isAbsolute3(relativePath)) {
+  const sourcePath = resolve(options.sourcePath);
+  const archivesDir = resolve(options.archivesDir);
+  const relativePath = relative3(archivesDir, sourcePath);
+  if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute2(relativePath)) {
     throw changed(options.projectPath);
   }
   let inspectedRoot;
@@ -2134,9 +1102,9 @@ async function readCurrentArchiveFile(options) {
     if (!inspectedRoot.isDirectory())
       throw changed(options.projectPath);
     inspected = await lstat(sourcePath, { bigint: true });
-    realArchivesDir = await realpath2(archivesDir);
-    const resolvedSource = await realpath2(sourcePath);
-    const expectedSource = resolve3(realArchivesDir, relativePath);
+    realArchivesDir = await realpath(archivesDir);
+    const resolvedSource = await realpath(sourcePath);
+    const expectedSource = resolve(realArchivesDir, relativePath);
     if (!inspected.isFile() || resolvedSource !== expectedSource || !isContained(realArchivesDir, resolvedSource)) {
       throw changed(options.projectPath);
     }
@@ -2157,9 +1125,9 @@ async function readCurrentArchiveFile(options) {
   }
   try {
     const opened = await handle.stat({ bigint: true });
-    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)) {
+    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)) {
       throw changed(options.projectPath);
     }
     if (opened.size > BigInt(options.maxFileBytes))
@@ -2222,9 +1190,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 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)) {
+  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)) {
     throw changed(options.projectPath);
   }
 }
@@ -2238,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 = relative5(root, path);
-  return candidate !== "" && candidate !== ".." && !candidate.startsWith(`..${sep3}`) && !isAbsolute3(candidate);
+  const candidate = relative3(root, path);
+  return candidate !== "" && candidate !== ".." && !candidate.startsWith(`..${sep}`) && !isAbsolute2(candidate);
 }
 function changed(projectPath) {
   return new ArchiveHistoryError(
@@ -2265,7 +1233,7 @@ function isPermissionError(error) {
 }
 
 // src/history/inspect.ts
-import { basename as basename2, dirname as dirname5, relative as relative6, resolve as resolve4 } 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"]);
@@ -2278,13 +1246,13 @@ var IssueRelationshipError = class extends Error {
   }
   code;
 };
-function parseIssueRelationships(frontmatter2) {
-  if (!frontmatter2 || !("issues" in frontmatter2))
+function parseIssueRelationships(frontmatter) {
+  if (!frontmatter || !("issues" in frontmatter))
     return [];
-  if (!Array.isArray(frontmatter2.issues))
+  if (!Array.isArray(frontmatter.issues))
     throw new IssueRelationshipError("invalid_issue_shape", 'frontmatter field "issues" must be a list');
   const seen = /* @__PURE__ */ new Set();
-  return frontmatter2.issues.map((value, index) => {
+  return frontmatter.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);
@@ -2333,7 +1301,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 = resolve4(options.archivesDir ?? ARCHIVES_DIR);
+  const archivesDir = resolve2(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) => ({
@@ -2397,42 +1365,42 @@ 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(relative6(archivesDir, dirname5(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 changeDocument2 = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
-  const groupDocument = parseRspDocument(changeDocument2.markdown, GROUP_BRIEF_DOCUMENT_SCHEMA);
-  const changeHeadings = getDocumentTitles(changeDocument2, "identity");
+  const changeDocument = parseRspDocument(content, CHANGE_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) {
     return { diagnostic: errorDiagnostic("archive_heading_invalid", path, "archive must contain exactly one Change or Change Group identity heading") };
   }
-  let frontmatter2;
+  let frontmatter;
   try {
-    frontmatter2 = parseFrontmatter(changeDocument2.markdown);
+    frontmatter = parseFrontmatter(changeDocument.markdown);
   } catch (error) {
     return { diagnostic: errorDiagnostic("archive_frontmatter_invalid", path, `archive frontmatter could not be parsed: ${toErrorMessage(error)}`) };
   }
-  if (typeof frontmatter2?.kind !== "string" || frontmatter2.kind.trim() === "")
+  if (typeof frontmatter?.kind !== "string" || frontmatter.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 || frontmatter2.kind !== "group" || !matchesArchiveStem(archiveStem, "brief")) {
+    if (!archiveGroup || group !== archiveGroup || frontmatter.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 frontmatter2) {
+  if ("issues" in frontmatter) {
     try {
-      issues = parseIssueRelationships(frontmatter2);
+      issues = parseIssueRelationships(frontmatter);
     } catch {
       issues = void 0;
     }
@@ -2447,7 +1415,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, changeDocument2, { preservePlaceholder: true });
+  const rawSummary = extractChangeSummary(content, changeDocument, { 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);
@@ -2456,7 +1424,7 @@ function parseArchiveEntry(current, path, maxFileBytes) {
       date,
       workRef,
       group: expectedGroup,
-      kind: frontmatter2.kind.trim(),
+      kind: frontmatter.kind.trim(),
       summary: summary.value,
       summaryTruncated: summary.truncated,
       path,
@@ -2481,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(relative6(resolve4(archivesDir), resolve4(sourcePath)))}`;
+  return `.rsp/archives/${normalizeLogicalPath(relative4(resolve2(archivesDir), resolve2(sourcePath)))}`;
 }
 function normalizeOutputPath(path, archivesDir) {
-  const relativePath = normalizeLogicalPath(relative6(resolve4(archivesDir), resolve4(path)));
+  const relativePath = normalizeLogicalPath(relative4(resolve2(archivesDir), resolve2(path)));
   return relativePath === "" ? ".rsp/archives" : `.rsp/archives/${relativePath}`;
 }
 function errorDiagnostic(code, path, message) {
@@ -2653,7 +1621,7 @@ async function inspectChangeDependencies(options = {}) {
     diagnostics.push(...archiveHistory.diagnostics);
   for (const brief of workTree.briefs) {
     try {
-      if (hasMeaningfulBlockers(await readFile4(brief.path, "utf-8")))
+      if (hasMeaningfulBlockers(await readFile2(brief.path, "utf-8")))
         blockedGroups.add(brief.group);
     } catch (error) {
       diagnostics.push({
@@ -2667,7 +1635,7 @@ async function inspectChangeDependencies(options = {}) {
   }
   for (const ref of workTree.changes) {
     try {
-      const parsed = parseDependencyBlockers(await readFile4(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);
@@ -3056,15 +2024,15 @@ async function inspectProjectStatus(options = {}) {
     let issues = [];
     if (path) {
       try {
-        const content = await readFile5(path, "utf-8");
+        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 frontmatter2 = parseFrontmatter(document.markdown);
-          kind = frontmatter2?.kind ? String(frontmatter2.kind) : "\u2014";
-          issues = parseIssueRelationships(frontmatter2);
+          const frontmatter = parseFrontmatter(document.markdown);
+          kind = frontmatter?.kind ? String(frontmatter.kind) : "\u2014";
+          issues = parseIssueRelationships(frontmatter);
         } catch (error) {
           kind = "(invalid)";
           const issueError = error instanceof IssueRelationshipError;
@@ -3108,7 +2076,7 @@ async function inspectProjectStatus(options = {}) {
         });
       }
       try {
-        const metadata = await stat2(path);
+        const metadata = await stat(path);
         ageDays = Math.floor((nowMs - metadata.mtime.getTime()) / (1e3 * 60 * 60 * 24));
       } catch (error) {
         diagnostics.push({
@@ -3200,569 +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 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);
-var SpecsQueryError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "SpecsQueryError";
-  }
-  code;
-};
-async function inspectSpecs(options = {}) {
-  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");
-  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 = resolve5(projectRoot, decisionRecordsPath);
-  const accumulator = {
-    documents: [],
-    generatedIndexes: [],
-    diagnostics: [],
-    candidateCount: 0,
-    candidateLimitReported: false
-  };
-  const excludedSpecDirectories = [DEFAULT_DECISION_RECORDS_PATH, decisionRecordsPath].map((path) => resolve5(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 = resolve5(inspection.source.root, normalized);
-  const current = await readCurrentDocument(
-    sourcePath,
-    inspection.source.root,
-    document.path,
-    inspection.limits.fileBytes
-  );
-  const currentDocument = parseDocumentRecord(parseMarkdown(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(
-      resolve5(inspection.source.root, document.path),
-      inspection.source.root,
-      document.path,
-      inspection.limits.fileBytes
-    );
-    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++) {
-      heading = headingsByLine.get(index + 1) ?? heading;
-      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(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 document = parseMarkdown(current.content);
-    const metadata = parseFrontmatter(document);
-    if (metadata?.kind === "generated-index")
-      return;
-    accumulator.documents.push({
-      sourcePath: path,
-      ...parseDocumentRecord(document, current.bytes, projectPath, kind, metadata)
-    });
-  } 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 = relative7(root, document.sourcePath);
-    if (rel === ".." || rel.startsWith(`..${sep4}`) || isAbsolute4(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(document) {
-  return document.root.children.flatMap((node) => node.type === "heading" ? [{ depth: node.depth, title: markdownText(node), line: node.position.start.line }] : []);
-}
-function extractSummary(document, frontmatterSummary) {
-  if (typeof frontmatterSummary === "string" && frontmatterSummary.trim() !== "")
-    return frontmatterSummary.trim();
-  for (const node of document.root.children) {
-    if (node.type !== "paragraph" && node.type !== "list")
-      continue;
-    const text = markdownText(node).split("\n", 1)[0].trim();
-    if (text)
-      return text;
-  }
-  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 (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 === join7(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 = 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");
-  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 realpath3(sourceRoot);
-    const resolvedPath = await realpath3(sourcePath);
-    if (!inspectedRoot.isDirectory() || !inspected.isFile() || resolvedPath !== resolve5(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 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))
-      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 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) {
-    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 = relative7(root, path);
-  return candidate !== "" && candidate !== ".." && !candidate.startsWith(`..${sep4}`) && !isAbsolute4(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(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(document, 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 = relative7(directory, path);
-  return rel === "" || !isAbsolute4(rel) && rel !== ".." && !rel.startsWith(`..${sep4}`);
-}
-function toProjectPath(projectRoot, path) {
-  return normalizeLogicalPath(relative7(projectRoot, path)) || ".";
-}
-
 // src/specs/projection.ts
 function projectSpecsTree(inspection) {
   assertCompleteInspection(inspection);
@@ -3853,73 +2258,9 @@ 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,
   GROUP_BRIEF_FILENAME,
   WorkRefError,
   normalizeWorkRefSegment,
@@ -3948,14 +2289,6 @@ export {
   readArchiveHistoryDocument,
   historyInspectionComplete,
   inspectChangeDependencies,
-  SPECS_DEFAULT_RESULT_LIMIT,
-  SPECS_MAX_RESULT_LIMIT,
-  SPECS_SEARCH_EXCERPT_CODE_POINTS,
-  SPECS_DETAIL_CONTENT_CODE_POINTS,
-  SpecsQueryError,
-  inspectSpecs,
-  specsInspectionComplete,
-  isRecognizedGeneratedSpecsIndex,
   collectArchiveReadiness,
   toArchiveReadinessOutput,
   buildDurableReviewGuidance,