@bastani/atomic 0.9.16-alpha.1 → 0.9.16-alpha.3

package/dist/builtin/workflows/src/extension/workflow-tool.ts

@@ -1,188 +0,0 @@
-import { getSupportedThinkingLevels } from "@bastani/pi-ai/compat";
-import { inspectRun } from "../runs/background/status.js";
-import { store } from "../shared/store.js";
-import type { WorkflowExecutionPolicy } from "../shared/types.js";
-import type { PiExecuteContext, WorkflowToolArgs } from "./public-types.js";
-import type { WorkflowToolResult } from "./render-result.js";
-import type { ExtensionRuntime } from "./runtime.js";
-import { formatWorkflowResourceLoadWarning } from "./workflow-command-surfaces.js";
-import { workflowPolicyFromContext } from "./workflow-policy.js";
-import type { WorkflowReloadReport } from "./workflow-reload-report.js";
-import { raceWorkflowRequestAbort } from "./workflow-request-abort.js";
-import { buildWorkflowStatusListing, setWorkflowStatusRenderRuns } from "./workflow-status-summary.js";
-import { isWorkflowStageToolContext, resolveRunId, topLevelExpandedSnapshots } from "./workflow-targets.js";
-import { workflowGetResult } from "./workflow-tool-content.js";
-import {
-	workflowInterruptAction,
-	workflowPauseAction,
-	workflowQuitAction,
-	workflowReloadAction,
-	workflowResumeAction,
-} from "./workflow-tool-control.js";
-import {
-	type WorkflowInspectionSource,
-	workflowStageResult,
-	workflowStagesResult,
-	workflowTranscriptResult,
-} from "./workflow-tool-inspection.js";
-import { type WorkflowSendDeps, workflowSendAction } from "./workflow-tool-send.js";
-
-type DurableInspectionSourceResolution =
-	| { readonly kind: "local" }
-	| { readonly kind: "durable"; readonly source: WorkflowInspectionSource }
-	| { readonly kind: "error"; readonly message: string };
-
-async function resolveDurableInspectionSource(
-	args: WorkflowToolArgs,
-	runtime: ExtensionRuntime,
-): Promise<DurableInspectionSourceResolution> {
-	const target = args.runId?.trim();
-	if (args.all === true || target === undefined || target.length === 0 || target === "--all") return { kind: "local" };
-	const local = resolveRunId(target);
-	if (local.kind !== "not_found") return { kind: "local" };
-	const durable = await runtime.inspectDurableWorkflow(target);
-	if (durable.kind !== "found") return { kind: "error", message: durable.message };
-	return { kind: "durable", source: { store: durable.store, allowLiveHandles: false } };
-}
-
-function durableInspectionError(
-	action: "stages" | "stage" | "transcript",
-	runId: string,
-	message: string,
-): WorkflowToolResult {
-	if (action === "stages") return { action, runId, filter: "all", stages: [], error: message };
-	if (action === "stage") return { action, runId, error: message };
-	return {
-		action,
-		runId,
-		stageId: "",
-		source: "error",
-		entries: [{ role: "notice", text: message }],
-		truncated: false,
-	};
-}
-
-export function makeExecuteWorkflowTool(
-	runtime: ExtensionRuntime | ((ctx: PiExecuteContext) => ExtensionRuntime),
-	reloadWorkflowResources: () => Promise<WorkflowReloadReport | undefined> | undefined,
-	ensureWorkflowResourcesLoaded: () => Promise<void> | void = () => {},
-	sendDeps: WorkflowSendDeps = {},
-): (
-	args: WorkflowToolArgs,
-	ctx: PiExecuteContext,
-	signal?: AbortSignal,
-	onRunAccepted?: (runId: string) => void,
-) => Promise<WorkflowToolResult> {
-	return async function executeWorkflowTool(
-		args: WorkflowToolArgs,
-		ctx: PiExecuteContext,
-		signal?: AbortSignal,
-		onRunAccepted?: (runId: string) => void,
-	): Promise<WorkflowToolResult> {
-		const action = args.action ?? "run";
-		const runId = args.runId ?? "";
-		if (isWorkflowStageToolContext(ctx)) {
-			return {
-				action: "run",
-				runId,
-				status: "failed",
-				error: "workflows cannot invoke workflows from workflow stages",
-				stages: [],
-			};
-		}
-		const policy: WorkflowExecutionPolicy = workflowPolicyFromContext(ctx);
-		const getRuntime = (): ExtensionRuntime => (typeof runtime === "function" ? runtime(ctx) : runtime);
-		const awaitRequest = <T>(operation: Promise<T>): Promise<T> => raceWorkflowRequestAbort(operation, signal);
-		const ensureWorkflowResourcesVisible = async (): Promise<void> => {
-			try {
-				await awaitRequest(Promise.resolve(ensureWorkflowResourcesLoaded()));
-			} catch (error) {
-				if (signal?.aborted === true) throw signal.reason ?? error;
-				ctx.ui?.notify?.(formatWorkflowResourceLoadWarning(error), "warning");
-			}
-		};
-
-		switch (action) {
-			case "get":
-				await ensureWorkflowResourcesVisible();
-				return workflowGetResult(getRuntime(), args);
-			case "models": {
-				const available = ctx.modelRegistry?.getAvailable() ?? [];
-				const current = ctx.model;
-				const models = available.map((m) => ({
-					provider: m.provider,
-					id: m.id,
-					fullId: `${m.provider}/${m.id}`,
-					isCurrent: current !== undefined && m.provider === current.provider && m.id === current.id,
-					availableThinkingLevels: getSupportedThinkingLevels(m),
-				}));
-				return { action: "models", models };
-			}
-			case "list":
-			case "inputs": {
-				await ensureWorkflowResourcesVisible();
-				return awaitRequest(getRuntime().dispatch(args, { policy, signal }));
-			}
-			case "run": {
-				await ensureWorkflowResourcesVisible();
-				// A tool launch is the agent's own action: it is attributed as such and
-				// the tool result already reports the run, so it raises no chat notice.
-				return awaitRequest(getRuntime().dispatch(args, { policy, origin: "agent", signal, onRunAccepted }));
-			}
-			case "status": {
-				const target = args.runId;
-				if (target !== undefined) {
-					const resolved = resolveRunId(target);
-					if (resolved.kind === "malformed") {
-						return { action: "statusDetail", runId: target, error: resolved.message };
-					}
-					if (resolved.kind === "not_found") {
-						const durable = await awaitRequest(getRuntime().inspectDurableWorkflow(target));
-						return durable.kind === "found"
-							? { action: "statusDetail", runId: target, detail: durable.detail }
-							: { action: "statusDetail", runId: target, error: durable.message };
-					}
-					const result = inspectRun(resolved.runId);
-					return result.ok
-						? { action: "statusDetail", runId: result.runId, detail: result.detail }
-						: { action: "statusDetail", runId: target, error: `run not found: ${target}` };
-				}
-				const listing = buildWorkflowStatusListing(topLevelExpandedSnapshots(), args.statusFilter ?? "all");
-				const result = {
-					action: "status" as const,
-					filter: listing.filter,
-					runs: listing.runs,
-					snapshots: listing.snapshots,
-				};
-				setWorkflowStatusRenderRuns(result, store.graphSnapshot().runs);
-				return result;
-			}
-			case "stages":
-			case "stage":
-			case "transcript": {
-				const resolved = await awaitRequest(resolveDurableInspectionSource(args, getRuntime()));
-				if (resolved.kind === "error") return durableInspectionError(action, args.runId ?? "", resolved.message);
-				const source = resolved.kind === "durable" ? resolved.source : undefined;
-				if (action === "stages") return workflowStagesResult(args, source);
-				if (action === "stage") return workflowStageResult(args, source);
-				return workflowTranscriptResult(args, source);
-			}
-			case "send":
-				return awaitRequest(workflowSendAction(args, sendDeps));
-			case "pause":
-				return awaitRequest(workflowPauseAction(args));
-			case "reload":
-				return awaitRequest(workflowReloadAction(args, { reloadWorkflowResources }));
-			case "quit":
-				return awaitRequest(workflowQuitAction(args));
-			case "interrupt":
-				return awaitRequest(workflowInterruptAction(args));
-			case "resume":
-				return awaitRequest(workflowResumeAction(args, { getRuntime, policy, ensureWorkflowResourcesLoaded }));
-			default: {
-				const _exhaustive: never = action;
-				throw new Error(`Workflow extension: unknown action "${_exhaustive}"`);
-			}
-		}
-	};
-}

