@bastani/atomic 0.9.16-alpha.2 → 0.9.16-alpha.4

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

@@ -1,376 +0,0 @@
-import { execSync } from "node:child_process";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import { APP_NAME, createChildProcessEnvironment, getEnvValue, getProjectConfigDirs } from "@bastani/atomic";
-import type { AgentConfig } from "../agents/agents.js";
-import type { ExtensionConfig, IntercomBridgeConfig, IntercomBridgeMode } from "../shared/types.js";
-import { getAgentDir } from "../shared/utils.js";
-
-const PI_INTERCOM_PACKAGE_NAME = "pi-intercom";
-
-function defaultAgentDir(): string {
-	return getAgentDir();
-}
-const INTERCOM_SESSION_ID_ENV = `${APP_NAME.toUpperCase()}_INTERCOM_SESSION_ID`;
-
-function defaultIntercomExtensionDir(agentDir = defaultAgentDir()): string {
-	return path.join(agentDir, "extensions", PI_INTERCOM_PACKAGE_NAME);
-}
-
-function bundledIntercomExtensionDir(): string {
-	return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "intercom");
-}
-
-function defaultIntercomConfigPath(agentDir = defaultAgentDir()): string {
-	return path.join(agentDir, "intercom", "config.json");
-}
-
-function defaultSubagentConfigDir(agentDir = defaultAgentDir()): string {
-	return path.join(agentDir, "extensions", "subagent");
-}
-
-const DEFAULT_INTERCOM_TARGET_PREFIX = "subagent-chat";
-export const INTERCOM_BRIDGE_MARKER = "Intercom orchestration channel:";
-const DEFAULT_INTERCOM_BRIDGE_TEMPLATE = `The inherited thread is reference-only. Do not continue that conversation or send questions, status updates, or completion handoffs to the supervisor in normal assistant text.
-
-Use contact_supervisor first. It resolves the supervisor session "{orchestratorTarget}" and run metadata automatically.
-- Need a decision, blocked, approval, or product/API/scope ambiguity: contact_supervisor({ reason: "need_decision", message: "<question>" })
-- A claimed decision or interview ends this child. Do not wait for or expect a reply in this run; the supervisor receives a dynamic [TASK_CONTEXT] handoff and may launch a fresh subagent with a new run identity and the answer.
-- Do not ask for clarification when the only conflict is review-only/no-edit versus progress-writing or artifact-writing instructions. Review-only/no-edit wins; leave files unchanged and mention the conflict in your final result only if it matters.
-- Meaningful progress or unexpected discoveries that change the plan: contact_supervisor({ reason: "progress_update", message: "UPDATE: <summary>" })
-- Generic intercom is lower-level plumbing/fallback only: intercom({ action: "ask", to: "{orchestratorTarget}", message: "<question>" })
-
-Do not use contact_supervisor or intercom for routine completion handoffs. If no coordination is needed, return a focused task result.`;
-
-export interface IntercomBridgeState {
-	active: boolean;
-	mode: IntercomBridgeMode;
-	orchestratorTarget?: string;
-	extensionDir: string;
-	instruction: string;
-}
-
-interface ResolveIntercomBridgeInput {
-	config: ExtensionConfig["intercomBridge"];
-	context: "fresh" | "fork" | undefined;
-	orchestratorTarget?: string;
-	extensionDir?: string;
-	configPath?: string;
-	settingsDir?: string;
-	cwd?: string;
-	agentDir?: string;
-	globalNpmRoot?: string | null;
-}
-
-export function resolveIntercomSessionTarget(sessionName: string | undefined, sessionId: string): string {
-	const connectedIntercomSessionId = getEnvValue(INTERCOM_SESSION_ID_ENV)?.trim();
-	if (connectedIntercomSessionId) return connectedIntercomSessionId;
-	const trimmedName = sessionName?.trim();
-	if (trimmedName) return trimmedName;
-	const normalizedSessionId = sessionId.startsWith("session-") ? sessionId.slice("session-".length) : sessionId;
-	return `${DEFAULT_INTERCOM_TARGET_PREFIX}-${normalizedSessionId}`;
-}
-
-function sanitizeIntercomTargetPart(value: string): string {
-	return (
-		value
-			.trim()
-			.toLowerCase()
-			.replace(/[^a-z0-9_-]+/g, "-")
-			.replace(/^-+|-+$/g, "") || "agent"
-	);
-}
-
-export function resolveSubagentIntercomTarget(runId: string, agent: string, index?: number): string {
-	const stepSuffix = index !== undefined ? `-${index + 1}` : "";
-	return `subagent-${sanitizeIntercomTargetPart(agent)}-${sanitizeIntercomTargetPart(runId)}${stepSuffix}`;
-}
-
-export function resolveIntercomBridgeMode(value: unknown): IntercomBridgeMode {
-	if (value === "off" || value === "always" || value === "fork-only") return value;
-	return "always";
-}
-
-function resolveIntercomBridgeConfig(value: ExtensionConfig["intercomBridge"]): Required<IntercomBridgeConfig> {
-	if (!value || typeof value !== "object" || Array.isArray(value)) {
-		return {
-			mode: "always",
-			instructionFile: "",
-		};
-	}
-	return {
-		mode: resolveIntercomBridgeMode(value.mode),
-		instructionFile: typeof value.instructionFile === "string" ? value.instructionFile : "",
-	};
-}
-
-function intercomConfigStatus(configPath: string): { enabled: boolean; error?: unknown } {
-	if (!fs.existsSync(configPath)) return { enabled: true };
-	try {
-		const parsed = JSON.parse(fs.readFileSync(configPath, "utf-8")) as { enabled?: unknown };
-		return { enabled: parsed.enabled !== false };
-	} catch (error) {
-		return { enabled: true, error };
-	}
-}
-
-function readJsonBestEffort(filePath: string): unknown {
-	try {
-		return JSON.parse(fs.readFileSync(filePath, "utf-8"));
-	} catch (error) {
-		const code =
-			error && typeof error === "object" && "code" in error ? (error as NodeJS.ErrnoException).code : undefined;
-		if (code !== "ENOENT") console.warn(`Failed to read JSON from '${filePath}'.`, error);
-		return null;
-	}
-}
-
-function packageHasPiExtension(packageRoot: string): boolean {
-	if (!fs.existsSync(packageRoot)) return false;
-	const pkg = readJsonBestEffort(path.join(packageRoot, "package.json"));
-	if (pkg && typeof pkg === "object" && !Array.isArray(pkg)) {
-		const pi = (pkg as { pi?: unknown }).pi;
-		if (pi && typeof pi === "object" && !Array.isArray(pi)) {
-			const extensions = (pi as { extensions?: unknown }).extensions;
-			return (
-				Array.isArray(extensions) && extensions.some((entry) => typeof entry === "string" && entry.trim() !== "")
-			);
-		}
-	}
-	return fs.existsSync(path.join(packageRoot, "extensions"));
-}
-
-function isSafePackagePath(value: string): boolean {
-	return (
-		value.length > 0 &&
-		!path.isAbsolute(value) &&
-		value.split(/[\\/]/).every((part) => part.length > 0 && part !== "." && part !== "..")
-	);
-}
-
-function parseNpmPackageName(source: string): string | undefined {
-	const spec = source.slice(4).trim();
-	if (!spec) return undefined;
-	const match = spec.match(/^(@?[^@]+(?:\/[^@]+)?)(?:@(.+))?$/);
-	const packageName = match?.[1] ?? spec;
-	return isSafePackagePath(packageName) ? packageName : undefined;
-}
-
-function packageEntrySource(entry: unknown): string | undefined {
-	if (typeof entry === "string") return entry;
-	if (
-		entry &&
-		typeof entry === "object" &&
-		!Array.isArray(entry) &&
-		typeof (entry as { source?: unknown }).source === "string"
-	) {
-		return (entry as { source: string }).source;
-	}
-	return undefined;
-}
-
-function packageEntryAllowsExtensions(entry: unknown): boolean {
-	if (!entry || typeof entry !== "object" || Array.isArray(entry)) return true;
-	const extensions = (entry as { extensions?: unknown }).extensions;
-	return !Array.isArray(extensions) || extensions.length > 0;
-}
-
-function findNearestProjectConfigDir(cwd: string): string | undefined {
-	let current = path.resolve(cwd);
-	while (true) {
-		for (const configDir of getProjectConfigDirs(current)) {
-			if (fs.existsSync(path.join(configDir, "settings.json"))) return configDir;
-		}
-		const parent = path.dirname(current);
-		if (parent === current) return undefined;
-		current = parent;
-	}
-}
-
-let cachedGlobalNpmRoot: string | null | undefined;
-
-function getGlobalNpmRoot(): string | null {
-	if (cachedGlobalNpmRoot !== undefined) return cachedGlobalNpmRoot;
-	try {
-		cachedGlobalNpmRoot = execSync("npm root -g", {
-			encoding: "utf-8",
-			timeout: 5000,
-			env: createChildProcessEnvironment(),
-		}).trim();
-		return cachedGlobalNpmRoot;
-	} catch {
-		cachedGlobalNpmRoot = null;
-		return null;
-	}
-}
-
-function configuredPiIntercomPackageDir(input: ResolveIntercomBridgeInput, agentDir: string): string | undefined {
-	const projectConfigDir = input.cwd ? findNearestProjectConfigDir(path.resolve(input.cwd)) : undefined;
-	const settingsFiles = [
-		...(projectConfigDir
-			? [
-					{
-						file: path.join(projectConfigDir, "settings.json"),
-						configDir: projectConfigDir,
-						scope: "project" as const,
-					},
-				]
-			: []),
-		{ file: path.join(agentDir, "settings.json"), configDir: agentDir, scope: "user" as const },
-	];
-	let resolvedGlobalNpmRoot = input.globalNpmRoot;
-	const resolveGlobalNpmRoot = (): string | null => {
-		if (resolvedGlobalNpmRoot !== undefined) return resolvedGlobalNpmRoot;
-		resolvedGlobalNpmRoot = getGlobalNpmRoot();
-		return resolvedGlobalNpmRoot;
-	};
-
-	for (const { file, configDir, scope } of settingsFiles) {
-		const settings = readJsonBestEffort(file);
-		if (!settings || typeof settings !== "object" || Array.isArray(settings)) continue;
-		const packages = (settings as { packages?: unknown }).packages;
-		if (!Array.isArray(packages)) continue;
-
-		for (const entry of packages) {
-			if (!packageEntryAllowsExtensions(entry)) continue;
-			const source = packageEntrySource(entry)?.trim();
-			if (!source?.startsWith("npm:")) continue;
-			const packageName = parseNpmPackageName(source);
-			if (packageName !== PI_INTERCOM_PACKAGE_NAME) continue;
-			const globalNpmRoot = scope === "user" ? resolveGlobalNpmRoot() : null;
-			const candidates =
-				scope === "project"
-					? [path.join(configDir, "npm", "node_modules", packageName)]
-					: [
-							...(globalNpmRoot ? [path.join(globalNpmRoot, packageName)] : []),
-							path.join(agentDir, "npm", "node_modules", packageName),
-						];
-			const packageRoot = candidates.find(packageHasPiExtension);
-			if (packageRoot) return path.resolve(packageRoot);
-		}
-	}
-	return undefined;
-}
-
-function resolveIntercomExtensionDir(input: ResolveIntercomBridgeInput, agentDir: string): string {
-	if (input.extensionDir) return path.resolve(input.extensionDir);
-	const bundledDir = bundledIntercomExtensionDir();
-	if (packageHasPiExtension(bundledDir)) return bundledDir;
-	const legacyDir = path.resolve(defaultIntercomExtensionDir(agentDir));
-	if (fs.existsSync(legacyDir)) return legacyDir;
-	return configuredPiIntercomPackageDir(input, agentDir) ?? legacyDir;
-}
-
-function extensionSandboxAllowsIntercom(extensions: string[] | undefined, extensionDir: string): boolean {
-	if (extensions === undefined) return true;
-
-	const intercomDir = path.resolve(extensionDir).replaceAll("\\", "/").toLowerCase();
-	for (const entry of extensions) {
-		const normalized = entry.trim().replaceAll("\\", "/").toLowerCase();
-		if (normalized === "pi-intercom") return true;
-		if (normalized === intercomDir) return true;
-		if (normalized.startsWith(`${intercomDir}/`)) return true;
-		if (normalized.endsWith("/pi-intercom")) return true;
-		if (normalized.includes("/pi-intercom/")) return true;
-	}
-	return false;
-}
-
-function expandTilde(filePath: string): string {
-	return filePath.startsWith("~/") ? path.join(os.homedir(), filePath.slice(2)) : filePath;
-}
-
-function resolveInstructionTemplate(instructionFile: string, settingsDir: string): string {
-	if (!instructionFile) return DEFAULT_INTERCOM_BRIDGE_TEMPLATE;
-	const expandedPath = expandTilde(instructionFile);
-	const resolvedPath = path.isAbsolute(expandedPath) ? expandedPath : path.resolve(settingsDir, expandedPath);
-	try {
-		return fs.readFileSync(resolvedPath, "utf-8");
-	} catch (error) {
-		console.warn(
-			`Failed to read intercom bridge instructionFile at '${resolvedPath}'. Using default instructions.`,
-			error,
-		);
-		return DEFAULT_INTERCOM_BRIDGE_TEMPLATE;
-	}
-}
-
-function buildIntercomBridgeInstruction(orchestratorTarget: string, template: string): string {
-	const instruction = template.replaceAll("{orchestratorTarget}", orchestratorTarget).trim();
-	if (instruction.startsWith(INTERCOM_BRIDGE_MARKER)) return instruction;
-	return `${INTERCOM_BRIDGE_MARKER}
-${instruction}`;
-}
-
-export function resolveIntercomBridge(input: ResolveIntercomBridgeInput): IntercomBridgeState {
-	const config = resolveIntercomBridgeConfig(input.config);
-	const mode = config.mode;
-	const agentDir = path.resolve(input.agentDir ?? defaultAgentDir());
-	const extensionDir = resolveIntercomExtensionDir(input, agentDir);
-	const orchestratorTarget = input.orchestratorTarget?.trim();
-	const settingsDir = path.resolve(input.settingsDir ?? defaultSubagentConfigDir(agentDir));
-	const defaultInstruction = buildIntercomBridgeInstruction(
-		orchestratorTarget || "{orchestratorTarget}",
-		DEFAULT_INTERCOM_BRIDGE_TEMPLATE,
-	);
-
-	if (mode === "off") {
-		return { active: false, mode, extensionDir, instruction: defaultInstruction };
-	}
-	if (mode === "fork-only" && input.context !== "fork") {
-		return { active: false, mode, extensionDir, instruction: defaultInstruction };
-	}
-	if (!orchestratorTarget) {
-		return { active: false, mode, extensionDir, instruction: defaultInstruction };
-	}
-	if (!fs.existsSync(extensionDir)) {
-		return { active: false, mode, extensionDir, instruction: defaultInstruction };
-	}
-
-	const configPath = path.resolve(input.configPath ?? defaultIntercomConfigPath(agentDir));
-	const intercomStatus = intercomConfigStatus(configPath);
-	if (intercomStatus.error)
-		console.warn(`Failed to parse intercom config at '${configPath}'. Assuming enabled.`, intercomStatus.error);
-	if (!intercomStatus.enabled) {
-		return { active: false, mode, extensionDir, instruction: defaultInstruction };
-	}
-
-	const instruction = buildIntercomBridgeInstruction(
-		orchestratorTarget,
-		resolveInstructionTemplate(config.instructionFile, settingsDir),
-	);
-
-	return {
-		active: true,
-		mode,
-		orchestratorTarget,
-		extensionDir,
-		instruction,
-	};
-}
-
-export function applyIntercomBridgeToAgent(agent: AgentConfig, bridge: IntercomBridgeState): AgentConfig {
-	if (!bridge.active || !bridge.orchestratorTarget) return agent;
-	if (!extensionSandboxAllowsIntercom(agent.extensions, bridge.extensionDir)) return agent;
-
-	const bridgeTools = ["intercom", "contact_supervisor"];
-	const tools = agent.tools
-		? [...agent.tools, ...bridgeTools.filter((tool) => !agent.tools?.includes(tool))]
-		: agent.tools;
-	const instruction = bridge.instruction;
-	const trimmedPrompt = agent.systemPrompt?.trim() || "";
-	const systemPrompt = trimmedPrompt.includes(INTERCOM_BRIDGE_MARKER)
-		? trimmedPrompt
-		: trimmedPrompt
-			? `${trimmedPrompt}\n\n${instruction}`
-			: instruction;
-
-	if (tools === agent.tools && systemPrompt === agent.systemPrompt) return agent;
-	return {
-		...agent,
-		tools,
-		systemPrompt,
-	};
-}

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

