@dreb/coding-agent 2.34.3 → 2.35.0

package/dist/modes/rpc/rpc-mode.js

@@ -11,16 +11,544 @@
  * - Extension UI: Extension UI requests are emitted, client responds with extension_ui_response
  */
 import * as crypto from "node:crypto";
+import { basename } from "node:path";
+import { isValidThinkingLevel, VALID_THINKING_LEVELS } from "../../cli/args.js";
 import { VERSION } from "../../config.js";
+import { DailyCostTracker } from "../../core/daily-cost-tracker.js";
+import { getGitBranch } from "../../core/git-branch.js";
 import { parseModelPattern } from "../../core/model-resolver.js";
 import { takeOverStdout, writeRawStdout } from "../../core/output-guard.js";
 import { SessionManager } from "../../core/session-manager.js";
+import { TabTitleGenerator } from "../../core/tab-title.js";
+import { discoverAgentTypes, getBackgroundAgents, rehydrateBackgroundAgentsFromDisk, } from "../../core/tools/subagent.js";
 import { theme } from "../interactive/theme/theme.js";
 import { attachJsonlLineReader, serializeJsonLine } from "./jsonl.js";
+/**
+ * Map a core {@link SessionInfo} to the RPC DTO, converting Date fields to ISO strings.
+ * Shared by the `list_sessions` and `list_all_sessions` handlers so their shapes cannot drift.
+ */
+export function toRpcSessionInfo(s) {
+    return {
+        path: s.path,
+        id: s.id,
+        cwd: s.cwd,
+        name: s.name,
+        created: s.created.toISOString(),
+        modified: s.modified.toISOString(),
+        messageCount: s.messageCount,
+        firstMessage: s.firstMessage,
+    };
+}
 export function getPerformanceStatsData(session) {
     const tracker = session.getPerformanceTracker();
     return { models: tracker.getAllRollingAverages() };
 }
