@oevery/rsp 2.0.4 → 3.1.0-beta.0

package/dist/chunk-QLXIDVKK.mjs

@@ -0,0 +1,2618 @@
+#!/usr/bin/env node
+
+// src/core/config.ts
+import { readFile as readFile2 } from "fs/promises";
+import { dirname as dirname3, join as join4 } from "path";
+import { fileURLToPath } from "url";
+import pc from "picocolors";
+
+// src/core/decisions.ts
+import { existsSync } from "fs";
+import { mkdir, readdir as readdir2, realpath, stat } from "fs/promises";
+import { dirname, isAbsolute, join as join2, posix, relative, resolve, sep } from "path";
+
+// src/core/managed-path.ts
+import { lstatSync } from "fs";
+import { readdir, writeFile } from "fs/promises";
+import { join } from "path";
+var ManagedPathError = class extends Error {
+  constructor(path, message) {
+    super(message);
+    this.path = path;
+    this.name = "ManagedPathError";
+  }
+  path;
+};
+function inspectManagedDirectory(path, label, options = {}) {
+  try {
+    const stats = lstatSync(path);
+    if (stats.isDirectory())
+      return { exists: true, issue: null };
+    return {
+      exists: true,
+      issue: new ManagedPathError(path, `${label} must be a real directory: ${path}`)
+    };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      if (options.allowMissing)
+        return { exists: false, issue: null };
+      return {
+        exists: false,
+        issue: new ManagedPathError(path, `${label} must be a real directory: ${path}`)
+      };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      exists: false,
+      issue: new ManagedPathError(path, `unable to inspect ${label} ${path}: ${message}`)
+    };
+  }
+}
+function requireManagedDirectory(path, label, options = {}) {
+  const inspection = inspectManagedDirectory(path, label, options);
+  if (inspection.issue)
+    throw inspection.issue;
+  return inspection.exists;
+}
+function inspectManagedFile(path, label, options = {}) {
+  try {
+    const stats = lstatSync(path);
+    if (stats.isFile())
+      return { exists: true, issue: null };
+    return {
+      exists: true,
+      issue: new ManagedPathError(path, `${label} must be a regular file: ${path}`)
+    };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      if (options.allowMissing)
+        return { exists: false, issue: null };
+      return {
+        exists: false,
+        issue: new ManagedPathError(path, `${label} must be a regular file: ${path}`)
+      };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      exists: false,
+      issue: new ManagedPathError(path, `unable to inspect ${label} ${path}: ${message}`)
+    };
+  }
+}
+function requireManagedFile(path, label, options = {}) {
+  const inspection = inspectManagedFile(path, label, options);
+  if (inspection.issue)
+    throw inspection.issue;
+  return inspection.exists;
+}
+async function ensureManagedFile(path, content, label) {
+  if (requireManagedFile(path, label, { allowMissing: true }))
+    return false;
+  await writeFile(path, content, { flag: "wx" });
+  return true;
+}
+async function writeManagedFile(path, content, label) {
+  const exists = requireManagedFile(path, label, { allowMissing: true });
+  if (exists)
+    await writeFile(path, content);
+  else
+    await writeFile(path, content, { flag: "wx" });
+}
+function resolveManagedDirectoryChain(root, segments, label) {
+  requireManagedDirectory(root, `${label} root`);
+  let current = root;
+  for (const segment of segments) {
+    if (!segment || segment === "." || segment === ".." || segment.includes("/") || segment.includes("\\"))
+      throw new ManagedPathError(current, `${label} contains an invalid directory segment: ${segment}`);
+    current = join(current, segment);
+    requireManagedDirectory(current, label, { allowMissing: true });
+  }
+  return current;
+}
+async function inspectManagedFileTree(root, label, options = {}) {
+  const result = { rootExists: false, files: [], issues: [] };
+  const rootInspection = inspectManagedDirectory(root, `${label} root`, options);
+  if (rootInspection.issue) {
+    result.issues.push(rootInspection.issue);
+    return result;
+  }
+  if (!rootInspection.exists)
+    return result;
+  result.rootExists = true;
+  await collectManagedFiles(root, label, result);
+  result.files.sort();
+  return result;
+}
+async function collectManagedFiles(directory, label, result) {
+  let entries;
+  try {
+    entries = await readdir(directory, { withFileTypes: true });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    result.issues.push(new ManagedPathError(directory, `unable to inspect the ${label} tree at ${directory}: ${message}`));
+    return;
+  }
+  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+    if (entry.name.startsWith("."))
+      continue;
+    const path = join(directory, entry.name);
+    if (entry.isDirectory()) {
+      await collectManagedFiles(path, label, result);
+      continue;
+    }
+    if (entry.isFile()) {
+      result.files.push(path);
+      continue;
+    }
+    result.issues.push(new ManagedPathError(path, `unsupported entry in the ${label} tree: ${path}`));
+  }
+}
+
+// src/core/decisions.ts
+var DEFAULT_DECISION_RECORDS_PATH = ".rsp/specs/decisions";
+function normalizeDecisionRecordsPath(pathValue) {
+  return posix.normalize(pathValue.trim().replace(/\\/g, "/")).replace(/^\.\//, "").replace(/\/$/, "");
+}
+function validateDecisionRecordsPath(pathValue) {
+  if (typeof pathValue !== "string" || pathValue.trim() === "")
+    return 'config.yaml field "decisions.path" must be a non-empty string';
+  const raw = pathValue.trim();
+  const portable = raw.replace(/\\/g, "/");
+  if (isAbsolute(raw) || posix.isAbsolute(portable) || /^[a-z]:[\\/]/i.test(raw))
+    return 'config.yaml field "decisions.path" must be project-relative';
+  const normalized = normalizeDecisionRecordsPath(raw);
+  if (normalized === "." || normalized === ".." || normalized.startsWith("../"))
+    return 'config.yaml field "decisions.path" must stay inside the Host Project';
+  if ((normalized === ".rsp" || normalized.startsWith(".rsp/")) && normalized !== DEFAULT_DECISION_RECORDS_PATH)
+    return `config.yaml field "decisions.path" must use ${DEFAULT_DECISION_RECORDS_PATH} or a path outside .rsp/`;
+  return null;
+}
+function getDecisionRecordsConfigIssue(config) {
+  if (!("decisions" in config))
+    return null;
+  const decisions = config.decisions;
+  if (!decisions || typeof decisions !== "object" || Array.isArray(decisions))
+    return 'config.yaml field "decisions" must be a mapping with one path';
+  const keys = Object.keys(decisions);
+  if (keys.length !== 1 || keys[0] !== "path")
+    return 'config.yaml field "decisions" supports only "path"';
+  return validateDecisionRecordsPath(decisions.path);
+}
+function resolveDecisionRecordsPath(config) {
+  const configured = config.decisions?.path;
+  return configured && validateDecisionRecordsPath(configured) === null ? normalizeDecisionRecordsPath(configured) : DEFAULT_DECISION_RECORDS_PATH;
+}
+async function ensureDecisionRecordsDirectory(pathValue) {
+  const filesystemError = await validateDecisionRecordsFilesystemPath(pathValue);
+  if (filesystemError)
+    throw new Error(filesystemError);
+  const existed = existsSync(pathValue);
+  await mkdir(pathValue, { recursive: true });
+  const entries = await readdir2(pathValue);
+  if (entries.length === 0) {
+    await ensureManagedFile(join2(pathValue, ".gitkeep"), "", "Decision Record placeholder");
+    return true;
+  }
+  if (entries.includes(".gitkeep"))
+    requireManagedFile(join2(pathValue, ".gitkeep"), "Decision Record placeholder");
+  return !existed;
+}
+async function validateDecisionRecordsFilesystemPath(pathValue) {
+  const projectRoot = await realpath(".");
+  let existingAncestor = resolve(pathValue);
+  while (!existsSync(existingAncestor)) {
+    const parent = dirname(existingAncestor);
+    if (parent === existingAncestor)
+      return `Decision Record path "${pathValue}" has no accessible Host Project ancestor`;
+    existingAncestor = parent;
+  }
+  const resolvedAncestor = await realpath(existingAncestor);
+  const rel = relative(projectRoot, resolvedAncestor);
+  if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel))
+    return `Decision Record path "${pathValue}" resolves outside the Host Project through ${existingAncestor}`;
+  if (existsSync(resolve(pathValue)) && !(await stat(resolve(pathValue))).isDirectory())
+    return `Decision Record path "${pathValue}" must be a directory`;
+  return null;
+}
+
+// src/core/helpers.ts
+import { existsSync as existsSync2 } from "fs";
+import { readdir as readdir3, readFile, rmdir } from "fs/promises";
+import { basename, dirname as dirname2, join as join3, relative as relative2, sep as sep2 } from "path";
+import { parse } from "yaml";
+var RSP_AGENTS_BEGIN = "<!-- rsp:begin -->";
+var RSP_AGENTS_END = "<!-- rsp:end -->";
+function parseYamlText(text) {
+  const parsed = parse(text);
+  if (parsed === null || parsed === void 0)
+    return {};
+  if (typeof parsed !== "object" || Array.isArray(parsed))
+    throw new Error("YAML document must be a mapping/object");
+  return parsed;
+}
+function parseFrontmatter(content) {
+  const m = content.match(/^---\r?\n([\s\S]*?)\r?\n(?:---|\.\.\.)\r?\n/);
+  if (!m)
+    return null;
+  return parseYamlText(m[1]);
+}
+function countCheckboxes(content) {
+  const todo = (content.match(/\[ \]/g) || []).length;
+  const progress = (content.match(/\[\/\]/g) || []).length;
+  const done = (content.match(/\[x\]/g) || []).length;
+  const dropped = (content.match(/\[-\]/g) || []).length;
+  return { todo, progress, done, dropped, total: todo + progress + done + dropped };
+}
+async function walkMarkdownFiles(dir, options = {}) {
+  const all = await walkFiles(dir, options);
+  return all.filter((f) => f.endsWith(".md"));
+}
+async function inspectUnsupportedRules() {
+  const rulesDir = join3(RSP_DIR, "rules");
+  const diagnostics = [];
+  const rawEntries = await walkAllEntries(rulesDir, diagnostics);
+  const entries = rawEntries.filter((entry) => entry.path !== OBSOLETE_RSP_RULES_PATH).map((entry) => ({
+    path: normalizeLogicalPath(relative2(rulesDir, entry.path)),
+    kind: entry.kind
+  }));
+  const obsoleteFallbackPresent = existsSync2(OBSOLETE_RSP_RULES_PATH);
+  return {
+    entries,
+    diagnostics,
+    directoryRemaining: existsSync2(rulesDir) && (!obsoleteFallbackPresent || entries.length > 0)
+  };
+}
+async function walkAllEntries(dir, diagnostics) {
+  const entries = [];
+  try {
+    const items = await readdir3(dir, { withFileTypes: true });
+    for (const item of items) {
+      const path = join3(dir, item.name);
+      const kind = item.isDirectory() ? "directory" : "file";
+      entries.push({ path, kind });
+      if (kind === "directory")
+        entries.push(...await walkAllEntries(path, diagnostics));
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      diagnostics.push({
+        code: "walk_failed",
+        operation: "readdir",
+        path: dir,
+        message: toErrorMessage(error)
+      });
+    }
+  }
+  return entries;
+}
+async function walkFiles(dir, options = {}) {
+  const files = [];
+  try {
+    const items = await readdir3(dir, { withFileTypes: true });
+    for (const item of items) {
+      if (item.name.startsWith("."))
+        continue;
+      const filePath = join3(dir, item.name);
+      if (item.isDirectory())
+        files.push(...await walkFiles(filePath, options));
+      else
+        files.push(filePath);
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      options.onError?.({
+        code: "walk_failed",
+        operation: "readdir",
+        path: dir,
+        message: toErrorMessage(error)
+      });
+    }
+  }
+  return files;
+}
+function normalizeLogicalPath(pathValue) {
+  return pathValue.split(sep2).join("/").replace(/\\/g, "/");
+}
+function generateChangeContent(name, summary = "", kind, options = {}) {
+  const proposalSummary = summary || (name === "project-setup" ? "Capture the project model, boundaries, and stable local constraints" : "<one-line summary>");
+  if (name === "project-setup") {
+    return `---
+kind: ops
+---
+
+# Change: project-setup
+
+## Proposal
+- Outcome: ${proposalSummary}
+- Why:
+  - Establish a durable project model before normal implementation work starts
+- Scope:
+  - Review the repository structure, entrypoints, and primary outputs
+  - Fill .rsp/specs/design.md with durable architecture facts
+  - Add stable navigation, context, instructions, or validation steps to project-owned CONTEXT.md or the nearest AGENTS.md when those conventions exist
+- Non-goals:
+  - Do not duplicate durable project facts across this change, specs, and AGENTS.md
+
+## Spec
+### ADDED
+- Requirement: project bootstrap capture
+  - The repository's purpose, scope, and structure are reflected in .rsp/specs/design.md
+
+### MODIFIED
+- Requirement: stable project-owned context and instructions
+  - Stable navigation and context are reflected in project-owned CONTEXT.md when that convention exists
+  - Stable agent instructions are reflected in the nearest project-owned AGENTS.md when needed
+
+### Acceptance
+#### Scenario: project model captured
+- GIVEN an initialized RSP project
+- WHEN project setup is completed
+- THEN .rsp/specs/design.md reflects durable project facts
+- AND project-owned CONTEXT.md and the nearest AGENTS.md contain only the stable context and instructions assigned to them by Host Project conventions
+
+## Design
+- Approach:
+  - Keep bootstrap work in this single Change while returning durable outcomes to their existing project owners
+- Boundaries:
+  - Specs own stable current facts; project-owned CONTEXT.md and AGENTS.md retain their navigation, context, and instruction roles
+- Affected areas:
+  - .rsp/specs/design.md
+  - Project-owned CONTEXT.md or AGENTS.md when applicable
+- Durable outcome targets:
+  - Current facts: .rsp/specs/design.md, existing scoped Specs, CONTEXT.md, or AGENTS.md as applicable
+  - Lasting rationale: one Decision Record under the configured authoritative path, only when a hard-to-reverse tradeoff exists
+- Constraints:
+  - Keep the setup lightweight and avoid duplicating durable project facts
+
+## Tasks
+- [ ] Review the repository structure, entrypoints, and primary outputs
+- [ ] Review project-owned CONTEXT.md and AGENTS.md and confirm the RSP entry points to the right project files
+- [ ] Fill .rsp/specs/design.md with durable architecture facts
+- [ ] Add stable project-owned context, instructions, or validation steps only where the Host Project convention requires them
+
+## Verify
+- Automated:
+  - [ ] Run rsp doctor \u2014 proves: the initialized RSP workspace is structurally valid
+- Manual or environment:
+  - [ ] Review .rsp/specs/design.md and project-owned context or instructions and confirm they match the repository
+- Coverage:
+  - none
+
+## Blockers
+- none
+`;
+  }
+  const frontmatterKind = kind ?? "<choose: feature | fix | refactor | docs | ops | research>";
+  if (options.lite)
+    return generateLiteChangeContent(name, proposalSummary, frontmatterKind);
+  const template = getChangeTemplateByKind(kind);
+  return `---
+kind: "${frontmatterKind}"
+---
+
+# Change: ${name}
+
+## Proposal
+- Outcome: ${proposalSummary}
+- Why:
+  - ${template.why}
+- Scope:
+  - ${template.scope}
+- Non-goals:
+  - ${template.nonGoals}
+
+## Spec
+${template.specSection}
+
+### Acceptance
+${template.acceptanceSection}
+
+## Design
+- Approach:
+  - ${template.approach}
+- Boundaries:
+  - <module, interface, data, document, or ownership boundary affected>
+- Affected areas:
+  - ${template.affectedArea1}
+  - ${template.affectedArea2}
+- Constraints:
+  - ${template.constraints}
+
+## Tasks
+- [ ] ${template.task}
+
+## Verify
+- Automated:
+  - [ ] ${template.automatedVerify} \u2014 proves: <behavior or scope covered>
+- Manual or environment:
+  - [ ] ${template.manualVerify}
+- Coverage:
+  - <omitted or unavailable relevant coverage and reason, or none>
+
+## Blockers
+- none
+`;
+}
+function generateLiteChangeContent(name, proposalSummary, frontmatterKind) {
+  return `---
+kind: "${frontmatterKind}"
+---
+
+# Change: ${name}
+
+## Proposal
+- Outcome: ${proposalSummary}
+- Why:
+  - <why this small change matters>
+- Scope:
+  - <what will change>
+- Non-goals:
+  - none
+
+## Spec
+### MODIFIED
+- Requirement: <observable outcome>
+  - <what should be true after this change>
+
+### Acceptance
+#### Scenario: change is complete
+- GIVEN <current context>
+- WHEN <the change is applied>
+- THEN <expected outcome>
+
+## Design
+- Approach:
+  - <minimal implementation approach>
+- Boundaries:
+  - <primary ownership or interface boundary>
+- Affected areas:
+  - <primary file, directory, or doc path>
+- Constraints:
+  - <important constraint, or none>
+
+## Tasks
+- [ ] Implement the small change
+
+## Verify
+- Automated:
+  - [ ] <cheapest decisive check; retain a new test only when justified, or not applicable: reason> \u2014 proves: <behavior or scope covered>
+- Manual or environment:
+  - [ ] <exact acceptance scenario, or unavailable/not applicable: owner and reason>
+- Coverage:
+  - <omitted or unavailable relevant coverage and reason, or none>
+
+## Blockers
+- none
+`;
+}
+function getChangeTemplateByKind(kind) {
+  const automatedVerify = "<cheapest decisive check; retain a new test only when justified, or not applicable: reason>";
+  switch (kind) {
+    case "feature":
+      return {
+        why: "<what user need or capability gap this addresses>",
+        scope: "<what new behavior or capability will be delivered>",
+        nonGoals: "<what related capabilities are explicitly out of scope>",
+        specSection: "<!-- Describe observable behavior and requirements. Implementation notes belong in ## Design. -->\n### ADDED\n- Requirement: <new user-facing behavior>\n  - <verifiable requirement for the new capability>",
+        acceptanceSection: "#### Scenario: user exercises the new capability\n- GIVEN <context>\n- WHEN <user action>\n- THEN <expected new behavior>",
+        approach: "<how the new capability will be implemented>",
+        affectedArea1: "<concrete file path, directory, module, or subsystem 1>",
+        affectedArea2: "<concrete file path, directory, module, or subsystem 2 if needed>",
+        constraints: "<behavior, compatibility, performance, safety, or scope constraint that must hold>",
+        task: "<implement the new behavior and its acceptance scenario in the affected areas>",
+        automatedVerify,
+        manualVerify: "<exact end-to-end user scenario to validate the new capability, or unavailable/not applicable: owner and reason>"
+      };
+    case "fix":
+      return {
+        why: "<what current behavior is wrong or broken>",
+        scope: "<what specific defect is being corrected>",
+        nonGoals: "<what related but separate issues are out of scope>",
+        specSection: "<!-- Describe expected correct behavior. Implementation notes belong in ## Design. -->\n### MODIFIED\n- Requirement: correct behavior\n  - <expected correct behavior after the fix>",
+        acceptanceSection: "#### Scenario: defect is resolved\n- GIVEN <conditions that trigger the defect>\n- WHEN <action that previously failed>\n- THEN <expected correct outcome>\n- AND the original broken outcome no longer occurs",
+        approach: "<confirmed cause and correction strategy, or exact evidence needed to establish the cause>",
+        affectedArea1: "<concrete file path, directory, module, or subsystem containing the defect>",
+        affectedArea2: "<secondary path, dependency, or test file if needed>",
+        constraints: "<regression, backward-compatibility, safety, or scope constraint that must hold>",
+        task: "<identify the root cause and apply the minimal fix>",
+        automatedVerify,
+        manualVerify: "<exact steps to reproduce the original issue and confirm it no longer occurs, or unavailable/not applicable: owner and reason>"
+      };
+    case "refactor":
+      return {
+        why: "<what maintainability, readability, or structural issue motivates this>",
+        scope: "<what code areas are being restructured>",
+        nonGoals: "<no behavior change is expected or intended>",
+        specSection: "<!-- Describe the desired structural outcome. Implementation notes belong in ## Design. -->\n### MODIFIED\n- Requirement: internal structure improvement\n  - <desired structural outcome without observable behavior change>",
+        acceptanceSection: "#### Scenario: behavior is preserved after restructuring\n- GIVEN the existing codebase before the refactor\n- WHEN the refactored code runs against existing tests\n- THEN all existing tests pass unchanged",
+        approach: "<how the code will be restructured (rename, extract, move, etc.)>",
+        affectedArea1: "<concrete file path, directory, module, or subsystem being refactored>",
+        affectedArea2: "<secondary path, dependency, or test file if needed>",
+        constraints: "<observable behavior must remain unchanged; compatibility, performance, and safety constraints must still hold>",
+        task: "<restructure the code while keeping behavior identical>",
+        automatedVerify,
+        manualVerify: "<exact scenario to spot-check that behavior is unchanged after the refactor, or unavailable/not applicable: owner and reason>"
+      };
+    case "docs":
+      return {
+        why: "<why the documentation change matters>",
+        scope: "<which docs, readers, or workflows will be updated>",
+        nonGoals: "<what documentation behavior or audience is out of scope>",
+        specSection: "<!-- Describe what the reader should see or experience. Implementation notes belong in ## Design. -->\n### MODIFIED\n- Requirement: documentation accuracy\n  - <what durable reader-facing behavior or explanation changes>",
+        acceptanceSection: "#### Scenario: reader follows the updated guidance\n- GIVEN the updated documentation\n- WHEN a reader follows the documented workflow\n- THEN the steps are accurate and sufficient",
+        approach: "<how the documentation will be updated and organized>",
+        affectedArea1: "<concrete doc path, directory, module doc, or documentation surface 1>",
+        affectedArea2: "<secondary doc path or reference file if needed>",
+        constraints: "<durable wording, consistency, scope, or audience constraint that must hold>",
+        task: "<update the target documentation and supporting references>",
+        automatedVerify,
+        manualVerify: "<exact reader or operator scenario to confirm the updated guidance is accurate, or unavailable/not applicable: owner and reason>"
+      };
+    case "research":
+      return {
+        why: "<what question or uncertainty this research resolves>",
+        scope: "<what system area, option set, or hypothesis is being examined>",
+        nonGoals: "<what implementation work is explicitly out of scope>",
+        specSection: "<!-- Describe what finding or decision must be captured. Implementation notes belong in ## Design. -->\n### ADDED\n- Requirement: research outcome recording\n  - <what finding, option, or decision must be captured clearly>",
+        acceptanceSection: "#### Scenario: research question is resolved\n- GIVEN the current uncertainty or open question\n- WHEN the investigation is completed\n- THEN the result is recorded clearly enough to guide follow-up work",
+        approach: "<how the investigation will be performed and what evidence will be gathered>",
+        affectedArea1: "<concrete file path, directory, module, subsystem, or source under investigation>",
+        affectedArea2: "<secondary path, dependency, environment, or evidence source if needed>",
+        constraints: "<time, evidence, safety, or scope constraint for the investigation>",
+        task: "<gather evidence, record the recommendation or finding, and note any follow-up implementation work if needed>",
+        automatedVerify,
+        manualVerify: "<exact review of the findings to confirm they answer the original question and identify follow-up work if needed, or unavailable/not applicable: owner and reason>"
+      };
+    case "ops":
+      return {
+        why: "<why this operational or environment change matters>",
+        scope: "<what environment, workflow, or operational path changes>",
+        nonGoals: "<what product or feature behavior will not change>",
+        specSection: "<!-- Describe the reliable operational outcome. Implementation notes belong in ## Design. -->\n### MODIFIED\n- Requirement: operational behavior\n  - <what reliable operational outcome should change or stay true>",
+        acceptanceSection: "#### Scenario: operational path succeeds\n- GIVEN the target environment or workflow\n- WHEN the operational change is applied\n- THEN the expected operational outcome is reliable",
+        approach: "<how the operational change will be applied safely>",
+        affectedArea1: "<concrete script, config path, workflow, environment path, or operational surface 1>",
+        affectedArea2: "<secondary script, config path, dependency, or environment surface if needed>",
+        constraints: "<rollback, safety, reliability, environment, or scope constraint that must hold>",
+        task: "<apply and verify the operational change>",
+        automatedVerify,
+        manualVerify: "<exact operator workflow or environment scenario to confirm the operational result, or unavailable/not applicable: owner and reason>"
+      };
+    default:
+      return {
+        why: "<why this change matters>",
+        scope: "<what this change will do>",
+        nonGoals: "<what this change will not do>",
+        specSection: "<!-- Describe observable behavior and requirements. Implementation notes belong in ## Design. -->\n### ADDED\n- Requirement: <new or updated behavior>\n  - <verifiable requirement>",
+        acceptanceSection: "#### Scenario: <name>\n- GIVEN <context>\n- WHEN <action>\n- THEN <expected outcome>",
+        approach: "<how the change will be implemented>",
+        affectedArea1: "<concrete file path, directory, module, or subsystem 1>",
+        affectedArea2: "<concrete file path, directory, module, or subsystem 2 if needed>",
+        constraints: "<behavior, compatibility, performance, safety, or scope constraint that must hold>",
+        task: "<implement the core change in the affected areas>",
+        automatedVerify,
+        manualVerify: "<exact acceptance scenario, or unavailable/not applicable: owner and reason>"
+      };
+  }
+}
+function renderRspAgentsBlock() {
+  return `${RSP_AGENTS_BEGIN}
+## RSP Entry
+
+RSP tracks current work, stable specs, and archives under \`.rsp/\`.
+
+Read in order:
+1. Nearest \`AGENTS.md\` for project or module instructions.
+2. Root \`CONTEXT-MAP.md\` if present, then the relevant nearest \`CONTEXT.md\`.
+3. The \`rsp\` skill; if unavailable, read \`.rsp/rsp-rules.md\` as the fallback protocol.
+4. \`.rsp/focus.d/\`; for grouped work read the sibling Group Brief, then the explicitly selected focused Change.
+5. Only the relevant Specs and Decision Records under the configured authoritative path.
+
+If \`.rsp/focus.d/\` is empty and the user has not provided a concrete task, ask what to work on or suggest \`npx -y @oevery/rsp create <name>\` for tracked work.
+Do not treat \`.rsp/specs/\` or \`.rsp/changes/\` as replacements for nearest \`AGENTS.md\` or \`CONTEXT.md\`.
+${RSP_AGENTS_END}`;
+}
+function upsertRspAgentsBlock(content) {
+  const block = renderRspAgentsBlock();
+  const managedRe = /<!-- rsp:begin -->[\s\S]*?<!-- rsp:end -->/;
+  if (managedRe.test(content)) {
+    const next2 = content.replace(managedRe, block);
+    return { content: next2, changed: next2 !== content };
+  }
+  const trimmed = content.trimStart();
+  const next = trimmed ? `${block}
+
+${trimmed}` : `${block}
+`;
+  return { content: next, changed: true };
+}
+function hasRspAgentsBlock(content) {
+  return content.includes(RSP_AGENTS_BEGIN) && content.includes(RSP_AGENTS_END);
+}
+var SPEC_NAME_RE = /^[a-z0-9-]+(?:\/[a-z0-9-]+)*$/;
+function isValidSpecName(name) {
+  return SPEC_NAME_RE.test(name);
+}
+function guardRspInitialized() {
+  const designPath = join3(RSP_DIR, "specs", "design.md");
+  const rules = inspectManagedFile(RSP_RULES_PATH, "fallback protocol", { allowMissing: true });
+  const design = inspectManagedFile(designPath, "design Spec", { allowMissing: true });
+  if (rules.issue || design.issue || !rules.exists || !design.exists) {
+    const initialized = existsSync2(RSP_DIR);
+    console.error(`  ${pc.red("Error:")} ${initialized ? "RSP project requires an update" : "RSP is not initialized in this project"}`);
+    console.error(`  ${pc.dim(initialized ? "Run: rsp update" : "Run: rsp init")}`);
+    process.exit(1);
+  }
+}
+function getOpenCheckboxes(sectionText) {
+  return sectionText.split("\n").map((line) => line.trim()).filter((line) => /^- \[[ /]\]/.test(line));
+}
+async function cleanupEmptyParentDirs(path, stopDir) {
+  let parent = dirname2(path);
+  while (parent !== stopDir) {
+    try {
+      const remaining = await readdir3(parent);
+      if (remaining.length === 0)
+        await rmdir(parent);
+      else
+        break;
+    } catch {
+      break;
+    }
+    parent = dirname2(parent);
+  }
+}
+async function detectProjectName() {
+  try {
+    if (existsSync2("package.json")) {
+      const raw = await readFile("package.json", "utf-8");
+      const pkg = JSON.parse(raw);
+      if (pkg.name && pkg.name !== "")
+        return pkg.name;
+    }
+  } catch {
+  }
+  return basename(process.cwd());
+}
+function generateDesignContent(projectName) {
+  return `# Project Design: ${projectName}
+
+## Purpose
+- <what this project is responsible for>
+- <who or what it serves>
+
+## Stable Facts
+- <durable fact that future agents or developers must know>
+- <key architectural invariant>
+
+## Boundaries
+- In scope:
+  - <major capability or boundary>
+- Out of scope:
+  - <intentional non-goal>
+
+## Structure
+- <important directory or subsystem> \u2014 <responsibility>
+
+## Constraints
+- <cross-cutting technical or operational constraint, when it affects architecture>
+`;
+}
+function generateSpecContent(name) {
+  const title = toTitleCase(name);
+  return `# ${title}
+
+## Purpose
+- <why this project-level spec exists>
+
+## Stable Facts
+- <durable fact that future work must know>
+
+## Boundaries
+- In scope:
+  - <what this spec covers>
+- Out of scope:
+  - <what this spec does not cover>
+
+## Constraints
+- <stable constraint, if any>
+`;
+}
+function toTitleCase(value) {
+  return value.split(/[-/]/g).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+function extractSection(content, heading) {
+  const lines = content.split("\n");
+  const start = lines.findIndex((line) => line.trim() === `## ${heading}`);
+  if (start === -1)
+    return "";
+  const body = [];
+  for (let index = start + 1; index < lines.length; index++) {
+    const line = lines[index];
+    if (line.startsWith("## "))
+      break;
+    body.push(line);
+  }
+  return body.join("\n").trim();
+}
+function extractBlockerLines(content) {
+  const uncommented = content.replace(/<!--[\s\S]*?-->/g, "");
+  return extractSection(uncommented, "Blockers").split("\n").map((line) => line.trim()).filter(Boolean);
+}
+function hasMeaningfulBlockers(content) {
+  const lines = extractBlockerLines(content);
+  if (lines.length === 0)
+    return false;
+  return lines.some((line) => !/^[-*]\s*(?:none)?$/i.test(line) && !/^none$/i.test(line));
+}
+function detectDeltaSections(content) {
+  const body = extractSection(content, "Spec");
+  return {
+    added: /^###\s*ADDED/im.test(body),
+    modified: /^###\s*MODIFIED/im.test(body),
+    removed: /^###\s*REMOVED/im.test(body)
+  };
+}
+function collectArchiveReadiness(content, options = {}) {
+  const warnings = [];
+  const tasksSection = extractSection(content, "Tasks");
+  const verifySection = extractSection(content, "Verify");
+  const taskTodos = getOpenCheckboxes(tasksSection);
+  if (taskTodos.length > 0)
+    warnings.push(`${taskTodos.length} task item(s) still incomplete`);
+  const verifyTodos = getOpenCheckboxes(verifySection);
+  if (verifyTodos.length > 0)
+    warnings.push(`${verifyTodos.length} Verify checklist item(s) are still incomplete`);
+  const activeBlockers = options.activeBlockers ?? hasMeaningfulBlockers(content);
+  if (activeBlockers)
+    warnings.push("active blockers are present in the change file");
+  const scenarios = parseScenarios(content);
+  const missingScenarios = scenarios.length === 0;
+  if (missingScenarios)
+    warnings.push("no Scenario blocks found (some changes do not need them)");
+  const archiveReady = activeBlockers ? "no" : warnings.length === 0 ? "yes" : "judgment";
+  return {
+    taskTodos,
+    verifyTodos,
+    activeBlockers,
+    scenarioCount: scenarios.length,
+    missingScenarios,
+    deterministic: warnings.length === 0 ? "pass" : "warnings",
+    semantic: "needs-review",
+    archiveReady,
+    warnings
+  };
+}
+function buildDurableReviewGuidance(factCandidateTargets, decisionRecordsPath) {
+  return {
+    required: true,
+    factDecisions: [
+      "No current-fact update needed",
+      "Update existing spec or scoped instruction",
+      "Create a new durable spec"
+    ],
+    rationaleDecisions: [
+      "No Decision Record needed",
+      "Create or update a Decision Record"
+    ],
+    factCandidateTargets,
+    decisionRecordsPath,
+    note: "Semantic review decides current-fact and lasting-rationale updates independently. The CLI never infers scoped instruction or Decision Record filenames and never promotes Change content automatically."
+  };
+}
+function getDurableReviewCandidateTargets() {
+  return [".rsp/specs/design.md"];
+}
+function collectArchiveChecklist(content, options = {}) {
+  return collectArchiveReadiness(content, options).warnings;
+}
+function parseScenarios(content) {
+  const scenarios = [];
+  const regex = /^#{3,4}\s*Scenario:\s*(.+)$/gim;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    const heading = match[1].trim();
+    const startPos = match.index + match[0].length;
+    const restContent = content.slice(startPos);
+    const nextSection = restContent.match(/^#{3,4}\s/m);
+    const block = nextSection ? restContent.slice(0, nextSection.index) : restContent;
+    const steps = block.split("\n").map((s) => s.trim()).filter((s) => s.startsWith("-") && /GIVEN|WHEN|THEN|AND|BUT/i.test(s)).map((s) => s.replace(/^[-*]\s*/, ""));
+    if (steps.length > 0)
+      scenarios.push({ heading, steps });
+  }
+  return scenarios;
+}
+
+// src/core/config.ts
+var __dirname = dirname3(fileURLToPath(import.meta.url));
+var PKG_ROOT = join4(__dirname, "..");
+var RSP_DIR = ".rsp";
+var RSP_RULES_PATH = join4(RSP_DIR, "rsp-rules.md");
+var OBSOLETE_RSP_RULES_PATH = join4(RSP_DIR, "rules", "rsp-rules.md");
+var CHANGES_DIR = join4(RSP_DIR, "changes");
+var FOCUS_DIR = join4(RSP_DIR, "focus.d");
+var ARCHIVES_DIR = join4(RSP_DIR, "archives");
+var LOCK_PATH = join4(RSP_DIR, ".lock");
+var CONFIG_PATH = join4(RSP_DIR, "config.yaml");
+var VALID_KINDS = ["feature", "fix", "refactor", "docs", "ops", "research"];
+var DEFAULT_REQUIRED_SECTIONS = ["Proposal", "Spec", "Design", "Tasks", "Verify", "Blockers"];
+var _configCache = null;
+async function loadRspConfig() {
+  const inspection = await inspectRspConfig();
+  if (inspection.issues.length > 0)
+    throw new Error(inspection.issues.join("; "));
+  return inspection.config;
+}
+async function inspectRspConfig() {
+  const cwd = process.cwd();
+  if (_configCache?.cwd === cwd)
+    return _configCache.inspection;
+  const configFile = inspectManagedFile(CONFIG_PATH, "config file", { allowMissing: true });
+  if (configFile.issue)
+    throw configFile.issue;
+  if (!configFile.exists) {
+    const inspection2 = { config: {}, issues: [] };
+    _configCache = { cwd, inspection: inspection2 };
+    return inspection2;
+  }
+  const raw = await readFile2(CONFIG_PATH, "utf-8");
+  const parsed = parseYamlText(raw);
+  const issues = validateRspConfig(parsed);
+  const decisions = parsed.decisions && typeof parsed.decisions === "object" && !Array.isArray(parsed.decisions) ? parsed.decisions : void 0;
+  const decisionPath = decisions?.path;
+  const kinds = Array.isArray(parsed.kinds) && parsed.kinds.every((value) => typeof value === "string" && value.trim() !== "") ? parsed.kinds.map((value) => value.trim()) : void 0;
+  const decisionRecordsIssue = getDecisionRecordsConfigIssue(parsed);
+  const inspection = {
+    config: {
+      kinds,
+      decisions: decisionRecordsIssue === null && validateDecisionRecordsPath(decisionPath) === null ? { path: normalizeDecisionRecordsPath(String(decisionPath)) } : void 0
+    },
+    issues
+  };
+  _configCache = { cwd, inspection };
+  return inspection;
+}
+function validateRspConfig(parsed) {
+  const issues = [];
+  const supported = /* @__PURE__ */ new Set(["kinds", "decisions"]);
+  for (const key of Object.keys(parsed)) {
+    if (key === "required_sections") {
+      issues.push('config.yaml field "required_sections" is no longer supported');
+    } else if (!supported.has(key)) {
+      issues.push(`config.yaml field "${key}" is not supported`);
+    }
+  }
+  if ("kinds" in parsed) {
+    if (!Array.isArray(parsed.kinds)) {
+      issues.push('config.yaml field "kinds" must be a YAML list');
+    } else if (!parsed.kinds.every((value) => typeof value === "string" && value.trim() !== "")) {
+      issues.push('config.yaml field "kinds" must contain only non-empty strings');
+    } else {
+      const kinds = parsed.kinds.map((value) => value.trim());
+      const duplicates = [...new Set(kinds.filter((value, index) => kinds.indexOf(value) !== index))];
+      if (duplicates.length > 0)
+        issues.push(`config.yaml field "kinds" contains duplicate entries: ${duplicates.join(", ")}`);
+    }
+  }
+  const decisionRecordsIssue = getDecisionRecordsConfigIssue(parsed);
+  if (decisionRecordsIssue)
+    issues.push(decisionRecordsIssue);
+  return issues;
+}
+function clearConfigCache() {
+  _configCache = null;
+}
+function resolveKinds(config) {
+  return config.kinds && config.kinds.length > 0 ? config.kinds : [...VALID_KINDS];
+}
+function resolveRequiredSections(_config) {
+  return [...DEFAULT_REQUIRED_SECTIONS];
+}
+async function getVersion() {
+  const { version } = JSON.parse(await readFile2(join4(PKG_ROOT, "package.json"), "utf-8"));
+  return version;
+}
+
+// src/core/output.ts
+function toErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function emitJson(data, options = {}) {
+  const indentation = options.compact ? void 0 : 2;
+  process.stdout.write(`${JSON.stringify(data, null, indentation)}
+`);
+}
+function recordRuntimeDiagnostic(runtime, diagnostic, verbose = false) {
+  runtime.push(diagnostic);
+  if (verbose) {
+    console.error(`  ${pc.dim(`[verbose] ${diagnostic.operation} ${diagnostic.path}: ${diagnostic.message}`)}`);
+  }
+}
+
+// src/status/inspect.ts
+import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile5, stat as stat2 } from "fs/promises";
+import { join as join7 } from "path";
+
+// src/core/change-group.ts
+import { readFile as readFile3 } from "fs/promises";
+import { dirname as dirname4, join as join6, relative as relative4 } from "path";
+
+// src/core/work-ref.ts
+import { lstatSync as lstatSync2 } from "fs";
+import { readdir as readdir4 } from "fs/promises";
+import { isAbsolute as isAbsolute2, join as join5, relative as relative3 } from "path";
+var WORK_SEGMENT_RE = /^[a-z0-9-]+$/;
+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 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))) {
+    throw new WorkRefError(
+      "invalid_work_ref",
+      `work identity "${name}" must contain one or two lowercase kebab-case segments`,
+      name
+    );
+  }
+  if (segments.length === 2 && segments[1] === GROUP_BRIEF_FILENAME.slice(0, -3)) {
+    throw new WorkRefError(
+      "invalid_work_ref",
+      `work identity "${name}" uses the reserved Group Brief filename`,
+      name
+    );
+  }
+  assertValidWorkRoot(changesDir, name);
+  assertNoIdentityCollision(changesDir, segments, name, isGroupBrief ? GROUP_BRIEF_FILENAME : void 0);
+  const path = join5(changesDir, ...segments.slice(0, -1), isGroupBrief ? GROUP_BRIEF_FILENAME : `${segments.at(-1)}.md`);
+  const ref = segments.length === 1 ? { kind: "change", name, path, group: null } : isGroupBrief ? { kind: "group-brief", name, path, group: segments[0] } : { kind: "group-change", name, path, group: segments[0] };
+  if (ref.kind === "group-change" && options.executable !== false)
+    assertGroupBrief(changesDir, ref);
+  if (options.executable && ref.kind === "group-brief") {
+    throw new WorkRefError(
+      "non_executable_work_ref",
+      `work identity "${name}" is a Group Brief and cannot be used as an executable Change`,
+      name
+    );
+  }
+  assertRegularWorkFile(ref, Boolean(options.mustExist));
+  return ref;
+}
+function assertGroupBrief(changesDir, ref) {
+  const briefPath = join5(changesDir, ref.group, GROUP_BRIEF_FILENAME);
+  const kind = getPathKind(briefPath, ref.name);
+  if (kind === "missing") {
+    throw new WorkRefError(
+      "group_brief_missing",
+      `Change Group "${ref.group}" requires a Group Brief; run: rsp group create ${ref.group}`,
+      ref.name
+    );
+  }
+  if (kind !== "file") {
+    throw new WorkRefError(
+      "work_ref_not_file",
+      `Group Brief must be a regular file: ${briefPath}`,
+      ref.name
+    );
+  }
+}
+function assertRegularWorkFile(ref, mustExist) {
+  let stats;
+  try {
+    stats = lstatSync2(ref.path);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      if (mustExist) {
+        throw new WorkRefError(
+          "work_ref_not_found",
+          `open work file not found: ${ref.path}`,
+          ref.name
+        );
+      }
+      return;
+    }
+    throw asReadFailure(ref.path, ref.name, error);
+  }
+  if (!stats.isFile()) {
+    throw new WorkRefError(
+      "work_ref_not_file",
+      `open work path is not a regular file: ${ref.path}`,
+      ref.name
+    );
+  }
+}
+function resolveWorkRefPath(path, options = {}) {
+  const changesDir = options.changesDir ?? CHANGES_DIR;
+  const logicalPath = normalizeLogicalPath2(relative3(changesDir, path));
+  if (isAbsolute2(logicalPath) || logicalPath === ".." || logicalPath.startsWith("../") || !logicalPath.endsWith(".md")) {
+    throw new WorkRefError(
+      "invalid_work_ref_path",
+      `work path must be a Markdown file inside ${changesDir}: ${path}`,
+      path
+    );
+  }
+  const segments = logicalPath.split("/");
+  if (segments.length === 2 && segments[1] === "brief.md") {
+    throw new WorkRefError(
+      "invalid_work_ref_path",
+      `unsupported legacy Group Brief path: ${path}`,
+      path
+    );
+  }
+  const name = segments.length === 2 && segments[1] === GROUP_BRIEF_FILENAME ? `${segments[0]}/brief` : logicalPath.slice(0, -3);
+  return resolveWorkRef(name, options);
+}
+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);
+  if (ref.group) {
+    assertOptionalManagedDirectory(
+      join5(focusDir, ref.group),
+      ref.name,
+      "invalid_focus_path",
+      "focus path"
+    );
+  }
+  const markerPath = join5(focusDir, ...ref.name.split("/"));
+  try {
+    requireManagedFile(markerPath, "focus marker", { allowMissing: true });
+  } catch (error) {
+    if (error instanceof ManagedPathError)
+      throw new WorkRefError("invalid_focus_path", error.message, ref.name);
+    throw error;
+  }
+  return markerPath;
+}
+function resolveArchiveDirectory(ref, options = {}) {
+  const archivesDir = options.archivesDir ?? ARCHIVES_DIR;
+  assertManagedRoot(archivesDir, ref.name, "invalid_archive_root", "archive root", true);
+  if (!ref.group)
+    return archivesDir;
+  const groupPath = join5(archivesDir, ref.group);
+  assertOptionalManagedDirectory(groupPath, ref.name, "invalid_archive_path", "archive path");
+  return groupPath;
+}
+async function inspectFocusTree(options = {}) {
+  const focusDir = options.focusDir ?? FOCUS_DIR;
+  const changesDir = options.changesDir ?? CHANGES_DIR;
+  const result = { markers: [], diagnostics: [] };
+  const rootInspection = inspectManagedDirectory(focusDir, "focus root", { allowMissing: true });
+  if (rootInspection.issue) {
+    addDiagnostic(result, new WorkRefError("invalid_focus_root", rootInspection.issue.message, focusDir), focusDir);
+    return result;
+  }
+  if (!rootInspection.exists)
+    return result;
+  const rootEntries = await readDirectory(focusDir, focusDir, result);
+  if (!rootEntries)
+    return result;
+  for (const entry of rootEntries) {
+    const path = join5(focusDir, entry.name);
+    if (entry.name === ".gitkeep" && entry.isFile())
+      continue;
+    if (entry.isDirectory()) {
+      if (!WORK_SEGMENT_RE.test(entry.name)) {
+        addDiagnostic(result, new WorkRefError(
+          "invalid_work_ref",
+          `work identity "${entry.name}" must contain one or two lowercase kebab-case segments`,
+          entry.name
+        ), path);
+        continue;
+      }
+      await inspectFocusGroup(entry.name, path, changesDir, result);
+      continue;
+    }
+    if (!entry.isFile()) {
+      addDiagnostic(result, new WorkRefError(
+        "invalid_focus_path",
+        `focus path must be a regular marker file or real directory: ${path}`,
+        entry.name
+      ), path);
+      continue;
+    }
+    collectFocusMarker(entry.name, path, changesDir, result);
+  }
+  result.markers.sort((a, b) => a.name.localeCompare(b.name));
+  return result;
+}
+async function inspectArchiveTree(options = {}) {
+  const archivesDir = options.archivesDir ?? ARCHIVES_DIR;
+  const result = { rootExists: false, files: [], diagnostics: [] };
+  const rootInspection = inspectManagedDirectory(archivesDir, "archive root", { allowMissing: true });
+  if (rootInspection.issue) {
+    addDiagnostic(result, new WorkRefError("invalid_archive_root", rootInspection.issue.message, archivesDir), archivesDir);
+    return result;
+  }
+  if (!rootInspection.exists)
+    return result;
+  result.rootExists = true;
+  const rootEntries = await readDirectory(archivesDir, archivesDir, result);
+  if (!rootEntries)
+    return result;
+  for (const entry of rootEntries) {
+    const path = join5(archivesDir, entry.name);
+    if (entry.name === "INDEX.md" && entry.isFile())
+      continue;
+    if (entry.isDirectory()) {
+      if (!WORK_SEGMENT_RE.test(entry.name)) {
+        addArchivePathDiagnostic(result, entry.name, path);
+        continue;
+      }
+      await inspectArchiveGroup(entry.name, path, result);
+      continue;
+    }
+    if (!entry.isFile() || !entry.name.endsWith(".md")) {
+      addArchivePathDiagnostic(result, entry.name, path);
+      continue;
+    }
+    result.files.push(path);
+  }
+  result.files.sort();
+  return result;
+}
+async function inspectWorkTree(options = {}) {
+  const changesDir = options.changesDir ?? CHANGES_DIR;
+  const result = { changes: [], briefs: [], diagnostics: [] };
+  try {
+    assertValidWorkRoot(changesDir, changesDir);
+  } catch (error) {
+    if (!(error instanceof WorkRefError))
+      throw error;
+    addDiagnostic(result, error, changesDir);
+    return result;
+  }
+  const rootEntries = await readDirectory(changesDir, changesDir, result);
+  if (!rootEntries)
+    return result;
+  const rootDirectories = new Set(rootEntries.filter((entry) => entry.isDirectory()).map((entry) => entry.name));
+  const rootMarkdownNames = new Set(rootEntries.filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => entry.name.slice(0, -3)));
+  const collidingGroups = new Set([...rootDirectories].filter((name) => rootMarkdownNames.has(name)));
+  for (const entry of rootEntries) {
+    const path = join5(changesDir, entry.name);
+    if (entry.name === ".gitkeep" && entry.isFile())
+      continue;
+    if (entry.isDirectory()) {
+      if (!WORK_SEGMENT_RE.test(entry.name)) {
+        addDiagnostic(result, new WorkRefError(
+          "invalid_work_ref",
+          `work identity "${entry.name}" must contain one or two lowercase kebab-case segments`,
+          entry.name
+        ), path);
+        continue;
+      }
+      const colliding = collidingGroups.has(entry.name);
+      if (colliding) {
+        addDiagnostic(result, new WorkRefError(
+          "work_ref_collision",
+          `work identity "${entry.name}" is claimed by both a file and a directory`,
+          entry.name
+        ), path);
+      }
+      await inspectGroupDirectory(entry.name, path, changesDir, result, colliding);
+      continue;
+    }
+    if (!entry.isFile() || !entry.name.endsWith(".md")) {
+      addInvalidEntryDiagnostic(result, entry.name, path);
+      continue;
+    }
+    const name = entry.name.slice(0, -3);
+    if (collidingGroups.has(name)) {
+      continue;
+    }
+    collectResolvedPath(path, changesDir, result);
+  }
+  result.changes.sort((a, b) => a.name.localeCompare(b.name));
+  result.briefs.sort((a, b) => a.name.localeCompare(b.name));
+  return result;
+}
+async function inspectGroupDirectory(group, groupPath, changesDir, result, colliding) {
+  const entries = await readDirectory(groupPath, group, result);
+  if (!entries)
+    return;
+  const briefEntry = entries.find((entry) => entry.name === GROUP_BRIEF_FILENAME);
+  if (!briefEntry) {
+    addDiagnostic(result, new WorkRefError(
+      "group_brief_missing",
+      `Change Group "${group}" requires a Group Brief; run: rsp group create ${group}`,
+      group
+    ), join5(groupPath, GROUP_BRIEF_FILENAME));
+  } else if (!briefEntry.isFile()) {
+    addDiagnostic(result, new WorkRefError(
+      "work_ref_not_file",
+      `Group Brief must be a regular file: ${join5(groupPath, GROUP_BRIEF_FILENAME)}`,
+      group
+    ), join5(groupPath, GROUP_BRIEF_FILENAME));
+  }
+  for (const entry of entries) {
+    const input = `${group}/${entry.name}`;
+    const path = join5(groupPath, entry.name);
+    if (entry.name === GROUP_BRIEF_FILENAME && !entry.isFile())
+      continue;
+    if (entry.name === "brief.md") {
+      addInvalidEntryDiagnostic(result, input, path);
+      continue;
+    }
+    if (entry.isDirectory()) {
+      addDiagnostic(result, new WorkRefError(
+        "unsupported_work_depth",
+        `work identity "${input}" exceeds the supported one-level Change Group depth`,
+        input
+      ), path);
+      continue;
+    }
+    if (!entry.isFile() || !entry.name.endsWith(".md")) {
+      addInvalidEntryDiagnostic(result, input, path);
+      continue;
+    }
+    if (!colliding)
+      collectResolvedPath(path, changesDir, result);
+  }
+}
+async function inspectFocusGroup(group, groupPath, changesDir, result) {
+  const entries = await readDirectory(groupPath, group, result);
+  if (!entries)
+    return;
+  for (const entry of entries) {
+    const input = `${group}/${entry.name}`;
+    const path = join5(groupPath, entry.name);
+    if (entry.isDirectory()) {
+      addDiagnostic(result, new WorkRefError(
+        "unsupported_work_depth",
+        `work identity "${input}" exceeds the supported one-level Change Group depth`,
+        input
+      ), path);
+      continue;
+    }
+    if (!entry.isFile()) {
+      addDiagnostic(result, new WorkRefError(
+        "invalid_focus_path",
+        `focus path must be a regular marker file: ${path}`,
+        input
+      ), path);
+      continue;
+    }
+    collectFocusMarker(input, path, changesDir, result);
+  }
+}
+async function inspectArchiveGroup(group, groupPath, result) {
+  const entries = await readDirectory(groupPath, group, result);
+  if (!entries)
+    return;
+  for (const entry of entries) {
+    const input = `${group}/${entry.name}`;
+    const path = join5(groupPath, entry.name);
+    if (!entry.isFile() || !entry.name.endsWith(".md")) {
+      addArchivePathDiagnostic(result, input, path);
+      continue;
+    }
+    result.files.push(path);
+  }
+}
+function collectFocusMarker(input, path, changesDir, result) {
+  try {
+    const ref = resolveWorkRef(input, { changesDir, executable: true });
+    result.markers.push({ name: ref.name, path });
+  } catch (error) {
+    if (!(error instanceof WorkRefError))
+      throw error;
+    addDiagnostic(result, error, path);
+  }
+}
+function collectResolvedPath(path, changesDir, result) {
+  try {
+    const ref = resolveWorkRefPath(path, { changesDir });
+    if (isExecutableWorkRef(ref))
+      result.changes.push(ref);
+    else
+      result.briefs.push(ref);
+  } catch (error) {
+    if (!(error instanceof WorkRefError))
+      throw error;
+    addDiagnostic(result, error, path);
+  }
+}
+async function readDirectory(path, input, result) {
+  try {
+    return (await readdir4(path, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
+  } catch (error) {
+    addDiagnostic(result, asReadFailure(path, input, error), path);
+    return null;
+  }
+}
+function addInvalidEntryDiagnostic(result, input, path) {
+  addDiagnostic(result, new WorkRefError(
+    "invalid_work_ref_path",
+    `unsupported entry in the open-work tree: ${path}`,
+    input
+  ), path);
+}
+function addArchivePathDiagnostic(result, input, path) {
+  addDiagnostic(result, new WorkRefError(
+    "invalid_archive_path",
+    `unsupported entry in the archive tree: ${path}`,
+    input
+  ), path);
+}
+function addDiagnostic(result, error, path) {
+  if (result.diagnostics.some((item) => item.code === error.code && item.input === error.input))
+    return;
+  result.diagnostics.push({ code: error.code, input: error.input, path, message: error.message });
+}
+function assertNoIdentityCollision(changesDir, segments, input, finalFilename) {
+  for (let depth = 1; depth <= segments.length; depth++) {
+    const identityPath = join5(changesDir, ...segments.slice(0, depth));
+    const filePath = finalFilename && depth === segments.length ? join5(changesDir, ...segments.slice(0, -1), finalFilename) : `${identityPath}.md`;
+    const fileKind = getPathKind(filePath, input);
+    const identityKind = getPathKind(identityPath, input);
+    const isPrefix = depth < segments.length;
+    const isFlatIdentity = segments.length === 1;
+    const identity = segments.slice(0, depth).join("/");
+    if (fileKind !== "missing" && fileKind !== "file") {
+      throw new WorkRefError(
+        "work_ref_not_file",
+        `open work path is not a regular file: ${filePath}`,
+        input
+      );
+    }
+    if (fileKind === "file" && identityKind === "directory" || isPrefix && fileKind === "file" || isFlatIdentity && identityKind === "directory") {
+      throw new WorkRefError(
+        "work_ref_collision",
+        `work identity "${identity}" is or would be claimed by both a file and a directory`,
+        input
+      );
+    }
+    if (isPrefix && identityKind !== "missing" && identityKind !== "directory") {
+      throw new WorkRefError(
+        "invalid_work_ref_path",
+        `open work path must be a real directory: ${identityPath}`,
+        input
+      );
+    }
+    if (!isPrefix && !isFlatIdentity && identityKind === "directory") {
+      throw new WorkRefError(
+        "unsupported_work_depth",
+        `work identity "${identity}" exceeds the supported one-level Change Group depth`,
+        input
+      );
+    }
+    if (!isPrefix && identityKind !== "missing" && identityKind !== "directory") {
+      throw new WorkRefError(
+        "invalid_work_ref_path",
+        `unsupported entry in the open-work tree: ${identityPath}`,
+        input
+      );
+    }
+  }
+}
+function assertValidWorkRoot(changesDir, input) {
+  assertManagedRoot(changesDir, input, "invalid_work_root", "open work root");
+}
+function assertManagedRoot(path, input, code, label, allowMissing = false) {
+  try {
+    requireManagedDirectory(path, label, { allowMissing });
+  } catch (error) {
+    if (error instanceof ManagedPathError)
+      throw new WorkRefError(code, error.message, input);
+    throw error;
+  }
+}
+function assertOptionalManagedDirectory(path, input, code, label) {
+  try {
+    requireManagedDirectory(path, label, { allowMissing: true });
+  } catch (error) {
+    if (error instanceof ManagedPathError)
+      throw new WorkRefError(code, error.message, input);
+    throw error;
+  }
+}
+function getPathKind(path, input) {
+  try {
+    const stats = lstatSync2(path);
+    if (stats.isFile())
+      return "file";
+    if (stats.isDirectory())
+      return "directory";
+    return "other";
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return "missing";
+    throw asReadFailure(path, input, error);
+  }
+}
+function asReadFailure(path, input, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return new WorkRefError(
+    "work_tree_read_failed",
+    `unable to inspect open work path ${path}: ${message}`,
+    input
+  );
+}
+function normalizeLogicalPath2(path) {
+  return path.split("\\").join("/");
+}
+
+// src/core/change-group.ts
+var GROUP_BRIEF_SECTIONS = ["Goal", "Scope", "Shared Constraints", "Slices", "Completion Conditions", "Durable Outcomes", "Blockers"];
+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 = "") {
+  return `---
+kind: group
+---
+
+# Change Group: ${name}
+
+## Goal
+- ${goal || "<what shared outcome this group must deliver>"}
+
+## Scope
+- <what is coordinated by this group>
+
+## Shared Constraints
+- <constraint shared by every child Change>
+
+## Slices
+- \`${name}/<change>\`: <independently executable boundary>
+
+## Completion Conditions
+- [ ] <end-to-end condition beyond individual child verification>
+
+## Durable Outcomes
+- Current facts: <Spec, CONTEXT.md, scoped instruction target, or none>
+- Lasting rationale: <Decision Record target, or none>
+
+## 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 openGroupNames = new Set(workTree.briefs.map((brief) => brief.group));
+  for (const path of archiveTree.files) {
+    const archivePath = normalizeLogicalPath(relative4(ARCHIVES_DIR, path));
+    const archiveGroup = archivePath.includes("/") ? archivePath.split("/")[0] : null;
+    if (!archiveGroup || !openGroupNames.has(archiveGroup))
+      continue;
+    try {
+      const content = await readFile3(path, "utf-8");
+      const 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)) {
+          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 (new RegExp(`^# Change Group:\\s+${escapeRegExp(archiveGroup)}\\s*$`, "m").test(content))
+        archivedGroups.add(archiveGroup);
+    } catch (error) {
+      diagnostics.push({
+        severity: "error",
+        code: "group_archive_read_failed",
+        change: archiveGroup,
+        path,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  for (const brief of workTree.briefs) {
+    let content;
+    try {
+      content = await readFile3(brief.path, "utf-8");
+    } catch (error) {
+      diagnostics.push({
+        severity: "error",
+        code: "group_brief_read_failed",
+        change: brief.group,
+        path: brief.path,
+        message: error instanceof Error ? error.message : String(error)
+      });
+      continue;
+    }
+    const parsed = parseGroupBrief(brief.group, content);
+    diagnostics.push(...parsed.diagnostics.map((diagnostic) => ({ ...diagnostic, path: brief.path })));
+    if (archivedGroups.has(brief.group)) {
+      diagnostics.push({
+        severity: "error",
+        code: "group_identity_reopened",
+        change: brief.group,
+        path: brief.path,
+        message: `archived Change Group cannot be reopened: ${brief.group}`
+      });
+    }
+    for (const diagnostic of archiveTree.diagnostics.filter((item) => {
+      if (item.code === "invalid_archive_root")
+        return true;
+      const archivePath = normalizeLogicalPath(relative4(ARCHIVES_DIR, item.path));
+      return archivePath === brief.group || archivePath.startsWith(`${brief.group}/`);
+    })) {
+      diagnostics.push({
+        severity: "error",
+        code: diagnostic.code,
+        change: brief.group,
+        path: diagnostic.path,
+        message: diagnostic.message
+      });
+    }
+    for (const diagnostic of focusTree.diagnostics.filter((item) => item.input.startsWith(`${brief.group}/`))) {
+      diagnostics.push({
+        severity: "error",
+        code: "group_focus_invalid",
+        change: brief.group,
+        path: diagnostic.path,
+        message: `invalid focus for ${diagnostic.input}: ${diagnostic.message}`
+      });
+    }
+    const openChildren = new Set(workTree.changes.filter((ref) => ref.group === brief.group).map((ref) => ref.name));
+    const archivedSlices = archivedSlicesByGroup.get(brief.group) ?? /* @__PURE__ */ new Set();
+    const slices = parsed.slices.map((slice) => {
+      const state = openChildren.has(slice.name) ? "open" : archivedSlices.has(slice.name) ? "archived" : "missing";
+      return { ...slice, state };
+    });
+    const focusedNames = new Set(focusTree.markers.map((marker) => marker.name));
+    for (const slice of slices.filter((slice2) => slice2.state !== "open" && focusedNames.has(slice2.name))) {
+      diagnostics.push({
+        severity: "error",
+        code: "group_focus_invalid",
+        change: brief.group,
+        path: focusTree.markers.find((marker) => marker.name === slice.name)?.path,
+        message: `invalid focus for ${slice.name}: focused group slice is not open`
+      });
+    }
+    const declared = new Set(slices.map((slice) => slice.name));
+    for (const child of [...openChildren].filter((name) => !declared.has(name)).sort()) {
+      diagnostics.push({
+        severity: "error",
+        code: "group_child_undeclared",
+        change: brief.group,
+        path: brief.path,
+        message: `open child Change is not declared by the Group Brief: ${child}`
+      });
+    }
+    for (const child of [...archivedSlices].filter((name) => !declared.has(name)).sort()) {
+      diagnostics.push({
+        severity: "error",
+        code: "group_archived_child_undeclared",
+        change: brief.group,
+        path: brief.path,
+        message: `archived child Change is not declared by the Group Brief: ${child}`
+      });
+    }
+    for (const slice of slices.filter((slice2) => slice2.state === "missing")) {
+      diagnostics.push({
+        severity: "error",
+        code: "group_slice_missing",
+        change: brief.group,
+        path: brief.path,
+        message: `declared group slice is neither open nor archived: ${slice.name}`
+      });
+    }
+    const warnings = parsed.diagnostics.filter((diagnostic) => diagnostic.severity === "warning").map((diagnostic) => diagnostic.message);
+    const readyToClose = diagnostics.every((diagnostic) => diagnostic.change !== brief.group || diagnostic.severity !== "error") && slices.length >= 2 && slices.every((slice) => slice.state === "archived") && parsed.completion.total > 0 && parsed.completion.done === parsed.completion.total && !parsed.blockers;
+    groups.push({
+      name: brief.group,
+      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 };
+}
+async function requireDeclaredGroupSlice(ref) {
+  const briefPath = join6(dirname4(ref.path), GROUP_BRIEF_FILENAME);
+  let content;
+  try {
+    content = await readFile3(briefPath, "utf-8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new WorkRefError("work_tree_read_failed", `unable to read Group Brief ${briefPath}: ${message}`, ref.name);
+  }
+  const parsed = parseGroupBrief(ref.group, 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(relative4(ARCHIVES_DIR, path)).startsWith(groupPrefix))
+      continue;
+    let content;
+    try {
+      content = await readFile3(path, "utf-8");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new WorkRefError("work_tree_read_failed", `unable to inspect archived Change Group identity at ${path}: ${message}`, group);
+    }
+    if (new RegExp(`^# Change Group:\\s+${escapeRegExp(group)}\\s*$`, "m").test(content))
+      return true;
+  }
+  return false;
+}
+function parseGroupBrief(group, content) {
+  const diagnostics = [];
+  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 (!new RegExp(`^# Change Group:\\s+${escapeRegExp(group)}\\s*$`, "m").test(content))
+    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}` });
+  }
+  const slices = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of extractSection(content, "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 (!new RegExp(`^${escapeRegExp(group)}/[a-z0-9-]+$`).test(name) || name === `${group}/brief`) {
+      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(extractSection(content, "Completion Conditions"));
+  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),
+    diagnostics
+  };
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/core/dependency-plan.ts
+import { readFile as readFile4 } 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) => ({
+    severity: "error",
+    code: diagnostic.code,
+    path: diagnostic.path,
+    message: diagnostic.message
+  }));
+  for (const path of archiveTree.files) {
+    try {
+      const heading = (await readFile4(path, "utf-8")).match(/^# Change:\s+(\S+)\s*$/m);
+      if (heading)
+        archivedNames.add(heading[1]);
+    } catch (error) {
+      diagnostics.push({
+        severity: "error",
+        code: "dependency_archive_read_failed",
+        path,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  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 (!EXECUTABLE_WORK_REF_RE.test(required)) {
+        diagnostics.push({
+          severity: "error",
+          code: "dependency_target_invalid",
+          change,
+          message: `dependency target must be an executable Change WorkRef: ${required}`
+        });
+      } else if (required === change) {
+        diagnostics.push({
+          severity: "error",
+          code: "dependency_self_reference",
+          change,
+          message: "Change cannot require itself"
+        });
+      } else if (edge.state === "missing") {
+        diagnostics.push({
+          severity: "error",
+          code: "dependency_target_missing",
+          change,
+          message: `dependency target is neither open nor archived: ${required}`
+        });
+      }
+    }
+  }
+  edges.sort(compareEdges);
+  diagnostics.push(...findCycleDiagnostics(edges));
+  const activeBlockers = /* @__PURE__ */ new Map();
+  const blocked = [...parsedByName].map(([change, blockers]) => {
+    const requires = edges.filter((edge) => edge.change === change && edge.state !== "archived").map((edge) => edge.requires).sort();
+    activeBlockers.set(change, blockers.external || requires.length > 0);
+    return { change, requires, external: blockers.external };
+  }).filter((blocker) => blocker.external || blocker.requires.length > 0).sort((left, right) => left.change.localeCompare(right.change));
+  const waves = buildWaves([...openNames], edges, parsedByName, options.preferredOrder ?? []);
+  const graphValid = diagnostics.every((diagnostic) => diagnostic.severity !== "error");
+  if (!graphValid) {
+    for (const name of openNames)
+      activeBlockers.set(name, true);
+  }
+  const ready = graphValid ? waves[0] ?? [] : [];
+  const executable = new Set(graphValid ? waves.flat() : []);
+  const nodes = [.../* @__PURE__ */ new Set([...openNames, ...edges.map((edge) => edge.requires)])].sort().map((name) => {
+    let state;
+    if (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 = [];
+  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();
+  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 });
+  diagnostics.push(...groupInspection.diagnostics);
+  const dependencyInspection = await inspectChangeDependencies({
+    workTree,
+    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 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;
+    if (path) {
+      try {
+        const content = await readFile5(path, "utf-8");
+        title = extractChangeTitle(content) ?? name;
+        blockerEntries = extractBlockerEntries(content);
+        try {
+          const frontmatter = parseFrontmatter(content);
+          kind = frontmatter?.kind ? String(frontmatter.kind) : "\u2014";
+        } catch (error) {
+          kind = "(invalid)";
+          runtime.push({
+            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 stat2(path);
+        ageDays = Math.floor((nowMs - metadata.mtime.getTime()) / (1e3 * 60 * 60 * 24));
+      } catch (error) {
+        diagnostics.push({
+          severity: "error",
+          code: "change_stat_failed",
+          change: name,
+          path,
+          message: "unable to inspect open Change metadata",
+          hint: toErrorMessage(error)
+        });
+        runtime.push({
+          code: "change_stat_failed",
+          operation: "stat",
+          path,
+          message: toErrorMessage(error)
+        });
+      }
+    } else {
+      kind = "(missing)";
+      const path2 = focusedPaths.get(name);
+      diagnostics.push({
+        severity: "error",
+        code: "focused_change_missing",
+        change: name,
+        path: path2,
+        message: "focus marker points to a missing Change file"
+      });
+      runtime.push({
+        code: "focused_change_missing",
+        operation: "resolveChange",
+        path: path2,
+        message: "focus marker points to a missing change file"
+      });
+    }
+    records.push({
+      output: {
+        name,
+        kind,
+        progress: { done, total },
+        ageDays,
+        isFocused,
+        isBlocked,
+        path: path ? normalizeLogicalPath(path) : null
+      },
+      progressKnown,
+      title,
+      blockerEntries,
+      readiness
+    });
+  }
+  return {
+    focused: [...focusedSet].sort(),
+    records,
+    groups: groupInspection.groups,
+    plan: dependencyInspection.plan,
+    archiveTrend: await readArchiveTrend(runtime),
+    diagnostics,
+    runtime
+  };
+}
+function emptyReadiness(activeBlockers) {
+  return {
+    incompleteTasks: 0,
+    incompleteVerify: 0,
+    activeBlockers,
+    missingScenarios: false,
+    deterministic: "pass",
+    semantic: "needs-review",
+    archiveReady: activeBlockers ? "no" : "judgment"
+  };
+}
+function extractChangeTitle(content) {
+  const heading = content.split(/\r?\n/).find((line) => line.startsWith("# Change: "));
+  return heading?.slice("# Change: ".length).trim() || null;
+}
+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");
+}
+async function readArchiveTrend(runtime) {
+  const indexPath = join7(ARCHIVES_DIR, "INDEX.md");
+  if (!existsSync3(indexPath))
+    return [];
+  try {
+    const content = await readFile5(indexPath, "utf-8");
+    const dateRe = /^\| (\d{4}-\d{2})-\d{2} \|/gm;
+    const counts = {};
+    let match;
+    while ((match = dateRe.exec(content)) !== null) {
+      const month = match[1];
+      counts[month] = (counts[month] || 0) + 1;
+    }
+    return Object.keys(counts).sort().map((month) => ({ month, count: counts[month] }));
+  } catch (error) {
+    runtime.push({
+      code: "archive_index_read_failed",
+      operation: "readFile",
+      path: indexPath,
+      message: toErrorMessage(error)
+    });
+    return [];
+  }
+}
+
+// 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
+import { readFile as readFile6 } from "fs/promises";
+import { basename as basename2, dirname as dirname5, relative as relative5 } from "path";
+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 = 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 readFile6(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 = basename2(sourcePath).match(ARCHIVE_NAME_RE);
+  if (!nameMatch || !isCalendarDate(nameMatch[1])) {
+    return { diagnostic: errorDiagnostic("archive_name_invalid", path, "archive filename must use a valid YYYY-MM-DD_name.md date") };
+  }
+  const date = nameMatch[1];
+  const archiveStem = nameMatch[2];
+  const relativeDirectory = normalizeLogicalPath(relative5(archivesDir, dirname5(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
+    }
+  };
+}
+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(relative5(archivesDir, sourcePath))}`;
+}
+function normalizeOutputPath(path, archivesDir) {
+  const relativePath = normalizeLogicalPath(relative5(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
+import { readFile as readFile7 } from "fs/promises";
+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)).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");
+}
+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 readFile7(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 { 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/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 {
+  ManagedPathError,
+  inspectManagedDirectory,
+  requireManagedDirectory,
+  inspectManagedFile,
+  ensureManagedFile,
+  writeManagedFile,
+  resolveManagedDirectoryChain,
+  inspectManagedFileTree,
+  DEFAULT_DECISION_RECORDS_PATH,
+  resolveDecisionRecordsPath,
+  ensureDecisionRecordsDirectory,
+  validateDecisionRecordsFilesystemPath,
+  toErrorMessage,
+  emitJson,
+  recordRuntimeDiagnostic,
+  parseFrontmatter,
+  countCheckboxes,
+  walkMarkdownFiles,
+  inspectUnsupportedRules,
+  normalizeLogicalPath,
+  generateChangeContent,
+  upsertRspAgentsBlock,
+  hasRspAgentsBlock,
+  isValidSpecName,
+  guardRspInitialized,
+  cleanupEmptyParentDirs,
+  detectProjectName,
+  generateDesignContent,
+  generateSpecContent,
+  extractSection,
+  hasMeaningfulBlockers,
+  detectDeltaSections,
+  collectArchiveReadiness,
+  buildDurableReviewGuidance,
+  getDurableReviewCandidateTargets,
+  collectArchiveChecklist,
+  parseScenarios,
+  pc,
+  PKG_ROOT,
+  RSP_DIR,
+  RSP_RULES_PATH,
+  OBSOLETE_RSP_RULES_PATH,
+  CHANGES_DIR,
+  FOCUS_DIR,
+  ARCHIVES_DIR,
+  LOCK_PATH,
+  CONFIG_PATH,
+  VALID_KINDS,
+  loadRspConfig,
+  inspectRspConfig,
+  clearConfigCache,
+  resolveKinds,
+  resolveRequiredSections,
+  getVersion,
+  GROUP_BRIEF_FILENAME,
+  WorkRefError,
+  resolveWorkRef,
+  resolveFocusMarkerPath,
+  resolveArchiveDirectory,
+  inspectFocusTree,
+  inspectArchiveTree,
+  inspectWorkTree,
+  resolveExecutableChange,
+  generateGroupBriefContent,
+  inspectChangeGroups,
+  hasArchivedGroupBrief,
+  inspectChangeDependencies,
+  HISTORY_DEFAULT_LIMIT,
+  HISTORY_MAX_LIMIT,
+  ArchiveHistoryError,
+  inspectArchiveHistory,
+  queryArchiveHistory,
+  selectArchiveHistoryRecord,
+  readArchiveHistoryDetail,
+  historyInspectionComplete,
+  inspectProjectStatus,
+  projectDependencyForest
+};