@oevery/rsp 3.2.0 → 4.0.0

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

@@ -1,19 +1,84 @@
 # Durable writeback decision
 
-Load this reference only after required Tasks and implementation verification pass, or when auditing archive readiness.
+Load for a necessary stable-knowledge update or preparation/audit of lifecycle or terminal delivery. Passing Tasks/checks or resuming work alone does not activate it. An evidence-only Tasks/Verify refresh with accurate scope, contract, design and stable knowledge stays in Core's direct path; it neither establishes closeout eligibility nor skips separately required Review.
 
-This operation is the durable writeback decision, not implementation verification and not fixed-scope change review. Implementation verification supplies fresh evidence after mutation. Fixed-scope change review is a report-only comparison owned by Review and is required only when explicitly requested, required by nearer authority or risk, or needed to derive managed `review-clean`; it is not automatically required for every tiny direct action. The durable writeback decision is always required before archive and independently decides current-fact and Decision Record updates. It never substitutes for fixed-scope change review.
+## Establish the evidence boundary
 
-Run `rsp check --focused` and `rsp show --focused --json`, or `rsp ready <name> --json` for an explicit Change. Treat `durableReview.factCandidateTargets` and `decisionRecordsPath` as routing advice, not permission. Spec delta markers are planning aids and are never promoted automatically.
+For routine writeback, establish the relevant facts, update justified knowledge using the methods below, reconcile only affected Change sections when tracked, and check those edits. Preserve ongoing plans and unfinished work; this does not trigger final whole-Change convergence, readiness or closure. Before archive, current-fact and Decision Record decisions are both required. Keep these evidence owners separate:
 
-Choose current facts and rationale independently. Use no update when there is no stable fact or lasting rationale worth rereading.
+- Implementation verification supplies applicable evidence for the final content, reusing unchanged coverage and rerunning affected checks after mutation.
+- Review owns fixed-scope, report-only comparison. Use it when explicitly requested, required by nearer authority or risk, or needed by the selected acceptance; tiny direct actions do not automatically need it.
+- Durable writeback decides what belongs in current facts or lasting rationale. It never substitutes for implementation checks or a required Review.
 
-Write a current-fact update only when implementation changed a stable behavior, boundary, default, or constraint that future maintainers need. Prefer the smallest existing domain Spec, `.rsp/specs/design.md` for project-wide boundaries/navigation, or an explicitly authorized scoped `CONTEXT.md`/`AGENTS.md`; create a new Spec only for reusable project-level truth that fits nowhere existing.
+Inspect existing evidence and the selected Change when tracked. Use `rsp ready <name> --json` when current readiness or durable target advice is needed; obtain fresh readiness immediately before an authorized archive. Do not query readiness twice merely for separate writing and delivery roles. Treat `durableReview.factCandidateTargets` and `decisionRecordsPath` as routing advice, not permission. Spec delta markers are planning aids and are never promoted automatically.
 
-Create or update a Decision Record only for a hard-to-reverse or surprising choice with a real tradeoff. It owns rationale, alternatives, tradeoffs, and consequences—not duplicated current facts. Choose one exact file under `durableReview.decisionRecordsPath`, not the directory itself.
+When a diagnostic tool fails, inspect its cause and effects. Use another permitted read/search method for the same authoritative artifacts. Do not replace named required checks, infer readiness from manual reading or mutate protected RSP files to obtain a gate. Missing decisive migration, structural or verification evidence leaves dependent closeout incomplete.
 
-Never use generated indexes, archives, `.rsp/rsp-rules.md`, or the managed RSP block as ordinary writeback targets. Keep narrative history, debugging notes, task chronology, and transient evidence out of Specs and Decisions.
+If inspection reports only `RSP project requires an update` without update authority, do not run `rsp update`. Preserve supported implementation and verification outcomes; report affected knowledge, readiness or delivery gaps. Archive requires current readiness. Commit may assess a separately authorized checkpoint against its exact boundary and required evidence; it stops if that evidence is affected or unavailable. Other inspection failures and required checks remain unresolved.
 
-Before archive, compress the Change to current design, completed outcomes, decisive evidence, omissions, remaining risks, and blockers. Archive only after required writeback is complete or explicitly unnecessary and every separately required fixed-scope change review is clean. Ordinary work needs later explicit Git authority for one independently reviewable logical commit. A `manage.closeout` preset applies only when Core selected and qualified Manage for the current continuation; declined, unavailable, or unselected Manage leaves Core advisory and configuration executes neither archive nor commit. In a qualified managed continuation, lifecycle closeout is independent from Git and follows the effective ceiling: `manual` leaves archive advisory, while `lifecycle` or `local` permits `rsp archive <change-work-ref>` after the durable writeback decision unless nearer authority narrows it. For a shallow Group with lifecycle closeout, make the durable writeback decision and archive each child independently, re-derive completion, and run `rsp group close <group>` only after every child and Group gate passes. Inspect each complete lifecycle diff before deciding Git separately. `manual` and `lifecycle` grant no commit; `local` may justify recovery checkpoints and, after lifecycle closeout, requires one `rsp-commit` invocation for a terminal non-small Change or Group when owner, paths, fresh decisive verification, and a clean exact boundary are known and no nearer denial exists. Terminal small work defaults to no commit; ambiguous, mixed, stale, or denied boundaries stop without staging. A separately authorized release operation may use a dedicated release commit. Push remains separate and requires the user to mention it explicitly.
+## Close out in order
 
