@oevery/rsp 1.1.0 → 2.0.0

package/dist/cli.mjs

@@ -7,90 +7,87 @@ import { defineCommand, runMain } from "citty";
 
 // src/commands/add-rules.ts
 import { existsSync as existsSync3 } from "fs";
-import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
-import { basename, dirname as dirname2, join as join3 } from "path";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname3, join as join3 } from "path";
 
 // src/core/config.ts
 import { existsSync as existsSync2 } from "fs";
-import { readFile } from "fs/promises";
-import { dirname, join as join2 } from "path";
+import { readFile as readFile2 } from "fs/promises";
+import { dirname as dirname2, join as join2 } from "path";
 import { fileURLToPath } from "url";
 import pc from "picocolors";
 
 // src/core/helpers.ts
 import { existsSync } from "fs";
-import { readdir, stat } from "fs/promises";
-import { join, relative } from "path";
+import { readdir, readFile, rmdir, stat } from "fs/promises";
+import { basename, dirname, join, relative, sep } from "path";
+import { parse } from "yaml";
+
+// src/core/output.ts
+function toErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function emitJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function emitStatusJsonError(error, options) {
+  const payload = {
+    command: "status",
+    ok: false,
+    filters: {
+      focused: options.focused,
+      blocked: options.blocked,
+      stale: null
+    },
+    focused: [],
+    records: [],
+    summary: {
+      total: 0,
+      focused: 0,
+      blocked: 0
+    },
+    archiveTrend: [],
+    runtime: [],
+    error
+  };
+  emitJson(payload);
+}
+function recordRuntimeDiagnostic(runtime, diagnostic, verbose = false) {
+  runtime.push(diagnostic);
+  if (verbose) {
+    console.error(`  ${pc.dim(`[verbose] ${diagnostic.operation} ${diagnostic.path}: ${diagnostic.message}`)}`);
+  }
+}
+
+// src/core/helpers.ts
 var RSP_AGENTS_BEGIN = "<!-- rsp:begin -->";
 var RSP_AGENTS_END = "<!-- rsp:end -->";
-function parseYamlLines(lines) {
-  const result = {};
-  let currentKey = null;
-  let currentList = null;
-  function flushList() {
-    if (currentList !== null && currentKey !== null) {
-      result[currentKey] = currentList;
-      currentList = null;
-      currentKey = null;
-    }
-  }
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (trimmed === "" || trimmed.startsWith("#")) {
-      continue;
-    }
-    const li = line.match(/^[ \t]+-[ \t]+([^\n]+)$/);
-    if (li && currentList !== null) {
-      currentList.push(li[1].trim());
-      continue;
-    }
-    flushList();
-    const kv = line.match(/^([\w-]+):[ \t]*([^\n]*)$/);
-    if (kv) {
-      currentKey = kv[1];
-      const val = kv[2].trim();
-      if (!val || val === "[]") {
-        currentList = [];
-      } else {
-        result[currentKey] = val;
-        currentKey = null;
-      }
-    }
-  }
-  flushList();
-  return result;
+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 parseYamlLines(m[1].split("\n"));
+  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, total: todo + progress + done + dropped };
+  return { todo, progress, done, dropped, total: todo + progress + done + dropped };
 }
