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

package/dist/builtin/intercom/intercom-utils.ts

@@ -1,427 +0,0 @@
-import { type ExtensionAPI, type SubagentChildPolicy } from "@bastani/atomic";
-import type { Attachment, Message, SessionInfo, SupervisorRegistration } from "./types.js";
-import { DEFAULT_GROUP, normalizeGroup } from "./group.js";
-
-
-export const SUBAGENT_CONTROL_INTERCOM_EVENT = "subagent:control-intercom";
-export const SUBAGENT_RESULT_INTERCOM_EVENT = "subagent:result-intercom";
-export const SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT = "subagent:result-intercom-delivery";
-export const SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT = "subagent:terminal-ordering-barrier";
-export const SUBAGENT_SUPERVISOR_AUTHORIZATION_EVENT = "subagent:supervisor-authorization";
-export const INBOUND_FLUSH_DELAY_MS = 200;
-export const INBOUND_IDLE_RETRY_MS = 500;
-export const DEFAULT_UNNAMED_SESSION_ALIAS_PREFIX = "subagent-chat";
-
-export interface ChildOrchestratorMetadata {
-  orchestratorTarget: string;
-  runId: string;
-  agent: string;
-  index: string;
-  sessionName?: string;
-  supervisor?: SupervisorRegistration;
-}
-
-export interface InboundMessageEntry {
-  from: SessionInfo;
-  message: Message;
-  channel?: "supervisor";
-  replyCommand?: string;
-  bodyText: string;
-}
-
-export type ContactSupervisorReason = "need_decision" | "progress_update" | "interview_request";
-
-export interface SupervisorInterviewQuestion extends Record<string, unknown> {
-  id: string;
-  type: "single" | "multi" | "text" | "image" | "info";
-  question: string;
-  options?: unknown[];
-}
-
-export interface SupervisorInterviewRequest extends Record<string, unknown> {
-  title?: string;
-  description?: string;
-  questions: SupervisorInterviewQuestion[];
-}
-
-export interface SupervisorInterviewReply {
-  responses: Array<{ id: string; value: unknown }>;
-}
-
-export function getErrorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
-
-export function toError(error: unknown): Error {
-  return error instanceof Error ? error : new Error(String(error));
-}
-
-export function formatAttachments(attachments: Attachment[]): string {
-  let text = "";
-  for (const att of attachments) {
-    if (att.language) {
-      text += `\n\n---\n📎 ${att.name}\n~~~${att.language}\n${att.content}\n~~~`;
-    } else {
-      text += `\n\n---\n📎 ${att.name}\n${att.content}`;
-    }
-  }
-  return text;
-}
-export function childOrchestratorMetadataFromPolicy(policy?: SubagentChildPolicy): ChildOrchestratorMetadata | null {
-  const identity = policy?.intercom;
-  if (!identity) return null;
-  return {
-    orchestratorTarget: identity.orchestratorTarget,
-    runId: identity.runId,
-    agent: identity.agent,
-    index: String(identity.index),
-    ...(identity.sessionName ? { sessionName: identity.sessionName } : {}),
-    ...(identity.supervisor ? { supervisor: identity.supervisor } : {}),
-  };
-}
-
-/** Resolve metadata only from the admission-issued typed child identity. */
-export function readChildOrchestratorMetadata(policy?: SubagentChildPolicy): ChildOrchestratorMetadata | null {
-	return childOrchestratorMetadataFromPolicy(policy);
-}
-export function formatChildOrchestratorMessage(kind: "ask" | "update" | "interview", metadata: ChildOrchestratorMetadata, message: string): string {
-  const heading = kind === "ask"
-    ? "Subagent needs a supervisor decision."
-    : kind === "interview"
-      ? "Subagent requests a structured supervisor interview."
-      : "Subagent progress update.";
-  return [
-    heading,
-    `Run: ${metadata.runId}`,
-    `Agent: ${metadata.agent}`,
-    `Child index: ${metadata.index}`,
-    metadata.sessionName ? `Child intercom target: ${metadata.sessionName}` : undefined,
-    "",
-    message,
-  ].filter((line): line is string => line !== undefined).join("\n");
-}
-
-export function validateSupervisorInterviewRequest(input: unknown): { ok: true; interview: SupervisorInterviewRequest } | { ok: false; error: string } {
-  if (!input || typeof input !== "object" || Array.isArray(input)) {
-    return { ok: false, error: "interview must be an object with a questions array" };
-  }
-
-  const raw = input as Record<string, unknown>;
-  if (raw.title !== undefined && typeof raw.title !== "string") {
-    return { ok: false, error: "interview.title must be a string when provided" };
-  }
-  if (raw.description !== undefined && typeof raw.description !== "string") {
-    return { ok: false, error: "interview.description must be a string when provided" };
-  }
-  if (!Array.isArray(raw.questions) || raw.questions.length === 0) {
-    return { ok: false, error: "interview.questions must be a non-empty array" };
-  }
-
-  const validTypes = new Set(["single", "multi", "text", "image", "info"]);
-  const ids = new Set<string>();
-  const questions: SupervisorInterviewQuestion[] = [];
-
-  for (let index = 0; index < raw.questions.length; index++) {
-    const questionInput = raw.questions[index];
-    if (!questionInput || typeof questionInput !== "object" || Array.isArray(questionInput)) {
-      return { ok: false, error: `interview.questions[${index}] must be an object` };
-    }
-    const question = questionInput as Record<string, unknown>;
-    if (typeof question.id !== "string" || question.id.trim() === "") {
-      return { ok: false, error: `interview.questions[${index}].id must be a non-empty string` };
-    }
-    const id = question.id.trim();
-    if (ids.has(id)) {
-      return { ok: false, error: `interview question id must be unique: ${id}` };
-    }
-    ids.add(id);
-
-    if (typeof question.type !== "string" || !validTypes.has(question.type)) {
-      return { ok: false, error: `interview.questions[${index}].type must be one of: single, multi, text, image, info` };
-    }
-    if (typeof question.question !== "string" || question.question.trim() === "") {
-      return { ok: false, error: `interview.questions[${index}].question must be a non-empty string` };
-    }
-    if (question.context !== undefined && typeof question.context !== "string") {
-      return { ok: false, error: `interview.questions[${index}].context must be a string when provided` };
-    }
-    let options: unknown[] | undefined;
-    if (question.options !== undefined) {
-      if (!Array.isArray(question.options)) {
-        return { ok: false, error: `interview.questions[${index}].options must be an array when provided` };
-      }
-      options = [];
-      for (let optionIndex = 0; optionIndex < question.options.length; optionIndex++) {
-        const option = question.options[optionIndex];
-        if (typeof option === "string") {
-          const label = option.trim();
-          if (!label) {
-            return { ok: false, error: `interview.questions[${index}].options[${optionIndex}] must not be empty` };
-          }
-          options.push(label);
-        } else if (!option || typeof option !== "object" || Array.isArray(option) || typeof (option as { label?: unknown }).label !== "string" || (option as { label: string }).label.trim() === "") {
-          return { ok: false, error: `interview.questions[${index}].options[${optionIndex}] must be a non-empty string or an object with a non-empty label` };
-        } else {
-          options.push({ ...option, label: (option as { label: string }).label.trim() });
-        }
-      }
-    }
-    if ((question.type === "single" || question.type === "multi") && (!options || options.length === 0)) {
-      return { ok: false, error: `interview.questions[${index}].options must be a non-empty array for ${question.type} questions` };
-    }
-    if (question.type !== "single" && question.type !== "multi" && options) {
-      return { ok: false, error: `interview.questions[${index}].options is only valid for single and multi questions` };
-    }
-
-    questions.push({
-      ...question,
-      id,
-      type: question.type as SupervisorInterviewQuestion["type"],
-      question: question.question.trim(),
-      ...(options ? { options } : {}),
-    });
-  }
-
-  return {
-    ok: true,
-    interview: {
-      ...raw,
-      ...(typeof raw.title === "string" ? { title: raw.title.trim() } : {}),
-      ...(typeof raw.description === "string" ? { description: raw.description.trim() } : {}),
-      questions,
-    },
-  };
-}
-
-function interviewOptionLabel(option: unknown): string {
-  return typeof option === "string" ? option : (option as { label: string }).label;
-}
-
-function interviewExampleValue(question: SupervisorInterviewQuestion): unknown {
-  if (question.type === "multi") {
-    return question.options?.slice(0, 2).map(interviewOptionLabel) ?? [];
-  }
-  if (question.type === "single") {
-    return question.options?.[0] !== undefined ? interviewOptionLabel(question.options[0]) : "option label";
-  }
-  if (question.type === "image") {
-    return "image/file reference or description";
-  }
-  return "answer text";
-}
-
-export function formatSupervisorInterviewRequest(interview: SupervisorInterviewRequest, message?: string): string {
-  const lines: string[] = [];
-  const title = interview.title?.trim();
-  if (title) lines.push(`Interview: ${title}`);
-  const description = interview.description?.trim();
-  if (description) lines.push(description);
-  const note = message?.trim();
-  if (note) lines.push(`Child note: ${note}`);
-  if (lines.length > 0) lines.push("");
-
-  lines.push("Questions:");
-  interview.questions.forEach((question, index) => {
-    lines.push(`${index + 1}. [${question.id}] (${question.type}) ${question.question}`);
-    if (typeof question.context === "string" && question.context.trim()) {
-      lines.push(`   Context: ${question.context.trim()}`);
-    }
-    if (question.options?.length) {
-      lines.push("   Options:");
-      for (const option of question.options) {
-        lines.push(`   - ${interviewOptionLabel(option)}`);
-      }
-    }
-  });
-
-  const responseExample = {
-    responses: interview.questions
-      .filter((question) => question.type !== "info")
-      .map((question) => ({
-        id: question.id,
-        value: interviewExampleValue(question),
-      })),
-  };
-
-  lines.push(
-    "",
-    "Supervisor reply instructions:",
-    "Reply with plain JSON or a fenced ```json block using this stable shape. Use the question ids exactly. Info questions are context-only and do not need responses. For single questions, value is one option label. For multi questions, value is an array of option labels. For text/image questions, value is a string unless the question asks otherwise.",
-    "",
-    "```json",
-    JSON.stringify(responseExample, null, 2),
-    "```",
-  );
-
-  return lines.join("\n");
-}
-
-export function validateSupervisorInterviewReply(value: unknown, interview: SupervisorInterviewRequest): SupervisorInterviewReply {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error("reply JSON must be an object with a responses array");
-  }
-
-  const responsesInput = (value as Record<string, unknown>).responses;
-  if (!Array.isArray(responsesInput)) {
-    throw new Error("reply JSON must include a responses array");
-  }
-
-  const questionById = new Map(interview.questions
-    .filter((question) => question.type !== "info")
-    .map((question) => [question.id, question]));
-  const seenIds = new Set<string>();
-  const responses: SupervisorInterviewReply["responses"] = [];
-
-  for (let index = 0; index < responsesInput.length; index++) {
-    const response = responsesInput[index];
-    if (!response || typeof response !== "object" || Array.isArray(response)) {
-      throw new Error(`responses[${index}] must be an object`);
-    }
-
-    const raw = response as Record<string, unknown>;
-    if (typeof raw.id !== "string" || raw.id.trim() === "") {
-      throw new Error(`responses[${index}].id must be a non-empty string`);
-    }
-    const id = raw.id.trim();
-    const question = questionById.get(id);
-    if (!question) {
-      throw new Error(`responses[${index}].id must match a non-info interview question id`);
-    }
-    if (seenIds.has(id)) {
-      throw new Error(`responses[${index}].id is duplicated: ${id}`);
-    }
-    seenIds.add(id);
-    if (!Object.hasOwn(raw, "value")) {
-      throw new Error(`responses[${index}].value is required`);
-    }
-
-    const value = raw.value;
-    if (question.type === "single") {
-      if (typeof value !== "string") throw new Error(`responses[${index}].value must be a string for single questions`);
-      const optionLabels = new Set(question.options?.map(interviewOptionLabel));
-      if (!optionLabels.has(value.trim())) throw new Error(`responses[${index}].value must match one of the question options`);
-      responses.push({ id, value: value.trim() });
-      continue;
-    }
-
-    if (question.type === "multi") {
-      if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
-        throw new Error(`responses[${index}].value must be an array of strings for multi questions`);
-      }
-      const optionLabels = new Set(question.options?.map(interviewOptionLabel));
-      const selected = value.map((item) => item.trim());
-      const invalid = selected.find((item) => !optionLabels.has(item));
-      if (invalid) throw new Error(`responses[${index}].value contains an option that is not in the question options: ${invalid}`);
-      responses.push({ id, value: selected });
-      continue;
-    }
-
-    if (typeof value !== "string") {
-      throw new Error(`responses[${index}].value must be a string for ${question.type} questions`);
-    }
-    responses.push({ id, value });
-  }
-
-  return { responses };
-}
-
-export function parseStructuredSupervisorReply(text: string, interview: SupervisorInterviewRequest): { value?: SupervisorInterviewReply; error?: string } | undefined {
-  const fencedMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
-  const candidate = (fencedMatch?.[1] ?? text).trim();
-  if (!candidate.startsWith("{") && !candidate.startsWith("[")) {
-    return undefined;
-  }
-  try {
-    return { value: validateSupervisorInterviewReply(JSON.parse(candidate), interview) };
-  } catch (error) {
-    return { error: getErrorMessage(error) };
-  }
-}
-export function duplicateSessionNames(sessions: SessionInfo[]): Set<string> {
-  return new Set(
-    sessions
-      .map(s => s.name?.toLowerCase())
-      .filter((name): name is string => Boolean(name))
-      .filter((name, index, names) => names.indexOf(name) !== index)
-  );
-}
-export function parseSubagentIntercomPayload(payload: unknown): { to: string; message: string; requestId?: string } | null {
-  if (typeof payload !== "object" || payload === null) {
-    return null;
-  }
-  const record = payload as Record<string, unknown>;
-  if (typeof record.to !== "string" || typeof record.message !== "string") {
-    return null;
-  }
-  const requestId = typeof record.requestId === "string" ? record.requestId : undefined;
-  return { to: record.to, message: record.message, ...(requestId ? { requestId } : {}) };
-}
-function subagentTargetPart(value: string): string {
-  return value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
-}
-
-function resolveSubagentSourceTarget(runId: string, agent: string, index: number): string {
-  return `subagent-${subagentTargetPart(agent)}-${subagentTargetPart(runId)}-${index + 1}`;
-}
-
-export function parseSubagentResultBarrier(payload: unknown): { runId: string; terminalId?: string; sourceSessionTargets: string[] } | null {
-  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return null;
-  const record = payload as Record<string, unknown>;
-  if (typeof record.runId !== "string" || !Array.isArray(record.children)) return null;
-  const runId = record.runId;
-  const requestId = typeof record.requestId === "string" ? record.requestId : undefined;
-  const terminalId = requestId?.startsWith("completion-") ? requestId.slice("completion-".length) : requestId;
-  const sourceSessionTargets = record.children.flatMap((child, arrayIndex) => {
-    if (!child || typeof child !== "object" || Array.isArray(child)) return [];
-    const childRecord = child as Record<string, unknown>;
-    const target = typeof childRecord.intercomTarget === "string" ? childRecord.intercomTarget.trim() : "";
-    if (target) return [target];
-    if (typeof childRecord.agent !== "string") return [];
-    const index = typeof childRecord.index === "number" && Number.isInteger(childRecord.index) && childRecord.index >= 0
-      ? childRecord.index : arrayIndex;
-    return [resolveSubagentSourceTarget(runId, childRecord.agent, index)];
-  });
-  return sourceSessionTargets.length > 0
-    ? { runId, ...(terminalId ? { terminalId } : {}), sourceSessionTargets }
-    : null;
-}
-export function resolveIntercomPresenceName(sessionName: string | undefined, sessionId: string): string {
-  const trimmedName = sessionName?.trim();
-  if (trimmedName) {
-    return trimmedName;
-  }
-  const normalizedSessionId = sessionId.startsWith("session-") ? sessionId.slice("session-".length) : sessionId;
-  return `${DEFAULT_UNNAMED_SESSION_ALIAS_PREFIX}-${normalizedSessionId}`;
-}
-export function buildPresenceIdentity(pi: ExtensionAPI, sessionId: string): { name: string } {
-  return {
-    name: resolveIntercomPresenceName(pi.getSessionName(), sessionId),
-  };
-}
-export function formatSessionLabel(session: SessionInfo, duplicates: Set<string>): string {
-  if (!session.name) {
-    return session.id;
-  }
-  return duplicates.has(session.name.toLowerCase())
-    ? `${session.name} (${session.id})`
-    : session.name;
-}
-export function formatSessionListRow(session: SessionInfo, currentCwd: string, isSelf: boolean): string {
-  const name = session.name || "Unnamed session";
-  const normalizedGroup = normalizeGroup(session.group);
-  const groupTag = normalizedGroup !== DEFAULT_GROUP ? `group: ${normalizedGroup}` : undefined;
-  const tags = [isSelf ? "self" : session.cwd === currentCwd ? "same cwd" : undefined, session.status, groupTag]
-    .filter((tag): tag is string => Boolean(tag));
-  const suffix = tags.length ? ` [${tags.join(", ")}]` : "";
-  return `• ${name} (${session.id}) — ${session.cwd} (${session.model})${suffix}`;
-}
-export function previewText(value: unknown, maxLength = 72): string | undefined {
-  if (typeof value !== "string") {
-    return undefined;
-  }
-  const normalized = value.replace(/\s+/g, " ").trim();
-  if (!normalized) {
-    return undefined;
-  }
-  return normalized.length > maxLength ? `${normalized.slice(0, maxLength - 1)}…` : normalized;
-}

