@hyperdrive.bot/fleet-server 0.3.99

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

@@ -0,0 +1,511 @@
+/**
+ * Tracks an agent's live Claude Code **background shells** (`Bash` invoked with
+ * `run_in_background: true`) so paseo can keep surfacing the agent as "Running"
+ * — and offer a dismiss — while those shells outlive the turn, and so the user
+ * can see WHAT is running the way the Claude Code CLI itself shows it: the
+ * command, how long it has been going, and the output it is writing.
+ *
+ * Why this exists: a backgrounded `Bash` returns its handle immediately, so the
+ * tool-call completes and the agent's lifecycle status settles to `idle` even
+ * though the shell is still alive. The liveness only shows up as two text
+ * signals in the (transport-agnostic) message stream paseo already ingests —
+ * the PTY transport feeds these by tailing Claude Code's transcript JSONL, the
+ * SDK transport by its message events, both converging on the same handler:
+ *
+ *   start → the Bash tool_result text: "Command running in background with ID: <id>"
+ *           plus "Output is being written to: <path>"
+ *   end   → a <task-notification> envelope carrying that same <id> + a terminal status
+ *
+ * Both carry the SAME id (e.g. `bjuk0pif4`), so we key the record set by it.
+ *
+ * The command itself is NOT in the tool_result — it lives in the matching
+ * `tool_use` block's input, which the caller already has cached. So the caller
+ * passes it in; this module never reaches for provider types.
+ *
+ * This module is pure (no SDK/PTY types, no filesystem) so it unit-tests
+ * cleanly and works regardless of transport. Anything that needs the disk (the
+ * output file's real birth time, reading the output back) is the caller's job.
+ */
+/**
+ * Matches the harness line emitted in a backgrounded Bash tool_result.
+ *
+ * The harness writes the id and the output path as PROSE on one line, each
+ * followed by a sentence period:
+ *
+ *   Command running in background with ID: beuhoixae. Output is being written
+ *   to: /tmp/.../beuhoixae.output. You will be notified when it completes.
+ *
+ * so both captures have to stop before that period. The dot cannot simply be
+ * dropped from the character classes (the path genuinely contains dots, and an
+ * id may), so trailing sentence punctuation is stripped after the match
+ * instead. See {@link stripTrailingSentencePunctuation}.
+ */
+const BACKGROUND_ID_PATTERN = /Command running in background with ID:\s*([A-Za-z0-9._-]+)/g;
+/**
+ * Matches the output-file line the harness emits next to the id. Captured so the
+ * daemon can read a running shell's output back on demand instead of guessing a
+ * 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;
+/**
+ * Matches the result of a **TaskStop**, which is the one way of ENDING that
+ * applies to every kind here and had no retirement path at all until 2026-08-29.
+ *
+ * A backgrounded shell or a monitor killed with TaskStop emits no
+ * `<task-notification>` (there is nothing left to notify), and its result says
+ * nothing like "Cancelled job", so the record sat in `running` forever and the
+ * session surfaced as Running while idle. Reproduced deterministically against a
+ * live daemon: `activeBackgroundTaskCount` stayed at 1 across a successful stop.
+ *
+ * Two captures rather than one, because the result arrives as a JSON object and
+ * reaches this parser via `JSON.stringify`, so the structured field is present
+ * and is the more reliable of the two. The prose is matched as well so a future
+ * plain-text result still retires.
+ *
+ * Captured verbatim from a live session on 2026-08-29:
+ *
+ *   {"message":"Successfully stopped task: bdzttg338 (sleep 400; echo done)",
+ *    "task_id":"bdzttg338","task_type":"local_bash","command":"sleep 400; echo done"}
+ */
+const TASK_STOP_PROSE_PATTERN = /Successfully stopped task:\s*([A-Za-z0-9._-]+)/g;
+const TASK_STOP_JSON_PATTERN = /"task_id"\s*:\s*"([A-Za-z0-9._-]+)"/g;
+/**
+ * Trim the sentence punctuation the harness's prose leaves glued to a capture.
+ *
+ * Not cosmetic. An id captured as `beuhoixae.` never matches the
+ * `<task-id>beuhoixae</task-id>` its own completion notification carries, so the
+ * shell never retires and the agent surfaces as Running forever. A path captured
+ * as `...beuhoixae.output.` does not exist on disk, so the output reads back
+ * empty. Both were live defects.
+ */
+function stripTrailingSentencePunctuation(value) {
+    return value.replace(/[.,;:!?]+$/, "");
+}
+/**
+ * How many finished shells to keep per agent. A shell that just completed is
+ * still interesting — its output is the reason it was backgrounded — so we keep
+ * a small tail rather than dropping it the instant the notification lands.
+ * Bounded so a long-lived agent can't grow this without limit.
+ */
+const FINISHED_RETENTION = 20;
+/**
+ * Task-notification statuses that mean the background shell is no longer alive.
+ * Compared case-insensitively; anything else (e.g. "running", "in_progress",
+ * "progress") is treated as still-alive and leaves the task running.
+ */
+const TERMINAL_STATUSES = new Set([
+    "completed",
+    "complete",
+    "failed",
+    "failure",
+    "error",
+    "killed",
+    "stopped",
+    "canceled",
+    "cancelled",
+    "timeout",
+    "timed_out",
+    "done",
+]);
+/** Statuses that mean the shell finished, but did not finish well. */
+const FAILED_STATUSES = new Set(["failed", "failure", "error", "timeout", "timed_out"]);
+/** Statuses that mean the shell was stopped on purpose rather than finishing. */
+const CANCELED_STATUSES = new Set(["killed", "stopped", "canceled", "cancelled"]);
+export function isTerminalTaskStatus(status) {
+    if (typeof status !== "string") {
+        return false;
+    }
+    return TERMINAL_STATUSES.has(status.trim().toLowerCase());
+}
+/**
+ * Map a notification's raw status onto the record's terminal status. Anything
+ * terminal that isn't recognisably a failure or a cancel is a plain completion.
+ */
+export function toTerminalRecordStatus(status) {
+    const normalized = typeof status === "string" ? status.trim().toLowerCase() : "";
+    if (FAILED_STATUSES.has(normalized)) {
+        return "failed";
+    }
+    if (CANCELED_STATUSES.has(normalized)) {
+        return "canceled";
+    }
+    return "completed";
+}
+/**
+ * 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 = [];
+    pattern.lastIndex = 0;
+    let match = pattern.exec(text);
+    while (match !== null) {
+        const id = match[1] ? stripTrailingSentencePunctuation(match[1]) : "";
+        if (id) {
+            ids.push(id);
+        }
+        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);
+}
+/**
+ * Ids stopped by TaskStop in this text. Unlike the cron cancel path this retires
+ * ANY kind, because TaskStop can end a shell, a monitor or a cron alike.
+ */
+export function extractStoppedTaskIds(text) {
+    const seen = new Set([
+        ...scanIds(TASK_STOP_PROSE_PATTERN, text),
+        ...scanIds(TASK_STOP_JSON_PATTERN, text),
+    ]);
+    return [...seen];
+}
+/**
+ * Which kinds a given tool is ALLOWED to announce.
+ *
+ * Scoping matters because the patterns are prose. Before this map every pattern
+ * ran against every result, so one `Bash` result registered a shell, a monitor
+ * and two crons at once - all four ids lifted out of a source file this very
+ * module documents itself with. A `Bash` can only ever start a shell; a
+ * `Monitor` can only ever start a monitor. Enforcing that removes three
+ * quarters of the surface for free.
+ */
+const START_KINDS_BY_TOOL = {
+    Bash: ["shell"],
+    Monitor: ["monitor"],
+    CronCreate: ["cron"],
+    CronDelete: [],
+    // Starts nothing. It only ever ENDS work, via STOP_SCANNING_TOOLS. This entry
+    // is not optional: the Record is keyed on the whole union, so omitting it is a
+    // type error, which is what caught it here rather than a crash in production.
+    TaskStop: [],
+};
+/**
+ * A cron's cancellation is announced by `CronDelete` and nothing else, so only
+ * that tool's result is scanned for it.
+ */
+const CANCEL_SCANNING_TOOLS = new Set(["CronDelete"]);
+/** Tools whose result may STOP work of any kind. See TASK_STOP_PROSE_PATTERN. */
+const STOP_SCANNING_TOOLS = new Set(["TaskStop"]);
+function isBackgroundWorkToolName(value) {
+    return (value === "Bash" ||
+        value === "Monitor" ||
+        value === "CronCreate" ||
+        value === "CronDelete" ||
+        value === "TaskStop");
+}
+/**
+ * Which start kinds may be read out of a result, given the tool that produced
+ * it. `null` means "no tool named, scan everything", the legacy behaviour kept
+ * for tests that feed a sample string directly. An unrecognised tool announces
+ * nothing.
+ */
+function resolveAllowedStartKinds(toolName) {
+    if (toolName === undefined || toolName === null) {
+        return null;
+    }
+    if (isBackgroundWorkToolName(toolName)) {
+        return START_KINDS_BY_TOOL[toolName];
+    }
+    return [];
+}
+/**
+ * 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.
+ *
+ * ⚠️ Matching is on PROSE, so it cannot tell an announcement from a QUOTE of
+ * one. Pass `toolName` and only the patterns that tool can actually emit are
+ * run. Omitting it keeps the legacy scan-everything behaviour and is for tests
+ * that feed a sample string directly; production must always pass it.
+ */
+export function extractBackgroundTaskStarts(text, toolName) {
+    const allowed = resolveAllowedStartKinds(toolName);
+    const allows = (kind) => allowed === null || allowed.includes(kind);
+    return [
+        ...(allows("shell")
+            ? extractBackgroundTaskIds(text).map((id) => ({ id, kind: "shell" }))
+            : []),
+        ...(allows("monitor")
+            ? extractMonitorTaskIds(text).map((id) => ({ id, kind: "monitor" }))
+            : []),
+        ...(allows("cron")
+            ? 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) {
+        return null;
+    }
+    const match = OUTPUT_FILE_PATTERN.exec(text);
+    if (!match?.[1]) {
+        return null;
+    }
+    const trimmed = stripTrailingSentencePunctuation(match[1]);
+    return trimmed.length > 0 ? trimmed : null;
+}
+export class ClaudeBackgroundTaskTracker {
+    constructor() {
+        /** Live shells, keyed by harness id, in the order they started. */
+        this.running = new Map();
+        /** Recently finished shells, oldest first, capped at {@link FINISHED_RETENTION}. */
+        this.finished = [];
+    }
+    /**
+     * Scan a Bash tool_result's text for background-shell launches and record each
+     * one as running. Returns the ids newly added (idempotent — re-seeing an id
+     * leaves the existing record untouched, which matters because the PTY
+     * transport replays the transcript on resume). Safe to call on any
+     * tool_result text; non-matching text adds none.
+     */
+    noteToolResultText(input) {
+        const normalized = typeof input === "string" || input === null || input === undefined ? { text: input } : input;
+        const toolName = normalized.toolName ?? undefined;
+        // A Bash that was NOT backgrounded cannot have started a background shell,
+        // whatever its output quotes. Only skip when we positively know the intent
+        // was false; `undefined` means unknown, and unknown falls back to the text.
+        if (toolName === "Bash" && normalized.backgrounded === false) {
+            return [];
+        }
+        const outputFile = extractBackgroundOutputFile(normalized.text);
+        const startedAt = normalized.startedAt ?? new Date().toISOString();
+        const added = [];
+        for (const { id, kind } of extractBackgroundTaskStarts(normalized.text, toolName)) {
+            if (this.running.has(id)) {
+                continue;
+            }
+            this.running.set(id, {
+                id,
+                kind,
+                command: normalized.command ?? null,
+                description: normalized.description ?? null,
+                // 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",
+                summary: null,
+            });
+            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.
+        const mayCancel = toolName === undefined || CANCEL_SCANNING_TOOLS.has(toolName);
+        for (const id of mayCancel ? 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(),
+            });
+        }
+        this.retireStoppedTasks(normalized.text, toolName);
+        return added;
+    }
+    /**
+     * Retire anything a TaskStop ended.
+     *
+     * TaskStop ends work of ANY kind and emits no `<task-notification>` (there is
+     * nothing left to notify), so this tool_result is its only retirement signal.
+     * Deliberately NOT filtered by `record.kind`, unlike the cron branch: only a
+     * cron uses the "Cancelled job" sentence, whereas TaskStop is universal.
+     */
+    retireStoppedTasks(text, toolName) {
+        // null and undefined both mean "no tool named, scan everything", matching
+        // resolveAllowedStartKinds. Narrowing only `undefined` leaves `string | null`,
+        // which Set.has rejects.
+        const mayStop = toolName === undefined || toolName === null || STOP_SCANNING_TOOLS.has(toolName);
+        if (!mayStop) {
+            return;
+        }
+        for (const id of extractStoppedTaskIds(text)) {
+            const record = this.running.get(id);
+            if (!record) {
+                continue;
+            }
+            this.running.delete(id);
+            this.retire({
+                ...record,
+                status: "canceled",
+                endedAt: new Date().toISOString(),
+            });
+        }
+    }
+    /**
+     * A `<task-notification>` arrived. If it carries a terminal status for a task
+     * we're tracking, move it out of the live set and into the finished tail.
+     * Returns true iff the live set changed. Unknown ids and non-terminal
+     * statuses are no-ops.
+     */
+    noteTaskNotification(input) {
+        const taskId = typeof input.taskId === "string" ? input.taskId.trim() : "";
+        if (!taskId) {
+            return false;
+        }
+        const record = this.running.get(taskId);
+        if (!record) {
+            return false;
+        }
+        if (!isTerminalTaskStatus(input.status)) {
+            return false;
+        }
+        this.running.delete(taskId);
+        this.retire({
+            ...record,
+            status: toTerminalRecordStatus(input.status),
+            endedAt: input.endedAt ?? new Date().toISOString(),
+            summary: input.summary ?? record.summary,
+            outputFile: record.outputFile ?? input.outputFile ?? null,
+        });
+        return true;
+    }
+    /** Explicit removal — e.g. the user dismissed/killed the shell from the UI. */
+    remove(taskId) {
+        const record = this.running.get(taskId);
+        if (!record) {
+            return false;
+        }
+        this.running.delete(taskId);
+        this.retire({
+            ...record,
+            status: "canceled",
+            endedAt: new Date().toISOString(),
+        });
+        return true;
+    }
+    has(taskId) {
+        return this.running.has(taskId);
+    }
+    /** Look up one record, live or recently finished. */
+    get(taskId) {
+        return this.running.get(taskId) ?? this.finished.find((task) => task.id === taskId) ?? null;
+    }
+    /** Count of still-alive background shells owned by this agent. */
+    get count() {
+        return this.running.size;
+    }
+    /** Snapshot of the live ids (start order), for surfacing a dismissable list. */
+    list() {
+        return [...this.running.keys()];
+    }
+    /**
+     * Full records: live shells first (start order), then the recently finished
+     * tail newest-first. This is what the UI renders.
+     */
+    listRecords() {
+        return [...this.running.values(), ...this.finished.toReversed()];
+    }
+    /**
+     * Stop every live shell and retire it as canceled, keeping the rows readable.
+     *
+     * This is the dismiss path: Claude Code's `ctrl+x ctrl+k` kills the session's
+     * background work wholesale, so every live shell ends at once. They are
+     * RETIRED rather than dropped because their output files still exist and a
+     * user who just stopped a build is exactly the user who wants to read why.
+     * Returns the ids that were stopped.
+     */
+    cancelAllRunning() {
+        const stopped = [...this.running.keys()];
+        const endedAt = new Date().toISOString();
+        for (const record of this.running.values()) {
+            this.retire({ ...record, status: "canceled", endedAt });
+        }
+        this.running.clear();
+        return stopped;
+    }
+    /**
+     * Drop every live shell without retiring it. Used when the session is torn
+     * down or restarted, where the shells die with the CLI and there is nothing
+     * left to show output for.
+     */
+    clear() {
+        this.running.clear();
+        this.finished = [];
+    }
+    retire(record) {
+        this.finished.push(record);
+        if (this.finished.length > FINISHED_RETENTION) {
+            this.finished = this.finished.slice(-FINISHED_RETENTION);
+        }
+    }
+}
+//# sourceMappingURL=background-task-tracker.js.map

