@deepstrike/sdk 0.2.60 → 0.2.62

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";
@@ -56,11 +57,7 @@ export interface TurnMetrics {
     inputTokens: number;
     /** Tokens served from the prompt cache this turn (Anthropic `cache_read_input_tokens`). */
     cacheReadTokens: number;
-    /** I1: per-slot attribution of `cacheReadTokens`. Anthropic reports a single cache-read total,
-     *  not a per-block breakdown — this field is a pro-rata estimate over the slots that actually
-     *  carried a `cache_control` breakpoint on the request. Missing / empty when the provider does
-     *  not honor `cache_control` (OpenAI-family auto-cache) or when no breakpoints were placed.
-     *  Useful for diagnosing which slot is buying the cache hit when comparing strategies. */
+    /** Provider-authoritative per-slot attribution, when the endpoint reports one. */
     cacheReadTokensBySlot?: {
         system?: number;
         tools?: number;
@@ -68,6 +65,10 @@ export interface TurnMetrics {
     };
     /** Tokens written to the prompt cache this turn (Anthropic `cache_creation_input_tokens`). */
     cacheCreationTokens: number;
+    cacheTelemetryStatus?: "measured" | "unavailable";
+    cacheTelemetrySource?: "anthropic_usage" | "openai_prompt_details" | "deepseek_prompt_cache" | "gemini_usage";
+    requestFingerprint?: string;
+    stablePrefixFingerprint?: string;
 }
 /** O5: decision returned by `onToolCall` — `block: true` denies this call before it executes; the
  *  `reason` is fed back to the model as a governance-denied tool result (so it can redirect). */

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";
@@ -1575,6 +1584,8 @@ export class RuntimeRunner {
                         let turnOutputTokens = 0;
                         let turnCacheReadTokens = 0;
                         let turnCacheCreationTokens = 0;
+                        let turnCacheTelemetryStatus = "unavailable";
+                        let turnCacheTelemetrySource;
                         let turnCacheReadBySlot;
                         let turnStopReason;
                         const providerPlan = createProviderRequestPlanForProvider(this.opts.provider, context, tools, ext);
@@ -1640,9 +1651,36 @@ export class RuntimeRunner {
                                     // P0-C: capture the prompt-cache split for the tool-gating hit-rate baseline.
                                     turnCacheReadTokens = usageEvt.cacheReadInputTokens ?? 0;
                                     turnCacheCreationTokens = usageEvt.cacheCreationInputTokens ?? 0;
+                                    turnCacheTelemetryStatus = usageEvt.cacheTelemetryStatus
+                                        ?? usageEvt.providerUsage?.cacheTelemetryStatus
+                                        ?? ((usageEvt.cacheReadInputTokens ?? 0) > 0 || (usageEvt.cacheCreationInputTokens ?? 0) > 0
+                                            ? "measured"
+                                            : "unavailable");
+                                    turnCacheTelemetrySource = usageEvt.cacheTelemetrySource ?? usageEvt.providerUsage?.cacheTelemetrySource;
                                     // I1: per-slot attribution forwarded into TurnMetrics. Undefined when the provider
                                     // doesn't honor cache_control (OpenAI-family auto-cache).
                                     turnCacheReadBySlot = usageEvt.cacheReadInputTokensBySlot;
+                                    // spc_024-06: postflight observed input is the authority (INV-024-08). Feed it back
+                                    // as a durable measurement fact for this exact request fingerprint so replay reuses
+                                    // the observed truth instead of re-counting (or trusting the preflight estimate).
+                                    if (turnInputTokens > 0) {
+                                        const postflight = recordPromptMeasurement(providerPlan, {
+                                            inputTokens: turnInputTokens,
+                                            source: { kind: "postflight" },
+                                            confidence: "exact",
+                                        });
+                                        recordedMeasurements.set(providerPlan.fingerprint, postflight);
+                                        await this.opts.sessionLog.append(sessionId, {
+                                            kind: "prompt_measured",
+                                            turn: runtime.turn(),
+                                            measurement: {
+                                                requestFingerprint: postflight.requestFingerprint,
+                                                inputTokens: postflight.inputTokens,
+                                                source: postflight.source,
+                                                confidence: postflight.confidence,
+                                            },
+                                        });
+                                    }
                                     // Phase 4: stop_reason drives the kernel's max-output-tokens recovery. The closing
                                     // usage frame carries it; keep the last non-empty value seen this turn.
                                     if (usageEvt.stopReason)
@@ -1782,6 +1820,10 @@ export class RuntimeRunner {
                                     inputTokens: turnInputTokens,
                                     cacheReadTokens: turnCacheReadTokens,
                                     cacheCreationTokens: turnCacheCreationTokens,
+                                    cacheTelemetryStatus: turnCacheTelemetryStatus,
+                                    ...(turnCacheTelemetrySource ? { cacheTelemetrySource: turnCacheTelemetrySource } : {}),
+                                    requestFingerprint: providerPlan.fingerprint,
+                                    stablePrefixFingerprint: providerPlan.stablePrefixFingerprint,
                                     ...(turnCacheReadBySlot ? { cacheReadTokensBySlot: turnCacheReadBySlot } : {}),
                                 });
                             }
@@ -1881,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()
                             ?? {
@@ -1908,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;
@@ -1926,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));
                             }
                         }
                     }
