pilothub 0.0.1

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

@@ -0,0 +1,427 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,159 @@
+/* @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')
+  })
+})