@deepstrike/wasm 0.2.39 → 0.2.40

package/README.md

@@ -79,7 +79,7 @@ src/
 ├── tools/            # tool() helper, executeTools (no fs/shell)
 ├── memory/           # WorkingMemory + DreamStore interfaces
 ├── knowledge/        # KnowledgeSource interface
-├── harness/          # SinglePassHarness, HarnessLoop
+├── harness/          # AttemptLoop body/judge/carry/stop policies
 ├── signals/          # RuntimeSignal, SignalSource, ScheduledPrompt
 └── safety/           # PermissionManager
 ```
@@ -241,26 +241,26 @@ const runner = new RuntimeRunner({
 
 ---
 
-## Harness
+## Attempt loop
 
 ```typescript
-import { SinglePassHarness, HarnessLoop } from "@deepstrike/wasm"
+import { AttemptLoop, RuntimeAttemptBody, LlmEvalJudge } from "@deepstrike/wasm"
 
-// Single pass — always passes
-const harness = new SinglePassHarness(runner)
-const outcome = await harness.run({ goal: "Write a haiku" })
-console.log(outcome.result)
-
-// Eval loop — LLM-judges the output; retries up to 3 times
-const loop = new HarnessLoop(runner, evalProvider, { maxAttempts: 3 })
-for await (const event of loop.runStreaming({
+const loop = new AttemptLoop({
+  body: new RuntimeAttemptBody(runner),
+  judge: new LlmEvalJudge(evalProvider),
+  stop: { maxAttempts: 3 },
+})
+for await (const event of loop.stream({
   goal: "Write a haiku",
   criteria: [
     { text: "Exactly 3 lines", required: true },
     { text: "Contains a seasonal reference", required: false },
   ],
 })) {
-  if (event.type === "done") console.log(event.verdict.passed, event.verdict.overallScore)
+  if (event.type === "completed") {
+    console.log(event.outcome.runStatus, event.outcome.outcome, event.outcome.verdict)
+  }
 }
 ```
 
@@ -268,7 +268,8 @@ for await (const event of loop.runStreaming({
 
 ## Signals & interrupts
 
-Delivered signals fold into Slot 3 (`turns[0]`) and are cleared after each render — they do not survive renewal.
+Delivered signals fold into Slot 3 (`turns[0]`) and are consumed only after the correlated
+provider result commits, so retries see the same signal exactly once.
 
 ```typescript
 import { ScheduledPrompt } from "@deepstrike/wasm"

package/dist/harness/index.d.ts

@@ -1,87 +1,153 @@
 import type { RuntimeRunner } from "../runtime/runner.js";
-export interface Criterion {
-    text: string;
-    required: boolean;
-    weight?: number;
-    /** I3.3 (A4): optional stable id from the host's contract layer; threaded to verdictFn. */
-    id?: string;
-    /** I3.3 (A4): host hint — host has a deterministic check for this criterion. */
-    machineCheckable?: boolean;
-}
-export interface CriterionResult {
-    criterion: string;
-    passed: boolean;
-    score: number;
-    feedback: string;
-}
-export interface HarnessRequest {
+import type { Criterion, Verdict } from "../runtime/eval.js";
+import type { LLMProvider } from "../types.js";
+import type { WorkflowNodeSpec } from "../runtime/types/agent.js";
+export type { Criterion, Verdict } from "../runtime/eval.js";
+export interface AttemptRequest {
+    sessionId?: string;
     goal: string;
     criteria?: Criterion[];
     extensions?: Record<string, unknown>;
+    inheritEvents?: Array<{
+        seq: number;
+        event: import("../runtime/session-log.js").SessionEvent;
+    }>;
 }
-export interface HarnessOutcome {
-    result: string;
-    passed: boolean;
-    iterations: number;
-    totalTokens: number;
-    status: string;
-    overallScore?: number;
-    feedback?: string;
-    details?: CriterionResult[];
-}
-export interface Verdict {
-    passed: boolean;
-    overallScore: number;
-    feedback: string;
-    details: CriterionResult[];
-}
-export type HarnessEvent = {
+export interface AttemptBodyContext extends AttemptRequest {
+    sessionId: string;
+    attempt: number;
+    contextInput?: string;
+}
+export type AttemptProgressEvent = {
     type: "token";
     text: string;
 } | {
     type: "tool_call";
     id: string;
     name: string;
+} | {
+    type: "tool_delta";
+    callId: string;
+    delta?: string;
+    chunk?: Record<string, unknown>;
+} | {
+    type: "tool_suspend";
+    callId: string;
+    suspensionId: string;
+    payload?: Record<string, unknown>;
 } | {
     type: "tool_result";
     callId: string;
     content: string;
     isError: boolean;
 } | {
-    type: "supervising";
-} | {
-    type: "revising";
-    verdict: Verdict;
+    type: "workflow_nodes_submitted";
+    nodes: WorkflowNodeSpec[];
 } | {
-    type: "done";
-    verdict: Verdict;
-    iterations: number;
-    totalTokens: number;
-    status: string;
-} | {
-    type: "max_attempts_reached";
+    type: "body_error";
+    message: string;
 };
-export declare class SinglePassHarness {
-    private runner;
+export interface AttemptBodyTerminal {
+    type: "body_done";
+    runStatus: string;
+    result: string;
+    turns: number;
+    totalTokens: number;
+    submittedNodes?: WorkflowNodeSpec[];
+}
+export type AttemptBodyEvent = AttemptProgressEvent | AttemptBodyTerminal;
+export interface AttemptBody {
+    run(context: AttemptBodyContext): AsyncIterable<AttemptBodyEvent>;
+}
+export declare class RuntimeAttemptBody implements AttemptBody {
+    private readonly runner;
     constructor(runner: RuntimeRunner);
-    run(request: HarnessRequest): Promise<HarnessOutcome>;
+    run(context: AttemptBodyContext): AsyncIterable<AttemptBodyEvent>;
 }
-/** I3.2 (A2/A3): host-supplied judgment — see Node `VerdictFn` for the full contract. Mirrors. */
-export type VerdictFn = (ctx: {
+export interface JudgeContext {
     goal: string;
     criteria: Criterion[];
     attempt: number;
     result: string;
-}) => Verdict | undefined | Promise<Verdict | undefined>;
-export interface HarnessLoopOptions {
-    maxAttempts?: number;
-    verdictFn?: VerdictFn;
-}
-export declare class HarnessLoop {
-    private runner;
-    private evalProvider;
-    private maxAttempts;
-    private verdictFn?;
-    constructor(runner: RuntimeRunner, evalProvider: import("../types.js").LLMProvider, options?: HarnessLoopOptions);
-    runStreaming(request: HarnessRequest): AsyncIterable<HarnessEvent>;
+}
+export interface JudgeResult {
+    verdict: Verdict;
+}
+export interface AttemptJudge {
+    judge(context: JudgeContext): Promise<JudgeResult | undefined>;
+}
+export type VerdictFn = (context: JudgeContext) => Verdict | undefined | Promise<Verdict | undefined>;
+export declare class VerdictFnJudge implements AttemptJudge {
+    private readonly verdictFn;
+    constructor(verdictFn: VerdictFn);
+    judge(context: JudgeContext): Promise<JudgeResult | undefined>;
+}
+export declare class LlmEvalJudge implements AttemptJudge {
+    private readonly provider;
+    constructor(provider: LLMProvider);
+    judge(context: JudgeContext): Promise<JudgeResult>;
+}
+export declare class HybridJudge implements AttemptJudge {
+    private readonly primary;
+    private readonly fallback;
+    constructor(primary: AttemptJudge, fallback: AttemptJudge);
+    judge(context: JudgeContext): Promise<JudgeResult | undefined>;
+}
+export interface PreparedAttempt {
+    sessionId: string;
+    goal: string;
+    contextInput?: string;
+}
+export type CarryPolicy = (context: {
+    rootSessionId: string;
+    goal: string;
+    attempt: number;
+    previousVerdict?: Verdict;
+}) => PreparedAttempt | Promise<PreparedAttempt>;
+export declare const continueSession: CarryPolicy;
+export declare const freshWithFeedback: CarryPolicy;
+export declare function freshWithDigest(digest: (verdict: Verdict, attempt: number) => string | Promise<string>): CarryPolicy;
+export interface StopPolicy {
+    maxAttempts: number;
+    maxTotalTokens?: number;
+    stopOnFailedVerdict?: boolean;
+}
+export type AttemptOutcomeKind = "passed" | "failed_judge" | "exhausted" | "run_error";
+export interface AttemptOutcome {
+    outcome: AttemptOutcomeKind;
+    runStatus: string;
+    verdict?: Verdict;
+    result: string;
+    attempts: number;
+    turns: number;
+    totalTokens: number;
+    submittedNodes?: WorkflowNodeSpec[];
+}
+export type AttemptLoopEvent = AttemptProgressEvent | {
+    type: "judging";
+    attempt: number;
+} | {
+    type: "retrying";
+    attempt: number;
+    verdict: Verdict;
+} | {
+    type: "completed";
+    outcome: AttemptOutcome;
+};
+export interface AttemptLoopOptions {
+    body: AttemptBody;
+    judge: AttemptJudge;
+    carry?: CarryPolicy;
+    stop: StopPolicy;
+    onPass?: (context: {
+        outcome: AttemptOutcome;
+        judgeResult: JudgeResult;
+    }) => void | Promise<void>;
+}
+export declare class AttemptLoop {
+    private readonly options;
+    private readonly carry;
+    constructor(options: AttemptLoopOptions);
+    run(request: AttemptRequest): Promise<AttemptOutcome>;
+    stream(request: AttemptRequest): AsyncIterable<AttemptLoopEvent>;
 }

package/dist/harness/index.js

@@ -1,101 +1,230 @@
-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 {
+import { getKernel } from "../runtime/kernel.js";
+export class RuntimeAttemptBody {
     runner;
     constructor(runner) {
         this.runner = runner;
     }
-    async run(request) {
-        return { ...await runOnce(this.runner, request), 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.delta, chunk: delta.chunk };
+            }
+            else if (event.type === "tool_suspend") {
+                const suspended = event;
+                yield { type: "tool_suspend", callId: suspended.callId, suspensionId: suspended.suspensionId, payload: suspended.payload };
+            }
+            else if (event.type === "tool_result") {
+                const tool = event;
+                yield { type: "tool_result", callId: tool.callId, content: tool.content, isError: tool.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;
+            }
+        }
+        yield {
+            type: "body_done",
+            runStatus: done?.status ?? "error",
+            result,
+            turns: done?.iterations ?? 0,
+            totalTokens: done?.totalTokens ?? 0,
+            ...(submittedNodes.length ? { submittedNodes } : {}),
+        };
     }
 }
-export class HarnessLoop {
-    runner;
-    evalProvider;
-    maxAttempts;
+export class VerdictFnJudge {
     verdictFn;
-    constructor(runner, evalProvider, options = {}) {
-        this.runner = runner;
-        this.evalProvider = evalProvider;
-        this.maxAttempts = options.maxAttempts ?? 3;
-        this.verdictFn = options.verdictFn;
+    constructor(verdictFn) {
+        this.verdictFn = verdictFn;
+    }
+    async judge(context) {
+        const verdict = await this.verdictFn(context);
+        return verdict ? { verdict } : undefined;
+    }
+}
+export class LlmEvalJudge {
+    provider;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    async judge(context) {
+        const kernel = await getKernel();
+        const messages = kernel.buildEvalMessages(context.goal, context.criteria, context.result, context.attempt, false);
+        const rendered = {
+            systemText: messages.filter(message => message.role === "system").map(message => message.content).join("\n\n"),
+            turns: messages.filter(message => message.role !== "system"),
+        };
+        let text = "";
+        for await (const event of this.provider.stream(rendered, [], undefined)) {
+            if (event.type === "text_delta")
+                text += event.delta;
+        }
+        if (!text)
+            throw new Error("attempt judge produced no text");
+        const parsed = kernel.parseVerdict(text);
+        return {
+            verdict: {
+                passed: parsed.passed,
+                overallScore: parsed.overallScore,
+                feedback: parsed.feedback,
+                details: (parsed.details ?? []),
+            },
+        };
+    }
+}
+export class HybridJudge {
+    primary;
+    fallback;
+    constructor(primary, fallback) {
+        this.primary = primary;
+        this.fallback = fallback;
+    }
+    async judge(context) {
+        return await this.primary.judge(context) ?? this.fallback.judge(context);
+    }
+}
+export const continueSession = context => ({
+    sessionId: context.rootSessionId,
+    goal: context.goal,
+    ...(context.previousVerdict?.feedback ? { contextInput: context.previousVerdict.feedback } : {}),
+});
+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,
+    });
+}
+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 outcome;
+        for await (const event of this.stream(request)) {
+            if (event.type === "completed")
+                outcome = event.outcome;
+        }
+        if (!outcome)
+            throw new Error("AttemptLoop ended without an outcome");
+        return outcome;
     }
-    async *runStreaming(request) {
-        const kernel = await import("@deepstrike/wasm-kernel");
+    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 = "";
-        const sessionId = crypto.randomUUID();
-        for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
-            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") {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    const tc = evt;
-                    yield { type: "tool_call", id: tc.id, name: tc.name };
-                }
-                else if (evt.type === "tool_result") {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    const tr = evt;
-                    yield { type: "tool_result", callId: tr.callId, content: tr.content, isError: tr.isError };
-                }
-                else if (evt.type === "done") {
-                    const d = evt;
-                    lastIterations = d.iterations;
-                    lastTotalTokens = d.totalTokens;
-                    lastStatus = d.status;
+        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
+                    yield event;
             }
-            yield { type: "supervising" };
-            // I3.2 (A2/A3): host-supplied verdictFn short-circuits the LLM eval. Undefined ⇒ defer.
-            let verdict;
-            if (this.verdictFn) {
-                verdict = await this.verdictFn({ goal: request.goal, criteria, attempt, result: lastResult });
+            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 ? { submittedNodes } : {}),
+            };
+            if (isRunError(terminal.runStatus)) {
+                yield { type: "completed", outcome: { outcome: "run_error", ...base } };
+                return;
             }
-            if (!verdict) {
-                // #6 (0.5.0): eval/verdict compute is the kernel's stateless free functions (was EvalPipeline).
-                const evalMsgs = kernel.buildEvalMessages(request.goal, criteria, lastResult, attempt, true);
-                let evalText = "";
-                const evalContext = {
-                    systemText: "",
-                    turns: evalMsgs,
-                };
-                for await (const evt of this.evalProvider.stream(evalContext, [], undefined)) {
-                    if (evt.type === "text_delta")
-                        evalText += evt.delta;
-                }
-                const parsed = kernel.parseVerdict(evalText);
-                verdict = {
-                    passed: parsed.passed,
-                    overallScore: parsed.overallScore,
-                    feedback: parsed.feedback,
-                    details: (parsed.details ?? []),
-                };
+            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");
+            if (judged.verdict.passed) {
+                const outcome = { outcome: "passed", ...base, verdict: judged.verdict };
+                await this.options.onPass?.({ outcome, judgeResult: judged });
+                yield { type: "completed", outcome };
+                return;
             }
-            if (verdict.passed) {
-                yield { type: "done", verdict, iterations: lastIterations, totalTokens: lastTotalTokens, status: lastStatus };
+            previousVerdict = judged.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: judged.verdict,
+                    },
+                };
                 return;
             }
-            yield { type: "revising", verdict };
-            currentGoal = `${request.goal}\n\n[Attempt ${attempt} feedback: ${verdict.feedback}]`;
-            lastResult = "";
+            yield { type: "retrying", attempt, verdict: judged.verdict };
         }
-        yield { type: "max_attempts_reached" };
     }
 }
