@oevery/rsp 3.3.0 → 4.1.0

package/dist/chunk-QM2UVPQK.mjs

@@ -1,375 +0,0 @@
-#!/usr/bin/env node
-import {
-  ManagedPathError,
-  PKG_ROOT,
-  emitJson,
-  inspectManagedDirectory,
-  inspectManagedFileTree,
-  resolveManagedDirectoryChain
-} from "./chunk-7HXQNBIG.mjs";
-
-// src/cli/presenters/skills.ts
-function presentPackagedSkillInventory(inventory, json = false) {
-  if (json) {
-    emitJson(inventory);
-    return;
-  }
-  console.log(`  ${inventory.package.name}@${inventory.package.version}`);
-  console.log(`  target: ${inventory.target}`);
-  for (const group of [
-    { heading: "Default suite Skills", kind: "default" },
-    { heading: "Optional project Skills", kind: "optional" }
-  ]) {
-    console.log("");
-    console.log(`  ${group.heading}`);
-    const skills = inventory.skills.filter((skill) => skill.kind === group.kind);
-    if (skills.length === 0)
-      console.log("    none");
-    for (const skill of skills)
-      console.log(`    ${skill.name}  ${skill.status}`);
-  }
-}
-function presentSkillInstallResult(result, dryRun = false) {
-  const prefix = dryRun ? "would be " : "";
-  for (const status of ["installed", "unchanged", "replaced", "removed"]) {
-    if (result[status].length > 0)
-      console.log(`  ${prefix}${status}: ${result[status].join(", ")}`);
-  }
-}
-
-// src/commands/skills.ts
-import { randomUUID } from "crypto";
-import { lstatSync, realpathSync } from "fs";
-import { chmod, copyFile, mkdir, readdir, readFile, rename, rm } from "fs/promises";
-import { dirname, join, relative } from "path";
-var DEFAULT_PACKAGED_SKILL_NAMES = [
-  "rsp",
-  "rsp-commit",
-  "rsp-design",
-  "rsp-diagnose",
-  "rsp-implement",
-  "rsp-manage",
-  "rsp-release-docs",
-  "rsp-resolve-findings",
-  "rsp-review",
-  "rsp-shape",
-  "rsp-tdd",
-  "rsp-verify"
-];
-var OBSOLETE_PACKAGED_SKILL_RENAMES = {
-  "rsp-address-review": "rsp-resolve-findings",
-  "rsp-codebase-audit": "rsp-structural-audit"
-};
-function unsupportedEntry(path, label) {
-  return new ManagedPathError(path, `unsupported entry in the ${label} tree: ${path}`);
-}
-function inspectDirectoryIdentity(path, label) {
-  const inspection = inspectManagedDirectory(path, label);
-  if (inspection.issue)
-    throw inspection.issue;
-  const stats = lstatSync(path);
-  return { path, dev: stats.dev, ino: stats.ino };
-}
-function assertDirectoryIdentities(identities, label) {
-  for (const identity of identities) {
-    const current = inspectDirectoryIdentity(identity.path, label);
-    if (current.dev !== identity.dev || current.ino !== identity.ino)
-      throw new ManagedPathError(identity.path, `${label} changed after validation: ${identity.path}`);
-  }
-}
-async function prepareTargetRoot(projectRoot, targetRoot) {
-  const projectIdentity = inspectDirectoryIdentity(projectRoot, "project Skills root");
-  const agentsRoot = join(projectRoot, ".agents");
-  const identities = [projectIdentity];
-  assertDirectoryIdentities(identities, "project Skills root");
-  await mkdir(agentsRoot).catch((error) => {
-    if (error.code !== "EEXIST")
-      throw error;
-  });
-  assertDirectoryIdentities(identities, "project Skills root");
-  identities.push(inspectDirectoryIdentity(agentsRoot, "project Skills root"));
-  assertDirectoryIdentities(identities, "project Skills root");
-  await mkdir(targetRoot).catch((error) => {
-    if (error.code !== "EEXIST")
-      throw error;
-  });
-  assertDirectoryIdentities(identities, "project Skills root");
-  identities.push(inspectDirectoryIdentity(targetRoot, "project Skills root"));
-  return identities;
-}
-async function inspectPackagedSkills(packageRoot) {
-  const skillsRoot = join(packageRoot, "skills");
-  const rootInspection = inspectManagedDirectory(skillsRoot, "packaged Skills root");
-  if (rootInspection.issue)
-    throw rootInspection.issue;
-  const entries = await readdir(skillsRoot, { withFileTypes: true });
-  const skills = [];
-  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-    if (entry.name.startsWith("."))
-      continue;
-    const root = join(skillsRoot, entry.name);
-    if (!entry.isDirectory())
-      throw unsupportedEntry(root, "packaged Skills");
-    const inspection = await inspectManagedFileTree(root, `packaged Skill ${entry.name}`);
-    if (inspection.issues.length > 0)
-      throw inspection.issues[0];
-    skills.push({
-      name: entry.name,
-      root,
-      files: inspection.files.map((path) => relative(root, path))
-    });
-  }
-  return skills;
-}
-function inspectTarget(path, name) {
-  try {
-    const stats = lstatSync(path);
-    if (stats.isDirectory())
-      return "directory";
-    throw unsupportedEntry(path, `installed Skill ${name}`);
-  } catch (error) {
-    if (error.code === "ENOENT")
-      return "missing";
-    throw error;
-  }
-}
-function inspectInventoryTarget(path) {
-  try {
-    return lstatSync(path).isDirectory() ? "directory" : "divergent";
-  } catch (error) {
-    if (error.code === "ENOENT")
-      return "missing";
-    throw error;
-  }
-}
-function isCanonicalSourceProjection(sourceRoot, targetRoot) {
-  try {
-    if (!lstatSync(targetRoot).isSymbolicLink())
-      return false;
-    return realpathSync(targetRoot) === realpathSync(sourceRoot);
-  } catch {
-    return false;
-  }
-}
-async function treesEqual(source, targetRoot) {
-  const target = await inspectManagedFileTree(targetRoot, `installed Skill ${source.name}`);
-  if (target.issues.length > 0)
-    throw target.issues[0];
-  const targetFiles = target.files.map((path) => relative(targetRoot, path));
-  if (source.files.length !== targetFiles.length || source.files.some((path, index) => path !== targetFiles[index]))
-    return false;
-  for (const path of source.files) {
-    const sourcePath = join(source.root, path);
-    const targetPath = join(targetRoot, path);
-    const [sourceStats, targetStats] = [lstatSync(sourcePath), lstatSync(targetPath)];
-    if (!sourceStats.isFile() || !targetStats.isFile())
-      throw unsupportedEntry(!sourceStats.isFile() ? sourcePath : targetPath, `Skill ${source.name}`);
-    if ((sourceStats.mode & 511) !== (targetStats.mode & 511))
-      return false;
-    const [sourceContent, targetContent] = await Promise.all([readFile(sourcePath), readFile(targetPath)]);
-    if (!sourceContent.equals(targetContent))
-      return false;
-  }
-  return true;
-}
-async function inspectPackagedSkillInventory(options = {}) {
-  const packageRoot = options.packageRoot ?? PKG_ROOT;
-  const projectRoot = options.projectRoot ?? process.cwd();
-  const packagedSkills = await inspectPackagedSkills(packageRoot);
-  const packagedNames = new Set(packagedSkills.map((skill) => skill.name));
-  const missingDefaults = DEFAULT_PACKAGED_SKILL_NAMES.filter((name) => !packagedNames.has(name));
-  if (missingDefaults.length > 0)
-    throw new Error(`packaged Skills missing default Skills: ${missingDefaults.join(", ")}`);
-  const manifest = JSON.parse(await readFile(join(packageRoot, "package.json"), "utf8"));
-  if (typeof manifest.name !== "string" || typeof manifest.version !== "string")
-    throw new Error("package.json must contain string name and version fields");
-  const targetRoot = resolveManagedDirectoryChain(projectRoot, [".agents", "skills"], "project Skills root");
-  const defaults = new Set(DEFAULT_PACKAGED_SKILL_NAMES);
-  const skills = [];
-  for (const skill of packagedSkills) {
-    const target = join(targetRoot, skill.name);
-    const targetStatus = inspectInventoryTarget(target);
-    skills.push({
-      name: skill.name,
-      kind: defaults.has(skill.name) ? "default" : "optional",
-      status: targetStatus === "missing" ? "missing" : targetStatus === "divergent" ? isCanonicalSourceProjection(skill.root, target) ? "unchanged" : "divergent" : await treesEqual(skill, target) ? "unchanged" : "divergent"
-    });
-  }
-  return {
-    package: { name: manifest.name, version: manifest.version },
-    target: relative(projectRoot, targetRoot) || ".",
-    skills
-  };
-}
-async function copySkillTree(source, targetRoot) {
-  await mkdir(targetRoot, { recursive: true });
-  for (const path of source.files) {
-    const sourcePath = join(source.root, path);
-    const targetPath = join(targetRoot, path);
-    const stats = lstatSync(sourcePath);
-    if (!stats.isFile())
-      throw unsupportedEntry(sourcePath, `packaged Skill ${source.name}`);
-    await mkdir(dirname(targetPath), { recursive: true });
-    await copyFile(sourcePath, targetPath);
-    await chmod(targetPath, stats.mode & 511);
-  }
-}
-async function installPackagedSkills(args = {}, options = {}) {
-  const packageRoot = options.packageRoot ?? PKG_ROOT;
-  const projectRoot = options.projectRoot ?? process.cwd();
-  const renamePath = options.renamePath ?? rename;
-  const packagedSkills = await inspectPackagedSkills(packageRoot);
-  const requestedNames = args.names?.length ? [...new Set(args.names)] : [...DEFAULT_PACKAGED_SKILL_NAMES];
-  const packagedSkillsByName = new Map(packagedSkills.map((skill) => [skill.name, skill]));
-  for (const name of requestedNames) {
-    if (!packagedSkillsByName.has(name))
-      throw new Error(`unknown packaged Skill: ${name}`);
-  }
-  const skills = requestedNames.map((name) => packagedSkillsByName.get(name)).sort((a, b) => a.name.localeCompare(b.name));
-  const targetRoot = resolveManagedDirectoryChain(projectRoot, [".agents", "skills"], "project Skills root");
-  const result = { installed: [], removed: [], unchanged: [], replaced: [] };
-  const conflicts = [];
-  const obsoleteConflicts = [];
-  const targetTreeIdentities = /* @__PURE__ */ new Map();
-  for (const skill of skills) {
-    const target = join(targetRoot, skill.name);
-    if (inspectTarget(target, skill.name) === "missing") {
-      result.installed.push(skill.name);
-      continue;
-    }
-    const targetIdentity = inspectDirectoryIdentity(target, `installed Skill ${skill.name}`);
-    if (await treesEqual(skill, target)) {
-      result.unchanged.push(skill.name);
-      continue;
-    }
-    assertDirectoryIdentities([targetIdentity], `installed Skill ${skill.name}`);
-    if (args.force) {
-      result.replaced.push(skill.name);
-      targetTreeIdentities.set(skill.name, targetIdentity);
-    } else {
-      conflicts.push(skill.name);
-    }
-  }
-  const selectedNames = new Set(skills.map((skill) => skill.name));
-  const obsoleteTreeIdentities = /* @__PURE__ */ new Map();
-  for (const [obsolete, replacement] of Object.entries(OBSOLETE_PACKAGED_SKILL_RENAMES)) {
-    if (!selectedNames.has(replacement))
-      continue;
-    const target = join(targetRoot, obsolete);
-    if (inspectTarget(target, obsolete) === "missing")
-      continue;
-    const targetIdentity = inspectDirectoryIdentity(target, `obsolete installed Skill ${obsolete}`);
-    assertDirectoryIdentities([targetIdentity], `obsolete installed Skill ${obsolete}`);
-    if (args.force) {
-      result.removed.push(obsolete);
-      obsoleteTreeIdentities.set(obsolete, targetIdentity);
-    } else {
-      obsoleteConflicts.push(`${obsolete} -> ${replacement}`);
-    }
-  }
-  const conflictMessages = [];
-  if (conflicts.length > 0)
-    conflictMessages.push(`conflicting packaged Skills: ${conflicts.join(", ")}`);
-  if (obsoleteConflicts.length > 0)
-    conflictMessages.push(`obsolete packaged Skill renames: ${obsoleteConflicts.join(", ")}`);
-  if (conflictMessages.length > 0)
-    throw new Error(`${conflictMessages.join("; ")}; rerun with --force to replace or remove only these package-owned directories`);
-  if (args.dryRun)
-    return result;
-  await options.onMutationStep?.({ phase: "before-target-root-mutation", targetRoot });
-  const targetIdentities = await prepareTargetRoot(projectRoot, targetRoot);
-  const stagingRoot = join(targetRoot, `.rsp-skills-install-${randomUUID()}`);
-  const nextRoot = join(stagingRoot, "next");
-  const previousRoot = join(stagingRoot, "previous");
-  const failedRoot = join(stagingRoot, "failed");
-  const movedPrevious = [];
-  const activated = [];
-  let removeStaging = true;
-  try {
-    assertDirectoryIdentities(targetIdentities, "project Skills root");
-    await mkdir(nextRoot, { recursive: true });
-    await mkdir(previousRoot);
-    await mkdir(failedRoot);
-    for (const skill of skills) {
-      if (result.unchanged.includes(skill.name))
-        continue;
-      await copySkillTree(skill, join(nextRoot, skill.name));
-    }
-    for (const name of result.installed) {
-      const target = join(targetRoot, name);
-      if (inspectTarget(target, name) !== "missing")
-        throw new ManagedPathError(target, `installed Skill changed after preflight: ${target}`);
-    }
-    for (const name of result.replaced) {
-      assertDirectoryIdentities([targetTreeIdentities.get(name)], `installed Skill ${name}`);
-    }
-    for (const name of result.removed) {
-      assertDirectoryIdentities([obsoleteTreeIdentities.get(name)], `obsolete installed Skill ${name}`);
-    }
-    for (const name of result.removed) {
-      assertDirectoryIdentities(targetIdentities, "project Skills root");
-      assertDirectoryIdentities([obsoleteTreeIdentities.get(name)], `obsolete installed Skill ${name}`);
-      await renamePath(join(targetRoot, name), join(previousRoot, name));
-      movedPrevious.push(name);
-    }
-    for (const name of result.replaced) {
-      assertDirectoryIdentities(targetIdentities, "project Skills root");
-      assertDirectoryIdentities([targetTreeIdentities.get(name)], `installed Skill ${name}`);
-      await renamePath(join(targetRoot, name), join(previousRoot, name));
-      movedPrevious.push(name);
-    }
-    for (const name of [...result.installed, ...result.replaced].sort()) {
-      const target = join(targetRoot, name);
-      assertDirectoryIdentities(targetIdentities, "project Skills root");
-      await options.onMutationStep?.({ phase: "before-activate", name, target });
-      assertDirectoryIdentities(targetIdentities, "project Skills root");
-      if (inspectTarget(target, name) !== "missing")
-        throw new ManagedPathError(target, `installed Skill changed after preflight: ${target}`);
-      await renamePath(join(nextRoot, name), target);
-      activated.push(name);
-    }
-  } catch (error) {
-    const rollbackErrors = [];
-    for (const name of activated.reverse()) {
-      const target = join(targetRoot, name);
-      try {
-        assertDirectoryIdentities(targetIdentities, "project Skills root");
-        if (inspectTarget(target, name) === "directory")
-          await renamePath(target, join(failedRoot, name));
-      } catch (rollbackError) {
-        rollbackErrors.push(rollbackError instanceof Error ? rollbackError.message : String(rollbackError));
-      }
-    }
-    for (const name of movedPrevious.reverse()) {
-      const target = join(targetRoot, name);
-      const previous = join(previousRoot, name);
-      try {
-        assertDirectoryIdentities(targetIdentities, "project Skills root");
-        await options.onMutationStep?.({ phase: "before-rollback-restore", name, target, previous });
-        assertDirectoryIdentities(targetIdentities, "project Skills root");
-        if (inspectTarget(target, name) !== "missing")
-          throw new ManagedPathError(target, `cannot restore installed Skill because the target is occupied: ${target}`);
-        await renamePath(previous, target);
-      } catch (rollbackError) {
-        rollbackErrors.push(rollbackError instanceof Error ? rollbackError.message : String(rollbackError));
-      }
-    }
-    if (rollbackErrors.length > 0) {
-      removeStaging = false;
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(`${message}; rollback incomplete; recover original Skills from ${previousRoot}; ${rollbackErrors.join("; ")}`);
-    }
-    throw error;
-  } finally {
-    if (removeStaging)
-      await rm(stagingRoot, { recursive: true, force: true });
-  }
-  return result;
-}
-
-export {
-  presentPackagedSkillInventory,
-  presentSkillInstallResult,
-  inspectPackagedSkillInventory,
-  installPackagedSkills
-};

