itermbot 1.0.2 → 1.0.4

package/src/config.ts

@@ -1,26 +1,53 @@
-import {
-  createRuntimeConfig,
-  getModelsConfigPath as getRuntimeModelsConfigPath,
-  getMemoryConfigPath as getRuntimeMemoryConfigPath,
-  getToolConfigPath as getRuntimeToolConfigPath,
-  type AgentRuntimeConfig,
-} from "@easynet/agent-runtime";
+import { resolveKindResourceFile, asObject } from "@easynet/agent-common/config";
 
-export type AppConfig = AgentRuntimeConfig;
+export type PromptTemplates = {
+  systemPrompt?: string;
+};
 
-export async function loadAppConfig(configPath?: string): Promise<AppConfig> {
-  const runtimeConfig = await createRuntimeConfig({ configPath });
-  return runtimeConfig;
-}
-
-export function getModelsConfigPath(config: AppConfig, agentName?: string): string {
-  return getRuntimeModelsConfigPath(config, agentName);
-}
+export type ResponseSafetyMode = "off" | "balanced" | "strict";
 
-export function getMemoryConfigPath(config: AppConfig, agentName?: string): string {
-  return getRuntimeMemoryConfigPath(config, agentName);
-}
+export type AppConfig = {
+  printSteps?: boolean;
+  maxSteps?: number;
+  promptTemplates?: PromptTemplates;
+  responseSafetyMode?: ResponseSafetyMode;
+};
 
