@oevery/rsp 3.1.0-beta.3 → 3.1.0-beta.4

package/dist/{chunk-7KKAUBKN.mjs → chunk-FI3SYHVH.mjs}

@@ -2,24 +2,34 @@
 import {
   ARCHIVES_DIR,
   CHANGES_DIR,
+  CHANGE_DOCUMENT_SCHEMA,
   CONFIG_PATH,
   FOCUS_DIR,
+  GROUP_BRIEF_DOCUMENT_SCHEMA,
   ManagedPathError,
   collectArchiveReadiness,
   countCheckboxes,
   extractBlockerLines,
-  extractSection,
+  getCanonicalSectionHeadings,
+  getDocumentSectionBody,
+  getDocumentTitle,
+  getDocumentTitles,
+  hasMeaningfulBlockerBody,
   hasMeaningfulBlockers,
   inspectManagedDirectory,
   inspectRspConfig,
   normalizeLogicalPath,
   parseFrontmatter,
+  parseRspDocument,
   parseScenarios,
+  renderDocumentSectionHeading,
+  renderDocumentTitle,
   requireManagedDirectory,
   requireManagedFile,
+  resolveLanguagePolicy,
   resolveManagePolicy,
   toErrorMessage
-} from "./chunk-OTJFL6XH.mjs";
+} from "./chunk-FJVH7ZYU.mjs";
 
 // src/status/inspect.ts
 import { readFile as readFile5, stat } from "fs/promises";
@@ -29,10 +39,13 @@ import { readFile } from "fs/promises";
 import { dirname, join as join2, relative as relative2 } from "path";
 
 // src/core/work-ref.ts
-import { lstatSync } from "fs";
+import { Buffer } from "buffer";
+import { lstatSync, readdirSync } from "fs";
 import { readdir } from "fs/promises";
 import { isAbsolute, join, relative } from "path";
-var WORK_SEGMENT_RE = /^[a-z0-9-]+$/;
+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) {
@@ -44,35 +57,51 @@ var WorkRefError = class extends Error {
   code;
   input;
 };
-function resolveWorkRef(name, options = {}) {
-  const changesDir = options.changesDir ?? CHANGES_DIR;
-  const segments = name.split("/");
-  const isGroupBrief = segments.length === 2 && segments[1] === "brief";
-  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) => !WORK_SEGMENT_RE.test(segment))) {
+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 "${name}" must contain one or two lowercase kebab-case segments`,
-      name
+      `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
     );
   }
-  if (segments.length === 2 && segments[1] === GROUP_BRIEF_FILENAME.slice(0, -3)) {
+  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",
-      `work identity "${name}" uses the reserved Group Brief filename`,
+      `stored work identity "${name}" must use Unicode NFC normalization`,
       name
     );
   }
-  assertValidWorkRoot(changesDir, name);
-  assertNoIdentityCollision(changesDir, segments, name, isGroupBrief ? GROUP_BRIEF_FILENAME : void 0);
+  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 = join(changesDir, ...segments.slice(0, -1), isGroupBrief ? GROUP_BRIEF_FILENAME : `${segments.at(-1)}.md`);
-  const ref = segments.length === 1 ? { kind: "change", name, path, group: null } : isGroupBrief ? { kind: "group-brief", name, path, group: segments[0] } : { kind: "group-change", name, path, group: segments[0] };
+  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") {
@@ -147,7 +176,7 @@ function resolveWorkRefPath(path, options = {}) {
     );
   }
   const name = segments.length === 2 && segments[1] === GROUP_BRIEF_FILENAME ? `${segments[0]}/brief` : logicalPath.slice(0, -3);
