@agentuity/opencode 1.0.19 → 1.0.21

package/dist/background/manager.js

@@ -1,1075 +0,0 @@
-import { agents } from '../agents';
-import { ConcurrencyManager } from './concurrency';
-const DEFAULT_BACKGROUND_CONFIG = {
-    enabled: true,
-    defaultConcurrency: 5,
-    staleTimeoutMs: 30 * 60 * 1000,
-};
-export class BackgroundManager {
-    ctx;
-    config;
-    concurrency;
-    callbacks;
-    dbReader;
-    serverUrl;
-    authHeaders;
-    tasks = new Map();
-    tasksByParent = new Map();
-    tasksBySession = new Map();
-    notifications = new Map();
-    toolCallIds = new Map();
-    /** Tracks tool call IDs that are currently in-flight (pending/running state) per task */
-    activeToolCallIds = new Map();
-    /** Maps parent session ID → monitor task ID for auto-launched monitors */
-    monitorsPerParent = new Map();
-    lastNotifyTimes = new Map();
-    shuttingDown = false;
-    refreshIntervalId;
-    constructor(ctx, config, callbacks, dbReader) {
-        this.ctx = ctx;
-        this.config = { ...DEFAULT_BACKGROUND_CONFIG, ...config };
-        this.concurrency = new ConcurrencyManager({
-            defaultLimit: this.config.defaultConcurrency,
-            limits: buildConcurrencyLimits(this.config),
-        });
-        this.callbacks = callbacks;
-        this.dbReader = dbReader;
-        this.serverUrl = this.resolveServerUrl();
-        this.authHeaders = this.resolveAuthHeaders();
-        // Periodic safety net: refresh task statuses every 30s in case events are missed
-        this.refreshIntervalId = setInterval(() => {
-            if (this.shuttingDown)
-                return;
-            const hasActive = Array.from(this.tasks.values()).some((t) => t.status === 'pending' || t.status === 'running');
-            if (hasActive) {
-                void this.refreshStatuses();
-            }
-        }, 30_000);
-    }
-    /**
-     * Resolve the server URL from the plugin context.
-     * Mirrors the defensive pattern used in the tmux manager to handle
-     * sandbox environments where the client may not have a baseUrl configured.
-     */
-    resolveServerUrl() {
-        const ctx = this.ctx;
-        const serverUrl = ctx.serverUrl ?? ctx.baseUrl ?? ctx.client?.baseUrl;
-        if (!serverUrl)
-            return undefined;
-        const urlStr = typeof serverUrl === 'string' ? serverUrl : serverUrl.toString();
-        // Strip trailing slash to prevent double-slash when SDK appends paths like /session
-        return urlStr.replace(/\/+$/, '');
-    }
-    /**
-     * Resolve authentication headers from environment variables.
-     *
-     * Reads `OPENCODE_SERVER_USERNAME` and `OPENCODE_SERVER_PASSWORD` (set
-     * automatically by the OpenCode server in sandbox environments) and
-     * produces a Basic Auth header (`base64("username:password")`).
-     *
-     * In sandbox environments the SDK client's default auth may not carry over
-     * when a per-call `baseUrl` override is provided, so we need to explicitly
-     * attach these credentials for server-to-server requests.
-     */
-    resolveAuthHeaders() {
-        const username = process.env.OPENCODE_SERVER_USERNAME;
-        const password = process.env.OPENCODE_SERVER_PASSWORD;
-        if (!username || !password)
-            return undefined;
-        const encoded = Buffer.from(username + ':' + password).toString('base64');
-        return { Authorization: `Basic ${encoded}` };
-    }
-    /**
-     * Build the per-call client overrides (baseUrl + auth headers).
-     * Spread this into every SDK client call so both the server URL and
-     * authentication are correctly forwarded in sandbox environments.
-     */
-    getClientOverrides() {
-        const overrides = {};
-        if (this.serverUrl)
-            overrides.baseUrl = this.serverUrl;
-        if (this.authHeaders)
-            overrides.headers = this.authHeaders;
-        return overrides;
-    }
-    async launch(input) {
-        const task = {
-            id: createTaskId(),
-            parentSessionId: input.parentSessionId,
-            parentMessageId: input.parentMessageId,
-            description: input.description,
-            prompt: input.prompt,
-            agent: input.agent,
-            status: 'pending',
-            queuedAt: new Date(),
-            concurrencyGroup: this.getConcurrencyGroup(input.agent),
-            notifiedStatuses: new Set(),
-        };
-        this.tasks.set(task.id, task);
-        this.indexTask(task);
-        if (!this.config.enabled) {
-            task.status = 'error';
-            task.error = 'Background tasks are disabled.';
-            task.completedAt = new Date();
-            this.markForNotification(task);
-            return task;
-        }
-        void this.startTask(task);
-        // Auto-launch a Monitor for this parent session if not already running.
-        // Monitor uses session_dashboard scoped to the parent session ID, so it only
-        // sees sibling tasks — not unrelated sessions across the server.
-        void this.ensureMonitorForParent(input.parentSessionId);
-        return task;
-    }
-    getTask(id) {
-        return this.tasks.get(id);
-    }
-    getTasksByParent(sessionId) {
-        const ids = this.tasksByParent.get(sessionId);
-        if (!ids)
-            return [];
-        return Array.from(ids)
-            .map((id) => this.tasks.get(id))
-            .filter((task) => Boolean(task));
-    }
-    findBySession(sessionId) {
-        const taskId = this.tasksBySession.get(sessionId);
-        if (!taskId)
-            return undefined;
-        return this.tasks.get(taskId);
-    }
-    /**
-     * Inspect a background task by fetching its session messages.
-     * Useful for seeing what a child Lead or other agent is doing.
-     */
-    async inspectTask(taskId) {
-        const task = this.tasks.get(taskId);
-        if (!task)
-            return undefined;
-        // Task exists but has not yet acquired a concurrency slot — it is queued
-        // and no session has been created yet. Return a lightweight inspection so
-        // callers can distinguish "queued/pending" from "not found".
-        if (!task.sessionId) {
-            return {
-                taskId: task.id,
-                sessionId: '',
-                status: task.status,
-                session: null,
-                messages: [],
-                lastActivity: task.queuedAt?.toISOString(),
-            };
-        }
-        try {
-            if (this.dbReader?.isAvailable()) {
-                const session = this.dbReader.getSession(task.sessionId);
-                const messageCount = this.dbReader.getMessageCount(task.sessionId);
-                const messageLimit = messageCount > 0 ? messageCount : 100;
-                const messageRows = this.dbReader.getMessages(task.sessionId, {
-                    limit: messageLimit,
-                    offset: 0,
-                });
-                const textParts = this.dbReader.getTextParts(task.sessionId, {
-                    limit: Math.max(messageLimit * 5, 200),
-                });
-                const partsByMessage = groupTextPartsByMessage(textParts);
-                const messages = messageRows
-                    .sort((a, b) => a.timeCreated - b.timeCreated)
-                    .map((message) => ({
-                    info: {
-                        role: message.role,
-                        agent: message.agent,
-                        model: message.model,
-                        cost: message.cost,
-                        tokens: message.tokens,
-                        error: message.error,
-                        timeCreated: message.timeCreated,
-                        timeUpdated: message.timeUpdated,
-                    },
-                    parts: buildTextParts(partsByMessage.get(message.id)),
-                }));
-                const activeTools = this.dbReader.getActiveToolCalls(task.sessionId).map((tool) => ({
-                    tool: tool.tool,
-                    status: tool.status,
-                    callId: tool.callId,
-                }));
-                const todos = this.dbReader.getTodos(task.sessionId).map((todo) => ({
-                    content: todo.content,
-                    status: todo.status,
-                    priority: todo.priority,
-                }));
-                const cost = this.dbReader.getSessionCost(task.sessionId);
-                const childSessionCount = this.dbReader.getChildSessions(task.sessionId).length;
-                return {
-                    taskId: task.id,
-                    sessionId: task.sessionId,
-                    status: task.status,
-                    session,
-                    messages,
-                    lastActivity: task.progress?.lastUpdate?.toISOString(),
-                    messageCount,
-                    activeTools,
-                    todos,
-                    costSummary: {
-                        totalCost: cost.totalCost,
-                        totalTokens: cost.totalTokens,
-                    },
-                    childSessionCount,
-                };
-            }
-            // Get session details
-            const sessionResponse = await this.ctx.client.session.get({
-                path: { id: task.sessionId },
-                throwOnError: false,
-                ...this.getClientOverrides(),
-            });
-            // Get messages from the session
-            const messagesResponse = await this.ctx.client.session.messages({
-                path: { id: task.sessionId },
-                throwOnError: false,
-                ...this.getClientOverrides(),
-            });
-            const session = unwrapResponse(sessionResponse);
-            const rawMessages = unwrapResponse(messagesResponse);
-            // Defensive array coercion (response may be non-array when throwOnError is false)
-            const messages = Array.isArray(rawMessages) ? rawMessages : [];
-            // Return structured inspection result
-            return {
-                taskId: task.id,
-                sessionId: task.sessionId,
-                status: task.status,
-                session,
-                messages,
-                lastActivity: task.progress?.lastUpdate?.toISOString(),
-            };
-        }
-        catch {
-            // Session might not exist anymore
-            return undefined;
-        }
-    }
-    /**
-     * Refresh task statuses from the server.
-     * Useful for recovering state after issues or checking on stuck tasks.
-     */
-    async refreshStatuses() {
-        const results = new Map();
-        // Get all our tracked session IDs
-        const sessionIds = Array.from(this.tasksBySession.keys());
-        if (sessionIds.length === 0)
-            return results;
-        try {
-            // Fetch children for each unique parent (more efficient than individual gets)
-            const parentIds = new Set();
-            for (const task of this.tasks.values()) {
-                if (task.parentSessionId) {
-                    parentIds.add(task.parentSessionId);
-                }
-            }
-            const completionPromises = [];
-            for (const parentId of parentIds) {
-                const childrenResponse = await this.ctx.client.session.children({
-                    path: { id: parentId },
-                    throwOnError: false,
-                    ...this.getClientOverrides(),
-                });
-                const rawChildren = unwrapResponse(childrenResponse);
-                const children = Array.isArray(rawChildren) ? rawChildren : [];
-                for (const child of children) {
-                    const childSession = child;
-                    if (!childSession.id)
-                        continue;
-                    const matchedTaskId = this.tasksBySession.get(childSession.id);
-                    if (matchedTaskId) {
-                        const task = this.tasks.get(matchedTaskId);
-                        if (task) {
-                            // Terminal tasks are final — never overwrite their status.
-                            // The API can return undefined/unknown status for cleaned-up sessions
-                            // which maps to 'pending' by default; without this guard that would
-                            // illegally resurrect a completed/errored/cancelled task.
-                            if (task.status === 'completed' ||
-                                task.status === 'error' ||
-                                task.status === 'cancelled') {
-                                continue;
-                            }
-                            const newStatus = this.mapSessionStatusToTaskStatus(childSession);
-                            if (newStatus !== task.status) {
-                                // Use proper handlers to trigger side effects (concurrency, notifications, etc.)
-                                if (newStatus === 'completed' && task.status === 'running') {
-                                    completionPromises.push(this.completeTask(task));
-                                    results.set(matchedTaskId, newStatus);
-                                }
-                                else if (newStatus === 'error') {
-                                    this.failTask(task, 'Session ended with error');
-                                    results.set(matchedTaskId, newStatus);
-                                }
-                                else {
-                                    // For other transitions (e.g., pending -> running), direct update is fine
-                                    task.status = newStatus;
-                                    results.set(matchedTaskId, newStatus);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            // Wait for all completion handlers to finish
-            await Promise.all(completionPromises);
-        }
-        catch (error) {
-            // Log but don't fail - this is a best-effort refresh
-            console.error('Failed to refresh task statuses:', error);
-        }
-        return results;
-    }
-    /**
-     * Recover background tasks from existing sessions.
-     * Call this on plugin startup to restore state after restart.
-     *
-     * This method queries all sessions and reconstructs task state from
-     * sessions that have JSON-encoded task metadata in their title.
-     *
-     * @returns The number of tasks recovered
-     */
-    async recoverTasks() {
-        let recovered = 0;
-        try {
-            if (this.dbReader?.isAvailable()) {
-                const parentSessionId = process.env.AGENTUITY_OPENCODE_SESSION;
-                if (parentSessionId) {
-                    const sessions = this.dbReader.getChildSessions(parentSessionId);
-                    for (const sess of sessions) {
-                        if (!sess.title?.startsWith('{'))
-                            continue;
-                        try {
-                            const metadata = JSON.parse(sess.title);
-                            if (!metadata.taskId || !metadata.taskId.startsWith('bg_'))
-                                continue;
-                            if (this.tasks.has(metadata.taskId))
-                                continue;
-                            const agentName = metadata.agent ?? 'unknown';
-                            const task = {
-                                id: metadata.taskId,
-                                sessionId: sess.id,
-                                parentSessionId: sess.parentId ?? '',
-                                agent: agentName,
-                                description: metadata.description ?? '',
-                                prompt: '',
-                                status: this.mapDbStatusToTaskStatus(sess.id),
-                                queuedAt: metadata.createdAt ? new Date(metadata.createdAt) : new Date(),
-                                startedAt: metadata.createdAt ? new Date(metadata.createdAt) : new Date(),
-                                concurrencyGroup: this.getConcurrencyGroup(agentName),
-                                progress: {
-                                    toolCalls: 0,
-                                    lastUpdate: new Date(),
-                                    activeToolCallsInFlight: 0,
-                                },
-                            };
-                            // Mark recovered terminal tasks as already notified
-                            if (task.status === 'completed' ||
-                                task.status === 'error' ||
-                                task.status === 'cancelled') {
-                                task.notifiedStatuses = new Set([task.status]);
-                            }
-                            this.tasks.set(task.id, task);
-                            this.tasksBySession.set(sess.id, task.id);
-                            if (task.parentSessionId) {
-                                const parentTasks = this.tasksByParent.get(task.parentSessionId) ?? new Set();
-                                parentTasks.add(task.id);
-                                this.tasksByParent.set(task.parentSessionId, parentTasks);
-                            }
-                            recovered++;
-                        }
-                        catch {
-                            continue;
-                        }
-                    }
-                    return recovered;
-                }
-            }
-            // Get all sessions
-            const sessionsResponse = await this.ctx.client.session.list({
-                throwOnError: false,
-                ...this.getClientOverrides(),
-            });
-            const rawSessions = unwrapResponse(sessionsResponse);
-            const sessions = Array.isArray(rawSessions) ? rawSessions : [];
-            for (const session of sessions) {
-                const sess = session;
-                // Check if this is one of our background task sessions
-                // Our sessions have JSON-encoded task metadata in the title
-                if (!sess.title?.startsWith('{'))
-                    continue;
-                try {
-                    const metadata = JSON.parse(sess.title);
-                    // Skip if not a valid task metadata (must have taskId starting with 'bg_')
-                    if (!metadata.taskId || !metadata.taskId.startsWith('bg_'))
-                        continue;
-                    // Skip if we already have this task
-                    if (this.tasks.has(metadata.taskId))
-                        continue;
-                    // Skip sessions without an ID
-                    if (!sess.id)
-                        continue;
-                    // Reconstruct the task
-                    const agentName = metadata.agent ?? 'unknown';
-                    const task = {
-                        id: metadata.taskId,
-                        sessionId: sess.id,
-                        parentSessionId: sess.parentID ?? '',
-                        agent: agentName,
-                        description: metadata.description ?? '',
-                        prompt: '', // Original prompt not stored in metadata
-                        status: this.mapSessionStatusToTaskStatus(sess),
-                        queuedAt: metadata.createdAt ? new Date(metadata.createdAt) : new Date(),
-                        startedAt: metadata.createdAt ? new Date(metadata.createdAt) : new Date(),
-                        concurrencyGroup: this.getConcurrencyGroup(agentName),
-                        progress: {
-                            toolCalls: 0,
-                            lastUpdate: new Date(),
-                            activeToolCallsInFlight: 0,
-                        },
-                    };
-                    // Mark recovered terminal tasks as already notified
-                    if (task.status === 'completed' ||
-                        task.status === 'error' ||
-                        task.status === 'cancelled') {
-                        task.notifiedStatuses = new Set([task.status]);
-                    }
-                    // Add to our tracking maps
-                    this.tasks.set(task.id, task);
-                    this.tasksBySession.set(sess.id, task.id);
-                    if (task.parentSessionId) {
-                        const parentTasks = this.tasksByParent.get(task.parentSessionId) ?? new Set();
-                        parentTasks.add(task.id);
-                        this.tasksByParent.set(task.parentSessionId, parentTasks);
-                    }
-                    recovered++;
-                }
-                catch {
-                    // Not valid JSON or not our task, skip
-                    continue;
-                }
-            }
-        }
-        catch (error) {
-            console.error('Failed to recover tasks:', error);
-        }
-        return recovered;
-    }
-    mapSessionStatusToTaskStatus(session) {
-        // Map OpenCode session status to our task status
-        // Session status types: 'idle' | 'pending' | 'running' | 'compacting' | 'error'
-        const status = session?.status?.type;
-        switch (status) {
-            case 'idle':
-                return 'completed';
-            case 'pending':
-                return 'pending';
-            case 'running':
-            case 'compacting': // Session is compacting context — still actively running
-                return 'running';
-            case 'error':
-                return 'error';
-            default:
-                // Unknown session status - default to pending for best-effort recovery.
-                // Note: refreshStatuses() guards terminal tasks before calling this,
-                // so a 'pending' default can never downgrade a completed/errored task.
-                return 'pending';
-        }
-    }
-    cancel(taskId) {
-        const task = this.tasks.get(taskId);
-        if (!task || task.status === 'completed' || task.status === 'error') {
-            return false;
-        }
-        task.status = 'cancelled';
-        task.completedAt = new Date();
-        this.releaseConcurrency(task);
-        this.markForNotification(task);
-        if (task.sessionId) {
-            void this.abortSession(task.sessionId);
-            this.callbacks?.onSubagentSessionDeleted?.({ sessionId: task.sessionId });
-        }
-        return true;
-    }
-    handleEvent(event) {
-        if (!event || typeof event.type !== 'string')
-            return;
-        this.expireStaleTasks();
-        if (event.type === 'message.part.updated') {
-            const part = event.properties?.part;
-            if (!part)
-                return;
-            const sessionId = part.sessionID;
-            if (!sessionId)
-                return;
-            const task = this.findBySession(sessionId);
-            if (!task)
-                return;
-            this.updateProgress(task, part);
-            return;
-        }
-        if (event.type === 'session.idle') {
-            const sessionId = extractSessionId(event.properties);
-            const task = sessionId ? this.findBySession(sessionId) : undefined;
-            if (!task)
-                return;
-            void this.completeTask(task);
-            return;
-        }
-        if (event.type === 'session.error') {
-            const sessionId = extractSessionId(event.properties);
-            const task = sessionId ? this.findBySession(sessionId) : undefined;
-            if (!task)
-                return;
-            const error = extractError(event.properties);
-            const errorMsg = error ?? 'Session error.';
-            this.failTask(task, errorMsg);
-            return;
-        }
-    }
-    markForNotification(task) {
-        // Monitor tasks are infrastructure — never notify Lead about them.
-        // Monitor pushes its own consolidated report as its final output.
-        if (task.isMonitor)
-            return;
-        const sessionId = task.parentSessionId;
-        if (!sessionId)
-            return;
-        const queue = this.notifications.get(sessionId) ?? new Set();
-        queue.add(task.id);
-        this.notifications.set(sessionId, queue);
-    }
-    getPendingNotifications(sessionId) {
-        const queue = this.notifications.get(sessionId);
-        if (!queue)
-            return [];
-        return Array.from(queue)
-            .map((id) => this.tasks.get(id))
-            .filter((task) => Boolean(task));
-    }
-    clearNotifications(sessionId) {
-        this.notifications.delete(sessionId);
-    }
-    shutdown() {
-        this.shuttingDown = true;
-        if (this.refreshIntervalId) {
-            clearInterval(this.refreshIntervalId);
-            this.refreshIntervalId = undefined;
-        }
-        this.concurrency.clear();
-        this.notifications.clear();
-        try {
-            void this.callbacks?.onShutdown?.();
-        }
-        catch {
-            // Ignore shutdown callback errors
-        }
-    }
-    indexTask(task) {
-        const parentList = this.tasksByParent.get(task.parentSessionId) ?? new Set();
-        parentList.add(task.id);
-        this.tasksByParent.set(task.parentSessionId, parentList);
-    }
-    /**
-     * Ensure a Monitor agent is watching all background tasks for the given parent session.
-     *
-     * Called automatically whenever a new background task is launched. If a Monitor is
-     * already running for this parent, this is a no-op. The Monitor uses
-     * `agentuity_session_dashboard({ session_id: parentSessionId })` which is scoped
-     * to child sessions of that parent only — it does not see unrelated sessions.
-     *
-     * The Monitor pushes a consolidated status update to Lead when all tasks complete,
-     * so Lead doesn't need to self-poll.
-     */
-    async ensureMonitorForParent(parentSessionId) {
-        if (this.shuttingDown)
-            return;
-        // Check if we already have a live monitor for this parent
-        const existingMonitorId = this.monitorsPerParent.get(parentSessionId);
-        if (existingMonitorId) {
-            const existing = this.tasks.get(existingMonitorId);
-            if (existing && (existing.status === 'pending' || existing.status === 'running')) {
-                return; // Monitor already active
-            }
-        }
-        // Find the Monitor agent display name
-        const monitorAgent = Object.values(agents).find((a) => a.role === 'monitor');
-        if (!monitorAgent)
-            return; // Monitor agent not registered
-        const monitorPrompt = `You are watching background tasks for parent session: ${parentSessionId}
-
-Use \`agentuity_session_dashboard({ session_id: "${parentSessionId}" })\` to see all child task sessions and their current status.
-
-Monitor all non-monitor background tasks until they complete. When all tasks are done (completed, error, or cancelled), send a consolidated summary back. Use \`agentuity_background_output\` to retrieve results for completed tasks.
-
-Do not poll more than once every 30 seconds. Be patient — Scout tasks reading large codebases typically take 3–8 minutes.`;
-        try {
-            const monitorTask = {
-                id: createTaskId(),
-                parentSessionId,
-                description: 'Monitor background tasks',
-                prompt: monitorPrompt,
-                agent: monitorAgent.displayName,
-                status: 'pending',
-                queuedAt: new Date(),
-                // Monitor uses a dedicated concurrency lane so it can never be blocked
-                // by the tasks it's watching. If Monitor queued behind regular tasks it
-                // would never start, and Lead would receive no consolidated report.
-                concurrencyGroup: 'monitor',
-                notifiedStatuses: new Set(),
-                isMonitor: true,
-            };
-            this.tasks.set(monitorTask.id, monitorTask);
-            this.monitorsPerParent.set(parentSessionId, monitorTask.id);
-            // Index monitor task so it's tracked by parent (but flagged as monitor)
-            this.indexTask(monitorTask);
-            void this.startTask(monitorTask);
-        }
-        catch {
-            // Non-fatal: if monitor launch fails, the event-driven notifyParent
-            // still works as the primary completion signal
-        }
-    }
-    async startTask(task) {
-        if (this.shuttingDown)
-            return;
-        // Use task.concurrencyGroup if explicitly set (e.g. 'monitor' for the auto-launched
-        // Monitor agent), otherwise derive from the agent name. This lets Monitor run in its
-        // own concurrency lane so it can never be blocked by the tasks it's watching.
-        const concurrencyKey = task.concurrencyGroup ?? this.getConcurrencyKey(task.agent);
-        task.concurrencyKey = concurrencyKey;
-        try {
-            await this.concurrency.acquire(concurrencyKey);
-        }
-        catch (error) {
-            if (task.status !== 'cancelled') {
-                task.status = 'error';
-                task.error = extractErrorMessage(error, 'Failed to acquire slot.');
-                task.completedAt = new Date();
-                this.markForNotification(task);
-            }
-            return;
-        }
-        if (task.status === 'cancelled') {
-            this.releaseConcurrency(task);
-            return;
-        }
-        try {
-            // Store task metadata in session title for persistence/recovery
-            const taskMetadata = JSON.stringify({
-                taskId: task.id,
-                agent: task.agent,
-                description: task.description,
-                createdAt: task.queuedAt?.toISOString() ?? new Date().toISOString(),
-            });
-            const sessionResult = await this.ctx.client.session.create({
-                body: {
-                    parentID: task.parentSessionId,
-                    title: taskMetadata,
-                },
-                throwOnError: true,
-                ...this.getClientOverrides(),
-            });
-            const session = unwrapResponse(sessionResult);
-            if (!session?.id) {
-                throw new Error('Failed to create session.');
-            }
-            task.sessionId = session.id;
-            task.status = 'running';
-            task.startedAt = new Date();
-            this.tasksBySession.set(session.id, task.id);
-            this.callbacks?.onSubagentSessionCreated?.({
-                sessionId: session.id,
-                parentId: task.parentSessionId,
-                title: task.description,
-            });
-            await this.ctx.client.session.prompt({
-                path: { id: session.id },
-                body: {
-                    agent: task.agent,
-                    parts: [{ type: 'text', text: task.prompt }],
-                },
-                throwOnError: true,
-                ...this.getClientOverrides(),
-            });
-        }
-        catch (error) {
-            const errorMsg = extractErrorMessage(error, 'Failed to launch background task.');
-            // Log the actual error for debugging — critical in sandbox environments
-            // where the client may silently fail due to missing baseUrl
-            try {
-                void this.ctx.client.app.log({
-                    body: {
-                        service: 'agentuity-coder',
-                        level: 'error',
-                        message: `Background task ${task.id} failed to start: ${errorMsg}`,
-                    },
-                    ...this.getClientOverrides(),
-                });
-            }
-            catch {
-                // If logging also fails, fall back to console
-                console.error(`[BackgroundManager] Task ${task.id} failed to start:`, errorMsg);
-            }
-            this.failTask(task, errorMsg);
-        }
-    }
-    updateProgress(task, part) {
-        const progress = task.progress ?? this.createProgress();
-        progress.lastUpdate = new Date();
-        if (part.type === 'tool') {
-            const callId = part.callID;
-            const toolName = part.tool;
-            const toolStatus = part.state?.status;
-            if (toolName) {
-                progress.lastTool = toolName;
-            }
-            if (callId) {
-                const seen = this.toolCallIds.get(task.id) ?? new Set();
-                const active = this.activeToolCallIds.get(task.id) ?? new Set();
-                if (!seen.has(callId)) {
-                    // First time seeing this callId — it's a new tool call starting
-                    seen.add(callId);
-                    progress.toolCalls += 1;
-                    this.toolCallIds.set(task.id, seen);
-                }
-                // Track in-flight status based on tool state
-                // Only remove for explicit terminal statuses; treat unknown/missing as in-flight
-                if (toolStatus === 'completed' ||
-                    toolStatus === 'error' ||
-                    toolStatus === 'cancelled') {
-                    active.delete(callId);
-                }
-                else {
-                    // pending, running, unknown, or missing status — treat as in-flight
-                    active.add(callId);
-                }
-                this.activeToolCallIds.set(task.id, active);
-                progress.activeToolCallsInFlight = active.size;
-            }
-        }
-        if (part.type === 'text' && part.text) {
-            progress.lastMessage = part.text;
-            progress.lastMessageAt = new Date();
-        }
-        task.progress = progress;
-    }
-    createProgress() {
-        return {
-            toolCalls: 0,
-            lastUpdate: new Date(),
-            activeToolCallsInFlight: 0,
-        };
-    }
-    async completeTask(task) {
-        if (task.status !== 'running')
-            return;
-        task.status = 'completed';
-        task.completedAt = new Date();
-        this.releaseConcurrency(task);
-        if (task.sessionId) {
-            const result = await this.fetchLatestResult(task.sessionId);
-            if (result) {
-                task.result = result;
-            }
-            this.callbacks?.onSubagentSessionDeleted?.({ sessionId: task.sessionId });
-        }
-        this.markForNotification(task);
-        void this.notifyParent(task);
-    }
-    failTask(task, error) {
-        if (task.status === 'completed' || task.status === 'error')
-            return;
-        task.status = 'error';
-        task.error = error;
-        task.completedAt = new Date();
-        this.releaseConcurrency(task);
-        if (task.sessionId) {
-            this.callbacks?.onSubagentSessionDeleted?.({ sessionId: task.sessionId });
-        }
-        this.markForNotification(task);
-        void this.notifyParent(task);
-    }
-    releaseConcurrency(task) {
-        if (!task.concurrencyKey)
-            return;
-        this.concurrency.release(task.concurrencyKey);
-        delete task.concurrencyKey;
-    }
-    async notifyParent(task) {
-        if (!task.parentSessionId)
-            return;
-        if (this.shuttingDown)
-            return;
-        // Monitor tasks push their own report as their session output — no separate notification needed.
-        if (task.isMonitor)
-            return;
-        // Recovered tasks (from recoverTasks) have no notifiedStatuses.
-        // Assume they were already notified and skip to prevent duplicate notifications.
-        if (!task.notifiedStatuses) {
-            task.notifiedStatuses = new Set([task.status]);
-            return;
-        }
-        // Snapshot status at call-time to prevent race conditions where concurrent
-        // refreshStatuses() calls mutate task.status during our async awaits below.
-        // Without this, the wrong status could be recorded as notified after delivery.
-        const statusAtCallTime = task.status;
-        const notifiedStatuses = task.notifiedStatuses;
-        if (notifiedStatuses.has(statusAtCallTime)) {
-            return; // Already notified for this status, skip duplicate
-        }
-        // Belt-and-suspenders: rate limit notifications per task+status to 1 per 10s
-        const now = Date.now();
-        const lastNotifyKey = `${task.id}:${statusAtCallTime}`;
-        const lastTime = this.lastNotifyTimes.get(lastNotifyKey);
-        if (lastTime && now - lastTime < 10_000) {
-            return;
-        }
-        this.lastNotifyTimes.set(lastNotifyKey, now);
-        // Do NOT pre-mark as notified here — if all retries fail, the status
-        // must remain unmarked so future retry attempts (via refreshStatuses
-        // or Monitor) are not blocked. Mark only on confirmed delivery below.
-        const message = `[BACKGROUND TASK ${statusAtCallTime.toUpperCase()}]
-
-Task: ${task.description}
-Agent: ${task.agent}
-Status: ${statusAtCallTime}
-Task ID: ${task.id}
-
-Use the agentuity_background_output tool with task_id "${task.id}" to view the result.`;
-        const maxRetries = 3;
-        for (let attempt = 0; attempt < maxRetries; attempt++) {
-            try {
-                await this.ctx.client.session.prompt({
-                    path: { id: task.parentSessionId },
-                    body: {
-                        parts: [{ type: 'text', text: message }],
-                    },
-                    throwOnError: true,
-                    responseStyle: 'data',
-                    ...this.getClientOverrides(),
-                });
-                // Mark the snapshotted status as notified only AFTER confirmed delivery.
-                // Using the snapshot prevents recording the wrong status if task.status
-                // was mutated concurrently during the await above.
-                notifiedStatuses.add(statusAtCallTime);
-                task.notifiedStatuses = notifiedStatuses;
-                return; // Success
-            }
-            catch (error) {
-                const errorMsg = extractErrorMessage(error, 'notification failed');
-                if (attempt < maxRetries - 1) {
-                    // Exponential backoff: 1s, 2s, 4s
-                    await new Promise((r) => setTimeout(r, 1000 * Math.pow(2, attempt)));
-                    if (this.shuttingDown)
-                        return;
-                }
-                else {
-                    console.error(`[BackgroundManager] Failed to notify parent for task ${task.id} after ${maxRetries} attempts:`, errorMsg);
-                    // Safety net: ensure status is NOT marked as notified so future
-                    // retry attempts (via refreshStatuses or Monitor) are not blocked
-                    notifiedStatuses.delete(statusAtCallTime);
-                }
-            }
-        }
-    }
-    async abortSession(sessionId) {
-        try {
-            await this.ctx.client.session.abort({
-                path: { id: sessionId },
-                throwOnError: false,
-                ...this.getClientOverrides(),
-            });
-        }
-        catch {
-            // Ignore abort errors
-        }
-    }
-    async fetchLatestResult(sessionId) {
-        try {
-            if (this.dbReader?.isAvailable()) {
-                const messages = this.dbReader.getMessages(sessionId, { limit: 100, offset: 0 });
-                const textParts = this.dbReader.getTextParts(sessionId, { limit: 300 });
-                const partsByMessage = groupTextPartsByMessage(textParts);
-                for (const message of messages) {
-                    if (message.role !== 'assistant')
-                        continue;
-                    const text = joinTextParts(partsByMessage.get(message.id));
-                    if (text)
-                        return text;
-                }
-                return undefined;
-            }
-            const messagesResult = await this.ctx.client.session.messages({
-                path: { id: sessionId },
-                throwOnError: true,
-                ...this.getClientOverrides(),
-            });
-            const messages = unwrapResponse(messagesResult) ?? [];
-            const entries = Array.isArray(messages) ? messages : [];
-            for (let i = entries.length - 1; i >= 0; i -= 1) {
-                const entry = entries[i];
-                if (entry?.info?.role !== 'assistant')
-                    continue;
-                const text = extractTextFromParts(entry.parts ?? []);
-                if (text)
-                    return text;
-            }
-        }
-        catch {
-            return undefined;
-        }
-        return undefined;
-    }
-    mapDbStatusToTaskStatus(sessionId) {
-        if (!this.dbReader)
-            return 'pending';
-        const status = this.dbReader.getSessionStatus(sessionId).status;
-        switch (status) {
-            case 'idle':
-            case 'archived':
-                return 'completed';
-            case 'active':
-            case 'compacting':
-                return 'running';
-            case 'error':
-                return 'error';
-            default:
-                return 'pending';
-        }
-    }
-    getConcurrencyGroup(agentName) {
-        const model = getAgentModel(agentName);
-        if (!model)
-            return undefined;
-        const provider = model.split('/')[0];
-        if (model && this.config.modelConcurrency?.[model] !== undefined) {
-            return `model:${model}`;
-        }
-        if (provider && this.config.providerConcurrency?.[provider] !== undefined) {
-            return `provider:${provider}`;
-        }
-        return undefined;
-    }
-    getConcurrencyKey(agentName) {
-        const group = this.getConcurrencyGroup(agentName);
-        return group ?? 'default';
-    }
-    expireStaleTasks() {
-        const now = Date.now();
-        for (const task of this.tasks.values()) {
-            if (task.status !== 'pending' && task.status !== 'running')
-                continue;
-            // Use last activity time (last event received) rather than start time.
-            // A task actively doing tool calls every minute should never expire —
-            // only tasks that have gone silent for staleTimeoutMs should be killed.
-            const lastActivity = task.progress?.lastUpdate.getTime() ??
-                task.startedAt?.getTime() ??
-                task.queuedAt?.getTime();
-            if (!lastActivity)
-                continue;
-            if (now - lastActivity > this.config.staleTimeoutMs) {
-                this.failTask(task, 'Background task timed out (no activity).');
-            }
-        }
-    }
-}
-function buildConcurrencyLimits(config) {
-    const limits = {};
-    if (config.providerConcurrency) {
-        for (const [provider, limit] of Object.entries(config.providerConcurrency)) {
-            limits[`provider:${provider}`] = limit;
-        }
-    }
-    if (config.modelConcurrency) {
-        for (const [model, limit] of Object.entries(config.modelConcurrency)) {
-            limits[`model:${model}`] = limit;
-        }
-    }
-    return limits;
-}
-function getAgentModel(agentName) {
-    const agent = findAgentDefinition(agentName);
-    return agent?.defaultModel;
-}
-function findAgentDefinition(agentName) {
-    return Object.values(agents).find((agent) => agent.displayName === agentName || agent.id === agentName || agent.role === agentName);
-}
-function createTaskId() {
-    return `bg_${Math.random().toString(36).slice(2, 8)}`;
-}
-function extractSessionId(properties) {
-    return (properties?.sessionId ?? properties?.sessionID);
-}
-function extractError(properties) {
-    const error = properties?.error;
-    return error?.data?.message ?? (typeof error?.name === 'string' ? error.name : undefined);
-}
-function extractTextFromParts(parts) {
-    const textParts = [];
-    for (const part of parts) {
-        if (typeof part !== 'object' || part === null)
-            continue;
-        const typed = part;
-        if (typed.type === 'text' && typeof typed.text === 'string') {
-            textParts.push(typed.text);
-        }
-    }
-    if (textParts.length === 0)
-        return undefined;
-    return textParts.join('\n');
-}
-function groupTextPartsByMessage(parts) {
-    const grouped = new Map();
-    for (const part of parts) {
-        const list = grouped.get(part.messageId) ?? [];
-        list.push(part);
-        grouped.set(part.messageId, list);
-    }
-    for (const list of grouped.values()) {
-        list.sort((a, b) => a.timeCreated - b.timeCreated);
-    }
-    return grouped;
-}
-function buildTextParts(parts) {
-    if (!parts || parts.length === 0)
-        return [];
-    return parts.map((part) => ({ type: 'text', text: part.text }));
-}
-function joinTextParts(parts) {
-    if (!parts || parts.length === 0)
-        return undefined;
-    return parts.map((part) => part.text).join('\n');
-}
-function unwrapResponse(result) {
-    if (typeof result === 'object' && result !== null && 'data' in result) {
-        return result.data;
-    }
-    return result;
-}
-/**
- * Extract an error message from an unknown thrown value.
- *
- * The OpenCode SDK client (with `throwOnError: true`) throws **plain objects**
- * (e.g. `{ message: "Not Found" }`) or raw strings rather than `Error` instances.
- * This helper normalises all shapes into a usable string.
- */
-function extractErrorMessage(error, fallback) {
-    if (error instanceof Error)
-        return error.message;
-    if (typeof error === 'string')
-        return error || fallback;
-    if (typeof error === 'object' && error !== null) {
-        const obj = error;
-        if (typeof obj.message === 'string')
-            return obj.message || fallback;
-        if (typeof obj.error === 'string')
-            return obj.error || fallback;
-        if (typeof obj.error === 'object' && obj.error !== null) {
-            return extractErrorMessage(obj.error, fallback);
-        }
-    }
-    return fallback;
-}
-//# sourceMappingURL=manager.js.map