pikiloom 0.4.26 → 0.4.28

package/dist/agent/drivers/codex.js

@@ -1,19 +1,11 @@
-/**
- * Codex CLI driver: HTTP server management, streaming, human-in-the-loop.
- */
 import fs from 'node:fs';
 import path from 'node:path';
 import { execSync, spawn } from 'node:child_process';
 import { registerDriver } from '../driver.js';
 import { terminateProcessTree } from '../../core/process-control.js';
-import { mimeForExt, 
-// shared helpers
-agentLog, agentWarn, buildStreamPreviewMeta, pushRecentActivity, normalizeActivityLine, firstNonEmptyLine, shortValue, numberOrNull, normalizeStreamPreviewPlan, IMAGE_EXTS, listPikiloomSessions, findPikiloomSession, mergeManagedAndNativeSessions, managedRecordToSessionInfo, stripInjectedPrompts, sanitizeSessionUserPreviewText, computeContext, readTailLines, applyTurnWindow, roundPercent, toIsoFromEpochSeconds, labelFromWindowMinutes, usageWindowFromRateLimit, parseJsonTail, emptyUsage, attachAgentImage, codexHome, Q, } from '../index.js';
+import { mimeForExt, agentLog, agentWarn, buildStreamPreviewMeta, pushRecentActivity, normalizeActivityLine, firstNonEmptyLine, shortValue, numberOrNull, normalizeStreamPreviewPlan, IMAGE_EXTS, listPikiloomSessions, findPikiloomSession, mergeManagedAndNativeSessions, managedRecordToSessionInfo, stripInjectedPrompts, sanitizeSessionUserPreviewText, computeContext, readTailLines, applyTurnWindow, roundPercent, toIsoFromEpochSeconds, labelFromWindowMinutes, usageWindowFromRateLimit, parseJsonTail, emptyUsage, attachAgentImage, codexHome, Q, } from '../index.js';
 import { CODEX_APPSERVER_SPAWN_TIMEOUT_MS as _CODEX_APPSERVER_SPAWN_TIMEOUT_MS, CODEX_STREAM_HARD_KILL_GRACE_MS, SESSION_RUNNING_THRESHOLD_MS, } from '../../core/constants.js';
 import { getHome } from '../../core/platform.js';