@@ -1,246 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { isStaleExtensionContextError } from "@bastani/atomic";
-import {
-	type Details,
-	type IntercomEventBus,
-	type SingleResult,
-	SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT,
-	SUBAGENT_RESULT_INTERCOM_EVENT,
-	type SubagentAttemptStatus,
-	type SubagentResultIntercomChild,
-	type SubagentResultIntercomPayload,
-	type SubagentResultStatus,
-	type SubagentRunMode,
-} from "../shared/types.js";
-
-export function resolveSubagentResultStatus(input: {
-	status?: SubagentAttemptStatus;
-	success?: boolean;
-	state?: string;
-	interrupted?: boolean;
-	detached?: boolean;
-}): SubagentResultStatus {
-	if (input.detached || input.status === "continued") return "detached";
-	if (input.interrupted || input.status === "interrupted" || input.state === "interrupted") return "interrupted";
-	if (input.status === "ok" || input.success === true || input.state === "complete") return "completed";
-	if (input.status === "error" || input.status === "skipped" || input.success === false || input.state === "failed")
-		return "failed";
-	return "failed";
-}
-
-function countStatuses(children: SubagentResultIntercomChild[]): Record<SubagentResultStatus, number> {
-	const counts: Record<SubagentResultStatus, number> = {
-		completed: 0,
-		failed: 0,
-		interrupted: 0,
-		detached: 0,
-	};
-	for (const child of children) {
-		counts[child.status] += 1;
-	}
-	return counts;
-}
-
-function formatStatusCounts(counts: Record<SubagentResultStatus, number>): string {
-	const parts = [
-		counts.completed ? `${counts.completed} completed` : undefined,
-		counts.failed ? `${counts.failed} failed` : undefined,
-		counts.interrupted ? `${counts.interrupted} interrupted` : undefined,
-		counts.detached ? `${counts.detached} detached` : undefined,
-	].filter((part): part is string => Boolean(part));
-	return parts.length ? parts.join(", ") : "0 results";
-}
-
-function resolveGroupedStatus(children: SubagentResultIntercomChild[]): SubagentResultStatus {
-	const counts = countStatuses(children);
-	if (counts.failed > 0) return "failed";
-	if (counts.interrupted > 0) return "interrupted";
-	if (counts.completed > 0) return "completed";
-	if (counts.detached > 0) return "detached";
-	return "failed";
-}
-
-export interface GroupedResultIntercomMessageInput {
-	to: string;
-	runId: string;
-	mode: SubagentRunMode;
-	children: SubagentResultIntercomChild[];
-}
-
-function formatSubagentResultIntercomMessage(input: {
-	runId: string;
-	mode: SubagentRunMode;
-	status: SubagentResultStatus;
-	children: SubagentResultIntercomChild[];
-}): string {
-	const counts = countStatuses(input.children);
-	const lines: string[] = [
-		"subagent results",
-		"",
-		`Run: ${input.runId}`,
-		`Mode: ${input.mode}`,
-		`Status: ${input.status}`,
-		`Children: ${formatStatusCounts(counts)}`,
-	];
-	if (input.children.some((child) => child.intercomTarget)) {
-		lines.push(
-			"",
-			"Intercom targets below identify child sessions used while they were running; completed child sessions may no longer be reachable. Inspect artifacts or session logs for follow-up.",
-		);
-	}
-
-	for (let index = 0; index < input.children.length; index++) {
-		const child = input.children[index]!;
-		lines.push("", `${index + 1}. ${child.agent} — ${child.status}`);
-		if (child.intercomTarget) lines.push(`Run intercom target: ${child.intercomTarget}`);
-		if (child.artifactPath) lines.push(`Output artifact: ${child.artifactPath}`);
-		if (child.sessionPath) lines.push(`Session: ${child.sessionPath}`);
-		lines.push("Summary:", child.summary);
-	}
-
-	return lines.join("\n");
-}
-
-export function buildSubagentResultIntercomPayload(
-	input: GroupedResultIntercomMessageInput,
-): SubagentResultIntercomPayload {
-	const children = input.children.map((child) => ({
-		...child,
-		summary: child.summary.trim() || "(no output)",
-	}));
-	const status = resolveGroupedStatus(children);
-	const summary = formatStatusCounts(countStatuses(children));
-	const firstChild = children[0];
-	const payload: SubagentResultIntercomPayload = {
-		to: input.to,
-		runId: input.runId,
-		mode: input.mode,
-		status,
-		summary,
-		children,
-		...(firstChild?.agent ? { agent: firstChild.agent } : {}),
-		...(firstChild?.index !== undefined ? { index: firstChild.index } : {}),
-		...(firstChild?.artifactPath ? { artifactPath: firstChild.artifactPath } : {}),
-		...(firstChild?.sessionPath ? { sessionPath: firstChild.sessionPath } : {}),
-		message: "",
-	};
-	payload.message = formatSubagentResultIntercomMessage(payload);
-	return payload;
-}
-
-export async function deliverSubagentResultIntercomEvent(
-	events: IntercomEventBus,
-	payload: SubagentResultIntercomPayload,
-	timeoutMs: number | false = 500,
-): Promise<boolean> {
-	return deliverSubagentIntercomMessageEvent(
-		events,
-		payload.to,
-		payload.message,
-		timeoutMs,
-		payload as unknown as Record<string, unknown>,
-	);
-}
-
-export async function deliverSubagentIntercomMessageEvent(
-	events: IntercomEventBus,
-	to: string,
-	message: string,
-	timeoutMs: number | false = 500,
-	extra: Record<string, unknown> = {},
-): Promise<boolean> {
-	if (typeof events.on !== "function" || typeof events.emit !== "function") return false;
-	const requestId = typeof extra.requestId === "string" ? extra.requestId : randomUUID();
-	return new Promise((resolve) => {
-		let settled = false;
-		let unsubscribe: (() => void) | undefined;
-		let timer: ReturnType<typeof setTimeout> | undefined;
-		const finish = (delivered: boolean) => {
-			if (settled) return;
-			settled = true;
-			if (timer) clearTimeout(timer);
-			try {
-				unsubscribe?.();
-			} catch (error) {
-				if (!isStaleExtensionContextError(error)) throw error;
-				// Stale event-bus cleanup must not change the delivery result.
-			}
-			resolve(delivered);
-		};
-		try {
-			unsubscribe = events.on(SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT, (data) => {
-				if (!data || typeof data !== "object") return;
-				const delivery = data as { requestId?: unknown; delivered?: unknown };
-				if (delivery.requestId !== requestId) return;
-				finish(delivery.delivered === true);
-			});
-		} catch (error) {
-			if (!isStaleExtensionContextError(error)) throw error;
-			finish(false);
-			return;
-		}
-		if (timeoutMs !== false) timer = setTimeout(() => finish(false), timeoutMs);
-		try {
-			events.emit(SUBAGENT_RESULT_INTERCOM_EVENT, { ...extra, to, message, requestId });
-		} catch {
-			finish(false);
-		}
-	});
-}
-
-function stripSingleResultOutputs(result: SingleResult): SingleResult {
-	return {
-		...result,
-		messages: undefined,
-		finalOutput: undefined,
-		truncation: undefined,
-	};
-}
-
-export function stripDetailsOutputsForIntercomReceipt(details: Details): Details {
-	return {
-		...details,
-		results: details.results.map(stripSingleResultOutputs),
-	};
-}
-
-export function formatSubagentResultReceipt(input: {
-	mode: SubagentRunMode;
-	runId: string;
-	payload: SubagentResultIntercomPayload;
-}): string {
-	const counts = countStatuses(input.payload.children);
-	const modeLabel = input.mode === "single" ? "single subagent result" : "parallel subagent results";
-	const lines = [
-		`Delivered ${modeLabel} via intercom.`,
-		`Run: ${input.runId}`,
-		`Children: ${formatStatusCounts(counts)}`,
-	];
-
-	const artifacts = input.payload.children.filter((child) => typeof child.artifactPath === "string");
-	if (artifacts.length > 0) {
-		lines.push("Artifacts:");
-		for (const child of artifacts) {
-			lines.push(`- ${child.agent} [${child.status}]: ${child.artifactPath}`);
-		}
-	}
-
-	const intercomTargets = input.payload.children.filter((child) => typeof child.intercomTarget === "string");
-	if (intercomTargets.length > 0) {
-		lines.push("Run intercom targets (may be inactive after completion):");
-		for (const child of intercomTargets) {
-			lines.push(`- ${child.agent} [${child.status}]: ${child.intercomTarget}`);
-		}
-	}
-
-	const sessions = input.payload.children.filter((child) => typeof child.sessionPath === "string");
-	if (sessions.length > 0) {
-		lines.push("Sessions:");
-		for (const child of sessions) {
-			lines.push(`- ${child.agent} [${child.status}]: ${child.sessionPath}`);
-		}
-	}
-
-	lines.push("Full grouped output was sent over intercom.");
-	return lines.join("\n");
-}

