@deepstrike/sdk 0.2.61 → 0.2.62

package/dist/index.d.ts

@@ -16,6 +16,8 @@ export { InMemorySessionLog, FileSessionLog } from "./runtime/session-log.js";
 export type { SessionLog, SessionEvent } from "./runtime/session-log.js";
 export { FileKernelJournal, InMemoryKernelJournal, JournalCasConflictError, JournalIntegrityError, JournalIoError, } from "./runtime/kernel-journal.js";
 export type { CheckpointCandidate, InstalledCheckpoint, JournalAppendReceipt, JournalEntry, JournalHead, JournalPruneReceipt, JournalRecordInput, KernelJournal, } from "./runtime/kernel-journal.js";
+export { diagnoseKernelJournal } from "./runtime/kernel-doctor.js";
+export type { KernelJournalDiagnosis } from "./runtime/kernel-doctor.js";
 export { InMemoryGroupBudgetStore, GroupBudgetScope } from "./runtime/run-group.js";
 export type { RunGroup, GroupBudgetStore, GroupLedger, GroupCharge, GroupMember, GroupBudgetRequest, GroupBudgetReservation, } from "./runtime/run-group.js";
 export { InMemoryEventStream, isVisibleTo } from "./runtime/event-stream.js";

package/dist/index.js

@@ -22,6 +22,7 @@ export { LocalExecutionPlane } from "./runtime/execution-plane.js";
 export { InMemorySessionLog, FileSessionLog } from "./runtime/session-log.js";
 // ── Durable transaction capability (Canonical Kernel ABI §9.1) ──────────────
 export { FileKernelJournal, InMemoryKernelJournal, JournalCasConflictError, JournalIntegrityError, JournalIoError, } from "./runtime/kernel-journal.js";
+export { diagnoseKernelJournal } from "./runtime/kernel-doctor.js";
 export { InMemoryGroupBudgetStore, GroupBudgetScope } from "./runtime/run-group.js";
 export { InMemoryEventStream, isVisibleTo } from "./runtime/event-stream.js";
 export { ManagedTaskScope, operationAbortSignal } from "./runtime/reliability.js";

package/dist/kernel.d.ts

