@agentuity/opencode 1.0.15 → 1.0.17

package/src/background/manager.ts

@@ -14,7 +14,7 @@ import { ConcurrencyManager } from './concurrency';
 
 const DEFAULT_BACKGROUND_CONFIG: BackgroundTaskConfig = {
 	enabled: true,
-	defaultConcurrency: 1,
+	defaultConcurrency: 5,
 	staleTimeoutMs: 30 * 60 * 1000,
 };
 
@@ -55,7 +55,13 @@ export class BackgroundManager {
 	private tasksBySession = new Map<string, string>();
 	private notifications = new Map<string, Set<string>>();
 	private toolCallIds = new Map<string, Set<string>>();
+	/** Tracks tool call IDs that are currently in-flight (pending/running state) per task */
+	private activeToolCallIds = new Map<string, Set<string>>();
+	/** Maps parent session ID → monitor task ID for auto-launched monitors */
+	private monitorsPerParent = new Map<string, string>();
+	private lastNotifyTimes = new Map<string, number>();
 	private shuttingDown = false;
+	private refreshIntervalId: ReturnType<typeof setInterval> | undefined;
 
 	constructor(
 		ctx: PluginInput,
@@ -73,6 +79,17 @@ export class BackgroundManager {
 		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);
 	}
 
 	/**
@@ -135,6 +152,7 @@ export class BackgroundManager {
 			status: 'pending',
 			queuedAt: new Date(),
 			concurrencyGroup: this.getConcurrencyGroup(input.agent),
+			notifiedStatuses: new Set(),
 		};
 
 		this.tasks.set(task.id, task);
@@ -149,6 +167,12 @@ export class BackgroundManager {
 		}
 
 		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;
 	}
 
@@ -176,7 +200,21 @@ export class BackgroundManager {
 	 */
 	async inspectTask(taskId: string): Promise<TaskInspection | undefined> {
 		const task = this.tasks.get(taskId);
-		if (!task?.sessionId) return undefined;
+		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()) {
@@ -387,9 +425,19 @@ export class BackgroundManager {
 								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);
 
@@ -463,9 +511,19 @@ export class BackgroundManager {
 						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);
@@ -556,12 +614,28 @@ export class BackgroundManager {
 			const task = sessionId ? this.findBySession(sessionId) : undefined;
 			if (!task) return;
 			const error = extractError(event.properties);
-			this.failTask(task, error ?? 'Session error.');
+			const errorMsg = error ?? 'Session error.';
+
+			// Log extra context for timeout errors — the server fires these when
+			// a model generates a long text response without tool activity.
+			if (
+				errorMsg.toLowerCase().includes('timeout') ||
+				errorMsg.toLowerCase().includes('no activity')
+			) {
+				console.debug(
+					`[BackgroundManager] Task ${task.id} timed out - may have been generating long response. Progress: ${JSON.stringify(task.progress)}`
+				);
+			}
+
+			this.failTask(task, errorMsg);
 			return;
 		}
 	}
 
 	markForNotification(task: BackgroundTask): void {
+		// 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<string>();
@@ -583,6 +657,10 @@ export class BackgroundManager {
 
 	shutdown(): void {
 		this.shuttingDown = true;
+		if (this.refreshIntervalId) {
+			clearInterval(this.refreshIntervalId);
+			this.refreshIntervalId = undefined;
+		}
 		this.concurrency.clear();
 		this.notifications.clear();
 		try {
@@ -598,6 +676,67 @@ export class BackgroundManager {
 		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.
+	 */
+	private async ensureMonitorForParent(parentSessionId: string): Promise<void> {
+		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: BackgroundTask = {
+				id: createTaskId(),
+				parentSessionId,
+				description: 'Monitor background tasks',
+				prompt: monitorPrompt,
+				agent: monitorAgent.displayName,
+				status: 'pending',
+				queuedAt: new Date(),
+				concurrencyGroup: this.getConcurrencyGroup(monitorAgent.displayName),
+				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
+		}
+	}
+
 	private async startTask(task: BackgroundTask): Promise<void> {
 		if (this.shuttingDown) return;
 
@@ -690,16 +829,37 @@ export class BackgroundManager {
 		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<string>();
+				const active = this.activeToolCallIds.get(task.id) ?? new Set<string>();
+
 				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;
 			}
 		}
 
@@ -715,6 +875,7 @@ export class BackgroundManager {
 		return {
 			toolCalls: 0,
 			lastUpdate: new Date(),
+			activeToolCallsInFlight: 0,
 		};
 	}
 
@@ -758,29 +919,34 @@ export class BackgroundManager {
 
 	private async notifyParent(task: BackgroundTask): Promise<void> {
 		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;
 
-		// Prevent duplicate notifications for the same task+status combination
-		// This guards against OpenCode firing multiple events for the same status transition
-		const notifiedStatuses = task.notifiedStatuses ?? new Set();
-
-		// Self-healing for tasks created before deduplication was added:
-		// If a task is already in a terminal state but has no notification history,
-		// assume it was already notified and skip to prevent duplicate notifications.
-		if (
-			notifiedStatuses.size === 0 &&
-			(task.status === 'completed' || task.status === 'error' || task.status === 'cancelled')
-		) {
-			notifiedStatuses.add(task.status);
-			task.notifiedStatuses = notifiedStatuses;
+		// 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;
 		}
 
+		const notifiedStatuses = task.notifiedStatuses;
 		if (notifiedStatuses.has(task.status)) {
 			return; // Already notified for this status, skip duplicate
 		}
-		// Mark as notified BEFORE sending to prevent race conditions
-		notifiedStatuses.add(task.status);
-		task.notifiedStatuses = notifiedStatuses;
+
+		// Belt-and-suspenders: rate limit notifications per task+status to 1 per 10s
+		const now = Date.now();
+		const lastNotifyKey = `${task.id}:${task.status}`;
+		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 statusLine = task.status === 'completed' ? 'completed' : task.status;
 		const message = `[BACKGROUND TASK ${statusLine.toUpperCase()}]
@@ -792,21 +958,38 @@ Task ID: ${task.id}
 
 Use the agentuity_background_output tool with task_id "${task.id}" to view the result.`;
 
-		try {
-			await this.ctx.client.session.prompt({
-				path: { id: task.parentSessionId },
-				body: {
-					parts: [{ type: 'text', text: message }],
-				},
-				throwOnError: true,
-				responseStyle: 'data',
-				...this.getClientOverrides(),
-			});
-		} catch (error) {
-			console.error(
-				`[BackgroundManager] Failed to notify parent for task ${task.id}:`,
-				extractErrorMessage(error, 'notification failed')
-			);
+		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 as notified only AFTER confirmed delivery
+				notifiedStatuses.add(task.status);
+				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(task.status);
+				}
+			}
 		}
 	}
 
@@ -895,10 +1078,16 @@ Use the agentuity_background_output tool with task_id "${task.id}" to view the r
 		const now = Date.now();
 		for (const task of this.tasks.values()) {
 			if (task.status !== 'pending' && task.status !== 'running') continue;
-			const start = task.startedAt?.getTime() ?? task.queuedAt?.getTime();
-			if (!start) continue;
-			if (now - start > this.config.staleTimeoutMs) {
-				this.failTask(task, 'Background task timed out.');
+			// 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).');
 			}
 		}
 	}

package/src/background/types.ts

@@ -7,6 +7,8 @@ export interface TaskProgress {
 	lastUpdate: Date;
 	lastMessage?: string;
 	lastMessageAt?: Date;
+	/** Number of tool calls currently in-flight (pending/running state) */
+	activeToolCallsInFlight: number;
 }
 
 export interface BackgroundTask {
@@ -27,6 +29,7 @@ export interface BackgroundTask {
 	concurrencyKey?: string; // Active concurrency slot key
 	concurrencyGroup?: string; // Persistent key for re-acquiring on resume
 	notifiedStatuses?: Set<BackgroundTaskStatus>; // Tracks statuses already notified to prevent duplicates
+	isMonitor?: boolean; // True if this task is an auto-launched Monitor agent
 }
 
 export interface LaunchInput {

package/src/config/loader.ts

@@ -146,7 +146,7 @@ const DEFAULT_BLOCKED_COMMANDS = [
 
 const DEFAULT_BACKGROUND_CONFIG: BackgroundTaskConfig = {
 	enabled: true,
-	defaultConcurrency: 1,
+	defaultConcurrency: 5,
 	staleTimeoutMs: 30 * 60 * 1000,
 	providerConcurrency: {},
 	modelConcurrency: {},
@@ -199,7 +199,7 @@ function mergeBackgroundConfig(
 	if (!base && !override) return undefined;
 	return {
 		enabled: override?.enabled ?? base?.enabled ?? true,
-		defaultConcurrency: override?.defaultConcurrency ?? base?.defaultConcurrency ?? 1,
+		defaultConcurrency: override?.defaultConcurrency ?? base?.defaultConcurrency ?? 5,
 		staleTimeoutMs: override?.staleTimeoutMs ?? base?.staleTimeoutMs ?? 30 * 60 * 1000,
 		providerConcurrency: {
 			...(base?.providerConcurrency ?? {}),