@deepstrike/wasm 0.2.39 → 0.2.41

package/dist/runtime/kernel-step.js

@@ -1,4 +1,25 @@
-export const KERNEL_ABI_VERSION = 1;
+export const KERNEL_ABI_VERSION = 2;
+export function readKernelDiagnostics(runtime) {
+    return JSON.parse(runtime.diagnostics());
+}
+export function snapshotKernelRuntime(runtime) {
+    return JSON.parse(runtime.snapshot());
+}
+export function restoreKernelRuntime(runtime, snapshot) {
+    runtime.restore(JSON.stringify(snapshot));
+    const operationId = snapshot.operation_id;
+    if (!operationId) {
+        kernelWireStates.delete(runtime);
+        return;
+    }
+    const nextEventSequence = snapshot.accepted_inputs.reduce((next, input) => {
+        const match = input.event_id.match(/-event-(\d+)$/);
+        return match ? Math.max(next, Number(match[1]) + 1) : next;
+    }, 1);
+    kernelWireStates.set(runtime, { operationId, nextEventSequence });
+}
+let nextOperationSequence = 1;
+const kernelWireStates = new WeakMap();
 function tryParseJson(s) {
     try {
         return JSON.parse(s);
@@ -41,7 +62,27 @@ export function messageToKernelMessage(message) {
     if (message.tokenCount !== undefined) {
         out.token_count = message.tokenCount;
     }
-    out.content = message.content;
+    // Multimodal: serialize typed content parts to the kernel `Content::Parts` shape when present
+    // (image/audio must survive the reconstruction→preload path, not just live ingress).
+    if (message.contentParts && message.contentParts.length > 0) {
+        out.content = message.contentParts.map(part => {
+            if (part.type === "text")
+                return { type: "text", text: part.text };
+            if (part.type === "tool_result") {
+                return { type: "tool_result", call_id: part.callId, output: part.output, is_error: part.isError };
+            }
+            if (part.type === "image") {
+                return { type: "image", url: part.url, data: part.data, media_type: part.mediaType, detail: part.detail };
+            }
+            if (part.type === "audio") {
+                return { type: "audio", data: part.data, media_type: part.mediaType };
+            }
+            return { type: "text", text: message.content };
+        });
+    }
+    else {
+        out.content = message.content;
+    }
     return out;
 }
 export function toolResultToKernel(result) {
@@ -130,10 +171,14 @@ function renderedContextToSdk(raw) {
     return ctx;
 }
 function mapKernelAction(raw) {
+    const effectId = String(raw.effect_id ?? "");
+    if (!effectId)
+        throw new Error(`kernel action ${String(raw.kind)} is missing effect_id`);
     switch (raw.kind) {
         case "call_provider":
             return {
                 kind: "call_provider",
+                effectId,
                 context: renderedContextToSdk(raw.context ?? {}),
                 tools: (raw.tools ?? []).map(t => ({
                     name: String(t.name ?? ""),
@@ -144,15 +189,49 @@ function mapKernelAction(raw) {
         case "execute_tool":
             return {
                 kind: "execute_tool",
+                effectId,
                 calls: (raw.calls ?? []).map(c => ({
                     id: String(c.id ?? ""),
                     name: String(c.name ?? ""),
                     arguments: JSON.stringify(c.arguments ?? {}),
                 })),
             };
+        case "request_approval":
+            return {
+                kind: "request_approval", effectId,
+                requests: (raw.requests ?? []).map(request => ({
+                    callId: String(request.call_id ?? ""), tool: String(request.tool ?? ""),
+                    arguments: JSON.stringify(request.arguments ?? {}), reason: String(request.reason ?? ""),
+                })),
+            };
+        case "spawn_workflow":
+            return {
+                kind: "spawn_workflow", effectId,
+                nodes: raw.nodes ?? [],
+                ...(raw.budget && typeof raw.budget === "object" ? { budget: raw.budget } : {}),
+            };
+        case "preempt_sub_agents":
+            return { kind: "preempt_sub_agents", effectId, agentIds: raw.agent_ids ?? [], reason: String(raw.reason ?? "") };
+        case "persist_memory":
+            return { kind: "persist_memory", effectId, memory: raw.memory ?? {} };
+        case "query_memory":
+            return { kind: "query_memory", effectId, query: raw.query ?? {}, requestedK: Number(raw.requested_k ?? 0) };
+        case "spool_large_result":
+            return {
+                kind: "spool_large_result", effectId, callId: String(raw.call_id ?? ""), tool: String(raw.tool ?? ""),
+                output: String(raw.output ?? ""), originalSize: Number(raw.original_size ?? 0), previewSize: Number(raw.preview_size ?? 0),
+            };
+        case "archive_page_out":
+            return {
+                kind: "archive_page_out", effectId, turn: Number(raw.turn ?? 0), action: String(raw.action ?? "auto_compact"),
+                ...(typeof raw.summary === "string" ? { summary: raw.summary } : {}),
+                archived: (raw.archived ?? []).map(kernelMessageToSdk),
+                tier: String(raw.tier ?? "durable"),
+            };
         case "evaluate_milestone":
             return {
                 kind: "evaluate_milestone",
+                effectId,
                 phaseId: String(raw.phase_id ?? ""),
                 criteria: raw.criteria ?? [],
                 requiredEvidence: raw.required_evidence ?? [],
@@ -162,6 +241,7 @@ function mapKernelAction(raw) {
             const pace = result.pace_decision;
             return {
                 kind: "done",
+                effectId,
                 result: {
                     termination: String(result.termination ?? "error"),
                     turnsUsed: Number(result.turns_used ?? 0),
@@ -184,16 +264,36 @@ function mapKernelAction(raw) {
             throw new Error(`unknown KernelAction kind: ${String(raw.kind)}`);
     }
 }
-function stepInput(event) {
-    return JSON.stringify({ version: KERNEL_ABI_VERSION, event });
+function stepInput(runtime, event) {
+    let state = kernelWireStates.get(runtime);
+    if (!state) {
+        state = { operationId: `wasm-operation-${nextOperationSequence++}`, nextEventSequence: 1 };
+        kernelWireStates.set(runtime, state);
+    }
+    const correlatedEvent = event.kind === "cancel_operation"
+        ? { ...event, operation_id: state.operationId }
+        : event;
+    return JSON.stringify({
+        version: KERNEL_ABI_VERSION,
+        operation_id: state.operationId,
+        event_id: `${state.operationId}-event-${state.nextEventSequence++}`,
+        observed_at_ms: Date.now(),
+        event: correlatedEvent,
+    });
 }
 export function kernelApply(runtime, pending, event) {
-    const step = parseStep(runtime.step(stepInput(event)));
+    const step = parseStep(runtime.step(stepInput(runtime, event)));
+    const fault = step.faults?.[0];
+    if (fault)
+        throw new Error(`${fault.code ?? "kernel_fault"}: ${fault.message ?? "kernel transition failed"}`);
     pending.push(...step.observations);
     return step.observations;
 }
 export function kernelAction(runtime, pending, event) {
-    const step = parseStep(runtime.step(stepInput(event)));
+    const step = parseStep(runtime.step(stepInput(runtime, event)));
+    const fault = step.faults?.[0];
+    if (fault)
+        throw new Error(`${fault.code ?? "kernel_fault"}: ${fault.message ?? "kernel transition failed"}`);
     pending.push(...step.observations);
     const raw = step.actions[0];
     if (!raw)
@@ -202,11 +302,11 @@ export function kernelAction(runtime, pending, event) {
 }
 /** Like kernelAction but tolerates zero-action steps (e.g. queued signals). */
 export function kernelMaybeAction(runtime, pending, event) {
-    const step = parseStep(runtime.step(stepInput(event)));
+    const step = parseStep(runtime.step(stepInput(runtime, event)));
+    const fault = step.faults?.[0];
+    if (fault)
+        throw new Error(`${fault.code ?? "kernel_fault"}: ${fault.message ?? "kernel transition failed"}`);
     pending.push(...step.observations);
     const raw = step.actions[0];
     return raw ? mapKernelAction(raw) : null;
 }
-export function forceCompact(runtime, pending) {
-    return kernelApply(runtime, pending, { kind: "force_compact" }).some(o => o.kind === "compressed");
-}

package/dist/runtime/kernel-transaction-log.d.ts

@@ -0,0 +1,61 @@
+export declare const KERNEL_LOG_RECORD_VERSION: 1;
+export interface KernelOperationGenesisBody {
+    record_version: typeof KERNEL_LOG_RECORD_VERSION;
+    abi_version: number;
+    operation_id: string;
+    initial_scheduler_policy: Record<string, unknown>;
+    resolved_runtime_defaults: Record<string, unknown>;
+    default_policy_version: number;
+}
+export interface KernelOperationGenesis extends KernelOperationGenesisBody {
+    genesis_digest: string;
+}
+export interface KernelTransactionBody {
+    record_version: typeof KERNEL_LOG_RECORD_VERSION;
+    operation_id: string;
+    step_seq: number;
+    base_generation: number;
+    input: Record<string, unknown>;
+    input_digest: string;
+    previous_transaction_digest: string;
+    step_digest: string;
+}
+export interface KernelTransaction extends KernelTransactionBody {
+    transaction_digest: string;
+}
+export interface KernelGenesisReceipt {
+    log_seq: number;
+    genesis_digest: string;
+}
+export interface DurableAppendReceipt {
+    log_seq: number;
+    transaction_digest: string;
+}
+export interface KernelOperationCursor {
+    operation_id: string;
+    next_event_sequence: number;
+    next_step_seq: number;
+    transaction_head_digest: string;
+}
+export declare class KernelLogConflictError extends Error {
+    constructor(message: string);
+}
+export declare class KernelLogIntegrityError extends Error {
+    constructor(message: string);
+}
+export declare function canonicalKernelJson(value: unknown): string;
+export declare function kernelRecordDigest(value: unknown): Promise<string>;
+export declare function createKernelOperationGenesis(input: Omit<KernelOperationGenesisBody, "record_version">): Promise<KernelOperationGenesis>;
+export declare function createKernelTransaction(input: {
+    operation_id: string;
+    step_seq: number;
+    base_generation: number;
+    input: Record<string, unknown>;
+    step: Record<string, unknown>;
+    previous_transaction_digest: string;
+}): Promise<KernelTransaction>;
+export declare function verifyKernelOperationGenesis(genesis: KernelOperationGenesis): Promise<void>;
+export declare function verifyKernelTransaction(transaction: KernelTransaction): Promise<void>;
+export declare function verifyKernelTransactionSuccessor(previous: KernelTransaction | undefined, transaction: KernelTransaction): void;
+/** Validate one complete authoritative operation stream and derive its next wire cursor. */
+export declare function verifyKernelTransactionStream(genesis: KernelOperationGenesis, transactions: readonly KernelTransaction[]): Promise<KernelOperationCursor>;

package/dist/runtime/kernel-transaction-log.js

@@ -0,0 +1,140 @@
+export const KERNEL_LOG_RECORD_VERSION = 1;
+export class KernelLogConflictError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "KernelLogConflictError";
+    }
+}
+export class KernelLogIntegrityError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "KernelLogIntegrityError";
+    }
+}
+export function canonicalKernelJson(value) {
+    if (value === null)
+        return "null";
+    if (typeof value === "string" || typeof value === "boolean")
+        return JSON.stringify(value);
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw new KernelLogIntegrityError("canonical records require finite numbers");
+        if (Number.isSafeInteger(value))
+            return JSON.stringify(Object.is(value, -0) ? 0 : value);
+        if (Number.isInteger(value)) {
+            throw new KernelLogIntegrityError("canonical record integer exceeds the cross-SDK safe range");
+        }
+        const bytes = new Uint8Array(8);
+        new DataView(bytes.buffer).setFloat64(0, value, false);
+        return `f64:${Array.from(bytes, byte => byte.toString(16).padStart(2, "0")).join("")}`;
+    }
+    if (Array.isArray(value))
+        return `[${value.map(canonicalKernelJson).join(",")}]`;
+    if (typeof value === "object") {
+        const object = value;
+        const keys = Object.keys(object).sort();
+        return `{${keys.map(key => `${JSON.stringify(key)}:${canonicalKernelJson(object[key])}`).join(",")}}`;
+    }
+    throw new KernelLogIntegrityError(`unsupported canonical record value: ${typeof value}`);
+}
+export async function kernelRecordDigest(value) {
+    const bytes = new TextEncoder().encode(canonicalKernelJson(value));
+    const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+    return Array.from(new Uint8Array(digest), byte => byte.toString(16).padStart(2, "0")).join("");
+}
+export async function createKernelOperationGenesis(input) {
+    const body = { record_version: KERNEL_LOG_RECORD_VERSION, ...input };
+    validateGenesisBody(body);
+    return { ...body, genesis_digest: await kernelRecordDigest(body) };
+}
+export async function createKernelTransaction(input) {
+    const body = {
+        record_version: KERNEL_LOG_RECORD_VERSION,
+        operation_id: input.operation_id,
+        step_seq: input.step_seq,
+        base_generation: input.base_generation,
+        input: input.input,
+        input_digest: await kernelRecordDigest(input.input),
+        previous_transaction_digest: input.previous_transaction_digest,
+        step_digest: await kernelRecordDigest(input.step),
+    };
+    validateTransactionBody(body);
+    return { ...body, transaction_digest: await kernelRecordDigest(body) };
+}
+export async function verifyKernelOperationGenesis(genesis) {
+    const { genesis_digest, ...body } = genesis;
+    validateGenesisBody(body);
+    if (await kernelRecordDigest(body) !== genesis_digest) {
+        throw new KernelLogIntegrityError("kernel genesis digest does not match its canonical body");
+    }
+}
+export async function verifyKernelTransaction(transaction) {
+    const { transaction_digest, ...body } = transaction;
+    validateTransactionBody(body);
+    if (await kernelRecordDigest(body.input) !== body.input_digest) {
+        throw new KernelLogIntegrityError("kernel transaction input digest does not match its input");
+    }
+    if (await kernelRecordDigest(body) !== transaction_digest) {
+        throw new KernelLogIntegrityError("kernel transaction digest does not match its canonical body");
+    }
+}
+export function verifyKernelTransactionSuccessor(previous, transaction) {
+    const expectedStepSeq = previous ? previous.step_seq + 1 : 1;
+    const expectedGeneration = previous ? previous.base_generation + 1 : 0;
+    if (transaction.step_seq !== expectedStepSeq) {
+        throw new KernelLogIntegrityError(`kernel transaction step_seq ${transaction.step_seq} does not follow ${expectedStepSeq - 1}`);
+    }
+    if (transaction.base_generation !== expectedGeneration) {
+        throw new KernelLogIntegrityError(`kernel transaction base_generation ${transaction.base_generation} does not match ${expectedGeneration}`);
+    }
+    if (transaction.input.operation_id !== transaction.operation_id) {
+        throw new KernelLogIntegrityError("kernel transaction input operation_id does not match its envelope");
+    }
+}
+/** Validate one complete authoritative operation stream and derive its next wire cursor. */
+export async function verifyKernelTransactionStream(genesis, transactions) {
+    await verifyKernelOperationGenesis(genesis);
+    let previous;
+    let head = genesis.genesis_digest;
+    for (const transaction of transactions) {
+        await verifyKernelTransaction(transaction);
+        if (transaction.operation_id !== genesis.operation_id) {
+            throw new KernelLogIntegrityError("kernel transaction operation_id does not match genesis");
+        }
+        if (transaction.previous_transaction_digest !== head) {
+            throw new KernelLogIntegrityError("kernel transaction digest chain is not continuous");
+        }
+        verifyKernelTransactionSuccessor(previous, transaction);
+        previous = transaction;
+        head = transaction.transaction_digest;
+    }
+    const nextSequence = (previous?.step_seq ?? 0) + 1;
+    return {
+        operation_id: genesis.operation_id,
+        next_event_sequence: nextSequence,
+        next_step_seq: nextSequence,
+        transaction_head_digest: head,
+    };
+}
+function validateGenesisBody(genesis) {
+    if (genesis.record_version !== KERNEL_LOG_RECORD_VERSION)
+        throw new KernelLogIntegrityError("unsupported kernel genesis record version");
+    if (!Number.isSafeInteger(genesis.abi_version) || genesis.abi_version <= 0)
+        throw new KernelLogIntegrityError("kernel genesis abi_version must be a positive safe integer");
+    if (!genesis.operation_id)
+        throw new KernelLogIntegrityError("kernel genesis operation_id is required");
+    if (!Number.isSafeInteger(genesis.default_policy_version) || genesis.default_policy_version <= 0)
+        throw new KernelLogIntegrityError("kernel genesis default_policy_version must be a positive safe integer");
+}
+function validateTransactionBody(transaction) {
+    if (transaction.record_version !== KERNEL_LOG_RECORD_VERSION)
+        throw new KernelLogIntegrityError("unsupported kernel transaction record version");
+    if (!transaction.operation_id)
+        throw new KernelLogIntegrityError("kernel transaction operation_id is required");
+    if (!Number.isSafeInteger(transaction.step_seq) || transaction.step_seq <= 0)
+        throw new KernelLogIntegrityError("kernel transaction step_seq must be a positive safe integer");
+    if (!Number.isSafeInteger(transaction.base_generation) || transaction.base_generation < 0)
+        throw new KernelLogIntegrityError("kernel transaction base_generation must be a non-negative safe integer");
+    if (!transaction.previous_transaction_digest)
+        throw new KernelLogIntegrityError("kernel transaction previous_transaction_digest is required");
+}

package/dist/runtime/os-profile.d.ts

@@ -1,16 +1,17 @@
 import type { GovernancePolicy } from "../governance.js";
 export type OsProfileId = "native";
+export interface SignalPolicy {
+    queueMax: number;
+    ttlMs?: number;
+    deadlineEscalation?: boolean;
+}
 export interface NativeOsProfile {
     id: OsProfileId;
-    attentionPolicy: {
-        maxQueueSize?: number;
-    };
+    signalPolicy: SignalPolicy;
     governancePolicy: GovernancePolicy;
 }
-/** Default attention policy for native profile smoke tests. */
-export declare const DEFAULT_NATIVE_ATTENTION_POLICY: {
-    maxQueueSize: number;
-};
+/** Default signal policy for native profile smoke tests. */
+export declare const DEFAULT_NATIVE_SIGNAL_POLICY: SignalPolicy;
 /** Permissive governance policy for native runs that do not need AskUser. */
 export declare const DEFAULT_NATIVE_GOVERNANCE_POLICY: GovernancePolicy;
 /** Default restrictive sandbox policy template requiring confirmation for modification/execution. */
@@ -22,9 +23,7 @@ export declare function assertNativeProfile(profile?: OsProfileId | NativeOsProf
 /**
  * Validates the declarative policies statically to prevent runtime crashes when loaded into the microkernel.
  */
-export declare function validateDeclarativePolicy(govPolicy?: GovernancePolicy, attentionPolicy?: {
-    maxQueueSize?: number;
-}): {
+export declare function validateDeclarativePolicy(govPolicy?: GovernancePolicy, signalPolicy?: SignalPolicy): {
     valid: boolean;
     errors: string[];
 };

package/dist/runtime/os-profile.js

@@ -1,5 +1,5 @@
-/** Default attention policy for native profile smoke tests. */
-export const DEFAULT_NATIVE_ATTENTION_POLICY = { maxQueueSize: 64 };
+/** Default signal policy for native profile smoke tests. */
+export const DEFAULT_NATIVE_SIGNAL_POLICY = { queueMax: 64 };
 /** Permissive governance policy for native runs that do not need AskUser. */
 export const DEFAULT_NATIVE_GOVERNANCE_POLICY = {
     rules: [{ pattern: "*", action: "allow" }],
@@ -21,7 +21,7 @@ export function osProfile(profile = "native") {
         throw new Error(`Unsupported OS profile: ${profile}`);
     return {
         id: "native",
-        attentionPolicy: DEFAULT_NATIVE_ATTENTION_POLICY,
+        signalPolicy: DEFAULT_NATIVE_SIGNAL_POLICY,
         governancePolicy: DEFAULT_NATIVE_GOVERNANCE_POLICY,
     };
 }
@@ -31,7 +31,7 @@ export function assertNativeProfile(profile = "native") {
     if (resolved.id !== "native") {
         throw new Error(`Unsupported OS profile: ${resolved.id}`);
     }
-    const validation = validateDeclarativePolicy(resolved.governancePolicy, resolved.attentionPolicy);
+    const validation = validateDeclarativePolicy(resolved.governancePolicy, resolved.signalPolicy);
     if (!validation.valid) {
         throw new Error(`Invalid native OS profile: ${validation.errors.join("; ")}`);
     }
@@ -40,7 +40,7 @@ export function assertNativeProfile(profile = "native") {
 /**
  * Validates the declarative policies statically to prevent runtime crashes when loaded into the microkernel.
  */
-export function validateDeclarativePolicy(govPolicy, attentionPolicy) {
+export function validateDeclarativePolicy(govPolicy, signalPolicy) {
     const errors = [];
     if (govPolicy) {
         if (!Array.isArray(govPolicy.rules)) {
@@ -57,11 +57,15 @@ export function validateDeclarativePolicy(govPolicy, attentionPolicy) {
             });
         }
     }
-    if (attentionPolicy) {
-        if (attentionPolicy.maxQueueSize !== undefined) {
-            if (typeof attentionPolicy.maxQueueSize !== "number" || attentionPolicy.maxQueueSize <= 0) {
-                errors.push("AttentionPolicy maxQueueSize must be a positive integer");
-            }
+    if (signalPolicy) {
+        if (!Number.isInteger(signalPolicy.queueMax) || signalPolicy.queueMax <= 0) {
+            errors.push("SignalPolicy queueMax must be a positive integer");
+        }
+        if (signalPolicy.ttlMs !== undefined && (!Number.isInteger(signalPolicy.ttlMs) || signalPolicy.ttlMs <= 0)) {
+            errors.push("SignalPolicy ttlMs must be a positive integer");
+        }
+        if (signalPolicy.deadlineEscalation !== undefined && typeof signalPolicy.deadlineEscalation !== "boolean") {
+            errors.push("SignalPolicy deadlineEscalation must be a boolean");
         }
     }
     return {

package/dist/runtime/os-snapshot.d.ts

@@ -14,10 +14,29 @@ export interface OsSnapshot {
     }>;
     budgetExceeded: Array<{
         turn: number;
+        operation_id: string;
+        reservation_id?: string;
         budget: string;
     }>;
+    budgetUsageReported: Array<{
+        turn: number;
+        operation_id: string;
+        reservation_id: string;
+        tokens: number;
+        subagents: number;
+        rounds: number;
+    }>;
+    cancellations: Array<{
+        turn: number;
+        operation_id: string;
+        reason: "user" | "deadline" | "lease_lost" | "host_shutdown";
+        pending_call_ids: string[];
+    }>;
     signals: Array<{
         turn: number;
+        operation_id: string;
+        delivery_id: string;
+        attempt: number;
         signal_id: string;
         disposition: string;
         queue_depth: number;

package/dist/runtime/os-snapshot.js

@@ -8,8 +8,10 @@ const KERNEL_KINDS = new Set([
     "suspended",
     "resumed",
     "tool_gated",
-    "signal_disposed",
+    "signal_delivery_disposed",
     "budget_exceeded",
+    "budget_usage_reported",
+    "operation_cancelled",
     "checkpoint_taken",
     "rollbacked",
     "agent_process_changed",
@@ -20,6 +22,8 @@ export function rebuildOsSnapshotFromSessionEvents(events) {
     const snap = {
         processByAgent: [],
         budgetExceeded: [],
+        budgetUsageReported: [],
+        cancellations: [],
         signals: [],
         pageOutCount: 0,
         pageInCount: 0,
@@ -62,11 +66,20 @@ export function rebuildOsSnapshotFromSessionEvents(events) {
                 break;
             }
             case "budget_exceeded":
-                snap.budgetExceeded.push({ turn: event.turn, budget: event.budget });
+                snap.budgetExceeded.push({ turn: event.turn, operation_id: event.operation_id, ...(event.reservation_id ? { reservation_id: event.reservation_id } : {}), budget: event.budget });
                 break;
-            case "signal_disposed":
+            case "budget_usage_reported":
+                snap.budgetUsageReported.push({ turn: event.turn, operation_id: event.operation_id, reservation_id: event.reservation_id, tokens: event.tokens, subagents: event.subagents, rounds: event.rounds });
+                break;
+            case "operation_cancelled":
+                snap.cancellations.push({ turn: event.turn, operation_id: event.operation_id, reason: event.reason, pending_call_ids: event.pending_call_ids });
+                break;
+            case "signal_delivery_disposed":
                 snap.signals.push({
                     turn: event.turn,
+                    operation_id: event.operation_id,
+                    delivery_id: event.delivery_id,
+                    attempt: event.attempt,
                     signal_id: event.signal_id,
                     disposition: event.disposition,
                     queue_depth: event.queue_depth,