whale-code 6.4.0 → 6.5.0

package/dist/cli/commands/mcp.js

@@ -9,26 +9,7 @@
  *   whale mcp remove <name>                 Remove server
  *   whale mcp get <name>                    Show server config
  */
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-const CONFIG_PATH = join(homedir(), ".swagmanager", "config.json");
-function loadConfig() {
-    if (!existsSync(CONFIG_PATH))
-        return {};
-    try {
-        return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
-    }
-    catch {
-        return {};
-    }
-}
-function saveConfig(config) {
-    const dir = join(homedir(), ".swagmanager");
-    if (!existsSync(dir))
-        mkdirSync(dir, { recursive: true });
-    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
-}
+import { loadConfig, saveConfig } from "../services/config-store.js";
 function getServers(config) {
     return config.mcpServers || {};
 }

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

@@ -54,6 +54,18 @@ export interface ToolOutputEvent {
     toolName: string;
     line: string;
 }
+export interface ToolProgressEvent {
+    type: "tool_progress";
+    toolName: string;
+    progress: {
+        phase?: string;
+        elapsed_s: number;
+        stdout_lines: number;
+        stderr_lines: number;
+        stdout_bytes: number;
+        last_line?: string;
+    };
+}
 export interface SubagentStartEvent {
     type: "subagent_start";
     id: string;
@@ -132,12 +144,20 @@ export interface TeamDoneEvent {
     };
     durationMs: number;
 }
