docks-kit 0.15.2 → 0.15.4

package/cli/src/engine-native/os/types.ts

@@ -0,0 +1,75 @@
+/**
+ * Host modules own only facts that cannot be probed. Anything that can fail at
+ * runtime stays try-then-fallback at the call site; a host module contributes
+ * only the order of that fallback chain.
+ */
+
+export type PlatformName = "linux" | "darwin" | "windows" | "unknown"
+/** Directory-link mechanisms, tried in order before the copy fallback. */
+export type DirectoryLinkKind = "symlink" | "junction"
+/** Tools whose install command differs per host OS. */
+export type HintedTool = "git" | "jq" | "curl" | "ffplay" | "claude" | "codex"
+
+/** A command plus argv, already shaped for how this host must invoke it. */
+export interface Invocation {
+  readonly command: string
+  readonly args: ReadonlyArray<string>
+  /** Preserve a fully quoted Windows command line instead of applying libuv quoting. */
+  readonly windowsVerbatimArguments?: boolean
+}
+
+/** How this host persists a user-level environment variable. */
+export type EnvironmentSetting =
+  | {
+      readonly kind: "profile"
+      /** Home-relative files scanned for an existing setting. */
+      readonly candidates: ReadonlyArray<string>
+      /** Home-relative file that receives the write for this shell. */
+      readonly target: (shell: string | undefined) => string
+      /** Line appended to the target file. */
+      readonly line: string
+    }
+  | {
+      readonly kind: "command"
+      /** Exits zero when the variable is already persisted. */
+      readonly probe: Invocation
+      /** Persists the variable. */
+      readonly apply: Invocation
+      /** Where the value lands, named for the log line. */
+      readonly location: string
+      /** Manual recovery when `apply` fails. */
+      readonly manualHint: string
+    }
+
+/** The two steps that fetch and run a pinned Bun installer. */
+export interface BunInstaller {
+  readonly scriptPath: string
+  readonly download: Invocation
+  readonly run: Invocation
+}
+
+export interface HostOs {
+  readonly id: PlatformName
+  /** `SoT/toolchain.json` `os` field this host matches; "" matches every row. */
+  readonly toolchainOs: string
+  /** Bubblewrap is the Linux-only Codex sandbox runtime. */
+  readonly supportsBubblewrap: boolean
+  /** Directory-link mechanisms tried in order before `skillsSync.ts linkOrCopy` copies. */
+  readonly directoryLinkKinds: ReadonlyArray<DirectoryLinkKind>
+  /** One-line install command for a tool whose package differs per OS. */
+  readonly installHint: (tool: HintedTool) => string
+  /** Filename suffixes tried in order when resolving a bare tool name on PATH. */
+  readonly executableSuffixes: ReadonlyArray<string>
+  /** Shape the argv that actually runs a resolved executable on this host. */
+  readonly invoke: (executablePath: string, args: ReadonlyArray<string>) => Invocation
+  /** Bun executable filename inside `<bunRoot>/bin`. */
+  readonly bunExecutableName: string
+  /** Download-then-run installer for a pinned Bun version placed in `directory`. */
+  readonly bunInstaller: (pin: string, directory: string) => BunInstaller
+  /** How this host persists a user-level environment variable. */
+  readonly environmentSetting: (name: string, value: string) => EnvironmentSetting
+  /** Claude `statusLine.command` for a resolved bun executable and script. */
+  readonly statusLineCommand: (bun: string, script: string) => string
+  /** Reshape the SoT `PostToolUseFailure` command for this host's shell. */
+  readonly failureHookCommand: (command: string) => string
+}

package/cli/src/engine-native/os/windows.ts

