@pellux/goodvibes-tui 0.18.10 → 0.18.12

package/src/runtime/emitters/forensics.ts

@@ -1,17 +0,0 @@
-import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { EmitterContext } from '@pellux/goodvibes-sdk/platform/runtime/emitters/index';
-
-export function emitForensicsReportCreated(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: {
-    reportId: string;
-    classification: string;
-    errorMessage?: string;
-    taskId?: string;
-    turnId?: string;
-  },
-): void {
-  bus.emit('forensics', createEventEnvelope('FORENSICS_REPORT_CREATED', { type: 'FORENSICS_REPORT_CREATED', ...data }, ctx));
-}

package/src/runtime/emitters/index.ts

@@ -1,59 +0,0 @@
-/**
- * Emitters barrel — re-exports all typed emission wrappers and the EmitterContext.
- *
- * The EmitterContext is the minimal context required by all emitter functions.
- * Construct one from the current session/turn/agent context and pass it through.
- *
- * Usage:
- * ```ts
- * import { emitTurnSubmitted } from '../runtime/emitters/index.ts';
- * import { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
- *
- * const bus = new RuntimeEventBus();
- * const ctx: EmitterContext = { sessionId: '...', traceId: '...', source: 'orchestrator' };
- * emitTurnSubmitted(bus, ctx, { turnId: '...', prompt: 'Hello' });
- * ```
- */
-import type { EnvelopeContext } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
-
-/**
- * Emitter context passed to all emission wrapper functions.
- *
- * Extends EnvelopeContext by narrowing `traceId` from optional to required.
- * Emitter callsites always possess a trace context (e.g. from the active turn
- * or session), so requiring it here prevents accidental fallback to a generated
- * UUID that breaks cross-boundary trace correlation. Compare to EnvelopeContext
- * where `traceId` is optional to support low-level envelope construction without
- * a pre-existing trace.
- */
-export interface EmitterContext extends EnvelopeContext {
-  /** Required trace identifier — must be supplied by the caller at emission time. */
-  readonly traceId: string;
-}
-
-export * from '@pellux/goodvibes-sdk/platform/runtime/emitters/session';
-export * from '@pellux/goodvibes-sdk/platform/runtime/emitters/turn';
-export * from '@pellux/goodvibes-sdk/platform/runtime/emitters/providers';
-export * from '@pellux/goodvibes-sdk/platform/runtime/emitters/tools';
-export * from '@pellux/goodvibes-sdk/platform/runtime/emitters/tasks';
-export * from '@pellux/goodvibes-sdk/platform/runtime/emitters/agents';
-export * from '@pellux/goodvibes-sdk/platform/runtime/emitters/workflows';
-export * from '@pellux/goodvibes-sdk/platform/runtime/emitters/orchestration';
-export * from '@pellux/goodvibes-sdk/platform/runtime/emitters/communication';
-export * from '@pellux/goodvibes-sdk/platform/runtime/emitters/planner';
-export * from '@pellux/goodvibes-sdk/platform/runtime/emitters/permissions';
-export * from '@pellux/goodvibes-sdk/platform/runtime/emitters/plugins';
-export * from '@pellux/goodvibes-sdk/platform/runtime/emitters/mcp';
-export * from '@pellux/goodvibes-sdk/platform/runtime/emitters/transport';
-export * from '@pellux/goodvibes-sdk/platform/runtime/emitters/compaction';
-export * from '@pellux/goodvibes-sdk/platform/runtime/emitters/ui';
-export * from '@pellux/goodvibes-sdk/platform/runtime/emitters/ops';
-export * from '@pellux/goodvibes-sdk/platform/runtime/emitters/forensics';
-export * from '@pellux/goodvibes-sdk/platform/runtime/emitters/security';
-export * from '@pellux/goodvibes-sdk/platform/runtime/emitters/automation';
-export * from '@pellux/goodvibes-sdk/platform/runtime/emitters/routes';
-export * from '@pellux/goodvibes-sdk/platform/runtime/emitters/control-plane';
-export * from '@pellux/goodvibes-sdk/platform/runtime/emitters/deliveries';
-export * from '@pellux/goodvibes-sdk/platform/runtime/emitters/watchers';
-export * from '@pellux/goodvibes-sdk/platform/runtime/emitters/surfaces';
-export * from '@pellux/goodvibes-sdk/platform/runtime/emitters/knowledge';