package/dist/builtin/intercom/late-stage-message-router.ts

@@ -1,148 +0,0 @@
-import type { ExtensionAPI } from "@bastani/atomic";
-import type { InboundMessageEntry } from "./intercom-utils.js";
-import type { InboundMessageAdmission, InboundMessageReservation } from "./inbound-message-admission.js";
-import type { IntercomContext, ReplyTracker } from "./reply-tracker.js";
-import { DEFAULT_GROUP, normalizeGroup } from "./group.js";
-
-const LATE_STAGE_MESSAGE_EVENT = "atomic:workflow-stage-late-message";
-type LateStageMessage = Parameters<ExtensionAPI["sendMessage"]>[0];
-type LateStageMessageEvent = {
-  handled: boolean;
-  completion?: Promise<void>;
-  batch: boolean;
-  messages: LateStageMessage[];
-  workflowRunId?: string;
-  workflowStageId?: string;
-  options?: Parameters<ExtensionAPI["sendMessage"]>[1];
-};
-
-interface LateStageReservation {
-  message: LateStageMessage;
-  reservation: InboundMessageReservation;
-  context: IntercomContext;
-}
-
-function isSubagentRelayHandoff(entry: InboundMessageEntry): boolean {
-  return entry.from.id === "subagent-control" || entry.from.id === "subagent-result";
-}
-
-export function registerLateStageMessageRouter(
-  pi: ExtensionAPI,
-  admission: InboundMessageAdmission,
-  getReplyTracker: () => ReplyTracker,
-  getOwnerGroup: () => string = () => DEFAULT_GROUP,
-): void {
-  pi.events.on(LATE_STAGE_MESSAGE_EVENT, (data) => {
-    if (!data || typeof data !== "object") return;
-    const event = data as Partial<LateStageMessageEvent>;
-    if (!Array.isArray(event.messages) || typeof event.batch !== "boolean") return;
-    // The workflow extension owns blocking asks to a completed stage so it can
-    // schedule a post-mortem turn in that exact retained conversation. Leaving
-    // the event unhandled here also makes listener registration order irrelevant.
-    if (isCompletedStageAskRoute(event)) return;
-    const tracker = getReplyTracker();
-    const accepted: LateStageMessage[] = [];
-    const reservations: LateStageReservation[] = [];
-    const joined: Promise<void>[] = [];
-    let queuedTurnContext = false;
-    for (const message of event.messages) {
-      if (message.customType !== "intercom_message") { accepted.push(message); continue; }
-      const entry = message.details as InboundMessageEntry | undefined;
-      if (!entry?.from || !entry.message) continue;
-      if (entry.channel !== "supervisor"
-        && !isSubagentRelayHandoff(entry)
-        && normalizeGroup(entry.from.group) !== normalizeGroup(getOwnerGroup())) continue;
-      const result = admission.admit(entry.from, entry.message);
-      if (result.kind === "pending") { joined.push(result.completion); continue; }
-      if (result.kind === "duplicate") continue;
-      const context = tracker.recordIncomingMessage(entry.from, entry.message);
-      if (!queuedTurnContext && event.options?.triggerTurn === true) {
-        tracker.queueTurnContext(context);
-        queuedTurnContext = true;
-      }
-      reservations.push({ message, reservation: result.reservation, context });
-      accepted.push(message);
-    }
-    event.handled = true;
-    const ownedCompletion = event.batch && typeof pi.sendMessages === "function"
-      ? deliverAtomicBatch(pi, accepted, event, reservations, admission, tracker)
-      : deliverSequentially(pi, accepted, event, reservations, admission, tracker);
-    event.completion = Promise.all([ownedCompletion, ...joined]).then(() => {});
-    return event.completion;
-  });
-}
-
-function isCompletedStageAskRoute(event: Partial<LateStageMessageEvent>): boolean {
-  return typeof event.workflowRunId === "string"
-    && typeof event.workflowStageId === "string"
-    && event.messages?.length !== 0
-    && event.messages?.every((message) => {
-      if (message.customType !== "intercom_message") return false;
-      const entry = message.details as InboundMessageEntry | undefined;
-      return entry?.message.expectsReply === true;
-    }) === true;
-}
-
-function deliverAtomicBatch(
-  pi: ExtensionAPI,
-  accepted: LateStageMessage[],
-  event: Partial<LateStageMessageEvent>,
-  reservations: LateStageReservation[],
-  admission: InboundMessageAdmission,
-  tracker: ReplyTracker,
-): Promise<void> {
-  if (accepted.length === 0) return Promise.resolve();
-  for (const { reservation } of reservations) admission.beginDelivery(reservation);
-  let delivery: Promise<void>;
-  try {
-    delivery = Promise.resolve(pi.sendMessages(accepted, event.options as Parameters<ExtensionAPI["sendMessages"]>[1]));
-  } catch (error) {
-    delivery = Promise.reject(error);
-  }
-  for (const { reservation } of reservations) admission.endDelivery(reservation);
-  return delivery.then(
-    () => { for (const { reservation } of reservations) admission.commit(reservation); },
-    (error: Error) => { releaseReservations(reservations, admission, tracker, error); throw error; },
-  );
-}
-
-async function deliverSequentially(
-  pi: ExtensionAPI,
-  accepted: LateStageMessage[],
-  event: Partial<LateStageMessageEvent>,
-  reservations: LateStageReservation[],
-  admission: InboundMessageAdmission,
-  tracker: ReplyTracker,
-): Promise<void> {
-  const pending = new Map(reservations.map((owned) => [owned.message, owned]));
-  for (let index = 0; index < accepted.length; index += 1) {
-    const message = accepted[index]!;
-    const owned = pending.get(message);
-    if (owned) admission.beginDelivery(owned.reservation);
-    try {
-      await pi.sendMessage(message, index === 0 ? event.options : { deliverAs: "followUp" });
-    } catch (error) {
-      if (owned) admission.endDelivery(owned.reservation);
-      const failure = error instanceof Error ? error : new Error(String(error));
-      releaseReservations([...pending.values()], admission, tracker, failure);
-      throw failure;
-    }
-    if (owned) {
-      admission.endDelivery(owned.reservation);
-      admission.commit(owned.reservation);
-      pending.delete(message);
-    }
-  }
-}
-
-function releaseReservations(
-  reservations: LateStageReservation[],
-  admission: InboundMessageAdmission,
-  tracker: ReplyTracker,
-  error: Error,
-): void {
-  for (const { reservation, context } of reservations) {
-    admission.release(reservation, error);
-    tracker.forgetIncomingMessage(context);
-  }
-}

