@inspecto-dev/cli 0.3.4 → 0.3.5

package/tests/apply.test.ts

@@ -33,7 +33,9 @@ vi.mock('../src/detect/package-manager.js', async () => {
 
 vi.mock('../src/utils/fs.js', () => ({
   exists: vi.fn(),
+  readFile: vi.fn(),
   readJSON: vi.fn(),
+  writeFile: vi.fn(),
   writeJSON: vi.fn(),
 }))
 
@@ -80,7 +82,9 @@ describe('apply onboarding flow', () => {
       mutations: [{ type: 'file_modified', path: 'vite.config.ts' }],
     })
     vi.mocked(fsUtils.exists).mockResolvedValue(false)
+    vi.mocked(fsUtils.readFile).mockResolvedValue(null)
     vi.mocked(fsUtils.readJSON).mockResolvedValue(null)
+    vi.mocked(fsUtils.writeFile).mockResolvedValue()
     vi.mocked(gitignoreUtils.updateGitignore).mockResolvedValue()
     vi.mocked(extensionUtils.installExtension).mockResolvedValue({
       type: 'extension_installed',
@@ -333,6 +337,321 @@ describe('apply onboarding flow', () => {
     )
   })
 
+  it('auto-applies high-confidence Next.js config patches for guided plans', async () => {
+    vi.mocked(fsUtils.readFile).mockImplementation(async filePath => {
+      if (filePath === '/repo/next.config.mjs') {
+        return 'export default {\n  reactStrictMode: true,\n}\n'
+      }
+      return null
+    })
+
+    const result = await applyOnboardingPlan({
+      repoRoot: '/repo',
+      projectRoot: '/repo',
+      packageManager: 'pnpm',
+      supportedBuildTargets: [],
+      options: {
+        shared: false,
+        skipInstall: false,
+        dryRun: false,
+        noExtension: false,
+      },
+      selectedIDE: { ide: 'vscode', supported: true },
+      providerDefault: 'codex.extension',
+      plan: {
+        status: 'warning',
+        warnings: [],
+        blockers: [],
+        strategy: 'guided',
+        actions: [
+          {
+            type: 'install_dependency',
+            target: '@inspecto-dev/plugin @inspecto-dev/core',
+            description: 'Install the Inspecto runtime packages with pnpm.',
+          },
+          {
+            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.',
+          },
+        ],
+        defaults: {
+          provider: 'codex',
+          ide: 'vscode',
+          shared: false,
+          extension: true,
+        },
+        framework: 'react',
+        metaFramework: 'Next.js',
+        routerMode: 'app',
+        autoApplied: ['dependencies', 'inspecto_settings'],
+        pendingSteps: [
+          'Review the generated Next.js patch plan for next.config.mjs.',
+          'Complete the remaining client-side mount step for your App Router entry.',
+        ],
+        assistantPrompt: 'Complete the remaining Inspecto onboarding for this Next.js project.',
+        patches: [
+          {
+            path: 'next.config.mjs',
+            status: 'planned',
+            reason: 'next_config_object_export',
+            confidence: 'high',
+            snippet:
+              "import { webpackPlugin as inspecto } from '@inspecto-dev/plugin'\n\nwebpack(config, { dev, isServer }) {\n  if (dev && !isServer) {\n    config.plugins.push(inspecto())\n  }\n  return config\n}",
+          },
+        ],
+      },
+      allowManualPlanApply: true,
+    })
+
+    expect(astInjectorUtils.injectPlugin).not.toHaveBeenCalled()
+    expect(fsUtils.writeFile).toHaveBeenCalledWith(
+      '/repo/next.config.mjs',
+      expect.stringContaining("import { webpackPlugin as inspecto } from '@inspecto-dev/plugin'"),
+    )
+    expect(fsUtils.writeFile).toHaveBeenCalledWith(
+      '/repo/next.config.mjs',
+      expect.stringContaining('if (dev) {\n      config.plugins.push(inspecto())'),
+    )
+    expect(result.mutations).toEqual(
+      expect.arrayContaining([
+        {
+          type: 'file_modified',
+          path: 'next.config.mjs',
+          description: 'Automatically configured Inspecto guided Next.js patch',
+        },
+      ]),
+    )
+    expect(result.postInstall.nextSteps).toContain(
+      'Complete the remaining client-side Inspecto mount step in your assistant or editor.',
+    )
+  })
+
+  it('auto-applies high-confidence Next.js patches for exported nextConfig objects', async () => {
+    vi.mocked(fsUtils.readFile).mockImplementation(async filePath => {
+      if (filePath === '/repo/next.config.ts') {
+        return "import type { NextConfig } from 'next'\nconst nextConfig: NextConfig = {\n  reactStrictMode: true,\n}\n\nexport default nextConfig\n"
+      }
+      return null
+    })
+
+    const result = await applyOnboardingPlan({
+      repoRoot: '/repo',
+      projectRoot: '/repo',
+      packageManager: 'pnpm',
+      supportedBuildTargets: [],
+      options: {
+        shared: false,
+        skipInstall: false,
+        dryRun: false,
+        noExtension: false,
+      },
+      selectedIDE: { ide: 'vscode', supported: true },
+      providerDefault: 'codex.extension',
+      plan: {
+        status: 'warning',
+        warnings: [],
+        blockers: [],
+        strategy: 'guided',
+        actions: [],
+        defaults: {
+          provider: 'codex',
+          ide: 'vscode',
+          shared: false,
+          extension: true,
+        },
+        framework: 'react',
+        metaFramework: 'Next.js',
+        routerMode: 'app',
+        autoApplied: ['dependencies', 'inspecto_settings'],
+        pendingSteps: [
+          'Review the generated Next.js patch plan for next.config.ts.',
+          'Complete the remaining client-side mount step for your App Router entry.',
+        ],
+        assistantPrompt: 'Complete the remaining Inspecto onboarding for this Next.js project.',
+        patches: [
+          {
+            path: 'next.config.ts',
+            status: 'planned',
+            reason: 'next_config_object_export',
+            confidence: 'high',
+            snippet:
+              "import { webpackPlugin as inspecto } from '@inspecto-dev/plugin'\n\nwebpack(config, { dev, isServer }) {\n  if (dev && !isServer) {\n    config.plugins.push(inspecto())\n  }\n  return config\n}",
+          },
+        ],
+      },
+      allowManualPlanApply: true,
+    })
+
+    expect(fsUtils.writeFile).toHaveBeenCalledWith(
+      '/repo/next.config.ts',
+      expect.stringContaining("import { webpackPlugin as inspecto } from '@inspecto-dev/plugin'"),
+    )
+    expect(fsUtils.writeFile).toHaveBeenCalledWith(
+      '/repo/next.config.ts',
+      expect.stringContaining(
+        'const nextConfig: NextConfig = {\n  webpack(config, { dev, isServer }) {',
+      ),
+    )
+    expect(fsUtils.writeFile).toHaveBeenCalledWith(
+      '/repo/next.config.ts',
+      expect.not.stringContaining('!isServer'),
+    )
+    expect(result.mutations).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          path: 'next.config.ts',
+          description: 'Automatically configured Inspecto guided Next.js patch',
+        }),
+      ]),
+    )
+  })
+
+  it('preserves manual patch follow-up for guided Next.js plans that are not auto-applicable', async () => {
+    const result = await applyOnboardingPlan({
+      repoRoot: '/repo',
+      projectRoot: '/repo',
+      packageManager: 'pnpm',
+      supportedBuildTargets: [],
+      options: {
+        shared: false,
+        skipInstall: false,
+        dryRun: false,
+        noExtension: false,
+      },
+      selectedIDE: { ide: 'vscode', supported: true },
+      providerDefault: 'codex.extension',
+      plan: {
+        status: 'warning',
+        warnings: [],
+        blockers: [],
+        strategy: 'guided',
+        actions: [
+          {
+            type: 'generate_patch_plan',
+            target: 'next.config',
+            description:
+              'Generate a guided patch plan for the Next.js Inspecto webpack integration.',
+          },
+        ],
+        defaults: {
+          provider: 'codex',
+          ide: 'vscode',
+          shared: false,
+          extension: true,
+        },
+        framework: 'react',
+        metaFramework: 'Next.js',
+        routerMode: 'pages',
+        pendingSteps: ['Review the generated Next.js patch plan for next.config.js.'],
+        patches: [
+          {
+            path: 'next.config.js',
+            status: 'manual_patch_required',
+            reason: 'next_config_wrapped_export',
+            confidence: 'medium',
+            snippet: 'module.exports = withBundleAnalyzer({ /* ... */ })',
+          },
+        ],
+      },
+      allowManualPlanApply: true,
+    })
+
+    expect(astInjectorUtils.injectPlugin).not.toHaveBeenCalled()
+    expect(fsUtils.writeFile).not.toHaveBeenCalledWith('/repo/next.config.js', expect.any(String))
+    expect(result.postInstall.nextSteps).toContain(
+      'Generate a guided patch plan for the Next.js Inspecto webpack integration.',
+    )
+  })
+
+  it('auto-applies high-confidence Nuxt config patches for guided plans', async () => {
+    vi.mocked(fsUtils.readFile).mockImplementation(async filePath => {
+      if (filePath === '/repo/nuxt.config.ts') {
+        return 'export default defineNuxtConfig({\n  devtools: { enabled: true },\n})\n'
+      }
+      return null
+    })
+
+    const result = await applyOnboardingPlan({
+      repoRoot: '/repo',
+      projectRoot: '/repo',
+      packageManager: 'pnpm',
+      supportedBuildTargets: [],
+      options: {
+        shared: false,
+        skipInstall: false,
+        dryRun: false,
+        noExtension: false,
+      },
+      selectedIDE: { ide: 'vscode', supported: true },
+      providerDefault: 'codex.extension',
+      plan: {
+        status: 'warning',
+        warnings: [],
+        blockers: [],
+        strategy: 'guided',
+        actions: [
+          {
+            type: 'generate_patch_plan',
+            target: 'nuxt.config',
+            description: 'Generate a guided patch plan for the Nuxt Inspecto Vite integration.',
+          },
+        ],
+        defaults: {
+          provider: 'codex',
+          ide: 'vscode',
+          shared: false,
+          extension: true,
+        },
+        framework: 'vue',
+        metaFramework: 'Nuxt',
+        pendingSteps: [
+          'Review the generated Nuxt patch plan for nuxt.config.ts.',
+          'Complete the remaining Nuxt client plugin mount step in plugins/inspecto.client.ts.',
+        ],
+        patches: [
+          {
+            path: 'nuxt.config.ts',
+            status: 'planned',
+            reason: 'nuxt_config_object_export',
+            confidence: 'high',
+            snippet:
+              "import { vitePlugin as inspecto } from '@inspecto-dev/plugin'\n\nexport default defineNuxtConfig({\n  vite: {\n    plugins: [inspecto()],\n  },\n})",
+          },
+          {
+            path: 'plugins/inspecto.client.ts',
+            status: 'manual_patch_required',
+            reason: 'nuxt_client_plugin_mount',
+            confidence: 'medium',
+            snippet: 'export default defineNuxtPlugin(() => {})',
+          },
+        ],
+      },
+      allowManualPlanApply: true,
+    })
+
+    expect(fsUtils.writeFile).toHaveBeenCalledWith(
+      '/repo/nuxt.config.ts',
+      expect.stringContaining("import { vitePlugin as inspecto } from '@inspecto-dev/plugin'"),
+    )
+    expect(result.mutations).toEqual(
+      expect.arrayContaining([
+        {
+          type: 'file_modified',
+          path: 'nuxt.config.ts',
+          description: 'Automatically configured Inspecto guided Next.js patch',
+        },
+      ]),
+    )
+  })
+
   it('uses onboarding context and planner output and prints JSON from the apply command', async () => {
     const context: OnboardingContext = {
       root: '/repo',

package/tests/dev-config.test.ts

@@ -0,0 +1,73 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import * as fsUtils from '../src/utils/fs.js'
+import * as gitignoreUtils from '../src/inject/gitignore.js'
+import { devLink, devStatus, devUnlink } from '../src/commands/dev-config.js'
+
+vi.mock('../src/utils/fs.js', () => ({
+  exists: vi.fn(),
+  readJSON: vi.fn(),
+  removeFile: vi.fn(),
+  writeJSON: vi.fn(),
+}))
+
+vi.mock('../src/inject/gitignore.js', () => ({
+  updateGitignore: vi.fn(),
+}))
+
+describe('dev config commands', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+    vi.spyOn(process, 'cwd').mockReturnValue('/repo')
+  })
+
+  it('writes cliBin into .inspecto/dev.json', async () => {
+    vi.mocked(fsUtils.readJSON).mockResolvedValue(null)
+
+    const result = await devLink({ cliBin: '/tmp/inspecto/bin.js', json: true })
+
+    expect(gitignoreUtils.updateGitignore).toHaveBeenCalledWith('/repo', false, false, true)
+    expect(fsUtils.writeJSON).toHaveBeenCalledWith('/repo/.inspecto/dev.json', {
+      cliBin: '/tmp/inspecto/bin.js',
+    })
+    expect(result.config).toEqual({ cliBin: '/tmp/inspecto/bin.js' })
+  })
+
+  it('writes devRepo into .inspecto/dev.json', async () => {
+    vi.mocked(fsUtils.readJSON).mockResolvedValue({ cliBin: '/tmp/old.js' })
+
+    const result = await devLink({ devRepo: '/tmp/inspecto', json: true })
+
+    expect(gitignoreUtils.updateGitignore).toHaveBeenCalledWith('/repo', false, false, true)
+    expect(fsUtils.writeJSON).toHaveBeenCalledWith('/repo/.inspecto/dev.json', {
+      cliBin: '/tmp/old.js',
+      devRepo: '/tmp/inspecto',
+    })
+    expect(result.config).toEqual({
+      cliBin: '/tmp/old.js',
+      devRepo: '/tmp/inspecto',
+    })
+  })
+
+  it('returns current dev config status', async () => {
+    vi.mocked(fsUtils.exists).mockResolvedValue(true)
+    vi.mocked(fsUtils.readJSON).mockResolvedValue({
+      cliBin: '/tmp/inspecto/bin.js',
+      devRepo: '/tmp/inspecto',
+    })
+
+    const result = await devStatus(true)
+
+    expect(result.status).toBe('ok')
+    expect(result.config).toEqual({
+      cliBin: '/tmp/inspecto/bin.js',
+      devRepo: '/tmp/inspecto',
+    })
+  })
+
+  it('clears the dev config on unlink', async () => {
+    const result = await devUnlink(true)
+
+    expect(fsUtils.removeFile).toHaveBeenCalledWith('/repo/.inspecto/dev.json')
+    expect(result.status).toBe('ok')
+  })
+})