package/src/runtime/emitters/knowledge.ts

@@ -1,129 +0,0 @@
-/**
- * Knowledge emitters — typed wrappers for KnowledgeEvent 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 '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { KnowledgeEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/knowledge';
-import type { EmitterContext } from '@pellux/goodvibes-sdk/platform/runtime/emitters/index';
-
-function knowledgeEvent<T extends KnowledgeEvent['type']>(
-  type: T,
-  data: Omit<Extract<KnowledgeEvent, { type: T }>, 'type'>,
-  ctx: EmitterContext,
-): RuntimeEventEnvelope<T, Extract<KnowledgeEvent, { type: T }>> {
-  return createEventEnvelope(type, { type, ...data } as Extract<KnowledgeEvent, { type: T }>, ctx);
-}
-
-export function emitKnowledgeIngestStarted(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { sourceId: string; connectorId: string; sourceType: string; uri?: string },
-): void {
-  bus.emit('knowledge', knowledgeEvent('KNOWLEDGE_INGEST_STARTED', data, ctx));
-}
-
-export function emitKnowledgeIngestCompleted(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { sourceId: string; status: string; artifactId?: string; title?: string },
-): void {
-  bus.emit('knowledge', knowledgeEvent('KNOWLEDGE_INGEST_COMPLETED', data, ctx));
-}
-
-export function emitKnowledgeIngestFailed(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { sourceId: string; error: string },
-): void {
-  bus.emit('knowledge', knowledgeEvent('KNOWLEDGE_INGEST_FAILED', data, ctx));
-}
-
-export function emitKnowledgeExtractionCompleted(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { sourceId: string; extractionId: string; format: string; estimatedTokens: number },
-): void {
-  bus.emit('knowledge', knowledgeEvent('KNOWLEDGE_EXTRACTION_COMPLETED', data, ctx));
-}
-
-export function emitKnowledgeExtractionFailed(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { sourceId: string; error: string },
-): void {
-  bus.emit('knowledge', knowledgeEvent('KNOWLEDGE_EXTRACTION_FAILED', data, ctx));
-}
-
-export function emitKnowledgeCompileCompleted(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { sourceId: string; nodeCount: number; edgeCount: number },
-): void {
-  bus.emit('knowledge', knowledgeEvent('KNOWLEDGE_COMPILE_COMPLETED', data, ctx));
-}
-
-export function emitKnowledgeLintCompleted(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { issueCount: number },
-): void {
-  bus.emit('knowledge', knowledgeEvent('KNOWLEDGE_LINT_COMPLETED', data, ctx));
-}
-
-export function emitKnowledgePacketBuilt(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { task: string; itemCount: number; estimatedTokens: number; detail: 'compact' | 'standard' | 'detailed' },
-): void {
-  bus.emit('knowledge', knowledgeEvent('KNOWLEDGE_PACKET_BUILT', data, ctx));
-}
-
-export function emitKnowledgeProjectionRendered(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { targetId: string; pageCount: number },
-): void {
-  bus.emit('knowledge', knowledgeEvent('KNOWLEDGE_PROJECTION_RENDERED', data, ctx));
-}
-
-export function emitKnowledgeProjectionMaterialized(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { targetId: string; artifactId: string; pageCount: number },
-): void {
-  bus.emit('knowledge', knowledgeEvent('KNOWLEDGE_PROJECTION_MATERIALIZED', data, ctx));
-}
-
-export function emitKnowledgeJobQueued(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { jobId: string; runId: string; mode: 'inline' | 'background' },
-): void {
-  bus.emit('knowledge', knowledgeEvent('KNOWLEDGE_JOB_QUEUED', data, ctx));
-}
-
-export function emitKnowledgeJobStarted(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { jobId: string; runId: string; mode: 'inline' | 'background' },
-): void {
-  bus.emit('knowledge', knowledgeEvent('KNOWLEDGE_JOB_STARTED', data, ctx));
-}
-
-export function emitKnowledgeJobCompleted(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { jobId: string; runId: string; durationMs: number },
-): void {
-  bus.emit('knowledge', knowledgeEvent('KNOWLEDGE_JOB_COMPLETED', data, ctx));
-}
-
-export function emitKnowledgeJobFailed(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { jobId: string; runId: string; error: string; durationMs: number },
-): void {
-  bus.emit('knowledge', knowledgeEvent('KNOWLEDGE_JOB_FAILED', data, ctx));
-}

package/src/runtime/emitters/mcp.ts

@@ -1,95 +0,0 @@
-/**
- * MCP emitters — typed emission wrappers for McpEvent domain.
- */
-import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { McpServerRole, McpTrustMode, QuarantineReason } from '@pellux/goodvibes-sdk/platform/runtime/mcp/types';
-import type { EmitterContext } from '@pellux/goodvibes-sdk/platform/runtime/emitters/index';
-
-/** Emit MCP_CONFIGURED when an MCP server config is parsed. */
-export function emitMcpConfigured(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { serverId: string; transport: string; url?: string; role?: McpServerRole; trustMode?: McpTrustMode; allowedPaths?: string[]; allowedHosts?: string[] }
-): void {
-  bus.emit('mcp', createEventEnvelope('MCP_CONFIGURED', { type: 'MCP_CONFIGURED', ...data }, ctx));
-}
-
-/** Emit MCP_CONNECTING when a connection attempt begins. */
-export function emitMcpConnecting(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { serverId: string }
-): void {
-  bus.emit('mcp', createEventEnvelope('MCP_CONNECTING', { type: 'MCP_CONNECTING', ...data }, ctx));
-}
-
-/** Emit MCP_CONNECTED when a connection is established. */
-export function emitMcpConnected(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { serverId: string; toolCount: number; resourceCount: number }
-): void {
-  bus.emit('mcp', createEventEnvelope('MCP_CONNECTED', { type: 'MCP_CONNECTED', ...data }, ctx));
-}
-
-/** Emit MCP_DEGRADED when partial tools are unavailable. */
-export function emitMcpDegraded(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { serverId: string; reason: string; availableTools: string[] }
-): void {
-  bus.emit('mcp', createEventEnvelope('MCP_DEGRADED', { type: 'MCP_DEGRADED', ...data }, ctx));
-}
-
-/** Emit MCP_AUTH_REQUIRED when auth is needed. */
-export function emitMcpAuthRequired(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { serverId: string; authType: string }
-): void {
-  bus.emit('mcp', createEventEnvelope('MCP_AUTH_REQUIRED', { type: 'MCP_AUTH_REQUIRED', ...data }, ctx));
-}
-
-/** Emit MCP_RECONNECTING when retrying a dropped connection. */
-export function emitMcpReconnecting(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { serverId: string; attempt: number; maxAttempts: number }
-): void {
-  bus.emit('mcp', createEventEnvelope('MCP_RECONNECTING', { type: 'MCP_RECONNECTING', ...data }, ctx));
-}
-
-/** Emit MCP_DISCONNECTED when a connection is closed. */
-export function emitMcpDisconnected(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { serverId: string; reason?: string; willRetry: boolean }
-): void {
-  bus.emit('mcp', createEventEnvelope('MCP_DISCONNECTED', { type: 'MCP_DISCONNECTED', ...data }, ctx));
-}
-
-/** Emit MCP_POLICY_UPDATED when server trust posture changes. */
-export function emitMcpPolicyUpdated(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { serverId: string; role: McpServerRole; trustMode: McpTrustMode; allowedPaths: string[]; allowedHosts: string[] }
-): void {
-  bus.emit('mcp', createEventEnvelope('MCP_POLICY_UPDATED', { type: 'MCP_POLICY_UPDATED', ...data }, ctx));
-}
-
-export function emitMcpSchemaQuarantined(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { serverId: string; reason: QuarantineReason; detail?: string }
-): void {
-  bus.emit('mcp', createEventEnvelope('MCP_SCHEMA_QUARANTINED', { type: 'MCP_SCHEMA_QUARANTINED', ...data }, ctx));
-}
-
-export function emitMcpSchemaQuarantineApproved(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { serverId: string; operatorId: string }
-): void {
-  bus.emit('mcp', createEventEnvelope('MCP_SCHEMA_QUARANTINE_APPROVED', { type: 'MCP_SCHEMA_QUARANTINE_APPROVED', ...data }, ctx));
-}

