@oevery/rsp 3.2.0 → 4.0.0

package/dist/entry-RG6HREUN.mjs

@@ -1,174 +0,0 @@
-#!/usr/bin/env node
-import {
-  inspectPackagedSkillInventory
-} from "./chunk-JYDEJEM4.mjs";
-import {
-  openTerminalSession,
-  truncateDisplay
-} from "./chunk-JOMFFQRG.mjs";
-import "./chunk-SEGJLWRE.mjs";
-
-// src/skills-tui/entry.tsx
-import process from "process";
-import { render } from "ink";
-import ReactRuntime from "react";
-
-// src/skills-tui/app.tsx
-import { Box, Text, useApp, useInput, useStdout } from "ink";
-import { useMemo, useState } from "react";
-import { jsx, jsxs } from "react/jsx-runtime";
-function SkillsApp({ initialWidth, inventory, messages, onComplete }) {
-  const { exit } = useApp();
-  const { stdout } = useStdout();
-  const width = Math.max(40, initialWidth ?? stdout.columns ?? 80);
-  const optional = useMemo(() => inventory.skills.filter((skill) => skill.kind === "optional"), [inventory]);
-  const defaults = useMemo(() => inventory.skills.filter((skill) => skill.kind === "default"), [inventory]);
-  const [selected, setSelected] = useState(/* @__PURE__ */ new Set());
-  const [cursor, setCursor] = useState(0);
-  const [phase, setPhase] = useState("select");
-  const finish = (selection) => {
-    onComplete(selection);
-    exit();
-  };
-  const selectedNames = () => [...defaults.map((skill) => skill.name), ...optional.filter((skill) => selected.has(skill.name)).map((skill) => skill.name)].sort();
-  useInput((input, key) => {
-    if (phase === "replace") {
-      if (input.toLowerCase() === "y") {
-        finish({ kind: "confirmed", names: selectedNames(), force: true });
-      } else if (input.toLowerCase() === "n" || key.escape) {
-        finish({ kind: "cancelled" });
-      }
-      return;
-    }
-    if (key.escape || input === "q" || key.ctrl && input === "c") {
-      finish({ kind: "cancelled" });
-      return;
-    }
-    if ((key.upArrow || input === "k") && optional.length > 0) {
-      setCursor((value) => (value - 1 + optional.length) % optional.length);
-    } else if ((key.downArrow || input === "j") && optional.length > 0) {
-      setCursor((value) => (value + 1) % optional.length);
-    } else if (input === " " && optional[cursor]) {
-      const name = optional[cursor].name;
-      setSelected((current) => {
-        const next = new Set(current);
-        if (next.has(name))
-          next.delete(name);
-        else
-          next.add(name);
-        return next;
-      });
-    } else if (key.return) {
-      const names = selectedNames();
-      const divergent = inventory.skills.some((skill) => names.includes(skill.name) && skill.status === "divergent");
-      if (divergent)
-        setPhase("replace");
-      else
-        finish({ kind: "confirmed", names, force: false });
-    }
-  });
-  const status = (value) => messages[value];
-  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width, children: [
-    /* @__PURE__ */ jsx(Text, { bold: true, children: messages.title }),
-    /* @__PURE__ */ jsx(Text, { children: truncateDisplay(`${inventory.package.name}@${inventory.package.version}`, width) }),
-    /* @__PURE__ */ jsx(Text, { children: truncateDisplay(`${messages.target}: ${inventory.target}`, width) }),
-    /* @__PURE__ */ jsx(Text, { children: " " }),
-    /* @__PURE__ */ jsx(Text, { bold: true, children: messages.defaultHeading }),
-    defaults.map((skill) => /* @__PURE__ */ jsx(Text, { children: truncateDisplay(`  [x] ${skill.name}  ${messages.locked} \xB7 ${status(skill.status)}`, width) }, skill.name)),
-    /* @__PURE__ */ jsx(Text, { children: " " }),
-    /* @__PURE__ */ jsx(Text, { bold: true, children: messages.optionalHeading }),
-    optional.length === 0 && /* @__PURE__ */ jsx(Text, { dimColor: true, children: `  ${messages.none}` }),
-    optional.map((skill, index) => /* @__PURE__ */ jsx(Text, { children: truncateDisplay(`${index === cursor ? "\u203A" : " "} ${selected.has(skill.name) ? "[x]" : "[ ]"} ${skill.name}  ${status(skill.status)}`, width) }, skill.name)),
-    /* @__PURE__ */ jsx(Text, { children: " " }),
-    /* @__PURE__ */ jsx(Text, { color: phase === "replace" ? "yellow" : void 0, children: phase === "replace" ? messages.replaceTitle : messages.selectHelp }),
-    phase === "replace" && /* @__PURE__ */ jsx(Text, { children: messages.replaceHelp })
-  ] });
-}
-
-// src/skills-tui/messages.ts
-var skillsCatalogs = {
-  "en": {
-    title: "RSP Skill manager",
-    target: "Target",
-    defaultHeading: "Default suite Skills",
-    optionalHeading: "Optional project Skills",
-    missing: "missing",
-    unchanged: "unchanged",
-    divergent: "divergent",
-    locked: "locked",
-    none: "none",
-    selectHelp: "\u2191/\u2193 move \xB7 Space select \xB7 Enter confirm \xB7 Esc cancel",
-    replaceTitle: "Replace divergent selected Skills?",
-    replaceHelp: "y replace \xB7 n cancel"
-  },
-  "zh-CN": {
-    title: "RSP Skill \u7BA1\u7406\u5668",
-    target: "\u76EE\u6807",
-    defaultHeading: "\u9ED8\u8BA4\u5957\u4EF6 Skills",
-    optionalHeading: "\u53EF\u9009\u9879\u76EE Skills",
-    missing: "\u672A\u5B89\u88C5",
-    unchanged: "\u4E00\u81F4",
-    divergent: "\u6709\u5DEE\u5F02",
-    locked: "\u9501\u5B9A",
-    none: "\u65E0",
-    selectHelp: "\u2191/\u2193 \u79FB\u52A8 \xB7 \u7A7A\u683C\u9009\u62E9 \xB7 \u56DE\u8F66\u786E\u8BA4 \xB7 Esc \u53D6\u6D88",
-    replaceTitle: "\u66FF\u6362\u6240\u9009\u7684\u5DEE\u5F02 Skill\uFF1F",
-    replaceHelp: "y \u66FF\u6362 \xB7 n \u53D6\u6D88"
-  }
-};
-
-// src/skills-tui/entry.tsx
-var signalExitCodes = { SIGHUP: 129, SIGINT: 130, SIGTERM: 143 };
-var defaultRuntime = {
-  inspect: inspectPackagedSkillInventory,
-  render,
-  openSession: openTerminalSession,
-  host: process,
-  reportError: (message) => console.error(message)
-};
-async function runSkillsTui(locale, runtime = defaultRuntime) {
-  const screenReader = runtime.host.env.INK_SCREEN_READER === "true" || runtime.host.env.INK_SCREEN_READER === "1";
-  const session = runtime.openSession(runtime.host.stdout, { screenReader });
-  let instance;
-  let selection = { kind: "cancelled" };
-  const listeners = /* @__PURE__ */ new Map();
-  let cleaned = false;
-  const cleanup = () => {
-    if (cleaned)
-      return;
-    cleaned = true;
-    for (const [signal, listener] of listeners)
-      runtime.host.off(signal, listener);
-    listeners.clear();
-    instance?.unmount();
-    session.cleanup();
-  };
-  try {
-    const inventory = await runtime.inspect();
-    instance = runtime.render(ReactRuntime.createElement(SkillsApp, {
-      inventory,
-      messages: skillsCatalogs[locale],
-      onComplete: (value) => {
-        selection = value;
-      }
-    }), { exitOnCtrlC: false, patchConsole: false });
-    for (const signal of Object.keys(signalExitCodes)) {
-      const listener = () => {
-        cleanup();
-        runtime.host.exit(signalExitCodes[signal]);
-      };
-      listeners.set(signal, listener);
-      runtime.host.once(signal, listener);
-    }
-    await instance.waitUntilExit();
-    cleanup();
-    return selection;
-  } catch (error) {
-    cleanup();
-    runtime.reportError(`  Error: ${error instanceof Error ? error.message : String(error)}`);
-    return { kind: "error" };
-  }
-}
-export {
-  runSkillsTui
-};

