@inspecto-dev/cli 0.3.8 → 0.3.10

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
 /** Package manager detection result */
 type PackageManager = 'bun' | 'pnpm' | 'yarn' | 'npm';
 /** Supported build tools (v1) */
@@ -111,6 +113,12 @@ interface OnboardingVerification {
     devCommand?: string;
     message: string;
 }
+interface OnboardingDailyUsageHandoff {
+    mode: 'agent';
+    skill: string;
+    prompt: string;
+    requiresMcp: boolean;
+}
 interface OnboardingAssistantHandoff {
     framework?: string;
     metaFramework?: string;
@@ -119,6 +127,7 @@ interface OnboardingAssistantHandoff {
     pendingSteps?: string[];
     assistantPrompt?: string;
     patches?: OnboardingPatchPlan[];
+    dailyUsage?: OnboardingDailyUsageHandoff;
 }
 interface ResolvedOnboardingSession {
     status: OnboardStatus;
@@ -141,6 +150,7 @@ interface ResolvedOnboardingSession {
     pendingSteps?: string[];
     assistantPrompt?: string;
     patches?: OnboardingPatchPlan[];
+    dailyUsage?: OnboardingDailyUsageHandoff;
     handoff?: OnboardingAssistantHandoff;
 }
 interface OnboardCommandResult {
@@ -159,6 +169,7 @@ interface OnboardCommandResult {
     pendingSteps?: string[];
     assistantPrompt?: string;
     patches?: OnboardingPatchPlan[];
+    dailyUsage?: OnboardingDailyUsageHandoff;
     handoff?: OnboardingAssistantHandoff;
 }
 /** Machine-readable detection output for skill-first onboarding */
@@ -383,6 +394,44 @@ interface IntegrationDoctorResult {
 }
 declare function integrationDoctor(assistant: string, options?: IntegrationDoctorOptions): Promise<IntegrationDoctorResult>;
 
+interface McpCommandOptions {
+    serverUrl?: string;
+    version?: string;
+}
+interface InspectoMcpRuntime {
+    getSession(args: {
+        sessionId: string;
+    }): Promise<Record<string, unknown>>;
+    claimNext(args?: {
+        timeoutMs?: number;
+    }): Promise<{
+        success: boolean;
+        timedOut: boolean;
+        matchedExisting: boolean;
+        session?: Record<string, unknown>;
+        event?: string;
+    }>;
+    reply(args: {
+        sessionId: string;
+        text: string;
+    }): Promise<Record<string, unknown>>;
+    resolve(args: {
+        sessionId: string;
+        message?: string;
+    }): Promise<Record<string, unknown>>;
+    dismiss(args: {
+        sessionId: string;
+        message?: string;
+    }): Promise<Record<string, unknown>>;
+}
+declare function startMcpServer(options?: McpCommandOptions): Promise<void>;
+declare function createInspectoMcpServer(options: {
+    baseUrl: string;
+    version?: string;
+}): McpServer;
+declare function createInspectoMcpRuntime(baseUrl: string): InspectoMcpRuntime;
+declare function resolveInspectoServerBaseUrl(cwd: string): string | null;
+
 interface OnboardCommandOptions {
     json?: boolean;
     target?: string;
@@ -407,4 +456,4 @@ declare function reportCommandError(error: unknown, options?: ReportCommandError
 
 type Framework = 'react' | 'vue' | 'svelte' | 'solid' | 'astro';
 
-export { type BuildTool, type DoctorDiagnostic, type DoctorResult, type Framework, type InitOptions, type InstallLock, type OnboardCommandResult, type OnboardStatus, type PackageManager, type ResolvedOnboardingSession, apply, collectDoctorResult, detect, devLink, devStatus, devUnlink, doctor, init, integrationDoctor, onboard, plan, reportCommandError, teardown, writeCommandOutput };
+export { type BuildTool, type DoctorDiagnostic, type DoctorResult, type Framework, type InitOptions, type InstallLock, type OnboardCommandResult, type OnboardStatus, type PackageManager, type ResolvedOnboardingSession, apply, collectDoctorResult, createInspectoMcpRuntime, createInspectoMcpServer, detect, devLink, devStatus, devUnlink, doctor, init, integrationDoctor, onboard, plan, reportCommandError, resolveInspectoServerBaseUrl, startMcpServer, teardown, writeCommandOutput };

package/dist/index.js

@@ -1,6 +1,8 @@
 import {
   apply,
   collectDoctorResult,
+  createInspectoMcpRuntime,
+  createInspectoMcpServer,
   detect,
   devLink,
   devStatus,
@@ -11,12 +13,16 @@ import {
   onboard,
   plan,
   reportCommandError,
+  resolveInspectoServerBaseUrl,
+  startMcpServer,
   teardown,
   writeCommandOutput
-} from "./chunk-B5JDHSP7.js";
+} from "./chunk-WOZPOTWE.js";
 export {
   apply,
   collectDoctorResult,
+  createInspectoMcpRuntime,
+  createInspectoMcpServer,
   detect,
   devLink,
   devStatus,
@@ -27,6 +33,8 @@ export {
   onboard,
   plan,
   reportCommandError,
+  resolveInspectoServerBaseUrl,
+  startMcpServer,
   teardown,
   writeCommandOutput
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inspecto-dev/cli",
-  "version": "0.3.8",
+  "version": "0.3.10",
   "description": "CLI tools for Inspecto onboarding and lifecycle management",
   "keywords": [
     "inspecto",
@@ -15,12 +15,14 @@
     "inspecto": "./bin/inspecto.js"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "cac": "^6.7.14",
     "magicast": "^0.5.2",
-    "ora": "^9.3.0",
+    "ora": "^9.4.0",
     "picocolors": "^1.0.0",
     "prompts": "^2.4.2",
-    "@inspecto-dev/types": "0.3.8"
+    "zod": "^4.1.12",
+    "@inspecto-dev/types": "0.3.10"
   },
   "devDependencies": {
     "@types/node": "^20.19.39",

package/src/bin.ts

@@ -11,6 +11,7 @@ import { detect } from './commands/detect.js'
 import { devLink, devStatus, devUnlink } from './commands/dev-config.js'
 import { init } from './commands/init.js'
 import { doctor } from './commands/doctor.js'
+import { startMcpServer } from './commands/mcp.js'
 import { onboard } from './commands/onboard.js'
 import { plan } from './commands/plan.js'
 import { teardown } from './commands/teardown.js'
@@ -75,6 +76,10 @@ interface DevCommandOptions extends JsonCommandOptions {
   repo?: string
 }
 
+interface McpCommandOptions extends GlobalOptions {
+  serverUrl?: string
+}
+
 const integrationScopes = ['project', 'user'] as const
 const integrationModes = ['skills', 'instructions', 'agents', 'rules'] as const
 
@@ -128,6 +133,21 @@ export function createCli(_argv: readonly string[] = process.argv): CAC {
       }
     })
 
+  cli
+    .command('mcp', 'Run Inspecto as a minimal stdio MCP server for agents')
+    .option('--server-url <url>', 'Use an explicit Inspecto dev server base URL')
+    .option('--debug', 'Enable debug mode to show full error traces', { default: false })
+    .action(async (options: McpCommandOptions) => {
+      try {
+        await startMcpServer({
+          ...(options.serverUrl ? { serverUrl: options.serverUrl } : {}),
+          version,
+        })
+      } catch (error) {
+        exitWithError(error, options)
+      }
+    })
+
   cli
     .command('init', 'Set up Inspecto in your project')
     .option('--shared', 'Share .inspecto/settings.json with your team via Git', { default: false })

package/src/commands/init.ts

@@ -202,11 +202,15 @@ export async function init(options: InitOptions): Promise<void> {
   }
 
   // IDE detection
-  let selectedIDE: { ide: string; supported: boolean } | null = null
+  let selectedIDE: { ide: string; supported: boolean } | null
 
   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 {

package/src/commands/integration-install.ts

@@ -75,6 +75,7 @@ interface InstallPlan {
 interface InspectoSettingsShape {
   ide?: string
   'provider.default'?: string
+  'annotate.deliveryMode'?: 'ide' | 'agent' | 'both'
   [key: string]: unknown
 }
 
@@ -376,21 +377,31 @@ async function persistProjectOnboardingDefaults(
     resolvedHostIde.ide && resolvedHostIde.confidence !== 'low'
       ? await resolveProviderDefaultForAssistant(assistant, resolvedHostIde.ide)
       : undefined
+  const annotateDeliveryMode = resolveAnnotateDefaultDeliveryForAssistant(assistant)
   const mergedSettings =
     existingSettings && typeof existingSettings === 'object'
       ? {
           ...existingSettings,
           ide: options.ide,
           ...(providerDefault ? { 'provider.default': providerDefault } : {}),
+          'annotate.deliveryMode': annotateDeliveryMode,
         }
       : {
           ide: options.ide,
           ...(providerDefault ? { 'provider.default': providerDefault } : {}),
+          'annotate.deliveryMode': annotateDeliveryMode,
         }
 
   await writeJSON(settingsPath, mergedSettings)
 }
 
+function resolveAnnotateDefaultDeliveryForAssistant(
+  assistant: AssistantId,
+): 'ide' | 'agent' | 'both' {
+  void assistant
+  return 'both'
+}
+
 function shouldSkipAutomationForInstall(options: InstallIntegrationOptions): boolean {
   return options.scope === 'user' && !options.preview
 }
@@ -576,6 +587,10 @@ function resolveCodexPlan(options: InstallIntegrationOptions): InstallPlan {
     scope === 'user'
       ? path.join(homedir(), '.agents/skills/inspecto-onboarding-codex')
       : '.agents/skills/inspecto-onboarding-codex'
+  const agentDir =
+    scope === 'user'
+      ? path.join(homedir(), '.agents/skills/inspecto-agent-codex')
+      : '.agents/skills/inspecto-agent-codex'
 
   return {
     assets: [
@@ -595,9 +610,19 @@ function resolveCodexPlan(options: InstallIntegrationOptions): InstallPlan {
         executable: true,
         localSource: 'skills/inspecto-onboarding-codex/scripts/run-inspecto.sh',
       },
+      {
+        source: `${REPO_RAW_BASE}/skills/inspecto-agent-codex/SKILL.md`,
+        target: path.join(agentDir, 'SKILL.md'),
+        localSource: 'skills/inspecto-agent-codex/SKILL.md',
+      },
+      {
+        source: `${REPO_RAW_BASE}/skills/inspecto-agent-codex/agents/openai.yaml`,
+        target: path.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.',
   }
 }
 

package/src/commands/mcp.ts

@@ -0,0 +1,386 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import crypto from 'node: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'
+
+const DEFAULT_MCP_SERVER_VERSION = '0.0.0'
+
+export interface McpCommandOptions {
+  serverUrl?: string
+  version?: string
+}
+
+interface McpToolResult<T extends Record<string, unknown>> {
+  [key: string]: unknown
+  content: Array<{ type: 'text'; text: string }>
+  structuredContent: T
+  isError?: boolean
+}
+
+export interface InspectoMcpRuntime {
+  getSession(args: { sessionId: string }): Promise<Record<string, unknown>>
+  claimNext(args?: { timeoutMs?: number }): Promise<{
+    success: boolean
+    timedOut: boolean
+    matchedExisting: boolean
+    session?: Record<string, unknown>
+    event?: string
+  }>
+  reply(args: { sessionId: string; text: string }): Promise<Record<string, unknown>>
+  resolve(args: { sessionId: string; message?: string }): Promise<Record<string, unknown>>
+  dismiss(args: { sessionId: string; message?: string }): Promise<Record<string, unknown>>
+}
+
+export interface InspectoMcpToolDefinition {
+  name:
+    | 'inspecto_get_session'
+    | 'inspecto_claim_next'
+    | 'inspecto_reply'
+    | 'inspecto_resolve'
+    | 'inspecto_dismiss'
+  description: string
+}
+
+export const INSPECTO_MCP_TOOLS: InspectoMcpToolDefinition[] = [
+  {
+    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.',
+  },
+]
+
+export async function startMcpServer(options: McpCommandOptions = {}): Promise<void> {
+  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)
+}
+
+export function createInspectoMcpServer(options: { baseUrl: string; version?: string }): McpServer {
+  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 !== undefined ? { 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 }) => {
+      try {
+        const result = await runtime.resolve({ sessionId, ...(message ? { message } : {}) })
+        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 }) => {
+      try {
+        const result = await runtime.dismiss({ sessionId, ...(message ? { message } : {}) })
+        return toolSuccess(result)
+      } catch (error) {
+        return toolError(error)
+      }
+    },
+  )
+
+  return server
+}
+
+export function getToolDescription(name: InspectoMcpToolDefinition['name']): string {
+  return INSPECTO_MCP_TOOLS.find(tool => tool.name === name)?.description ?? name
+}
+
+export function createInspectoMcpRuntime(baseUrl: string): InspectoMcpRuntime {
+  return {
+    async getSession(args) {
+      return getSession(baseUrl, args.sessionId)
+    },
+
+    async claimNext(args = {}) {
+      return (await postJson(`${baseUrl}${INSPECTO_API_PATHS.SESSION_CLAIM_NEXT}`, {
+        ...(args.timeoutMs !== undefined ? { timeoutMs: args.timeoutMs } : {}),
+      })) as {
+        success: boolean
+        timedOut: boolean
+        matchedExisting: boolean
+        session?: Record<string, unknown>
+        event?: string
+      }
+    },
+
+    async reply(args) {
+      return postJson(
+        `${baseUrl}${INSPECTO_API_PATHS.SESSIONS}/${args.sessionId}${INSPECTO_API_PATHS.SESSION_REPLY_SUFFIX}`,
+        {
+          role: 'agent',
+          text: args.text.trim(),
+        },
+      ) as Promise<Record<string, unknown>>
+    },
+
+    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() } : {},
+      ) as Promise<Record<string, unknown>>
+    },
+
+    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() } : {},
+      ) as Promise<Record<string, unknown>>
+    },
+  }
+}
+
+export function resolveInspectoServerBaseUrl(cwd: string): string | null {
+  const ports = resolveServerPorts(cwd)
+  const port = ports[0]
+  return port ? `http://127.0.0.1:${port}` : null
+}
+
+export function resolveServerPorts(cwd: string): number[] {
+  const prioritized = readProjectScopedPorts(cwd)
+  if (prioritized.length > 0) return prioritized
+
+  const legacyPortFile = path.join(os.tmpdir(), 'inspecto.port')
+  try {
+    const raw = fs.readFileSync(legacyPortFile, 'utf-8').trim()
+    const port = parseInt(raw, 10)
+    if (Number.isInteger(port) && port > 0 && port < 65536) {
+      return [port]
+    }
+  } catch {
+    // ignore
+  }
+
+  return Array.from({ length: 23 }, (_, index) => 5678 + index)
+}
+
+function toolSuccess<T extends Record<string, unknown>>(value: T): McpToolResult<T> {
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(value, null, 2),
+      },
+    ],
+    structuredContent: value,
+  }
+}
+
+function toolError(error: unknown): McpToolResult<{ success: false; error: string }> {
+  const message = error instanceof Error ? error.message : String(error)
+  return {
+    content: [
+      {
+        type: 'text',
+        text: message,
+      },
+    ],
+    structuredContent: {
+      success: false,
+      error: message,
+    },
+    isError: true,
+  }
+}
+
+async function getJson(url: string): Promise<unknown> {
+  const response = await fetch(url)
+  const payload = (await response.json().catch(() => ({}))) as Record<string, unknown>
+  if (!response.ok) {
+    throw new Error(String(payload['error'] ?? `Request failed with status ${response.status}.`))
+  }
+  return payload
+}
+
+async function getSession(baseUrl: string, sessionId: string): Promise<Record<string, unknown>> {
+  const trimmed = sessionId.trim()
+  if (!trimmed) {
+    throw new Error('Session id is required.')
+  }
+
+  const payload = (await getJson(
+    `${baseUrl}${INSPECTO_API_PATHS.SESSIONS}/${encodeURIComponent(trimmed)}`,
+  )) as {
+    success?: boolean
+    session?: Record<string, unknown>
+    error?: string
+  }
+
+  if (!payload.success || !payload.session) {
+    throw new Error(payload.error ?? 'Session not found.')
+  }
+
+  return {
+    success: true,
+    session: payload.session,
+  }
+}
+
+async function postJson(url: string, body: Record<string, unknown>): Promise<unknown> {
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  })
+  const payload = (await response.json().catch(() => ({}))) as Record<string, unknown>
+  if (!response.ok || payload['success'] === false) {
+    throw new Error(String(payload['error'] ?? `Request failed with status ${response.status}.`))
+  }
+  return payload
+}
+
+function readProjectScopedPorts(cwd: string): number[] {
+  const portFile = path.join(os.tmpdir(), 'inspecto.port.json')
+  try {
+    const raw = fs.readFileSync(portFile, 'utf-8').trim()
+    const portData = JSON.parse(raw) as Record<string, number>
+    const currentRootHashes = resolveCandidateRootHashes(cwd)
+
+    const prioritized: number[] = []
+    const seen = new Set<number>()
+
+    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: string): string[] {
+  const normalized = path.resolve(cwd)
+  const candidates = new Set<string>()
+  let currentDir = normalized
+
+  while (true) {
+    candidates.add(crypto.createHash('md5').update(currentDir).digest('hex'))
+    const parentDir = path.dirname(currentDir)
+    if (parentDir === currentDir) {
+      break
+    }
+    currentDir = parentDir
+  }
+
+  return [...candidates]
+}

package/src/commands/onboard.ts

@@ -57,6 +57,7 @@ function buildAssistantHandoff(
     ...(result.pendingSteps ? { pendingSteps: result.pendingSteps } : {}),
     ...(result.assistantPrompt ? { assistantPrompt: result.assistantPrompt } : {}),
     ...(result.patches ? { patches: result.patches } : {}),
+    ...(result.dailyUsage ? { dailyUsage: result.dailyUsage } : {}),
   }
 }
 
@@ -110,6 +111,9 @@ function printOnboardResult(result: OnboardCommandResult): void {
   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)
   }
@@ -139,7 +143,7 @@ export async function onboard(options: OnboardCommandOptions = {}): Promise<Onbo
     session.status === 'needs_confirmation'
   ) {
     return writeCommandOutput(
-      normalizeOnboardResult(buildDeferredOnboardResult(session)),
+      normalizeOnboardResult(await buildDeferredOnboardResult(session)),
       options.json ?? false,
       printOnboardResult,
     )