package/src/runtime/emitters/ops.ts

@@ -1,163 +0,0 @@
-/**
- * Ops emitters — typed emission wrappers for the OpsEvent domain.
- *
- * Every intervention emits both a specific action event AND an OPS_AUDIT
- * entry with the reason code, as required by the Operator Control Plane spec.
- */
-import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { EmitterContext } from '@pellux/goodvibes-sdk/platform/runtime/emitters/index';
-import type { OpsInterventionReason } from '@pellux/goodvibes-sdk/platform/runtime/events/ops';
-
-/** Emit OPS_CONTEXT_WARNING when context usage crosses a warning threshold. */
-export function emitOpsContextWarning(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { usage: number; threshold: number }
-): void {
-  bus.emit('ops', createEventEnvelope('OPS_CONTEXT_WARNING', {
-    type: 'OPS_CONTEXT_WARNING',
-    usage: data.usage,
-    threshold: data.threshold,
-  }, ctx));
-}
-
-/** Emit OPS_CACHE_METRICS for cache hit-rate and token accounting snapshots. */
-export function emitOpsCacheMetrics(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: {
-    hitRate: number;
-    cacheReadTokens: number;
-    cacheWriteTokens: number;
-    totalInputTokens: number;
-    turns: number;
-  }
-): void {
-  bus.emit('ops', createEventEnvelope('OPS_CACHE_METRICS', {
-    type: 'OPS_CACHE_METRICS',
-    ...data,
-  }, ctx));
-}
-
-/** Emit OPS_HELPER_USAGE for cumulative helper-model token/call snapshots. */
-export function emitOpsHelperUsage(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { inputTokens: number; outputTokens: number; calls: number }
-): void {
-  bus.emit('ops', createEventEnvelope('OPS_HELPER_USAGE', {
-    type: 'OPS_HELPER_USAGE',
-    ...data,
-  }, ctx));
-}
-
-// ── Generic helper ───────────────────────────────────────────────────────────
-
-type OpsAuditData = {
-  action: string;
-  targetId: string;
-  targetKind: 'task' | 'agent';
-  reason: OpsInterventionReason;
-  note?: string;
-  outcome: 'success' | 'rejected' | 'error';
-  errorMessage?: string;
-  taskId?: string;
-  agentId?: string;
-};
-
-function emitOpsAudit(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: OpsAuditData
-): void {
-  bus.emit('ops', createEventEnvelope('OPS_AUDIT', {
-    type: 'OPS_AUDIT',
-    action: data.action,
-    targetId: data.targetId,
-    targetKind: data.targetKind,
-    reason: data.reason,
-    note: data.note,
-    outcome: data.outcome,
-    errorMessage: data.errorMessage,
-  }, { ...ctx, ...(data.taskId !== undefined ? { taskId: data.taskId } : {}), ...(data.agentId !== undefined ? { agentId: data.agentId } : {}) }));
-}
-
-// ── Task emitters ─────────────────────────────────────────────────────────────
-
-/** Emit OPS_TASK_CANCELLED and a paired OPS_AUDIT event. */
-export function emitOpsTaskCancelled(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { taskId: string; reason: OpsInterventionReason; note?: string; outcome: 'success' | 'rejected' | 'error'; errorMessage?: string }
-): void {
-  bus.emit('ops', createEventEnvelope('OPS_TASK_CANCELLED', {
-    type: 'OPS_TASK_CANCELLED',
-    taskId: data.taskId,
-    reason: data.reason,
-    note: data.note,
-  }, { ...ctx, taskId: data.taskId }));
-  emitOpsAudit(bus, ctx, { action: 'task.cancel', targetId: data.taskId, targetKind: 'task', ...data });
-}
-
-/** Emit OPS_TASK_PAUSED and a paired OPS_AUDIT event. */
-export function emitOpsTaskPaused(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { taskId: string; reason: OpsInterventionReason; note?: string; outcome: 'success' | 'rejected' | 'error'; errorMessage?: string }
-): void {
-  bus.emit('ops', createEventEnvelope('OPS_TASK_PAUSED', {
-    type: 'OPS_TASK_PAUSED',
-    taskId: data.taskId,
-    reason: data.reason,
-    note: data.note,
-  }, { ...ctx, taskId: data.taskId }));
-  emitOpsAudit(bus, ctx, { action: 'task.pause', targetId: data.taskId, targetKind: 'task', ...data });
-}
-
-/** Emit OPS_TASK_RESUMED and a paired OPS_AUDIT event. */
-export function emitOpsTaskResumed(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { taskId: string; reason: OpsInterventionReason; note?: string; outcome: 'success' | 'rejected' | 'error'; errorMessage?: string }
-): void {
-  bus.emit('ops', createEventEnvelope('OPS_TASK_RESUMED', {
-    type: 'OPS_TASK_RESUMED',
-    taskId: data.taskId,
-    reason: data.reason,
-    note: data.note,
-  }, { ...ctx, taskId: data.taskId }));
-  emitOpsAudit(bus, ctx, { action: 'task.resume', targetId: data.taskId, targetKind: 'task', ...data });
-}
-
-/** Emit OPS_TASK_RETRIED and a paired OPS_AUDIT event. */
-export function emitOpsTaskRetried(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { taskId: string; reason: OpsInterventionReason; note?: string; outcome: 'success' | 'rejected' | 'error'; errorMessage?: string }
-): void {
-  bus.emit('ops', createEventEnvelope('OPS_TASK_RETRIED', {
-    type: 'OPS_TASK_RETRIED',
-    taskId: data.taskId,
-    reason: data.reason,
-    note: data.note,
-  }, { ...ctx, taskId: data.taskId }));
-  emitOpsAudit(bus, ctx, { action: 'task.retry', targetId: data.taskId, targetKind: 'task', ...data });
-}
-
-// ── Agent emitters ────────────────────────────────────────────────────────────
-
-/** Emit OPS_AGENT_CANCELLED and a paired OPS_AUDIT event. */
-export function emitOpsAgentCancelled(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { agentId: string; reason: OpsInterventionReason; note?: string; outcome: 'success' | 'rejected' | 'error'; errorMessage?: string }
-): void {
-  bus.emit('ops', createEventEnvelope('OPS_AGENT_CANCELLED', {
-    type: 'OPS_AGENT_CANCELLED',
-    agentId: data.agentId,
-    reason: data.reason,
-    note: data.note,
-  }, { ...ctx, agentId: data.agentId }));
-  emitOpsAudit(bus, ctx, { action: 'agent.cancel', targetId: data.agentId, targetKind: 'agent', ...data });
-}