+function isRunError(status) {
+    return ["error", "invalid_arg", "user_abort"].includes(status.toLocaleLowerCase());
+}

package/dist/index.d.ts

@@ -1,10 +1,11 @@
-export { RuntimeRunner, collectText, runAgent, runFanout, InMemorySessionLog, LocalExecutionPlane, DEFAULT_NATIVE_ATTENTION_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, DEFAULT_SANDBOX_POLICY, assertNativeProfile, osProfile, validateDeclarativePolicy, ReplayProvider, extractRecordedMessages, judge, buildEvalMessages, parseVerdict, verdictOutputSchema, } from "./runtime/index.js";
+export { RuntimeRunner, collectText, runAgent, runFanout, InMemorySessionLog, LocalExecutionPlane, DEFAULT_NATIVE_SIGNAL_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, DEFAULT_SANDBOX_POLICY, assertNativeProfile, osProfile, validateDeclarativePolicy, ReplayProvider, extractRecordedMessages, judge, buildEvalMessages, parseVerdict, verdictOutputSchema, } from "./runtime/index.js";
+export * from "./runtime/kernel-transaction-log.js";
 export type { ReplayProviderOpts, Criterion, Verdict, VerdictDetail, JudgeArgs, } from "./runtime/index.js";
-export type { NativeOsProfile, OsProfileId, MemoryPolicy, MemoryWriteRateLimit, ResourceQuota, RuntimeOptions, SchedulerBudget, SessionEvent, SessionLog, RunContext, ExecutionPlane, } from "./runtime/index.js";
+export type { NativeOsProfile, OsProfileId, MemoryPolicy, MemoryWriteRateLimit, ResourceQuota, RuntimeOptions, PromptBudget, SchedulerPolicy, SignalPolicy, SessionEvent, SessionLog, KernelTransactionEntry, RunContext, ExecutionPlane, } from "./runtime/index.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
 export type { SubAgentRunContext } from "./runtime/sub-agent-orchestrator.js";
