pikiloom 0.4.26 → 0.4.28

package/dist/agent/drivers/gemini.js

@@ -1,9 +1,3 @@
-/**
- * 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';
@@ -12,9 +6,6 @@ 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, listPikiloomSessions, mergeManagedAndNativeSessions, managedRecordToSessionInfo, 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;
@@ -25,15 +16,9 @@ function hasGeminiFlag(args, names) {
         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;
 }
@@ -53,7 +38,6 @@ function geminiCmd(o) {
     }
     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)
@@ -166,20 +150,13 @@ function geminiToolResultSummary(tool, ev) {
 }
 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 || '';
@@ -211,7 +188,6 @@ function geminiParse(ev, s) {
             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') {
@@ -227,19 +203,12 @@ function geminiParse(ev, s) {
             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);
@@ -253,23 +222,6 @@ function geminiParseStderrLine(line, s) {
     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)
@@ -345,8 +297,6 @@ function prepareGeminiHomeOverlay(opts) {
         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')
@@ -354,10 +304,10 @@ function prepareGeminiHomeOverlay(opts) {
             try {
                 fs.symlinkSync(path.join(userGeminiDir, entry.name), path.join(overlayGeminiDir, entry.name));
             }
-            catch { /* ignore individual symlink failures */ }
+            catch { }
         }
     }
-    catch { /* readdir failure → fall through with whatever we managed */ }
+    catch { }
     let userSettings = {};
     const userSettingsPath = path.join(userGeminiDir, 'settings.json');
     try {
@@ -365,7 +315,7 @@ function prepareGeminiHomeOverlay(opts) {
             userSettings = JSON.parse(fs.readFileSync(userSettingsPath, 'utf-8'));
         }
     }
-    catch { /* malformed user settings — start fresh */ }
+    catch { }
     const merged = { ...userSettings };
     if (effortOverrides) {
         merged.agents = deepMergeAgents(userSettings.agents, effortOverrides);
@@ -402,11 +352,7 @@ function prepareGeminiHomeOverlay(opts) {
         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,
@@ -422,10 +368,6 @@ export async function doGeminiStream(opts) {
         overlay?.cleanup();
     }
 }
-// ---------------------------------------------------------------------------
-// Sessions / Tail
-// ---------------------------------------------------------------------------
-/** Resolve Gemini project name for a workdir from ~/.gemini/projects.json */
 function geminiProjectName(workdir) {
     const home = getHome();
     if (!home)
@@ -437,7 +379,6 @@ function geminiProjectName(workdir) {
         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)) {
@@ -445,7 +386,7 @@ function geminiProjectName(workdir) {
                 return name;
         }
     }
-    catch { /* skip */ }
+    catch { }
     return null;
 }
 function geminiChatsDir(workdir) {
@@ -475,15 +416,6 @@ function extractGeminiText(content) {
     }
     return parts.join('\n').trim();
 }
-// Gemini's -p mode is text-only, so pikiloom 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]',
@@ -513,12 +445,6 @@ function cleanGeminiUserText(rawText) {
     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)
@@ -538,14 +464,9 @@ function buildGeminiUserMessageContent(rawText, workdir) {
     });
     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();
 }
@@ -577,7 +498,7 @@ function findGeminiSessionFile(workdir, sessionId) {
             if (data?.sessionId === sessionId)
                 return filePath;
         }
-        catch { /* skip */ }
+        catch { }
     }
     return null;
 }
@@ -586,7 +507,6 @@ function loadGeminiSessionData(filePath) {
         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 = [];
@@ -606,7 +526,7 @@ function loadGeminiSessionData(filePath) {
                     messages.push(obj);
                 }
             }
-            catch { /* skip */ }
+            catch { }
         }
         data.messages = messages;
         return data;
@@ -615,24 +535,14 @@ function loadGeminiSessionData(filePath) {
         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;
@@ -668,7 +578,6 @@ function readNativeGeminiContent(filePath) {
         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))
