whale-code 6.4.0 → 6.5.1

package/dist/cli/services/telemetry.js

@@ -1,12 +1,13 @@
 /**
- * CLI Telemetry — fire-and-forget span logging to audit_logs
+ * CLI Telemetry — spans are buffered and flushed to the Fly.io server,
+ * which queues them into ClickHouse ai_spans.
  *
  * Session-scoped conversationId + auto-incrementing turnNumber.
- * Uses same column schema as executor.ts telemetry (trace_id, span_id, etc).
+ * Uses same column schema as server-side telemetry (trace_id, span_id, etc).
  * Never blocks or crashes the chat.
  */
-import { createClient } from "@supabase/supabase-js";
 import { createRequire } from "module";
+import os from "node:os";
 import { resolveConfig, loadConfig } from "./config-store.js";
 import { getValidToken, createAuthenticatedClient } from "./auth-service.js";
 import { captureError } from "./error-logger.js";
@@ -55,39 +56,6 @@ export function generateSpanId() {
     return Array.from(bytes).map(b => b.toString(16).padStart(2, "0")).join("");
 }
 // ============================================================================
-// SUPABASE CLIENT (lazy init)
-// ============================================================================
-async function getClient() {
-    if (supabaseClient)
-        return supabaseClient;
-    const config = resolveConfig();
-    // Prefer service role key
-    if (config.supabaseUrl && config.supabaseKey) {
-        supabaseClient = createClient(config.supabaseUrl, config.supabaseKey, {
-            auth: { persistSession: false, autoRefreshToken: false },
-        });
-        if (process.env.DEBUG_TELEMETRY) {
-            process.stderr.write(`[telemetry] using service role key\n`);
-        }
-        return supabaseClient;
-    }
-    // Fallback: user JWT
-    const token = await getValidToken();
-    if (token) {
-        supabaseClient = createAuthenticatedClient(token);
-        if (process.env.DEBUG_TELEMETRY) {
-            process.stderr.write(`[telemetry] using user JWT token\n`);
-        }
-        return supabaseClient;
-    }
-    if (process.env.DEBUG_TELEMETRY) {
-        process.stderr.write(`[telemetry] NO CLIENT - no service key and no valid token\n`);
-        process.stderr.write(`[telemetry]   config.supabaseUrl: ${config.supabaseUrl}\n`);
-        process.stderr.write(`[telemetry]   config.supabaseKey: ${config.supabaseKey ? 'set' : 'not set'}\n`);
-    }
-    return null;
-}
-// ============================================================================
 // TURN CONTEXT
 // ============================================================================
 export function nextTurn() {
@@ -113,6 +81,93 @@ export function createTurnContext(overrides) {
 export function getTurnNumber() {
     return turnNumber;
 }
+// ============================================================================
+// SPAN BUFFER — batches spans for bulk POST to the Fly.io server
+// Same pattern as server's clickhouse-buffer.ts but over HTTP.
+// ============================================================================
+const FLUSH_INTERVAL = 2000; // 2s (slower than server — HTTP has more overhead)
+const FLUSH_MAX = 50; // max spans before force flush
+const spanBuffer = [];
+let flushTimer = null;
+let conversationRegistered = false;
+function queueCliSpan(span) {
+    spanBuffer.push(span);
+    if (spanBuffer.length >= FLUSH_MAX) {
+        flushCliSpans();
+    }
+    else if (!flushTimer) {
+        flushTimer = setTimeout(() => {
+            flushTimer = null;
+            flushCliSpans();
+        }, FLUSH_INTERVAL);
+    }
+}
+/**
+ * Flush all buffered spans to the Fly.io server.
+ * Call this on session end or at shutdown.
+ */
+export function flushCliSpans() {
+    if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+    }
+    if (spanBuffer.length === 0)
+        return;
+    const batch = spanBuffer.splice(0, spanBuffer.length);
+    // Fire-and-forget — never block the chat
+    _sendSpans(batch).catch((err) => {
+        if (process.env.DEBUG_TELEMETRY) {
+            process.stderr.write(`[telemetry] flush error: ${err.message}\n`);
+        }
+    });
+}
+async function _sendSpans(spans) {
+    const config = resolveConfig();
+    if (!config.serverUrl)
+        return;
+    let authToken = config.supabaseKey;
+    if (!authToken) {
+        authToken = await getValidToken() || "";
+    }
+    if (!authToken)
+        return;
+    const fileConfig = loadConfig();
+    const body = {
+        mode: "telemetry_ingest",
+        spans,
+        conversation_id: conversationId,
+        store_id: config.storeId || undefined,
+        userId: fileConfig.user_id || undefined,
+        userEmail: fileConfig.email || undefined,
+        source: "whale_cli",
+    };
+    // Include conversation metadata on first flush so server creates the row
+    if (!conversationRegistered) {
+        conversationRegistered = true;
+        body.conversation_title = `CLI Session ${new Date().toISOString().split("T")[0]}`;
+        body.hostname = os.hostname();
+        body.version = PKG_VERSION;
+    }
+    try {
+        const response = await fetch(config.serverUrl, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${authToken}`,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok && process.env.DEBUG_TELEMETRY) {
+            const text = await response.text().catch(() => "");
+            process.stderr.write(`[telemetry] ingest failed (${response.status}): ${text.slice(0, 200)}\n`);
+        }
+    }
+    catch (err) {
+        if (process.env.DEBUG_TELEMETRY) {
+            process.stderr.write(`[telemetry] ingest error: ${err.message}\n`);
+        }
+    }
+}
 export function logSpan(opts) {
     // Fire-and-forget — don't await, log errors in debug mode
     _logSpan(opts).catch((err) => {
@@ -125,74 +180,43 @@ async function _logSpan(opts) {
     if (process.env.DEBUG_TELEMETRY) {
         process.stderr.write(`[telemetry] _logSpan called for ${opts.action}\n`);
     }
-    const client = await getClient();
-    if (!client) {
-        if (process.env.DEBUG_TELEMETRY) {
-            process.stderr.write(`[telemetry] no client for ${opts.action}\n`);
-        }
-        return;
-    }
-    const now = new Date();
-    const startTime = new Date(now.getTime() - opts.durationMs);
     const ctx = opts.context;
-    // Debug: log team-related spans (only when DEBUG_TELEMETRY is set)
-    if (process.env.DEBUG_TELEMETRY && (opts.action.startsWith("team.") || opts.details?.parent_conversation_id)) {
-        process.stderr.write(`[telemetry:team] action=${opts.action}\n`);
-        process.stderr.write(`[telemetry:team]   conversation_id=${ctx.conversationId}\n`);
-        process.stderr.write(`[telemetry:team]   parent_conversation_id=${opts.details?.parent_conversation_id}\n`);
-    }
-    const row = {
+    const now = new Date();
+    const startedAt = new Date(now.getTime() - opts.durationMs).toISOString();
+    const endedAt = now.toISOString();
+    // Build span in same shape as server's auditRowToSpan input
+    const span = {
         action: opts.action,
         severity: opts.severity || (opts.error ? "error" : "info"),
         store_id: opts.storeId || resolveConfig().storeId || null,
+        source: ctx.source || "whale_cli",
+        service_name: ctx.serviceName || "whale-code",
+        span_kind: "INTERNAL",
+        status_code: opts.error ? "ERROR" : "OK",
+        trace_id: ctx.traceId || null,
+        span_id: ctx.spanId || generateSpanId(),
+        conversation_id: ctx.conversationId || conversationId,
         user_id: ctx.userId || null,
         user_email: ctx.userEmail || null,
-        resource_type: "cli_span",
-        resource_id: opts.action,
-        request_id: ctx.traceId,
-        parent_id: ctx.parentId || null,
+        start_time: startedAt,
+        end_time: endedAt,
         duration_ms: opts.durationMs,
         error_message: opts.error || null,
-        // OTEL columns
-        trace_id: ctx.traceId,
-        span_id: ctx.spanId,
-        trace_flags: ctx.traceFlags ?? 1,
-        span_kind: "INTERNAL",
-        service_name: ctx.serviceName || "whale-code",
-        service_version: ctx.serviceVersion || PKG_VERSION,
-        status_code: opts.error ? "ERROR" : "OK",
-        start_time: startTime.toISOString(),
-        end_time: now.toISOString(),
-        // AI telemetry — use ?? to handle 0 correctly
-        model: ctx.model || null,
-        input_tokens: ctx.inputTokens ?? null,
-        output_tokens: ctx.outputTokens ?? null,
-        total_cost: ctx.totalCost ?? null,
-        turn_number: ctx.turnNumber ?? null,
-        conversation_id: ctx.conversationId || null,
         details: {
-            source: ctx.source || "whale_cli",
-            conversation_id: ctx.conversationId || conversationId,
-            turn_number: ctx.turnNumber ?? turnNumber,
-            parent_span_id: ctx.parentSpanId || null,
             ...opts.details,
+            input_tokens: ctx.inputTokens,
+            output_tokens: ctx.outputTokens,
+            total_cost: ctx.totalCost,
+            model: ctx.model,
+            turn_number: ctx.turnNumber,
+            agent_id: ctx.agentId,
+            agent_name: ctx.agentName,
+            tool_type: ctx.toolType,
         },
     };
-    // Allow caller to control row ID so children can reference it via parent_id
-    if (ctx.rowId)
-        row.id = ctx.rowId;
-    const { error } = await client.from("audit_logs").insert(row);
-    if (error) {
-        if (process.env.DEBUG_TELEMETRY) {
-            process.stderr.write(`[telemetry db error] ${opts.action}: ${error.message}\n`);
-            process.stderr.write(`[telemetry db error]   code: ${error.code}\n`);
-            process.stderr.write(`[telemetry db error]   hint: ${error.hint}\n`);
-        }
-    }
-    else if (opts.details?.is_teammate && process.env.DEBUG_TELEMETRY) {
-        process.stderr.write(`[telemetry] teammate span logged: ${opts.action}\n`);
-    }
-    // Bridge errors to the error logging system
+    // Queue for batch send to server → ClickHouse
+    queueCliSpan(span);
+    // Also bridge errors to the error logging system (Postgres)
     if (opts.error) {
         captureError({
             errorType: opts.action,

package/dist/cli/services/tools/agent-tools.d.ts

@@ -12,3 +12,4 @@ export declare function taskTool(input: Record<string, unknown>): Promise<ToolRe
 export declare function taskOutput(input: Record<string, unknown>): Promise<ToolResult>;
 export declare function taskStop(input: Record<string, unknown>): ToolResult;
 export declare function teamCreateTool(input: Record<string, unknown>): Promise<ToolResult>;
+export declare function teamAutoTool(input: Record<string, unknown>): Promise<ToolResult>;

package/dist/cli/services/tools/agent-tools.js

@@ -8,7 +8,7 @@ import { dirname, join } from "path";
 import { homedir } from "os";
 import { runSubagent, runSubagentBackground, } from "../subagent.js";
 import { createTurnContext, getTurnNumber, } from "../telemetry.js";
-import { runAgentTeam, } from "../team-lead.js";
+import { runAgentTeam, runAutoTeam, } from "../team-lead.js";
 import { readAgentOutput, stopBackgroundAgent } from "../background-processes.js";
 import { readProcessOutput, killProcess } from "../background-processes.js";
 import { getGlobalEmitter } from "../agent-events.js";
@@ -244,13 +244,13 @@ export async function taskOutput(input) {
                 await new Promise(r => setTimeout(r, 1000));
                 const updated = readAgentOutput(taskId);
                 if (updated && updated.status !== "running") {
-                    return { success: true, output: `[${updated.status}]\n${updated.output}` };
+                    return { success: true, output: updated.output };
                 }
             }
             const final = readAgentOutput(taskId);
-            return { success: true, output: `[${final?.status || "running"} — timed out waiting]\n${final?.output || ""}` };
+            return { success: true, output: `${final?.output || ""}\n(timed out waiting — agent may still be running)`.trim() };
         }
-        return { success: true, output: `[${agentResult.status}]\n${agentResult.output}` };
+        return { success: true, output: agentResult.output };
     }
     // Fall back to shell process output (bash_output behavior)
     const result = readProcessOutput(taskId, {});
@@ -345,3 +345,49 @@ export async function teamCreateTool(input) {
         };
     }
 }
+// ============================================================================
+// TEAM AUTO — auto-decompose + parallel execution + review
+// ============================================================================
+export async function teamAutoTool(input) {
+    const task = input.task;
+    if (!task)
+        return { success: false, output: "task is required" };
+    const maxTeammates = input.max_teammates || 4;
+    const model = input.model || "sonnet";
+    const workingDirectory = input.working_directory || process.cwd();
+    const review = input.review !== false;
+    try {
+        const result = await runAutoTeam(task, {
+            maxTeammates,
+            model,
+            workingDirectory,
+            review,
+        });
+        const lines = [
+            `## Auto Team`,
+            `Status: ${result.success ? "SUCCESS" : "PARTIAL"}`,
+            `Duration: ${(result.durationMs / 1000).toFixed(1)}s`,
+            `Tokens: ${result.tokensUsed.input} in, ${result.tokensUsed.output} out`,
+        ];
+        if (result.warnings?.length) {
+            lines.push("", "### Warnings");
+            for (const w of result.warnings)
+                lines.push(`- ${w}`);
+        }
+        lines.push("", "### Task Results");
+        for (const t of result.taskResults) {
+            const icon = t.status === "completed" ? "[done]" : "[fail]";
+            lines.push(`${icon} ${t.description.slice(0, 120)}`);
+            if (t.result) {
+                lines.push(`    ${t.result.slice(0, 200)}${t.result.length > 200 ? "..." : ""}`);
+            }
+        }
+        if (result.review) {
+            lines.push("", "### Review", result.review);
+        }
+        return { success: result.success, output: lines.join("\n") };
+    }
+    catch (err) {
+        return { success: false, output: `Auto team failed: ${err.message || err}` };
+    }
+}

package/dist/cli/services/tools/file-ops.d.ts

@@ -5,6 +5,8 @@
  */
 import { ToolResult } from "../../../shared/types.js";
 export declare function resolvePath(p: string): string;
+/** Clear the session-level read cache. Call on session reset. */
+export declare function clearReadCache(): void;
 export declare function readFile(input: Record<string, unknown>): Promise<ToolResult>;
 export declare function writeFile(input: Record<string, unknown>): ToolResult;
 export declare function editFile(input: Record<string, unknown>): ToolResult;

package/dist/cli/services/tools/file-ops.js

@@ -15,6 +15,36 @@ export function resolvePath(p) {
         return join(homedir(), p.slice(2));
     return p;
 }
+const READ_CACHE_MAX = 100;
+const MAX_ENTRY_SIZE = 100_000; // 100KB — skip caching larger files
+const MAX_CACHE_BYTES = 10_000_000; // 10MB total budget
+let totalCacheBytes = 0;
+const readCache = new Map();
+/** Clear the session-level read cache. Call on session reset. */
+export function clearReadCache() {
+    readCache.clear();
+    totalCacheBytes = 0;
+}
+/** Invalidate a specific path from the cache (call on write/edit). */
+function invalidateCache(path) {
+    const existing = readCache.get(path);
+    if (existing) {
+        totalCacheBytes -= existing.content.length;
+        readCache.delete(path);
+    }
+}
+/** LRU eviction: remove oldest entries when cache exceeds count or byte budget. */
+function evictIfNeeded() {
+    while (readCache.size >= READ_CACHE_MAX || totalCacheBytes > MAX_CACHE_BYTES) {
+        const oldest = readCache.keys().next().value;
+        if (!oldest)
+            break;
+        const entry = readCache.get(oldest);
+        if (entry)
+            totalCacheBytes -= entry.content.length;
+        readCache.delete(oldest);
+    }
+}
 // ============================================================================
 // READ FILE
 // ============================================================================
@@ -30,6 +60,28 @@ const AUDIO_MEDIA_TYPES = {
     m4a: "audio/mp4",
 };
 const AUDIO_MAX_SIZE = 25 * 1024 * 1024; // 25MB
+function formatTextFileResult(lines, input, content) {
+    const offset = input.offset || 1; // 1-based
+    const limit = input.limit;
+    if (offset > 1 || limit) {
+        const startIdx = Math.max(0, offset - 1);
+        const endIdx = limit ? startIdx + limit : lines.length;
+        const slice = lines.slice(startIdx, endIdx);
+        const numbered = slice.map((line, i) => {
+            const lineNum = startIdx + i + 1;
+            return `${String(lineNum).padStart(6)}  ${line}`;
+        });
+        let output = numbered.join("\n");
+        if (endIdx < lines.length) {
+            output += `\n\n... (showing lines ${startIdx + 1}-${Math.min(endIdx, lines.length)} of ${lines.length})`;
+        }
+        return { success: true, output };
+    }
+    if (content.length > 500_000) {
+        return { success: true, output: content.slice(0, 500_000) + `\n\n... (safety truncated, ${content.length.toLocaleString()} total chars)` };
+    }
+    return { success: true, output: content };
+}
 export async function readFile(input) {
     const path = resolvePath(input.path);
     if (!existsSync(path))
@@ -90,29 +142,39 @@ export async function readFile(input) {
             return { success: false, output: `Failed to parse PDF: ${err}` };
         }
     }
-    // Text files — existing behavior
+    // Text files — check cache first via mtime comparison
+    try {
+        const stat = statSync(path);
+        const cached = readCache.get(path);
+        if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+            // Cache hit — use previously read content
+            debugLog("file-ops", `readFile cache hit: ${path}`);
+            const content = cached.content;
+            const lines = content.split("\n");
+            // Move to end of map for LRU freshness
+            readCache.delete(path);
+            readCache.set(path, cached);
+            return formatTextFileResult(lines, input, content);
+        }
+    }
+    catch {
+        // stat failed — fall through to normal read
+    }
     const content = readFileSync(path, "utf-8");
     const lines = content.split("\n");
