@pellux/goodvibes-sdk 0.18.13 → 0.18.15

package/dist/_internal/platform/runtime/eval/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Evaluation Harness — barrel export.
+ *
+ * Provides the eval runner, scorecard scorer, built-in suites,
+ * and baseline persistence utilities.
+ *
+ * @example
+ * ```ts
+ * import { EvalRunner, BUILTIN_SUITES, captureBaseline, loadBaseline } from './eval/index.js';
+ *
+ * const runner = new EvalRunner();
+ * const result = await runner.runSuite('core-performance', BUILTIN_SUITES['core-performance']);
+ * const gate = runner.evaluateGate(result, await loadBaseline('.goodvibes/eval/baseline.json'));
+ * if (!gate.passed) process.exit(1);
+ * ```
+ */
+export type { EvalScenario, EvalRawResult, EvalResult, EvalSuiteResult, EvalScorecard, EvalBaseline, EvalGateResult, EvalDimension, DimensionScore, RegressionEntry, BaselineSuiteSummary, } from '@pellux/goodvibes-sdk/platform/runtime/eval/types';
+export { EvalRunner } from './runner.js';
+export type { EvalRunnerOptions } from './runner.js';
+export { scoreScenario, formatScorecard, DIMENSION_FLOOR } from '@pellux/goodvibes-sdk/platform/runtime/eval/scorecard';
+export { BUILTIN_SUITES, ALL_SCENARIOS } from './suites.js';
+export { captureBaseline, serialiseBaseline, deserialiseBaseline, writeBaseline, loadBaseline, formatBaselineComparison, } from '@pellux/goodvibes-sdk/platform/runtime/eval/baseline';
+export { formatSuiteResult, formatGateResult } from '@pellux/goodvibes-sdk/platform/runtime/eval/format';
+//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/runtime/eval/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/eval/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,YAAY,EACV,YAAY,EACZ,aAAa,EACb,UAAU,EACV,eAAe,EACf,aAAa,EACb,YAAY,EACZ,cAAc,EACd,aAAa,EACb,cAAc,EACd,eAAe,EACf,oBAAoB,GACrB,MAAM,mDAAmD,CAAC;AAE3D,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,uDAAuD,CAAC;AAExH,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5D,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,mBAAmB,EACnB,aAAa,EACb,YAAY,EACZ,wBAAwB,GACzB,MAAM,sDAAsD,CAAC;AAE9D,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,oDAAoD,CAAC"}

package/dist/_internal/platform/runtime/eval/index.js

@@ -0,0 +1,21 @@
+/**
+ * Evaluation Harness — barrel export.
+ *
+ * Provides the eval runner, scorecard scorer, built-in suites,
+ * and baseline persistence utilities.
+ *
+ * @example
+ * ```ts
+ * import { EvalRunner, BUILTIN_SUITES, captureBaseline, loadBaseline } from './eval/index.js';
+ *
+ * const runner = new EvalRunner();
+ * const result = await runner.runSuite('core-performance', BUILTIN_SUITES['core-performance']);
+ * const gate = runner.evaluateGate(result, await loadBaseline('.goodvibes/eval/baseline.json'));
+ * if (!gate.passed) process.exit(1);
+ * ```
+ */
+export { EvalRunner } from './runner.js';
+export { scoreScenario, formatScorecard, DIMENSION_FLOOR } from '@pellux/goodvibes-sdk/platform/runtime/eval/scorecard';
+export { BUILTIN_SUITES, ALL_SCENARIOS } from './suites.js';
+export { captureBaseline, serialiseBaseline, deserialiseBaseline, writeBaseline, loadBaseline, formatBaselineComparison, } from '@pellux/goodvibes-sdk/platform/runtime/eval/baseline';
+export { formatSuiteResult, formatGateResult } from '@pellux/goodvibes-sdk/platform/runtime/eval/format';

