whale-code 6.4.0

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

@@ -0,0 +1,543 @@
+/**
+ * Server Tools — loaded dynamically from ai_tool_registry
+ *
+ * Single source of truth: the database. Same as the MCP server (index.ts).
+ * No hardcoded definitions. Tools are cached for 60s after first load.
+ *
+ * Execution: proxied to the Fly.io server or Supabase edge function (mode: "tool").
+ * All business logic lives server-side — CLI is a thin client.
+ * Claude formats the JSON results for the user (no client-side formatter).
+ */
+import { createClient } from "@supabase/supabase-js";
+import { writeFileSync, readFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+// Note: extractMediaToFiles below is a fallback for any tools that still return
+// base64 media. The voice handler now uploads to Supabase Storage and returns
+// file_url instead, but this remains for backwards compatibility.
+import { resolveConfig } from "./config-store.js";
+import { getValidToken, createAuthenticatedClient } from "./auth-service.js";
+import { formatServerResponse } from "./format-server-response.js";
+let executionContext = {};
+/**
+ * Set the execution context for server tool calls.
+ * Called by agent-loop.ts before each turn so tool calls carry trace/user identity.
+ */
+export function setServerToolContext(ctx) {
+    executionContext = ctx;
+}
+// ============================================================================
+// SUPABASE CLIENT (tiered: service role > user JWT)
+// Used only for loading tool definitions from ai_tool_registry.
+// Tool execution goes through the edge function.
+// ============================================================================
+let cachedClient = null;
+let cachedStoreId = "";
+let cachedAuthMethod = "none";
+let cachedToken = "";
+async function getSupabaseClient() {
+    const config = resolveConfig();
+    // Tier 1: Service role key (full access, MCP server mode) — never expires
+    if (config.supabaseUrl && config.supabaseKey) {
+        if (cachedClient && cachedAuthMethod === "service_role") {
+            return { client: cachedClient, storeId: cachedStoreId };
+        }
+        cachedClient = createClient(config.supabaseUrl, config.supabaseKey, {
+            auth: { persistSession: false, autoRefreshToken: false },
+        });
+        cachedStoreId = config.storeId || "";
+        cachedAuthMethod = "service_role";
+        return { client: cachedClient, storeId: cachedStoreId };
+    }
+    // Tier 2: User JWT (CLI login) — recreate client when token refreshes
+    const token = await getValidToken();
+    if (token) {
+        if (cachedClient && cachedToken === token) {
+            cachedStoreId = config.storeId || "";
+            return { client: cachedClient, storeId: cachedStoreId };
+        }
+        cachedClient = createAuthenticatedClient(token);
+        cachedToken = token;
+        cachedStoreId = config.storeId || "";
+        cachedAuthMethod = "jwt";
+        return { client: cachedClient, storeId: cachedStoreId };
+    }
+    cachedClient = null;
+    cachedToken = "";
+    cachedAuthMethod = "none";
+    return null;
+}
+export function resetServerToolClient() {
+    cachedClient = null;
+    cachedStoreId = "";
+    cachedToken = "";
+    cachedAuthMethod = "none";
+    connectionVerified = false;
+    // Also clear tool cache so next load fetches fresh
+    loadedTools = [];
+    loadedToolNames.clear();
+    toolsLoadedAt = 0;
+}
+// ============================================================================
+// CONNECTION CHECK
+// ============================================================================
+let connectionVerified = false;
+export async function checkConnection() {
+    if (connectionVerified)
+        return true;
+    const conn = await getSupabaseClient();
+    if (!conn)
+        return false;
+    try {
+        // Quick health check — query a small table
+        const { error } = await conn.client.from("stores").select("id").limit(1);
+        connectionVerified = !error;
+        return connectionVerified;
+    }
+    catch {
+        return false;
+    }
+}
+// ============================================================================
+// TOOL DEFINITIONS — loaded from ai_tool_registry (single source of truth)
+// ============================================================================
+let loadedTools = [];
+let loadedToolNames = new Set();
+let toolsLoadedAt = 0;
+const TOOL_CACHE_TTL = 60_000; // 1 minute
+/**
+ * Load server tool definitions from ai_tool_registry.
+ * Same query as the MCP server (index.ts). Cached for 60s.
+ * Filters out tool_mode='code' (those are local CLI tools).
+ */
+export async function loadServerToolDefinitions(force = false) {
+    // Return cache if fresh
+    if (!force && loadedTools.length > 0 && Date.now() - toolsLoadedAt < TOOL_CACHE_TTL) {
+        return loadedTools;
+    }
+    const conn = await getSupabaseClient();
+    if (!conn)
+        return [];
+    try {
+        const { data, error } = await conn.client
+            .from("ai_tool_registry")
+            .select("name, description, definition")
+            .eq("is_active", true)
+            .neq("tool_mode", "code");
+        if (error) {
+            console.error("[server-tools] Failed to load from ai_tool_registry:", error.message);
+            return loadedTools; // Return stale cache on error
+        }
+        loadedTools = (data || []).map(t => ({
+            name: t.name,
+            description: t.description || t.definition?.description || `Execute ${t.name}`,
+            input_schema: t.definition?.input_schema || { type: "object", properties: {} },
+        }));
+        // Rebuild the name set
+        loadedToolNames.clear();
+        for (const tool of loadedTools) {
+            loadedToolNames.add(tool.name);
+        }
+        toolsLoadedAt = Date.now();
+        connectionVerified = true;
+        return loadedTools;
+    }
+    catch (err) {
+        console.error("[server-tools] Error loading tool definitions:", err);
+        return loadedTools;
+    }
+}
+/**
+ * Check if a tool name is a server tool.
+ * After first load, checks against the dynamically loaded set.
+ */
+export function isServerTool(name) {
+    return loadedToolNames.has(name);
+}
+/**
+ * Get currently loaded definitions (for /tools listing).
+ * Returns whatever is cached — call loadServerToolDefinitions() first to populate.
+ */
+export function getAllServerToolDefinitions() {
+    return loadedTools;
+}
+// ============================================================================
+// SERVER STATUS
+// ============================================================================
+export async function getServerStatus() {
+    const { loadConfig } = await import("./config-store.js");
+    const config = loadConfig();
+    // Loading tools also verifies connection
+    const tools = await loadServerToolDefinitions();
+    return {
+        connected: tools.length > 0,
+        storeId: config.store_id || "",
+        storeName: config.store_name || "",
+        toolCount: tools.length,
+        authMethod: cachedAuthMethod,
+    };
+}
+// ============================================================================
+// EXECUTE SERVER TOOL — proxied to edge function
+// ============================================================================
+/** Media fields that contain base64-encoded binary data */
+const MEDIA_FIELDS = {
+    audio_base64: { ext: "mp3", label: "audio" },
+    stems_zip_base64: { ext: "zip", label: "stems" },
+};
+/** Tools that produce downloadable media files via file_url */
+const MEDIA_TOOLS = new Set(["voice", "image_gen", "video_gen"]);
+/**
+ * Download a single file_url to a local path, replacing the URL in the data.
+ * inputArgs is the original tool call args — used to derive descriptive filenames
+ * when the result data doesn't include the text/prompt.
+ */
+async function downloadSingleMedia(data, toolName, outDir, inputArgs) {
+    const fileUrl = data.file_url;
+    if (typeof fileUrl !== "string" || !fileUrl.startsWith("http"))
+        return;
+    // Derive a descriptive filename
+    // Check result data first, then fall back to input args for text/prompt
+    let label = "";
+    const text = (data.prompt || data.text || inputArgs?.text || inputArgs?.prompt);
+    if (text) {
+        label = text.substring(0, 40).replace(/[^a-zA-Z0-9]+/g, "-").replace(/-+$/, "").toLowerCase();
+    }
+    const action = data.action || inputArgs?.action || toolName;
+    // Detect format: explicit field > file extension from URL > tool-based default
+    let format = data.format;
+    if (!format) {
+        try {
+            const urlPath = new URL(fileUrl).pathname;
+            const urlExt = urlPath.split(".").pop();
+            if (urlExt && urlExt.length <= 4)
+                format = urlExt;
+        }
+        catch { /* invalid URL — use default */ }
+    }
+    if (!format)
+        format = toolName === "image_gen" ? "png" : toolName === "video_gen" ? "mp4" : "mp3";
+    const ts = Date.now();
+    const nameParts = [action, label, String(ts)].filter(Boolean);
+    const filename = `${nameParts.join("-")}.${format}`;
+    const localPath = join(outDir, filename);
+    try {
+        const resp = await fetch(fileUrl);
+        if (!resp.ok) {
+            data.download_error = `Failed to download: HTTP ${resp.status}`;
+            return;
+        }
+        const buffer = Buffer.from(await resp.arrayBuffer());
+        writeFileSync(localPath, buffer);
+        // Replace remote URL with local path — the LLM reports this, no URL needed
+        data.local_file = localPath;
+        data.file_size = buffer.length;
+        // Remove fields that tempt the LLM to fabricate URLs
+        delete data.file_url;
+        delete data.download;
+    }
+    catch (err) {
+        data.download_error = `Download failed: ${err.message || err}`;
+    }
+}
+/**
+ * Download remote media (file_url) to the user's working directory.
+ * This ensures the LLM never needs to handle URLs — it just reports local paths.
+ * Prevents the hallucinated-URL problem where models fabricate wrong download URLs.
+ *
+ * Handles both single results (file_url at top level) and batch results
+ * (file_url inside images[] or previews[] arrays).
+ */
+async function downloadRemoteMedia(data, toolName, inputArgs) {
+    // Save to cwd — the user's working directory, not a hidden temp folder
+    const outDir = process.cwd();
+    // Single file at top level (voice speak, image_gen generate, etc.)
+    if (typeof data.file_url === "string" && data.file_url.startsWith("http")) {
+        await downloadSingleMedia(data, toolName, outDir, inputArgs);
+    }
+    // Batch arrays — image_gen batch returns images[], voice_design returns previews[]
+    if (Array.isArray(data.images)) {
+        for (const img of data.images) {
+            if (img && typeof img === "object" && typeof img.file_url === "string") {
+                await downloadSingleMedia(img, toolName, outDir);
+            }
+        }
+    }
+    if (Array.isArray(data.previews)) {
+        for (const preview of data.previews) {
+            if (preview && typeof preview === "object" && typeof preview.file_url === "string") {
+                await downloadSingleMedia(preview, toolName, outDir);
+            }
+        }
+    }
+}
+/**
+ * Extract base64 media from tool results, save to temp files, and replace
+ * with file paths. This prevents truncation from destroying binary data
+ * that the model needs to save for the user.
+ */
+function extractMediaToFiles(data, toolName) {
+    const outDir = join(tmpdir(), "whale-audio");
+    let dirCreated = false;
+    for (const [field, { ext, label }] of Object.entries(MEDIA_FIELDS)) {
+        const b64 = data[field];
+        if (typeof b64 !== "string" || b64.length < 100)
+            continue;
+        if (!dirCreated) {
+            mkdirSync(outDir, { recursive: true });
+            dirCreated = true;
+        }
+        const ts = Date.now();
+        const filename = `${toolName}-${label}-${ts}.${ext}`;
+        const filePath = join(outDir, filename);
+        try {
+            writeFileSync(filePath, Buffer.from(b64, "base64"));
+            // Replace base64 with file path so model can reference it
+            data[field] = `(saved to ${filePath})`;
+            data[`${label}_file`] = filePath;
+        }
+        catch {
+            // Leave original data if write fails
+        }
+    }
+    // Handle voice_design previews array
+    if (Array.isArray(data.previews)) {
+        if (!dirCreated) {
+            mkdirSync(outDir, { recursive: true });
+        }
+        for (let i = 0; i < data.previews.length; i++) {
+            const preview = data.previews[i];
+            if (!preview?.audio_base64 || typeof preview.audio_base64 !== "string")
+                continue;
+            const ts = Date.now();
+            const filePath = join(outDir, `${toolName}-preview-${i}-${ts}.mp3`);
+            try {
+                writeFileSync(filePath, Buffer.from(preview.audio_base64, "base64"));
+                preview.audio_base64 = `(saved to ${filePath})`;
+                preview.audio_file = filePath;
+            }
+            catch {
+                // Leave original
+            }
+        }
+    }
+}
+/**
+ * Execute a server tool via the Fly.io server or Supabase edge function (mode: "tool").
+ * Returns the raw JSON — Claude formats it for the user.
+ * No client-side formatting: the model is the presentation layer.
+ *
+ * For tools that support live progress (kali exec), uses `mode: "tool_stream"` with NDJSON
+ * and emits `tool_output` events via the optional emitter for real-time CLI rendering.
+ */
+export async function executeServerTool(name, input, emitter) {
+    const config = resolveConfig();
+    if (!config.serverUrl) {
+        return { success: false, output: "No server URL configured — server tools unavailable." };
+    }
+    // Auth token: service role key preferred, user JWT fallback
+    let authToken = config.supabaseKey;
+    if (!authToken) {
+        authToken = await getValidToken() || "";
+    }
+    if (!authToken) {
+        return { success: false, output: "No auth token — server tools unavailable. Run: whale login" };
+    }
+    // ── Pre-process file_paths for voice tool ──
+    // Reads local files and base64-encodes them so the LLM never handles binary data.
+    // CRITICAL: We must NOT mutate `input` — the agent loop keeps a reference to it
+    // in the conversation history. If we inject base64 into `input`, it leaks into
+    // the LLM context and blows the 200K token limit.
+    let serverArgs = input;
+    if (name === "voice" && (input.file_paths || input.file_path)) {
+        let paths = [];
+        if (Array.isArray(input.file_paths)) {
+            paths = input.file_paths;
+        }
+        else if (typeof input.file_path === "string") {
+            paths = [input.file_path];
+        }
+        const MAX_TOTAL_BYTES = 7_000_000; // 7MB raw = ~9.3MB base64, under 10MB server limit
+        const MAX_SINGLE_FILE = 2_000_000; // 2MB per file (~2 min at 128kbps) — enough for good clone
+        const samples = [];
+        let totalBytes = 0;
+        for (const p of paths) {
+            try {
+                let buf = readFileSync(p);
+                // IVC: trim to 2MB per file. PVC: no trim (needs 30+ min for best quality)
+                const isPVC = input.action === "pvc_upload";
+                if (!isPVC && buf.length > MAX_SINGLE_FILE) {
+                    buf = buf.subarray(0, MAX_SINGLE_FILE);
+                }
+                totalBytes += buf.length;
+                const maxTotal = isPVC ? 25_000_000 : MAX_TOTAL_BYTES;
+                if (totalBytes > maxTotal)
+                    break; // use what we have
+                samples.push(buf.toString("base64"));
+            }
+            catch (err) {
+                // Skip unreadable files instead of killing the entire batch
+                continue;
+            }
+        }
+        if (samples.length === 0) {
+            return { success: false, output: "No valid audio files found in the provided paths." };
+        }
+        // Build a SEPARATE args object for the server — never touch `input`
+        const { file_paths: _fp, file_path: _f, ...rest } = input;
+        serverArgs = { ...rest };
+        if (input.action === "clone_voice" || input.action === "pvc_upload") {
+            serverArgs.audio_samples = samples;
+        }
+        else if (input.action === "voice_design") {
+            serverArgs.reference_audio_base64 = samples[0];
+        }
+        else {
+            serverArgs.audio_base64 = samples[0];
+        }
+    }
+    // ── Streaming path for kali exec actions ──
+    // Uses NDJSON streaming to show live stdout/stderr in the CLI while the command runs.
+    const isStreamable = name === "kali" && emitter &&
+        (input.action === "exec" || input.action === "exec_stream");
+    if (isStreamable) {
+        try {
+            const serverUrl = config.serverUrl;
+            const response = await fetch(serverUrl, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "Authorization": `Bearer ${authToken}`,
+                },
+                body: JSON.stringify({
+                    mode: "tool_stream",
+                    tool_name: name,
+                    args: serverArgs,
+                    store_id: config.storeId || undefined,
+                    trace_id: executionContext.traceId || undefined,
+                    conversation_id: executionContext.conversationId || undefined,
+                    userId: executionContext.userId || undefined,
+                    userEmail: executionContext.userEmail || undefined,
+                    source: executionContext.source || "whale-code",
+                }),
+            });
+            if (!response.ok) {
+                const text = await response.text().catch(() => "");
+                return { success: false, output: `Server tool stream error: HTTP ${response.status}: ${text.substring(0, 500)}` };
+            }
+            if (!response.body) {
+                return { success: false, output: "Server returned no response body for tool_stream" };
+            }
+            // Read NDJSON stream — emit progress events, collect final result
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            let finalResult = null;
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                let newlineIdx;
+                while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
+                    const line = buffer.substring(0, newlineIdx).trim();
+                    buffer = buffer.substring(newlineIdx + 1);
+                    if (!line)
+                        continue;
+                    try {
+                        const parsed = JSON.parse(line);
+                        if (parsed.type === "progress" && parsed.progress) {
+                            const p = parsed.progress;
+                            if ((p.type === "stdout" || p.type === "stderr") && p.data) {
+                                emitter.emitToolOutput(name, p.data);
+                            }
+                        }
+                        else if (parsed.type === "result") {
+                            finalResult = parsed;
+                        }
+                    }
+                    catch { /* skip malformed lines */ }
+                }
+            }
+            // Process remaining buffer
+            const remaining = buffer.trim();
+            if (remaining) {
+                try {
+                    const parsed = JSON.parse(remaining);
+                    if (parsed.type === "result")
+                        finalResult = parsed;
+                }
+                catch { /* skip */ }
+            }
+            if (finalResult) {
+                if (finalResult.success && finalResult.data) {
+                    const output = typeof finalResult.data === "string"
+                        ? finalResult.data
+                        : formatServerResponse(finalResult.data, name);
+                    return { success: true, output };
+                }
+                return { success: false, output: finalResult.error || `Server tool "${name}" returned success=false` };
+            }
+            return { success: false, output: "No result received from streaming tool execution" };
+        }
+        catch (err) {
+            return { success: false, output: `Server tool stream error: ${err.message || err}` };
+        }
+    }
+    // ── Standard path: non-streaming tools ──
+    try {
+        const serverUrl = config.serverUrl;
+        const response = await fetch(serverUrl, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${authToken}`,
+            },
+            body: JSON.stringify({
+                mode: "tool",
+                tool_name: name,
+                args: serverArgs,
+                store_id: config.storeId || undefined,
+                trace_id: executionContext.traceId || undefined,
+                conversation_id: executionContext.conversationId || undefined,
+                userId: executionContext.userId || undefined,
+                userEmail: executionContext.userEmail || undefined,
+                source: executionContext.source || "whale-code",
+            }),
+        });
+        const result = await response.json();
+        if (result.success) {
+            if (result.data && typeof result.data === "object") {
+                const dataObj = result.data;
+                // Auto-download remote media files to local temp paths
+                if (MEDIA_TOOLS.has(name)) {
+                    await downloadRemoteMedia(dataObj, name, input);
+                }
+                // Legacy: extract base64 media to temp files
+                extractMediaToFiles(dataObj, name);
+            }
+            let output = typeof result.data === "string"
+                ? result.data
+                : formatServerResponse(result.data, name);
+            // Safety cap only — Anthropic context_management handles normal limits.
+            // Old limit was 30K which caused constant truncation and extra tool calls.
+            const SAFETY_MAX_SERVER_CHARS = 500_000;
+            if (output.length > SAFETY_MAX_SERVER_CHARS) {
+                output = output.slice(0, SAFETY_MAX_SERVER_CHARS)
+                    + `\n\n... (safety truncated — ${output.length.toLocaleString()} chars total)`;
+            }
+            return { success: true, output };
+        }
+        // Extract error from nested data if top-level error is missing
+        let errorMsg = result.error;
+        if (!errorMsg && result.data && typeof result.data === "object") {
+            const nested = result.data.error;
+            if (typeof nested === "string")
+                errorMsg = nested;
+        }
+        return { success: false, output: errorMsg || `Server tool "${name}" returned success=false with no error message` };
+    }
+    catch (err) {
+        return { success: false, output: `Server tool error: ${err.message || err}` };
+    }
+}

package/dist/cli/services/session-persistence.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Session Persistence — save/load conversations to disk
+ *
+ * Extracted from agent-loop.ts for single-responsibility.
+ * All consumers should import from agent-loop.ts (re-export facade).
+ */
+import type Anthropic from "@anthropic-ai/sdk";
+export interface SessionMeta {
+    id: string;
+    title: string;
+    model: string;
+    messageCount: number;
+    createdAt: string;
+    updatedAt: string;
+    cwd?: string;
+}
+export declare function saveSession(messages: Anthropic.MessageParam[], sessionId?: string): string;
+export declare function loadSession(sessionId: string): {
+    meta: SessionMeta;
+    messages: Anthropic.MessageParam[];
+} | null;
+export declare function listSessions(limit?: number): SessionMeta[];
+export declare function findLatestSessionForCwd(): SessionMeta | null;

package/dist/cli/services/session-persistence.js

@@ -0,0 +1,99 @@
+/**
+ * Session Persistence — save/load conversations to disk
+ *
+ * Extracted from agent-loop.ts for single-responsibility.
+ * All consumers should import from agent-loop.ts (re-export facade).
+ */
+import { readFileSync, existsSync, mkdirSync, writeFileSync, readdirSync, appendFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { getModel } from "./model-manager.js";
+const SESSIONS_DIR = join(homedir(), ".swagmanager", "sessions");
+function ensureSessionsDir() {
+    if (!existsSync(SESSIONS_DIR))
+        mkdirSync(SESSIONS_DIR, { recursive: true });
+}
+export function saveSession(messages, sessionId) {
+    ensureSessionsDir();
+    const id = sessionId || `session-${Date.now()}`;
+    const meta = {
+        id,
+        title: extractSessionTitle(messages),
+        model: getModel(),
+        messageCount: messages.length,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        cwd: process.cwd(),
+    };
+    const data = JSON.stringify({ meta, messages }, null, 2);
+    writeFileSync(join(SESSIONS_DIR, `${id}.json`), data, "utf-8");
+    logSessionHistory(meta);
+    return id;
+}
+export function loadSession(sessionId) {
+    const path = join(SESSIONS_DIR, `${sessionId}.json`);
+    if (!existsSync(path))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function listSessions(limit = 20) {
+    ensureSessionsDir();
+    const files = readdirSync(SESSIONS_DIR)
+        .filter((f) => f.endsWith(".json"))
+        .sort()
+        .reverse()
+        .slice(0, limit);
+    const sessions = [];
+    for (const f of files) {
+        try {
+            const data = JSON.parse(readFileSync(join(SESSIONS_DIR, f), "utf-8"));
+            if (data.meta)
+                sessions.push(data.meta);
+        }
+        catch { /* skip corrupted */ }
+    }
+    return sessions;
+}
+const HISTORY_FILE = join(homedir(), ".swagmanager", "history.jsonl");
+function logSessionHistory(meta) {
+    try {
+        const dir = join(homedir(), ".swagmanager");
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        const entry = {
+            display: meta.title,
+            project: meta.cwd || process.cwd(),
+            timestamp: meta.updatedAt,
+            sessionId: meta.id,
+            model: meta.model,
+        };
+        appendFileSync(HISTORY_FILE, JSON.stringify(entry) + "\n");
+    }
+    catch { /* best effort */ }
+}
+export function findLatestSessionForCwd() {
+    const cwd = process.cwd();
+    const sessions = listSessions(100);
+    return sessions.find(s => s.cwd === cwd) || null;
+}
+function extractSessionTitle(messages) {
+    // Use first user message as title (truncated)
+    for (const m of messages) {
+        if (m.role === "user" && typeof m.content === "string") {
+            return m.content.slice(0, 60) + (m.content.length > 60 ? "..." : "");
+        }
+        if (m.role === "user" && Array.isArray(m.content)) {
+            for (const block of m.content) {
+                if ("text" in block && typeof block.text === "string") {
+                    return block.text.slice(0, 60) + (block.text.length > 60 ? "..." : "");
+                }
+            }
+        }
+    }
+    return "Untitled session";
+}

package/dist/cli/services/subagent-worker.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Subagent Worker — runs in separate thread to not block UI
+ *
+ * Usage: Spawned by parallel_tasks via worker_threads
+ *
+ * This worker runs `runSubagent()` in isolation, keeping the main thread
+ * (and Ink UI) responsive. Results are posted back via parentPort.
+ */
+import { type SubagentOptions, type SubagentResult } from "./subagent.js";
+export interface WorkerData {
+    options: SubagentOptions;
+    index: number;
+}
+export interface WorkerResult {
+    success: boolean;
+    index: number;
+    result?: SubagentResult;
+    error?: string;
+}