+export function getScopedModelsForRpc(session) {
+    return session.scopedModels.map(({ model, thinkingLevel }) => ({
+        provider: model.provider,
+        id: model.id,
+        name: model.name,
+        reasoning: model.reasoning,
+        thinkingLevel,
+    }));
+}
+export function getResourcesForRpc(session) {
+    const extensionsResult = session.resourceLoader.getExtensions();
+    return {
+        contextFiles: session.resourceLoader.getAgentsFiles().agentsFiles.map((file) => ({ path: file.path })),
+        skills: session.getFilteredSkills().map((skill) => ({ name: skill.name, description: skill.description })),
+        extensions: extensionsResult.extensions.map((extension) => ({
+            path: extension.path,
+            name: extension.sourceInfo.source || basename(extension.path),
+        })),
+        promptTemplates: session.promptTemplates.map((template) => ({
+            name: template.name,
+            description: template.description,
+        })),
+        systemPromptPresent: session.resourceLoader.getSystemPrompt() !== undefined ||
+            session.resourceLoader.getAppendSystemPrompt().length > 0,
+    };
+}
+export function getPendingMessagesForRpc(session) {
+    return {
+        steering: [...session.getSteeringMessages()],
+        followUp: [...session.getFollowUpMessages()],
+        steeringMessages: session.getSteeringMessagePayloads().map((message) => ({
+            text: message.text,
+            images: message.images ? [...message.images] : undefined,
+        })),
+        followUpMessages: session.getFollowUpMessagePayloads().map((message) => ({
+            text: message.text,
+            images: message.images ? [...message.images] : undefined,
+        })),
+    };
+}
+export function getStateForRpc(session, modelFallbackMessage) {
+    return {
+        model: session.model,
+        scopedModels: getScopedModelsForRpc(session),
+        usingSubscription: session.model ? session.modelRegistry.isUsingOAuth(session.model) : false,
+        thinkingLevel: session.thinkingLevel,
+        isStreaming: session.isStreaming,
+        isCompacting: session.isCompacting,
+        steeringMode: session.steeringMode,
+        followUpMode: session.followUpMode,
+        sessionFile: session.sessionFile,
+        sessionId: session.sessionId,
+        sessionName: session.sessionName,
+        autoCompactionEnabled: session.autoCompactionEnabled,
+        messageCount: session.messages.length,
+        pendingMessageCount: session.pendingMessageCount,
+        contextUsage: session.getContextUsage(),
+        modelFallbackMessage,
+    };
+}
+/**
+ * Handle the `delete_session` RPC command: wires the active session into the core
+ * {@link SessionManager.deleteSession} guard and maps the result to a discriminated
+ * union the handler serializes. Extracted (like {@link getPerformanceStatsData}) so the guard
+ * wiring is unit-testable without a live RPC session. Note: the authoritative active-session
+ * guard lives in core — this passes the active path through; it does not re-implement it.
+ * Uses the same unrestricted path-based addressing as `switch_session` (no containment guard —
+ * see PR #315 discussion).
+ */
+export async function deleteSessionForRpc(sessionManager, sessionPath) {
+    const activePath = sessionManager.getSessionFile();
+    const result = await SessionManager.deleteSession(sessionPath, {
+        activeSessionPath: activePath,
+    });
+    if (!result.ok) {
+        return { ok: false, error: result.error ?? "Unknown deletion error" };
+    }
+    return { ok: true, method: result.method };
+}
+/** Handle the `list_all_sessions` RPC command: list every project's sessions as RPC DTOs. */
+export async function listAllSessionsForRpc() {
+    const sessions = await SessionManager.listAll();
+    return sessions.map(toRpcSessionInfo);
+}
+/**
+ * Map a {@link BackgroundAgentInfo} registry entry to the RPC DTO, converting the
+ * epoch-ms timestamp to an ISO string. Shared shape guard for `list_background_agents`.
+ */
+export function toRpcBackgroundAgentInfo(a) {
+    return {
+        agentId: a.agentId,
+        agentType: a.agentType,
+        taskSummary: a.taskSummary,
+        startedAt: new Date(a.startedAt).toISOString(),
+        status: a.status,
+        sessionDir: a.sessionDir,
+        sessionFile: a.sessionFile,
+        cwd: a.cwd,
+    };
+}
+/** Discover available subagent types for RPC clients, sorted by display name. */
+export function listAgentTypesForRpc(cwd) {
+    return [...discoverAgentTypes(cwd).values()]
+        .map(({ name, description }) => ({ name, description }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+ * Handle the `get_settings` RPC command: snapshot the persistent default settings.
+ *
+ * Reads the SettingsManager's merged (global + project) view — these are the values that
+ * seed fresh runtimes, NOT the live session state (`get_state` reports that). Extracted
+ * (like {@link deleteSessionForRpc}) so it is unit-testable without a live RPC session.
+ */
+export function getSettingsForRpc(settingsManager) {
+    return {
+        defaultProvider: settingsManager.getDefaultProvider(),
+        defaultModel: settingsManager.getDefaultModel(),
+        defaultThinkingLevel: settingsManager.getDefaultThinkingLevel(),
+        steeringMode: settingsManager.getSteeringMode(),
+        followUpMode: settingsManager.getFollowUpMode(),
+        compactionEnabled: settingsManager.getCompactionEnabled(),
+        retryEnabled: settingsManager.getRetryEnabled(),
+        imageAutoResize: settingsManager.getImageAutoResize(),
+        blockImages: settingsManager.getBlockImages(),
+        enableSkillCommands: settingsManager.getEnableSkillCommands(),
+        autoLoadNestedContext: settingsManager.getAutoLoadNestedContext(),
+        transport: settingsManager.getTransport(),
+        hideThinkingBlock: settingsManager.getHideThinkingBlock(),
+        agentModels: settingsManager.getAgentModels(),
+    };
+}
+const SETTINGS_UPDATE_KEYS = [
+    "defaultProvider",
+    "defaultModel",
+    "defaultThinkingLevel",
+    "steeringMode",
+    "followUpMode",
+    "compactionEnabled",
+    "retryEnabled",
+    "imageAutoResize",
+    "blockImages",
+    "enableSkillCommands",
+    "autoLoadNestedContext",
+    "transport",
+    "hideThinkingBlock",
+    "agentModels",
+];
+const QUEUE_MODES = ["all", "one-at-a-time"];
+const TRANSPORT_SETTINGS = ["sse", "websocket", "auto"];
+function isPlainObject(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+function validateAgentModels(value) {
+    if (!isPlainObject(value)) {
+        return {
+            ok: false,
+            error: "Invalid agentModels: must be a plain object mapping agent names to model fallback arrays",
+        };
+    }
+    for (const [agentName, models] of Object.entries(value)) {
+        if (!Array.isArray(models)) {
+            return {
+                ok: false,
+                error: `Invalid agentModels[${JSON.stringify(agentName)}]: expected an array of non-empty strings`,
+            };
+        }
+        const invalidModel = models.find((model) => typeof model !== "string" || model.trim().length === 0);
+        if (invalidModel !== undefined) {
+            return {
+                ok: false,
+                error: `Invalid agentModels[${JSON.stringify(agentName)}]: expected an array of non-empty strings`,
+            };
+        }
+    }
+    return { ok: true };
+}
+/**
+ * Simple promise-based mutex that serializes settings writes. RPC commands are dispatched
+ * concurrently (`void handleInputLine(line)`) so two `set_settings` commands can overlap.
+ * Without serialization, concurrent commands race on SettingsManager's shared error bucket
+ * (`drainErrors()` clears the array for everyone): the first to drain takes all errors
+ * (including the second's), and the second reports false success despite its write failing.
+ *
+ * This lock ensures only one apply+flush+drain block runs at a time — each `set_settings`
+ * gets an error window isolated from other `set_settings` commands and from stale errors.
+ *
+ * Known limitation: the lock does NOT cover the per-runtime commands (`set_model`,
+ * `set_steering_mode`, etc.), which persist through the same SettingsManager write queue
+ * and record failures into the same shared error bucket. Because `flush()` awaits the
+ * entire shared queue, a concurrent runtime setter's write failure can land in this
+ * operation's post-flush drain window and be reported as a `set_settings` failure (loud
+ * but mis-attributed — never a silent success). Per-operation error isolation in
+ * SettingsManager is the proper fix and is tracked in
+ * https://github.com/aebrer/dreb/issues/319.
+ */
+let settingsWriteQueue = Promise.resolve();
+function settingsWriteLock(fn) {
+    const prev = settingsWriteQueue;
+    const next = prev.then(fn, fn);
+    settingsWriteQueue = next.catch(() => { });
+    return next;
+}
+/**
+ * Handle the `set_settings` RPC command: validate and persist default settings.
+ *
+ * Writes persistent defaults via SettingsManager only — never touches live session state
+ * (the existing per-runtime commands do that). The whole payload is validated before
+ * anything is applied: on any invalid field, nothing changes.
+ *
+ * Persistence is verified loudly: if the settings file failed to load at startup,
+ * SettingsManager.save() silently no-ops — this handler reports that as an error instead
+ * of returning success while nothing was written. Write failures surface the same way.
+ *
+ * The apply+flush+drain block is serialized via {@link settingsWriteLock} so that
+ * concurrent `set_settings` commands (dispatched concurrently by the RPC input loop)
+ * cannot race on the shared error bucket. Pre-existing stale errors (from other commands
+ * like `set_model` that record write failures but never drain) are discarded before
+ * applying. See the {@link settingsWriteLock} doc for the remaining attribution caveat
+ * with runtime setters that write concurrently during the flush window.
+ */
+export async function setSettingsForRpc(settingsManager, modelRegistry, update) {
+    // --- Validate everything first; apply nothing on any failure ---
+    if (update === undefined || update === null || typeof update !== "object" || Array.isArray(update)) {
+        return { ok: false, error: "set_settings requires a settings object" };
+    }
+    const unknownKeys = Object.keys(update).filter((key) => !SETTINGS_UPDATE_KEYS.includes(key));
+    if (unknownKeys.length > 0) {
+        return {
+            ok: false,
+            error: `Unknown settings key(s): ${unknownKeys.join(", ")}. Valid keys: ${SETTINGS_UPDATE_KEYS.join(", ")}`,
+        };
+    }
+    const hasAnySetting = SETTINGS_UPDATE_KEYS.some((key) => update[key] !== undefined);
+    if (!hasAnySetting) {
+        return { ok: false, error: "set_settings requires at least one setting to change" };
+    }
+    if (update.defaultThinkingLevel !== undefined) {
+        if (typeof update.defaultThinkingLevel !== "string" || !isValidThinkingLevel(update.defaultThinkingLevel)) {
+            return {
+                ok: false,
+                error: `Invalid defaultThinkingLevel: ${JSON.stringify(update.defaultThinkingLevel)}. Valid values: ${VALID_THINKING_LEVELS.join(", ")}`,
+            };
+        }
+    }
+    for (const key of ["steeringMode", "followUpMode"]) {
+        const value = update[key];
+        if (value !== undefined && !QUEUE_MODES.includes(value)) {
+            return {
+                ok: false,
+                error: `Invalid ${key}: ${JSON.stringify(value)}. Valid values: ${QUEUE_MODES.join(", ")}`,
+            };
+        }
+    }
+    for (const key of [
+        "compactionEnabled",
+        "retryEnabled",
+        "imageAutoResize",
+        "blockImages",
+        "enableSkillCommands",
+        "autoLoadNestedContext",
+        "hideThinkingBlock",
+    ]) {
+        const value = update[key];
+        if (value !== undefined && typeof value !== "boolean") {
+            return { ok: false, error: `Invalid ${key}: ${JSON.stringify(value)}. Must be a boolean` };
+        }
+    }
+    if (update.transport !== undefined) {
+        if (typeof update.transport !== "string" ||
+            !TRANSPORT_SETTINGS.includes(update.transport)) {
+            return {
+                ok: false,
+                error: `Invalid transport: ${JSON.stringify(update.transport)}. Valid values: ${TRANSPORT_SETTINGS.join(", ")}`,
+            };
+        }
+    }
+    if (update.agentModels !== undefined) {
+        const validation = validateAgentModels(update.agentModels);
+        if (!validation.ok) {
+            return validation;
+        }
+    }
+    const hasProvider = update.defaultProvider !== undefined;
+    const hasModel = update.defaultModel !== undefined;
+    if (hasProvider !== hasModel) {
+        return {
+            ok: false,
+            error: "defaultProvider and defaultModel must be set together",
+        };
+    }
+    if (hasProvider && hasModel) {
+        if (typeof update.defaultProvider !== "string" || typeof update.defaultModel !== "string") {
+            return { ok: false, error: "defaultProvider and defaultModel must be strings" };
+        }
+        const models = await modelRegistry.getAvailable();
+        const match = models.find((m) => m.provider === update.defaultProvider && m.id === update.defaultModel);
+        if (!match) {
+            return {
+                ok: false,
+                error: `Model not found: ${update.defaultProvider}/${update.defaultModel}`,
+            };
+        }
+    }
+    // Serialize the apply+flush+drain block so concurrent set_settings commands
+    // cannot race on the shared error bucket. See settingsWriteLock doc.
+    return settingsWriteLock(async () => {
+        // Discard stale errors left by other operations (set_model, set_steering_mode, etc.)
+        // that record write failures into SettingsManager's shared error bucket but never
+        // drain it. Without this, we'd mis-attribute their failures to this operation.
+        settingsManager.drainErrors();
+        // Persisting would silently no-op if the settings file failed to load — fail loudly
+        // instead. Checked INSIDE the lock (after the stale-error discard) so a concurrent
+        // reload() that flips the load-error state cannot slip between check and apply and
+        // turn this write into a silent no-op reported as success.
+        if (settingsManager.hasGlobalSettingsLoadError()) {
+            return {
+                ok: false,
+                error: "Cannot write settings: the global settings file failed to load (fix or remove the corrupt settings.json first)",
+            };
+        }
+        // --- Apply (validated) ---
+        if (update.defaultProvider !== undefined && update.defaultModel !== undefined) {
+            settingsManager.setDefaultModelAndProvider(update.defaultProvider, update.defaultModel);
+        }
+        if (update.defaultThinkingLevel !== undefined) {
+            settingsManager.setDefaultThinkingLevel(update.defaultThinkingLevel);
+        }
+        if (update.steeringMode !== undefined) {
+            settingsManager.setSteeringMode(update.steeringMode);
+        }
+        if (update.followUpMode !== undefined) {
+            settingsManager.setFollowUpMode(update.followUpMode);
+        }
+        if (update.compactionEnabled !== undefined) {
+            settingsManager.setCompactionEnabled(update.compactionEnabled);
+        }
+        if (update.retryEnabled !== undefined) {
+            settingsManager.setRetryEnabled(update.retryEnabled);
+        }
+        if (update.imageAutoResize !== undefined) {
+            settingsManager.setImageAutoResize(update.imageAutoResize);
+        }
+        if (update.blockImages !== undefined) {
+            settingsManager.setBlockImages(update.blockImages);
+        }
+        if (update.enableSkillCommands !== undefined) {
+            settingsManager.setEnableSkillCommands(update.enableSkillCommands);
+        }
+        if (update.autoLoadNestedContext !== undefined) {
+            settingsManager.setAutoLoadNestedContext(update.autoLoadNestedContext);
+        }
+        if (update.transport !== undefined) {
+            settingsManager.setTransport(update.transport);
+        }
+        if (update.hideThinkingBlock !== undefined) {
+            settingsManager.setHideThinkingBlock(update.hideThinkingBlock);
+        }
+        const warnings = [];
+        if (update.agentModels !== undefined) {
+            for (const [agentName, models] of Object.entries(update.agentModels)) {
+                if (settingsManager.hasProjectAgentModelOverride(agentName)) {
+                    warnings.push(`A project-level agentModels override for ${JSON.stringify(agentName)} (.dreb/settings.json) ` +
+                        "takes precedence — this change to global settings will have no effect. " +
+                        "Edit the project settings file to change it.");
+                }
+                if (models.length > 0) {
+                    settingsManager.setAgentModelsForAgent(agentName, models);
+                }
+                else {
+                    settingsManager.removeAgentModelsForAgent(agentName);
+                }
+            }
+        }
+        // Ensure durability and surface write errors instead of losing them.
+        await settingsManager.flush();
+        const writeErrors = settingsManager.drainErrors();
+        if (writeErrors.length > 0) {
+            const detail = writeErrors.map((e) => `${e.scope}: ${e.error.message}`).join("; ");
+            return { ok: false, error: `Failed to persist settings: ${detail}` };
+        }
+        return warnings.length > 0
+            ? { ok: true, settings: getSettingsForRpc(settingsManager), warnings }
+            : { ok: true, settings: getSettingsForRpc(settingsManager) };
+    });
+}
+function normalizePreview(text) {
+    return text.replace(/\s+/g, " ").trim().slice(0, 200);
+}
+function extractTextContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    let text = "";
+    for (const part of content) {
+        if (typeof part === "object" &&
+            part !== null &&
+            "type" in part &&
+            part.type === "text" &&
+            "text" in part &&
+            typeof part.text === "string") {
+            text += part.text;
+        }
+    }
+    return text;
+}
+function getRpcEntryPreview(node) {
+    const entry = node.entry;
+    switch (entry.type) {
+        case "message": {
+            const msg = entry.message;
+            const role = msg.role;
+            if (role === "user") {
+                return normalizePreview(extractTextContent(msg.content));
+            }
+            if (role === "assistant") {
+                const textContent = normalizePreview(extractTextContent(msg.content));
+                if (textContent)
+                    return textContent;
+                if (msg.stopReason === "aborted")
+                    return "(aborted)";
+                if (msg.errorMessage)
+                    return normalizePreview(msg.errorMessage);
+                return "(no content)";
+            }
+            if (role === "toolResult") {
+                return normalizePreview(`[${msg.toolName ?? "tool"}]`);
+            }
+            if (role === "bashExecution") {
+                return normalizePreview(`[bash]: ${msg.command ?? ""}`);
+            }
+            return normalizePreview(`[${role}]`);
+        }
+        case "custom_message":
+            return normalizePreview(`[${entry.customType}]: ${extractTextContent(entry.content)}`);
+        case "compaction":
+            return normalizePreview(`[compaction: ${Math.round(entry.tokensBefore / 1000)}k tokens]`);
+        case "branch_summary":
+            return normalizePreview(`[branch summary]: ${entry.summary}`);
+        case "model_change":
+            return normalizePreview(`[model: ${entry.modelId}]`);
+        case "thinking_level_change":
+            return normalizePreview(`[thinking: ${entry.thinkingLevel}]`);
+        case "custom":
+            return normalizePreview(`[custom: ${entry.customType}]`);
+        case "label":
+            return normalizePreview(`[label: ${entry.label ?? "(cleared)"}]`);
+        case "session_info":
+            return normalizePreview(`[title: ${entry.name || "empty"}]`);
+        default: {
+            // Compile-time exhaustiveness guard: a new SessionEntry type forces an update here.
+            const _exhaustive = entry;
+            // Runtime: unknown types from forward-compat/corrupt session files get a placeholder.
+            return normalizePreview(`[${entry.type}]`);
+        }
+    }
+}
+function toRpcTreeNode(node) {
+    const role = node.entry.type === "message" ? String(node.entry.message.role) : undefined;
+    return {
+        id: node.entry.id,
+        parentId: node.entry.parentId,
+        type: node.entry.type,
+        ...(role !== undefined ? { role } : {}),
+        preview: getRpcEntryPreview(node),
+        timestamp: node.entry.timestamp,
+        ...(node.label !== undefined ? { label: node.label } : {}),
+        children: [],
+    };
+}
+/**
+ * Map core session tree nodes to stable RPC DTOs without leaking raw entries/messages.
+ * Uses an explicit stack so deep linear session trees do not overflow the JS call stack.
+ */
+export function toRpcTreeNodes(nodes) {
+    const roots = [];
+    const stack = [];
+    for (let i = nodes.length - 1; i >= 0; i--) {
+        stack.push({ source: nodes[i], targetSiblings: roots });
+    }
+    while (stack.length > 0) {
+        const { source, targetSiblings } = stack.pop();
+        const dto = toRpcTreeNode(source);
+        targetSiblings.push(dto);
+        for (let i = source.children.length - 1; i >= 0; i--) {
+            stack.push({ source: source.children[i], targetSiblings: dto.children });
+        }
+    }
+    return roots;
+}
+/** Return the current session tree and active leaf as RPC DTOs. */
+export function getTreeForRpc(sessionManager) {
+    return { roots: toRpcTreeNodes(sessionManager.getTree()), leafId: sessionManager.getLeafId() };
+}
+/** Navigate the active session tree, returning only the stable RPC result fields. */
+export async function navigateTreeForRpc(session, targetId, options) {
+    const result = await session.navigateTree(targetId, options ?? {});
+    return {
+        cancelled: result.cancelled,
+        ...(result.editorText !== undefined ? { editorText: result.editorText } : {}),
+    };
+}
 /**
  * Run in RPC mode.
  * Listens for JSON commands on stdin, outputs events and responses on stdout.
@@ -39,10 +567,18 @@ export async function runRpcMode(session, modelFallbackMessage) {
     const error = (id, command, message) => {
         return { id, type: "response", command, success: false, error: message };
     };
+    if (session.sessionFile && session.messages.length > 0) {
+        const rehydratedCount = rehydrateBackgroundAgentsFromDisk(session.sessionFile);
+        if (rehydratedCount > 0) {
+            console.error(`[rpc] Rehydrated ${rehydratedCount} background subagent${rehydratedCount === 1 ? "" : "s"} from disk`);
+        }
+    }
     // Pending extension UI requests waiting for response
     const pendingExtensionRequests = new Map();
     // Shutdown request flag
     let shutdownRequested = false;
+    let dailyCostTracker;
+    let dailyCostTrackerPrimed = false;
     /** Helper for dialog methods with signal/timeout support */
     function createDialogPromise(opts, defaultValue, request, parseResponse) {
         if (opts?.signal?.aborted)
@@ -244,8 +780,51 @@ export async function runRpcMode(session, modelFallbackMessage) {
             output({ type: "extension_error", extensionPath: err.extensionPath, event: err.event, error: err.error });
         },
     });
+    const getDailyCost = async () => {
+        dailyCostTracker ??= new DailyCostTracker();
+        if (!dailyCostTrackerPrimed) {
+            await dailyCostTracker.refresh();
+            dailyCostTrackerPrimed = true;
+        }
+        return dailyCostTracker.getDailyCost();
+    };
+    const cwd = session.sessionManager.getCwd();
+    const tabTitleSettings = session.settingsManager.getTabTitleSettings();
+    const tabTitleGenerator = !session.sessionName && tabTitleSettings?.enabled !== false
+        ? new TabTitleGenerator(tabTitleSettings, {
+            setTitle: () => { },
+            setSessionName: (name) => {
+                if (!session.sessionName) {
+                    session.setSessionName(name);
+                }
+            },
+            getMessages: () => session.messages,
+            getModel: () => session.model,
+            getModelRegistry: () => session.modelRegistry,
+            getProvider: () => session.model?.provider,
+            getAgentModelsOverride: (name) => session.settingsManager.getAgentModelsForAgent(name),
+            getBranch: () => getGitBranch(cwd),
+            getRepo: () => basename(cwd),
+            getCwd: () => cwd,
+            onError: (err) => {
+                console.error(`[rpc] Tab title auto-generation failed: ${err instanceof Error ? err.message : String(err)}`);
+            },
+        })
+        : undefined;
     // Output all agent events as JSON
     session.subscribe((event) => {
+        if (tabTitleGenerator && !session.sessionName) {
+            if (event.type === "tool_execution_end") {
+                tabTitleGenerator.onToolEnd({
+                    toolName: event.toolName,
+                    isError: event.isError,
+                    result: event.result,
+                });
+            }
+            else if (event.type === "message_end") {
+                tabTitleGenerator.onMessageEnd(event.message);
+            }
+        }
         output(event);
     });
     // Handle a single command
@@ -291,22 +870,16 @@ export async function runRpcMode(session, modelFallbackMessage) {
             // State
             // =================================================================
             case "get_state": {
-                const state = {
-                    model: session.model,
-                    thinkingLevel: session.thinkingLevel,
-                    isStreaming: session.isStreaming,
-                    isCompacting: session.isCompacting,
-                    steeringMode: session.steeringMode,
-                    followUpMode: session.followUpMode,
-                    sessionFile: session.sessionFile,
-                    sessionId: session.sessionId,
-                    sessionName: session.sessionName,
-                    autoCompactionEnabled: session.autoCompactionEnabled,
-                    messageCount: session.messages.length,
-                    pendingMessageCount: session.pendingMessageCount,
-                    modelFallbackMessage,
-                };
-                return success(id, "get_state", state);
+                return success(id, "get_state", getStateForRpc(session, modelFallbackMessage));
+            }
+            case "get_resources": {
+                return success(id, "get_resources", getResourcesForRpc(session));
+            }
+            case "get_git_branch": {
+                return success(id, "get_git_branch", { branch: getGitBranch(session.sessionManager.getCwd()) });
+            }
+            case "get_daily_cost": {
+                return success(id, "get_daily_cost", { cost: await getDailyCost() });
             }
             // =================================================================
             // Model
@@ -400,6 +973,12 @@ export async function runRpcMode(session, modelFallbackMessage) {
                 session.setFollowUpMode(command.mode);
                 return success(id, "set_follow_up_mode");
             }
+            case "get_pending_messages": {
+                return success(id, "get_pending_messages", getPendingMessagesForRpc(session));
+            }
+            case "clear_pending_messages": {
+                return success(id, "clear_pending_messages", session.clearQueue());
+            }
             // =================================================================
             // Compaction
             // =================================================================
@@ -411,6 +990,10 @@ export async function runRpcMode(session, modelFallbackMessage) {
                 session.setAutoCompactionEnabled(command.enabled);
                 return success(id, "set_auto_compaction");
             }
+            case "abort_compaction": {
+                session.abortCompaction();
+                return success(id, "abort_compaction");
+            }
             // =================================================================
             // Retry
             // =================================================================
@@ -451,6 +1034,13 @@ export async function runRpcMode(session, modelFallbackMessage) {
                 const cancelled = !(await session.switchSession(command.sessionPath));
                 return success(id, "switch_session", { cancelled });
             }
+            case "delete_session": {
+                const result = await deleteSessionForRpc(session.sessionManager, command.sessionPath);
+                if (!result.ok) {
+                    return error(id, "delete_session", result.error);
+                }
+                return success(id, "delete_session", { method: result.method });
+            }
             case "fork": {
                 const result = await session.fork(command.entryId);
                 return success(id, "fork", { text: result.selectedText, cancelled: result.cancelled });
@@ -459,6 +1049,23 @@ export async function runRpcMode(session, modelFallbackMessage) {
                 const messages = session.getUserMessagesForForking();
                 return success(id, "get_fork_messages", { messages });
             }
+            case "get_tree": {
+                return success(id, "get_tree", getTreeForRpc(session.sessionManager));
+            }
+            case "navigate_tree": {
+                try {
+                    const result = await navigateTreeForRpc(session, command.targetId, {
+                        summarize: command.summarize,
+                        customInstructions: command.customInstructions,
+                        replaceInstructions: command.replaceInstructions,
+                        label: command.label,
+                    });
+                    return success(id, "navigate_tree", result);
+                }
+                catch (e) {
+                    return error(id, "navigate_tree", e instanceof Error ? e.message : String(e));
+                }
+            }
             case "get_last_assistant_text": {
                 const text = session.getLastAssistantText();
                 return success(id, "get_last_assistant_text", { text });
@@ -487,17 +1094,38 @@ export async function runRpcMode(session, modelFallbackMessage) {
                 const cwd = session.sessionManager.getCwd();
                 const sessionDir = session.sessionManager.getSessionDir();
                 const sessions = await SessionManager.list(cwd, sessionDir);
-                const data = sessions.map((s) => ({
-                    path: s.path,
-                    id: s.id,
-                    cwd: s.cwd,
-                    name: s.name,
-                    created: s.created.toISOString(),
-                    modified: s.modified.toISOString(),
-                    messageCount: s.messageCount,
-                    firstMessage: s.firstMessage,
-                }));
-                return success(id, "list_sessions", { sessions: data });
+                return success(id, "list_sessions", { sessions: sessions.map(toRpcSessionInfo) });
+            }
+            case "list_all_sessions": {
+                return success(id, "list_all_sessions", { sessions: await listAllSessionsForRpc() });
+            }
+            // =================================================================
+            // Background agents
+            // =================================================================
+            case "list_background_agents": {
+                return success(id, "list_background_agents", {
+                    agents: getBackgroundAgents().map(toRpcBackgroundAgentInfo),
+                });
+            }
+            case "list_agent_types": {
+                return success(id, "list_agent_types", {
+                    agentTypes: listAgentTypesForRpc(session.sessionManager.getCwd()),
+                });
+            }
+            // =================================================================
+            // Settings (persistent defaults)
+            // =================================================================
+            case "get_settings": {
+                return success(id, "get_settings", getSettingsForRpc(session.settingsManager));
+            }
+            case "set_settings": {
+                const result = await setSettingsForRpc(session.settingsManager, session.modelRegistry, command.settings);
+                if (!result.ok) {
+                    return error(id, "set_settings", result.error);
+                }
+                return success(id, "set_settings", result.warnings && result.warnings.length > 0
+                    ? { ...result.settings, warnings: result.warnings }
+                    : result.settings);
             }
             // =================================================================
             // Version
@@ -549,6 +1177,7 @@ export async function runRpcMode(session, modelFallbackMessage) {
         if (currentRunner?.hasHandlers("session_shutdown")) {
             await currentRunner.emit({ type: "session_shutdown" });
         }
+        dailyCostTracker?.dispose();
         detachInput();
         process.stdin.pause();
         process.exit(0);