@@ -702,7 +611,6 @@ function getNativeGeminiSessionsFromFiles(workdir) {
         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;
@@ -739,9 +647,6 @@ function getNativeGeminiSessions(workdir) {
 }
 function getGeminiSessions(workdir, limit) {
     const resolvedWorkdir = path.resolve(workdir);
-    // Merge pikiloom-tracked sessions with native Gemini sessions
-    // Canonical record→SessionInfo mapper (single source of truth) — see claude.ts.
-    // Hand-rolling dropped thinkingEffort/workflowEnabled/profileId from the merge.
     const pikiloomSessions = listPikiloomSessions(resolvedWorkdir, 'gemini').map(managedRecordToSessionInfo);
     const nativeSessions = getNativeGeminiSessions(resolvedWorkdir);
     const merged = mergeManagedAndNativeSessions(pikiloomSessions, nativeSessions);
@@ -777,9 +682,6 @@ function getGeminiSessionTail(opts) {
         return { ok: false, messages: [], error: e.message };
     }
 }
-// ---------------------------------------------------------------------------
-// Session messages (full content)
-// ---------------------------------------------------------------------------
 function getGeminiSessionMessages(opts) {
     const filePath = findGeminiSessionFile(opts.workdir, opts.sessionId);
     if (!filePath)
@@ -819,10 +721,6 @@ function getGeminiSessionMessages(opts) {
         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' },
@@ -833,9 +731,6 @@ const GEMINI_MODELS = [
     { 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;
@@ -993,9 +888,6 @@ async function getGeminiUsageLive() {
         return cachedGeminiUsage(detail);
     }
 }
-// ---------------------------------------------------------------------------
-// Driver
-// ---------------------------------------------------------------------------
 class GeminiDriver {
     id = 'gemini';
     cmd = 'gemini';

package/dist/agent/drivers/hermes.js

@@ -1,14 +1,3 @@
-/**
- * Hermes Agent driver — speaks ACP (Agent Client Protocol) to `hermes acp`.
- *
- * Pikiloom owns Provider/Profile credentials in its own vault; this driver
- * reads the active Profile via the model layer's injector and applies env
- * vars when spawning the Hermes ACP child process. Hermes' own config and
- * `hermes auth` command are not touched.
- *
- * Reference: https://agentclientprotocol.com — JSON-RPC 2.0 over stdio.
- * Hermes implements ACP via `~/.hermes/hermes-agent/acp_adapter/server.py`.
- */
 import { spawn } from 'node:child_process';
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
@@ -17,11 +6,6 @@ import { resolve as resolvePath } from 'node:path';
 import { registerDriver } from '../driver.js';
 import { AcpClient, toAcpMcpServers } from '../acp-client.js';
 import { agentLog, agentWarn, emptyUsage, normalizeErrorMessage, listPikiloomSessions, managedRecordToSessionInfo, findPikiloomSession, buildStreamPreviewMeta, applyTurnWindow, pushRecentActivity, IMAGE_EXTS, mimeForExt, } from '../index.js';
-// Build the ACP `prompt` content array from the user's text + staged
-// attachments. Images become ImageContentBlocks (base64 + mimeType — the
-// shape Hermes' acp_adapter accepts and converts to OpenAI multimodal
-// content). Non-image attachments are referenced by path so the agent can
-// open them with its own filesystem tools.
 function buildHermesPromptBlocks(prompt, attachments) {
     const blocks = [];
     for (const filePath of attachments) {
@@ -75,9 +59,6 @@ function applySessionUpdate(state, update) {
             return false;
         }
         case 'tool_call': {
-            // ACP tool_call kicks off a new invocation. Accumulate it (mirroring
-            // Claude/Codex) so the user sees the full chain in the live footer,
-            // not just the title of whatever tool is currently mid-flight.
             const id = typeof update.toolCallId === 'string' ? update.toolCallId : '';
             const title = (typeof update.title === 'string' && update.title.trim()) || 'tool';
             if (id)
@@ -104,10 +85,6 @@ function applySessionUpdate(state, update) {
             return true;
         }
         case 'usage_update': {
-            // ACP semantics: `size` = model context window, `used` = current
-            // context pressure. We previously mis-mapped `size` to
-            // contextUsedTokens, which made the chip show the full window
-            // (e.g. "1.0M tok" for a 1M-window model) regardless of actual use.
             if (typeof update.size === 'number')
                 state.contextWindow = update.size;
             if (typeof update.used === 'number')
@@ -129,21 +106,9 @@ function makeStreamResult(start, partial = {}) {
         ...partial,
     };
 }
-// Empty / refusal heuristic — used to surface a hint when the model's reply
-// is the canonical OpenAI safety refusal with no content. We don't paper
-// over it (the user should see exactly what the model said), but a short
-// pikiloom note tells them this came from the model itself, not a bug.
 const REFUSAL_REGEX = /^(?:i'?m sorry|sorry),?[\s\w,'`]*?(?:can(?:not|'t)|unable to)\s+(?:assist|help)[\s\S]{0,40}$/i;
-// ---------------------------------------------------------------------------
-// ACP-driven streaming
-// ---------------------------------------------------------------------------
 async function doHermesStream(opts) {
     const start = Date.now();
-    // BYOK env is populated on opts by stream.ts via resolveAgentInjection('hermes');
-    // we just merge it into the spawn env. The bound model is delivered via the
-    // ACP `session/set_model` request below — `hermes acp` does NOT accept any
-    // CLI flags besides `--accept-hooks`, so we MUST NOT append byokArgvAppend
-    // here (doing so would crash the spawn with `unrecognized arguments`).
     const baseEnv = { ...process.env, ...(opts.extraEnv || {}) };
     if (!opts.hermesModel) {
         agentLog(`[hermes] no active profile bound — running with hermes' native config default`);
@@ -156,16 +121,8 @@ async function doHermesStream(opts) {
     });
     let sessionId = opts.sessionId || null;
     let stopReason = null;
-    // Per-turn streaming state. We reset it just before sending session/prompt
-    // so any session/update events from the prior session/load replay don't
-    // leak into the user-visible reply.
     const state = makeStreamState();
-    // While true, sessionUpdate events flow into `state`. When false, they are
-    // counted but discarded — used during the session/load replay window so
-    // history-replay chunks don't pollute the new turn's reply.
     let consumeUpdates = true;
-    // Agent-initiated requests we must respond to (we deny filesystem ops we
-    // don't support; pikiloom has its own sandbox/permission model elsewhere).
     client.on('request', ({ id, method }) => {
         if (method === 'session/request_permission') {
             client.respond(id, { outcome: { outcome: 'cancelled' } });
@@ -196,7 +153,6 @@ async function doHermesStream(opts) {
         }
     };
     client.on('sessionUpdate', onUpdate);
-    // Abort handling
     const onAbort = () => {
         stopReason = 'interrupted';
         if (sessionId)
@@ -223,16 +179,6 @@ async function doHermesStream(opts) {
                 opts.onSessionId?.(sessionId);
         }
         else {
-            // Resumed session in a fresh `hermes acp` process. We MUST call
-            // `session/load`, not just rely on the implicit DB restore that
-            // `session/prompt` does internally:
-            //   1. ACP-registered MCP servers are NOT persisted on disk — Hermes'
-            //      `_make_agent` (used during DB restore) recreates the agent with
-            //      *only* its native toolset. Without re-registering, the model
-            //      sees a different tool surface than turn 1.
-            //   2. `session/load` triggers Hermes' history-replay (it streams every
-            //      prior user/assistant message back as session/update events).
-            //      Discard them so they don't pollute the new turn's reply.
             consumeUpdates = false;
             try {
                 const result = await client.request('session/load', {
@@ -244,9 +190,6 @@ async function doHermesStream(opts) {
                     agentWarn(`[hermes] session/load returned null for ${sessionId} — session not found in Hermes DB; continuing with a fresh prompt against the existing id`);
                 }
                 else {
-                    // Replay events arrive on Hermes' event loop AFTER session/load
-                    // resolves. Wait until the stream goes quiet for ~150ms (or 3s
-                    // hard cap) — that's a more robust signal than a fixed sleep.
                     const drained = await client.waitForQuiet(150, 3_000);
                     if (drained > 0)
                         agentLog(`[hermes] drained ${drained} replay event(s) after session/load`);
@@ -258,12 +201,6 @@ async function doHermesStream(opts) {
         }
         if (!sessionId)
             throw new Error('Hermes did not return a session id');
-        // If a Profile is bound, override Hermes' config-default model via ACP.
-        // `set_model` is best-effort: a Hermes that doesn't recognise the model id
-        // (or doesn't have credentials for the requested provider) responds with
-        // an error, but we keep going — the user will see that error in the first
-        // prompt response and can re-pick a working profile, which is far better
-        // than crashing the whole spawn.
         if (opts.hermesModel) {
             try {
                 await client.request('session/set_model', {
@@ -276,20 +213,12 @@ async function doHermesStream(opts) {
                 agentWarn(`[hermes] session/set_model failed (${opts.hermesModel}): ${e?.message || e} — falling back to Hermes' config default`);
             }
         }
-        // Best-effort: forward the chosen reasoning effort via ACP `session/set_mode`.
-        // Current `hermes acp` accepts the request but only persists the value on
-        // the session record (it doesn't influence generation). When Hermes adds a
-        // real effort knob to the ACP surface, this call will start taking effect
-        // without any pikiloom change.
         if (opts.thinkingEffort) {
             await client.tryRequest('session/set_mode', {
                 sessionId,
                 modeId: opts.thinkingEffort,
             });
         }
-        // Reset the buffer one last time before we start consuming updates for
-        // the prompt. Anything that arrived during/after the drain (latency
-        // stragglers from the replay) gets discarded too.
         state.text = '';
         state.thinking = '';
         state.activity = '';
@@ -301,9 +230,6 @@ async function doHermesStream(opts) {
             prompt: buildHermesPromptBlocks(opts.prompt, opts.attachments || []),
         }, Math.max(opts.timeout * 1000, 30_000));
         stopReason = promptResponse?.stopReason || 'end_turn';
-        // `PromptResponse.usage` (ACP) carries real per-turn token counts from the
-        // provider. `usage_update` notifications, by contrast, describe the
-        // session's *context window pressure* (size/used), not this turn's I/O.
         const usage = promptResponse?.usage;
         if (usage && typeof usage === 'object') {
             const input = usage.inputTokens ?? usage.input_tokens;
@@ -333,8 +259,6 @@ async function doHermesStream(opts) {
             stopReason,
             incomplete: stopReason !== 'end_turn',
             activity: null,
-            // When the model itself refuses, mark as incomplete and add a hint so
-            // the user can tell it's the model's choice (not a pikiloom error).
             error: isRefusalOnly
                 ? `Model returned a safety refusal. Try a different model on the agent card (e.g. claude-haiku-4.5 via OpenRouter), or check ~/.hermes/config.yaml.`
                 : null,
@@ -362,16 +286,8 @@ async function doHermesStream(opts) {
         await client.close().catch(() => { });
     }
 }
-// ---------------------------------------------------------------------------
-// Sessions / models / usage — minimal surface
-// ---------------------------------------------------------------------------
 async function getHermesSessions(workdir, limit) {
-    // Hermes' own session list lives in a SQLite DB inside ~/.hermes — useful
-    // for the `hermes sessions` CLI but irrelevant to pikiloom, which always
-    // creates its own ACP session per turn and records it under .pikiloom.
     const resolvedWorkdir = resolvePath(workdir);
-    // Canonical record→SessionInfo mapper (single source of truth) — see claude.ts.
-    // Hand-rolling dropped thinkingEffort/workflowEnabled/profileId.
     const records = listPikiloomSessions(resolvedWorkdir, 'hermes');
     const sessions = records.map(managedRecordToSessionInfo);
     sessions.sort((a, b) => Date.parse(b.createdAt || '') - Date.parse(a.createdAt || ''));
@@ -382,19 +298,12 @@ async function getHermesSessions(workdir, limit) {
 async function getHermesSessionTail(_opts) {
     return { ok: true, messages: [], error: null };
 }
-// Hermes mirrors every ACP/CLI session to ~/.hermes/sessions/session_<id>.json
-// (in addition to the SQLite store at ~/.hermes/state.db). The JSON file is
-// authoritative for full conversation replay: it carries the OpenAI-style
-// `messages[]` stream, including assistant `reasoning_content` and any
-// `tool_calls[] / role:"tool"` pairs. Reading it is ~20ms vs. a 4+ s ACP
-// `session/load` replay round-trip, so we use it directly.
 function hermesSessionJsonPath(sessionId) {
     return join(homedir(), '.hermes', 'sessions', `session_${sessionId}.json`);
 }
 function extractHermesContentText(content) {
     if (typeof content === 'string')
         return content;
-    // OpenAI multimodal: array of { type, text | image_url, ... }.
     if (Array.isArray(content)) {
         const parts = [];
         for (const part of content) {
@@ -417,7 +326,6 @@ function formatHermesArgs(raw) {
         const trimmed = raw.trim();
         if (!trimmed)
             return '';
-        // tool_calls.function.arguments is a JSON string — pretty-print when valid.
         try {
             const parsed = JSON.parse(trimmed);
             return JSON.stringify(parsed, null, 2);
@@ -537,16 +445,11 @@ function getHermesSessionMessagesFromJson(opts) {
             });
             continue;
         }
-        // Unknown role — ignore silently.
     }
     flushAssistant();
     return applyTurnWindow(allMsgs, opts, opts.rich !== false ? richMsgs : undefined);
 }
 function getHermesSessionMessagesFromRecord(opts) {
-    // Fallback for sessions that pre-date the JSON store (or that Hermes wrote
-    // somewhere we can't see). Synthesizes the most recent turn from the
-    // pikiloom session record so the dashboard still has *something* after the
-    // live snapshot expires.
     const record = findPikiloomSession(opts.workdir, 'hermes', opts.sessionId);
     if (!record || (!record.lastQuestion && !record.lastAnswer && !record.lastThinking)) {
         return { ok: true, messages: [], totalTurns: 0, error: null };
@@ -597,10 +500,6 @@ async function getHermesSessionMessages(opts) {
     return getHermesSessionMessagesFromRecord(opts);
 }
 async function listHermesModels(_opts) {
-    // When Hermes has its own working config (typical case — user ran `hermes auth`
-    // and `hermes config`), surface the configured default model so the dashboard
-    // and IM /models reflect what Hermes will actually use without forcing the
-    // user to re-configure inside pikiloom.
     const native = readHermesNativeConfig();
     const models = native?.model
         ? [{ id: native.model, alias: `${native.provider} (Hermes config)` }]
@@ -614,24 +513,11 @@ async function listHermesModels(_opts) {
             : `Run \`hermes config\` to set a default model, or bind a pikiloom Provider on the agent card.`,
     };
 }
-// ---------------------------------------------------------------------------
-// Native config reader
-//
-// Pikiloom never writes to ~/.hermes/config.yaml — that is Hermes' own state.
-// We just *read* a few fields so the dashboard can show what Hermes will run
-// with when no BYOK Profile is bound, and so the UI doesn't pretend that an
-// already-configured Hermes "needs" to be re-configured inside pikiloom.
-//
-// Limited surface: only the top-level `model.*` and `agent.reasoning_effort`
-// keys we care about. Implemented with simple string matching (no YAML
-// dependency) since the schema is stable and shallow.
-// ---------------------------------------------------------------------------
 let cachedNativeConfig = null;
 function readHermesNativeConfig() {
     const path = join(homedir(), '.hermes', 'config.yaml');
     if (!existsSync(path))
         return null;
-    // Cheap mtime check — re-read only when the file has changed.
     let mtimeMs;
     try {
         mtimeMs = statSync(path).mtimeMs;
@@ -650,14 +536,10 @@ function readHermesNativeConfig() {
         return null;
     }
     const blockOf = (name) => {
-        // Captures consecutive indented lines under `name:` (a top-level mapping).
-        // Stops at the first non-indented line, which marks the next top-level
-        // key. Plain (no `m` flag) so `.` matches across lines via [^\n].
         const re = new RegExp(`(?:^|\\n)${name}:[ \\t]*\\n((?:[ \\t]+[^\\n]*\\n?)+)`);
         return text.match(re)?.[1] || '';
     };
     const valueOf = (block, key) => {
-        // The key must be at any indentation level deeper than the parent.
         const m = block.match(new RegExp(`(?:^|\\n)[ \\t]+${key}:[ \\t]*([^\\n]*)`));
         if (!m)
             return null;
@@ -682,7 +564,6 @@ function getHermesUsage(_opts) {
     return emptyUsage('hermes', 'Run `hermes insights` for token analytics.');
 }
 async function getHermesUsageLive(_opts) {
-    // Spawn `hermes insights --days 30 --source tool` and parse output.
     return new Promise(resolve => {
         let stdout = '';
         let stderr = '';
@@ -725,7 +606,6 @@ async function getHermesUsageLive(_opts) {
     });
 }
 function parseHermesInsightsOutput(text) {
-    // Minimal parser: extract Sessions / Total tokens summary line.
     const out = [];
     const sessionsMatch = text.match(/Sessions:\s+(\d+)/);
     const totalTokensMatch = text.match(/Total tokens:\s+([\d,]+)/);
@@ -744,18 +624,11 @@ function parseHermesInsightsOutput(text) {
     }
     return out;
 }
-// ---------------------------------------------------------------------------
-// Driver registration
-// ---------------------------------------------------------------------------
 const HermesDriver = {
     id: 'hermes',
     cmd: 'hermes',
     thinkLabel: 'Reasoning',
-    // Hermes locks the model at profile-binding time. The ACP `session/set_model`
-    // hook exists but is unreliable across providers in current Hermes builds, so
-    // pikiloom treats the model as fixed for the session and hides the picker.
     capabilities: { fork: false, modelSwitch: false, workflow: false },
-    // Hermes is BYOK-only — every Profile kind is fair game.
     acceptedProviderKinds: ['anthropic', 'openai', 'openai-compatible', 'google'],
     doStream: doHermesStream,
     getSessions: getHermesSessions,
@@ -766,7 +639,6 @@ const HermesDriver = {
     getUsageLive: getHermesUsageLive,
     getNativeConfig: getHermesNativeConfig,
     shutdown() {
-        /* Per-stream AcpClient is closed in doStream finally; nothing process-wide. */
     },
 };
 registerDriver(HermesDriver);