@inspecto-dev/cli 0.3.1 → 0.3.2

package/src/commands/integration-host-ide.ts

@@ -0,0 +1,156 @@
+import path from 'node:path'
+import { exists, readJSON } from '../utils/fs.js'
+import {
+  HOST_IDE_IDS,
+  getHostIdeArtifactPath,
+  isSupportedHostIde,
+  type SupportedHostIde,
+} from '../integrations/capabilities.js'
+export type HostIdeConfidence = 'high' | 'medium' | 'low'
+export type HostIdeSource = 'explicit' | 'config' | 'env' | 'artifact' | 'ambiguous' | 'none'
+
+export interface ResolveIntegrationHostIdeOptions {
+  explicitIde?: string
+  cwd?: string
+}
+
+export interface ResolvedIntegrationHostIde {
+  ide: SupportedHostIde | null
+  confidence: HostIdeConfidence
+  source: HostIdeSource
+  candidates: SupportedHostIde[]
+}
+
+interface InspectoSettingsShape {
+  ide?: string
+}
+
+export async function resolveIntegrationHostIde(
+  options: ResolveIntegrationHostIdeOptions = {},
+): Promise<ResolvedIntegrationHostIde> {
+  if (isSupportedHostIde(options.explicitIde)) {
+    return {
+      ide: options.explicitIde,
+      confidence: 'high',
+      source: 'explicit',
+      candidates: [options.explicitIde],
+    }
+  }
+
+  const cwd = options.cwd ?? process.cwd()
+  const configuredIde = await resolveConfiguredIde(cwd)
+  if (configuredIde) {
+    return {
+      ide: configuredIde,
+      confidence: 'high',
+      source: 'config',
+      candidates: [configuredIde],
+    }
+  }
+
+  const envCandidates = detectEnvHostIdes()
+  if (envCandidates.length === 1) {
+    return {
+      ide: envCandidates[0],
+      confidence: 'high',
+      source: 'env',
+      candidates: envCandidates,
+    }
+  }
+
+  if (envCandidates.length > 1) {
+    return {
+      ide: null,
+      confidence: 'low',
+      source: 'ambiguous',
+      candidates: envCandidates,
+    }
+  }
+
+  const artifactCandidates = await detectArtifactHostIdes(cwd)
+  if (artifactCandidates.length === 1) {
+    return {
+      ide: artifactCandidates[0],
+      confidence: 'medium',
+      source: 'artifact',
+      candidates: artifactCandidates,
+    }
+  }
+
+  if (artifactCandidates.length > 1) {
+    return {
+      ide: null,
+      confidence: 'low',
+      source: 'ambiguous',
+      candidates: artifactCandidates,
+    }
+  }
+
+  return {
+    ide: null,
+    confidence: 'low',
+    source: 'none',
+    candidates: [],
+  }
+}
+
+async function resolveConfiguredIde(cwd: string): Promise<SupportedHostIde | null> {
+  const settingsPaths = [
+    path.join(cwd, '.inspecto', 'settings.local.json'),
+    path.join(cwd, '.inspecto', 'settings.json'),
+  ]
+
+  for (const settingsPath of settingsPaths) {
+    const settings = await readJSON<InspectoSettingsShape>(settingsPath)
+    if (settings && isSupportedHostIde(settings.ide)) {
+      return settings.ide
+    }
+  }
+
+  return null
+}
+
+function detectEnvHostIdes(): SupportedHostIde[] {
+  const detected = new Set<SupportedHostIde>()
+
+  if (process.env.CURSOR_TRACE_DIR || process.env.CURSOR_CHANNEL) {
+    detected.add('cursor')
+  }
+
+  if (
+    process.env.TRAE_APP_DIR ||
+    process.env.__CFBundleIdentifier === 'com.byteocean.trae' ||
+    process.env.COCO_IDE_PLUGIN_TYPE === 'Trae' ||
+    (process.env.npm_config_user_agent && process.env.npm_config_user_agent.includes('trae'))
+  ) {
+    detected.add('trae')
+  }
+
+  if (
+    process.env.__CFBundleIdentifier === 'com.byteocean.trae.cn' ||
+    process.env.COCO_IDE_PLUGIN_TYPE === 'TraeCN' ||
+    (process.env.npm_config_user_agent && process.env.npm_config_user_agent.includes('trae-cn'))
+  ) {
+    detected.add('trae-cn')
+  }
+
+  if (detected.size === 0 && process.env.TERM_PROGRAM === 'vscode') {
+    detected.add('vscode')
+  }
+
+  return Array.from(detected)
+}
+
+async function detectArtifactHostIdes(cwd: string): Promise<SupportedHostIde[]> {
+  const artifactOrder: SupportedHostIde[] = ['cursor', 'trae', 'trae-cn', 'vscode']
+  const candidates = artifactOrder.map(ide => ({
+    ide,
+    target: getHostIdeArtifactPath(ide, cwd),
+  }))
+
+  const resolved = await Promise.all(
+    candidates.map(async candidate => ((await exists(candidate.target)) ? candidate.ide : null)),
+  )
+
+  return resolved.filter((value): value is SupportedHostIde => value !== null)
+}

