@oevery/rsp 4.0.0 → 4.2.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-AUZYUJ46.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,56 @@ 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.label ? ` ${edge.label}` : ""}: ${edge.description}`);
+      for (const view of result.views) {
+        console.log(`View ${view.id}: ${view.title} (owner: ${view.node}; include: ${view.include.join(", ")})`);
+        if (view.relationTypes || view.relationIds || view.boundary)
+          console.log(`  Filters: types=${view.relationTypes?.join(", ") ?? "*"}; relations=${view.relationIds?.join(", ") ?? "*"}; boundary=${view.boundary ?? "include"}`);
+        for (const participant of view.scenario?.participants ?? [])
+          console.log(`  Participant ${participant.id}: ${participant.node}${participant.title ? ` (${participant.title})` : ""}`);
+        view.scenario?.steps.forEach((step, index) => console.log(`  ${index + 1}. ${step.id}: ${step.source} -> ${step.target} [${step.type}] ${step.label}${step.replyTo ? ` (reply to ${step.replyTo})` : ""}${step.description ? ` \u2014 ${step.description}` : ""}`));
+      }
+      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-U2PN3VS4.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 +319,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 +336,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 +691,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 -->";
@@ -802,8 +755,8 @@ ${changeSectionHeading("verify")}
 ### Optional
 - Manual or environment:
   - [ ] ${placeholder}
-- Coverage:
-  - ${placeholder}
+### Conclusions
+- ${placeholder}
 
 ${changeSectionHeading("blockers")}
 - none
@@ -853,8 +806,8 @@ ${changeSectionHeading("verify")}
 ### Optional
 - Manual or environment:
   - [ ] ${template.manualVerify}
-- Coverage:
-  - ${placeholder}
+### Conclusions
+- ${placeholder}
 
 ${changeSectionHeading("blockers")}
 - none
@@ -895,9 +848,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: "Use Required/Optional checklists and an optional short, non-nested Conclusions list only. Uncheck failed, unrun or invalidated evidence. Keep current limits, applicability conditions or required failure dispositions; replace stale conclusions. No prose paragraphs, tables, repeated results or repair history. Remove Conclusions when unnecessary.",
     blockers: "Name unresolved decisions or dependencies that prevent progress; use none when there are no blockers."
   };
   return `${renderDocumentSectionHeading(CHANGE_DOCUMENT_SCHEMA, sectionId)}
@@ -911,14 +864,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 +983,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 +1009,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 +1018,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 +1070,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 +1091,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 +1106,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 +1117,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 +1141,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 +1152,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 +1227,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 +1248,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 +1379,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 +1438,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 +1802,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 +1822,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 +1866,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 +1910,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 +1939,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 +2840,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 +2856,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 +2895,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 +2943,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 +2969,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 +2997,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 +3023,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 +3054,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 +3120,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 +3152,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 +3210,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 +3233,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 +3297,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 +3317,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 +3337,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 +3346,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 +3368,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 +3383,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 +3408,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 +3454,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 +3568,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 +3596,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 +3616,7 @@ var addSpecCommand = defineCommand2({
     }, args);
   }
 });
-var addCommand = defineCommand2({
+var addCommand = defineCommand3({
   meta: {
     name: "add",
     description: "Add an optional durable spec file"
@@ -3635,7 +3625,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 +3650,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 +3668,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 +3679,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 +3708,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 +3737,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 +3852,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 +3891,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 +3924,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 +3965,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 +4027,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 +4058,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 +4082,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 +4105,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 +4190,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 +4240,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 +4410,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 +4435,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 +4448,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 +4461,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 +4488,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 +4515,7 @@ var groupCommand = defineCommand4({
     })
   }
 });
-var archiveCommand = defineCommand4({
+var archiveCommand = defineCommand5({
   meta: {
     name: "archive",
     description: "Archive an open change into .rsp/archives/"
@@ -4549,7 +4539,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 +4564,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 +4584,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 +4614,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 +4707,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;