@deepstrike/sdk 0.2.61 → 0.2.63

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

@@ -1,7 +1,9 @@
 import type { EntropySample, Message, RenderedContext, TaskUpdate, ToolCall, ToolResult, ToolSchema } from "../types.js";
 import type { SkillMetadata } from "../skills/loader.js";
 import type { RollbackReason } from "./session-log.js";
+export declare const CANONICAL_CONTENT_PARTS_PREFIX = "[[deepstrike-content-parts]]";
 export declare function encodeCanonicalContentParts(parts: unknown[]): string;
+export declare function decodeCanonicalContentParts(content: string): Array<Record<string, unknown>> | undefined;
 export interface PaceDecision {
     action: "continue" | "sleep" | "stop";
     delayMs?: number;
@@ -73,11 +75,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 +198,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

@@ -1,8 +1,8 @@
-const CANONICAL_CONTENT_PARTS_PREFIX = "[[deepstrike-content-parts]]";
+export const CANONICAL_CONTENT_PARTS_PREFIX = "[[deepstrike-content-parts]]";
 export function encodeCanonicalContentParts(parts) {
     return `${CANONICAL_CONTENT_PARTS_PREFIX}${Buffer.from(JSON.stringify(parts)).toString("base64url")}`;
 }
-function decodeCanonicalContentParts(content) {
+export function decodeCanonicalContentParts(content) {
     if (!content.startsWith(CANONICAL_CONTENT_PARTS_PREFIX))
         return undefined;
     try {
@@ -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,9 +9,11 @@ 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";
+import { type UsageAccountingPolicy } from "./execution-evidence.js";
 import { type NativeOsProfile, type OsProfileId, type SignalPolicy } from "./os-profile.js";
 import { PayloadStore } from "./payload-store.js";
 import type { BackgroundTaskErrorHandler } from "./reliability.js";
@@ -175,6 +177,12 @@ export interface RuntimeOptions {
     signalPolicy?: SignalPolicy;
     /** Provider-envelope overhead plus output and safety reserves journaled before start. */
     promptBudget?: PromptBudget;
+    /**
+     * P4-S2: the measurement→settlement conversion policy. Absent ⇒ the default full-footprint
+     * policy — byte-identical numbers to what the runner has always fed `observed_*`; the policy
+     * only makes the conversion named, pinnable on `provider_attempt`, and replayable.
+     */
+    usageAccountingPolicy?: UsageAccountingPolicy;
     /** Stable replayable context behavior; SDK ratios are normalized to integer ppm on the ABI wire. */
     contextPolicy?: ContextPolicyOverrides;
     /** Deterministic DAG scheduling policy installed atomically through ConfigureRun. */
@@ -402,6 +410,16 @@ export declare class RuntimeRunner {
     private readonly composedSystemPrompt;
     /** H1.2: present only when `opts.nudges` is non-empty; else null and the append funnel is untouched. */
     private readonly 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). */
+    private readonly providerRoute;
+    /** P4-S2: measurement→settlement policy; default = the exact implicit behavior (numbers unchanged). */
+    private readonly 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). */
+    private activeProviderInvocationId;
+    private providerRetryPending;
     constructor(opts: RuntimeOptions);
     /** Host configuration (for coordinator / sub-agent spawn). */
     get hostOptions(): RuntimeOptions;
@@ -411,6 +429,13 @@ export declare class RuntimeRunner {
     private commitKernelAction;
     private startKernelAgent;
     private payloadStore;
+    /**
+     * 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.
+     */
+    private appendProviderAttempt;
     private persistMemoryToStore;
     private retrieveMemoryFromStore;
     /**