-export type { AgentCapabilityFilter, AgentIdentity, AgentIsolation, AgentRunSpec, AgentProcessChangedObservation, ContextInheritance, KernelAgentRole, LoopResult, MilestoneCheckResult, MilestoneContract, MilestonePhase, MilestonePolicy, SubAgentResult, TerminationReason, WorkflowSpec, WorkflowNodeSpec, WorkflowTaskSpec, WorkflowSpawnInfo, } from "./runtime/types/agent.js";
+export type { AgentCapabilityFilter, AgentIdentity, AgentIsolation, AgentRunSpec, AgentProcessChangedObservation, ContextInheritance, KernelAgentRole, LoopResult, MilestoneCheckResult, MilestoneContract, MilestonePhase, MilestonePolicy, SubAgentResult, TerminationReason, WorkflowSpec, WorkflowNodeSpec, WorkflowDependencyPolicy, WorkflowNodeStatus, WorkflowNodeOutcome, WorkflowOutcome, WorkflowTaskSpec, WorkflowSpawnInfo, } from "./runtime/types/agent.js";
 export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesToKernel, submitWorkflowToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, genEval, verifyRules } from "./runtime/types/agent.js";
 export { loopInstruction, classifyInstruction, judgeGoal, extractLoopContinue, extractClassifyBranch, extractJudgeWinner, } from "./runtime/workflow-control-flow.js";
 export { Governance } from "./governance.js";
