@agentuity/opencode 1.0.19 → 1.0.20

package/src/plugin/plugin.ts

@@ -17,7 +17,6 @@ import { createCadenceHooks } from './hooks/cadence';
 import { createSessionMemoryHooks } from './hooks/session-memory';
 import { createCompletionHooks } from './hooks/completion';
 import type { AgentRole } from '../types';
-import { BackgroundManager } from '../background';
 import type { SessionTreeNode } from '../sqlite';
 import { OpenCodeDBReader } from '../sqlite';
 import { TmuxSessionManager } from '../tmux';
@@ -114,76 +113,18 @@ export async function createCoderPlugin(ctx: PluginInput): Promise<Hooks> {
 					}),
 			})
 		: undefined;
-	const backgroundManager = new BackgroundManager(
-		ctx,
-		coderConfig.background,
-		{
-			onSubagentSessionCreated: tmuxManager
-				? (event) => {
-						void tmuxManager.onSessionCreated(event);
-					}
-				: undefined,
-			onSubagentSessionDeleted: tmuxManager
-				? (event) => {
-						void tmuxManager.onSessionDeleted(event);
-					}
-				: undefined,
-			onShutdown: tmuxManager
-				? () => {
-						void tmuxManager.cleanup();
-					}
-				: undefined,
-		},
-		dbReader
-	);
-
-	// Recover any background tasks from previous sessions
-	// This allows tasks to survive plugin restarts
-	void backgroundManager
-		.recoverTasks()
-		.then((count) => {
-			if (count > 0) {
-				ctx.client.app.log({
-					body: {
-						service: 'agentuity-coder',
-						level: 'info',
-						message: `Recovered ${count} background task(s) from previous sessions`,
-					},
-				});
-			}
-		})
-		.catch((error) => {
-			ctx.client.app.log({
-				body: {
-					service: 'agentuity-coder',
-					level: 'warn',
-					message: `Failed to recover background tasks: ${error}`,
-				},
-			});
-		});
 
-	// Create hooks that need backgroundManager for task reference injection during compaction
-	const cadenceHooks = createCadenceHooks(
-		ctx,
-		coderConfig,
-		backgroundManager,
-		dbReader,
-		lastUserMessages
-	);
+	// Create hooks for session routing and compaction behavior
+	const cadenceHooks = createCadenceHooks(ctx, coderConfig, dbReader, lastUserMessages);
 
 	// Session memory hooks handle checkpointing and compaction for non-Cadence sessions
 	// Orchestration (deciding which module handles which session) happens below in the hooks
-	const sessionMemoryHooks = createSessionMemoryHooks(
-		ctx,
-		coderConfig,
-		backgroundManager,
-		dbReader
-	);
+	const sessionMemoryHooks = createSessionMemoryHooks(ctx, coderConfig, dbReader);
 
 	const configHandler = createConfigHandler(coderConfig);
 
 	// Create plugin tools using the @opencode-ai/plugin tool helper
-	const tools = createTools(backgroundManager, dbReader);
+	const tools = createTools(dbReader);
 
 	// Create a logger for shutdown handler
 	const shutdownLogger = (message: string) =>
@@ -195,7 +136,7 @@ export async function createCoderPlugin(ctx: PluginInput): Promise<Hooks> {
 			},
 		});
 
