@hyperdrive.bot/paseo-server 0.3.41 → 0.3.43

package/dist/server/server/agent/agent-manager.d.ts

@@ -142,6 +142,14 @@ interface ManagedAgentBase {
     lastUsage?: AgentUsage;
     lastError?: string;
     attention: AttentionState;
+    /**
+     * How many times a "finished" attention event was suppressed on this agent
+     * because it still owned armed background work (see checkAndSetAttention).
+     * Diagnostic only — never persisted, never projected to clients. It exists so
+     * the deliberately-accepted gap (a prose question swallowed mid-monitor) can
+     * be MEASURED from real sessions instead of argued about.
+     */
+    suppressedAttentionCount?: number;
     foregroundTurnWaiters: Set<ForegroundTurnWaiter>;
     finalizedForegroundTurnIds: Set<string>;
     unsubscribeSession: (() => void) | null;
@@ -472,6 +480,13 @@ export declare class AgentManager {
     private recordTimeline;
     private emitState;
     private syncFeaturesFromSession;
+    /**
+     * Live background work owned by this agent: monitors, crons, and backgrounded
+     * shells the provider is still tracking. Mirrors what `agent-projections`
+     * publishes as `activeBackgroundTaskCount`, read through the same optional
+     * hook so providers that do not implement it simply report zero.
+     */
+    private getActiveBackgroundTaskCount;
     private checkAndSetAttention;
     private enqueueBackgroundPersist;
     private enqueueDurableTimelineAppend;

package/dist/server/server/agent/agent-manager.js

@@ -228,7 +228,10 @@ export class AgentManager {
         this.mcpAuthToken = options?.mcpAuthToken ?? null;
         this.configurePaseoTools(options);
         this.appendSystemPrompt = options.appendSystemPrompt ?? "";
-        this.logger = options.logger.child({ module: "agent", component: "agent-manager" });
+        this.logger = options.logger.child({
+            module: "agent",
+            component: "agent-manager",
+        });
         this.rescueTimeouts = {
             reloadSessionCloseMs: options.rescueTimeouts?.reloadSessionCloseMs ?? RELOAD_SESSION_CLOSE_TIMEOUT_MS,
             interruptSessionMs: options.rescueTimeouts?.interruptSessionMs ?? INTERRUPT_SESSION_TIMEOUT_MS,
@@ -467,7 +470,9 @@ export class AgentManager {
         }
     }
     async listDraftCommands(config) {
-        const normalizedConfig = await this.normalizeConfig(config, { resolveDefaultModel: false });
+        const normalizedConfig = await this.normalizeConfig(config, {
+            resolveDefaultModel: false,
+        });
         const client = this.requireClient(normalizedConfig.provider);
         if (!normalizedConfig.model) {
             return [];
@@ -496,7 +501,9 @@ export class AgentManager {
         }
     }
     async listDraftFeatures(config) {
-        const normalizedConfig = await this.normalizeConfig(config, { resolveDefaultModel: false });
+        const normalizedConfig = await this.normalizeConfig(config, {
+            resolveDefaultModel: false,
+        });
         const client = this.requireClient(normalizedConfig.provider);
         if (!normalizedConfig.model) {
             return [];
@@ -600,7 +607,9 @@ export class AgentManager {
     async importProviderSession(input) {
         const resolvedAgentId = validateAgentId(this.idFactory(), "importProviderSession");
         this.requireEnabledProvider(input.provider);
-        const client = await this.requireAvailableClient({ provider: input.provider });
+        const client = await this.requireAvailableClient({
+            provider: input.provider,
+        });
         if (!client.importSession) {
             throw new Error(`Provider '${input.provider}' does not support importing sessions`);
         }
@@ -908,7 +917,10 @@ export class AgentManager {
     async markRecordArchived(record) {
         const registry = this.requireRegistry();
         const archivedAt = new Date().toISOString();
-        const archivedRecord = buildArchivedAgentRecord(record, { archivedAt, updatedAt: archivedAt });
+        const archivedRecord = buildArchivedAgentRecord(record, {
+            archivedAt,
+            updatedAt: archivedAt,
+        });
         await registry.upsert(archivedRecord);
         await this.archiveNativeSessionBestEffort(record.provider, record.persistence);
         if (this.agents.has(record.id)) {
@@ -1024,7 +1036,10 @@ export class AgentManager {
             throw new Error("Agent session does not support setting features");
         }
         await agent.session.setFeature(featureId, value);
-        agent.config.featureValues = { ...agent.config.featureValues, [featureId]: value };
+        agent.config.featureValues = {
+            ...agent.config.featureValues,
+            [featureId]: value,
+        };
         this.touchUpdatedAt(agent);
         this.emitState(agent);
     }
@@ -1072,7 +1087,9 @@ export class AgentManager {
         const priorColumn = touchesColumn && this.registry
             ? ((await this.registry.get(agentId))?.labels?.[KANBAN_LABEL_KEY] ?? null)
             : null;
-        const nextRecord = await this.writeStoredMetadata(agentId, { labels: patch });
+        const nextRecord = await this.writeStoredMetadata(agentId, {
+            labels: patch,
+        });
         if (touchesColumn) {
             this.cardMoveLog?.record(agentId, priorColumn, nextRecord.labels?.[KANBAN_LABEL_KEY] ?? null);
         }
@@ -1107,7 +1124,9 @@ export class AgentManager {
                 }
                 return { record, live: true, previousParentAgentId: null };
             }
-            const { record } = await this.writeLabels(agentId, { [PARENT_AGENT_ID_LABEL]: null });
+            const { record } = await this.writeLabels(agentId, {
+                [PARENT_AGENT_ID_LABEL]: null,
+            });
             if (!record) {
                 throw new Error(`Agent not found in storage after detach: ${agentId}`);
             }
@@ -1121,7 +1140,9 @@ export class AgentManager {
         if (!previousParentAgentId) {
             return { record, live: false, previousParentAgentId: null };
         }
-        const result = await this.writeLabels(agentId, { [PARENT_AGENT_ID_LABEL]: null });
+        const result = await this.writeLabels(agentId, {
+            [PARENT_AGENT_ID_LABEL]: null,
+        });
         if (!result.record) {
             throw new Error(`Agent not found in storage after detach: ${agentId}`);
         }
@@ -1292,7 +1313,9 @@ export class AgentManager {
                 });
                 return;
             }
-            this.dispatchStream(agent.id, event, { timestamp: new Date().toISOString() });
+            this.dispatchStream(agent.id, event, {
+                timestamp: new Date().toISOString(),
+            });
         };
         void (async () => {
             try {
@@ -1432,7 +1455,10 @@ export class AgentManager {
         mutableAgent.lifecycle = nextLifecycle;
         const persistenceHandle = mutableAgent.session.describePersistence() ??
             (mutableAgent.runtimeInfo?.sessionId
-                ? { provider: mutableAgent.provider, sessionId: mutableAgent.runtimeInfo.sessionId }
+                ? {
+                    provider: mutableAgent.provider,
+                    sessionId: mutableAgent.runtimeInfo.sessionId,
+                }
                 : null);
         if (persistenceHandle) {
             mutableAgent.persistence = attachPersistenceCwd(persistenceHandle, mutableAgent.cwd);
@@ -1589,7 +1615,9 @@ export class AgentManager {
             const bufferedResolution = agent.bufferedPermissionResolutions.get(requestId);
             if (bufferedResolution) {
                 agent.bufferedPermissionResolutions.delete(requestId);
-                this.dispatchStream(agent.id, bufferedResolution, { timestamp: new Date().toISOString() });
+                this.dispatchStream(agent.id, bufferedResolution, {
+                    timestamp: new Date().toISOString(),
+                });
             }
             return result;
         }
@@ -1626,7 +1654,11 @@ export class AgentManager {
                 continue;
             }
             for (const task of agent.session.listBackgroundTasks()) {
-                rows.push({ agentId: agent.id, agentTitle: agent.config.title ?? null, task });
+                rows.push({
+                    agentId: agent.id,
+                    agentTitle: agent.config.title ?? null,
+                    task,
+                });
             }
         }
         return rows;
@@ -1767,7 +1799,10 @@ export class AgentManager {
             this.logger.info({ agentId, provider: agent.provider, messageId, mode }, "agent.rewind.start");
             await invokeRewindCapability(agent.session, { messageId, mode });
             if (mode !== "files") {
-                await this.hydrateTimelineFromProvider(agentId, { force: true, broadcast: true });
+                await this.hydrateTimelineFromProvider(agentId, {
+                    force: true,
+                    broadcast: true,
+                });
             }
             await this.refreshRuntimeInfo(agent);
             await this.persistSnapshot(agent);
@@ -2013,14 +2048,18 @@ export class AgentManager {
         this.agents.set(resolvedAgentId, managed);
         // Initialize previousStatus to track transitions
         this.previousStatuses.set(resolvedAgentId, managed.lifecycle);
-        await this.refreshRuntimeInfo(managed, { emit: !options?.publishWhenReady });
+        await this.refreshRuntimeInfo(managed, {
+            emit: !options?.publishWhenReady,
+        });
         await this.persistSnapshot(managed, {
             title: initialPersistedTitle,
         });
         if (!options?.publishWhenReady) {
             this.emitState(managed, { persist: false });
         }
-        await this.refreshSessionState(managed, { emit: !options?.publishWhenReady });
+        await this.refreshSessionState(managed, {
+            emit: !options?.publishWhenReady,
+        });
         managed.lifecycle = "idle";
         await this.persistSnapshot(managed);
         this.emitState(managed, { persist: false });
@@ -2280,7 +2319,9 @@ export class AgentManager {
             this.agentStreamCoalescer.flushAndDiscard(agent.id);
             await this.deleteCommittedTimeline(agent.id);
             this.timelineStore.delete(agent.id);
-            this.timelineStore.initialize(agent.id, { timestamp: new Date().toISOString() });
+            this.timelineStore.initialize(agent.id, {
+                timestamp: new Date().toISOString(),
+            });
             agent.historyPrimed = true;
             for (const event of historyEvents) {
                 const row = this.recordTimeline(agent.id, event.item, event.timestamp ? { timestamp: event.timestamp } : undefined);
@@ -2348,7 +2389,10 @@ export class AgentManager {
             }
             this.agentStreamCoalescer.flushFor(agent.id);
         }
-        const flags = { shouldDispatchEvent: true, shouldNotifyWaiters: true };
+        const flags = {
+            shouldDispatchEvent: true,
+            shouldNotifyWaiters: true,
+        };
         const dispatchPromise = this.dispatchStreamEventByType({
             agent,
             event,
@@ -2364,7 +2408,9 @@ export class AgentManager {
             this.finalizeForegroundTurn(agent, eventTurnId);
         }
         if (!options?.fromHistory && flags.shouldDispatchEvent) {
-            this.dispatchStream(agent.id, event, { timestamp: new Date().toISOString() });
+            this.dispatchStream(agent.id, event, {
+                timestamp: new Date().toISOString(),
+            });
         }
         this.traceHandleStreamEventEnd(agent, event, eventTurnId, flags);
         return flags.shouldNotifyWaiters;
@@ -2417,7 +2463,10 @@ export class AgentManager {
                 agent.currentModeId = event.currentModeId;
                 agent.availableModes = event.availableModes;
                 if (agent.runtimeInfo) {
-                    agent.runtimeInfo = { ...agent.runtimeInfo, modeId: event.currentModeId };
+                    agent.runtimeInfo = {
+                        ...agent.runtimeInfo,
+                        modeId: event.currentModeId,
+                    };
                 }
                 flags.shouldDispatchEvent = false;
                 this.emitState(agent);
@@ -2425,7 +2474,10 @@ export class AgentManager {
             case "model_changed":
                 agent.runtimeInfo = event.runtimeInfo;
                 if (!agent.persistence && event.runtimeInfo.sessionId) {
-                    agent.persistence = attachPersistenceCwd({ provider: agent.provider, sessionId: event.runtimeInfo.sessionId }, agent.cwd);
+                    agent.persistence = attachPersistenceCwd({
+                        provider: agent.provider,
+                        sessionId: event.runtimeInfo.sessionId,
+                    }, agent.cwd);
                 }
                 agent.currentModeId = event.runtimeInfo.modeId ?? agent.currentModeId;
                 flags.shouldDispatchEvent = false;
@@ -2442,9 +2494,20 @@ export class AgentManager {
                 this.emitState(agent);
                 return undefined;
             case "timeline":
-                return this.onStreamTimelineEvent({ agent, event, options, isForegroundEvent, flags });
+                return this.onStreamTimelineEvent({
+                    agent,
+                    event,
+                    options,
+                    isForegroundEvent,
+                    flags,
+                });
             case "turn_completed":
-                this.onStreamTurnCompleted({ agent, event, eventTurnId, isForegroundEvent });
+                this.onStreamTurnCompleted({
+                    agent,
+                    event,
+                    eventTurnId,
+                    isForegroundEvent,
+                });
                 return undefined;
             case "turn_failed":
                 return this.onStreamTurnFailed({
@@ -2455,7 +2518,13 @@ export class AgentManager {
                     options,
                 });
             case "turn_canceled":
-                this.onStreamTurnCanceled({ agent, event, eventTurnId, isForegroundEvent, options });
+                this.onStreamTurnCanceled({
+                    agent,
+                    event,
+                    eventTurnId,
+                    isForegroundEvent,
+                    options,
+                });
                 return undefined;
             case "turn_started":
                 this.onStreamTurnStarted({ agent, eventTurnId, isForegroundEvent });
@@ -2704,6 +2773,18 @@ export class AgentManager {
             agent.features = agent.session.features;
         }
     }
+    /**
+     * Live background work owned by this agent: monitors, crons, and backgrounded
+     * shells the provider is still tracking. Mirrors what `agent-projections`
+     * publishes as `activeBackgroundTaskCount`, read through the same optional
+     * hook so providers that do not implement it simply report zero.
+     */
+    getActiveBackgroundTaskCount(agent) {
+        if (!("session" in agent)) {
+            return 0;
+        }
+        return agent.session?.getActiveBackgroundTaskCount?.() ?? 0;
+    }
     checkAndSetAttention(agent) {
         const previousStatus = this.previousStatuses.get(agent.id);
         const currentStatus = agent.lifecycle;
@@ -2719,6 +2800,40 @@ export class AgentManager {
         }
         // Check if agent transitioned from running to idle (finished)
         if (previousStatus === "running" && currentStatus === "idle") {
+            // ...but "the lifecycle went running -> idle" is NOT the same fact as
+            // "this agent is finished and wants you".
+            //
+            // A monitor tick, a cron firing, or a background shell reporting progress
+            // all WAKE the session: status goes idle -> running, the agent prints a
+            // progress line ("1/12 done, I'll let you know"), the turn ends, and the
+            // lifecycle settles back to idle. Under the old rule that transition set
+            // requiresAttention="finished" on EVERY tick, which lit the Unread chip,
+            // the dock badge and a push notification for output nobody needs to act
+            // on. With several sessions in parallel that made Unread — the one chip
+            // you actually watch — useless.
+            //
+            // So: if the agent still owns armed background work, the turn ending is a
+            // progress beat, not a handoff. Stay quiet and let the bucket derivation
+            // surface it as "pending" (alive, will come back on its own) instead.
+            //
+            // KNOWN GAP, deliberately named rather than silently accepted: a turn that
+            // ends with the agent asking a real question in PROSE (not a permission
+            // request, which still routes through needs_input and is unaffected) is
+            // also suppressed while background work is armed. Prose questions are not
+            // machine-detectable here. The counter below exists so that gap is
+            // MEASURED rather than assumed — feed it to the Jarvis judge in shadow
+            // mode (PASEO_JARVIS_SHADOW=1) to size the real distribution before
+            // deciding whether it needs rescuing.
+            const activeBackgroundTaskCount = this.getActiveBackgroundTaskCount(agent);
+            if (activeBackgroundTaskCount > 0) {
+                agent.suppressedAttentionCount = (agent.suppressedAttentionCount ?? 0) + 1;
+                this.logger.debug({
+                    agentId: agent.id,
+                    activeBackgroundTaskCount,
+                    suppressedAttentionCount: agent.suppressedAttentionCount,
+                }, "Suppressed finished-attention: agent still owns armed background work");
+                return;
+            }
             agent.attention = {
                 requiresAttention: true,
                 attentionReason: "finished",
@@ -2938,7 +3053,9 @@ export class AgentManager {
         if (this.paseoToolsEnabled &&
             client.capabilities.supportsNativePaseoTools &&
             this.paseoToolCatalogFactory) {
-            context.paseoTools = await this.paseoToolCatalogFactory({ callerAgentId: agentId });
+            context.paseoTools = await this.paseoToolCatalogFactory({
+                callerAgentId: agentId,
+            });
         }
         return context;
     }

package/dist/server/server/agent/mcp-server.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { WorkflowNotFoundError } from "../workflow/workflow-manager.js";
-import { WorkflowSnapshotSchema, WorkflowStatusSchema, WorkflowTaskGraphSchema, SessionDigestSchema, } from "../messages.js";
+import { WorkflowAgentPresetSchema, WorkflowSnapshotSchema, WorkflowStatusSchema, WorkflowTaskGraphSchema, SessionDigestSchema, } from "../messages.js";
 import { AgentStatusEnum } from "./mcp-shared.js";
 import { expandUserPath } from "../path-utils.js";
 import { ensureValidJson } from "../json-utils.js";
@@ -28,6 +28,10 @@ const workflowStartArgsSchema = z.object({
         .record(z.string(), z.string())
         .optional()
         .describe("Optional labels copied onto every spawned child alongside the workflow id"),
+    agentPresets: z
+        .record(z.string(), WorkflowAgentPresetSchema)
+        .optional()
+        .describe("Optional map of agent name to partial session config; a task's agentType selects one"),
 });
 const workflowIdArgsSchema = z.object({
     workflowId: z.string().describe("Workflow id returned by workflow_start"),
@@ -238,6 +242,7 @@ export async function createAgentMcpServer(options) {
                 baseConfig,
                 ...(args.title ? { title: args.title } : {}),
                 ...(args.labels ? { labels: args.labels } : {}),
+                ...(args.agentPresets ? { agentPresets: args.agentPresets } : {}),
                 ...(callerAgentId ? { parentAgentId: callerAgentId } : {}),
             });
             const started = await workflowManager.startWorkflow(workflow.id);

package/dist/server/server/agent/providers/claude/background-task-tracker.d.ts

@@ -27,9 +27,25 @@
  * output file's real birth time, reading the output back) is the caller's job.
  */
 export type ClaudeBackgroundTaskStatus = "running" | "completed" | "failed" | "canceled";
+/**
+ * What kind of background work a record represents. Surfaced so the UI can say
+ * WHAT is holding a session open ("pending · monitoring deploy.log") instead of
+ * an unexplained spinner, which is how users end up force-quitting sessions.
+ *
+ * ⚠️ Adding a member here is not enough to make it tracked — it must also get a
+ * start pattern above AND a retirement path, and be listed in the exhaustiveness
+ * test. See `background-work-kinds.ts`.
+ */
+export type ClaudeBackgroundTaskKind = "shell" | "monitor" | "cron";
+export interface BackgroundTaskStart {
+    id: string;
+    kind: ClaudeBackgroundTaskKind;
+}
 export interface ClaudeBackgroundTaskRecord {
     /** Harness-assigned shell id, e.g. `bjuk0pif4`. Stable across start and end. */
     id: string;
+    /** Which flavour of background work this is. Defaults to "shell" (legacy). */
+    kind: ClaudeBackgroundTaskKind;
     /** The shell command, from the originating `tool_use` input. Null if unseen. */
     command: string | null;
     /** The tool call's human description ("Run the test suite"), if it carried one. */
@@ -68,8 +84,29 @@ export declare function isTerminalTaskStatus(status: string | null | undefined):
  * terminal that isn't recognisably a failure or a cancel is a plain completion.
  */
 export declare function toTerminalRecordStatus(status: string | null | undefined): Exclude<ClaudeBackgroundTaskStatus, "running">;
-/** Extract every background-task id announced in a Bash tool_result's text. */
+/**
+ * Extract every background-task id announced in a Bash tool_result's text.
+ *
+ * Bash shells only — kept at this name and signature because it is part of the
+ * module's public surface. For all tracked kinds use
+ * {@link extractBackgroundTaskStarts}.
+ */
 export declare function extractBackgroundTaskIds(text: string | null | undefined): string[];
+/** Ids of monitors started in this text. */
+export declare function extractMonitorTaskIds(text: string | null | undefined): string[];
+/** Ids of cron jobs scheduled in this text. */
+export declare function extractCronTaskIds(text: string | null | undefined): string[];
+/** Ids of cron jobs cancelled in this text (a cron's only retirement signal). */
+export declare function extractCancelledCronTaskIds(text: string | null | undefined): string[];
+/**
+ * Every background-work start announced in one tool_result, tagged by kind.
+ *
+ * This is the single place that decides "does this text start something that
+ * keeps the agent alive?". A new kind of background work is invisible until it
+ * is added HERE — which is precisely how monitors and crons went untracked
+ * while `deriveAgentStateBucket` happily reported those sessions as done.
+ */
+export declare function extractBackgroundTaskStarts(text: string | null | undefined): BackgroundTaskStart[];
 /** Extract the output-file path the harness announced alongside the id, if any. */
 export declare function extractBackgroundOutputFile(text: string | null | undefined): string | null;
 export declare class ClaudeBackgroundTaskTracker {

package/dist/server/server/agent/providers/claude/background-task-tracker.js

@@ -47,6 +47,45 @@ const BACKGROUND_ID_PATTERN = /Command running in background with ID:\s*([A-Za-z
  * path from the id (the directory is session-scoped and not derivable here).
  */
 const OUTPUT_FILE_PATTERN = /Output is being written to:\s*(\S+)/;
+/**
+ * Matches the harness line for a started **Monitor** (the long-running watcher
+ * tool), which announces itself with a completely different sentence from a
+ * backgrounded Bash:
+ *
+ *   Monitor started (task b6dxcqe9y, timeout 20000ms). You will be notified on
+ *   each event. Keep working — do not poll or sleep.
+ *
+ * The id is followed by a comma rather than a period, so it needs its own
+ * capture. Crucially the monitor's END is already handled: it retires through
+ * the SAME `<task-notification>` envelope carrying the same `<task-id>` and a
+ * `<status>completed</status>`. Only the start was invisible, which is why a
+ * session holding a live monitor reported zero background tasks and settled to
+ * "done" while the monitor was still watching.
+ *
+ * Captured verbatim from a live session on 2026-08-22, not transcribed.
+ */
+const MONITOR_ID_PATTERN = /Monitor started \(task\s+([A-Za-z0-9._-]+)/g;
+/**
+ * Matches a scheduled **cron** job's announcement. Two shapes, one per mode:
+ *
+ *   Scheduled one-shot task dcdae8f2 (17 4 1 1 *). Session-only ...
+ *   Scheduled recurring job b8df03d3 (Every Wednesday at 4:23 AM). Session-only ...
+ *
+ * Note the noun changes with the mode ("task" vs "job"), so both are accepted.
+ * Captured verbatim from a live session on 2026-08-22.
+ */
+const CRON_ID_PATTERN = /Scheduled\s+(?:one-shot|recurring)\s+(?:task|job)\s+([A-Za-z0-9._-]+)/g;
+/**
+ * Matches a cancelled cron job. A cron has no `<task-notification>`, so this
+ * tool_result line is its ONLY retirement signal:
+ *
+ *   Cancelled job b8df03d3.
+ *
+ * The trailing period is glued to the id — the exact defect class documented in
+ * {@link stripTrailingSentencePunctuation}. It is stripped, or the id would
+ * never match the record and the agent would sit in "pending" forever.
+ */
+const CRON_CANCEL_PATTERN = /Cancelled job\s+([A-Za-z0-9._-]+)/g;
 /**
  * Trim the sentence punctuation the harness's prose leaves glued to a capture.
  *
@@ -109,24 +148,66 @@ export function toTerminalRecordStatus(status) {
     }
     return "completed";
 }
-/** Extract every background-task id announced in a Bash tool_result's text. */
-export function extractBackgroundTaskIds(text) {
+/**
+ * Run one module-scoped global pattern over `text` and return every stripped
+ * capture. Shared by all start/cancel scanners so the two easy-to-forget
+ * details — resetting `lastIndex` on a module-scoped global regex, and
+ * stripping the sentence punctuation the harness's prose glues to a capture —
+ * are written once instead of per pattern.
+ */
+function scanIds(pattern, text) {
     if (typeof text !== "string" || text.length === 0) {
         return [];
     }
     const ids = [];
-    // Reset lastIndex defensively — the regex is module-scoped and global.
-    BACKGROUND_ID_PATTERN.lastIndex = 0;
-    let match = BACKGROUND_ID_PATTERN.exec(text);
+    pattern.lastIndex = 0;
+    let match = pattern.exec(text);
     while (match !== null) {
         const id = match[1] ? stripTrailingSentencePunctuation(match[1]) : "";
         if (id) {
             ids.push(id);
         }
-        match = BACKGROUND_ID_PATTERN.exec(text);
+        match = pattern.exec(text);
     }
     return ids;
 }
+/**
+ * Extract every background-task id announced in a Bash tool_result's text.
+ *
+ * Bash shells only — kept at this name and signature because it is part of the
+ * module's public surface. For all tracked kinds use
+ * {@link extractBackgroundTaskStarts}.
+ */
+export function extractBackgroundTaskIds(text) {
+    return scanIds(BACKGROUND_ID_PATTERN, text);
+}
+/** Ids of monitors started in this text. */
+export function extractMonitorTaskIds(text) {
+    return scanIds(MONITOR_ID_PATTERN, text);
+}
+/** Ids of cron jobs scheduled in this text. */
+export function extractCronTaskIds(text) {
+    return scanIds(CRON_ID_PATTERN, text);
+}
+/** Ids of cron jobs cancelled in this text (a cron's only retirement signal). */
+export function extractCancelledCronTaskIds(text) {
+    return scanIds(CRON_CANCEL_PATTERN, text);
+}
+/**
+ * Every background-work start announced in one tool_result, tagged by kind.
+ *
+ * This is the single place that decides "does this text start something that
+ * keeps the agent alive?". A new kind of background work is invisible until it
+ * is added HERE — which is precisely how monitors and crons went untracked
+ * while `deriveAgentStateBucket` happily reported those sessions as done.
+ */
+export function extractBackgroundTaskStarts(text) {
+    return [
+        ...extractBackgroundTaskIds(text).map((id) => ({ id, kind: "shell" })),
+        ...extractMonitorTaskIds(text).map((id) => ({ id, kind: "monitor" })),
+        ...extractCronTaskIds(text).map((id) => ({ id, kind: "cron" })),
+    ];
+}
 /** Extract the output-file path the harness announced alongside the id, if any. */
 export function extractBackgroundOutputFile(text) {
     if (typeof text !== "string" || text.length === 0) {
@@ -158,15 +239,19 @@ export class ClaudeBackgroundTaskTracker {
         const outputFile = extractBackgroundOutputFile(normalized.text);
         const startedAt = normalized.startedAt ?? new Date().toISOString();
         const added = [];
-        for (const id of extractBackgroundTaskIds(normalized.text)) {
+        for (const { id, kind } of extractBackgroundTaskStarts(normalized.text)) {
             if (this.running.has(id)) {
                 continue;
             }
             this.running.set(id, {
                 id,
+                kind,
                 command: normalized.command ?? null,
                 description: normalized.description ?? null,
-                outputFile,
+                // Only a backgrounded shell announces an output file on START. A
+                // monitor announces its own on its terminal notification instead, and a
+                // cron never has one.
+                outputFile: kind === "shell" ? outputFile : null,
                 startedAt,
                 endedAt: null,
                 status: "running",
@@ -174,6 +259,22 @@ export class ClaudeBackgroundTaskTracker {
             });
             added.push(id);
         }
+        // A cron has no `<task-notification>`, so its cancellation arrives as
+        // another tool_result in this same stream. Retire it here or it stays live
+        // forever and pins the agent to "pending" — the "never retires" failure
+        // this module already documents for a mis-captured shell id.
+        for (const id of extractCancelledCronTaskIds(normalized.text)) {
+            const record = this.running.get(id);
+            if (!record || record.kind !== "cron") {
+                continue;
+            }
+            this.running.delete(id);
+            this.retire({
+                ...record,
+                status: "canceled",
+                endedAt: new Date().toISOString(),
+            });
+        }
         return added;
     }
     /**
@@ -211,7 +312,11 @@ export class ClaudeBackgroundTaskTracker {
             return false;
         }
         this.running.delete(taskId);
-        this.retire({ ...record, status: "canceled", endedAt: new Date().toISOString() });
+        this.retire({
+            ...record,
+            status: "canceled",
+            endedAt: new Date().toISOString(),
+        });
         return true;
     }
     has(taskId) {