@deepstrike/sdk 0.2.61 → 0.2.63

package/dist/runtime/runner.js

@@ -7,15 +7,25 @@ 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";
 import { resolveReducer } from "./reducers.js";
 import { loopInstruction, classifyInstruction, judgeGoal, dependencyOutputsNote, extractClassifyBranch, extractJudgeWinner, } from "./workflow-control-flow.js";
 import { governancePolicyToKernelEvent, governanceFilterSchema } from "../governance.js";
-import { createProviderRequestPlanForProvider, estimateProviderPromptTokens, measurementForPlan, recordPromptMeasurement, } from "../providers/request-plan.js";
+import { createProviderRequestPlanForProvider, estimateProviderPromptTokens, measurementForPlan, recordPromptMeasurement, resolveProviderRoute, } from "../providers/request-plan.js";
+import { FULL_FOOTPRINT_USAGE_ACCOUNTING_POLICY, providerAttemptToRecord, tryNormalizeProviderUsage, } from "./execution-evidence.js";
 import { kernelObservationToSessionEvent } from "./kernel-event-log.js";
 import { assertNativeProfile } from "./os-profile.js";
 import { PayloadStore } from "./payload-store.js";
@@ -155,6 +165,16 @@ export class RuntimeRunner {
     composedSystemPrompt;
     /** H1.2: present only when `opts.nudges` is non-empty; else null and the append funnel is untouched. */
     nudgeEngine;
+    /** P4-S1: the run's resolved provider route, assembled once at construction (P4 §0.2 — the
+     *  provider is fixed for the run today; every attempt references this same route object). */
+    providerRoute;
+    /** P4-S2: measurement→settlement policy; default = the exact implicit behavior (numbers unchanged). */
+    usageAccountingPolicy;
+    /** P4 §1.1: the active invocation's derived identity = its chain's FIRST effect_id. Tracked
+     *  across kernel-driven provider retries (a provider_error commit arms `providerRetryPending`;
+     *  the next call_provider adopts the pending invocation instead of opening a new one). */
+    activeProviderInvocationId;
+    providerRetryPending = false;
     constructor(opts) {
         this.opts = opts;
         const schemaAttempts = opts.workflowSchemaValidationAttempts ?? 2;
@@ -166,6 +186,8 @@ export class RuntimeRunner {
         if (opts.memoryPolicy)
             memoryPolicyToKernel(opts.memoryPolicy);
         this.composedSystemPrompt = composeSystemPrompt(opts.systemPrompt, opts.instructions);
+        this.providerRoute = resolveProviderRoute(opts.provider);
+        this.usageAccountingPolicy = opts.usageAccountingPolicy ?? FULL_FOOTPRINT_USAGE_ACCOUNTING_POLICY;
         if (opts.enableDiagnosticsDashboard) {
             const originalAppend = opts.sessionLog.append.bind(opts.sessionLog);
             opts.sessionLog.append = async (sessionId, event) => {
@@ -221,6 +243,18 @@ export class RuntimeRunner {
         this.fallbackPayloadStore ??= new PayloadStore();
         return this.fallbackPayloadStore;
     }
+    /**
+     * P4-S1 (G1): land one provider_attempt evidence record per effect execution. Pure host
+     * evidence (B7) — appended AFTER the transport fact exists (success/failure/abort), never
+     * consulted for kernel input. The accounting policy id pins only when a measurement exists,
+     * so (usage, policy_id) deterministically recomputes the settlement that crossed the wire.
+     */
+    async appendProviderAttempt(sessionId, attempt) {
+        await this.opts.sessionLog.append(sessionId, {
+            kind: "provider_attempt",
+            ...providerAttemptToRecord(attempt, attempt.usage ? this.usageAccountingPolicy.policyId : undefined),
+        });
+    }
     async persistMemoryToStore(memory, agentId) {
         if (!this.opts.memoryStore)
             throw new Error("memory persistence requires memoryStore");
@@ -745,6 +779,7 @@ export class RuntimeRunner {
                     goal: `workflow:${spec.nodes.length} nodes`,
                     criteria: [],
                     agent_id: this.opts.agentId,
+                    route: this.providerRoute,
                 });
                 await this.initializeWorkflowKernel(sessionId, runId, groupBudgetScope);
             }
@@ -1195,6 +1230,7 @@ export class RuntimeRunner {
                 agent_id: this.opts.agentId,
                 system_prompt: this.composedSystemPrompt,
                 ...(attachments ? { attachments } : {}),
+                route: this.providerRoute,
             });
         }
         yield* this.execute(req.sessionId, req.goal, req.criteria ?? [], req.extensions, prior.length > 0 ? prior : undefined, midRun, attachments, runId);
@@ -1224,7 +1260,10 @@ export class RuntimeRunner {
         yield* this.execute(sessionId, start.goal, start.criteria, extensions, events, true, start.attachments, start.run_id);
     }
     /** Execute a kernel-owned approval effect and return the correlated decision lists. */
-    async resolveApprovalRequests(requests, runtime, sessionId) {
+    async resolveApprovalRequests(requests, runtime, sessionId, 
+    /** P3-S2 (G4): the request_approval effect's id — pinned on the denial's tool_completed
+     *  so the denial evidence joins the journal effect chain like an executed tool's does. */
+    effectId) {
         const approved = [];
         const denied = [];
         const events = [];
@@ -1297,6 +1336,7 @@ export class RuntimeRunner {
                             error_kind: "governance_denied",
                             content: { blocks: [{ type: "text", text: `permission denied: ${denyReason}` }] },
                         }],
+                    ...(effectId !== undefined ? { effect_id: effectId } : {}),
                 });
             }
         }
