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

package/dist/{chunk-7KKAUBKN.mjs → chunk-ZKZVWJQ7.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-UVYEXKYS.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,8 @@ 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);
+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")
@@ -550,32 +674,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
 `;
 }
@@ -587,6 +712,8 @@ async function inspectChangeGroups(options = {}) {
   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(relative2(ARCHIVES_DIR, path));
@@ -595,10 +722,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,8 +739,16 @@ 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);
+        const evidence = archivedGroupReopenEvidence.get(archiveGroup) ?? /* @__PURE__ */ new Set();
+        for (const item of getGroupReopenEvidence(content))
+          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",
@@ -640,7 +775,11 @@ async function inspectChangeGroups(options = {}) {
     }
     const parsed = parseGroupBrief(brief.group, content);
     diagnostics.push(...parsed.diagnostics.map((diagnostic) => ({ ...diagnostic, path: brief.path })));
-    if (archivedGroups.has(brief.group)) {
+    if (archivedGroups.has(brief.group) && !hasExplicitGroupReopenEvidence(
+      content,
+      archivedGroupReopenEvidence.get(brief.group) ?? /* @__PURE__ */ new Set(),
+      archivedGroupBriefPaths.get(brief.group) ?? /* @__PURE__ */ new Set()
+    )) {
       diagnostics.push({
         severity: "error",
         code: "group_identity_reopened",
@@ -731,6 +870,16 @@ async function inspectChangeGroups(options = {}) {
   groups.sort((left, right) => left.name.localeCompare(right.name));
   return { groups, diagnostics };
 }
+function getGroupReopenEvidence(content) {
+  const completion = getDocumentSectionBody(parseRspDocument(content, GROUP_BRIEF_DOCUMENT_SCHEMA), "completionConditions");
+  return completion.split("\n").flatMap((line) => {
+    const match = line.trim().match(/^-\s+\[([ /xX-])\]\s+(Resolve reopened concern from `(\.rsp\/archives\/[^`]+)`: \S.*)$/);
+    return match ? [{ active: match[1] !== "-", key: match[2], sourcePath: match[3] }] : [];
+  });
+}
+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 = join2(dirname(ref.path), GROUP_BRIEF_FILENAME);
   let content;
