@oevery/rsp 3.3.0 → 4.0.0

package/dist/{entry-GIDNR7CJ.mjs → entry-RIJQ2X46.mjs}

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import {
   ArchiveHistoryError,
+  CHANGES_DIR,
   SPECS_DEFAULT_RESULT_LIMIT,
   SPECS_SEARCH_EXCERPT_CODE_POINTS,
   WorkRefError,
@@ -8,7 +9,10 @@ import {
   inspectArchiveHistory,
   inspectProjectStatus,
   inspectSpecs,
+  isMarkdownComment,
+  markdownText,
   normalizeLogicalPath,
+  parseMarkdown,
   projectDependencyForest,
   projectSpecsDetail,
   projectSpecsSearch,
@@ -17,16 +21,7 @@ import {
   readArchiveHistoryDetail,
   readArchiveHistoryDocument,
   resolveWorkRefPath
-} from "./chunk-TSUDEX5Y.mjs";
-import {
-  displayWidth,
-  openTerminalSession,
-  truncateDisplay,
-  wrapDisplay
-} from "./chunk-JOMFFQRG.mjs";
-import {
-  CHANGES_DIR
-} from "./chunk-7HXQNBIG.mjs";
+} from "./chunk-HFSTLCCK.mjs";
 
 // src/tui/entry.tsx
 import process from "process";
@@ -37,6 +32,81 @@ import React from "react";
 import { Box as Box3, Text as Text3, useApp, useInput, useStdout } from "ink";
 import { useCallback, useEffect, useMemo, useReducer, useRef, useState } from "react";
 
+// src/tui/display.ts
+var segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function isWide(codePoint) {
+  return codePoint >= 4352 && (codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 42191 && codePoint !== 12351 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65135 || codePoint >= 65280 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 127744 && codePoint <= 129791 || codePoint >= 131072 && codePoint <= 262141);
+}
+function displayWidth(value) {
+  let width = 0;
+  for (const { segment } of segmenter.segment(value)) {
+    const codePoint = segment.codePointAt(0) ?? 0;
+    if (/^\p{Mark}$/u.test(segment) || codePoint === 8205)
+      continue;
+    width += isWide(codePoint) ? 2 : 1;
+  }
+  return width;
+}
+function truncateDisplay(value, maxWidth) {
+  if (displayWidth(value) <= maxWidth)
+    return value;
+  if (maxWidth <= 1)
+    return "\u2026".slice(0, maxWidth);
+  let result = "";
+  for (const { segment } of segmenter.segment(value)) {
+    if (displayWidth(result + segment) > maxWidth - 1)
+      break;
+    result += segment;
+  }
+  return `${result}\u2026`;
+}
+function wrapDisplay(value, maxWidth, firstPrefix = "", continuationPrefix = firstPrefix) {
+  const width = Math.max(1, maxWidth);
+  if (displayWidth(firstPrefix) >= width)
+    return [truncateDisplay(`${firstPrefix}${value}`, width)];
+  const lines = [];
+  let prefix = firstPrefix;
+  let line = prefix;
+  const pushLine = () => {
+    lines.push(line);
+    prefix = continuationPrefix;
+    line = prefix;
+  };
+  const appendUnbroken = (token) => {
+    for (const { segment } of segmenter.segment(token)) {
+      if (displayWidth(line + segment) > width && line !== prefix)
+        pushLine();
+      if (displayWidth(line + segment) > width) {
+        lines.push(truncateDisplay(line + segment, width));
+        prefix = continuationPrefix;
+        line = prefix;
+        continue;
+      }
+      line += segment;
+    }
+  };
+  let pendingWhitespace = "";
+  for (const token of value.split(/(\s+)/u).filter(Boolean)) {
+    if (token.trim().length === 0) {
+      if (line !== prefix)
+        pendingWhitespace += token;
+      continue;
+    }
+    const separator = line === prefix ? "" : pendingWhitespace;
+    if (displayWidth(line + separator + token) <= width) {
+      line += `${separator}${token}`;
+    } else {
+      if (line !== prefix && separator)
+        pushLine();
+      appendUnbroken(token);
+    }
+    pendingWhitespace = "";
+  }
+  if (line !== prefix || lines.length === 0)
+    lines.push(line);
+  return lines;
+}
+
 // src/tui/history-display.ts
 function formatHistoryRow(record, width) {
   const boundedWidth = Math.max(1, width);
@@ -138,18 +208,17 @@ function projectHistoryEvidence(evidence, options) {
 }
 
 // src/tui/markdown-presentation.ts
-import { fromMarkdown } from "mdast-util-from-markdown";
-import { gfmFromMarkdown } from "mdast-util-gfm";
-import { gfm } from "micromark-extension-gfm";
 var EMPTY_LINE = { spans: [{ text: "" }] };
 var graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
 function markdownLineText(line) {
   return line.spans.map((span) => span.text).join("");
 }
 function projectMarkdownLines(content, width) {
-  const root = fromMarkdown(sanitizeMarkdown(stripFrontmatter(content)), { extensions: [gfm()], mdastExtensions: [gfmFromMarkdown()] });
+  const root = parseMarkdown(sanitizeMarkdown(content)).root;
   const logical = [];
   root.children.forEach((node, index) => {
+    if (node.type === "yaml" || isMarkdownComment(node))
+      return;
     if (index > 0 && logical.length > 0 && markdownLineText(logical.at(-1)) !== "")
       logical.push(EMPTY_LINE);
     logical.push(...projectBlock(node, 0, Math.max(1, width)));
@@ -173,9 +242,6 @@ function projectMarkdownLineViewport(lines, options) {
     hasNext: end < lines.length
   };
 }
-function stripFrontmatter(content) {
-  return content.replace(/^---\r?\n[\s\S]*?\r?\n(?:---|\.\.\.)\r?\n/u, "");
-}
 function sanitizeMarkdown(value) {
   let result = "";
   for (let index = 0; index < value.length; index++) {
@@ -222,7 +288,7 @@ function projectBlock(node, depth, width) {
     case "table":
       return projectTable(node, width);
     case "html":
-      return [metavariableLine(node.value) ?? { spans: [{ text: node.value, dim: true }] }];
+      return [metavariableLine(node.value) ?? { spans: [{ text: markdownText(node).trim(), dim: true }] }];
     default:
       return "children" in node ? inlineLines(node.children.filter((child) => isPhrasing(child))) : [];
   }
@@ -263,11 +329,13 @@ function inlineLines(children, style = {}, prefix = "") {
   return lines;
 }
 function projectInline(node, inherited) {
+  if (isMarkdownComment(node))
+    return [];
   switch (node.type) {
     case "text":
       return [{ text: node.value, ...inherited }];
     case "html":
-      return metavariableSpan(node.value, inherited) ?? [{ text: node.value, ...inherited, dim: true }];
+      return metavariableSpan(node.value, inherited) ?? [{ text: markdownText(node), ...inherited, dim: true }];
     case "inlineCode":
       return [{ text: node.value, ...inherited, code: true, color: "cyan" }];
     case "break":
@@ -751,16 +819,8 @@ function projectItemDependencyForest(item, snapshot) {
   const forest = projectDependencyForest(snapshot.plan, roots);
   return item.type === "change" ? forest[0]?.children ?? [] : forest;
 }
-function projectExternalBlockers(item, snapshot) {
-  if (item.type !== "change")
-    return [];
-  const edges = snapshot.plan.edges.filter((edge) => edge.change === item.workRef);
-  return item.record.blockerEntries.filter((entry) => {
-    const dependency = entry.match(/^requires\s+`([^`]+)`:\s*(\S.*)$/i);
-    if (!dependency)
-      return true;
-    return !edges.some((edge) => edge.requires === dependency[1] && edge.reason === dependency[2]);
-  });
+function projectExternalBlockers(item) {
+  return item.type === "change" ? item.record.externalBlockers : [];
 }
 function projectNextAction(item, snapshot) {
   if (item.type === "history")
@@ -808,9 +868,7 @@ function projectWorkDetailLines(item, snapshot, messages, width) {
     add(messages.none);
   if (item.type === "group")
     add(`${messages.changes}: ${item.group.slices.length ? item.group.slices.map((slice) => `${slice.name} (${slice.state})`).join(", ") : messages.none}`);
-  const external = projectExternalBlockers(item, snapshot);
-  const blockers = external.length ? external.join("; ") : item.type === "group" && item.group.blockers || snapshot.plan.blocked.some((blocked) => blocked.change === item.workRef && blocked.external) ? messages.yes : messages.none;
-  add(`${messages.blockers}: ${blockers}`);
+  add(`${messages.blockers}: ${blockersLabel(item, snapshot, messages)}`);
   const next = projectNextAction(item, snapshot);
   add(`${next.kind === "command" ? messages.nextCommand : next.kind === "blocked" ? messages.nextAction : messages.reviewGroupBrief}: ${next.kind === "blocked" ? messages.awaitingOwnerDecision : next.value}`);
   return lines;
@@ -821,6 +879,13 @@ function workStateLabel(item, snapshot, messages) {
   const state = projectItemState(item, snapshot);
   return (state.focused ? [messages.focused, messages[state.execution]] : [messages[state.execution]]).join(" \xB7 ");
 }
+function blockersLabel(item, snapshot, messages) {
+  const external = projectExternalBlockers(item);
+  if (external.length)
+    return external.join("; ");
+  const inherited = item.type === "group" && item.group.blockers || snapshot.plan.blocked.some((blocked) => blocked.change === item.workRef && blocked.external);
+  return inherited ? messages.yes : messages.none;
+}
 function dependencySymbol(node, snapshot) {
   if (snapshot.focused.includes(node.name))
     return "\u25CE";
@@ -861,9 +926,8 @@ function WorkDetail({ expanded, item, messages, snapshot, width }) {
   if (!item || item.type === "history")
     return /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: messages.noWork });
   const forest = projectItemDependencyForest(item, snapshot);
-  const externalBlockers = projectExternalBlockers(item, snapshot);
   const nextAction = projectNextAction(item, snapshot);
-  const blockers = externalBlockers.length ? externalBlockers.join("; ") : item.type === "group" && item.group.blockers || snapshot.plan.blocked.some((blocked) => blocked.change === item.workRef && blocked.external) ? messages.yes : messages.none;
+  const blockers = blockersLabel(item, snapshot, messages);
   return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", paddingLeft: 1, width, children: [
     /* @__PURE__ */ jsxs2(Text2, { bold: true, children: [
       messages.detail,
@@ -982,10 +1046,16 @@ function scopeNavigation(scope, messages, width) {
   const navigation = labels.map(([candidate, label]) => candidate === scope ? `[${label}]` : label).join(" ");
   return truncateDisplay(`${messages.title}  ${navigation}`, width);
 }
+function terminalDimensions(stdout) {
+  return {
+    width: "columns" in stdout && typeof stdout.columns === "number" ? stdout.columns : 80,
+    height: "rows" in stdout && typeof stdout.rows === "number" ? stdout.rows : 24
+  };
+}
 function DashboardApp({ initialDimensions, initialSnapshot, inspectHistory, inspectHistoryDetail, inspectHistoryDocument, inspectStatus, messages, specsSource, workSource }) {
   const { exit } = useApp();
   const { stdout } = useStdout();
-  const dimensions = initialDimensions ?? { width: stdout.columns ?? 80, height: stdout.rows ?? 24 };
+  const dimensions = initialDimensions ?? terminalDimensions(stdout);
   const [state, dispatch] = useReducer(reduceDashboard, initialDashboardState(initialSnapshot, dimensions));
   const filterRefs = useRef({ work: "", specs: "", history: "" });
   const refreshing = useRef(false);
@@ -1182,7 +1252,7 @@ function DashboardApp({ initialDimensions, initialSnapshot, inspectHistory, insp
     }
   }, [detailDocumentState, inspectHistoryDocument, selected, state.scope, workSource]);
   useEffect(() => {
-    const resize = () => dispatch({ type: "resize", width: stdout.columns ?? 80, height: stdout.rows ?? 24 });
+    const resize = () => dispatch({ type: "resize", ...terminalDimensions(stdout) });
     stdout.on("resize", resize);
     return () => {
       stdout.off("resize", resize);
@@ -1655,6 +1725,22 @@ function createTuiSpecsSource(dependencies = defaultDependencies2) {
   };
 }
 
+// src/tui/terminal.ts
+function openTerminalSession(stdout, options) {
+  let cleaned = false;
+  if (!options.screenReader)
+    stdout.write("\x1B[?1049h\x1B[?25l");
+  return {
+    cleanup() {
+      if (cleaned)
+        return;
+      cleaned = true;
+      if (!options.screenReader)
+        stdout.write("\x1B[?25h\x1B[?1049l");
+    }
+  };
+}
+
 // src/tui/work-source.ts
 import { Buffer } from "buffer";
 import { constants } from "fs";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oevery/rsp",
   "type": "module",
-  "version": "3.3.0",
+  "version": "4.0.0",
   "description": "RSP (Reliable Software Practice), a repository-native engineering workflow for humans and AI agents",
   "author": "oevery",
   "license": "MIT",
@@ -29,7 +29,6 @@
   "files": [
     "bin/",
     "dist/",
-    "rules/",
     "skills/"
   ],
   "engines": {
@@ -37,12 +36,10 @@
   },
   "scripts": {
     "prepare": "pnpm run build",
-    "release:acceptance": "node scripts/release-acceptance.mjs",
-    "release:behavior-check": "node scripts/release-behavior-acceptance.mjs",
-    "release:provider-compare": "node scripts/release-provider-comparison.mjs",
-    "release:candidate-check": "node scripts/release-candidate-check.mjs && node scripts/release-behavior-evidence-check.mjs && pnpm run release:acceptance",
-    "skills:security-check": "node scripts/skill-security-preflight.mjs --suppressions skill-security-suppressions.json",
-    "prepublishOnly": "pnpm run release:candidate-check",
+    "skills:security-check": "node scripts/skill-security-preflight.mjs",
+    "skills:package-check": "node scripts/skill-package-check.mjs",
+    "prepublishOnly": "pnpm run release:check",
+    "release": "release-it",
     "build": "tsup",
     "dev": "tsup --watch",
     "docs:build": "vitepress build docs",
@@ -53,30 +50,41 @@
     "lint": "eslint .",
     "lint:fix": "eslint --fix .",
     "typecheck": "tsc --noEmit",
-    "test": "pnpm run build && vitest run",
-    "test:watch": "vitest --config vitest.watch.config.ts"
+    "test": "pnpm run build && pnpm run test:code",
+    "test:code": "vitest run --no-file-parallelism",
+    "test:diagnostics": "vitest run --config tests/diagnostics/vitest.config.ts",
+    "test:pack": "node tests/code/package/package-check.mjs",
+    "test:skills": "uv run --frozen --project tests/skills python tests/skills/evaluate.py",
+    "release:check": "pnpm run build && pnpm run typecheck && pnpm run lint && pnpm run test:code && pnpm run test:skills check && pnpm run skills:security-check && pnpm run docs:check"
   },
   "dependencies": {
     "citty": "^0.2.2",
-    "ink": "~7.1.1",
-    "mdast-util-from-markdown": "2.0.3",
-    "mdast-util-gfm": "3.1.0",
-    "micromark-extension-gfm": "3.0.0",
+    "hast-util-from-html": "^2.0.3",
+    "ink": "~8.0.0",
+    "mdast-util-from-markdown": "^2.1.0",
+    "mdast-util-frontmatter": "^2.0.1",
+    "mdast-util-gfm": "^3.1.0",
+    "micromark-extension-frontmatter": "^2.0.0",
+    "micromark-extension-gfm": "^3.0.0",
     "picocolors": "^1.1.1",
-    "react": "~19.2.8",
-    "yaml": "^2.9.0"
+    "react": "~19.3.1",
+    "yaml": "^2.9.1"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^9.2.0",
-    "@types/mdast": "4.0.4",
+    "@antfu/eslint-config": "^9.5.1",
+    "@release-it/conventional-changelog": "12.0.2",
+    "@types/hast": "^3.0.5",
+    "@types/mdast": "^4.0.4",
     "@types/node": "^22.20.1",
-    "@types/react": "19.2.17",
-    "eslint": "^10.8.0",
-    "ink-testing-library": "4.0.0",
-    "tsup": "^8.5.1",
+    "@types/react": "^19.3.0",
+    "eslint": "^10.13.0",
+    "ink-testing-library": "^4.0.0",
+    "release-it": "21.1.1",
+    "smol-toml": "^1.9.1",
+    "tsup": "^9.0.0",
     "typescript": "^5.9.3",
     "vitepress": "^1.6.4",
-    "vitest": "^4.1.10",
-    "wrangler": "^4.114.0"
+    "vitest": "^5.0.5",
+    "wrangler": "^4.151.3"
   }
 }

package/skills/rsp/SKILL.md

@@ -1,73 +1,78 @@
 ---
 name: rsp
-description: Use this skill when initializing RSP, operating an existing .rsp project, auditing or repairing .rsp state, or deciding whether a change needs durable updates before archive.
+description: Coordinate authorized direct, Change or Group work; select capabilities and accept results while executors load their methods. Retain recovery and evidence and prepare delivery without treating completion as closure.
 license: MIT
 metadata:
   author: oevery
-  version: "2026.08.21.3"
+  version: "2026.10.22.4"
 ---
 
-# RSP Skill
+# RSP Core
 
-Use RSP to derive one current action from project authority and durable work artifacts. This Skill is the preferred operational guide; `.rsp/rsp-rules.md` is the runtime fallback when the Skill is unavailable.
+Carry the authorized request through execution, applicable evidence and needed knowledge updates. Core owns the goal, boundary, capability selection, cross-capability decisions and result acceptance. Capabilities own their methods and may be invoked directly. Skills are the only workflow. A missing or unusable required Skill stops dependent work; report the incomplete installation without reading retired Rules or installing implicitly.
 
-Nearest project instructions and relevant `CONTEXT.md` remain authoritative. Use the response-language and artifact-language rules in [response language](references/response-language.md) for user-visible narration and durable prose. Preserve canonical headings, paths, commands, identifiers, and machine values. WorkRefs are stable identities independent from prose language and locale; Shape owns naming when a new identity must be inferred.
+## Select the work and responsibility
 
-## Scope
+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.
 
-Use this Skill for RSP setup or repair, focused `.rsp/` work, and the durable-update decision before archive. Do not use it for unrelated coding or create a Change for a simple session task unless the user explicitly requests tracking.
+- **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.
+- **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.
 
-## Derive one next action
+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.
 
-Read user intent, nearest authority, `rsp status --json`, the selected Change and its readiness, fresh verification evidence, and blockers. Stages are derived guidance, never persisted state.
+Use the CLI invocation selected by the project AGENTS entry: consumer projects pin an exact package in `.rsp/version`; an explicit `.rsp/source` selects the RSP development checkout's own built CLI. `rsp` in these Skills denotes that selection, never `@latest`, a version range, or an unverified global binary. Do not substitute a published package for source mode because version strings match. Only an authorized upgrade selects another exact package target and runs its `update` command for the complete environment; source-mode update retains the local source selection. Upgrade notices grant no migration authority. 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.
 
-Use the canonical transient control vocabulary from the maintainer Skill Control Model. Before Core returns or composes a phase result, read the canonical [control outcome](references/control-outcome.md) contract. Route and stop dispositions, dispatch disposition, topology, lane results, acceptance, and closeout remain nested phase-specific details or gates; do not expose them as peer status flows or persist any control object. Core transfers current-phase control to Manage or one Discipline and receives its bounded result. Manage-to-worker communication is delegation, not control transfer: the worker never becomes owner of the managed goal. Core may mutate only RSP control-plane state; product mutation belongs to Implement or a bounded manual Discipline action. Every stop is fail-closed until its declared resume rule succeeds.
+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:
 
-Apply these routes in order:
+- 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.
+- rsp-doc: substantive document/Skill writing, needed knowledge writeback and final Change reconciliation.
+- rsp-verify: a requested declared-evidence result or a separately required verification obligation; ordinary implementation checks stay with Implement.
+- rsp-review: fixed-scope read-only judgment or explicitly bounded structural discovery. Supporting checks remain within that review.
+- rsp-commit: separately authorized exact local delivery; required for Git execution, with no Core substitute if unavailable.
 
-Before later-turn mutation under a direct report, design, tiny, or small route, rederive from the newly authorized objective and prospective work. Independent slices, recovery, distinct execution and acceptance owners, repeated production-path correction, real-host, provider, or hardware validation, bounded review convergence, managed lifecycle delivery, or a clear ready successor requires the smallest sufficient WorkRef plus fresh owner preflight and Manage qualification before mutation. Multiple files or documentation surfaces alone do not. Unchanged direct follow-ups remain direct. Elapsed time and message count alone never escalate work.
+Continue authorized same-scope work without another continuation request. A phase, role or method change alone requires no tool call, worker, review or test run. Required review, independent execution and protected operations still apply. For ownerless release checks, establish the exact candidate, check contract, baseline and effects authority; invent no Change or Verify owner.
 
-1. Route explicit fixed-scope review to `rsp-review`, release finalization or reconciliation to `rsp-release-docs`, and one bounded design question to installed `rsp-design`; never manually emulate it. Without a selected Change, use report-only Pre-Change Design without inventing a WorkRef or artifact. Only when unavailable, its manual fallback stays bounded to the same question.
-2. Return `RouteDisposition: direct` only for one ready owner, one writer, one execution phase, one integrated decisive check, no recovery, no independent acceptance obligation, no managed lifecycle coordination, and no ready successor. Multiple changed files or documentation surfaces do not by themselves alter that route. Perform no Manage handoff or managed Assignment. After the direct result and fresh verification exist, explicit local commit authority may route exactly once to `rsp-commit` with a `direct` owner summary, exact allowed paths, decisive evidence, and current authority; do not invent a Change, WorkRef, lifecycle state, or RSP trailer. An available Commit refusal returns its real missing condition to Core and never becomes a manual fallback. Rederive before further mutation if any condition changes.
-3. Core resolves whether one unambiguous shape-ready Change or shallow Group is the `WorkOwner` before Manage qualification. Missing or non-ready ownership reports `RouteDisposition: shape`; Core invokes Shape only with independently granted planning-artifact authority. Material product or authority questions stop for their `DecisionOwner`; ask one highest-impact owner question that resumes through fresh Core derivation after the answer. Invalid ownership, topology, dirty paths, scope, route, or authority stops for rerouting.
-4. Read [managed routing](references/managed-routing.md) for initial qualification and handoff. On `selected`, pass the WorkRef, authority, evidence, closeout ceiling, and return boundaries to `rsp-manage`. Once selected, Manage solely owns same-goal revalidation, interruption and resume, selected-goal execution, and lifecycle orchestration; `rsp-commit` retains the exact local delivery procedure. Automatic selection grants routing only.
-5. If Manage is declined, continue ordinary routing when the owner and authority are clear; otherwise return the one required input. For incomplete or failed evidence use [Implementation evidence](#implementation-evidence). When required Tasks and verification pass, load [durable writeback decision](references/durable-review.md); do not infer release, archive, Git, publication, approval, or human acceptance.
+## Execute and reconcile evidence
 
-Return the canonical outer `ControlOutcome` in localized prose through the Core-owned contract. Preserve exact machine values as secondary technical values and keep route, dispatch disposition, or topology only as nested technical evidence.
+Implement owns ordinary self-checks. Main-agent inspection can assess results, but an implementation participant cannot certify required independent review. Select extra Verify/Review only when requested, required or supported by concrete risk, not per task or per worker automatically.
 
-For managed evaluation, report `selected` or `declined` and the decisive signal; report a sequential or parallel choice only when dispatch applies. Name at most one optional capability when it is the next action and available. A missing optional Discipline Skill does not invalidate RSP: use its bounded manual fallback against the same owner. This fallback never substitutes for a required managed worker or required independent Verify. Do not preload or recursively invoke capabilities.
+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.
 
-### Implementation evidence
+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. Keep commands, results, tested boundaries and decisive sources with their existing owner, including failures, unavailable checks and superseded results. Add no evidence ledger.
 
-For incomplete or failed implementation evidence, read [implementation evidence](references/implementation-evidence.md) before selecting Diagnose, TDD, ordinary Implement, or Verify. Diagnosis precedes TDD; every branch returns evidence to the same Change, and fresh Required verification remains mandatory.
+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.
 
-## Operate the selected Change
+Dependent writes require successful prerequisites; observe each required result rather than relying on a batch's final exit status. Recover tool failures within unchanged authority, inspecting uncertain effects before safe replay. Named checks and Commit's one-attempt rule remain binding.
 
-Before focusing or mutating a different WorkRef, compare dirty product or durable-truth paths with the prior owner's paths. Overlap never transfers ownership; continue, explicitly reopen, use an authorized integration owner, or stop for boundary resolution. Disjoint work may proceed without staging or forcing a commit.
+## Coordinate only when needed and allowed
 
-Read the focused Change, its sibling Group Brief when grouped, and only the relevant Specs and Decision Records. Use `rsp specs` for direct tree navigation or bounded literal discovery, then re-read the exact authoritative source before a material decision or mutation; generated index files are migration inputs, not navigation authority. Only a `focus.d/` marker path selects current work. When a Focus Capsule exists, is inspected or mutated, reports warnings, or a continuation resumes, read [focus and continuation recovery](references/focus-continuation.md). Run the focused check before treating the owner as ready. Preserve the canonical Proposal, Spec, Design, Tasks, Verify, and Blockers sections.
+Work shape does not choose agent topology. Automatic delegation defaults off. An explicit worker request or binding independent-worker requirement permits that bounded dispatch; otherwise resolve workflow.delegation before automatic delegation. When auto is enabled, the user or main agent chooses zero, one or multiple execution workers. RSP has no worker-count tiers or maximum; host constraints still apply.
 
-Keep the Change a convergent snapshot of the current plan and final decisive evidence. Replace superseded content; keep routine attempts, temporary probes, and command transcripts in the response. Persist only `open` and `archived`; focus, readiness, routing, and capability availability grant no implementation, review, Git, publication, or approval authority.
+Load [worker coordination](references/coordination.md) for actual dispatch, dependencies/shared-resource arbitration or required independent workers. Keep tightly coupled work local; never simulate missing worker identity or independence. Workers do not delegate further by default. Main retains integration and result acceptance; child passes do not establish integration coverage.
 
-RSP remains repository-native and derives workflow state from current project artifacts and checkout evidence; it requires no hidden runtime state.
+Load [interruption recovery](references/coordination-recovery.md) for pause/resume or unsettled host effects, and [focus continuation](references/focus-continuation.md) for a recovery snapshot. Cross-session continuation refreshes current authority, owner, applicable status, Git index, dirty paths, evidence applicability and replay safety. Cancelling a wait does not stop workers or release resources.
 
-When archived acceptance is incomplete, read [reopen recovery](references/reopen-recovery.md) before lifecycle mutation. Reopen requires explicit lifecycle authority and grants no Git or external authority.
+## Maintain records and prepare delivery
 
-Load detailed procedures only when active:
+During execution update Tasks/Verify directly for actual outcomes when scope, contract, design and knowledge remain accurate. Consolidate repeated conclusions for the same scope and candidate; retain distinct inputs, outcomes, material failures and evidence references. When changing Blockers, use the [shared work-model syntax](references/work-model.md). Passing checks or recovery alone adds no whole-document rewrite. Routine narration stays in the conversation; retained execution evidence stays with its existing owner. Focus is replaceable recovery guidance, never acceptance or authority.
 
-- [setup and repair](references/setup-repair.md) for initialization, audit, migration, or repair.
-- [groups and dependencies](references/groups-dependencies.md) for grouped or dependent work.
-- [conflict handling](references/conflict-handling.md) for an intersecting Git operation.
-- [durable writeback decision](references/durable-review.md) after required Tasks and implementation verification pass.
+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.
 
-## Ownership and safety
+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.
 
-Route planned design to the selected Change; implemented facts to the smallest fact owner; rationale to one Decision Record; stable navigation to project-owned `CONTEXT.md`; operating rules to project-owned `AGENTS.md`; temporary continuation to the response. Never write planned state as current truth or duplicate facts into rationale.
+Operate command-owned state through RSP commands. Persist only open and archived; derive readiness and routing. A complete Task list never closes work. Reopen is exceptional recovery requiring explicit authority: load [reopen recovery](references/reopen-recovery.md) only when actually needed.
 
-Use RSP commands for command-owned files. Do not directly create command-owned files; preserve unrelated work. Core recommends archive only after the durable decision; it does not execute archive or grant staging, commit, push, publication, deletion, deployment, approval, or human-acceptance authority. Detailed Manage closeout, local Commit, conflict, and recovery rules remain in their owning Skills or conditional references. Execution-environment selection and cross-branch integration remain host, user, or Git concerns outside RSP workflow state.
+Other conditional procedures:
 
-When accepted work remains or a continuation resumes, read [focus and continuation recovery](references/focus-continuation.md), then return a localized continuation with these semantic fields in order: `WorkRef`, `Authority`, `Current state`, `Changed artifacts`, `Fresh verification`, `Blockers`, `Next action`. Preserve technical values; the continuation is not a second state store. On resume, reopen its pointers to authority and owned artifacts, inspect drift and replay safety, and refresh decisive evidence before mutation.
+- [Setup and repair](references/setup-repair.md) for initialization, audit or repair.
+- [Groups and dependencies](references/groups-dependencies.md) for grouped work.
+- [Context migration](references/context-migration.md) when a root/relevant legacy CONTEXT-MAP.md is found or migration requested; preserve context, discovery alone grants no migration.
+- [Conflict handling](references/conflict-handling.md) for an intersecting Git operation.
 
-## Durable decision output
+## Return the result
 
-After loading [durable writeback decision](references/durable-review.md), use its canonical localized output and choose current facts and lasting rationale independently. A required unwritten update, incomplete Task, incomplete Required Verify item, or real blocker makes archive readiness `no`; Optional coverage warnings do not. Before lifecycle closeout, consume fresh `rsp ready <work-ref> --json` evidence with `completionGate: pass` and `archiveReady: yes`.
+Follow explicit response language, personal instructions, then conversation language. Existing artifacts retain their language; new artifacts follow explicit instruction, effective project settings, scoped instructions, then conversation language. Keep identifiers and machine values exact; load [language details](references/response-language.md) only for contested choices.
+
+Report the outcome, decisive evidence, material limits and needed next action. Distinguish observed effects, checks, review and acceptance; unverified claims stay unverified. Missing Required evidence blocks only dependent completion. No mandatory phase receipts or repeated logs. Load [control outcome](references/control-outcome.md) only for a consumer needing its technical rendering. For unfinished work retain only the owner, authority, evidence, blocker and safe continuation needed by the next actor.

package/skills/rsp/references/closeout.md

@@ -0,0 +1,38 @@
+# 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.
+
+## 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.
+- 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.
+
+## Reconcile the final boundary
+
+1. Confirm exact delivery scope and inspect existing evidence for that boundary.
+2. Apply [durable writeback](durable-review.md): necessary stable knowledge first, final Change reconciliation second. These can be one operation with no edits when already current.
+3. Fill missing or invalidated checks and separately required review. Reuse applicable results; ordinary record cleanup does not invalidate code tests. Changed normative contracts and executable Skills need affected checks/judgment. Fresh independent review is not a universal closeout prerequisite.
+4. For each Change to close, obtain current rsp ready <work-ref> --json with completionGate: pass and archiveReady: yes. Also require accurate final records, completed or unnecessary knowledge updates, applicable Required evidence and every separately required review. Readiness alone does not establish semantic acceptance.
+
+Missing Required evidence, active blockers or contradictory contracts prevent closure. Optional omissions remain visible. Fresh authority, owner and exact Git/lifecycle observations remain necessary even when tests are reused.
+
+## Close only when authorized
+
+Run rsp archive <work-ref>. Inspect the resulting archive and entire lifecycle diff, including Focus removal and cleanup warnings. Use the returned filename in the selected WorkRef's archive directory: .rsp/archives/ for an ungrouped Change, .rsp/archives/<group>/ for a child. Do not guess dates, suffixes or directories. Expand read-only discovery only for incomplete or contradictory output/effects; do not replay the mutation.
+
+For a Group, archive eligible authorized children independently, reconcile the Brief and integrated evidence, then run rsp group close <group> after every child and Group gate passes. Request-only integration conditions must first be recorded in the Brief; child passes alone do not prove integration.
+
+Never delete or copy lifecycle files to bypass commands. If archive succeeds but commit fails, report the archived, uncommitted state. Do not automatically reopen, rewrite history or repeat uncertain mutations.
+
+## Route exact delivery separately
+
+With explicit local commit authority, route to rsp-commit with the delivery kind (direct, change, integration, group or release), purpose (checkpoint or terminal), real owner/WorkRefs, exact paths, applicable verification and lifecycle evidence only when applicable. No transport schema or duplicate receipt is required.
+
+Integration requires at least two real WorkRefs and one shared delivery boundary but creates no Group. Ambiguous, mixed, stale or denied boundaries stop before staging. Missing Commit capability has no Core fallback. Commit audits the exact index and owns Git execution.
+
+Push requires explicit authority and an unambiguous remote, branch and milestone. Never infer it from commit or closure; no force push or automatic publication. Remote failure preserves local commits and stops at that boundary.

package/skills/rsp/references/context-migration.md

@@ -0,0 +1,22 @@
+# Context migration
+
+Load when a legacy CONTEXT-MAP.md is found, CLI reports it, or the user requests context migration. This is a conditional Core method, not a separate Skill or a mandatory project phase. CONTEXT.md remains the target model for vocabulary, domain relationships, and navigation.
+
+## Inspect without migrating
+
+Read the relevant legacy map, existing root/local CONTEXT files, scoped instructions, and incoming references. File presence is a migration signal, not proof that its content is obsolete or that an existing CONTEXT already contains it. Resolve overlapping or contradictory definitions with their owner; do not choose a winner from the filename.
+
+Without migration authority, preserve files and use the legacy content relevant to the current task alongside current context. Report the pending migration without repeatedly demanding it or blocking unrelated work. Stop only work that depends on an unresolved meaning or authority conflict. Do not follow unsafe or out-of-scope paths merely because a legacy map points to them.
+
+## Migrate within explicit scope
+
+Establish authorized source files, target owners, reference updates, and whether retiring the old file is included. Reuse the selected WorkRef when tracked; bounded direct migration needs no new work record.
+
+1. Map useful terms, relationships, and navigation to their root/local CONTEXT owners. Keep contracts and operating rules with their existing Spec/AGENTS owners, using links instead of parallel definitions. Resolve material conflicts before changing their meaning.
+2. Merge into existing context without overwriting unrelated content or renaming concepts for consistency alone. For substantial writing use Doc when available; otherwise preserve meaning and verify the reader's navigation directly. Doc supplies the writing method, not migration or deletion authority.
+3. Update active references and entry instructions. Check both lost meaning and broken paths; historical snapshots need not be rewritten.
+4. Retire the old map only after checking preserved meaning, active references, and explicit retirement authority. If any gate is missing, keep it and report the remaining work.
+
+`rsp update` and `rsp doctor` only detect the root legacy path and provide guidance; they do not compare semantics, merge context, or retire project files. A successful command is not migration acceptance.
+
+Return the source-to-owner result, changed files, checks, and unresolved conflicts or permissions. Migration completion derives from inspected documents and references, not a new marker or stored lifecycle state.