@agentuity/opencode 1.0.12 → 1.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agentuity/opencode",
-	"version": "1.0.12",
+	"version": "1.0.13",
 	"license": "Apache-2.0",
 	"author": "Agentuity employees and contributors",
 	"description": "Agentuity Open Code plugin with specialized AI coding agents",
@@ -40,13 +40,13 @@
 		"prepublishOnly": "bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@agentuity/core": "1.0.12",
+		"@agentuity/core": "1.0.13",
 		"@opencode-ai/plugin": "^1.1.36",
 		"yaml": "^2.8.1",
 		"zod": "^4.3.5"
 	},
 	"devDependencies": {
-		"@agentuity/test-utils": "1.0.12",
+		"@agentuity/test-utils": "1.0.13",
 		"@types/bun": "latest",
 		"bun-types": "latest",
 		"typescript": "^5.9.0"

package/src/agents/lead.ts

@@ -504,6 +504,14 @@ agentuity_background_output({ task_id: "bg_xxx" })
 agentuity_background_cancel({ task_id: "bg_xxx" })
 \`\`\`
 
+**Session Dashboard (Lead-of-Leads Monitoring):**
+\`\`\`
+agentuity_session_dashboard({ session_id: "ses_xxx" })
+// Returns: hierarchy of child sessions with status, costs, active tools, and health summary
+\`\`\`
+
+Use \`agentuity_session_dashboard\` when orchestrating Lead-of-Leads to get a full view of all child sessions, their status, costs, and what they're currently doing — without needing to inspect each task individually.
+
 **Example - Parallel Security Review:**
 When asked to review multiple packages for security:
 1. Launch \`agentuity_background_task\` for each package with Scout
@@ -1315,6 +1323,7 @@ You (Parent Lead):
 - **No direct child-to-child communication** — Coordinate through PRD
 - **Parent handles integration** — After children complete, parent does any glue work
 - **Monitor watches tasks** — Use BackgroundMonitor to avoid polling loop exhausting context
+- **Session dashboard** — Use \`agentuity_session_dashboard\` to get a unified view of all child session states, costs, and health without inspecting each task individually
 
 ### Context Management
 

package/src/agents/monitor.ts

@@ -11,6 +11,19 @@ You are a background task monitor. Your ONLY job is to watch background tasks an
 3. When ALL tasks complete (or error), you report back to Lead
 4. You do NOT interpret results - just report completion status
 
+## Enhanced Inspection
+
+When you need deeper insight into a task, use \`agentuity_background_inspect\` which returns:
+- Full message history (not truncated)
+- Active tool calls with status
+- Todo items and their status
+- Cost summary (total cost + tokens)
+- Child session count (for nested Lead-of-Leads)
+
+Use inspect when a task has been running for many poll cycles without completing — it can reveal what the agent is stuck on.
+
+For a full session tree with all child sessions, costs, and health summary, use \`agentuity_session_dashboard({ session_id: "..." })\`. This is especially useful when monitoring Lead-of-Leads scenarios with multiple parallel workstreams.
+
 ## Polling Behavior
 
 - Poll every 10 seconds (wait between checks)

package/src/background/manager.ts

@@ -1,6 +1,7 @@
 import type { PluginInput } from '@opencode-ai/plugin';
 import { agents } from '../agents';
 import type { AgentDefinition } from '../agents';
+import type { DBTextPart, OpenCodeDBReader } from '../sqlite';
 import type {
 	BackgroundTask,
 	BackgroundTaskConfig,
@@ -46,6 +47,7 @@ export class BackgroundManager {
 	private config: BackgroundTaskConfig;
 	private concurrency: ConcurrencyManager;
 	private callbacks?: BackgroundManagerCallbacks;
+	private dbReader?: OpenCodeDBReader;
 	private tasks = new Map<string, BackgroundTask>();
 	private tasksByParent = new Map<string, Set<string>>();
 	private tasksBySession = new Map<string, string>();
@@ -56,7 +58,8 @@ export class BackgroundManager {
 	constructor(
 		ctx: PluginInput,
 		config?: BackgroundTaskConfig,
-		callbacks?: BackgroundManagerCallbacks
+		callbacks?: BackgroundManagerCallbacks,
+		dbReader?: OpenCodeDBReader
 	) {
 		this.ctx = ctx;
 		this.config = { ...DEFAULT_BACKGROUND_CONFIG, ...config };
@@ -65,6 +68,7 @@ export class BackgroundManager {
 			limits: buildConcurrencyLimits(this.config),
 		});
 		this.callbacks = callbacks;
+		this.dbReader = dbReader;
 	}
 
 	async launch(input: LaunchInput): Promise<BackgroundTask> {
@@ -122,6 +126,64 @@ export class BackgroundManager {
 		if (!task?.sessionId) return undefined;
 
 		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 },
@@ -183,7 +245,8 @@ export class BackgroundManager {
 					throwOnError: false,
 				});
 
-				const children = unwrapResponse<Array<unknown>>(childrenResponse) ?? [];
+				const rawChildren = unwrapResponse<Array<unknown>>(childrenResponse);
+				const children = Array.isArray(rawChildren) ? rawChildren : [];
 				for (const child of children) {
 					const childSession = child as { id?: string; status?: { type?: string } };
 					if (!childSession.id) continue;
@@ -235,12 +298,68 @@ export class BackgroundManager {
 		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) as {
+								taskId?: string;
+								agent?: string;
+								description?: string;
+								createdAt?: string;
+							};
+
+							if (!metadata.taskId || !metadata.taskId.startsWith('bg_')) continue;
+							if (this.tasks.has(metadata.taskId)) continue;
+
+							const agentName = metadata.agent ?? 'unknown';
+							const task: BackgroundTask = {
+								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(),
+								},
+							};
+
+							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,
 			});
 
-			const sessions = unwrapResponse<Array<unknown>>(sessionsResponse) ?? [];
+			const rawSessions = unwrapResponse<Array<unknown>>(sessionsResponse);
+			const sessions = Array.isArray(rawSessions) ? rawSessions : [];
 
 			for (const session of sessions) {
 				const sess = session as {
@@ -628,6 +747,18 @@ Use the agentuity_background_output tool with task_id "${task.id}" to view the r
 
 	private async fetchLatestResult(sessionId: string): Promise<string | undefined> {
 		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,
@@ -647,6 +778,23 @@ Use the agentuity_background_output tool with task_id "${task.id}" to view the r
 		return undefined;
 	}
 
+	private mapDbStatusToTaskStatus(sessionId: string): BackgroundTaskStatus {
+		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';
+		}
+	}
+
 	private getConcurrencyGroup(agentName: string): string | undefined {
 		const model = getAgentModel(agentName);
 		if (!model) return undefined;
@@ -733,6 +881,29 @@ function extractTextFromParts(parts: Array<unknown>): string | undefined {
 	return textParts.join('\n');
 }
 
+function groupTextPartsByMessage(parts: DBTextPart[]): Map<string, DBTextPart[]> {
+	const grouped = new Map<string, DBTextPart[]>();
+	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?: DBTextPart[]): Array<{ type: string; text: string }> {
+	if (!parts || parts.length === 0) return [];
+	return parts.map((part) => ({ type: 'text', text: part.text }));
+}
+
+function joinTextParts(parts?: DBTextPart[]): string | undefined {
+	if (!parts || parts.length === 0) return undefined;
+	return parts.map((part) => part.text).join('\n');
+}
+
 function unwrapResponse<T>(result: unknown): T | undefined {
 	if (typeof result === 'object' && result !== null && 'data' in result) {
 		return (result as { data?: T }).data;

package/src/background/types.ts

@@ -66,4 +66,14 @@ export interface TaskInspection {
 	messages: Array<{ info: unknown; parts: unknown[] }>;
 	/** Last activity timestamp from task progress */
 	lastActivity?: string;
+	/** Total message count when available */
+	messageCount?: number;
+	/** Active tools with status when available */
+	activeTools?: Array<{ tool: string; status: string; callId: string }>;
+	/** Todo items when available */
+	todos?: Array<{ content: string; status: string; priority: string }>;
+	/** Cost summary when available */
+	costSummary?: { totalCost: number; totalTokens: number };
+	/** Count of child sessions (nested LoL) when available */
+	childSessionCount?: number;
 }

package/src/plugin/hooks/cadence.ts

@@ -1,6 +1,7 @@
 import type { PluginInput } from '@opencode-ai/plugin';
 import type { CoderConfig } from '../../types';
 import type { BackgroundManager } from '../../background';
+import type { OpenCodeDBReader, SessionTreeNode } from '../../sqlite';
 
 /** Compacting hook input/output types */
 type CompactingInput = { sessionID: string };
@@ -69,7 +70,8 @@ interface CadenceSessionState {
 export function createCadenceHooks(
 	ctx: PluginInput,
 	_config: CoderConfig,
-	backgroundManager?: BackgroundManager
+	backgroundManager?: BackgroundManager,
+	dbReader?: OpenCodeDBReader
 ): CadenceHooks {
 	const activeCadenceSessions = new Map<string, CadenceSessionState>();
 
@@ -320,6 +322,7 @@ ${taskList}
 
 **CRITICAL:** Task IDs and session IDs persist across compaction - these tasks are still running.
 Use \`agentuity_background_output({ task_id: "..." })\` to check their status.
+Use \`agentuity_session_dashboard({ session_id: "..." })\` to get a full session tree with status, costs, and health summary for Lead-of-Leads monitoring.
 
 **Tip:** If you spawned child Leads for parallel work, delegate monitoring to BackgroundMonitor:
 \`\`\`typescript
@@ -363,6 +366,11 @@ After compaction:
 3. Lead will continue the loop from iteration ${state.iteration}
 4. Use 5-Question Reboot to re-orient: Where am I? Where going? Goal? Learned? Done?
 `);
