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

package/dist/{chunk-EALHA3ZS.mjs → chunk-7KKAUBKN.mjs}

@@ -22,9 +22,7 @@ import {
 } from "./chunk-OTJFL6XH.mjs";
 
 // src/status/inspect.ts
-import { existsSync } from "fs";
-import { readFile as readFile3, stat } from "fs/promises";
-import { join as join3 } from "path";
+import { readFile as readFile5, stat } from "fs/promises";
 
 // src/core/change-group.ts
 import { readFile } from "fs/promises";
@@ -967,7 +965,7 @@ async function inspectChangeDependencies(options = {}) {
   const executable = new Set(graphValid ? waves.flat() : []);
   const nodes = [.../* @__PURE__ */ new Set([...openNames, ...edges.map((edge) => edge.requires)])].sort().map((name) => {
     let state;
-    if (archivedNames.has(name))
+    if (!openNames.has(name) && archivedNames.has(name))
       state = "archived";
     else if (!openNames.has(name))
       state = "missing";
@@ -1104,246 +1102,12 @@ function findCycleDiagnostics(edges) {
   return diagnostics;
 }
 
-// src/status/inspect.ts
-async function inspectProjectStatus(options = {}) {
-  const runtime = [];
-  const diagnostics = [];
-  let manage = resolveManagePolicy({});
-  try {
-    const configInspection = await inspectRspConfig();
-    const configValid = configInspection.issues.length === 0;
-    manage = resolveManagePolicy(configInspection.config, { configValid });
-    if (!configValid) {
-      diagnostics.push({
-        severity: "error",
-        code: "invalid_config",
-        path: CONFIG_PATH,
-        message: configInspection.issues.join("; ")
-      });
-    }
-  } catch (error) {
-    manage = resolveManagePolicy({}, { configValid: false });
-    diagnostics.push({
-      severity: "error",
-      code: "invalid_config",
-      path: CONFIG_PATH,
-      message: toErrorMessage(error)
-    });
-  }
-  const focusTree = await inspectFocusTree();
-  for (const diagnostic of focusTree.diagnostics) {
-    diagnostics.push({
-      severity: "error",
-      code: diagnostic.code,
-      change: diagnostic.input,
-      path: diagnostic.path,
-      message: diagnostic.message
-    });
-  }
-  const rawFocusedSet = new Set(focusTree.markers.map((marker) => marker.name));
-  const focusedSet = /* @__PURE__ */ new Set();
-  const focusedPaths = /* @__PURE__ */ new Map();
-  for (const name of rawFocusedSet) {
-    try {
-      const ref = resolveWorkRef(name, { executable: true });
-      focusedSet.add(ref.name);
-      focusedPaths.set(ref.name, ref.path);
-    } catch (error) {
-      if (!(error instanceof WorkRefError))
-        throw error;
-      diagnostics.push({
-        severity: "error",
-        code: error.code,
-        path: `.rsp/focus.d/${name}`,
-        change: name,
-        message: error.message
-      });
-    }
-  }
-  const workTree = await inspectWorkTree();
-  diagnostics.push(...workTree.diagnostics.map((diagnostic) => ({
-    severity: "error",
-    code: diagnostic.code,
-    change: diagnostic.input,
-    path: diagnostic.path,
-    message: diagnostic.message
-  })));
-  const groupInspection = await inspectChangeGroups({ workTree, focusTree });
-  diagnostics.push(...groupInspection.diagnostics);
-  const dependencyInspection = await inspectChangeDependencies({
-    workTree,
-    preferredOrder: groupInspection.groups.flatMap((group) => group.slices.map((slice) => slice.name))
-  });
-  diagnostics.push(...dependencyInspection.diagnostics);
-  const changeMap = new Map(workTree.changes.map((ref) => [ref.name, ref.path]));
-  const allNames = [.../* @__PURE__ */ new Set([...changeMap.keys(), ...focusedSet])].sort();
-  const records = [];
-  const nowMs = options.nowMs ?? Date.now();
-  for (const name of allNames) {
-    const path = changeMap.get(name);
-    let kind = "\u2014";
-    let title = name;
-    let blockerEntries = [];
-    let readiness = emptyReadiness(false);
-    let ageDays = null;
-    const isFocused = focusedSet.has(name);
-    let isBlocked = false;
-    let done = 0;
-    let total = 0;
-    let progressKnown = false;
-    if (path) {
-      try {
-        const content = await readFile3(path, "utf-8");
-        title = extractChangeTitle(content) ?? name;
-        blockerEntries = extractBlockerEntries(content);
-        try {
-          const frontmatter = parseFrontmatter(content);
-          kind = frontmatter?.kind ? String(frontmatter.kind) : "\u2014";
-        } catch (error) {
-          kind = "(invalid)";
-          runtime.push({
-            code: "frontmatter_parse_failed",
-            operation: "parseFrontmatter",
-            path,
-            message: toErrorMessage(error)
-          });
-        }
-        isBlocked = dependencyInspection.activeBlockers.get(name) ?? hasMeaningfulBlockers(content);
-        const checkboxes = countCheckboxes(content);
-        done = checkboxes.done;
-        total = checkboxes.total;
-        progressKnown = true;
-        const details = collectArchiveReadiness(content, { activeBlockers: isBlocked });
-        readiness = {
-          incompleteTasks: details.taskTodos.length,
-          incompleteVerify: details.verifyTodos.length,
-          activeBlockers: details.activeBlockers,
-          missingScenarios: details.missingScenarios,
-          deterministic: details.deterministic,
-          semantic: details.semantic,
-          archiveReady: details.archiveReady
-        };
-      } catch (error) {
-        diagnostics.push({
-          severity: "error",
-          code: "change_read_failed",
-          change: name,
-          path,
-          message: "unable to read open Change",
-          hint: toErrorMessage(error)
-        });
-        runtime.push({
-          code: "change_read_failed",
-          operation: "readFile",
-          path,
-          message: toErrorMessage(error)
-        });
-      }
-      try {
-        const metadata = await stat(path);
-        ageDays = Math.floor((nowMs - metadata.mtime.getTime()) / (1e3 * 60 * 60 * 24));
-      } catch (error) {
-        diagnostics.push({
-          severity: "error",
-          code: "change_stat_failed",
-          change: name,
-          path,
-          message: "unable to inspect open Change metadata",
-          hint: toErrorMessage(error)
-        });
-        runtime.push({
-          code: "change_stat_failed",
-          operation: "stat",
-          path,
-          message: toErrorMessage(error)
-        });
-      }
-    } else {
-      kind = "(missing)";
-      const path2 = focusedPaths.get(name);
-      diagnostics.push({
-        severity: "error",
-        code: "focused_change_missing",
-        change: name,
-        path: path2,
-        message: "focus marker points to a missing Change file"
-      });
-      runtime.push({
-        code: "focused_change_missing",
-        operation: "resolveChange",
-        path: path2,
-        message: "focus marker points to a missing change file"
-      });
-    }
-    records.push({
-      output: {
-        name,
-        kind,
-        progress: { done, total },
-        ageDays,
-        isFocused,
-        isBlocked,
-        path: path ? normalizeLogicalPath(path) : null
-      },
-      progressKnown,
-      title,
-      blockerEntries,
-      readiness
-    });
-  }
-  return {
-    manage,
-    focused: [...focusedSet].sort(),
-    records,
-    groups: groupInspection.groups,
-    plan: dependencyInspection.plan,
-    archiveTrend: await readArchiveTrend(runtime),
-    diagnostics,
-    runtime
-  };
-}
-function emptyReadiness(activeBlockers) {
-  return {
-    incompleteTasks: 0,
-    incompleteVerify: 0,
-    activeBlockers,
-    missingScenarios: false,
-    deterministic: "pass",
-    semantic: "needs-review",
-    archiveReady: activeBlockers ? "no" : "judgment"
-  };
-}
-function extractChangeTitle(content) {
-  const heading = content.split(/\r?\n/).find((line) => line.startsWith("# Change: "));
-  return heading?.slice("# Change: ".length).trim() || null;
-}
-function extractBlockerEntries(content) {
-  return extractSection(content, "Blockers").split("\n").map((line) => line.trim()).filter((line) => /^[-*]\s+/.test(line)).map((line) => line.replace(/^[-*]\s+/, "").trim()).filter((line) => line.toLowerCase() !== "none");
-}
-async function readArchiveTrend(runtime) {
-  const indexPath = join3(ARCHIVES_DIR, "INDEX.md");
-  if (!existsSync(indexPath))
-    return [];
-  try {
-    const content = await readFile3(indexPath, "utf-8");
-    const dateRe = /^\| (\d{4}-\d{2})-\d{2} \|/gm;
-    const counts = {};
-    let match;
-    while ((match = dateRe.exec(content)) !== null) {
-      const month = match[1];
-      counts[month] = (counts[month] || 0) + 1;
-    }
-    return Object.keys(counts).sort().map((month) => ({ month, count: counts[month] }));
-  } catch (error) {
-    runtime.push({
-      code: "archive_index_read_failed",
-      operation: "readFile",
-      path: indexPath,
-      message: toErrorMessage(error)
-    });
-    return [];
-  }
-}
+// src/history/query.ts
+import { readFile as readFile4 } from "fs/promises";
+
+// src/history/inspect.ts
+import { readFile as readFile3 } from "fs/promises";
+import { basename, dirname as dirname2, relative as relative3 } from "path";
 
 // src/history/model.ts
 var HISTORY_DEFAULT_LIMIT = 20;
@@ -1369,14 +1133,12 @@ var ArchiveHistoryError = class extends Error {
 };
 
 // src/history/inspect.ts
-import { readFile as readFile4 } from "fs/promises";
-import { basename, dirname as dirname2, relative as relative3 } from "path";
 var EXECUTABLE_WORK_REF_RE2 = /^[a-z0-9-]+(?:\/[a-z0-9-]+)?$/;
 var GROUP_NAME_RE = /^[a-z0-9-]+$/;
 var ARCHIVE_NAME_RE = /^(\d{4}-\d{2}-\d{2})_(.+)\.md$/;
 async function inspectArchiveHistory(options = {}) {
   const archivesDir = options.archivesDir ?? ARCHIVES_DIR;
-  const tree = await inspectArchiveTree({ archivesDir });
+  const tree = options.archiveTree ?? await inspectArchiveTree({ archivesDir });
   const diagnostics = tree.diagnostics.map((diagnostic) => ({
     severity: "error",
     code: diagnostic.code,
@@ -1397,7 +1159,7 @@ async function inspectArchiveHistory(options = {}) {
     const path = archiveOutputPath(sourcePath, archivesDir);
     let content;
     try {
-      content = await readFile4(sourcePath, "utf-8");
+      content = await readFile3(sourcePath, "utf-8");
     } catch (error) {
       const message = toErrorMessage(error);
       diagnostics.push({ severity: "error", code: "archive_read_failed", path, message: `unable to read archived work: ${message}` });
@@ -1479,7 +1241,8 @@ function parseArchiveEntry(sourcePath, path, archivesDir, content) {
       summary: summary.value,
       summaryTruncated: summary.truncated,
       path,
-      sourcePath
+      sourcePath,
+      searchSummary: rawSummary
     }
   };
 }
@@ -1527,11 +1290,11 @@ function compareDiagnostics(left, right) {
 }
 
 // src/history/query.ts
-import { readFile as readFile5 } from "fs/promises";
 function queryArchiveHistory(records, query = {}) {
   validateArchiveHistoryQuery(query);
   const limit = query.limit ?? HISTORY_DEFAULT_LIMIT;
-  const matched = records.filter((record) => (!query.since || record.date >= query.since) && (!query.until || record.date <= query.until) && (!query.kind || record.kind === query.kind) && (!query.group || record.group === query.group)).sort(compareHistoryRecords2);
+  const matched = records.filter((record) => (!query.since || record.date >= query.since) && (!query.until || record.date <= query.until) && (!query.kind || record.kind === query.kind) && (!query.group || record.group === query.group) && (!query.search || `${record.workRef}
+${record.searchSummary ?? record.summary}`.toLowerCase().includes(query.search.toLowerCase()))).sort(compareHistoryRecords2);
   const selected = matched.slice(0, limit);
   return {
     records: selected.map(toOutputRecord),
@@ -1556,6 +1319,8 @@ function validateArchiveHistoryQuery(query) {
     throw new ArchiveHistoryError("invalid_history_kind", "history kind must be non-empty");
   if (query.group !== void 0 && !/^[a-z0-9-]+$/.test(query.group))
     throw new ArchiveHistoryError("invalid_history_group", "history group must be one lowercase kebab-case segment");
+  if (query.search !== void 0 && query.search.trim() === "")
+    throw new ArchiveHistoryError("invalid_history_search", "history search must be non-empty");
 }
 function selectArchiveHistoryRecord(records, selector) {
   const matches = "path" in selector ? records.filter((record) => record.path === selector.path) : records.filter((record) => record.workRef === selector.workRef);
@@ -1571,7 +1336,7 @@ function selectArchiveHistoryRecord(records, selector) {
 async function readArchiveHistoryDetail(record) {
   let content;
   try {
-    content = await readFile5(record.sourcePath, "utf-8");
+    content = await readFile4(record.sourcePath, "utf-8");
   } catch (error) {
     throw new ArchiveHistoryError("archive_read_failed", `unable to read archived Change ${record.path}: ${error instanceof Error ? error.message : String(error)}`);
   }
@@ -1596,7 +1361,7 @@ function historyInspectionComplete(inspection) {
   return inspection.diagnostics.every((diagnostic) => diagnostic.severity !== "error");
 }
 function toOutputRecord(record) {
-  const { sourcePath: _sourcePath, ...output } = record;
+  const { searchSummary: _searchSummary, sourcePath: _sourcePath, ...output } = record;
   return output;
 }
 function boundEvidence(section, omitNone = false) {
@@ -1617,6 +1382,234 @@ function compareHistoryRecords2(left, right) {
   return right.date.localeCompare(left.date) || left.workRef.localeCompare(right.workRef) || left.path.localeCompare(right.path);
 }
 
+// src/status/inspect.ts
+async function inspectProjectStatus(options = {}) {
+  const runtime = [];
+  const diagnostics = [];
+  let manage = resolveManagePolicy({});
+  try {
+    const configInspection = await inspectRspConfig();
+    const configValid = configInspection.issues.length === 0;
+    manage = resolveManagePolicy(configInspection.config, { configValid });
+    if (!configValid) {
+      diagnostics.push({
+        severity: "error",
+        code: "invalid_config",
+        path: CONFIG_PATH,
+        message: configInspection.issues.join("; ")
+      });
+    }
+  } catch (error) {
+    manage = resolveManagePolicy({}, { configValid: false });
+    diagnostics.push({
+      severity: "error",
+      code: "invalid_config",
+      path: CONFIG_PATH,
+      message: toErrorMessage(error)
+    });
+  }
+  const focusTree = await inspectFocusTree();
+  for (const diagnostic of focusTree.diagnostics) {
+    diagnostics.push({
+      severity: "error",
+      code: diagnostic.code,
+      change: diagnostic.input,
+      path: diagnostic.path,
+      message: diagnostic.message
+    });
+  }
+  const rawFocusedSet = new Set(focusTree.markers.map((marker) => marker.name));
+  const focusedSet = /* @__PURE__ */ new Set();
+  const focusedPaths = /* @__PURE__ */ new Map();
+  for (const name of rawFocusedSet) {
+    try {
+      const ref = resolveWorkRef(name, { executable: true });
+      focusedSet.add(ref.name);
+      focusedPaths.set(ref.name, ref.path);
+    } catch (error) {
+      if (!(error instanceof WorkRefError))
+        throw error;
+      diagnostics.push({
+        severity: "error",
+        code: error.code,
+        path: `.rsp/focus.d/${name}`,
+        change: name,
+        message: error.message
+      });
+    }
+  }
+  const workTree = await inspectWorkTree();
+  const archiveTree = await inspectArchiveTree();
+  const historyInspection = await inspectArchiveHistory({ archiveTree });
+  diagnostics.push(...workTree.diagnostics.map((diagnostic) => ({
+    severity: "error",
+    code: diagnostic.code,
+    change: diagnostic.input,
+    path: diagnostic.path,
+    message: diagnostic.message
+  })));
+  const groupInspection = await inspectChangeGroups({ workTree, focusTree, archiveTree });
+  diagnostics.push(...groupInspection.diagnostics);
+  const dependencyInspection = await inspectChangeDependencies({
+    workTree,
+    archiveTree,
+    preferredOrder: groupInspection.groups.flatMap((group) => group.slices.map((slice) => slice.name))
+  });
+  diagnostics.push(...dependencyInspection.diagnostics);
+  const changeMap = new Map(workTree.changes.map((ref) => [ref.name, ref.path]));
+  const allNames = [.../* @__PURE__ */ new Set([...changeMap.keys(), ...focusedSet])].sort();
+  const records = [];
+  const nowMs = options.nowMs ?? Date.now();
+  for (const name of allNames) {
+    const path = changeMap.get(name);
+    let kind = "\u2014";
+    let title = name;
+    let blockerEntries = [];
+    let readiness = emptyReadiness(false);
+    let ageDays = null;
+    const isFocused = focusedSet.has(name);
+    let isBlocked = false;
+    let done = 0;
+    let total = 0;
+    let progressKnown = false;
+    if (path) {
+      try {
+        const content = await readFile5(path, "utf-8");
+        title = extractChangeTitle(content) ?? name;
+        blockerEntries = extractBlockerEntries(content);
+        try {
+          const frontmatter = parseFrontmatter(content);
+          kind = frontmatter?.kind ? String(frontmatter.kind) : "\u2014";
+        } catch (error) {
+          kind = "(invalid)";
+          runtime.push({
+            code: "frontmatter_parse_failed",
+            operation: "parseFrontmatter",
+            path,
+            message: toErrorMessage(error)
+          });
+        }
+        isBlocked = dependencyInspection.activeBlockers.get(name) ?? hasMeaningfulBlockers(content);
+        const checkboxes = countCheckboxes(content);
+        done = checkboxes.done;
+        total = checkboxes.total;
+        progressKnown = true;
+        const details = collectArchiveReadiness(content, { activeBlockers: isBlocked });
+        readiness = {
+          incompleteTasks: details.taskTodos.length,
+          incompleteVerify: details.verifyTodos.length,
+          activeBlockers: details.activeBlockers,
+          missingScenarios: details.missingScenarios,
+          deterministic: details.deterministic,
+          semantic: details.semantic,
+          archiveReady: details.archiveReady
+        };
+      } catch (error) {
+        diagnostics.push({
+          severity: "error",
+          code: "change_read_failed",
+          change: name,
+          path,
+          message: "unable to read open Change",
+          hint: toErrorMessage(error)
+        });
+        runtime.push({
+          code: "change_read_failed",
+          operation: "readFile",
+          path,
+          message: toErrorMessage(error)
+        });
+      }
+      try {
+        const metadata = await stat(path);
+        ageDays = Math.floor((nowMs - metadata.mtime.getTime()) / (1e3 * 60 * 60 * 24));
+      } catch (error) {
+        diagnostics.push({
+          severity: "error",
+          code: "change_stat_failed",
+          change: name,
+          path,
+          message: "unable to inspect open Change metadata",
+          hint: toErrorMessage(error)
+        });
+        runtime.push({
+          code: "change_stat_failed",
+          operation: "stat",
+          path,
+          message: toErrorMessage(error)
+        });
+      }
+    } else {
+      kind = "(missing)";
+      const path2 = focusedPaths.get(name);
+      diagnostics.push({
+        severity: "error",
+        code: "focused_change_missing",
+        change: name,
+        path: path2,
+        message: "focus marker points to a missing Change file"
+      });
+      runtime.push({
+        code: "focused_change_missing",
+        operation: "resolveChange",
+        path: path2,
+        message: "focus marker points to a missing change file"
+      });
+    }
+    records.push({
+      output: {
+        name,
+        kind,
+        progress: { done, total },
+        ageDays,
+        isFocused,
+        isBlocked,
+        path: path ? normalizeLogicalPath(path) : null
+      },
+      progressKnown,
+      title,
+      blockerEntries,
+      readiness
+    });
+  }
+  return {
+    manage,
+    focused: [...focusedSet].sort(),
+    records,
+    groups: groupInspection.groups,
+    plan: dependencyInspection.plan,
+    archiveTrend: historyInspectionComplete(historyInspection) ? deriveArchiveTrend(historyInspection.records) : [],
+    diagnostics: [...diagnostics, ...historyInspection.rootExists ? historyInspection.diagnostics : []],
+    runtime: [...runtime, ...historyInspection.runtime]
+  };
+}
+function emptyReadiness(activeBlockers) {
+  return {
+    incompleteTasks: 0,
+    incompleteVerify: 0,
+    activeBlockers,
+    missingScenarios: false,
+    deterministic: "pass",
+    semantic: "needs-review",
+    archiveReady: activeBlockers ? "no" : "judgment"
+  };
+}
+function extractChangeTitle(content) {
+  const heading = content.split(/\r?\n/).find((line) => line.startsWith("# Change: "));
+  return heading?.slice("# Change: ".length).trim() || null;
+}
+function extractBlockerEntries(content) {
+  return extractSection(content, "Blockers").split("\n").map((line) => line.trim()).filter((line) => /^[-*]\s+/.test(line)).map((line) => line.replace(/^[-*]\s+/, "").trim()).filter((line) => line.toLowerCase() !== "none");
+}
+function deriveArchiveTrend(records) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const month = record.date.slice(0, 7);
+    counts.set(month, (counts.get(month) ?? 0) + 1);
+  }
+  return [...counts].sort(([left], [right]) => left.localeCompare(right)).map(([month, count]) => ({ month, count }));
+}
+
 // src/status/dependency-forest.ts
 function defaultRoots(plan) {
   const selected = new Set(plan.nodes.filter((node) => node.selection === "selected").map((node) => node.name));

package/dist/{chunk-4K53353L.mjs → chunk-NX55NIC3.mjs}

@@ -14,17 +14,21 @@ import { chmod, copyFile, mkdir, readdir, readFile, rename, rm } from "fs/promis
 import { dirname, join, relative } from "path";
 var DEFAULT_PACKAGED_SKILL_NAMES = [
   "rsp",
-  "rsp-address-review",
   "rsp-commit",
   "rsp-design",
   "rsp-diagnose",
   "rsp-implement",
   "rsp-manage",
   "rsp-release-docs",
+  "rsp-resolve-findings",
   "rsp-review",
   "rsp-shape",
   "rsp-tdd"
 ];
+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}`);
 }
@@ -199,8 +203,9 @@ async function installPackagedSkills(args = {}, options = {}) {
   }
   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: [], unchanged: [], replaced: [] };
+  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);
@@ -221,8 +226,30 @@ async function installPackagedSkills(args = {}, options = {}) {
       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)
-    throw new Error(`conflicting packaged Skills: ${conflicts.join(", ")}; rerun with --force to replace only these package-owned directories`);
+    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 });
@@ -252,6 +279,15 @@ async function installPackagedSkills(args = {}, options = {}) {
     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}`);
@@ -308,7 +344,7 @@ async function installPackagedSkills(args = {}, options = {}) {
 }
 function printSkillInstallResult(result, dryRun = false) {
   const prefix = dryRun ? "would be " : "";
-  for (const status of ["installed", "unchanged", "replaced"]) {
+  for (const status of ["installed", "unchanged", "replaced", "removed"]) {
     if (result[status].length > 0)
       console.log(`  ${prefix}${status}: ${result[status].join(", ")}`);
   }