package/dist/entry-YAW3PYFA.mjs

@@ -1,174 +0,0 @@
-#!/usr/bin/env node
-import {
-  inspectPackagedSkillInventory
-} from "./chunk-QM2UVPQK.mjs";
-import {
-  openTerminalSession,
-  truncateDisplay
-} from "./chunk-JOMFFQRG.mjs";
-import "./chunk-7HXQNBIG.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,48 +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 each `focus.d/` marker path as the only current-focus source. A marker may contain a short optional Markdown Focus Capsule with Manager-accepted recovery pointers, but its prose never selects work or grants authority, acceptance, lifecycle, Git, or worker coordination. A valid non-empty v1 capsule contains only one leading `<!-- rsp-focus:v1 -->`, blank lines, exactly one non-empty single-line `Current`, `Evidence`, and `Next`, and at most one non-empty single-line `Resume check`; unknown non-empty lines or fields are invalid. Legacy unversioned content is warning-only compatibility and makes no structured recovery claim. 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, and acceptance remain derived from current artifacts and evidence. A Focus Capsule may project accepted current work, next action, evidence validity, and blockers for recovery without becoming lifecycle or controller state. Under `## Verify`, `### Required` owns acceptance-critical evidence and `### Optional` owns additional coverage; legacy unclassified items are Required. Incomplete Tasks, Required verification, or blockers fail the completion gate, while Optional omissions remain visible warnings.
-- 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.
-- When the next action is a read-only pass over a Change-declared evidence boundary, use `rsp-verify` when available. Verify owns the bounded result and evidence; Core retains routing, while Manage validates required results and derives acceptance and closeout. Any required identity or independence evidence comes from the host. If Verify is unavailable, a manual fallback may collect only the same declared evidence and must report the capability gap truthfully.
-- 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. Required verification must pass; Optional omissions may remain as explicit coverage warnings. Reclassifying incomplete Required evidence as Optional changes acceptance and requires explicit owner authority plus fresh readiness and review. 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, execution-environment selection, or configured closeout. Configuration selects no capability and grants no planning, product-mutation, lifecycle, Git, publication, deployment, approval, or human-acceptance authority. The fallback never selects, prepares, or integrates an execution environment; the host, user, and Git own execution location and cross-branch integration.
-- 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 one outer `ControlOutcome` for the selected WorkRef with `mode: solo | delegated | coordinated`, `status: running | waiting | completed`, the current phase outcome or stop reason, decisive evidence, changed artifacts when present, next owner/action, and optional recovery. Status transitions are only `running -> waiting | completed` and `waiting -> running | completed`; route, strategy, lane result, acceptance, and closeout remain nested details or gates rather than peer statuses. This response is not durable truth or a second state store. The fallback reports these semantics but does not emulate Manage qualification, worker delegation, strategy selection, acceptance, or closeout.

