@inspecto-dev/cli 0.3.1 → 0.3.3

package/dist/{chunk-PSYZB5GI.js → chunk-LJOKPCPD.js}

@@ -90,7 +90,7 @@ function reportCommandError(error, options = {}) {
 }
 
 // src/onboarding/apply.ts
-import path5 from "path";
+import path6 from "path";
 import ora from "ora";
 
 // src/detect/package-manager.ts
@@ -496,24 +496,119 @@ async function which(bin) {
   }
 }
 
+// src/integrations/capabilities.ts
+import path4 from "path";
+import {
+  DUAL_MODE_PROVIDER_CAPABILITIES,
+  HOST_IDE_IDS,
+  getHostIdeLabel,
+  isSupportedHostIde
+} from "@inspecto-dev/types";
+var HOST_IDE_CAPABILITIES = {
+  vscode: {
+    label: "VS Code",
+    artifactDir: ".vscode",
+    extensionDir: ".vscode/extensions",
+    binaryName: "code",
+    binaryPaths: {
+      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`
+      ]
+    }
+  },
+  cursor: {
+    label: "Cursor",
+    artifactDir: ".cursor",
+    extensionDir: ".cursor/extensions",
+    binaryName: "cursor",
+    binaryPaths: {
+      darwin: [
+        "/Applications/Cursor.app/Contents/Resources/app/bin/cursor",
+        `${process.env.HOME}/Applications/Cursor.app/Contents/Resources/app/bin/cursor`
+      ],
+      linux: ["/usr/bin/cursor", "/opt/Cursor/resources/app/bin/cursor"],
+      win32: [
+        `${process.env.LOCALAPPDATA}\\Programs\\Cursor\\resources\\app\\bin\\cursor.cmd`,
+        `${process.env.PROGRAMFILES}\\Cursor\\resources\\app\\bin\\cursor.cmd`
+      ]
+    }
+  },
+  trae: {
+    label: "Trae",
+    artifactDir: ".trae",
+    extensionDir: ".trae/extensions",
+    binaryName: "trae",
+    binaryPaths: {
+      darwin: [
+        "/Applications/Trae.app/Contents/Resources/app/bin/trae",
+        `${process.env.HOME}/Applications/Trae.app/Contents/Resources/app/bin/trae`
+      ],
+      linux: ["/usr/bin/trae", "/opt/Trae/resources/app/bin/trae"],
+      win32: [
+        `${process.env.LOCALAPPDATA}\\Programs\\Trae\\resources\\app\\bin\\trae.cmd`,
+        `${process.env.PROGRAMFILES}\\Trae\\resources\\app\\bin\\trae.cmd`
+      ]
+    }
+  },
+  "trae-cn": {
+    label: "Trae CN",
+    artifactDir: ".trae-cn",
+    extensionDir: ".trae-cn/extensions",
+    binaryName: "trae-cn",
+    binaryPaths: {
+      darwin: [
+        "/Applications/Trae CN.app/Contents/Resources/app/bin/trae-cn",
+        `${process.env.HOME}/Applications/Trae CN.app/Contents/Resources/app/bin/trae-cn`
+      ],
+      linux: ["/usr/bin/trae-cn", "/opt/Trae CN/resources/app/bin/trae-cn"],
+      win32: [
+        `${process.env.LOCALAPPDATA}\\Programs\\Trae CN\\resources\\app\\bin\\trae-cn.cmd`,
+        `${process.env.PROGRAMFILES}\\Trae CN\\resources\\app\\bin\\trae-cn.cmd`
+      ]
+    }
+  }
+};
+function getHostIdeResolutionSourceLabel(source) {
+  if (source === "explicit") return "from --host-ide";
+  if (source === "config") return "from .inspecto settings";
+  if (source === "env") return "from IDE terminal environment";
+  if (source === "artifact") return "from project files";
+  return source;
+}
+function getHostIdeArtifactPath(ide, cwd) {
+  return path4.join(cwd, HOST_IDE_CAPABILITIES[ide].artifactDir);
+}
+function getHostIdeExtensionDir(ide, homeDir) {
+  return path4.join(homeDir, HOST_IDE_CAPABILITIES[ide].extensionDir);
+}
+function getHostIdeBinaryName(ide) {
+  return HOST_IDE_CAPABILITIES[ide].binaryName ?? null;
+}
+function getHostIdeBinaryCandidates(ide) {
+  const platform = process.platform;
+  return HOST_IDE_CAPABILITIES[ide].binaryPaths?.[platform] ?? [];
+}
+function getDualModeAssistantCapability(assistant) {
+  return DUAL_MODE_PROVIDER_CAPABILITIES[assistant];
+}
+
 // 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] || [];
+  const candidates = getHostIdeBinaryCandidates("vscode");
   for (const candidate of candidates) {
     if (await exists(candidate)) {
       return candidate;
@@ -524,7 +619,70 @@ async function findVSCodeBinary() {
   }
   return null;
 }
-async function tryOpenURI(uri) {
+async function findIdeBinary(ide) {
+  const binaryName = getHostIdeBinaryName(ide);
+  if (binaryName && await which(binaryName)) {
+    return binaryName;
+  }
+  if (ide === "vscode") {
+    return findVSCodeBinary();
+  }
+  const candidates = getHostIdeBinaryCandidates(ide);
+  for (const candidate of candidates) {
+    if (await exists(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+async function installAlternativeIdeExtension(binaryPath, ideLabel, extensionRef, quiet) {
+  try {
+    const { stdout } = await run(binaryPath, ["--list-extensions"]);
+    if (extensionRef === EXTENSION_ID && stdout.toLowerCase().includes(EXTENSION_ID)) {
+      if (!quiet) {
+        log.success(`${ideLabel} extension already installed`);
+      }
+      return { type: "extension_installed", id: EXTENSION_ID, description: "already_installed" };
+    }
+  } catch {
+  }
+  try {
+    await run(binaryPath, ["--install-extension", extensionRef, "--force"]);
+    if (!quiet) {
+      log.success(`${ideLabel} extension installed via CLI`);
+    }
+    return { type: "extension_installed", id: extensionRef, description: "installed_via_cli" };
+  } catch {
+    try {
+      const { stdout } = await run(binaryPath, ["--list-extensions"]);
+      if (extensionRef === EXTENSION_ID && stdout.toLowerCase().includes(EXTENSION_ID)) {
+        if (!quiet) {
+          log.success(`${ideLabel} extension already installed`);
+        }
+        return { type: "extension_installed", id: EXTENSION_ID, description: "already_installed" };
+      }
+    } catch {
+    }
+    return null;
+  }
+}
+async function resolveHostIdeBinary(ide) {
+  if (!isSupportedHostIde(ide)) return null;
+  return findIdeBinary(ide);
+}
+async function openIdeWorkspace(ide, cwd) {
+  const binaryPath = await resolveHostIdeBinary(ide);
+  if (!binaryPath) {
+    return false;
+  }
+  try {
+    await run(binaryPath, ["--new-window", cwd]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function openUri(uri) {
   try {
     const platform = process.platform;
     if (platform === "win32") {
@@ -538,7 +696,7 @@ async function tryOpenURI(uri) {
     return false;
   }
 }
-async function installExtension(dryRun, ide, quiet = false) {
+async function installExtension(dryRun, ide, quiet = false, extensionRef = EXTENSION_ID) {
   if (dryRun) {
     if (!quiet) {
       log.dryRun("Would attempt to install VS Code extension");
@@ -553,7 +711,7 @@ async function installExtension(dryRun, ide, quiet = false) {
         if (!quiet) {
           log.success("VS Code extension installed via CLI");
         }
-        return { type: "extension_installed", id: EXTENSION_ID };
+        return { type: "extension_installed", id: EXTENSION_ID, description: "installed_via_cli" };
       } catch {
       }
     }
@@ -567,17 +725,22 @@ async function installExtension(dryRun, ide, quiet = false) {
             'Tip: Add "code" to your PATH to help Inspecto detect other AI tools in the future'
           );
         }
-        return { type: "extension_installed", id: EXTENSION_ID };
+        return { type: "extension_installed", id: EXTENSION_ID, description: "installed_via_cli" };
       } catch {
       }
     }
     const uri = `vscode:extension/${EXTENSION_ID}`;
-    if (await tryOpenURI(uri)) {
+    if (await openUri(uri)) {
       if (!quiet) {
         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 };
+      return {
+        type: "extension_installed",
+        id: EXTENSION_ID,
+        description: "opened_install_page",
+        manual_action_required: true
+      };
     }
     if (!quiet) {
       log.warn("Could not auto-install VS Code extension");
@@ -589,6 +752,48 @@ async function installExtension(dryRun, ide, quiet = false) {
     }
     return null;
   }
+  if (ide === "cursor" && process.platform === "darwin") {
+    const cursorPath = await findIdeBinary("cursor");
+    if (cursorPath) {
+      const result = await installAlternativeIdeExtension(
+        cursorPath,
+        getHostIdeLabel("cursor"),
+        extensionRef,
+        quiet
+      );
+      if (result) {
+        return result;
+      }
+    }
+  }
+  if (ide === "trae" && process.platform === "darwin") {
+    const traePath = await findIdeBinary("trae");
+    if (traePath) {
+      const result = await installAlternativeIdeExtension(
+        traePath,
+        getHostIdeLabel("trae"),
+        extensionRef,
+        quiet
+      );
+      if (result) {
+        return result;
+      }
+    }
+  }
+  if (ide === "trae-cn" && process.platform === "darwin") {
+    const traeCnPath = await findIdeBinary("trae-cn");
+    if (traeCnPath) {
+      const result = await installAlternativeIdeExtension(
+        traeCnPath,
+        getHostIdeLabel("trae-cn"),
+        extensionRef,
+        quiet
+      );
+      if (result) {
+        return result;
+      }
+    }
+  }
   if (!quiet) {
     log.warn(`Could not auto-install extension for ${ide}`);
     log.hint("Please install it manually to enable Inspector features:");
@@ -620,11 +825,11 @@ async function isExtensionInstalled() {
 }
 
 // src/inject/gitignore.ts
-import path4 from "path";
+import path5 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, quiet = false) {
-  const gitignorePath = path4.join(root, ".gitignore");
+  const gitignorePath = path5.join(root, ".gitignore");
   let content = await readFile(gitignorePath) ?? "";
   const desiredRules = shared ? SHARED_RULES : DEFAULT_RULES;
   const hasGlobalRule = content.match(/^\.inspecto\/\s*$/m) !== null;
@@ -656,7 +861,7 @@ async function updateGitignore(root, shared, dryRun, quiet = false) {
   }
 }
 async function cleanGitignore(root) {
-  const gitignorePath = path4.join(root, ".gitignore");
+  const gitignorePath = path5.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");
@@ -675,11 +880,11 @@ function resolveRuntimePackages() {
       installedDependencyNames: ["@inspecto-dev/plugin", "@inspecto-dev/core"]
     };
   }
-  const normalizedRepo = path5.resolve(devRepo);
+  const normalizedRepo = path6.resolve(devRepo);
   return {
     installSpec: [
-      shellQuote(path5.join(normalizedRepo, "packages/plugin")),
-      shellQuote(path5.join(normalizedRepo, "packages/core"))
+      shellQuote(path6.join(normalizedRepo, "packages/plugin")),
+      shellQuote(path6.join(normalizedRepo, "packages/core"))
     ].join(" "),
     installedDependencyNames: ["@inspecto-dev/plugin", "@inspecto-dev/core"]
   };
@@ -768,11 +973,11 @@ async function applyOnboardingPlanInternal(input) {
     };
   }
   const mutations = [];
-  const settingsDir = path5.join(input.projectRoot, ".inspecto");
+  const settingsDir = path6.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 settingsPath = path6.join(settingsDir, settingsFileName);
+  const promptsPath = path6.join(settingsDir, promptsFileName);
   const runtimePackages = resolveRuntimePackages();
   const installCmd = getInstallCommand(input.packageManager, runtimePackages.installSpec);
   const nextSteps = [];
@@ -873,7 +1078,7 @@ async function applyOnboardingPlanInternal(input) {
       created_at: (/* @__PURE__ */ new Date()).toISOString(),
       mutations
     };
-    await writeJSON(path5.join(settingsDir, "install.lock"), lock);
+    await writeJSON(path6.join(settingsDir, "install.lock"), lock);
   }
   const shouldInstallExt = !input.options.noExtension && (!input.selectedIDE || input.selectedIDE.supported);
   let manualExtensionInstallNeeded = false;
@@ -890,7 +1095,7 @@ async function applyOnboardingPlanInternal(input) {
       if (extMutation.manual_action_required) {
         manualExtensionInstallNeeded = true;
       }
-      const lockPath = path5.join(settingsDir, "install.lock");
+      const lockPath = path6.join(settingsDir, "install.lock");
       const lock = await readJSON(lockPath);
       if (lock) {
         lock.mutations = mutations;
@@ -935,12 +1140,12 @@ async function applyOnboardingPlanInternal(input) {
 }
 
 // src/detect/build-tool.ts
-import path6 from "path";
+import path7 from "path";
 import fs2 from "fs/promises";
 import { createRequire } from "module";
 function isPackageResolvable(pkgName, root) {
   try {
-    const require2 = createRequire(path6.join(root, "package.json"));
+    const require2 = createRequire(path7.join(root, "package.json"));
     try {
       require2.resolve(`${pkgName}/package.json`, { paths: [root] });
       return true;
@@ -954,7 +1159,7 @@ function isPackageResolvable(pkgName, root) {
 }
 async function getResolvedPackageVersion(pkgName, root) {
   try {
-    const require2 = createRequire(path6.join(root, "package.json"));
+    const require2 = createRequire(path7.join(root, "package.json"));
     const pkgJsonPath = require2.resolve(`${pkgName}/package.json`, { paths: [root] });
     const pkg = await readJSON(pkgJsonPath);
     return pkg?.version || null;
@@ -1009,9 +1214,9 @@ var UNSUPPORTED_META = [
   { 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);
+  const relative = path7.relative(root, filePath);
+  const normalized = relative.split(path7.sep).join("/");
+  return normalized || path7.basename(filePath);
 }
 function createTargets(root, packagePaths) {
   if (!packagePaths || packagePaths.length === 0) {
@@ -1019,12 +1224,12 @@ function createTargets(root, packagePaths) {
   }
   return packagePaths.map((pkg) => ({
     packagePath: pkg,
-    absolutePath: pkg ? path6.join(root, pkg) : root
+    absolutePath: pkg ? path7.join(root, pkg) : root
   }));
 }
 async function getWorkspacePackagePatterns(root) {
   const pkg = await readJSON(
-    path6.join(root, "package.json")
+    path7.join(root, "package.json")
   );
   const workspaces = pkg?.workspaces;
   if (Array.isArray(workspaces)) {
@@ -1033,7 +1238,7 @@ async function getWorkspacePackagePatterns(root) {
   if (workspaces && Array.isArray(workspaces.packages)) {
     return workspaces.packages;
   }
-  const pnpmWorkspace = await readFile(path6.join(root, "pnpm-workspace.yaml"));
+  const pnpmWorkspace = await readFile(path7.join(root, "pnpm-workspace.yaml"));
   if (!pnpmWorkspace) {
     return [];
   }
@@ -1052,7 +1257,7 @@ async function expandWorkspacePattern(root, pattern) {
     return [];
   }
   if (!normalized.includes("*")) {
-    return await exists(path6.join(root, normalized)) ? [normalized] : [];
+    return await exists(path7.join(root, normalized)) ? [normalized] : [];
   }
   const starIndex = normalized.indexOf("*");
   const baseDir = normalized.slice(0, starIndex).replace(/\/$/, "");
@@ -1060,13 +1265,13 @@ async function expandWorkspacePattern(root, pattern) {
   if (suffix && suffix !== "") {
     return [];
   }
-  const absoluteBaseDir = path6.join(root, baseDir);
+  const absoluteBaseDir = path7.join(root, baseDir);
   if (!await exists(absoluteBaseDir)) {
     return [];
   }
   try {
     const entries = await fs2.readdir(absoluteBaseDir, { withFileTypes: true });
-    return entries.filter((entry) => entry.isDirectory()).map((entry) => path6.posix.join(baseDir, entry.name));
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => path7.posix.join(baseDir, entry.name));
   } catch {
     return [];
   }
@@ -1085,7 +1290,7 @@ async function detectWorkspaceTargets(root) {
   }
   return Array.from(packagePaths).map((packagePath) => ({
     packagePath,
-    absolutePath: path6.join(root, packagePath)
+    absolutePath: path7.join(root, packagePath)
   }));
 }
 async function detectBuildTools(root, packagePaths) {
@@ -1095,7 +1300,7 @@ async function detectBuildTools(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 pkg = await readJSON(path7.join(target.absolutePath, "package.json"));
     const allDeps = { ...pkg?.dependencies, ...pkg?.devDependencies };
     const scripts = pkg?.scripts || {};
     const supportedChecks = SUPPORTED_PATTERNS.map(
@@ -1117,7 +1322,7 @@ async function detectBuildTools(root, packagePaths) {
     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))) {
+        if (await exists(path7.join(target.absolutePath, file))) {
           return meta.name;
         }
       }
@@ -1165,7 +1370,7 @@ async function detectPattern({
     return null;
   }
   for (const file of pattern.files) {
-    if (await exists(path6.join(targetRoot, file))) {
+    if (await exists(path7.join(targetRoot, file))) {
       detectedFile = file;
       break;
     }
@@ -1175,7 +1380,7 @@ async function detectPattern({
       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 (await exists(path7.join(targetRoot, match[1]))) {
             if (cmd.includes(pattern.tool) || match[1].includes(pattern.tool)) {
               detectedFile = match[1];
               break;
@@ -1186,7 +1391,7 @@ async function detectPattern({
         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]))) {
+            if (await exists(path7.join(targetRoot, configMatch[1]))) {
               detectedFile = configMatch[1];
               break;
             }
@@ -1224,7 +1429,7 @@ async function detectPattern({
       isLegacyWebpack = true;
     }
   }
-  const absoluteConfig = path6.join(targetRoot, detectedFile);
+  const absoluteConfig = path7.join(targetRoot, detectedFile);
   const relativeConfig = normalizeRelativePath(workspaceRoot, absoluteConfig);
   return {
     tool: pattern.tool,
@@ -1242,7 +1447,7 @@ function resolveInjectionTarget(detections) {
 }
 
 // src/detect/framework.ts
-import path7 from "path";
+import path8 from "path";
 import { createRequire as createRequire2 } from "module";
 var META_FRAMEWORK_MAP = {
   next: "react",
@@ -1268,7 +1473,7 @@ var UNSUPPORTED_FRAMEWORKS = [
 ];
 function isPackageResolvable2(pkgName, root) {
   try {
-    const require2 = createRequire2(path7.join(root, "package.json"));
+    const require2 = createRequire2(path8.join(root, "package.json"));
     try {
       require2.resolve(`${pkgName}/package.json`, { paths: [root] });
       return true;
@@ -1281,7 +1486,7 @@ function isPackageResolvable2(pkgName, root) {
   }
 }
 async function detectFrameworks(root) {
-  const pkg = await readJSON(path7.join(root, "package.json"));
+  const pkg = await readJSON(path8.join(root, "package.json"));
   const allDeps = {
     ...pkg?.dependencies || {},
     ...pkg?.devDependencies || {},
@@ -1316,7 +1521,7 @@ async function detectFrameworks(root) {
 }
 
 // src/detect/ide.ts
-import path8 from "path";
+import path9 from "path";
 var SUPPORTED_IDE = "vscode";
 async function detectIDE(root) {
   const detected = /* @__PURE__ */ new Map();
@@ -1333,10 +1538,10 @@ async function detectIDE(root) {
     detected.set("Windsurf", { ide: "Windsurf", supported: false });
   }
   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"))
+    exists(path9.join(root, ".trae")),
+    exists(path9.join(root, ".cursor")),
+    exists(path9.join(root, ".vscode")),
+    exists(path9.join(root, ".idea"))
   ]);
   if (hasTrae && !detected.has("Trae")) {
     detected.set("Trae", { ide: "trae", supported: true });
@@ -1359,7 +1564,7 @@ async function detectIDE(root) {
 }
 
 // src/detect/provider.ts
-import path9 from "path";
+import path10 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 },
@@ -1386,7 +1591,7 @@ async function detectProviders(root) {
     }
   });
   await Promise.all(cliChecks);
-  const extensionsJsonPath = path9.join(root, ".vscode", "extensions.json");
+  const extensionsJsonPath = path10.join(root, ".vscode", "extensions.json");
   let recommendedExts = [];
   if (await exists(extensionsJsonPath)) {
     try {
@@ -1398,14 +1603,14 @@ async function detectProviders(root) {
     }
   }
   const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-  const globalExtDir = path9.join(homeDir, ".vscode", "extensions");
+  const globalExtDir = path10.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");
+      const obsoletePath = path10.join(globalExtDir, ".obsolete");
       if (await exists(obsoletePath)) {
         try {
           const obsoleteData = await readJSON(obsoletePath);
@@ -1832,7 +2037,7 @@ async function detect(json = false) {
 }
 
 // src/commands/init.ts
-import path10 from "path";
+import path11 from "path";
 
 // src/onboarding/target-resolution.ts
 function normalizePackagePath(packagePath) {
@@ -2108,7 +2313,7 @@ async function init(options) {
       verifiedPackages.push(pkg);
       continue;
     }
-    const absolutePath = path10.join(repoRoot, pkg);
+    const absolutePath = path11.join(repoRoot, pkg);
     if (await exists(absolutePath)) {
       verifiedPackages.push(pkg);
     } else {
@@ -2121,7 +2326,7 @@ async function init(options) {
     return;
   }
   log.header("Inspecto Setup");
-  if (!await exists(path10.join(repoRoot, "package.json"))) {
+  if (!await exists(path11.join(repoRoot, "package.json"))) {
     log.error("No package.json found in current directory");
     log.hint("Run this command from your project root");
     return;
@@ -2156,12 +2361,12 @@ async function init(options) {
           log.hint("Run `inspecto init` inside the target app, or pass --packages <app-path>.");
           return;
         }
-        projectRoot = path10.join(repoRoot, selectedPackage);
+        projectRoot = path11.join(repoRoot, selectedPackage);
         buildResult = await detectBuildTools(repoRoot, [selectedPackage]);
         log.info(`Continuing initialization in ${selectedPackage}`);
       } else if (targetResolution.selected?.packagePath) {
         const selectedPackage = targetResolution.selected.packagePath;
-        projectRoot = path10.join(repoRoot, selectedPackage);
+        projectRoot = path11.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.");
@@ -2380,7 +2585,7 @@ async function detectFrameworkSupportByPackage(repoRoot, buildTools) {
   const supportByPackage = {};
   await Promise.all(
     packagePaths.map(async (packagePath) => {
-      const result = await detectFrameworks(path10.join(repoRoot, packagePath));
+      const result = await detectFrameworks(path11.join(repoRoot, packagePath));
       supportByPackage[packagePath] = result.supported;
     })
   );
@@ -2388,7 +2593,7 @@ async function detectFrameworkSupportByPackage(repoRoot, buildTools) {
 }
 
 // src/commands/doctor.ts
-import path11 from "path";
+import path12 from "path";
 function createDiagnostic(code, status, message2, hints = [], details) {
   return {
     code,
@@ -2432,7 +2637,7 @@ function printDoctorResult(result) {
 }
 async function collectDoctorResult(root = process.cwd()) {
   const checks = [];
-  if (!await exists(path11.join(root, "package.json"))) {
+  if (!await exists(path12.join(root, "package.json"))) {
     const diagnostic = createDiagnostic("missing-package-json", "error", "No package.json found", [
       "Run this command from your project root"
     ]);
@@ -2526,9 +2731,9 @@ async function collectDoctorResult(root = process.cwd()) {
     }).join(", ");
     checks.push(createDiagnostic("provider-detected", "ok", `Provider: ${aiNames}`));
   }
-  const pluginPath = path11.join(root, "node_modules", "@inspecto-dev", "plugin");
+  const pluginPath = path12.join(root, "node_modules", "@inspecto-dev", "plugin");
   if (await exists(pluginPath)) {
-    const pkgJson = await readJSON(path11.join(pluginPath, "package.json"));
+    const pkgJson = await readJSON(path12.join(pluginPath, "package.json"));
     const version = pkgJson?.version ?? "unknown";
     checks.push(
       createDiagnostic("plugin-installed", "ok", `@inspecto-dev/plugin@${version} installed`, [], {
@@ -2545,7 +2750,7 @@ async function collectDoctorResult(root = process.cwd()) {
   if (buildResult.supported.length > 0) {
     let injected = false;
     for (const bt of buildResult.supported) {
-      const content = await readFile(path11.join(root, bt.configPath));
+      const content = await readFile(path12.join(root, bt.configPath));
       if (content && content.includes("@inspecto-dev/plugin")) {
         checks.push(
           createDiagnostic("plugin-configured", "ok", `Plugin configured in ${bt.configPath}`, [], {
@@ -2604,8 +2809,8 @@ async function collectDoctorResult(root = process.cwd()) {
       );
     }
   }
-  const settingsJsonPath = path11.join(root, ".inspecto", "settings.json");
-  const settingsLocalPath = path11.join(root, ".inspecto", "settings.local.json");
+  const settingsJsonPath = path12.join(root, ".inspecto", "settings.json");
+  const settingsLocalPath = path12.join(root, ".inspecto", "settings.local.json");
   const hasSettingsJson = await exists(settingsJsonPath);
   const hasSettingsLocal = await exists(settingsLocalPath);
   if (hasSettingsJson || hasSettingsLocal) {
@@ -2639,7 +2844,7 @@ async function collectDoctorResult(root = process.cwd()) {
       )
     );
   }
-  const gitignoreContent = await readFile(path11.join(root, ".gitignore"));
+  const gitignoreContent = await readFile(path12.join(root, ".gitignore"));
   if (gitignoreContent) {
     const hasLockIgnore = gitignoreContent.includes(".inspecto/install.lock") || gitignoreContent.includes(".inspecto/");
     if (!hasLockIgnore) {
@@ -2677,7 +2882,7 @@ async function doctor(options = {}) {
 }
 
 // src/onboarding/session.ts
-import path12 from "path";
+import path13 from "path";
 function normalizePackagePath2(packagePath) {
   if (!packagePath || packagePath === ".") return "";
   return packagePath.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "");
@@ -2702,7 +2907,7 @@ function getVerificationCommand(packageManager) {
 }
 async function buildVerification(projectRoot, packageManager) {
   const packageJson = await readJSON(
-    path12.join(projectRoot, "package.json")
+    path13.join(projectRoot, "package.json")
   );
   if (packageJson?.scripts?.dev) {
     const devCommand = getVerificationCommand(packageManager);
@@ -2742,7 +2947,7 @@ async function detectFrameworkSupportByPackage2(repoRoot, context) {
   await Promise.all(
     Array.from(packagePaths).map(async (packagePath) => {
       const frameworkResult = await detectFrameworks(
-        packagePath ? path12.join(repoRoot, packagePath) : repoRoot
+        packagePath ? path13.join(repoRoot, packagePath) : repoRoot
       );
       supportByPackage[packagePath] = frameworkResult.supported;
     })
@@ -2750,7 +2955,7 @@ async function detectFrameworkSupportByPackage2(repoRoot, context) {
   return supportByPackage;
 }
 async function buildTargetedContext(rootContext, packagePath) {
-  const projectRoot = packagePath ? path12.join(rootContext.root, packagePath) : rootContext.root;
+  const projectRoot = packagePath ? path13.join(rootContext.root, packagePath) : rootContext.root;
   const [frameworks, ides, providers] = await Promise.all([
     detectFrameworks(projectRoot),
     detectIDE(projectRoot),
@@ -2991,6 +3196,21 @@ function buildDeferredOnboardResult(session) {
 }
 
 // src/commands/onboard.ts
+function printManualExtensionGuidance(result) {
+  if (!result.ideExtension?.required || !result.ideExtension.manualRequired) {
+    return;
+  }
+  log.warn("Complete the IDE extension install before verification.");
+  if (result.ideExtension.installCommand) {
+    log.hint(result.ideExtension.installCommand);
+  }
+  if (result.ideExtension.marketplaceUrl) {
+    log.hint(result.ideExtension.marketplaceUrl);
+  }
+  if (result.ideExtension.openVsxUrl) {
+    log.hint(result.ideExtension.openVsxUrl);
+  }
+}
 function printOnboardResult(result) {
   log.header("Inspecto Onboard");
   log.info(`Status: ${result.status}`);
@@ -3004,6 +3224,7 @@ function printOnboardResult(result) {
   if (result.confirmation.required && result.confirmation.question) {
     log.warn(result.confirmation.question);
   }
+  printManualExtensionGuidance(result);
   const extensionReady = !result.ideExtension?.required || result.ideExtension.installed && !result.ideExtension.manualRequired;
   if (extensionReady && (result.status === "success" || result.status === "partial_success") && result.verification?.message) {
     log.info(result.verification.message);
@@ -3057,11 +3278,11 @@ async function plan(json = false) {
 }
 
 // src/commands/teardown.ts
-import path13 from "path";
+import path14 from "path";
 async function teardown() {
   const root = process.cwd();
   log.header("Inspecto Teardown");
-  const lockPath = path13.join(root, ".inspecto", "install.lock");
+  const lockPath = path14.join(root, ".inspecto", "install.lock");
   const lock = await readJSON(lockPath);
   if (!lock) {
     log.warn("No .inspecto/install.lock found. Running in best-effort mode.");
@@ -3074,8 +3295,8 @@ async function teardown() {
     } catch {
       log.warn("Could not remove @inspecto-dev/plugin (may not be installed)");
     }
-    if (await exists(path13.join(root, ".inspecto"))) {
-      await removeDir(path13.join(root, ".inspecto"));
+    if (await exists(path14.join(root, ".inspecto"))) {
+      await removeDir(path14.join(root, ".inspecto"));
       log.success("Deleted .inspecto/ directory");
     }
     await cleanGitignore(root);
@@ -3124,7 +3345,7 @@ async function teardown() {
       }
     }
   }
-  await removeDir(path13.join(root, ".inspecto"));
+  await removeDir(path14.join(root, ".inspecto"));
   log.success("Deleted .inspecto/ directory");
   await cleanGitignore(root);
   log.blank();
@@ -3132,10 +3353,1083 @@ async function teardown() {
   log.blank();
 }
 
+// src/commands/integration-install.ts
+import fs3 from "fs/promises";
+import { homedir as homedir2 } from "os";
+import path17 from "path";
+import { fileURLToPath } from "url";
+
+// src/commands/integration-host-ide.ts
+import path15 from "path";
+async function resolveIntegrationHostIde(options = {}) {
+  if (isSupportedHostIde(options.explicitIde)) {
+    return {
+      ide: options.explicitIde,
+      confidence: "high",
+      source: "explicit",
+      candidates: [options.explicitIde]
+    };
+  }
+  const cwd = options.cwd ?? process.cwd();
+  const configuredIde = await resolveConfiguredIde(cwd);
+  if (configuredIde) {
+    return {
+      ide: configuredIde,
+      confidence: "high",
+      source: "config",
+      candidates: [configuredIde]
+    };
+  }
+  const envCandidates = detectEnvHostIdes();
+  if (envCandidates.length === 1) {
+    return {
+      ide: envCandidates[0],
+      confidence: "high",
+      source: "env",
+      candidates: envCandidates
+    };
+  }
+  if (envCandidates.length > 1) {
+    return {
+      ide: null,
+      confidence: "low",
+      source: "ambiguous",
+      candidates: envCandidates
+    };
+  }
+  const artifactCandidates = await detectArtifactHostIdes(cwd);
+  if (artifactCandidates.length === 1) {
+    return {
+      ide: artifactCandidates[0],
+      confidence: "medium",
+      source: "artifact",
+      candidates: artifactCandidates
+    };
+  }
+  if (artifactCandidates.length > 1) {
+    return {
+      ide: null,
+      confidence: "low",
+      source: "ambiguous",
+      candidates: artifactCandidates
+    };
+  }
+  return {
+    ide: null,
+    confidence: "low",
+    source: "none",
+    candidates: []
+  };
+}
+async function resolveConfiguredIde(cwd) {
+  const settingsPaths = [
+    path15.join(cwd, ".inspecto", "settings.local.json"),
+    path15.join(cwd, ".inspecto", "settings.json")
+  ];
+  for (const settingsPath of settingsPaths) {
+    const settings = await readJSON(settingsPath);
+    if (settings && isSupportedHostIde(settings.ide)) {
+      return settings.ide;
+    }
+  }
+  return null;
+}
+function detectEnvHostIdes() {
+  const detected = /* @__PURE__ */ new Set();
+  if (process.env.CURSOR_TRACE_DIR || process.env.CURSOR_CHANNEL) {
+    detected.add("cursor");
+  }
+  if (process.env.TRAE_APP_DIR || process.env.__CFBundleIdentifier === "com.byteocean.trae" || process.env.COCO_IDE_PLUGIN_TYPE === "Trae" || process.env.npm_config_user_agent && process.env.npm_config_user_agent.includes("trae")) {
+    detected.add("trae");
+  }
+  if (process.env.__CFBundleIdentifier === "com.byteocean.trae.cn" || process.env.COCO_IDE_PLUGIN_TYPE === "TraeCN" || process.env.npm_config_user_agent && process.env.npm_config_user_agent.includes("trae-cn")) {
+    detected.add("trae-cn");
+  }
+  if (detected.size === 0 && process.env.TERM_PROGRAM === "vscode") {
+    detected.add("vscode");
+  }
+  return Array.from(detected);
+}
+async function detectArtifactHostIdes(cwd) {
+  const artifactOrder = ["cursor", "trae", "trae-cn", "vscode"];
+  const candidates = artifactOrder.map((ide) => ({
+    ide,
+    target: getHostIdeArtifactPath(ide, cwd)
+  }));
+  const resolved = await Promise.all(
+    candidates.map(async (candidate) => await exists(candidate.target) ? candidate.ide : null)
+  );
+  return resolved.filter((value) => value !== null);
+}
+
+// src/commands/integration-dispatch-mode.ts
+import { homedir } from "os";
+import path16 from "path";
+async function resolveIntegrationDispatchMode(options) {
+  const assistantRule = getDualModeAssistantCapability(options.assistant);
+  const home = options.homeDir ?? homedir();
+  const extensionDir = getHostIdeExtensionDir(options.hostIde, home);
+  if (assistantRule && extensionDir) {
+    if (await isIdeExtensionInstalled(assistantRule.extensionId, extensionDir)) {
+      return {
+        mode: "extension",
+        ready: true,
+        reason: `${options.hostIde}_${options.assistant}_extension`
+      };
+    }
+    if (await which(assistantRule.cliBin)) {
+      return {
+        mode: "cli",
+        ready: true,
+        reason: `${options.assistant}_cli`
+      };
+    }
+    return {
+      mode: null,
+      ready: false,
+      reason: `missing_${options.assistant}_runtime`
+    };
+  }
+  return {
+    mode: null,
+    ready: true,
+    reason: "default"
+  };
+}
+async function isIdeExtensionInstalled(extensionId, extensionsDir) {
+  if (!await exists(extensionsDir)) {
+    return false;
+  }
+  let extensionFolders;
+  try {
+    const { readdir } = await import("fs/promises");
+    extensionFolders = await readdir(extensionsDir);
+  } catch {
+    return false;
+  }
+  const obsoletePath = path16.join(extensionsDir, ".obsolete");
+  let obsoleteFolders = /* @__PURE__ */ new Set();
+  if (await exists(obsoletePath)) {
+    const obsolete = await readJSON(obsoletePath);
+    if (obsolete) {
+      obsoleteFolders = new Set(Object.keys(obsolete));
+    }
+  }
+  return extensionFolders.some((folder) => {
+    if (obsoleteFolders.has(folder)) return false;
+    const lower = folder.toLowerCase();
+    const normalized = extensionId.toLowerCase();
+    return lower === normalized || lower.startsWith(`${normalized}-`);
+  });
+}
+
+// src/commands/integration-automation.ts
+var ONBOARDING_PROMPT = "Set up Inspecto in this project";
+var TOTAL_STEPS = 6;
+var EXTENSION_ID2 = "inspecto.inspecto";
+function getPreviewReadyMessage() {
+  return "Preview complete. Inspecto did not write files or open IDE windows. Review the resolved setup below, then rerun without --preview to apply it.";
+}
+function getPreviewBlockedMessage() {
+  return "Preview blocked. Inspecto did not write files or open IDE windows because setup cannot continue until the blocking issue below is resolved.";
+}
+function getHostIdeBlockedMessage() {
+  return "Automatic setup stopped: Inspecto could not determine which IDE should receive onboarding.";
+}
+function getRuntimeBlockedMessage(assistant, ide) {
+  return `Automatic setup stopped: Inspecto could not find a runnable ${getAssistantLabel(assistant)} target in ${getHostIdeLabel(ide)}.`;
+}
+function getLaunchBlockedMessage(ide) {
+  return `Automatic setup stopped: Inspecto could not open onboarding in ${getHostIdeLabel(ide)}.`;
+}
+async function runIntegrationAutomation(assistant, options = {}, cwd) {
+  const silent = options.silent ?? false;
+  const resolvedHostIde = await resolveIntegrationHostIde({
+    ...options.ide ? { explicitIde: options.ide } : {},
+    ...cwd ? { cwd } : {}
+  });
+  const details = {
+    hostIde: {
+      id: resolvedHostIde.ide,
+      confidence: resolvedHostIde.confidence,
+      candidates: resolvedHostIde.candidates,
+      ...resolvedHostIde.ide ? {
+        label: getHostIdeLabel(resolvedHostIde.ide),
+        source: getHostIdeResolutionSourceLabel(resolvedHostIde.source)
+      } : {}
+    }
+  };
+  if (!resolvedHostIde.ide || resolvedHostIde.confidence === "low") {
+    if (!silent) {
+      log.warn(formatIntegrationStep(2, "Could not confidently resolve the host IDE"));
+    }
+    if (resolvedHostIde.candidates.length > 0) {
+      if (!silent) {
+        log.hint(`Candidates: ${resolvedHostIde.candidates.join(", ")}`);
+      }
+    }
+    if (!silent) {
+      log.hint(
+        "Re-run with --host-ide <vscode|cursor|trae|trae-cn> or run the command from the target IDE terminal to continue automatic setup."
+      );
+    }
+    return {
+      status: "blocked",
+      message: getHostIdeBlockedMessage(),
+      nextStep: "Re-run with --host-ide <vscode|cursor|trae|trae-cn> or run the command from the target IDE terminal to continue automatic setup.",
+      details
+    };
+  }
+  const previewParams = new URLSearchParams();
+  previewParams.set("target", assistant);
+  previewParams.set("prompt", ONBOARDING_PROMPT);
+  previewParams.set("autoSend", String(shouldAutoSend(assistant, resolvedHostIde.ide)));
+  if (cwd) {
+    previewParams.set("workspace", cwd);
+  }
+  const dispatchMode = await resolveIntegrationDispatchMode({
+    assistant,
+    hostIde: resolvedHostIde.ide
+  });
+  if (dispatchMode.mode) {
+    previewParams.set("overrides", JSON.stringify({ type: dispatchMode.mode }));
+  }
+  const launchUri = `${resolvedHostIde.ide}://inspecto.inspecto/send?${previewParams.toString()}`;
+  details.inspectoExtension = {
+    source: options.inspectoVsix ? "local_vsix" : "marketplace",
+    reference: options.inspectoVsix ?? EXTENSION_ID2
+  };
+  details.runtime = {
+    assistant: getAssistantLabel(assistant),
+    ready: dispatchMode.ready,
+    mode: dispatchMode.mode
+  };
+  details.workspace = {
+    ...cwd ? { path: cwd } : {},
+    attempted: Boolean(cwd)
+  };
+  details.onboarding = {
+    uri: launchUri,
+    autoSend: shouldAutoSend(assistant, resolvedHostIde.ide)
+  };
+  if (options.preview) {
+    if (!silent) {
+      log.info(formatIntegrationStep(2, "Previewed host IDE resolution"));
+      log.hint(
+        `${getHostIdeLabel(resolvedHostIde.ide)} (${getHostIdeResolutionSourceLabel(resolvedHostIde.source)})`
+      );
+    }
+    const hostIdeBinary = await resolveHostIdeBinary(resolvedHostIde.ide);
+    details.inspectoExtension.binaryAvailable = Boolean(hostIdeBinary);
+    details.inspectoExtension.binaryPath = hostIdeBinary;
+    if (!hostIdeBinary) {
+      const nextStep = `Install the ${getHostIdeLabel(resolvedHostIde.ide)} CLI binary or rerun the command from a shell where it is available, then rerun the command.`;
+      details.inspectoExtension.status = "missing_host_ide_binary";
+      if (!silent) {
+        log.warn(
+          formatIntegrationStep(
+            3,
+            `Could not verify Inspecto extension installation in ${getHostIdeLabel(resolvedHostIde.ide)}`
+          )
+        );
+        log.hint(
+          `No ${getHostIdeLabel(resolvedHostIde.ide)} CLI binary was found. Automatic extension install and workspace opening may not work.`
+        );
+      }
+      return {
+        status: "preview_blocked",
+        message: getPreviewBlockedMessage(),
+        nextStep,
+        details
+      };
+    }
+    if (options.inspectoVsix && !await exists(options.inspectoVsix)) {
+      const nextStep = `Provide a valid local VSIX path for ${getHostIdeLabel(resolvedHostIde.ide)} or remove --inspecto-vsix, then rerun the command.`;
+      details.inspectoExtension.status = "missing_local_vsix";
+      if (!silent) {
+        log.warn(
+          formatIntegrationStep(
+            3,
+            `Could not verify the local Inspecto VSIX for ${getHostIdeLabel(resolvedHostIde.ide)}`
+          )
+        );
+        log.hint(`The local VSIX path does not exist: ${options.inspectoVsix}`);
+      }
+      return {
+        status: "preview_blocked",
+        message: getPreviewBlockedMessage(),
+        nextStep,
+        details
+      };
+    }
+    details.inspectoExtension.status = "preview_ready";
+    if (!silent) {
+      log.info(formatIntegrationStep(3, "Previewed Inspecto extension installation"));
+      log.hint(
+        options.inspectoVsix ? `Local VSIX (${options.inspectoVsix})` : `Marketplace install in ${getHostIdeLabel(resolvedHostIde.ide)}`
+      );
+    }
+    if (!dispatchMode.ready) {
+      const nextStep = `Install the ${getAssistantLabel(assistant)} plugin in ${getHostIdeLabel(resolvedHostIde.ide)} or install the \`${getAssistantCliName(assistant)}\` CLI, then rerun the command.`;
+      if (!silent) {
+        log.warn(
+          formatIntegrationStep(
+            4,
+            `Could not resolve a runnable ${getAssistantLabel(assistant)} runtime`
+          )
+        );
+        log.hint(nextStep);
+      }
+      return {
+        status: "preview_blocked",
+        message: getPreviewBlockedMessage(),
+        nextStep,
+        details
+      };
+    }
+    if (!silent) {
+      log.info(formatIntegrationStep(4, `Previewed ${getAssistantLabel(assistant)} runtime`));
+      log.hint(getDispatchModeLabel(assistant, resolvedHostIde.ide, dispatchMode.mode));
+    }
+    if (cwd) {
+      if (!silent) {
+        log.info(
+          formatIntegrationStep(
+            5,
+            `Previewed workspace routing in ${getHostIdeLabel(resolvedHostIde.ide)}`
+          )
+        );
+        log.hint(cwd);
+      }
+    }
+    if (!silent) {
+      log.info(formatIntegrationStep(6, "Previewed onboarding launch"));
+      log.hint(launchUri);
+    }
+    return {
+      status: "preview",
+      message: getPreviewReadyMessage(),
+      nextStep: "Run the same command again without --preview to apply the integration and launch onboarding.",
+      details
+    };
+  }
+  if (!silent) {
+    log.success(formatIntegrationStep(2, "Resolved host IDE"));
+    log.hint(
+      `${getHostIdeLabel(resolvedHostIde.ide)} (${getHostIdeResolutionSourceLabel(resolvedHostIde.source)})`
+    );
+  }
+  const installResult = await installExtension(
+    false,
+    resolvedHostIde.ide,
+    true,
+    options.inspectoVsix
+  );
+  details.inspectoExtension.status = installResult?.description ?? "not_prepared";
+  if (!silent) {
+    logInstallStep(resolvedHostIde.ide, installResult);
+  }
+  if (installResult?.type === "extension_installed") {
+    if (!silent) {
+      if (installResult.manual_action_required) {
+        log.hint("Complete the IDE install prompt before retrying if onboarding does not appear.");
+      } else {
+        log.hint("Waiting briefly for the IDE extension to finish activating...");
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1500));
+  } else {
+    if (!silent) {
+      log.warn(
+        formatIntegrationStep(
+          3,
+          `Could not prepare the Inspecto extension for ${getHostIdeLabel(resolvedHostIde.ide)}`
+        )
+      );
+      log.hint("Automatic onboarding may fail until the Inspecto extension is installed.");
+    }
+  }
+  if (cwd) {
+    const openedWorkspace = await openIdeWorkspace(resolvedHostIde.ide, cwd);
+    details.workspace.opened = openedWorkspace;
+    if (openedWorkspace) {
+      if (!silent) {
+        log.success(
+          formatIntegrationStep(5, `Opened workspace in ${getHostIdeLabel(resolvedHostIde.ide)}`)
+        );
+        log.hint(cwd);
+      }
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+    } else {
+      if (!silent) {
+        log.warn(
+          formatIntegrationStep(
+            5,
+            `Could not open the workspace in ${getHostIdeLabel(resolvedHostIde.ide)}`
+          )
+        );
+        log.hint(cwd);
+      }
+    }
+  }
+  if (!dispatchMode.ready) {
+    const nextStep = `Install the ${getAssistantLabel(assistant)} plugin in ${getHostIdeLabel(resolvedHostIde.ide)} or install the \`${getAssistantCliName(assistant)}\` CLI, then rerun the command.`;
+    if (!silent) {
+      log.warn(
+        formatIntegrationStep(
+          4,
+          `Could not resolve a runnable ${getAssistantLabel(assistant)} runtime`
+        )
+      );
+      log.hint(nextStep);
+    }
+    return {
+      status: "blocked",
+      message: getRuntimeBlockedMessage(assistant, resolvedHostIde.ide),
+      nextStep,
+      details
+    };
+  }
+  if (!silent) {
+    log.success(formatIntegrationStep(4, `Resolved ${getAssistantLabel(assistant)} runtime`));
+    log.hint(getDispatchModeLabel(assistant, resolvedHostIde.ide, dispatchMode.mode));
+  }
+  const workspaceOpenFailed = Boolean(cwd) && details.workspace?.opened === false;
+  const launched = await openUri(launchUri);
+  if (launched) {
+    if (!silent) {
+      log.success(
+        formatIntegrationStep(6, `Launched onboarding in ${getHostIdeLabel(resolvedHostIde.ide)}`)
+      );
+      log.hint(`${getAssistantLabel(assistant)} via ${dispatchMode.mode ?? "default"} mode`);
+    }
+    if (workspaceOpenFailed) {
+      const nextStep = `If the wrong IDE window received onboarding, open ${cwd} in ${getHostIdeLabel(resolvedHostIde.ide)} and rerun the command from that project.`;
+      return {
+        status: "partial",
+        message: `Onboarding opened in ${getHostIdeLabel(resolvedHostIde.ide)} for ${getAssistantLabel(assistant)}, but Inspecto could not open the target workspace first.`,
+        nextStep,
+        details
+      };
+    }
+    return {
+      status: installResult ? "launched" : "partial",
+      message: installResult ? `Onboarding opened in ${getHostIdeLabel(resolvedHostIde.ide)} for ${getAssistantLabel(assistant)}.` : `Onboarding opened in ${getHostIdeLabel(resolvedHostIde.ide)} for ${getAssistantLabel(assistant)}, but the Inspecto extension may still need manual setup.`,
+      ...installResult ? {} : {
+        nextStep: `Install the Inspecto extension in ${getHostIdeLabel(resolvedHostIde.ide)} if IDE-side features are missing.`
+      },
+      details
+    };
+  } else {
+    if (!silent) {
+      log.warn(
+        formatIntegrationStep(
+          6,
+          `Could not launch onboarding in ${getHostIdeLabel(resolvedHostIde.ide)}`
+        )
+      );
+      log.hint(launchUri);
+    }
+    return {
+      status: "blocked",
+      message: getLaunchBlockedMessage(resolvedHostIde.ide),
+      nextStep: launchUri,
+      details
+    };
+  }
+}
+function shouldAutoSend(assistant, ide) {
+  if (assistant === "copilot") return true;
+  if (assistant === "codex") return true;
+  return false;
+}
+function getAssistantLabel(assistant) {
+  return getDualModeAssistantCapability(assistant)?.label ?? assistant;
+}
+function getAssistantCliName(assistant) {
+  return getDualModeAssistantCapability(assistant)?.cliBin ?? assistant;
+}
+function formatIntegrationStep(step, text) {
+  return `Step ${step}/${TOTAL_STEPS}: ${text}`;
+}
+function logInstallStep(ide, installResult) {
+  if (!installResult) {
+    return;
+  }
+  if (installResult.description === "already_installed") {
+    log.success(
+      formatIntegrationStep(3, `Inspecto extension already installed in ${getHostIdeLabel(ide)}`)
+    );
+    log.hint(installResult.id ?? "inspecto.inspecto");
+    return;
+  }
+  if (installResult.description === "opened_install_page") {
+    log.warn(
+      formatIntegrationStep(
+        3,
+        `Opened the Inspecto extension install page in ${getHostIdeLabel(ide)}`
+      )
+    );
+    log.hint("Finish the extension install in the IDE window, then rerun the command if needed.");
+    return;
+  }
+  log.success(
+    formatIntegrationStep(3, `Installed the Inspecto extension in ${getHostIdeLabel(ide)}`)
+  );
+  log.hint(installResult.id ?? "inspecto.inspecto");
+}
+function getDispatchModeLabel(assistant, ide, mode) {
+  if (mode === "cli") {
+    return `CLI fallback (\`${getAssistantCliName(assistant)}\`)`;
+  }
+  if (mode === "extension") {
+    return `${getAssistantLabel(assistant)} plugin in ${getHostIdeLabel(ide)}`;
+  }
+  return "Default runtime";
+}
+
+// src/commands/integration-install.ts
+var REPO_RAW_BASE = "https://raw.githubusercontent.com/inspecto-dev/inspecto/main";
+var TOTAL_STEPS2 = 6;
+var INTEGRATION_MANIFESTS = [
+  {
+    assistant: "codex",
+    type: "native-skill",
+    installTarget: ".agents/skills/",
+    preferredInstall: "npx @inspecto-dev/cli integrations install codex --host-ide <vscode|cursor|trae|trae-cn>",
+    cliSupported: true
+  },
+  {
+    assistant: "claude-code",
+    type: "native-skill",
+    installTarget: ".claude/skills/ or ~/.claude/skills/",
+    preferredInstall: "npx @inspecto-dev/cli integrations install claude-code --scope project --host-ide <vscode|cursor|trae|trae-cn>",
+    cliSupported: true
+  },
+  {
+    assistant: "copilot",
+    type: "native-skill",
+    installTarget: ".github/skills/inspecto-onboarding/",
+    preferredInstall: "npx @inspecto-dev/cli integrations install copilot --host-ide <vscode|cursor|trae|trae-cn>",
+    cliSupported: true
+  },
+  {
+    assistant: "cursor",
+    type: "native-skill",
+    installTarget: ".cursor/skills/inspecto-onboarding/",
+    preferredInstall: "npx @inspecto-dev/cli integrations install cursor --host-ide <vscode|cursor|trae|trae-cn>",
+    cliSupported: true
+  },
+  {
+    assistant: "gemini",
+    type: "native-skill",
+    installTarget: ".gemini/skills/inspecto-onboarding/",
+    preferredInstall: "npx @inspecto-dev/cli integrations install gemini --host-ide <vscode|cursor|trae|trae-cn>",
+    cliSupported: true
+  },
+  {
+    assistant: "trae",
+    type: "native-skill",
+    installTarget: ".trae/skills/inspecto-onboarding/",
+    preferredInstall: "npx @inspecto-dev/cli integrations install trae --host-ide <vscode|cursor|trae|trae-cn>",
+    cliSupported: true
+  },
+  {
+    assistant: "coco",
+    type: "native-skill",
+    installTarget: ".traecli/skills/inspecto-onboarding/",
+    preferredInstall: "npx @inspecto-dev/cli integrations install coco --host-ide <vscode|cursor|trae|trae-cn>",
+    cliSupported: true
+  }
+];
+async function installIntegration(assistant, options = {}) {
+  const plan2 = resolveInstallPlan(assistant, options);
+  const manifest = getIntegrationManifest(assistant);
+  const silent = options.json ?? false;
+  if (!silent) {
+    log.header("Inspecto Integration Install");
+  }
+  if (!options.preview) {
+    const existingFiles = /* @__PURE__ */ new Map();
+    for (const asset of plan2.assets) {
+      if (await exists(asset.target)) {
+        if (options.force) {
+        } else if (manifest.type === "context-template") {
+          const originalContent = await fs3.readFile(asset.target, "utf-8");
+          existingFiles.set(asset.target, originalContent);
+          if (!silent) {
+            log.info(`File ${asset.target} already exists. Content will be appended safely.`);
+          }
+        } else {
+          throw new Error(
+            `Refusing to overwrite existing file: ${asset.target}. Re-run with --force if you want to replace it.`
+          );
+        }
+      }
+    }
+    const downloadedAssets = [];
+    for (const asset of plan2.assets) {
+      let content = await loadAsset(asset);
+      if (existingFiles.has(asset.target)) {
+        const existingContent = existingFiles.get(asset.target);
+        if (!existingContent.includes("Inspecto Onboarding") && !existingContent.includes("inspecto-onboarding")) {
+          content = `${existingContent}
+
+---
+
+${content}`;
+        } else {
+          if (!silent) {
+            log.info(
+              `Skipping ${asset.target} as it seems to already contain Inspecto rules. Use --force to overwrite.`
+            );
+          }
+          continue;
+        }
+      }
+      downloadedAssets.push({ asset, content });
+    }
+    for (const { asset, content } of downloadedAssets) {
+      await writeFile(asset.target, content);
+      if (asset.executable) {
+        await fs3.chmod(asset.target, 493);
+      }
+    }
+  }
+  const stepOneMessage = options.preview ? formatIntegrationStep2(1, `Previewing ${getAssistantLabel2(assistant)} integration assets`) : formatIntegrationStep2(1, `Installed ${getAssistantLabel2(assistant)} integration assets`);
+  if (!silent) {
+    if (options.preview) {
+      log.info(stepOneMessage);
+    } else {
+      log.success(stepOneMessage);
+    }
+    for (const asset of plan2.assets) {
+      log.hint(asset.target);
+    }
+    if (!options.preview) {
+      log.hint(plan2.nextStep);
+    }
+  }
+  if (shouldSkipAutomationForInstall(options)) {
+    const message2 = `Installed ${getAssistantLabel2(assistant)} integration assets. User-level installs only write integration assets and do not launch onboarding automatically.`;
+    const nextStep = options.ide ? `Run the install command again from your target project root with --host-ide ${options.ide} when you want to launch onboarding automatically.` : "Run the install command again from your target project root with --host-ide <vscode|cursor|trae|trae-cn> when you want to launch onboarding automatically.";
+    const result2 = {
+      status: "partial",
+      assistant,
+      preview: options.preview ?? false,
+      assets: plan2.assets.map((asset) => asset.target),
+      message: message2,
+      nextStep,
+      automation: {
+        status: "blocked",
+        message: message2,
+        nextStep
+      }
+    };
+    if (options.json) {
+      return writeCommandOutput(result2, true, () => {
+      });
+    }
+    log.ready(message2);
+    if (options.ide) {
+      log.hint(
+        `The provided --host-ide value is saved only as a rerun hint for later; this command does not open ${formatHostIdeLabel(options.ide)} for user-level installs.`
+      );
+    }
+    log.hint(nextStep);
+    return result2;
+  }
+  const automationResult = await runIntegrationAutomation(
+    assistant,
+    { ...options, silent },
+    process.cwd()
+  );
+  const result = {
+    status: automationResult.status,
+    assistant,
+    preview: options.preview ?? false,
+    assets: plan2.assets.map((asset) => asset.target),
+    message: automationResult.message,
+    ...automationResult.nextStep ? { nextStep: automationResult.nextStep } : {},
+    automation: automationResult
+  };
+  if (options.json) {
+    return writeCommandOutput(result, true, () => {
+    });
+  }
+  if (automationResult.status === "launched") {
+    log.ready(automationResult.message);
+    return result;
+  }
+  if (automationResult.status === "preview") {
+    log.ready(automationResult.message);
+    if (automationResult.nextStep) {
+      log.hint(automationResult.nextStep);
+    }
+    return result;
+  }
+  if (automationResult.status === "partial" || automationResult.status === "preview_blocked") {
+    log.warn(automationResult.message);
+    if (automationResult.nextStep) {
+      log.hint(automationResult.nextStep);
+    }
+    return result;
+  }
+  log.warn(automationResult.message);
+  if (automationResult.nextStep) {
+    log.hint(automationResult.nextStep);
+  }
+  return result;
+}
+function shouldSkipAutomationForInstall(options) {
+  return options.scope === "user" && !options.preview;
+}
+function describeIntegration(assistant, options = {}) {
+  const manifest = getIntegrationManifest(assistant);
+  const targets = manifest.cliSupported ? resolveInstallPlan(assistant, options).assets.map((asset) => asset.target) : [manifest.installTarget];
+  return {
+    assistant: manifest.assistant,
+    type: manifest.type,
+    targets,
+    preferredInstall: manifest.preferredInstall,
+    cliSupported: manifest.cliSupported
+  };
+}
+function printIntegrationList() {
+  log.header("Inspecto Integrations");
+  for (const manifest of INTEGRATION_MANIFESTS) {
+    const support = manifest.cliSupported ? "CLI" : "native installer";
+    log.info(`${manifest.assistant} \u2014 ${manifest.type} \u2014 ${manifest.installTarget} \u2014 ${support}`);
+  }
+}
+function printIntegrationPath(assistant, options = {}) {
+  const description = describeIntegration(assistant, options);
+  log.header(`Inspecto Integration Paths: ${description.assistant}`);
+  for (const target of description.targets) {
+    log.info(target);
+  }
+  if (description.cliSupported) {
+    log.hint(`Preferred install: ${description.preferredInstall}`);
+  } else {
+    log.hint(`Native install required: ${description.preferredInstall}`);
+  }
+}
+function resolveInstallPlan(assistant, options) {
+  switch (assistant) {
+    case "codex":
+      return resolveCodexPlan(options);
+    case "claude-code":
+      return resolveClaudeCodePlan(options);
+    case "copilot":
+      return resolveCopilotPlan(options);
+    case "cursor":
+      return resolveCursorPlan(options);
+    case "gemini":
+      return {
+        assets: [
+          {
+            source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-gemini/SKILL.md`,
+            target: ".gemini/skills/inspecto-onboarding/SKILL.md",
+            localSource: "skills/inspecto-onboarding-gemini/SKILL.md"
+          }
+        ],
+        successMessage: "Installed Gemini skill to .gemini/skills/inspecto-onboarding/SKILL.md",
+        nextStep: "Start a new Gemini CLI session and use /skills list to verify."
+      };
+    case "trae":
+      return {
+        assets: [
+          {
+            source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-trae/SKILL.md`,
+            target: ".trae/skills/inspecto-onboarding/SKILL.md",
+            localSource: "skills/inspecto-onboarding-trae/SKILL.md"
+          }
+        ],
+        successMessage: "Installed Trae skill to .trae/skills/inspecto-onboarding/SKILL.md",
+        nextStep: "Open a new Trae chat and verify the inspecto-onboarding skill is available."
+      };
+    case "coco":
+      return {
+        assets: [
+          {
+            source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-trae/SKILL.md`,
+            target: ".traecli/skills/inspecto-onboarding/SKILL.md",
+            localSource: "skills/inspecto-onboarding-trae/SKILL.md"
+          }
+        ],
+        successMessage: "Installed Coco skill to .traecli/skills/inspecto-onboarding/SKILL.md",
+        nextStep: "Start a new Coco session."
+      };
+    default:
+      throw new Error(`Unknown assistant: ${assistant}`);
+  }
+}
+function getIntegrationManifest(assistant) {
+  const manifest = INTEGRATION_MANIFESTS.find((item) => item.assistant === assistant);
+  if (!manifest) {
+    throw new Error(
+      `Unknown assistant: ${assistant}. Run 'inspecto integrations list' to see available targets.`
+    );
+  }
+  return manifest;
+}
+function formatIntegrationStep2(step, text) {
+  return `Step ${step}/${TOTAL_STEPS2}: ${text}`;
+}
+function getAssistantLabel2(assistant) {
+  if (assistant === "claude-code") return "Claude Code";
+  if (assistant === "codex") return "Codex";
+  if (assistant === "copilot") return "GitHub Copilot";
+  if (assistant === "cursor") return "Cursor";
+  if (assistant === "gemini") return "Gemini";
+  if (assistant === "trae") return "Trae";
+  if (assistant === "coco") return "Coco";
+  return assistant;
+}
+function formatHostIdeLabel(ide) {
+  if (ide === "vscode") return "VS Code";
+  if (ide === "cursor") return "Cursor";
+  if (ide === "trae") return "Trae";
+  if (ide === "trae-cn") return "Trae CN";
+  return ide;
+}
+function resolveCodexPlan(options) {
+  const scope = options.scope ?? "project";
+  if (options.mode !== void 0) {
+    throw new Error("`--mode` is not supported for codex.");
+  }
+  const baseDir = scope === "user" ? path17.join(homedir2(), ".agents/skills/inspecto-onboarding-codex") : ".agents/skills/inspecto-onboarding-codex";
+  return {
+    assets: [
+      {
+        source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-codex/SKILL.md`,
+        target: path17.join(baseDir, "SKILL.md"),
+        localSource: "skills/inspecto-onboarding-codex/SKILL.md"
+      },
+      {
+        source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-codex/agents/openai.yaml`,
+        target: path17.join(baseDir, "agents/openai.yaml"),
+        localSource: "skills/inspecto-onboarding-codex/agents/openai.yaml"
+      },
+      {
+        source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-codex/scripts/run-inspecto.sh`,
+        target: path17.join(baseDir, "scripts/run-inspecto.sh"),
+        executable: true,
+        localSource: "skills/inspecto-onboarding-codex/scripts/run-inspecto.sh"
+      }
+    ],
+    successMessage: `Installed Codex skill to ${baseDir}`,
+    nextStep: "Restart Codex or start a new Codex session to load the skill."
+  };
+}
+function resolveClaudeCodePlan(options) {
+  const scope = options.scope ?? "project";
+  const unsupportedMode = options.mode !== void 0;
+  if (unsupportedMode) {
+    throw new Error(
+      "`--mode` is not supported for claude-code. Use `--scope project|user` instead."
+    );
+  }
+  if (scope !== "project" && scope !== "user") {
+    throw new Error(`Unknown Claude Code scope: ${scope}`);
+  }
+  const baseDir = scope === "user" ? path17.join(homedir2(), ".claude/skills/inspecto-onboarding-claude-code") : ".claude/skills/inspecto-onboarding-claude-code";
+  return {
+    assets: [
+      {
+        source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-claude-code/SKILL.md`,
+        target: path17.join(baseDir, "SKILL.md"),
+        localSource: "skills/inspecto-onboarding-claude-code/SKILL.md"
+      },
+      {
+        source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-claude-code/agents/openai.yaml`,
+        target: path17.join(baseDir, "agents/openai.yaml"),
+        localSource: "skills/inspecto-onboarding-claude-code/agents/openai.yaml"
+      },
+      {
+        source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-claude-code/scripts/run-inspecto.sh`,
+        target: path17.join(baseDir, "scripts/run-inspecto.sh"),
+        executable: true,
+        localSource: "skills/inspecto-onboarding-claude-code/scripts/run-inspecto.sh"
+      }
+    ],
+    successMessage: `Installed Claude Code skill to ${baseDir}`,
+    nextStep: "Restart Claude Code to load the new skill."
+  };
+}
+function resolveCopilotPlan(options) {
+  const mode = options.mode ?? "skills";
+  if (options.scope !== void 0) {
+    throw new Error(
+      "`--scope` is not supported for copilot. Use `--mode skills|instructions|agents` instead."
+    );
+  }
+  switch (mode) {
+    case "skills":
+    case "instructions":
+    // Legacy fallback gracefully acts as skills mode now
+    case "agents":
+      return {
+        assets: [
+          {
+            source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-copilot/SKILL.md`,
+            target: ".github/skills/inspecto-onboarding/SKILL.md",
+            localSource: "skills/inspecto-onboarding-copilot/SKILL.md"
+          }
+        ],
+        successMessage: "Installed Copilot skill to .github/skills/inspecto-onboarding/SKILL.md",
+        nextStep: "Open a new Copilot chat or agent session."
+      };
+    default:
+      throw new Error(`Unknown Copilot mode: ${mode}`);
+  }
+}
+function resolveCursorPlan(options) {
+  const mode = options.mode ?? "skills";
+  if (options.scope !== void 0) {
+    throw new Error("`--scope` is not supported for cursor. Use `--mode skills|agents` instead.");
+  }
+  switch (mode) {
+    case "skills":
+    case "rules":
+    // Legacy fallback gracefully acts as skills mode now
+    case "agents":
+      return {
+        assets: [
+          {
+            source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-cursor/SKILL.md`,
+            target: ".cursor/skills/inspecto-onboarding/SKILL.md",
+            localSource: "skills/inspecto-onboarding-cursor/SKILL.md"
+          }
+        ],
+        successMessage: "Installed Cursor skill to .cursor/skills/inspecto-onboarding/SKILL.md",
+        nextStep: "Open a new Cursor chat."
+      };
+    default:
+      throw new Error(`Unknown Cursor mode: ${mode}`);
+  }
+}
+async function loadAsset(asset) {
+  if (asset.localSource) {
+    const localPath = await resolveBundledAssetPath(asset.localSource);
+    if (localPath) {
+      return await fs3.readFile(localPath, "utf-8");
+    }
+  }
+  return await downloadAsset(asset.source);
+}
+async function resolveBundledAssetPath(relativePath) {
+  const startDir = path17.dirname(fileURLToPath(import.meta.url));
+  let currentDir = startDir;
+  for (let depth = 0; depth < 8; depth += 1) {
+    const candidate = path17.join(currentDir, relativePath);
+    if (await exists(candidate)) {
+      return candidate;
+    }
+    const parent = path17.dirname(currentDir);
+    if (parent === currentDir) break;
+    currentDir = parent;
+  }
+  return null;
+}
+async function downloadAsset(source) {
+  let response;
+  try {
+    response = await fetch(source);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    const wrappedError = new Error(`Failed to download ${source}: ${reason}`);
+    wrappedError.cause = error;
+    throw wrappedError;
+  }
+  if (!response.ok) {
+    throw new Error(`Failed to download ${source}: ${response.status} ${response.statusText}`);
+  }
+  return await response.text();
+}
+
+// src/utils/process.ts
+function exitProcess(code) {
+  process.exit(code);
+}
+
+// src/commands/integration-doctor.ts
+var INTEGRATION_DOCTOR_SCHEMA_VERSION = "1";
+function printIntegrationDoctorResult(result, options = {}) {
+  log.header("Inspecto Integration Doctor");
+  log.info(`Assistant: ${result.assistant}`);
+  const compact = options.compact ?? false;
+  if (!compact && result.assets.length > 0) {
+    log.info("Asset targets:");
+    for (const asset of result.assets) {
+      log.hint(asset);
+    }
+  }
+  const details = result.automation.details;
+  if (details?.hostIde?.id && details.hostIde.label) {
+    const hostIdeDetail = details.hostIde.source ? `${details.hostIde.label} (${details.hostIde.source})` : details.hostIde.label;
+    log.info(`Host IDE: ${hostIdeDetail}`);
+  }
+  if (!compact && details?.inspectoExtension) {
+    log.info(
+      `Inspecto extension: ${details.inspectoExtension.source} (${details.inspectoExtension.reference})`
+    );
+  }
+  if (details?.runtime) {
+    const mode = details.runtime.mode ?? "default";
+    const readiness = details.runtime.ready ? ` via ${mode}` : " unavailable";
+    log.info(`Runtime: ${details.runtime.assistant}${readiness}`);
+  }
+  if (details?.workspace?.path) {
+    log.info(`Workspace: ${details.workspace.path}`);
+  }
+  if (!compact && details?.onboarding?.uri) {
+    log.info(`Onboarding URI: ${details.onboarding.uri}`);
+  }
+  if (result.status === "ok") {
+    log.ready(result.message);
+  } else {
+    log.warn(result.message);
+    if (result.nextStep) {
+      log.hint(result.nextStep);
+    }
+  }
+}
+async function integrationDoctor(assistant, options = {}) {
+  const description = describeIntegration(assistant, options);
+  const automation = await runIntegrationAutomation(
+    assistant,
+    {
+      ...options.ide ? { ide: options.ide } : {},
+      ...options.inspectoVsix ? { inspectoVsix: options.inspectoVsix } : {},
+      preview: true,
+      silent: true
+    },
+    process.cwd()
+  );
+  const result = {
+    schemaVersion: INTEGRATION_DOCTOR_SCHEMA_VERSION,
+    status: automation.status === "preview" ? "ok" : "blocked",
+    assistant,
+    assets: description.targets,
+    message: automation.message,
+    ...automation.nextStep ? { nextStep: automation.nextStep } : {},
+    automation
+  };
+  const written = writeCommandOutput(
+    result,
+    options.json ?? false,
+    (value) => printIntegrationDoctorResult(value, {
+      ...options.compact !== void 0 ? { compact: options.compact } : {}
+    })
+  );
+  if (result.status === "blocked" && options.failOnBlocked) {
+    exitProcess(1);
+  }
+  return written;
+}
+
 export {
-  exists,
-  writeFile,
-  log,
   writeCommandOutput,
   reportCommandError,
   apply,
@@ -3145,5 +4439,9 @@ export {
   doctor,
   onboard,
   plan,
-  teardown
+  teardown,
+  installIntegration,
+  printIntegrationList,
+  printIntegrationPath,
+  integrationDoctor
 };