@fitchmultz/pi-subagents 0.44.6 → 0.45.0

package/dist/runs/background/async-job-tracker.js

@@ -1,383 +1,353 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { scanJournal } from "../../shared/journal-reader.js";
 import { renderWidget, widgetRenderKey } from "../../tui/render.js";
-import { formatControlNoticeMessage, isObsoleteIdleNotice } from "../shared/subagent-control.js";
-import { POLL_INTERVAL_MS, RESULTS_DIR, SUBAGENT_CONTROL_EVENT, SUBAGENT_CONTROL_INTERCOM_EVENT, } from "../../shared/types.js";
+import { POLL_INTERVAL_MS, RESULTS_DIR, } from "../../shared/types.js";
 import { readStatus } from "../../shared/utils.js";
-import { normalizeParallelGroups } from "./parallel-groups.js";
-import { reconcileAsyncRun, reconcileNestedAsyncDescendants } from "./stale-run-reconciler.js";
-import { attachRootChildrenToSteps, findNestedRouteForRootId, hasLiveNestedDescendants } from "../shared/nested-events.js";
+import { startedJob } from "./async-job-admission.js";
+import { reconcileAsyncRun } from "./stale-run-reconciler.js";
+import { findNestedRouteForRootId, hasLiveNestedDescendants } from "../shared/nested-events.js";
 import { asyncStatusToSummary, createAsyncRunDiscovery, listAsyncRuns } from "./async-status.js";
 import { isTuiContext } from "../../shared/ui-mode.js";
