pikiloop 0.4.0

package/dist/agent/drivers/gemini.js

@@ -0,0 +1,1059 @@
+/**
+ * driver-gemini.ts — Gemini CLI agent driver.
+ *
+ * Requires `gemini` CLI installed (https://github.com/google-gemini/gemini-cli).
+ * Stream protocol: spawns `gemini` with JSON output and parses stdout line-by-line.
+ */
+import { registerDriver } from '../driver.js';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { GEMINI_USAGE_TIMEOUTS, SESSION_RUNNING_THRESHOLD_MS } from '../../core/constants.js';
+import { run, agentLog, appendSystemPrompt, pushRecentActivity, firstNonEmptyLine, shortValue, normalizeErrorMessage, sanitizeSessionUserPreviewText, emitSessionIdUpdate, listPikiloopSessions, mergeManagedAndNativeSessions, applyTurnWindow, stripInjectedPrompts, attachAgentImage, roundPercent, emptyUsage, Q, } from '../index.js';
+import { getHome } from '../../core/platform.js';
+// ---------------------------------------------------------------------------
+// Command & parser
+// ---------------------------------------------------------------------------
+function hasGeminiFlag(args, names) {
+    if (!args?.length)
+        return false;
+    return args.some(arg => {
+        const trimmed = String(arg || '').trim();
+        if (!trimmed.startsWith('-'))
+            return false;
+        return names.some(name => trimmed === name || trimmed.startsWith(`${name}=`));
+    });
+}
+// Gemini CLI's -p mode is text-only — there's no flag for binary inputs. The
+// CLI does, however, parse `@<path>` references in the prompt and inlines the
+// file's content (text or image) into the model's context. We splice those
+// references at the front of the prompt so attachments survive the trip.
+export function buildGeminiPromptText(prompt, attachments) {
+    if (!attachments.length)
+        return prompt;
+    // Quote paths that contain spaces — gemini's tokenizer reads `@"..."` as a
+    // single reference. Plain paths can be left bare for cleaner display.
+    const refs = attachments.map(p => /\s/.test(p) ? `@"${p}"` : `@${p}`).join(' ');
+    return prompt ? `${refs}\n\n${prompt}` : refs;
+}
+function geminiCmd(o) {
+    const approvalMode = o.geminiApprovalMode || 'yolo';
+    const sandbox = typeof o.geminiSandbox === 'boolean' ? o.geminiSandbox : false;
+    const args = ['gemini', '--output-format', 'stream-json'];
+    if (o.geminiModel)
+        args.push('--model', o.geminiModel);
+    if (o.sessionId)
+        args.push('--resume', o.sessionId);
+    if (!hasGeminiFlag(o.geminiExtraArgs, ['--approval-mode', '--yolo', '-y'])) {
+        args.push('--approval-mode', approvalMode);
+    }
+    if (!hasGeminiFlag(o.geminiExtraArgs, ['--sandbox', '-s'])) {
+        args.push('--sandbox', String(sandbox));
+    }
+    if (o.geminiExtraArgs?.length)
+        args.push(...o.geminiExtraArgs);
+    // gemini's -p requires the prompt as its value (not via stdin)
+    const userPrompt = buildGeminiPromptText(o.prompt, o.attachments || []);
+    const promptText = o.geminiSystemInstruction
+        ? appendSystemPrompt(o.geminiSystemInstruction, userPrompt)
+        : userPrompt;
+    args.push('-p', promptText);
+    return args;
+}
+function geminiContextWindowFromModel(model) {
+    const id = typeof model === 'string' ? model.trim().toLowerCase() : '';
+    if (!id)
+        return null;
+    if (/^(auto-gemini-(2\.5|3)|gemini-(2\.5|3|3\.1)-)/.test(id))
+        return 1_048_576;
+    return null;
+}
+function geminiToolName(value) {
+    const name = typeof value === 'string' ? value.trim() : '';
+    return name || 'tool';
+}
+function geminiToolLabel(name) {
+    return name
+        .replace(/^mcp_/, '')
+        .replace(/^discovered_tool_/, '')
+        .replace(/_/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim() || 'tool';
+}
+function geminiToolSummary(name, parameters) {
+    const tool = geminiToolName(name);
+    const params = parameters && typeof parameters === 'object' ? parameters : {};
+    switch (tool) {
+        case 'read_file': {
+            const target = shortValue(params.file_path || params.path, 140);
+            return target ? `Read ${target}` : 'Read file';
+        }
+        case 'read_many_files': {
+            const include = shortValue(params.include || params.pattern, 120);
+            return include ? `Read files: ${include}` : 'Read files';
+        }
+        case 'write_file': {
+            const target = shortValue(params.file_path || params.path, 140);
+            return target ? `Write ${target}` : 'Write file';
+        }
+        case 'replace': {
+            const target = shortValue(params.file_path || params.path, 140);
+            return target ? `Edit ${target}` : 'Edit file';
+        }
+        case 'list_directory': {
+            const dir = shortValue(params.dir_path || params.path, 120);
+            return dir ? `List files: ${dir}` : 'List files';
+        }
+        case 'glob': {
+            const pattern = shortValue(params.pattern || params.glob, 120);
+            return pattern ? `Find files: ${pattern}` : 'Find files';
+        }
+        case 'grep_search':
+        case 'search_file_content': {
+            const pattern = shortValue(params.pattern || params.query, 120);
+            return pattern ? `Search text: ${pattern}` : 'Search text';
+        }
+        case 'run_shell_command': {
+            const command = shortValue(params.command, 120);
+            return command ? `Run shell: ${command}` : 'Run shell';
+        }
+        case 'web_fetch': {
+            const target = shortValue(params.url || params.prompt, 120);
+            return target ? `Fetch ${target}` : 'Fetch web page';
+        }
+        case 'google_web_search': {
+            const query = shortValue(params.query, 120);
+            return query ? `Search web: ${query}` : 'Search web';
+        }
+        case 'write_todos': return 'Update todo list';
+        case 'save_memory': return 'Save memory';
+        case 'ask_user': return 'Request user input';
+        case 'activate_skill': {
+            const skill = shortValue(params.name, 80);
+            return skill ? `Activate skill: ${skill}` : 'Activate skill';
+        }
+        case 'get_internal_docs': {
+            const target = shortValue(params.path, 120);
+            return target ? `Read docs: ${target}` : 'Read docs';
+        }
+        case 'enter_plan_mode': return 'Enter plan mode';
+        case 'exit_plan_mode': return 'Exit plan mode';
+        default: {
+            const detail = shortValue(params.file_path
+                || params.path
+                || params.dir_path
+                || params.pattern
+                || params.query
+                || params.command
+                || params.url
+                || params.name, 120);
+            const label = shortValue(geminiToolLabel(tool), 80);
+            return detail ? `Use ${label}: ${detail}` : `Use ${label}`;
+        }
+    }
+}
+function geminiToolResultSummary(tool, ev) {
+    const fallbackSummary = geminiToolSummary(tool?.name || ev.tool_name || ev.name || ev.tool, ev.parameters || ev.args || ev.input || {});
+    const summary = tool?.summary || fallbackSummary;
+    const detail = shortValue(firstNonEmptyLine(normalizeErrorMessage(ev.error)
+        || ev.output
+        || ev.message
+        || ''), 120);
+    if (ev.status === 'error')
+        return detail ? `${summary} failed: ${detail}` : `${summary} failed`;
+    return detail ? `${summary} -> ${detail}` : `${summary} done`;
+}
+function geminiParse(ev, s) {
+    const t = ev.type || '';
+    // init event: {"type":"init","session_id":"...","model":"..."}
+    if (t === 'init') {
+        emitSessionIdUpdate(s, ev.session_id);
+        s.model = ev.model ?? s.model;
+        s.contextWindow = geminiContextWindowFromModel(s.model) ?? s.contextWindow;
+        // Gemini's stream-json drops `thought` parts and every `agent_*`/`tool_update`
+        // event, so between init and the first tool_use/message there's nothing to
+        // surface — easily 10–30s on Gemini 3 Pro with HIGH thinking, longer when
+        // 429 backoffs kick in. Plant a sentinel so the IM/dashboard activity area
+        // shows progress instead of staying blank.
+        pushRecentActivity(s.recentActivity, 'Thinking...');
+        s.activity = s.recentActivity.join('\n');
+    }
+    // message delta: {"type":"message","role":"assistant","content":"...","delta":true}
+    if (t === 'message' && ev.role === 'assistant') {
+        if (ev.delta)
+            s.text += ev.content || '';
+        else if (!s.text.trim())
+            s.text = ev.content || '';
+    }
+    if (t === 'tool_use' || t === 'tool_call') {
+        const name = geminiToolName(ev.tool_name || ev.name || ev.tool);
+        const summary = geminiToolSummary(name, ev.parameters || ev.args || ev.input || {});
+        const toolId = String(ev.tool_id || ev.id || '').trim();
+        if (toolId)
+            s.geminiToolsById.set(toolId, { name, summary });
+        pushRecentActivity(s.recentActivity, summary);
+        s.activity = s.recentActivity.join('\n');
+    }
+    if (t === 'tool_result') {
+        const toolId = String(ev.tool_id || ev.id || '').trim();
+        const tool = toolId ? s.geminiToolsById.get(toolId) : undefined;
+        pushRecentActivity(s.recentActivity, geminiToolResultSummary(tool, ev));
+        s.activity = s.recentActivity.join('\n');
+    }
+    if (t === 'error') {
+        const message = normalizeErrorMessage(ev.message || ev.error) || 'Gemini reported an error';
+        if (ev.severity === 'error') {
+            s.errors = [...(s.errors || []), message];
+        }
+        else {
+            pushRecentActivity(s.recentActivity, message);
+            s.activity = s.recentActivity.join('\n');
+        }
+    }
+    // result event: {"type":"result","status":"success","stats":{...}}
+    if (t === 'result') {
+        emitSessionIdUpdate(s, ev.session_id);
+        if (ev.status === 'error' || ev.status === 'failure') {
+            const message = normalizeErrorMessage(ev.error)
+                || normalizeErrorMessage(ev.errors)
+                || normalizeErrorMessage(ev.message)
+                || `Gemini returned status: ${ev.status}`;
+            s.errors = [message];
+        }
+        s.stopReason = ev.status === 'success' ? 'end_turn' : ev.status;
+        const u = ev.stats;
+        if (u) {
+            s.inputTokens = u.input_tokens ?? u.input ?? s.inputTokens;
+            s.outputTokens = u.output_tokens ?? u.output ?? s.outputTokens;
+            s.cachedInputTokens = u.cached ?? s.cachedInputTokens;
+            // Gemini's `input_tokens` is the full prompt size (cached portion is
+            // already a subset of it). Use it directly as the context-window
+            // occupancy — adding `cached` would double-count.
+            if (s.inputTokens != null)
+                s.contextUsedTokens = s.inputTokens;
+        }
+        s.contextWindow = geminiContextWindowFromModel(s.model) ?? s.contextWindow;
+    }
+}
+// Gemini-cli does an exponential backoff on 429s and other transient errors
+// without emitting any stream-json event — only stderr gets a line like
+// `Attempt 1 failed with status 429. Retrying with backoff...`. Surface those
+// lines as activity so users don't see a frozen UI during MODEL_CAPACITY_EXHAUSTED.
+const GEMINI_RETRY_RE = /^Attempt\s+(\d+)\s+failed\s+with\s+status\s+(\d+)/i;
+function geminiParseStderrLine(line, s) {
+    const m = GEMINI_RETRY_RE.exec(line);
+    if (!m)
+        return;
+    const attempt = m[1];
+    const status = m[2];
+    const reason = status === '429' ? 'rate limit / capacity exhausted'
+        : status === '503' ? 'service unavailable'
+            : `status ${status}`;
+    pushRecentActivity(s.recentActivity, `Retrying after ${reason} (attempt ${attempt})`);
+    s.activity = s.recentActivity.join('\n');
+}
+// ---------------------------------------------------------------------------
+// Thinking effort overlay
+//
+// Gemini CLI exposes thinking via two knobs depending on model family:
+//   - Gemini 3.x: thinkingLevel: "LOW" | "HIGH"
+//   - Gemini 2.5: thinkingBudget: number (0=off, 8192=default, -1=dynamic)
+// There is no CLI flag — the only place the CLI reads them is settings.json
+// under `agents.<chat-base*>.modelConfig.generateContentConfig.thinkingConfig`.
+//
+// We don't want to mutate the user's ~/.gemini/settings.json, so for streams
+// where an effort is set we materialise a fake $HOME via GEMINI_CLI_HOME and
+// place a synthetic `.gemini/` inside it: symlinks for everything in the
+// real ~/.gemini/ (oauth, projects, history, tmp, …) plus our merged
+// settings.json. Note that gemini-cli reads GEMINI_CLI_HOME as the *parent*
+// of `.gemini/`, not as `.gemini/` itself — getting that wrong makes gemini
+// fail with "Please set an Auth method" because it can't find any creds.
+// ---------------------------------------------------------------------------
+function geminiEffortOverlay(effort) {
+    const value = String(effort || '').trim().toLowerCase();
+    if (!value)
+        return null;
+    let level3;
+    let budget25;
+    if (value === 'low' || value === 'minimal') {
+        level3 = 'LOW';
+        budget25 = 512;
+    }
+    else if (value === 'medium') {
+        level3 = 'HIGH';
+        budget25 = 8192;
+    }
+    else {
+        level3 = 'HIGH';
+        budget25 = -1;
+    }
+    return {
+        'chat-base-3': {
+            modelConfig: { generateContentConfig: { thinkingConfig: { thinkingLevel: level3 } } },
+        },
+        'chat-base-2.5': {
+            modelConfig: { generateContentConfig: { thinkingConfig: { thinkingBudget: budget25 } } },
+        },
+    };
+}
+function deepMergeAgents(base, overlay) {
+    const out = base && typeof base === 'object' && !Array.isArray(base) ? { ...base } : {};
+    for (const key of Object.keys(overlay)) {
+        out[key] = mergePlainObjects(out[key], overlay[key]);
+    }
+    return out;
+}
+function mergePlainObjects(a, b) {
+    if (b === undefined)
+        return a;
+    if (a === undefined || a === null || typeof a !== 'object' || Array.isArray(a))
+        return b;
+    if (typeof b !== 'object' || Array.isArray(b))
+        return b;
+    const out = { ...a };
+    for (const key of Object.keys(b))
+        out[key] = mergePlainObjects(a[key], b[key]);
+    return out;
+}
+function prepareGeminiHomeOverlay(opts) {
+    const effortOverrides = geminiEffortOverlay(opts.effort);
+    const needsFileFilterBypass = opts.hasAttachments;
+    if (!effortOverrides && !needsFileFilterBypass)
+        return null;
+    const home = getHome();
+    if (!home)
+        return null;
+    const userGeminiDir = path.join(home, '.gemini');
+    if (!fs.existsSync(userGeminiDir))
+        return null;
+    let overlayHome;
+    try {
+        overlayHome = fs.mkdtempSync(path.join(os.tmpdir(), 'pikiloop-gemini-'));
+    }
+    catch {
+        return null;
+    }
+    const overlayGeminiDir = path.join(overlayHome, '.gemini');
+    try {
+        fs.mkdirSync(overlayGeminiDir, { recursive: true });
+    }
+    catch {
+        try {
+            fs.rmSync(overlayHome, { recursive: true, force: true });
+        }
+        catch { }
+        return null;
+    }
+    // Symlink every entry in ~/.gemini except settings.json so OAuth, projects,
+    // history, tmp/, etc. all stay shared with the user's real config.
+    try {
+        for (const entry of fs.readdirSync(userGeminiDir, { withFileTypes: true })) {
+            if (entry.name === 'settings.json')
+                continue;
+            try {
+                fs.symlinkSync(path.join(userGeminiDir, entry.name), path.join(overlayGeminiDir, entry.name));
+            }
+            catch { /* ignore individual symlink failures */ }
+        }
+    }
+    catch { /* readdir failure → fall through with whatever we managed */ }
+    let userSettings = {};
+    const userSettingsPath = path.join(userGeminiDir, 'settings.json');
+    try {
+        if (fs.existsSync(userSettingsPath)) {
+            userSettings = JSON.parse(fs.readFileSync(userSettingsPath, 'utf-8'));
+        }
+    }
+    catch { /* malformed user settings — start fresh */ }
+    const merged = { ...userSettings };
+    if (effortOverrides) {
+        merged.agents = deepMergeAgents(userSettings.agents, effortOverrides);
+    }
+    if (needsFileFilterBypass) {
+        const baseContext = userSettings.context && typeof userSettings.context === 'object' && !Array.isArray(userSettings.context)
+            ? userSettings.context : {};
+        const baseFileFiltering = baseContext.fileFiltering && typeof baseContext.fileFiltering === 'object' && !Array.isArray(baseContext.fileFiltering)
+            ? baseContext.fileFiltering : {};
+        merged.context = {
+            ...baseContext,
+            fileFiltering: {
+                ...baseFileFiltering,
+                respectGitIgnore: false,
+                respectGeminiIgnore: false,
+            },
+        };
+    }
+    try {
+        fs.writeFileSync(path.join(overlayGeminiDir, 'settings.json'), JSON.stringify(merged, null, 2));
+    }
+    catch {
+        try {
+            fs.rmSync(overlayHome, { recursive: true, force: true });
+        }
+        catch { }
+        return null;
+    }
+    return {
+        homeDir: overlayHome,
+        cleanup: () => { try {
+            fs.rmSync(overlayHome, { recursive: true, force: true });
+        }
+        catch { } },
+    };
+}
+// ---------------------------------------------------------------------------
+// Stream
+// ---------------------------------------------------------------------------
+export async function doGeminiStream(opts) {
+    // Prompt is passed as -p argument; send empty stdin so run() doesn't duplicate it
+    const overlay = prepareGeminiHomeOverlay({
+        effort: opts.thinkingEffort,
+        hasAttachments: (opts.attachments?.length ?? 0) > 0,
+    });
+    const extraEnv = overlay
+        ? { ...(opts.extraEnv || {}), GEMINI_CLI_HOME: overlay.homeDir }
+        : opts.extraEnv;
+    const streamOpts = { ...opts, _stdinOverride: '', extraEnv };
+    try {
+        return await run(geminiCmd(opts), streamOpts, geminiParse, geminiParseStderrLine);
+    }
+    finally {
+        overlay?.cleanup();
+    }
+}
+// ---------------------------------------------------------------------------
+// Sessions / Tail
+// ---------------------------------------------------------------------------
+/** Resolve Gemini project name for a workdir from ~/.gemini/projects.json */
+function geminiProjectName(workdir) {
+    const home = getHome();
+    if (!home)
+        return null;
+    const projectsPath = path.join(home, '.gemini', 'projects.json');
+    try {
+        const data = JSON.parse(fs.readFileSync(projectsPath, 'utf8'));
+        const projects = data?.projects;
+        if (!projects || typeof projects !== 'object')
+            return null;
+        const resolved = path.resolve(workdir);
+        // Exact match first, then check entries
+        if (projects[resolved])
+            return projects[resolved];
+        for (const [dir, name] of Object.entries(projects)) {
+            if (path.resolve(dir) === resolved)
+                return name;
+        }
+    }
+    catch { /* skip */ }
+    return null;
+}
+function geminiChatsDir(workdir) {
+    const home = getHome();
+    if (!home)
+        return null;
+    const projectName = geminiProjectName(workdir);
+    if (!projectName)
+        return null;
+    return path.join(home, '.gemini', 'tmp', projectName, 'chats');
+}
+function extractGeminiText(content) {
+    if (typeof content === 'string')
+        return content.trim();
+    if (!Array.isArray(content))
+        return '';
+    const parts = [];
+    for (const block of content) {
+        if (typeof block === 'string') {
+            if (block.trim())
+                parts.push(block.trim());
+            continue;
+        }
+        const text = typeof block?.text === 'string' ? block.text.trim() : '';
+        if (text)
+            parts.push(text);
+    }
+    return parts.join('\n').trim();
+}
+// Gemini's -p mode is text-only, so pikiloop concatenates its system-prompt
+// blocks ([Browser Automation], [Artifact Return], …) onto the user's prompt
+// before invoking the CLI. That means the JSONL "user" message we read back
+// later contains those orchestrator-injected blocks AND the gemini-CLI-emitted
+// `--- Content from referenced files ---` markers it appends when expanding
+// `@<path>` references. Both are noise for the dashboard / IM render path —
+// the helpers below strip them so the displayed user bubble matches what the
+// human actually typed, and surface staged image attachments as image blocks
+// instead of raw `@<path>` text.
+const GEMINI_SYSTEM_BLOCK_SENTINELS = [
+    '[Artifact Return]',
+    '[Asking the user]',
+    '[Browser Automation]',
+    '[Session Workspace]',
+];
+const GEMINI_REFERENCED_FILES_BLOCK_RE = /\n*--- Content from referenced files ---[\s\S]*?--- End of content ---\n*/g;
+const GEMINI_FILE_REF_RE = /(^|\s)@(?:"([^"]+)"|([^\s"@]+))/g;
+function stripGeminiSystemPreamble(text) {
+    let cur = text.replace(/^\s+/, '');
+    while (true) {
+        const sentinel = GEMINI_SYSTEM_BLOCK_SENTINELS.find(s => cur.startsWith(s));
+        if (!sentinel)
+            break;
+        const blockEnd = cur.indexOf('\n\n');
+        if (blockEnd < 0)
+            return '';
+        cur = cur.slice(blockEnd + 2).replace(/^\s+/, '');
+    }
+    return cur;
+}
+function cleanGeminiUserText(rawText) {
+    if (!rawText)
+        return '';
+    let text = stripInjectedPrompts(rawText);
+    text = stripGeminiSystemPreamble(text);
+    text = text.replace(GEMINI_REFERENCED_FILES_BLOCK_RE, '\n');
+    return text.trim();
+}
+/**
+ * Build a (text, image blocks) pair for a rendered user bubble. `@<path>`
+ * references that resolve to readable image files are lifted into image
+ * blocks; refs that don't resolve are left in the text so the user can still
+ * see what they wrote.
+ */
+function buildGeminiUserMessageContent(rawText, workdir) {
+    const cleaned = cleanGeminiUserText(rawText);
+    if (!cleaned)
+        return { text: '', blocks: [] };
+    const blocks = [];
+    const textOnly = cleaned.replace(GEMINI_FILE_REF_RE, (match, lead, quoted, bare) => {
+        const ref = String(quoted || bare || '').trim();
+        if (!ref)
+            return match;
+        const abs = path.isAbsolute(ref) ? ref : path.resolve(workdir, ref);
+        const block = attachAgentImage({ imagePath: abs });
+        if (block) {
+            blocks.push(block);
+            return lead || '';
+        }
+        return match;
+    });
+    return { text: textOnly.replace(/\n{3,}/g, '\n\n').trim(), blocks };
+}
+/** Drop the attachment `@<path>` refs entirely so they don't surface as raw
+ *  paths in plain-text contexts (tail snippets, sidebar previews). Newlines
+ *  in the surrounding prose are preserved. */
+function dropGeminiFileRefs(text) {
+    return text.replace(GEMINI_FILE_REF_RE, '$1');
+}
+/** Single-line variant for session list titles where the bubble shape is a
+ *  one-liner — collapses every whitespace run to a single space. */
+function flattenGeminiUserText(rawText) {
+    return dropGeminiFileRefs(cleanGeminiUserText(rawText)).replace(/\s+/g, ' ').trim();
+}
+function normalizeGeminiSessionTitle(value) {
+    const text = String(value || '').replace(/\s+/g, ' ').trim();
+    if (!text)
+        return null;
+    return text.length <= 120 ? text : `${text.slice(0, 117).trimEnd()}...`;
+}
+function findGeminiSessionFile(workdir, sessionId) {
+    const chatsDir = geminiChatsDir(workdir);
+    if (!chatsDir || !fs.existsSync(chatsDir))
+        return null;
+    let entries;
+    try {
+        entries = fs.readdirSync(chatsDir, { withFileTypes: true });
+    }
+    catch {
+        return null;
+    }
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.startsWith('session-'))
+            continue;
+        if (!entry.name.endsWith('.json') && !entry.name.endsWith('.jsonl'))
+            continue;
+        const filePath = path.join(chatsDir, entry.name);
+        try {
+            const data = loadGeminiSessionData(filePath);
+            if (data?.sessionId === sessionId)
+                return filePath;
+        }
+        catch { /* skip */ }
+    }
+    return null;
+}
+function loadGeminiSessionData(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        if (filePath.endsWith('.json'))
+            return JSON.parse(content);
+        // JSONL format: first line is metadata, subsequent lines are messages or $set updates
+        const lines = content.split('\n');
+        let data = {};
+        const messages = [];
+        for (const line of lines) {
+            if (!line.trim() || line[0] !== '{')
+                continue;
+            try {
+                const obj = JSON.parse(line);
+                if (obj.sessionId && !data.sessionId) {
+                    data = { ...obj };
+                }
+                else if (obj.$set) {
+                    if (obj.$set.lastUpdated)
+                        data.lastUpdated = obj.$set.lastUpdated;
+                }
+                else if (obj.type === 'user' || obj.type === 'gemini' || obj.type === 'model' || obj.type === 'assistant') {
+                    messages.push(obj);
+                }
+            }
+            catch { /* skip */ }
+        }
+        data.messages = messages;
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+// Per-file cache of the derived fields. getNativeGeminiSessionsFromFiles read +
+// JSON-parsed every chat file's full contents on every list request AND per
+// workspace×agent in the overview fan-out. Keyed by (mtime,size) so unchanged
+// chats are never re-read; `running` depends on Date.now() so it's recomputed
+// per call. Stores only the small derived fields, never the full messages array.
+const nativeGeminiContentCache = new Map();
+function readNativeGeminiContent(filePath) {
+    const data = loadGeminiSessionData(filePath);
+    if (!data?.sessionId)
+        return null;
+    // Gemini CLI writes stub session files for internal bookkeeping — e.g.
+    // `sessionId: "a2a-server"` for its built-in a2a server, plus abandoned
+    // UUID-named sessions that never received a turn. Both share the same shape:
+    // metadata only, no `messages` array. Nothing to render, so skip them.
+    const messages = Array.isArray(data.messages) ? data.messages : [];
+    if (messages.length === 0)
+        return null;
+    // Extract title from first user message + last Q&A from tail.
+    let title = null;
+    let lastQuestion = null;
+    let lastAnswer = null;
+    let lastMessageText = null;
+    for (const msg of messages) {
+        if (msg.type === 'user') {
+            const text = sanitizeSessionUserPreviewText(flattenGeminiUserText(extractGeminiText(msg.content)));
+            if (!title)
+                title = normalizeGeminiSessionTitle(text);
+            if (text) {
+                lastQuestion = shortValue(text, 500);
+                lastMessageText = shortValue(text, 500);
+            }
+        }
+        else if (msg.type === 'model' || msg.type === 'assistant' || msg.type === 'gemini') {
+            const text = extractGeminiText(msg.content);
+            if (text) {
+                lastAnswer = shortValue(text, 500);
+                lastMessageText = shortValue(text, 500);
+            }
+        }
+    }
+    const numTurns = messages.filter((m) => m.type === 'user' && flattenGeminiUserText(extractGeminiText(m.content))).length;
+    return {
+        sessionId: String(data.sessionId),
+        title,
+        createdAt: data.startTime || data.createdAt || null,
+        updatedAt: data.lastUpdated || data.startTime || data.createdAt || null,
+        lastUpdated: data.lastUpdated || null,
+        lastQuestion,
+        lastAnswer,
+        lastMessageText,
+        numTurns: numTurns || null,
+    };
+}
+/** Read native Gemini CLI sessions from ~/.gemini/tmp/{projectName}/chats/ */
+function getNativeGeminiSessionsFromFiles(workdir) {
+    const chatsDir = geminiChatsDir(workdir);
+    if (!chatsDir || !fs.existsSync(chatsDir))
+        return [];
+    let entries;
+    try {
+        entries = fs.readdirSync(chatsDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const sessionsById = new Map();
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.startsWith('session-'))
+            continue;
+        if (!entry.name.endsWith('.json') && !entry.name.endsWith('.jsonl'))
+            continue;
+        const filePath = path.join(chatsDir, entry.name);
+        let stat;
+        try {
+            stat = fs.statSync(filePath);
+        }
+        catch {
+            continue;
+        }
+        let cached = nativeGeminiContentCache.get(filePath);
+        if (!cached || cached.mtimeMs !== stat.mtimeMs || cached.size !== stat.size) {
+            cached = { mtimeMs: stat.mtimeMs, size: stat.size, content: readNativeGeminiContent(filePath) };
+            nativeGeminiContentCache.set(filePath, cached);
+        }
+        const content = cached.content;
+        if (!content)
+            continue;
+        // If we already saw this sessionId, only replace it if this file is newer.
+        const existing = sessionsById.get(content.sessionId);
+        if (existing && content.updatedAt && existing.runUpdatedAt && Date.parse(content.updatedAt) <= Date.parse(existing.runUpdatedAt)) {
+            continue;
+        }
+        const running = content.lastUpdated ? Date.now() - Date.parse(content.lastUpdated) < SESSION_RUNNING_THRESHOLD_MS : false;
+        sessionsById.set(content.sessionId, {
+            sessionId: content.sessionId,
+            agent: 'gemini',
+            workdir,
+            workspacePath: null,
+            model: null,
+            createdAt: content.createdAt,
+            title: content.title,
+            running,
+            runState: running ? 'running' : 'completed',
+            runDetail: null,
+            runUpdatedAt: content.updatedAt,
+            classification: null,
+            userStatus: null,
+            userNote: null,
+            lastQuestion: content.lastQuestion,
+            lastAnswer: content.lastAnswer,
+            lastMessageText: content.lastMessageText,
+            migratedFrom: null,
+            migratedTo: null,
+            linkedSessions: [],
+            numTurns: content.numTurns,
+        });
+    }
+    return [...sessionsById.values()];
+}
+function getNativeGeminiSessions(workdir) {
+    return getNativeGeminiSessionsFromFiles(workdir);
+}
+function getGeminiSessions(workdir, limit) {
+    const resolvedWorkdir = path.resolve(workdir);
+    // Merge pikiloop-tracked sessions with native Gemini sessions
+    const pikiloopSessions = listPikiloopSessions(resolvedWorkdir, 'gemini').map(record => ({
+        sessionId: record.sessionId,
+        agent: 'gemini',
+        workdir: record.workdir,
+        workspacePath: record.workspacePath,
+        threadId: record.threadId,
+        model: record.model,
+        createdAt: record.createdAt,
+        title: record.title,
+        running: record.runState === 'running',
+        runState: record.runState,
+        runDetail: record.runDetail,
+        runUpdatedAt: record.runUpdatedAt,
+        runPid: record.runPid,
+        classification: record.classification,
+        userStatus: record.userStatus,
+        userNote: record.userNote,
+        lastQuestion: record.lastQuestion,
+        lastAnswer: record.lastAnswer,
+        lastMessageText: record.lastMessageText,
+        migratedFrom: record.migratedFrom,
+        migratedTo: record.migratedTo,
+        linkedSessions: record.linkedSessions,
+        numTurns: record.numTurns ?? null,
+    }));
+    const nativeSessions = getNativeGeminiSessions(resolvedWorkdir);
+    const merged = mergeManagedAndNativeSessions(pikiloopSessions, nativeSessions);
+    const sessions = typeof limit === 'number' ? merged.slice(0, limit) : merged;
+    const projectName = geminiProjectName(resolvedWorkdir);
+    const chatsDir = projectName ? geminiChatsDir(resolvedWorkdir) || '' : '';
+    agentLog(`[sessions:gemini] workdir=${resolvedWorkdir} projectName=${projectName || '(none)'} chatsDir=${chatsDir || '(none)'} ` +
+        `chatsDirExists=${chatsDir ? fs.existsSync(chatsDir) : false} pikiloop=${pikiloopSessions.length} native=${nativeSessions.length} merged=${sessions.length}`);
+    return { ok: true, sessions, error: null };
+}
+function getGeminiSessionTail(opts) {
+    const limit = opts.limit ?? 4;
+    const filePath = findGeminiSessionFile(opts.workdir, opts.sessionId);
+    if (!filePath)
+        return { ok: false, messages: [], error: 'Session file not found' };
+    try {
+        const data = loadGeminiSessionData(filePath);
+        const messages = Array.isArray(data?.messages) ? data.messages : [];
+        const allMsgs = [];
+        for (const msg of messages) {
+            const type = typeof msg?.type === 'string' ? msg.type.trim().toLowerCase() : '';
+            const role = type === 'user' ? 'user' : (type === 'gemini' || type === 'model' || type === 'assistant') ? 'assistant' : null;
+            if (!role)
+                continue;
+            const rawText = extractGeminiText(msg?.content);
+            const text = role === 'user' ? dropGeminiFileRefs(cleanGeminiUserText(rawText)) : rawText;
+            if (text)
+                allMsgs.push({ role, text });
+        }
+        return { ok: true, messages: allMsgs.slice(-limit), error: null };
+    }
+    catch (e) {
+        return { ok: false, messages: [], error: e.message };
+    }
+}
+// ---------------------------------------------------------------------------
+// Session messages (full content)
+// ---------------------------------------------------------------------------
+function getGeminiSessionMessages(opts) {
+    const filePath = findGeminiSessionFile(opts.workdir, opts.sessionId);
+    if (!filePath)
+        return { ok: false, messages: [], totalTurns: 0, error: 'Session file not found' };
+    try {
+        const data = loadGeminiSessionData(filePath);
+        const messages = Array.isArray(data?.messages) ? data.messages : [];
+        const allMsgs = [];
+        const richMsgs = [];
+        for (const msg of messages) {
+            const type = typeof msg?.type === 'string' ? msg.type.trim().toLowerCase() : '';
+            const role = type === 'user' ? 'user' : (type === 'gemini' || type === 'model' || type === 'assistant') ? 'assistant' : null;
+            if (!role)
+                continue;
+            const rawText = extractGeminiText(msg?.content);
+            if (role === 'user') {
+                const { text, blocks: imageBlocks } = buildGeminiUserMessageContent(rawText, opts.workdir);
+                if (!text && !imageBlocks.length)
+                    continue;
+                allMsgs.push({ role, text });
+                const blocks = [];
+                if (text)
+                    blocks.push({ type: 'text', content: text });
+                blocks.push(...imageBlocks);
+                richMsgs.push({ role, text, blocks });
+            }
+            else {
+                if (!rawText)
+                    continue;
+                allMsgs.push({ role, text: rawText });
+                richMsgs.push({ role, text: rawText, blocks: [{ type: 'text', content: rawText }] });
+            }
+        }
+        return applyTurnWindow(allMsgs, opts, opts.rich ? richMsgs : undefined);
+    }
+    catch (e) {
+        return { ok: false, messages: [], totalTurns: 0, error: e.message };
+    }
+}
+// ---------------------------------------------------------------------------
+// Models — static list for now, can be extended with `gemini models list`
+// ---------------------------------------------------------------------------
+// Model IDs from gemini-cli-core (no CLI command to list them dynamically)
+const GEMINI_MODELS = [
+    { id: 'auto-gemini-3', alias: 'auto-3' },
+    { id: 'auto-gemini-2.5', alias: 'auto' },
+    { id: 'gemini-3.1-pro-preview', alias: '3.1-pro' },
+    { id: 'gemini-3-pro-preview', alias: '3-pro' },
+    { id: 'gemini-3-flash-preview', alias: '3-flash' },
+    { id: 'gemini-2.5-pro', alias: 'pro' },
+    { id: 'gemini-2.5-flash', alias: 'flash' },
+    { id: 'gemini-2.5-flash-lite', alias: 'flash-lite' },
+];
+// ---------------------------------------------------------------------------
+// Usage
+// ---------------------------------------------------------------------------
+const GEMINI_USAGE_TIMEOUT_MS = GEMINI_USAGE_TIMEOUTS.request;
+const GEMINI_USAGE_URL = 'https://cloudcode-pa.googleapis.com/v1internal:retrieveUserQuota';
+let lastGeminiUsage = null;
+function cachedGeminiUsage(error) {
+    return lastGeminiUsage?.ok ? lastGeminiUsage : emptyUsage('gemini', error);
+}
+function getGeminiOAuthToken() {
+    const home = getHome();
+    if (!home)
+        return null;
+    const credsPath = path.join(home, '.gemini', 'oauth_creds.json');
+    try {
+        const raw = fs.readFileSync(credsPath, 'utf-8').trim();
+        if (!raw || raw[0] !== '{')
+            return null;
+        const parsed = JSON.parse(raw);
+        const token = typeof parsed?.access_token === 'string' ? parsed.access_token.trim() : '';
+        return token || null;
+    }
+    catch {
+        return null;
+    }
+}
+function geminiUsageLabel(modelId) {
+    const raw = typeof modelId === 'string' ? modelId.trim() : '';
+    const lower = raw.toLowerCase();
+    if (!lower)
+        return 'Gemini';
+    if (lower.includes('flash-lite'))
+        return 'Flash Lite';
+    if (lower.includes('flash'))
+        return 'Flash';
+    if (lower.includes('pro'))
+        return 'Pro';
+    return raw
+        .replace(/^gemini-/i, '')
+        .replace(/[-_]+/g, ' ')
+        .trim() || 'Gemini';
+}
+function geminiUsageStatus(usedPercent) {
+    if (usedPercent == null)
+        return null;
+    if (usedPercent >= 100)
+        return 'limit_reached';
+    if (usedPercent >= 80)
+        return 'warning';
+    return 'allowed';
+}
+function geminiResetAt(value) {
+    const raw = typeof value === 'string' ? value.trim() : '';
+    if (!raw)
+        return null;
+    const ms = Date.parse(raw);
+    return Number.isFinite(ms) ? new Date(ms).toISOString() : null;
+}
+function geminiResetAtMs(value) {
+    if (!value)
+        return Number.POSITIVE_INFINITY;
+    const ms = Date.parse(value);
+    return Number.isFinite(ms) ? ms : Number.POSITIVE_INFINITY;
+}
+function geminiUsageWindowSort(label) {
+    switch (label) {
+        case 'Pro': return 0;
+        case 'Flash': return 1;
+        case 'Flash Lite': return 2;
+        default: return 10;
+    }
+}
+function parseGeminiUsageResponse(data, capturedAt) {
+    const buckets = Array.isArray(data?.buckets) ? data.buckets : [];
+    const grouped = new Map();
+    for (const bucket of buckets) {
+        const remainingFraction = Number(bucket?.remainingFraction);
+        if (!Number.isFinite(remainingFraction))
+            continue;
+        const label = geminiUsageLabel(bucket?.modelId);
+        const resetAt = geminiResetAt(bucket?.resetTime);
+        const prev = grouped.get(label);
+        if (!prev
+            || remainingFraction < prev.remainingFraction
+            || (remainingFraction === prev.remainingFraction && geminiResetAtMs(resetAt) < geminiResetAtMs(prev.resetAt))) {
+            grouped.set(label, { label, remainingFraction, resetAt });
+        }
+    }
+    const windows = [...grouped.values()]
+        .map(entry => {
+        const usedPercent = roundPercent((1 - entry.remainingFraction) * 100);
+        const remainingPercent = roundPercent(entry.remainingFraction * 100);
+        let resetAfterSeconds = null;
+        if (entry.resetAt) {
+            const resetAtMs = Date.parse(entry.resetAt);
+            if (Number.isFinite(resetAtMs))
+                resetAfterSeconds = Math.max(0, Math.round((resetAtMs - Date.now()) / 1000));
+        }
+        return {
+            label: entry.label,
+            usedPercent,
+            remainingPercent,
+            resetAt: entry.resetAt,
+            resetAfterSeconds,
+            status: geminiUsageStatus(usedPercent),
+        };
+    })
+        .sort((a, b) => {
+        const byLabel = geminiUsageWindowSort(a.label) - geminiUsageWindowSort(b.label);
+        return byLabel || a.label.localeCompare(b.label);
+    });
+    if (!windows.length)
+        return null;
+    const status = windows.some(window => window.status === 'limit_reached') ? 'limit_reached'
+        : windows.some(window => window.status === 'warning') ? 'warning'
+            : 'allowed';
+    return { ok: true, agent: 'gemini', source: 'quota-api', capturedAt, status, windows, error: null };
+}
+function geminiUsageError(status, bodyText) {
+    let detail = '';
+    const trimmed = String(bodyText || '').trim();
+    if (trimmed && trimmed[0] === '{') {
+        try {
+            const parsed = JSON.parse(trimmed);
+            detail = normalizeErrorMessage(parsed?.error?.message)
+                || normalizeErrorMessage(parsed?.error)
+                || normalizeErrorMessage(parsed?.message)
+                || '';
+        }
+        catch { }
+    }
+    return cachedGeminiUsage(`HTTP ${status}${detail ? `: ${detail}` : ''}`);
+}
+async function getGeminiUsageLive() {
+    const token = getGeminiOAuthToken();
+    if (!token)
+        return cachedGeminiUsage('Gemini OAuth token not found.');
+    try {
+        const raw = execSync(`curl -sS --max-time ${Math.ceil(GEMINI_USAGE_TIMEOUT_MS / 1000)} -w '\\n%{http_code}' -H ${Q(`Authorization: Bearer ${token}`)} -H 'Content-Type: application/json' -d '{}' ${Q(GEMINI_USAGE_URL)}`, { encoding: 'utf-8', timeout: GEMINI_USAGE_TIMEOUT_MS + GEMINI_USAGE_TIMEOUTS.execSyncBuffer });
+        const trimmed = raw.trimEnd();
+        const sep = trimmed.lastIndexOf('\n');
+        const bodyText = sep >= 0 ? trimmed.slice(0, sep) : '';
+        const status = Number(sep >= 0 ? trimmed.slice(sep + 1).trim() : '');
+        if (!Number.isFinite(status))
+            return cachedGeminiUsage('Gemini quota query returned an invalid HTTP status.');
+        if (status < 200 || status >= 300)
+            return geminiUsageError(status, bodyText);
+        if (!bodyText.trim() || bodyText.trim()[0] !== '{')
+            return cachedGeminiUsage('Gemini quota query returned an invalid response.');
+        const usage = parseGeminiUsageResponse(JSON.parse(bodyText), new Date().toISOString())
+            || cachedGeminiUsage('No Gemini quota buckets returned.');
+        if (usage.ok)
+            lastGeminiUsage = usage;
+        return usage;
+    }
+    catch (err) {
+        const detail = normalizeErrorMessage(err?.message || err) || 'Gemini usage query failed.';
+        return cachedGeminiUsage(detail);
+    }
+}
+// ---------------------------------------------------------------------------
+// Driver
+// ---------------------------------------------------------------------------
+class GeminiDriver {
+    id = 'gemini';
+    cmd = 'gemini';
+    thinkLabel = 'Thinking';
+    acceptedProviderKinds = ['google'];
+    async doStream(opts) { return doGeminiStream(opts); }
+    async getSessions(workdir, limit) {
+        return getGeminiSessions(workdir, limit);
+    }
+    async getSessionTail(opts) {
+        return getGeminiSessionTail(opts);
+    }
+    async getSessionMessages(opts) {
+        return getGeminiSessionMessages(opts);
+    }
+    async listModels(_opts) {
+        return { agent: 'gemini', models: [...GEMINI_MODELS], sources: [], note: null };
+    }
+    getUsage(_opts) {
+        return cachedGeminiUsage('No recent Gemini usage data found.');
+    }
+    async getUsageLive(_opts) {
+        return getGeminiUsageLive();
+    }
+    async deleteNativeSession(workdir, sessionId) {
+        const file = findGeminiSessionFile(workdir, sessionId);
+        if (!file)
+            return [];
+        try {
+            fs.rmSync(file, { force: true });
+            return [file];
+        }
+        catch {
+            return [];
+        }
+    }
+    shutdown() { }
+}
+registerDriver(new GeminiDriver());