@fitchmultz/pi-subagents 0.44.6 → 0.45.0

package/dist/runs/background/result-watcher.js

@@ -5,422 +5,431 @@ import { getRunMetadataDir } from "../shared/supervisor-questions.js";
 import { buildCompletionKey, markSeenWithTtl } from "./completion-dedupe.js";
 import { createFileCoalescer } from "../../shared/file-coalescer.js";
 import { journalStamp } from "../../shared/journal-reader.js";
-import { resolveOrchestratorIntercomTarget } from "../../intercom/intercom-bridge.js";
 import { SUBAGENT_ASYNC_COMPLETE_EVENT, } from "../../shared/types.js";
-import { attachNestedChildrenToResultChildren, buildSubagentResultIntercomPayload, compactNestedResultChildren, deliverSubagentResultIntercomEvent, resolveSubagentResultStatus, } from "../../intercom/result-intercom.js";
-import { projectNestedRegistryForRoot, sanitizeSummary } from "../shared/nested-events.js";
-import { isDurableRun, readAsyncResultFile } from "./async-result-file.js";
-const WATCHER_RESTART_DELAY_MS = 3000;
+import { completionEvent, deliverResultIntercom, prepareResult, readResultEnvelope, } from "./result-payload.js";
+import { errorCode, hasText } from "./async-value.js";
+const RESTART_DELAY_MS = 3000;
 const POLL_INTERVAL_MS = 3000;