package/dist/builtin/subagents/src/intercom/supervisor-authorization.ts

@@ -1,30 +0,0 @@
-import { isStaleExtensionContextError } from "@bastani/atomic";
-import type { IntercomEventBus } from "../shared/types.js";
-
-export const SUBAGENT_SUPERVISOR_AUTHORIZATION_EVENT = "subagent:supervisor-authorization";
-
-export interface SupervisorAuthorization {
-	capability: string;
-	supervisorSessionId: string;
-	childName: string;
-}
-
-/** Ask the parent Intercom extension to mint a broker-issued child capability. */
-export async function requestSupervisorAuthorization(
-	events: IntercomEventBus | undefined,
-	childName: string | undefined,
-): Promise<SupervisorAuthorization | undefined> {
-	const normalizedChildName = childName?.trim();
-	if (!events || !normalizedChildName) return undefined;
-	const request: { childName: string; completion?: Promise<SupervisorAuthorization> } = {
-		childName: normalizedChildName,
-	};
-	try {
-		events.emit(SUBAGENT_SUPERVISOR_AUTHORIZATION_EVENT, request);
-		return request.completion ? await request.completion : undefined;
-	} catch (error) {
-		if (!isStaleExtensionContextError(error)) throw error;
-		// Authorization is advisory when a child outlives its parent runtime.
-		return undefined;
-	}
-}