-When commit eligibility and authority exist, give `rsp-commit` one envelope containing the Change, Group/wave, or confirmed release owner, exact allowed paths, decisive evidence, lifecycle state, and current authority. If that Skill is unavailable, perform the same bounded manual action: reread nearest authority and owner; inspect staged, unstaged, and untracked paths, the cached diff, and recent non-merge messages; stop without staging on ambiguity or stale evidence; stage only allowed paths; re-inspect the complete cached boundary; derive a repository-consistent Conventional subject plus a proportionate body and truthful RSP trailers; create one local commit; then observe its complete message, paths, remaining worktree, and remote safety without amending or performing any external action.
+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. Recovery state alone supplies no required acceptance evidence.
+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` and its artifact-lenses method when available to reconcile all six sections as one final document. Retain the delivered delta, relevant design, task outcomes, candidate-bound verification, material failures/limits and knowledge-update references; leave already-converged text unchanged. Reconcile superseded, misplaced or duplicate content. Keep process history in its report or conversation, Group integration conclusions in the Brief, and transient operation permissions distinct from product boundaries. 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.
+
+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.
+
+Observe acceptance-critical commands separately by default. A batch must stop on failure and expose every result and exit status; trailing success proves no earlier pass. For a missing result, re-observe only that read-only or proven repeat-safe check by its declared method. Inspect effects before repeating mutations. Keep dependent lifecycle actions incomplete until required checks pass. Use existing document/link checks or known-path inspection instead of improvised general Markdown regex parsing. Ordinary reads may be batched.
+
+## Decide current facts and lasting rationale
+
+Use no update when there is no stable fact or lasting rationale worth rereading.
+
+Report actual knowledge updates, unresolved decisions and requested readiness conclusions concisely. Current-fact and Decision Record decisions remain independently required before archive, but routine no-op fields need not appear in the response. Include exact targets and decisive rationale when needed; a readiness report retains `yes | no`, gate evidence and blockers. Use the complete rendering below only for an explicit request or real technical consumer. Localize headings and labels while preserving the canonical values:
+
+```md
+## <localized Durable Decision heading>
+- <localized Current facts label>: <No current-fact update needed | Update existing spec or scoped instruction | Create a new durable spec>
+- <localized Current-fact target label>: <exact file path or N/A>
+- <localized Facts to write label>: <durable facts or none>
+- <localized Decision Record label>: <No Decision Record needed | Create or update a Decision Record>
+- <localized Decision Record target label>: <exact file path or N/A>
+- <localized Rationale to write label>: <lasting rationale or none>
+- <localized Archive ready label>: <yes | no>
+```
+
+This is a response-only decision summary, not a block to paste into Change or archive. Persist actual knowledge updates and material decisions in the appropriate existing sections; omit empty targets, transient readiness and authorization receipts unless a declared consumer requires them. In Chinese, for example, use `## 持久化决策`, `决策记录（Decision Record）`, and `可归档（Archive ready）`, not English labels alone. Compact presentation changes no decision or closeout gate.
+
+## Write current facts to their owner
+
+Write only a changed stable fact that future maintainers need. Select the smallest existing owner; summarize and link rather than maintain the same rule twice:
+
+- `README` owns introduction, usage and starting points, not duplicate specifications.
+- `AGENTS.md` owns scoped operating rules, authority and checks, not product behavior.
+- Authorized root or local `CONTEXT.md` owns canonical vocabulary, domain relationships and navigation, not implementation notes or session history. Define a term once in its domain and link it elsewhere.
+- Specs own current capabilities, collaboration contracts, boundaries and necessary constraints, not code inventories or future plans. Domain contracts use their relevant Spec; project-wide architecture uses `.rsp/specs/design.md`. Keep design references when they define normative evidence.
+- Change owns this outcome's delta, design, work and evidence, not a full baseline copy. Decision Records own significant choices, alternatives and consequences, not another current-contract definition. Archives retain historical evidence, not current authority.
+
+Create a Spec only for reusable truth with no suitable existing owner.
+
+For substantial authorized writeback, use `rsp-doc` when available. A partial or older installation may instead apply these local checks; neither method replaces required Review:
+
+- State consumers/value, handoffs, observable behavior, invariants and limits that survive replaceable internals.
+- New domain Specs may use Purpose, Boundaries, Contracts, Scenarios and Constraints as a scaffold. Domain headings and normative design references remain valid; neither table shape nor template conformity selects ownership.
+- Include only useful discriminating scenarios; Given/When/Then is optional. Plain-prose hints may stay, but requirements and limits remain visible.
+- Link rationale to its Decision Record and verification to the Change. Resolve Spec/code discrepancies before choosing the correction owner; code alone supplies no new promise.
+- Check that the future reader can find and use grounded facts, understand conditions and unknowns, and follow valid references. Preserve meaning; do not rewrite existing Specs merely for matching headings.
+
+## Write lasting rationale when needed
+
+Create or update a Decision Record only for a hard-to-reverse or surprising choice with a real tradeoff. It owns rationale, alternatives, tradeoffs and consequences, not duplicated current facts. Choose one exact file under `durableReview.decisionRecordsPath`, not the directory itself.
+
+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
+
+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.

package/skills/rsp/references/focus-continuation.md