-	registerShutdownHandler(backgroundManager, tmuxManager, shutdownLogger, dbReader);
+	registerShutdownHandler(tmuxManager, shutdownLogger, dbReader);
 
 	// Show startup toast (fire and forget, don't block)
 	try {
@@ -245,10 +186,6 @@ export async function createCoderPlugin(ctx: PluginInput): Promise<Hooks> {
 			}
 		},
 		event: async (input) => {
-			const event = extractEventFromInput(input);
-			if (event) {
-				backgroundManager.handleEvent(event);
-			}
 			// Orchestrate: route to appropriate module based on session type
 			const sessionId = extractSessionIdFromEvent(input);
 			if (sessionId) {
@@ -628,7 +565,7 @@ $ARGUMENTS
 ## Lead-of-Leads (Parallel Work)
 If the task has **independent workstreams** that can run in parallel (e.g., "build auth, payments, and notifications"):
 1. Ask @Agentuity Coder Product to create PRD with workstreams
-2. Spawn child Leads via \`agentuity_background_task\` for each workstream
+2. Spawn child Leads using the \`task\` tool (issue multiple task calls in a single response for parallel work)
 3. Each child Lead claims a workstream, works autonomously, marks done when complete
 4. Monitor progress via PRD workstream status
 5. Do integration work when all children complete
@@ -674,170 +611,10 @@ function normalizeBaseDir(path: string): string {
 	return path.replace(/[\\/]+$/, '');
 }
 
-function createTools(
-	backgroundManager: BackgroundManager,
-	dbReader?: OpenCodeDBReader
-): Hooks['tool'] {
+function createTools(dbReader?: OpenCodeDBReader): Hooks['tool'] {
 	// Use the schema from @opencode-ai/plugin's tool helper to avoid Zod version mismatches
 	const s = tool.schema;
 
-	const backgroundTask = tool({
-		description: `Launch a task to run in the background. Use this for parallel execution of multiple independent tasks.
-
-IMPORTANT: Use this tool instead of the 'task' tool when:
-- You need to run multiple agents in parallel
-- Tasks are independent and don't need sequential execution
-- The user asks for "parallel", "background", or "concurrent" work`,
-		args: {
-			agent: s
-				.enum([
-					'lead',
-					'scout',
-					'builder',
-					'architect',
-					'reviewer',
-					'memory',
-					'expert',
-					'runner',
-					'product',
-					'monitor',
-				])
-				.describe('Agent role to run the task'),
-			task: s.string().describe('Task prompt to run in the background'),
-			description: s.string().optional().describe('Short description of the task'),
-		},
-		async execute(args, context) {
-			const parentSessionId = context.sessionID;
-			if (!parentSessionId) {
-				return JSON.stringify({
-					taskId: 'unknown',
-					status: 'error',
-					message: 'Missing session context for background task.',
-				});
-			}
-
-			const agentName = resolveAgentName(args.agent as AgentRole);
-			const bgTask = await backgroundManager.launch({
-				description: args.description ?? args.task,
-				prompt: args.task,
-				agent: agentName,
-				parentSessionId,
-				parentMessageId: context.messageID,
-			});
-			return JSON.stringify({
-				taskId: bgTask.id,
-				status: bgTask.status,
-				message:
-					bgTask.status === 'error'
-						? (bgTask.error ?? 'Failed to launch background task.')
-						: 'Background task launched.',
-			});
-		},
-	});
-
-	const backgroundOutput = tool({
-		description: 'Retrieve output for a background task.',
-		args: {
-			task_id: s.string().describe('Background task ID'),
-		},
-		async execute(args) {
-			const bgTask = backgroundManager.getTask(args.task_id);
-			if (!bgTask) {
-				return JSON.stringify({
-					taskId: args.task_id,
-					status: 'error',
-					error: 'Task not found.',
-				});
-			}
-			return JSON.stringify({
-				taskId: bgTask.id,
-				status: bgTask.status,
-				result: bgTask.result,
-				error: bgTask.error,
-			});
-		},
-	});
-
-	const backgroundCancel = tool({
-		description: 'Cancel a running background task.',
-		args: {
-			task_id: s.string().describe('Background task ID'),
-		},
-		async execute(args) {
-			const success = backgroundManager.cancel(args.task_id);
-			return JSON.stringify({
-				taskId: args.task_id,
-				success,
-				message: success ? 'Background task cancelled.' : 'Unable to cancel task.',
-			});
-		},
-	});
-
-	const backgroundInspect = tool({
-		description: `Inspect a background task to see its session messages and current state. Useful for debugging or checking what a child agent is doing.`,
-		args: {
-			task_id: s.string().describe('Background task ID to inspect'),
-		},
-		async execute(args) {
-			const inspection = await backgroundManager.inspectTask(args.task_id);
-			if (!inspection) {
-				return JSON.stringify({
-					taskId: args.task_id,
-					status: 'unknown',
-					found: false,
-					error: 'Task not found or session no longer exists.',
-				});
-			}
-
-			const messages = inspection.messages ?? [];
-			const enhanced =
-				inspection.messageCount !== undefined ||
-				inspection.activeTools !== undefined ||
-				inspection.todos !== undefined ||
-				inspection.costSummary !== undefined ||
-				inspection.childSessionCount !== undefined;
-
-			if (enhanced) {
-				return JSON.stringify({
-					taskId: inspection.taskId,
-					status: inspection.status,
-					found: true,
-					messageCount: inspection.messageCount ?? messages.length,
-					messages,
-					lastActivity: inspection.lastActivity,
-					activeTools: inspection.activeTools,
-					todos: inspection.todos,
-					costSummary: inspection.costSummary,
-					childSessionCount: inspection.childSessionCount,
-				});
-			}
-
-			// Extract last few messages for summary (fallback)
-			const lastMessages = messages
-				.slice(-3)
-				.map((m) => {
-					const parts = m.parts ?? [];
-					const textParts = parts.filter(
-						(p: unknown) => (p as { type?: string }).type === 'text'
-					);
-					return textParts
-						.map((p: unknown) => ((p as { text?: string }).text ?? '').slice(0, 200))
-						.join(' ')
-						.slice(0, 300);
-				})
-				.filter(Boolean);
-
-			return JSON.stringify({
-				taskId: inspection.taskId,
-				status: inspection.status,
-				found: true,
-				messageCount: messages.length,
-				lastMessages,
-				lastActivity: inspection.lastActivity,
-			});
-		},
-	});
-
 	const sessionDashboard = tool({
 		description:
 			'Inspect a parent session dashboard from the local OpenCode SQLite database. Useful for Lead-of-Leads monitoring and nested session visibility.',
@@ -1007,10 +784,6 @@ Returns the public URL that can be copied and used anywhere.`,
 	});
 
 	return {
-		agentuity_background_task: backgroundTask,
-		agentuity_background_output: backgroundOutput,
-		agentuity_background_cancel: backgroundCancel,
-		agentuity_background_inspect: backgroundInspect,
 		agentuity_session_dashboard: sessionDashboard,
 		agentuity_memory_share: memoryShare,
 	};