package/skills/rsp/references/implementation-evidence.md

@@ -1,12 +0,0 @@
-# Implementation evidence
-
-Load this reference only when implementation evidence is incomplete or failed and Core must select Diagnose, TDD, ordinary Implement, or Verify.
-
-Apply these routes in order:
-
-- **Diagnosis first:** diagnosis takes precedence over TDD for an evidenced but unexplained, conflicting, intermittent, or multi-layer failure. Use `rsp-diagnose` when available; its manual fallback reproduces, locates, and tests the smallest discriminating hypothesis. Do not encode an unexplained symptom as a guessed regression test.
-- **TDD when justified:** use `rsp-tdd` only when test-first is explicitly required by the user, Change, or project instructions, or when a concrete changed risk makes a pre-mutation RED materially safer; mere testability or being a fix does not qualify. Its manual fallback observes the focused RED, makes the minimum GREEN change, and refactors only while green.
-- **Ordinary implementation by default:** use `rsp-implement`, or the equivalent bounded edit and verification, once the behavior, cause, and owner are sufficiently evidenced.
-- **Verification as one bounded action:** use `rsp-verify` for a read-only pass over the Change-declared evidence boundary. Verify owns its result; Core retains routing and continuation, while Manage validates required results and derives acceptance and closeout. Any worker identity or independence evidence comes from the host, not Verify self-report.
-
-All branches return evidence, Tasks, Verify updates, and blockers to the same Change. Required verification proves acceptance or changed material risk; Optional verification adds environment, compatibility, scale, or confidence coverage. Fresh Required verification is mandatory, and optional omissions remain visible warnings.