package/dist/server/server/agent/providers/claude/background-work-kinds.d.ts

@@ -0,0 +1,124 @@
+/**
+ * The complete census of background work a Claude Code session can hold open.
+ *
+ * WHY THIS FILE EXISTS
+ *
+ * `deriveAgentStateBucket` ends in `return "done"`. That makes "done" the
+ * FALLTHROUGH: any kind of background work nobody taught the system about
+ * becomes invisible by construction, not by decision. Monitors and crons sat in
+ * that blind spot for the life of the feature — a session with an armed monitor
+ * reported zero background tasks, bucketed as "done", and looked idle while it
+ * was actively watching.
+ *
+ * The fix is not "remember to add a pattern". It is to enumerate what we
+ * SILENCE rather than what we want, so an unlisted kind is merely noisy (a
+ * failing build) instead of invisible (a lying UI).
+ *
+ * HOW IT FAILS LOUDLY
+ *
+ * `BACKGROUND_WORK_KINDS` is declared `satisfies Record<BackgroundWorkKind, …>`.
+ * Add a member to the union without adding its entry here and the TYPE CHECK
+ * fails. Add an entry claiming `tracked: true` without a start pattern that
+ * actually extracts its id and `background-work-kinds.test.ts` fails.
+ *
+ * ⚠️ A PATTERN IS NOT ENOUGH — THE TOOL NAME MUST BE GATED IN TOO
+ *
+ * `trackBackgroundShellStart` in `providers/claude/agent.ts` only forwards a
+ * tool_result to the parser when its tool name is in `BACKGROUND_WORK_TOOL_NAMES`.
+ * The first version of this file shipped monitor and cron patterns while that
+ * gate still read `toolName !== "Bash"`, so both were dead code in production
+ * and every test passed because the tests called the parser directly. A kind is
+ * only really tracked when it has: a start pattern, a retirement path, an entry
+ * here, AND its tool name in that set — proven by an integration test that goes
+ * through `handleToolResult`.
+ *
+ * SAMPLES ARE CAPTURES, NOT TRANSCRIPTIONS
+ *
+ * Every `sample` below was pasted verbatim out of a live session's tool_result
+ * on 2026-08-22. Do not tidy them. This repo has already shipped a regex that
+ * passed 21 green tests against hand-typed fixtures while being broken in
+ * production, because the real text was prose and every fixture was a clean
+ * one-liner. If you add a kind, capture its real string first.
+ */
+/** Every flavour of background work, tracked or deliberately not. */
+export type BackgroundWorkKind = "shell" | "monitor" | "cron" | "scheduled_wakeup" | "subagent";
+interface TrackedKind {
+    tracked: true;
+    /** Human label for the UI ("pending · monitoring deploy.log"). */
+    label: string;
+    /** Verbatim capture of the harness text that announces a start. */
+    sample: string;
+    /** The id the sample must yield, proving the pattern actually works. */
+    expectedId: string;
+    /**
+     * EVERY way this kind can be retired, not just its characteristic one.
+     *
+     * An array rather than a string because the original single value quietly
+     * modelled "the one way this ends", and a second way existed for all three
+     * tracked kinds that nothing here named: a TaskStop. It had no code path at
+     * all, so a stopped shell or monitor sat live forever and its session showed
+     * Running while idle (2026-08-29). Enumerating the paths is what makes an
+     * unlisted one a failing test instead of an invisible leak.
+     */
+    retiredBy: readonly string[];
+    /** Which module owns the tracking. */
+    trackedBy: string;
+    /**
+     * The tool name this kind's result arrives under. MUST be present in
+     * `BACKGROUND_WORK_TOOL_NAMES` (providers/claude/agent.ts) or the parser is
+     * never reached, however correct its pattern is.
+     */
+    toolName: string;
+}
+interface SilencedKind {
+    tracked: false;
+    label: string;
+    /**
+     * Why this kind does NOT keep an agent alive. Must be a real, specific
+     * reason — "not implemented yet" is one, and an honest one. What is not
+     * allowed is for a kind to be absent from this file entirely.
+     */
+    silencedBecause: string;
+}
+export type BackgroundWorkKindEntry = TrackedKind | SilencedKind;
+export declare const BACKGROUND_WORK_KINDS: {
+    readonly shell: {
+        readonly tracked: true;
+        readonly label: "background shell";
+        readonly sample: "Command running in background with ID: beuhoixae. Output is being written to: /tmp/x/beuhoixae.output. You will be notified when it completes.";
+        readonly expectedId: "beuhoixae";
+        readonly retiredBy: readonly ["<task-notification> with a terminal <status>", "\"Successfully stopped task: <id>\" in a TaskStop tool_result"];
+        readonly trackedBy: "ClaudeBackgroundTaskTracker.noteToolResultText";
+        readonly toolName: "Bash";
+    };
+    readonly monitor: {
+        readonly tracked: true;
+        readonly label: "monitor";
+        readonly sample: "Monitor started (task b6dxcqe9y, timeout 20000ms). You will be notified on each event. Keep working — do not poll or sleep.";
+        readonly expectedId: "b6dxcqe9y";
+        readonly retiredBy: readonly ["<task-notification> with a terminal <status>", "\"Successfully stopped task: <id>\" in a TaskStop tool_result"];
+        readonly trackedBy: "ClaudeBackgroundTaskTracker.noteToolResultText";
+        readonly toolName: "Monitor";
+    };
+    readonly cron: {
+        readonly tracked: true;
+        readonly label: "scheduled job";
+        readonly sample: "Scheduled recurring job b8df03d3 (Every Wednesday at 4:23 AM). Session-only (not written to disk, dies when Claude exits). Auto-expires after 7 days. Use CronDelete to cancel sooner.";
+        readonly expectedId: "b8df03d3";
+        readonly retiredBy: readonly ["\"Cancelled job <id>.\" in a later tool_result", "\"Successfully stopped task: <id>\" in a TaskStop tool_result"];
+        readonly trackedBy: "ClaudeBackgroundTaskTracker.noteToolResultText";
+        readonly toolName: "CronCreate";
+    };
+    readonly scheduled_wakeup: {
+        readonly tracked: false;
+        readonly label: "scheduled wakeup";
+        readonly silencedBecause: "ScheduleWakeup only exists inside /loop dynamic mode, and invoking it to capture its announcement would schedule a real wakeup of the capturing session. No verbatim capture has been taken yet, and this module's rule is that a pattern is written from a real string or not at all. A /loop session's transcript must be captured before this can move to tracked:true. Until then a dynamic /loop between wakeups buckets as done.";
+    };
+    readonly subagent: {
+        readonly tracked: false;
+        readonly label: "subagent";
+        readonly silencedBecause: "Live subagents DO keep the parent alive, but not through this tracker: they arrive as their own agent snapshots and are attributed to the delegation root in workspace-directory.applyAgentBucketContributions (server) and countActiveChildrenByParent (app). Counting them here as well would double-count them.";
+    };
+};
+export {};
+//# sourceMappingURL=background-work-kinds.d.ts.map