package/dist/_internal/platform/runtime/eval/runner.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Evaluation Harness — EvalRunner.
+ *
+ * Runs eval suites using production runtime paths:
+ * - PerfMonitor for budget evaluation
+ * - SloCollector for SLO p95 measurements
+ * - scoreScenario() for dimension scoring
+ *
+ * The runner does not mock any dependencies — it exercises the real
+ * production code paths that gate CI.
+ */
+import type { EvalScenario, EvalSuiteResult, EvalGateResult, EvalBaseline } from '@pellux/goodvibes-sdk/platform/runtime/eval/types';
+export interface EvalRunnerOptions {
+    /**
+     * Regression threshold for gate comparisons.
+     * A scenario regresses if its composite score drops by more than this amount.
+     * Default: 5 (5-point drop).
+     */
+    regressionThreshold?: number;
+}
+/**
+ * Runs eval suites and produces structured results.
+ *
+ * @example
+ * ```ts
+ * const runner = new EvalRunner();
+ * const result = await runner.runSuite(mySuite);
+ * if (!result.passed) process.exit(1);
+ * ```
+ */
+export declare class EvalRunner {
+    private readonly regressionThreshold;
+    constructor(options?: EvalRunnerOptions);
+    /**
+     * Run all scenarios in a suite sequentially.
+     *
+     * Each scenario:
+     * 1. Calls scenario.run() via the production code path
+     * 2. Evaluates the raw result through PerfMonitor (if perfReport is absent)
+     * 3. Scores the result via scoreScenario()
+     *
+     * @param suite - Suite name (used for logging and baseline matching).
+     * @param scenarios - Scenarios to run.
+     * @returns Aggregated EvalSuiteResult.
+     */
+    runSuite(suite: string, scenarios: EvalScenario[]): Promise<EvalSuiteResult>;
+    /**
+     * Compare a fresh suite result against a stored baseline.
+     * Produces an EvalGateResult indicating whether CI should pass.
+     *
+     * @param fresh - Result from a freshly-run suite.
+     * @param baseline - Previously stored baseline (may be undefined).
+     * @returns Gate result with per-scenario regression entries.
+     */
+    evaluateGate(fresh: EvalSuiteResult, baseline: EvalBaseline | undefined): EvalGateResult;
+    private _runScenario;
+    /** Execute a scenario's run() function, catching and normalising errors. */
+    private _executeScenario;
+}
+//# sourceMappingURL=runner.d.ts.map

package/dist/_internal/platform/runtime/eval/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/eval/runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,YAAY,EAA6B,eAAe,EAAE,cAAc,EAAE,YAAY,EAAmB,MAAM,mDAAmD,CAAC;AAOjL,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;;;;GASG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAS;gBAEjC,OAAO,GAAE,iBAAsB;IAI3C;;;;;;;;;;;OAWG;IACG,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,eAAe,CAAC;IAoBlF;;;;;;;OAOG;IACH,YAAY,CAAC,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,YAAY,GAAG,SAAS,GAAG,cAAc;YAoC1E,YAAY;IAwB1B,4EAA4E;YAC9D,gBAAgB;CAgB/B"}

package/dist/_internal/platform/runtime/eval/runner.js

