@takara-ai/miru-code 1.5.3 → 1.7.2

package/src/installer/installer.ts

@@ -1,4 +1,5 @@
-import { unlink } from "node:fs/promises";
+import { mkdir, rmdir, unlink } from "node:fs/promises";
+import { dirname, join } from "node:path";
 import { loadAgentTemplate } from "../agents.ts";
 import { clearBenchmarkHistory } from "../benchmark/history.ts";
 import { brandTitle, dim, divider, green, hint, info, success, writeStdout } from "../cli-ui.ts";
@@ -13,6 +14,14 @@ import {
 } from "./agents.ts";
 import { withPreservedBenchmarkFlag } from "./benchmark-mode.ts";
 import {
+  ensureSharedCavemanOwnersOnInstall,
+  isSharedCavemanPath,
+  removeCavemanSkillFiles,
+  resolveSharedCavemanUninstall,
+} from "./caveman-shared.ts";
+import {
+  codexSkillsFeatureEnabled,
+  ensureCodexSkillsFeature,
   mergeJsonMember,
   mergeTomlBlock,
   removeJsonMember,
@@ -24,13 +33,44 @@ import {
 import { mergeHooks, removeHooks } from "./hooks/install.ts";
 import { promptConfirm, promptMultiSelect, requireInteractiveTerminal } from "./prompt.ts";
 import { CURSOR_RULES_MDC } from "./search-policy.ts";
+import {
+  ensureSharedSkillOwnersOnInstall,
+  isSharedSkillPath,
+  removeSkillMdAndOwners,
+  resolveSharedSkillUninstall,
+  type SkillPathOf,
+} from "./shared-skill.ts";
+import { CAVEMAN_SKILL_MD } from "./style-packs/caveman.ts";
+import { STE_REFERENCE_FILES, STE_SKILL_MD } from "./style-packs/ste/skill.ts";
+
+const steSkillPathOf: SkillPathOf = (agent) =>
+  agent.steSkillDir ? join(agent.steSkillDir, "SKILL.md") : null;
 
 export interface WriteResult {
   path: string;
   action: InstallAction;
+  note?: string;
 }
 
-export type IntegrationId = "mcp" | "instructions" | "subagent" | "hooks" | "rules";
+export type IntegrationId =
+  | "mcp"
+  | "instructions"
+  | "subagent"
+  | "hooks"
+  | "rules"
+  | "caveman"
+  | "ste";
+
+/** Shared context for one install/uninstall pass (path dedupe + shared-skill keep). */
+export interface ApplyCtx {
+  selectedAgents: AgentTarget[];
+  cavemanSeenPaths: Set<string>;
+  steSeenPaths: Set<string>;
+  /** Defaults to AGENT_TARGETS; override in tests. */
+  allAgents?: AgentTarget[];
+  /** Defaults to isAgentDetected; override in tests. */
+  isDetected?: (agent: AgentTarget) => Promise<boolean>;
+}
 
 interface Integration {
   id: IntegrationId;
@@ -39,7 +79,7 @@ interface Integration {
   experimental?: boolean;
   defaultChecked?: boolean;
   planPath: (agent: AgentTarget) => string | null;
-  apply: (agent: AgentTarget, mode: InstallMode) => Promise<WriteResult | null>;
+  apply: (agent: AgentTarget, mode: InstallMode, ctx?: ApplyCtx) => Promise<WriteResult | null>;
 }
 
 const ACTION_DETAIL: Partial<Record<InstallAction, string>> = {
@@ -183,6 +223,202 @@ async function applySubagent(agent: AgentTarget, mode: InstallMode): Promise<Wri
   }
 }
 
+async function withCodexSkillsFeature(
+  agent: AgentTarget,
+  result: WriteResult,
+): Promise<WriteResult> {
+  if (agent.id !== "codex" || !agent.mcp?.path) {
+    return result;
+  }
+  const featureAction = await ensureCodexSkillsFeature(agent.mcp.path);
+  if (featureAction === "unchanged") {
+    return result;
+  }
+  const skillsNote = "enabled [features] skills = true in config.toml";
+  if (result.action === "unchanged") {
+    return {
+      ...result,
+      action: "updated",
+      note: result.note ? `${result.note}; ${skillsNote}` : skillsNote,
+    };
+  }
+  return {
+    ...result,
+    note: result.note
+      ? `${result.note}; also sets [features] skills = true in config.toml`
+      : "also sets [features] skills = true in config.toml",
+  };
+}
+
+async function applyCaveman(
+  agent: AgentTarget,
+  mode: InstallMode,
+  ctx: ApplyCtx = {
+    selectedAgents: [agent],
+    cavemanSeenPaths: new Set(),
+    steSeenPaths: new Set(),
+  },
+): Promise<WriteResult | null> {
+  const path = agent.cavemanSkillPath;
+  if (!path) {
+    return null;
+  }
+
+  const skillDir = dirname(path);
+  const allAgents = ctx.allAgents ?? AGENT_TARGETS;
+  const shared = isSharedCavemanPath(path, allAgents);
+  const sharedCtx = {
+    selectedAgents: ctx.selectedAgents,
+    allAgents: ctx.allAgents,
+    isDetected: ctx.isDetected,
+  };
+
+  if (mode === "uninstall") {
+    if (shared) {
+      const decision = await resolveSharedCavemanUninstall(path, skillDir, agent, sharedCtx);
+      if (decision.kind === "defer" || decision.kind === "keep") {
+        return { path, action: "unchanged", note: decision.note };
+      }
+    }
+    return { path, action: await removeCavemanSkillFiles(path, skillDir) };
+  }
+
+  if (shared) {
+    await ensureSharedCavemanOwnersOnInstall(skillDir, path, agent, sharedCtx);
+  }
+
+  if (ctx.cavemanSeenPaths.has(path)) {
+    return withCodexSkillsFeature(agent, {
+      path,
+      action: "unchanged",
+      note: "shared skill path already written",
+    });
+  }
+  ctx.cavemanSeenPaths.add(path);
+
+  const existed = await Bun.file(path).exists();
+  if (existed && (await Bun.file(path).text()) === CAVEMAN_SKILL_MD) {
+    return withCodexSkillsFeature(agent, { path, action: "unchanged" });
+  }
+
+  await mkdir(skillDir, { recursive: true });
+  await Bun.write(path, CAVEMAN_SKILL_MD);
+  return withCodexSkillsFeature(agent, {
+    path,
+    action: existed ? "updated" : "created",
+  });
+}
+
+async function stePackMatches(skillDir: string): Promise<boolean> {
+  const skillPath = join(skillDir, "SKILL.md");
+  if (!(await Bun.file(skillPath).exists())) {
+    return false;
+  }
+  if ((await Bun.file(skillPath).text()) !== STE_SKILL_MD) {
+    return false;
+  }
+  for (const file of STE_REFERENCE_FILES) {
+    const path = join(skillDir, file.relativePath);
+    if (!(await Bun.file(path).exists()) || (await Bun.file(path).text()) !== file.content) {
+      return false;
+    }
+  }
+  return true;
+}
+
+async function removeSteSkillFiles(
+  skillDir: string,
+  skillPath: string,
+): Promise<Extract<InstallAction, "removed" | "not-found">> {
+  let removedReference = false;
+  for (const file of STE_REFERENCE_FILES) {
+    const referencePath = join(skillDir, file.relativePath);
+    if (await Bun.file(referencePath).exists()) {
+      await unlink(referencePath);
+      removedReference = true;
+    }
+  }
+
+  // Match Caveman's ownership model: remove Miru's known files only. Leave
+  // any user-created files in this skill directory untouched.
+  try {
+    await rmdir(join(skillDir, "references"));
+  } catch {
+    // User files may keep the directory non-empty.
+  }
+
+  const skillAction = await removeSkillMdAndOwners(skillPath, skillDir);
+  return removedReference && skillAction === "not-found" ? "removed" : skillAction;
+}
+
+async function applySte(
+  agent: AgentTarget,
+  mode: InstallMode,
+  ctx: ApplyCtx = {
+    selectedAgents: [agent],
+    cavemanSeenPaths: new Set(),
+    steSeenPaths: new Set(),
+  },
+): Promise<WriteResult | null> {
+  const skillDir = agent.steSkillDir;
+  if (!skillDir) {
+    return null;
+  }
+
+  const skillPath = join(skillDir, "SKILL.md");
+  const allAgents = ctx.allAgents ?? AGENT_TARGETS;
+  const shared = isSharedSkillPath(skillPath, allAgents, steSkillPathOf);
+  const sharedCtx = {
+    selectedAgents: ctx.selectedAgents,
+    allAgents: ctx.allAgents,
+    isDetected: ctx.isDetected,
+  };
+
+  if (mode === "uninstall") {
+    if (shared) {
+      const decision = await resolveSharedSkillUninstall(
+        skillPath,
+        skillDir,
+        agent,
+        sharedCtx,
+        steSkillPathOf,
+      );
+      if (decision.kind === "defer" || decision.kind === "keep") {
+        return { path: skillPath, action: "unchanged", note: decision.note };
+      }
+    }
+    return { path: skillPath, action: await removeSteSkillFiles(skillDir, skillPath) };
+  }
+
+  if (shared) {
+    await ensureSharedSkillOwnersOnInstall(skillDir, skillPath, agent, sharedCtx, steSkillPathOf);
+  }
+
+  if (ctx.steSeenPaths.has(skillPath)) {
+    return withCodexSkillsFeature(agent, {
+      path: skillPath,
+      action: "unchanged",
+      note: "shared skill path already written",
+    });
+  }
+  ctx.steSeenPaths.add(skillPath);
+
+  const existed = await Bun.file(skillPath).exists();
+  if (existed && (await stePackMatches(skillDir))) {
+    return withCodexSkillsFeature(agent, { path: skillPath, action: "unchanged" });
+  }
+
+  await mkdir(join(skillDir, "references"), { recursive: true });
+  await Bun.write(skillPath, STE_SKILL_MD);
+  for (const file of STE_REFERENCE_FILES) {
+    await Bun.write(join(skillDir, file.relativePath), file.content);
+  }
+  return withCodexSkillsFeature(agent, {
+    path: skillPath,
+    action: existed ? "updated" : "created",
+  });
+}
+
 const INTEGRATIONS: Integration[] = [
   {
     id: "mcp",
@@ -221,26 +457,94 @@ const INTEGRATIONS: Integration[] = [
     planPath: (agent) => agent.hooksPath,
     apply: applyHooks,
   },
+  {
+    id: "caveman",
+    label: "Caveman",
+    description: "on-demand chat compression skill (/caveman)",
+    experimental: true,
+    defaultChecked: false,
+    planPath: (agent) => agent.cavemanSkillPath,
+    apply: applyCaveman,
+  },
+  {
+    id: "ste",
+    label: "STE writing",
+    description: "on-demand clear technical English for docs (/ste)",
+    experimental: true,
+    defaultChecked: false,
+    planPath: (agent) => (agent.steSkillDir ? join(agent.steSkillDir, "SKILL.md") : null),
+    apply: applySte,
+  },
 ];
 
+function integrationApplies(integration: Integration, agent: AgentTarget): boolean {
+  return integration.planPath(agent) !== null;
+}
+
+function integrationsForAgents(agents: AgentTarget[]): Integration[] {
+  return INTEGRATIONS.filter((integration) =>
+    agents.some((agent) => integrationApplies(integration, agent)),
+  );
+}
+
 function formatActionLine(integration: Integration, result: WriteResult): string {
   const icon = ACTION_ICON[result.action] ?? dim("·");
-  const detail = ACTION_DETAIL[result.action];
+  const detail = result.note ?? ACTION_DETAIL[result.action];
   const suffix = detail ? dim(` — ${detail}`) : "";
   return `   ${icon} ${integration.label.padEnd(13)} ${dim(result.action)}${suffix}\n      ${dim(result.path)}`;
 }
 
-function printPlan(agents: AgentTarget[], integrations: Integration[]): void {
+/** Plan footnote for Codex + skills (Caveman / STE); null when nothing should be shown. */
+export function codexSkillsPlanNote(
+  mode: InstallMode,
+  skillsFeatureEnabled: boolean,
+): string | null {
+  if (mode === "install") {
+    return "also sets [features] skills = true in ~/.codex/config.toml";
+  }
+  if (skillsFeatureEnabled) {
+    return "leaves [features] skills = true in ~/.codex/config.toml";
+  }
+  return null;
+}
+
+/** @deprecated Prefer codexSkillsPlanNote. */
+export const codexCavemanPlanNote = codexSkillsPlanNote;
+
+async function printPlan(
+  mode: InstallMode,
+  agents: AgentTarget[],
+  integrations: Integration[],
+): Promise<void> {
   writeStdout("");
   writeStdout(dim("Plan"));
   divider();
 
   for (const agent of agents) {
     writeStdout(` ${agent.displayName}`);
+    let printedCodexSkillsNote = false;
     for (const integration of integrations) {
       const path = integration.planPath(agent);
-      const icon = path ? green("✓") : dim("–");
-      writeStdout(`   ${icon} ${integration.label.padEnd(13)} ${path ?? dim("(not supported)")}`);
+      if (!path) {
+        continue;
+      }
+      writeStdout(`   ${green("✓")} ${integration.label.padEnd(13)} ${path}`);
+      if (
+        !printedCodexSkillsNote &&
+        (integration.id === "caveman" || integration.id === "ste") &&
+        agent.id === "codex"
+      ) {
+        let skillsEnabled = false;
+        const configPath = agent.mcp?.path;
+        if (mode === "uninstall" && configPath && (await Bun.file(configPath).exists())) {
+          skillsEnabled = codexSkillsFeatureEnabled(await Bun.file(configPath).text());
+        }
+        const note = codexSkillsPlanNote(mode, skillsEnabled);
+        if (note) {
+          writeStdout(`      ${dim(note)}`);
+          printedCodexSkillsNote = true;
+        }
+      }
     }
   }
   writeStdout("");
@@ -255,12 +559,20 @@ async function apply(
   writeStdout(dim(mode === "install" ? "Installing" : "Removing"));
   divider();
 
+  const ctx: ApplyCtx = {
+    selectedAgents: agents,
+    cavemanSeenPaths: new Set(),
+    steSeenPaths: new Set(),
+  };
+
   for (const agent of agents) {
     writeStdout(` ${agent.displayName}`);
     for (const integration of integrations) {
-      const result = await integration.apply(agent, mode);
+      if (!integrationApplies(integration, agent)) {
+        continue;
+      }
+      const result = await integration.apply(agent, mode, ctx);
       if (!result) {
-        writeStdout(`   ${dim("–")} ${integration.id.padEnd(13)} ${dim("not supported")}`);
         continue;
       }
       writeStdout(formatActionLine(integration, result));
@@ -317,7 +629,13 @@ export async function runInstaller(mode: InstallMode): Promise<void> {
     return;
   }
 
-  const integrationItems = INTEGRATIONS.map((integration) => ({
+  const availableIntegrations = integrationsForAgents(chosenAgents);
+  if (availableIntegrations.length === 0) {
+    hint("No integrations apply to the selected agents. Exiting.");
+    return;
+  }
+
+  const integrationItems = availableIntegrations.map((integration) => ({
     label: `${integration.label}${integration.experimental ? dim(" (experimental)") : ""} — ${integration.description}`,
     value: integration,
     checked: install ? (integration.defaultChecked ?? true) : true,
@@ -333,7 +651,7 @@ export async function runInstaller(mode: InstallMode): Promise<void> {
     return;
   }
 
-  printPlan(chosenAgents, chosenIntegrations);
+  await printPlan(mode, chosenAgents, chosenIntegrations);
 
   const proceed = await promptConfirm(install ? "Proceed?" : "Remove miru configuration?", install);
   if (!proceed) {
@@ -355,11 +673,14 @@ export async function runInstaller(mode: InstallMode): Promise<void> {
 }
 
 export {
+  applyCaveman,
   applyHooks,
   applyInstructions,
   applyMcp,
+  applySte,
   applySubagent,
   INTEGRATIONS,
+  integrationsForAgents,
   mergeJsonMember as mergeMcpJson,
   removeJsonMember as removeMcpJson,
 };

package/src/installer/prompt.ts

@@ -163,6 +163,17 @@ export function parseInstallerKeyForTest(chunk: Buffer): string {
   return parseKey(chunk);
 }
 
+/** Map confirm keys to the next Yes selection. Left/← and y → Yes; right/→ and n → No. */
+export function nextConfirmYesSelected(yesSelected: boolean, key: string): boolean {
+  if (key === "left" || key === "yes") {
+    return true;
+  }
+  if (key === "right" || key === "no") {
+    return false;
+  }
+  return yesSelected;
+}
+
 async function withRawMode<T>(fn: () => Promise<T>): Promise<T> {
   input.setRawMode(true);
   input.resume();
@@ -328,14 +339,10 @@ export async function promptConfirm(question: string, defaultYes = true): Promis
         writeRaw("\n");
         return yesSelected;
       }
-      if (key === "left" || key === "no") {
-        if (yesSelected) {
-          yesSelected = false;
-          updateConfirmPromptLine(question, yesSelected);
-        }
-      } else if (key === "right" || key === "yes") {
-        if (!yesSelected) {
-          yesSelected = true;
+      if (key === "left" || key === "right" || key === "yes" || key === "no") {
+        const next = nextConfirmYesSelected(yesSelected, key);
+        if (next !== yesSelected) {
+          yesSelected = next;
           updateConfirmPromptLine(question, yesSelected);
         }
       }

package/src/installer/search-policy.ts

@@ -88,7 +88,7 @@ export const INSTRUCTIONS_MARKDOWN = `## Miru Code Search
 
 ${SEARCH_POLICY_BODY}
 
-Run \`miru setup\` once — the MCP server loads your API key from \`credentials.json\`.
+Run \`miru setup\` once — the MCP server loads credentials from \`credentials.json\`, and interactive first use can auto-start device login when nothing is stored.
 
 CLI fallback when MCP is unavailable:
 
@@ -123,7 +123,8 @@ export const MCP_SERVER_INSTRUCTIONS =
   "(3) `find_related` traces similar code in other files, not more context in the same file. " +
   "(4) `locate` finds exact substrings (env vars, symbols, error codes) — prefer over Grep; use mode=count or locations when possible. " +
   "Always pass the project root as `repo`. Local repos return `absolute_path` on each hit — use Read only to edit. " +
-  "Native Grep/Glob only outside the indexed repo or for non-code tasks.";
+  "Native Grep/Glob only outside the indexed repo or for non-code tasks. " +
+  "On credential errors, call this server's `auth` tool — not the host `mcp_auth` tool.";
 
 export const MCP_BENCHMARK_SERVER_INSTRUCTIONS =
   `${MCP_SERVER_INSTRUCTIONS} ` +

package/src/installer/shared-skill.ts

@@ -0,0 +1,200 @@
+import { mkdir, rmdir, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { AGENT_TARGETS, type AgentTarget, type InstallAction, isAgentDetected } from "./agents.ts";
+
+/** Sidecar next to a shared Agent Skill (`SKILL.md`) tracking which IDEs own it. */
+export const SKILL_OWNERS_FILE = "miru-owners.json";
+
+/** Context for shared-path skill install/uninstall (Caveman, STE, …). */
+export interface SharedSkillCtx {
+  selectedAgents: AgentTarget[];
+  allAgents?: AgentTarget[];
+  isDetected?: (agent: AgentTarget) => Promise<boolean>;
+}
+
+export type SkillPathOf = (agent: AgentTarget) => string | null;
+
+function uniqueIds(ids: Iterable<string>): string[] {
+  return Array.from(new Set(ids));
+}
+
+function resolvedAgents(ctx: SharedSkillCtx): AgentTarget[] {
+  return ctx.allAgents ?? AGENT_TARGETS;
+}
+
+function agentsSharingPath(
+  path: string,
+  allAgents: AgentTarget[],
+  pathOf: SkillPathOf,
+): AgentTarget[] {
+  return allAgents.filter((agent) => pathOf(agent) === path);
+}
+
+export function isSharedSkillPath(
+  path: string,
+  allAgents: AgentTarget[],
+  pathOf: SkillPathOf,
+): boolean {
+  return agentsSharingPath(path, allAgents, pathOf).length > 1;
+}
+
+export async function readSkillOwners(skillDir: string): Promise<string[] | null> {
+  const ownersPath = join(skillDir, SKILL_OWNERS_FILE);
+  if (!(await Bun.file(ownersPath).exists())) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(await Bun.file(ownersPath).text()) as unknown;
+    if (!Array.isArray(parsed)) {
+      return null;
+    }
+    return parsed.filter((item): item is string => typeof item === "string");
+  } catch {
+    return null;
+  }
+}
+
+export async function writeSkillOwners(skillDir: string, owners: string[]): Promise<void> {
+  await mkdir(skillDir, { recursive: true });
+  await Bun.write(
+    join(skillDir, SKILL_OWNERS_FILE),
+    `${JSON.stringify([...owners].sort(), null, 2)}\n`,
+  );
+}
+
+/**
+ * Stamp shared-path ownership on install.
+ * - Existing owners file: add current agent.
+ * - Fresh skill: start with current agent only.
+ * - Legacy skill (file exists, no owners): seed from detected siblings + current;
+ *   skip writing a singleton so uninstall stays on the legacy keep path.
+ */
+export async function ensureSharedSkillOwnersOnInstall(
+  skillDir: string,
+  skillPath: string,
+  agent: AgentTarget,
+  ctx: SharedSkillCtx,
+  pathOf: SkillPathOf,
+): Promise<void> {
+  const existing = await readSkillOwners(skillDir);
+  if (existing !== null) {
+    await writeSkillOwners(skillDir, uniqueIds([...existing, agent.id]));
+    return;
+  }
+
+  if (!(await Bun.file(skillPath).exists())) {
+    await writeSkillOwners(skillDir, [agent.id]);
+    return;
+  }
+
+  const detect = ctx.isDetected ?? isAgentDetected;
+  const seeded: string[] = [];
+  for (const member of agentsSharingPath(skillPath, resolvedAgents(ctx), pathOf)) {
+    if (member.id === agent.id || (await detect(member))) {
+      seeded.push(member.id);
+    }
+  }
+  const unique = uniqueIds(seeded);
+  if (unique.length <= 1) {
+    return;
+  }
+  await writeSkillOwners(skillDir, unique);
+}
+
+async function shouldKeepSharedSkill(
+  path: string,
+  agent: AgentTarget,
+  ctx: SharedSkillCtx,
+  pathOf: SkillPathOf,
+): Promise<boolean> {
+  const detect = ctx.isDetected ?? isAgentDetected;
+  const siblings = agentsSharingPath(path, resolvedAgents(ctx), pathOf).filter(
+    (other) => other.id !== agent.id,
+  );
+
+  for (const sibling of siblings) {
+    if (ctx.selectedAgents.some((selected) => selected.id === sibling.id)) {
+      continue;
+    }
+    if (await detect(sibling)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export type SharedSkillUninstallDecision =
+  | { kind: "defer"; note: string }
+  | { kind: "keep"; note: string }
+  | { kind: "remove" };
+
+/**
+ * Decide whether a shared-path skill uninstall should defer, keep, or remove.
+ * Caller removes files only on `remove`.
+ */
+export async function resolveSharedSkillUninstall(
+  path: string,
+  skillDir: string,
+  agent: AgentTarget,
+  ctx: SharedSkillCtx,
+  pathOf: SkillPathOf,
+): Promise<SharedSkillUninstallDecision> {
+  const selectedSharing = agentsSharingPath(path, ctx.selectedAgents, pathOf);
+  const isLast =
+    selectedSharing.length === 0 || selectedSharing[selectedSharing.length - 1]?.id === agent.id;
+  if (!isLast) {
+    return {
+      kind: "defer",
+      note: "shared skill; remove deferred to last selected IDE",
+    };
+  }
+
+  const owners = await readSkillOwners(skillDir);
+  if (owners !== null) {
+    const removing = new Set<string>(selectedSharing.map((selected) => selected.id));
+    const remaining = owners.filter((ownerId) => !removing.has(ownerId));
+    if (remaining.length > 0) {
+      await writeSkillOwners(skillDir, remaining);
+      return {
+        kind: "keep",
+        note: "shared skill kept — still owned by another IDE",
+      };
+    }
+    return { kind: "remove" };
+  }
+
+  if (await shouldKeepSharedSkill(path, agent, ctx, pathOf)) {
+    return {
+      kind: "keep",
+      note: "shared skill kept — another IDE still uses this path",
+    };
+  }
+  return { kind: "remove" };
+}
+
+/** Remove SKILL.md and owners sidecar; leave sibling skill folders untouched. */
+export async function removeSkillMdAndOwners(
+  path: string,
+  skillDir: string,
+): Promise<Extract<InstallAction, "removed" | "not-found">> {
+  let removedSomething = false;
+
+  if (await Bun.file(path).exists()) {
+    await unlink(path);
+    removedSomething = true;
+  }
+
+  const ownersPath = join(skillDir, SKILL_OWNERS_FILE);
+  if (await Bun.file(ownersPath).exists()) {
+    await unlink(ownersPath);
+    removedSomething = true;
+  }
+
+  try {
+    await rmdir(skillDir);
+  } catch {
+    // Directory not empty or already gone — leave other skills alone.
+  }
+
+  return removedSomething ? "removed" : "not-found";
+}