@@ -17,10 +18,12 @@ export { safeTool, ok, fail, ToolError, formatToolError } from "./tools/errors.j
 export type { ToolEnvelope, ToolEnvelopeOk, ToolEnvelopeFail } from "./tools/errors.js";
 export { WorkingMemory } from "./memory/index.js";
 export { InMemoryDreamStore } from "./memory/in-memory-store.js";
-export type { DreamStore, DreamResult, SessionStore, SessionData, SessionMessage, MemoryEntry, CurationResult, CurationStats, } from "./memory/index.js";
+export type { InMemoryDreamStoreOptions } from "./memory/in-memory-store.js";
+export { memoryRetentionScore } from "./memory/retention.js";
+export type { DreamStore, SessionStore, SessionData, SessionMessage, MemoryRecord, MemoryRecall, MemoryRecallLifecycle, MemoryQuery, MemoryScope, MemoryProvenance, MemoryKind, MemoryAuthor, MemoryTrustLevel, } from "./memory/index.js";
 export type { KnowledgeSource } from "./knowledge/index.js";
-export { SinglePassHarness, HarnessLoop } from "./harness/index.js";
-export type { HarnessRequest, HarnessOutcome, HarnessLoopOptions, CriterionResult, HarnessEvent, VerdictFn } from "./harness/index.js";
+export { AttemptLoop, RuntimeAttemptBody, VerdictFnJudge, LlmEvalJudge, HybridJudge, continueSession, freshWithFeedback, freshWithDigest, } from "./harness/index.js";
+export type { AttemptBody, AttemptBodyContext, AttemptBodyEvent, AttemptBodyTerminal, AttemptJudge, AttemptLoopEvent, AttemptLoopOptions, AttemptOutcome, AttemptOutcomeKind, AttemptProgressEvent, AttemptRequest, CarryPolicy, JudgeContext, JudgeResult, PreparedAttempt, StopPolicy, VerdictFn, } from "./harness/index.js";
 export { ScheduledPrompt } from "./signals/index.js";
 export type { RuntimeSignal, SignalSource } from "./signals/index.js";
 export { PermissionManager, PermissionMode } from "./safety/index.js";

