notsleep 1.0.0

package/dist/agent.js

@@ -0,0 +1,1064 @@
+"use strict";
+// ============================================================
+// NotSleep - Long-Horizon Agent Loop
+// ============================================================
+//
+// This is the core engine. It:
+// 1. Runs an iterative loop calling the LLM and executing tools
+// 2. Monitors context window usage and summarizes when needed
+// 3. Saves checkpoints for crash recovery
+// 4. Handles errors gracefully and keeps going
+// 5. In SINGLE mode: stops when task_complete is called
+// 6. In CONTINUOUS mode: after task_complete, picks up the next
+//    queued task or asks the LLM to generate new tasks. Only
+//    stops on STOP file, Ctrl+C, or max iterations.
+//
+// ============================================================
+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.Agent = void 0;
+exports.sanitizeMessageWindow = sanitizeMessageWindow;
+const fs = __importStar(require("fs"));
+const child_process_1 = require("child_process");
+const types_1 = require("./types");
+const provider_1 = require("./provider");
+const checkpoint_1 = require("./checkpoint");
+const tools_1 = require("./tools");
+const cost_1 = require("./cost");
+const modelsdev_1 = require("./modelsdev");
+const config_1 = require("./config");
+/**
+ * Make an arbitrary slice of the message history a VALID conversation:
+ *   - every `tool` message has a matching preceding `assistant` tool_call
+ *   - every `assistant` tool_call has all of its `tool` results present
+ *   - no leading `tool` message (which would be an orphaned result)
+ *
+ * Runs to a fixed point because removing a dangling assistant can orphan a
+ * tool result, and removing an orphaned tool result can leave an assistant
+ * with fewer results. Used by the context-truncation fallback.
+ */
+function sanitizeMessageWindow(window) {
+    let msgs = [...window];
+    for (let pass = 0; pass < 10; pass++) {
+        // IDs that actually have a tool result present.
+        const resultIds = new Set(msgs.filter((m) => m.role === 'tool' && m.tool_call_id).map((m) => m.tool_call_id));
+        // Drop assistant messages whose tool_calls are not all answered.
+        const keptAssistants = msgs.filter((m) => {
+            if (m.role === 'assistant' && m.tool_calls && m.tool_calls.length > 0) {
+                return m.tool_calls.every((tc) => resultIds.has(tc.id));
+            }
+            return true;
+        });
+        // Valid tool_call IDs from the assistant messages we kept.
+        const callIds = new Set();
+        for (const m of keptAssistants) {
+            if (m.role === 'assistant' && m.tool_calls) {
+                for (const tc of m.tool_calls)
+                    callIds.add(tc.id);
+            }
+        }
+        // Drop tool results with no matching preceding assistant tool_call.
+        let cleaned = keptAssistants.filter((m) => {
+            if (m.role === 'tool')
+                return m.tool_call_id ? callIds.has(m.tool_call_id) : false;
+            return true;
+        });
+        // Drop any leading tool messages (orphaned results at the window start).
+        while (cleaned.length > 0 && cleaned[0].role === 'tool') {
+            cleaned = cleaned.slice(1);
+        }
+        if (cleaned.length === msgs.length)
+            return cleaned; // stable
+        msgs = cleaned;
+    }
+    return msgs;
+}
+class Agent {
+    config;
+    provider;
+    logger;
+    checkpoint;
+    tools;
+    messages;
+    stats;
+    taskDescription;
+    progress;
+    running;
+    taskComplete;
+    completionSummary;
+    paused;
+    /** Shared task queue - tools can push to this, agent reads from it */
+    taskQueue;
+    currentTaskId;
+    /**
+     * The value of stats.totalIterations when the CURRENT task started. Used to
+     * enforce maxIterationsPerTask: if a task runs longer than the per-task
+     * budget without calling task_complete, the agent auto-advances to the next
+     * queued task so an open-ended task can't starve the queue forever.
+     */
+    currentTaskStartIteration = 0;
+    /** Optional dashboard for web UI */
+    dashboard = null;
+    /**
+     * Exact prompt-token count reported by the provider on the last chat call.
+     * This is the real API measurement of the context size at that moment —
+     * NOT a chars/4 guess. 0 until the first response arrives.
+     */
+    lastPromptTokens = 0;
+    /**
+     * How many messages had been sent when lastPromptTokens was measured.
+     * Messages appended after this index (the assistant reply + tool results)
+     * haven't been counted by the API yet, so only that small tail is estimated.
+     */
+    lastPromptMessageCount = 0;
+    /**
+     * Real completion-token count from the last chat call (API-reported).
+     */
+    lastCompletionTokens = 0;
+    /**
+     * Number of CONSECUTIVE failed iterations. Reset to 0 after any success.
+     * The agent stops only when this hits the limit — meaning it's genuinely
+     * stuck — rather than on a lifetime error total, which would kill a healthy
+     * long run that has merely accumulated transient errors over hours/days.
+     */
+    consecutiveErrors = 0;
+    static MAX_CONSECUTIVE_ERRORS = 20;
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+        this.provider = new provider_1.LLMProvider(config, logger);
+        this.checkpoint = new checkpoint_1.CheckpointManager(config.checkpointDir, logger);
+        this.taskQueue = [];
+        this.tools = (0, tools_1.createBuiltinTools)(logger, config.toolTimeoutMs, this.taskQueue, process.cwd());
+        // Register user-defined shell tools from notsleep.json, if any.
+        const custom = (0, tools_1.createCustomTools)(config.customTools, logger, config.toolTimeoutMs);
+        if (custom.length > 0) {
+            this.tools.push(...custom);
+            logger.info(`Loaded ${custom.length} custom tool(s) from config: ${custom.map((t) => t.name).join(', ')}`);
+        }
+        this.messages = [];
+        this.stats = {
+            startTime: Date.now(),
+            totalIterations: 0,
+            totalTokensUsed: 0,
+            totalToolCalls: 0,
+            errors: 0,
+            contextResets: 0,
+            tasksCompleted: 0,
+            tasksFailed: 0,
+            totalCostUsd: 0,
+        };
+        this.taskDescription = '';
+        this.progress = [];
+        this.running = false;
+        this.taskComplete = false;
+        this.completionSummary = '';
+        this.currentTaskId = null;
+        this.paused = false;
+    }
+    /**
+     * Register a custom tool.
+     */
+    addTool(tool) {
+        this.tools.push(tool);
+    }
+    /**
+     * Attach a dashboard server for web UI.
+     */
+    setDashboard(dashboard) {
+        this.dashboard = dashboard;
+        // Wire up logger to push logs to dashboard
+        this.logger.onLog = (entry) => {
+            dashboard.pushLog(entry);
+        };
+        // Handle commands from the dashboard UI
+        dashboard.onCommand = (cmd) => {
+            this.handleDashboardCommand(cmd);
+        };
+    }
+    handleDashboardCommand(cmd) {
+        switch (cmd.type) {
+            case 'pause':
+                this.paused = true;
+                this.logger.info('Agent PAUSED from dashboard.');
+                this.broadcastState();
+                break;
+            case 'resume':
+                this.paused = false;
+                this.logger.info('Agent RESUMED from dashboard.');
+                this.broadcastState();
+                break;
+            case 'stop':
+                this.logger.warn('Agent STOPPED from dashboard. Saving checkpoint...');
+                this.saveCheckpoint();
+                this.running = false;
+                this.broadcastState();
+                break;
+            case 'add_task':
+                if ('description' in cmd && cmd.description) {
+                    const id = `task-ui-${Date.now()}-${Math.random().toString(36).substring(2, 7)}`;
+                    const priority = ('priority' in cmd ? cmd.priority : 'medium');
+                    this.taskQueue.push({
+                        id,
+                        description: cmd.description,
+                        priority,
+                        status: 'pending',
+                        addedAt: new Date().toISOString(),
+                    });
+                    this.logger.info(`Task added from dashboard [${priority}]: ${cmd.description}`);
+                    this.broadcastState();
+                }
+                break;
+            case 'delete_task':
+                if ('taskId' in cmd && cmd.taskId) {
+                    const taskId = cmd.taskId;
+                    const idx = this.taskQueue.findIndex(t => t.id === taskId);
+                    if (idx !== -1) {
+                        const removed = this.taskQueue.splice(idx, 1)[0];
+                        this.logger.info(`Task deleted from dashboard: ${removed.description.substring(0, 60)}`);
+                    }
+                    this.broadcastState();
+                }
+                break;
+            case 'get_state':
+                this.broadcastState();
+                break;
+        }
+    }
+    /** Push current state to dashboard */
+    broadcastState() {
+        if (!this.dashboard)
+            return;
+        let status = 'running';
+        if (!this.running)
+            status = 'stopped';
+        if (this.paused)
+            status = 'paused';
+        if (this.taskComplete && !this.config.continuous)
+            status = 'completed';
+        const currentTask = this.currentTaskId
+            ? this.taskQueue.find(t => t.id === this.currentTaskId)?.description || this.taskDescription
+            : this.taskDescription;
+        // Context window usage from the REAL API token count (chars/4 only as a
+        // pre-first-response fallback), so the dashboard shows true numbers.
+        const contextTokens = this.currentContextTokens().tokens;
+        const contextUsage = Math.min(contextTokens / this.config.contextWindowLimit, 1);
+        // Show the registry provider name (e.g. "limitrouter") when a
+        // "provider/model" selector is in use, else the protocol.
+        const providerLabel = this.config.model && this.config.model.includes('/')
+            ? this.config.model.slice(0, this.config.model.indexOf('/'))
+            : this.config.provider;
+        this.dashboard.updateState({
+            status,
+            currentTask,
+            taskQueue: [...this.taskQueue],
+            stats: { ...this.stats },
+            provider: providerLabel,
+            model: this.getModelName(),
+            smallModel: this.config.smallModel?.model,
+            contextLimitSource: (0, config_1.getConfigSources)().contextLimitSource,
+            continuous: this.config.continuous,
+            paused: this.paused,
+            recentLogs: [],
+            contextUsage,
+            contextLimit: this.config.contextWindowLimit,
+            maxIterations: this.config.maxIterations,
+        });
+    }
+    /**
+     * Run the agent on a task. This is the main entry point.
+     *
+     * SINGLE MODE (default):
+     *   Runs until task_complete, maxIterations, or unrecoverable error.
+     *
+     * CONTINUOUS MODE (config.continuous = true):
+     *   After task_complete, picks next task from queue. If queue is empty,
+     *   asks the LLM to generate follow-up tasks. Only stops when:
+     *   - STOP file is detected (config.stopFile)
+     *   - Ctrl+C / SIGINT
+     *   - maxIterations reached
+     *   - Agent explicitly decides there is nothing left to do
+     */
+    async run(taskDescription, resumeFromCheckpoint) {
+        this.taskDescription = taskDescription;
+        this.running = true;
+        // Handle SIGINT gracefully
+        const sigintHandler = () => {
+            this.logger.warn('Received SIGINT. Saving checkpoint and shutting down gracefully...');
+            this.saveCheckpoint();
+            this.running = false;
+        };
+        process.on('SIGINT', sigintHandler);
+        try {
+            // Check for checkpoint to resume from
+            if (resumeFromCheckpoint) {
+                const cp = this.checkpoint.loadLatest();
+                if (cp) {
+                    this.messages = cp.messages;
+                    this.progress = cp.progress;
+                    this.taskDescription = cp.taskDescription;
+                    if (cp.taskQueue)
+                        this.taskQueue.splice(0, this.taskQueue.length, ...cp.taskQueue);
+                    if (cp.currentTaskId)
+                        this.currentTaskId = cp.currentTaskId;
+                    // Restore cumulative stats so tokens/tool-calls/tasks/errors keep
+                    // counting across the crash. Preserve the ORIGINAL startTime so
+                    // elapsed time reflects real wall-clock, not just this process.
+                    if (cp.stats) {
+                        this.stats = { ...cp.stats };
+                    }
+                    else {
+                        // Older checkpoints only stored the iteration count.
+                        this.stats.totalIterations = cp.iteration;
+                    }
+                    // Restart the per-task budget from here so a resumed task isn't
+                    // instantly considered over-budget against the restored iteration count.
+                    this.currentTaskStartIteration = this.stats.totalIterations;
+                    this.logger.info(`Resuming from checkpoint at iteration ${cp.iteration}`);
+                }
+                else {
+                    this.logger.info('No checkpoint found, starting fresh.');
+                    this.initializeMessages(taskDescription);
+                }
+            }
+            else {
+                this.initializeMessages(taskDescription);
+            }
+            this.logger.separator();
+            this.logger.info(`Starting agent loop for task: ${taskDescription.substring(0, 100)}...`);
+            this.logger.info(`Provider: ${this.config.provider} | Model: ${this.getModelName()}`);
+            this.logger.info(`Mode: ${this.config.continuous ? 'CONTINUOUS (runs until you wake up)' : 'SINGLE TASK'}`);
+            const unlimited = (0, types_1.isUnlimitedIterations)(this.config.maxIterations);
+            this.logger.info(`Max iterations: ${unlimited ? 'UNLIMITED' : this.config.maxIterations} | Context limit: ${this.config.contextWindowLimit.toLocaleString()} tokens`);
+            if (this.config.continuous) {
+                this.logger.info(`Stop file: ${this.config.stopFile} (create this file to stop the agent)`);
+            }
+            this.logger.separator();
+            // ─── Main Agent Loop ───────────────────────────────
+            while (this.running && (unlimited || this.stats.totalIterations < this.config.maxIterations)) {
+                // ── Check stop conditions ──
+                if (this.shouldStop())
+                    break;
+                // ── Wait while paused ──
+                while (this.paused && this.running) {
+                    await this.sleep(500);
+                    if (this.shouldStop())
+                        break;
+                }
+                if (!this.running)
+                    break;
+                // ── Per-task budget: auto-advance if a task runs too long ──
+                // In continuous mode, an open-ended task (e.g. "keep improving") may
+                // never call task_complete, which would starve every queued task. If a
+                // per-task cap is set and exceeded, force-complete the current task and
+                // move on so the queue actually drains.
+                if (this.config.continuous &&
+                    !this.taskComplete &&
+                    this.config.maxIterationsPerTask > 0 &&
+                    this.stats.totalIterations - this.currentTaskStartIteration >= this.config.maxIterationsPerTask) {
+                    const spent = this.stats.totalIterations - this.currentTaskStartIteration;
+                    this.logger.warn(`Task hit its per-task budget (${spent}/${this.config.maxIterationsPerTask} iterations) ` +
+                        `without completing. Auto-advancing to the next queued task.`);
+                    this.taskComplete = true;
+                    this.completionSummary =
+                        `[auto-advanced] Reached the per-task iteration budget ` +
+                            `(${this.config.maxIterationsPerTask}) before an explicit task_complete. ` +
+                            `Partial progress has been auto-committed if enabled.`;
+                }
+                // ── If current task is complete, handle transition ──
+                if (this.taskComplete) {
+                    this.stats.tasksCompleted++;
+                    this.markCurrentTaskComplete(this.completionSummary);
+                    // Auto-commit the completed task's changes (local only, never pushes).
+                    if (this.config.autoCommit) {
+                        await this.autoCommitTask(this.completionSummary);
+                    }
+                    this.broadcastState();
+                    if (!this.config.continuous) {
+                        // Single mode: we're done
+                        break;
+                    }
+                    // Continuous mode: get next task
+                    this.logger.separator();
+                    this.logger.info(`Task completed! Looking for next task...`);
+                    const nextTask = await this.getNextTask();
+                    if (!nextTask) {
+                        this.logger.info('No more tasks to do. Agent is stopping.');
+                        break;
+                    }
+                    // Reset for next task
+                    this.logger.separator();
+                    this.logger.info(`Starting next task: ${nextTask.description.substring(0, 100)}`);
+                    this.taskComplete = false;
+                    this.completionSummary = '';
+                    this.currentTaskId = nextTask.id;
+                    nextTask.status = 'in_progress';
+                    this.currentTaskStartIteration = this.stats.totalIterations;
+                    // Fresh context for new task, but carry forward the overall mission
+                    this.messages = [
+                        { role: 'system', content: this.config.systemPrompt },
+                        {
+                            role: 'user',
+                            content: `CONTINUOUS MODE: You have completed previous tasks. Here is your next task:\n\n` +
+                                `${nextTask.description}\n\n` +
+                                `Previous progress summary:\n${this.progress.slice(-3).join('\n---\n')}\n\n` +
+                                `Do NOT stop until this task is fully complete. When done, call "task_complete". ` +
+                                `If you discover additional work needed, use "add_task" to queue it.`,
+                        },
+                    ];
+                }
+                this.stats.totalIterations++;
+                this.logger.progress(this.stats.totalIterations, this.config.maxIterations, this.stats.totalTokensUsed);
+                this.broadcastState();
+                try {
+                    // 1. Check context window and summarize if needed
+                    await this.manageContext();
+                    // 2. Call the LLM
+                    const response = await this.provider.chat(this.messages, this.tools);
+                    this.stats.totalTokensUsed += response.usage.total_tokens;
+                    // Accumulate estimated cost from this call's token usage.
+                    this.stats.totalCostUsd += (0, cost_1.estimateCost)(this.getModelName(), response.usage.prompt_tokens, response.usage.completion_tokens);
+                    // Remember the EXACT input size the API measured, plus how many
+                    // messages it covered, so context tracking uses the real number
+                    // instead of a chars/4 guess.
+                    if (response.usage.prompt_tokens > 0) {
+                        this.lastPromptTokens = response.usage.prompt_tokens;
+                        this.lastPromptMessageCount = this.messages.length;
+                    }
+                    this.lastCompletionTokens = response.usage.completion_tokens || 0;
+                    // 3. Process the response
+                    await this.processResponse(response);
+                    // 4. Enforce the cost budget, if one is set.
+                    if (this.config.maxCostUsd && this.stats.totalCostUsd >= this.config.maxCostUsd) {
+                        this.logger.warn(`Cost budget reached: estimated ${(0, cost_1.formatUsd)(this.stats.totalCostUsd)} ` +
+                            `>= limit ${(0, cost_1.formatUsd)(this.config.maxCostUsd)}. Stopping gracefully.`);
+                        this.saveCheckpoint();
+                        this.running = false;
+                        break;
+                    }
+                    // A completed iteration means we recovered from any prior errors.
+                    this.consecutiveErrors = 0;
+                    // 5. Save checkpoint every 5 iterations
+                    if (this.stats.totalIterations % 5 === 0) {
+                        this.saveCheckpoint();
+                    }
+                }
+                catch (error) {
+                    this.stats.errors++; // lifetime metric (reporting)
+                    // ── Context overflow: self-correct instead of counting as "stuck" ──
+                    // If the provider rejected the request because it exceeded the model's
+                    // context window, the error carries the REAL maximum. Trust it over
+                    // our detected limit: shrink the limit and summarize immediately so
+                    // the next attempt fits. This is the reactive safety net beneath the
+                    // models.dev catalog and /models endpoint sync.
+                    const overflowMax = (0, modelsdev_1.parseContextOverflow)(error.message);
+                    if (overflowMax !== undefined) {
+                        const newLimit = Math.floor(overflowMax * 0.9);
+                        if (newLimit > 0 && newLimit < this.config.contextWindowLimit) {
+                            this.logger.warn(`Provider reported a context overflow (model max ${overflowMax.toLocaleString()} tokens). ` +
+                                `Lowering context limit ${this.config.contextWindowLimit.toLocaleString()} → ` +
+                                `${newLimit.toLocaleString()} and summarizing.`);
+                            this.config.contextWindowLimit = newLimit;
+                        }
+                        else {
+                            this.logger.warn(`Context overflow (model max ${overflowMax.toLocaleString()} tokens). Forcing summarization.`);
+                        }
+                        try {
+                            await this.manageContext(true); // force, ignoring the threshold
+                        }
+                        catch (e) {
+                            this.logger.error(`Forced summarization after overflow failed: ${e.message}`);
+                        }
+                        // Handled and recoverable — don't let it trip the stuck detector.
+                        this.consecutiveErrors = 0;
+                        this.broadcastState();
+                        continue;
+                    }
+                    this.consecutiveErrors++; // stuck-detection (stop decision)
+                    this.logger.error(`Iteration ${this.stats.totalIterations} failed ` +
+                        `(${this.consecutiveErrors} in a row): ${error.message}`);
+                    // Add error to conversation so the agent can learn from it, unless
+                    // we've failed too many times in a row — then we're genuinely stuck.
+                    if (this.consecutiveErrors < Agent.MAX_CONSECUTIVE_ERRORS) {
+                        this.messages.push({
+                            role: 'user',
+                            content: `[SYSTEM] An error occurred: ${error.message}. Please continue with the task. If this is a persistent issue, try a different approach.`,
+                        });
+                    }
+                    else {
+                        this.logger.error(`${Agent.MAX_CONSECUTIVE_ERRORS} consecutive errors — the agent appears stuck. ` +
+                            `Stopping. (${this.stats.errors} total errors this run.)`);
+                        this.running = false;
+                    }
+                }
+            }
+            // ─── Final Checkpoint ──────────────────────────────
+            this.saveCheckpoint();
+            // ─── Return Results ────────────────────────────────
+            const elapsed = ((Date.now() - this.stats.startTime) / 1000).toFixed(0);
+            this.logger.separator();
+            this.logger.info(`Agent finished after ${this.stats.totalIterations} iterations in ${elapsed}s`);
+            this.logger.info(`Total tokens: ${this.stats.totalTokensUsed.toLocaleString()} | Est. cost: ${(0, cost_1.formatUsd)(this.stats.totalCostUsd)}`);
+            this.logger.info(`Tool calls: ${this.stats.totalToolCalls} | Errors: ${this.stats.errors} | Context resets: ${this.stats.contextResets}`);
+            this.logger.info(`Tasks completed: ${this.stats.tasksCompleted} | Tasks failed: ${this.stats.tasksFailed}`);
+            this.logger.info(`Log file: ${this.logger.getLogFile()}`);
+            // Show task queue summary
+            if (this.taskQueue.length > 0) {
+                this.logger.separator();
+                this.logger.info('Task Queue Final Status:');
+                for (const t of this.taskQueue) {
+                    this.logger.info(`  [${t.status.toUpperCase()}] ${t.description.substring(0, 80)}`);
+                }
+            }
+            this.logger.separator();
+            const isSuccess = this.taskComplete || this.stats.tasksCompleted > 0;
+            if (isSuccess) {
+                this.logger.agent(`Agent completed successfully! (${this.stats.tasksCompleted} task(s) done)`);
+            }
+            else if (!(0, types_1.isUnlimitedIterations)(this.config.maxIterations) && this.stats.totalIterations >= this.config.maxIterations) {
+                this.logger.warn('Max iterations reached. Task may not be fully complete.');
+            }
+            return {
+                success: isSuccess,
+                summary: this.buildFinalSummary(),
+                stats: this.stats,
+            };
+        }
+        finally {
+            process.removeListener('SIGINT', sigintHandler);
+        }
+    }
+    // ─── Private Methods ──────────────────────────────────────
+    initializeMessages(taskDescription) {
+        const continuousNote = this.config.continuous
+            ? `\n\nYou are in CONTINUOUS MODE. After completing this task, use "add_task" to queue any follow-up ` +
+                `tasks you identify. When the current task is done, call "task_complete" and you will automatically ` +
+                `receive the next task. Think proactively - what else could be improved, tested, documented, or built?`
+            : '';
+        this.messages = [
+            { role: 'system', content: this.config.systemPrompt },
+            { role: 'user', content: `Here is your task. Do NOT stop until it is fully complete:\n\n${taskDescription}${continuousNote}` },
+        ];
+        // In continuous mode, also queue the initial task
+        if (this.config.continuous) {
+            const id = `task-initial-${Date.now()}`;
+            this.taskQueue.push({
+                id,
+                description: taskDescription,
+                priority: 'high',
+                status: 'in_progress',
+                addedAt: new Date().toISOString(),
+            });
+            this.currentTaskId = id;
+            this.currentTaskStartIteration = this.stats.totalIterations;
+        }
+    }
+    getModelName() {
+        if (this.config.provider === 'openai')
+            return this.config.openai?.model || 'unknown';
+        return this.config.anthropic?.model || 'unknown';
+    }
+    /**
+     * Auto-commit the changes produced by a completed task. LOCAL ONLY — this
+     * never pushes to a remote. Stages all changes and commits with a message
+     * derived from the task summary. If there is nothing to commit (e.g. the
+     * task made no file changes), it silently does nothing.
+     */
+    async autoCommitTask(summary) {
+        try {
+            // Only commit if inside a git repo.
+            const inRepo = await this.runGitQuiet(['rev-parse', '--is-inside-work-tree']);
+            if (inRepo.trim() !== 'true') {
+                this.logger.debug('auto-commit skipped: not a git repository.');
+                return;
+            }
+            // Anything to commit?
+            const status = await this.runGitQuiet(['status', '--porcelain']);
+            if (!status.trim()) {
+                this.logger.info('auto-commit: no changes to commit for this task.');
+                return;
+            }
+            await this.runGitQuiet(['add', '-A']);
+            // Build a concise, single-line commit subject from the summary.
+            const firstLine = (summary || 'completed task').split('\n')[0].trim();
+            const subject = `notsleep: ${firstLine}`.substring(0, 72);
+            const out = await this.runGitQuiet(['commit', '-m', subject]);
+            this.logger.info(`auto-commit created: ${subject}`);
+            this.logger.debug(out);
+        }
+        catch (err) {
+            // Never let a commit failure derail the agent loop.
+            this.logger.warn(`auto-commit failed (continuing anyway): ${err.message}`);
+        }
+    }
+    /** Run a git command via execFile (argv array, no shell). Resolves stdout. */
+    runGitQuiet(args) {
+        return new Promise((resolve) => {
+            (0, child_process_1.execFile)('git', args, { cwd: process.cwd(), maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+                if (error && !stdout) {
+                    resolve(`${stderr || error.message}`);
+                }
+                else {
+                    resolve(stdout || '');
+                }
+            });
+        });
+    }
+    /**
+     * Check if the agent should stop (STOP file, SIGINT already handled).
+     */
+    shouldStop() {
+        if (!this.running)
+            return true;
+        // Check for STOP file
+        if (this.config.stopFile) {
+            try {
+                if (fs.existsSync(this.config.stopFile)) {
+                    this.logger.warn(`STOP file detected at ${this.config.stopFile}. Shutting down gracefully...`);
+                    // Remove the stop file so next run doesn't immediately stop
+                    try {
+                        fs.unlinkSync(this.config.stopFile);
+                    }
+                    catch { /* ignore */ }
+                    // Set running=false so ALL exit paths converge. Without this, a STOP
+                    // file detected inside the pause loop would be consumed (the file is
+                    // deleted here) yet the agent would resume, because that loop only
+                    // breaks itself and the outer check relies on `running`.
+                    this.running = false;
+                    return true;
+                }
+            }
+            catch { /* ignore fs errors */ }
+        }
+        return false;
+    }
+    /**
+     * Mark the current task as complete in the queue.
+     */
+    markCurrentTaskComplete(summary) {
+        if (this.currentTaskId) {
+            const task = this.taskQueue.find((t) => t.id === this.currentTaskId);
+            if (task) {
+                task.status = 'completed';
+                task.completedAt = new Date().toISOString();
+                task.summary = summary.substring(0, 500);
+            }
+        }
+        // Store summary in progress
+        this.progress.push(`[Task Complete] ${summary}`);
+    }
+    /**
+     * Get the next task to work on. Checks queue first, then asks LLM to generate tasks.
+     */
+    async getNextTask() {
+        // Sort pending tasks by priority
+        const priorityOrder = { high: 0, medium: 1, low: 2 };
+        const pendingTasks = this.taskQueue
+            .filter((t) => t.status === 'pending')
+            .sort((a, b) => (priorityOrder[a.priority] || 1) - (priorityOrder[b.priority] || 1));
+        if (pendingTasks.length > 0) {
+            this.logger.info(`${pendingTasks.length} task(s) in queue. Picking highest priority.`);
+            return pendingTasks[0];
+        }
+        // No tasks in queue - ask LLM to generate follow-up tasks
+        this.logger.info('Queue empty. Asking LLM to identify follow-up tasks...');
+        const completedSummaries = this.taskQueue
+            .filter((t) => t.status === 'completed')
+            .map((t) => `- ${t.description} -> ${t.summary || 'done'}`)
+            .join('\n');
+        const generateRequest = [
+            {
+                role: 'system',
+                content: 'You are an autonomous AI agent in continuous mode. Your job is to identify useful follow-up tasks ' +
+                    'based on what has been accomplished. Think about: testing, documentation, optimization, edge cases, ' +
+                    'error handling, refactoring, security, and anything else that would improve the project.',
+            },
+            {
+                role: 'user',
+                content: `Original goal: ${this.taskDescription}\n\n` +
+                    `Completed tasks:\n${completedSummaries || '(none)'}\n\n` +
+                    `Based on what has been done, suggest 1-3 follow-up tasks that would be valuable. ` +
+                    `If you believe the project is truly complete and there is nothing useful left to do, respond with exactly: NO_MORE_TASKS\n\n` +
+                    `Otherwise, respond with one task per line in the format:\n` +
+                    `[high|medium|low] Description of the task`,
+            },
+        ];
+        try {
+            // Follow-up task generation is an internal call → use the small model.
+            const response = await this.provider.chatSmall(generateRequest, []);
+            const content = response.content || '';
+            if (content.includes('NO_MORE_TASKS')) {
+                this.logger.info('LLM determined there are no more tasks to do.');
+                return null;
+            }
+            // Parse generated tasks
+            const lines = content.split('\n').filter((l) => l.trim().length > 0);
+            for (const line of lines) {
+                const match = line.match(/\[(high|medium|low)\]\s*(.+)/i);
+                if (match) {
+                    const priority = match[1].toLowerCase();
+                    const description = match[2].trim();
+                    const id = `task-gen-${Date.now()}-${Math.random().toString(36).substring(2, 7)}`;
+                    this.taskQueue.push({
+                        id,
+                        description,
+                        priority,
+                        status: 'pending',
+                        addedAt: new Date().toISOString(),
+                    });
+                    this.logger.info(`Generated task [${priority}]: ${description.substring(0, 80)}`);
+                }
+            }
+            // Return the first newly generated task
+            const newPending = this.taskQueue.filter((t) => t.status === 'pending');
+            return newPending.length > 0 ? newPending[0] : null;
+        }
+        catch (error) {
+            this.logger.error(`Failed to generate follow-up tasks: ${error.message}`);
+            return null;
+        }
+    }
+    /**
+     * Process an LLM response: display content, execute tool calls.
+     */
+    async processResponse(response) {
+        // Detect a response that was cut off at max_tokens. When this happens
+        // mid-tool-call the arguments JSON is truncated and won't parse, so we
+        // flag it explicitly rather than letting it look like a random failure.
+        const truncated = response.finish_reason === 'length' || response.finish_reason === 'max_tokens';
+        if (truncated) {
+            this.logger.warn(`Model output was truncated at max_tokens (finish_reason=${response.finish_reason}). ` +
+                `Any tool call in this turn may be incomplete.`);
+        }
+        // Show agent's text output
+        if (response.content) {
+            this.logger.agent(response.content);
+        }
+        // If no tool calls, add the response and prompt the agent to continue
+        if (response.tool_calls.length === 0) {
+            this.messages.push({
+                role: 'assistant',
+                content: response.content || '',
+            });
+            // If the agent just responded with text but didn't call any tool,
+            // nudge it to take action or call task_complete
+            if (!this.taskComplete) {
+                this.messages.push({
+                    role: 'user',
+                    content: '[SYSTEM] You responded with text but did not use any tools. If the task is complete, call the "task_complete" tool. Otherwise, use tools to continue making progress.',
+                });
+            }
+            return;
+        }
+        // Add assistant message with tool calls
+        this.messages.push({
+            role: 'assistant',
+            content: response.content || '',
+            tool_calls: response.tool_calls,
+        });
+        // Execute each tool call
+        for (const toolCall of response.tool_calls) {
+            this.stats.totalToolCalls++;
+            const tool = this.tools.find((t) => t.name === toolCall.function.name);
+            if (!tool) {
+                this.messages.push({
+                    role: 'tool',
+                    tool_call_id: toolCall.id,
+                    content: `Error: Unknown tool "${toolCall.function.name}". Available tools: ${this.tools.map((t) => t.name).join(', ')}`,
+                });
+                continue;
+            }
+            let args;
+            try {
+                args = JSON.parse(toolCall.function.arguments);
+            }
+            catch {
+                // A truncated response is the most common cause of unparseable args.
+                // Tell the model exactly what happened so it can retry with smaller,
+                // well-formed arguments (e.g. write a file in chunks) instead of
+                // blindly repeating the same oversized call.
+                const hint = truncated
+                    ? 'Your previous response was cut off at the token limit, so these arguments are incomplete. ' +
+                        'Retry this tool call with shorter arguments — for large files, write them in multiple smaller edits.'
+                    : 'The arguments were not valid JSON. Retry the tool call with correctly-formatted JSON arguments.';
+                this.messages.push({
+                    role: 'tool',
+                    tool_call_id: toolCall.id,
+                    content: `Error: could not parse tool arguments. ${hint}`,
+                });
+                continue;
+            }
+            this.logger.debug(`Executing tool: ${toolCall.function.name}(${JSON.stringify(args).substring(0, 200)})`);
+            try {
+                const result = await tool.execute(args);
+                // Check for task completion signal
+                if (result.startsWith('__TASK_COMPLETE__:')) {
+                    this.taskComplete = true;
+                    this.completionSummary = result.replace('__TASK_COMPLETE__:', '');
+                    this.messages.push({
+                        role: 'tool',
+                        tool_call_id: toolCall.id,
+                        content: 'Task marked as complete.',
+                    });
+                }
+                else {
+                    this.messages.push({
+                        role: 'tool',
+                        tool_call_id: toolCall.id,
+                        content: result,
+                    });
+                }
+            }
+            catch (error) {
+                this.messages.push({
+                    role: 'tool',
+                    tool_call_id: toolCall.id,
+                    content: `Tool execution error: ${error.message}`,
+                });
+            }
+        }
+    }
+    /**
+     * Approximate token count for a slice of messages.
+     *
+     * Uses chars/4 for content plus ~4 tokens per-message overhead (role,
+     * delimiters, name field, etc. — the real overhead varies by provider
+     * but 4 is a reasonable average). This is a FALLBACK; whenever the API
+     * has reported a real prompt_tokens count we prefer that.
+     */
+    approxTokens(messages) {
+        // Per-message overhead: role token, <|im_start|>/<|im_end|> delimiters,
+        // optional name field. ~4 tokens on average across providers.
+        const PER_MESSAGE_OVERHEAD = 4;
+        return Math.ceil(messages.reduce((sum, m) => {
+            let chars = m.content?.length || 0;
+            if (m.tool_calls)
+                chars += JSON.stringify(m.tool_calls).length;
+            return sum + chars / 4 + PER_MESSAGE_OVERHEAD;
+        }, 0));
+    }
+    /**
+     * Best available measure of the CURRENT context size in tokens.
+     *
+     * Prefers the real number the API reported (lastPromptTokens) and only
+     * estimates the small tail of messages appended since that measurement.
+     * Before the first API response, falls back to a chars/4 estimate.
+     *
+     * IMPORTANT: The tail typically contains the assistant reply (whose real
+     * token count is `lastCompletionTokens`) PLUS tool-result messages. We
+     * use the real completion count for the assistant message and only
+     * estimate the tool-result messages, avoiding double-counting.
+     */
+    currentContextTokens() {
+        if (this.lastPromptTokens <= 0) {
+            // No API measurement yet — estimate the whole thing.
+            return { tokens: this.approxTokens(this.messages), exact: false };
+        }
+        const tail = this.messages.slice(this.lastPromptMessageCount);
+        if (tail.length === 0) {
+            // Nothing appended since the API measured — use the exact numbers.
+            return {
+                tokens: this.lastPromptTokens + this.lastCompletionTokens,
+                exact: true,
+            };
+        }
+        // The tail usually starts with the assistant reply (whose real token
+        // count we already know from lastCompletionTokens) followed by tool
+        // results. Only estimate the NON-assistant messages to avoid
+        // double-counting the completion.
+        const toolAndUserTail = tail.filter((m) => m.role !== 'assistant');
+        const tailApprox = this.approxTokens(toolAndUserTail);
+        return {
+            tokens: this.lastPromptTokens + this.lastCompletionTokens + tailApprox,
+            exact: false,
+        };
+    }
+    /**
+     * Manage context window size. When the conversation gets too long,
+     * ask the LLM to summarize progress so we can compress the history.
+     */
+    async manageContext(force = false) {
+        // Use the REAL API token count (plus a tiny estimated tail), not a guess.
+        const ctx = this.currentContextTokens();
+        const estimatedTokens = ctx.tokens;
+        const threshold = this.config.contextWindowLimit * this.config.summarizeThreshold;
+        // `force` is used by the context-overflow recovery path, which must
+        // summarize regardless of the (now-stale) threshold estimate.
+        if (!force && estimatedTokens < threshold)
+            return;
+        const prefix = ctx.exact ? 'Context window at' : 'Context window at ~';
+        this.logger.warn(`${prefix}${Math.round(estimatedTokens).toLocaleString()} tokens (threshold: ${Math.round(threshold).toLocaleString()}). Summarizing...`);
+        this.stats.contextResets++;
+        // Ask the LLM to summarize the conversation so far.
+        //
+        // The summary request itself must fit within the model's context window.
+        // We budget roughly half the context limit for the conversation dump
+        // (the other half is headroom for the system prompt, instructions, and
+        // the model's output). Each message is truncated to keep the total
+        // under budget.
+        const summaryBudgetTokens = Math.floor(this.config.contextWindowLimit * 0.5);
+        const messagesToSummarize = this.messages.slice(0, -1); // exclude last
+        const perMsgCharLimit = Math.max(200, Math.floor((summaryBudgetTokens * 4) / Math.max(messagesToSummarize.length, 1)));
+        const conversationDump = messagesToSummarize
+            .map((m) => {
+            const content = (m.content || '').substring(0, perMsgCharLimit);
+            const suffix = (m.content || '').length > perMsgCharLimit ? '...[truncated]' : '';
+            return `[${m.role}]: ${content}${suffix}`;
+        })
+            .join('\n\n');
+        const summaryRequest = [
+            { role: 'system', content: 'You are a helpful assistant. Summarize the following conversation into a concise progress report.' },
+            {
+                role: 'user',
+                content: `Please provide a detailed summary of everything accomplished so far in this agent session. Include:\n` +
+                    `1. The original task\n` +
+                    `2. What has been completed\n` +
+                    `3. What is currently in progress\n` +
+                    `4. Any important findings, decisions, or state (file paths, variable values, etc.)\n` +
+                    `5. What still needs to be done\n\n` +
+                    `Here is the conversation history:\n\n` +
+                    conversationDump,
+            },
+        ];
+        try {
+            // Bound this call hard: the summary is a recovery step, not the task.
+            // If the upstream is flaky (repeated 524s / long Retry-After), fail fast
+            // to the truncation fallback below instead of blocking the whole run for
+            // many minutes retrying a single summarize request.
+            // Use the cheaper small model (if configured) for this internal call.
+            const summaryResponse = await this.provider.chatSmall(summaryRequest, [], {
+                maxRetries: 2,
+                maxDelayMs: 15000,
+            });
+            const summary = summaryResponse.content || 'Unable to generate summary.';
+            this.progress.push(summary);
+            // Reset messages with the summary injected
+            this.messages = [
+                { role: 'system', content: this.config.systemPrompt },
+                {
+                    role: 'user',
+                    content: `CONTEXT RECOVERY: The conversation was too long and has been summarized. Here is the summary of everything so far:\n\n` +
+                        `--- PROGRESS SUMMARY ---\n${summary}\n--- END SUMMARY ---\n\n` +
+                        `Original task: ${this.taskDescription}\n\n` +
+                        `Continue from where you left off. Do NOT repeat work that was already completed. ` +
+                        `Use the tools to verify the current state if needed, then continue making progress.`,
+                },
+            ];
+            // The old prompt-token count no longer reflects the (now small) context.
+            // Reset so the next call re-measures from the compressed history.
+            this.lastPromptTokens = 0;
+            this.lastPromptMessageCount = 0;
+            this.lastCompletionTokens = 0;
+            this.logger.info(`Context compressed. New message count: ${this.messages.length}. Previous summaries: ${this.progress.length}`);
+        }
+        catch (error) {
+            this.logger.error(`Failed to summarize context: ${error.message}. Doing hard truncation.`);
+            // Fallback: keep system prompt + last N messages. The raw slice can begin
+            // with an orphaned tool result or end with a dangling assistant tool_call,
+            // both of which are INVALID conversation states that make providers return
+            // a 400 — turning a recovery step into an unrecoverable loop. Sanitize the
+            // window so tool_calls and tool_results are always properly paired.
+            const keepLast = 20;
+            const systemMsg = this.messages[0];
+            const recentMessages = this.sanitizeMessageWindow(this.messages.slice(-keepLast));
+            this.messages = [
+                systemMsg,
+                {
+                    role: 'user',
+                    content: `[SYSTEM] Context was truncated due to length. Original task: ${this.taskDescription}\n` +
+                        `The following are the most recent messages. Continue from where you left off.`,
+                },
+                ...recentMessages,
+            ];
+            // Stale count reflects the pre-truncation context; reset it.
+            this.lastPromptTokens = 0;
+            this.lastPromptMessageCount = 0;
+            this.lastCompletionTokens = 0;
+        }
+    }
+    /** Delegate to the standalone exported function. */
+    sanitizeMessageWindow(window) {
+        return sanitizeMessageWindow(window);
+    }
+    /**
+     * Save current state as a checkpoint.
+     */
+    saveCheckpoint() {
+        const id = new Date().toISOString().replace(/[:.]/g, '-');
+        const checkpoint = {
+            id,
+            timestamp: new Date().toISOString(),
+            iteration: this.stats.totalIterations,
+            messages: this.messages,
+            taskDescription: this.taskDescription,
+            progress: this.progress,
+            provider: this.config.provider,
+            model: this.getModelName(),
+            taskQueue: [...this.taskQueue],
+            currentTaskId: this.currentTaskId || undefined,
+            stats: { ...this.stats },
+        };
+        this.checkpoint.save(checkpoint);
+    }
+    /**
+     * Build a final summary of everything accomplished.
+     */
+    buildFinalSummary() {
+        const completed = this.taskQueue.filter((t) => t.status === 'completed');
+        const pending = this.taskQueue.filter((t) => t.status === 'pending');
+        let summary = '';
+        if (completed.length > 0) {
+            summary += `Completed ${completed.length} task(s):\n`;
+            for (const t of completed) {
+                summary += `  - ${t.description}${t.summary ? ': ' + t.summary : ''}\n`;
+            }
+        }
+        if (this.completionSummary && completed.length === 0) {
+            summary += this.completionSummary;
+        }
+        if (pending.length > 0) {
+            summary += `\n${pending.length} task(s) still pending:\n`;
+            for (const t of pending) {
+                summary += `  - [${t.priority}] ${t.description}\n`;
+            }
+        }
+        return summary || 'Task did not complete within the iteration limit.';
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+exports.Agent = Agent;
+//# sourceMappingURL=agent.js.map