package/dist/builtin/workflows/src/index.ts

@@ -1,8 +0,0 @@
-/**
- * workflows
- * Public entry point — re-exports the authoring API and public types.
- */
-
-// Add new non-cyclic public runtime exports to sdk-surface.ts so the Bun
-// virtual SDK used by workflow discovery stays in lockstep with this entry.
-export * from "./sdk-surface.js";

package/dist/builtin/workflows/src/intercom/intercom-bridge.ts

@@ -1,90 +0,0 @@
-/**
- * pi-intercom cooperation: parent session naming + presence detection.
- *
- * Responsibilities:
- *  1. Detect whether pi-intercom-like surfaces exist on the ExtensionAPI
- *     (structural check — no hard import).
- *  2. On session_start, register the parent session name as
- *     `pi-workflows-parent-<short-cwd-hash>` so detached child processes
- *     can `contact_supervisor` through the intercom channel.
- *
- * cross-ref: pi-subagents src/intercom/intercom-bridge.ts
- * cross-ref: spec §5.10 Integration with pi-intercom, §8.1 Phase G
- */
-
-import { createHash } from "node:crypto";
-
-// ---------------------------------------------------------------------------
-// Minimal structural types — no hard imports from pi-intercom
-// ---------------------------------------------------------------------------
-
-/** Minimal ExtensionAPI surface expected by intercom integration. */
-export interface PiIntercomExtensionAPI {
-	/** Sets the session name that children can use as `contact_supervisor` target. */
-	setSessionName?: (name: string) => void;
-	/** Event subscription surface used by multiple integrations. */
-	events?: {
-		emit?: (event: string, payload: Record<string, unknown>) => void;
-		on?: (event: string, handler: (payload: unknown) => void) => void;
-	};
-	[key: string]: unknown;
-}
-
-// ---------------------------------------------------------------------------
-// Session name derivation
-// ---------------------------------------------------------------------------
-
-/**
- * Derives a short (8-char) hex hash from the given string (typically cwd).
- * Stable across restarts for the same directory, short enough for display.
- */
-export function deriveCwdHash(cwd: string): string {
-	return createHash("sha256").update(cwd).digest("hex").slice(0, 8);
-}
-
-/**
- * Returns the canonical parent session name for this workflow run.
- * Format: `pi-workflows-parent-<8-char-hash>`
- *
- * Spec default: derive from cwd (§9 open question 7 → resolved as cwd hash).
- */
-export function buildParentSessionName(cwd: string = process.cwd()): string {
-	return `pi-workflows-parent-${deriveCwdHash(cwd)}`;
-}
-
-// ---------------------------------------------------------------------------
-// Presence detection
-// ---------------------------------------------------------------------------
-
-/**
- * Returns `true` when the pi runtime exposes an intercom-like `setSessionName`
- * method. Purely structural — does not import pi-intercom.
- */
-export function isIntercomPresent(pi: PiIntercomExtensionAPI): boolean {
-	return typeof pi.setSessionName === "function";
-}
-
-// ---------------------------------------------------------------------------
-// Registration
-// ---------------------------------------------------------------------------
-
-/**
- * Registers the workflow parent session name via `pi.setSessionName` so
- * detached child processes can `contact_supervisor` back to this session.
- *
- * - No-op when `pi.setSessionName` is absent (pi-intercom not installed).
- * - Called once during extension initialization (session_start equivalent).
- *
- * @param pi   The ExtensionAPI instance.
- * @param cwd  Working directory used to derive a stable hash. Defaults to
- *             `process.cwd()`.
- * @returns    The session name that was set, or `null` if intercom absent.
- */
-export function registerIntercomParentSession(pi: PiIntercomExtensionAPI, cwd: string = process.cwd()): string | null {
-	if (!isIntercomPresent(pi)) return null;
-
-	const name = buildParentSessionName(cwd);
-	// Safe: isIntercomPresent guard above ensures setSessionName exists.
-	pi.setSessionName!(name);
-	return name;
-}