@@ -2483,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;
             }
@@ -2496,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);
@@ -2601,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/dist/types.d.ts

@@ -151,10 +151,9 @@ export interface UsageEvent extends StreamEvent {
     cacheReadInputTokens?: number;
     /** Prompt tokens written to cache this request (billed ~1.25x). Subset of inputTokens. */
     cacheCreationInputTokens?: number;
-    /** I1: per-slot pro-rata attribution of `cacheReadInputTokens`. Estimated, not authoritative —
-     *  Anthropic returns a single cache-read total, so the SDK divides it evenly across the slots
-     *  that carried a `cache_control` breakpoint on the request. Missing when the provider doesn't
-     *  honor `cache_control` (OpenAI-family auto-cache) or when no breakpoints were placed. */
+    cacheTelemetryStatus?: CacheTelemetryStatus;
+    cacheTelemetrySource?: CacheTelemetrySource;
+    /** Reserved for provider-authoritative per-slot data. DeepStrike does not estimate this field. */
     cacheReadInputTokensBySlot?: {
         system?: number;
         tools?: number;
@@ -339,12 +338,16 @@ export interface ProviderUsage {
     outputTokens: number;
     cacheReadInputTokens?: number;
     cacheCreationInputTokens?: number;
+    cacheTelemetryStatus?: CacheTelemetryStatus;
+    cacheTelemetrySource?: CacheTelemetrySource;
     /** Output tokens spent on hidden reasoning (OpenAI `completion_tokens_details.reasoning_tokens` /
      *  Responses `output_tokens_details.reasoning_tokens`). A SUBSET of `outputTokens`, not additional
      *  — vendors that don't report a separate count (Anthropic, Gemini via this SDK) leave this unset
      *  rather than guessing. */
     reasoningTokens?: number;
 }
+export type CacheTelemetryStatus = "measured" | "unavailable";
+export type CacheTelemetrySource = "anthropic_usage" | "openai_prompt_details" | "deepseek_prompt_cache" | "gemini_usage";
 /** Node-side mirror of the reserved Rust `context::measurement` types — where a
  *  preflight token count came from. Field names/shape intentionally match the Rust
  *  `MeasurementSource` enum (`kind`-tagged, snake_case variant names) so the two sides can be
@@ -523,7 +526,7 @@ export interface LLMProvider {
      * capability remains directly callable, but no dispatch trigger is enabled until request
      * fingerprinting and durable measurement semantics are defined.
      */
-    countTokens?(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<PromptMeasurement>;
+    countTokens?(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState): Promise<PromptMeasurement>;
     complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState, 
     /** #2-B-ii: when provided, a preempting `InterruptNow` (or `interrupt()`) aborts the in-flight

package/package.json

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