@@ -0,0 +1,176 @@
+import { win32 } from "node:path"
+import { p } from "../exec"
+import type { HostOs } from "./types"
+
+function powershellLiteral(value: string): string {
+  return `'${value.replaceAll("'", "''")}'`
+}
+
+function encodedPowerShellCommand(script: string): string {
+  const encoded = Buffer.from(script, "utf16le").toString("base64")
+  return `powershell.exe -NoProfile -NonInteractive -EncodedCommand ${encoded}`
+}
+
+/**
+ * Windows shim encoding handles three hazards: Windows argv parsing, cmd
+ * metacharacter parsing, and percent/newline values that cmd cannot escape.
+ * The encoders are ported from cross-spawn's escape.js and its parseNonShell
+ * assembly, based on:
+ * https://github.com/moxystudio/node-cross-spawn
+ * https://qntm.org/cmd
+ * https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/
+ * https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/cmd
+ */
+const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g
+
+function escapeCommand(arg: string): string {
+  return arg.replace(metaCharsRegExp, "^$1")
+}
+
+function escapeArgument(arg: string, doubleEscapeMetaChars: boolean): string {
+  arg = `${arg}`
+  arg = arg.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"")
+  arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1")
+  arg = `"${arg}"`
+  arg = arg.replace(metaCharsRegExp, "^$1")
+  if (doubleEscapeMetaChars) {
+    arg = arg.replace(metaCharsRegExp, "^$1")
+  }
+  return arg
+}
+
+function assertCommandLineValue(value: string, kind: "executable path" | "argument"): void {
+  const unsupported = value.includes("%")
+    ? "percent sign (%)"
+    : value.includes("\r")
+      ? "carriage return (CR)"
+      : value.includes("\n")
+        ? "line feed (LF)"
+        : undefined
+  if (unsupported === undefined) return
+
+  const executablePercentHint =
+    kind === "executable path" && unsupported === "percent sign (%)"
+      ? " The tool must be reached through its .exe or moved out of a directory whose name contains a percent sign."
+      : ""
+  throw new Error(
+    `${kind} ${JSON.stringify(value)} contains a ${unsupported}, which cannot be escaped on a cmd command line; the caller must pass the value another way.${executablePercentHint}`
+  )
+}
+
+/**
+ * Always absolute. A pathless name lets CreateProcess and libuv search the
+ * parent's current directory before System32, so an untrusted checkout holding
+ * a cmd.exe would win. ComSpec is the documented interpreter, honoured only
+ * when it is an absolute path; otherwise it is rebuilt under SystemRoot.
+ */
+function commandInterpreter(environment: NodeJS.ProcessEnv = process.env): string {
+  const comSpec = environment["ComSpec"] ?? ""
+  if (win32.isAbsolute(comSpec)) return comSpec
+  const systemRoot = environment["SystemRoot"] ?? ""
+  const root = win32.isAbsolute(systemRoot) ? systemRoot : "C:\\Windows"
+  return win32.join(root, "System32", "cmd.exe")
+}
+
+function commandShimInvocation(executablePath: string, args: ReadonlyArray<string>) {
+  assertCommandLineValue(executablePath, "executable path")
+  for (const arg of args) assertCommandLineValue(arg, "argument")
+
+  const normalizedPath = win32.normalize(executablePath)
+  const doubleEscapeMetaChars = /node_modules[\\/]\.bin[\\/][^\\/]+\.cmd$/i.test(normalizedPath)
+  const commandLine = [
+    escapeCommand(normalizedPath),
+    ...args.map((arg) => escapeArgument(arg, doubleEscapeMetaChars))
+  ].join(" ")
+  return {
+    command: commandInterpreter(),
+    args: ["/d", "/v:off", "/s", "/c", `"${commandLine}"`],
+    windowsVerbatimArguments: true
+  } as const
+}
+
+// Authored now, but unreachable until the supported-host admission gate opens.
+export const windows: HostOs = {
+  id: "windows",
+  toolchainOs: "windows",
+  supportsBubblewrap: false,
+  directoryLinkKinds: ["symlink", "junction"],
+  executableSuffixes: [".exe", ".cmd", ".bat", ""],
+  invoke: (executablePath, args) =>
+    /\.(?:cmd|bat)$/i.test(executablePath)
+      ? commandShimInvocation(executablePath, args)
+      : { command: executablePath, args },
+  bunExecutableName: "bun.exe",
+  bunInstaller: (pin, directory) => {
+    const scriptPath = p(directory, "install.ps1")
+    return {
+      scriptPath,
+      download: {
+        command: "curl",
+        args: ["-fsSL", "https://bun.sh/install.ps1", "-o", scriptPath]
+      },
+      run: {
+        command: "powershell.exe",
+        args: [
+          "-NoProfile",
+          "-NonInteractive",
+          "-ExecutionPolicy",
+          "Bypass",
+          "-File",
+          scriptPath,
+          "-Version",
+          pin
+        ]
+      }
+    }
+  },
+  environmentSetting: (name, value) => ({
+    kind: "command",
+    probe: {
+      command: "reg",
+      args: ["query", "HKCU\\Environment", "/v", name]
+    },
+    apply: {
+      command: "setx",
+      args: [name, value]
+    },
+    location: "user environment",
+    manualHint: "set it manually in System Properties > Environment Variables"
+  }),
+  statusLineCommand: (bun, script) => {
+    const bunLiteral = powershellLiteral(bun)
+    const scriptLiteral = powershellLiteral(script)
+    // Module auto-loading reports "Preparing modules for first use" as a
+    // progress record, which a redirected host serializes to stderr as CLIXML.
+    // Claude runs this command every turn, and the records recur across runs, so
+    // silencing progress inside the stored command keeps its streams clean.
+    return encodedPowerShellCommand(
+      `$ProgressPreference = 'SilentlyContinue'; if ((Test-Path -LiteralPath ${bunLiteral} -PathType Leaf) -and (Test-Path -LiteralPath ${scriptLiteral} -PathType Leaf)) { & ${bunLiteral} ${scriptLiteral} }`
+    )
+  },
+  failureHookCommand: (command) => {
+    const prefix = "echo '"
+    if (!command.startsWith(prefix) || !command.endsWith("'")) return command
+    const quotedPayload = command.slice(prefix.length, -1)
+    const posixApostrophe = `'"'"'`
+    if (quotedPayload.replaceAll(posixApostrophe, "").includes("'")) return command
+    const payload = quotedPayload.replaceAll(posixApostrophe, "'")
+    return encodedPowerShellCommand(`Write-Output ${powershellLiteral(payload)}`)
+  },
+  installHint: (tool) => {
+    switch (tool) {
+      case "git":
+        return "winget install --id Git.Git -e"
+      case "jq":
+        return "winget install --id jqlang.jq -e"
+      case "curl":
+        return "winget install --id cURL.cURL -e"
+      case "ffplay":
+        return "winget install --id Gyan.FFmpeg -e"
+      case "claude":
+        return "$tmp = Join-Path $env:TEMP 'claude-install.ps1'; curl.exe -fsSL https://claude.ai/install.ps1 -o $tmp; if ($LASTEXITCODE -eq 0) { powershell.exe -NoProfile -ExecutionPolicy Bypass -File $tmp }"
+      case "codex":
+        return "$tmp = Join-Path $env:TEMP 'codex-install.ps1'; curl.exe -fsSL https://chatgpt.com/codex/install.ps1 -o $tmp; if ($LASTEXITCODE -eq 0) { $env:CODEX_NON_INTERACTIVE = '1'; powershell.exe -NoProfile -ExecutionPolicy Bypass -File $tmp }"
+    }
+  }
+}