package/rules/rsp-rules.md

@@ -1,47 +0,0 @@
----
-name: rsp-rules
-description: Minimal fallback protocol for Rules, Specs, and Plans driven development.
----
-
-# RSP fallback protocol
-
-This file is the minimal fallback protocol for agents that cannot load the `rsp` Skill. It is a compatibility and safety kernel, not a replacement for project instructions, installed Skills, or durable design documentation.
-
-## Entry
-
-- Read the nearest `AGENTS.md` and relevant `CONTEXT.md` before RSP work. Use the root `CONTEXT-MAP.md` when present.
-- Apply this fallback before operating `.rsp/` only after the Core Skill is absent or cannot be used.
-- Treat `focus.d/` as the only current-focus source. For grouped work, read the sibling Group Brief before the explicitly focused child Change. Then read only the relevant Specs and Decision Records under the configured authoritative path.
-- If `focus.d/` is empty and the user has not provided a concrete task, ask what to work on or suggest `npx -y @oevery/rsp create <name>`. Do not infer current work from open Changes or filenames.
-
-## Ownership
-
-- `changes/` owns open work, `archives/` owns completed history, `specs/` owns stable current facts, and the configured Decision Record path owns lasting rationale and tradeoffs.
-- A Change owns one executable outcome and its acceptance, Tasks, verification, and blockers. Executable WorkRefs are `<change>` or one direct `<group>/<change>` child. A Group Brief provides shared context but is not executable or focusable.
-- For a new inferred WorkRef, preserve explicit valid user input first, otherwise follow an explicit nearest project or domain naming convention, otherwise use ASCII lowercase kebab-case from stable domain or technical vocabulary. Language or locale settings never select or translate WorkRef language. Valid Unicode remains available through explicit input or project/domain convention, and existing identities are never renamed by later guidance.
-- Persist only `open` and `archived` lifecycle state. Readiness, blockers, routes, verification freshness, progress, and next actions are derived from current artifacts and evidence.
-- Project-owned `AGENTS.md` and `CONTEXT.md` retain their own instruction and context authority. RSP does not replace them.
-- Prefer RSP commands for deterministic setup, status, validation, repair, focus, Spec-index, history, archive, and reopen operations. Invalid identity, structure, dependency, managed path, symlink, or incomplete inspection fails closed.
-
-## One bounded action
-
-- Derive the next action from user intent, explicit authority, the selected WorkRef, its current Change and Group Brief when any, relevant durable facts, the worktree, and fresh status or verification evidence.
-- Perform at most one bounded ordinary Core action or one optional Discipline action against the same owner. A mutation requires one ready owner, an explicit boundary, settled acceptance criteria, and one decisive verification. Do not auto-continue a successor or widen the boundary because more work is visible.
-- When an optional Discipline Skill is unavailable, a compact manual fallback may cover only the same bounded owner and action. It never substitutes for a required managed worker, independent verification, unresolved product or authority decision, or missing acceptance.
-- Before later mutation or a different WorkRef, rederive authority and inspect dirty product and durable-truth paths. Continue the same owner, use an explicitly authorized reopen or integration owner, or stop for boundary resolution when ownership overlaps or remains uncertain.
-- If the action becomes multi-owner, cross-boundary, dependent on managed coordination, or unsafe without an unavailable capability, stop. Return the missing capability or input, decisive evidence, next owner, and the condition for safe resumption.
-
-## Durable routing
-
-- Route planned future design to the selected Change; stable implemented facts to the smallest authoritative Spec or explicitly authorized project context; lasting rationale to the configured Decision Record path when warranted; and temporary execution or continuation state to the response.
-- Keep a Change as a convergent current-plan and final-evidence snapshot, not an append-only execution log. Replace superseded plans and evidence; keep routine attempts, transcripts, and temporary probes out of durable artifacts.
-- Before archive, judge current-fact and rationale updates independently, then compress the Change to the delivered outcome, current design, completed Tasks, decisive final verification, unresolved blockers, and remaining risk. Change Spec deltas are never promoted automatically.
-- Use the response language for user-visible narration while preserving exact WorkRefs, paths, commands, headings, and machine values. Preserve each existing artifact's established language unless translation is explicitly authorized.
-
-## Safety ceiling
-
-- This fallback does not emulate `rsp-manage`, ready-owner qualification, worker dispatch, convergence loops, managed resume, or configured closeout. Configuration selects no capability and grants no planning, product-mutation, lifecycle, Git, publication, deployment, approval, or human-acceptance authority.
-- Do not create or repair command-owned RSP files directly. Do not create archives or restore archived content by editing files; use the owning RSP command only with explicit lifecycle authority.
-- This fallback never archives, closes a Group, stages, commits, tags, pushes, publishes, deploys, deletes unrelated work, or records external approval. Those actions require their own explicit authority and available owning capability.
-- On malformed or incomplete evidence, ambiguous focus or ownership, unresolved decisions, unavailable required capability, failed verification, or out-of-scope work, fail closed without mutation. State what was inspected, what is missing, who owns the next decision or action, and what evidence or authority permits resumption.
-- Return the selected `WorkRef`, effective authority, changed artifacts, fresh verification, blockers, and next action. This response is not durable truth or a second state store.