package/src/runtime/emitters/orchestration.ts

@@ -1,87 +0,0 @@
-/**
- * Orchestration emitters — typed emission wrappers for OrchestrationEvent domain.
- */
-import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { OrchestrationTaskContract } from '@pellux/goodvibes-sdk/platform/runtime/events/orchestration';
-import type { EmitterContext } from '@pellux/goodvibes-sdk/platform/runtime/emitters/index';
-
-export function emitOrchestrationGraphCreated(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { graphId: string; title: string; mode: 'single-worker' | 'parallel-workers' | 'review-loop' | 'graph-execute' },
-): void {
-  bus.emit('orchestration', createEventEnvelope('ORCHESTRATION_GRAPH_CREATED', { type: 'ORCHESTRATION_GRAPH_CREATED', ...data }, ctx));
-}
-
-export function emitOrchestrationNodeAdded(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { graphId: string; nodeId: string; title: string; role: 'planner' | 'engineer' | 'reviewer' | 'fixer' | 'verifier' | 'researcher' | 'integrator'; parentNodeId?: string; dependsOn?: string[]; taskId?: string; agentId?: string; contract?: OrchestrationTaskContract },
-): void {
-  bus.emit('orchestration', createEventEnvelope('ORCHESTRATION_NODE_ADDED', { type: 'ORCHESTRATION_NODE_ADDED', ...data }, ctx));
-}
-
-export function emitOrchestrationNodeReady(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { graphId: string; nodeId: string },
-): void {
-  bus.emit('orchestration', createEventEnvelope('ORCHESTRATION_NODE_READY', { type: 'ORCHESTRATION_NODE_READY', ...data }, ctx));
-}
-
-export function emitOrchestrationNodeStarted(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { graphId: string; nodeId: string; taskId?: string; agentId?: string },
-): void {
-  bus.emit('orchestration', createEventEnvelope('ORCHESTRATION_NODE_STARTED', { type: 'ORCHESTRATION_NODE_STARTED', ...data }, ctx));
-}
-
-export function emitOrchestrationNodeProgress(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { graphId: string; nodeId: string; message: string },
-): void {
-  bus.emit('orchestration', createEventEnvelope('ORCHESTRATION_NODE_PROGRESS', { type: 'ORCHESTRATION_NODE_PROGRESS', ...data }, ctx));
-}
-
-export function emitOrchestrationNodeBlocked(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { graphId: string; nodeId: string; reason: string },
-): void {
-  bus.emit('orchestration', createEventEnvelope('ORCHESTRATION_NODE_BLOCKED', { type: 'ORCHESTRATION_NODE_BLOCKED', ...data }, ctx));
-}
-
-export function emitOrchestrationNodeCompleted(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { graphId: string; nodeId: string; summary?: string },
-): void {
-  bus.emit('orchestration', createEventEnvelope('ORCHESTRATION_NODE_COMPLETED', { type: 'ORCHESTRATION_NODE_COMPLETED', ...data }, ctx));
-}
-
-export function emitOrchestrationNodeFailed(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { graphId: string; nodeId: string; error: string },
-): void {
-  bus.emit('orchestration', createEventEnvelope('ORCHESTRATION_NODE_FAILED', { type: 'ORCHESTRATION_NODE_FAILED', ...data }, ctx));
-}
-
-export function emitOrchestrationNodeCancelled(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { graphId: string; nodeId: string; reason?: string },
-): void {
-  bus.emit('orchestration', createEventEnvelope('ORCHESTRATION_NODE_CANCELLED', { type: 'ORCHESTRATION_NODE_CANCELLED', ...data }, ctx));
-}
-
-export function emitOrchestrationRecursionGuardTriggered(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { graphId: string; nodeId?: string; depth: number; activeAgents: number; reason: string },
-): void {
-  bus.emit('orchestration', createEventEnvelope('ORCHESTRATION_RECURSION_GUARD_TRIGGERED', { type: 'ORCHESTRATION_RECURSION_GUARD_TRIGGERED', ...data }, ctx));
-}

