background-agents 0.1.1 → 0.1.2

package/dist/providers/base.js

@@ -1,10 +1,29 @@
-import { spawn } from "node:child_process";
-import * as readline from "node:readline";
 import { randomUUID } from "node:crypto";
 import { debugLog } from "../debug.js";
-import { getDefaultSessionPath, loadSession, storeSession } from "../utils/session.js";
-import { ensureCliInstalled } from "../utils/install.js";
 import { adaptSandbox } from "../sandbox/index.js";
+/** After {@link readSandboxMeta} `startedAt`, ignore "done but no output" briefly (race with wrapper). */
+const BACKGROUND_STARTUP_GRACE_MS = 4000;
+function withinStartupGrace(meta) {
+    if (!meta.startedAt)
+        return false;
+    const t = Date.parse(meta.startedAt);
+    if (Number.isNaN(t))
+        return false;
+    return Date.now() - t < BACKGROUND_STARTUP_GRACE_MS;
+}
+function hasObservableBackgroundProgress(result) {
+    for (const e of result.events) {
+        if (e.type === "token" || e.type === "tool_start" || e.type === "tool_end" || e.type === "end") {
+            return true;
+        }
+    }
+    const raw = (result.rawOutput ?? "").trim();
+    const nonJsonLines = raw.split("\n").filter((l) => {
+        const t = l.trim();
+        return t && !(t.startsWith("{") && t.endsWith("}"));
+    });
+    return nonJsonLines.some((l) => l.trim().length > 0);
+}
 /**
  * Abstract base class for AI coding agent providers
  */
@@ -14,44 +33,25 @@ export class Provider {
         return this.sessionId;
     }
     /** Sandbox for secure execution */
-    sandboxManager = null;
-    /** Whether local execution is allowed */
-    allowLocalExecution = false;
+    sandboxManager;
     /** Resolves when initial setup (install + env) has completed. */
     _readyPromise = null;
-    /** Env passed at creation; used for setup and when run() omits env */
-    _creationEnv;
     /** Defaults merged into every run (model, timeout, sessionId, env). Set by createSession. */
     _runDefaults = {};
+    /** Tracks whether session-level env has been applied */
+    _sessionEnvApplied = false;
     /** Tracks whether we've already applied a synthetic system prompt for this session. */
     _systemPromptApplied = false;
     get ready() {
         return this._readyPromise ?? Promise.resolve();
     }