-export type AgentEvent = AgentTextEvent | AgentToolStartEvent | AgentToolEndEvent | AgentUsageEvent | AgentDoneEvent | AgentErrorEvent | AgentCompactEvent | ToolOutputEvent | SubagentStartEvent | SubagentProgressEvent | SubagentDoneEvent | SubagentToolStartEvent | SubagentToolEndEvent | TeamStartEvent | TeamProgressEvent | TeamTaskEvent | TeamDoneEvent;
+export interface AgentThinkingEvent {
+    type: "thinking";
+    chunkCount: number;
+}
+export type AgentEvent = AgentTextEvent | AgentThinkingEvent | AgentToolStartEvent | AgentToolEndEvent | AgentUsageEvent | AgentDoneEvent | AgentErrorEvent | AgentCompactEvent | ToolOutputEvent | ToolProgressEvent | SubagentStartEvent | SubagentProgressEvent | SubagentDoneEvent | SubagentToolStartEvent | SubagentToolEndEvent | TeamStartEvent | TeamProgressEvent | TeamTaskEvent | TeamDoneEvent;
 export declare class AgentEventEmitter extends EventEmitter {
     /**
      * Emit text immediately — UI-side handles batching via single flush timer
      */
     emitText(text: string): void;
+    /**
+     * Emit thinking chunk count — UI renders activity dots
+     */
+    emitThinking(chunkCount: number): void;
     /**
      * No-op — kept for interface compat
      */
@@ -149,6 +169,7 @@ export declare class AgentEventEmitter extends EventEmitter {
     emitError(error: string): void;
     emitCompact(before: number, after: number, tokensSaved: number): void;
     emitToolOutput(toolName: string, line: string): void;
+    emitToolProgress(toolName: string, progress: ToolProgressEvent["progress"]): void;
     emitSubagentStart(id: string, agentType: string, model: string, description: string): void;
     emitSubagentProgress(id: string, agentType: string, message: string, turn?: number, toolName?: string): void;
     emitSubagentDone(id: string, agentType: string, success: boolean, output: string, tokens: {

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

@@ -19,6 +19,12 @@ export class AgentEventEmitter extends EventEmitter {
             accumulated: "", // Set by consumer
         });
     }
+    /**
+     * Emit thinking chunk count — UI renders activity dots
+     */
+    emitThinking(chunkCount) {
+        this.emit("event", { type: "thinking", chunkCount });
+    }
     /**
      * No-op — kept for interface compat
      */
@@ -55,6 +61,9 @@ export class AgentEventEmitter extends EventEmitter {
     emitToolOutput(toolName, line) {
         this.emit("event", { type: "tool_output", toolName, line });
     }
+    emitToolProgress(toolName, progress) {
+        this.emit("event", { type: "tool_progress", toolName, progress });
+    }
     emitSubagentStart(id, agentType, model, description) {
         this.emit("event", { type: "subagent_start", id, agentType, model, description });
     }

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

@@ -17,11 +17,11 @@
  *   - system-prompt.ts      (buildSystemPrompt)
  */
 import { LOCAL_TOOL_DEFINITIONS, executeLocalTool, isLocalTool, } from "./local-tools.js";
-import { INTERACTIVE_TOOL_DEFINITIONS, executeInteractiveTool, } from "./interactive-tools.js";
+import { INTERACTIVE_TOOL_DEFINITIONS, executeInteractiveTool, waitForPlanApproval, } from "./interactive-tools.js";
 import { loadConfig, resolveConfig, getProxyUrl } from "./config-store.js";
 import { getValidToken, refreshSession } from "./auth-service.js";
 import { isServerTool, loadServerToolDefinitions, executeServerTool, getServerStatus, setServerToolContext, } from "./server-tools.js";
-import { nextTurn, createTurnContext, logSpan, generateSpanId, } from "./telemetry.js";
+import { nextTurn, createTurnContext, logSpan, generateSpanId, flushCliSpans, } from "./telemetry.js";
 import { captureError, addBreadcrumb } from "./error-logger.js";
 import { setGlobalEmitter, clearGlobalEmitter, } from "./agent-events.js";
 import { mcpClientManager } from "./mcp-client.js";
@@ -35,6 +35,7 @@ import { dispatchTools, buildAssistantContent } from "../../shared/tool-dispatch
 import { loadMemory, addMemory, removeMemory, listMemories } from "./memory-manager.js";
 import { refreshGitContext, resetGitContext } from "./git-context.js";
 import { loadClaudeMd, reloadClaudeMd, resetClaudeMdCache } from "./claude-md-loader.js";
+import { clearReadCache } from "./tools/file-ops.js";
 import { setPermissionMode, getPermissionMode, isToolAllowedByPermission } from "./permission-modes.js";
 import { setModel, setModelById, getModel, getModelShortName, estimateCostUsd } from "./model-manager.js";
 import { saveSession, loadSession, listSessions, findLatestSessionForCwd } from "./session-persistence.js";
@@ -86,6 +87,7 @@ export function resetSessionState() {
     sessionLoopDetector = null;
     resetGitContext();
     resetClaudeMdCache();
+    clearReadCache();
 }
 /** CLI-only: loop detector — persists session error state across turns (reset by resetSessionState) */
 let sessionLoopDetector = null;
@@ -305,6 +307,7 @@ export async function runAgentLoop(opts) {
     });
     let sessionCostUsd = 0;
     let compactionCount = 0;
+    const costWarningsEmitted = new Set();
     const activeModel = getModel();
     // Tool executor — routes to interactive, local, server, or MCP tools.
     // Wraps execution with before/after hooks when hooks are loaded.
@@ -331,6 +334,24 @@ export async function runAgentLoop(opts) {
         let result;
         if (INTERACTIVE_TOOL_NAMES.has(name)) {
             result = await executeInteractiveTool(name, effectiveInput);
+            // For exit_plan_mode: wait for UI approval, then map decision to result
+            if (name === "exit_plan_mode" && result.success) {
+                const decision = await waitForPlanApproval();
+                switch (decision.action) {
+                    case "execute":
+                        result = { success: true, output: `__PLAN_APPROVED_CLEAN__\n${result.output}` };
+                        break;
+                    case "edit":
+                        result = { success: true, output: "Plan returned for revision. Make changes and use ExitPlanMode again when ready." };
+                        break;
+                    case "feedback":
+                        result = { success: true, output: `User feedback on plan:\n\n${decision.feedback || "(no feedback provided)"}\n\nRevise the plan based on this feedback, then use ExitPlanMode again.` };
+                        break;
+                    case "cancel":
+                        result = { success: true, output: "Plan cancelled by user. Do not proceed with implementation." };
+                        break;
+                }
+            }
         }
         else if (isLocalTool(name)) {
             result = await executeLocalTool(name, effectiveInput);
@@ -449,6 +470,7 @@ export async function runAgentLoop(opts) {
                 },
             });
             // Process stream events with UI callbacks
+            let thinkingChunks = 0;
             const result = await processStreamWithCallbacks(parseSSEStream(stream, abortSignal), {
                 onText: (text) => {
                     if (emitter) {
@@ -458,6 +480,10 @@ export async function runAgentLoop(opts) {
                         callbacks.onText(text);
                     }
                 },
+                onThinking: () => {
+                    thinkingChunks++;
+                    emitter?.emitThinking(thinkingChunks);
+                },
                 onToolStart: (name, input) => {
                     // NOTE: Do NOT call callbacks.onToolStart here — dispatchTools.onStart
                     // fires it once per tool at execution time. Calling it here too would
@@ -489,6 +515,21 @@ export async function runAgentLoop(opts) {
             totalCacheRead += result.usage.cacheReadTokens;
             totalThinking += result.thinkingTokens;
             sessionCostUsd += estimateCostUsd(result.usage.inputTokens, result.usage.outputTokens, currentModel, result.thinkingTokens, result.usage.cacheReadTokens, result.usage.cacheCreationTokens);
+            // Graduated cost warnings
+            if (opts.maxBudgetUsd) {
+                for (const pct of [25, 50, 75]) {
+                    if (!costWarningsEmitted.has(pct) && sessionCostUsd >= opts.maxBudgetUsd * (pct / 100)) {
+                        costWarningsEmitted.add(pct);
+                        const warnMsg = `\n[Cost warning: ${pct}% of budget used ($${sessionCostUsd.toFixed(2)}/$${opts.maxBudgetUsd.toFixed(2)}). ${pct >= 75 ? "Wrap up soon." : ""}]`;
+                        if (emitter) {
+                            emitter.emitText(warnMsg);
+                        }
+                        else {
+                            callbacks.onText(warnMsg);
+                        }
+                    }
+                }
+            }
             // Server-side context management notification
             if (result.contextManagementApplied) {
                 callbacks.onAutoCompact?.(messages.length, messages.length, 0);
@@ -616,6 +657,25 @@ export async function runAgentLoop(opts) {
                 compactionContent: result.compactionContent,
             });
             messages.push({ role: "assistant", content: assistantContent });
+            // Check for __PLAN_APPROVED_CLEAN__ marker — clear context and start fresh with just the plan
+            const planCleanMarker = "__PLAN_APPROVED_CLEAN__\n";
+            const hasCleanPlanApproval = finalToolResults.some((tr) => {
+                const content = typeof tr.content === "string" ? tr.content : "";
+                return content.startsWith(planCleanMarker);
+            });
+            if (hasCleanPlanApproval) {
+                // Extract plan content from the marker
+                const planResult = finalToolResults.find((tr) => {
+                    const content = typeof tr.content === "string" ? tr.content : "";
+                    return content.startsWith(planCleanMarker);
+                });
+                const planText = planResult.content.slice(planCleanMarker.length);
+                const beforeCount = messages.length;
+                messages.length = 0;
+                messages.push({ role: "user", content: [{ type: "text", text: `Implement this plan:\n\n${planText}` }] });
+                callbacks.onAutoCompact?.(beforeCount, 1, 0);
+                continue;
+            }
             messages.push({ role: "user", content: finalToolResults });
             // Non-native compaction for OpenAI/Gemini — fires after tool results appended
             const compactionCfg = getCompactionConfig(currentModel);
@@ -683,6 +743,8 @@ export async function runAgentLoop(opts) {
         });
         const turnCostUsd = estimateCostUsd(totalIn, totalOut, activeModel, totalThinking, totalCacheRead, totalCacheCreation);
         callbacks.onUsage(totalIn, totalOut, totalThinking, activeModel, turnCostUsd, totalCacheRead, totalCacheCreation);
+        // Flush telemetry spans to server before session ends
+        flushCliSpans();
         // Fire SessionEnd hook (non-blocking)
         if (hooks.length > 0) {
             runSessionHook(hooks, "SessionEnd", { session_id: `turn-${sessionStart}` }).catch(() => { });
@@ -719,6 +781,8 @@ export async function runAgentLoop(opts) {
                 tags: { model: activeModel, turn: String(turnNum) },
             });
         }
+        // Flush telemetry on error path too
+        flushCliSpans();
         emitter?.emitError(errorMsg);
         if (emitter)
             clearGlobalEmitter();

package/dist/cli/services/agent-worker-base.js

@@ -13,6 +13,7 @@ import { getProxyUrl, resolveConfig } from "./config-store.js";
 import { getValidToken, refreshSession } from "./auth-service.js";
 import { parseSSEStream, collectStreamResult } from "../../shared/sse-parser.js";
 import { callServerProxy, buildAPIRequest, buildSystemBlocks, } from "../../shared/api-client.js";
+import { addPromptCaching } from "../../shared/agent-core.js";
 import { isLocalTool, executeLocalTool, } from "./local-tools.js";
 import { isServerTool, executeServerTool, } from "./server-tools.js";
 // ============================================================================
@@ -20,7 +21,7 @@ import { isServerTool, executeServerTool, } from "./server-tools.js";
 // ============================================================================
 /** Tools that spawn workers/subprocesses and need much longer than 2 min */
 const LONG_RUNNING_TOOL_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
-const LONG_RUNNING_TOOLS = new Set(["team_create", "task", "delegate_task"]);
+const LONG_RUNNING_TOOLS = new Set(["team_create", "task", "delegate_task", "exit_plan_mode", "ask_user_question"]);
 // ============================================================================
 // API CLIENT — unified proxy caller
 // ============================================================================
@@ -87,13 +88,15 @@ export async function callAgentAPI(opts) {
         tools = [...opts.tools];
     }
     const system = buildSystemBlocks(opts.systemPrompt);
+    // Apply prompt caching to messages (tools already cached above)
+    const { messages: cachedMessages } = addPromptCaching([], opts.messages);
     const { storeId } = resolveConfig();
     const stream = await callServerProxy({
         proxyUrl: getProxyUrl(),
         token,
         model: opts.modelId,
         system,
-        messages: opts.messages,
+        messages: cachedMessages,
         tools,
         apiConfig,
         storeId: storeId || undefined,
@@ -119,7 +122,7 @@ export async function callAgentAPI(opts) {
  * Returns tool results ready to append to messages, plus metadata.
  */
 export async function executeToolBlocks(opts) {
-    const { toolBlocks, loopDetector, callbacks, customExecutor, maxToolResultChars = 30_000, toolTimeoutMs, } = opts;
+    const { toolBlocks, loopDetector, callbacks, customExecutor, maxToolResultChars = 500_000, toolTimeoutMs, } = opts;
     const toolResults = [];
     const toolsUsed = [];
     const customSignals = {};
@@ -187,9 +190,21 @@ export async function executeToolBlocks(opts) {
             content: contentStr,
         };
     }
-    // Execute all tool calls in parallel — the model already determined these are independent
-    const batchResults = await Promise.all(toolBlocks.map(tu => executeSingle(tu)));
-    toolResults.push(...batchResults);
+    // Split into file-mutating (sequential) and read-only/server (parallel) batches.
+    // File writes/edits must be sequential to prevent race conditions on the same file.
+    const FILE_MUTATING_TOOLS = new Set(["write_file", "edit_file", "multi_edit", "notebook_edit", "run_command"]);
+    const sequential = toolBlocks.filter(tu => FILE_MUTATING_TOOLS.has(tu.name));
+    const parallel = toolBlocks.filter(tu => !FILE_MUTATING_TOOLS.has(tu.name));
+    // Run read-only/server tools in parallel
+    if (parallel.length > 0) {
+        const parallelResults = await Promise.all(parallel.map(tu => executeSingle(tu)));
+        toolResults.push(...parallelResults);
+    }
+    // Run file-mutating tools sequentially
+    for (const tu of sequential) {
+        const result = await executeSingle(tu);
+        toolResults.push(result);
+    }
     return { toolResults, toolsUsed, customSignals };
 }
 // ============================================================================

package/dist/cli/services/api-retry.d.ts

@@ -0,0 +1,25 @@
+/**
+ * API Retry Utility — shared exponential backoff for Anthropic API calls.
+ *
+ * Retries on: 429 (rate limit), 5xx (server error), 529 (overloaded),
+ * timeout errors, and network errors.
+ *
+ * Respects `retry-after` header on 429 responses.
+ * 429 gets a 4x delay multiplier since the server is actively rate-limiting.
+ */
+export interface RetryOptions {
+    maxRetries?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    label?: string;
+}
+/**
+ * Call an async function with automatic retry and exponential backoff.
+ *
+ * Usage:
+ *   const response = await callWithRetry(
+ *     () => client.messages.create({ ... }),
+ *     { label: "decomposer" }
+ *   );
+ */
+export declare function callWithRetry<T>(fn: () => Promise<T>, opts?: RetryOptions): Promise<T>;

package/dist/cli/services/api-retry.js

@@ -0,0 +1,91 @@
+/**
+ * API Retry Utility — shared exponential backoff for Anthropic API calls.
+ *
+ * Retries on: 429 (rate limit), 5xx (server error), 529 (overloaded),
+ * timeout errors, and network errors.
+ *
+ * Respects `retry-after` header on 429 responses.
+ * 429 gets a 4x delay multiplier since the server is actively rate-limiting.
+ */
+const RETRIABLE_STATUS_CODES = new Set([429, 500, 502, 503, 504, 529]);
+const RETRIABLE_ERROR_PATTERNS = [
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "ETIMEDOUT",
+    "ENOTFOUND",
+    "fetch failed",
+    "network",
+    "socket hang up",
+    "aborted",
+];
+function isRetriable(err) {
+    if (!err || typeof err !== "object")
+        return { retriable: false };
+    const e = err;
+    // Anthropic SDK errors expose `.status` for HTTP status codes
+    const status = e.status ?? e.statusCode;
+    if (status && RETRIABLE_STATUS_CODES.has(status)) {
+        let retryAfterMs;
+        // Check for retry-after header (Anthropic SDK surfaces headers on error)
+        const headers = e.headers;
+        if (headers?.["retry-after"]) {
+            const retryAfterSec = parseFloat(headers["retry-after"]);
+            if (!isNaN(retryAfterSec)) {
+                retryAfterMs = retryAfterSec * 1000;
+            }
+        }
+        return { retriable: true, statusCode: status, retryAfterMs };
+    }
+    // Check error message for network-level failures
+    const message = (e.message ?? "").toLowerCase();
+    const code = e.code ?? "";
+    if (RETRIABLE_ERROR_PATTERNS.some(p => message.includes(p.toLowerCase()) || code === p)) {
+        return { retriable: true };
+    }
+    return { retriable: false };
+}
+/**
+ * Call an async function with automatic retry and exponential backoff.
+ *
+ * Usage:
+ *   const response = await callWithRetry(
+ *     () => client.messages.create({ ... }),
+ *     { label: "decomposer" }
+ *   );
+ */
+export async function callWithRetry(fn, opts = {}) {
+    const maxRetries = opts.maxRetries ?? 3;
+    const baseDelayMs = opts.baseDelayMs ?? 2000;
+    const maxDelayMs = opts.maxDelayMs ?? 30000;
+    const label = opts.label ?? "api";
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastError = err;
+            if (attempt >= maxRetries)
+                break;
+            const { retriable, statusCode, retryAfterMs } = isRetriable(err);
+            if (!retriable)
+                throw err;
+            // Exponential backoff: 2s → 8s → 30s
+            let delayMs = Math.min(baseDelayMs * Math.pow(2, attempt), maxDelayMs);
+            // 429 gets 4x multiplier — the server is rate-limiting us
+            if (statusCode === 429) {
+                delayMs = retryAfterMs
+                    ? Math.min(retryAfterMs, maxDelayMs)
+                    : Math.min(delayMs * 4, maxDelayMs);
+            }
+            console.warn(`[${label}] Attempt ${attempt + 1}/${maxRetries + 1} failed` +
+                (statusCode ? ` (HTTP ${statusCode})` : "") +
+                ` — retrying in ${(delayMs / 1000).toFixed(1)}s: ${err.message?.slice(0, 100)}`);
+            await sleep(delayMs);
+        }
+    }
+    throw lastError;
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

package/dist/cli/services/auth-service.d.ts

@@ -25,6 +25,6 @@ export declare function signUp(email: string, password: string): Promise<AuthRes
 export declare function refreshSession(): Promise<AuthResult>;
 export declare function getValidToken(): Promise<string | null>;
 export declare function signOut(): void;
-export declare function getStoresForUser(accessToken: string, _userId: string): Promise<StoreInfo[]>;
+export declare function getStoresForUser(accessToken: string, userId: string): Promise<StoreInfo[]>;
 export declare function selectStore(storeId: string, storeName: string): void;
 export declare function isLoggedIn(): boolean;

package/dist/cli/services/auth-service.js

@@ -121,33 +121,54 @@ export function signOut() {
     clearConfig();
 }
 // Get stores for the authenticated user
-// RLS on the stores table filters to only stores the user has access to,
-// same as the Swift app does: client.from("stores").select()
-export async function getStoresForUser(accessToken, _userId) {
+// With a user JWT, RLS on the stores table handles access control directly —
+// same approach the platform exchange endpoint uses. For service role keys,
+// we fall back to store_members to prevent cross-tenant leakage.
+export async function getStoresForUser(accessToken, userId) {
+    if (!userId)
+        return [];
     const client = createAuthenticatedClient(accessToken);
-    // Let RLS filter — same pattern as the macOS app (SupabaseService.fetchStores)
-    const { data: stores, error } = await client
+    // Primary: query stores directly — RLS filters to user's stores
+    const { data: stores, error: storeError } = await client
         .from("stores")
         .select("id, store_name, slug")
         .limit(20);
-    if (error) {
-        // Fallback: try via the users table (auth_user_id column, not id)
-        const { data: userData } = await client
-            .from("users")
-            .select("store_id")
-            .eq("auth_user_id", _userId)
-            .single();
-        if (userData?.store_id) {
-            const { data: store } = await client
+    if (!storeError && stores && stores.length > 0) {
+        return stores.map((s) => ({ id: s.id, name: s.store_name, slug: s.slug }));
+    }
+    // Fallback 1: try via users table (auth_user_id → store_id)
+    const { data: userData } = await client
+        .from("users")
+        .select("store_id")
+        .eq("auth_user_id", userId);
+    if (userData && userData.length > 0) {
+        const storeIds = userData.map((u) => u.store_id).filter(Boolean);
+        if (storeIds.length > 0) {
+            const { data: userStores } = await client
                 .from("stores")
                 .select("id, store_name, slug")
-                .eq("id", userData.store_id)
-                .single();
-            return store ? [{ id: store.id, name: store.store_name, slug: store.slug }] : [];
+                .in("id", storeIds);
+            if (userStores && userStores.length > 0) {
+                return userStores.map((s) => ({ id: s.id, name: s.store_name, slug: s.slug }));
+            }
+        }
+    }
+    // Fallback 2: store_members table
+    const { data: memberships } = await client
+        .from("store_members")
+        .select("store_id")
+        .eq("user_id", userId);
+    if (memberships && memberships.length > 0) {
+        const storeIds = memberships.map((m) => m.store_id);
+        const { data: memberStores } = await client
+            .from("stores")
+            .select("id, store_name, slug")
+            .in("id", storeIds);
+        if (memberStores && memberStores.length > 0) {
+            return memberStores.map((s) => ({ id: s.id, name: s.store_name, slug: s.slug }));
         }
-        return [];
     }
-    return (stores || []).map((s) => ({ id: s.id, name: s.store_name, slug: s.slug }));
+    return [];
 }
 // Select a store and save to config
 export function selectStore(storeId, storeName) {

package/dist/cli/services/background-processes.js

@@ -250,8 +250,32 @@ export function readAgentOutput(id) {
     if (!agent)
         return null;
     try {
-        const content = existsSync(agent.outputFile) ? readFileSync(agent.outputFile, "utf-8") : "(no output yet)";
-        return { status: agent.status, output: content };
+        const raw = existsSync(agent.outputFile) ? readFileSync(agent.outputFile, "utf-8") : "";
+        if (!raw)
+            return { status: agent.status, output: "(no output yet)" };
+        // Parse ---DONE--- sentinel: extract .output from the JSON blob after it
+        const doneIdx = raw.indexOf("\n---DONE---\n");
+        if (doneIdx !== -1) {
+            try {
+                const json = JSON.parse(raw.slice(doneIdx + "\n---DONE---\n".length).trim());
+                const clean = (json.output || json.result || json.message || "").toString().trim();
+                return { status: agent.status, output: clean || raw.slice(0, doneIdx).trim() };
+            }
+            catch {
+                // JSON parse failed — return content before sentinel
+                return { status: agent.status, output: raw.slice(0, doneIdx).trim() };
+            }
+        }
+        // Parse ---ERROR--- sentinel
+        const errIdx = raw.indexOf("\n---ERROR---\n");
+        if (errIdx !== -1) {
+            const errMsg = raw.slice(errIdx + "\n---ERROR---\n".length).trim();
+            return { status: agent.status, output: errMsg || raw.slice(0, errIdx).trim() };
+        }
+        // Still running — strip the "Agent X started" header line
+        const lines = raw.split("\n");
+        const content = lines[0]?.startsWith("Agent ") ? lines.slice(1).join("\n").trim() : raw.trim();
+        return { status: agent.status, output: content || "(running...)" };
     }
     catch {
         return { status: agent.status, output: "(failed to read output file)" };

package/dist/cli/services/config-store.d.ts

@@ -1,10 +1,12 @@
 /**
  * Config Store
  *
- * Persistent configuration at ~/.swagmanager/config.json
+ * Unified auth session at ~/.whaletools/session.json
+ * User preferences at ~/.whaletools/preferences.json
  *
  * v2.0: Raw Supabase/Anthropic keys (for MCP server env vars)
  * v2.1: Auth tokens from login flow (for CLI chat/status)
+ * v4.0: Shared auth with Swift apps via ~/.whaletools/session.json
  *
  * Environment variables always override file-based config for MCP server mode.
  */
@@ -26,10 +28,20 @@ export interface SwagManagerConfig {
     agent_api_key?: string;
     platform_url?: string;
 }
+/** Preferences that survive sign-out (stored in preferences.json) */
+export interface WhalePreferences {
+    default_model?: string;
+    thinking_enabled?: boolean;
+    permission_mode?: string;
+    platform_url?: string;
+    theme?: string;
+}
 export declare function loadConfig(): SwagManagerConfig;
 export declare function saveConfig(config: SwagManagerConfig): void;
 export declare function updateConfig(partial: Partial<SwagManagerConfig>): void;
 export declare function clearConfig(): void;
+export declare function loadPreferences(): WhalePreferences;
+export declare function savePreferences(prefs: WhalePreferences): void;
 export interface ResolvedConfig {
     supabaseUrl: string;
     supabaseKey: string;