@deepstrike/sdk 0.2.2 → 0.2.4

package/README.md

@@ -118,6 +118,33 @@ const provider = createProvider({
 
 ---
 
+## Context model (four slots)
+
+The kernel renders context as four LLM API slots — only **history** is compressed.
+
+| Slot | Source | Role |
+|------|--------|------|
+| `systemStable` | system partition | Identity, rules — never changes within a run |
+| `systemKnowledge` | knowledge partition | Preloaded memory, skill defs — low frequency |
+| `turns[0]` | `task_state` + signals | Goal, plan, progress, compression log, runtime signals |
+| `turns[1..N]` | history | Conversation transcript |
+
+```typescript
+const runner = new RuntimeRunner({
+  // ...
+  initialMemory: ["User prefers chartreuse."],  // → Slot 2 (systemKnowledge)
+  systemPrompt: "You are a helpful assistant.", // → Slot 1 (systemStable)
+})
+```
+
+- `memory(query)` / `knowledge(query)` meta-tool results → **history** (tool results)
+- External signals → **Slot 3** via `push_signal()`, cleared after each render
+- Anthropic: Slots 1–2 get separate `cache_control` breakpoints
+
+Full reference: [docs/context-partition-compression.md](../docs/context-partition-compression.md)
+
+---
+
 ## Runtime options
 
 ```typescript
@@ -135,6 +162,11 @@ const runner = new RuntimeRunner({
   signalSource: rx,           // SignalSource for external signals
   dreamStore: myStore,        // DreamStore for long-term memory
   agentId: "my-agent",        // required with dreamStore for memory meta-tool
+  initialMemory: ["..."],     // preloaded blocks → Slot 2 (systemKnowledge)
+  subAgentHarness: {          // optional: sub-agents run through HarnessLoop
+    evalProvider,
+    maxAttempts: 3,
+  },
   governance: gov,            // Governance pipeline instance
 })
 ```
@@ -182,7 +214,9 @@ effort: 1
 
 ## Knowledge
 
-Implement `KnowledgeSource` to connect any RAG system. The kernel injects a `knowledge` meta-tool that the LLM calls on demand.
+Implement `KnowledgeSource` to connect any RAG system. The kernel injects a `knowledge` meta-tool that the LLM calls on demand. **Runtime retrieval results land in history** as tool results.
+
+To inject durable knowledge at startup (Slot 2, cacheable on Anthropic), use `initialMemory` or kernel `add_knowledge_message`.
 
 ```typescript
 const runner = new RuntimeRunner({
@@ -202,7 +236,9 @@ const runner = new RuntimeRunner({
 
 ## Memory
 
-### WorkingMemory (in-session scratch pad)
+### WorkingMemory (SDK-side scratch pad)
+
+`WorkingMemory` is an SDK helper — not the kernel `working` partition (removed). Kernel task state lives in `task_state` and renders into Slot 3 (`turns[0]`).
 
 ```typescript
 import { WorkingMemory } from "@deepstrike/sdk"
@@ -233,7 +269,8 @@ const runner = new RuntimeRunner({
   agentId: "my-agent",  // enables `memory` meta-tool
 })
 
-// In-session: LLM calls memory(query) → DreamStore.search()
+// In-session: LLM calls memory(query) → DreamStore.search() → history tool result
+// Preload:    initialMemory → Slot 2 (systemKnowledge)
 // Post-session: trigger memory consolidation
 const result = await runner.dream("my-agent", Date.now())
 ```
@@ -318,6 +355,14 @@ const harness = new EvalLoopHarness(runner, {
 
 // 3. HarnessLoop — LLM-as-judge with feedback injection + skill extraction
 const loop = new HarnessLoop(runner, evalProvider, { maxAttempts: 3, skillDir: "./skills" })
+
+// Sub-agents: pass subAgentHarness on RuntimeRunner to auto-evaluate spawned children
+const runnerWithHarness = new RuntimeRunner({
+  provider,
+  executionPlane: plane,
+  sessionLog,
+  subAgentHarness: { evalProvider, maxAttempts: 3 },
+})
 for await (const event of loop.runStreaming({
   goal: "Write a haiku",
   criteria: [{ text: "Must be 3 lines", required: true }],

package/dist/providers/anthropic.d.ts

@@ -24,6 +24,7 @@ export declare class AnthropicProvider implements LLMProvider {
     private hasBetas;
     private createMessage;
     private streamMessage;
+    private buildSystem;
     private buildMessages;
     private rememberNativeBlocks;
 }

package/dist/providers/anthropic.js

@@ -44,16 +44,17 @@ export class AnthropicProvider {
         }
     }
     buildTools(tools) {
-        return tools.map(t => ({
+        return tools.map((t, i) => ({
             name: t.name,
             description: t.description,
             input_schema: JSON.parse(t.parameters),
+            ...(i === tools.length - 1 ? { cache_control: { type: "ephemeral" } } : {}),
         }));
     }
     async complete(context, tools, extensions) {
         if (this.circuit.isOpen())
             throw new Error("Circuit breaker open");
-        const system = context.systemText || undefined;
+        const system = this.buildSystem(context);
         const msgs = this.buildMessages(context);
         const requestExtensions = this.requestExtensions(extensions);
         let lastErr;
@@ -79,7 +80,7 @@ export class AnthropicProvider {
                             toolCalls.push(tc);
                     }
                 }
-                const message = { role: "assistant", content, tokenCount: resp.usage.input_tokens + resp.usage.output_tokens, toolCalls };
+                const message = { role: "assistant", content, tokenCount: resp.usage.output_tokens, toolCalls };
                 this.rememberNativeBlocks(message, resp.content);
                 return message;
             }
@@ -93,7 +94,7 @@ export class AnthropicProvider {
         throw lastErr;
     }
     async *stream(context, tools, extensions) {
-        const system = context.systemText || undefined;
+        const system = this.buildSystem(context);
         const msgs = this.buildMessages(context);
         const requestExtensions = this.requestExtensions(extensions);
         const toolBlocks = {};
@@ -113,8 +114,10 @@ export class AnthropicProvider {
             if (evt.type === "message_start" || evt.type === "message_delta") {
                 const usage = evt.usage ?? evt.message?.usage;
                 if (usage) {
-                    totalTokens = usage.input_tokens + (usage.output_tokens ?? 0);
-                    yield { type: "usage", totalTokens };
+                    const inputTokens = usage.input_tokens ?? 0;
+                    const outputTokens = usage.output_tokens ?? 0;
+                    totalTokens = inputTokens + outputTokens;
+                    yield { type: "usage", totalTokens, inputTokens, outputTokens };
                 }
             }
             else if (evt.type === "content_block_start") {
@@ -175,8 +178,25 @@ export class AnthropicProvider {
             ? this.client.beta.messages.stream(params)
             : this.client.messages.stream(params));
     }
+    buildSystem(context) {
+        if (!context.systemStable && !context.systemKnowledge) {
+            return context.systemText || undefined;
+        }
+        const blocks = [];
+        if (context.systemStable) {
+            blocks.push({ type: "text", text: context.systemStable, cache_control: { type: "ephemeral" } });
+        }
+        if (context.systemKnowledge) {
+            blocks.push({ type: "text", text: context.systemKnowledge, cache_control: { type: "ephemeral" } });
+        }
+        return blocks.length ? blocks : undefined;
+    }
     buildMessages(context) {
-        return toAnthropicMessages(context.turns, message => this.nativeAssistantBlocks.get(assistantReplayKey(message)));
+        const msgs = toAnthropicMessages(context.turns, message => this.nativeAssistantBlocks.get(assistantReplayKey(message)));
+        if (msgs.length === 0) {
+            msgs.push({ role: "user", content: "Proceed." });
+        }
+        return msgs;
     }
     rememberNativeBlocks(message, blocks) {
         if (!blocks.length)

package/dist/providers/base.js

@@ -96,12 +96,14 @@ export function toAnthropicMessages(turns, nativeReplay) {
         if (msg.role === "assistant" && msg.toolCalls?.length) {
             const replay = nativeReplay?.(msg);
             if (replay) {
-                result.push({ role: "assistant", content: replay });
+                result.push({ role: "assistant", content: ensureAssistantToolText(replay) });
                 continue;
             }
             const blocks = [];
             if (msg.content)
                 blocks.push({ type: "text", text: msg.content });
+            else
+                blocks.push({ type: "text", text: "Tool call requested." });
             blocks.push(...msg.toolCalls.map(tc => ({
                 type: "tool_use",
                 id: tc.id,
@@ -115,6 +117,15 @@ export function toAnthropicMessages(turns, nativeReplay) {
     }
     return result;
 }
+function ensureAssistantToolText(blocks) {
+    if (!blocks.some(b => b.type === "tool_use"))
+        return blocks;
+    if (blocks.some(b => b.type === "text" && String(b.text ?? "").trim()))
+        return blocks;
+    if (blocks.some(b => b.type === "thinking"))
+        return blocks;
+    return [{ type: "text", text: "Tool call requested." }, ...blocks];
+}
 // ─── OpenAI-compatible message conversion ────────────────────────────────────
 export function toOpenAIContent(msg) {
     if (!msg.contentParts?.length)

package/dist/providers/deepseek.js

@@ -35,17 +35,27 @@ export class DeepSeekProvider extends OpenAIChatProvider {
         let finalText = "";
         const stream = await this.client.chat.completions.create({
             ...omitExtensionKeys(extensions, [
-                "model", "messages", "tools", "stream", "extra_body", "reasoning_effort",
+                "model", "messages", "tools", "stream", "stream_options", "extra_body", "reasoning_effort",
                 "exposeReasoning", "thinking", "reasoningEffort",
             ]),
             model: this.model,
             messages: msgs,
             ...(tools.length ? { tools: this.chat.buildTools(tools) } : {}),
             stream: true,
+            stream_options: { include_usage: true },
             reasoning_effort: reasoningEffort,
             extra_body: { thinking: { type: thinking } },
         });
+        let totalTokens = 0;
+        let inputTokens = 0;
+        let outputTokens = 0;
         for await (const chunk of stream) {
+            if (chunk.usage) {
+                totalTokens = chunk.usage.total_tokens;
+                inputTokens = chunk.usage.prompt_tokens ?? 0;
+                outputTokens = chunk.usage.completion_tokens ?? 0;
+                continue;
+            }
             const choice = chunk.choices[0];
             if (!choice)
                 continue;
@@ -110,5 +120,7 @@ export class DeepSeekProvider extends OpenAIChatProvider {
             emittedToolCallIndexes.add(idx);
             yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
         }
+        if (totalTokens > 0)
+            yield { type: "usage", totalTokens, inputTokens, outputTokens };
     }
 }

package/dist/providers/gemini.js

@@ -125,7 +125,7 @@ export class GeminiProvider {
                 return {
                     role: "assistant",
                     content,
-                    tokenCount: usage?.totalTokenCount,
+                    tokenCount: usage?.candidatesTokenCount ?? usage?.totalTokenCount,
                     toolCalls,
                 };
             }
@@ -164,8 +164,14 @@ export class GeminiProvider {
             yield { type: "tool_call", id: tc.id, name: tc.name, arguments: tc.args };
         }
         const usage = (await result.response).usageMetadata;
-        if (usage?.totalTokenCount)
-            yield { type: "usage", totalTokens: usage.totalTokenCount };
+        if (usage?.totalTokenCount) {
+            yield {
+                type: "usage",
+                totalTokens: usage.totalTokenCount,
+                inputTokens: usage.promptTokenCount ?? 0,
+                outputTokens: usage.candidatesTokenCount ?? 0,
+            };
+        }
     }
     modelExtensions(extensions) {
         if (!extensions)

package/dist/providers/openai-chat.d.ts

@@ -11,13 +11,7 @@ export declare class OpenAIChatAdapter {
         };
     }[];
     buildMessages(context: RenderedContext): OpenAI.ChatCompletionMessageParam[];
-    normalizeToolCalls(toolCalls?: Array<{
-        id: string;
-        function: {
-            name: string;
-            arguments: string;
-        };
-    }>): Array<{
+    normalizeToolCalls(toolCalls?: OpenAI.ChatCompletionMessageToolCall[]): Array<{
         id: string;
         name: string;
         arguments: string;

package/dist/providers/openai-chat.js

@@ -29,6 +29,7 @@ export class OpenAIChatAdapter {
     }
     normalizeToolCalls(toolCalls = []) {
         return toolCalls
+            .filter((tc) => tc.type === "function")
             .map(tc => normalizeToolCall(tc.id, tc.function.name, tc.function.arguments))
             .filter(Boolean);
     }

package/dist/providers/openai-responses.js

@@ -158,7 +158,7 @@ export class OpenAIResponsesProvider {
                     role: "assistant",
                     content: decoded.content,
                     toolCalls: decoded.toolCalls,
-                    tokenCount: resp.usage?.total_tokens,
+                    tokenCount: resp.usage?.output_tokens ?? resp.usage?.total_tokens,
                 };
             }
             catch (err) {
@@ -223,7 +223,12 @@ export class OpenAIResponsesProvider {
                 runState.previousResponseId = evt.response.id;
                 runState.coveredMessageCount = context.turns.length + 1;
                 if (evt.response.usage?.total_tokens) {
-                    yield { type: "usage", totalTokens: evt.response.usage.total_tokens };
+                    yield {
+                        type: "usage",
+                        totalTokens: evt.response.usage.total_tokens,
+                        ...(evt.response.usage.input_tokens ? { inputTokens: evt.response.usage.input_tokens } : {}),
+                        ...(evt.response.usage.output_tokens ? { outputTokens: evt.response.usage.output_tokens } : {}),
+                    };
                 }
             }
         }

package/dist/providers/openai.js

@@ -69,7 +69,7 @@ export class OpenAIChatProvider {
                 this.circuit.recordSuccess();
                 const choice = resp.choices[0].message;
                 const toolCalls = this.chat.normalizeToolCalls(choice.tool_calls ?? []);
-                return { role: "assistant", content: choice.content ?? "", tokenCount: resp.usage?.total_tokens, toolCalls };
+                return { role: "assistant", content: choice.content ?? "", tokenCount: resp.usage?.completion_tokens ?? resp.usage?.total_tokens, toolCalls };
             }
             catch (err) {
                 lastErr = err;
@@ -96,9 +96,13 @@ export class OpenAIChatProvider {
             stream_options: { include_usage: true },
         });
         let totalTokens = 0;
+        let inputTokens = 0;
+        let outputTokens = 0;
         for await (const chunk of stream) {
             if (chunk.usage) {
                 totalTokens = chunk.usage.total_tokens;
+                inputTokens = chunk.usage.prompt_tokens ?? 0;
+                outputTokens = chunk.usage.completion_tokens ?? 0;
                 continue;
             }
             const choice = chunk.choices[0];
@@ -183,7 +187,7 @@ export class OpenAIChatProvider {
             yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
         }
         if (totalTokens > 0)
-            yield { type: "usage", totalTokens };
+            yield { type: "usage", totalTokens, inputTokens, outputTokens };
     }
     requestExtensions(extensions) {
         return omitExtensionKeys(extensions, ["model", "messages", "tools", "stream", "stream_options"]);

package/dist/providers/qwen.js

@@ -65,7 +65,7 @@ export class QwenProvider {
                 this.circuit.recordSuccess();
                 const choice = resp.choices[0].message;
                 const toolCalls = this.chat.normalizeToolCalls(choice.tool_calls ?? []);
-                return { role: "assistant", content: choice.content ?? "", tokenCount: resp.usage?.total_tokens, toolCalls };
+                return { role: "assistant", content: choice.content ?? "", tokenCount: resp.usage?.completion_tokens ?? resp.usage?.total_tokens, toolCalls };
             }
             catch (err) {
                 lastErr = err;
@@ -93,9 +93,13 @@ export class QwenProvider {
             ...(extraBody ? { extra_body: extraBody } : {}),
         });
         let totalTokens = 0;
+        let inputTokens = 0;
+        let outputTokens = 0;
         for await (const chunk of stream) {
             if (chunk.usage) {
                 totalTokens = chunk.usage.total_tokens;
+                inputTokens = chunk.usage.prompt_tokens ?? 0;
+                outputTokens = chunk.usage.completion_tokens ?? 0;
                 continue;
             }
             const choice = chunk.choices[0];
@@ -162,7 +166,7 @@ export class QwenProvider {
             yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
         }
         if (totalTokens > 0)
-            yield { type: "usage", totalTokens };
+            yield { type: "usage", totalTokens, inputTokens, outputTokens };
     }
     thinkingExtraBody(extensions) {
         const enableThinking = Boolean(extensions?.enableThinking ?? extensions?.enable_thinking);

package/dist/runtime/kernel-step.js

@@ -194,6 +194,8 @@ function kernelMessageToSdk(raw) {
 function renderedContextToSdk(raw) {
     return {
         systemText: String(raw.system_text ?? raw.systemText ?? ""),
+        systemStable: String(raw.system_stable ?? raw.systemStable ?? ""),
+        systemKnowledge: String(raw.system_knowledge ?? raw.systemKnowledge ?? ""),
         turns: (raw.turns ?? []).map(kernelMessageToSdk),
     };
 }

package/dist/runtime/runner.d.ts

@@ -1,4 +1,4 @@
-import type { LLMProvider, Message, ToolSchema, StreamEvent, ToolSuspendEvent } from "../types.js";
+import type { LLMProvider, Message, ToolSchema, StreamEvent, ToolSuspendEvent, AsyncSummarizer } from "../types.js";
 import type { DreamStore } from "../memory/protocols.js";
 import type { KnowledgeSource } from "../knowledge/source.js";
 import type { SignalSource } from "../signals/types.js";
@@ -48,8 +48,24 @@ export interface RuntimeOptions {
     milestoneContract?: MilestoneContract;
     /** Custom sub-agent host driver; defaults to SubAgentOrchestrator. */
     subAgentOrchestrator?: SubAgentOrchestrator;
+    /**
+     * When set, sub-agents run through a HarnessLoop with this config.
+     * The eval provider evaluates the sub-agent's output against the criteria
+     * from the AgentRunSpec, retrying up to maxAttempts times.
+     */
+    subAgentHarness?: {
+        evalProvider: LLMProvider;
+        maxAttempts?: number;
+    };
     /** Optional system prompt injected into the dream synthesis call. */
     dreamSystemPrompt?: string;
+    /**
+     * Optional async LLM summarizer. When provided, a background call is fired
+     * after each compression event to produce a richer semantic summary.
+     * The result is written back to SessionLog as `summary_upgraded` and used
+     * on the next wake() in place of the rule-based summary.
+     */
+    asyncSummarizer?: AsyncSummarizer;
 }
 export declare class RuntimeRunner {
     private readonly opts;
@@ -69,8 +85,8 @@ export declare class RuntimeRunner {
     mountMarker(kind: string, id: string, description: string): void;
     /** Unmount a capability by kind + id from the active run. No-op if not running. */
     unmountCapability(kind: string, id: string): void;
-    /** Push a large artifact into the kernel artifacts partition (not inlined in history). */
-    pushArtifact(message: Message, tokens?: number): void;
+    /** Push content into the Knowledge slot (memory retrievals, skill definitions, artifacts). */
+    pushKnowledge(message: Message, tokens?: number): void;
     /**
      * Spawn an isolated sub-agent via the kernel, run it on the host, and feed the result back.
      * Requires an active parent run (`run()` / `wake()` in progress or paused at milestone).
@@ -92,6 +108,7 @@ export declare class RuntimeRunner {
     dream(agentId: string, nowMs?: number): AsyncIterable<StreamEvent>;
     private execute;
     private appendObservations;
+    private upgradeCompressedSummary;
 }
 export declare function replayMessages(events: Array<{
     seq: number;

package/dist/runtime/runner.js

@@ -43,14 +43,14 @@ export class RuntimeRunner {
             return;
         kernelApply(this.activeKernel, this.pendingObservations, capabilityCommandUnmount(kind, id));
     }
-    /** Push a large artifact into the kernel artifacts partition (not inlined in history). */
-    pushArtifact(message, tokens) {
+    /** Push content into the Knowledge slot (memory retrievals, skill definitions, artifacts). */
+    pushKnowledge(message, tokens) {
         if (!this.activeKernel)
             return;
         kernelApply(this.activeKernel, this.pendingObservations, {
-            kind: "push_artifact",
-            message: messageToKernelMessage(message),
-            ...(tokens !== undefined ? { tokens } : {}),
+            kind: "add_knowledge_message",
+            content: message.content ?? "",
+            tokens: tokens ?? Math.max(1, Math.ceil((message.content?.length ?? 0) / 4)),
         });
     }
     /**
@@ -89,6 +89,7 @@ export class RuntimeRunner {
             spec,
             manifest,
             sessionLog: this.opts.sessionLog,
+            ...(this.opts.subAgentHarness ? { harness: this.opts.subAgentHarness } : {}),
         });
         kernelApply(runtime, this.pendingObservations, {
             kind: "sub_agent_completed",
@@ -238,7 +239,7 @@ export class RuntimeRunner {
         if (this.opts.initialMemory) {
             for (const mem of this.opts.initialMemory) {
                 kernelApply(runtime, this.pendingObservations, {
-                    kind: "add_memory_message",
+                    kind: "add_knowledge_message",
                     content: mem,
                     tokens: Math.max(1, Math.ceil(mem.length / 4)),
                 });
@@ -346,11 +347,16 @@ export class RuntimeRunner {
                 const context = action.context;
                 const tools = action.tools;
                 let turnTokens = 0;
+                let turnInputTokens = 0;
+                let turnOutputTokens = 0;
                 let shouldRetry = false;
                 try {
                     for await (const evt of this.opts.provider.stream(context, tools, Object.keys(ext).length ? ext : undefined, providerState)) {
                         if (evt.type === "usage") {
-                            turnTokens = evt.totalTokens;
+                            const usageEvt = evt;
+                            turnTokens = usageEvt.totalTokens;
+                            turnInputTokens = usageEvt.inputTokens ?? 0;
+                            turnOutputTokens = usageEvt.outputTokens ?? 0;
                             continue;
                         }
                         yield evt;
@@ -390,17 +396,19 @@ export class RuntimeRunner {
                     role: "assistant",
                     content: finalText,
                     toolCalls: finalToolCalls,
-                    tokenCount: turnTokens || undefined,
+                    tokenCount: turnOutputTokens || turnTokens || undefined,
                 };
                 action = kernelAction(runtime, this.pendingObservations, {
                     kind: "provider_result",
                     message: messageToKernelMessage(assistantMessage),
+                    ...(turnInputTokens > 0 ? { observed_input_tokens: turnInputTokens } : {}),
+                    ...(turnOutputTokens > 0 ? { observed_output_tokens: turnOutputTokens } : {}),
                 });
                 const providerReplay = peekProviderReplay(this.opts.provider, finalText, finalToolCalls);
                 await this.opts.sessionLog.append(sessionId, buildLlmCompletedEvent({
                     turn: runtime.turn(),
                     content: finalText,
-                    tokenCount: turnTokens || undefined,
+                    tokenCount: turnOutputTokens || turnTokens || undefined,
                     toolCalls: finalToolCalls,
                     providerReplay,
                 }));
@@ -616,6 +624,9 @@ export class RuntimeRunner {
                     preserved_refs: preservedRefs,
                 });
                 nextArchiveStart = compressedSeq + 1;
+                if (this.opts.asyncSummarizer && archived && archived.length > 0) {
+                    void this.upgradeCompressedSummary(sessionId, compressedSeq, archived, compressionAction(obs.action) ?? "auto_compact");
+                }
             }
             else if (obs.kind === "rollbacked") {
                 await this.opts.sessionLog.append(sessionId, {
@@ -687,6 +698,19 @@ export class RuntimeRunner {
         }
         return nextArchiveStart;
     }
+    async upgradeCompressedSummary(sessionId, compressedSeq, archived, action) {
+        try {
+            const summary = await this.opts.asyncSummarizer.summarize(archived, action);
+            await this.opts.sessionLog.append(sessionId, {
+                kind: "summary_upgraded",
+                compressed_seq: compressedSeq,
+                summary,
+            });
+        }
+        catch {
+            // non-fatal: rule-based summary stays in place
+        }
+    }
 }
 function isMidRun(events) {
     return events.length > 0 && !events.some(e => e.event.kind === "run_terminal");
@@ -701,8 +725,14 @@ function compressionAction(action) {
     return undefined;
 }
 export function replayMessages(events, maxBytes) {
-    const messages = [];
+    // Build upgraded-summary index: compressed_seq -> upgraded summary
+    const upgradedSummaries = new Map();
     for (const { event: e } of events) {
+        if (e.kind === "summary_upgraded")
+            upgradedSummaries.set(e.compressed_seq, e.summary);
+    }
+    const messages = [];
+    for (const { seq, event: e } of events) {
         if (e.kind === "run_started") {
             const userText = e.criteria.length
                 ? `${e.goal}\n\nCriteria:\n${e.criteria.map((c, i) => `${i + 1}. ${c}`).join("\n")}`
@@ -715,8 +745,9 @@ export function replayMessages(events, maxBytes) {
             });
         }
         else if (e.kind === "compressed") {
-            if (e.summary) {
-                const systemText = `[Compressed context: turn ${e.turn}]\n${e.summary}`;
+            const summary = upgradedSummaries.get(seq) ?? e.summary;
+            if (summary) {
+                const systemText = `[Compressed context: turn ${e.turn}]\n${summary}`;
                 messages.push({
                     role: "system",
                     content: systemText,
@@ -754,8 +785,14 @@ export function replayMessages(events, maxBytes) {
     return messages;
 }
 export async function replayMessagesAsync(events, maxBytes, loadArchive) {
-    const messages = [];
+    // Build upgraded-summary index: compressed_seq -> upgraded summary
+    const upgradedSummaries = new Map();
     for (const { event: e } of events) {
+        if (e.kind === "summary_upgraded")
+            upgradedSummaries.set(e.compressed_seq, e.summary);
+    }
+    const messages = [];
+    for (const { seq, event: e } of events) {
         if (e.kind === "run_started") {
             const userText = e.criteria.length
                 ? `${e.goal}\n\nCriteria:\n${e.criteria.map((c, i) => `${i + 1}. ${c}`).join("\n")}`
@@ -787,8 +824,9 @@ export async function replayMessagesAsync(events, maxBytes, loadArchive) {
                 }
             }
             if (!loadedSuccessfully) {
-                if (e.summary) {
-                    const systemText = `[Compressed context: turn ${e.turn}]\n${e.summary}`;
+                const summary = upgradedSummaries.get(seq) ?? e.summary;
+                if (summary) {
+                    const systemText = `[Compressed context: turn ${e.turn}]\n${summary}`;
                     messages.push({
                         role: "system",
                         content: systemText,

package/dist/runtime/session-log.d.ts

@@ -127,6 +127,10 @@ export type SessionEvent = {
     reason: string;
     turns_used: number;
     total_tokens: number;
+} | {
+    kind: "summary_upgraded";
+    compressed_seq: number;
+    summary: string;
 };
 export interface SessionLog {
     append(sessionId: string, event: SessionEvent): Promise<number>;

package/dist/runtime/sub-agent-orchestrator.d.ts

@@ -8,6 +8,10 @@ export interface SubAgentRunContext {
     spec: AgentRunSpec;
     manifest: AgentSpawnedObservation;
     sessionLog: SessionLog;
+    harness?: {
+        evalProvider: import("../types.js").LLMProvider;
+        maxAttempts?: number;
+    };
 }
 /** Host-side driver for kernel-isolated sub-agent runs. */
 export declare class SubAgentOrchestrator {

package/dist/runtime/sub-agent-orchestrator.js

@@ -46,6 +46,36 @@ export class SubAgentOrchestrator {
         });
     }
     async run(ctx) {
+        if (ctx.harness) {
+            const { RuntimeRunner } = await import("./runner.js");
+            const { HarnessLoop } = await import("../harness/harness.js");
+            const permitted = new Set(ctx.manifest.permitted_capability_ids ?? []);
+            const filteredPlane = new FilteredExecutionPlane(ctx.parentOpts.executionPlane, permitted);
+            const childRunner = new RuntimeRunner({
+                ...ctx.parentOpts,
+                executionPlane: filteredPlane,
+                agentId: ctx.spec.identity.agentId,
+                sessionLog: ctx.sessionLog,
+            });
+            const loop = new HarnessLoop(childRunner, ctx.harness.evalProvider, {
+                maxAttempts: ctx.harness.maxAttempts ?? 3,
+            });
+            const outcome = await loop.run({
+                goal: ctx.spec.goal,
+                criteria: (ctx.spec.milestones?.phases.flatMap(p => p.criteria) ?? [])
+                    .filter((t) => typeof t === "string")
+                    .map(text => ({ text, required: true })),
+            });
+            return {
+                agentId: ctx.spec.identity.agentId,
+                result: {
+                    termination: outcome.passed ? "completed" : "error",
+                    turnsUsed: outcome.iterations,
+                    totalTokensUsed: outcome.totalTokens,
+                    ...(outcome.result ? { finalMessage: { role: "assistant", content: outcome.result, toolCalls: [] } } : {}),
+                },
+            };
+        }
         let done;
         let finalText = "";
         for await (const evt of this.stream(ctx)) {

package/dist/types.d.ts

@@ -180,12 +180,13 @@ export interface ProviderReplay {
 }
 /** Structured render output produced by the kernel for each LLM call. */
 export interface RenderedContext {
-    /** Combined system text: system partition + dashboard (when non-empty).
-     *  Anthropic → `system` param · OpenAI → messages[0] system role ·
-     *  Gemini → `systemInstruction`. */
+    /** Identity + Knowledge combined — for providers with a single system slot (OpenAI). */
     systemText: string;
-    /** Strictly alternating user / assistant / tool turns.
-     *  Working-partition signals are already folded into the first user turn. */
+    /** Identity only (system partition). Anthropic system[0] with cache_control. */
+    systemStable?: string;
+    /** Knowledge (memory retrievals, skill definitions, artifacts). Anthropic system[1] with cache_control. */
+    systemKnowledge?: string;
+    /** Turns: [0] = State (task_state + signals), [1..N] = History. */
     turns: Message[];
 }
 /**
@@ -213,6 +214,13 @@ export interface LLMProvider {
     complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState): AsyncIterable<StreamEvent>;
 }
+/**
+ * Optional async summarizer called after context compression.
+ * Produces a richer LLM-generated summary that replaces the rule-based one on next wake.
+ */
+export interface AsyncSummarizer {
+    summarize(archived: Message[], action: string): Promise<string>;
+}
 export interface TaskUpdate {
     plan?: string[];
     currentStep?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/sdk",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "DeepStrike Node.js SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -12,14 +12,17 @@
   "scripts": {
     "build": "tsc",
     "test": "node --experimental-vm-modules node_modules/.bin/jest",
+    "test:e2e": "node --experimental-vm-modules node_modules/.bin/jest --testPathPattern e2e/run --testTimeout 300000",
+    "test:e2e:k": "node --experimental-vm-modules node_modules/.bin/jest --testPathPattern e2e/run --testTimeout 300000",
     "test:local-core": "cd ../crates/deepstrike-node && napi build --platform && cd ../../node && npm test",
-    "smoke:providers": "node ../scripts/smoke-node-provider-loops.mjs"
+    "smoke:providers": "node ../scripts/smoke-node-provider-loops.mjs",
+    "e2e": "node ../scripts/run-e2e.mjs"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.39.0",
-    "@deepstrike/core": "0.2.2",
+    "@anthropic-ai/sdk": "^0.99.0",
+    "@deepstrike/core": "0.2.4",
     "@google/generative-ai": "^0.24.1",
-    "openai": "^4.77.0"
+    "openai": "^5.23.2"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",