dsh-plugin-capabilities 0.1.6 → 0.2.0

package/src/routes.ts

@@ -3,16 +3,39 @@
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import { scanAllMcp } from './agents.ts'
 import { readJsonBody, sameOrigin, sendJson } from './http.ts'
+import { loadMarketIndex, type MarketMcpServer } from './market.ts'
+import { openDirectory } from './opener.ts'
+import { addGitRepo, addLocalRepo, rootExists } from './repos.ts'
 import { dshLaunch, restartOwnedByShell, scheduleRestart, trustedRestartRequest } from './restart.ts'
-import { deleteSkill, validateSkillInput, writeSkill, type SkillInput } from './skills.ts'
+import { deleteSkill, setSkillPolicy, userSkillsDir, validateSkillInput, writeSkill, type SkillInput } from './skills.ts'
+import { findRootByUrl, loadState, pluginStateDir, removeSkillRoot, type SkillRootEntry } from './state.ts'
 import { listMcp, removeMcp, setMcpDisabled, upsertMcp, validateMcpInput, type McpInput } from './mcp.ts'
-import type { CapabilitiesHost } from './types.ts'
+import type { CapabilitiesHost, HostSkill } from './types.ts'
 
 /** Only this source is writable from the Settings page (provider rank 400). */
 const EDITABLE_SOURCE = 'user-dsh'
 
+/** One catalog skill as the browser sees it (editable/dir flags added). */
+type SkillRow = HostSkill & { editable: boolean; dir?: string; policyEditable: boolean }
+
+function toSkillRow(skill: HostSkill): SkillRow {
+  const dir = skill.resourceBase?.kind === 'directory' ? skill.resourceBase.path : undefined
+  return { ...skill, editable: skill.source === EDITABLE_SOURCE, ...(dir !== undefined ? { dir } : {}), policyEditable: dir !== undefined }
+}
+
+/** One registered repository plus a liveness flag (roots can go stale). */
+function toRootView(entry: SkillRootEntry): SkillRootEntry & { live: boolean } {
+  return { ...entry, live: entry.roots.every(root => rootExists(root)) }
+}
+
+export interface CapabilitiesRoutesConfig {
+  profileDirPath: string
+  /** Remount the host-plane skill provider after root-set changes. */
+  remountProvider: () => Promise<void>
+}
+
 /** Register the manager's routes; returns the disposer removing them all. */
