@addai/node 0.4.0

package/dist/events.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bufferedEvents = bufferedEvents;
+exports.normalizeJsonlLine = normalizeJsonlLine;
+/**
+ * Event source for degenerate spawn handles (binary not installed / spawn
+ * threw synchronously). The old pattern — queueMicrotask over a listeners
+ * array — silently DROPPED the events: session-runner attaches onEvent only
+ * after `await setStatus(...)`, and the microtask fires at that first await,
+ * when the listeners array is still empty. The request then completed with
+ * no error ever surfaced to the chat.
+ *
+ * This buffers the events and delivers them (async, preserving the old
+ * post-return timing contract) to each listener when it attaches.
+ */
+function bufferedEvents(events) {
+    const pending = [...events];
+    const listeners = [];
+    const drain = () => {
+        while (pending.length) {
+            const e = pending.shift();
+            for (const l of listeners) {
+                try {
+                    l(e);
+                }
+                catch { /* listener error */ }
+            }
+        }
+    };
+    return {
+        onEvent: (cb) => {
+            listeners.push(cb);
+            queueMicrotask(drain);
+        },
+    };
+}
+/**
+ * Pure transform from one line of Claude's JSONL transcript into zero or
+ * more RuntimeEvent objects.
+ *
+ *   - `user` lines: extract any tool_result content blocks (caller's own
+ *     prompt echoes are dropped — they already know what they sent).
+ *   - `assistant` lines: text blocks → assistant_text, tool_use blocks
+ *     → tool_use. String content → single assistant_text.
+ *   - Everything else → claude:<type> forward-compat passthrough.
+ */
+function normalizeJsonlLine(line) {
+    const type = typeof line.type === 'string' ? line.type : undefined;
+    if (!type)
+        return [];
+    if (type === 'user') {
+        const message = line.message;
+        const content = message?.content;
+        if (!Array.isArray(content))
+            return [];
+        const events = [];
+        for (const block of content) {
+            if (block?.type === 'tool_result') {
+                events.push({
+                    type: 'tool_result',
+                    id: String(block.tool_use_id ?? ''),
+                    content: block.content,
+                    isError: block.is_error === true,
+                });
+            }
+        }
+        return events;
+    }
+    if (type === 'assistant') {
+        const message = line.message;
+        if (!message)
+            return [];
+        const content = message.content;
+        if (typeof content === 'string') {
+            return [{ type: 'assistant_text', delta: content }];
+        }
+        if (Array.isArray(content)) {
+            const events = [];
+            for (const block of content) {
+                if (block?.type === 'text' && typeof block.text === 'string') {
+                    events.push({ type: 'assistant_text', delta: block.text });
+                }
+                else if (block?.type === 'tool_use') {
+                    events.push({
+                        type: 'tool_use',
+                        id: String(block.id ?? ''),
+                        name: String(block.name ?? ''),
+                        input: block.input,
+                    });
+                }
+            }
+            return events;
+        }
+        return [];
+    }
+    return [{ type: `claude:${type}`, raw: line }];
+}

package/dist/gemini-binary.d.ts

@@ -0,0 +1,4 @@
+/** Forget the cached lookup — call after an install so a fresh probe
+ *  can see a binary that was missing at daemon start. */
+export declare function resetCache(): void;
+export declare function findGeminiBinary(): string | null;

package/dist/gemini-binary.js

@@ -0,0 +1,64 @@
+"use strict";
+// Locate the `gemini` binary (Google's gemini-cli) on the host.
+// `npm install -g @google/gemini-cli` puts it on PATH as `gemini`
+// (a .cmd shim under %APPDATA%\npm on Windows).
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetCache = resetCache;
+exports.findGeminiBinary = findGeminiBinary;
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const win_1 = require("./win");
+const POSIX_CANDIDATES = [
+    '/usr/local/bin/gemini',
+    '/opt/homebrew/bin/gemini',
+    path.join(os.homedir(), '.npm-global/bin/gemini'),
+];
+const WIN32_CANDIDATES = [
+    path.join(os.homedir(), '.npm-global', 'gemini.cmd'),
+];
+/** Forget the cached lookup — call after an install so a fresh probe
+ *  can see a binary that was missing at daemon start. */
+function resetCache() { cached = undefined; }
+let cached;
+function findGeminiBinary() {
+    if (cached !== undefined)
+        return cached;
+    cached = (0, win_1.findCliBinary)('gemini', {
+        posixCandidates: POSIX_CANDIDATES,
+        win32Candidates: WIN32_CANDIDATES,
+    });
+    return cached;
+}