-    constructor(options = {}) {
-        this._creationEnv = options.env;
+    constructor(options) {
         this._runDefaults = options.runDefaults ?? {};
-        if (options.sandbox) {
-            this.sandboxManager = adaptSandbox(options.sandbox, { env: options.env });
-            if (!options.skipInstall) {
-                this._readyPromise = new Promise((resolve, reject) => {
-                    queueMicrotask(() => this._doSetup().then(resolve).catch(reject));
-                });
-            }
-        }
-        else if (options.dangerouslyAllowLocalExecution) {
-            this.allowLocalExecution = true;
-        }
-        else {
-            throw new Error("Provider requires either a sandbox or dangerouslyAllowLocalExecution: true. " +
-                "For secure execution, create a sandbox with @daytonaio/sdk and pass it in:\n\n" +
-                "  import { Daytona } from '@daytonaio/sdk'\n" +
-                "  import { createProvider } from 'background-agents'\n" +
-                "  const daytona = new Daytona({ apiKey: '...' })\n" +
-                "  const sandbox = await daytona.create({ envVars: { ANTHROPIC_API_KEY: '...' } })\n" +
-                "  const provider = createProvider('claude', { sandbox })\n\n" +
-                "For local execution (dangerous), use:\n\n" +
-                "  const provider = createProvider('claude', { dangerouslyAllowLocalExecution: true })");
+        this.sandboxManager = adaptSandbox(options.sandbox, { env: options.env });
+        if (!options.skipInstall) {
+            this._readyPromise = new Promise((resolve, reject) => {
+                queueMicrotask(() => this._doSetup().then(resolve).catch(reject));
+            });
         }
     }
     /**
@@ -82,15 +82,7 @@ export class Provider {
             : { ...this._runDefaults, ...promptOrOptions };
         options = this._applySystemPrompt(options);
         debugLog(`run start provider=${this.name} promptLength=${options.prompt?.length ?? 0}`, this.sessionId);
-        if (this.sandboxManager) {
-            yield* this.runSandbox(options);
-        }
-        else if (this.allowLocalExecution) {
-            yield* this.runLocal(options);
-        }
-        else {
-            throw new Error("No execution mode configured");
-        }
+        yield* this.runSandbox(options);
         debugLog(`run end provider=${this.name}`, this.sessionId);
     }
     async _codexLoginIfNeeded(env) {
@@ -101,32 +93,58 @@ export class Provider {
         const safeKey = env.OPENAI_API_KEY.replace(/'/g, "'\\''");
         await this.sandboxManager.executeCommand(`echo '${safeKey}' | codex login --with-api-key 2>&1`, 30);
     }
-    /** One-time setup: install CLI and set env. Run in microtask so subclass name is set. */
+    /** One-time setup: install CLI and set session-level env. Run in microtask so subclass name is set. */
     async _doSetup() {
-        if (!this.sandboxManager)
-            return;
         const t = Date.now();
         await this.sandboxManager.ensureProvider(this.name);
         console.log(`[timing] ensureProvider(${this.name}) took ${Date.now() - t}ms`);
-        if (this._creationEnv)
-            this.sandboxManager.setEnvVars(this._creationEnv);
+        // Apply session-level env from runDefaults (set by createSession)
+        const sessionEnv = this._runDefaults.env;
+        if (sessionEnv && !this._sessionEnvApplied) {
+            if (this.sandboxManager.setSessionEnvVars) {
+                this.sandboxManager.setSessionEnvVars(sessionEnv);
+            }
+            else {
+                // Fallback for backwards compatibility
+                this.sandboxManager.setEnvVars(sessionEnv);
+            }
+            this._sessionEnvApplied = true;
+        }
     }
-    /** Per-run: set env and Codex login. */
+    /** Per-run: clear previous run-level env, set new run-level env, and handle Codex login. */
     async _applyRunEnv(options) {
-        if (!this.sandboxManager)
-            return;
-        const env = options.env ?? this._creationEnv;
-        if (env)
-            this.sandboxManager.setEnvVars(env);
-        await this._codexLoginIfNeeded(env);
+        // Ensure session-level env is applied (idempotent)
+        const sessionEnv = this._runDefaults.env;
+        if (sessionEnv && !this._sessionEnvApplied) {
+            if (this.sandboxManager.setSessionEnvVars) {
+                this.sandboxManager.setSessionEnvVars(sessionEnv);
+            }
+            else {
+                this.sandboxManager.setEnvVars(sessionEnv);
+            }
+            this._sessionEnvApplied = true;
+        }
+        // Clear previous run-level env
+        if (this.sandboxManager.clearRunEnvVars) {
+            this.sandboxManager.clearRunEnvVars();
+        }
+        // Apply new run-level env (if provided)
+        const runEnv = options.env;
+        if (runEnv) {
+            if (this.sandboxManager.setRunEnvVars) {
+                this.sandboxManager.setRunEnvVars(runEnv);
+            }
+            else {
+                // Fallback for backwards compatibility
+                this.sandboxManager.setEnvVars(runEnv);
+            }
+        }
+        await this._codexLoginIfNeeded(runEnv ?? sessionEnv);
     }
     /**
      * Run in a secure Daytona sandbox
      */
     async *runSandbox(options) {
-        if (!this.sandboxManager) {
-            throw new Error("Sandbox manager not configured");
-        }
         await (this._readyPromise ?? Promise.resolve());
         await this._applyRunEnv(options);
         // Build the command
@@ -173,81 +191,6 @@ export class Provider {
         }
         debugLog(`runSandbox stream ended provider=${this.name}`, this.sessionId);
     }
-    /**
-     * Run directly on local machine (dangerous - use with caution)
-     */
-    async *runLocal(options) {
-        // Ensure CLI is installed locally
-        ensureCliInstalled(this.name, !(options.skipInstall ?? false));
-        // Load session from file if not provided and persistence is enabled
-        const sessionFile = options.sessionFile ?? getDefaultSessionPath(this.name);
-        if (options.sessionId) {
-            this.sessionId = options.sessionId;
-        }
-        else if (options.persistSession !== false) {
-            this.sessionId = loadSession(sessionFile);
-        }
-        const { cmd, args, env: cmdEnv } = this.getCommand(options);
-        const cliCommand = [cmd, ...args].join(" ");
-        debugLog("runLocal cli", this.sessionId, cliCommand);
-        const proc = spawn(cmd, args, {
-            stdio: ["inherit", "pipe", "inherit"],
-            cwd: options.cwd,
-            env: {
-                ...process.env,
-                ...cmdEnv,
-                ...options.env,
-            },
-        });
-        const rl = readline.createInterface({ input: proc.stdout });
-        let pendingToolEnd = false;
-        debugLog(`runLocal started provider=${this.name}`, this.sessionId);
-        for await (const line of rl) {
-            debugLog(`raw line (local): ${line.length > 300 ? line.slice(0, 300) + "…" : line}`, this.sessionId);
-            const raw = this.parse(line);
-            if (raw === null) {
-                debugLog(`unparsed line (local):`, this.sessionId, line);
-            }
-            const events = raw === null ? [] : Array.isArray(raw) ? raw : [raw];
-            for (const event of events) {
-                if (event.type === "session") {
-                    this.sessionId = event.id;
-                    if (options.persistSession !== false) {
-                        storeSession(sessionFile, event.id);
-                    }
-                }
-                if (event.type === "tool_start")
-                    pendingToolEnd = true;
-                if (event.type === "tool_end")
-                    pendingToolEnd = false;
-                if (event.type === "end" && pendingToolEnd) {
-                    yield { type: "tool_end" };
-                    pendingToolEnd = false;
-                }
-                if (event.type === "end") {
-                    debugLog("session end", this.sessionId, event.error ? `reason=error ${event.error}` : "reason=completed");
-                }
-                else if (event.type === "agent_crashed") {
-                    debugLog("session end", this.sessionId, "reason=crashed", event.message ?? event.output ?? "");
-                }
-                yield event;
-            }
-        }
-        // Wait for process to close
-        await new Promise((resolve, reject) => {
-            proc.on("close", (code) => {
-                debugLog(`runLocal process closed provider=${this.name} code=${code}`, this.sessionId);
-                if (code != null && code !== 0) {
-                    debugLog("session end", this.sessionId, `reason=process exited with code ${code}`);
-                    reject(new Error(`Provider process exited with code ${code}`));
-                }
-                else {
-                    resolve();
-                }
-            });
-            proc.on("error", reject);
-        });
-    }
     /** Meta stored in sandbox for background session (one log per turn, cursor in meta). */
     async readSandboxMeta(sessionDir) {
         if (!this.sandboxManager?.executeCommand)
@@ -296,6 +239,27 @@ export class Provider {
         const b64 = Buffer.from(json, "utf8").toString("base64");
         await this.sandboxManager.executeCommand(`mkdir -p "${sessionDir}" && echo '${b64}' | base64 -d > "${sessionDir}/meta.json"`, 10);
     }
+    /**
+     * Best-effort no-op write guard for polling paths. Skips writing meta when no
+     * relevant fields changed to reduce sandbox file writes on every poll.
+     */
+    async writeSandboxMetaIfChanged(sessionDir, next, prev) {
+        if (prev) {
+            const unchanged = prev.currentTurn === next.currentTurn &&
+                prev.cursor === next.cursor &&
+                (prev.rawCursor ?? 0) === (next.rawCursor ?? 0) &&
+                prev.pid === next.pid &&
+                prev.runId === next.runId &&
+                prev.outputFile === next.outputFile &&
+                (prev.sawEnd ?? false) === (next.sawEnd ?? false) &&
+                prev.startedAt === next.startedAt &&
+                prev.provider === next.provider &&
+                (prev.sessionId ?? null) === (next.sessionId ?? null);
+            if (unchanged)
+                return;
+        }
+        await this.writeSandboxMeta(sessionDir, next);
+    }
     /**
      * Start a new turn in a session directory: one log file per turn, meta in sandbox.
      * Uses currentTurn for this run; currentTurn is incremented when the turn ends (in getEvents).
@@ -355,8 +319,8 @@ export class Provider {
     }
     /**
      * Cancel the current turn's process in the sandbox (kill pid from meta).
-     * Uses killBackgroundProcess when available (same channel as start, e.g. SSH); else executeCommand.
-     * Writes the done file after kill so isRunning() becomes false (the wrapper never gets to write it).
+     * Uses robust multi-step kill: SIGTERM -> SIGKILL -> pkill fallback.
+     * Writes the done file after kill so isRunning() becomes false.
      */
     async cancelSandboxBackground(sessionDir) {
         const meta = await this.readSandboxMeta(sessionDir);
@@ -364,11 +328,17 @@ export class Provider {
             return;
         const mgr = this.sandboxManager;
         if (mgr?.killBackgroundProcess) {
-            await mgr.killBackgroundProcess(meta.pid);
+            // Use the robust kill implementation (includes TERM -> KILL -> pkill)
+            await mgr.killBackgroundProcess(meta.pid, this.name);
         }
         else if (mgr?.executeCommand) {
-            await mgr.executeCommand(`kill ${meta.pid} 2>/dev/null || true`, 10);
+            // Fallback: manual multi-step kill
+            await mgr.executeCommand(`kill -TERM ${meta.pid} 2>/dev/null || true`, 10);
+            await new Promise(r => setTimeout(r, 500));
+            await mgr.executeCommand(`kill -9 ${meta.pid} 2>/dev/null || true`, 10);
+            await mgr.executeCommand(`pkill -9 -f "${this.name}" 2>/dev/null || true`, 10);
         }
+        // Write done file so isRunning() returns false
         if (meta.outputFile && mgr?.executeCommand) {
             const donePath = meta.outputFile + ".done";
             const escaped = donePath.replace(/'/g, "'\\''");
@@ -388,93 +358,132 @@ export class Provider {
             debugLog(`isRunning false (no run) sessionDir=${sessionDir}`, this.sessionId);
             return false;
         }
-        const donePath = meta.outputFile + ".done";
+        const running = await this.isSandboxBackgroundOutputRunning(meta.outputFile);
+        debugLog(`isRunning ${running} (done file ${running ? "missing" : "exists"}) sessionDir=${sessionDir}`, this.sessionId);
+        return running;
+    }
+    async isSandboxBackgroundOutputRunning(outputFile) {
+        if (!this.sandboxManager?.executeCommand)
+            return false;
+        const donePath = outputFile + ".done";
         const escaped = donePath.replace(/'/g, "'\\''");
         const r = await this.sandboxManager.executeCommand(`test -f '${escaped}' 2>/dev/null; echo $?`, 10);
         const doneExists = Number((r.output ?? "").trim().split(/\s+/).pop()) === 0;
-        const running = !doneExists;
-        debugLog(`isRunning ${running} (done file ${doneExists ? "exists" : "missing"}) sessionDir=${sessionDir}`, this.sessionId);
-        return running;
+        return !doneExists;
     }
     /**
      * Get new events for the current turn; reads and updates cursor in sandbox meta.
-     * Use isSandboxBackgroundProcessRunning() to check if the agent is still running.
+     * Uses optimized polling when available (2 round trips instead of 4).
      */
     async getEventsSandboxBackgroundFromMeta(sessionDir) {
-        const meta = await this.readSandboxMeta(sessionDir);
+        // Optimized path: read meta + output + done status together
+        let meta = null;
+        let outputContent = null;
+        let stillRunning;
+        if (this.sandboxManager?.pollBackgroundState) {
+            const state = await this.sandboxManager.pollBackgroundState(sessionDir);
+            if (state?.meta) {
+                try {
+                    const parsed = JSON.parse(state.meta);
+                    if (typeof parsed.currentTurn === "number" && typeof parsed.cursor === "number") {
+                        meta = parsed;
+                    }
+                }
+                catch { /* invalid JSON */ }
+            }
+            outputContent = state?.output ?? null;
+            stillRunning = !state?.done;
+        }
+        else {
+            // Legacy path: separate calls
+            meta = await this.readSandboxMeta(sessionDir);
+            stillRunning = meta?.outputFile ? await this.isSandboxBackgroundOutputRunning(meta.outputFile) : false;
+        }
         if (!meta?.runId || !meta.outputFile) {
             debugLog(`getEventsSandboxBackgroundFromMeta provider=${this.name} sessionDir=${sessionDir} (no turn in progress)`, this.sessionId);
             return {
                 sessionId: meta?.sessionId ?? this.sessionId ?? null,
                 events: [],
                 cursor: String(meta?.cursor ?? 0),
+                running: false,
+                runPhase: "idle",
             };
         }
-        const outputFile = meta.outputFile;
         const cursor = String(meta.cursor);
         debugLog(`getEventsSandboxBackgroundFromMeta provider=${this.name} sessionDir=${sessionDir} turn=${meta.currentTurn} cursor=${cursor}`, this.sessionId);
-        const result = await this.pollSandboxBackground(outputFile, cursor, meta.rawCursor != null ? String(meta.rawCursor) : null);
+        // Poll output (uses pre-fetched content if available)
+        const result = await this.pollSandboxBackground(meta.outputFile, cursor, meta.rawCursor != null ? String(meta.rawCursor) : null, outputContent);
         const sawEnd = meta.sawEnd || result.events.some((e) => e.type === "end");
-        const stillRunning = await this.isSandboxBackgroundProcessRunning(sessionDir);
-        // Clear run when process stopped or we've seen end event (sawEnd can be true before .done file exists)
-        if (!stillRunning || sawEnd) {
-            const nextTurn = (meta.currentTurn ?? 0) + 1;
-            const metaUpdate = {
-                currentTurn: nextTurn,
-                cursor: Number(result.cursor) || 0,
-                rawCursor: Number(result.rawCursor) || meta.rawCursor || 0,
-                sawEnd,
-                provider: this.name,
-                sessionId: this.sessionId ?? meta.sessionId ?? null,
-                ...(sawEnd ? {} : { outputFile: meta.outputFile, runId: meta.runId }),
-            };
-            await this.writeSandboxMeta(sessionDir, metaUpdate);
-        }
-        if (stillRunning && !sawEnd) {
-            await this.writeSandboxMeta(sessionDir, {
+        // Handle completion states and update meta
+        return this._handlePollResult(sessionDir, meta, result, stillRunning, sawEnd);
+    }
+    /** Process poll result and update meta. Shared by all polling paths. */
+    async _handlePollResult(sessionDir, meta, result, stillRunning, sawEnd) {
+        const baseMeta = {
+            cursor: Number(result.cursor) || 0,
+            rawCursor: Number(result.rawCursor) || meta.rawCursor || 0,
+            provider: this.name,
+            sessionId: this.sessionId ?? meta.sessionId ?? null,
+        };
+        // Early poll / wrapper race: done file appears before any JSONL output — stay "active" until grace elapses.
+        if (!stillRunning &&
+            !sawEnd &&
+            withinStartupGrace(meta) &&
+            !hasObservableBackgroundProgress(result)) {
+            await this.writeSandboxMetaIfChanged(sessionDir, {
                 currentTurn: meta.currentTurn,
-                cursor: Number(result.cursor) || 0,
-                rawCursor: Number(result.rawCursor) || meta.rawCursor || 0,
+                ...baseMeta,
+                sawEnd: false,
                 pid: meta.pid,
                 runId: meta.runId,
                 outputFile: meta.outputFile,
-                sawEnd,
                 startedAt: meta.startedAt,
-                provider: this.name,
-                sessionId: this.sessionId,
-            });
+            }, meta);
+            return {
+                sessionId: result.sessionId,
+                events: result.events,
+                cursor: result.cursor,
+                running: true,
+                runPhase: "starting",
+            };
+        }
+        if (!stillRunning || sawEnd) {
+            const nextTurn = (meta.currentTurn ?? 0) + 1;
+            await this.writeSandboxMetaIfChanged(sessionDir, {
+                currentTurn: nextTurn, ...baseMeta, sawEnd,
+                ...(sawEnd ? {} : { outputFile: meta.outputFile, runId: meta.runId }),
+            }, meta);
+        }
+        else {
+            await this.writeSandboxMetaIfChanged(sessionDir, {
+                currentTurn: meta.currentTurn, ...baseMeta, sawEnd,
+                pid: meta.pid, runId: meta.runId, outputFile: meta.outputFile, startedAt: meta.startedAt,
+            }, meta);
         }
+        // Crashed: process exited without end event
         if (!stillRunning && !sawEnd) {
-            const maxOutputChars = 4096;
-            let output;
-            if (this.sandboxManager?.executeCommand) {
-                const outResult = await this.sandboxManager.executeCommand(`cat ${outputFile} 2>/dev/null || true`, 10);
-                const raw = (outResult.output ?? "").trim();
-                const nonJsonLines = raw.split("\n").filter((line) => {
-                    const t = line.trim();
-                    return t && !(t.startsWith("{") && t.endsWith("}"));
-                });
-                const filtered = nonJsonLines.join("\n").trim();
-                output = filtered.length > maxOutputChars ? filtered.slice(-maxOutputChars) : filtered || undefined;
-            }
-            const crashEvent = {
-                type: "agent_crashed",
-                message: "Agent process exited without completing (crashed or killed)",
-                output,
+            const raw = (result.rawOutput ?? "").trim();
+            const nonJsonLines = raw.split("\n").filter((l) => { const t = l.trim(); return t && !(t.startsWith("{") && t.endsWith("}")); });
+            const output = nonJsonLines.join("\n").trim().slice(-4096) || undefined;
+            const crashEvent = { type: "agent_crashed", message: "Agent process exited without completing (crashed or killed)", output };
+            debugLog("session end", this.sessionId ?? meta.sessionId, "reason=crashed", crashEvent.message);
+            await this.writeSandboxMetaIfChanged(sessionDir, { currentTurn: (meta.currentTurn ?? 0) + 1, ...baseMeta, sawEnd: true }, meta);
+            return {
+                sessionId: result.sessionId,
+                events: [...result.events, crashEvent],
+                cursor: result.cursor,
+                running: false,
+                runPhase: "stopped",
             };
-            debugLog("session end", this.sessionId ?? meta.sessionId, "reason=crashed", crashEvent.message, output ? `output=${output.slice(0, 200)}${output.length > 200 ? "…" : ""}` : "");
-            const nextTurn = (meta.currentTurn ?? 0) + 1;
-            await this.writeSandboxMeta(sessionDir, {
-                currentTurn: nextTurn,
-                cursor: Number(result.cursor) || 0,
-                rawCursor: Number(result.rawCursor) || meta.rawCursor || 0,
-                sawEnd: true,
-                provider: this.name,
-                sessionId: this.sessionId ?? meta.sessionId ?? null,
-            });
-            return { sessionId: result.sessionId, events: [...result.events, crashEvent], cursor: result.cursor };
         }
-        return { sessionId: result.sessionId, events: result.events, cursor: result.cursor };
+        const active = stillRunning && !sawEnd;
+        return {
+            sessionId: result.sessionId,
+            events: result.events,
+            cursor: result.cursor,
+            running: active,
+            runPhase: active ? "running" : "stopped",
+        };
     }
     /**
      * Start a background run inside the sandbox.
@@ -529,98 +538,52 @@ export class Provider {
     }
     /**
      * Poll a background sandbox run by reading the JSONL log file.
-     * Cursor is an opaque string representing the last processed line index.
+     * If prefetchedContent is provided, uses that instead of fetching from sandbox.
      */
-    async pollSandboxBackground(outputFile, cursor, rawCursor) {
-        if (!this.sandboxManager || !this.sandboxManager.executeCommand) {
-            throw new Error("Sandbox background mode requires a sandbox with executeCommand support");
+    async pollSandboxBackground(outputFile, cursor, rawCursor, prefetchedContent) {
+        // Get content: use prefetched if available, otherwise fetch
+        let rawOutput;
+        if (prefetchedContent != null) {
+            rawOutput = prefetchedContent;
         }
-        const decodeCursor = (c) => (c ? Number(c) || 0 : 0);
-        const encodeCursor = (index) => String(index);
-        const startIndex = decodeCursor(cursor);
-        const rawStartIndex = decodeCursor(rawCursor);
-        const catCommand = `cat ${outputFile}`;
-        const result = await this.sandboxManager.executeCommand(catCommand, 30);
-        const rawOutput = result.output ?? "";
+        else {
+            if (!this.sandboxManager?.executeCommand) {
+                throw new Error("Sandbox background mode requires a sandbox with executeCommand support");
+            }
+            const result = await this.sandboxManager.executeCommand(`cat ${outputFile}`, 30);
+            rawOutput = result.output ?? "";
+        }
+        const startIndex = cursor ? Number(cursor) || 0 : 0;
+        void rawCursor; // used for tracking but not filtering in simplified version
         const rawLines = rawOutput.split("\n");
-        debugLog(`pollSandboxBackground provider=${this.name} outputFile=${outputFile} cursor=${cursor ?? "null"} rawLines=${rawLines.length}`, this.sessionId);
         const lines = [];
-        const isJsonLine = (line) => {
-            const trimmed = line.trim();
-            return trimmed.startsWith("{") && trimmed.endsWith("}");
-        };
-        const isRereading = rawStartIndex >= rawLines.length;
+        const isJson = (s) => s.startsWith("{") && s.endsWith("}");
         for (let i = 0; i < rawLines.length; i++) {
-            const line = rawLines[i];
-            if (i >= rawStartIndex) {
-                debugLog(`raw file line [${i}]: ${line}`, this.sessionId);
-            }
-            const trimmed = line.trim();
+            const trimmed = rawLines[i].trim();
             if (!trimmed)
                 continue;
-            if (!isJsonLine(trimmed) && i === rawLines.length - 1) {
-                if (!isRereading)
-                    debugLog(`background poll skipped (partial last line) [${i}]: ${trimmed}`, this.sessionId);
-                continue;
-            }
-            if (isJsonLine(trimmed)) {
+            if (!isJson(trimmed) && i === rawLines.length - 1)
+                continue; // skip partial last line
+            if (isJson(trimmed))
                 lines.push(trimmed);
-            }
-            else {
-                if (!isRereading)
-                    debugLog(`background poll skipped (not JSONL) [${i}]: ${trimmed}`, this.sessionId);
-            }
         }
         if (startIndex >= lines.length) {
-            // No new JSONL events since the last cursor; keep status as running
-            // and only advance the cursor based on JSON lines, not raw lines.
-            const nextCursor = lines.length;
-            const nextRawCursor = encodeCursor(rawLines.length);
-            return {
-                status: "running",
-                sessionId: this.sessionId,
-                events: [],
-                cursor: encodeCursor(nextCursor),
-                rawCursor: nextRawCursor,
-            };
-        }
-        const slice = lines.slice(startIndex);
-        for (let i = 0; i < slice.length; i++) {
-            const l = slice[i];
-            debugLog(`raw line (background poll) [${startIndex + i}]: ${l ?? ""}`, this.sessionId);
+            return { status: "running", sessionId: this.sessionId, events: [], cursor: String(lines.length), rawCursor: String(rawLines.length), rawOutput };
         }
         const eventsOut = [];
         let status = "running";
-        for (const line of slice) {
+        for (const line of lines.slice(startIndex)) {
             const raw = this.parse(line);
-            if (raw === null) {
-                debugLog(`unparsed line (background poll):`, this.sessionId, line);
-            }
             const events = raw === null ? [] : Array.isArray(raw) ? raw : [raw];
             for (const event of events) {
-                if (event.type === "session") {
+                if (event.type === "session")
                     this.sessionId = event.id;
-                }
-                if (event.type === "end") {
+                if (event.type === "end")
                     status = "completed";
-                    debugLog("session end", this.sessionId, event.error ? `reason=error ${event.error}` : "reason=completed");
-                }
-                else if (event.type === "agent_crashed") {
-                    debugLog("session end", this.sessionId, "reason=crashed", event.message ?? event.output ?? "");
-                }
                 eventsOut.push(event);
             }
         }
-        const newCursor = encodeCursor(lines.length);
-        const newRawCursor = encodeCursor(rawLines.length);
-        debugLog(`pollSandboxBackground result provider=${this.name} status=${status} events=${eventsOut.length} newCursor=${newCursor} newRawCursor=${newRawCursor}`, this.sessionId);
-        return {
-            status,
-            sessionId: this.sessionId,
-            events: eventsOut,
-            cursor: newCursor,
-            rawCursor: newRawCursor,
-        };
+        return { status, sessionId: this.sessionId, events: eventsOut, cursor: String(lines.length), rawCursor: String(rawLines.length), rawOutput };
     }
     /**
      * Run the provider with a callback for each event