-import { exactAsyncRunLocation } from "./async-resume.js";
-export function createAsyncJobTracker(pi, state, asyncDirRoot, options = {}) {
-    const resultsDir = RESULTS_DIR;
-    let restoreDiscovery;
-    let restoreBoundary = 0;
-    let restoreDiscoveryDeadline = 0;
-    const rerenderWidget = (ctx, jobs = Array.from(state.asyncJobs.values())) => {
-        (options.render ?? renderWidget)(ctx, jobs);
-        const uiWithRender = ctx.ui;
-        uiWithRender.requestRender?.();
-    };
-    const cancelCleanup = (asyncId) => {
-        const existingTimer = state.cleanupTimers.get(asyncId);
-        if (!existingTimer)
-            return;
-        clearTimeout(existingTimer);
-        state.cleanupTimers.delete(asyncId);
-    };
-    const scheduleCleanup = (asyncId) => {
-        cancelCleanup(asyncId);
+import { exactAsyncRunLocation } from "./async-run-location.js";
+import { AsyncJobProjection } from "./async-job-projection.js";
+import { errorCode, hasText, isRecord } from "./async-value.js";
+import { parseAsyncStartedEvent } from "./run-schemas.js";
+function terminal(status) {
+    return (status === "complete" || status === "failed" || status === "blocked" || status === "paused");
+}
+function completionState(data) {
+    if (data.state === "blocked" || data.state === "paused") {
+        return data.state;
+    }
+    return data.success === true ? "complete" : "failed";
+}
+/** Owns job admission, restoration discovery, polling, and cleanup timers. */
+class AsyncJobTracker {
+    pi;
+    state;
+    asyncDirRoot;
+    options;
+    restoreDiscovery;
+    restoreBoundary = 0;
+    restoreDiscoveryDeadline = 0;
+    constructor(pi, state, asyncDirRoot, options) {
+        this.pi = pi;
+        this.state = state;
+        this.asyncDirRoot = asyncDirRoot;
+        this.options = options;
+    }
+    rerender(ctx, jobs = Array.from(this.state.asyncJobs.values())) {
+        (this.options.render ?? renderWidget)(ctx, jobs);
+        const ui = ctx.ui;
+        ui.requestRender?.();
+    }
+    rerenderCurrent() {
+        const ctx = this.state.lastUiContext;
+        if (ctx && isTuiContext(ctx)) {
+            this.rerender(ctx);
+        }
+    }
+    summarizeJob(job, status) {
+        return asyncStatusToSummary(job.asyncDir, status, [], job.nestedRoute ? (job.nestedChildren ?? []) : undefined);
+    }
+    cancelCleanup(id) {
+        const timer = this.state.cleanupTimers.get(id);
+        if (timer) {
+            clearTimeout(timer);
+            this.state.cleanupTimers.delete(id);
+        }
+    }
+    scheduleCleanup(id) {
+        this.cancelCleanup(id);
         const timer = setTimeout(() => {
-            state.cleanupTimers.delete(asyncId);
-            state.asyncJobs.delete(asyncId);
-            if (state.lastUiContext) {
-                rerenderWidget(state.lastUiContext);
+            this.state.cleanupTimers.delete(id);
+            this.state.asyncJobs.delete(id);
+            if (this.state.lastUiContext) {
+                this.rerender(this.state.lastUiContext);
             }
         }, 10000);
-        state.cleanupTimers.set(asyncId, timer);
-    };
-    const emitNewControlEvents = (job) => {
-        const eventsPath = path.join(job.asyncDir, "events.jsonl");
+        this.state.cleanupTimers.set(id, timer);
+    }
+    refreshNested(id) {
+        const job = this.state.asyncJobs.get(id);
+        if (!job) {
+            return false;
+        }
         try {
-            const stat = fs.statSync(eventsPath);
-            const identity = `${stat.dev}:${stat.ino}`;
-            if (job.controlEventIdentity !== identity || stat.size < (job.controlEventCursor ?? 0))
-                job.controlEventCursor = 0;
-            job.controlEventIdentity = identity;
-            if (stat.size === (job.controlEventCursor ?? 0))
-                return;
-            const cursor = scanJournal(eventsPath, (path) => !path.length || ["type", "event", "channels", "childIntercomTarget", "noticeText", "intercom"].includes(String(path[0])), ({ value, end }) => {
-                if (value?.type === "subagent.control") {
-                    const record = value;
-                    if (record.event?.type === "needs_attention" && Array.isArray(record.channels)
-                        && (job.controlEventSince === undefined || typeof record.event.ts === "number" && record.event.ts >= job.controlEventSince)) {
-                        const payload = { event: record.event, source: "async", asyncDir: job.asyncDir, childIntercomTarget: record.childIntercomTarget,
-                            noticeText: record.noticeText ?? formatControlNoticeMessage(record.event, record.childIntercomTarget) };
-                        if (!isObsoleteIdleNotice(payload)) {
-                            if (record.channels.includes("event"))
-                                pi.events.emit(SUBAGENT_CONTROL_EVENT, payload);
-                            if (record.channels.includes("intercom") && record.intercom?.to && record.intercom.message)
-                                pi.events.emit(SUBAGENT_CONTROL_INTERCOM_EVENT, { ...payload, to: record.intercom.to, message: record.intercom.message });
-                        }
-                    }
-                }
-                job.controlEventCursor = end;
-            }, { policy: "live", start: job.controlEventCursor ?? 0 });
-            job.controlEventCursor = cursor;
+            new AsyncJobProjection(job, this.pi.events).refreshNested();
+            return true;
         }
         catch (error) {
-            if (error.code !== "ENOENT")
-                console.error(`Failed to read async control events for '${job.asyncDir}':`, error);
+            console.error(`Failed to refresh nested async descendants for '${job.asyncDir}':`, error);
+            return false;
         }
-    };
-    const refreshNestedJob = (job) => {
-        if (!job.nestedRoute)
+    }
+    refreshJob(id, restored) {
+        const job = this.state.asyncJobs.get(id);
+        if (!job) {
+            return false;
+        }
+        const before = widgetRenderKey(job);
+        const projection = new AsyncJobProjection(job, this.pi.events);
+        try {
+            projection.emitNewControlEvents();
+            const nestedReady = this.refreshNested(id);
+            const reconciliation = restored.get(job.asyncDir) ??
+                reconcileAsyncRun(job.asyncDir, {
+                    resultsDir: RESULTS_DIR,
+                    startedRun: {
+                        runId: job.asyncId,
+                        pid: job.pid,
+                        sessionId: job.sessionId,
+                        mode: job.mode,
+                        agents: job.agents,
+                        chainStepCount: job.chainStepCount,
+                        parallelGroups: job.parallelGroups,
+                        startedAt: job.startedAt,
+                        sessionFile: job.sessionFile,
+                    },
+                });
+            const status = reconciliation.status ?? readStatus(job.asyncDir);
+            if (status) {
+                const previous = job.status;
+                projection.applySummary(this.summarizeJob(job, status));
+                this.reconcileCleanup(id, previous, nestedReady);
+            }
+            else {
+                projection.markRunning();
+            }
+        }
+        catch (error) {
+            if (job.status !== "failed") {
+                console.error(`Failed to read async status for '${job.asyncDir}':`, error);
+                projection.markFailed();
+            }
+            if (!hasLiveNestedDescendants(job.nestedChildren) && !this.state.cleanupTimers.has(id)) {
+                this.scheduleCleanup(id);
+            }
+        }
+        return widgetRenderKey(job) !== before;
+    }
+    reconcileCleanup(id, previous, nestedReady) {
+        const job = this.state.asyncJobs.get(id);
+        if (!job) {
             return;
-        job.nestedChildren = reconcileNestedAsyncDescendants(job.nestedRoute, { resultsDir });
-        attachRootChildrenToSteps(job.asyncId, job.steps, job.nestedChildren);
-    };
-    const ensurePoller = () => {
-        if (state.poller)
+        }
+        if (!terminal(job.status)) {
+            this.cancelCleanup(id);
             return;
-        state.poller = setInterval(() => {
-            let widgetChanged = false;
-            let restoredRecords = [];
-            if (restoreDiscovery) {
-                try {
-                    restoredRecords = restoreDiscovery();
-                    widgetChanged = discoverRestoredJobs(restoredRecords, true);
-                }
-                catch (error) {
-                    console.error("Failed to discover active async jobs:", error);
-                }
-                if (Date.now() >= restoreDiscoveryDeadline) {
-                    restoreDiscovery = undefined;
-                    restoreDiscoveryDeadline = 0;
-                }
+        }
+        if (nestedReady &&
+            !hasLiveNestedDescendants(job.nestedChildren) &&
+            (previous !== job.status || !this.state.cleanupTimers.has(id))) {
+            this.scheduleCleanup(id);
+        }
+    }
+    discoverDuringPoll() {
+        let records = [];
+        let changed = false;
+        if (this.restoreDiscovery) {
+            try {
+                records = this.restoreDiscovery();
+                changed = this.discoverRestoredJobs(records, true);
             }
-            if (state.asyncJobs.size === 0) {
-                if (restoreDiscovery)
-                    return;
-                if (state.lastUiContext && isTuiContext(state.lastUiContext))
-                    rerenderWidget(state.lastUiContext, []);
-                if (state.poller) {
-                    clearInterval(state.poller);
-                    state.poller = null;
-                }
+            catch (error) {
+                console.error("Failed to discover active async jobs:", error);
+            }
+            if (Date.now() >= this.restoreDiscoveryDeadline) {
+                this.restoreDiscovery = undefined;
+                this.restoreDiscoveryDeadline = 0;
+            }
+        }
+        return { records, changed };
+    }
+    poll() {
+        const discovery = this.discoverDuringPoll();
+        if (this.state.asyncJobs.size === 0) {
+            if (this.restoreDiscovery) {
                 return;
             }
-            const restoredByDir = new Map(restoredRecords.map((record) => [record.location.asyncDir, record]));
-            for (const job of state.asyncJobs.values()) {
-                const widgetStateBefore = widgetRenderKey(job);
-                let nestedRefreshFailed = false;
-                const refreshNestedProjection = () => {
-                    try {
-                        refreshNestedJob(job);
-                    }
-                    catch (error) {
-                        nestedRefreshFailed = true;
-                        console.error(`Failed to refresh nested async descendants for '${job.asyncDir}':`, error);
-                    }
-                };
-                try {
-                    emitNewControlEvents(job);
-                    refreshNestedProjection();
-                    const reconciliation = restoredByDir.get(job.asyncDir) ?? reconcileAsyncRun(job.asyncDir, {
-                        resultsDir,
-                        startedRun: {
-                            runId: job.asyncId,
-                            pid: job.pid,
-                            sessionId: job.sessionId,
-                            mode: job.mode,
-                            agents: job.agents,
-                            chainStepCount: job.chainStepCount,
-                            parallelGroups: job.parallelGroups,
-                            startedAt: job.startedAt,
-                            sessionFile: job.sessionFile,
-                        },
-                    });
-                    const status = reconciliation.status ?? readStatus(job.asyncDir);
-                    if (status) {
-                        const summary = asyncStatusToSummary(job.asyncDir, status, [], job.nestedRoute ? job.nestedChildren ?? [] : undefined);
-                        const previousStatus = job.status;
-                        job.status = summary.state;
-                        if (job.status !== "complete" && job.status !== "failed" && job.status !== "blocked" && job.status !== "paused")
-                            cancelCleanup(job.asyncId);
-                        job.sessionId = summary.sessionId ?? job.sessionId;
-                        job.activityState = summary.activityState;
-                        job.lastActivityAt = summary.lastActivityAt ?? job.lastActivityAt;
-                        job.currentTool = summary.currentTool;
-                        job.currentToolStartedAt = summary.currentToolStartedAt;
-                        job.currentPath = summary.currentPath;
-                        job.turnCount = summary.turnCount ?? job.turnCount;
-                        job.toolCount = summary.toolCount ?? job.toolCount;
-                        job.mode = summary.mode;
-                        job.currentStep = summary.currentStep ?? job.currentStep;
-                        job.chainStepCount = summary.chainStepCount ?? job.chainStepCount;
-                        job.startedAt = summary.startedAt;
-                        if (summary.lastUpdate !== undefined)
-                            job.updatedAt = summary.lastUpdate;
-                        if (summary.steps.length) {
-                            const groups = summary.parallelGroups ?? [];
-                            job.parallelGroups = groups.length ? groups : job.parallelGroups;
-                            const activeGroup = summary.currentStep !== undefined
-                                ? groups.find((group) => summary.currentStep >= group.start && summary.currentStep < group.start + group.count)
-                                : undefined;
-                            const visibleSteps = activeGroup
-                                ? summary.steps.slice(activeGroup.start, activeGroup.start + activeGroup.count)
-                                : summary.steps;
-                            job.activeParallelGroup = Boolean(activeGroup);
-                            job.agents = visibleSteps.map((step) => step.agent);
-                            job.steps = visibleSteps;
-                            attachRootChildrenToSteps(job.asyncId, job.steps, job.nestedChildren);
-                            job.stepsTotal = visibleSteps.length;
-                            job.runningSteps = visibleSteps.filter((step) => step.status === "running").length;
-                            job.completedSteps = visibleSteps.filter((step) => step.status === "complete" || step.status === "completed").length;
-                            if (summary.state === "complete")
-                                job.completedSteps = visibleSteps.length;
-                        }
-                        job.totalTokens = summary.totalTokens ?? job.totalTokens;
-                        job.sessionFile = summary.sessionFile ?? job.sessionFile;
-                        if ((job.status === "complete" || job.status === "failed" || job.status === "blocked" || job.status === "paused") && !nestedRefreshFailed && !hasLiveNestedDescendants(job.nestedChildren) && (previousStatus !== job.status || !state.cleanupTimers.has(job.asyncId))) {
-                            scheduleCleanup(job.asyncId);
-                        }
-                        if (widgetRenderKey(job) !== widgetStateBefore)
-                            widgetChanged = true;
-                        continue;
-                    }
-                    if (job.status === "queued") {
-                        job.status = "running";
-                        job.updatedAt = Date.now();
-                    }
-                }
-                catch (error) {
-                    if (job.status !== "failed") {
-                        console.error(`Failed to read async status for '${job.asyncDir}':`, error);
-                        job.status = "failed";
-                        job.updatedAt = Date.now();
-                    }
-                    if (!hasLiveNestedDescendants(job.nestedChildren) && !state.cleanupTimers.has(job.asyncId)) {
-                        scheduleCleanup(job.asyncId);
-                    }
-                }
-                if (widgetRenderKey(job) !== widgetStateBefore)
-                    widgetChanged = true;
+            if (this.state.lastUiContext && isTuiContext(this.state.lastUiContext)) {
+                this.rerender(this.state.lastUiContext, []);
+            }
+            if (this.state.poller) {
+                clearInterval(this.state.poller);
+                this.state.poller = null;
             }
-            if (widgetChanged && state.lastUiContext && isTuiContext(state.lastUiContext))
-                rerenderWidget(state.lastUiContext);
+            return;
+        }
+        const restored = new Map(discovery.records.map((record) => [record.location.asyncDir, record]));
+        let changed = discovery.changed;
+        for (const id of this.state.asyncJobs.keys()) {
+            changed = this.refreshJob(id, restored) || changed;
+        }
+        if (changed) {
+            this.rerenderCurrent();
+        }
+    }
+    ensurePoller = () => {
+        if (this.state.poller) {
+            return;
+        }
+        this.state.poller = setInterval(() => {
+            this.poll();
         }, POLL_INTERVAL_MS);
-        state.poller.unref?.();
+        this.state.poller.unref();
     };
-    const handleStarted = (data) => {
-        const info = data;
-        if (!info.id)
+    handleStarted = (data) => {
+        const info = parseAsyncStartedEvent(data);
+        if (!hasText(info.id)) {
             return;
-        const now = Date.now();
-        const asyncDir = info.asyncDir ?? exactAsyncRunLocation(info.id, asyncDirRoot, resultsDir).asyncDir ?? path.join(asyncDirRoot, info.id);
-        const rawAgents = info.agents?.length ? info.agents : info.chain && info.chain.length > 0 ? info.chain : info.agent ? [info.agent] : undefined;
-        const validParallelGroups = normalizeParallelGroups(info.parallelGroups, Number.MAX_SAFE_INTEGER, info.chainStepCount ?? Number.MAX_SAFE_INTEGER);
-        const firstGroup = validParallelGroups.find((group) => group.start === 0);
-        const firstGroupCount = firstGroup?.count;
-        const agents = firstGroupCount && firstGroupCount > 0
-            ? rawAgents?.slice(0, firstGroupCount)
-            : rawAgents;
-        state.asyncJobs.set(info.id, {
-            asyncId: info.id,
-            asyncDir,
-            status: "queued",
-            pid: typeof info.pid === "number" ? info.pid : undefined,
-            ...(typeof info.sessionId === "string" ? { sessionId: info.sessionId } : {}),
-            mode: info.mode ?? (info.chain ? "chain" : "single"),
-            agents,
-            chainStepCount: info.chainStepCount,
-            parallelGroups: validParallelGroups,
-            nestedRoute: info.nestedRoute,
-            stepsTotal: firstGroupCount ?? agents?.length,
-            activeParallelGroup: Boolean(firstGroupCount && firstGroupCount > 0),
-            startedAt: now,
-            updatedAt: now,
-        });
-        ensurePoller();
-        if (state.lastUiContext && isTuiContext(state.lastUiContext)) {
-            rerenderWidget(state.lastUiContext);
         }
+        const now = Date.now();
+        const asyncDir = info.asyncDir ??
+            exactAsyncRunLocation(info.id, this.asyncDirRoot, RESULTS_DIR).asyncDir ??
+            path.join(this.asyncDirRoot, info.id);
+        this.state.asyncJobs.set(info.id, startedJob(info.id, info, asyncDir, now));
+        this.ensurePoller();
+        this.rerenderCurrent();
     };
-    const handleComplete = (data) => {
-        const result = data;
-        const asyncId = result.id;
-        if (!asyncId)
+    handleComplete = (data) => {
+        if (!isRecord(data) || typeof data.id !== "string" || data.id.length === 0) {
             return;
-        const job = state.asyncJobs.get(asyncId);
-        let nestedRefreshFailed = false;
+        }
+        const job = this.state.asyncJobs.get(data.id);
+        let nestedReady = true;
         if (job) {
-            job.status = result.state === "blocked" ? "blocked" : result.state === "paused" ? "paused" : result.success ? "complete" : "failed";
-            job.updatedAt = Date.now();
-            if (result.asyncDir)
-                job.asyncDir = result.asyncDir;
+            new AsyncJobProjection(job, this.pi.events).complete(completionState(data), typeof data.asyncDir === "string" ? data.asyncDir : undefined);
+            nestedReady = this.refreshNested(data.id);
+        }
+        this.rerenderCurrent();
+        if (nestedReady && !hasLiveNestedDescendants(job?.nestedChildren)) {
+            this.scheduleCleanup(data.id);
+        }
+    };
+    controlCursor(run, sinceBoundary) {
+        let cursor = 0;
+        let since = sinceBoundary ? this.restoreBoundary : undefined;
+        // Late publications use the original restoration cut, not an EOF observed after discovery.
+        if (!sinceBoundary) {
             try {
-                refreshNestedJob(job);
+                cursor = fs.statSync(path.join(run.asyncDir, "events.jsonl")).size;
             }
             catch (error) {
-                nestedRefreshFailed = true;
-                console.error(`Failed to refresh nested async descendants for '${job.asyncDir}':`, error);
+                if (errorCode(error) !== "ENOENT") {
+                    since = this.restoreBoundary;
+                    console.error(`Failed to inspect async control events for '${run.asyncDir}':`, error);
+                }
             }
         }
-        if (state.lastUiContext && isTuiContext(state.lastUiContext)) {
-            rerenderWidget(state.lastUiContext);
+        return { controlEventCursor: cursor, controlEventSince: since };
+    }
+    restoredJob(run, sinceBoundary) {
+        const groups = run.parallelGroups ?? [];
+        const current = run.currentStep;
+        const active = current === undefined
+            ? undefined
+            : groups.find((group) => current >= group.start && current < group.start + group.count);
+        const steps = active ? run.steps.slice(active.start, active.start + active.count) : run.steps;
+        let nestedRoute;
+        try {
+            nestedRoute = findNestedRouteForRootId(run.id);
+        }
+        catch (error) {
+            console.error(`Failed to restore nested async descendants for '${run.asyncDir}':`, error);
         }
-        if (!nestedRefreshFailed && !hasLiveNestedDescendants(job?.nestedChildren))
-            scheduleCleanup(asyncId);
-    };
-    const discoverRestoredJobs = (records, sinceBoundary) => {
+        return {
+            asyncId: run.id,
+            asyncDir: run.asyncDir,
+            status: run.state,
+            pid: run.pid,
+            sessionId: run.sessionId,
+            activityState: run.activityState,
+            lastActivityAt: run.lastActivityAt,
+            currentTool: run.currentTool,
+            currentToolStartedAt: run.currentToolStartedAt,
+            currentPath: run.currentPath,
+            turnCount: run.turnCount,
+            toolCount: run.toolCount,
+            mode: run.mode,
+            agents: steps.map((step) => step.agent),
+            currentStep: run.currentStep,
+            chainStepCount: run.chainStepCount,
+            parallelGroups: groups,
+            steps: steps.map((step) => ({ ...step })),
+            stepsTotal: steps.length,
+            runningSteps: steps.filter((step) => step.status === "running").length,
+            completedSteps: steps.filter((step) => step.status === "complete" || step.status === "completed").length,
+            activeParallelGroup: active !== undefined,
+            startedAt: run.startedAt,
+            updatedAt: run.lastUpdate ?? run.startedAt,
+            totalTokens: run.totalTokens,
+            sessionFile: run.sessionFile,
+            ...this.controlCursor(run, sinceBoundary),
+            nestedRoute,
+            nestedChildren: run.nestedChildren,
+        };
+    }
+    discoverRestoredJobs(records, sinceBoundary) {
         let changed = false;
-        for (const run of listAsyncRuns(asyncDirRoot, {
+        for (const run of listAsyncRuns(this.asyncDirRoot, {
             states: ["queued", "running"],
             records,
-            resultsDir,
+            resultsDir: RESULTS_DIR,
             skipInvalid: true,
         })) {
-            if (state.asyncJobs.has(run.id))
+            if (this.state.asyncJobs.has(run.id)) {
                 continue;
-            const groups = run.parallelGroups ?? [];
-            const activeGroup = run.currentStep !== undefined
-                ? groups.find((group) => run.currentStep >= group.start && run.currentStep < group.start + group.count)
-                : undefined;
-            const steps = activeGroup
-                ? run.steps.slice(activeGroup.start, activeGroup.start + activeGroup.count)
-                : run.steps;
-            let controlEventCursor = 0;
-            let controlEventSince = sinceBoundary ? restoreBoundary : undefined;
-            // Shared discovery has already started. An EOF observed now could swallow
-            // attention appended during it; late publications use the same original cut.
-            if (!sinceBoundary)
-                try {
-                    controlEventCursor = fs.statSync(path.join(run.asyncDir, "events.jsonl")).size;
-                }
-                catch (error) {
-                    if (error.code !== "ENOENT") {
-                        controlEventSince = restoreBoundary;
-                        console.error(`Failed to inspect async control events for '${run.asyncDir}':`, error);
-                    }
-                }
-            let nestedRoute;
-            try {
-                nestedRoute = findNestedRouteForRootId(run.id);
-            }
-            catch (error) {
-                console.error(`Failed to restore nested async descendants for '${run.asyncDir}':`, error);
             }
-            state.asyncJobs.set(run.id, {
-                asyncId: run.id,
-                asyncDir: run.asyncDir,
-                status: run.state,
-                pid: run.pid,
-                sessionId: run.sessionId,
-                activityState: run.activityState,
-                lastActivityAt: run.lastActivityAt,
-                currentTool: run.currentTool,
-                currentToolStartedAt: run.currentToolStartedAt,
-                currentPath: run.currentPath,
-                turnCount: run.turnCount,
-                toolCount: run.toolCount,
-                mode: run.mode,
-                agents: steps.map((step) => step.agent),
-                currentStep: run.currentStep,
-                chainStepCount: run.chainStepCount,
-                parallelGroups: groups,
-                steps,
-                stepsTotal: steps.length,
-                runningSteps: steps.filter((step) => step.status === "running").length,
-                completedSteps: steps.filter((step) => step.status === "complete" || step.status === "completed").length,
-                activeParallelGroup: Boolean(activeGroup),
-                startedAt: run.startedAt,
-                updatedAt: run.lastUpdate ?? run.startedAt,
-                totalTokens: run.totalTokens,
-                sessionFile: run.sessionFile,
-                controlEventCursor,
-                controlEventSince,
-                nestedRoute,
-                nestedChildren: run.nestedChildren,
-            });
+            this.state.asyncJobs.set(run.id, this.restoredJob(run, sinceBoundary));
             changed = true;
         }
         return changed;
-    };
-    const restoreJobs = (sessionId, ctx, restoration) => {
-        restoreBoundary = restoration?.startedAt ?? Date.now();
-        restoreDiscovery = restoration?.discover ?? createAsyncRunDiscovery(asyncDirRoot, {
-            sessionId: ctx.sessionManager?.getSessionFile() ?? sessionId, ownerSessionId: ctx.sessionManager?.getSessionId(), resultsDir, skipInvalid: true,
-        });
-        restoreDiscoveryDeadline = restoreBoundary + 2_000;
+    }
+    restoreJobs = (sessionId, ctx, restoration) => {
+        this.restoreBoundary = restoration?.startedAt ?? Date.now();
+        this.restoreDiscovery =
+            restoration?.discover ??
+                createAsyncRunDiscovery(this.asyncDirRoot, {
+                    sessionId: ctx.sessionManager.getSessionFile() ?? sessionId,
+                    ownerSessionId: ctx.sessionManager.getSessionId(),
+                    resultsDir: RESULTS_DIR,
+                    skipInvalid: true,
+                });
+        this.restoreDiscoveryDeadline = this.restoreBoundary + 2_000;
         try {
-            discoverRestoredJobs(restoration?.records ?? restoreDiscovery(), Boolean(restoration));
+            this.discoverRestoredJobs(restoration?.records ?? this.restoreDiscovery(), restoration !== undefined);
         }
         catch (error) {
             console.error("Failed to discover active async jobs:", error);
         }
         if (isTuiContext(ctx)) {
-            state.lastUiContext = ctx;
-            rerenderWidget(ctx);
+            this.state.lastUiContext = ctx;
+            this.rerender(ctx);
         }
-        ensurePoller();
+        this.ensurePoller();
     };
-    const resetJobs = (ctx) => {
-        restoreDiscovery = undefined;
-        restoreBoundary = 0;
-        restoreDiscoveryDeadline = 0;
-        for (const timer of state.cleanupTimers.values()) {
+    resetJobs = (ctx) => {
+        this.restoreDiscovery = undefined;
+        this.restoreBoundary = 0;
+        this.restoreDiscoveryDeadline = 0;
+        for (const timer of this.state.cleanupTimers.values()) {
             clearTimeout(timer);
         }
-        state.cleanupTimers.clear();
-        state.asyncJobs.clear();
-        state.foregroundRuns?.clear();
-        state.resultFileCoalescer.clear();
+        this.state.cleanupTimers.clear();
+        this.state.asyncJobs.clear();
+        this.state.foregroundRuns?.clear();
+        this.state.resultFileCoalescer.clear();
         if (ctx && isTuiContext(ctx)) {
-            state.lastUiContext = ctx;
-            rerenderWidget(ctx, []);
+            this.state.lastUiContext = ctx;
+            this.rerender(ctx, []);
         }
     };
-    return { ensurePoller, handleStarted, handleComplete, restoreJobs, resetJobs };
+}
+export function createAsyncJobTracker(pi, state, asyncDirRoot, options = {}) {
+    const tracker = new AsyncJobTracker(pi, state, asyncDirRoot, options);
+    return {
+        ensurePoller: tracker.ensurePoller,
+        handleStarted: tracker.handleStarted,
+        handleComplete: tracker.handleComplete,
+        restoreJobs: tracker.restoreJobs,
+        resetJobs: tracker.resetJobs,
+    };
 }