package/tests/doctor.test.ts

@@ -262,4 +262,93 @@ describe('doctor command', () => {
     expect(output).not.toContain('"status"')
     expect(output).not.toContain('"summary"')
   })
+
+  it('reports Next.js as guided onboarding instead of unsupported', async () => {
+    vi.mocked(fsUtils.exists).mockImplementation(async (filePath: string) => {
+      const existingPaths = new Set([
+        '/repo/package.json',
+        '/repo/node_modules/@inspecto-dev/plugin',
+        '/repo/next.config.ts',
+        '/repo/.inspecto/settings.local.json',
+        '/repo/.gitignore',
+      ])
+      return existingPaths.has(filePath)
+    })
+    vi.mocked(fsUtils.readJSON).mockImplementation(async (filePath: string) => {
+      if (filePath === '/repo/package.json') {
+        return { scripts: { dev: 'next dev --webpack' } }
+      }
+      if (filePath === '/repo/node_modules/@inspecto-dev/plugin/package.json') {
+        return { version: '1.2.3' }
+      }
+      if (filePath === '/repo/.inspecto/settings.local.json') {
+        return { ide: 'trae', 'provider.default': 'coco.cli' }
+      }
+      return null
+    })
+    vi.mocked(fsUtils.readFile).mockImplementation(async filePath => {
+      if (filePath === '/repo/next.config.ts') {
+        return "import { webpackPlugin as inspecto } from '@inspecto-dev/plugin'\nexport default {}"
+      }
+      if (filePath === '/repo/.gitignore') {
+        return '.inspecto/install.lock\n.inspecto/dev.json\n'
+      }
+      return null
+    })
+    vi.mocked(packageManager.detectPackageManager).mockResolvedValue('pnpm')
+    vi.mocked(packageManager.getInstallCommand).mockReturnValue('pnpm add -D @inspecto-dev/plugin')
+    vi.mocked(ide.detectIDE).mockResolvedValue({
+      detected: [{ ide: 'trae', supported: true }],
+    })
+    vi.mocked(framework.detectFrameworks).mockResolvedValue({
+      supported: ['react'],
+      unsupported: [],
+    })
+    vi.mocked(provider.detectProviders).mockResolvedValue({
+      detected: [{ label: 'Trae CLI (Coco)', providerModes: ['cli'] }],
+    })
+    vi.mocked(buildTool.detectBuildTools).mockResolvedValue({
+      supported: [],
+      unsupported: ['Next.js'],
+    })
+    vi.mocked(extension.isExtensionInstalled).mockResolvedValue(true)
+
+    const result = await collectDoctorResult('/repo')
+
+    expect(result.status).toBe('warning')
+    expect(result.errors).toEqual([])
+    expect(result.warnings).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          code: 'build-tool-guided',
+          message: 'Build tool: Next.js (guided onboarding available)',
+          hints: expect.arrayContaining([
+            'Run `inspecto onboard --json` to generate the remaining patch plan and assistant handoff.',
+            expect.stringContaining('Review the generated Next.js patch plan'),
+          ]),
+          details: expect.objectContaining({
+            metaFrameworks: ['Next.js'],
+            patchCount: expect.any(Number),
+            pendingSteps: expect.arrayContaining([
+              expect.stringContaining('Review the generated Next.js patch plan'),
+            ]),
+            assistantPrompt: expect.stringContaining(
+              'Complete the remaining Inspecto onboarding for this Next.js project.',
+            ),
+          }),
+        }),
+      ]),
+    )
+    expect(result.warnings).toEqual(
+      expect.not.arrayContaining([expect.objectContaining({ code: 'build-tool-unsupported' })]),
+    )
+    expect(result.checks).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          code: 'guided-config-patch-pending',
+          message: 'Guided config patch still needs review in next.config.js',
+        }),
+      ]),
+    )
+  })
 })