-    const offset = input.offset || 1; // 1-based
-    const limit = input.limit;
-    if (offset > 1 || limit) {
-        const startIdx = Math.max(0, offset - 1);
-        const endIdx = limit ? startIdx + limit : lines.length;
-        const slice = lines.slice(startIdx, endIdx);
-        const numbered = slice.map((line, i) => {
-            const lineNum = startIdx + i + 1;
-            return `${String(lineNum).padStart(6)}  ${line}`;
-        });
-        let output = numbered.join("\n");
-        if (endIdx < lines.length) {
-            output += `\n\n... (showing lines ${startIdx + 1}-${Math.min(endIdx, lines.length)} of ${lines.length})`;
+    // Cache the read — skip caching files larger than MAX_ENTRY_SIZE
+    if (content.length <= MAX_ENTRY_SIZE) {
+        try {
+            const stat = statSync(path);
+            evictIfNeeded();
+            readCache.set(path, { content, mtimeMs: stat.mtimeMs, size: stat.size });
+            totalCacheBytes += content.length;
+        }
+        catch {
+            // stat failed — skip caching
         }
-        return { success: true, output };
-    }
-    if (content.length > 500_000) {
-        return { success: true, output: content.slice(0, 500_000) + `\n\n... (safety truncated, ${content.length.toLocaleString()} total chars)` };
     }
-    return { success: true, output: content };
+    return formatTextFileResult(lines, input, content);
 }
 function parsePageRange(range, totalPages) {
     const parts = range.split("-");
@@ -188,6 +250,7 @@ function computeWriteDiff(oldLines, newLines) {
 export function writeFile(input) {
     const path = resolvePath(input.path);
     const content = input.content;
+    invalidateCache(path); // Invalidate read cache before write
     const existed = existsSync(path);
     const oldContent = existed ? readFileSync(path, "utf-8") : null;
     backupFile(path); // Save backup before modification
@@ -236,6 +299,7 @@ export function editFile(input) {
     const replaceAll = input.replace_all ?? false;
     if (!existsSync(path))
         return { success: false, output: `File not found: ${path}` };
+    invalidateCache(path); // Invalidate read cache before edit
     backupFile(path); // Save backup before modification
     let content = readFileSync(path, "utf-8");
     if (!content.includes(oldString))
@@ -308,6 +372,7 @@ export function multiEdit(input) {
         return { success: false, output: `File not found: ${path}` };
     if (!Array.isArray(edits) || edits.length === 0)
         return { success: false, output: "edits array is required and must not be empty" };
+    invalidateCache(path); // Invalidate read cache before edit
     backupFile(path); // Save backup before modification
     let content = readFileSync(path, "utf-8");
     const diffParts = [];
@@ -371,6 +436,7 @@ export function notebookEdit(input) {
     const cellId = input.cell_id;
     if (!existsSync(path))
         return { success: false, output: `Notebook not found: ${path}` };
+    invalidateCache(path); // Invalidate read cache before notebook edit
     let notebook;
     try {
         notebook = JSON.parse(readFileSync(path, "utf-8"));

package/dist/cli/services/tools/shell-exec.js

@@ -22,24 +22,34 @@ export async function runCommand(input) {
     const background = input.run_in_background;
     const description = input.description;
     debugLog("tools", `run_command: ${description || command.slice(0, 80)}`, { cwd, timeout, background });
-    // UX guardrail only — the sandbox (macOS) is the real security boundary.
-    // This catches obvious destructive commands before they reach the sandbox.
+    // ── Safety guardrail ──
+    // Minimal filter for catastrophic commands that bypass the macOS sandbox.
+    // The sandbox (sandbox-exec) is the real security boundary — it restricts
+    // file writes to cwd + /tmp + ~/.swagmanager only.
+    //
+    // Philosophy: block ONLY what the sandbox cannot prevent.
+    //   - Hardware/filesystem damage (mkfs, dd to block devices)
+    //   - Process-level DoS (fork bomb)
+    //   - rm on literal root / or home ~ (sanity check)
+    //
+    // Everything else is allowed — chmod, chown, curl|bash, npm, pip, etc.
+    // are either harmless within the sandbox or need sudo to do real damage.
     if (command.length > 10000) {
         return { success: false, output: "Command too long (max 10000 chars)" };
     }
     const DANGEROUS_PATTERNS = [
-        /\brm\s+(-[a-z]*f[a-z]*\s+)?(-[a-z]*r[a-z]*\s+)?(\/|~)/i,
-        /\brm\s+(-[a-z]*r[a-z]*\s+)?(-[a-z]*f[a-z]*\s+)?(\/|~)/i,
+        // rm on literal root (/) or (/*) — NOT subdirectories like /tmp, /Users/...
+        /\brm\b[^|;]*\s\/(\*)?(\s*$|\s*[;|&])/i,
+        // rm on literal home (~) or (~/) or (~/*) — NOT subdirs like ~/project
+        /\brm\b[^|;]*\s~\/?(\*)?(\s*$|\s*[;|&])/i,
+        // Format filesystem — irreversible hardware damage
         /\bmkfs\b/i,
-        /\bdd\s+.*\bif=/i,
-        />\s*\/dev\/sd/,
+        // dd writing to raw block devices — irreversible hardware damage
+        /\bdd\b.*\bof=\s*\/dev\/(sd|hd|nvme|disk|rdisk|vd)/i,
+        // Redirect to raw block devices
+        />\s*\/dev\/(sd|hd|nvme|disk|rdisk|vd)/,
+        // Fork bomb — process-level DoS, sandbox cannot prevent
         /:\(\)\s*\{.*\|.*&\s*\}\s*;/,
-        /\bchmod\s+(-[a-z]*R[a-z]*\s+)?777\s+\//i,
-        /\bchown\s+(-[a-z]*R[a-z]*\s+).*\//i,
-        /\bcurl\b.*\|\s*(ba)?sh\b/i,
-        /\bwget\b.*\|\s*(ba)?sh\b/i,
-        /\b(python|perl|ruby|node)\s+-e\s+.*\b(system|exec|spawn)\b/i,
-        /base64\s+(-d|--decode)\s*\|\s*(ba)?sh/i,
     ];
     const command_lower = command.toLowerCase().replace(/\s+/g, " ");
     if (DANGEROUS_PATTERNS.some((p) => p.test(command_lower))) {

package/dist/cli/shared/Theme.d.ts

@@ -8,7 +8,7 @@
  * Override any color via ~/.swagmanager/theme.json:
  *   { "brand": "#FF6600", "text": "#E0E0E0" }
  */
-declare const DEFAULT_COLORS: {
+export declare const DEFAULT_COLORS: {
     brand: string;
     brandDim: string;
     success: string;
@@ -71,4 +71,3 @@ export declare const symbols: {
 export declare function boxLine(width: number): string;
 export declare function boxTop(width: number): string;
 export declare function boxBottom(width: number): string;
-export {};

package/dist/cli/shared/Theme.js

@@ -14,7 +14,7 @@ import { homedir } from "os";
 // ============================================================================
 // COLORS — macOS system palette (dark appearance)
 // ============================================================================
-const DEFAULT_COLORS = {
+export const DEFAULT_COLORS = {
     // Accents
     brand: "#0A84FF", // systemBlue
     brandDim: "#0071E3", // Apple link blue

package/dist/cli/shared/WhaleBanner.d.ts

@@ -1,5 +1,8 @@
 /**
- * whale code banner — clean terminal style
+ * whale code banner — ASCII art header
+ *
+ * Auto-switches to compact mode when terminal is too narrow for ASCII art.
+ * Each line rendered separately with wrap="truncate" to prevent reflow on resize.
  */
 interface WhaleBannerProps {
     subtitle?: string;

package/dist/cli/shared/WhaleBanner.js

@@ -1,12 +1,16 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
-import { colors, symbols, boxTop, boxBottom } from "./Theme.js";
+import { colors } from "./Theme.js";
+const ASCII_LINES = [
+    "  ╦ ╦╦ ╦╔═╗╦  ╔═╗  ╔═╗╔═╗╔╦╗╔═╗",
+    "  ║║║╠═╣╠═╣║  ║╣   ║  ║ ║ ║║║╣ ",
+    "  ╚╩╝╩ ╩╩ ╩╩═╝╚═╝  ╚═╝╚═╝═╩╝╚═╝",
+];
+const MIN_WIDTH_FOR_ART = 38;
 export function WhaleBanner({ subtitle, version, compact }) {
-    if (compact) {
-        return (_jsxs(Box, { children: [_jsxs(Text, { color: colors.brand, bold: true, children: [symbols.sparkle, " whale code"] }), version && _jsxs(Text, { color: colors.dim, children: [" v", version] }), subtitle && _jsxs(Text, { color: colors.muted, children: [" ", subtitle] })] }));
+    const termWidth = process.stdout.columns || 80;
+    if (compact || termWidth < MIN_WIDTH_FOR_ART) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: " " }), _jsxs(Box, { children: [_jsx(Text, { color: colors.brand, bold: true, children: "  \u25C6 whale code" }), version && _jsxs(Text, { color: colors.dim, children: [" v", version] }), subtitle && _jsxs(Text, { color: colors.muted, children: [" ", subtitle] })] })] }));
     }
-    const width = 44;
-    const titleLine = `${symbols.sparkle} whale code` + (version ? `  v${version}` : "");
-    const titlePad = Math.max(0, Math.floor((width - 2 - titleLine.length) / 2));
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: colors.border, children: boxTop(width) }), _jsxs(Box, { children: [_jsx(Text, { color: colors.border, children: symbols.verticalBar }), _jsx(Text, { children: " ".repeat(width - 2) }), _jsx(Text, { color: colors.border, children: symbols.verticalBar })] }), _jsxs(Box, { children: [_jsx(Text, { color: colors.border, children: symbols.verticalBar }), _jsx(Text, { children: " ".repeat(titlePad) }), _jsxs(Text, { color: colors.brand, bold: true, children: [symbols.sparkle, " whale code"] }), version && _jsxs(Text, { color: colors.dim, children: ["  v", version] }), _jsx(Text, { children: " ".repeat(Math.max(0, width - 2 - titlePad - titleLine.length)) }), _jsx(Text, { color: colors.border, children: symbols.verticalBar })] }), subtitle && (_jsxs(Box, { children: [_jsx(Text, { color: colors.border, children: symbols.verticalBar }), _jsx(Text, { children: " ".repeat(titlePad) }), _jsx(Text, { color: colors.muted, children: subtitle }), _jsx(Text, { children: " ".repeat(Math.max(0, width - 2 - titlePad - subtitle.length)) }), _jsx(Text, { color: colors.border, children: symbols.verticalBar })] })), _jsxs(Box, { children: [_jsx(Text, { color: colors.border, children: symbols.verticalBar }), _jsx(Text, { children: " ".repeat(width - 2) }), _jsx(Text, { color: colors.border, children: symbols.verticalBar })] }), _jsx(Text, { color: colors.border, children: boxBottom(width) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: " " }), ASCII_LINES.map((line, i) => (_jsx(Text, { color: colors.info, bold: true, wrap: "truncate", children: line }, i)))] }));
 }

package/dist/cli/shared/markdown.d.ts

@@ -1,14 +1,15 @@
 /**
- * Markdown rendering — Apple-polished terminal output
+ * Markdown rendering — polished terminal output with shiki syntax highlighting
  *
- * Syntax theme: purples, blues, pinks — no yellow.
- * Financials: green for gains, red for losses/deductions.
- * Uses marked + marked-terminal + cli-highlight.
+ * Uses shiki for VS Code-quality syntax highlighting.
+ * All chalk instances are rebuilt on theme switch via rebuildMarkdownRenderer().
+ * Uses marked + marked-terminal for markdown structure.
  */
 /** Width for top-level assistant text (accounts for MessageList marginLeft=2) */
 export declare function contentWidth(): number;
 /** Width for content nested inside tool results (MessageList=2 + ToolIndicator=2 + safety=2) */
 export declare function toolContentWidth(): number;
+export declare function rebuildMarkdownRenderer(): void;
 /**
  * Close incomplete markdown fences for safe streaming rendering.
  * State-tracking approach: handles nested fences, escaped markers, double-backtick spans.