-export function mountCapabilitiesRoutes(host: CapabilitiesHost, config: { profileDirPath: string }): () => void {
+export function mountCapabilitiesRoutes(host: CapabilitiesHost, config: CapabilitiesRoutesConfig): () => void {
   const disposers = [
     host.webServer.register({
       kind: 'exact',
@@ -25,9 +48,7 @@ export function mountCapabilitiesRoutes(host: CapabilitiesHost, config: { profil
         }
         try {
           const skills = await host.skills.list()
-          sendJson(response, 200, {
-            skills: skills.map(skill => ({ ...skill, editable: skill.source === EDITABLE_SOURCE })),
-          })
+          sendJson(response, 200, { skills: skills.map(toSkillRow) })
         } catch (error) {
           sendJson(response, 500, { error: error instanceof Error ? error.message : String(error) })
         }
@@ -47,6 +68,10 @@ export function mountCapabilitiesRoutes(host: CapabilitiesHost, config: { profil
         const name = url.searchParams.get('name') ?? ''
         try {
           const definition = await host.skills.get(name)
+          if (definition === undefined) {
+            sendJson(response, 404, { error: 'skill not found' })
+            return
+          }
           sendJson(response, 200, { name: definition.name, content: definition.content })
         } catch (error) {
           sendJson(response, 500, { error: error instanceof Error ? error.message : String(error) })
@@ -114,6 +139,311 @@ export function mountCapabilitiesRoutes(host: CapabilitiesHost, config: { profil
       },
     }),
 
+    host.webServer.register({
+      kind: 'exact',
+      path: '/dsh-plugin-capabilities/skill/policy',
+      handler: async (request: IncomingMessage, response: ServerResponse) => {
+        if (request.method !== 'POST') {
+          response.writeHead(405, { allow: 'POST' })
+          response.end()
+          return
+        }
+        if (!sameOrigin(request)) {
+          sendJson(response, 403, { error: 'untrusted origin' })
+          return
+        }
+        try {
+          const body = (await readJsonBody(request)) as { name?: unknown; enabled?: unknown }
+          if (typeof body.name !== 'string' || typeof body.enabled !== 'boolean') {
+            sendJson(response, 400, { error: 'name and enabled are required' })
+            return
+          }
+          const definition = await host.skills.get(body.name)
+          if (definition === undefined) {
+            sendJson(response, 404, { error: 'skill not found' })
+            return
+          }
+          if (definition.path === undefined) {
+            sendJson(response, 422, { error: 'skill has no file on disk (runtime-registered)' })
+            return
+          }
+          setSkillPolicy(definition.path, body.enabled)
+          sendJson(response, 200, { ok: true })
+        } catch (error) {
+          sendJson(response, 500, { error: error instanceof Error ? error.message : String(error) })
+        }
+      },
+    }),
+
+    host.webServer.register({
+      kind: 'exact',
+      path: '/dsh-plugin-capabilities/open',
+      handler: async (request: IncomingMessage, response: ServerResponse) => {
+        if (request.method !== 'POST') {
+          response.writeHead(405, { allow: 'POST' })
+          response.end()
+          return
+        }
+        if (!sameOrigin(request)) {
+          sendJson(response, 403, { error: 'untrusted origin' })
+          return
+        }
+        try {
+          const body = (await readJsonBody(request)) as { target?: unknown; name?: unknown; id?: unknown }
+          if (typeof body.target !== 'string') {
+            sendJson(response, 400, { error: 'target is required' })
+            return
+          }
+          // Targets are resolved server-side; the browser never supplies a
+          // raw path, so this cannot be turned into an arbitrary open.
+          let dir: string | undefined
+          if (body.target === 'user-skills') {
+            dir = userSkillsDir()
+          } else if (body.target === 'plugin-state') {
+            dir = pluginStateDir()
+          } else if (body.target === 'skill') {
+            if (typeof body.name !== 'string') {
+              sendJson(response, 400, { error: 'name is required' })
+              return
+            }
+            const definition = await host.skills.get(body.name)
+            if (definition === undefined) {
+              sendJson(response, 404, { error: 'skill not found' })
+              return
+            }
+            dir = definition.path !== undefined
+              ? definition.path.replace(/[/\\]SKILL\.md$/, '').replace(/[/\\][^/\\]+\.md$/, '')
+              : definition.resourceBase?.kind === 'directory' ? definition.resourceBase.path : undefined
+          } else if (body.target === 'root') {
+            if (typeof body.id !== 'string') {
+              sendJson(response, 400, { error: 'id is required' })
+              return
+            }
+            const entry = loadState().skillRoots.find(row => row.id === body.id)
+            if (entry === undefined) {
+              sendJson(response, 404, { error: 'repository not found' })
+              return
+            }
+            dir = entry.materialDir ?? entry.path ?? entry.roots[0]
+          } else {
+            sendJson(response, 400, { error: 'unknown target' })
+            return
+          }
+          if (dir === undefined || !openDirectory(dir)) {
+            sendJson(response, 422, { error: 'directory is not available on disk' })
+            return
+          }
+          sendJson(response, 200, { ok: true })
+        } catch (error) {
+          sendJson(response, 500, { error: error instanceof Error ? error.message : String(error) })
+        }
+      },
+    }),
+
+    host.webServer.register({
+      kind: 'exact',
+      path: '/dsh-plugin-capabilities/roots',
+      handler: async (request: IncomingMessage, response: ServerResponse) => {
+        if (request.method !== 'GET') {
+          response.writeHead(405, { allow: 'GET' })
+          response.end()
+          return
+        }
+        sendJson(response, 200, { roots: loadState().skillRoots.map(toRootView) })
+      },
+    }),
+
+    host.webServer.register({
+      kind: 'exact',
+      path: '/dsh-plugin-capabilities/roots/add',
+      handler: async (request: IncomingMessage, response: ServerResponse) => {
+        if (request.method !== 'POST') {
+          response.writeHead(405, { allow: 'POST' })
+          response.end()
+          return
+        }
+        if (!sameOrigin(request)) {
+          sendJson(response, 403, { error: 'untrusted origin' })
+          return
+        }
+        try {
+          const body = (await readJsonBody(request)) as { kind?: unknown; path?: unknown; url?: unknown }
+          if (body.kind !== 'local' && body.kind !== 'git') {
+            sendJson(response, 400, { error: 'kind must be local or git' })
+            return
+          }
+          const entry = body.kind === 'local'
+            ? typeof body.path === 'string' && body.path.trim() !== ''
+              ? await addLocalRepo(body.path)
+              : undefined
+            : typeof body.url === 'string' && body.url.trim() !== ''
+              ? await addGitRepo(body.url)
+              : undefined
+          if (entry === undefined) {
+            sendJson(response, 400, { error: body.kind === 'local' ? 'path is required' : 'url is required' })
+            return
+          }
+          await config.remountProvider()
+          sendJson(response, 200, { ok: true, root: toRootView(entry) })
+        } catch (error) {
+          sendJson(response, 400, { error: error instanceof Error ? error.message : String(error) })
+        }
+      },
+    }),
+
+    host.webServer.register({
+      kind: 'exact',
+      path: '/dsh-plugin-capabilities/roots/remove',
+      handler: async (request: IncomingMessage, response: ServerResponse) => {
+        if (request.method !== 'POST') {
+          response.writeHead(405, { allow: 'POST' })
+          response.end()
+          return
+        }
+        if (!sameOrigin(request)) {
+          sendJson(response, 403, { error: 'untrusted origin' })
+          return
+        }
+        try {
+          const body = (await readJsonBody(request)) as { id?: unknown }
+          if (typeof body.id !== 'string') {
+            sendJson(response, 400, { error: 'id is required' })
+            return
+          }
+          const ok = removeSkillRoot(body.id)
+          if (!ok) {
+            sendJson(response, 404, { error: 'repository not found' })
+            return
+          }
+          await config.remountProvider()
+          sendJson(response, 200, { ok: true })
+        } catch (error) {
+          sendJson(response, 500, { error: error instanceof Error ? error.message : String(error) })
+        }
+      },
+    }),
+
+    host.webServer.register({
+      kind: 'exact',
+      path: '/dsh-plugin-capabilities/market/skills',
+      handler: async (request: IncomingMessage, response: ServerResponse) => {
+        if (request.method !== 'GET') {
+          response.writeHead(405, { allow: 'GET' })
+          response.end()
+          return
+        }
+        const index = await loadMarketIndex('skills')
+        if (index === null) {
+          sendJson(response, 502, { error: 'market index unavailable (offline?)' })
+          return
+        }
+        sendJson(response, 200, {
+          source: index.source,
+          repos: (index.skills ?? []).map(repo => ({ ...repo, installedId: findRootByUrl(repo.url)?.id ?? null })),
+        })
+      },
+    }),
+
+    host.webServer.register({
+      kind: 'exact',
+      path: '/dsh-plugin-capabilities/market/mcp',
+      handler: async (request: IncomingMessage, response: ServerResponse) => {
+        if (request.method !== 'GET') {
+          response.writeHead(405, { allow: 'GET' })
+          response.end()
+          return
+        }
+        const index = await loadMarketIndex('mcp')
+        if (index === null) {
+          sendJson(response, 502, { error: 'market index unavailable (offline?)' })
+          return
+        }
+        const existing = new Set(listMcp(config.profileDirPath).map(row => row.serverName))
+        sendJson(response, 200, {
+          source: index.source,
+          servers: (index.servers ?? []).map(server => ({ ...server, installed: existing.has(server.id) })),
+        })
+      },
+    }),
+
+    host.webServer.register({
+      kind: 'exact',
+      path: '/dsh-plugin-capabilities/market/skills/install',
+      handler: async (request: IncomingMessage, response: ServerResponse) => {
+        if (request.method !== 'POST') {
+          response.writeHead(405, { allow: 'POST' })
+          response.end()
+          return
+        }
+        if (!sameOrigin(request)) {
+          sendJson(response, 403, { error: 'untrusted origin' })
+          return
+        }
+        try {
+          const body = (await readJsonBody(request)) as { url?: unknown }
+          if (typeof body.url !== 'string') {
+            sendJson(response, 400, { error: 'url is required' })
+            return
+          }
+          const entry = await addGitRepo(body.url)
+          await config.remountProvider()
+          sendJson(response, 200, { ok: true, root: toRootView(entry) })
+        } catch (error) {
+          sendJson(response, 400, { error: error instanceof Error ? error.message : String(error) })
+        }
+      },
+    }),
+
+    host.webServer.register({
+      kind: 'exact',
+      path: '/dsh-plugin-capabilities/market/mcp/install',
+      handler: async (request: IncomingMessage, response: ServerResponse) => {
+        if (request.method !== 'POST') {
+          response.writeHead(405, { allow: 'POST' })
+          response.end()
+          return
+        }
+        if (!sameOrigin(request)) {
+          sendJson(response, 403, { error: 'untrusted origin' })
+          return
+        }
+        try {
+          const body = (await readJsonBody(request)) as { id?: unknown }
+          if (typeof body.id !== 'string') {
+            sendJson(response, 400, { error: 'id is required' })
+            return
+          }
+          const index = await loadMarketIndex('mcp')
+          const server = index?.servers?.find((row: MarketMcpServer) => row.id === body.id)
+          if (server === undefined) {
+            sendJson(response, 404, { error: 'server not found in the market index' })
+            return
+          }
+          if (listMcp(config.profileDirPath).some(row => row.serverName === server.id)) {
+            sendJson(response, 409, { error: 'already installed' })
+            return
+          }
+          const input: McpInput = {
+            id: '',
+            serverName: server.id,
+            transport: server.transport,
+            ...(server.transport === 'stdio'
+              ? { command: server.command, args: server.args, env: undefined }
+              : { url: server.url }),
+          }
+          const invalid = validateMcpInput(input)
+          if (invalid !== null) {
+            sendJson(response, 400, { error: invalid })
+            return
+          }
+          const id = upsertMcp(config.profileDirPath, input)
+          sendJson(response, 200, { ok: true, id, restartNeeded: true })
+        } catch (error) {
+          sendJson(response, 500, { error: error instanceof Error ? error.message : String(error) })
+        }
+      },
+    }),
+
     host.webServer.register({
       kind: 'exact',
       path: '/dsh-plugin-capabilities/mcp',

package/src/skills.test.ts

@@ -2,7 +2,7 @@ import { mkdtempSync, readFileSync, rmSync, existsSync, writeFileSync, mkdirSync
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { afterAll, describe, expect, it } from 'vitest'
-import { deleteSkill, serializeSkill, validateSkillInput, writeSkill, type SkillInput } from './skills.ts'
+import { deleteSkill, serializeSkill, setSkillPolicy, validateSkillInput, writeSkill, type SkillInput } from './skills.ts'
 
 const root = mkdtempSync(join(tmpdir(), 'dsh-caps-skills-'))
 afterAll(() => rmSync(root, { recursive: true, force: true }))
@@ -71,3 +71,47 @@ describe('writeSkill / deleteSkill', () => {
     expect(existsSync(join(root, 'skills', 'flat.txt'))).toBe(true)
   })
 })
+
+describe('setSkillPolicy', () => {
+  const file = join(root, 'policy', 'SKILL.md')
+  const original = '---\nname: pol\ndescription: "A skill"\nwhenToUse: "later"\nlicense: MIT\n---\n\nBody stays.\n'
+
+  it('disables by adding both keys and keeps everything else byte-for-byte', () => {
+    mkdirSync(join(root, 'policy'), { recursive: true })
+    writeFileSync(file, original)
+    setSkillPolicy(file, false)
+    const text = readFileSync(file, 'utf8')
+    expect(text).toContain('disable-model-invocation: true')
+    expect(text).toContain('user-invocable: false')
+    expect(text).toContain('name: pol')
+    expect(text).toContain('whenToUse: "later"')
+    expect(text).toContain('license: MIT')
+    expect(text).toContain('Body stays.')
+    // Idempotent: disabling twice does not duplicate the keys.
+    setSkillPolicy(file, false)
+    expect(readFileSync(file, 'utf8').match(/disable-model-invocation/g)).toHaveLength(1)
+  })
+
+  it('re-enables by removing both keys', () => {
+    setSkillPolicy(file, true)
+    const text = readFileSync(file, 'utf8')
+    expect(text).not.toContain('disable-model-invocation')
+    expect(text).not.toContain('user-invocable')
+    expect(text).toContain('license: MIT')
+    expect(text).toContain('Body stays.')
+  })
+
+  it('preserves CRLF files and rejects frontmatter-less files', () => {
+    const crlf = join(root, 'policy-crlf', 'SKILL.md')
+    mkdirSync(join(root, 'policy-crlf'), { recursive: true })
+    writeFileSync(crlf, '---\r\nname: crlf\r\ndescription: d\r\n---\r\n\r\nbody\r\n')
+    setSkillPolicy(crlf, false)
+    const text = readFileSync(crlf, 'utf8')
+    expect(text).toContain('disable-model-invocation: true\r')
+    expect(text).toContain('user-invocable: false\r')
+
+    const bare = join(root, 'policy-bare.md')
+    writeFileSync(bare, 'no frontmatter here')
+    expect(() => setSkillPolicy(bare, false)).toThrow(/frontmatter/)
+  })
+})

package/src/skills.ts

@@ -5,7 +5,7 @@
  * land in the catalog without any restart.
  */
 
-import { existsSync, mkdirSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 
@@ -79,3 +79,24 @@ export function deleteSkill(name: string, dshHome?: string): boolean {
   rmSync(dir, { recursive: true, force: true })
   return true
 }
+
+/**
+ * Flip one skill file's load policy by editing only the two invocation keys
+ * in its frontmatter — `disable-model-invocation: true` plus
+ * `user-invocable: false` together take the skill out of both the model and
+ * the human catalogs on every standard-provider surface; enabling removes
+ * both keys (defaults permit both surfaces). Works on any file-backed skill
+ * (user, project, agent, bundled, custom); the rest of the file, including
+ * custom keys, ordering, and body, survives byte-for-byte.
+ */
+export function setSkillPolicy(file: string, enabled: boolean): void {
+  const text = readFileSync(file, 'utf8')
+  const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text)
+  if (match === null) throw new Error('skill file has no frontmatter block')
+  const newline = text.includes('\r\n---') ? '\r\n' : '\n'
+  const body = text.slice(match[0].length)
+  const lines = match[1].split(/\r?\n/)
+  const kept = lines.filter(line => !/^(disable-model-invocation|user-invocable):/.test(line))
+  if (!enabled) kept.push('disable-model-invocation: true', 'user-invocable: false')
+  writeFileSync(file, `---${newline}${kept.join(newline)}${newline}---${body}`, 'utf8')
+}

package/src/smoke.test.ts

@@ -8,7 +8,7 @@
  */
 
 import { spawn, execFile } from 'node:child_process'
-import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs'
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
 import { tmpdir, homedir } from 'node:os'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
@@ -153,5 +153,57 @@ describe.skipIf(process.env.DSH_DESKTOP_PLUGIN_SMOKE !== '1' || !guard || !nodeO
     expect(servers.servers.some(row => row.serverName === 'smokeweb')).toBe(true)
     const patch = readFileSync(join(smokeRoot, 'profiles', 'web', 'cordis.patch.yml'), 'utf8')
     expect(patch).toContain('@deepseek-ai/dsh-mcp-client')
+
+    // 6. Local skill repository: register a folder, provider remounts, the
+    // skill enters the catalog under source "custom".
+    const repoDir = join(smokeRoot, 'my-repo')
+    mkdirSync(join(repoDir, 'repo-skill'), { recursive: true })
+    writeFileSync(join(repoDir, 'repo-skill', 'SKILL.md'), '---\nname: repo-skill\ndescription: from a local repo\n---\n\nhi')
+    const addRoot = await post('/dsh-plugin-capabilities/roots/add', { kind: 'local', path: repoDir })
+    expect(addRoot.status).toBe(200)
+    expect(readFileSync(join(smokeRoot, 'dsh-plugin-capabilities', 'state.json'), 'utf8')).toContain('my-repo') // roots recorded
+    let repoSeen = false
+    for (let tick = 0; tick < 10 && !repoSeen; tick++) {
+      await new Promise(resolve => setTimeout(resolve, 1000))
+      const again = await fetch(`${base}/dsh-plugin-capabilities/skills`).then(r => r.json()) as { skills: Array<{ name: string; source: string; policyEditable: boolean }> }
+      repoSeen = again.skills.some(skill => skill.name === 'repo-skill' && skill.source === 'custom' && skill.policyEditable)
+    }
+    expect(repoSeen).toBe(true)
+
+    // 7. Policy toggle flips the invocation flags through the watched file.
+    const policyOff = await post('/dsh-plugin-capabilities/skill/policy', { name: 'repo-skill', enabled: false })
+    expect(policyOff.status).toBe(200)
+    expect(readFileSync(join(repoDir, 'repo-skill', 'SKILL.md'), 'utf8')).toContain('disable-model-invocation: true')
+    let policySeen = false
+    for (let tick = 0; tick < 10 && !policySeen; tick++) {
+      await new Promise(resolve => setTimeout(resolve, 1000))
+      const again = await fetch(`${base}/dsh-plugin-capabilities/skills`).then(r => r.json()) as { skills: Array<{ name: string; invocation: { modelInvocable: boolean; userInvocable: boolean } }> }
+      const row = again.skills.find(skill => skill.name === 'repo-skill')
+      policySeen = row !== undefined && !row.invocation.modelInvocable && !row.invocation.userInvocable
+    }
+    expect(policySeen).toBe(true)
+    const policyRestore = await post('/dsh-plugin-capabilities/skill/policy', { name: 'repo-skill', enabled: true })
+    expect(policyRestore.status).toBe(200)
+
+    // 8. Market: MCP index serves (remote or bundled fallback) and one-click
+    // install writes a profile row.
+    const marketIndex = await fetch(`${base}/dsh-plugin-capabilities/market/mcp`)
+    expect(marketIndex.status).toBe(200)
+    const marketBody = await marketIndex.json() as { servers: Array<{ id: string; installed: boolean }> }
+    const memory = marketBody.servers.find(server => server.id === 'memory')
+    expect(memory).toBeDefined()
+    if (memory !== undefined && !memory.installed) {
+      const install = await post('/dsh-plugin-capabilities/market/mcp/install', { id: 'memory' })
+      expect(install.status).toBe(200)
+      const after = await fetch(`${base}/dsh-plugin-capabilities/mcp`).then(r => r.json()) as { servers: Array<{ serverName: string }> }
+      expect(after.servers.some(row => row.serverName === 'memory')).toBe(true)
+    }
+
+    // 9. Open-folder route resolves server-side and answers ok (no GUI
+    // assertion beyond the route not failing headless).
+    const open = await post('/dsh-plugin-capabilities/open', { target: 'user-skills' })
+    expect([200, 422]).toContain(open.status)
+    const openBad = await post('/dsh-plugin-capabilities/open', { target: 'root', id: 'does-not-exist' })
+    expect(openBad.status).toBe(404)
   })
 })

package/src/state.test.ts

@@ -0,0 +1,64 @@
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterAll, describe, expect, it } from 'vitest'
+import { addSkillRoot, findRootByUrl, loadState, materialDirFor, newEntryId, removeSkillRoot, saveState } from './state.ts'
+
+const root = mkdtempSync(join(tmpdir(), 'dsh-caps-state-'))
+afterAll(() => rmSync(root, { recursive: true, force: true }))
+
+describe('state round-trip', () => {
+  it('returns empty for missing and corrupt files', () => {
+    expect(loadState(join(root, 'missing'))).toEqual({ skillRoots: [] })
+    const corrupt = join(root, 'corrupt')
+    mkdirSync(join(corrupt, 'dsh-plugin-capabilities'), { recursive: true })
+    writeFileSync(join(corrupt, 'dsh-plugin-capabilities', 'state.json'), '{oops')
+    expect(loadState(corrupt)).toEqual({ skillRoots: [] })
+  })
+
+  it('adds, finds by url, and removes entries', () => {
+    const home = join(root, 'home')
+    const entry = addSkillRoot({ id: newEntryId('git'), kind: 'git', label: 'a/b', url: 'a/b', roots: [join(root, 'x')] }, home)
+    expect(loadState(home).skillRoots).toHaveLength(1)
+    expect(findRootByUrl('a/b', home)?.id).toBe(entry.id)
+    expect(findRootByUrl('other/repo', home)).toBeUndefined()
+
+    expect(removeSkillRoot(entry.id, home)).toBe(true)
+    expect(removeSkillRoot(entry.id, home)).toBe(false)
+    expect(loadState(home).skillRoots).toHaveLength(0)
+  })
+
+  it('drops malformed entries on load instead of failing', () => {
+    const home = join(root, 'home-malformed')
+    saveState({
+      skillRoots: [
+        { id: 'ok', kind: 'local', label: 'ok', roots: [], addedAt: 1 },
+        { nope: true } as never,
+        null as never,
+      ],
+    }, home)
+    const loaded = loadState(home)
+    expect(loaded.skillRoots.map(entry => entry.id)).toEqual(['ok'])
+  })
+})
+
+describe('removeSkillRoot with link material', () => {
+  it('deletes the junction wrapper without touching the linked source', () => {
+    const home = join(root, 'home-link')
+    const source = join(root, 'linked-source')
+    mkdirSync(source, { recursive: true })
+    writeFileSync(join(source, 'SKILL.md'), '---\nname: keep\n---\n')
+
+    const id = newEntryId('local')
+    const material = materialDirFor(id, home)
+    mkdirSync(material, { recursive: true })
+    symlinkSync(source, join(material, 'skill'), process.platform === 'win32' ? 'junction' : 'dir')
+    addSkillRoot({ id, kind: 'local', label: 'keep', path: source, roots: [material], materialDir: material }, home)
+
+    expect(removeSkillRoot(id, home)).toBe(true)
+    expect(existsSync(material)).toBe(false)
+    expect(existsSync(join(source, 'SKILL.md'))).toBe(true)
+    // State file persisted without the entry.
+    expect(readFileSync(join(home, 'dsh-plugin-capabilities', 'state.json'), 'utf8')).not.toContain('linked-source')
+  })
+})