-export function getToolConfigPath(config: AppConfig, agentName?: string): string {
-  return getRuntimeToolConfigPath(config, agentName);
+export async function loadAppConfig(configPath: string): Promise<AppConfig> {
+  try {
+    const resource = await resolveKindResourceFile<{
+      printSteps?: unknown;
+      maxSteps?: unknown;
+      promptTemplates?: PromptTemplates;
+      responseSafetyMode?: unknown;
+    }>(configPath, {
+      baseDir: process.cwd(),
+      expectedApiVersion: "easynet.world/v1",
+      expectedKind: "AppConfig",
+    });
+    const spec = asObject(resource.spec) as {
+      printSteps?: unknown;
+      maxSteps?: unknown;
+      promptTemplates?: PromptTemplates;
+      responseSafetyMode?: unknown;
+    } | undefined;
+    const modeRaw = typeof spec?.responseSafetyMode === "string" ? spec.responseSafetyMode.trim().toLowerCase() : "";
+    const responseSafetyMode =
+      modeRaw === "off" || modeRaw === "balanced" || modeRaw === "strict"
+        ? (modeRaw as ResponseSafetyMode)
+        : undefined;
+    const printSteps = typeof spec?.printSteps === "boolean" ? spec.printSteps : undefined;
+    const maxSteps =
+      typeof spec?.maxSteps === "number" && Number.isFinite(spec.maxSteps)
+        ? Math.max(1, Math.floor(spec.maxSteps))
+        : undefined;
+    return {
+      printSteps,
+      maxSteps,
+      promptTemplates: spec?.promptTemplates,
+      responseSafetyMode,
+    };
+  } catch {
+    return {};
+  }
 }

package/src/index.ts

@@ -1,67 +1,105 @@
 #!/usr/bin/env node
 /**
- * iTermBot: ReAct agent (LangChain) + Deep agent (DeepAgents).
+ * iTermBot: ReAct agent powered by @easynet/agent-runtime.
  * Usage:
- *   npm start              # interactive: choose agent then chat
- *   npm run react          # use ReAct agent
- *   npm run deep           # use Deep agent
- *   node dist/index.js react "Your question"
- *   node dist/index.js deep "Your question"
+ *   npm start                        # interactive REPL
+ *   node dist/index.js "Your question"  # single-turn
  */
+import * as readline from "node:readline";
+import { marked } from "marked";
+import { markedTerminal } from "marked-terminal";
 import {
-  runAppCli,
-  createStructuredRunEventListener,
-} from "@easynet/agent-runtime";
-import { readFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import type { TargetRoutingState } from "./target-routing.js";
-import { applyStartupPanelColors, restoreSessionColorsSync } from "./startup-colors.js";
-import { injectTargetSessionHint } from "./session-hint.js";
-import { enableDynamicTargetRouting } from "./target-routing.js";
-import { createBotContext } from "./context.js";
+  createAgentEventBus,
+  type AgentEventListener,
+} from "@easynet/agent-common";
+import { resolveConfigPath } from "@easynet/agent-common/config";
+import { createAgentReactRuntime } from "@easynet/agent-runtime";
+import { createAgentModel } from "@easynet/agent-model";
+import { createAgentMemory } from "@easynet/agent-memory";
+import { createAgentTools } from "@easynet/agent-tool";
+import { createAgentSkills } from "@easynet/agent-skill";
+import { runWithTextToolCallRecovery } from "./runtime/text-tool-call-recovery.js";
+import { applyStartupPanelColors, restoreSessionColorsSync } from "./startup/colors.js";
+import { buildSystemPrompt } from "./iterm/session-hint.js";
+import {
+  detectDirectTargetPanelCommand,
+  tryHandleDirectTargetPanelCommand,
+} from "./iterm/direct-command-router.js";
+import { enforceTargetPanelExecutionPolicy, setTargetPanelHint } from "./iterm/target-panel-policy.js";
+import { runLlmHealthCheck } from "./startup/diagnostics.js";
+import { detectStartupTargetOs } from "./startup/os.js";
+import { createChatProgressEventListener } from "./chat/progress.js";
+import { renderStepLine } from "./chat/step-display.js";
+import { enforceResponseSafetyWithMode } from "./chat/response-safety.js";
+import { tryHandleBuiltinReadCommand } from "./chat/builtin-commands.js";
+import {
+  clearStartupNoise,
+  formatLogPath,
+  getAppVersion,
+  printStartupBanner,
+  printStartupSummary,
+  runStartupStep,
+  StartupProgressRenderer,
+} from "./startup/ui.js";
+import { loadAppConfig, type ResponseSafetyMode } from "./config.js";
 
 let startupColorSnapshots: Parameters<typeof restoreSessionColorsSync>[0] = [];
-let stopDynamicTargetRouting: (() => void) | null = null;
+let unpatchTargetPanelPolicy: (() => void) | null = null;
+type AgentRuntime = Awaited<ReturnType<typeof createAgentReactRuntime>>;
+
+marked.use(markedTerminal({
+  code: false,
+  width: Math.max(80, process.stdout.columns ?? 100),
+  reflowText: true,
+  heading: (text: string, level: number) => `\n${"#".repeat(level)} ${text}\n`,
+}) as never);
+
+function renderMarkdownForTerminal(text: string): string {
+  try {
+    const rendered = marked.parse(text) as string;
+    return rendered.trimEnd();
+  } catch {
+    return text;
+  }
+}
+
+let conversationTurn = 0;
+
+function supportsColor(): boolean {
+  return Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+}
+
+function colorize(text: string, code: string): string {
+  if (!supportsColor()) return text;
+  return `${code}${text}\x1b[0m`;
+}
+
+function divider(char = "─"): string {
+  const width = Math.max(50, Math.min(process.stdout.columns ?? 100, 120));
+  return char.repeat(width);
+}
+
+function printUserMessage(turn: number, text: string): void {
+  console.log(`\n${colorize(divider("─"), "\x1b[2m")}`);
+  console.log(colorize(`[Turn ${turn}] USER`, "\x1b[1m\x1b[36m"));
+  console.log(text);
+}
+
+function printBotMessage(text: string, turn = conversationTurn): void {
+  const rendered = renderMarkdownForTerminal(text);
+  console.log(colorize(`[Turn ${turn}] iTermBot`, "\x1b[1m\x1b[32m"));
+  console.log(rendered);
+  console.log(colorize(divider("─"), "\x1b[2m"));
+}
 
 function sanitizeSessionId(input: string): string {
   return input.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
 }
 
-function configureThreadMemoryNamespace(ctx: Parameters<NonNullable<Parameters<typeof runAppCli>[0]["onReady"]>>[0], args: {
-  chatSessionId: string | null;
-}): string {
-  const appConfig = ctx.config.app as
-    | {
-        agent?: Record<string, { memory?: { namespace_mode?: "thread" | "fixed"; namespace?: string } }>;
-      }
-    | undefined;
-  const agents = appConfig?.agent;
-  const defaultBaseNamespace = "user:itermbot";
-  const baseNamespace =
-    agents?.react?.memory?.namespace ??
-    agents?.deep?.memory?.namespace ??
-    defaultBaseNamespace;
-  const mode = agents?.react?.memory?.namespace_mode ?? agents?.deep?.memory?.namespace_mode ?? "thread";
-  const seed = args.chatSessionId ? sanitizeSessionId(args.chatSessionId) : `local_${Date.now().toString(36)}`;
-  const threadNamespace = mode === "fixed" ? baseNamespace : `${baseNamespace}:thread:${seed}`;
-
-  if (!ctx.config.app) ctx.config.app = {};
-  if (!ctx.config.app.agent) ctx.config.app.agent = {};
-
-  for (const agentName of ["react", "deep"]) {
-    const current = ctx.config.app.agent[agentName] ?? {};
-    const currentMemory = current.memory ?? {};
-    ctx.config.app.agent[agentName] = {
-      ...current,
-      memory: {
-        ...currentMemory,
-        namespace: threadNamespace,
-      },
-    };
-  }
-
-  return threadNamespace;
+function buildNamespace(chatSessionId: string | null): string {
+  const base = "user:itermbot";
+  const seed = chatSessionId ? sanitizeSessionId(chatSessionId) : `local_${Date.now().toString(36)}`;
+  return `${base}:thread:${seed}`;
 }
 
 function ensureItermEnvironmentOrExit(): void {
@@ -69,135 +107,307 @@ function ensureItermEnvironmentOrExit(): void {
   const itermSessionId = process.env.ITERM_SESSION_ID?.trim();
   const isIterm = termProgram === "iTerm.app" || Boolean(itermSessionId);
   if (isIterm) return;
-
   console.error("iTermBot startup blocked: iTerm2 environment is required.");
   console.error("Please run iTermBot inside iTerm2 and try again.");
   process.exit(1);
 }
 
-function printStartupBanner(): void {
-  const lines = [
-    "  _ _____                   ____        _   ",
-    " (_)_   _|__ _ __ _ __ ___ | __ )  ___ | |_ ",
-    " | | | |/ _ \\ '__| '_ ` _ \\|  _ \\ / _ \\| __|",
-    " | | | |  __/ |  | | | | | | |_) | (_) | |_ ",
-    " |_| |_|\\___|_|  |_| |_| |_|____/ \\___/ \\__|",
-    "                   iTermBot                 ",
-  ];
-  console.log("--------------------------------------------------------------------------------------------------");
-  console.log(`\n${lines.join("\n")}`);
-  console.log("      Observe the terminal. Act with precision.\n");
+async function buildRuntime(
+  systemPrompt: string,
+  namespace: string,
+  startup: Awaited<ReturnType<typeof applyStartupPanelColors>>,
+  maxSteps?: number,
+): Promise<AgentRuntime> {
+  createAgentEventBus();
+  await createAgentModel({
+    configPath: resolveConfigPath("config/model.yaml", process.cwd()),
+  });
+
+  const memoryConfigPath = resolveConfigPath("config/memory.yaml", process.cwd());
+  await createAgentMemory({ configPath: memoryConfigPath });
+  const tools = createAgentTools({
+    configFilePath: resolveConfigPath("config/tool.yaml", process.cwd()),
+    coreTools: { sandboxRoot: process.cwd() },
+  });
+  setTargetPanelHint({
+    windowId: startup.windowId ?? undefined,
+    tabIndex: startup.tabIndex ?? undefined,
+    sessionId: startup.targetSessionId ?? undefined,
+  });
+  if (unpatchTargetPanelPolicy) unpatchTargetPanelPolicy();
+  unpatchTargetPanelPolicy = enforceTargetPanelExecutionPolicy(tools);
+  await createAgentSkills(resolveConfigPath("config/skill.yaml", process.cwd()));
+
+  return createAgentReactRuntime({
+    systemPrompt,
+    namespace,
+    ...(typeof maxSteps === "number" ? { maxSteps } : {}),
+  });
 }
 
-function clearStartupNoise(): void {
-  if (!process.stdout.isTTY) return;
-  process.stdout.write("\x1b[2J\x1b[H");
+async function runInteractive(runtime: AgentRuntime): Promise<void> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true,
+  });
+
+  const ask = (): void => {
+    rl.question("\nyou> ", async (input) => {
+      const trimmed = input.trim();
+      if (trimmed === "exit" || trimmed === "quit") {
+        rl.close();
+        return;
+      }
+      if (!trimmed) {
+        ask();
+        return;
+      }
+      conversationTurn += 1;
+      const turn = conversationTurn;
+      printUserMessage(turn, trimmed);
+      try {
+        const builtin = tryHandleBuiltinReadCommand(trimmed, runtime);
+        if (builtin !== null) {
+          printBotMessage(builtin, turn);
+          ask();
+          return;
+        }
+
+        const directOutput = await tryHandleDirectCommandWithProgress(trimmed, runtime);
+        if (directOutput !== null) {
+          printBotMessage(directOutput, turn);
+          ask();
+          return;
+        }
+
+        const recoveryWriter = printSteps ? writeStepLine : () => {};
+        const result = await runWithTextToolCallRecovery(runtime, trimmed, recoveryWriter, {
+          windowId: startup.windowId ?? undefined,
+          tabIndex: startup.tabIndex ?? undefined,
+          sessionId: startup.targetSessionId ?? undefined,
+        });
+        const safeText = enforceResponseSafetyWithMode(result.text, responseSafetyMode, {
+          evidenceText: result.evidenceText,
+          targetOs: startupTargetOs,
+        });
+        if (safeText) printBotMessage(safeText, turn);
+      } catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : String(error));
+      }
+      ask();
+    });
+  };
+
+  rl.on("close", () => {
+    shutdown();
+    process.exit(0);
+  });
+
+  ask();
 }
 
