@oevery/rsp 4.1.0 → 4.2.0

package/dist/viewer-service.mjs

@@ -9,12 +9,13 @@ import {
   readProjectFile,
   readProjectRuntime,
   selectArchitecture
-} from "./chunk-JO6NDJM4.mjs";
+} from "./chunk-AUZYUJ46.mjs";
 import {
   VIEWER_PROTOCOL,
   snapshotViewerRuntime,
+  viewerEntries,
   viewerRuntime
-} from "./chunk-U56XMIOO.mjs";
+} from "./chunk-DNRGBQS7.mjs";
 import {
   readCurrentDocument
 } from "./chunk-LGDCIQYL.mjs";
@@ -161,7 +162,7 @@ async function renderDocument(root, model, file) {
       case "inlineCode":
         return `<code>${escape(node.value)}</code>`;
       case "code":
-        return `<pre><code>${escape(node.value)}</code></pre>`;
+        return node.lang === "mermaid" ? `<figure data-rsp-mermaid><pre><code>${escape(node.value)}</code></pre></figure>` : `<pre><code>${escape(node.value)}</code></pre>`;
       case "blockquote":
         return `<blockquote>${children()}</blockquote>`;
       case "list":
@@ -184,6 +185,17 @@ async function renderDocument(root, model, file) {
       case "linkReference": {
         const value = node.type === "link" ? node.url : definitions.get(node.identifier.toLowerCase())?.url;
         const href = value === void 0 ? void 0 : url(value);
+        if (!href && value && !/^[a-z][\w+.-]*:|^[/\\#]/i.test(value)) {
+          try {
+            const target = posix.normalize(posix.join(posix.dirname(file), decodeURIComponent(value.split(/[?#]/)[0])));
+            if (permitted(model, target) && /\.(?:[cm]?[jt]sx?|vue|svelte|py|rs|go|java|kt|c|cpp|h|hpp|cs|sh|json|ya?ml|toml)$/i.test(target)) {
+              const fragment = new URL(value, "http://document.local/").hash;
+              const locator = `${target}${/^#L\d+(?:-L\d+)?$/.test(fragment) ? fragment : ""}`;
+              return `${children()} <button type="button" data-source-locator="${escape(locator)}"><span data-rsp-reading-status="copySource">Copy source path</span>: <code>${escape(locator)}</code></button>`;
+            }
+          } catch {
+          }
+        }
         return href ? `<a href="${href}" rel="noopener noreferrer"${/^https?:/i.test(href) ? ' target="_blank"' : ""}>${children()}</a>` : `${children()}<span data-rsp-reading-status="unavailableLink"> (unavailable link)</span>`;
       }
       case "image": {
@@ -229,6 +241,13 @@ async function layoutArchitecture(architecture, workspace, focus) {
   const targetName = (edge) => edge.source === edge.target && containers.has(edge.source) ? selfNames[edge.target] : needsReference(edge) || containers.has(edge.target) ? referenceNames[edge.target] : names[edge.target];
   const views = focus ? [{ id: "", title: `${nodeById.get(focus)?.title ?? focus} relationships`, node: "", include: [focus] }] : [{ id: "", title: "All registered nodes", node: "", include: architecture.nodes.map((node) => node.id) }, ...architecture.views];
   const viewNames = Object.fromEntries(views.map((view, index) => [view.id, `v${index}`]));
+  const scenarioViews = focus ? [] : architecture.views.filter((view) => view.scenario);
+  const scenarioNames = Object.fromEntries(scenarioViews.map((view, index) => [
+    view.id,
+    Object.fromEntries(view.scenario.participants.map((participant, role) => [`p${index}r${role}`, participant]))
+  ]));
+  const scenarioReferences = Object.fromEntries(Object.values(scenarioNames).flatMap((roles) => Object.entries(roles).map(([alias, participant]) => [alias, participant.node])));
+  const collaborationViews = Object.fromEntries(scenarioViews.map((view) => [view.id, `${viewNames[view.id]}c`]));
   viewNames[""] = "v0";
   const focusView = focus ? `v${views.length - 1}` : void 0;
   const relationTags = new Map(architecture.relations.map((edge, index) => [edge.id, `e${index}`]));
@@ -245,11 +264,38 @@ async function layoutArchitecture(architecture, workspace, focus) {
     return pipe(...diagramNodes.filter((node) => !node.parent).map(element), ...Object.entries(references).map(([alias, id]) => {
       const node = nodeById.get(id);
       return h.component(alias, { ...properties(node), title: `${node.title} (relationship reference)`, description: { txt: `Reference to ${node.id}. ${node.description}` } });
-    }), ...architecture.relations.map((edge) => h.rel(sourceName(edge), targetName(edge), { kind: "relation", title: edge.type, tags: [relationTags.get(edge.id)], description: { txt: edge.description } })));
+    }), ...Object.values(scenarioNames).flatMap((roles) => Object.entries(roles).map(([alias, participant]) => h.component(alias, {
+      ...properties(nodeById.get(participant.node)),
+      title: participant.title ?? nodeById.get(participant.node).title,
+      description: { txt: nodeById.get(participant.node).title }
+    }))), ...architecture.relations.map((edge) => h.rel(sourceName(edge), targetName(edge), {
+      kind: "relation",
+      title: edge.label ?? edge.type,
+      tags: [relationTags.get(edge.id)],
+      description: { txt: edge.description },
+      ...edge.type === "return" ? { line: "dashed" } : edge.type === "event" ? { line: "dotted" } : {}
+    })));
   }).views((helpers, compose) => {
     const h = helpers;
     const pipe = compose;
-    return pipe(...views.map((view, index) => {
+    return pipe(...views.flatMap((view, index) => {
+      const scenario = architecture.views.find((candidate) => candidate.id === view.id)?.scenario;
+      if (scenario) {
+        const roles = scenarioNames[view.id];
+        const aliasFor = (id) => Object.entries(roles).find(([, participant]) => participant.id === id)[0];
+        return ["sequence", "diagram"].map((variant) => h.dynamicView(variant === "sequence" ? viewNames[view.id] : collaborationViews[view.id], { title: view.title, variant }).with(
+          ...Object.keys(roles).map((alias2) => h.$include(alias2, { with: { size: "sm", padding: "xs", textSize: "sm" } })),
+          ...scenario.steps.map((step) => (builder2) => builder2.step({
+            source: aliasFor(step.source),
+            target: aliasFor(step.target),
+            astPath: step.id,
+            title: step.label,
+            description: { txt: step.description ?? step.type },
+            line: step.type === "return" ? "dashed" : step.type === "event" ? "dotted" : "solid",
+            ...step.type === "return" ? { isBackward: true } : step.type === "event" ? { head: "open" } : {}
+          }))
+        ));
+      }
       const isFocus = !!focus && index === views.length - 1;
       const projection = selectArchitecture(architecture, isFocus ? { kind: "focus", id: focus } : view.id ? { kind: "view", id: view.id } : { kind: "full" });
       const include = [...projection.visible].map((id) => names[id]);
@@ -268,8 +314,17 @@ async function layoutArchitecture(architecture, workspace, focus) {
     }));
   });
   const data = (await layoutLikeC4Model(builder.toLikeC4Model({ id: workspace }))).$data;
-  const relationIds = Object.fromEntries(Object.values(data.relations).map((edge) => [edge.id, architecture.relations.find((item) => relationTags.get(item.id) === edge.tags?.[0]).id]));
-  return { data, names, viewNames, references, relationIds, focusView };
+  const relationIds = Object.fromEntries(Object.values(data.relations).flatMap((edge) => {
+    const original = architecture.relations.find((item) => relationTags.get(item.id) === edge.tags?.[0]);
+    return original ? [[edge.id, original.id]] : [];
+  }));
+  const stepIds = Object.fromEntries(scenarioViews.flatMap(
+    (view) => [viewNames[view.id], collaborationViews[view.id]].map((alias) => {
+      const edges = data.views[alias].edges;
+      return [alias, Object.fromEntries(edges.map((edge) => [edge.id, edge.astPath]))];
+    })
+  ));
+  return { data, names, viewNames, references: { ...references, ...scenarioReferences }, relationIds, focusView, collaborationViews, scenarioNames, stepIds };
 }
 
 // src/viewer/workspaces.ts
@@ -443,11 +498,12 @@ async function createViewerService(options) {
         return;
       }
       if (url.pathname === "/") {
-        send(200, "text/html; charset=utf-8", '<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>RSP Architecture</title><link rel="stylesheet" href="/app.css"></head><body><div id="root"></div><script type="module" src="/app.js"></script></body></html>');
+        send(200, "text/html; charset=utf-8", `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>RSP Architecture</title><link rel="stylesheet" href="/${viewerEntries.style}"></head><body><div id="root"></div><script type="module" src="/${viewerEntries.app}"></script></body></html>`);
         return;
       }
-      if (["/app.js", "/app.css"].includes(url.pathname)) {
-        send(200, url.pathname.endsWith(".css") ? "text/css" : "text/javascript", runtime.assets.get(url.pathname));
+      const asset = runtime.assets.get(url.pathname);
+      if (asset) {
+        send(200, asset.type, asset.content);
         return;
       }
       if (!authorized(request.headers.authorization, options.readToken)) {
@@ -499,9 +555,9 @@ async function createViewerService(options) {
         json({ workspace: id, ...await renderDocument(workspace.root, workspace.model, file) });
         return;
       }
-      const asset = await readAsset(workspace.root, workspace.model, file);
-      response.setHeader("ETag", `"${asset.revision}"`);
-      send(200, asset.type, asset.content);
+      const image = await readAsset(workspace.root, workspace.model, file);
+      response.setHeader("ETag", `"${image.revision}"`);
+      send(200, image.type, image.content);
     } catch (error) {
       send(409, "text/plain; charset=utf-8", error.message);
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oevery/rsp",
   "type": "module",
-  "version": "4.1.0",
+  "version": "4.2.0",
   "description": "RSP (Reliable Software Practice), a repository-native engineering workflow for humans and AI agents",
   "author": "oevery",
   "license": "MIT",
@@ -40,8 +40,8 @@
     "skills:package-check": "node scripts/skill-package-check.mjs",
     "prepublishOnly": "pnpm run release:check",
     "release": "release-it",
-    "build": "tsup && node scripts/build-viewer.mjs",
-    "dev": "tsup --watch",
+    "build": "node scripts/build.mjs",
+    "dev": "node scripts/dev.mjs",
     "docs:build": "vitepress build docs",
     "docs:check": "node scripts/docs-check.mjs",
     "doctor": "node dist/cli.mjs doctor",
@@ -82,7 +82,7 @@
     "@radix-ui/react-slot": "1.5.0",
     "@radix-ui/react-tooltip": "1.4.1",
     "@release-it/conventional-changelog": "12.0.2",
-    "@tailwindcss/cli": "4.3.3",
+    "@tailwindcss/cli": "4.3.4",
     "@types/hast": "^3.0.5",
     "@types/mdast": "^4.0.4",
     "@types/node": "^22.20.1",
@@ -91,18 +91,19 @@
     "class-variance-authority": "0.7.1",
     "clsx": "2.1.1",
     "esbuild": "^0.28.2",
-    "eslint": "^10.13.0",
+    "eslint": "^10.14.0",
     "ink-testing-library": "^4.0.0",
+    "mermaid": "12.3.0",
     "playwright-core": "1.64.1",
     "react-dom": "~19.3.1",
-    "release-it": "21.1.1",
+    "release-it": "21.1.2",
     "smol-toml": "^1.9.1",
     "tailwind-merge": "3.7.0",
-    "tailwindcss": "4.3.3",
+    "tailwindcss": "4.3.4",
     "tsup": "^9.0.0",
     "typescript": "^5.9.3",
     "vitepress": "^1.6.4",
-    "vitest": "^5.0.5",
-    "wrangler": "^4.151.3"
+    "vitest": "^5.1.0",
+    "wrangler": "4.157.0"
   }
 }

package/skills/rsp/SKILL.md

@@ -4,7 +4,7 @@ description: Coordinate authorized direct, Change or Group work; select capabili
 license: MIT
 metadata:
   author: oevery
-  version: "2026.11.04.1"
+  version: "2026.11.06.1"
 ---
 
 # RSP Core
@@ -15,15 +15,17 @@ Carry the authorized request through execution, applicable evidence and needed k
 
 Before mutation, read nearest instructions and relevant CONTEXT; establish intent, authority and the existing owner from evidence. Use known paths and discover missing context as needed. An explicit WorkRef wins; multiple focus markers alone do not block work. Preserve dirty work and its owner. Before switching owners, check overlapping product and knowledge paths; overlap transfers no authority.
 
-- **Direct:** a clear bounded request needing no durable continuity. Create no Change and run no tracking preflight merely to execute it.
-- **Change:** one delivery/acceptance boundary needing sustained work or cross-session recovery. Read its six sections and relevant Specs; Focus is only a sparse recovery pointer.
+- **Direct:** a local, explicit modification with a clear result and verification boundary. Interface changes, multiple files, strict checks or repeated execution alone require no Change or tracking preflight.
+- **Change:** one delivery/acceptance boundary whose implementation needs a shared record of related behavior, responsibility, compatibility or acceptance decisions. Actual staged delivery, handoff or deferred obligations can also require this record. It need not span sessions or split into independently deliverable parts. Read its six sections and relevant Specs; Focus is only a sparse recovery pointer.
 - **Group:** independently acceptable/deliverable child Changes with dependencies or integration obligations. Read the Brief then select a child; the Brief is not executable work. File count, complexity and agent count alone do not create a Group.
 
+Read-only advice, diagnosis and review create no implementation Change. Establish actual impact before selecting new work; reconsider when authorized scope materially expands, not for routine corrections or failed checks. Continue a matching existing owner only for the same outcome or remaining obligations; shared files or modules alone establish no ownership. A short plan or design discussion alone requires no Change. Preserve explicit user and project tracking requirements.
+
 Load the [work model](references/work-model.md) when tracked identities are missing from context; required tracking cannot be bypassed by relabelling work Direct. Use rsp status for needed owner, dependency or recovery facts, and JSON for exact dependency data. Required dependency checks and fresh archive readiness still apply.
 
 Use the CLI invocation selected by the project AGENTS entry; `rsp` in these Skills denotes that selection. Resolve needed settings through the selected CLI's successful `rsp config --json` summary. Reuse it until relevant drift or recovery; raw YAML is diagnostic only. Projection failure blocks choices depending on unknown settings, while independent authorized work continues.
 
-Select capabilities from their descriptions and the task contract. Executors load applicable methods and inspect sources; Core consults method details when needed for its own work or a concrete coordination question. Select the responsibility needed now:
+Select capabilities from their descriptions and the task contract. Executors reuse applicable entrypoint and method text already in context, load missing or changed instructions, and inspect sources; Core consults method details when needed for its own work or a concrete coordination question. Select the responsibility needed now:
 
 - rsp-shape: bounded read-only design or authorized planning; reopen planning only for material unresolved choices.
 - rsp-implement: diagnosis, authorized implementation or accepted-finding correction, including ordinary own checks.
@@ -40,7 +42,7 @@ Implement owns ordinary self-checks. Main-agent inspection can assess results, b
 
 Reuse traceable observations, checks and reviews while their target, acceptance boundary and relevant inputs still apply. Changed code, dependencies, configuration, tools or environment invalidate affected evidence; role changes and delivery-scope confirmation alone do not. Include excluded worktree inputs when assessing a staged slice, and recognize behavior changes in normative Specs or executable Skills even when stored as Markdown.
 
-Check paths, diff, outcomes, omissions and evidence applicability. Reuse executor checks when applicable. Independent semantic review may use implementer test evidence; required independent execution must run. Preserve original evidence and verdicts with their existing owner; Change retains only applicable conclusions and material failure dispositions. Add no evidence ledger.
+Check paths, diff, outcomes, omissions and evidence applicability. Reuse executor checks when applicable. Independent semantic review may use implementer test evidence; required independent execution must run. Preserve original evidence and verdicts with their existing owner; apply the current work record rules to Change summaries. Add no evidence ledger.
 
 For required correction/re-review, load [review convergence](references/coordination-review.md). Batch compatible findings into one correction, run covering checks, then review finding resolution and new risks in the correction. Stop for changed scope/authority, unsafe replay, missing required capability, non-convergence or no new discriminating evidence. Required failures remain incomplete.
 
@@ -56,9 +58,9 @@ Load [interruption recovery](references/coordination-recovery.md) for pause/resu
 
 ## Maintain records and prepare delivery
 
-During execution apply the [current work record rules](references/work-model.md#current-work-records), loading them when absent from context. Update affected Tasks/Verify directly when scope, contract, design and knowledge remain accurate; do not append attempts or postpone current-state corrections until archive. Use the same work model for Blockers syntax. Passing checks or recovery alone adds no whole-document rewrite. Focus supplies only missing recovery context, never acceptance or authority.
+For tracked work, apply the [current work record rules](references/work-model.md#current-work-records) during execution. Load them only when absent from context. Update affected Tasks/Verify directly when scope, contract, design and knowledge remain accurate; do not append attempts or postpone current-state corrections until archive. Use the same work model for Blockers syntax. Passing checks or recovery alone adds no whole-document rewrite. Focus supplies only missing recovery context, never acceptance or authority.
 
-Ordinary completion and checkpoint commits leave Change open; a generic commit request does not establish final delivery. At established final delivery or an explicit close request, load [delivery closeout](references/closeout.md). workflow.closeout is ask (default), auto or manual; no setting grants Git, push, publication, deployment, approval or human acceptance authority.
+Ordinary completion and checkpoint commits leave Change open. Before a tracked commit, inspect actual remaining Tasks: incomplete work selects a checkpoint; all Tasks complete selects [delivery closeout](references/closeout.md), even with missing or failed verification. Reuse an explicit applicable checkpoint or closure choice without asking again. Also load closeout for established final delivery or an explicit close request. workflow.closeout is ask (default), auto or manual; no setting grants Git, push, publication, deployment, approval or human acceptance authority.
 
 For necessary stable-knowledge updates, load [durable writeback](references/durable-review.md) to establish facts, update their owners and reconcile affected records. Final delivery or closure additionally requires whole-Change convergence and consistency checks. Reuse applicable evidence and fill missing or invalidated coverage and separately required review. Already-accurate records need no edit; current readiness is a lifecycle observation, not semantic acceptance.
 

package/skills/rsp/references/closeout.md

@@ -1,16 +1,16 @@
 # Final delivery and lifecycle closeout
 
-Load for an established final-delivery boundary, an explicit close request, or a delivery question requiring checkpoint classification. Ordinary completion never activates closeout. A generic commit request defaults to a checkpoint unless final delivery is already established; checkpoints keep Change open and require only the authorized slice and applicable evidence.
+Load for an established final-delivery boundary, an explicit close request, or a tracked commit whose Tasks are complete. Inspect actual remaining work and correct inaccurate records before classification. Task completion triggers a closure decision, not archive eligibility; missing or failed checks do not suppress the decision. Ordinary completion without a delivery request leaves work open. Reuse an explicit applicable checkpoint or closure choice. Checkpoints keep Change open and require their own applicable evidence.
 
 ## Decide closure independently of Git
 
 Use the validated workflow.closeout setting from rsp config --json:
 
-- ask (default): prepare a concrete final boundary, applicable evidence and required knowledge/Change updates, then ask whether to close before terminal staging. Reuse explicit closure authority already granted; do not ask twice.
-- auto: close eligible work at established final delivery without another closure request, subject to nearer denial.
+- ask (default): inspect the concrete boundary, existing evidence and specific gaps, then ask before staging whether to finish necessary checks and records, archive when eligible and commit if authorized, or make only an eligible checkpoint and leave work open. Do not require every check or final-record update before asking. A selected conditional closeout authorizes its necessary preparation and eligible archive; do not ask again when gates pass.
+- auto: prepare closeout for a completed-task delivery or established final delivery and close only eligible work, subject to nearer denial.
 - manual: close only on an explicit close request. Authorized final commits may leave work open and must report that fact.
 
-Explicit refusal keeps work open. A decision to leave it open does not block an otherwise authorized commit. Neither policy, readiness nor archive grants Git authority. An explicit standalone close request can close eligible work without a commit. Do not interpret finishing implementation, a pass, a successor task or elapsed time as final delivery.
+Explicit refusal keeps work open. A decision to leave it open does not block an otherwise authorized, verified commit. Neither policy, readiness nor archive grants Git authority. An explicit standalone close request can close eligible work without a commit. A pass, a successor task or elapsed time alone selects no closure. After closeout is selected, resolve failures within existing authority; if blocked, report the gap without silently falling back to a checkpoint commit.
 
 ## Reconcile the final boundary
 

package/skills/rsp/references/durable-review.md

@@ -21,10 +21,10 @@ If inspection reports only `RSP project requires an update` without update autho
 Apply this sequence only for established final delivery or preparation/audit of closure. Routine knowledge updates use the bounded writeback above.
 
 1. **Verify outcome facts.** Establish the approved delivered result from current implementation, authoritative contracts and decisive evidence. Distinguish passed, failed, unverified and superseded conclusions. This establishes truth, not a preliminary full-document rewrite; plans and recovery notes alone cannot establish current facts.
-2. **Distill Focus as needed.** Integrate only verified outcomes, evidence applicability or material limits missing from Change; no useful addition means no edit. Resolve or safely transfer outstanding recovery obligations before discarding their notes. Recovery state alone supplies no required acceptance evidence.
+2. **Distill Focus as needed.** Integrate only verified outcomes, evidence applicability or material limits missing from Change; no useful addition means no edit. Resolve or safely transfer outstanding recovery obligations before discarding their notes. Recovery state alone supplies no required acceptance evidence; clearing Focus cannot substitute for knowledge writeback.
 3. **Write back knowledge as needed.** Using the verified result and Change delta, decide current facts and lasting rationale independently using the methods below. Update existing owners only when justified. No stable change means no edit; a delivered contract that leaves its authoritative Spec stale requires correction before closeout. Do not copy the whole Change or its verification history into knowledge documents.
-4. **Converge the whole Change.** After necessary writeback, use `rsp-doc`'s artifact method to reconcile all six sections under the [current work record rules](work-model.md#current-work-records). Retain the delivered delta, relevant design and result comparisons, applicable scoped evidence, material failure dispositions/limits and knowledge-update references; leave already-converged text unchanged. Remove obsolete plans and duplicate or misplaced content without moving history into a new report or Focus. Group integration conclusions stay in the Brief. Without Doc, perform the same bounded convergence locally without installation or replacing required Review.
-5. **Check final consistency, then archive when authorized.** Compare the final Change and knowledge owners with the verified result; an earlier review of another revision or a passing readiness command proves no text quality. Reuse applicable implementation/test evidence, check new knowledge/document edits, and fill only missing or invalidated coverage. Document-only writeback and archive preparation do not themselves invalidate code checks. Complete separately required Review before the archive gate below. Fix prose defects in scope, but return material contract or implementation contradictions to the decision, implementation or verification owner. Unresolved Required failures still block closeout.
+4. **Converge the whole Change.** After necessary writeback, use `rsp-doc`'s artifact method to reconcile all six sections under the [current work record rules](work-model.md#current-work-records), including Verify admission. Retain the delivered delta, relevant design and knowledge-update references; leave already-converged text unchanged. Remove obsolete plans and duplicate or misplaced content. Group integration conclusions stay in the Brief. Without Doc, perform the same bounded convergence locally without installation or replacing required Review.
+5. **Check final consistency.** Compare the final Change and knowledge owners with the verified result; an earlier review of another revision or a passing readiness command proves no text quality. Reuse applicable implementation/test evidence, check new knowledge/document edits, and fill only missing or invalidated coverage. Document-only writeback and archive preparation do not themselves invalidate code checks. Retain separately required Review as an unresolved obligation until its result is available. Fix prose defects in scope, but return material contract or implementation contradictions to the decision, implementation or verification owner. Return unresolved Required failures with the convergence result.
 
 These are dependency constraints, not persisted phases or mandatory separate tool calls. Edit only what needs writeback; required updates cannot be waived. Resolve stale statements from verified outcomes. Preserve settled planning, unrelated style and original evidence/verdict owners; add no no-op reports. Author checks establish no independent review.
 
@@ -75,10 +75,7 @@ Create or update a Decision Record only for a hard-to-reverse or surprising choi
 
 Never use generated indexes, archives, or the managed RSP block as ordinary writeback targets. Keep narrative history, debugging notes, task chronology, and transient evidence out of Specs and Decisions.
 
-## Prepare the Change for archive
+## Return the convergence result
 
-Before archive, require the converged final Change, completed or unnecessary knowledge writeback, applicable passing verification, current readiness and every separately required Review clean. Authorized archive preserves Change and clears its Focus marker; clearing the Capsule cannot substitute for writeback. Archive grants no local commit authority.
-
-## Deliver with explicit boundaries
-
-[Delivery closeout](closeout.md) owns checkpoint/final classification, the ask/auto/manual closure decision, Group-close sequence and exact Git handoff. Ordinary completion leaves work open. Apply the selected policy and current gates regardless of delegation. Git delivery separately needs explicit authority for one independently reviewable logical commit; closure grants none. Reuse applicable evidence.
+Return the converged records and unresolved gaps to [delivery closeout](closeout.md),
+which owns the closure decision, archive gates and Git handoff.

package/skills/rsp/references/work-model.md

@@ -4,9 +4,9 @@ Read when selecting, reporting or operating a tracked RSP owner, or writing/revi
 
 ## Work shapes
 
-Direct work is a clear bounded request without durable continuity needs. Change retains one acceptance/delivery boundary for sustained work or recovery. Group coordinates independently acceptable/deliverable child Changes with dependencies or integration obligations. Complexity, file count and worker count alone select neither Group nor delegation. Agent topology is a separate execution choice.
+Direct handles local explicit modifications. Change retains one acceptance/delivery boundary whose related implementation decisions or actual staged, handoff or deferred obligations need a shared record. Session duration, interface edits and strict verification alone do not select a Change; independent slices are not required. Group coordinates independently acceptable/deliverable child Changes with dependencies or integration obligations. Complexity, file count and worker count alone select neither Group nor delegation. Agent topology is a separate execution choice. Core owns selection and scope reassessment; existing ownership follows the same outcome or remaining obligations, not shared paths.
 
-Ordinary completion and checkpoint commits leave a Change open. Final delivery or an explicit close request uses the closeout policy; reopen is exceptional recovery, not the normal iteration path.
+Ordinary completion and checkpoint commits leave a Change open. A tracked commit with completed Tasks, established final delivery or an explicit close request uses the closeout policy. Task completion triggers the decision even when verification remains incomplete; eligibility still gates archive. Reopen is exceptional recovery, not the normal iteration path.
 
 ## Identity and ownership
 
@@ -31,7 +31,7 @@ Use only the selected owner's relevant artifacts and authoritative project conte
 A Change retains six sections: Proposal, Spec, Design, Tasks, Verify and Blockers. During work it states the current authorized intent, approach and actual progress; at closeout it records the delivered outcome. Update affected content as facts change instead of appending rounds, dates or session summaries. Keep a date only when it matters to provenance or applicability. Record cleanup never authorizes dropping unmet scope or acceptance obligations.
 
 - **Tasks:** keep current checkable work and completion. Replace, split or merge tasks within authorized scope; reopen or rewrite invalidated results. Routine attempts, fixes, retries and individual check runs are not new tasks. Completion proves neither verification nor independent or human acceptance.
-- **Verify:** keep declared acceptance checks and their required/optional distinction, then retain only information needed to judge acceptance, evidence applicability or locate necessary evidence. Do not restate results already expressed by check items. Commands, counts, candidate/environment details and review steps belong here only when their omission would change those judgments or prevent that lookup; occurrence alone is no reason to retain them. Replace superseded conclusions only within their covered scope, preserve still-applicable reused evidence, and distinguish full review, correction-only re-review and human acceptance. Mark invalidated coverage incomplete. Keep shared evidence once and detailed execution/review records with their existing owner; no run history or debugging narrative.
+- **Verify:** allow only Required/Optional checklists and an optional `### Conclusions` with short, non-nested bullets. No prose paragraphs, tables, logs or process subsections. Check applicable passes; uncheck failed, unrun or invalidated coverage. Revise check items when authorized scope or acceptance changes without dropping unmet obligations. An item may include a brief result or evidence locator, not repeated results, run counts or repair history. Conclusions hold only current acceptance limits, evidence applicability conditions or required failure dispositions that the checklist cannot express; one fact per bullet. Replace stale conclusions rather than append rounds. Preserve full-review, correction-only re-review and human-acceptance scope. Remove resolved findings unless they still affect acceptance, evidence reuse or required audit. Keep detailed evidence with its existing owner.
 - **Focus:** keep only additional context needed to resume safely or avoid costly repeated discovery; refer to Change state without maintaining a second task, verification or blocker list. The conditional [Focus method](focus-continuation.md) owns replacement and cleanup. Ordinary progress needs no snapshot.
 
-Keep decision rationale, useful before/after outcome comparisons and material failure dispositions with their existing owner. For resolved ordinary failures, remove the attempt narrative; preserve any effect on acceptance or evidence validity. Routine history stays in conversation and raw evidence with its existing owner. Removing stale prose does not delete reports, conversation or Git history, require a new log, or move discarded history into Focus or an appendix.
+Keep decision rationale and useful outcome comparisons in their owning sections; they do not exempt Verify text from the admission rule above. Do not relocate discarded narration into another section, Focus, an appendix or a new report. Prose cleanup does not remove tests, raw evidence, reports, conversation or Git history.

package/skills/rsp-commit/SKILL.md

@@ -4,7 +4,7 @@ description: Inspect or create one authorized exact-scope local commit for direc
 license: MIT
 metadata:
   author: oevery
-  version: "2026.10.16.1"
+  version: "2026.11.06.1"
 ---
 
 # RSP Commit
@@ -36,7 +36,7 @@ Purpose is separate from kind:
 - A checkpoint keeps the Change open and delivers a verified current slice without claiming completed acceptance, closing an issue or requiring archive.
 - A terminal delivery claims completion only for its selected boundary. Tracked terminal inputs require complete Tasks, decisive Required Verify and no active blocker; legacy unclassified Verify is Required. Optional omissions remain explicit but do not block. Direct work uses its own acceptance, not an invented lifecycle gate.
 
-A generic commit request is a checkpoint unless final delivery is already established. For tracked final delivery, resolve the closure decision through [Core closeout](../rsp/references/closeout.md) before staging, including direct invocation; do not repeat an already settled decision. Commit pauses for its owning capability to perform necessary writing or authorized lifecycle work. Lifecycle authority stays upstream. If terminal delivery includes authorized archive or Group closeout, require that action and its inspected diff before staging. Do not archive, update Specs or clean up a Change inside Commit. A valid explicitly authorized local commit without lifecycle authority does not gain it or require an invented archive.
+Before staging a tracked commit, inspect the selected owner's Tasks and actual remaining scope. Incomplete Tasks select a checkpoint; all Tasks complete selects [Core closeout](../rsp/references/closeout.md), even when Required checks or review are incomplete or failed. Generic commit wording must not bypass that decision. Reuse an explicit applicable checkpoint or closure choice; do not ask twice. For multiple included WorkRefs, assess their boundaries separately rather than infer Group completion. Commit pauses for its owning capability to correct stale records, perform necessary writing or authorized lifecycle work. If terminal delivery includes authorized archive or Group closeout, require that action and its inspected diff before staging. Do not archive, update Specs or clean up a Change inside Commit. A checkpoint still needs its own applicable verification; absent lifecycle authority neither grants closure nor prohibits an otherwise authorized checkpoint.
 
 ## Audit before staging
 

package/skills/rsp-doc/SKILL.md

@@ -25,7 +25,7 @@ Write a grounded artifact usable without the author conversation. Use the artifa
 - README and procedures supply the starting point, prerequisites, actions and recognizable success. Concepts and decisions explain meanings, reasons, alternatives and consequences; references supply exact, navigable contracts.
 - CONTEXT defines vocabulary and relationships and directs readers to authoritative owners. Specs state what consumers may rely on, including conditions, failures and exceptions; add scenarios only to resolve ambiguity. Scoped operating instructions own commands, authority and required checks.
 - For architecture models or changes to their bound documents, use [architecture knowledge](../rsp/references/architecture.md) for synchronization and reference checks.
-- Before writing a Change, load the [current work record rules](../rsp/references/work-model.md#current-work-records) when absent from context; the same resource owns Blockers syntax. Keep its six sections current during iteration and reconcile the whole record for closeout. Readers must find the outcome, applicable evidence and remaining work without reconstructing attempts; preserve useful before/after results and decision reasons when removing chronology.
+- Before writing a Change, load the [current work record rules](../rsp/references/work-model.md#current-work-records) when absent from context; the same resource owns Verify admission and Blockers syntax. Keep its six sections current during iteration and reconcile the whole record for closeout. Apply those rules to existing text as well as additions.
 
 ## Check facts and reading paths
 

package/skills/rsp-implement/SKILL.md

@@ -79,7 +79,7 @@ After final mutation, establish minimum sufficient evidence for tracked Required
 
 - Reuse traceable passing results when the tested boundary and relevant code, dependencies, configuration, tools, inputs and environment still apply. Phase changes and unrelated edits do not invalidate evidence.
 - Run missing, failed or invalidated checks and risk-justified additions, including checks affected by integration. Named checks retain their method and coverage; explicit reruns and independent execution remain binding.
-- For an unfixed method, choose the cheapest decisive existing test, static check, build or acceptance evidence; a new test is not required.
+- If no verification method is prescribed, choose the lowest-cost existing test, static check, build or other evidence that decisively establishes acceptance. A new test is not required.
 - Match the actual target, inputs, coverage and completion to the declared check. Invocation errors or incomplete observations do not by themselves prove a product defect. Record command, tested scope, result, source and omissions, distinguishing reused evidence from new execution. Failed, unavailable or untraceable evidence cannot establish completion.
 
 Before completion, apply the same admission criteria to retained tests. Remove disposable probes, fixtures and helpers that add no distinct future confidence unless retention is required by user, Change or project authority; establish sufficient evidence for the final retained state.

package/skills/rsp-review/SKILL.md

@@ -29,7 +29,7 @@ The user request fixes the requested outcome and allowed operations subject to n
 
 ## Select perspectives before loading
 
-Select methods from the judged content and its risks. Supporting references inform the judgment without becoming additional review targets. Respect narrower requested scope and reuse applicable instructions already in context.
+Select methods from the judged content and its risks. Two perspectives require neither two reports nor two reviewers. Supporting references inform the judgment without becoming additional review targets. Respect narrower requested scope and reuse applicable instructions already in context.
 
 - **[Code](references/code-review.md):** behavior, contracts, safety and failures of executable content; also ownership, dependency and verification lenses for explicitly bounded structural discovery. Within change review, structural inspection stays with a concrete risk in the fixed boundary. A prose behavior claim alone can remain Document grounding.
 - **[Document](references/document-review.md):** factual explanation, usability, navigation and maintenance of reviewed content, including API/TSDoc comments, requirements and human- or agent-facing guidance.
@@ -39,11 +39,11 @@ When fixed reviewed artifacts include changelogs, release notes, migration guide
 
 ## Inspect the fixed scope
 
-Inspect checkout state and the selected diff or structural boundary, then authority, then the smallest behavior chain and evidence needed for the question. Match checks to each perspective, actual content and changed risk. Report a comment/implementation or example/contract discrepancy once, with evidence from both sides; presume neither correct. Stop when applicable judgments are supported. Do not broaden scope or execute snippets without authority.
+Inspect checkout state and the selected diff or structural boundary, then authority, then the smallest behavior chain and evidence needed for the question. Report a comment/implementation or example/contract discrepancy once, with evidence from both sides; presume neither correct. Stop when applicable judgments are supported. Do not broaden scope or execute snippets without authority.
 
-When the reviewed scope affects modeled structure, responsibilities, dependencies or bindings, apply [architecture knowledge](../rsp/references/architecture.md) within that scope.
+Reuse traceable check evidence while its tested scope and relevant code, dependencies, configuration, tools, inputs and environment still apply. Before running an authorized check, identify the evidence gap, invalidated result, changed risk or explicit execution requirement it addresses. Apply this selection to tests and non-test checks alike; low cost alone does not justify extra execution. Distinguish reused evidence from new observations.
 
-Reuse traceable test evidence while its tested scope and relevant code, dependencies, configuration, tools, inputs and environment still apply. Run authorized checks only for gaps, invalidated results, changed risk or explicitly required execution. Distinguish reused evidence from new observations.
+When the reviewed scope affects modeled structure, responsibilities, dependencies or bindings, apply [architecture knowledge](../rsp/references/architecture.md) within that scope.
 
 For re-review, inspect the actual correction and affected behavior against the original scope, expanding within it for evidenced consequences. Earlier clean verdicts do not establish a changed target; unchanged tests need no rerun solely for a new judgment. Perform the requested semantic review: neither passing tests nor an implementer summary supplies that judgment or required independence.
 
@@ -53,7 +53,7 @@ Missing comparison or authority blocks dependent pipelines; other gaps follow th
 
 ## Report
 
-Responses follow explicit language instruction, personal instructions, then conversation language, never project artifact-language settings. Preserve paths, commands, identifiers, WorkOwner/WorkRefs, `P0`-`P3` and `issues_found | clean | skipped | blocked`; use localized narration with differing machine values as secondary exact tokens.
+Responses follow explicit language instruction, personal instructions, then conversation language, never project artifact-language settings. Preserve paths, commands, identifiers, WorkOwner/WorkRefs and `P0`-`P3`; use localized narration with differing machine values as secondary exact tokens. Use `blocked | findings | clean` for the overall verdict. For per-file or per-perspective results, preserve the caller's required schema, including `issues_found` or `skipped` where specified.
 
 Preserve the information below without mandatory headings or one line per field. Use a compact report for a clean bounded review, omit empty Findings and unrelated no-op fields, and honor explicitly required formats:
 
@@ -62,7 +62,7 @@ Preserve the information below without mandatory headings or one line per field.
 - Coverage: each perspective's checked content, material omissions and unverified scope, including non-actionable gaps; distinguish reused evidence from new observations.
 - Verdict: `blocked | findings | clean`; give the next action only when an issue, blocker or requested follow-up remains. Do not repeat the findings or evidence.
 
-Use `clean` only for an applicable judgment with no actionable issue, `skipped` for an inapplicable perspective when the requested format requires it, and `blocked` when required scope, authority or decisive evidence is missing. Findings may establish a defect, an explicit-requirement violation, or an evidenced simplification; fewer lines alone, speculative impact and taste-only cleanup do not qualify. Do not invent a wrong-result bug for a supported simplification. Missing evidence alone is a coverage limit. Retain supported findings while blocking only affected judgments. Two perspectives require neither two reports nor two reviewers.
+Use `clean` only for an applicable judgment with no actionable issue, `skipped` for an inapplicable perspective when the requested format requires it, and `blocked` when required scope, authority or decisive evidence is missing. Findings may establish a defect, an explicit-requirement violation, or an evidenced simplification; fewer lines alone, speculative impact and taste-only cleanup do not qualify. Do not invent a wrong-result bug for a supported simplification. Missing evidence alone is a coverage limit. Retain supported findings while blocking only affected judgments.
 
 Order findings by severity and path: P0 critical security/data/breakage risk; P1 normal-path contract failure; P2 meaningful edge/maintenance risk; P3 narrow actionable improvement. Assess findings by consequence and confidence, not lines removed or ease of correction.
 

package/skills/rsp-review/references/document-review.md

@@ -17,9 +17,9 @@ Classify each document by its semantic role: requirement/Change, implementation
 
 Check ownership by meaning, not file shape. CONTEXT owns canonical terms, domain relationships, and navigation; AGENTS owns operating rules; README owns introduction and usage. Specs own current contracts and necessary constraints, including design-reference tables when they define normative evidence. Change Spec owns only the delta and acceptance; Design owns the approach, Tasks the work, and Verify the evidence. Decision Records own rationale. Short summaries and references are valid; parallel full definitions are not.
 
-Within fixed work-record scope, load the [current work record rules](../../rsp/references/work-model.md#current-work-records) when absent from context. Check that Tasks reflects current work, each Verify detail serves acceptance, applicability or necessary evidence lookup without repeating check results, and Focus contains only additional recovery context without a second state list or execution timeline. A record can still contain unnecessary execution detail without chronological headings. Preserve useful before/after comparisons, material failure dispositions and distinct review/acceptance boundaries. When judging blockers/readiness, compare actual impediments and the declaration with parsed state under the same work model. A claim of no blockers that parses as blocked is an inconsistency.
+Within fixed work-record scope, load the [current work record rules](../../rsp/references/work-model.md#current-work-records) when absent from context. Check Tasks, Verify and Focus against their respective rules, including current limits and stale conclusions. Existing text has no exemption. When judging blockers/readiness, compare actual impediments and the declaration with parsed state under the same work model. A claim of no blockers that parses as blocked is an inconsistency.
 
-For closeout, inspect the final whole Change or archived artifact after needs-based writeback, not only added Verify lines or an earlier candidate. Check that any writeback uses verified results, necessary knowledge corrections are complete and the final Change reflects them without duplicating current specifications. Already-accurate knowledge needs no edit; required corrections cannot be waived. Whole-Change convergence removes stale operation permissions, attempt/session chronology and response-only handoff/readiness blocks while retaining the contract delta, material failures, version-bound results and evidence references. Return substantive inconsistencies to their owner; prose cleanup cannot resolve them. Do not hide failures, relabel reports or grant cleanup authority. CLI readiness cannot establish this semantic result.
+For closeout, inspect the final whole Change or archived artifact after needs-based writeback, not only added Verify lines or an earlier candidate. Check that any writeback uses verified results, necessary knowledge corrections are complete and the final Change reflects them without duplicating current specifications. Already-accurate knowledge needs no edit; required corrections cannot be waived. Whole-Change convergence follows the current work record rules and removes stale operation permissions and response-only handoff/readiness blocks. Return substantive inconsistencies to their owner; prose cleanup cannot resolve them. Do not conceal unmet checks or limits, relabel reports or grant cleanup authority. CLI readiness cannot establish this semantic result.
 
 Specialized Spec headings and omitted unnecessary scenarios are not defects; scaffold hints are optional writing aids, not requirements or evidence. Material promises, decisions, and limits must remain visible outside comments. Do not request extra sections, tests, or bulk historical rewrites merely for template conformity.
 

package/skills/rsp-shape/references/planning.md

@@ -16,7 +16,7 @@ Keep one observable outcome per Change:
 - `Spec`: settled contract delta and acceptance, referencing affected existing Specs rather than copying the baseline or inventing public promises;
 - `Design`: approach, responsibility boundaries, and necessary tradeoffs, not repeated requirements or tasks;
 - `Tasks`: current checkable work, with prescribed order only where correctness, safety, or migration requires it;
-- `Verify`: required/optional checks proving settled acceptance, not adding new public requirements; then applicable scoped results and gaps;
+- `Verify`: settled acceptance evidence under the current work record rules below; do not introduce new public requirements;
 - `Blockers`: dependencies and decisions, or `none`.
 
 Keep the six sections; small changes need only proportionate content. Plain-prose HTML scaffold hints may remain or be removed; they guide writing, never supply requirements, evidence, or completed content. Resolve body placeholders and keep all material decisions visible outside comments.
@@ -35,7 +35,7 @@ A Change is ready only when:
 - product and mutation authority are settled;
 - affected boundaries and material constraints are known;
 - no hidden assumption can change implementation or acceptance;
-- Tasks are executable without performing them;
+- Tasks are concrete enough for implementation to begin. Shaping does not execute them;
 - Verify proves the result without process chronology; Blockers are truthful;
 - one Change or a justified shallow Group is the smallest sufficient owner.
 

package/skills/rsp-verify/SKILL.md

@@ -62,6 +62,6 @@ Long-running verification remains active while its boundary and stop conditions
 
 ## Stop and return
 
-Stop when evidence is missing, the environment is unavailable, the boundary changes or a required check cannot be observed. Use the caller's canonical stop reason only when supplied. For direct invocation, identify the missing input or changed boundary and the required next action; do not invent a completed verification result before the declared boundary is established.
+Stop the affected verification if required evidence cannot be collected or observed, the required environment is unavailable, or the declared boundary changes. Use the caller's canonical stop reason only when supplied. For direct invocation, identify the missing input or changed boundary and the required next action; do not invent a completed verification result before the declared boundary is established.
 
 On cancellation, wait until the command or owned process is observed stopped before beginning conflicting work. Return the result, decisive evidence, omissions and next action to the caller or user. Retry only with new evidence and safe replay inside the declared boundary.

package/dist/chunk-U56XMIOO.mjs

@@ -1,66 +0,0 @@
-#!/usr/bin/env node
-import {
-  PKG_ROOT
-} from "./chunk-P3KO3GZW.mjs";
-
-// src/viewer/runtime.ts
-import { createHash } from "crypto";
-import { readdir, readFile, realpath } from "fs/promises";
-import { homedir } from "os";
-import { join, sep } from "path";
-var VIEWER_PROTOCOL = 1;
-async function viewerRuntime(installation = PKG_ROOT) {
-  const root = await realpath(installation);
-  const { version } = JSON.parse(await readFile(join(root, "package.json"), "utf8"));
-  const build = (await readFile(join(root, "dist/viewer-build.json"), "utf8")).trim();
-  const identity = createHash("sha256").update(JSON.stringify({ root, version, build, protocol: VIEWER_PROTOCOL })).digest("hex");
-  const directory = join(homedir(), ".cache", "rsp", "viewer");
-  return { root, version, build, identity, directory, recordPath: join(directory, `${identity}.json`), lockPath: join(directory, `${identity}.lock`) };
-}
-async function snapshotViewerRuntime(root, identity) {
-  const runtime = await viewerRuntime(root);
-  if (runtime.identity !== identity)
-    throw new Error("Viewer build changed during startup; retry");
-  const hash = createHash("sha256");
-  const assets = /* @__PURE__ */ new Map();
-  for (const file of (await readdir(join(root, "dist"), { recursive: true })).map((file2) => file2.split(sep).join("/")).sort()) {
-    if (!/\.(?:mjs|js|css)$/.test(file))
-      continue;
-    const content = await readFile(join(root, "dist", file));
-    hash.update(file).update(content);
-    if (file === "viewer/app.js" || file === "viewer/app.css")
-      assets.set(`/${file.slice("viewer/".length)}`, content);
-  }
-  if (hash.digest("hex") !== JSON.parse(runtime.build).identity || assets.size !== 2 || (await viewerRuntime(root)).identity !== identity) {
-    throw new Error("Viewer assets do not match the startup build; rebuild or reinstall and retry");
-  }
-  return { version: runtime.version, assets };
-}
-async function serviceRequest(record, path, body, timeoutMs = 2500) {
-  const response = await fetch(`http://127.0.0.1:${record.port}${path}`, { method: body === void 0 ? "GET" : "POST", headers: { Authorization: `Bearer ${record.adminToken}`, ...body === void 0 ? {} : { "Content-Type": "application/json" } }, ...body === void 0 ? {} : { body: JSON.stringify(body) }, signal: AbortSignal.timeout(timeoutMs) });
-  if (!response.ok)
-    throw new Error(await response.text());
-  const result = await response.json();
-  if (result.identity !== record.identity || result.protocol !== VIEWER_PROTOCOL)
-    throw new Error("Viewer identity/protocol mismatch");
-  return result;
-}
-async function discoverService(path, identity) {
-  try {
-    const record = JSON.parse(await readFile(path, "utf8"));
-    if (record.identity !== identity || record.protocol !== VIEWER_PROTOCOL || !Number.isInteger(record.port) || record.port < 1 || record.port > 65535 || typeof record.adminToken !== "string")
-      return null;
-    await serviceRequest(record, "/control/status");
-    return record;
-  } catch {
-    return null;
-  }
-}
-
-export {
-  VIEWER_PROTOCOL,
-  viewerRuntime,
-  snapshotViewerRuntime,
-  serviceRequest,
-  discoverService
-};