-async function walkMarkdownFiles(dir) {
-  const files = [];
-  try {
-    const items = await readdir(dir, { withFileTypes: true });
-    for (const item of items) {
-      if (item.name.startsWith("."))
-        continue;
-      const filePath = join(dir, item.name);
-      if (item.isDirectory())
-        files.push(...await walkMarkdownFiles(filePath));
-      else if (item.name.endsWith(".md"))
-        files.push(filePath);
-    }
-  } catch {
-  }
-  return files;
+async function walkMarkdownFiles(dir, options = {}) {
+  const all = await walkFiles(dir, options);
+  return all.filter((f) => f.endsWith(".md"));
 }
-async function walkFiles(dir) {
+async function walkFiles(dir, options = {}) {
   const files = [];
   try {
     const items = await readdir(dir, { withFileTypes: true });
@@ -99,63 +96,210 @@ async function walkFiles(dir) {
         continue;
       const filePath = join(dir, item.name);
       if (item.isDirectory())
-        files.push(...await walkFiles(filePath));
+        files.push(...await walkFiles(filePath, options));
       else
         files.push(filePath);
     }
-  } catch {
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      options.onError?.({
+        code: "walk_failed",
+        operation: "readdir",
+        path: dir,
+        message: toErrorMessage(error)
+      });
+    }
   }
   return files;
 }
-function featureNameFromPath(featuresDir, filePath) {
-  const rel = relative(featuresDir, filePath);
+function changeNameFromPath(changesDir, filePath) {
+  const rel = normalizeLogicalPath(relative(changesDir, filePath));
   return rel.replace(/\.md$/, "");
 }
-function generateFeatureContent(name, summary = "") {
-  return `---
-status: draft
-priority: medium
-tags:
+function normalizeLogicalPath(pathValue) {
+  return pathValue.split(sep).join("/").replace(/\\/g, "/");
+}
+function generateChangeContent(name, summary = "", kind) {
+  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
 ---
-# Feature: ${name}
+
+# Change: project-setup
+
+## Proposal
+- Summary: ${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 .rsp/rules/project-rules.md when stable local rules or validation steps exist
+- Non-goals:
+  - Do not duplicate durable project facts across this change, specs, and rules
 
 ## Spec
-- Summary: ${summary || "<one-line summary>"}
-- Requirements:
-  - [ ] <verifiable requirement>
+### ADDED
+- Requirement: project bootstrap capture
+  - The repository's purpose, scope, and structure are reflected in .rsp/specs/design.md
+
+### MODIFIED
+- Requirement: stable local operating constraints
+  - Stable validation or workflow constraints are reflected in .rsp/rules/project-rules.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 .rsp/rules/project-rules.md exists only when stable local rules are present
+
+## Design
+- Approach:
+  - Keep bootstrap knowledge in this single change while moving durable facts into specs and rules
+- Affected areas:
+  - .rsp/specs/design.md
+  - .rsp/rules/project-rules.md
 - Constraints:
-  -
+  - Keep the setup lightweight and avoid duplicating durable project facts
+
+## Tasks
+- [ ] Review the repository structure, entrypoints, and primary outputs
+- [ ] Fill .rsp/specs/design.md with durable architecture facts
+- [ ] Add .rsp/rules/project-rules.md if stable local rules or validation steps exist
+
+## Verify
+- Automated:
+  - [ ] Run rsp doctor
+- Manual:
+  - [ ] Review .rsp/specs/design.md and confirm it matches the repository
+- Durable updates:
+  - [ ] Decide whether this change produced durable knowledge that belongs in \`.rsp/specs/\` or \`.rsp/rules/\`
+  - [ ] If yes, write only stable facts to the smallest correct target file before archive; do not promote task history, debugging notes, or one-off implementation context
+
+## Blockers
+- none
+`;
+  }
+  const frontmatterKind = kind ?? "<choose: feature | fix | refactor | docs | ops | research>";
+  const template = getChangeTemplateByKind(kind);
+  return `---
+kind: "${frontmatterKind}"
+---
+
+# Change: ${name}
+
+## Proposal
+- Summary: ${proposalSummary}
+- Why:
+  - ${template.why}
+- Scope:
+  - ${template.scope}
+- Non-goals:
+  - ${template.nonGoals}
+
+## Spec
+${template.specSection}
 
-## Plan
-- [ ] Phase 1:
-  - [ ] <task>
+### Acceptance
+${template.acceptanceSection}
 
-## Tests
-- [ ] <test file or scenario>
+## Design
+- Approach:
+  - ${template.approach}
+- Affected areas:
+  - ${template.affectedAreas}
+- Constraints:
+  - ${template.constraints}
+
+## Tasks
+- [ ] ${template.task}
 
-## Notes (optional)
-- <design decisions discovered during implementation>
+## Verify
+- Automated:
+  - [ ] ${template.automatedVerify}
+- Manual:
+  - [ ] ${template.manualVerify}
+- Durable updates:
+  - [ ] Decide whether this change produced durable knowledge that belongs in \`.rsp/specs/\` or \`.rsp/rules/\`
+  - [ ] If yes, write only stable facts to the smallest correct target file before archive; do not promote task history, debugging notes, or one-off implementation context
 
 ## Blockers
--
+- none
 `;
 }
+function getChangeTemplateByKind(kind) {
+  switch (kind) {
+    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: "### 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>",
+        affectedAreas: "<doc path or documentation area>",
+        constraints: "<durable wording, consistency, or scope constraint>",
+        task: "<update the target documentation and supporting references>",
+        automatedVerify: "<run markdown, docs, or link checks if applicable>",
+        manualVerify: "<review the updated doc as a reader and confirm it is accurate>"
+      };
+    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: "### 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>",
+        affectedAreas: "<code path, subsystem, or source being investigated>",
+        constraints: "<time, evidence, or scope constraint for the investigation>",
+        task: "<gather evidence and record the resulting recommendation or finding>",
+        automatedVerify: "<run any command needed to confirm the observed behavior>",
+        manualVerify: "<review the findings and confirm they answer the original question>"
+      };
+    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: "### 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>",
+        affectedAreas: "<script, config, workflow, or environment path>",
+        constraints: "<rollback, safety, or environment constraint>",
+        task: "<apply and verify the operational change>",
+        automatedVerify: "<run the relevant operational validation command>",
+        manualVerify: "<exercise the target workflow and confirm the operational result>"
+      };
+    default:
+      return {
+        why: "<why this change matters>",
+        scope: "<what this change will do>",
+        nonGoals: "<what this change will not do>",
+        specSection: "### 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>",
+        affectedAreas: "<path or subsystem>",
+        constraints: "<binding technical or product constraint>",
+        task: "<implementation task>",
+        automatedVerify: "<test command or automated check>",
+        manualVerify: "<manual scenario to validate>"
+      };
+  }
+}
 function renderRspAgentsBlock() {
   return `${RSP_AGENTS_BEGIN}
 ## RSP Entry
 
 Read in order:
-1. .rsp/rules/*.md
-2. .rsp/specs/INDEX.md
-3. .rsp/specs/design.md
-4. .rsp/active.d/ and matching .rsp/features/*.md
-
-Guidelines:
-- .rsp/rules/rsp-rules.md is required
-- .rsp/rules/project-rules.md is optional
-- Keep project design in .rsp/specs/
-- Add extra spec files only when they have durable value
-- Do not create a feature named 'init'
+1. .rsp/rules/rsp-rules.md
+2. .rsp/focus.d/
+3. matching .rsp/changes/*.md for the focused entries
+4. .rsp/specs/design.md
+5. .rsp/specs/INDEX.md
+6. only the relevant additional .rsp/rules/*.md and .rsp/specs/*.md files
 ${RSP_AGENTS_END}`;
 }
 function upsertRspAgentsBlock(content) {
@@ -175,6 +319,49 @@ ${trimmed}` : `${block}
 function hasRspAgentsBlock(content) {
   return content.includes(RSP_AGENTS_BEGIN) && content.includes(RSP_AGENTS_END);
 }
+var CHANGE_NAME_RE = /^[a-z0-9-]+(?:\/[a-z0-9-]+)*$/;
+function isValidChangeName(name) {
+  return CHANGE_NAME_RE.test(name);
+}
+function guardRspInitialized() {
+  const rspRulesPath = join(RSP_DIR, "rules", "rsp-rules.md");
+  const designPath = join(RSP_DIR, "specs", "design.md");
+  if (!existsSync(rspRulesPath) || !existsSync(designPath)) {
+    console.error(`  ${pc.red("Error:")} RSP is not initialized in this project`);
+    console.error(`  ${pc.dim("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 = dirname(path);
+  while (parent !== stopDir) {
+    try {
+      const remaining = await readdir(parent);
+      if (remaining.length === 0)
+        await rmdir(parent);
+      else
+        break;
+    } catch {
+      break;
+    }
+    parent = dirname(parent);
+  }
+}
+async function detectProjectName() {
+  try {
+    if (existsSync("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}
 
@@ -182,7 +369,11 @@ function generateDesignContent(projectName) {
 - <what this project is responsible for>
 - <who or what it serves>
 
-## Scope
+## Stable Facts
+- <durable fact that future agents or developers must know>
+- <key architectural invariant>
+
+## Boundaries
 - In scope:
   - <major capability or boundary>
 - Out of scope:
@@ -192,7 +383,7 @@ function generateDesignContent(projectName) {
 - <important directory or subsystem> \u2014 <responsibility>
 
 ## Constraints
-- <cross-cutting technical or operational constraint>
+- <cross-cutting technical or operational constraint, when it affects architecture>
 `;
 }
 function generateProjectRulesContent(projectName) {
@@ -204,10 +395,11 @@ description: Project-specific rules for ${projectName}
 # Project Rules
 
 ## Scope
-- <rules that apply across the project>
+- <stable local rules, workflow constraints, or validation expectations>
+- Do not put temporary debugging steps here.
 
 ## Validation
-- <preferred validation commands>
+- <preferred stable validation commands, not temporary troubleshooting steps>
 
 ## Conventions
 - <project-specific conventions>
@@ -217,7 +409,7 @@ function generateRulesContent(name) {
   const title = toTitleCase(name);
   return `---
 name: ${name}
-description: Project-specific rules for ${title}
+description: Durable rules for ${title}
 ---
 
 # ${title}
@@ -239,27 +431,47 @@ function generateSpecContent(name) {
 ## Purpose
 - <why this project-level spec exists>
 
-## Details
-- <important project-level detail>
+## 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 detectDeltaSections(content) {
-  const match = content.match(/^## Spec\n([\s\S]*?)(?=\n## |\n---|\n\.\.\.)/m);
-  if (!match) {
-    const m2 = content.match(/^## Spec\n([\s\S]*)$/m);
-    if (!m2)
-      return { added: false, modified: false, removed: false };
-    const body2 = m2[1];
-    return {
-      added: /^###\s*ADDED/im.test(body2),
-      modified: /^###\s*MODIFIED/im.test(body2),
-      removed: /^###\s*REMOVED/im.test(body2)
-    };
+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);
   }
-  const body = match[1];
+  return body.join("\n").trim();
+}
+function hasMeaningfulBlockers(content) {
+  const blockers = extractSection(content, "Blockers");
+  if (!blockers)
+    return false;
+  const lines = blockers.split("\n").map((line) => line.trim()).filter(Boolean);
+  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),
@@ -268,60 +480,32 @@ function detectDeltaSections(content) {
 }
 function parseScenarios(content) {
   const scenarios = [];
-  const regex = /^###\s*Scenario:\s*(.+)$/gim;
+  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(/^###/m);
+    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*/, ""));
+    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;
 }
-function detectCycles(graph) {
-  const cycles = [];
-  const visited = /* @__PURE__ */ new Set();
-  const inStack = /* @__PURE__ */ new Set();
-  function dfs(node, path) {
-    if (inStack.has(node)) {
-      const cycleStart = path.indexOf(node);
-      if (cycleStart !== -1)
-        cycles.push(path.slice(cycleStart).concat(node));
-      return;
-    }
-    if (visited.has(node))
-      return;
-    visited.add(node);
-    inStack.add(node);
-    path.push(node);
-    const neighbors = graph.get(node) || [];
-    for (const next of neighbors) {
-      if (graph.has(next))
-        dfs(next, path);
-    }
-    path.pop();
-    inStack.delete(node);
-  }
-  for (const node of graph.keys())
-    dfs(node, []);
-  return cycles;
-}
 
 // src/core/config.ts
-var __dirname = dirname(fileURLToPath(import.meta.url));
+var __dirname = dirname2(fileURLToPath(import.meta.url));
 var PKG_ROOT = join2(__dirname, "..");
 var RSP_DIR = ".rsp";
-var ACTIVE_DIR = join2(RSP_DIR, "active.d");
+var CHANGES_DIR = join2(RSP_DIR, "changes");
+var FOCUS_DIR = join2(RSP_DIR, "focus.d");
 var ARCHIVES_DIR = join2(RSP_DIR, "archives");
 var LOCK_PATH = join2(RSP_DIR, ".lock");
 var CONFIG_PATH = join2(RSP_DIR, "config.yaml");
-var VALID_STATUSES = ["draft", "ready", "in-progress", "blocked", "done"];
-var VALID_PRIORITIES = ["low", "medium", "high", "critical"];
-var DEFAULT_REQUIRED_SECTIONS = ["Spec", "Plan"];
+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() {
   if (_configCache)
@@ -330,31 +514,26 @@ async function loadRspConfig() {
     _configCache = {};
     return _configCache;
   }
-  const raw = await readFile(CONFIG_PATH, "utf-8");
-  const parsed = parseYamlLines(raw.split("\n"));
+  const raw = await readFile2(CONFIG_PATH, "utf-8");
+  const parsed = parseYamlText(raw);
   _configCache = {
-    statuses: Array.isArray(parsed.statuses) ? parsed.statuses.map(String) : void 0,
-    priorities: Array.isArray(parsed.priorities) ? parsed.priorities.map(String) : void 0,
-    required_sections: Array.isArray(parsed.required_sections) ? parsed.required_sections.map(String) : void 0
+    kinds: Array.isArray(parsed.kinds) ? parsed.kinds.map(String) : void 0
   };
   return _configCache;
 }
-function resolveStatuses(config) {
-  return config.statuses && config.statuses.length > 0 ? config.statuses : [...VALID_STATUSES];
+function resolveKinds(config) {
+  return config.kinds && config.kinds.length > 0 ? config.kinds : [...VALID_KINDS];
 }
-function resolvePriorities(config) {
-  return config.priorities && config.priorities.length > 0 ? config.priorities : [...VALID_PRIORITIES];
-}
-function resolveRequiredSections(config) {
-  return config.required_sections && config.required_sections.length > 0 ? config.required_sections : [...DEFAULT_REQUIRED_SECTIONS];
+function resolveRequiredSections(_config) {
+  return [...DEFAULT_REQUIRED_SECTIONS];
 }
 async function getVersion() {
-  const { version } = JSON.parse(await readFile(join2(PKG_ROOT, "package.json"), "utf-8"));
+  const { version } = JSON.parse(await readFile2(join2(PKG_ROOT, "package.json"), "utf-8"));
   return version;
 }
 
 // src/core/lock.ts
-import { mkdir, readFile as readFile2, unlink, writeFile } from "fs/promises";
+import { mkdir, readFile as readFile3, unlink, writeFile } from "fs/promises";
 async function withRspLock(operation, fn) {
   await mkdir(RSP_DIR, { recursive: true });
   try {
@@ -378,7 +557,7 @@ ${(/* @__PURE__ */ new Date()).toISOString()}`, { flag: "wx" });
 }
 async function handleStaleLock(operation) {
   try {
-    const content = await readFile2(LOCK_PATH, "utf-8");
+    const content = await readFile3(LOCK_PATH, "utf-8");
     const lines = content.trim().split("\n");
     const pid = Number(lines[0]);
     if (pid && Number.isFinite(pid)) {
@@ -390,10 +569,15 @@ async function handleStaleLock(operation) {
       } catch (e) {
         if (e instanceof Error && e.message.startsWith("RSP locked"))
           throw e;
-        await unlink(LOCK_PATH);
-        await writeFile(LOCK_PATH, `${process.pid}
+        const code = e.code;
+        if (code === "ESRCH") {
+          await unlink(LOCK_PATH);
+          await writeFile(LOCK_PATH, `${process.pid}
 ${operation}
 ${(/* @__PURE__ */ new Date()).toISOString()}`, { flag: "wx" });
+          return;
+        }
+        throw e;
       }
     } else {
       await unlink(LOCK_PATH);
@@ -409,39 +593,19 @@ ${(/* @__PURE__ */ new Date()).toISOString()}`, { flag: "wx" });
 }
 
 // src/commands/add-rules.ts
-var NAME_RE = /^[a-z0-9-]+(?:\/[a-z0-9-]+)*$/;
-async function detectProjectName() {
-  try {
-    if (existsSync3("package.json")) {
-      const raw = await readFile3("package.json", "utf-8");
-      const pkg = JSON.parse(raw);
-      if (pkg.name && pkg.name !== "")
-        return pkg.name;
-    }
-  } catch {
-  }
-  return basename(process.cwd());
-}
 async function addRules(name, projectName = "project") {
-  if (!name || !NAME_RE.test(name)) {
+  if (!name || !isValidChangeName(name)) {
     console.error(`  ${pc.red("Error:")} rule name must be kebab-case with optional subdirectory`);
     process.exit(1);
   }
-  const rspRulesPath = join3(RSP_DIR, "rules", "rsp-rules.md");
-  const designPath = join3(RSP_DIR, "specs", "design.md");
-  if (!existsSync3(rspRulesPath) || !existsSync3(designPath)) {
-    console.error(`  ${pc.red("Error:")} RSP is not initialized in this project`);
-    console.error(`  ${pc.dim("Run: rsp init")}`);
+  guardRspInitialized();
+  const path = join3(RSP_DIR, "rules", `${name}.md`);
+  if (existsSync3(path)) {
+    console.error(`  ${pc.red("Error:")} rule file already exists: .rsp/rules/${name}.md`);
     process.exit(1);
   }
   return withRspLock("add-rules", async () => {
-    const dir = join3(RSP_DIR, "rules");
-    const path = join3(dir, `${name}.md`);
-    if (existsSync3(path)) {
-      console.error(`  ${pc.red("Error:")} rule file already exists: .rsp/rules/${name}.md`);
-      process.exit(1);
-    }
-    await mkdir2(dirname2(path), { recursive: true });
+    await mkdir2(dirname3(path), { recursive: true });
     const resolvedProjectName = projectName === "project" ? await detectProjectName() : projectName;
     const content = name === "project-rules" ? generateProjectRulesContent(resolvedProjectName) : generateRulesContent(name);
     await writeFile2(path, content);
@@ -452,8 +616,8 @@ async function addRules(name, projectName = "project") {
 
 // src/commands/add-spec.ts
 import { existsSync as existsSync5 } from "fs";
-import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
-import { basename as basename3, dirname as dirname3, join as join5 } from "path";
+import { mkdir as mkdir3, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname4, join as join5 } from "path";
 
 // src/commands/specs-index.ts
 import { existsSync as existsSync4 } from "fs";
@@ -480,16 +644,17 @@ async function buildSpecsIndex({ acquireLock = true } = {}) {
     lines.push("| File | Title | Summary |");
     lines.push("|------|-------|---------|");
     for (const fp of specFiles) {
-      const rel = relative2(specsDir, fp);
+      const rel = normalizeLogicalPath(relative2(specsDir, fp));
       const content = await readFile4(fp, "utf-8");
       const fm = parseFrontmatter(content);
-      const title = extractTitle(content) || rel.replace(/\.md$/, "");
+      const fmTitle = fm && typeof fm.title === "string" ? fm.title : "";
+      const title = fmTitle || extractTitle(content) || rel.replace(/\.md$/, "");
       const summary = extractSummary(content, fm?.summary);
       lines.push(`| ${escapeCell(rel)} | ${escapeCell(title)} | ${escapeCell(summary || "\u2014")} |`);
     }
   }
   lines.push("");
-  lines.push("_Auto-generated by `rsp specs-index`._");
+  lines.push("_Auto-generated by `rsp update`._");
   await writeFile3(join4(specsDir, "INDEX.md"), lines.join("\n"));
   console.log(`  ${pc.green("INDEX.md updated:")} ${specFiles.length} spec file(s).
 `);
@@ -528,40 +693,20 @@ function escapeCell(value) {
 }
 
 // src/commands/add-spec.ts
-var NAME_RE2 = /^[a-z0-9-]+(?:\/[a-z0-9-]+)*$/;
-async function detectProjectName2() {
-  try {
-    if (existsSync5("package.json")) {
-      const raw = await readFile5("package.json", "utf-8");
-      const pkg = JSON.parse(raw);
-      if (pkg.name && pkg.name !== "")
-        return pkg.name;
-    }
-  } catch {
-  }
-  return basename3(process.cwd());
-}
 async function addSpec(name, projectName = "project") {
-  if (!name || !NAME_RE2.test(name)) {
+  if (!name || !isValidChangeName(name)) {
     console.error(`  ${pc.red("Error:")} spec name must be kebab-case with optional subdirectory`);
     process.exit(1);
   }
-  const rspRulesPath = join5(RSP_DIR, "rules", "rsp-rules.md");
-  const designPath = join5(RSP_DIR, "specs", "design.md");
-  if (!existsSync5(rspRulesPath) || !existsSync5(designPath)) {
-    console.error(`  ${pc.red("Error:")} RSP is not initialized in this project`);
-    console.error(`  ${pc.dim("Run: rsp init")}`);
+  guardRspInitialized();
+  const path = join5(RSP_DIR, "specs", `${name}.md`);
+  if (existsSync5(path)) {
+    console.error(`  ${pc.red("Error:")} spec file already exists: .rsp/specs/${name}.md`);
     process.exit(1);
   }
   return withRspLock("add-spec", async () => {
-    const dir = join5(RSP_DIR, "specs");
-    const path = join5(dir, `${name}.md`);
-    if (existsSync5(path)) {
-      console.error(`  ${pc.red("Error:")} spec file already exists: .rsp/specs/${name}.md`);
-      process.exit(1);
-    }
-    await mkdir3(dirname3(path), { recursive: true });
-    const resolvedProjectName = projectName === "project" ? await detectProjectName2() : projectName;
+    await mkdir3(dirname4(path), { recursive: true });
+    const resolvedProjectName = projectName === "project" ? await detectProjectName() : projectName;
     const content = name === "design" ? generateDesignContent(resolvedProjectName) : generateSpecContent(name);
     await writeFile4(path, content);
     await buildSpecsIndex({ acquireLock: false });
@@ -570,148 +715,359 @@ async function addSpec(name, projectName = "project") {
   });
 }
 
+// src/commands/archive.ts
+import { existsSync as existsSync7 } from "fs";
+import { mkdir as mkdir4, readFile as readFile6, rename, unlink as unlink2 } from "fs/promises";
+import { basename as basename4, dirname as dirname6, join as join7 } from "path";
+
 // src/commands/archive-index.ts
 import { existsSync as existsSync6 } from "fs";
-import { readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
-import { basename as basename4, dirname as dirname4, join as join6, relative as relative3 } from "path";
+import { readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import { basename as basename3, dirname as dirname5, join as join6, relative as relative3 } from "path";
 async function buildArchiveIndex({ acquireLock = true } = {}) {
   if (acquireLock)
     return withRspLock("archive-index", async () => buildArchiveIndex({ acquireLock: false }));
-  const archiveDir = join6(RSP_DIR, "archives");
-  if (!existsSync6(archiveDir)) {
+  if (!existsSync6(ARCHIVES_DIR)) {
     console.log(`  ${pc.dim("No archives directory.")}
 `);
     return;
   }
-  const archiveFiles = (await walkMarkdownFiles(archiveDir)).filter((fp) => basename4(fp) !== "INDEX.md").sort();
+  const archiveFiles = (await walkMarkdownFiles(ARCHIVES_DIR)).filter((fp) => basename3(fp) !== "INDEX.md").sort();
   const lines = [];
   lines.push("# Archive Index");
   lines.push("");
   lines.push(`Generated: ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`);
   lines.push("");
   if (archiveFiles.length === 0) {
-    lines.push("_No archived features yet._");
+    lines.push("_No archived changes yet._");
   } else {
-    lines.push("| Date | Feature | Summary |");
-    lines.push("|------|---------|---------|");
+    lines.push("| Date | Change | Summary |");
+    lines.push("|------|--------|---------|");
   }
   for (const fp of archiveFiles) {
-    const base = basename4(fp);
-    const archiveRel = relative3(archiveDir, fp);
-    const archiveDirPart = dirname4(archiveRel);
+    const base = basename3(fp);
+    const archiveRel = normalizeLogicalPath(relative3(ARCHIVES_DIR, fp));
+    const archiveDirPart = dirname5(archiveRel);
     const dateMatch = base.match(/^(\d{4}-\d{2}-\d{2})_(.+)\.md$/);
     const date = dateMatch ? dateMatch[1] : "\u2014";
     const baseName = dateMatch ? dateMatch[2] : base.replace(/\.md$/, "");
-    const featureName = archiveDirPart !== "." ? `${archiveDirPart}/${baseName}` : baseName;
+    const changeName = archiveDirPart !== "." ? `${archiveDirPart}/${baseName}` : baseName;
     let summary = "";
     try {
-      const content = await readFile6(fp, "utf-8");
-      const fm = parseFrontmatter(content);
-      if (fm?.summary)
-        summary = String(fm.summary);
-      if (!summary) {
-        const specMatch = content.match(/^## Spec[\s\S]*?\n- Summary:[ \t]*([^\n]+)$/m);
-        if (specMatch)
-          summary = specMatch[1].trim();
-      }
+      const content = await readFile5(fp, "utf-8");
+      const proposal = extractSection(content, "Proposal");
+      const summaryLine = proposal.split("\n").map((line) => line.trim()).find((line) => line.startsWith("- Summary:"));
+      if (summaryLine)
+        summary = summaryLine.slice("- Summary:".length).trim();
     } catch {
     }
     const summaryCell = summary ? summary.replace(/\|/g, "\\|") : "\u2014";
-    lines.push(`| ${date} | ${featureName} | ${summaryCell} |`);
+    lines.push(`| ${date} | ${changeName} | ${summaryCell} |`);
   }
   lines.push("");
-  lines.push("_Auto-generated by `rsp archive-index`._");
-  const indexPath = join6(archiveDir, "INDEX.md");
+  lines.push("_Auto-generated by `rsp update`._");
+  const indexPath = join6(ARCHIVES_DIR, "INDEX.md");
   await writeFile5(indexPath, lines.join("\n"));
-  console.log(`  ${pc.green("INDEX.md updated:")} ${archiveFiles.length} archived feature(s).
+  console.log(`  ${pc.green("INDEX.md updated:")} ${archiveFiles.length} archived change(s).
+`);
+}
+
+// src/commands/archive.ts
+async function archiveChange(name) {
+  if (!name) {
+    console.error(`  ${pc.red("Usage:")} rsp archive <name>`);
+    process.exit(1);
+  }
+  if (!isValidChangeName(name)) {
+    console.error(`  ${pc.red("Error:")} change name must be kebab-case with optional subdirectory (lowercase, digits, hyphens, slashes)`);
+    process.exit(1);
+  }
+  const srcPath = join7(CHANGES_DIR, `${name}.md`);
+  if (!existsSync7(srcPath)) {
+    console.error(`  ${pc.red("Change not found:")} .rsp/changes/${name}.md`);
+    process.exit(1);
+  }
+  return withRspLock("archive-change", async () => {
+    const content = await readFile6(srcPath, "utf-8");
+    const checklist = collectArchiveChecklist(content);
+    for (const line of checklist)
+      console.log(`  ${pc.yellow("\u26A0")} ${line}`);
+    if (checklist.length > 0)
+      console.log(`  ${pc.dim("Archive will continue. Review the warnings above before treating this work as fully closed.")}
+`);
+    const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const dir = dirname6(name);
+    const base = basename4(name);
+    const archiveSubdir = dir !== "." ? join7(ARCHIVES_DIR, dir) : ARCHIVES_DIR;
+    await mkdir4(archiveSubdir, { recursive: true });
+    const archiveName = resolveArchiveName(archiveSubdir, date, base);
+    await rename(srcPath, join7(archiveSubdir, archiveName));
+    const postArchiveWarnings = [];
+    let focusCleared = false;
+    const focusEntry = join7(FOCUS_DIR, name);
+    if (existsSync7(focusEntry)) {
+      try {
+        await unlink2(focusEntry);
+        await cleanupEmptyParentDirs(focusEntry, FOCUS_DIR);
+        focusCleared = true;
+      } catch (error) {
+        postArchiveWarnings.push(`focus marker cleanup failed: ${toErrorMessage(error)}`);
+      }
+    }
+    try {
+      await cleanupEmptyParentDirs(srcPath, CHANGES_DIR);
+    } catch (error) {
+      postArchiveWarnings.push(`changes directory cleanup failed: ${toErrorMessage(error)}`);
+    }
+    const clearedMsg = focusCleared ? `  ${pc.dim("focus marker cleared")}
+` : "";
+    console.log(`  ${pc.green("Archived:")} ${archiveName}
+${clearedMsg}`);
+    try {
+      await buildArchiveIndex({ acquireLock: false });
+    } catch (error) {
+      postArchiveWarnings.push(`archive index rebuild failed: ${toErrorMessage(error)}`);
+    }
+    for (const warning of postArchiveWarnings)
+      console.log(`  ${pc.yellow("\u26A0")} ${warning}`);
+    if (postArchiveWarnings.length > 0)
+      console.log(`  ${pc.dim("Archive completed, but follow-up cleanup was only partially successful.")}
+`);
+    if (existsSync7(".git")) {
+      const archiveRelPath = dir !== "." ? join7(dir, archiveName) : archiveName;
+      console.log(`  ${pc.cyan("Git workflow:")}
 `);
+      console.log(`    git add .rsp/archives/${archiveRelPath}`);
+      console.log(`    git commit -m "feat: archive ${name}"`);
+      console.log();
+    }
+  });
+}
+function resolveArchiveName(archiveSubdir, date, base) {
+  const initialName = `${date}_${base}.md`;
+  if (!existsSync7(join7(archiveSubdir, initialName)))
+    return initialName;
+  const MAX_SUFFIX = 9999;
+  for (let index = 2; index <= MAX_SUFFIX; index++) {
+    const candidate = `${date}_${base}-${index}.md`;
+    if (!existsSync7(join7(archiveSubdir, candidate)))
+      return candidate;
+  }
+  console.error(`  ${pc.red("Error:")} archive name collision exceeded ${MAX_SUFFIX} attempts for ${base}`);
+  process.exit(1);
+}
+function collectArchiveChecklist(content) {
+  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`);
+  if (hasMeaningfulBlockers(content))
+    warnings.push("active blockers are present in the change file");
+  const scenarios = parseScenarios(content);
+  if (scenarios.length === 0)
+    warnings.push("no Scenario blocks found (some changes do not need them)");
+  return warnings;
 }
 
 // src/commands/check.ts
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 import { readFile as readFile7 } from "fs/promises";
-import { join as join7, relative as relative4 } from "path";
-async function runCheck() {
-  const featuresDir = join7(RSP_DIR, "features");
+import { join as join8, relative as relative4 } from "path";
+async function runCheck(options = {}) {
   const config = await loadRspConfig();
-  const validStatuses = resolveStatuses(config);
-  const validPriorities = resolvePriorities(config);
+  const validKinds = resolveKinds(config);
   const requiredSections = resolveRequiredSections(config);
-  let errors = 0;
-  let warnings = 0;
-  console.log();
-  console.log(`  ${pc.bold("RSP check")}`);
-  console.log();
-  if (existsSync7(ACTIVE_DIR)) {
-    const entries = await walkFiles(ACTIVE_DIR);
+  const choosePlaceholderRe = /^<choose:/i;
+  const diagnostics = [];
+  const runtime = [];
+  const reportRuntime = (diagnostic) => recordRuntimeDiagnostic(runtime, diagnostic, Boolean(options.verbose) && !options.json);
+  const addDiagnostic = (diagnostic) => diagnostics.push(diagnostic);
+  if (existsSync8(FOCUS_DIR)) {
+    const entries = await walkFiles(FOCUS_DIR, { onError: reportRuntime });
     for (const entryPath of entries) {
-      const entryContent = relative4(ACTIVE_DIR, entryPath);
-      const markerContent = (await readFile7(entryPath, "utf-8")).trim();
+      const entryContent = normalizeLogicalPath(relative4(FOCUS_DIR, entryPath));
+      let markerContent = "";
+      try {
+        markerContent = (await readFile7(entryPath, "utf-8")).trim();
+      } catch (error) {
+        addDiagnostic({
+          severity: "error",
+          code: "focus_marker_read_failed",
+          path: `focus.d/${entryContent}`,
+          change: entryContent,
+          message: "unable to read focus marker file",
+          hint: toErrorMessage(error)
+        });
+        reportRuntime({
+          code: "focus_marker_read_failed",
+          operation: "readFile",
+          path: entryPath,
+          message: toErrorMessage(error)
+        });
+        continue;
+      }
       if (markerContent) {
-        console.log(`  ${pc.yellow("\u26A0")} active.d/${entryContent} should be an empty marker file; path is the source of truth`);
-        warnings++;
+        addDiagnostic({
+          severity: "warning",
+          code: "focus_marker_not_empty",
+          path: `focus.d/${entryContent}`,
+          message: "should be an empty marker file; path is the source of truth"
+        });
       }
-      const fp = join7(featuresDir, `${entryContent}.md`);
-      if (!existsSync7(fp)) {
-        console.log(`  ${pc.red("\u2717")} active.d/${entryContent} points to "${entryContent}" but features/${entryContent}.md not found`);
-        errors++;
+      const fp = join8(CHANGES_DIR, `${entryContent}.md`);
+      if (!existsSync8(fp)) {
+        addDiagnostic({
+          severity: "error",
+          code: "focused_change_missing",
+          path: `focus.d/${entryContent}`,
+          change: entryContent,
+          message: `focuses "${entryContent}" but changes/${entryContent}.md not found`
+        });
       }
     }
   }
-  const featureFiles = existsSync7(featuresDir) ? await walkMarkdownFiles(featuresDir) : [];
-  if (featureFiles.length === 0) {
-    console.log(`  ${pc.dim("No feature files to check.")}
+  const changeFiles = existsSync8(CHANGES_DIR) ? await walkMarkdownFiles(CHANGES_DIR, { onError: reportRuntime }) : [];
+  if (changeFiles.length === 0) {
+    const result2 = {
+      command: "check",
+      ok: diagnostics.every((d) => d.severity !== "error"),
+      diagnostics,
+      runtime,
+      summary: {
+        changeFiles: 0,
+        errors: diagnostics.filter((d) => d.severity === "error").length,
+        warnings: diagnostics.filter((d) => d.severity === "warning").length
+      }
+    };
+    if (options.json) {
+      emitJson(result2);
+      return result2;
+    }
+    console.log();
+    console.log(`  ${pc.bold("RSP check")}`);
+    console.log();
+    if (diagnostics.length === 0) {
+      console.log(`  ${pc.dim("No change files to check.")}
+`);
+      return result2;
+    }
+    for (const diagnostic of diagnostics) {
+      const icon = diagnostic.severity === "error" ? pc.red("\u2717") : diagnostic.severity === "warning" ? pc.yellow("\u26A0") : pc.dim("\u2139");
+      const label = diagnostic.change ?? diagnostic.path;
+      const headline = label ? `${label} \u2014 ${diagnostic.message}` : diagnostic.message;
+      console.log(`  ${icon} ${headline}`);
+      for (const detail of diagnostic.details || [])
+        console.log(`      ${pc.dim(detail)}`);
+      if (diagnostic.hint)
+        console.log(`      ${pc.dim(diagnostic.hint)}`);
+    }
+    console.log();
+    console.log(`  ${pc.red(String(result2.summary.errors))} error(s), ${pc.yellow(String(result2.summary.warnings))} warning(s) in 0 change file(s).
 `);
-    return 0;
+    return result2;
   }
-  const allDeps = /* @__PURE__ */ new Map();
-  for (const fp of featureFiles) {
-    const name = featureNameFromPath(featuresDir, fp);
+  for (const fp of changeFiles) {
+    const name = changeNameFromPath(CHANGES_DIR, fp);
     let content;
     try {
       content = await readFile7(fp, "utf-8");
-    } catch {
-      console.log(`  ${pc.red("\u2717")} ${name} \u2014 unable to read file`);
-      errors++;
+    } catch (error) {
+      addDiagnostic({
+        severity: "error",
+        code: "change_read_failed",
+        change: name,
+        path: fp,
+        message: "unable to read file",
+        hint: toErrorMessage(error)
+      });
+      continue;
+    }
+    let fm = null;
+    try {
+      fm = parseFrontmatter(content);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      addDiagnostic({
+        severity: "error",
+        code: "invalid_frontmatter",
+        change: name,
+        path: fp,
+        message: `invalid YAML frontmatter (${message})`
+      });
       continue;
     }
-    const fm = parseFrontmatter(content);
     if (!fm) {
-      console.log(`  ${pc.red("\u2717")} ${name} \u2014 missing YAML frontmatter`);
-      errors++;
+      addDiagnostic({
+        severity: "error",
+        code: "missing_frontmatter",
+        change: name,
+        path: fp,
+        message: "missing YAML frontmatter"
+      });
     }
     for (const section of requiredSections) {
       if (!new RegExp(`^## ${section}$`, "m").test(content)) {
-        console.log(`  ${pc.red("\u2717")} ${name} \u2014 missing "## ${section}" section`);
-        errors++;
+        addDiagnostic({
+          severity: "error",
+          code: "missing_section",
+          change: name,
+          path: fp,
+          message: `missing "## ${section}" section`
+        });
       }
     }
     if (fm) {
-      if (!("status" in fm)) {
-        console.log(`  ${pc.red("\u2717")} ${name} \u2014 missing frontmatter field: status`);
-        errors++;
-      } else if (!validStatuses.includes(String(fm.status))) {
-        console.log(`  ${pc.red("\u2717")} ${name} \u2014 invalid status "${fm.status}" (valid: ${validStatuses.join(", ")})`);
-        errors++;
-      }
-      if (!("priority" in fm)) {
-        console.log(`  ${pc.red("\u2717")} ${name} \u2014 missing frontmatter field: priority`);
-        errors++;
-      } else if (!validPriorities.includes(String(fm.priority))) {
-        console.log(`  ${pc.red("\u2717")} ${name} \u2014 invalid priority "${fm.priority}" (valid: ${validPriorities.join(", ")})`);
-        errors++;
+      if (!("kind" in fm)) {
+        addDiagnostic({
+          severity: "error",
+          code: "missing_kind",
+          change: name,
+          path: fp,
+          message: "missing frontmatter field: kind"
+        });
+      } else if (choosePlaceholderRe.test(String(fm.kind))) {
+        addDiagnostic({
+          severity: "error",
+          code: "placeholder_kind",
+          change: name,
+          path: fp,
+          message: `kind still uses the template placeholder; choose one of: ${validKinds.join(", ")}`
+        });
+      } else if (!validKinds.includes(String(fm.kind))) {
+        addDiagnostic({
+          severity: "error",
+          code: "invalid_kind",
+          change: name,
+          path: fp,
+          message: `invalid kind "${fm.kind}" (valid: ${validKinds.join(", ")})`
+        });
       }
     }
-    const headingMatch = content.match(/^# Feature:[ \t]*([^\n]+)$/m);
-    if (headingMatch) {
-      const heading = headingMatch[1].trim();
+    const headingLine = content.split("\n").map((line) => line.trim()).find((line) => line.startsWith("# Change:"));
+    if (headingLine) {
+      const heading = headingLine.slice("# Change:".length).trim();
       if (heading !== name) {
-        console.log(`  ${pc.red("\u2717")} ${name} \u2014 # Feature: heading "${heading}" differs from feature name`);
-        errors++;
+        addDiagnostic({
+          severity: "error",
+          code: "heading_mismatch",
+          change: name,
+          path: fp,
+          message: `# Change: heading "${heading}" differs from change name`
+        });
       }
     } else {
-      console.log(`  ${pc.red("\u2717")} ${name} \u2014 missing "# Feature:" heading`);
-      errors++;
+      addDiagnostic({
+        severity: "error",
+        code: "missing_heading",
+        change: name,
+        path: fp,
+        message: 'missing "# Change:" heading'
+      });
     }
     const deltas = detectDeltaSections(content);
     if (deltas.added || deltas.modified || deltas.removed) {
@@ -722,7 +1078,13 @@ async function runCheck() {
         parts.push("MODIFIED");
       if (deltas.removed)
         parts.push("REMOVED");
-      console.log(`  ${pc.dim("\u2139")} ${name} \u2014 delta markers found: ${parts.join(", ")}`);
+      addDiagnostic({
+        severity: "info",
+        code: "delta_markers_found",
+        change: name,
+        path: fp,
+        message: `delta markers found: ${parts.join(", ")}`
+      });
     }
     const scenarios = parseScenarios(content);
     if (scenarios.length > 0) {
@@ -742,509 +1104,482 @@ async function runCheck() {
           scenarioIssues.push(`"${s.heading}" missing ${missing.join("/")}`);
       }
       if (scenarioIssues.length > 0) {
-        console.log(`  ${pc.yellow("\u26A0")} ${name} \u2014 scenario format issues:`);
-        for (const issue of scenarioIssues)
-          console.log(`      ${pc.dim(issue)}`);
-        warnings++;
+        addDiagnostic({
+          severity: "warning",
+          code: "scenario_format_issues",
+          change: name,
+          path: fp,
+          message: "scenario format issues",
+          details: scenarioIssues
+        });
       }
     }
-    if (fm && fm["depends-on"]) {
-      const deps = Array.isArray(fm["depends-on"]) ? fm["depends-on"] : [fm["depends-on"]];
-      const seen = /* @__PURE__ */ new Set();
-      for (const dep of deps) {
-        if (dep === name) {
-          console.log(`  ${pc.red("\u2717")} ${name} \u2014 depends on itself`);
-          errors++;
-          continue;
-        }
-        if (seen.has(dep)) {
-          console.log(`  ${pc.red("\u2717")} ${name} \u2014 duplicate dependency "${dep}"`);
-          errors++;
-          continue;
-        }
-        seen.add(dep);
-        allDeps.set(name, [...allDeps.get(name) || [], dep]);
-        const depFp = join7(featuresDir, `${dep}.md`);
-        if (!existsSync7(depFp)) {
-          console.log(`  ${pc.red("\u2717")} ${name} \u2014 depends on "${dep}" but features/${dep}.md not found`);
-          errors++;
-        }
-      }
+  }
+  const result = {
+    command: "check",
+    ok: diagnostics.every((d) => d.severity !== "error"),
+    diagnostics,
+    runtime,
+    summary: {
+      changeFiles: changeFiles.length,
+      errors: diagnostics.filter((d) => d.severity === "error").length,
+      warnings: diagnostics.filter((d) => d.severity === "warning").length
     }
+  };
+  if (options.json) {
+    emitJson(result);
+    return result;
   }
-  const cycles = detectCycles(allDeps);
-  for (const cycle of cycles) {
-    console.log(`  ${pc.red("\u2717")} circular dependency: ${cycle.join(" \u2192 ")}`);
-    errors++;
+  console.log();
+  console.log(`  ${pc.bold("RSP check")}`);
+  console.log();
+  for (const diagnostic of diagnostics) {
+    const icon = diagnostic.severity === "error" ? pc.red("\u2717") : diagnostic.severity === "warning" ? pc.yellow("\u26A0") : pc.dim("\u2139");
+    const label = diagnostic.change ?? diagnostic.path;
+    const headline = label ? `${label} \u2014 ${diagnostic.message}` : diagnostic.message;
+    console.log(`  ${icon} ${headline}`);
+    for (const detail of diagnostic.details || [])
+      console.log(`      ${pc.dim(detail)}`);
+    if (diagnostic.hint)
+      console.log(`      ${pc.dim(diagnostic.hint)}`);
   }
   console.log();
-  if (errors === 0 && warnings === 0)
-    console.log(`  ${pc.green("\u2713")} All ${featureFiles.length} feature file(s) valid.
+  if (result.summary.errors === 0 && result.summary.warnings === 0)
+    console.log(`  ${pc.green("\u2713")} All ${changeFiles.length} change file(s) valid.
 `);
   else
-    console.log(`  ${pc.red(String(errors))} error(s), ${pc.yellow(String(warnings))} warning(s) in ${featureFiles.length} feature file(s).
+    console.log(`  ${pc.red(String(result.summary.errors))} error(s), ${pc.yellow(String(result.summary.warnings))} warning(s) in ${changeFiles.length} change file(s).
 `);
-  return errors;
+  return result;
 }
 
-// src/commands/close-feature.ts
-import { existsSync as existsSync8 } from "fs";
-import { mkdir as mkdir4, readdir as readdir2, readFile as readFile8, rename, rmdir, unlink as unlink2 } from "fs/promises";
-import { basename as basename5, dirname as dirname5, join as join8 } from "path";
-async function closeFeature(name) {
-  return withRspLock("close-feature", async () => {
-    if (!name) {
-      console.error(`  ${pc.red("Usage:")} rsp close <name>`);
-      process.exit(1);
-    }
-    if (/^[a-z0-9-]+(?:\/[a-z0-9-]+)*$/.test(name) === false) {
-      console.error(`  ${pc.red("Error:")} feature name must be kebab-case with optional subdirectory (lowercase, digits, hyphens, slashes)`);
-      process.exit(1);
-    }
-    const srcPath = join8(RSP_DIR, "features", `${name}.md`);
-    if (!existsSync8(srcPath)) {
-      console.error(`  ${pc.red("Feature not found:")} .rsp/features/${name}.md`);
-      process.exit(1);
-    }
-    const dependents = await findDependents(name);
-    if (dependents.length > 0) {
-      console.error(`  ${pc.red("Error:")} cannot close "${name}" because it is still referenced by: ${dependents.join(", ")}`);
-      console.error(`  ${pc.dim("Remove or update those depends-on entries before archiving this feature.")}`);
-      process.exit(1);
-    }
-    const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    const dir = dirname5(name);
-    const base = basename5(name);
-    const archiveSubdir = dir !== "." ? join8(ARCHIVES_DIR, dir) : ARCHIVES_DIR;
-    const archiveName = `${date}_${base}.md`;
-    await mkdir4(archiveSubdir, { recursive: true });
-    await rename(srcPath, join8(archiveSubdir, archiveName));
-    let activeCleared = false;
-    const activeEntry = join8(ACTIVE_DIR, name);
-    if (existsSync8(activeEntry)) {
-      await unlink2(activeEntry);
-      await cleanupEmptyParentDirs(activeEntry, ACTIVE_DIR);
-      activeCleared = true;
+// src/commands/create.ts
+import { existsSync as existsSync9 } from "fs";
+import { mkdir as mkdir5, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname7, join as join9 } from "path";
+async function createChange(name, summary = "", kind) {
+  if (!name) {
+    console.error(`  ${pc.red("Usage:")} rsp create <name> [summary]`);
+    process.exit(1);
+  }
+  if (!isValidChangeName(name)) {
+    console.error(`  ${pc.red("Error:")} change name must be kebab-case with optional subdirectory (lowercase, digits, hyphens, slashes)`);
+    process.exit(1);
+  }
+  guardRspInitialized();
+  return withRspLock("create-change", async () => {
+    const changePath = join9(CHANGES_DIR, `${name}.md`);
+    await mkdir5(dirname7(changePath), { recursive: true });
+    const existed = existsSync9(changePath);
+    if (!existed) {
+      const content = generateChangeContent(name, summary, kind);
+      await writeFile6(changePath, content);
+      await mkdir5(FOCUS_DIR, { recursive: true });
+      const focusEntry = join9(FOCUS_DIR, name);
+      await mkdir5(dirname7(focusEntry), { recursive: true });
+      await writeFile6(focusEntry, "");
     }
-    await cleanupEmptyParentDirs(srcPath, join8(RSP_DIR, "features"));
-    const clearedMsg = activeCleared ? `  ${pc.dim("active.d cleared")}
-` : "";
-    console.log(`  ${pc.green("Archived:")} ${archiveName}
-${clearedMsg}`);
-    await buildArchiveIndex({ acquireLock: false });
-    await runCheckIfHasDependents(name);
-    if (existsSync8(".git")) {
-      const archiveRelPath = dir !== "." ? join8(dir, archiveName) : archiveName;
-      console.log(`  ${pc.cyan("Git workflow:")}
+    const label = existed ? "Using" : pc.green("Created");
+    console.log(`  ${label}: ${changePath}`);
+    if (existed)
+      console.log(`  ${pc.dim("Unchanged focus.")} Run: rsp focus ${name}`);
+    else
+      console.log(`  ${pc.dim("focused via focus.d")} \u2192 ${name}`);
+    console.log(`  ${pc.cyan("Next:")} edit the change file and complete the tasks
 `);
-      console.log(`    git add .rsp/archives/${archiveRelPath}`);
-      console.log(`    git commit -m "feat: complete ${name}"`);
-      console.log();
-    }
   });
 }
-async function findDependents(name) {
-  const featuresDir = join8(RSP_DIR, "features");
-  const allFeatureFiles = await walkMarkdownFiles(featuresDir);
-  const dependents = [];
-  for (const fp of allFeatureFiles) {
-    const featureName = fp === join8(featuresDir, `${name}.md`) ? name : fp.replace(`${featuresDir}/`, "").replace(/\.md$/, "");
-    if (featureName === name)
-      continue;
-    const content = await readFile8(fp, "utf-8");
-    const fm = parseFrontmatter(content);
-    if (!fm || !fm["depends-on"])
-      continue;
-    const deps = Array.isArray(fm["depends-on"]) ? fm["depends-on"] : [fm["depends-on"]];
-    if (deps.includes(name))
-      dependents.push(featureName);
+
+// src/commands/doctor.ts
+import { existsSync as existsSync10 } from "fs";
+import { readFile as readFile8 } from "fs/promises";
+import { basename as basename5, join as join10, relative as relative5 } from "path";
+async function runDoctor(options = {}) {
+  const checks = [];
+  const runtime = [];
+  const reportRuntime = (diagnostic) => recordRuntimeDiagnostic(runtime, diagnostic, Boolean(options.verbose) && !options.json);
+  const rspRulesPath = join10(RSP_DIR, "rules", "rsp-rules.md");
+  const designPath = join10(RSP_DIR, "specs", "design.md");
+  const specsIndexPath = join10(RSP_DIR, "specs", "INDEX.md");
+  const archivesIndexPath = join10(RSP_DIR, "archives", "INDEX.md");
+  reportCheck(checks, ".rsp exists", existsSync10(RSP_DIR), "Run: rsp init");
+  reportCheck(checks, "rules/rsp-rules.md exists", existsSync10(rspRulesPath), "Run: rsp init");
+  reportCheck(checks, "specs/design.md exists", existsSync10(designPath), "Run: rsp init");
+  reportCheck(checks, "specs/INDEX.md exists", existsSync10(specsIndexPath), "Run: rsp update");
+  reportCheck(checks, "archives/INDEX.md exists", existsSync10(archivesIndexPath), "Run: rsp update");
+  await checkAgents(checks, reportRuntime);
+  await checkGeneratedIndex(checks, reportRuntime, specsIndexPath, "_Auto-generated by `rsp update`._", "specs/INDEX.md has generated signature", "Run: rsp update");
+  await checkGeneratedIndex(checks, reportRuntime, archivesIndexPath, "_Auto-generated by `rsp update`._", "archives/INDEX.md has generated signature", "Run: rsp update");
+  await checkArchiveNaming(checks, reportRuntime);
+  await checkConfigSemantics(checks, reportRuntime);
+  await checkActiveChangeConsistency(checks, reportRuntime);
+  const result = {
+    command: "doctor",
+    ok: checks.every((check) => check.status !== "issue"),
+    checks,
+    runtime,
+    summary: {
+      issues: checks.filter((check) => check.status === "issue").length
+    }
+  };
+  if (options.json) {
+    emitJson(result);
+    return result;
   }
-  return dependents.sort();
+  console.log();
+  console.log(`  ${pc.bold("RSP doctor")}`);
+  console.log();
+  for (const check of checks)
+    printDoctorCheck(check);
+  if (result.summary.issues === 0)
+    console.log(`
+  ${pc.green("\u2713")} RSP setup looks healthy.
+`);
+  else
+    console.log(`
+  ${pc.yellow(String(result.summary.issues))} issue(s) detected.
+`);
+  return result;
 }
-async function runCheckIfHasDependents(name) {
-  try {
-    const hasDependents = (await findDependents(name)).length > 0;
-    if (hasDependents)
-      await runCheck();
-  } catch {
-    console.warn(`  ${pc.dim("\u26A0 could not verify dependents for")} "${name}"`);
-  }
-}
-async function cleanupEmptyParentDirs(path, stopDir) {
-  let parent = dirname5(path);
-  while (parent !== stopDir) {
-    try {
-      const remaining = await readdir2(parent);
-      if (remaining.length === 0)
-        await rmdir(parent);
-      else
-        break;
-    } catch {
-      break;
-    }
-    parent = dirname5(parent);
-  }
-}
-
-// src/commands/deps.ts
-import { existsSync as existsSync9 } from "fs";
-import { readFile as readFile9 } from "fs/promises";
-import { join as join9 } from "path";
-async function showDependencies(options = false) {
-  const resolved = typeof options === "boolean" ? { mermaid: options } : options;
-  const mermaid = Boolean(resolved.mermaid);
-  const focus = resolved.focus?.trim();
-  const reverse = resolved.reverse?.trim();
-  if (focus && reverse)
-    throw new Error("Use either --focus or --reverse, not both");
-  const featuresDir = join9(RSP_DIR, "features");
-  const featureFiles = existsSync9(featuresDir) ? await walkMarkdownFiles(featuresDir) : [];
-  console.log();
-  console.log(`  ${pc.bold("RSP dependencies")}`);
-  console.log();
-  if (featureFiles.length === 0) {
-    console.log(`  ${pc.dim("No features found.")}
-`);
+function reportCheck(checks, label, ok, fixHint) {
+  if (ok) {
+    checks.push({ status: "ok", label });
     return;
   }
-  const records = [];
-  const dependents = /* @__PURE__ */ new Map();
-  for (const fp of featureFiles) {
-    const name = featureNameFromPath(featuresDir, fp);
-    let content;
-    try {
-      content = await readFile9(fp, "utf-8");
-    } catch {
-      continue;
-    }
-    const fm = parseFrontmatter(content);
-    const depsRaw = fm?.["depends-on"] ? Array.isArray(fm["depends-on"]) ? fm["depends-on"] : [fm["depends-on"]] : [];
-    const deps = depsRaw.filter(Boolean);
-    records.push({ name, deps });
-    for (const dep of deps) {
-      const list = dependents.get(dep) || [];
-      list.push(name);
-      dependents.set(dep, list);
-    }
-  }
-  let visibleRecords = [...records];
-  if (focus) {
-    const related = /* @__PURE__ */ new Set([focus]);
-    const target = records.find((record) => record.name === focus);
-    if (target) {
-      for (const dep of target.deps)
-        related.add(dep);
-    }
-    for (const dependent of dependents.get(focus) || [])
-      related.add(dependent);
-    visibleRecords = records.filter((record) => related.has(record.name));
-  } else if (reverse) {
-    const related = new Set(dependents.get(reverse) || []);
-    visibleRecords = records.filter((record) => related.has(record.name));
-  }
-  if ((focus || reverse) && visibleRecords.length === 0) {
-    console.log(`  ${pc.dim("No dependency matches found for the current filter.")}
-`);
+  checks.push({ status: "issue", label, hint: fixHint });
+}
+function printDoctorCheck(check) {
+  if (check.status === "ok") {
+    console.log(`  ${pc.green("\u2713")} ${check.label}`);
     return;
   }
-  if (mermaid) {
-    console.log("```mermaid");
-    console.log("graph LR");
-    const safeId = (s) => s.replace(/\//g, "__slash__").replace(/\W/g, "_");
-    for (const { name } of visibleRecords) {
-      const id = safeId(name);
-      const label = name.replace(/"/g, "#quot;");
-      console.log(`    ${id}["${label}"]`);
-    }
-    const visibleNames = new Set(visibleRecords.map((record) => record.name));
-    for (const { name, deps } of visibleRecords) {
-      const fromId = safeId(name);
-      for (const dep of deps) {
-        if (!visibleNames.has(dep))
-          continue;
-        const toId = safeId(dep);
-        console.log(`    ${fromId} --> ${toId}`);
-      }
-    }
-    console.log("```");
-    console.log();
+  if (check.status === "info") {
+    console.log(`  ${pc.dim(`Info: ${check.message || check.label}`)}`);
+    if (check.hint)
+      console.log(`    ${pc.dim(check.hint)}`);
     return;
   }
-  console.log(`  ${"Feature".padEnd(28)} ${"Depends On".padEnd(28)} Dependents`);
-  console.log(`  ${"\u2500".repeat(28)} ${"\u2500".repeat(28)} \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
-  for (const { name, deps } of visibleRecords.sort((a, b) => a.name.localeCompare(b.name))) {
-    const depText = deps.length > 0 ? deps.join(", ") : "\u2014";
-    const dependentText = (dependents.get(name) || []).length > 0 ? pc.dim((dependents.get(name) || []).join(", ")) : "\u2014";
-    console.log(`  ${name.padEnd(28)} ${depText.padEnd(28)} ${dependentText}`);
-  }
-  console.log();
-}
-
-// src/commands/doctor.ts
-import { existsSync as existsSync10 } from "fs";
-import { readFile as readFile10 } from "fs/promises";
-import { join as join10, relative as relative5 } from "path";
-async function runDoctor() {
-  let issues = 0;
-  console.log();
-  console.log(`  ${pc.bold("RSP doctor")}`);
-  console.log();
-  const rspRulesPath = join10(RSP_DIR, "rules", "rsp-rules.md");
-  const designPath = join10(RSP_DIR, "specs", "design.md");
-  const specsIndexPath = join10(RSP_DIR, "specs", "INDEX.md");
-  const archivesIndexPath = join10(RSP_DIR, "archives", "INDEX.md");
-  issues += reportCheck(".rsp exists", existsSync10(RSP_DIR), "Run: rsp init");
-  issues += reportCheck("rules/rsp-rules.md exists", existsSync10(rspRulesPath), "Run: rsp init");
-  issues += reportCheck("specs/design.md exists", existsSync10(designPath), "Run: rsp init");
-  issues += reportCheck("specs/INDEX.md exists", existsSync10(specsIndexPath), "Run: rsp specs-index");
-  issues += reportCheck("archives/INDEX.md exists", existsSync10(archivesIndexPath), "Run: rsp archive-index");
-  issues += await checkAgents();
-  issues += await checkGeneratedIndex(specsIndexPath, "_Auto-generated by `rsp specs-index`._", "specs/INDEX.md has generated signature", "Run: rsp specs-index");
-  issues += await checkGeneratedIndex(archivesIndexPath, "_Auto-generated by `rsp archive-index`._", "archives/INDEX.md has generated signature", "Run: rsp archive-index");
-  issues += await checkArchiveNaming();
-  issues += await checkConfigSemantics();
-  issues += await checkActiveFeatureConsistency();
-  if (issues === 0)
-    console.log(`
-  ${pc.green("\u2713")} RSP setup looks healthy.
-`);
-  else
-    console.log(`
-  ${pc.yellow(String(issues))} issue(s) detected.
-`);
-  return issues;
-}
-function reportCheck(label, ok, fixHint) {
-  if (ok) {
-    console.log(`  ${pc.green("\u2713")} ${label}`);
-    return 0;
-  }
-  console.log(`  ${pc.yellow("!")} ${label}`);
-  if (fixHint)
-    console.log(`    ${pc.dim(fixHint)}`);
-  return 1;
+  console.log(`  ${pc.yellow("!")} ${check.message || check.label}`);
+  if (check.hint)
+    console.log(`    ${pc.dim(check.hint)}`);
 }
-async function checkAgents() {
+async function checkAgents(checks, reportRuntime) {
   if (!existsSync10("AGENTS.md")) {
-    console.log(`  ${pc.yellow("!")} AGENTS.md missing`);
-    console.log(`    ${pc.dim("Run: rsp init --agents-mode managed")}`);
-    return 1;
+    checks.push({ status: "issue", label: "AGENTS.md contains managed RSP block", message: "AGENTS.md missing", hint: "Run: rsp init" });
+    return;
+  }
+  let agents;
+  try {
+    agents = await readFile8("AGENTS.md", "utf-8");
+  } catch (error) {
+    reportRuntime({
+      code: "agents_read_failed",
+      operation: "readFile",
+      path: "AGENTS.md",
+      message: toErrorMessage(error)
+    });
+    checks.push({ status: "issue", label: "AGENTS.md contains managed RSP block", message: "AGENTS.md could not be read", hint: "Check AGENTS.md permissions or recreate it with rsp init" });
+    return;
   }
-  const agents = await readFile10("AGENTS.md", "utf-8");
   if (hasRspAgentsBlock(agents)) {
-    console.log(`  ${pc.green("\u2713")} AGENTS.md contains managed RSP block`);
-    return 0;
+    checks.push({ status: "ok", label: "AGENTS.md contains managed RSP block" });
+    return;
   }
-  console.log(`  ${pc.yellow("!")} AGENTS.md missing managed RSP block`);
-  console.log(`    ${pc.dim("Run: rsp init --agents-mode managed")}`);
-  return 1;
+  checks.push({ status: "issue", label: "AGENTS.md contains managed RSP block", message: "AGENTS.md missing managed RSP block", hint: "Run: rsp init" });
 }
-async function checkGeneratedIndex(path, signature, label, fixHint) {
+async function checkGeneratedIndex(checks, reportRuntime, path, signature, label, fixHint) {
   if (!existsSync10(path))
-    return 0;
-  const content = await readFile10(path, "utf-8");
+    return;
+  let content;
+  try {
+    content = await readFile8(path, "utf-8");
+  } catch (error) {
+    reportRuntime({
+      code: "generated_index_read_failed",
+      operation: "readFile",
+      path,
+      message: toErrorMessage(error)
+    });
+    checks.push({ status: "issue", label, message: `${label} could not be read`, hint: fixHint });
+    return;
+  }
   if (content.includes(signature)) {
-    console.log(`  ${pc.green("\u2713")} ${label}`);
-    return 0;
+    checks.push({ status: "ok", label });
+    return;
   }
-  console.log(`  ${pc.yellow("!")} ${label}`);
-  console.log(`    ${pc.dim(fixHint)}`);
-  return 1;
+  checks.push({ status: "issue", label, hint: fixHint });
 }
-async function checkArchiveNaming() {
+async function checkArchiveNaming(checks, reportRuntime) {
   const archivesDir = join10(RSP_DIR, "archives");
-  const archiveFiles = existsSync10(archivesDir) ? (await walkMarkdownFiles(archivesDir)).filter((fp) => relative5(archivesDir, fp) !== "INDEX.md") : [];
-  const invalidFiles = archiveFiles.map((fp) => relative5(archivesDir, fp)).filter((fp) => /^\d{4}-\d{2}-\d{2}_.+\.md$/.test(fp.split("/").at(-1) || "") === false);
+  const archiveFiles = existsSync10(archivesDir) ? (await walkMarkdownFiles(archivesDir, { onError: reportRuntime })).filter((fp) => relative5(archivesDir, fp) !== "INDEX.md") : [];
+  const invalidFiles = archiveFiles.map((fp) => normalizeLogicalPath(relative5(archivesDir, fp))).filter((fp) => /^\d{4}-\d{2}-\d{2}_.+\.md$/.test(basename5(fp)) === false);
   if (invalidFiles.length === 0) {
-    console.log(`  ${pc.green("\u2713")} archived feature files follow the date_name.md convention`);
-    return 0;
+    checks.push({ status: "ok", label: "archived change files follow the date_name.md convention" });
+    return;
   }
-  console.log(`  ${pc.yellow("!")} archived feature files with invalid names: ${invalidFiles.join(", ")}`);
-  console.log(`    ${pc.dim("Rename archive files to YYYY-MM-DD_name.md and run: rsp archive-index")}`);
-  return 1;
+  checks.push({
+    status: "issue",
+    label: "archived change files follow the date_name.md convention",
+    message: `archived change files with invalid names: ${invalidFiles.join(", ")}`,
+    hint: "Rename archive files to YYYY-MM-DD_name.md and run: rsp update"
+  });
 }
-async function checkConfigSemantics() {
+async function checkConfigSemantics(checks, reportRuntime) {
   if (!existsSync10(CONFIG_PATH))
-    return 0;
-  const content = await readFile10(CONFIG_PATH, "utf-8");
-  const parsed = parseYamlLines(content.split("\n"));
-  let issues = 0;
-  issues += reportConfigListField(parsed, "statuses");
-  issues += reportConfigListField(parsed, "priorities");
-  issues += reportConfigListField(parsed, "required_sections");
-  return issues;
-}
-function reportConfigListField(parsed, key) {
+    return;
+  let content;
+  try {
+    content = await readFile8(CONFIG_PATH, "utf-8");
+  } catch (error) {
+    reportRuntime({
+      code: "config_read_failed",
+      operation: "readFile",
+      path: CONFIG_PATH,
+      message: toErrorMessage(error)
+    });
+    checks.push({ status: "issue", label: "config.yaml semantic checks", message: "config.yaml could not be read", hint: "Check .rsp/config.yaml permissions or recreate it with rsp init" });
+    return;
+  }
+  let parsed;
+  try {
+    parsed = parseYamlText(content);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    checks.push({ status: "issue", label: "config.yaml semantic checks", message: "config.yaml is not valid YAML", hint: message });
+    return;
+  }
+  reportConfigListField(checks, parsed, "kinds");
+  if ("required_sections" in parsed) {
+    checks.push({
+      status: "issue",
+      label: "config.yaml semantic checks",
+      message: 'config.yaml field "required_sections" is no longer supported',
+      hint: 'RSP keeps the core change section structure fixed. Remove "required_sections" from .rsp/config.yaml.'
+    });
+  }
+}
+function reportConfigListField(checks, parsed, key) {
   if (!(key in parsed))
-    return 0;
+    return;
   const value = parsed[key];
   if (!Array.isArray(value)) {
-    console.log(`  ${pc.yellow("!")} config.yaml field "${key}" must be a YAML list`);
-    console.log(`    ${pc.dim(`Update .rsp/config.yaml so "${key}" uses "key:" followed by indented "- item" entries`)}`);
-    return 1;
+    checks.push({
+      status: "issue",
+      label: "config.yaml semantic checks",
+      message: `config.yaml field "${key}" must be a YAML list`,
+      hint: `Update .rsp/config.yaml so "${key}" is a YAML sequence (for example: ${key}: [item])`
+    });
+    return;
   }
   const items = value.map(String);
   const duplicates = [...new Set(items.filter((item, index) => items.indexOf(item) !== index))];
   if (duplicates.length === 0) {
-    console.log(`  ${pc.green("\u2713")} config.yaml field "${key}" has valid list semantics`);
-    return 0;
-  }
-  console.log(`  ${pc.yellow("!")} config.yaml field "${key}" contains duplicate entries: ${duplicates.join(", ")}`);
-  console.log(`    ${pc.dim(`Remove duplicate values from .rsp/config.yaml:${key}`)}`);
-  return 1;
-}
-async function checkActiveFeatureConsistency() {
-  const featuresDir = join10(RSP_DIR, "features");
-  const featureFiles = existsSync10(featuresDir) ? await walkMarkdownFiles(featuresDir) : [];
-  const featureNames = new Set(featureFiles.map((fp) => relative5(featuresDir, fp).replace(/\.md$/, "")));
-  const activeEntries = existsSync10(ACTIVE_DIR) ? await walkFiles(ACTIVE_DIR) : [];
-  const activeNames = new Set(activeEntries.map((fp) => relative5(ACTIVE_DIR, fp)));
-  const missingFeatureFiles = [...activeNames].filter((name) => !featureNames.has(name));
-  const unstagedActiveMarkers = [...featureNames].filter((name) => !activeNames.has(name));
-  let issues = 0;
-  if (missingFeatureFiles.length === 0) {
-    console.log(`  ${pc.green("\u2713")} every active marker maps to a feature file`);
+    checks.push({ status: "ok", label: `config.yaml field "${key}" has valid list semantics` });
+    return;
+  }
+  checks.push({
+    status: "issue",
+    label: "config.yaml semantic checks",
+    message: `config.yaml field "${key}" contains duplicate entries: ${duplicates.join(", ")}`,
+    hint: `Remove duplicate values from .rsp/config.yaml:${key}`
+  });
+}
+async function checkActiveChangeConsistency(checks, reportRuntime) {
+  const changeFiles = existsSync10(CHANGES_DIR) ? await walkMarkdownFiles(CHANGES_DIR, { onError: reportRuntime }) : [];
+  const changeNames = new Set(changeFiles.map((fp) => changeNameFromPath(CHANGES_DIR, fp)));
+  const focusEntries = existsSync10(FOCUS_DIR) ? await walkFiles(FOCUS_DIR, { onError: reportRuntime }) : [];
+  const focusNames = new Set(focusEntries.map((fp) => normalizeLogicalPath(relative5(FOCUS_DIR, fp))));
+  const missingChangeFiles = [...focusNames].filter((name) => !changeNames.has(name));
+  const unfocusedChangeFiles = [...changeNames].filter((name) => !focusNames.has(name));
+  if (missingChangeFiles.length === 0) {
+    checks.push({ status: "ok", label: "every focus marker maps to a change file" });
   } else {
-    console.log(`  ${pc.yellow("!")} active markers without matching feature files: ${missingFeatureFiles.join(", ")}`);
-    console.log(`    ${pc.dim("Run: remove stale files in .rsp/active.d/ or recreate the feature with rsp new <name>")}`);
-    issues++;
+    checks.push({
+      status: "issue",
+      label: "every focus marker maps to a change file",
+      message: `focus markers without matching change files: ${missingChangeFiles.join(", ")}`,
+      hint: "Run: remove stale files in .rsp/focus.d/ or recreate the change with rsp create <name>"
+    });
   }
-  if (unstagedActiveMarkers.length === 0) {
-    console.log(`  ${pc.green("\u2713")} every feature file has an active marker`);
+  if (unfocusedChangeFiles.length === 0) {
+    checks.push({ status: "ok", label: "focus markers are consistent with open changes" });
   } else {
-    console.log(`  ${pc.yellow("!")} feature files without active markers: ${unstagedActiveMarkers.join(", ")}`);
-    console.log(`    ${pc.dim("Run: recreate the marker with rsp new <name> or archive the feature with rsp close <name>")}`);
-    issues++;
+    const preview = unfocusedChangeFiles.slice(0, 5).join(", ");
+    const extra = unfocusedChangeFiles.length > 5 ? ` (+${unfocusedChangeFiles.length - 5} more)` : "";
+    checks.push({
+      status: "info",
+      label: "focus markers are consistent with open changes",
+      message: `unfocused open changes: ${preview}${extra}`,
+      hint: "Only changes listed in .rsp/focus.d/ are currently focused. Use rsp focus <name> to foreground one."
+    });
   }
-  return issues;
 }
 
-// src/commands/init.ts
+// src/commands/focus.ts
 import { existsSync as existsSync11 } from "fs";
-import { mkdir as mkdir5, readFile as readFile11, writeFile as writeFile6 } from "fs/promises";
-import { basename as basename6, join as join11 } from "path";
-var CONFIG_TEMPLATE = `# RSP project configuration
-# Uncomment any section below to override defaults.
+import { mkdir as mkdir6, unlink as unlink3, writeFile as writeFile7 } from "fs/promises";
+import { dirname as dirname8, join as join11 } from "path";
+async function focusChange(name) {
+  if (!name) {
+    console.error(`  ${pc.red("Usage:")} rsp focus <name>`);
+    process.exit(1);
+  }
+  if (!isValidChangeName(name)) {
+    console.error(`  ${pc.red("Error:")} change name must be kebab-case with optional subdirectory (lowercase, digits, hyphens, slashes)`);
+    process.exit(1);
+  }
+  guardRspInitialized();
+  const changePath = join11(CHANGES_DIR, `${name}.md`);
+  if (!existsSync11(changePath)) {
+    console.error(`  ${pc.red("Change not found:")} .rsp/changes/${name}.md`);
+    process.exit(1);
+  }
+  return withRspLock("focus-change", async () => {
+    await mkdir6(FOCUS_DIR, { recursive: true });
+    const focusEntry = join11(FOCUS_DIR, name);
+    await mkdir6(dirname8(focusEntry), { recursive: true });
+    await writeFile7(focusEntry, "");
+    console.log(`  ${pc.green("Focused:")} ${name}`);
+    console.log(`  ${pc.dim("focus.d")} \u2192 ${name}`);
+    console.log();
+  });
+}
+async function unfocusChange(name) {
+  if (!name) {
+    console.error(`  ${pc.red("Usage:")} rsp unfocus <name>`);
+    process.exit(1);
+  }
+  if (!isValidChangeName(name)) {
+    console.error(`  ${pc.red("Error:")} change name must be kebab-case with optional subdirectory (lowercase, digits, hyphens, slashes)`);
+    process.exit(1);
+  }
+  guardRspInitialized();
+  const focusEntry = join11(FOCUS_DIR, name);
+  if (!existsSync11(focusEntry)) {
+    console.error(`  ${pc.red("Focus marker not found:")} .rsp/focus.d/${name}`);
+    process.exit(1);
+  }
+  return withRspLock("unfocus-change", async () => {
+    await unlink3(focusEntry);
+    await cleanupEmptyParentDirs(focusEntry, FOCUS_DIR);
+    console.log(`  ${pc.green("Unfocused:")} ${name}`);
+    console.log(`  ${pc.dim("focus.d cleared")} \u2192 ${name}`);
+    console.log();
+  });
+}
+
+// src/commands/init.ts
+import { existsSync as existsSync12 } from "fs";
+import { mkdir as mkdir7, readFile as readFile9, writeFile as writeFile8 } from "fs/promises";
+import { join as join12 } from "path";
+function generateConfigTemplate() {
+  const fmtList = (items, indent) => items.map((i) => `${" ".repeat(indent)}# - ${i}`).join("\n");
+  return `# RSP project configuration
+# Uncomment any section below to customize classification values.
 #
 # Built-in defaults:
-#   statuses:            draft, ready, in-progress, blocked, done
-#   priorities:          low, medium, high, critical
-#   required_sections:   Spec, Plan
+#   kinds:               ${VALID_KINDS.join(", ")}
 #
-# statuses:
-#   - draft
-#   - ready
-#   - in-progress
-#   - blocked
-#   - done
-#
-# priorities:
-#   - low
-#   - medium
-#   - high
-#   - critical
-#
-# required_sections:
-#   - Spec
-#   - Plan
+# kinds:
+${fmtList(VALID_KINDS, 2)}
 `;
-async function detectProjectName3() {
-  try {
-    if (existsSync11("package.json")) {
-      const raw = await readFile11("package.json", "utf-8");
-      const pkg = JSON.parse(raw);
-      if (pkg.name && pkg.name !== "")
-        return pkg.name;
-    }
-  } catch {
-  }
-  return basename6(process.cwd());
 }
 async function ensureFile(path, content) {
-  if (existsSync11(path))
+  if (existsSync12(path))
     return false;
-  await writeFile6(path, content);
+  await writeFile8(path, content);
   return true;
 }
 function toTitle(projectName) {
   return projectName.startsWith("@") ? projectName.split("/")[1] || projectName : projectName;
 }
 async function initProject(args = {}) {
-  const isNew = !existsSync11(RSP_DIR);
-  const projectName = await detectProjectName3();
+  const isNew = !existsSync12(RSP_DIR);
+  const projectName = await detectProjectName();
+  const mode = args.agentsMode ?? "managed";
+  if (mode !== "managed" && mode !== "print") {
+    console.error(`  ${pc.red("Error:")} unsupported --agents-mode "${mode}". Use: managed or print`);
+    process.exit(1);
+  }
   return withRspLock("init", async () => {
     const dirs = [
-      join11(RSP_DIR, "rules"),
-      join11(RSP_DIR, "specs"),
-      join11(RSP_DIR, "features"),
-      join11(RSP_DIR, "active.d"),
-      join11(RSP_DIR, "archives")
+      join12(RSP_DIR, "rules"),
+      join12(RSP_DIR, "specs"),
+      CHANGES_DIR,
+      FOCUS_DIR,
+      join12(RSP_DIR, "archives")
     ];
     for (const d of dirs)
-      await mkdir5(d, { recursive: true });
+      await mkdir7(d, { recursive: true });
     let created = false;
-    const bundledRules = await readFile11(join11(PKG_ROOT, "rules", "rsp-rules.md"), "utf-8");
-    created = await ensureFile(join11(RSP_DIR, "rules", "rsp-rules.md"), bundledRules) || created;
-    created = await ensureFile(join11(RSP_DIR, "config.yaml"), CONFIG_TEMPLATE) || created;
-    const createdSpecsIndex = await ensureFile(join11(RSP_DIR, "specs", "INDEX.md"), "# Specs Index\n\n_Project-level specs and design notes._\n");
+    const bundledRules = await readFile9(join12(PKG_ROOT, "rules", "rsp-rules.md"), "utf-8");
+    created = await ensureFile(join12(RSP_DIR, "rules", "rsp-rules.md"), bundledRules) || created;
+    created = await ensureFile(join12(RSP_DIR, "config.yaml"), generateConfigTemplate()) || created;
+    const createdSpecsIndex = await ensureFile(join12(RSP_DIR, "specs", "INDEX.md"), "# Specs Index\n\n_Project-level specs and design notes._\n");
     created = createdSpecsIndex || created;
-    const createdDesign = await ensureFile(join11(RSP_DIR, "specs", "design.md"), generateDesignContent(projectName));
+    const createdDesign = await ensureFile(join12(RSP_DIR, "specs", "design.md"), generateDesignContent(projectName));
     created = createdDesign || created;
-    const createdArchivesIndex = await ensureFile(join11(RSP_DIR, "archives", "INDEX.md"), "# Archive Index\n");
+    const createdArchivesIndex = await ensureFile(join12(RSP_DIR, "archives", "INDEX.md"), "# Archive Index\n");
     created = createdArchivesIndex || created;
-    created = await ensureFile(join11(RSP_DIR, "features", ".gitkeep"), "") || created;
-    created = await ensureFile(join11(RSP_DIR, "active.d", ".gitkeep"), "") || created;
-    created = await ensureFile(join11(RSP_DIR, ".gitignore"), "# Transient files that should not be committed\n.lock\n") || created;
+    created = await ensureFile(join12(CHANGES_DIR, ".gitkeep"), "") || created;
+    created = await ensureFile(join12(FOCUS_DIR, ".gitkeep"), "") || created;
+    created = await ensureFile(join12(RSP_DIR, ".gitignore"), "# Transient files that should not be committed\n.lock\n") || created;
     if (args.withProjectRules)
-      created = await ensureFile(join11(RSP_DIR, "rules", "project-rules.md"), generateProjectRulesContent(projectName)) || created;
+      created = await ensureFile(join12(RSP_DIR, "rules", "project-rules.md"), generateProjectRulesContent(projectName)) || created;
+    if (args.withProjectSetup) {
+      const changePath = join12(CHANGES_DIR, "project-setup.md");
+      const focusMarker = join12(FOCUS_DIR, "project-setup");
+      created = await ensureFile(changePath, generateChangeContent("project-setup")) || created;
+      created = await ensureFile(focusMarker, "") || created;
+    }
     if (createdSpecsIndex || createdDesign)
       await buildSpecsIndex({ acquireLock: false });
     if (createdArchivesIndex)
       await buildArchiveIndex({ acquireLock: false });
     const agentsPath = "AGENTS.md";
     const title = toTitle(projectName);
-    const mode = args.agentsMode ?? "managed";
-    if (!existsSync11(agentsPath)) {
-      if (mode === "managed") {
-        await writeFile6(agentsPath, `# ${title}
+    let agentsUpdated = false;
+    if (!existsSync12(agentsPath)) {
+      await writeFile8(agentsPath, `# ${title}
 
 ${upsertRspAgentsBlock("").content}
 `);
-        created = true;
-      }
-    } else if (mode === "managed") {
-      const existing = await readFile11(agentsPath, "utf-8");
+      created = true;
+      agentsUpdated = true;
+    } else {
+      const existing = await readFile9(agentsPath, "utf-8");
       const next = upsertRspAgentsBlock(existing);
       if (next.changed) {
-        await writeFile6(agentsPath, next.content);
+        await writeFile8(agentsPath, next.content);
         created = true;
+        agentsUpdated = true;
       }
     }
     if (mode === "print") {
-      const managed = existsSync11(agentsPath) ? upsertRspAgentsBlock(await readFile11(agentsPath, "utf-8")).content : `# ${title}
-
-${renderRspAgentsBlock()}
-`;
+      const managed = await readFile9(agentsPath, "utf-8");
       console.log(`
 ${managed}
 `);
     }
     if (isNew) {
+      const createdProjectSetup = args.withProjectSetup ? "\n           .rsp/changes/project-setup.md\n           .rsp/focus.d/project-setup" : "";
+      const createdAgents = agentsUpdated ? "\n           AGENTS.md" : "";
+      const next = args.withProjectSetup ? "fill .rsp/changes/project-setup.md" : "rsp create project-setup";
       console.log(`
   ${pc.green("RSP scaffolded.")}
 `);
       console.log(`  Created: .rsp/rules/
            .rsp/specs/
-           .rsp/features/
-           .rsp/active.d/
+           .rsp/changes/
+           .rsp/focus.d/
            .rsp/archives/
            .rsp/.gitignore
            .rsp/config.yaml
-           .rsp/specs/design.md
-           AGENTS.md
+           .rsp/specs/design.md${createdProjectSetup}${createdAgents}
 `);
-      console.log(`  ${pc.cyan("Next:")} rsp new <name>
-  ${pc.dim("Also:")} rsp status  rsp deps
+      console.log(`  ${pc.cyan("Next:")} ${next}
+  ${pc.dim("Then:")} fill .rsp/specs/design.md
+  ${pc.dim("Also:")} rsp status  rsp check
 `);
     } else if (created) {
       console.log(`
@@ -1258,129 +1593,101 @@ ${managed}
   });
 }
 
-// src/commands/new-feature.ts
-import { existsSync as existsSync12 } from "fs";
-import { mkdir as mkdir6, writeFile as writeFile7 } from "fs/promises";
-import { dirname as dirname6, join as join12 } from "path";
-async function newFeature(name, summary = "") {
-  if (!name) {
-    console.error(`  ${pc.red("Usage:")} rsp new <name> [summary]`);
-    process.exit(1);
-  }
-  if (/^[a-z0-9-]+(?:\/[a-z0-9-]+)*$/.test(name) === false) {
-    console.error(`  ${pc.red("Error:")} feature name must be kebab-case with optional subdirectory (lowercase, digits, hyphens, slashes)`);
-    process.exit(1);
-  }
-  if (name === "init") {
-    console.error(`  ${pc.red("Error:")} "init" is a reserved workflow name, not a feature name`);
-    process.exit(1);
-  }
-  const rspRulesPath = join12(RSP_DIR, "rules", "rsp-rules.md");
-  const designPath = join12(RSP_DIR, "specs", "design.md");
-  if (!existsSync12(rspRulesPath) || !existsSync12(designPath)) {
-    console.error(`  ${pc.red("Error:")} RSP is not initialized in this project`);
-    console.error(`  ${pc.dim("Run: rsp init")}`);
-    process.exit(1);
-  }
-  return withRspLock("new-feature", async () => {
-    const featurePath = join12(RSP_DIR, "features", `${name}.md`);
-    await mkdir6(dirname6(featurePath), { recursive: true });
-    const existed = existsSync12(featurePath);
-    if (!existed) {
-      const content = generateFeatureContent(name, summary);
-      await writeFile7(featurePath, content);
-    }
-    await mkdir6(ACTIVE_DIR, { recursive: true });
-    const activeEntry = join12(ACTIVE_DIR, name);
-    await mkdir6(dirname6(activeEntry), { recursive: true });
-    await writeFile7(activeEntry, "");
-    if (!existed) {
-      const archiveIndex = join12(ARCHIVES_DIR, "INDEX.md");
-      if (existsSync12(archiveIndex))
-        await buildArchiveIndex({ acquireLock: false });
-    }
-    const label = existed ? "Using" : pc.green("Created");
-    console.log(`  ${label}: ${featurePath}
-  ${pc.dim("active.d")} \u2192 ${name}
-`);
-  });
-}
-
 // src/commands/status.ts
 import { existsSync as existsSync13 } from "fs";
-import { readFile as readFile12, stat as stat2 } from "fs/promises";
+import { readFile as readFile10, stat as stat2 } from "fs/promises";
 import { join as join13, relative as relative6 } from "path";
-var COL_FEATURE = 30;
-var COL_STATUS = 16;
+var COL_CHANGE = 32;
+var COL_KIND = 10;
 var COL_AGE = 7;
 var COL_PROGRESS = 10;
-async function showStatus(options = {}) {
-  const featuresDir = join13(RSP_DIR, "features");
-  const activeSet = /* @__PURE__ */ new Set();
-  if (existsSync13(ACTIVE_DIR)) {
-    try {
-      const entries = await walkFiles(ACTIVE_DIR);
-      for (const entryPath of entries) {
-        const name = relative6(ACTIVE_DIR, entryPath);
-        activeSet.add(name);
-      }
-    } catch {
-    }
-  }
-  const featureFiles = existsSync13(featuresDir) ? await walkMarkdownFiles(featuresDir) : [];
-  const featureMap = {};
-  for (const fp of featureFiles) {
-    const name = featureNameFromPath(featuresDir, fp);
-    featureMap[name] = fp;
-  }
-  console.log();
-  console.log(`  ${pc.bold("RSP status")}`);
-  console.log();
-  if (activeSet.size > 0) {
-    console.log(`  ${pc.cyan("Active:")} ${[...activeSet].join(", ")}`);
-    console.log();
-  } else {
-    console.log(`  ${pc.dim("No active feature.")} Run: rsp new <name>`);
-    console.log();
-  }
-  const allNames = [.../* @__PURE__ */ new Set([...Object.keys(featureMap), ...activeSet])].sort();
-  if (allNames.length === 0) {
-    console.log(`  ${pc.dim("No features found.")} Run: rsp new <name>
-`);
-    return;
-  }
+async function showStatus(options = {}, runOptions = {}) {
+  const focusedSet = /* @__PURE__ */ new Set();
+  const runtime = [];
+  const reportRuntime = (diagnostic) => recordRuntimeDiagnostic(runtime, diagnostic, Boolean(runOptions.verbose) && !runOptions.json);
+  if (existsSync13(FOCUS_DIR)) {
+    const entries = await walkFiles(FOCUS_DIR, { onError: reportRuntime });
+    for (const entryPath of entries)
+      focusedSet.add(normalizeLogicalPath(relative6(FOCUS_DIR, entryPath)));
+  }
+  const changeFiles = existsSync13(CHANGES_DIR) ? await walkMarkdownFiles(CHANGES_DIR, { onError: reportRuntime }) : [];
+  const changeMap = {};
+  for (const fp of changeFiles)
+    changeMap[changeNameFromPath(CHANGES_DIR, fp)] = fp;
+  const allNames = [.../* @__PURE__ */ new Set([...Object.keys(changeMap), ...focusedSet])].sort();
   const records = [];
+  const outputRecords = [];
   for (const name of allNames) {
-    const fp = featureMap[name];
-    let status = "\u2014";
+    const fp = changeMap[name];
+    let kind = "\u2014";
     let progress = "\u2014";
-    let depends = "\u2014";
-    let age = "\u2014";
-    const isActive = activeSet.has(name);
+    let ageDays = null;
+    const isFocused = focusedSet.has(name);
     let isBlocked = false;
+    let done = 0;
+    let total = 0;
     if (fp) {
       try {
-        const content = await readFile12(fp, "utf-8");
-        const fm = parseFrontmatter(content);
-        status = fm?.status || "\u2014";
-        isBlocked = status === "blocked";
-        if (fm?.["depends-on"])
-          depends = Array.isArray(fm["depends-on"]) ? fm["depends-on"].join(", ") : String(fm["depends-on"]);
+        const content = await readFile10(fp, "utf-8");
+        try {
+          const fm = parseFrontmatter(content);
+          kind = fm?.kind ? String(fm.kind) : "\u2014";
+        } catch (error) {
+          kind = "(invalid)";
+          reportRuntime({
+            code: "frontmatter_parse_failed",
+            operation: "parseFrontmatter",
+            path: fp,
+            message: toErrorMessage(error)
+          });
+        }
+        isBlocked = hasMeaningfulBlockers(content);
         const cb = countCheckboxes(content);
-        progress = `${cb.done}/${cb.total}`;
+        done = cb.done;
+        total = cb.total;
+        progress = `${done}/${total}`;
+      } catch (error) {
+        reportRuntime({
+          code: "change_read_failed",
+          operation: "readFile",
+          path: fp,
+          message: toErrorMessage(error)
+        });
+      }
+      try {
         const s = await stat2(fp);
-        const created = s.birthtime || s.mtime;
-        const diffMs = Date.now() - created.getTime();
-        age = String(Math.floor(diffMs / (1e3 * 60 * 60 * 24)));
-      } catch {
+        ageDays = Math.floor((Date.now() - s.mtime.getTime()) / (1e3 * 60 * 60 * 24));
+      } catch (error) {
+        reportRuntime({
+          code: "change_stat_failed",
+          operation: "stat",
+          path: fp,
+          message: toErrorMessage(error)
+        });
       }
     } else {
-      status = "(missing)";
+      kind = "(missing)";
+      reportRuntime({
+        code: "focused_change_missing",
+        operation: "resolveChange",
+        path: join13(CHANGES_DIR, `${name}.md`),
+        message: "focus marker points to a missing change file"
+      });
     }
-    records.push({ name, status, progress, age, depends, isActive, isBlocked });
+    const age = ageDays === null ? "\u2014" : String(ageDays);
+    records.push({ name, kind, progress, age, isFocused, isBlocked });
+    outputRecords.push({
+      name,
+      kind,
+      progress: { done, total },
+      ageDays,
+      isFocused,
+      isBlocked,
+      path: fp ? normalizeLogicalPath(fp) : null
+    });
   }
   const filteredRecords = records.filter((record) => {
-    if (options.active && !record.isActive)
+    if (options.focused && !record.isFocused)
       return false;
     if (options.blocked && !record.isBlocked)
       return false;
@@ -1391,48 +1698,90 @@ async function showStatus(options = {}) {
     }
     return true;
   });
-  if (filteredRecords.length === 0) {
-    console.log(`  ${pc.dim("No features match the current filters.")}`);
+  const filteredOutputRecords = outputRecords.filter((record) => {
+    if (options.focused && !record.isFocused)
+      return false;
+    if (options.blocked && !record.isBlocked)
+      return false;
+    if (typeof options.stale === "number") {
+      if (record.ageDays === null || record.ageDays < options.stale)
+        return false;
+    }
+    return true;
+  });
+  const blockedCount = filteredOutputRecords.filter((r) => r.isBlocked).length;
+  const statusResult = {
+    command: "status",
+    ok: true,
+    filters: {
+      focused: Boolean(options.focused),
+      blocked: Boolean(options.blocked),
+      stale: typeof options.stale === "number" ? options.stale : null
+    },
+    focused: [...focusedSet].sort(),
+    records: filteredOutputRecords,
+    summary: {
+      total: filteredOutputRecords.length,
+      focused: filteredOutputRecords.filter((r) => r.isFocused).length,
+      blocked: blockedCount
+    },
+    archiveTrend: await readArchiveTrend(runtime, runOptions),
+    runtime
+  };
+  if (runOptions.json) {
+    emitJson(statusResult);
+    return statusResult;
+  }
+  console.log();
+  console.log(`  ${pc.bold("RSP status")}`);
+  console.log();
+  if (focusedSet.size > 0) {
+    console.log(`  ${pc.cyan("Focused:")} ${[...focusedSet].join(", ")}`);
+    console.log();
+  } else {
+    console.log(`  ${pc.dim("No focused change.")} Run: rsp create <name> or rsp focus <name>`);
     console.log();
-    return;
+  }
+  if (allNames.length === 0) {
+    console.log(`  ${pc.dim("No changes found.")} Run: rsp create <name>
+`);
+    return statusResult;
+  }
+  if (filteredRecords.length === 0) {
+    console.log(`  ${pc.dim("No changes match the current filters.")}
+`);
+    return statusResult;
   }
   const pad = (s, w) => s.padEnd(w);
-  console.log(`  ${pad("Feature", COL_FEATURE)} ${pad("Status", COL_STATUS)} ${pad("Age(d)", COL_AGE)} ${pad("Progress", COL_PROGRESS)} Depends On`);
-  console.log(`  ${"\u2500".repeat(COL_FEATURE)} ${"\u2500".repeat(COL_STATUS)} ${"\u2500".repeat(COL_AGE)} ${"\u2500".repeat(COL_PROGRESS)} ${"\u2500".repeat(30)}`);
-  let blockedCount = 0;
+  console.log(`  ${pad("Change", COL_CHANGE)} ${pad("Kind", COL_KIND)} ${pad("Age(d)", COL_AGE)} ${pad("Progress", COL_PROGRESS)}`);
+  console.log(`  ${"\u2500".repeat(COL_CHANGE)} ${"\u2500".repeat(COL_KIND)} ${"\u2500".repeat(COL_AGE)} ${"\u2500".repeat(COL_PROGRESS)}`);
   for (const r of filteredRecords) {
-    const marker = r.isActive ? pc.cyan("*") : " ";
-    const namePadded = r.name.padEnd(COL_FEATURE - 1);
-    const statusPadded = String(r.status).padEnd(COL_STATUS);
+    const marker = r.isFocused ? pc.cyan("*") : " ";
+    const namePadded = r.name.padEnd(COL_CHANGE - 1);
+    const kindPadded = r.kind.padEnd(COL_KIND);
     const agePadded = r.age.padEnd(COL_AGE);
     const progressPadded = r.progress.padEnd(COL_PROGRESS);
     const nameDisplay = r.isBlocked ? pc.yellow(namePadded) : namePadded;
-    const statusDisplay = r.isBlocked ? pc.yellow(statusPadded) : statusPadded;
-    const ageDisplay = r.isActive ? pc.cyan(agePadded) : agePadded;
-    console.log(`  ${marker}${nameDisplay} ${statusDisplay} ${ageDisplay} ${progressPadded} ${r.depends}`);
-    if (r.isBlocked)
-      blockedCount++;
+    const ageDisplay = r.isFocused ? pc.cyan(agePadded) : agePadded;
+    console.log(`  ${marker}${nameDisplay} ${kindPadded} ${ageDisplay} ${progressPadded}`);
   }
   console.log();
-  const total = filteredRecords.length;
-  const doneCount = filteredRecords.filter((r) => r.status === "done").length;
-  const activeCount = filteredRecords.filter((r) => r.isActive).length;
-  console.log(`  ${pc.bold("Summary:")} ${total} feature(s), ${activeCount} active, ${doneCount} done, ${pc.yellow(String(blockedCount))} blocked`);
+  console.log(`  ${pc.bold("Summary:")} ${statusResult.summary.total} change(s), ${statusResult.summary.focused} focused, ${pc.yellow(String(statusResult.summary.blocked))} blocked`);
   console.log();
-  await showArchiveTrend();
-  if (blockedCount > 0) {
+  printArchiveTrend(statusResult.archiveTrend);
+  if (statusResult.summary.blocked > 0) {
     const blocked = filteredRecords.filter((r) => r.isBlocked);
     console.log(`  ${pc.yellow("Blocked:")} ${blocked.map((r) => r.name).join(", ")}`);
     console.log();
   }
+  return statusResult;
 }
-async function showArchiveTrend() {
-  const archiveDir = join13(RSP_DIR, "archives");
-  const indexPath = join13(archiveDir, "INDEX.md");
+async function readArchiveTrend(runtime, runOptions) {
+  const indexPath = join13(ARCHIVES_DIR, "INDEX.md");
   if (!existsSync13(indexPath))
-    return;
+    return [];
   try {
-    const content = await readFile12(indexPath, "utf-8");
+    const content = await readFile10(indexPath, "utf-8");
     const dateRe = /^\| (\d{4}-\d{2})-\d{2} \|/gm;
     const counts = {};
     let match;
@@ -1442,58 +1791,119 @@ async function showArchiveTrend() {
     }
     const months = Object.keys(counts).sort();
     if (months.length === 0)
-      return;
-    console.log(`  ${pc.bold("Archive trend:")}`);
-    const bar = months.map((m) => {
-      const n = counts[m];
-      return pc.dim(`${m} ${"\u2588".repeat(Math.min(n, 20))} ${n}`);
-    }).join("\n  ");
-    console.log(`  ${bar}`);
-    console.log();
-  } catch {
+      return [];
+    return months.map((month) => ({ month, count: counts[month] }));
+  } catch (error) {
+    recordRuntimeDiagnostic(runtime, {
+      code: "archive_index_read_failed",
+      operation: "readFile",
+      path: indexPath,
+      message: toErrorMessage(error)
+    }, Boolean(runOptions.verbose) && !runOptions.json);
+    return [];
   }
 }
+function printArchiveTrend(trend) {
+  if (trend.length === 0)
+    return;
+  console.log(`  ${pc.bold("Archive trend:")}`);
+  const bar = trend.map(({ month, count }) => pc.dim(`${month} ${"\u2588".repeat(Math.min(count, 20))} ${count}`)).join("\n  ");
+  console.log(`  ${bar}`);
+  console.log();
+}
+
+// src/commands/update.ts
+import { existsSync as existsSync14 } from "fs";
+import { mkdir as mkdir8, readFile as readFile11, writeFile as writeFile9 } from "fs/promises";
+import { join as join14 } from "path";
+async function updateProject() {
+  if (!existsSync14(RSP_DIR)) {
+    console.log(`  ${pc.red("Error:")} RSP is not initialized. Run: rsp init`);
+    process.exit(1);
+  }
+  return withRspLock("update", async () => {
+    let updated = false;
+    const bundledRules = await readFile11(join14(PKG_ROOT, "rules", "rsp-rules.md"), "utf-8");
+    const rulesPath = join14(RSP_DIR, "rules", "rsp-rules.md");
+    await mkdir8(join14(RSP_DIR, "rules"), { recursive: true });
+    const existingRules = existsSync14(rulesPath) ? await readFile11(rulesPath, "utf-8") : null;
+    if (existingRules !== bundledRules) {
+      await writeFile9(rulesPath, bundledRules);
+      console.log(`  ${pc.green("\u2713")} rules/rsp-rules.md updated`);
+      updated = true;
+    }
+    const agentsPath = "AGENTS.md";
+    const projectName = await detectProjectName();
+    const baseAgents = existsSync14(agentsPath) ? await readFile11(agentsPath, "utf-8") : `# ${projectName}
+
+`;
+    const nextAgents = upsertRspAgentsBlock(baseAgents);
+    if (!existsSync14(agentsPath) || nextAgents.changed) {
+      await writeFile9(agentsPath, nextAgents.content);
+      console.log(`  ${pc.green("\u2713")} AGENTS.md managed block refreshed`);
+      updated = true;
+    }
+    await buildSpecsIndex({ acquireLock: false });
+    await buildArchiveIndex({ acquireLock: false });
+    if (!updated)
+      console.log(`  ${pc.dim("Already up to date.")}
+`);
+    else
+      console.log(`  ${pc.green("Update complete.")}
+`);
+  });
+}
 
 // src/cli.ts
 var initCommand = defineCommand({
   meta: {
     name: "init",
-    description: "Scaffold .rsp/ + AGENTS.md in current project"
+    description: "Scaffold .rsp/ and ensure AGENTS.md contains the RSP entry block"
   },
   args: {
     "agents-mode": {
       type: "string",
-      description: "How to update AGENTS.md: managed, skip, or print",
+      description: "How to handle AGENTS.md output: managed or print",
       default: "managed"
     },
     "with-project-rules": {
       type: "boolean",
       description: "Create .rsp/rules/project-rules.md",
       default: false
+    },
+    "with-project-setup": {
+      type: "boolean",
+      description: "Create .rsp/changes/project-setup.md and focus it",
+      default: false
     }
   },
   async run({ args }) {
     await initProject({
-      agentsMode: args["agents-mode"] === "skip" || args["agents-mode"] === "print" ? args["agents-mode"] : "managed",
-      withProjectRules: Boolean(args["with-project-rules"])
+      agentsMode: args["agents-mode"] === "print" ? "print" : "managed",
+      withProjectRules: Boolean(args["with-project-rules"]),
+      withProjectSetup: Boolean(args["with-project-setup"])
     });
   }
 });
-var newFeatureCommand = defineCommand({
+var createCommand = defineCommand({
   meta: {
-    name: "new",
-    description: "Create .rsp/features/<name>.md [summary]"
+    name: "create",
+    description: "Create .rsp/changes/<name>.md [summary]"
   },
   args: {
     name: {
       type: "positional",
-      description: "Feature name",
+      description: "Change name",
       required: true
+    },
+    kind: {
+      type: "string",
+      description: "Optional kind for a kind-aware template (feature, fix, refactor, docs, ops, research)"
     }
   },
   async run({ args }) {
     const summary = Array.isArray(args._) && args._.length > 1 ? args._.slice(1).join(" ") : "";
-    await newFeature(args.name, summary);
+    await createChange(args.name, summary, args.kind);
   }
 });
 var addRulesCommand = defineCommand({
@@ -1538,111 +1948,141 @@ var addCommand = defineCommand({
     spec: addSpecCommand
   }
 });
-var closeFeatureCommand = defineCommand({
+var archiveCommand = defineCommand({
+  meta: {
+    name: "archive",
+    description: "Archive an open change into .rsp/archives/"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Change name",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await archiveChange(args.name);
+  }
+});
+var focusCommand = defineCommand({
+  meta: {
+    name: "focus",
+    description: "Mark an existing change as currently focused in .rsp/focus.d/"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Change name",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await focusChange(args.name);
+  }
+});
+var unfocusCommand = defineCommand({
   meta: {
-    name: "close",
-    description: "Archive to .rsp/archives/"
+    name: "unfocus",
+    description: "Remove a change from the current focus set in .rsp/focus.d/"
   },
   args: {
     name: {
       type: "positional",
-      description: "Feature name",
+      description: "Change name",
       required: true
     }
   },
   async run({ args }) {
-    await closeFeature(args.name);
+    await unfocusChange(args.name);
   }
 });
 var statusCommand = defineCommand({
   meta: {
     name: "status",
-    description: "Show project status summary"
+    description: "Show project status summary with current focus information"
   },
   args: {
-    active: {
+    focused: {
       type: "boolean",
-      description: "Show only active features",
+      description: "Show only currently focused changes",
       default: false
     },
     blocked: {
       type: "boolean",
-      description: "Show only blocked features",
+      description: "Show only blocked changes",
       default: false
     },
     stale: {
       type: "string",
-      description: "Show only features with age >= days"
+      description: "Show only changes with age >= days"
+    },
+    json: {
+      type: "boolean",
+      description: "Print machine-readable JSON output",
+      default: false
+    },
+    verbose: {
+      type: "boolean",
+      description: "Print runtime diagnostics for suppressed I/O issues",
+      default: false
     }
   },
   async run({ args }) {
     const stale = args.stale === void 0 ? void 0 : Number(args.stale);
     if (args.stale !== void 0 && (Number.isFinite(stale) === false || Number.isInteger(stale) === false || stale < 0)) {
-      console.error(`  Error: --stale must be a non-negative integer number of days`);
+      if (args.json) {
+        emitStatusJsonError({
+          code: "invalid_stale_filter",
+          message: "--stale must be a non-negative integer number of days"
+        }, {
+          focused: Boolean(args.focused),
+          blocked: Boolean(args.blocked)
+        });
+      } else {
+        console.error(`  Error: --stale must be a non-negative integer number of days`);
+      }
       process.exit(1);
     }
     await showStatus({
-      active: Boolean(args.active),
+      focused: Boolean(args.focused),
       blocked: Boolean(args.blocked),
       stale
+    }, {
+      json: Boolean(args.json),
+      verbose: Boolean(args.verbose)
     });
   }
 });
 var checkCommand = defineCommand({
   meta: {
     name: "check",
-    description: "Validate features (frontmatter, sections, deps, deltas, scenarios)"
-  },
-  async run() {
-    const errors = await runCheck();
-    if (errors > 0)
-      process.exit(1);
-  }
-});
-var depsCommand = defineCommand({
-  meta: {
-    name: "deps",
-    description: "Show dependency summary (--mermaid for graph)"
+    description: "Validate changes (frontmatter, sections, deltas, scenarios)"
   },
   args: {
-    mermaid: {
+    json: {
       type: "boolean",
-      description: "Output as Mermaid.js graph",
+      description: "Print machine-readable JSON output",
       default: false
     },
-    focus: {
-      type: "string",
-      description: "Show only a feature and its direct dependency neighborhood"
-    },
-    reverse: {
-      type: "string",
-      description: "Show only features that depend on the given feature"
+    verbose: {
+      type: "boolean",
+      description: "Print runtime diagnostics for suppressed I/O issues",
+      default: false
     }
   },
   async run({ args }) {
-    await showDependencies({
-      mermaid: Boolean(args.mermaid),
-      focus: typeof args.focus === "string" ? args.focus : void 0,
-      reverse: typeof args.reverse === "string" ? args.reverse : void 0
-    });
-  }
-});
-var archiveIndexCommand = defineCommand({
-  meta: {
-    name: "archive-index",
-    description: "Regenerate archives INDEX.md"
-  },
-  async run() {
-    await buildArchiveIndex();
+    const result = await runCheck({ json: Boolean(args.json), verbose: Boolean(args.verbose) });
+    if (!result.ok)
+      process.exit(1);
   }
 });
-var specsIndexCommand = defineCommand({
+var updateCommand = defineCommand({
   meta: {
-    name: "specs-index",
-    description: "Regenerate specs INDEX.md"
+    name: "update",
+    description: "Refresh RSP project structure after upgrade (rules, AGENTS, indices)"
   },
   async run() {
-    await buildSpecsIndex();
+    await updateProject();
   }
 });
 var doctorCommand = defineCommand({
@@ -1650,9 +2090,21 @@ var doctorCommand = defineCommand({
     name: "doctor",
     description: "Check RSP setup health and common integration issues"
   },
-  async run() {
-    const issues = await runDoctor();
-    if (issues > 0)
+  args: {
+    json: {
+      type: "boolean",
+      description: "Print machine-readable JSON output",
+      default: false
+    },
+    verbose: {
+      type: "boolean",
+      description: "Print runtime diagnostics for suppressed I/O issues",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const result = await runDoctor({ json: Boolean(args.json), verbose: Boolean(args.verbose) });
+    if (!result.ok)
       process.exit(1);
   }
 });
@@ -1662,19 +2114,19 @@ async function runCli(rawArgs = process.argv.slice(2)) {
     meta: {
       name: "rsp",
       version,
-      description: "RSP (Rules, Specs, Plans) workflow for AI-assisted development"
+      description: "RSP (Rules, Specs, Plans) workflow for lightweight AI-assisted change management"
     },
     subCommands: {
-      "init": initCommand,
-      "add": addCommand,
-      "new": newFeatureCommand,
-      "close": closeFeatureCommand,
-      "status": statusCommand,
-      "check": checkCommand,
-      "deps": depsCommand,
-      "archive-index": archiveIndexCommand,
-      "specs-index": specsIndexCommand,
-      "doctor": doctorCommand
+      init: initCommand,
+      add: addCommand,
+      create: createCommand,
+      focus: focusCommand,
+      unfocus: unfocusCommand,
+      archive: archiveCommand,
+      status: statusCommand,
+      check: checkCommand,
+      update: updateCommand,
+      doctor: doctorCommand
     }
   });
   await runMain(main, { rawArgs });