package/src/commands/integration-install.ts

@@ -4,13 +4,16 @@ import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { exists, writeFile } from '../utils/fs.js'
 import { log } from '../utils/logger.js'
+import { writeCommandOutput } from '../utils/output.js'
+import { runIntegrationAutomation } from './integration-automation.js'
 
 const REPO_RAW_BASE = 'https://raw.githubusercontent.com/inspecto-dev/inspecto/main'
+const TOTAL_STEPS = 6
 
 type AssistantId = 'codex' | 'claude-code' | 'copilot' | 'cursor' | 'gemini' | 'trae' | 'coco'
 type ClaudeScope = 'project' | 'user'
-type CopilotMode = 'instructions' | 'agents'
-type CursorMode = 'rules' | 'agents'
+type CopilotMode = 'skills' | 'instructions' | 'agents'
+type CursorMode = 'skills' | 'rules' | 'agents'
 
 interface DownloadAsset {
   source: string
@@ -21,12 +24,7 @@ interface DownloadAsset {
 
 export interface IntegrationManifest {
   assistant: string
-  type:
-    | 'native-skill'
-    | 'instruction-template'
-    | 'rule-template'
-    | 'context-template'
-    | 'compatibility-template'
+  type: 'native-skill' | 'context-template'
   installTarget: string
   preferredInstall: string
   cliSupported: boolean
@@ -44,6 +42,11 @@ export interface InstallIntegrationOptions {
   scope?: ClaudeScope
   mode?: CopilotMode | CursorMode
   force?: boolean
+  ide?: string
+  inspectoVsix?: string
+  compact?: boolean
+  preview?: boolean
+  json?: boolean
 }
 
 interface InstallPlan {
@@ -52,54 +55,71 @@ interface InstallPlan {
   nextStep: string
 }
 
+export interface IntegrationInstallResult {
+  status: 'launched' | 'partial' | 'blocked' | 'preview' | 'preview_blocked'
+  assistant: string
+  preview: boolean
+  assets: string[]
+  message: string
+  nextStep?: string
+  automation: Awaited<ReturnType<typeof runIntegrationAutomation>>
+}
+
 const INTEGRATION_MANIFESTS: IntegrationManifest[] = [
   {
     assistant: 'codex',
     type: 'native-skill',
-    installTarget: '~/.codex/skills/',
-    preferredInstall: 'npx @inspecto-dev/cli integrations install codex',
+    installTarget: '.agents/skills/',
+    preferredInstall:
+      'npx @inspecto-dev/cli integrations install codex --host-ide <vscode|cursor|trae|trae-cn>',
     cliSupported: true,
   },
   {
     assistant: 'claude-code',
     type: 'native-skill',
     installTarget: '.claude/skills/ or ~/.claude/skills/',
-    preferredInstall: 'npx @inspecto-dev/cli integrations install claude-code --scope project',
+    preferredInstall:
+      'npx @inspecto-dev/cli integrations install claude-code --scope project --host-ide <vscode|cursor|trae|trae-cn>',
     cliSupported: true,
   },
   {
     assistant: 'copilot',
-    type: 'instruction-template',
-    installTarget: '.github/copilot-instructions.md or AGENTS.md',
-    preferredInstall: 'npx @inspecto-dev/cli integrations install copilot',
+    type: 'native-skill',
+    installTarget: '.github/skills/inspecto-onboarding/',
+    preferredInstall:
+      'npx @inspecto-dev/cli integrations install copilot --host-ide <vscode|cursor|trae|trae-cn>',
     cliSupported: true,
   },
   {
     assistant: 'cursor',
-    type: 'rule-template',
-    installTarget: '.cursor/rules/inspecto-onboarding.mdc or AGENTS.md',
-    preferredInstall: 'npx @inspecto-dev/cli integrations install cursor --mode rules',
+    type: 'native-skill',
+    installTarget: '.cursor/skills/inspecto-onboarding/',
+    preferredInstall:
+      'npx @inspecto-dev/cli integrations install cursor --host-ide <vscode|cursor|trae|trae-cn>',
     cliSupported: true,
   },
   {
     assistant: 'gemini',
-    type: 'context-template',
-    installTarget: 'GEMINI.md',
-    preferredInstall: 'npx @inspecto-dev/cli integrations install gemini',
+    type: 'native-skill',
+    installTarget: '.gemini/skills/inspecto-onboarding/',
+    preferredInstall:
+      'npx @inspecto-dev/cli integrations install gemini --host-ide <vscode|cursor|trae|trae-cn>',
     cliSupported: true,
   },
   {
     assistant: 'trae',
-    type: 'compatibility-template',
-    installTarget: 'AGENTS.md',
-    preferredInstall: 'npx @inspecto-dev/cli integrations install trae',
+    type: 'native-skill',
+    installTarget: '.trae/skills/inspecto-onboarding/',
+    preferredInstall:
+      'npx @inspecto-dev/cli integrations install trae --host-ide <vscode|cursor|trae|trae-cn>',
     cliSupported: true,
   },
   {
     assistant: 'coco',
-    type: 'compatibility-template',
-    installTarget: 'AGENTS.md',
-    preferredInstall: 'npx @inspecto-dev/cli integrations install coco',
+    type: 'native-skill',
+    installTarget: '.traecli/skills/inspecto-onboarding/',
+    preferredInstall:
+      'npx @inspecto-dev/cli integrations install coco --host-ide <vscode|cursor|trae|trae-cn>',
     cliSupported: true,
   },
 ]
@@ -107,36 +127,173 @@ const INTEGRATION_MANIFESTS: IntegrationManifest[] = [
 export async function installIntegration(
   assistant: string,
   options: InstallIntegrationOptions = {},
-): Promise<void> {
+): Promise<IntegrationInstallResult> {
   const plan = resolveInstallPlan(assistant, options)
+  const manifest = getIntegrationManifest(assistant)
+  const silent = options.json ?? false
 
-  log.header('Inspecto Integration Install')
+  if (!silent) {
+    log.header('Inspecto Integration Install')
+  }
+
+  if (!options.preview) {
+    // Check for existing files
+    const existingFiles = new Map<string, string>()
+    for (const asset of plan.assets) {
+      if (await exists(asset.target)) {
+        if (options.force) {
+          // Will overwrite later
+        } else if (manifest.type === 'context-template') {
+          // Safe to append for templates and markdown files
+          const originalContent = await fs.readFile(asset.target, 'utf-8')
+          existingFiles.set(asset.target, originalContent)
+          if (!silent) {
+            log.info(`File ${asset.target} already exists. Content will be appended safely.`)
+          }
+        } else {
+          // Native skills (like codex, claude-code) shouldn't be blindly appended to
+          throw new Error(
+            `Refusing to overwrite existing file: ${asset.target}. Re-run with --force if you want to replace it.`,
+          )
+        }
+      }
+    }
+
+    const downloadedAssets = [] as Array<{ asset: DownloadAsset; content: string }>
+
+    for (const asset of plan.assets) {
+      let content = await loadAsset(asset)
+
+      // Handle appending if needed
+      if (existingFiles.has(asset.target)) {
+        const existingContent = existingFiles.get(asset.target)!
+        if (
+          !existingContent.includes('Inspecto Onboarding') &&
+          !existingContent.includes('inspecto-onboarding')
+        ) {
+          content = `${existingContent}\n\n---\n\n${content}`
+        } else {
+          if (!silent) {
+            log.info(
+              `Skipping ${asset.target} as it seems to already contain Inspecto rules. Use --force to overwrite.`,
+            )
+          }
+          continue // Skip this asset
+        }
+      }
+
+      downloadedAssets.push({ asset, content })
+    }
+
+    for (const { asset, content } of downloadedAssets) {
+      await writeFile(asset.target, content)
+
+      if (asset.executable) {
+        await fs.chmod(asset.target, 0o755)
+      }
+    }
+  }
+
+  const stepOneMessage = options.preview
+    ? formatIntegrationStep(1, `Previewing ${getAssistantLabel(assistant)} integration assets`)
+    : formatIntegrationStep(1, `Installed ${getAssistantLabel(assistant)} integration assets`)
+
+  if (!silent) {
+    if (options.preview) {
+      log.info(stepOneMessage)
+    } else {
+      log.success(stepOneMessage)
+    }
+    for (const asset of plan.assets) {
+      log.hint(asset.target)
+    }
+    if (!options.preview) {
+      log.hint(plan.nextStep)
+    }
+  }
+
+  if (shouldSkipAutomationForInstall(options)) {
+    const message = `Installed ${getAssistantLabel(assistant)} integration assets. User-level installs only write integration assets and do not launch onboarding automatically.`
+    const nextStep = options.ide
+      ? `Run the install command again from your target project root with --host-ide ${options.ide} when you want to launch onboarding automatically.`
+      : 'Run the install command again from your target project root with --host-ide <vscode|cursor|trae|trae-cn> when you want to launch onboarding automatically.'
+    const result: IntegrationInstallResult = {
+      status: 'partial',
+      assistant,
+      preview: options.preview ?? false,
+      assets: plan.assets.map(asset => asset.target),
+      message,
+      nextStep,
+      automation: {
+        status: 'blocked',
+        message,
+        nextStep,
+      },
+    }
+
+    if (options.json) {
+      return writeCommandOutput(result, true, () => {})
+    }
 
-  for (const asset of plan.assets) {
-    if ((await exists(asset.target)) && !options.force) {
-      throw new Error(
-        `Refusing to overwrite existing file: ${asset.target}. Re-run with --force if you want to replace it.`,
+    log.ready(message)
+    if (options.ide) {
+      log.hint(
+        `The provided --host-ide value is saved only as a rerun hint for later; this command does not open ${formatHostIdeLabel(options.ide)} for user-level installs.`,
       )
     }
+    log.hint(nextStep)
+    return result
   }
 
-  const downloadedAssets = [] as Array<{ asset: DownloadAsset; content: string }>
+  const automationResult = await runIntegrationAutomation(
+    assistant,
+    { ...options, silent },
+    process.cwd(),
+  )
+  const result: IntegrationInstallResult = {
+    status: automationResult.status,
+    assistant,
+    preview: options.preview ?? false,
+    assets: plan.assets.map(asset => asset.target),
+    message: automationResult.message,
+    ...(automationResult.nextStep ? { nextStep: automationResult.nextStep } : {}),
+    automation: automationResult,
+  }
+
+  if (options.json) {
+    return writeCommandOutput(result, true, () => {})
+  }
 
-  for (const asset of plan.assets) {
-    const content = await loadAsset(asset)
-    downloadedAssets.push({ asset, content })
+  if (automationResult.status === 'launched') {
+    log.ready(automationResult.message)
+    return result
   }
 
-  for (const { asset, content } of downloadedAssets) {
-    await writeFile(asset.target, content)
+  if (automationResult.status === 'preview') {
+    log.ready(automationResult.message)
+    if (automationResult.nextStep) {
+      log.hint(automationResult.nextStep)
+    }
+    return result
+  }
 
-    if (asset.executable) {
-      await fs.chmod(asset.target, 0o755)
+  if (automationResult.status === 'partial' || automationResult.status === 'preview_blocked') {
+    log.warn(automationResult.message)
+    if (automationResult.nextStep) {
+      log.hint(automationResult.nextStep)
     }
+    return result
   }
 
-  log.success(plan.successMessage)
-  log.hint(plan.nextStep)
+  log.warn(automationResult.message)
+  if (automationResult.nextStep) {
+    log.hint(automationResult.nextStep)
+  }
+  return result
+}
+
+function shouldSkipAutomationForInstall(options: InstallIntegrationOptions): boolean {
+  return options.scope === 'user' && !options.preview
 }
 
 export function listIntegrationManifests(): IntegrationManifest[] {
@@ -202,36 +359,36 @@ function resolveInstallPlan(assistant: string, options: InstallIntegrationOption
       return {
         assets: [
           {
-            source: `${REPO_RAW_BASE}/assistant-integrations/gemini/GEMINI.md`,
-            target: 'GEMINI.md',
-            localSource: 'assistant-integrations/gemini/GEMINI.md',
+            source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-gemini/SKILL.md`,
+            target: '.gemini/skills/inspecto-onboarding/SKILL.md',
+            localSource: 'skills/inspecto-onboarding-gemini/SKILL.md',
           },
         ],
-        successMessage: 'Installed Gemini context to GEMINI.md',
-        nextStep: 'Start a new Gemini CLI session.',
+        successMessage: 'Installed Gemini skill to .gemini/skills/inspecto-onboarding/SKILL.md',
+        nextStep: 'Start a new Gemini CLI session and use /skills list to verify.',
       }
     case 'trae':
       return {
         assets: [
           {
-            source: `${REPO_RAW_BASE}/assistant-integrations/trae/AGENTS.md`,
-            target: 'AGENTS.md',
-            localSource: 'assistant-integrations/trae/AGENTS.md',
+            source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-trae/SKILL.md`,
+            target: '.trae/skills/inspecto-onboarding/SKILL.md',
+            localSource: 'skills/inspecto-onboarding-trae/SKILL.md',
           },
         ],
-        successMessage: 'Installed Trae compatibility instructions to AGENTS.md',
-        nextStep: 'Open a new Trae chat.',
+        successMessage: 'Installed Trae skill to .trae/skills/inspecto-onboarding/SKILL.md',
+        nextStep: 'Open a new Trae chat and verify the inspecto-onboarding skill is available.',
       }
     case 'coco':
       return {
         assets: [
           {
-            source: `${REPO_RAW_BASE}/assistant-integrations/coco/AGENTS.md`,
-            target: 'AGENTS.md',
-            localSource: 'assistant-integrations/coco/AGENTS.md',
+            source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-trae/SKILL.md`,
+            target: '.traecli/skills/inspecto-onboarding/SKILL.md',
+            localSource: 'skills/inspecto-onboarding-trae/SKILL.md',
           },
         ],
-        successMessage: 'Installed Coco compatibility instructions to AGENTS.md',
+        successMessage: 'Installed Coco skill to .traecli/skills/inspecto-onboarding/SKILL.md',
         nextStep: 'Start a new Coco session.',
       }
     default:
@@ -251,16 +408,40 @@ function getIntegrationManifest(assistant: string): IntegrationManifest {
   return manifest
 }
 
+function formatIntegrationStep(step: number, text: string): string {
+  return `Step ${step}/${TOTAL_STEPS}: ${text}`
+}
+
+function getAssistantLabel(assistant: string): string {
+  if (assistant === 'claude-code') return 'Claude Code'
+  if (assistant === 'codex') return 'Codex'
+  if (assistant === 'copilot') return 'GitHub Copilot'
+  if (assistant === 'cursor') return 'Cursor'
+  if (assistant === 'gemini') return 'Gemini'
+  if (assistant === 'trae') return 'Trae'
+  if (assistant === 'coco') return 'Coco'
+  return assistant
+}
+
+function formatHostIdeLabel(ide: string): string {
+  if (ide === 'vscode') return 'VS Code'
+  if (ide === 'cursor') return 'Cursor'
+  if (ide === 'trae') return 'Trae'
+  if (ide === 'trae-cn') return 'Trae CN'
+  return ide
+}
+
 function resolveCodexPlan(options: InstallIntegrationOptions): InstallPlan {
-  if (options.scope !== undefined) {
-    throw new Error('`--scope` is not supported for codex.')
-  }
+  const scope = options.scope ?? 'project'
 
   if (options.mode !== undefined) {
     throw new Error('`--mode` is not supported for codex.')
   }
 
-  const baseDir = path.join(homedir(), '.codex/skills/inspecto-onboarding-codex')
+  const baseDir =
+    scope === 'user'
+      ? path.join(homedir(), '.agents/skills/inspecto-onboarding-codex')
+      : '.agents/skills/inspecto-onboarding-codex'
 
   return {
     assets: [
@@ -330,37 +511,27 @@ function resolveClaudeCodePlan(options: InstallIntegrationOptions): InstallPlan
 }
 
 function resolveCopilotPlan(options: InstallIntegrationOptions): InstallPlan {
-  const mode = options.mode ?? 'instructions'
+  const mode = options.mode ?? 'skills'
 
   if (options.scope !== undefined) {
     throw new Error(
-      '`--scope` is not supported for copilot. Use `--mode instructions|agents` instead.',
+      '`--scope` is not supported for copilot. Use `--mode skills|instructions|agents` instead.',
     )
   }
 
   switch (mode) {
-    case 'instructions':
-      return {
-        assets: [
-          {
-            source: `${REPO_RAW_BASE}/assistant-integrations/copilot/.github/copilot-instructions.md`,
-            target: '.github/copilot-instructions.md',
-            localSource: 'assistant-integrations/copilot/.github/copilot-instructions.md',
-          },
-        ],
-        successMessage: 'Installed Copilot instructions to .github/copilot-instructions.md',
-        nextStep: 'Open a new Copilot chat or agent session.',
-      }
-    case 'agents':
+    case 'skills':
+    case 'instructions': // Legacy fallback gracefully acts as skills mode now
+    case 'agents': // Legacy fallback gracefully acts as skills mode now
       return {
         assets: [
           {
-            source: `${REPO_RAW_BASE}/assistant-integrations/copilot/AGENTS.md`,
-            target: 'AGENTS.md',
-            localSource: 'assistant-integrations/copilot/AGENTS.md',
+            source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-copilot/SKILL.md`,
+            target: '.github/skills/inspecto-onboarding/SKILL.md',
+            localSource: 'skills/inspecto-onboarding-copilot/SKILL.md',
           },
         ],
-        successMessage: 'Installed Copilot compatibility instructions to AGENTS.md',
+        successMessage: 'Installed Copilot skill to .github/skills/inspecto-onboarding/SKILL.md',
         nextStep: 'Open a new Copilot chat or agent session.',
       }
     default:
@@ -369,35 +540,25 @@ function resolveCopilotPlan(options: InstallIntegrationOptions): InstallPlan {
 }
 
 function resolveCursorPlan(options: InstallIntegrationOptions): InstallPlan {
-  const mode = options.mode ?? 'rules'
+  const mode = options.mode ?? 'skills'
 
   if (options.scope !== undefined) {
-    throw new Error('`--scope` is not supported for cursor. Use `--mode rules|agents` instead.')
+    throw new Error('`--scope` is not supported for cursor. Use `--mode skills|agents` instead.')
   }
 
   switch (mode) {
-    case 'rules':
-      return {
-        assets: [
-          {
-            source: `${REPO_RAW_BASE}/assistant-integrations/cursor/.cursor/rules/inspecto-onboarding.mdc`,
-            target: '.cursor/rules/inspecto-onboarding.mdc',
-            localSource: 'assistant-integrations/cursor/.cursor/rules/inspecto-onboarding.mdc',
-          },
-        ],
-        successMessage: 'Installed Cursor rule to .cursor/rules/inspecto-onboarding.mdc',
-        nextStep: 'Open a new Cursor chat.',
-      }
-    case 'agents':
+    case 'skills':
+    case 'rules': // Legacy fallback gracefully acts as skills mode now
+    case 'agents': // Legacy fallback gracefully acts as skills mode now
       return {
         assets: [
           {
-            source: `${REPO_RAW_BASE}/assistant-integrations/cursor/AGENTS.md`,
-            target: 'AGENTS.md',
-            localSource: 'assistant-integrations/cursor/AGENTS.md',
+            source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-cursor/SKILL.md`,
+            target: '.cursor/skills/inspecto-onboarding/SKILL.md',
+            localSource: 'skills/inspecto-onboarding-cursor/SKILL.md',
           },
         ],
-        successMessage: 'Installed Cursor compatibility instructions to AGENTS.md',
+        successMessage: 'Installed Cursor skill to .cursor/skills/inspecto-onboarding/SKILL.md',
         nextStep: 'Open a new Cursor chat.',
       }
     default:
@@ -441,9 +602,9 @@ async function downloadAsset(source: string): Promise<string> {
     response = await fetch(source)
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error)
-    throw new Error(`Failed to download ${source}: ${reason}`, {
-      cause: error,
-    })
+    const wrappedError = new Error(`Failed to download ${source}: ${reason}`)
+    ;(wrappedError as Error & { cause?: unknown }).cause = error
+    throw wrappedError
   }
 
   if (!response.ok) {