package/src/runtime/emitters/permissions.ts

@@ -1,98 +0,0 @@
-/**
- * Permission emitters — typed emission wrappers for PermissionEvent domain.
- */
-import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { EmitterContext } from '@pellux/goodvibes-sdk/platform/runtime/emitters/index';
-
-/** Emit PERMISSION_REQUESTED when a tool needs a permission decision. */
-export function emitPermissionRequested(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: {
-    callId: string;
-    tool: string;
-    args: Record<string, unknown>;
-    category: string;
-    classification?: string;
-    riskLevel?: string;
-    summary?: string;
-    reasons?: readonly string[];
-  }
-): void {
-  bus.emit('permissions', createEventEnvelope('PERMISSION_REQUESTED', { type: 'PERMISSION_REQUESTED', ...data }, ctx));
-}
-
-/** Emit RULES_COLLECTED after all permission rules are gathered. */
-export function emitRulesCollected(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { callId: string; tool: string; ruleCount: number }
-): void {
-  bus.emit('permissions', createEventEnvelope('RULES_COLLECTED', { type: 'RULES_COLLECTED', ...data }, ctx));
-}
-
-/** Emit INPUT_NORMALIZED after tool args are normalised for policy evaluation. */
-export function emitInputNormalized(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { callId: string; tool: string }
-): void {
-  bus.emit('permissions', createEventEnvelope('INPUT_NORMALIZED', { type: 'INPUT_NORMALIZED', ...data }, ctx));
-}
-
-/** Emit POLICY_EVALUATED after static policy rules are checked. */
-export function emitPolicyEvaluated(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { callId: string; tool: string; result: 'allow' | 'deny' | 'unknown' }
-): void {
-  bus.emit('permissions', createEventEnvelope('POLICY_EVALUATED', { type: 'POLICY_EVALUATED', ...data }, ctx));
-}
-
-/** Emit MODE_EVALUATED after trust mode is checked. */
-export function emitModeEvaluated(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { callId: string; tool: string; mode: string; result: 'allow' | 'deny' | 'unknown' }
-): void {
-  bus.emit('permissions', createEventEnvelope('MODE_EVALUATED', { type: 'MODE_EVALUATED', ...data }, ctx));
-}
-
-/** Emit SESSION_OVERRIDE_EVALUATED after session always-allow list is checked. */
-export function emitSessionOverrideEvaluated(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { callId: string; tool: string; overrideApplied: boolean }
-): void {
-  bus.emit('permissions', createEventEnvelope('SESSION_OVERRIDE_EVALUATED', { type: 'SESSION_OVERRIDE_EVALUATED', ...data }, ctx));
-}
-
-/** Emit SAFETY_CHECKED after safety validation (path traversal, etc.) runs. */
-export function emitSafetyChecked(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { callId: string; tool: string; safe: boolean; warnings: string[] }
-): void {
-  bus.emit('permissions', createEventEnvelope('SAFETY_CHECKED', { type: 'SAFETY_CHECKED', ...data }, ctx));
-}
-
-/** Emit DECISION_EMITTED when the final permission decision is made. */
-export function emitPermissionDecision(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: {
-    callId: string;
-    tool: string;
-    approved: boolean;
-    source: string;
-    sourceLayer?: string;
-    persisted?: boolean;
-    reasonCode?: string;
-    classification?: string;
-    riskLevel?: string;
-    summary?: string;
-  }
-): void {
-  bus.emit('permissions', createEventEnvelope('DECISION_EMITTED', { type: 'DECISION_EMITTED', ...data }, ctx));
-}

package/src/runtime/emitters/planner.ts

@@ -1,23 +0,0 @@
-/**
- * Planner emitters — typed emission wrappers for adaptive planner events.
- */
-import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { EmitterContext } from '@pellux/goodvibes-sdk/platform/runtime/emitters/index';
-import type { PlannerDecision, ExecutionStrategy } from '@pellux/goodvibes-sdk/platform/core/adaptive-planner';
-
-export function emitPlanStrategySelected(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  decision: PlannerDecision
-): void {
-  bus.emit('planner', createEventEnvelope('PLAN_STRATEGY_SELECTED', { type: 'PLAN_STRATEGY_SELECTED', ...decision }, ctx));
-}
-
-export function emitPlanStrategyOverridden(
-  bus: RuntimeEventBus,
-  ctx: EmitterContext,
-  data: { strategy: ExecutionStrategy | null; clearedBy?: string }
-): void {
-  bus.emit('planner', createEventEnvelope('PLAN_STRATEGY_OVERRIDDEN', { type: 'PLAN_STRATEGY_OVERRIDDEN', ...data }, ctx));
-}