autodev-cli 1.4.0 → 1.4.3

package/out/taskLoop.js

@@ -0,0 +1,2505 @@
+"use strict";
+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.taskLoopRunner = exports.TaskLoopRunner = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const crypto = __importStar(require("crypto"));
+const child_process_1 = require("child_process");
+const todo_1 = require("./todo");
+const todoWriteManager_1 = require("./todoWriteManager");
+const prompt_1 = require("./prompt");
+const messageBuilder_1 = require("./messageBuilder");
+const webhook_1 = require("./webhook");
+const settingsLoader_1 = require("./core/settingsLoader");
+const dispatcher_1 = require("./dispatcher");
+const opencodeCliProvider_1 = require("./providers/opencodeCliProvider");
+const openCodeHooksManager_1 = require("./openCodeHooksManager");
+const claudeCliProvider_1 = require("./providers/claudeCliProvider");
+const claudeTuiProvider_1 = require("./providers/claudeTuiProvider");
+const copilotSdkProvider_1 = require("./providers/copilotSdkProvider");
+const opencodeSdkProvider_1 = require("./providers/opencodeSdkProvider");
+const sessionState_1 = require("./sessionState");
+const dispatcher_2 = require("./dispatcher");
+const providers_1 = require("./providers");
+const discordPoller_1 = require("./discordPoller");
+const periodicActions_1 = require("./periodicActions");
+const discordGateway_1 = require("./discordGateway");
+const webhookPoller_1 = require("./webhookPoller");
+const emailPoller_1 = require("./emailPoller");
+const projectMcp_1 = require("./core/projectMcp");
+const configManager_1 = require("./configManager");
+const agentBackup_1 = require("./agentBackup");
+// ---------------------------------------------------------------------------
+// Rate-limit + context-length errors
+// ---------------------------------------------------------------------------
+const rateLimit_1 = require("./rateLimit");
+const cliExit_1 = require("./cliExit");
+class ContextLengthError extends Error {
+    rawMessage;
+    constructor(rawMessage) {
+        super(rawMessage);
+        this.rawMessage = rawMessage;
+        this.name = 'ContextLengthError';
+    }
+}
+/** Thrown when Claude's autocompact is thrashing — /clear is needed. */
+class ThrashingError extends ContextLengthError {
+    constructor(rawMessage) {
+        super(rawMessage);
+        this.name = 'ThrashingError';
+    }
+}
+// ---------------------------------------------------------------------------
+// RetryScheduler — single clearable timer for rate-limit resume
+// ---------------------------------------------------------------------------
+class RetryScheduler {
+    _timer = null;
+    schedule(ms, cb) {
+        this.clear();
+        this._timer = setTimeout(cb, ms);
+    }
+    clear() {
+        if (this._timer !== null) {
+            clearTimeout(this._timer);
+            this._timer = null;
+        }
+    }
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Read a CLI stdout file and return its content as a UTF-8 string.
+ * Handles all BOM variants that PowerShell may write:
+ *   \xFF\xFE → UTF-16 LE (Tee-Object default on PS5)
+ *   \xEF\xBB\xBF → UTF-8 with BOM (Out-File -Encoding UTF8 on PS5)
+ *   no BOM → plain UTF-8 (PS7)
+ */
+function readOutputFile(filePath) {
+    const raw = fs.readFileSync(filePath);
+    if (raw.length === 0) {
+        return '';
+    }
+    if (raw[0] === 0xFF && raw[1] === 0xFE) {
+        // UTF-16 LE
+        return raw.subarray(2).toString('utf16le').trim();
+    }
+    if (raw[0] === 0xEF && raw[1] === 0xBB && raw[2] === 0xBF) {
+        // UTF-8 BOM
+        return raw.subarray(3).toString('utf8').trim();
+    }
+    return raw.toString('utf8').trim();
+}
+/** First line of task text, capped at 200 chars — safe to post to Discord. */
+function discordLabel(taskText) {
+    const first = taskText.split('\n')[0].trim();
+    return first.length > 200 ? first.slice(0, 197) + '\u2026' : first;
+}
+function resolveGitInfo(workDir) {
+    const run = (cmd) => {
+        try {
+            return (0, child_process_1.execSync)(cmd, { cwd: workDir, stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+        }
+        catch {
+            return '';
+        }
+    };
+    return {
+        gitRepo: run('git remote get-url origin'),
+        gitBranch: run('git rev-parse --abbrev-ref HEAD'),
+    };
+}
+class TaskLoopRunner {
+    _state = 'idle';
+    _currentTask;
+    _taskWatcher;
+    _iterations = 0;
+    _cb;
+    _webhook = null;
+    _settings;
+    _workspaceRoot;
+    _discordPoller = null;
+    _discordGateway = null;
+    _webhookPoller = null;
+    _emailPoller = null;
+    /** True after we last told the server "all_tasks_done" — cleared on task_start.
+     *  Used to re-assert idle state on WS reconnect, otherwise agent_online flips
+     *  the server-side status back to 'active' even though we have no work. */
+    _idleNotified = false;
+    _pollerIntervals = [];
+    _hooksFileOffset = 0;
+    /** Recently-forwarded hook-line hashes → first-seen timestamp (ms).
+     *  Used to suppress byte-identical hook events that get appended multiple
+     *  times to the shared JSONL (Copilot CLI fires the same hook from every
+     *  parallel session in the same workspace, all writing to one homedir
+     *  file). Entries older than HOOKS_DEDUPE_WINDOW_MS are pruned each tick. */
+    _hookLineSeen = new Map();
+    _taskCompletionAbort = null;
+    _retryScheduler = new RetryScheduler();
+    _resumeResolve = null;
+    /** Resolves the idle no-task sleep early when a poller appends a new task. */
+    _idleSleepWake = null;
+    _resumeAt;
+    /** When fallback is active: the saved main provider and when to switch back. */
+    _mainProviderBeforeFallback = null;
+    _mainProviderResumeAt;
+    _gitRepo = '';
+    _gitBranch = '';
+    _hostname = '';
+    _completedCount = 0;
+    _failedCount = 0;
+    _loopStartTime = 0;
+    /** Task lines that have already had /compact run — prevents infinite compact loops. */
+    _compactedTaskLines = new Set();
+    /** True while a compact operation is in progress — prevents nested/recursive compacts. */
+    _compacting = false;
+    /** Timestamp (ms) when compact was last run — used to throttle auto-compact (minimum 2min between compacts). */
+    _lastCompactTime = 0;
+    /** Dispatch attempt counter per task key (id or text). After 3 failed attempts the
+     *  loop force-marks the task done so it doesn't block the queue indefinitely. */
+    _taskAttempts = new Map();
+    /** Counts completed tasks since the last auto-compact run. */
+    _autoCompactCounter = 0;
+    /** Counts completed tasks since the last session reset. */
+    _resetSessionCounter = 0;
+    /** Counts tasks dispatched since the last profile-included send. */
+    _profileSentCounter = 0;
+    /** Manages all "every N tasks" periodic action counters. */
+    _periodicMgr = new periodicActions_1.PeriodicActionManager();
+    get state() { return this._state; }
+    get currentTask() { return this._currentTask; }
+    get resumeAt() { return this._resumeAt; }
+    /** Manually trigger a /compact on the current session for the given provider/root. */
+    async compact(root, provider) {
+        const log = (m) => this._cb?.log(m);
+        // Guard: prevent infinite compact loops
+        if (this._compacting) {
+            log('⚠️  Compact skipped: already compacting (infinite loop prevention)');
+            return;
+        }
+        this._compacting = true;
+        log(`🗜 Manual compact triggered (provider: ${provider})`);
+        try {
+            if (provider === 'claude-cli') {
+                let sid = (0, sessionState_1.getSessionId)(root, 'claude-cli');
+                if (!sid) {
+                    sid = (0, dispatcher_1.findLatestClaudeSession)(root);
+                }
+                if (sid) {
+                    await (0, claudeCliProvider_1.runClaudeCompact)(sid, root, log);
+                    log('🗜 Compact complete');
+                }
+                else {
+                    log('⚠️ Compact: no Claude session ID found');
+                }
+            }
+            else if (provider === 'claude-tui') {
+                let sid = (0, sessionState_1.getSessionId)(root, 'claude-tui');
+                if (!sid) {
+                    sid = (0, claudeTuiProvider_1.getClaudeTuiLatestSessionId)(root);
+                }
+                if (sid) {
+                    await (0, claudeTuiProvider_1.runClaudeTuiCompact)(root, sid, log);
+                    log('🗜 Compact complete');
+                }
+                else {
+                    log('⚠️ Compact: no Claude TUI session ID found');
+                }
+            }
+            else if (provider === 'opencode-cli') {
+                let sid = (0, sessionState_1.getSessionId)(root, 'opencode-cli');
+                if (!sid) {
+                    sid = await (0, opencodeCliProvider_1.getLatestOpenCodeSessionId)(root, log);
+                }
+                if (sid) {
+                    await (0, opencodeCliProvider_1.runOpenCodeCompact)(sid, root, log);
+                    log('🗜 Compact complete');
+                }
+                else {
+                    log('⚠️ Compact: no OpenCode session ID found');
+                }
+            }
+            else if (provider === 'opencode-sdk') {
+                await (0, opencodeSdkProvider_1.runOpencodeSdkCompact)(root, log);
+                log('🗜 Compact complete (opencode-sdk)');
+            }
+            else {
+                log(`⚠️ Compact not supported for provider: ${provider}`);
+            }
+        }
+        catch (e) {
+            log(`⚠️ Compact failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        finally {
+            this._compacting = false;
+            this._lastCompactTime = Date.now();
+        }
+    }
+    /** Manually trigger a /clear on the current Claude session for the given provider/root. */
+    async clearSession(root, provider) {
+        const log = (m) => this._cb?.log(m);
+        log(`🗑 Manual /clear triggered (provider: ${provider})`);
+        try {
+            if (provider === 'claude-cli') {
+                let sid = (0, sessionState_1.getSessionId)(root, 'claude-cli');
+                if (!sid) {
+                    sid = (0, dispatcher_1.findLatestClaudeSession)(root);
+                }
+                if (sid) {
+                    await (0, claudeCliProvider_1.runClaudeClear)(sid, root, log);
+                    (0, sessionState_1.clearSessionId)(root, 'claude-cli');
+                    log('🗑 /clear complete — session reset');
+                }
+                else {
+                    log('⚠️ /clear: no Claude session ID found');
+                }
+            }
+            else if (provider === 'claude-tui') {
+                let sid = (0, sessionState_1.getSessionId)(root, 'claude-tui');
+                if (!sid) {
+                    sid = (0, claudeTuiProvider_1.getClaudeTuiLatestSessionId)(root);
+                }
+                if (sid) {
+                    await (0, claudeTuiProvider_1.runClaudeTuiClear)(root, sid, log);
+                    (0, sessionState_1.clearSessionId)(root, 'claude-tui');
+                    log('🗑 /clear (TUI) complete — session reset');
+                }
+                else {
+                    log('⚠️ /clear: no Claude TUI session ID found');
+                }
+            }
+            else {
+                log(`⚠️ /clear not supported for provider: ${provider}`);
+            }
+        }
+        catch (e) {
+            log(`⚠️ /clear failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    /** Resume the loop after a rate-limit pause. Clears the scheduled timer. */
+    retry() {
+        if (this._state !== 'paused') {
+            return;
+        }
+        this._retryScheduler.clear();
+        this._resumeAt = undefined;
+        this._mainProviderBeforeFallback = null;
+        this._mainProviderResumeAt = undefined;
+        this._setState('running');
+        const r = this._resumeResolve;
+        this._resumeResolve = null;
+        r?.();
+    }
+    async start(callbacks) {
+        if (this._state === 'running') {
+            callbacks.log('Task loop already running');
+            return;
+        }
+        this._cb = callbacks;
+        this._iterations = 0;
+        this._compactedTaskLines.clear();
+        this._taskAttempts.clear();
+        this._autoCompactCounter = 0;
+        this._resetSessionCounter = 0;
+        this._profileSentCounter = 0;
+        this._periodicMgr.resetAndPersist(callbacks.workspaceRoot);
+        this._hookLineSeen.clear();
+        this._setState('running');
+        const settings = (0, settingsLoader_1.loadSettingsForRoot)(callbacks.workspaceRoot);
+        const root = callbacks.workspaceRoot;
+        if (!root) {
+            callbacks.log('No workspace folder open');
+            this._setState('idle');
+            return;
+        }
+        this._settings = settings;
+        this._workspaceRoot = root;
+        this._completedCount = 0;
+        this._failedCount = 0;
+        this._loopStartTime = Date.now();
+        this._hostname = os.hostname();
+        const git = resolveGitInfo(root);
+        this._gitRepo = git.gitRepo;
+        this._gitBranch = git.gitBranch;
+        this._webhook = (settings.serverBaseUrl && settings.webhookSlug)
+            ? new webhook_1.WebhookClient(settings.serverBaseUrl.replace(/\/$/, '') + '/webhook/' + settings.webhookSlug, settings.serverApiKey, settings.webhookSlug)
+            : null;
+        this._webhook?.setMeta({ provider: settings.provider, workDir: root, hostname: this._hostname, gitRepo: this._gitRepo, gitBranch: this._gitBranch });
+        this._discordPoller = (settings.discordToken && settings.discordChannelId && settings.discordOwners)
+            ? new discordPoller_1.DiscordPoller(settings.discordToken, settings.discordChannelId, settings.discordOwners)
+            : null;
+        this._discordGateway = settings.discordToken
+            ? new discordGateway_1.DiscordGateway(settings.discordToken)
+            : null;
+        this._webhookPoller = (settings.serverBaseUrl && settings.serverApiKey && settings.webhookSlug)
+            ? new webhookPoller_1.WebhookPoller(settings.serverBaseUrl, settings.serverApiKey, settings.webhookSlug)
+            : null;
+        // Email task ingestion — pulls IMAP creds from the Email MCP entry's env
+        // block. Disabled unless AUTODEV_EMAIL_RECEIVE_TASKS is "true".
+        this._emailPoller = this._buildEmailPoller(settings);
+        // When the poller is WebSocket-backed, route outbound events through the
+        // same WS connection instead of HTTP POST (which fails for ws:// URLs).
+        if (this._webhook && this._webhookPoller?.isWebSocket) {
+            this._webhook.setWsSender((frame) => this._webhookPoller.sendFrame(frame));
+            // Re-send agent_online once the WS connection is actually established so
+            // the server can record the VNC host/port from the live connection context.
+            this._webhookPoller.setOnConnect(() => {
+                // If the loop is no longer running (stopped or stopping), re-assert
+                // offline status on reconnect instead of claiming agent_online.
+                if (this._state === 'idle' || this._state === 'stopping') {
+                    this._notifyWebhook('agent_offline', {
+                        workDir: this._workspaceRoot ?? '',
+                        gitRepo: this._gitRepo,
+                        gitBranch: this._gitBranch,
+                    });
+                    return;
+                }
+                this._notifyWebhook('agent_online', {
+                    hostname: this._hostname,
+                    workDir: this._workspaceRoot ?? '',
+                    gitRepo: this._gitRepo,
+                    gitBranch: this._gitBranch,
+                    vncEnabled: this._settings?.vncEnabled ?? false,
+                    vncHost: this._settings?.vncEnabled ? (this._settings?.vncHost || undefined) : undefined,
+                    vncPort: this._settings?.vncEnabled ? (this._settings?.vncPort ?? 5900) : undefined,
+                    rdpEnabled: this._settings?.rdpEnabled ?? false,
+                    rdpHost: this._settings?.rdpEnabled ? (this._settings?.rdpHost || undefined) : undefined,
+                    rdpPort: this._settings?.rdpEnabled ? (this._settings?.rdpPort ?? 3389) : undefined,
+                    fileBrowserEnabled: this._settings?.enableFileBrowser ?? false,
+                    gitEnabled: this._settings?.gitEnabled ?? false,
+                });
+                // Re-sync working state if the WS dropped mid-task
+                if (this._currentTask) {
+                    this._notifyWebhook('task_start', {
+                        iteration: this._iterations,
+                        task: { text: this._currentTask },
+                        workDir: this._workspaceRoot,
+                        gitRepo: this._gitRepo,
+                        gitBranch: this._gitBranch,
+                    });
+                }
+                // Re-sync idle state if we previously drained the queue — otherwise the
+                // server-side `agent_online` handler flips status back to 'active' and
+                // the agent looks busy when it isn't.
+                if (!this._currentTask && this._idleNotified) {
+                    this._notifyWebhook('agent_idle', {
+                        workDir: this._workspaceRoot,
+                        gitRepo: this._gitRepo,
+                        gitBranch: this._gitBranch,
+                    });
+                }
+            });
+        }
+        // Pass VNC password so the poller can authenticate incoming vnc_session requests.
+        if (this._webhookPoller && settings.vncEnabled && settings.vncPassword) {
+            this._webhookPoller.setVncPassword(settings.vncPassword);
+        }
+        if (this._webhookPoller) {
+            this._webhookPoller.setGitEnabled(settings.gitEnabled ?? false);
+            // Wake the idle no-task sleep instantly when a WS-pushed task arrives.
+            this._webhookPoller.setOnTaskAppend(() => this._wakeIdleSleep());
+            this._webhookPoller.setOnCommand((cmd) => this._handleCommand(cmd));
+            this._webhookPoller.setOnMcpUpdate((entries) => this._handleMcpUpdate(entries));
+            this._webhookPoller.setOnExportRequest((agentId) => void this._handleExportRequest(agentId));
+            this._webhookPoller.setOnRestoreRequest((agentId, downloadUrl) => void this._handleRestoreRequest(agentId, downloadUrl));
+            this._webhookPoller.setOnExportConfig((exportEnabled, exportDailyBackup, agentId) => this._handleExportConfig(exportEnabled, exportDailyBackup, agentId));
+        }
+        if (this._discordPoller) {
+            this._discordPoller.setOnCommand((cmd) => this._handleCommand(cmd));
+        }
+        if (this._webhookPoller && settings.rdpEnabled) {
+            this._webhookPoller.setRdpSettings({
+                host: settings.rdpHost || undefined,
+                port: settings.rdpPort ?? 3389,
+                username: settings.rdpUsername || undefined,
+                password: settings.rdpPassword || undefined,
+                domain: settings.rdpDomain || undefined,
+                guacWsUrl: settings.rdpGuacWsUrl || undefined,
+            });
+        }
+        const todoPath = settings.todoPath || path.join(root, 'TODO.md');
+        // Seed Discord cursor to ignore history before the loop started
+        if (this._discordPoller) {
+            await this._discordPoller.initialize();
+        }
+        if (this._emailPoller) {
+            try {
+                await this._emailPoller.initialize();
+                callbacks.log('🔧 Email task poller started — checking inbox every 10s');
+            }
+            catch (e) {
+                callbacks.log(`Email poller init failed: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+        else {
+            const root = this._workspaceRoot;
+            const userMcp = root ? (0, projectMcp_1.loadProjectUserMcp)(root) : {};
+            const entry = userMcp['zerolib-email'];
+            const env = entry?.env ?? {};
+            const reasons = [];
+            if (!entry)
+                reasons.push('no zerolib-email entry in .mcp.json');
+            else {
+                if (String(env.AUTODEV_EMAIL_RECEIVE_TASKS).toLowerCase() !== 'true')
+                    reasons.push('AUTODEV_EMAIL_RECEIVE_TASKS != "true"');
+                if (!env.MCP_EMAIL_SERVER_IMAP_HOST)
+                    reasons.push('IMAP host missing');
+                if (!(env.MCP_EMAIL_SERVER_USER_NAME || env.MCP_EMAIL_SERVER_EMAIL_ADDRESS))
+                    reasons.push('IMAP user/email missing');
+                if (!env.MCP_EMAIL_SERVER_PASSWORD)
+                    reasons.push('IMAP password missing');
+            }
+            if (reasons.length)
+                callbacks.log(`🔧 Email task poller NOT started: ${reasons.join('; ')}`);
+        }
+        // Connect to Discord Gateway so the bot appears online
+        this._discordGateway?.connect();
+        // Start WebSocket connection (no-op for HTTP pollers)
+        if (this._webhookPoller) {
+            this._webhookPoller.start(todoPath, (msg) => callbacks.log(msg), root);
+        }
+        // Start independent background polling loops — run even while AI is processing a task
+        this._startPollers(todoPath);
+        callbacks.log(`Task loop starting — TODO: ${todoPath}`);
+        this._notifyWebhook('loop_start', {
+            provider: settings.provider,
+            workDir: root,
+            gitRepo: this._gitRepo,
+            gitBranch: this._gitBranch,
+        });
+        this._notifyWebhook('agent_online', {
+            hostname: this._hostname,
+            workDir: root,
+            gitRepo: this._gitRepo,
+            gitBranch: this._gitBranch,
+            vncEnabled: settings.vncEnabled ?? false,
+            vncHost: settings.vncEnabled ? (settings.vncHost || undefined) : undefined,
+            vncPort: settings.vncEnabled ? (settings.vncPort ?? 5900) : undefined,
+            rdpEnabled: settings.rdpEnabled ?? false,
+            rdpHost: settings.rdpEnabled ? (settings.rdpHost || undefined) : undefined,
+            rdpPort: settings.rdpEnabled ? (settings.rdpPort ?? 3389) : undefined,
+            fileBrowserEnabled: settings.enableFileBrowser ?? false,
+            gitEnabled: settings.gitEnabled ?? false,
+        });
+        this._notifyDiscord('🚀 AutoDev task loop started');
+        // Auto-run `cozempic init` for Claude CLI projects so the guard daemon and
+        // pruning hooks are wired automatically — the user only needs cozempic on
+        // their PATH; no per-project manual step required.
+        if (settings.provider === 'claude-cli') {
+            this._runCozempicInit(root, callbacks.log.bind(callbacks));
+        }
+        this._checkDailyBackup(settings.agentId || settings.webhookSlug || undefined);
+        try {
+            await this._runLoop(todoPath, settings);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            callbacks.log(`Task loop error: ${msg}`);
+        }
+        const elapsed = Math.round((Date.now() - this._loopStartTime) / 1000);
+        this._notifyWebhook('loop_complete', {
+            total: this._completedCount + this._failedCount,
+            success: this._completedCount,
+            failed: this._failedCount,
+            elapsed,
+            workDir: root,
+            gitRepo: this._gitRepo,
+            gitBranch: this._gitBranch,
+        });
+        this._notifyWebhook('agent_offline', {
+            total: this._completedCount + this._failedCount,
+            success: this._completedCount,
+            failed: this._failedCount,
+            elapsed,
+            workDir: root,
+            gitRepo: this._gitRepo,
+            gitBranch: this._gitBranch,
+        });
+        this._notifyDiscord('👋 AutoDev loop ended');
+        this._stopPollers();
+        this._currentTask = undefined;
+        this._webhook = null;
+        this._discordPoller = null;
+        this._discordGateway?.destroy();
+        this._discordGateway = null;
+        this._webhookPoller = null;
+        if (this._emailPoller) {
+            void this._emailPoller.dispose();
+            this._emailPoller = null;
+        }
+        this._setState('idle');
+        callbacks.log('Task loop stopped');
+    }
+    stop() {
+        if (this._state !== 'running' && this._state !== 'paused') {
+            return;
+        }
+        this._setState('stopping');
+        this._retryScheduler.clear();
+        this._resumeAt = undefined;
+        this._mainProviderBeforeFallback = null;
+        this._mainProviderResumeAt = undefined;
+        // Unblock _pause() if we're currently suspended
+        const r = this._resumeResolve;
+        this._resumeResolve = null;
+        r?.();
+        // Unblock the idle no-task sleep immediately
+        const w = this._idleSleepWake;
+        this._idleSleepWake = null;
+        w?.();
+        this._disposeWatcher();
+        this._stopPollers();
+        // Abort any in-progress task wait immediately
+        this._taskCompletionAbort?.();
+        this._taskCompletionAbort = null;
+        // Notify Pixel Office / webhook immediately — don't wait for the _runLoop
+        // finally block which may never fire if the WS disconnects before cleanup.
+        this._notifyWebhook('agent_offline', {
+            workDir: this._workspaceRoot,
+            gitRepo: this._gitRepo,
+            gitBranch: this._gitBranch,
+        });
+        // Send discord goodbye right now (don't wait for cleanup path)
+        this._notifyDiscord('⛔ AutoDev loop stopped');
+        this._cb?.log('Task loop stop requested…');
+    }
+    /**
+     * Stop the loop and, once it reaches idle, start it again with the same
+     * callbacks. Useful for picking up new MCP server configs etc.
+     */
+    async restart() {
+        const savedCb = this._cb;
+        if (!savedCb) {
+            return;
+        }
+        if (this._state !== 'idle') {
+            this.stop();
+            const deadline = Date.now() + 15_000;
+            while (this._state !== 'idle' && Date.now() < deadline) {
+                await new Promise(r => setTimeout(r, 100));
+            }
+        }
+        await this.start(savedCb);
+    }
+    /** Handle mcp_update pushed from pixel-office: write .mcp.json, sync all providers, restart loop. */
+    _handleMcpUpdate(entries) {
+        const root = this._workspaceRoot;
+        if (!root)
+            return;
+        this._cb?.log('🔧 mcp_update received — writing .mcp.json and syncing providers…');
+        try {
+            // Cast to the shape saveProjectUserMcp expects
+            const typed = entries;
+            (0, projectMcp_1.saveProjectUserMcp)(root, typed);
+            configManager_1.ConfigManager.syncProjectMcpServers(root, (m) => this._cb?.log(m));
+            this._cb?.log('✅ MCP config synced to .mcp.json, opencode.json, .vscode/mcp.json — restarting loop…');
+        }
+        catch (err) {
+            this._cb?.log(`⚠️ MCP update failed: ${err instanceof Error ? err.message : String(err)}`);
+            return;
+        }
+        void this.restart();
+    }
+    /** Handle export_request from pixel-office: create backup zip and upload. */
+    async _handleExportRequest(agentId) {
+        const root = this._workspaceRoot;
+        const settings = this._settings;
+        if (!root || !settings?.serverBaseUrl || !settings?.serverApiKey) {
+            this._cb?.log('⚠️ export_request ignored — serverBaseUrl/serverApiKey not configured');
+            return;
+        }
+        this._cb?.log('📦 export_request received — building backup zip…');
+        const tmpPath = path.join(os.tmpdir(), `agent-backup-${agentId}-${Date.now()}.zip`);
+        try {
+            await (0, agentBackup_1.createAgentBackup)(root, tmpPath);
+            this._cb?.log('📤 Uploading backup to pixel-office…');
+            const result = await (0, agentBackup_1.uploadAgentBackup)(tmpPath, agentId, settings.serverBaseUrl, settings.serverApiKey);
+            this._saveLastBackupTime(root);
+            this._cb?.log(`✅ Backup uploaded: ${result.filename}`);
+        }
+        catch (err) {
+            this._cb?.log(`⚠️ Export failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        finally {
+            try {
+                fs.unlinkSync(tmpPath);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    /** Handle restore_request from pixel-office: download zip and restore workspace. */
+    async _handleRestoreRequest(agentId, downloadUrl) {
+        const root = this._workspaceRoot;
+        const settings = this._settings;
+        if (!root || !settings?.serverApiKey) {
+            this._cb?.log('⚠️ restore_request ignored — serverApiKey not configured');
+            return;
+        }
+        this._cb?.log(`🔄 restore_request received — downloading backup from ${downloadUrl}…`);
+        const tmpPath = path.join(os.tmpdir(), `agent-restore-${agentId}-${Date.now()}.zip`);
+        try {
+            await (0, agentBackup_1.downloadAgentBackup)(downloadUrl, tmpPath, settings.serverApiKey);
+            this._cb?.log('📂 Restoring workspace from backup…');
+            const result = await (0, agentBackup_1.restoreAgentBackup)(tmpPath, root);
+            this._cb?.log(`✅ Restored ${result.workspaceFiles} workspace file(s) — restarting loop…`);
+            void this.restart();
+        }
+        catch (err) {
+            this._cb?.log(`⚠️ Restore failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        finally {
+            try {
+                fs.unlinkSync(tmpPath);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    /** Handle export_config from pixel-office: persist exportEnabled + exportDailyBackup to settings. */
+    _handleExportConfig(exportEnabled, exportDailyBackup, agentId) {
+        const root = this._workspaceRoot;
+        if (!root)
+            return;
+        try {
+            const { loadSettingsForRoot: load, settingsWritePath } = require('./core/settingsLoader');
+            const current = load(root);
+            if (current.exportEnabled === exportEnabled && current.exportDailyBackup === exportDailyBackup && (!agentId || current.agentId === agentId))
+                return;
+            current.exportEnabled = exportEnabled;
+            current.exportDailyBackup = exportDailyBackup;
+            if (agentId)
+                current.agentId = agentId;
+            fs.mkdirSync(path.join(root, '.autodev'), { recursive: true });
+            fs.writeFileSync(settingsWritePath(root), JSON.stringify(current, null, 2), 'utf8');
+            this._cb?.log(`⚙️ Export config updated: enabled=${exportEnabled}, dailyBackup=${exportDailyBackup}`);
+        }
+        catch (err) {
+            this._cb?.log(`⚠️ export_config write failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    /** Check if a daily backup is due and trigger it automatically. */
+    _checkDailyBackup(agentId) {
+        if (!agentId)
+            return;
+        const settings = this._settings;
+        if (!settings?.exportEnabled || !settings?.exportDailyBackup)
+            return;
+        const root = this._workspaceRoot;
+        if (!root)
+            return;
+        const MS_PER_DAY = 86_400_000;
+        const statePath = path.join(root, '.autodev', 'last_backup.json');
+        try {
+            if (fs.existsSync(statePath)) {
+                const { ts } = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+                if (Date.now() - ts < MS_PER_DAY)
+                    return;
+            }
+        }
+        catch { /* proceed */ }
+        this._cb?.log('⏰ Daily backup due — triggering automatic export…');
+        void this._handleExportRequest(agentId);
+    }
+    _saveLastBackupTime(root) {
+        try {
+            fs.writeFileSync(path.join(root, '.autodev', 'last_backup.json'), JSON.stringify({ ts: Date.now() }), 'utf8');
+        }
+        catch { /* ignore */ }
+    }
+    /** Dispatch a slash command received from any inbound channel. */
+    _handleCommand(cmd) {
+        const c = cmd.trim().toLowerCase();
+        if (c === '/restart') {
+            this._cb?.log('🔄 /restart received — restarting loop…');
+            this._notifyDiscord('🔄 Restarting loop (/restart received)');
+            void this.restart();
+            return;
+        }
+        if (c === '/clear') {
+            this._cb?.log('🗑 /clear received — clearing Claude session…');
+            this._notifyDiscord('🗑 `/clear` received — clearing Claude session');
+            const root = this._workspaceRoot;
+            const provider = this._cb?.getActiveProvider() ?? '';
+            if (root) {
+                if (provider === 'claude-tui') {
+                    let sessionId = (0, sessionState_1.getSessionId)(root, 'claude-tui');
+                    if (!sessionId) {
+                        sessionId = (0, claudeTuiProvider_1.getClaudeTuiLatestSessionId)(root);
+                    }
+                    if (sessionId) {
+                        (0, claudeTuiProvider_1.runClaudeTuiClear)(root, sessionId, msg => this._cb?.log(msg))
+                            .then(() => { (0, sessionState_1.clearSessionId)(root, 'claude-tui'); this._cb?.log('🗑 /clear (TUI) complete'); })
+                            .catch(e => this._cb?.log(`⚠️ /clear (TUI) failed: ${e instanceof Error ? e.message : String(e)}`));
+                    }
+                    else {
+                        this._cb?.log('⚠️ /clear: no active Claude TUI session found');
+                    }
+                }
+                else {
+                    // Default to claude-cli
+                    let sessionId = (0, sessionState_1.getSessionId)(root, 'claude-cli');
+                    if (!sessionId) {
+                        sessionId = (0, dispatcher_1.findLatestClaudeSession)(root);
+                    }
+                    if (sessionId) {
+                        (0, claudeCliProvider_1.runClaudeClear)(sessionId, root, msg => this._cb?.log(msg))
+                            .then(() => { (0, sessionState_1.clearSessionId)(root, 'claude-cli'); this._cb?.log('🗑 /clear complete'); })
+                            .catch(e => this._cb?.log(`⚠️ /clear failed: ${e instanceof Error ? e.message : String(e)}`));
+                    }
+                    else {
+                        this._cb?.log('⚠️ /clear: no active Claude session found');
+                    }
+                }
+            }
+        }
+    }
+    // -------------------------------------------------------------------------
+    /**
+     * Build an EmailTaskPoller from the Email MCP entry's env block, or return
+     * null if the feature is disabled or required IMAP creds are missing.
+     */
+    _buildEmailPoller(settings) {
+        const root = this._workspaceRoot;
+        const userMcp = root ? (0, projectMcp_1.loadProjectUserMcp)(root) : {};
+        const entry = userMcp['zerolib-email'];
+        const env = entry?.env ?? {};
+        if (!entry)
+            return null;
+        if (String(env.AUTODEV_EMAIL_RECEIVE_TASKS).toLowerCase() !== 'true')
+            return null;
+        const host = env.MCP_EMAIL_SERVER_IMAP_HOST;
+        const user = env.MCP_EMAIL_SERVER_USER_NAME || env.MCP_EMAIL_SERVER_EMAIL_ADDRESS;
+        const pass = env.MCP_EMAIL_SERVER_PASSWORD;
+        if (!host || !user || !pass)
+            return null;
+        const port = parseInt(env.MCP_EMAIL_SERVER_IMAP_PORT || '993', 10) || 993;
+        const secure = String(env.MCP_EMAIL_SERVER_IMAP_SSL ?? 'true').toLowerCase() !== 'false';
+        const verify = String(env.MCP_EMAIL_SERVER_IMAP_VERIFY_SSL ?? 'true').toLowerCase() !== 'false';
+        const allowed = (env.AUTODEV_EMAIL_ALLOWED_SENDERS || '')
+            .split(',').map(s => s.trim()).filter(Boolean);
+        return new emailPoller_1.EmailTaskPoller({ host, port, secure, user, pass, allowedSenders: allowed, rejectUnauthorized: verify });
+    }
+    /**
+     * Start Discord and webhook server pollers as independent setInterval loops.
+     * They run continuously in the background — even while the AI is processing a task.
+     */
+    _startPollers(todoPath) {
+        const POLL_MS = 3_000;
+        if (this._discordPoller) {
+            const discordInterval = setInterval(async () => {
+                if (this._state !== 'running') {
+                    return;
+                }
+                try {
+                    const appended = await this._discordPoller.pollAndAppend(todoPath, this._workspaceRoot ?? undefined);
+                    if (appended) {
+                        this._wakeIdleSleep();
+                    }
+                }
+                catch { }
+            }, POLL_MS);
+            this._pollerIntervals.push(discordInterval);
+        }
+        if (this._webhookPoller) {
+            const webhookInterval = setInterval(async () => {
+                if (this._state !== 'running') {
+                    return;
+                }
+                try {
+                    const appended = await this._webhookPoller.pollAndAppend(todoPath, this._workspaceRoot ?? undefined);
+                    if (appended) {
+                        this._wakeIdleSleep();
+                    }
+                }
+                catch { }
+            }, POLL_MS);
+            this._pollerIntervals.push(webhookInterval);
+        }
+        if (this._emailPoller) {
+            // IMAP servers throttle aggressive polling — every 10s is plenty.
+            const emailInterval = setInterval(async () => {
+                if (this._state !== 'running') {
+                    return;
+                }
+                try {
+                    const appended = await this._emailPoller.pollAndAppend(todoPath, this._workspaceRoot ?? undefined);
+                    if (appended) {
+                        this._wakeIdleSleep();
+                    }
+                }
+                catch { }
+            }, 10_000);
+            this._pollerIntervals.push(emailInterval);
+        }
+        // Poll <workspace>/.autodev/hooks-events.jsonl every 10s and forward new
+        // lines via WS. Per-workspace, NOT homedir: two VS Code instances on the
+        // same machine would otherwise both poll one shared file and each ship
+        // every line under their own slug — making hooks from `tester-1` show
+        // up as `A1` (and vice-versa) in pixel-office.
+        if (this._webhookPoller?.isWebSocket && this._workspaceRoot) {
+            const hooksJsonl = path.join(this._workspaceRoot, '.autodev', 'hooks-events.jsonl');
+            // Start at current file size so we don't replay old events on loop restart
+            try {
+                this._hooksFileOffset = fs.existsSync(hooksJsonl)
+                    ? fs.statSync(hooksJsonl).size
+                    : 0;
+            }
+            catch {
+                this._hooksFileOffset = 0;
+            }
+            // Dedupe window: any hook line byte-identical to one forwarded within
+            // this many ms is dropped. Even with per-workspace sinks, parallel
+            // copilot/claude processes inside the same workspace can write the
+            // same payload several times in one second.
+            const HOOKS_DEDUPE_WINDOW_MS = 30_000;
+            const hooksInterval = setInterval(() => {
+                if (this._state !== 'running') {
+                    return;
+                }
+                try {
+                    if (!fs.existsSync(hooksJsonl)) {
+                        return;
+                    }
+                    const size = fs.statSync(hooksJsonl).size;
+                    if (size <= this._hooksFileOffset) {
+                        return;
+                    }
+                    const fd = fs.openSync(hooksJsonl, 'r');
+                    const buf = Buffer.alloc(size - this._hooksFileOffset);
+                    fs.readSync(fd, buf, 0, buf.length, this._hooksFileOffset);
+                    fs.closeSync(fd);
+                    this._hooksFileOffset = size;
+                    const sessionName = (this._settings?.sessionName && this._settings.sessionName.trim())
+                        || (this._workspaceRoot ? path.basename(this._workspaceRoot) : undefined);
+                    const lines = buf.toString('utf8').split('\n').filter(l => l.trim());
+                    // Prune dedupe map of stale entries before this tick's run
+                    const now = Date.now();
+                    for (const [hash, ts] of this._hookLineSeen) {
+                        if (now - ts > HOOKS_DEDUPE_WINDOW_MS) {
+                            this._hookLineSeen.delete(hash);
+                        }
+                    }
+                    for (const line of lines) {
+                        const hash = crypto.createHash('sha1').update(line).digest('hex');
+                        const seenAt = this._hookLineSeen.get(hash);
+                        if (seenAt !== undefined && now - seenAt <= HOOKS_DEDUPE_WINDOW_MS) {
+                            // Byte-identical hook within the window — drop silently. Distinct
+                            // tool invocations have at least one differing byte (timestamp,
+                            // tool input args, runId) and survive this check.
+                            continue;
+                        }
+                        this._hookLineSeen.set(hash, now);
+                        try {
+                            const ev = JSON.parse(line);
+                            // Inject session name (workspace folder) so pixel office can display it
+                            if (sessionName) {
+                                ev._session_name = sessionName;
+                            }
+                            this._webhookPoller.sendFrame({ type: 'hook_event', data: ev });
+                        }
+                        catch { /* skip malformed lines */ }
+                    }
+                }
+                catch { /* ignore read errors */ }
+            }, 10_000);
+            this._pollerIntervals.push(hooksInterval);
+        }
+    }
+    /**
+     * Run `cozempic init` in the given project directory if:
+     *  1. `cozempic` is on the PATH (or login-shell PATH on Unix)
+     *  2. The project hasn't been initialised yet
+     *     (`.claude/settings.local.json` does not contain a cozempic hook entry)
+     *
+     * Runs synchronously in a background thread-pool task (spawnSync) so it
+     * doesn't block the VS Code event loop but still logs completion.
+     */
+    _runCozempicInit(workspaceRoot, log) {
+        try {
+            // Detect whether cozempic hooks are already wired for this project.
+            // `cozempic init` writes its hooks into .claude/settings.local.json.
+            const localSettingsPath = path.join(workspaceRoot, '.claude', 'settings.local.json');
+            if (fs.existsSync(localSettingsPath)) {
+                const content = fs.readFileSync(localSettingsPath, 'utf8');
+                if (content.includes('cozempic')) {
+                    // Already initialised — skip silently.
+                    return;
+                }
+            }
+            // Resolve cozempic binary (VS Code's process.env.PATH may not include
+            // ~/.local/bin where pipx/pip installs it, so try a login shell on Unix).
+            const isWin = process.platform === 'win32';
+            // Disable telemetry and auto-update pings for all cozempic invocations.
+            const cozempicEnv = { ...process.env, COZEMPIC_NO_TELEMETRY: '1', COZEMPIC_NO_AUTO_UPDATE: '1' };
+            let cozempicAvailable = false;
+            try {
+                if (isWin) {
+                    (0, child_process_1.execSync)('cozempic --version', { stdio: 'pipe', cwd: workspaceRoot, env: cozempicEnv });
+                }
+                else {
+                    const shell = process.env.SHELL || 'bash';
+                    (0, child_process_1.execSync)(`${shell} -lc "cozempic --version"`, { stdio: 'pipe', cwd: workspaceRoot, env: cozempicEnv });
+                }
+                cozempicAvailable = true;
+            }
+            catch { /* not installed — skip */ }
+            if (!cozempicAvailable) {
+                return;
+            }
+            log('🧹 Running cozempic init for this project…');
+            if (isWin) {
+                (0, child_process_1.execSync)('cozempic init', { stdio: 'pipe', cwd: workspaceRoot, env: cozempicEnv });
+            }
+            else {
+                const shell = process.env.SHELL || 'bash';
+                (0, child_process_1.execSync)(`${shell} -lc "cozempic init"`, { stdio: 'pipe', cwd: workspaceRoot, env: cozempicEnv });
+            }
+            log('🧹 cozempic init complete — guard daemon and pruning hooks wired');
+        }
+        catch (err) {
+            // Non-fatal — cozempic is optional.
+            const msg = err instanceof Error ? err.message : String(err);
+            log(`⚠️ cozempic init failed (non-fatal): ${msg}`);
+        }
+    }
+    _stopPollers() {
+        for (const id of this._pollerIntervals) {
+            clearInterval(id);
+        }
+        this._pollerIntervals = [];
+        // Tear down any persistent WebSocket connection
+        if (this._webhookPoller) {
+            this._webhookPoller.destroy();
+        }
+    }
+    async _runLoop(todoPath, settings) {
+        let allTasksDoneNotified = false;
+        // Reset any [~] in-progress tasks left over from a previous run
+        if (settings.autoResetPendingTasks) {
+            await todoWriteManager_1.todoWriter.resetAllInProgress(todoPath);
+            this._cb?.log('Auto-reset in-progress tasks to [ ]');
+        }
+        while (this._state === 'running') {
+            // --- Restore main provider after fallback period ends ---
+            if (this._mainProviderBeforeFallback && this._mainProviderResumeAt &&
+                Date.now() >= this._mainProviderResumeAt.getTime()) {
+                const main = this._mainProviderBeforeFallback;
+                this._mainProviderBeforeFallback = null;
+                this._mainProviderResumeAt = undefined;
+                this._resumeAt = undefined;
+                this._cb?.log(`↩ Rate limit period ended — switching back to ${main}`);
+                this._notifyDiscord(`↩ Rate limit period ended — switching back to **${main}**`);
+                this._cb?.setActiveProvider?.(main);
+            }
+            const tasks = (0, todo_1.parseTodo)(todoPath);
+            let task = (0, todo_1.pickNextTask)(tasks); // first [ ] task
+            // Helper: is the CLI process still running? (exit file absent or empty)
+            // On the very first dispatch (_iterations === 0) no process has been launched yet,
+            // so always return false regardless of file state.
+            const provider = this._cb?.getActiveProvider();
+            const cliIsRunning = (() => {
+                if (this._iterations === 0) {
+                    return false;
+                } // nothing launched yet
+                if (!this._workspaceRoot || !provider || !providers_1.PROVIDERS[provider]?.isCli) {
+                    return false;
+                }
+                // claude-tui: the exit file is per-message and gets a sentinel when the
+                // turn takes >30 s to finish.  Instead, use the in-flight turn flag which
+                // stays true for the entire duration of the async, including after
+                // _waitForTaskCompletion resolves but before the turn emits 'result'.
+                if (provider === 'claude-tui') {
+                    return (0, claudeTuiProvider_1.isClaudeTuiBusy)(this._workspaceRoot);
+                }
+                if (provider === 'copilot-sdk') {
+                    return (0, copilotSdkProvider_1.isCopilotSdkBusy)(this._workspaceRoot);
+                }
+                if (provider === 'opencode-sdk') {
+                    return (0, opencodeSdkProvider_1.isOpencodeSdkBusy)(this._workspaceRoot);
+                }
+                // opencode-cli may run on a remote machine (not launched by this extension).
+                // The JSONL hooks file is the authoritative source of truth: if the last
+                // event is a terminal Stop/StopFailure/SessionEnd (or the file is stale),
+                // treat the process as NOT running — regardless of the exit file.
+                // This prevents the exit-file `catch { return true }` fallback from
+                // incorrectly reporting "still running" when the file simply doesn't exist
+                // (remote session never wrote one), causing [~] tasks to be stuck forever.
+                if (provider === 'opencode-cli') {
+                    // If the exit file from the last dispatch is non-empty, the process has
+                    // definitely exited — don't block waiting for the hooks-file staleness
+                    // window. The hooks Stop event may lag behind the bash echo due to async
+                    // I/O ordering inside the opencode process, causing a race where
+                    // isOpenCodeCliActive() returns true even after the process has exited.
+                    // Checking the exit file first avoids a ~90 s stall between tasks.
+                    try {
+                        const xfContent = fs.readFileSync((0, sessionState_1.exitFilePath)(this._workspaceRoot, provider), 'utf8').trim();
+                        if (xfContent !== '') {
+                            return false;
+                        } // process wrote exit code → done
+                    }
+                    catch { /* no exit file yet — fall through to hooks check */ }
+                    const ocSid = (0, sessionState_1.getSessionId)(this._workspaceRoot, 'opencode-cli');
+                    // 5-minute staleness window (was 90 s). The exit-file check above is the
+                    // authoritative "done" signal for locally-launched runs, so this only
+                    // bridges gaps DURING an active run — e.g. a long LLM generation phase
+                    // between tool.execute events. A 90 s window flipped the agent to IDLE
+                    // mid-run (and tripped the premature-completion watchdog) whenever a
+                    // single turn ran longer than that without emitting an intermediate hook.
+                    return (0, openCodeHooksManager_1.isOpenCodeCliActive)(this._workspaceRoot, 300_000, ocSid);
+                }
+                try {
+                    const content = fs.readFileSync((0, sessionState_1.exitFilePath)(this._workspaceRoot, provider), 'utf8').trim();
+                    return content === ''; // empty = process still running (exit code not yet written)
+                }
+                catch {
+                    return true;
+                } // file absent = still running
+            })();
+            // If no [ ] task but CLI is still running and there's a [~] task in flight,
+            // treat that [~] task as the current one and wait — don't interrupt the process.
+            let watchingInProgress = false;
+            if (!task && cliIsRunning) {
+                const inProgress = tasks.find(t => t.status === 'in-progress');
+                if (inProgress) {
+                    task = inProgress;
+                    watchingInProgress = true;
+                    this._cb?.log(`⏳ CLI running, watching in-progress: ${discordLabel(task.text)}`);
+                }
+            }
+            if (!task) {
+                const remaining = (0, todo_1.countRemaining)(tasks);
+                if (remaining === 0) {
+                    if (!allTasksDoneNotified) {
+                        allTasksDoneNotified = true;
+                        this._idleNotified = true;
+                        this._cb?.log('All tasks completed ✓ — polling for new tasks…');
+                        this._notifyWebhook('all_tasks_done', {
+                            workDir: this._workspaceRoot,
+                            gitRepo: this._gitRepo,
+                            gitBranch: this._gitBranch,
+                        });
+                        // Explicit idle state — server flips badge to 'idle' on this signal.
+                        this._notifyWebhook('agent_idle', {
+                            workDir: this._workspaceRoot,
+                            gitRepo: this._gitRepo,
+                            gitBranch: this._gitBranch,
+                        });
+                        this._notifyDiscord('✅ All tasks done — waiting for more…');
+                        // Notify once-mode callers (e.g. `autodev start --once`) so they can
+                        // stop instead of idle-polling forever.
+                        this._cb?.onAllTasksDone?.();
+                    }
+                }
+                else {
+                    // There are uncompleted tasks but none are pending (e.g. all [~] in-progress).
+                    // If the CLI isn't running, those [~] tasks are stranded — the AI
+                    // marked them in-progress but never came back to finish them. Reset
+                    // them to [ ] so the next iteration picks them up instead of idling
+                    // forever.
+                    //
+                    // Exception: if opencode-cli exited cleanly (Stop event present), the
+                    // [~] task was intentionally left in-progress while waiting for an
+                    // external response (e.g. waiting for an email from another agent).
+                    // In that case we must NOT reset — just wait; the email/webhook
+                    // pollers will add new [ ] tasks when the response arrives, which
+                    // will trigger a fresh opencode dispatch that also resolves the [~].
+                    if (!cliIsRunning) {
+                        const cleanExit = provider === 'opencode-cli' &&
+                            (0, openCodeHooksManager_1.openCodeExitedCleanly)(this._workspaceRoot ?? '', (0, sessionState_1.getSessionId)(this._workspaceRoot ?? '', 'opencode-cli'));
+                        if (cleanExit) {
+                            this._cb?.log(`⏳ opencode-cli exited cleanly with [~] task — waiting for external response…`);
+                        }
+                        else {
+                            const stranded = tasks.filter(t => t.status === 'in-progress');
+                            for (const t of stranded) {
+                                // Auto-mark as [x] done rather than resetting to [ ].
+                                // Resetting to [ ] causes an infinite loop: the agent picks it
+                                // up, marks [~] again, exits, and we end up here forever.
+                                // If the CLI exited leaving a [~] task it means the agent
+                                // already worked on it — treat it as done.
+                                await todoWriteManager_1.todoWriter.markDone(todoPath, t).catch(() => { });
+                            }
+                            if (stranded.length > 0) {
+                                this._cb?.log(`✅ Auto-marked ${stranded.length} stranded [~] task(s) as done — CLI exited without completing them`);
+                                continue; // re-pick immediately
+                            }
+                        }
+                    }
+                    this._cb?.log(`No pending tasks — waiting ${settings.loopInterval}s…`);
+                }
+                // Clear any stale current-task label and refresh the sidebar so the
+                // counter reflects the just-finalised TODO.md (otherwise it can sit on
+                // the pre-final-cycle "N left" until something else triggers a push).
+                this._currentTask = undefined;
+                this._setState('running');
+                // Keep polling forever — never stop automatically.
+                // _sleepOrWake() resolves early if a poller appends a task mid-sleep.
+                await this._sleepOrWake(settings.loopInterval * 1000);
+                continue;
+            }
+            // A task is available — reset the all-done flag
+            allTasksDoneNotified = false;
+            if (!watchingInProgress) {
+                this._iterations++;
+                // Track how many times we've dispatched this specific task.
+                // If the agent hasn't marked it done after 3 attempts, force-mark it
+                // ourselves and move on so the queue doesn't get stuck.
+                const taskKey = task.id ?? task.text;
+                const attempts = (this._taskAttempts.get(taskKey) ?? 0) + 1;
+                this._taskAttempts.set(taskKey, attempts);
+                const maxAttempts = settings.maxTaskAttempts ?? 3;
+                if (attempts > maxAttempts) {
+                    this._taskAttempts.delete(taskKey);
+                    this._cb?.log(`⚠️ Task not marked done after ${maxAttempts} attempt(s) — force-marking complete: ${task.text}`);
+                    this._notifyDiscord(`⚠️ Task force-marked done after ${maxAttempts} failed attempt(s):\n${task.text}`);
+                    await todoWriteManager_1.todoWriter.markDone(todoPath, task).catch(() => { });
+                    this._completedCount++;
+                    continue;
+                }
+                if (attempts > 1) {
+                    this._cb?.log(`🔍 Retrying task (attempt ${attempts}/${maxAttempts}): ${task.text}`);
+                }
+            }
+            // Detect first pickup of a watchingInProgress task (OpenCode was already
+            // running when this iteration started). We need to send task_start so
+            // Pixel Office flips from idle → active — but only once per task, not on
+            // every polling iteration while the process is still running.
+            const isNewWatchedTask = watchingInProgress && this._currentTask !== task.text;
+            this._currentTask = task.text;
+            this._setState('running', task.text);
+            // Decide whether to include the full profile in this dispatch.
+            // Always include on first task; also re-include every profileEveryNTasks if set.
+            const profileInterval = settings.profileEveryNTasks ?? 0;
+            const includeProfile = this._iterations === 1
+                || (profileInterval > 0 && this._profileSentCounter >= profileInterval);
+            if (includeProfile) {
+                this._profileSentCounter = 0;
+            }
+            this._profileSentCounter++;
+            // Build prompt (needed even when not sending, for messageFile path)
+            const { prompt, messageFile } = (0, prompt_1.buildPrompt)(task, this._workspaceRoot, path.dirname(todoPath), includeProfile);
+            const remaining = (0, todo_1.countRemaining)((0, todo_1.parseTodo)(todoPath));
+            if (!watchingInProgress) {
+                this._cb?.log(`▶ Task [${this._iterations}]: ${task.text}`);
+                this._idleNotified = false;
+                this._notifyWebhook('task_start', {
+                    iteration: this._iterations,
+                    task: { text: task.text },
+                    remaining,
+                    workDir: this._workspaceRoot,
+                    gitRepo: this._gitRepo,
+                    gitBranch: this._gitBranch,
+                });
+                this._notifyDiscord(`▶️ **Task started** (${remaining} remaining):\n${discordLabel(task.text)}`);
+            }
+            else if (isNewWatchedTask) {
+                // CLI was already running when this task was first detected — send task_start
+                // so Pixel Office flips from idle → active (it never saw the original start).
+                this._cb?.log(`⏳ Watching in-progress task: ${task.text}`);
+                this._idleNotified = false;
+                this._notifyWebhook('task_start', {
+                    iteration: this._iterations,
+                    task: { text: task.text },
+                    remaining,
+                    workDir: this._workspaceRoot,
+                    gitRepo: this._gitRepo,
+                    gitBranch: this._gitBranch,
+                });
+            }
+            const taskStartTime = Date.now();
+            // Snapshot the JSONL cursor before sending — we only read bytes written after this
+            const claudeCursor = (0, dispatcher_1.getClaudeSessionCursor)(this._workspaceRoot);
+            try {
+                if (cliIsRunning || watchingInProgress) {
+                    this._cb?.log(`⏳ CLI still running — skipping send, waiting for task completion…`);
+                }
+                else {
+                    // Send to AI — resolves as soon as the prompt is pasted, not when Claude finishes
+                    await this._cb.sendToAi(prompt, task.text, includeProfile, messageFile);
+                }
+                // Wait for the AI to mark the task [x] done in TODO.md
+                await this._waitForTaskCompletion(todoPath, task, claudeCursor);
+                // Wait for the CLI process to fully exit before reading its stdout.
+                // The exit-code file is written only after the shell command completes,
+                // so a non-empty file guarantees the stdout file is fully flushed.
+                const activeProvider = this._cb?.getActiveProvider();
+                if (this._workspaceRoot && activeProvider === 'claude-tui') {
+                    // claude-tui: _waitForTaskCompletion resolves as soon as the task is
+                    // marked [x] in TODO.md, but the persistent async turn may still be
+                    // running (Claude executing further tool calls, marking other tasks [~],
+                    // etc.).  Wait for the busy flag to clear — written at the very end of
+                    // the fire-and-forget async after 'result' fires — so we don't
+                    // prematurely proceed while the client is still mid-turn.
+                    //
+                    // Use activity-based deadline: reset the 10-minute window whenever a
+                    // new streaming event arrives so we never cut off an active turn early.
+                    // Only time out after 10 consecutive minutes of no streaming activity.
+                    const INACTIVITY_MS = 10 * 60_000;
+                    let lastSeenActivity = (0, claudeTuiProvider_1.getClaudeTuiLastActivity)(this._workspaceRoot);
+                    let tuiDeadline = Date.now() + INACTIVITY_MS;
+                    while ((0, claudeTuiProvider_1.isClaudeTuiBusy)(this._workspaceRoot) && Date.now() < tuiDeadline) {
+                        if (this._state !== 'running') {
+                            break;
+                        }
+                        await this._sleepAbortable(500);
+                        // Reset deadline if new activity arrived since last check.
+                        const nowActivity = (0, claudeTuiProvider_1.getClaudeTuiLastActivity)(this._workspaceRoot);
+                        if (nowActivity > lastSeenActivity) {
+                            lastSeenActivity = nowActivity;
+                            tuiDeadline = Date.now() + INACTIVITY_MS;
+                        }
+                    }
+                    if ((0, claudeTuiProvider_1.isClaudeTuiBusy)(this._workspaceRoot)) {
+                        this._cb?.log('⚠️ Claude TUI turn: no streaming activity for 10 minutes — force-clearing busy state and moving on');
+                        (0, claudeTuiProvider_1.forceIdleClaudeTui)(this._workspaceRoot);
+                    }
+                }
+                else if (this._workspaceRoot && activeProvider === 'copilot-sdk') {
+                    const tuiDeadline = Date.now() + 10 * 60_000;
+                    while ((0, copilotSdkProvider_1.isCopilotSdkBusy)(this._workspaceRoot) && Date.now() < tuiDeadline) {
+                        if (this._state !== 'running') {
+                            break;
+                        }
+                        await this._sleepAbortable(500);
+                    }
+                    if ((0, copilotSdkProvider_1.isCopilotSdkBusy)(this._workspaceRoot)) {
+                        this._cb?.log('⚠️ Copilot TUI turn did not complete within 10 minutes — moving on');
+                    }
+                }
+                else if (this._workspaceRoot && activeProvider === 'opencode-sdk') {
+                    // opencode-sdk: same pattern as claude-tui — wait for the in-flight
+                    // fire-and-forget async to fully complete (session.idle received).
+                    // Use activity-based deadline: reset the 30-minute window on each tool
+                    // activity change so long-running tasks are never prematurely cut off.
+                    const INACTIVITY_MS_SDK = 30 * 60_000;
+                    let sdkDeadline = Date.now() + INACTIVITY_MS_SDK;
+                    let lastActivity;
+                    while ((0, opencodeSdkProvider_1.isOpencodeSdkBusy)(this._workspaceRoot) && Date.now() < sdkDeadline) {
+                        if (this._state !== 'running') {
+                            break;
+                        }
+                        // Escape hatch: if hooks-events.jsonl shows server was disposed but
+                        // the SDK async never got the event (e.g. stream closed before we
+                        // could read it), force-clear the busy flag so we don’t wait forever.
+                        const sdkSid = (0, opencodeSdkProvider_1.getOpencodeSdkLatestSessionId)(this._workspaceRoot);
+                        if ((0, openCodeHooksManager_1.openCodeExitedCleanly)(this._workspaceRoot, sdkSid)) {
+                            this._cb?.log('⚠️ OpenCode SDK: server disposed detected via hooks — force-clearing busy state');
+                            (0, opencodeSdkProvider_1.forceIdleOpencodeSdk)(this._workspaceRoot);
+                            break;
+                        }
+                        // Forward tool activity changes to the sidebar; reset inactivity deadline.
+                        const act = (0, opencodeSdkProvider_1.getOpencodeSdkActivity)(this._workspaceRoot);
+                        if (act !== lastActivity) {
+                            lastActivity = act;
+                            this._cb?.onActivityChange?.(act);
+                            sdkDeadline = Date.now() + INACTIVITY_MS_SDK;
+                        }
+                        await this._sleepAbortable(500);
+                    }
+                    if (lastActivity !== undefined) {
+                        this._cb?.onActivityChange?.(undefined);
+                    }
+                    if ((0, opencodeSdkProvider_1.isOpencodeSdkBusy)(this._workspaceRoot)) {
+                        this._cb?.log('⚠️ OpenCode SDK turn: no activity for 30 minutes — force-clearing busy state and moving on');
+                        (0, opencodeSdkProvider_1.forceIdleOpencodeSdk)(this._workspaceRoot);
+                    }
+                }
+                else if (this._workspaceRoot && activeProvider && providers_1.PROVIDERS[activeProvider]?.isCli) {
+                    const exitFile = (0, sessionState_1.exitFilePath)(this._workspaceRoot, activeProvider);
+                    // Do NOT clear the file here. Each dispatch allocates a fresh
+                    // per-message exit file via newMessageOutput(), so the value we see
+                    // is the one the CLI just wrote. Clearing it would leave it empty
+                    // forever (no CLI is running to re-write it) and the NEXT iteration's
+                    // cliIsRunning probe would then incorrectly conclude "CLI still
+                    // running" — pinning the loop on a task that was never dispatched.
+                    const isReady = () => {
+                        try {
+                            return fs.readFileSync(exitFile, 'utf8').trim().length > 0;
+                        }
+                        catch {
+                            return false;
+                        }
+                    };
+                    if (!isReady()) {
+                        // Poll up to 30 s for the exit file to become non-empty
+                        const deadline = Date.now() + 30_000;
+                        while (Date.now() < deadline) {
+                            await this._sleepAbortable(500);
+                            if (this._state !== 'running') {
+                                break;
+                            }
+                            if (isReady()) {
+                                break;
+                            }
+                        }
+                        // If still empty after the wait, write a sentinel so the next
+                        // iteration's cliIsRunning probe doesn't read an empty file and
+                        // wrongly conclude "CLI still running". The shell may have failed
+                        // to run the trailing `echo $? > exitFile` (terminal killed,
+                        // bundle aborted, etc.) — but the task is done and we're moving on.
+                        if (!isReady()) {
+                            try {
+                                fs.writeFileSync(exitFile, 'unknown\n', 'utf8');
+                            }
+                            catch { /* ignore */ }
+                            this._cb?.log('⚠️ CLI exit file never written — wrote sentinel to unblock next cycle');
+                        }
+                    }
+                }
+                else {
+                    // Non-CLI providers: just wait for OS flush
+                    await this._sleepAbortable(2_000);
+                }
+                // Capture and persist CLI session ID so the next task can resume it
+                if (this._workspaceRoot && activeProvider && providers_1.PROVIDERS[activeProvider]?.isCli) {
+                    if (activeProvider === 'opencode-cli') {
+                        // Prefer the session ID from hooks events (fast, no subprocess);
+                        // fall back to `opencode session list` if hooks haven't fired yet.
+                        // Pass taskStartTime so we ignore stale/foreign hooks events from
+                        // before this dispatch (prevents cross-folder contamination).
+                        const hooksSid = (0, openCodeHooksManager_1.getOpenCodeSessionIdFromHooks)(this._workspaceRoot, taskStartTime);
+                        if (hooksSid) {
+                            (0, sessionState_1.saveSessionId)(this._workspaceRoot, 'opencode-cli', hooksSid);
+                            this._cb?.log(`OpenCode session ID from hooks: ${hooksSid}`);
+                        }
+                        else {
+                            (0, opencodeCliProvider_1.getLatestOpenCodeSessionId)(this._workspaceRoot, msg => this._cb?.log(msg))
+                                .then(id => { if (id && this._workspaceRoot) {
+                                (0, sessionState_1.saveSessionId)(this._workspaceRoot, 'opencode-cli', id);
+                            } })
+                                .catch(() => { });
+                        }
+                    }
+                    else if (activeProvider === 'claude-tui') {
+                        const sid = (0, claudeTuiProvider_1.getClaudeTuiLatestSessionId)(this._workspaceRoot);
+                        if (sid) {
+                            (0, sessionState_1.saveSessionId)(this._workspaceRoot, 'claude-tui', sid);
+                        }
+                    }
+                    else if (activeProvider === 'copilot-sdk') {
+                        const sid = (0, copilotSdkProvider_1.getLatestCopilotSdkSessionId)(this._workspaceRoot);
+                        if (sid) {
+                            (0, sessionState_1.saveSessionId)(this._workspaceRoot, 'copilot-sdk', sid);
+                        }
+                    }
+                    else if (activeProvider === 'opencode-sdk') {
+                        const sid = (0, opencodeSdkProvider_1.getOpencodeSdkLatestSessionId)(this._workspaceRoot);
+                        if (sid) {
+                            (0, sessionState_1.saveSessionId)(this._workspaceRoot, 'opencode-sdk', sid);
+                        }
+                    }
+                    else {
+                        const jsonlFallback = activeProvider === 'claude-cli'
+                            ? (0, dispatcher_1.findLatestClaudeSession)(this._workspaceRoot)
+                            : undefined;
+                        (0, sessionState_1.captureAndSaveSessionId)(this._workspaceRoot, activeProvider, jsonlFallback);
+                        // Apply the configured display name to the now-known claude session
+                        // (the --resume picker label lives in ~/.claude/history.jsonl).
+                        if (activeProvider === 'claude-cli' && jsonlFallback && this._settings?.sessionName) {
+                            (0, dispatcher_1.setClaudeSessionName)(jsonlFallback, this._settings.sessionName, this._workspaceRoot);
+                        }
+                    }
+                    this._cb?.log(`Session ID captured for ${activeProvider}`);
+                }
+                const duration = Math.round((Date.now() - taskStartTime) / 1000);
+                this._completedCount++;
+                this._autoCompactCounter++;
+                this._resetSessionCounter++;
+                this._periodicMgr.increment(this._iterations, this._workspaceRoot);
+                this._compactedTaskLines.delete(task.line); // allow compact again if task re-appears
+                this._taskAttempts.delete(task.id ?? task.text); // task done — reset attempt counter
+                const afterTasks = (0, todo_1.parseTodo)(todoPath);
+                const afterRemaining = (0, todo_1.countRemaining)(afterTasks);
+                const totalKnown = this._iterations + afterRemaining;
+                // Read the AI's output — prefer clean JSONL assistant text (no tool noise),
+                // fall back to the tail of the raw stdout file.
+                let taskOutput = '';
+                if (this._workspaceRoot && (activeProvider === 'claude-cli' || activeProvider === 'claude-tui')) {
+                    // Primary: clean assistant-only text extracted from the JSONL session file.
+                    // Works for both claude-cli and claude-tui — both write the same JSONL format.
+                    // For claude-tui this replaces the noisy partial-chunk Discord stream with
+                    // one clean summary sent at task completion.
+                    taskOutput = (0, dispatcher_2.readClaudeOutputSince)(this._workspaceRoot, claudeCursor);
+                }
+                else if (this._workspaceRoot && activeProvider === 'copilot-sdk') {
+                    // copilot-sdk: read from the per-message stdoutFile (absolute path stored
+                    // at pointer file location in the .autodev directory).
+                    const outFile = (0, sessionState_1.stdoutFilePath)(this._workspaceRoot, 'copilot-sdk');
+                    taskOutput = (0, copilotSdkProvider_1.readCopilotSdkOutputSince)(outFile, 0);
+                }
+                if (!taskOutput && this._workspaceRoot && activeProvider && providers_1.PROVIDERS[activeProvider]?.isCli) {
+                    // Fallback: raw stdout file — take only the last 4 KB to avoid huge payloads.
+                    const outFile = (0, sessionState_1.stdoutFilePath)(this._workspaceRoot, activeProvider);
+                    try {
+                        if (fs.existsSync(outFile)) {
+                            const raw = readOutputFile(outFile);
+                            // Strip ANSI escape codes and take the tail (the meaningful summary is at the end)
+                            const clean = raw.replace(/\x1B\[[0-9;]*[mGKHF]/g, '').replace(/\r/g, '');
+                            taskOutput = clean.length > 4000 ? '…' + clean.slice(-4000) : clean;
+                        }
+                    }
+                    catch { /* ignore */ }
+                }
+                this._cb?.log(`\u2705 Task done: ${task.text}`);
+                this._notifyWebhook('task_done', {
+                    iteration: this._iterations,
+                    task: { text: task.text },
+                    output: taskOutput || undefined,
+                    duration,
+                    workDir: this._workspaceRoot,
+                    gitRepo: this._gitRepo,
+                    gitBranch: this._gitBranch,
+                });
+                const discordOutput = taskOutput
+                    ? `\n\`\`\`\n${taskOutput.slice(0, 1800)}\n\`\`\``
+                    : '';
+                this._notifyDiscord(`\u2705 **Task done** (${afterRemaining} remaining):\n${discordLabel(task.text)}${discordOutput}`);
+                if (afterRemaining > 0) {
+                    this._notifyDiscord(`\ud83d\udcca Progress: ${this._iterations}/${totalKnown}`);
+                    this._notifyWebhook('task_progress', {
+                        iteration: this._iterations,
+                        total: totalKnown,
+                        remaining: afterRemaining,
+                        workDir: this._workspaceRoot,
+                        gitRepo: this._gitRepo,
+                        gitBranch: this._gitBranch,
+                    });
+                }
+                // --- Auto-compact: run /compact every N completed tasks -----------
+                // Skip the legacy autoCompact mechanism when compactEveryNTasks is set —
+                // the new periodic-action system handles it and they must not both fire.
+                const compactInterval = settings.autoCompactInterval ?? 5;
+                if (settings.autoCompact && !(settings.compactEveryNTasks > 0) && this._autoCompactCounter >= compactInterval) {
+                    this._autoCompactCounter = 0;
+                    const acProvider = this._cb?.getActiveProvider() ?? '';
+                    this._cb?.log(`🗜 Auto-compact triggered after ${compactInterval} tasks (provider: ${acProvider})`);
+                    this._notifyDiscord(`🗜 Auto-compact triggered after ${compactInterval} tasks`);
+                    try {
+                        if (acProvider === 'claude-cli') {
+                            let sid = (0, sessionState_1.getSessionId)(this._workspaceRoot, 'claude-cli');
+                            if (!sid) {
+                                sid = (0, dispatcher_1.findLatestClaudeSession)(this._workspaceRoot);
+                            }
+                            if (sid) {
+                                await (0, claudeCliProvider_1.runClaudeCompact)(sid, this._workspaceRoot, msg => this._cb?.log(msg));
+                                this._cb?.log('🗜 Auto-compact complete');
+                            }
+                            else {
+                                this._cb?.log('⚠️ Auto-compact: no Claude session ID found — skipping');
+                            }
+                        }
+                        else if (acProvider === 'claude-tui') {
+                            let sid = (0, sessionState_1.getSessionId)(this._workspaceRoot, 'claude-tui');
+                            if (!sid) {
+                                sid = (0, claudeTuiProvider_1.getClaudeTuiLatestSessionId)(this._workspaceRoot);
+                            }
+                            if (sid) {
+                                await (0, claudeTuiProvider_1.runClaudeTuiCompact)(this._workspaceRoot, sid, msg => this._cb?.log(msg));
+                                this._cb?.log('🗜 Auto-compact complete');
+                            }
+                            else {
+                                this._cb?.log('⚠️ Auto-compact: no Claude TUI session ID found — skipping');
+                            }
+                        }
+                        else if (acProvider === 'copilot-sdk') {
+                            this._cb?.log('ℹ️ Auto-compact not supported for copilot-sdk — skipping');
+                        }
+                        else if (acProvider === 'opencode-cli') {
+                            let sid = (0, sessionState_1.getSessionId)(this._workspaceRoot, 'opencode-cli');
+                            if (!sid) {
+                                sid = await (0, opencodeCliProvider_1.getLatestOpenCodeSessionId)(this._workspaceRoot, msg => this._cb?.log(msg));
+                            }
+                            if (sid) {
+                                await (0, opencodeCliProvider_1.runOpenCodeCompact)(sid, this._workspaceRoot, msg => this._cb?.log(msg));
+                                this._cb?.log('🗜 Auto-compact complete');
+                            }
+                            else {
+                                this._cb?.log('⚠️ Auto-compact: no OpenCode session ID found — skipping');
+                            }
+                        }
+                        else if (acProvider === 'opencode-sdk') {
+                            await (0, opencodeSdkProvider_1.runOpencodeSdkCompact)(this._workspaceRoot, msg => this._cb?.log(msg));
+                            this._cb?.log('🗜 Auto-compact complete (opencode-sdk)');
+                        }
+                    }
+                    catch (compactErr) {
+                        const cm = compactErr instanceof Error ? compactErr.message : String(compactErr);
+                        this._cb?.log(`⚠️ Auto-compact failed (non-fatal): ${cm}`);
+                    }
+                }
+                // --- Session reset: clear session every N completed tasks ---------
+                const resetInterval = settings.resetSessionEveryNTurns ?? 0;
+                if (settings.resumeSession && resetInterval > 0 && this._resetSessionCounter >= resetInterval) {
+                    this._resetSessionCounter = 0;
+                    const rsProvider = this._cb?.getActiveProvider() ?? '';
+                    this._cb?.log(`🔄 Session reset triggered after ${resetInterval} tasks (provider: ${rsProvider})`);
+                    this._notifyDiscord(`🔄 Session reset after ${resetInterval} tasks — summarising and starting fresh`);
+                    // Ask the agent to write a summary before the session is cleared
+                    try {
+                        const summaryMsg = `Before this session ends, please summarise everything accomplished so far into a file called SUMMARY.md in the project root. Include: tasks completed, key decisions made, any issues found, and current project state. Write comprehensively so the next session can continue without context loss. Then stop — do not pick up any new tasks.`;
+                        const summaryFile = (0, messageBuilder_1.writeMessageFile)(this._workspaceRoot, summaryMsg);
+                        await this._cb.sendToAi(summaryMsg, 'session-summary', false, summaryFile);
+                    }
+                    catch (rsErr) {
+                        const rm = rsErr instanceof Error ? rsErr.message : String(rsErr);
+                        this._cb?.log(`⚠️ Session reset summary failed (non-fatal): ${rm}`);
+                    }
+                    // Clear the session ID so the next dispatch starts a fresh session
+                    if (this._workspaceRoot && rsProvider) {
+                        (0, sessionState_1.clearSessionId)(this._workspaceRoot, rsProvider);
+                        this._cb?.log(`🔄 Session ID cleared — next task will start a new session`);
+                    }
+                }
+                // --- Periodic actions: compact / pruneTodo / skill / memory / summary / etc. --
+                for (const action of this._periodicMgr.getDue(settings)) {
+                    this._periodicMgr.markHandled(action.id, this._iterations, this._workspaceRoot);
+                    this._cb?.log(`${action.icon} Periodic action '${action.id}' triggered`);
+                    this._notifyDiscord(`${action.icon} Periodic action: ${action.label}`);
+                    try {
+                        if (action.type === 'compact') {
+                            // Guard: time-based throttle — minimum 2 minutes between compacts
+                            const MIN_COMPACT_INTERVAL_MS = 2 * 60 * 1000; // 2 minutes
+                            const timeSinceLastCompact = Date.now() - this._lastCompactTime;
+                            if (timeSinceLastCompact < MIN_COMPACT_INTERVAL_MS) {
+                                const waitSec = Math.ceil((MIN_COMPACT_INTERVAL_MS - timeSinceLastCompact) / 1000);
+                                this._cb?.log(`⚠️ Auto-compact throttled: wait ${waitSec}s (minimum 2min between compacts)`);
+                            }
+                            else {
+                                const acProvider = this._cb?.getActiveProvider() ?? '';
+                                if (acProvider && this._workspaceRoot) {
+                                    await this.compact(this._workspaceRoot, acProvider);
+                                }
+                                else {
+                                    this._cb?.log(`⚠️ Periodic compact: no active provider`);
+                                }
+                            }
+                        }
+                        else if (action.type === 'pruneTodo') {
+                            if (this._workspaceRoot) {
+                                const pruned = (0, todo_1.pruneTodoToArchive)(todoPath, this._workspaceRoot);
+                                if (pruned > 0) {
+                                    this._cb?.log(`🧹 Pruned ${pruned} completed task(s) from TODO.md → DONE.md`);
+                                    this._notifyDiscord(`🧹 Pruned ${pruned} completed task(s) from TODO.md → DONE.md`);
+                                }
+                                else {
+                                    this._cb?.log(`🧹 Prune TODO: no completed tasks to move`);
+                                }
+                            }
+                        }
+                        else {
+                            const msgFile = (0, messageBuilder_1.writeMessageFile)(this._workspaceRoot, action.prompt);
+                            await this._cb.sendToAi(action.prompt, action.id, false, msgFile);
+                        }
+                    }
+                    catch (paErr) {
+                        const pm = paErr instanceof Error ? paErr.message : String(paErr);
+                        this._cb?.log(`⚠️ Periodic action '${action.id}' failed (non-fatal): ${pm}`);
+                    }
+                }
+            }
+            catch (err) {
+                // --- Rate limit: pause loop, schedule auto-resume -----------------
+                if (err instanceof rateLimit_1.RateLimitError) {
+                    // Two flavours:
+                    //   1. Daily usage limit — message includes "resets 9pm (Europe/Sofia)"
+                    //      → resume 15 min after the parsed reset time.
+                    //   2. Transient server throttle — "API Error: Server is temporarily
+                    //      limiting requests (not your usage limit) · Rate limited"
+                    //      → no reset time given, retry in 5 minutes by default.
+                    const DEFAULT_RETRY_MS = 5 * 60_000;
+                    const resetAt = err.resetAt;
+                    const resumeMs = resetAt ? (resetAt.getTime() - Date.now() + 15 * 60_000) : DEFAULT_RETRY_MS;
+                    const resumeAt = resetAt ?? new Date(Date.now() + DEFAULT_RETRY_MS);
+                    const resumeStr = resumeAt.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+                    const suffix = resetAt ? '+15 min' : 'retry in 5m (no reset time given)';
+                    const rawMsg = err.rawMessage;
+                    const currentProvider = this._cb?.getActiveProvider() ?? 'unknown';
+                    // Fresh settings — check fallback config (user may have changed it after loop start)
+                    const freshSettings = this._workspaceRoot ? (0, settingsLoader_1.loadSettingsForRoot)(this._workspaceRoot) : this._settings;
+                    const fallbackEnabled = freshSettings?.fallbackProviderEnabled ?? false;
+                    const fallbackId = (freshSettings?.fallbackProvider ?? '');
+                    // Use fallback if: enabled, different from current provider, and not already on fallback
+                    if (fallbackEnabled && fallbackId && fallbackId !== currentProvider && !this._mainProviderBeforeFallback) {
+                        this._mainProviderBeforeFallback = currentProvider;
+                        this._mainProviderResumeAt = resumeAt;
+                        this._resumeAt = resumeAt;
+                        this._cb?.log(`⏩ Rate limit on ${currentProvider} — switching to ${fallbackId} until ${resumeStr} (${suffix})`);
+                        this._notifyDiscord(`⏩ **Rate limit on ${currentProvider}** — switching to **${fallbackId}** until ${resumeStr} (${suffix})\n\`\`\`\n${rawMsg}\n\`\`\``);
+                        this._notifyWebhook('rate_limit', {
+                            iteration: this._iterations,
+                            task: { text: task.text },
+                            message: rawMsg,
+                            resumeAt: resumeAt.toISOString(),
+                            provider: currentProvider,
+                            fallbackProvider: fallbackId,
+                            workDir: this._workspaceRoot,
+                            gitRepo: this._gitRepo,
+                            gitBranch: this._gitBranch,
+                        });
+                        // Reset task so the fallback picks it up from scratch
+                        await todoWriteManager_1.todoWriter.resetToTodo(todoPath, task).catch(() => { });
+                        this._cb?.setActiveProvider?.(fallbackId);
+                        continue; // continue loop immediately with fallback provider
+                    }
+                    // No usable fallback — standard pause
+                    this._cb?.log(`⏸ Rate limit hit — ${rawMsg}. Auto-resume at ${resumeStr} (${suffix})`);
+                    this._notifyDiscord(`⏸ **Rate limit hit** — resuming at ${resumeStr} (${suffix})\n\`\`\`\n${rawMsg}\n\`\`\``);
+                    this._notifyWebhook('rate_limit', {
+                        iteration: this._iterations,
+                        task: { text: task.text },
+                        message: rawMsg,
+                        resumeAt: resumeAt.toISOString(),
+                        provider: currentProvider,
+                        workDir: this._workspaceRoot,
+                        gitRepo: this._gitRepo,
+                        gitBranch: this._gitBranch,
+                    });
+                    // Reset task so it gets picked up again after resume
+                    await todoWriteManager_1.todoWriter.resetToTodo(todoPath, task).catch(() => { });
+                    // Block here until resumed (timer or user clicks Retry Now)
+                    this._resumeAt = resumeAt;
+                    await this._pauseLoop(resumeMs);
+                    // After resume, if user stopped while paused, exit the while loop
+                    if (this._state !== 'running') {
+                        break;
+                    }
+                    continue; // pick up the same task at the top of the loop
+                }
+                // --- Thrashing: /compact is failing, Claude recommends /clear -----
+                if (err instanceof ThrashingError) {
+                    const rawMsg = err.rawMessage.slice(0, 300);
+                    const provider = this._cb?.getActiveProvider() ?? '';
+                    this._cb?.log(`🗑 Autocompact thrashing (${provider}) — running /clear to reset session…\n${rawMsg}`);
+                    this._notifyDiscord(`🗑 **Autocompact thrashing** (${provider}) — running \`/clear\` to reset session…\n\`\`\`\n${rawMsg}\n\`\`\``);
+                    if (provider === 'claude-cli') {
+                        let sessionId = (0, sessionState_1.getSessionId)(this._workspaceRoot, 'claude-cli');
+                        if (!sessionId) {
+                            sessionId = (0, dispatcher_1.findLatestClaudeSession)(this._workspaceRoot);
+                        }
+                        if (sessionId) {
+                            try {
+                                await (0, claudeCliProvider_1.runClaudeClear)(sessionId, this._workspaceRoot, msg => this._cb?.log(msg));
+                                (0, sessionState_1.clearSessionId)(this._workspaceRoot, 'claude-cli');
+                                this._cb?.log('🗑 /clear complete — session reset, retrying task');
+                                this._notifyDiscord('🗑 `/clear` complete — session reset, retrying task');
+                            }
+                            catch (e) {
+                                this._cb?.log(`⚠️ /clear failed: ${e instanceof Error ? e.message : String(e)} — retrying anyway`);
+                            }
+                        }
+                        else {
+                            this._cb?.log('⚠️ No Claude session ID found for /clear — retrying anyway');
+                        }
+                    }
+                    else if (provider === 'claude-tui') {
+                        let sessionId = (0, sessionState_1.getSessionId)(this._workspaceRoot, 'claude-tui');
+                        if (!sessionId) {
+                            sessionId = (0, claudeTuiProvider_1.getClaudeTuiLatestSessionId)(this._workspaceRoot);
+                        }
+                        if (sessionId) {
+                            try {
+                                await (0, claudeTuiProvider_1.runClaudeTuiClear)(this._workspaceRoot, sessionId, msg => this._cb?.log(msg));
+                                (0, sessionState_1.clearSessionId)(this._workspaceRoot, 'claude-tui');
+                                this._cb?.log('🗑 /clear (TUI) complete — session reset, retrying task');
+                                this._notifyDiscord('🗑 `/clear` (TUI) complete — session reset, retrying task');
+                            }
+                            catch (e) {
+                                this._cb?.log(`⚠️ /clear (TUI) failed: ${e instanceof Error ? e.message : String(e)} — retrying anyway`);
+                            }
+                        }
+                        else {
+                            this._cb?.log('⚠️ No Claude TUI session ID found for /clear — retrying anyway');
+                        }
+                    }
+                    this._compactedTaskLines.delete(task.line); // allow compact to run again next time
+                    await todoWriteManager_1.todoWriter.resetToTodo(todoPath, task).catch(() => { });
+                    continue;
+                }
+                // --- Context length (OpenCode + Claude): run /compact once then retry
+                if (err instanceof ContextLengthError && !this._compactedTaskLines.has(task.line)) {
+                    this._compactedTaskLines.add(task.line);
+                    const rawMsg = err.rawMessage.slice(0, 300);
+                    const provider = this._cb?.getActiveProvider() ?? '';
+                    this._cb?.log(`🗜 Context length exceeded (${provider}) — running /compact: ${rawMsg}`);
+                    this._notifyDiscord(`🗜 **Context length exceeded** (${provider}) — running \`/compact\`…\n\`\`\`\n${rawMsg}\n\`\`\``);
+                    if (provider === 'claude-cli') {
+                        // Resolve a Claude session ID — prefer the saved one, else scan
+                        // the .claude/projects jsonl folder for the most recent.
+                        let sessionId = (0, sessionState_1.getSessionId)(this._workspaceRoot, 'claude-cli');
+                        if (!sessionId) {
+                            sessionId = (0, dispatcher_1.findLatestClaudeSession)(this._workspaceRoot);
+                        }
+                        if (sessionId) {
+                            try {
+                                await (0, claudeCliProvider_1.runClaudeCompact)(sessionId, this._workspaceRoot, msg => this._cb?.log(msg));
+                                this._cb?.log('🗜 Claude compact complete — retrying task');
+                                this._notifyDiscord('🗜 Claude compact complete — retrying task');
+                            }
+                            catch (compactErr) {
+                                const compactMsg = compactErr instanceof Error ? compactErr.message : String(compactErr);
+                                this._cb?.log(`⚠️ Claude compact failed: ${compactMsg} — retrying anyway`);
+                            }
+                        }
+                        else {
+                            this._cb?.log('⚠️ No Claude session ID found for compact — retrying task without compact');
+                        }
+                    }
+                    else if (provider === 'claude-tui') {
+                        let sessionId = (0, sessionState_1.getSessionId)(this._workspaceRoot, 'claude-tui');
+                        if (!sessionId) {
+                            sessionId = (0, claudeTuiProvider_1.getClaudeTuiLatestSessionId)(this._workspaceRoot);
+                        }
+                        if (sessionId) {
+                            try {
+                                await (0, claudeTuiProvider_1.runClaudeTuiCompact)(this._workspaceRoot, sessionId, msg => this._cb?.log(msg));
+                                this._cb?.log('🗜 Claude TUI compact complete — retrying task');
+                                this._notifyDiscord('🗜 Claude TUI compact complete — retrying task');
+                            }
+                            catch (compactErr) {
+                                const compactMsg = compactErr instanceof Error ? compactErr.message : String(compactErr);
+                                this._cb?.log(`⚠️ Claude TUI compact failed: ${compactMsg} — retrying anyway`);
+                            }
+                        }
+                        else {
+                            this._cb?.log('⚠️ No Claude TUI session ID found for compact — retrying task without compact');
+                        }
+                    }
+                    else {
+                        // OpenCode (existing behaviour)
+                        let sessionId = (0, sessionState_1.getSessionId)(this._workspaceRoot, 'opencode-cli');
+                        if (!sessionId) {
+                            sessionId = await (0, opencodeCliProvider_1.getLatestOpenCodeSessionId)(this._workspaceRoot, msg => this._cb?.log(msg));
+                        }
+                        if (sessionId) {
+                            try {
+                                await (0, opencodeCliProvider_1.runOpenCodeCompact)(sessionId, this._workspaceRoot, msg => this._cb?.log(msg));
+                                this._cb?.log('🗜 Compact complete — retrying task');
+                                this._notifyDiscord('🗜 Compact complete — retrying task');
+                            }
+                            catch (compactErr) {
+                                const compactMsg = compactErr instanceof Error ? compactErr.message : String(compactErr);
+                                this._cb?.log(`⚠️ Compact failed: ${compactMsg} — retrying anyway`);
+                            }
+                        }
+                        else {
+                            this._cb?.log('⚠️ No OpenCode session ID found for compact — retrying task without compact');
+                        }
+                    }
+                    await todoWriteManager_1.todoWriter.resetToTodo(todoPath, task).catch(() => { });
+                    continue;
+                }
+                // --- Context length already compacted or plan limit: pause + retry button
+                if (err instanceof ContextLengthError) {
+                    const rawMsg = err.rawMessage.slice(0, 300);
+                    const provider = this._cb?.getActiveProvider() ?? '';
+                    this._cb?.log(`⏸ Context length exceeded (${provider}) and already compacted — pausing. Click Retry to resume.\n${rawMsg}`);
+                    this._notifyDiscord(`⏸ **Context length exceeded** (${provider}) — already compacted or plan limit hit. Pausing…\n\`\`\`\n${rawMsg}\n\`\`\``);
+                    this._notifyWebhook('rate_limit', {
+                        iteration: this._iterations,
+                        task: { text: task.text },
+                        message: rawMsg,
+                        resumeAt: new Date(Date.now() + 60 * 60_000).toISOString(),
+                        provider,
+                        workDir: this._workspaceRoot,
+                        gitRepo: this._gitRepo,
+                        gitBranch: this._gitBranch,
+                    });
+                    await todoWriteManager_1.todoWriter.resetToTodo(todoPath, task).catch(() => { });
+                    // No auto-resume time — user must click Retry manually
+                    this._resumeAt = undefined;
+                    await this._pauseLoop(); // pause indefinitely
+                    if (this._state !== 'running') {
+                        break;
+                    }
+                    continue;
+                }
+                // --- Normal task failure ------------------------------------------
+                const duration = Math.round((Date.now() - taskStartTime) / 1000);
+                this._failedCount++;
+                const msg = err instanceof Error ? err.message : String(err);
+                this._cb?.log(`❌ Task failed: ${task.text} — ${msg}`);
+                this._notifyWebhook('task_fail', {
+                    iteration: this._iterations,
+                    task: { text: task.text },
+                    duration,
+                    error: msg,
+                    workDir: this._workspaceRoot,
+                    gitRepo: this._gitRepo,
+                    gitBranch: this._gitBranch,
+                });
+                this._notifyDiscord(`❌ **Task failed:**\n${discordLabel(task.text)}\n\`${msg}\``);
+                const afterRemainingFail = (0, todo_1.countRemaining)((0, todo_1.parseTodo)(todoPath));
+                if (afterRemainingFail > 0) {
+                    const totalKnownFail = this._iterations + afterRemainingFail;
+                    this._notifyDiscord(`\ud83d\udcca Progress: ${this._iterations}/${totalKnownFail}`);
+                    this._notifyWebhook('task_progress', {
+                        iteration: this._iterations,
+                        total: totalKnownFail,
+                        remaining: afterRemainingFail,
+                        workDir: this._workspaceRoot,
+                        gitRepo: this._gitRepo,
+                        gitBranch: this._gitBranch,
+                    });
+                } // Continue to next task rather than stopping the loop
+            }
+            this._currentTask = undefined;
+        }
+    }
+    /**
+     * Suspend the loop in 'paused' state.
+     * Resolves when retry() is called or (optionally) the timer fires.
+     * MUST be called only from _runLoop.
+     */
+    _pauseLoop(resumeAfterMs) {
+        this._setState('paused');
+        return new Promise(resolve => {
+            this._resumeResolve = resolve;
+            if (resumeAfterMs !== undefined && resumeAfterMs > 0) {
+                this._retryScheduler.schedule(resumeAfterMs, () => {
+                    this._cb?.log('Rate limit timer expired — resuming loop automatically');
+                    this.retry();
+                });
+            }
+        });
+    }
+    /** Interrupt the idle no-task sleep — called by pollers when they append a task. */
+    _wakeIdleSleep() {
+        const w = this._idleSleepWake;
+        this._idleSleepWake = null;
+        w?.();
+    }
+    /** sleep() that resolves early when _wakeIdleSleep() is called. */
+    _sleepOrWake(ms) {
+        return new Promise(resolve => {
+            const id = setTimeout(resolve, ms);
+            this._idleSleepWake = () => { clearTimeout(id); resolve(); };
+        });
+    }
+    /** sleep() that resolves immediately when the task-completion abort fires. */
+    _sleepAbortable(ms) {
+        return new Promise(resolve => {
+            const id = setTimeout(resolve, ms);
+            const prev = this._taskCompletionAbort;
+            this._taskCompletionAbort = () => { clearTimeout(id); resolve(); prev?.(); };
+        });
+    }
+    /** Return when the task text appears with [x] status in the TODO.md file. */
+    _waitForTaskCompletion(todoPath, task, claudeCursor = 0) {
+        const isClaudeCli = this._cb?.getActiveProvider() === 'claude-cli';
+        const isClaudeTui = this._cb?.getActiveProvider() === 'claude-tui';
+        const iscopilotSdkProvider = this._cb?.getActiveProvider() === 'copilot-sdk';
+        const isOpenCodeCli = this._cb?.getActiveProvider() === 'opencode-cli';
+        const isOpencodeSdk = this._cb?.getActiveProvider() === 'opencode-sdk';
+        return new Promise((resolve, reject) => {
+            if (this._state !== 'running') {
+                resolve();
+                return;
+            }
+            const settings = this._settings;
+            const timeoutMs = (settings.taskTimeoutMinutes ?? 30) * 60 * 1_000;
+            const taskStartTime = Date.now();
+            // Timeout is based on TODO.md inactivity, not total process runtime.
+            // Every time TODO.md changes (any [~]/[x] write by the AI) this resets.
+            // Only fires if TODO.md has been untouched for the full timeout duration.
+            let lastTodoChangeTime = Date.now();
+            // Shared with the JSONL inactivity poller — reset here so TODO.md changes
+            // prevent the "Still working" reminder from firing unnecessarily.
+            let lastActivityTime = Date.now();
+            const found = () => {
+                const updated = (0, todo_1.parseTodo)(todoPath);
+                // 1. Prefer task ID (globally unique — set by appendTask on every new task).
+                // 2. Line number with text verification (fast; guards against line-shift from
+                //    new tasks inserted above this one pointing to the wrong entry).
+                // 3. Text-only fallback when there is no ID and the line has shifted.
+                const byId = task.id ? updated.find(t => t.id === task.id) : undefined;
+                const byLine = updated.find(t => t.line === task.line);
+                const byLineVerified = (byLine && byLine.text === task.text) ? byLine : undefined;
+                const byText = updated.find(t => t.text === task.text);
+                const match = byId ?? byLineVerified ?? byText;
+                // If the current task can no longer be found but there are no pending
+                // tasks left at all, treat it as completed. This avoids re-prompt loops
+                // where the CLI exits cleanly after finishing work but TODO matching was
+                // invalidated by line shifts or post-processing.
+                if (!match) {
+                    return (0, todo_1.countRemaining)(updated) === 0 ? true : undefined;
+                }
+                return match.status === 'done';
+            };
+            // Track "task not found" state to detect line-number shifts from new tasks.
+            // If task becomes unfindable, give it 3 seconds grace before treating as lost.
+            let taskLostAt = null;
+            // Check immediately (AI might have already edited the file)
+            if (found() === true) {
+                resolve();
+                return;
+            }
+            let poller;
+            let stdoutWatcherRef;
+            let exitWatcherRef;
+            let todoWatcher;
+            const endTurnTimers = [];
+            // Set to true by cleanup() so stale onCliExit() calls that are still
+            // sleeping don't send a spurious reminder after the task resolved.
+            let cancelled = false;
+            const cleanup = () => {
+                cancelled = true;
+                this._taskCompletionAbort = null;
+                clearInterval(poller);
+                for (const t of endTurnTimers) {
+                    clearTimeout(t);
+                }
+                endTurnTimers.length = 0;
+                todoWatcher?.dispose();
+                stdoutWatcherRef?.dispose();
+                stdoutWatcherRef = undefined;
+                exitWatcherRef?.dispose();
+                exitWatcherRef = undefined;
+                this._cb?.onActivityChange?.(undefined);
+            };
+            const check = () => {
+                if (this._state !== 'running') {
+                    cleanup();
+                    resolve();
+                    return;
+                }
+                const state = found(); // returns true (done), false (undefined), or undefined (not found)
+                if (state === true) {
+                    // Task explicitly marked [x] done
+                    lastTodoChangeTime = Date.now(); // reset inactivity clock
+                    lastActivityTime = Date.now();
+                    cleanup();
+                    resolve();
+                    return;
+                }
+                if (state === false) {
+                    // Task marked [~] in-progress or other non-done status
+                    lastTodoChangeTime = Date.now();
+                    lastActivityTime = Date.now();
+                    taskLostAt = null; // task found again, reset lost timer
+                    return;
+                }
+                // state === undefined: task not found in TODO.md
+                if (taskLostAt === null) {
+                    // First time seeing task as lost — start the grace period
+                    taskLostAt = Date.now();
+                    this._cb?.log(`⚠️ Task became unfindable in TODO.md (line shift from new tasks?) — giving 3s grace period…`);
+                    return;
+                }
+                // Check if grace period expired
+                if (Date.now() - taskLostAt > 3_000) {
+                    this._cb?.log(`⚠️ Task still unfindable after 3s grace period — treating as lost and resolving`);
+                    cleanup();
+                    resolve();
+                    return;
+                }
+            };
+            todoWatcher = this._cb.fileWatcher.watch(todoPath, check);
+            this._taskWatcher = todoWatcher;
+            // Per-provider stdout capture file (only used for CLI providers)
+            const activeProvider = this._cb?.getActiveProvider() ?? 'unknown';
+            // Re-computed dynamically — sendToAi() (reminder path) rotates to a fresh
+            // per-message file and updates the .latest pointer.  Using a let + refresh
+            // in the interval ensures checkStdout() always reads the current file.
+            let resolvedStdoutFile = this._workspaceRoot
+                ? (0, sessionState_1.stdoutFilePath)(this._workspaceRoot, activeProvider)
+                : null;
+            // Helper: read stdout capture file handling both UTF-8 and UTF-16 LE (PowerShell default)
+            const readStdoutFile = () => {
+                if (!resolvedStdoutFile) {
+                    return '';
+                }
+                try {
+                    const buf = fs.readFileSync(resolvedStdoutFile);
+                    // Detect UTF-16 LE BOM (0xFF 0xFE)
+                    if (buf.length >= 2 && buf[0] === 0xFF && buf[1] === 0xFE) {
+                        return buf.toString('utf16le');
+                    }
+                    return buf.toString('utf8');
+                }
+                catch {
+                    return '';
+                }
+            };
+            // Track how many characters of the stdout file we've already forwarded
+            let lastStdoutLen = 0;
+            // Check stdout file: forward any new content to Discord/webhook, detect rate limit / context errors
+            const checkStdout = () => {
+                if (!isClaudeCli && !isClaudeTui && !iscopilotSdkProvider && !isOpenCodeCli) {
+                    return;
+                } // only CLI providers tee stdout
+                const content = readStdoutFile();
+                // Forward new output lines to Discord / webhook.
+                // claude-cli: stream partial chunks so the operator can see live progress.
+                // claude-tui: do NOT stream — the TUI writes noisy partial chunks; we
+                //   send one clean summary from the JSONL session file at task completion
+                //   (same approach as opencode).
+                if (isClaudeCli && content.length > lastStdoutLen) {
+                    const newText = content.slice(lastStdoutLen).trim();
+                    lastStdoutLen = content.length;
+                    if (newText) {
+                        this._notifyDiscord(`🖥 **Claude output:**\n\`\`\`\n${newText}\n\`\`\``);
+                        this._notifyWebhook('claude_output', {
+                            iteration: this._iterations,
+                            task: { text: task.text },
+                            output: newText,
+                            workDir: this._workspaceRoot,
+                            gitRepo: this._gitRepo,
+                            gitBranch: this._gitBranch,
+                        });
+                    }
+                }
+                else {
+                    lastStdoutLen = content.length; // keep cursor up to date
+                }
+                // Rate limit detection (Claude CLI + TUI)
+                if (isClaudeCli || isClaudeTui) {
+                    const rlErr = rateLimit_1.RateLimitDetector.detect(content);
+                    if (rlErr) {
+                        cleanup();
+                        reject(rlErr);
+                        return;
+                    }
+                }
+                // Context length error detection (OpenCode)
+                if (isOpenCodeCli) {
+                    const lc = content.toLowerCase();
+                    if (lc.includes('maximum context length') || lc.includes('prompt is too long')) {
+                        cleanup();
+                        reject(new ContextLengthError(content.trim()));
+                        return;
+                    }
+                }
+                // Context length error detection (Claude). Patterns observed:
+                //   "prompt is too long: 1018289 tokens > 1000000 maximum"
+                //   "Prompt is too long" (last_assistant_message in StopFailure hook)
+                //   "context_length_exceeded"
+                //   "Autocompact is thrashing" (context refills immediately after compact)
+                if (isClaudeCli) {
+                    const lc = content.toLowerCase();
+                    if (lc.includes('autocompact is thrashing')) {
+                        cleanup();
+                        reject(new ThrashingError(content.trim()));
+                        return;
+                    }
+                    if (lc.includes('prompt is too long')
+                        || lc.includes('context_length_exceeded')
+                        || /tokens?\s*>\s*\d+\s*maximum/.test(lc)) {
+                        cleanup();
+                        reject(new ContextLengthError(content.trim()));
+                        return;
+                    }
+                }
+                // Context length detection for claude-tui (same patterns)
+                if (isClaudeTui) {
+                    const lc = content.toLowerCase();
+                    if (lc.includes('autocompact is thrashing')) {
+                        cleanup();
+                        reject(new ThrashingError(content.trim()));
+                        return;
+                    }
+                    if (lc.includes('prompt is too long')
+                        || lc.includes('context_length_exceeded')
+                        || /tokens?\s*>\s*\d+\s*maximum/.test(lc)) {
+                        cleanup();
+                        reject(new ContextLengthError(content.trim()));
+                        return;
+                    }
+                }
+            };
+            // Register abort hook so stop() can resolve this immediately
+            this._taskCompletionAbort = () => { cleanup(); resolve(); };
+            // Watch the per-provider stdout capture file for instant rate-limit detection.
+            // Use the actual per-message file, not the legacy provider-level path, so the
+            // watcher fires on the file the current process is writing to.
+            const attachStdoutWatcher = (filePath) => {
+                stdoutWatcherRef?.dispose();
+                stdoutWatcherRef = filePath
+                    ? this._cb.fileWatcher.watch(filePath, checkStdout)
+                    : undefined;
+            };
+            attachStdoutWatcher(resolvedStdoutFile);
+            // Watch the exit file — written by withExitFile() in dispatcher.ts when the CLI
+            // process finishes. CliExitHandler owns the decision tree of what to do.
+            const isTaskDone = () => found() === true;
+            const exitHandler = this._workspaceRoot
+                ? new cliExit_1.CliExitHandler(this._workspaceRoot, todoPath, task, taskStartTime, isTaskDone)
+                : null;
+            const onCliExit = async () => {
+                if (this._state !== 'running') {
+                    return;
+                }
+                // Give TODO.md enough time to be fully flushed and for any final Claude
+                // writes (session ID capture etc.) to settle before we declare it undone.
+                await sleep(3_000);
+                // A parallel path (todoWatcher / poller check()) may have already
+                // resolved the promise while we were sleeping.  Don't send a spurious
+                // reminder to the next task's session.
+                if (cancelled) {
+                    return;
+                }
+                // Fast-path: if the stdout capture file already contains a rate-limit
+                // or context-length phrase at exit time, raise immediately.
+                const exitStdout = readStdoutFile();
+                if (isClaudeCli) {
+                    const rlFromStdout = rateLimit_1.RateLimitDetector.detect(exitStdout);
+                    if (rlFromStdout) {
+                        cleanup();
+                        reject(rlFromStdout);
+                        return;
+                    }
+                }
+                if (isOpenCodeCli) {
+                    const lc = exitStdout.toLowerCase();
+                    if (lc.includes('maximum context length') || lc.includes('prompt is too long')) {
+                        cleanup();
+                        reject(new ContextLengthError(exitStdout.trim()));
+                        return;
+                    }
+                }
+                const decision = exitHandler?.decide() ?? { kind: 'remind' };
+                if (decision.kind === 'done') {
+                    return;
+                }
+                if (decision.kind === 'deferred') {
+                    this._cb?.log(`↩️ CLI exited with task [~] deferred — moving to next pending task: ${discordLabel(task.text)}`);
+                    cleanup();
+                    resolve();
+                    return;
+                }
+                if (decision.kind === 'rate_limit') {
+                    cleanup();
+                    reject(decision.error);
+                    return;
+                }
+                if (decision.kind === 'give_up') {
+                    this._cb?.log(`↩️ CLI exited again without marking task done — auto-marking [x] and moving on: ${discordLabel(task.text)}`);
+                    // Auto-mark the task done so the loop doesn't re-pick the same
+                    // [ ] task on the next iteration, causing an infinite loop.
+                    await todoWriteManager_1.todoWriter.markDone(todoPath, task).catch(() => { });
+                    cleanup();
+                    resolve();
+                    return;
+                }
+                // decision.kind === 'remind'
+                const elapsedMin = Math.round((Date.now() - taskStartTime) / 60_000);
+                const msg = `⏳ CLI finished but task not yet marked done (${elapsedMin}m): ${discordLabel(task.text)}`;
+                this._cb?.log(msg);
+                this._notifyDiscord(msg);
+                this._notifyWebhook('task_checkin', {
+                    iteration: this._iterations,
+                    task: { text: task.text },
+                    elapsedMinutes: elapsedMin,
+                    workDir: this._workspaceRoot,
+                    gitRepo: this._gitRepo,
+                    gitBranch: this._gitBranch,
+                });
+                const date = new Date().toISOString().slice(0, 10);
+                // Read the actual current marker from TODO.md so the reminder is accurate.
+                // If Claude never started the task it will be [ ]; if it marked it in-progress
+                // but then exited it will be [~]. Using the wrong marker causes the AI to fail
+                // to locate the line and exit again without making any change.
+                const currentTasks = (0, todo_1.parseTodo)(todoPath);
+                const currentLine = currentTasks.find(t => t.line === task.line || t.text === task.text);
+                const currentMarker = currentLine?.status === 'in-progress' ? '~' : ' ';
+                const reminder = [
+                    `⚠️ ACTION REQUIRED: Your process has finished but your current task is NOT marked done in TODO.md.`,
+                    `Do NOT stop. Do NOT wait. Update TODO.md right now, then continue to the next task.`,
+                    `Read TODO.md now: cat ${todoPath}`,
+                    ``,
+                    `Find line ${task.line} (task: ${task.text}):`,
+                    `  - [${currentMarker}] ${task.text}`,
+                    ``,
+                    `You MUST change it to one of:`,
+                    `  [x] – done:        - [x] ${date}  ${task.text}`,
+                    `  [~] – in progress: - [~] ${task.text}`,
+                    ``,
+                    `After saving the file, immediately continue to the next [ ] task. Do not exit or wait for instructions.`,
+                ].join('\n');
+                this._cb?.log(`⚠️ CLI exited: reminding AI to mark TODO.md (${elapsedMin}m elapsed)`);
+                try {
+                    const reminderFile = (0, messageBuilder_1.writeMessageFile)(this._workspaceRoot, reminder);
+                    await this._cb.sendToAi(reminder, task.text, false, reminderFile);
+                }
+                catch { /* ignore */ }
+            };
+            // Track which exit file we are currently watching so the poller can
+            // re-attach when sendToAi() rotates to a new per-message exit file.
+            let watchedExitFile = null;
+            // Path of the exit file for which onCliExit() has already been invoked.
+            // Prevents the watcher AND the poller fallback from both firing onCliExit()
+            // for the same exit event (the guard is set by whichever fires first).
+            let handledExitFile = null;
+            const attachExitWatcher = (filePath) => {
+                if (filePath === watchedExitFile) {
+                    return;
+                } // already watching this file
+                exitWatcherRef?.dispose();
+                watchedExitFile = filePath;
+                exitWatcherRef = this._cb.fileWatcher.watch(filePath, () => {
+                    if (handledExitFile === filePath) {
+                        return;
+                    } // poller already handled
+                    try {
+                        const content = fs.readFileSync(filePath, 'utf8').trim();
+                        if (content === '') {
+                            return;
+                        } // file cleared at task start — ignore
+                    }
+                    catch {
+                        return;
+                    }
+                    handledExitFile = filePath;
+                    void onCliExit();
+                });
+            };
+            // opencode-sdk: the persistent in-process SDK doesn't use the CLI exit-file
+            // reminder flow — doing so causes a re-prompt loop (the SDK writes '0' to the
+            // exit file when session.idle fires, the poller sees it, calls onCliExit(),
+            // which re-sends the prompt, which loops).  Instead, the poller resolves this
+            // promise directly when isOpencodeSdkBusy() becomes false (see below).
+            if (!isOpencodeSdk && this._workspaceRoot) {
+                attachExitWatcher((0, sessionState_1.exitFilePath)(this._workspaceRoot, activeProvider));
+            }
+            // Inactivity-based check-in: track Claude JSONL byte size every 3 s.
+            // After 15 minutes of silence (no new bytes), send the TODO.md reminder.
+            // Resets when Claude writes again so we don't spam.
+            const INACTIVITY_MS = 15 * 60 * 1_000;
+            let endTurnSeen = false;
+            let lastJSONLSize = claudeCursor > 0 && this._workspaceRoot
+                ? (0, dispatcher_1.getClaudeSessionCursor)(this._workspaceRoot) : 0;
+            // lastActivityTime is declared above (shared with check())
+            let reminderPending = true; // allow one reminder per quiet period
+            let lastActivity;
+            poller = setInterval(async () => {
+                check();
+                checkStdout(); // also poll stdout every tick — file watcher can miss events on Linux
+                if (!this._workspaceRoot) {
+                    return;
+                }
+                // If sendToAi() was called (e.g. reminder path) it rotates to a new
+                // per-message stdout/exit file.  Re-attach both watchers so the next
+                // process's output and exit are both detected even though the paths changed.
+                const latestStdout = this._workspaceRoot ? (0, sessionState_1.stdoutFilePath)(this._workspaceRoot, activeProvider) : null;
+                if (latestStdout && latestStdout !== resolvedStdoutFile) {
+                    resolvedStdoutFile = latestStdout;
+                    lastStdoutLen = 0; // reset cursor — new file starts from byte 0
+                    attachStdoutWatcher(resolvedStdoutFile);
+                }
+                const latestExit = (0, sessionState_1.exitFilePath)(this._workspaceRoot, activeProvider);
+                if (!isOpencodeSdk && latestExit !== watchedExitFile) {
+                    attachExitWatcher(latestExit);
+                }
+                // opencode-sdk: resolve _waitForTaskCompletion as soon as the SDK
+                // session goes idle (isOpencodeSdkBusy false).  This avoids the
+                // CLI-style onCliExit() reminder re-prompt loop that the exit-file
+                // mechanism would otherwise trigger.
+                if (isOpencodeSdk && this._workspaceRoot && !(0, opencodeSdkProvider_1.isOpencodeSdkBusy)(this._workspaceRoot)) {
+                    check(); // one last todo-file check before resolving
+                    if (!cancelled) {
+                        cleanup();
+                        resolve();
+                    }
+                    return;
+                }
+                // Poller-based exit fallback: the VS Code file-system watcher can miss
+                // events (gitignored dirs, inotify limits, fast exits before re-attach).
+                // Read the exit file directly every tick and trigger onCliExit() if it
+                // became non-empty without the watcher firing.
+                if (!isOpencodeSdk && latestExit && latestExit !== handledExitFile) {
+                    try {
+                        if (fs.readFileSync(latestExit, 'utf8').trim() !== '') {
+                            handledExitFile = latestExit;
+                            void onCliExit();
+                        }
+                        else if (isOpenCodeCli && this._workspaceRoot) {
+                            // Empty exit file: the opencode process may have been killed before
+                            // writing the exit code (VS Code restart, OOM, terminal force-close).
+                            // If opencode is no longer active (hooks JSONL stale > 90s) and a
+                            // minimum grace period has elapsed, treat it as an unclean exit so
+                            // CliExitHandler can decide whether to retry, remind, or give up.
+                            const minWaitMs = 2 * 60 * 1_000; // 2 min grace period for startup
+                            if (Date.now() - taskStartTime > minWaitMs
+                                && !(0, openCodeHooksManager_1.isOpenCodeCliActive)(this._workspaceRoot)) {
+                                handledExitFile = latestExit;
+                                void onCliExit();
+                            }
+                        }
+                    }
+                    catch { /* file not yet written — ignore */ }
+                }
+                // Parse rich JSONL state: end_turn, active tool, bash progress
+                if (claudeCursor > 0) {
+                    const sessionState = (0, dispatcher_1.parseClaudeStateSince)(this._workspaceRoot, claudeCursor);
+                    // end_turn detection — fast-path on Linux where inotify can lag
+                    if (!endTurnSeen && sessionState.hasEndTurn) {
+                        endTurnSeen = true;
+                        this._cb?.log('end_turn detected in Claude JSONL — checking TODO.md');
+                        endTurnTimers.push(setTimeout(check, 800));
+                        endTurnTimers.push(setTimeout(check, 2_500));
+                    }
+                    // Surface current tool activity to sidebar
+                    const activity = sessionState.hasEndTurn
+                        ? undefined
+                        : (sessionState.activeToolStatus ?? (sessionState.hasProgress ? 'Running command\u2026' : undefined));
+                    if (activity !== lastActivity) {
+                        lastActivity = activity;
+                        this._cb?.onActivityChange?.(activity);
+                    }
+                    // Rate limit detection — reject immediately so _runLoop can pause
+                    if (sessionState.rateLimitMessage) {
+                        cleanup();
+                        reject(rateLimit_1.RateLimitDetector.toError(sessionState.rateLimitMessage));
+                        return;
+                    }
+                }
+                // Also check stdout capture file as poller fallback (watcher handles most cases)
+                checkStdout();
+                // Track JSONL activity
+                const currentSize = (0, dispatcher_1.getClaudeSessionCursor)(this._workspaceRoot);
+                if (currentSize !== lastJSONLSize) {
+                    lastJSONLSize = currentSize;
+                    lastActivityTime = Date.now();
+                    reminderPending = true; // new activity — allow a fresh reminder after next silence
+                    return;
+                }
+                // TODO.md inactivity timeout — fires when TODO.md has not been touched
+                // for the full timeout duration (resets on every TODO.md write).
+                // Checked on every tick independently of the JSONL reminder flow, so it
+                // fires even after a reminder has already been sent and reminderPending=false.
+                {
+                    const idleMs = Date.now() - lastTodoChangeTime;
+                    if (idleMs >= timeoutMs) {
+                        cleanup();
+                        const minutes = settings.taskTimeoutMinutes ?? 30;
+                        if (settings.retryOnTimeout) {
+                            await todoWriteManager_1.todoWriter.resetToTodo(todoPath, task).catch(() => { });
+                            const msg = `⏱ TODO.md idle for ${minutes}m — retrying: ${discordLabel(task.text)}`;
+                            this._cb?.log(msg);
+                            this._notifyDiscord(msg);
+                            this._notifyWebhook('task_checkin', {
+                                iteration: this._iterations,
+                                task: { text: task.text },
+                                elapsedMinutes: minutes,
+                                timedOut: true,
+                                retrying: true,
+                                workDir: this._workspaceRoot,
+                                gitRepo: this._gitRepo,
+                                gitBranch: this._gitBranch,
+                            });
+                            resolve(); // loop will pick it up again as a fresh [ ] task
+                        }
+                        else {
+                            reject(new Error(`Task timed out after ${minutes} minutes of TODO.md inactivity`));
+                        }
+                        return;
+                    }
+                }
+                // No new bytes — check if we've been quiet long enough
+                if (!reminderPending) {
+                    return;
+                }
+                if (Date.now() - lastActivityTime < INACTIVITY_MS) {
+                    return;
+                }
+                // 15+ minutes of JSONL silence — send one reminder
+                reminderPending = false;
+                if (this._state !== 'running') {
+                    return;
+                }
+                const elapsedMin = Math.round((Date.now() - taskStartTime) / 60_000);
+                const msg = `⏳ Still working... (${elapsedMin}m elapsed): ${discordLabel(task.text)}`;
+                this._cb?.log(msg);
+                this._notifyDiscord(msg);
+                this._notifyWebhook('task_checkin', {
+                    iteration: this._iterations,
+                    task: { text: task.text },
+                    elapsedMinutes: elapsedMin,
+                    workDir: this._workspaceRoot,
+                    gitRepo: this._gitRepo,
+                    gitBranch: this._gitBranch,
+                });
+                const date = new Date().toISOString().slice(0, 10);
+                const currentTasks2 = (0, todo_1.parseTodo)(todoPath);
+                const currentLine2 = currentTasks2.find(t => t.line === task.line || t.text === task.text);
+                const currentMarker2 = currentLine2?.status === 'in-progress' ? '~' : ' ';
+                const reminder = [
+                    `REMINDER: you have an unfinished task. Read TODO.md now: cat ${todoPath}`,
+                    ``,
+                    `Find line ${task.line} (task: ${task.text}):`,
+                    `  - [${currentMarker2}] ${task.text}`,
+                    ``,
+                    `When done, change it to:`,
+                    `  - [x] ${date}  ${task.text}`,
+                    ``,
+                    `If still in progress, mark it:`,
+                    `  - [~] ${task.text}`,
+                    ``,
+                    `Save the file. Do NOT exit without updating that line.`,
+                ].join('\n');
+                this._cb?.log(`⚠️ Check-in: reminding AI to mark TODO.md (${elapsedMin}m, JSONL quiet for 3m)`);
+                try {
+                    const reminderFile = (0, messageBuilder_1.writeMessageFile)(this._workspaceRoot, reminder);
+                    await this._cb.sendToAi(reminder, task.text, false, reminderFile);
+                }
+                catch { /* ignore */ }
+            }, 3_000);
+        });
+    }
+    _disposeWatcher() {
+        this._taskWatcher?.dispose();
+        this._taskWatcher = undefined;
+    }
+    _setState(state, taskText) {
+        this._state = state;
+        this._cb?.onStatusChange(state, taskText);
+    }
+    _notifyWebhook(event, payload) {
+        this._webhook?.send(event, payload);
+    }
+    _notifyDiscord(message) {
+        const s = this._settings;
+        if (!s) {
+            return;
+        }
+        if (s.discordToken && s.discordChannelId) {
+            (0, webhook_1.sendDiscordBotMessage)(s.discordToken, s.discordChannelId, message);
+        }
+    }
+}
+exports.TaskLoopRunner = TaskLoopRunner;
+/** Singleton runner — one loop per workspace session. */
+exports.taskLoopRunner = new TaskLoopRunner();
+//# sourceMappingURL=taskLoop.js.map