-  return resolveWorkRef(name, options);
+  return resolveWorkRef(name, { ...options, canonical: true });
 }
 function isExecutableWorkRef(ref) {
   return ref.kind !== "group-brief";
@@ -155,6 +184,7 @@ function isExecutableWorkRef(ref) {
 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(
       join(focusDir, ref.group),
@@ -178,6 +208,7 @@ function resolveArchiveDirectory(ref, options = {}) {
   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 = join(archivesDir, ref.group);
   assertOptionalManagedDirectory(groupPath, ref.name, "invalid_archive_path", "archive path");
   return groupPath;
@@ -201,10 +232,10 @@ async function inspectFocusTree(options = {}) {
     if (entry.name === ".gitkeep" && entry.isFile())
       continue;
     if (entry.isDirectory()) {
-      if (!WORK_SEGMENT_RE.test(entry.name)) {
+      if (!isCanonicalWorkRefSegment(entry.name)) {
         addDiagnostic(result, new WorkRefError(
           "invalid_work_ref",
-          `work identity "${entry.name}" must contain one or two lowercase kebab-case segments`,
+          `stored work identity "${entry.name}" must be a safe Unicode NFC segment`,
           entry.name
         ), path);
         continue;
@@ -244,7 +275,7 @@ async function inspectArchiveTree(options = {}) {
     if (entry.name === "INDEX.md" && entry.isFile())
       continue;
     if (entry.isDirectory()) {
-      if (!WORK_SEGMENT_RE.test(entry.name)) {
+      if (!isCanonicalWorkRefSegment(entry.name)) {
         addArchivePathDiagnostic(result, entry.name, path);
         continue;
       }
@@ -282,10 +313,10 @@ async function inspectWorkTree(options = {}) {
     if (entry.name === ".gitkeep" && entry.isFile())
       continue;
     if (entry.isDirectory()) {
-      if (!WORK_SEGMENT_RE.test(entry.name)) {
+      if (!isCanonicalWorkRefSegment(entry.name)) {
         addDiagnostic(result, new WorkRefError(
           "invalid_work_ref",
-          `work identity "${entry.name}" must contain one or two lowercase kebab-case segments`,
+          `stored work identity "${entry.name}" must be a safe Unicode NFC segment`,
           entry.name
         ), path);
         continue;
@@ -400,7 +431,7 @@ async function inspectArchiveGroup(group, groupPath, result) {
 }
 function collectFocusMarker(input, path, changesDir, result) {
   try {
-    const ref = resolveWorkRef(input, { changesDir, executable: true });
+    const ref = resolveWorkRef(input, { changesDir, canonical: true, executable: true });
     result.markers.push({ name: ref.name, path });
   } catch (error) {
     if (!(error instanceof WorkRefError))
@@ -448,6 +479,98 @@ function addDiagnostic(result, error, path) {
     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 = join(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 = join(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 = join(changesDir, ...segments.slice(0, depth));
@@ -542,7 +665,7 @@ function normalizeLogicalPath2(path) {
 }
 
 // src/core/change-group.ts
-var GROUP_BRIEF_SECTIONS = ["Goal", "Scope", "Shared Constraints", "Slices", "Completion Conditions", "Durable Outcomes", "Blockers"];
+var GROUP_BRIEF_SECTIONS = getCanonicalSectionHeadings(GROUP_BRIEF_DOCUMENT_SCHEMA);
 async function resolveExecutableChange(name, options = {}) {
   const ref = resolveWorkRef(name, { ...options, executable: true });
   if (ref.kind === "group-change")
@@ -550,32 +673,33 @@ async function resolveExecutableChange(name, options = {}) {
   return ref;
 }
 function generateGroupBriefContent(name, goal = "") {
+  const placeholder = "<\u2026>";
   return `---
 kind: group
 ---
 
-# Change Group: ${name}
+${renderDocumentTitle(GROUP_BRIEF_DOCUMENT_SCHEMA, name)}
 
-## Goal
-- ${goal || "<what shared outcome this group must deliver>"}
+${groupSectionHeading("goal")}
+- ${goal || placeholder}
 
-## Scope
-- <what is coordinated by this group>
+${groupSectionHeading("scope")}
+- ${placeholder}
 
-## Shared Constraints
-- <constraint shared by every child Change>
+${groupSectionHeading("sharedConstraints")}
+- ${placeholder}
 
-## Slices
-- \`${name}/<change>\`: <independently executable boundary>
+${groupSectionHeading("slices")}
+- \`${name}/<change>\`: ${placeholder}
 
-## Completion Conditions
-- [ ] <end-to-end condition beyond individual child verification>
+${groupSectionHeading("completionConditions")}
+- [ ] ${placeholder}
 
-## Durable Outcomes
-- Current facts: <Spec, CONTEXT.md, scoped instruction target, or none>
-- Lasting rationale: <Decision Record target, or none>
+${groupSectionHeading("durableOutcomes")}
+- Current facts: ${placeholder}
+- Lasting rationale: ${placeholder}
 
-## Blockers
+${groupSectionHeading("blockers")}
 - none
 `;
 }
@@ -595,10 +719,10 @@ async function inspectChangeGroups(options = {}) {
       continue;
     try {
       const content = await readFile(path, "utf-8");
-      const heading = content.match(/^# Change:\s+(\S+)\s*$/m);
-      if (heading?.[1]?.includes("/")) {
-        const identity = heading[1];
-        if (!new RegExp(`^${escapeRegExp(archiveGroup)}/[a-z0-9-]+$`).test(identity)) {
+      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",
@@ -612,7 +736,7 @@ async function inspectChangeGroups(options = {}) {
           archivedSlicesByGroup.set(archiveGroup, groupSlices);
         }
       }
-      if (new RegExp(`^# Change Group:\\s+${escapeRegExp(archiveGroup)}\\s*$`, "m").test(content))
+      if (getDocumentTitle(parseRspDocument(content, GROUP_BRIEF_DOCUMENT_SCHEMA), "identity") === archiveGroup)
         archivedGroups.add(archiveGroup);
     } catch (error) {
       diagnostics.push({
@@ -774,13 +898,14 @@ async function hasArchivedGroupBrief(group) {
       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 (new RegExp(`^# Change Group:\\s+${escapeRegExp(group)}\\s*$`, "m").test(content))
+    if (getDocumentTitle(parseRspDocument(content, GROUP_BRIEF_DOCUMENT_SCHEMA), "identity") === group)
       return true;
   }
   return false;
 }
 function parseGroupBrief(group, content) {
   const diagnostics = [];
+  const document = parseRspDocument(content, GROUP_BRIEF_DOCUMENT_SCHEMA);
   let frontmatter;
   try {
     frontmatter = parseFrontmatter(content);
@@ -789,15 +914,15 @@ function parseGroupBrief(group, content) {
   }
   if (frontmatter?.kind !== "group")
     diagnostics.push({ severity: "error", code: "group_kind_invalid", change: group, message: "Group Brief frontmatter must declare kind: group" });
-  if (!new RegExp(`^# Change Group:\\s+${escapeRegExp(group)}\\s*$`, "m").test(content))
+  if (getDocumentTitle(document, "identity") !== group)
     diagnostics.push({ severity: "error", code: "group_heading_mismatch", change: group, message: `Group Brief heading must be: # Change Group: ${group}` });
-  for (const section of GROUP_BRIEF_SECTIONS) {
-    if (!extractSection(content, section))
-      diagnostics.push({ severity: "error", code: "group_section_missing", change: group, message: `Group Brief missing required section: ${section}` });
+  for (const definition of GROUP_BRIEF_DOCUMENT_SCHEMA.sections) {
+    if (!getDocumentSectionBody(document, definition.id))
+      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 extractSection(content, "Slices").split("\n")) {
+  for (const line of getDocumentSectionBody(document, "slices").split("\n")) {
     const trimmed = line.trim();
     const identity = trimmed.match(/^-\s+`(\S+)`/);
     if (!identity || identity[1].includes("<"))
@@ -813,7 +938,7 @@ function parseGroupBrief(group, content) {
       diagnostics.push({ severity: "error", code: "group_slice_invalid", change: group, message: `group slice requires a boundary: ${name}` });
       continue;
     }
-    if (!new RegExp(`^${escapeRegExp(group)}/[a-z0-9-]+$`).test(name) || name === `${group}/brief`) {
+    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;
     }
@@ -826,382 +951,123 @@ function parseGroupBrief(group, content) {
   }
   if (slices.length < 2)
     diagnostics.push({ severity: "warning", code: "group_slices_incomplete", change: group, message: "Change Group must declare at least two direct child slices" });
-  const completion = countCheckboxes(extractSection(content, "Completion Conditions"));
+  const completion = countCheckboxes(getDocumentSectionBody(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: hasMeaningfulBlockers(content),
+    blockers: hasMeaningfulBlockerBody(getDocumentSectionBody(document, "blockers")),
     diagnostics
   };
 }
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function groupSectionHeading(sectionId) {
+  return renderDocumentSectionHeading(GROUP_BRIEF_DOCUMENT_SCHEMA, sectionId);
 }
 
 // src/core/dependency-plan.ts
+import { readFile as readFile4 } from "fs/promises";
+
+// src/history/query.ts
+import { readFile as readFile3 } from "fs/promises";
+
+// src/history/inspect.ts
 import { readFile as readFile2 } from "fs/promises";
-var NONE_BLOCKER_RE = /^[-*]\s*(?:none)?$/i;
-var REQUIRES_RE = /^[-*]\s+requires\s+`([^`]+)`:[ \t]*(\S.*)$/i;
-var EXECUTABLE_WORK_REF_RE = /^[a-z0-9-]+(?:\/(?!(?:brief|00-brief)$)[a-z0-9-]+)?$/;
-async function inspectChangeDependencies(options = {}) {
-  const workTree = options.workTree ?? await inspectWorkTree();
-  const archiveTree = options.archiveTree ?? await inspectArchiveTree();
-  const openNames = new Set(workTree.changes.map((ref) => ref.name));
-  const archivedNames = /* @__PURE__ */ new Set();
-  const parsedByName = /* @__PURE__ */ new Map();
-  const blockedGroups = /* @__PURE__ */ new Set();
-  const diagnostics = archiveTree.diagnostics.map((diagnostic) => ({
+import { basename, dirname as dirname2, relative as relative3 } 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 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/inspect.ts
+var ARCHIVE_NAME_RE = /^(\d{4}-\d{2}-\d{2})_(.+)\.md$/;
+async function inspectArchiveHistory(options = {}) {
+  const archivesDir = options.archivesDir ?? ARCHIVES_DIR;
+  const tree = options.archiveTree ?? await inspectArchiveTree({ archivesDir });
+  const diagnostics = tree.diagnostics.map((diagnostic) => ({
     severity: "error",
     code: diagnostic.code,
-    path: diagnostic.path,
+    path: normalizeOutputPath(diagnostic.path, archivesDir),
     message: diagnostic.message
   }));
-  for (const path of archiveTree.files) {
-    try {
-      const heading = (await readFile2(path, "utf-8")).match(/^# Change:\s+(\S+)\s*$/m);
-      if (heading)
-        archivedNames.add(heading[1]);
-    } catch (error) {
-      diagnostics.push({
-        severity: "error",
-        code: "dependency_archive_read_failed",
-        path,
-        message: error instanceof Error ? error.message : String(error)
-      });
-    }
+  const runtime = [];
+  const records = [];
+  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 brief of workTree.briefs) {
+  for (const sourcePath of tree.files) {
+    const path = archiveOutputPath(sourcePath, archivesDir);
+    let content;
     try {
-      if (hasMeaningfulBlockers(await readFile2(brief.path, "utf-8")))
-        blockedGroups.add(brief.group);
+      content = await readFile2(sourcePath, "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)
-      });
+      const message = toErrorMessage(error);
+      diagnostics.push({ severity: "error", code: "archive_read_failed", path, message: `unable to read archived work: ${message}` });
+      continue;
     }
+    const parsed = parseArchiveEntry(sourcePath, path, archivesDir, content);
+    if (parsed.diagnostic)
+      diagnostics.push(parsed.diagnostic);
+    if (parsed.record)
+      records.push(parsed.record);
   }
-  for (const ref of workTree.changes) {
-    try {
-      const parsed = parseDependencyBlockers(await readFile2(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)
-      });
-    }
+  records.sort(compareHistoryRecords);
+  diagnostics.sort(compareDiagnostics);
+  const diagnosticTotal = diagnostics.length;
+  const boundedDiagnostics = diagnostics.slice(0, HISTORY_MAX_DIAGNOSTICS);
+  return {
+    rootExists: tree.rootExists,
+    records,
+    diagnostics: boundedDiagnostics,
+    diagnosticSummary: {
+      total: diagnosticTotal,
+      returned: boundedDiagnostics.length,
+      hasMore: diagnosticTotal > boundedDiagnostics.length
+    },
+    runtime
+  };
+}
+function parseArchiveEntry(sourcePath, path, archivesDir, content) {
+  const nameMatch = basename(sourcePath).match(ARCHIVE_NAME_RE);
+  if (!nameMatch || !isCalendarDate(nameMatch[1])) {
+    return { diagnostic: errorDiagnostic("archive_name_invalid", path, "archive filename must use a valid YYYY-MM-DD_name.md date") };
   }
-  const 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 (!EXECUTABLE_WORK_REF_RE.test(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 = [];
-  for (const line of extractBlockerLines(content)) {
-    if (!line || NONE_BLOCKER_RE.test(line) || /^none$/i.test(line))
-      continue;
-    const dependency = line.match(REQUIRES_RE);
-    if (dependency) {
-      if (!requires.has(dependency[1]))
-        requires.set(dependency[1], dependency[2]);
-    } else if (/^[-*]\s+requires\b/i.test(line)) {
-      malformed.push(line);
-      external = true;
-    } else {
-      external = true;
-    }
-  }
-  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 changed = true;
-  while (changed) {
-    changed = false;
-    for (const edge of edges) {
-      if ((edge.state === "missing" || excluded.has(edge.requires)) && !excluded.has(edge.change)) {
-        excluded.add(edge.change);
-        changed = 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/history/query.ts
-import { readFile as readFile4 } from "fs/promises";
-
-// src/history/inspect.ts
-import { readFile as readFile3 } from "fs/promises";
-import { basename, dirname as dirname2, relative as relative3 } 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 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/inspect.ts
-var EXECUTABLE_WORK_REF_RE2 = /^[a-z0-9-]+(?:\/[a-z0-9-]+)?$/;
-var GROUP_NAME_RE = /^[a-z0-9-]+$/;
-var ARCHIVE_NAME_RE = /^(\d{4}-\d{2}-\d{2})_(.+)\.md$/;
-async function inspectArchiveHistory(options = {}) {
-  const archivesDir = options.archivesDir ?? ARCHIVES_DIR;
-  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 = [];
-  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 content;
-    try {
-      content = await readFile3(sourcePath, "utf-8");
-    } catch (error) {
-      const message = toErrorMessage(error);
-      diagnostics.push({ severity: "error", code: "archive_read_failed", path, message: `unable to read archived work: ${message}` });
-      continue;
-    }
-    const parsed = parseArchiveEntry(sourcePath, path, archivesDir, content);
-    if (parsed.diagnostic)
-      diagnostics.push(parsed.diagnostic);
-    if (parsed.record)
-      records.push(parsed.record);
-  }
-  records.sort(compareHistoryRecords);
-  diagnostics.sort(compareDiagnostics);
-  const diagnosticTotal = diagnostics.length;
-  const boundedDiagnostics = diagnostics.slice(0, HISTORY_MAX_DIAGNOSTICS);
-  return {
-    rootExists: tree.rootExists,
-    records,
-    diagnostics: boundedDiagnostics,
-    diagnosticSummary: {
-      total: diagnosticTotal,
-      returned: boundedDiagnostics.length,
-      hasMore: diagnosticTotal > boundedDiagnostics.length
-    },
-    runtime
-  };
-}
-function parseArchiveEntry(sourcePath, path, archivesDir, content) {
-  const nameMatch = basename(sourcePath).match(ARCHIVE_NAME_RE);
-  if (!nameMatch || !isCalendarDate(nameMatch[1])) {
-    return { diagnostic: errorDiagnostic("archive_name_invalid", path, "archive filename must use a valid YYYY-MM-DD_name.md date") };
-  }
-  const date = nameMatch[1];
-  const archiveStem = nameMatch[2];
-  const relativeDirectory = normalizeLogicalPath(relative3(archivesDir, dirname2(sourcePath)));
-  const archiveGroup = relativeDirectory === "." || relativeDirectory === "" ? null : relativeDirectory;
-  if (archiveGroup && !GROUP_NAME_RE.test(archiveGroup))
-    return { diagnostic: errorDiagnostic("archive_identity_mismatch", path, "archive group path is not a valid one-segment Group identity") };
-  const changeHeadings = [...content.matchAll(/^# Change:\s+(\S+)\s*$/gm)].map((match) => match[1]);
-  const groupHeadings = [...content.matchAll(/^# Change Group:\s+(\S+)\s*$/gm)].map((match) => match[1]);
-  if (changeHeadings.length + groupHeadings.length !== 1) {
-    return { diagnostic: errorDiagnostic("archive_heading_invalid", path, "archive must contain exactly one Change or Change Group identity heading") };
+  const date = nameMatch[1];
+  const archiveStem = nameMatch[2];
+  const relativeDirectory = normalizeLogicalPath(relative3(archivesDir, dirname2(sourcePath)));
+  const archiveGroup = relativeDirectory === "." || relativeDirectory === "" ? null : relativeDirectory;
+  if (archiveGroup && !isCanonicalWorkRefSegment(archiveGroup))
+    return { diagnostic: errorDiagnostic("archive_identity_mismatch", path, "archive group path is not a valid one-segment Group identity") };
+  const changeDocument = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
+  const groupDocument = parseRspDocument(content, GROUP_BRIEF_DOCUMENT_SCHEMA);
+  const changeHeadings = getDocumentTitles(changeDocument, "identity");
+  const groupHeadings = getDocumentTitles(groupDocument, "identity");
+  if (changeHeadings.length + groupHeadings.length !== 1) {
+    return { diagnostic: errorDiagnostic("archive_heading_invalid", path, "archive must contain exactly one Change or Change Group identity heading") };
   }
   let frontmatter;
   try {
@@ -1225,10 +1091,10 @@ function parseArchiveEntry(sourcePath, path, archivesDir, content) {
   }
   const expectedGroup = segments.length === 2 ? segments[0] : null;
   const expectedBase = segments.at(-1);
-  if (!EXECUTABLE_WORK_REF_RE2.test(workRef) || expectedGroup !== archiveGroup || !matchesArchiveStem(archiveStem, expectedBase)) {
+  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 = extractSummary(content);
+  const rawSummary = extractSummary(content, changeDocument);
   if (!rawSummary)
     return { diagnostic: errorDiagnostic("archive_summary_missing", path, "archived Change must contain frontmatter summary, Proposal Outcome, or Proposal Summary") };
   const summary = boundText(rawSummary);
@@ -1246,11 +1112,11 @@ function parseArchiveEntry(sourcePath, path, archivesDir, content) {
     }
   };
 }
-function extractSummary(content) {
+function extractSummary(content, document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA)) {
   const frontmatter = parseFrontmatter(content);
   if (typeof frontmatter?.summary === "string" && frontmatter.summary.trim())
     return frontmatter.summary.trim();
-  const proposalLines = extractSection(content, "Proposal").split("\n").map((line) => line.trim());
+  const proposalLines = getDocumentSectionBody(document, "proposal").split("\n").map((line) => line.trim());
   for (const prefix of ["- Outcome:", "- Summary:"]) {
     const line = proposalLines.find((candidate) => candidate.startsWith(prefix));
     if (line && line.slice(prefix.length).trim())
@@ -1263,7 +1129,7 @@ function boundText(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(`^${escapeRegExp2(identityBase)}-(?:[2-9]|[1-9]\\d+)$`).test(stem);
+  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`);
@@ -1279,7 +1145,7 @@ function normalizeOutputPath(path, archivesDir) {
 function errorDiagnostic(code, path, message) {
   return { severity: "error", code, path, message };
 }
-function escapeRegExp2(value) {
+function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function compareHistoryRecords(left, right) {
@@ -1292,8 +1158,9 @@ function compareDiagnostics(left, right) {
 // 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) && (!query.group || record.group === query.group) && (!query.search || `${record.workRef}
+  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 {
@@ -1317,8 +1184,13 @@ function validateArchiveHistoryQuery(query) {
     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 && !/^[a-z0-9-]+$/.test(query.group))
-    throw new ArchiveHistoryError("invalid_history_group", "history group must be one lowercase kebab-case segment");
+  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");
 }
@@ -1336,13 +1208,14 @@ function selectArchiveHistoryRecord(records, selector) {
 async function readArchiveHistoryDetail(record) {
   let content;
   try {
-    content = await readFile4(record.sourcePath, "utf-8");
+    content = await readFile3(record.sourcePath, "utf-8");
   } catch (error) {
     throw new ArchiveHistoryError("archive_read_failed", `unable to read archived Change ${record.path}: ${error instanceof Error ? error.message : String(error)}`);
   }
-  const tasks = extractSection(content, "Tasks");
-  const verify = extractSection(content, "Verify");
-  const blockers = extractSection(content, "Blockers");
+  const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
+  const tasks = getDocumentSectionBody(document, "tasks");
+  const verify = getDocumentSectionBody(document, "verify");
+  const blockers = getDocumentSectionBody(document, "blockers");
   return {
     ...toOutputRecord(record),
     scenarioCount: parseScenarios(content).length,
@@ -1382,15 +1255,268 @@ 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
+var NONE_BLOCKER_RE = /^[-*]\s*(?:none)?$/i;
+var REQUIRES_RE = /^[-*]\s+requires\s+`([^`]+)`:[ \t]*(\S.*)$/i;
+async function inspectChangeDependencies(options = {}) {
+  const workTree = options.workTree ?? await inspectWorkTree();
+  const archiveTree = options.archiveTree ?? await inspectArchiveTree();
+  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 = [];
+  for (const line of extractBlockerLines(content)) {
+    if (!line || NONE_BLOCKER_RE.test(line) || /^none$/i.test(line))
+      continue;
+    const dependency = line.match(REQUIRES_RE);
+    if (dependency) {
+      if (!requires.has(dependency[1]))
+        requires.set(dependency[1], dependency[2]);
+    } else if (/^[-*]\s+requires\b/i.test(line)) {
+      malformed.push(line);
+      external = true;
+    } else {
+      external = true;
+    }
+  }
+  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 changed = true;
+  while (changed) {
+    changed = false;
+    for (const edge of edges) {
+      if ((edge.state === "missing" || excluded.has(edge.requires)) && !excluded.has(edge.change)) {
+        excluded.add(edge.change);
+        changed = 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/status/inspect.ts
 async function inspectProjectStatus(options = {}) {
   const runtime = [];
   const diagnostics = [];
   let manage = resolveManagePolicy({});
+  let language = resolveLanguagePolicy({});
   try {
     const configInspection = await inspectRspConfig();
     const configValid = configInspection.issues.length === 0;
     manage = resolveManagePolicy(configInspection.config, { configValid });
+    language = resolveLanguagePolicy(configInspection.config, { configValid });
     if (!configValid) {
       diagnostics.push({
         severity: "error",
@@ -1401,6 +1527,7 @@ async function inspectProjectStatus(options = {}) {
     }
   } catch (error) {
     manage = resolveManagePolicy({}, { configValid: false });
+    language = resolveLanguagePolicy({}, { configValid: false });
     diagnostics.push({
       severity: "error",
       code: "invalid_config",
@@ -1453,6 +1580,7 @@ async function inspectProjectStatus(options = {}) {
   const dependencyInspection = await inspectChangeDependencies({
     workTree,
     archiveTree,
+    archiveHistory: historyInspection,
     preferredOrder: groupInspection.groups.flatMap((group) => group.slices.map((slice) => slice.name))
   });
   diagnostics.push(...dependencyInspection.diagnostics);
@@ -1574,6 +1702,7 @@ async function inspectProjectStatus(options = {}) {
   }
   return {
     manage,
+    language,
     focused: [...focusedSet].sort(),
     records,
     groups: groupInspection.groups,
@@ -1595,11 +1724,11 @@ function emptyReadiness(activeBlockers) {
   };
 }
 function extractChangeTitle(content) {
-  const heading = content.split(/\r?\n/).find((line) => line.startsWith("# Change: "));
-  return heading?.slice("# Change: ".length).trim() || null;
+  return getDocumentTitle(parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA), "spaced");
 }
 function extractBlockerEntries(content) {
-  return extractSection(content, "Blockers").split("\n").map((line) => line.trim()).filter((line) => /^[-*]\s+/.test(line)).map((line) => line.replace(/^[-*]\s+/, "").trim()).filter((line) => line.toLowerCase() !== "none");
+  const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
+  return getDocumentSectionBody(document, "blockers").split("\n").map((line) => line.trim()).filter((line) => /^[-*]\s+/.test(line)).map((line) => line.replace(/^[-*]\s+/, "").trim()).filter((line) => line.toLowerCase() !== "none");
 }
 function deriveArchiveTrend(records) {
   const counts = /* @__PURE__ */ new Map();
@@ -1648,6 +1777,8 @@ function projectDependencyForest(plan, requestedRoots = defaultRoots(plan)) {
 export {
   GROUP_BRIEF_FILENAME,
   WorkRefError,
+  normalizeWorkRefSegment,
+  normalizeExecutableWorkRef,
   resolveWorkRef,
   resolveFocusMarkerPath,
   resolveArchiveDirectory,
@@ -1658,7 +1789,6 @@ export {
   generateGroupBriefContent,
   inspectChangeGroups,
   hasArchivedGroupBrief,
-  inspectChangeDependencies,
   HISTORY_DEFAULT_LIMIT,
   HISTORY_MAX_LIMIT,
   ArchiveHistoryError,
@@ -1667,6 +1797,7 @@ export {
   selectArchiveHistoryRecord,
   readArchiveHistoryDetail,
   historyInspectionComplete,
+  inspectChangeDependencies,
   inspectProjectStatus,
   projectDependencyForest
 };