@oevery/rsp 3.3.0 → 4.0.0

package/dist/cli.mjs

@@ -1,125 +1,123 @@
 #!/usr/bin/env node
 import {
-  inspectPackagedSkillInventory,
-  installPackagedSkills,
-  presentPackagedSkillInventory,
-  presentSkillInstallResult
-} from "./chunk-QM2UVPQK.mjs";
-import {
+  ARCHIVES_DIR,
   ArchiveHistoryError,
+  CHANGES_DIR,
+  CHANGE_DOCUMENT_SCHEMA,
+  CONFIG_PATH,
+  DEFAULT_DECISION_RECORDS_PATH,
+  DocumentSectionCardinalityError,
+  FOCUS_DIR,
+  GROUP_BRIEF_DOCUMENT_SCHEMA,
   GROUP_BRIEF_FILENAME,
   GROUP_REOPEN_COMPLETION_PREFIX,
   HISTORY_DEFAULT_LIMIT,
   HISTORY_MAX_LIMIT,
   IssueRelationshipError,
+  LOCK_PATH,
+  MAX_FOCUS_CAPSULE_BYTES,
+  ManagedPathError,
+  OBSOLETE_RSP_RULES_PATH,
+  PKG_ROOT,
+  RSP_DIR,
+  RSP_RULES_PATH,
   SPECS_DEFAULT_RESULT_LIMIT,
   SPECS_DETAIL_CONTENT_CODE_POINTS,
-  SPECS_MAX_FILE_BYTES,
   SPECS_MAX_RESULT_LIMIT,
   SpecsQueryError,
   WorkRefError,
+  appendDocumentSectionItem,
   buildDurableReviewGuidance,
   cleanupEmptyParentDirs,
+  clearConfigCache,
   collectArchiveReadiness,
+  countCheckboxes,
   createIssueRelationship,
+  detectDeltaSections,
   detectProjectName,
+  emitJson,
+  ensureManagedFile,
+  generateConfigTemplate,
   generateGroupBriefContent,
+  getDocumentSectionDefinitionByHeading,
+  getDocumentSectionMarkdown,
+  getDocumentSections,
+  getDocumentTitles,
   getDurableReviewCandidateTargets,
   getGroupReopenEvidence,
+  getVersion,
+  getVisibleBodyLines,
   guardRspInitialized,
   hasArchivedGroupBrief,
+  hasMeaningfulBlockers,
   historyInspectionComplete,
   inspectArchiveHistory,
   inspectArchiveTree,
   inspectChangeDependencies,
   inspectChangeGroups,
   inspectFocusTree,
+  inspectManagedDirectory,
+  inspectManagedFile,
+  inspectManagedFileTree,
   inspectProjectStatus,
+  inspectRspConfig,
+  inspectRspInitialization,
   inspectSpecs,
   inspectUnsupportedRules,
   inspectWorkTree,
   isRecognizedGeneratedSpecsIndex,
   isValidSpecName,
+  loadRspConfig,
+  markdownProse,
+  markdownText,
+  markdownTopLevelComments,
   normalizeExecutableWorkRef,
   normalizeLogicalPath,
   normalizeWorkRefSegment,
+  parseFrontmatter,
   parseIssueRelationships,
+  parseMarkdown,
+  parseRspDocument,
+  parseScenarios,
+  pc,
   projectDependencyForest,
   projectSpecsDetail,
   projectSpecsSearch,
   projectSpecsTree,
   queryArchiveHistory,
   readArchiveHistoryDetail,
-  resolveArchiveDirectory,
-  resolveExecutableChange,
-  resolveFocusMarkerPath,
-  resolveWorkRef,
-  selectArchiveHistoryRecord,
-  selectArchivedGroupBrief,
-  specsInspectionComplete,
-  toArchiveReadinessOutput,
-  walkMarkdownFiles
-} from "./chunk-TSUDEX5Y.mjs";
-import {
-  ARCHIVES_DIR,
-  CHANGES_DIR,
-  CHANGE_DOCUMENT_SCHEMA,
-  CONFIG_PATH,
-  DEFAULT_DECISION_RECORDS_PATH,
-  DocumentSectionCardinalityError,
-  FOCUS_DIR,
-  GROUP_BRIEF_DOCUMENT_SCHEMA,
-  LOCK_PATH,
-  MAX_FOCUS_CAPSULE_BYTES,
-  ManagedPathError,
-  OBSOLETE_RSP_RULES_PATH,
-  PKG_ROOT,
-  RSP_DIR,
-  RSP_RULES_PATH,
-  appendDocumentSectionItem,
-  clearConfigCache,
-  countCheckboxes,
-  detectDeltaSections,
-  emitJson,
-  ensureDecisionRecordsDirectory,
-  ensureManagedFile,
-  generateConfigTemplate,
-  getDocumentSectionBody,
-  getDocumentSectionDefinitionByHeading,
-  getDocumentSections,
-  getDocumentTitles,
-  getVersion,
-  hasMeaningfulBlockers,
-  inspectManagedDirectory,
-  inspectManagedFile,
-  inspectManagedFileTree,
-  inspectRspConfig,
-  loadRspConfig,
-  parseFrontmatter,
-  parseRspDocument,
-  parseScenarios,
-  pc,
-  reconcileRspConfigDefaults,
   renderDocumentSectionHeading,
   renderDocumentTitle,
   requireManagedDirectory,
   requireManagedFile,
+  resolveArchiveDirectory,
   resolveDecisionRecordsPath,
+  resolveExecutableChange,
+  resolveFocusMarkerPath,
   resolveKinds,
+  resolveLanguagePolicy,
   resolveManagedDirectoryChain,
   resolveRequiredSections,
+  resolveWorkRef,
+  resolveWorkflowPolicy,
+  selectArchiveHistoryRecord,
+  selectArchivedGroupBrief,
+  specsInspectionComplete,
+  toArchiveReadinessOutput,
   toErrorMessage,
   validateDecisionRecordsFilesystemPath,
+  walkMarkdownFiles,
   writeManagedFile
-} from "./chunk-7HXQNBIG.mjs";
+} from "./chunk-HFSTLCCK.mjs";
 
 // src/cli.ts