package/dist/gemini-spawn.d.ts

@@ -0,0 +1,52 @@
+import type { RuntimeEvent, RuntimeEffortLevel } from './types';
+export interface GeminiMcpServer {
+    slug: string;
+    command: string;
+    args?: string[] | null;
+    env?: Record<string, string> | null;
+}
+export interface GeminiInput {
+    workingDirectory: string;
+    prompt: string;
+    model?: string;
+    resumeSessionId?: string;
+    appendSystemPrompt?: string;
+    mcpServers?: GeminiMcpServer[];
+    /** Per-run reasoning effort. gemini-cli has no verified reasoning-effort
+     *  CLI flag, so we do NOT forward one (an unsupported flag would fail the
+     *  spawn). The level is exported as GEMINI_REASONING_EFFORT so an opt-in
+     *  config/wrapper can read it; if gemini ignores it, behaviour is
+     *  unchanged. */
+    effortLevel?: RuntimeEffortLevel;
+}
+export interface GeminiHandle {
+    pid: number | undefined;
+    sessionId: string | null;
+    kill(): void;
+    onEvent(cb: (e: RuntimeEvent) => void): void;
+    done: Promise<number>;
+}
+/** gemini-cli session ids are v4 UUIDs (createSessionId → node randomUUID).
+ *  Only pass a plausibly-gemini id to `--resume`; a foreign id would just be
+ *  reported "Invalid session identifier" and the run degrades to fresh via the
+ *  runner's isSessionInvalid clear-and-retry path (see error-classify). */
+export declare function isGeminiSessionId(id: string): boolean;
+/**
+ * Parse one gemini-cli v0.52 stream-json line into 0+ RuntimeEvents.
+ *
+ * VERIFIED against @google/gemini-cli@0.52.0's StreamJsonFormatter
+ * (bundle/gemini-*.js). The wire shapes are:
+ *   INIT        { type:'init', session_id, model }             ← session id captured at spawn
+ *   assistant   { type:'message', role:'assistant', content:'<text>', delta:true }
+ *   prompt echo { type:'message', role:'user', ... }           ← MUST be skipped
+ *   tool call   { type:'tool_use', tool_id, tool_name, parameters }
+ *   tool result { type:'tool_result', tool_id, output, status }
+ *   fatal       { type:'result', status:'error', error:{type,message}, stats }
+ *
+ * The OLD parser matched invented types (content/text/assistant_delta) and
+ * invented field names (id/tool_call_id, name/tool, arguments/input,
+ * result/content) — none of which gemini emits — so every reply was silently
+ * empty and every tool event was mis-shaped.
+ */
+export declare function lineToEvents(line: Record<string, unknown>): RuntimeEvent[];
+export declare function spawnGemini(input: GeminiInput): GeminiHandle;

package/dist/gemini-spawn.js

