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

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

@@ -1,947 +1,37 @@
 #!/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}`)}`);
-  }
-}
+import {
+  ARCHIVES_DIR,
+  CHANGES_DIR,
+  CONFIG_PATH,
+  FOCUS_DIR,
+  ManagedPathError,
+  collectArchiveReadiness,
+  countCheckboxes,
+  extractBlockerLines,
+  extractSection,
+  hasMeaningfulBlockers,
+  inspectManagedDirectory,
+  inspectRspConfig,
+  normalizeLogicalPath,
+  parseFrontmatter,
+  parseScenarios,
+  requireManagedDirectory,
+  requireManagedFile,
+  resolveManagePolicy,
+  toErrorMessage
+} from "./chunk-OTJFL6XH.mjs";
 
 // 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";
+import { readFile as readFile5, stat } from "fs/promises";
 
 // src/core/change-group.ts
-import { readFile as readFile3 } from "fs/promises";
-import { dirname as dirname4, join as join6, relative as relative4 } from "path";
+import { readFile } from "fs/promises";
+import { dirname, join as join2, relative as relative2 } 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";
+import { lstatSync } from "fs";
+import { readdir } from "fs/promises";
+import { isAbsolute, join, relative } from "path";
 var WORK_SEGMENT_RE = /^[a-z0-9-]+$/;
 var GROUP_BRIEF_FILENAME = "00-brief.md";
 var WorkRefError = class extends Error {
@@ -981,7 +71,7 @@ function resolveWorkRef(name, options = {}) {
   }
   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 path = join(changesDir, ...segments.slice(0, -1), isGroupBrief ? GROUP_BRIEF_FILENAME : `${segments.at(-1)}.md`);
   const ref = segments.length === 1 ? { kind: "change", name, path, group: null } : isGroupBrief ? { kind: "group-brief", name, path, group: segments[0] } : { kind: "group-change", name, path, group: segments[0] };
   if (ref.kind === "group-change" && options.executable !== false)
     assertGroupBrief(changesDir, ref);
@@ -996,7 +86,7 @@ function resolveWorkRef(name, options = {}) {
   return ref;
 }
 function assertGroupBrief(changesDir, ref) {
-  const briefPath = join5(changesDir, ref.group, GROUP_BRIEF_FILENAME);
+  const briefPath = join(changesDir, ref.group, GROUP_BRIEF_FILENAME);
   const kind = getPathKind(briefPath, ref.name);
   if (kind === "missing") {
     throw new WorkRefError(
@@ -1016,7 +106,7 @@ function assertGroupBrief(changesDir, ref) {
 function assertRegularWorkFile(ref, mustExist) {
   let stats;
   try {
-    stats = lstatSync2(ref.path);
+    stats = lstatSync(ref.path);
   } catch (error) {
     if (error.code === "ENOENT") {
       if (mustExist) {
@@ -1040,8 +130,8 @@ function assertRegularWorkFile(ref, mustExist) {
 }
 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")) {
+  const logicalPath = normalizeLogicalPath2(relative(changesDir, path));
+  if (isAbsolute(logicalPath) || logicalPath === ".." || logicalPath.startsWith("../") || !logicalPath.endsWith(".md")) {
     throw new WorkRefError(
       "invalid_work_ref_path",
       `work path must be a Markdown file inside ${changesDir}: ${path}`,
@@ -1067,13 +157,13 @@ function resolveFocusMarkerPath(ref, options = {}) {
   assertManagedRoot(focusDir, ref.name, "invalid_focus_root", "focus root", true);
   if (ref.group) {
     assertOptionalManagedDirectory(
-      join5(focusDir, ref.group),
+      join(focusDir, ref.group),
       ref.name,
       "invalid_focus_path",
       "focus path"
     );
   }
-  const markerPath = join5(focusDir, ...ref.name.split("/"));
+  const markerPath = join(focusDir, ...ref.name.split("/"));
   try {
     requireManagedFile(markerPath, "focus marker", { allowMissing: true });
   } catch (error) {
@@ -1088,7 +178,7 @@ function resolveArchiveDirectory(ref, options = {}) {
   assertManagedRoot(archivesDir, ref.name, "invalid_archive_root", "archive root", true);
   if (!ref.group)
     return archivesDir;
-  const groupPath = join5(archivesDir, ref.group);
+  const groupPath = join(archivesDir, ref.group);
   assertOptionalManagedDirectory(groupPath, ref.name, "invalid_archive_path", "archive path");
   return groupPath;
 }
@@ -1107,7 +197,7 @@ async function inspectFocusTree(options = {}) {
   if (!rootEntries)
     return result;
   for (const entry of rootEntries) {
-    const path = join5(focusDir, entry.name);
+    const path = join(focusDir, entry.name);
     if (entry.name === ".gitkeep" && entry.isFile())
       continue;
     if (entry.isDirectory()) {
@@ -1150,7 +240,7 @@ async function inspectArchiveTree(options = {}) {
   if (!rootEntries)
     return result;
   for (const entry of rootEntries) {
-    const path = join5(archivesDir, entry.name);
+    const path = join(archivesDir, entry.name);
     if (entry.name === "INDEX.md" && entry.isFile())
       continue;
     if (entry.isDirectory()) {
@@ -1188,7 +278,7 @@ async function inspectWorkTree(options = {}) {
   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);
+    const path = join(changesDir, entry.name);
     if (entry.name === ".gitkeep" && entry.isFile())
       continue;
     if (entry.isDirectory()) {
@@ -1235,17 +325,17 @@ async function inspectGroupDirectory(group, groupPath, changesDir, result, colli
       "group_brief_missing",
       `Change Group "${group}" requires a Group Brief; run: rsp group create ${group}`,
       group
-    ), join5(groupPath, GROUP_BRIEF_FILENAME));
+    ), join(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 Brief must be a regular file: ${join(groupPath, GROUP_BRIEF_FILENAME)}`,
       group
-    ), join5(groupPath, GROUP_BRIEF_FILENAME));
+    ), join(groupPath, GROUP_BRIEF_FILENAME));
   }
   for (const entry of entries) {
     const input = `${group}/${entry.name}`;
-    const path = join5(groupPath, entry.name);
+    const path = join(groupPath, entry.name);
     if (entry.name === GROUP_BRIEF_FILENAME && !entry.isFile())
       continue;
     if (entry.name === "brief.md") {
@@ -1274,7 +364,7 @@ async function inspectFocusGroup(group, groupPath, changesDir, result) {
     return;
   for (const entry of entries) {
     const input = `${group}/${entry.name}`;
-    const path = join5(groupPath, entry.name);
+    const path = join(groupPath, entry.name);
     if (entry.isDirectory()) {
       addDiagnostic(result, new WorkRefError(
         "unsupported_work_depth",
@@ -1300,7 +390,7 @@ async function inspectArchiveGroup(group, groupPath, result) {
     return;
   for (const entry of entries) {
     const input = `${group}/${entry.name}`;
-    const path = join5(groupPath, entry.name);
+    const path = join(groupPath, entry.name);
     if (!entry.isFile() || !entry.name.endsWith(".md")) {
       addArchivePathDiagnostic(result, input, path);
       continue;
@@ -1333,7 +423,7 @@ function collectResolvedPath(path, changesDir, result) {
 }
 async function readDirectory(path, input, result) {
   try {
-    return (await readdir4(path, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
+    return (await readdir(path, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
   } catch (error) {
     addDiagnostic(result, asReadFailure(path, input, error), path);
     return null;
@@ -1360,8 +450,8 @@ function addDiagnostic(result, error, path) {
 }
 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 identityPath = join(changesDir, ...segments.slice(0, depth));
+    const filePath = finalFilename && depth === segments.length ? join(changesDir, ...segments.slice(0, -1), finalFilename) : `${identityPath}.md`;
     const fileKind = getPathKind(filePath, input);
     const identityKind = getPathKind(identityPath, input);
     const isPrefix = depth < segments.length;
@@ -1427,7 +517,7 @@ function assertOptionalManagedDirectory(path, input, code, label) {
 }
 function getPathKind(path, input) {
   try {
-    const stats = lstatSync2(path);
+    const stats = lstatSync(path);
     if (stats.isFile())
       return "file";
     if (stats.isDirectory())
@@ -1499,12 +589,12 @@ async function inspectChangeGroups(options = {}) {
   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 archivePath = normalizeLogicalPath(relative2(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 content = await readFile(path, "utf-8");
       const heading = content.match(/^# Change:\s+(\S+)\s*$/m);
       if (heading?.[1]?.includes("/")) {
         const identity = heading[1];
@@ -1537,7 +627,7 @@ async function inspectChangeGroups(options = {}) {
   for (const brief of workTree.briefs) {
     let content;
     try {
-      content = await readFile3(brief.path, "utf-8");
+      content = await readFile(brief.path, "utf-8");
     } catch (error) {
       diagnostics.push({
         severity: "error",
@@ -1562,7 +652,7 @@ async function inspectChangeGroups(options = {}) {
     for (const diagnostic of archiveTree.diagnostics.filter((item) => {
       if (item.code === "invalid_archive_root")
         return true;
-      const archivePath = normalizeLogicalPath(relative4(ARCHIVES_DIR, item.path));
+      const archivePath = normalizeLogicalPath(relative2(ARCHIVES_DIR, item.path));
       return archivePath === brief.group || archivePath.startsWith(`${brief.group}/`);
     })) {
       diagnostics.push({
@@ -1642,10 +732,10 @@ async function inspectChangeGroups(options = {}) {
   return { groups, diagnostics };
 }
 async function requireDeclaredGroupSlice(ref) {
-  const briefPath = join6(dirname4(ref.path), GROUP_BRIEF_FILENAME);
+  const briefPath = join2(dirname(ref.path), GROUP_BRIEF_FILENAME);
   let content;
   try {
-    content = await readFile3(briefPath, "utf-8");
+    content = await readFile(briefPath, "utf-8");
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new WorkRefError("work_tree_read_failed", `unable to read Group Brief ${briefPath}: ${message}`, ref.name);
@@ -1675,11 +765,11 @@ async function hasArchivedGroupBrief(group) {
   }
   const groupPrefix = `${group}/`;
   for (const path of archiveTree.files) {
-    if (!normalizeLogicalPath(relative4(ARCHIVES_DIR, path)).startsWith(groupPrefix))
+    if (!normalizeLogicalPath(relative2(ARCHIVES_DIR, path)).startsWith(groupPrefix))
       continue;
     let content;
     try {
-      content = await readFile3(path, "utf-8");
+      content = await readFile(path, "utf-8");
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       throw new WorkRefError("work_tree_read_failed", `unable to inspect archived Change Group identity at ${path}: ${message}`, group);
@@ -1751,7 +841,7 @@ function escapeRegExp(value) {
 }
 
 // src/core/dependency-plan.ts
-import { readFile as readFile4 } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 var NONE_BLOCKER_RE = /^[-*]\s*(?:none)?$/i;
 var REQUIRES_RE = /^[-*]\s+requires\s+`([^`]+)`:[ \t]*(\S.*)$/i;
 var EXECUTABLE_WORK_REF_RE = /^[a-z0-9-]+(?:\/(?!(?:brief|00-brief)$)[a-z0-9-]+)?$/;
@@ -1770,7 +860,7 @@ async function inspectChangeDependencies(options = {}) {
   }));
   for (const path of archiveTree.files) {
     try {
-      const heading = (await readFile4(path, "utf-8")).match(/^# Change:\s+(\S+)\s*$/m);
+      const heading = (await readFile2(path, "utf-8")).match(/^# Change:\s+(\S+)\s*$/m);
       if (heading)
         archivedNames.add(heading[1]);
     } catch (error) {
@@ -1784,7 +874,7 @@ async function inspectChangeDependencies(options = {}) {
   }
   for (const brief of workTree.briefs) {
     try {
-      if (hasMeaningfulBlockers(await readFile4(brief.path, "utf-8")))
+      if (hasMeaningfulBlockers(await readFile2(brief.path, "utf-8")))
         blockedGroups.add(brief.group);
     } catch (error) {
       diagnostics.push({
@@ -1798,7 +888,7 @@ async function inspectChangeDependencies(options = {}) {
   }
   for (const ref of workTree.changes) {
     try {
-      const parsed = parseDependencyBlockers(await readFile4(ref.path, "utf-8"));
+      const parsed = parseDependencyBlockers(await readFile2(ref.path, "utf-8"));
       if (ref.group && blockedGroups.has(ref.group))
         parsed.external = true;
       parsedByName.set(ref.name, parsed);
@@ -1875,7 +965,7 @@ async function inspectChangeDependencies(options = {}) {
   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))
+    if (!openNames.has(name) && archivedNames.has(name))
       state = "archived";
     else if (!openNames.has(name))
       state = "missing";
@@ -2012,223 +1102,12 @@ function findCycleDiagnostics(edges) {
   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/query.ts
+import { readFile as readFile4 } from "fs/promises";
+
+// src/history/inspect.ts
+import { readFile as readFile3 } from "fs/promises";
+import { basename, dirname as dirname2, relative as relative3 } from "path";
 
 // src/history/model.ts
 var HISTORY_DEFAULT_LIMIT = 20;
@@ -2254,14 +1133,12 @@ var ArchiveHistoryError = class extends Error {
 };
 
 // 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 tree = options.archiveTree ?? await inspectArchiveTree({ archivesDir });
   const diagnostics = tree.diagnostics.map((diagnostic) => ({
     severity: "error",
     code: diagnostic.code,
@@ -2282,7 +1159,7 @@ async function inspectArchiveHistory(options = {}) {
     const path = archiveOutputPath(sourcePath, archivesDir);
     let content;
     try {
-      content = await readFile6(sourcePath, "utf-8");
+      content = await readFile3(sourcePath, "utf-8");
     } catch (error) {
       const message = toErrorMessage(error);
       diagnostics.push({ severity: "error", code: "archive_read_failed", path, message: `unable to read archived work: ${message}` });
@@ -2311,13 +1188,13 @@ async function inspectArchiveHistory(options = {}) {
   };
 }
 function parseArchiveEntry(sourcePath, path, archivesDir, content) {
-  const nameMatch = basename2(sourcePath).match(ARCHIVE_NAME_RE);
+  const nameMatch = basename(sourcePath).match(ARCHIVE_NAME_RE);
   if (!nameMatch || !isCalendarDate(nameMatch[1])) {
     return { diagnostic: errorDiagnostic("archive_name_invalid", path, "archive filename must use a valid YYYY-MM-DD_name.md date") };
   }
   const date = nameMatch[1];
   const archiveStem = nameMatch[2];
-  const relativeDirectory = normalizeLogicalPath(relative5(archivesDir, dirname5(sourcePath)));
+  const relativeDirectory = normalizeLogicalPath(relative3(archivesDir, dirname2(sourcePath)));
   const archiveGroup = relativeDirectory === "." || relativeDirectory === "" ? null : relativeDirectory;
   if (archiveGroup && !GROUP_NAME_RE.test(archiveGroup))
     return { diagnostic: errorDiagnostic("archive_identity_mismatch", path, "archive group path is not a valid one-segment Group identity") };
@@ -2364,7 +1241,8 @@ function parseArchiveEntry(sourcePath, path, archivesDir, content) {
       summary: summary.value,
       summaryTruncated: summary.truncated,
       path,
-      sourcePath
+      sourcePath,
+      searchSummary: rawSummary
     }
   };
 }
@@ -2392,10 +1270,10 @@ function isCalendarDate(value) {
   return Number.isFinite(parsed.getTime()) && parsed.toISOString().slice(0, 10) === value;
 }
 function archiveOutputPath(sourcePath, archivesDir) {
-  return `.rsp/archives/${normalizeLogicalPath(relative5(archivesDir, sourcePath))}`;
+  return `.rsp/archives/${normalizeLogicalPath(relative3(archivesDir, sourcePath))}`;
 }
 function normalizeOutputPath(path, archivesDir) {
-  const relativePath = normalizeLogicalPath(relative5(archivesDir, path));
+  const relativePath = normalizeLogicalPath(relative3(archivesDir, path));
   return relativePath === "" ? ".rsp/archives" : `.rsp/archives/${relativePath}`;
 }
 function errorDiagnostic(code, path, message) {
@@ -2412,11 +1290,11 @@ function compareDiagnostics(left, right) {
 }
 
 // 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 matched = records.filter((record) => (!query.since || record.date >= query.since) && (!query.until || record.date <= query.until) && (!query.kind || record.kind === query.kind) && (!query.group || record.group === query.group) && (!query.search || `${record.workRef}
+${record.searchSummary ?? record.summary}`.toLowerCase().includes(query.search.toLowerCase()))).sort(compareHistoryRecords2);
   const selected = matched.slice(0, limit);
   return {
     records: selected.map(toOutputRecord),
@@ -2441,6 +1319,8 @@ function validateArchiveHistoryQuery(query) {
     throw new ArchiveHistoryError("invalid_history_kind", "history kind must be non-empty");
   if (query.group !== void 0 && !/^[a-z0-9-]+$/.test(query.group))
     throw new ArchiveHistoryError("invalid_history_group", "history group must be one lowercase kebab-case segment");
+  if (query.search !== void 0 && query.search.trim() === "")
+    throw new ArchiveHistoryError("invalid_history_search", "history search must be non-empty");
 }
 function selectArchiveHistoryRecord(records, selector) {
   const matches = "path" in selector ? records.filter((record) => record.path === selector.path) : records.filter((record) => record.workRef === selector.workRef);
@@ -2456,7 +1336,7 @@ function selectArchiveHistoryRecord(records, selector) {
 async function readArchiveHistoryDetail(record) {
   let content;
   try {
-    content = await readFile7(record.sourcePath, "utf-8");
+    content = await readFile4(record.sourcePath, "utf-8");
   } catch (error) {
     throw new ArchiveHistoryError("archive_read_failed", `unable to read archived Change ${record.path}: ${error instanceof Error ? error.message : String(error)}`);
   }
@@ -2481,7 +1361,7 @@ function historyInspectionComplete(inspection) {
   return inspection.diagnostics.every((diagnostic) => diagnostic.severity !== "error");
 }
 function toOutputRecord(record) {
-  const { sourcePath: _sourcePath, ...output } = record;
+  const { searchSummary: _searchSummary, sourcePath: _sourcePath, ...output } = record;
   return output;
 }
 function boundEvidence(section, omitNone = false) {
@@ -2502,6 +1382,234 @@ function compareHistoryRecords2(left, right) {
   return right.date.localeCompare(left.date) || left.workRef.localeCompare(right.workRef) || left.path.localeCompare(right.path);
 }
 
+// src/status/inspect.ts
+async function inspectProjectStatus(options = {}) {
+  const runtime = [];
+  const diagnostics = [];
+  let manage = resolveManagePolicy({});
+  try {
+    const configInspection = await inspectRspConfig();
+    const configValid = configInspection.issues.length === 0;
+    manage = resolveManagePolicy(configInspection.config, { configValid });
+    if (!configValid) {
+      diagnostics.push({
+        severity: "error",
+        code: "invalid_config",
+        path: CONFIG_PATH,
+        message: configInspection.issues.join("; ")
+      });
+    }
+  } catch (error) {
+    manage = resolveManagePolicy({}, { configValid: false });
+    diagnostics.push({
+      severity: "error",
+      code: "invalid_config",
+      path: CONFIG_PATH,
+      message: toErrorMessage(error)
+    });
+  }
+  const focusTree = await inspectFocusTree();
+  for (const diagnostic of focusTree.diagnostics) {
+    diagnostics.push({
+      severity: "error",
+      code: diagnostic.code,
+      change: diagnostic.input,
+      path: diagnostic.path,
+      message: diagnostic.message
+    });
+  }
+  const rawFocusedSet = new Set(focusTree.markers.map((marker) => marker.name));
+  const focusedSet = /* @__PURE__ */ new Set();
+  const focusedPaths = /* @__PURE__ */ new Map();
+  for (const name of rawFocusedSet) {
+    try {
+      const ref = resolveWorkRef(name, { executable: true });
+      focusedSet.add(ref.name);
+      focusedPaths.set(ref.name, ref.path);
+    } catch (error) {
+      if (!(error instanceof WorkRefError))
+        throw error;
+      diagnostics.push({
+        severity: "error",
+        code: error.code,
+        path: `.rsp/focus.d/${name}`,
+        change: name,
+        message: error.message
+      });
+    }
+  }
+  const workTree = await inspectWorkTree();
+  const archiveTree = await inspectArchiveTree();
+  const historyInspection = await inspectArchiveHistory({ archiveTree });
+  diagnostics.push(...workTree.diagnostics.map((diagnostic) => ({
+    severity: "error",
+    code: diagnostic.code,
+    change: diagnostic.input,
+    path: diagnostic.path,
+    message: diagnostic.message
+  })));
+  const groupInspection = await inspectChangeGroups({ workTree, focusTree, archiveTree });
+  diagnostics.push(...groupInspection.diagnostics);
+  const dependencyInspection = await inspectChangeDependencies({
+    workTree,
+    archiveTree,
+    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 stat(path);
+        ageDays = Math.floor((nowMs - metadata.mtime.getTime()) / (1e3 * 60 * 60 * 24));
+      } catch (error) {
+        diagnostics.push({
+          severity: "error",
+          code: "change_stat_failed",
+          change: name,
+          path,
+          message: "unable to inspect open Change metadata",
+          hint: toErrorMessage(error)
+        });
+        runtime.push({
+          code: "change_stat_failed",
+          operation: "stat",
+          path,
+          message: toErrorMessage(error)
+        });
+      }
+    } else {
+      kind = "(missing)";
+      const path2 = focusedPaths.get(name);
+      diagnostics.push({
+        severity: "error",
+        code: "focused_change_missing",
+        change: name,
+        path: path2,
+        message: "focus marker points to a missing Change file"
+      });
+      runtime.push({
+        code: "focused_change_missing",
+        operation: "resolveChange",
+        path: path2,
+        message: "focus marker points to a missing change file"
+      });
+    }
+    records.push({
+      output: {
+        name,
+        kind,
+        progress: { done, total },
+        ageDays,
+        isFocused,
+        isBlocked,
+        path: path ? normalizeLogicalPath(path) : null
+      },
+      progressKnown,
+      title,
+      blockerEntries,
+      readiness
+    });
+  }
+  return {
+    manage,
+    focused: [...focusedSet].sort(),
+    records,
+    groups: groupInspection.groups,
+    plan: dependencyInspection.plan,
+    archiveTrend: historyInspectionComplete(historyInspection) ? deriveArchiveTrend(historyInspection.records) : [],
+    diagnostics: [...diagnostics, ...historyInspection.rootExists ? historyInspection.diagnostics : []],
+    runtime: [...runtime, ...historyInspection.runtime]
+  };
+}
+function emptyReadiness(activeBlockers) {
+  return {
+    incompleteTasks: 0,
+    incompleteVerify: 0,
+    activeBlockers,
+    missingScenarios: false,
+    deterministic: "pass",
+    semantic: "needs-review",
+    archiveReady: activeBlockers ? "no" : "judgment"
+  };
+}
+function extractChangeTitle(content) {
+  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");
+}
+function deriveArchiveTrend(records) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const month = record.date.slice(0, 7);
+    counts.set(month, (counts.get(month) ?? 0) + 1);
+  }
+  return [...counts].sort(([left], [right]) => left.localeCompare(right)).map(([month, count]) => ({ month, count }));
+}
+
 // src/status/dependency-forest.ts
 function defaultRoots(plan) {
   const selected = new Set(plan.nodes.filter((node) => node.selection === "selected").map((node) => node.name));
@@ -2538,60 +1646,6 @@ function projectDependencyForest(plan, requestedRoots = defaultRoots(plan)) {
 }
 
 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,