-import { resolve as resolve4 } from "path";
+import { resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
 import { runMain } from "citty";
 
 // src/cli/capabilities.ts
 var CLI_COMMAND_CAPABILITIES = {
+  "config": { json: true, compact: true },
   "status": { json: true, compact: true },
   "show": { json: true, compact: true },
   "ready": { json: true, compact: true },
@@ -164,9 +162,10 @@ import { readFile } from "fs/promises";
 var choosePlaceholderRe = /^<choose:/i;
 function inspectChangeDocument(content, options) {
   const diagnostics = [];
+  const document = typeof content === "string" ? parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA) : content;
   let frontmatter = null;
   try {
-    frontmatter = parseFrontmatter(content);
+    frontmatter = parseFrontmatter(document.markdown);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     diagnostics.push({
@@ -182,7 +181,6 @@ function inspectChangeDocument(content, options) {
       message: "missing YAML frontmatter"
     });
   }
-  const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
   for (const heading of options.requiredSections) {
     const definition = getDocumentSectionDefinitionByHeading(CHANGE_DOCUMENT_SCHEMA, heading);
     if (!definition)
@@ -481,9 +479,10 @@ async function runCheck(options = {}) {
       });
       continue;
     }
-    for (const diagnostic of inspectChangeDocument(content, { name, validKinds, requiredSections }))
+    const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
+    for (const diagnostic of inspectChangeDocument(document, { name, validKinds, requiredSections }))
       addDiagnostic({ ...diagnostic, change: name, path: fp });
-    const deltas = detectDeltaSections(content);
+    const deltas = detectDeltaSections(document);
     if (deltas.added || deltas.modified || deltas.removed) {
       const parts = [];
       if (deltas.added)
@@ -500,7 +499,7 @@ async function runCheck(options = {}) {
         message: `delta markers found: ${parts.join(", ")}`
       });
     }
-    const placeholderLines = findUnfinishedTemplateLines(content);
+    const placeholderLines = findUnfinishedTemplateLines(document.markdown);
     if (placeholderLines.length > 0) {
       addDiagnostic({
         severity: "warning",
@@ -512,7 +511,7 @@ async function runCheck(options = {}) {
         hint: "Replace angle-bracket template text with concrete change details before archiving."
       });
     }
-    const clarificationLines = findUnresolvedClarificationLines(content);
+    const clarificationLines = findUnresolvedClarificationLines(document.markdown);
     if (clarificationLines.length > 0) {
       addDiagnostic({
         severity: "warning",
@@ -524,7 +523,7 @@ async function runCheck(options = {}) {
         hint: "Resolve or remove clarification markers once the open question is answered."
       });
     }
-    const scenarios = parseScenarios(content);
+    const scenarios = parseScenarios(document.markdown);
     if (scenarios.length > 0) {
       const scenarioIssues = [];
       for (const s of scenarios) {
@@ -569,32 +568,178 @@ async function runCheck(options = {}) {
 }
 function findUnfinishedTemplateLines(content) {
   const placeholderRe = /<(?:…|[^>\n]*(?:choose:|one-line|what |why |which |who |how |new |updated |expected |actual |specific |concrete |exact |verifiable |user |capability |behavior |context |action|path|directory|module|subsystem|command|scenario|constraint|requirement|question|uncertainty|implementation)[^>\n]*)>/i;
-  return collectMatchingLines(content, (line) => {
-    const trimmed = stripInlineCodeSpans(line).trim();
-    return trimmed.startsWith("<!--") === false && placeholderRe.test(trimmed);
-  });
+  return collectMatchingLines(content, (value) => placeholderRe.test(value));
 }
 function findUnresolvedClarificationLines(content) {
-  return collectMatchingLines(content, (line) => /\[(?:NEEDS|TODO|TBD)\s+CLARIFICATION(?::[^\]]*)?\]/i.test(stripInlineCodeSpans(line)));
-}
-function stripInlineCodeSpans(line) {
-  return line.replace(/`[^`]*`/g, "");
+  return collectMatchingLines(content, (value) => /\[(?:NEEDS|TODO|TBD)\s+CLARIFICATION(?::[^\]]*)?\]/i.test(value));
 }
 function collectMatchingLines(content, predicate) {
-  const matches = [];
-  const lines = content.split("\n");
-  for (let index = 0; index < lines.length; index++) {
-    const line = lines[index];
-    if (predicate(line))
-      matches.push(`line ${index + 1}: ${line.trim()}`);
+  const document = parseMarkdown(content);
+  const sourceLines = document.source.split(/\r?\n/);
+  const matched = /* @__PURE__ */ new Set();
+  for (const fragment of markdownProse(document)) {
+    fragment.value.split(/\r?\n/).forEach((value, index) => {
+      if (predicate(value))
+        matched.add(fragment.line + index);
+    });
+  }
+  return [...matched].sort((a, b) => a - b).slice(0, 10).map((line) => `line ${line}: ${sourceLines[line - 1].trim()}`);
+}
+
+// src/commands/config.ts
+async function showConfig() {
+  try {
+    const inspection = await inspectRspConfig();
+    if (inspection.issues.length > 0) {
+      return {
+        command: "config",
+        ok: false,
+        path: CONFIG_PATH,
+        summary: null,
+        diagnostics: [{
+          severity: "error",
+          code: "invalid_config",
+          path: CONFIG_PATH,
+          message: inspection.issues.join("; ")
+        }],
+        runtime: []
+      };
+    }
+    return {
+      command: "config",
+      ok: true,
+      path: CONFIG_PATH,
+      summary: {
+        kinds: resolveKinds(inspection.config),
+        decisions: { path: resolveDecisionRecordsPath(inspection.config) },
+        workflow: resolveWorkflowPolicy(inspection.config, { configValid: true }),
+        language: resolveLanguagePolicy(inspection.config, { configValid: true })
+      },
+      diagnostics: [],
+      runtime: []
+    };
+  } catch (error) {
+    return {
+      command: "config",
+      ok: false,
+      path: CONFIG_PATH,
+      summary: null,
+      diagnostics: [{
+        severity: "error",
+        code: "invalid_config",
+        path: CONFIG_PATH,
+        message: toErrorMessage(error)
+      }],
+      runtime: []
+    };
   }
-  return matches.slice(0, 10);
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync2 } from "fs";
-import { readdir as readdir2, readFile as readFile5, stat } from "fs/promises";
-import { basename, join as join4, relative as relative4 } from "path";
+import { existsSync } from "fs";
+import { readdir as readdir2, readFile as readFile4, stat } from "fs/promises";
+import { basename, join as join3, relative as relative2 } from "path";
+
+// src/core/project-version.ts
+import { readFile as readFile2, realpath } from "fs/promises";
+import { join } from "path";
+var PROJECT_VERSION_PATH = ".rsp/version";
+var PROJECT_SOURCE_PATH = ".rsp/source";
+var SOURCE_INVOCATION = "mise exec -- node dist/cli.mjs";
+function isExactVersion(value) {
+  return /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-(?:0|[1-9]\d*|\d*[a-z-][\da-z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-z-][\da-z-]*))*)?(?:\+[\da-z-]+(?:\.[\da-z-]+)*)?$/i.test(value);
+}
+function exactInvocation(version) {
+  if (!isExactVersion(version))
+    throw new Error(`Invalid exact RSP version: ${version}`);
+  return `npx -y @oevery/rsp@${version}`;
+}
+async function readProjectVersion(projectRoot = ".") {
+  const directory = inspectManagedDirectory(join(projectRoot, RSP_DIR), "RSP root", { allowMissing: true });
+  if (directory.issue)
+    throw directory.issue;
+  if (!directory.exists)
+    return null;
+  const path = join(projectRoot, PROJECT_VERSION_PATH);
+  const inspection = inspectManagedFile(path, "project CLI version", { allowMissing: true });
+  if (inspection.issue)
+    throw inspection.issue;
+  if (!inspection.exists)
+    return null;
+  const version = (await readFile2(path, "utf8")).trim();
+  if (!isExactVersion(version))
+    throw new Error(`${PROJECT_VERSION_PATH} must contain one exact package version, not a tag or range`);
+  return version;
+}
+async function readProjectRuntime(projectRoot = ".") {
+  const version = await readProjectVersion(projectRoot);
+  const source = inspectManagedFile(join(projectRoot, PROJECT_SOURCE_PATH), "project source selection", { allowMissing: true });
+  if (source.issue)
+    throw source.issue;
+  if (!source.exists)
+    return { mode: "package", version };
+  if (version !== null)
+    throw new Error(`${PROJECT_SOURCE_PATH} and ${PROJECT_VERSION_PATH} are mutually exclusive; explicitly select one runtime.`);
+  if ((await readFile2(join(projectRoot, PROJECT_SOURCE_PATH), "utf8")).trim() !== ".")
+    throw new Error(`${PROJECT_SOURCE_PATH} must contain . to select this RSP source checkout.`);
+  if (await realpath(projectRoot) !== await realpath(PKG_ROOT))
+    throw new Error(`Source mode requires this checkout's local CLI. Build here, then use ${SOURCE_INVOCATION} <command>; a registry package or another checkout cannot substitute.`);
+  const sourceDirectory = inspectManagedDirectory(join(projectRoot, "src"), "RSP source directory");
+  const sourceEntry = inspectManagedFile(join(projectRoot, "src/cli.ts"), "RSP source entry");
+  if (sourceDirectory.issue || sourceEntry.issue)
+    throw sourceDirectory.issue ?? sourceEntry.issue;
+  return { mode: "source" };
+}
+async function selectProjectRuntime(operation = "ordinary") {
+  const version = await getVersion();
+  exactInvocation(version);
+  const selected = await readProjectRuntime();
+  if (selected.mode === "source")
+    return { mode: "source", version };
+  if (selected.version && selected.version !== version && operation !== "update") {
+    throw new Error(`Project pins RSP ${selected.version}; running CLI is ${version}. Use ${exactInvocation(selected.version)} <command>. To migrate deliberately, inspect the target version and run ${exactInvocation(version)} update.`);
+  }
+  if (selected.version && operation === "update" && compareVersions(version, selected.version) < 0)
+    throw new Error(`Downgrading RSP from ${selected.version} to ${version} is unsupported. Use ${exactInvocation(selected.version)} <command>.`);
+  return { mode: "package", version };
+}
+function compareVersions(left, right) {
+  const parts = (value) => {
+    const [core, ...pre] = value.split("+", 1)[0].split("-");
+    return { core: core.split(".").map(BigInt), pre: pre.length ? pre.join("-").split(".") : [] };
+  };
+  const a = parts(left);
+  const b = parts(right);
+  for (let i = 0; i < 3; i++) {
+    if (a.core[i] !== b.core[i])
+      return a.core[i] > b.core[i] ? 1 : -1;
+  }
+  if (!a.pre.length || !b.pre.length)
+    return Number(!a.pre.length) - Number(!b.pre.length);
+  for (let i = 0; i < Math.max(a.pre.length, b.pre.length); i++) {
+    const x = a.pre[i];
+    const y = b.pre[i];
+    if (x === y)
+      continue;
+    if (x === void 0 || y === void 0)
+      return x === void 0 ? -1 : 1;
+    const nx = /^\d+$/.test(x);
+    const ny = /^\d+$/.test(y);
+    if (nx && ny)
+      return BigInt(x) > BigInt(y) ? 1 : -1;
+    if (nx !== ny)
+      return nx ? -1 : 1;
+    return x > y ? 1 : -1;
+  }
+  return 0;
+}
+async function guardProjectVersion(rawArgs) {
+  if (rawArgs.some((arg) => ["--help", "-h"].includes(arg)) || rawArgs.length === 1 && ["--version", "-v"].includes(rawArgs[0]))
+    return;
+  if (["doctor", "config", "update"].includes(rawArgs[0] ?? ""))
+    return;
+  await selectProjectRuntime();
+}
 
 // src/core/artifacts.ts
 var RSP_AGENTS_BEGIN = "<!-- rsp:begin -->";
@@ -747,62 +892,89 @@ function getChangeTemplateByKind(kind) {
   };
 }
 function changeSectionHeading(sectionId) {
-  return renderDocumentSectionHeading(CHANGE_DOCUMENT_SCHEMA, sectionId);
+  const guidance = {
+    proposal: "State the intended outcome, why it matters, scope, and non-goals; do not narrate execution.",
+    spec: "Describe the contract delta and acceptance conditions, referencing affected existing Specs; do not copy the full baseline or implementation steps.",
+    design: "Explain the approach, responsibility boundaries, and necessary tradeoffs; keep simple changes brief and avoid repeating requirements or tasks.",
+    tasks: "List checkable work and mark completion only after outcomes exist; prescribe order only where correctness, safety, or migration requires it.",
+    verify: "Connect acceptance to verification methods; after execution retain actual results, gaps, and limits, not command transcripts.",
+    blockers: "Name unresolved decisions or dependencies that prevent progress; use none when there are no blockers."
+  };
+  return `${renderDocumentSectionHeading(CHANGE_DOCUMENT_SCHEMA, sectionId)}
+<!-- ${guidance[sectionId]} -->`;
 }
-function renderRspAgentsBlock() {
+function renderRspAgentsBlock(runtime) {
+  const { version } = runtime;
+  const selection = runtime.mode === "source" ? `This RSP development checkout explicitly selects source mode through \`.rsp/source\`. Build the current source with \`mise exec -- pnpm run build\`, then use \`${SOURCE_INVOCATION} <command>\` from this checkout for every CLI operation. Skill examples use \`rsp\` as shorthand for this local invocation. Do not substitute a registry package, global CLI or another checkout, even when its version matches. Package version metadata is not source identity; retain the commit, uncommitted diff and build inputs for candidate evidence. Authorized \`update\` reconciles this checkout's managed environment from its local source and keeps source mode; it does not select a published version.` : `This project pins RSP \`${version}\` in \`.rsp/version\`. For every CLI operation use \`${exactInvocation(version)} <command>\` (or a verified executable of that exact version). Skill examples use \`rsp\` as shorthand for this selected invocation. Never substitute \`@latest\`, a version range, or an unverified global CLI. Package fetching requires authority; if unavailable, report the gap. Only an authorized upgrade uses a deliberately selected target CLI with \`update\`; it updates the complete managed environment. Notices grant no upgrade authority.`;
   return `${RSP_AGENTS_BEGIN}
 ## RSP Entry
 
 RSP tracks current work, stable specs, and archives under \`.rsp/\`.
 
-Read in order:
+Read in order using supplied or confirmed paths; discover only missing paths or applicable ancestor instructions, without overlapping whole-tree scans:
 1. Nearest \`AGENTS.md\` for project or module instructions.
-2. Root \`CONTEXT-MAP.md\` if present, then the relevant nearest \`CONTEXT.md\`.
-3. Use the project \`rsp\` Skill at \`.agents/skills/rsp/SKILL.md\`; hosts may load it through Skill discovery or read it directly. Only when it is absent or cannot be used, read \`.rsp/rsp-rules.md\` as the fallback protocol.
-4. \`.rsp/focus.d/\`; marker paths select work, while optional bounded Markdown content is recovery guidance only. For grouped work read the sibling Group Brief, then the explicitly selected focused Change.
+2. Root \`CONTEXT.md\` if present, then the relevant nearest \`CONTEXT.md\` for domain language, relationships, and navigation. If a legacy \`CONTEXT-MAP.md\` remains, retain its relevant context and use Core's context-migration branch; discovery alone does not authorize migration.
+3. Use the project \`rsp\` Skill at \`.agents/skills/rsp/SKILL.md\`; hosts may load it through Skill discovery or read it directly. Skills are the only workflow: if a required Skill is missing or unusable, stop dependent work and report the incomplete installation. Do not use retired Rules or install implicitly.
+4. \`.rsp/focus.d/\`; marker paths form the open-work candidate set, while optional bounded Markdown content is recovery guidance only. For grouped work read the sibling Group Brief, then the explicitly selected child Change.
 5. Only the relevant Specs and Decision Records under the configured authoritative path.
 
-If \`.rsp/focus.d/\` is empty and the user has not provided a concrete task, ask what to work on or suggest \`npx -y @oevery/rsp create <name>\` for tracked work.
+If \`.rsp/focus.d/\` is empty or has several candidates, use an explicit WorkRef, the user's mentioned Change, or current status/dependency evidence to resolve the default action.
 Do not treat \`.rsp/specs/\` or \`.rsp/changes/\` as replacements for nearest \`AGENTS.md\` or \`CONTEXT.md\`.
+
+${selection}
 ${RSP_AGENTS_END}`;
 }
-function upsertRspAgentsBlock(content) {
-  const block = renderRspAgentsBlock();
-  const managedRe = /<!-- rsp:begin -->[\s\S]*?<!-- rsp:end -->/;
-  if (managedRe.test(content)) {
-    const next2 = content.replace(managedRe, block);
+function upsertRspAgentsBlock(content, runtime) {
+  const block = renderRspAgentsBlock(runtime);
+  const span = rspAgentsBlockSpan(content);
+  if (span) {
+    const next2 = content.slice(0, span.start) + block + content.slice(span.end);
     return { content: next2, changed: next2 !== content };
   }
-  const trimmed = content.trimStart();
-  const next = trimmed ? `${block}
+  const next = content ? `${block}
 
-${trimmed}` : `${block}
+${content}` : `${block}
 `;
   return { content: next, changed: true };
 }
 function hasRspAgentsBlock(content) {
-  return content.includes(RSP_AGENTS_BEGIN) && content.includes(RSP_AGENTS_END);
+  return rspAgentsBlockSpan(content) !== null;
+}
+function rspAgentsBlockSpan(content) {
+  let start;
+  for (const comment of markdownTopLevelComments(content)) {
+    if (comment.source === RSP_AGENTS_BEGIN && start === void 0)
+      start = comment.start;
+    if (comment.source === RSP_AGENTS_END && start !== void 0)
+      return { start, end: comment.end };
+  }
+  return null;
 }
 function generateDesignContent(projectName) {
   const placeholder = "<\u2026>";
   return `# Project Design: ${projectName}
 
 ## Purpose
-- ${placeholder}
-
-## Stable Facts
+<!-- Define the system's purpose and consumers, not the current change. -->
 - ${placeholder}
 
 ## Boundaries
+<!-- Define system responsibilities, exclusions, and responsibility handoffs. -->
 - In scope:
   - ${placeholder}
 - Out of scope:
   - ${placeholder}
 
+## Contracts
+<!-- State current architectural obligations and invariants that must survive implementation changes. -->
+- ${placeholder}
+
 ## Structure
+<!-- Describe stable ownership and dependency direction; leave repository navigation to CONTEXT.md. -->
 - ${placeholder}
 
 ## Constraints
+<!-- Record necessary technical, security, protocol, or compatibility limits; link lasting rationale rather than duplicating it. -->
 - ${placeholder}
 `;
 }
@@ -812,1577 +984,297 @@ function generateSpecContent(name) {
   return `# ${title}
 
 ## Purpose
-- ${placeholder}
-
-## Stable Facts
+<!-- Define the capability, its consumers, and its value; do not describe this change. -->
 - ${placeholder}
 
 ## Boundaries
+<!-- Define responsibilities, exclusions, and handoffs to other capabilities. -->
 - In scope:
   - ${placeholder}
 - Out of scope:
   - ${placeholder}
 
-## Constraints
+## Contracts
+<!-- State current behavior, inputs and outputs, invariants, and failure semantics by capability, not internal implementation steps. -->
 - ${placeholder}
-`;
-}
-
-// src/commands/update.ts
-import { existsSync } from "fs";
-import { mkdir as mkdir3, readFile as readFile4, rm, rmdir as rmdir2 } from "fs/promises";
-import { join as join3 } from "path";
-
-// src/core/lock.ts
-import { mkdir, readFile as readFile2, unlink, writeFile } from "fs/promises";
-async function withRspLock(operation, fn) {
-  requireManagedDirectory(RSP_DIR, "RSP root", { allowMissing: true });
-  await mkdir(RSP_DIR, { recursive: true });
-  try {
-    await writeFile(LOCK_PATH, `${process.pid}
-${operation}
-${(/* @__PURE__ */ new Date()).toISOString()}`, { flag: "wx" });
-  } catch (err) {
-    if (err.code === "EEXIST")
-      await handleStaleLock(operation);
-    else
-      throw err;
-  }
-  try {
-    return await fn();
-  } finally {
-    try {
-      await unlink(LOCK_PATH);
-    } catch {
-    }
-  }
-}
-async function handleStaleLock(operation) {
-  try {
-    const content = await readFile2(LOCK_PATH, "utf-8");
-    const lines = content.trim().split("\n");
-    const pid = Number(lines[0]);
-    if (pid && Number.isFinite(pid)) {
-      try {
-        process.kill(pid, 0);
-        const op = lines[1] || "unknown";
-        const ts = lines[2] || "unknown";
-        throw new Error(`RSP locked by pid ${pid} (${op}) since ${ts}`);
-      } catch (e) {
-        if (e instanceof Error && e.message.startsWith("RSP locked"))
-          throw e;
-        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);
-      await writeFile(LOCK_PATH, `${process.pid}
-${operation}
-${(/* @__PURE__ */ new Date()).toISOString()}`, { flag: "wx" });
-    }
-  } catch (e) {
-    if (e instanceof Error && e.message.startsWith("RSP locked"))
-      throw e;
-    throw new Error(`RSP is locked. Remove ${LOCK_PATH} manually if no other process is running.`);
-  }
-}
 
-// src/commands/archive-index-migration.ts
-import { readFile as readFile3, unlink as unlink2 } from "fs/promises";
-import { join } from "path";
-async function removeLegacyArchiveIndex() {
-  const path = join(ARCHIVES_DIR, "INDEX.md");
-  const inspection = inspectManagedFile(path, "legacy archive index", { allowMissing: true });
-  if (!inspection.exists || inspection.issue)
-    return false;
-  let frontmatter;
-  try {
-    frontmatter = parseFrontmatter(await readFile3(path, "utf-8"));
-  } catch {
-    return false;
-  }
-  if (frontmatter?.kind !== "generated-index" || frontmatter.index_type !== "archives")
-    return false;
-  await unlink2(path);
-  return true;
-}
-
-// src/commands/specs-index-migration.ts
-import { Buffer as Buffer2 } from "buffer";
-import { createHash, randomUUID } from "crypto";
-import { constants } from "fs";
-import { link, lstat as lstat2, open, readdir, realpath as realpath2, rename, unlink as unlink3 } from "fs/promises";
-import { dirname, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2, sep as sep2 } from "path";
-
-// src/core/path-identity.ts
-import { lstat, realpath } from "fs/promises";
-import { isAbsolute, relative, resolve, sep } from "path";
-var StablePathIdentityError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "StablePathIdentityError";
-  }
-  code;
-};
-async function captureStableDirectoryChain(options) {
-  const rootPath = resolve(options.rootPath);
-  const targetPath = resolve(options.targetPath);
-  const requiredPath = options.requiredPath === void 0 ? null : resolve(options.requiredPath);
-  const targetRelative = containedRelative(rootPath, targetPath);
-  if (targetRelative === null) {
-    throw new StablePathIdentityError(
-      "stable_path_outside_root",
-      `${options.label} target must stay inside ${rootPath}: ${targetPath}`
-    );
-  }
-  if (requiredPath !== null) {
-    if (containedRelative(rootPath, requiredPath) === null || containedRelative(requiredPath, targetPath) === null) {
-      throw new StablePathIdentityError(
-        "stable_path_outside_required_root",
-        `${options.label} target must stay inside ${requiredPath}: ${targetPath}`
-      );
-    }
-  }
-  const logicalPaths = [rootPath];
-  if (targetRelative !== "") {
-    let current = rootPath;
-    for (const segment of targetRelative.split(sep)) {
-      current = resolve(current, segment);
-      logicalPaths.push(current);
-    }
-  }
-  const entries = [];
-  let rootRealPath = null;
-  let requiredRealPath = null;
-  for (const path of logicalPaths) {
-    let value;
-    let resolvedPath;
-    try {
-      value = await lstat(path, { bigint: true });
-      resolvedPath = await realpath(path);
-    } catch (error) {
-      throw new StablePathIdentityError(
-        "stable_path_inspection_failed",
-        `${options.label} parent chain could not be inspected at ${path}: ${errorMessage(error)}`
-      );
-    }
-    if (!value.isDirectory() || value.isSymbolicLink()) {
-      throw new StablePathIdentityError(
-        "stable_path_not_real_directory",
-        `${options.label} parent chain must contain only real directories: ${path}`
-      );
-    }
-    rootRealPath ??= resolvedPath;
-    if (containedRelative(rootRealPath, resolvedPath) === null) {
-      throw new StablePathIdentityError(
-        "stable_path_real_containment_failed",
-        `${options.label} parent chain resolves outside ${rootRealPath}: ${path}`
-      );
-    }
-    if (requiredPath === path)
-      requiredRealPath = resolvedPath;
-    entries.push({
-      path,
-      realPath: resolvedPath,
-      device: value.dev,
-      inode: value.ino
-    });
-  }
-  if (requiredPath !== null) {
-    const target = entries.at(-1);
-    if (requiredRealPath === null || containedRelative(requiredRealPath, target.realPath) === null) {
-      throw new StablePathIdentityError(
-        "stable_path_required_containment_failed",
-        `${options.label} parent chain no longer resolves inside ${requiredPath}`
-      );
-    }
-  }
-  return {
-    rootPath,
-    targetPath,
-    requiredPath,
-    entries
-  };
-}
-async function assertStableDirectoryChain(expected, label) {
-  const current = await captureStableDirectoryChain({
-    rootPath: expected.rootPath,
-    targetPath: expected.targetPath,
-    requiredPath: expected.requiredPath ?? void 0,
-    label
-  });
-  if (current.entries.length !== expected.entries.length)
-    throw changed(label, expected.targetPath);
-  for (let index = 0; index < expected.entries.length; index += 1) {
-    const before = expected.entries[index];
-    const after = current.entries[index];
-    if (before.path !== after.path || before.realPath !== after.realPath || before.device !== after.device || before.inode !== after.inode) {
-      throw changed(label, before.path);
-    }
-  }
-}
-function containedRelative(rootPath, candidatePath) {
-  const candidate = relative(rootPath, candidatePath);
-  if (candidate === "" || candidate !== ".." && !candidate.startsWith(`..${sep}`) && !isAbsolute(candidate)) {
-    return candidate;
-  }
-  return null;
-}
-function changed(label, path) {
-  return new StablePathIdentityError(
-    "stable_path_identity_changed",
-    `${label} parent identity changed before the filesystem operation: ${path}`
-  );
-}
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-
-// src/commands/specs-index-migration.ts
-var READ_NO_FOLLOW_FLAGS = constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0);
-var WRITE_EXCLUSIVE_NO_FOLLOW_FLAGS = constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | (constants.O_NOFOLLOW ?? 0);
-var DEFAULT_FILE_ADAPTER = { link };
-var GeneratedSpecsIndexMigrationError = class extends Error {
-  constructor(code, message, recoveryPaths = [], retainedMutations = []) {
-    super(message);
-    this.code = code;
-    this.recoveryPaths = recoveryPaths;
-    this.retainedMutations = retainedMutations;
-    this.name = "GeneratedSpecsIndexMigrationError";
-  }
-  code;
-  recoveryPaths;
-  retainedMutations;
-};
-async function inspectGeneratedSpecsIndexMigration(cwd = process.cwd()) {
-  const inspection = await inspectSpecs({
-    cwd,
-    allowMissingDecisionRecords: true
-  });
-  const removable = inspection.generatedIndexes.filter((index) => index.classification === "safe-removal").map((index) => index.path).sort();
-  const ownerControlled = inspection.generatedIndexes.filter((index) => index.classification === "owner-controlled").map((index) => index.path).sort();
-  return {
-    inspectionComplete: specsInspectionComplete(inspection),
-    removable,
-    ownerControlled,
-    diagnostics: inspection.diagnostics.map((diagnostic) => `${diagnostic.path ?? ".rsp/specs"}: ${diagnostic.message}`)
-  };
-}
-async function removeRecognizedGeneratedSpecsIndexes(options = {}) {
-  const cwd = await realpath2(resolve2(options.cwd ?? process.cwd()));
-  const fileAdapter = options.fileAdapter ?? DEFAULT_FILE_ADAPTER;
-  const plan = await inspectGeneratedSpecsIndexMigration(cwd);
-  if (!plan.inspectionComplete || plan.ownerControlled.length > 0) {
-    const ownerMessage = plan.ownerControlled.length > 0 ? ` Owner-controlled reserved path(s): ${plan.ownerControlled.join(", ")}.` : "";
-    const diagnosticMessage = plan.diagnostics.length > 0 ? ` ${plan.diagnostics.join("; ")}` : "";
-    throw new GeneratedSpecsIndexMigrationError(
-      "generated_specs_index_owner_review_required",
-      `Generated Specs-index migration stopped before mutation.${ownerMessage}${diagnosticMessage}`
-    );
-  }
-  if (plan.removable.length === 0)
-    return [];
-  const snapshots = [];
-  for (const projectPath of plan.removable)
-    snapshots.push(await inspectRecognizedGeneratedIndex(cwd, projectPath));
-  const quarantined = [];
-  let removalCommitted = false;
-  try {
-    for (const snapshot2 of snapshots) {
-      const quarantinePath = `${snapshot2.absolutePath}.${process.pid}.${randomUUID()}.rsp-migration`;
-      await assertMigrationParent(snapshot2, "quarantine");
-      await rename(snapshot2.absolutePath, quarantinePath);
-      await assertMigrationParent(snapshot2, "quarantine");
-      const quarantinedItem = {
-        ...snapshot2,
-        quarantinePath,
-        recoveryPath: null
-      };
-      quarantined.push(quarantinedItem);
-      const quarantinedSnapshot = await inspectRecognizedGeneratedIndexAt(
-        cwd,
-        snapshot2.projectPath,
-        quarantinePath,
-        snapshot2.parentChain
-      );
-      if (!sameRenamedSnapshot(snapshot2.identity, quarantinedSnapshot.identity) || snapshot2.contentHash !== quarantinedSnapshot.contentHash) {
-        throw new GeneratedSpecsIndexMigrationError(
-          "generated_specs_index_changed",
-          `Generated Specs index changed before migration: ${snapshot2.projectPath}`
-        );
-      }
-      quarantinedItem.identity = quarantinedSnapshot.identity;
-      await options.afterQuarantine?.(snapshot2.projectPath);
-      await assertMigrationParent(quarantinedItem, "post-quarantine hook");
-    }
-    for (const item of quarantined)
-      await assertMigrationParent(item, "direct Specs postcheck");
-    const after = await inspectSpecs({
-      cwd,
-      allowMissingDecisionRecords: true
-    });
-    if (!specsInspectionComplete(after) || after.generatedIndexes.length > 0) {
-      throw new GeneratedSpecsIndexMigrationError(
-        "generated_specs_index_postcheck_failed",
-        "Specs tree changed while generated indexes were being migrated; no quarantined index was deleted."
-      );
-    }
-    for (const item of quarantined)
-      await assertMigrationParent(item, "direct Specs postcheck");
-    for (const item of quarantined) {
-      item.recoveryPath = `${item.quarantinePath}.recovery`;
-      await materializeVerifiedSnapshot(
-        item,
-        item.quarantinePath,
-        item.recoveryPath,
-        fileAdapter,
-        options.testing
-      );
-    }
-    for (const item of quarantined) {
-      await assertMigrationParent(item, "quarantine removal");
-      await unlink3(item.quarantinePath);
-      await assertMigrationParent(item, "quarantine removal");
-    }
-    removalCommitted = true;
-    const cleanupPaths = [];
-    for (const item of quarantined) {
-      try {
-        await assertMigrationParent(item, "recovery cleanup");
-        await unlink3(item.recoveryPath);
-        await assertMigrationParent(item, "recovery cleanup");
-        item.recoveryPath = null;
-      } catch {
-        cleanupPaths.push(item.recoveryPath);
-      }
-    }
-    if (cleanupPaths.length > 0) {
-      throw new GeneratedSpecsIndexMigrationError(
-        "generated_specs_index_cleanup_required",
-        `Generated Specs indexes were removed, but recovery-link cleanup requires owner action: ${cleanupPaths.join(", ")}`,
-        cleanupPaths
-      );
-    }
-    return plan.removable;
-  } catch (error) {
-    if (removalCommitted)
-      throw error;
-    const recovery = await restoreQuarantinedIndexes(
-      quarantined,
-      fileAdapter,
-      options.testing
-    );
-    if (recovery.recoveryPaths.length > 0 || recovery.retainedMutations.length > 0) {
-      const retainedMessage = recovery.retainedMutations.length > 0 ? ` Retained mutation evidence: ${recovery.retainedMutations.map((item) => `${item.projectPath} (${item.quarantineName}, sha256 ${item.contentHash})`).join(", ")}.` : "";
-      throw new GeneratedSpecsIndexMigrationError(
-        "generated_specs_index_recovery_required",
-        `Generated Specs-index migration stopped and preserved recovery evidence.${recovery.recoveryPaths.length > 0 ? ` Accessible recovery copies: ${recovery.recoveryPaths.join(", ")}.` : ""}${retainedMessage}`,
-        recovery.recoveryPaths,
-        recovery.retainedMutations
-      );
-    }
-    throw error;
-  }
-}
-async function inspectRecognizedGeneratedIndex(projectRoot, projectPath) {
-  const absolutePath = resolveProjectPath(projectRoot, projectPath);
-  const parentChain = await captureStableDirectoryChain({
-    rootPath: projectRoot,
-    requiredPath: resolve2(projectRoot, ".rsp", "specs"),
-    targetPath: dirname(absolutePath),
-    label: `generated Specs index ${projectPath}`
-  });
-  return inspectRecognizedGeneratedIndexAt(
-    projectRoot,
-    projectPath,
-    absolutePath,
-    parentChain
-  );
-}
-async function inspectRecognizedGeneratedIndexAt(projectRoot, projectPath, absolutePath, parentChain) {
-  await assertStableDirectoryChain(parentChain, `generated Specs index ${projectPath}`);
-  const before = await lstat2(absolutePath, { bigint: true });
-  if (!before.isFile() || before.isSymbolicLink())
-    throw changed2(projectPath);
-  const handle = await open(absolutePath, READ_NO_FOLLOW_FLAGS);
-  try {
-    const opened = await handle.stat({ bigint: true });
-    if (!opened.isFile() || !sameSnapshot(before, opened))
-      throw changed2(projectPath);
-    const content = await readBounded(handle, projectPath);
-    const after = await handle.stat({ bigint: true });
-    if (!sameSnapshot(opened, after))
-      throw changed2(projectPath);
-    const finalPath = await lstat2(absolutePath, { bigint: true });
-    if (!sameSnapshot(after, finalPath))
-      throw changed2(projectPath);
-    await assertStableDirectoryChain(parentChain, `generated Specs index ${projectPath}`);
-    if (!isRecognizedGeneratedSpecsIndex(content, projectPath)) {
-      throw new GeneratedSpecsIndexMigrationError(
-        "generated_specs_index_owner_review_required",
-        `Reserved Specs index is not recognized generated content: ${projectPath}`
-      );
-    }
-    return {
-      projectPath,
-      absolutePath,
-      identity: snapshot(after),
-      contentHash: createHash("sha256").update(content).digest("hex"),
-      parentChain
-    };
-  } finally {
-    await handle.close();
-  }
-}
-async function readBounded(handle, projectPath) {
-  const buffer = Buffer2.allocUnsafe(SPECS_MAX_FILE_BYTES + 1);
-  let bytes = 0;
-  while (bytes < buffer.length) {
-    const result = await handle.read(buffer, bytes, buffer.length - bytes, bytes);
-    if (result.bytesRead === 0)
-      break;
-    bytes += result.bytesRead;
-  }
-  if (bytes > SPECS_MAX_FILE_BYTES) {
-    throw new GeneratedSpecsIndexMigrationError(
-      "generated_specs_index_too_large",
-      `Reserved Specs index exceeds the ${SPECS_MAX_FILE_BYTES}-byte migration limit: ${projectPath}`
-    );
-  }
-  return buffer.subarray(0, bytes).toString("utf8");
-}
-async function restoreQuarantinedIndexes(quarantined, fileAdapter, testing) {
-  const recoveryPaths = [];
-  const retainedMutations = [];
-  for (const item of [...quarantined].reverse()) {
-    try {
-      await assertMigrationParent(item, "rollback source inspection");
-      const sourcePath = await firstExistingPath(item);
-      if (!sourcePath) {
-        recoveryPaths.push(item.recoveryPath ?? item.quarantinePath);
-        continue;
-      }
-      await materializeVerifiedSnapshot(
-        item,
-        sourcePath,
-        item.absolutePath,
-        fileAdapter,
-        testing
-      );
-      await assertMigrationParent(item, "rollback cleanup");
-      await unlink3(item.quarantinePath).catch(ignoreMissing);
-      if (item.recoveryPath) {
-        await assertMigrationParent(item, "rollback cleanup");
-        await unlink3(item.recoveryPath).catch(ignoreMissing);
-      }
-    } catch {
-      try {
-        await assertMigrationParent(item, "rollback recovery reporting");
-        const recoveryPath = await firstExistingPath(item);
-        if (recoveryPath)
-          recoveryPaths.push(recoveryPath);
-        else
-          retainedMutations.push(retainedMutationEvidence(item));
-      } catch {
-        const relocated = await findRelocatedRetainedMutation(item).catch(() => null);
-        if (relocated)
-          recoveryPaths.push(relocated);
-        else
-          retainedMutations.push(retainedMutationEvidence(item));
-      }
-    }
-  }
-  return { recoveryPaths, retainedMutations };
-}
-async function findRelocatedRetainedMutation(item) {
-  const targetName = item.quarantinePath.slice(dirname(item.quarantinePath).length + 1);
-  const pending = [item.parentChain.rootPath];
-  let inspected = 0;
-  while (pending.length > 0 && inspected < 4096) {
-    const directory = pending.shift();
-    for (const entry of await readdir(directory, { withFileTypes: true })) {
-      inspected += 1;
-      if (inspected > 4096)
-        return null;
-      const path = resolve2(directory, entry.name);
-      if (entry.isSymbolicLink())
-        continue;
-      if (entry.isDirectory()) {
-        pending.push(path);
-        continue;
-      }
-      if (!entry.isFile() || entry.name !== targetName)
-        continue;
-      const value = await lstat2(path, { bigint: true });
-      if (value.isFile() && !value.isSymbolicLink() && value.dev === item.identity.dev && value.ino === item.identity.ino) {
-        return path;
-      }
-    }
-  }
-  return null;
-}
-async function firstExistingPath(item) {
-  for (const path of [item.quarantinePath, item.recoveryPath]) {
-    if (!path) {
-      continue;
-    }
-    try {
-      await assertMigrationParent(item, "recovery source inspection");
-      await lstat2(path);
-      return path;
-    } catch (error) {
-      if (error.code !== "ENOENT")
-        throw error;
-    }
-  }
-  return null;
-}
-function ignoreMissing(error) {
-  if (error.code !== "ENOENT")
-    throw error;
-}
-async function materializeVerifiedSnapshot(item, sourcePath, destinationPath, fileAdapter, testing) {
-  await assertMigrationParent(item, "snapshot materialization");
-  const source = await inspectRecognizedGeneratedIndexAt(
-    item.parentChain.rootPath,
-    item.projectPath,
-    sourcePath,
-    item.parentChain
-  );
-  if (source.contentHash !== item.contentHash || permissionMode(source.identity.mode) !== permissionMode(item.identity.mode)) {
-    throw changed2(item.projectPath);
-  }
-  try {
-    await fileAdapter.link(sourcePath, destinationPath);
-  } catch (error) {
-    if (!hardLinkUnsupported(error))
-      throw error;
-    await copySnapshotExclusive(
-      source,
-      destinationPath,
-      fileAdapter,
-      testing
-    );
-  }
-  const destination = await inspectRecognizedGeneratedIndexAt(
-    item.parentChain.rootPath,
-    item.projectPath,
-    destinationPath,
-    item.parentChain
-  );
-  const sourceAfter = await inspectRecognizedGeneratedIndexAt(
-    item.parentChain.rootPath,
-    item.projectPath,
-    sourcePath,
-    item.parentChain
-  );
-  if (destination.contentHash !== item.contentHash || sourceAfter.contentHash !== item.contentHash || permissionMode(destination.identity.mode) !== permissionMode(item.identity.mode) || permissionMode(sourceAfter.identity.mode) !== permissionMode(item.identity.mode) || !sameRenamedSnapshot(source.identity, sourceAfter.identity)) {
-    throw changed2(item.projectPath);
-  }
-  await assertMigrationParent(item, "snapshot materialization");
-}
-async function copySnapshotExclusive(source, destinationPath, fileAdapter, testing) {
-  const sourceHandle = await open(source.absolutePath, READ_NO_FOLLOW_FLAGS);
-  let destinationHandle = null;
-  let destinationIdentity = null;
-  try {
-    const sourceOpened = await sourceHandle.stat({ bigint: true });
-    if (!sameSnapshot(source.identity, sourceOpened))
-      throw changed2(source.projectPath);
-    destinationHandle = await open(
-      destinationPath,
-      WRITE_EXCLUSIVE_NO_FOLLOW_FLAGS,
-      Number(permissionMode(source.identity.mode))
-    );
-    const destinationOpened = await destinationHandle.stat({ bigint: true });
-    if (!destinationOpened.isFile() || destinationOpened.isSymbolicLink())
-      throw changed2(source.projectPath);
-    destinationIdentity = snapshot(destinationOpened);
-    await testing?.afterCopyDestinationOpen?.(destinationPath);
-    const hash = createHash("sha256");
-    const buffer = Buffer2.allocUnsafe(64 * 1024);
-    let bytes = 0;
-    while (bytes <= SPECS_MAX_FILE_BYTES) {
-      const read = await sourceHandle.read(buffer, 0, buffer.length, null);
-      if (read.bytesRead === 0)
-        break;
-      bytes += read.bytesRead;
-      if (bytes > SPECS_MAX_FILE_BYTES)
-        throw changed2(source.projectPath);
-      const chunk = buffer.subarray(0, read.bytesRead);
-      hash.update(chunk);
-      let written = 0;
-      while (written < chunk.length) {
-        const result = await destinationHandle.write(
-          chunk,
-          written,
-          chunk.length - written,
-          null
-        );
-        written += result.bytesWritten;
-      }
-    }
-    if (BigInt(bytes) !== source.identity.size || hash.digest("hex") !== source.contentHash) {
-      throw changed2(source.projectPath);
-    }
-    await destinationHandle.chmod(Number(permissionMode(source.identity.mode)));
-    await destinationHandle.sync();
-    const destinationAfter = await destinationHandle.stat({ bigint: true });
-    const sourceAfter = await sourceHandle.stat({ bigint: true });
-    if (!sameSnapshot(sourceOpened, sourceAfter) || !destinationAfter.isFile() || destinationAfter.isSymbolicLink() || destinationAfter.size !== source.identity.size || permissionMode(destinationAfter.mode) !== permissionMode(source.identity.mode)) {
-      throw changed2(source.projectPath);
-    }
-  } catch (error) {
-    await destinationHandle?.close().catch(() => void 0);
-    destinationHandle = null;
-    if (destinationIdentity) {
-      await cleanupExclusiveDestination(
-        source,
-        destinationPath,
-        destinationIdentity,
-        fileAdapter
-      );
-    }
-    throw error;
-  } finally {
-    await destinationHandle?.close();
-    await sourceHandle.close();
-  }
-}
-async function cleanupExclusiveDestination(source, destinationPath, expected, fileAdapter) {
-  const quarantinePath = `${destinationPath}.${process.pid}.${randomUUID()}.rsp-copy-cleanup`;
-  await assertMigrationParent(source, "exclusive-copy cleanup");
-  try {
-    await rename(destinationPath, quarantinePath);
-  } catch (error) {
-    if (error.code === "ENOENT")
-      return;
-    throw error;
-  }
-  await assertMigrationParent(source, "exclusive-copy cleanup");
-  const quarantined = await lstat2(quarantinePath, { bigint: true });
-  if (quarantined.isFile() && !quarantined.isSymbolicLink() && quarantined.dev === expected.dev && quarantined.ino === expected.ino) {
-    const finalIdentity = await lstat2(quarantinePath, { bigint: true });
-    if (!finalIdentity.isFile() || finalIdentity.isSymbolicLink() || finalIdentity.dev !== expected.dev || finalIdentity.ino !== expected.ino) {
-      throw new GeneratedSpecsIndexMigrationError(
-        "generated_specs_index_copy_cleanup_required",
-        `Exclusive-copy cleanup retained a changed file: ${quarantinePath}`,
-        [quarantinePath]
-      );
-    }
-    await unlink3(quarantinePath);
-    return;
-  }
-  try {
-    await fileAdapter.link(quarantinePath, destinationPath);
-    await unlink3(quarantinePath);
-    throw new GeneratedSpecsIndexMigrationError(
-      "generated_specs_index_copy_replaced",
-      `Exclusive-copy cleanup preserved a concurrent replacement at ${destinationPath}`
-    );
-  } catch (error) {
-    if (error instanceof GeneratedSpecsIndexMigrationError)
-      throw error;
-    if (!hardLinkUnsupported(error) && error.code !== "EEXIST") {
-      throw error;
-    }
-  }
-  if (await lstat2(destinationPath).catch(() => null) === null)
-    await copyConcurrentReplacementExclusive(quarantinePath, destinationPath);
-  throw new GeneratedSpecsIndexMigrationError(
-    "generated_specs_index_copy_cleanup_required",
-    `Exclusive-copy cleanup preserved a concurrent replacement and retained its original inode at ${quarantinePath}`,
-    [quarantinePath]
-  );
-}
-async function copyConcurrentReplacementExclusive(sourcePath, destinationPath) {
-  const sourceHandle = await open(sourcePath, READ_NO_FOLLOW_FLAGS);
-  let destinationHandle = null;
-  try {
-    const sourceBefore = await sourceHandle.stat({ bigint: true });
-    if (!sourceBefore.isFile() || sourceBefore.isSymbolicLink() || sourceBefore.size > BigInt(SPECS_MAX_FILE_BYTES)) {
-      return;
-    }
-    destinationHandle = await open(
-      destinationPath,
-      WRITE_EXCLUSIVE_NO_FOLLOW_FLAGS,
-      Number(permissionMode(sourceBefore.mode))
-    );
-    const buffer = Buffer2.allocUnsafe(64 * 1024);
-    let bytes = 0;
-    while (bytes <= SPECS_MAX_FILE_BYTES) {
-      const read = await sourceHandle.read(buffer, 0, buffer.length, null);
-      if (read.bytesRead === 0)
-        break;
-      bytes += read.bytesRead;
-      if (bytes > SPECS_MAX_FILE_BYTES)
-        return;
-      let written = 0;
-      while (written < read.bytesRead) {
-        const result = await destinationHandle.write(
-          buffer,
-          written,
-          read.bytesRead - written,
-          null
-        );
-        written += result.bytesWritten;
-      }
-    }
-    await destinationHandle.chmod(Number(permissionMode(sourceBefore.mode)));
-    await destinationHandle.sync();
-    const sourceAfter = await sourceHandle.stat({ bigint: true });
-    const destinationAfter = await destinationHandle.stat({ bigint: true });
-    if (!sameSnapshot(sourceBefore, sourceAfter) || destinationAfter.size !== sourceBefore.size || permissionMode(destinationAfter.mode) !== permissionMode(sourceBefore.mode)) {
-      throw new GeneratedSpecsIndexMigrationError(
-        "generated_specs_index_copy_cleanup_required",
-        `Concurrent replacement could not be restored byte-for-byte: ${sourcePath}`,
-        [sourcePath]
-      );
-    }
-  } finally {
-    await destinationHandle?.close();
-    await sourceHandle.close();
-  }
-}
-function retainedMutationEvidence(item) {
-  return {
-    projectPath: item.projectPath,
-    quarantineName: item.quarantinePath.slice(dirname(item.quarantinePath).length + 1),
-    contentHash: item.contentHash,
-    device: String(item.identity.dev),
-    inode: String(item.identity.ino),
-    size: String(item.identity.size),
-    mode: permissionMode(item.identity.mode).toString(8),
-    lastKnownParentRealPath: item.parentChain.entries.at(-1).realPath
-  };
-}
-async function assertMigrationParent(item, operation) {
-  try {
-    await assertStableDirectoryChain(
-      item.parentChain,
-      `generated Specs index ${item.projectPath} ${operation}`
-    );
-  } catch (error) {
-    throw new GeneratedSpecsIndexMigrationError(
-      "generated_specs_index_parent_changed",
-      `Generated Specs-index migration stopped because a managed parent changed before ${operation}: ${item.projectPath}. ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}
-function hardLinkUnsupported(error) {
-  return ["EXDEV", "ENOSYS", "ENOTSUP", "EOPNOTSUPP", "EPERM"].includes(error.code ?? "");
-}
-function permissionMode(mode) {
-  return mode & 0o777n;
-}
-function resolveProjectPath(projectRoot, projectPath) {
-  const normalized = normalizeLogicalPath(projectPath);
-  const absolutePath = resolve2(projectRoot, ...normalized.split("/"));
-  const candidate = relative2(projectRoot, absolutePath);
-  if (normalized === "" || isAbsolute2(projectPath) || candidate === "" || candidate === ".." || candidate.startsWith(`..${sep2}`) || isAbsolute2(candidate) || dirname(normalized) === ".") {
-    throw new GeneratedSpecsIndexMigrationError(
-      "generated_specs_index_path_invalid",
-      `Generated Specs-index path is outside the managed Specs tree: ${projectPath}`
-    );
-  }
-  return absolutePath;
-}
-function changed2(projectPath) {
-  return new GeneratedSpecsIndexMigrationError(
-    "generated_specs_index_changed",
-    `Generated Specs index changed before migration: ${projectPath}`
-  );
-}
-function snapshot(value) {
-  return {
-    dev: value.dev,
-    ino: value.ino,
-    size: value.size,
-    mode: value.mode,
-    mtimeNs: value.mtimeNs,
-    ctimeNs: value.ctimeNs
-  };
-}
-function sameSnapshot(left, right) {
-  return left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mode === right.mode && left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs;
-}
-function sameRenamedSnapshot(left, right) {
-  return left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mode === right.mode && left.mtimeNs === right.mtimeNs;
-}
+## Scenarios
+<!-- Clarify key cross-boundary, failure, or ambiguous behavior with a few examples; omit when unnecessary and keep test execution results in the Change. -->
+- ${placeholder}
 
-// src/commands/update-transaction.ts
-import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
-import { constants as constants2 } from "fs";
-import {
-  chmod,
-  link as link2,
-  lstat as lstat3,
-  mkdir as mkdir2,
-  mkdtemp,
-  open as open2,
-  rename as rename2,
-  rmdir,
-  unlink as unlink4
-} from "fs/promises";
-import { tmpdir } from "os";
-import { dirname as dirname2, join as join2, relative as relative3, resolve as resolve3, sep as sep3 } from "path";
-var READ_NO_FOLLOW_FLAGS2 = constants2.O_RDONLY | (constants2.O_NOFOLLOW ?? 0);
-var WRITE_EXCLUSIVE_NO_FOLLOW_FLAGS2 = constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | (constants2.O_NOFOLLOW ?? 0);
-var UpdateRollbackMutationError = class extends Error {
-  constructor(message, recoveryPaths = []) {
-    super(message);
-    this.recoveryPaths = recoveryPaths;
-    this.name = "UpdateRollbackMutationError";
-  }
-  recoveryPaths;
-};
-var UpdateRollbackJournal = class {
-  constructor(projectRoot = resolve3("."), testing = {}) {
-    this.projectRoot = projectRoot;
-    this.testing = testing;
-  }
-  projectRoot;
-  testing;
-  entries = /* @__PURE__ */ new Map();
-  mutationOrder = [];
-  async capture(path) {
-    const absolutePath = this.resolveProjectPath(path);
-    if (this.entries.has(absolutePath))
-      return;
-    this.entries.set(absolutePath, {
-      path: absolutePath,
-      original: await inspectPathSnapshot(absolutePath),
-      published: null,
-      parentChain: await captureExistingParentChain(
-        this.projectRoot,
-        absolutePath
-      )
-    });
-  }
-  async captureDirectoryChain(path) {
-    const absolutePath = this.resolveProjectPath(path);
-    const rel = relative3(this.projectRoot, absolutePath);
-    const captured = [];
-    let current = this.projectRoot;
-    for (const segment of rel === "" ? [] : rel.split(sep3)) {
-      current = resolve3(current, segment);
-      await this.capture(current);
-      captured.push(current);
-    }
-    return captured;
-  }
-  async mark(path) {
-    const absolutePath = this.resolveProjectPath(path);
-    const entry = this.entries.get(absolutePath);
-    if (!entry)
-      throw new Error(`Update rollback journal did not capture ${absolutePath}`);
-    entry.published = await inspectPathSnapshot(absolutePath);
-    if (!samePathState(entry.original, entry.published) && !this.mutationOrder.includes(absolutePath)) {
-      this.mutationOrder.push(absolutePath);
-    }
-  }
-  async markAll(paths) {
-    for (const path of paths)
-      await this.mark(path);
-  }
-  async rollback() {
-    const restored = [];
-    const retainedMutations = [];
-    const recoveryPaths = [];
-    for (const [path, entry] of this.entries) {
-      if (entry.published)
-        continue;
-      const current = await inspectPathSnapshot(path).catch(() => null);
-      if (current && !samePathState(entry.original, current)) {
-        entry.published = current;
-        if (!this.mutationOrder.includes(path))
-          this.mutationOrder.push(path);
-      }
-    }
-    const ordered = [...this.mutationOrder].sort((left, right) => compareRollbackOrder(
-      this.entries.get(left),
-      this.entries.get(right)
-    ));
-    for (const path of ordered) {
-      const entry = this.entries.get(path);
-      const published = entry.published;
-      if (!published)
-        continue;
-      let current;
-      try {
-        current = await inspectPathSnapshot(path);
-      } catch {
-        await recordIncompleteRollback(
-          this.projectRoot,
-          entry,
-          retainedMutations,
-          recoveryPaths
-        );
-        continue;
-      }
-      if (!samePathState(current, published)) {
-        await recordIncompleteRollback(
-          this.projectRoot,
-          entry,
-          retainedMutations,
-          recoveryPaths
-        );
-        continue;
-      }
-      try {
-        recoveryPaths.push(...await restorePath(entry, this.testing));
-        restored.push(toProjectPath(this.projectRoot, path));
-        if (entry.original.kind === "directory" && published.kind === "missing") {
-          await this.refreshDescendantParentChains(path);
-        }
-      } catch (error) {
-        if (error instanceof UpdateRollbackMutationError)
-          recoveryPaths.push(...error.recoveryPaths);
-        await recordIncompleteRollback(
-          this.projectRoot,
-          entry,
-          retainedMutations,
-          recoveryPaths
-        );
-      }
-    }
-    return {
-      restored,
-      retainedMutations: [...new Set(retainedMutations)].sort(),
-      recoveryPaths: [...new Set(recoveryPaths)].sort()
-    };
-  }
-  resolveProjectPath(path) {
-    const absolutePath = resolve3(path);
-    const rel = relative3(this.projectRoot, absolutePath);
-    if (rel === ".." || rel.startsWith(`..${sep3}`))
-      throw new Error(`Update transaction path escapes the project root: ${path}`);
-    return absolutePath;
-  }
-  async refreshDescendantParentChains(restoredDirectory) {
-    for (const entry of this.entries.values()) {
-      const rel = relative3(restoredDirectory, entry.path);
-      if (rel === "" || rel === ".." || rel.startsWith(`..${sep3}`))
-        continue;
-      entry.parentChain = await captureExistingParentChain(
-        this.projectRoot,
-        entry.path
-      );
-    }
-  }
-};
-async function recordIncompleteRollback(projectRoot, entry, retainedMutations, recoveryPaths) {
-  retainedMutations.push(toProjectPath(projectRoot, entry.path));
-  const recovery = await persistOriginalRecovery(entry.original).catch(() => null);
-  if (recovery)
-    recoveryPaths.push(recovery);
-}
-async function inspectPathSnapshot(path) {
-  let before;
-  try {
-    before = await lstat3(path, { bigint: true });
-  } catch (error) {
-    if (error.code === "ENOENT")
-      return { kind: "missing" };
-    throw error;
-  }
-  if (before.isSymbolicLink())
-    throw new Error(`Update transaction refuses a symlinked path: ${path}`);
-  if (before.isDirectory()) {
-    return {
-      kind: "directory",
-      device: before.dev,
-      inode: before.ino,
-      mode: before.mode
-    };
-  }
-  if (!before.isFile())
-    throw new Error(`Update transaction requires a regular file or directory: ${path}`);
-  const handle = await open2(path, READ_NO_FOLLOW_FLAGS2);
-  try {
-    const opened = await handle.stat({ bigint: true });
-    if (!sameFileIdentity(before, opened))
-      throw new Error(`Update transaction path changed while it was captured: ${path}`);
-    const content = await handle.readFile();
-    const after = await handle.stat({ bigint: true });
-    const finalPath = await lstat3(path, { bigint: true });
-    if (!sameFileIdentity(opened, after) || !sameFileIdentity(after, finalPath) || BigInt(content.length) !== after.size) {
-      throw new Error(`Update transaction path changed while it was captured: ${path}`);
-    }
-    return {
-      kind: "file",
-      content,
-      device: after.dev,
-      inode: after.ino,
-      mode: after.mode,
-      size: after.size,
-      mtimeNs: after.mtimeNs,
-      ctimeNs: after.ctimeNs,
-      contentHash: createHash2("sha256").update(content).digest("hex")
-    };
-  } finally {
-    await handle.close();
-  }
-}
-async function restorePath(entry, testing) {
-  const { path, original, published, parentChain } = entry;
-  if (!published)
-    return [];
-  if (original.kind === "missing") {
-    if (published.kind === "file") {
-      const quarantine2 = await quarantineExpectedFile(entry, published, testing);
-      await unlinkVerifiedQuarantine(quarantine2, published, parentChain);
-      return [];
-    }
-    if (published.kind === "directory") {
-      const quarantine2 = await quarantineExpectedDirectory(entry, published, testing);
-      await assertStableDirectoryChain(parentChain, "update rollback directory removal");
-      await rmdir(quarantine2);
-      await assertStableDirectoryChain(parentChain, "update rollback directory removal");
-      return [];
-    }
-    return [];
-  }
-  if (original.kind === "directory") {
-    if (published.kind === "missing") {
-      await assertStableDirectoryChain(parentChain, "update rollback directory restore");
-      await mkdir2(path, { mode: Number(permissionMode2(original.mode)) });
-      if (process.platform !== "win32")
-        await chmod(path, Number(permissionMode2(original.mode)));
-      return [];
-    }
-    if (published.kind !== "directory")
-      throw new Error(`Update rollback path type changed: ${path}`);
-    const current = await inspectPathSnapshot(path);
-    if (!samePathState(current, published))
-      throw new UpdateRollbackMutationError(`Update rollback directory changed: ${path}`);
-    if (process.platform !== "win32" && permissionMode2(published.mode) !== permissionMode2(original.mode)) {
-      await assertStableDirectoryChain(parentChain, "update rollback directory mode restore");
-      await chmod(path, Number(permissionMode2(original.mode)));
-    }
-    return [];
-  }
-  if (published.kind === "missing") {
-    await writeSnapshotExclusive(path, original, parentChain, testing);
-    return [];
-  }
-  if (published.kind !== "file")
-    throw new Error(`Update rollback path type changed: ${path}`);
-  const quarantine = await quarantineExpectedFile(entry, published, testing);
-  try {
-    await writeSnapshotExclusive(path, original, parentChain, testing);
-  } catch (error) {
-    const recovery = await restoreQuarantinedFile(
-      quarantine,
-      path,
-      published,
-      parentChain
-    );
-    if (recovery.length > 0) {
-      throw new UpdateRollbackMutationError(
-        `Update rollback preserved the current file after restore failure: ${path}`,
-        recovery
-      );
-    }
-    throw error;
-  }
-  await unlinkVerifiedQuarantine(quarantine, published, parentChain);
-  return [];
-}
-async function quarantineExpectedFile(entry, expected, testing) {
-  await testing.afterPublishedValidation?.(entry.path);
-  await assertStableDirectoryChain(entry.parentChain, "update rollback file quarantine");
-  const quarantine = `${entry.path}.${process.pid}.${randomUUID2()}.rsp-update-current`;
-  await rename2(entry.path, quarantine);
-  await assertStableDirectoryChain(entry.parentChain, "update rollback file quarantine");
-  const quarantined = await inspectPathSnapshot(quarantine);
-  if (!sameClaimedPathState(quarantined, expected)) {
-    const recovery = await restoreQuarantinedPath(
-      quarantine,
-      entry.path,
-      quarantined,
-      entry.parentChain
-    );
-    throw new UpdateRollbackMutationError(
-      `Update rollback refused a concurrently replaced file: ${entry.path}`,
-      recovery
-    );
-  }
-  return quarantine;
-}
-async function quarantineExpectedDirectory(entry, expected, testing) {
-  await testing.afterPublishedValidation?.(entry.path);
-  await assertStableDirectoryChain(entry.parentChain, "update rollback directory quarantine");
-  const quarantine = `${entry.path}.${process.pid}.${randomUUID2()}.rsp-update-current`;
-  await rename2(entry.path, quarantine);
-  await assertStableDirectoryChain(entry.parentChain, "update rollback directory quarantine");
-  const quarantined = await inspectPathSnapshot(quarantine);
-  if (!sameClaimedPathState(quarantined, expected)) {
-    const recovery = await restoreQuarantinedPath(
-      quarantine,
-      entry.path,
-      quarantined,
-      entry.parentChain
-    );
-    throw new UpdateRollbackMutationError(
-      `Update rollback refused a concurrently replaced directory: ${entry.path}`,
-      recovery
-    );
-  }
-  return quarantine;
-}
-async function restoreQuarantinedPath(quarantine, destination, snapshot2, parentChain) {
-  if (snapshot2.kind === "file")
-    return restoreQuarantinedFile(quarantine, destination, snapshot2, parentChain);
-  return [quarantine];
-}
-async function restoreQuarantinedFile(quarantine, destination, snapshot2, parentChain) {
-  await assertStableDirectoryChain(parentChain, "update rollback concurrent-file restore");
-  try {
-    await link2(quarantine, destination);
-    const restored = await inspectPathSnapshot(destination);
-    const retained = await inspectPathSnapshot(quarantine);
-    if (!sameClaimedPathState(restored, snapshot2) || !sameClaimedPathState(retained, snapshot2)) {
-      return [quarantine];
-    }
-    await unlinkVerifiedQuarantine(quarantine, snapshot2, parentChain);
-    return [];
-  } catch (error) {
-    if (error.code === "EEXIST")
-      return [quarantine];
-    if (!hardLinkUnsupported2(error))
-      throw error;
-  }
+## Constraints
+<!-- Record necessary technical, protocol, security, or compatibility limits; do not repeat behavior requirements or decision rationale. -->
+- ${placeholder}
+`;
+}
+
+// src/core/update-check.ts
+async function checkForUpdates(current) {
   try {
-    await writeSnapshotExclusive(destination, snapshot2, parentChain, {});
+    const response = await fetch("https://registry.npmjs.org/-/package/@oevery%2Frsp/dist-tags", {
+      signal: AbortSignal.timeout(2e3),
+      redirect: "error"
+    });
+    if (!response.ok)
+      throw new Error("registry unavailable");
+    const body = await response.text();
+    if (body.length > 16384)
+      throw new Error("registry metadata exceeded bound");
+    const latest = JSON.parse(body)?.latest;
+    if (typeof latest !== "string" || !isExactVersion(latest) || !/^\d+\.\d+\.\d+$/.test(latest))
+      throw new Error("invalid stable version");
+    return { status: compareVersions(latest, current) > 0 ? "available" : "current", current, latest };
   } catch {
-    return [quarantine];
+    return { status: "unavailable", current };
   }
-  return [quarantine];
 }
-async function unlinkVerifiedQuarantine(quarantine, expected, parentChain) {
-  await assertStableDirectoryChain(parentChain, "update rollback quarantine cleanup");
-  const current = await inspectPathSnapshot(quarantine);
-  if (!sameClaimedPathState(current, expected)) {
-    throw new UpdateRollbackMutationError(
-      `Update rollback cleanup retained a changed quarantine: ${quarantine}`,
-      [quarantine]
-    );
+
+// src/commands/skills.ts
+import { lstatSync, realpathSync } from "fs";
+import { chmod, copyFile, mkdir, mkdtemp, readdir, readFile as readFile3, rename, rm } from "fs/promises";
+import { dirname, join as join2, relative } from "path";
+var DEFAULT_PACKAGED_SKILL_NAMES = [
+  "rsp",
+  "rsp-shape",
+  "rsp-implement",
+  "rsp-doc",
+  "rsp-verify",
+  "rsp-review",
+  "rsp-commit"
+];
+var RETIRED_PACKAGED_SKILL_NAMES = [
+  "rsp-address-review",
+  "rsp-codebase-audit",
+  "rsp-structural-audit",
+  "rsp-design",
+  "rsp-diagnose",
+  "rsp-manage",
+  "rsp-release-docs",
+  "rsp-resolve-findings",
+  "rsp-tdd"
+];
+function unsupportedEntry(path, label) {
+  return new ManagedPathError(path, `unsupported entry in the ${label} tree: ${path}`);
+}
+async function inspectPackagedSkills(packageRoot) {
+  const skillsRoot = join2(packageRoot, "skills");
+  const rootInspection = inspectManagedDirectory(skillsRoot, "packaged Skills root");
+  if (rootInspection.issue)
+    throw rootInspection.issue;
+  const entries = await readdir(skillsRoot, { withFileTypes: true });
+  const skills = [];
+  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+    if (entry.name.startsWith("."))
+      continue;
+    const root = join2(skillsRoot, entry.name);
+    if (!entry.isDirectory())
+      throw unsupportedEntry(root, "packaged Skills");
+    const inspection = await inspectManagedFileTree(root, `packaged Skill ${entry.name}`, { includeHidden: true });
+    if (inspection.issues.length > 0)
+      throw inspection.issues[0];
+    skills.push({
+      name: entry.name,
+      root,
+      files: inspection.files.map((path) => relative(root, path))
+    });
   }
-  await unlink4(quarantine);
-  await assertStableDirectoryChain(parentChain, "update rollback quarantine cleanup");
+  return skills;
 }
-async function writeSnapshotExclusive(path, snapshot2, parentChain, testing) {
-  let handle = null;
-  let createdIdentity = null;
+function inspectTarget(path, name) {
   try {
-    await assertStableDirectoryChain(parentChain, "update rollback exclusive restore");
-    handle = await open2(
-      path,
-      WRITE_EXCLUSIVE_NO_FOLLOW_FLAGS2,
-      Number(permissionMode2(snapshot2.mode))
-    );
-    const opened = await handle.stat({ bigint: true });
-    if (!opened.isFile() || opened.isSymbolicLink())
-      throw new Error(`Update rollback could not open a regular restore file: ${path}`);
-    createdIdentity = { device: opened.dev, inode: opened.ino };
-    await testing.afterRestoreDestinationOpen?.(path);
-    await handle.writeFile(snapshot2.content);
-    await handle.chmod(Number(permissionMode2(snapshot2.mode)));
-    await handle.sync();
-    const value = await handle.stat({ bigint: true });
-    if (!value.isFile() || value.isSymbolicLink() || value.dev !== createdIdentity.device || value.ino !== createdIdentity.inode || value.size !== snapshot2.size || permissionMode2(value.mode) !== permissionMode2(snapshot2.mode)) {
-      throw new Error(`Update rollback could not validate restored file: ${path}`);
-    }
+    const stats = lstatSync(path);
+    if (stats.isDirectory())
+      return "directory";
+    throw unsupportedEntry(path, `installed Skill ${name}`);
   } catch (error) {
-    await handle?.close().catch(() => void 0);
-    handle = null;
-    if (createdIdentity) {
-      const recovery = await cleanupCreatedFile(
-        path,
-        createdIdentity,
-        parentChain
-      );
-      if (recovery.length > 0) {
-        throw new UpdateRollbackMutationError(
-          `Update rollback exclusive restore preserved a concurrent replacement: ${path}`,
-          recovery
-        );
-      }
-    }
+    if (error.code === "ENOENT")
+      return "missing";
     throw error;
-  } finally {
-    await handle?.close();
-  }
-  await assertStableDirectoryChain(parentChain, "update rollback exclusive restore");
-  const restored = await inspectPathSnapshot(path);
-  if (restored.kind !== "file" || restored.contentHash !== snapshot2.contentHash || permissionMode2(restored.mode) !== permissionMode2(snapshot2.mode)) {
-    throw new Error(`Update rollback restored different bytes or mode: ${path}`);
   }
 }
-async function cleanupCreatedFile(path, expected, parentChain) {
-  const quarantine = `${path}.${process.pid}.${randomUUID2()}.rsp-update-created`;
-  await assertStableDirectoryChain(parentChain, "update rollback exclusive cleanup");
+function inspectInventoryTarget(path) {
   try {
-    await rename2(path, quarantine);
+    return lstatSync(path).isDirectory() ? "directory" : "divergent";
   } catch (error) {
     if (error.code === "ENOENT")
-      return [];
+      return "missing";
     throw error;
   }
-  await assertStableDirectoryChain(parentChain, "update rollback exclusive cleanup");
-  const current = await lstat3(quarantine, { bigint: true });
-  if (current.isFile() && !current.isSymbolicLink() && current.dev === expected.device && current.ino === expected.inode) {
-    const finalIdentity = await lstat3(quarantine, { bigint: true });
-    if (!finalIdentity.isFile() || finalIdentity.isSymbolicLink() || finalIdentity.dev !== expected.device || finalIdentity.ino !== expected.inode) {
-      return [quarantine];
-    }
-    await unlink4(quarantine);
-    return [];
-  }
-  const snapshot2 = await inspectPathSnapshot(quarantine);
-  return restoreQuarantinedPath(quarantine, path, snapshot2, parentChain);
-}
-async function persistOriginalRecovery(original) {
-  if (original.kind !== "file")
-    return null;
-  const recoveryRoot = await mkdtemp(join2(tmpdir(), "rsp-update-recovery-"));
-  if (process.platform !== "win32")
-    await chmod(recoveryRoot, 448);
-  const recovery = join2(recoveryRoot, "snapshot");
-  const parentChain = await captureStableDirectoryChain({
-    rootPath: recoveryRoot,
-    targetPath: recoveryRoot,
-    label: "update rollback recovery root"
-  });
-  await writeSnapshotExclusive(recovery, original, parentChain, {});
-  return recovery;
-}
-async function captureExistingParentChain(projectRoot, path) {
-  let parent = dirname2(path);
-  while (true) {
-    const rel = relative3(projectRoot, parent);
-    if (rel === ".." || rel.startsWith(`..${sep3}`))
-      throw new Error(`Update transaction parent escapes the project root: ${path}`);
-    try {
-      const value = await lstat3(parent);
-      if (!value.isDirectory() || value.isSymbolicLink())
-        throw new Error(`Update transaction parent must be a real directory: ${parent}`);
-      break;
-    } catch (error) {
-      if (error.code !== "ENOENT")
-        throw error;
-      if (parent === projectRoot)
-        throw error;
-      parent = dirname2(parent);
-    }
-  }
-  return captureStableDirectoryChain({
-    rootPath: projectRoot,
-    targetPath: parent,
-    label: `update transaction ${path}`
-  });
 }
-function samePathState(left, right) {
-  if (left.kind !== right.kind)
+function isCanonicalSourceProjection(sourceRoot, targetRoot) {
+  try {
+    if (!lstatSync(targetRoot).isSymbolicLink())
+      return false;
+    return realpathSync(targetRoot) === realpathSync(sourceRoot);
+  } catch {
     return false;
-  if (left.kind === "missing")
-    return true;
-  if (left.kind === "directory" && right.kind === "directory") {
-    return left.device === right.device && left.inode === right.inode && permissionMode2(left.mode) === permissionMode2(right.mode);
   }
-  if (left.kind === "file" && right.kind === "file") {
-    return left.device === right.device && left.inode === right.inode && left.size === right.size && left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs && permissionMode2(left.mode) === permissionMode2(right.mode) && left.contentHash === right.contentHash;
-  }
-  return false;
-}
-function compareRollbackOrder(left, right) {
-  const leftRestoresDeleted = left.original.kind !== "missing" && left.published?.kind === "missing";
-  const rightRestoresDeleted = right.original.kind !== "missing" && right.published?.kind === "missing";
-  if (leftRestoresDeleted !== rightRestoresDeleted)
-    return leftRestoresDeleted ? -1 : 1;
-  if (leftRestoresDeleted)
-    return pathDepth(left.path) - pathDepth(right.path);
-  return pathDepth(right.path) - pathDepth(left.path);
 }
-function sameClaimedPathState(left, right) {
-  if (left.kind !== right.kind)
+async function treesEqual(source, targetRoot) {
+  const target = await inspectManagedFileTree(targetRoot, `installed Skill ${source.name}`, { includeHidden: true });
+  if (target.issues.length > 0)
+    throw target.issues[0];
+  const targetFiles = target.files.map((path) => relative(targetRoot, path));
+  if (source.files.length !== targetFiles.length || source.files.some((path, index) => path !== targetFiles[index]))
     return false;
-  if (left.kind === "missing")
-    return true;
-  if (left.kind === "directory" && right.kind === "directory") {
-    return left.device === right.device && left.inode === right.inode && permissionMode2(left.mode) === permissionMode2(right.mode);
-  }
-  if (left.kind === "file" && right.kind === "file") {
-    return left.device === right.device && left.inode === right.inode && left.size === right.size && permissionMode2(left.mode) === permissionMode2(right.mode) && left.contentHash === right.contentHash;
+  for (const path of source.files) {
+    const sourcePath = join2(source.root, path);
+    const targetPath = join2(targetRoot, path);
+    const [sourceStats, targetStats] = [lstatSync(sourcePath), lstatSync(targetPath)];
+    if (!sourceStats.isFile() || !targetStats.isFile())
+      throw unsupportedEntry(!sourceStats.isFile() ? sourcePath : targetPath, `Skill ${source.name}`);
+    if ((sourceStats.mode & 511) !== (targetStats.mode & 511))
+      return false;
+    const [sourceContent, targetContent] = await Promise.all([readFile3(sourcePath), readFile3(targetPath)]);
+    if (!sourceContent.equals(targetContent))
+      return false;
   }
-  return false;
-}
-function sameFileIdentity(left, right) {
-  return left.isFile() && right.isFile() && !left.isSymbolicLink() && !right.isSymbolicLink() && left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs;
-}
-function hardLinkUnsupported2(error) {
-  return ["EXDEV", "ENOSYS", "ENOTSUP", "EOPNOTSUPP", "EPERM"].includes(error.code ?? "");
-}
-function permissionMode2(mode) {
-  return mode & 0o777n;
-}
-function pathDepth(path) {
-  return path.split(sep3).length;
+  return true;
 }
-function toProjectPath(projectRoot, path) {
-  return relative3(projectRoot, path).split(sep3).join("/");
+async function inspectPackagedSkillInventory(options = {}) {
+  const packageRoot = options.packageRoot ?? PKG_ROOT;
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const packagedSkills = await inspectPackagedSkills(packageRoot);
+  const packagedNames = new Set(packagedSkills.map((skill) => skill.name));
+  const missingDefaults = DEFAULT_PACKAGED_SKILL_NAMES.filter((name) => !packagedNames.has(name));
+  if (missingDefaults.length > 0)
+    throw new Error(`packaged Skills missing default Skills: ${missingDefaults.join(", ")}`);
+  const manifest = JSON.parse(await readFile3(join2(packageRoot, "package.json"), "utf8"));
+  if (typeof manifest.name !== "string" || typeof manifest.version !== "string")
+    throw new Error("package.json must contain string name and version fields");
+  const targetRoot = resolveManagedDirectoryChain(projectRoot, [".agents", "skills"], "project Skills root");
+  const defaults = new Set(DEFAULT_PACKAGED_SKILL_NAMES);
+  const skills = [];
+  for (const skill of packagedSkills) {
+    const target = join2(targetRoot, skill.name);
+    const targetStatus = inspectInventoryTarget(target);
+    skills.push({
+      name: skill.name,
+      kind: defaults.has(skill.name) ? "default" : "optional",
+      status: targetStatus === "missing" ? "missing" : targetStatus === "divergent" ? isCanonicalSourceProjection(skill.root, target) ? "unchanged" : "divergent" : await treesEqual(skill, target) ? "unchanged" : "divergent"
+    });
+  }
+  const retired = RETIRED_PACKAGED_SKILL_NAMES.filter((name) => inspectInventoryTarget(join2(targetRoot, name)) !== "missing");
+  return {
+    retired,
+    package: { name: manifest.name, version: manifest.version },
+    target: relative(projectRoot, targetRoot) || ".",
+    skills
+  };
 }
-
-// src/commands/update.ts
-var UpdateTransactionError = class extends Error {
-  constructor(message, attemptedActions, rollback, options = {}) {
-    super(message, options);
-    this.attemptedActions = attemptedActions;
-    this.rollback = rollback;
-    this.name = "UpdateTransactionError";
-  }
-  attemptedActions;
-  rollback;
-};
-async function updateProject(options = {}) {
-  if (!existsSync(RSP_DIR)) {
-    return {
-      ok: false,
-      actions: [],
-      updated: false,
-      events: [{ type: "not-initialized" }],
-      migration: { inspectionComplete: false, manualMigrationRequired: false, residualEntries: [], diagnostics: [] }
-    };
+async function copySkillTree(source, targetRoot) {
+  await mkdir(targetRoot, { recursive: true });
+  for (const path of source.files) {
+    const sourcePath = join2(source.root, path);
+    const targetPath = join2(targetRoot, path);
+    const stats = lstatSync(sourcePath);
+    if (!stats.isFile())
+      throw unsupportedEntry(sourcePath, `packaged Skill ${source.name}`);
+    await mkdir(dirname(targetPath), { recursive: true });
+    await copyFile(sourcePath, targetPath);
+    await chmod(targetPath, stats.mode & 511);
+  }
+}
+async function updatePackagedSkills(options = {}) {
+  const packageRoot = options.packageRoot ?? PKG_ROOT;
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const renamePath = options.renamePath ?? rename;
+  const packaged = await inspectPackagedSkills(packageRoot);
+  const skills = DEFAULT_PACKAGED_SKILL_NAMES.map((name) => {
+    const skill = packaged.find((candidate) => candidate.name === name);
+    if (!skill)
+      throw new Error(`Packaged Skill missing: ${name}`);
+    return skill;
+  }).sort((a, b) => a.name.localeCompare(b.name));
+  const targetRoot = resolveManagedDirectoryChain(projectRoot, [".agents", "skills"], "project Skills root");
+  const result = { installed: [], removed: [], unchanged: [], replaced: [] };
+  for (const skill of skills) {
+    const target = join2(targetRoot, skill.name);
+    if (isCanonicalSourceProjection(skill.root, target))
+      result.unchanged.push(skill.name);
+    else if (inspectTarget(target, skill.name) === "missing")
+      result.installed.push(skill.name);
+    else if (await treesEqual(skill, target))
+      result.unchanged.push(skill.name);
+    else
+      result.replaced.push(skill.name);
   }
-  return withRspLock("update", async () => {
-    const agentsPath = "AGENTS.md";
-    const agentsInspection = inspectManagedFile(agentsPath, "AGENTS.md", { allowMissing: true });
-    if (agentsInspection.issue)
-      throw agentsInspection.issue;
-    let updated = false;
-    const actions = [];
-    const events = [];
-    clearConfigCache();
-    const configInspection = await inspectRspConfig();
-    if (configInspection.issues.length > 0)
-      throw new Error(configInspection.issues.join("; "));
-    const decisionRecordsPath = resolveDecisionRecordsPath(configInspection.config);
-    const decisionRecordsFilesystemIssue = await validateDecisionRecordsFilesystemPath(decisionRecordsPath);
-    if (decisionRecordsFilesystemIssue)
-      throw new Error(decisionRecordsFilesystemIssue);
-    const specsMigrationPlan = await inspectGeneratedSpecsIndexMigration();
-    if (!specsMigrationPlan.inspectionComplete || specsMigrationPlan.ownerControlled.length > 0) {
-      const ownerMessage = specsMigrationPlan.ownerControlled.length > 0 ? ` Owner-controlled reserved path(s): ${specsMigrationPlan.ownerControlled.join(", ")}.` : "";
-      const diagnosticMessage = specsMigrationPlan.diagnostics.length > 0 ? ` ${specsMigrationPlan.diagnostics.join("; ")}` : "";
-      throw new Error(`Generated Specs-index migration requires owner review before update.${ownerMessage}${diagnosticMessage}`);
+  for (const name of RETIRED_PACKAGED_SKILL_NAMES) {
+    if (inspectTarget(join2(targetRoot, name), name) !== "missing")
+      result.removed.push(name);
+  }
+  if (options.dryRun || result.installed.length + result.replaced.length + result.removed.length === 0)
+    return result;
+  await mkdir(targetRoot, { recursive: true });
+  resolveManagedDirectoryChain(projectRoot, [".agents", "skills"], "project Skills root");
+  const staging = await mkdtemp(join2(targetRoot, ".rsp-skills-"));
+  const completed = [];
+  let failure2;
+  try {
+    for (const skill of skills) {
+      if (!result.unchanged.includes(skill.name))
+        await copySkillTree(skill, join2(staging, skill.name));
     }
-    const rollbackJournal = new UpdateRollbackJournal(
-      process.cwd(),
-      options.testing?.rollback
-    );
-    try {
-      const configFileInspection = inspectManagedFile(CONFIG_PATH, "config file", { allowMissing: true });
-      if (configFileInspection.issue)
-        throw configFileInspection.issue;
-      const configContent = configFileInspection.exists ? await readFile4(CONFIG_PATH, "utf-8") : null;
-      const reconciledConfig = configContent === null ? { content: generateConfigTemplate(), added: ["all defaults"], changed: true } : reconcileRspConfigDefaults(configContent);
-      if (reconciledConfig.changed) {
-        await rollbackJournal.capture(CONFIG_PATH);
-        await writeManagedFile(CONFIG_PATH, reconciledConfig.content, "config file");
-        await rollbackJournal.mark(CONFIG_PATH);
-        const detail = reconciledConfig.added.length > 0 ? `defaults added: ${reconciledConfig.added.join(", ")}` : "generated layout normalized";
-        actions.push(`config.yaml ${detail}`);
-        events.push({ type: "updated", message: `config.yaml ${detail}` });
-        updated = true;
-      }
-      const changesInspection = inspectManagedDirectory(CHANGES_DIR, "open work root", { allowMissing: true });
-      if (changesInspection.issue)
-        throw changesInspection.issue;
-      if (!changesInspection.exists) {
-        const changesDirectoryChain = await rollbackJournal.captureDirectoryChain(CHANGES_DIR);
-        const changesPlaceholder = join3(CHANGES_DIR, ".gitkeep");
-        await rollbackJournal.capture(changesPlaceholder);
-        await mkdir3(CHANGES_DIR, { recursive: true });
-        await ensureManagedFile(changesPlaceholder, "", "changes placeholder");
-        await rollbackJournal.mark(changesPlaceholder);
-        await rollbackJournal.markAll(changesDirectoryChain);
-        actions.push("changes/ directory restored");
-        events.push({ type: "updated", message: "changes/ directory restored" });
-        updated = true;
-      }
-      const archivesInspection = inspectManagedDirectory(join3(RSP_DIR, "archives"), "archive root", { allowMissing: true });
-      if (archivesInspection.issue)
-        throw archivesInspection.issue;
-      const bundledRules = await readFile4(join3(options.testing?.packageRoot ?? PKG_ROOT, "rules", "rsp-rules.md"), "utf-8");
-      const rulesInspection = inspectManagedFile(RSP_RULES_PATH, "fallback protocol", { allowMissing: true });
-      if (rulesInspection.issue)
-        throw rulesInspection.issue;
-      const existingRules = rulesInspection.exists ? await readFile4(RSP_RULES_PATH, "utf-8") : null;
-      if (existingRules !== bundledRules) {
-        await rollbackJournal.capture(RSP_RULES_PATH);
-        await writeManagedFile(RSP_RULES_PATH, bundledRules, "fallback protocol");
-        await rollbackJournal.mark(RSP_RULES_PATH);
-        actions.push("rsp-rules.md updated");
-        events.push({ type: "updated", message: "rsp-rules.md updated" });
-        updated = true;
-      }
-      if (existsSync(OBSOLETE_RSP_RULES_PATH)) {
-        await rollbackJournal.capture(OBSOLETE_RSP_RULES_PATH);
-        await rm(OBSOLETE_RSP_RULES_PATH);
-        await rollbackJournal.mark(OBSOLETE_RSP_RULES_PATH);
-        actions.push("obsolete rules/rsp-rules.md removed");
-        events.push({ type: "updated", message: "obsolete rules/rsp-rules.md removed" });
-        updated = true;
-      }
-      try {
-        const rulesRoot = join3(RSP_DIR, "rules");
-        await rollbackJournal.capture(rulesRoot);
-        await rmdir2(rulesRoot);
-        await rollbackJournal.mark(rulesRoot);
-        actions.push("empty rules directory removed");
-        updated = true;
-      } catch (error) {
-        if (!["ENOENT", "ENOTEMPTY"].includes(error.code || ""))
-          throw error;
-      }
-      let inspection = await inspectUnsupportedRules();
-      if (inspection.diagnostics.length === 0 && inspection.directoryRemaining && inspection.entries.every((entry) => entry.kind === "directory")) {
-        const directories = inspection.entries.map((entry) => entry.path).sort((left, right) => right.split("/").length - left.split("/").length);
-        for (const path of directories) {
-          const directoryPath = join3(RSP_DIR, "rules", path);
-          await rollbackJournal.capture(directoryPath);
-          await rmdir2(directoryPath);
-          await rollbackJournal.mark(directoryPath);
-        }
-        const rulesRoot = join3(RSP_DIR, "rules");
-        await rollbackJournal.capture(rulesRoot);
-        await rmdir2(rulesRoot);
-        await rollbackJournal.mark(rulesRoot);
-        actions.push("empty rules directory tree removed");
-        events.push({ type: "updated", message: "empty rules directory tree removed" });
-        updated = true;
-        inspection = await inspectUnsupportedRules();
-      }
-      const residualEntries = inspection.entries.map((entry) => entry.path);
-      if (inspection.diagnostics.length > 0)
-        events.push({ type: "migration-diagnostics", diagnostics: inspection.diagnostics });
-      if (residualEntries.length > 0)
-        events.push({ type: "residual-rules", entries: residualEntries });
-      const projectName = await detectProjectName();
-      const baseAgents = agentsInspection.exists ? await readFile4(agentsPath, "utf-8") : `# ${projectName}
-
-`;
-      const nextAgents = upsertRspAgentsBlock(baseAgents);
-      if (!agentsInspection.exists || nextAgents.changed) {
-        await rollbackJournal.capture(agentsPath);
-        await writeManagedFile(agentsPath, nextAgents.content, "AGENTS.md");
-        await rollbackJournal.mark(agentsPath);
-        actions.push("AGENTS.md managed block refreshed");
-        events.push({ type: "updated", message: "AGENTS.md managed block refreshed" });
-        updated = true;
-      }
-      const decisionRecordsDirectoryChain = await rollbackJournal.captureDirectoryChain(decisionRecordsPath);
-      const decisionRecordsPlaceholder = join3(decisionRecordsPath, ".gitkeep");
-      await rollbackJournal.capture(decisionRecordsPlaceholder);
-      if (await ensureDecisionRecordsDirectory(decisionRecordsPath)) {
-        await rollbackJournal.mark(decisionRecordsPlaceholder);
-        await rollbackJournal.markAll(decisionRecordsDirectoryChain);
-        actions.push(`Decision Record directory ensured: ${decisionRecordsPath}`);
-        events.push({ type: "updated", message: `Decision Record directory ensured: ${decisionRecordsPath}` });
-        updated = true;
-      }
-      const legacyArchiveIndexPath = join3(RSP_DIR, "archives", "INDEX.md");
-      await rollbackJournal.capture(legacyArchiveIndexPath);
-      if (await removeLegacyArchiveIndex()) {
-        await rollbackJournal.mark(legacyArchiveIndexPath);
-        actions.push("legacy Archive Index removed");
-        events.push({ type: "updated", message: "legacy Archive Index removed" });
-        updated = true;
-      }
-      for (const path of specsMigrationPlan.removable)
-        await rollbackJournal.capture(path);
-      await options.testing?.afterPreMutations?.();
-      const removedSpecsIndexes = await removeRecognizedGeneratedSpecsIndexes();
-      for (const path of specsMigrationPlan.removable)
-        await rollbackJournal.mark(path);
-      await options.testing?.afterSpecsMigration?.();
-      if (removedSpecsIndexes.length > 0) {
-        actions.push(`generated Specs indexes removed: ${removedSpecsIndexes.join(", ")}`);
-        events.push({ type: "specs-indexes-removed", paths: removedSpecsIndexes });
-        updated = true;
-      }
-      return {
-        ok: inspection.diagnostics.length === 0,
-        actions,
-        updated,
-        events,
-        migration: {
-          inspectionComplete: inspection.diagnostics.length === 0,
-          manualMigrationRequired: inspection.directoryRemaining,
-          residualEntries,
-          diagnostics: inspection.diagnostics
-        }
-      };
-    } catch (error) {
-      const rollback = await rollbackJournal.rollback();
-      clearConfigCache();
-      if (rollback.retainedMutations.length > 0 || rollback.recoveryPaths.length > 0) {
-        throw new UpdateTransactionError(
-          `RSP update failed and could not fully restore its command-scoped mutations: ${error instanceof Error ? error.message : String(error)}`,
-          actions,
-          rollback,
-          { cause: error }
-        );
-      }
-      throw error;
+    for (const name of result.removed) {
+      resolveManagedDirectoryChain(projectRoot, [".agents", "skills"], "project Skills root");
+      inspectTarget(join2(targetRoot, name), name);
+      await rm(join2(targetRoot, name), { recursive: true, force: true });
+      completed.push(`removed ${name}`);
     }
-  });
+    for (const skill of skills) {
+      if (result.unchanged.includes(skill.name))
+        continue;
+      resolveManagedDirectoryChain(projectRoot, [".agents", "skills"], "project Skills root");
+      const target = join2(targetRoot, skill.name);
+      inspectTarget(target, skill.name);
+      await rm(target, { recursive: true, force: true });
+      await renamePath(join2(staging, skill.name), target);
+      completed.push(`installed ${skill.name}`);
+    }
+  } catch (error) {
+    failure2 = new Error(`Skill update stopped; completed: ${completed.join(", ") || "none"}. ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+  try {
+    await rm(staging, { recursive: true });
+  } catch (error) {
+    failure2 = new Error(`Temporary Skill content cleanup failed: ${staging}`, { cause: failure2 ?? error });
+  }
+  if (failure2)
+    throw failure2;
+  return result;
 }
 
 // src/commands/doctor.ts
 async function runDoctor(options = {}) {
-  const fixed = [];
-  let repairIssue = null;
-  if (options.fix && existsSync2(RSP_DIR)) {
-    try {
-      const update = await updateProject({ testing: options.testing });
-      fixed.push(...update.actions);
-    } catch (error) {
-      if (error instanceof UpdateTransactionError) {
-        fixed.push(
-          ...error.rollback.retainedMutations.map((path) => `partial update mutation retained: ${path}`),
-          ...error.rollback.recoveryPaths.map((path) => `update recovery copy retained: ${path}`)
-        );
-      }
-      repairIssue = `safe deterministic repair could not run: ${toErrorMessage(error)}`;
-    }
-  }
   const checks = [];
-  if (repairIssue) {
+  const runtime = [];
+  const reportRuntime = (diagnostic) => runtime.push(diagnostic);
+  reportCheck(checks, ".rsp exists", existsSync(RSP_DIR), "Run: rsp init");
+  reportRetiredProtocol(checks);
+  const sourceMode = await reportProjectRuntime(checks);
+  if (options.checkUpdates) {
+    const notice = await checkForUpdates(await getVersion());
     checks.push({
-      status: "issue",
-      label: "safe deterministic repairs completed",
-      message: repairIssue,
-      hint: "Resolve the reported configuration or filesystem issue, then run rsp doctor --fix again."
+      status: "info",
+      code: `update_${notice.status}`,
+      label: "stable package update check",
+      message: notice.status === "available" ? `RSP ${notice.latest} is available; running ${notice.current}. Project selection is unchanged.` : notice.status === "current" ? `No newer stable package found for ${notice.current}.` : "Update metadata is unavailable; local checks are unaffected.",
+      hint: sourceMode ? "Stable package metadata does not establish source freshness. Keep using the local source CLI; this notice does not select a package runtime." : notice.status === "available" ? "Inspect migration guidance and choose an exact target. Upgrade notices authorize no update." : void 0
     });
   }
-  const runtime = [];
-  const reportRuntime = (diagnostic) => runtime.push(diagnostic);
-  const designPath = join4(RSP_DIR, "specs", "design.md");
-  reportCheck(checks, ".rsp exists", existsSync2(RSP_DIR), "Run: rsp init");
-  reportFallbackProtocol(checks);
   await reportUnsupportedRules(checks, reportRuntime);
-  reportCheck(checks, "specs/design.md exists", existsSync2(designPath), "Run: rsp init");
+  const initialization = inspectRspInitialization();
+  checks.push({ status: initialization ? "issue" : "ok", label: "specs/design.md exists", message: initialization });
   await checkAgents(checks, reportRuntime);
+  if (existsSync("CONTEXT-MAP.md")) {
+    checks.push({
+      status: "info",
+      code: "legacy_context_map",
+      label: "legacy root context map detected",
+      message: "CONTEXT-MAP.md remains; its semantic migration requires owner review.",
+      hint: "Use Core context migration. Retain relevant legacy context until an authorized merge updates CONTEXT.md and active references; update does not migrate or delete it."
+    });
+  }
   await checkSpecsTree(checks, reportRuntime);
   await checkArchiveNaming(checks);
   const decisionRecordsConfigValid = await checkConfigSemantics(checks, reportRuntime);
@@ -2394,7 +1286,6 @@ async function runDoctor(options = {}) {
   const result = {
     command: "doctor",
     ok: checks.every((check) => check.status !== "issue"),
-    fixed,
     checks,
     runtime,
     summary: {
@@ -2403,32 +1294,52 @@ async function runDoctor(options = {}) {
   };
   return result;
 }
-function reportFallbackProtocol(checks) {
-  const canonical = inspectManagedFile(RSP_RULES_PATH, "fallback protocol", { allowMissing: true });
-  const obsoleteExists = existsSync2(OBSOLETE_RSP_RULES_PATH);
-  if (canonical.issue) {
-    checks.push({
-      status: "issue",
-      label: "rsp-rules.md is a regular managed file",
-      message: canonical.issue.message,
-      hint: "Replace the unsupported entry with a project-local regular file, then run: rsp update"
-    });
-  } else if (canonical.exists) {
-    checks.push({ status: "ok", label: "rsp-rules.md exists" });
-  } else if (!obsoleteExists) {
+async function reportProjectRuntime(checks) {
+  let sourceMode = false;
+  try {
+    const selected = await readProjectRuntime();
+    sourceMode = selected.mode === "source";
+    const running = await getVersion();
     checks.push({
-      status: "issue",
-      label: "rsp-rules.md exists",
-      hint: existsSync2(RSP_DIR) ? "Run: rsp update" : "Run: rsp init"
+      status: selected.mode === "source" || selected.version === running ? "ok" : "issue",
+      code: "project_cli_version",
+      label: "project CLI runtime",
+      message: selected.mode === "source" ? `Source mode: this checkout's local CLI; package metadata ${running} is not source identity.` : selected.version ? `Project pins ${selected.version}; running ${running}.` : "Project has no exact CLI pin.",
+      hint: selected.mode === "source" ? `Build current source, then use ${SOURCE_INVOCATION} <command>. Retain commit, uncommitted diff and build inputs for candidate evidence.` : selected.version ? `Use ${exactInvocation(selected.version)} <command>; only an authorized migration uses update.` : "Choose an exact CLI version, then run its update command."
     });
+  } catch (error) {
+    checks.push({ status: "issue", code: "project_cli_version", label: "project CLI runtime", message: toErrorMessage(error) });
   }
-  if (obsoleteExists) {
+  try {
+    const inventory = await inspectPackagedSkillInventory();
+    const drift = [
+      ...inventory.skills.filter((skill) => skill.status !== "unchanged").map((skill) => `${skill.name}: ${skill.status}`),
+      ...inventory.retired.map((name) => `${name}: retired`)
+    ];
     checks.push({
-      status: "issue",
-      label: "obsolete fallback protocol path detected",
-      message: "obsolete fallback protocol path detected",
-      hint: "Run: rsp update"
+      status: drift.length === 0 ? "ok" : "issue",
+      code: "project_skill_suite",
+      label: "project Skill suite matches running package",
+      message: drift.length > 0 ? drift.join(", ") : void 0,
+      hint: drift.length > 0 ? "Preserve needed custom content in managed Skills, then run the selected exact CLI: update." : void 0
     });
+  } catch (error) {
+    checks.push({ status: "issue", code: "project_skill_suite", label: "project Skill suite is inspectable", message: toErrorMessage(error) });
+  }
+  return sourceMode;
+}
+function reportRetiredProtocol(checks) {
+  for (const path of [RSP_RULES_PATH, OBSOLETE_RSP_RULES_PATH]) {
+    const inspection = inspectManagedFile(path, "retired Rules file", { allowMissing: true });
+    if (inspection.issue || inspection.exists) {
+      checks.push({
+        status: "issue",
+        code: "retired_rules",
+        label: `retired Rules path: ${path}`,
+        message: inspection.issue?.message ?? "Rules are no longer read or generated.",
+        hint: "Preserve needed custom content, then run update. Symlinks and special files require owner review."
+      });
+    }
   }
 }
 async function reportUnsupportedRules(checks, reportRuntime) {
@@ -2468,7 +1379,7 @@ async function checkAgents(checks, reportRuntime) {
       status: "issue",
       label: "AGENTS.md is a regular managed file",
       message: inspection.issue.message,
-      hint: "Replace the unsupported entry with a project-local regular file, then run: rsp update"
+      hint: "Check AGENTS.md path type and permissions; preserve user content before correcting the entry. Then run: rsp update"
     });
     return;
   }
@@ -2478,7 +1389,7 @@ async function checkAgents(checks, reportRuntime) {
   }
   let agents;
   try {
-    agents = await readFile5("AGENTS.md", "utf-8");
+    agents = await readFile4("AGENTS.md", "utf-8");
   } catch (error) {
     reportRuntime({
       code: "agents_read_failed",
@@ -2486,7 +1397,7 @@ async function checkAgents(checks, reportRuntime) {
       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" });
+    checks.push({ status: "issue", label: "AGENTS.md contains managed RSP block", message: "AGENTS.md could not be read", hint: "Check AGENTS.md permissions and filesystem access; init/update do not repair unreadable user content." });
     return;
   }
   if (hasRspAgentsBlock(agents)) {
@@ -2537,7 +1448,7 @@ async function checkSpecsTree(checks, reportRuntime) {
   }
 }
 async function checkArchiveNaming(checks) {
-  const archivesDir = join4(RSP_DIR, "archives");
+  const archivesDir = join3(RSP_DIR, "archives");
   const inspection = await inspectArchiveTree({ archivesDir });
   if (inspection.diagnostics.length > 0) {
     checks.push({
@@ -2549,7 +1460,7 @@ async function checkArchiveNaming(checks) {
     return;
   }
   checks.push({ status: "ok", label: "archives use supported managed paths" });
-  const invalidFiles = inspection.files.map((fp) => normalizeLogicalPath(relative4(archivesDir, fp))).filter((fp) => /^\d{4}-\d{2}-\d{2}_.+\.md$/.test(basename(fp)) === false);
+  const invalidFiles = inspection.files.map((fp) => normalizeLogicalPath(relative2(archivesDir, fp))).filter((fp) => /^\d{4}-\d{2}-\d{2}_.+\.md$/.test(basename(fp)) === false);
   if (invalidFiles.length === 0) {
     checks.push({ status: "ok", label: "archived change files follow the date_name.md convention" });
     return;
@@ -2558,7 +1469,7 @@ async function checkArchiveNaming(checks) {
     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"
+    hint: "Rename archive files to YYYY-MM-DD_name.md, then rerun rsp doctor"
   });
 }
 async function checkConfigSemantics(checks, reportRuntime) {
@@ -2605,7 +1516,7 @@ async function checkDecisionRecordsDirectory(checks, reportRuntime) {
         status: "issue",
         label: `${decisionRecordsPath} is the authoritative Decision Record directory`,
         message: filesystemError,
-        hint: "Choose a project-relative directory that does not escape through a symlink."
+        hint: "Correct decisions.path or its filesystem entry; it must resolve to a project-local directory. Preserve existing user content."
       });
       return;
     }
@@ -2616,10 +1527,12 @@ async function checkDecisionRecordsDirectory(checks, reportRuntime) {
       checks,
       `${decisionRecordsPath} is the authoritative Decision Record directory`,
       info.isDirectory(),
-      "Run: rsp update"
+      "Correct the path type; init/update do not replace existing user content."
     );
   } catch (error) {
-    if (error.code !== "ENOENT") {
+    const code = error.code;
+    const missing = code === "ENOENT";
+    if (!missing) {
       reportRuntime({
         code: "decision_records_path_stat_failed",
         operation: "stat",
@@ -2630,14 +1543,14 @@ async function checkDecisionRecordsDirectory(checks, reportRuntime) {
     checks.push({
       status: "issue",
       label: `${decisionRecordsPath} is the authoritative Decision Record directory`,
-      message: `${decisionRecordsPath} Decision Record directory is missing or unreadable`,
-      hint: "Run: rsp update"
+      message: missing ? `${decisionRecordsPath} Decision Record directory is missing` : `Unable to inspect Decision Record directory ${decisionRecordsPath}: ${toErrorMessage(error)}`,
+      hint: missing ? "Create the directory yourself, or run rsp init to create missing scaffolding. Update does not create user directories." : code === "EACCES" || code === "EPERM" ? "Check directory and parent permissions; init/update do not repair filesystem access." : "Resolve the filesystem error or correct decisions.path, then rerun rsp doctor."
     });
   }
 }
 async function checkInactiveDefaultDecisionRecords(checks, reportRuntime) {
   const decisionRecordsPath = resolveDecisionRecordsPath(await loadRspConfig());
-  if (decisionRecordsPath === DEFAULT_DECISION_RECORDS_PATH || !existsSync2(DEFAULT_DECISION_RECORDS_PATH))
+  if (decisionRecordsPath === DEFAULT_DECISION_RECORDS_PATH || !existsSync(DEFAULT_DECISION_RECORDS_PATH))
     return;
   let inspectionFailed = false;
   const inactiveRecords = (await walkMarkdownFiles(DEFAULT_DECISION_RECORDS_PATH, {
@@ -2645,7 +1558,7 @@ async function checkInactiveDefaultDecisionRecords(checks, reportRuntime) {
       inspectionFailed = true;
       reportRuntime(diagnostic);
     }
-  })).map((path) => normalizeLogicalPath(relative4(DEFAULT_DECISION_RECORDS_PATH, path))).sort();
+  })).map((path) => normalizeLogicalPath(relative2(DEFAULT_DECISION_RECORDS_PATH, path))).sort();
   if (inspectionFailed) {
     checks.push({
       status: "issue",
@@ -2899,7 +1812,7 @@ function emptyCollectionSummary() {
 }
 
 // src/commands/ready.ts
-import { readFile as readFile6 } from "fs/promises";
+import { readFile as readFile5 } from "fs/promises";
 function readyError(name, error, kind) {
   return { command: "ready", ok: false, change: name || null, path: null, warnings: [], runtime: [], error, kind };
 }
@@ -2919,7 +1832,7 @@ async function showReady(name) {
   const runtime = [];
   let content;
   try {
-    content = await readFile6(srcPath, "utf-8");
+    content = await readFile5(srcPath, "utf-8");
   } catch {
     return readyError(name, { code: "change_read_failed", message: `unable to read .rsp/changes/${name}.md` }, "read");
   }
@@ -2937,9 +1850,10 @@ async function showReady(name) {
     return readyError(name, { code: "invalid_config", message: `.rsp/config.yaml could not be parsed: ${toErrorMessage(error)}` }, "config");
   }
   const dependencyInspection = await inspectChangeDependencies();
-  const readinessDetails = collectArchiveReadiness(content, {
+  const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
+  const readinessDetails = collectArchiveReadiness(document, {
     activeBlockers: dependencyInspection.activeBlockers.get(name),
-    documentDiagnostics: inspectChangeDocument(content, {
+    documentDiagnostics: inspectChangeDocument(document, {
       name,
       validKinds: resolveKinds(configInspection.config),
       requiredSections: resolveRequiredSections(configInspection.config)
@@ -2962,7 +1876,7 @@ async function showReady(name) {
 }
 
 // src/commands/show.ts
-import { readFile as readFile7 } from "fs/promises";
+import { readFile as readFile6 } from "fs/promises";
 function showError(error, runtime = []) {
   const nextActions = error.code === "no_focused_change" ? ["Run: rsp status", "Run: rsp focus <name>", "Or run: rsp create <name>"] : [];
   return { command: "show", ok: false, change: null, contextPaths: [], runtime, nextActions, error };
@@ -3006,14 +1920,15 @@ async function showChange(nameOrFocused, options = {}) {
   const srcPath = workRef.path;
   let content;
   try {
-    content = await readFile7(srcPath, "utf-8");
+    content = await readFile6(srcPath, "utf-8");
   } catch {
     return showError({ code: "change_read_failed", message: `unable to read .rsp/changes/${name}.md` }, runtime);
   }
   let kind = "\u2014";
+  const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
   let issues = [];
   try {
-    const fm = parseFrontmatter(content);
+    const fm = parseFrontmatter(document.markdown);
     kind = fm?.kind ? String(fm.kind) : "\u2014";
     issues = parseIssueRelationships(fm);
   } catch (error) {
@@ -3034,7 +1949,7 @@ async function showChange(nameOrFocused, options = {}) {
     const markerPath = focusMarkers.get(name);
     let markerContent;
     try {
-      markerContent = await readFile7(markerPath);
+      markerContent = await readFile6(markerPath);
     } catch (error) {
       reportRuntime({
         code: "focus_marker_read_failed",
@@ -3060,11 +1975,10 @@ async function showChange(nameOrFocused, options = {}) {
       recovery = capsule.recovery;
   }
   const dependencyInspection = await inspectChangeDependencies();
-  const blockers = dependencyInspection.activeBlockers.get(name) ?? hasMeaningfulBlockers(content);
-  const scenarios = parseScenarios(content);
-  const readinessDetails = collectArchiveReadiness(content, { activeBlockers: blockers });
-  const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
-  const taskCheckboxes = countCheckboxes(getDocumentSectionBody(document, "tasks"));
+  const blockers = dependencyInspection.activeBlockers.get(name) ?? hasMeaningfulBlockers(document);
+  const scenarios = parseScenarios(document.markdown);
+  const readinessDetails = collectArchiveReadiness(document, { activeBlockers: blockers });
+  const taskCheckboxes = countCheckboxes(getDocumentSectionMarkdown(document, "tasks"));
   const progress = {
     done: taskCheckboxes.done + readinessDetails.verifyCriticality.required.done,
     total: taskCheckboxes.total + readinessDetails.verifyCriticality.required.total
@@ -3221,13 +2135,13 @@ function publicQuery(query) {
 }
 
 // src/status/derive.ts
-function deriveStatusView(snapshot2, options = {}) {
+function deriveStatusView(snapshot, options = {}) {
   const query = {
     focused: Boolean(options.focused),
     blocked: Boolean(options.blocked),
     stale: typeof options.stale === "number" ? options.stale : null
   };
-  const records = snapshot2.records.filter(({ output: record }) => {
+  const records = snapshot.records.filter(({ output: record }) => {
     if (query.focused && !record.isFocused)
       return false;
     if (query.blocked && !record.isBlocked)
@@ -3237,26 +2151,26 @@ function deriveStatusView(snapshot2, options = {}) {
     return true;
   });
   const filtered = query.focused || query.blocked || query.stale !== null;
-  const ok = snapshot2.diagnostics.every((diagnostic) => diagnostic.severity !== "error");
-  const nextActions = ok ? buildStatusNextActions(snapshot2.focused.length, snapshot2.records.map((record) => record.output), snapshot2.groups, filtered) : ["Run: rsp doctor"];
+  const ok = snapshot.diagnostics.every((diagnostic) => diagnostic.severity !== "error");
+  const nextActions = ok ? buildStatusNextActions(snapshot.focused.length, snapshot.records.map((record) => record.output), snapshot.groups, filtered) : ["Run: rsp doctor"];
   return {
-    manage: snapshot2.manage,
-    language: snapshot2.language,
+    workflow: snapshot.workflow,
+    language: snapshot.language,
     query,
-    focused: snapshot2.focused,
+    focused: snapshot.focused,
     records,
-    groups: snapshot2.groups,
-    plan: filterDependencyPlan(snapshot2.plan, new Set(records.map((record) => record.output.name))),
+    groups: snapshot.groups,
+    plan: filterDependencyPlan(snapshot.plan, new Set(records.map((record) => record.output.name))),
     summary: {
       total: records.length,
       focused: records.filter((record) => record.output.isFocused).length,
       blocked: records.filter((record) => record.output.isBlocked).length
     },
     nextActions,
-    archiveTrend: snapshot2.archiveTrend,
-    diagnostics: snapshot2.diagnostics,
-    runtime: snapshot2.runtime,
-    hasExecutableChanges: snapshot2.records.length > 0,
+    archiveTrend: snapshot.archiveTrend,
+    diagnostics: snapshot.diagnostics,
+    runtime: snapshot.runtime,
+    hasExecutableChanges: snapshot.records.length > 0,
     ok
   };
 }
@@ -3304,13 +2218,13 @@ function recommendOpenChange(records, groups) {
 }
 function filterDependencyPlan(plan, names) {
   const included = new Set(names);
-  let changed3 = true;
-  while (changed3) {
-    changed3 = false;
+  let changed = true;
+  while (changed) {
+    changed = false;
     for (const edge of plan.edges) {
       if (included.has(edge.change) && !included.has(edge.requires)) {
         included.add(edge.requires);
-        changed3 = true;
+        changed = true;
       }
     }
   }
@@ -3326,46 +2240,49 @@ function filterDependencyPlan(plan, names) {
 
 // src/commands/status.ts
 async function showStatus(options = {}) {
-  const snapshot2 = await inspectProjectStatus();
-  return deriveStatusView(snapshot2, options);
+  const snapshot = await inspectProjectStatus();
+  return deriveStatusView(snapshot, options);
 }
 
 // src/status/v3-json.ts
-function toStatusJson(view) {
-  return {
+function hasActiveFilters(query) {
+  return query.focused || query.blocked || query.stale !== null;
+}
+function toStatusJson(view, options = {}) {
+  const output = {
     command: "status",
     ok: view.ok,
-    manage: view.manage,
-    language: view.language,
-    filters: view.query,
     focused: view.focused,
     records: view.records.map((record) => record.output),
     groups: view.groups,
-    plan: view.plan,
+    plan: {
+      nodes: view.plan.nodes,
+      edges: view.plan.edges,
+      blocked: view.plan.blocked,
+      waves: view.plan.waves
+    },
     summary: view.summary,
-    nextActions: view.nextActions,
-    archiveTrend: view.archiveTrend,
-    diagnostics: view.diagnostics,
-    runtime: view.runtime
+    diagnostics: view.diagnostics
   };
+  if (options.verbose || hasActiveFilters(view.query)) {
+    output.filters = view.query;
+  }
+  if (options.verbose) {
+    output.nextActions = view.nextActions;
+    output.archiveTrend = view.archiveTrend;
+    output.runtime = view.runtime;
+  }
+  return output;
 }
 function toStatusJsonError(error, options) {
-  return {
+  const output = {
     command: "status",
     ok: false,
-    manage: { activation: "explicit", closeout: "manual" },
-    language: { artifacts: null, commit: null },
-    filters: {
-      focused: options.focused,
-      blocked: options.blocked,
-      stale: null
-    },
     focused: [],
     records: [],
     groups: [],
     plan: {
       nodes: [],
-      ready: [],
       edges: [],
       blocked: [],
       waves: []
@@ -3375,12 +2292,22 @@ function toStatusJsonError(error, options) {
       focused: 0,
       blocked: 0
     },
-    archiveTrend: [],
-    nextActions: [],
     diagnostics: [],
-    runtime: [],
     error
   };
+  if (options.verbose || options.focused || options.blocked) {
+    output.filters = {
+      focused: options.focused,
+      blocked: options.blocked,
+      stale: null
+    };
+  }
+  if (options.verbose) {
+    output.archiveTrend = [];
+    output.nextActions = [];
+    output.runtime = [];
+  }
+  return output;
 }
 
 // src/cli/adapter.ts
@@ -3393,9 +2320,6 @@ async function executeCliCommand(adapter, args) {
   return result;
 }
 
-// src/cli/presenters/inspection.ts
-import { existsSync as existsSync3 } from "fs";
-
 // src/status/plain.ts
 var COL_CHANGE = 32;
 var COL_KIND = 10;
@@ -3409,10 +2333,6 @@ function printStatusPlain(view, options = {}) {
   console.log();
   console.log(`  ${pc.bold("RSP status")}`);
   console.log();
-  if (options.verbose)
-    console.log(`  ${pc.bold("Manage:")} activation ${view.manage.activation} \xB7 closeout ${view.manage.closeout}`);
-  if (options.verbose && (view.language.artifacts !== null || view.language.commit !== null))
-    console.log(`  ${pc.bold("Language:")} artifacts ${view.language.artifacts ?? "unset"} \xB7 commit ${view.language.commit ?? "unset"}`);
   if (options.verbose)
     console.log();
   for (const diagnostic of view.diagnostics) {
@@ -3542,6 +2462,25 @@ function printArchiveTrend(trend) {
 }
 
 // src/cli/presenters/inspection.ts
+function presentConfig(result, options) {
+  if (options.json) {
+    emitJson(result.ok ? result.summary : result, options);
+    return;
+  }
+  if (!result.ok) {
+    console.error(`  ${pc.red("Error:")} ${result.diagnostics.map((diagnostic) => diagnostic.message).join("; ")}`);
+    return;
+  }
+  console.log();
+  console.log(`  ${pc.bold("RSP config")}`);
+  console.log(`  ${pc.dim("Path:")} ${result.path}`);
+  console.log(`  ${pc.dim("Valid:")} ${pc.green("yes")}`);
+  console.log(`  ${pc.dim("Kinds:")} ${result.summary.kinds.join(", ")}`);
+  console.log(`  ${pc.dim("Decision Records:")} ${result.summary.decisions.path}`);
+  console.log(`  ${pc.dim("Workflow:")} delegation ${result.summary.workflow.delegation} \xB7 closeout ${result.summary.workflow.closeout}`);
+  console.log(`  ${pc.dim("Language:")} artifacts ${result.summary.language.artifacts ?? "unset"} \xB7 commit ${result.summary.language.commit ?? "unset"}`);
+  console.log();
+}
 function presentStatus(result, options) {
   if (result.kind === "error") {
     if (options.json)
@@ -3553,7 +2492,7 @@ function presentStatus(result, options) {
   if (options.verbose && !options.json)
     printStatusRuntimeDiagnostics(result.view.runtime);
   if (options.json)
-    emitJson(toStatusJson(result.view), options);
+    emitJson(toStatusJson(result.view, { verbose: options.verbose }), options);
   else
     printStatusPlain(result.view, { verbose: options.verbose });
 }
@@ -3694,13 +2633,6 @@ function presentDoctor(result, options) {
   console.log();
   console.log(`  ${pc.bold("RSP doctor")}`);
   console.log();
-  if (result.fixed.length > 0) {
-    console.log(`  ${pc.green("Fixed:")} ${result.fixed.join(", ")}`);
-    console.log();
-  } else if (options.fix && result.checks.every((check) => check.message?.startsWith("safe deterministic repair could not run:") !== true) && existsSync3(RSP_DIR)) {
-    console.log(`  ${pc.dim("No safe fixes needed.")}`);
-    console.log();
-  }
   for (const check of result.checks)
     printDoctorCheck(check);
   if (result.summary.issues === 0)
@@ -3918,6 +2850,22 @@ function formatArchiveReady(value) {
 }
 
 // src/cli/commands/inspection.ts
+var configCommand = defineCommand({
+  meta: {
+    name: "config",
+    description: "Inspect effective project configuration without scanning work state"
+  },
+  args: {
+    ...compactJsonArgs
+  },
+  async run({ args }) {
+    await executeCliCommand({
+      execute: () => showConfig(),
+      present: (result) => presentConfig(result, args),
+      exitCode: (result) => result.ok ? void 0 : 1
+    }, args);
+  }
+});
 var specsCommand = defineCommand({
   meta: {
     name: "specs",
@@ -3980,7 +2928,7 @@ var statusCommand = defineCommand({
     ...compactJsonArgs,
     verbose: {
       type: "boolean",
-      description: "Print runtime diagnostics for suppressed I/O issues",
+      description: "Show auxiliary status details and runtime diagnostics",
       default: false
     }
   },
@@ -3993,7 +2941,8 @@ var statusCommand = defineCommand({
             kind: "error",
             output: toStatusJsonError({ code: "invalid_stale_filter", message: "--stale must be a non-negative integer number of days" }, {
               focused: Boolean(args.focused),
-              blocked: Boolean(args.blocked)
+              blocked: Boolean(args.blocked),
+              verbose: Boolean(args.verbose)
             })
           };
         }
@@ -4037,20 +2986,22 @@ var doctorCommand = defineCommand({
   },
   args: {
     ...compactJsonArgs,
-    verbose: {
+    "verbose": {
       type: "boolean",
       description: "Print runtime diagnostics for suppressed I/O issues",
       default: false
     },
-    fix: {
+    "check-updates": {
       type: "boolean",
-      description: "Run safe deterministic repairs before reporting diagnostics",
+      description: "Explicitly check stable registry metadata without upgrading; timeout is non-blocking",
       default: false
     }
   },
-  async run({ args }) {
+  async run({ args, rawArgs }) {
+    if (rawArgs.some((arg) => arg === "--fix" || arg.startsWith("--fix=") || arg === "--no-fix"))
+      throw new Error("doctor is read-only; use update to reconcile managed assets");
     await executeCliCommand({
-      execute: () => runDoctor({ fix: Boolean(args.fix) }),
+      execute: () => runDoctor({ checkUpdates: Boolean(args["check-updates"]) }),
       present: (result) => presentDoctor(result, args),
       exitCode: (result) => result.ok ? void 0 : 1
     }, args);
@@ -4166,24 +3117,87 @@ var historyCommand = defineCommand({
       exitCode: (result) => result.ok ? void 0 : 1
     }, args);
   }
-});
-var inspectionCommands = {
-  specs: specsCommand,
-  ready: readyCommand,
-  show: showCommand,
-  history: historyCommand,
-  status: statusCommand,
-  check: checkCommand,
-  doctor: doctorCommand
-};
-
-// src/cli/commands/setup.ts
-import { defineCommand as defineCommand2 } from "citty";
+});
+var inspectionCommands = {
+  config: configCommand,
+  specs: specsCommand,
+  ready: readyCommand,
+  show: showCommand,
+  history: historyCommand,
+  status: statusCommand,
+  check: checkCommand,
+  doctor: doctorCommand
+};
+
+// src/cli/commands/setup.ts
+import { defineCommand as defineCommand2 } from "citty";
+
+// src/commands/add-spec.ts
+import { mkdir as mkdir3, writeFile as writeFile2 } from "fs/promises";
+import { join as join4 } from "path";
+
+// src/core/lock.ts
+import { mkdir as mkdir2, readFile as readFile7, unlink, writeFile } from "fs/promises";
+async function withRspLock(operation, fn) {
+  requireManagedDirectory(RSP_DIR, "RSP root", { allowMissing: true });
+  await mkdir2(RSP_DIR, { recursive: true });
+  try {
+    await writeFile(LOCK_PATH, `${process.pid}
+${operation}
+${(/* @__PURE__ */ new Date()).toISOString()}`, { flag: "wx" });
+  } catch (err) {
+    if (err.code === "EEXIST")
+      await handleStaleLock(operation);
+    else
+      throw err;
+  }
+  try {
+    return await fn();
+  } finally {
+    try {
+      await unlink(LOCK_PATH);
+    } catch {
+    }
+  }
+}
+async function handleStaleLock(operation) {
+  try {
+    const content = await readFile7(LOCK_PATH, "utf-8");
+    const lines = content.trim().split("\n");
+    const pid = Number(lines[0]);
+    if (pid && Number.isFinite(pid)) {
+      try {
+        process.kill(pid, 0);
+        const op = lines[1] || "unknown";
+        const ts = lines[2] || "unknown";
+        throw new Error(`RSP locked by pid ${pid} (${op}) since ${ts}`);
+      } catch (e) {
+        if (e instanceof Error && e.message.startsWith("RSP locked"))
+          throw e;
+        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);
+      await writeFile(LOCK_PATH, `${process.pid}
+${operation}
+${(/* @__PURE__ */ new Date()).toISOString()}`, { flag: "wx" });
+    }
+  } catch (e) {
+    if (e instanceof Error && e.message.startsWith("RSP locked"))
+      throw e;
+    throw new Error(`RSP is locked. Remove ${LOCK_PATH} manually if no other process is running.`);
+  }
+}
 
 // src/commands/add-spec.ts
-import { existsSync as existsSync4 } from "fs";
-import { mkdir as mkdir4, writeFile as writeFile2 } from "fs/promises";
-import { join as join5 } from "path";
 async function addSpec(name, projectName = "project") {
   if (!name || !isValidSpecName(name)) {
     return { ok: false, message: "spec name must be kebab-case with optional subdirectory" };
@@ -4194,13 +3208,9 @@ async function addSpec(name, projectName = "project") {
   if (["index", "00-index"].includes(name.split("/").at(-1) || "")) {
     return { ok: false, message: 'spec name "index" is reserved for Specs migration compatibility' };
   }
-  const rules = inspectManagedFile(RSP_RULES_PATH, "fallback protocol", { allowMissing: true });
-  const design = inspectManagedFile(join5(RSP_DIR, "specs", "design.md"), "design Spec", { allowMissing: true });
-  if (rules.issue || design.issue || !rules.exists || !design.exists) {
-    const initialized = existsSync4(RSP_DIR);
-    return { ok: false, message: `${initialized ? "RSP project requires an update" : "RSP is not initialized in this project"}
-  ${initialized ? "Run: rsp update" : "Run: rsp init"}` };
-  }
+  const initialization = inspectRspInitialization();
+  if (initialization)
+    return { ok: false, message: initialization };
   try {
     const configInspection = await inspectRspConfig();
     if (configInspection.issues.length > 0) {
@@ -4210,14 +3220,14 @@ async function addSpec(name, projectName = "project") {
     return { ok: false, message: `.rsp/config.yaml could not be parsed: ${toErrorMessage(error)}` };
   }
   return withRspLock("add-spec", async () => {
-    const specsDir = join5(RSP_DIR, "specs");
+    const specsDir = join4(RSP_DIR, "specs");
     const segments = name.split("/");
     const parent = resolveManagedDirectoryChain(specsDir, segments.slice(0, -1), "spec path");
-    const path = join5(parent, `${segments.at(-1)}.md`);
+    const path = join4(parent, `${segments.at(-1)}.md`);
     const inspection = await inspectManagedFileTree(specsDir, "Specs");
     if (inspection.issues.length > 0)
       throw inspection.issues[0];
-    await mkdir4(parent, { recursive: true });
+    await mkdir3(parent, { recursive: true });
     const resolvedProjectName = projectName === "project" ? await detectProjectName() : projectName;
     const content = name === "design" ? generateDesignContent(resolvedProjectName) : generateSpecContent(name);
     try {
@@ -4232,114 +3242,245 @@ async function addSpec(name, projectName = "project") {
 }
 
 // src/commands/init.ts
-import { existsSync as existsSync5 } from "fs";
-import { mkdir as mkdir5, readFile as readFile8 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { mkdir as mkdir4, readdir as readdir3, readFile as readFile9 } from "fs/promises";
 import { join as join6 } from "path";
-async function ensureFile(path, content) {
-  return ensureManagedFile(path, content, "managed file");
-}
-function toTitle(projectName) {
-  return projectName.startsWith("@") ? projectName.split("/")[1] || projectName : projectName;
+
+// src/core/setup-files.ts
+import { constants } from "fs";
+import { access, chmod as chmod2, link, mkdtemp as mkdtemp2, readFile as readFile8, rename as rename2, rm as rm2, stat as stat2, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname2, join as join5 } from "path";
+async function updateSetupFile(path, render) {
+  const exists = requireManagedFile(path, "setup file", { allowMissing: true });
+  const current = exists ? await readFile8(path, "utf8") : null;
+  const next = render(current);
+  if (next === current)
+    return false;
+  if (exists)
+    await access(path, constants.W_OK);
+  const temporary = await mkdtemp2(join5(dirname2(path), ".rsp-write-"));
+  const prepared = join5(temporary, "next");
+  let failure2;
+  try {
+    await writeFile3(prepared, next, { flag: "wx" });
+    if (exists)
+      await chmod2(prepared, (await stat2(path)).mode & 511);
+    const stillExists = requireManagedFile(path, "setup file", { allowMissing: true });
+    if (stillExists !== exists || stillExists && await readFile8(path, "utf8") !== current)
+      throw new Error(`Setup file changed during update: ${path}`);
+    if (exists)
+      await rename2(prepared, path);
+    else
+      await link(prepared, path);
+  } catch (error) {
+    failure2 = error instanceof Error ? error : new Error(String(error));
+  }
+  try {
+    await rm2(temporary, { recursive: true });
+  } catch (error) {
+    failure2 = new Error(`Temporary content cleanup failed: ${temporary}`, { cause: failure2 ?? error });
+  }
+  if (failure2)
+    throw failure2;
+  return true;
 }
+
+// src/commands/init.ts
 async function initProject(args = {}) {
-  const isNew = !existsSync5(RSP_DIR);
+  const isNew = !existsSync2(RSP_DIR);
   const projectName = await detectProjectName();
   const mode = args.agentsMode ?? "managed";
-  if (mode !== "managed" && mode !== "print") {
-    return { ok: false, message: `unsupported --agents-mode "${mode}". Use: managed or print` };
-  }
-  const agentsPath = "AGENTS.md";
-  const initialAgentsInspection = inspectManagedFile(agentsPath, "AGENTS.md", { allowMissing: true });
-  if (initialAgentsInspection.issue)
-    throw initialAgentsInspection.issue;
+  if (mode !== "managed" && mode !== "print")
+    return { ok: false, message: "unsupported --agents-mode; use managed or print" };
   return withRspLock("init", async () => {
-    const agentsInspection = inspectManagedFile(agentsPath, "AGENTS.md", { allowMissing: true });
-    if (agentsInspection.issue)
-      throw agentsInspection.issue;
-    if (existsSync5(CONFIG_PATH)) {
-      clearConfigCache();
-      const existingConfig = await inspectRspConfig();
-      if (existingConfig.issues.length > 0)
-        throw new Error(existingConfig.issues.join("; "));
-      const existingDecisionRecordsPath = resolveDecisionRecordsPath(existingConfig.config);
-      const filesystemIssue = await validateDecisionRecordsFilesystemPath(existingDecisionRecordsPath);
-      if (filesystemIssue)
-        throw new Error(filesystemIssue);
+    const runtime = await selectProjectRuntime();
+    const { version } = runtime;
+    const retiredRules = [RSP_RULES_PATH, OBSOLETE_RSP_RULES_PATH].map((path) => requireManagedFile(path, "retired Rules", { allowMissing: true })).some(Boolean);
+    if (retiredRules)
+      return { ok: false, message: "Retired RSP assets require migration; use the selected target CLI: rsp update" };
+    requireManagedFile("AGENTS.md", "AGENTS.md", { allowMissing: true });
+    clearConfigCache();
+    const inspection = await inspectRspConfig();
+    if (inspection.issues.length)
+      throw new Error(inspection.issues.join("; "));
+    const decisionRecordsPath = resolveDecisionRecordsPath(inspection.config);
+    const pathIssue = await validateDecisionRecordsFilesystemPath(decisionRecordsPath);
+    if (pathIssue)
+      throw new Error(pathIssue);
+    const dirs = [join6(RSP_DIR, "specs"), CHANGES_DIR, FOCUS_DIR, join6(RSP_DIR, "archives"), decisionRecordsPath];
+    for (const path of dirs)
+      resolveManagedDirectoryChain(process.cwd(), path.split("/"), "project directory");
+    const completed = [];
+    async function ensureFile(path, content) {
+      if (await updateSetupFile(path, (current) => current ?? content))
+        completed.push(`created ${path}`);
     }
-    const dirs = [
-      { path: join6(RSP_DIR, "specs"), label: "specs root" },
-      { path: CHANGES_DIR, label: "open work root" },
-      { path: FOCUS_DIR, label: "focus root" },
-      { path: join6(RSP_DIR, "archives"), label: "archive root" }
-    ];
-    for (const directory of dirs)
-      requireManagedDirectory(directory.path, directory.label, { allowMissing: true });
-    for (const directory of dirs)
-      await mkdir5(directory.path, { recursive: true });
-    let created = false;
-    const bundledRules = await readFile8(join6(PKG_ROOT, "rules", "rsp-rules.md"), "utf-8");
-    created = await ensureFile(RSP_RULES_PATH, bundledRules) || created;
-    if (existsSync5(CONFIG_PATH)) {
-      const existing = await readFile8(CONFIG_PATH, "utf-8");
-      const reconciled = reconcileRspConfigDefaults(existing);
-      if (reconciled.changed) {
-        await writeManagedFile(CONFIG_PATH, reconciled.content, "config file");
-        created = true;
+    try {
+      const skills = await updatePackagedSkills();
+      completed.push(...skills.installed.map((name) => `installed ${name}`), ...skills.replaced.map((name) => `updated ${name}`), ...skills.removed.map((name) => `removed ${name}`));
+      for (const path of dirs) {
+        if (!requireManagedDirectory(path, "project directory", { allowMissing: true })) {
+          await mkdir4(path, { recursive: true });
+          requireManagedDirectory(path, "project directory");
+          completed.push(`created ${path}`);
+        }
       }
-    } else {
-      created = await ensureFile(join6(RSP_DIR, "config.yaml"), generateConfigTemplate()) || created;
+      await ensureFile(CONFIG_PATH, generateConfigTemplate());
+      clearConfigCache();
+      await ensureFile(join6(RSP_DIR, "specs/design.md"), generateDesignContent(projectName));
+      if ((await readdir3(decisionRecordsPath)).length === 0)
+        await ensureFile(join6(decisionRecordsPath, ".gitkeep"), "");
+      await ensureFile(join6(CHANGES_DIR, ".gitkeep"), "");
+      await ensureFile(join6(FOCUS_DIR, ".gitkeep"), "");
+      await ensureFile(join6(RSP_DIR, ".gitignore"), "# Transient files that should not be committed\n.lock\n");
+      if (args.withProjectSetup) {
+        const work = resolveWorkRef("project-setup", { executable: true });
+        await ensureFile(work.path, generateChangeContent("project-setup"));
+        await ensureFile(resolveFocusMarkerPath(work), "");
+      }
+      const title = projectName.startsWith("@") ? projectName.split("/")[1] || projectName : projectName;
+      const agentsUpdated = await updateSetupFile("AGENTS.md", (current) => upsertRspAgentsBlock(current ?? `# ${title}
+
+`, runtime).content);
+      if (agentsUpdated)
+        completed.push("updated AGENTS.md managed block");
+      if (runtime.mode === "package" && await updateSetupFile(PROJECT_VERSION_PATH, () => `${version}
+`))
+        completed.push(`pinned ${version}`);
+      return { ok: true, isNew, created: completed.length > 0, decisionRecordsPath, withProjectSetup: Boolean(args.withProjectSetup), agentsUpdated, skills, managedAgents: mode === "print" ? await readFile9("AGENTS.md", "utf8") : void 0 };
+    } catch (error) {
+      throw new Error(`Init stopped; completed: ${completed.join(", ") || "none"}. No rollback was attempted. Fix the cause and rerun init with the same target CLI. ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
+  });
+}
+
+// src/commands/update.ts
+import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile12, unlink as unlink3 } from "fs/promises";
+import { join as join8 } from "path";
+
+// src/commands/archive-index-migration.ts
+import { readFile as readFile10 } from "fs/promises";
+import { join as join7 } from "path";
+async function isLegacyArchiveIndex() {
+  const path = join7(ARCHIVES_DIR, "INDEX.md");
+  if (!requireManagedFile(path, "legacy archive index", { allowMissing: true }))
+    return false;
+  return isLegacyArchiveIndexContent(await readFile10(path, "utf-8"));
+}
+function isLegacyArchiveIndexContent(content) {
+  try {
+    const frontmatter = parseFrontmatter(content);
+    return frontmatter?.kind === "generated-index" && frontmatter.index_type === "archives";
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/specs-index-migration.ts
+import { readFile as readFile11, unlink as unlink2 } from "fs/promises";
+import { dirname as dirname3, resolve } from "path";
+async function inspectGeneratedSpecsIndexMigration(cwd = process.cwd()) {
+  const inspection = await inspectSpecs({ cwd, allowMissingDecisionRecords: true });
+  return {
+    inspectionComplete: specsInspectionComplete(inspection),
+    removable: inspection.generatedIndexes.filter((index) => index.classification === "safe-removal").map((index) => index.path).sort(),
+    ownerControlled: inspection.generatedIndexes.filter((index) => index.classification === "owner-controlled").map((index) => index.path).sort(),
+    diagnostics: inspection.diagnostics.map((diagnostic) => `${diagnostic.path}: ${diagnostic.message}`)
+  };
+}
+async function removeGeneratedSpecsIndex(path) {
+  resolveManagedDirectoryChain(process.cwd(), dirname3(path).split("/"), "Specs parent");
+  if (!requireManagedFile(path, "generated Specs index", { allowMissing: true }))
+    return false;
+  if (!isRecognizedGeneratedSpecsIndex(await readFile11(resolve(path), "utf8"), path))
+    throw new Error(`Specs index is no longer generated; left untouched: ${path}`);
+  await unlink2(path);
+  return true;
+}
+
+// src/commands/update.ts
+async function updateProject(options = {}) {
+  if (!existsSync3(RSP_DIR))
+    return { ok: false, actions: [], updated: false, events: [{ type: "not-initialized" }], migration: { inspectionComplete: false, manualMigrationRequired: false, residualEntries: [], diagnostics: [] } };
+  const execute = async () => {
+    const runtime = await selectProjectRuntime("update");
+    const { version } = runtime;
     clearConfigCache();
-    const configInspection = await inspectRspConfig();
-    if (configInspection.issues.length > 0)
-      throw new Error(configInspection.issues.join("; "));
-    const decisionRecordsPath = resolveDecisionRecordsPath(configInspection.config);
-    created = await ensureDecisionRecordsDirectory(decisionRecordsPath) || created;
-    const createdDesign = await ensureFile(join6(RSP_DIR, "specs", "design.md"), generateDesignContent(projectName));
-    created = createdDesign || created;
-    created = await removeLegacyArchiveIndex() || created;
-    created = await ensureFile(join6(CHANGES_DIR, ".gitkeep"), "") || created;
-    created = await ensureFile(join6(FOCUS_DIR, ".gitkeep"), "") || created;
-    created = await ensureFile(join6(RSP_DIR, ".gitignore"), "# Transient files that should not be committed\n.lock\n") || created;
-    if (args.withProjectSetup) {
-      const projectSetupRef = resolveWorkRef("project-setup", { executable: true });
-      const changePath = projectSetupRef.path;
-      const focusMarker = resolveFocusMarkerPath(projectSetupRef);
-      created = await ensureFile(changePath, generateChangeContent("project-setup")) || created;
-      created = await ensureFile(focusMarker, "") || created;
-    }
-    const title = toTitle(projectName);
-    let agentsUpdated = false;
-    if (!agentsInspection.exists) {
-      await writeManagedFile(agentsPath, `# ${title}
+    const config = await inspectRspConfig();
+    if (config.issues.length)
+      throw new Error(config.issues.join("; "));
+    resolveManagedDirectoryChain(process.cwd(), [RSP_DIR, "rules"], "retired Rules parent");
+    const retired = [RSP_RULES_PATH, OBSOLETE_RSP_RULES_PATH].filter((path) => requireManagedFile(path, "retired Rules", { allowMissing: true }));
+    const rules = await inspectUnsupportedRules();
+    const migration = { inspectionComplete: rules.diagnostics.length === 0, manualMigrationRequired: rules.entries.length > 0, residualEntries: rules.entries.map((entry) => entry.path), diagnostics: rules.diagnostics };
+    if (!migration.inspectionComplete)
+      return { ok: false, actions: [], updated: false, events: [{ type: "migration-diagnostics", diagnostics: rules.diagnostics }], migration };
+    requireManagedFile("AGENTS.md", "AGENTS.md", { allowMissing: true });
+    resolveManagedDirectoryChain(process.cwd(), [RSP_DIR, "archives"], "archive parent");
+    requireManagedFile(join8(RSP_DIR, "archives/INDEX.md"), "archive index", { allowMissing: true });
+    const plan = await inspectGeneratedSpecsIndexMigration();
+    if (!plan.inspectionComplete || plan.ownerControlled.length)
+      throw new Error(`Generated Specs-index migration requires owner review before update: ${[...plan.ownerControlled, ...plan.diagnostics].join("; ")}`);
+    const projectName = await detectProjectName();
+    const agents = requireManagedFile("AGENTS.md", "AGENTS.md", { allowMissing: true }) ? await readFile12("AGENTS.md", "utf8") : null;
+    const refreshAgents = (current) => upsertRspAgentsBlock(current ?? `# ${projectName}
 
-${upsertRspAgentsBlock("").content}
-`, "AGENTS.md");
-      created = true;
-      agentsUpdated = true;
-    } else {
-      const existing = await readFile8(agentsPath, "utf-8");
-      const next = upsertRspAgentsBlock(existing);
-      if (next.changed) {
-        await writeManagedFile(agentsPath, next.content, "AGENTS.md");
-        created = true;
-        agentsUpdated = true;
+`, runtime).content;
+    const removeArchive = await isLegacyArchiveIndex();
+    const actions = [];
+    const events = [];
+    if (existsSync3("CONTEXT-MAP.md"))
+      events.push({ type: "legacy-context-map" });
+    if (migration.residualEntries.length)
+      events.push({ type: "residual-rules", entries: migration.residualEntries });
+    const record = (message) => {
+      actions.push(message);
+      events.push({ type: "updated", message });
+    };
+    try {
+      const skills = await updatePackagedSkills({ dryRun: options.dryRun });
+      for (const name of skills.installed) record(`Skill installed: ${name}`);
+      for (const name of skills.replaced) record(`Skill updated: ${name}`);
+      for (const name of skills.removed) record(`retired Skill removed: ${name}`);
+      if (options.dryRun) {
+        actions.push(...retired.map((path) => `retired Rules file removed: ${path}`), ...plan.removable.map((path) => `generated Specs index removed: ${path}`));
+        if (removeArchive)
+          actions.push("legacy Archive Index removed");
+        if (refreshAgents(agents) !== agents)
+          actions.push("AGENTS.md managed block refreshed");
+        if (runtime.mode === "package" && await readProjectVersion() !== version)
+          actions.push(`project CLI pinned to ${version}`);
+        return { ok: true, actions, updated: false, skills, events: [], migration };
+      }
+      for (const path of retired) {
+        if (requireManagedFile(path, "retired Rules", { allowMissing: true })) {
+          await unlink3(path);
+          record(`retired Rules file removed: ${path}`);
+        }
+      }
+      for (const path of plan.removable) {
+        if (await removeGeneratedSpecsIndex(path))
+          record(`generated Specs index removed: ${path}`);
       }
+      if (await isLegacyArchiveIndex()) {
+        await unlink3(join8(RSP_DIR, "archives/INDEX.md"));
+        record("legacy Archive Index removed");
+      }
+      if (await updateSetupFile("AGENTS.md", refreshAgents))
+        record("AGENTS.md managed block refreshed");
+      if (runtime.mode === "package" && await updateSetupFile(PROJECT_VERSION_PATH, () => `${version}
+`))
+        record(`project CLI pinned to ${version}`);
+      return { ok: true, actions, updated: actions.length > 0, skills, events, migration };
+    } catch (error) {
+      throw new Error(`Update stopped; completed: ${actions.join(", ") || "none"}. No rollback was attempted. Fix the cause and rerun update with the same target CLI. ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
-    return {
-      ok: true,
-      isNew,
-      created,
-      decisionRecordsPath,
-      withProjectSetup: Boolean(args.withProjectSetup),
-      agentsUpdated,
-      managedAgents: mode === "print" ? await readFile8(agentsPath, "utf-8") : void 0
-    };
-  });
+  };
+  return options.dryRun ? execute() : withRspLock("update", execute);
 }
 
 // src/cli/presenters/setup.ts
-var SKILL_REFRESH_HINT = "  Note: if you use package-bundled RSP Skills, refresh them too:\n    rsp skills install --dry-run\n    rsp skills install --force\n";
 function presentAddSpec(result) {
   if (!result.ok) {
     console.error(`  ${pc.red("Error:")} ${result.message}`);
@@ -4360,11 +3501,12 @@ ${result.managedAgents}
   if (result.isNew) {
     const createdProjectSetup = result.withProjectSetup ? "\n           .rsp/changes/project-setup.md\n           .rsp/focus.d/project-setup" : "";
     const createdAgents = result.agentsUpdated ? "\n           AGENTS.md" : "";
-    const next = result.withProjectSetup ? "fill .rsp/changes/project-setup.md" : "rsp create project-setup";
+    const next = result.withProjectSetup ? "fill .rsp/changes/project-setup.md" : "rsp status";
     console.log(`
   ${pc.green("RSP scaffolded.")}
 `);
-    console.log(`  Created: .rsp/rsp-rules.md
+    console.log(`  Created: complete core Skill suite
+           .rsp/version
            .rsp/specs/
            ${result.decisionRecordsPath}/
            .rsp/changes/
@@ -4388,7 +3530,13 @@ ${result.managedAgents}
 `);
   }
 }
-function presentUpdate(result) {
+function presentUpdate(result, dryRun = false) {
+  if (dryRun && result.ok) {
+    console.log("  Update preview (no files changed):");
+    for (const action of result.actions)
+      console.log(`    ${action}`);
+    return;
+  }
   if (!result.ok && result.events.some((event) => event.type === "not-initialized")) {
     console.error(`  ${pc.red("Error:")} RSP is not initialized in this project`);
     console.error(`  ${pc.dim("Run: rsp init")}`);
@@ -4410,10 +3558,9 @@ function presentUpdate(result) {
       console.log(`  ${pc.dim("Move stable scoped instructions to the nearest project-owned AGENTS.md, then remove the old files.")}`);
       console.log(`  ${pc.dim("Run: rsp doctor")}`);
       console.log();
-    } else if (event.type === "specs-indexes-removed") {
-      console.log(`  ${pc.green("\u2713")} generated Specs indexes removed`);
-      for (const path of event.paths)
-        console.log(`    ${path}`);
+    } else if (event.type === "legacy-context-map") {
+      console.log(`  ${pc.yellow("Note:")} CONTEXT-MAP.md remains; context migration needs owner review.`);
+      console.log(`  ${pc.dim("Use Core context migration. Keep relevant legacy context until an authorized merge updates CONTEXT.md and active references; update does not migrate or delete it.")}`);
     }
   }
   if (!result.migration.inspectionComplete)
@@ -4428,7 +3575,6 @@ function presentUpdate(result) {
   else
     console.log(`  ${pc.green("Update complete.")}
 `);
-  console.log(SKILL_REFRESH_HINT);
 }
 
 // src/cli/commands/setup.ts
@@ -4492,14 +3638,19 @@ var addCommand = defineCommand2({
 var updateCommand = defineCommand2({
   meta: {
     name: "update",
-    description: "Refresh RSP-managed project files after upgrade; does not update packaged Skills"
+    description: "Update the complete pinned environment and remove retired managed assets"
+  },
+  args: {
+    "dry-run": { type: "boolean", description: "Preview the complete update without changing files", default: false }
   },
-  async run() {
+  async run({ args, rawArgs }) {
+    if (args._.length || rawArgs.some((arg) => !["--dry-run", "--dry-run=true", "--dry-run=false", "--no-dry-run"].includes(arg)))
+      throw new Error("rsp update accepts only --dry-run; use the selected target CLI to update all managed assets");
     await executeCliCommand({
-      execute: () => updateProject(),
-      present: presentUpdate,
+      execute: () => updateProject({ dryRun: Boolean(args["dry-run"]) }),
+      present: (result) => presentUpdate(result, Boolean(args["dry-run"])),
       exitCode: (result) => result.migration.inspectionComplete ? void 0 : 1
-    }, {});
+    }, args);
   }
 });
 var setupCommands = {
@@ -4510,49 +3661,26 @@ var setupCommands = {
 
 // src/cli/commands/skills.ts
 import { defineCommand as defineCommand3 } from "citty";
-var skillsInstallCommand = defineCommand3({
-  meta: {
-    name: "install",
-    description: "Install this package's bundled Skills into .agents/skills"
-  },
-  args: {
-    "name": {
-      type: "positional",
-      description: "Exact packaged Skill name (default: lifecycle suite)",
-      required: false
-    },
-    "dry-run": {
-      type: "boolean",
-      description: "Preflight selected packaged Skills without changing files",
-      default: false
-    },
-    "force": {
-      type: "boolean",
-      description: "Replace divergent package-owned Skill directories",
-      default: false
-    }
-  },
-  async run({ args }) {
-    if (args._.length > 1)
-      throw new Error("rsp skills install accepts at most one Skill name");
-    await executeCliCommand({
-      execute: () => installPackagedSkills({
-        dryRun: Boolean(args["dry-run"]),
-        force: Boolean(args.force),
-        names: args.name ? [args.name] : void 0
-      }),
-      present: (result) => presentSkillInstallResult(result, Boolean(args["dry-run"]))
-    }, args);
+
+// src/cli/presenters/skills.ts
+function presentPackagedSkillInventory(inventory, json = false) {
+  if (json) {
+    emitJson(inventory);
+    return;
   }
-});
+  console.log(`  ${inventory.package.name}@${inventory.package.version}`);
+  console.log(`  target: ${inventory.target}`);
+  console.log("  Core suite (managed by init/update)");
+  for (const skill of inventory.skills)
+    console.log(`    ${skill.name}  ${skill.status}`);
+  for (const name of inventory.retired)
+    console.log(`    ${name}  retired`);
+}
+
+// src/cli/commands/skills.ts
 var skillsListCommand = defineCommand3({
-  meta: {
-    name: "list",
-    description: "List package-bundled Skills and their project status"
-  },
-  args: {
-    ...jsonArgs
-  },
+  meta: { name: "list", description: "Inspect the complete package-owned Skill inventory" },
+  args: { ...jsonArgs },
   async run({ args }) {
     await executeCliCommand({
       execute: () => inspectPackagedSkillInventory(),
@@ -4560,32 +3688,25 @@ var skillsListCommand = defineCommand3({
     }, args);
   }
 });
-var skillsCommand = defineCommand3({
-  meta: {
-    name: "skills",
-    description: "Manage package-bundled project Skills"
-  },
-  subCommands: {
-    install: skillsInstallCommand,
-    list: skillsListCommand
-  }
-});
 var skillsCommands = {
-  skills: skillsCommand
+  skills: defineCommand3({
+    meta: { name: "skills", description: "Inspect Skills; use init or update to manage the complete environment" },
+    subCommands: { list: skillsListCommand }
+  })
 };
 
 // src/cli/commands/work.ts
 import { defineCommand as defineCommand4 } from "citty";
 
 // src/commands/archive.ts
-import { existsSync as existsSync6, readdirSync } from "fs";
-import { mkdir as mkdir6, readFile as readFile9, rename as rename3, unlink as unlink5 } from "fs/promises";
-import { basename as basename2, join as join7 } from "path";
+import { existsSync as existsSync4, readdirSync } from "fs";
+import { mkdir as mkdir5, readFile as readFile13, rename as rename3, unlink as unlink4 } from "fs/promises";
+import { basename as basename2, join as join9 } from "path";
 async function archiveChange(name) {
   if (!name) {
     return { ok: false, kind: "usage", message: "rsp archive <name>" };
   }
-  const initialization = inspectInitialization();
+  const initialization = inspectRspInitialization();
   if (initialization)
     return { ok: false, kind: "error", message: initialization };
   try {
@@ -4597,7 +3718,7 @@ async function archiveChange(name) {
       const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
       const base = basename2(workRef.name);
       const archiveName = resolveArchiveName(archiveSubdir, date, base);
-      const content = await readFile9(srcPath, "utf-8");
+      const content = await readFile13(srcPath, "utf-8");
       const configInspection = await inspectRspConfig();
       if (configInspection.issues.length > 0) {
         return {
@@ -4607,9 +3728,10 @@ async function archiveChange(name) {
         };
       }
       const dependencyInspection = await inspectChangeDependencies();
-      const readiness = collectArchiveReadiness(content, {
+      const document = parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA);
+      const readiness = collectArchiveReadiness(document, {
         activeBlockers: dependencyInspection.activeBlockers.get(workRef.name),
-        documentDiagnostics: inspectChangeDocument(content, {
+        documentDiagnostics: inspectChangeDocument(document, {
           name: workRef.name,
           validKinds: resolveKinds(configInspection.config),
           requiredSections: resolveRequiredSections(configInspection.config)
@@ -4624,13 +3746,13 @@ async function archiveChange(name) {
           warnings: checklist
         };
       }
-      await mkdir6(archiveSubdir, { recursive: true });
-      await rename3(srcPath, join7(archiveSubdir, archiveName));
+      await mkdir5(archiveSubdir, { recursive: true });
+      await rename3(srcPath, join9(archiveSubdir, archiveName));
       const postArchiveWarnings = [];
       let focusCleared = false;
-      if (existsSync6(focusEntry)) {
+      if (existsSync4(focusEntry)) {
         try {
-          await unlink5(focusEntry);
+          await unlink4(focusEntry);
           await cleanupEmptyParentDirs(focusEntry, FOCUS_DIR);
           focusCleared = true;
         } catch (error) {
@@ -4642,7 +3764,7 @@ async function archiveChange(name) {
       } catch (error) {
         postArchiveWarnings.push(`changes directory cleanup failed: ${toErrorMessage(error)}`);
       }
-      return { ok: true, archiveName, focusCleared, readinessWarnings: checklist, cleanupWarnings: postArchiveWarnings, git: existsSync6(".git") };
+      return { ok: true, archiveName, focusCleared, readinessWarnings: checklist, cleanupWarnings: postArchiveWarnings, git: existsSync4(".git") };
     });
   } catch (error) {
     if (error instanceof WorkRefError) {
@@ -4651,15 +3773,6 @@ async function archiveChange(name) {
     throw error;
   }
 }
-function inspectInitialization() {
-  const rules = inspectManagedFile(RSP_RULES_PATH, "fallback protocol", { allowMissing: true });
-  const design = inspectManagedFile(join7(RSP_DIR, "specs", "design.md"), "design Spec", { allowMissing: true });
-  if (!rules.issue && !design.issue && rules.exists && design.exists)
-    return void 0;
-  const initialized = existsSync6(RSP_DIR);
-  return `${initialized ? "RSP project requires an update" : "RSP is not initialized in this project"}
-  ${initialized ? "Run: rsp update" : "Run: rsp init"}`;
-}
 function resolveArchiveName(archiveSubdir, date, base) {
   const initialName = `${date}_${base}.md`;
   if (!archiveNameExists(archiveSubdir, initialName))
@@ -4677,7 +3790,7 @@ function resolveArchiveName(archiveSubdir, date, base) {
   );
 }
 function archiveNameExists(archiveSubdir, name) {
-  if (!existsSync6(archiveSubdir))
+  if (!existsSync4(archiveSubdir))
     return false;
   return readdirSync(archiveSubdir).some((entry) => {
     if (entry.normalize("NFC") !== name)
@@ -4693,252 +3806,10 @@ function archiveNameExists(archiveSubdir, name) {
   });
 }
 
-// src/commands/commit.ts
-import { execFile, spawn } from "child_process";
-import { lstat as lstat4, readFile as readFile10 } from "fs/promises";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
-function messagesMatch(prepared, observed) {
-  if (prepared === observed)
-    return true;
-  if (prepared.endsWith("\n") && prepared.slice(0, -1) === observed)
-    return true;
-  return observed.endsWith("\n") && observed.slice(0, -1) === prepared;
-}
-function extractCommittedMessage(output) {
-  const separator = output.indexOf("\0");
-  return separator === -1 ? output : output.slice(0, separator);
-}
-async function readStagedPaths() {
-  const { stdout } = await execFileAsync("git", ["diff", "--cached", "--name-only", "--no-renames", "--diff-filter=ACDMRTUXB"], {
-    encoding: "utf8"
-  });
-  return stdout.split("\n").filter(Boolean);
-}
-async function readHead() {
-  try {
-    const { stdout } = await execFileAsync("git", ["rev-parse", "--verify", "HEAD"], { encoding: "utf8" });
-    return stdout.trim();
-  } catch {
-    return null;
-  }
-}
-async function readPathLines(args) {
-  const { stdout } = await execFileAsync("git", args, { encoding: "utf8" });
-  return stdout.split("\n").filter(Boolean);
-}
-async function readCommittedPaths(commit) {
-  return readPathLines(["diff-tree", "--root", "--no-commit-id", "--name-only", "--no-renames", "-r", commit]);
-}
-async function readRemainingWorktreePaths() {
-  const [unstaged, staged, untracked] = await Promise.all([
-    readPathLines(["diff", "--name-only", "--no-renames", "--diff-filter=ACDMRTUXB"]),
-    readPathLines(["diff", "--cached", "--name-only", "--no-renames", "--diff-filter=ACDMRTUXB"]),
-    readPathLines(["ls-files", "--others", "--exclude-standard"])
-  ]);
-  return [.../* @__PURE__ */ new Set([...unstaged, ...staged, ...untracked])].sort();
-}
-async function gitPathExists(path) {
-  const { stdout } = await execFileAsync("git", ["rev-parse", "--git-path", path], { encoding: "utf8" });
-  try {
-    await lstat4(stdout.trim());
-    return true;
-  } catch (error) {
-    if (error.code === "ENOENT")
-      return false;
-    throw error;
-  }
-}
-async function detectGitOperation() {
-  const operations = [
-    ["merge", "MERGE_HEAD"],
-    ["cherry-pick", "CHERRY_PICK_HEAD"],
-    ["revert", "REVERT_HEAD"],
-    ["rebase", "rebase-merge"],
-    ["rebase-or-am", "rebase-apply"],
-    ["sequencer", "sequencer"]
-  ];
-  for (const [operation, path] of operations) {
-    if (await gitPathExists(path))
-      return operation;
-  }
-  return null;
-}
-function samePaths(expected, observed) {
-  const left = [...expected].sort();
-  const right = [...observed].sort();
-  return left.length === right.length && left.every((path, index) => path === right[index]);
-}
-async function runGitCommit(message) {
-  return await new Promise((resolve5) => {
-    const child = spawn("git", ["commit", "--cleanup=verbatim", "-F", "-"], {
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    let settled = false;
-    child.stdout.setEncoding("utf8");
-    child.stderr.setEncoding("utf8");
-    child.stdout.on("data", (chunk) => stdout += chunk);
-    child.stderr.on("data", (chunk) => stderr += chunk);
-    child.on("error", (error) => {
-      if (!settled) {
-        settled = true;
-        resolve5({ ok: false, message: toErrorMessage(error) });
-      }
-    });
-    child.on("close", (code) => {
-      if (settled)
-        return;
-      settled = true;
-      if (code === 0)
-        resolve5({ ok: true, stdout });
-      else
-        resolve5({ ok: false, message: stderr.trim() || stdout.trim() || `git commit exited with code ${code ?? "unknown"}` });
-    });
-    child.stdin.end(message);
-  });
-}
-async function commitFromMessageFile(messageFile) {
-  let preparedMessage;
-  try {
-    preparedMessage = await readFile10(messageFile, "utf8");
-  } catch (error) {
-    return {
-      ok: false,
-      command: "commit",
-      code: "message_file_read_failed",
-      message: `unable to read message file: ${toErrorMessage(error)}`
-    };
-  }
-  if (preparedMessage.includes("\\n")) {
-    return {
-      ok: false,
-      command: "commit",
-      code: "literal_newline_escape",
-      message: "message file contains literal \\\\n; use actual line breaks"
-    };
-  }
-  let operation;
-  try {
-    operation = await detectGitOperation();
-  } catch (error) {
-    return {
-      ok: false,
-      command: "commit",
-      code: "git_operation_in_progress",
-      message: `unable to verify current Git operation state: ${toErrorMessage(error)}`
-    };
-  }
-  if (operation) {
-    return {
-      ok: false,
-      command: "commit",
-      code: "git_operation_in_progress",
-      operation,
-      message: `refusing to commit while Git operation is in progress: ${operation}`
-    };
-  }
-  let stagedPaths;
-  try {
-    stagedPaths = await readStagedPaths();
-  } catch (error) {
-    return {
-      ok: false,
-      command: "commit",
-      code: "no_staged_boundary",
-      message: `unable to inspect staged boundary: ${toErrorMessage(error)}`
-    };
-  }
-  if (stagedPaths.length === 0) {
-    return {
-      ok: false,
-      command: "commit",
-      code: "no_staged_boundary",
-      message: "no staged boundary exists"
-    };
-  }
-  const headBefore = await readHead();
-  const commitResult = await runGitCommit(preparedMessage);
-  if (!commitResult.ok) {
-    return {
-      ok: false,
-      command: "commit",
-      code: "git_commit_failed",
-      message: commitResult.message
-    };
-  }
-  let headAfter;
-  let observedMessage;
-  let committedPaths;
-  let remainingWorktreePaths;
-  try {
-    const [head, observed] = await Promise.all([
-      execFileAsync("git", ["rev-parse", "HEAD"], { encoding: "utf8" }),
-      execFileAsync("git", ["show", "-s", "--format=%B%x00", "HEAD"], { encoding: "utf8" })
-    ]);
-    headAfter = head.stdout.trim();
-    observedMessage = extractCommittedMessage(observed.stdout);
-    [committedPaths, remainingWorktreePaths] = await Promise.all([
-      readCommittedPaths(headAfter),
-      readRemainingWorktreePaths()
-    ]);
-  } catch (error) {
-    return {
-      ok: false,
-      command: "commit",
-      code: "receipt_observation_failed",
-      message: `commit created but its complete receipt could not be observed: ${toErrorMessage(error)}`,
-      headBefore,
-      preparedLength: preparedMessage.length
-    };
-  }
-  if (!messagesMatch(preparedMessage, observedMessage)) {
-    return {
-      ok: false,
-      command: "commit",
-      code: "message_mismatch",
-      message: "committed message differs from the prepared message; stopped without amend or a second commit",
-      commit: headAfter,
-      headBefore,
-      headAfter,
-      storedMessage: observedMessage,
-      committedPaths,
-      remainingWorktreePaths,
-      preparedLength: preparedMessage.length,
-      observedLength: observedMessage.length
-    };
-  }
-  if (!samePaths(stagedPaths, committedPaths)) {
-    return {
-      ok: false,
-      command: "commit",
-      code: "commit_boundary_mismatch",
-      message: "committed paths differ from the reviewed staged boundary; stopped without amend or a second commit",
-      commit: headAfter,
-      headBefore,
-      headAfter,
-      storedMessage: observedMessage,
-      committedPaths,
-      remainingWorktreePaths
-    };
-  }
-  return {
-    ok: true,
-    command: "commit",
-    commit: headAfter,
-    headBefore,
-    headAfter,
-    storedMessage: observedMessage,
-    committedPaths,
-    remainingWorktreePaths
-  };
-}
-
 // src/commands/create.ts
-import { existsSync as existsSync7 } from "fs";
-import { mkdir as mkdir7, unlink as unlink6, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname3 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { mkdir as mkdir6, unlink as unlink5, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname4 } from "path";
 async function createChange(name, summary = "", kind, options = {}) {
   if (!name) {
     return { ok: false, kind: "usage", message: "rsp create <name> [summary]" };
@@ -4948,31 +3819,31 @@ async function createChange(name, summary = "", kind, options = {}) {
   if (options.issueRelation && !hasIssueOption)
     throw new Error("--issue-relation requires --issue");
   const issues = options.issue !== void 0 ? [createIssueRelationship(options.issue, options.issueRelation)] : [];
-  const initialization = inspectInitialization2();
+  const initialization = inspectRspInitialization();
   if (initialization)
     return { ok: false, kind: "error", message: initialization, warning };
   try {
     return await withRspLock("create-change", async () => {
       const workRef = await resolveExecutableChange(name);
       const changePath = workRef.path;
-      const existed = existsSync7(changePath);
+      const existed = existsSync5(changePath);
       if (existed && hasIssueOption)
         throw new Error(`Change already exists; --issue cannot update ${workRef.name}`);
       if (!existed) {
         const focusEntry = resolveFocusMarkerPath(workRef);
         const content = generateChangeContent(workRef.name, summary, kind, { issues });
-        await mkdir7(dirname3(changePath), { recursive: true });
+        await mkdir6(dirname4(changePath), { recursive: true });
         let changeCreated = false;
         try {
-          await writeFile3(changePath, content, { flag: "wx" });
+          await writeFile4(changePath, content, { flag: "wx" });
           changeCreated = true;
-          await mkdir7(FOCUS_DIR, { recursive: true });
-          await mkdir7(dirname3(focusEntry), { recursive: true });
+          await mkdir6(FOCUS_DIR, { recursive: true });
+          await mkdir6(dirname4(focusEntry), { recursive: true });
           await writeManagedFile(focusEntry, "", "focus marker");
         } catch (error) {
           if (changeCreated) {
             try {
-              await unlink6(changePath);
+              await unlink5(changePath);
               await cleanupEmptyParentDirs(changePath, CHANGES_DIR);
             } catch {
             }
@@ -4989,35 +3860,26 @@ async function createChange(name, summary = "", kind, options = {}) {
     throw error;
   }
 }
-function inspectInitialization2() {
-  const rules = inspectManagedFile(RSP_RULES_PATH, "fallback protocol", { allowMissing: true });
-  const design = inspectManagedFile(`${RSP_DIR}/specs/design.md`, "design Spec", { allowMissing: true });
-  if (!rules.issue && !design.issue && rules.exists && design.exists)
-    return void 0;
-  const initialized = existsSync7(RSP_DIR);
-  return `${initialized ? "RSP project requires an update" : "RSP is not initialized in this project"}
-  ${initialized ? "Run: rsp update" : "Run: rsp init"}`;
-}
 
 // src/commands/focus.ts
-import { Buffer as Buffer3 } from "buffer";
-import { randomUUID as randomUUID3 } from "crypto";
-import { existsSync as existsSync8 } from "fs";
-import { mkdir as mkdir8, open as open3, rename as rename4, unlink as unlink7 } from "fs/promises";
-import { basename as basename3, dirname as dirname4, join as join8 } from "path";
+import { Buffer as Buffer2 } from "buffer";
+import { randomUUID } from "crypto";
+import { existsSync as existsSync6 } from "fs";
+import { mkdir as mkdir7, open, rename as rename4, unlink as unlink6 } from "fs/promises";
+import { basename as basename3, dirname as dirname5, join as join10 } from "path";
 async function focusChange(name, options = {}) {
   if (!name) {
     return { ok: false, kind: "usage", message: "rsp focus <name>" };
   }
-  const initialization = inspectInitialization3();
+  const initialization = inspectRspInitialization();
   if (initialization)
     return { ok: false, kind: "error", message: initialization };
   try {
     return await withRspLock("focus-change", async () => {
       const workRef = await resolveExecutableChange(name, { mustExist: true });
       const focusEntry = resolveFocusMarkerPath(workRef);
-      await mkdir8(FOCUS_DIR, { recursive: true });
-      await mkdir8(dirname4(focusEntry), { recursive: true });
+      await mkdir7(FOCUS_DIR, { recursive: true });
+      await mkdir7(dirname5(focusEntry), { recursive: true });
       if (options.capsuleFile === void 0)
         await ensureManagedFile(focusEntry, "", "focus marker");
       else
@@ -5039,10 +3901,10 @@ async function readCapsule(source) {
 }
 async function replaceFocusCapsule(path, content) {
   requireManagedFile(path, "focus marker", { allowMissing: true });
-  const temporaryPath = join8(dirname4(path), `.${basename3(path)}.${randomUUID3()}.tmp`);
+  const temporaryPath = join10(dirname5(path), `.${basename3(path)}.${randomUUID()}.tmp`);
   let handle;
   try {
-    handle = await open3(temporaryPath, "wx");
+    handle = await open(temporaryPath, "wx");
     await handle.writeFile(content, "utf-8");
     await handle.close();
     handle = void 0;
@@ -5051,7 +3913,7 @@ async function replaceFocusCapsule(path, content) {
   } finally {
     await handle?.close().catch(() => {
     });
-    await unlink7(temporaryPath).catch((error) => {
+    await unlink6(temporaryPath).catch((error) => {
       if (error.code !== "ENOENT")
         throw error;
     });
@@ -5059,7 +3921,7 @@ async function replaceFocusCapsule(path, content) {
 }
 async function readRegularCapsuleFile(path) {
   requireManagedFile(path, "focus capsule input");
-  const handle = await open3(path, "r");
+  const handle = await open(path, "r");
   try {
     if (!(await handle.stat()).isFile())
       throw new Error(`focus capsule input must be a regular file: ${path}`);
@@ -5072,28 +3934,28 @@ async function readBoundedStdin() {
   const chunks = [];
   let size = 0;
   for await (const chunk of process.stdin) {
-    const buffer = Buffer3.isBuffer(chunk) ? chunk : Buffer3.from(chunk);
+    const buffer = Buffer2.isBuffer(chunk) ? chunk : Buffer2.from(chunk);
     size += buffer.byteLength;
     if (size > MAX_FOCUS_CAPSULE_BYTES)
       throw new Error(`focus capsule exceeds ${MAX_FOCUS_CAPSULE_BYTES} UTF-8 bytes`);
     chunks.push(buffer);
   }
-  return Buffer3.concat(chunks, size);
+  return Buffer2.concat(chunks, size);
 }
 async function unfocusChange(name) {
   if (!name) {
     return { ok: false, kind: "usage", message: "rsp unfocus <name>" };
   }
-  const initialization = inspectInitialization3();
+  const initialization = inspectRspInitialization();
   if (initialization)
     return { ok: false, kind: "error", message: initialization };
   try {
     return await withRspLock("unfocus-change", async () => {
       const workRef = resolveWorkRef(name, { executable: false, mustExist: false });
       const focusEntry = resolveFocusMarkerPath(workRef);
-      if (!existsSync8(focusEntry))
+      if (!existsSync6(focusEntry))
         throw new WorkRefError("focus_marker_not_found", `.rsp/focus.d/${name}`, name);
-      await unlink7(focusEntry);
+      await unlink6(focusEntry);
       await cleanupEmptyParentDirs(focusEntry, FOCUS_DIR);
       return { ok: true, action: "unfocus", workRef: workRef.name };
     });
@@ -5109,21 +3971,12 @@ function workRefFailure(error) {
   }
   throw error;
 }
-function inspectInitialization3() {
-  const rules = inspectManagedFile(RSP_RULES_PATH, "fallback protocol", { allowMissing: true });
-  const design = inspectManagedFile(`${RSP_DIR}/specs/design.md`, "design Spec", { allowMissing: true });
-  if (!rules.issue && !design.issue && rules.exists && design.exists)
-    return void 0;
-  const initialized = existsSync8(RSP_DIR);
-  return `${initialized ? "RSP project requires an update" : "RSP is not initialized in this project"}
-  ${initialized ? "Run: rsp update" : "Run: rsp init"}`;
-}
 
 // src/commands/group.ts
-import { randomUUID as randomUUID4 } from "crypto";
-import { existsSync as existsSync9 } from "fs";
-import { link as link3, mkdir as mkdir9, readdir as readdir3, readFile as readFile11, rename as rename5, unlink as unlink8, writeFile as writeFile4 } from "fs/promises";
-import { join as join9 } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync7 } from "fs";
+import { link as link2, mkdir as mkdir8, readdir as readdir4, readFile as readFile14, rename as rename5, unlink as unlink7, writeFile as writeFile5 } from "fs/promises";
+import { join as join11 } from "path";
 var ChangeGroupError = class extends Error {
   name = "ChangeGroupError";
 };
@@ -5131,7 +3984,7 @@ async function createChangeGroup(name, goal = "") {
   if (!name) {
     return failure("usage", "rsp group create <name> [goal]");
   }
-  const initialization = inspectInitialization4();
+  const initialization = inspectRspInitialization();
   if (initialization)
     return failure("error", initialization);
   try {
@@ -5143,9 +3996,9 @@ async function createChangeGroup(name, goal = "") {
       if (await hasArchivedGroupBrief(groupName))
         throw new ChangeGroupError(`archived Change Group cannot be reopened: ${groupName}`);
       const groupDirectory = resolveManagedDirectoryChain(CHANGES_DIR, [groupName], "Change Group path");
-      await mkdir9(groupDirectory, { recursive: true });
+      await mkdir8(groupDirectory, { recursive: true });
       try {
-        await writeFile4(ref.path, generateGroupBriefContent(groupName, goal), { flag: "wx" });
+        await writeFile5(ref.path, generateGroupBriefContent(groupName, goal), { flag: "wx" });
       } catch (error) {
         if (error.code === "EEXIST")
           throw new ChangeGroupError(`Change Group already exists: ${groupName}`);
@@ -5164,7 +4017,7 @@ async function closeChangeGroup(name) {
   if (!name) {
     return failure("usage", "rsp group close <name>");
   }
-  const initialization = inspectInitialization4();
+  const initialization = inspectRspInitialization();
   if (initialization)
     return failure("error", initialization);
   try {
@@ -5183,15 +4036,15 @@ async function closeChangeGroup(name) {
       const archiveDirectory = resolveArchiveDirectory(ref);
       const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
       const archiveName = resolveArchiveName(archiveDirectory, date, "brief");
-      await mkdir9(archiveDirectory, { recursive: true });
-      await rename5(ref.path, join9(archiveDirectory, archiveName));
+      await mkdir8(archiveDirectory, { recursive: true });
+      await rename5(ref.path, join11(archiveDirectory, archiveName));
       const warnings = [];
       try {
         await cleanupEmptyParentDirs(ref.path, CHANGES_DIR);
       } catch (error) {
         warnings.push(`changes directory cleanup failed: ${toErrorMessage(error)}`);
       }
-      return { ok: true, action: "close", groupName, archivePath: join9(archiveDirectory, archiveName), warnings };
+      return { ok: true, action: "close", groupName, archivePath: join11(archiveDirectory, archiveName), warnings };
     });
   } catch (error) {
     if (error instanceof WorkRefError || error instanceof ChangeGroupError) {
@@ -5205,18 +4058,18 @@ async function reopenChangeGroup(name, options) {
     return failure("usage", "rsp group reopen <name> --reason <text> [--from <archive-path>]");
   }
   const reason = options.reason?.trim();
-  if (!reason || /[\r\n]/.test(reason)) {
+  if (!reason || /[\r\n]/.test(reason) || !markdownText(parseMarkdown(reason).root).trim()) {
     return failure("error", "--reason must be one non-empty line");
   }
-  const initialization = inspectInitialization4();
+  const initialization = inspectRspInitialization();
   if (initialization)
     return failure("error", initialization);
   try {
     return await withRspLock("reopen-change-group", async () => {
       const warnings = [];
       const groupName = normalizeWorkRefSegment(name);
-      await requireEmptyGroupRecoverySubtree(join9(CHANGES_DIR, groupName), `Change Group work subtree for ${groupName}`);
-      await requireEmptyGroupRecoverySubtree(join9(FOCUS_DIR, groupName), `Change Group focus subtree for ${groupName}`);
+      await requireEmptyGroupRecoverySubtree(join11(CHANGES_DIR, groupName), `Change Group work subtree for ${groupName}`);
+      await requireEmptyGroupRecoverySubtree(join11(FOCUS_DIR, groupName), `Change Group focus subtree for ${groupName}`);
       const ref = resolveWorkRef(`${groupName}/brief`);
       if (ref.kind !== "group-brief")
         throw new ChangeGroupError(`invalid Change Group name: ${name}`);
@@ -5237,16 +4090,16 @@ async function reopenChangeGroup(name, options) {
           `selected archived Change Group belongs to ${record.group}, not ${groupName}`
         );
       }
-      if (existsSync9(ref.path))
+      if (existsSync7(ref.path))
         throw new ArchiveHistoryError("open_group_exists", `open Change Group already exists: ${groupName}`);
-      const archivedContent = await readFile11(record.sourcePath, "utf-8");
+      const archivedContent = await readFile14(record.sourcePath, "utf-8");
       const document = parseRspDocument(archivedContent, GROUP_BRIEF_DOCUMENT_SCHEMA);
       validateArchivedGroupBrief(document, groupName);
       const evidenceKey = `${GROUP_REOPEN_COMPLETION_PREFIX} \`${record.path}\`: ${reason}`;
       const retainedEvidence = /* @__PURE__ */ new Set();
       for (const retained of inspection.groupBriefs.filter((candidate) => candidate.group === groupName)) {
-        const content = retained.sourcePath === record.sourcePath ? archivedContent : await readFile11(retained.sourcePath, "utf-8");
-        for (const item of getGroupReopenEvidence(content))
+        const retainedDocument = retained.sourcePath === record.sourcePath ? document : parseRspDocument(await readFile14(retained.sourcePath, "utf-8"), GROUP_BRIEF_DOCUMENT_SCHEMA);
+        for (const item of getGroupReopenEvidence(retainedDocument))
           retainedEvidence.add(item.key);
       }
       if (retainedEvidence.has(evidenceKey)) {
@@ -5261,17 +4114,17 @@ async function reopenChangeGroup(name, options) {
         `- [ ] ${evidenceKey}`
       );
       const groupDirectory = resolveManagedDirectoryChain(CHANGES_DIR, [groupName], "Change Group path");
-      await mkdir9(groupDirectory, { recursive: true });
-      const temporaryPath = join9(RSP_DIR, `.group-reopen-${process.pid}-${randomUUID4()}.tmp`);
+      await mkdir8(groupDirectory, { recursive: true });
+      const temporaryPath = join11(RSP_DIR, `.group-reopen-${process.pid}-${randomUUID2()}.tmp`);
       let mutationError;
       try {
-        await writeFile4(temporaryPath, reopenedContent, { flag: "wx" });
-        await link3(temporaryPath, ref.path);
+        await writeFile5(temporaryPath, reopenedContent, { flag: "wx" });
+        await link2(temporaryPath, ref.path);
       } catch (error) {
         mutationError = error;
       }
       try {
-        await unlink8(temporaryPath);
+        await unlink7(temporaryPath);
       } catch (error) {
         if (!mutationError)
           warnings.push(`temporary reopen file cleanup failed: ${toErrorMessage(error)}`);
@@ -5302,21 +4155,12 @@ async function reopenChangeGroup(name, options) {
 function failure(kind, message, candidates = [], remainingCandidates = 0) {
   return { ok: false, kind, message, candidates, remainingCandidates };
 }
-function inspectInitialization4() {
-  const rules = inspectManagedFile(RSP_RULES_PATH, "fallback protocol", { allowMissing: true });
-  const design = inspectManagedFile(join9(RSP_DIR, "specs", "design.md"), "design Spec", { allowMissing: true });
-  if (!rules.issue && !design.issue && rules.exists && design.exists)
-    return void 0;
-  const initialized = existsSync9(RSP_DIR);
-  return `${initialized ? "RSP project requires an update" : "RSP is not initialized in this project"}
-  ${initialized ? "Run: rsp update" : "Run: rsp init"}`;
-}
 async function requireEmptyGroupRecoverySubtree(path, label) {
   if (!requireManagedDirectory(path, label, { allowMissing: true }))
     return;
   let entries;
   try {
-    entries = await readdir3(path);
+    entries = await readdir4(path);
   } catch (error) {
     throw new ChangeGroupError(`unable to inspect ${label}: ${toErrorMessage(error)}`);
   }
@@ -5329,7 +4173,7 @@ function validateArchivedGroupBrief(document, group) {
     throw new ArchiveHistoryError("archive_heading_invalid", `archived Change Group must contain exactly one canonical identity heading for ${group}`);
   for (const section of GROUP_BRIEF_DOCUMENT_SCHEMA.sections) {
     const matches = getDocumentSections(document, section.id);
-    if (matches.length !== 1 || !matches[0].canonical || !getDocumentSectionBody(document, section.id)) {
+    if (matches.length !== 1 || !matches[0].canonical || getVisibleBodyLines(getDocumentSectionMarkdown(document, section.id)).length === 0) {
       throw new ArchiveHistoryError(
         "archive_section_invalid",
         `archived Change Group must contain exactly one canonical required section: ${section.heading}`
@@ -5339,10 +4183,10 @@ function validateArchivedGroupBrief(document, group) {
 }
 function collectCloseReasons(group, errors) {
   const reasons = [...errors, ...group.warnings];
-  const open4 = group.slices.filter((slice) => slice.state === "open").map((slice) => slice.name);
+  const open2 = group.slices.filter((slice) => slice.state === "open").map((slice) => slice.name);
   const missing = group.slices.filter((slice) => slice.state === "missing").map((slice) => slice.name);
-  if (open4.length > 0)
-    reasons.push(`open slices: ${open4.join(", ")}`);
+  if (open2.length > 0)
+    reasons.push(`open slices: ${open2.join(", ")}`);
   if (missing.length > 0)
     reasons.push(`missing slices: ${missing.join(", ")}`);
   if (group.completion.total === 0)
@@ -5355,18 +4199,18 @@ function collectCloseReasons(group, errors) {
 }
 
 // src/commands/reopen.ts
-import { existsSync as existsSync10 } from "fs";
-import { mkdir as mkdir10, readFile as readFile12, unlink as unlink9, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname5 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { mkdir as mkdir9, readFile as readFile15, unlink as unlink8, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname6 } from "path";
 async function reopenChange(name, options) {
   if (!name) {
     return { ok: false, kind: "usage", message: "rsp reopen <name> --reason <text> [--from <archive-path>]", candidates: [], remainingCandidates: 0 };
   }
   const reason = options.reason?.trim();
-  if (!reason || /[\r\n]/.test(reason)) {
+  if (!reason || /[\r\n]/.test(reason) || !markdownText(parseMarkdown(reason).root).trim()) {
     return { ok: false, kind: "error", message: "--reason must be one non-empty line", candidates: [], remainingCandidates: 0 };
   }
-  const initialization = inspectInitialization5();
+  const initialization = inspectRspInitialization();
   if (initialization)
     return { ok: false, kind: "error", message: initialization, candidates: [], remainingCandidates: 0 };
   try {
@@ -5401,36 +4245,36 @@ async function reopenChange(name, options) {
         }
         throw error;
       }
-      if (existsSync10(workRef.path))
+      if (existsSync8(workRef.path))
         throw new ArchiveHistoryError("open_change_exists", `open Change already exists: ${name}`);
       const focusEntry = resolveFocusMarkerPath(workRef);
-      if (existsSync10(focusEntry))
+      if (existsSync8(focusEntry))
         throw new ArchiveHistoryError("focus_marker_exists", `focus marker already exists for non-open Change: ${name}; run rsp doctor`);
-      const archivedContent = await readFile12(record.sourcePath, "utf-8");
+      const archivedContent = await readFile15(record.sourcePath, "utf-8");
       const reopenedContent = appendChecklistItem(
         appendChecklistItem(archivedContent, "tasks", `- [ ] Resolve reopened concern: ${reason}`),
         "verify",
         `- [ ] Verify reopened concern: ${reason}`
       );
-      await mkdir10(dirname5(workRef.path), { recursive: true });
+      await mkdir9(dirname6(workRef.path), { recursive: true });
       let changeCreated = false;
       try {
-        await writeFile5(workRef.path, reopenedContent, { flag: "wx" });
+        await writeFile6(workRef.path, reopenedContent, { flag: "wx" });
         changeCreated = true;
-        await mkdir10(FOCUS_DIR, { recursive: true });
-        await mkdir10(dirname5(focusEntry), { recursive: true });
+        await mkdir9(FOCUS_DIR, { recursive: true });
+        await mkdir9(dirname6(focusEntry), { recursive: true });
         await writeManagedFile(focusEntry, "", "focus marker");
       } catch (error) {
         if (changeCreated) {
           try {
-            await unlink9(workRef.path);
+            await unlink8(workRef.path);
             await cleanupEmptyParentDirs(workRef.path, CHANGES_DIR);
           } catch {
           }
         }
         throw error;
       }
-      return { ok: true, workRef: workRef.name, archivePath: record.path, git: existsSync10(".git") };
+      return { ok: true, workRef: workRef.name, archivePath: record.path, git: existsSync8(".git") };
     });
   } catch (error) {
     if (error instanceof ArchiveHistoryError || error instanceof WorkRefError) {
@@ -5445,15 +4289,6 @@ async function reopenChange(name, options) {
     throw error;
   }
 }
-function inspectInitialization5() {
-  const rules = inspectManagedFile(RSP_RULES_PATH, "fallback protocol", { allowMissing: true });
-  const design = inspectManagedFile(`${RSP_DIR}/specs/design.md`, "design Spec", { allowMissing: true });
-  if (!rules.issue && !design.issue && rules.exists && design.exists)
-    return void 0;
-  const initialized = existsSync10(RSP_DIR);
-  return `${initialized ? "RSP project requires an update" : "RSP is not initialized in this project"}
-  ${initialized ? "Run: rsp update" : "Run: rsp init"}`;
-}
 function appendChecklistItem(content, sectionId, item) {
   try {
     return appendDocumentSectionItem(parseRspDocument(content, CHANGE_DOCUMENT_SCHEMA), sectionId, item);
@@ -5468,25 +4303,6 @@ function appendChecklistItem(content, sectionId, item) {
   }
 }
 
-// src/cli/presenters/commit.ts
-function presentCommit(result, json) {
-  if (json) {
-    emitJson(result);
-    return;
-  }
-  if (!result.ok) {
-    console.error(`  Commit stopped: ${result.message}`);
-    return;
-  }
-  console.log(`  Committed: ${result.commit}`);
-  console.log(`  HEAD: ${result.headBefore ?? "(unborn)"} -> ${result.headAfter}`);
-  console.log(`  committed paths: ${result.committedPaths?.join(", ") || "none"}`);
-  console.log(`  remaining worktree paths: ${result.remainingWorktreePaths?.join(", ") || "none"}`);
-  console.log("  stored message:");
-  for (const line of (result.storedMessage ?? "").split("\n"))
-    console.log(`    ${line}`);
-}
-
 // src/cli/presenters/work.ts
 function presentFailure(result) {
   const label = result.kind === "usage" ? "Usage:" : "Error:";
@@ -5794,30 +4610,8 @@ var unfocusCommand = defineCommand4({
     await executeCliCommand({ execute: () => unfocusChange(args.name), present: presentFocus, exitCode: (result) => result.ok ? void 0 : 1 }, args);
   }
 });
-var commitCommand = defineCommand4({
-  meta: {
-    name: "commit",
-    description: "Create one local commit from a message file on the existing staged boundary"
-  },
-  args: {
-    "message-file": {
-      type: "string",
-      description: "Path to the prepared commit message file",
-      required: true
-    },
-    ...jsonArgs
-  },
-  async run({ args }) {
-    await executeCliCommand({
-      execute: () => commitFromMessageFile(args["message-file"]),
-      present: (result) => presentCommit(result, Boolean(args.json)),
-      exitCode: (result) => result.ok ? void 0 : 1
-    }, args);
-  }
-});
 function createWorkCommands(deprecatedLite) {
   return {
-    commit: commitCommand,
     create: createCreateCommand(deprecatedLite),
     group: groupCommand,
     focus: focusCommand,
@@ -5840,7 +4634,7 @@ function createRootCommand(options) {
       init: setupCommands.init,
       add: setupCommands.add,
       specs: inspectionCommands.specs,
-      commit: workCommands.commit,
+      config: inspectionCommands.config,
       create: workCommands.create,
       group: workCommands.group,
       focus: workCommands.focus,
@@ -5866,9 +4660,6 @@ function isInteractiveTerminal(environment) {
 function shouldAutoLaunchUi(args, environment) {
   return args.length === 0 && isInteractiveTerminal(environment) && (environment.ci === void 0 || environment.ci === "false");
 }
-function shouldLaunchSkillsUi(args, environment) {
-  return args.length === 1 && args[0] === "skills" && isInteractiveTerminal(environment) && (environment.ci === void 0 || environment.ci === "false");
-}
 function validateUiArgs(args) {
   let lang = "auto";
   for (let index = 0; index < args.length; index += 1) {
@@ -5908,6 +4699,7 @@ function normalizeLegacyCreateOptions(rawArgs) {
   };
 }
 async function runCli(rawArgs = process.argv.slice(2)) {
+  await guardProjectVersion(rawArgs);
   const terminalEnvironment = {
     stdinTty: Boolean(process.stdin.isTTY),
     stdoutTty: Boolean(process.stdout.isTTY),
@@ -5915,19 +4707,6 @@ async function runCli(rawArgs = process.argv.slice(2)) {
     ci: process.env.CI
   };
   const explicitUi = rawArgs[0] === "ui";
-  if (shouldLaunchSkillsUi(rawArgs, terminalEnvironment)) {
-    const { resolveUiLocale } = await import("./locale-HT44UIUP.mjs");
-    const locale = resolveUiLocale("auto", process.env.RSP_UI_LANG, process.env.LC_ALL ?? process.env.LC_MESSAGES ?? process.env.LANG ?? new Intl.DateTimeFormat().resolvedOptions().locale);
-    const { runSkillsTui } = await import("./entry-YAW3PYFA.mjs");
-    const selection = await runSkillsTui(locale);
-    if (selection.kind === "confirmed") {
-      const result = await installPackagedSkills({ names: selection.names, force: selection.force });
-      presentSkillInstallResult(result);
-    } else if (selection.kind === "error") {
-      process.exitCode = 1;
-    }
-    return;
-  }
   if (explicitUi || shouldAutoLaunchUi(rawArgs, terminalEnvironment)) {
     const { lang } = validateUiArgs(explicitUi ? rawArgs.slice(1) : []);
     if (!isInteractiveTerminal(terminalEnvironment)) {
@@ -5936,7 +4715,7 @@ async function runCli(rawArgs = process.argv.slice(2)) {
     } else {
       const { resolveUiLocale } = await import("./locale-HT44UIUP.mjs");
       const locale = resolveUiLocale(lang, process.env.RSP_UI_LANG, process.env.LC_ALL ?? process.env.LC_MESSAGES ?? process.env.LANG ?? new Intl.DateTimeFormat().resolvedOptions().locale);
-      const { runTui } = await import("./entry-GIDNR7CJ.mjs");
+      const { runTui } = await import("./entry-RIJQ2X46.mjs");
       const exitCode = await runTui(locale);
       if (exitCode !== 0)
         process.exitCode = exitCode;
@@ -5961,7 +4740,7 @@ async function runCliMain(rawArgs = process.argv.slice(2)) {
     process.exitCode = 1;
   }
 }
-var isMain = process.argv[1] && fileURLToPath(import.meta.url) === resolve4(process.argv[1]);
+var isMain = process.argv[1] && fileURLToPath(import.meta.url) === resolve2(process.argv[1]);
 if (isMain)
   await runCliMain();
 export {