@inspecto-dev/cli 0.3.8 → 0.3.10

package/dist/{chunk-B5JDHSP7.js → chunk-WOZPOTWE.js}

@@ -2497,7 +2497,7 @@ function buildUmiMountSnippet() {
     "    if (process.env.NODE_ENV !== 'production') {",
     "      import('@inspecto-dev/core').then(({ mountInspector }) => {",
     "        mountInspector({",
-    "          serverUrl: 'http://127.0.0.1:' + ((window as any).__AI_INSPECTOR_PORT__ || 5678),",
+    "          serverUrl: 'http://127.0.0.1:' + ((window as { __AI_INSPECTOR_PORT__?: number }).__AI_INSPECTOR_PORT__ || 5678),",
     "        })",
     "      })",
     "    }",
@@ -3379,21 +3379,29 @@ function resolveOnboardingTarget(input) {
 import prompts from "prompts";
 async function promptIDEChoice(detections) {
   if (!process.stdin.isTTY) {
-    log.warn("Multiple IDEs detected but stdin is not interactive");
-    log.hint(`Using: ${detections[0].ide} (first match)`);
-    return detections[0];
+    if (detections.length > 0) {
+      log.warn("Multiple IDEs detected but stdin is not interactive");
+      log.hint(`Using: ${detections[0].ide} (first match)`);
+      return detections[0];
+    }
+    return { ide: "none", supported: true };
   }
+  const choices = detections.map((d) => ({
+    title: `${d.ide} ${d.supported ? "(supported)" : "(unsupported/limited)"}`,
+    value: d
+  }));
+  choices.push({
+    title: "none (Standalone / MCP / Browser-only)",
+    value: { ide: "none", supported: true }
+  });
   const { choice } = await prompts({
     type: "select",
     name: "choice",
-    message: "Detected multiple IDEs, please choose one:",
-    choices: detections.map((d, i) => ({
-      title: `${d.ide} ${d.supported ? "(supported)" : "(unsupported/limited)"}`,
-      value: i
-    }))
+    message: "Detected multiple IDEs, please choose one (or select none for standalone use):",
+    choices
   });
   if (choice === void 0) return null;
-  return detections[choice];
+  return choice;
 }
 async function promptProviderChoice(detections) {
   if (!process.stdin.isTTY) {
@@ -3724,10 +3732,14 @@ async function init(options) {
       "Please refer to the manual setup guide: https://inspecto-dev.github.io/inspecto/guide/manual-installation"
     );
   }
-  let selectedIDE = null;
+  let selectedIDE;
   if (ideProbe.detected.length === 0) {
-    log.error("No IDE detected in current project");
-    log.hint("Please open this project in a supported IDE (like VS Code)");
+    if (process.stdin.isTTY) {
+      log.warn("No IDE detected in current project");
+      selectedIDE = await promptIDEChoice([]);
+    } else {
+      selectedIDE = { ide: "none", supported: true };
+    }
   } else if (ideProbe.detected.length === 1) {
     selectedIDE = ideProbe.detected[0];
   } else {
@@ -4303,8 +4315,311 @@ async function doctor(options = {}) {
   return writeCommandOutput(result, json, printDoctorResult);
 }
 
-// src/onboarding/session.ts
+// src/commands/mcp.ts
+import fs6 from "fs";
+import os from "os";
 import path17 from "path";
+import crypto from "crypto";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { INSPECTO_API_PATHS } from "@inspecto-dev/types";
+import { z } from "zod";
+var DEFAULT_MCP_SERVER_VERSION = "0.0.0";
+var INSPECTO_MCP_TOOLS = [
+  {
+    name: "inspecto_get_session",
+    description: "Return one Inspecto annotation session by sessionId."
+  },
+  {
+    name: "inspecto_claim_next",
+    description: "Wait for the next unclaimed Inspecto annotation session, mark it acknowledged, and return full context."
+  },
+  {
+    name: "inspecto_reply",
+    description: "Append an agent reply to an Inspecto annotation session."
+  },
+  {
+    name: "inspecto_resolve",
+    description: "Resolve an Inspecto annotation session with an optional final message."
+  },
+  {
+    name: "inspecto_dismiss",
+    description: "Dismiss an Inspecto annotation session with an optional final message."
+  }
+];
+async function startMcpServer(options = {}) {
+  const baseUrl = options.serverUrl ?? resolveInspectoServerBaseUrl(process.cwd());
+  if (!baseUrl) {
+    throw new Error(
+      "Could not find a running Inspecto dev server. Start your local dev server or pass --server-url <url>."
+    );
+  }
+  const server = createInspectoMcpServer({
+    baseUrl,
+    ...options.version ? { version: options.version } : {}
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+function createInspectoMcpServer(options) {
+  const runtime = createInspectoMcpRuntime(options.baseUrl);
+  const server = new McpServer({
+    name: "inspecto-mcp",
+    version: options.version ?? DEFAULT_MCP_SERVER_VERSION
+  });
+  server.registerTool(
+    "inspecto_get_session",
+    {
+      description: getToolDescription("inspecto_get_session"),
+      inputSchema: {
+        sessionId: z.string().min(1)
+      }
+    },
+    async ({ sessionId }) => {
+      try {
+        const result = await runtime.getSession({ sessionId });
+        return toolSuccess(result);
+      } catch (error) {
+        return toolError(error);
+      }
+    }
+  );
+  server.registerTool(
+    "inspecto_claim_next",
+    {
+      description: getToolDescription("inspecto_claim_next"),
+      inputSchema: {
+        timeoutMs: z.number().int().nonnegative().optional()
+      }
+    },
+    async ({ timeoutMs }) => {
+      try {
+        const result = await runtime.claimNext({
+          ...timeoutMs !== void 0 ? { timeoutMs } : {}
+        });
+        return toolSuccess(result);
+      } catch (error) {
+        return toolError(error);
+      }
+    }
+  );
+  server.registerTool(
+    "inspecto_reply",
+    {
+      description: getToolDescription("inspecto_reply"),
+      inputSchema: {
+        sessionId: z.string().min(1),
+        text: z.string().min(1)
+      }
+    },
+    async ({ sessionId, text }) => {
+      try {
+        const result = await runtime.reply({ sessionId, text });
+        return toolSuccess(result);
+      } catch (error) {
+        return toolError(error);
+      }
+    }
+  );
+  server.registerTool(
+    "inspecto_resolve",
+    {
+      description: getToolDescription("inspecto_resolve"),
+      inputSchema: {
+        sessionId: z.string().min(1),
+        message: z.string().optional()
+      }
+    },
+    async ({ sessionId, message: message2 }) => {
+      try {
+        const result = await runtime.resolve({ sessionId, ...message2 ? { message: message2 } : {} });
+        return toolSuccess(result);
+      } catch (error) {
+        return toolError(error);
+      }
+    }
+  );
+  server.registerTool(
+    "inspecto_dismiss",
+    {
+      description: getToolDescription("inspecto_dismiss"),
+      inputSchema: {
+        sessionId: z.string().min(1),
+        message: z.string().optional()
+      }
+    },
+    async ({ sessionId, message: message2 }) => {
+      try {
+        const result = await runtime.dismiss({ sessionId, ...message2 ? { message: message2 } : {} });
+        return toolSuccess(result);
+      } catch (error) {
+        return toolError(error);
+      }
+    }
+  );
+  return server;
+}
+function getToolDescription(name) {
+  return INSPECTO_MCP_TOOLS.find((tool) => tool.name === name)?.description ?? name;
+}
+function createInspectoMcpRuntime(baseUrl) {
+  return {
+    async getSession(args) {
+      return getSession(baseUrl, args.sessionId);
+    },
+    async claimNext(args = {}) {
+      return await postJson(`${baseUrl}${INSPECTO_API_PATHS.SESSION_CLAIM_NEXT}`, {
+        ...args.timeoutMs !== void 0 ? { timeoutMs: args.timeoutMs } : {}
+      });
+    },
+    async reply(args) {
+      return postJson(
+        `${baseUrl}${INSPECTO_API_PATHS.SESSIONS}/${args.sessionId}${INSPECTO_API_PATHS.SESSION_REPLY_SUFFIX}`,
+        {
+          role: "agent",
+          text: args.text.trim()
+        }
+      );
+    },
+    async resolve(args) {
+      return postJson(
+        `${baseUrl}${INSPECTO_API_PATHS.SESSIONS}/${args.sessionId}${INSPECTO_API_PATHS.SESSION_RESOLVE_SUFFIX}`,
+        args.message?.trim() ? { message: args.message.trim() } : {}
+      );
+    },
+    async dismiss(args) {
+      return postJson(
+        `${baseUrl}${INSPECTO_API_PATHS.SESSIONS}/${args.sessionId}${INSPECTO_API_PATHS.SESSION_DISMISS_SUFFIX}`,
+        args.message?.trim() ? { message: args.message.trim() } : {}
+      );
+    }
+  };
+}
+function resolveInspectoServerBaseUrl(cwd) {
+  const ports = resolveServerPorts(cwd);
+  const port = ports[0];
+  return port ? `http://127.0.0.1:${port}` : null;
+}
+function resolveServerPorts(cwd) {
+  const prioritized = readProjectScopedPorts(cwd);
+  if (prioritized.length > 0) return prioritized;
+  const legacyPortFile = path17.join(os.tmpdir(), "inspecto.port");
+  try {
+    const raw = fs6.readFileSync(legacyPortFile, "utf-8").trim();
+    const port = parseInt(raw, 10);
+    if (Number.isInteger(port) && port > 0 && port < 65536) {
+      return [port];
+    }
+  } catch {
+  }
+  return Array.from({ length: 23 }, (_, index) => 5678 + index);
+}
+function toolSuccess(value) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(value, null, 2)
+      }
+    ],
+    structuredContent: value
+  };
+}
+function toolError(error) {
+  const message2 = error instanceof Error ? error.message : String(error);
+  return {
+    content: [
+      {
+        type: "text",
+        text: message2
+      }
+    ],
+    structuredContent: {
+      success: false,
+      error: message2
+    },
+    isError: true
+  };
+}
+async function getJson(url) {
+  const response = await fetch(url);
+  const payload = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    throw new Error(String(payload["error"] ?? `Request failed with status ${response.status}.`));
+  }
+  return payload;
+}
+async function getSession(baseUrl, sessionId) {
+  const trimmed = sessionId.trim();
+  if (!trimmed) {
+    throw new Error("Session id is required.");
+  }
+  const payload = await getJson(
+    `${baseUrl}${INSPECTO_API_PATHS.SESSIONS}/${encodeURIComponent(trimmed)}`
+  );
+  if (!payload.success || !payload.session) {
+    throw new Error(payload.error ?? "Session not found.");
+  }
+  return {
+    success: true,
+    session: payload.session
+  };
+}
+async function postJson(url, body) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  const payload = await response.json().catch(() => ({}));
+  if (!response.ok || payload["success"] === false) {
+    throw new Error(String(payload["error"] ?? `Request failed with status ${response.status}.`));
+  }
+  return payload;
+}
+function readProjectScopedPorts(cwd) {
+  const portFile = path17.join(os.tmpdir(), "inspecto.port.json");
+  try {
+    const raw = fs6.readFileSync(portFile, "utf-8").trim();
+    const portData = JSON.parse(raw);
+    const currentRootHashes = resolveCandidateRootHashes(cwd);
+    const prioritized = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const rootHash of currentRootHashes) {
+      const currentPort = portData[rootHash];
+      if (currentPort && !seen.has(currentPort)) {
+        prioritized.push(currentPort);
+        seen.add(currentPort);
+      }
+    }
+    for (const port of Object.values(portData)) {
+      if (!seen.has(port)) {
+        prioritized.push(port);
+        seen.add(port);
+      }
+    }
+    return prioritized;
+  } catch {
+    return [];
+  }
+}
+function resolveCandidateRootHashes(cwd) {
+  const normalized = path17.resolve(cwd);
+  const candidates = /* @__PURE__ */ new Set();
+  let currentDir = normalized;
+  while (true) {
+    candidates.add(crypto.createHash("md5").update(currentDir).digest("hex"));
+    const parentDir = path17.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return [...candidates];
+}
+
+// src/onboarding/session.ts
+import path18 from "path";
 function normalizePackagePath2(packagePath) {
   if (!packagePath || packagePath === ".") return "";
   return packagePath.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "");
@@ -4328,7 +4643,7 @@ function getVerificationCommand(packageManager) {
   }
 }
 async function buildVerification(projectRoot, packageManager) {
-  const packageJson = await readJSON(path17.join(projectRoot, "package.json"));
+  const packageJson = await readJSON(path18.join(projectRoot, "package.json"));
   if (packageJson?.scripts?.dev) {
     const devCommand = getVerificationCommand(packageManager);
     return {
@@ -4386,7 +4701,7 @@ async function detectFrameworkSupportByPackage2(repoRoot, context) {
   await Promise.all(
     Array.from(packagePaths).map(async (packagePath) => {
       const frameworkResult = await detectFrameworks(
-        packagePath ? path17.join(repoRoot, packagePath) : repoRoot
+        packagePath ? path18.join(repoRoot, packagePath) : repoRoot
       );
       supportByPackage[packagePath] = frameworkResult.supported;
     })
@@ -4395,7 +4710,7 @@ async function detectFrameworkSupportByPackage2(repoRoot, context) {
 }
 async function buildTargetedContext(rootContext, target) {
   const packagePath = normalizePackagePath2(target.packagePath);
-  const projectRoot = packagePath ? path17.join(rootContext.root, packagePath) : rootContext.root;
+  const projectRoot = packagePath ? path18.join(rootContext.root, packagePath) : rootContext.root;
   const [frameworks, ides, providers] = await Promise.all([
     detectFrameworks(projectRoot),
     detectIDE(projectRoot),
@@ -4470,7 +4785,25 @@ function buildConfirmation(plan2, summary, session, options) {
     question: "Proceed with Inspecto onboarding using the proposed default target and settings?"
   };
 }
-function buildPreApplyResult(status, session) {
+async function buildDailyUsageHandoff(projectRoot) {
+  const localSettings = await readJSON(
+    path18.join(projectRoot, ".inspecto", "settings.local.json")
+  ) ?? {};
+  const sharedSettings = await readJSON(
+    path18.join(projectRoot, ".inspecto", "settings.json")
+  ) ?? {};
+  const annotateDeliveryMode = localSettings["annotate.deliveryMode"] ?? sharedSettings["annotate.deliveryMode"];
+  if (annotateDeliveryMode !== "agent") {
+    return void 0;
+  }
+  return {
+    mode: "agent",
+    skill: "inspecto-agent",
+    prompt: "Use $inspecto-agent to claim Inspecto tasks continuously",
+    requiresMcp: true
+  };
+}
+function buildPreApplyResult(status, session, dailyUsage) {
   const diagnostics = session.summary.risks.length > 0 || session.summary.manualFollowUp.length > 0 || session.plan.blockers.length > 0 ? {
     warnings: session.summary.risks,
     errors: session.plan.blockers.map((item) => item.message),
@@ -4496,6 +4829,7 @@ function buildPreApplyResult(status, session) {
     ...session.pendingSteps ? { pendingSteps: session.pendingSteps } : {},
     ...session.assistantPrompt ? { assistantPrompt: session.assistantPrompt } : {},
     ...session.patches ? { patches: session.patches } : {},
+    ...dailyUsage ? { dailyUsage } : {},
     ...diagnostics ? { diagnostics } : {}
   };
 }
@@ -4536,6 +4870,7 @@ function buildExecutionDiagnostics(session, applyResult) {
 async function resolveOnboardingSession(root, options = {}) {
   const rootContext = await buildOnboardingContext(root);
   const rootVerification = await buildVerification(root, rootContext.packageManager);
+  const rootDailyUsage = await buildDailyUsageHandoff(root);
   const frameworkSupportByPackage = await detectFrameworkSupportByPackage2(root, rootContext);
   const target = resolveOnboardingTarget({
     repoRoot: root,
@@ -4569,7 +4904,8 @@ async function resolveOnboardingSession(root, options = {}) {
       ...plan3.autoApplied ? { autoApplied: plan3.autoApplied } : {},
       ...plan3.pendingSteps ? { pendingSteps: plan3.pendingSteps } : {},
       ...plan3.assistantPrompt ? { assistantPrompt: plan3.assistantPrompt } : {},
-      ...plan3.patches ? { patches: plan3.patches } : {}
+      ...plan3.patches ? { patches: plan3.patches } : {},
+      ...rootDailyUsage ? { dailyUsage: rootDailyUsage } : {}
     };
   }
   if (target.status === "needs_selection") {
@@ -4593,6 +4929,7 @@ async function resolveOnboardingSession(root, options = {}) {
   }
   const context = await buildTargetedContext(rootContext, target.selected);
   const verification = await buildVerification(context.root, context.packageManager);
+  const dailyUsage = await buildDailyUsageHandoff(context.root);
   const plan2 = createPlanResult(context);
   const summary = buildOnboardingSummary(plan2, context.root);
   const confirmation = buildConfirmation(
@@ -4636,11 +4973,13 @@ async function resolveOnboardingSession(root, options = {}) {
     ...plan2.autoApplied ? { autoApplied: plan2.autoApplied } : {},
     ...plan2.pendingSteps ? { pendingSteps: plan2.pendingSteps } : {},
     ...plan2.assistantPrompt ? { assistantPrompt: plan2.assistantPrompt } : {},
-    ...plan2.patches ? { patches: plan2.patches } : {}
+    ...plan2.patches ? { patches: plan2.patches } : {},
+    ...dailyUsage ? { dailyUsage } : {}
   };
 }
 async function applyResolvedOnboardingSession(session, options = {}) {
   const verification = await buildVerification(session.projectRoot, session.context.packageManager);
+  const dailyUsage = await buildDailyUsageHandoff(session.projectRoot);
   const applyResult = await applyOnboardingPlan({
     repoRoot: process.cwd(),
     projectRoot: session.projectRoot,
@@ -4681,11 +5020,16 @@ async function applyResolvedOnboardingSession(session, options = {}) {
     ...session.pendingSteps ? { pendingSteps: session.pendingSteps } : {},
     ...session.assistantPrompt ? { assistantPrompt: session.assistantPrompt } : {},
     ...session.patches ? { patches: session.patches } : {},
+    ...dailyUsage ? { dailyUsage } : {},
     ...diagnostics ? { diagnostics } : {}
   };
 }
-function buildDeferredOnboardResult(session) {
-  return buildPreApplyResult(session.status, session);
+async function buildDeferredOnboardResult(session) {
+  return buildPreApplyResult(
+    session.status,
+    session,
+    await buildDailyUsageHandoff(session.projectRoot)
+  );
 }
 
 // src/commands/onboard.ts
@@ -4715,7 +5059,8 @@ function buildAssistantHandoff(result) {
     ...result.autoApplied ? { autoApplied: result.autoApplied } : {},
     ...result.pendingSteps ? { pendingSteps: result.pendingSteps } : {},
     ...result.assistantPrompt ? { assistantPrompt: result.assistantPrompt } : {},
-    ...result.patches ? { patches: result.patches } : {}
+    ...result.patches ? { patches: result.patches } : {},
+    ...result.dailyUsage ? { dailyUsage: result.dailyUsage } : {}
   };
 }
 function normalizeOnboardResult(result) {
@@ -4763,6 +5108,9 @@ function printOnboardResult(result) {
   if (normalized.handoff?.assistantPrompt) {
     log.hint(normalized.handoff.assistantPrompt);
   }
+  if (normalized.handoff?.dailyUsage?.prompt) {
+    log.hint(normalized.handoff.dailyUsage.prompt);
+  }
   if (normalized.confirmation.required && normalized.confirmation.question) {
     log.warn(normalized.confirmation.question);
   }
@@ -4777,7 +5125,7 @@ async function onboard(options = {}) {
   const session = await resolveOnboardingSession(root, options);
   if (session.status === "error" || session.status === "needs_target_selection" || session.status === "needs_confirmation") {
     return writeCommandOutput(
-      normalizeOnboardResult(buildDeferredOnboardResult(session)),
+      normalizeOnboardResult(await buildDeferredOnboardResult(session)),
       options.json ?? false,
       printOnboardResult
     );
@@ -4820,11 +5168,11 @@ async function plan(json = false) {
 }
 
 // src/commands/teardown.ts
-import path18 from "path";
+import path19 from "path";
 async function teardown() {
   const root = process.cwd();
   log.header("Inspecto Teardown");
-  const lockPath = path18.join(root, ".inspecto", "install.lock");
+  const lockPath = path19.join(root, ".inspecto", "install.lock");
   const lock = await readJSON(lockPath);
   if (!lock) {
     log.warn("No .inspecto/install.lock found. Running in best-effort mode.");
@@ -4837,8 +5185,8 @@ async function teardown() {
     } catch {
       log.warn("Could not remove @inspecto-dev/plugin (may not be installed)");
     }
-    if (await exists(path18.join(root, ".inspecto"))) {
-      await removeDir(path18.join(root, ".inspecto"));
+    if (await exists(path19.join(root, ".inspecto"))) {
+      await removeDir(path19.join(root, ".inspecto"));
       log.success("Deleted .inspecto/ directory");
     }
     await cleanGitignore(root);
@@ -4887,7 +5235,7 @@ async function teardown() {
       }
     }
   }
-  await removeDir(path18.join(root, ".inspecto"));
+  await removeDir(path19.join(root, ".inspecto"));
   log.success("Deleted .inspecto/ directory");
   await cleanGitignore(root);
   log.blank();
@@ -4896,13 +5244,13 @@ async function teardown() {
 }
 
 // src/commands/integration-install.ts
-import fs6 from "fs/promises";
+import fs7 from "fs/promises";
 import { homedir as homedir2 } from "os";
-import path21 from "path";
+import path22 from "path";
 import { fileURLToPath } from "url";
 
 // src/commands/integration-host-ide.ts
-import path19 from "path";
+import path20 from "path";
 async function resolveIntegrationHostIde(options = {}) {
   if (isSupportedHostIde(options.explicitIde)) {
     return {
@@ -4967,8 +5315,8 @@ async function resolveIntegrationHostIde(options = {}) {
 }
 async function resolveConfiguredIde(cwd) {
   const settingsPaths = [
-    path19.join(cwd, ".inspecto", "settings.local.json"),
-    path19.join(cwd, ".inspecto", "settings.json")
+    path20.join(cwd, ".inspecto", "settings.local.json"),
+    path20.join(cwd, ".inspecto", "settings.json")
   ];
   for (const settingsPath of settingsPaths) {
     const settings = await readJSON(settingsPath);
@@ -5019,7 +5367,7 @@ async function detectArtifactHostIdes(cwd) {
 
 // src/commands/integration-dispatch-mode.ts
 import { homedir } from "os";
-import path20 from "path";
+import path21 from "path";
 async function resolveIntegrationDispatchMode(options) {
   const assistantRule = getDualModeAssistantCapability(options.assistant);
   const home = options.homeDir ?? homedir();
@@ -5062,7 +5410,7 @@ async function isIdeExtensionInstalled(extensionId, extensionsDir) {
   } catch {
     return false;
   }
-  const obsoletePath = path20.join(extensionsDir, ".obsolete");
+  const obsoletePath = path21.join(extensionsDir, ".obsolete");
   let obsoleteFolders = /* @__PURE__ */ new Set();
   if (await exists(obsoletePath)) {
     const obsolete = await readJSON(obsoletePath);
@@ -5526,7 +5874,7 @@ async function installIntegration(assistant, options = {}) {
       if (await exists(asset.target)) {
         if (options.force) {
         } else if (manifest.type === "context-template") {
-          const originalContent = await fs6.readFile(asset.target, "utf-8");
+          const originalContent = await fs7.readFile(asset.target, "utf-8");
           existingFiles.set(asset.target, originalContent);
           if (!silent) {
             log.info(`File ${asset.target} already exists. Content will be appended safely.`);
@@ -5563,7 +5911,7 @@ ${content}`;
     for (const { asset, content } of downloadedAssets) {
       await writeFile(asset.target, content);
       if (asset.executable) {
-        await fs6.chmod(asset.target, 493);
+        await fs7.chmod(asset.target, 493);
       }
     }
   }
@@ -5678,23 +6026,30 @@ async function resolveProviderDefaultForAssistant(assistant, ide) {
   return `${assistant}.${mode}`;
 }
 async function persistProjectOnboardingDefaults(assistant, options) {
-  const settingsPath = path21.join(process.cwd(), ".inspecto", "settings.local.json");
+  const settingsPath = path22.join(process.cwd(), ".inspecto", "settings.local.json");
   const existingSettings = await readJSON(settingsPath);
   const resolvedHostIde = await resolveIntegrationHostIde({
     explicitIde: options.ide,
     cwd: process.cwd()
   });
   const providerDefault = resolvedHostIde.ide && resolvedHostIde.confidence !== "low" ? await resolveProviderDefaultForAssistant(assistant, resolvedHostIde.ide) : void 0;
+  const annotateDeliveryMode = resolveAnnotateDefaultDeliveryForAssistant(assistant);
   const mergedSettings = existingSettings && typeof existingSettings === "object" ? {
     ...existingSettings,
     ide: options.ide,
-    ...providerDefault ? { "provider.default": providerDefault } : {}
+    ...providerDefault ? { "provider.default": providerDefault } : {},
+    "annotate.deliveryMode": annotateDeliveryMode
   } : {
     ide: options.ide,
-    ...providerDefault ? { "provider.default": providerDefault } : {}
+    ...providerDefault ? { "provider.default": providerDefault } : {},
+    "annotate.deliveryMode": annotateDeliveryMode
   };
   await writeJSON(settingsPath, mergedSettings);
 }
+function resolveAnnotateDefaultDeliveryForAssistant(assistant) {
+  void assistant;
+  return "both";
+}
 function shouldSkipAutomationForInstall(options) {
   return options.scope === "user" && !options.preview;
 }
@@ -5845,28 +6200,39 @@ function resolveCodexPlan(options) {
   if (options.mode !== void 0) {
     throw new Error("`--mode` is not supported for codex.");
   }
-  const baseDir = scope === "user" ? path21.join(homedir2(), ".agents/skills/inspecto-onboarding-codex") : ".agents/skills/inspecto-onboarding-codex";
+  const baseDir = scope === "user" ? path22.join(homedir2(), ".agents/skills/inspecto-onboarding-codex") : ".agents/skills/inspecto-onboarding-codex";
+  const agentDir = scope === "user" ? path22.join(homedir2(), ".agents/skills/inspecto-agent-codex") : ".agents/skills/inspecto-agent-codex";
   return {
     assets: [
       {
         source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-codex/SKILL.md`,
-        target: path21.join(baseDir, "SKILL.md"),
+        target: path22.join(baseDir, "SKILL.md"),
         localSource: "skills/inspecto-onboarding-codex/SKILL.md"
       },
       {
         source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-codex/agents/openai.yaml`,
-        target: path21.join(baseDir, "agents/openai.yaml"),
+        target: path22.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: path21.join(baseDir, "scripts/run-inspecto.sh"),
+        target: path22.join(baseDir, "scripts/run-inspecto.sh"),
         executable: true,
         localSource: "skills/inspecto-onboarding-codex/scripts/run-inspecto.sh"
+      },
+      {
+        source: `${REPO_RAW_BASE}/skills/inspecto-agent-codex/SKILL.md`,
+        target: path22.join(agentDir, "SKILL.md"),
+        localSource: "skills/inspecto-agent-codex/SKILL.md"
+      },
+      {
+        source: `${REPO_RAW_BASE}/skills/inspecto-agent-codex/agents/openai.yaml`,
+        target: path22.join(agentDir, "agents/openai.yaml"),
+        localSource: "skills/inspecto-agent-codex/agents/openai.yaml"
       }
     ],
-    successMessage: `Installed Codex skill to ${baseDir}`,
-    nextStep: "Restart Codex or start a new Codex session to load the skill."
+    successMessage: `Installed Codex skills to ${baseDir} and ${agentDir}`,
+    nextStep: "Restart Codex or start a new Codex session to load the new skills."
   };
 }
 function resolveClaudeCodePlan(options) {
@@ -5880,22 +6246,22 @@ function resolveClaudeCodePlan(options) {
   if (scope !== "project" && scope !== "user") {
     throw new Error(`Unknown Claude Code scope: ${scope}`);
   }
-  const baseDir = scope === "user" ? path21.join(homedir2(), ".claude/skills/inspecto-onboarding-claude-code") : ".claude/skills/inspecto-onboarding-claude-code";
+  const baseDir = scope === "user" ? path22.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: path21.join(baseDir, "SKILL.md"),
+        target: path22.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: path21.join(baseDir, "agents/openai.yaml"),
+        target: path22.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: path21.join(baseDir, "scripts/run-inspecto.sh"),
+        target: path22.join(baseDir, "scripts/run-inspecto.sh"),
         executable: true,
         localSource: "skills/inspecto-onboarding-claude-code/scripts/run-inspecto.sh"
       }
@@ -5960,20 +6326,20 @@ async function loadAsset(asset) {
   if (asset.localSource) {
     const localPath = await resolveBundledAssetPath(asset.localSource);
     if (localPath) {
-      return await fs6.readFile(localPath, "utf-8");
+      return await fs7.readFile(localPath, "utf-8");
     }
   }
   return await downloadAsset(asset.source);
 }
 async function resolveBundledAssetPath(relativePath) {
-  const startDir = path21.dirname(fileURLToPath(import.meta.url));
+  const startDir = path22.dirname(fileURLToPath(import.meta.url));
   let currentDir = startDir;
   for (let depth = 0; depth < 8; depth += 1) {
-    const candidate = path21.join(currentDir, relativePath);
+    const candidate = path22.join(currentDir, relativePath);
     if (await exists(candidate)) {
       return candidate;
     }
-    const parent = path21.dirname(currentDir);
+    const parent = path22.dirname(currentDir);
     if (parent === currentDir) break;
     currentDir = parent;
   }
@@ -6087,6 +6453,10 @@ export {
   init,
   collectDoctorResult,
   doctor,
+  startMcpServer,
+  createInspectoMcpServer,
+  createInspectoMcpRuntime,
+  resolveInspectoServerBaseUrl,
   onboard,
   plan,
   teardown,