package/tests/init.test.ts

@@ -244,6 +244,23 @@ describe('init in monorepo roots', () => {
     expect(instructionUtils.printNuxtManualInstructions).not.toHaveBeenCalled()
   })
 
+  it('prints detailed Nuxt guided instructions when Nuxt is detected', async () => {
+    vi.mocked(buildToolUtils.detectBuildTools).mockResolvedValue({
+      supported: [],
+      unsupported: ['Nuxt'],
+    })
+
+    await init({
+      shared: false,
+      skipInstall: true,
+      dryRun: true,
+      noExtension: true,
+      force: false,
+    })
+
+    expect(instructionUtils.printNuxtManualInstructions).toHaveBeenCalled()
+  })
+
   it('preserves detected preferred mode for an explicit provider override', async () => {
     vi.mocked(buildToolUtils.detectBuildTools).mockResolvedValue({
       supported: [

package/tests/instructions.test.ts

@@ -19,7 +19,9 @@ describe('manual framework instructions', () => {
     printNextJsManualInstructions()
 
     expect(log.blank).toHaveBeenCalled()
-    expect(log.hint).toHaveBeenCalledWith('Next.js requires manual setup in the current version.')
+    expect(log.hint).toHaveBeenCalledWith(
+      'Next.js supports guided setup in the current version. Inspecto can prepare the config patch, but the client-side mount step still needs review.',
+    )
     expect(log.hint).toHaveBeenCalledWith(
       '1. Update `next.config.mjs` to register the Inspecto webpack plugin:',
     )
@@ -30,10 +32,10 @@ describe('manual framework instructions', () => {
       ]),
     )
     expect(log.hint).toHaveBeenCalledWith(
-      '2. Initialize `@inspecto-dev/core` from a client component such as `app/layout.tsx` or `pages/_app.tsx`:',
+      '2. Complete the remaining client-side mount step in `app/layout.tsx` or `pages/_app.tsx`:',
     )
     expect(log.hint).toHaveBeenCalledWith(
-      '3. Restart your Next.js dev server after updating the config.',
+      '3. Restart your Next.js dev server after applying the guided patches.',
     )
   })
 
@@ -41,7 +43,9 @@ describe('manual framework instructions', () => {
     printNuxtManualInstructions()
 
     expect(log.blank).toHaveBeenCalled()
-    expect(log.hint).toHaveBeenCalledWith('Nuxt requires manual setup in the current version.')
+    expect(log.hint).toHaveBeenCalledWith(
+      'Nuxt supports guided setup in the current version. Inspecto can prepare the config patch, but the client plugin mount step still needs review.',
+    )
     expect(log.hint).toHaveBeenCalledWith(
       '1. Update `nuxt.config.ts` to register the Inspecto Vite plugin:',
     )
@@ -52,10 +56,10 @@ describe('manual framework instructions', () => {
       ]),
     )
     expect(log.hint).toHaveBeenCalledWith(
-      '2. Create `plugins/inspecto.client.ts` to mount `@inspecto-dev/core` in development:',
+      '2. Complete the remaining client plugin mount step in `plugins/inspecto.client.ts`:',
     )
     expect(log.hint).toHaveBeenCalledWith(
-      '3. Restart your Nuxt dev server after updating the config.',
+      '3. Restart your Nuxt dev server after applying the guided patches.',
     )
   })
 })

package/tests/integration-host-ide.test.ts

@@ -169,4 +169,24 @@ describe('resolveIntegrationHostIde', () => {
       candidates: ['cursor', 'vscode'],
     })
   })