-function sanitizeNestedResultChildren(value, resultPath, label) {
-    if (value === undefined)
-        return undefined;
-    if (!Array.isArray(value)) {
-        console.error(`Ignoring invalid nested children in subagent result file '${resultPath}' at ${label}: expected an array.`);
-        return undefined;
-    }
-    const children = value.map((child) => sanitizeSummary(child)).filter((child) => Boolean(child));
-    if (children.length !== value.length) {
-        console.error(`Ignoring ${value.length - children.length} invalid nested child record(s) in subagent result file '${resultPath}' at ${label}.`);
-    }
-    return children.length ? children : undefined;
+function notFound(error) {
+    return (errorCode(error) === "ENOENT" ||
+        errorCode(error instanceof Error ? error.cause : undefined) === "ENOENT");
 }
-function getErrorCode(error) {
-    return typeof error === "object" && error !== null && "code" in error
-        ? error.code
-        : undefined;
-}
-function isNotFoundError(error) {
-    if (getErrorCode(error) === "ENOENT")
-        return true;
-    const cause = error instanceof Error ? error.cause : undefined;
-    return getErrorCode(cause) === "ENOENT";
-}
-function shouldFallBackToPolling(error) {
-    const code = getErrorCode(error);
+function pollingRequired(error) {
+    const code = errorCode(error);
     return code === "EMFILE" || code === "ENOSPC";
 }
-export function createResultWatcher(pi, state, resultsDir, deps = {}) {
-    let periodicScanTimer = null;
-    const processingCompletionKeys = new Set();
-    const inFlight = new Set();
-    let startTail = Promise.resolve(), generation = 0, preserveBeforeGeneration = 0;
-    let joiningGeneration;
-    const foreignResults = new Map();
-    const pendingResultFiles = () => {
-        const files = fs.existsSync(resultsDir) ? fs.readdirSync(resultsDir).filter((name) => name.endsWith(".json")) : [];
+/** Owns admitted background deliveries, watcher resources, and shutdown generations. */
+class ResultWatcher {
+    pi;
+    state;
+    resultsDir;
+    deps;
+    periodicScanTimer = null;
+    processingCompletionKeys = new Set();
+    inFlight = new Set();
+    startTail = Promise.resolve();
+    generation = 0;
+    preserveBeforeGeneration = 0;
+    joiningGeneration;
+    foreignResults = new Map();
+    scheduled = new Set();
+    drainGeneration;
+    constructor(pi, state, resultsDir, deps) {
+        this.pi = pi;
+        this.state = state;
+        this.resultsDir = resultsDir;
+        this.deps = deps;
+        this.state.resultFileCoalescer = createFileCoalescer(this.scheduleResult, 50);
+    }
+    isForeignUnchanged(resultPath) {
+        const cached = this.foreignResults.get(resultPath);
+        if (!cached ||
+            cached.sessionId !== this.state.currentSessionId ||
+            cached.ownerSessionId !== this.state.ownedRuns?.get(cached.runId)?.ownerSessionId) {
+            return false;
+        }
+        return (cached.stamp === journalStamp(fs.statSync(resultPath, { bigint: true })) &&
+            (cached.canonicalPath === undefined ||
+                cached.canonicalStamp === journalStamp(fs.statSync(cached.canonicalPath, { bigint: true }))));
+    }
+    resultPath(file) {
+        return path.isAbsolute(file) ? file : path.join(this.resultsDir, file);
+    }
+    needsRecovery(run) {
+        return (run.source === "async" &&
+            (run.accounting?.state === "incomplete" || !hasText(run.delivery?.entryId)));
+    }
+    candidateFiles() {
+        const files = fs.existsSync(this.resultsDir)
+            ? fs.readdirSync(this.resultsDir).filter((name) => name.endsWith(".json"))
+            : [];
         const notified = new Map(files.map((file, index) => [file, index]));
-        for (const run of state.ownedRuns?.values() ?? []) {
-            if (run.source !== "async" || run.accounting?.state !== "incomplete" && run.delivery?.entryId)
+        for (const run of this.state.ownedRuns?.values() ?? []) {
+            if (!this.needsRecovery(run)) {
                 continue;
+            }
             const file = path.join(getRunMetadataDir(run.runId), "result.json");
-            if (!fs.existsSync(file))
+            if (!fs.existsSync(file)) {
                 continue;
+            }
             // Disposable hints cannot veto canonical recovery, including corrupt hints.
             const notification = notified.get(`${run.runId}.json`);
-            if (notification === undefined)
+            if (notification === undefined) {
                 files.push(file);
-            else
+            }
+            else {
                 files[notification] = file;
+            }
+        }
+        return files;
+    }
+    pendingResultFiles() {
+        const files = this.candidateFiles();
+        const present = new Set(files.map((file) => this.resultPath(file)));
+        for (const file of this.foreignResults.keys()) {
+            if (!present.has(file)) {
+                this.foreignResults.delete(file);
+            }
         }
-        const present = new Set(files.map((file) => path.isAbsolute(file) ? file : path.join(resultsDir, file)));
-        for (const file of foreignResults.keys())
-            if (!present.has(file))
-                foreignResults.delete(file);
         return files.filter((file) => {
-            const resultPath = path.isAbsolute(file) ? file : path.join(resultsDir, file);
+            const resultPath = this.resultPath(file);
             try {
-                return !isForeignUnchanged(resultPath);
+                return !this.isForeignUnchanged(resultPath);
             }
             catch (error) {
-                if (isNotFoundError(error)) {
-                    foreignResults.delete(resultPath);
+                if (notFound(error)) {
+                    this.foreignResults.delete(resultPath);
                     return false;
                 }
                 return true;
             }
         });
-    };
-    const isForeignUnchanged = (resultPath) => {
-        const cached = foreignResults.get(resultPath);
-        if (!cached || cached.sessionId !== state.currentSessionId || cached.ownerSessionId !== state.ownedRuns?.get(cached.runId)?.ownerSessionId)
+    }
+    foreign(envelope) {
+        const run = this.state.ownedRuns?.get(envelope.runId);
+        const sessionId = envelope.data.sessionId;
+        const foreign = hasText(sessionId)
+            ? sessionId !== this.state.currentSessionId &&
+                run?.ownerSessionId !== this.state.currentSessionId
+            : run === undefined;
+        if (foreign) {
+            this.foreignResults.set(envelope.resultPath, {
+                stamp: envelope.stamp,
+                sessionId: this.state.currentSessionId,
+                runId: envelope.runId,
+                ownerSessionId: run?.ownerSessionId,
+                canonicalPath: envelope.canonicalPath,
+                canonicalStamp: envelope.canonicalStamp,
+            });
+        }
+        else {
+            this.foreignResults.delete(envelope.resultPath);
+        }
+        return foreign;
+    }
+    consumeNotification(envelope, key) {
+        // Native queue admission is not publication. Retain the only legacy saved result until publication.
+        if (!envelope.durableFile &&
+            envelope.canonicalPath === undefined &&
+            this.deps.isCompletionPublished !== undefined &&
+            !this.deps.isCompletionPublished(envelope.runId, key)) {
+            return;
+        }
+        const hint = envelope.durableFile
+            ? path.join(this.resultsDir, `${envelope.runId}.json`)
+            : envelope.resultPath;
+        if (fs.existsSync(hint)) {
+            fs.unlinkSync(hint);
+        }
+    }
+    alreadyHandled(envelope, key) {
+        const handled = this.deps.reconcileDelivery === undefined
+            ? this.state.isRunResultConsumed?.(envelope.runId) === true
+            : this.deps.reconcileDelivery(envelope.runId, key);
+        if (handled) {
+            this.consumeNotification(envelope, key);
+            return true;
+        }
+        if (this.state.waitingRuns?.has(envelope.runId) === true) {
+            this.pi.events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, {
+                ...envelope.data,
+                runId: envelope.runId,
+                suppressNotification: true,
+                intercomResultDelivered: false,
+            });
+            return true;
+        }
+        return false;
+    }
+    claimCompletion(envelope, key) {
+        if (this.processingCompletionKeys.has(key)) {
             return false;
-        return cached.stamp === journalStamp(fs.statSync(resultPath, { bigint: true }))
-            && (!cached.canonicalPath || cached.canonicalStamp === journalStamp(fs.statSync(cached.canonicalPath, { bigint: true })));
-    };
-    const handleResult = async (file) => {
-        const startedGeneration = generation, ownerSessionId = state.currentSessionId;
-        let claimedCompletionKey;
-        let completionEmitted = false;
-        const durableFile = path.isAbsolute(file);
-        const resultPath = durableFile ? file : path.join(resultsDir, file);
-        if (!fs.existsSync(resultPath))
+        }
+        // Owned queue/receipt reconciliation remains authoritative after TTL expiry.
+        if (markSeenWithTtl(this.state.completionSeen, key, Date.now(), 10 * 60 * 1000)) {
+            this.consumeNotification(envelope, key);
+            return false;
+        }
+        this.processingCompletionKeys.add(key);
+        return true;
+    }
+    async deliverClaimed(envelope, prepared, key, ownership) {
+        const delivered = await deliverResultIntercom(this.pi.events, envelope, prepared);
+        // Stop/session callbacks may change generation and owner during suspension.
+        if ((ownership.generation !== this.generation &&
+            ownership.generation !== this.joiningGeneration) ||
+            ownership.sessionId !== this.state.currentSessionId) {
+            this.state.completionSeen.delete(key);
+            return false;
+        }
+        // Shutdown closes native turn ingress; accepted acknowledgements are still recorded.
+        if (!delivered && ownership.generation < this.preserveBeforeGeneration) {
+            return false;
+        }
+        this.pi.events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, completionEvent(envelope, prepared, key, delivered));
+        return true;
+    }
+    releaseCompletion(key, emitted) {
+        if (!hasText(key)) {
             return;
+        }
+        this.processingCompletionKeys.delete(key);
+        if (!emitted) {
+            this.state.completionSeen.delete(key);
+        }
+    }
+    handleResult = async (file) => {
+        const startedGeneration = this.generation;
+        const ownerSessionId = this.state.currentSessionId;
+        let claimed;
+        let emitted = false;
+        const resultPath = this.resultPath(file);
+        if (!fs.existsSync(resultPath)) {
+            return;
+        }
         try {
-            if (isForeignUnchanged(resultPath))
-                return;
-            const stamp = journalStamp(fs.statSync(resultPath, { bigint: true }));
-            const notification = readAsyncResultFile(resultPath);
-            const runId = notification.runId ?? notification.id ?? path.basename(file, ".json");
-            const run = state.ownedRuns?.get(runId);
-            const canonicalPath = isDurableRun(notification) && !durableFile ? path.join(getRunMetadataDir(runId), "result.json") : undefined;
-            const canonicalStamp = canonicalPath ? journalStamp(fs.statSync(canonicalPath, { bigint: true })) : undefined;
-            const data = canonicalPath ? readAsyncResultFile(canonicalPath) : notification;
-            if ((data.runId ?? data.id ?? runId) !== runId)
-                throw new Error(`Result identity does not match notification '${runId}'.`);
-            if (durableFile && resultPath !== path.join(getRunMetadataDir(runId), "result.json"))
-                throw new Error(`Canonical result identity does not match path '${resultPath}'.`);
-            if (data.sessionId ? data.sessionId !== state.currentSessionId && run?.ownerSessionId !== state.currentSessionId : !run) {
-                if (stamp)
-                    foreignResults.set(resultPath, { stamp, sessionId: state.currentSessionId, runId, ownerSessionId: run?.ownerSessionId, canonicalPath, canonicalStamp });
+            if (this.isForeignUnchanged(resultPath)) {
                 return;
             }
-            foreignResults.delete(resultPath);
-            const consumeNotification = () => {
-                // A legacy hint can be the only saved result. Native queue admission
-                // is not publication; retain it until the verified parent receipt exists.
-                if (!durableFile && !canonicalPath && deps.isCompletionPublished && !deps.isCompletionPublished(runId, completionKey))
-                    return;
-                const hint = durableFile ? path.join(resultsDir, `${runId}.json`) : resultPath;
-                if (fs.existsSync(hint))
-                    fs.unlinkSync(hint);
-            };
-            data.completionId ??= `legacy:${runId}:${data.timestamp ?? "unknown"}`;
-            const completionKey = buildCompletionKey({ ...data, id: runId }, "result");
-            if (deps.reconcileDelivery ? deps.reconcileDelivery(runId, completionKey) : state.isRunResultConsumed?.(runId)) {
-                consumeNotification();
+            const envelope = readResultEnvelope(file, this.resultsDir);
+            if (this.foreign(envelope)) {
                 return;
             }
-            if (state.waitingRuns?.has(runId)) {
-                pi.events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, { ...data, runId, suppressNotification: true, intercomResultDelivered: false });
+            const key = buildCompletionKey({ ...envelope.data, id: envelope.runId }, "result");
+            if (this.alreadyHandled(envelope, key)) {
                 return;
             }
-            const hasExplicitNestedChildren = data.nestedChildren !== undefined;
-            let nestedChildren = compactNestedResultChildren(sanitizeNestedResultChildren(data.nestedChildren, resultPath, "nestedChildren"));
-            if (!nestedChildren?.length && !hasExplicitNestedChildren) {
-                try {
-                    nestedChildren = compactNestedResultChildren(projectNestedRegistryForRoot(runId)?.children);
-                }
-                catch (error) {
-                    console.error(`Failed to enrich subagent result file '${resultPath}' with nested registry children; will retry later:`, error);
-                    return;
-                }
-            }
-            const hasResultChildren = Array.isArray(data.results) && data.results.length > 0;
-            const resultChildren = hasResultChildren
-                ? data.results
-                : [{
-                        agent: data.agent,
-                        output: data.summary,
-                        success: data.success,
-                    }];
-            const normalizedChildren = attachNestedChildrenToResultChildren(runId, resultChildren.map((result = {}, index) => {
-                const baseOutput = result.output ?? result.finalOutput ?? data.summary;
-                const hasRealOutput = typeof baseOutput === "string" && baseOutput.trim().length > 0;
-                const output = hasRealOutput ? baseOutput : "(no output)";
-                const summary = result.success === false && result.error
-                    ? `${result.error}${hasRealOutput ? `\n\nOutput:\n${baseOutput}` : ""}`
-                    : output;
-                const sessionPath = result.sessionFile ?? (resultChildren.length === 1 ? data.sessionFile : undefined);
-                const childNestedChildren = sanitizeNestedResultChildren(result.children, resultPath, `results[${index}].children`);
-                return {
-                    agent: result.agent ?? data.agent ?? `step-${index + 1}`,
-                    status: resolveSubagentResultStatus({
-                        success: result.success,
-                        exitCode: result.exitCode ?? undefined,
-                        acceptance: result.acceptance,
-                        interrupted: result.interrupted,
-                        state: result.interrupted || typeof result.success !== "boolean" ? data.state : undefined,
-                    }),
-                    summary,
-                    index,
-                    artifactPath: result.artifactPaths?.outputPath,
-                    metadataPath: result.artifactPaths?.metadataPath,
-                    ...(typeof sessionPath === "string" && fs.existsSync(sessionPath) ? { sessionPath } : {}),
-                    ...(result.intercomTarget ? { intercomTarget: result.intercomTarget } : {}),
-                    ...(childNestedChildren ? { children: childNestedChildren } : {}),
-                };
-            }), nestedChildren);
-            if (processingCompletionKeys.has(completionKey))
-                return;
-            // Owned queue/receipt reconciliation above remains authoritative after TTL expiry.
-            if (markSeenWithTtl(state.completionSeen, completionKey, Date.now(), 10 * 60 * 1000)) {
-                consumeNotification();
+            const prepared = prepareResult(envelope);
+            if (prepared === undefined) {
                 return;
             }
-            processingCompletionKeys.add(completionKey);
-            claimedCompletionKey = completionKey;
-            // Saved ownership is stable; the owner's live intercom identity can change on restart.
-            const intercomTarget = resolveOrchestratorIntercomTarget(pi.events, data.intercomTarget?.trim() ?? "");
-            let intercomResultDelivered = false;
-            if (intercomTarget) {
-                const mode = data.mode === "single" || data.mode === "parallel" || data.mode === "chain"
-                    ? data.mode
-                    : resultChildren.length > 1 ? "chain" : "single";
-                const savedResultPath = path.join(getRunMetadataDir(runId), "result.json");
-                const payload = buildSubagentResultIntercomPayload({
-                    to: intercomTarget,
-                    runId,
-                    completionId: data.completionId,
-                    mode,
-                    source: "async",
-                    ...(fs.existsSync(savedResultPath) ? { resultPath: savedResultPath } : {}),
-                    status: resolveSubagentResultStatus({ state: data.terminalState }),
-                    error: data.workflowGraph?.nodes.find((node) => node.error)?.error,
-                    children: normalizedChildren,
-                    asyncId: data.id,
-                    asyncDir: data.asyncDir,
-                });
-                intercomResultDelivered = await deliverSubagentResultIntercomEvent(pi.events, payload);
-            }
-            if (startedGeneration !== generation && startedGeneration !== joiningGeneration || ownerSessionId !== state.currentSessionId) {
-                state.completionSeen.delete(completionKey);
+            if (!this.claimCompletion(envelope, key)) {
                 return;
             }
-            // Shutdown closes native turn ingress. Retain failed deliveries for the
-            // next startup, while still recording acknowledgements already accepted.
-            if (!intercomResultDelivered && startedGeneration < preserveBeforeGeneration)
-                return;
-            const { terminalState: _terminalState, ...eventData } = data;
-            pi.events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, {
-                ...eventData,
-                agent: data.agent ?? normalizedChildren.map((child) => child.agent).join(", "),
-                summary: data.summary?.trim() ? data.summary : normalizedChildren.map((child) => child.summary).join("\n\n"),
-                runId,
-                completionKey,
-                intercomResultDelivered,
-                ...(nestedChildren?.length ? { nestedChildren } : {}),
-                ...(Array.isArray(data.results) ? {
-                    results: hasResultChildren
-                        ? normalizedChildren.map((child, index) => ({
-                            ...data.results[index],
-                            agent: child.agent,
-                            status: child.status,
-                            summary: child.summary,
-                            index: child.index,
-                            artifactPath: child.artifactPath,
-                            sessionPath: child.sessionPath,
-                            children: child.children,
-                        }))
-                        : [],
-                } : {}),
+            claimed = key;
+            emitted = await this.deliverClaimed(envelope, prepared, key, {
+                generation: startedGeneration,
+                sessionId: ownerSessionId,
             });
-            completionEmitted = true;
-            consumeNotification();
+            if (emitted) {
+                this.consumeNotification(envelope, key);
+            }
         }
         catch (error) {
-            if (isNotFoundError(error))
-                return;
-            console.error(`Failed to process subagent result file '${resultPath}':`, error);
+            if (!notFound(error)) {
+                console.error(`Failed to process subagent result file '${resultPath}':`, error);
+            }
         }
         finally {
-            if (claimedCompletionKey) {
-                processingCompletionKeys.delete(claimedCompletionKey);
-                if (!completionEmitted)
-                    state.completionSeen.delete(claimedCompletionKey);
-            }
+            this.releaseCompletion(claimed, emitted);
         }
     };
-    const scheduled = new Set();
-    let drainGeneration;
-    const scheduleResult = (file) => {
-        scheduled.add(file);
-        if (drainGeneration === generation)
-            return;
-        drainGeneration = generation;
-        const scheduledGeneration = generation;
-        startTail = startTail.then(async () => {
-            try {
-                while (scheduled.size) {
-                    await yieldToInput();
-                    if (scheduledGeneration !== generation)
-                        return;
-                    const files = [...scheduled].slice(0, 4);
-                    for (const file of files)
-                        scheduled.delete(file);
-                    // Only synchronous starts share publication proof. Async delivery
-                    // resumes outside this scope; yield between batches for native input.
-                    const start = () => {
-                        for (const file of files) {
-                            if (scheduledGeneration !== generation)
-                                return;
-                            const tail = handleResult(file);
-                            inFlight.add(tail);
-                            void tail.finally(() => inFlight.delete(tail));
-                        }
-                    };
-                    if (deps.withReceiptBatch)
-                        deps.withReceiptBatch(start);
-                    else
-                        start();
+    startBatch(files, generation) {
+        for (const file of files) {
+            if (generation !== this.generation) {
+                return;
+            }
+            const tail = this.handleResult(file)
+                .catch((error) => {
+                console.error(`Subagent delivery failed for '${file}':`, error);
+            })
+                .finally(() => {
+                this.inFlight.delete(tail);
+            });
+            this.inFlight.add(tail);
+        }
+    }
+    async drain(generation) {
+        try {
+            while (this.scheduled.size > 0) {
+                // Batches yield to native input; later starts depend on this generation guard.
+                // oxlint-disable-next-line no-await-in-loop
+                await yieldToInput();
+                if (generation !== this.generation) {
+                    return;
+                }
+                const files = [...this.scheduled].slice(0, 4);
+                for (const file of files) {
+                    this.scheduled.delete(file);
+                }
+                const start = () => {
+                    this.startBatch(files, generation);
+                };
+                if (this.deps.withReceiptBatch) {
+                    this.deps.withReceiptBatch(start);
+                }
+                else {
+                    start();
                 }
             }
-            finally {
-                if (drainGeneration === scheduledGeneration)
-                    drainGeneration = undefined;
+        }
+        finally {
+            if (this.drainGeneration === generation) {
+                this.drainGeneration = undefined;
             }
+        }
+    }
+    scheduleResult = (file) => {
+        this.scheduled.add(file);
+        if (this.drainGeneration === this.generation) {
+            return;
+        }
+        this.drainGeneration = this.generation;
+        const generation = this.generation;
+        this.startTail = this.startTail
+            .then(() => this.drain(generation))
+            .catch((error) => {
+            console.error("Failed to drain admitted subagent results:", error);
         });
     };
-    state.resultFileCoalescer = createFileCoalescer(scheduleResult, 50);
-    const primeExistingResults = () => {
+    primeExistingResults = () => {
         try {
-            // Admit one recovery scan synchronously; separate zero-delay file timers
-            // can split the same scan into additional verification batches.
-            pendingResultFiles().forEach(scheduleResult);
+            this.pendingResultFiles().forEach(this.scheduleResult);
         }
         catch (error) {
-            if (isNotFoundError(error))
-                return;
-            console.error(`Failed to scan subagent result directory '${resultsDir}':`, error);
+            if (!notFound(error)) {
+                console.error(`Failed to scan subagent result directory '${this.resultsDir}':`, error);
+            }
         }
     };
-    const ensurePeriodicScan = () => {
-        if (periodicScanTimer)
+    ensurePeriodicScan() {
+        if (this.periodicScanTimer) {
             return;
-        periodicScanTimer = setInterval(primeExistingResults, POLL_INTERVAL_MS);
-        periodicScanTimer.unref?.();
-    };
-    const clearPeriodicScan = () => {
-        if (!periodicScanTimer)
-            return;
-        clearInterval(periodicScanTimer);
-        periodicScanTimer = null;
-    };
-    const startPollingFallback = (reason) => {
-        state.watcher?.close();
-        state.watcher = null;
-        clearPeriodicScan();
-        if (state.watcherRestartTimer)
+        }
+        this.periodicScanTimer = setInterval(this.primeExistingResults, POLL_INTERVAL_MS);
+        this.periodicScanTimer.unref();
+    }
+    clearPeriodicScan() {
+        if (this.periodicScanTimer) {
+            clearInterval(this.periodicScanTimer);
+            this.periodicScanTimer = null;
+        }
+    }
+    startPollingFallback(reason) {
+        this.state.watcher?.close();
+        this.state.watcher = null;
+        this.clearPeriodicScan();
+        if (this.state.watcherRestartTimer) {
             return;
-        console.error(`Subagent result watcher for '${resultsDir}' fell back to polling because native fs.watch is unavailable (${getErrorCode(reason) ?? "unknown error"}).`);
-        primeExistingResults();
-        state.watcherRestartTimer = setInterval(primeExistingResults, POLL_INTERVAL_MS);
-        state.watcherRestartTimer.unref?.();
-    };
-    const scheduleRestart = () => {
-        if (state.watcherRestartTimer)
+        }
+        console.error(`Subagent result watcher for '${this.resultsDir}' fell back to polling because native fs.watch is unavailable (${errorCode(reason) ?? "unknown error"}).`);
+        this.primeExistingResults();
+        this.state.watcherRestartTimer = setInterval(this.primeExistingResults, POLL_INTERVAL_MS);
+        this.state.watcherRestartTimer.unref();
+    }
+    scheduleRestart() {
+        if (this.state.watcherRestartTimer) {
             return;
-        state.watcherRestartTimer = setTimeout(() => {
-            state.watcherRestartTimer = null;
+        }
+        this.state.watcherRestartTimer = setTimeout(() => {
+            this.state.watcherRestartTimer = null;
             try {
-                fs.mkdirSync(resultsDir, { recursive: true });
-                startResultWatcher();
+                fs.mkdirSync(this.resultsDir, { recursive: true });
+                this.startResultWatcher();
             }
             catch (error) {
-                if (shouldFallBackToPolling(error)) {
-                    startPollingFallback(error);
+                if (pollingRequired(error)) {
+                    this.startPollingFallback(error);
                     return;
                 }
-                console.error(`Failed to restart subagent result watcher for '${resultsDir}':`, error);
-                scheduleRestart();
+                console.error(`Failed to restart subagent result watcher for '${this.resultsDir}':`, error);
+                this.scheduleRestart();
             }
-        }, WATCHER_RESTART_DELAY_MS);
-        state.watcherRestartTimer.unref?.();
-    };
-    const startResultWatcher = () => {
-        if (state.watcher) {
-            ensurePeriodicScan();
+        }, RESTART_DELAY_MS);
+        this.state.watcherRestartTimer.unref();
+    }
+    startResultWatcher = () => {
+        if (this.state.watcher) {
+            this.ensurePeriodicScan();
             return;
         }
-        if (state.watcherRestartTimer) {
-            clearTimeout(state.watcherRestartTimer);
-            clearInterval(state.watcherRestartTimer);
-            state.watcherRestartTimer = null;
+        if (this.state.watcherRestartTimer) {
+            clearTimeout(this.state.watcherRestartTimer);
+            clearInterval(this.state.watcherRestartTimer);
+            this.state.watcherRestartTimer = null;
         }
         try {
-            state.watcher = fs.watch(resultsDir, (ev, file) => {
-                if (ev !== "rename" || !file)
+            this.state.watcher = fs.watch(this.resultsDir, (event, file) => {
+                if (event !== "rename" || !hasText(file)) {
                     return;
-                const fileName = file.toString();
-                if (!fileName.endsWith(".json"))
-                    return;
-                if (!fs.existsSync(path.join(resultsDir, fileName)))
-                    return;
-                state.resultFileCoalescer.schedule(fileName);
+                }
+                if (file.endsWith(".json") && fs.existsSync(path.join(this.resultsDir, file))) {
+                    this.state.resultFileCoalescer.schedule(file);
+                }
             });
-            state.watcher.on("error", (error) => {
-                if (shouldFallBackToPolling(error)) {
-                    startPollingFallback(error);
+            this.state.watcher.on("error", (error) => {
+                if (pollingRequired(error)) {
+                    this.startPollingFallback(error);
                     return;
                 }
-                console.error(`Subagent result watcher failed for '${resultsDir}':`, error);
-                state.watcher?.close();
-                state.watcher = null;
-                scheduleRestart();
+                console.error(`Subagent result watcher failed for '${this.resultsDir}':`, error);
+                this.state.watcher?.close();
+                this.state.watcher = null;
+                this.scheduleRestart();
             });
-            state.watcher.unref?.();
-            ensurePeriodicScan();
+            this.state.watcher.unref();
+            this.ensurePeriodicScan();
         }
         catch (error) {
-            if (shouldFallBackToPolling(error)) {
-                startPollingFallback(error);
+            if (pollingRequired(error)) {
+                this.startPollingFallback(error);
                 return;
             }
-            console.error(`Failed to start subagent result watcher for '${resultsDir}':`, error);
-            state.watcher = null;
-            scheduleRestart();
+            console.error(`Failed to start subagent result watcher for '${this.resultsDir}':`, error);
+            this.state.watcher = null;
+            this.scheduleRestart();
+        }
+    };
+    stopResultWatcher = (options = {}) => {
+        this.joiningGeneration = options.joinInFlight === true ? this.generation : undefined;
+        this.generation++;
+        if (options.preservePending === true) {
+            this.preserveBeforeGeneration = this.generation;
         }
+        this.state.watcher?.close();
+        this.state.watcher = null;
+        this.clearPeriodicScan();
+        if (this.state.watcherRestartTimer) {
+            clearTimeout(this.state.watcherRestartTimer);
+            clearInterval(this.state.watcherRestartTimer);
+        }
+        this.state.watcherRestartTimer = null;
+        this.state.resultFileCoalescer.clear();
+        this.scheduled.clear();
+        this.foreignResults.clear();
     };
-    const stopResultWatcher = (options = {}) => {
-        joiningGeneration = options.joinInFlight ? generation : undefined;
-        generation++;
-        if (options.preservePending)
-            preserveBeforeGeneration = generation;
-        state.watcher?.close();
-        state.watcher = null;
-        clearPeriodicScan();
-        if (state.watcherRestartTimer) {
-            clearTimeout(state.watcherRestartTimer);
-            clearInterval(state.watcherRestartTimer);
-        }
-        state.watcherRestartTimer = null;
-        state.resultFileCoalescer.clear();
-        scheduled.clear();
-        foreignResults.clear();
+    joinInFlight = async () => {
+        await this.startTail;
+        await Promise.all(this.inFlight);
+        this.joiningGeneration = undefined;
     };
-    const joinInFlight = async () => {
-        await Promise.all([...inFlight]);
-        joiningGeneration = undefined;
+}
+export function createResultWatcher(pi, state, resultsDir, deps = {}) {
+    const watcher = new ResultWatcher(pi, state, resultsDir, deps);
+    return {
+        startResultWatcher: watcher.startResultWatcher,
+        primeExistingResults: watcher.primeExistingResults,
+        stopResultWatcher: watcher.stopResultWatcher,
+        joinInFlight: watcher.joinInFlight,
     };
-    return { startResultWatcher, primeExistingResults, stopResultWatcher, joinInFlight };
 }