@oevery/rsp 3.2.0 → 4.0.0

package/dist/chunk-ZORUJTVS.mjs

@@ -1,1967 +0,0 @@
-#!/usr/bin/env node
-import {
-  ARCHIVES_DIR,
-  CHANGES_DIR,
-  CHANGE_DOCUMENT_SCHEMA,
-  CONFIG_PATH,
-  FOCUS_DIR,
-  GROUP_BRIEF_DOCUMENT_SCHEMA,
-  ManagedPathError,
-  collectArchiveReadiness,
-  countCheckboxes,
-  extractBlockerLines,
-  getCanonicalSectionHeadings,
-  getDocumentSectionBody,
-  getDocumentTitle,
-  getDocumentTitles,
-  hasMeaningfulBlockerBody,
-  hasMeaningfulBlockers,
-  inspectManagedDirectory,
-  inspectRspConfig,
-  normalizeLogicalPath,
-  parseFrontmatter,
-  parseRspDocument,
-  parseScenarios,
-  renderDocumentSectionHeading,
-  renderDocumentTitle,
-  requireManagedDirectory,
-  requireManagedFile,
-  resolveLanguagePolicy,
-  resolveManagePolicy,
-  toErrorMessage
-} from "./chunk-SEGJLWRE.mjs";
-
-// src/status/inspect.ts
-import { readFile as readFile5, stat } from "fs/promises";
-
-// src/core/change-group.ts
-import { readFile } from "fs/promises";
-import { dirname, join as join2, relative as relative2 } from "path";
-
-// src/core/work-ref.ts
-import { Buffer } from "buffer";
-import { lstatSync, readdirSync } from "fs";
-import { readdir } from "fs/promises";
-import { isAbsolute, join, relative } from "path";
-var WORK_SEGMENT_RE = /^[\p{Ll}\p{Lo}\p{Lm}\p{M}\p{Nd}]+(?:-[\p{Ll}\p{Lo}\p{Lm}\p{M}\p{Nd}]+)*$/u;
-var WORK_SEGMENT_MAX_CODE_POINTS = 100;
-var WORK_SEGMENT_MAX_UTF8_BYTES = 200;
-var GROUP_BRIEF_FILENAME = "00-brief.md";
-var WorkRefError = class extends Error {
-  constructor(code, message, input) {
-    super(message);
-    this.code = code;
-    this.input = input;
-    this.name = "WorkRefError";
-  }
-  code;
-  input;
-};
-function normalizeWorkRefSegment(segment) {
-  const normalized = segment.normalize("NFC");
-  if (!WORK_SEGMENT_RE.test(normalized) || [...normalized].length > WORK_SEGMENT_MAX_CODE_POINTS || Buffer.byteLength(normalized, "utf8") > WORK_SEGMENT_MAX_UTF8_BYTES) {
-    throw new WorkRefError(
-      "invalid_work_ref",
-      `work identity segment "${segment}" must contain at most ${WORK_SEGMENT_MAX_CODE_POINTS} lowercase or caseless Unicode letters, marks, or decimal numbers separated only by internal hyphens and fit within ${WORK_SEGMENT_MAX_UTF8_BYTES} UTF-8 bytes`,
-      segment
-    );
-  }
-  return normalized;
-}
-function normalizeExecutableWorkRef(name) {
-  return normalizeWorkRefName(name, false);
-}
-function isCanonicalExecutableWorkRef(name) {
-  try {
-    return normalizeExecutableWorkRef(name) === name;
-  } catch {
-    return false;
-  }
-}
-function isCanonicalWorkRefSegment(segment) {
-  try {
-    return normalizeWorkRefSegment(segment) === segment;
-  } catch {
-    return false;
-  }
-}
-function resolveWorkRef(name, options = {}) {
-  const changesDir = options.changesDir ?? CHANGES_DIR;
-  const normalizedName = normalizeWorkRefName(name, true);
-  if (options.canonical && normalizedName !== name) {
-    throw new WorkRefError(
-      "invalid_work_ref",
-      `stored work identity "${name}" must use Unicode NFC normalization`,
-      name
-    );
-  }
-  const segments = normalizedName.split("/");
-  const isGroupBrief = segments.length === 2 && segments[1] === "brief";
-  assertValidWorkRoot(changesDir, normalizedName);
-  assertNoNormalizationCollision(changesDir, segments, normalizedName, isGroupBrief);
-  assertNoIdentityCollision(changesDir, segments, normalizedName, isGroupBrief ? GROUP_BRIEF_FILENAME : void 0);
-  const path = join(changesDir, ...segments.slice(0, -1), isGroupBrief ? GROUP_BRIEF_FILENAME : `${segments.at(-1)}.md`);
-  const ref = segments.length === 1 ? { kind: "change", name: normalizedName, path, group: null } : isGroupBrief ? { kind: "group-brief", name: normalizedName, path, group: segments[0] } : { kind: "group-change", name: normalizedName, path, group: segments[0] };
-  if (ref.kind === "group-change" && options.executable !== false)
-    assertGroupBrief(changesDir, ref);
-  if (options.executable && ref.kind === "group-brief") {
-    throw new WorkRefError(
-      "non_executable_work_ref",
-      `work identity "${name}" is a Group Brief and cannot be used as an executable Change`,
-      name
-    );
-  }
-  assertRegularWorkFile(ref, Boolean(options.mustExist));
-  return ref;
-}
-function assertGroupBrief(changesDir, ref) {
-  const briefPath = join(changesDir, ref.group, GROUP_BRIEF_FILENAME);
-  const kind = getPathKind(briefPath, ref.name);
-  if (kind === "missing") {
-    throw new WorkRefError(
-      "group_brief_missing",
-      `Change Group "${ref.group}" requires a Group Brief; run: rsp group create ${ref.group}`,
-      ref.name
-    );
-  }
-  if (kind !== "file") {
-    throw new WorkRefError(
-      "work_ref_not_file",
-      `Group Brief must be a regular file: ${briefPath}`,
-      ref.name
-    );
-  }
-}
-function assertRegularWorkFile(ref, mustExist) {
-  let stats;
-  try {
-    stats = lstatSync(ref.path);
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      if (mustExist) {
-        throw new WorkRefError(
-          "work_ref_not_found",
-          `open work file not found: ${ref.path}`,
-          ref.name
-        );
-      }
-      return;
-    }
-    throw asReadFailure(ref.path, ref.name, error);
-  }
-  if (!stats.isFile()) {
-    throw new WorkRefError(
-      "work_ref_not_file",
-      `open work path is not a regular file: ${ref.path}`,
-      ref.name
-    );
-  }
-}
-function resolveWorkRefPath(path, options = {}) {
-  const changesDir = options.changesDir ?? CHANGES_DIR;
-  const logicalPath = normalizeLogicalPath2(relative(changesDir, path));
-  if (isAbsolute(logicalPath) || logicalPath === ".." || logicalPath.startsWith("../") || !logicalPath.endsWith(".md")) {
-    throw new WorkRefError(
-      "invalid_work_ref_path",
-      `work path must be a Markdown file inside ${changesDir}: ${path}`,
-      path
-    );
-  }
-  const segments = logicalPath.split("/");
-  if (segments.length === 2 && segments[1] === "brief.md") {
-    throw new WorkRefError(
-      "invalid_work_ref_path",
-      `unsupported legacy Group Brief path: ${path}`,
-      path
-    );
-  }
-  const name = segments.length === 2 && segments[1] === GROUP_BRIEF_FILENAME ? `${segments[0]}/brief` : logicalPath.slice(0, -3);
-  return resolveWorkRef(name, { ...options, canonical: true });
-}
-function isExecutableWorkRef(ref) {
-  return ref.kind !== "group-brief";
-}
-function resolveFocusMarkerPath(ref, options = {}) {
-  const focusDir = options.focusDir ?? FOCUS_DIR;
-  assertManagedRoot(focusDir, ref.name, "invalid_focus_root", "focus root", true);
-  assertNoManagedNormalizationCollision(focusDir, ref.name.split("/"), ref.name, "invalid_focus_path");
-  if (ref.group) {
-    assertOptionalManagedDirectory(
-      join(focusDir, ref.group),
-      ref.name,
-      "invalid_focus_path",
-      "focus path"
-    );
-  }
-  const markerPath = join(focusDir, ...ref.name.split("/"));
-  try {
-    requireManagedFile(markerPath, "focus marker", { allowMissing: true });
-  } catch (error) {
-    if (error instanceof ManagedPathError)
-      throw new WorkRefError("invalid_focus_path", error.message, ref.name);
-    throw error;
-  }
-  return markerPath;
-}
-function resolveArchiveDirectory(ref, options = {}) {
-  const archivesDir = options.archivesDir ?? ARCHIVES_DIR;
-  assertManagedRoot(archivesDir, ref.name, "invalid_archive_root", "archive root", true);
-  if (!ref.group)
-    return archivesDir;
-  assertNoManagedNormalizationCollision(archivesDir, [ref.group], ref.name, "invalid_archive_path");
-  const groupPath = join(archivesDir, ref.group);
-  assertOptionalManagedDirectory(groupPath, ref.name, "invalid_archive_path", "archive path");
-  return groupPath;
-}
-async function inspectFocusTree(options = {}) {
-  const focusDir = options.focusDir ?? FOCUS_DIR;
-  const changesDir = options.changesDir ?? CHANGES_DIR;
-  const result = { markers: [], diagnostics: [] };
-  const rootInspection = inspectManagedDirectory(focusDir, "focus root", { allowMissing: true });
-  if (rootInspection.issue) {
-    addDiagnostic(result, new WorkRefError("invalid_focus_root", rootInspection.issue.message, focusDir), focusDir);
-    return result;
-  }
-  if (!rootInspection.exists)
-    return result;
-  const rootEntries = await readDirectory(focusDir, focusDir, result);
-  if (!rootEntries)
-    return result;
-  for (const entry of rootEntries) {
-    const path = join(focusDir, entry.name);
-    if (entry.name === ".gitkeep" && entry.isFile())
-      continue;
-    if (entry.isDirectory()) {
-      if (!isCanonicalWorkRefSegment(entry.name)) {
-        addDiagnostic(result, new WorkRefError(
-          "invalid_work_ref",
-          `stored work identity "${entry.name}" must be a safe Unicode NFC segment`,
-          entry.name
-        ), path);
-        continue;
-      }
-      await inspectFocusGroup(entry.name, path, changesDir, result);
-      continue;
-    }
-    if (!entry.isFile()) {
-      addDiagnostic(result, new WorkRefError(
-        "invalid_focus_path",
-        `focus path must be a regular marker file or real directory: ${path}`,
-        entry.name
-      ), path);
-      continue;
-    }
-    collectFocusMarker(entry.name, path, changesDir, result);
-  }
-  result.markers.sort((a, b) => a.name.localeCompare(b.name));
-  return result;
-}
-async function inspectArchiveTree(options = {}) {
-  const archivesDir = options.archivesDir ?? ARCHIVES_DIR;
-  const result = { rootExists: false, files: [], diagnostics: [] };
-  const rootInspection = inspectManagedDirectory(archivesDir, "archive root", { allowMissing: true });
-  if (rootInspection.issue) {
-    addDiagnostic(result, new WorkRefError("invalid_archive_root", rootInspection.issue.message, archivesDir), archivesDir);
-    return result;
-  }
-  if (!rootInspection.exists)
-    return result;
-  result.rootExists = true;
-  const rootEntries = await readDirectory(archivesDir, archivesDir, result);
-  if (!rootEntries)
-    return result;
-  for (const entry of rootEntries) {
-    const path = join(archivesDir, entry.name);
-    if (entry.name === "INDEX.md" && entry.isFile())
-      continue;
-    if (entry.isDirectory()) {
-      if (!isCanonicalWorkRefSegment(entry.name)) {
-        addArchivePathDiagnostic(result, entry.name, path);
-        continue;
-      }
-      await inspectArchiveGroup(entry.name, path, result);
-      continue;
-    }
-    if (!entry.isFile() || !entry.name.endsWith(".md")) {
-      addArchivePathDiagnostic(result, entry.name, path);
-      continue;
-    }
-    result.files.push(path);
-  }
-  result.files.sort();
-  return result;
-}
-async function inspectWorkTree(options = {}) {
-  const changesDir = options.changesDir ?? CHANGES_DIR;
-  const result = { changes: [], briefs: [], diagnostics: [] };
-  try {
-    assertValidWorkRoot(changesDir, changesDir);
-  } catch (error) {
-    if (!(error instanceof WorkRefError))
-      throw error;
-    addDiagnostic(result, error, changesDir);
-    return result;
-  }
-  const rootEntries = await readDirectory(changesDir, changesDir, result);
-  if (!rootEntries)
-    return result;
-  const rootDirectories = new Set(rootEntries.filter((entry) => entry.isDirectory()).map((entry) => entry.name));
-  const rootMarkdownNames = new Set(rootEntries.filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => entry.name.slice(0, -3)));
-  const collidingGroups = new Set([...rootDirectories].filter((name) => rootMarkdownNames.has(name)));
-  for (const entry of rootEntries) {
-    const path = join(changesDir, entry.name);
-    if (entry.name === ".gitkeep" && entry.isFile())
-      continue;
-    if (entry.isDirectory()) {
-      if (!isCanonicalWorkRefSegment(entry.name)) {
-        addDiagnostic(result, new WorkRefError(
-          "invalid_work_ref",
-          `stored work identity "${entry.name}" must be a safe Unicode NFC segment`,
-          entry.name
-        ), path);
-        continue;
-      }
-      const colliding = collidingGroups.has(entry.name);
-      if (colliding) {
-        addDiagnostic(result, new WorkRefError(
-          "work_ref_collision",
-          `work identity "${entry.name}" is claimed by both a file and a directory`,
-          entry.name
-        ), path);
-      }
-      await inspectGroupDirectory(entry.name, path, changesDir, result, colliding);
-      continue;
-    }
-    if (!entry.isFile() || !entry.name.endsWith(".md")) {
-      addInvalidEntryDiagnostic(result, entry.name, path);
-      continue;
-    }
-    const name = entry.name.slice(0, -3);
-    if (collidingGroups.has(name)) {
-      continue;
-    }
-    collectResolvedPath(path, changesDir, result);
-  }
-  result.changes.sort((a, b) => a.name.localeCompare(b.name));
-  result.briefs.sort((a, b) => a.name.localeCompare(b.name));
-  return result;
-}
-async function inspectGroupDirectory(group, groupPath, changesDir, result, colliding) {
-  const entries = await readDirectory(groupPath, group, result);
-  if (!entries)
-    return;
-  const briefEntry = entries.find((entry) => entry.name === GROUP_BRIEF_FILENAME);
-  if (!briefEntry) {
-    addDiagnostic(result, new WorkRefError(
-      "group_brief_missing",
-      `Change Group "${group}" requires a Group Brief; run: rsp group create ${group}`,
-      group
-    ), join(groupPath, GROUP_BRIEF_FILENAME));
-  } else if (!briefEntry.isFile()) {
-    addDiagnostic(result, new WorkRefError(
-      "work_ref_not_file",
-      `Group Brief must be a regular file: ${join(groupPath, GROUP_BRIEF_FILENAME)}`,
-      group
-    ), join(groupPath, GROUP_BRIEF_FILENAME));
-  }
-  for (const entry of entries) {
-    const input = `${group}/${entry.name}`;
-    const path = join(groupPath, entry.name);
-    if (entry.name === GROUP_BRIEF_FILENAME && !entry.isFile())
-      continue;
-    if (entry.name === "brief.md") {
-      addInvalidEntryDiagnostic(result, input, path);
-      continue;
-    }
-    if (entry.isDirectory()) {
-      addDiagnostic(result, new WorkRefError(
-        "unsupported_work_depth",
-        `work identity "${input}" exceeds the supported one-level Change Group depth`,
-        input
-      ), path);
-      continue;
-    }
-    if (!entry.isFile() || !entry.name.endsWith(".md")) {
-      addInvalidEntryDiagnostic(result, input, path);
-      continue;
-    }
-    if (!colliding)
-      collectResolvedPath(path, changesDir, result);
-  }
-}
-async function inspectFocusGroup(group, groupPath, changesDir, result) {
-  const entries = await readDirectory(groupPath, group, result);
-  if (!entries)
-    return;
-  for (const entry of entries) {
-    const input = `${group}/${entry.name}`;
-    const path = join(groupPath, entry.name);
-    if (entry.isDirectory()) {
-      addDiagnostic(result, new WorkRefError(
-        "unsupported_work_depth",
-        `work identity "${input}" exceeds the supported one-level Change Group depth`,
-        input
-      ), path);
-      continue;
-    }
-    if (!entry.isFile()) {
-      addDiagnostic(result, new WorkRefError(
-        "invalid_focus_path",
-        `focus path must be a regular marker file: ${path}`,
-        input
-      ), path);
-      continue;
-    }
-    collectFocusMarker(input, path, changesDir, result);
-  }
-}
-async function inspectArchiveGroup(group, groupPath, result) {
-  const entries = await readDirectory(groupPath, group, result);
-  if (!entries)
-    return;
-  for (const entry of entries) {
-    const input = `${group}/${entry.name}`;
-    const path = join(groupPath, entry.name);
-    if (!entry.isFile() || !entry.name.endsWith(".md")) {
-      addArchivePathDiagnostic(result, input, path);
-      continue;
-    }
-    result.files.push(path);
-  }
-}
-function collectFocusMarker(input, path, changesDir, result) {
-  try {
-    const ref = resolveWorkRef(input, { changesDir, canonical: true, executable: true });
-    result.markers.push({ name: ref.name, path });
-  } catch (error) {
-    if (!(error instanceof WorkRefError))
-      throw error;
-    addDiagnostic(result, error, path);
-  }
-}
-function collectResolvedPath(path, changesDir, result) {
-  try {
-    const ref = resolveWorkRefPath(path, { changesDir });
-    if (isExecutableWorkRef(ref))
-      result.changes.push(ref);
-    else
-      result.briefs.push(ref);
-  } catch (error) {
-    if (!(error instanceof WorkRefError))
-      throw error;
-    addDiagnostic(result, error, path);
-  }
-}
-async function readDirectory(path, input, result) {
-  try {
-    return (await readdir(path, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
-  } catch (error) {
-    addDiagnostic(result, asReadFailure(path, input, error), path);
-    return null;
-  }
-}
-function addInvalidEntryDiagnostic(result, input, path) {
-  addDiagnostic(result, new WorkRefError(
-    "invalid_work_ref_path",
-    `unsupported entry in the open-work tree: ${path}`,
-    input
-  ), path);
-}
-function addArchivePathDiagnostic(result, input, path) {
-  addDiagnostic(result, new WorkRefError(
-    "invalid_archive_path",
-    `unsupported entry in the archive tree: ${path}`,
-    input
-  ), path);
-}
-function addDiagnostic(result, error, path) {
-  if (result.diagnostics.some((item) => item.code === error.code && item.input === error.input))
-    return;
-  result.diagnostics.push({ code: error.code, input: error.input, path, message: error.message });
-}
-function normalizeWorkRefName(name, allowGroupBrief) {
-  const segments = name.split("/");
-  if (segments.length > 2) {
-    throw new WorkRefError(
-      "unsupported_work_depth",
-      `work identity "${name}" exceeds the supported one-level Change Group depth`,
-      name
-    );
-  }
-  if (!name || segments.some((segment) => !segment)) {
-    throw new WorkRefError(
-      "invalid_work_ref",
-      `work identity "${name}" must contain one or two safe Unicode segments`,
-      name
-    );
-  }
-  const normalizedSegments = segments.map(normalizeWorkRefSegment);
-  const child = normalizedSegments[1];
-  if (segments.length === 2 && child === GROUP_BRIEF_FILENAME.slice(0, -3)) {
-    throw new WorkRefError(
-      "invalid_work_ref",
-      `work identity "${name}" uses the reserved Group Brief filename`,
-      name
-    );
-  }
-  if (segments.length === 2 && child === "brief" && !allowGroupBrief) {
-    throw new WorkRefError(
-      "non_executable_work_ref",
-      `work identity "${name}" is a Group Brief and cannot be used as an executable Change`,
-      name
-    );
-  }
-  return normalizedSegments.join("/");
-}
-function assertNoNormalizationCollision(changesDir, segments, input, isGroupBrief) {
-  for (let depth = 0; depth < segments.length; depth++) {
-    const parent = 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));
-    const filePath = finalFilename && depth === segments.length ? join(changesDir, ...segments.slice(0, -1), finalFilename) : `${identityPath}.md`;
-    const fileKind = getPathKind(filePath, input);
-    const identityKind = getPathKind(identityPath, input);
-    const isPrefix = depth < segments.length;
-    const isFlatIdentity = segments.length === 1;
-    const identity = segments.slice(0, depth).join("/");
-    if (fileKind !== "missing" && fileKind !== "file") {
-      throw new WorkRefError(
-        "work_ref_not_file",
-        `open work path is not a regular file: ${filePath}`,
-        input
-      );
-    }
-    if (fileKind === "file" && identityKind === "directory" || isPrefix && fileKind === "file" || isFlatIdentity && identityKind === "directory") {
-      throw new WorkRefError(
-        "work_ref_collision",
-        `work identity "${identity}" is or would be claimed by both a file and a directory`,
-        input
-      );
-    }
-    if (isPrefix && identityKind !== "missing" && identityKind !== "directory") {
-      throw new WorkRefError(
-        "invalid_work_ref_path",
-        `open work path must be a real directory: ${identityPath}`,
-        input
-      );
-    }
-    if (!isPrefix && !isFlatIdentity && identityKind === "directory") {
-      throw new WorkRefError(
-        "unsupported_work_depth",
-        `work identity "${identity}" exceeds the supported one-level Change Group depth`,
-        input
-      );
-    }
-    if (!isPrefix && identityKind !== "missing" && identityKind !== "directory") {
-      throw new WorkRefError(
-        "invalid_work_ref_path",
-        `unsupported entry in the open-work tree: ${identityPath}`,
-        input
-      );
-    }
-  }
-}
-function assertValidWorkRoot(changesDir, input) {
-  assertManagedRoot(changesDir, input, "invalid_work_root", "open work root");
-}
-function assertManagedRoot(path, input, code, label, allowMissing = false) {
-  try {
-    requireManagedDirectory(path, label, { allowMissing });
-  } catch (error) {
-    if (error instanceof ManagedPathError)
-      throw new WorkRefError(code, error.message, input);
-    throw error;
-  }
-}
-function assertOptionalManagedDirectory(path, input, code, label) {
-  try {
-    requireManagedDirectory(path, label, { allowMissing: true });
-  } catch (error) {
-    if (error instanceof ManagedPathError)
-      throw new WorkRefError(code, error.message, input);
-    throw error;
-  }
-}
-function getPathKind(path, input) {
-  try {
-    const stats = lstatSync(path);
-    if (stats.isFile())
-      return "file";
-    if (stats.isDirectory())
-      return "directory";
-    return "other";
-  } catch (error) {
-    if (error.code === "ENOENT")
-      return "missing";
-    throw asReadFailure(path, input, error);
-  }
-}
-function asReadFailure(path, input, error) {
-  const message = error instanceof Error ? error.message : String(error);
-  return new WorkRefError(
-    "work_tree_read_failed",
-    `unable to inspect open work path ${path}: ${message}`,
-    input
-  );
-}
-function normalizeLogicalPath2(path) {
-  return path.split("\\").join("/");
-}
-
-// src/core/work-summary.ts
-var PLACEHOLDER_SUMMARY = "<\u2026>";
-function extractChangeSummary(content, document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA), options = {}) {
-  try {
-    const frontmatter = parseFrontmatter(content);
-    const frontmatterSummary = meaningfulSummary(frontmatter?.summary, options);
-    if (frontmatterSummary)
-      return frontmatterSummary;
-  } catch {
-  }
-  const proposalLines = getDocumentSectionBody(document, "proposal").split("\n").map((line) => line.trim());
-  for (const field of ["Outcome", "Summary"]) {
-    const prefix = `- ${field}:`;
-    for (const line of proposalLines) {
-      const summary = line.startsWith(prefix) ? meaningfulSummary(line.slice(prefix.length), options) : null;
-      if (summary)
-        return summary;
-    }
-  }
-  return null;
-}
-function extractGroupSummary(content, document = parseRspDocument(content, GROUP_BRIEF_DOCUMENT_SCHEMA)) {
-  for (const line of getDocumentSectionBody(document, "goal").split("\n")) {
-    const trimmed = line.trim();
-    const summary = trimmed.startsWith("- ") || trimmed.startsWith("* ") ? meaningfulSummary(trimmed.slice(2)) : null;
-    if (summary)
-      return summary;
-  }
-  return null;
-}
-function meaningfulSummary(value, options = {}) {
-  if (typeof value !== "string")
-    return null;
-  const summary = value.trim();
-  return summary && (options.preservePlaceholder || summary !== PLACEHOLDER_SUMMARY) ? summary : null;
-}
-
-// src/core/change-group.ts
-var GROUP_BRIEF_SECTIONS = getCanonicalSectionHeadings(GROUP_BRIEF_DOCUMENT_SCHEMA);
-var GROUP_REOPEN_COMPLETION_PREFIX = "Resolve reopened concern from";
-async function resolveExecutableChange(name, options = {}) {
-  const ref = resolveWorkRef(name, { ...options, executable: true });
-  if (ref.kind === "group-change")
-    await requireDeclaredGroupSlice(ref);
-  return ref;
-}
-function generateGroupBriefContent(name, goal = "") {
-  const placeholder = "<\u2026>";
-  return `---
-kind: group
----
-
-${renderDocumentTitle(GROUP_BRIEF_DOCUMENT_SCHEMA, name)}
-
-${groupSectionHeading("goal")}
-- ${goal || placeholder}
-
-${groupSectionHeading("scope")}
-- ${placeholder}
-
-${groupSectionHeading("sharedConstraints")}
-- ${placeholder}
-
-${groupSectionHeading("slices")}
-- \`${name}/<change>\`: ${placeholder}
-
-${groupSectionHeading("completionConditions")}
-- [ ] ${placeholder}
-
-${groupSectionHeading("durableOutcomes")}
-- Current facts: ${placeholder}
-- Lasting rationale: ${placeholder}
-
-${groupSectionHeading("blockers")}
-- none
-`;
-}
-async function inspectChangeGroups(options = {}) {
-  const workTree = options.workTree ?? await inspectWorkTree();
-  const archiveTree = options.archiveTree ?? await inspectArchiveTree();
-  const focusTree = options.focusTree ?? await inspectFocusTree();
-  const diagnostics = [];
-  const groups = [];
-  const archivedSlicesByGroup = /* @__PURE__ */ new Map();
-  const archivedGroups = /* @__PURE__ */ new Set();
-  const archivedGroupReopenEvidence = /* @__PURE__ */ new Map();
-  const archivedGroupBriefPaths = /* @__PURE__ */ new Map();
-  const openGroupNames = new Set(workTree.briefs.map((brief) => brief.group));
-  for (const path of archiveTree.files) {
-    const archivePath = normalizeLogicalPath(relative2(ARCHIVES_DIR, path));
-    const archiveGroup = archivePath.includes("/") ? archivePath.split("/")[0] : null;
-    if (!archiveGroup || !openGroupNames.has(archiveGroup))
-      continue;
-    try {
-      const content = await readFile(path, "utf-8");
-      const archivedChange = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
-      const identity = getDocumentTitle(archivedChange, "identity");
-      if (identity?.includes("/")) {
-        if (!isCanonicalExecutableWorkRef(identity) || !identity.startsWith(`${archiveGroup}/`)) {
-          diagnostics.push({
-            severity: "error",
-            code: "group_archive_identity_mismatch",
-            change: archiveGroup,
-            path,
-            message: `archived Change identity ${identity} does not belong to archive group ${archiveGroup}`
-          });
-        } else {
-          const groupSlices = archivedSlicesByGroup.get(archiveGroup) ?? /* @__PURE__ */ new Set();
-          groupSlices.add(identity);
-          archivedSlicesByGroup.set(archiveGroup, groupSlices);
-        }
-      }
-      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",
-        code: "group_archive_read_failed",
-        change: archiveGroup,
-        path,
-        message: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  for (const brief of workTree.briefs) {
-    let content;
-    try {
-      content = await readFile(brief.path, "utf-8");
-    } catch (error) {
-      diagnostics.push({
-        severity: "error",
-        code: "group_brief_read_failed",
-        change: brief.group,
-        path: brief.path,
-        message: error instanceof Error ? error.message : String(error)
-      });
-      continue;
-    }
-    const parsed = parseGroupBrief(brief.group, content);
-    diagnostics.push(...parsed.diagnostics.map((diagnostic) => ({ ...diagnostic, path: brief.path })));
-    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",
-        change: brief.group,
-        path: brief.path,
-        message: `archived Change Group cannot be reopened: ${brief.group}`
-      });
-    }
-    for (const diagnostic of archiveTree.diagnostics.filter((item) => {
-      if (item.code === "invalid_archive_root")
-        return true;
-      const archivePath = normalizeLogicalPath(relative2(ARCHIVES_DIR, item.path));
-      return archivePath === brief.group || archivePath.startsWith(`${brief.group}/`);
-    })) {
-      diagnostics.push({
-        severity: "error",
-        code: diagnostic.code,
-        change: brief.group,
-        path: diagnostic.path,
-        message: diagnostic.message
-      });
-    }
-    for (const diagnostic of focusTree.diagnostics.filter((item) => item.input.startsWith(`${brief.group}/`))) {
-      diagnostics.push({
-        severity: "error",
-        code: "group_focus_invalid",
-        change: brief.group,
-        path: diagnostic.path,
-        message: `invalid focus for ${diagnostic.input}: ${diagnostic.message}`
-      });
-    }
-    const openChildren = new Set(workTree.changes.filter((ref) => ref.group === brief.group).map((ref) => ref.name));
-    const archivedSlices = archivedSlicesByGroup.get(brief.group) ?? /* @__PURE__ */ new Set();
-    const slices = parsed.slices.map((slice) => {
-      const state = openChildren.has(slice.name) ? "open" : archivedSlices.has(slice.name) ? "archived" : "missing";
-      return { ...slice, state };
-    });
-    const focusedNames = new Set(focusTree.markers.map((marker) => marker.name));
-    for (const slice of slices.filter((slice2) => slice2.state !== "open" && focusedNames.has(slice2.name))) {
-      diagnostics.push({
-        severity: "error",
-        code: "group_focus_invalid",
-        change: brief.group,
-        path: focusTree.markers.find((marker) => marker.name === slice.name)?.path,
-        message: `invalid focus for ${slice.name}: focused group slice is not open`
-      });
-    }
-    const declared = new Set(slices.map((slice) => slice.name));
-    for (const child of [...openChildren].filter((name) => !declared.has(name)).sort()) {
-      diagnostics.push({
-        severity: "error",
-        code: "group_child_undeclared",
-        change: brief.group,
-        path: brief.path,
-        message: `open child Change is not declared by the Group Brief: ${child}`
-      });
-    }
-    for (const child of [...archivedSlices].filter((name) => !declared.has(name)).sort()) {
-      diagnostics.push({
-        severity: "error",
-        code: "group_archived_child_undeclared",
-        change: brief.group,
-        path: brief.path,
-        message: `archived child Change is not declared by the Group Brief: ${child}`
-      });
-    }
-    for (const slice of slices.filter((slice2) => slice2.state === "missing")) {
-      diagnostics.push({
-        severity: "error",
-        code: "group_slice_missing",
-        change: brief.group,
-        path: brief.path,
-        message: `declared group slice is neither open nor archived: ${slice.name}`
-      });
-    }
-    const warnings = parsed.diagnostics.filter((diagnostic) => diagnostic.severity === "warning").map((diagnostic) => diagnostic.message);
-    const readyToClose = diagnostics.every((diagnostic) => diagnostic.change !== brief.group || diagnostic.severity !== "error") && slices.length >= 2 && slices.every((slice) => slice.state === "archived") && parsed.completion.total > 0 && parsed.completion.done === parsed.completion.total && !parsed.blockers;
-    groups.push({
-      name: brief.group,
-      summary: extractGroupSummary(content),
-      path: normalizeLogicalPath(brief.path),
-      slices,
-      completion: parsed.completion,
-      blockers: parsed.blockers,
-      readyToClose,
-      warnings
-    });
-  }
-  groups.sort((left, right) => left.name.localeCompare(right.name));
-  return { groups, diagnostics };
-}
-function getGroupReopenEvidence(content) {
-  const 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;
-  try {
-    content = await readFile(briefPath, "utf-8");
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new WorkRefError("work_tree_read_failed", `unable to read Group Brief ${briefPath}: ${message}`, ref.name);
-  }
-  const parsed = parseGroupBrief(ref.group, content);
-  const errors = parsed.diagnostics.filter((diagnostic) => diagnostic.severity === "error");
-  if (errors.length > 0) {
-    throw new WorkRefError(
-      "invalid_group_brief",
-      `Change Group "${ref.group}" brief is invalid: ${errors.map((error) => error.message).join("; ")}`,
-      ref.name
-    );
-  }
-  if (!parsed.slices.some((slice) => slice.name === ref.name)) {
-    throw new WorkRefError(
-      "group_child_undeclared",
-      `grouped Change is not declared by ${ref.group}/brief: ${ref.name}`,
-      ref.name
-    );
-  }
-}
-async function hasArchivedGroupBrief(group) {
-  const archiveTree = await inspectArchiveTree();
-  if (archiveTree.diagnostics.length > 0) {
-    const diagnostic = archiveTree.diagnostics[0];
-    throw new WorkRefError(diagnostic.code, diagnostic.message, diagnostic.input);
-  }
-  const groupPrefix = `${group}/`;
-  for (const path of archiveTree.files) {
-    if (!normalizeLogicalPath(relative2(ARCHIVES_DIR, path)).startsWith(groupPrefix))
-      continue;
-    let content;
-    try {
-      content = await readFile(path, "utf-8");
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      throw new WorkRefError("work_tree_read_failed", `unable to inspect archived Change Group identity at ${path}: ${message}`, group);
-    }
-    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);
-  } catch (error) {
-    diagnostics.push({ severity: "error", code: "group_frontmatter_invalid", change: group, message: error instanceof Error ? error.message : String(error) });
-  }
-  if (frontmatter?.kind !== "group")
-    diagnostics.push({ severity: "error", code: "group_kind_invalid", change: group, message: "Group Brief frontmatter must declare kind: group" });
-  if (getDocumentTitle(document, "identity") !== group)
-    diagnostics.push({ severity: "error", code: "group_heading_mismatch", change: group, message: `Group Brief heading must be: # Change Group: ${group}` });
-  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 getDocumentSectionBody(document, "slices").split("\n")) {
-    const trimmed = line.trim();
-    const identity = trimmed.match(/^-\s+`(\S+)`/);
-    if (!identity || identity[1].includes("<"))
-      continue;
-    const suffix = trimmed.slice(identity[0].length).trim();
-    if (![":", "\u2014", "-"].includes(suffix[0])) {
-      diagnostics.push({ severity: "error", code: "group_slice_invalid", change: group, message: `group slice requires an identity and boundary: ${trimmed}` });
-      continue;
-    }
-    const name = identity[1];
-    const boundary = suffix.slice(1).trim();
-    if (!boundary) {
-      diagnostics.push({ severity: "error", code: "group_slice_invalid", change: group, message: `group slice requires a boundary: ${name}` });
-      continue;
-    }
-    if (!isCanonicalExecutableWorkRef(name) || !name.startsWith(`${group}/`)) {
-      diagnostics.push({ severity: "error", code: "group_slice_invalid", change: group, message: `invalid direct child identity in Group Brief: ${name}` });
-      continue;
-    }
-    if (seen.has(name)) {
-      diagnostics.push({ severity: "error", code: "group_slice_duplicate", change: group, message: `duplicate group slice: ${name}` });
-      continue;
-    }
-    seen.add(name);
-    slices.push({ name, boundary: boundary.trim() });
-  }
-  if (slices.length < 2)
-    diagnostics.push({ severity: "warning", code: "group_slices_incomplete", change: group, message: "Change Group must declare at least two direct child slices" });
-  const completion = countCheckboxes(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: hasMeaningfulBlockerBody(getDocumentSectionBody(document, "blockers")),
-    diagnostics
-  };
-}
-function groupSectionHeading(sectionId) {
-  return renderDocumentSectionHeading(GROUP_BRIEF_DOCUMENT_SCHEMA, sectionId);
-}
-
-// src/core/dependency-plan.ts
-import { readFile as readFile4 } from "fs/promises";
-
-// src/history/query.ts
-import { readFile as readFile3 } from "fs/promises";
-
-// src/history/inspect.ts
-import { readFile as readFile2 } from "fs/promises";
-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: normalizeOutputPath(diagnostic.path, archivesDir),
-    message: diagnostic.message
-  }));
-  const runtime = [];
-  const records = [];
-  const groupBriefs = [];
-  if (!tree.rootExists && tree.diagnostics.length === 0) {
-    diagnostics.push({
-      severity: "error",
-      code: "archive_root_missing",
-      path: ".rsp/archives",
-      message: "archive root does not exist; run rsp init or rsp update before querying history"
-    });
-  }
-  for (const sourcePath of tree.files) {
-    const path = archiveOutputPath(sourcePath, archivesDir);
-    let content;
-    try {
-      content = await readFile2(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);
-    if (parsed.groupBrief)
-      groupBriefs.push(parsed.groupBrief);
-  }
-  records.sort(compareHistoryRecords);
-  groupBriefs.sort(compareArchivedGroupBriefs);
-  diagnostics.sort(compareDiagnostics);
-  const diagnosticTotal = diagnostics.length;
-  const boundedDiagnostics = diagnostics.slice(0, HISTORY_MAX_DIAGNOSTICS);
-  return {
-    rootExists: tree.rootExists,
-    records,
-    groupBriefs,
-    diagnostics: boundedDiagnostics,
-    diagnosticSummary: {
-      total: diagnosticTotal,
-      returned: boundedDiagnostics.length,
-      hasMore: diagnosticTotal > boundedDiagnostics.length
-    },
-    runtime
-  };
-}
-function parseArchiveEntry(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 } };
-  }
-  let issues;
-  if ("issues" in frontmatter) {
-    try {
-      issues = parseIssueRelationships(frontmatter);
-    } catch {
-      issues = void 0;
-    }
-  }
-  const workRef = changeHeadings[0];
-  const segments = workRef.split("/");
-  if (segments.length === 2 && (segments[1] === "brief" || segments[1] === "00-brief")) {
-    return { diagnostic: errorDiagnostic("archive_work_ref_invalid", path, `archived executable Change uses reserved Group Brief identity: ${workRef}`) };
-  }
-  const expectedGroup = segments.length === 2 ? segments[0] : null;
-  const expectedBase = segments.at(-1);
-  if (!isCanonicalExecutableWorkRef(workRef) || expectedGroup !== archiveGroup || !matchesArchiveStem(archiveStem, expectedBase)) {
-    return { diagnostic: errorDiagnostic("archive_identity_mismatch", path, `archived Change identity ${workRef} does not match its archive path`) };
-  }
-  const rawSummary = extractChangeSummary(content, changeDocument, { preservePlaceholder: true });
-  if (!rawSummary)
-    return { diagnostic: errorDiagnostic("archive_summary_missing", path, "archived Change must contain frontmatter summary, Proposal Outcome, or Proposal Summary") };
-  const summary = boundText(rawSummary);
-  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 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}`
-        });
-      } 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",
-        code: "invalid_config",
-        path: CONFIG_PATH,
-        message: configInspection.issues.join("; ")
-      });
-    }
-  } catch (error) {
-    manage = resolveManagePolicy({}, { configValid: false });
-    language = resolveLanguagePolicy({}, { configValid: false });
-    diagnostics.push({
-      severity: "error",
-      code: "invalid_config",
-      path: CONFIG_PATH,
-      message: toErrorMessage(error)
-    });
-  }
-  const focusTree = await inspectFocusTree();
-  for (const diagnostic of focusTree.diagnostics) {
-    diagnostics.push({
-      severity: "error",
-      code: diagnostic.code,
-      change: diagnostic.input,
-      path: diagnostic.path,
-      message: diagnostic.message
-    });
-  }
-  const rawFocusedSet = new Set(focusTree.markers.map((marker) => marker.name));
-  const focusedSet = /* @__PURE__ */ new Set();
-  const focusedPaths = /* @__PURE__ */ new Map();
-  for (const name of rawFocusedSet) {
-    try {
-      const ref = resolveWorkRef(name, { executable: true });
-      focusedSet.add(ref.name);
-      focusedPaths.set(ref.name, ref.path);
-    } catch (error) {
-      if (!(error instanceof WorkRefError))
-        throw error;
-      diagnostics.push({
-        severity: "error",
-        code: error.code,
-        path: `.rsp/focus.d/${name}`,
-        change: name,
-        message: error.message
-      });
-    }
-  }
-  const workTree = await inspectWorkTree();
-  const archiveTree = await inspectArchiveTree();
-  const historyInspection = await inspectArchiveHistory({ archiveTree });
-  diagnostics.push(...workTree.diagnostics.map((diagnostic) => ({
-    severity: "error",
-    code: diagnostic.code,
-    change: diagnostic.input,
-    path: diagnostic.path,
-    message: diagnostic.message
-  })));
-  const groupInspection = await inspectChangeGroups({ workTree, focusTree, archiveTree });
-  diagnostics.push(...groupInspection.diagnostics);
-  const dependencyInspection = await inspectChangeDependencies({
-    workTree,
-    archiveTree,
-    archiveHistory: historyInspection,
-    preferredOrder: groupInspection.groups.flatMap((group) => group.slices.map((slice) => slice.name))
-  });
-  diagnostics.push(...dependencyInspection.diagnostics);
-  const changeMap = new Map(workTree.changes.map((ref) => [ref.name, ref.path]));
-  const allNames = [.../* @__PURE__ */ new Set([...changeMap.keys(), ...focusedSet])].sort();
-  const records = [];
-  const nowMs = options.nowMs ?? Date.now();
-  for (const name of allNames) {
-    const path = changeMap.get(name);
-    let kind = "\u2014";
-    let summary = null;
-    let title = name;
-    let blockerEntries = [];
-    let readiness = emptyReadiness(false);
-    let ageDays = null;
-    const isFocused = focusedSet.has(name);
-    let isBlocked = false;
-    let done = 0;
-    let total = 0;
-    let progressKnown = false;
-    let issues = [];
-    if (path) {
-      try {
-        const content = await readFile5(path, "utf-8");
-        title = extractChangeTitle(content) ?? name;
-        summary = extractChangeSummary(content);
-        blockerEntries = extractBlockerEntries(content);
-        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: issueError ? error.code : "frontmatter_parse_failed",
-            operation: "parseFrontmatter",
-            path,
-            message: toErrorMessage(error)
-          });
-        }
-        isBlocked = dependencyInspection.activeBlockers.get(name) ?? hasMeaningfulBlockers(content);
-        const checkboxes = countCheckboxes(content);
-        done = checkboxes.done;
-        total = checkboxes.total;
-        progressKnown = true;
-        const details = collectArchiveReadiness(content, { activeBlockers: isBlocked });
-        readiness = {
-          incompleteTasks: details.taskTodos.length,
-          incompleteVerify: details.verifyTodos.length,
-          activeBlockers: details.activeBlockers,
-          missingScenarios: details.missingScenarios,
-          deterministic: details.deterministic,
-          semantic: details.semantic,
-          archiveReady: details.archiveReady
-        };
-      } catch (error) {
-        diagnostics.push({
-          severity: "error",
-          code: "change_read_failed",
-          change: name,
-          path,
-          message: "unable to read open Change",
-          hint: toErrorMessage(error)
-        });
-        runtime.push({
-          code: "change_read_failed",
-          operation: "readFile",
-          path,
-          message: toErrorMessage(error)
-        });
-      }
-      try {
-        const metadata = await stat(path);
-        ageDays = Math.floor((nowMs - metadata.mtime.getTime()) / (1e3 * 60 * 60 * 24));
-      } catch (error) {
-        diagnostics.push({
-          severity: "error",
-          code: "change_stat_failed",
-          change: name,
-          path,
-          message: "unable to inspect open Change metadata",
-          hint: toErrorMessage(error)
-        });
-        runtime.push({
-          code: "change_stat_failed",
-          operation: "stat",
-          path,
-          message: toErrorMessage(error)
-        });
-      }
-    } else {
-      kind = "(missing)";
-      const path2 = focusedPaths.get(name);
-      diagnostics.push({
-        severity: "error",
-        code: "focused_change_missing",
-        change: name,
-        path: path2,
-        message: "focus marker points to a missing Change file"
-      });
-      runtime.push({
-        code: "focused_change_missing",
-        operation: "resolveChange",
-        path: path2,
-        message: "focus marker points to a missing change file"
-      });
-    }
-    records.push({
-      output: {
-        name,
-        summary,
-        kind,
-        progress: { done, total },
-        ageDays,
-        isFocused,
-        isBlocked,
-        path: path ? normalizeLogicalPath(path) : null,
-        issues
-      },
-      progressKnown,
-      title,
-      blockerEntries,
-      readiness
-    });
-  }
-  return {
-    manage,
-    language,
-    focused: [...focusedSet].sort(),
-    records,
-    groups: groupInspection.groups,
-    plan: dependencyInspection.plan,
-    archiveTrend: historyInspectionComplete(historyInspection) ? deriveArchiveTrend(historyInspection.records) : [],
-    diagnostics: [...diagnostics, ...historyInspection.rootExists ? historyInspection.diagnostics : []],
-    runtime: [...runtime, ...historyInspection.runtime]
-  };
-}
-function emptyReadiness(activeBlockers) {
-  return {
-    incompleteTasks: 0,
-    incompleteVerify: 0,
-    activeBlockers,
-    missingScenarios: false,
-    deterministic: "pass",
-    semantic: "needs-review",
-    archiveReady: activeBlockers ? "no" : "judgment"
-  };
-}
-function extractChangeTitle(content) {
-  return getDocumentTitle(parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA), "spaced");
-}
-function extractBlockerEntries(content) {
-  const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
-  return getDocumentSectionBody(document, "blockers").split("\n").map((line) => line.trim()).filter((line) => /^[-*]\s+/.test(line)).map((line) => line.replace(/^[-*]\s+/, "").trim()).filter((line) => line.toLowerCase() !== "none");
-}
-function deriveArchiveTrend(records) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const record of records) {
-    const month = record.date.slice(0, 7);
-    counts.set(month, (counts.get(month) ?? 0) + 1);
-  }
-  return [...counts].sort(([left], [right]) => left.localeCompare(right)).map(([month, count]) => ({ month, count }));
-}
-
-// src/status/dependency-forest.ts
-function defaultRoots(plan) {
-  const selected = new Set(plan.nodes.filter((node) => node.selection === "selected").map((node) => node.name));
-  const nested = new Set(plan.edges.filter((edge) => selected.has(edge.change) && selected.has(edge.requires)).map((edge) => edge.requires));
-  const roots = [...selected].filter((name) => !nested.has(name)).sort();
-  return roots.length > 0 ? roots : [...selected].sort();
-}
-function projectDependencyForest(plan, requestedRoots = defaultRoots(plan)) {
-  const nodes = new Map(plan.nodes.map((node) => [node.name, node]));
-  const edges = /* @__PURE__ */ new Map();
-  for (const edge of plan.edges) {
-    const children = edges.get(edge.change) ?? [];
-    children.push(edge);
-    edges.set(edge.change, children);
-  }
-  for (const children of edges.values())
-    children.sort((left, right) => left.requires.localeCompare(right.requires));
-  const expanded = /* @__PURE__ */ new Set();
-  const visit = (name, edge) => {
-    const node = nodes.get(name);
-    if (!node)
-      return null;
-    const shared = expanded.has(name);
-    if (!shared)
-      expanded.add(name);
-    return {
-      ...node,
-      ...edge ? { reason: edge.reason, edgeState: edge.state } : {},
-      shared,
-      children: shared ? [] : (edges.get(name) ?? []).map((child) => visit(child.requires, child)).filter((child) => child !== null)
-    };
-  };
-  return requestedRoots.map((name) => visit(name)).filter((node) => node !== null);
-}
-
-export {
-  GROUP_BRIEF_FILENAME,
-  WorkRefError,
-  normalizeWorkRefSegment,
-  normalizeExecutableWorkRef,
-  resolveWorkRef,
-  resolveFocusMarkerPath,
-  resolveArchiveDirectory,
-  inspectFocusTree,
-  inspectArchiveTree,
-  inspectWorkTree,
-  GROUP_REOPEN_COMPLETION_PREFIX,
-  resolveExecutableChange,
-  generateGroupBriefContent,
-  inspectChangeGroups,
-  getGroupReopenEvidence,
-  hasArchivedGroupBrief,
-  IssueRelationshipError,
-  parseIssueRelationships,
-  createIssueRelationship,
-  HISTORY_DEFAULT_LIMIT,
-  HISTORY_MAX_LIMIT,
-  ArchiveHistoryError,
-  inspectArchiveHistory,
-  queryArchiveHistory,
-  selectArchiveHistoryRecord,
-  selectArchivedGroupBrief,
-  readArchiveHistoryDetail,
-  historyInspectionComplete,
-  inspectChangeDependencies,
-  inspectProjectStatus,
-  projectDependencyForest
-};