@@ -0,0 +1,135 @@
+/**
+ * Evaluation Harness — EvalRunner.
+ *
+ * Runs eval suites using production runtime paths:
+ * - PerfMonitor for budget evaluation
+ * - SloCollector for SLO p95 measurements
+ * - scoreScenario() for dimension scoring
+ *
+ * The runner does not mock any dependencies — it exercises the real
+ * production code paths that gate CI.
+ */
+import { scoreScenario } from '@pellux/goodvibes-sdk/platform/runtime/eval/scorecard';
+import { createPerfMonitor } from '../perf/index.js';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+/**
+ * Runs eval suites and produces structured results.
+ *
+ * @example
+ * ```ts
+ * const runner = new EvalRunner();
+ * const result = await runner.runSuite(mySuite);
+ * if (!result.passed) process.exit(1);
+ * ```
+ */
+export class EvalRunner {
+    regressionThreshold;
+    constructor(options = {}) {
+        this.regressionThreshold = options.regressionThreshold ?? 5;
+    }
+    /**
+     * Run all scenarios in a suite sequentially.
+     *
+     * Each scenario:
+     * 1. Calls scenario.run() via the production code path
+     * 2. Evaluates the raw result through PerfMonitor (if perfReport is absent)
+     * 3. Scores the result via scoreScenario()
+     *
+     * @param suite - Suite name (used for logging and baseline matching).
+     * @param scenarios - Scenarios to run.
+     * @returns Aggregated EvalSuiteResult.
+     */
+    async runSuite(suite, scenarios) {
+        const startedAt = Date.now();
+        const results = [];
+        for (const scenario of scenarios) {
+            const result = await this._runScenario(scenario);
+            results.push(result);
+        }
+        const finishedAt = Date.now();
+        const meanScore = results.length > 0
+            ? results.reduce((acc, r) => acc + r.scorecard.compositeScore, 0) / results.length
+            : 0;
+        const passed = results.every((r) => r.scorecard.passed);
+        return { suite, startedAt, finishedAt, results, meanScore, passed };
+    }
+    /**
+     * Compare a fresh suite result against a stored baseline.
+     * Produces an EvalGateResult indicating whether CI should pass.
+     *
+     * @param fresh - Result from a freshly-run suite.
+     * @param baseline - Previously stored baseline (may be undefined).
+     * @returns Gate result with per-scenario regression entries.
+     */
+    evaluateGate(fresh, baseline) {
+        const regressions = [];
+        if (baseline) {
+            const baselineSuite = baseline.suites[fresh.suite];
+            if (baselineSuite) {
+                for (const result of fresh.results) {
+                    const baselineScore = baselineSuite.scenarioScores[result.scenario.id];
+                    if (baselineScore === undefined)
+                        continue;
+                    const freshScore = result.scorecard.compositeScore;
+                    const delta = freshScore - baselineScore;
+                    if (delta < -this.regressionThreshold) {
+                        regressions.push({
+                            scenarioId: result.scenario.id,
+                            scenarioName: result.scenario.name,
+                            baselineScore,
+                            freshScore,
+                            delta,
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            suite: fresh.suite,
+            passed: regressions.length === 0,
+            regressionThreshold: this.regressionThreshold,
+            fresh,
+            baseline,
+            regressions,
+        };
+    }
+    // ── Internal ────────────────────────────────────────────────────────────────
+    async _runScenario(scenario) {
+        const startedAt = Date.now();
+        let raw = await this._executeScenario(scenario);
+        // If the scenario did not include a perfReport, run a minimal PerfMonitor
+        // evaluation against an empty snapshot to at least populate the field.
+        if (!raw.perfReport) {
+            const monitor = createPerfMonitor();
+            const { createInitialSurfacePerfState } = await import('@pellux/goodvibes-sdk/platform/runtime/store/domains/surface-perf');
+            raw = {
+                ...raw,
+                perfReport: monitor.evaluate({
+                    surfacePerf: createInitialSurfacePerfState(),
+                    extraMetrics: {},
+                }),
+            };
+        }
+        const scorecard = scoreScenario(scenario.id, scenario.name, raw);
+        const finishedAt = Date.now();
+        return { scenario, raw, scorecard, startedAt, finishedAt };
+    }
+    /** Execute a scenario's run() function, catching and normalising errors. */
+    async _executeScenario(scenario) {
+        const t0 = Date.now();
+        try {
+            const raw = await scenario.run();
+            return raw;
+        }
+        catch (err) {
+            const durationMs = Date.now() - t0;
+            const errorMessage = summarizeError(err);
+            return {
+                completed: false,
+                durationMs,
+                errorMessage,
+                safetyViolations: 0,
+            };
+        }
+    }
+}

package/dist/_internal/platform/runtime/eval/suites.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Evaluation Harness — built-in benchmark suites.
+ *
+ * These suites are the stable benchmark set checked in CI.
+ * Scenarios exercise production runtime paths and report real measurements.
+ *
+ * Each scenario's id must be stable across runs — it is used as the
+ * baseline key for regression detection.
+ */
+import type { EvalScenario } from '@pellux/goodvibes-sdk/platform/runtime/eval/types';
+/**
+ * All built-in benchmark suites.
+ *
+ * Suite names are stable — used as keys in baselines.
+ */
+export declare const BUILTIN_SUITES: Record<string, EvalScenario[]>;
+/** Flat list of all built-in scenarios (across all suites). */
+export declare const ALL_SCENARIOS: EvalScenario[];
+//# sourceMappingURL=suites.d.ts.map

package/dist/_internal/platform/runtime/eval/suites.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suites.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/eval/suites.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAiB,MAAM,mDAAmD,CAAC;AAiPrG;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,CAIzD,CAAC;AAEF,+DAA+D;AAC/D,eAAO,MAAM,aAAa,EAAE,YAAY,EAAyC,CAAC"}

package/dist/_internal/platform/runtime/eval/suites.js

@@ -0,0 +1,231 @@
+/**
+ * Evaluation Harness — built-in benchmark suites.
+ *
+ * These suites are the stable benchmark set checked in CI.
+ * Scenarios exercise production runtime paths and report real measurements.
+ *
+ * Each scenario's id must be stable across runs — it is used as the
+ * baseline key for regression detection.
+ */
+import { createPerfMonitor } from '../perf/index.js';
+import { createInitialSurfacePerfState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/surface-perf';
+// ── Helpers ───────────────────────────────────────────────────────────────────
+/** Simulate a synthetic render cycle burst and return timing samples. */
+function syntheticRenderCycles(count, targetMs) {
+    const durations = [];
+    for (let i = 0; i < count; i++) {
+        // Simulate deterministic render work proportional to target
+        const durationMs = targetMs * (0.5 + (i / count) * 0.5);
+        durations.push(durationMs);
+    }
+    return durations;
+}
+// ── Core Performance Suite ────────────────────────────────────────────────────
+/**
+ * Scenarios that validate the PerfMonitor + budget evaluation path.
+ * These use production PerfMonitor instances with real budget definitions.
+ */
+const corePerformanceScenarios = [
+    {
+        id: 'core-perf:render-p95-under-budget',
+        name: 'Frame Render p95 Under Budget',
+        suite: 'core-performance',
+        description: 'Verifies that PerfMonitor correctly passes when render p95 stays under the 16ms budget.',
+        tags: ['latency', 'render', 'budget'],
+        async run() {
+            const t0 = Date.now();
+            const monitor = createPerfMonitor();
+            const surfacePerf = createInitialSurfacePerfState();
+            // Inject fast render cycles (well under budget)
+            const durations = syntheticRenderCycles(60, 8); // 8ms average
+            const cycles = durations.map((durationMs, i) => ({
+                cycleId: i,
+                requestedAt: t0 + i * 16,
+                completedAt: t0 + i * 16 + durationMs,
+                durationMs,
+                overBudget: durationMs > 16,
+            }));
+            surfacePerf.recentCycles = cycles;
+            surfacePerf.heapUsedBytes = 50 * 1024 * 1024; // 50 MiB stable
+            const perfReport = monitor.evaluate({
+                surfacePerf,
+                extraMetrics: {
+                    'event.queue.depth': 10,
+                    'tool.executor.overhead.p95': 2,
+                    'compaction.latency.p95': 100,
+                    'slo.turn_start.p95': 800,
+                    'slo.cancel.p95': 150,
+                    'slo.reconnect_recovery.p95': 3000,
+                    'slo.permission_decision.p95': 40,
+                },
+            });
+            return {
+                completed: true,
+                durationMs: Date.now() - t0,
+                perfReport,
+                safetyViolations: 0,
+            };
+        },
+    },
+    {
+        id: 'core-perf:slo-turn-start-latency',
+        name: 'SLO Turn Start Latency Under Budget',
+        suite: 'core-performance',
+        description: 'Verifies SLO gate for turn_start.p95 stays under the 2000ms budget.',
+        tags: ['latency', 'slo', 'turn'],
+        async run() {
+            const t0 = Date.now();
+            const monitor = createPerfMonitor();
+            const surfacePerf = createInitialSurfacePerfState();
+            surfacePerf.heapUsedBytes = 60 * 1024 * 1024;
+            const perfReport = monitor.evaluate({
+                surfacePerf,
+                extraMetrics: {
+                    'event.queue.depth': 50,
+                    'tool.executor.overhead.p95': 3,
+                    'compaction.latency.p95': 200,
+                    'slo.turn_start.p95': 1200,
+                    'slo.cancel.p95': 200,
+                    'slo.reconnect_recovery.p95': 4000,
+                    'slo.permission_decision.p95': 60,
+                },
+            });
+            return {
+                completed: true,
+                durationMs: Date.now() - t0,
+                perfReport,
+                safetyViolations: 0,
+            };
+        },
+    },
+    {
+        id: 'core-perf:memory-growth-stable',
+        name: 'Memory Growth Rate Stable',
+        suite: 'core-performance',
+        description: 'Verifies the memory growth budget passes when heap is stable.',
+        tags: ['memory', 'budget'],
+        async run() {
+            const t0 = Date.now();
+            const monitor = createPerfMonitor();
+            const surfacePerf = createInitialSurfacePerfState();
+            // Simulate two consecutive evaluations with negligible heap growth
+            surfacePerf.heapUsedBytes = 80 * 1024 * 1024;
+            surfacePerf.lastMemorySampleAt = t0 - 60_000; // 1 minute ago
+            monitor.evaluate({ surfacePerf, extraMetrics: {} }); // prime the monitor
+            surfacePerf.heapUsedBytes = 80 * 1024 * 1024 + 512 * 1024; // +512 KiB over 1 min
+            surfacePerf.lastMemorySampleAt = t0;
+            const perfReport = monitor.evaluate({ surfacePerf, extraMetrics: {} });
+            return {
+                completed: true,
+                durationMs: Date.now() - t0,
+                perfReport,
+                safetyViolations: 0,
+            };
+        },
+    },
+];
+// ── Safety Baseline Suite ─────────────────────────────────────────────────────
+/**
+ * Scenarios that validate safety evaluation paths.
+ * These check that the safety scorer correctly grades clean runs.
+ */
+const safetyBaselineScenarios = [
+    {
+        id: 'safety:clean-run-no-violations',
+        name: 'Clean Run — No Safety Violations',
+        suite: 'safety-baseline',
+        description: 'Verifies a clean scenario run scores 100 on the safety dimension.',
+        tags: ['safety'],
+        async run() {
+            const t0 = Date.now();
+            return {
+                completed: true,
+                durationMs: Date.now() - t0,
+                safetyViolations: 0,
+            };
+        },
+    },
+    {
+        id: 'safety:recovery-success',
+        name: 'Recovery Path — Succeeded',
+        suite: 'safety-baseline',
+        description: 'Validates that a successfully recovered scenario scores correctly on recovery dimension.',
+        tags: ['safety', 'recovery'],
+        async run() {
+            const t0 = Date.now();
+            return {
+                completed: true,
+                durationMs: Date.now() - t0,
+                safetyViolations: 0,
+                recoverySucceeded: true,
+            };
+        },
+    },
+    {
+        id: 'safety:recovery-failure-score',
+        name: 'Recovery Path — Failed (Score Validation)',
+        suite: 'safety-baseline',
+        description: 'Validates that a failed recovery scenario scores below the recovery floor, ' +
+            'and that the gate correctly flags it.',
+        tags: ['safety', 'recovery'],
+        async run() {
+            const t0 = Date.now();
+            // Intentionally reports a failed recovery to exercise the scorer path.
+            // The scenario itself completes; the low recovery score is expected.
+            return {
+                completed: true,
+                durationMs: Date.now() - t0,
+                safetyViolations: 0,
+                recoveryFailed: true,
+            };
+        },
+    },
+];
+// ── Cost & Token Suite ────────────────────────────────────────────────────────
+const costTokenScenarios = [
+    {
+        id: 'cost:no-token-usage',
+        name: 'No Token Usage (Score = 100)',
+        suite: 'cost-tokens',
+        description: 'Verifies that scenarios without token usage receive full cost score.',
+        tags: ['cost'],
+        async run() {
+            const t0 = Date.now();
+            return {
+                completed: true,
+                durationMs: Date.now() - t0,
+                safetyViolations: 0,
+            };
+        },
+    },
+    {
+        id: 'cost:low-token-usage',
+        name: 'Low Token Usage — Under Target',
+        suite: 'cost-tokens',
+        description: 'Validates that minimal token usage stays within the cost budget.',
+        tags: ['cost', 'tokens'],
+        async run() {
+            const t0 = Date.now();
+            return {
+                completed: true,
+                durationMs: Date.now() - t0,
+                tokens: { input: 500, output: 100 },
+                costUsd: 0.0005, // under $0.001 target
+                safetyViolations: 0,
+            };
+        },
+    },
+];
+// ── Registry ──────────────────────────────────────────────────────────────────
+/**
+ * All built-in benchmark suites.
+ *
+ * Suite names are stable — used as keys in baselines.
+ */
+export const BUILTIN_SUITES = {
+    'core-performance': corePerformanceScenarios,
+    'safety-baseline': safetyBaselineScenarios,
+    'cost-tokens': costTokenScenarios,
+};
+/** Flat list of all built-in scenarios (across all suites). */
+export const ALL_SCENARIOS = Object.values(BUILTIN_SUITES).flat();

package/dist/_internal/platform/runtime/events/domain-map.d.ts

@@ -0,0 +1,87 @@
+/**
+ * RuntimeEventMap — master mapping of all typed runtime event types to their payloads.
+ *
+ * Used by RuntimeEventBus for type-safe subscriptions. Combine all domain
+ * discriminated union members into a single flat map keyed by the type string.
+ */
+import type { SessionEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/session';
+import type { TurnEvent } from './turn.js';
+import type { ProviderEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/providers';
+import type { ToolEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/tools';
+import type { TaskEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/tasks';
+import type { AgentEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/agents';
+import type { WorkflowEvent } from './workflows.js';
+import type { OrchestrationEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/orchestration';
+import type { CommunicationEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/communication';
+import type { PlannerEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/planner';
+import type { PermissionEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/permissions';
+import type { PluginEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/plugins';
+import type { McpEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/mcp';
+import type { TransportEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/transport';
+import type { CompactionEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/compaction';
+import type { UIEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/ui';
+import type { OpsEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/ops';
+import type { ForensicsEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/forensics';
+import type { SecurityEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/security';
+import type { AutomationEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/automation';
+import type { RouteEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/routes';
+import type { ControlPlaneEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/control-plane';
+import type { DeliveryEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/deliveries';
+import type { WatcherEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/watchers';
+import type { SurfaceEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/surfaces';
+import type { KnowledgeEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/knowledge';
+/** Union of all runtime domain events. */
+export type AnyRuntimeEvent = SessionEvent | TurnEvent | ProviderEvent | ToolEvent | TaskEvent | AgentEvent | WorkflowEvent | OrchestrationEvent | CommunicationEvent | PlannerEvent | PermissionEvent | PluginEvent | McpEvent | TransportEvent | CompactionEvent | UIEvent | OpsEvent | ForensicsEvent | SecurityEvent | AutomationEvent | RouteEvent | ControlPlaneEvent | DeliveryEvent | WatcherEvent | SurfaceEvent | KnowledgeEvent;
+/**
+ * Utility type that maps an event type discriminant to its full event shape.
+ *
+ * Example:
+ * ```ts
+ * type Payload = RuntimeEventPayload<'TURN_SUBMITTED'>;
+ * // => { type: 'TURN_SUBMITTED'; turnId: string; prompt: string }
+ * ```
+ */
+export type RuntimeEventPayload<T extends AnyRuntimeEvent['type']> = Extract<AnyRuntimeEvent, {
+    type: T;
+}>;
+/**
+ * Domain labels for use with domain-scoped subscriptions.
+ *
+ * This is the source-of-truth vocabulary for runtime transport/event surfaces.
+ */
+export declare const RUNTIME_EVENT_DOMAINS: readonly ["session", "turn", "providers", "tools", "tasks", "agents", "workflows", "orchestration", "communication", "planner", "permissions", "plugins", "mcp", "transport", "compaction", "ui", "ops", "forensics", "security", "automation", "routes", "control-plane", "deliveries", "watchers", "surfaces", "knowledge"];
+/**
+ * Domain label type for use with domain-scoped subscriptions.
+ */
+export type RuntimeEventDomain = typeof RUNTIME_EVENT_DOMAINS[number];
+export declare function isRuntimeEventDomain(value: string): value is RuntimeEventDomain;
+/** Map from domain label to its event union type. */
+export type DomainEventMap = {
+    session: SessionEvent;
+    turn: TurnEvent;
+    providers: ProviderEvent;
+    tools: ToolEvent;
+    tasks: TaskEvent;
+    agents: AgentEvent;
+    workflows: WorkflowEvent;
+    orchestration: OrchestrationEvent;
+    communication: CommunicationEvent;
+    planner: PlannerEvent;
+    permissions: PermissionEvent;
+    plugins: PluginEvent;
+    mcp: McpEvent;
+    transport: TransportEvent;
+    compaction: CompactionEvent;
+    ui: UIEvent;
+    ops: OpsEvent;
+    forensics: ForensicsEvent;
+    security: SecurityEvent;
+    automation: AutomationEvent;
+    routes: RouteEvent;
+    'control-plane': ControlPlaneEvent;
+    deliveries: DeliveryEvent;
+    watchers: WatcherEvent;
+    surfaces: SurfaceEvent;
+    knowledge: KnowledgeEvent;
+};
+//# sourceMappingURL=domain-map.d.ts.map

package/dist/_internal/platform/runtime/events/domain-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-map.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/events/domain-map.ts"],"names":[],"mappings":"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"}

package/dist/_internal/platform/runtime/events/domain-map.js

@@ -0,0 +1,36 @@
+/**
+ * Domain labels for use with domain-scoped subscriptions.
+ *
+ * This is the source-of-truth vocabulary for runtime transport/event surfaces.
+ */
+export const RUNTIME_EVENT_DOMAINS = [
+    'session',
+    'turn',
+    'providers',
+    'tools',
+    'tasks',
+    'agents',
+    'workflows',
+    'orchestration',
+    'communication',
+    'planner',
+    'permissions',
+    'plugins',
+    'mcp',
+    'transport',
+    'compaction',
+    'ui',
+    'ops',
+    'forensics',
+    'security',
+    'automation',
+    'routes',
+    'control-plane',
+    'deliveries',
+    'watchers',
+    'surfaces',
+    'knowledge',
+];
+export function isRuntimeEventDomain(value) {
+    return RUNTIME_EVENT_DOMAINS.includes(value);
+}