@runcore-sh/runcore 0.1.2

package/dist/agents/autonomous.js

@@ -0,0 +1,710 @@
+/**
+ * Autonomous work loop — the missing "first nudge" that makes the agent proactive.
+ *
+ * Two entry points:
+ *   1. Timer: fires 60s after boot, then every 15 min. Checks board, spawns agents.
+ *   2. continueAfterBatch(): called when a batch completes, decides what's next.
+ *
+ * Both use planAndSpawn() which:
+ *   - Reads board state directly (no HTTP, no SSE, no session validation)
+ *   - Asks the LLM to pick tasks and write agent prompts
+ *   - Parses [AGENT_REQUEST] blocks from the response
+ *   - Spawns agents via submitTask()
+ */
+import { getBoardProvider } from "../board/provider.js";
+import { submitTask } from "./index.js";
+import { activeAgentCount, generateBridgeReport } from "./spawn.js";
+import { commitAgentBatch } from "./commit.js";
+import { listTasks as listAgentTasks } from "./store.js";
+import { logActivity } from "../activity/log.js";
+import { pushNotification } from "../goals/notifications.js";
+import { completeChat } from "../llm/complete.js";
+import { LLMError } from "../llm/errors.js";
+import { resolveProvider } from "../settings.js";
+import { resolveEnv, getInstanceName, getInstanceNameLower } from "../instance.js";
+import { createLogger } from "../utils/logger.js";
+import { reflectOnSession } from "./reflection.js";
+import { TaskCooldownManager } from "./cooldown.js";
+import { checkDedup } from "./dedup-guard.js";
+import { recordAutonomousAction, recordDedupBlock } from "../metrics/firewall-metrics.js";
+import { getCapabilityRegistry } from "../capabilities/index.js";
+import { getPressureIntegrator } from "../pulse/pressure.js";
+const log = createLogger("autonomous");
+// ─── Config ──────────────────────────────────────────────────────────────────
+const AUTONOMOUS_INTERVAL_MS = 60 * 60 * 1000; // 60 min (coma failsafe — primary trigger is now tension-based)
+const FIRST_CHECK_DELAY_MS = 60 * 1000; // 60s after boot
+const MAX_CONTINUATION_ROUNDS = 5;
+const MAX_AGENTS_PER_ROUND = 5;
+/** Model for the planner LLM — needs to be capable enough for structured output. */
+const PLANNER_MODEL = "anthropic/claude-sonnet-4";
+// ─── State ───────────────────────────────────────────────────────────────────
+let timer = null;
+let firstCheckTimer = null;
+const continuationRounds = new Map();
+let autonomousSessionCounter = 0;
+/** Guard against concurrent planAndSpawn calls (timer vs continuation race). */
+let planningInProgress = false;
+/**
+ * Per-session cumulative failure counter.
+ * If a session accumulates too many total failures across all continuation rounds,
+ * stop the session entirely. This prevents the scenario where mixed success/failure
+ * batches keep the session alive while repeatedly retrying the same failing tasks.
+ */
+const sessionCumulativeFailures = new Map();
+const MAX_SESSION_CUMULATIVE_FAILURES = 8;
+/** Persistent cooldown tracker — survives restarts, shared across modules. */
+const cooldownManager = TaskCooldownManager.getInstance();
+/**
+ * Planner skip cache — tracks items the LLM planner reviewed and decided
+ * weren't ready. Avoids re-calling the LLM (~2 min round-trip) for the same
+ * unchanged items. Items are re-evaluated if their `updatedAt` changes or
+ * after the cooldown expires.
+ */
+const plannerSkipCache = new Map();
+const PLANNER_SKIP_COOLDOWN_MS = 2 * 60 * 60 * 1000; // 2 hours
+/**
+ * Max agents the planner will allow before skipping a work check.
+ * The planner can still spawn 1-3 agents per round, so actual peak may
+ * briefly exceed this while a batch is starting up.
+ */
+const MAX_CONCURRENT_AGENTS = parseInt(resolveEnv("MAX_CONCURRENT_AGENTS") ?? "", 10) || 3;
+/**
+ * Map agent label → board taskId, so we can mark the board task as failed
+ * when the agent fails and avoid immediately re-assigning it.
+ */
+const labelToBoardTaskId = new Map();
+/**
+ * Circuit breaker for LLM credit exhaustion.
+ * When a credit error is detected, autonomous work pauses until the cooldown expires.
+ * This prevents burning through the 15-min cycle repeatedly hitting a dead API.
+ */
+let creditCircuitBreakerUntil = 0;
+const CREDIT_CIRCUIT_BREAKER_MS = 30 * 60_000; // 30 minutes
+// ─── Public API ──────────────────────────────────────────────────────────────
+/**
+ * Start the autonomous work timer. Idempotent.
+ * First check fires 60s after boot (not immediately — gives system time to init).
+ * Then repeats every 15 min.
+ */
+export function startAutonomousTimer(intervalMs) {
+    if (timer)
+        return;
+    const interval = intervalMs ?? AUTONOMOUS_INTERVAL_MS;
+    // Initialize cooldown manager (loads persisted state from disk)
+    cooldownManager.init().catch((err) => {
+        log.warn(`Cooldown manager init failed: ${err instanceof Error ? err.message : String(err)}`);
+    });
+    // Fire first check shortly after boot
+    firstCheckTimer = setTimeout(async () => {
+        firstCheckTimer = null;
+        log.info(` First work check starting...`);
+        try {
+            await checkForWork();
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            log.error(` First check error: ${msg}`);
+            logActivity({ source: "autonomous", summary: `First check error: ${msg}`, actionLabel: "AUTONOMOUS", reason: "15-min autonomous planner cycle" });
+        }
+    }, FIRST_CHECK_DELAY_MS);
+    // Then repeat on interval
+    timer = setInterval(async () => {
+        try {
+            await checkForWork();
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            log.error(` Work check error: ${msg}`);
+            logActivity({ source: "autonomous", summary: `Work check error: ${msg}`, actionLabel: "AUTONOMOUS", reason: "15-min autonomous planner cycle" });
+        }
+    }, interval);
+    const mins = Math.round(interval / 60_000);
+    log.info(`Autonomous work: first check in ${FIRST_CHECK_DELAY_MS / 1000}s, then every ${mins} min`);
+}
+/** Stop the autonomous timer. */
+export function stopAutonomousTimer() {
+    if (firstCheckTimer) {
+        clearTimeout(firstCheckTimer);
+        firstCheckTimer = null;
+    }
+    if (timer) {
+        clearInterval(timer);
+        timer = null;
+    }
+    // Flush cooldown state to disk
+    cooldownManager.shutdown();
+}
+/** Is the autonomous timer running? */
+export function isAutonomousTimerRunning() {
+    return timer !== null;
+}
+/**
+ * Called by PressureIntegrator when tension exceeds threshold.
+ * Wraps checkForWork() with the existing planningInProgress guard.
+ */
+export async function triggerPulse() {
+    if (planningInProgress) {
+        log.info(`Pulse trigger skipped: planning already in progress`);
+        return;
+    }
+    if (activeAgentCount() >= MAX_CONCURRENT_AGENTS) {
+        log.info(`Pulse trigger skipped: at capacity (${activeAgentCount()}/${MAX_CONCURRENT_AGENTS})`);
+        return;
+    }
+    log.info(`Pulse trigger: checking for work...`);
+    await checkForWork();
+}
+/** Get a snapshot of the autonomous work loop's current state. */
+export function getAutonomousStatus() {
+    const activeSessions = [...continuationRounds.keys()];
+    const activeCooldowns = cooldownManager.listActiveCooldowns().map((c) => ({
+        taskId: c.taskId,
+        label: c.label,
+        failureCount: c.failureCount,
+        remainingMin: Math.round(c.remainingMs / 60_000),
+    }));
+    const cbRemain = Math.max(0, creditCircuitBreakerUntil - Date.now());
+    return {
+        timerRunning: timer !== null,
+        intervalMs: AUTONOMOUS_INTERVAL_MS,
+        firstCheckDelayMs: FIRST_CHECK_DELAY_MS,
+        creditCircuitBreakerActive: Date.now() < creditCircuitBreakerUntil,
+        creditCircuitBreakerRemainingMin: Math.ceil(cbRemain / 60_000),
+        planningInProgress,
+        activeAgents: activeAgentCount(),
+        maxConcurrentAgents: MAX_CONCURRENT_AGENTS,
+        activeSessions,
+        cooldowns: activeCooldowns,
+        plannerSkippedItems: plannerSkipCache.size,
+        pulse: getPressureIntegrator()?.getStatus() ?? null,
+    };
+}
+/**
+ * Called by onBatchComplete when all agents in a session finish.
+ * Commits work, then checks if there's more to do.
+ */
+export async function continueAfterBatch(sessionId, results) {
+    // Commit agent work as a logical batch
+    const round = (continuationRounds.get(sessionId) ?? 0) + 1;
+    try {
+        const commitResult = await commitAgentBatch(results, round);
+        if (commitResult.ok && commitResult.message !== "No changes to commit" && commitResult.message !== "No staged changes to commit") {
+            logActivity({ source: "system", summary: commitResult.message });
+        }
+    }
+    catch (err) {
+        logActivity({ source: "autonomous", summary: `Commit error: ${err instanceof Error ? err.message : String(err)}`, actionLabel: "AUTONOMOUS", reason: "batch continuation commit" });
+    }
+    // Record failed agent labels → board task cooldown (escalating, persisted)
+    const batchFailedCount = results.filter((r) => r.status === "failed").length;
+    for (const r of results) {
+        if (r.status === "failed") {
+            const boardTaskId = labelToBoardTaskId.get(r.label);
+            if (boardTaskId) {
+                cooldownManager.recordFailure(boardTaskId, r.label);
+                const failureCount = cooldownManager.getFailureCount(boardTaskId);
+                if (failureCount >= 3) {
+                    generateBridgeReport(boardTaskId, r.label, failureCount).catch(() => { });
+                }
+                labelToBoardTaskId.delete(r.label);
+            }
+        }
+    }
+    // Track cumulative failures across all rounds for this session
+    if (batchFailedCount > 0) {
+        const prevCumulative = sessionCumulativeFailures.get(sessionId) ?? 0;
+        const newCumulative = prevCumulative + batchFailedCount;
+        sessionCumulativeFailures.set(sessionId, newCumulative);
+        if (newCumulative >= MAX_SESSION_CUMULATIVE_FAILURES) {
+            log.info(` Session ${sessionId} hit ${newCumulative} cumulative failures (limit ${MAX_SESSION_CUMULATIVE_FAILURES}) — stopping`);
+            logActivity({
+                source: "autonomous",
+                summary: `Session hit ${newCumulative} cumulative failures — stopping`,
+                actionLabel: "AUTONOMOUS",
+                reason: "cumulative failure limit reached",
+            });
+            continuationRounds.delete(sessionId);
+            sessionCumulativeFailures.delete(sessionId);
+            await reflectOnSession({ sessionId, round, results, isFinal: true }).catch(() => { });
+            return;
+        }
+    }
+    // If all agents in the batch failed, stop continuation — don't keep trying
+    const allFailed = results.every((r) => r.status === "failed");
+    if (allFailed) {
+        log.info(` All ${results.length} agent(s) in batch failed — stopping continuation for session ${sessionId}`);
+        logActivity({ source: "autonomous", summary: `All agents in batch failed — stopping continuation`, actionLabel: "AUTONOMOUS", reason: "all-failure batch halt" });
+        continuationRounds.delete(sessionId);
+        sessionCumulativeFailures.delete(sessionId);
+        await reflectOnSession({ sessionId, round, results, isFinal: true }).catch(() => { });
+        return;
+    }
+    // Check round limit
+    if (round > MAX_CONTINUATION_ROUNDS) {
+        log.info(` Hit ${MAX_CONTINUATION_ROUNDS}-round limit for session ${sessionId}, pausing`);
+        logActivity({ source: "autonomous", summary: `Hit ${MAX_CONTINUATION_ROUNDS}-round limit, pausing`, actionLabel: "AUTONOMOUS", reason: "round limit reached" });
+        continuationRounds.delete(sessionId);
+        sessionCumulativeFailures.delete(sessionId);
+        await reflectOnSession({ sessionId, round, results, isFinal: true }).catch(() => { });
+        return;
+    }
+    continuationRounds.set(sessionId, round);
+    const batchSummary = results.map((r) => `${r.label}: ${r.status}`).join(", ");
+    // Fixed 2s pause between rounds — enough to prevent rapid cycling,
+    // short enough to keep the cluster responsive. Guards (dedup, cooldown,
+    // cumulative failure limit) handle runaway scenarios, not the delay.
+    const continuationDelayMs = 2000;
+    const msg = `Batch done (${batchSummary}). Checking for more work in ${Math.round(continuationDelayMs / 1000)}s (round ${round}/${MAX_CONTINUATION_ROUNDS})...`;
+    log.info(` ${msg}`);
+    logActivity({ source: "autonomous", summary: msg, actionLabel: "AUTONOMOUS", reason: `batch continuation round ${round}` });
+    pushNotification({ timestamp: new Date().toISOString(), source: "autonomous", message: msg });
+    // Build context from batch results
+    const resultSummary = results
+        .map((r) => `- ${r.label}: ${r.status}`)
+        .join("\n");
+    // Skip LLM-based reflection on intermediate rounds — saves 30-60s per round.
+    // Final reflections still run at the early-exit points above (all-failed, cumulative limit, round limit).
+    await new Promise((resolve) => setTimeout(resolve, continuationDelayMs));
+    const enhancedContext = `Just completed round ${round}:\n${resultSummary}`;
+    await planAndSpawn(sessionId, enhancedContext);
+}
+/** Reset continuation tracking for a session. */
+export function resetContinuation(sessionId) {
+    continuationRounds.delete(sessionId);
+    sessionCumulativeFailures.delete(sessionId);
+}
+// ─── Core ────────────────────────────────────────────────────────────────────
+/**
+ * Periodic check: if agents are idle and there's actionable work, spawn agents.
+ * Exported so PressureIntegrator can call it directly on pulse.
+ */
+export async function checkForWork() {
+    // Circuit breaker: skip if credits are exhausted (avoid hammering a dead API)
+    if (Date.now() < creditCircuitBreakerUntil) {
+        const remainMin = Math.ceil((creditCircuitBreakerUntil - Date.now()) / 60_000);
+        log.info(` Credit circuit breaker active — skipping work check (${remainMin}min remaining)`);
+        return;
+    }
+    const currentAgents = activeAgentCount();
+    if (currentAgents >= MAX_CONCURRENT_AGENTS) {
+        log.info(` At capacity (${currentAgents}/${MAX_CONCURRENT_AGENTS} agents), skipping work check`);
+        return;
+    }
+    if (planningInProgress) {
+        log.info(` Planning already in progress, skipping work check`);
+        return;
+    }
+    const board = getBoardProvider();
+    if (!board?.isAvailable()) {
+        log.info(` No board provider available`);
+        return;
+    }
+    const store = board.getStore?.();
+    if (!store) {
+        log.info(` No queue store available`);
+        return;
+    }
+    const allTasks = await store.list();
+    const atCapacity = currentAgents >= MAX_CONCURRENT_AGENTS;
+    // Filter to tasks the planner can assign.
+    // "todo" tasks assigned to the agent are reclaimed if no agent is actively running —
+    // they're leftovers from a previous session that failed or was interrupted.
+    const agentAssignee = `${getInstanceNameLower()}-agent`;
+    const actionable = allTasks.filter((t) => {
+        if (t.state !== "todo")
+            return false;
+        if (t.assignee && !(t.assignee === agentAssignee && t.state === "todo" && !atCapacity))
+            return false;
+        if (cooldownManager.shouldSkip(t.id))
+            return false;
+        return true;
+    });
+    if (actionable.length === 0) {
+        log.info(` No actionable items on the board`);
+        return;
+    }
+    // Filter out items the planner already reviewed and skipped (unless updated since)
+    const now = Date.now();
+    const needsReview = actionable.filter((t) => {
+        const cached = plannerSkipCache.get(t.id);
+        if (!cached)
+            return true;
+        // Re-evaluate if item was updated after the planner skipped it
+        if (t.updatedAt && t.updatedAt !== cached.itemUpdatedAt)
+            return true;
+        // Re-evaluate if the skip cooldown expired
+        if (now - cached.skippedAt >= PLANNER_SKIP_COOLDOWN_MS) {
+            plannerSkipCache.delete(t.id);
+            return true;
+        }
+        return false;
+    });
+    if (needsReview.length === 0) {
+        log.info(` ${actionable.length} actionable item(s) all recently reviewed by planner — skipping LLM call`);
+        return;
+    }
+    log.info(` Found ${needsReview.length} actionable item(s) (${actionable.length - needsReview.length} cached skip), calling LLM planner...`);
+    // Create an internal session for batch tracking
+    autonomousSessionCounter++;
+    const sessionId = `auto-${Date.now()}-${autonomousSessionCounter}`;
+    await planAndSpawn(sessionId, null, needsReview);
+}
+/**
+ * Ask the LLM what to work on, parse AGENT_REQUEST blocks, spawn agents.
+ */
+async function planAndSpawn(sessionId, priorContext, explicitItems) {
+    if (planningInProgress) {
+        log.info(` planAndSpawn already running, skipping duplicate call`);
+        return;
+    }
+    planningInProgress = true;
+    try {
+        await planAndSpawnInner(sessionId, priorContext, explicitItems);
+    }
+    finally {
+        planningInProgress = false;
+    }
+}
+async function planAndSpawnInner(sessionId, priorContext, explicitItems) {
+    // Get actionable board items (unless explicitly provided)
+    let actionable = explicitItems;
+    if (!actionable) {
+        const board = getBoardProvider();
+        if (!board?.isAvailable())
+            return;
+        const store = board.getStore?.();
+        if (!store)
+            return;
+        const allTasks = await store.list();
+        const atCap = activeAgentCount() >= MAX_CONCURRENT_AGENTS;
+        const agentAssigneeInner = `${getInstanceNameLower()}-agent`;
+        actionable = allTasks.filter((t) => {
+            if (t.state !== "todo")
+                return false;
+            if (t.assignee && !(t.assignee === agentAssigneeInner && t.state === "todo" && !atCap))
+                return false;
+            if (cooldownManager.shouldSkip(t.id))
+                return false;
+            return true;
+        });
+        if (actionable.length === 0) {
+            log.info(` No more actionable items — pausing`);
+            logActivity({ source: "autonomous", summary: "No more actionable items — pausing", actionLabel: "AUTONOMOUS", reason: "planner found no work" });
+            continuationRounds.delete(sessionId);
+            sessionCumulativeFailures.delete(sessionId);
+            return;
+        }
+    }
+    // Build board context with descriptions and project names
+    const boardContext = actionable
+        .map((t) => {
+        const desc = t.description ? `\n  ${t.description.slice(0, 1500)}` : "";
+        const proj = t.project ? ` {${t.project}}` : "";
+        return `- **${t.identifier}**: ${t.title} [${t.state}, P${t.priority ?? 4}]${proj} (id: ${t.id})${desc}`;
+    })
+        .join("\n");
+    // Build the planning prompt
+    const prompt = await buildPlannerPrompt(boardContext, priorContext);
+    const messages = [
+        { role: "system", content: getPlannerSystemPrompt() },
+        { role: "user", content: prompt },
+    ];
+    try {
+        log.info(` Calling LLM planner (model: ${PLANNER_MODEL}, provider: ${resolveProvider()})...`);
+        const response = await completeChat({
+            messages,
+            model: PLANNER_MODEL,
+            provider: resolveProvider(),
+        });
+        log.info(` LLM response (${response.length} chars): ${response.slice(0, 200)}...`);
+        // Process action blocks + meta blocks (TASK_DONE, etc.) via capability registry
+        let actionsExecuted = 0;
+        {
+            const capReg = getCapabilityRegistry();
+            if (capReg) {
+                const { results, metaResults } = await capReg.processResponse(response, { origin: "autonomous" });
+                actionsExecuted += results.filter((r) => r.ok).length;
+                actionsExecuted += metaResults.reduce((n, m) => n + m.results.filter((r) => r.ok).length, 0);
+            }
+        }
+        // Parse AGENT_REQUEST blocks from LLM response
+        const blocks = [...response.matchAll(/\[AGENT_REQUEST\]\s*([\s\S]*?)\s*\[\/AGENT_REQUEST\]/g)];
+        if (blocks.length === 0 && actionsExecuted === 0) {
+            // Extract a brief reason from the LLM response (strip markdown noise)
+            const briefReason = response.replace(/[#*`\[\]]/g, "").trim().slice(0, 150);
+            log.info(` LLM decided no agents needed. Response: ${response.slice(0, 300)}`);
+            logActivity({
+                source: "autonomous",
+                summary: `Reviewed ${actionable.length} backlog item(s), none ready: ${briefReason}`,
+                actionLabel: "AUTONOMOUS",
+                reason: "planner decided no action needed",
+            });
+            // Cache these items so the next cycle skips the LLM call for unchanged items
+            const skipTime = Date.now();
+            for (const t of actionable) {
+                plannerSkipCache.set(t.id, { skippedAt: skipTime, itemUpdatedAt: t.updatedAt });
+            }
+            log.info(` Cached ${actionable.length} item(s) as planner-skipped for ${PLANNER_SKIP_COOLDOWN_MS / 60_000}min`);
+            continuationRounds.delete(sessionId);
+            sessionCumulativeFailures.delete(sessionId);
+            return;
+        }
+        if (blocks.length === 0 && actionsExecuted > 0) {
+            log.info(` Executed ${actionsExecuted} action(s), no agents spawned`);
+            logActivity({
+                source: "autonomous",
+                summary: `Executed ${actionsExecuted} action(s) from ${actionable.length} backlog item(s)`,
+                actionLabel: "AUTONOMOUS",
+                reason: "planner executed actions directly",
+            });
+            continuationRounds.delete(sessionId);
+            sessionCumulativeFailures.delete(sessionId);
+            return;
+        }
+        // Log the planning entry now that the LLM has actually decided to spawn
+        const planEntry = logActivity({
+            source: "autonomous",
+            summary: `Planning ${blocks.length} agent(s) from ${actionable.length} backlog item(s)`,
+            actionLabel: "AUTONOMOUS",
+            reason: "15-min autonomous planner cycle",
+        });
+        const planTraceId = planEntry.traceId;
+        log.info(` Found ${blocks.length} AGENT_REQUEST block(s)`);
+        let spawnCount = 0;
+        const spawnedLabels = [];
+        for (const block of blocks) {
+            if (spawnCount >= MAX_AGENTS_PER_ROUND)
+                break;
+            const rawContent = block[1].trim();
+            let jsonStr = rawContent
+                .replace(/^`{3,}(?:json)?\s*/i, "")
+                .replace(/\s*`{3,}$/i, "")
+                .replace(/^`+|`+$/g, "");
+            const jsonMatch = jsonStr.match(/\{[\s\S]*\}/);
+            if (!jsonMatch) {
+                log.warn(` No JSON in AGENT_REQUEST block: ${rawContent.slice(0, 200)}`);
+                logActivity({ source: "autonomous", summary: `No JSON in AGENT_REQUEST block`, actionLabel: "AUTONOMOUS", reason: "planner output parse issue" });
+                continue;
+            }
+            try {
+                const req = JSON.parse(jsonMatch[0]);
+                if (!req.prompt) {
+                    log.warn(` AGENT_REQUEST missing "prompt" field`);
+                    continue;
+                }
+                const label = req.label || req.prompt.slice(0, 60);
+                let finalPrompt = req.prompt;
+                // Guard: dedup — skip if same work is already in progress or recently done
+                const dedup = await checkDedup(label, finalPrompt);
+                if (dedup.blocked) {
+                    log.info(` Dedup guard blocked: "${label}" — ${dedup.reason}`);
+                    recordDedupBlock(dedup.reason ?? "unknown");
+                    logActivity({
+                        source: "autonomous",
+                        summary: `Skipped "${label}": ${dedup.reason}`,
+                        actionLabel: "AUTONOMOUS",
+                        reason: "dedup guard",
+                    });
+                    continue;
+                }
+                // Guard: detect vague prompts
+                const hasFilePath = /(?:src\/|brain\/|public\/|\.ts|\.js|\.md|\.json|\.yaml|\.yml)/.test(finalPrompt);
+                const isVague = /\b(?:comprehensive|robust|production-ready|enterprise|scalable|world-class)\b/i.test(finalPrompt)
+                    && !hasFilePath;
+                if (isVague) {
+                    finalPrompt = [
+                        `IMPORTANT: The original request is vague. Do NOT try to build everything listed.`,
+                        `Instead: 1) Read the existing codebase (start with src/ and package.json).`,
+                        `2) Pick ONE small, concrete piece you can implement that connects to existing code.`,
+                        `3) Build that one thing well.`,
+                        `4) If nothing concrete can be built without more requirements, create a brief spec at brain/knowledge/notes/.`,
+                        ``,
+                        `Original request:`,
+                        finalPrompt,
+                    ].join("\n");
+                }
+                // Track label→boardTaskId so we can cooldown on failure
+                if (req.taskId) {
+                    labelToBoardTaskId.set(label, req.taskId);
+                }
+                spawnCount++;
+                spawnedLabels.push(label);
+                recordAutonomousAction();
+                log.info(` Spawning agent: ${label}`);
+                logActivity({ source: "autonomous", summary: `Spawning: ${label}`, backref: planTraceId, actionLabel: "AUTONOMOUS", reason: "planner selected from backlog" });
+                await submitTask({
+                    label,
+                    prompt: finalPrompt,
+                    origin: "ai",
+                    sessionId,
+                    boardTaskId: req.taskId,
+                });
+            }
+            catch (err) {
+                log.error(` AGENT_REQUEST parse error: ${err instanceof Error ? err.message : String(err)}`);
+                logActivity({
+                    source: "autonomous",
+                    summary: `AGENT_REQUEST parse error: ${err instanceof Error ? err.message : String(err)}`,
+                    actionLabel: "AUTONOMOUS",
+                    reason: "planner output parse error",
+                });
+            }
+        }
+        if (spawnCount > 0) {
+            const summary = `Working on ${spawnCount} task(s): ${spawnedLabels.join(", ")}`;
+            log.info(` ${summary}`);
+            logActivity({ source: "autonomous", summary, backref: planTraceId, actionLabel: "AUTONOMOUS", reason: "planner selected from backlog" });
+            pushNotification({
+                timestamp: new Date().toISOString(),
+                source: "autonomous",
+                message: summary,
+            });
+        }
+        else {
+            log.warn(` Found ${blocks.length} block(s) but spawned 0 agents`);
+            logActivity({ source: "autonomous", summary: "Parsed blocks but spawned 0 agents", actionLabel: "AUTONOMOUS", reason: "planner blocks had no valid agents" });
+            continuationRounds.delete(sessionId);
+            sessionCumulativeFailures.delete(sessionId);
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log.error(` LLM call failed: ${msg}`);
+        logActivity({ source: "autonomous", summary: `LLM call failed: ${msg}`, actionLabel: "AUTONOMOUS", reason: "15-min autonomous planner cycle" });
+        // Trip circuit breaker on credit/billing errors to stop hammering a dead API
+        const isCreditsIssue = (err instanceof LLMError && err.isCreditsError)
+            || /402|credits|afford|payment.required|billing/i.test(msg);
+        if (isCreditsIssue) {
+            creditCircuitBreakerUntil = Date.now() + CREDIT_CIRCUIT_BREAKER_MS;
+            const breaker_msg = `API credits exhausted — autonomous work paused for ${CREDIT_CIRCUIT_BREAKER_MS / 60_000}min. Top up at openrouter.ai/settings/credits.`;
+            log.warn(breaker_msg);
+            logActivity({ source: "autonomous", summary: breaker_msg, actionLabel: "AUTONOMOUS", reason: "credit circuit breaker tripped" });
+            pushNotification({
+                timestamp: new Date().toISOString(),
+                source: "autonomous",
+                message: breaker_msg,
+            });
+        }
+        continuationRounds.delete(sessionId);
+        sessionCumulativeFailures.delete(sessionId);
+    }
+}
+// ─── Prompts ─────────────────────────────────────────────────────────────────
+function getPlannerSystemPrompt() {
+    const capInstructions = getCapabilityRegistry()?.getPromptInstructions({ origin: "autonomous" }) ?? "";
+    return `You are ${getInstanceName()}'s autonomous work planner. Your job is to look at the backlog and decide what agents should work on next.
+
+Rules:
+- Pick 1-3 items from the backlog that are ready to implement NOW.
+- Skip items that are vague specs or need human decisions — those need grooming first.
+- Prefer items with clear titles and descriptions over ambiguous ones.
+- Each agent gets ONE focused task. Don't bundle multiple items into one agent.
+- Write clear, specific agent prompts with file paths when possible.
+- If nothing is ready to implement, output NO [AGENT_REQUEST] blocks and explain why.
+- DO NOT retry tasks that have already been attempted and failed. If the "Recent agent history" section shows a task was tried before, skip it unless you have a fundamentally different approach (not just "try again").
+- If the same board item has failed multiple times, it probably needs human input or a spec change — skip it.
+
+## Two types of actions
+
+### 1. Code agents (for code/file tasks)
+For tasks that require reading/writing code or files, output:
+
+[AGENT_REQUEST]
+{
+  "label": "Short descriptive name",
+  "prompt": "Detailed instructions for the agent. Reference specific files. Be concrete.",
+  "taskId": "the-task-id-from-the-board"
+}
+[/AGENT_REQUEST]
+
+The agent runs \`claude --print --dangerously-skip-permissions\` in the project root.
+It can read/write files, run npm commands, etc. Give it everything it needs to succeed independently.
+After making changes, the agent should run \`npm run build\` to verify compilation.
+
+### 2. Google Workspace actions (for calendar, email, docs tasks)
+For tasks like scheduling meetings, sending emails, or creating documents, output action blocks directly — NO agent needed.
+
+${capInstructions}
+
+IMPORTANT: When a task says "schedule", "meeting", "calendar", "appointment" — use [CALENDAR_ACTION], not an agent.
+When a task says "email", "send", "notify" — use [EMAIL_ACTION], not an agent.
+After outputting the action block, also include the taskId so the task can be marked done:
+[TASK_DONE]{"taskId": "the-task-id"}[/TASK_DONE]`;
+}
+async function buildPlannerPrompt(boardContext, priorContext) {
+    const parts = [];
+    parts.push(`Current time: ${new Date().toISOString()}`);
+    parts.push(``);
+    if (priorContext) {
+        parts.push(`## Previous batch results`);
+        parts.push(priorContext);
+        parts.push(``);
+    }
+    // Include recent agent history so the planner knows what's been tried
+    const historyContext = await buildAgentHistoryContext();
+    if (historyContext) {
+        parts.push(`## Recent agent history (last 24h)`);
+        parts.push(historyContext);
+        parts.push(``);
+    }
+    // Include currently cooling-down tasks
+    const cooldownContext = cooldownManager.getCooldownContext();
+    if (cooldownContext) {
+        parts.push(`## Tasks on cooldown (DO NOT assign these)`);
+        parts.push(cooldownContext);
+        parts.push(``);
+    }
+    parts.push(`## Actionable backlog items (unassigned, ready to work)`);
+    parts.push(boardContext);
+    parts.push(``);
+    parts.push(`Review these items and decide which ones to assign to agents. Output [AGENT_REQUEST] blocks for each.`);
+    parts.push(`If an item is too vague or needs human input, skip it and explain why.`);
+    return parts.join("\n");
+}
+/**
+ * Build a summary of recent agent task results so the planner can avoid
+ * re-attempting tasks that have already been tried and failed.
+ *
+ * Optimization: uses `since` filter to skip reading old task files from disk
+ * entirely (filename-embedded timestamps are checked before file read).
+ */
+async function buildAgentHistoryContext() {
+    try {
+        const cutoff = Date.now() - 24 * 60 * 60 * 1000; // last 24h
+        const tasks = await listAgentTasks({ since: cutoff });
+        const recent = tasks.filter((t) => {
+            const ts = t.finishedAt || t.createdAt;
+            return ts && new Date(ts).getTime() > cutoff;
+        });
+        if (recent.length === 0)
+            return null;
+        // Group by normalized label to show patterns
+        const byLabel = new Map();
+        for (const t of recent) {
+            const key = t.label.replace(/\d+/g, "N").slice(0, 60);
+            if (!byLabel.has(key))
+                byLabel.set(key, { completed: 0, failed: 0, labels: [] });
+            const entry = byLabel.get(key);
+            if (t.status === "completed")
+                entry.completed++;
+            else if (t.status === "failed")
+                entry.failed++;
+            if (!entry.labels.includes(t.label))
+                entry.labels.push(t.label);
+        }
+        const lines = [];
+        for (const [key, info] of byLabel) {
+            const status = [];
+            if (info.completed > 0)
+                status.push(`${info.completed} completed`);
+            if (info.failed > 0)
+                status.push(`${info.failed} FAILED`);
+            lines.push(`- "${info.labels[0]}": ${status.join(", ")}`);
+        }
+        return lines.join("\n");
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=autonomous.js.map