package/skills/rsp/references/managed-routing.md

@@ -1,44 +0,0 @@
-# Managed routing
-
-Load this reference only for a requested completion or continuation that is not a report-only review or release operation and is either explicitly managed or has effective `manage.activation: auto` in status. Missing configuration preserves `explicit` activation with `local` closeout compatibility. Invalid configuration fails closed as `explicit` plus `manual` and must remain visible.
-
-## OWNER PREFLIGHT — Core resolves the owner without execution
-
-Use this route after Core has preserved the fixed-scope Review, release, isolated Design, and tiny settled-work exceptions. Here fixed-scope Review means the explicit report-only fixed-scope change review. Under `manage.activation: explicit`, consider Manage only for an explicitly managed request. Under `manage.activation: auto`, consider it for every other requested completion or continuation that does not satisfy the complete small-work exclusion: one owner, one local seam, one mutation pass, one decisive check, no managed lifecycle coordination, and no ready successor.
-
-Treat the requested goal and independently allowed planning and product mutations as a transient authority envelope. Automatic activation grants controller selection only and never adds planning or product-mutation authority. Core resolves the smallest sufficient owner before testing Manage eligibility, without dispatching work or mutating product state.
-
-Before focusing, dispatching, or mutating a different WorkRef, inspect dirty paths and the diff against the prior owner's declared and observed product or durable-truth paths. Overlap never changes owner implicitly: continue the same open WorkRef, explicitly reopen its archived acceptance when authorized and applicable, use an explicitly authorized integration owner, or stop for boundary resolution. Disjoint authorized work may proceed without staging or a forced commit; insufficient ownership evidence stops the transition.
-
-Core derives one ownership `ControlOutcome`. `WorkOwner` means the selected shape-ready Change or shallow Group. When one unambiguous ready WorkOwner exists, Core proceeds to QUALIFY. Missing or non-ready ownership uses `RouteDisposition: shape` only when the current request or nearer authority independently permits in-scope RSP planning artifacts; configuration alone never does. Shape returns the ready WorkOwner to Core, which re-reads status and freshly derives ownership, route, and qualification without another authorization round. A material product or authority decision stops with `StopDisposition: ask-owner` and names its `DecisionOwner`. An invalid WorkRef, topology, dirty-path, route, scope, or authority boundary stops with `StopDisposition: reroute` rather than converting it into a product question.
-
-A prior direct report, design, tiny, or small route is not sticky. Before later-turn mutation, rederive from the now-authorized objective and prospective work. Material expansion into cross-module implementation, multiple acceptance surfaces, repeated production-path correction, real-host validation, bounded review convergence, lifecycle delivery, or a clear ready successor requires Core to establish or reuse the smallest sufficient WorkRef and rerun owner preflight plus fresh Manage qualification before mutation. Unchanged tiny/small follow-ups remain direct; elapsed time and message count alone never trigger escalation.
-
-Owner preflight creates no Task, Blocker, worker envelope, frontier, ticket, run record, or synthetic WorkRef. Manage has no pre-owner Intake and never creates, focuses, or reshapes the durable owner.
-
-## QUALIFY — select or decline Manage
-
-Select `rsp-manage` only for one selected ready Change or shallow Group that qualifies through at least one independent path: genuinely independent slices, interruption recovery, or prospective execution signals showing more than one bounded phase or authority surface. Prospective signals are implementation followed by integration verification, managed review, or lifecycle work; cross-module or cross-process mutation; real-host, provider, or hardware verification; bounded finding convergence; or a clear ready successor. A Change with prospective or recovery work does not also need independent or parallelizable slices. Derive these signals before dispatch from the authorized objective and expected phases; elapsed wall-clock minutes are never qualification evidence.
-
-A Group qualifies when it has at least two ready children, or when the continuation qualifies through prospective signals or recovery.
-
-Under automatic activation, bias non-small continuation toward Manage. A tracked completion spanning authoritative Specs, product presentation, public documentation, and multiple verification surfaces is multi-surface non-small work and reports `selected` even when one writer owns all mutations and dispatch must remain sequential. Writer count and lack of parallelism do not collapse multiple acceptance or authority surfaces into one local seam.
-
-Decline as direct one-step work only when all of these are true: one owner, one local seam, one mutation pass, one decisive check, no managed lifecycle coordination, and no ready successor. A selected ready completion or continuation that fails any one of these conditions qualifies as non-small through this automatic path even when no separate prospective signal is obvious; do not leave the middle case unclassified. Worker-only work remains ineligible. Readiness alone does not qualify work without a requested completion or continuation, and automatic routing remains bounded by the requested goal.
-
-Make the route observable: report `selected` with the decisive qualification signal, or `declined` with the complete direct-work exclusion and exact Core or Discipline action. If dispatch applies, report the concrete overlap/isolation evidence that makes it sequential or parallel. Selection, decline, and dispatch reasoning remain transient and create no controller state.
-
-## HANDOFF AND RETURN — bound selected execution
-
-Core and this reference solely own initial qualification and the `selected | declined` route result. Core hands selected Manage the goal, WorkRef, authority envelope, decisive qualification evidence, closeout ceiling, and exact return boundaries as transient control data. Manage validates handoff completeness and current owner, authority, and diff drift, but never repeats direct-versus-managed eligibility. Selected execution remains wholly owned by `rsp-manage`.
-
-- Ordinary Fix, Verify, Review, or Resolve Findings receipts remain inside Manage for fresh same-goal revalidation.
-- A clear in-scope ready successor under the unchanged owner topology and authority may continue inside the same managed goal.
-- Owner identity, topology, requested route, behavior, acceptance, public interface, scope, mutation authority, or external-action authority changes return evidence to Core for fresh ownership and routing.
-- Shape is entered only through Core when durable owner refinement is independently authorized.
-
-Never persist the goal envelope, WorkSet, waves, discovery classification, or transition chronology.
-
-## Dormant closeout fail-safe
-
-If Manage was declined, unavailable, or unselected, every `manage.closeout` preset is dormant: ordinary Core may report readiness and the explicit next lifecycle or Git action, but configuration executes neither archive nor commit. Readiness, an earlier managed run, or project policy never substitutes for current selection and qualification. After selection, stop using this reference for execution detail; `rsp-manage` solely owns same-goal revalidation, interruption and resume, review convergence, acceptance, lifecycle closeout, commit eligibility and orchestration, and all corresponding authority stops. Exact staging, message construction, local commit execution, and post-commit observation remain owned by `rsp-commit`.

