mia-code 0.2.0

package/src/cli.ts

@@ -0,0 +1,742 @@
+import { createInterface } from "readline";
+import chalk from "chalk";
+import { loadConfig, saveConfig, ENGINE_MODELS, ENGINES } from "./config.js";
+import { runGeminiHeadless } from "./geminiHeadless.js";
+import { rememberSession, getLastSessionForProject, listSessions, clearSessions, markSessionInitialized, isSessionInitialized, saveChatMessage, loadChatHistory } from "./sessionStore.js";
+import { MiaCodeSessionMeta, MiaCodeConfig, Engine, ChatMessage } from "./types.js";
+import { renderEventsToText, formatHeader, formatHelpText, formatError, formatSuccess } from "./formatting.js";
+import { runUnifierSession } from "./unifier.js";
+import { MultilineInput, supportsMultilineInput, TabCompletion } from "./multiline-input.js";
+import { findMatchingCommands, getCommand } from "./commands.js";
+import path from "path";
+import fs from "fs";
+
+/** Prompt a numbered-choice question and return the 0-based index chosen. */
+async function promptChoice(label: string, options: string[], current?: string): Promise<number> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  console.log(chalk.bold(`\n${label}`));
+  options.forEach((opt, i) => {
+    const marker = opt === current ? chalk.green(" ◀ current") : "";
+    console.log(chalk.dim(`  ${i + 1}. ${opt}${marker}`));
+  });
+  return new Promise((resolve) => {
+    rl.question(chalk.cyan(`  select (1-${options.length}): `), (answer) => {
+      rl.close();
+      const n = parseInt(answer.trim(), 10);
+      if (isNaN(n) || n < 1 || n > options.length) {
+        console.log(chalk.yellow("  cancelled (invalid choice)"));
+        resolve(-1);
+      } else {
+        resolve(n - 1);
+      }
+    });
+  });
+}
+
+/** Interactive config: pick engine → pick model → save */
+async function runInteractiveConfig(config: MiaCodeConfig): Promise<void> {
+  console.log(chalk.dim("\ncurrent configuration:"));
+  console.log(chalk.dim(`  engine: ${config.engine}`));
+  console.log(chalk.dim(`  model:  ${config.model}`));
+
+  // 1. Pick engine
+  const engineIdx = await promptChoice("Select engine:", ENGINES, config.engine);
+  if (engineIdx < 0) return;
+  const engine = ENGINES[engineIdx];
+
+  // 2. Pick model for chosen engine
+  const models = ENGINE_MODELS[engine];
+  const modelIdx = await promptChoice(`Select model for ${engine}:`, models, config.model);
+  if (modelIdx < 0) return;
+  const model = models[modelIdx];
+
+  // 3. Save
+  saveConfig({ engine, model });
+  config.engine = engine;
+  config.model = model;
+  console.log(chalk.green(`\n✓ config updated → engine: ${engine}, model: ${model}`));
+}
+
+async function pickSession(projectRoot: string): Promise<string | undefined> {
+  const sessions = listSessions().filter(s => s.projectRoot === projectRoot);
+  
+  if (sessions.length === 0) {
+    console.log(chalk.yellow("No saved sessions for this project."));
+    return undefined;
+  }
+
+  console.log(chalk.bold("\nAvailable sessions:"));
+  sessions.forEach((s, idx) => {
+    console.log(chalk.dim(`  ${idx + 1}. ${s.id.slice(0, 12)}... (${s.startedAt})`));
+  });
+  console.log(chalk.dim(`  0. Start new session`));
+  console.log("");
+
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    rl.question(chalk.cyan("Select session (0-" + sessions.length + "): "), (answer) => {
+      rl.close();
+      const choice = parseInt(answer.trim(), 10);
+      
+      if (isNaN(choice) || choice < 0 || choice > sessions.length) {
+        console.log(chalk.yellow("Invalid choice. Starting new session."));
+        resolve(undefined);
+      } else if (choice === 0) {
+        resolve(undefined);
+      } else {
+        resolve(sessions[choice - 1].id);
+      }
+    });
+  });
+}
+
+export interface CliOptions {
+  projectRoot?: string;
+  resume?: string | boolean;  // Can be session ID, true (for picker), or undefined
+  yolo?: boolean;
+  raw?: boolean;
+  engine?: Engine;
+  addDirs?: string[];
+}
+
+export async function runInteractiveCli(options: CliOptions = {}): Promise<void> {
+  const config = loadConfig();
+  const projectRoot = options.projectRoot
+    ? path.resolve(options.projectRoot)
+    : process.cwd();
+
+  // Override engine if specified
+  if (options.engine !== undefined) {
+    config.engine = options.engine;
+    // Update model to match engine if using default
+    if (!process.env.MIA_CODE_MODEL && !options.resume) {
+      config.model = config.engine === "claude" ? "sonnet" : "gemini-2.5-pro";
+    }
+  }
+
+  // Override yolo mode if specified
+  if (options.yolo !== undefined) {
+    config.yoloMode = options.yolo;
+  }
+
+  // Raw mode - skip unifier, show raw events
+  const rawMode = options.raw ?? false;
+
+  // Mutable list of additional directories (from CLI + runtime /add-dir)
+  const runtimeAddDirs: string[] = [...(options.addDirs || [])];
+
+  // Handle session resume
+  let currentSessionId: string | undefined;
+  
+  if (options.resume === true) {
+    // Interactive session picker
+    currentSessionId = await pickSession(projectRoot);
+  } else if (typeof options.resume === "string") {
+    // Explicit session ID provided
+    currentSessionId = options.resume;
+  } else {
+    // Auto-resume last session for this project
+    currentSessionId = getLastSessionForProject(projectRoot)?.id;
+  }
+
+  // Print header
+  console.log("");
+  console.log(formatHeader(projectRoot, currentSessionId, config.engine));
+  if (!currentSessionId) {
+    console.log(chalk.dim("new session will be created on first prompt"));
+  }
+  if (supportsMultilineInput()) {
+    console.log(chalk.dim("type /help for commands, Ctrl+J for newline, Enter to submit"));
+  } else {
+    console.log(chalk.dim("type /help for commands, ctrl+c to exit"));
+  }
+  console.log("");
+
+  // Restore chat history if resuming a session
+  if (currentSessionId) {
+    const history = loadChatHistory(currentSessionId);
+    if (history.length > 0) {
+      console.log(chalk.dim(`── restoring ${history.length} messages ──`));
+      for (const msg of history) {
+        if (msg.role === "user") {
+          console.log(chalk.cyan.bold("you> ") + chalk.cyan(msg.text.length > 200 ? msg.text.slice(0, 200) + "…" : msg.text));
+        } else {
+          const preview = msg.text.length > 300 ? msg.text.slice(0, 300) + "…" : msg.text;
+          console.log(chalk.green.bold("🧠🌸 ") + chalk.dim(preview));
+        }
+      }
+      console.log(chalk.dim(`── end history ──\n`));
+    }
+  }
+
+  // Process input handles both readline and MultilineInput callbacks
+  const processInput = async (input: string, resetFn: () => void): Promise<boolean> => {
+    const trimmed = input.trim();
+    if (!trimmed) {
+      resetFn();
+      return true;
+    }
+
+    // Handle slash commands
+    if (trimmed.startsWith("/")) {
+      const [cmd] = trimmed.slice(1).split(/\s+/);
+      const lowerCmd = cmd.toLowerCase();
+      
+      switch (lowerCmd) {
+        case "exit":
+        case "quit":
+        case "q":
+          console.log(chalk.dim("👋 bye."));
+          return false;
+
+        case "help":
+        case "h":
+        case "?":
+          console.log(formatHelpText());
+          break;
+
+        case "session":
+          if (currentSessionId) {
+            console.log(chalk.dim(`current session: ${currentSessionId}`));
+            console.log(chalk.dim(`project: ${projectRoot}`));
+            console.log(chalk.dim(`model: ${config.model}`));
+          } else {
+            console.log(chalk.dim("no active session"));
+          }
+          break;
+
+        case "sessions":
+          const sessions = listSessions();
+          if (sessions.length === 0) {
+            console.log(chalk.dim("no saved sessions"));
+          } else {
+            console.log(chalk.dim(`saved sessions (${sessions.length}):`));
+            for (const s of sessions.slice(-10)) {
+              const marker = s.id === currentSessionId ? chalk.green("→ ") : "  ";
+              console.log(chalk.dim(`${marker}${s.id.slice(0, 12)}... | ${s.projectRoot || "unknown"} | ${s.startedAt}`));
+            }
+          }
+          break;
+
+        case "clear":
+          clearSessions();
+          console.log(formatSuccess("sessions cleared"));
+          break;
+
+        case "config":
+          await runInteractiveConfig(config);
+          break;
+
+        case "add-dir": {
+          const dirArg = trimmed.slice(trimmed.indexOf(cmd) + cmd.length).trim();
+          if (!dirArg) {
+            console.log(chalk.dim("usage: /add-dir <directory>"));
+            if (runtimeAddDirs.length > 0) {
+              console.log(chalk.dim(`\ncurrent additional dirs:`));
+              for (const d of runtimeAddDirs) {
+                console.log(chalk.dim(`  📁 ${d}`));
+              }
+            }
+            break;
+          }
+          const resolved = path.resolve(dirArg);
+          try {
+            const stat = fs.statSync(resolved);
+            if (!stat.isDirectory()) {
+              console.log(formatError(`not a directory: ${resolved}`));
+              break;
+            }
+          } catch {
+            console.log(formatError(`directory not found: ${resolved}`));
+            break;
+          }
+          if (!runtimeAddDirs.includes(resolved)) {
+            runtimeAddDirs.push(resolved);
+          }
+          console.log(formatSuccess(`added directory: ${resolved}`));
+          console.log(chalk.dim(`total additional dirs: ${runtimeAddDirs.length}`));
+          break;
+        }
+
+        default:
+          console.log(formatError(`unknown command: /${cmd}`));
+          console.log(formatHelpText());
+      }
+      
+      console.log("");
+      resetFn();
+      return true;
+    }
+
+    // Expand @file references: read file contents and inject into prompt
+    const expandedPrompt = expandFileReferences(trimmed);
+
+    // Send to engine
+    console.log("");
+    console.log(chalk.dim("⏳ thinking..."));
+
+    try {
+      // Only pass sessionId if the session is initialized (acknowledged by engine)
+      const sessionToUse = currentSessionId && isSessionInitialized(currentSessionId)
+        ? currentSessionId
+        : undefined;
+
+      const result = await runGeminiHeadless({
+        prompt: expandedPrompt,
+        config,
+        sessionId: sessionToUse,
+        projectRoot,
+        additionalDirs: runtimeAddDirs.length > 0 ? runtimeAddDirs : undefined
+      });
+
+      // Clear the "thinking" line
+      process.stdout.write("\x1B[1A\x1B[2K");
+
+      if (result.sessionId) {
+        if (result.sessionId !== currentSessionId) {
+          currentSessionId = result.sessionId;
+          const meta: MiaCodeSessionMeta = {
+            id: currentSessionId,
+            startedAt: new Date().toISOString(),
+            model: config.model,
+            projectRoot,
+            initialized: true
+          };
+          rememberSession(meta);
+          console.log(chalk.dim(`session: ${currentSessionId.slice(0, 12)}...`));
+        } else if (!isSessionInitialized(currentSessionId)) {
+          // Mark existing session as initialized now that engine acknowledged it
+          markSessionInitialized(currentSessionId);
+        }
+      }
+
+      // Extract assistant text for history
+      let assistantText = "";
+
+      // Raw mode: show original events
+      if (rawMode) {
+        const rendered = renderEventsToText(result.events);
+        if (rendered) {
+          console.log(rendered);
+          assistantText = rendered;
+        }
+      } else {
+        // Unifier mode: run ceremonial interpretation
+        console.log(chalk.dim("⏳ interpreting..."));
+        try {
+          const ceremonialOutput = await runUnifierSession(result.events, trimmed, config);
+          process.stdout.write("\x1B[1A\x1B[2K");
+          if (ceremonialOutput) {
+            console.log(ceremonialOutput);
+            assistantText = ceremonialOutput;
+          }
+        } catch (unifierErr: unknown) {
+          // Fallback to raw output if unifier fails
+          process.stdout.write("\x1B[1A\x1B[2K");
+          console.log(chalk.yellow("⚠ unifier failed, showing raw output:"));
+          const rendered = renderEventsToText(result.events);
+          if (rendered) {
+            console.log(rendered);
+            assistantText = rendered;
+          }
+        }
+      }
+
+      // Save chat history
+      if (currentSessionId) {
+        const ts = new Date().toISOString();
+        saveChatMessage(currentSessionId, { role: "user", text: trimmed, timestamp: ts });
+        if (assistantText) {
+          saveChatMessage(currentSessionId, { role: "assistant", text: assistantText, timestamp: ts });
+        }
+      }
+
+      console.log("");
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : String(err);
+      
+      // Handle invalid session error gracefully
+      if (message.includes("Invalid session identifier") && currentSessionId) {
+        console.log(chalk.yellow("⚠ Session expired, starting fresh..."));
+        // Mark session as not initialized and retry without session
+        const meta: MiaCodeSessionMeta = {
+          id: currentSessionId,
+          startedAt: new Date().toISOString(),
+          model: config.model,
+          projectRoot,
+          initialized: false
+        };
+        rememberSession(meta);
+        
+        try {
+          const result = await runGeminiHeadless({
+            prompt: trimmed,
+            config,
+            sessionId: undefined,  // Don't resume
+            projectRoot,
+            additionalDirs: runtimeAddDirs.length > 0 ? runtimeAddDirs : undefined
+          });
+          
+          process.stdout.write("\x1B[1A\x1B[2K");
+          
+          if (result.sessionId) {
+            currentSessionId = result.sessionId;
+            const newMeta: MiaCodeSessionMeta = {
+              id: currentSessionId,
+              startedAt: new Date().toISOString(),
+              model: config.model,
+              projectRoot,
+              initialized: true
+            };
+            rememberSession(newMeta);
+            console.log(chalk.dim(`new session: ${currentSessionId.slice(0, 12)}...`));
+          }
+          
+          const rendered = renderEventsToText(result.events);
+          if (rendered) {
+            console.log(rendered);
+          }
+        } catch (retryErr: unknown) {
+          const retryMessage = retryErr instanceof Error ? retryErr.message : String(retryErr);
+          console.log(formatError(`engine error: ${retryMessage}`));
+        }
+      } else {
+        console.log(formatError(`engine error: ${message}`));
+      }
+      console.log("");
+    }
+
+    resetFn();
+    return true;
+  };
+
+  // Tab completion handler for /commands and @file paths
+  const handleTabComplete = (input: string): TabCompletion | null => {
+    // --- @file/path completion ---
+    // Find the last @ token before or at cursor position
+    const atIdx = input.lastIndexOf("@");
+    if (atIdx >= 0) {
+      const afterAt = input.slice(atIdx + 1);
+      // Only complete if there's no space after @ (still typing the path)
+      if (!afterAt.includes(" ")) {
+        return completeFilePath(input, atIdx, afterAt);
+      }
+    }
+
+    // --- /command completion (only when input starts with / with no spaces) ---
+    if (input.startsWith("/") && !input.includes(" ")) {
+      const partial = input.slice(1);
+      const matches = findMatchingCommands(partial);
+      if (matches.length === 0) return null;
+
+      // Build rich labels: "/command  — description"
+      const labels = matches.map(name => {
+        const cmd = getCommand(name);
+        const desc = cmd ? cmd.description : "";
+        return desc ? `/${name}  — ${desc}` : `/${name}`;
+      });
+
+      return {
+        matches,
+        labels,
+        prefix: partial,
+        tokenStart: 0,
+        triggerChar: "/",
+      };
+    }
+
+    // --- /add-dir <path> directory completion ---
+    const addDirMatch = input.match(/^\/add-dir\s+(.*)/);
+    if (addDirMatch) {
+      const partial = addDirMatch[1];
+      return completeDirPath(input, input.indexOf(addDirMatch[1]), partial);
+    }
+
+    return null;
+  };
+
+  function fileIcon(name: string): string {
+    const ext = name.split(".").pop()?.toLowerCase() || "";
+    const icons: Record<string, string> = {
+      ts: "🔷", tsx: "🔷", js: "🟡", jsx: "🟡", json: "📋",
+      md: "📝", txt: "📄", sh: "⚙️", yaml: "📋", yml: "📋",
+      py: "🐍", rs: "🦀", go: "🔵", toml: "📋", lock: "🔒",
+      css: "🎨", html: "🌐", svg: "🖼️", png: "🖼️", jpg: "🖼️",
+    };
+    return icons[ext] || "📄";
+  }
+
+  /**
+   * Complete file/directory paths after @
+   */
+  function completeFilePath(_input: string, atIdx: number, partial: string): TabCompletion | null {
+    const cwd = process.cwd();
+
+    // Split into directory part and name prefix
+    const lastSlash = partial.lastIndexOf("/");
+    let dirPath: string;
+    let namePrefix: string;
+
+    if (lastSlash >= 0) {
+      dirPath = partial.slice(0, lastSlash + 1);
+      namePrefix = partial.slice(lastSlash + 1);
+    } else {
+      dirPath = "";
+      namePrefix = partial;
+    }
+
+    const resolvedDir = path.resolve(cwd, dirPath || ".");
+
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(resolvedDir, { withFileTypes: true });
+    } catch {
+      return null;
+    }
+
+    // Filter: skip hidden files, match prefix
+    const lowerPrefix = namePrefix.toLowerCase();
+    const filtered = entries
+      .filter(e => !e.name.startsWith(".") && e.name.toLowerCase().startsWith(lowerPrefix))
+      .sort((a, b) => {
+        if (a.isDirectory() && !b.isDirectory()) return -1;
+        if (!a.isDirectory() && b.isDirectory()) return 1;
+        return a.name.localeCompare(b.name);
+      })
+      .slice(0, 20);
+
+    const matches = filtered.map(e => dirPath + e.name + (e.isDirectory() ? "/" : ""));
+
+    // Rich labels with icons
+    const labels = filtered.map(e => {
+      const icon = e.isDirectory() ? "📁" : fileIcon(e.name);
+      return `${icon} @${dirPath}${e.name}${e.isDirectory() ? "/" : ""}`;
+    });
+
+    if (matches.length === 0) return null;
+
+    return {
+      matches,
+      labels,
+      prefix: partial,
+      tokenStart: atIdx,
+      triggerChar: "@",
+      isFilePath: true,
+    };
+  }
+
+  /**
+   * Complete directory paths for /add-dir command
+   */
+  function completeDirPath(_input: string, tokenStart: number, partial: string): TabCompletion | null {
+    const cwd = process.cwd();
+    const lastSlash = partial.lastIndexOf("/");
+    let dirPath: string;
+    let namePrefix: string;
+
+    if (lastSlash >= 0) {
+      dirPath = partial.slice(0, lastSlash + 1);
+      namePrefix = partial.slice(lastSlash + 1);
+    } else {
+      dirPath = "";
+      namePrefix = partial;
+    }
+
+    const resolvedDir = path.resolve(cwd, dirPath || ".");
+
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(resolvedDir, { withFileTypes: true });
+    } catch {
+      return null;
+    }
+
+    const lowerPrefix = namePrefix.toLowerCase();
+    const filtered = entries
+      .filter(e => e.isDirectory() && !e.name.startsWith(".") && e.name.toLowerCase().startsWith(lowerPrefix))
+      .sort((a, b) => a.name.localeCompare(b.name))
+      .slice(0, 20);
+
+    const matches = filtered.map(e => dirPath + e.name + "/");
+    const labels = filtered.map(e => `📁 ${dirPath}${e.name}/`);
+
+    if (matches.length === 0) return null;
+
+    return {
+      matches,
+      labels,
+      prefix: partial,
+      tokenStart,
+      triggerChar: "",
+      isFilePath: true,
+    };
+  }
+
+  /**
+   * Expand @file references in user input.
+   * Replaces @path/to/file with the file contents block.
+   */
+  function expandFileReferences(input: string): string {
+    // Match @path (non-whitespace after @), but not email-like patterns
+    const refPattern = /@((?:\.{0,2}\/)?[\w./_-]+[\w._-])/g;
+    let expanded = input;
+    const seen = new Set<string>();
+
+    let match;
+    while ((match = refPattern.exec(input)) !== null) {
+      const refPath = match[1];
+      if (seen.has(refPath)) continue;
+      seen.add(refPath);
+
+      const resolved = path.resolve(process.cwd(), refPath);
+      try {
+        const stat = fs.statSync(resolved);
+        if (stat.isFile()) {
+          const content = fs.readFileSync(resolved, "utf-8");
+          const maxLen = 50_000; // safety cap
+          const truncated = content.length > maxLen
+            ? content.slice(0, maxLen) + "\n... [truncated]"
+            : content;
+          const block = `\n\n--- @${refPath} ---\n${truncated}\n--- end @${refPath} ---\n`;
+          expanded = expanded.replace(`@${refPath}`, refPath) + block;
+          console.log(chalk.dim(`  📎 attached ${refPath} (${stat.size} bytes)`));
+        } else if (stat.isDirectory()) {
+          // List directory contents
+          const entries = fs.readdirSync(resolved)
+            .filter(e => !e.startsWith("."))
+            .slice(0, 50);
+          const listing = entries.join("\n");
+          const block = `\n\n--- @${refPath} (directory listing) ---\n${listing}\n--- end @${refPath} ---\n`;
+          expanded = expanded.replace(`@${refPath}`, refPath) + block;
+          console.log(chalk.dim(`  📁 attached ${refPath}/ listing (${entries.length} entries)`));
+        }
+      } catch {
+        // File doesn't exist — leave as-is, might be intentional @mention
+      }
+    }
+
+    return expanded;
+  }
+
+  // Use MultilineInput if available, otherwise fall back to readline
+  if (supportsMultilineInput()) {
+    const multilineInput = new MultilineInput({
+      prompt: chalk.yellow("you> "),
+      continuationPrompt: chalk.dim("... "),
+      onSubmit: async (input) => {
+        const shouldContinue = await processInput(input, () => multilineInput.reset());
+        if (!shouldContinue) {
+          multilineInput.stop();
+          process.exit(0);
+        }
+      },
+      onClose: () => {
+        console.log(chalk.dim("\n👋 bye."));
+        process.exit(0);
+      },
+      onTabComplete: handleTabComplete
+    });
+    
+    multilineInput.start();
+  } else {
+    // Fallback to readline for non-TTY environments
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: chalk.yellow("you> "),
+      terminal: true
+    });
+
+    rl.on("line", async (line) => {
+      const shouldContinue = await processInput(line, () => rl.prompt());
+      if (!shouldContinue) {
+        rl.close();
+      }
+    });
+
+    rl.on("close", () => {
+      console.log(chalk.dim("\n👋 bye."));
+      process.exit(0);
+    });
+
+    rl.prompt();
+  }
+}
+
+export async function runSinglePrompt(prompt: string, options: CliOptions = {}): Promise<void> {
+  const config = loadConfig();
+  const projectRoot = options.projectRoot
+    ? path.resolve(options.projectRoot)
+    : process.cwd();
+
+  if (options.engine !== undefined) {
+    config.engine = options.engine;
+    // Update model to match engine if using default
+    if (!process.env.MIA_CODE_MODEL) {
+      config.model = config.engine === "claude" ? "sonnet" : "gemini-2.5-pro";
+    }
+  }
+
+  if (options.yolo !== undefined) {
+    config.yoloMode = options.yolo;
+  }
+
+  const rawMode = options.raw ?? false;
+  
+  // Handle session resume (single prompt doesn't support interactive picker)
+  let sessionId: string | undefined;
+  if (typeof options.resume === "string") {
+    sessionId = options.resume;
+  } else if (options.resume === true) {
+    // Don't auto-resume for single prompts
+    sessionId = undefined;
+  } else {
+    // options.resume is undefined - don't auto-resume
+    sessionId = undefined;
+  }
+
+  try {
+    const result = await runGeminiHeadless({
+      prompt,
+      config,
+      sessionId,
+      projectRoot,
+      additionalDirs: options.addDirs
+    });
+
+    if (result.sessionId) {
+      const meta: MiaCodeSessionMeta = {
+        id: result.sessionId,
+        startedAt: new Date().toISOString(),
+        model: config.model,
+        projectRoot
+      };
+      rememberSession(meta);
+    }
+
+    // Raw mode: show original events
+    if (rawMode) {
+      const rendered = renderEventsToText(result.events);
+      console.log(rendered);
+    } else {
+      // Unifier mode: run ceremonial interpretation
+      try {
+        const ceremonialOutput = await runUnifierSession(result.events, prompt, config);
+        console.log(ceremonialOutput);
+      } catch (unifierErr: unknown) {
+        // Fallback to raw output if unifier fails
+        console.error(chalk.yellow("⚠ unifier failed, showing raw output:"));
+        const rendered = renderEventsToText(result.events);
+        console.log(rendered);
+      }
+    }
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(formatError(message));
+    process.exit(1);
+  }
+}