@@ -1310,6 +1350,8 @@ export class RuntimeRunner {
         this.pendingPageOutArchives = [];
         this.activePageOutArchive = undefined;
         this.currentSessionId = sessionId;
+        this.activeProviderInvocationId = undefined;
+        this.providerRetryPending = false;
         if (this.opts.enableDiagnosticsDashboard) {
             this.dashboard = new KernelPrimitivesDashboard(sessionId);
         }
@@ -1548,6 +1590,18 @@ export class RuntimeRunner {
                         break;
                     if (action.kind === "call_provider") {
                         const providerEffectId = action.effectId;
+                        // P4 §1.1: invocation identity is derived, never minted — the chain's FIRST effect_id.
+                        // A provider_error commit armed `providerRetryPending`, so this effect CONTINUES the
+                        // pending invocation; otherwise it opens a new one. The chain itself lives in the
+                        // journal (each hop a Failed resolution input → new effect); this is the SessionLog
+                        // evidence projection of it.
+                        if (!this.providerRetryPending || this.activeProviderInvocationId === undefined) {
+                            this.activeProviderInvocationId = providerEffectId;
+                        }
+                        this.providerRetryPending = false;
+                        const invocationId = this.activeProviderInvocationId;
+                        // Host wall-clock, pure evidence (B7/DEC-2): never crosses into kernel input.
+                        const attemptStartedAtMs = Date.now();
                         const finalToolCalls = [];
                         let finalText = "";
                         // I5: governance schema-level pre-filter. When a declarative GovernancePolicy is loaded
@@ -1579,6 +1633,9 @@ export class RuntimeRunner {
                         let turnCacheTelemetrySource;
                         let turnCacheReadBySlot;
                         let turnStopReason;
+                        // P4 §2: the raw postflight provider usage frame, kept whole so the attempt's
+                        // measurement carries full fields (only the settlement crosses the kernel boundary, B4).
+                        let turnProviderUsage;
                         const providerPlan = createProviderRequestPlanForProvider(this.opts.provider, context, tools, ext);
                         const recorded = measurementForPlan(providerPlan, recordedMeasurements.get(providerPlan.fingerprint));
                         let promptMeasurement = recorded;
@@ -1605,6 +1662,7 @@ export class RuntimeRunner {
                                 kind: "prompt_measured",
                                 turn: runtime.turn(),
                                 measurement: promptMeasurement,
+                                effect_id: providerEffectId,
                             });
                         }
                         const reservedPromptTokens = (this.opts.promptBudget?.promptOverheadTokens ?? 0)
@@ -1617,6 +1675,23 @@ export class RuntimeRunner {
                             && promptMeasurement.source.kind !== "heuristic"
                             && promptMeasurement.inputTokens + reservedPromptTokens > this.opts.maxTokens;
                         if (context.budgetOverflow || measuredOverflow) {
+                            // P4 §1.2: blocked BEFORE any transport — zero rungs, status rejected. The
+                            // fingerprint still binds the would-be request to its prompt_measured record (G2).
+                            await this.appendProviderAttempt(sessionId, {
+                                effectId: providerEffectId,
+                                attemptSeq: 1,
+                                route: this.providerRoute,
+                                requestFingerprint: providerPlan.fingerprint,
+                                status: "rejected",
+                                transportRungs: 0,
+                                lastErrorClass: "context_overflow",
+                                startedAtMs: attemptStartedAtMs,
+                                finishedAtMs: Date.now(),
+                                wireEvidence: {
+                                    protocol: this.providerRoute.protocol,
+                                    request_fingerprint: providerPlan.fingerprint,
+                                },
+                            });
                             action = await this.commitKernelAction(runtime, this.pendingObservations, {
                                 kind: "provider_error",
                                 effect_id: providerEffectId,
@@ -1624,6 +1699,7 @@ export class RuntimeRunner {
                                 error_kind: "context_overflow",
                                 retryable: false,
                             });
+                            this.providerRetryPending = action.kind === "call_provider";
                             continue;
                         }
                         const abortSignal = this.abortController?.signal;
@@ -1639,6 +1715,7 @@ export class RuntimeRunner {
                                     turnTokens = usageEvt.totalTokens;
                                     turnInputTokens = usageEvt.inputTokens ?? 0;
                                     turnOutputTokens = usageEvt.outputTokens ?? 0;
+                                    turnProviderUsage = usageEvt.providerUsage ?? turnProviderUsage;
                                     // P0-C: capture the prompt-cache split for the tool-gating hit-rate baseline.
                                     turnCacheReadTokens = usageEvt.cacheReadInputTokens ?? 0;
                                     turnCacheCreationTokens = usageEvt.cacheCreationInputTokens ?? 0;
@@ -1670,6 +1747,7 @@ export class RuntimeRunner {
                                                 source: postflight.source,
                                                 confidence: postflight.confidence,
                                             },
+                                            effect_id: providerEffectId,
                                         });
                                     }
                                     // Phase 4: stop_reason drives the kernel's max-output-tokens recovery. The closing
@@ -1697,6 +1775,26 @@ export class RuntimeRunner {
                                 const provider = this.opts.provider.descriptor?.().provider ?? "unknown";
                                 const providerError = classifyProviderError(provider, err);
                                 const message = providerError.message;
+                                // P4 §1.2: the transport ladder is exhausted — one attempt record, rung count from
+                                // provider telemetry (1 on the single-shot stream path), error CLASS only (B1:
+                                // never the raw vendor text).
+                                const telemetry = this.opts.provider.peekTransportTelemetry?.();
+                                await this.appendProviderAttempt(sessionId, {
+                                    effectId: providerEffectId,
+                                    attemptSeq: 1,
+                                    route: this.providerRoute,
+                                    requestFingerprint: providerPlan.fingerprint,
+                                    status: "transport_exhausted",
+                                    transportRungs: telemetry?.rungs ?? 1,
+                                    lastErrorClass: providerError.kind,
+                                    startedAtMs: attemptStartedAtMs,
+                                    finishedAtMs: Date.now(),
+                                    wireEvidence: {
+                                        protocol: this.providerRoute.protocol,
+                                        request_fingerprint: providerPlan.fingerprint,
+                                        ...(telemetry?.responseId !== undefined ? { response_id: telemetry.responseId } : {}),
+                                    },
+                                });
                                 // Reactive recovery is now a kernel decision. Forward the raw provider error and
                                 // dispatch whatever the kernel returns: `call_provider` to retry with a freshly
                                 // compacted context, or `done` to terminate with an honest `ContextOverflow`. The
@@ -1710,6 +1808,9 @@ export class RuntimeRunner {
                                     message,
                                     ...providerErrorEventFields(providerError),
                                 });
+                                // P4 §1.1: a kernel-recovered retry CONTINUES this invocation (the journal holds the
+                                // causation hop); a terminal closes it.
+                                this.providerRetryPending = action.kind === "call_provider";
                                 // Withholding (query.ts parity): surface the raw provider error only when the kernel
                                 // could NOT recover (it returned a terminal). On a recovered retry (`call_provider`)
                                 // the error stays hidden, so embedders that terminate on `error` events don't see a
@@ -1722,6 +1823,23 @@ export class RuntimeRunner {
                         }
                         // Do not commit partial provider output after host cancellation.
                         if (abortSignal?.aborted) {
+                            // P4 §1.2: host cancellation mid-stream — the attempt is evidence too.
+                            const telemetry = this.opts.provider.peekTransportTelemetry?.();
+                            await this.appendProviderAttempt(sessionId, {
+                                effectId: providerEffectId,
+                                attemptSeq: 1,
+                                route: this.providerRoute,
+                                requestFingerprint: providerPlan.fingerprint,
+                                status: "aborted",
+                                transportRungs: telemetry?.rungs ?? 1,
+                                startedAtMs: attemptStartedAtMs,
+                                finishedAtMs: Date.now(),
+                                wireEvidence: {
+                                    protocol: this.providerRoute.protocol,
+                                    request_fingerprint: providerPlan.fingerprint,
+                                    ...(telemetry?.responseId !== undefined ? { response_id: telemetry.responseId } : {}),
+                                },
+                            });
                             action = await this.commitKernelAction(runtime, this.pendingObservations, {
                                 kind: "cancel_operation",
                                 reason: this.cancellationReason ?? "user",
@@ -1753,12 +1871,37 @@ export class RuntimeRunner {
                             toolCalls: canonicalToolCalls,
                             tokenCount: turnOutputTokens || turnTokens || undefined,
                         };
+                        // P4 §2: assemble the measurement from the exact numbers that cross the boundary today
+                        // (inputTokens/outputTokens turn counters), enriched with the raw provider frame's cache
+                        // split and reasoning fields. An invalid frame degrades to no measurement (evidence
+                        // never breaks a run); the settlement then falls back to the raw counts below.
+                        const attemptUsage = (turnInputTokens > 0 || turnOutputTokens > 0)
+                            ? tryNormalizeProviderUsage({
+                                inputTokens: turnInputTokens,
+                                outputTokens: turnOutputTokens,
+                                ...(turnProviderUsage?.cacheReadInputTokens !== undefined
+                                    ? { cacheReadInputTokens: turnProviderUsage.cacheReadInputTokens }
+                                    : turnCacheReadTokens > 0 ? { cacheReadInputTokens: turnCacheReadTokens } : {}),
+                                ...(turnProviderUsage?.cacheCreationInputTokens !== undefined
+                                    ? { cacheCreationInputTokens: turnProviderUsage.cacheCreationInputTokens }
+                                    : turnCacheCreationTokens > 0 ? { cacheCreationInputTokens: turnCacheCreationTokens } : {}),
+                                ...(turnProviderUsage?.reasoningTokens !== undefined
+                                    ? { reasoningTokens: turnProviderUsage.reasoningTokens } : {}),
+                                cacheTelemetryStatus: turnCacheTelemetryStatus,
+                                ...(turnCacheTelemetrySource !== undefined
+                                    ? { cacheTelemetrySource: turnCacheTelemetrySource } : {}),
+                            })
+                            : undefined;
+                        const settlement = attemptUsage ? this.usageAccountingPolicy.settle(attemptUsage) : undefined;
                         const providerEvent = {
                             kind: "provider_result",
                             effect_id: providerEffectId,
                             message: messageToKernelMessage(assistantMessage),
-                            ...(turnInputTokens > 0 ? { observed_input_tokens: turnInputTokens } : {}),
-                            ...(turnOutputTokens > 0 ? { observed_output_tokens: turnOutputTokens } : {}),
+                            // P4-S2: observed_* now comes from the pinned policy's settlement of the measurement.
+                            // Under the default full-footprint policy these are provably the numbers the runner
+                            // has always fed (inputTokens/outputTokens verbatim under the same >0 gates).
+                            ...(turnInputTokens > 0 ? { observed_input_tokens: settlement?.observed_input_tokens ?? turnInputTokens } : {}),
+                            ...(turnOutputTokens > 0 ? { observed_output_tokens: settlement?.observed_output_tokens ?? turnOutputTokens } : {}),
                             ...(turnStopReason ? { stop_reason: turnStopReason } : {}),
                         };
                         if (this.opts.skillDir) {
@@ -1789,14 +1932,38 @@ export class RuntimeRunner {
                                 }
                             }
                         }
-                        action = await this.commitKernelAction(runtime, this.pendingObservations, providerEvent);
+                        // P4-S1: land the attempt evidence BEFORE the kernel resolution commits — the record
+                        // describes the transport fact, which exists regardless of what the kernel decides next.
+                        const attemptTelemetry = this.opts.provider.peekTransportTelemetry?.();
                         const providerReplay = peekProviderReplay(this.opts.provider, finalText, finalToolCalls);
+                        const wireEvidence = {
+                            protocol: this.providerRoute.protocol,
+                            request_fingerprint: providerPlan.fingerprint,
+                            ...(attemptTelemetry?.responseId !== undefined ? { response_id: attemptTelemetry.responseId } : {}),
+                            ...(providerReplay !== undefined ? { replay_state: providerReplay } : {}),
+                        };
+                        await this.appendProviderAttempt(sessionId, {
+                            effectId: providerEffectId,
+                            attemptSeq: 1,
+                            route: this.providerRoute,
+                            requestFingerprint: providerPlan.fingerprint,
+                            status: "success",
+                            transportRungs: attemptTelemetry?.rungs ?? 1,
+                            startedAtMs: attemptStartedAtMs,
+                            finishedAtMs: Date.now(),
+                            ...(attemptUsage !== undefined ? { usage: attemptUsage } : {}),
+                            wireEvidence,
+                        });
+                        action = await this.commitKernelAction(runtime, this.pendingObservations, providerEvent);
                         await this.opts.sessionLog.append(sessionId, buildLlmCompletedEvent({
                             turn: runtime.turn(),
                             content: finalText,
                             tokenCount: turnOutputTokens || turnTokens || undefined,
                             toolCalls: finalToolCalls,
                             providerReplay,
+                            effectId: providerEffectId,
+                            invocationId,
+                            wireEvidence,
                         }));
                         // P0-C: emit per-turn tool-gating telemetry. `activeSkill` reflects the skill in effect
                         // GOING INTO this turn; a `skill` call here only takes effect next turn, so emit first, then
@@ -1831,7 +1998,7 @@ export class RuntimeRunner {
                         }
                     }
                     else if (action.kind === "request_approval") {
-                        const resolved = await this.resolveApprovalRequests(action.requests, runtime, sessionId);
+                        const resolved = await this.resolveApprovalRequests(action.requests, runtime, sessionId, action.effectId);
                         for (const event of resolved.events)
                             yield event;
                         action = await this.commitKernelAction(runtime, this.pendingObservations, {
@@ -1914,6 +2081,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 +2109,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 +2127,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));
                             }
                         }
                     }
@@ -2160,6 +2328,7 @@ export class RuntimeRunner {
                                 token_count: r.tokenCount,
                                 content: { blocks: toolOutputBlocksToDurable(r.contentParts?.length ? r.contentParts : [{ type: "text", text: r.output }]) },
                             })),