-function getAppVersion(): string {
-  try {
-    const currentFile = fileURLToPath(import.meta.url);
-    const packageJsonPath = resolve(dirname(currentFile), "../package.json");
-    const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8")) as { version?: unknown };
-    return typeof parsed.version === "string" ? parsed.version : "unknown";
-  } catch {
-    return "unknown";
+function shutdown(): void {
+  if (unpatchTargetPanelPolicy) {
+    unpatchTargetPanelPolicy();
+    unpatchTargetPanelPolicy = null;
+  }
+  setTargetPanelHint(null);
+  if (startupColorSnapshots.length > 0) {
+    restoreSessionColorsSync(startupColorSnapshots);
   }
 }
 
-function printStartupSummary(args: {
-  version: string;
-}): void {
-  console.log("--------------------------------------------------------------------------------------------------");
-  console.log(`Version   : v${args.version}`);
-  console.log(`Workspace : ${process.cwd()}`);
-  console.log("");
-  console.log("Commands  : list tools, list skills, exit");
-  console.log("--------------------------------------------------------------------------------------------------\n");
-}
-
-ensureItermEnvironmentOrExit();
-clearStartupNoise();
-printStartupBanner();
-
-runAppCli({
-  appName: "iTermBot",
-  createBotContext,
-  ui: {
-    assistantLabel: "iTermBot",
-    useColor: true,
-    echoUserQuestion: false,
-    processingSpinner: true,
-    processingText: false,
-    loadingText: "Loading config, LLM, memory, tools...",
-    loadingSpinner: true,
-    readyText: false,
-    interactiveIntro: false,
-  },
-  eventListener: createStructuredRunEventListener((line) => console.log(line)),
-  onShutdown: () => {
-    if (stopDynamicTargetRouting) {
-      stopDynamicTargetRouting();
-      stopDynamicTargetRouting = null;
-    }
-    if (startupColorSnapshots.length > 0) {
-      restoreSessionColorsSync(startupColorSnapshots);
-    }
-  },
-  onReady: async (ctx) => {
-    const startup = await applyStartupPanelColors();
-    const routingState: TargetRoutingState = {
-      chatSessionId: startup.chatSessionId,
-      chatWindowId: startup.windowId,
-      chatTabIndex: startup.tabIndex,
-      targetSessionId: startup.targetSessionId,
-      windowId: startup.windowId,
-      tabIndex: startup.tabIndex,
-    };
-    stopDynamicTargetRouting = enableDynamicTargetRouting(ctx, routingState);
-    configureThreadMemoryNamespace(ctx, {
-      chatSessionId: startup.chatSessionId,
-    });
+process.on("SIGINT", () => { shutdown(); process.exit(0); });
+process.on("SIGTERM", () => { shutdown(); process.exit(0); });
 
-    startupColorSnapshots = startup.colorSnapshots;
+let startup: Awaited<ReturnType<typeof applyStartupPanelColors>> = {
+  chatSessionId: null,
+  targetSessionId: null,
+  windowId: null,
+  tabIndex: null,
+  colorSnapshots: [],
+};
+let responseSafetyMode: ResponseSafetyMode = "balanced";
+let startupTargetOs = "";
+let printSteps = false;
+let maxSteps = 16;
 
-    printStartupSummary({
-      version: getAppVersion(),
-    });
-    injectTargetSessionHint(ctx, {
-      ...startup,
-      targetSessionId: routingState.targetSessionId,
-      windowId: routingState.windowId,
-      tabIndex: routingState.tabIndex,
+function formatStepNumber(stepNumber: number): string {
+  return String(Math.max(0, stepNumber)).padStart(2, "0");
+}
+
+function writeStepLine(line: string): void {
+  console.log(renderStepLine(line));
+}
+
+async function tryHandleDirectCommandWithProgress(
+  input: string,
+  runtime: AgentRuntime,
+): Promise<string | null> {
+  const verbose = process.env.ITB_VERBOSE_DIRECT_ROUTE?.trim() === "1" || printSteps;
+  const startedAt = Date.now();
+  const writeStep = (line: string): void => console.log(renderStepLine(line));
+  if (verbose) {
+    writeStep("");
+    writeStep("=== Steps: direct command routing ===");
+    writeStep(`[${formatStepNumber(1)}] ▶ detect/translate direct command`);
+  }
+  try {
+    const directIntent = detectDirectTargetPanelCommand(input);
+    if (verbose && directIntent?.command) {
+      const reason = directIntent.reason === "raw_shell_command"
+        ? "Because your input is an executable shell command, execute it directly in the target panel."
+        : "Because you explicitly requested direct terminal execution, execute it directly in the target panel.";
+      writeStep(`    reason: ${reason}`);
+    }
+
+    const directOutput = await tryHandleDirectTargetPanelCommand(input, runtime, {
+      windowId: startup.windowId ?? undefined,
+      tabIndex: startup.tabIndex ?? undefined,
+      sessionId: startup.targetSessionId ?? undefined,
     });
-  },
-  interactiveCommands: {
-    "list tools": (ctx) => {
-      const tools = (ctx.tools as Array<{ name?: unknown; description?: unknown }>)
-        .map((tool) => ({
-          name: typeof tool.name === "string" ? tool.name : "(unnamed-tool)",
-          description:
-            typeof tool.description === "string" && tool.description.trim().length > 0
-              ? tool.description.trim()
-              : "No description",
-        }))
-        .sort((a, b) => a.name.localeCompare(b.name));
-      console.log(`Available tools (${tools.length}):`);
-      for (const tool of tools) {
-        console.log(`- ${tool.name}: ${tool.description}`);
-      }
-    },
-    "list skills": (ctx) => {
-      const skills = (ctx.skillSet?.list() ?? [])
-        .map((skill) => ({
-          name: skill.name,
-          description: (skill.description ?? "").trim() || "No description",
-        }))
-        .sort((a, b) => a.name.localeCompare(b.name));
-      console.log(`Available skills (${skills.length}):`);
-      for (const skill of skills) {
-        console.log(`- ${skill.name}: ${skill.description}`);
+    if (directOutput === null) {
+      if (verbose) {
+        writeStep(`[${formatStepNumber(1)}] ✓ detect/translate direct command (fallback to agent)`);
+        writeStep("    progress 1/1");
+        writeStep("=== Steps complete: 1 step(s) ===");
+        writeStep("");
       }
-    },
-  },
+      return null;
+    }
+    if (verbose) {
+      const elapsed = Date.now() - startedAt;
+      writeStep(`[${formatStepNumber(1)}] ✓ detect/translate direct command (${elapsed}ms)`);
+      writeStep("    progress 1/1");
+      writeStep(`=== Steps complete: 1 step(s), ${elapsed}ms ===`);
+      writeStep("");
+    }
+    return directOutput;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (verbose) {
+      const elapsed = Date.now() - startedAt;
+      writeStep(`[${formatStepNumber(1)}] ✖ detect/translate direct command`);
+      writeStep(`    error: ${message}`);
+      writeStep("    progress 1/1");
+      writeStep(`=== Steps complete: 1 step(s), ${elapsed}ms ===`);
+      writeStep("");
+    }
+    throw error;
+  }
+}
+
+async function main(): Promise<void> {
+  ensureItermEnvironmentOrExit();
+  clearStartupNoise();
+  printStartupBanner();
+
+  const progress = new StartupProgressRenderer();
+
+  // 1. Load app config (prompt templates only)
+  const appConfigPath = resolveConfigPath("config/app.yaml", process.cwd());
+  const appConfig = await runStartupStep(
+    progress,
+    "init app config",
+    () => loadAppConfig(appConfigPath),
+    () => formatLogPath(appConfigPath),
+  );
+  printSteps = appConfig.printSteps === true;
+  maxSteps = appConfig.maxSteps ?? 16;
+  responseSafetyMode = appConfig.responseSafetyMode ?? "balanced";
+
+  // 2. Identify iTerm panels and apply colors
+  startup = await runStartupStep(
+    progress,
+    "init iTerm panels",
+    () => applyStartupPanelColors(),
+  );
+  startupColorSnapshots = startup.colorSnapshots;
+
+  // 3. Detect target panel OS early so command translation can be OS-aware.
+  const osInfo = await runStartupStep(
+    progress,
+    "detect target os",
+    () => detectStartupTargetOs({
+      windowId: startup.windowId ?? undefined,
+      tabIndex: startup.tabIndex ?? undefined,
+      sessionId: startup.targetSessionId ?? undefined,
+    }),
+    (info) => `${info.os} (${info.source})`,
+  );
+  startupTargetOs = osInfo.os;
+  process.env.ITB_TARGET_OS = osInfo.os;
+
+  // 4. Build system prompt and namespace
+  const namespace = buildNamespace(startup.chatSessionId);
+  const systemPrompt = buildSystemPrompt(appConfig.promptTemplates, startup, "", {
+    targetOs: startupTargetOs,
+  });
+
+  // 5. Create agent runtime (model/memory/tools registered by application)
+  let runtime!: AgentRuntime;
+  await runStartupStep(
+    progress,
+    "init agent runtime",
+    async () => { runtime = await buildRuntime(systemPrompt, namespace, startup, maxSteps); },
+    () => `namespace=${namespace}`,
+  );
+
+  // 6. Subscribe to agent events for UI output
+  if (printSteps) {
+    const listener: AgentEventListener = createChatProgressEventListener(console.log);
+    runtime.events.subscribe(listener);
+  }
+
+  // 7. LLM health check — call LLM directly, not through agent loop
+  await runStartupStep(
+    progress,
+    "check llm health",
+    () => runLlmHealthCheck(runtime),
+    (label) => label,
+  );
+
+  printStartupSummary({ version: getAppVersion(), responseSafetyMode, targetOs: startupTargetOs });
+
+  // 8. Single-turn or interactive REPL
+  const args = process.argv.slice(2);
+  const question = args.find((a) => !a.startsWith("-") && a !== "react" && a !== "deep");
+  if (question) {
+    conversationTurn += 1;
+    const turn = conversationTurn;
+    printUserMessage(turn, question);
+    const builtin = tryHandleBuiltinReadCommand(question, runtime);
+    if (builtin !== null) {
+      printBotMessage(builtin, turn);
+      shutdown();
+      return;
+    }
+
+    const directOutput = await tryHandleDirectCommandWithProgress(question, runtime);
+    if (directOutput !== null) {
+      printBotMessage(directOutput, turn);
+    } else {
+      const recoveryWriter = printSteps ? writeStepLine : () => {};
+      const result = await runWithTextToolCallRecovery(runtime, question, recoveryWriter, {
+        windowId: startup.windowId ?? undefined,
+        tabIndex: startup.tabIndex ?? undefined,
+        sessionId: startup.targetSessionId ?? undefined,
+      });
+      const safeText = enforceResponseSafetyWithMode(result.text, responseSafetyMode, {
+        evidenceText: result.evidenceText,
+        targetOs: startupTargetOs,
+      });
+      if (safeText) printBotMessage(safeText, turn);
+    }
+    shutdown();
+  } else {
+    await runInteractive(runtime);
+  }
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  shutdown();
+  process.exit(1);
 });