@evalops/maestro 0.10.8 → 0.10.11

package/dist/telemetry/maestro-event-bus.js

@@ -0,0 +1,784 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomUUID } from "node:crypto";
+import { MaestroBusEventType, getMaestroBusEventCatalogEntry, } from "./maestro-event-catalog.js";
+export { MaestroBusEventType } from "./maestro-event-catalog.js";
+let transportOverride;
+const scopedTransportOverride = new AsyncLocalStorage();
+let natsTransportPromise;
+function readEnv(env, names) {
+    for (const name of names) {
+        const value = env[name]?.trim();
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+function readBoolean(value) {
+    if (!value)
+        return undefined;
+    switch (value.toLowerCase()) {
+        case "1":
+        case "true":
+        case "yes":
+        case "on":
+            return true;
+        case "0":
+        case "false":
+        case "no":
+        case "off":
+            return false;
+        default:
+            return undefined;
+    }
+}
+function readStringRecord(env, prefix) {
+    const output = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (!key.startsWith(prefix) || typeof value !== "string" || !value.trim()) {
+            continue;
+        }
+        output[key.slice(prefix.length).toLowerCase()] = value.trim();
+    }
+    return Object.keys(output).length > 0 ? output : undefined;
+}
+function normalizeSurface(value) {
+    switch (value?.toLowerCase()) {
+        case "cli":
+            return "MAESTRO_SURFACE_CLI";
+        case "web":
+            return "MAESTRO_SURFACE_WEB";
+        case "ide":
+        case "vscode":
+        case "jetbrains":
+            return "MAESTRO_SURFACE_IDE";
+        case "github":
+        case "github-agent":
+            return "MAESTRO_SURFACE_GITHUB_AGENT";
+        case "desktop":
+            return "MAESTRO_SURFACE_DESKTOP";
+        case "remote":
+        case "remote-runner":
+            return "MAESTRO_SURFACE_REMOTE_RUNNER";
+        default:
+            return "MAESTRO_SURFACE_TUI";
+    }
+}
+function normalizeRuntimeMode(value) {
+    switch (value?.toLowerCase()) {
+        case "headless":
+            return "MAESTRO_RUNTIME_MODE_HEADLESS";
+        case "hosted":
+            return "MAESTRO_RUNTIME_MODE_HOSTED";
+        case "remote":
+        case "remote-attached":
+            return "MAESTRO_RUNTIME_MODE_REMOTE_ATTACHED";
+        default:
+            return "MAESTRO_RUNTIME_MODE_LOCAL";
+    }
+}
+function managedEvalOpsRoutingActive(env) {
+    return Boolean(readEnv(env, ["MAESTRO_EVALOPS_ACCESS_TOKEN"]) &&
+        readEnv(env, [
+            "MAESTRO_EVALOPS_ORG_ID",
+            "EVALOPS_ORGANIZATION_ID",
+            "MAESTRO_ENTERPRISE_ORG_ID",
+        ]));
+}
+function defaultCorrelation(env) {
+    const workspaceId = readEnv(env, ["MAESTRO_EVALOPS_WORKSPACE_ID", "EVALOPS_WORKSPACE_ID"]) ??
+        env.PWD ??
+        process.cwd();
+    const sessionId = readEnv(env, ["MAESTRO_SESSION_ID"]) ?? "unknown";
+    return {
+        organization_id: readEnv(env, [
+            "MAESTRO_EVALOPS_ORG_ID",
+            "EVALOPS_ORGANIZATION_ID",
+            "MAESTRO_ENTERPRISE_ORG_ID",
+        ]),
+        user_id: readEnv(env, [
+            "MAESTRO_EVALOPS_USER_ID",
+            "EVALOPS_USER_ID",
+            "MAESTRO_USER_ID",
+        ]),
+        workspace_id: workspaceId,
+        session_id: sessionId,
+        agent_run_id: readEnv(env, ["MAESTRO_AGENT_RUN_ID"]),
+        agent_run_step_id: readEnv(env, ["MAESTRO_AGENT_RUN_STEP_ID"]),
+        agent_id: readEnv(env, ["MAESTRO_AGENT_ID"]),
+        actor_id: readEnv(env, ["MAESTRO_ACTOR_ID"]),
+        principal_id: readEnv(env, ["MAESTRO_PRINCIPAL_ID"]),
+        trace_id: readEnv(env, ["TRACE_ID", "OTEL_TRACE_ID"]),
+        traceparent: readEnv(env, ["TRACEPARENT", "TRACE_PARENT"]),
+        request_id: readEnv(env, ["MAESTRO_REQUEST_ID"]),
+        remote_runner_session_id: readEnv(env, [
+            "MAESTRO_REMOTE_RUNNER_SESSION_ID",
+        ]),
+        objective_id: readEnv(env, ["MAESTRO_OBJECTIVE_ID"]),
+        conversation_id: readEnv(env, ["MAESTRO_CONVERSATION_ID"]),
+        attributes: readStringRecord(env, "MAESTRO_EVENT_BUS_ATTR_"),
+    };
+}
+function defaultPrincipal(env) {
+    const subject = readEnv(env, [
+        "MAESTRO_PRINCIPAL_SUBJECT",
+        "MAESTRO_USER_SUBJECT",
+        "USER",
+    ]);
+    if (!subject)
+        return undefined;
+    return {
+        subject,
+        user_id: readEnv(env, [
+            "MAESTRO_EVALOPS_USER_ID",
+            "EVALOPS_USER_ID",
+            "MAESTRO_USER_ID",
+        ]),
+        organization_id: readEnv(env, [
+            "MAESTRO_EVALOPS_ORG_ID",
+            "EVALOPS_ORGANIZATION_ID",
+            "MAESTRO_ENTERPRISE_ORG_ID",
+        ]),
+        workspace_id: readEnv(env, [
+            "MAESTRO_EVALOPS_WORKSPACE_ID",
+            "EVALOPS_WORKSPACE_ID",
+        ]),
+        roles: readEnv(env, ["MAESTRO_PRINCIPAL_ROLES"])
+            ?.split(",")
+            .map((role) => role.trim())
+            .filter(Boolean),
+        scopes: readEnv(env, ["MAESTRO_PRINCIPAL_SCOPES"])
+            ?.split(",")
+            .map((scope) => scope.trim())
+            .filter(Boolean),
+        claims: readStringRecord(env, "MAESTRO_PRINCIPAL_CLAIM_"),
+    };
+}
+export function resolveMaestroEventBusConfig(env = process.env) {
+    const flag = readBoolean(readEnv(env, ["MAESTRO_EVENT_BUS", "MAESTRO_AUDIT_BUS"]));
+    const natsUrl = readEnv(env, [
+        "MAESTRO_EVENT_BUS_URL",
+        "EVALOPS_NATS_URL",
+        "NATS_URL",
+    ]);
+    const managedRouting = managedEvalOpsRoutingActive(env);
+    const enabled = flag === false ? false : (flag ?? Boolean(natsUrl || managedRouting));
+    let reason = "disabled";
+    if (flag === false)
+        reason = "flag disabled";
+    else if (natsUrl)
+        reason = "nats";
+    else if (managedRouting)
+        reason = "managed evalops routing";
+    else if (flag === true)
+        reason = "flag enabled";
+    return {
+        enabled,
+        reason,
+        natsUrl,
+        natsToken: readEnv(env, ["MAESTRO_EVENT_BUS_TOKEN", "NATS_TOKEN"]),
+        natsUser: readEnv(env, ["MAESTRO_EVENT_BUS_USER", "NATS_USER"]),
+        natsPassword: readEnv(env, ["MAESTRO_EVENT_BUS_PASSWORD", "NATS_PASSWORD"]),
+        source: readEnv(env, ["MAESTRO_EVENT_BUS_SOURCE"]) ?? "maestro",
+        tenantId: readEnv(env, [
+            "MAESTRO_EVALOPS_ORG_ID",
+            "EVALOPS_ORGANIZATION_ID",
+            "MAESTRO_ENTERPRISE_ORG_ID",
+        ]),
+        defaultSurface: normalizeSurface(readEnv(env, ["MAESTRO_SURFACE", "MAESTRO_EVENT_SURFACE"])),
+        defaultRuntimeMode: normalizeRuntimeMode(readEnv(env, ["MAESTRO_RUNTIME_MODE"])),
+        defaultCorrelation: defaultCorrelation(env),
+        defaultPrincipal: defaultPrincipal(env),
+    };
+}
+export function getMaestroEventBusStatus(env = process.env) {
+    const config = resolveMaestroEventBusConfig(env);
+    return {
+        enabled: config.enabled,
+        reason: config.enabled && !config.natsUrl ? "missing nats url" : config.reason,
+        natsUrl: config.natsUrl,
+        source: config.source,
+        tenantId: config.tenantId,
+        defaultSurface: config.defaultSurface,
+        defaultRuntimeMode: config.defaultRuntimeMode,
+    };
+}
+export function setMaestroEventBusTransportForTests(transport) {
+    transportOverride = transport;
+}
+export async function withMaestroEventBusTransportOverride(transport, callback) {
+    return scopedTransportOverride.run(transport, callback);
+}
+export async function closeMaestroEventBusTransport() {
+    const scopedTransport = scopedTransportOverride.getStore();
+    if (scopedTransport?.close)
+        await scopedTransport.close();
+    if (transportOverride?.close)
+        await transportOverride.close();
+    if (natsTransportPromise) {
+        const { transport } = await natsTransportPromise;
+        await transport.close?.();
+        natsTransportPromise = undefined;
+    }
+}
+async function createNatsTransport(config) {
+    if (!config.natsUrl)
+        return null;
+    const key = JSON.stringify({
+        url: config.natsUrl,
+        token: config.natsToken,
+        user: config.natsUser,
+        password: config.natsPassword,
+    });
+    if (!natsTransportPromise) {
+        const pendingTransport = (async () => {
+            const nats = await import("nats");
+            const codec = nats.StringCodec();
+            const connection = await nats.connect({
+                servers: config.natsUrl,
+                name: "maestro-event-bus",
+                token: config.natsToken,
+                user: config.natsUser,
+                pass: config.natsPassword,
+            });
+            const jetstream = connection.jetstream();
+            return {
+                key,
+                transport: {
+                    async publish(subject, payload) {
+                        await jetstream.publish(subject, codec.encode(payload));
+                    },
+                    async close() {
+                        await connection.drain();
+                    },
+                },
+            };
+        })();
+        const trackedTransport = pendingTransport.catch((error) => {
+            if (natsTransportPromise === trackedTransport) {
+                natsTransportPromise = undefined;
+            }
+            throw error;
+        });
+        natsTransportPromise = trackedTransport;
+    }
+    const resolved = await natsTransportPromise;
+    if (resolved.key === key)
+        return resolved.transport;
+    await resolved.transport.close?.();
+    natsTransportPromise = undefined;
+    return createNatsTransport(config);
+}
+async function getTransport(config) {
+    const scopedTransport = scopedTransportOverride.getStore();
+    if (scopedTransport !== undefined)
+        return scopedTransport;
+    if (transportOverride !== undefined)
+        return transportOverride;
+    return createNatsTransport(config);
+}
+function mergeCorrelation(base, overrides) {
+    const definedOverrides = Object.fromEntries(Object.entries(overrides ?? {}).filter(([, value]) => value !== undefined));
+    const attributes = {
+        ...base.attributes,
+        ...definedOverrides.attributes,
+    };
+    return {
+        ...base,
+        ...definedOverrides,
+        workspace_id: definedOverrides.workspace_id ?? base.workspace_id,
+        session_id: definedOverrides.session_id ?? base.session_id,
+        attributes: Object.keys(attributes).length > 0 ? attributes : undefined,
+    };
+}
+export function maestroCorrelationToChronicleMetadata(correlation) {
+    const metadata = {};
+    const canonicalKeys = new Set();
+    const putCanonicalMetadata = (key, value) => {
+        canonicalKeys.add(key);
+        putMetadata(metadata, key, value);
+    };
+    putCanonicalMetadata("organization_id", correlation.organization_id);
+    putCanonicalMetadata("user_id", correlation.user_id);
+    putCanonicalMetadata("workspace_id", correlation.workspace_id);
+    putCanonicalMetadata("maestro_session_id", correlation.session_id);
+    putCanonicalMetadata("agent_run_id", correlation.agent_run_id);
+    putCanonicalMetadata("agent_run_step_id", correlation.agent_run_step_id);
+    putCanonicalMetadata("agent_id", correlation.agent_id);
+    putCanonicalMetadata("actor_id", correlation.actor_id);
+    putCanonicalMetadata("principal_id", correlation.principal_id);
+    putCanonicalMetadata("trace_id", correlation.trace_id);
+    putCanonicalMetadata("traceparent", correlation.traceparent);
+    putCanonicalMetadata("request_id", correlation.request_id);
+    putCanonicalMetadata("remote_runner_session_id", correlation.remote_runner_session_id);
+    putCanonicalMetadata("objective_id", correlation.objective_id);
+    putCanonicalMetadata("conversation_id", correlation.conversation_id);
+    putCanonicalMetadata("parent_event_id", correlation.parent_event_id);
+    for (const [key, value] of Object.entries(correlation.attributes ?? {})) {
+        if (canonicalKeys.has(key))
+            continue;
+        putMetadata(metadata, key, value);
+    }
+    return metadata;
+}
+function putMetadata(metadata, key, value) {
+    const cleanValue = value?.trim();
+    if (!cleanValue)
+        return;
+    metadata[key] = cleanValue;
+}
+function normalizeTime(value) {
+    if (value instanceof Date)
+        return value.toISOString();
+    return value ?? new Date().toISOString();
+}
+function dataSchemaFor(type) {
+    return getMaestroBusEventCatalogEntry(type).dataSchema;
+}
+function protoAnyTypeFor(type) {
+    return getMaestroBusEventCatalogEntry(type).protoAnyType;
+}
+export function buildMaestroCloudEvent(type, data, options = {}) {
+    const config = resolveMaestroEventBusConfig(options.env);
+    const correlation = mergeCorrelation(config.defaultCorrelation, options.correlation);
+    const contextCorrelation = "correlation" in data && data.correlation
+        ? mergeCorrelation(correlation, data.correlation)
+        : correlation;
+    const dataCorrelation = maestroDataCorrelation(contextCorrelation);
+    const typedData = {
+        ...data,
+        "@type": protoAnyTypeFor(type),
+        correlation: dataCorrelation,
+    };
+    const contextExtensions = maestroContextExtensions(contextCorrelation, typedData);
+    return {
+        spec_version: "1.0",
+        id: options.eventId ?? randomUUID(),
+        type,
+        source: options.source ?? config.source,
+        subject: options.subject ?? type,
+        time: normalizeTime(options.time),
+        data_content_type: "application/protobuf",
+        tenant_id: options.tenantId ?? config.tenantId,
+        data: typedData,
+        extensions: {
+            dataschema: dataSchemaFor(type),
+            evalops_context_version: "evalops.context.v1",
+            ...contextExtensions,
+        },
+    };
+}
+function maestroDataCorrelation(correlation) {
+    const { traceparent: _traceparent, ...dataCorrelation } = correlation;
+    return dataCorrelation;
+}
+function maestroContextExtensions(correlation, data) {
+    const extensions = {};
+    putMetadata(extensions, "organization_id", correlation.organization_id);
+    putMetadata(extensions, "user_id", correlation.user_id);
+    putMetadata(extensions, "workspace_id", correlation.workspace_id);
+    putMetadata(extensions, "maestro_session_id", correlation.session_id);
+    putMetadata(extensions, "agent_run_id", correlation.agent_run_id);
+    putMetadata(extensions, "agent_run_step_id", correlation.agent_run_step_id);
+    putMetadata(extensions, "trace_id", correlation.trace_id);
+    putMetadata(extensions, "traceparent", correlation.traceparent);
+    putMetadata(extensions, "request_id", correlation.request_id);
+    putMetadata(extensions, "source_issue", correlation.attributes?.source_issue);
+    putMetadata(extensions, "task_id", correlation.attributes?.task_id);
+    putMetadata(extensions, "tool_execution_id", stringRecordValue(data, "tool_execution_id"));
+    return extensions;
+}
+function stringRecordValue(record, key) {
+    const value = record[key];
+    return typeof value === "string" ? value : undefined;
+}
+export async function publishMaestroCloudEvent(type, data, options = {}) {
+    const config = resolveMaestroEventBusConfig(options.env);
+    if (!config.enabled)
+        return;
+    try {
+        const transport = await getTransport(config);
+        if (!transport)
+            return;
+        const event = buildMaestroCloudEvent(type, data, options);
+        await transport.publish(type, JSON.stringify(event));
+    }
+    catch {
+        // Audit-bus publishing must never affect the local agent runtime.
+    }
+}
+export async function publishMaestroCloudEventStrict(type, data, options = {}) {
+    const config = resolveMaestroEventBusConfig(options.env);
+    if (!config.enabled && !config.natsUrl) {
+        throw new Error(`Maestro event bus is not enabled: ${config.reason}`);
+    }
+    const transport = await getTransport(config);
+    if (!transport) {
+        throw new Error("Maestro event bus transport is unavailable");
+    }
+    const event = buildMaestroCloudEvent(type, data, options);
+    await transport.publish(type, JSON.stringify(event));
+}
+function contextFromMetadata(metadata, extra) {
+    const context = metadata && typeof metadata === "object" && !Array.isArray(metadata)
+        ? { ...metadata }
+        : {};
+    if (extra)
+        Object.assign(context, extra);
+    return Object.keys(context).length > 0 ? context : undefined;
+}
+function correlationFromMetadata(metadata) {
+    if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) {
+        return undefined;
+    }
+    const record = metadata;
+    return {
+        session_id: typeof record.sessionId === "string"
+            ? record.sessionId
+            : typeof record.session_id === "string"
+                ? record.session_id
+                : undefined,
+        workspace_id: typeof record.workspaceId === "string"
+            ? record.workspaceId
+            : typeof record.workspace_id === "string"
+                ? record.workspace_id
+                : undefined,
+        agent_run_id: typeof record.agentRunId === "string"
+            ? record.agentRunId
+            : typeof record.agent_run_id === "string"
+                ? record.agent_run_id
+                : undefined,
+        agent_run_step_id: typeof record.toolCallId === "string"
+            ? record.toolCallId
+            : typeof record.tool_call_id === "string"
+                ? record.tool_call_id
+                : undefined,
+    };
+}
+function stringMetadata(metadata, name) {
+    return metadata &&
+        typeof metadata === "object" &&
+        !Array.isArray(metadata) &&
+        typeof metadata[name] === "string"
+        ? metadata[name]
+        : undefined;
+}
+function closeReasonFromMetadata(metadata) {
+    const value = stringMetadata(metadata, "closeReason") ??
+        stringMetadata(metadata, "close_reason");
+    switch (value) {
+        case "MAESTRO_CLOSE_REASON_COMPLETED":
+        case "MAESTRO_CLOSE_REASON_USER_STOPPED":
+        case "MAESTRO_CLOSE_REASON_IDLE_TIMEOUT":
+        case "MAESTRO_CLOSE_REASON_TTL_EXPIRED":
+        case "MAESTRO_CLOSE_REASON_ERROR":
+        case "MAESTRO_CLOSE_REASON_POLICY_DENIED":
+            return value;
+        default:
+            return undefined;
+    }
+}
+function durationFromMs(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+        return undefined;
+    }
+    return `${Number((value / 1000).toFixed(3))}s`;
+}
+function protoSkillOutcomeStatusFromTurnStatus(status) {
+    switch (status) {
+        case "success":
+            return "MAESTRO_SKILL_OUTCOME_STATUS_SUCCEEDED";
+        case "aborted":
+            return "MAESTRO_SKILL_OUTCOME_STATUS_CANCELLED";
+        case "evaluation_failed":
+            return "MAESTRO_SKILL_OUTCOME_STATUS_EVALUATION_FAILED";
+        case "rate_limited":
+            return "MAESTRO_SKILL_OUTCOME_STATUS_RATE_LIMITED";
+        case "error":
+            return "MAESTRO_SKILL_OUTCOME_STATUS_FAILED";
+    }
+}
+function sessionEventTypeForMetric(metric) {
+    switch (metric) {
+        case "session.count":
+            return MaestroBusEventType.SessionStarted;
+        case "session.duration":
+            return MaestroBusEventType.SessionClosed;
+        default:
+            return undefined;
+    }
+}
+export function recordMaestroSessionEvent(state, options = {}) {
+    const now = new Date().toISOString();
+    const config = resolveMaestroEventBusConfig(options.env);
+    const eventType = state === "MAESTRO_SESSION_STATE_CLOSED"
+        ? MaestroBusEventType.SessionClosed
+        : state === "MAESTRO_SESSION_STATE_SUSPENDED"
+            ? MaestroBusEventType.SessionSuspended
+            : state === "MAESTRO_SESSION_STATE_RESUMED"
+                ? MaestroBusEventType.SessionResumed
+                : MaestroBusEventType.SessionStarted;
+    void publishMaestroCloudEvent(eventType, {
+        correlation: mergeCorrelation(config.defaultCorrelation, {
+            ...options.correlation,
+            session_id: options.sessionId ?? options.correlation?.session_id,
+        }),
+        state,
+        surface: config.defaultSurface,
+        runtime_mode: config.defaultRuntimeMode,
+        principal: config.defaultPrincipal,
+        workspace_root: process.cwd(),
+        runtime_version: process.env.npm_package_version,
+        started_at: state === "MAESTRO_SESSION_STATE_STARTED" ? now : undefined,
+        suspended_at: state === "MAESTRO_SESSION_STATE_SUSPENDED" ? now : undefined,
+        resumed_at: state === "MAESTRO_SESSION_STATE_RESUMED" ? now : undefined,
+        closed_at: state === "MAESTRO_SESSION_STATE_CLOSED" ? now : undefined,
+        close_reason: options.closeReason,
+        close_message: options.closeMessage,
+        metadata: options.metadata,
+    }, { env: options.env, time: now });
+}
+export function recordMaestroApprovalHit(event) {
+    const occurredAt = event.occurred_at ?? new Date().toISOString();
+    void publishMaestroCloudEvent(MaestroBusEventType.ApprovalHit, {
+        correlation: mergeCorrelation(resolveMaestroEventBusConfig(event.env).defaultCorrelation, event.correlation),
+        approval_request_id: event.approval_request_id,
+        governance_decision_id: event.governance_decision_id,
+        action: event.action,
+        command: event.command,
+        risk_level: event.risk_level,
+        decision_mode: event.decision_mode,
+        policy_id: event.policy_id,
+        reason: event.reason,
+        context: event.context,
+        occurred_at: occurredAt,
+    }, { env: event.env, eventId: event.event_id, time: occurredAt });
+}
+export function recordMaestroFirewallBlock(event) {
+    const occurredAt = event.occurred_at ?? new Date().toISOString();
+    void publishMaestroCloudEvent(MaestroBusEventType.FirewallBlock, {
+        correlation: mergeCorrelation(resolveMaestroEventBusConfig(event.env).defaultCorrelation, event.correlation),
+        rule_id: event.rule_id,
+        operation: event.operation,
+        target: event.target,
+        protocol: event.protocol,
+        port: event.port,
+        reason: event.reason,
+        context: event.context,
+        occurred_at: occurredAt,
+    }, { env: event.env, eventId: event.event_id, time: occurredAt });
+}
+export function recordMaestroToolCallAttempt(event) {
+    const attemptedAt = event.attempted_at ?? new Date().toISOString();
+    void publishMaestroCloudEvent(MaestroBusEventType.ToolCallAttempted, {
+        correlation: mergeCorrelation(resolveMaestroEventBusConfig(event.env).defaultCorrelation, event.correlation),
+        tool_call_id: event.tool_call_id,
+        tool_execution_id: event.tool_execution_id,
+        prompt_metadata: event.prompt_metadata,
+        skill_metadata: event.skill_metadata,
+        tool_namespace: event.tool_namespace,
+        tool_name: event.tool_name,
+        tool_version: event.tool_version,
+        capability: event.capability,
+        connector_id: event.connector_id,
+        mutates_resource: event.mutates_resource,
+        risk_level: event.risk_level,
+        safe_arguments: event.safe_arguments,
+        redactions: event.redactions,
+        idempotency_key: event.idempotency_key,
+        attempted_at: attemptedAt,
+    }, { env: event.env, eventId: event.event_id, time: attemptedAt });
+}
+export function recordMaestroToolCallCompleted(event) {
+    const completedAt = event.completed_at ?? new Date().toISOString();
+    void publishMaestroCloudEvent(MaestroBusEventType.ToolCallCompleted, {
+        correlation: mergeCorrelation(resolveMaestroEventBusConfig(event.env).defaultCorrelation, event.correlation),
+        tool_call_id: event.tool_call_id,
+        tool_execution_id: event.tool_execution_id,
+        prompt_metadata: event.prompt_metadata,
+        skill_metadata: event.skill_metadata,
+        approval_request_id: event.approval_request_id,
+        governed_outcome: event.governed_outcome,
+        status: event.status,
+        duration: event.duration,
+        safe_output: event.safe_output,
+        redactions: event.redactions,
+        error_code: event.error_code,
+        error_message: event.error_message,
+        completed_at: completedAt,
+    }, { env: event.env, eventId: event.event_id, time: completedAt });
+}
+export function recordMaestroPromptVariantSelected(event) {
+    const selectedAt = event.selected_at ?? new Date().toISOString();
+    const promptID = event.prompt_id ?? event.prompt_metadata.name;
+    const promptName = event.prompt_name ?? event.prompt_metadata.name;
+    const versionID = event.version_id ??
+        event.prompt_metadata.versionId ??
+        event.prompt_metadata.hash;
+    void publishMaestroCloudEvent(MaestroBusEventType.PromptVariantSelected, {
+        correlation: mergeCorrelation(resolveMaestroEventBusConfig(event.env).defaultCorrelation, event.correlation),
+        prompt_id: promptID,
+        prompt_name: promptName,
+        version_id: versionID,
+        prompt_metadata: event.prompt_metadata,
+        selected_at: selectedAt,
+    }, { env: event.env, eventId: event.event_id, time: selectedAt });
+}
+export function recordMaestroLearnedContext(event) {
+    const learnedAt = event.learned_at ?? new Date().toISOString();
+    void publishMaestroCloudEvent(MaestroBusEventType.ContextLearned, {
+        correlation: mergeCorrelation(resolveMaestroEventBusConfig(event.env).defaultCorrelation, event.correlation),
+        learning_id: event.learning_id,
+        subject_thing_id: event.subject_thing_id,
+        subject_key: event.subject_key,
+        statement: event.statement,
+        dimension: event.dimension,
+        confidence_score: event.confidence_score,
+        confidence_reason: event.confidence_reason,
+        evidence: event.evidence,
+        tool_call_id: event.tool_call_id,
+        tool_execution_id: event.tool_execution_id,
+        learned_at: learnedAt,
+    }, { env: event.env, eventId: event.event_id, time: learnedAt });
+}
+export function recordMaestroSkillInvoked(event) {
+    const invokedAt = event.invoked_at ?? new Date().toISOString();
+    void publishMaestroCloudEvent(MaestroBusEventType.SkillInvoked, {
+        correlation: mergeCorrelation(resolveMaestroEventBusConfig(event.env).defaultCorrelation, event.correlation),
+        prompt_metadata: event.prompt_metadata,
+        skill_metadata: event.skill_metadata,
+        invocation_id: event.invocation_id,
+        skill_id: event.skill_id ?? event.skill_metadata.artifactId,
+        tool_call_id: event.tool_call_id,
+        tool_execution_id: event.tool_execution_id,
+        invoked_at: invokedAt,
+    }, { env: event.env, eventId: event.event_id, time: invokedAt });
+}
+export function recordMaestroSkillOutcome(event) {
+    const outcomeAt = event.outcome_at ?? new Date().toISOString();
+    const eventType = event.turn_status === "success"
+        ? MaestroBusEventType.SkillSucceeded
+        : MaestroBusEventType.SkillFailed;
+    void publishMaestroCloudEvent(eventType, {
+        correlation: mergeCorrelation(resolveMaestroEventBusConfig(event.env).defaultCorrelation, event.correlation),
+        prompt_metadata: event.prompt_metadata,
+        skill_metadata: event.skill_metadata,
+        invocation_id: event.invocation_id,
+        skill_id: event.skill_id ?? event.skill_metadata.artifactId,
+        status: event.status ??
+            protoSkillOutcomeStatusFromTurnStatus(event.turn_status),
+        tool_call_id: event.tool_call_id,
+        tool_execution_id: event.tool_execution_id,
+        turn_status: event.turn_status,
+        error_category: event.error_category,
+        error_message: event.error_message,
+        evaluation_tool_name: event.evaluation_tool_name,
+        evaluation_tool_call_id: event.evaluation_tool_call_id,
+        evaluation_tool_execution_id: event.evaluation_tool_execution_id,
+        evaluation_score: event.evaluation_score,
+        evaluation_threshold: event.evaluation_threshold,
+        evaluation_assertion_count: event.evaluation_assertion_count,
+        evaluation_rationale: event.evaluation_rationale,
+        stop_reason: event.stop_reason,
+        outcome_at: outcomeAt,
+    }, { env: event.env, eventId: event.event_id, time: outcomeAt });
+}
+export function recordMaestroEvalScored(event) {
+    const scoredAt = event.scored_at ?? new Date().toISOString();
+    const evalRunID = event.eval_run_id ?? event.tool_execution_id ?? event.tool_call_id;
+    const scenarioID = event.scenario_id ??
+        event.skill_metadata?.artifactId ??
+        event.skill_metadata?.name ??
+        event.tool_name ??
+        event.tool_call_id;
+    void publishMaestroCloudEvent(MaestroBusEventType.EvalScored, {
+        correlation: mergeCorrelation(resolveMaestroEventBusConfig(event.env).defaultCorrelation, event.correlation),
+        eval_run_id: evalRunID,
+        scenario_id: scenarioID,
+        prompt_metadata: event.prompt_metadata,
+        skill_metadata: event.skill_metadata,
+        tool_call_id: event.tool_call_id,
+        tool_execution_id: event.tool_execution_id,
+        tool_name: event.tool_name,
+        score: event.score,
+        threshold: event.threshold,
+        passed: event.passed,
+        scorer: event.scorer,
+        rationale: event.rationale,
+        assertion_count: event.assertion_count,
+        scored_at: scoredAt,
+    }, { env: event.env, eventId: event.event_id, time: scoredAt });
+}
+export async function mirrorTelemetryToMaestroEventBus(event) {
+    const fields = event;
+    if (event.type === "sandbox-violation") {
+        const path = typeof fields.path === "string" ? fields.path : undefined;
+        await publishMaestroCloudEvent(MaestroBusEventType.SandboxViolation, {
+            correlation: mergeCorrelation(resolveMaestroEventBusConfig().defaultCorrelation, correlationFromMetadata(fields.metadata)),
+            operation: String(fields.action ?? fields.tool ?? "unknown"),
+            resource: path ?? String(fields.command ?? fields.tool ?? "unknown"),
+            attempted_path: path,
+            reason: typeof fields.reason === "string" ? fields.reason : undefined,
+            context: contextFromMetadata(fields.metadata, {
+                tool: fields.tool,
+                command: fields.command,
+                event: fields.event,
+            }),
+            occurred_at: event.timestamp,
+        }, { time: event.timestamp });
+        return;
+    }
+    if (event.type === "business-metric") {
+        const eventType = sessionEventTypeForMetric(fields.metric);
+        if (!eventType)
+            return;
+        const config = resolveMaestroEventBusConfig();
+        await publishMaestroCloudEvent(eventType, {
+            correlation: mergeCorrelation(config.defaultCorrelation, correlationFromMetadata(fields.metadata)),
+            state: eventType === MaestroBusEventType.SessionClosed
+                ? "MAESTRO_SESSION_STATE_CLOSED"
+                : "MAESTRO_SESSION_STATE_STARTED",
+            surface: config.defaultSurface,
+            runtime_mode: config.defaultRuntimeMode,
+            principal: config.defaultPrincipal,
+            workspace_root: process.cwd(),
+            runtime_version: process.env.npm_package_version,
+            started_at: eventType === MaestroBusEventType.SessionStarted
+                ? event.timestamp
+                : undefined,
+            closed_at: eventType === MaestroBusEventType.SessionClosed
+                ? event.timestamp
+                : undefined,
+            close_reason: eventType === MaestroBusEventType.SessionClosed
+                ? (closeReasonFromMetadata(fields.metadata) ??
+                    "MAESTRO_CLOSE_REASON_COMPLETED")
+                : undefined,
+            close_message: eventType === MaestroBusEventType.SessionClosed
+                ? (stringMetadata(fields.metadata, "closeMessage") ??
+                    stringMetadata(fields.metadata, "close_message"))
+                : undefined,
+            metadata: contextFromMetadata(fields.metadata, {
+                value: fields.value,
+                metric: fields.metric,
+            }),
+        }, { time: event.timestamp });
+        return;
+    }
+    if (event.type === "tool-execution") {
+        const metadata = fields.metadata;
+        await publishMaestroCloudEvent(MaestroBusEventType.ToolCallCompleted, {
+            correlation: mergeCorrelation(resolveMaestroEventBusConfig().defaultCorrelation, correlationFromMetadata(metadata)),
+            tool_call_id: stringMetadata(metadata, "toolCallId") ??
+                stringMetadata(metadata, "tool_call_id") ??
+                `${String(fields.toolName ?? "tool")}:${event.timestamp}`,
+            status: fields.success
+                ? "MAESTRO_TOOL_CALL_STATUS_SUCCEEDED"
+                : "MAESTRO_TOOL_CALL_STATUS_FAILED",
+            duration: durationFromMs(fields.durationMs),
+            error_message: fields.success
+                ? undefined
+                : stringMetadata(metadata, "error"),
+            completed_at: event.timestamp,
+        }, { time: event.timestamp });
+    }
+}
+//# sourceMappingURL=maestro-event-bus.js.map