@oevery/rsp 3.2.0 → 4.0.0

package/dist/chunk-HFSTLCCK.mjs

@@ -0,0 +1,3968 @@
+#!/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;
+}
+
+// src/status/inspect.ts
+import { readFile as readFile5, stat as stat2 } 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());
+}
+
+// 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";
+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;
+var GROUP_BRIEF_FILENAME = "00-brief.md";
+var WorkRefError = class extends Error {
+  constructor(code, message, input) {
+    super(message);
+    this.code = code;
+    this.input = input;
+    this.name = "WorkRefError";
+  }
+  code;
+  input;
+};
+function normalizeWorkRefSegment(segment) {
+  const normalized = segment.normalize("NFC");
+  if (!WORK_SEGMENT_RE.test(normalized) || [...normalized].length > WORK_SEGMENT_MAX_CODE_POINTS || Buffer.byteLength(normalized, "utf8") > WORK_SEGMENT_MAX_UTF8_BYTES) {
+    throw new WorkRefError(
+      "invalid_work_ref",
+      `work identity segment "${segment}" must contain at most ${WORK_SEGMENT_MAX_CODE_POINTS} lowercase or caseless Unicode letters, marks, or decimal numbers separated only by internal hyphens and fit within ${WORK_SEGMENT_MAX_UTF8_BYTES} UTF-8 bytes`,
+      segment
+    );
+  }
+  return normalized;
+}
+function normalizeExecutableWorkRef(name) {
+  return normalizeWorkRefName(name, false);
+}
+function isCanonicalExecutableWorkRef(name) {
+  try {
+    return normalizeExecutableWorkRef(name) === name;
+  } catch {
+    return false;
+  }
+}
+function isCanonicalWorkRefSegment(segment) {
+  try {
+    return normalizeWorkRefSegment(segment) === segment;
+  } catch {
+    return false;
+  }
+}
+function resolveWorkRef(name, options = {}) {
+  const changesDir = options.changesDir ?? CHANGES_DIR;
+  const normalizedName = normalizeWorkRefName(name, true);
+  if (options.canonical && normalizedName !== name) {
+    throw new WorkRefError(
+      "invalid_work_ref",
+      `stored work identity "${name}" must use Unicode NFC normalization`,
+      name
+    );
+  }
+  const segments = normalizedName.split("/");
+  const isGroupBrief = segments.length === 2 && segments[1] === "brief";
+  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 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);
+  if (options.executable && ref.kind === "group-brief") {
+    throw new WorkRefError(
+      "non_executable_work_ref",
+      `work identity "${name}" is a Group Brief and cannot be used as an executable Change`,
+      name
+    );
+  }
+  assertRegularWorkFile(ref, Boolean(options.mustExist));
+  return ref;
+}
+function assertGroupBrief(changesDir, ref) {
+  const briefPath = join5(changesDir, ref.group, GROUP_BRIEF_FILENAME);
+  const kind = getPathKind(briefPath, ref.name);
+  if (kind === "missing") {
+    throw new WorkRefError(
+      "group_brief_missing",
+      `Change Group "${ref.group}" requires a Group Brief; run: rsp group create ${ref.group}`,
+      ref.name
+    );
+  }
+  if (kind !== "file") {
+    throw new WorkRefError(
+      "work_ref_not_file",
+      `Group Brief must be a regular file: ${briefPath}`,
+      ref.name
+    );
+  }
+}
+function assertRegularWorkFile(ref, mustExist) {
+  let stats;
+  try {
+    stats = lstatSync2(ref.path);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      if (mustExist) {
+        throw new WorkRefError(
+          "work_ref_not_found",
+          `open work file not found: ${ref.path}`,
+          ref.name
+        );
+      }
+      return;
+    }
+    throw asReadFailure(ref.path, ref.name, error);
+  }
+  if (!stats.isFile()) {
+    throw new WorkRefError(
+      "work_ref_not_file",
+      `open work path is not a regular file: ${ref.path}`,
+      ref.name
+    );
+  }
+}
+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")) {
+    throw new WorkRefError(
+      "invalid_work_ref_path",
+      `work path must be a Markdown file inside ${changesDir}: ${path}`,
+      path
+    );
+  }
+  const segments = logicalPath.split("/");
+  if (segments.length === 2 && segments[1] === "brief.md") {
+    throw new WorkRefError(
+      "invalid_work_ref_path",
+      `unsupported legacy Group Brief path: ${path}`,
+      path
+    );
+  }
+  const name = segments.length === 2 && segments[1] === GROUP_BRIEF_FILENAME ? `${segments[0]}/brief` : logicalPath.slice(0, -3);
+  return resolveWorkRef(name, { ...options, canonical: true });
+}
+function isExecutableWorkRef(ref) {
+  return ref.kind !== "group-brief";
+}
+function resolveFocusMarkerPath(ref, options = {}) {
+  const focusDir = options.focusDir ?? FOCUS_DIR;
+  assertManagedRoot(focusDir, ref.name, "invalid_focus_root", "focus root", true);
+  assertNoManagedNormalizationCollision(focusDir, ref.name.split("/"), ref.name, "invalid_focus_path");
+  if (ref.group) {
+    assertOptionalManagedDirectory(
+      join5(focusDir, ref.group),
+      ref.name,
+      "invalid_focus_path",
+      "focus path"
+    );
+  }
+  const markerPath = join5(focusDir, ...ref.name.split("/"));
+  try {
+    requireManagedFile(markerPath, "focus marker", { allowMissing: true });
+  } catch (error) {
+    if (error instanceof ManagedPathError)
+      throw new WorkRefError("invalid_focus_path", error.message, ref.name);
+    throw error;
+  }
+  return markerPath;
+}
+function resolveArchiveDirectory(ref, options = {}) {
+  const archivesDir = options.archivesDir ?? ARCHIVES_DIR;
+  assertManagedRoot(archivesDir, ref.name, "invalid_archive_root", "archive root", true);
+  if (!ref.group)
+    return archivesDir;
+  assertNoManagedNormalizationCollision(archivesDir, [ref.group], ref.name, "invalid_archive_path");
+  const groupPath = join5(archivesDir, ref.group);
+  assertOptionalManagedDirectory(groupPath, ref.name, "invalid_archive_path", "archive path");
+  return groupPath;
+}
+async function inspectFocusTree(options = {}) {
+  const focusDir = options.focusDir ?? FOCUS_DIR;
+  const changesDir = options.changesDir ?? CHANGES_DIR;
+  const result = { markers: [], diagnostics: [] };
+  const rootInspection = inspectManagedDirectory(focusDir, "focus root", { allowMissing: true });
+  if (rootInspection.issue) {
+    addDiagnostic(result, new WorkRefError("invalid_focus_root", rootInspection.issue.message, focusDir), focusDir);
+    return result;
+  }
+  if (!rootInspection.exists)
+    return result;
+  const rootEntries = await readDirectory(focusDir, focusDir, result);
+  if (!rootEntries)
+    return result;
+  for (const entry of rootEntries) {
+    const path = join5(focusDir, entry.name);
+    if (entry.name === ".gitkeep" && entry.isFile())
+      continue;
+    if (entry.isDirectory()) {
+      if (!isCanonicalWorkRefSegment(entry.name)) {
+        addDiagnostic(result, new WorkRefError(
+          "invalid_work_ref",
+          `stored work identity "${entry.name}" must be a safe Unicode NFC segment`,
+          entry.name
+        ), path);
+        continue;
+      }
+      await inspectFocusGroup(entry.name, path, changesDir, result);
+      continue;
+    }
+    if (!entry.isFile()) {
+      addDiagnostic(result, new WorkRefError(
+        "invalid_focus_path",
+        `focus path must be a regular marker file or real directory: ${path}`,
+        entry.name
+      ), path);
+      continue;
+    }
+    collectFocusMarker(entry.name, path, changesDir, result);
+  }
+  result.markers.sort((a, b) => a.name.localeCompare(b.name));
+  return result;
+}
+async function inspectArchiveTree(options = {}) {
+  const archivesDir = options.archivesDir ?? ARCHIVES_DIR;
+  const result = { rootExists: false, files: [], diagnostics: [] };
+  const rootInspection = inspectManagedDirectory(archivesDir, "archive root", { allowMissing: true });
+  if (rootInspection.issue) {
+    addDiagnostic(result, new WorkRefError("invalid_archive_root", rootInspection.issue.message, archivesDir), archivesDir);
+    return result;
+  }
+  if (!rootInspection.exists)
+    return result;
+  result.rootExists = true;
+  const rootEntries = await readDirectory(archivesDir, archivesDir, result);
+  if (!rootEntries)
+    return result;
+  for (const entry of rootEntries) {
+    const path = join5(archivesDir, entry.name);
+    if (entry.name === "INDEX.md" && entry.isFile())
+      continue;
+    if (entry.isDirectory()) {
+      if (!isCanonicalWorkRefSegment(entry.name)) {
+        addArchivePathDiagnostic(result, entry.name, path);
+        continue;
+      }
+      await inspectArchiveGroup(entry.name, path, result);
+      continue;
+    }
+    if (!entry.isFile() || !entry.name.endsWith(".md")) {
+      addArchivePathDiagnostic(result, entry.name, path);
+      continue;
+    }
+    result.files.push(path);
+  }
+  result.files.sort();
+  return result;
+}
+async function inspectWorkTree(options = {}) {
+  const changesDir = options.changesDir ?? CHANGES_DIR;
+  const result = { changes: [], briefs: [], diagnostics: [] };
+  try {
+    assertValidWorkRoot(changesDir, changesDir);
+  } catch (error) {
+    if (!(error instanceof WorkRefError))
+      throw error;
+    addDiagnostic(result, error, changesDir);
+    return result;
+  }
+  const rootEntries = await readDirectory(changesDir, changesDir, result);
+  if (!rootEntries)
+    return result;
+  const rootDirectories = new Set(rootEntries.filter((entry) => entry.isDirectory()).map((entry) => entry.name));
+  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);
+    if (entry.name === ".gitkeep" && entry.isFile())
+      continue;
+    if (entry.isDirectory()) {
+      if (!isCanonicalWorkRefSegment(entry.name)) {
+        addDiagnostic(result, new WorkRefError(
+          "invalid_work_ref",
+          `stored work identity "${entry.name}" must be a safe Unicode NFC segment`,
+          entry.name
+        ), path);
+        continue;
+      }
+      const colliding = collidingGroups.has(entry.name);
+      if (colliding) {
+        addDiagnostic(result, new WorkRefError(
+          "work_ref_collision",
+          `work identity "${entry.name}" is claimed by both a file and a directory`,
+          entry.name
+        ), path);
+      }
+      await inspectGroupDirectory(entry.name, path, changesDir, result, colliding);
+      continue;
+    }
+    if (!entry.isFile() || !entry.name.endsWith(".md")) {
+      addInvalidEntryDiagnostic(result, entry.name, path);
+      continue;
+    }
+    const name = entry.name.slice(0, -3);
+    if (collidingGroups.has(name)) {
+      continue;
+    }
+    collectResolvedPath(path, changesDir, result);
+  }
+  result.changes.sort((a, b) => a.name.localeCompare(b.name));
+  result.briefs.sort((a, b) => a.name.localeCompare(b.name));
+  return result;
+}
+async function inspectGroupDirectory(group, groupPath, changesDir, result, colliding) {
+  const entries = await readDirectory(groupPath, group, result);
+  if (!entries)
+    return;
+  const briefEntry = entries.find((entry) => entry.name === GROUP_BRIEF_FILENAME);
+  if (!briefEntry) {
+    addDiagnostic(result, new WorkRefError(
+      "group_brief_missing",
+      `Change Group "${group}" requires a Group Brief; run: rsp group create ${group}`,
+      group
+    ), join5(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
+    ), join5(groupPath, GROUP_BRIEF_FILENAME));
+  }
+  for (const entry of entries) {
+    const input = `${group}/${entry.name}`;
+    const path = join5(groupPath, entry.name);
+    if (entry.name === GROUP_BRIEF_FILENAME && !entry.isFile())
+      continue;
+    if (entry.name === "brief.md") {
+      addInvalidEntryDiagnostic(result, input, path);
+      continue;
+    }
+    if (entry.isDirectory()) {
+      addDiagnostic(result, new WorkRefError(
+        "unsupported_work_depth",
+        `work identity "${input}" exceeds the supported one-level Change Group depth`,
+        input
+      ), path);
+      continue;
+    }
+    if (!entry.isFile() || !entry.name.endsWith(".md")) {
+      addInvalidEntryDiagnostic(result, input, path);
+      continue;
+    }
+    if (!colliding)
+      collectResolvedPath(path, changesDir, result);
+  }
+}
+async function inspectFocusGroup(group, groupPath, changesDir, result) {
+  const entries = await readDirectory(groupPath, group, result);
+  if (!entries)
+    return;
+  for (const entry of entries) {
+    const input = `${group}/${entry.name}`;
+    const path = join5(groupPath, entry.name);
+    if (entry.isDirectory()) {
+      addDiagnostic(result, new WorkRefError(
+        "unsupported_work_depth",
+        `work identity "${input}" exceeds the supported one-level Change Group depth`,
+        input
+      ), path);
+      continue;
+    }
+    if (!entry.isFile()) {
+      addDiagnostic(result, new WorkRefError(
+        "invalid_focus_path",
+        `focus path must be a regular marker file: ${path}`,
+        input
+      ), path);
+      continue;
+    }
+    collectFocusMarker(input, path, changesDir, result);
+  }
+}
+async function inspectArchiveGroup(group, groupPath, result) {
+  const entries = await readDirectory(groupPath, group, result);
+  if (!entries)
+    return;
+  for (const entry of entries) {
+    const input = `${group}/${entry.name}`;
+    const path = join5(groupPath, entry.name);
+    if (!entry.isFile() || !entry.name.endsWith(".md")) {
+      addArchivePathDiagnostic(result, input, path);
+      continue;
+    }
+    result.files.push(path);
+  }
+}
+function collectFocusMarker(input, path, changesDir, result) {
+  try {
+    const ref = resolveWorkRef(input, { changesDir, canonical: true, executable: true });
+    result.markers.push({ name: ref.name, path });
+  } catch (error) {
+    if (!(error instanceof WorkRefError))
+      throw error;
+    addDiagnostic(result, error, path);
+  }
+}
+function collectResolvedPath(path, changesDir, result) {
+  try {
+    const ref = resolveWorkRefPath(path, { changesDir });
+    if (isExecutableWorkRef(ref))
+      result.changes.push(ref);
+    else
+      result.briefs.push(ref);
+  } catch (error) {
+    if (!(error instanceof WorkRefError))
+      throw error;
+    addDiagnostic(result, error, path);
+  }
+}
+async function readDirectory(path, input, result) {
+  try {
+    return (await readdir4(path, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
+  } catch (error) {
+    addDiagnostic(result, asReadFailure(path, input, error), path);
+    return null;
+  }
+}
+function addInvalidEntryDiagnostic(result, input, path) {
+  addDiagnostic(result, new WorkRefError(
+    "invalid_work_ref_path",
+    `unsupported entry in the open-work tree: ${path}`,
+    input
+  ), path);
+}
+function addArchivePathDiagnostic(result, input, path) {
+  addDiagnostic(result, new WorkRefError(
+    "invalid_archive_path",
+    `unsupported entry in the archive tree: ${path}`,
+    input
+  ), path);
+}
+function addDiagnostic(result, error, path) {
+  if (result.diagnostics.some((item) => item.code === error.code && item.input === error.input))
+    return;
+  result.diagnostics.push({ code: error.code, input: error.input, path, message: error.message });
+}
+function normalizeWorkRefName(name, allowGroupBrief) {
+  const segments = name.split("/");
+  if (segments.length > 2) {
+    throw new WorkRefError(
+      "unsupported_work_depth",
+      `work identity "${name}" exceeds the supported one-level Change Group depth`,
+      name
+    );
+  }
+  if (!name || segments.some((segment) => !segment)) {
+    throw new WorkRefError(
+      "invalid_work_ref",
+      `work identity "${name}" must contain one or two safe Unicode segments`,
+      name
+    );
+  }
+  const normalizedSegments = segments.map(normalizeWorkRefSegment);
+  const child = normalizedSegments[1];
+  if (segments.length === 2 && child === GROUP_BRIEF_FILENAME.slice(0, -3)) {
+    throw new WorkRefError(
+      "invalid_work_ref",
+      `work identity "${name}" uses the reserved Group Brief filename`,
+      name
+    );
+  }
+  if (segments.length === 2 && child === "brief" && !allowGroupBrief) {
+    throw new WorkRefError(
+      "non_executable_work_ref",
+      `work identity "${name}" is a Group Brief and cannot be used as an executable Change`,
+      name
+    );
+  }
+  return normalizedSegments.join("/");
+}
+function assertNoNormalizationCollision(changesDir, segments, input, isGroupBrief) {
+  for (let depth = 0; depth < segments.length; depth++) {
+    const parent = join5(changesDir, ...segments.slice(0, depth));
+    const parentKind = getPathKind(parent, input);
+    if (parentKind === "missing")
+      return;
+    if (parentKind !== "directory")
+      continue;
+    let entries;
+    try {
+      entries = readdirSync(parent, { withFileTypes: true });
+    } catch (error) {
+      throw asReadFailure(parent, input, error);
+    }
+    const expected = segments[depth];
+    for (const entry of entries) {
+      let candidate = null;
+      if (entry.isDirectory())
+        candidate = entry.name;
+      else if (entry.isFile() && entry.name.endsWith(".md"))
+        candidate = entry.name.slice(0, -3);
+      if (depth === segments.length - 1 && isGroupBrief && entry.name === GROUP_BRIEF_FILENAME)
+        candidate = "brief";
+      if (candidate && candidate !== expected && candidate.normalize("NFC") === expected) {
+        throw new WorkRefError(
+          "work_ref_collision",
+          `work identity "${input}" collides with non-canonical stored identity "${candidate}" after Unicode NFC normalization`,
+          input
+        );
+      }
+    }
+  }
+}
+function assertNoManagedNormalizationCollision(root, segments, input, code) {
+  for (let depth = 0; depth < segments.length; depth++) {
+    const parent = join5(root, ...segments.slice(0, depth));
+    const parentKind = getPathKind(parent, input);
+    if (parentKind === "missing")
+      return;
+    if (parentKind !== "directory")
+      continue;
+    let entries;
+    try {
+      entries = readdirSync(parent, { withFileTypes: true });
+    } catch (error) {
+      throw asReadFailure(parent, input, error);
+    }
+    const expected = segments[depth];
+    const alias = entries.find((entry) => entry.name !== expected && entry.name.normalize("NFC") === expected);
+    if (alias) {
+      throw new WorkRefError(
+        code,
+        `managed identity "${input}" collides with non-canonical stored entry "${alias.name}" after Unicode NFC normalization`,
+        input
+      );
+    }
+  }
+}
+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 fileKind = getPathKind(filePath, input);
+    const identityKind = getPathKind(identityPath, input);
+    const isPrefix = depth < segments.length;
+    const isFlatIdentity = segments.length === 1;
+    const identity = segments.slice(0, depth).join("/");
+    if (fileKind !== "missing" && fileKind !== "file") {
+      throw new WorkRefError(
+        "work_ref_not_file",
+        `open work path is not a regular file: ${filePath}`,
+        input
+      );
+    }
+    if (fileKind === "file" && identityKind === "directory" || isPrefix && fileKind === "file" || isFlatIdentity && identityKind === "directory") {
+      throw new WorkRefError(
+        "work_ref_collision",
+        `work identity "${identity}" is or would be claimed by both a file and a directory`,
+        input
+      );
+    }
+    if (isPrefix && identityKind !== "missing" && identityKind !== "directory") {
+      throw new WorkRefError(
+        "invalid_work_ref_path",
+        `open work path must be a real directory: ${identityPath}`,
+        input
+      );
+    }
+    if (!isPrefix && !isFlatIdentity && identityKind === "directory") {
+      throw new WorkRefError(
+        "unsupported_work_depth",
+        `work identity "${identity}" exceeds the supported one-level Change Group depth`,
+        input
+      );
+    }
+    if (!isPrefix && identityKind !== "missing" && identityKind !== "directory") {
+      throw new WorkRefError(
+        "invalid_work_ref_path",
+        `unsupported entry in the open-work tree: ${identityPath}`,
+        input
+      );
+    }
+  }
+}
+function assertValidWorkRoot(changesDir, input) {
+  assertManagedRoot(changesDir, input, "invalid_work_root", "open work root");
+}
+function assertManagedRoot(path, input, code, label, allowMissing = false) {
+  try {
+    requireManagedDirectory(path, label, { allowMissing });
+  } catch (error) {
+    if (error instanceof ManagedPathError)
+      throw new WorkRefError(code, error.message, input);
+    throw error;
+  }
+}
+function assertOptionalManagedDirectory(path, input, code, label) {
+  try {
+    requireManagedDirectory(path, label, { allowMissing: true });
+  } catch (error) {
+    if (error instanceof ManagedPathError)
+      throw new WorkRefError(code, error.message, input);
+    throw error;
+  }
+}
+function getPathKind(path, input) {
+  try {
+    const stats = lstatSync2(path);
+    if (stats.isFile())
+      return "file";
+    if (stats.isDirectory())
+      return "directory";
+    return "other";
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return "missing";
+    throw asReadFailure(path, input, error);
+  }
+}
+function asReadFailure(path, input, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return new WorkRefError(
+    "work_tree_read_failed",
+    `unable to inspect open work path ${path}: ${message}`,
+    input
+  );
+}
+function normalizeLogicalPath2(path) {
+  return path.split("\\").join("/");
+}
+
+// src/core/work-summary.ts
+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);
+    if (frontmatterSummary)
+      return frontmatterSummary;
+  } catch {
+  }
+  const proposalLines = visibleSummaryItemLines(getDocumentSectionMarkdown(document, "proposal"));
+  for (const field of ["Outcome", "Summary"]) {
+    const prefix = `- ${field}:`;
+    for (const line of proposalLines) {
+      const summary = line.startsWith(prefix) ? meaningfulSummary(line.slice(prefix.length), options) : null;
+      if (summary)
+        return summary;
+    }
+  }
+  return null;
+}
+function extractGroupSummary(content, document = parseRspDocument(content, GROUP_BRIEF_DOCUMENT_SCHEMA)) {
+  for (const line of visibleSummaryItemLines(getDocumentSectionMarkdown(document, "goal"))) {
+    const trimmed = line.trim();
+    const summary = trimmed.startsWith("- ") || trimmed.startsWith("* ") ? meaningfulSummary(trimmed.slice(2)) : null;
+    if (summary)
+      return summary;
+  }
+  return null;
+}
+function visibleSummaryItemLines(document) {
+  const source = visibleMarkdownSource(document);
+  return markdownListItems(document).map(({ node }) => source.slice(node.position.start.offset - document.start, node.position.end.offset - document.start).split(/\r?\n/, 1)[0].trim());
+}
+function meaningfulSummary(value, options = {}) {
+  if (typeof value !== "string")
+    return null;
+  const summary = value.trim();
+  return summary && (options.preservePlaceholder || summary !== PLACEHOLDER_SUMMARY) ? summary : null;
+}
+
+// src/core/change-group.ts
+var GROUP_BRIEF_SECTIONS = getCanonicalSectionHeadings(GROUP_BRIEF_DOCUMENT_SCHEMA);
+var GROUP_REOPEN_COMPLETION_PREFIX = "Resolve reopened concern from";
+async function resolveExecutableChange(name, options = {}) {
+  const ref = resolveWorkRef(name, { ...options, executable: true });
+  if (ref.kind === "group-change")
+    await requireDeclaredGroupSlice(ref);
+  return ref;
+}
+function generateGroupBriefContent(name, goal = "") {
+  const placeholder = "<\u2026>";
+  return `---
+kind: group
+---
+
+${renderDocumentTitle(GROUP_BRIEF_DOCUMENT_SCHEMA, name)}
+
+${groupSectionHeading("goal")}
+- ${goal || placeholder}
+
+${groupSectionHeading("scope")}
+- ${placeholder}
+
+${groupSectionHeading("sharedConstraints")}
+- ${placeholder}
+
+${groupSectionHeading("slices")}
+<!-- Declare at least two independently executable direct child WorkRefs before creating them; keep their Tasks and evidence in each Change. -->
+- \`${name}/<change>\`: ${placeholder}
+
+${groupSectionHeading("completionConditions")}
+<!-- State shared completion conditions. For Group-level verification, name an Integration: condition and retain its acceptance and evidence here; child passes alone do not prove it. -->
+- [ ] ${placeholder}
+
+${groupSectionHeading("durableOutcomes")}
+<!-- Identify current-fact and lasting-rationale owners only when an update is needed; do not duplicate child results, current Specs or execution history. -->
+- Current facts: ${placeholder}
+- Lasting rationale: ${placeholder}
+
+${groupSectionHeading("blockers")}
+- none
+`;
+}
+async function inspectChangeGroups(options = {}) {
+  const workTree = options.workTree ?? await inspectWorkTree();
+  const archiveTree = options.archiveTree ?? await inspectArchiveTree();
+  const focusTree = options.focusTree ?? await inspectFocusTree();
+  const diagnostics = [];
+  const groups = [];
+  const archivedSlicesByGroup = /* @__PURE__ */ new Map();
+  const archivedGroups = /* @__PURE__ */ new Set();
+  const archivedGroupReopenEvidence = /* @__PURE__ */ new Map();
+  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 archiveGroup = archivePath.includes("/") ? archivePath.split("/")[0] : null;
+    if (!archiveGroup || !openGroupNames.has(archiveGroup))
+      continue;
+    try {
+      const content = await readFile3(path, "utf-8");
+      const archivedChange = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
+      const identity = getDocumentTitle(archivedChange, "identity");
+      if (identity?.includes("/")) {
+        if (!isCanonicalExecutableWorkRef(identity) || !identity.startsWith(`${archiveGroup}/`)) {
+          diagnostics.push({
+            severity: "error",
+            code: "group_archive_identity_mismatch",
+            change: archiveGroup,
+            path,
+            message: `archived Change identity ${identity} does not belong to archive group ${archiveGroup}`
+          });
+        } else {
+          const groupSlices = archivedSlicesByGroup.get(archiveGroup) ?? /* @__PURE__ */ new Set();
+          groupSlices.add(identity);
+          archivedSlicesByGroup.set(archiveGroup, groupSlices);
+        }
+      }
+      const archivedBrief = parseRspDocument(archivedChange.markdown, GROUP_BRIEF_DOCUMENT_SCHEMA);
+      if (getDocumentTitle(archivedBrief, "identity") === archiveGroup) {
+        archivedGroups.add(archiveGroup);
+        const evidence = archivedGroupReopenEvidence.get(archiveGroup) ?? /* @__PURE__ */ new Set();
+        for (const item of getGroupReopenEvidence(archivedBrief))
+          evidence.add(item.key);
+        archivedGroupReopenEvidence.set(archiveGroup, evidence);
+        const retainedPaths = archivedGroupBriefPaths.get(archiveGroup) ?? /* @__PURE__ */ new Set();
+        retainedPaths.add(`.rsp/archives/${archivePath}`);
+        archivedGroupBriefPaths.set(archiveGroup, retainedPaths);
+      }
+    } catch (error) {
+      diagnostics.push({
+        severity: "error",
+        code: "group_archive_read_failed",
+        change: archiveGroup,
+        path,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  for (const brief of workTree.briefs) {
+    let content;
+    try {
+      content = await readFile3(brief.path, "utf-8");
+    } catch (error) {
+      diagnostics.push({
+        severity: "error",
+        code: "group_brief_read_failed",
+        change: brief.group,
+        path: brief.path,
+        message: error instanceof Error ? error.message : String(error)
+      });
+      continue;
+    }
+    const document = parseRspDocument(content, GROUP_BRIEF_DOCUMENT_SCHEMA);
+    const parsed = parseGroupBrief(brief.group, document);
+    diagnostics.push(...parsed.diagnostics.map((diagnostic) => ({ ...diagnostic, path: brief.path })));
+    if (archivedGroups.has(brief.group) && !hasExplicitGroupReopenEvidence(
+      document,
+      archivedGroupReopenEvidence.get(brief.group) ?? /* @__PURE__ */ new Set(),
+      archivedGroupBriefPaths.get(brief.group) ?? /* @__PURE__ */ new Set()
+    )) {
+      diagnostics.push({
+        severity: "error",
+        code: "group_identity_reopened",
+        change: brief.group,
+        path: brief.path,
+        message: `archived Change Group cannot be reopened: ${brief.group}`
+      });
+    }
+    for (const diagnostic of archiveTree.diagnostics.filter((item) => {
+      if (item.code === "invalid_archive_root")
+        return true;
+      const archivePath = normalizeLogicalPath(relative4(ARCHIVES_DIR, item.path));
+      return archivePath === brief.group || archivePath.startsWith(`${brief.group}/`);
+    })) {
+      diagnostics.push({
+        severity: "error",
+        code: diagnostic.code,
+        change: brief.group,
+        path: diagnostic.path,
+        message: diagnostic.message
+      });
+    }
+    for (const diagnostic of focusTree.diagnostics.filter((item) => item.input.startsWith(`${brief.group}/`))) {
+      diagnostics.push({
+        severity: "error",
+        code: "group_focus_invalid",
+        change: brief.group,
+        path: diagnostic.path,
+        message: `invalid focus for ${diagnostic.input}: ${diagnostic.message}`
+      });
+    }
+    const openChildren = new Set(workTree.changes.filter((ref) => ref.group === brief.group).map((ref) => ref.name));
+    const archivedSlices = archivedSlicesByGroup.get(brief.group) ?? /* @__PURE__ */ new Set();
+    const slices = parsed.slices.map((slice) => {
+      const state = openChildren.has(slice.name) ? "open" : archivedSlices.has(slice.name) ? "archived" : "missing";
+      return { ...slice, state };
+    });
+    const focusedNames = new Set(focusTree.markers.map((marker) => marker.name));
+    for (const slice of slices.filter((slice2) => slice2.state !== "open" && focusedNames.has(slice2.name))) {
+      diagnostics.push({
+        severity: "error",
+        code: "group_focus_invalid",
+        change: brief.group,
+        path: focusTree.markers.find((marker) => marker.name === slice.name)?.path,
+        message: `invalid focus for ${slice.name}: focused group slice is not open`
+      });
+    }
+    const declared = new Set(slices.map((slice) => slice.name));
+    for (const child of [...openChildren].filter((name) => !declared.has(name)).sort()) {
+      diagnostics.push({
+        severity: "error",
+        code: "group_child_undeclared",
+        change: brief.group,
+        path: brief.path,
+        message: `open child Change is not declared by the Group Brief: ${child}`
+      });
+    }
+    for (const child of [...archivedSlices].filter((name) => !declared.has(name)).sort()) {
+      diagnostics.push({
+        severity: "error",
+        code: "group_archived_child_undeclared",
+        change: brief.group,
+        path: brief.path,
+        message: `archived child Change is not declared by the Group Brief: ${child}`
+      });
+    }
+    for (const slice of slices.filter((slice2) => slice2.state === "missing")) {
+      diagnostics.push({
+        severity: "error",
+        code: "group_slice_missing",
+        change: brief.group,
+        path: brief.path,
+        message: `declared group slice is neither open nor archived: ${slice.name}`
+      });
+    }
+    const warnings = parsed.diagnostics.filter((diagnostic) => diagnostic.severity === "warning").map((diagnostic) => diagnostic.message);
+    const readyToClose = diagnostics.every((diagnostic) => diagnostic.change !== brief.group || diagnostic.severity !== "error") && slices.length >= 2 && slices.every((slice) => slice.state === "archived") && parsed.completion.total > 0 && parsed.completion.done === parsed.completion.total && !parsed.blockers;
+    groups.push({
+      name: brief.group,
+      summary: extractGroupSummary(content, document),
+      path: normalizeLogicalPath(brief.path),
+      slices,
+      completion: parsed.completion,
+      blockers: parsed.blockers,
+      readyToClose,
+      warnings
+    });
+  }
+  groups.sort((left, right) => left.name.localeCompare(right.name));
+  return { groups, diagnostics };
+}
+function getGroupReopenEvidence(content) {
+  const document = typeof content === "string" ? parseRspDocument(content, GROUP_BRIEF_DOCUMENT_SCHEMA) : content;
+  const completion = getDocumentSectionMarkdown(document, "completionConditions");
+  return markdownListItems(completion).flatMap(({ line }) => {
+    const match = line.trim().match(/^-\s+\[([ /xX-])\]\s+(Resolve reopened concern from `(\.rsp\/archives\/[^`]+)`: (\S.*))$/);
+    const reason = match?.[4];
+    return match && reason && markdownText(parseMarkdown(reason).root).trim() ? [{ active: match[1] !== "-", key: match[2], sourcePath: match[3] }] : [];
+  });
+}
+function hasExplicitGroupReopenEvidence(content, retainedEvidence, retainedGroupBriefPaths) {
+  return getGroupReopenEvidence(content).some((item) => item.active && retainedGroupBriefPaths.has(item.sourcePath) && !retainedEvidence.has(item.key));
+}
+async function requireDeclaredGroupSlice(ref) {
+  const briefPath = join6(dirname4(ref.path), GROUP_BRIEF_FILENAME);
+  let content;
+  try {
+    content = await readFile3(briefPath, "utf-8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new WorkRefError("work_tree_read_failed", `unable to read Group Brief ${briefPath}: ${message}`, ref.name);
+  }
+  const parsed = parseGroupBrief(ref.group, parseRspDocument(content, GROUP_BRIEF_DOCUMENT_SCHEMA));
+  const errors = parsed.diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+  if (errors.length > 0) {
+    throw new WorkRefError(
+      "invalid_group_brief",
+      `Change Group "${ref.group}" brief is invalid: ${errors.map((error) => error.message).join("; ")}`,
+      ref.name
+    );
+  }
+  if (!parsed.slices.some((slice) => slice.name === ref.name)) {
+    throw new WorkRefError(
+      "group_child_undeclared",
+      `grouped Change is not declared by ${ref.group}/brief: ${ref.name}`,
+      ref.name
+    );
+  }
+}
+async function hasArchivedGroupBrief(group) {
+  const archiveTree = await inspectArchiveTree();
+  if (archiveTree.diagnostics.length > 0) {
+    const diagnostic = archiveTree.diagnostics[0];
+    throw new WorkRefError(diagnostic.code, diagnostic.message, diagnostic.input);
+  }
+  const groupPrefix = `${group}/`;
+  for (const path of archiveTree.files) {
+    if (!normalizeLogicalPath(relative4(ARCHIVES_DIR, path)).startsWith(groupPrefix))
+      continue;
+    let content;
+    try {
+      content = await readFile3(path, "utf-8");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new WorkRefError("work_tree_read_failed", `unable to inspect archived Change Group identity at ${path}: ${message}`, group);
+    }
+    if (getDocumentTitle(parseRspDocument(content, GROUP_BRIEF_DOCUMENT_SCHEMA), "identity") === group)
+      return true;
+  }
+  return false;
+}
+function parseGroupBrief(group, document) {
+  const diagnostics = [];
+  let frontmatter2;
+  try {
+    frontmatter2 = parseFrontmatter(document.markdown);
+  } catch (error) {
+    diagnostics.push({ severity: "error", code: "group_frontmatter_invalid", change: group, message: error instanceof Error ? error.message : String(error) });
+  }
+  if (frontmatter2?.kind !== "group")
+    diagnostics.push({ severity: "error", code: "group_kind_invalid", change: group, message: "Group Brief frontmatter must declare kind: group" });
+  if (getDocumentTitle(document, "identity") !== group)
+    diagnostics.push({ severity: "error", code: "group_heading_mismatch", change: group, message: `Group Brief heading must be: # Change Group: ${group}` });
+  for (const definition of GROUP_BRIEF_DOCUMENT_SCHEMA.sections) {
+    if (getVisibleBodyLines(getDocumentSectionMarkdown(document, definition.id)).length === 0)
+      diagnostics.push({ severity: "error", code: "group_section_missing", change: group, message: `Group Brief missing required section: ${definition.heading}` });
+  }
+  const slices = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const { line } of markdownListItems(getDocumentSectionMarkdown(document, "slices"))) {
+    const trimmed = line.trim();
+    const identity = trimmed.match(/^-\s+`(\S+)`/);
+    if (!identity || identity[1].includes("<"))
+      continue;
+    const suffix = trimmed.slice(identity[0].length).trim();
+    if (![":", "\u2014", "-"].includes(suffix[0])) {
+      diagnostics.push({ severity: "error", code: "group_slice_invalid", change: group, message: `group slice requires an identity and boundary: ${trimmed}` });
+      continue;
+    }
+    const name = identity[1];
+    const boundary = suffix.slice(1).trim();
+    if (!boundary) {
+      diagnostics.push({ severity: "error", code: "group_slice_invalid", change: group, message: `group slice requires a boundary: ${name}` });
+      continue;
+    }
+    if (!isCanonicalExecutableWorkRef(name) || !name.startsWith(`${group}/`)) {
+      diagnostics.push({ severity: "error", code: "group_slice_invalid", change: group, message: `invalid direct child identity in Group Brief: ${name}` });
+      continue;
+    }
+    if (seen.has(name)) {
+      diagnostics.push({ severity: "error", code: "group_slice_duplicate", change: group, message: `duplicate group slice: ${name}` });
+      continue;
+    }
+    seen.add(name);
+    slices.push({ name, boundary: boundary.trim() });
+  }
+  if (slices.length < 2)
+    diagnostics.push({ severity: "warning", code: "group_slices_incomplete", change: group, message: "Change Group must declare at least two direct child slices" });
+  const completion = countCheckboxes(getDocumentSectionMarkdown(document, "completionConditions"));
+  if (completion.total === 0)
+    diagnostics.push({ severity: "warning", code: "group_completion_missing", change: group, message: "Change Group must declare at least one completion condition" });
+  return {
+    slices,
+    completion: { done: completion.done + completion.dropped, total: completion.total },
+    blockers: hasMeaningfulBlockerBody(getDocumentSectionMarkdown(document, "blockers")),
+    diagnostics
+  };
+}
+function groupSectionHeading(sectionId) {
+  return renderDocumentSectionHeading(GROUP_BRIEF_DOCUMENT_SCHEMA, sectionId);
+}
+
+// src/core/dependency-plan.ts
+import { readFile as readFile4 } from "fs/promises";
+
+// src/history/current-file.ts
+import { Buffer as Buffer2 } from "buffer";
+import { constants } from "fs";
+import { lstat, open, realpath as realpath2 } from "fs/promises";
+import { isAbsolute as isAbsolute3, relative as relative5, resolve as resolve3, sep as sep3 } from "path";
+
+// src/history/model.ts
+var HISTORY_DEFAULT_LIMIT = 20;
+var HISTORY_MAX_LIMIT = 100;
+var HISTORY_MAX_TEXT_CODE_POINTS = 500;
+var HISTORY_MAX_EVIDENCE_ITEMS = 20;
+var HISTORY_MAX_DIAGNOSTICS = 20;
+var HISTORY_MAX_CANDIDATES = 20;
+var HISTORY_MAX_FILE_BYTES = 512 * 1024;
+var ArchiveHistoryError = class extends Error {
+  constructor(code, message, candidates = []) {
+    super(message);
+    this.code = code;
+    this.name = "ArchiveHistoryError";
+    const ordered = [...candidates].sort();
+    this.candidateTotal = ordered.length;
+    this.candidates = ordered.slice(0, HISTORY_MAX_CANDIDATES);
+    this.candidatesTruncated = this.candidateTotal > this.candidates.length;
+  }
+  code;
+  candidates;
+  candidateTotal;
+  candidatesTruncated;
+};
+
+// 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)) {
+    throw changed(options.projectPath);
+  }
+  let inspectedRoot;
+  let inspected;
+  let realArchivesDir;
+  try {
+    inspectedRoot = await lstat(archivesDir, { bigint: true });
+    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);
+    if (!inspected.isFile() || resolvedSource !== expectedSource || !isContained(realArchivesDir, resolvedSource)) {
+      throw changed(options.projectPath);
+    }
+  } catch (error) {
+    if (error instanceof ArchiveHistoryError)
+      throw error;
+    if (isPermissionError(error))
+      throw readFailed(options.projectPath);
+    throw changed(options.projectPath);
+  }
+  let handle;
+  try {
+    handle = await open(sourcePath, READ_NO_FOLLOW_FLAGS);
+  } catch (error) {
+    if (isPermissionError(error))
+      throw readFailed(options.projectPath);
+    throw changed(options.projectPath);
+  }
+  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)) {
+      throw changed(options.projectPath);
+    }
+    if (opened.size > BigInt(options.maxFileBytes))
+      throw tooLarge(options.projectPath, options.maxFileBytes);
+    if (options.expectedSnapshot !== void 0 && !sameFileSnapshot(options.expectedSnapshot, opened)) {
+      throw changed(options.projectPath);
+    }
+    const content = await readBoundedArchive(handle, opened, options.projectPath, options.maxFileBytes);
+    await validateCurrentArchivePath({
+      sourcePath,
+      archivesDir,
+      relativePath,
+      realArchivesDir,
+      inspectedRoot,
+      finalHandle: content.final,
+      projectPath: options.projectPath
+    });
+    return {
+      sourcePath,
+      archivesDir,
+      content: content.content,
+      bytes: content.bytes,
+      snapshot: {
+        device: content.final.dev,
+        inode: content.final.ino,
+        size: content.final.size,
+        mtimeNs: content.final.mtimeNs,
+        ctimeNs: content.final.ctimeNs
+      }
+    };
+  } catch (error) {
+    if (error instanceof ArchiveHistoryError)
+      throw error;
+    throw changed(options.projectPath);
+  } finally {
+    await handle.close();
+  }
+}
+async function readBoundedArchive(handle, opened, projectPath, maxFileBytes) {
+  const buffer = Buffer2.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 tooLarge(projectPath, maxFileBytes);
+  if (!sameIdentity(opened, final) || !sameSnapshot(opened, final) || final.size !== BigInt(bytes)) {
+    throw changed(projectPath);
+  }
+  return {
+    content: buffer.subarray(0, bytes).toString("utf-8"),
+    bytes,
+    final
+  };
+}
+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)) {
+    throw changed(options.projectPath);
+  }
+}
+function sameIdentity(left, right) {
+  return left.dev === right.dev && left.ino === right.ino;
+}
+function sameSnapshot(left, right) {
+  return left.size === right.size && left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs;
+}
+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);
+}
+function changed(projectPath) {
+  return new ArchiveHistoryError(
+    "archive_file_changed",
+    `archived Change is no longer the inspected readable regular file: ${projectPath}`
+  );
+}
+function tooLarge(projectPath, maxFileBytes) {
+  return new ArchiveHistoryError(
+    "archive_file_too_large",
+    `archived Change exceeds the ${maxFileBytes}-byte inspection limit: ${projectPath}`
+  );
+}
+function readFailed(projectPath) {
+  return new ArchiveHistoryError(
+    "archive_read_failed",
+    `unable to read archived Change ${projectPath}`
+  );
+}
+function isPermissionError(error) {
+  const code = error.code;
+  return code === "EACCES" || code === "EPERM";
+}
+
+// src/history/inspect.ts
+import { basename as basename2, dirname as dirname5, relative as relative6, resolve as resolve4 } from "path";
+
+// src/core/issue-relationship.ts
+var ISSUE_RELATIONS = /* @__PURE__ */ new Set(["relates", "closes"]);
+var ISSUE_FIELDS = /* @__PURE__ */ new Set(["url", "relation"]);
+var IssueRelationshipError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "IssueRelationshipError";
+  }
+  code;
+};
+function parseIssueRelationships(frontmatter2) {
+  if (!frontmatter2 || !("issues" in frontmatter2))
+    return [];
+  if (!Array.isArray(frontmatter2.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) => {
+    if (!isPlainObject(value))
+      throw new IssueRelationshipError("invalid_issue_shape", `issues[${index}] must be a mapping with url and relation`);
+    const fields = Object.keys(value);
+    const unsupported = fields.filter((field) => !ISSUE_FIELDS.has(field));
+    if (unsupported.length > 0)
+      throw new IssueRelationshipError("unsupported_issue_field", `issues[${index}] contains unsupported field(s): ${unsupported.sort().join(", ")}`);
+    if (fields.length !== 2 || !("url" in value) || !("relation" in value))
+      throw new IssueRelationshipError("invalid_issue_shape", `issues[${index}] must contain exactly url and relation`);
+    if (typeof value.url !== "string")
+      throw new IssueRelationshipError("invalid_issue_url", `issues[${index}].url must be an absolute http or https URL`);
+    if (typeof value.relation !== "string" || !ISSUE_RELATIONS.has(value.relation))
+      throw new IssueRelationshipError("unsupported_issue_relation", `issues[${index}].relation must be relates or closes`);
+    const url = normalizeIssueUrl(value.url, `issues[${index}].url`);
+    if (seen.has(url))
+      throw new IssueRelationshipError("duplicate_issue_url", `issues contains duplicate normalized URL: ${url}`);
+    seen.add(url);
+    return { url, relation: value.relation };
+  });
+}
+function createIssueRelationship(url, relation = "relates") {
+  return parseIssueRelationships({ issues: [{ url, relation }] })[0];
+}
+function normalizeIssueUrl(raw, label) {
+  if (raw.trim() !== raw || raw === "")
+    throw new IssueRelationshipError("invalid_issue_url", `${label} must be an absolute http or https URL without surrounding whitespace`);
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    throw new IssueRelationshipError("invalid_issue_url", `${label} must be an absolute http or https URL`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+    throw new IssueRelationshipError("invalid_issue_url", `${label} must use http or https`);
+  if (!parsed.hostname)
+    throw new IssueRelationshipError("invalid_issue_url", `${label} must include a host`);
+  if (parsed.username || parsed.password)
+    throw new IssueRelationshipError("unsafe_issue_url", `${label} must not contain credentials`);
+  if (parsed.hash)
+    throw new IssueRelationshipError("unsafe_issue_url", `${label} must not contain a fragment`);
+  return parsed.toString();
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(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 maxFileBytes = options.maxFileBytes ?? HISTORY_MAX_FILE_BYTES;
+  const tree = options.archiveTree ?? await inspectArchiveTree({ archivesDir });
+  const diagnostics = tree.diagnostics.map((diagnostic) => ({
+    severity: "error",
+    code: diagnostic.code,
+    path: normalizeOutputPath(diagnostic.path, archivesDir),
+    message: diagnostic.message
+  }));
+  const runtime = [];
+  const records = [];
+  const groupBriefs = [];
+  if (!tree.rootExists && tree.diagnostics.length === 0) {
+    diagnostics.push({
+      severity: "error",
+      code: "archive_root_missing",
+      path: ".rsp/archives",
+      message: "archive root does not exist; run rsp init or rsp update before querying history"
+    });
+  }
+  for (const sourcePath of tree.files) {
+    const path = archiveOutputPath(sourcePath, archivesDir);
+    let current;
+    try {
+      current = await readCurrentArchiveFile({
+        sourcePath,
+        archivesDir,
+        projectPath: path,
+        maxFileBytes
+      });
+    } catch (error) {
+      const code = error instanceof ArchiveHistoryError ? error.code : "archive_read_failed";
+      const message = error instanceof ArchiveHistoryError ? error.message : `unable to read archived work: ${toErrorMessage(error)}`;
+      diagnostics.push({ severity: "error", code, path, message });
+      continue;
+    }
+    const parsed = parseArchiveEntry(current, path, maxFileBytes);
+    if (parsed.diagnostic)
+      diagnostics.push(parsed.diagnostic);
+    if (parsed.record)
+      records.push(parsed.record);
+    if (parsed.groupBrief)
+      groupBriefs.push(parsed.groupBrief);
+  }
+  records.sort(compareHistoryRecords);
+  groupBriefs.sort(compareArchivedGroupBriefs);
+  diagnostics.sort(compareDiagnostics);
+  const diagnosticTotal = diagnostics.length;
+  const boundedDiagnostics = diagnostics.slice(0, HISTORY_MAX_DIAGNOSTICS);
+  return {
+    rootExists: tree.rootExists,
+    records,
+    groupBriefs,
+    diagnostics: boundedDiagnostics,
+    diagnosticSummary: {
+      total: diagnosticTotal,
+      returned: boundedDiagnostics.length,
+      hasMore: diagnosticTotal > boundedDiagnostics.length
+    },
+    runtime
+  };
+}
+function parseArchiveEntry(current, path, maxFileBytes) {
+  const { sourcePath, archivesDir, content } = current;
+  const nameMatch = basename2(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 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 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;
+  try {
+    frontmatter2 = parseFrontmatter(changeDocument2.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() === "")
+    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")) {
+      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) {
+    try {
+      issues = parseIssueRelationships(frontmatter2);
+    } catch {
+      issues = void 0;
+    }
+  }
+  const workRef = changeHeadings[0];
+  const segments = workRef.split("/");
+  if (segments.length === 2 && (segments[1] === "brief" || segments[1] === "00-brief")) {
+    return { diagnostic: errorDiagnostic("archive_work_ref_invalid", path, `archived executable Change uses reserved Group Brief identity: ${workRef}`) };
+  }
+  const expectedGroup = segments.length === 2 ? segments[0] : null;
+  const expectedBase = segments.at(-1);
+  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 });
+  if (!rawSummary)
+    return { diagnostic: errorDiagnostic("archive_summary_missing", path, "archived Change must contain frontmatter summary, Proposal Outcome, or Proposal Summary") };
+  const summary = boundText(rawSummary);
+  return {
+    record: {
+      date,
+      workRef,
+      group: expectedGroup,
+      kind: frontmatter2.kind.trim(),
+      summary: summary.value,
+      summaryTruncated: summary.truncated,
+      path,
+      ...issues === void 0 ? {} : { issues },
+      sourcePath,
+      archivesDir,
+      sourceSnapshot: current.snapshot,
+      maxFileBytes,
+      searchSummary: rawSummary
+    }
+  };
+}
+function boundText(value) {
+  const codePoints = [...value];
+  return codePoints.length > HISTORY_MAX_TEXT_CODE_POINTS ? { value: codePoints.slice(0, HISTORY_MAX_TEXT_CODE_POINTS).join(""), truncated: true } : { value, truncated: false };
+}
+function matchesArchiveStem(stem, identityBase) {
+  return stem === identityBase || new RegExp(`^${escapeRegExp(identityBase)}-(?:[2-9]|[1-9]\\d+)$`).test(stem);
+}
+function isCalendarDate(value) {
+  const parsed = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
+  return Number.isFinite(parsed.getTime()) && parsed.toISOString().slice(0, 10) === value;
+}
+function archiveOutputPath(sourcePath, archivesDir) {
+  return `.rsp/archives/${normalizeLogicalPath(relative6(resolve4(archivesDir), resolve4(sourcePath)))}`;
+}
+function normalizeOutputPath(path, archivesDir) {
+  const relativePath = normalizeLogicalPath(relative6(resolve4(archivesDir), resolve4(path)));
+  return relativePath === "" ? ".rsp/archives" : `.rsp/archives/${relativePath}`;
+}
+function errorDiagnostic(code, path, message) {
+  return { severity: "error", code, path, message };
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function compareHistoryRecords(left, right) {
+  return right.date.localeCompare(left.date) || left.workRef.localeCompare(right.workRef) || left.path.localeCompare(right.path);
+}
+function compareArchivedGroupBriefs(left, right) {
+  return right.date.localeCompare(left.date) || left.group.localeCompare(right.group) || left.path.localeCompare(right.path);
+}
+function compareDiagnostics(left, right) {
+  return (left.path ?? "").localeCompare(right.path ?? "") || left.code.localeCompare(right.code) || left.message.localeCompare(right.message);
+}
+
+// src/history/query.ts
+function queryArchiveHistory(records, query = {}) {
+  validateArchiveHistoryQuery(query);
+  const group = query.group === void 0 ? void 0 : normalizeWorkRefSegment(query.group);
+  const limit = query.limit ?? HISTORY_DEFAULT_LIMIT;
+  const matched = records.filter((record) => (!query.since || record.date >= query.since) && (!query.until || record.date <= query.until) && (!query.kind || record.kind === query.kind) && (!group || record.group === group) && (!query.search || `${record.workRef}
+${record.searchSummary ?? record.summary}`.toLowerCase().includes(query.search.toLowerCase()))).sort(compareHistoryRecords2);
+  const selected = matched.slice(0, limit);
+  return {
+    records: selected.map(toOutputRecord),
+    summary: {
+      matched: matched.length,
+      returned: selected.length,
+      hasMore: matched.length > selected.length
+    }
+  };
+}
+function validateArchiveHistoryQuery(query) {
+  const limit = query.limit ?? HISTORY_DEFAULT_LIMIT;
+  if (!Number.isInteger(limit) || limit < 1 || limit > HISTORY_MAX_LIMIT)
+    throw new ArchiveHistoryError("invalid_history_limit", `history limit must be an integer from 1 through ${HISTORY_MAX_LIMIT}`);
+  if (query.since && !isCalendarDate2(query.since))
+    throw new ArchiveHistoryError("invalid_history_since", "history since must be a valid YYYY-MM-DD date");
+  if (query.until && !isCalendarDate2(query.until))
+    throw new ArchiveHistoryError("invalid_history_until", "history until must be a valid YYYY-MM-DD date");
+  if (query.since && query.until && query.since > query.until)
+    throw new ArchiveHistoryError("invalid_history_date_range", "history since must be on or before until");
+  if (query.kind !== void 0 && query.kind.trim() === "")
+    throw new ArchiveHistoryError("invalid_history_kind", "history kind must be non-empty");
+  if (query.group !== void 0) {
+    try {
+      normalizeWorkRefSegment(query.group);
+    } catch {
+      throw new ArchiveHistoryError("invalid_history_group", "history group must be one safe Unicode segment");
+    }
+  }
+  if (query.search !== void 0 && query.search.trim() === "")
+    throw new ArchiveHistoryError("invalid_history_search", "history search must be non-empty");
+}
+function selectArchiveHistoryRecord(records, selector) {
+  const matches = "path" in selector ? records.filter((record) => record.path === selector.path) : records.filter((record) => record.workRef === selector.workRef);
+  const identity = "path" in selector ? selector.path : selector.workRef;
+  if (matches.length === 0)
+    throw new ArchiveHistoryError("archive_not_found", `archived Change not found: ${identity}`);
+  if (matches.length > 1) {
+    const candidates = matches.map((record) => record.path).sort();
+    throw new ArchiveHistoryError("archive_ambiguous", `multiple archives match WorkRef ${identity}`, candidates);
+  }
+  return matches[0];
+}
+function selectArchivedGroupBrief(records, selector) {
+  const matches = "path" in selector ? records.filter((record) => record.path === selector.path) : records.filter((record) => record.group === selector.group);
+  const identity = "path" in selector ? selector.path : selector.group;
+  if (matches.length === 0)
+    throw new ArchiveHistoryError("archive_not_found", `archived Change Group not found: ${identity}`);
+  if (matches.length > 1) {
+    const candidates = matches.map((record) => record.path).sort();
+    throw new ArchiveHistoryError("archive_ambiguous", `multiple archives match Change Group ${identity}`, candidates);
+  }
+  return matches[0];
+}
+async function readArchiveHistoryDetail(record) {
+  return (await readArchiveHistoryDocument(record)).detail;
+}
+async function readArchiveHistoryDocument(record) {
+  let content;
+  try {
+    content = (await readCurrentArchiveFile({
+      sourcePath: record.sourcePath,
+      archivesDir: record.archivesDir,
+      projectPath: record.path,
+      maxFileBytes: record.maxFileBytes,
+      expectedSnapshot: record.sourceSnapshot
+    })).content;
+  } catch (error) {
+    if (error instanceof ArchiveHistoryError)
+      throw error;
+    throw new ArchiveHistoryError("archive_read_failed", `unable to read archived Change ${record.path}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
+  const tasks = getDocumentSectionMarkdown(document, "tasks");
+  const verify = getDocumentSectionMarkdown(document, "verify");
+  const blockers = getDocumentSectionMarkdown(document, "blockers");
+  const detail = {
+    ...toOutputRecord(record),
+    scenarioCount: parseScenarios(document.markdown).length,
+    checkboxes: {
+      tasks: countCheckboxes(tasks),
+      verify: countCheckboxes(verify)
+    },
+    evidence: {
+      tasks: boundEvidence(getVisibleBodyLines(tasks)),
+      verify: boundEvidence(getVisibleBodyLines(verify)),
+      blockers: boundEvidence(readBlockerEntries(blockers).map((entry) => entry.line))
+    }
+  };
+  return { content, detail };
+}
+function historyInspectionComplete(inspection) {
+  return inspection.diagnostics.every((diagnostic) => diagnostic.severity !== "error");
+}
+function toOutputRecord(record) {
+  const {
+    searchSummary: _searchSummary,
+    sourcePath: _sourcePath,
+    archivesDir: _archivesDir,
+    sourceSnapshot: _sourceSnapshot,
+    maxFileBytes: _maxFileBytes,
+    ...output
+  } = record;
+  return output;
+}
+function boundEvidence(rawItems) {
+  const boundedItems = rawItems.slice(0, HISTORY_MAX_EVIDENCE_ITEMS).map((item) => boundText(item));
+  return {
+    items: boundedItems.map((item) => item.value),
+    truncated: rawItems.length > HISTORY_MAX_EVIDENCE_ITEMS || boundedItems.some((item) => item.truncated)
+  };
+}
+function isCalendarDate2(value) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(value))
+    return false;
+  const parsed = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
+  return Number.isFinite(parsed.getTime()) && parsed.toISOString().slice(0, 10) === value;
+}
+function compareHistoryRecords2(left, right) {
+  return right.date.localeCompare(left.date) || left.workRef.localeCompare(right.workRef) || left.path.localeCompare(right.path);
+}
+
+// src/core/dependency-plan.ts
+async function inspectChangeDependencies(options = {}) {
+  const workTree = options.workTree ?? await inspectWorkTree();
+  const archiveTree = options.archiveTree ?? await inspectArchiveTree();
+  const archiveHistory = archiveTree.rootExists ? options.archiveHistory ?? await inspectArchiveHistory({ archiveTree }) : null;
+  const openNames = new Set(workTree.changes.map((ref) => ref.name));
+  const archivedNames = new Set(
+    archiveHistory && historyInspectionComplete(archiveHistory) ? archiveHistory.records.map((record) => record.workRef) : []
+  );
+  const parsedByName = /* @__PURE__ */ new Map();
+  const blockedGroups = /* @__PURE__ */ new Set();
+  const diagnostics = archiveTree.diagnostics.map((diagnostic) => ({
+    severity: "error",
+    code: diagnostic.code,
+    path: diagnostic.path,
+    message: diagnostic.message
+  }));
+  if (archiveHistory)
+    diagnostics.push(...archiveHistory.diagnostics);
+  for (const brief of workTree.briefs) {
+    try {
+      if (hasMeaningfulBlockers(await readFile4(brief.path, "utf-8")))
+        blockedGroups.add(brief.group);
+    } catch (error) {
+      diagnostics.push({
+        severity: "error",
+        code: "group_brief_read_failed",
+        change: brief.group,
+        path: brief.path,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  for (const ref of workTree.changes) {
+    try {
+      const parsed = parseDependencyBlockers(await readFile4(ref.path, "utf-8"));
+      if (ref.group && blockedGroups.has(ref.group))
+        parsed.external = true;
+      parsedByName.set(ref.name, parsed);
+      for (const line of parsed.malformed) {
+        diagnostics.push({
+          severity: "error",
+          code: "dependency_syntax_invalid",
+          change: ref.name,
+          path: ref.path,
+          message: `invalid dependency blocker syntax: ${line}`,
+          hint: "Use: - requires `<change-work-ref>`: <reason>"
+        });
+      }
+    } catch (error) {
+      diagnostics.push({
+        severity: "error",
+        code: "change_read_failed",
+        change: ref.name,
+        path: ref.path,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  const edges = [];
+  for (const [change, blockers] of parsedByName) {
+    for (const requirement of blockers.requires) {
+      const required = requirement.name;
+      const edge = {
+        change,
+        requires: required,
+        reason: requirement.reason,
+        state: openNames.has(required) ? "open" : archivedNames.has(required) ? "archived" : "missing"
+      };
+      edges.push(edge);
+      if (!isCanonicalExecutableWorkRef(required)) {
+        diagnostics.push({
+          severity: "error",
+          code: "dependency_target_invalid",
+          change,
+          message: `dependency target must be an executable Change WorkRef: ${required}`
+        });
+      } else if (required === change) {
+        diagnostics.push({
+          severity: "error",
+          code: "dependency_self_reference",
+          change,
+          message: "Change cannot require itself"
+        });
+      } else if (edge.state === "missing") {
+        diagnostics.push({
+          severity: "error",
+          code: "dependency_target_missing",
+          change,
+          message: `dependency target is neither open nor archived: ${required}`
+        });
+      }
+    }
+  }
+  edges.sort(compareEdges);
+  diagnostics.push(...findCycleDiagnostics(edges));
+  const activeBlockers = /* @__PURE__ */ new Map();
+  const blocked = [...parsedByName].map(([change, blockers]) => {
+    const requires = edges.filter((edge) => edge.change === change && edge.state !== "archived").map((edge) => edge.requires).sort();
+    activeBlockers.set(change, blockers.external || requires.length > 0);
+    return { change, requires, external: blockers.external };
+  }).filter((blocker) => blocker.external || blocker.requires.length > 0).sort((left, right) => left.change.localeCompare(right.change));
+  const waves = buildWaves([...openNames], edges, parsedByName, options.preferredOrder ?? []);
+  const graphValid = diagnostics.every((diagnostic) => diagnostic.severity !== "error");
+  if (!graphValid) {
+    for (const name of openNames)
+      activeBlockers.set(name, true);
+  }
+  const ready = graphValid ? waves[0] ?? [] : [];
+  const executable = new Set(graphValid ? waves.flat() : []);
+  const nodes = [.../* @__PURE__ */ new Set([...openNames, ...edges.map((edge) => edge.requires)])].sort().map((name) => {
+    let state;
+    if (!openNames.has(name) && archivedNames.has(name))
+      state = "archived";
+    else if (!openNames.has(name))
+      state = "missing";
+    else if (ready.includes(name))
+      state = "ready";
+    else if (executable.has(name))
+      state = "waiting";
+    else
+      state = "blocked";
+    return { name, selection: openNames.has(name) ? "selected" : "prerequisite", state };
+  });
+  return {
+    plan: {
+      nodes,
+      ready,
+      edges,
+      blocked,
+      waves: graphValid ? waves : []
+    },
+    activeBlockers,
+    diagnostics
+  };
+}
+function parseDependencyBlockers(content) {
+  const requires = /* @__PURE__ */ new Map();
+  let external = false;
+  const malformed = [];
+  const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
+  const blockers = getDocumentSectionMarkdown(document, "blockers");
+  for (const entry of readBlockerEntries(blockers)) {
+    if (entry.kind === "dependency") {
+      if (!requires.has(entry.name))
+        requires.set(entry.name, entry.reason);
+    } else {
+      external = true;
+      if (entry.kind === "malformed-dependency")
+        malformed.push(entry.line);
+    }
+  }
+  return {
+    requires: [...requires].map(([name, reason]) => ({ name, reason })).sort((left, right) => left.name.localeCompare(right.name)),
+    external,
+    malformed
+  };
+}
+function buildWaves(names, edges, blockersByName, preferredOrder) {
+  const orderIndex = new Map(preferredOrder.map((name, index) => [name, index]));
+  const excluded = new Set(
+    [...blockersByName].filter(([, blockers]) => blockers.external).map(([name]) => name)
+  );
+  let changed2 = true;
+  while (changed2) {
+    changed2 = false;
+    for (const edge of edges) {
+      if ((edge.state === "missing" || excluded.has(edge.requires)) && !excluded.has(edge.change)) {
+        excluded.add(edge.change);
+        changed2 = true;
+      }
+    }
+  }
+  const remaining = new Set(names.filter((name) => !excluded.has(name)));
+  const waves = [];
+  while (remaining.size > 0) {
+    const wave = [...remaining].filter((name) => !edges.some((edge) => edge.change === name && edge.state === "open" && remaining.has(edge.requires))).sort((left, right) => comparePlanNames(left, right, orderIndex));
+    if (wave.length === 0)
+      break;
+    waves.push(wave);
+    for (const name of wave)
+      remaining.delete(name);
+  }
+  return waves;
+}
+function comparePlanNames(left, right, orderIndex) {
+  const leftGroup = left.includes("/") ? left.split("/")[0] : null;
+  const rightGroup = right.includes("/") ? right.split("/")[0] : null;
+  if (leftGroup && leftGroup === rightGroup) {
+    const leftIndex = orderIndex.get(left);
+    const rightIndex = orderIndex.get(right);
+    if (leftIndex !== void 0 && rightIndex !== void 0)
+      return leftIndex - rightIndex;
+  }
+  return left.localeCompare(right);
+}
+function compareEdges(left, right) {
+  return left.change.localeCompare(right.change) || left.requires.localeCompare(right.requires);
+}
+function findCycleDiagnostics(edges) {
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    if (edge.state !== "open" || edge.change === edge.requires)
+      continue;
+    const targets = adjacency.get(edge.change) ?? [];
+    targets.push(edge.requires);
+    adjacency.set(edge.change, targets.sort());
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const active = /* @__PURE__ */ new Set();
+  const stack = [];
+  const reported = /* @__PURE__ */ new Set();
+  const diagnostics = [];
+  const visit = (name) => {
+    if (active.has(name)) {
+      const start = stack.indexOf(name);
+      const cycle = [...stack.slice(start), name];
+      const key = [...new Set(cycle)].sort().join("|");
+      if (!reported.has(key)) {
+        reported.add(key);
+        const message = `dependency cycle detected: ${cycle.join(" -> ")}`;
+        for (const participant of [...new Set(cycle)].sort()) {
+          diagnostics.push({
+            severity: "error",
+            code: "dependency_cycle",
+            change: participant,
+            message
+          });
+        }
+      }
+      return;
+    }
+    if (visited.has(name))
+      return;
+    visited.add(name);
+    active.add(name);
+    stack.push(name);
+    for (const target of adjacency.get(name) ?? [])
+      visit(target);
+    stack.pop();
+    active.delete(name);
+  };
+  for (const name of [...adjacency.keys()].sort())
+    visit(name);
+  return diagnostics;
+}
+
+// src/core/readiness.ts
+function collectArchiveReadiness(content, options = {}) {
+  const warnings = [];
+  const documentDiagnostics = options.documentDiagnostics ?? [];
+  warnings.push(...documentDiagnostics.map((diagnostic) => diagnostic.message));
+  const document = typeof content === "string" ? parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA) : content;
+  const missingSummary = !extractChangeSummary(document.source, document, { preservePlaceholder: true });
+  if (missingSummary)
+    warnings.push("archived Change must contain frontmatter summary, Proposal Outcome, or Proposal Summary");
+  const tasksSection = getDocumentSectionMarkdown(document, "tasks");
+  const verifySection = getDocumentSectionMarkdown(document, "verify");
+  const taskTodos = getOpenCheckboxes(tasksSection);
+  if (taskTodos.length > 0)
+    warnings.push(`${taskTodos.length} task item(s) still incomplete`);
+  const verifyItems = collectVerifyCheckboxes(verifySection);
+  const verifyCriticality = summarizeVerifyCheckboxes(verifyItems);
+  const requiredVerifyTodos = openCheckboxLines([...verifyItems.required, ...verifyItems.unclassified]);
+  const optionalVerifyTodos = openCheckboxLines(verifyItems.optional);
+  const verifyTodos = [...requiredVerifyTodos, ...optionalVerifyTodos];
+  if (requiredVerifyTodos.length > 0)
+    warnings.push(`${requiredVerifyTodos.length} required Verify item(s) are still incomplete`);
+  if (optionalVerifyTodos.length > 0)
+    warnings.push(`${optionalVerifyTodos.length} optional Verify item(s) are still incomplete`);
+  const activeBlockers = options.activeBlockers ?? hasMeaningfulBlockers(document);
+  if (activeBlockers)
+    warnings.push("active blockers are present in the change file");
+  const scenarios = parseScenarios(document.markdown);
+  const missingScenarios = scenarios.length === 0;
+  if (missingScenarios)
+    warnings.push("no Scenario blocks found (some changes do not need them)");
+  const archiveReady = documentDiagnostics.some((diagnostic) => diagnostic.severity === "error") || missingSummary || activeBlockers || taskTodos.length > 0 || requiredVerifyTodos.length > 0 ? "no" : "yes";
+  return {
+    taskTodos,
+    verifyTodos,
+    requiredVerifyTodos,
+    optionalVerifyTodos,
+    verifyCriticality,
+    activeBlockers,
+    scenarioCount: scenarios.length,
+    missingScenarios,
+    deterministic: warnings.length === 0 ? "pass" : "warnings",
+    semantic: "needs-review",
+    archiveReady,
+    warnings,
+    documentDiagnostics
+  };
+}
+function toArchiveReadinessOutput(readiness) {
+  return {
+    incompleteTasks: readiness.taskTodos.length,
+    incompleteVerify: readiness.verifyTodos.length,
+    incompleteRequiredVerify: readiness.requiredVerifyTodos.length,
+    incompleteOptionalVerify: readiness.optionalVerifyTodos.length,
+    requiredVerify: readiness.verifyCriticality.required,
+    optionalVerify: readiness.verifyCriticality.optional,
+    legacyVerify: readiness.verifyCriticality.legacy,
+    completionGate: readiness.archiveReady === "no" ? "blocked" : "pass",
+    coverageWarnings: readiness.optionalVerifyTodos.length,
+    activeBlockers: readiness.activeBlockers,
+    missingScenarios: readiness.missingScenarios,
+    deterministic: readiness.deterministic,
+    semantic: readiness.semantic,
+    archiveReady: readiness.archiveReady
+  };
+}
+function buildDurableReviewGuidance(factCandidateTargets, decisionRecordsPath) {
+  return {
+    required: true,
+    factDecisions: ["No current-fact update needed", "Update existing spec or scoped instruction", "Create a new durable spec"],
+    rationaleDecisions: ["No Decision Record needed", "Create or update a Decision Record"],
+    factCandidateTargets,
+    decisionRecordsPath,
+    note: "Semantic review decides current-fact and lasting-rationale updates independently. The CLI never infers scoped instruction or Decision Record filenames and never promotes Change content automatically."
+  };
+}
+function getDurableReviewCandidateTargets() {
+  return [".rsp/specs/design.md"];
+}
+
+// src/status/inspect.ts
+async function inspectProjectStatus(options = {}) {
+  const runtime = [];
+  const diagnostics = [];
+  let workflow = resolveWorkflowPolicy({});
+  let language = resolveLanguagePolicy({});
+  try {
+    const configInspection = await inspectRspConfig();
+    const configValid = configInspection.issues.length === 0;
+    workflow = resolveWorkflowPolicy(configInspection.config, { configValid });
+    language = resolveLanguagePolicy(configInspection.config, { configValid });
+    if (!configValid) {
+      diagnostics.push({
+        severity: "error",
+        code: "invalid_config",
+        path: CONFIG_PATH,
+        message: configInspection.issues.join("; ")
+      });
+    }
+  } catch (error) {
+    workflow = resolveWorkflowPolicy({}, { configValid: false });
+    language = resolveLanguagePolicy({}, { configValid: false });
+    diagnostics.push({
+      severity: "error",
+      code: "invalid_config",
+      path: CONFIG_PATH,
+      message: toErrorMessage(error)
+    });
+  }
+  const focusTree = await inspectFocusTree();
+  for (const diagnostic of focusTree.diagnostics) {
+    diagnostics.push({
+      severity: "error",
+      code: diagnostic.code,
+      change: diagnostic.input,
+      path: diagnostic.path,
+      message: diagnostic.message
+    });
+  }
+  const rawFocusedSet = new Set(focusTree.markers.map((marker) => marker.name));
+  const focusedSet = /* @__PURE__ */ new Set();
+  const focusedPaths = /* @__PURE__ */ new Map();
+  for (const name of rawFocusedSet) {
+    try {
+      const ref = resolveWorkRef(name, { executable: true });
+      focusedSet.add(ref.name);
+      focusedPaths.set(ref.name, ref.path);
+    } catch (error) {
+      if (!(error instanceof WorkRefError))
+        throw error;
+      diagnostics.push({
+        severity: "error",
+        code: error.code,
+        path: `.rsp/focus.d/${name}`,
+        change: name,
+        message: error.message
+      });
+    }
+  }
+  const workTree = await inspectWorkTree();
+  const archiveTree = await inspectArchiveTree();
+  const historyInspection = await inspectArchiveHistory({ archiveTree });
+  diagnostics.push(...workTree.diagnostics.map((diagnostic) => ({
+    severity: "error",
+    code: diagnostic.code,
+    change: diagnostic.input,
+    path: diagnostic.path,
+    message: diagnostic.message
+  })));
+  const groupInspection = await inspectChangeGroups({ workTree, focusTree, archiveTree });
+  diagnostics.push(...groupInspection.diagnostics);
+  const dependencyInspection = await inspectChangeDependencies({
+    workTree,
+    archiveTree,
+    archiveHistory: historyInspection,
+    preferredOrder: groupInspection.groups.flatMap((group) => group.slices.map((slice) => slice.name))
+  });
+  diagnostics.push(...dependencyInspection.diagnostics);
+  const changeMap = new Map(workTree.changes.map((ref) => [ref.name, ref.path]));
+  const allNames = [.../* @__PURE__ */ new Set([...changeMap.keys(), ...focusedSet])].sort();
+  const records = [];
+  const nowMs = options.nowMs ?? Date.now();
+  for (const name of allNames) {
+    const path = changeMap.get(name);
+    let kind = "\u2014";
+    let summary = null;
+    let title = name;
+    let externalBlockers = [];
+    let readiness = emptyReadiness(false);
+    let ageDays = null;
+    const isFocused = focusedSet.has(name);
+    let isBlocked = false;
+    let done = 0;
+    let total = 0;
+    let progressKnown = false;
+    let issues = [];
+    if (path) {
+      try {
+        const content = await readFile5(path, "utf-8");
+        const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
+        title = getDocumentTitle(document, "spaced") ?? name;
+        summary = extractChangeSummary(content, document);
+        externalBlockers = readBlockerEntries(getDocumentSectionMarkdown(document, "blockers")).filter((entry) => entry.kind !== "dependency").map((entry) => entry.text);
+        try {
+          const frontmatter2 = parseFrontmatter(document.markdown);
+          kind = frontmatter2?.kind ? String(frontmatter2.kind) : "\u2014";
+          issues = parseIssueRelationships(frontmatter2);
+        } catch (error) {
+          kind = "(invalid)";
+          const issueError = error instanceof IssueRelationshipError;
+          if (issueError) {
+            diagnostics.push({
+              severity: "error",
+              code: error.code,
+              change: name,
+              path,
+              message: error.message
+            });
+          }
+          runtime.push({
+            code: issueError ? error.code : "frontmatter_parse_failed",
+            operation: "parseFrontmatter",
+            path,
+            message: toErrorMessage(error)
+          });
+        }
+        isBlocked = dependencyInspection.activeBlockers.get(name) ?? hasMeaningfulBlockers(document);
+        const details = collectArchiveReadiness(document, { activeBlockers: isBlocked });
+        const taskCheckboxes = countCheckboxes(getDocumentSectionMarkdown(document, "tasks"));
+        done = taskCheckboxes.done + details.verifyCriticality.required.done;
+        total = taskCheckboxes.total + details.verifyCriticality.required.total;
+        progressKnown = true;
+        readiness = toArchiveReadinessOutput(details);
+      } catch (error) {
+        diagnostics.push({
+          severity: "error",
+          code: "change_read_failed",
+          change: name,
+          path,
+          message: "unable to read open Change",
+          hint: toErrorMessage(error)
+        });
+        runtime.push({
+          code: "change_read_failed",
+          operation: "readFile",
+          path,
+          message: toErrorMessage(error)
+        });
+      }
+      try {
+        const metadata = await stat2(path);
+        ageDays = Math.floor((nowMs - metadata.mtime.getTime()) / (1e3 * 60 * 60 * 24));
+      } catch (error) {
+        diagnostics.push({
+          severity: "error",
+          code: "change_stat_failed",
+          change: name,
+          path,
+          message: "unable to inspect open Change metadata",
+          hint: toErrorMessage(error)
+        });
+        runtime.push({
+          code: "change_stat_failed",
+          operation: "stat",
+          path,
+          message: toErrorMessage(error)
+        });
+      }
+    } else {
+      kind = "(missing)";
+      const path2 = focusedPaths.get(name);
+      diagnostics.push({
+        severity: "error",
+        code: "focused_change_missing",
+        change: name,
+        path: path2,
+        message: "focus marker points to a missing Change file"
+      });
+      runtime.push({
+        code: "focused_change_missing",
+        operation: "resolveChange",
+        path: path2,
+        message: "focus marker points to a missing change file"
+      });
+    }
+    records.push({
+      output: {
+        name,
+        summary,
+        kind,
+        progress: { done, total },
+        ageDays,
+        isFocused,
+        isBlocked,
+        path: path ? normalizeLogicalPath(path) : null,
+        issues
+      },
+      progressKnown,
+      title,
+      externalBlockers,
+      readiness
+    });
+  }
+  return {
+    workflow,
+    language,
+    focused: [...focusedSet].sort(),
+    records,
+    groups: groupInspection.groups,
+    plan: dependencyInspection.plan,
+    archiveTrend: historyInspectionComplete(historyInspection) ? deriveArchiveTrend(historyInspection.records) : [],
+    diagnostics: [...diagnostics, ...historyInspection.rootExists ? historyInspection.diagnostics : []],
+    runtime: [...runtime, ...historyInspection.runtime]
+  };
+}
+function emptyReadiness(activeBlockers) {
+  return {
+    incompleteTasks: 0,
+    incompleteVerify: 0,
+    incompleteRequiredVerify: 0,
+    incompleteOptionalVerify: 0,
+    requiredVerify: { todo: 0, progress: 0, done: 0, dropped: 0, total: 0 },
+    optionalVerify: { todo: 0, progress: 0, done: 0, dropped: 0, total: 0 },
+    legacyVerify: false,
+    completionGate: activeBlockers ? "blocked" : "pass",
+    coverageWarnings: 0,
+    activeBlockers,
+    missingScenarios: false,
+    deterministic: "pass",
+    semantic: "needs-review",
+    archiveReady: activeBlockers ? "no" : "judgment"
+  };
+}
+function deriveArchiveTrend(records) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const month = record.date.slice(0, 7);
+    counts.set(month, (counts.get(month) ?? 0) + 1);
+  }
+  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);
+  return {
+    ...projectionBase(inspection),
+    mode: "tree",
+    tree: inspection.tree,
+    decisionRecords: inspection.decisionRecords,
+    documents: inspection.documents
+  };
+}
+async function projectSpecsDetail(inspection, path) {
+  assertCompleteInspection(inspection);
+  return {
+    ...projectionBase(inspection),
+    mode: "detail",
+    document: await readSpecsDetail(inspection, path)
+  };
+}
+async function projectSpecsSearch(inspection, literal, options) {
+  assertCompleteInspection(inspection);
+  const result = await searchSpecs(inspection, literal, options);
+  return {
+    ...projectionBase(inspection),
+    mode: "search",
+    query: {
+      literal,
+      limit: options.limit,
+      excerptCodePoints: options.excerptCodePoints
+    },
+    matches: result.matches,
+    summary: result.summary
+  };
+}
+function assertCompleteInspection(inspection) {
+  if (!specsInspectionComplete(inspection)) {
+    throw new SpecsQueryError(
+      "specs_inspection_incomplete",
+      "Specs inspection is incomplete; resolve the reported diagnostics before using the projection"
+    );
+  }
+}
+function projectionBase(inspection) {
+  return {
+    source: inspection.source,
+    roots: inspection.roots,
+    generatedIndexes: inspection.generatedIndexes,
+    diagnostics: inspection.diagnostics,
+    diagnosticSummary: inspection.diagnosticSummary,
+    runtime: inspection.runtime,
+    limits: inspection.limits
+  };
+}
+
+// src/status/dependency-forest.ts
+function defaultRoots(plan) {
+  const selected = new Set(plan.nodes.filter((node) => node.selection === "selected").map((node) => node.name));
+  const nested = new Set(plan.edges.filter((edge) => selected.has(edge.change) && selected.has(edge.requires)).map((edge) => edge.requires));
+  const roots = [...selected].filter((name) => !nested.has(name)).sort();
+  return roots.length > 0 ? roots : [...selected].sort();
+}
+function projectDependencyForest(plan, requestedRoots = defaultRoots(plan)) {
+  const nodes = new Map(plan.nodes.map((node) => [node.name, node]));
+  const edges = /* @__PURE__ */ new Map();
+  for (const edge of plan.edges) {
+    const children = edges.get(edge.change) ?? [];
+    children.push(edge);
+    edges.set(edge.change, children);
+  }
+  for (const children of edges.values())
+    children.sort((left, right) => left.requires.localeCompare(right.requires));
+  const expanded = /* @__PURE__ */ new Set();
+  const visit = (name, edge) => {
+    const node = nodes.get(name);
+    if (!node)
+      return null;
+    const shared = expanded.has(name);
+    if (!shared)
+      expanded.add(name);
+    return {
+      ...node,
+      ...edge ? { reason: edge.reason, edgeState: edge.state } : {},
+      shared,
+      children: shared ? [] : (edges.get(name) ?? []).map((child) => visit(child.requires, child)).filter((child) => child !== null)
+    };
+  };
+  return requestedRoots.map((name) => visit(name)).filter((node) => node !== null);
+}
+
+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,
+  normalizeExecutableWorkRef,
+  resolveWorkRef,
+  resolveWorkRefPath,
+  resolveFocusMarkerPath,
+  resolveArchiveDirectory,
+  inspectFocusTree,
+  inspectArchiveTree,
+  inspectWorkTree,
+  GROUP_REOPEN_COMPLETION_PREFIX,
+  resolveExecutableChange,
+  generateGroupBriefContent,
+  inspectChangeGroups,
+  getGroupReopenEvidence,
+  hasArchivedGroupBrief,
+  HISTORY_DEFAULT_LIMIT,
+  HISTORY_MAX_LIMIT,
+  ArchiveHistoryError,
+  inspectArchiveHistory,
+  queryArchiveHistory,
+  selectArchiveHistoryRecord,
+  selectArchivedGroupBrief,
+  readArchiveHistoryDetail,
+  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,
+  getDurableReviewCandidateTargets,
+  projectSpecsTree,
+  projectSpecsDetail,
+  projectSpecsSearch,
+  inspectProjectStatus,
+  projectDependencyForest
+};