@deepstrike/sdk 0.2.38 → 0.2.40

package/dist/harness/harness.js

@@ -1,166 +1,212 @@
-import { collectText } from "../runtime/runner.js";
-import { writeFile } from "fs/promises";
-import path from "path";
-import { HybridJudge, VerdictFnJudge, LlmEvalJudge } from "./judge.js";
-async function runOnce(runner, req) {
-    let text = "";
-    let done;
-    const sessionId = crypto.randomUUID();
-    for await (const evt of runner.run({ sessionId, goal: req.goal, criteria: req.criteria?.map(c => c.text), extensions: req.extensions })) {
-        if (evt.type === "text_delta")
-            text += evt.delta;
-        else if (evt.type === "done")
-            done = evt;
-    }
-    return { result: text, passed: false, iterations: done?.iterations ?? 0, totalTokens: done?.totalTokens ?? 0, status: done?.status ?? "error" };
-}
-export class SinglePassHarness {
+/** Adapts RuntimeRunner to the body slot without giving the loop knowledge of kernel events. */
+export class RuntimeAttemptBody {
     runner;
     constructor(runner) {
         this.runner = runner;
     }
-    async run(request) {
-        return { ...await runOnce(this.runner, request), passed: true };
-    }
-    async *stream(request) {
-        yield* this.runner.run({ sessionId: crypto.randomUUID(), goal: request.goal, criteria: request.criteria?.map(c => c.text), extensions: request.extensions });
-    }
-}
-/**
- * @deprecated I3.4 (A1): prefer {@link HarnessLoop} with `verdictFn` for host-defined judgment.
- * `EvalLoopHarness.stream()` does NOT honor the `gate` passed via `request.gate` (only `.run()`
- * does), which is a long-standing footgun for streaming hosts. `HarnessLoop` runs the eval loop
- * uniformly across both stream and run, accepts an optional `verdictFn` for short-circuiting the
- * built-in LLM eval, and otherwise mirrors `EvalLoopHarness`'s behavior. New code should use
- * `HarnessLoop`; existing call sites can migrate by switching the class + (if applicable)
- * passing a `verdictFn` for the same gate logic. Slated for removal in a future major. */
-export class EvalLoopHarness {
-    runner;
-    gate;
-    maxAttempts;
-    constructor(runner, gate, maxAttempts = 3) {
-        this.runner = runner;
-        this.gate = gate;
-        this.maxAttempts = maxAttempts;
-    }
-    async run(request) {
-        let outcome = { result: "", passed: false, iterations: 0, totalTokens: 0, status: "error" };
-        for (let i = 0; i < this.maxAttempts; i++) {
-            outcome = await runOnce(this.runner, request);
-            if (await this.gate.evaluate(request, outcome))
-                return { ...outcome, passed: true };
+    async *run(context) {
+        if (context.contextInput)
+            this.runner.injectNote(context.contextInput);
+        let result = "";
+        let done;
+        const submittedNodes = [];
+        for await (const event of this.runner.run({
+            sessionId: context.sessionId,
+            goal: context.goal,
+            criteria: (context.criteria ?? []).map(criterion => criterion.text),
+            extensions: context.extensions,
+            ...(context.attempt === 1 && context.inheritEvents
+                ? { inheritEvents: context.inheritEvents }
+                : {}),
+        })) {
+            if (event.type === "text_delta") {
+                const text = event.delta;
+                result += text;
+                yield { type: "token", text };
+            }
+            else if (event.type === "tool_call") {
+                const call = event;
+                yield { type: "tool_call", id: call.id, name: call.name };
+            }
+            else if (event.type === "tool_delta") {
+                const delta = event;
+                yield {
+                    type: "tool_delta",
+                    callId: delta.callId,
+                    ...(delta.delta !== undefined ? { delta: delta.delta } : {}),
+                    ...(delta.chunk !== undefined ? { chunk: delta.chunk } : {}),
+                };
+            }
+            else if (event.type === "tool_suspend") {
+                const suspended = event;
+                yield {
+                    type: "tool_suspend",
+                    callId: suspended.callId,
+                    suspensionId: suspended.suspensionId,
+                    ...(suspended.payload !== undefined ? { payload: suspended.payload } : {}),
+                };
+            }
+            else if (event.type === "tool_result") {
+                const toolResult = event;
+                yield {
+                    type: "tool_result",
+                    callId: toolResult.callId,
+                    content: toolResult.content,
+                    isError: toolResult.isError,
+                };
+            }
+            else if (event.type === "workflow_nodes_submitted") {
+                const nodes = event.nodes;
+                submittedNodes.push(...nodes);
+                yield { type: "workflow_nodes_submitted", nodes };
+            }
+            else if (event.type === "error") {
+                yield { type: "body_error", message: String(event.message ?? "run failed") };
+            }
+            else if (event.type === "done") {
+                done = event;
+            }
         }
-        return outcome;
-    }
-    async *stream(request) {
-        yield* this.runner.run({ sessionId: crypto.randomUUID(), goal: request.goal, criteria: request.criteria?.map(c => c.text), extensions: request.extensions });
+        yield {
+            type: "body_done",
+            runStatus: done?.status ?? "error",
+            result,
+            turns: done?.iterations ?? 0,
+            totalTokens: done?.totalTokens ?? 0,
+            ...(submittedNodes.length > 0 ? { submittedNodes } : {}),
+        };
     }
 }
-export class HarnessLoop {
-    runner;
-    maxAttempts;
-    skillDir;
-    /** How each attempt is judged. Hybrid (host verdictFn → LLM eval) when a verdictFn is supplied,
-     *  otherwise the built-in LLM eval. The loop just calls `this.judge.judge(...)`. */
-    judge;
-    constructor(runner, evalProvider, options = {}) {
-        this.runner = runner;
-        this.maxAttempts = options.maxAttempts ?? 3;
-        this.skillDir = options.skillDir;
-        const llmJudge = new LlmEvalJudge(evalProvider);
-        this.judge = options.verdictFn
-            ? new HybridJudge(new VerdictFnJudge(options.verdictFn), llmJudge)
-            : llmJudge;
+/** Default: retain the transcript and deliver judge feedback through the runner's signal input. */
+export const continueSession = context => ({
+    sessionId: context.rootSessionId,
+    goal: context.goal,
+    ...(context.previousVerdict?.feedback
+        ? { contextInput: context.previousVerdict.feedback }
+        : {}),
+});
+/** Explicit isolation policy preserving the old fresh-session + goal-feedback behavior. */
+export const freshWithFeedback = context => ({
+    sessionId: context.attempt === 1 ? context.rootSessionId : crypto.randomUUID(),
+    goal: context.previousVerdict?.feedback
+        ? `${context.goal}\n\n[Attempt ${context.attempt - 1} feedback: ${context.previousVerdict.feedback}]`
+        : context.goal,
+});
+export function freshWithDigest(digest) {
+    return async (context) => ({
+        sessionId: context.attempt === 1 ? context.rootSessionId : crypto.randomUUID(),
+        goal: context.previousVerdict
+            ? `${context.goal}\n\n[Prior attempt digest: ${await digest(context.previousVerdict, context.attempt - 1)}]`
+            : context.goal,
+    });
+}
+function isRunError(status) {
+    const normalized = status.toLocaleLowerCase();
+    return normalized === "error" || normalized === "invalid_arg" || normalized === "user_abort";
+}
+/** One attempt engine. Body, judgment, carry, and stopping are independent policy slots. */
+export class AttemptLoop {
+    options;
+    carry;
+    constructor(options) {
+        this.options = options;
+        if (!Number.isInteger(options.stop.maxAttempts) || options.stop.maxAttempts < 1) {
+            throw new Error("AttemptLoop stop.maxAttempts must be a positive integer");
+        }
+        if (options.stop.maxTotalTokens !== undefined && options.stop.maxTotalTokens < 0) {
+            throw new Error("AttemptLoop stop.maxTotalTokens must be non-negative");
+        }
+        this.carry = options.carry ?? continueSession;
     }
     async run(request) {
-        let last;
-        // R3-1: collect nodes the agent submitted while running under the harness, so dynamic fan-out
-        // works in harness mode too (not just the plain streaming path).
-        const submittedNodes = [];
-        for await (const evt of this.stream(request)) {
-            last = evt;
-            if (evt.type === "workflow_nodes_submitted")
-                submittedNodes.push(...evt.nodes);
+        let outcome;
+        for await (const event of this.stream(request)) {
+            if (event.type === "completed")
+                outcome = event.outcome;
         }
-        const done = last?.type === "done" ? last : undefined;
-        return {
-            result: "",
-            passed: done?.verdict.passed ?? false,
-            iterations: done?.iterations ?? 0,
-            totalTokens: done?.totalTokens ?? 0,
-            status: done?.status ?? "error",
-            overallScore: done?.verdict.overallScore,
-            feedback: done?.verdict.feedback,
-            details: done?.verdict.details,
-            ...(submittedNodes.length ? { submittedNodes } : {}),
-        };
+        if (!outcome)
+            throw new Error("AttemptLoop ended without an outcome");
+        return outcome;
     }
     async *stream(request) {
+        const rootSessionId = request.sessionId ?? crypto.randomUUID();
         const criteria = request.criteria ?? [];
-        let currentGoal = request.goal;
-        let lastIterations = 0;
-        let lastTotalTokens = 0;
-        let lastStatus = "error";
-        let lastResult = "";
-        for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
-            const sessionId = crypto.randomUUID();
-            for await (const evt of this.runner.run({ sessionId, goal: currentGoal, criteria: criteria.map(c => c.text), extensions: request.extensions })) {
-                if (evt.type === "text_delta") {
-                    lastResult += evt.delta;
-                    yield { type: "token", text: evt.delta };
-                }
-                else if (evt.type === "tool_call") {
-                    const tc = evt;
-                    yield { type: "tool_call", id: tc.id, name: tc.name };
-                }
-                else if (evt.type === "tool_delta") {
-                    const td = evt;
-                    yield { type: "tool_delta", callId: td.callId, ...(td.delta ? { delta: td.delta } : {}), ...(td.chunk ? { chunk: td.chunk } : {}) };
-                }
-                else if (evt.type === "tool_suspend") {
-                    const ts = evt;
-                    yield { type: "tool_suspend", callId: ts.callId, suspensionId: ts.suspensionId, ...(ts.payload ? { payload: ts.payload } : {}) };
-                }
-                else if (evt.type === "tool_result") {
-                    const tr = evt;
-                    yield { type: "tool_result", callId: tr.callId, content: tr.content, isError: tr.isError };
-                }
-                else if (evt.type === "workflow_nodes_submitted") {
-                    const ws = evt;
-                    yield { type: "workflow_nodes_submitted", nodes: ws.nodes };
+        const submittedNodes = [];
+        let totalTokens = 0;
+        let totalTurns = 0;
+        let previousVerdict;
+        for (let attempt = 1; attempt <= this.options.stop.maxAttempts; attempt++) {
+            const prepared = await this.carry({
+                rootSessionId,
+                goal: request.goal,
+                attempt,
+                previousVerdict,
+            });
+            let terminal;
+            for await (const event of this.options.body.run({
+                ...request,
+                sessionId: prepared.sessionId,
+                goal: prepared.goal,
+                criteria,
+                attempt,
+                ...(prepared.contextInput ? { contextInput: prepared.contextInput } : {}),
+            })) {
+                if (event.type === "body_done") {
+                    terminal = event;
+                    if (event.submittedNodes)
+                        submittedNodes.push(...event.submittedNodes);
                 }
-                else if (evt.type === "done") {
-                    const d = evt;
-                    lastIterations = d.iterations;
-                    lastTotalTokens = d.totalTokens;
-                    lastStatus = d.status;
+                else {
+                    yield event;
                 }
             }
-            yield { type: "supervising" };
-            // I3.2 (A2/A3): the judge Strategy encapsulates "host verdictFn short-circuit → built-in LLM
-            // eval". HarnessLoop's judge always terminates in LlmEvalJudge, so a verdict is guaranteed.
-            const judged = await this.judge.judge({ goal: request.goal, criteria, attempt, result: lastResult });
-            const verdict = judged?.verdict;
-            const skillCandidate = judged?.skillCandidate;
-            if (!verdict)
-                throw new Error("HarnessLoop: judge produced no verdict");
+            if (!terminal)
+                throw new Error("AttemptBody ended without body_done");
+            totalTokens += terminal.totalTokens;
+            totalTurns += terminal.turns;
+            const base = {
+                runStatus: terminal.runStatus,
+                result: terminal.result,
+                attempts: attempt,
+                turns: totalTurns,
+                totalTokens,
+                ...(submittedNodes.length > 0 ? { submittedNodes } : {}),
+            };
+            if (isRunError(terminal.runStatus)) {
+                yield { type: "completed", outcome: { outcome: "run_error", ...base } };
+                return;
+            }
+            yield { type: "judging", attempt };
+            const judged = await this.options.judge.judge({
+                goal: request.goal,
+                criteria,
+                attempt,
+                result: terminal.result,
+            });
+            if (!judged)
+                throw new Error("AttemptLoop judge produced no verdict");
+            const verdict = judged.verdict;
             if (verdict.passed) {
-                if (skillCandidate && this.skillDir) {
-                    const { name, description, whenToUse, content } = skillCandidate;
-                    const fm = ["---", `name: ${name}`, `description: ${description}`,
-                        whenToUse ? `when_to_use: ${whenToUse}` : null, "---", ""]
-                        .filter(Boolean).join("\n");
-                    await writeFile(path.join(this.skillDir, `${name}.md`), fm + content, "utf8");
-                }
-                yield { type: "done", verdict, iterations: lastIterations, totalTokens: lastTotalTokens, status: lastStatus };
+                const outcome = { outcome: "passed", ...base, verdict };
+                await this.options.onPass?.({ outcome, judgeResult: judged });
+                yield { type: "completed", outcome };
+                return;
+            }
+            previousVerdict = verdict;
+            const tokenLimitReached = this.options.stop.maxTotalTokens !== undefined
+                && totalTokens >= this.options.stop.maxTotalTokens;
+            if (this.options.stop.stopOnFailedVerdict || attempt === this.options.stop.maxAttempts || tokenLimitReached) {
+                yield {
+                    type: "completed",
+                    outcome: {
+                        outcome: this.options.stop.stopOnFailedVerdict ? "failed_judge" : "exhausted",
+                        ...base,
+                        verdict,
+                    },
+                };
                 return;
             }
-            yield { type: "revising", verdict };
-            currentGoal = `${request.goal}\n\n[Attempt ${attempt} feedback: ${verdict.feedback}]`;
-            lastResult = "";
+            yield { type: "retrying", attempt, verdict };
         }
-        yield { type: "max_attempts_reached" };
     }
 }
-// Re-export collectText so harness callers can use it without knowing runner internals.
-export { collectText };

package/dist/harness/judge.d.ts

@@ -1,6 +1,7 @@
 import type { LLMProvider } from "../types.js";
 import { getKernel } from "../kernel.js";
-import type { Criterion, Verdict, VerdictFn } from "./harness.js";
+import type { VerdictFn } from "./harness.js";
+import type { Criterion, Verdict } from "../runtime/eval.js";
 export type SkillCandidate = ReturnType<ReturnType<typeof getKernel>["parseVerdict"]>["skillCandidate"];
 export interface JudgeContext {
     goal: string;
@@ -32,7 +33,7 @@ export declare class LlmEvalJudge implements AttemptJudge {
     constructor(evalProvider: LLMProvider, extractSkillOnPass?: boolean);
     judge(ctx: JudgeContext): Promise<JudgeResult>;
 }
-/** Try `primary`; if it defers (`undefined`), use `fallback`. Models HarnessLoop's
+/** Try `primary`; if it defers (`undefined`), use `fallback`.
  *  "verdictFn short-circuits, else built-in LLM eval" hybrid judgment. */
 export declare class HybridJudge implements AttemptJudge {
     private readonly primary;

package/dist/harness/judge.js

@@ -15,13 +15,17 @@ export class VerdictFnJudge {
 export class LlmEvalJudge {
     evalProvider;
     extractSkillOnPass;
-    constructor(evalProvider, extractSkillOnPass = true) {
+    constructor(evalProvider, extractSkillOnPass = false) {
         this.evalProvider = evalProvider;
         this.extractSkillOnPass = extractSkillOnPass;
     }
     async judge(ctx) {
         const kernel = getKernel();
-        const evalMsgs = kernel.buildEvalMessages(ctx.goal, ctx.criteria, ctx.result, ctx.attempt, this.extractSkillOnPass);
+        const evalMsgs = kernel.buildEvalMessages(ctx.goal, ctx.criteria.map(criterion => ({
+            text: criterion.text,
+            required: criterion.required ?? true,
+            weight: criterion.weight,
+        })), ctx.result, ctx.attempt, this.extractSkillOnPass);
         const evalContext = {
             systemText: evalMsgs.filter((m) => m.role === "system").map((m) => m.content).join("\n\n"),
             turns: evalMsgs.filter((m) => m.role !== "system"),
@@ -43,7 +47,7 @@ export class LlmEvalJudge {
         };
     }
 }
-/** Try `primary`; if it defers (`undefined`), use `fallback`. Models HarnessLoop's
+/** Try `primary`; if it defers (`undefined`), use `fallback`.
  *  "verdictFn short-circuits, else built-in LLM eval" hybrid judgment. */
 export class HybridJudge {
     primary;

package/dist/harness/public.d.ts

@@ -1,4 +1,6 @@
-export { SinglePassHarness, EvalLoopHarness, HarnessLoop } from "./harness.js";
-export type { HarnessRequest, HarnessOutcome, HarnessLoopOptions, QualityGate, CriterionResult, HarnessEvent, VerdictFn, } from "./harness.js";
+export { AttemptLoop, RuntimeAttemptBody, continueSession, freshWithFeedback, freshWithDigest, } from "./harness.js";
+export type { AttemptRequest, AttemptBodyContext, AttemptProgressEvent, AttemptBodyTerminal, AttemptBodyEvent, AttemptBody, PreparedAttempt, CarryPolicy, StopPolicy, AttemptOutcomeKind, AttemptOutcome, AttemptLoopEvent, AttemptLoopOptions, VerdictFn, Criterion, Verdict, } from "./harness.js";
+export { VerdictFnJudge, LlmEvalJudge, HybridJudge } from "./judge.js";
+export type { AttemptJudge, JudgeContext, JudgeResult, SkillCandidate } from "./judge.js";
 export { judge } from "../runtime/eval.js";
-export type { Criterion, Verdict, VerdictDetail, JudgeArgs } from "../runtime/eval.js";
+export type { VerdictDetail, JudgeArgs } from "../runtime/eval.js";

package/dist/harness/public.js

@@ -1,3 +1,4 @@
-// `@deepstrike/sdk/harness` — the evaluation framework: single-pass / eval-loop harnesses and the judge.
-export { SinglePassHarness, EvalLoopHarness, HarnessLoop } from "./harness.js";
+// `@deepstrike/sdk/harness` — one attempt engine with independent body/judge/carry/stop policies.
+export { AttemptLoop, RuntimeAttemptBody, continueSession, freshWithFeedback, freshWithDigest, } from "./harness.js";
+export { VerdictFnJudge, LlmEvalJudge, HybridJudge } from "./judge.js";
 export { judge } from "../runtime/eval.js";

package/dist/index.d.ts

@@ -3,19 +3,33 @@ export { runLoop, LoopDriver, foldLoopState } from "./runtime/loop-driver.js";
 export type { LoopSpec, LoopOutcome } from "./runtime/loop-driver.js";
 export type { RunAgentOptions, RunFanoutOptions } from "./runtime/facade.js";
 export { RuntimeRunner, collectText } from "./runtime/runner.js";
-export type { RuntimeOptions } from "./runtime/runner.js";
+export type { RuntimeOptions, KernelReliabilityOptions, OperationCancellationReason, PromptBudget, SchedulerPolicy } from "./runtime/runner.js";
+export type { SignalPolicy } from "./runtime/os-profile.js";
+export { readKernelDiagnostics, restoreKernelRuntime, snapshotKernelRuntime } from "./runtime/kernel-step.js";
+export type { KernelDiagnostics, KernelSnapshot } from "./runtime/kernel-step.js";
+export { rebuildKernelRuntime } from "./runtime/kernel-rebuild.js";
+export type { KernelRebuildResult } from "./runtime/kernel-rebuild.js";
+export { CONTEXT_POLICY_VERSION, DEFAULT_CONTEXT_POLICY_V1, PPM_SCALE, contextPolicyV1, normalizeContextPolicyV1, ratioToPpm, } from "./runtime/context-policy.js";
+export type { ContextPolicyOverridesV1, ContextPolicyV1, ContextPolicyWireV1, ContextPressureThresholdsV1, } from "./runtime/context-policy.js";
 export { LocalExecutionPlane } from "./runtime/execution-plane.js";
 export type { ExecutionPlane, RunContext } from "./runtime/execution-plane.js";
 export { InMemorySessionLog, FileSessionLog } from "./runtime/session-log.js";
-export type { SessionLog, SessionEvent } from "./runtime/session-log.js";
-export { InMemoryGroupBudgetStore, SessionLogGroupBudgetStore } from "./runtime/run-group.js";
-export type { RunGroup, GroupBudgetStore, GroupLedger, GroupCharge, GroupMember } from "./runtime/run-group.js";
+export type { KernelTransactionEntry, SessionLog, SessionEvent } from "./runtime/session-log.js";
+export { KERNEL_LOG_RECORD_VERSION, KernelLogConflictError, KernelLogIntegrityError, canonicalKernelJson, createKernelOperationGenesis, createKernelTransaction, kernelRecordDigest, verifyKernelOperationGenesis, verifyKernelTransaction, verifyKernelTransactionStream, verifyKernelTransactionSuccessor, } from "./runtime/kernel-transaction-log.js";
+export type { DurableAppendReceipt, KernelGenesisReceipt, KernelOperationCursor, KernelOperationGenesis, KernelOperationGenesisBody, KernelTransaction, KernelTransactionBody, } from "./runtime/kernel-transaction-log.js";
+export { InMemoryGroupBudgetStore, GroupBudgetScope } from "./runtime/run-group.js";
+export type { RunGroup, GroupBudgetStore, GroupLedger, GroupCharge, GroupMember, GroupBudgetRequest, GroupBudgetReservation, } from "./runtime/run-group.js";
 export { InMemoryEventStream, isVisibleTo } from "./runtime/event-stream.js";
-export type { EventStream, BlackboardEvent, EventViewer } from "./runtime/event-stream.js";
+export type { EventStream, EventStreamOptions, BlackboardEvent, EventViewer } from "./runtime/event-stream.js";
+export type { ObserverFailure, ObserverErrorHandler } from "./runtime/reliability.js";
+export { ManagedTaskScope } from "./runtime/reliability.js";
+export type { OperationContext, BackgroundTaskFailure, BackgroundTaskErrorHandler } from "./runtime/reliability.js";
 export { reactByMention, directorDriven, roundRobin, firstNonEmpty, union } from "./runtime/turn-policy.js";
 export type { TurnPolicy, PeerView } from "./runtime/turn-policy.js";
 export { ReactiveSession, readRecentTool } from "./runtime/reactive-session.js";
 export type { ReactiveSessionOptions, ReactivePeerSpec, EmitEvent, Reaction, ReactorTurn, ReactorContext } from "./runtime/reactive-session.js";
+export { InMemoryReactionCheckpointStore, ReactionInProgressError } from "./runtime/reaction-checkpoint.js";
+export type { ReactionCheckpointClaim, ReactionCheckpointClaimResult, ReactionCheckpointReceipt, ReactionCheckpointStore, ReactionRecord, } from "./runtime/reaction-checkpoint.js";
 export { tool, streamingTool } from "./tools/index.js";
 export type { RegisteredTool, ToolExecContext } from "./tools/index.js";
 export { safeTool, ok, fail, ToolError, formatToolError } from "./tools/errors.js";
@@ -26,10 +40,11 @@ export { OpenAIProvider } from "./providers/openai.js";
 export type { OpenAIProviderOptions } from "./providers/openai.js";
 export { OpenAIResponsesProvider } from "./providers/openai-responses.js";
 export { createProvider } from "./providers/catalog.js";
+export { UnsupportedModalityError } from "./providers/base.js";
 export type { CreateProviderOptions, EndpointProfileId } from "./providers/catalog.js";
 export { Governance } from "./governance.js";
 export type { GovernanceVerdict, GovernancePolicy, GovernanceConstraint } from "./governance.js";
 export { AgentPool } from "./collaboration/pool.js";
-export type { RuntimeSignal, SignalSource } from "./signals/types.js";
+export type { RuntimeSignal, SignalClaim, SignalDeliveryReceipt, SignalSource, } from "./signals/types.js";
 export type { Message, ToolCall, ToolResult, ToolSchema, ContentPart, TextPart, ImagePart, AudioPart, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolChunk, ToolDeltaEvent, ToolSuspendEvent, ToolResultEvent, ToolAuditFailedEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, PermissionResolvedEvent, PermissionResponse, EntropySample, EntropySampleEvent, EntropyAlertEvent, EntropyWatchOptions, LLMProvider, RetryConfig, TokenUsage, } from "./types.js";
-export type { WorkflowSpec, WorkflowNodeSpec, } from "./types/agent.js";
+export type { WorkflowSpec, WorkflowNodeSpec, WorkflowDependencyPolicy, WorkflowNodeStatus, WorkflowNodeOutcome, WorkflowOutcome, } from "./types/agent.js";

package/dist/index.js

@@ -15,13 +15,19 @@ export { runAgent, runFanout } from "./runtime/facade.js";
 // ③ dynamic loop agents: self-pacing rounds over the kernel pacing trap.
 export { runLoop, LoopDriver, foldLoopState } from "./runtime/loop-driver.js";
 export { RuntimeRunner, collectText } from "./runtime/runner.js";
+export { readKernelDiagnostics, restoreKernelRuntime, snapshotKernelRuntime } from "./runtime/kernel-step.js";
+export { rebuildKernelRuntime } from "./runtime/kernel-rebuild.js";
+export { CONTEXT_POLICY_VERSION, DEFAULT_CONTEXT_POLICY_V1, PPM_SCALE, contextPolicyV1, normalizeContextPolicyV1, ratioToPpm, } from "./runtime/context-policy.js";
 // ── Execution plane + session log (the defaults) ────────────────────────────
 export { LocalExecutionPlane } from "./runtime/execution-plane.js";
 export { InMemorySessionLog, FileSessionLog } from "./runtime/session-log.js";
-export { InMemoryGroupBudgetStore, SessionLogGroupBudgetStore } from "./runtime/run-group.js";
+export { KERNEL_LOG_RECORD_VERSION, KernelLogConflictError, KernelLogIntegrityError, canonicalKernelJson, createKernelOperationGenesis, createKernelTransaction, kernelRecordDigest, verifyKernelOperationGenesis, verifyKernelTransaction, verifyKernelTransactionStream, verifyKernelTransactionSuccessor, } from "./runtime/kernel-transaction-log.js";
+export { InMemoryGroupBudgetStore, GroupBudgetScope } from "./runtime/run-group.js";
 export { InMemoryEventStream, isVisibleTo } from "./runtime/event-stream.js";
+export { ManagedTaskScope } from "./runtime/reliability.js";
 export { reactByMention, directorDriven, roundRobin, firstNonEmpty, union } from "./runtime/turn-policy.js";
 export { ReactiveSession, readRecentTool } from "./runtime/reactive-session.js";
+export { InMemoryReactionCheckpointStore, ReactionInProgressError } from "./runtime/reaction-checkpoint.js";
 // ── Tool authoring ──────────────────────────────────────────────────────────
 export { tool, streamingTool } from "./tools/index.js";
 export { safeTool, ok, fail, ToolError, formatToolError } from "./tools/errors.js";
@@ -32,6 +38,7 @@ export { AnthropicProvider } from "./providers/anthropic.js";
 export { OpenAIProvider } from "./providers/openai.js";
 export { OpenAIResponsesProvider } from "./providers/openai-responses.js";
 export { createProvider } from "./providers/catalog.js";
+export { UnsupportedModalityError } from "./providers/base.js";
 // ── Governance ──────────────────────────────────────────────────────────────
 export { Governance } from "./governance.js";
 // ── Multi-agent primitive ───────────────────────────────────────────────────

package/dist/kernel.d.ts

@@ -70,10 +70,15 @@ export interface RuntimeSignal {
     summary: string;
     payload: string;
     dedupeKey?: string;
+    recipient?: string;
+    deadlineMs?: number;
+    coalesceKey?: string;
+    coalescedCount?: number;
     timestampMs: number;
 }
+export type SignalRouterLifecycle = "ready" | "running" | "suspended" | "done";
 interface SignalRouterInstance {
-    ingest(signal: RuntimeSignal, isRunning: boolean): string;
+    ingest(signal: RuntimeSignal, lifecycle: SignalRouterLifecycle): string;
     next(): RuntimeSignal | null;
 }
 interface NativeCriterion {
@@ -98,45 +103,14 @@ export interface Verdict {
         content: string;
     };
 }
-interface IdlePipelineAction {
-    kind: "synthesize_insights" | "commit_memories" | "noop" | "aborted";
-    messages?: Message[];
-    curationResult?: {
-        toAdd?: Array<{
-            text: string;
-            score: number;
-            metadata: string;
-        }>;
-        toRemoveIndices?: number[];
-        stats?: {
-            insightsProcessed?: number;
-            duplicatesRemoved?: number;
-            conflictsResolved?: number;
-            entriesAdded?: number;
-        };
-    };
-    runResult?: {
-        sessionsProcessed: number;
-        insightsExtracted: number;
-    };
-}
-interface IdlePipelineInstance {
-    feedTrigger(sessions: Array<{
-        sessionId: string;
-        agentId: string;
-        messages: Message[];
-        metadata: string;
-        createdAtMs: number;
-        updatedAtMs: number;
-    }>, existingMemories: Array<{
-        text: string;
-        score: number;
-        metadata: string;
-    }>, nowMs: number): IdlePipelineAction;
-    feedSynthesisResult(content: string): IdlePipelineAction;
-}
 export interface KernelRuntimeInstance {
     step(inputJson: string): string;
+    prepareStep(inputJson: string): string;
+    commitPrepared(prepareToken: string): string;
+    abortPrepared(prepareToken: string): void;
+    snapshot(): string;
+    restore(snapshotJson: string): void;
+    diagnostics(): string;
     isTerminal(): boolean;
     turn(): number;
     /** L1 (RunGroup): cumulative sub-agent spawns this run, for charging the group ledger at run end. */
@@ -158,7 +132,6 @@ interface KernelModule {
     buildEvalMessages(goal: string, criteria: NativeCriterion[], result: string, attempt: number, extractSkillOnPass: boolean): Message[];
     parseVerdict(content: string): Verdict;
     verdictOutputSchema(extractSkillOnPass: boolean): string;
-    IdlePipeline: new (agentId: string) => IdlePipelineInstance;
 }
 export declare function getKernel(): KernelModule;
 export {};