package/dist/builtin/subagents/src/runs/foreground/completion-notification.ts

@@ -1,42 +0,0 @@
-import type { IntercomEventBus } from "../../shared/types.js";
-import { SUBAGENT_COMPLETE_EVENT } from "../../shared/types.js";
-
-export interface CompletionNotificationEnvelope extends Record<string, unknown> {
-	notificationId: string;
-	acknowledge: (delivered: boolean) => void;
-	defer: () => void;
-}
-
-export function deliverLocalCompletionNotification(
-	events: IntercomEventBus,
-	payload: Record<string, unknown>,
-	notificationId: string,
-): Promise<boolean> {
-	return new Promise((resolve, reject) => {
-		let settled = false;
-		let deferred = false;
-		const finish = (delivered: boolean) => {
-			if (settled) return;
-			settled = true;
-			resolve(delivered);
-		};
-		const fail = (error: unknown) => {
-			if (settled) return;
-			settled = true;
-			reject(error);
-		};
-		try {
-			events.emit(SUBAGENT_COMPLETE_EVENT, {
-				...payload,
-				notificationId,
-				defer: () => {
-					deferred = true;
-				},
-				acknowledge: finish,
-			} satisfies CompletionNotificationEnvelope);
-			if (!deferred) finish(true);
-		} catch (error) {
-			fail(error);
-		}
-	});
-}