package/dist/index.js

@@ -1,4 +1,5 @@
-export { RuntimeRunner, collectText, runAgent, runFanout, InMemorySessionLog, LocalExecutionPlane, DEFAULT_NATIVE_ATTENTION_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, DEFAULT_SANDBOX_POLICY, assertNativeProfile, osProfile, validateDeclarativePolicy, ReplayProvider, extractRecordedMessages, judge, buildEvalMessages, parseVerdict, verdictOutputSchema, } from "./runtime/index.js";
+export { RuntimeRunner, collectText, runAgent, runFanout, InMemorySessionLog, LocalExecutionPlane, DEFAULT_NATIVE_SIGNAL_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, DEFAULT_SANDBOX_POLICY, assertNativeProfile, osProfile, validateDeclarativePolicy, ReplayProvider, extractRecordedMessages, judge, buildEvalMessages, parseVerdict, verdictOutputSchema, } from "./runtime/index.js";
+export * from "./runtime/kernel-transaction-log.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
 export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesToKernel, submitWorkflowToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, genEval, verifyRules } from "./runtime/types/agent.js";
@@ -10,6 +11,7 @@ export { tool, executeTools } from "./tools/index.js";
 export { safeTool, ok, fail, ToolError, formatToolError } from "./tools/errors.js";
 export { WorkingMemory } from "./memory/index.js";
 export { InMemoryDreamStore } from "./memory/in-memory-store.js";
-export { SinglePassHarness, HarnessLoop } from "./harness/index.js";
+export { memoryRetentionScore } from "./memory/retention.js";
+export { AttemptLoop, RuntimeAttemptBody, VerdictFnJudge, LlmEvalJudge, HybridJudge, continueSession, freshWithFeedback, freshWithDigest, } from "./harness/index.js";
 export { ScheduledPrompt } from "./signals/index.js";
 export { PermissionManager, PermissionMode } from "./safety/index.js";

package/dist/memory/extraction.d.ts

@@ -0,0 +1,4 @@
+import type { LLMProvider } from "../types.js";
+import type { MemoryRecord, MemoryScope, SessionData } from "./index.js";
+export declare function extractSessionMemories(provider: LLMProvider, session: SessionData, scope: MemoryScope, systemPrompt?: string): Promise<MemoryRecord[]>;
+export declare function parseExtractedMemories(output: string, session: SessionData, scope: MemoryScope): MemoryRecord[];