package/cli/src/engine-native/parseArgs.ts

@@ -135,7 +135,6 @@ function usage(ctx: Ctx): void {
   )
   echo("  --skip-bubblewrap skip optional bubblewrap bootstrap (Codex Linux sandbox)")
   echo("  --skip-plugin-refresh  install missing plugins but skip refresh-only updates")
-  echo("  --yes             auto-accept toolchain prompts (containers/CI)")
   echo("  --verbose         also print no-op confirmations (already in sync, up to date, left as-is)")
   echo("")
   echo("Deploy-time modifiers (deployed config only; SoT untouched; a later flag-less sync reverts)")
@@ -261,9 +260,6 @@ export function parseArgs(ctx: Ctx, args: ReadonlyArray<string>): void {
       case "--prune":
         ctx.prune = true
         continue
-      case "--yes":
-        ctx.assumeYes = true
-        continue
       case "--verbose":
         ctx.verbose = true
         continue

package/cli/src/engine-native/services.ts

@@ -9,11 +9,9 @@ import {
   DEPENDENCIES,
   defaultProbeExecutor,
   resolveDependency,
-  resolveLocation,
   resolvePath,
   resolveVersion,
   type DependencySpec,
-  type DependencyLocation,
   type ProbeExecutor,
   type ProbeResult,
   type ToolId
@@ -28,8 +26,6 @@ export interface DependencyManager {
   readonly probe: (id: ToolId) => ProbeResult
   readonly version: (id: ToolId) => Promise<string>
   readonly path: (id: ToolId) => Promise<string>
-  readonly location: (id: ToolId) => Promise<DependencyLocation>
-  readonly latest: (id: ToolId) => Promise<string>
   readonly warnMissing: (id: ToolId, logger: Logger, context?: string) => void
 }
 
@@ -68,8 +64,6 @@ export const makeDependencyManager = (
     probe: (id) => resolveDependency(DEPENDENCIES[id], exec, platform.raw()),
     version: (id) => resolveVersion(DEPENDENCIES[id], exec),
     path: (id) => resolvePath(DEPENDENCIES[id], exec, platform.raw()),
-    location: (id) => resolveLocation(DEPENDENCIES[id], exec, platform.raw()),
-    latest: (id) => DEPENDENCIES[id].latest?.(exec) ?? Promise.resolve(""),
     warnMissing: (id, logger, context) => {
       if (warned.has(id)) return
       warned.add(id)

package/cli/src/engine-native/skillsSync.ts

@@ -1,24 +1,39 @@
 /**
  * EngineNative `sync agents` pipeline: universal-skill bootstrap
  * (`npx skills@<pin> add`), Claude symlink healing, --prune reconcile against
- * the kit-managed snapshot, the effect-solutions toolchain callback, and the
- * snapshot write.
+ * the kit-managed snapshot, and the snapshot write.
  */
-import { existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, rmSync, statSync, symlinkSync } from "node:fs"
+import {
+  cpSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  readlinkSync,
+  rmSync,
+  statSync,
+  symlinkSync,
+  writeFileSync
+} from "node:fs"
 import { dirname, relative, resolve } from "node:path"
+import { payloadText } from "../payload"
 import { p, spawnProcess, writeFileIfChanged } from "./exec"
-import { bunBootstrap } from "./bun"
 import type { Ctx } from "./index"
-import { compareCodepoints, isObject, parseJson } from "./jq"
-import type { EngineServices } from "./services"
-import { ensure, field } from "./toolchain"
-import { payloadText } from "../payload"
+import { compareCodepoints } from "./jq"
+import { hostOs, type DirectoryLinkKind } from "./os"
 import { ExitError } from "./parseArgs"
+import type { EngineServices } from "./services"
+import { field } from "./toolchain"
 
 export interface SkillsState {
   present: number
 }
 
+export type LinkOutcome = "symlink" | "junction" | "copy" | "failed"
+
+/** Lets heal and prune distinguish a kit-owned copy from a user's real directory. */
+export const COPY_MARKER = ".docks-kit-copied-skill"
+
 export async function skillsSync(ctx: Ctx): Promise<SkillsState> {
   const state: SkillsState = { present: 0 }
   const skillsDir = p(ctx.agentsDir, "skills")
@@ -29,7 +44,6 @@ export async function skillsSync(ctx: Ctx): Promise<SkillsState> {
 
   await syncUniversal(ctx, state, skillsDir, manifest)
   const failedRemovals = ctx.prune ? await reconcileRemovals(ctx, manifest, snapshot) : []
-  await syncEffectSolutionsCli(ctx)
   updateSnapshot(ctx, manifest, snapshot, failedRemovals)
   return state
 }
@@ -152,15 +166,25 @@ function healClaudeSymlink(ctx: Ctx, skillsDir: string, base: string): boolean {
       return false
     }
   } else if (linkStat !== undefined) {
-    warn(`~/.claude/skills/${base} exists as a real path (not a symlink) — leaving alone; remove manually if it's stale`)
-    return false
+    if (!isKitOwnedCopy(claudeLink)) {
+      warn(`~/.claude/skills/${base} exists as a real path (not a symlink) — leaving alone; remove manually if it's stale`)
+      return false
+    }
+    if (ctx.dryRun) {
+      echo(`[dry-run] would replace kit-created Claude copy: ~/.claude/skills/${base} -> ${relTarget}`)
+      return true
+    }
+    if (!removeKitOwnedCopy(claudeLink)) {
+      warn(`could not remove kit-created copy ~/.claude/skills/${base} — remove it manually, then re-run sync`)
+      return false
+    }
   } else if (ctx.dryRun) {
     echo(`[dry-run] would create missing Claude symlink: ~/.claude/skills/${base} -> ${relTarget}`)
     return true
   }
 
   mkdirSync(claudeSkillsDir, { recursive: true })
-  return linkOrCopyWithWarnings(relTarget, claudeLink, ctx.services)
+  return linkOrCopyWithWarnings(relTarget, claudeLink, ctx.services) !== "failed"
 }
 
 function lstat(path: string): ReturnType<typeof lstatSync> | undefined {
@@ -171,97 +195,105 @@ function lstat(path: string): ReturnType<typeof lstatSync> | undefined {
   }
 }
 
-function safeReadlink(path: string): string {
+/**
+ * A link only counts when it RESOLVES to the skill directory. Windows picks a
+ * symlink's file-or-directory type by autodetecting the target against the
+ * process working directory, not the link's own directory, so a relative
+ * target can yield a symlink that exists but resolves to nothing. Checking
+ * resolution is what makes the next mechanism in the chain reachable.
+ */
+function linksToDirectory(path: string): boolean {
+  if (lstat(path)?.isSymbolicLink() !== true) return false
   try {
-    return readlinkSync(path)
+    return statSync(path).isDirectory()
   } catch {
-    return ""
+    return false
   }
 }
 
+function isKitOwnedCopy(path: string): boolean {
+  return lstat(path)?.isDirectory() === true && existsSync(p(path, COPY_MARKER))
+}
 
-/** Remove a symlink without touching a real directory. */
-function removeLink(path: string): boolean {
+function removeKitOwnedCopy(path: string): boolean {
+  if (!isKitOwnedCopy(path)) return false
   try {
-    rmSync(path, { force: true })
+    rmSync(path, { recursive: true, force: true })
     return true
   } catch {
     return lstat(path) === undefined
   }
 }
 
-/** skills::_link_or_copy — create a symlink without replacing its source. */
-export function linkOrCopy(target: string, link: string): boolean {
-  const resolvedLink = resolve(link)
-  if (resolve(dirname(resolvedLink), target) === resolvedLink) return true
-  removeLink(link)
+function safeReadlink(path: string): string {
   try {
-    symlinkSync(target, link)
+    return readlinkSync(path)
   } catch {
-    return false
+    return ""
   }
-  return lstat(link)?.isSymbolicLink() === true
 }
 
-function linkOrCopyWithWarnings(target: string, link: string, services: EngineServices): boolean {
-  const linked = linkOrCopy(target, link)
-  if (!linked) {
-    services.logger.warn(`could not create symlink ${link}`)
+
+/** Remove a symlink without touching a real directory. */
+function removeLink(path: string): boolean {
+  try {
+    rmSync(path, { force: true })
+    return true
+  } catch {
+    return lstat(path) === undefined
   }
-  return linked
 }
 
-// ------------------------------------------------- toolchain callbacks ----
-
-/** skills::_effect_solutions_install. */
-export function effectSolutionsInstall(
-  ctx: Ctx
-): (mode: "install" | "upgrade", version: string, services: EngineServices) => Promise<number> {
-  return async (mode, version, services) => {
-    const { change, clearProgress, progress, verbose, warn } = services.logger
-    const verb = mode === "upgrade" ? "Upgrading" : "Installing"
-    const pkg = `effect-solutions@${version !== "" ? version : "latest"}`
-
-    const bunState = await bunBootstrap(ctx, services)
-    if (bunState.kind === "deferred") return 1
-    const bun = bunState.executable
+/** skills::_link_or_copy — try directory links in host order, then a marked copy. */
+export function linkOrCopy(
+  target: string,
+  link: string,
+  kinds: ReadonlyArray<DirectoryLinkKind> = hostOs().directoryLinkKinds
+): LinkOutcome {
+  const resolvedLink = resolve(link)
+  const absoluteTarget = resolve(dirname(resolvedLink), target)
+  if (absoluteTarget === resolvedLink) return "symlink"
+  removeLink(link)
 
-    verbose(`${verb} effect-solutions CLI via bun${version !== "" ? ` (pinned ${version})` : ""}...`)
-    progress(`${verb} effect-solutions CLI...`)
-    const installResult = await spawnProcess(bun, ["add", "-g", pkg], { stdio: "ignore" })
-    clearProgress()
-    if (installResult.exitCode !== 0) {
-      warn(`bun add -g ${pkg} failed. Try manually: bun add -g ${pkg}`)
-      return 1
+  for (const kind of kinds) {
+    try {
+      if (kind === "symlink") {
+        symlinkSync(target, link)
+      } else {
+        symlinkSync(absoluteTarget, link, "junction")
+      }
+      if (linksToDirectory(link)) return kind
+    } catch {
+      // The runtime decides whether each mechanism works; try the next one.
     }
+    removeLink(link)
+  }
 
-    const location = await services.deps.location("effect-solutions")
-    const gbin = location.binDir
-    if (location.path !== "") {
-      mkdirSync(p(ctx.home, ".local", "bin"), { recursive: true })
-      linkOrCopyWithWarnings(bun, p(ctx.home, ".local", "bin", "bun"), services)
-      linkOrCopyWithWarnings(location.path, p(ctx.home, ".local", "bin", "effect-solutions"), services)
-      change("effect-solutions CLI ready (linked bun + effect-solutions into ~/.local/bin)")
-    } else {
-      warn(`effect-solutions installed but binary not found under '${gbin !== "" ? gbin : "<unknown>"}' — link it onto PATH manually`)
+  const copyDestinationWasAbsent = lstat(link) === undefined
+  try {
+    cpSync(absoluteTarget, link, { recursive: true })
+    writeFileSync(p(link, COPY_MARKER), "")
+    return "copy"
+  } catch {
+    if (copyDestinationWasAbsent) {
+      try {
+        rmSync(link, { recursive: true, force: true })
+      } catch {
+        // The outcome remains failed; a later sync can retry the destination.
+      }
     }
-    return 0
+    return "failed"
   }
 }
 
-async function syncEffectSolutionsCli(ctx: Ctx): Promise<void> {
-  const { clearProgress, progress, warn } = ctx.services.logger
-  const settings = parseJson(payloadText("SoT/.claude/settings.json"))
-  if (settings === undefined || !isObject(settings)) return
-  const enabledPlugins = settings["enabledPlugins"]
-  if (enabledPlugins === undefined || !isObject(enabledPlugins) || enabledPlugins["effect-kit@docks"] !== true) return
-
-  progress("Checking effect-solutions CLI...")
-  const result = await ensure(ctx, "effect-solutions", effectSolutionsInstall(ctx))
-  clearProgress()
-  if (result !== 0) {
-    warn("effect-solutions bootstrap failed — continuing sync")
+function linkOrCopyWithWarnings(target: string, link: string, services: EngineServices): LinkOutcome {
+  const outcome = linkOrCopy(target, link)
+  if (outcome === "copy") {
+    services.logger.warn(`created copy fallback ${link} because directory linking is unavailable — a later sync will restore a real link once linking works`)
+  } else if (outcome === "failed") {
+    services.logger.warn(`could not create symlink ${link}`)
   }
+  return outcome
 }
 
 // ----------------------------------------------------- prune + snapshot ----
@@ -286,8 +318,13 @@ async function reconcileRemovals(ctx: Ctx, manifest: string, snapshot: string):
     if (current.includes(slug)) continue
     const base = slug.slice(slug.lastIndexOf("/") + 1)
     if (currentBases.has(base)) continue
+    const claudeEntry = p(ctx.home, ".claude", "skills", base)
+    const managedClaudeEntry = lstat(claudeEntry)?.isSymbolicLink() === true || isKitOwnedCopy(claudeEntry)
     if (ctx.dryRun) {
       echo(`[dry-run] kit-managed skill no longer in SoT — would remove: ${base}`)
+      if (managedClaudeEntry) {
+        echo(`[dry-run] kit-managed Claude skill entry — would remove: ~/.claude/skills/${base}`)
+      }
       continue
     }
     progress(`Removing universal skill ${base}...`)
@@ -295,13 +332,24 @@ async function reconcileRemovals(ctx: Ctx, manifest: string, snapshot: string):
       stdio: "ignore"
     })
     clearProgress()
-    if (res.error === undefined && res.exitCode === 0) {
-      removed++
-    } else {
+    if (res.error !== undefined || res.exitCode !== 0) {
       warn(`Failed to remove kit-managed skill: ${base}`)
       failed++
       failedSlugs.push(slug)
+      continue
+    }
+    if (managedClaudeEntry) {
+      const entryStat = lstat(claudeEntry)
+      const removedClaudeEntry = entryStat === undefined
+        || (entryStat.isSymbolicLink() ? removeLink(claudeEntry) : removeKitOwnedCopy(claudeEntry))
+      if (!removedClaudeEntry) {
+        warn(`Failed to remove kit-managed Claude skill entry: ${base}`)
+        failed++
+        failedSlugs.push(slug)
+        continue
+      }
     }
+    removed++
   }
 
   if (removed > 0) {