-// ---------------------------------------------------------------------------
-// App-server JSON-RPC client
-// ---------------------------------------------------------------------------
 const CODEX_APPSERVER_SPAWN_TIMEOUT_MS = _CODEX_APPSERVER_SPAWN_TIMEOUT_MS;
 export class CodexAppServer {
     proc = null;
@@ -42,9 +34,6 @@ export class CodexAppServer {
         return new Promise((resolve) => {
             const timer = setTimeout(() => { this.kill(); resolve(false); }, CODEX_APPSERVER_SPAWN_TIMEOUT_MS);
             const args = ['app-server'];
-            // Always enable codex's native /goal feature so pikiloom can route through
-            // codex's own `thread/goal/*` RPC + continuation engine. User-supplied -c
-            // overrides win.
             const overrides = this.configOverrides.some(entry => /^features\.goals\s*=/.test(entry))
                 ? this.configOverrides
                 : [...this.configOverrides, 'features.goals=true'];
@@ -109,15 +98,11 @@ export class CodexAppServer {
             proc.on('close', () => {
                 this.ready = false;
                 this.proc = null;
-                // Resolve any pending RPC calls so callers don't hang forever
                 for (const [id, cb] of this.pending) {
                     cb({ error: { message: 'process exited before responding' } });
                 }
                 this.pending.clear();
             });
-            // Declare experimentalApi so `thread/goal/*` is reachable. Codex 0.130+
-            // gates these RPCs behind that capability — without it, every goal call
-            // returns "requires experimentalApi capability".
             this.call('initialize', {
                 clientInfo: { name: 'pikiloom', version: '0.2.0' },
                 capabilities: { experimentalApi: true },
@@ -213,7 +198,6 @@ export class CodexAppServer {
         catch { }
     }
 }
-/** Singleton app-server for shared operations (sessions, models, usage). */
 let _sharedServer = null;
 function getSharedServer() {
     if (!_sharedServer)
@@ -248,7 +232,6 @@ function unwrapGoal(raw) {
         updatedAt: typeof g.updatedAt === 'number' ? g.updatedAt : 0,
     };
 }
-/** Set / replace the active goal on a codex thread. Codex auto-starts a continuation turn if it is idle. */
 export async function setCodexGoal(opts) {
     const srv = await ensureSharedServerForGoal();
     if (!srv)
@@ -291,9 +274,6 @@ export async function pauseCodexGoal(threadId) {
 export async function resumeCodexGoal(threadId) {
     return setCodexGoal({ threadId, status: 'active' });
 }
-// ---------------------------------------------------------------------------
-// Effort mapping
-// ---------------------------------------------------------------------------
 const EFFORT_MAP = {
     low: 'low', medium: 'medium', high: 'high', min: 'minimal', max: 'xhigh',
 };
@@ -482,19 +462,9 @@ function formatCodexPlanSummary(plan) {
         lines.push(`[${step.status}] ${step.step}`);
     return lines.join('\n').trim();
 }
-/**
- * Resolve the on-disk path Codex writes generated images to. Format:
- *   `$CODEX_HOME/generated_images/<sessionId>/<call_id>.png`
- *
- * The developer-message Codex injects when its built-in `image_gen` tool fires
- * documents this convention (`Generated images are saved to … as …/<id>.png`).
- * We honour `$CODEX_HOME`; the SKILL.md prescribes `.png` as the only output
- * format for the built-in tool.
- */
 function codexImagePathFor(sessionId, callId) {
     return path.join(codexHome(), 'generated_images', sessionId, `${callId}.png`);
 }
-/** Build an image MessageBlock from a Codex `image_generation_call` payload. */
 function buildCodexImageBlock(sessionId, payload, phase) {
     const callId = typeof payload?.id === 'string' ? payload.id
         : typeof payload?.call_id === 'string' ? payload.call_id
@@ -503,22 +473,8 @@ function buildCodexImageBlock(sessionId, payload, phase) {
         return null;
     const filePath = codexImagePathFor(sessionId, callId);
     const caption = typeof payload?.revised_prompt === 'string' ? payload.revised_prompt : undefined;
-    return attachAgentImage({ imagePath: filePath, caption, phase });
-}
-/**
- * Idempotently push the image MessageBlock for a Codex `image_gen` call to the
- * stream state. Returns true if a block was emitted on this invocation.
- *
- * Codex emits image_generation_call across several inconsistent paths depending
- * on the app-server build: `item/started`, `item/completed`, and
- * `rawResponseItem/completed` may all fire — or some may be skipped (we've seen
- * runs where only `image_generation_end` lands and the response item is frozen
- * at status="generating", so no completion notification ever arrives). This
- * helper lets every code path call into one place; the pendingImageGen map is
- * the source of truth for "not yet emitted." On success we drop the pending
- * entry and decrement the in-flight counter; on miss (file not yet on disk) we
- * leave the entry so a later event — or the turn-end drain — can retry.
- */
+    return attachAgentImage({ imagePath: filePath, caption, captionKind: 'prompt', phase });
+}
 function tryEmitCodexImageBlock(s, callId, revisedPrompt) {
     if (!callId || !s.sessionId)
         return false;
@@ -711,9 +667,6 @@ function buildCodexPreviewText(s) {
         return `${commentary}\n\n${finalText}`;
     return commentary || finalText;
 }
-// ---------------------------------------------------------------------------
-// Token usage
-// ---------------------------------------------------------------------------
 function buildCodexCumulativeUsage(raw) {
     if (!raw || typeof raw !== 'object')
         return null;
@@ -769,19 +722,12 @@ function applyCodexTokenUsage(s, rawUsage, prev) {
         if (lastCached == null)
             s.cachedInputTokens = prev ? Math.max(0, total.cached - prev.cached) : total.cached;
     }
-    // NOTE: do NOT set s.contextUsedTokens from cumulative totals —
-    // those counters span the full thread, not the current turn. Use the per-turn
-    // `last` usage only. `cached_input_tokens` is already a subset of
-    // `input_tokens`, so adding it again inflates the context percentage.
     if (!s.byokContextWindow) {
         const contextWindow = numberOrNull(info.modelContextWindow, info.model_context_window, rawUsage.modelContextWindow, rawUsage.model_context_window);
         if (contextWindow != null && contextWindow > 0)
             s.contextWindow = contextWindow;
     }
 }
-// ---------------------------------------------------------------------------
-// Turn input
-// ---------------------------------------------------------------------------
 export function buildCodexTurnInput(prompt, attachments) {
     const input = [];
     for (const filePath of attachments) {
@@ -796,8 +742,6 @@ export function buildCodexTurnInput(prompt, attachments) {
     return input;
 }
 function createCodexStreamState(opts) {
-    // BYOK: lock in the provider-cached context window so codex's own (often
-    // wrong, model-dependent) `model_context_window` reports get ignored later.
     const byokWindow = opts.byokContextWindow && opts.byokContextWindow > 0
         ? opts.byokContextWindow
         : null;
@@ -839,14 +783,10 @@ function codexErrorResult(error, start, sessionId, model, thinkingEffort) {
         codexCumulative: null, stopReason: null, incomplete: true, activity: null,
     };
 }
-// ---------------------------------------------------------------------------
-// Stream notification handler (extracted from doCodexStream)
-// ---------------------------------------------------------------------------
 function handleCodexNotification(method, params, s, opts, deadline, emit, hardTimer, settleTurnDone, publishTurnControl) {
     if (Date.now() > deadline)
         return;
     if (params.threadId !== s.sessionId) {
-        // Only turn/started and model/rerouted are checked below; all others already filter on threadId.
         if (method !== 'turn/started' && method !== 'model/rerouted')
             return;
         if (params.threadId !== s.sessionId)
@@ -926,10 +866,6 @@ function handleItemStarted(item, s, emit) {
             emit();
         }
     }
-    // Codex's built-in `image_gen` tool surfaces as a distinct item type. Track
-    // the in-flight count so renderers can show "Generating image…" while the
-    // bytes are being written. Item id naming differs across Codex versions
-    // (`imageGenerationCall` / `image_generation_call`); accept either form.
     if (item.id && (item.type === 'imageGenerationCall' || item.type === 'image_generation_call')) {
         if (!s.pendingImageGen.has(item.id))
             s.generatingImages++;
@@ -938,11 +874,6 @@ function handleItemStarted(item, s, emit) {
                 : typeof item.revised_prompt === 'string' ? item.revised_prompt : undefined,
         });
         pushRecentActivity(s.recentNarrative, 'Generating image...');
-        // Some codex builds never fire a "completed" event for image_generation_call
-        // (rollout shows the item frozen at status="generating"). The PNG is on
-        // disk by the time item/started lands, so try an opportunistic emit here;
-        // tryEmit is a no-op when the file isn't ready yet — handleItemCompleted /
-        // rawResponseItem/completed / the turn-end drain will pick it up later.
         tryEmitCodexImageBlock(s, item.id);
         emit();
     }
@@ -1005,17 +936,10 @@ function handleRawResponseItemCompleted(item, s, emit) {
             return;
         }
     }
-    // image_generation_call: Codex's built-in image_gen has just finished writing
-    // the file at $CODEX_HOME/generated_images/<sessionId>/<id>.png. Read it into
-    // an image MessageBlock so the bot's final-reply path can dispatch it to IM
-    // channels and the dashboard renders it inline.
     if (item?.type === 'image_generation_call' || item?.type === 'imageGenerationCall') {
         const callId = typeof item.id === 'string' ? item.id
             : typeof item.call_id === 'string' ? item.call_id : '';
         if (callId) {
-            // Merge revised_prompt from this event with anything we stashed earlier —
-            // different Codex builds attach it on different events. Idempotent helper
-            // handles the dedupe against item/started + handleItemCompleted paths.
             const revisedPrompt = typeof item.revised_prompt === 'string' ? item.revised_prompt
                 : typeof item.revisedPrompt === 'string' ? item.revisedPrompt
                     : undefined;
@@ -1036,12 +960,6 @@ function handleCompletedAgentMessage(item, s, emit) {
         const text = item.text?.trim();
         if (text) {
             s.msgs.push(text);
-            // When Codex emits the final-answer body without intervening deltas
-            // (short replies, certain provider configs), `s.text` is empty and the
-            // preview would stay blank until doCodexStream's turn-end backfill.
-            // Append the completed body now so the live stream catches up. The
-            // delta-seen set tells us whether we'd be duplicating content already
-            // accumulated via item/agentMessage/delta.
             const alreadyStreamed = item.id && s.deltaSeenForItem.has(item.id);
             if (!alreadyStreamed) {
                 s.text = s.text.trim() ? `${s.text.trim()}\n\n${text}` : text;
@@ -1098,9 +1016,6 @@ function handleTurnPlanUpdated(params, s, emit) {
     };
     emit();
 }
-// ---------------------------------------------------------------------------
-// Stream request handler (extracted from doCodexStream)
-// ---------------------------------------------------------------------------
 async function handleCodexRequest(method, params, requestId, s, opts, emit) {
     const interaction = toAgentInteraction(method, params, requestId);
     if (!interaction)
@@ -1119,9 +1034,6 @@ async function handleCodexRequest(method, params, requestId, s, opts, emit) {
     }
     return defaultAgentInteractionResponse(interaction);
 }
-// ---------------------------------------------------------------------------
-// Stream via app-server
-// ---------------------------------------------------------------------------
 export async function doCodexStream(opts) {
     const start = Date.now();
     const srv = new CodexAppServer();
@@ -1140,9 +1052,6 @@ export async function doCodexStream(opts) {
                     config.push(opts.codexExtraArgs[++i]);
             }
         }
-        // Enable codex's native `/goal` feature so `thread/goal/*` RPCs work and
-        // the model gets the native `create_goal` / `update_goal` / `get_goal`
-        // tools + continuation engine. User-provided -c overrides win.
         if (!config.some(entry => /^features\.goals\s*=/.test(entry))) {
             config.push('features.goals=true');
         }
@@ -1189,7 +1098,6 @@ export async function doCodexStream(opts) {
                 agentWarn(`[codex-rpc] onCodexTurnReady error: ${error?.message || error}`);
             }
         };
-        // thread/start or thread/resume
         let threadResp;
         const threadParams = {
             cwd: opts.workdir,
@@ -1223,7 +1131,6 @@ export async function doCodexStream(opts) {
             }
         }
         agentLog(`[codex-rpc] thread ready: id=${s.sessionId} model=${s.model}`);
-        // turn/start
         const input = buildCodexTurnInput(opts.prompt, opts.attachments || []);
         const deadline = start + opts.timeout * 1000;
         const turnDone = new Promise((resolve) => {
@@ -1264,9 +1171,6 @@ export async function doCodexStream(opts) {
             s.turnError = s.turnError || 'Interrupted by user.';
             agentWarn(`[codex-rpc] abort requested thread=${s.sessionId || '?'} turn=${s.turnId || '?'}`);
             if (s.turnId && s.sessionId) {
-                // Send turn/interrupt and wait for Codex to acknowledge before settling.
-                // Don't kill the process here — let the finally block handle it after
-                // Codex has had time to persist the interrupted session state.
                 srv.call('turn/interrupt', { threadId: s.sessionId, turnId: s.turnId }, 5_000)
                     .finally(() => settleTurnDone?.());
             }
@@ -1278,7 +1182,6 @@ export async function doCodexStream(opts) {
         if (opts.abortSignal?.aborted)
             abortStream();
         opts.abortSignal?.addEventListener('abort', abortStream, { once: true });
-        // Log equivalent CLI command for reproducibility
         const cliParts = ['codex'];
         if (opts.codexModel)
             cliParts.push('--model', opts.codexModel);
@@ -1317,11 +1220,6 @@ export async function doCodexStream(opts) {
             s.text = s.msgs.join('\n\n');
         if (!s.thinking.trim() && s.thinkParts.length)
             s.thinking = s.thinkParts.join('\n\n');
-        // Drain any image_gen calls that started but never received a completion
-        // event. We've observed runs where the response_item stays at
-        // status="generating" and no `rawResponseItem/completed` fires — the PNG
-        // is on disk, we just never got told to emit it. Try once at turn end;
-        // tryEmit is a no-op for already-emitted entries.
         for (const callId of [...s.pendingImageGen.keys()]) {
             tryEmitCodexImageBlock(s, callId);
         }
@@ -1354,10 +1252,6 @@ export async function doCodexStream(opts) {
         srv.kill();
     }
 }
-// ---------------------------------------------------------------------------
-// Sessions
-// ---------------------------------------------------------------------------
-/** Load title index from ~/.codex/session_index.jsonl (deduped, last entry wins). */
 function loadCodexSessionIndex() {
     const home = getHome();
     if (!home)
@@ -1376,13 +1270,12 @@ function loadCodexSessionIndex() {
                 if (entry.id)
                     map.set(entry.id, { threadName: entry.thread_name || '', updatedAt: entry.updated_at || '' });
             }
-            catch { /* skip */ }
+            catch { }
         }
     }
-    catch { /* skip */ }
+    catch { }
     return map;
 }
-/** Scan ~/.codex/sessions/ rollout files to find sessions matching the given workdir. */
 function extractCodexTailQA(filePath) {
     const lines = readTailLines(filePath, 128 * 1024);
     let lastQuestion = null;
@@ -1410,7 +1303,7 @@ function extractCodexTailQA(filePath) {
                 }
             }
         }
-        catch { /* skip */ }
+        catch { }
     }
     return { lastQuestion, lastAnswer, lastMessageText };
 }
@@ -1439,12 +1332,6 @@ function readCodexSessionHead(filePath) {
         return null;
     }
 }
-// Per-file cache of the head meta + tail Q&A. getNativeCodexSessions walks the
-// whole y/m/d rollout tree and reads each file's 8KB head (to filter by cwd) on
-// every list request AND per workspace×agent in the overview fan-out. Keyed by
-// (mtime,size): unchanged rollouts — including other workspaces' files passed
-// while filtering — are never re-read. `running` depends on Date.now() so it is
-// recomputed per call, not cached.
 const nativeCodexContentCache = new Map();
 function getNativeCodexSessions(workdir, limit) {
     const home = getHome();
@@ -1455,9 +1342,6 @@ function getNativeCodexSessions(workdir, limit) {
         return [];
     const resolvedWorkdir = path.resolve(workdir);
     const titleIndex = loadCodexSessionIndex();
-    // Collect rollout files across the year/month/day tree, newest-first, then read
-    // bodies only as far as needed: `limit` applies to a recency-sorted merge
-    // downstream, so older rollouts can't surface in a top-`limit` view.
     const files = [];
     const walkDir = (dir) => {
         let entries;
@@ -1478,7 +1362,7 @@ function getNativeCodexSessions(workdir, limit) {
             try {
                 files.push({ filePath: fullPath, stat: fs.statSync(fullPath) });
             }
-            catch { /* skip */ }
+            catch { }
         }
     };
     walkDir(sessionsDir);
@@ -1488,8 +1372,6 @@ function getNativeCodexSessions(workdir, limit) {
     for (const { filePath, stat } of files) {
         let cached = nativeCodexContentCache.get(filePath);
         if (!cached || cached.mtimeMs !== stat.mtimeMs || cached.size !== stat.size) {
-            // First line can be very large (base_instructions), so read a head chunk
-            // and extract session_meta via regex instead of a full JSON parse.
             const meta = readCodexSessionHead(filePath);
             const matches = !!meta && !meta.isSubagent && path.resolve(meta.cwd) === resolvedWorkdir;
             cached = { mtimeMs: stat.mtimeMs, size: stat.size, meta, tailQA: matches ? extractCodexTailQA(filePath) : null };
@@ -1613,9 +1495,6 @@ function getCodexSessionTailFromRollout(opts) {
 }
 function getCodexSessions(workdir, limit) {
     const resolvedWorkdir = path.resolve(workdir);
-    // Merge pikiloom-tracked sessions with native Codex 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, 'codex').map(managedRecordToSessionInfo);
     const nativeSessions = getNativeCodexSessions(resolvedWorkdir, limit);
     const merged = mergeManagedAndNativeSessions(pikiloomSessions, nativeSessions);
@@ -1663,16 +1542,12 @@ async function getCodexSessionTail(opts) {
         return { ok: true, messages, error: null };
     return getCodexSessionTailFromRollout(opts);
 }
-// ---------------------------------------------------------------------------
-// Session messages (full content)
-// ---------------------------------------------------------------------------
 async function getCodexSessionMessages(opts) {
     if (opts.rich) {
         const rolloutResult = getCodexSessionMessagesFromRollout(opts);
         if (rolloutResult.ok)
             return rolloutResult;
     }
-    // Try RPC first
     const srv = getSharedServer();
     if (await srv.ensureRunning()) {
         try {
@@ -1690,7 +1565,6 @@ async function getCodexSessionMessages(opts) {
                                 if (c.type === 'text' && c.text)
                                     parts.push(c.text);
                                 else if (c.type === 'localImage' && c.path) {
-                                    // Read the image file if it still exists
                                     try {
                                         if (fs.existsSync(c.path) && fs.statSync(c.path).size <= 4 * 1024 * 1024) {
                                             const ext = path.extname(c.path).toLowerCase();
@@ -1698,7 +1572,7 @@ async function getCodexSessionMessages(opts) {
                                             blocks.push({ type: 'image', content: `data:${mimeForExt(ext)};base64,${data}` });
                                         }
                                     }
-                                    catch { /* skip unreadable images */ }
+                                    catch { }
                                 }
                             }
                             if (parts.length || blocks.length) {
@@ -1730,9 +1604,8 @@ async function getCodexSessionMessages(opts) {
                 }
             }
         }
-        catch { /* fall through to rollout */ }
+        catch { }
     }
-    // Fallback: read full rollout file
     return getCodexSessionMessagesFromRollout(opts);
 }
 function getCodexSessionMessagesFromRollout(opts) {
@@ -1867,9 +1740,6 @@ function getCodexSessionMessagesFromRollout(opts) {
                 sawAssistantResponseItems = true;
                 continue;
             }
-            // image_generation_call: Codex's built-in `image_gen` tool — surface the
-            // file on disk as an image block so historical sessions render images
-            // (not just text). Path: $CODEX_HOME/generated_images/<sessionId>/<id>.png
             if (payload.type === 'image_generation_call' || payload.type === 'imageGenerationCall') {
                 const block = buildCodexImageBlock(opts.sessionId, payload);
                 if (block) {
@@ -1900,10 +1770,7 @@ function getCodexSessionMessagesFromRollout(opts) {
         return { ok: false, messages: [], totalTurns: 0, error: e?.message || 'Failed to read session history' };
     }
 }
-// ---------------------------------------------------------------------------
-// Models (with TTL cache + stale fallback)
-// ---------------------------------------------------------------------------
-const MODEL_CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+const MODEL_CACHE_TTL_MS = 5 * 60 * 1000;
 let modelCache = null;
 function pushModel(models, seen, id, alias) {
     const cleanId = id.trim();
@@ -1912,7 +1779,6 @@ function pushModel(models, seen, id, alias) {
     seen.add(cleanId);
     models.push({ id: cleanId, alias: alias?.trim() || null });
 }
-/** Merge currentModel into a cached result so the selected model always appears first. */
 function withCurrentModel(cached, currentModel) {
     if (!currentModel?.trim())
         return cached;
@@ -1922,11 +1788,9 @@ function withCurrentModel(cached, currentModel) {
     return { ...cached, models: [{ id: cm, alias: null }, ...cached.models] };
 }
 async function discoverCodexModels(opts) {
-    // Return cached result if still fresh
     if (modelCache && Date.now() - modelCache.fetchedAt < MODEL_CACHE_TTL_MS) {
         return withCurrentModel(modelCache.result, opts.currentModel);
     }
-    // Try fetching fresh
     const srv = getSharedServer();
     if (!(await srv.ensureRunning())) {
         if (modelCache)
@@ -1954,9 +1818,6 @@ async function discoverCodexModels(opts) {
     modelCache = { result, fetchedAt: Date.now() };
     return result;
 }
-// ---------------------------------------------------------------------------
-// Usage
-// ---------------------------------------------------------------------------
 function getCodexStateDbPath(home) {
     const root = path.join(home, '.codex');
     if (!fs.existsSync(root))
@@ -1994,9 +1855,6 @@ function getCodexUsageFromStateDb(home) {
         return null;
     try {
         const query = "SELECT ts || '|' || message FROM logs WHERE message LIKE '%codex.rate_limits%' ORDER BY ts DESC LIMIT 1;";
-        // stdio: 'pipe' keeps sqlite3 stderr ("no such table", "unable to open") out
-        // of pikiloom's own stderr — this probe is best-effort and the catch below
-        // already swallows failures.
         const out = execSync(`sqlite3 -noheader ${Q(dbPath)} ${Q(query)}`, { encoding: 'utf-8', timeout: 3000, stdio: ['ignore', 'pipe', 'pipe'] }).trim();
         if (!out)
             return null;
@@ -2103,9 +1961,6 @@ export async function getCodexUsageLive() {
         windows, error: windows.length > 0 ? null : 'No rate limit windows.',
     };
 }
-// ---------------------------------------------------------------------------
-// Driver
-// ---------------------------------------------------------------------------
 class CodexDriver {
     id = 'codex';
     cmd = 'codex';
@@ -2136,12 +1991,6 @@ class CodexDriver {
     }
     shutdown() { shutdownCodexServer(); }
 }
-/**
- * Locate and remove the codex rollout file backing a session. Codex stores
- * sessions under `~/.codex/sessions/<year>/<month>/<day>/rollout-<...>.jsonl`,
- * keyed by `meta.sessionId` inside the file rather than the filename — so we
- * walk the tree and match on the parsed head metadata, scoped to `workdir`.
- */
 async function deleteNativeCodexSession(workdir, sessionId) {
     const home = getHome();
     if (!home || !sessionId)
@@ -2178,7 +2027,7 @@ async function deleteNativeCodexSession(workdir, sessionId) {
                 removed.push(full);
                 return true;
             }
-            catch { /* skip */ }
+            catch { }
         }
         return false;
     };