pilothub 0.0.1 → 0.0.2

package/packages/pilothub/src/cli/commands/syncHelpers.ts

@@ -1,427 +0,0 @@
-import { createHash } from 'node:crypto'
-import { realpath } from 'node:fs/promises'
-import { homedir } from 'node:os'
-import { resolve } from 'node:path'
-import { isCancel, multiselect } from '@clack/prompts'
-import semver from 'semver'
-import { apiRequest, downloadZip } from '../../http.js'
-import {
-  ApiCliTelemetrySyncResponseSchema,
-  ApiRoutes,
-  ApiV1SkillResolveResponseSchema,
-  ApiV1SkillResponseSchema,
-  ApiV1WhoamiResponseSchema,
-  LegacyApiRoutes,
-} from '../../schema/index.js'
-import { hashSkillZip } from '../../skills.js'
-import { getRegistry } from '../registry.js'
-import { findSkillFolders, type SkillFolder } from '../scanSkills.js'
-import type { GlobalOpts } from '../types.js'
-import { fail, formatError } from '../ui.js'
-import type { Candidate, LocalSkill } from './syncTypes.js'
-
-export async function reportTelemetryIfEnabled(params: {
-  token: string
-  registry: string
-  scan: { roots: string[]; skillsByRoot: Record<string, SkillFolder[]> }
-  candidates: Candidate[]
-}) {
-  if (isTelemetryDisabled()) return
-  const versionBySlug = new Map<string, string | null>()
-  for (const candidate of params.candidates) {
-    versionBySlug.set(candidate.slug, candidate.matchVersion ?? null)
-  }
-
-  const roots = params.scan.roots.map((root) => ({
-    rootId: rootTelemetryId(root),
-    label: formatRootLabel(root),
-    skills: (params.scan.skillsByRoot[root] ?? []).map((skill) => ({
-      slug: skill.slug,
-      version: versionBySlug.get(skill.slug) ?? null,
-    })),
-  }))
-
-  try {
-    await apiRequest(
-      params.registry,
-      {
-        method: 'POST',
-        path: LegacyApiRoutes.cliTelemetrySync,
-        token: params.token,
-        body: { roots },
-      },
-      ApiCliTelemetrySyncResponseSchema,
-    )
-  } catch {
-    // ignore telemetry failures
-  }
-}
-
-function isTelemetryDisabled() {
-  const raw = process.env.PILOTHUB_DISABLE_TELEMETRY
-  if (!raw) return false
-  return ['1', 'true', 'yes', 'on'].includes(raw.trim().toLowerCase())
-}
-
-export function buildScanRoots(opts: GlobalOpts, extraRoots: string[] | undefined) {
-  const roots = [opts.workdir, opts.dir, ...(extraRoots ?? [])]
-  return Array.from(new Set(roots.map((root) => resolve(root))))
-}
-
-export function normalizeConcurrency(value: number | undefined) {
-  const raw = typeof value === 'number' ? value : 4
-  const rounded = Number.isFinite(raw) ? Math.round(raw) : 4
-  return Math.min(32, Math.max(1, rounded))
-}
-
-export async function mapWithConcurrency<T, R>(
-  items: T[],
-  limit: number,
-  fn: (item: T) => Promise<R>,
-) {
-  const results = Array.from({ length: items.length }) as R[]
-  let nextIndex = 0
-  const workerCount = Math.min(Math.max(1, limit), items.length || 1)
-
-  async function worker() {
-    while (true) {
-      const index = nextIndex
-      nextIndex += 1
-      if (index >= items.length) return
-      results[index] = await fn(items[index] as T)
-    }
-  }
-
-  await Promise.all(Array.from({ length: workerCount }, () => worker()))
-  return results
-}
-
-export async function checkRegistrySyncState(
-  registry: string,
-  skill: LocalSkill,
-  resolveSupport: { value: boolean | null },
-): Promise<Candidate> {
-  if (resolveSupport.value !== false) {
-    try {
-      const resolved = await apiRequest(
-        registry,
-        {
-          method: 'GET',
-          path: `${ApiRoutes.resolve}?slug=${encodeURIComponent(skill.slug)}&hash=${encodeURIComponent(skill.fingerprint)}`,
-        },
-        ApiV1SkillResolveResponseSchema,
-      )
-      resolveSupport.value = true
-      const latestVersion = resolved.latestVersion?.version ?? null
-      const matchVersion = resolved.match?.version ?? null
-      if (!latestVersion) {
-        return {
-          ...skill,
-          status: 'new',
-          matchVersion: null,
-          latestVersion: null,
-        }
-      }
-      return {
-        ...skill,
-        status: matchVersion ? 'synced' : 'update',
-        matchVersion,
-        latestVersion,
-      }
-    } catch (error) {
-      const message = formatError(error)
-      if (/skill not found/i.test(message) || /HTTP 404/i.test(message)) {
-        resolveSupport.value = true
-        return {
-          ...skill,
-          status: 'new',
-          matchVersion: null,
-          latestVersion: null,
-        }
-      }
-      if (/no matching routes found/i.test(message)) {
-        resolveSupport.value = false
-      } else {
-        throw error
-      }
-    }
-  }
-
-  const meta = await apiRequest(
-    registry,
-    { method: 'GET', path: `${ApiRoutes.skills}/${encodeURIComponent(skill.slug)}` },
-    ApiV1SkillResponseSchema,
-  ).catch(() => null)
-
-  const latestVersion = meta?.latestVersion?.version ?? null
-  if (!latestVersion) {
-    return {
-      ...skill,
-      status: 'new',
-      matchVersion: null,
-      latestVersion: null,
-    }
-  }
-
-  const zip = await downloadZip(registry, { slug: skill.slug, version: latestVersion })
-  const remote = hashSkillZip(zip).fingerprint
-  const matchVersion = remote === skill.fingerprint ? latestVersion : null
-
-  return {
-    ...skill,
-    status: matchVersion ? 'synced' : 'update',
-    matchVersion,
-    latestVersion,
-  }
-}
-
-export async function scanRoots(roots: string[]) {
-  const result = await scanRootsWithLabels(roots)
-  return {
-    roots: result.roots,
-    skillsByRoot: result.skillsByRoot,
-    skills: result.skills,
-    rootsWithSkills: result.rootsWithSkills,
-  }
-}
-
-export async function scanRootsWithLabels(roots: string[], labels?: Record<string, string>) {
-  const all: SkillFolder[] = []
-  const rootsWithSkills: string[] = []
-  const uniqueRoots = await dedupeRoots(roots)
-  const skillsByRoot: Record<string, SkillFolder[]> = {}
-  const rootLabels: Record<string, string> = {}
-  for (const root of uniqueRoots) {
-    const found = await findSkillFolders(root)
-    skillsByRoot[root] = found
-    if (found.length > 0) rootsWithSkills.push(root)
-    all.push(...found)
-    if (labels?.[root]) rootLabels[root] = labels[root] as string
-  }
-  const byFolder = new Map<string, SkillFolder>()
-  for (const folder of all) {
-    byFolder.set(folder.folder, folder)
-  }
-  return {
-    roots: uniqueRoots,
-    skillsByRoot,
-    skills: Array.from(byFolder.values()),
-    rootsWithSkills,
-    rootLabels,
-  }
-}
-
-export function mergeScan(
-  left: {
-    roots: string[]
-    skillsByRoot: Record<string, SkillFolder[]>
-    skills: SkillFolder[]
-    rootsWithSkills: string[]
-    rootLabels: Record<string, string>
-  },
-  right: {
-    roots: string[]
-    skillsByRoot: Record<string, SkillFolder[]>
-    skills: SkillFolder[]
-    rootsWithSkills: string[]
-    rootLabels: Record<string, string>
-  },
-) {
-  const mergedRoots = Array.from(new Set([...left.roots, ...right.roots]))
-  const skillsByRoot: Record<string, SkillFolder[]> = {}
-  for (const root of mergedRoots) {
-    skillsByRoot[root] = right.skillsByRoot[root] ?? left.skillsByRoot[root] ?? []
-  }
-  const rootLabels: Record<string, string> = { ...left.rootLabels, ...right.rootLabels }
-  const byFolder = new Map<string, SkillFolder>()
-  for (const entry of [...left.skills, ...right.skills]) {
-    byFolder.set(entry.folder, entry)
-  }
-  const skills = Array.from(byFolder.values())
-  const rootsWithSkills = mergedRoots.filter((root) => (skillsByRoot[root]?.length ?? 0) > 0)
-  return { roots: mergedRoots, skillsByRoot, skills, rootsWithSkills, rootLabels }
-}
-
-async function dedupeRoots(roots: string[]) {
-  const seen = new Set<string>()
-  const unique: string[] = []
-  for (const root of roots) {
-    const resolved = resolve(root)
-    const canonical = await realpath(resolved).catch(() => null)
-    const key = canonical ?? resolved
-    if (seen.has(key)) continue
-    seen.add(key)
-    unique.push(key)
-  }
-  return unique
-}
-
-export async function selectToUpload(
-  candidates: Candidate[],
-  params: { allowPrompt: boolean; all: boolean; bump: 'patch' | 'minor' | 'major' },
-): Promise<Candidate[]> {
-  if (params.all || !params.allowPrompt) return candidates
-
-  const valueByKey = new Map<string, Candidate>()
-  const choices = candidates.map((candidate) => {
-    const key = candidate.folder
-    valueByKey.set(key, candidate)
-    return {
-      value: key,
-      label: `${candidate.slug}  ${formatActionableStatus(candidate, params.bump)}`,
-      hint: `${abbreviatePath(candidate.folder)} | ${candidate.fileCount} files`,
-    }
-  })
-
-  const picked = await multiselect({
-    message: 'Select skills to upload',
-    options: choices,
-    initialValues: choices.map((choice) => choice.value),
-    required: false,
-  })
-  if (isCancel(picked)) fail('Canceled')
-  const selected = picked.map((key) => valueByKey.get(String(key))).filter(Boolean) as Candidate[]
-  return selected
-}
-
-export async function resolvePublishMeta(
-  skill: Candidate,
-  params: { bump: 'patch' | 'minor' | 'major'; allowPrompt: boolean; changelogFlag?: string },
-) {
-  if (skill.status === 'new') {
-    return { publishVersion: '1.0.0', changelog: '' }
-  }
-
-  const latest = skill.latestVersion
-  if (!latest) fail(`Could not resolve latest version for ${skill.slug}`)
-  const publishVersion = semver.inc(latest, params.bump)
-  if (!publishVersion) fail(`Could not bump version for ${skill.slug}`)
-
-  const fromFlag = params.changelogFlag?.trim()
-  if (fromFlag) return { publishVersion, changelog: fromFlag }
-
-  return { publishVersion, changelog: '' }
-}
-
-export async function getRegistryWithAuth(opts: GlobalOpts, token: string) {
-  const registry = await getRegistry(opts, { cache: true })
-  await apiRequest(
-    registry,
-    { method: 'GET', path: ApiRoutes.whoami, token },
-    ApiV1WhoamiResponseSchema,
-  )
-  return registry
-}
-
-export function formatList(values: string[], max: number) {
-  if (values.length === 0) return ''
-  const shown = values.map(abbreviatePath)
-  if (shown.length <= max) return shown.join('\n')
-  const head = shown.slice(0, Math.max(1, max - 1))
-  const rest = values.length - head.length
-  return [...head, `… +${rest} more`].join('\n')
-}
-
-export function printSection(title: string, body?: string) {
-  const trimmed = body?.trim()
-  if (!trimmed) {
-    console.log(title)
-    return
-  }
-  if (trimmed.includes('\n')) {
-    console.log(`\n${title}\n${trimmed}`)
-    return
-  }
-  console.log(`${title}: ${trimmed}`)
-}
-
-function abbreviatePath(value: string) {
-  const home = homedir()
-  if (value.startsWith(home)) return `~${value.slice(home.length)}`
-  return value
-}
-
-function rootTelemetryId(value: string) {
-  return createHash('sha256').update(value).digest('hex')
-}
-
-function formatRootLabel(value: string) {
-  const home = homedir()
-  if (value === home) return '~'
-
-  const normalized = value.replaceAll('\\', '/')
-  const normalizedHome = home.replaceAll('\\', '/')
-  const isHome = normalized === normalizedHome || normalized.startsWith(`${normalizedHome}/`)
-
-  const stripped = isHome ? normalized.slice(normalizedHome.length).replace(/^\//, '') : normalized
-  const parts = stripped.split('/').filter(Boolean)
-  const tail = parts.slice(-2).join('/')
-
-  if (!tail) return isHome ? '~' : '…'
-  return isHome ? `~/${tail}` : `…/${tail}`
-}
-
-export function dedupeSkillsBySlug(skills: SkillFolder[]) {
-  const bySlug = new Map<string, SkillFolder[]>()
-  for (const skill of skills) {
-    const existing = bySlug.get(skill.slug)
-    if (existing) existing.push(skill)
-    else bySlug.set(skill.slug, [skill])
-  }
-  const unique: SkillFolder[] = []
-  const duplicates: string[] = []
-  for (const [slug, entries] of bySlug.entries()) {
-    unique.push(entries[0] as SkillFolder)
-    if (entries.length > 1) duplicates.push(`${slug} (${entries.length})`)
-  }
-  return { skills: unique, duplicates }
-}
-
-export function formatActionableStatus(
-  candidate: Candidate,
-  bump: 'patch' | 'minor' | 'major',
-): string {
-  if (candidate.status === 'new') return 'NEW'
-  const latest = candidate.latestVersion
-  const next = latest ? semver.inc(latest, bump) : null
-  if (latest && next) return `UPDATE ${latest} → ${next}`
-  return 'UPDATE'
-}
-
-export function formatActionableLine(
-  candidate: Candidate,
-  bump: 'patch' | 'minor' | 'major',
-): string {
-  return `${candidate.slug}  ${formatActionableStatus(candidate, bump)}  (${candidate.fileCount} files)`
-}
-
-function formatSyncedLine(candidate: Candidate): string {
-  const version = candidate.matchVersion ?? candidate.latestVersion ?? 'unknown'
-  return `${candidate.slug}  synced (${version})`
-}
-
-export function formatSyncedSummary(candidate: Candidate): string {
-  const version = candidate.matchVersion ?? candidate.latestVersion
-  return version ? `${candidate.slug}@${version}` : candidate.slug
-}
-
-export function formatBulletList(lines: string[], max: number): string {
-  if (lines.length <= max) return lines.map((line) => `- ${line}`).join('\n')
-  const head = lines.slice(0, max)
-  const rest = lines.length - head.length
-  return [...head, `... +${rest} more`].map((line) => `- ${line}`).join('\n')
-}
-
-export function formatSyncedDisplay(synced: Candidate[]) {
-  const lines = synced.map(formatSyncedLine)
-  if (lines.length <= 12) return formatBulletList(lines, 12)
-  return formatCommaList(synced.map(formatSyncedSummary), 24)
-}
-
-export function formatCommaList(values: string[], max: number) {
-  if (values.length === 0) return ''
-  if (values.length <= max) return values.join(', ')
-  const head = values.slice(0, Math.max(1, max - 1))
-  const rest = values.length - head.length
-  return `${head.join(', ')}, ... +${rest} more`
-}

package/packages/pilothub/src/cli/commands/syncTypes.ts

@@ -1,27 +0,0 @@
-import type { SkillOrigin } from '../../skills.js'
-import type { SkillFolder } from '../scanSkills.js'
-
-export type SyncOptions = {
-  root?: string[]
-  all?: boolean
-  dryRun?: boolean
-  bump?: 'patch' | 'minor' | 'major'
-  changelog?: string
-  tags?: string
-  concurrency?: number
-}
-
-export type Candidate = SkillFolder & {
-  fingerprint: string
-  fileCount: number
-  origin: SkillOrigin | null
-  status: 'synced' | 'new' | 'update'
-  matchVersion: string | null
-  latestVersion: string | null
-}
-
-export type LocalSkill = SkillFolder & {
-  fingerprint: string
-  fileCount: number
-  origin: SkillOrigin | null
-}

package/packages/pilothub/src/cli/commands/unstar.ts

@@ -1,48 +0,0 @@
-import { readGlobalConfig } from '../../config.js'
-import { apiRequest } from '../../http.js'
-import { ApiRoutes, ApiV1UnstarResponseSchema } from '../../schema/index.js'
-import { getRegistry } from '../registry.js'
-import type { GlobalOpts } from '../types.js'
-import { createSpinner, fail, formatError, isInteractive, promptConfirm } from '../ui.js'
-
-async function requireToken() {
-  const cfg = await readGlobalConfig()
-  const token = cfg?.token
-  if (!token) fail('Not logged in. Run: pilothub login')
-  return token
-}
-
-export async function cmdUnstarSkill(
-  opts: GlobalOpts,
-  slugArg: string,
-  options: { yes?: boolean },
-  inputAllowed: boolean,
-) {
-  const slug = slugArg.trim().toLowerCase()
-  if (!slug) fail('Slug required')
-  const allowPrompt = isInteractive() && inputAllowed !== false
-
-  if (!options.yes) {
-    if (!allowPrompt) fail('Pass --yes (no input)')
-    const ok = await promptConfirm(`Unstar ${slug}?`)
-    if (!ok) return
-  }
-
-  const token = await requireToken()
-  const registry = await getRegistry(opts, { cache: true })
-  const spinner = createSpinner(`Unstarring ${slug}`)
-  try {
-    const result = await apiRequest(
-      registry,
-      { method: 'DELETE', path: `${ApiRoutes.stars}/${encodeURIComponent(slug)}`, token },
-      ApiV1UnstarResponseSchema,
-    )
-    spinner.succeed(
-      result.alreadyUnstarred ? `OK. ${slug} already unstarred.` : `OK. Unstarred ${slug}`,
-    )
-    return result
-  } catch (error) {
-    spinner.fail(formatError(error))
-    throw error
-  }
-}

package/packages/pilothub/src/cli/helpStyle.ts

@@ -1,45 +0,0 @@
-type Color = (value: string) => string
-
-function wrap(start: string, end = '\x1b[0m'): Color {
-  return (value) => `${start}${value}${end}`
-}
-
-const ansi = {
-  reset: '\x1b[0m',
-  bold: wrap('\x1b[1m'),
-  dim: wrap('\x1b[2m'),
-  cyan: wrap('\x1b[36m'),
-  green: wrap('\x1b[32m'),
-  yellow: wrap('\x1b[33m'),
-}
-
-function isColorEnabled() {
-  if (!process.stdout.isTTY) return false
-  if (process.env.NO_COLOR) return false
-  return true
-}
-
-export function styleTitle(value: string) {
-  if (!isColorEnabled()) return value
-  return `${ansi.bold(ansi.cyan(value))}${ansi.reset}`
-}
-
-export function configureCommanderHelp(program: {
-  configureHelp: (config: {
-    sectionTitle?: (title: string) => string
-    optionTerm?: (option: { flags: string }) => string
-    commandTerm?: (cmd: { name: () => string }) => string
-  }) => unknown
-}) {
-  if (!isColorEnabled()) return
-  program.configureHelp({
-    sectionTitle: (title) => ansi.bold(ansi.cyan(title)),
-    optionTerm: (option) => ansi.yellow(option.flags),
-    commandTerm: (cmd) => ansi.green(cmd.name()),
-  })
-}
-
-export function styleEnvBlock(value: string) {
-  if (!isColorEnabled()) return value
-  return `${ansi.dim(value)}${ansi.reset}`
-}

package/packages/pilothub/src/cli/pilotbotConfig.test.ts

@@ -1,159 +0,0 @@
-/* @vitest-environment node */
-import { mkdir, mkdtemp, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join, resolve } from 'node:path'
-import { afterEach, describe, expect, it } from 'vitest'
-import { resolvePilotbotDefaultWorkspace, resolvePilotbotSkillRoots } from './pilotbotConfig.js'
-
-const originalEnv = { ...process.env }
-
-afterEach(() => {
-  process.env = { ...originalEnv }
-})
-
-describe('resolvePilotbotSkillRoots', () => {
-  it('reads JSON5 config and resolves per-agent + shared skill roots', async () => {
-    const base = await mkdtemp(join(tmpdir(), 'pilothub-pilotbot-'))
-    const home = join(base, 'home')
-    const stateDir = join(base, 'state')
-    const configPath = join(base, 'pilotbot.json')
-
-    process.env.HOME = home
-    process.env.PILOTBOT_STATE_DIR = stateDir
-    process.env.PILOTBOT_CONFIG_PATH = configPath
-
-    const config = `{
-      // JSON5 comments + trailing commas supported
-      agents: {
-        defaults: { workspace: '~/pilot-main', },
-        list: [
-          { id: 'work', name: 'Work Bot', workspace: '~/pilot-work', },
-          { id: 'family', workspace: '~/pilot-family', },
-        ],
-      },
-      // legacy entries still supported
-      agent: { workspace: '~/pilot-legacy', },
-      routing: {
-        agents: {
-          work: { name: 'Work Bot', workspace: '~/pilot-work', },
-          family: { workspace: '~/pilot-family' },
-        },
-      },
-      skills: {
-        load: { extraDirs: ['~/shared/skills', '/opt/skills',], },
-      },
-    }`
-    await writeFile(configPath, config, 'utf8')
-
-    const { roots, labels } = await resolvePilotbotSkillRoots()
-
-    const expectedRoots = [
-      resolve(stateDir, 'skills'),
-      resolve(home, 'pilot-main', 'skills'),
-      resolve(home, 'pilot-work', 'skills'),
-      resolve(home, 'pilot-family', 'skills'),
-      resolve(home, 'shared', 'skills'),
-      resolve('/opt/skills'),
-    ]
-
-    expect(roots).toEqual(expect.arrayContaining(expectedRoots))
-    expect(labels[resolve(stateDir, 'skills')]).toBe('Shared skills')
-    expect(labels[resolve(home, 'pilot-main', 'skills')]).toBe('Agent: main')
-    expect(labels[resolve(home, 'pilot-work', 'skills')]).toBe('Agent: Work Bot')
-    expect(labels[resolve(home, 'pilot-family', 'skills')]).toBe('Agent: family')
-    expect(labels[resolve(home, 'shared', 'skills')]).toBe('Extra: skills')
-    expect(labels[resolve('/opt/skills')]).toBe('Extra: skills')
-  })
-
-  it('resolves default workspace from agents.defaults and agents.list', async () => {
-    const base = await mkdtemp(join(tmpdir(), 'pilothub-pilotbot-default-'))
-    const home = join(base, 'home')
-    const stateDir = join(base, 'state')
-    const configPath = join(base, 'pilotbot.json')
-    const workspaceMain = join(base, 'workspace-main')
-    const workspaceList = join(base, 'workspace-list')
-
-    process.env.HOME = home
-    process.env.PILOTBOT_STATE_DIR = stateDir
-    process.env.PILOTBOT_CONFIG_PATH = configPath
-
-    const config = `{
-      agents: {
-        defaults: { workspace: "${workspaceMain}", },
-        list: [
-          { id: 'main', workspace: "${workspaceList}", default: true },
-        ],
-      },
-    }`
-    await writeFile(configPath, config, 'utf8')
-
-    const workspace = await resolvePilotbotDefaultWorkspace()
-    expect(workspace).toBe(resolve(workspaceMain))
-  })
-
-  it('falls back to default agent in agents.list when defaults missing', async () => {
-    const base = await mkdtemp(join(tmpdir(), 'pilothub-pilotbot-list-'))
-    const home = join(base, 'home')
-    const configPath = join(base, 'pilotbot.json')
-    const workspaceMain = join(base, 'workspace-main')
-    const workspaceWork = join(base, 'workspace-work')
-
-    process.env.HOME = home
-    process.env.PILOTBOT_CONFIG_PATH = configPath
-
-    const config = `{
-      agents: {
-        list: [
-          { id: 'main', workspace: "${workspaceMain}", default: true },
-          { id: 'work', workspace: "${workspaceWork}" },
-        ],
-      },
-    }`
-    await writeFile(configPath, config, 'utf8')
-
-    const workspace = await resolvePilotbotDefaultWorkspace()
-    expect(workspace).toBe(resolve(workspaceMain))
-  })
-
-  it('respects PILOTBOT_STATE_DIR and PILOTBOT_CONFIG_PATH overrides', async () => {
-    const base = await mkdtemp(join(tmpdir(), 'pilothub-pilotbot-override-'))
-    const home = join(base, 'home')
-    const stateDir = join(base, 'custom-state')
-    const configPath = join(base, 'config', 'pilotbot.json')
-
-    process.env.HOME = home
-    process.env.PILOTBOT_STATE_DIR = stateDir
-    process.env.PILOTBOT_CONFIG_PATH = configPath
-
-    const config = `{
-      agent: { workspace: "${join(base, 'workspace-main')}" },
-    }`
-    await mkdir(join(base, 'config'), { recursive: true })
-    await writeFile(configPath, config, 'utf8')
-
-    const { roots, labels } = await resolvePilotbotSkillRoots()
-
-    expect(roots).toEqual(
-      expect.arrayContaining([
-        resolve(stateDir, 'skills'),
-        resolve(join(base, 'workspace-main'), 'skills'),
-      ]),
-    )
-    expect(labels[resolve(stateDir, 'skills')]).toBe('Shared skills')
-    expect(labels[resolve(join(base, 'workspace-main'), 'skills')]).toBe('Agent: main')
-  })
-
-  it('returns shared skills root when config is missing', async () => {
-    const base = await mkdtemp(join(tmpdir(), 'pilothub-pilotbot-missing-'))
-    const stateDir = join(base, 'state')
-    const configPath = join(base, 'missing', 'pilotbot.json')
-
-    process.env.PILOTBOT_STATE_DIR = stateDir
-    process.env.PILOTBOT_CONFIG_PATH = configPath
-
-    const { roots, labels } = await resolvePilotbotSkillRoots()
-
-    expect(roots).toEqual([resolve(stateDir, 'skills')])
-    expect(labels[resolve(stateDir, 'skills')]).toBe('Shared skills')
-  })
-})