comisai 1.0.42 → 1.0.45

package/node_modules/@comis/observability/dist/trajectory/session-registry.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Session-scoped trajectory-recorder registry.
+ *
+ * Lifts recorder lifecycle out of `pi-executor.runSessionLocked` (which
+ * runs per-turn) into a session-scoped handle (one recorder per session,
+ * spanning every turn). Ensures:
+ *
+ *   - `seq` is monotonic across all turns in a session (per-session
+ *     monotonic, NOT per-turn).
+ *   - Exactly one `session.started` and one `session.ended` event appear
+ *     in the trajectory file.
+ *   - The bridge subscription matches the recorder's lifetime, so events
+ *     emitted between turns also reach the trajectory.
+ *
+ * The registry is the **only** owner of the EventBus bridge subscription
+ * — callers receive a recorder reference but the unsubscribe lives on
+ * the registry's internal map. `close(formattedKey)` is the single path
+ * to flush + unsubscribe; `closeAll()` is the daemon-shutdown drain.
+ *
+ * Production wiring: the daemon composition root creates one registry
+ * via `createSessionTrajectoryHandleRegistry()`, threads it through
+ * `PiExecutorDeps.trajectoryRegistry`, and registers `closeAll()` in the
+ * shutdown chain. `pi-executor` calls `getOrCreate(formattedKey, init,
+ * eventBus)` once per `execute()` — on the second + subsequent turns
+ * the existing recorder is returned (the `init` from the first call
+ * wins for the session's lifetime).
+ *
+ * @module
+ */
+import type { TypedEventBus } from "@comis/core";
+import { type TrajectoryBridgedEventName } from "./event-bus-bridge.js";
+import type { TrajectoryRecorder, TrajectoryRecorderInit } from "./types.js";
+/**
+ * Optional bridge filter forwarded to `attachTrajectoryToEventBus`.
+ * Production callers (pi-executor) thread the
+ * `diagnostics.trajectory.eventTypes` allowlist through here.
+ */
+export type SessionTrajectoryFilter = (eventName: TrajectoryBridgedEventName) => boolean;
+/**
+ * Public registry surface. The shape mirrors the lifecycle:
+ *   - `getOrCreate` (called per-turn; first call materializes the
+ *      recorder + bridge subscription, later calls reuse the same
+ *      recorder),
+ *   - `close` (single-session drain — called by the agent/orchestrator
+ *      when the session is destroyed; flushes + unsubscribes + drops
+ *      the entry),
+ *   - `closeAll` (daemon-shutdown drain — called in the shutdown chain).
+ */
+export interface SessionTrajectoryHandleRegistry {
+    /**
+     * Return the recorder for `formattedKey`. If no entry exists yet,
+     * construct one from `init` and subscribe the bridge to `eventBus`
+     * with the optional `filter`. The `init` from the first call wins;
+     * later calls IGNORE the passed `init` (subsequent turns can't
+     * change provider/modelId mid-session without an explicit reset).
+     *
+     * Returns `{ recorder: null }` when the recorder factory short-circuits
+     * (env-disabled or `init.enabled === false`); the registry remembers
+     * the null entry so subsequent calls don't re-attempt construction.
+     */
+    getOrCreate(formattedKey: string, init: TrajectoryRecorderInit, eventBus: TypedEventBus, filter?: SessionTrajectoryFilter): {
+        recorder: TrajectoryRecorder | null;
+    };
+    /**
+     * Drain one session. Unsubscribe + flushAndClose + drop the map
+     * entry. Best-effort — errors are swallowed (a partial sidecar must
+     * NOT block the agent's main shutdown path). Safe to call when no
+     * entry exists (no-op).
+     */
+    close(formattedKey: string): Promise<void>;
+    /**
+     * Drain every open session. Used by the daemon's shutdown chain
+     * after RPC servers stop accepting connections. Errors are swallowed
+     * per-entry; the iteration completes even when one entry's
+     * `flushAndClose` throws.
+     */
+    closeAll(): Promise<void>;
+    /**
+     * Return the recorder for `formattedKey` if it exists, `undefined`
+     * otherwise. Pure-read accessor — no creation side-effects. Returns
+     * `null` when the entry was created with env-disabled / `enabled:false`
+     * init (i.e., the entry exists but the recorder itself is null). Returns
+     * `undefined` when no entry exists at all.
+     *
+     * Used by direct-emit sites to call
+     * `recorder.recordEvent(...)` without going through the bus bridge.
+     */
+    getRecorder(formattedKey: string): TrajectoryRecorder | null | undefined;
+    /**
+     * Returns `true` once `markSessionStarted(formattedKey)` has been
+     * called for this session's registry lifetime, `false` otherwise.
+     *
+     * Used by the pi-event-bridge `agent_start` case to suppress per-turn
+     * `session:started` re-emits — the mapping table makes
+     * `session.started` a once-per-session event (not once-per-turn).
+     * Per-turn bridges consult this latch so the second + subsequent
+     * turns short-circuit the emit.
+     *
+     * Defaults to `false` for unknown keys (the bridge may consult this
+     * for a session whose entry hasn't been materialized yet via
+     * `getOrCreate`; the safe behavior is "no emit recorded → let the
+     * caller emit"). When the entry is later created and the emit fires,
+     * `markSessionStarted` flips the latch on the entry.
+     */
+    hasSessionStartedBeenEmitted(formattedKey: string): boolean;
+    /**
+     * Mark that `session:started` has been emitted for this session.
+     * Idempotent. Safe to call on unknown keys (no-op — the bridge
+     * always calls this immediately after `eventBus.emit("session:started", …)`
+     * and the entry materializes on the same turn via `getOrCreate`,
+     * but the API tolerates ordering surprises).
+     */
+    markSessionStarted(formattedKey: string): void;
+}
+/**
+ * Construct an empty registry. The factory is the sanctioned entry
+ * point — callers MUST NOT instantiate the internal map shape directly.
+ */
+export declare function createSessionTrajectoryHandleRegistry(): SessionTrajectoryHandleRegistry;

package/node_modules/@comis/observability/dist/trajectory/session-registry.js

@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Session-scoped trajectory-recorder registry.
+ *
+ * Lifts recorder lifecycle out of `pi-executor.runSessionLocked` (which
+ * runs per-turn) into a session-scoped handle (one recorder per session,
+ * spanning every turn). Ensures:
+ *
+ *   - `seq` is monotonic across all turns in a session (per-session
+ *     monotonic, NOT per-turn).
+ *   - Exactly one `session.started` and one `session.ended` event appear
+ *     in the trajectory file.
+ *   - The bridge subscription matches the recorder's lifetime, so events
+ *     emitted between turns also reach the trajectory.
+ *
+ * The registry is the **only** owner of the EventBus bridge subscription
+ * — callers receive a recorder reference but the unsubscribe lives on
+ * the registry's internal map. `close(formattedKey)` is the single path
+ * to flush + unsubscribe; `closeAll()` is the daemon-shutdown drain.
+ *
+ * Production wiring: the daemon composition root creates one registry
+ * via `createSessionTrajectoryHandleRegistry()`, threads it through
+ * `PiExecutorDeps.trajectoryRegistry`, and registers `closeAll()` in the
+ * shutdown chain. `pi-executor` calls `getOrCreate(formattedKey, init,
+ * eventBus)` once per `execute()` — on the second + subsequent turns
+ * the existing recorder is returned (the `init` from the first call
+ * wins for the session's lifetime).
+ *
+ * @module
+ */
+import { attachTrajectoryToEventBus, } from "./event-bus-bridge.js";
+import { createTrajectoryRecorder } from "./runtime.js";
+/**
+ * Construct an empty registry. The factory is the sanctioned entry
+ * point — callers MUST NOT instantiate the internal map shape directly.
+ */
+export function createSessionTrajectoryHandleRegistry() {
+    const entries = new Map();
+    return {
+        getOrCreate(formattedKey, init, eventBus, filter) {
+            const existing = entries.get(formattedKey);
+            if (existing !== undefined) {
+                return { recorder: existing.recorder };
+            }
+            const recorder = createTrajectoryRecorder(init);
+            let unsubscribe;
+            if (recorder !== null) {
+                unsubscribe = attachTrajectoryToEventBus({
+                    eventBus,
+                    recorder,
+                    ...(filter !== undefined ? { filter } : {}),
+                });
+            }
+            // sessionStartedEmitted intentionally starts as `false`. Bridge
+            // flips it via markSessionStarted on the first emit; close()
+            // drops the entry so a future getOrCreate re-starts at `false`.
+            const entry = {
+                recorder,
+                unsubscribe,
+                sessionStartedEmitted: false,
+            };
+            entries.set(formattedKey, entry);
+            return { recorder };
+        },
+        async close(formattedKey) {
+            const entry = entries.get(formattedKey);
+            if (entry === undefined)
+                return;
+            entries.delete(formattedKey);
+            // Unsubscribe before flush — once unsubscribed, no new events can
+            // land between the flush and close. EventEmitter.off is sync.
+            try {
+                entry.unsubscribe?.();
+            }
+            catch {
+                // Unsubscribe failure is unreachable in practice (EventEmitter.off
+                // is sync); swallow defensively so this never aborts cleanup.
+            }
+            if (entry.recorder !== null) {
+                try {
+                    await entry.recorder.flushAndClose();
+                }
+                catch {
+                    // Best-effort — a partial sidecar must NOT block agent shutdown.
+                }
+            }
+        },
+        async closeAll() {
+            // Snapshot keys first so per-entry close calls can safely mutate
+            // the internal map.
+            const keys = Array.from(entries.keys());
+            for (const k of keys) {
+                // close() swallows per-entry errors; the iteration always
+                // completes.
+                await this.close(k);
+            }
+        },
+        getRecorder(formattedKey) {
+            const entry = entries.get(formattedKey);
+            if (entry === undefined)
+                return undefined;
+            // Return null when env-disabled (recorder is null but entry exists),
+            // or the recorder itself when it was constructed successfully.
+            return entry.recorder;
+        },
+        hasSessionStartedBeenEmitted(formattedKey) {
+            // Unknown key → false (lets the bridge emit on the very first
+            // turn before the recorder is materialized; getOrCreate fires
+            // on the same call path so by the time markSessionStarted runs
+            // the entry exists).
+            return entries.get(formattedKey)?.sessionStartedEmitted ?? false;
+        },
+        markSessionStarted(formattedKey) {
+            const entry = entries.get(formattedKey);
+            if (entry === undefined)
+                return; // silent no-op for unknown keys
+            entry.sessionStartedEmitted = true;
+        },
+    };
+}

package/node_modules/@comis/observability/dist/trajectory/translate-cache-break-payload.d.ts

@@ -0,0 +1,2 @@
+/** Translate the `observability:cache_break` payload into the `cache.break` data. */
+export declare function translateCacheBreakPayload(payload: Record<string, unknown>): Record<string, unknown>;

package/node_modules/@comis/observability/dist/trajectory/translate-cache-break-payload.js

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * `observability:cache_break → cache.break` trajectory payload translator
+ * (PERSIST-01, Phase 176 Plan 04 + AUDIT-05 Plan 05). Extracted from
+ * `translate-payload.ts` to keep that module under the file-size cap (the est-$
+ * forward pushed it over) — the same per-event delegation pattern as
+ * `translate-image-payload.ts` / `translate-video-payload.ts` etc.
+ *
+ * CONTENT-FREE (the load-bearing constraint, §2.7 / I3 / H1): a closed `reason`,
+ * the `tokenDrop` counts, a changed-dims DIGEST (counts only — the
+ * toolsAdded/Removed/SchemaChanged NAME arrays are NEVER forwarded), and a
+ * COMPUTED `estCostUsd` (a number — the directly-lost cache-read saving, SAME
+ * formula as the Plan-04 `obs_diagnostics` row-builder:
+ * `tokenDrop × resolveModelPricing(provider, model).cacheRead`; 0 for an unknown
+ * model). `provider`/`model` are closed labels (already on the event, already
+ * forwarded by the image/vision records), never bodies. Correlation keys
+ * (`agentId`/`sessionKey`/`traceId`) are envelope-only and NOT echoed into `data`.
+ *
+ * @module
+ */
+import { resolveModelPricing } from "@comis/core";
+/** Translate the `observability:cache_break` payload into the `cache.break` data. */
+export function translateCacheBreakPayload(payload) {
+    const toLen = (v) => (Array.isArray(v) ? v.length : 0);
+    const str = (v) => (typeof v === "string" ? v : "");
+    const num = (v) => (typeof v === "number" ? v : 0);
+    return {
+        reason: payload.reason,
+        tokenDrop: payload.tokenDrop,
+        tokenDropRelative: payload.tokenDropRelative,
+        estCostUsd: num(payload.tokenDrop) * resolveModelPricing(str(payload.provider), str(payload.model)).cacheRead,
+        changedDimsDigest: {
+            added: toLen(payload.toolsAdded),
+            removed: toLen(payload.toolsRemoved),
+            schemaChanged: toLen(payload.toolsSchemaChanged),
+            systemCharDelta: num(payload.systemCharDelta),
+        },
+    };
+}

package/node_modules/@comis/observability/dist/trajectory/translate-image-payload.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Trajectory bridge payload translators for the image-generation (`image:*`)
+ * lifecycle (OBS-04, Phase 186).
+ *
+ * Extracted from `translate-payload.ts` (which is at the file-size cap) — the
+ * main `translatePayload` switch delegates its four `image:*` cases here.
+ * BEHAVIOR-NEUTRAL move (ORCH-OBS file-size split): the returned shapes are
+ * byte-identical to the previously-inline arms, pinned by the existing `image:*`
+ * arm tests in `translate-payload.test.ts` + the `never` exhaustiveness check
+ * below. This is the EXACT precedent that produced `translate-vision-payload.ts`
+ * / `translate-video-payload.ts` / `translate-voice-payload.ts` — image was the
+ * last media lifecycle still inline.
+ *
+ * CONTENT-FREE (T-186-08): ids/labels/numbers/booleans ONLY — never the prompt,
+ * image bytes, a credential, or a raw provider message. `costUsd` rides
+ * `image:generated` so `comis explain` reconstructs the cost (OBS-03 Route a).
+ * agentId/sessionKey/timestamp are envelope-only + stripped; optional fields
+ * spread presence-conditionally.
+ *
+ * @module
+ */
+/** The four `image:*` EventBus event names the bridge maps. */
+export type ImageBridgedEventName = "image:requested" | "image:generated" | "image:delivered" | "image:failed";
+/**
+ * Translate an `image:*` EventBus payload into the content-free `data` of its
+ * trajectory event. Mirrors the `media.vision:*` / `video:*` / `media.*` arms.
+ * The envelope keys are stripped (they ride the trajectory envelope via the
+ * recorder, not `data`).
+ */
+export declare function translateImagePayload(eventName: ImageBridgedEventName, payload: Record<string, unknown>): Record<string, unknown>;

package/node_modules/@comis/observability/dist/trajectory/translate-image-payload.js

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Trajectory bridge payload translators for the image-generation (`image:*`)
+ * lifecycle (OBS-04, Phase 186).
+ *
+ * Extracted from `translate-payload.ts` (which is at the file-size cap) — the
+ * main `translatePayload` switch delegates its four `image:*` cases here.
+ * BEHAVIOR-NEUTRAL move (ORCH-OBS file-size split): the returned shapes are
+ * byte-identical to the previously-inline arms, pinned by the existing `image:*`
+ * arm tests in `translate-payload.test.ts` + the `never` exhaustiveness check
+ * below. This is the EXACT precedent that produced `translate-vision-payload.ts`
+ * / `translate-video-payload.ts` / `translate-voice-payload.ts` — image was the
+ * last media lifecycle still inline.
+ *
+ * CONTENT-FREE (T-186-08): ids/labels/numbers/booleans ONLY — never the prompt,
+ * image bytes, a credential, or a raw provider message. `costUsd` rides
+ * `image:generated` so `comis explain` reconstructs the cost (OBS-03 Route a).
+ * agentId/sessionKey/timestamp are envelope-only + stripped; optional fields
+ * spread presence-conditionally.
+ *
+ * @module
+ */
+/**
+ * Translate an `image:*` EventBus payload into the content-free `data` of its
+ * trajectory event. Mirrors the `media.vision:*` / `video:*` / `media.*` arms.
+ * The envelope keys are stripped (they ride the trajectory envelope via the
+ * recorder, not `data`).
+ */
+export function translateImagePayload(eventName, payload) {
+    switch (eventName) {
+        case "image:requested":
+            return {
+                provider: payload.provider,
+                mainProvider: payload.mainProvider,
+            };
+        case "image:generated":
+            return {
+                provider: payload.provider,
+                outcome: payload.outcome,
+                ...(payload.model !== undefined ? { model: payload.model } : {}),
+                ...(payload.costUsd !== undefined ? { costUsd: payload.costUsd } : {}),
+                ...(payload.sizeBytes !== undefined ? { sizeBytes: payload.sizeBytes } : {}),
+            };
+        case "image:delivered":
+            return {
+                channelType: payload.channelType,
+                delivered: payload.delivered,
+            };
+        case "image:failed":
+            return {
+                errorKind: payload.errorKind,
+                provider: payload.provider,
+            };
+        default: {
+            // Exhaustiveness — the switch covers every ImageBridgedEventName.
+            const _exhaustive = eventName;
+            void _exhaustive;
+            return payload;
+        }
+    }
+}

package/node_modules/@comis/observability/dist/trajectory/translate-orchestration-payload.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Trajectory bridge payload translators for the v2.27 authoring / sub-agent
+ * orchestration family (TELEM-01 + AUTHOR-01/02 + STEER-01).
+ *
+ * Extracted from `translate-payload.ts` (which is at the file-size cap) — the
+ * main `translatePayload` switch delegates these four cases here. No behavior
+ * change vs. inlining; this is purely a file-size split (the same rationale the
+ * `translate-video-payload.ts` / `translate-vision-payload.ts` /
+ * `translate-voice-payload.ts` splits document).
+ *
+ * CONTENT-FREE (§2.7 / H1): each arm forwards ONLY closed enums + numbers /
+ * booleans / a run id and STRIPS the envelope (agentId / sessionKey / timestamp).
+ * NEVER a pipeline / graph body, a `type_config` value, a node task, the
+ * synthesis INTENT TEXT (the highest-risk authoring leak), or the steer MESSAGE
+ * BODY (the highest-risk steer leak). `pipeline:authored.repaired` is P1-inert.
+ *
+ * @module
+ */
+/** The authoring / sub-agent orchestration EventBus event names the bridge maps. */
+export type OrchestrationBridgedEventName = "pipeline:authored" | "graph:repaired" | "graph:synthesized_from_intent" | "subagent:steered" | "security:sandbox_downgrade_refused" | "subagent:delivery_deadlettered" | "subagent:delivery_retried" | "subagent:budget_exceeded" | "capability:audited" | "graph:node_spawned";
+/**
+ * Translate a v2.27 authoring / orchestration EventBus payload into the
+ * content-free `data` of its trajectory event. The envelope keys are stripped
+ * (they ride the trajectory envelope via the recorder, not `data`).
+ */
+export declare function translateOrchestrationPayload(eventName: OrchestrationBridgedEventName, payload: Record<string, unknown>): Record<string, unknown>;

package/node_modules/@comis/observability/dist/trajectory/translate-orchestration-payload.js

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Trajectory bridge payload translators for the v2.27 authoring / sub-agent
+ * orchestration family (TELEM-01 + AUTHOR-01/02 + STEER-01).
+ *
+ * Extracted from `translate-payload.ts` (which is at the file-size cap) — the
+ * main `translatePayload` switch delegates these four cases here. No behavior
+ * change vs. inlining; this is purely a file-size split (the same rationale the
+ * `translate-video-payload.ts` / `translate-vision-payload.ts` /
+ * `translate-voice-payload.ts` splits document).
+ *
+ * CONTENT-FREE (§2.7 / H1): each arm forwards ONLY closed enums + numbers /
+ * booleans / a run id and STRIPS the envelope (agentId / sessionKey / timestamp).
+ * NEVER a pipeline / graph body, a `type_config` value, a node task, the
+ * synthesis INTENT TEXT (the highest-risk authoring leak), or the steer MESSAGE
+ * BODY (the highest-risk steer leak). `pipeline:authored.repaired` is P1-inert.
+ *
+ * @module
+ */
+/**
+ * Translate a v2.27 authoring / orchestration EventBus payload into the
+ * content-free `data` of its trajectory event. The envelope keys are stripped
+ * (they ride the trajectory envelope via the recorder, not `data`).
+ */
+export function translateOrchestrationPayload(eventName, payload) {
+    switch (eventName) {
+        case "pipeline:authored":
+            // TELEM-01: closed enums + booleans ONLY — never a pipeline body / type_config value / node task. repaired is P1-inert.
+            return { action: payload.action, capabilityClass: payload.capabilityClass, schemaValid: payload.schemaValid, repaired: payload.repaired };
+        case "graph:repaired":
+            // AUTHOR-01: matched canonical template + repaired-graph nodeCount + tier.
+            return { pattern: payload.pattern, nodeCount: payload.nodeCount, capabilityClass: payload.capabilityClass };
+        case "graph:synthesized_from_intent":
+            // AUTHOR-02: requested pattern + synthesized-graph nodeCount (no intent text).
+            return { pattern: payload.pattern, nodeCount: payload.nodeCount };
+        case "subagent:steered":
+            // STEER-01 (175): the steered runId + the closed-union mode (steer|followup) ONLY — NEVER the steer message body (the highest-risk leak); agentId/timestamp are envelope-only and stripped (the graph:repaired precedent).
+            return { runId: payload.runId, mode: payload.mode };
+        case "security:sandbox_downgrade_refused":
+            // ORCH-OBS (SANDBOX-02): the violated sandbox DIMENSION labels ONLY (exec/filesystem/
+            // network/uid) — NEVER the postures' fail-closed values or any path/host/uid-number
+            // that would leak the operator's sandbox topology (§2.7). parent/child agent ids +
+            // timestamp are envelope-only and stripped.
+            return { dimensions: payload.violatedDimensions };
+        case "subagent:delivery_deadlettered":
+            // ORCH-OBS (DELIVERY-02): the dropped run id + the closed channelType + the transient
+            // (retries-exhausted vs immediate-permanent) tag ONLY — NEVER the announcement body or
+            // the error string (§2.7). timestamp envelope-only.
+            return { runId: payload.runId, channelType: payload.channelType, transient: payload.transient };
+        case "subagent:delivery_retried":
+            // OE-6b (DELIVERY-03): the self-healing transient retry — run id + closed channelType +
+            // the 1-based attempt count + the transient tag ONLY (the `explain` view wants the attempt
+            // number so an operator can see HOW MANY retries a completion took before it landed) —
+            // NEVER the announcement body or the error string (§2.7). timestamp envelope-only.
+            return { runId: payload.runId, channelType: payload.channelType, attempt: payload.attempt, transient: payload.transient };
+        case "subagent:budget_exceeded":
+            // ORCH-OBS (BUDGET-03): the per-incident breach view for `comis explain` — graphId/
+            // nodeId ids + the closed capSource + the two token NUMBERS (counts, §2.7-safe; the
+            // explain view DOES want them, unlike the fleet aggregate) — NEVER a task or output.
+            // agentId/timestamp envelope-only.
+            return { graphId: payload.graphId, nodeId: payload.nodeId, capSource: payload.capSource, tokenBudget: payload.tokenBudget, tokensUsed: payload.tokensUsed };
+        case "capability:audited":
+            // AUDIT-01 / TREE (215): the per-node spawn-tree source — capability + tool
+            // NAME + the closed-union decision + the lease/root ids ONLY. NEVER the
+            // tool.invoke args, a message body, or a secret name (the highest-risk leak,
+            // T-215-01 / Pitfall 5). agentId/timestamp/method are envelope-ish labels and
+            // are stripped (the subagent:steered/budget_exceeded precedent). leaseId/
+            // parentLeaseId/tool are honestly absent on the in-process record (no lease, G1).
+            return {
+                capability: payload.capability,
+                tool: payload.tool,
+                decision: payload.decision,
+                leaseId: payload.leaseId,
+                parentLeaseId: payload.parentLeaseId,
+                rootRunId: payload.rootRunId,
+            };
+        case "graph:node_spawned":
+            // TREE-01 (finding D): the per-graph-node spawn-tree leaf — graph/node ids +
+            // the node's CHILD agentId + the tree-stable rootRunId + the per-node token cap
+            // ONLY. NEVER the node task or output. The child agentId rides `data` as
+            // `nodeAgentId` (NOT the correlation key `agentId`, which would be stripped to
+            // the envelope): the daemon coordinator emits this in the PARENT context, so
+            // the envelope agentId is the caller, not the child — the leaf's identity is
+            // DATA about the node, not the emitter's correlation id. timestamp is envelope-only.
+            return {
+                graphId: payload.graphId,
+                nodeId: payload.nodeId,
+                nodeAgentId: payload.agentId,
+                rootRunId: payload.rootRunId,
+                tokenBudget: payload.tokenBudget,
+            };
+        default: {
+            // Exhaustiveness — the switch covers every OrchestrationBridgedEventName.
+            const _exhaustive = eventName;
+            void _exhaustive;
+            return payload;
+        }
+    }
+}

package/node_modules/@comis/observability/dist/trajectory/translate-payload.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Trajectory bridge payload translators (event-specific shape massaging).
+ *
+ * Extracted from `event-bus-bridge.ts` to keep that module under the
+ * file-size cap. `translatePayload` is the exhaustive switch that maps each
+ * mapped EventBus payload into the `data` payload of a trajectory event; the
+ * `TrajectoryBridgedEventName` union (the switch's exhaustiveness key) and the
+ * `TRAJECTORY_BRIDGE_MAPPING` table stay in `event-bus-bridge.ts` (the bridge
+ * imports `translatePayload` back from here). No behavior change.
+ *
+ * SECURITY INVARIANTS are enforced HERE: each translator is the PRIMARY
+ * control deciding which payload fields cross into the persisted trajectory.
+ * Correlation keys (`traceId`, `agentId`, `sessionKey`, `sessionId`) are
+ * envelope-only and MUST NOT be echoed into `data`; verbatim taint strings
+ * (`patterns[]`), raw tool arguments (`approval:requested.params`), user
+ * identifiers, and message bodies are intentionally omitted. The downstream
+ * `sanitizeForPersistence` pass is a defense-in-depth backstop, not a
+ * substitute for translator omission.
+ *
+ * @module
+ */
+import type { TrajectoryBridgedEventName } from "./event-bus-bridge.js";
+/**
+ * Translate one EventBus payload into the `data` payload of a trajectory event.
+ *
+ * Correlation keys (`traceId`, `agentId`, `sessionKey`, `sessionId`) are envelope-only;
+ * translators MUST NOT echo them into `data` (the recorder envelope carries them via
+ * `TrajectoryRecorderInit` + AsyncLocalStorage).
+ */
+export declare function translatePayload(eventName: TrajectoryBridgedEventName, rawPayload: unknown): Record<string, unknown>;