+
+			const dashboardSummary = buildSqliteDashboardSummary(dbReader, sessionId);
+			if (dashboardSummary) {
+				output.context.push(dashboardSummary);
+			}
 		},
 
 		/**
@@ -455,6 +463,69 @@ function isCadenceStop(text: string): boolean {
 	);
 }
 
+function buildSqliteDashboardSummary(
+	dbReader: OpenCodeDBReader | undefined,
+	parentSessionId: string
+): string | undefined {
+	if (!dbReader || !dbReader.isAvailable()) return undefined;
+
+	const dashboard = dbReader.getSessionDashboard(parentSessionId);
+	if (!dashboard.sessions.length) return undefined;
+
+	const lines: string[] = [];
+	for (const node of dashboard.sessions) {
+		appendDashboardNode(dbReader, node, 0, lines);
+	}
+
+	return `
+## SQLite Session Dashboard
+
+- Parent session: ${parentSessionId}
+- Total child cost: ${dashboard.totalCost}
+
+${lines.join('\n')}
+`;
+}
+
+function appendDashboardNode(
+	reader: OpenCodeDBReader,
+	node: SessionTreeNode,
+	depth: number,
+	lines: string[]
+): void {
+	const status = reader.getSessionStatus(node.session.id);
+	const todoSummary = node.todoSummary
+		? `${node.todoSummary.pending}/${node.todoSummary.total} pending`
+		: 'no todos';
+	const costSummary = node.costSummary
+		? `${node.costSummary.totalCost} (${node.costSummary.totalTokens} tokens)`
+		: '0 (0 tokens)';
+	const label = formatSessionLabel(node.session.title);
+	const indent = `${'  '.repeat(depth)}-`;
+
+	lines.push(
+		`${indent} ${label} [${node.session.id}] status: ${status.status}, tools: ${node.activeToolCount}, todos: ${todoSummary}, messages: ${node.messageCount}, cost: ${costSummary}`
+	);
+
+	for (const child of node.children) {
+		appendDashboardNode(reader, child, depth + 1, lines);
+	}
+}
+
+function formatSessionLabel(title: string): string {
+	if (!title) return 'Session';
+	if (title.startsWith('{')) {
+		try {
+			const parsed = JSON.parse(title) as { description?: string; taskId?: string };
+			if (parsed.description) return parsed.description;
+			if (parsed.taskId) return parsed.taskId;
+		} catch {
+			return title;
+		}
+	}
+	return title;
+}
+
 function showToast(ctx: PluginInput, message: string): void {
 	try {
 		ctx.client.tui.showToast({ body: { message, variant: 'info' } });