package/skills/rsp/references/release-operations.md

@@ -1,9 +0,0 @@
-# Release operations
-
-Load this reference only when the user explicitly requests release documentation, finalization, publication, or reconciliation and `rsp-release-docs` is unavailable. Load it before requiring a confirmed identity, range, or clean candidate. A selected Change is not required, and lifecycle stage or archive readiness alone is insufficient.
-
-First resolve the release identity or range and inspect the exact candidate. Release identity is an owner decision confirmed only by explicit user instruction or authoritative repository release configuration. Never infer it from version order, a previous prerelease, commits, or planned prose. Until confirmation, keep ledgers version-neutral and leave manifests, target changelog headings, exact-version commands, versioned notes, and tag comparisons unchanged. An unconfirmed identity or range, unclean exact candidate, missing owner, or material release-surface ambiguity stops before versioned mutation and returns the required owner input.
-
-Use an evidence-led manual fallback equivalent to the unavailable Discipline. An explicit tag, hosted release, registry publication, or equivalent public action must first pass finalization against a clean exact candidate after implementation Change closeout. Finalize versioned shipped surfaces in a separate release commit when Git delivery is authorized. The credential-free `ready` or `not ready` handoff never executes or grants commit, tag, push, release creation, publication, deployment, or approval authority.
-
-Use an optional Release Change only for material decisions, cross-stage coordination, recovery, blockers, or acceptance needing a persistent owner—never for a mechanical checklist. After observed publication, reconcile unfinished verification or authorized mutable-surface corrections; preserve immutable history and assign drift to a corrective version or owner.

package/skills/rsp-design/SKILL.md

@@ -1,53 +0,0 @@
----
-name: rsp-design
-description: Resolve one material domain-model, module/seam, or evidence-seeking design question before a Change or for an explicit or focused RSP Change without implementing production behavior or writing durable project truth.
-license: MIT
-metadata:
-  author: oevery
-  version: "2026.07.27.1"
----
-
-# RSP Design
-
-Resolve one design question. Do not implement it.
-
-## Establish the question and authority
-
-State one explicit bounded design question. Read project authority and the smallest relevant Specs, decisions, code, tests, callers, and runtime evidence.
-
-Choose one ownership mode:
-
-- **Pre-Change Design:** use when no Change is selected and the request already contains one bounded design question. When this Skill is installed, Core selects it instead of manually emulating the discipline; the manual fallback is only for an unavailable Skill. Remain report-only and return to the user. If outcome, scope, non-goals, acceptance, or decomposition remains materially unclear, return the request to Shape instead of creating an implicit planning owner. Do not invent a WorkRef, continuation, or artifact.
-- **Tracked Design:** require an explicit WorkRef or exactly one unambiguous focus marker. Read the selected Change and sibling Group Brief, then return the result to the same WorkRef.
-
-Stop on an ambiguous question, evidence boundary, owner intent, authorized-write owner, or required mutation authority. Never invent product intent.
-
-## Load one design mode
-
-Load only the reference matching the question:
-
-- Read [domain modeling](references/domain-modeling.md) for vocabulary, identity, lifecycle, invariants, relationships, or ownership.
-- Read [module and seam design](references/module-seams.md) for interface obligations, caller complexity, adapters, test surfaces, or seam placement.
-- Read [reversible exploration](references/reversible-exploration.md) only when a material conclusion depends on unobserved behavior and a cheap safe probe can provide it.
-
-Separate evidence-driven conclusions from owner choices. Compare one credible alternative when alternatives exist; do not manufacture options when evidence or authority forces the conclusion.
-
-## Preserve artifact ownership
-
-Default to report-only. Pre-Change Design never mutates artifacts. In Tracked Design, when the user or project explicitly authorizes updating the selected Change, write settled planned design only under its `Design` section. Do not write Specs, Decision Records, `CONTEXT.md`, `AGENTS.md`, production code, lifecycle state, focus, archives, or Git state. Identify possible durable current facts or rationale only as artifact-routing candidates for the Core durable review.
-
-An exploration additionally requires explicit disposable-code authority and the cleanup contract in its reference. A design request alone grants neither production mutation nor external side-effect authority.
-
-## Return the bounded result
-
-Follow Core's response-versus-artifact language boundary: use the requested language for natural prose, while any authorized `Design` update follows the selected Change's language and canonical headings. Do not use a technical token alone as a response label; retain it only in parentheses after a localized label. Return these semantic fields:
-
-- ownership mode, selected WorkRef when tracked, and exact question;
-- inspected evidence and material gaps;
-- recommendation and evidence-driven reasoning;
-- credible alternatives and tradeoffs;
-- unresolved owner decisions;
-- artifact routing and any authorized Change update;
-- smallest next action.
-
-Pre-Change results return to the user; name Shape as the smallest next action only when accepted work needs an executable owner. Tracked results return to Shape or the user against the same WorkRef. Do not create parallel state, recursively invoke another Skill, implement, review, archive, stage, commit, push, publish, deploy, or approve.

