@agnishc/edb-subagents 0.14.3 → 0.16.0

package/CHANGELOG.md

@@ -1,5 +1,7 @@
 # Changelog
 
+## [0.16.0] - 2026-06-22
+
 ## [0.13.0] - 2026-05-23
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agnishc/edb-subagents",
-	"version": "0.14.3",
+	"version": "0.16.0",
 	"description": "Pi extension: Claude Code-style autonomous sub-agents with live widget, parallel execution, mid-run steering, and custom agent types",
 	"keywords": [
 		"pi-package",

package/src/agent-manager.ts

@@ -296,6 +296,18 @@ export class AgentManager {
 
 		const promise = runWithFallback()
 			.then(({ responseText, session, aborted, steered }) => {
+				// If agent sent ask_supervisor and yielded, suspend instead of completing.
+				// The session stays alive — resumeInBackground will restart it with the answer.
+				if (record.pendingSupervisorAsk && record.status !== "stopped") {
+					record.status = "suspended";
+					record.session = session;
+					// Decrement so the queue can drain — this agent is no longer "running"
+					if (options.isBackground) {
+						this.runningBackground--;
+						this.drainQueue();
+					}
+					return responseText;
+				}
 				// Don't overwrite status if externally stopped via abort()
 				if (record.status !== "stopped") {
 					record.status = aborted ? "aborted" : steered ? "steered" : "completed";
@@ -432,11 +444,13 @@ export class AgentManager {
 	/**
 	 * Resume an existing agent session with a new prompt in the background (non-blocking).
 	 * Returns immediately; the record's promise resolves when done.
+	 * Also clears pendingSupervisorAsk so the agent transitions cleanly from "suspended".
 	 */
 	resumeInBackground(id: string, prompt: string): AgentRecord | undefined {
 		const record = this.agents.get(id);
 		if (!record?.session) return undefined;
 
+		record.pendingSupervisorAsk = false;
 		record.status = "running";
 		record.startedAt = Date.now();
 		record.completedAt = undefined;
@@ -557,7 +571,7 @@ export class AgentManager {
 	private cleanup() {
 		const cutoff = Date.now() - 10 * 60_000;
 		for (const [id, record] of this.agents) {
-			if (record.status === "running" || record.status === "queued") continue;
+			if (record.status === "running" || record.status === "queued" || record.status === "suspended") continue;
 			if ((record.completedAt ?? 0) >= cutoff) continue;
 			this.removeRecord(id, record);
 		}
@@ -569,7 +583,7 @@ export class AgentManager {
 	 */
 	clearCompleted(): void {
 		for (const [id, record] of this.agents) {
-			if (record.status === "running" || record.status === "queued") continue;
+			if (record.status === "running" || record.status === "queued" || record.status === "suspended") continue;
 			this.removeRecord(id, record);
 		}
 	}

package/src/index.ts

@@ -543,6 +543,51 @@ export default function (pi: ExtensionAPI) {
 		if (p?.path) todoStorePath = p.path;
 	});
 
+	// ── bridge:agent_suspending ──────────────────────────────────────────────
+	// Fired by edb-bridge when a sub-agent calls ask_supervisor.
+	// Mark the agent so that when runAgent() returns we suspend instead of completing.
+	pi.events.on("bridge:agent_suspending", (payload: unknown) => {
+		const p = payload as { agentId?: string } | undefined;
+		if (!p?.agentId) return;
+		const record = manager.getRecord(p.agentId);
+		if (record) {
+			record.pendingSupervisorAsk = true;
+			widget.update();
+		}
+	});
+
+	// Fired by edb-bridge when ask_supervisor fails to reach the supervisor.
+	// Undo the suspending flag so the agent completes normally.
+	pi.events.on("bridge:agent_suspend_cancelled", (payload: unknown) => {
+		const p = payload as { agentId?: string } | undefined;
+		if (!p?.agentId) return;
+		const record = manager.getRecord(p.agentId);
+		if (record) {
+			record.pendingSupervisorAsk = false;
+		}
+	});
+
+	// ── bridge:resume_agent ─────────────────────────────────────────────────
+	// Fired by edb-bridge when answer_subagent is called.
+	// Resume the suspended agent with the supervisor's answer.
+	pi.events.on("bridge:resume_agent", (payload: unknown) => {
+		const p = payload as { agentId?: string; answer?: string } | undefined;
+		if (!p?.agentId || !p.answer) return;
+		const record = manager.getRecord(p.agentId);
+		if (!record?.session) return;
+
+		const resumed = manager.resumeInBackground(p.agentId, `Supervisor replied: ${p.answer}`);
+		if (resumed) {
+			// Ensure activity tracking exists for the resumed agent
+			if (!agentActivity.has(p.agentId)) {
+				const { state } = createActivityTracker(undefined, () => widget.update());
+				agentActivity.set(p.agentId, state);
+			}
+			widget.ensureTimer();
+			widget.update();
+		}
+	});
+
 	/**
 	 * Read a task from the shared task store (synchronous, best-effort).
 	 * Returns undefined if the store is not available or the task doesn't exist.

package/src/types.ts

@@ -73,7 +73,7 @@ export interface AgentRecord {
 	agentName?: string;
 	/** Linked task ID in the shared task store. Used for blocked-state check in get_subagent_result. */
 	taskId?: string;
-	status: "queued" | "running" | "completed" | "steered" | "aborted" | "stopped" | "error";
+	status: "queued" | "running" | "completed" | "steered" | "aborted" | "stopped" | "error" | "suspended";
 	result?: string;
 	error?: string;
 	toolUses: number;
@@ -88,6 +88,11 @@ export interface AgentRecord {
 	resultConsumed?: boolean;
 	/** Steering messages queued before the session was ready. */
 	pendingSteers?: string[];
+	/**
+	 * True when the agent sent ask_supervisor and is waiting for the supervisor's answer.
+	 * The session is still alive — the agent will be resumed via manager.resumeInBackground.
+	 */
+	pendingSupervisorAsk?: boolean;
 	/** Worktree info if the agent is running in an isolated worktree. */
 	worktree?: { path: string; branch: string };
 	/** Worktree cleanup result after agent completion. */

package/src/ui/agent-widget.ts

@@ -324,12 +324,17 @@ export class AgentWidget {
 		const allAgents = this.manager.listAgents();
 		const running = allAgents.filter((a) => a.status === "running");
 		const queued = allAgents.filter((a) => a.status === "queued");
+		const suspended = allAgents.filter((a) => a.status === "suspended");
 		const finished = allAgents.filter(
 			(a) =>
-				a.status !== "running" && a.status !== "queued" && a.completedAt && this.shouldShowFinished(a.id, a.status),
+				a.status !== "running" &&
+				a.status !== "queued" &&
+				a.status !== "suspended" &&
+				a.completedAt &&
+				this.shouldShowFinished(a.id, a.status),
 		);
 
-		const hasActive = running.length > 0 || queued.length > 0;
+		const hasActive = running.length > 0 || queued.length > 0 || suspended.length > 0;
 		const hasFinished = finished.length > 0;
 
 		// Nothing to show — return empty (widget will be unregistered by update())
@@ -342,7 +347,7 @@ export class AgentWidget {
 		const frame = SPINNER[this.widgetFrame % SPINNER.length];
 
 		// Build sections separately for overflow-aware assembly.
-		// Each running agent = 2 lines (header + activity), finished = 1 line, queued = 1 line.
+		// Each running agent = 2 lines (header + activity), suspended/finished/queued = 1 line.
 
 		const finishedLines: string[] = [];
 		for (const a of finished) {
@@ -380,6 +385,19 @@ export class AgentWidget {
 			]);
 		}
 
+		const suspendedLines: string[] = [];
+		for (const a of suspended) {
+			const name = getDisplayName(a.type);
+			const elapsed = formatMs(Date.now() - a.startedAt);
+			suspendedLines.push(
+				truncate(
+					`${theme.fg("dim", "├─")} ${theme.fg("warning", "⏸")} ${theme.fg("dim", name)}` +
+						`${a.agentName ? `  ${theme.fg("dim", a.agentName)}` : ""}  ${theme.fg("dim", a.description)}` +
+						` ${theme.fg("dim", "·")} ${theme.fg("dim", `waiting for supervisor · ${elapsed}`)}`,
+				),
+			);
+		}
+
 		const queuedLine =
 			queued.length > 0
 				? truncate(
@@ -389,7 +407,7 @@ export class AgentWidget {
 
 		// Assemble with overflow cap (heading + overflow indicator = 2 reserved lines).
 		const maxBody = MAX_WIDGET_LINES - 1; // heading takes 1 line
-		const totalBody = finishedLines.length + runningLines.length * 2 + (queuedLine ? 1 : 0);
+		const totalBody = finishedLines.length + runningLines.length * 2 + suspendedLines.length + (queuedLine ? 1 : 0);
 
 		const lines: string[] = [truncate(`${theme.fg(headingColor, headingIcon)} ${theme.fg(headingColor, "Agents")}`)];
 
@@ -397,6 +415,7 @@ export class AgentWidget {
 			// Everything fits — add all lines and fix up connectors for the last item.
 			lines.push(...finishedLines);
 			for (const pair of runningLines) lines.push(...pair);
+			lines.push(...suspendedLines);
 			if (queuedLine) lines.push(queuedLine);
 
 			// Fix last connector: swap ├─ → └─ and │ → space for activity lines.
@@ -436,7 +455,17 @@ export class AgentWidget {
 				budget--;
 			}
 
-			// 3. Finished agents
+			// 3. Suspended agents
+			for (const sl of suspendedLines) {
+				if (budget >= 1) {
+					lines.push(sl);
+					budget--;
+				} else {
+					hiddenFinished++;
+				}
+			}
+
+			// 4. Finished agents
 			for (const fl of finishedLines) {
 				if (budget >= 1) {
 					lines.push(fl);
@@ -470,17 +499,20 @@ export class AgentWidget {
 		// Lightweight existence checks — full categorization happens in renderWidget()
 		let runningCount = 0;
 		let queuedCount = 0;
+		let suspendedCount = 0;
 		let hasFinished = false;
 		for (const a of allAgents) {
 			if (a.status === "running") {
 				runningCount++;
 			} else if (a.status === "queued") {
 				queuedCount++;
+			} else if (a.status === "suspended") {
+				suspendedCount++;
 			} else if (a.completedAt && this.shouldShowFinished(a.id, a.status)) {
 				hasFinished = true;
 			}
 		}
-		const hasActive = runningCount > 0 || queuedCount > 0;
+		const hasActive = runningCount > 0 || queuedCount > 0 || suspendedCount > 0;
 
 		// Nothing to show — clear widget
 		if (!hasActive && !hasFinished) {