@seed-app-studio/protocol 0.1.1-canary.0

package/dist/index.d.mts

@@ -0,0 +1,1597 @@
+//#region src/manifest.d.ts
+type SeedAppKind = "vertical-app";
+type SeedAppEntry = {
+  type: "iframe" | "webcontents";
+  url: string;
+};
+type SeedAppRouteContribution = {
+  path: string;
+  title: string;
+};
+type SeedAppResourceOpenerContribution = {
+  resourceType: string;
+  route: string;
+};
+type SeedAppLauncherContribution = {
+  label: string;
+  icon?: string;
+  order?: number;
+};
+type SeedAppContributions = {
+  launcher?: SeedAppLauncherContribution;
+  routes?: SeedAppRouteContribution[];
+  resourceOpeners?: SeedAppResourceOpenerContribution[];
+  conversationPanels?: Array<{
+    id: string;
+    title: string;
+  }>;
+};
+type SeedAppRuntime = {
+  sdkVersion: string;
+  framework: "react" | "vanilla" | string;
+};
+type SeedAppCapabilities = Record<string, string[]>;
+type SeedAppPermissions = {
+  network?: {
+    allowedDomains?: string[];
+  };
+  memoryScopes?: string[];
+  mcpServers?: string[];
+  sensitiveActionsRequireApproval?: boolean;
+};
+type SeedAppGrantPolicy = "enabled" | "ask" | "disabled";
+type SeedAppBundleSummary = {
+  format: "static-spa" | string;
+  entryHtml: string;
+  integrity?: string;
+  checksum?: string;
+};
+type SeedAppManifest = {
+  schemaVersion: 1;
+  id: string;
+  version: string;
+  name: string;
+  description?: string;
+  kind: SeedAppKind;
+  entry: SeedAppEntry;
+  contributes?: SeedAppContributions;
+  runtime: SeedAppRuntime;
+  capabilities: SeedAppCapabilities;
+  permissions?: SeedAppPermissions;
+  grantDefaults?: Record<string, SeedAppGrantPolicy>;
+  userConfigurable?: Record<string, boolean>;
+  tenantPolicy?: {
+    installScope?: "user" | "team" | "tenant";
+    dataResidency?: "inherit" | string;
+  };
+  bundle?: SeedAppBundleSummary;
+};
+type SeedAppBundleAsset = {
+  path: string;
+  sha256: string;
+  size: number;
+  contentType: string;
+};
+type SeedAppBundleManifest = {
+  format: "static-spa" | string;
+  entryHtml: string;
+  baseUrl: string;
+  assets: SeedAppBundleAsset[];
+  integrity?: string;
+  signature?: string | null;
+};
+type SeedAppValidationIssue = {
+  path: string;
+  message: string;
+};
+type SeedAppValidationResult<T> = {
+  success: true;
+  data: T;
+  errors: [];
+} | {
+  success: false;
+  errors: SeedAppValidationIssue[];
+};
+declare function validateSeedAppManifest(input: unknown): SeedAppValidationResult<SeedAppManifest>;
+declare function validateSeedAppBundleManifest(input: unknown): SeedAppValidationResult<SeedAppBundleManifest>;
+//#endregion
+//#region src/constants.d.ts
+declare const SEED_BRIDGE_SCHEMA_VERSION: "seed.jsonrpc.v1";
+declare const SEED_BRIDGE_ELECTRON_IPC_CHANNEL: "seed-bridge-adapter";
+declare const SEED_APP_HOST_EVENT_NAMES: {
+  readonly hostReady: "host.ready";
+  readonly hostThemeChanged: "host.theme.changed";
+  readonly agentStream: "seed.agent.stream";
+  readonly aguiStream: "seed.agui.stream";
+  readonly backgroundStream: "seed.background.stream";
+  readonly agentApprovalChanged: "seed.agent.approval.changed";
+  readonly conversationChanged: "seed.conversation.changed";
+  readonly remotePcPresenceChanged: "seed.remotePc.presence.changed";
+  readonly employeeChanged: "seed.employee.changed";
+  readonly employeeMemoryEventsChanged: "seed.employee.memory.events.changed";
+  readonly roleTemplateChanged: "seed.roleTemplate.changed";
+  readonly roleMakerSessionChanged: "seed.roleMaker.session.changed";
+  readonly teamChanged: "seed.team.changed";
+  readonly teamAgentSpawned: "seed.team.agent.spawned";
+  readonly teamAgentRemoved: "seed.team.agent.removed";
+  readonly teamAgentRenamed: "seed.team.agent.renamed";
+  readonly teamAgentStatusChanged: "seed.team.agent.statusChanged";
+  readonly workspaceChanged: "seed.workspace.changed";
+};
+declare const SEED_APP_HOST_EVENT_NAME_LIST: readonly ["host.ready", "host.theme.changed", "seed.agent.stream", "seed.agui.stream", "seed.background.stream", "seed.agent.approval.changed", "seed.conversation.changed", "seed.remotePc.presence.changed", "seed.employee.changed", "seed.employee.memory.events.changed", "seed.team.changed", "seed.team.agent.statusChanged", "seed.team.agent.spawned", "seed.team.agent.removed", "seed.team.agent.renamed", "seed.roleTemplate.changed", "seed.roleMaker.session.changed", "seed.workspace.changed"];
+declare const SEED_AGENT_STREAM_EVENT_NAMES: {
+  readonly runStarted: "agent.run.started";
+  readonly runCompleted: "agent.run.completed";
+  readonly runFailed: "agent.run.failed";
+  readonly runCancelled: "agent.run.cancelled";
+  readonly inputSteer: "agent.input.steer";
+  readonly inputCollect: "agent.input.collect";
+  readonly inputFollowup: "agent.input.followup";
+  readonly inputSide: "agent.input.side";
+  readonly messageDelta: "agent.message.delta";
+  readonly thoughtDelta: "agent.thought.delta";
+  readonly toolStarted: "agent.tool.started";
+  readonly toolUpdated: "agent.tool.updated";
+  readonly planUpdated: "agent.plan.updated";
+  readonly goalUpdated: "agent.goal.updated";
+  readonly commandsUpdated: "agent.commands.updated";
+  readonly modeUpdated: "agent.mode.updated";
+  readonly configUpdated: "agent.config.updated";
+  readonly contextUsageUpdated: "agent.context.usage.updated";
+  readonly sessionInfoUpdated: "agent.session.info.updated";
+  readonly audioTranscriptUpdated: "agent.audio.transcript.updated";
+  readonly artifactCreated: "agent.artifact.created";
+  readonly connectionDegraded: "agent.connection.degraded";
+  readonly turnCompleted: "agent.turn.completed";
+  readonly userConfirmed: "agent.user.confirmed";
+  readonly userDelta: "agent.user.delta";
+  readonly permissionRequired: "agent.permission.required";
+  readonly elicitationRequired: "agent.elicitation.required";
+  readonly backgroundOutput: "agent.background.output";
+  readonly subagentAnchor: "agent.subagent.anchor";
+  readonly subagentMessageDelta: "agent.subagent.message.delta";
+  readonly subagentStatusUpdated: "agent.subagent.status.updated";
+};
+declare const SEED_AGENT_STREAM_EVENT_NAME_LIST: readonly ["agent.run.started", "agent.run.completed", "agent.run.failed", "agent.run.cancelled", "agent.input.steer", "agent.input.collect", "agent.input.followup", "agent.input.side", "agent.message.delta", "agent.thought.delta", "agent.tool.started", "agent.tool.updated", "agent.plan.updated", "agent.goal.updated", "agent.commands.updated", "agent.mode.updated", "agent.config.updated", "agent.context.usage.updated", "agent.session.info.updated", "agent.audio.transcript.updated", "agent.artifact.created", "agent.connection.degraded", "agent.turn.completed", "agent.user.confirmed", "agent.user.delta", "agent.permission.required", "agent.elicitation.required", "agent.background.output", "agent.subagent.anchor", "agent.subagent.message.delta", "agent.subagent.status.updated"];
+declare const SEED_BACKGROUND_STREAM_EVENT_NAMES: {
+  readonly taskOutput: "background.task.output";
+};
+declare const SEED_BACKGROUND_STREAM_EVENT_NAME_LIST: readonly ["background.task.output"];
+declare const SEED_AGUI_STREAM_EVENT_NAMES: {
+  readonly runStarted: "RUN_STARTED";
+  readonly runFinished: "RUN_FINISHED";
+  readonly runError: "RUN_ERROR";
+  readonly textMessageStart: "TEXT_MESSAGE_START";
+  readonly textMessageContent: "TEXT_MESSAGE_CONTENT";
+  readonly textMessageEnd: "TEXT_MESSAGE_END";
+  readonly toolCallStart: "TOOL_CALL_START";
+  readonly toolCallArgs: "TOOL_CALL_ARGS";
+  readonly toolCallEnd: "TOOL_CALL_END";
+  readonly toolCallResult: "TOOL_CALL_RESULT";
+  readonly stateDelta: "STATE_DELTA";
+  readonly custom: "CUSTOM";
+};
+declare const SEED_AGUI_STREAM_EVENT_NAME_LIST: readonly ["RUN_STARTED", "RUN_FINISHED", "RUN_ERROR", "TEXT_MESSAGE_START", "TEXT_MESSAGE_CONTENT", "TEXT_MESSAGE_END", "TOOL_CALL_START", "TOOL_CALL_ARGS", "TOOL_CALL_END", "TOOL_CALL_RESULT", "STATE_DELTA", "CUSTOM"];
+declare const SEED_BRIDGE_EVENT_CATALOG: readonly [{
+  readonly id: "app-host";
+  readonly owner: "app-host.runtime";
+  readonly purpose: "Host-level event contracts visible through the Seed Bridge envelope.";
+  readonly events: readonly ["host.ready", "host.theme.changed", "seed.agent.stream", "seed.agui.stream", "seed.background.stream", "seed.agent.approval.changed", "seed.conversation.changed", "seed.remotePc.presence.changed", "seed.employee.changed", "seed.employee.memory.events.changed", "seed.team.changed", "seed.team.agent.statusChanged", "seed.team.agent.spawned", "seed.team.agent.removed", "seed.team.agent.renamed", "seed.roleTemplate.changed", "seed.roleMaker.session.changed", "seed.workspace.changed"];
+}, {
+  readonly id: "agent-stream";
+  readonly owner: "app-host.agent";
+  readonly purpose: "ACP-aligned agent lifecycle and replay events carried by seed.agent.stream.";
+  readonly events: readonly ["agent.run.started", "agent.run.completed", "agent.run.failed", "agent.run.cancelled", "agent.input.steer", "agent.input.collect", "agent.input.followup", "agent.input.side", "agent.message.delta", "agent.thought.delta", "agent.tool.started", "agent.tool.updated", "agent.plan.updated", "agent.goal.updated", "agent.commands.updated", "agent.mode.updated", "agent.config.updated", "agent.context.usage.updated", "agent.session.info.updated", "agent.audio.transcript.updated", "agent.artifact.created", "agent.connection.degraded", "agent.turn.completed", "agent.user.confirmed", "agent.user.delta", "agent.permission.required", "agent.elicitation.required", "agent.background.output", "agent.subagent.anchor", "agent.subagent.message.delta", "agent.subagent.status.updated"];
+}, {
+  readonly id: "agui-stream";
+  readonly owner: "app-host.agui";
+  readonly purpose: "AGUI run lifecycle and form events carried by seed.agui.stream.";
+  readonly events: readonly ["RUN_STARTED", "RUN_FINISHED", "RUN_ERROR", "TEXT_MESSAGE_START", "TEXT_MESSAGE_CONTENT", "TEXT_MESSAGE_END", "TOOL_CALL_START", "TOOL_CALL_ARGS", "TOOL_CALL_END", "TOOL_CALL_RESULT", "STATE_DELTA", "CUSTOM"];
+}, {
+  readonly id: "background-stream";
+  readonly owner: "app-host.agent";
+  readonly purpose: "Background task lifecycle and output events carried by seed.background.stream.";
+  readonly events: readonly ["background.task.output"];
+}];
+type SeedBridgeSchemaVersion = typeof SEED_BRIDGE_SCHEMA_VERSION;
+//#endregion
+//#region src/workspaceContracts.d.ts
+declare const workspaceBridgeMethodSpecs: readonly SeedBridgeMethodSpec[];
+//#endregion
+//#region src/routeMetadata.d.ts
+declare const SEED_BRIDGE_ROUTE_IMPLEMENTATIONS: readonly ["bridge-provider", "conversation-runtime", "electron-local", "electron-runner"];
+type SeedBridgeRouteImplementation = (typeof SEED_BRIDGE_ROUTE_IMPLEMENTATIONS)[number];
+declare const SEED_BRIDGE_ROUTE_COMMAND_TRANSPORTS: readonly ["seed-jsonrpc", "conversation-command", "electron-ipc", "dual-channel"];
+type SeedBridgeRouteCommandTransport = (typeof SEED_BRIDGE_ROUTE_COMMAND_TRANSPORTS)[number];
+type SeedBridgeRouteEventSource = "bridge-provider" | "websocket-hub" | "conversation-runtime" | "electron-ipc" | "dual-channel";
+type SeedBridgeRouteAuthority = "server" | "host";
+type SeedBridgeAuditAuthority = SeedBridgeRouteAuthority;
+declare const SEED_CONVERSATION_AUTHORITY_KINDS: readonly ["cloud", "remote-pc"];
+type SeedCloudConversationAuthorityDescriptor = {
+  kind: "cloud";
+  cloudConversationId: string;
+};
+type SeedRemotePcConversationAuthorityDescriptor = {
+  kind: "remote-pc";
+  deviceId: string;
+  hostConversationId: string;
+};
+type SeedConversationAuthorityDescriptor = SeedCloudConversationAuthorityDescriptor | SeedRemotePcConversationAuthorityDescriptor;
+type SeedConversationAuthorityValidationCode = "invalid_authority_object" | "unsupported_authority_kind" | "cloud_conversation_id_required" | "remote_pc_identity_required" | "mixed_authority_identifiers";
+type SeedConversationAuthorityValidationResult = {
+  ok: true;
+  value: SeedConversationAuthorityDescriptor;
+} | {
+  ok: false;
+  code: SeedConversationAuthorityValidationCode;
+};
+declare function validateSeedConversationAuthorityDescriptor(value: unknown): SeedConversationAuthorityValidationResult;
+type SeedBridgeRouteFallback = "none" | "legacy-provider";
+type SeedBridgeMethodRuntimeRoute = {
+  method: string;
+  capability: string;
+  implementation: SeedBridgeRouteImplementation;
+  commandTransport: SeedBridgeRouteCommandTransport;
+  eventType?: string;
+  eventSource?: SeedBridgeRouteEventSource;
+  routeAuthority: SeedBridgeRouteAuthority;
+  auditAuthority: SeedBridgeAuditAuthority;
+  fallback: SeedBridgeRouteFallback;
+};
+type SeedBridgeAgentRuntimeRouteMethod = "seed.agent.run" | "seed.agent.stop" | "seed.agent.approval.respond" | "seed.agent.elicitation.respond" | "seed.event.subscribe" | "seed.event.unsubscribe";
+declare const seedBridgeMethodRuntimeRoutes: readonly SeedBridgeMethodRuntimeRoute[];
+declare function getSeedBridgeRouteMetadataForMethod(method: string): SeedBridgeMethodRuntimeRoute | undefined;
+declare function listSeedBridgeRouteMetadata(): SeedBridgeMethodRuntimeRoute[];
+declare function listSeedBridgeRouteMetadataForCapability(capability: string): SeedBridgeMethodRuntimeRoute[];
+//#endregion
+//#region src/acp/reasoningConfig.d.ts
+type RuntimeReasoningEffort = "minimal" | "low" | "medium" | "high";
+type RuntimeReasoningConfig = {
+  enabled?: boolean;
+  effort?: RuntimeReasoningEffort;
+  budgetTokens?: number;
+};
+type RuntimeReasoningConfigOption = {
+  id: string;
+  name?: string;
+  label?: string;
+  description?: string;
+  category?: string;
+  type?: string;
+  currentValue?: string | boolean;
+  selectedValue?: string | boolean;
+  options?: Array<{
+    value?: string;
+    id?: string;
+    name?: string;
+    label?: string;
+    description?: string;
+  }>;
+};
+type RuntimeReasoningConfigOptionUpdate = {
+  configId: string;
+  value: string | boolean;
+  reason: "enabled" | "disabled" | "effort" | "budget";
+  offUnsupported?: boolean;
+};
+type RuntimeReasoningConfigOptionResolution = {
+  updates: RuntimeReasoningConfigOptionUpdate[];
+  diagnostics: Array<{
+    code: "reasoning_unsupported" | "reasoning_off_unsupported" | "reasoning_effort_unsupported";
+    requested?: RuntimeReasoningConfig;
+    fallback?: RuntimeReasoningConfigOptionUpdate;
+  }>;
+};
+declare function normalizeRuntimeReasoningConfig(input: unknown): RuntimeReasoningConfig | undefined;
+declare function normalizeRuntimeConfigReasoning(input: Record<string, unknown> | undefined): Record<string, unknown> | undefined;
+declare function isRuntimeReasoningConfigOption(option: RuntimeReasoningConfigOption): boolean;
+declare function resolveRuntimeReasoningConfigOptions(options: readonly RuntimeReasoningConfigOption[] | undefined, config: RuntimeReasoningConfig | undefined): RuntimeReasoningConfigOptionResolution;
+//#endregion
+//#region src/jsonRpc.d.ts
+/**
+ * JSON-RPC 2.0 frame creation, parsing, validation, and serialization.
+ *
+ * This module replaces the legacy SeedBridgeRequest / SeedBridgeResult / SeedBridgeEvent
+ * envelope system. All cross-runtime communication MUST use JSON-RPC 2.0 frames.
+ */
+declare const JSONRPC_VERSION: "2.0";
+type JsonRpcId = string | number;
+type JsonRpcRequest = {
+  jsonrpc: typeof JSONRPC_VERSION;
+  id: JsonRpcId;
+  method: string;
+  params?: Record<string, unknown>;
+};
+type JsonRpcResponse = {
+  jsonrpc: typeof JSONRPC_VERSION;
+  id: JsonRpcId;
+  result: unknown;
+};
+type JsonRpcErrorObject = {
+  code: number;
+  message: string;
+  data?: unknown;
+};
+type JsonRpcErrorResponse = {
+  jsonrpc: typeof JSONRPC_VERSION;
+  id: JsonRpcId | null;
+  error: JsonRpcErrorObject;
+};
+type JsonRpcNotification = {
+  jsonrpc: typeof JSONRPC_VERSION;
+  method: string;
+  params?: Record<string, unknown>;
+};
+type JsonRpcFrame = JsonRpcRequest | JsonRpcResponse | JsonRpcErrorResponse | JsonRpcNotification;
+type ParsedJsonRpcFrame = {
+  type: "request";
+  id: JsonRpcId;
+  method: string;
+  params: Record<string, unknown> | undefined;
+} | {
+  type: "response";
+  id: JsonRpcId;
+  result: unknown;
+} | {
+  type: "error";
+  id: JsonRpcId | null;
+  error: JsonRpcErrorObject;
+} | {
+  type: "notification";
+  method: string;
+  params: Record<string, unknown> | undefined;
+};
+declare const JSON_RPC_ERROR_CODES: {
+  readonly PARSE_ERROR: -32700;
+  readonly INVALID_REQUEST: -32600;
+  readonly METHOD_NOT_FOUND: -32601;
+  readonly INVALID_PARAMS: -32602;
+  readonly INTERNAL_ERROR: -32603;
+};
+declare function createJsonRpcRequest(method: string, id: JsonRpcId, params?: Record<string, unknown>): JsonRpcRequest;
+declare function createJsonRpcResponse(id: JsonRpcId, result: unknown): JsonRpcResponse;
+declare function createJsonRpcError(id: JsonRpcId | null, code: number, message: string, data?: unknown): JsonRpcErrorResponse;
+declare function createJsonRpcNotification(method: string, params?: Record<string, unknown>): JsonRpcNotification;
+declare function parseJsonRpcFrame(value: unknown): ParsedJsonRpcFrame | undefined;
+type JsonRpcValidationResult = {
+  valid: true;
+} | {
+  valid: false;
+  error: JsonRpcErrorObject;
+};
+declare function validateJsonRpcRequest(frame: unknown): JsonRpcValidationResult;
+declare function serializeJsonRpcFrame(frame: JsonRpcFrame): string;
+declare function deserializeJsonRpcFrame(value: string): ParsedJsonRpcFrame | undefined;
+//#endregion
+//#region src/events.d.ts
+declare const SEED_BACKGROUND_STREAM_EVENT_TYPE: "seed.background.stream";
+declare const SEED_AGUI_STREAM_EVENT_TYPE: "seed.agui.stream";
+declare const seedBackgroundStreamEventTypes: readonly ["background.task.output"];
+type SeedBackgroundStreamEventType = (typeof seedBackgroundStreamEventTypes)[number];
+declare const CANONICAL_EVENT_TYPES: {
+  readonly AGENT_RUN_STARTED: "agent.run.started";
+  readonly AGENT_RUN_COMPLETED: "agent.run.completed";
+  readonly AGENT_RUN_FAILED: "agent.run.failed";
+  readonly AGENT_RUN_CANCELLED: "agent.run.cancelled";
+  readonly AGENT_MESSAGE_DELTA: "agent.message.delta";
+  readonly AGENT_THOUGHT_DELTA: "agent.thought.delta";
+  readonly AGENT_TOOL_STARTED: "agent.tool.started";
+  readonly AGENT_TOOL_UPDATED: "agent.tool.updated";
+  readonly AGENT_TURN_COMPLETED: "agent.turn.completed";
+  readonly AGENT_PERMISSION_REQUIRED: "agent.permission.required";
+  readonly AGENT_ELICITATION_REQUIRED: "agent.elicitation.required";
+  readonly AGENT_USER_CONFIRMED: "agent.user.confirmed";
+  readonly AGENT_USER_DELTA: "agent.user.delta";
+  readonly AGENT_INPUT_STEER: "agent.input.steer";
+  readonly AGENT_INPUT_COLLECT: "agent.input.collect";
+  readonly AGENT_INPUT_FOLLOWUP: "agent.input.followup";
+  readonly AGENT_INPUT_SIDE: "agent.input.side";
+  readonly AGENT_PLAN_UPDATED: "agent.plan.updated";
+  readonly AGENT_BACKGROUND_OUTPUT: "agent.background.output";
+  readonly BACKGROUND_TASK_OUTPUT: "background.task.output";
+  readonly AGENT_SUBAGENT_ANCHOR: "agent.subagent.anchor";
+  readonly AGENT_SUBAGENT_MESSAGE_DELTA: "agent.subagent.message.delta";
+  readonly AGENT_SUBAGENT_STATUS_UPDATED: "agent.subagent.status.updated";
+  readonly SEED_AGENT_STREAM: "seed.agent.stream";
+  readonly SEED_AGUI_STREAM: "seed.agui.stream";
+  readonly SEED_BACKGROUND_STREAM: "seed.background.stream";
+  readonly SEED_AGENT_APPROVAL_CHANGED: "seed.agent.approval.changed";
+  readonly SEED_CONVERSATION_CHANGED: "seed.conversation.changed";
+  readonly SEED_REMOTE_PC_PRESENCE_CHANGED: "seed.remotePc.presence.changed";
+  readonly SEED_EMPLOYEE_CHANGED: "seed.employee.changed";
+  readonly SEED_EMPLOYEE_MEMORY_EVENTS_CHANGED: "seed.employee.memory.events.changed";
+  readonly SEED_ROLE_TEMPLATE_CHANGED: "seed.roleTemplate.changed";
+  readonly SEED_ROLE_MAKER_SESSION_CHANGED: "seed.roleMaker.session.changed";
+  readonly SEED_TEAM_CHANGED: "seed.team.changed";
+  readonly SEED_TEAM_AGENT_SPAWNED: "seed.team.agent.spawned";
+  readonly SEED_TEAM_AGENT_REMOVED: "seed.team.agent.removed";
+  readonly SEED_TEAM_AGENT_RENAMED: "seed.team.agent.renamed";
+  readonly SEED_TEAM_AGENT_STATUS_CHANGED: "seed.team.agent.statusChanged";
+  readonly SEED_WORKSPACE_CHANGED: "seed.workspace.changed";
+  readonly BRIDGE_ERROR: "jsonrpc.error";
+};
+type CanonicalEventType = (typeof CANONICAL_EVENT_TYPES)[keyof typeof CANONICAL_EVENT_TYPES];
+type AgentMessageDeltaPayload = {
+  conversationId: string;
+  runId: string;
+  content: string;
+  role: "assistant";
+};
+type AgentThoughtDeltaPayload = {
+  conversationId: string;
+  runId: string;
+  content: string;
+};
+type AgentToolStartedPayload = {
+  conversationId: string;
+  runId: string;
+  toolName: string;
+  toolInput?: unknown;
+};
+type AgentToolUpdatedPayload = {
+  conversationId: string;
+  runId: string;
+  toolName: string;
+  output?: unknown;
+  status?: "running" | "completed" | "failed";
+};
+type AgentPermissionRequiredPayload = {
+  conversationId: string;
+  runId: string;
+  toolName: string;
+  toolInput?: unknown;
+};
+type AgentElicitationRequiredPayload = {
+  conversationId: string;
+  runId: string;
+  question: string;
+  options?: string[];
+};
+type AgentTurnCompletedPayload = {
+  conversationId: string;
+  runId: string;
+  stopReason: string;
+  status: "completed" | "failed" | "cancelled";
+};
+type AgentRunStartedPayload = {
+  conversationId: string;
+  runId: string;
+};
+type AgentRunCompletedPayload = {
+  conversationId: string;
+  runId: string;
+};
+type AgentRunFailedPayload = {
+  conversationId: string;
+  runId: string;
+  error?: string;
+};
+type AgentRunCancelledPayload = {
+  conversationId: string;
+  runId: string;
+};
+type AgentRuntimeEventPayload = {
+  conversationId: string;
+  runId: string;
+  type: string;
+  payload: unknown;
+  source?: string;
+  reason?: string;
+};
+type CanonicalEventPayload = AgentMessageDeltaPayload | AgentThoughtDeltaPayload | AgentToolStartedPayload | AgentToolUpdatedPayload | AgentPermissionRequiredPayload | AgentElicitationRequiredPayload | AgentTurnCompletedPayload | AgentRunStartedPayload | AgentRunCompletedPayload | AgentRunFailedPayload | AgentRunCancelledPayload | AgentRuntimeEventPayload | Record<string, unknown>;
+type CanonicalEventMeta = {
+  traceId: string;
+  eventId: string;
+  cursor?: string;
+  seq?: number;
+  tenantId?: string;
+  userId?: string;
+  appId?: string;
+  conversationId?: string;
+  runId?: string;
+  projection?: SeedEventProjectionTrace;
+};
+declare const SEED_EVENT_NOTIFICATION_METHOD: "seed.event";
+type SeedEventProjectionTrace = {
+  source: "acp";
+  type: string;
+  direction?: string;
+  entryId?: string;
+  sessionId?: string;
+  conversationId?: string;
+  timestamp?: number;
+  payload?: unknown;
+};
+type SeedEventAcpProjectionTraceInput = {
+  type: string;
+  direction?: string;
+  entryId?: string;
+  sessionId?: string;
+  conversationId?: string;
+  timestamp?: number;
+  payload?: unknown;
+  includePayload?: boolean;
+};
+type SeedEventClientEvent = Record<string, unknown> & {
+  type: string;
+  payload?: unknown;
+  status?: string;
+  timestamp?: number;
+};
+type SeedBackgroundStreamEvent = SeedEventClientEvent & {
+  type: SeedBackgroundStreamEventType;
+};
+type SeedEventTransportMeta = Partial<CanonicalEventMeta> & Record<string, unknown> & {
+  projection?: SeedEventProjectionTrace;
+};
+type SeedEventTransportParams = {
+  type: string;
+  runtime?: string;
+  payload?: unknown;
+  meta?: SeedEventTransportMeta;
+};
+type SeedEventAcpInspectorProjection = {
+  streamEvent: SeedEventClientEvent;
+  trace?: SeedEventProjectionTrace;
+  acp?: {
+    type: string;
+    direction?: string;
+    entryId?: string;
+    sessionId?: string;
+    conversationId?: string;
+    timestamp?: number;
+    payload?: unknown;
+  };
+  lossless: boolean;
+  reason?: "missing_projection_trace" | "missing_projection_payload";
+};
+type SeedEventNotificationParams = {
+  type: CanonicalEventType;
+  runtime: string;
+  payload?: CanonicalEventPayload;
+  meta: CanonicalEventMeta;
+};
+type CanonicalEventValidationResult = {
+  valid: true;
+} | {
+  valid: false;
+  reason: string;
+};
+declare function validateCanonicalEvent(eventType: string, payload?: unknown): CanonicalEventValidationResult;
+declare function isSeedBackgroundStreamEvent(event: unknown): event is SeedBackgroundStreamEvent;
+declare function validateCanonicalEventMeta(meta: unknown): CanonicalEventValidationResult;
+declare function createSeedEventNotification(params: SeedEventNotificationParams): JsonRpcNotification;
+declare function readSeedEventTransportParams(params: Record<string, unknown> | undefined): SeedEventTransportParams | undefined;
+declare function projectSeedEventFrameToClientEvent(frame: ParsedJsonRpcFrame): SeedEventClientEvent | undefined;
+declare function projectSeedEventParamsToClientEvent(params: Record<string, unknown> | undefined): SeedEventClientEvent | undefined;
+declare function createSeedEventAcpProjectionTrace(input: SeedEventAcpProjectionTraceInput): SeedEventProjectionTrace;
+declare function readSeedEventProjectionTrace(params: Record<string, unknown> | undefined): SeedEventProjectionTrace | undefined;
+declare function projectSeedClientEventToAcpInspectorProjection(streamEvent: SeedEventClientEvent, params?: Record<string, unknown>): SeedEventAcpInspectorProjection;
+//#endregion
+//#region src/electronIpc.d.ts
+type JsonRpcElectronIpcAdapterContract = {
+  channel?: string;
+  transportId?: SeedBridgeTransportId;
+  authBoundary?: SeedBridgeAuthBoundary;
+  supportsStreaming?: boolean;
+  supportsBroadcast?: boolean;
+};
+type JsonRpcElectronIpcFrame = JsonRpcFrame;
+declare function serializeJsonRpcElectronIpcFrame(frame: JsonRpcElectronIpcFrame): string;
+declare function parseJsonRpcElectronIpcFrame(value: unknown): ParsedJsonRpcFrame | undefined;
+declare function validateJsonRpcElectronIpcAdapterContract(input?: JsonRpcElectronIpcAdapterContract): string[];
+//#endregion
+//#region src/localWebui.d.ts
+type JsonRpcLocalWebuiFrame = JsonRpcFrame;
+declare function serializeJsonRpcLocalWebuiFrame(frame: JsonRpcLocalWebuiFrame): string;
+declare function parseJsonRpcLocalWebuiFrame(value: unknown): ParsedJsonRpcFrame | undefined;
+//#endregion
+//#region src/controlGateway.d.ts
+declare const jsonRpcControlGatewayPayloadKinds: {
+  readonly request: "seed.bridge.jsonrpc.request";
+  readonly response: "seed.bridge.jsonrpc.response";
+  readonly notification: "seed.bridge.jsonrpc.notification";
+};
+type JsonRpcControlGatewayFrameType = "session.input" | "run.completed" | "run.event";
+type JsonRpcControlGatewayFrameContext = {
+  nodeId: string;
+  seq: number;
+  ts?: number;
+  tenantId?: string;
+  userId?: string;
+  id?: string;
+  traceId?: string;
+};
+type JsonRpcControlGatewayAdapterContract = {
+  transportId?: SeedBridgeTransportId;
+  authBoundary?: SeedBridgeAuthBoundary;
+  supportsStreaming?: boolean;
+  supportsBroadcast?: boolean;
+};
+type JsonRpcControlGatewayFrame<TType extends JsonRpcControlGatewayFrameType, TPayload> = {
+  type: TType;
+  id: string;
+  traceId: string;
+  tenantId: string;
+  userId: string;
+  nodeId: string;
+  seq: number;
+  ts: number;
+  payload: TPayload;
+};
+type JsonRpcControlGatewayRequestPayload = {
+  schemaVersion: typeof SEED_BRIDGE_SCHEMA_VERSION;
+  kind: typeof jsonRpcControlGatewayPayloadKinds.request;
+  frame: JsonRpcRequest;
+};
+type JsonRpcControlGatewayResponsePayload = {
+  schemaVersion: typeof SEED_BRIDGE_SCHEMA_VERSION;
+  kind: typeof jsonRpcControlGatewayPayloadKinds.response;
+  frame: JsonRpcResponse | JsonRpcErrorResponse;
+};
+type JsonRpcControlGatewayNotificationPayload = {
+  schemaVersion: typeof SEED_BRIDGE_SCHEMA_VERSION;
+  kind: typeof jsonRpcControlGatewayPayloadKinds.notification;
+  frame: JsonRpcNotification;
+};
+type JsonRpcControlGatewayRequestFrame = JsonRpcControlGatewayFrame<"session.input", JsonRpcControlGatewayRequestPayload>;
+type JsonRpcControlGatewayResponseFrame = JsonRpcControlGatewayFrame<"run.completed", JsonRpcControlGatewayResponsePayload>;
+type JsonRpcControlGatewayNotificationFrame = JsonRpcControlGatewayFrame<"run.event", JsonRpcControlGatewayNotificationPayload>;
+type JsonRpcControlGatewayFrameUnion = JsonRpcControlGatewayRequestFrame | JsonRpcControlGatewayResponseFrame | JsonRpcControlGatewayNotificationFrame;
+declare function createJsonRpcControlGatewayRequestFrame(request: JsonRpcRequest, context: JsonRpcControlGatewayFrameContext): JsonRpcControlGatewayRequestFrame;
+declare function createJsonRpcControlGatewayResponseFrame(response: JsonRpcResponse | JsonRpcErrorResponse, context: JsonRpcControlGatewayFrameContext & {
+  tenantId: string;
+  userId: string;
+  traceId: string;
+}): JsonRpcControlGatewayResponseFrame;
+declare function createJsonRpcControlGatewayNotificationFrame(notification: JsonRpcNotification, context: JsonRpcControlGatewayFrameContext & {
+  id: string;
+  traceId: string;
+}): JsonRpcControlGatewayNotificationFrame;
+declare function serializeJsonRpcControlGatewayFrame(frame: JsonRpcControlGatewayFrameUnion): string;
+declare function parseJsonRpcControlGatewayFrame(value: unknown): JsonRpcControlGatewayFrameUnion | undefined;
+declare function validateJsonRpcControlGatewayAdapterContract(input?: JsonRpcControlGatewayAdapterContract): string[];
+//#endregion
+//#region src/reactNative.d.ts
+type JsonRpcReactNativeWebViewPort = {
+  postMessage(message: string): void;
+};
+type JsonRpcReactNativeWebViewAdapter = {
+  postFrame<TFrame extends JsonRpcFrame>(frame: TFrame): TFrame;
+  postRequest(request: JsonRpcRequest): JsonRpcRequest;
+  postResponse(response: JsonRpcResponse | JsonRpcErrorResponse): JsonRpcResponse | JsonRpcErrorResponse;
+  postNotification(notification: JsonRpcNotification): JsonRpcNotification;
+  parseMessage(message: unknown): ParsedJsonRpcFrame | undefined;
+};
+type JsonRpcReactNativeWebViewAdapterOptions = {
+  port: JsonRpcReactNativeWebViewPort;
+  onInvalidFrame?(message: unknown): void;
+};
+type JsonRpcReactNativeFrame = JsonRpcFrame;
+declare function serializeJsonRpcReactNativeFrame(frame: JsonRpcReactNativeFrame): string;
+declare function parseJsonRpcReactNativeFrame(value: unknown): ParsedJsonRpcFrame | undefined;
+declare function createJsonRpcReactNativeWebViewAdapter(options: JsonRpcReactNativeWebViewAdapterOptions): JsonRpcReactNativeWebViewAdapter;
+//#endregion
+//#region src/transportContracts.d.ts
+type SeedBridgeRuntimeTransportContract = {
+  runtime: SeedBridgeRuntime;
+  primaryTransportId: SeedBridgeTransportId;
+  authBoundary: SeedBridgeAuthBoundary;
+  requestFrame: string;
+  responseFrame: string;
+  eventFrame: string;
+  supportsStreaming: boolean;
+  supportsBroadcast: boolean;
+};
+type SeedBridgeRuntimeTransportContractValidation = {
+  runtime: SeedBridgeRuntime;
+  transportId?: SeedBridgeTransportId;
+  authBoundary?: SeedBridgeAuthBoundary;
+  supportsStreaming?: boolean;
+  supportsBroadcast?: boolean;
+};
+type SeedBridgeRuntimeTransportVerificationCommand = {
+  command: string;
+  scope: "unit" | "browser-smoke" | "package-build" | "gateway-smoke";
+};
+type SeedBridgeRuntimeTransportVerification = {
+  runtime: SeedBridgeRuntime;
+  primaryTransportId: SeedBridgeTransportId;
+  authBoundary: SeedBridgeAuthBoundary;
+  adapterEntries: readonly string[];
+  verificationCommands: readonly SeedBridgeRuntimeTransportVerificationCommand[];
+  evidence: readonly string[];
+};
+type SeedBridgeRuntimeTransportDiagnosticsSummary = {
+  runtime: SeedBridgeRuntime;
+  transportId: SeedBridgeTransportId;
+  contractRole: "primary-runtime-transport";
+  endpointRole: "runtime-primary-endpoint";
+  protocolVersion: "JSON-RPC 2.0";
+  authBoundary: SeedBridgeAuthBoundary;
+  requestFrame: string;
+  responseFrame: string;
+  eventFrame: string;
+  supportsStreaming: boolean;
+  supportsBroadcast: boolean;
+  portHint?: number;
+  adapterEntries: readonly string[];
+  verificationCommands: readonly SeedBridgeRuntimeTransportVerificationCommand[];
+  evidence: readonly string[];
+};
+declare const seedBridgeRuntimeTransportContracts: readonly [{
+  readonly runtime: "electron";
+  readonly primaryTransportId: "electron-ipc";
+  readonly authBoundary: "preload-main";
+  readonly requestFrame: "JSON-RPC request";
+  readonly responseFrame: "JSON-RPC response | error";
+  readonly eventFrame: "JSON-RPC notification";
+  readonly supportsStreaming: true;
+  readonly supportsBroadcast: true;
+}, {
+  readonly runtime: "local-webui";
+  readonly primaryTransportId: "local-websocket";
+  readonly authBoundary: "local-session";
+  readonly requestFrame: "JSON-RPC request";
+  readonly responseFrame: "JSON-RPC response | error";
+  readonly eventFrame: "JSON-RPC notification";
+  readonly supportsStreaming: true;
+  readonly supportsBroadcast: true;
+}, {
+  readonly runtime: "web-saas";
+  readonly primaryTransportId: "web-saas-bridge-ws";
+  readonly authBoundary: "session-cookie";
+  readonly requestFrame: "JSON-RPC request";
+  readonly responseFrame: "JSON-RPC response | error";
+  readonly eventFrame: "JSON-RPC notification";
+  readonly supportsStreaming: true;
+  readonly supportsBroadcast: false;
+}, {
+  readonly runtime: "react-native";
+  readonly primaryTransportId: "react-native-webview";
+  readonly authBoundary: "manifest-capability";
+  readonly requestFrame: "JSON-RPC request";
+  readonly responseFrame: "JSON-RPC response | error";
+  readonly eventFrame: "JSON-RPC notification";
+  readonly supportsStreaming: true;
+  readonly supportsBroadcast: false;
+}, {
+  readonly runtime: "app-host";
+  readonly primaryTransportId: "app-host-postmessage";
+  readonly authBoundary: "manifest-capability";
+  readonly requestFrame: "SeedAppSdkEnvelope";
+  readonly responseFrame: "SeedAppHostEnvelope";
+  readonly eventFrame: "SeedAppHostEnvelope.event";
+  readonly supportsStreaming: false;
+  readonly supportsBroadcast: false;
+}];
+declare const seedBridgeRuntimeTransportVerificationMatrix: readonly [{
+  readonly runtime: "electron";
+  readonly primaryTransportId: "electron-ipc";
+  readonly authBoundary: "preload-main";
+  readonly adapterEntries: readonly ["packages/seed-runtime-state/bridge-protocol/src/electronIpc.ts", "apps/desktop/src/preload/main.ts", "apps/desktop/src/common/adapter/ipcBridge.ts"];
+  readonly verificationCommands: readonly [{
+    readonly command: "npm --prefix packages/seed-runtime-state/bridge-protocol test -- --run tests/electronIpc.test.ts";
+    readonly scope: "unit";
+  }, {
+    readonly command: "npm --prefix apps/desktop test -- --run tests/unit/adapterBrowserElectronTypedBridge.dom.test.ts";
+    readonly scope: "unit";
+  }, {
+    readonly command: "npm run smoke:electron-bridge-artifacts";
+    readonly scope: "package-build";
+  }, {
+    readonly command: "npm run smoke:electron-bridge-artifacts:fresh";
+    readonly scope: "package-build";
+  }, {
+    readonly command: "npm run smoke:electron-bridge-artifacts:launch";
+    readonly scope: "package-build";
+  }];
+  readonly evidence: readonly ["Electron IPC frames stay on the preload/main channel.", "Renderer callers send JSON-RPC frames through preload instead of importing Electron or Node APIs.", "Electron build artifacts preserve the preload/main JSON-RPC bridge channel and App Studio renderer route.", "Electron artifact freshness smoke fails when bridge or App Studio sources are newer than the packaged output.", "Electron launch smoke opens the built app and verifies the renderer preload bridge is exposed in a real BrowserWindow."];
+}, {
+  readonly runtime: "local-webui";
+  readonly primaryTransportId: "local-websocket";
+  readonly authBoundary: "local-session";
+  readonly adapterEntries: readonly ["packages/seed-runtime-state/bridge-protocol/src/localWebui.ts"];
+  readonly verificationCommands: readonly [{
+    readonly command: "npm --prefix packages/seed-runtime-state/bridge-protocol test -- --run tests/localWebui.test.ts";
+    readonly scope: "unit";
+  }];
+  readonly evidence: readonly ["Local WebUI exchanges JSON-RPC request, response, error, and notification frames."];
+}, {
+  readonly runtime: "web-saas";
+  readonly primaryTransportId: "web-saas-bridge-ws";
+  readonly authBoundary: "session-cookie";
+  readonly adapterEntries: readonly ["packages/seed-web-api/src/websocket/index.ts", "packages/seed-web-api/src/websocket/appBridgeProvider.ts", "packages/seed-runtime-state/bridge-protocol/src/controlGateway.ts", "packages/seed-web-api/src/service.ts", "control-gateway/src/server/ControlGatewayServer.ts"];
+  readonly verificationCommands: readonly [{
+    readonly command: "bun test packages/seed-web-api/tests/appBridgeProvider.bun.test.ts";
+    readonly scope: "unit";
+  }, {
+    readonly command: "npm --prefix packages/seed-runtime-state/bridge-protocol test -- --run tests/controlGateway.test.ts";
+    readonly scope: "unit";
+  }, {
+    readonly command: "bun test packages/seed-web-api/tests/realtimeProtocol.bun.test.ts";
+    readonly scope: "gateway-smoke";
+  }, {
+    readonly command: "bun test control-gateway/src/server/managementDashboard.bun.test.ts";
+    readonly scope: "gateway-smoke";
+  }, {
+    readonly command: "npm run smoke:web-gateway-process";
+    readonly scope: "gateway-smoke";
+  }];
+  readonly evidence: readonly ["SaaS browser calls enter through /v1/ws JSON-RPC before any downstream runner dispatch.", "Control Gateway frames wrap JSON-RPC evidence and carry tenant/user metadata without Electron IPC assumptions."];
+}, {
+  readonly runtime: "react-native";
+  readonly primaryTransportId: "react-native-webview";
+  readonly authBoundary: "manifest-capability";
+  readonly adapterEntries: readonly ["packages/seed-runtime-state/bridge-protocol/src/reactNative.ts"];
+  readonly verificationCommands: readonly [{
+    readonly command: "npm --prefix packages/seed-runtime-state/bridge-protocol test -- --run tests/reactNative.test.ts";
+    readonly scope: "unit";
+  }];
+  readonly evidence: readonly ["React Native WebView ports exchange stringified request/result/event frames.", "Malformed WebView messages are rejected before adapter dispatch."];
+}, {
+  readonly runtime: "app-host";
+  readonly primaryTransportId: "app-host-postmessage";
+  readonly authBoundary: "manifest-capability";
+  readonly adapterEntries: readonly ["packages/seed-runtime-state/app-sdk/src/windowTransport.ts", "apps/desktop/src/renderer/pages/dev/appStudioBroker.ts", "apps/desktop/scripts/dev/app-studio/appStudioPageBrowserSmoke.mjs"];
+  readonly verificationCommands: readonly [{
+    readonly command: "npm --prefix apps/desktop test -- --run tests/unit/renderer/dev/appStudioBrokerPreview.dom.test.tsx";
+    readonly scope: "unit";
+  }, {
+    readonly command: "npm run smoke:app-studio-page-browser";
+    readonly scope: "browser-smoke";
+  }];
+  readonly evidence: readonly ["App Studio brokers SDK postMessage envelopes through manifest capability grants.", "The full page browser smoke verifies app-dev-demo stories inside the real Studio preview iframe."];
+}];
+declare function getSeedBridgeRuntimeTransportContract(runtime: SeedBridgeRuntime): SeedBridgeRuntimeTransportContract | undefined;
+declare function validateSeedBridgeRuntimeTransportContract(input: SeedBridgeRuntimeTransportContractValidation): string[];
+declare function getSeedBridgeRuntimeTransportVerification(runtime: SeedBridgeRuntime): SeedBridgeRuntimeTransportVerification | undefined;
+declare function getSeedBridgeRuntimeTransportDiagnosticsSummary(runtime: SeedBridgeRuntime): SeedBridgeRuntimeTransportDiagnosticsSummary | undefined;
+declare function listSeedBridgeRuntimeTransportDiagnosticsSummaries(): SeedBridgeRuntimeTransportDiagnosticsSummary[];
+declare function validateSeedBridgeRuntimeTransportVerificationMatrix(matrix?: readonly SeedBridgeRuntimeTransportVerification[]): string[];
+//#endregion
+//#region src/agentStream.d.ts
+declare const seedAgentStreamEventTypes: readonly ["agent.run.started", "agent.run.completed", "agent.run.failed", "agent.run.cancelled", "agent.input.steer", "agent.input.collect", "agent.input.followup", "agent.input.side", "agent.message.delta", "agent.thought.delta", "agent.tool.started", "agent.tool.updated", "agent.plan.updated", "agent.goal.updated", "agent.commands.updated", "agent.mode.updated", "agent.config.updated", "agent.context.usage.updated", "agent.session.info.updated", "agent.audio.transcript.updated", "agent.artifact.created", "agent.connection.degraded", "agent.turn.completed", "agent.user.confirmed", "agent.user.delta", "agent.permission.required", "agent.elicitation.required", "agent.background.output", "agent.subagent.anchor", "agent.subagent.message.delta", "agent.subagent.status.updated"];
+type SeedAgentStreamEventType = (typeof seedAgentStreamEventTypes)[number];
+type SeedAgentStreamStatus = "started" | "running" | "pending" | "blocked" | "completed" | "failed" | "cancelled";
+type SeedAgentStreamPayloadPolicy = "metadata-only" | "redacted";
+type SeedAgentStreamEventSpec = {
+  event: SeedAgentStreamEventType;
+  capability: "agent.stream";
+  owner: "app-host.agent";
+  status: SeedAgentStreamStatus;
+  audit: SeedAgentStreamPayloadPolicy;
+  mergeKey?: string;
+  terminal?: boolean;
+  replayable: boolean;
+};
+type SeedAgentBasePayload = {
+  runId: string;
+  conversationId?: string;
+  sessionId?: string;
+};
+type SeedAgentTextDeltaPayload = SeedAgentBasePayload & {
+  messageId?: string;
+  text: string;
+};
+type SeedAgentToolPayload = SeedAgentBasePayload & {
+  toolCallId: string;
+  title?: string;
+  kind?: string;
+  name?: string;
+  status?: string;
+  redactedInput?: unknown;
+  redactedOutput?: unknown;
+  content?: unknown;
+  locations?: unknown;
+  metadata?: Record<string, unknown>;
+};
+type SeedAgentInputDispatchPayload = SeedAgentBasePayload & {
+  inputId?: string;
+  contentSummary?: string;
+  createdAt?: string | number;
+  itemCount?: number;
+  qwenNative?: boolean;
+};
+type SeedAgentRuntimeStatus = "connecting" | "connected" | "authenticated" | "session_active" | "error";
+type SeedAgentStreamPayloadByType = {
+  [SEED_AGENT_STREAM_EVENT_NAMES.runStarted]: SeedAgentBasePayload & {
+    inputSummary?: string;
+  };
+  [SEED_AGENT_STREAM_EVENT_NAMES.runCompleted]: SeedAgentBasePayload & {
+    outputSummary?: string;
+    metrics?: unknown;
+  };
+  [SEED_AGENT_STREAM_EVENT_NAMES.runFailed]: SeedAgentBasePayload & {
+    errorCode?: string;
+    message?: string;
+    metrics?: unknown;
+  };
+  [SEED_AGENT_STREAM_EVENT_NAMES.runCancelled]: SeedAgentBasePayload & {
+    reason?: string;
+    metrics?: unknown;
+  };
+  [SEED_AGENT_STREAM_EVENT_NAMES.inputSteer]: SeedAgentInputDispatchPayload;
+  [SEED_AGENT_STREAM_EVENT_NAMES.inputCollect]: SeedAgentInputDispatchPayload;
+  [SEED_AGENT_STREAM_EVENT_NAMES.inputFollowup]: SeedAgentInputDispatchPayload;
+  [SEED_AGENT_STREAM_EVENT_NAMES.inputSide]: SeedAgentInputDispatchPayload;
+  [SEED_AGENT_STREAM_EVENT_NAMES.messageDelta]: SeedAgentTextDeltaPayload;
+  [SEED_AGENT_STREAM_EVENT_NAMES.thoughtDelta]: SeedAgentTextDeltaPayload;
+  [SEED_AGENT_STREAM_EVENT_NAMES.toolStarted]: SeedAgentToolPayload;
+  [SEED_AGENT_STREAM_EVENT_NAMES.toolUpdated]: SeedAgentToolPayload;
+  [SEED_AGENT_STREAM_EVENT_NAMES.planUpdated]: SeedAgentBasePayload & {
+    entries: unknown[];
+  };
+  [SEED_AGENT_STREAM_EVENT_NAMES.goalUpdated]: SeedAgentBasePayload & {
+    condition?: string;
+    kind?: "set" | "checking" | "achieved" | "failed" | "aborted" | "cleared";
+    iterations?: number;
+    durationMs?: number;
+    lastReason?: string;
+  };
+  [SEED_AGENT_STREAM_EVENT_NAMES.commandsUpdated]: SeedAgentBasePayload & {
+    commands: unknown[];
+  };
+  [SEED_AGENT_STREAM_EVENT_NAMES.modeUpdated]: SeedAgentBasePayload & {
+    modeId?: string;
+  };
+  [SEED_AGENT_STREAM_EVENT_NAMES.configUpdated]: SeedAgentBasePayload & {
+    options: unknown[];
+  };
+  [SEED_AGENT_STREAM_EVENT_NAMES.contextUsageUpdated]: SeedAgentBasePayload & {
+    used?: number;
+    size?: number;
+    total?: number;
+    totalTokens?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    cost?: unknown;
+  };
+  [SEED_AGENT_STREAM_EVENT_NAMES.sessionInfoUpdated]: SeedAgentBasePayload & {
+    title?: string;
+    updatedAt?: string;
+    runtimeStatus?: SeedAgentRuntimeStatus;
+    backend?: string;
+    agentName?: string;
+    detail?: string;
+    messageId?: string;
+  };
+  [SEED_AGENT_STREAM_EVENT_NAMES.audioTranscriptUpdated]: SeedAgentBasePayload & {
+    status?: string;
+    text?: string;
+  };
+  [SEED_AGENT_STREAM_EVENT_NAMES.artifactCreated]: SeedAgentBasePayload & {
+    artifact?: unknown;
+  };
+  [SEED_AGENT_STREAM_EVENT_NAMES.connectionDegraded]: SeedAgentBasePayload & {
+    status?: string;
+    reason?: string;
+    message?: string;
+  };
+  [SEED_AGENT_STREAM_EVENT_NAMES.turnCompleted]: SeedAgentBasePayload & {
+    promptRequestId?: string;
+    stopReason?: string;
+    metrics?: unknown;
+  };
+  [SEED_AGENT_STREAM_EVENT_NAMES.userConfirmed]: SeedAgentBasePayload & {
+    messageId?: string;
+    clientMessageId?: string;
+  };
+  [SEED_AGENT_STREAM_EVENT_NAMES.userDelta]: SeedAgentTextDeltaPayload;
+  [SEED_AGENT_STREAM_EVENT_NAMES.permissionRequired]: SeedAgentBasePayload & {
+    requestId: string;
+    toolCallId?: string;
+    options?: unknown[];
+    toolName?: string;
+    redactedInput?: unknown;
+    description?: string;
+  };
+  [SEED_AGENT_STREAM_EVENT_NAMES.elicitationRequired]: SeedAgentBasePayload & {
+    requestId: string;
+    toolCallId?: string;
+    requestScopeId?: string;
+    title?: string;
+    message?: string;
+    description?: string;
+    schema?: unknown;
+    choices?: unknown[];
+    fields?: unknown[];
+    rawRequest?: unknown;
+  };
+  [SEED_AGENT_STREAM_EVENT_NAMES.backgroundOutput]: SeedAgentBasePayload & {
+    taskId?: string;
+    agent?: string;
+    description?: string;
+    outputText?: string;
+  };
+  [SEED_AGENT_STREAM_EVENT_NAMES.subagentAnchor]: SeedAgentBasePayload & {
+    parentToolCallId?: string;
+    childSessionId: string;
+    title?: string;
+  };
+  [SEED_AGENT_STREAM_EVENT_NAMES.subagentMessageDelta]: SeedAgentBasePayload & {
+    childSessionId: string;
+    childEntryIndex?: number;
+    event?: string;
+    text?: string;
+  };
+  [SEED_AGENT_STREAM_EVENT_NAMES.subagentStatusUpdated]: SeedAgentBasePayload & {
+    childSessionId: string;
+    status: string;
+  };
+};
+type SeedAgentStreamEvent<TEvent extends SeedAgentStreamEventType = SeedAgentStreamEventType> = {
+  schemaVersion: SeedBridgeSchemaVersion;
+  id: string;
+  traceId: string;
+  event: TEvent;
+  runtime: SeedBridgeRuntime;
+  status: SeedAgentStreamStatus;
+  timestamp: number;
+  payload: SeedAgentStreamPayloadByType[TEvent];
+  appId?: string;
+  tenantId?: string;
+  userId?: string;
+  requestId?: string;
+  seq?: number;
+};
+declare const seedAgentStreamEventSpecs: readonly SeedAgentStreamEventSpec[];
+declare function isSeedAgentStreamEventType(value: string): value is SeedAgentStreamEventType;
+declare function getSeedAgentStreamEventSpec(event: string): SeedAgentStreamEventSpec | undefined;
+declare function createSeedAgentStreamEvent<TEvent extends SeedAgentStreamEventType>(input: Omit<SeedAgentStreamEvent<TEvent>, "schemaVersion">): SeedAgentStreamEvent<TEvent>;
+type SeedAgentStreamOutboxRecord = {
+  channel: string;
+  cursor: string;
+  eventId: string;
+  event: SeedAgentStreamEvent;
+  recordedAt: number;
+};
+type SeedAgentStreamOutboxAppendInput = {
+  channel: string;
+  event: SeedAgentStreamEvent;
+  cursor?: string;
+  eventId?: string;
+  recordedAt?: number;
+};
+type SeedAgentStreamOutboxSnapshot = {
+  records: SeedAgentStreamOutboxRecord[];
+  cursor?: string;
+  replayRequired?: boolean;
+  reason?: "cursor_not_found";
+};
+type SeedAgentStreamOutboxOptions = {
+  maxRecordsPerChannel?: number;
+  now?: () => number;
+};
+declare class SeedAgentStreamOutbox {
+  private readonly maxRecordsPerChannel;
+  private readonly now;
+  private readonly recordsByChannel;
+  constructor(options?: SeedAgentStreamOutboxOptions);
+  append(input: SeedAgentStreamOutboxAppendInput): SeedAgentStreamOutboxRecord;
+  appendMany(inputs: readonly SeedAgentStreamOutboxAppendInput[]): SeedAgentStreamOutboxRecord[];
+  snapshot(channelInput: string, cursorInput?: string): SeedAgentStreamOutboxSnapshot;
+}
+declare function createSeedAgentStreamOutbox(options?: SeedAgentStreamOutboxOptions): SeedAgentStreamOutbox;
+//#endregion
+//#region src/seedAppAgentStream.d.ts
+declare const seedAppAgentStreamEventTypes: readonly ["agent.run.started", "agent.run.completed", "agent.run.failed", "agent.run.cancelled", "agent.input.steer", "agent.input.collect", "agent.input.followup", "agent.input.side", "agent.message.delta", "agent.thought.delta", "agent.tool.started", "agent.tool.updated", "agent.plan.updated", "agent.goal.updated", "agent.commands.updated", "agent.mode.updated", "agent.config.updated", "agent.context.usage.updated", "agent.session.info.updated", "agent.audio.transcript.updated", "agent.artifact.created", "agent.connection.degraded", "agent.turn.completed", "agent.user.confirmed", "agent.user.delta", "agent.permission.required", "agent.elicitation.required", "agent.background.output", "agent.subagent.anchor", "agent.subagent.message.delta", "agent.subagent.status.updated"];
+type SeedAppAgentStreamEventType = SeedAgentStreamEventType;
+type SeedAppAgentStreamStatus = SeedAgentStreamStatus;
+type SeedAppEventLike = {
+  type: string;
+  payload?: unknown;
+  status?: string;
+  timestamp?: number;
+};
+type SeedAppAgentBasePayload = {
+  cursor?: string;
+  eventId?: string;
+  replay?: boolean;
+};
+type SeedAppAgentStreamPayloadByType = { [TEvent in SeedAppAgentStreamEventType]: SeedAgentStreamPayloadByType[TEvent] & SeedAppAgentBasePayload; };
+type SeedAppAgentStreamEvent<TEvent extends SeedAppAgentStreamEventType = SeedAppAgentStreamEventType> = TEvent extends SeedAppAgentStreamEventType ? SeedAppEventLike & {
+  cursor?: string;
+  id?: string;
+  type: TEvent;
+  payload: SeedAppAgentStreamPayloadByType[TEvent];
+  status?: SeedAppAgentStreamStatus;
+} : never;
+type SeedAppAgentStreamHandler = (event: SeedAppAgentStreamEvent) => void;
+type SeedAppAgentStreamSubscribeOptions = {
+  conversationId?: string;
+  runId?: string;
+};
+type SeedAppAgentStreamSubscribeConversationInput = {
+  conversationId: string;
+  cursor?: string;
+};
+type SeedAppAgentStreamSubscribeRunInput = {
+  runId: string;
+  cursor?: string;
+};
+type SeedAppAgentStreamSubscribeRequest = SeedAppAgentStreamSubscribeConversationInput | SeedAppAgentStreamSubscribeRunInput;
+type SeedAppAgentStreamChannel = `conversation:${string}` | `run:${string}`;
+type SeedAppAgentStreamSubscribeResult = {
+  subscriptionId: string;
+  channel: SeedAppAgentStreamChannel;
+  cursor?: string;
+  replayRequired?: boolean;
+  reason?: "cursor_not_found";
+  events: SeedAppAgentStreamEvent[];
+};
+type SeedAppAgentStreamUnsubscribeRequest = {
+  subscriptionId: string;
+};
+type SeedAppAgentStreamScopedSubscribeOptions = {
+  requestTimeoutMs?: number;
+};
+type SeedAppAgentStreamScopedUnsubscribe = () => Promise<void>;
+type SeedAppAgentRunAndWatchHandlers = {
+  onEvent?: SeedAppAgentStreamHandler;
+  onMessageDelta?: (event: SeedAppAgentStreamEvent<"agent.message.delta">) => void;
+  onThoughtDelta?: (event: SeedAppAgentStreamEvent<"agent.thought.delta">) => void;
+  onTool?: (event: SeedAppAgentStreamEvent<"agent.tool.started" | "agent.tool.updated">) => void;
+  onBlocked?: (event: SeedAppAgentStreamEvent<"agent.permission.required" | "agent.elicitation.required">) => void;
+  onTerminal?: (event: SeedAppAgentStreamEvent<"agent.run.completed" | "agent.run.failed" | "agent.run.cancelled" | "agent.turn.completed">) => void;
+};
+type SeedAppAgentRunAndWatchOptions = {
+  requestTimeoutMs?: number;
+  streamTimeoutMs?: number;
+};
+type SeedAppAgentStreamConsumptionGuardMode = "dedupe" | "strict-dev";
+type SeedAppAgentStreamConsumptionGuardConsumeOptions = {
+  deliveryScope?: string;
+};
+type SeedAppAgentStreamConsumptionGuardIssueCode = "duplicate_event" | "missing_assistant_message_id" | "multiple_assistant_message_ids_for_run" | "tool_update_without_start";
+type SeedAppAgentStreamConsumptionGuardIssue = {
+  code: SeedAppAgentStreamConsumptionGuardIssueCode;
+  consumerName: string;
+  deliveryKey?: string;
+  semanticKey?: string;
+  eventType: SeedAppAgentStreamEventType;
+  conversationId?: string;
+  runId: string;
+  message: string;
+};
+type SeedAppAgentStreamConsumptionGuardOptions = {
+  consumerName: string;
+  mode?: SeedAppAgentStreamConsumptionGuardMode;
+  maxDeliveryKeys?: number;
+  logger?: Pick<Console, "error" | "warn">;
+  throwOnDeveloperError?: boolean;
+};
+declare function isSeedAppAgentStreamEvent(event: SeedAppEventLike): event is SeedAppAgentStreamEvent;
+declare function createSeedAppAgentStreamEvent<TEvent extends SeedAppAgentStreamEventType>(event: SeedAppAgentStreamEvent<TEvent>): SeedAppAgentStreamEvent<TEvent>;
+declare function resolveSeedAppAgentStreamEventIdentity(event: SeedAppAgentStreamEvent): string;
+/**
+ * Resolve the business-level merge key for one canonical agent stream event.
+ *
+ * This is intentionally separate from delivery identity. Delivery identity answers
+ * "have I received this exact frame before?", while semantic identity answers
+ * "which UI/runtime object should this frame update?". Inspectors should display
+ * this key when explaining why live, replay, WebSocket, Electron IPC, and Mobile
+ * streams converge into the same rendered object.
+ */
+declare function resolveSeedAppAgentStreamSemanticKey(event: SeedAppAgentStreamEvent): string;
+/**
+ * Shared consumer-side protection for canonical agent stream events.
+ *
+ * The guard treats agent streams as at-least-once delivery: the same transport
+ * frame may arrive twice, and replay/live streams may converge on the same
+ * semantic object. Use this class at the consumer boundary before mutating UI or
+ * runtime state. It performs:
+ * - delivery dedupe via `event.id` / `payload.eventId` / `cursor`
+ * - semantic-key inspection for assistant messages and tool calls
+ * - development-only error reporting for protocol shapes that would duplicate UI
+ */
+declare class SeedAppAgentStreamConsumptionGuard {
+  private readonly consumerName;
+  private readonly mode;
+  private readonly maxDeliveryKeys;
+  private readonly logger;
+  private readonly throwOnDeveloperError;
+  private readonly seenDeliveryKeys;
+  private readonly runStateByKey;
+  private readonly reportedIssueKeys;
+  private readonly issues;
+  constructor(options: SeedAppAgentStreamConsumptionGuardOptions);
+  shouldConsume(event: SeedAppAgentStreamEvent, options?: SeedAppAgentStreamConsumptionGuardConsumeOptions): boolean;
+  assertCanonical(event: SeedAppAgentStreamEvent): SeedAppAgentStreamConsumptionGuardIssue[];
+  resolveDeliveryKey(event: SeedAppAgentStreamEvent, options?: SeedAppAgentStreamConsumptionGuardConsumeOptions): string;
+  resolveSemanticKey(event: SeedAppAgentStreamEvent): string;
+  getIssues(): SeedAppAgentStreamConsumptionGuardIssue[];
+  reset(): void;
+  private inspectCanonicalEvent;
+  private getRunState;
+  private rememberDeliveryKey;
+  private reportIssue;
+}
+declare function createSeedAppAgentStreamConsumptionGuard(options: SeedAppAgentStreamConsumptionGuardOptions): SeedAppAgentStreamConsumptionGuard;
+//#endregion
+//#region src/seedAppAguiStream.d.ts
+declare const seedAppAguiStreamEventTypes: readonly ["RUN_STARTED", "RUN_FINISHED", "RUN_ERROR", "TEXT_MESSAGE_START", "TEXT_MESSAGE_CONTENT", "TEXT_MESSAGE_END", "TOOL_CALL_START", "TOOL_CALL_ARGS", "TOOL_CALL_END", "TOOL_CALL_RESULT", "STATE_DELTA", "CUSTOM"];
+type SeedAguiSource = "seed-web" | "desktop-acp" | "control-gateway";
+type SeedAguiEventType = (typeof seedAppAguiStreamEventTypes)[number];
+type SeedAguiMetadata = {
+  conversationId: string;
+  runId: string;
+  source: SeedAguiSource;
+  tenantId?: string;
+  employeeId?: string;
+  roleTemplateId?: string;
+  seq?: number;
+  sourceEventId?: string;
+};
+type SeedAguiBaseEvent = {
+  type: SeedAguiEventType;
+  eventId: string;
+  threadId: string;
+  runId: string;
+  seed: SeedAguiMetadata;
+};
+type SeedAguiRunStartedEvent = SeedAguiBaseEvent & {
+  type: "RUN_STARTED";
+};
+type SeedAguiRunFinishedEvent = SeedAguiBaseEvent & {
+  type: "RUN_FINISHED";
+};
+type SeedAguiRunErrorEvent = SeedAguiBaseEvent & {
+  type: "RUN_ERROR";
+  message: string;
+};
+type SeedAguiTextMessageStartEvent = SeedAguiBaseEvent & {
+  type: "TEXT_MESSAGE_START";
+  messageId: string;
+  role: "assistant";
+};
+type SeedAguiTextMessageContentEvent = SeedAguiBaseEvent & {
+  type: "TEXT_MESSAGE_CONTENT";
+  messageId: string;
+  delta: string;
+};
+type SeedAguiTextMessageEndEvent = SeedAguiBaseEvent & {
+  type: "TEXT_MESSAGE_END";
+  messageId: string;
+};
+type SeedAguiToolCallStartEvent = SeedAguiBaseEvent & {
+  type: "TOOL_CALL_START";
+  toolCallId: string;
+  toolCallName: string;
+  parentMessageId?: string;
+};
+type SeedAguiToolCallArgsEvent = SeedAguiBaseEvent & {
+  type: "TOOL_CALL_ARGS";
+  toolCallId: string;
+  delta: string;
+};
+type SeedAguiToolCallEndEvent = SeedAguiBaseEvent & {
+  type: "TOOL_CALL_END";
+  toolCallId: string;
+};
+type SeedAguiToolCallResultEvent = SeedAguiBaseEvent & {
+  type: "TOOL_CALL_RESULT";
+  toolCallId: string;
+  content: unknown;
+};
+type SeedAguiJsonPatchOperation = {
+  op: "add" | "replace";
+  path: string;
+  value: unknown;
+} | {
+  op: "remove";
+  path: string;
+};
+type SeedAguiStateDeltaEvent = SeedAguiBaseEvent & {
+  type: "STATE_DELTA";
+  delta: SeedAguiJsonPatchOperation[];
+};
+type SeedAguiCustomEvent = SeedAguiBaseEvent & {
+  type: "CUSTOM";
+  name: string;
+  value: unknown;
+};
+type SeedAguiFormField = {
+  key: string;
+  label: string;
+  type: "text" | "select" | "number" | "boolean" | "email" | "textarea";
+  required?: boolean;
+  placeholder?: string;
+  options?: Array<{
+    label: string;
+    value: string;
+  }>;
+};
+type SeedAguiFormSchema = {
+  title: string;
+  fields: SeedAguiFormField[];
+};
+type SeedAguiEvent = SeedAguiRunStartedEvent | SeedAguiRunFinishedEvent | SeedAguiRunErrorEvent | SeedAguiTextMessageStartEvent | SeedAguiTextMessageContentEvent | SeedAguiTextMessageEndEvent | SeedAguiToolCallStartEvent | SeedAguiToolCallArgsEvent | SeedAguiToolCallEndEvent | SeedAguiToolCallResultEvent | SeedAguiStateDeltaEvent | SeedAguiCustomEvent;
+type SeedAppAguiStreamHandler = (event: SeedAguiEvent) => void;
+type SeedAppAguiStreamSubscribeOptions = {
+  conversationId?: string;
+  runId?: string;
+};
+type SeedAppAguiStreamSubscribeConversationInput = {
+  conversationId: string;
+  cursor?: string;
+};
+type SeedAppAguiStreamSubscribeRunInput = {
+  runId: string;
+  cursor?: string;
+};
+type SeedAppAguiStreamSubscribeRequest = SeedAppAguiStreamSubscribeConversationInput | SeedAppAguiStreamSubscribeRunInput;
+type SeedAppAguiStreamChannel = `conversation:${string}` | `run:${string}`;
+type SeedAppAguiStreamSubscribeResult = {
+  subscriptionId: string;
+  channel: SeedAppAguiStreamChannel;
+  cursor?: string;
+  replayRequired?: boolean;
+  reason?: "cursor_not_found";
+  events: SeedAguiEvent[];
+};
+type SeedAppAguiStreamUnsubscribeRequest = {
+  subscriptionId: string;
+};
+type SeedAppAguiStreamScopedSubscribeOptions = {
+  requestTimeoutMs?: number;
+};
+type SeedAppAguiStreamScopedUnsubscribe = () => Promise<void>;
+declare function isSeedAguiEvent(event: unknown): event is SeedAguiEvent;
+declare function resolveSeedAguiEventIdentity(event: SeedAguiEvent): string;
+declare function matchesSeedAguiStreamScope(event: SeedAguiEvent, input: SeedAppAguiStreamSubscribeRequest): boolean;
+//#endregion
+//#region src/acp/alignment.d.ts
+declare const SEED_ACP_STABLE_PROTOCOL_VERSION = 1;
+declare const SEED_ACP_ALIGNMENT_SOURCE_CHECKED_AT = "2026-06-20";
+type SeedAcpAlignmentClass = "stable" | "rfd-preview" | "seed-extension" | "out-of-scope";
+type SeedAcpAlignmentLifecycle = "protocol-v1" | "completed-rfd" | "draft-rfd" | "preview-rfd" | "seed-owned";
+type SeedAcpAlignmentExposure = "candidate-only" | "runtime-gated-candidate";
+type SeedAcpLocalWebuiRole = "adapter-parity" | "diagnostics-only" | "not-applicable";
+type SeedAcpAlignmentSource = {
+  id: string;
+  url: string;
+  checkedAt: string;
+};
+type SeedAcpAlignmentTarget = {
+  kind: "diagnostics-metadata" | "method-candidate" | "event-candidate" | "runtime-extension" | "none";
+  method?: string;
+  event?: string;
+  capability?: string;
+};
+type SeedAcpAlignmentRuntimeCandidate = {
+  runtime: SeedBridgeRuntime;
+  transport?: SeedBridgeTransportId;
+  support: "candidate" | "diagnostics-only" | "blocked";
+};
+type SeedAcpAlignmentCapability = {
+  id: string;
+  acpName: string;
+  classification: SeedAcpAlignmentClass;
+  lifecycle: SeedAcpAlignmentLifecycle;
+  exposure: SeedAcpAlignmentExposure;
+  seedBridge: SeedAcpAlignmentTarget;
+  runtimeCandidates: readonly SeedAcpAlignmentRuntimeCandidate[];
+  localWebuiRole: SeedAcpLocalWebuiRole;
+  diagnosticsEligible: boolean;
+  webSaasDefaultAllowlist: boolean;
+  mobileDefaultEnabledDomain: boolean;
+  sources: readonly SeedAcpAlignmentSource[];
+  note: string;
+};
+type SeedAcpAlignmentCapabilityFilter = {
+  classification?: SeedAcpAlignmentClass;
+  lifecycle?: SeedAcpAlignmentLifecycle;
+  diagnosticsEligible?: boolean;
+  localWebuiRole?: SeedAcpLocalWebuiRole;
+};
+type SeedAcpAlignmentGateIssue = {
+  id: string;
+  message: string;
+};
+declare const seedAcpAlignmentCapabilities: readonly SeedAcpAlignmentCapability[];
+declare function listSeedAcpAlignmentCapabilities(filter?: SeedAcpAlignmentCapabilityFilter): SeedAcpAlignmentCapability[];
+declare function getSeedAcpAlignmentCapability(id: string): SeedAcpAlignmentCapability | undefined;
+declare function validateSeedAcpAlignmentCapabilityGates(capabilities?: readonly SeedAcpAlignmentCapability[]): SeedAcpAlignmentGateIssue[];
+//#endregion
+//#region src/acp/diagnostics.d.ts
+type SeedAcpStableDiagnosticsLifecycle = Extract<SeedAcpAlignmentLifecycle, "protocol-v1" | "completed-rfd">;
+type SeedAcpRfdPreviewDiagnosticsLifecycle = Extract<SeedAcpAlignmentLifecycle, "draft-rfd" | "preview-rfd">;
+type SeedAcpStableDiagnosticsCandidate = {
+  id: string;
+  acpName: string;
+  classification: "stable";
+  lifecycle: SeedAcpStableDiagnosticsLifecycle;
+  seedBridge: SeedAcpAlignmentTarget;
+  runtimeCandidates: readonly SeedAcpAlignmentRuntimeCandidate[];
+  localWebuiRole: SeedAcpLocalWebuiRole;
+  webSaasDefaultAllowlist: false;
+  mobileDefaultEnabledDomain: false;
+  sources: readonly SeedAcpAlignmentSource[];
+  note: string;
+};
+type SeedAcpStableDiagnosticsSnapshot = {
+  schemaVersion: "seed.acp.diagnostics.v1";
+  source: "seed-acp-alignment";
+  stableProtocolVersion: typeof SEED_ACP_STABLE_PROTOCOL_VERSION;
+  candidates: readonly SeedAcpStableDiagnosticsCandidate[];
+};
+type SeedAcpRfdPreviewDiagnosticsCandidate = {
+  id: `rfd-acp.${string}`;
+  acpName: string;
+  classification: "rfd-preview";
+  lifecycle: SeedAcpRfdPreviewDiagnosticsLifecycle;
+  seedBridge: SeedAcpAlignmentTarget;
+  runtimeCandidates: readonly SeedAcpAlignmentRuntimeCandidate[];
+  localWebuiRole: SeedAcpLocalWebuiRole;
+  webSaasDefaultAllowlist: false;
+  mobileDefaultEnabledDomain: false;
+  sources: readonly SeedAcpAlignmentSource[];
+  note: string;
+};
+type SeedAcpRfdPreviewDiagnosticsSnapshot = {
+  schemaVersion: "seed.acp.rfd-preview.diagnostics.v1";
+  source: "seed-acp-alignment";
+  candidates: readonly SeedAcpRfdPreviewDiagnosticsCandidate[];
+};
+type SeedAcpStableDiagnosticsCandidateValidationInput = Omit<SeedAcpStableDiagnosticsCandidate, "classification" | "lifecycle" | "webSaasDefaultAllowlist" | "mobileDefaultEnabledDomain"> & {
+  classification: string;
+  lifecycle: string;
+  webSaasDefaultAllowlist: boolean;
+  mobileDefaultEnabledDomain: boolean;
+};
+type SeedAcpRfdPreviewDiagnosticsCandidateValidationInput = Omit<SeedAcpRfdPreviewDiagnosticsCandidate, "id" | "classification" | "lifecycle" | "webSaasDefaultAllowlist" | "mobileDefaultEnabledDomain"> & {
+  id: string;
+  classification: string;
+  lifecycle: string;
+  webSaasDefaultAllowlist: boolean;
+  mobileDefaultEnabledDomain: boolean;
+};
+declare function listSeedAcpStableDiagnosticsCandidates(capabilities?: readonly SeedAcpAlignmentCapability[]): SeedAcpStableDiagnosticsCandidate[];
+declare function createSeedAcpStableDiagnosticsSnapshot(capabilities?: readonly SeedAcpAlignmentCapability[]): SeedAcpStableDiagnosticsSnapshot;
+declare function listSeedAcpRfdPreviewDiagnosticsCandidates(capabilities?: readonly SeedAcpAlignmentCapability[]): SeedAcpRfdPreviewDiagnosticsCandidate[];
+declare function createSeedAcpRfdPreviewDiagnosticsSnapshot(capabilities?: readonly SeedAcpAlignmentCapability[]): SeedAcpRfdPreviewDiagnosticsSnapshot;
+declare function validateSeedAcpStableDiagnosticsCandidates(candidates: readonly SeedAcpStableDiagnosticsCandidateValidationInput[]): string[];
+declare function validateSeedAcpRfdPreviewDiagnosticsCandidates(candidates: readonly SeedAcpRfdPreviewDiagnosticsCandidateValidationInput[]): string[];
+//#endregion
+//#region src/acp/types.d.ts
+type SeedAcpEventLogEntry = {
+  id?: string;
+  timestamp?: number;
+  type: string;
+  direction?: "inbound" | "outbound" | "internal" | string;
+  payload?: unknown;
+  sessionId?: string;
+  conversationId?: string;
+  error?: string;
+};
+type SeedAcpEventLogExport = {
+  events: SeedAcpEventLogEntry[];
+};
+type SeedAcpEventLogParseIssue = {
+  line?: number;
+  message: string;
+  raw?: string;
+};
+type SeedAcpEventLogParseResult = {
+  entries: SeedAcpEventLogEntry[];
+  issues: SeedAcpEventLogParseIssue[];
+};
+type SeedAcpProjectionOptions = {
+  runId: string;
+  traceId: string;
+  runtime?: SeedBridgeRuntime;
+  appId?: string;
+  tenantId?: string;
+  userId?: string;
+  requestId?: string;
+  conversationId?: string;
+  defaultSessionId?: string;
+  includeBackupEvents?: boolean;
+};
+//#endregion
+//#region src/acp/projection.d.ts
+declare function projectAcpEventLogToSeedAgentStreamEvents(input: readonly SeedAcpEventLogEntry[] | SeedAcpEventLogExport, options: SeedAcpProjectionOptions): SeedAgentStreamEvent[];
+declare function projectAcpEventLogEntryToSeedAgentStreamEvents(entry: SeedAcpEventLogEntry, options: SeedAcpProjectionOptions): SeedAgentStreamEvent[];
+//#endregion
+//#region src/acp/projectionParse.d.ts
+declare function parseAcpEventLogExport(input: string): SeedAcpEventLogParseResult;
+//#endregion
+//#region src/workspaceEvents.d.ts
+type SeedWorkspaceFileEventType = "workspace.file.created" | "workspace.file.updated" | "workspace.file.deleted" | "workspace.file.moved" | "workspace.file.patched";
+type SeedWorkspaceFileEventInput = {
+  eventId: string;
+  type: SeedWorkspaceFileEventType;
+  workspaceId?: string;
+  sessionId: string;
+  operationId?: string;
+  origin?: string;
+  providerKind?: string;
+  providerInstanceId?: string;
+  providerRef?: string;
+  paths: string[];
+  parentDirs: string[];
+  updatedAt: string;
+  timestamp: string;
+  source: string;
+  workspaceRoot?: string;
+  fullPaths?: string[];
+};
+type SeedWorkspaceChangedOperation = "created" | "updated" | "deleted" | "moved" | "patched";
+type SeedWorkspaceChangedPayload = {
+  workspaceId: string;
+  sessionId: string;
+  operation: SeedWorkspaceChangedOperation;
+  uri: string;
+  paths: string[];
+  parentDirs: string[];
+  source: string;
+  updatedAt: string;
+  providerKind?: string;
+  providerInstanceId?: string;
+  providerRef?: string;
+  operationId?: string;
+  origin?: string;
+  pathCount: number;
+};
+declare function projectWorkspaceFileEventToJsonRpcNotification(input: {
+  appId?: string;
+  event: SeedWorkspaceFileEventInput;
+  runtime?: SeedBridgeRuntime;
+  seq?: number;
+  tenantId?: string;
+  traceId?: string;
+  userId?: string;
+}): JsonRpcNotification | undefined;
+//#endregion
+//#region src/index.d.ts
+type SeedBridgeRuntime = "electron" | "local-webui" | "web-saas" | "react-native" | "app-host";
+type SeedBridgeRisk = "safe" | "conditional" | "blocked" | "needs_design";
+type SeedBridgeTransportId = "electron-ipc" | "local-websocket" | "web-saas-api" | "web-saas-bridge-ws" | "control-gateway" | "react-native-webview" | "acp-provider" | "app-host-postmessage";
+type SeedBridgeAuthBoundary = "preload-main" | "local-session" | "session-cookie" | "bearer-token" | "manifest-capability";
+type SeedBridgeTransportSpec = {
+  id: SeedBridgeTransportId;
+  requestFrame: string;
+  responseFrame: string;
+  eventFrame: string;
+  authBoundary: SeedBridgeAuthBoundary;
+  supportsStreaming: boolean;
+  supportsBroadcast: boolean;
+};
+type SeedBridgeErrorCode = "host_unavailable" | "app_not_installed" | "app_disabled" | "handshake_timeout" | "unsupported_runtime" | "unauthenticated" | "capability_denied" | "approval_required" | "approval_denied" | "tenant_policy_denied" | "origin_denied" | "grant_required" | "nonce_invalid" | "csrf_required" | "mcp_unavailable" | "memory_scope_denied" | "resource_scope_denied" | "skill_scope_denied" | "bundle_integrity_failed" | "sdk_version_incompatible" | "bridge_policy_denied" | "provider_unavailable" | "provider_failed" | "payload_too_large" | "rate_limited" | "invalid_payload_schema" | "reserved_bridge_key" | "invalid_request" | "invalid_target" | "not_found" | "already_exists" | "not_a_file" | "not_a_directory" | "parent_not_found" | "directory_not_empty" | "protected_path" | "permission_denied" | "mount_not_found" | "resource_not_found" | "resource_disabled" | "resource_unavailable" | "mode_not_allowed" | "unsupported_operation" | "unsupported_option_combination" | "execute_preflight_unknown" | "cross_mount_move_unsupported" | "version_conflict" | "edit_conflict" | "idempotency_conflict" | "stale_writer" | "write_fence_expired" | "write_fence_scope_denied" | "file_too_large" | "cursor_invalid" | "timeout" | "cancelled" | "provider_error" | "internal_error";
+type SeedBridgeError = {
+  code: SeedBridgeErrorCode;
+  message: string;
+  retryable: boolean;
+  requestId: string;
+  capability?: string;
+  action?: string;
+  operationId?: string;
+  details?: unknown;
+};
+type SeedBridgeTransportSupport = "native" | "websocket" | "api" | "gateway" | "compat-projection" | "capability-broker" | "planned" | "unsupported";
+type SeedBridgeMethodSpec = {
+  method: string;
+  kind: "provider" | "event";
+  owner: string;
+  risk: SeedBridgeRisk;
+  errors: SeedBridgeErrorCode[];
+  transports: Partial<Record<SeedBridgeRuntime, SeedBridgeTransportSupport>>;
+  capability?: string;
+  audit: {
+    payload: "none" | "metadata-only" | "inline-attachments" | "redacted";
+    tenantScoped: boolean;
+    userScoped: boolean;
+  };
+};
+declare const seedBridgeTransportSpecs: readonly SeedBridgeTransportSpec[];
+declare const appHostBridgeMethodSpecs: readonly SeedBridgeMethodSpec[];
+declare const seedBridgeMethodSpecs: readonly SeedBridgeMethodSpec[];
+declare function getSeedBridgeMethodSpec(method: string): SeedBridgeMethodSpec | undefined;
+declare function getSeedBridgeCapabilityForMethod(method: string): string | undefined;
+declare function listSeedBridgeMethodsForCapability(capability: string): SeedBridgeMethodSpec[];
+declare function createSeedBridgeError(input: Omit<SeedBridgeError, "retryable"> & {
+  retryable?: boolean;
+}): SeedBridgeError;
+//#endregion
+export { type AgentElicitationRequiredPayload, type AgentMessageDeltaPayload, type AgentPermissionRequiredPayload, type AgentRunCancelledPayload, type AgentRunCompletedPayload, type AgentRunFailedPayload, type AgentRunStartedPayload, type AgentRuntimeEventPayload, type AgentThoughtDeltaPayload, type AgentToolStartedPayload, type AgentToolUpdatedPayload, type AgentTurnCompletedPayload, CANONICAL_EVENT_TYPES, type CanonicalEventMeta, type CanonicalEventPayload, type CanonicalEventType, type CanonicalEventValidationResult, JSON_RPC_ERROR_CODES, JsonRpcControlGatewayAdapterContract, JsonRpcControlGatewayFrame, JsonRpcControlGatewayFrameContext, JsonRpcControlGatewayFrameType, JsonRpcControlGatewayFrameUnion, JsonRpcControlGatewayNotificationFrame, JsonRpcControlGatewayNotificationPayload, JsonRpcControlGatewayRequestFrame, JsonRpcControlGatewayRequestPayload, JsonRpcControlGatewayResponseFrame, JsonRpcControlGatewayResponsePayload, JsonRpcElectronIpcAdapterContract, JsonRpcElectronIpcFrame, type JsonRpcErrorObject, type JsonRpcErrorResponse, type JsonRpcFrame, type JsonRpcId, JsonRpcLocalWebuiFrame, type JsonRpcNotification, JsonRpcReactNativeFrame, JsonRpcReactNativeWebViewAdapter, JsonRpcReactNativeWebViewAdapterOptions, JsonRpcReactNativeWebViewPort, type JsonRpcRequest, type JsonRpcResponse, type JsonRpcValidationResult, type ParsedJsonRpcFrame, RuntimeReasoningConfig, RuntimeReasoningConfigOption, RuntimeReasoningConfigOptionResolution, RuntimeReasoningConfigOptionUpdate, RuntimeReasoningEffort, SEED_ACP_ALIGNMENT_SOURCE_CHECKED_AT, SEED_ACP_STABLE_PROTOCOL_VERSION, SEED_AGENT_STREAM_EVENT_NAMES, SEED_AGENT_STREAM_EVENT_NAME_LIST, SEED_AGUI_STREAM_EVENT_NAMES, SEED_AGUI_STREAM_EVENT_NAME_LIST, SEED_AGUI_STREAM_EVENT_TYPE, SEED_APP_HOST_EVENT_NAMES, SEED_APP_HOST_EVENT_NAME_LIST, SEED_BACKGROUND_STREAM_EVENT_NAMES, SEED_BACKGROUND_STREAM_EVENT_NAME_LIST, SEED_BACKGROUND_STREAM_EVENT_TYPE, SEED_BRIDGE_ELECTRON_IPC_CHANNEL, SEED_BRIDGE_EVENT_CATALOG, SEED_BRIDGE_ROUTE_COMMAND_TRANSPORTS, SEED_BRIDGE_ROUTE_IMPLEMENTATIONS, SEED_BRIDGE_SCHEMA_VERSION, SEED_CONVERSATION_AUTHORITY_KINDS, SEED_EVENT_NOTIFICATION_METHOD, SeedAcpAlignmentCapability, SeedAcpAlignmentCapabilityFilter, SeedAcpAlignmentClass, SeedAcpAlignmentExposure, SeedAcpAlignmentGateIssue, SeedAcpAlignmentLifecycle, SeedAcpAlignmentRuntimeCandidate, SeedAcpAlignmentSource, SeedAcpAlignmentTarget, SeedAcpEventLogEntry, SeedAcpEventLogExport, SeedAcpEventLogParseIssue, SeedAcpEventLogParseResult, SeedAcpLocalWebuiRole, SeedAcpProjectionOptions, SeedAcpRfdPreviewDiagnosticsCandidate, SeedAcpRfdPreviewDiagnosticsCandidateValidationInput, SeedAcpRfdPreviewDiagnosticsLifecycle, SeedAcpRfdPreviewDiagnosticsSnapshot, SeedAcpStableDiagnosticsCandidate, SeedAcpStableDiagnosticsCandidateValidationInput, SeedAcpStableDiagnosticsLifecycle, SeedAcpStableDiagnosticsSnapshot, SeedAgentBasePayload, SeedAgentInputDispatchPayload, SeedAgentRuntimeStatus, SeedAgentStreamEvent, SeedAgentStreamEventSpec, SeedAgentStreamEventType, SeedAgentStreamOutbox, SeedAgentStreamOutboxAppendInput, SeedAgentStreamOutboxOptions, SeedAgentStreamOutboxRecord, SeedAgentStreamOutboxSnapshot, SeedAgentStreamPayloadByType, SeedAgentStreamPayloadPolicy, SeedAgentStreamStatus, SeedAgentTextDeltaPayload, SeedAgentToolPayload, SeedAguiBaseEvent, SeedAguiCustomEvent, SeedAguiEvent, SeedAguiEventType, SeedAguiFormField, SeedAguiFormSchema, SeedAguiJsonPatchOperation, SeedAguiMetadata, SeedAguiRunErrorEvent, SeedAguiRunFinishedEvent, SeedAguiRunStartedEvent, SeedAguiSource, SeedAguiStateDeltaEvent, SeedAguiTextMessageContentEvent, SeedAguiTextMessageEndEvent, SeedAguiTextMessageStartEvent, SeedAguiToolCallArgsEvent, SeedAguiToolCallEndEvent, SeedAguiToolCallResultEvent, SeedAguiToolCallStartEvent, SeedAppAgentBasePayload, SeedAppAgentRunAndWatchHandlers, SeedAppAgentRunAndWatchOptions, SeedAppAgentStreamChannel, SeedAppAgentStreamConsumptionGuard, SeedAppAgentStreamConsumptionGuardConsumeOptions, SeedAppAgentStreamConsumptionGuardIssue, SeedAppAgentStreamConsumptionGuardIssueCode, SeedAppAgentStreamConsumptionGuardMode, SeedAppAgentStreamConsumptionGuardOptions, SeedAppAgentStreamEvent, SeedAppAgentStreamEventType, SeedAppAgentStreamHandler, SeedAppAgentStreamPayloadByType, SeedAppAgentStreamScopedSubscribeOptions, SeedAppAgentStreamScopedUnsubscribe, SeedAppAgentStreamStatus, SeedAppAgentStreamSubscribeConversationInput, SeedAppAgentStreamSubscribeOptions, SeedAppAgentStreamSubscribeRequest, SeedAppAgentStreamSubscribeResult, SeedAppAgentStreamSubscribeRunInput, SeedAppAgentStreamUnsubscribeRequest, SeedAppAguiStreamChannel, SeedAppAguiStreamHandler, SeedAppAguiStreamScopedSubscribeOptions, SeedAppAguiStreamScopedUnsubscribe, SeedAppAguiStreamSubscribeConversationInput, SeedAppAguiStreamSubscribeOptions, SeedAppAguiStreamSubscribeRequest, SeedAppAguiStreamSubscribeResult, SeedAppAguiStreamSubscribeRunInput, SeedAppAguiStreamUnsubscribeRequest, type SeedAppBundleAsset, type SeedAppBundleManifest, type SeedAppBundleSummary, type SeedAppCapabilities, type SeedAppContributions, type SeedAppEntry, SeedAppEventLike, type SeedAppGrantPolicy, type SeedAppKind, type SeedAppLauncherContribution, type SeedAppManifest, type SeedAppPermissions, type SeedAppRuntime, type SeedAppValidationIssue, type SeedAppValidationResult, type SeedBackgroundStreamEvent, type SeedBackgroundStreamEventType, type SeedBridgeAgentRuntimeRouteMethod, type SeedBridgeAuditAuthority, SeedBridgeAuthBoundary, SeedBridgeError, SeedBridgeErrorCode, type SeedBridgeMethodRuntimeRoute, SeedBridgeMethodSpec, SeedBridgeRisk, type SeedBridgeRouteAuthority, type SeedBridgeRouteCommandTransport, type SeedBridgeRouteEventSource, type SeedBridgeRouteFallback, type SeedBridgeRouteImplementation, SeedBridgeRuntime, SeedBridgeRuntimeTransportContract, SeedBridgeRuntimeTransportContractValidation, SeedBridgeRuntimeTransportDiagnosticsSummary, SeedBridgeRuntimeTransportVerification, SeedBridgeRuntimeTransportVerificationCommand, type SeedBridgeSchemaVersion, SeedBridgeTransportId, SeedBridgeTransportSpec, SeedBridgeTransportSupport, type SeedCloudConversationAuthorityDescriptor, type SeedConversationAuthorityDescriptor, type SeedConversationAuthorityValidationCode, type SeedConversationAuthorityValidationResult, type SeedEventAcpInspectorProjection, type SeedEventAcpProjectionTraceInput, type SeedEventClientEvent, type SeedEventNotificationParams, type SeedEventProjectionTrace, type SeedEventTransportMeta, type SeedEventTransportParams, type SeedRemotePcConversationAuthorityDescriptor, SeedWorkspaceChangedOperation, SeedWorkspaceChangedPayload, SeedWorkspaceFileEventInput, SeedWorkspaceFileEventType, appHostBridgeMethodSpecs, createJsonRpcControlGatewayNotificationFrame, createJsonRpcControlGatewayRequestFrame, createJsonRpcControlGatewayResponseFrame, createJsonRpcError, createJsonRpcNotification, createJsonRpcReactNativeWebViewAdapter, createJsonRpcRequest, createJsonRpcResponse, createSeedAcpRfdPreviewDiagnosticsSnapshot, createSeedAcpStableDiagnosticsSnapshot, createSeedAgentStreamEvent, createSeedAgentStreamOutbox, createSeedAppAgentStreamConsumptionGuard, createSeedAppAgentStreamEvent, createSeedBridgeError, createSeedEventAcpProjectionTrace, createSeedEventNotification, deserializeJsonRpcFrame, getSeedAcpAlignmentCapability, getSeedAgentStreamEventSpec, getSeedBridgeCapabilityForMethod, getSeedBridgeMethodSpec, getSeedBridgeRouteMetadataForMethod, getSeedBridgeRuntimeTransportContract, getSeedBridgeRuntimeTransportDiagnosticsSummary, getSeedBridgeRuntimeTransportVerification, isRuntimeReasoningConfigOption, isSeedAgentStreamEventType, isSeedAguiEvent, isSeedAppAgentStreamEvent, isSeedBackgroundStreamEvent, jsonRpcControlGatewayPayloadKinds, listSeedAcpAlignmentCapabilities, listSeedAcpRfdPreviewDiagnosticsCandidates, listSeedAcpStableDiagnosticsCandidates, listSeedBridgeMethodsForCapability, listSeedBridgeRouteMetadata, listSeedBridgeRouteMetadataForCapability, listSeedBridgeRuntimeTransportDiagnosticsSummaries, matchesSeedAguiStreamScope, normalizeRuntimeConfigReasoning, normalizeRuntimeReasoningConfig, parseAcpEventLogExport, parseJsonRpcControlGatewayFrame, parseJsonRpcElectronIpcFrame, parseJsonRpcFrame, parseJsonRpcLocalWebuiFrame, parseJsonRpcReactNativeFrame, projectAcpEventLogEntryToSeedAgentStreamEvents, projectAcpEventLogToSeedAgentStreamEvents, projectSeedClientEventToAcpInspectorProjection, projectSeedEventFrameToClientEvent, projectSeedEventParamsToClientEvent, projectWorkspaceFileEventToJsonRpcNotification, readSeedEventProjectionTrace, readSeedEventTransportParams, resolveRuntimeReasoningConfigOptions, resolveSeedAguiEventIdentity, resolveSeedAppAgentStreamEventIdentity, resolveSeedAppAgentStreamSemanticKey, seedAcpAlignmentCapabilities, seedAgentStreamEventSpecs, seedAgentStreamEventTypes, seedAppAgentStreamEventTypes, seedAppAguiStreamEventTypes, seedBridgeMethodRuntimeRoutes, seedBridgeMethodSpecs, seedBridgeRuntimeTransportContracts, seedBridgeRuntimeTransportVerificationMatrix, seedBridgeTransportSpecs, serializeJsonRpcControlGatewayFrame, serializeJsonRpcElectronIpcFrame, serializeJsonRpcFrame, serializeJsonRpcLocalWebuiFrame, serializeJsonRpcReactNativeFrame, validateCanonicalEvent, validateCanonicalEventMeta, validateJsonRpcControlGatewayAdapterContract, validateJsonRpcElectronIpcAdapterContract, validateJsonRpcRequest, validateSeedAcpAlignmentCapabilityGates, validateSeedAcpRfdPreviewDiagnosticsCandidates, validateSeedAcpStableDiagnosticsCandidates, validateSeedAppBundleManifest, validateSeedAppManifest, validateSeedBridgeRuntimeTransportContract, validateSeedBridgeRuntimeTransportVerificationMatrix, validateSeedConversationAuthorityDescriptor, workspaceBridgeMethodSpecs };