package/skills/rsp-design/references/domain-modeling.md

@@ -1,11 +0,0 @@
-# Domain modeling
-
-Use this procedure only for a question about domain language, identity, lifecycle, invariants, relationships, or ownership.
-
-1. Collect the project's existing terms from its authoritative context, Specs, code, tests, and user language. Record contradictions rather than silently choosing one source.
-2. Trace concrete scenarios across creation, transition, failure, cancellation, deletion, and relevant scope boundaries. Prefer observable lifecycle evidence over type names alone.
-3. Identify each concept's identity, owner, allowed transitions, invariants, and relationships. Distinguish a domain concept from a transport shape, persistence record, UI label, or implementation helper.
-4. Propose the smallest coherent vocabulary and ownership model that explains the evidence. Test it against at least one edge case and one existing production consumer.
-5. Separate conclusions forced by evidence from product choices that require owner confirmation.
-
-Return canonical terms, definitions, ownership and lifecycle implications, conflicts with current usage, alternatives, and unresolved owner decisions. Planned vocabulary may update only the authorized selected Change `Design`; flag possible current-fact or rationale destinations without writing them.

package/skills/rsp-design/references/module-seams.md

@@ -1,11 +0,0 @@
-# Module and seam design
-
-Use this procedure only for a question about an interface, caller complexity, adapter, test surface, or seam placement.
-
-1. Trace the direct production consumer and the smallest complete call/data path before proposing a seam. Confirm the live path reaches the candidate owner.
-2. List what callers must know: inputs, outputs, invariants, ordering, failures, configuration, cancellation, and relevant performance constraints.
-3. Locate where behavior or policy actually varies. Do not add an interface for hypothetical variation or wrap an existing pass-through for symmetry.
-4. Compare credible placements by caller leverage, implementation locality, dependency direction, state ownership, and whether callers and tests can use the same public surface.
-5. Recommend the smallest interface that hides meaningful complexity while preserving domain ownership. State migration or compatibility consequences without implementing them.
-
-Return the proposed owner, seam, interface obligations, affected consumers, verification surface, alternatives, and unresolved owner decisions. Treat code sketches as explanatory output only; do not write production code.

package/skills/rsp-diagnose/SKILL.md

@@ -1,46 +0,0 @@
----
-name: rsp-diagnose
-description: Diagnose one selected RSP Change when a reproducible or materially evidenced failure has an unexplained cause or owning layer. Use for conflicting, intermittent, or multi-layer symptoms before production correction.
-license: MIT
-metadata:
-  author: oevery
-  version: "2026.07.22.1"
----
-
-# RSP Diagnose
-
-Establish a confirmed cause before correction. Keep the selected Change as owner and return investigation evidence to it.
-
-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.
-
-## Establish bounds
-
-Resolve exactly one executable open Change from an explicit work reference or unambiguous focus. Read the user request, nearest project instructions, relevant context, RSP rules, the sibling Group Brief when present, the selected Change, and only the code, tests, logs, configuration, and worktree evidence needed to investigate.
-
-A diagnosis request grants read-only investigation and safe diagnostic command execution. Editing tests, instrumentation, fixtures, or the Change requires explicit mutation authority. Production correction is outside this Skill even when separate fix authority exists.
-
-Stop with one evidence request when the target, expected behavior, investigation scope, or safe reproduction conditions are unclear.
-
-## Diagnose
-
-1. **REPRODUCE.** Capture the smallest command or observation that exposes the symptom, its expected and actual result, and relevant conditions. When reproduction is unsafe or unavailable, label the supplied evidence and its limits. Continue only with a stable symptom or material evidence.
-2. **LOCATE.** Trace the live path to the first boundary where actual behavior diverges from expected behavior. Identify the affected layer and owner; verify that any suspected adapter, validator, cache, or wrapper is reached by the production consumer.
-3. **HYPOTHESIZE.** State the smallest set of live competing causes and the distinct observation each predicts. A single hypothesis is sufficient only when existing evidence already excludes credible alternatives.
-4. **DISCRIMINATE.** Run the smallest safe check that separates the leading hypotheses. Record the exact command or observation and decisive result. Prefer one discriminating check over broad speculative changes.
-5. **CONFIRM.** Confirm a cause only when observed evidence selects it over the remaining live alternatives and explains the reproduced symptom. Otherwise return `unresolved` with the missing evidence and one bounded next check.
-
-## Return evidence
-
-Return:
-
-- selected Change;
-- result: `confirmed` or `unresolved`;
-- reproduction or supplied-evidence limit;
-- cause and affected owner, or remaining hypotheses;
-- decisive evidence and impact boundary;
-- investigation mutations, if explicitly authorized;
-- exactly one next action.
-
-For `confirmed`, name one correction entrypoint owned by the same Change; do not apply it. For `unresolved`, name the next discriminating check or blocker. Update that Change's Tasks, Verify, or Blockers only with authority and observed facts. Preserve unrelated work and never infer Git, delivery, publication, or approval authority.
-
-When correction, further discrimination, or other work remains, use Core's compact continuation fields in order: `WorkRef`, `Authority`, `Current state`, `Changed artifacts`, `Fresh verification`, `Blockers`, and `Next action`. Put the result, reproduction limit, cause or hypotheses, decisive evidence, and impact boundary in `Current state`; put authorized investigation mutations in `Changed artifacts`. Reopen authority pointers, inspect drift, and refresh decisive evidence before resuming. This response is not durable truth or a second state store; persist it only with explicit path authority.

package/skills/rsp-manage/SKILL.md

