@deepstrike/sdk 0.2.39 → 0.2.40

package/dist/runtime/eval.d.ts

@@ -4,10 +4,10 @@
  * Wraps the three kernel free functions `buildEvalMessages` / `parseVerdict` / `verdictOutputSchema`
  * (folded out of the old EvalPipeline class in 0.5.0) into a small typed surface that's safe to
  * call from a benchmark harness, a CI gate, or any caller that just wants "does this result meet
- * the criteria?" without setting up `HarnessLoop`.
+ * the criteria?" without setting up `AttemptLoop`.
  *
  * The judge is a single LLM call: build the eval prompt → stream → parse verdict. No retry loop,
- * no skill extraction, no harness state. Use `HarnessLoop` if you want the retry/refine flow.
+ * no skill extraction, no loop state. Use `AttemptLoop` if you want the retry/refine flow.
  */
 import type { LLMProvider, Message } from "../types.js";
 export interface Criterion {
@@ -17,6 +17,10 @@ export interface Criterion {
     required?: boolean;
     /** Optional weight for weighted scoring (kernel-defined semantics). */
     weight?: number;
+    /** Stable host contract identifier, passed through to deterministic judges. */
+    id?: string;
+    /** Signals that the host can evaluate this criterion without an LLM. */
+    machineCheckable?: boolean;
 }
 export interface VerdictDetail {
     criterion: string;

package/dist/runtime/eval.js

@@ -4,10 +4,10 @@
  * Wraps the three kernel free functions `buildEvalMessages` / `parseVerdict` / `verdictOutputSchema`
  * (folded out of the old EvalPipeline class in 0.5.0) into a small typed surface that's safe to
  * call from a benchmark harness, a CI gate, or any caller that just wants "does this result meet
- * the criteria?" without setting up `HarnessLoop`.
+ * the criteria?" without setting up `AttemptLoop`.
  *
  * The judge is a single LLM call: build the eval prompt → stream → parse verdict. No retry loop,
- * no skill extraction, no harness state. Use `HarnessLoop` if you want the retry/refine flow.
+ * no skill extraction, no loop state. Use `AttemptLoop` if you want the retry/refine flow.
  */
 import { getKernel } from "../kernel.js";
 /**

package/dist/runtime/event-stream.d.ts

@@ -7,10 +7,16 @@
  * event to a subset of personas, enforced at the framework boundary (`readSince(seq, viewer)` + the
  * `read_recent` tool) — context isolation, not convention.
  */
+import type { ObserverErrorHandler } from "./reliability.js";
+export interface EventStreamOptions {
+    onObserverError?: ObserverErrorHandler;
+}
 /** One entry on the shared blackboard. `channel`/`audience` are optional visibility scoping. */
 export interface BlackboardEvent {
     seq: number;
     payload: unknown;
+    /** Stable external event key. Re-appending the same key returns the original event. */
+    idempotencyKey?: string;
     /** Emitting persona id (or external source), for audit / `reactByMention`. */
     source?: string;
     /** Channel this event belongs to; only personas subscribed to it see it. Omit ⇒ all see it. */
@@ -36,8 +42,11 @@ export interface EventStream {
 }
 /** Process-local default blackboard. */
 export declare class InMemoryEventStream implements EventStream {
+    private readonly opts;
     private readonly events;
+    private readonly idempotentEvents;
     private readonly listeners;
+    constructor(opts?: EventStreamOptions);
     append(event: Omit<BlackboardEvent, "seq">): Promise<BlackboardEvent>;
     readSince(seq: number, viewer?: EventViewer): Promise<BlackboardEvent[]>;
     subscribe(cb: (e: BlackboardEvent) => void): () => void;

package/dist/runtime/event-stream.js

@@ -1,12 +1,4 @@
-/**
- * L2 (Blackboard) — a shared, append-only event stream that N peer agent sessions of one logical run
- * observe. This is the pluggable storage seam (like `SessionLog`): the default `InMemoryEventStream`
- * is process-local; back it with Postgres/Redis to span replicas/restarts.
- *
- * Visibility (spec §6.1): events are shared by default. Optional `channel` / `audience` tags scope an
- * event to a subset of personas, enforced at the framework boundary (`readSince(seq, viewer)` + the
- * `read_recent` tool) — context isolation, not convention.
- */
+import { reportObserverFailure } from "./reliability.js";
 /** Default full-share visibility rule (spec §6.1). */
 export function isVisibleTo(event, viewer) {
     if (event.audience === undefined && event.channel === undefined)
@@ -19,13 +11,35 @@ export function isVisibleTo(event, viewer) {
 }
 /** Process-local default blackboard. */
 export class InMemoryEventStream {
+    opts;
     events = [];
+    idempotentEvents = new Map();
     listeners = new Set();
+    constructor(opts = {}) {
+        this.opts = opts;
+    }
     async append(event) {
+        if (event.idempotencyKey) {
+            const existing = this.idempotentEvents.get(event.idempotencyKey);
+            if (existing)
+                return existing;
+        }
         const stamped = { ...event, seq: this.events.length };
         this.events.push(stamped);
-        for (const l of this.listeners)
-            l(stamped);
+        if (stamped.idempotencyKey)
+            this.idempotentEvents.set(stamped.idempotencyKey, stamped);
+        for (const listener of this.listeners) {
+            try {
+                listener(stamped);
+            }
+            catch (cause) {
+                reportObserverFailure(this.opts.onObserverError, {
+                    component: "InMemoryEventStream",
+                    operation: "event_stream_listener",
+                    cause,
+                });
+            }
+        }
         return stamped;
     }
     async readSince(seq, viewer) {

package/dist/runtime/execution-plane.d.ts

@@ -1,10 +1,14 @@
 import type { ToolCall, ToolSchema, StreamEvent, ToolSuspendEvent, PermissionRequestEvent, PermissionResponse } from "../types.js";
 import type { RegisteredTool } from "../tools/index.js";
-import type { DreamStore } from "../memory/protocols.js";
+import type { DreamStore, MemoryScope } from "../memory/protocols.js";
 import type { KnowledgeSource } from "../knowledge/source.js";
 import { LargeResultSpool } from "./large-result-spool.js";
+import type { OperationContext } from "./reliability.js";
 export interface RunContext {
+    /** Immutable identity, deadline, and cancellation boundary for this operation. */
+    operation?: OperationContext;
     agentId?: string;
+    memoryScope?: MemoryScope;
     skillDir?: string;
     dreamStore?: DreamStore;
     knowledgeSource?: KnowledgeSource;

package/dist/runtime/execution-plane.js

@@ -30,11 +30,16 @@ export class LocalExecutionPlane {
         for (const c of memoryCalls) {
             const args = tryParseJson(c.arguments);
             const topK = typeof args?.top_k === "number" ? args.top_k : 5;
-            const entries = (ctx.dreamStore && ctx.agentId)
-                ? await ctx.dreamStore.search(ctx.agentId, String(args?.query ?? ""), topK)
+            const entries = (ctx.dreamStore && ctx.agentId && ctx.memoryScope)
+                ? await ctx.dreamStore.search(ctx.agentId, {
+                    scope: ctx.memoryScope,
+                    query: String(args?.query ?? ""),
+                    top_k: topK,
+                    kinds: [],
+                })
                 : [];
             const content = entries.length
-                ? entries.map((e) => `[score=${e.score.toFixed(3)}] ${e.text}`).join("\n---\n")
+                ? entries.map(e => `[memory record_id=${e.record.record_id} trust=${e.record.provenance.trust} score=${e.score.toFixed(3)}] ${e.record.content}`).join("\n---\n")
                 : "No relevant memories found.";
             yield { type: "tool_result", callId: c.id, name: c.name, content, isError: false };
         }
@@ -107,6 +112,7 @@ export class LocalExecutionPlane {
         // best-effort failures recorded before the main throw.
         const auditFailures = [];
         const callCtx = {
+            ...(ctx.operation !== undefined ? { operation: ctx.operation } : {}),
             ...(ctx.cwd !== undefined ? { cwd: ctx.cwd } : {}),
             audit: async (label, fn) => {
                 try {

package/dist/runtime/facade.js

@@ -62,7 +62,8 @@ export async function runFanout(opts) {
     // but fall back to the last completed node's output so a kernel id-scheme change can't silently
     // return an empty synthesis.
     const synthesisId = `wf-node${opts.tasks.length}`;
-    const lastCompleted = outcome.completed[outcome.completed.length - 1];
+    const completed = outcome.nodeOutcomes.filter(node => node.status === "completed" || node.status === "completed_partial");
+    const lastCompleted = completed[completed.length - 1]?.nodeId;
     const synthesis = outcome.outputs[synthesisId] ?? (lastCompleted ? outcome.outputs[lastCompleted] : undefined) ?? "";
     return { synthesis, outputs: outcome.outputs };
 }

package/dist/runtime/kernel-event-log.d.ts

@@ -9,10 +9,8 @@ type CompressionAction = Extract<SessionEvent, {
 export declare function kernelObservationToSessionEvent(obs: KernelObservation, turn: number, opts?: {
     nextArchiveStart?: number;
     latestSeq?: number;
-    archiveRef?: string;
     preservedRefs?: string[];
     compressionAction?: (action?: string) => CompressionAction;
-    spoolRef?: string;
 }): SessionEvent | null;
 export type KernelPrimitive = "syscall" | "sched" | "mm";
 export declare function primitiveForCategory(category: KernelEventCategory): KernelPrimitive;

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

@@ -16,7 +16,7 @@ export function categoryForKind(kind) {
             return "mm";
         case "agent_process_changed":
             return "proc";
-        case "signal_disposed":
+        case "signal_delivery_disposed":
             return "ipc";
         default:
             return "sched";
@@ -38,7 +38,6 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 action: compressionAction(obs.action),
                 summary: obs.summary,
                 summary_tokens: obs.summary ? Math.max(1, Math.ceil(obs.summary.length / 4)) : undefined,
-                archive_ref: opts.archiveRef,
                 preserved_refs: opts.preservedRefs ?? [],
             };
         }
@@ -130,10 +129,13 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 tool: obs.tool ?? "",
                 reason: typeof obs.reason === "string" ? obs.reason : "",
             };
-        case "signal_disposed":
+        case "signal_delivery_disposed":
             return {
-                kind: "signal_disposed",
+                kind: "signal_delivery_disposed",
                 turn: t,
+                operation_id: obs.operation_id ?? "",
+                delivery_id: obs.delivery_id ?? "",
+                attempt: obs.attempt ?? 0,
                 signal_id: obs.signal_id ?? "",
                 disposition: obs.disposition ?? "",
                 queue_depth: obs.queue_depth ?? 0,
@@ -143,6 +145,26 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 kind: "budget_exceeded",
                 turn: t,
                 budget: obs.budget ?? "",
+                operation_id: obs.operation_id ?? "",
+                ...(obs.reservation_id ? { reservation_id: obs.reservation_id } : {}),
+            };
+        case "budget_usage_reported":
+            return {
+                kind: "budget_usage_reported",
+                turn: t,
+                operation_id: obs.operation_id ?? "",
+                reservation_id: obs.reservation_id ?? "",
+                tokens: obs.tokens ?? 0,
+                subagents: obs.subagents ?? 0,
+                rounds: obs.rounds ?? 0,
+            };
+        case "operation_cancelled":
+            return {
+                kind: "operation_cancelled",
+                turn: t,
+                operation_id: obs.operation_id ?? "",
+                reason: (obs.reason ?? "user"),
+                pending_call_ids: obs.pending_call_ids ?? [],
             };
         case "suspended":
             return {
@@ -168,21 +190,34 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 tool: obs.tool ?? "",
                 original_size: obs.original_size ?? 0,
                 preview_size: obs.preview_size ?? 0,
-                spool_ref: opts.spoolRef,
+                spool_ref: obs.spool_ref,
+            };
+        case "page_out_archived":
+            return {
+                kind: "page_out",
+                turn: t,
+                action: compressionAction(obs.action),
+                summary: obs.summary,
+                tier_hint: obs.tier,
+                message_count: obs.message_count ?? 0,
+                archive_ref: obs.archive_ref,
             };
         case "memory_written":
             return {
                 kind: "memory_written",
                 turn: t,
-                memory_id: obs.memory_id ?? "",
+                record_id: obs.record_id ?? "",
+                scope: obs.scope ?? { tenant_id: "", namespace: "" },
                 memory_kind: obs.memory_kind ?? "",
+                name: obs.name ?? "",
                 size_bytes: obs.size_bytes ?? 0,
             };
         case "memory_queried":
             return {
                 kind: "memory_queried",
                 turn: t,
-                query_context: obs.query_context ?? "",
+                scope: obs.scope ?? { tenant_id: "", namespace: "" },
+                query: obs.query ?? "",
                 requested_k: obs.requested_k ?? 0,
                 requires_async_response: obs.requires_async_response ?? false,
             };
@@ -190,7 +225,22 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
             return {
                 kind: "memory_validation_failed",
                 turn: t,
-                memory_id: obs.memory_id ?? "",
+                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": {
@@ -205,14 +255,12 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
             };
         }
         case "workflow_completed": {
-            const completed = obs.completed ?? [];
-            const failed = obs.failed ?? [];
+            const nodeOutcomes = obs.node_outcomes ?? [];
             return {
                 kind: "workflow_completed",
                 turn: t,
-                completed,
-                failed,
-                total_nodes: completed.length + failed.length,
+                node_outcomes: nodeOutcomes,
+                total_nodes: nodeOutcomes.length,
             };
         }
         default:

package/dist/runtime/kernel-primitives-dashboard.js

@@ -54,7 +54,7 @@ export class KernelPrimitivesDashboard {
             else if (event.kind === "resumed") {
                 this.stats.sched.resumedCount++;
             }
-            else if (event.kind === "signal_disposed") {
+            else if (event.kind === "signal_delivery_disposed") {
                 this.stats.sched.signalDisposedCount++;
             }
             else if (event.kind === "budget_exceeded") {

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

@@ -0,0 +1,13 @@
+import type { KernelRuntimeHandle } from "./kernel-step.js";
+import { type KernelOperationCursor, type KernelOperationGenesis, type KernelTransaction } from "./kernel-transaction-log.js";
+export interface KernelRebuildResult {
+    runtime: KernelRuntimeHandle;
+    cursor: KernelOperationCursor;
+}
+/**
+ * Deterministically fold an authoritative operation stream into a fresh runtime.
+ *
+ * The caller owns runtime construction, but its initial policy and replay-affecting defaults must
+ * exactly match genesis. A failure leaves the supplied runtime unusable; callers must discard it.
+ */
+export declare function rebuildKernelRuntime(runtime: KernelRuntimeHandle, genesis: KernelOperationGenesis, transactions: readonly KernelTransaction[]): KernelRebuildResult;

package/dist/runtime/kernel-rebuild.js

@@ -0,0 +1,75 @@
+import { KernelLogIntegrityError, kernelRecordDigest, verifyKernelTransactionStream, } from "./kernel-transaction-log.js";
+/**
+ * Deterministically fold an authoritative operation stream into a fresh runtime.
+ *
+ * The caller owns runtime construction, but its initial policy and replay-affecting defaults must
+ * exactly match genesis. A failure leaves the supplied runtime unusable; callers must discard it.
+ */
+export function rebuildKernelRuntime(runtime, genesis, transactions) {
+    const cursor = verifyKernelTransactionStream(genesis, transactions);
+    assertFreshRuntimeMatchesGenesis(runtime, genesis);
+    for (const transaction of transactions) {
+        const prepared = JSON.parse(runtime.prepareStep(JSON.stringify(transaction.input)));
+        const token = prepared.prepare_token;
+        try {
+            if (prepared.status !== "prepared" || !token) {
+                throw new KernelLogIntegrityError(`kernel rebuild step ${transaction.step_seq} was not accepted as a new transition`);
+            }
+            if (prepared.base_generation !== transaction.base_generation) {
+                throw new KernelLogIntegrityError(`kernel rebuild generation ${prepared.base_generation} does not match transaction ${transaction.base_generation}`);
+            }
+            if (prepared.step.step_seq !== transaction.step_seq) {
+                throw new KernelLogIntegrityError(`kernel rebuild step_seq ${prepared.step.step_seq} does not match transaction ${transaction.step_seq}`);
+            }
+            if (kernelRecordDigest(prepared.input) !== transaction.input_digest) {
+                throw new KernelLogIntegrityError(`kernel rebuild normalized input diverged at step ${transaction.step_seq}`);
+            }
+            if (kernelRecordDigest(prepared.step) !== transaction.step_digest) {
+                throw new KernelLogIntegrityError(`kernel rebuild planned step diverged at step ${transaction.step_seq}`);
+            }
+            const committed = JSON.parse(runtime.commitPrepared(token));
+            if (kernelRecordDigest(committed) !== transaction.step_digest) {
+                throw new KernelLogIntegrityError(`kernel rebuild committed step diverged at step ${transaction.step_seq}`);
+            }
+        }
+        catch (error) {
+            if (token && prepared.status === "prepared") {
+                try {
+                    runtime.abortPrepared(token);
+                }
+                catch {
+                    // The caller must discard a failed rebuild runtime; preserve the primary integrity error.
+                }
+            }
+            throw error;
+        }
+    }
+    return { runtime, cursor };
+}
+function assertFreshRuntimeMatchesGenesis(runtime, genesis) {
+    const snapshot = JSON.parse(runtime.snapshot());
+    if (snapshot.abi_version !== genesis.abi_version) {
+        throw new KernelLogIntegrityError("kernel runtime ABI version does not match operation genesis");
+    }
+    if (genesis.default_policy_version !== 1) {
+        throw new KernelLogIntegrityError("kernel operation uses an unsupported default policy version");
+    }
+    if (snapshot.operation_id || snapshot.next_step_seq !== 1 || snapshot.accepted_inputs.length !== 0) {
+        throw new KernelLogIntegrityError("kernel rebuild requires a fresh runtime");
+    }
+    if (kernelRecordDigest(snapshot.initial_policy) !== kernelRecordDigest(genesis.initial_scheduler_policy)) {
+        throw new KernelLogIntegrityError("kernel runtime initial policy does not match operation genesis");
+    }
+    const defaults = resolvedRuntimeDefaults(snapshot);
+    if (kernelRecordDigest(defaults) !== kernelRecordDigest(genesis.resolved_runtime_defaults)) {
+        throw new KernelLogIntegrityError("kernel runtime defaults do not match operation genesis");
+    }
+}
+function resolvedRuntimeDefaults(snapshot) {
+    return {
+        snapshot_version: snapshot.snapshot_version,
+        snapshot_input_limit: snapshot.snapshot_input_limit,
+        max_input_bytes: snapshot.max_input_bytes,
+        snapshot_journal_bytes_limit: snapshot.snapshot_journal_bytes_limit,
+    };
+}