@inspecto-dev/cli 0.2.0-alpha.4 → 0.2.0-alpha.6

package/dist/{chunk-EUCQCD3Y.js → chunk-PDDFPQJS.js}

@@ -46,14 +46,55 @@ var log = {
     console.log(`  ${pc.dim("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518")}`);
     console.log();
   },
+  /** Copy-friendly code block without box characters */
+  copyableCodeBlock(lines) {
+    console.log();
+    for (const line of lines) {
+      console.log(`      ${line}`);
+    }
+    console.log();
+  },
   /** Dry-run prefix */
   dryRun(text) {
     console.log(`  ${pc.blue("[dry-run]")} ${text}`);
   }
 };
 
-// src/commands/init.ts
-import path9 from "path";
+// src/utils/output.ts
+function writeCommandOutput(result, json, renderText) {
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    return result;
+  }
+  renderText(result);
+  return result;
+}
+function reportCommandError(error, options = {}) {
+  const message2 = error instanceof Error ? error.message : String(error);
+  const stack = error instanceof Error ? error.stack : void 0;
+  if (options.json) {
+    const payload = {
+      status: "error",
+      error: {
+        message: message2,
+        ...options.debug && stack ? { stack } : {}
+      }
+    };
+    console.error(JSON.stringify(payload, null, 2));
+    return;
+  }
+  log.error(message2);
+  if (options.debug && stack) {
+    console.error(stack);
+  }
+}
+
+// src/onboarding/apply.ts
+import path5 from "path";
+import ora from "ora";
+
+// src/detect/package-manager.ts
+import path2 from "path";
 
 // src/utils/fs.ts
 import fs from "fs/promises";