+
+  it('ignores project artifacts when requested by integration install flows', async () => {
+    vi.mocked(fsUtils.exists).mockImplementation(async filePath => {
+      return filePath === '/repo/.trae'
+    })
+
+    const { resolveIntegrationHostIde } = await import('../src/commands/integration-host-ide.js')
+
+    await expect(
+      resolveIntegrationHostIde({
+        cwd: '/repo',
+        ignoreProjectArtifacts: true,
+      }),
+    ).resolves.toMatchObject({
+      ide: null,
+      confidence: 'low',
+      source: 'none',
+      candidates: [],
+    })
+  })
 })

package/tests/integration-install.test.ts

@@ -279,6 +279,40 @@ describe('integration install', () => {
     )
   })
 
+  it('blocks automatic onboarding when no explicit host ide, config, or env signal is available', async () => {
+    runIntegrationAutomationMock.mockResolvedValue({
+      status: 'blocked',
+      message:
+        'Automatic setup stopped: Inspecto could not determine which IDE should receive onboarding.',
+      nextStep:
+        'Re-run with --host-ide <vscode|cursor|trae|trae-cn> or run the command from the target IDE terminal to continue automatic setup.',
+    })
+    resolveIntegrationHostIdeMock.mockResolvedValue({
+      ide: null,
+      source: 'none',
+      confidence: 'low',
+      candidates: [],
+    })
+
+    const { installIntegration } = await import('../src/commands/integration-install.js')
+
+    await installIntegration('coco')
+
+    expect(runIntegrationAutomationMock).toHaveBeenCalledWith(
+      'coco',
+      expect.objectContaining({
+        ignoreProjectArtifacts: true,
+      }),
+      '/repo',
+    )
+    expect(logMock.warn).toHaveBeenCalledWith(
+      'Automatic setup stopped: Inspecto could not determine which IDE should receive onboarding.',
+    )
+    expect(logMock.hint).toHaveBeenCalledWith(
+      'Re-run with --host-ide <vscode|cursor|trae|trae-cn> or run the command from the target IDE terminal to continue automatic setup.',
+    )
+  })
+
   it('surfaces a partial automation outcome as a warning with follow-up guidance', async () => {
     runIntegrationAutomationMock.mockResolvedValue({
       status: 'partial',
@@ -662,6 +696,37 @@ describe('integration install', () => {
     })
   })
 
+  it('wires the dev command group to link, status, and unlink handlers', async () => {
+    const linkCommand = vi.fn().mockResolvedValue(undefined)
+    const statusCommand = vi.fn().mockResolvedValue(undefined)
+    const unlinkCommand = vi.fn().mockResolvedValue(undefined)
+
+    vi.doMock('../src/commands/init.js', () => ({ init: vi.fn() }))
+    vi.doMock('../src/commands/doctor.js', () => ({ doctor: vi.fn() }))
+    vi.doMock('../src/commands/teardown.js', () => ({ teardown: vi.fn() }))
+    vi.doMock('../src/commands/detect.js', () => ({ detect: vi.fn() }))
+    vi.doMock('../src/commands/plan.js', () => ({ plan: vi.fn() }))
+    vi.doMock('../src/commands/apply.js', () => ({ apply: vi.fn() }))
+    vi.doMock('../src/commands/dev-config.js', () => ({
+      devLink: linkCommand,
+      devStatus: statusCommand,
+      devUnlink: unlinkCommand,
+    }))
+
+    const { runCli } = await import('../src/bin.js')
+
+    await runCli(['node', 'inspecto', 'dev', 'link', '--cli-bin', '/tmp/inspecto/bin.js'])
+    await runCli(['node', 'inspecto', 'dev', 'status', '--json'])
+    await runCli(['node', 'inspecto', 'dev', 'unlink'])
+
+    expect(linkCommand).toHaveBeenCalledWith({
+      cliBin: '/tmp/inspecto/bin.js',
+      json: false,
+    })
+    expect(statusCommand).toHaveBeenCalledWith(true)
+    expect(unlinkCommand).toHaveBeenCalledWith(false)
+  })
+
   it('sets a non-zero exit code when integrations doctor reports a blocked result', async () => {
     const doctorCommand = vi.fn().mockResolvedValue({ status: 'blocked' })