@oevery/rsp 3.1.0-beta.1 → 3.1.0-beta.3

package/dist/entry-WZDVKDUM.mjs

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+import {
+  inspectPackagedSkillInventory
+} from "./chunk-NX55NIC3.mjs";
+import {
+  openTerminalSession,
+  truncateDisplay
+} from "./chunk-JOMFFQRG.mjs";
+import "./chunk-OTJFL6XH.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 lifecycle 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\u751F\u547D\u5468\u671F 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/dist/{entry-LAPR3TNI.mjs → entry-X23GPCVS.mjs}

@@ -7,7 +7,14 @@ import {
   projectDependencyForest,
   queryArchiveHistory,
   readArchiveHistoryDetail
-} from "./chunk-QLXIDVKK.mjs";
+} from "./chunk-7KKAUBKN.mjs";
+import {
+  displayWidth,
+  openTerminalSession,
+  truncateDisplay,
+  wrapDisplay
+} from "./chunk-JOMFFQRG.mjs";
+import "./chunk-OTJFL6XH.mjs";
 
 // src/tui/entry.tsx
 import process from "process";
@@ -18,81 +25,6 @@ import React from "react";
 import { Box, Text, useApp, useInput, useStdout } from "ink";
 import { useCallback, useEffect, useReducer, useRef } from "react";
 