package/dist/builtin/intercom/lazy-heavy-proxy.ts

@@ -1,108 +0,0 @@
-import type {
-  AgentEndEvent, AgentStartEvent, ExtensionAPI, ExtensionContext, ExtensionHandler,
-  MessageRenderer, ModelSelectEvent, RegisteredCommand, SessionShutdownEvent,
-  SessionStartEvent, ToolDefinition, ToolExecutionEndEvent, ToolExecutionStartEvent,
-  TurnEndEvent, TurnStartEvent,
-} from "@bastani/atomic";
-
-type CapturedCommand = Omit<RegisteredCommand, "name" | "sourceInfo">;
-type CapturedShortcut = Parameters<ExtensionAPI["registerShortcut"]>[1];
-type EventHandler = Parameters<ExtensionAPI["events"]["on"]>[1];
-type EventPayload = Parameters<EventHandler>[0];
-const LIVE_EVENT_SUBSCRIPTIONS = new Set(["pi-intercom:detach-response"]);
-
-export type ToolRenderResultArgs = Parameters<NonNullable<ToolDefinition["renderResult"]>>;
-export type ForwardedEventMap = {
-  session_start: SessionStartEvent;
-  session_shutdown: SessionShutdownEvent;
-  turn_start: TurnStartEvent;
-  turn_end: TurnEndEvent;
-  agent_start: AgentStartEvent;
-  agent_end: AgentEndEvent;
-  tool_execution_start: ToolExecutionStartEvent;
-  tool_execution_end: ToolExecutionEndEvent;
-  model_select: ModelSelectEvent;
-};
-type LazyLifecycleEvent = keyof ForwardedEventMap;
-type ForwardedHandler<K extends LazyLifecycleEvent> = ExtensionHandler<ForwardedEventMap[K]>;
-type ForwardedHandlerMap = { [K in LazyLifecycleEvent]: ForwardedHandler<K>[] };
-type AnyForwardedHandler = { [K in LazyLifecycleEvent]: ForwardedHandler<K> }[LazyLifecycleEvent];
-
-export type CapturedHeavy = {
-  tools: Map<string, ToolDefinition>;
-  commands: Map<string, CapturedCommand>;
-  handlers: ForwardedHandlerMap;
-  shortcuts: Map<string, CapturedShortcut>;
-  eventHandlers: Map<string, EventHandler[]>;
-};
-
-export function createForwardedHandlerMap(): ForwardedHandlerMap {
-  return {
-    session_start: [], session_shutdown: [], turn_start: [], turn_end: [], agent_start: [],
-    agent_end: [], tool_execution_start: [], tool_execution_end: [], model_select: [],
-  };
-}
-
-function addHandler<K extends LazyLifecycleEvent>(captured: CapturedHeavy, event: K, handler: ForwardedHandler<K>): void {
-  captured.handlers[event].push(handler);
-}
-
-function captureForwardedHandler(captured: CapturedHeavy, event: LazyLifecycleEvent, handler: AnyForwardedHandler): void {
-  switch (event) {
-    case "session_start": addHandler(captured, event, handler as ForwardedHandler<"session_start">); return;
-    case "session_shutdown": addHandler(captured, event, handler as ForwardedHandler<"session_shutdown">); return;
-    case "turn_start": addHandler(captured, event, handler as ForwardedHandler<"turn_start">); return;
-    case "turn_end": addHandler(captured, event, handler as ForwardedHandler<"turn_end">); return;
-    case "agent_start": addHandler(captured, event, handler as ForwardedHandler<"agent_start">); return;
-    case "agent_end": addHandler(captured, event, handler as ForwardedHandler<"agent_end">); return;
-    case "tool_execution_start": addHandler(captured, event, handler as ForwardedHandler<"tool_execution_start">); return;
-    case "tool_execution_end": addHandler(captured, event, handler as ForwardedHandler<"tool_execution_end">); return;
-    case "model_select": addHandler(captured, event, handler as ForwardedHandler<"model_select">);
-  }
-}
-
-function addEventHandler(captured: CapturedHeavy, event: string, handler: EventHandler): void {
-  const handlers = captured.eventHandlers.get(event) ?? [];
-  handlers.push(handler);
-  captured.eventHandlers.set(event, handlers);
-}
-
-export async function dispatchHandlers<K extends LazyLifecycleEvent>(
-  captured: CapturedHeavy, eventName: K, event: ForwardedEventMap[K], ctx: ExtensionContext,
-): Promise<void> {
-  for (const handler of captured.handlers[eventName]) await handler(event, ctx);
-}
-
-export async function dispatchEventHandlers(captured: CapturedHeavy, eventName: string, payload: EventPayload): Promise<void> {
-  for (const handler of captured.eventHandlers.get(eventName) ?? []) await handler(payload);
-}
-
-export function createHeavyProxy(pi: ExtensionAPI, captured: CapturedHeavy): ExtensionAPI {
-  return new Proxy(pi, {
-    get(target, prop, receiver) {
-      if (prop === "registerTool") return (tool: ToolDefinition) => captured.tools.set(tool.name, tool);
-      if (prop === "registerCommand") return (name: string, options: CapturedCommand) => captured.commands.set(name, options);
-      if (prop === "on") return (event: LazyLifecycleEvent, handler: AnyForwardedHandler) => captureForwardedHandler(captured, event, handler);
-      if (prop === "registerShortcut") return (shortcut: string, options: CapturedShortcut) => captured.shortcuts.set(shortcut, options);
-      if (prop === "registerMessageRenderer") return (customType: string, renderer: MessageRenderer) => pi.registerMessageRenderer(customType, renderer);
-      if (prop === "events") {
-        return new Proxy(pi.events, {
-          get(eventTarget, eventProp, eventReceiver) {
-            if (eventProp === "on") {
-              return (event: string, handler: EventHandler) => {
-                if (LIVE_EVENT_SUBSCRIPTIONS.has(event)) return pi.events.on(event, handler);
-                addEventHandler(captured, event, handler);
-                return () => {
-                  const handlers = captured.eventHandlers.get(event) ?? [];
-                  captured.eventHandlers.set(event, handlers.filter((candidate) => candidate !== handler));
-                };
-              };
-            }
-            return Reflect.get(eventTarget, eventProp, eventReceiver);
-          },
-        });
-      }
-      return Reflect.get(target, prop, receiver);
-    },
-  }) as ExtensionAPI;
-}