@@ -774,13 +923,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 +939,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 +963,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,107 +976,477 @@ 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/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(frontmatter) {
+  if (!frontmatter || !("issues" in frontmatter))
+    return [];
+  if (!Array.isArray(frontmatter.issues))
+    throw new IssueRelationshipError("invalid_issue_shape", 'frontmatter field "issues" must be a list');
+  const seen = /* @__PURE__ */ new Set();
+  return frontmatter.issues.map((value, index) => {
+    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/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) {
+  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 content;
     try {
-      const heading = (await readFile2(path, "utf-8")).match(/^# Change:\s+(\S+)\s*$/m);
-      if (heading)
-        archivedNames.add(heading[1]);
+      content = await readFile2(sourcePath, "utf-8");
     } catch (error) {
-      diagnostics.push({
-        severity: "error",
-        code: "dependency_archive_read_failed",
-        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);
+    if (parsed.groupBrief)
+      groupBriefs.push(parsed.groupBrief);
   }
-  for (const brief of workTree.briefs) {
-    try {
-      if (hasMeaningfulBlockers(await readFile2(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)
-      });
+  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(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 && !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 {
+    frontmatter = parseFrontmatter(content);
+  } catch (error) {
+    return { diagnostic: errorDiagnostic("archive_frontmatter_invalid", path, `archive frontmatter could not be parsed: ${toErrorMessage(error)}`) };
+  }
+  if (typeof frontmatter?.kind !== "string" || frontmatter.kind.trim() === "")
+    return { diagnostic: errorDiagnostic("archive_kind_invalid", path, "archive frontmatter must declare a non-empty kind") };
+  if (groupHeadings.length === 1) {
+    const group = groupHeadings[0];
+    if (!archiveGroup || group !== archiveGroup || frontmatter.kind !== "group" || !matchesArchiveStem(archiveStem, "brief")) {
+      return { diagnostic: errorDiagnostic("archive_identity_mismatch", path, `archived Change Group identity ${group} does not match its archive path`) };
     }
+    return { groupBrief: { date, group, path, sourcePath } };
   }
-  for (const ref of workTree.changes) {
+  let issues;
+  if ("issues" in frontmatter) {
     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)
-      });
+      issues = parseIssueRelationships(frontmatter);
+    } catch {
+      issues = void 0;
     }
   }
-  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",
+  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 = 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);
+  return {
+    record: {
+      date,
+      workRef,
+      group: expectedGroup,
+      kind: frontmatter.kind.trim(),
+      summary: summary.value,
+      summaryTruncated: summary.truncated,
+      path,
+      ...issues === void 0 ? {} : { issues },
+      sourcePath,
+      searchSummary: rawSummary
+    }
+  };
+}
+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 = 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())
+      return line.slice(prefix.length).trim();
+  }
+  return "";
+}
+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(relative3(archivesDir, sourcePath))}`;
+}
+function normalizeOutputPath(path, archivesDir) {
+  const relativePath = normalizeLogicalPath(relative3(archivesDir, 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) {
+  let content;
+  try {
+    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 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,
+    checkboxes: {
+      tasks: countCheckboxes(tasks),
+      verify: countCheckboxes(verify)
+    },
+    evidence: {
+      tasks: boundEvidence(tasks),
+      verify: boundEvidence(verify),
+      blockers: boundEvidence(blockers, true)
+    }
+  };
+}
+function historyInspectionComplete(inspection) {
+  return inspection.diagnostics.every((diagnostic) => diagnostic.severity !== "error");
+}
+function toOutputRecord(record) {
+  const { searchSummary: _searchSummary, sourcePath: _sourcePath, ...output } = record;
+  return output;
+}
+function boundEvidence(section, omitNone = false) {
+  const rawItems = section.split("\n").map((line) => line.trim()).filter(Boolean).filter((line) => !omitNone || !/^[-*]\s*(?:none)?$/i.test(line) && !/^none$/i.test(line));
+  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
+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}`
         });