@@ -85,7 +126,8 @@ async function removeDir(dirPath) {
 }
 async function readJSON(filePath) {
   const text = await readFile(filePath);
-  if (!text) return null;
+  if (text === null) return null;
+  if (text.trim() === "") return {};
   try {
     return JSON.parse(text);
   } catch {
@@ -96,39 +138,7 @@ async function writeJSON(filePath, data) {
   await writeFile(filePath, JSON.stringify(data, null, 2) + "\n");
 }
 
-// src/utils/exec.ts
-import { execFile, exec as execCb } from "child_process";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
-var execAsync = promisify(execCb);
-async function run(command, args, cwd) {
-  const result = await execFileAsync(command, args, {
-    cwd,
-    timeout: 6e4,
-    env: { ...process.env }
-  });
-  return { stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
-}
-async function shell(command, cwd) {
-  const result = await execAsync(command, {
-    cwd,
-    timeout: 6e4,
-    env: { ...process.env }
-  });
-  return { stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
-}
-async function which(bin) {
-  try {
-    const cmd = process.platform === "win32" ? "where" : "which";
-    await run(cmd, [bin]);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 // src/detect/package-manager.ts
-import path2 from "path";
 async function detectPackageManager(root) {
   const checks = [
     ["bun.lockb", "bun"],
@@ -175,262 +185,700 @@ function getUninstallCommand(pm, pkg) {
   }
 }
 
-// src/detect/build-tool.ts
+// src/inject/ast-injector.ts
 import path3 from "path";
-import { createRequire } from "module";
-function isPackageResolvable(pkgName, root) {
-  try {
-    const require2 = createRequire(path3.join(root, "package.json"));
-    try {
-      require2.resolve(`${pkgName}/package.json`, { paths: [root] });
-      return true;
-    } catch {
-      require2.resolve(pkgName, { paths: [root] });
-      return true;
-    }
-  } catch {
-    return false;
+import { loadFile, writeFile as writeAstFile } from "magicast";
+
+// src/inject/strategies/vite.ts
+import { addVitePlugin } from "magicast/helpers";
+var ViteStrategy = class {
+  name = "Vite";
+  supports(tool) {
+    return tool === "vite";
   }
-}
-async function getResolvedPackageVersion(pkgName, root) {
-  try {
-    const require2 = createRequire(path3.join(root, "package.json"));
-    const pkgJsonPath = require2.resolve(`${pkgName}/package.json`, { paths: [root] });
-    const pkg = await readJSON(pkgJsonPath);
-    return pkg?.version || null;
-  } catch {
-    return null;
+  inject({ mod, detection }) {
+    addVitePlugin(mod, {
+      from: "@inspecto-dev/plugin",
+      constructor: "inspecto",
+      imported: "vitePlugin"
+    });
   }
-}
-var SUPPORTED_PATTERNS = [
-  {
-    tool: "vite",
-    files: [
-      "vite.config.ts",
-      "vite.config.js",
-      "vite.config.mts",
-      "vite.config.mjs",
-      "vite.config.cjs",
-      "vite.config.cts"
-    ],
-    label: "Vite"
-  },
-  {
-    tool: "rspack",
-    files: ["rspack.config.js", "rspack.config.ts", "rspack.config.mjs"],
-    label: "Rspack"
-  },
-  {
-    tool: "rsbuild",
-    files: ["rsbuild.config.js", "rsbuild.config.ts", "rsbuild.config.mjs"],
-    label: "Rsbuild"
-  },
-  {
-    tool: "webpack",
-    files: ["webpack.config.js", "webpack.config.ts", "webpack.config.mjs", "webpack.config.cjs"],
-    label: "Webpack"
-  },
-  {
-    tool: "esbuild",
-    files: ["esbuild.config.js", "esbuild.config.ts", "esbuild.config.mjs", "build.js", "build.ts"],
-    label: "esbuild"
-  },
-  {
-    tool: "rollup",
-    files: ["rollup.config.js", "rollup.config.ts", "rollup.config.mjs"],
-    label: "Rollup"
+  getManualInstructions(detection, reason) {
+    return [
+      `import { vitePlugin as inspecto } from '@inspecto-dev/plugin'`,
+      "",
+      "// Add to your plugins array:",
+      `plugins: [`,
+      `  process.env.NODE_ENV !== 'production' && inspecto(),`,
+      `  ...otherPlugins`,
+      `].filter(Boolean)`
+    ];
   }
-];
-var UNSUPPORTED_META = [
-  { name: "Next.js", dep: "next", files: ["next.config.mjs", "next.config.js", "next.config.ts"] },
-  { name: "Nuxt", dep: "nuxt", files: ["nuxt.config.ts", "nuxt.config.js"] },
-  { name: "Remix", dep: "@remix-run/dev", files: ["remix.config.js", "remix.config.ts"] },
-  { name: "Astro", dep: "astro", files: ["astro.config.mjs", "astro.config.ts"] },
-  { name: "SvelteKit", dep: "@sveltejs/kit", files: ["svelte.config.js", "svelte.config.ts"] }
-];
-function normalizeRelativePath(root, filePath) {
-  const relative = path3.relative(root, filePath);
-  const normalized = relative.split(path3.sep).join("/");
-  return normalized || path3.basename(filePath);
-}
-function createTargets(root, packagePaths) {
-  if (!packagePaths || packagePaths.length === 0) {
-    return [{ packagePath: "", absolutePath: root }];
+};
+
+// src/inject/strategies/webpack.ts
+var WebpackStrategy = class {
+  name = "Webpack";
+  supports(tool) {
+    return tool === "webpack";
   }
-  return packagePaths.map((pkg) => ({
-    packagePath: pkg,
-    absolutePath: pkg ? path3.join(root, pkg) : root
-  }));
-}
-async function detectBuildTools(root, packagePaths) {
-  const supported = [];
-  const unsupported = /* @__PURE__ */ new Set();
-  const targets = createTargets(root, packagePaths);
-  for (const target of targets) {
-    const pkg = await readJSON(path3.join(target.absolutePath, "package.json"));
-    const allDeps = { ...pkg?.dependencies, ...pkg?.devDependencies };
-    const scripts = pkg?.scripts || {};
-    const supportedChecks = SUPPORTED_PATTERNS.map(
-      (pattern) => detectPattern({
-        pattern,
-        workspaceRoot: root,
-        targetRoot: target.absolutePath,
-        packagePath: target.packagePath,
-        allDeps,
-        scripts
-      })
-    );
-    const supportedResults = await Promise.all(supportedChecks);
-    for (const result of supportedResults) {
-      if (result) {
-        supported.push(result);
-      }
-    }
-    const unsupportedChecks = UNSUPPORTED_META.map(async (meta) => {
-      if (!(meta.dep in allDeps)) return null;
-      for (const file of meta.files) {
-        if (await exists(path3.join(target.absolutePath, file))) {
-          return meta.name;
-        }
-      }
-      return null;
-    });
-    const unsupportedResults = await Promise.all(unsupportedChecks);
-    for (const result of unsupportedResults) {
-      if (result) {
-        unsupported.add(result);
-      }
-    }
+  inject(options) {
+    throw new Error("Webpack requires manual plugin configuration");
   }
-  return { supported, unsupported: Array.from(unsupported) };
-}
-async function detectPattern({
-  pattern,
-  workspaceRoot,
-  targetRoot,
-  packagePath,
-  allDeps,
-  scripts
-}) {
-  let hasDep;
-  let resolvedVersion = null;
-  if (pattern.tool === "rspack") {
-    const depName = allDeps["@rspack/cli"] ? "@rspack/cli" : "@rspack/core";
-    hasDep = !!allDeps["@rspack/cli"] || !!allDeps["@rspack/core"] || isPackageResolvable("@rspack/core", targetRoot);
-    if (hasDep) {
-      resolvedVersion = allDeps[depName] || await getResolvedPackageVersion("@rspack/core", targetRoot);
-    }
-  } else if (pattern.tool === "webpack") {
-    const depName = allDeps["webpack"] ? "webpack" : "webpack-cli";
-    hasDep = !!allDeps["webpack"] || !!allDeps["webpack-cli"] || isPackageResolvable("webpack", targetRoot);
-    if (hasDep) {
-      resolvedVersion = allDeps[depName] || await getResolvedPackageVersion("webpack", targetRoot);
-    }
-  } else if (pattern.tool === "rsbuild") {
-    hasDep = !!allDeps["@rsbuild/core"] || isPackageResolvable("@rsbuild/core", targetRoot);
-  } else {
-    hasDep = !!allDeps[pattern.tool] || isPackageResolvable(pattern.tool, targetRoot);
+  getManualInstructions(detection, reason) {
+    const importPkg = detection.isLegacyWebpack ? "@inspecto-dev/plugin/legacy/webpack4" : "@inspecto-dev/plugin";
+    const pluginName = detection.isLegacyWebpack ? "webpack4Plugin" : "webpackPlugin";
+    const pluginCall = detection.isLegacyWebpack ? `process.env.NODE_ENV !== 'production' && inspecto({
+      pathType: 'absolute',
+      escapeTags: ['Transition', 'AnimatePresence'],
+    })` : `process.env.NODE_ENV !== 'production' && inspecto()`;
+    return [
+      `import { ${pluginName} as inspecto } from '${importPkg}'`,
+      "",
+      "// Add to your plugins array:",
+      `plugins: [`,
+      `  ${pluginCall},`,
+      `  ...otherPlugins`,
+      `].filter(Boolean)`
+    ];
   }
-  let detectedFile = "";
-  if (pattern.tool === "esbuild" && !hasDep) {
-    return null;
+};
+
+// src/inject/strategies/rspack.ts
+var RspackStrategy = class {
+  name = "Rspack";
+  supports(tool) {
+    return tool === "rspack";
   }
-  for (const file of pattern.files) {
-    if (await exists(path3.join(targetRoot, file))) {
-      detectedFile = file;
-      break;
-    }
+  inject(options) {
+    throw new Error("Rspack requires manual plugin configuration");
   }
-  if (hasDep && !detectedFile && (pattern.tool === "esbuild" || pattern.tool === "rollup" || pattern.tool === "webpack" || pattern.tool === "rspack" || pattern.tool === "rsbuild")) {
-    for (const cmd of Object.values(scripts)) {
-      if (cmd.includes("node ")) {
-        const match = cmd.match(/node\s+([^\s]+\.(js|mjs|cjs|ts))/);
-        if (match && match[1]) {
-          if (await exists(path3.join(targetRoot, match[1]))) {
-            if (cmd.includes(pattern.tool) || match[1].includes(pattern.tool)) {
-              detectedFile = match[1];
-              break;
-            }
-          }
-        }
-      } else if (cmd.includes(`${pattern.tool} `)) {
-        if (pattern.tool === "webpack" || pattern.tool === "rspack") {
-          const configMatch = cmd.match(/--config\s+([^\s]+)/);
-          if (configMatch && configMatch[1]) {
-            if (await exists(path3.join(targetRoot, configMatch[1]))) {
-              detectedFile = configMatch[1];
-              break;
-            }
-          }
-        }
-        if (!detectedFile) {
-          detectedFile = "package.json (scripts)";
-          break;
-        }
+  getManualInstructions(detection, reason) {
+    const importPkg = detection.isLegacyRspack ? "@inspecto-dev/plugin/legacy/rspack" : "@inspecto-dev/plugin";
+    const pluginCall = detection.isLegacyRspack ? `process.env.NODE_ENV !== 'production' && inspecto({
+      pathType: 'absolute',
+      escapeTags: ['Transition', 'AnimatePresence'],
+    })` : `process.env.NODE_ENV !== 'production' && inspecto()`;
+    return [
+      `import { rspackPlugin as inspecto } from '${importPkg}'`,
+      "",
+      "// Add to your plugins array:",
+      `plugins: [`,
+      `  ${pluginCall},`,
+      `  ...otherPlugins`,
+      `].filter(Boolean)`
+    ];
+  }
+};
+
+// src/inject/strategies/rsbuild.ts
+var RsbuildStrategy = class {
+  name = "Rsbuild";
+  supports(tool) {
+    return tool === "rsbuild";
+  }
+  inject(options) {
+    throw new Error("Rsbuild requires manual plugin configuration due to nested structure");
+  }
+  getManualInstructions(detection, reason) {
+    return [
+      `import { rspackPlugin as inspecto } from '@inspecto-dev/plugin'`,
+      "",
+      "// Add to tools.rspack:",
+      `tools: {`,
+      `  rspack: {`,
+      `    plugins: [`,
+      `      process.env.NODE_ENV !== 'production' && inspecto(),`,
+      `    ]`,
+      `  }`,
+      `}`
+    ];
+  }
+};
+
+// src/inject/strategies/esbuild.ts
+var EsbuildStrategy = class {
+  name = "esbuild";
+  supports(tool) {
+    return tool === "esbuild";
+  }
+  inject(options) {
+    throw new Error("Esbuild requires manual plugin configuration");
+  }
+  getManualInstructions(detection, reason) {
+    return [
+      `1. Update your esbuild config (${detection.configPath}):`,
+      `import { esbuildPlugin as inspecto } from '@inspecto-dev/plugin'`,
+      "",
+      "// Add to your plugins array:",
+      `plugins: [`,
+      `  process.env.NODE_ENV !== 'production' && inspecto(),`,
+      `  ...otherPlugins`,
+      `].filter(Boolean)`,
+      "",
+      "2. Initialize the client in your app entry (e.g., main.js / index.js):",
+      `import { mountInspector } from '@inspecto-dev/core'`,
+      "",
+      "// Call this before your app renders",
+      `if (process.env.NODE_ENV !== 'production') {`,
+      `  mountInspector()`,
+      `}`
+    ];
+  }
+};
+
+// src/inject/strategies/rollup.ts
+var RollupStrategy = class {
+  name = "Rollup";
+  supports(tool) {
+    return tool === "rollup";
+  }
+  inject(options) {
+    throw new Error("Rollup requires manual plugin configuration");
+  }
+  getManualInstructions(detection, reason) {
+    return [
+      `1. Update your rollup config (${detection.configPath}):`,
+      `import { rollupPlugin as inspecto } from '@inspecto-dev/plugin'`,
+      "",
+      "// Add to your plugins array:",
+      `plugins: [`,
+      `  process.env.NODE_ENV !== 'production' && inspecto(),`,
+      `  ...otherPlugins`,
+      `].filter(Boolean)`,
+      "",
+      "2. Initialize the client in your app entry (e.g., main.js / index.js):",
+      `import { mountInspector } from '@inspecto-dev/core'`,
+      "",
+      "// Call this before your app renders",
+      `if (process.env.NODE_ENV !== 'production') {`,
+      `  mountInspector()`,
+      `}`
+    ];
+  }
+};
+
+// src/inject/strategies/index.ts
+var STRATEGIES = [
+  new ViteStrategy(),
+  new WebpackStrategy(),
+  new RspackStrategy(),
+  new RsbuildStrategy(),
+  new EsbuildStrategy(),
+  new RollupStrategy()
+];
+
+// src/inject/ast-injector.ts
+function printManualInstructions(strategy, detection, reason) {
+  log.warn(`Could not automatically configure ${detection.configPath}`);
+  log.hint(`(reason: ${reason})`);
+  log.blank();
+  log.hint("Please add the following manually:");
+  if (strategy) {
+    const instructions = strategy.getManualInstructions(detection, reason);
+    log.copyableCodeBlock(instructions);
+  } else {
+    log.error(`Unsupported build tool: ${detection.tool}`);
+  }
+}
+function isAlreadyInjected(content) {
+  const normalized = content.replace(/\s+/g, " ");
+  const importPlugin = /import\s+(.+?)\s+from\s+['"]@inspecto-dev\/plugin['"]/g;
+  const requirePlugin = /require\(['"]@inspecto-dev\/plugin['"]\)/;
+  const legacyImport = /import\s+.*ai-dev-inspector/.test(normalized);
+  const legacyRequire = /require\(['"]ai-dev-inspector['"]\)/.test(normalized);
+  if (legacyImport || legacyRequire || requirePlugin.test(normalized)) return true;
+  let match;
+  importPlugin.lastIndex = 0;
+  while (match = importPlugin.exec(normalized)) {
+    const importClause = match[1] || "";
+    if (/inspecto/.test(importClause) || /vitePlugin/.test(importClause)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function injectPlugin(root, detection, dryRun) {
+  const configPath = path3.join(root, detection.configPath);
+  const mutations = [];
+  const strategy = STRATEGIES.find((s) => s.supports(detection.tool));
+  const content = await readFile(configPath);
+  if (!content) {
+    printManualInstructions(strategy, detection, "config file not readable");
+    return { success: false, mutations, failureReason: "config file not readable" };
+  }
+  if (isAlreadyInjected(content)) {
+    log.success(`Plugin already configured in ${detection.configPath} (skipped)`);
+    mutations.push({
+      type: "file_modified",
+      path: detection.configPath,
+      description: "Previously configured inspecto() plugin"
+    });
+    return { success: true, mutations };
+  }
+  if (!strategy) {
+    printManualInstructions(
+      strategy,
+      detection,
+      `No injection strategy found for ${detection.tool}`
+    );
+    return { success: false, mutations, failureReason: "No strategy found" };
+  }
+  if (dryRun) {
+    log.dryRun(`Would automatically configure plugin in ${detection.configPath}`);
+    return { success: true, mutations: [] };
+  }
+  try {
+    const mod = await loadFile(configPath);
+    strategy.inject({
+      mod,
+      detection
+    });
+    await writeAstFile(mod, configPath);
+    mutations.push({
+      type: "file_modified",
+      path: detection.configPath,
+      description: "Automatically configured inspecto() plugin"
+    });
+    log.success(`Configured plugin in ${detection.configPath}`);
+    return { success: true, mutations };
+  } catch (err) {
+    printManualInstructions(
+      strategy,
+      detection,
+      `Automatic configuration unavailable: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return {
+      success: false,
+      mutations,
+      failureReason: "Automatic configuration unavailable"
+    };
+  }
+}
+
+// src/utils/exec.ts
+import { execFile, exec as execCb } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var execAsync = promisify(execCb);
+async function run(command, args, cwd) {
+  const result = await execFileAsync(command, args, {
+    cwd,
+    timeout: 6e4,
+    env: { ...process.env }
+  });
+  return { stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
+}
+async function shell(command, cwd) {
+  const result = await execAsync(command, {
+    cwd,
+    timeout: 6e4,
+    env: { ...process.env }
+  });
+  return { stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
+}
+async function which(bin) {
+  try {
+    const cmd = process.platform === "win32" ? "where" : "which";
+    await run(cmd, [bin]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/inject/extension.ts
+var EXTENSION_ID = "inspecto.inspecto";
+var VSCODE_PATHS = {
+  darwin: [
+    "/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code",
+    "/Applications/Visual Studio Code - Insiders.app/Contents/Resources/app/bin/code-insiders",
+    `${process.env.HOME}/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code`
+  ],
+  linux: ["/usr/bin/code", "/usr/share/code/bin/code", "/snap/bin/code", "/usr/bin/code-insiders"],
+  win32: [
+    `${process.env.LOCALAPPDATA}\\Programs\\Microsoft VS Code\\bin\\code.cmd`,
+    `${process.env.LOCALAPPDATA}\\Programs\\Microsoft VS Code Insiders\\bin\\code-insiders.cmd`,
+    `${process.env.PROGRAMFILES}\\Microsoft VS Code\\bin\\code.cmd`
+  ]
+};
+async function findVSCodeBinary() {
+  const platform = process.platform;
+  const candidates = VSCODE_PATHS[platform] || [];
+  for (const candidate of candidates) {
+    if (await exists(candidate)) {
+      return candidate;
+    }
+  }
+  if (await which("code-insiders")) {
+    return "code-insiders";
+  }
+  return null;
+}
+async function tryOpenURI(uri) {
+  try {
+    const platform = process.platform;
+    if (platform === "win32") {
+      await shell(`cmd /c start "" "${uri}"`);
+    } else {
+      const openCmd = platform === "darwin" ? "open" : "xdg-open";
+      await shell(`${openCmd} "${uri}"`);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installExtension(dryRun, ide) {
+  if (dryRun) {
+    log.dryRun("Would attempt to install VS Code extension");
+    return null;
+  }
+  const isVSCode = !ide || ide === "vscode";
+  if (isVSCode) {
+    if (await which("code")) {
+      try {
+        await run("code", ["--install-extension", EXTENSION_ID]);
+        log.success("VS Code extension installed via CLI");
+        return { type: "extension_installed", id: EXTENSION_ID };
+      } catch {
+      }
+    }
+    const codePath = await findVSCodeBinary();
+    if (codePath) {
+      try {
+        await run(codePath, ["--install-extension", EXTENSION_ID]);
+        log.success("VS Code extension installed via binary path");
+        log.info(
+          'Tip: Add "code" to your PATH to help Inspecto detect other AI tools in the future'
+        );
+        return { type: "extension_installed", id: EXTENSION_ID };
+      } catch {
+      }
+    }
+    const uri = `vscode:extension/${EXTENSION_ID}`;
+    if (await tryOpenURI(uri)) {
+      log.warn("Opened extension page in VS Code");
+      log.hint('Please click "Install" in the opened VS Code window to complete setup.');
+      return { type: "extension_installed", id: EXTENSION_ID, manual_action_required: true };
+    }
+    log.warn("Could not auto-install VS Code extension");
+    log.hint("Please install it manually to enable Inspector features:");
+    log.hint("  1. Open VS Code");
+    log.hint("  2. Press Ctrl+Shift+X (or Cmd+Shift+X)");
+    log.hint('  3. Search for "Inspecto"');
+    log.hint(`  Or visit: https://marketplace.visualstudio.com/items?itemName=${EXTENSION_ID}`);
+    return null;
+  }
+  log.warn(`Could not auto-install extension for ${ide}`);
+  log.hint("Please install it manually to enable Inspector features:");
+  log.hint("  1. Download the latest .vsix file (Open VSX: https://open-vsx.org/extension/inspecto/inspecto)");
+  log.hint(`  2. Open ${ide}`);
+  log.hint("  3. Open the Command Palette (Ctrl+Shift+P or Cmd+Shift+P)");
+  log.hint('  4. Type and select "Extensions: Install from VSIX..."');
+  log.hint("  5. Select the downloaded .vsix file");
+  return null;
+}
+async function isExtensionInstalled() {
+  try {
+    if (await which("code")) {
+      const { stdout } = await run("code", ["--list-extensions"]);
+      return stdout.toLowerCase().includes(EXTENSION_ID);
+    }
+    const codePath = await findVSCodeBinary();
+    if (codePath) {
+      const { stdout } = await run(codePath, ["--list-extensions"]);
+      return stdout.toLowerCase().includes(EXTENSION_ID);
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+// src/inject/gitignore.ts
+import path4 from "path";
+var DEFAULT_RULES = [".inspecto/install.lock", ".inspecto/cache.json", ".inspecto/*.local.json"];
+var SHARED_RULES = [".inspecto/install.lock", ".inspecto/cache.json", ".inspecto/*.local.json"];
+async function updateGitignore(root, shared, dryRun) {
+  const gitignorePath = path4.join(root, ".gitignore");
+  let content = await readFile(gitignorePath) ?? "";
+  const desiredRules = shared ? SHARED_RULES : DEFAULT_RULES;
+  const hasGlobalRule = content.match(/^\.inspecto\/\s*$/m) !== null;
+  if (hasGlobalRule) {
+    content = content.replace(/^\.inspecto\/\s*$/gm, SHARED_RULES.join("\n"));
+    if (!dryRun) {
+      await writeFile(gitignorePath, content);
+    }
+    log.success("Updated .gitignore: .inspecto/ is no longer fully ignored");
+    return;
+  }
+  const missingRules = desiredRules.filter((rule) => !content.includes(rule));
+  if (missingRules.length === 0) {
+    return;
+  }
+  const section = "\n# Inspecto\n" + missingRules.join("\n") + "\n";
+  content = content.trimEnd() + "\n" + section;
+  if (dryRun) {
+    log.dryRun(`Would update .gitignore with: ${missingRules.join(", ")}`);
+  } else {
+    await writeFile(gitignorePath, content);
+    log.success("Updated .gitignore");
+  }
+}
+async function cleanGitignore(root) {
+  const gitignorePath = path4.join(root, ".gitignore");
+  const content = await readFile(gitignorePath);
+  if (!content) return;
+  const cleaned = content.replace(/^# Inspecto\s*$/m, "").replace(/^\.inspecto\/?\s*$/gm, "").replace(/^\.inspecto\/install\.lock\s*$/gm, "").replace(/^\.inspecto\/cache\.json\s*$/gm, "").replace(/^\.inspecto\/\*\.local\.json\s*$/gm, "").replace(/\n{3,}/g, "\n\n");
+  await writeFile(gitignorePath, cleaned);
+}
+
+// src/onboarding/apply.ts
+function resultStatus(nextSteps) {
+  return nextSteps.length > 0 ? "warning" : "ok";
+}
+function manualPlanSteps(plan2) {
+  return [
+    ...plan2.blockers.map((blocker) => blocker.message),
+    ...plan2.actions.filter((action) => action.type === "manual_step").map((action) => action.description)
+  ];
+}
+async function applyOnboardingPlan(input) {
+  return applyOnboardingPlanInternal(input);
+}
+function createReporter(quiet = false) {
+  if (quiet) {
+    return {
+      warn() {
+      },
+      success() {
+      },
+      error() {
+      },
+      hint() {
+      },
+      dryRun() {
       }
+    };
+  }
+  return {
+    warn(text) {
+      log.warn(text);
+    },
+    success(text) {
+      log.success(text);
+    },
+    error(text) {
+      log.error(text);
+    },
+    hint(text) {
+      log.hint(text);
+    },
+    dryRun(text) {
+      log.dryRun(text);
     }
+  };
+}
+function createSpinner(text, quiet = false) {
+  if (quiet) {
+    return {
+      start() {
+      },
+      succeed() {
+      },
+      fail() {
+      }
+    };
   }
-  if (!detectedFile) {
-    return null;
+  const spinner = ora(text);
+  return {
+    start() {
+      spinner.start();
+    },
+    succeed(successText) {
+      spinner.succeed(successText);
+    },
+    fail(failureText) {
+      spinner.fail(failureText);
+    }
+  };
+}
+async function applyOnboardingPlanInternal(input) {
+  const reporter = createReporter(input.options.quiet);
+  if (input.plan && input.plan.strategy !== "supported" && !input.allowManualPlanApply) {
+    return {
+      status: input.plan.status,
+      mutations: [],
+      postInstall: {
+        installFailed: false,
+        injectionFailed: false,
+        manualExtensionInstallNeeded: false,
+        nextSteps: manualPlanSteps(input.plan)
+      }
+    };
   }
-  let isLegacyRspack = false;
-  let isLegacyWebpack = false;
-  if (pattern.tool === "rspack") {
-    const version = resolvedVersion;
-    if (version && (version.includes("0.3.") || version.includes("0.2.") || version.includes("0.1."))) {
-      isLegacyRspack = true;
+  const mutations = [];
+  const settingsDir = path5.join(input.projectRoot, ".inspecto");
+  const settingsFileName = input.options.shared ? "settings.json" : "settings.local.json";
+  const promptsFileName = input.options.shared ? "prompts.json" : "prompts.local.json";
+  const settingsPath = path5.join(settingsDir, settingsFileName);
+  const promptsPath = path5.join(settingsDir, promptsFileName);
+  const installCmd = getInstallCommand(
+    input.packageManager,
+    "@inspecto-dev/plugin @inspecto-dev/core"
+  );
+  const nextSteps = [];
+  let installFailed = false;
+  if (input.options.skipInstall) {
+    reporter.warn("Skipping dependency installation (--skip-install)");
+  } else if (input.options.dryRun) {
+    reporter.dryRun(`Would run: ${installCmd}`);
+  } else {
+    const spinner = createSpinner(
+      `Installing devDependencies via: ${installCmd}`,
+      input.options.quiet
+    );
+    try {
+      spinner.start();
+      await shell(installCmd, input.projectRoot);
+      spinner.succeed("Dependencies installed successfully");
+      reporter.success("Installed @inspecto-dev/plugin and @inspecto-dev/core as devDependencies");
+      mutations.push({ type: "dependency_added", name: "@inspecto-dev/plugin", dev: true });
+      mutations.push({ type: "dependency_added", name: "@inspecto-dev/core", dev: true });
+    } catch (error) {
+      spinner.fail("Dependency installation failed");
+      installFailed = true;
+      reporter.error(`Failed to install dependency: ${error?.message || "Unknown error"}`);
+      reporter.hint(`Run manually in ${input.projectRoot}: ${installCmd}`);
+      reporter.hint(
+        "Setup will continue without dependencies, but Inspecto may not run until installation succeeds."
+      );
     }
-  } else if (pattern.tool === "webpack") {
-    const version = resolvedVersion;
-    if (version && version.includes("^4") || version?.startsWith("4.")) {
-      isLegacyWebpack = true;
+  }
+  let injectionFailed = Boolean(input.injectionSkippedRequiresManualConfig);
+  for (const target of input.supportedBuildTargets) {
+    const result = await injectPlugin(input.repoRoot, target, input.options.dryRun);
+    if (result.success) {
+      mutations.push(...result.mutations);
+    } else {
+      injectionFailed = true;
+    }
+  }
+  if (await exists(settingsPath)) {
+    const existingSettings = await readJSON(settingsPath);
+    if (existingSettings === null) {
+      reporter.warn(`.inspecto/${settingsFileName} exists but contains invalid JSON`);
+      reporter.hint("Please fix the syntax errors manually, or delete it and re-run init");
+      nextSteps.push(`Fix .inspecto/${settingsFileName} or delete it and rerun Inspecto setup.`);
+    } else {
+      reporter.success(`.inspecto/${settingsFileName} already exists (skipped)`);
+    }
+  } else {
+    const defaultSettings = {};
+    if (input.selectedIDE?.supported) {
+      defaultSettings.ide = input.selectedIDE.ide.toLowerCase() === "vscode" ? "vscode" : input.selectedIDE.ide.toLowerCase();
+    }
+    if (input.providerDefault) {
+      defaultSettings["provider.default"] = input.providerDefault;
+    }
+    if (input.options.dryRun) {
+      reporter.dryRun(`Would create .inspecto/${settingsFileName}`);
+    } else {
+      await writeJSON(settingsPath, defaultSettings);
+      reporter.success(`Created .inspecto/${settingsFileName}`);
+      mutations.push({ type: "file_created", path: `.inspecto/${settingsFileName}` });
+    }
+  }
+  if (await exists(promptsPath)) {
+    reporter.success(`.inspecto/${promptsFileName} already exists (skipped)`);
+  } else if (input.options.dryRun) {
+    reporter.dryRun(`Would create .inspecto/${promptsFileName}`);
+  } else {
+    await writeJSON(promptsPath, []);
+    reporter.success(`Created .inspecto/${promptsFileName}`);
+    mutations.push({ type: "file_created", path: `.inspecto/${promptsFileName}` });
+  }
+  if (!input.options.dryRun) {
+    await updateGitignore(input.projectRoot, input.options.shared, input.options.dryRun);
+    mutations.push({
+      type: "file_modified",
+      path: ".gitignore",
+      description: "Appended .inspecto/ ignore rules"
+    });
+  } else {
+    reporter.dryRun("Would update .gitignore");
+  }
+  if (!input.options.dryRun && mutations.length > 0) {
+    const lock = {
+      version: "1.0.0",
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      mutations
+    };
+    await writeJSON(path5.join(settingsDir, "install.lock"), lock);
+  }
+  const shouldInstallExt = !input.options.noExtension && (!input.selectedIDE || input.selectedIDE.supported);
+  let manualExtensionInstallNeeded = false;
+  if (input.options.noExtension) {
+    reporter.warn("Skipping IDE extension (--no-extension)");
+  } else if (shouldInstallExt) {
+    const extMutation = await installExtension(input.options.dryRun, input.selectedIDE?.ide);
+    if (extMutation && !input.options.dryRun) {
+      mutations.push(extMutation);
+      if (extMutation.manual_action_required) {
+        manualExtensionInstallNeeded = true;
+      }
+      const lockPath = path5.join(settingsDir, "install.lock");
+      const lock = await readJSON(lockPath);
+      if (lock) {
+        lock.mutations = mutations;
+        await writeJSON(lockPath, lock);
+      }
+    } else if (extMutation === null && !input.options.dryRun) {
+      manualExtensionInstallNeeded = true;
+    }
+  }
+  if (!input.options.dryRun) {
+    if (installFailed) {
+      nextSteps.push(`Install dependencies manually in ${input.projectRoot}: ${installCmd}`);
+    }
+    if (injectionFailed) {
+      nextSteps.push(
+        "Plugin injection skipped. Follow manual instructions printed above to update your config."
+      );
+    }
+    if (manualExtensionInstallNeeded) {
+      nextSteps.push("Install the Inspecto IDE extension manually");
+    }
+    if (input.manualConfigRequiredFor === "Nuxt") {
+      nextSteps.push(
+        "Nuxt detected\u2014please follow the Nuxt instructions printed above to finish setup."
+      );
+    } else if (input.manualConfigRequiredFor === "Next.js") {
+      nextSteps.push(
+        "Next.js detected\u2014please follow the Next.js instructions printed above to finish setup."
+      );
     }
   }
-  const absoluteConfig = path3.join(targetRoot, detectedFile);
-  const relativeConfig = normalizeRelativePath(workspaceRoot, absoluteConfig);
   return {
-    tool: pattern.tool,
-    configPath: relativeConfig,
-    label: `${pattern.label} (${relativeConfig})${isLegacyRspack ? " [Legacy]" : ""}${isLegacyWebpack ? " [Webpack 4]" : ""}`,
-    isLegacyRspack,
-    isLegacyWebpack,
-    packagePath: packagePath || void 0
+    status: resultStatus(nextSteps),
+    mutations,
+    postInstall: {
+      installFailed,
+      injectionFailed,
+      manualExtensionInstallNeeded,
+      nextSteps
+    }
   };
 }
-function resolveInjectionTarget(detections) {
-  if (detections.length === 0) return null;
-  if (detections.length === 1) return detections[0];
-  return "ambiguous";
-}
 
-// src/detect/framework.ts
-import path4 from "path";
-import { createRequire as createRequire2 } from "module";
-var META_FRAMEWORK_MAP = {
-  next: "react",
-  nuxt: "vue",
-  "@remix-run/react": "react",
-  "@remix-run/dev": "react",
-  "@vue/nuxt": "vue",
-  "vite-plugin-vue": "vue",
-  "@vitejs/plugin-vue": "vue",
-  "@vitejs/plugin-react": "react",
-  "@vitejs/plugin-react-swc": "react"
-};
-var SUPPORTED_FRAMEWORKS = [
-  { framework: "react", deps: ["react", "react-dom"] },
-  { framework: "vue", deps: ["vue"] }
-];
-var UNSUPPORTED_FRAMEWORKS = [
-  { name: "Solid", dep: "solid-js" },
-  { name: "Svelte", dep: "svelte" },
-  { name: "Angular", dep: "@angular/core" },
-  { name: "Preact", dep: "preact" },
-  { name: "Lit", dep: "lit" }
-];
-function isPackageResolvable2(pkgName, root) {
+// src/detect/build-tool.ts
+import path6 from "path";
+import fs2 from "fs/promises";
+import { createRequire } from "module";
+function isPackageResolvable(pkgName, root) {
   try {
-    const require2 = createRequire2(path4.join(root, "package.json"));
+    const require2 = createRequire(path6.join(root, "package.json"));
     try {
       require2.resolve(`${pkgName}/package.json`, { paths: [root] });
       return true;
@@ -442,579 +890,878 @@ function isPackageResolvable2(pkgName, root) {
     return false;
   }
 }
-async function detectFrameworks(root) {
-  const pkg = await readJSON(path4.join(root, "package.json"));
-  const allDeps = {
-    ...pkg?.dependencies || {},
-    ...pkg?.devDependencies || {},
-    ...pkg?.peerDependencies || {}
-  };
-  const supportedSet = /* @__PURE__ */ new Set();
-  const unsupported = [];
-  const isTest = root.includes("/mock/root");
-  for (const [metaPkg, framework] of Object.entries(META_FRAMEWORK_MAP)) {
-    if (metaPkg in allDeps || !isTest && isPackageResolvable2(metaPkg, root)) {
-      supportedSet.add(framework);
-    }
-  }
-  for (const { framework, deps } of SUPPORTED_FRAMEWORKS) {
-    if (supportedSet.has(framework)) continue;
-    for (const dep of deps) {
-      if (dep in allDeps || !isTest && isPackageResolvable2(dep, root)) {
-        supportedSet.add(framework);
-        break;
-      }
-    }
-  }
-  for (const fw of UNSUPPORTED_FRAMEWORKS) {
-    if (fw.dep in allDeps || !isTest && isPackageResolvable2(fw.dep, root)) {
-      unsupported.push(fw);
-    }
+async function getResolvedPackageVersion(pkgName, root) {
+  try {
+    const require2 = createRequire(path6.join(root, "package.json"));
+    const pkgJsonPath = require2.resolve(`${pkgName}/package.json`, { paths: [root] });
+    const pkg = await readJSON(pkgJsonPath);
+    return pkg?.version || null;
+  } catch {
+    return null;
   }
-  return {
-    supported: Array.from(supportedSet),
-    unsupported
-  };
 }
-
-// src/detect/ide.ts
-import path5 from "path";
-var SUPPORTED_IDE = "vscode";
-async function detectIDE(root) {
-  const detected = /* @__PURE__ */ new Map();
-  if (process.env.CURSOR_TRACE_DIR || process.env.CURSOR_CHANNEL) {
-    detected.set("Cursor", { ide: "cursor", supported: true });
-  }
-  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.set("Trae", { ide: "trae", supported: true });
+var SUPPORTED_PATTERNS = [
+  {
+    tool: "vite",
+    files: [
+      "vite.config.ts",
+      "vite.config.js",
+      "vite.config.mts",
+      "vite.config.mjs",
+      "vite.config.cjs",
+      "vite.config.cts"
+    ],
+    label: "Vite"
+  },
+  {
+    tool: "rspack",
+    files: ["rspack.config.js", "rspack.config.ts", "rspack.config.mjs"],
+    label: "Rspack"
+  },
+  {
+    tool: "rsbuild",
+    files: ["rsbuild.config.js", "rsbuild.config.ts", "rsbuild.config.mjs"],
+    label: "Rsbuild"
+  },
+  {
+    tool: "webpack",
+    files: ["webpack.config.js", "webpack.config.ts", "webpack.config.mjs", "webpack.config.cjs"],
+    label: "Webpack"
+  },
+  {
+    tool: "esbuild",
+    files: ["esbuild.config.js", "esbuild.config.ts", "esbuild.config.mjs", "build.js", "build.ts"],
+    label: "esbuild"
+  },
+  {
+    tool: "rollup",
+    files: ["rollup.config.js", "rollup.config.ts", "rollup.config.mjs"],
+    label: "Rollup"
   }
-  if (process.env.ZED_TERM) {
-    detected.set("Zed", { ide: "Zed", supported: false });
+];
+var UNSUPPORTED_META = [
+  { name: "Next.js", dep: "next", files: ["next.config.mjs", "next.config.js", "next.config.ts"] },
+  { name: "Nuxt", dep: "nuxt", files: ["nuxt.config.ts", "nuxt.config.js"] },
+  { name: "Remix", dep: "@remix-run/dev", files: ["remix.config.js", "remix.config.ts"] },
+  { name: "Astro", dep: "astro", files: ["astro.config.mjs", "astro.config.ts"] },
+  { name: "SvelteKit", dep: "@sveltejs/kit", files: ["svelte.config.js", "svelte.config.ts"] }
+];
+function normalizeRelativePath(root, filePath) {
+  const relative = path6.relative(root, filePath);
+  const normalized = relative.split(path6.sep).join("/");
+  return normalized || path6.basename(filePath);
+}
+function createTargets(root, packagePaths) {
+  if (!packagePaths || packagePaths.length === 0) {
+    return [{ packagePath: "", absolutePath: root }];
   }
-  if (process.env.WINDSURF_APP_DIR || process.env.WINDSURF_CHANNEL || process.env.__CFBundleIdentifier === "com.codeium.windsurf" || process.env.npm_config_user_agent && process.env.npm_config_user_agent.includes("windsurf")) {
-    detected.set("Windsurf", { ide: "Windsurf", supported: false });
+  return packagePaths.map((pkg) => ({
+    packagePath: pkg,
+    absolutePath: pkg ? path6.join(root, pkg) : root
+  }));
+}
+async function getWorkspacePackagePatterns(root) {
+  const pkg = await readJSON(
+    path6.join(root, "package.json")
+  );
+  const workspaces = pkg?.workspaces;
+  if (Array.isArray(workspaces)) {
+    return workspaces;
+  }
+  if (workspaces && Array.isArray(workspaces.packages)) {
+    return workspaces.packages;
+  }
+  const pnpmWorkspace = await readFile(path6.join(root, "pnpm-workspace.yaml"));
+  if (!pnpmWorkspace) {
+    return [];
+  }
+  const patterns = [];
+  for (const line of pnpmWorkspace.split("\n")) {
+    const match = line.match(/^\s*-\s*['"]?([^'"]+)['"]?\s*$/);
+    if (match?.[1]) {
+      patterns.push(match[1]);
+    }
   }
-  const [hasTrae, hasCursor, hasVscode, hasIdea] = await Promise.all([
-    exists(path5.join(root, ".trae")),
-    exists(path5.join(root, ".cursor")),
-    exists(path5.join(root, ".vscode")),
-    exists(path5.join(root, ".idea"))
-  ]);
-  if (hasTrae && !detected.has("Trae")) {
-    detected.set("Trae", { ide: "trae", supported: true });
+  return patterns;
+}
+async function expandWorkspacePattern(root, pattern) {
+  const normalized = pattern.replace(/\\/g, "/").replace(/\/$/, "");
+  if (!normalized || normalized.startsWith("!")) {
+    return [];
   }
-  if (hasCursor && !detected.has("Cursor")) {
-    detected.set("Cursor", { ide: "cursor", supported: true });
+  if (!normalized.includes("*")) {
+    return await exists(path6.join(root, normalized)) ? [normalized] : [];
   }
-  if (hasVscode && !detected.has("vscode")) {
-    detected.set("vscode", { ide: SUPPORTED_IDE, supported: true });
+  const starIndex = normalized.indexOf("*");
+  const baseDir = normalized.slice(0, starIndex).replace(/\/$/, "");
+  const suffix = normalized.slice(starIndex + 1);
+  if (suffix && suffix !== "") {
+    return [];
   }
-  if (hasIdea && !detected.has("JetBrains IDE")) {
-    detected.set("JetBrains IDE", { ide: "JetBrains IDE", supported: false });
+  const absoluteBaseDir = path6.join(root, baseDir);
+  if (!await exists(absoluteBaseDir)) {
+    return [];
   }
-  if (detected.size === 0 && process.env.TERM_PROGRAM === "vscode") {
-    detected.set("vscode", { ide: SUPPORTED_IDE, supported: true });
+  try {
+    const entries = await fs2.readdir(absoluteBaseDir, { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => path6.posix.join(baseDir, entry.name));
+  } catch {
+    return [];
   }
-  return {
-    detected: Array.from(detected.values())
-  };
 }
-
-// src/detect/provider.ts
-import path6 from "path";
-var KNOWN_CLI_TOOLS = [
-  { id: "claude-code", bin: "claude", label: "Claude Code", supported: true },
-  { id: "coco", bin: "coco", label: "Trae CLI (Coco)", supported: true },
-  { id: "codex", bin: "codex", label: "Codex CLI", supported: true },
-  { id: "gemini", bin: "gemini", label: "Gemini CLI", supported: true }
-];
-var KNOWN_IDE_PLUGINS = [
-  { id: "claude-code", extId: "anthropic.claude-code", label: "Claude Code", supported: true },
-  { id: "copilot", extId: "github.copilot", label: "GitHub Copilot", supported: true },
-  { id: "codex", extId: "openai.chatgpt", label: "Codex (ChatGPT)", supported: true },
-  { id: "gemini", extId: "google.geminicodeassist", label: "Gemini Code Assist", supported: true }
-];
-async function detectProviders(root) {
-  const detectedMap = /* @__PURE__ */ new Map();
-  const cliChecks = KNOWN_CLI_TOOLS.map(async (tool) => {
-    if (await which(tool.bin)) {
-      detectedMap.set(tool.id, {
-        id: tool.id,
-        label: tool.label,
-        supported: tool.supported,
-        providerModes: ["cli"],
-        preferredMode: "cli"
-      });
+async function detectWorkspaceTargets(root) {
+  const patterns = await getWorkspacePackagePatterns(root);
+  if (patterns.length === 0) {
+    return [];
+  }
+  const packagePaths = /* @__PURE__ */ new Set();
+  for (const pattern of patterns) {
+    const expanded = await expandWorkspacePattern(root, pattern);
+    for (const packagePath of expanded) {
+      packagePaths.add(packagePath);
     }
-  });
-  await Promise.all(cliChecks);
-  const extensionsJsonPath = path6.join(root, ".vscode", "extensions.json");
-  let recommendedExts = [];
-  if (await exists(extensionsJsonPath)) {
-    try {
-      const extData = await readJSON(extensionsJsonPath);
-      if (extData && Array.isArray(extData.recommendations)) {
-        recommendedExts = extData.recommendations.map((e) => e.toLowerCase());
+  }
+  return Array.from(packagePaths).map((packagePath) => ({
+    packagePath,
+    absolutePath: path6.join(root, packagePath)
+  }));
+}
+async function detectBuildTools(root, packagePaths) {
+  const supported = [];
+  const unsupported = /* @__PURE__ */ new Set();
+  const explicitTargets = createTargets(root, packagePaths);
+  const workspaceTargets = !packagePaths || packagePaths.length === 0 ? await detectWorkspaceTargets(root) : [];
+  const targets = workspaceTargets.length > 0 ? workspaceTargets : explicitTargets;
+  for (const target of targets) {
+    const pkg = await readJSON(path6.join(target.absolutePath, "package.json"));
+    const allDeps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+    const scripts = pkg?.scripts || {};
+    const supportedChecks = SUPPORTED_PATTERNS.map(
+      (pattern) => detectPattern({
+        pattern,
+        workspaceRoot: root,
+        targetRoot: target.absolutePath,
+        packagePath: target.packagePath,
+        allDeps,
+        scripts
+      })
+    );
+    const supportedResults = await Promise.all(supportedChecks);
+    for (const result of supportedResults) {
+      if (result) {
+        supported.push(result);
       }
-    } catch {
     }
-  }
-  const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-  const globalExtDir = path6.join(homeDir, ".vscode", "extensions");
-  const globalExtExists = await exists(globalExtDir);
-  let installedExtensionFolders = [];
-  if (globalExtExists) {
-    try {
-      const { readdir } = await import("fs/promises");
-      installedExtensionFolders = await readdir(globalExtDir);
-      const obsoletePath = path6.join(globalExtDir, ".obsolete");
-      if (await exists(obsoletePath)) {
-        try {
-          const obsoleteData = await readJSON(obsoletePath);
-          if (obsoleteData) {
-            const obsoleteKeys = Object.keys(obsoleteData);
-            installedExtensionFolders = installedExtensionFolders.filter((folder) => {
-              return !obsoleteKeys.includes(folder);
-            });
-          }
-        } catch {
+    const unsupportedChecks = UNSUPPORTED_META.map(async (meta) => {
+      if (!(meta.dep in allDeps)) return null;
+      for (const file of meta.files) {
+        if (await exists(path6.join(target.absolutePath, file))) {
+          return meta.name;
         }
       }
-    } catch {
-    }
-  }
-  for (const plugin of KNOWN_IDE_PLUGINS) {
-    let isInstalled = false;
-    if (recommendedExts.includes(plugin.extId.toLowerCase())) {
-      isInstalled = true;
-    } else if (installedExtensionFolders.some((f) => {
-      const lower = f.toLowerCase();
-      return lower === plugin.extId.toLowerCase() || lower.startsWith(plugin.extId.toLowerCase() + "-");
-    })) {
-      isInstalled = true;
-    }
-    if (isInstalled) {
-      const existing = detectedMap.get(plugin.id);
-      if (existing) {
-        existing.providerModes.push("extension");
-        existing.preferredMode = "extension";
-      } else {
-        detectedMap.set(plugin.id, {
-          id: plugin.id,
-          label: plugin.label,
-          supported: plugin.supported,
-          providerModes: ["extension"],
-          preferredMode: "extension"
-        });
+      return null;
+    });
+    const unsupportedResults = await Promise.all(unsupportedChecks);
+    for (const result of unsupportedResults) {
+      if (result) {
+        unsupported.add(result);
       }
     }
   }
-  return { detected: Array.from(detectedMap.values()) };
+  return { supported, unsupported: Array.from(unsupported) };
 }
-
-// src/inject/ast-injector.ts
-import path7 from "path";
-import { loadFile, writeFile as writeAstFile } from "magicast";
-
-// src/inject/strategies/vite.ts
-import { addVitePlugin } from "magicast/helpers";
-var ViteStrategy = class {
-  name = "Vite";
-  supports(tool) {
-    return tool === "vite";
-  }
-  inject({ mod, detection }) {
-    addVitePlugin(mod, {
-      from: "@inspecto-dev/plugin",
-      constructor: "vitePlugin"
-    });
-  }
-  getManualInstructions(detection, reason) {
-    return [
-      `import { vitePlugin as inspecto } from '@inspecto-dev/plugin'`,
-      "",
-      "// Add to your plugins array:",
-      `plugins: [`,
-      `  process.env.NODE_ENV !== 'production' && inspecto(),`,
-      `  ...otherPlugins`,
-      `].filter(Boolean)`
-    ];
-  }
-};
-
-// src/inject/strategies/webpack.ts
-var WebpackStrategy = class {
-  name = "Webpack";
-  supports(tool) {
-    return tool === "webpack";
-  }
-  inject(options) {
-    throw new Error("Webpack requires manual plugin configuration");
-  }
-  getManualInstructions(detection, reason) {
-    const importPkg = detection.isLegacyWebpack ? "@inspecto-dev/plugin/legacy/webpack4" : "@inspecto-dev/plugin";
-    const pluginName = detection.isLegacyWebpack ? "webpack4Plugin" : "webpackPlugin";
-    const pluginCall = detection.isLegacyWebpack ? `process.env.NODE_ENV !== 'production' && inspecto({
-      pathType: 'absolute',
-      escapeTags: ['Transition', 'AnimatePresence'],
-    })` : `process.env.NODE_ENV !== 'production' && inspecto()`;
-    return [
-      `import { ${pluginName} as inspecto } from '${importPkg}'`,
-      "",
-      "// Add to your plugins array:",
-      `plugins: [`,
-      `  ${pluginCall},`,
-      `  ...otherPlugins`,
-      `].filter(Boolean)`
-    ];
-  }
-};
-
-// src/inject/strategies/rspack.ts
-var RspackStrategy = class {
-  name = "Rspack";
-  supports(tool) {
-    return tool === "rspack";
+async function detectPattern({
+  pattern,
+  workspaceRoot,
+  targetRoot,
+  packagePath,
+  allDeps,
+  scripts
+}) {
+  let hasDep;
+  let resolvedVersion = null;
+  if (pattern.tool === "rspack") {
+    const depName = allDeps["@rspack/cli"] ? "@rspack/cli" : "@rspack/core";
+    hasDep = !!allDeps["@rspack/cli"] || !!allDeps["@rspack/core"] || isPackageResolvable("@rspack/core", targetRoot);
+    if (hasDep) {
+      resolvedVersion = allDeps[depName] || await getResolvedPackageVersion("@rspack/core", targetRoot);
+    }
+  } else if (pattern.tool === "webpack") {
+    const depName = allDeps["webpack"] ? "webpack" : "webpack-cli";
+    hasDep = !!allDeps["webpack"] || !!allDeps["webpack-cli"] || isPackageResolvable("webpack", targetRoot);
+    if (hasDep) {
+      resolvedVersion = allDeps[depName] || await getResolvedPackageVersion("webpack", targetRoot);
+    }
+  } else if (pattern.tool === "rsbuild") {
+    hasDep = !!allDeps["@rsbuild/core"] || isPackageResolvable("@rsbuild/core", targetRoot);
+  } else {
+    hasDep = !!allDeps[pattern.tool] || isPackageResolvable(pattern.tool, targetRoot);
   }
-  inject(options) {
-    throw new Error("Rspack requires manual plugin configuration");
+  let detectedFile = "";
+  let inferredFromScripts = false;
+  if (pattern.tool === "esbuild" && !hasDep) {
+    return null;
   }
-  getManualInstructions(detection, reason) {
-    const importPkg = detection.isLegacyRspack ? "@inspecto-dev/plugin/legacy/rspack" : "@inspecto-dev/plugin";
-    const pluginCall = detection.isLegacyRspack ? `process.env.NODE_ENV !== 'production' && inspecto({
-      pathType: 'absolute',
-      escapeTags: ['Transition', 'AnimatePresence'],
-    })` : `process.env.NODE_ENV !== 'production' && inspecto()`;
-    return [
-      `import { rspackPlugin as inspecto } from '${importPkg}'`,
-      "",
-      "// Add to your plugins array:",
-      `plugins: [`,
-      `  ${pluginCall},`,
-      `  ...otherPlugins`,
-      `].filter(Boolean)`
-    ];
+  for (const file of pattern.files) {
+    if (await exists(path6.join(targetRoot, file))) {
+      detectedFile = file;
+      break;
+    }
   }
-};
-
-// src/inject/strategies/rsbuild.ts
-var RsbuildStrategy = class {
-  name = "Rsbuild";
-  supports(tool) {
-    return tool === "rsbuild";
+  if (hasDep && !detectedFile && (pattern.tool === "esbuild" || pattern.tool === "rollup" || pattern.tool === "webpack" || pattern.tool === "rspack" || pattern.tool === "rsbuild")) {
+    for (const cmd of Object.values(scripts)) {
+      if (cmd.includes("node ")) {
+        const match = cmd.match(/node\s+([^\s]+\.(js|mjs|cjs|ts))/);
+        if (match && match[1]) {
+          if (await exists(path6.join(targetRoot, match[1]))) {
+            if (cmd.includes(pattern.tool) || match[1].includes(pattern.tool)) {
+              detectedFile = match[1];
+              break;
+            }
+          }
+        }
+      } else if (cmd.includes(`${pattern.tool} `)) {
+        if (pattern.tool === "webpack" || pattern.tool === "rspack") {
+          const configMatch = cmd.match(/--config\s+([^\s]+)/);
+          if (configMatch && configMatch[1]) {
+            if (await exists(path6.join(targetRoot, configMatch[1]))) {
+              detectedFile = configMatch[1];
+              break;
+            }
+          }
+        }
+        if (!detectedFile) {
+          inferredFromScripts = true;
+          detectedFile = "package.json (scripts)";
+          break;
+        }
+      }
+    }
   }
-  inject(options) {
-    throw new Error("Rsbuild requires manual plugin configuration due to nested structure");
+  if (!detectedFile) {
+    if (hasDep && (pattern.tool === "rollup" || pattern.tool === "webpack" || pattern.tool === "rspack" || pattern.tool === "esbuild")) {
+      return {
+        tool: pattern.tool,
+        configPath: "package.json (dependency)",
+        label: `${pattern.label} (detected via dependency)`,
+        packagePath: packagePath || void 0
+      };
+    }
+    return null;
   }
-  getManualInstructions(detection, reason) {
-    return [
-      `import { rspackPlugin as inspecto } from '@inspecto-dev/plugin'`,
-      "",
-      "// Add to tools.rspack:",
-      `tools: {`,
-      `  rspack: {`,
-      `    plugins: [`,
-      `      process.env.NODE_ENV !== 'production' && inspecto(),`,
-      `    ]`,
-      `  }`,
-      `}`
-    ];
+  let isLegacyRspack = false;
+  let isLegacyWebpack = false;
+  if (pattern.tool === "rspack") {
+    const version = resolvedVersion;
+    if (version && (version.includes("0.3.") || version.includes("0.2.") || version.includes("0.1."))) {
+      isLegacyRspack = true;
+    }
+  } else if (pattern.tool === "webpack") {
+    const version = resolvedVersion;
+    if (version && version.includes("^4") || version?.startsWith("4.")) {
+      isLegacyWebpack = true;
+    }
   }
-};
+  const absoluteConfig = path6.join(targetRoot, detectedFile);
+  const relativeConfig = normalizeRelativePath(workspaceRoot, absoluteConfig);
+  return {
+    tool: pattern.tool,
+    configPath: relativeConfig,
+    label: `${pattern.label} (${relativeConfig})${isLegacyRspack ? " [Legacy]" : ""}${isLegacyWebpack ? " [Webpack 4]" : ""}${inferredFromScripts ? " [Scripts Detected]" : ""}`,
+    isLegacyRspack,
+    isLegacyWebpack,
+    packagePath: packagePath || void 0
+  };
+}
+function resolveInjectionTarget(detections) {
+  if (detections.length === 0) return null;
+  if (detections.length === 1) return detections[0];
+  return "ambiguous";
+}
 
-// src/inject/strategies/esbuild.ts
-var EsbuildStrategy = class {
-  name = "esbuild";
-  supports(tool) {
-    return tool === "esbuild";
+// src/detect/framework.ts
+import path7 from "path";
+import { createRequire as createRequire2 } from "module";
+var META_FRAMEWORK_MAP = {
+  next: "react",
+  nuxt: "vue",
+  "@remix-run/react": "react",
+  "@remix-run/dev": "react",
+  "@vue/nuxt": "vue",
+  "vite-plugin-vue": "vue",
+  "@vitejs/plugin-vue": "vue",
+  "@vitejs/plugin-react": "react",
+  "@vitejs/plugin-react-swc": "react"
+};
+var SUPPORTED_FRAMEWORKS = [
+  { framework: "react", deps: ["react", "react-dom"] },
+  { framework: "vue", deps: ["vue"] }
+];
+var UNSUPPORTED_FRAMEWORKS = [
+  { name: "Solid", dep: "solid-js" },
+  { name: "Svelte", dep: "svelte" },
+  { name: "Angular", dep: "@angular/core" },
+  { name: "Preact", dep: "preact" },
+  { name: "Lit", dep: "lit" }
+];
+function isPackageResolvable2(pkgName, root) {
+  try {
+    const require2 = createRequire2(path7.join(root, "package.json"));
+    try {
+      require2.resolve(`${pkgName}/package.json`, { paths: [root] });
+      return true;
+    } catch {
+      require2.resolve(pkgName, { paths: [root] });
+      return true;
+    }
+  } catch {
+    return false;
   }
-  inject(options) {
-    throw new Error("Esbuild requires manual plugin configuration");
+}
+async function detectFrameworks(root) {
+  const pkg = await readJSON(path7.join(root, "package.json"));
+  const allDeps = {
+    ...pkg?.dependencies || {},
+    ...pkg?.devDependencies || {},
+    ...pkg?.peerDependencies || {}
+  };
+  const supportedSet = /* @__PURE__ */ new Set();
+  const unsupported = [];
+  const isTest = root.includes("/mock/root");
+  for (const [metaPkg, framework] of Object.entries(META_FRAMEWORK_MAP)) {
+    if (metaPkg in allDeps || !isTest && isPackageResolvable2(metaPkg, root)) {
+      supportedSet.add(framework);
+    }
   }
-  getManualInstructions(detection, reason) {
-    return [
-      `1. Update your esbuild config (${detection.configPath}):`,
-      `import { esbuildPlugin as inspecto } from '@inspecto-dev/plugin'`,
-      "",
-      "// Add to your plugins array:",
-      `plugins: [`,
-      `  process.env.NODE_ENV !== 'production' && inspecto(),`,
-      `  ...otherPlugins`,
-      `].filter(Boolean)`,
-      "",
-      "2. Initialize the client in your app entry (e.g., main.js / index.js):",
-      `import { mountInspector } from '@inspecto-dev/core'`,
-      "",
-      "// Call this before your app renders",
-      `if (process.env.NODE_ENV !== 'production') {`,
-      `  mountInspector()`,
-      `}`
-    ];
+  for (const { framework, deps } of SUPPORTED_FRAMEWORKS) {
+    if (supportedSet.has(framework)) continue;
+    for (const dep of deps) {
+      if (dep in allDeps || !isTest && isPackageResolvable2(dep, root)) {
+        supportedSet.add(framework);
+        break;
+      }
+    }
   }
-};
-
-// src/inject/strategies/rollup.ts
-var RollupStrategy = class {
-  name = "Rollup";
-  supports(tool) {
-    return tool === "rollup";
+  for (const fw of UNSUPPORTED_FRAMEWORKS) {
+    if (fw.dep in allDeps || !isTest && isPackageResolvable2(fw.dep, root)) {
+      unsupported.push(fw);
+    }
   }
-  inject(options) {
-    throw new Error("Rollup requires manual plugin configuration");
+  return {
+    supported: Array.from(supportedSet),
+    unsupported
+  };
+}
+
+// src/detect/ide.ts
+import path8 from "path";
+var SUPPORTED_IDE = "vscode";
+async function detectIDE(root) {
+  const detected = /* @__PURE__ */ new Map();
+  if (process.env.CURSOR_TRACE_DIR || process.env.CURSOR_CHANNEL) {
+    detected.set("Cursor", { ide: "cursor", supported: true });
   }
-  getManualInstructions(detection, reason) {
-    return [
-      `1. Update your rollup config (${detection.configPath}):`,
-      `import { rollupPlugin as inspecto } from '@inspecto-dev/plugin'`,
-      "",
-      "// Add to your plugins array:",
-      `plugins: [`,
-      `  process.env.NODE_ENV !== 'production' && inspecto(),`,
-      `  ...otherPlugins`,
-      `].filter(Boolean)`,
-      "",
-      "2. Initialize the client in your app entry (e.g., main.js / index.js):",
-      `import { mountInspector } from '@inspecto-dev/core'`,
-      "",
-      "// Call this before your app renders",
-      `if (process.env.NODE_ENV !== 'production') {`,
-      `  mountInspector()`,
-      `}`
-    ];
+  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.set("Trae", { ide: "trae", supported: true });
   }
-};
-
-// src/inject/strategies/index.ts
-var STRATEGIES = [
-  new ViteStrategy(),
-  new WebpackStrategy(),
-  new RspackStrategy(),
-  new RsbuildStrategy(),
-  new EsbuildStrategy(),
-  new RollupStrategy()
-];
-
-// src/inject/ast-injector.ts
-function printManualInstructions(strategy, detection, reason) {
-  log.warn(`Could not automatically configure ${detection.configPath}`);
-  log.hint(`(reason: ${reason})`);
-  log.blank();
-  log.hint("Please add the following manually:");
-  if (strategy) {
-    const instructions = strategy.getManualInstructions(detection, reason);
-    log.codeBlock(instructions);
-  } else {
-    log.error(`Unsupported build tool: ${detection.tool}`);
+  if (process.env.ZED_TERM) {
+    detected.set("Zed", { ide: "Zed", supported: false });
   }
-}
-function isAlreadyInjected(content) {
-  return /import\s+.*@inspecto-dev\/plugin/.test(content) || /require\(['"]@inspecto-dev\/plugin['"]\)/.test(content) || /import\s+.*ai-dev-inspector/.test(content) || // Legacy support
-  /require\(['"]ai-dev-inspector['"]\)/.test(content);
-}
-async function injectPlugin(root, detection, dryRun) {
-  const configPath = path7.join(root, detection.configPath);
-  const mutations = [];
-  const strategy = STRATEGIES.find((s) => s.supports(detection.tool));
-  const content = await readFile(configPath);
-  if (!content) {
-    printManualInstructions(strategy, detection, "config file not readable");
-    return { success: false, mutations, failureReason: "config file not readable" };
+  if (process.env.WINDSURF_APP_DIR || process.env.WINDSURF_CHANNEL || process.env.__CFBundleIdentifier === "com.codeium.windsurf" || process.env.npm_config_user_agent && process.env.npm_config_user_agent.includes("windsurf")) {
+    detected.set("Windsurf", { ide: "Windsurf", supported: false });
   }
-  if (isAlreadyInjected(content)) {
-    log.success(`Plugin already configured in ${detection.configPath} (skipped)`);
-    mutations.push({
-      type: "file_modified",
-      path: detection.configPath,
-      description: "Previously configured inspecto() plugin"
-    });
-    return { success: true, mutations };
+  const [hasTrae, hasCursor, hasVscode, hasIdea] = await Promise.all([
+    exists(path8.join(root, ".trae")),
+    exists(path8.join(root, ".cursor")),
+    exists(path8.join(root, ".vscode")),
+    exists(path8.join(root, ".idea"))
+  ]);
+  if (hasTrae && !detected.has("Trae")) {
+    detected.set("Trae", { ide: "trae", supported: true });
   }
-  if (!strategy) {
-    printManualInstructions(
-      strategy,
-      detection,
-      `No injection strategy found for ${detection.tool}`
-    );
-    return { success: false, mutations, failureReason: "No strategy found" };
+  if (hasCursor && !detected.has("Cursor")) {
+    detected.set("Cursor", { ide: "cursor", supported: true });
   }
-  if (dryRun) {
-    log.dryRun(`Would automatically configure plugin in ${detection.configPath}`);
-    return { success: true, mutations: [] };
+  if (hasVscode && !detected.has("vscode")) {
+    detected.set("vscode", { ide: SUPPORTED_IDE, supported: true });
   }
-  try {
-    const mod = await loadFile(configPath);
-    strategy.inject({
-      mod,
-      detection
-    });
-    await writeAstFile(mod, configPath);
-    mutations.push({
-      type: "file_modified",
-      path: detection.configPath,
-      description: "Automatically configured inspecto() plugin"
-    });
-    log.success(`Configured plugin in ${detection.configPath}`);
-    return { success: true, mutations };
-  } catch (err) {
-    printManualInstructions(
-      strategy,
-      detection,
-      `Automatic configuration unavailable: ${err instanceof Error ? err.message : String(err)}`
-    );
-    return {
-      success: false,
-      mutations,
-      failureReason: "Automatic configuration unavailable"
-    };
+  if (hasIdea && !detected.has("JetBrains IDE")) {
+    detected.set("JetBrains IDE", { ide: "JetBrains IDE", supported: false });
   }
+  if (detected.size === 0 && process.env.TERM_PROGRAM === "vscode") {
+    detected.set("vscode", { ide: SUPPORTED_IDE, supported: true });
+  }
+  return {
+    detected: Array.from(detected.values())
+  };
 }
 
-// src/inject/gitignore.ts
-import path8 from "path";
-var DEFAULT_RULES = [".inspecto/install.lock", ".inspecto/cache.json", ".inspecto/*.local.json"];
-var SHARED_RULES = [".inspecto/install.lock", ".inspecto/cache.json", ".inspecto/*.local.json"];
-async function updateGitignore(root, shared, dryRun) {
-  const gitignorePath = path8.join(root, ".gitignore");
-  let content = await readFile(gitignorePath) ?? "";
-  const desiredRules = shared ? SHARED_RULES : DEFAULT_RULES;
-  const hasGlobalRule = content.match(/^\.inspecto\/\s*$/m) !== null;
-  if (hasGlobalRule) {
-    content = content.replace(/^\.inspecto\/\s*$/gm, SHARED_RULES.join("\n"));
-    if (!dryRun) {
-      await writeFile(gitignorePath, content);
+// src/detect/provider.ts
+import path9 from "path";
+var KNOWN_CLI_TOOLS = [
+  { id: "claude-code", bin: "claude", label: "Claude Code", supported: true },
+  { id: "coco", bin: "coco", label: "Trae CLI (Coco)", supported: true },
+  { id: "codex", bin: "codex", label: "Codex CLI", supported: true },
+  { id: "gemini", bin: "gemini", label: "Gemini CLI", supported: true }
+];
+var KNOWN_IDE_PLUGINS = [
+  { id: "claude-code", extId: "anthropic.claude-code", label: "Claude Code", supported: true },
+  { id: "copilot", extId: "github.copilot", label: "GitHub Copilot", supported: true },
+  { id: "codex", extId: "openai.chatgpt", label: "Codex (ChatGPT)", supported: true },
+  { id: "gemini", extId: "google.geminicodeassist", label: "Gemini Code Assist", supported: true }
+];
+async function detectProviders(root) {
+  const detectedMap = /* @__PURE__ */ new Map();
+  const cliChecks = KNOWN_CLI_TOOLS.map(async (tool) => {
+    if (await which(tool.bin)) {
+      detectedMap.set(tool.id, {
+        id: tool.id,
+        label: tool.label,
+        supported: tool.supported,
+        providerModes: ["cli"],
+        preferredMode: "cli"
+      });
+    }
+  });
+  await Promise.all(cliChecks);
+  const extensionsJsonPath = path9.join(root, ".vscode", "extensions.json");
+  let recommendedExts = [];
+  if (await exists(extensionsJsonPath)) {
+    try {
+      const extData = await readJSON(extensionsJsonPath);
+      if (extData && Array.isArray(extData.recommendations)) {
+        recommendedExts = extData.recommendations.map((e) => e.toLowerCase());
+      }
+    } catch {
     }
-    log.success("Updated .gitignore: .inspecto/ is no longer fully ignored");
-    return;
   }
-  const missingRules = desiredRules.filter((rule) => !content.includes(rule));
-  if (missingRules.length === 0) {
-    return;
+  const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+  const globalExtDir = path9.join(homeDir, ".vscode", "extensions");
+  const globalExtExists = await exists(globalExtDir);
+  let installedExtensionFolders = [];
+  if (globalExtExists) {
+    try {
+      const { readdir } = await import("fs/promises");
+      installedExtensionFolders = await readdir(globalExtDir);
+      const obsoletePath = path9.join(globalExtDir, ".obsolete");
+      if (await exists(obsoletePath)) {
+        try {
+          const obsoleteData = await readJSON(obsoletePath);
+          if (obsoleteData) {
+            const obsoleteKeys = Object.keys(obsoleteData);
+            installedExtensionFolders = installedExtensionFolders.filter((folder) => {
+              return !obsoleteKeys.includes(folder);
+            });
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
   }
-  const section = "\n# Inspecto\n" + missingRules.join("\n") + "\n";
-  content = content.trimEnd() + "\n" + section;
-  if (dryRun) {
-    log.dryRun(`Would update .gitignore with: ${missingRules.join(", ")}`);
-  } else {
-    await writeFile(gitignorePath, content);
-    log.success("Updated .gitignore");
+  for (const plugin of KNOWN_IDE_PLUGINS) {
+    let isInstalled = false;
+    if (recommendedExts.includes(plugin.extId.toLowerCase())) {
+      isInstalled = true;
+    } else if (installedExtensionFolders.some((f) => {
+      const lower = f.toLowerCase();
+      return lower === plugin.extId.toLowerCase() || lower.startsWith(plugin.extId.toLowerCase() + "-");
+    })) {
+      isInstalled = true;
+    }
+    if (isInstalled) {
+      const existing = detectedMap.get(plugin.id);
+      if (existing) {
+        existing.providerModes.push("extension");
+        existing.preferredMode = "extension";
+      } else {
+        detectedMap.set(plugin.id, {
+          id: plugin.id,
+          label: plugin.label,
+          supported: plugin.supported,
+          providerModes: ["extension"],
+          preferredMode: "extension"
+        });
+      }
+    }
   }
+  return { detected: Array.from(detectedMap.values()) };
 }
-async function cleanGitignore(root) {
-  const gitignorePath = path8.join(root, ".gitignore");
-  const content = await readFile(gitignorePath);
-  if (!content) return;
-  const cleaned = content.replace(/^# Inspecto\s*$/m, "").replace(/^\.inspecto\/?\s*$/gm, "").replace(/^\.inspecto\/install\.lock\s*$/gm, "").replace(/^\.inspecto\/cache\.json\s*$/gm, "").replace(/^\.inspecto\/\*\.local\.json\s*$/gm, "").replace(/\n{3,}/g, "\n\n");
-  await writeFile(gitignorePath, cleaned);
+
+// src/onboarding/context.ts
+async function buildOnboardingContext(root) {
+  const [packageManager, buildTools, frameworks, ides, providers] = await Promise.all([
+    detectPackageManager(root),
+    detectBuildTools(root),
+    detectFrameworks(root),
+    detectIDE(root),
+    detectProviders(root)
+  ]);
+  return {
+    root,
+    packageManager,
+    buildTools: {
+      supported: buildTools.supported,
+      unsupported: buildTools.unsupported
+    },
+    frameworks: {
+      supported: frameworks.supported,
+      unsupported: frameworks.unsupported.map((item) => item.name)
+    },
+    ides: ides.detected.map(({ ide, supported }) => ({ ide, supported })),
+    providers: providers.detected.map(({ id, label, supported, preferredMode }) => ({
+      id,
+      label,
+      supported,
+      preferredMode
+    }))
+  };
 }
 
-// src/inject/extension.ts
-var EXTENSION_ID = "inspecto.inspecto";
-var VSCODE_PATHS = {
-  darwin: [
-    "/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code",
-    "/Applications/Visual Studio Code - Insiders.app/Contents/Resources/app/bin/code-insiders",
-    `${process.env.HOME}/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code`
-  ],
-  linux: ["/usr/bin/code", "/usr/share/code/bin/code", "/snap/bin/code", "/usr/bin/code-insiders"],
-  win32: [
-    `${process.env.LOCALAPPDATA}\\Programs\\Microsoft VS Code\\bin\\code.cmd`,
-    `${process.env.LOCALAPPDATA}\\Programs\\Microsoft VS Code Insiders\\bin\\code-insiders.cmd`,
-    `${process.env.PROGRAMFILES}\\Microsoft VS Code\\bin\\code.cmd`
-  ]
-};
-async function findVSCodeBinary() {
-  const platform = process.platform;
-  const candidates = VSCODE_PATHS[platform] || [];
-  for (const candidate of candidates) {
-    if (await exists(candidate)) {
-      return candidate;
+// src/onboarding/planner.ts
+function message(code, message2) {
+  return { code, message: message2 };
+}
+function uniqueMessages(messages) {
+  const seen = /* @__PURE__ */ new Set();
+  return messages.filter((item) => {
+    const key = `${item.code}:${item.message}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function detectionStatus(warnings, blockers) {
+  if (blockers.length > 0) return "blocked";
+  if (warnings.length > 0) return "warning";
+  return "ok";
+}
+function planStatus(warnings, blockers) {
+  if (blockers.length > 0) return "blocked";
+  if (warnings.length > 0) return "warning";
+  return "ok";
+}
+function supportedIde(context) {
+  return context.ides.find((ide) => ide.supported)?.ide;
+}
+function supportedProvider(context) {
+  return context.providers.find((provider) => provider.supported)?.id;
+}
+function buildToolBlockers(context) {
+  if (context.buildTools.unsupported.length > 0) {
+    return [
+      message(
+        "unsupported-build-tool",
+        `Detected unsupported build tool(s): ${context.buildTools.unsupported.join(", ")}`
+      )
+    ];
+  }
+  if (context.buildTools.supported.length > 0) {
+    if (context.buildTools.supported.length === 1) {
+      return [];
     }
+    const targets = context.buildTools.supported.map((target) => target.packagePath ?? target.configPath).join(", ");
+    return [
+      message(
+        "multiple-supported-build-targets",
+        `Multiple supported build targets detected: ${targets}. Run inspecto apply from a single app/package root until explicit target selection is available.`
+      )
+    ];
   }
-  if (await which("code-insiders")) {
-    return "code-insiders";
+  return [message("missing-build-tool", "No supported build tool detected")];
+}
+function frameworkBlockers(context) {
+  if (context.frameworks.supported.length > 0) {
+    return [];
   }
-  return null;
+  if (context.frameworks.unsupported.length > 0) {
+    return [
+      message(
+        "unsupported-framework",
+        `Detected unsupported framework(s): ${context.frameworks.unsupported.join(", ")}`
+      )
+    ];
+  }
+  return [message("missing-framework", "No supported frontend framework detected")];
 }
-async function tryOpenURI(uri) {
-  try {
-    const platform = process.platform;
-    if (platform === "win32") {
-      await shell(`cmd /c start "" "${uri}"`);
-    } else {
-      const openCmd = platform === "darwin" ? "open" : "xdg-open";
-      await shell(`${openCmd} "${uri}"`);
-    }
-    return true;
-  } catch {
-    return false;
+function unsupportedEnvironmentWarnings(context) {
+  const warnings = [];
+  if (context.frameworks.unsupported.length > 0 && context.frameworks.supported.length > 0) {
+    warnings.push(
+      message(
+        "unsupported-framework-present",
+        `Unsupported framework(s) also detected: ${context.frameworks.unsupported.join(", ")}`
+      )
+    );
+  }
+  const unsupportedIdes = context.ides.filter((ide) => !ide.supported).map((ide) => ide.ide);
+  if (unsupportedIdes.length > 0) {
+    warnings.push(message("unsupported-ide", `Unsupported IDE(s) detected: ${unsupportedIdes.join(", ")}`));
+  }
+  const unsupportedProviders = context.providers.filter((provider) => !provider.supported).map((provider) => provider.label);
+  if (unsupportedProviders.length > 0) {
+    warnings.push(
+      message(
+        "unsupported-provider",
+        `Unsupported provider(s) detected: ${unsupportedProviders.join(", ")}`
+      )
+    );
   }
+  return warnings;
 }
-async function installExtension(dryRun, ide) {
-  if (dryRun) {
-    log.dryRun("Would attempt to install VS Code extension");
-    return null;
+function manualBuildToolActions(context) {
+  if (context.buildTools.unsupported.length > 0) {
+    return [
+      {
+        type: "manual_step",
+        target: context.buildTools.unsupported.join(", "),
+        description: "Inspecto cannot auto-configure this build stack yet. Follow the manual setup guide for the detected framework or build tool."
+      }
+    ];
   }
-  const isVSCode = !ide || ide === "vscode";
-  if (isVSCode) {
-    if (await which("code")) {
-      try {
-        await run("code", ["--install-extension", EXTENSION_ID]);
-        log.success("VS Code extension installed via CLI");
-        return { type: "extension_installed", id: EXTENSION_ID };
-      } catch {
+  if (context.buildTools.supported.length > 1) {
+    const targets = context.buildTools.supported.map((target) => target.packagePath ?? target.configPath).join(", ");
+    return [
+      {
+        type: "manual_step",
+        target: targets,
+        description: "Run inspecto apply from the target app/package root. Root-level apply is blocked when multiple supported targets are detected."
       }
+    ];
+  }
+  return [
+    {
+      type: "manual_step",
+      target: context.root,
+      description: "No supported build tool was detected. Add a supported build config before trying Inspecto again."
     }
-    const codePath = await findVSCodeBinary();
-    if (codePath) {
-      try {
-        await run(codePath, ["--install-extension", EXTENSION_ID]);
-        log.success("VS Code extension installed via binary path");
-        log.info(
-          'Tip: Add "code" to your PATH to help Inspecto detect other AI tools in the future'
-        );
-        return { type: "extension_installed", id: EXTENSION_ID };
-      } catch {
+  ];
+}
+function manualFrameworkActions(context) {
+  if (context.frameworks.unsupported.length > 0) {
+    return [
+      {
+        type: "manual_step",
+        target: context.frameworks.unsupported.join(", "),
+        description: "Inspecto cannot auto-configure this framework yet. Follow the manual setup guide for the detected framework."
       }
+    ];
+  }
+  return [
+    {
+      type: "manual_step",
+      target: context.root,
+      description: "No supported frontend framework was detected. Add a supported React or Vue app before trying Inspecto again."
     }
-    const uri = `vscode:extension/${EXTENSION_ID}`;
-    if (await tryOpenURI(uri)) {
-      log.warn("Opened extension page in VS Code");
-      log.hint('Please click "Install" in the opened VS Code window to complete setup.');
-      return { type: "extension_installed", id: EXTENSION_ID, manual_action_required: true };
+  ];
+}
+async function createDetectionResult(root) {
+  const context = await buildOnboardingContext(root);
+  const warnings = uniqueMessages([...unsupportedEnvironmentWarnings(context)]);
+  const buildToolResult = buildToolBlockers(context);
+  const frameworkResult = frameworkBlockers(context);
+  const blockers = uniqueMessages([...buildToolResult, ...frameworkResult]);
+  return {
+    status: detectionStatus(warnings, blockers),
+    warnings,
+    blockers,
+    project: {
+      root: context.root,
+      packageManager: context.packageManager
+    },
+    environment: {
+      frameworks: context.frameworks.supported,
+      unsupportedFrameworks: context.frameworks.unsupported,
+      buildTools: context.buildTools.supported,
+      unsupportedBuildTools: context.buildTools.unsupported,
+      ides: context.ides,
+      providers: context.providers
     }
-    log.warn("Could not auto-install VS Code extension");
-    log.hint("Please install it manually to enable Inspector features:");
-    log.hint("  1. Open VS Code");
-    log.hint("  2. Press Ctrl+Shift+X (or Cmd+Shift+X)");
-    log.hint('  3. Search for "Inspecto"');
-    log.hint(`  Or visit: https://marketplace.visualstudio.com/items?itemName=${EXTENSION_ID}`);
-    return null;
-  }
-  log.warn(`Could not auto-install extension for ${ide}`);
-  log.hint("Please install it manually to enable Inspector features:");
-  log.hint("  1. Download the latest .vsix file from Inspecto releases");
-  log.hint(`  2. Open ${ide}`);
-  log.hint("  3. Open the Command Palette (Ctrl+Shift+P or Cmd+Shift+P)");
-  log.hint('  4. Type and select "Extensions: Install from VSIX..."');
-  log.hint("  5. Select the downloaded .vsix file");
-  return null;
+  };
 }
-async function isExtensionInstalled() {
-  try {
-    if (await which("code")) {
-      const { stdout } = await run("code", ["--list-extensions"]);
-      return stdout.toLowerCase().includes(EXTENSION_ID);
+function createPlanResult(context) {
+  const warnings = uniqueMessages(unsupportedEnvironmentWarnings(context));
+  const blockers = uniqueMessages([...buildToolBlockers(context), ...frameworkBlockers(context)]);
+  const actions = [];
+  let strategy = "supported";
+  if (blockers.length > 0) {
+    strategy = "manual";
+    if (context.buildTools.unsupported.length > 0 || context.buildTools.supported.length === 0 || context.buildTools.supported.length > 1) {
+      actions.push(...manualBuildToolActions(context));
     }
-    const codePath = await findVSCodeBinary();
-    if (codePath) {
-      const { stdout } = await run(codePath, ["--list-extensions"]);
-      return stdout.toLowerCase().includes(EXTENSION_ID);
+    if (frameworkBlockers(context).length > 0) {
+      actions.push(...manualFrameworkActions(context));
     }
-    return false;
-  } catch {
-    return false;
+  } else {
+    actions.push({
+      type: "install_dependency",
+      target: "@inspecto-dev/plugin @inspecto-dev/core",
+      description: `Install the Inspecto runtime packages with ${context.packageManager}.`
+    });
+    for (const buildTool of context.buildTools.supported) {
+      actions.push({
+        type: "modify_file",
+        target: buildTool.configPath,
+        description: `Inject the Inspecto plugin into ${buildTool.label}.`
+      });
+    }
+    const ide2 = supportedIde(context);
+    if (ide2 === "vscode") {
+      actions.push({
+        type: "install_extension",
+        target: "vscode",
+        description: "Install the Inspecto VS Code extension."
+      });
+    }
+  }
+  const defaults = {
+    shared: false,
+    extension: supportedIde(context) === "vscode"
+  };
+  const provider = supportedProvider(context);
+  if (provider) {
+    defaults.provider = provider;
+  }
+  const ide = supportedIde(context);
+  if (ide) {
+    defaults.ide = ide;
+  }
+  return {
+    status: planStatus(warnings, blockers),
+    warnings,
+    blockers,
+    strategy,
+    actions,
+    defaults
+  };
+}
+
+// src/commands/apply.ts
+function getProviderDefault(providerId, preferredMode) {
+  if (!providerId) return void 0;
+  const mode = preferredMode ?? (providerId === "coco" ? "cli" : "extension");
+  return `${providerId}.${mode}`;
+}
+function statusRank(status) {
+  switch (status) {
+    case "error":
+      return 3;
+    case "blocked":
+      return 2;
+    case "warning":
+      return 1;
+    case "ok":
+    default:
+      return 0;
+  }
+}
+function mergeStatus(planStatus2, applyStatus) {
+  return statusRank(planStatus2) >= statusRank(applyStatus) ? planStatus2 : applyStatus;
+}
+function printApplyResult(result) {
+  const manualSteps = result.postInstall.nextSteps.filter(
+    (step) => !result.plan.blockers.some((blocker) => blocker.message === step)
+  );
+  log.header("Inspecto Apply");
+  log.info(`Status: ${result.status}`);
+  log.info(`Strategy: ${result.plan.strategy}`);
+  for (const blocker of result.plan.blockers) {
+    log.error(blocker.message);
+  }
+  for (const warning of result.plan.warnings) {
+    log.warn(warning.message);
+  }
+  if (manualSteps.length > 0 || result.plan.blockers.length > 0) {
+    log.blank();
+    log.warn("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 Manual Steps Required \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    manualSteps.forEach((step) => log.error(step));
+    return;
+  }
+  if (result.plan.warnings.length > 0) {
+    return;
+  }
+  log.ready("Ready! Hold Alt + Click any element to inspect.");
+}
+async function apply(options = {}) {
+  const root = process.cwd();
+  const context = await buildOnboardingContext(root);
+  const plan2 = createPlanResult(context);
+  const selectedProvider = context.providers.find((provider) => provider.id === plan2.defaults.provider) ?? null;
+  const selectedIDE = context.ides.find((ide) => ide.ide === plan2.defaults.ide) ?? context.ides.find((ide) => ide.supported) ?? null;
+  const applyResult = await applyOnboardingPlan({
+    repoRoot: root,
+    projectRoot: root,
+    packageManager: context.packageManager,
+    supportedBuildTargets: context.buildTools.supported,
+    options: {
+      shared: options.shared ?? plan2.defaults.shared,
+      skipInstall: options.skipInstall ?? false,
+      dryRun: options.dryRun ?? false,
+      noExtension: options.noExtension ?? !plan2.defaults.extension,
+      quiet: options.json ?? false
+    },
+    selectedIDE,
+    providerDefault: getProviderDefault(plan2.defaults.provider, selectedProvider?.preferredMode),
+    plan: plan2
+  });
+  const result = {
+    ...applyResult,
+    status: mergeStatus(plan2.status, applyResult.status),
+    plan: plan2
+  };
+  return writeCommandOutput(result, options.json ?? false, printApplyResult);
+}
+
+// src/commands/detect.ts
+function printDetectionResult(result) {
+  const suppressedCodes = /* @__PURE__ */ new Set([
+    "unsupported-build-tool",
+    "unsupported-build-tool-present",
+    "unsupported-framework",
+    "unsupported-framework-present"
+  ]);
+  log.header("Inspecto Detect");
+  log.info(`Status: ${result.status}`);
+  log.info(`Root: ${result.project.root}`);
+  log.info(`Package manager: ${result.project.packageManager}`);
+  if (result.environment.frameworks.length > 0) {
+    log.success(`Supported frameworks: ${result.environment.frameworks.join(", ")}`);
+  }
+  if (result.environment.unsupportedFrameworks.length > 0) {
+    log.warn(`Unsupported frameworks: ${result.environment.unsupportedFrameworks.join(", ")}`);
+  }
+  if (result.environment.buildTools.length > 0) {
+    log.success(
+      `Supported build tools: ${result.environment.buildTools.map((tool) => tool.label).join(", ")}`
+    );
+  }
+  if (result.environment.unsupportedBuildTools.length > 0) {
+    log.warn(`Unsupported build tools: ${result.environment.unsupportedBuildTools.join(", ")}`);
+  }
+  const supportedIdes = result.environment.ides.filter((ide) => ide.supported).map((ide) => ide.ide);
+  if (supportedIdes.length > 0) {
+    log.success(`Supported IDEs: ${supportedIdes.join(", ")}`);
+  }
+  const supportedProviders = result.environment.providers.filter((provider) => provider.supported).map((provider) => provider.label);
+  if (supportedProviders.length > 0) {
+    log.success(`Supported providers: ${supportedProviders.join(", ")}`);
+  }
+  for (const blocker of result.blockers) {
+    if (suppressedCodes.has(blocker.code)) continue;
+    log.error(blocker.message);
+  }
+  for (const warning of result.warnings) {
+    if (suppressedCodes.has(warning.code)) continue;
+    log.warn(warning.message);
   }
 }
+async function detect(json = false) {
+  const result = await createDetectionResult(process.cwd());
+  return writeCommandOutput(result, json, printDetectionResult);
+}
+
+// src/commands/init.ts
+import path10 from "path";
 
 // src/prompts.ts
 import prompts from "prompts";
@@ -1055,9 +1802,9 @@ async function promptProviderChoice(detections) {
         title: `${d.label} ${d.supported ? `(supported ${modeStr})` : "(unsupported/limited)"}`,
         value: i
       };
-    })
+    }).concat({ title: "Skip (configure later)", value: -1 })
   });
-  if (choice === void 0) return null;
+  if (choice === void 0 || choice === -1) return null;
   return detections[choice];
 }
 async function promptConfigChoice(detections) {
@@ -1083,6 +1830,33 @@ async function promptConfigChoice(detections) {
   if (choice === void 0 || choice === -1) return null;
   return detections[choice];
 }
+async function promptMonorepoPackageChoice(detections) {
+  const uniquePackages = Array.from(
+    new Map(
+      detections.filter((d) => !!d.packagePath).map((d) => [d.packagePath, d])
+    ).values()
+  );
+  if (uniquePackages.length === 0) {
+    return null;
+  }
+  if (!process.stdin.isTTY) {
+    log.error("Monorepo root detected, but stdin is not interactive.");
+    log.hint("Re-run `inspecto init` inside a specific app directory, or pass --packages <app-path>.");
+    return null;
+  }
+  const { choice } = await prompts({
+    type: "select",
+    name: "choice",
+    message: "Monorepo root detected. Choose the app to initialize:",
+    choices: uniquePackages.map((d, i) => ({
+      title: `${d.packagePath} (${d.tool})`,
+      description: d.configPath,
+      value: i
+    }))
+  });
+  if (choice === void 0) return null;
+  return uniquePackages[choice].packagePath;
+}
 async function promptUnsupportedFrameworkContinue() {
   if (!process.stdin.isTTY) {
     log.error("Unsupported framework detected in non-interactive environment.");
@@ -1101,60 +1875,75 @@ async function promptUnsupportedFrameworkContinue() {
 // src/instructions.ts
 function printNuxtManualInstructions() {
   log.blank();
-  log.hint("To enable Inspecto in Nuxt, update your nuxt.config.ts:");
-  console.log(`\x1B[36m
-  import { vitePlugin as inspecto } from '@inspecto-dev/plugin'
-  export default defineNuxtConfig({
-    vite: {
-      plugins: [inspecto()]
-    }
-  })
-\x1B[0m`);
-  log.hint("And create a Nuxt plugin at plugins/inspecto.client.ts:");
-  console.log(`\x1B[36m
-  export default defineNuxtPlugin(() => {
-    if (import.meta.dev) {
-      import('@inspecto-dev/core').then(({ mountInspector }) => {
-        mountInspector()
-      })
-    }
-  })
-\x1B[0m`);
+  log.hint("Nuxt requires manual setup in the current version.");
+  log.hint("1. Update `nuxt.config.ts` to register the Inspecto Vite plugin:");
+  log.copyableCodeBlock([
+    "import { vitePlugin as inspecto } from '@inspecto-dev/plugin'",
+    "",
+    "export default defineNuxtConfig({",
+    "  vite: {",
+    "    plugins: [inspecto()],",
+    "  },",
+    "})"
+  ]);
+  log.hint("2. Create `plugins/inspecto.client.ts` to mount `@inspecto-dev/core` in development:");
+  log.copyableCodeBlock([
+    "export default defineNuxtPlugin(() => {",
+    "  if (import.meta.dev) {",
+    "    import('@inspecto-dev/core').then(({ mountInspector }) => {",
+    "      mountInspector()",
+    "    })",
+    "  }",
+    "})"
+  ]);
+  log.hint("3. Restart your Nuxt dev server after updating the config.");
 }
 function printNextJsManualInstructions() {
   log.blank();
-  log.hint("To enable Inspecto in Next.js, update your next.config.mjs:");
-  console.log(`\x1B[36m
-  import { webpackPlugin as inspecto } from '@inspecto-dev/plugin'
-  const nextConfig = {
-    webpack: (config, { dev, isServer }) => {
-      if (dev && !isServer) config.plugins.push(inspecto())
-      return config
-    }
-  }
-  export default nextConfig
-\x1B[0m`);
-  log.hint("And initialize the client dynamically in your app/layout.tsx (or pages/_app.tsx):");
-  console.log(`\x1B[36m
-  'use client'
-  import { useEffect } from 'react'
-
-  export default function RootLayout({ children }) {
-    useEffect(() => {
-      if (process.env.NODE_ENV !== 'production') {
-        import('@inspecto-dev/core').then(({ mountInspector }) => {
-          mountInspector({ serverUrl: 'http://127.0.0.1:5678' })
-        })
-      }
-    }, [])
-    return <html><body>{children}</body></html>
-  }
-\x1B[0m`);
+  log.hint("Next.js requires manual setup in the current version.");
+  log.hint("1. Update `next.config.mjs` to register the Inspecto webpack plugin:");
+  log.copyableCodeBlock([
+    "import { webpackPlugin as inspecto } from '@inspecto-dev/plugin'",
+    "",
+    "/** @type {import('next').NextConfig} */",
+    "const nextConfig = {",
+    "  webpack: (config, { dev, isServer }) => {",
+    "    if (dev && !isServer) {",
+    "      config.plugins.push(inspecto())",
+    "    }",
+    "    return config",
+    "  },",
+    "}",
+    "",
+    "export default nextConfig"
+  ]);
+  log.hint(
+    "2. Initialize `@inspecto-dev/core` from a client component such as `app/layout.tsx` or `pages/_app.tsx`:"
+  );
+  log.copyableCodeBlock([
+    "'use client'",
+    "",
+    "import { useEffect } from 'react'",
+    "",
+    "export default function RootLayout({ children }) {",
+    "  useEffect(() => {",
+    "    if (process.env.NODE_ENV !== 'production') {",
+    "      import('@inspecto-dev/core').then(({ mountInspector }) => {",
+    "        mountInspector({ serverUrl: 'http://127.0.0.1:5678' })",
+    "      })",
+    "    }",
+    "  }, [])",
+    "",
+    "  return <html><body>{children}</body></html>",
+    "}"
+  ]);
+  log.hint("3. Restart your Next.js dev server after updating the config.");
 }
 
 // src/commands/init.ts
 async function init(options) {
-  const root = process.cwd();
+  const repoRoot = process.cwd();
+  let projectRoot = repoRoot;
   const mutations = [];
   const normalizedPackages = normalizePackageList(options.packages);
   const verifiedPackages = [];
@@ -1163,7 +1952,7 @@ async function init(options) {
       verifiedPackages.push(pkg);
       continue;
     }
-    const absolutePath = path9.join(root, pkg);
+    const absolutePath = path10.join(repoRoot, pkg);
     if (await exists(absolutePath)) {
       verifiedPackages.push(pkg);
     } else {
@@ -1176,21 +1965,54 @@ async function init(options) {
     return;
   }
   log.header("Inspecto Setup");
-  if (!await exists(path9.join(root, "package.json"))) {
+  if (!await exists(path10.join(repoRoot, "package.json"))) {
     log.error("No package.json found in current directory");
     log.hint("Run this command from your project root");
     return;
   }
-  const [pm, frameworkResult, buildResult, ideProbe, providerProbe] = await Promise.all([
-    detectPackageManager(root),
-    detectFrameworks(root),
-    detectBuildTools(root, verifiedPackages.length > 0 ? verifiedPackages : void 0),
-    detectIDE(root),
-    detectProviders(root)
+  const pm = await detectPackageManager(repoRoot);
+  let buildResult = await detectBuildTools(
+    repoRoot,
+    verifiedPackages.length > 0 ? verifiedPackages : void 0
+  );
+  if (verifiedPackages.length === 0) {
+    const monorepoTargets = Array.from(
+      new Set(
+        buildResult.supported.map((d) => d.packagePath).filter((value) => !!value)
+      )
+    );
+    if (monorepoTargets.length > 1) {
+      log.warn("Monorepo root detected with multiple candidate apps.");
+      const selectedPackage = await promptMonorepoPackageChoice(buildResult.supported);
+      if (!selectedPackage) {
+        log.hint("Run `inspecto init` inside the target app, or pass --packages <app-path>.");
+        return;
+      }
+      projectRoot = path10.join(repoRoot, selectedPackage);
+      buildResult = await detectBuildTools(repoRoot, [selectedPackage]);
+      log.info(`Continuing initialization in ${selectedPackage}`);
+    } else if (monorepoTargets.length === 1) {
+      const [selectedPackage] = monorepoTargets;
+      projectRoot = path10.join(repoRoot, selectedPackage);
+      buildResult = await detectBuildTools(repoRoot, [selectedPackage]);
+      log.warn(`Monorepo root detected. Using the only candidate app: ${selectedPackage}`);
+      log.hint("Run `inspecto init` inside that app next time to skip this prompt.");
+    }
+  }
+  const [frameworkResult, ideProbe, providerProbe] = await Promise.all([
+    detectFrameworks(projectRoot),
+    detectIDE(projectRoot),
+    detectProviders(projectRoot)
   ]);
   log.success(`Detected package manager: ${pm}`);
   if (frameworkResult.supported.length > 0) {
-    log.success(`Detected framework: ${frameworkResult.supported.join(", ")}`);
+    const frameworks = frameworkResult.supported.join(", ");
+    log.success(`Detected framework: ${frameworks}`);
+    if (frameworkResult.unsupported.length > 0) {
+      log.hint(
+        `Other frameworks detected (${frameworkResult.unsupported.map((f) => f.name).join(", ")}) will be skipped in this setup.`
+      );
+    }
   }
   const isSupported = frameworkResult.supported.length > 0;
   const hasUnsupported = frameworkResult.unsupported.length > 0;
@@ -1219,7 +2041,9 @@ async function init(options) {
   }
   let manualConfigRequiredFor = "";
   if (verifiedPackages.length > 0 && buildResult.supported.length === 0) {
-    log.warn(`No supported build configs detected for: ${verifiedPackages.map((pkg) => pkg ? pkg : ".").join(", ")}`);
+    log.warn(
+      `No supported build configs detected for: ${verifiedPackages.map((pkg) => pkg ? pkg : ".").join(", ")}`
+    );
     log.hint("Double-check the --packages values or run without the flag to scan the repo root");
   }
   if (buildResult.supported.length > 0) {
@@ -1230,6 +2054,12 @@ async function init(options) {
     manualConfigRequiredFor = buildResult.unsupported[0] || "";
     log.warn(`Detected ${names} \u2014 automatic plugin injection is not supported in current version`);
     log.hint("You can still manually configure it by modifying your configuration file");
+    if (buildResult.unsupported.includes("Next.js")) {
+      printNextJsManualInstructions();
+    }
+    if (buildResult.unsupported.includes("Nuxt")) {
+      printNuxtManualInstructions();
+    }
   }
   if (buildResult.supported.length === 0 && buildResult.unsupported.length === 0) {
     log.warn("No recognized build tool detected");
@@ -1260,6 +2090,7 @@ async function init(options) {
     }
   }
   let selectedProvider = null;
+  const explicitProvider = options.provider ? providerProbe.detected.find((provider) => provider.id === options.provider) ?? null : null;
   if (!options.provider) {
     if (providerProbe.detected.length === 0) {
       log.warn("No supported AI tools detected");
@@ -1270,36 +2101,17 @@ async function init(options) {
         log.success(`Detected AI tool: ${selectedProvider.label}`);
       }
     } else {
+      log.info("Multiple providers detected, waiting for your selection...");
       selectedProvider = await promptProviderChoice(providerProbe.detected);
       if (selectedProvider) {
         log.success(`Selected provider: ${selectedProvider.label}`);
+      } else {
+        log.warn("No provider selected. You can set provider.default later in .inspecto/settings.");
       }
     }
   }
-  let installFailed = false;
-  if (options.skipInstall) {
-    log.warn("Skipping dependency installation (--skip-install)");
-  } else {
-    const installCmd = getInstallCommand(pm, "@inspecto-dev/plugin @inspecto-dev/core");
-    if (options.dryRun) {
-      log.dryRun(`Would run: ${installCmd}`);
-    } else {
-      try {
-        const result = await shell(installCmd, root);
-        if (result.stderr && result.stderr.toLowerCase().includes("error")) {
-          throw new Error(result.stderr);
-        }
-        log.success("Installed @inspecto-dev/plugin and @inspecto-dev/core as devDependencies");
-        mutations.push({ type: "dependency_added", name: "@inspecto-dev/plugin", dev: true });
-        mutations.push({ type: "dependency_added", name: "@inspecto-dev/core", dev: true });
-      } catch (err) {
-        installFailed = true;
-        log.error(`Failed to install dependency: ${err?.message || "Unknown error"}`);
-        log.hint(`Run manually: ${installCmd}`);
-      }
-    }
-  }
-  let injectionFailed = false;
+  let injectionSkippedRequiresManualConfig = false;
+  const supportedBuildTargets = [];
   if (buildResult.supported.length > 0) {
     if (verifiedPackages.length > 0) {
       const targets = buildResult.supported.filter(
@@ -1315,137 +2127,54 @@ async function init(options) {
         log.hint("Check the package paths or run without --packages to inspect the repo root");
       }
       if (targets.length === 0) {
-        injectionFailed = true;
-      }
-      for (const target of targets) {
-        const result = await injectPlugin(root, target, options.dryRun);
-        if (result.success) {
-          mutations.push(...result.mutations);
-        } else {
-          injectionFailed = true;
-        }
+        injectionSkippedRequiresManualConfig = true;
       }
+      supportedBuildTargets.push(...targets);
     } else {
       let target = resolveInjectionTarget(buildResult.supported);
       if (target === "ambiguous") {
         target = await promptConfigChoice(buildResult.supported);
       }
       if (target) {
-        const result = await injectPlugin(root, target, options.dryRun);
-        if (result.success) {
-          mutations.push(...result.mutations);
-        } else {
-          injectionFailed = true;
-        }
+        supportedBuildTargets.push(target);
       } else {
-        injectionFailed = true;
+        injectionSkippedRequiresManualConfig = true;
         log.warn("Skipping plugin injection (manual configuration required)");
       }
     }
   }
-  const settingsDir = path9.join(root, ".inspecto");
-  const settingsFileName = options.shared ? "settings.json" : "settings.local.json";
-  const promptsFileName = options.shared ? "prompts.json" : "prompts.local.json";
-  const settingsPath = path9.join(settingsDir, settingsFileName);
-  const promptsPath = path9.join(settingsDir, promptsFileName);
-  if (await exists(settingsPath)) {
-    const existingSettings = await readJSON(settingsPath);
-    if (existingSettings === null) {
-      log.warn(`.inspecto/${settingsFileName} exists but contains invalid JSON`);
-      log.hint("Please fix the syntax errors manually, or delete it and re-run init");
-    } else {
-      log.success(`.inspecto/${settingsFileName} already exists (skipped)`);
-    }
-  } else {
-    const defaultSettings = {};
-    if (selectedIDE && selectedIDE.supported) {
-      defaultSettings.ide = selectedIDE.ide.toLowerCase() === "vscode" ? "vscode" : selectedIDE.ide.toLowerCase();
-    }
-    if (options.provider) {
-      const tool = options.provider;
-      const mode = tool === "coco" ? "cli" : "extension";
-      defaultSettings["provider.default"] = `${tool}.${mode}`;
-    } else if (selectedProvider) {
-      const toolId = selectedProvider.id;
-      const mode = selectedProvider.preferredMode === "cli" ? "cli" : "extension";
-      defaultSettings["provider.default"] = `${toolId}.${mode}`;
-    }
-    if (options.dryRun) {
-      log.dryRun(`Would create .inspecto/${settingsFileName}`);
-    } else {
-      await writeJSON(settingsPath, defaultSettings);
-      log.success(`Created .inspecto/${settingsFileName}`);
-      mutations.push({ type: "file_created", path: `.inspecto/${settingsFileName}` });
-    }
-  }
-  if (await exists(promptsPath)) {
-    log.success(`.inspecto/${promptsFileName} already exists (skipped)`);
-  } else {
-    const defaultPrompts = [];
-    if (options.dryRun) {
-      log.dryRun(`Would create .inspecto/${promptsFileName}`);
-    } else {
-      await writeJSON(promptsPath, defaultPrompts);
-      log.success(`Created .inspecto/${promptsFileName}`);
-      mutations.push({ type: "file_created", path: `.inspecto/${promptsFileName}` });
-    }
-  }
-  if (!options.dryRun) {
-    await updateGitignore(root, options.shared, options.dryRun);
-    mutations.push({
-      type: "file_modified",
-      path: ".gitignore",
-      description: "Appended .inspecto/ ignore rules"
-    });
-  } else {
-    log.dryRun("Would update .gitignore");
-  }
-  if (!options.dryRun && mutations.length > 0) {
-    const lock = {
-      version: "1.0.0",
-      created_at: (/* @__PURE__ */ new Date()).toISOString(),
-      mutations
-    };
-    await writeJSON(path9.join(settingsDir, "install.lock"), lock);
-  }
-  const shouldInstallExt = !options.noExtension && (!selectedIDE || selectedIDE && selectedIDE.supported);
-  let manualExtensionInstallNeeded = false;
-  if (options.noExtension) {
-    log.warn("Skipping IDE extension (--no-extension)");
-  } else if (!shouldInstallExt) {
-  } else {
-    const extMutation = await installExtension(options.dryRun, selectedIDE?.ide);
-    if (extMutation && !options.dryRun) {
-      mutations.push(extMutation);
-      if (extMutation.manual_action_required) {
-        manualExtensionInstallNeeded = true;
-      }
-      const lockPath = path9.join(settingsDir, "install.lock");
-      const lock = await readJSON(lockPath);
-      if (lock) {
-        lock.mutations = mutations;
-        await writeJSON(lockPath, lock);
-      }
-    } else if (extMutation === null && !options.dryRun) {
-      manualExtensionInstallNeeded = true;
-    }
-  }
+  const providerDefault = options.provider ? `${options.provider}.${explicitProvider?.preferredMode ?? (options.provider === "coco" ? "cli" : "extension")}` : selectedProvider ? `${selectedProvider.id}.${selectedProvider.preferredMode === "cli" ? "cli" : "extension"}` : void 0;
+  const applyResult = await applyOnboardingPlan({
+    repoRoot,
+    projectRoot,
+    packageManager: pm,
+    supportedBuildTargets,
+    options: {
+      shared: options.shared,
+      skipInstall: options.skipInstall,
+      dryRun: options.dryRun,
+      noExtension: options.noExtension
+    },
+    selectedIDE,
+    providerDefault,
+    manualConfigRequiredFor,
+    injectionSkippedRequiresManualConfig,
+    allowManualPlanApply: true
+  });
+  mutations.push(...applyResult.mutations);
   if (options.dryRun) {
     log.blank();
     log.warn("Dry run complete. No files were modified.");
-  } else if (installFailed || injectionFailed || manualExtensionInstallNeeded || manualConfigRequiredFor) {
+  } else {
     log.blank();
-    log.warn("Setup completed with some manual steps required.");
-    if (manualConfigRequiredFor === "Nuxt") {
-      printNuxtManualInstructions();
-    } else if (manualConfigRequiredFor === "Next.js") {
-      printNextJsManualInstructions();
+    if (applyResult.postInstall.nextSteps.length > 0) {
+      log.warn("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 Manual Steps Required \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+      applyResult.postInstall.nextSteps.forEach((step) => log.error(step));
+      log.hint("Complete the items above.");
+      log.blank();
     } else {
-      log.hint("Please check the logs above and complete the manual steps.");
+      log.ready("Ready! Hold Alt + Click any element to inspect.");
     }
-    log.blank();
-  } else {
-    log.ready("Ready! Hold Alt + Click any element to inspect.");
   }
 }
 function normalizePackageList(packages) {
@@ -1471,15 +2200,66 @@ function matchesAnyPackage(detection, packages) {
 }
 
 // src/commands/doctor.ts
-import path10 from "path";
-async function doctor() {
-  const root = process.cwd();
-  const result = { errors: 0, warnings: 0 };
+import path11 from "path";
+function createDiagnostic(code, status, message2, hints = [], details) {
+  return {
+    code,
+    status,
+    message: message2,
+    hints,
+    ...details ? { details } : {}
+  };
+}
+function doctorStatus(errors, warnings) {
+  if (errors > 0) return "blocked";
+  if (warnings > 0) return "warning";
+  return "ok";
+}
+function printDoctorResult(result) {
   log.header("Inspecto Doctor");
-  if (!await exists(path10.join(root, "package.json"))) {
-    log.error("No package.json found");
-    log.hint("Run this command from your project root");
-    return;
+  for (const check of result.checks) {
+    if (check.status === "ok") {
+      log.success(check.message);
+    } else if (check.status === "warning") {
+      log.warn(check.message);
+    } else {
+      log.error(check.message);
+    }
+    for (const hint of check.hints) {
+      log.hint(hint);
+    }
+  }
+  log.blank();
+  if (result.summary.errors === 0 && result.summary.warnings === 0) {
+    log.success("All checks passed. Hold Alt + Click to start!");
+  } else {
+    const parts = [];
+    if (result.summary.errors > 0) parts.push(`${result.summary.errors} error(s)`);
+    if (result.summary.warnings > 0) parts.push(`${result.summary.warnings} warning(s)`);
+    console.log(
+      `  ${parts.join(", ")}. ${result.summary.errors > 0 ? "Fix the errors above to get started." : ""}`
+    );
+  }
+  log.blank();
+}
+async function collectDoctorResult(root = process.cwd()) {
+  const checks = [];
+  if (!await exists(path11.join(root, "package.json"))) {
+    const diagnostic = createDiagnostic(
+      "missing-package-json",
+      "error",
+      "No package.json found",
+      ["Run this command from your project root"]
+    );
+    checks.push(diagnostic);
+    return {
+      status: "blocked",
+      summary: { errors: 1, warnings: 0 },
+      project: { root },
+      errors: [diagnostic],
+      warnings: [],
+      checks
+    };
   }
   const [ideProbe, frameworkResult, providerProbe, pm, buildResult, extInstalled] = await Promise.all([
     detectIDE(root),
@@ -1490,34 +2270,68 @@ async function doctor() {
     isExtensionInstalled()
   ]);
   if (ideProbe.detected.length === 0) {
-    log.warn("IDE: not detected");
-    result.warnings++;
+    checks.push(createDiagnostic("ide-not-detected", "warning", "IDE: not detected"));
   } else {
     const hasSupported = ideProbe.detected.some((d) => d.supported);
     if (hasSupported) {
-      log.success(
-        `IDE: ${ideProbe.detected.filter((d) => d.supported).map((d) => d.ide).join(", ")}`
+      checks.push(
+        createDiagnostic(
+          "ide-supported",
+          "ok",
+          `IDE: ${ideProbe.detected.filter((d) => d.supported).map((d) => d.ide).join(", ")}`,
+          [],
+          {
+            detected: ideProbe.detected
+          }
+        )
       );
     } else {
       const names = ideProbe.detected.map((d) => d.ide).join(", ");
-      log.warn(`IDE: ${names} (not supported in v1, VS Code, Cursor, Trae only)`);
-      result.warnings++;
+      checks.push(
+        createDiagnostic(
+          "ide-unsupported",
+          "warning",
+          `IDE: ${names} (not supported in v1, VS Code, Cursor, Trae only)`,
+          [],
+          {
+            detected: ideProbe.detected
+          }
+        )
+      );
     }
   }
   if (frameworkResult.supported.length > 0) {
-    log.success(`Framework: ${frameworkResult.supported.join(", ")}`);
+    checks.push(
+      createDiagnostic(
+        "framework-supported",
+        "ok",
+        `Framework: ${frameworkResult.supported.join(", ")}`
+      )
+    );
   } else if (frameworkResult.unsupported.length > 0) {
     const names = frameworkResult.unsupported.map((f) => f.name).join(", ");
-    log.warn(`Framework: ${names} (not supported in v1, React/Vue only)`);
-    result.warnings++;
+    checks.push(
+      createDiagnostic(
+        "framework-unsupported",
+        "warning",
+        `Framework: ${names} (not supported in v1, React/Vue only)`
+      )
+    );
   } else {
-    log.warn("Framework: not detected (React / Vue expected)");
-    result.warnings++;
+    checks.push(
+      createDiagnostic(
+        "framework-not-detected",
+        "warning",
+        "Framework: not detected (React / Vue expected)"
+      )
+    );
   }
   if (providerProbe.detected.length === 0) {
-    log.warn("Provider: none detected");
-    log.hint("Inspecto works best with Claude Code, Trae CLI, or GitHub Copilot");
-    result.warnings++;
+    checks.push(
+      createDiagnostic("provider-missing", "warning", "Provider: none detected", [
+        "Inspecto works best with Claude Code, Trae CLI, or GitHub Copilot"
+      ])
+    );
   } else {
     const aiNames = providerProbe.detected.map((d) => {
       const modeLabels = d.providerModes.map(
@@ -1525,58 +2339,80 @@ async function doctor() {
       );
       return `${d.label} (${modeLabels.join(" & ")})`;
     }).join(", ");
-    log.success(`Provider: ${aiNames}`);
+    checks.push(createDiagnostic("provider-detected", "ok", `Provider: ${aiNames}`));
   }
-  const pluginPath = path10.join(root, "node_modules", "@inspecto-dev", "plugin");
+  const pluginPath = path11.join(root, "node_modules", "@inspecto-dev", "plugin");
   if (await exists(pluginPath)) {
-    const pkgJson = await readJSON(path10.join(pluginPath, "package.json"));
+    const pkgJson = await readJSON(path11.join(pluginPath, "package.json"));
     const version = pkgJson?.version ?? "unknown";
-    log.success(`@inspecto-dev/plugin@${version} installed`);
+    checks.push(
+      createDiagnostic("plugin-installed", "ok", `@inspecto-dev/plugin@${version} installed`, [], {
+        version
+      })
+    );
   } else {
-    log.error("@inspecto-dev/plugin not installed");
-    const pm2 = await detectPackageManager(root);
-    log.hint(`Fix: ${getInstallCommand(pm2, "@inspecto-dev/plugin")}`);
-    result.errors++;
+    checks.push(
+      createDiagnostic("plugin-missing", "error", "@inspecto-dev/plugin not installed", [
+        `Fix: ${getInstallCommand(pm, "@inspecto-dev/plugin")}`
+      ])
+    );
   }
   if (buildResult.supported.length > 0) {
     let injected = false;
     for (const bt of buildResult.supported) {
-      const content = await readFile(path10.join(root, bt.configPath));
+      const content = await readFile(path11.join(root, bt.configPath));
       if (content && content.includes("@inspecto-dev/plugin")) {
-        log.success(`Plugin configured in ${bt.configPath}`);
+        checks.push(
+          createDiagnostic("plugin-configured", "ok", `Plugin configured in ${bt.configPath}`, [], {
+            configPath: bt.configPath,
+            buildTool: bt.tool
+          })
+        );
         injected = true;
         break;
       }
     }
     if (!injected) {
-      log.error("Plugin not configured in any build config");
-      log.hint("Fix: npx @inspecto-dev/cli init");
-      result.errors++;
+      checks.push(
+        createDiagnostic("plugin-not-configured", "error", "Plugin not configured in any build config", [
+          "Fix: npx @inspecto-dev/cli init"
+        ])
+      );
     }
   } else if (buildResult.unsupported.length > 0) {
     const names = buildResult.unsupported.join(", ");
-    log.warn(`Build tool: ${names} (not supported in v1)`);
-    log.hint("current version supports: Vite, Webpack, Rspack, esbuild, Rollup");
-    result.warnings++;
+    checks.push(
+      createDiagnostic(`build-tool-unsupported`, "warning", `Build tool: ${names} (not supported in v1)`, [
+        "current version supports: Vite, Webpack, Rspack, esbuild, Rollup"
+      ])
+    );
   } else {
-    log.warn("No recognized build config found");
-    result.warnings++;
+    checks.push(createDiagnostic("build-tool-missing", "warning", "No recognized build config found"));
   }
   if (extInstalled) {
-    log.success("VS Code extension detected");
+    checks.push(createDiagnostic("extension-installed", "ok", "VS Code extension detected"));
   } else {
-    const hasSupported = ideProbe.detected.some((d) => d.supported);
-    if (ideProbe.detected.length > 0 && !hasSupported) {
-      log.warn("VS Code extension not applicable (non-VS Code IDE)");
+    const hasVSCode = ideProbe.detected.some((d) => d.supported && d.ide === "vscode");
+    const hasSupportedNonVSCode = ideProbe.detected.some((d) => d.supported && d.ide !== "vscode");
+    if (hasSupportedNonVSCode && !hasVSCode) {
+      checks.push(
+        createDiagnostic(
+          "extension-not-applicable",
+          "warning",
+          "VS Code extension not applicable (non-VS Code IDE)"
+        )
+      );
     } else {
-      log.error("VS Code extension not found");
-      log.hint("Fix: code --install-extension inspecto.inspecto");
-      log.hint("Or: https://marketplace.visualstudio.com/items?itemName=inspecto.inspecto");
-      result.errors++;
+      checks.push(
+        createDiagnostic("extension-missing", "error", "VS Code extension not found", [
+          "Fix: code --install-extension inspecto.inspecto",
+          "Or: https://marketplace.visualstudio.com/items?itemName=inspecto.inspecto"
+        ])
+      );
     }
   }
-  const settingsJsonPath = path10.join(root, ".inspecto", "settings.json");
-  const settingsLocalPath = path10.join(root, ".inspecto", "settings.local.json");
+  const settingsJsonPath = path11.join(root, ".inspecto", "settings.json");
+  const settingsLocalPath = path11.join(root, ".inspecto", "settings.local.json");
   const hasSettingsJson = await exists(settingsJsonPath);
   const hasSettingsLocal = await exists(settingsLocalPath);
   if (hasSettingsJson || hasSettingsLocal) {
@@ -1584,48 +2420,108 @@ async function doctor() {
     const fileName = hasSettingsLocal ? "settings.local.json" : "settings.json";
     const settings = await readJSON(targetPath);
     if (settings) {
-      log.success(`.inspecto/${fileName} valid`);
+      checks.push(createDiagnostic("settings-valid", "ok", `.inspecto/${fileName} valid`));
     } else {
-      log.error(`.inspecto/${fileName} has invalid JSON`);
-      log.hint(
-        "Fix: Manually correct the syntax errors, or delete the file and re-run npx @inspecto-dev/cli init"
+      checks.push(
+        createDiagnostic(
+          "settings-invalid-json",
+          "error",
+          `.inspecto/${fileName} has invalid JSON`,
+          [
+            "Fix: Manually correct the syntax errors, or delete the file and re-run npx @inspecto-dev/cli init"
+          ],
+          {
+            fileName
+          }
+        )
       );
-      result.errors++;
     }
   } else {
-    log.warn("No .inspecto/settings.json or settings.local.json found (using defaults)");
-    log.hint("Optional: npx @inspecto-dev/cli init");
-    result.warnings++;
+    checks.push(
+      createDiagnostic(
+        "settings-missing",
+        "warning",
+        "No .inspecto/settings.json or settings.local.json found (using defaults)",
+        ["Optional: npx @inspecto-dev/cli init"]
+      )
+    );
   }
-  const gitignoreContent = await readFile(path10.join(root, ".gitignore"));
+  const gitignoreContent = await readFile(path11.join(root, ".gitignore"));
   if (gitignoreContent) {
     const hasLockIgnore = gitignoreContent.includes(".inspecto/install.lock") || gitignoreContent.includes(".inspecto/");
     if (!hasLockIgnore) {
-      log.warn(".inspecto/install.lock not in .gitignore");
-      log.hint("install.lock contains local machine state and should not be committed");
-      result.warnings++;
+      checks.push(
+        createDiagnostic(
+          "gitignore-missing-install-lock",
+          "warning",
+          ".inspecto/install.lock not in .gitignore",
+          ["install.lock contains local machine state and should not be committed"]
+        )
+      );
     }
   }
-  log.blank();
-  if (result.errors === 0 && result.warnings === 0) {
-    log.success("All checks passed. Hold Alt + Click to start!");
-  } else {
-    const parts = [];
-    if (result.errors > 0) parts.push(`${result.errors} error(s)`);
-    if (result.warnings > 0) parts.push(`${result.warnings} warning(s)`);
-    console.log(
-      `  ${parts.join(", ")}. ${result.errors > 0 ? "Fix the errors above to get started." : ""}`
-    );
+  const errors = checks.filter((check) => check.status === "error");
+  const warnings = checks.filter((check) => check.status === "warning");
+  return {
+    status: doctorStatus(errors.length, warnings.length),
+    summary: {
+      errors: errors.length,
+      warnings: warnings.length
+    },
+    project: {
+      root,
+      packageManager: pm
+    },
+    errors,
+    warnings,
+    checks
+  };
+}
+async function doctor(options = {}) {
+  const json = typeof options === "boolean" ? options : options.json ?? false;
+  const result = await collectDoctorResult(process.cwd());
+  return writeCommandOutput(result, json, printDoctorResult);
+}
+
+// src/commands/plan.ts
+function printPlanResult(result) {
+  log.header("Inspecto Plan");
+  log.info(`Status: ${result.status}`);
+  log.info(`Strategy: ${result.strategy}`);
+  if (result.defaults.provider) {
+    log.info(`Default provider: ${result.defaults.provider}`);
+  }
+  if (result.defaults.ide) {
+    log.info(`Default IDE: ${result.defaults.ide}`);
+  }
+  log.info(`Shared mode: ${result.defaults.shared ? "enabled" : "disabled"}`);
+  log.info(`Extension mode: ${result.defaults.extension ? "enabled" : "disabled"}`);
+  if (result.actions.length > 0) {
+    log.blank();
+    log.info("Actions:");
+    for (const action of result.actions) {
+      log.hint(`${action.type}: ${action.target} \u2014 ${action.description}`);
+    }
+  }
+  for (const blocker of result.blockers) {
+    log.error(blocker.message);
+  }
+  for (const warning of result.warnings) {
+    log.warn(warning.message);
   }
-  log.blank();
+}
+async function plan(json = false) {
+  const context = await buildOnboardingContext(process.cwd());
+  const result = createPlanResult(context);
+  return writeCommandOutput(result, json, printPlanResult);
 }
 
 // src/commands/teardown.ts
-import path11 from "path";
+import path12 from "path";
 async function teardown() {
   const root = process.cwd();
   log.header("Inspecto Teardown");
-  const lockPath = path11.join(root, ".inspecto", "install.lock");
+  const lockPath = path12.join(root, ".inspecto", "install.lock");
   const lock = await readJSON(lockPath);
   if (!lock) {
     log.warn("No .inspecto/install.lock found. Running in best-effort mode.");
@@ -1638,8 +2534,8 @@ async function teardown() {
     } catch {
       log.warn("Could not remove @inspecto-dev/plugin (may not be installed)");
     }
-    if (await exists(path11.join(root, ".inspecto"))) {
-      await removeDir(path11.join(root, ".inspecto"));
+    if (await exists(path12.join(root, ".inspecto"))) {
+      await removeDir(path12.join(root, ".inspecto"));
       log.success("Deleted .inspecto/ directory");
     }
     await cleanGitignore(root);
@@ -1688,7 +2584,7 @@ async function teardown() {
       }
     }
   }
-  await removeDir(path11.join(root, ".inspecto"));
+  await removeDir(path12.join(root, ".inspecto"));
   log.success("Deleted .inspecto/ directory");
   await cleanGitignore(root);
   log.blank();
@@ -1697,8 +2593,13 @@ async function teardown() {
 }
 
 export {
-  log,
+  writeCommandOutput,
+  reportCommandError,
+  apply,
+  detect,
   init,
+  collectDoctorResult,
   doctor,
+  plan,
   teardown
 };