-// src/tui/display.ts
-var segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
-function isWide(codePoint) {
-  return codePoint >= 4352 && (codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 42191 && codePoint !== 12351 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65135 || codePoint >= 65280 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 127744 && codePoint <= 129791 || codePoint >= 131072 && codePoint <= 262141);
-}
-function displayWidth(value) {
-  let width = 0;
-  for (const { segment } of segmenter.segment(value)) {
-    const codePoint = segment.codePointAt(0) ?? 0;
-    if (/^\p{Mark}$/u.test(segment) || codePoint === 8205)
-      continue;
-    width += isWide(codePoint) ? 2 : 1;
-  }
-  return width;
-}
-function truncateDisplay(value, maxWidth) {
-  if (displayWidth(value) <= maxWidth)
-    return value;
-  if (maxWidth <= 1)
-    return "\u2026".slice(0, maxWidth);
-  let result = "";
-  for (const { segment } of segmenter.segment(value)) {
-    if (displayWidth(result + segment) > maxWidth - 1)
-      break;
-    result += segment;
-  }
-  return `${result}\u2026`;
-}
-function wrapDisplay(value, maxWidth, firstPrefix = "", continuationPrefix = firstPrefix) {
-  const width = Math.max(1, maxWidth);
-  if (displayWidth(firstPrefix) >= width)
-    return [truncateDisplay(`${firstPrefix}${value}`, width)];
-  const lines = [];
-  let prefix = firstPrefix;
-  let line = prefix;
-  const pushLine = () => {
-    lines.push(line);
-    prefix = continuationPrefix;
-    line = prefix;
-  };
-  const appendUnbroken = (token) => {
-    for (const { segment } of segmenter.segment(token)) {
-      if (displayWidth(line + segment) > width && line !== prefix)
-        pushLine();
-      if (displayWidth(line + segment) > width) {
-        lines.push(truncateDisplay(line + segment, width));
-        prefix = continuationPrefix;
-        line = prefix;
-        continue;
-      }
-      line += segment;
-    }
-  };
-  let pendingWhitespace = "";
-  for (const token of value.split(/(\s+)/u).filter(Boolean)) {
-    if (token.trim().length === 0) {
-      if (line !== prefix)
-        pendingWhitespace += token;
-      continue;
-    }
-    const separator = line === prefix ? "" : pendingWhitespace;
-    if (displayWidth(line + separator + token) <= width) {
-      line += `${separator}${token}`;
-    } else {
-      if (line !== prefix && separator)
-        pushLine();
-      appendUnbroken(token);
-    }
-    pendingWhitespace = "";
-  }
-  if (line !== prefix || lines.length === 0)
-    lines.push(line);
-  return lines;
-}
-
 // src/tui/history-display.ts
 function formatHistoryRow(record, width) {
   const boundedWidth = Math.max(1, width);
@@ -884,22 +816,6 @@ var catalogs = {
   "zh-CN": zhCN
 };
 
-// src/tui/terminal.ts
-function openTerminalSession(stdout, options) {
-  let cleaned = false;
-  if (!options.screenReader)
-    stdout.write("\x1B[?1049h\x1B[?25l");
-  return {
-    cleanup() {
-      if (cleaned)
-        return;
-      cleaned = true;
-      if (!options.screenReader)
-        stdout.write("\x1B[?25h\x1B[?1049l");
-    }
-  };
-}
-
 // src/tui/entry.tsx
 var signalExitCodes = {
   SIGHUP: 129,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oevery/rsp",
   "type": "module",
-  "version": "3.1.0-beta.1",
+  "version": "3.1.0-beta.3",
   "description": "RSP (Reliable Software Practice), a repository-native engineering workflow for humans and AI agents",
   "author": "oevery",
   "license": "MIT",
@@ -38,9 +38,10 @@
   "scripts": {
     "prepare": "pnpm run build",
     "release:check": "pnpm run release:metadata-check && pnpm run build && pnpm run typecheck && pnpm run lint && pnpm run test && pnpm run release:package-check",
+    "release:candidate-check": "node scripts/release-candidate-check.mjs && pnpm run release:check",
     "release:metadata-check": "node scripts/release-metadata-check.mjs",
     "release:package-check": "node scripts/clean-install-check.mjs",
-    "prepublishOnly": "pnpm run release:check",
+    "prepublishOnly": "pnpm run release:candidate-check",
     "build": "tsup",
     "dev": "tsup --watch",
     "lint": "eslint .",
@@ -53,17 +54,17 @@
     "citty": "^0.2.2",
     "ink": "~7.1.1",
     "picocolors": "^1.1.1",
-    "react": "~19.2.3",
+    "react": "~19.2.8",
     "yaml": "^2.9.0"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^9.0.0",
-    "@types/node": "^22.19.19",
-    "@types/react": "19.2.14",
-    "eslint": "^10.4.0",
+    "@antfu/eslint-config": "^9.2.0",
+    "@types/node": "^22.20.1",
+    "@types/react": "19.2.17",
+    "eslint": "^10.8.0",
     "ink-testing-library": "4.0.0",
-    "tsup": "^8.4.0",
-    "typescript": "^5.8.0",
-    "vitest": "^4.1.7"
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.10"
   }
 }

package/rules/rsp-rules.md

@@ -18,30 +18,30 @@ This file is the minimal fallback protocol for agents that cannot load the `rsp`
 
 ## Core
 
-- Choose response language and artifact language independently. Localize human-facing response headings, labels, explanations, and conclusions according to the requested response language, response-specific project instructions, then conversation language. Write artifact prose according to the requested artifact language, artifact-specific project instructions, existing artifact language, then conversation language. Preserve canonical RSP artifact headings, WorkRef values, paths, commands, identifiers, and machine-consumed values. Response-only Continuation and Durable Decision labels are not artifact headings; a technical token may appear in parentheses but cannot replace the localized label.
+- Choose response language and artifact language independently. Localize response prose from the explicit request, scoped instructions, then conversation language; write authorized artifacts from the explicit request, scoped instructions, existing artifact language, then conversation language. Preserve canonical headings, WorkRefs, paths, commands, identifiers, and machine values.
 - Write persistent artifact prose in domain, system, user, or operator language. Mention AI or agents only when they are real product actors, consumers, interface participants, or constraints; agent authorship, execution narration, or convenience for a hypothetical future agent is not durable content.
 - `changes/` stores open work; `archives/` stores completed history; `specs/` stores stable current facts; the configured Decision Record path stores lasting rationale.
 - Every Change is one Markdown file with explicit `kind` and the fixed `Proposal`, `Spec`, `Design`, `Tasks`, `Verify`, and `Blockers` sections.
 - A Change is a convergent current-plan and final-evidence snapshot, not an append-only execution log. Keep Tasks aligned with current delivery and Verify limited to final decisive commands or scenarios, results, proven scope, omitted or unavailable coverage, and remaining risk. Replace superseded plans and evidence; retain an earlier failure only when it still explains a current blocker, coverage gap, or risk.
 - In a Change `Blockers` section, `- requires \`<change-work-ref>\`: <reason>` declares an exact dependency on another executable Change. Other meaningful blocker prose remains external and is never inferred as a dependency.
 - Executable Change identities are either `<change>` or `<group>/<change>`. Recursive work paths are unsupported.
-- A Change Group is the only composite work shape. Use it only when at least two independently executable direct child Changes share one goal or completion contract.
-- `<group>/brief`, physically stored as `<group>/00-brief.md`, owns Goal, Scope, Shared Constraints, Slices, Completion Conditions, Durable Outcomes, and Blockers. Every direct child must be declared by `Slices`, and every declared slice must be open or archived.
-- A Group Brief is not executable or focusable. Read it before a grouped child, archive children independently, and use `rsp group close <group>` only after derived completion passes. Archived Group identities cannot be reopened.
+- A Change Group is the only composite shape and requires at least two independent direct children. Its non-executable, non-focusable `<group>/brief` at `<group>/00-brief.md` owns shared scope, constraints, declared Slices, completion, durable outcomes, and blockers. Read it before a child; archive children independently and close only a derived-complete Group.
 - A file and directory cannot claim the same work identity.
-- `changes/` must exist as a real directory. Existing `focus.d/`, `archives/`, and direct group prefixes must also be real directories; symlinks, missing open-work roots, and incomplete inspection fail closed.
-- Initialization, repair, status inspection, Spec creation, and index generation use the same no-follow managed-path rules; recursive Specs may use only real directories and regular files.
-- Final managed files, including the project `AGENTS.md`, focus markers, fallback/config files, indexes, and placeholders, must be regular files rather than symlinks or special entries.
+- Managed roots, Group prefixes, recursive Spec paths, and final managed files must be real directories or regular files as applicable. Initialization, repair, inspection, Spec-index work, and mutations use shared no-follow checks; symlinks, special entries, missing roots, and incomplete inspection fail closed.
 - `status`, `check`, and `doctor` share work-tree, Change Group, and dependency inspection. They fail visibly on unsupported structure, membership mismatches, malformed or missing dependency targets, self-dependencies, and cycles. With no focus, status uses Group Brief declaration order and derived blockers to recommend the first executable slice.
-- `status` derives minimal graph nodes, dependency edges with their reasons, ready Changes, blockers, and stable execution waves from exact blocker references. Filtered plans retain transitive prerequisite context and distinguish selected nodes from prerequisite nodes; human output renders the same flat graph as a dependency forest whose parent requires its children. Archived prerequisites resolve automatically; incomplete dependency or archive inspection fails closed and marks open Changes blocked for readiness; no graph file or delivery state is persisted; and Group Briefs are not dependency targets.
+- `status` derives blockers, exact edges and reasons, ready Changes, and stable waves without persisted graph or delivery state. Filtered views retain prerequisite context. Archived prerequisites resolve; invalid or incompletely inspected graphs fail closed.
 - Parallel Changes in one Group follow the Brief `Slices` declaration order in plan output; unrelated work uses stable lexical ordering.
 - A Group Brief blocker is inherited by its direct child Changes as an external blocker; it does not create inferred dependency edges.
 - Persist only `open` and `archived`; readiness, blockers, verification, and next actions are derived.
-- Ordinary implementation is the default after unexplained failures have been ruled out. Use test-first work only when user, Change, or project authority requires it or a concrete changed risk makes a focused pre-mutation failure materially safer. Retain a new test only when it protects observable behavior or a real boundary, adds distinct future confidence, avoids duplicate or implementation-detail coverage, and has proportionate maintenance cost; otherwise remove the temporary probe and use the smallest decisive final verification.
-- Route one isolated domain, module/seam, or evidence-seeking design question to `rsp-design` when available, or use a compact manual design pass. Return evidence, alternatives, owner decisions, and any authorized planned-design update to the same selected Change; do not implement or write durable current truth from that pass.
-- Route release documentation only when a dedicated Release Change explicitly owns a confirmed release identity or range and still has unfinished changelog, release-note, or migration work. Identity is confirmed only by explicit user instruction or authoritative release configuration; never infer it from version order, prior prereleases, commits, or planned prose. Until confirmation, keep release planning version-neutral and leave manifests, target changelog headings, exact-version documentation, versioned release notes, and tag comparisons unchanged. Select `rsp-release-docs` when available, or use the same evidence-led manual fallback; lifecycle stage, completed implementation, and archive readiness alone are insufficient. This route never grants commit, tag, push, release creation, publication, deployment, or approval authority.
+- When fresh evidence shows that an archived executable Change did not meet its original acceptance, explicitly use `rsp reopen <work-ref> --reason <text>` to restore the same WorkRef. Reopen retains the selected archive, focuses the open Change, and adds unfinished Task and Verify evidence. Multiple archives require exact `--from .rsp/archives/...` selection; open work wins over same-WorkRef history in current dependency state. Use a new corrective Change for genuinely new scope or an independently delivered correction. Do not reopen a closed Change Group implicitly.
+- Ordinary implementation is the default after unexplained failures are ruled out. Use test-first only when authority requires it or a concrete risk makes pre-mutation failure materially safer. Retain a new test only when it protects observable behavior or a real boundary with distinct proportionate value; otherwise remove the temporary probe and use decisive final verification.
+- Before later-turn mutation under a direct report, tiny, or small route, rederive from the newly authorized objective and prospective work. Cross-module implementation, multiple acceptance surfaces, repeated production-path correction, real-host validation, or lifecycle delivery requires the smallest sufficient WorkRef before mutation; unchanged tiny/small follow-ups stay direct. Elapsed time and message count alone never escalate work.
+- Before focusing or mutating a different WorkRef, compare dirty product or durable-truth paths with the prior owner's declared or observed paths. Overlap requires continuation of the same open WorkRef, an authorized reopen, an explicitly authorized integration owner, or a stop for boundary resolution. Disjoint authorized work may proceed without staging or forcing a commit; insufficient ownership evidence stops the transition.
+- This fallback does not emulate `rsp-manage`, even when project configuration selects automatic activation or local closeout. Invalid configuration grants nothing and remains visible. Every `manage.closeout` preset stays advisory because fallback Core never selects or qualifies Manage. For an explicit managed request or an automatically eligible completion/continuation, resolve the smallest owner using ordinary Core rules: reuse one unambiguous selected ready Change, send tiny settled work direct without a synthetic Change, and shape only independently authorized planning artifacts for clear non-trivial work. Configuration grants no planning or product-mutation authority. Stop for material product, acceptance, interface, scope, mutation, or external-action decisions. Perform at most one ordinary Core or Discipline action, return its WorkRef and next action, and never dispatch, auto-continue successors, loop review corrections, archive, stage, commit, push, or persist controller state. Load the `rsp` and `rsp-manage` Skills when controller behavior is required.
+- Route one explicit isolated domain, module/seam, or evidence-seeking question to installed `rsp-design`; use a compact manual design pass only when that Skill is unavailable. Without a selected Change, use report-only Pre-Change Design without inventing a WorkRef only when the question is already bounded; when outcome, scope, non-goals, acceptance, or decomposition remains materially unclear, route to Shape. With a selected Change, return evidence, alternatives, owner decisions, and any authorized planned-design update to the same WorkRef. Do not implement or write durable current truth from either mode.
+- Route release documentation only for an explicit release operation with a confirmed identity or range and unfinished surfaces; no Release Change is required. Confirm identity only from explicit instruction or authoritative configuration. Until then stay version-neutral and do not mutate versioned surfaces. Keep ledgers transient; use an optional Release Change only for material decisions, coordination, recovery, blockers, or acceptance. This route grants no Git, publication, deployment, or approval authority.
 - Do not infer current work from open Changes or filenames.
-- Prefer RSP commands for deterministic setup, status, validation, repair, focus, index, and archive operations.
+- Prefer RSP commands for deterministic setup, status, validation, repair, focus, Specs-index, history, archive, and reopen operations.
 
 ## Durable review
 
@@ -49,11 +49,12 @@ This file is the minimal fallback protocol for agents that cannot load the `rsp`
 - Project-owned `CONTEXT.md` owns stable navigation or scoped current context, while project-owned `AGENTS.md` owns stable operating instructions. Preserve their conventions and never treat RSP as their owner.
 - Before archive, decide independently whether current facts need a Spec or scoped-instruction update and whether lasting rationale needs a Decision Record.
 - Before archive, compress the Change to its final outcome, current design, completed delivery tasks, final decisive verification, and unresolved risks. Keep RED/GREEN/REFACTOR cycles, temporary probes, command transcripts, and step-by-step review corrections in the response instead of the Change or Archive.
-- After required durable updates, Core recommends explicit archive before final Git delivery. Keep each completed Change independently reviewable; with explicit Git authority deliver it as one logical commit before a separate Release Change and dedicated release commit finalize versioned shipped surfaces. Core does not execute archive or grant authority to stage, commit, push, or publish.
+- After required durable updates, Core recommends explicit archive before final Git delivery. Ordinary work requires separate Git and release authority; fallback Core never executes archive, stage, commit, push, or publication.
+- When loaded Core or qualified Manage has already derived one authorized RSP-owned commit boundary, prefer the `rsp-commit` Skill for exact staging, repository-consistent structured message construction, one local commit, and complete post-commit observation. If that Skill alone is unavailable, loaded Core may provide its equivalent bounded manual action against the same owner; this minimal fallback still grants and executes no Git action.
 - Decision Records are for hard-to-reverse choices with real tradeoffs; they do not duplicate current facts.
 - Change Spec deltas are planning aids and are never promoted automatically into Specs or Decision Records.
 - Keep task history, debugging notes, and transient execution state out of Specs and Decision Records.
-- Generated indexes and archives are not current-truth owners.
+- Generated local Specs `00-index.md` files and archives are not current-truth owners. Use each index only to discover direct child Specs and child Spec directories; authoritative Archive Markdown is queried directly without a generated Archive Index.
 
 ## Continuation and conflicts
 
@@ -67,5 +68,6 @@ This file is the minimal fallback protocol for agents that cannot load the `rsp`
 
 - Do not create RSP-managed files directly when a command owns the operation.
 - Do not create archive entries directly; use `npx -y @oevery/rsp archive <name>`.
+- Do not restore archived Change content directly; use `npx -y @oevery/rsp reopen <name> --reason <text>` and exact `--from` selection when required.
 - Do not modify content outside the managed RSP block in `AGENTS.md` unless explicitly requested.
 - Archive reports warnings but does not grant commit, push, publication, deletion, or external approval authority.