@pellux/goodvibes-tui 0.18.4

package/src/runtime/emitters/plugins.ts

@@ -0,0 +1,78 @@
+/**
+ * Plugin emitters — typed emission wrappers for PluginEvent domain.
+ */
+import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
+import type { RuntimeEventBus } from '../events/index.ts';
+import type { EmitterContext } from './index.ts';
+
+/** Emit PLUGIN_DISCOVERED when a plugin is found during scan. */
+export function emitPluginDiscovered(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { pluginId: string; path: string; version: string }
+): void {
+  bus.emit('plugins', createEventEnvelope('PLUGIN_DISCOVERED', { type: 'PLUGIN_DISCOVERED', ...data }, ctx));
+}
+
+/** Emit PLUGIN_LOADING when a plugin begins loading. */
+export function emitPluginLoading(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { pluginId: string; path: string }
+): void {
+  bus.emit('plugins', createEventEnvelope('PLUGIN_LOADING', { type: 'PLUGIN_LOADING', ...data }, ctx));
+}
+
+/** Emit PLUGIN_LOADED when a plugin is successfully loaded. */
+export function emitPluginLoaded(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { pluginId: string; version: string; capabilities: string[] }
+): void {
+  bus.emit('plugins', createEventEnvelope('PLUGIN_LOADED', { type: 'PLUGIN_LOADED', ...data }, ctx));
+}
+
+/** Emit PLUGIN_ACTIVE when a plugin is fully active. */
+export function emitPluginActive(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { pluginId: string }
+): void {
+  bus.emit('plugins', createEventEnvelope('PLUGIN_ACTIVE', { type: 'PLUGIN_ACTIVE', ...data }, ctx));
+}
+
+/** Emit PLUGIN_DEGRADED when a plugin loses partial functionality. */
+export function emitPluginDegraded(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { pluginId: string; reason: string; affectedCapabilities: string[] }
+): void {
+  bus.emit('plugins', createEventEnvelope('PLUGIN_DEGRADED', { type: 'PLUGIN_DEGRADED', ...data }, ctx));
+}
+
+/** Emit PLUGIN_ERROR when a plugin encounters an error. */
+export function emitPluginError(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { pluginId: string; error: string; fatal: boolean }
+): void {
+  bus.emit('plugins', createEventEnvelope('PLUGIN_ERROR', { type: 'PLUGIN_ERROR', ...data }, ctx));
+}
+
+/** Emit PLUGIN_UNLOADING when a plugin begins unloading. */
+export function emitPluginUnloading(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { pluginId: string; reason?: string }
+): void {
+  bus.emit('plugins', createEventEnvelope('PLUGIN_UNLOADING', { type: 'PLUGIN_UNLOADING', ...data }, ctx));
+}
+
+/** Emit PLUGIN_DISABLED when a plugin is permanently disabled. */
+export function emitPluginDisabled(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { pluginId: string; reason: string }
+): void {
+  bus.emit('plugins', createEventEnvelope('PLUGIN_DISABLED', { type: 'PLUGIN_DISABLED', ...data }, ctx));
+}

package/src/runtime/emitters/providers.ts

@@ -0,0 +1,30 @@
+/**
+ * Provider emitters — typed emission wrappers for provider events.
+ */
+import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
+import type { RuntimeEventBus } from '../events/index.ts';
+import type { EmitterContext } from './index.ts';
+
+export function emitProvidersChanged(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { added: string[]; removed: string[]; updated: string[] }
+): void {
+  bus.emit('providers', createEventEnvelope('PROVIDERS_CHANGED', { type: 'PROVIDERS_CHANGED', ...data }, ctx));
+}
+
+export function emitProviderWarning(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { message: string }
+): void {
+  bus.emit('providers', createEventEnvelope('PROVIDER_WARNING', { type: 'PROVIDER_WARNING', ...data }, ctx));
+}
+
+export function emitModelFallback(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { from: string; to: string; provider: string }
+): void {
+  bus.emit('providers', createEventEnvelope('MODEL_FALLBACK', { type: 'MODEL_FALLBACK', ...data }, ctx));
+}

package/src/runtime/emitters/routes.ts