@@ -1,96 +0,0 @@
----
-name: rsp-manage
-description: Coordinate one eligible long-running, recovery, or multi-slice RSP goal across ready Changes or a shallow Group without expanding its authority.
-license: MIT
-metadata:
-  author: oevery
-  version: "2026.08.05.2"
----
-
-# RSP Manage
-
-Manage one requested goal selected by Core from an explicit request or effective `manage.activation: auto`. Enter only with one selected shape-ready Change or shallow Group plus a transient handoff containing the goal, WorkRef, authority envelope, decisive qualification evidence, closeout ceiling, and return boundaries. Once selected, this Skill solely owns same-goal revalidation, interruption and resume, review convergence, acceptance, lifecycle closeout, and commit eligibility and orchestration. Exact staging, message construction, local commit execution, and post-commit observation remain owned by `rsp-commit`. Keep artifacts durable and process data transient. The goal defines authority; automatic activation grants selection, not mutation.
-
-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.
-
-## Selected-goal entry
-
-Core resolves ownership before this Skill is entered. Manage has no pre-owner Intake and never creates, focuses, or reshapes a durable owner. Reject an incomplete handoff without mutation and return to Core with the missing owner, authority, qualification, closeout, or return-boundary evidence.
-
-## Validate the selected handoff before mutation
-
-Core and its managed-routing reference solely own initial Manage qualification and the `selected | declined` route result. Manage never repeats the direct-versus-managed eligibility test or declines a valid selected handoff back to an ordinary Core or Discipline action.
-
-Before dispatch, validate the handoff against current evidence by re-reading all of the following:
-
-- every selected WorkRef, including clear in-scope successors;
-- the complete owning Change, or the Group Brief and its children;
-- relevant Specs and Decisions;
-- the authority envelope, `rsp status --json`, and the current worktree.
-
-Validate only handoff completeness and current drift: the selected owner and topology still match, the requested goal and route are unchanged, the authority envelope still permits the next action, owned paths remain exact and unmixed, and the decisive qualification evidence has not been invalidated. If the handoff is incomplete, evidence has drifted, or a true owner, topology, route, behavior, acceptance, interface, scope, mutation-authority, or external-action-authority boundary changed, stop without mutation and return the decisive evidence to Core. Otherwise continue the selected managed goal without repeating qualification. When dispatch applies, report only the concrete reason for sequential or parallel execution. Keep validation and dispatch reasoning transient.
-
-Preserve unrelated work and require an explicit release identity. Allow four worker dispatches and one worker corrective retry across the whole managed run. Owner transitions do not reset either limit.
-
-## Resolve the execution frontier
-
-After the selected handoff remains valid, classify every newly surfaced unknown before selecting work, in this fail-closed compatibility order: `out-of-goal` → `owner-decision` → `fog` → `evidence-needed` → `ready-to-execute`. The canonical `FrontierDisposition` is exactly `out-of-goal`, `owner-decision`, `fog`, `evidence-needed`, or `executable`; public `ready-to-execute` maps only to canonical `executable`.
-
-- `out-of-goal` stops for topology or authority resolution with `StopDisposition: reroute`.
-- `owner-decision` stops with the single highest-impact question for its `DecisionOwner` when behavior, acceptance, public interface, scope, mutation authority, external action, or human acceptance is unresolved. Return `StopDisposition: ask-owner` to Core for fresh routing after the answer.
-- `fog` is not yet a precise question. Create no synthetic Task, Change, Blocker, or worker dispatch; return `StopDisposition: return-to-shape` to Core and halt the current managed control phase. Only Core may route authorized Shape. Do not continue an independently ready slice, dispatch another worker, or mutate product state. Resume only after Shape confirms a ready owner and Core freshly rederives the route.
-- `evidence-needed` is one precise factual question answerable without choosing any owner decision above. If evidence would cross one of those boundaries, take the applicable stop instead of selecting Fix.
-- Canonical `executable` permits lane selection only after ownership, authority, and required evidence are settled.
-
-`StopDisposition` is exactly `ask-owner`, `return-to-shape`, `reroute`, `retry-with-evidence`, `environment-blocked`, `verification-blocked`, or `capability-unavailable`. No stop disposition permits another worker dispatch, product mutation, lifecycle closeout, or Git action until its stated resume contract succeeds.
-
-Every lane receives one transient `WorkerEnvelope` with these common fields: `WorkRef`, `lane`, `objective`, `current hypothesis` when one exists, `known evidence`, `allowed paths`, `allowed actions and commands`, `prohibited actions`, `comparison baseline`, `expected result schema`, `response language`, `localized control-narration rule`, and `stop conditions`. The narration rule requires human-facing receipt prose in the response language and preserves the exact result only as a secondary parenthesized or code-formatted token; it applies equally to private Inspect and Verify lanes that have no standalone Skill. Never include token counts or context-size targets; they do not influence dispatch, authority, continuation, completion, or acceptance.
-
-- Diagnose reuses `rsp-diagnose` and remains read-only until it returns a discriminating cause or an explicit no-cause result. Its result is exactly one of `confirmed-same-scope`, `unresolved-same-scope`, or `boundary-changed`; the receipt also gives decisive evidence and the next safe discriminating check when one exists.
-- Inspect is a private Manager-only read-only lane. It gathers one independent evidence packet and may run alongside another read-only lane only when paths and verification resources are demonstrably isolated; otherwise keep it sequential. Its result is exactly one of `confirmed-same-scope`, `unresolved-same-scope`, or `boundary-changed`; the receipt also gives decisive evidence and the next safe discriminating check when one exists.
-- Fix reuses `rsp-implement`, receives explicit in-scope mutation authority, and is the sole product writer at its mutation boundary. Separate Group child mutation boundaries may overlap only under the existing isolated workspace and verification rule. Its result is exactly one of `changed-same-scope`, `no-change`, or `boundary-changed`; the receipt also gives `worker identity` when the host exposes it, changed paths, and fresh verification evidence.
-- Verify is a private Manager-only read-only lane and runs only for the Change-declared risk or after a failed correction. Its result is exactly one of `pass`, `failed-with-new-evidence`, `failed-without-new-evidence`, `unavailable`, or `boundary-changed`; the receipt also gives named checks, the observed diff boundary, `worker identity` when the host exposes it, and `independence: established | unavailable`. Fixed-scope review remains owned by `rsp-review`; Inspect and Verify are not public Skills.
-
-Every receipt contains these common fields: `WorkRef`, `lane objective`, `effective authority`, `result`, `decisive evidence`, and `stop boundary`, plus the lane-specific fields above. Its human-facing narration follows the envelope's response language; when that differs from a canonical result value, localize the primary result explanation and retain the exact result only as a secondary parenthesized or code-formatted token. Inspect the actual diff and fresh verification before acceptance. After every ordinary same-goal Fix, Verify, Review, or Resolve Findings receipt, re-read status, owner, authority, diff, blockers, and decisive evidence internally before any later mutation or dispatch. Do not return to Core merely to repeat route selection or qualification.
-
-Independent Verify is established only when its worker identity and the accepted Fix worker identity are both available and different. If the host cannot establish that identity boundary, record `independence: unavailable`; ordinary read-only Verify may still run, but Manager must not claim independent verification.
-
-Derive `AcceptanceDisposition` independently from execution; it is exactly `incomplete`, `evidence-complete`, or `review-clean`. Implementation verification, fixed-scope change review, and the durable writeback decision are separate gates. A required worker that was not created, did not return a valid required receipt, returned `unavailable` or `boundary-changed`, or could not satisfy required independent verification keeps acceptance `incomplete`. Accepted required receipts plus fresh declared verification may derive only `evidence-complete`; this verification is implementation verification. Only a clean fixed-scope change review may then derive managed `review-clean`. An execution receipt never derives `review-clean` directly; a verification receipt does not derive it either. The later durable writeback decision cannot substitute for fixed-scope change review. An unavailable required implementation worker cannot be replaced by controller mutation, and ordinary Verify cannot satisfy an acceptance contract that requires independent Verify.
-
-Keep frontier classification, lane choice, envelopes, receipts, dispatch and retry counts, concurrency reasoning, and resume chronology response-only. Converged requirements and design belong in the selected Change, real dependencies in `Blockers`, and durable facts or rationale in the durable writeback decision. Create no frontier file, ticket map, ledger, registry, ambient hook, or numeric routing score.
-
-Total worker dispatch remains at most four. Before starting an optional Diagnose or Inspect dispatch, derive the currently known required remaining worker obligations: count one Fix when accepted mutation is still required and count one Verify when the declared acceptance risk or a failed correction still requires worker verification. Start the optional dispatch only when the remaining dispatch capacity covers that dispatch plus every known required obligation; otherwise skip it and preserve the completion path, or stop when no decisive path fits. This is dynamic capacity protection, not a fixed per-lane allocation.
-
-An evidenced failed correction permits at most one corrective retry. Start it only when new evidence makes another correction discriminating, the remaining dispatch capacity still covers the retry and every then-required Verify dispatch, and those remaining resources can still produce decisive acceptance evidence. A failure without new evidence, or a retry that cannot still be decisively verified, stops dispatch. Missing verification, drift, an authority boundary, or unavailable capability also stops dispatch. Use an explicit manual fallback only when it stays within the same owner and authority; Manager never absorbs an unavailable worker's unauthorized implementation.
-
-## Dispatch owned work
-
-Send a compact envelope that identifies the WorkRef, objective, authority, decisive evidence, and stop boundary. When the host supports workers and authorized implementation remains, dispatch at least one implementation worker; sequential execution does not permit the controller to absorb the whole implementation. The controller retains worker-result acceptance, integration verification, review convergence, lifecycle decisions, and commit eligibility and orchestration. It does not absorb Commit's exact Git procedure.
-
-When dispatch cannot satisfy a required worker obligation, apply the AcceptanceDisposition rule above: return `StopDisposition: capability-unavailable`, keep acceptance `incomplete`, and stop. Absence of a dispatch event or receipt is never success, does not discharge the required obligation, and cannot be replaced by the controller claiming the worker's result.
-
-For a Group, dispatch child WorkRefs only in the current derived `plan.waves` wave. Assume shared paths, lockfiles, generated artifacts, integration state, real hosts, provider sessions, and hardware resources overlap unless an authorized isolated workspace and verification boundary exist. Keep blockers, later waves, overlaps, and dependent verification sequential. Dispatch in parallel only for isolated mutation paths and verification resources; delegation never implies concurrency. Workers receive no implied focus, lifecycle, Git, publication, deployment, or approval authority. Choose the cheapest decisive check and at most one integration gate.
-
-## Continue from evidence
-
-Inspect diff and verification before accepting results; rerun `rsp status --json`. For a Group restrict it to declared children.
-
-Continue a clear in-scope ready successor while the goal, WorkRef topology, route, behavior, acceptance, interface, scope, and authority remain unchanged. Return to Core only when owner identity, topology, requested route, behavior, acceptance, public interface, scope, mutation authority, or external-action authority changes. At that boundary, suspend mutation, return decisive evidence, and never classify discovery or change topology; only Core may route authorized Shape and freshly select the next path.
-
-Stop when discovery changes behavior, acceptance, interfaces, scope, mutation, or external authority. Retry only evidenced corrections. During recovery, reread authority and evidence. If incomplete archived child acceptance belongs to a closed Group, require separate explicit lifecycle authority for `rsp group reopen <group> --reason <text>` before `rsp reopen <group>/<child>`; restore neither children nor dependents implicitly. Never create controller status or parallel lifecycle state.
-
-Read [interruption and recovery](references/interruption-recovery.md) only for a progress or status inquiry, explicit pause or release, an environment or verification stop, or resume from continuation pointers.
-
-Read [managed review convergence](references/review-convergence.md) only after a fixed-scope re-review returns Findings or when an accepted in-scope Finding may require another bounded Resolve Findings pass.
-
-## Preserve boundaries
-
-Keep dispatch chronology out of Changes, Group Briefs, Specs, Decision Records. Changes retain converged requirements, outcomes, evidence, omissions, and blockers; Briefs retain shared completion without copied child state. Never persist the goal envelope, WorkSet, waves, or discovery classification.
-
-Closeout requires a Core-selected and qualified handoff that remains valid under current evidence. For declined, unavailable, unselected, incomplete, or drifted handoffs, every `manage.closeout` preset is dormant; Core may report readiness/next action, but configuration executes neither archive nor commit. Earlier qualification does not carry forward across a new continuation without a fresh Core route result.
-
-Derive `CloseoutEligibility` independently; it is exactly `not-eligible`, `lifecycle-ready`, or `local-commit-ready`. Only `AcceptanceDisposition: review-clean` plus fresh owner, authority, exact diff, and decisive verification evidence can derive a ready value. Any other acceptance state derives `CloseoutEligibility: not-eligible`; neither archive nor commit runs.
-
-Read [lifecycle and delivery closeout](references/closeout.md) only after `CloseoutEligibility` becomes ready, when an explicitly authorized recovery checkpoint is being considered, or when the user explicitly requests push. The reference owns preset application, lifecycle commands, Commit handoff, and remote delivery constraints; this Skill retains the fail-safe above before loading it.
-
-Stop on unavailable dependencies, missing authority, failed verification, drift, or limits. When accepted work remains, preserve the focused owner unless explicit release or owner-conflict resolution requires otherwise, then return the incomplete continuation in this order: `WorkRef, Authority, Current state, Changed artifacts, Fresh verification, Blockers, and Next action`. Do not expose retry chronology or claim unobserved completion.

