yepanywhere 0.1.0

package/dist/supervisor/Supervisor.js

@@ -0,0 +1,933 @@
+import { randomUUID } from "node:crypto";
+import { getLogger } from "../logging/logger.js";
+import { getProvider } from "../sdk/providers/index.js";
+import { Process } from "./Process.js";
+import { WorkerQueue, isQueueFullError, } from "./WorkerQueue.js";
+import { DEFAULT_IDLE_PREEMPT_THRESHOLD_MS, encodeProjectId, } from "./types.js";
+/** Maximum number of terminated processes to retain */
+const MAX_TERMINATED_PROCESSES = 50;
+/** How long to retain terminated process info (10 minutes) */
+const TERMINATED_RETENTION_MS = 10 * 60 * 1000;
+export class Supervisor {
+    processes = new Map();
+    sessionToProcess = new Map(); // sessionId -> processId
+    everOwnedSessions = new Set(); // Sessions we've ever owned (for orphan detection)
+    terminatedProcesses = []; // Recently terminated processes
+    provider;
+    sdk;
+    realSdk;
+    idleTimeoutMs;
+    defaultPermissionMode;
+    eventBus;
+    maxWorkers;
+    idlePreemptThresholdMs;
+    workerQueue;
+    constructor(options) {
+        this.provider = options.provider ?? null;
+        this.sdk = options.sdk ?? null;
+        this.realSdk = options.realSdk ?? null;
+        this.idleTimeoutMs = options.idleTimeoutMs;
+        this.defaultPermissionMode = options.defaultPermissionMode ?? "default";
+        this.eventBus = options.eventBus;
+        this.maxWorkers = options.maxWorkers ?? 0; // 0 = unlimited
+        this.idlePreemptThresholdMs =
+            options.idlePreemptThresholdMs ?? DEFAULT_IDLE_PREEMPT_THRESHOLD_MS;
+        this.workerQueue = new WorkerQueue({
+            eventBus: options.eventBus,
+            maxQueueSize: options.maxQueueSize,
+        });
+        if (!this.provider && !this.sdk && !this.realSdk) {
+            throw new Error("Either provider, sdk, or realSdk must be provided");
+        }
+    }
+    async startSession(projectPath, message, permissionMode, modelSettings) {
+        const projectId = encodeProjectId(projectPath);
+        // Check if at capacity
+        if (this.isAtCapacity()) {
+            // Try to preempt an idle worker
+            const preemptable = this.findPreemptableWorker();
+            if (preemptable) {
+                await this.preemptWorker(preemptable);
+                // Fall through to start session normally
+            }
+            else {
+                // Queue the request
+                const result = this.workerQueue.enqueue({
+                    type: "new-session",
+                    projectPath,
+                    projectId,
+                    message,
+                    permissionMode,
+                });
+                if (isQueueFullError(result)) {
+                    return result;
+                }
+                return {
+                    queued: true,
+                    queueId: result.queueId,
+                    position: result.position,
+                };
+            }
+        }
+        // Resolve provider: use specified provider name, or fall back to default provider
+        const provider = modelSettings?.providerName
+            ? getProvider(modelSettings.providerName)
+            : this.provider;
+        // Use provider if available (preferred)
+        if (provider) {
+            return this.startProviderSession(projectPath, projectId, message, undefined, permissionMode, modelSettings, provider);
+        }
+        // Use real SDK if available
+        if (this.realSdk) {
+            return this.startRealSession(projectPath, projectId, message, undefined, permissionMode, modelSettings);
+        }
+        // Fall back to legacy mock SDK
+        return this.startLegacySession(projectPath, projectId, message, undefined, permissionMode);
+    }
+    /**
+     * Create a session without sending an initial message.
+     * Used for two-phase flow: create session first, upload files, then send message.
+     * The agent will wait for a message to be pushed to the queue.
+     */
+    async createSession(projectPath, permissionMode, modelSettings) {
+        const projectId = encodeProjectId(projectPath);
+        // Check if at capacity
+        if (this.isAtCapacity()) {
+            // Try to preempt an idle worker
+            const preemptable = this.findPreemptableWorker();
+            if (preemptable) {
+                await this.preemptWorker(preemptable);
+                // Fall through to create session normally
+            }
+            else {
+                // Queue the request - use empty message placeholder
+                const result = this.workerQueue.enqueue({
+                    type: "new-session",
+                    projectPath,
+                    projectId,
+                    message: { text: "" }, // Placeholder, will be replaced when first message sent
+                    permissionMode,
+                });
+                if (isQueueFullError(result)) {
+                    return result;
+                }
+                return {
+                    queued: true,
+                    queueId: result.queueId,
+                    position: result.position,
+                };
+            }
+        }
+        // Resolve provider: use specified provider name, or fall back to default provider
+        const provider = modelSettings?.providerName
+            ? getProvider(modelSettings.providerName)
+            : this.provider;
+        // Use provider if available (preferred)
+        if (provider) {
+            return this.createProviderSession(projectPath, projectId, permissionMode, modelSettings, provider);
+        }
+        // Use real SDK if available
+        if (this.realSdk) {
+            return this.createRealSession(projectPath, projectId, permissionMode, modelSettings);
+        }
+        // Fall back to legacy mock SDK - not supported for create-only
+        throw new Error("createSession requires provider or real SDK - legacy mock SDK not supported");
+    }
+    /**
+     * Create a session using the real SDK without an initial message.
+     * The session is created and waits for a message to be queued.
+     */
+    async createRealSession(projectPath, projectId, permissionMode, modelSettings) {
+        if (!this.realSdk) {
+            throw new Error("realSdk is not available");
+        }
+        const processHolder = { process: null };
+        const effectiveMode = permissionMode ?? this.defaultPermissionMode;
+        // Start session WITHOUT an initial message - agent will wait
+        const result = await this.realSdk.startSession({
+            cwd: projectPath,
+            // No initialMessage - queue will block until one is pushed
+            permissionMode: effectiveMode,
+            model: modelSettings?.model,
+            maxThinkingTokens: modelSettings?.maxThinkingTokens,
+            onToolApproval: async (toolName, input, opts) => {
+                if (!processHolder.process) {
+                    return { behavior: "deny", message: "Process not ready" };
+                }
+                return processHolder.process.handleToolApproval(toolName, input, opts);
+            },
+        });
+        const { iterator, queue, abort } = result;
+        const tempSessionId = randomUUID();
+        const options = {
+            projectPath,
+            projectId,
+            sessionId: tempSessionId,
+            idleTimeoutMs: this.idleTimeoutMs,
+            queue,
+            abortFn: abort,
+            permissionMode: effectiveMode,
+            provider: "claude", // Real SDK is always Claude
+            model: modelSettings?.model,
+            maxThinkingTokens: modelSettings?.maxThinkingTokens,
+        };
+        const process = new Process(iterator, options);
+        processHolder.process = process;
+        // Wait for the real session ID from the SDK
+        await process.waitForSessionId();
+        // Register as a new session
+        this.registerProcess(process, true);
+        return process;
+    }
+    /**
+     * Start a session using the real SDK with full features.
+     */
+    async startRealSession(projectPath, projectId, message, resumeSessionId, permissionMode, modelSettings) {
+        // Create a placeholder process first (needed for tool approval callback)
+        const tempSessionId = resumeSessionId ?? randomUUID();
+        // realSdk is guaranteed to exist here (checked in startSession)
+        if (!this.realSdk) {
+            throw new Error("realSdk is not available");
+        }
+        // We need to reference process in the callback before it's assigned
+        // Using a holder object allows us to set the reference later
+        const processHolder = { process: null };
+        // Use provided mode or fall back to default
+        const effectiveMode = permissionMode ?? this.defaultPermissionMode;
+        // Generate UUID for the initial message so SDK and SSE use the same ID.
+        // This ensures the client can match the SSE replay to its temp message,
+        // and prevents duplicates when JSONL is later fetched.
+        const messageUuid = randomUUID();
+        const messageWithUuid = { ...message, uuid: messageUuid };
+        const result = await this.realSdk.startSession({
+            cwd: projectPath,
+            initialMessage: messageWithUuid,
+            resumeSessionId,
+            permissionMode: effectiveMode,
+            model: modelSettings?.model,
+            maxThinkingTokens: modelSettings?.maxThinkingTokens,
+            onToolApproval: async (toolName, input, opts) => {
+                // Delegate to the process's handleToolApproval
+                if (!processHolder.process) {
+                    return { behavior: "deny", message: "Process not ready" };
+                }
+                return processHolder.process.handleToolApproval(toolName, input, opts);
+            },
+        });
+        const { iterator, queue, abort } = result;
+        const options = {
+            projectPath,
+            projectId,
+            sessionId: tempSessionId,
+            idleTimeoutMs: this.idleTimeoutMs,
+            queue,
+            abortFn: abort,
+            permissionMode: effectiveMode,
+            provider: "claude", // Real SDK is always Claude
+            model: modelSettings?.model,
+            maxThinkingTokens: modelSettings?.maxThinkingTokens,
+        };
+        const process = new Process(iterator, options);
+        processHolder.process = process;
+        // Add the initial user message to history with the same UUID we passed to SDK.
+        // This ensures SSE replay includes the user message so the client can replace
+        // its temp message. The SDK also writes to JSONL with this UUID, so both SSE
+        // and JSONL will have matching IDs (no duplicates).
+        process.addInitialUserMessage(message.text, messageUuid, message.tempId);
+        // Wait for the real session ID from the SDK before registering
+        // This ensures the client gets the correct ID to use for persistence
+        if (!resumeSessionId) {
+            await process.waitForSessionId();
+        }
+        this.registerProcess(process, !resumeSessionId);
+        return process;
+    }
+    /**
+     * Create a session using the provider interface without an initial message.
+     * The session is created and waits for a message to be queued.
+     */
+    async createProviderSession(projectPath, projectId, permissionMode, modelSettings, provider) {
+        const activeProvider = provider ?? this.provider;
+        if (!activeProvider) {
+            throw new Error("provider is not available");
+        }
+        const processHolder = { process: null };
+        const effectiveMode = permissionMode ?? this.defaultPermissionMode;
+        // Start session WITHOUT an initial message - agent will wait
+        const result = await activeProvider.startSession({
+            cwd: projectPath,
+            // No initialMessage - queue will block until one is pushed
+            permissionMode: effectiveMode,
+            model: modelSettings?.model,
+            maxThinkingTokens: modelSettings?.maxThinkingTokens,
+            onToolApproval: async (toolName, input, opts) => {
+                if (!processHolder.process) {
+                    return { behavior: "deny", message: "Process not ready" };
+                }
+                return processHolder.process.handleToolApproval(toolName, input, opts);
+            },
+        });
+        const { iterator, queue, abort } = result;
+        const tempSessionId = randomUUID();
+        const options = {
+            projectPath,
+            projectId,
+            sessionId: tempSessionId,
+            idleTimeoutMs: this.idleTimeoutMs,
+            queue,
+            abortFn: abort,
+            permissionMode: effectiveMode,
+            provider: activeProvider.name,
+            model: modelSettings?.model,
+            maxThinkingTokens: modelSettings?.maxThinkingTokens,
+        };
+        const process = new Process(iterator, options);
+        processHolder.process = process;
+        // Wait for the real session ID from the provider
+        await process.waitForSessionId();
+        // Register as a new session
+        this.registerProcess(process, true);
+        return process;
+    }
+    /**
+     * Start a session using the provider interface with full features.
+     */
+    async startProviderSession(projectPath, projectId, message, resumeSessionId, permissionMode, modelSettings, provider) {
+        const activeProvider = provider ?? this.provider;
+        if (!activeProvider) {
+            throw new Error("provider is not available");
+        }
+        const tempSessionId = resumeSessionId ?? randomUUID();
+        // We need to reference process in the callback before it's assigned
+        const processHolder = { process: null };
+        // Use provided mode or fall back to default
+        const effectiveMode = permissionMode ?? this.defaultPermissionMode;
+        // Generate UUID for the initial message so SDK and SSE use the same ID.
+        const messageUuid = randomUUID();
+        const messageWithUuid = { ...message, uuid: messageUuid };
+        const result = await activeProvider.startSession({
+            cwd: projectPath,
+            initialMessage: messageWithUuid,
+            resumeSessionId,
+            permissionMode: effectiveMode,
+            model: modelSettings?.model,
+            maxThinkingTokens: modelSettings?.maxThinkingTokens,
+            onToolApproval: async (toolName, input, opts) => {
+                if (!processHolder.process) {
+                    return { behavior: "deny", message: "Process not ready" };
+                }
+                return processHolder.process.handleToolApproval(toolName, input, opts);
+            },
+        });
+        const { iterator, queue, abort } = result;
+        const options = {
+            projectPath,
+            projectId,
+            sessionId: tempSessionId,
+            idleTimeoutMs: this.idleTimeoutMs,
+            queue,
+            abortFn: abort,
+            permissionMode: effectiveMode,
+            provider: activeProvider.name,
+            model: modelSettings?.model,
+            maxThinkingTokens: modelSettings?.maxThinkingTokens,
+        };
+        const process = new Process(iterator, options);
+        processHolder.process = process;
+        // Add the initial user message to history with the same UUID we passed to provider.
+        process.addInitialUserMessage(message.text, messageUuid, message.tempId);
+        // Wait for the real session ID from the provider before registering
+        if (!resumeSessionId) {
+            await process.waitForSessionId();
+        }
+        this.registerProcess(process, !resumeSessionId);
+        return process;
+    }
+    /**
+     * Start a session using the legacy mock SDK.
+     */
+    startLegacySession(projectPath, projectId, message, resumeSessionId, permissionMode) {
+        // sdk is guaranteed to exist here (checked in startSession)
+        if (!this.sdk) {
+            throw new Error("sdk is not available");
+        }
+        const iterator = this.sdk.startSession({
+            cwd: projectPath,
+            resume: resumeSessionId,
+        });
+        const sessionId = resumeSessionId ?? randomUUID();
+        // Use provided mode or fall back to default
+        const effectiveMode = permissionMode ?? this.defaultPermissionMode;
+        const options = {
+            projectPath,
+            projectId,
+            sessionId,
+            idleTimeoutMs: this.idleTimeoutMs,
+            permissionMode: effectiveMode,
+            provider: "claude", // Legacy mock SDK simulates Claude
+        };
+        const process = new Process(iterator, options);
+        this.registerProcess(process, !resumeSessionId);
+        // Queue the initial message
+        process.queueMessage(message);
+        return process;
+    }
+    async resumeSession(sessionId, projectPath, message, permissionMode, modelSettings) {
+        // Check if already have a process for this session
+        const existingProcessId = this.sessionToProcess.get(sessionId);
+        if (existingProcessId) {
+            const existingProcess = this.processes.get(existingProcessId);
+            if (existingProcess) {
+                // Check if process is terminated - if so, start a fresh one
+                if (existingProcess.isTerminated) {
+                    this.unregisterProcess(existingProcess);
+                }
+                else {
+                    // Check if thinking settings changed - if so, abort and restart
+                    const requestedThinking = modelSettings?.maxThinkingTokens;
+                    if (existingProcess.maxThinkingTokens !== requestedThinking) {
+                        const log = getLogger();
+                        log.info({
+                            event: "thinking_mode_changed",
+                            sessionId,
+                            processId: existingProcess.id,
+                            oldThinking: existingProcess.maxThinkingTokens,
+                            newThinking: requestedThinking,
+                        }, `Thinking mode changed, restarting process: ${existingProcess.maxThinkingTokens} → ${requestedThinking}`);
+                        // Abort the existing process and start fresh with new thinking settings
+                        await existingProcess.abort();
+                        this.unregisterProcess(existingProcess);
+                        // Fall through to start a new session with the updated settings
+                    }
+                    else {
+                        // Update permission mode if specified
+                        if (permissionMode) {
+                            existingProcess.setPermissionMode(permissionMode);
+                        }
+                        // Queue message to existing process
+                        const result = existingProcess.queueMessage(message);
+                        if (result.success) {
+                            return existingProcess;
+                        }
+                        // Failed to queue - process likely terminated, clean up and start fresh
+                        this.unregisterProcess(existingProcess);
+                    }
+                }
+            }
+        }
+        // Check if there's already a queued request for this session
+        const existingQueued = this.workerQueue.findBySessionId(sessionId);
+        if (existingQueued) {
+            // Already queued - return current position
+            const position = this.workerQueue.getPosition(existingQueued.id);
+            return {
+                queued: true,
+                queueId: existingQueued.id,
+                position: position ?? 1,
+            };
+        }
+        const projectId = encodeProjectId(projectPath);
+        // Check if at capacity
+        if (this.isAtCapacity()) {
+            // Try to preempt an idle worker
+            const preemptable = this.findPreemptableWorker();
+            if (preemptable) {
+                await this.preemptWorker(preemptable);
+                // Fall through to start session normally
+            }
+            else {
+                // Queue the request
+                const result = this.workerQueue.enqueue({
+                    type: "resume-session",
+                    projectPath,
+                    projectId,
+                    sessionId,
+                    message,
+                    permissionMode,
+                });
+                if (isQueueFullError(result)) {
+                    return result;
+                }
+                return {
+                    queued: true,
+                    queueId: result.queueId,
+                    position: result.position,
+                };
+            }
+        }
+        // Resolve provider: use specified provider name, or fall back to default provider
+        const provider = modelSettings?.providerName
+            ? getProvider(modelSettings.providerName)
+            : this.provider;
+        // Use provider if available (preferred)
+        if (provider) {
+            return this.startProviderSession(projectPath, projectId, message, sessionId, permissionMode, modelSettings, provider);
+        }
+        // Use real SDK if available
+        if (this.realSdk) {
+            return this.startRealSession(projectPath, projectId, message, sessionId, permissionMode, modelSettings);
+        }
+        // Fall back to legacy mock SDK
+        return this.startLegacySession(projectPath, projectId, message, sessionId, permissionMode);
+    }
+    getProcess(processId) {
+        return this.processes.get(processId);
+    }
+    getProcessForSession(sessionId) {
+        const processId = this.sessionToProcess.get(sessionId);
+        if (!processId)
+            return undefined;
+        return this.processes.get(processId);
+    }
+    /**
+     * Queue a message to an existing session, handling thinking mode changes.
+     * If the thinking mode differs from the process's current setting, this will:
+     * 1. Abort the existing process
+     * 2. Start a new process with the new thinking settings
+     * 3. Queue the message to the new process
+     *
+     * @returns The process (possibly new), or an error object
+     */
+    async queueMessageToSession(sessionId, projectPath, message, permissionMode, modelSettings) {
+        const process = this.getProcessForSession(sessionId);
+        if (!process) {
+            return { success: false, error: "No active process for session" };
+        }
+        if (process.isTerminated) {
+            return { success: false, error: "Process terminated" };
+        }
+        // Check if thinking settings changed
+        const requestedThinking = modelSettings?.maxThinkingTokens;
+        if (process.maxThinkingTokens !== requestedThinking) {
+            const log = getLogger();
+            log.info({
+                event: "thinking_mode_changed_queue",
+                sessionId,
+                processId: process.id,
+                oldThinking: process.maxThinkingTokens,
+                newThinking: requestedThinking,
+            }, `Thinking mode changed on queue, restarting process: ${process.maxThinkingTokens} → ${requestedThinking}`);
+            // Abort the existing process
+            await process.abort();
+            this.unregisterProcess(process);
+            // Start a new session with the message and new thinking settings
+            const result = await this.resumeSession(sessionId, projectPath, message, permissionMode, modelSettings);
+            // Check if we got a process back
+            if ("id" in result) {
+                return { success: true, process: result, restarted: true };
+            }
+            // Queued or error
+            return { success: false, error: "Request was queued or failed" };
+        }
+        // No thinking change - just queue to existing process
+        if (permissionMode) {
+            process.setPermissionMode(permissionMode);
+        }
+        const result = process.queueMessage(message);
+        if (result.success) {
+            return { success: true, process, restarted: false };
+        }
+        return { success: false, error: result.error ?? "Failed to queue message" };
+    }
+    getAllProcesses() {
+        return Array.from(this.processes.values());
+    }
+    getProcessInfoList() {
+        return this.getAllProcesses().map((p) => p.getInfo());
+    }
+    /**
+     * Check if a session was ever owned by this server instance.
+     * Used to determine if orphaned tool detection should be trusted.
+     * For sessions we never owned (external), we can't know if tools were interrupted.
+     */
+    wasEverOwned(sessionId) {
+        return this.everOwnedSessions.has(sessionId);
+    }
+    async abortProcess(processId) {
+        const process = this.processes.get(processId);
+        if (!process)
+            return false;
+        const log = getLogger();
+        log.info({
+            event: "session_abort_requested",
+            sessionId: process.sessionId,
+            processId: process.id,
+            projectId: process.projectId,
+            currentState: process.state.type,
+        }, `Session abort requested: ${process.sessionId}`);
+        // Emit session-aborted event BEFORE aborting, so ExternalSessionTracker
+        // can set up the grace period before any file changes arrive
+        this.emitSessionAborted(process.sessionId, process.projectId);
+        await process.abort();
+        this.unregisterProcess(process);
+        return true;
+    }
+    emitSessionAborted(sessionId, projectId) {
+        if (!this.eventBus)
+            return;
+        const event = {
+            type: "session-aborted",
+            sessionId,
+            projectId,
+            timestamp: new Date().toISOString(),
+        };
+        this.eventBus.emit(event);
+    }
+    registerProcess(process, isNewSession) {
+        const log = getLogger();
+        log.info({
+            event: "session_registered",
+            sessionId: process.sessionId,
+            processId: process.id,
+            projectId: process.projectId,
+            projectPath: process.projectPath,
+            isNewSession,
+            permissionMode: process.permissionMode,
+        }, `Session registered: ${process.sessionId} (process: ${process.id})`);
+        this.processes.set(process.id, process);
+        this.sessionToProcess.set(process.sessionId, process.id);
+        this.everOwnedSessions.add(process.sessionId);
+        const status = {
+            state: "owned",
+            processId: process.id,
+            permissionMode: process.permissionMode,
+            modeVersion: process.modeVersion,
+        };
+        // Emit session created event for new sessions
+        if (isNewSession) {
+            this.emitSessionCreated(process, status);
+        }
+        // Emit status change event
+        this.emitStatusChange(process.sessionId, process.projectId, status);
+        // Emit initial process state (process starts in running state)
+        const initialState = process.state;
+        if (initialState.type === "running" ||
+            initialState.type === "waiting-input") {
+            // Convert InputRequest.type to PendingInputType if waiting for input at start
+            let pendingInputType;
+            if (initialState.type === "waiting-input") {
+                const requestType = initialState.request.type;
+                pendingInputType =
+                    requestType === "tool-approval" ? "tool-approval" : "user-question";
+            }
+            this.emitProcessStateChange(process.sessionId, process.projectId, initialState.type, pendingInputType);
+        }
+        // Emit worker activity after registering (new worker added)
+        this.emitWorkerActivity();
+        // Listen for completion to auto-cleanup, and state changes for process state events
+        process.subscribe((event) => {
+            if (event.type === "complete") {
+                this.unregisterProcess(process);
+            }
+            else if (event.type === "session-id-changed") {
+                // Update session→process mapping when temp ID is replaced by real ID from SDK
+                // This is critical for ExternalSessionTracker to correctly identify owned sessions
+                const log = getLogger();
+                log.info({
+                    event: "session_id_mapping_updated",
+                    oldSessionId: event.oldSessionId,
+                    newSessionId: event.newSessionId,
+                    processId: process.id,
+                    projectId: process.projectId,
+                }, `Session ID mapping updated: ${event.oldSessionId} → ${event.newSessionId}`);
+                // Keep both temp and real session ID mappings to support lookups by either ID
+                // Clients might still be using the temp ID when the real ID arrives
+                // The old temp ID mapping is retained (no delete)
+                this.sessionToProcess.set(event.newSessionId, process.id);
+                this.everOwnedSessions.add(event.newSessionId);
+                // Emit status change for new session ID so clients can update
+                const status = {
+                    state: "owned",
+                    processId: process.id,
+                    permissionMode: process.permissionMode,
+                    modeVersion: process.modeVersion,
+                };
+                this.emitStatusChange(event.newSessionId, process.projectId, status);
+            }
+            else if (event.type === "state-change") {
+                // Emit process state change for all states that clients need to track
+                // This includes running/waiting-input (active) and idle (inactive)
+                if (event.state.type === "running" ||
+                    event.state.type === "waiting-input" ||
+                    event.state.type === "idle") {
+                    // Convert InputRequest.type to PendingInputType when waiting for input
+                    // "tool-approval" stays as-is, "question" or "choice" becomes "user-question"
+                    let pendingInputType;
+                    if (event.state.type === "waiting-input") {
+                        const requestType = event.state.request.type;
+                        pendingInputType =
+                            requestType === "tool-approval"
+                                ? "tool-approval"
+                                : "user-question";
+                    }
+                    this.emitProcessStateChange(process.sessionId, process.projectId, event.state.type, pendingInputType);
+                }
+                // Emit worker activity on any state change (affects hasActiveWork)
+                this.emitWorkerActivity();
+            }
+        });
+    }
+    unregisterProcess(process) {
+        const log = getLogger();
+        const durationMs = Date.now() - process.startedAt.getTime();
+        log.info({
+            event: "session_unregistered",
+            sessionId: process.sessionId,
+            processId: process.id,
+            projectId: process.projectId,
+            durationMs,
+            finalState: process.state.type,
+            terminationReason: process.terminationReason,
+        }, `Session unregistered: ${process.sessionId} after ${durationMs}ms (reason: ${process.terminationReason ?? process.state.type})`);
+        // Capture process info for terminated list before deleting
+        const terminatedInfo = process.getInfo();
+        terminatedInfo.state = "terminated"; // Override state since process may have been forcefully aborted
+        terminatedInfo.terminatedAt = new Date().toISOString();
+        if (process.terminationReason) {
+            terminatedInfo.terminationReason = process.terminationReason;
+        }
+        this.addTerminatedProcess(terminatedInfo);
+        this.processes.delete(process.id);
+        // Delete all session ID mappings that point to this process
+        // This handles both temp and real session IDs
+        for (const [sessionId, processId] of this.sessionToProcess.entries()) {
+            if (processId === process.id) {
+                this.sessionToProcess.delete(sessionId);
+            }
+        }
+        // Emit status change event (back to idle)
+        this.emitStatusChange(process.sessionId, process.projectId, {
+            state: "idle",
+        });
+        // Emit process state change to notify clients that this session is no longer running
+        // This is needed for real-time updates (e.g., AgentsNavItem indicator)
+        this.emitProcessStateChange(process.sessionId, process.projectId, "idle");
+        // Emit worker activity after unregistering (worker removed)
+        this.emitWorkerActivity();
+        // Process queue when a worker becomes available
+        void this.processQueue();
+    }
+    /**
+     * Add a terminated process to the tracking list.
+     * Prunes old entries and caps at MAX_TERMINATED_PROCESSES.
+     */
+    addTerminatedProcess(info) {
+        this.terminatedProcesses.push(info);
+        // Cap at max entries
+        if (this.terminatedProcesses.length > MAX_TERMINATED_PROCESSES) {
+            this.terminatedProcesses = this.terminatedProcesses.slice(-MAX_TERMINATED_PROCESSES);
+        }
+    }
+    /**
+     * Get recently terminated processes (within retention window).
+     * Prunes expired entries before returning.
+     */
+    getRecentlyTerminatedProcesses() {
+        const now = Date.now();
+        const cutoff = now - TERMINATED_RETENTION_MS;
+        // Prune old entries
+        this.terminatedProcesses = this.terminatedProcesses.filter((p) => {
+            if (!p.terminatedAt)
+                return false;
+            return new Date(p.terminatedAt).getTime() > cutoff;
+        });
+        return [...this.terminatedProcesses];
+    }
+    emitStatusChange(sessionId, projectId, status) {
+        if (!this.eventBus)
+            return;
+        const event = {
+            type: "session-status-changed",
+            sessionId,
+            projectId,
+            status,
+            timestamp: new Date().toISOString(),
+        };
+        this.eventBus.emit(event);
+    }
+    emitSessionCreated(process, status) {
+        if (!this.eventBus)
+            return;
+        const now = new Date().toISOString();
+        const session = {
+            id: process.sessionId,
+            projectId: process.projectId,
+            title: null, // Title comes from first user message, populated later via file change
+            fullTitle: null,
+            createdAt: now,
+            updatedAt: now,
+            messageCount: 0,
+            status,
+            provider: process.provider,
+        };
+        const event = {
+            type: "session-created",
+            session,
+            timestamp: now,
+        };
+        this.eventBus.emit(event);
+    }
+    emitProcessStateChange(sessionId, projectId, processState, pendingInputType) {
+        if (!this.eventBus)
+            return;
+        const event = {
+            type: "process-state-changed",
+            sessionId,
+            projectId,
+            processState,
+            pendingInputType,
+            timestamp: new Date().toISOString(),
+        };
+        this.eventBus.emit(event);
+    }
+    /**
+     * Emit worker activity event for safe restart indicator.
+     * Called when workers are added, removed, or change state.
+     */
+    emitWorkerActivity() {
+        if (!this.eventBus)
+            return;
+        const hasActiveWork = Array.from(this.processes.values()).some((p) => p.state.type === "running" || p.state.type === "waiting-input");
+        const event = {
+            type: "worker-activity-changed",
+            activeWorkers: this.processes.size,
+            queueLength: this.workerQueue.length,
+            hasActiveWork,
+            timestamp: new Date().toISOString(),
+        };
+        this.eventBus.emit(event);
+    }
+    // ============ Worker Pool Methods ============
+    /**
+     * Check if we're at worker capacity.
+     */
+    isAtCapacity() {
+        if (this.maxWorkers <= 0)
+            return false; // 0 = unlimited
+        return this.processes.size >= this.maxWorkers;
+    }
+    /**
+     * Find a preemptable worker (idle longer than threshold).
+     * Returns the worker that has been idle longest.
+     * Does not preempt workers waiting for input.
+     */
+    findPreemptableWorker() {
+        let oldest;
+        let oldestIdleTime = 0;
+        const now = Date.now();
+        for (const process of this.processes.values()) {
+            // Only preempt idle processes, not waiting-input
+            if (process.state.type !== "idle")
+                continue;
+            const idleMs = now - process.state.since.getTime();
+            if (idleMs >= this.idlePreemptThresholdMs && idleMs > oldestIdleTime) {
+                oldest = process;
+                oldestIdleTime = idleMs;
+            }
+        }
+        return oldest;
+    }
+    /**
+     * Preempt an idle worker to make room for a new request.
+     */
+    async preemptWorker(process) {
+        await process.abort();
+        this.unregisterProcess(process);
+    }
+    /**
+     * Process the queue - called when a worker becomes available.
+     */
+    async processQueue() {
+        while (!this.workerQueue.isEmpty && !this.isAtCapacity()) {
+            const request = this.workerQueue.dequeue();
+            if (!request)
+                break;
+            try {
+                let process;
+                if (request.type === "new-session") {
+                    const result = await this.startSessionInternal(request.projectPath, request.projectId, request.message, undefined, request.permissionMode);
+                    process = result;
+                }
+                else {
+                    const result = await this.startSessionInternal(request.projectPath, request.projectId, request.message, request.sessionId, request.permissionMode);
+                    process = result;
+                }
+                // Emit queue removed event
+                this.eventBus?.emit({
+                    type: "queue-request-removed",
+                    queueId: request.id,
+                    sessionId: request.sessionId,
+                    reason: "started",
+                    timestamp: new Date().toISOString(),
+                });
+                request.resolve({ status: "started", processId: process.id });
+            }
+            catch (error) {
+                // On error, resolve with cancelled status
+                request.resolve({
+                    status: "cancelled",
+                    reason: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    }
+    /**
+     * Internal session start that always starts immediately.
+     * Used by queue processing.
+     */
+    async startSessionInternal(projectPath, projectId, message, resumeSessionId, permissionMode) {
+        // Use provider if available (preferred)
+        if (this.provider) {
+            return this.startProviderSession(projectPath, projectId, message, resumeSessionId, permissionMode);
+        }
+        // Use real SDK if available
+        if (this.realSdk) {
+            return this.startRealSession(projectPath, projectId, message, resumeSessionId, permissionMode);
+        }
+        // Fall back to legacy mock SDK
+        return this.startLegacySession(projectPath, projectId, message, resumeSessionId, permissionMode);
+    }
+    // ============ Public Queue Methods ============
+    /**
+     * Cancel a queued request.
+     * @returns true if cancelled, false if not found
+     */
+    cancelQueuedRequest(queueId) {
+        return this.workerQueue.cancel(queueId);
+    }
+    /**
+     * Get info about all queued requests.
+     */
+    getQueueInfo() {
+        return this.workerQueue.getQueueInfo();
+    }
+    /**
+     * Get position for a specific queue entry.
+     */
+    getQueuePosition(queueId) {
+        return this.workerQueue.getPosition(queueId);
+    }
+    /**
+     * Get current worker count and capacity info.
+     */
+    getWorkerPoolStatus() {
+        return {
+            activeWorkers: this.processes.size,
+            maxWorkers: this.maxWorkers,
+            queueLength: this.workerQueue.length,
+        };
+    }
+    /**
+     * Get worker activity status for safe restart indicator.
+     * Returns whether any workers are actively processing or waiting for input.
+     */
+    getWorkerActivity() {
+        const hasActiveWork = Array.from(this.processes.values()).some((p) => p.state.type === "running" || p.state.type === "waiting-input");
+        return {
+            activeWorkers: this.processes.size,
+            queueLength: this.workerQueue.length,
+            hasActiveWork,
+        };
+    }
+}
+//# sourceMappingURL=Supervisor.js.map