@@ -0,0 +1,13 @@
+# Focus and continuation recovery
+
+Load when tracked work needs a recovery snapshot, a Capsule needs inspection or replacement, or a portable continuation handoff is required. Same-session worker continuation alone uses [coordinated interruption and recovery](coordination-recovery.md), not this format. Short direct tasks need no new WorkRef or Capsule.
+
+Core owns the selected WorkRef's replaceable recovery snapshot. At a pause, handoff or recovery-relevant checkpoint, update it only when the Change, evidence and existing snapshot are insufficient for safe continuation. Retain the minimum current state, evidence pointers, next action and resume conditions. Ordinary same-session progress needs no update. Use `rsp focus <work-ref> --capsule-file <path|->` to replace, not append. Respect nearer mutation restrictions. For Group work use the selected child's Capsule, not a Group marker. Empty markers remain valid.
+
+The existing v1 format is bounded to 4096 UTF-8 bytes: one leading `<!-- rsp-focus:v1 -->`, blank lines, exactly one non-empty single-line `Current`, `Evidence`, `Next`, and at most one non-empty single-line `Resume check`. No other non-empty lines are valid. Keep raw logs/diffs, runtime identifiers, host paths, credentials and execution history out. The marker path selects work; its notes grant no authority or acceptance and are never worker transport or controller state.
+
+Before closeout, use the [durable-writeback sequence](durable-review.md): verify outcome facts, distill useful Focus facts and update stable knowledge as needed, then converge the whole Change and check final consistency before authorized archive. No useful Focus addition requires no edit; it waives neither necessary knowledge correction nor final Change convergence. Detailed evidence stays with its existing owner, never solely in the Capsule.
+
+When accepted work remains, return a localized continuation with these semantic fields in order: `WorkOwner`, `Authority`, `Current state`, `Changed artifacts`, `Fresh verification`, `Blockers`, `Next action`. A Change WorkOwner uses its WorkRef; a Group WorkOwner uses its Group reference and direct child Changes. Preserve technical values; the continuation is not a second state store.
+
+For same-session, cross-session or cross-device resume, follow [interruption and recovery](coordination-recovery.md#resume-from-effects-not-tool-status) before continuing from this snapshot. That method owns drift, evidence applicability, replay safety and re-establishing current authority and host facts.

package/skills/rsp/references/groups-dependencies.md

@@ -1,12 +1,14 @@
 # Groups and dependencies
 
 Load this reference before creating, focusing, planning, or closing grouped or dependent work.
+Use the same selected CLI throughout; `rsp` below denotes that invocation, not a request to fetch or install a package.
 
-- Executable WorkRefs are `<change>` or one direct `<group>/<change>` child. Deeper paths are unsupported.
-- Use a Change Group only for at least two independently executable Changes sharing a goal or completion contract. Create it with `npx -y @oevery/rsp group create <group> [goal]`, replace placeholders, and declare each direct child under `Slices` before creating it.
-- `<group>/brief`, stored as `<group>/00-brief.md`, is not executable or focusable. Read it before a selected child. Its declaration order guides navigation and its blockers are inherited as external blockers, not graph edges.
+- Use the [shared work model](work-model.md) for Group and child identities when those definitions are missing from the current context.
+- Use a Change Group only for at least two independently acceptable/deliverable Changes with dependencies or an integration obligation. Create it with `rsp group create <group> [goal]`, replace placeholders, and declare each direct child under `Slices` before creating it.
+- The Brief is not focusable. Read it before a selected child. Its declaration order guides navigation and its blockers are inherited as external blockers, not graph edges.
+- Group-level integration obligations belong in the Brief's `Completion Conditions`. Use a named `Integration:` condition for the durable boundary and record fresh integration evidence before marking it complete. A boundary supplied only by the current request is transient and cannot complete Group closeout until it is written back.
 - Declare an exact prerequisite only as `- requires \`<change-work-ref>\`: <reason>` under the dependent Change's `Blockers`. Targets must be executable Changes.
-- Use `rsp status --json` as the derived dependency view. `plan.nodes`, `ready`, `edges`, `blocked`, and `waves` are authoritative for the current inspection. Each edge means “change requires prerequisite”; filtered plans retain transitive prerequisite context.
+- Use plain `rsp status` for the default semantic view and `rsp status --json` when exact dependency fields are needed. In the default JSON projection, `plan.nodes`, `plan.edges`, `plan.blocked`, and `plan.waves` are authoritative; the first non-empty wave is the current ready work. Each edge means “change requires prerequisite”; filtered plans retain transitive prerequisite context.
 - Do not infer nested ownership from the human dependency forest, create a parallel graph, or copy live delivery state into a Group Brief. Archived prerequisites resolve without rewriting dependents; incomplete inspection fails closed.
 - Archive children independently. Close the brief with `rsp group close <group>` only after every direct child and group completion gate passes.
 - Closed Group recovery never reuses its identity through `rsp group create` and never cascades into children or dependents. Core's direct reopen-recovery procedure owns the lifecycle sequence and exact retained-archive selection.

package/skills/rsp/references/response-language.md

@@ -0,0 +1,13 @@
+# Response and artifact language
+
+Load this reference when the current action needs language selection beyond the Core routing summary.
+
+Response prose is user/session-owned. Precedence: explicit current response-language instruction → user or host personal instructions → conversation language. Project `.rsp/config.yaml` never selects response language. Use natural-language narration for progress, phases, control results, receipts, stop reasons, and handoffs. Preserve an exact machine value unchanged only as a secondary parenthesized or code-formatted value.
+
+Durable artifact prose is repository-owned. For a new authorized artifact: explicit artifact language → configured effective artifact language → artifact-scoped project instructions → conversation language. Existing artifacts retain their established language unless translation is explicitly authorized; configuration changes never rewrite them.
+
+Commit-message prose: explicit current instruction → configured effective commit language → nearest repository authority → clear recent non-merge history.
+
+When precedence needs configured RSP language, use the same selected CLI's successful `rsp config --json` summary, optionally `--compact`; the CLI resolves defaults and inheritance. Reuse it until relevant configuration changes or recovery requires refresh. Raw YAML and status do not resolve effective language. On failed or unavailable projection, diagnose without inventing values or silently dropping configured precedence. Only the dependent choice waits; existing-file preservation, explicit overrides and independently authorized work needing no unresolved setting may continue. Other configuration systems retain their own readers.
+
+Preserve canonical headings, paths, commands, identifiers, WorkRefs, Conventional Commit types and scopes, trailers, severity labels, and machine values. Language and locale never rename or translate an existing WorkRef. Persistent prose belongs to the domain, system, user, or operator; mention AI or agents only when they are actual product actors or constraints.

package/skills/rsp/references/setup-repair.md

@@ -1,11 +1,41 @@
 # Setup and repair
 
-Load this reference only before initializing, auditing, migrating, or repairing RSP-managed state.
+Load before initializing, inspecting or updating RSP-managed assets.
 
-1. Initialize with `npx -y @oevery/rsp init [--agents-mode managed|print] [--with-project-setup]`.
-2. `--with-project-setup` creates and focuses `changes/project-setup.md`. Without it, create that Change only when explicit bootstrap tracking is still needed.
-3. Put project-wide boundaries in `.rsp/specs/design.md`, use generated local `00-index.md` files only for direct-child navigation, put cohesive reusable facts in the smallest domain Spec, and keep stable operating instructions in the nearest project-owned `AGENTS.md` outside its managed block.
-4. Diagnose with `npx -y @oevery/rsp doctor`. Apply only deterministic repairs with `doctor --fix` or `rsp update`; `fixed` entries are real filesystem mutations, while an empty list means nothing changed.
-5. Do not use repair commands to decide stale focus, semantic durable updates, or archive readiness.
+Use the runtime selected in AGENTS: an exact package pin in .rsp/version for
+consumer projects, or this checkout's built CLI when .rsp/source explicitly
+selects source mode. The two markers are mutually exclusive. An authorized package
+upgrade deliberately selects its exact target CLI; source update keeps the local
+selection. Never silently resolve @latest; package fetching requires separate authority.
 
-For manual audit, require `.rsp/`, managed roots, and nested Spec parents to be real directories. Require the project `AGENTS.md`, managed markers, fallback/config files, generated local `00-index.md` files, and placeholders to be regular files. Confirm the managed block, root and populated-directory Specs indexes, `specs/design.md`, configured Decision Record exclusion, valid group briefs and direct children, supported path depth, and focus markers matching executable Changes. Symlinks, special files, incomplete inspection, unrecognized reserved indexes, and file/directory identity collisions fail closed.
+- **Initialize:** rsp init [--agents-mode managed|print] [--with-project-setup] creates missing scaffolding and the complete core suite. Existing user files remain unchanged. Retry an incomplete init with the same target; repeated init cannot adopt a different pinned version. Retired Rules require update instead.
+- **Update:** rsp update replaces the selected package's owned assets; optional --dry-run previews without writes. No separate installation or migration switches are needed.
+- **Inspect:** rsp doctor and rsp skills list are read-only. Only explicit doctor --check-updates queries stable metadata. Reports and notices grant no mutation authority.
+
+## Ownership and failure
+
+Core Skill installation directories and exact retired Skill/Rules names are
+package-owned: replace or delete them, including local changes. Preserve needed
+customizations beforehand. Unknown Skills, config, Specs, work, archives, Decision
+Records and Focus are user-owned; update does not rewrite or repair them. Missing
+config values use read-time defaults. AGENTS changes are confined to its managed
+block; write a consumer pin last, and never create one in source mode. Preserve
+canonical maintainer links to package sources.
+
+Only metadata-recognized generated indexes may be deleted from user knowledge
+directories. Stop for owner-controlled reserved paths, invalid config, unexpected
+symlinks or unsupported targets. Do not bypass validation or downgrade the pin.
+
+Failure stops without whole-update rollback or recovery copies. Completed steps
+remain applied. Inspect the reported failure, fix its cause and rerun the same exact
+target command; do not infer completion or switch to the old pin's CLI midway.
+Concurrent external edits and crash recovery are unsupported. No recovery entry exists.
+
+## Project knowledge
+
+Keep architecture in .rsp/specs/design.md, contracts in domain Specs, navigation in
+CONTEXT and scoped instructions outside the managed AGENTS block. Use rsp specs to
+query knowledge. A legacy context map selects [context migration](context-migration.md);
+discovery alone grants no merge or deletion. Semantic writeback and archive decisions
+remain outside deterministic setup. Missing required Skills stop dependent work;
+never fall back to retired Rules or install implicitly.

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

@@ -0,0 +1,27 @@
+# Shared work model
+
+Read when selecting, reporting or operating a tracked RSP owner and these definitions are not already available in the current context. Direct untracked work needs no RSP identity. This file defines identities, not a requirement to execute Core.
+
+## 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.
+
+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.
+
+## Identity and ownership
+
+A WorkOwner is the selected owner of the requested work: a Change, or a Group for its coordination boundary. A direct untracked request retains its explicit scope without inventing a Change, Group or WorkRef.
+
+A Change WorkRef is its logical name: `<change>` for an ungrouped Change, or `<group>/<change>` for a grouped child. Use that identity in commands, reports and ownership trailers. Its Markdown file is `.rsp/changes/<work-ref>.md`: a location for reading or evidence, never the WorkRef value. For example, `checkout/cache-ttl` identifies the child whose file is `.rsp/changes/checkout/cache-ttl.md`. Evidence may cite a file and line separately.
+
+A Group reference is `<group>/brief` and resolves to `.rsp/changes/<group>/00-brief.md`; it names the Group, not an executable child Change. Identities are shallow; deeper nesting is invalid. Read its Brief for shared scope and dependencies, then select the actual child before child work. Do not substitute a Group reference, Brief path or directory for a child WorkRef. A Group-level judgment retains its Group reference and identifies the included direct child Changes.
+
+An explicit user-selected owner wins over default focus discovery. Focus markers locate open-work candidates; multiple candidates alone are not a blocker. Resolve intent and relevant state rather than guessing ownership. Preserve existing work and its owner when changing scope.
+
+## Authority and evidence
+
+Identity, focus, readiness, dependency state and capability availability grant no action authority. A Group Brief supplies context, not permission to implement every child. A completed check proves only its tested boundary; neither it nor a review report grants lifecycle completion, Git delivery, publication or approval. Each capability retains its own action and stop conditions.
+
+In a Change's Blockers, record only unresolved dependencies or decisions preventing required work. Write standalone `None` when none remain; keep non-blocking verification limits in Verify. Exact prerequisites use ``- requires `<work-ref>`: <reason>``. Other prose, including an explanation after `None`, remains an external blocker declaration.
+
+Use only the selected owner's relevant artifacts and authoritative project context. Installed files are shared across the suite, but separate workers do not inherit one another's loaded instructions. Reuse applicable definitions in the same context; obtain this file before depending on missing definitions. If the shared resource is unavailable, report an incomplete suite and stop identity-dependent actions rather than inventing a substitute or installing implicitly.

package/skills/rsp-commit/SKILL.md

@@ -1,48 +1,108 @@
 ---
 name: rsp-commit
-description: Create one authorized, exact-scope local commit for an RSP-owned Change, Group wave, or confirmed release boundary with a repository-consistent structured message.
+description: Inspect or create one authorized exact-scope local commit for direct, Change, integration, Group or release delivery. Preserve unrelated work; do not infer lifecycle, remote delivery or history-rewrite authority.
 license: MIT
 metadata:
   author: oevery
-  version: "2026.07.28.2"
+  version: "2026.10.16.1"
 ---
 
 # RSP Commit
 
-Create one reviewable local commit after Core or qualified Manage has already derived the owner, allowed paths, decisive verification, lifecycle state, and commit authority. Skill availability grants none of those facts. Accept only one Change, one integration-coupled Group wave, one Group closeout, or one confirmed release commit boundary.
+For tracked work, read the [shared work model](../rsp/references/work-model.md) when its identity and ownership definitions are missing from the current context. Use logical WorkRefs in commands and reports; cite file locations separately. Direct invocation needs no prior Core execution.
 
-Follow Core's response-versus-artifact language boundary for all user-visible control narration; when the response language differs, keep exact canonical values only as secondary parenthesized or code-formatted tokens.
+Own exact local Git delivery, invoked directly or through Core. This default core capability grants no authority through availability. Readiness-only work stays read-only. Commit only with current local authority, one exact owned boundary and applicable passing verification.
 
-## Audit the envelope
+Responses follow explicit instruction, personal instructions, then conversation language; existing artifacts retain theirs. Commit prose follows explicit commit-language instruction, effective configuration, nearest repository authority, then clear recent non-merge style. Response language does not select it. Preserve commands, identifiers, Conventional types/scopes and trailers.
 
-Read nearest project authority, the relevant open Change, Group Brief and children, archive, or confirmed release owner, then inspect `git status`, staged, unstaged, and untracked paths, the cached diff, and recent non-merge commit messages. Recheck the supplied verification and lifecycle facts against current repository state.
+Resolve needed RSP defaults/inheritance through the selected CLI's successful `rsp config --json`, refreshing on drift or recovery. Raw YAML is diagnostic only. Projection failure leaves dependent language unresolved before staging; history cannot replace it, while independent authorized inspection may continue. Resolve material conflicts with the owner.
 
-Stop without staging when the owner, allowed paths, commit authority, verification, lifecycle state, or logical boundary is missing, ambiguous, stale, or conflicts with unrelated work. Stop when an allowed path contains mixed owned and unrelated changes that cannot be staged without guessing. Never infer archive, Group closeout, commit, push, tag, publication, approval, amend, rebase, force-push, or history-rewrite authority.
+## Establish the delivery boundary
 
-## Derive the message
+Resolve the smallest request: kind, purpose, owner or summary, real included WorkRefs when relevant, exact paths, current local authority, applicable verification pointers and lifecycle evidence only when applicable. Derive these facts from direct user intent or Core's bounded handoff; do not require a transport schema or create a second source of truth.
 
-Choose subject and body prose language from explicit current commit-language instruction, then the configured effective commit language, nearest repository commit authority, and finally the clear style of recent non-merge commits. Response language and preferences remembered from another repository do not select it. Preserve Conventional Commit types/scopes and trailers as technical values. When recent history is materially mixed and no nearer rule resolves it, return the single language decision to its owner.
+| Kind | Identity and applicable evidence | RSP trailers |
+| --- | --- | --- |
+| direct | One confirmed direct outcome permitted by project tracking rules | none |
+| change | One real WorkRef | RSP-WorkRef |
+| integration | At least two real WorkRefs and one evidenced shared delivery boundary | included RSP-WorkRef values |
+| group | Group reference, included WorkRefs and one wave or closeout boundary | RSP-Group and included RSP-WorkRef values |
+| release | Confirmed release identity and release-boundary evidence | only real included WorkRefs |
 
-Use the repository's established Conventional Commit form when present. Derive type and scope from the owned outcome and repository history, not from the conversation. Keep the subject concise and imperative or otherwise repository-consistent.
+A durable owner is a Change WorkRef or Group reference; included children never replace it. Direct, integration and release may have no durable WorkOwner. Integration creates no Group, direct creates no Change, and commit count is independent from Change count.
 
-A tiny or mechanical boundary may be subject-only when that subject fully explains it. For a non-trivial Change, integration wave, Group closeout, or release commit, add two to four concise bullets covering:
+Purpose is separate from kind:
 
-- the observable outcome;
-- material behavior or compatibility boundaries; and
-- an important omission or risk when one affects review.
+- 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.
 
-Do not copy file lists, command transcripts, routine verification output, execution chronology, or the full Change/archive. Add only truthful trailers: one `RSP-WorkRef:` per included WorkRef, `RSP-Group:` when the Group is the commit owner, authoritative external references already owned by the work, and `BREAKING CHANGE:` only for an actual breaking change. Never invent an issue, co-author, sign-off, breaking change, or AI attribution.
+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.
 
-Project every owned issue relationship as a non-closing `Issue: <canonical-url>` reference when proportionate. Only a terminal commit whose selected Change acceptance is complete may additionally use a provider-supported closing keyword for an explicit `relation: closes`. Checkpoints, `relation: relates`, ambiguous Change or Group ownership, and unresolved provider or repository identity emit no closing keyword. When safe shorthand cannot be resolved, keep only the canonical URL; never infer an issue from changed files or mutate the external tracker.
+## Audit before staging
 
-## Commit the exact boundary
+Read nearest authority and the selected current owner, plus the relevant Brief/children or archive when needed. Inspect status, the complete staged, unstaged and untracked boundary, cached diff and recent non-merge messages. Reread decisive verification and applicable lifecycle facts; copied handoff prose is insufficient.
 
-Stage only the explicit allowed paths. Re-read `git status --short`, inspect the complete cached path list and cached diff, and confirm they represent exactly one owner boundary with no sensitive material. If the cached boundary is wrong, stop and leave unrelated work untouched; do not repair it by broad staging, destructive reset, or history rewrite.
+Reuse traceable passing results while relevant content, dependencies, configuration, tools, inputs and environment still apply. Run only authorized missing or invalidated checks with settled scope and method, or explicitly required executions; entering Commit alone requires no rerun. Failed or unavailable required evidence stops delivery.
 
-Transport a structured multiline message with actual line breaks or a safely prepared message file. Do not rely on ordinary quoted `\n` escape sequences as portable newlines; a host shell may pass those characters through literally.
+Stop without changing the index on missing or ambiguous authority, stale evidence, an invalid kind/purpose, unrelated staged work, mixed ownership that cannot be separated without guessing, or active merge, cherry-pick, revert, rebase, mail-apply or sequencer state. Preserve pre-existing owned partial staging unless the exact additional content is authorized. Never broaden paths, unstage unrelated work or reset the index to make a boundary fit.
 
-Create one local commit with the prepared subject, optional body, and trailers. Do not push, tag, publish, amend, rebase, or force-push. Afterward observe `HEAD`, the raw complete committed message, committed paths, remaining worktree state, and remote refs when required. A successful commit is still a post-commit mismatch when the observed message differs from the prepared message, including unintended literal `\n` sequences; report and stop without inferring amend or second-commit authority.
+Before reporting eligibility, confirm verification covers the exact proposed content. Matching filenames or a working-tree pass containing excluded changes is insufficient. For a staged slice, compare evidence with the current index. Check excluded code, configuration, fixtures and generated inputs for invalidation. Obtain missing evidence within authority or report the gap; preserve unrelated work.
 
-## Return the receipt
+Before dependent `git add` or `git commit`, run required audits and preparation as separately observed commands by default. If batching, explicitly gate each dependent write on all its prerequisites succeeding; shell newlines and the batch's final exit code do not provide that gate. A failed or unavailable prerequisite blocks its dependent write. Inspect actual index/worktree effects before permitted recovery; later success does not erase an earlier write after failure. Commit's one-attempt rule still applies.
 
-Return the commit SHA, owner and included WorkRefs, committed paths, parsed subject/body/trailers, remaining worktree paths, and explicit omissions. Report a stop before staging, commit failure, or post-commit mismatch truthfully; never silently amend or create a second commit to repair the first.
+For readiness-only work, report eligibility, gaps and the next owner here; do not stage, prepare files or commit.
+
+## Review the final index and message
+
+1. Stage only the authorized content with exact path handling. Reread status, complete cached paths and diff, including sensitive material, and prove one reviewable logical boundary. Stop if it does not match; do not repair unrelated staging.
+2. Confirm the final index matches the content covered by the audited evidence. If staging changed that boundary, reassess applicability and fill only missing or invalidated coverage before proceeding; unchanged applicable results need no rerun. Record the reviewed HEAD (or unborn state) and index tree. These bind content, file modes and deletions, not only names; keep them transient.
+3. Derive the message from that final cached diff, not conversation chronology or a copied Change. Follow applicable project message rules and checks, using the established Conventional form when present and a concise repository-consistent subject. When the project permits and the subject is sufficient, omit the body; otherwise add only the rationale, behavior differences, compatibility or risk needed by a reader without the session.
+4. Load [message and references](references/message.md) for tracked, integration, Group, release, issue-related or non-trivial messages. Keep real removals, migration constraints and important omissions; omit session-only attempts, file inventories and routine command output. A supplied prepared message must still match the reviewed boundary; do not edit it when nearer authority forbids editing.
+5. Prepare actual multiline text, preferably outside the worktree or at an explicitly allowed path. Never use literal backslash-n as a newline transport or include a temporary message file in delivery. Legitimate escape notation in prose stays literal; do not decode it or reject it merely for containing backslash-n.
+
+## Execute once and observe
+
+Use native Git inside this capability; no RSP commit wrapper or generated delivery
+script is required. Missing Commit capability has no Core substitute. Respect a
+nearer required method or denial; an incompatible requirement needs an owner
+decision, not a trial commit or automatic fallback.
+
+1. Inspect operation state through `git rev-parse --git-path` for MERGE_HEAD,
+   CHERRY_PICK_HEAD, REVERT_HEAD, rebase-merge, rebase-apply and sequencer. Any
+   active operation or incomplete inspection stops ordinary delivery. Resolve
+   paths through Git, not a presumed .git directory, so worktrees are covered.
+2. Read HEAD with `git --no-replace-objects rev-parse --verify 'HEAD^{commit}'`.
+   A failed read is not automatically unborn: require `git symbolic-ref -q HEAD`
+   to name refs/heads/... and `git show-ref --verify --quiet <that-ref>` to confirm
+   absence (exit 1). Other errors stop. Immediately before execution, recheck this
+   HEAD/unborn state and `git write-tree` against the reviewed snapshot. A caller's
+   fixed snapshot cannot be replaced on its behalf. Drift stops without index repair.
+3. Attempt exactly once: `git commit --cleanup=verbatim -F <message-file>`, replacing
+   the placeholder with the safely prepared, quoted path. Preserve normal hooks
+   and signing policy; do not disable either to obtain success. Snapshot checks
+   are sequential observations, not a cross-process lock.
+4. Read resulting HEAD, then inspect that immutable SHA using
+   `git --no-replace-objects cat-file commit <sha>` for the raw message, tree and
+   parents, and `git --no-replace-objects diff-tree --root --no-commit-id --name-only --no-renames -r -z <sha>`
+   for actual paths. Use NUL-delimited path observations before and after delivery;
+   do not split unusual filenames on whitespace or treat display quoting as identity.
+5. Require the committed tree and paths to match the reviewed index, one parent
+   equal to reviewed HEAD (no parents for unborn), and the complete stored message
+   to match the prepared text with at most one terminal LF difference. Recheck
+   final HEAD still identifies that SHA and inspect remaining staged, unstaged
+   and untracked work against the prior boundary. Obtain committed facts from the
+   immutable object, not several movable HEAD reads.
+
+Post-commit verification inspects these Git results and hook effects, not routine repetition of product tests. If hooks changed relevant inputs, report which evidence no longer applies; delivery remains stopped on mismatch or uncertain effects.
+
+Exit zero alone is not exact delivery. After any failure, observe HEAD and actual
+index/worktree effects before classifying the result. Distinguish refusal before
+execution, Git failure with observed unchanged HEAD, created-commit mismatch and
+incomplete observation. Even unchanged HEAD cannot rule out hook side effects.
+An attempted commit or uncertain effects stops delivery without retry, amend,
+reset, rollback or a repair commit. Preserve the observed state and report gaps;
+never claim successful delivery when required observations fail or disagree.
+
+## Return the result
+
+Concisely report kind and purpose, owner or refs when relevant, commit SHA when observed, delivered paths and message subject; include remaining work and material omissions when present. Retain the complete message and content/history observations as evidence; expand them when requested or needed to explain a mismatch, not as routine output. For a stop, name the missing condition, observed Git effects and safe next action. No stage grants push, tag, publication, deployment, approval, cross-branch integration or history rewrite.

package/skills/rsp-commit/references/message.md

@@ -0,0 +1,34 @@
+# Message and owned references
+
+Load for tracked, integration, Group, release, issue-related or non-trivial messages after the final cached boundary is reviewed.
+
+## Project contract and subject
+
+Read applicable project instructions, message conventions and configured checks. Recent relevant commits supplement explicit rules, never override them. RSP does not require adopting Conventional Commits; where adopted, distinguish its syntax from stricter project requirements. Report conflicts with required checks instead of bypassing them. Preserve the entrypoint's commit-language precedence.
+
+Derive type from the accepted change and scope from a stable domain or module, not session activities or path inventories. Summarize one reviewable outcome. If the message exposes unrelated outcomes, return to the delivery-boundary check; do not silently split or broaden the authorized commit.
+
+## Body by information need
+
+When project rules permit, omit the body if the subject suffices and no material rationale, compatibility, migration or risk needs explanation. File count and change type alone do not determine that need. Otherwise explain only what a reader without the session needs: the problem and motivation, important old/new behavior differences, consequential tradeoffs or limitations.
+
+For Conventional messages, separate the body from the subject with a blank line. Use prose for causes/tradeoffs, lists for independent points or both as needed. Do not require a bullet list, Why/What/Testing template or prose-plus-list sequence. Omit padding and subject repetition.
+
+Keep real removals, migration constraints and important omissions. Do not copy the Change, execution chronology, routine checks or full path lists. Omit session-only attempts; retain a consequential reason for rejecting an alternative or accepting a tradeoff only when it explains the final design. A decisive measurement or verification limitation may matter, but command success must not imply broader acceptance.
+
+Follow project length and wrapping checks without inventing universal 50/72-character limits. Otherwise wrap for readability without breaking URLs, identifiers, commands or natural Chinese text. If an exact required reference conflicts with a hard check, report the conflict rather than truncating it or bypassing the check.
+
+## Owned footers
+
+Body freedom does not remove footer syntax. Keep footers separated by a blank line from the body, or from the subject when the body is absent. Emit ownership trailers as standalone fields, not body-list items; a necessary footer does not require a filler body. For Conventional breaking changes, use `!` or a `BREAKING CHANGE` footer as permitted, requiring both only when the project does. Explain the affected contract and migration needs proportionately; use the footer's exact token and syntax when present.
+
+Project trailers from real ownership:
+
+- Add one RSP-WorkRef per included Change.
+- Add RSP-Group only when a Group is the durable owner; integration alone emits none.
+- Direct and release without real included WorkRefs emit no RSP trailer.
+- Keep authoritative external references already owned by the work. Use BREAKING CHANGE only for a real breaking contract.
+
+Never invent a WorkRef, Group, issue, co-author, sign-off, breaking change or AI attribution.
+
+Represent owned issue relationships with a proportionate non-closing Issue reference. A terminal delivery with complete selected Change acceptance may additionally use the provider-supported closing keyword only for an explicit closes relation. Checkpoints, relates, ambiguous ownership or unresolved provider/repository identity emit no closing keyword. If shorthand cannot be resolved safely, retain only the canonical URL; do not infer issues from files or mutate the tracker.

package/skills/rsp-doc/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: rsp-doc
+description: Write or revise repository documents, Skills and release communication, including final Change convergence and knowledge writeback. Own writing and author self-checks, not product planning, formal read-only review or publication.
+license: MIT
+metadata:
+  author: oevery
+  version: "2026.10.15.1"
+---
+
+# RSP Doc
+
+For tracked work, read the [shared work model](../rsp/references/work-model.md) when its identity and ownership definitions are missing from the current context. Use logical WorkRefs in commands and reports; cite file locations separately. Direct invocation needs no prior Core execution.
+
+Write a grounded artifact usable without the author conversation. Use the artifact method for whole-record reconciliation, inspect final consistency and retain already-converged text. Local wording fixes and mechanical status/evidence updates need no full writing pass unless the whole record needs reconciliation. A no-op decision needs no new artifact or routine report field.
+
+## Produce the artifact
+
+1. **Fix the outcome.** Identify the reader, task, authorized files and expected result. For a document set, distinguish authoritative owners from summaries. Keep routine narration in conversation and retained evidence with its existing owner.
+2. **Establish the facts.** Read existing content, relevant callers and the smallest authoritative contract, code or source chain. Check commands, defaults, links and behavior with available tools. Distinguish current behavior, intended requirements and unknowns. Resolve material contradictions before rewriting a promise. Interpret tool output as evidence; it grants no permission and does not prove semantic correctness.
+3. **Draft for the task.** Apply the expression rules below and load only the relevant method:
+   - [Artifact lenses](references/artifact-lenses.md): README, CONTEXT, Spec, Change, guides and scoped operating documents.
+   - [Skill authoring](references/skill-authoring.md): Skill creation or revision, including descriptions, package resources and invocation policy.
+   - [Release communication](references/release-communication.md): changelogs, release notes, migration guidance or authorized release-document reconciliation; not ordinary document writing.
+4. **Verify the result.** Check the edited meaning in context. For structural edits, also follow the affected reading path and references. Use the checks below; reuse traceable unchanged mechanical results. Writing completion does not automatically trigger Review, but separately requested or required judgment remains binding.
+
+## Check facts and reading paths
+
+Use the checks relevant to the change:
+
+- Check whether readers can find information, understand conditions, act or judge compliance, and recognize unknowns.
+- Check affected links, anchors, examples and metadata with existing tools. Execute examples only within safe authorized scope.
+- For linked artifacts, compare shared claims, terminology, defaults and handoffs against their authoritative owner. Correct authorized summaries and links without copying full definitions or changing unassigned owners. Report out-of-scope contradictions to their owner.
+- Recheck facts, quantifiers, defaults, failures, permissions and terminology after editing. Report actual checks and remaining gaps.
+- API comments and embedded guidance: compare claims with their contract and implementation without assuming either side correct. Keep ordinary inline comments locally accurate and useful: retain constraints, rationale or usage that nearby code does not make clear, and remove restatement that adds no information; no full writing workflow is needed. Compiler/tool annotations retain implementation ownership.
+- Examples: label illustrative pseudocode or incomplete snippets; check copyable commands against real prerequisites, outcomes and safe use without inferring execution or installation authority.
+
+For agent-facing instructions, trace the relevant branch and its targets. Distinguish local reading-path reasoning from actual agent execution and required independent evidence; retain background human co-readers need.
+
+For a failed command, inspect cause and actual effects before recovery. Change a permitted read/search or repeat-safe check method only within unchanged goal, scope, authority, baseline and required evidence. Named checks and protected RSP operations retain their methods/owners; unavailable Required evidence, unknown mutation or unsafe replay stops affected work.
+
+## Resolve language
+
+- Response: explicit request → personal instructions → conversation language.
+- Existing files: preserve language unless the user asks to change it.
+- New files: explicit artifact language → effective configuration → scoped instructions → conversation language. Resolve needed RSP defaults/inheritance through the selected CLI's successful `rsp config --json`; refresh on relevant drift or recovery. Raw YAML is diagnostic only. Failed projection leaves dependent choices unresolved, not replaced by lower precedence; independent authorized work may continue. Other projects retain their configuration readers.
+- Keep canonical identifiers, machine values and required headings exact.
+
+## Write precisely
+
+- Organize around the reader's task: operations need actions and success signals; contracts need guarantees and exceptions; design needs reasons and tradeoffs. Explain unfamiliar concepts through their task-relevant meaning; include mechanisms needed to reason, troubleshoot or assess guarantees. Reference entries need no forced tutorial. Do not force every artifact into an action list or closing next step.
+- State the actor, action and object directly. Prefer short, complete sentences when easier to follow. Separate independent actions; preserve causal and conditional links. Give each paragraph one useful purpose. Put prerequisites before use, conditions beside actions and exceptions beside their rules. Keep necessary local context; link branch-only detail with its reading condition and purpose.
+- Number steps when their order matters; make each step a bounded action. Use peer bullets for independent items and connected prose for reasoning. Use tables for useful fixed mappings/comparisons, not branching Skill judgments.
+- Remove empty introductions, rhetorical framing, repeated conclusions, filler and irrelevant chronology. Keep author voice, decision-relevant explanations, necessary reasoning and required audit evidence. Replace abstract aspirations with concrete actions. For prescriptive rules, use contrasts or counterexamples only to resolve likely ambiguity. Retain explanatory comparisons needed for understanding, decisions or migration; merge equivalent examples. No fixed sentence length, list size or compression ratio defines quality.
+- Preserve negation, conditions, exceptions, permissions, quantities, units and certainty. Merge failure explanations with the same decision effect. Retain permission, outcome, stop and safe-recovery conditions, including rare boundaries preventing unauthorized action, serious harm or unsafe replay. Keep incident details with their evidence owner. Do not turn a proposal or unknown into a verified fact. Shorter wording proves no behavioral equivalence.
+- Wording edits preserve meaning, information ownership, heading anchors and technical literals: code blocks, commands, paths, identifiers, links, versions and numeric values. Structural edits may merge, move or reorder content within scope while preserving completeness and references. Behavior changes and technical corrections need their own scope and checks; shortening prose grants neither.
+- Use ordinary words for conjunctions. Preserve technical syntax; reserve | for closed alternatives, / for established pairs, → for defined transitions and : for label/value boundaries.
+
+## Preserve ownership
+
+- Follow nearest project instructions and the authorized file boundary. Keep a selected WorkRef when tracked; bounded direct work needs no automatic Change.
+- Doc owns writing and self-checks; formal fixed-scope Review remains read-only and independent when required. A combined request retains both responsibilities: Review grants no repair authority, but originally authorized corrections may continue.
+- Product decisions stay with their design owner. Release writing grants no version decision, release verification, Git delivery or external publication authority. Missing optional methods do not require installation or block an available bounded method.
+- Preserve unrelated work. Ask when a missing choice materially changes the result or authority; stop when required evidence is unavailable. Writing alone grants no installation, deployment, Git delivery or publication.
+
+Return changed artifacts, decisive checks and material limits. Tracked work retains necessary conclusions in its existing record; stable knowledge belongs to its document and retained evidence to its existing owner. Focus maintenance remains Core's responsibility.

package/skills/rsp-doc/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: RSP Doc
+  short_description: 'Write clear, grounded documents and Skills'

package/skills/rsp-doc/references/artifact-lenses.md

@@ -0,0 +1,43 @@
+# Artifact lenses
+
+Choose what the reader must understand, do or judge, not a mandatory template. Preserve project formats and canonical headings; action-first wording is useful for procedures, not a requirement for every artifact.
+
+For a document set, start with the reader's entry point and follow only the links needed for the task. Check that each handoff supplies its prerequisites and that summaries agree with the linked owner. An owner outside the authorized write set remains read-only; return its conflicting claim rather than expanding the edit boundary.
+
+## README
+
+- Help a newcomer find the starting point, prerequisites and first useful result with a recognizable success signal.
+- State important exclusions before setup. Keep a useful overview and local prerequisites; link specialized detail with its reading purpose.
+- Match the audience. A maintainer README need not become an installation tutorial.
+
+## CONTEXT
+
+- Help readers understand domain terms and relationships, then find the authoritative owner; do not duplicate that owner's full contract.
+- Keep names, useful translations and navigation near each definition. Link one authoritative definition across root and local files.
+- Explain different meanings at domain boundaries; do not silently rename them.
+
+## Spec
+
+- Enable a reader to judge compliance: state what a consumer can rely on, under which conditions, with scope, handoffs, failures and exceptions.
+- Keep normative design references and protocol detail needed to establish compliance.
+- Add a scenario only when it resolves ambiguity. Domain headings are valid; no fixed section set is required.
+- Leave future promises in the Change and verification results with their work owner.
+
+For example, “retries are safe” is incomplete when deduplication applies only to the same key. State that condition without inventing retention or failure guarantees.
+
+## Guides and references
+
+- Procedures: give prerequisites, execution context, bounded actions and success signals. Explain a likely failure when it helps the task; keep conditional branches near their triggers.
+- Concepts and design explanations: preserve definitions, causal reasoning and tradeoffs needed to understand or decide; do not replace them with a terse action checklist.
+- References: provide exact contracts and navigable details, not a forced tutorial.
+- Label illustrative snippets; do not present invented output as observed execution. Preserve incoming links after heading changes.
+- API/TSDoc comments: explain the consumer's real inputs, returns, failures and use. Compare examples and claims with their authoritative contract and implementation; report unresolved discrepancies rather than silently documenting whatever code does. Writing authority does not permit implementation changes, execution or dependency installation.
+
+## Operating instructions and work records
+
+- AGENTS: state applicable rules, commands, authority and checks. Changing rules requires explicit scope.
+- Change: retain the six canonical sections and selected delta. Proposal gives the outcome; Spec gives acceptance; Design gives the approach; Tasks state checkable work and completion, with completed items describing the accomplished result; Verify records methods, candidate-bound conclusions, limits and necessary evidence references; Blockers uses the [shared work-model syntax](../../rsp/references/work-model.md) for current impediments.
+- Work records: retain necessary plan/contract changes, outcomes, blockers and scoped verification. Keep routine narration in conversation and needed recovery state in Focus. Before archive, establish facts and justified knowledge writeback; reconcile all six sections with current outcomes, superseded plans and knowledge owners. Retain facts affecting the delivered contract, evidence applicability, important failure disposition or remaining limit. Link knowledge and evidence owners; preserve their detailed records and original verdicts. Correct stale authoritative contracts. Return substantive contradictions to their owner; prose cleanup cannot settle them.
+- Decision Record: let readers understand why a choice was made, its alternatives and consequences, without redefining the contract.
+- Audit/run records: retain required observations, actions and evidence. Remove irrelevant session narration, not the record's purpose.
+- Skill packages: use Doc's Skill-authoring branch. Release communication uses Doc's conditional release method.