package/skills/rsp-manage/references/closeout.md

@@ -1,11 +0,0 @@
-# Lifecycle and delivery closeout
-
-Load this reference only after `CloseoutEligibility` becomes `lifecycle-ready` or `local-commit-ready`, when an explicitly authorized recovery checkpoint is being considered, or when the user explicitly requests push. The main Skill must first establish a valid selected handoff and retain its incomplete-or-drifted fail-safe.
-
-Valid selected handoff only: effective `manage.closeout` is an automatic grant ceiling narrowed by nearer restrictions and host enforcement. `manual` grants neither automatic archive nor commit. `lifecycle` grants lifecycle closeout after Manage-owned clean fixed-scope change review and a complete durable writeback decision but no Git action. `local` automatically grants lifecycle closeout and, for one eligible terminal non-small clean exact owned boundary, exactly one local Commit route without another user request. Separately justified recovery checkpoints remain possible within the same ceiling. Explicit current-turn authority may allow a local action not automated by the preset; denial wins.
-
-When granted, close lifecycle before any commit. Change: after Manage-owned clean fixed-scope change review and the durable writeback decision run `rsp archive <change-work-ref>` and inspect the complete lifecycle diff. For shallow Group: review, decide durable writeback, and archive each child independently; rederive completion, then when all children plus Group gate pass run `rsp group close <group>`; inspect the complete lifecycle diff after each mutation. This includes terminal owners. Require proven review/clean-boundaries.
-
-Decide commit eligibility separately. Under `local` or explicit commit authority, downstream work may justify one recovery checkpoint: give `rsp-commit` the WorkOwner, paths, evidence, lifecycle state, and authority, then derive status from its receipt. Terminal small owners default to no commit. After lifecycle closeout, a qualified `local` terminal non-small Change or Group with known owner and paths, fresh decisive verification, clean exact boundary, and no nearer denial routes exactly once to `rsp-commit`; do not require the user to repeat `commit`. An ambiguous, mixed, stale, or denied boundary stops without staging. Apply the same owner envelope to explicitly authorized Group/release commits. If Commit is unavailable, return `StopDisposition: capability-unavailable` to Core for its bounded manual Commit fallback; Manage does not stage or commit. Archive grants no Git or publication authority.
-
-Push is opt-in only when user explicitly mentions push and remote, branch, and Group or goal milestone are unambiguous or accepted. Push there, or earlier only for required remote CI, recovery, or collaboration. Never force-push, infer push from commit authority, or push a protected or ambiguous branch. Failure preserves local commits and stops at remote boundary. Return to Core before a separate release operation and dedicated release commit.