package/dist/builtin/workflows/src/intercom/intercom-routing.ts

@@ -1,131 +0,0 @@
-/**
- * Intercom routing: builds IntercomControlCallbacks that wire store/ui/emit.
- *
- * `buildIntercomCallbacks` is the pure factory consumed by extension/index.ts.
- * Keeping it separate makes unit testing trivial (no full pi surface needed).
- *
- * cross-ref: spec §5.10, RFC §8.1 Phase G
- */
-
-import { isStaleExtensionContextError } from "@bastani/atomic";
-import type { Store } from "../shared/store.js";
-import type { NoticeLevel } from "../shared/store-types.js";
-import type { IntercomControlCallbacks, IntercomControlPayload } from "./result-intercom.js";
-
-// ---------------------------------------------------------------------------
-// Dependency surface
-// ---------------------------------------------------------------------------
-
-/**
- * Minimal deps injected by the extension factory.
- * Separating them makes the logic independently testable.
- */
-export interface IntercomRoutingDeps {
-	/** Workflow store — for recordNotice / ackNotice. */
-	store: Store;
-	/**
-	 * Raw pi events emit — used to fire `subagent:control-intercom:response`.
-	 * `undefined` when pi.events.emit is not available.
-	 */
-	emit: ((event: string, payload: Record<string, unknown>) => void) | undefined;
-	/**
-	 * Pi confirm dialog with separate title + message args.
-	 * `undefined` when pi.ui.confirm is absent.
-	 */
-	confirm: ((title: string, message: string) => Promise<boolean>) | undefined;
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function toNoticeLevel(raw: unknown): NoticeLevel {
-	if (raw === "warning" || raw === "error") return raw;
-	return "info";
-}
-
-function makeId(): string {
-	// crypto.randomUUID() is available globally in Bun and Node ≥ 16.
-	return crypto.randomUUID();
-}
-
-// ---------------------------------------------------------------------------
-// Callback builder
-// ---------------------------------------------------------------------------
-
-/**
- * Builds `IntercomControlCallbacks` wired to the given deps.
- *
- * - `need_decision`:
- *     1. Record a notice with `requiresAck: true` (level: "warning").
- *     2. Surface `pi.ui.confirm("Subagent needs decision", payload.message)`.
- *     3. Emit `subagent:control-intercom:response` with
- *        `{ requestId, runId, stageId, accepted }`.
- *     4. Ack the notice.
- *
- * - `notify`:
- *     Record a notice at `payload.level` (info/warning/error, defaults to info).
- *
- * - unknown / malformed:
- *     Record a warning notice. No ack, no emit.
- */
-export function buildIntercomCallbacks(deps: IntercomRoutingDeps): IntercomControlCallbacks {
-	const { store, emit, confirm } = deps;
-
-	return {
-		async onNeedDecision(payload: IntercomControlPayload): Promise<void> {
-			const noticeId = makeId();
-
-			store.recordNotice({
-				id: noticeId,
-				runId: payload.runId,
-				stageId: payload.stageId,
-				level: "warning",
-				message: payload.message,
-				createdAt: Date.now(),
-				requiresAck: true,
-			});
-
-			const accepted: boolean =
-				typeof confirm === "function"
-					? await confirm("Subagent needs decision", payload.message).catch(() => false)
-					: false;
-
-			try {
-				emit?.("subagent:control-intercom:response", {
-					requestId: payload.requestId ?? "",
-					runId: payload.runId ?? "",
-					stageId: payload.stageId ?? "",
-					accepted,
-				});
-			} catch (error) {
-				if (!isStaleExtensionContextError(error)) throw error;
-				// The decision can finish after the workflow extension reloads.
-			}
-
-			store.ackNotice(noticeId);
-		},
-
-		onNotify(payload: IntercomControlPayload): void {
-			store.recordNotice({
-				id: makeId(),
-				runId: payload.runId,
-				stageId: payload.stageId,
-				level: toNoticeLevel(payload.level),
-				message: payload.message,
-				createdAt: Date.now(),
-			});
-		},
-
-		onUnknown(payload: IntercomControlPayload): void {
-			store.recordNotice({
-				id: makeId(),
-				runId: payload.runId,
-				stageId: payload.stageId,
-				level: "warning",
-				message: `Unknown intercom type "${payload.type}": ${payload.message}`,
-				createdAt: Date.now(),
-			});
-		},
-	};
-}

package/dist/builtin/workflows/src/intercom/result-intercom.ts

@@ -1,271 +0,0 @@
-/**
- * pi-intercom result routing: subagent:control-intercom → UI/store callbacks.
- *
- * Responsibilities:
- *  Subscribes to `pi.events.on("subagent:control-intercom", ...)` (the channel
- *  pi-subagents uses when a child calls `contact_supervisor`).  When a child
- *  sub-agent of a workflow stage escalates, this module routes the event to
- *  the appropriate callback:
- *    - `onNeedDecision` → surfaces a blocking confirm dialog (ctx.ui.confirm)
- *    - `onNotify`       → surfaces a non-blocking notice in the workflow overlay
- *
- * No-op when the events bus or subscription method is absent.
- *
- * cross-ref: pi-subagents src/intercom/result-intercom.ts
- * cross-ref: spec §5.10 Integration with pi-intercom, §8.1 Phase G
- */
-
-import { isStaleExtensionContextError } from "@bastani/atomic";
-import type { WorkflowDetails } from "../shared/types.js";
-
-// ---------------------------------------------------------------------------
-// Minimal structural types
-// ---------------------------------------------------------------------------
-
-/** Minimal pi events bus surface used by this module. */
-export interface PiEventBus {
-	on?: (event: string, handler: (payload: unknown) => void) => unknown;
-	emit?: (event: string, payload: Record<string, unknown>) => void;
-}
-
-/** Minimal ExtensionAPI surface expected by result-intercom module. */
-export interface PiResultIntercomExtensionAPI {
-	events?: PiEventBus;
-	[key: string]: unknown;
-}
-
-// ---------------------------------------------------------------------------
-// Intercom control event payload
-// ---------------------------------------------------------------------------
-
-/**
- * Shape of the `subagent:control-intercom` event payload emitted by
- * pi-subagents when a child calls `contact_supervisor`.
- *
- * Both `type` and `message` are required. Additional fields are forwarded
- * opaquely to callbacks.
- */
-export interface IntercomControlPayload {
-	/** Escalation kind: a blocking decision request or an informational notice. */
-	type: "need_decision" | "notify" | string;
-	/** Human-readable message from the child agent. */
-	message: string;
-	/** Originating run/stage context if the child is inside a workflow. */
-	runId?: string;
-	stageId?: string;
-	/** The child agent's identifier (pi-subagents populates this). */
-	agentId?: string;
-	/** Arbitrary extra fields forwarded from pi-subagents. */
-	[key: string]: unknown;
-}
-
-// ---------------------------------------------------------------------------
-// Callback types
-// ---------------------------------------------------------------------------
-
-/**
- * Called when the child requests a blocking decision from the user.
- * Implementors should display `ctx.ui.confirm`-style UI.
- */
-export type OnNeedDecision = (payload: IntercomControlPayload) => void | Promise<void>;
-
-/**
- * Called for non-blocking notifications (e.g. status updates from the child).
- * Implementors should surface these in the workflow overlay.
- */
-export type OnNotify = (payload: IntercomControlPayload) => void | Promise<void>;
-
-/** Callback bag passed to `subscribeIntercomControl`. */
-export interface IntercomControlCallbacks {
-	onNeedDecision?: OnNeedDecision;
-	onNotify?: OnNotify;
-	/**
-	 * Fallback called for unknown `type` values — useful for forward
-	 * compatibility as pi-subagents adds new escalation kinds.
-	 */
-	onUnknown?: (payload: IntercomControlPayload) => void | Promise<void>;
-}
-
-export type WorkflowIntercomDelivery = "off" | "notify" | "result" | "control-and-result";
-
-export interface WorkflowResultIntercomPort {
-	emit?: (event: string, payload: Record<string, unknown>) => void;
-	parentSession?: string | (() => string | undefined);
-}
-
-export interface WorkflowIntercomEventOptions {
-	readonly delivery: Exclude<WorkflowIntercomDelivery, "off">;
-	readonly parentSession?: string;
-}
-
-export interface WorkflowControlIntercomPayload {
-	readonly type: "notify" | "needs_attention";
-	readonly runId: string;
-	readonly mode: WorkflowDetails["mode"];
-	readonly status: WorkflowDetails["status"];
-	readonly message: string;
-	/** Terminal ctx.exit() discriminator and payload for parent sessions. */
-	readonly exited?: boolean;
-	readonly exitReason?: string;
-	readonly outputs?: WorkflowDetails["output"];
-	readonly parentSession?: string;
-	readonly createdAt: number;
-}
-
-export interface WorkflowResultIntercomPayload {
-	readonly runId: string;
-	readonly mode: WorkflowDetails["mode"];
-	readonly status: WorkflowDetails["status"];
-	readonly details: WorkflowDetails;
-	readonly parentSession?: string;
-	readonly createdAt: number;
-}
-
-function parentSessionFromPort(port: WorkflowResultIntercomPort, override?: string): string | undefined {
-	if (override !== undefined) return override;
-	if (typeof port.parentSession === "function") return port.parentSession();
-	return port.parentSession;
-}
-
-function shouldEmitControl(delivery: WorkflowIntercomDelivery): boolean {
-	return delivery === "notify" || delivery === "control-and-result";
-}
-
-function shouldEmitResult(delivery: WorkflowIntercomDelivery): boolean {
-	return delivery === "result" || delivery === "control-and-result";
-}
-
-export function workflowIntercomAvailable(port: WorkflowResultIntercomPort | undefined): boolean {
-	return typeof port?.emit === "function";
-}
-
-export function emitWorkflowControlIntercom(
-	port: WorkflowResultIntercomPort | undefined,
-	details: WorkflowDetails,
-	message: string,
-	options: WorkflowIntercomEventOptions,
-): boolean {
-	if (!workflowIntercomAvailable(port) || !shouldEmitControl(options.delivery) || details.runId === undefined) {
-		return false;
-	}
-	const parentSession = parentSessionFromPort(port!, options.parentSession);
-	const payload: WorkflowControlIntercomPayload = {
-		type: "notify",
-		runId: details.runId,
-		mode: details.mode,
-		status: details.status,
-		message,
-		...(details.exited !== undefined ? { exited: details.exited } : {}),
-		...(details.exitReason !== undefined ? { exitReason: details.exitReason } : {}),
-		...(details.output !== undefined ? { outputs: details.output } : {}),
-		...(parentSession !== undefined ? { parentSession } : {}),
-		createdAt: Date.now(),
-	};
-	try {
-		port!.emit!("workflow:control-intercom", payload as unknown as Record<string, unknown>);
-	} catch (error) {
-		if (!isStaleExtensionContextError(error)) throw error;
-		// A workflow can outlive the extension runtime that supplied the port.
-		return false;
-	}
-	return true;
-}
-
-export function emitWorkflowResultIntercom(
-	port: WorkflowResultIntercomPort | undefined,
-	details: WorkflowDetails,
-	options: WorkflowIntercomEventOptions,
-): boolean {
-	if (!workflowIntercomAvailable(port) || !shouldEmitResult(options.delivery) || details.runId === undefined) {
-		return false;
-	}
-	const parentSession = parentSessionFromPort(port!, options.parentSession);
-	const payload: WorkflowResultIntercomPayload = {
-		runId: details.runId,
-		mode: details.mode,
-		status: details.status,
-		details,
-		...(parentSession !== undefined ? { parentSession } : {}),
-		createdAt: Date.now(),
-	};
-	try {
-		port!.emit!("workflow:result-intercom", payload as unknown as Record<string, unknown>);
-	} catch (error) {
-		if (!isStaleExtensionContextError(error)) throw error;
-		// A workflow can outlive the extension runtime that supplied the port.
-		return false;
-	}
-	return true;
-}
-
-// ---------------------------------------------------------------------------
-// Subscription
-// ---------------------------------------------------------------------------
-
-/**
- * Subscribes to `subagent:control-intercom` events on `pi.events` and routes
- * each incoming payload to the appropriate callback.
- *
- * - No-op when `pi.events?.on` is absent (events bus not supported).
- * - Each individual callback error is caught and re-thrown asynchronously so
- *   one bad callback cannot prevent others from running.
- *
- * @returns A cleanup / unsubscribe function. Call it to stop routing.
- *          Returns `null` when the subscription could not be established.
- */
-export function subscribeIntercomControl(
-	pi: PiResultIntercomExtensionAPI,
-	callbacks: IntercomControlCallbacks,
-): (() => void) | null {
-	if (typeof pi.events?.on !== "function") return null;
-
-	let active = true;
-
-	const handler = (rawPayload: unknown): void => {
-		if (!active) return;
-
-		// Coerce to typed payload — we trust pi-subagents' contract but guard
-		// defensively against malformed emissions.
-		const payload = rawPayload as IntercomControlPayload;
-
-		if (!payload || typeof payload !== "object" || typeof payload.type !== "string") return;
-
-		const dispatch = (): Promise<void> => {
-			switch (payload.type) {
-				case "need_decision":
-					return Promise.resolve(callbacks.onNeedDecision?.(payload));
-				case "notify":
-					return Promise.resolve(callbacks.onNotify?.(payload));
-				default:
-					return Promise.resolve(callbacks.onUnknown?.(payload));
-			}
-		};
-
-		dispatch().catch((err) => {
-			// Surface errors without breaking the event loop.
-			Promise.reject(
-				new Error(
-					`atomic-workflows: intercom callback error (type=${payload.type}): ${err instanceof Error ? err.message : String(err)}`,
-				),
-			);
-		});
-	};
-
-	let unsubscribe: unknown;
-	try {
-		unsubscribe = pi.events!.on!("subagent:control-intercom", handler);
-	} catch (error) {
-		if (!isStaleExtensionContextError(error)) throw error;
-		return null;
-	}
-
-	return () => {
-		active = false;
-		try {
-			if (typeof unsubscribe === "function") unsubscribe();
-		} catch (error) {
-			if (!isStaleExtensionContextError(error)) throw error;
-			// Stale event-bus cleanup is best effort.
-		}
-	};
-}