@oevery/rsp 3.1.1 → 3.3.0

package/dist/{chunk-WJXKLLIF.mjs → chunk-7HXQNBIG.mjs}

@@ -1,219 +1,14 @@
 #!/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 { readFile } from "fs/promises";
+import { dirname as dirname2, join as join3, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
 import pc from "picocolors";
+import { parseDocument, stringify, visit } from "yaml";
 
-// 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/content.ts
+import { parse } from "yaml";
 
 // src/core/document-model.ts
 var CHANGE_DOCUMENT_SCHEMA = {
@@ -371,13 +166,7 @@ function lineBreakStart(source, headingStart) {
   return headingStart;
 }
 
-// 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 -->";
+// src/core/content.ts
 function parseYamlText(text) {
   const parsed = parse(text);
   if (parsed === null || parsed === void 0)
@@ -399,518 +188,457 @@ function countCheckboxes(content) {
   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);
+function classifyVerifyCheckboxes(sectionText) {
+  const buckets = collectVerifyCheckboxLines(sectionText);
   return {
-    entries,
-    diagnostics,
-    directoryRemaining: existsSync2(rulesDir) && (!obsoleteFallbackPresent || entries.length > 0)
+    required: countCheckboxes([...buckets.required, ...buckets.unclassified].join("\n")),
+    optional: countCheckboxes(buckets.optional.join("\n")),
+    unclassified: countCheckboxes(buckets.unclassified.join("\n")),
+    legacy: buckets.legacy
   };
 }
-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)
-      });
+function collectVerifyCheckboxLines(sectionText) {
+  const required = [];
+  const optional = [];
+  const unclassified = [];
+  let current = "unclassified";
+  let sawClassificationHeading = false;
+  for (const line of sectionText.split("\n")) {
+    const heading = line.match(/^###\s+(Required|Optional)\s*$/i);
+    if (heading) {
+      current = heading[1].toLowerCase();
+      sawClassificationHeading = true;
+      continue;
     }
+    if (!/^- \[[ /x-]\]/i.test(line.trim()))
+      continue;
+    if (current === "required")
+      required.push(line);
+    else if (current === "optional")
+      optional.push(line);
+    else
+      unclassified.push(line);
   }
-  return entries;
+  return { required, optional, unclassified, legacy: unclassified.length > 0 || !sawClassificationHeading };
 }
-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 getOpenCheckboxes(sectionText) {
+  return sectionText.split("\n").map((line) => line.trim()).filter((line) => /^- \[[ /]\]/.test(line));
 }
-function normalizeLogicalPath(pathValue) {
-  return pathValue.split(sep2).join("/").replace(/\\/g, "/");
+function extractBlockerLines(content) {
+  const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
+  return normalizeBlockerBody(getDocumentSectionBody(document, "blockers"));
 }
-function generateChangeContent(name, summary = "", kind, options = {}) {
-  const placeholder = "<\u2026>";
-  const proposalSummary = summary || placeholder;
-  const issueFrontmatter = renderIssueFrontmatter(options.issues ?? []);
-  if (name === "project-setup") {
-    return `---
-kind: ops
-${issueFrontmatter}---
-
-${renderDocumentTitle(CHANGE_DOCUMENT_SCHEMA, "project-setup")}
-
-${changeSectionHeading("proposal")}
-- Outcome: ${proposalSummary}
-- Why:
-  - ${placeholder}
-- Scope:
-  - ${placeholder}
-- Non-goals:
-  - ${placeholder}
-
-${changeSectionHeading("spec")}
-### ADDED
-- Requirement: ${placeholder}
-  - ${placeholder}
-
-### Acceptance
-#### Scenario: ${placeholder}
-- GIVEN ${placeholder}
-- WHEN ${placeholder}
-- THEN ${placeholder}
-
-${changeSectionHeading("design")}
-- Approach:
-  - ${placeholder}
-- Boundaries:
-  - ${placeholder}
-- Affected areas:
-  - .rsp/specs/design.md
-  - CONTEXT.md
-  - AGENTS.md
-- Durable outcome targets:
-  - Current facts: ${placeholder}
-  - Lasting rationale: ${placeholder}
-- Constraints:
-  - ${placeholder}
-
-${changeSectionHeading("tasks")}
-- [ ] .rsp/specs/design.md: ${placeholder}
-- [ ] CONTEXT.md: ${placeholder}
-- [ ] AGENTS.md: ${placeholder}
-
-${changeSectionHeading("verify")}
-- Automated:
-  - [ ] rsp doctor \u2014 proves: ${placeholder}
-- Manual or environment:
-  - [ ] ${placeholder}
-- Coverage:
-  - ${placeholder}
-
-${changeSectionHeading("blockers")}
-- none
-`;
-  }
-  const frontmatterKind = kind ?? "<choose: feature | fix | refactor | docs | ops | research>";
-  if (options.lite)
-    return generateLiteChangeContent(name, proposalSummary, frontmatterKind, issueFrontmatter);
-  const template = getChangeTemplateByKind(kind);
-  return `---
-kind: "${frontmatterKind}"
-${issueFrontmatter}---
-
-${renderDocumentTitle(CHANGE_DOCUMENT_SCHEMA, name)}
-
-${changeSectionHeading("proposal")}
-- Outcome: ${proposalSummary}
-- Why:
-  - ${template.why}
-- Scope:
-  - ${template.scope}
-- Non-goals:
-  - ${template.nonGoals}
-
-${changeSectionHeading("spec")}
-${template.specSection}
-
-### Acceptance
-${template.acceptanceSection}
-
-${changeSectionHeading("design")}
-- Approach:
-  - ${template.approach}
-- Boundaries:
-  - ${placeholder}
-- Affected areas:
-  - ${template.affectedArea1}
-  - ${template.affectedArea2}
-- Constraints:
-  - ${template.constraints}
-
-${changeSectionHeading("tasks")}
-- [ ] ${template.task}
-
-${changeSectionHeading("verify")}
-- Automated:
-  - [ ] ${template.automatedVerify} \u2014 proves: ${placeholder}
-- Manual or environment:
-  - [ ] ${template.manualVerify}
-- Coverage:
-  - ${placeholder}
-
-${changeSectionHeading("blockers")}
-- none
-`;
+function hasMeaningfulBlockerBody(body) {
+  return hasMeaningfulBlockerLines(normalizeBlockerBody(body));
 }
-function generateLiteChangeContent(name, proposalSummary, frontmatterKind, issueFrontmatter) {
-  const placeholder = "<\u2026>";
-  return `---
-kind: "${frontmatterKind}"
-${issueFrontmatter}---
-
-${renderDocumentTitle(CHANGE_DOCUMENT_SCHEMA, name)}
-
-${changeSectionHeading("proposal")}
-- Outcome: ${proposalSummary}
-- Why:
-  - ${placeholder}
-- Scope:
-  - ${placeholder}
-- Non-goals:
-  - none
-
-${changeSectionHeading("spec")}
-### MODIFIED
-- Requirement: ${placeholder}
-  - ${placeholder}
-
-### Acceptance
-#### Scenario: ${placeholder}
-- GIVEN ${placeholder}
-- WHEN ${placeholder}
-- THEN ${placeholder}
-
-${changeSectionHeading("design")}
-- Approach:
-  - ${placeholder}
-- Boundaries:
-  - ${placeholder}
-- Affected areas:
-  - ${placeholder}
-- Constraints:
-  - ${placeholder}
-
-${changeSectionHeading("tasks")}
-- [ ] ${placeholder}
-
-${changeSectionHeading("verify")}
-- Automated:
-  - [ ] ${placeholder} \u2014 proves: ${placeholder}
-- Manual or environment:
-  - [ ] ${placeholder}
-- Coverage:
-  - ${placeholder}
-
-${changeSectionHeading("blockers")}
-- none
-`;
+function normalizeBlockerBody(body) {
+  return body.replace(/<!--[\s\S]*?-->/g, "").split("\n").map((line) => line.trim()).filter(Boolean);
 }
-function renderIssueFrontmatter(issues) {
-  if (issues.length === 0)
-    return "";
-  return `issues:
-${issues.map((issue) => `  - url: ${JSON.stringify(issue.url)}
-    relation: ${issue.relation}`).join("\n")}
-`;
+function hasMeaningfulBlockers(content) {
+  return hasMeaningfulBlockerLines(extractBlockerLines(content));
+}
+function isEmptyBlockerLine(line) {
+  const normalized = line.trim();
+  return /^none[.。]?$/i.test(normalized) || /^[-*]\s*(?:none[.。]?)?$/i.test(normalized);
+}
+function hasMeaningfulBlockerLines(lines) {
+  if (lines.length === 0)
+    return false;
+  return lines.some((line) => !isEmptyBlockerLine(line));
 }
-function getChangeTemplateByKind(kind) {
-  const placeholder = "<\u2026>";
-  const delta = kind === "feature" || kind === "research" || kind === void 0 ? "ADDED" : "MODIFIED";
+function detectDeltaSections(content) {
+  const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
+  const body = getDocumentSectionBody(document, "spec");
   return {
-    why: placeholder,
-    scope: placeholder,
-    nonGoals: placeholder,
-    specSection: `### ${delta}
-- Requirement: ${placeholder}
-  - ${placeholder}`,
-    acceptanceSection: `#### Scenario: ${placeholder}
-- GIVEN ${placeholder}
-- WHEN ${placeholder}
-- THEN ${placeholder}`,
-    approach: placeholder,
-    affectedArea1: placeholder,
-    affectedArea2: placeholder,
-    constraints: placeholder,
-    task: placeholder,
-    automatedVerify: placeholder,
-    manualVerify: placeholder
+    added: /^###\s*ADDED/im.test(body),
+    modified: /^###\s*MODIFIED/im.test(body),
+    removed: /^###\s*REMOVED/im.test(body)
   };
 }
-function changeSectionHeading(sectionId) {
-  return renderDocumentSectionHeading(CHANGE_DOCUMENT_SCHEMA, sectionId);
+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/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 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 requireManagedDirectory(path, label, options = {}) {
+  const inspection = inspectManagedDirectory(path, label, options);
+  if (inspection.issue)
+    throw inspection.issue;
+  return inspection.exists;
 }
-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 };
+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}`)
+    };
   }
-  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);
+function requireManagedFile(path, label, options = {}) {
+  const inspection = inspectManagedFile(path, label, options);
+  if (inspection.issue)
+    throw inspection.issue;
+  return inspection.exists;
 }
-var SPEC_NAME_RE = /^[a-z0-9-]+(?:\/[a-z0-9-]+)*$/;
-function isValidSpecName(name) {
-  return SPEC_NAME_RE.test(name);
+async function ensureManagedFile(path, content, label) {
+  if (requireManagedFile(path, label, { allowMissing: true }))
+    return false;
+  await writeFile(path, content, { flag: "wx" });
+  return true;
 }
-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);
-  }
+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 getOpenCheckboxes(sectionText) {
-  return sectionText.split("\n").map((line) => line.trim()).filter((line) => /^- \[[ /]\]/.test(line));
+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 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 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 detectProjectName() {
+async function collectManagedFiles(directory, label, result) {
+  let entries;
   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;
+    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;
     }
-  } catch {
+    if (entry.isFile()) {
+      result.files.push(path);
+      continue;
+    }
+    result.issues.push(new ManagedPathError(path, `unsupported entry in the ${label} tree: ${path}`));
   }
-  return basename(process.cwd());
-}
-function generateDesignContent(projectName) {
-  const placeholder = "<\u2026>";
-  return `# Project Design: ${projectName}
-
-## Purpose
-- ${placeholder}
-
-## Stable Facts
-- ${placeholder}
-
-## Boundaries
-- In scope:
-  - ${placeholder}
-- Out of scope:
-  - ${placeholder}
-
-## Structure
-- ${placeholder}
-
-## Constraints
-- ${placeholder}
-`;
 }
-function generateSpecContent(name) {
-  const title = toTitleCase(name);
-  const placeholder = "<\u2026>";
-  return `# ${title}
 
-## Purpose
-- ${placeholder}
-
-## Stable Facts
-- ${placeholder}
-
-## Boundaries
-- In scope:
-  - ${placeholder}
-- Out of scope:
-  - ${placeholder}
-
-## Constraints
-- ${placeholder}
-`;
-}
-function toTitleCase(value) {
-  return value.split(/[-/]/g).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
-}
-function extractBlockerLines(content) {
-  const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
-  return normalizeBlockerBody(getDocumentSectionBody(document, "blockers"));
-}
-function hasMeaningfulBlockerBody(body) {
-  return hasMeaningfulBlockerLines(normalizeBlockerBody(body));
-}
-function normalizeBlockerBody(body) {
-  return body.replace(/<!--[\s\S]*?-->/g, "").split("\n").map((line) => line.trim()).filter(Boolean);
-}
-function hasMeaningfulBlockers(content) {
-  return hasMeaningfulBlockerLines(extractBlockerLines(content));
-}
-function hasMeaningfulBlockerLines(lines) {
-  if (lines.length === 0)
-    return false;
-  return lines.some((line) => !/^[-*]\s*(?:none)?$/i.test(line) && !/^none$/i.test(line));
-}
-function detectDeltaSections(content) {
-  const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
-  const body = getDocumentSectionBody(document, "spec");
-  return {
-    added: /^###\s*ADDED/im.test(body),
-    modified: /^###\s*MODIFIED/im.test(body),
-    removed: /^###\s*REMOVED/im.test(body)
-  };
+// 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 collectArchiveReadiness(content, options = {}) {
-  const warnings = [];
-  const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
-  const tasksSection = getDocumentSectionBody(document, "tasks");
-  const verifySection = getDocumentSectionBody(document, "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 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 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 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 getDurableReviewCandidateTargets() {
-  return [".rsp/specs/design.md"];
+function resolveDecisionRecordsPath(config) {
+  const configured = config.decisions?.path;
+  return configured && validateDecisionRecordsPath(configured) === null ? normalizeDecisionRecordsPath(configured) : DEFAULT_DECISION_RECORDS_PATH;
 }
-function collectArchiveChecklist(content, options = {}) {
-  return collectArchiveReadiness(content, options).warnings;
+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;
 }
-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 });
+async function validateDecisionRecordsFilesystemPath(pathValue, cwd = process.cwd()) {
+  const projectRoot = await realpath(cwd);
+  const targetPath = resolve(projectRoot, pathValue);
+  let existingAncestor = targetPath;
+  while (!existsSync(existingAncestor)) {
+    const parent = dirname(existingAncestor);
+    if (parent === existingAncestor)
+      return `Decision Record path "${pathValue}" has no accessible Host Project ancestor`;
+    existingAncestor = parent;
   }
-  return scenarios;
+  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(targetPath) && !(await stat(targetPath)).isDirectory())
+    return `Decision Record path "${pathValue}" must be a directory`;
+  return null;
 }
 
 // src/core/config.ts
-var __dirname = dirname3(fileURLToPath(import.meta.url));
-var PKG_ROOT = join4(__dirname, "..");
+var __dirname = dirname2(fileURLToPath(import.meta.url));
+var PKG_ROOT = join3(__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 RSP_RULES_PATH = join3(RSP_DIR, "rsp-rules.md");
+var OBSOLETE_RSP_RULES_PATH = join3(RSP_DIR, "rules", "rsp-rules.md");
+var CHANGES_DIR = join3(RSP_DIR, "changes");
+var FOCUS_DIR = join3(RSP_DIR, "focus.d");
+var MAX_FOCUS_CAPSULE_BYTES = 4096;
+var ARCHIVES_DIR = join3(RSP_DIR, "archives");
+var LOCK_PATH = join3(RSP_DIR, ".lock");
+var CONFIG_PATH = join3(RSP_DIR, "config.yaml");
 var VALID_KINDS = ["feature", "fix", "refactor", "docs", "ops", "research"];
 var DEFAULT_REQUIRED_SECTIONS = getCanonicalSectionHeadings(CHANGE_DOCUMENT_SCHEMA);
-var DEFAULT_MANAGE_POLICY = { activation: "explicit", closeout: "local" };
-var FAILED_CLOSED_MANAGE_POLICY = { activation: "explicit", closeout: "manual" };
+var LEGACY_MISSING_CONFIG_MANAGE_POLICY = { activation: "explicit", closeout: "local" };
+var INVALID_CONFIG_MANAGE_POLICY = { activation: "explicit", closeout: "manual" };
+var CONFIG_DEFAULTS = {
+  kinds: [],
+  decisions: { path: ".rsp/specs/decisions" },
+  language: { default: "en" },
+  manage: { activation: "auto", closeout: "local" }
+};
+function generateConfigTemplate(config = {}) {
+  const kinds = config.kinds ?? CONFIG_DEFAULTS.kinds;
+  const decisions = { ...CONFIG_DEFAULTS.decisions, ...config.decisions };
+  const manage = { ...CONFIG_DEFAULTS.manage, ...config.manage };
+  const language = { ...CONFIG_DEFAULTS.language, ...config.language };
+  const kindsYaml = stringify(kinds).trimEnd();
+  const renderedKinds = kinds.length === 0 ? `kinds: ${kindsYaml}` : `kinds:
+${kindsYaml.split("\n").map((line) => `  ${line}`).join("\n")}`;
+  const artifactsLine = language.artifacts ? `  artifacts: ${stringify(language.artifacts).trim()}` : "  # artifacts: zh-CN";
+  const commitLine = language.commit ? `  commit: ${stringify(language.commit).trim()}` : "  # commit: zh-CN";
+  return `# RSP project configuration
+# An empty kinds list retains the built-in defaults.
+# A non-empty kinds list replaces the built-in defaults; it does not extend them.
+# Every entry must be a unique non-empty string.
+#
+# Built-in defaults:
+#   kinds:               ${VALID_KINDS.join(", ")}
+#
+${renderedKinds}
+
+# Decision Records default to .rsp/specs/decisions.
+decisions:
+  path: ${stringify(decisions.path).trim()}
+
+# New projects default to automatic Manage routing with local closeout.
+# Use activation: explicit to require a named managed request.
+# closeout accepts manual, lifecycle, or local; local routes a qualified clean terminal non-small boundary to one local commit but never push or publication.
+manage:
+  activation: ${manage.activation}
+  closeout: ${manage.closeout}
+
+# Set one shared project default for durable artifact and commit prose.
+# Response language remains user/session-owned and is never read from this project mapping.
+language:
+  default: ${stringify(language.default).trim()}
+${artifactsLine}
+${commitLine}
+`;
+}
 var MANAGE_ACTIVATIONS = ["explicit", "auto"];
 var MANAGE_CLOSEOUTS = ["manual", "lifecycle", "local"];
+function reconcileRspConfigDefaults(raw) {
+  const document = parseDocument(raw);
+  if (document.errors.length > 0)
+    throw new Error(document.errors.map((error) => error.message).join("; "));
+  const parsed = parseYamlText(raw);
+  const issues = validateRspConfig(parsed);
+  if (issues.length > 0)
+    throw new Error(issues.join("; "));
+  const added = collectMissingConfigDefaults(parsed);
+  const customComments = hasCustomConfigComments(document, parsed);
+  if (customComments) {
+    backfillConfigDocument(document, parsed);
+  }
+  if (customComments && added.length === 0)
+    return { content: raw, added, changed: false };
+  const content = customComments ? String(document) : generateConfigTemplate(parsed);
+  return { content, added, changed: content !== raw };
+}
+function collectMissingConfigDefaults(parsed) {
+  const added = [];
+  if (!("kinds" in parsed))
+    added.push("kinds");
+  if (!("decisions" in parsed) || !hasNestedKey(parsed.decisions, "path"))
+    added.push("decisions.path");
+  if (!("language" in parsed))
+    added.push("language.default");
+  if (!("manage" in parsed)) {
+    added.push("manage.activation", "manage.closeout");
+  } else {
+    if (!hasNestedKey(parsed.manage, "activation"))
+      added.push("manage.activation");
+    if (!hasNestedKey(parsed.manage, "closeout"))
+      added.push("manage.closeout");
+  }
+  return added;
+}
+function backfillConfigDocument(document, parsed) {
+  if (!("kinds" in parsed))
+    document.set("kinds", [...CONFIG_DEFAULTS.kinds]);
+  if (!("decisions" in parsed))
+    document.set("decisions", { path: CONFIG_DEFAULTS.decisions.path });
+  else if (!hasNestedKey(parsed.decisions, "path"))
+    document.setIn(["decisions", "path"], CONFIG_DEFAULTS.decisions.path);
+  if (!("language" in parsed))
+    document.set("language", { default: CONFIG_DEFAULTS.language.default });
+  if (!("manage" in parsed)) {
+    document.set("manage", { ...CONFIG_DEFAULTS.manage });
+  } else {
+    if (!hasNestedKey(parsed.manage, "activation"))
+      document.setIn(["manage", "activation"], CONFIG_DEFAULTS.manage.activation);
+    if (!hasNestedKey(parsed.manage, "closeout"))
+      document.setIn(["manage", "closeout"], CONFIG_DEFAULTS.manage.closeout);
+  }
+}
+function hasNestedKey(value, key) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value) && key in value);
+}
+var LEGACY_GENERATED_CONFIG_COMMENTS = /* @__PURE__ */ new Set([
+  "Omit kinds or use [] to retain the built-in defaults.",
+  "New projects default to automatic Manage routing with lifecycle-only closeout.",
+  "Self-host automatic Manage routing with bounded deterministic local commits; push and publication stay explicit.",
+  "Set exactly one project-relative authoritative directory when the Host Project already owns Decision Records elsewhere.",
+  "kinds:",
+  "decisions:",
+  "path: docs/adr",
+  ...VALID_KINDS.map((kind) => `- ${kind}`)
+]);
+function hasCustomConfigComments(document, parsed) {
+  const generated = new Set(collectConfigComments(parseDocument(generateConfigTemplate(parsed))));
+  for (const comment of LEGACY_GENERATED_CONFIG_COMMENTS)
+    generated.add(comment);
+  return collectConfigComments(document).some((comment) => !generated.has(comment));
+}
+function collectConfigComments(document) {
+  const comments = [];
+  const append = (value) => {
+    if (!value)
+      return;
+    for (const line of value.split("\n")) {
+      const comment = line.trim();
+      if (comment)
+        comments.push(comment);
+    }
+  };
+  append(document.commentBefore);
+  append(document.comment);
+  visit(document, {
+    Node(_key, node) {
+      append(node.commentBefore);
+      append(node.comment);
+    }
+  });
+  return comments;
+}
 var _configCache = null;
 async function loadRspConfig() {
   const inspection = await inspectRspConfig();
@@ -918,11 +646,12 @@ async function loadRspConfig() {
     throw new Error(inspection.issues.join("; "));
   return inspection.config;
 }
-async function inspectRspConfig() {
-  const cwd = process.cwd();
+async function inspectRspConfig(cwd = process.cwd()) {
+  cwd = resolve2(cwd);
   if (_configCache?.cwd === cwd)
     return _configCache.inspection;
-  const configFile = inspectManagedFile(CONFIG_PATH, "config file", { allowMissing: true });
+  const configPath = join3(cwd, CONFIG_PATH);
+  const configFile = inspectManagedFile(configPath, "config file", { allowMissing: true });
   if (configFile.issue)
     throw configFile.issue;
   if (!configFile.exists) {
@@ -930,7 +659,7 @@ async function inspectRspConfig() {
     _configCache = { cwd, inspection: inspection2 };
     return inspection2;
   }
-  const raw = await readFile2(CONFIG_PATH, "utf-8");
+  const raw = await readFile(configPath, "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;
@@ -1025,10 +754,10 @@ function resolveRequiredSections(_config) {
 }
 function resolveManagePolicy(config, options = {}) {
   if (options.configValid === false)
-    return { ...FAILED_CLOSED_MANAGE_POLICY };
+    return { ...INVALID_CONFIG_MANAGE_POLICY };
   return {
-    activation: config.manage?.activation ?? DEFAULT_MANAGE_POLICY.activation,
-    closeout: config.manage?.closeout ?? DEFAULT_MANAGE_POLICY.closeout
+    activation: config.manage?.activation ?? LEGACY_MISSING_CONFIG_MANAGE_POLICY.activation,
+    closeout: config.manage?.closeout ?? LEGACY_MISSING_CONFIG_MANAGE_POLICY.closeout
   };
 }
 function resolveLanguagePolicy(config, options = {}) {
@@ -1063,11 +792,12 @@ function canonicalizeLanguageTag(value) {
   }
 }
 async function getVersion() {
-  const { version } = JSON.parse(await readFile2(join4(PKG_ROOT, "package.json"), "utf-8"));
+  const { version } = JSON.parse(await readFile(join3(PKG_ROOT, "package.json"), "utf-8"));
   return version;
 }
 
 // src/core/output.ts
+import pc2 from "picocolors";
 function toErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -1076,27 +806,8 @@ function emitJson(data, options = {}) {
   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}`)}`);
-  }
-}
 
 export {
-  ManagedPathError,
-  inspectManagedDirectory,
-  requireManagedDirectory,
-  inspectManagedFile,
-  requireManagedFile,
-  ensureManagedFile,
-  writeManagedFile,
-  resolveManagedDirectoryChain,
-  inspectManagedFileTree,
-  DEFAULT_DECISION_RECORDS_PATH,
-  resolveDecisionRecordsPath,
-  ensureDecisionRecordsDirectory,
-  validateDecisionRecordsFilesystemPath,
   CHANGE_DOCUMENT_SCHEMA,
   GROUP_BRIEF_DOCUMENT_SCHEMA,
   DocumentSectionCardinalityError,
@@ -1110,32 +821,30 @@ export {
   renderDocumentSectionHeading,
   renderDocumentTitle,
   appendDocumentSectionItem,
-  toErrorMessage,
-  emitJson,
-  recordRuntimeDiagnostic,
   parseFrontmatter,
   countCheckboxes,
-  walkMarkdownFiles,
-  inspectUnsupportedRules,
-  normalizeLogicalPath,
-  generateChangeContent,
-  upsertRspAgentsBlock,
-  hasRspAgentsBlock,
-  isValidSpecName,
-  guardRspInitialized,
-  cleanupEmptyParentDirs,
-  detectProjectName,
-  generateDesignContent,
-  generateSpecContent,
+  classifyVerifyCheckboxes,
+  collectVerifyCheckboxLines,
+  getOpenCheckboxes,
   extractBlockerLines,
   hasMeaningfulBlockerBody,
   hasMeaningfulBlockers,
+  isEmptyBlockerLine,
   detectDeltaSections,
-  collectArchiveReadiness,
-  buildDurableReviewGuidance,
-  getDurableReviewCandidateTargets,
-  collectArchiveChecklist,
   parseScenarios,
+  ManagedPathError,
+  inspectManagedDirectory,
+  requireManagedDirectory,
+  inspectManagedFile,
+  requireManagedFile,
+  ensureManagedFile,
+  writeManagedFile,
+  resolveManagedDirectoryChain,
+  inspectManagedFileTree,
+  DEFAULT_DECISION_RECORDS_PATH,
+  resolveDecisionRecordsPath,
+  ensureDecisionRecordsDirectory,
+  validateDecisionRecordsFilesystemPath,
   pc,
   PKG_ROOT,
   RSP_DIR,
@@ -1143,10 +852,12 @@ export {
   OBSOLETE_RSP_RULES_PATH,
   CHANGES_DIR,
   FOCUS_DIR,
+  MAX_FOCUS_CAPSULE_BYTES,
   ARCHIVES_DIR,
   LOCK_PATH,
   CONFIG_PATH,
-  VALID_KINDS,
+  generateConfigTemplate,
+  reconcileRspConfigDefaults,
   loadRspConfig,
   inspectRspConfig,
   clearConfigCache,
@@ -1154,5 +865,7 @@ export {
   resolveRequiredSections,
   resolveManagePolicy,
   resolveLanguagePolicy,
-  getVersion
+  getVersion,
+  toErrorMessage,
+  emitJson
 };