@agents-tower/core 0.1.0

package/dist/live-monitor.js

@@ -0,0 +1,1461 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectLiveMonitor = exports.shouldMarkThreadStoppedFromAppServerNotification = exports.shouldMarkThreadLiveFromAppServerNotification = exports.buildRolloutHookEvent = exports.parseApplyPatchInput = exports.hasEquivalentRecentMessageEvent = exports.extractCollabReceiverThreadIds = exports.buildThreadReadAgentMessageEvent = exports.buildDashboardEventFromAppServerMessage = exports.buildAppServerDiagnosticNote = void 0;
+const node_events_1 = require("node:events");
+const node_fs_1 = require("node:fs");
+const app_server_1 = require("./app-server");
+const codex_thread_query_1 = require("./codex-thread-query");
+const cloud_1 = require("./cloud");
+const goal_1 = require("./goal");
+const project_paths_1 = require("./project-paths");
+const codex_turn_semantics_1 = require("./domain/codex-turn-semantics");
+const room_config_1 = require("./room-config");
+const snapshot_1 = require("./snapshot");
+const events_1 = require("./live-monitor-lib/events");
+Object.defineProperty(exports, "buildAppServerDiagnosticNote", { enumerable: true, get: function () { return events_1.buildAppServerDiagnosticNote; } });
+Object.defineProperty(exports, "buildDashboardEventFromAppServerMessage", { enumerable: true, get: function () { return events_1.buildDashboardEventFromAppServerMessage; } });
+Object.defineProperty(exports, "buildThreadReadAgentMessageEvent", { enumerable: true, get: function () { return events_1.buildThreadReadAgentMessageEvent; } });
+Object.defineProperty(exports, "extractCollabReceiverThreadIds", { enumerable: true, get: function () { return events_1.extractCollabReceiverThreadIds; } });
+Object.defineProperty(exports, "hasEquivalentRecentMessageEvent", { enumerable: true, get: function () { return events_1.hasEquivalentRecentMessageEvent; } });
+Object.defineProperty(exports, "shouldMarkThreadLiveFromAppServerNotification", { enumerable: true, get: function () { return events_1.shouldMarkThreadLiveFromAppServerNotification; } });
+Object.defineProperty(exports, "shouldMarkThreadStoppedFromAppServerNotification", { enumerable: true, get: function () { return events_1.shouldMarkThreadStoppedFromAppServerNotification; } });
+const rollout_hooks_1 = require("./live-monitor-lib/rollout-hooks");
+Object.defineProperty(exports, "buildRolloutHookEvent", { enumerable: true, get: function () { return rollout_hooks_1.buildRolloutHookEvent; } });
+Object.defineProperty(exports, "parseApplyPatchInput", { enumerable: true, get: function () { return rollout_hooks_1.parseApplyPatchInput; } });
+const workload_1 = require("./workload");
+const DISCOVERY_INTERVAL_MS = 4000;
+const CLOUD_REFRESH_INTERVAL_MS = 30000;
+const FILE_WATCH_INTERVAL_MS = 250;
+const SNAPSHOT_DEBOUNCE_MS = 60;
+const THREAD_READ_DEBOUNCE_MS = 80;
+const ACTIVE_SUBSCRIPTION_WINDOW_MS = 10 * 60 * 1000;
+const MAX_SUBSCRIBED_THREADS = 8;
+const MAX_RECENT_EVENTS = 240;
+const RECENT_EVENT_RETENTION_MS = 45 * 60 * 1000;
+// Desktop-backed threads can take noticeably longer to resume than simple CLI
+// sessions, and a too-short timeout drops the live item stream we need for
+// `item/agentMessage/*` notifications.
+// Desktop-backed thread attaches can easily take 20s+ on large rollouts.
+// Keep a wider budget so live subscriptions don't flap back to read-only.
+const APP_SERVER_SUBSCRIPTION_TIMEOUT_MS = 60000;
+const APP_SERVER_DISCOVERY_REQUEST_TIMEOUT_MS = 15000;
+const CLOUD_NOTE_LEGACY_PREFIX = "Codex cloud list unavailable:";
+const CLOUD_NOTE_PREFIX = "Codex cloud ";
+const STOPPED_THREAD_REMOVAL_BUFFER_MS = 1000;
+const NOT_LOADED_STOP_DEBOUNCE_MS = 3000;
+const DEFAULT_LOCAL_THREAD_LIMIT = 24;
+const APPROVAL_DECISIONS = new Set(["accept", "acceptForSession", "decline", "cancel"]);
+async function withTimeout(promise, timeoutMs, label) {
+    return await Promise.race([
+        promise,
+        new Promise((_, reject) => {
+            const timer = setTimeout(() => {
+                reject(new Error(`${label} timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            timer.unref?.();
+            promise.finally(() => clearTimeout(timer)).catch(() => clearTimeout(timer));
+        })
+    ]);
+}
+function latestInProgressTurn(thread) {
+    return [...thread.turns].reverse().find((turn) => turn.status === "inProgress") ?? null;
+}
+function notificationTurn(params) {
+    const turn = (0, events_1.asRecord)((0, events_1.asRecord)(params)?.turn);
+    const id = (0, events_1.asString)(turn?.id);
+    const status = (0, events_1.asString)(turn?.status);
+    if (!id || !status || !["completed", "interrupted", "failed", "inProgress"].includes(status)) {
+        return null;
+    }
+    return {
+        id,
+        status: status,
+        error: (0, events_1.asRecord)(turn?.error),
+        items: Array.isArray(turn?.items) ? turn.items : []
+    };
+}
+function childThreadsByParent(threads) {
+    const byParent = new Map();
+    for (const thread of threads) {
+        const parentThreadId = (0, snapshot_1.parentThreadIdForThread)(thread);
+        if (!parentThreadId) {
+            continue;
+        }
+        const children = byParent.get(parentThreadId) ?? [];
+        children.push(thread);
+        byParent.set(parentThreadId, children);
+    }
+    return byParent;
+}
+function upsertThreadTurn(thread, turn) {
+    const turns = thread.turns.filter((entry) => entry.id !== turn.id);
+    turns.push({
+        ...turn,
+        items: turn.items.length > 0
+            ? turn.items
+            : thread.turns.find((entry) => entry.id === turn.id)?.items ?? []
+    });
+    return {
+        ...thread,
+        turns
+    };
+}
+function threadStillAwaitsFinalAnswer(thread) {
+    if (thread.status.type === "systemError") {
+        return false;
+    }
+    const lastTurn = thread.turns.at(-1);
+    if (!lastTurn || lastTurn.status === "failed" || (0, codex_turn_semantics_1.turnHasFinalAnswer)(lastTurn)) {
+        return false;
+    }
+    return lastTurn.status === "inProgress" || (0, codex_turn_semantics_1.turnHasNonFinalWorkSignal)(lastTurn);
+}
+function isSettledDormantSubagentThread(thread) {
+    if (!(0, snapshot_1.parentThreadIdForThread)(thread)) {
+        return false;
+    }
+    if (thread.status.type !== "idle" && thread.status.type !== "notLoaded") {
+        return false;
+    }
+    const lastTurn = thread.turns.at(-1);
+    if (!lastTurn || lastTurn.status === "inProgress") {
+        return false;
+    }
+    if (thread.status.type === "notLoaded" && !(0, codex_turn_semantics_1.turnHasOpenWorkSignal)(lastTurn)) {
+        return true;
+    }
+    const summary = (0, snapshot_1.summariseThread)(thread);
+    return summary.state === "done" || summary.state === "idle";
+}
+function isFreshEnoughToPromoteAwaitingFinalAnswer(thread) {
+    const updatedAtMs = thread.updatedAt * 1000;
+    return Number.isFinite(updatedAtMs) && Date.now() - updatedAtMs <= ACTIVE_SUBSCRIPTION_WINDOW_MS;
+}
+function isRecentThreadSubscriptionCandidate(thread, now) {
+    if ((0, snapshot_1.parentThreadIdForThread)(thread)) {
+        return false;
+    }
+    const updatedAtMs = thread.updatedAt * 1000;
+    return Number.isFinite(updatedAtMs) && now - updatedAtMs <= ACTIVE_SUBSCRIPTION_WINDOW_MS;
+}
+function shouldPreserveKnownOngoingThread(thread, wasOngoing) {
+    if ((0, snapshot_1.isOngoingThread)(thread)) {
+        return true;
+    }
+    if (!wasOngoing || isSettledDormantSubagentThread(thread)) {
+        return false;
+    }
+    return threadStillAwaitsFinalAnswer(thread);
+}
+class ProjectLiveMonitor extends node_events_1.EventEmitter {
+    projectRoot;
+    localLimit;
+    includeCloud;
+    appServerRequestTimeoutMs;
+    threads = new Map();
+    threadWatchers = new Map();
+    threadReadTimers = new Map();
+    threadRefreshGenerations = new Map();
+    threadPaths = new Map();
+    notes = new Set();
+    roomConfigPath;
+    pendingUserRequests = new Map();
+    subscribedThreadIds = new Set();
+    ongoingThreadIds = new Set();
+    stoppedAtByThreadId = new Map();
+    hydratedThreadIds = new Set();
+    threadGoals = new Map();
+    threadRemovalTimers = new Map();
+    pendingNotLoadedStopTimers = new Map();
+    roomWatcher = null;
+    snapshot = null;
+    snapshotCoordinator = null;
+    snapshotCoordinatorPromise = null;
+    cloudTasks = [];
+    client = null;
+    discoveryTimer = null;
+    cloudTimer = null;
+    snapshotTimer = null;
+    discoveryPromise = null;
+    discoveryRequested = 0;
+    discoveryCompleted = 0;
+    snapshotRebuildPromise = null;
+    snapshotRebuildRequested = 0;
+    snapshotRebuildCompleted = 0;
+    stopping = false;
+    stopped = false;
+    stopPromise = null;
+    recentEvents = [];
+    unsubscribeNotifications = null;
+    unsubscribeServerRequests = null;
+    subscriptionSyncPromise = null;
+    subscriptionSyncQueued = false;
+    constructor(options) {
+        super();
+        this.projectRoot = options.projectRoot;
+        this.localLimit = options.localLimit ?? DEFAULT_LOCAL_THREAD_LIMIT;
+        this.includeCloud = options.includeCloud !== false;
+        this.appServerRequestTimeoutMs = options.appServerRequestTimeoutMs
+            ?? APP_SERVER_DISCOVERY_REQUEST_TIMEOUT_MS;
+        this.roomConfigPath = (0, room_config_1.getRoomsFilePath)(this.projectRoot);
+    }
+    getSnapshot() {
+        return this.snapshot;
+    }
+    async start() {
+        const coordinator = await this.ensureSnapshotCoordinator();
+        await Promise.all([this.ensureClient(), coordinator.warm()]);
+        await this.discoverThreads();
+        this.roomConfigPath = await (0, room_config_1.resolveReadableRoomsFilePath)(this.projectRoot);
+        this.watchRoomsFile();
+        this.discoveryTimer = setInterval(() => {
+            void this.discoverThreads();
+            void this.refreshSecondarySources();
+        }, DISCOVERY_INTERVAL_MS);
+        if (this.includeCloud) {
+            void this.refreshCloudTasks();
+            this.cloudTimer = setInterval(() => {
+                void this.refreshCloudTasks();
+            }, CLOUD_REFRESH_INTERVAL_MS);
+        }
+        await this.rebuildSnapshot();
+    }
+    async refreshNow() {
+        await Promise.all([
+            this.includeCloud ? this.refreshCloudTasks() : Promise.resolve(),
+            this.discoverThreads(),
+            this.refreshSecondarySources("manual", 0)
+        ]);
+        await this.rebuildSnapshot();
+    }
+    async respondToApprovalRequest(requestId, decision) {
+        if (!APPROVAL_DECISIONS.has(decision)) {
+            throw new Error(`Unsupported approval decision: ${decision}`);
+        }
+        await this.ensureClient();
+        if (!this.client) {
+            throw new Error("Local Codex app-server unavailable.");
+        }
+        const pending = this.pendingUserRequests.get(requestId) ?? null;
+        if (!pending) {
+            throw new Error("Approval request not found or already resolved.");
+        }
+        if (pending.kind !== "approval") {
+            throw new Error("Only approval requests are actionable from Agents Office right now.");
+        }
+        const numericRequestId = Number.parseInt(requestId, 10);
+        if (!Number.isFinite(numericRequestId)) {
+            throw new Error(`Invalid approval request id: ${requestId}`);
+        }
+        if (pending.responseKind === "legacyReview") {
+            this.client.respondToServerRequest(numericRequestId, {
+                decision: legacyReviewDecision(decision)
+            });
+        }
+        else if (pending.responseKind === "permissionsApproval") {
+            if (decision !== "accept" && decision !== "acceptForSession") {
+                throw new Error("Permission-profile requests only support accept or acceptForSession from Agents Office.");
+            }
+            this.client.respondToServerRequest(numericRequestId, {
+                permissions: pending.requestedPermissions ?? { network: null, fileSystem: null },
+                scope: decision === "acceptForSession" ? "session" : "turn"
+            });
+        }
+        else {
+            this.client.respondToApprovalRequest(numericRequestId, decision);
+        }
+        this.pendingUserRequests.delete(requestId);
+        this.markThreadLive(pending.threadId);
+        this.scheduleThreadRefresh(pending.threadId);
+        await this.rebuildSnapshot();
+    }
+    async sendThreadReply(threadId, text) {
+        const normalizedText = text.trim();
+        if (!normalizedText) {
+            throw new Error("Reply text is required.");
+        }
+        await this.ensureClient();
+        if (!this.client) {
+            throw new Error("Local Codex app-server unavailable.");
+        }
+        let thread = this.threads.get(threadId) ?? null;
+        if (!thread || thread.status.type === "notLoaded") {
+            thread = await this.client.resumeThread(threadId);
+            this.threads.set(threadId, thread);
+        }
+        const threadProjectRoot = (0, project_paths_1.canonicalizeProjectPath)(thread.cwd) ?? thread.cwd;
+        if (!(threadProjectRoot === this.projectRoot || threadProjectRoot.startsWith(`${this.projectRoot}/`))) {
+            throw new Error("Thread does not belong to this project.");
+        }
+        const sourceKind = (0, snapshot_1.parseThreadSourceMeta)(thread).sourceKind;
+        if (sourceKind !== "appServer") {
+            throw new Error("Browser replies are only supported for Codex app-server-owned threads. Continue this observed desktop/CLI thread in Codex instead.");
+        }
+        let activeTurn = latestInProgressTurn(thread);
+        if (!activeTurn && thread.status.type === "active") {
+            thread = await this.client.readThread(threadId);
+            this.threads.set(threadId, thread);
+            activeTurn = latestInProgressTurn(thread);
+        }
+        if (activeTurn?.id) {
+            this.client.steerTurnNoWait(threadId, activeTurn.id, normalizedText);
+        }
+        else if (thread.status.type === "active") {
+            throw new Error("Active Codex thread has no steerable turn yet. Wait for the live turn to load, then retry.");
+        }
+        else {
+            this.client.startTurnNoWait(threadId, normalizedText, thread.cwd);
+        }
+        this.markThreadLive(threadId);
+        this.scheduleThreadRefresh(threadId);
+        this.scheduleThreadSubscriptions();
+        await this.rebuildSnapshot();
+    }
+    async respondToInputRequest(requestId, answers) {
+        await this.ensureClient();
+        if (!this.client) {
+            throw new Error("Local Codex app-server unavailable.");
+        }
+        const pending = this.pendingUserRequests.get(requestId) ?? null;
+        if (!pending) {
+            throw new Error("Input request not found or already resolved.");
+        }
+        if (pending.kind !== "input") {
+            throw new Error("Only input requests can be answered with browser input.");
+        }
+        const normalizedAnswers = normalizeUserInputAnswers(pending.questions ?? [], answers);
+        const numericRequestId = Number.parseInt(requestId, 10);
+        if (!Number.isFinite(numericRequestId)) {
+            throw new Error(`Invalid input request id: ${requestId}`);
+        }
+        if (pending.responseKind === "mcpElicitation") {
+            this.client.respondToServerRequest(numericRequestId, {
+                action: "accept",
+                content: normalizeMcpElicitationContent(pending.requestedSchema ?? null, normalizedAnswers),
+                _meta: null
+            });
+        }
+        else {
+            this.client.respondToToolRequestUserInput(numericRequestId, {
+                answers: normalizedAnswers
+            });
+        }
+        this.pendingUserRequests.delete(requestId);
+        this.markThreadLive(pending.threadId);
+        this.scheduleThreadRefresh(pending.threadId);
+        await this.rebuildSnapshot();
+    }
+    setSharedCloudTasks(tasks, errorMessage) {
+        this.cloudTasks = (0, snapshot_1.filterProjectCloudTasks)(tasks, this.projectRoot);
+        this.setCloudErrorNote(errorMessage);
+        this.scheduleSnapshot();
+    }
+    stop() {
+        if (!this.stopPromise) {
+            this.stopPromise = this.performStop();
+        }
+        return this.stopPromise;
+    }
+    async performStop() {
+        this.stopping = true;
+        if (this.discoveryTimer) {
+            clearInterval(this.discoveryTimer);
+        }
+        if (this.cloudTimer) {
+            clearInterval(this.cloudTimer);
+        }
+        if (this.snapshotTimer) {
+            clearTimeout(this.snapshotTimer);
+        }
+        if (this.roomWatcher) {
+            this.roomWatcher.close();
+        }
+        (0, node_fs_1.unwatchFile)(this.roomConfigPath);
+        for (const timer of this.threadReadTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.threadReadTimers.clear();
+        this.threadRefreshGenerations.clear();
+        for (const timer of this.threadRemovalTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.threadRemovalTimers.clear();
+        for (const timer of this.pendingNotLoadedStopTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.pendingNotLoadedStopTimers.clear();
+        for (const [threadId, watcher] of this.threadWatchers.entries()) {
+            watcher.close();
+            const path = this.threadPaths.get(threadId);
+            if (path) {
+                (0, node_fs_1.unwatchFile)(path);
+            }
+        }
+        this.threadWatchers.clear();
+        this.threadPaths.clear();
+        this.unsubscribeNotifications?.();
+        this.unsubscribeNotifications = null;
+        this.unsubscribeServerRequests?.();
+        this.unsubscribeServerRequests = null;
+        this.client?.close();
+        this.client = null;
+        await this.discoveryPromise?.catch(() => undefined);
+        await this.snapshotRebuildPromise?.catch((error) => {
+            if (!this.stopping && !this.stopped) {
+                throw error;
+            }
+        });
+        const coordinator = this.snapshotCoordinator
+            ?? await this.snapshotCoordinatorPromise?.catch(() => null)
+            ?? null;
+        await coordinator?.dispose();
+        this.snapshotCoordinator = null;
+        this.snapshotCoordinatorPromise = null;
+        this.ongoingThreadIds.clear();
+        this.subscribedThreadIds.clear();
+        this.stopped = true;
+        this.stopping = false;
+    }
+    async ensureClient() {
+        if (this.stopping || this.stopped) {
+            return;
+        }
+        if (this.client) {
+            return;
+        }
+        try {
+            this.client = await app_server_1.CodexAppServerClient.create();
+            this.unsubscribeNotifications?.();
+            this.unsubscribeServerRequests?.();
+            this.unsubscribeNotifications = this.client.onNotification((notification) => {
+                this.handleAppServerNotification(notification);
+            });
+            this.unsubscribeServerRequests = this.client.onServerRequest((request) => {
+                this.handleAppServerServerRequest(request);
+            });
+            this.clearMatchingNote("Local Codex app-server unavailable:");
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.addNote(`Local Codex app-server unavailable: ${message}`);
+        }
+    }
+    addNote(note) {
+        this.notes.add(note);
+    }
+    clearMatchingNote(prefix) {
+        for (const note of this.notes) {
+            if (note.startsWith(prefix)) {
+                this.notes.delete(note);
+            }
+        }
+    }
+    recoverTimedOutAppServerClient(error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!/timed out after \d+ms/i.test(message)) {
+            return;
+        }
+        this.addNote(`Local Codex app-server connection reset after timeout: ${message}`);
+        this.client?.close();
+        this.client = null;
+        this.subscribedThreadIds.clear();
+    }
+    setCloudErrorNote(errorMessage) {
+        this.clearMatchingNote(CLOUD_NOTE_LEGACY_PREFIX);
+        this.clearMatchingNote(CLOUD_NOTE_PREFIX);
+        if (!errorMessage) {
+            return;
+        }
+        this.addNote(errorMessage.startsWith(CLOUD_NOTE_PREFIX)
+            ? errorMessage
+            : `${CLOUD_NOTE_LEGACY_PREFIX} ${errorMessage}`);
+    }
+    discoverThreads() {
+        if (this.stopping || this.stopped) {
+            return Promise.resolve();
+        }
+        this.discoveryRequested += 1;
+        if (!this.discoveryPromise) {
+            const pump = this.runDiscoveryPump();
+            this.discoveryPromise = pump.finally(() => {
+                this.discoveryPromise = null;
+            });
+        }
+        return this.discoveryPromise;
+    }
+    async runDiscoveryPump() {
+        while (this.discoveryCompleted < this.discoveryRequested) {
+            if (this.stopping || this.stopped) {
+                this.discoveryCompleted = this.discoveryRequested;
+                return;
+            }
+            const targetGeneration = this.discoveryRequested;
+            await this.performThreadDiscovery();
+            this.discoveryCompleted = targetGeneration;
+        }
+    }
+    async performThreadDiscovery() {
+        if (this.stopping || this.stopped) {
+            return;
+        }
+        await this.ensureClient();
+        if (!this.client) {
+            return;
+        }
+        try {
+            const query = await (0, codex_thread_query_1.listCodexProjectThreadCandidates)({
+                client: this.client,
+                projectRoot: this.projectRoot,
+                localLimit: this.localLimit
+            });
+            if (this.stopping || this.stopped) {
+                return;
+            }
+            if (query.usedUnscopedFallback) {
+                this.addNote("Local Codex cwd filter returned no project threads; used unscoped Windows path fallback.");
+            }
+            else {
+                this.clearMatchingNote("Local Codex cwd filter returned no project threads;");
+            }
+            const projectThreads = query.projectThreads;
+            const projectThreadsById = new Map(projectThreads.map((thread) => [thread.id, thread]));
+            const trackedThreads = new Map(query.trackedThreads
+                .map((thread) => [thread.id, thread]));
+            const listedThreadsById = new Map(query.allThreads.map((thread) => [thread.id, thread]));
+            const listedChildrenByParent = childThreadsByParent(query.allThreads);
+            const loadedThreadIds = await withTimeout(this.client.listLoadedThreads(), this.appServerRequestTimeoutMs, "thread/loaded/list");
+            for (const threadId of loadedThreadIds) {
+                if (projectThreadsById.has(threadId) || trackedThreads.has(threadId)) {
+                    continue;
+                }
+                let loadedThread = null;
+                try {
+                    loadedThread = await (0, codex_thread_query_1.readCodexThreadWithTimeout)(this.client, threadId, this.appServerRequestTimeoutMs);
+                }
+                catch {
+                    loadedThread = null;
+                }
+                if (!loadedThread) {
+                    continue;
+                }
+                const canonicalCwd = (0, project_paths_1.canonicalizeProjectPath)(loadedThread.cwd) ?? loadedThread.cwd;
+                if (!(canonicalCwd === this.projectRoot || canonicalCwd.startsWith(`${this.projectRoot}/`))) {
+                    continue;
+                }
+                projectThreadsById.set(loadedThread.id, loadedThread);
+                trackedThreads.set(loadedThread.id, loadedThread);
+                listedThreadsById.set(loadedThread.id, loadedThread);
+            }
+            const pendingRelatedThreads = [...trackedThreads.values()];
+            while (pendingRelatedThreads.length > 0) {
+                const thread = pendingRelatedThreads.shift();
+                if (!thread) {
+                    continue;
+                }
+                const parentThreadId = (0, snapshot_1.parentThreadIdForThread)(thread);
+                if (parentThreadId && !trackedThreads.has(parentThreadId)) {
+                    let parentThread = projectThreadsById.get(parentThreadId)
+                        ?? listedThreadsById.get(parentThreadId)
+                        ?? this.threads.get(parentThreadId)
+                        ?? null;
+                    if (!parentThread) {
+                        try {
+                            parentThread = await (0, codex_thread_query_1.readCodexThreadWithTimeout)(this.client, parentThreadId, this.appServerRequestTimeoutMs);
+                        }
+                        catch {
+                            parentThread = null;
+                        }
+                    }
+                    if (parentThread) {
+                        projectThreadsById.set(parentThread.id, parentThread);
+                        trackedThreads.set(parentThread.id, parentThread);
+                        pendingRelatedThreads.push(parentThread);
+                    }
+                }
+                for (const childThread of listedChildrenByParent.get(thread.id) ?? []) {
+                    if (trackedThreads.has(childThread.id)) {
+                        continue;
+                    }
+                    projectThreadsById.set(childThread.id, childThread);
+                    trackedThreads.set(childThread.id, childThread);
+                    pendingRelatedThreads.push(childThread);
+                }
+            }
+            for (const threadId of Array.from(this.threads.keys())) {
+                if (trackedThreads.has(threadId)) {
+                    continue;
+                }
+                const knownThread = projectThreadsById.get(threadId);
+                if (knownThread) {
+                    trackedThreads.set(threadId, knownThread);
+                }
+            }
+            this.clearMatchingNote("Local Codex app-server unavailable:");
+            await Promise.all([...trackedThreads.values()].map(async (listedThread) => {
+                const known = this.threads.get(listedThread.id);
+                if (!known || known.updatedAt !== listedThread.updatedAt || known.path !== listedThread.path) {
+                    await this.refreshThread(listedThread.id, listedThread);
+                    return;
+                }
+                const mergedThread = {
+                    ...known,
+                    status: listedThread.status,
+                    updatedAt: listedThread.updatedAt,
+                    path: listedThread.path ?? known.path
+                };
+                if (shouldPreserveKnownOngoingThread(mergedThread, this.ongoingThreadIds.has(listedThread.id))) {
+                    this.markThreadLive(listedThread.id);
+                }
+                else if (this.ongoingThreadIds.has(listedThread.id)) {
+                    this.markThreadStopped(listedThread.id);
+                }
+                this.threads.set(listedThread.id, mergedThread);
+                await this.refreshThreadGoal(listedThread.id);
+                this.ensureThreadWatcher(listedThread.id, listedThread.path ?? known.path);
+            }));
+            for (const threadId of Array.from(this.threads.keys())) {
+                if (!projectThreadsById.has(threadId)) {
+                    if (this.ongoingThreadIds.has(threadId)) {
+                        continue;
+                    }
+                    this.markThreadStopped(threadId);
+                }
+            }
+            this.scheduleThreadSubscriptions();
+            this.scheduleSnapshot();
+        }
+        catch (error) {
+            if (this.stopping || this.stopped) {
+                return;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            this.addNote(`Local Codex app-server unavailable: ${message}`);
+            this.recoverTimedOutAppServerClient(error);
+            this.client?.close();
+            this.client = null;
+            this.subscribedThreadIds.clear();
+            this.scheduleSnapshot();
+        }
+    }
+    scheduleThreadSubscriptions() {
+        if (this.stopping || this.stopped) {
+            return;
+        }
+        if (this.subscriptionSyncPromise) {
+            this.subscriptionSyncQueued = true;
+            return;
+        }
+        this.subscriptionSyncPromise = this.syncThreadSubscriptions()
+            .catch(() => {
+            /* notes are handled inside syncThreadSubscriptions */
+        })
+            .finally(() => {
+            this.subscriptionSyncPromise = null;
+            if (this.subscriptionSyncQueued) {
+                this.subscriptionSyncQueued = false;
+                this.scheduleThreadSubscriptions();
+            }
+        });
+    }
+    async syncThreadSubscriptions() {
+        if (!this.client) {
+            return;
+        }
+        this.clearMatchingNote("Live subscription sync degraded:");
+        this.clearMatchingNote("Thread subscribe failed (");
+        const now = Date.now();
+        const candidates = [...this.threads.values()]
+            .filter((thread) => (!this.stoppedAtByThreadId.has(thread.id)
+            && (this.ongoingThreadIds.has(thread.id)
+                || (thread.status.type === "active" && !(0, snapshot_1.isStaleActiveSubagentThread)(thread, now))
+                || (0, snapshot_1.isOngoingThread)(thread)
+                || isRecentThreadSubscriptionCandidate(thread, now))))
+            .sort((left, right) => {
+            const leftActive = (left.status.type === "active" && !(0, snapshot_1.isStaleActiveSubagentThread)(left, now)) || this.ongoingThreadIds.has(left.id) ? 1 : 0;
+            const rightActive = (right.status.type === "active" && !(0, snapshot_1.isStaleActiveSubagentThread)(right, now)) || this.ongoingThreadIds.has(right.id) ? 1 : 0;
+            return rightActive - leftActive || right.updatedAt - left.updatedAt;
+        })
+            .slice(0, MAX_SUBSCRIBED_THREADS);
+        const targetIds = new Set(candidates.map((thread) => thread.id));
+        const loadedThreadIds = new Set(await withTimeout(this.client.listLoadedThreads().catch(() => []), APP_SERVER_SUBSCRIPTION_TIMEOUT_MS, "thread/loaded/list").catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            this.addNote(`Live subscription sync degraded: ${message}`);
+            return [];
+        }));
+        await Promise.all([...targetIds]
+            .filter((candidateId) => !this.subscribedThreadIds.has(candidateId))
+            .map(async (threadId) => {
+            try {
+                await withTimeout(this.client?.resumeThread(threadId) ?? Promise.reject(new Error("client unavailable")), APP_SERVER_SUBSCRIPTION_TIMEOUT_MS, `thread/resume ${threadId.slice(0, 8)}`);
+                this.subscribedThreadIds.add(threadId);
+                loadedThreadIds.add(threadId);
+                await this.refreshThread(threadId);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                this.addNote(`Thread subscribe failed (${threadId.slice(0, 8)}): ${message}`);
+            }
+        }));
+        await Promise.all([...this.subscribedThreadIds]
+            .filter((candidateId) => !targetIds.has(candidateId))
+            .map(async (threadId) => {
+            try {
+                await withTimeout(this.client?.unsubscribeThread(threadId) ?? Promise.reject(new Error("client unavailable")), APP_SERVER_SUBSCRIPTION_TIMEOUT_MS, `thread/unsubscribe ${threadId.slice(0, 8)}`);
+            }
+            catch {
+                /* ignore unsubscribe failures */
+            }
+            this.subscribedThreadIds.delete(threadId);
+        }));
+        for (const threadId of [...this.subscribedThreadIds]) {
+            if (!loadedThreadIds.has(threadId)) {
+                this.scheduleThreadRefresh(threadId);
+            }
+        }
+        this.scheduleSnapshot();
+    }
+    scheduleThreadRefresh(threadId) {
+        const existing = this.threadReadTimers.get(threadId);
+        if (existing) {
+            clearTimeout(existing);
+        }
+        const timer = setTimeout(() => {
+            this.threadReadTimers.delete(threadId);
+            void this.refreshThread(threadId);
+        }, THREAD_READ_DEBOUNCE_MS);
+        timer.unref?.();
+        this.threadReadTimers.set(threadId, timer);
+    }
+    ensureThreadWatcher(threadId, path) {
+        if (!path) {
+            return;
+        }
+        const currentPath = this.threadPaths.get(threadId);
+        if (currentPath === path) {
+            return;
+        }
+        if (currentPath) {
+            this.threadWatchers.get(threadId)?.close();
+            (0, node_fs_1.unwatchFile)(currentPath);
+        }
+        this.threadPaths.set(threadId, path);
+        try {
+            const watcher = (0, node_fs_1.watch)(path, { persistent: false }, () => {
+                this.scheduleThreadRefresh(threadId);
+            });
+            this.threadWatchers.set(threadId, watcher);
+        }
+        catch {
+            /* ignore and rely on watchFile below */
+        }
+        (0, node_fs_1.watchFile)(path, { interval: FILE_WATCH_INTERVAL_MS, persistent: false }, () => {
+            this.scheduleThreadRefresh(threadId);
+        });
+    }
+    removeThread(threadId) {
+        this.threads.delete(threadId);
+        const watcher = this.threadWatchers.get(threadId);
+        watcher?.close();
+        this.threadWatchers.delete(threadId);
+        const timer = this.threadReadTimers.get(threadId);
+        if (timer) {
+            clearTimeout(timer);
+            this.threadReadTimers.delete(threadId);
+        }
+        const path = this.threadPaths.get(threadId);
+        if (path) {
+            (0, node_fs_1.unwatchFile)(path);
+            this.threadPaths.delete(threadId);
+        }
+        for (const [requestId, request] of this.pendingUserRequests.entries()) {
+            if (request.threadId === threadId) {
+                this.pendingUserRequests.delete(requestId);
+            }
+        }
+        const removalTimer = this.threadRemovalTimers.get(threadId);
+        if (removalTimer) {
+            clearTimeout(removalTimer);
+            this.threadRemovalTimers.delete(threadId);
+        }
+        this.clearPendingNotLoadedStop(threadId);
+        this.ongoingThreadIds.delete(threadId);
+        this.stoppedAtByThreadId.delete(threadId);
+        this.hydratedThreadIds.delete(threadId);
+        this.threadGoals.delete(threadId);
+        this.subscribedThreadIds.delete(threadId);
+    }
+    belongsToProject(message) {
+        const threadId = (0, events_1.extractThreadId)(message.params);
+        if (threadId && this.threads.has(threadId)) {
+            return true;
+        }
+        const projectPaths = [...(0, events_1.collectPaths)(message.params)];
+        return projectPaths.some((path) => path === this.projectRoot || path.startsWith(`${this.projectRoot}/`));
+    }
+    pushRecentEvent(event) {
+        const now = Date.now();
+        const createdAtMs = Date.parse(event.createdAt);
+        if (Number.isFinite(createdAtMs) && createdAtMs < now - RECENT_EVENT_RETENTION_MS) {
+            return;
+        }
+        this.recentEvents.unshift(event);
+        const seen = new Set();
+        this.recentEvents = this.recentEvents.filter((entry) => {
+            const entryCreatedAtMs = Date.parse(entry.createdAt);
+            if (Number.isFinite(entryCreatedAtMs) && entryCreatedAtMs < now - RECENT_EVENT_RETENTION_MS) {
+                return false;
+            }
+            if (seen.has(entry.id)) {
+                return false;
+            }
+            seen.add(entry.id);
+            return true;
+        }).slice(0, MAX_RECENT_EVENTS);
+    }
+    handleAppServerNotification(notification) {
+        const diagnosticNote = (0, events_1.buildAppServerDiagnosticNote)(notification);
+        if (!this.belongsToProject(notification)) {
+            if (!(0, events_1.extractThreadId)(notification.params) && diagnosticNote) {
+                this.clearMatchingNote((0, events_1.appServerDiagnosticNotePrefix)(notification.method));
+                this.addNote(diagnosticNote);
+                this.scheduleSnapshot();
+            }
+            return;
+        }
+        if (diagnosticNote) {
+            this.clearMatchingNote((0, events_1.appServerDiagnosticNotePrefix)(notification.method));
+            this.addNote(diagnosticNote);
+        }
+        const threadId = (0, events_1.extractThreadId)(notification.params);
+        if (threadId) {
+            let knownThread = this.threads.get(threadId) ?? null;
+            const wasOngoing = this.ongoingThreadIds.has(threadId)
+                || (knownThread ? (0, snapshot_1.isOngoingThread)(knownThread) : false);
+            const status = notification.method === "thread/status/changed"
+                ? (0, events_1.asRecord)((0, events_1.asRecord)(notification.params)?.status)
+                : null;
+            const statusType = (0, events_1.asString)(status?.type);
+            const hasFinalAgentMessage = (0, events_1.isFinalAgentMessageNotification)(notification);
+            const turn = notification.method === "turn/started" || notification.method === "turn/completed"
+                ? notificationTurn(notification.params)
+                : null;
+            if (knownThread && turn) {
+                knownThread = upsertThreadTurn(knownThread, turn);
+                this.threads.set(threadId, knownThread);
+            }
+            this.applyGoalNotification(threadId, notification);
+            if (knownThread && notification.method === "thread/status/changed" && statusType) {
+                const nextStatus = statusType === "active"
+                    ? {
+                        type: "active",
+                        activeFlags: Array.isArray(status?.activeFlags)
+                            ? status.activeFlags.filter((flag) => typeof flag === "string")
+                            : knownThread.status.type === "active" ? knownThread.status.activeFlags : undefined
+                    }
+                    : statusType === "notLoaded" ? { type: "notLoaded" }
+                        : statusType === "idle" ? { type: "idle" }
+                            : statusType === "systemError" ? { type: "systemError" }
+                                : null;
+                if (nextStatus) {
+                    this.threads.set(threadId, {
+                        ...knownThread,
+                        status: nextStatus
+                    });
+                }
+            }
+            if ((0, events_1.shouldMarkThreadLiveFromAppServerNotification)(notification.method, statusType)) {
+                this.markThreadLive(threadId);
+            }
+            else if (hasFinalAgentMessage) {
+                this.markThreadStopped(threadId);
+            }
+            else if ((0, events_1.shouldMarkThreadStoppedFromAppServerNotification)(notification.method, statusType)) {
+                this.markThreadStopped(threadId);
+            }
+            else if ((0, events_1.shouldStopDormantThreadAfterAppServerNotification)({
+                method: notification.method,
+                statusType,
+                wasOngoing
+            })) {
+                if (notification.method === "thread/status/changed" && statusType === "notLoaded") {
+                    this.schedulePendingNotLoadedStop(threadId);
+                }
+                else {
+                    this.markThreadStopped(threadId);
+                }
+            }
+            if (notification.method === "thread/closed"
+                || (notification.method === "thread/status/changed" && statusType === "notLoaded")) {
+                this.scheduleThreadSubscriptions();
+            }
+        }
+        const collabReceiverThreadIds = (0, events_1.extractCollabReceiverThreadIds)(notification);
+        if (collabReceiverThreadIds.length > 0) {
+            for (const receiverThreadId of collabReceiverThreadIds) {
+                this.markThreadLive(receiverThreadId);
+                void this.refreshCollabReceiverThread(receiverThreadId, threadId);
+            }
+            this.scheduleThreadSubscriptions();
+        }
+        if (notification.method === "serverRequest/resolved") {
+            const params = (0, events_1.asRecord)(notification.params) ?? {};
+            const requestId = (0, events_1.asString)(params.requestId);
+            const pendingRequest = requestId ? this.pendingUserRequests.get(requestId) ?? null : null;
+            if (requestId) {
+                this.pendingUserRequests.delete(requestId);
+            }
+            const event = (0, events_1.buildDashboardEventFromAppServerMessage)({ projectRoot: this.projectRoot, pendingRequest }, notification);
+            if (event) {
+                this.pushRecentEvent(event);
+            }
+        }
+        else {
+            const event = (0, events_1.buildDashboardEventFromAppServerMessage)({ projectRoot: this.projectRoot }, notification);
+            if (event) {
+                if (event.kind === "subagent" && event.threadId) {
+                    this.markThreadLive(event.threadId);
+                }
+                this.pushRecentEvent(event);
+            }
+        }
+        if (threadId) {
+            this.scheduleThreadRefresh(threadId);
+        }
+        else {
+            void this.discoverThreads();
+        }
+        this.scheduleSnapshot();
+    }
+    handleAppServerServerRequest(request) {
+        if (!this.belongsToProject(request)) {
+            return;
+        }
+        if (request.method === "currentTime/read") {
+            this.client?.respondToServerRequest(request.id, {
+                currentTimeAt: Math.floor(Date.now() / 1000)
+            });
+            return;
+        }
+        const needsUser = (0, events_1.buildNeedsUserStateFromServerRequest)(request);
+        if (needsUser) {
+            this.pendingUserRequests.set(needsUser.requestId, needsUser);
+        }
+        const event = (0, events_1.buildDashboardEventFromAppServerMessage)({ projectRoot: this.projectRoot, pendingRequest: needsUser }, request);
+        if (event) {
+            this.pushRecentEvent(event);
+        }
+        if (request.method === "item/tool/call") {
+            const numericRequestId = request.id;
+            const requestParams = (0, events_1.asRecord)(request.params);
+            const tool = (0, events_1.asString)(requestParams?.tool);
+            const namespace = (0, events_1.asString)(requestParams?.namespace);
+            this.client?.respondToDynamicToolCallUnsupported(numericRequestId, namespace && tool ? `${namespace}.${tool}` : tool);
+        }
+        const threadId = (0, events_1.extractThreadId)(request.params);
+        if (threadId) {
+            this.markThreadLive(threadId);
+            this.scheduleThreadRefresh(threadId);
+        }
+        else {
+            void this.discoverThreads();
+        }
+        this.scheduleSnapshot();
+    }
+    applyGoalNotification(threadId, notification) {
+        if (notification.method === "thread/goal/cleared") {
+            this.threadGoals.delete(threadId);
+            return;
+        }
+        if (notification.method !== "thread/goal/updated") {
+            return;
+        }
+        const goal = (0, goal_1.codexGoalToAgentGoal)((0, events_1.asRecord)(notification.params)?.goal);
+        if (goal) {
+            this.threadGoals.set(threadId, goal);
+        }
+    }
+    async refreshThreadGoal(threadId) {
+        if (!this.client) {
+            return;
+        }
+        try {
+            const goal = (0, goal_1.codexGoalToAgentGoal)(await withTimeout(this.client.getThreadGoal(threadId), this.appServerRequestTimeoutMs, `thread/goal/get ${threadId.slice(0, 8)}`));
+            if (goal) {
+                this.threadGoals.set(threadId, goal);
+            }
+            else {
+                this.threadGoals.delete(threadId);
+            }
+        }
+        catch (error) {
+            this.recoverTimedOutAppServerClient(error);
+            // Goal metadata is best-effort and should not disturb thread visibility.
+        }
+    }
+    async refreshThread(threadId, listedThread = null) {
+        if (!this.client) {
+            return;
+        }
+        const refreshGeneration = (this.threadRefreshGenerations.get(threadId) ?? 0) + 1;
+        this.threadRefreshGenerations.set(threadId, refreshGeneration);
+        try {
+            const wasHydrated = this.hydratedThreadIds.has(threadId);
+            const hasLiveSubscription = this.subscribedThreadIds.has(threadId);
+            const previousThread = this.threads.get(threadId) ?? null;
+            const wasOngoing = this.ongoingThreadIds.has(threadId)
+                || (previousThread ? (0, snapshot_1.isOngoingThread)(previousThread) : false);
+            let readThread;
+            try {
+                readThread = await (0, codex_thread_query_1.readCodexThreadWithTimeout)(this.client, threadId, this.appServerRequestTimeoutMs);
+            }
+            catch (error) {
+                this.recoverTimedOutAppServerClient(error);
+                if (!listedThread) {
+                    throw error;
+                }
+                readThread = listedThread;
+            }
+            if (this.threadRefreshGenerations.get(threadId) !== refreshGeneration) {
+                return;
+            }
+            // A file-watch reread may arrive immediately after thread/list hydration.
+            // Preserve the freshest known list metadata instead of letting an older
+            // thread/read payload move the workload backwards in time.
+            const freshestKnownThread = listedThread ?? previousThread;
+            const thread = freshestKnownThread
+                ? {
+                    ...readThread,
+                    status: listedThread ? listedThread.status : readThread.status,
+                    updatedAt: Math.max(readThread.updatedAt, freshestKnownThread.updatedAt),
+                    path: freshestKnownThread.path ?? readThread.path
+                }
+                : readThread;
+            this.clearMatchingNote(`Thread refresh failed (${threadId.slice(0, 8)}):`);
+            this.threads.set(threadId, thread);
+            await this.refreshThreadGoal(threadId);
+            const settledDormantSubagent = isSettledDormantSubagentThread(thread);
+            const awaitingFinalAnswer = !settledDormantSubagent && threadStillAwaitsFinalAnswer(thread);
+            const shouldPromoteAwaitingFinalAnswer = awaitingFinalAnswer
+                && (hasLiveSubscription
+                    || wasOngoing
+                    || isFreshEnoughToPromoteAwaitingFinalAnswer(thread));
+            if ((0, snapshot_1.isOngoingThread)(thread) || shouldPromoteAwaitingFinalAnswer) {
+                this.markThreadLive(threadId);
+            }
+            else if (wasOngoing) {
+                const nextMessage = (0, events_1.latestThreadAgentMessage)(thread);
+                const hasFinalAnswer = nextMessage?.phase === "final_answer";
+                const pendingNotLoadedStop = thread.status.type === "notLoaded" && this.pendingNotLoadedStopTimers.has(threadId);
+                if (pendingNotLoadedStop) {
+                    // Wait for the scheduled reread confirmation before releasing a desk.
+                }
+                else if ((0, snapshot_1.isStaleActiveSubagentThread)(thread)) {
+                    this.markThreadStopped(threadId);
+                }
+                else if (settledDormantSubagent) {
+                    this.markThreadStopped(threadId);
+                }
+                else if (thread.status.type === "systemError" || hasFinalAnswer) {
+                    this.markThreadStopped(threadId);
+                }
+                else {
+                    this.markThreadLive(threadId);
+                }
+            }
+            const previousMessage = previousThread ? (0, events_1.latestThreadAgentMessage)(previousThread) : null;
+            const nextMessage = (0, events_1.latestThreadAgentMessage)(thread);
+            if (wasHydrated
+                && nextMessage
+                && (0, events_1.latestThreadAgentMessageIsInLastTurn)(thread)
+                && (nextMessage.itemId !== previousMessage?.itemId
+                    || nextMessage.text !== previousMessage?.text)) {
+                // Even subscribed desktop sessions can miss a terminal message notification;
+                // rereads backfill the toast event while equivalent live events still dedupe.
+                const messageEvent = (0, events_1.buildThreadReadAgentMessageEvent)({ projectRoot: this.projectRoot }, thread);
+                if (messageEvent && !(0, events_1.hasEquivalentRecentMessageEvent)(this.recentEvents, messageEvent)) {
+                    this.pushRecentEvent(messageEvent);
+                }
+            }
+            this.ensureThreadWatcher(threadId, thread.path);
+            const rolloutEvents = await (0, rollout_hooks_1.readRecentRolloutHookEvents)(this.projectRoot, threadId, thread.path, thread.updatedAt);
+            for (const event of rolloutEvents) {
+                this.pushRecentEvent(event);
+            }
+            this.hydratedThreadIds.add(threadId);
+            this.scheduleSnapshot();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.addNote(`Thread refresh failed (${threadId.slice(0, 8)}): ${message}`);
+            this.scheduleSnapshot();
+        }
+    }
+    async refreshCollabReceiverThread(threadId, senderThreadId) {
+        if (!this.client) {
+            return;
+        }
+        try {
+            const thread = await this.client.readThread(threadId);
+            const parentThreadId = (0, snapshot_1.parentThreadIdForThread)(thread);
+            const canonicalCwd = (0, project_paths_1.canonicalizeProjectPath)(thread.cwd) ?? thread.cwd;
+            const belongsToProject = canonicalCwd === this.projectRoot
+                || canonicalCwd.startsWith(`${this.projectRoot}/`)
+                || Boolean(parentThreadId && this.threads.has(parentThreadId))
+                || Boolean(parentThreadId && senderThreadId === parentThreadId);
+            if (!belongsToProject) {
+                return;
+            }
+            this.threads.set(threadId, thread);
+            await this.refreshThreadGoal(threadId);
+            if ((0, snapshot_1.isOngoingThread)(thread)) {
+                this.markThreadLive(threadId);
+            }
+            this.ensureThreadWatcher(threadId, thread.path);
+            this.scheduleThreadSubscriptions();
+            this.scheduleSnapshot();
+        }
+        catch {
+            this.scheduleThreadRefresh(threadId);
+        }
+    }
+    watchRoomsFile() {
+        try {
+            this.roomWatcher = (0, node_fs_1.watch)(this.roomConfigPath, { persistent: false }, () => {
+                this.scheduleSnapshot();
+            });
+        }
+        catch {
+            this.roomWatcher = null;
+        }
+        (0, node_fs_1.watchFile)(this.roomConfigPath, { interval: FILE_WATCH_INTERVAL_MS, persistent: false }, () => {
+            this.scheduleSnapshot();
+        });
+    }
+    async refreshCloudTasks() {
+        if (!this.includeCloud) {
+            this.cloudTasks = [];
+            return;
+        }
+        try {
+            const listed = await (0, cloud_1.listCloudTasks)(10);
+            this.cloudTasks = (0, snapshot_1.filterProjectCloudTasks)(listed, this.projectRoot);
+            this.setCloudErrorNote(null);
+            this.scheduleSnapshot();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.setCloudErrorNote(message);
+            this.scheduleSnapshot();
+        }
+    }
+    scheduleSnapshot() {
+        if (this.stopping || this.stopped) {
+            return;
+        }
+        if (this.snapshotTimer) {
+            clearTimeout(this.snapshotTimer);
+        }
+        this.snapshotTimer = setTimeout(() => {
+            void this.rebuildSnapshot();
+        }, SNAPSHOT_DEBOUNCE_MS);
+        this.snapshotTimer.unref?.();
+    }
+    async rebuildSnapshot() {
+        if (this.stopping || this.stopped) {
+            return;
+        }
+        this.snapshotTimer = null;
+        this.snapshotRebuildRequested += 1;
+        if (!this.snapshotRebuildPromise) {
+            const pump = this.runSnapshotRebuildPump();
+            this.snapshotRebuildPromise = pump.finally(() => {
+                this.snapshotRebuildPromise = null;
+            });
+        }
+        await this.snapshotRebuildPromise;
+    }
+    async runSnapshotRebuildPump() {
+        while (this.snapshotRebuildCompleted < this.snapshotRebuildRequested) {
+            if (this.stopping || this.stopped) {
+                this.snapshotRebuildCompleted = this.snapshotRebuildRequested;
+                return;
+            }
+            const targetGeneration = this.snapshotRebuildRequested;
+            try {
+                await this.assembleLatestSnapshot(targetGeneration);
+            }
+            catch (error) {
+                if (this.stopping || this.stopped) {
+                    this.snapshotRebuildCompleted = this.snapshotRebuildRequested;
+                    return;
+                }
+                throw error;
+            }
+            this.snapshotRebuildCompleted = targetGeneration;
+        }
+    }
+    async assembleLatestSnapshot(targetGeneration) {
+        const needsUserByThreadId = new Map();
+        for (const pending of this.pendingUserRequests.values()) {
+            needsUserByThreadId.set(pending.threadId, pending);
+        }
+        const coordinator = await this.ensureSnapshotCoordinator();
+        const snapshot = await coordinator.buildSnapshot({
+            threads: Array.from(this.threads.values()),
+            cloudTasks: this.cloudTasks,
+            events: this.recentEvents,
+            notes: Array.from(this.notes),
+            needsUserByThreadId,
+            goalsByThreadId: this.threadGoals,
+            subscribedThreadIds: this.subscribedThreadIds,
+            stoppedAtByThreadId: this.stoppedAtByThreadId,
+            ongoingThreadIds: this.ongoingThreadIds
+        });
+        if (snapshot && targetGeneration === this.snapshotRebuildRequested) {
+            this.snapshot = snapshot;
+            this.emit("snapshot", snapshot);
+        }
+    }
+    async ensureSnapshotCoordinator() {
+        if (this.stopping || this.stopped) {
+            throw new Error("ProjectLiveMonitor has been stopped.");
+        }
+        if (this.snapshotCoordinator) {
+            return this.snapshotCoordinator;
+        }
+        if (!this.snapshotCoordinatorPromise) {
+            this.snapshotCoordinatorPromise = Promise.resolve().then(() => __importStar(require("./snapshot"))).then(async ({ createProjectSnapshotCoordinator }) => {
+                const coordinator = await createProjectSnapshotCoordinator({
+                    projectRoot: this.projectRoot,
+                    localLimit: this.localLimit,
+                    includeManagedCloud: false
+                });
+                this.snapshotCoordinator = coordinator;
+                return coordinator;
+            });
+        }
+        return this.snapshotCoordinatorPromise;
+    }
+    async refreshSecondarySources(reason = "interval", minimumAgeMs = DISCOVERY_INTERVAL_MS) {
+        if (this.stopping || this.stopped) {
+            return;
+        }
+        try {
+            const coordinator = await this.ensureSnapshotCoordinator();
+            if (this.stopping || this.stopped) {
+                return;
+            }
+            if (await coordinator.refreshIfStale(reason, minimumAgeMs)) {
+                this.scheduleSnapshot();
+            }
+        }
+        catch (error) {
+            if (!this.stopping && !this.stopped) {
+                throw error;
+            }
+        }
+    }
+    markThreadLive(threadId) {
+        this.clearPendingNotLoadedStop(threadId);
+        this.ongoingThreadIds.add(threadId);
+        this.stoppedAtByThreadId.delete(threadId);
+        const removalTimer = this.threadRemovalTimers.get(threadId);
+        if (removalTimer) {
+            clearTimeout(removalTimer);
+            this.threadRemovalTimers.delete(threadId);
+        }
+    }
+    markThreadStopped(threadId) {
+        if (!this.threads.has(threadId)) {
+            return;
+        }
+        if (this.stoppedAtByThreadId.has(threadId)) {
+            return;
+        }
+        this.clearPendingNotLoadedStop(threadId);
+        this.ongoingThreadIds.delete(threadId);
+        this.stoppedAtByThreadId.set(threadId, Date.now());
+        const removalTimer = this.threadRemovalTimers.get(threadId);
+        if (removalTimer) {
+            clearTimeout(removalTimer);
+        }
+        const timer = setTimeout(() => {
+            this.threadRemovalTimers.delete(threadId);
+            this.removeThread(threadId);
+            this.scheduleSnapshot();
+        }, workload_1.RECENT_DONE_GRACE_MS + STOPPED_THREAD_REMOVAL_BUFFER_MS);
+        timer.unref?.();
+        this.threadRemovalTimers.set(threadId, timer);
+    }
+    clearPendingNotLoadedStop(threadId) {
+        const timer = this.pendingNotLoadedStopTimers.get(threadId);
+        if (!timer) {
+            return;
+        }
+        clearTimeout(timer);
+        this.pendingNotLoadedStopTimers.delete(threadId);
+    }
+    schedulePendingNotLoadedStop(threadId) {
+        if (!this.threads.has(threadId)) {
+            return;
+        }
+        this.clearPendingNotLoadedStop(threadId);
+        const timer = setTimeout(() => {
+            this.pendingNotLoadedStopTimers.delete(threadId);
+            void this.confirmDormantNotLoadedThread(threadId);
+        }, NOT_LOADED_STOP_DEBOUNCE_MS);
+        timer.unref?.();
+        this.pendingNotLoadedStopTimers.set(threadId, timer);
+    }
+    async confirmDormantNotLoadedThread(threadId) {
+        if (!this.threads.has(threadId)) {
+            return;
+        }
+        await this.refreshThread(threadId);
+        const thread = this.threads.get(threadId) ?? null;
+        if (!thread) {
+            return;
+        }
+        if ((0, snapshot_1.isOngoingThread)(thread)) {
+            this.markThreadLive(threadId);
+            return;
+        }
+        if (thread.status.type !== "notLoaded") {
+            return;
+        }
+        const latestMessage = (0, events_1.latestThreadAgentMessage)(thread);
+        if (isSettledDormantSubagentThread(thread) || latestMessage?.phase === "final_answer") {
+            this.markThreadStopped(threadId);
+        }
+        else {
+            this.markThreadLive(threadId);
+        }
+        this.scheduleSnapshot();
+    }
+}
+exports.ProjectLiveMonitor = ProjectLiveMonitor;
+function normalizeUserInputAnswers(questions, rawAnswers) {
+    if (!rawAnswers || typeof rawAnswers !== "object" || Array.isArray(rawAnswers)) {
+        throw new Error("Input answers must be an object keyed by question id.");
+    }
+    const questionsById = new Map((questions ?? []).map((question) => [question.id, question]));
+    const requiredQuestions = [...questionsById.values()].filter((question) => question.required !== false);
+    const answerEntries = Object.entries(rawAnswers);
+    if (requiredQuestions.length > 0 && answerEntries.length === 0) {
+        throw new Error("Answer at least one required question before sending input.");
+    }
+    const normalized = {};
+    for (const [questionId, answer] of answerEntries) {
+        const question = questionsById.get(questionId) ?? null;
+        const answerRecord = typeof answer === "object" && answer && !Array.isArray(answer)
+            ? answer
+            : null;
+        const values = Array.isArray(answerRecord?.answers)
+            ? answerRecord.answers
+                .map((value) => typeof value === "string" ? value.trim() : "")
+                .filter((value) => value.length > 0)
+            : [];
+        if (values.length === 0) {
+            throw new Error(`Question ${questionId} requires at least one answer.`);
+        }
+        if (question?.options && question.isOther !== true) {
+            const allowed = new Set(question.options.map((option) => option.label));
+            const invalid = values.find((value) => !allowed.has(value));
+            if (invalid) {
+                throw new Error(`Question ${question.header} contains an unsupported answer.`);
+            }
+        }
+        normalized[questionId] = { answers: values };
+    }
+    if (questionsById.size > 0) {
+        for (const question of questionsById.values()) {
+            if (question.required === false) {
+                continue;
+            }
+            if (!normalized[question.id]) {
+                throw new Error(`Question ${question.header} is still unanswered.`);
+            }
+        }
+    }
+    return normalized;
+}
+function legacyReviewDecision(decision) {
+    switch (decision) {
+        case "accept":
+            return "approved";
+        case "acceptForSession":
+            return "approved_for_session";
+        case "decline":
+            return "denied";
+        case "cancel":
+            return "abort";
+    }
+}
+function normalizeMcpElicitationContent(requestedSchema, answers) {
+    const content = {};
+    const properties = requestedSchema && typeof requestedSchema.properties === "object" && requestedSchema.properties && !Array.isArray(requestedSchema.properties)
+        ? requestedSchema.properties
+        : {};
+    for (const [questionId, answer] of Object.entries(answers)) {
+        const values = answer.answers;
+        const firstValue = values[0] ?? "";
+        const propertySchema = typeof properties[questionId] === "object" && properties[questionId] && !Array.isArray(properties[questionId])
+            ? properties[questionId]
+            : null;
+        if (propertySchema?.type === "number" || propertySchema?.type === "integer") {
+            const numeric = Number(firstValue);
+            if (!Number.isFinite(numeric)) {
+                throw new Error(`Question ${questionId} requires a numeric answer.`);
+            }
+            content[questionId] = propertySchema.type === "integer" ? Math.trunc(numeric) : numeric;
+            continue;
+        }
+        if (propertySchema?.type === "boolean") {
+            if (firstValue !== "true" && firstValue !== "false") {
+                throw new Error(`Question ${questionId} requires true or false.`);
+            }
+            content[questionId] = firstValue === "true";
+            continue;
+        }
+        if (propertySchema?.type === "array") {
+            content[questionId] = values;
+            continue;
+        }
+        content[questionId] = firstValue;
+    }
+    return content;
+}
+//# sourceMappingURL=live-monitor.js.map