pi-subagents 0.40.0 → 0.41.0

package/src/integrations/herdr-status.ts

@@ -0,0 +1,330 @@
+import {
+	SUBAGENT_ASYNC_COMPLETE_EVENT,
+	SUBAGENT_ASYNC_STARTED_EVENT,
+	SUBAGENT_CONTROL_EVENT,
+} from "../shared/types.ts";
+
+const DEFAULT_SOURCE = "pi-subagents:herdr";
+const DEFAULT_TTL_MS = 120_000;
+const DEFAULT_REFRESH_MS = 45_000;
+
+let metadataReportSeq = Date.now() * 1000;
+
+function nextMetadataReportSeq(): number {
+	metadataReportSeq = Math.max(metadataReportSeq + 1, Date.now() * 1000);
+	return metadataReportSeq;
+}
+
+export interface HerdrStatusBridgeEvents {
+	on(event: string, handler: (data: unknown) => void): (() => void) | void;
+	emit(event: string, data: unknown): void;
+}
+
+export interface HerdrStatusRun {
+	id: string;
+	agent?: string;
+	agents?: string[];
+	needsAttention?: boolean;
+	attentionLabel?: string;
+}
+
+export interface HerdrStatusBridgeOptions {
+	events: HerdrStatusBridgeEvents;
+	env?: Record<string, string | undefined>;
+	/** Current authoritative active-run projection, used before TTL refresh. */
+	getRuns?: () => Iterable<HerdrStatusRun>;
+	runHerdr: (args: readonly string[]) => void | Promise<void>;
+	ttlMs?: number;
+	refreshMs?: number;
+	timers?: {
+		setInterval: typeof setInterval;
+		clearInterval: typeof clearInterval;
+	};
+}
+
+export interface HerdrStatusBridge {
+	/**
+	 * Binds the pane owner. Only the root interactive session may publish pane
+	 * metadata: headless parents (print/json), non-UI harnesses, and child
+	 * runtimes must never fight the pane's lifecycle authority over display
+	 * state. Also re-syncs runs that survived a reload/resume.
+	 */
+	sessionStarted(input: { hasUI: boolean; runs: Iterable<HerdrStatusRun> }): void;
+	agentStarted(): void;
+	flush(): Promise<void>;
+	dispose(): void;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function startedRun(data: unknown): HerdrStatusRun | undefined {
+	if (!isRecord(data) || typeof data.id !== "string" || !data.id) return undefined;
+	return {
+		id: data.id,
+		...(typeof data.agent === "string" ? { agent: data.agent } : {}),
+		...(Array.isArray(data.agents) && data.agents.every((agent) => typeof agent === "string") ? { agents: data.agents as string[] } : {}),
+	};
+}
+
+function completedRunId(data: unknown): string | undefined {
+	if (!isRecord(data)) return undefined;
+	const id = typeof data.runId === "string" ? data.runId : data.id;
+	return typeof id === "string" && id.length > 0 ? id : undefined;
+}
+
+function attentionNotice(data: unknown): { runId: string; label: string } | undefined {
+	if (!isRecord(data) || data.source !== "async" || !isRecord(data.event)) return undefined;
+	if (data.event.type !== "needs_attention" || typeof data.event.runId !== "string" || !data.event.runId) return undefined;
+	const label = typeof data.noticeText === "string" && data.noticeText
+		? data.noticeText
+		: typeof data.event.message === "string" && data.event.message
+			? data.event.message
+			: "subagent needs attention";
+	return { runId: data.event.runId, label };
+}
+
+export function registerHerdrStatusBridge(options: HerdrStatusBridgeOptions): HerdrStatusBridge {
+	const env = options.env ?? process.env;
+	const paneId = env.HERDR_PANE_ID;
+	const enabled = env.HERDR_ENV === "1" && typeof paneId === "string" && paneId.length > 0;
+	const runHerdr = options.runHerdr;
+	const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+	const refreshMs = options.refreshMs ?? DEFAULT_REFRESH_MS;
+	const timers = options.timers ?? { setInterval, clearInterval };
+	const runs = new Map<string, HerdrStatusRun>();
+	const attentionLabels = new Map<string, string>();
+	const acknowledgedAttention = new Set<string>();
+	const subscriptions: Array<() => void> = [];
+	let rootSession = false;
+	let published = false;
+	let busyRaised = false;
+	let busyLabel: string | undefined;
+	let blockedRaised = false;
+	let blockedLabel: string | undefined;
+	let disposed = false;
+	let pendingReport: readonly string[] | undefined;
+	let draining = false;
+	let drainPromise = Promise.resolve();
+	let refreshTimer: ReturnType<typeof setInterval> | undefined;
+
+	const label = (): string => {
+		const agents = [...new Set([...runs.values()].flatMap((run) => run.agents?.length ? run.agents : run.agent ? [run.agent] : []))];
+		const who = agents.length > 0
+			? ` (${agents.slice(0, 3).join(", ")}${agents.length > 3 ? ", …" : ""})`
+			: "";
+		return `⏳ ${runs.size} subagent${runs.size === 1 ? "" : "s"}${who}`;
+	};
+
+	const enqueue = (args: readonly string[]): void => {
+		pendingReport = args;
+		if (draining) return;
+		draining = true;
+		drainPromise = (async () => {
+			while (pendingReport) {
+				const next = pendingReport;
+				pendingReport = undefined;
+				try {
+					await runHerdr(next);
+				} catch {
+					// Herdr integration is best effort; a later state transition or TTL
+					// refresh retries with the newest desired snapshot.
+				}
+			}
+		})().finally(() => {
+			draining = false;
+		});
+	};
+
+	const publish = (): void => {
+		if (!enabled || !rootSession || disposed || !paneId) return;
+		if (runs.size === 0 && !published) return;
+		const seq = String(nextMetadataReportSeq());
+		if (runs.size === 0) {
+			published = false;
+			enqueue([
+				"pane", "report-metadata", paneId,
+				"--source", DEFAULT_SOURCE,
+				"--agent", "pi",
+				"--applies-to-source", "herdr:pi",
+				"--clear-state-labels",
+				"--clear-token", "summary",
+				"--seq", seq,
+			]);
+			return;
+		}
+		const text = label();
+		published = true;
+		enqueue([
+			"pane", "report-metadata", paneId,
+			"--source", DEFAULT_SOURCE,
+			"--agent", "pi",
+			"--applies-to-source", "herdr:pi",
+			"--state-label", `idle=${text}`,
+			"--state-label", `done=${text}`,
+			"--state-label", `working=${text}`,
+			"--token", `summary=${text}`,
+			"--ttl-ms", String(ttlMs),
+			"--seq", seq,
+		]);
+	};
+
+	const syncRefreshTimer = (): void => {
+		if (runs.size > 0 && refreshMs > 0 && !refreshTimer) {
+			refreshTimer = timers.setInterval(() => refresh(), refreshMs);
+			refreshTimer.unref?.();
+		} else if ((runs.size === 0 || refreshMs <= 0) && refreshTimer) {
+			timers.clearInterval(refreshTimer);
+			refreshTimer = undefined;
+		}
+	};
+
+	const syncBusy = (): void => {
+		if (!enabled || !rootSession || disposed) return;
+		if (runs.size > 0) {
+			const text = label();
+			if (busyRaised && busyLabel === text) return;
+			if (busyRaised) options.events.emit("herdr:busy", { active: false });
+			busyRaised = true;
+			busyLabel = text;
+			options.events.emit("herdr:busy", { active: true, label: text });
+			return;
+		}
+		if (busyRaised) {
+			busyRaised = false;
+			busyLabel = undefined;
+			options.events.emit("herdr:busy", { active: false });
+		}
+	};
+
+	const syncBlocked = (): void => {
+		if (!enabled || !rootSession || disposed) return;
+		const nextLabel = [...attentionLabels.values()].at(-1);
+		if (nextLabel !== undefined) {
+			if (blockedRaised && blockedLabel === nextLabel) return;
+			// Herdr's sibling overlay contract is counted. Lower before changing
+			// the active label so this bridge continues to own exactly one count.
+			if (blockedRaised) options.events.emit("herdr:blocked", { active: false });
+			blockedRaised = true;
+			blockedLabel = nextLabel;
+			options.events.emit("herdr:blocked", { active: true, label: nextLabel });
+			return;
+		}
+		if (blockedRaised) {
+			blockedRaised = false;
+			blockedLabel = undefined;
+			options.events.emit("herdr:blocked", { active: false });
+		}
+	};
+
+	const clearAttention = (): void => {
+		attentionLabels.clear();
+		syncBlocked();
+	};
+
+	const raiseAttention = (runId: string, labelText: string): void => {
+		if (!rootSession || attentionLabels.has(runId)) return;
+		acknowledgedAttention.delete(runId);
+		attentionLabels.set(runId, labelText);
+		syncBlocked();
+	};
+
+	const replaceRuns = (nextRuns: Iterable<HerdrStatusRun>): void => {
+		const nextAttention = new Map<string, string>();
+		const activeIds = new Set<string>();
+		runs.clear();
+		for (const run of nextRuns) {
+			if (!run || typeof run.id !== "string" || !run.id) continue;
+			activeIds.add(run.id);
+			runs.set(run.id, { ...run });
+			if (!run.needsAttention) {
+				acknowledgedAttention.delete(run.id);
+			} else if (!acknowledgedAttention.has(run.id)) {
+				nextAttention.set(run.id, run.attentionLabel || attentionLabels.get(run.id) || "subagent needs attention");
+			}
+		}
+		for (const id of acknowledgedAttention) {
+			if (!activeIds.has(id)) acknowledgedAttention.delete(id);
+		}
+		attentionLabels.clear();
+		for (const [id, labelText] of nextAttention) attentionLabels.set(id, labelText);
+		syncBusy();
+		syncRefreshTimer();
+		syncBlocked();
+		publish();
+	};
+
+	const refresh = (): void => {
+		if (!options.getRuns) {
+			publish();
+			return;
+		}
+		try {
+			replaceRuns(options.getRuns());
+		} catch {
+			// Keep the last known active projection and retry on the next refresh.
+			publish();
+		}
+	};
+
+	const subscribe = (event: string, handler: (data: unknown) => void): void => {
+		const unsubscribe = options.events.on(event, handler);
+		if (typeof unsubscribe === "function") subscriptions.push(unsubscribe);
+	};
+
+	if (enabled) {
+		subscribe(SUBAGENT_ASYNC_STARTED_EVENT, (data) => {
+			if (!rootSession) return;
+			const run = startedRun(data);
+			if (!run) return;
+			acknowledgedAttention.delete(run.id);
+			runs.set(run.id, run);
+			syncBusy();
+			syncRefreshTimer();
+			publish();
+		});
+		subscribe(SUBAGENT_ASYNC_COMPLETE_EVENT, (data) => {
+			if (!rootSession) return;
+			const id = completedRunId(data);
+			if (!id || !runs.delete(id)) return;
+			acknowledgedAttention.delete(id);
+			if (attentionLabels.delete(id)) syncBlocked();
+			syncBusy();
+			syncRefreshTimer();
+			publish();
+		});
+		subscribe(SUBAGENT_CONTROL_EVENT, (data) => {
+			if (!rootSession) return;
+			const notice = attentionNotice(data);
+			if (!notice || !runs.has(notice.runId)) return;
+			raiseAttention(notice.runId, notice.label);
+		});
+	}
+
+	return {
+		agentStarted() {
+			for (const id of attentionLabels.keys()) acknowledgedAttention.add(id);
+			clearAttention();
+		},
+		sessionStarted({ hasUI, runs: restoredRuns }) {
+			if (!enabled || disposed || hasUI !== true) return;
+			rootSession = true;
+			replaceRuns(restoredRuns);
+		},
+		async flush() {
+			while (draining || pendingReport) await drainPromise;
+		},
+		dispose() {
+			if (disposed) return;
+			clearAttention();
+			acknowledgedAttention.clear();
+			runs.clear();
+			syncBusy();
+			syncRefreshTimer();
+			publish();
+			for (const unsubscribe of subscriptions) unsubscribe();
+			disposed = true;
+		},
+	};
+}

package/src/intercom/intercom-bridge.ts

@@ -53,6 +53,7 @@ interface ResolveIntercomBridgeInput {
 	config: ExtensionConfig["intercomBridge"];
 	context: "fresh" | "fork" | undefined;
 	orchestratorTarget?: string;
+	cwd?: string;
 	settingsDir?: string;
 	agentDir?: string;
 }
@@ -81,12 +82,12 @@ export function resolveIntercomBridgeMode(value: unknown): IntercomBridgeMode {
 
 function resolveIntercomBridgeConfig(value: ExtensionConfig["intercomBridge"]): Required<IntercomBridgeConfig> {
 	if (!value || typeof value !== "object" || Array.isArray(value)) {
-		return { mode: "always", instructionFile: "", resultDelivery: true };
+		return { mode: "always", instructionFile: "", resultDelivery: false };
 	}
 	return {
 		mode: resolveIntercomBridgeMode(value.mode),
 		instructionFile: typeof value.instructionFile === "string" ? value.instructionFile : "",
-		resultDelivery: value.resultDelivery !== false,
+		resultDelivery: value.resultDelivery === true,
 	};
 }
 

package/src/intercom/result-intercom.ts

@@ -113,6 +113,8 @@ function compactNestedRun(run: NestedRunSummary | PublicNestedRunSummary, depth
 		state: run.state,
 		...(run.agent ? { agent: run.agent } : {}),
 		...(run.agents?.length ? { agents: run.agents.slice(0, 12) } : {}),
+		...(run.model ? { model: run.model } : {}),
+		...(run.thinking ? { thinking: run.thinking } : {}),
 		...(run.currentStep !== undefined ? { currentStep: run.currentStep } : {}),
 		...(run.chainStepCount !== undefined ? { chainStepCount: run.chainStepCount } : {}),
 		...(run.parallelGroups?.length ? { parallelGroups: run.parallelGroups.slice(0, 8) } : {}),
@@ -131,6 +133,8 @@ function compactNestedRun(run: NestedRunSummary | PublicNestedRunSummary, depth
 		...(run.steps?.length ? { steps: run.steps.slice(0, 12).map((step) => ({
 			agent: step.agent,
 			status: step.status,
+			...(step.model ? { model: step.model } : {}),
+			...(step.thinking ? { thinking: step.thinking } : {}),
 			...(step.sessionFile ? { sessionFile: step.sessionFile } : {}),
 			...(step.activityState ? { activityState: step.activityState } : {}),
 			...(step.lastActivityAt !== undefined ? { lastActivityAt: step.lastActivityAt } : {}),
@@ -315,7 +319,7 @@ export async function deliverSubagentResultIntercomEvent(
 	payload: SubagentResultIntercomPayload,
 	timeoutMs = 500,
 ): Promise<boolean> {
-	return deliverSubagentIntercomMessageEvent(events, payload.to, payload.message, timeoutMs, payload);
+	return deliverSubagentIntercomMessageEvent(events, payload.to, payload.message, timeoutMs, payload as unknown as Record<string, unknown>);
 }
 
 export async function deliverSubagentIntercomMessageEvent(