@@ -0,0 +1,369 @@
+"use strict";
+// gemini -p <prompt> --output-format stream-json adapter.
+//
+// Mirrors the kimi / codex / claude adapters: spawns gemini-cli
+// non-interactively, parses the JSONL stream into RuntimeEvents,
+// resolves on exit. The host's ~/.gemini/settings.json is hidden via
+// HOME override so MCP servers from the user's global config don't
+// leak into chats — only the MCPs we explicitly pass land.
+//
+// gemini-cli reads MCP servers from ~/.gemini/settings.json under the
+// `mcpServers` key. We write a sandbox settings file with only our
+// servers and point gemini at it via HOME redirect.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGeminiSessionId = isGeminiSessionId;
+exports.lineToEvents = lineToEvents;
+exports.spawnGemini = spawnGemini;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const gemini_binary_1 = require("./gemini-binary");
+const win_1 = require("./win");
+const events_1 = require("./events");
+/**
+ * Write a workspace-scope `<cwd>/.gemini/settings.json` for THIS spawn.
+ *
+ * gemini-cli's settings hierarchy is workspace > user — a workspace
+ * settings file wins over `~/.gemini/settings.json` field-by-field, so
+ * we can override `mcpServers` (the field we care about) without
+ * touching the user's home dir.
+ *
+ * The OLD approach pointed HOME at a temp dir to suppress the host's
+ * `~/.gemini/settings.json`. That was destructive: gemini-cli shells out
+ * to git, npm, node, and those tools read `~/.gitconfig`, `~/.npmrc`,
+ * `~/.netrc` from HOME. Pointing HOME at an empty dir blew them all
+ * away → silent tool failures (git push without creds, etc.).
+ */
+function writeGeminiWorkspaceSettings(cwd, servers) {
+    const dir = path.join(cwd, '.gemini');
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const mcpServers = {};
+    for (const s of servers) {
+        if (!s.slug || !s.command)
+            continue;
+        // `cmd /c` wrapper for npm-shim commands on native Windows (no-op on POSIX).
+        const wrapped = (0, win_1.wrapMcpCommandForPlatform)(s.command, Array.isArray(s.args) ? s.args : []);
+        mcpServers[s.slug] = {
+            command: wrapped.command,
+            ...(wrapped.args.length > 0 ? { args: wrapped.args } : {}),
+            ...(s.env && Object.keys(s.env).length > 0 ? { env: s.env } : {}),
+        };
+    }
+    // Start with the host's settings so auth method (security.auth.selectedType
+    // = oauth-personal etc.) and theme carry through. Override just mcpServers.
+    const hostSettingsPath = path.join(os.homedir(), '.gemini', 'settings.json');
+    let baseSettings = {};
+    if (fs.existsSync(hostSettingsPath)) {
+        try {
+            baseSettings = JSON.parse(fs.readFileSync(hostSettingsPath, 'utf8'));
+        }
+        catch { /* corrupt — start fresh */ }
+    }
+    const merged = { ...baseSettings, mcpServers };
+    const settingsPath = path.join(dir, 'settings.json');
+    fs.writeFileSync(settingsPath, JSON.stringify(merged, null, 2), { mode: 0o600 });
+    return settingsPath;
+}
+/** gemini-cli session ids are v4 UUIDs (createSessionId → node randomUUID).
+ *  Only pass a plausibly-gemini id to `--resume`; a foreign id would just be
+ *  reported "Invalid session identifier" and the run degrades to fresh via the
+ *  runner's isSessionInvalid clear-and-retry path (see error-classify). */
+function isGeminiSessionId(id) {
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id);
+}
+/**
+ * Parse one gemini-cli v0.52 stream-json line into 0+ RuntimeEvents.
+ *
+ * VERIFIED against @google/gemini-cli@0.52.0's StreamJsonFormatter
+ * (bundle/gemini-*.js). The wire shapes are:
+ *   INIT        { type:'init', session_id, model }             ← session id captured at spawn
+ *   assistant   { type:'message', role:'assistant', content:'<text>', delta:true }
+ *   prompt echo { type:'message', role:'user', ... }           ← MUST be skipped
+ *   tool call   { type:'tool_use', tool_id, tool_name, parameters }
+ *   tool result { type:'tool_result', tool_id, output, status }
+ *   fatal       { type:'result', status:'error', error:{type,message}, stats }
+ *
+ * The OLD parser matched invented types (content/text/assistant_delta) and
+ * invented field names (id/tool_call_id, name/tool, arguments/input,
+ * result/content) — none of which gemini emits — so every reply was silently
+ * empty and every tool event was mis-shaped.
+ */
+function lineToEvents(line) {
+    const type = typeof line.type === 'string' ? line.type : '';
+    // Assistant reply. gemini also echoes the user prompt as a role='user'
+    // message on the same 'message' type — skip it so we never replay the
+    // prompt back as if it were the answer. content is already a plain string.
+    if (type === 'message') {
+        const role = typeof line.role === 'string' ? line.role : '';
+        if (role !== 'assistant')
+            return []; // 'user' prompt-echo or other → drop
+        const text = typeof line.content === 'string' ? line.content : '';
+        return text ? [{ type: 'assistant_text', delta: text }] : [];
+    }
+    // Tool use — real fields: tool_id, tool_name, parameters.
+    if (type === 'tool_use') {
+        return [{
+                type: 'tool_use',
+                id: String(line.tool_id ?? ''),
+                name: String(line.tool_name ?? ''),
+                input: line.parameters,
+            }];
+    }
+    // Tool result — real fields: tool_id, output, status. Pairs with the
+    // tool_use above by tool_id.
+    if (type === 'tool_result') {
+        const status = typeof line.status === 'string' ? line.status.toLowerCase() : '';
+        return [{
+                type: 'tool_result',
+                id: String(line.tool_id ?? ''),
+                content: line.output,
+                // Only 'success' is a clean result; anything else (error/cancelled/…)
+                // marks the bubble as failed. An absent status stays non-error.
+                isError: status !== '' && status !== 'success',
+            }];
+    }
+    // Final result. On a fatal turn gemini sets status='error' and carries the
+    // real reason under error.message — surface it as an error event so the
+    // runner's lastError reports "429 / auth / model error" instead of exit_N.
+    if (type === 'result') {
+        const status = typeof line.status === 'string' ? line.status : '';
+        if (status === 'error') {
+            const message = line.error?.message
+                || (typeof line.message === 'string' ? line.message : 'gemini error');
+            return [
+                { type: 'error', code: 'gemini_error', message },
+                { type: 'turn_complete', stopReason: 'failed' },
+            ];
+        }
+        return [{
+                type: 'turn_complete',
+                usage: line.stats ?? line.usage ?? undefined,
+                stopReason: typeof line.stop_reason === 'string' ? line.stop_reason : undefined,
+            }];
+    }
+    // Standalone stream 'error' event. VERIFIED against the v0.52 bundle: this
+    // is gemini's NON-FATAL feedback/warning channel. It carries a `severity`
+    // of 'warning' OR 'error', and BOTH severities just push to a warnings[]
+    // list and CONTINUE the turn (context-compression, policy block,
+    // malformed-tool retry, loop-detected, max-session-turns, deprecation
+    // notices). Genuine terminal failures arrive as {type:'result',
+    // status:'error'} (handled above) or crash the process. The OLD code forced
+    // an `error` event + turn_complete{stopReason:'failed'} on EVERY one of
+    // these — fabricating a failed turn (and a bogus lastError / chat-UI error
+    // bubble) on runs that actually succeeded.
+    //
+    // Now: never synthesize turn_complete — let the process exit code drive
+    // terminal status (session-runner finalizes on exit; lastError is only
+    // consulted on a NON-zero exit). Only severity==='error' records a reason
+    // (so a subsequent fatal exit — e.g. a stale-resume "Invalid session
+    // identifier" printed just before process.exit — reports the real cause and
+    // is matchable by isSessionInvalid). severity 'warning'/absent is a benign,
+    // log-only passthrough.
+    if (type === 'error') {
+        const severity = typeof line.severity === 'string' ? line.severity : '';
+        if (severity === 'error') {
+            const message = line.error?.message
+                ?? (typeof line.message === 'string' ? line.message : 'gemini error');
+            return [{ type: 'error', code: 'gemini_error', message }];
+        }
+        return [{ type: 'gemini:warning', raw: line }];
+    }
+    // Unknown event types (incl. 'init') are tagged with the agent namespace so
+    // downstream consumers can filter them. The session_id on 'init' is captured
+    // by the stdout reader, not here.
+    return [{ type: `gemini:${type || 'unknown'}`, raw: line }];
+}
+function spawnGemini(input) {
+    const bin = (0, gemini_binary_1.findGeminiBinary)();
+    if (!bin) {
+        // bufferedEvents delivers even though the runner attaches its
+        // listener after an await (the old queueMicrotask pattern dropped these).
+        const events = (0, events_1.bufferedEvents)([
+            { type: 'error', code: 'gemini_not_installed', message: 'gemini CLI is not installed on this runtime. Install: npm install -g @google/gemini-cli' },
+            { type: 'turn_complete', stopReason: 'failed' },
+        ]);
+        return {
+            pid: undefined,
+            sessionId: null,
+            kill: () => { },
+            onEvent: events.onEvent,
+            done: Promise.resolve(127),
+        };
+    }
+    // Write workspace-scope settings (overrides host mcpServers without
+    // touching HOME). Auth files in ~/.gemini stay where they are — no
+    // symlinking needed since gemini reads them via $HOME, which is now
+    // the real one.
+    writeGeminiWorkspaceSettings(input.workingDirectory, input.mcpServers ?? []);
+    const args = [
+        '-p', input.appendSystemPrompt && input.appendSystemPrompt.trim().length > 0
+            ? `[system]\n${input.appendSystemPrompt.trim()}\n[/system]\n\n${input.prompt}`
+            : input.prompt,
+        '--output-format', 'stream-json',
+    ];
+    if (input.model)
+        args.push('-m', input.model);
+    // Bypass gemini's "trusted folders" gate. We're a headless runtime
+    // running in ephemeral session cwds — there's no user to interactively
+    // approve. Either --skip-trust on the CLI OR the env var works; the
+    // env var avoids touching the prompt args.
+    args.push('--skip-trust');
+    // Resume a prior turn's session. gemini-cli v0.52 DOES support this:
+    // `--resume <uuid>` (SessionSelector.findSession matches by session id
+    // first, then index). The session store is keyed by the cwd-derived project
+    // hash, and continuation turns reuse the prior turn's working_directory
+    // (session-runner resolveCwdAndProject), so the prior session's chats/*.jsonl
+    // is discoverable — same mechanism claude/grok resume rely on. If the id is
+    // stale/foreign, gemini prints "Invalid session identifier" and exits
+    // non-zero → the runner's isSessionInvalid clears the id and retries fresh.
+    if (input.resumeSessionId && isGeminiSessionId(input.resumeSessionId)) {
+        args.push('--resume', input.resumeSessionId);
+    }
+    // No HOME override — gemini's auth + shell-out tools all need the
+    // real $HOME. Workspace-scope settings.json (written above) is enough
+    // to override the host's mcpServers without poisoning everything else.
+    const childEnv = {
+        ...process.env,
+        TERM: 'dumb',
+        // Belt and suspenders alongside --skip-trust — some gemini code
+        // paths check this env var directly.
+        GEMINI_CLI_TRUST_WORKSPACE: 'true',
+        // Surface the requested reasoning effort without betting on a CLI flag
+        // that may not exist; ignored harmlessly if gemini doesn't read it.
+        ...(input.effortLevel ? { GEMINI_REASONING_EFFORT: input.effortLevel } : {}),
+    };
+    const listeners = [];
+    const emit = (e) => { for (const l of listeners)
+        try {
+            l(e);
+        }
+        catch { } };
+    let sessionId = null;
+    let buffer = '';
+    let proc;
+    try {
+        // npm .cmd shim → node script (win32); identity on POSIX. Both this
+        // resolution and spawn() itself can throw synchronously on Windows —
+        // fail the request cleanly instead of crashing the daemon.
+        const inv = (0, win_1.resolveCliInvocation)(bin, args);
+        proc = (0, child_process_1.spawn)(inv.file, inv.args, {
+            cwd: input.workingDirectory,
+            env: childEnv,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+    }
+    catch (err) {
+        const msg = err.message || String(err);
+        const events = (0, events_1.bufferedEvents)([
+            { type: 'error', code: 'gemini_spawn_failed', message: msg },
+            { type: 'turn_complete', stopReason: 'failed' },
+        ]);
+        return {
+            pid: undefined,
+            sessionId: null,
+            kill: () => { },
+            onEvent: events.onEvent,
+            done: Promise.resolve(-1),
+        };
+    }
+    proc.stdout?.on('data', (chunk) => {
+        buffer += chunk.toString('utf8');
+        let nl;
+        while ((nl = buffer.indexOf('\n')) !== -1) {
+            const raw = buffer.slice(0, nl).trim();
+            buffer = buffer.slice(nl + 1);
+            if (!raw)
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch {
+                continue;
+            }
+            if (typeof parsed.session_id === 'string' && !sessionId)
+                sessionId = parsed.session_id;
+            for (const ev of lineToEvents(parsed))
+                emit(ev);
+        }
+    });
+    proc.stderr?.on('data', (chunk) => {
+        const txt = chunk.toString('utf8').trim();
+        if (txt)
+            emit({ type: 'error', code: 'gemini_stderr', message: txt.slice(0, 4096) });
+    });
+    const done = new Promise((resolve, reject) => {
+        proc.once('error', reject);
+        let exitCode = -1;
+        proc.once('exit', (code) => { exitCode = code ?? -1; });
+        // Resolve on 'close' (all stdio EOF), NOT 'exit'. gemini prints its fatal
+        // reason — most importantly a stale-resume "Error resuming session:
+        // Invalid session identifier" / "No previous sessions found" — as a FINAL
+        // stdout stream-json error line and then process.exit()s immediately.
+        // Resolving on 'exit' can finalize the request before that last stdout
+        // 'data' event is processed, leaving lastError null → the runner reports a
+        // bare exit_N and isSessionInvalid never sees the message to self-heal.
+        // 'close' fires only after stdout/stderr have been fully delivered, so the
+        // error line is parsed and lastError is set first.
+        proc.once('close', () => {
+            // Flush any trailing line that had no newline terminator.
+            const raw = buffer.trim();
+            buffer = '';
+            if (raw) {
+                try {
+                    const parsed = JSON.parse(raw);
+                    if (typeof parsed.session_id === 'string' && !sessionId)
+                        sessionId = parsed.session_id;
+                    for (const ev of lineToEvents(parsed))
+                        emit(ev);
+                }
+                catch { /* ignore a partial/non-JSON tail */ }
+            }
+            // No HOME-temp-dir to clean up anymore. The workspace settings file in
+            // <cwd>/.gemini/settings.json sits with the rest of the ephemeral cwd
+            // and is cleaned by the session dispose path.
+            resolve(exitCode);
+        });
+    });
+    return {
+        pid: proc.pid,
+        get sessionId() { return sessionId; },
+        kill: () => { (0, win_1.killProcessTree)(proc); },
+        onEvent: (cb) => { listeners.push(cb); },
+        done,
+    };
+}

package/dist/git-identity.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Give a freshly cloned repo the ENTITY's git identity, and optionally credit
+ * the person who asked for the work.
+ *
+ * Without this, commits land under whatever global git config the host machine
+ * happens to have — usually the machine's owner, which is wrong and confusing
+ * when several entities share a node.
+ *
+ * Identity comes from runtime_get_git_identity rather than the request row: six
+ * different RPCs create those rows and threading two more columns through all of
+ * them is needless fragility.
+ *
+ * On avatars: GitHub derives a commit's avatar from the email, so an entity's
+ * own photo cannot appear there without a real GitHub account per entity. The
+ * co-author trailer is what puts a real avatar and a real GitHub identity on the
+ * commit, which is why it defaults on.
+ */
+export declare function applyGitIdentity(dir: string, requestId: string, token: string): Promise<void>;