@oevery/rsp 4.0.0 → 4.1.0

package/dist/cli.mjs

@@ -1,7 +1,78 @@
 #!/usr/bin/env node
 import {
-  ARCHIVES_DIR,
+  ARCHITECTURE_FILE,
+  PROJECT_VERSION_PATH,
+  SOURCE_INVOCATION,
+  compareVersions,
+  exactInvocation,
+  guardProjectVersion,
+  isExactVersion,
+  queryArchitecture,
+  readProjectRuntime,
+  readProjectVersion,
+  selectProjectRuntime
+} from "./chunk-JO6NDJM4.mjs";
+import {
   ArchiveHistoryError,
+  GROUP_BRIEF_FILENAME,
+  GROUP_REOPEN_COMPLETION_PREFIX,
+  HISTORY_DEFAULT_LIMIT,
+  HISTORY_MAX_LIMIT,
+  IssueRelationshipError,
+  WorkRefError,
+  buildDurableReviewGuidance,
+  collectArchiveReadiness,
+  createIssueRelationship,
+  generateGroupBriefContent,
+  getDurableReviewCandidateTargets,
+  getGroupReopenEvidence,
+  hasArchivedGroupBrief,
+  historyInspectionComplete,
+  inspectArchiveHistory,
+  inspectArchiveTree,
+  inspectChangeDependencies,
+  inspectChangeGroups,
+  inspectFocusTree,
+  inspectProjectStatus,
+  inspectWorkTree,
+  normalizeExecutableWorkRef,
+  normalizeWorkRefSegment,
+  parseIssueRelationships,
+  projectDependencyForest,
+  projectSpecsDetail,
+  projectSpecsSearch,
+  projectSpecsTree,
+  queryArchiveHistory,
+  readArchiveHistoryDetail,
+  resolveArchiveDirectory,
+  resolveExecutableChange,
+  resolveFocusMarkerPath,
+  resolveWorkRef,
+  selectArchiveHistoryRecord,
+  selectArchivedGroupBrief,
+  toArchiveReadinessOutput
+} from "./chunk-VDRXFKBP.mjs";
+import {
+  SPECS_DEFAULT_RESULT_LIMIT,
+  SPECS_DETAIL_CONTENT_CODE_POINTS,
+  SPECS_MAX_RESULT_LIMIT,
+  SpecsQueryError,
+  cleanupEmptyParentDirs,
+  detectProjectName,
+  emitJson,
+  guardRspInitialized,
+  inspectRspInitialization,
+  inspectSpecs,
+  inspectUnsupportedRules,
+  isRecognizedGeneratedSpecsIndex,
+  isValidSpecName,
+  normalizeLogicalPath,
+  specsInspectionComplete,
+  toErrorMessage,
+  walkMarkdownFiles
+} from "./chunk-LGDCIQYL.mjs";
+import {
+  ARCHIVES_DIR,
   CHANGES_DIR,
   CHANGE_DOCUMENT_SCHEMA,
   CONFIG_PATH,
@@ -9,11 +80,6 @@ import {
   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,
@@ -21,94 +87,45 @@ import {
   PKG_ROOT,
   RSP_DIR,
   RSP_RULES_PATH,
-  SPECS_DEFAULT_RESULT_LIMIT,
-  SPECS_DETAIL_CONTENT_CODE_POINTS,
-  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,
   renderDocumentSectionHeading,
   renderDocumentTitle,
   requireManagedDirectory,
   requireManagedFile,
-  resolveArchiveDirectory,
   resolveDecisionRecordsPath,
-  resolveExecutableChange,
-  resolveFocusMarkerPath,
   resolveKinds,
   resolveLanguagePolicy,
   resolveManagedDirectoryChain,
   resolveRequiredSections,
-  resolveWorkRef,
   resolveWorkflowPolicy,
-  selectArchiveHistoryRecord,
-  selectArchivedGroupBrief,
-  specsInspectionComplete,
-  toArchiveReadinessOutput,
-  toErrorMessage,
   validateDecisionRecordsFilesystemPath,
-  walkMarkdownFiles,
   writeManagedFile
-} from "./chunk-HFSTLCCK.mjs";
+} from "./chunk-P3KO3GZW.mjs";
 
 // src/cli.ts
 import { resolve as resolve2 } from "path";
@@ -117,6 +134,7 @@ import { runMain } from "citty";
 
 // src/cli/capabilities.ts
 var CLI_COMMAND_CAPABILITIES = {
+  "architecture": { json: true, compact: true },
   "config": { json: true, compact: true },
   "status": { json: true, compact: true },
   "show": { json: true, compact: true },
@@ -150,10 +168,49 @@ function supportsCompact(command) {
 }
 
 // src/cli/registry.ts
-import { defineCommand as defineCommand5 } from "citty";
+import { defineCommand as defineCommand6 } from "citty";
 
-// src/cli/commands/inspection.ts
+// src/cli/commands/architecture.ts
 import { defineCommand } from "citty";
+var architectureCommand = defineCommand({
+  meta: { name: "architecture", description: "Read full or selected architecture structure without document bodies" },
+  args: { node: { type: "string", description: "Node and descendants" }, view: { type: "string", description: "Explicit view selection" }, ...compactJsonArgs },
+  async run({ args }) {
+    const unknown = Object.keys(args).filter((key) => !["node", "view", "json", "compact", "_"].includes(key));
+    if (unknown.length || args._.length)
+      throw new Error(`Unsupported architecture options/arguments: ${[...unknown, ...args._].join(", ")}`);
+    const result = await queryArchitecture({ node: args.node, view: args.view });
+    if (args.json) {
+      console.log(JSON.stringify(result, null, args.compact ? void 0 : 2));
+    } else {
+      console.log(`Architecture: ${result.configured ? result.source.root : "not configured"}
+Selection: ${result.selection.kind}${result.selection.id ? ` ${result.selection.id}` : ""}`);
+      for (const node of result.nodes) {
+        console.log(`${node.boundary ? "[boundary] " : ""}${node.id}: ${node.title} \u2014 ${node.description}${node.parent ? ` (parent: ${node.parent})` : ""}`);
+        for (const binding of node.bindings) console.log(`  ${binding.file}${binding.headings ? ` > ${binding.headings.join(" > ")}` : ""} (scope: ${binding.scope}; ${binding.inherited ? `inherited from ${binding.origin}` : `direct on ${binding.origin}`})`);
+      }
+      for (const edge of result.relations) console.log(`Relation ${edge.id}: ${edge.source} -> ${edge.target} [${edge.type}]: ${edge.description}`);
+      for (const view of result.views) console.log(`View ${view.id}: ${view.title} (owner: ${view.node}; include: ${view.include.join(", ")})`);
+      for (const diagnostic of result.diagnostics) console.log(`${diagnostic.code}: ${diagnostic.message}`);
+      if (result.configured)
+        console.log(`Source: ${result.source.file} @ ${result.source.revision}`);
+    }
+  }
+});
+var viewCommand = defineCommand({
+  meta: { name: "view", description: "Open the shared local architecture viewer, inspect or stop its service" },
+  args: { action: { type: "positional", required: false, description: "status or stop; omit to open" }, open: { type: "boolean", default: true, description: "Open browser (use --no-open to print URL only)" } },
+  async run({ args }) {
+    const unknown = Object.keys(args).filter((key) => !["action", "open", "_"].includes(key));
+    if (unknown.length || args._.length > 1 || args.action && !args.open)
+      throw new Error("rsp view accepts only an optional status/stop action or --no-open");
+    const { runView } = await import("./client-EHRWH5Q7.mjs");
+    await runView(args.action, args.open);
+  }
+});
+
+// src/cli/commands/inspection.ts
+import { defineCommand as defineCommand2 } from "citty";
 
 // src/commands/check.ts
 import { readFile } from "fs/promises";
@@ -255,7 +312,6 @@ function inspectChangeDocument(content, options) {
 }
 
 // src/core/focus-capsule.ts
-import { Buffer } from "buffer";
 import { TextDecoder } from "util";
 var FOCUS_CAPSULE_VERSION = "<!-- rsp-focus:v1 -->";
 var LEGACY_WARNING = "legacy focus capsule has no structured recovery projection";
@@ -273,15 +329,6 @@ function inspectFocusCapsuleBytes(bytes) {
   } catch {
     return { kind: "invalid", code: "focus_capsule_invalid_utf8", message: "focus capsule must contain valid UTF-8" };
   }
-  if (Buffer.byteLength(content, "utf-8") > MAX_FOCUS_CAPSULE_BYTES) {
-    return {
-      kind: "invalid",
-      code: "focus_capsule_too_large",
-      message: `focus capsule exceeds ${MAX_FOCUS_CAPSULE_BYTES} UTF-8 bytes`
-    };
-  }
-  if (content.length === 0)
-    return { kind: "empty", content: "" };
   return parseFocusCapsule(content);
 }
 function parseFocusCapsule(content) {
@@ -637,109 +684,8 @@ async function showConfig() {
 
 // src/commands/doctor.ts
 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();
-}
+import { readdir as readdir2, readFile as readFile3, stat } from "fs/promises";
+import { basename, join as join2, relative as relative2 } from "path";
 
 // src/core/artifacts.ts
 var RSP_AGENTS_BEGIN = "<!-- rsp:begin -->";
@@ -895,9 +841,9 @@ function changeSectionHeading(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.",
+    design: "Explain the current approach, boundaries, and necessary tradeoffs; replace obsolete plans while preserving decision reasons and useful outcome comparisons.",
+    tasks: "Keep current checkable work and actual completion; revise or reopen invalidated tasks within authorized scope. Do not append routine attempts, fixes, retries, or check runs.",
+    verify: "Keep required/optional checks and only details needed to judge acceptance, evidence applicability, or locate necessary evidence. Do not repeat check results or retain commands, counts, or review steps merely because they occurred. Preserve applicable coverage, gaps, and distinct review/human acceptance; no run history.",
     blockers: "Name unresolved decisions or dependencies that prevent progress; use none when there are no blockers."
   };
   return `${renderDocumentSectionHeading(CHANGE_DOCUMENT_SCHEMA, sectionId)}
@@ -911,14 +857,13 @@ function renderRspAgentsBlock(runtime) {
 
 RSP tracks current work, stable specs, and archives under \`.rsp/\`.
 
-Read in order using supplied or confirmed paths; discover only missing paths or applicable ancestor instructions, without overlapping whole-tree scans:
+Use 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.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.
+3. Establish the request's scope, authority and existing owner. A clear bounded request selecting one capability with sufficient owner facts loads that project Skill directly from \`.agents/skills/\`, without a Core or Focus preflight. For tracked work read the selected Change; for grouped work read its sibling Group Brief first. Read only relevant Specs and Decision Records under the configured authoritative path.
+4. Load \`rsp\` at \`.agents/skills/rsp/SKILL.md\` for unresolved routing or ownership, actual cross-capability coordination, or lifecycle operations. Read \`.rsp/focus.d/\` only when needed to resolve or recover the owner; marker paths are open-work candidates and optional bounded Markdown is recovery guidance, not authority. An explicit WorkRef or the user's mentioned Change selects first; otherwise use current status and dependency evidence.
 
-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.
+Direct capability invocation does not make tracked work untracked. Preserve existing Changes, required tracking prerequisites, Group dependencies, independent review and permission boundaries; missing prerequisites stop dependent work. Skills are the only workflow: hosts may discover them or read them directly, but a missing or unusable required Skill stops dependent work and must be reported as an incomplete installation. Do not use retired Rules or install implicitly.
 Do not treat \`.rsp/specs/\` or \`.rsp/changes/\` as replacements for nearest \`AGENTS.md\` or \`CONTEXT.md\`.
 
 ${selection}
@@ -1031,8 +976,8 @@ async function checkForUpdates(current) {
 
 // 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";
+import { chmod, copyFile, mkdir, mkdtemp, readdir, readFile as readFile2, rename, rm } from "fs/promises";
+import { dirname, join, relative } from "path";
 var DEFAULT_PACKAGED_SKILL_NAMES = [
   "rsp",
   "rsp-shape",
@@ -1057,7 +1002,7 @@ 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 skillsRoot = join(packageRoot, "skills");
   const rootInspection = inspectManagedDirectory(skillsRoot, "packaged Skills root");
   if (rootInspection.issue)
     throw rootInspection.issue;
@@ -1066,7 +1011,7 @@ async function inspectPackagedSkills(packageRoot) {
   for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
     if (entry.name.startsWith("."))
       continue;
-    const root = join2(skillsRoot, entry.name);
+    const root = join(skillsRoot, entry.name);
     if (!entry.isDirectory())
       throw unsupportedEntry(root, "packaged Skills");
     const inspection = await inspectManagedFileTree(root, `packaged Skill ${entry.name}`, { includeHidden: true });
@@ -1118,14 +1063,14 @@ async function treesEqual(source, targetRoot) {
   if (source.files.length !== targetFiles.length || source.files.some((path, index) => path !== targetFiles[index]))
     return false;
   for (const path of source.files) {
-    const sourcePath = join2(source.root, path);
-    const targetPath = join2(targetRoot, path);
+    const sourcePath = join(source.root, path);
+    const targetPath = join(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)]);
+    const [sourceContent, targetContent] = await Promise.all([readFile2(sourcePath), readFile2(targetPath)]);
     if (!sourceContent.equals(targetContent))
       return false;
   }
@@ -1139,14 +1084,14 @@ async function inspectPackagedSkillInventory(options = {}) {
   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"));
+  const manifest = JSON.parse(await readFile2(join(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 target = join(targetRoot, skill.name);
     const targetStatus = inspectInventoryTarget(target);
     skills.push({
       name: skill.name,
@@ -1154,7 +1099,7 @@ async function inspectPackagedSkillInventory(options = {}) {
       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");
+  const retired = RETIRED_PACKAGED_SKILL_NAMES.filter((name) => inspectInventoryTarget(join(targetRoot, name)) !== "missing");
   return {
     retired,
     package: { name: manifest.name, version: manifest.version },
@@ -1165,8 +1110,8 @@ async function inspectPackagedSkillInventory(options = {}) {
 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 sourcePath = join(source.root, path);
+    const targetPath = join(targetRoot, path);
     const stats = lstatSync(sourcePath);
     if (!stats.isFile())
       throw unsupportedEntry(sourcePath, `packaged Skill ${source.name}`);
@@ -1189,7 +1134,7 @@ async function updatePackagedSkills(options = {}) {
   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);
+    const target = join(targetRoot, skill.name);
     if (isCanonicalSourceProjection(skill.root, target))
       result.unchanged.push(skill.name);
     else if (inspectTarget(target, skill.name) === "missing")
@@ -1200,35 +1145,35 @@ async function updatePackagedSkills(options = {}) {
       result.replaced.push(skill.name);
   }
   for (const name of RETIRED_PACKAGED_SKILL_NAMES) {
-    if (inspectTarget(join2(targetRoot, name), name) !== "missing")
+    if (inspectTarget(join(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 staging = await mkdtemp(join(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));
+        await copySkillTree(skill, join(staging, skill.name));
     }
     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 });
+      inspectTarget(join(targetRoot, name), name);
+      await rm(join(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);
+      const target = join(targetRoot, skill.name);
       inspectTarget(target, skill.name);
       await rm(target, { recursive: true, force: true });
-      await renamePath(join2(staging, skill.name), target);
+      await renamePath(join(staging, skill.name), target);
       completed.push(`installed ${skill.name}`);
     }
   } catch (error) {
@@ -1275,14 +1220,16 @@ async function runDoctor(options = {}) {
       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);
-  if (decisionRecordsConfigValid) {
+  const configValid = await checkConfigSemantics(checks, reportRuntime);
+  if (configValid) {
+    await checkSpecsTree(checks, reportRuntime);
     await checkDecisionRecordsDirectory(checks, reportRuntime);
     await checkInactiveDefaultDecisionRecords(checks, reportRuntime);
   }
   await checkActiveChangeConsistency(checks);
+  if (configValid)
+    await checkArchitecture(checks);
   const result = {
     command: "doctor",
     ok: checks.every((check) => check.status !== "issue"),
@@ -1294,6 +1241,42 @@ async function runDoctor(options = {}) {
   };
   return result;
 }
+async function checkArchitecture(checks) {
+  try {
+    const architecture = await queryArchitecture();
+    if (!architecture.configured) {
+      checks.push({
+        status: "info",
+        code: "architecture_not_configured",
+        label: ARCHITECTURE_FILE,
+        message: "Optional architecture model is not configured."
+      });
+    } else if (architecture.diagnostics.length) {
+      for (const diagnostic of architecture.diagnostics) {
+        checks.push({
+          status: "issue",
+          code: `architecture_${diagnostic.code}`,
+          label: `architecture binding: ${diagnostic.file ?? ARCHITECTURE_FILE}`,
+          message: `${diagnostic.file ?? ARCHITECTURE_FILE}: ${diagnostic.message}`
+        });
+      }
+    } else {
+      checks.push({
+        status: "ok",
+        code: "architecture_valid",
+        label: "architecture structure and document bindings",
+        message: `${architecture.nodes.length} nodes, ${architecture.relations.length} relations, ${architecture.views.length} views. Structural and reference validity does not establish semantic agreement with implementation.`
+      });
+    }
+  } catch (error) {
+    checks.push({
+      status: "issue",
+      code: "architecture_inspection_failed",
+      label: ARCHITECTURE_FILE,
+      message: `${ARCHITECTURE_FILE}: ${toErrorMessage(error)}`
+    });
+  }
+}
 async function reportProjectRuntime(checks) {
   let sourceMode = false;
   try {
@@ -1389,7 +1372,7 @@ async function checkAgents(checks, reportRuntime) {
   }
   let agents;
   try {
-    agents = await readFile4("AGENTS.md", "utf-8");
+    agents = await readFile3("AGENTS.md", "utf-8");
   } catch (error) {
     reportRuntime({
       code: "agents_read_failed",
@@ -1448,7 +1431,7 @@ async function checkSpecsTree(checks, reportRuntime) {
   }
 }
 async function checkArchiveNaming(checks) {
-  const archivesDir = join3(RSP_DIR, "archives");
+  const archivesDir = join2(RSP_DIR, "archives");
   const inspection = await inspectArchiveTree({ archivesDir });
   if (inspection.diagnostics.length > 0) {
     checks.push({
@@ -1812,7 +1795,7 @@ function emptyCollectionSummary() {
 }
 
 // src/commands/ready.ts
-import { readFile as readFile5 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
 function readyError(name, error, kind) {
   return { command: "ready", ok: false, change: name || null, path: null, warnings: [], runtime: [], error, kind };
 }
@@ -1832,7 +1815,7 @@ async function showReady(name) {
   const runtime = [];
   let content;
   try {
-    content = await readFile5(srcPath, "utf-8");
+    content = await readFile4(srcPath, "utf-8");
   } catch {
     return readyError(name, { code: "change_read_failed", message: `unable to read .rsp/changes/${name}.md` }, "read");
   }
@@ -1876,7 +1859,7 @@ async function showReady(name) {
 }
 
 // src/commands/show.ts
-import { readFile as readFile6 } from "fs/promises";
+import { readFile as readFile5 } 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 };
@@ -1920,7 +1903,7 @@ async function showChange(nameOrFocused, options = {}) {
   const srcPath = workRef.path;
   let content;
   try {
-    content = await readFile6(srcPath, "utf-8");
+    content = await readFile5(srcPath, "utf-8");
   } catch {
     return showError({ code: "change_read_failed", message: `unable to read .rsp/changes/${name}.md` }, runtime);
   }
@@ -1949,7 +1932,7 @@ async function showChange(nameOrFocused, options = {}) {
     const markerPath = focusMarkers.get(name);
     let markerContent;
     try {
-      markerContent = await readFile6(markerPath);
+      markerContent = await readFile5(markerPath);
     } catch (error) {
       reportRuntime({
         code: "focus_marker_read_failed",
@@ -2850,7 +2833,7 @@ function formatArchiveReady(value) {
 }
 
 // src/cli/commands/inspection.ts
-var configCommand = defineCommand({
+var configCommand = defineCommand2({
   meta: {
     name: "config",
     description: "Inspect effective project configuration without scanning work state"
@@ -2866,7 +2849,7 @@ var configCommand = defineCommand({
     }, args);
   }
 });
-var specsCommand = defineCommand({
+var specsCommand = defineCommand2({
   meta: {
     name: "specs",
     description: "Inspect current Specs and Decision Records or run bounded literal search"
@@ -2905,7 +2888,7 @@ var specsCommand = defineCommand({
     }, args);
   }
 });
-var statusCommand = defineCommand({
+var statusCommand = defineCommand2({
   meta: {
     name: "status",
     description: "Show project status summary with current focus information"
@@ -2953,7 +2936,7 @@ var statusCommand = defineCommand({
     }, args);
   }
 });
-var checkCommand = defineCommand({
+var checkCommand = defineCommand2({
   meta: {
     name: "check",
     description: "Validate changes (frontmatter, sections, template text, deltas, scenarios)"
@@ -2979,7 +2962,7 @@ var checkCommand = defineCommand({
     }, args);
   }
 });
-var doctorCommand = defineCommand({
+var doctorCommand = defineCommand2({
   meta: {
     name: "doctor",
     description: "Check RSP setup health and common integration issues"
@@ -3007,7 +2990,7 @@ var doctorCommand = defineCommand({
     }, args);
   }
 });
-var readyCommand = defineCommand({
+var readyCommand = defineCommand2({
   meta: {
     name: "ready",
     description: "Preview archive readiness for a change without moving it"
@@ -3033,7 +3016,7 @@ var readyCommand = defineCommand({
     }, args);
   }
 });
-var showCommand = defineCommand({
+var showCommand = defineCommand2({
   meta: {
     name: "show",
     description: "Show change context with readiness signals and relevant paths"
@@ -3064,7 +3047,7 @@ var showCommand = defineCommand({
     }, args);
   }
 });
-var historyCommand = defineCommand({
+var historyCommand = defineCommand2({
   meta: {
     name: "history",
     description: "Query bounded archived Change summaries or one exact archived WorkRef"
@@ -3130,14 +3113,14 @@ var inspectionCommands = {
 };
 
 // src/cli/commands/setup.ts
-import { defineCommand as defineCommand2 } from "citty";
+import { defineCommand as defineCommand3 } from "citty";
 
 // src/commands/add-spec.ts
 import { mkdir as mkdir3, writeFile as writeFile2 } from "fs/promises";
-import { join as join4 } from "path";
+import { join as join3 } from "path";
 
 // src/core/lock.ts
-import { mkdir as mkdir2, readFile as readFile7, unlink, writeFile } from "fs/promises";
+import { mkdir as mkdir2, readFile as readFile6, unlink, writeFile } from "fs/promises";
 async function withRspLock(operation, fn) {
   requireManagedDirectory(RSP_DIR, "RSP root", { allowMissing: true });
   await mkdir2(RSP_DIR, { recursive: true });
@@ -3162,7 +3145,7 @@ ${(/* @__PURE__ */ new Date()).toISOString()}`, { flag: "wx" });
 }
 async function handleStaleLock(operation) {
   try {
-    const content = await readFile7(LOCK_PATH, "utf-8");
+    const content = await readFile6(LOCK_PATH, "utf-8");
     const lines = content.trim().split("\n");
     const pid = Number(lines[0]);
     if (pid && Number.isFinite(pid)) {
@@ -3220,10 +3203,10 @@ 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 = join4(RSP_DIR, "specs");
+    const specsDir = join3(RSP_DIR, "specs");
     const segments = name.split("/");
     const parent = resolveManagedDirectoryChain(specsDir, segments.slice(0, -1), "spec path");
-    const path = join4(parent, `${segments.at(-1)}.md`);
+    const path = join3(parent, `${segments.at(-1)}.md`);
     const inspection = await inspectManagedFileTree(specsDir, "Specs");
     if (inspection.issues.length > 0)
       throw inspection.issues[0];
@@ -3243,30 +3226,30 @@ async function addSpec(name, projectName = "project") {
 
 // src/commands/init.ts
 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";
+import { mkdir as mkdir4, readdir as readdir3, readFile as readFile8 } from "fs/promises";
+import { join as join5 } from "path";
 
 // 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";
+import { access, chmod as chmod2, link, mkdtemp as mkdtemp2, readFile as readFile7, rename as rename2, rm as rm2, stat as stat2, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname2, join as join4 } from "path";
 async function updateSetupFile(path, render) {
   const exists = requireManagedFile(path, "setup file", { allowMissing: true });
-  const current = exists ? await readFile8(path, "utf8") : null;
+  const current = exists ? await readFile7(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");
+  const temporary = await mkdtemp2(join4(dirname2(path), ".rsp-write-"));
+  const prepared = join4(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)
+    if (stillExists !== exists || stillExists && await readFile7(path, "utf8") !== current)
       throw new Error(`Setup file changed during update: ${path}`);
     if (exists)
       await rename2(prepared, path);
@@ -3307,7 +3290,7 @@ async function initProject(args = {}) {
     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];
+    const dirs = [join5(RSP_DIR, "specs"), CHANGES_DIR, FOCUS_DIR, join5(RSP_DIR, "archives"), decisionRecordsPath];
     for (const path of dirs)
       resolveManagedDirectoryChain(process.cwd(), path.split("/"), "project directory");
     const completed = [];
@@ -3327,12 +3310,12 @@ async function initProject(args = {}) {
       }
       await ensureFile(CONFIG_PATH, generateConfigTemplate());
       clearConfigCache();
-      await ensureFile(join6(RSP_DIR, "specs/design.md"), generateDesignContent(projectName));
+      await ensureFile(join5(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");
+        await ensureFile(join5(decisionRecordsPath, ".gitkeep"), "");
+      await ensureFile(join5(CHANGES_DIR, ".gitkeep"), "");
+      await ensureFile(join5(FOCUS_DIR, ".gitkeep"), "");
+      await ensureFile(join5(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"));
@@ -3347,7 +3330,7 @@ async function initProject(args = {}) {
       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 };
+      return { ok: true, isNew, created: completed.length > 0, decisionRecordsPath, withProjectSetup: Boolean(args.withProjectSetup), agentsUpdated, skills, managedAgents: mode === "print" ? await readFile8("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 });
     }
@@ -3356,17 +3339,17 @@ async function initProject(args = {}) {
 
 // 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";
+import { readFile as readFile11, unlink as unlink3 } from "fs/promises";
+import { join as join7 } from "path";
 
 // src/commands/archive-index-migration.ts
-import { readFile as readFile10 } from "fs/promises";
-import { join as join7 } from "path";
+import { readFile as readFile9 } from "fs/promises";
+import { join as join6 } from "path";
 async function isLegacyArchiveIndex() {
-  const path = join7(ARCHIVES_DIR, "INDEX.md");
+  const path = join6(ARCHIVES_DIR, "INDEX.md");
   if (!requireManagedFile(path, "legacy archive index", { allowMissing: true }))
     return false;
-  return isLegacyArchiveIndexContent(await readFile10(path, "utf-8"));
+  return isLegacyArchiveIndexContent(await readFile9(path, "utf-8"));
 }
 function isLegacyArchiveIndexContent(content) {
   try {
@@ -3378,7 +3361,7 @@ function isLegacyArchiveIndexContent(content) {
 }
 
 // src/commands/specs-index-migration.ts
-import { readFile as readFile11, unlink as unlink2 } from "fs/promises";
+import { readFile as readFile10, 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 });
@@ -3393,7 +3376,7 @@ 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))
+  if (!isRecognizedGeneratedSpecsIndex(await readFile10(resolve(path), "utf8"), path))
     throw new Error(`Specs index is no longer generated; left untouched: ${path}`);
   await unlink2(path);
   return true;
@@ -3418,12 +3401,12 @@ async function updateProject(options = {}) {
       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 });
+    requireManagedFile(join7(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 agents = requireManagedFile("AGENTS.md", "AGENTS.md", { allowMissing: true }) ? await readFile11("AGENTS.md", "utf8") : null;
     const refreshAgents = (current) => upsertRspAgentsBlock(current ?? `# ${projectName}
 
 `, runtime).content;
@@ -3464,7 +3447,7 @@ async function updateProject(options = {}) {
           record(`generated Specs index removed: ${path}`);
       }
       if (await isLegacyArchiveIndex()) {
-        await unlink3(join8(RSP_DIR, "archives/INDEX.md"));
+        await unlink3(join7(RSP_DIR, "archives/INDEX.md"));
         record("legacy Archive Index removed");
       }
       if (await updateSetupFile("AGENTS.md", refreshAgents))
@@ -3578,7 +3561,7 @@ function presentUpdate(result, dryRun = false) {
 }
 
 // src/cli/commands/setup.ts
-var initCommand = defineCommand2({
+var initCommand = defineCommand3({
   meta: {
     name: "init",
     description: "Scaffold .rsp/ and ensure AGENTS.md contains the RSP entry block"
@@ -3606,7 +3589,7 @@ var initCommand = defineCommand2({
     }, args);
   }
 });
-var addSpecCommand = defineCommand2({
+var addSpecCommand = defineCommand3({
   meta: {
     name: "spec",
     description: "Create .rsp/specs/<name>.md for direct Specs queries"
@@ -3626,7 +3609,7 @@ var addSpecCommand = defineCommand2({
     }, args);
   }
 });
-var addCommand = defineCommand2({
+var addCommand = defineCommand3({
   meta: {
     name: "add",
     description: "Add an optional durable spec file"
@@ -3635,7 +3618,7 @@ var addCommand = defineCommand2({
     spec: addSpecCommand
   }
 });
-var updateCommand = defineCommand2({
+var updateCommand = defineCommand3({
   meta: {
     name: "update",
     description: "Update the complete pinned environment and remove retired managed assets"
@@ -3660,7 +3643,7 @@ var setupCommands = {
 };
 
 // src/cli/commands/skills.ts
-import { defineCommand as defineCommand3 } from "citty";
+import { defineCommand as defineCommand4 } from "citty";
 
 // src/cli/presenters/skills.ts
 function presentPackagedSkillInventory(inventory, json = false) {
@@ -3678,7 +3661,7 @@ function presentPackagedSkillInventory(inventory, json = false) {
 }
 
 // src/cli/commands/skills.ts
-var skillsListCommand = defineCommand3({
+var skillsListCommand = defineCommand4({
   meta: { name: "list", description: "Inspect the complete package-owned Skill inventory" },
   args: { ...jsonArgs },
   async run({ args }) {
@@ -3689,19 +3672,19 @@ var skillsListCommand = defineCommand3({
   }
 });
 var skillsCommands = {
-  skills: defineCommand3({
+  skills: defineCommand4({
     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";
+import { defineCommand as defineCommand5 } from "citty";
 
 // src/commands/archive.ts
 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";
+import { mkdir as mkdir5, readFile as readFile12, rename as rename3, unlink as unlink4 } from "fs/promises";
+import { basename as basename2, join as join8 } from "path";
 async function archiveChange(name) {
   if (!name) {
     return { ok: false, kind: "usage", message: "rsp archive <name>" };
@@ -3718,7 +3701,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 readFile13(srcPath, "utf-8");
+      const content = await readFile12(srcPath, "utf-8");
       const configInspection = await inspectRspConfig();
       if (configInspection.issues.length > 0) {
         return {
@@ -3747,7 +3730,7 @@ async function archiveChange(name) {
         };
       }
       await mkdir5(archiveSubdir, { recursive: true });
-      await rename3(srcPath, join9(archiveSubdir, archiveName));
+      await rename3(srcPath, join8(archiveSubdir, archiveName));
       const postArchiveWarnings = [];
       let focusCleared = false;
       if (existsSync4(focusEntry)) {
@@ -3862,11 +3845,11 @@ async function createChange(name, summary = "", kind, options = {}) {
 }
 
 // src/commands/focus.ts
-import { Buffer as Buffer2 } from "buffer";
+import { Buffer } 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";
+import { basename as basename3, dirname as dirname5, join as join9 } from "path";
 async function focusChange(name, options = {}) {
   if (!name) {
     return { ok: false, kind: "usage", message: "rsp focus <name>" };
@@ -3901,7 +3884,7 @@ async function readCapsule(source) {
 }
 async function replaceFocusCapsule(path, content) {
   requireManagedFile(path, "focus marker", { allowMissing: true });
-  const temporaryPath = join10(dirname5(path), `.${basename3(path)}.${randomUUID()}.tmp`);
+  const temporaryPath = join9(dirname5(path), `.${basename3(path)}.${randomUUID()}.tmp`);
   let handle;
   try {
     handle = await open(temporaryPath, "wx");
@@ -3934,13 +3917,13 @@ async function readBoundedStdin() {
   const chunks = [];
   let size = 0;
   for await (const chunk of process.stdin) {
-    const buffer = Buffer2.isBuffer(chunk) ? chunk : Buffer2.from(chunk);
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.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 Buffer2.concat(chunks, size);
+  return Buffer.concat(chunks, size);
 }
 async function unfocusChange(name) {
   if (!name) {
@@ -3975,8 +3958,8 @@ function workRefFailure(error) {
 // src/commands/group.ts
 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";
+import { link as link2, mkdir as mkdir8, readdir as readdir4, readFile as readFile13, rename as rename5, unlink as unlink7, writeFile as writeFile5 } from "fs/promises";
+import { join as join10 } from "path";
 var ChangeGroupError = class extends Error {
   name = "ChangeGroupError";
 };
@@ -4037,14 +4020,14 @@ async function closeChangeGroup(name) {
       const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
       const archiveName = resolveArchiveName(archiveDirectory, date, "brief");
       await mkdir8(archiveDirectory, { recursive: true });
-      await rename5(ref.path, join11(archiveDirectory, archiveName));
+      await rename5(ref.path, join10(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: join11(archiveDirectory, archiveName), warnings };
+      return { ok: true, action: "close", groupName, archivePath: join10(archiveDirectory, archiveName), warnings };
     });
   } catch (error) {
     if (error instanceof WorkRefError || error instanceof ChangeGroupError) {
@@ -4068,8 +4051,8 @@ async function reopenChangeGroup(name, options) {
     return await withRspLock("reopen-change-group", async () => {
       const warnings = [];
       const groupName = normalizeWorkRefSegment(name);
-      await requireEmptyGroupRecoverySubtree(join11(CHANGES_DIR, groupName), `Change Group work subtree for ${groupName}`);
-      await requireEmptyGroupRecoverySubtree(join11(FOCUS_DIR, groupName), `Change Group focus subtree for ${groupName}`);
+      await requireEmptyGroupRecoverySubtree(join10(CHANGES_DIR, groupName), `Change Group work subtree for ${groupName}`);
+      await requireEmptyGroupRecoverySubtree(join10(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}`);
@@ -4092,13 +4075,13 @@ async function reopenChangeGroup(name, options) {
       }
       if (existsSync7(ref.path))
         throw new ArchiveHistoryError("open_group_exists", `open Change Group already exists: ${groupName}`);
-      const archivedContent = await readFile14(record.sourcePath, "utf-8");
+      const archivedContent = await readFile13(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 retainedDocument = retained.sourcePath === record.sourcePath ? document : parseRspDocument(await readFile14(retained.sourcePath, "utf-8"), GROUP_BRIEF_DOCUMENT_SCHEMA);
+        const retainedDocument = retained.sourcePath === record.sourcePath ? document : parseRspDocument(await readFile13(retained.sourcePath, "utf-8"), GROUP_BRIEF_DOCUMENT_SCHEMA);
         for (const item of getGroupReopenEvidence(retainedDocument))
           retainedEvidence.add(item.key);
       }
@@ -4115,7 +4098,7 @@ async function reopenChangeGroup(name, options) {
       );
       const groupDirectory = resolveManagedDirectoryChain(CHANGES_DIR, [groupName], "Change Group path");
       await mkdir8(groupDirectory, { recursive: true });
-      const temporaryPath = join11(RSP_DIR, `.group-reopen-${process.pid}-${randomUUID2()}.tmp`);
+      const temporaryPath = join10(RSP_DIR, `.group-reopen-${process.pid}-${randomUUID2()}.tmp`);
       let mutationError;
       try {
         await writeFile5(temporaryPath, reopenedContent, { flag: "wx" });
@@ -4200,7 +4183,7 @@ function collectCloseReasons(group, errors) {
 
 // src/commands/reopen.ts
 import { existsSync as existsSync8 } from "fs";
-import { mkdir as mkdir9, readFile as readFile15, unlink as unlink8, writeFile as writeFile6 } from "fs/promises";
+import { mkdir as mkdir9, readFile as readFile14, unlink as unlink8, writeFile as writeFile6 } from "fs/promises";
 import { dirname as dirname6 } from "path";
 async function reopenChange(name, options) {
   if (!name) {
@@ -4250,7 +4233,7 @@ async function reopenChange(name, options) {
       const focusEntry = resolveFocusMarkerPath(workRef);
       if (existsSync8(focusEntry))
         throw new ArchiveHistoryError("focus_marker_exists", `focus marker already exists for non-open Change: ${name}; run rsp doctor`);
-      const archivedContent = await readFile15(record.sourcePath, "utf-8");
+      const archivedContent = await readFile14(record.sourcePath, "utf-8");
       const reopenedContent = appendChecklistItem(
         appendChecklistItem(archivedContent, "tasks", `- [ ] Resolve reopened concern: ${reason}`),
         "verify",
@@ -4420,7 +4403,7 @@ function presentReopen(result) {
 
 // src/cli/commands/work.ts
 function createCreateCommand(deprecatedLite) {
-  return defineCommand4({
+  return defineCommand5({
     meta: {
       name: "create",
       description: "Create .rsp/changes/<name>.md [summary]"
@@ -4445,7 +4428,7 @@ function createCreateCommand(deprecatedLite) {
       }
     },
     async run({ args }) {
-      const summary = Array.isArray(args._) && args._.length > 1 ? args._.slice(1).join(" ") : "";
+      const summary = args._.slice(1).join(" ");
       await executeCliCommand({
         execute: () => createChange(args.name, summary, args.kind, {
           issue: args.issue,
@@ -4458,7 +4441,7 @@ function createCreateCommand(deprecatedLite) {
     }
   });
 }
-var groupCreateCommand = defineCommand4({
+var groupCreateCommand = defineCommand5({
   meta: {
     name: "create",
     description: "Create an unfocused .rsp/changes/<group>/00-brief.md"
@@ -4471,18 +4454,18 @@ var groupCreateCommand = defineCommand4({
     }
   },
   async run({ args }) {
-    const goal = Array.isArray(args._) && args._.length > 1 ? args._.slice(1).join(" ") : "";
+    const goal = args._.slice(1).join(" ");
     await executeCliCommand({ execute: () => createChangeGroup(args.name, goal), present: presentGroup, exitCode: (result) => result.ok ? void 0 : 1 }, args);
   }
 });
-var groupCommand = defineCommand4({
+var groupCommand = defineCommand5({
   meta: {
     name: "group",
     description: "Create, close, and explicitly reopen shallow Change Groups"
   },
   subCommands: {
     create: groupCreateCommand,
-    close: defineCommand4({
+    close: defineCommand5({
       meta: {
         name: "close",
         description: "Archive a completed Group Brief after all child Changes are archived"
@@ -4498,7 +4481,7 @@ var groupCommand = defineCommand4({
         await executeCliCommand({ execute: () => closeChangeGroup(args.name), present: presentGroup, exitCode: (result) => result.ok ? void 0 : 1 }, args);
       }
     }),
-    reopen: defineCommand4({
+    reopen: defineCommand5({
       meta: {
         name: "reopen",
         description: "Restore one archived Group Brief while retaining history"
@@ -4525,7 +4508,7 @@ var groupCommand = defineCommand4({
     })
   }
 });
-var archiveCommand = defineCommand4({
+var archiveCommand = defineCommand5({
   meta: {
     name: "archive",
     description: "Archive an open change into .rsp/archives/"
@@ -4549,7 +4532,7 @@ var archiveCommand = defineCommand4({
       await executeCliCommand({ execute: () => archiveChange(args.name), present: presentArchive, exitCode: (result) => result.ok ? void 0 : 1 }, args);
   }
 });
-var reopenCommand = defineCommand4({
+var reopenCommand = defineCommand5({
   meta: {
     name: "reopen",
     description: "Restore one archived Change as focused open work while retaining history"
@@ -4574,7 +4557,7 @@ var reopenCommand = defineCommand4({
     await executeCliCommand({ execute: () => reopenChange(args.name, { from: args.from, reason: args.reason }), present: presentReopen, exitCode: (result) => result.ok ? void 0 : 1 }, args);
   }
 });
-var focusCommand = defineCommand4({
+var focusCommand = defineCommand5({
   meta: {
     name: "focus",
     description: "Mark an existing change as currently focused in .rsp/focus.d/"
@@ -4594,7 +4577,7 @@ var focusCommand = defineCommand4({
     await executeCliCommand({ execute: () => focusChange(args.name, { capsuleFile: args["capsule-file"] }), present: presentFocus, exitCode: (result) => result.ok ? void 0 : 1 }, args);
   }
 });
-var unfocusCommand = defineCommand4({
+var unfocusCommand = defineCommand5({
   meta: {
     name: "unfocus",
     description: "Remove a change from the current focus set in .rsp/focus.d/"
@@ -4624,13 +4607,15 @@ function createWorkCommands(deprecatedLite) {
 // src/cli/registry.ts
 function createRootCommand(options) {
   const workCommands = createWorkCommands(options.deprecatedLite);
-  return defineCommand5({
+  return defineCommand6({
     meta: {
       name: "rsp",
       version: options.version,
       description: "RSP (Reliable Software Practice), a repository-native engineering workflow for humans and AI agents"
     },
     subCommands: {
+      architecture: architectureCommand,
+      view: viewCommand,
       init: setupCommands.init,
       add: setupCommands.add,
       specs: inspectionCommands.specs,
@@ -4715,7 +4700,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-RIJQ2X46.mjs");
+      const { runTui } = await import("./entry-NDASTAI5.mjs");
       const exitCode = await runTui(locale);
       if (exitCode !== 0)
         process.exitCode = exitCode;