package/skills/rsp-manage/references/interruption-recovery.md

@@ -1,7 +0,0 @@
-# Interruption and recovery
-
-Load this reference only for a progress or status inquiry, explicit pause or release, an environment or verification stop, or resume from continuation pointers.
-
-Treat a progress or status inquiry as an update, not a stop signal: report current evidence and continuing intent, then continue authorized work after the update while authority, verification, and blockers still permit it. For an explicit pause, interrupt active workers and confirm they have stopped before acknowledging the pause, keep the focused WorkRef selected, and do not mutate again until resume. Only an explicit release or unfocus request clears owner selection; ordinary pause and blockers preserve focus.
-
-When an environment or verification boundary stops dispatch, preserve the focused owner. Update the Change only with durable blocker and verification facts, then return the incomplete continuation in this order: `WorkRef, Authority, Current state, Changed artifacts, Fresh verification, Blockers, and Next action`. Treat continuation prose only as pointers. On resume, reread the current authority, status, focused owner, worktree diff, blockers, and decisive evidence; mark stale or unverifiable claims pending and revalidate the selected handoff before mutation or worker dispatch. Never persist a paused state, worker registry, controller ledger, or execution chronology.

package/skills/rsp-manage/references/review-convergence.md

@@ -1,7 +0,0 @@
-# Managed review convergence
-
-Load this reference only after a fixed-scope re-review returns Findings or when an accepted in-scope Finding may require another bounded Resolve Findings pass.
-
-After fixed-scope re-review, Manage correlates the report with the selected Change, original authority, fresh verification, and transient pass count. An `accepted` Finding starts another Resolve Findings pass without asking the user to continue only when it remains inside the original behavior, acceptance, paths, mutation authority, and declared verification scope. Resolve Findings never self-loops.
-
-Allow at most three Resolve Findings passes per Change, separate from the worker retry limit. Stop when the same Finding remains after two completed corrections. Also stop for `needs-clarification`; a material product, interface, or scope change; new mutation or external authority; an additional real-host, provider, or network run outside existing verification authority; or failed or unavailable decisive verification. Return one owner input. Treat an eligible in-scope Finding as `correction-needed`, not an external blocker. Keep counts and correction chronology transient.