+                            effect_id: toolEffectId,
                         });
                         // The canonical provider resolution already activates a successfully resolved `skill` call.
                         // The host's remaining responsibility is to pin the resolved METHOD content — how to do
@@ -2516,7 +2685,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 +2703,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 +2829,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

@@ -1,6 +1,7 @@
 import type { KernelPrimitive } from "./kernel-event-log.js";
-import type { ContentPart, ProviderReplay, ToolCall, ToolErrorKind } from "../types.js";
-import type { RecordedPromptMeasurement } from "../providers/request-plan.js";
+import type { ContentPart, ProviderReplay, ProviderWireEvidence, ToolCall, ToolErrorKind } from "../types.js";
+import type { RecordedPromptMeasurement, ResolvedProviderRoute } from "../providers/request-plan.js";
+import type { ProviderAttemptRecord } from "./execution-evidence.js";
 import type { MemoryRecall, MemoryScope } from "../memory/protocols.js";
 import type { KernelJournal } from "./kernel-journal.js";
 export type RollbackReason = {
@@ -30,6 +31,7 @@ export type SessionEvent = {
     agent_id?: string;
     system_prompt?: string;
     attachments?: ContentPart[];
+    route?: ResolvedProviderRoute;
 } | {
     kind: "llm_completed";
     turn: number;
@@ -37,11 +39,17 @@ export type SessionEvent = {
     token_count?: number;
     tool_calls: ToolCall[];
     provider_replay?: ProviderReplay;
+    effect_id?: string;
+    invocation_id?: string;
+    wire_evidence?: ProviderWireEvidence;
 } | {
     kind: "prompt_measured";
     turn: number;
     measurement: RecordedPromptMeasurement;
-} | {
+    effect_id?: string;
+} | ({
+    kind: "provider_attempt";
+} & ProviderAttemptRecord) | {
     kind: "tool_requested";
     turn: number;
     calls: ToolCall[];
@@ -59,6 +67,7 @@ export type SessionEvent = {
             blocks: Record<string, unknown>[];
         };
     }>;
+    effect_id?: string;
 } | {
     kind: "tool_argument_repaired";
     turn: number;
@@ -98,6 +107,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;
@@ -314,6 +335,14 @@ export type SessionEvent = {
     reason: string;
     coerced_from?: string;
 };
+export type SessionEventKind = SessionEvent["kind"];
+/**
+ * The registered session-event vocabulary (F9 / S3, P7-S4). This list is the single authority
+ * the cross-SDK manifest fixture pins: a kind added here without the same-commit update to
+ * `tests/fixtures/sdk-conformance/canonical/session-event-vocabulary.json` and the python/wasm
+ * vocabularies turns cross-SDK conformance red. Declared in `SessionEvent` union order.
+ */
+export declare const SESSION_EVENT_KINDS: readonly ["run_started", "llm_completed", "prompt_measured", "provider_attempt", "tool_requested", "tool_completed", "tool_argument_repaired", "tool_denied", "permission_requested", "permission_resolved", "compressed", "page_out", "semantic_archive_pending", "semantic_archive_completed", "semantic_archive_failed", "page_in", "rollbacked", "capability_changed", "context_renewed", "suspended", "resumed", "tool_gated", "signal_delivery_disposed", "budget_exceeded", "budget_usage_reported", "operation_cancelled", "milestone_advanced", "milestone_blocked", "checkpoint_taken", "entropy_sample", "entropy_alert", "agent_process_changed", "memory_written", "memory_queried", "memory_validation_failed", "memory_write_failed", "memory_query_failed", "memory_retrieval_result", "workflow_node_completed", "workflow_nodes_submitted", "workflow_batch_spawned", "workflow_completed", "kernel_observation", "run_terminal", "summary_upgraded", "group_member_joined", "group_budget_charged", "round_started", "round_paced"];
 /**
  * The business-projection log (spec §9.2): run started/terminal, stream events, observations,
  * provider/tool presentation, audit metadata.