@deepstrike/wasm 0.2.77 → 0.2.79

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

@@ -9,9 +9,13 @@ export function categoryForKind(kind) {
         case "page_in_requested":
         case "renewed":
         case "context_renewed":
+        case "lifecycle_report":
+        case "context_lifecycle_reported":
         case "memory_written":
         case "memory_queried":
         case "memory_validation_failed":
+        case "memory_candidate_pending":
+        case "memory_candidate_rejected":
             return "mm";
         case "agent_process_changed":
             return "proc";
@@ -21,9 +25,27 @@ export function categoryForKind(kind) {
             return "sched";
     }
 }
+/** The kernel's pressure actions that name a session-level compression action; any other
+ *  action (e.g. `none`) is omitted from the event. Shared rule across all four SDKs. */
+export function canonicalCompressionAction(action) {
+    return action === "snip_compact" || action === "micro_compact" || action === "context_collapse" || action === "auto_compact"
+        ? action
+        : undefined;
+}
+/**
+ * Project one kernel observation onto its session event (null = not persisted). Pinned across
+ * SDKs by the `kernel_observation_projection` conformance fixture: an absent optional field is
+ * omitted, never written as `null`.
+ */
 export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
+    const event = projectKernelObservation(obs, turn, opts);
+    if (!event)
+        return null;
+    return Object.fromEntries(Object.entries(event).filter(([, value]) => value !== undefined && value !== null));
+}
+function projectKernelObservation(obs, turn, opts = {}) {
     const t = obs.turn ?? turn;
-    const compressionAction = opts.compressionAction ?? (() => undefined);
+    const compressionAction = opts.compressionAction ?? canonicalCompressionAction;
     switch (obs.kind) {
         case "compressed": {
             const latest = opts.latestSeq ?? -1;
@@ -47,6 +69,22 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 sprint: obs.sprint ?? 0,
                 handoff_ref: "",
             };
+        case "lifecycle_report":
+            return {
+                kind: "context_lifecycle_reported",
+                turn: t,
+                knowledge_entries: obs.knowledge_entries ?? 0,
+                knowledge_referenced: obs.knowledge_referenced ?? 0,
+                regret: obs.regret ?? 0,
+                waste_tokens: obs.waste_tokens ?? 0,
+                cache_loss_tokens: obs.cache_loss_tokens ?? 0,
+                recalled: obs.recalled ?? 0,
+                recall_expanded: obs.recall_expanded ?? 0,
+                ...(obs.items && obs.items.length > 0 ? { items: obs.items } : {}),
+                ...(obs.history && obs.history.length > 0 ? { history: obs.history } : {}),
+                ...(obs.history_items && obs.history_items.length > 0 ? { history_items: obs.history_items } : {}),
+                ...(obs.history_items_omitted ? { history_items_omitted: obs.history_items_omitted } : {}),
+            };
         case "rollbacked":
             return {
                 kind: "rollbacked",
@@ -200,6 +238,15 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 name: obs.name ?? "",
                 size_bytes: obs.size_bytes ?? 0,
             };
+        case "memory_candidate_pending":
+            // M2 · the kernel's PersistMemory effect settled as a candidate (the child-request path).
+            return {
+                kind: "memory_candidate_pending",
+                turn: t,
+                candidate_id: String(obs.candidate_id ?? ""),
+                source: "child_request",
+                name: obs.name ?? "",
+            };
         case "memory_queried":
             return {
                 kind: "memory_queried",
@@ -216,6 +263,21 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 record_id: obs.record_id ?? "",
                 error: obs.error ?? "",
             };
+        case "memory_write_failed":
+            return {
+                kind: "memory_write_failed",
+                turn: t,
+                record_id: obs.record_id ?? "",
+                error: obs.error ?? "",
+            };
+        case "memory_query_failed":
+            return {
+                kind: "memory_query_failed",
+                turn: t,
+                scope: obs.scope ?? { tenant_id: "", namespace: "" },
+                query: obs.query ?? "",
+                error: obs.error ?? "",
+            };
         case "workflow_batch_spawned": {
             const nodes = obs.nodes ?? [];
             return {

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

@@ -1,5 +1,5 @@
 import type { ModelMessage, RenderedContext, ToolCall, ToolExecutionResult, ToolSchema } from "../types.js";
-import type { RollbackReason } from "./session-log.js";
+import type { ContextHistoryItemRecord, ContextItemRecord, ContextOriginTally, RollbackReason } from "./session-log.js";
 interface TaskUpdate {
     plan?: string[];
     currentStep?: number;
@@ -50,7 +50,6 @@ export type KernelRunnerAction = {
     effectId: string;
     context: RenderedContext;
     tools: ToolSchema[];
-    contextEffect: Record<string, unknown>;
 } | {
     kind: "execute_tool";
     effectId: string;
@@ -89,6 +88,9 @@ export type KernelRunnerAction = {
     requestedK: number;
 } | {
     kind: "archive_page_out";
+    action?: string;
+    summary?: string;
+    tier?: "semantic" | "durable";
     effectId: string;
     archived: ModelMessage[];
     handleId?: string;
@@ -126,6 +128,17 @@ export interface KernelObservation {
     rho_after?: number;
     sprint?: number;
     summary?: string;
+    knowledge_entries?: number;
+    knowledge_referenced?: number;
+    regret?: number;
+    waste_tokens?: number;
+    cache_loss_tokens?: number;
+    recalled?: number;
+    recall_expanded?: number;
+    items?: ContextItemRecord[];
+    history?: ContextOriginTally[];
+    history_items?: ContextHistoryItemRecord[];
+    history_items_omitted?: number;
     archived_count?: number;
     turn?: number;
     checkpoint_history_len?: number;

package/dist/runtime/os-snapshot.js

@@ -4,6 +4,7 @@ const KERNEL_KINDS = new Set([
     "page_in",
     "capability_changed",
     "context_renewed",
+    "context_lifecycle_reported",
     "suspended",
     "resumed",
     "tool_gated",

package/dist/runtime/runner.d.ts

@@ -1,15 +1,16 @@
-import type { LLMProvider, ModelMessage, StreamEvent, PermissionRequestEvent, PermissionResponse, EntropySample, EntropyWatchOptions, MemorySummarizer } from "../types.js";
+import type { LLMProvider, ModelMessage, StreamEvent, PermissionRequestEvent, PermissionResponse, EntropySample, EntropyWatchOptions, NativeContextTiers } from "../types.js";
 import type { ToolSuspendEvent } from "./execution-plane.js";
-import type { MemoryStore, MemoryQuery, MemoryRecord, MemoryScope } from "../memory/index.js";
+import type { MemoryStore, MemoryQuery, MemoryRecall, MemoryRecord, MemoryScope } from "../memory/index.js";
+import { type MemoryRuntimePolicy } from "../memory/runtime-policy.js";
+import { type MemoryCandidateSource, type MemoryCandidateSink } from "../memory/candidate-sink.js";
 import type { KnowledgeSource } from "../knowledge/index.js";
 import type { SignalSource, RuntimeSignal } from "../signals/index.js";
 import type { SessionLog, SessionEvent } from "./session-log.js";
 import type { ExecutionPlane } from "./execution-plane.js";
 import { type GovernancePolicy, type LivePolicyPatch } from "../governance.js";
 import type { KernelJournal } from "./kernel-journal.js";
-import type { AgentRunSpec, MilestonePolicy, MilestoneContract, MilestoneCheckResult, WorkflowSpec, WorkflowOutcome } from "./types/agent.js";
+import type { AgentRunSpec, MilestonePolicy, MilestoneContract, MilestoneCheckResult, WorkflowSpec, InheritedKnowledge, WorkflowOutcome } from "./types/agent.js";
 import { type SubAgentOrchestrator } from "./sub-agent-orchestrator.js";
-import { type ReducerRegistry } from "./reducers.js";
 import { type NativeOsProfile, type OsProfileId, type SignalPolicy } from "./os-profile.js";
 import { PayloadStore } from "./payload-store.js";
 import { type ContextPolicyOverrides } from "./context-policy.js";
@@ -111,8 +112,6 @@ export interface ToolResultHookDecision {
 }
 export interface RuntimeOptions {
     provider: LLMProvider;
-    /** Host-owned artifact set identity captured in operation genesis. */
-    artifactSetDigest?: string;
     /** Required for ABI operation recovery unless the SessionLog embeds one. */
     kernelJournal?: KernelJournal;
     /** M1/G3 intelligence routing: resolve a per-node provider from a workflow node's `modelHint`.
@@ -139,8 +138,16 @@ export interface RuntimeOptions {
     }) => Promise<MemoryQuery[] | undefined> | MemoryQuery[] | undefined;
     systemPrompt?: string;
     initialMemory?: string[];
+    /** Plan task 3.1 · outputs of the workflow nodes this run depends on, by agent id. The kernel
+     *  holds them; the model reads one with `read_result(call_id="dep:<agent_id>")`. */
+    dependencyOutputs?: Record<string, string>;
+    /** Plan task 1.1 · the parent knowledge a child run starts with, chosen by the kernel from the
+     *  items' scope and the node's context inheritance. Set by the workflow driver. */
+    inheritedKnowledge?: InheritedKnowledge[];
     /** Skill name → markdown body (WASM has no filesystem). */
     skillContentMap?: Map<string, string>;
+    memoryRuntimePolicy?: MemoryRuntimePolicy;
+    memoryCandidateSink?: MemoryCandidateSink;
     memoryStore?: MemoryStore;
     /** M4: advisory callback when a recalled record crosses the promotion threshold. */
     onPromotionSuggested?: (info: {
@@ -209,8 +216,6 @@ export interface RuntimeOptions {
     onToolSuspend?: (event: ToolSuspendEvent) => Promise<unknown> | unknown;
     onPermissionRequest?: (event: PermissionRequestEvent) => Promise<PermissionResponse | boolean> | PermissionResponse | boolean;
     subAgentOrchestrator?: SubAgentOrchestrator;
-    /** G2: custom reducers for `NodeKind::Reduce` workflow nodes, merged over the built-ins. */
-    reducers?: ReducerRegistry;
     milestonePolicy?: MilestonePolicy;
     milestoneContract?: MilestoneContract;
     onMilestoneEvaluate?: (ctx: {
@@ -269,14 +274,18 @@ export interface RuntimeOptions {
      *  to exactly their declared tools + meta-tools. (wasm skills come from `skillContentMap`; gating
      *  engages only once that carries per-skill tool lists.) */
     stableCoreToolIds?: string[];
-    memoryProvider?: LLMProvider;
-    memorySummarizer?: MemorySummarizer;
-    memorySystemPrompt?: string;
     payloadStore?: PayloadStore;
 }
 export type OperationCancellationReason = "user" | "deadline" | "lease_lost" | "host_shutdown";
+/** The kernel's wire form of the tiers a provider performs natively, or nothing when it performs
+ *  none — an operation that delegates nothing configures exactly as before. */
+export declare function delegatedContextTiers(native: NativeContextTiers | undefined): {
+    tool_result_clearing?: true;
+    compaction?: true;
+} | undefined;
 export declare class RuntimeRunner {
     private readonly opts;
+    private readonly memoryRuntimeGates;
     private interrupted;
     private cancellationReason;
     /** #2-B-ii: aborts the in-flight provider stream on interrupt/preempt. Recreated per `execute`. */
@@ -357,9 +366,28 @@ export declare class RuntimeRunner {
      * §22.13 · a host-authored memory write. The kernel decides whether it may happen: a live
      * operation answers through `admit_memory_write` (the model's validation rule and rolling write
      * quota); with no live operation the same kernel rule answers statelessly. Resolves `true` when
-     * the record was persisted.
+     * the record was persisted or submitted as a pending candidate.
      */
-    writeMemory(memory: MemoryRecord, sessionId?: string): Promise<boolean>;
+    writeMemory(memory: MemoryRecord, sessionId?: string, candidate?: {
+        source: MemoryCandidateSource;
+        candidateId: string;
+    }): Promise<boolean>;
+    /**
+     * M4 · a host-initiated recall (an explicit `recall`). Same path as the prefetch: the retrieval
+     * gate, the policy's `retrievalTopK`, the kernel-derived recall lifecycle, and a
+     * `memory_retrieval_result` audit.
+     */
+    queryMemory(query: MemoryQuery, sessionId?: string): Promise<MemoryRecall[]>;
+    private persistMemoryEffectResult;
+    /** The host's side of every memory write: the store, or the candidate sink's receipt contract. */
+    private memoryWriter;
+    /** The audit fact for a sink's answer. Only an accepted candidate is a written record. */
+    private memoryCandidateEvent;
+    /** Host memory-policy gate: a path is on unless the host set its switch to `"disabled"`. */
+    private memoryPathEnabled;
+    /** M2 · whether a write path hands its writes to the candidate sink. Off unless the host set the
+     *  path to `"candidate_sink"` — unlike the on/off gates, the default here is the store. */
+    private memoryPathToCandidateSink;
     private admitMemoryWrite;
     /** The run's memory policy as the kernel's canonical wire carries it. */
     private kernelMemoryPolicyWire;
@@ -409,12 +437,6 @@ export declare class RuntimeRunner {
      * reason (an `Error`-terminated result fails the node in-kernel, starving its dependents).
      */
     private runWorkflowNode;
-    /**
-     * G2: execute a deterministic reduce node — run the named reducer (built-ins overlaid with
-     * `opts.reducers`) over its dependency outputs and return a synthetic completion. No LLM, zero
-     * tokens. An unknown reducer or a thrown reducer fails the node (`Error` → starves dependents).
-     */
-    private runReduceNode;
     /**
      * W0-ABI: run a declarative workflow DAG. The kernel owns the DAG and gates every node spawn
      * through the syscall trap; this driver runs each kernel-emitted batch of nodes in parallel,
@@ -450,13 +472,9 @@ export declare class RuntimeRunner {
      */
     private driveWorkflow;
     private appendObservations;
-    /** I4 + K4: fetch long-term memory hits for the current goal and land them in `history` as an
-     *  ordinary user turn — single-use retrieval content that decays with the compression pyramid,
-     *  never pinned into `knowledge`. `phase: "initial"` = once before turn 1; `phase: "renewal"` =
-     *  re-fired after each sprint renewal (renewal drops the old history INCLUDING earlier memory
-     *  hits). Errs-open throughout. */
-    private prefetchMemoryIntoHistory;
-    private archiveSemanticPageOut;
+    /** The kernel's own recall for the run goal (plan task 2.1). `preQueryMemory` may rewrite it
+     *  into several scoped queries; their hits are merged, one per record. */
+    private kernelRecallHits;
 }
 export declare function replayMessages(events: Array<{
     seq: number;