@@ -1032,20 +805,6 @@ function extractSessionIdFromEvent(input: unknown): string | undefined {
 	);
 }
 
-function resolveAgentName(role: AgentRole): string {
-	const agent = agents[role];
-	return agent?.displayName ?? role;
-}
-
-function extractEventFromInput(
-	input: unknown
-): { type: string; properties?: Record<string, unknown> } | undefined {
-	if (typeof input !== 'object' || input === null) return undefined;
-	const inp = input as { event?: { type?: string; properties?: Record<string, unknown> } };
-	if (!inp.event || typeof inp.event.type !== 'string') return undefined;
-	return { type: inp.event.type, properties: inp.event.properties };
-}
-
 function parseDisplayTitle(rawTitle: string): string {
 	try {
 		const parsed = JSON.parse(rawTitle);
@@ -1210,7 +969,6 @@ function isMemoryPath(path: string): boolean {
 }
 
 function registerShutdownHandler(
-	manager: BackgroundManager,
 	tmuxManager?: TmuxSessionManager,
 	logger?: (msg: string) => void,
 	dbReader?: OpenCodeDBReader
@@ -1238,14 +996,6 @@ function registerShutdownHandler(
 
 		log(`Shutdown triggered by ${signal ?? 'unknown'} signal`);
 
-		try {
-			log('Shutting down background manager...');
-			manager.shutdown();
-			log('Background manager shutdown complete');
-		} catch (error) {
-			log(`Background manager shutdown error: ${error}`);
-		}
-
 		if (tmuxManager) {
 			try {
 				log('Cleaning up tmux sessions...');

package/src/sqlite/types.ts

@@ -142,7 +142,6 @@ export interface DBToolCallSummary {
 /** Stats about what compaction preserved */
 export interface CompactionStats {
 	planningPhasesCount: number;
-	backgroundTasksCount: number;
 	imageDescriptionsCount: number;
 	toolCallSummariesCount: number;
 	estimatedTokens: number;
@@ -153,7 +152,6 @@ export interface PreCompactionSnapshot {
 	timestamp: string;
 	sessionId: string;
 	planningState?: Record<string, unknown>;
-	backgroundTasks?: Array<{ id: string; description: string; status: string }>;
 	imageDescriptions?: string[];
 	toolCallSummaries?: string[];
 	cadenceState?: Record<string, unknown>;

package/src/tmux/manager.ts

@@ -52,7 +52,7 @@ export interface TmuxSessionManagerCallbacks {
 }
 
 /**
- * Manages tmux panes for background agents.
+ * Manages tmux panes for agent sessions.
  *
  * Architecture:
  * 1. QUERY: Get actual tmux pane state (source of truth)
@@ -106,8 +106,8 @@ export class TmuxSessionManager {
 	}
 
 	/**
-	 * Handle a new background session being created
-	 * This is called by BackgroundManager when a background task starts
+	 * Handle a new subagent session being created
+	 * This is called when a delegated session starts
 	 *
 	 * Operations are queued to prevent race conditions when multiple sessions
 	 * are created rapidly.
@@ -251,7 +251,7 @@ export class TmuxSessionManager {
 	/**
 	 * Handle a session being deleted
 	 *
-	 * Explicitly kills the pane when a background session completes.
+	 * Explicitly kills the pane when a subagent session completes.
 	 * We can't rely on `opencode attach` exiting because it's an interactive
 	 * terminal that keeps running even after the session goes idle.
 	 *

package/src/tmux/types.ts

@@ -29,11 +29,11 @@ export interface WindowState {
 	windowWidth: number;
 	windowHeight: number;
 	mainPane: TmuxPaneInfo | null; // The pane running the main agent
-	agentPanes: TmuxPaneInfo[]; // Panes for background agents
+	agentPanes: TmuxPaneInfo[]; // Panes for subagent sessions
 }
 
 /**
- * Tracked session for a background agent in tmux
+ * Tracked session for a subagent in tmux
  */
 export interface TrackedSession {
 	sessionId: string; // OpenCode session ID

package/src/tools/index.ts

@@ -1,9 +1,2 @@
-export {
-	createBackgroundTools,
-	BackgroundTaskArgsSchema,
-	BackgroundOutputArgsSchema,
-	BackgroundCancelArgsSchema,
-	type BackgroundTaskArgs,
-	type BackgroundOutputArgs,
-	type BackgroundCancelArgs,
-} from './background';
+// Tools are registered directly in plugin/plugin.ts
+export {};

package/src/types.ts

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import type { BackgroundTaskConfig } from './background/types';
 import type { SkillsConfig } from './skills/types';
 import type { TmuxConfig } from './tmux/types';
 
@@ -11,7 +10,6 @@ export type {
 	ToolDefinition,
 } from '@opencode-ai/plugin';
 
-export type { BackgroundTaskConfig } from './background/types';
 export type { SkillsConfig, LoadedSkill, SkillMetadata, SkillScope } from './skills';
 export type { TmuxConfig } from './tmux/types';
 
@@ -28,7 +26,6 @@ export const AgentRoleSchema = z.enum([
 	'expert-ops',
 	'runner',
 	'product',
-	'monitor',
 ]);
 export type AgentRole = z.infer<typeof AgentRoleSchema>;
 
@@ -184,20 +181,11 @@ export interface CoderConfig {
 	disabledMcps?: string[];
 	/** CLI command patterns to block for security (e.g., 'cloud secrets', 'auth token') */
 	blockedCommands?: string[];
-	background?: BackgroundTaskConfig;
 	skills?: SkillsConfig;
 	tmux?: TmuxConfig;
 	compaction?: CompactionConfig;
 }
 
-export const BackgroundTaskConfigSchema = z.object({
-	enabled: z.boolean(),
-	defaultConcurrency: z.number(),
-	staleTimeoutMs: z.number(),
-	providerConcurrency: z.record(z.string(), z.number()).optional(),
-	modelConcurrency: z.record(z.string(), z.number()).optional(),
-});
-
 export const SkillsConfigSchema = z.object({
 	enabled: z.boolean(),
 	paths: z.array(z.string()).optional(),
@@ -225,7 +213,6 @@ export const CoderConfigSchema = z.object({
 	org: z.string().optional(),
 	disabledMcps: z.array(z.string()).optional(),
 	blockedCommands: z.array(z.string()).optional(),
-	background: BackgroundTaskConfigSchema.optional(),
 	skills: SkillsConfigSchema.optional(),
 	tmux: TmuxConfigSchema.optional(),
 	compaction: CompactionConfigSchema.optional(),

package/dist/agents/monitor.d.ts

@@ -1,4 +0,0 @@
-import type { AgentDefinition } from './types';
-export declare const MONITOR_SYSTEM_PROMPT = "# BackgroundMonitor Agent\n\nYou are an auto-launched background task monitor. You were spawned automatically when Lead started background tasks. Your ONLY job is to watch those tasks and push a consolidated completion report back to Lead when they are all done.\n\n**Lead is not polling. Lead is not watching. You are the eyes. Lead trusts you to report.**\n\n## How You Discover Tasks\n\nYou receive a parent session ID in your prompt. Use it to discover all sibling tasks:\n\n```\nagentuity_session_dashboard({ session_id: \"<parentSessionId>\" })\n```\n\nThis is scoped to child sessions of that parent only \u2014 it does not expose unrelated sessions.\nFrom the dashboard, extract the task IDs (bg_xxx format) from session titles.\nThen use `agentuity_background_output({ task_id: \"bg_xxx\" })` to get status + progress for each.\n\nIgnore sessions that are other Monitor instances \u2014 their `displayTitle` will be \"Monitor background tasks\". Filter these out when processing the dashboard results.\n\n## Progress Signal\n\n`agentuity_background_output` now returns a `progress` object on running tasks:\n\n```json\n{\n  \"status\": \"running\",\n  \"progress\": {\n    \"toolCalls\": 21,\n    \"lastTool\": \"read\",\n    \"lastToolSec\": 12,\n    \"activeTools\": 1\n  }\n}\n```\n\n- `toolCalls`: total tool calls completed \u2014 growing means active work\n- `lastTool`: name of the most recently completed tool\n- `lastToolSec`: seconds since last tool activity \u2014 <300 with growth means healthy\n- `activeTools`: tool calls currently in-flight\n\nA task is **stuck** only if `lastToolSec > 300` AND `activeTools === 0` AND `toolCalls` has not grown between checks.\n\n## Check Cadence \u2014 CRITICAL\n\n**You MUST wait at least 20 seconds between each check cycle.** This is a hard requirement, not a suggestion.\n\n- Minimum 20 seconds between checks \u2014 count them, do not rush\n- Maximum 10 check cycles total (covers ~3-4 minutes of typical work)\n- After EACH check, output: \"\u23F3 Waiting 20 seconds before next check...\" \u2014 this helps you pace yourself\n- Scout tasks typically take 3\u20138 minutes \u2014 be patient, checking faster does NOT make them complete faster\n- Excessive polling wastes tokens and provides no benefit\n\nFor each poll cycle (track cycle number starting at 1):\n1. Check each task ID with `agentuity_background_output({ task_id: \"bg_xxx\" })`\n2. Track the status of each task\n3. If any task is still \"pending\" or \"running\" **and cycle < 10**, wait 20 seconds and poll again\n4. When all tasks are \"completed\" or \"error\" **OR cycle reaches 10**, generate the final report\n\n## When Tasks Are Stuck\n\nIf a task shows `lastToolSec > 300` AND `activeTools === 0`:\n1. Call `agentuity_background_inspect({ task_id: \"bg_xxx\" })` for a full view\n2. Include what you found in your final report under \"Stuck Tasks\"\n3. Do NOT cancel the task \u2014 report it to Lead for a decision\n\n## Completion Condition\n\nAll work tasks are done when every non-monitor task is `completed`, `error`, or `cancelled`.\n\n## Final Report Format\n\nWhen all tasks are done (or after 20 cycles), output exactly this:\n\n```markdown\n## [ALL BACKGROUND TASKS COMPLETE]\n\n- **bg_xxx** (completed): [first 100 chars of result]\n- **bg_yyy** (error): [error message]\n- **bg_zzz** (completed): [first 100 chars of result]\n\n### Results\n\n**bg_xxx:**\n[full result text]\n\n**bg_yyy (error):**\n[error]\n```\n\nIf tasks are still running after 10 cycles, use \"## [BACKGROUND TASKS STILL RUNNING]\" as the header and list the stuck ones with their last known progress.\n\n## Timeout Errors\n\n- **Timeout errors** (\"Background task timed out (no activity).\") often occur when the model is\n  generating a long text response without making tool calls. These are server-side inactivity\n  timeouts, not true failures \u2014 the model was still working but appeared idle to the server.\n- If a task errors with a timeout, note this in your report. It may be worth retrying.\n\n## What You Do NOT Do\n\n- \u274C Interpret or analyze task results beyond summarizing\n- \u274C Make decisions about next steps\n- \u274C Cancel tasks (ever)\n- \u274C Interact with the user\n- \u274C Modify any files\n- \u274C Call other agents\n- \u274C Use tools other than agentuity_background_output, agentuity_background_inspect, and agentuity_session_dashboard\n\nYou are a patient, focused watcher. When work is done, you report. Nothing more.\n\n## Example Workflow\n\nGiven task: \"Monitor these tasks: bg_abc123, bg_def456\"\n\n1. Call agentuity_background_output for bg_abc123\n2. Call agentuity_background_output for bg_def456\n3. If any status is \"pending\" or \"running\" and cycle < 10, wait 20 seconds\n4. Repeat steps 1-3 until all complete or 10 cycles reached\n5. Output final report\n\n## Waiting Between Polls\n\nSince you cannot use setTimeout, after checking all tasks and finding some still running, you MUST output:\n\n\"\u23F3 Waiting 20 seconds before next check... (cycle 3/10)\"\n\nThen poll again. The conversation history serves as your \"timer\" \u2014 each response and check adds natural delay. Do NOT skip the waiting message.\n\n**After 10 cycles:** Report final status even if tasks are still running, noting which tasks did not complete within the monitoring window.\n";
-export declare const monitorAgent: AgentDefinition;
-//# sourceMappingURL=monitor.d.ts.map

package/dist/agents/monitor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"monitor.d.ts","sourceRoot":"","sources":["../../src/agents/monitor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,eAAO,MAAM,qBAAqB,muKAkIjC,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,eA0B1B,CAAC"}

package/dist/agents/monitor.js

@@ -1,159 +0,0 @@
-export const MONITOR_SYSTEM_PROMPT = `# BackgroundMonitor Agent
-
-You are an auto-launched background task monitor. You were spawned automatically when Lead started background tasks. Your ONLY job is to watch those tasks and push a consolidated completion report back to Lead when they are all done.
-
-**Lead is not polling. Lead is not watching. You are the eyes. Lead trusts you to report.**
-
-## How You Discover Tasks
-
-You receive a parent session ID in your prompt. Use it to discover all sibling tasks:
-
-\`\`\`
-agentuity_session_dashboard({ session_id: "<parentSessionId>" })
-\`\`\`
-
-This is scoped to child sessions of that parent only — it does not expose unrelated sessions.
-From the dashboard, extract the task IDs (bg_xxx format) from session titles.
-Then use \`agentuity_background_output({ task_id: "bg_xxx" })\` to get status + progress for each.
-
-Ignore sessions that are other Monitor instances — their \`displayTitle\` will be "Monitor background tasks". Filter these out when processing the dashboard results.
-
-## Progress Signal
-
-\`agentuity_background_output\` now returns a \`progress\` object on running tasks:
-
-\`\`\`json
-{
-  "status": "running",
-  "progress": {
-    "toolCalls": 21,
-    "lastTool": "read",
-    "lastToolSec": 12,
-    "activeTools": 1
-  }
-}
-\`\`\`
-
-- \`toolCalls\`: total tool calls completed — growing means active work
-- \`lastTool\`: name of the most recently completed tool
-- \`lastToolSec\`: seconds since last tool activity — <300 with growth means healthy
-- \`activeTools\`: tool calls currently in-flight
-
-A task is **stuck** only if \`lastToolSec > 300\` AND \`activeTools === 0\` AND \`toolCalls\` has not grown between checks.
-
-## Check Cadence — CRITICAL
-
-**You MUST wait at least 20 seconds between each check cycle.** This is a hard requirement, not a suggestion.
-
-- Minimum 20 seconds between checks — count them, do not rush
-- Maximum 10 check cycles total (covers ~3-4 minutes of typical work)
-- After EACH check, output: "⏳ Waiting 20 seconds before next check..." — this helps you pace yourself
-- Scout tasks typically take 3–8 minutes — be patient, checking faster does NOT make them complete faster
-- Excessive polling wastes tokens and provides no benefit
-
-For each poll cycle (track cycle number starting at 1):
-1. Check each task ID with \`agentuity_background_output({ task_id: "bg_xxx" })\`
-2. Track the status of each task
-3. If any task is still "pending" or "running" **and cycle < 10**, wait 20 seconds and poll again
-4. When all tasks are "completed" or "error" **OR cycle reaches 10**, generate the final report
-
-## When Tasks Are Stuck
-
-If a task shows \`lastToolSec > 300\` AND \`activeTools === 0\`:
-1. Call \`agentuity_background_inspect({ task_id: "bg_xxx" })\` for a full view
-2. Include what you found in your final report under "Stuck Tasks"
-3. Do NOT cancel the task — report it to Lead for a decision
-
-## Completion Condition
-
-All work tasks are done when every non-monitor task is \`completed\`, \`error\`, or \`cancelled\`.
-
-## Final Report Format
-
-When all tasks are done (or after 20 cycles), output exactly this:
-
-\`\`\`markdown
-## [ALL BACKGROUND TASKS COMPLETE]
-
-- **bg_xxx** (completed): [first 100 chars of result]
-- **bg_yyy** (error): [error message]
-- **bg_zzz** (completed): [first 100 chars of result]
-
-### Results
-
-**bg_xxx:**
-[full result text]
-
-**bg_yyy (error):**
-[error]
-\`\`\`
-
-If tasks are still running after 10 cycles, use "## [BACKGROUND TASKS STILL RUNNING]" as the header and list the stuck ones with their last known progress.
-
-## Timeout Errors
-
-- **Timeout errors** ("Background task timed out (no activity).") often occur when the model is
-  generating a long text response without making tool calls. These are server-side inactivity
-  timeouts, not true failures — the model was still working but appeared idle to the server.
-- If a task errors with a timeout, note this in your report. It may be worth retrying.
-
-## What You Do NOT Do
-
-- ❌ Interpret or analyze task results beyond summarizing
-- ❌ Make decisions about next steps
-- ❌ Cancel tasks (ever)
-- ❌ Interact with the user
-- ❌ Modify any files
-- ❌ Call other agents
-- ❌ Use tools other than agentuity_background_output, agentuity_background_inspect, and agentuity_session_dashboard
-
-You are a patient, focused watcher. When work is done, you report. Nothing more.
-
-## Example Workflow
-
-Given task: "Monitor these tasks: bg_abc123, bg_def456"
-
-1. Call agentuity_background_output for bg_abc123
-2. Call agentuity_background_output for bg_def456
-3. If any status is "pending" or "running" and cycle < 10, wait 20 seconds
-4. Repeat steps 1-3 until all complete or 10 cycles reached
-5. Output final report
-
-## Waiting Between Polls
-
-Since you cannot use setTimeout, after checking all tasks and finding some still running, you MUST output:
-
-"⏳ Waiting 20 seconds before next check... (cycle 3/10)"
-
-Then poll again. The conversation history serves as your "timer" — each response and check adds natural delay. Do NOT skip the waiting message.
-
-**After 10 cycles:** Report final status even if tasks are still running, noting which tasks did not complete within the monitoring window.
-`;
-export const monitorAgent = {
-    role: 'monitor',
-    id: 'ag-monitor',
-    displayName: 'Agentuity Coder Monitor',
-    description: 'Background task monitor - watches background tasks and reports completions',
-    defaultModel: 'anthropic/claude-haiku-4-5-20251001', // Lightweight, fast
-    systemPrompt: MONITOR_SYSTEM_PROMPT,
-    mode: 'subagent', // Only used as subagent, never primary
-    hidden: true, // Hidden from @ autocomplete, but can be invoked via Task tool
-    tools: {
-        // Monitor only needs the background output tool - exclude everything else
-        exclude: [
-            'write',
-            'edit',
-            'apply_patch',
-            'bash',
-            'read',
-            'glob',
-            'grep',
-            'task',
-            'agentuity_background_task',
-            'agentuity_background_cancel',
-            'agentuity_memory_share',
-        ],
-    },
-    temperature: 0.0, // Deterministic - just poll and report
-};
-//# sourceMappingURL=monitor.js.map

package/dist/agents/monitor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"monitor.js","sourceRoot":"","sources":["../../src/agents/monitor.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,qBAAqB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkIpC,CAAC;AAEF,MAAM,CAAC,MAAM,YAAY,GAAoB;IAC5C,IAAI,EAAE,SAAS;IACf,EAAE,EAAE,YAAY;IAChB,WAAW,EAAE,yBAAyB;IACtC,WAAW,EAAE,4EAA4E;IACzF,YAAY,EAAE,qCAAqC,EAAE,oBAAoB;IACzE,YAAY,EAAE,qBAAqB;IACnC,IAAI,EAAE,UAAU,EAAE,uCAAuC;IACzD,MAAM,EAAE,IAAI,EAAE,+DAA+D;IAC7E,KAAK,EAAE;QACN,0EAA0E;QAC1E,OAAO,EAAE;YACR,OAAO;YACP,MAAM;YACN,aAAa;YACb,MAAM;YACN,MAAM;YACN,MAAM;YACN,MAAM;YACN,MAAM;YACN,2BAA2B;YAC3B,6BAA6B;YAC7B,wBAAwB;SACxB;KACD;IACD,WAAW,EAAE,GAAG,EAAE,uCAAuC;CACzD,CAAC"}

package/dist/background/concurrency.d.ts

@@ -1,36 +0,0 @@
-/**
- * Error thrown when a concurrency waiter is cancelled.
- */
-export declare const ConcurrencyCancelledError: {
-    new (args?: ({
-        key?: string;
-    } & {
-        cause?: unknown;
-    }) | undefined): import("@agentuity/core").RichError & {
-        readonly _tag: "ConcurrencyCancelledError";
-    } & Readonly<{
-        key?: string;
-    }>;
-    readonly defaultMessage?: string;
-};
-export interface ConcurrencyConfig {
-    defaultLimit: number;
-    limits?: Record<string, number>;
-}
-export declare class ConcurrencyManager {
-    private defaultLimit;
-    private limits;
-    private counts;
-    private queues;
-    constructor(config?: Partial<ConcurrencyConfig>);
-    getConcurrencyLimit(key: string): number;
-    acquire(key: string): Promise<void>;
-    release(key: string): void;
-    cancelWaiters(key: string): void;
-    clear(): void;
-    getCount(key: string): number;
-    getQueueLength(key: string): number;
-    private getQueue;
-    private flushQueue;
-}
-//# sourceMappingURL=concurrency.d.ts.map