@pellux/goodvibes-tui 0.18.4

package/src/runtime/emitters/index.ts

@@ -0,0 +1,59 @@
+/**
+ * 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 '../runtime/events/index.ts';
+ *
+ * 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 './session.ts';
+export * from './turn.ts';
+export * from './providers.ts';
+export * from './tools.ts';
+export * from './tasks.ts';
+export * from './agents.ts';
+export * from './workflows.ts';
+export * from './orchestration.ts';
+export * from './communication.ts';
+export * from './planner.ts';
+export * from './permissions.ts';
+export * from './plugins.ts';
+export * from './mcp.ts';
+export * from './transport.ts';
+export * from './compaction.ts';
+export * from './ui.ts';
+export * from './ops.ts';
+export * from './forensics.ts';
+export * from './security.ts';
+export * from './automation.ts';
+export * from './routes.ts';
+export * from './control-plane.ts';
+export * from './deliveries.ts';
+export * from './watchers.ts';
+export * from './surfaces.ts';
+export * from './knowledge.ts';

package/src/runtime/emitters/knowledge.ts

@@ -0,0 +1,129 @@
+/**
+ * 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 '../events/index.ts';
+import type { KnowledgeEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/knowledge';
+import type { EmitterContext } from './index.ts';
+
+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

@@ -0,0 +1,95 @@
+/**
+ * MCP emitters — typed emission wrappers for McpEvent domain.
+ */
+import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
+import type { RuntimeEventBus } from '../events/index.ts';
+import type { McpServerRole, McpTrustMode, QuarantineReason } from '@pellux/goodvibes-sdk/platform/runtime/mcp/types';
+import type { EmitterContext } from './index.ts';
+
+/** 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

@@ -0,0 +1,163 @@
+/**
+ * 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 '../events/index.ts';
+import type { EmitterContext } from './index.ts';
+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

@@ -0,0 +1,87 @@
+/**
+ * Orchestration emitters — typed emission wrappers for OrchestrationEvent domain.
+ */
+import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
+import type { RuntimeEventBus } from '../events/index.ts';
+import type { OrchestrationTaskContract } from '@pellux/goodvibes-sdk/platform/runtime/events/orchestration';
+import type { EmitterContext } from './index.ts';
+
+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

@@ -0,0 +1,98 @@
+/**
+ * Permission emitters — typed emission wrappers for PermissionEvent 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 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

@@ -0,0 +1,23 @@
+/**
+ * Planner emitters — typed emission wrappers for adaptive planner events.
+ */
+import { createEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/envelope';
+import type { RuntimeEventBus } from '../events/index.ts';
+import type { EmitterContext } from './index.ts';
+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));
+}