@inspecto-dev/cli 0.3.3 → 0.3.5

package/tests/plan.test.ts

@@ -14,7 +14,7 @@ describe('planner orchestration', () => {
     vi.resetAllMocks()
   })
 
-  it('blocks unsupported build stacks and returns a manual action', () => {
+  it('returns guided onboarding actions for Next.js projects', () => {
     const context: OnboardingContext = {
       root: '/repo',
       packageManager: 'pnpm',
@@ -32,28 +32,114 @@ describe('planner orchestration', () => {
 
     const result = planner.createPlanResult(context)
 
-    expect(result.status).toBe('blocked')
-    expect(result.strategy).toBe('manual')
-    expect(result.blockers).toEqual([
-      {
-        code: 'unsupported-build-tool',
-        message: 'Detected unsupported build tool(s): Next.js',
+    expect(result.status).toBe('warning')
+    expect(result.strategy).toBe('guided')
+    expect(result.blockers).toEqual([])
+    expect(result.framework).toBe('react')
+    expect(result.metaFramework).toBe('Next.js')
+    expect(result.autoApplied).toEqual(['dependencies', 'inspecto_settings'])
+    expect(result.pendingSteps).toEqual(
+      expect.arrayContaining([
+        expect.stringContaining('Review the generated Next.js patch plan'),
+        expect.stringContaining('Complete the remaining client-side mount step'),
+      ]),
+    )
+    expect(result.assistantPrompt).toContain('Complete the remaining Inspecto onboarding')
+    expect(result.actions).toEqual(
+      expect.arrayContaining([
+        {
+          type: 'install_dependency',
+          target: '@inspecto-dev/plugin @inspecto-dev/core',
+          description: 'Install the Inspecto runtime packages with pnpm.',
+        },
+        {
+          type: 'install_extension',
+          target: 'vscode',
+          description: 'Install the Inspecto VS Code extension.',
+        },
+        {
+          type: 'generate_patch_plan',
+          target: 'next.config',
+          description: 'Generate a guided patch plan for the Next.js Inspecto webpack integration.',
+        },
+        {
+          type: 'manual_confirmation',
+          target: '/repo',
+          description:
+            'Complete the remaining client-side Inspecto mount step in your assistant or editor.',
+        },
+      ]),
+    )
+  })
+
+  it('returns guided onboarding actions for Nuxt projects', () => {
+    const context: OnboardingContext = {
+      root: '/repo',
+      packageManager: 'pnpm',
+      buildTools: {
+        supported: [],
+        unsupported: ['Nuxt'],
       },
-    ])
-    expect(result.actions).toEqual([
-      {
-        type: 'manual_step',
-        target: 'Next.js',
-        description:
-          'Inspecto cannot auto-configure this build stack yet. Follow the manual setup guide for the detected framework or build tool.',
+      frameworks: {
+        supported: ['vue'],
+        unsupported: [],
       },
-    ])
-    expect(result.defaults).toEqual({
-      provider: 'codex',
-      ide: 'vscode',
-      shared: false,
-      extension: true,
-    })
+      ides: [{ ide: 'vscode', supported: true }],
+      providers: [{ id: 'codex', label: 'Codex CLI', supported: true, preferredMode: 'cli' }],
+    }
+
+    const result = planner.createPlanResult(context)
+
+    expect(result.status).toBe('warning')
+    expect(result.strategy).toBe('guided')
+    expect(result.blockers).toEqual([])
+    expect(result.framework).toBe('vue')
+    expect(result.metaFramework).toBe('Nuxt')
+    expect(result.pendingSteps).toEqual(
+      expect.arrayContaining([
+        expect.stringContaining('Review the generated Nuxt patch plan'),
+        expect.stringContaining('Complete the remaining Nuxt client plugin mount step'),
+      ]),
+    )
+    expect(result.actions).toEqual(
+      expect.arrayContaining([
+        {
+          type: 'generate_patch_plan',
+          target: 'nuxt.config',
+          description: 'Generate a guided patch plan for the Nuxt Inspecto Vite integration.',
+        },
+      ]),
+    )
+  })
+
+  it('keeps Next.js in guided mode when additional unsupported build tools are also detected', () => {
+    const context: OnboardingContext = {
+      root: '/repo',
+      packageManager: 'pnpm',
+      buildTools: {
+        supported: [],
+        unsupported: ['Next.js', 'CustomStack'],
+      },
+      frameworks: {
+        supported: ['react'],
+        unsupported: [],
+      },
+      ides: [{ ide: 'vscode', supported: true }],
+      providers: [{ id: 'codex', label: 'Codex CLI', supported: true, preferredMode: 'cli' }],
+    }
+
+    const result = planner.createPlanResult(context)
+
+    expect(result.strategy).toBe('guided')
+    expect(result.blockers).toEqual([])
+    expect(result.warnings).toEqual(
+      expect.arrayContaining([
+        {
+          code: 'additional-unsupported-build-tool',
+          message: 'Additional unsupported build tool also detected: CustomStack',
+        },
+      ]),
+    )
   })
 
   it('blocks mixed supported and unsupported build tools instead of taking the supported auto path', () => {
@@ -269,6 +355,182 @@ describe('planner orchestration', () => {
     ])
   })
 
+  it('returns a legacy rspack partial-manual strategy when the selected build target is legacy rspack', () => {
+    const context: OnboardingContext = {
+      root: '/repo/finder',
+      packageManager: 'pnpm',
+      buildTools: {
+        supported: [
+          {
+            tool: 'rspack',
+            configPath: 'finder/rspack-config/rspack.config.dev.ts',
+            label: 'Rspack (finder/rspack-config/rspack.config.dev.ts) [Legacy]',
+            packagePath: 'finder',
+            isLegacyRspack: true,
+          },
+        ],
+        unsupported: [],
+      },
+      frameworks: {
+        supported: ['react'],
+        unsupported: [],
+      },
+      ides: [{ ide: 'trae', supported: true }],
+      providers: [{ id: 'coco', label: 'Coco CLI', supported: true, preferredMode: 'cli' }],
+    }
+
+    const result = planner.createPlanResult(context)
+
+    expect(result.status).toBe('warning')
+    expect(result.strategy).toBe('manual')
+    expect(result.blockers).toEqual([])
+    expect(result.warnings).toEqual([
+      {
+        code: 'legacy-rspack-requires-manual-config',
+        message:
+          'Legacy Rspack detected at finder/rspack-config/rspack.config.dev.ts. Inspecto must use the legacy Rspack plugin entry and manual config steps.',
+      },
+    ])
+    expect(result.actions).toEqual([
+      {
+        type: 'install_dependency',
+        target: '@inspecto-dev/plugin @inspecto-dev/core',
+        description: 'Install the Inspecto runtime packages with pnpm.',
+      },
+      {
+        type: 'manual_step',
+        target: 'finder/rspack-config/rspack.config.dev.ts',
+        description:
+          'Update finder/rspack-config/rspack.config.dev.ts to import `rspackPlugin` from `@inspecto-dev/plugin/legacy/rspack` and add it to the Rspack plugins array.',
+      },
+    ])
+  })
+
+  it('plans Inspecto extension installation for Cursor by default', () => {
+    const context: OnboardingContext = {
+      root: '/repo',
+      packageManager: 'pnpm',
+      buildTools: {
+        supported: [
+          {
+            tool: 'vite',
+            configPath: 'vite.config.ts',
+            label: 'Vite (vite.config.ts)',
+          },
+        ],
+        unsupported: [],
+      },
+      frameworks: {
+        supported: ['react'],
+        unsupported: [],
+      },
+      ides: [{ ide: 'cursor', supported: true }],
+      providers: [{ id: 'copilot', label: 'Copilot', supported: true, preferredMode: 'extension' }],
+    }
+
+    const result = planner.createPlanResult(context)
+
+    expect(result.actions).toContainEqual({
+      type: 'install_extension',
+      target: 'cursor',
+      description: 'Install the Inspecto Cursor extension.',
+    })
+    expect(result.defaults).toMatchObject({
+      provider: 'copilot',
+      ide: 'cursor',
+      shared: false,
+      extension: true,
+    })
+  })
+
+  it('plans Inspecto extension installation for Trae CN by default', () => {
+    const context: OnboardingContext = {
+      root: '/repo',
+      packageManager: 'pnpm',
+      buildTools: {
+        supported: [
+          {
+            tool: 'vite',
+            configPath: 'vite.config.ts',
+            label: 'Vite (vite.config.ts)',
+          },
+        ],
+        unsupported: [],
+      },
+      frameworks: {
+        supported: ['react'],
+        unsupported: [],
+      },
+      ides: [{ ide: 'trae-cn', supported: true }],
+      providers: [{ id: 'gemini', label: 'Gemini', supported: true, preferredMode: 'extension' }],
+    }
+
+    const result = planner.createPlanResult(context)
+
+    expect(result.actions).toContainEqual({
+      type: 'install_extension',
+      target: 'trae-cn',
+      description: 'Install the Inspecto Trae CN extension.',
+    })
+    expect(result.defaults).toMatchObject({
+      provider: 'gemini',
+      ide: 'trae-cn',
+      shared: false,
+      extension: true,
+    })
+  })
+
+  it('returns a webpack 4 partial-manual strategy when the selected build target is legacy webpack', () => {
+    const context: OnboardingContext = {
+      root: '/repo/app',
+      packageManager: 'pnpm',
+      buildTools: {
+        supported: [
+          {
+            tool: 'webpack',
+            configPath: 'app/webpack.config.js',
+            label: 'Webpack (app/webpack.config.js) [Webpack 4]',
+            packagePath: 'app',
+            isLegacyWebpack: true,
+          },
+        ],
+        unsupported: [],
+      },
+      frameworks: {
+        supported: ['react'],
+        unsupported: [],
+      },
+      ides: [{ ide: 'cursor', supported: true }],
+      providers: [{ id: 'copilot', label: 'Copilot', supported: true, preferredMode: 'extension' }],
+    }
+
+    const result = planner.createPlanResult(context)
+
+    expect(result.status).toBe('warning')
+    expect(result.strategy).toBe('manual')
+    expect(result.blockers).toEqual([])
+    expect(result.warnings).toEqual([
+      {
+        code: 'legacy-webpack4-requires-manual-config',
+        message:
+          'Webpack 4 detected at app/webpack.config.js. Inspecto must use the legacy Webpack 4 plugin entry and manual config steps.',
+      },
+    ])
+    expect(result.actions).toEqual([
+      {
+        type: 'install_dependency',
+        target: '@inspecto-dev/plugin @inspecto-dev/core',
+        description: 'Install the Inspecto runtime packages with pnpm.',
+      },
+      {
+        type: 'manual_step',
+        target: 'app/webpack.config.js',
+        description:
+          'Update app/webpack.config.js to import `webpackPlugin` from `@inspecto-dev/plugin/legacy/webpack4` and add it to the Webpack plugins array.',
+      },
+    ])
+  })
+
   it('blocks root-level apply planning when multiple supported build targets are detected', () => {
     const context: OnboardingContext = {
       root: '/repo',

package/tests/runner-script.test.ts

@@ -19,7 +19,7 @@ async function writeExecutable(filePath: string, content: string): Promise<void>
 }
 
 function runRunner(scriptPath: string, cwd: string, pathEnv: string): string {
-  const result = spawnSync(scriptPath, ['onboard', '--json'], {
+  const result = spawnSync('bash', [scriptPath, 'onboard', '--json'], {
     cwd,
     env: {
       ...process.env,
@@ -32,6 +32,41 @@ function runRunner(scriptPath: string, cwd: string, pathEnv: string): string {
   return (result.stdout + result.stderr).trim()
 }
 
+function runRunnerWithEnv(
+  scriptPath: string,
+  cwd: string,
+  pathEnv: string,
+  extraEnv: Record<string, string>,
+): string {
+  const result = spawnSync('bash', [scriptPath, 'onboard', '--json'], {
+    cwd,
+    env: {
+      ...process.env,
+      PATH: pathEnv,
+      ...extraEnv,
+    },
+    encoding: 'utf8',
+  })
+
+  expect(result.status).toBe(0)
+  return (result.stdout + result.stderr).trim()
+}
+
+async function writeJson(filePath: string, data: unknown): Promise<void> {
+  await fs.mkdir(path.dirname(filePath), { recursive: true })
+  await fs.writeFile(filePath, JSON.stringify(data, null, 2), 'utf8')
+}
+
+async function writeNodeEntrypoint(filePath: string, content: string): Promise<void> {
+  await fs.mkdir(path.dirname(filePath), { recursive: true })
+  await fs.writeFile(
+    filePath,
+    `#!/usr/bin/env node\nconsole.log(${JSON.stringify(content)} + process.argv.slice(2).join(' '))\n`,
+    'utf8',
+  )
+  await fs.chmod(filePath, 0o755)
+}
+
 describe('skill runner scripts', () => {
   afterEach(async () => {
     await Promise.all(TEMP_DIRS.splice(0).map(dir => fs.rm(dir, { recursive: true, force: true })))
@@ -69,4 +104,88 @@ exit 99
       expect(output).not.toContain('pnpm-should-not-run')
     },
   )
+
+  it.each([
+    'skills/inspecto-onboarding-codex/scripts/run-inspecto.sh',
+    'skills/inspecto-onboarding-claude-code/scripts/run-inspecto.sh',
+    'skills/inspecto-onboarding-trae/scripts/run-inspecto.sh',
+    'skills/inspecto-onboarding-core/scripts/run-inspecto.sh',
+  ])('prefers .inspecto/dev.json cliBin before global fallback: %s', async scriptRelativePath => {
+    const workspaceRoot = path.resolve(__dirname, '../../..')
+    const scriptPath = path.join(workspaceRoot, scriptRelativePath)
+    const tempDir = await makeTempDir()
+    const fakeBin = path.join(tempDir, 'bin')
+    const fakeCli = path.join(tempDir, 'inspecto-dev-bin.js')
+
+    await writeNodeEntrypoint(fakeCli, 'dev-config-cli:')
+    await writeJson(path.join(tempDir, '.inspecto/dev.json'), {
+      cliBin: fakeCli,
+    })
+    await writeExecutable(
+      path.join(fakeBin, 'inspecto'),
+      `#!/usr/bin/env bash
+echo "installed-inspecto:$*"
+`,
+    )
+
+    const output = runRunner(scriptPath, tempDir, `${fakeBin}:${process.env.PATH ?? ''}`)
+    expect(output).toContain('dev-config-cli:onboard --json')
+    expect(output).not.toContain('installed-inspecto:onboard --json')
+  })
+
+  it.each([
+    'skills/inspecto-onboarding-codex/scripts/run-inspecto.sh',
+    'skills/inspecto-onboarding-claude-code/scripts/run-inspecto.sh',
+    'skills/inspecto-onboarding-trae/scripts/run-inspecto.sh',
+    'skills/inspecto-onboarding-core/scripts/run-inspecto.sh',
+  ])('prefers .inspecto/dev.json devRepo before global fallback: %s', async scriptRelativePath => {
+    const workspaceRoot = path.resolve(__dirname, '../../..')
+    const scriptPath = path.join(workspaceRoot, scriptRelativePath)
+    const tempDir = await makeTempDir()
+    const fakeBin = path.join(tempDir, 'bin')
+    const fakeRepoDist = path.join(tempDir, 'repo/packages/cli/dist')
+
+    await writeNodeEntrypoint(path.join(fakeRepoDist, 'bin.js'), 'dev-config-repo:')
+    await writeJson(path.join(tempDir, '.inspecto/dev.json'), {
+      devRepo: path.join(tempDir, 'repo'),
+    })
+    await writeExecutable(
+      path.join(fakeBin, 'inspecto'),
+      `#!/usr/bin/env bash
+echo "installed-inspecto:$*"
+`,
+    )
+
+    const output = runRunner(scriptPath, tempDir, `${fakeBin}:${process.env.PATH ?? ''}`)
+    expect(output).toContain('dev-config-repo:onboard --json')
+    expect(output).not.toContain('installed-inspecto:onboard --json')
+  })
+
+  it.each([
+    'skills/inspecto-onboarding-codex/scripts/run-inspecto.sh',
+    'skills/inspecto-onboarding-claude-code/scripts/run-inspecto.sh',
+    'skills/inspecto-onboarding-trae/scripts/run-inspecto.sh',
+    'skills/inspecto-onboarding-core/scripts/run-inspecto.sh',
+  ])('prefers env vars over .inspecto/dev.json: %s', async scriptRelativePath => {
+    const workspaceRoot = path.resolve(__dirname, '../../..')
+    const scriptPath = path.join(workspaceRoot, scriptRelativePath)
+    const tempDir = await makeTempDir()
+    const fakeBin = path.join(tempDir, 'bin')
+    const envCli = path.join(tempDir, 'env-bin.js')
+    const configCli = path.join(tempDir, 'config-bin.js')
+
+    await writeNodeEntrypoint(envCli, 'env-cli:')
+    await writeNodeEntrypoint(configCli, 'config-cli:')
+    await writeJson(path.join(tempDir, '.inspecto/dev.json'), {
+      cliBin: configCli,
+    })
+    await fs.mkdir(fakeBin, { recursive: true })
+
+    const output = runRunnerWithEnv(scriptPath, tempDir, `${fakeBin}:${process.env.PATH ?? ''}`, {
+      INSPECTO_CLI_BIN: envCli,
+    })
+
+    expect(output).toContain('env-cli:onboard --json')
+    expect(output).not.toContain('config-cli:onboard --json')
+  })
 })

package/tests/session-resolve.test.ts

@@ -0,0 +1,116 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { resolveOnboardingSession } from '../src/onboarding/session.js'
+
+const { buildOnboardingContextMock, readJSONMock } = vi.hoisted(() => ({
+  buildOnboardingContextMock: vi.fn(),
+  readJSONMock: vi.fn(),
+}))
+
+vi.mock('../src/onboarding/context.js', () => ({
+  buildOnboardingContext: buildOnboardingContextMock,
+}))
+
+vi.mock('../src/utils/fs.js', async () => {
+  const actual = await vi.importActual('../src/utils/fs.js')
+  return {
+    ...actual,
+    readJSON: readJSONMock,
+  }
+})
+
+describe('resolveOnboardingSession for Next.js guided onboarding', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+    readJSONMock.mockImplementation(async filePath => {
+      if (String(filePath).endsWith('package.json')) {
+        return { scripts: { dev: 'next dev' } }
+      }
+      return null
+    })
+  })
+
+  it('returns partial_success instead of error for Next.js projects', async () => {
+    buildOnboardingContextMock.mockResolvedValue({
+      root: '/repo',
+      packageManager: 'pnpm',
+      buildTools: {
+        supported: [],
+        unsupported: ['Next.js'],
+      },
+      frameworks: {
+        supported: ['react'],
+        unsupported: [],
+      },
+      ides: [{ ide: 'vscode', supported: true }],
+      providers: [{ id: 'codex', label: 'Codex CLI', supported: true, preferredMode: 'cli' }],
+    })
+
+    const result = await resolveOnboardingSession('/repo')
+
+    expect(result.status).toBe('partial_success')
+    expect(result.target).toEqual({
+      status: 'guided',
+      candidates: [],
+      reason: 'Guided onboarding is available for Next.js.',
+    })
+    expect(result.plan.strategy).toBe('guided')
+    expect(result.framework).toBe('react')
+    expect(result.metaFramework).toBe('Next.js')
+    expect(result.pendingSteps).toEqual(
+      expect.arrayContaining([expect.stringContaining('Review the generated Next.js patch plan')]),
+    )
+  })
+
+  it('returns partial_success instead of error for Nuxt projects', async () => {
+    buildOnboardingContextMock.mockResolvedValue({
+      root: '/repo',
+      packageManager: 'pnpm',
+      buildTools: {
+        supported: [],
+        unsupported: ['Nuxt'],
+      },
+      frameworks: {
+        supported: ['vue'],
+        unsupported: [],
+      },
+      ides: [{ ide: 'vscode', supported: true }],
+      providers: [{ id: 'codex', label: 'Codex CLI', supported: true, preferredMode: 'cli' }],
+    })
+
+    const result = await resolveOnboardingSession('/repo')
+
+    expect(result.status).toBe('partial_success')
+    expect(result.plan.strategy).toBe('guided')
+    expect(result.framework).toBe('vue')
+    expect(result.metaFramework).toBe('Nuxt')
+    expect(result.pendingSteps).toEqual(
+      expect.arrayContaining([expect.stringContaining('Review the generated Nuxt patch plan')]),
+    )
+  })
+
+  it('keeps Next.js guided onboarding when extra unsupported build tools are present', async () => {
+    buildOnboardingContextMock.mockResolvedValue({
+      root: '/repo',
+      packageManager: 'pnpm',
+      buildTools: {
+        supported: [],
+        unsupported: ['Next.js', 'CustomStack'],
+      },
+      frameworks: {
+        supported: ['react'],
+        unsupported: [],
+      },
+      ides: [{ ide: 'vscode', supported: true }],
+      providers: [{ id: 'codex', label: 'Codex CLI', supported: true, preferredMode: 'cli' }],
+    })
+
+    const result = await resolveOnboardingSession('/repo')
+
+    expect(result.status).toBe('partial_success')
+    expect(result.plan.strategy).toBe('guided')
+    expect(result.target.status).toBe('guided')
+    expect(result.summary.risks).toEqual(
+      expect.arrayContaining(['Additional unsupported build tool also detected: CustomStack']),
+    )
+  })
+})

package/tests/session.test.ts

@@ -0,0 +1,120 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { applyResolvedOnboardingSession } from '../src/onboarding/session.js'
+import type { ApplyOnboardingResult } from '../src/onboarding/apply.js'
+import type { ResolvedOnboardingSession } from '../src/types.js'
+
+const { applyOnboardingPlanMock, readJSONMock } = vi.hoisted(() => ({
+  applyOnboardingPlanMock: vi.fn(),
+  readJSONMock: vi.fn(),
+}))
+
+vi.mock('../src/onboarding/apply.js', () => ({
+  applyOnboardingPlan: applyOnboardingPlanMock,
+}))
+
+vi.mock('../src/utils/fs.js', async () => {
+  const actual = await vi.importActual('../src/utils/fs.js')
+  return {
+    ...actual,
+    readJSON: readJSONMock,
+  }
+})
+
+describe('onboarding session extension guidance', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+    readJSONMock.mockResolvedValue({
+      scripts: {
+        dev: 'vite',
+      },
+    })
+  })
+
+  it('returns Cursor-specific manual extension guidance when onboarding still needs manual completion', async () => {
+    const session: ResolvedOnboardingSession = {
+      status: 'success',
+      target: {
+        status: 'resolved',
+        selected: {
+          packagePath: '',
+          configPath: 'vite.config.ts',
+          buildTool: 'vite',
+          frameworks: ['react'],
+          automaticInjection: true,
+        },
+        candidates: [
+          {
+            packagePath: '',
+            configPath: 'vite.config.ts',
+            buildTool: 'vite',
+            frameworks: ['react'],
+            automaticInjection: true,
+          },
+        ],
+        reason: 'Only one supported target was detected.',
+      },
+      summary: {
+        headline: 'Inspecto is ready to onboard /repo.',
+        changes: ['Install dependencies.'],
+        risks: [],
+        manualFollowUp: [],
+      },
+      confirmation: { required: false },
+      verification: {
+        available: true,
+        devCommand: 'pnpm dev',
+        message: 'Start the local dev server with `pnpm dev` to verify Inspecto in the browser.',
+      },
+      context: {
+        root: '/repo',
+        packageManager: 'pnpm',
+        buildTools: { supported: [], unsupported: [] },
+        frameworks: { supported: ['react'], unsupported: [] },
+        ides: [{ ide: 'cursor', supported: true }],
+        providers: [
+          { id: 'codex', label: 'Codex CLI', supported: true, preferredMode: 'extension' },
+        ],
+      },
+      plan: {
+        status: 'ok',
+        warnings: [],
+        blockers: [],
+        strategy: 'supported',
+        actions: [],
+        defaults: {
+          provider: 'codex',
+          ide: 'cursor',
+          shared: false,
+          extension: true,
+        },
+      },
+      projectRoot: '/repo',
+      selectedIDE: { ide: 'cursor', supported: true },
+      providerDefault: 'codex.extension',
+    }
+
+    const applyResult: ApplyOnboardingResult = {
+      status: 'warning',
+      mutations: [],
+      postInstall: {
+        installFailed: false,
+        injectionFailed: false,
+        manualExtensionInstallNeeded: true,
+        nextSteps: ['Install the Inspecto IDE extension manually'],
+      },
+    }
+
+    applyOnboardingPlanMock.mockResolvedValue(applyResult)
+
+    const result = await applyResolvedOnboardingSession(session, {})
+
+    expect(result.status).toBe('partial_success')
+    expect(result.ideExtension).toMatchObject({
+      required: true,
+      installed: false,
+      manualRequired: true,
+      installCommand: 'cursor --install-extension inspecto.inspecto',
+      openVsxUrl: 'https://open-vsx.org/extension/inspecto/inspecto',
+    })
+  })
+})