@@ -141,6 +141,10 @@ export interface CanonicalKernelInstance {
     restore(checkpointBytes: Buffer | undefined, recordBytes: Buffer[]): CanonicalRestoreCost;
     lifecycle(): "created" | "configured" | "running" | "suspended" | "completed" | "cancelled" | "failed";
     pendingEffectsJson(): string;
+    /** Canonical core projection; additive during the 0.2.62 migration. */
+    currentProjectionJson(): string;
+    projectPlannedStepJson(plannedStepJson: string): string;
+    publishedEffectsManifestJson(plannedStepJson: string): string;
     terminalJson(): string | undefined;
 }
 interface KernelModule {

package/dist/runtime/canonical-kernel-step.d.ts

@@ -37,8 +37,8 @@ export interface CanonicalTransition {
     replayed: boolean;
 }
 export declare function canonicalUnsupportedEffectResolution(effectId: string, effectKind: string): CanonicalKernelInput;
-/** The only ABI-v3 planned-step → Node host-action projection. */
-export declare function canonicalActionFromPlannedStep(plannedStep: CanonicalPlannedStep): KernelRunnerAction | null;
+/** Adapt the additive core CurrentProjection JSON into the existing Node action surface. */
+export declare function canonicalActionFromProjectionJson(raw: string): KernelRunnerAction | null;
 export declare class CanonicalKernelRejectedError extends Error {
     readonly fault: Record<string, unknown>;
     constructor(faultJson: string);

package/dist/runtime/canonical-kernel-step.js

@@ -41,239 +41,186 @@ export function canonicalUnsupportedEffectResolution(effectId, effectKind) {
     };
 }
 /** The only ABI-v3 planned-step → Node host-action projection. */
-export function canonicalActionFromPlannedStep(plannedStep) {
-    if (plannedStep.disposition.kind === "terminal") {
-        const terminal = plannedStep.disposition.terminal;
-        const usage = asObject(terminal.usage);
-        let termination = String(terminal.kind ?? "failed");
-        let turnsUsed = Number(usage.turns ?? 0);
-        if (terminal.kind === "agent") {
-            const result = asObject(terminal.result);
-            termination = String(result.termination ?? "completed");
-            turnsUsed = Number(result.turns_used ?? turnsUsed);
-            const finalMessage = asObject(result.final_message);
-            const pace = asObject(result.pace_decision);
-            if (Object.keys(finalMessage).length > 0) {
-                return {
-                    kind: "done",
-                    effectId: "",
-                    result: {
-                        termination,
-                        turnsUsed,
-                        totalTokensUsed: totalUsageTokens(terminal),
-                        finalMessage: {
-                            role: String(finalMessage.role ?? "assistant"),
-                            content: String(finalMessage.content ?? ""),
-                            toolCalls: (Array.isArray(finalMessage.tool_calls) ? finalMessage.tool_calls : [])
-                                .map(value => {
-                                const call = asObject(value);
-                                return {
-                                    id: String(call.call_id ?? ""),
-                                    name: String(call.name ?? ""),
-                                    arguments: JSON.stringify(call.arguments ?? {}),
-                                };
-                            }),
-                        },
-                        ...(Object.keys(pace).length > 0
-                            ? {
-                                paceDecision: {
-                                    action: String(pace.action ?? "stop"),
-                                    ...(pace.delay_ms !== undefined ? { delayMs: Number(pace.delay_ms) } : {}),
-                                    reason: String(pace.reason ?? ""),
-                                    ...(pace.coerced_from ? { coercedFrom: String(pace.coerced_from) } : {}),
-                                },
-                            }
-                            : {}),
-                    },
-                };
-            }
-        }
-        else if (terminal.kind === "workflow") {
-            const outcome = asObject(terminal.outcome);
-            termination = String(outcome.status ?? "completed");
-        }
-        else if (terminal.kind === "cancelled") {
-            termination = String(terminal.reason ?? "cancelled");
-        }
-        else if (terminal.kind === "failed") {
-            const failure = asObject(terminal.failure);
-            termination = failure.code === "provider_recovery_exhausted"
-                ? "context_overflow"
-                : "error";
-        }
+function canonicalDoneFromTerminal(terminal) {
+    const usage = asObject(terminal.usage);
+    let termination = String(terminal.kind ?? "failed");
+    let turnsUsed = Number(usage.turns ?? 0);
+    if (terminal.kind === "agent") {
+        const result = asObject(terminal.result);
+        termination = String(result.termination ?? "completed");
+        turnsUsed = Number(result.turns_used ?? turnsUsed);
+        const finalMessage = asObject(result.final_message);
+        const pace = asObject(result.pace_decision);
         return {
-            kind: "done",
-            effectId: "",
+            kind: "done", effectId: "",
             result: {
-                termination,
-                turnsUsed,
-                totalTokensUsed: totalUsageTokens(terminal),
+                termination, turnsUsed, totalTokensUsed: totalUsageTokens(terminal),
+                ...(Object.keys(finalMessage).length > 0 ? { finalMessage: {
+                        role: String(finalMessage.role ?? "assistant"),
+                        content: String(finalMessage.content ?? ""),
+                        toolCalls: (Array.isArray(finalMessage.tool_calls) ? finalMessage.tool_calls : []).map(value => {
+                            const call = asObject(value);
+                            return { id: String(call.call_id ?? ""), name: String(call.name ?? ""), arguments: JSON.stringify(call.arguments ?? {}) };
+                        }),
+                    } } : {}),
+                ...(Object.keys(pace).length > 0 ? { paceDecision: {
+                        action: String(pace.action ?? "stop"),
+                        ...(pace.delay_ms !== undefined ? { delayMs: Number(pace.delay_ms) } : {}),
+                        reason: String(pace.reason ?? ""),
+                        ...(pace.coerced_from ? { coercedFrom: String(pace.coerced_from) } : {}),
+                    } } : {}),
             },
         };
     }
-    const published = plannedStep.disposition.effects ?? [];
-    if (published.length === 0)
+    if (terminal.kind === "workflow")
+        termination = String(asObject(terminal.outcome).status ?? "completed");
+    if (terminal.kind === "cancelled")
+        termination = String(terminal.reason ?? "cancelled");
+    if (terminal.kind === "failed")
+        termination = asObject(terminal.failure).code === "provider_recovery_exhausted" ? "context_overflow" : "error";
+    return { kind: "done", effectId: "", result: { termination, turnsUsed, totalTokensUsed: totalUsageTokens(terminal) } };
+}
+/** Adapt the additive core CurrentProjection JSON into the existing Node action surface. */
+export function canonicalActionFromProjectionJson(raw) {
+    const projection = asObject(JSON.parse(raw));
+    const state = String(projection.state ?? "idle");
+    if (state === "idle")
         return null;
-    if (published.length !== 1) {
-        throw new Error(`Node runner expects one canonical effect at a time, received ${published.length}`);
+    if (state === "terminal") {
+        return canonicalDoneFromTerminal(asObject(projection.action));
     }
-    const envelope = asObject(published[0]);
-    const effectId = String(envelope.effect_id ?? "");
-    const effect = asObject(envelope.effect);
-    if (!effectId)
-        throw new Error("canonical effect is missing effect_id");
-    switch (effect.kind) {
-        case "call_provider":
-            return {
-                kind: "call_provider",
-                effectId,
-                context: renderedContextToSdk(asObject(effect.context)),
-                tools: (Array.isArray(effect.tools) ? effect.tools : []).map(raw => {
-                    const tool = asObject(raw);
-                    return {
-                        name: String(tool.name ?? ""),
-                        description: String(tool.description ?? ""),
-                        parameters: JSON.stringify(tool.parameters ?? {}),
-                    };
-                }),
-            };
-        case "execute_tools":
-            return {
-                kind: "execute_tool",
-                effectId,
-                calls: (Array.isArray(effect.calls) ? effect.calls : []).map(raw => {
-                    const call = asObject(raw);
-                    return {
-                        id: String(call.call_id ?? ""),
-                        name: String(call.name ?? ""),
-                        arguments: JSON.stringify(call.arguments ?? {}),
-                    };
-                }),
-            };
-        case "request_approval":
-            return {
-                kind: "request_approval",
-                effectId,
-                requests: (Array.isArray(effect.requests) ? effect.requests : []).map(raw => {
-                    const request = asObject(raw);
-                    return {
-                        callId: String(request.call_id ?? ""),
-                        tool: String(request.tool_name ?? ""),
-                        arguments: JSON.stringify(request.arguments ?? {}),
-                        reason: String(request.reason ?? ""),
-                    };
-                }),
-            };
-        case "spawn_tasks":
-            return {
-                kind: "spawn_workflow",
-                effectId,
-                nodes: (Array.isArray(effect.tasks) ? effect.tasks : []).map(raw => {
-                    const task = asObject(raw);
-                    const spec = asObject(task.spec);
-                    return {
-                        agent_id: String(task.task_id ?? ""),
-                        task_id: String(task.task_id ?? ""),
-                        attempt_id: String(task.attempt_id ?? ""),
-                        launch_token: String(task.launch_token ?? ""),
-                        node_id: String(task.node_id ?? ""),
-                        goal: String(spec.goal ?? ""),
-                        role: String(spec.role ?? "custom"),
-                        isolation: String(spec.isolation ?? "shared"),
-                        context_inheritance: String(spec.context_inheritance ?? "none"),
-                        ...(spec.metadata && typeof spec.metadata === "object"
-                            ? asObject(spec.metadata)
-                            : {}),
-                    };
-                }),
-                ...(effect.budget ? { budget: asObject(effect.budget) } : {}),
-            };
-        case "preempt_tasks": {
-            const attempts = (Array.isArray(effect.attempts) ? effect.attempts : []).map(raw => {
-                const attempt = asObject(raw);
+    const action = asObject(projection.action);
+    const payload = asObject(action.payload);
+    const effectId = String(action.effect_id ?? "");
+    if (action.kind === "query_memory") {
+        return {
+            kind: "query_memory",
+            effectId,
+            query: asObject(payload.query),
+            requestedK: Number(payload.requested_k ?? 0),
+        };
+    }
+    if (action.kind === "execute_tools") {
+        return {
+            kind: "execute_tool",
+            effectId,
+            calls: (Array.isArray(payload.calls) ? payload.calls : []).map(raw => {
+                const call = asObject(raw);
                 return {
-                    task_id: String(attempt.task_id ?? ""),
-                    attempt_id: String(attempt.attempt_id ?? ""),
+                    id: String(call.call_id ?? ""),
+                    name: String(call.name ?? ""),
+                    arguments: JSON.stringify(call.arguments ?? {}),
                 };
-            });
-            return {
-                kind: "preempt_sub_agents",
-                effectId,
-                attempts,
-                agentIds: attempts.map(attempt => attempt.task_id),
-                reason: String(effect.reason ?? ""),
-            };
-        }
-        case "persist_memory":
-            return {
-                kind: "persist_memory",
-                effectId,
-                memory: asObject(effect.memory),
-            };
-        case "query_memory":
-            return {
-                kind: "query_memory",
-                effectId,
-                query: asObject(effect.query),
-                requestedK: Number(effect.requested_k ?? 0),
-            };
-        case "archive_page_out": {
-            const payload = asObject(effect.payload);
-            let archived = [];
-            try {
-                const decoded = JSON.parse(String(payload.content ?? ""));
-                if (Array.isArray(decoded)) {
-                    archived = decoded.map(value => kernelMessageToSdk(asObject(value)));
-                }
-            }
-            catch {
-                // Persistence still uses the opaque body and digest. Only optional presentation-side
-                // summarization is skipped if the archived message batch cannot be decoded.
-            }
-            const compressed = (plannedStep.observations ?? [])
-                .find(observation => observation.kind === "compressed");
-            const pressureAction = compressed ? String(compressed.action ?? "") : "";
-            return {
-                kind: "archive_page_out",
-                effectId,
-                handleId: String(effect.handle_id ?? ""),
-                payload,
-                archived,
-                ...(pressureAction ? { action: pressureAction } : {}),
-                ...(compressed?.summary ? { summary: String(compressed.summary) } : {}),
-                ...(pressureAction
-                    ? {
-                        tier: ["context_collapse", "auto_compact"].includes(pressureAction)
-                            ? "semantic"
-                            : "durable",
-                    }
-                    : {}),
-            };
+            }),
+        };
+    }
+    if (action.kind === "call_provider") {
+        const context = asObject(payload.context);
+        return {
+            kind: "call_provider",
+            effectId,
+            context: renderedContextToSdk(context),
+            tools: (Array.isArray(payload.tools) ? payload.tools : []).map(raw => {
+                const tool = asObject(raw);
+                return {
+                    name: String(tool.name ?? ""),
+                    description: String(tool.description ?? ""),
+                    parameters: JSON.stringify(tool.parameters ?? {}),
+                };
+            }),
+        };
+    }
+    if (action.kind === "request_approval") {
+        return {
+            kind: "request_approval",
+            effectId,
+            requests: (Array.isArray(payload.requests) ? payload.requests : []).map(raw => {
+                const request = asObject(raw);
+                return {
+                    callId: String(request.call_id ?? ""),
+                    tool: String(request.tool_name ?? ""),
+                    arguments: JSON.stringify(request.arguments ?? {}),
+                    reason: String(request.reason ?? ""),
+                };
+            }),
+        };
+    }
+    if (action.kind === "load_payload") {
+        return {
+            kind: "load_payload",
+            effectId,
+            handleId: String(payload.handle_id ?? ""),
+            payloadRef: String(payload.payload_ref ?? ""),
+        };
+    }
+    if (action.kind === "evaluate_milestone") {
+        const request = asObject(payload.request);
+        return {
+            kind: "evaluate_milestone",
+            effectId,
+            phaseId: String(request.phase_id ?? ""),
+            criteria: [],
+            requiredEvidence: [],
+        };
+    }
+    if (action.kind === "spawn_tasks") {
+        return {
+            kind: "spawn_workflow",
+            effectId,
+            nodes: (Array.isArray(payload.tasks) ? payload.tasks : []).map(raw => {
+                const task = asObject(raw);
+                const spec = asObject(task.spec);
+                return {
+                    agent_id: String(task.task_id ?? ""), task_id: String(task.task_id ?? ""),
+                    attempt_id: String(task.attempt_id ?? ""), launch_token: String(task.launch_token ?? ""),
+                    node_id: String(task.node_id ?? ""), goal: String(spec.goal ?? ""),
+                    role: String(spec.role ?? "custom"), isolation: String(spec.isolation ?? "shared"),
+                    context_inheritance: String(spec.context_inheritance ?? "none"),
+                    ...(spec.metadata && typeof spec.metadata === "object" ? asObject(spec.metadata) : {}),
+                };
+            }),
+            ...(payload.budget ? { budget: asObject(payload.budget) } : {}),
+        };
+    }
+    if (action.kind === "preempt_tasks") {
+        const attempts = (Array.isArray(payload.attempts) ? payload.attempts : []).map(raw => {
+            const attempt = asObject(raw);
+            return { task_id: String(attempt.task_id ?? ""), attempt_id: String(attempt.attempt_id ?? "") };
+        });
+        return { kind: "preempt_sub_agents", effectId, attempts, agentIds: attempts.map(a => a.task_id), reason: String(payload.reason ?? "") };
+    }
+    if (action.kind === "persist_memory") {
+        return { kind: "persist_memory", effectId, memory: asObject(payload.memory) };
+    }
+    if (action.kind === "archive_page_out") {
+        const archivePayload = asObject(payload.payload);
+        let archived = [];
+        try {
+            const decoded = JSON.parse(String(archivePayload.content ?? ""));
+            if (Array.isArray(decoded))
+                archived = decoded.map(value => kernelMessageToSdk(asObject(value)));
         }
-        case "load_payload":
-            return {
-                kind: "load_payload",
-                effectId,
-                handleId: String(effect.handle_id ?? ""),
-                payloadRef: String(effect.payload_ref ?? ""),
-            };
-        case "evaluate_milestone": {
-            const request = asObject(effect.request);
-            return {
-                kind: "evaluate_milestone",
-                effectId,
-                phaseId: String(request.phase_id ?? ""),
-                criteria: [],
-                requiredEvidence: [],
-            };
+        catch {
+            // The opaque archive payload remains authoritative even when presentation decoding fails.
         }
-        default:
-            return {
-                kind: "unsupported_effect",
-                effectId,
-                effectKind: String(effect.kind),
-            };
+        return {
+            kind: "archive_page_out",
+            effectId,
+            handleId: String(payload.handle_id ?? ""),
+            payload: {
+                content: String(archivePayload.content ?? ""),
+                digest: String(archivePayload.digest ?? ""),
+                original_size: String(archivePayload.original_size ?? "0"),
+                ...(archivePayload.preview ? { preview: String(archivePayload.preview) } : {}),
+            },
+            archived,
+        };
     }
+    return {
+        kind: "unsupported_effect",
+        effectId,
+        effectKind: String(action.kind ?? ""),
+    };
 }
 export class CanonicalKernelRejectedError extends Error {
     fault;
@@ -1178,6 +1125,16 @@ export class CanonicalRunnerRuntime {
                             throw new Error("canonical observation is missing kind");
                         this.hostObservations.push({ ...raw, kind });
                     }
+                    // §7.11 · a committed step that publishes effects is a fact worth recording in the
+                    // host event log: the journal stores only a digest of the step, so this manifest is
+                    // what makes the published effect ids + kinds recoverable post-hoc without replaying.
+                    const published = JSON.parse(this.host.kernel.publishedEffectsManifestJson(JSON.stringify(transition.plannedStep)));
+                    if (published.length > 0) {
+                        this.hostObservations.push({
+                            kind: "step_published_effects",
+                            effects: published,
+                        });
+                    }
                     if (transition.checkpointAdvice) {
                         this.hostObservations.push({
                             kind: "checkpoint_advised",
@@ -1191,7 +1148,7 @@ export class CanonicalRunnerRuntime {
                         });
                     }
                 }
-                this.lastAction = canonicalActionFromPlannedStep(transition.plannedStep);
+                this.lastAction = canonicalActionFromProjectionJson(this.host.kernel.projectPlannedStepJson(JSON.stringify(transition.plannedStep)));
             }
             if (this.lastAction?.kind !== "unsupported_effect")
                 return this.lastAction;
@@ -1199,16 +1156,7 @@ export class CanonicalRunnerRuntime {
         }
     }
     currentAction() {
-        const terminal = this.host.kernel.terminalJson();
-        if (terminal) {
-            return canonicalActionFromPlannedStep({
-                disposition: { kind: "terminal", terminal: JSON.parse(terminal) },
-            });
-        }
-        const effects = this.pendingEffects();
-        return canonicalActionFromPlannedStep({
-            disposition: { kind: "effects", effects },
-        });
+        return canonicalActionFromProjectionJson(this.host.kernel.currentProjectionJson());
     }
     pendingEffects() {
         return JSON.parse(this.host.kernel.pendingEffectsJson());

package/dist/runtime/kernel-doctor.d.ts

@@ -0,0 +1,36 @@
+import type { CanonicalKernelInstance } from "../kernel.js";
+import type { KernelJournal } from "./kernel-journal.js";
+/**
+ * What a journal inspection knows: whether the operation restores, and — when it does not — which
+ * record is the first this binary cannot replay. The effect manifest (which effects each step
+ * published) lives in the host event log via the `step_published_effects` observation, not here:
+ * a journal stores only each record's input and digests, never the step it produced (§8.1).
+ */
+export interface KernelJournalDiagnosis {
+    operationId: string;
+    recordCount: number;
+    /** True when `restore()` replayed the whole journal and verified every step digest. */
+    restorable: boolean;
+    /**
+     * The `step_seq` of the first record whose replay diverged from the durable digest, when known.
+     * The restore failure message names this step; a fault before any record replays leaves it null.
+     */
+    divergenceStep: number | null;
+    divergenceReason: string | null;
+    /** The operation's terminal, only when the journal restored cleanly. */
+    terminal: Record<string, unknown> | undefined;
+    /** Pending effects at the head, only when the journal restored cleanly. */
+    pendingEffects: Array<{
+        effect_id: string;
+        kind: string;
+    }>;
+}
+/**
+ * Inspect a durable journal without committing anything: replay it through the kernel and report
+ * whether it still restores. This turns a "silent brick" — an operation whose journal was appended
+ * but whose step can no longer be re-derived by this binary — into an actionable diagnosis: which
+ * record diverges, and what the head still holds if it does not.
+ *
+ * Nothing is mutated; the same journal can be diagnosed repeatedly and then restored normally.
+ */
+export declare function diagnoseKernelJournal(kernel: CanonicalKernelInstance, journal: KernelJournal, operationId: string): Promise<KernelJournalDiagnosis>;

package/dist/runtime/kernel-doctor.js

@@ -0,0 +1,60 @@
+const DIVERGENCE_STEP = /at step (\d+)/;
+/**
+ * Inspect a durable journal without committing anything: replay it through the kernel and report
+ * whether it still restores. This turns a "silent brick" — an operation whose journal was appended
+ * but whose step can no longer be re-derived by this binary — into an actionable diagnosis: which
+ * record diverges, and what the head still holds if it does not.
+ *
+ * Nothing is mutated; the same journal can be diagnosed repeatedly and then restored normally.
+ */
+export async function diagnoseKernelJournal(kernel, journal, operationId) {
+    const checkpoint = await journal.latestCheckpoint(operationId);
+    const records = await journal.recordsAfter(operationId, checkpoint?.covered_head);
+    try {
+        const cost = kernel.restore(checkpoint ? Buffer.from(checkpoint.checkpoint_bytes) : undefined, records.map(record => Buffer.from(record.record_bytes)));
+        return {
+            operationId,
+            recordCount: records.length,
+            restorable: true,
+            divergenceStep: null,
+            divergenceReason: null,
+            terminal: parseJson(kernel.terminalJson()),
+            pendingEffects: parsePendingEffects(kernel.pendingEffectsJson()),
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const match = DIVERGENCE_STEP.exec(message);
+        return {
+            operationId,
+            recordCount: records.length,
+            restorable: false,
+            divergenceStep: match ? Number(match[1]) : null,
+            divergenceReason: message,
+            terminal: undefined,
+            pendingEffects: [],
+        };
+    }
+}
+function parseJson(value) {
+    if (!value)
+        return undefined;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function parsePendingEffects(raw) {
+    const parsed = parseJson(raw);
+    if (!Array.isArray(parsed))
+        return [];
+    return parsed.map(envelope => {
+        const effect = envelope?.effect;
+        return {
+            effect_id: String(envelope?.effect_id ?? ""),
+            kind: String(effect?.kind ?? ""),
+        };
+    });
+}

package/dist/runtime/kernel-step.d.ts

@@ -73,11 +73,7 @@ export type KernelRunnerAction = {
 } | {
     kind: "archive_page_out";
     effectId: string;
-    turn?: number;
-    action?: string;
-    summary?: string;
     archived?: Message[];
-    tier?: string;
     handleId?: string;
     payload?: {
         content: string;
@@ -200,7 +196,18 @@ export interface KernelObservation {
     rollbacks_in_window?: number;
     window_turns?: number;
     threshold?: number;
+    effects?: Array<{
+        effect_id: string;
+        kind: string;
+    }>;
 }
+/** Presentation/policy facts for an archive action come from committed observations, never from
+ * the wire effect projection. */
+export declare function archivePresentationFromObservations(observations: readonly KernelObservation[]): {
+    action?: string;
+    summary?: string;
+    tier?: "semantic" | "durable";
+};
 export declare function toolSchemaToKernel(schema: ToolSchema): Record<string, unknown>;
 export declare function skillMetadataToKernel(skill: SkillMetadata): Record<string, unknown>;
 export declare function messageToKernelMessage(message: Message): Record<string, unknown>;

package/dist/runtime/kernel-step.js

@@ -15,6 +15,26 @@ function decodeCanonicalContentParts(content) {
         return undefined;
     }
 }
+/** Presentation/policy facts for an archive action come from committed observations, never from
+ * the wire effect projection. */
+export function archivePresentationFromObservations(observations) {
+    const compressed = [...observations].reverse().find(observation => observation.kind === "compressed");
+    if (!compressed)
+        return {};
+    const action = compressionActionFromObservation(compressed.action);
+    if (!action)
+        return {};
+    return {
+        action,
+        ...(compressed.summary ? { summary: compressed.summary } : {}),
+        tier: action === "context_collapse" || action === "auto_compact" ? "semantic" : "durable",
+    };
+}
+function compressionActionFromObservation(action) {
+    return action === "snip_compact" || action === "micro_compact" || action === "context_collapse" || action === "auto_compact"
+        ? action
+        : undefined;
+}
 function tryParseJson(s) {
     try {
         return JSON.parse(s);

package/dist/runtime/runner.d.ts

@@ -9,6 +9,7 @@ import type { ExecutionPlane } from "./execution-plane.js";
 import type { RunGroup } from "./run-group.js";
 import { type MemoryPolicy, type ResourceQuota } from "../kernel.js";
 import type { AgentRunSpec, MilestoneCheckResult, MilestoneContract, MilestonePolicy, WorkflowSpec, WorkflowOutcome } from "../types/agent.js";
+export declare function stableSemanticArchiveName(effectId: string): string;
 import { type SubAgentOrchestrator } from "./sub-agent-orchestrator.js";
 import { type ReducerRegistry } from "./reducers.js";
 import { type GovernancePolicy } from "../governance.js";

package/dist/runtime/runner.js

@@ -7,8 +7,17 @@ import { peekProviderReplay, seedProviderReplayFromEvents } from "./provider-rep
 import { sanitizeReplayText } from "./replay-sanitize.js";
 import { buildLlmCompletedEvent, buildRunTerminalEvent, buildWorkflowNodeCompletedEvent, buildWorkflowNodesSubmittedEvent, } from "./session-repair.js";
 import { KernelPrimitivesDashboard } from "./kernel-primitives-dashboard.js";
-import { capabilityMarker, capabilitySkill, capabilityTool, capabilityCommandMount, capabilityCommandUnmount, entropySampleFromObservation, messageToKernelMessage, skillMetadataToKernel, taskUpdateToKernel, toolResultToKernel, toolSchemaToKernel, } from "./kernel-step.js";
+import { capabilityMarker, capabilitySkill, capabilityTool, capabilityCommandMount, capabilityCommandUnmount, archivePresentationFromObservations, entropySampleFromObservation, messageToKernelMessage, skillMetadataToKernel, taskUpdateToKernel, toolResultToKernel, toolSchemaToKernel, } from "./kernel-step.js";
 import { CanonicalKernelRejectedError, CanonicalRunnerRuntime, canonicalKernelAction, canonicalKernelApply, canonicalKernelMaybeAction, canonicalStartAgent, canonicalStartWorkflow, } from "./canonical-kernel-step.js";
+export function stableSemanticArchiveName(effectId) {
+    const stableEffectId = effectId.replace(/[^a-zA-Z0-9._:-]/g, "_");
+    return `page-out-${stableEffectId || "unknown"}`;
+}
+function compressionAction(action) {
+    return action === "snip_compact" || action === "micro_compact" || action === "context_collapse" || action === "auto_compact"
+        ? action
+        : undefined;
+}
 import { agentRunSpecToKernel, MILESTONE_UNVERIFIED_REASON, milestoneCheckFail, milestoneCheckPass, milestoneCheckResultToKernel, subAgentResultToKernel, workflowBudgetNote, workflowNodeSpecToKernel, workflowNodeOutcomeFromKernel, workflowNodeStatusFromTermination, workflowNodeToManifest, workflowNodeToSpec, workflowSpecToKernel, } from "../types/agent.js";
 import { defaultSubAgentOrchestrator } from "./sub-agent-orchestrator.js";
 import { extractJsonValue, schemaInstruction, schemaRetryInstruction, validateAgainstSchema, } from "./output-schema.js";
@@ -1914,6 +1923,7 @@ export class RuntimeRunner {
                             await this.logMemoryRetrievalResult(sessionId, hits);
                     }
                     else if (action.kind === "archive_page_out") {
+                        const archiveEffectId = action.effectId;
                         const archiveMeta = this.activePageOutArchive
                             ?? this.pendingPageOutArchives.shift()
                             ?? {
@@ -1941,8 +1951,8 @@ export class RuntimeRunner {
                             error = formatToolError(cause);
                         }
                         const archived = action.archived ?? [];
-                        const archiveAction = compressionAction(action.action) ?? "auto_compact";
-                        const archiveTier = action.tier;
+                        const archiveAction = archiveMeta.action ?? "auto_compact";
+                        const archiveTier = archiveMeta.tier;
                         const compressedSeq = archiveMeta.compressedSeq;
                         if (!error)
                             this.activePageOutArchive = undefined;
@@ -1959,7 +1969,7 @@ export class RuntimeRunner {
                                 taskScope.spawn("compressed-summary-upgrade", upgrade);
                             }
                             if (archiveTier === "semantic" && archived.length > 0) {
-                                taskScope.spawn("semantic-page-out", () => this.archiveSemanticPageOut(archived, archiveAction, sessionId));
+                                taskScope.spawn("semantic-page-out", () => this.archiveSemanticPageOut(archived, archiveAction, sessionId, archiveEffectId));
                             }
                         }
                     }
@@ -2516,7 +2526,12 @@ export class RuntimeRunner {
             const compressedSeq = await this.opts.sessionLog.append(sessionId, event);
             if (event.kind === "compressed") {
                 if ((obs.archived_count ?? 0) > 0) {
-                    this.pendingPageOutArchives.push({ archiveStart: nextArchiveStart, compressedSeq });
+                    const archivePresentation = archivePresentationFromObservations([obs]);
+                    this.pendingPageOutArchives.push({
+                        archiveStart: nextArchiveStart,
+                        compressedSeq,
+                        ...archivePresentation,
+                    });
                 }
                 nextArchiveStart = compressedSeq + 1;
             }
@@ -2529,37 +2544,58 @@ export class RuntimeRunner {
         }
         return nextArchiveStart;
     }
-    async archiveSemanticPageOut(archived, action, sessionId) {
+    async archiveSemanticPageOut(archived, action, sessionId, effectId = "unknown") {
         if (!this.opts.memoryStore || !this.opts.agentId || !this.opts.memoryScope)
             return;
-        const summary = this.opts.memorySummarizer
-            ? await this.opts.memorySummarizer.summarize(archived, { action })
-            : await summarizeForLongTermMemory(this.opts.memoryProvider ?? this.opts.provider, archived, this.opts.memorySystemPrompt);
-        // P2 write-funnel: route through the ONE gated WriteMemory syscall so validation,
-        // the rolling write quota, dedup, and the memory_written audit all apply. Score is
-        // advisory (0.6) — an automatic summary must never outrank curated content.
-        const now = Date.now();
-        const name = `page-out-${now}`;
-        await this.writeMemory({
-            record_id: `${this.opts.memoryScope.tenant_id}:${this.opts.memoryScope.namespace}:project:${name}`,
-            scope: this.opts.memoryScope,
-            name,
-            kind: "project",
-            content: summary,
-            description: `auto summary of ${action ?? "compaction"} archive`,
-            provenance: {
-                session_id: sessionId,
-                author: "extraction",
-                trust: "untrusted",
-                evidence_refs: [],
-            },
-            created_at: now,
-            updated_at: now,
-            recall_count: 0,
-            confidence: 0.6,
-            links: [],
-            pinned: false,
-        }, { sessionId, agentId: this.opts.agentId });
+        await this.opts.sessionLog.append(sessionId, {
+            kind: "semantic_archive_pending",
+            effect_id: effectId,
+            ...(action ? { action } : {}),
+        });
+        try {
+            const summary = this.opts.memorySummarizer
+                ? await this.opts.memorySummarizer.summarize(archived, { action })
+                : await summarizeForLongTermMemory(this.opts.memoryProvider ?? this.opts.provider, archived, this.opts.memorySystemPrompt);
+            // P2 write-funnel: route through the ONE gated WriteMemory syscall so validation,
+            // the rolling write quota, dedup, and the memory_written audit all apply. Score is
+            // advisory (0.6) — an automatic summary must never outrank curated content.
+            const now = Date.now();
+            const name = stableSemanticArchiveName(effectId);
+            const recordId = `${this.opts.memoryScope.tenant_id}:${this.opts.memoryScope.namespace}:project:${name}`;
+            await this.writeMemory({
+                record_id: recordId,
+                scope: this.opts.memoryScope,
+                name,
+                kind: "project",
+                content: summary,
+                description: `auto summary of ${action ?? "compaction"} archive`,
+                provenance: {
+                    session_id: sessionId,
+                    author: "extraction",
+                    trust: "untrusted",
+                    evidence_refs: [],
+                },
+                created_at: now,
+                updated_at: now,
+                recall_count: 0,
+                confidence: 0.6,
+                links: [],
+                pinned: false,
+            }, { sessionId, agentId: this.opts.agentId });
+            await this.opts.sessionLog.append(sessionId, {
+                kind: "semantic_archive_completed",
+                effect_id: effectId,
+                record_id: recordId,
+            });
+        }
+        catch (error) {
+            await this.opts.sessionLog.append(sessionId, {
+                kind: "semantic_archive_failed",
+                effect_id: effectId,
+                error: formatToolError(error),
+            });
+            throw error;
+        }
     }
     async upgradeCompressedSummary(sessionId, compressedSeq, archived, action, runtime) {
         const summary = await this.opts.asyncSummarizer.summarize(archived, action);
@@ -2634,15 +2670,6 @@ function attachmentsToKernelMessage(parts) {
     });
     return { role: "user", content };
 }
-function compressionAction(action) {
-    if (action === "snip_compact" ||
-        action === "micro_compact" ||
-        action === "context_collapse" ||
-        action === "auto_compact") {
-        return action;
-    }
-    return undefined;
-}
 async function summarizeForLongTermMemory(provider, archived, systemPrompt) {
     const transcript = archived
         .map(m => `${m.role}: ${m.content}`)

package/dist/runtime/session-log.d.ts

@@ -98,6 +98,18 @@ export type SessionEvent = {
     tier_hint?: string;
     message_count?: number;
     archive_ref?: string;
+} | {
+    kind: "semantic_archive_pending";
+    effect_id: string;
+    action?: string;
+} | {
+    kind: "semantic_archive_completed";
+    effect_id: string;
+    record_id: string;
+} | {
+    kind: "semantic_archive_failed";
+    effect_id: string;
+    error: string;
 } | {
     kind: "page_in";
     turn: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/sdk",
-  "version": "0.2.61",
+  "version": "0.2.62",
   "description": "DeepStrike Node.js SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -72,7 +72,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.99.0",
-    "@deepstrike/core": "0.2.61",
+    "@deepstrike/core": "0.2.62",
     "@google/generative-ai": "^0.24.1",
     "openai": "^7.5.0"
   },