@@ -0,0 +1,57 @@
+/**
+ * Route emitters — typed wrappers for RouteEvent domain.
+ */
+
+import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
+import type { RuntimeEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
+import type { RuntimeEventBus } from '../events/index.ts';
+import type { RouteEvent, RouteSurfaceKind, RouteTargetKind } from '@pellux/goodvibes-sdk/platform/runtime/events/routes';
+import type { EmitterContext } from './index.ts';
+
+function routeEvent<T extends RouteEvent['type']>(
+  type: T,
+  data: Omit<Extract<RouteEvent, { type: T }>, 'type'>,
+  ctx: EmitterContext,
+): RuntimeEventEnvelope<T, Extract<RouteEvent, { type: T }>> {
+  return createEventEnvelope(type, { type, ...data } as Extract<RouteEvent, { type: T }>, ctx);
+}
+
+export function emitRouteBindingCreated(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { bindingId: string; surfaceKind: RouteSurfaceKind; externalId: string; targetKind: RouteTargetKind; targetId: string },
+): void {
+  bus.emit('routes', routeEvent('ROUTE_BINDING_CREATED', data, ctx));
+}
+
+export function emitRouteBindingUpdated(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { bindingId: string; changedFields: string[] },
+): void {
+  bus.emit('routes', routeEvent('ROUTE_BINDING_UPDATED', data, ctx));
+}
+
+export function emitRouteBindingResolved(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { bindingId: string; surfaceKind: RouteSurfaceKind; externalId: string; targetKind: RouteTargetKind; targetId: string },
+): void {
+  bus.emit('routes', routeEvent('ROUTE_BINDING_RESOLVED', data, ctx));
+}
+
+export function emitRouteReplyTargetCaptured(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { bindingId: string; surfaceKind: RouteSurfaceKind; externalId: string; replyTargetId: string; threadId: string },
+): void {
+  bus.emit('routes', routeEvent('ROUTE_REPLY_TARGET_CAPTURED', data, ctx));
+}
+
+export function emitRouteBindingFailed(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { surfaceKind: RouteSurfaceKind; externalId: string; error: string },
+): void {
+  bus.emit('routes', routeEvent('ROUTE_BINDING_FAILED', data, ctx));
+}

package/src/runtime/emitters/security.ts

@@ -0,0 +1,53 @@
+/**
+ * Security emitters — typed wrappers for SecurityEvent domain.
+ */
+
+import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
+import type { RuntimeEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
+import type { RuntimeEventBus } from '../events/index.ts';
+import type { SecurityEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/security';
+import type { EmitterContext } from './index.ts';
+
+function securityEvent<T extends SecurityEvent['type']>(
+  type: T,
+  data: Omit<Extract<SecurityEvent, { type: T }>, 'type'>,
+  ctx: EmitterContext,
+): RuntimeEventEnvelope<T, Extract<SecurityEvent, { type: T }>> {
+  return createEventEnvelope(type, { type, ...data } as Extract<SecurityEvent, { type: T }>, ctx);
+}
+
+export function emitTokenScopeViolation(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { tokenId: string; label: string; policyId: string; excessScopes: string[] },
+): void {
+  bus.emit('security', securityEvent('TOKEN_SCOPE_VIOLATION', data, ctx));
+}
+
+export function emitTokenRotationWarning(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { tokenId: string; label: string; msUntilDue: number; dueAt: number; ageMs: number },
+): void {
+  bus.emit('security', securityEvent('TOKEN_ROTATION_WARNING', data, ctx));
+}
+
+export function emitTokenRotationExpired(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { tokenId: string; label: string; ageMs: number; cadenceMs: number; dueAt: number },
+): void {
+  bus.emit('security', securityEvent('TOKEN_ROTATION_EXPIRED', data, ctx));
+}
+
+export function emitTokenBlocked(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: {
+    tokenId: string;
+    label: string;
+    reason: 'scope_violation' | 'rotation_overdue' | 'scope_violation_and_rotation_overdue';
+  },
+): void {
+  bus.emit('security', securityEvent('TOKEN_BLOCKED', data, ctx));
+}

package/src/runtime/emitters/session.ts

@@ -0,0 +1,93 @@
+/**
+ * Session emitters — typed emission wrappers for SessionEvent domain.
+ *
+ * Import and call these instead of emitting raw strings.
+ */
+import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
+import type { RuntimeEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
+import type { RuntimeEventBus } from '../events/index.ts';
+import type { SessionEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/session';
+import type { EmitterContext } from './index.ts';
+
+// ---------------------------------------------------------------------------
+// Internal helper
+// ---------------------------------------------------------------------------
+
+/**
+ * Creates a typed session event envelope, reducing boilerplate across the
+ * 7 public wrapper functions below.
+ */
+function sessionEvent<T extends SessionEvent['type']>(
+  type: T,
+  data: Omit<Extract<SessionEvent, { type: T }>, 'type'>,
+  ctx: EmitterContext,
+): RuntimeEventEnvelope<T, Extract<SessionEvent, { type: T }>> {
+  return createEventEnvelope(type, { type, ...data } as Extract<SessionEvent, { type: T }>, ctx);
+}
+
+// ---------------------------------------------------------------------------
+// Public typed emitter wrappers
+// ---------------------------------------------------------------------------
+
+/** Emit SESSION_STARTED when a new session is created and initialising. */
+export function emitSessionStarted(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { sessionId: string; profileId: string; workingDir: string }
+): void {
+  bus.emit('session', sessionEvent('SESSION_STARTED', data, ctx));
+}
+
+/** Emit SESSION_LOADING when an existing session is being loaded from disk. */
+export function emitSessionLoading(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { sessionId: string; path: string }
+): void {
+  bus.emit('session', sessionEvent('SESSION_LOADING', data, ctx));
+}
+
+/** Emit SESSION_RESUMED when a previously saved session is being resumed. */
+export function emitSessionResumed(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { sessionId: string; turnCount: number }
+): void {
+  bus.emit('session', sessionEvent('SESSION_RESUMED', data, ctx));
+}
+
+/** Emit SESSION_REPAIRING when session state is being repaired after a detected inconsistency. */
+export function emitSessionRepairing(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { sessionId: string; reason: string }
+): void {
+  bus.emit('session', sessionEvent('SESSION_REPAIRING', data, ctx));
+}
+
+/** Emit SESSION_RECONCILING when context messages are being reconciled with stored state. */
+export function emitSessionReconciling(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { sessionId: string; messageCount: number }
+): void {
+  bus.emit('session', sessionEvent('SESSION_RECONCILING', data, ctx));
+}
+
+/** Emit SESSION_READY when session is fully loaded and ready for input. */
+export function emitSessionReady(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { sessionId: string }
+): void {
+  bus.emit('session', sessionEvent('SESSION_READY', data, ctx));
+}
+
+/** Emit SESSION_RECOVERY_FAILED when session recovery has failed unrecoverably. */
+export function emitSessionRecoveryFailed(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { sessionId: string; error: string }
+): void {
+  bus.emit('session', sessionEvent('SESSION_RECOVERY_FAILED', data, ctx));
+}

package/src/runtime/emitters/surfaces.ts

@@ -0,0 +1,57 @@
+/**
+ * Surface emitters — typed wrappers for SurfaceEvent domain.
+ */
+
+import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
+import type { RuntimeEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
+import type { RuntimeEventBus } from '../events/index.ts';
+import type { SurfaceEvent, SurfaceKind } from '@pellux/goodvibes-sdk/platform/runtime/events/surfaces';
+import type { EmitterContext } from './index.ts';
+
+function surfaceEvent<T extends SurfaceEvent['type']>(
+  type: T,
+  data: Omit<Extract<SurfaceEvent, { type: T }>, 'type'>,
+  ctx: EmitterContext,
+): RuntimeEventEnvelope<T, Extract<SurfaceEvent, { type: T }>> {
+  return createEventEnvelope(type, { type, ...data } as Extract<SurfaceEvent, { type: T }>, ctx);
+}
+
+export function emitSurfaceEnabled(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { surfaceKind: SurfaceKind; surfaceId: string; accountId: string },
+): void {
+  bus.emit('surfaces', surfaceEvent('SURFACE_ENABLED', data, ctx));
+}
+
+export function emitSurfaceDisabled(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { surfaceKind: SurfaceKind; surfaceId: string; reason: string },
+): void {
+  bus.emit('surfaces', surfaceEvent('SURFACE_DISABLED', data, ctx));
+}
+
+export function emitSurfaceAccountConnected(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { surfaceKind: SurfaceKind; surfaceId: string; accountId: string; displayName: string },
+): void {
+  bus.emit('surfaces', surfaceEvent('SURFACE_ACCOUNT_CONNECTED', data, ctx));
+}
+
+export function emitSurfaceAccountDegraded(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { surfaceKind: SurfaceKind; surfaceId: string; accountId: string; error: string },
+): void {
+  bus.emit('surfaces', surfaceEvent('SURFACE_ACCOUNT_DEGRADED', data, ctx));
+}
+
+export function emitSurfaceCapabilityChanged(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { surfaceKind: SurfaceKind; surfaceId: string; capability: string; enabled: boolean },
+): void {
+  bus.emit('surfaces', surfaceEvent('SURFACE_CAPABILITY_CHANGED', data, ctx));
+}

package/src/runtime/emitters/tasks.ts

@@ -0,0 +1,69 @@
+/**
+ * Task emitters — typed emission wrappers for TaskEvent domain.
+ */
+import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
+import type { RuntimeEventBus } from '../events/index.ts';
+import type { EmitterContext } from './index.ts';
+
+/** Emit TASK_CREATED when a new task enters the queue. */
+export function emitTaskCreated(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { taskId: string; agentId?: string; description: string; priority: number }
+): void {
+  bus.emit('tasks', createEventEnvelope('TASK_CREATED', { type: 'TASK_CREATED', ...data }, ctx));
+}
+
+/** Emit TASK_STARTED when task execution begins. */
+export function emitTaskStarted(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { taskId: string; agentId?: string }
+): void {
+  bus.emit('tasks', createEventEnvelope('TASK_STARTED', { type: 'TASK_STARTED', ...data }, ctx));
+}
+
+/** Emit TASK_BLOCKED when a task is waiting on a dependency. */
+export function emitTaskBlocked(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { taskId: string; agentId?: string; reason: string }
+): void {
+  bus.emit('tasks', createEventEnvelope('TASK_BLOCKED', { type: 'TASK_BLOCKED', ...data }, ctx));
+}
+
+/** Emit TASK_PROGRESS when a task makes measurable progress. */
+export function emitTaskProgress(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { taskId: string; agentId?: string; progress: number; message?: string }
+): void {
+  bus.emit('tasks', createEventEnvelope('TASK_PROGRESS', { type: 'TASK_PROGRESS', ...data }, ctx));
+}
+
+/** Emit TASK_COMPLETED when a task finishes successfully. */
+export function emitTaskCompleted(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { taskId: string; agentId?: string; durationMs: number }
+): void {
+  bus.emit('tasks', createEventEnvelope('TASK_COMPLETED', { type: 'TASK_COMPLETED', ...data }, ctx));
+}
+
+/** Emit TASK_FAILED when a task fails. */
+export function emitTaskFailed(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { taskId: string; agentId?: string; error: string; durationMs: number }
+): void {
+  bus.emit('tasks', createEventEnvelope('TASK_FAILED', { type: 'TASK_FAILED', ...data }, ctx));
+}
+
+/** Emit TASK_CANCELLED when a task is cancelled. */
+export function emitTaskCancelled(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { taskId: string; agentId?: string; reason?: string }
+): void {
+  bus.emit('tasks', createEventEnvelope('TASK_CANCELLED', { type: 'TASK_CANCELLED', ...data }, ctx));
+}

package/src/runtime/emitters/tools.ts

@@ -0,0 +1,140 @@
+/**
+ * Tool emitters — typed emission wrappers for ToolEvent domain.
+ */
+import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
+import type { RuntimeEventBus } from '../events/index.ts';
+import type { EmitterContext } from './index.ts';
+
+/** Emit TOOL_RECEIVED when a tool call is received from the LLM. */
+export function emitToolReceived(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { callId: string; turnId: string; tool: string; args: Record<string, unknown> }
+): void {
+  bus.emit('tools', createEventEnvelope('TOOL_RECEIVED', { type: 'TOOL_RECEIVED', ...data }, ctx));
+}
+
+/** Emit TOOL_VALIDATED when tool arguments pass schema validation. */
+export function emitToolValidated(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { callId: string; turnId: string; tool: string }
+): void {
+  bus.emit('tools', createEventEnvelope('TOOL_VALIDATED', { type: 'TOOL_VALIDATED', ...data }, ctx));
+}
+
+/** Emit TOOL_PREHOOKED after pre-execution hooks have run. */
+export function emitToolPrehooked(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { callId: string; turnId: string; tool: string }
+): void {
+  bus.emit('tools', createEventEnvelope('TOOL_PREHOOKED', { type: 'TOOL_PREHOOKED', ...data }, ctx));
+}
+
+/** Emit TOOL_PERMISSIONED after permission check completes. */
+export function emitToolPermissioned(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { callId: string; turnId: string; tool: string; approved: boolean }
+): void {
+  bus.emit('tools', createEventEnvelope('TOOL_PERMISSIONED', { type: 'TOOL_PERMISSIONED', ...data }, ctx));
+}
+
+/** Emit TOOL_EXECUTING when the tool starts executing. */
+export function emitToolExecuting(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { callId: string; turnId: string; tool: string; startedAt: number }
+): void {
+  bus.emit('tools', createEventEnvelope('TOOL_EXECUTING', { type: 'TOOL_EXECUTING', ...data }, ctx));
+}
+
+/** Emit TOOL_MAPPED after the result is mapped for the provider. */
+export function emitToolMapped(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { callId: string; turnId: string; tool: string }
+): void {
+  bus.emit('tools', createEventEnvelope('TOOL_MAPPED', { type: 'TOOL_MAPPED', ...data }, ctx));
+}
+
+/** Emit TOOL_POSTHOOKED after post-execution hooks have run. */
+export function emitToolPosthooked(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { callId: string; turnId: string; tool: string }
+): void {
+  bus.emit('tools', createEventEnvelope('TOOL_POSTHOOKED', { type: 'TOOL_POSTHOOKED', ...data }, ctx));
+}
+
+/** Emit TOOL_SUCCEEDED when a tool call completes successfully. */
+export function emitToolSucceeded(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { callId: string; turnId: string; tool: string; durationMs: number; result?: unknown }
+): void {
+  bus.emit('tools', createEventEnvelope('TOOL_SUCCEEDED', { type: 'TOOL_SUCCEEDED', ...data }, ctx));
+}
+
+/** Emit TOOL_FAILED when a tool call fails. */
+export function emitToolFailed(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { callId: string; turnId: string; tool: string; error: string; durationMs: number; result?: unknown }
+): void {
+  bus.emit('tools', createEventEnvelope('TOOL_FAILED', { type: 'TOOL_FAILED', ...data }, ctx));
+}
+
+/** Emit TOOL_RECONCILED when unresolved tool calls are synthesized. */
+export function emitToolReconciled(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: {
+    turnId: string;
+    count: number;
+    callIds: string[];
+    toolNames: string[];
+    reason: string;
+    timestamp: number;
+    isMalformed?: boolean;
+  }
+): void {
+  bus.emit('tools', createEventEnvelope('TOOL_RECONCILED', { type: 'TOOL_RECONCILED', ...data }, ctx));
+}
+
+/** Emit TOOL_CANCELLED when a tool call is cancelled. */
+export function emitToolCancelled(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { callId: string; turnId: string; tool: string; reason?: string }
+): void {
+  bus.emit('tools', createEventEnvelope('TOOL_CANCELLED', { type: 'TOOL_CANCELLED', ...data }, ctx));
+}
+
+/** Emit BUDGET_EXCEEDED_MS when wall-clock time limit is breached. */
+export function emitBudgetExceededMs(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { callId: string; turnId: string; tool: string; phase: string; limitMs: number; elapsedMs: number }
+): void {
+  bus.emit('tools', createEventEnvelope('BUDGET_EXCEEDED_MS', { type: 'BUDGET_EXCEEDED_MS', ...data }, ctx));
+}
+
+/** Emit BUDGET_EXCEEDED_TOKENS when token consumption limit is breached. */
+export function emitBudgetExceededTokens(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { callId: string; turnId: string; tool: string; phase: string; limitTokens: number; usedTokens: number }
+): void {
+  bus.emit('tools', createEventEnvelope('BUDGET_EXCEEDED_TOKENS', { type: 'BUDGET_EXCEEDED_TOKENS', ...data }, ctx));
+}
+
+/** Emit BUDGET_EXCEEDED_COST when cost-in-USD limit is breached. */
+export function emitBudgetExceededCost(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { callId: string; turnId: string; tool: string; phase: string; limitCostUsd: number; usedCostUsd: number }
+): void {
+  bus.emit('tools', createEventEnvelope('BUDGET_EXCEEDED_COST', { type: 'BUDGET_EXCEEDED_COST', ...data }, ctx));
+}

package/src/runtime/emitters/transport.ts

@@ -0,0 +1,78 @@
+/**
+ * Transport emitters — typed emission wrappers for TransportEvent domain.
+ */
+import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
+import type { RuntimeEventBus } from '../events/index.ts';
+import type { EmitterContext } from './index.ts';
+
+/** Emit TRANSPORT_INITIALIZING when the transport layer starts. */
+export function emitTransportInitializing(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { transportId: string; protocol: string }
+): void {
+  bus.emit('transport', createEventEnvelope('TRANSPORT_INITIALIZING', { type: 'TRANSPORT_INITIALIZING', ...data }, ctx));
+}
+
+/** Emit TRANSPORT_AUTHENTICATING when transport auth is in progress. */
+export function emitTransportAuthenticating(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { transportId: string }
+): void {
+  bus.emit('transport', createEventEnvelope('TRANSPORT_AUTHENTICATING', { type: 'TRANSPORT_AUTHENTICATING', ...data }, ctx));
+}
+
+/** Emit TRANSPORT_CONNECTED when the connection is ready. */
+export function emitTransportConnected(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { transportId: string; endpoint: string }
+): void {
+  bus.emit('transport', createEventEnvelope('TRANSPORT_CONNECTED', { type: 'TRANSPORT_CONNECTED', ...data }, ctx));
+}
+
+/** Emit TRANSPORT_SYNCING during state synchronisation. */
+export function emitTransportSyncing(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { transportId: string }
+): void {
+  bus.emit('transport', createEventEnvelope('TRANSPORT_SYNCING', { type: 'TRANSPORT_SYNCING', ...data }, ctx));
+}
+
+/** Emit TRANSPORT_DEGRADED during reduced-reliability operation. */
+export function emitTransportDegraded(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { transportId: string; reason: string }
+): void {
+  bus.emit('transport', createEventEnvelope('TRANSPORT_DEGRADED', { type: 'TRANSPORT_DEGRADED', ...data }, ctx));
+}
+
+/** Emit TRANSPORT_RECONNECTING when retrying after failure. */
+export function emitTransportReconnecting(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { transportId: string; attempt: number; maxAttempts: number }
+): void {
+  bus.emit('transport', createEventEnvelope('TRANSPORT_RECONNECTING', { type: 'TRANSPORT_RECONNECTING', ...data }, ctx));
+}
+
+/** Emit TRANSPORT_DISCONNECTED when the connection closes. */
+export function emitTransportDisconnected(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { transportId: string; reason?: string; willRetry: boolean }
+): void {
+  bus.emit('transport', createEventEnvelope('TRANSPORT_DISCONNECTED', { type: 'TRANSPORT_DISCONNECTED', ...data }, ctx));
+}
+
+/** Emit TRANSPORT_TERMINAL_FAILURE on unrecoverable failure. */
+export function emitTransportTerminalFailure(
+  bus: RuntimeEventBus,
+  ctx: EmitterContext,
+  data: { transportId: string; error: string }
+): void {
+  bus.emit('transport', createEventEnvelope('TRANSPORT_TERMINAL_FAILURE', { type: 'TRANSPORT_TERMINAL_FAILURE', ...data }, ctx));
+}