@@ -1102,295 +1622,17 @@ function findCycleDiagnostics(edges) {
   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") };
-  }
-  let frontmatter;
-  try {
-    frontmatter = parseFrontmatter(content);
-  } catch (error) {
-    return { diagnostic: errorDiagnostic("archive_frontmatter_invalid", path, `archive frontmatter could not be parsed: ${toErrorMessage(error)}`) };
-  }
-  if (typeof frontmatter?.kind !== "string" || frontmatter.kind.trim() === "")
-    return { diagnostic: errorDiagnostic("archive_kind_invalid", path, "archive frontmatter must declare a non-empty kind") };
-  if (groupHeadings.length === 1) {
-    const group = groupHeadings[0];
-    if (!archiveGroup || group !== archiveGroup || frontmatter.kind !== "group" || !matchesArchiveStem(archiveStem, "brief")) {
-      return { diagnostic: errorDiagnostic("archive_identity_mismatch", path, `archived Change Group identity ${group} does not match its archive path`) };
-    }
-    return {};
-  }
-  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 (!EXECUTABLE_WORK_REF_RE2.test(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);
-  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: frontmatter.kind.trim(),
-      summary: summary.value,
-      summaryTruncated: summary.truncated,
-      path,
-      sourcePath,
-      searchSummary: rawSummary
-    }
-  };
-}
-function extractSummary(content) {
-  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());
-  for (const prefix of ["- Outcome:", "- Summary:"]) {
-    const line = proposalLines.find((candidate) => candidate.startsWith(prefix));
-    if (line && line.slice(prefix.length).trim())
-      return line.slice(prefix.length).trim();
-  }
-  return "";
-}
-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(`^${escapeRegExp2(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(relative3(archivesDir, sourcePath))}`;
-}
-function normalizeOutputPath(path, archivesDir) {
-  const relativePath = normalizeLogicalPath(relative3(archivesDir, path));
-  return relativePath === "" ? ".rsp/archives" : `.rsp/archives/${relativePath}`;
-}
-function errorDiagnostic(code, path, message) {
-  return { severity: "error", code, path, message };
-}
-function escapeRegExp2(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 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 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}
-${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 && !/^[a-z0-9-]+$/.test(query.group))
-    throw new ArchiveHistoryError("invalid_history_group", "history group must be one lowercase kebab-case 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];
-}
-async function readArchiveHistoryDetail(record) {
-  let content;
-  try {
-    content = await readFile4(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");
-  return {
-    ...toOutputRecord(record),
-    scenarioCount: parseScenarios(content).length,
-    checkboxes: {
-      tasks: countCheckboxes(tasks),
-      verify: countCheckboxes(verify)
-    },
-    evidence: {
-      tasks: boundEvidence(tasks),
-      verify: boundEvidence(verify),
-      blockers: boundEvidence(blockers, true)
-    }
-  };
-}
-function historyInspectionComplete(inspection) {
-  return inspection.diagnostics.every((diagnostic) => diagnostic.severity !== "error");
-}
-function toOutputRecord(record) {
-  const { searchSummary: _searchSummary, sourcePath: _sourcePath, ...output } = record;
-  return output;
-}
-function boundEvidence(section, omitNone = false) {
-  const rawItems = section.split("\n").map((line) => line.trim()).filter(Boolean).filter((line) => !omitNone || !/^[-*]\s*(?:none)?$/i.test(line) && !/^none$/i.test(line));
-  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/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 +1643,7 @@ async function inspectProjectStatus(options = {}) {
     }
   } catch (error) {
     manage = resolveManagePolicy({}, { configValid: false });
+    language = resolveLanguagePolicy({}, { configValid: false });
     diagnostics.push({
       severity: "error",
       code: "invalid_config",
@@ -1453,6 +1696,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);
@@ -1472,6 +1716,7 @@ async function inspectProjectStatus(options = {}) {
     let done = 0;
     let total = 0;
     let progressKnown = false;
+    let issues = [];
     if (path) {
       try {
         const content = await readFile5(path, "utf-8");
@@ -1480,10 +1725,21 @@ async function inspectProjectStatus(options = {}) {
         try {
           const frontmatter = parseFrontmatter(content);
           kind = frontmatter?.kind ? String(frontmatter.kind) : "\u2014";
+          issues = parseIssueRelationships(frontmatter);
         } 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: "frontmatter_parse_failed",
+            code: issueError ? error.code : "frontmatter_parse_failed",
             operation: "parseFrontmatter",
             path,
             message: toErrorMessage(error)
@@ -1564,7 +1820,8 @@ async function inspectProjectStatus(options = {}) {
         ageDays,
         isFocused,
         isBlocked,
-        path: path ? normalizeLogicalPath(path) : null
+        path: path ? normalizeLogicalPath(path) : null,
+        issues
       },
       progressKnown,
       title,
@@ -1574,6 +1831,7 @@ async function inspectProjectStatus(options = {}) {
   }
   return {
     manage,
+    language,
     focused: [...focusedSet].sort(),
     records,
     groups: groupInspection.groups,
@@ -1595,11 +1853,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,25 +1906,33 @@ function projectDependencyForest(plan, requestedRoots = defaultRoots(plan)) {
 export {
   GROUP_BRIEF_FILENAME,
   WorkRefError,
+  normalizeWorkRefSegment,
+  normalizeExecutableWorkRef,
   resolveWorkRef,
   resolveFocusMarkerPath,
   resolveArchiveDirectory,
   inspectFocusTree,
   inspectArchiveTree,
   inspectWorkTree,
+  GROUP_REOPEN_COMPLETION_PREFIX,
   resolveExecutableChange,
   generateGroupBriefContent,
   inspectChangeGroups,
+  getGroupReopenEvidence,
   hasArchivedGroupBrief,
-  inspectChangeDependencies,
+  IssueRelationshipError,
+  parseIssueRelationships,
+  createIssueRelationship,
   HISTORY_DEFAULT_LIMIT,
   HISTORY_MAX_LIMIT,
   ArchiveHistoryError,
   inspectArchiveHistory,
   queryArchiveHistory,
   selectArchiveHistoryRecord,
+  selectArchivedGroupBrief,
   readArchiveHistoryDetail,
   historyInspectionComplete,
+  inspectChangeDependencies,
   inspectProjectStatus,
   projectDependencyForest
 };