@deepstrike/sdk 0.1.12 → 0.1.14

package/README.md

@@ -1,6 +1,6 @@
 # DeepStrike Node.js SDK
 
-Agent framework built on a Rust kernel. The kernel handles loop control, context compression, skill routing, governance, signal prioritization — the SDK handles all I/O.
+Runtime framework built on a Rust kernel. The kernel handles loop control, context compression, skill routing, governance, signal prioritization — the SDK handles all I/O.
 
 ## Install
 
@@ -33,7 +33,14 @@ The correct platform package is selected and installed automatically via `option
 ## Quick start
 
 ```typescript
-import { Agent, OpenAIResponsesProvider, tool } from "@deepstrike/sdk"
+import {
+  FileSessionLog,
+  LocalExecutionPlane,
+  RuntimeRunner,
+  OpenAIResponsesProvider,
+  collectText,
+  tool,
+} from "@deepstrike/sdk"
 
 const provider = new OpenAIResponsesProvider(process.env.OPENAI_API_KEY!, "gpt-5-mini")
 
@@ -43,26 +50,34 @@ const add = tool("add", "Add two numbers.", {
   required: ["x", "y"],
 }, async ({ x, y }) => String(Number(x) + Number(y)))
 
-const agent = new Agent(provider, { maxTokens: 4096 })
-agent.register(add)
+const plane = new LocalExecutionPlane().register(add)
+const runner = new RuntimeRunner({
+  provider,
+  executionPlane: plane,
+  sessionLog: new FileSessionLog(".deepstrike/sessions"),
+  maxTokens: 4096,
+})
 
-const result = await agent.run("What is 17 + 28?")
+const result = await collectText(runner.run({
+  sessionId: "math-1",
+  goal: "What is 17 + 28?",
+}))
 console.log(result)
 ```
 
 Same-session conversation continuity is explicit via `sessionId`:
 
 ```typescript
-await agent.run("My name is Ada.", undefined, undefined, "chat-1")
-const reply = await agent.run("What is my name?", undefined, undefined, "chat-1")
+await collectText(runner.run({ sessionId: "chat-1", goal: "My name is Ada." }))
+const reply = await collectText(runner.run({ sessionId: "chat-1", goal: "What is my name?" }))
 ```
 
-By default, the agent keeps session transcripts in memory for the lifetime of that `Agent` instance. Provide a `sessionStore` when the transcript must survive process restarts or be shared across workers.
+Use `InMemorySessionLog` for process-local sessions or `FileSessionLog` when event replay should survive restarts. `wake(sessionId)` resumes from the event log without inserting a duplicate user start event.
 
 Streaming:
 
 ```typescript
-for await (const event of agent.runStreaming("Summarize README.md")) {
+for await (const event of runner.run({ sessionId: "readme-1", goal: "Summarize README.md" })) {
   if (event.type === "text_delta") process.stdout.write(event.delta)
   else if (event.type === "tool_call") console.log(`\n[→ ${event.name}]`)
   else if (event.type === "tool_result") console.log(`  = ${event.content}`)
@@ -88,6 +103,8 @@ for await (const event of agent.runStreaming("Summarize README.md")) {
 
 All providers accept `RetryConfig` for exponential backoff and share a `CircuitBreaker`.
 
+`extensions` are forwarded by every provider in both `complete()` and `stream()` while SDK-owned structural fields such as `model`, `messages`, `tools`, and streaming flags remain protected. Provider-specific controls still keep their native spellings: for example Anthropic `thinking` / `betas`, OpenAI Responses `reasoning`, Gemini `generationConfig`, Ollama `think` / `options`, DeepSeek `thinking` + `reasoningEffort`, and Qwen `enableThinking` + `thinkingBudget`.
+
 OpenAI can also be selected through the provider catalog:
 
 ```typescript
@@ -101,14 +118,18 @@ const provider = createProvider({
 
 ---
 
-## Agent options
+## Runtime options
 
 ```typescript
-const agent = new Agent(provider, {
+const plane = new LocalExecutionPlane()
+const runner = new RuntimeRunner({
+  provider,
+  executionPlane: plane,
+  sessionLog: new FileSessionLog(".deepstrike/sessions"),
   maxTokens: 4096,            // context window size
   maxTurns: 25,               // max turns (default 25)
   timeoutMs: 60_000,          // timeout in ms
-  extensions: { temperature: 0.1 },  // pass-through to LLM
+  extensions: { temperature: 0.1 },  // provider-native controls, passed through to the LLM
   skillDir: "./skills",       // skill .md files directory
   knowledgeSource: myKS,      // KnowledgeSource implementation
   signalSource: rx,           // SignalSource for external signals
@@ -125,19 +146,25 @@ const agent = new Agent(provider, {
 ```typescript
 import { tool, readFile } from "@deepstrike/sdk"
 
-agent.register(tool("search", "Search.", schema, async (args) => ...))
-agent.register(readFile)     // built-in: read files from disk
-agent.unregister("search")
+plane.register(tool("search", "Search.", schema, async (args) => ...))
+plane.register(readFile)     // built-in: read files from disk
+plane.unregister("search")
 ```
 
 ---
 
 ## Skills
 
-Skills are `.md` files with YAML frontmatter. Set `skillDir` on the agent — the kernel auto-injects a `skill` meta-tool, and the LLM loads skills by name on demand.
+Skills are `.md` files with YAML frontmatter. Set `skillDir` on the runner — the kernel auto-injects a `skill` meta-tool, and the LLM loads skills by name on demand.
 
 ```typescript
-const agent = new Agent(provider, { maxTokens: 4096, skillDir: "./skills" })
+const runner = new RuntimeRunner({
+  provider,
+  executionPlane: plane,
+  sessionLog: new FileSessionLog(".deepstrike/sessions"),
+  maxTokens: 4096,
+  skillDir: "./skills",
+})
 ```
 
 ```markdown
@@ -158,7 +185,10 @@ effort: 1
 Implement `KnowledgeSource` to connect any RAG system. The kernel injects a `knowledge` meta-tool that the LLM calls on demand.
 
 ```typescript
-const agent = new Agent(provider, {
+const runner = new RuntimeRunner({
+  provider,
+  executionPlane: plane,
+  sessionLog: new FileSessionLog(".deepstrike/sessions"),
   maxTokens: 4096,
   knowledgeSource: {
     async retrieve(query: string, topK: number): Promise<string[]> {
@@ -194,7 +224,10 @@ class MyStore implements DreamStore {
   async search(agentId, query, topK) { ... }
 }
 
-const agent = new Agent(provider, {
+const runner = new RuntimeRunner({
+  provider,
+  executionPlane: plane,
+  sessionLog: new FileSessionLog(".deepstrike/sessions"),
   maxTokens: 4096,
   dreamStore: new MyStore(),
   agentId: "my-agent",  // enables `memory` meta-tool
@@ -202,23 +235,7 @@ const agent = new Agent(provider, {
 
 // In-session: LLM calls memory(query) → DreamStore.search()
 // Post-session: trigger memory consolidation
-const result = await agent.dream("my-agent", Date.now())
-```
-
-### SessionStore (same-session transcript continuity)
-
-```typescript
-import type { SessionStore } from "@deepstrike/sdk"
-
-class MySessionStore implements SessionStore {
-  async loadSession(sessionId) { return db.sessions.get(sessionId) }
-  async saveSession(session) { await db.sessions.put(session.sessionId, session) }
-}
-
-const agent = new Agent(provider, {
-  maxTokens: 4096,
-  sessionStore: new MySessionStore(),
-})
+const result = await runner.dream("my-agent", Date.now())
 ```
 
 ---
@@ -250,7 +267,13 @@ gov.requireParam("write_file", "path")
 gov.allowParamValues("set_mode", "mode", ["read", "write"])
 gov.limitParamRange("sleep", "seconds", 0, 10)
 
-const agent = new Agent(provider, { maxTokens: 4096, governance: gov })
+const runner = new RuntimeRunner({
+  provider,
+  executionPlane: plane,
+  sessionLog: new FileSessionLog(".deepstrike/sessions"),
+  maxTokens: 4096,
+  governance: gov,
+})
 // Every tool call goes through: Permission → Veto → RateLimit → Constraint → Audit
 ```
 
@@ -265,10 +288,16 @@ const gw = new SignalGateway()
 gw.schedule(new ScheduledPrompt("standup", Date.now() + 3600_000))
 gw.ingest({ kind: "interrupt", urgency: "critical", payload: {} })
 
-const agent = new Agent(provider, { maxTokens: 4096, signalSource: gw })
-// kind="interrupt" → immediately stops the running agent
+const runner = new RuntimeRunner({
+  provider,
+  executionPlane: plane,
+  sessionLog: new FileSessionLog(".deepstrike/sessions"),
+  maxTokens: 4096,
+  signalSource: gw,
+})
+// kind="interrupt" → immediately stops the running runner
 
-agent.interrupt() // also works directly
+runner.interrupt() // also works directly
 gw.destroy()
 ```
 
@@ -280,22 +309,21 @@ gw.destroy()
 import { SinglePassHarness, EvalLoopHarness, HarnessLoop } from "@deepstrike/sdk"
 
 // 1. SinglePass — run once, always passes
-const outcome = await new SinglePassHarness(agent).run({ goal: "Say hello" })
+const outcome = await new SinglePassHarness(runner).run({ goal: "Say hello" })
 
 // 2. EvalLoop — retry until QualityGate passes
-const harness = new EvalLoopHarness(agent, {
-  gate: async (req, out) => out.result.includes("hello"),
-  maxAttempts: 3,
-})
+const harness = new EvalLoopHarness(runner, {
+  async evaluate(_req, out) { return out.result.includes("hello") },
+}, 3)
 
 // 3. HarnessLoop — LLM-as-judge with feedback injection + skill extraction
-const loop = new HarnessLoop(agent, {
-  evalProvider,
-  maxAttempts: 3,
-  skillDir: "./skills",
-})
-const out = await loop.run({ goal: "Write a haiku", criteria: ["Must be 3 lines"] })
-console.log(out.passed, out.feedback)
+const loop = new HarnessLoop(runner, evalProvider, { maxAttempts: 3, skillDir: "./skills" })
+for await (const event of loop.runStreaming({
+  goal: "Write a haiku",
+  criteria: [{ text: "Must be 3 lines", required: true }],
+})) {
+  if (event.type === "done") console.log(event.verdict.passed, event.verdict.feedback)
+}
 ```
 
 ---
@@ -307,6 +335,8 @@ console.log(out.passed, out.feedback)
 | `text_delta` | `delta` |
 | `thinking_delta` | `delta` |
 | `tool_call` | `id`, `name`, `arguments` |
+| `tool_delta` | `callId`, `delta?`, `chunk?` |
+| `tool_suspend` | `callId`, `suspensionId`, `payload?` |
 | `tool_result` | `callId`, `content`, `isError` |
 | `permission_request` | `toolName`, `reason` |
 | `done` | `iterations`, `totalTokens`, `status` |

package/dist/collaboration/harness.js

@@ -1,3 +1,4 @@
+import { collectText } from "../runtime/runner.js";
 import { formatContractForSystemPrompt, contractToCriteriaStrings } from "./contract.js";
 import { HandoffBus } from "./handoff.js";
 /**
@@ -42,7 +43,11 @@ export class ContractDrivenHarness {
                 ? `\n\n[Previous attempt failed. Violations to fix:\n${this._formatViolationsForFeedback(checkResults)}]`
                 : "";
             const executorGoal = `${contractBlock}\n\n---\n\n${currentGoal}${violationNote}`;
-            artifact = await this.pool.get("executor").run(executorGoal, contractToCriteriaStrings(this.contract));
+            artifact = await collectText(this.pool.get("executor").run({
+                sessionId: crypto.randomUUID(),
+                goal: executorGoal,
+                criteria: contractToCriteriaStrings(this.contract),
+            }));
             // ── Phase 2: Verifier ──────────────────────────────────────────────────
             // Verifier sees: artifact + contract only. No executor history.
             const auditText = await this.pool.runVerifier({ contract: this.contract, artifact });

package/dist/collaboration/modes/creator-verifier.d.ts

@@ -15,8 +15,8 @@ export interface CreatorVerifierMetrics {
  * Usage:
  * ```ts
  * const pool = new AgentPool()
- *   .add("executor", new Agent(provider, { maxTokens: 32_000, skillDir }))
- *   .add("verifier", new Agent(provider, { maxTokens: 8_000 }))
+ *   .add("executor", executorRunner)
+ *   .add("verifier", verifierRunner)
  *
  * const mode = new CreatorVerifierMode(pool)
  * const result = await mode.run(contract)

package/dist/collaboration/modes/creator-verifier.js

@@ -8,8 +8,8 @@ import { ContractDrivenHarness } from "../harness.js";
  * Usage:
  * ```ts
  * const pool = new AgentPool()
- *   .add("executor", new Agent(provider, { maxTokens: 32_000, skillDir }))
- *   .add("verifier", new Agent(provider, { maxTokens: 8_000 }))
+ *   .add("executor", executorRunner)
+ *   .add("verifier", verifierRunner)
  *
  * const mode = new CreatorVerifierMode(pool)
  * const result = await mode.run(contract)

package/dist/collaboration/pool.d.ts

@@ -1,46 +1,15 @@
-import type { Agent } from "../agent.js";
+import type { RuntimeRunner } from "../runtime/runner.js";
 import type { VerificationContract } from "./contract.js";
-/**
- * Roles in a multi-agent collaboration.
- *
- * - orchestrator: strong-reasoning, produces VerificationContracts; no tools beyond planning
- * - executor:     code/task execution, full tool access, sees goal + contract only
- * - verifier:     adversarial auditor, no tools, low temperature, sees artifact + contract only
- */
 export type AgentRole = "orchestrator" | "executor" | "verifier";
-/** Context passed to a verifier run — intentionally minimal. */
 export interface IsolatedVerifierContext {
     contract: VerificationContract;
-    /** The artifact produced by the executor. */
     artifact: string;
 }
-/**
- * AgentPool manages a set of role-specific Agent instances.
- *
- * Each role runs in its own Agent instance with an independent history partition,
- * ensuring that the verifier never sees the executor's implementation transcript.
- *
- * Usage:
- * ```ts
- * const pool = new AgentPool()
- *   .add("executor", executorAgent)
- *   .add("verifier", verifierAgent)
- * ```
- */
 export declare class AgentPool {
-    private agents;
-    add(role: AgentRole, agent: Agent): this;
+    private runners;
+    add(role: AgentRole, runner: RuntimeRunner): this;
     has(role: AgentRole): boolean;
-    get(role: AgentRole): Agent;
-    /**
-     * Run the verifier with an isolated context — only the artifact and contract.
-     * The verifier does NOT receive the executor's conversation history.
-     * Returns a structured audit response as a plain string.
-     */
+    get(role: AgentRole): RuntimeRunner;
     runVerifier(ctx: IsolatedVerifierContext): Promise<string>;
-    /**
-     * Run the orchestrator to decompose a high-level goal into a VerificationContract.
-     * The orchestrator receives the goal and must produce a structured contract in JSON.
-     */
     runOrchestrator(goal: string): Promise<string>;
 }

package/dist/collaboration/pool.js

@@ -1,64 +1,38 @@
+import { collectText } from "../runtime/runner.js";
 import { formatContractForSystemPrompt } from "./contract.js";
-/**
- * AgentPool manages a set of role-specific Agent instances.
- *
- * Each role runs in its own Agent instance with an independent history partition,
- * ensuring that the verifier never sees the executor's implementation transcript.
- *
- * Usage:
- * ```ts
- * const pool = new AgentPool()
- *   .add("executor", executorAgent)
- *   .add("verifier", verifierAgent)
- * ```
- */
 export class AgentPool {
-    agents = new Map();
-    add(role, agent) {
-        this.agents.set(role, agent);
+    runners = new Map();
+    add(role, runner) {
+        this.runners.set(role, runner);
         return this;
     }
     has(role) {
-        return this.agents.has(role);
+        return this.runners.has(role);
     }
     get(role) {
-        const agent = this.agents.get(role);
-        if (!agent)
-            throw new Error(`AgentPool: no agent registered for role "${role}"`);
-        return agent;
+        const runner = this.runners.get(role);
+        if (!runner)
+            throw new Error(`AgentPool: no runner registered for role "${role}"`);
+        return runner;
     }
-    /**
-     * Run the verifier with an isolated context — only the artifact and contract.
-     * The verifier does NOT receive the executor's conversation history.
-     * Returns a structured audit response as a plain string.
-     */
     async runVerifier(ctx) {
-        const agent = this.get("verifier");
+        const runner = this.get("verifier");
         const contractBlock = formatContractForSystemPrompt(ctx.contract);
         const auditGoal = [
-            contractBlock,
-            "",
-            "---",
-            "",
-            "## Artifact to Audit",
-            "",
-            ctx.artifact,
-            "",
-            "---",
-            "",
+            contractBlock, "",
+            "---", "",
+            "## Artifact to Audit", "",
+            ctx.artifact, "",
+            "---", "",
             "Audit the artifact against every criterion in the contract above.",
             "For each criterion, state whether it PASSED or FAILED and cite specific evidence.",
             "List any anti-patterns you detected.",
             "Conclude with an overall PASS or FAIL verdict.",
         ].join("\n");
-        return agent.run(auditGoal);
+        return collectText(runner.run({ sessionId: crypto.randomUUID(), goal: auditGoal }));
     }
-    /**
-     * Run the orchestrator to decompose a high-level goal into a VerificationContract.
-     * The orchestrator receives the goal and must produce a structured contract in JSON.
-     */
     async runOrchestrator(goal) {
-        const agent = this.get("orchestrator");
+        const runner = this.get("orchestrator");
         const orchestratorGoal = [
             `You are a planning orchestrator. Decompose the following goal into a VerificationContract.`,
             ``,
@@ -75,6 +49,6 @@ export class AgentPool {
             ``,
             `Output ONLY the JSON object, no prose.`,
         ].join("\n");
-        return agent.run(orchestratorGoal);
+        return collectText(runner.run({ sessionId: crypto.randomUUID(), goal: orchestratorGoal }));
     }
 }

package/dist/harness/harness.d.ts

@@ -1,4 +1,5 @@
-import type { Agent } from "../agent.js";
+import type { RuntimeRunner } from "../runtime/runner.js";
+import { collectText } from "../runtime/runner.js";
 export interface Criterion {
     text: string;
     required: boolean;
@@ -38,6 +39,16 @@ export type HarnessEvent = {
     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;
@@ -61,15 +72,15 @@ export interface QualityGate {
     evaluate(request: HarnessRequest, outcome: HarnessOutcome): Promise<boolean>;
 }
 export declare class SinglePassHarness {
-    private agent;
-    constructor(agent: Agent);
+    private runner;
+    constructor(runner: RuntimeRunner);
     run(request: HarnessRequest): Promise<HarnessOutcome>;
 }
 export declare class EvalLoopHarness {
-    private agent;
+    private runner;
     private gate;
     private maxAttempts;
-    constructor(agent: Agent, gate: QualityGate, maxAttempts?: number);
+    constructor(runner: RuntimeRunner, gate: QualityGate, maxAttempts?: number);
     run(request: HarnessRequest): Promise<HarnessOutcome>;
 }
 export interface HarnessLoopOptions {
@@ -77,10 +88,11 @@ export interface HarnessLoopOptions {
     skillDir?: string;
 }
 export declare class HarnessLoop {
-    private agent;
+    private runner;
     private evalProvider;
     private maxAttempts;
     private skillDir?;
-    constructor(agent: Agent, evalProvider: import("../types.js").LLMProvider, options?: HarnessLoopOptions);
+    constructor(runner: RuntimeRunner, evalProvider: import("../types.js").LLMProvider, options?: HarnessLoopOptions);
     runStreaming(request: HarnessRequest): AsyncIterable<HarnessEvent>;
 }
+export { collectText };

package/dist/harness/harness.js

@@ -1,10 +1,12 @@
+import { collectText } from "../runtime/runner.js";
 import { writeFile } from "fs/promises";
 import path from "path";
 import { getKernel } from "../kernel.js";
-async function runOnce(agent, req) {
+async function runOnce(runner, req) {
     let text = "";
     let done;
-    for await (const evt of agent.runStreaming(req.goal, req.criteria?.map(c => c.text), req.extensions)) {
+    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")
@@ -13,27 +15,27 @@ async function runOnce(agent, req) {
     return { result: text, passed: false, iterations: done?.iterations ?? 0, totalTokens: done?.totalTokens ?? 0, status: done?.status ?? "error" };
 }
 export class SinglePassHarness {
-    agent;
-    constructor(agent) {
-        this.agent = agent;
+    runner;
+    constructor(runner) {
+        this.runner = runner;
     }
     async run(request) {
-        return { ...await runOnce(this.agent, request), passed: true };
+        return { ...await runOnce(this.runner, request), passed: true };
     }
 }
 export class EvalLoopHarness {
-    agent;
+    runner;
     gate;
     maxAttempts;
-    constructor(agent, gate, maxAttempts = 3) {
-        this.agent = agent;
+    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.agent, request);
+            outcome = await runOnce(this.runner, request);
             if (await this.gate.evaluate(request, outcome))
                 return { ...outcome, passed: true };
         }
@@ -41,12 +43,12 @@ export class EvalLoopHarness {
     }
 }
 export class HarnessLoop {
-    agent;
+    runner;
     evalProvider;
     maxAttempts;
     skillDir;
-    constructor(agent, evalProvider, options = {}) {
-        this.agent = agent;
+    constructor(runner, evalProvider, options = {}) {
+        this.runner = runner;
         this.evalProvider = evalProvider;
         this.maxAttempts = options.maxAttempts ?? 3;
         this.skillDir = options.skillDir;
@@ -55,27 +57,31 @@ export class HarnessLoop {
         const kernel = getKernel();
         const pipeline = new kernel.EvalPipeline({ extractSkillOnPass: true });
         const criteria = request.criteria ?? [];
-        // history tracks the full conversation; agent sees only the current goal message
-        // but we inject feedback as user messages to guide revision without discarding prior output
         let currentGoal = request.goal;
         let lastIterations = 0;
         let lastTotalTokens = 0;
         let lastStatus = "error";
         let lastResult = "";
         for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
-            // Stream agent output directly to caller
-            for await (const evt of this.agent.runStreaming(currentGoal, criteria.map(c => c.text), request.extensions)) {
+            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") {
-                    // 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_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") {
-                    // 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 };
                 }
@@ -86,13 +92,11 @@ export class HarnessLoop {
                     lastStatus = d.status;
                 }
             }
-            // Checkpoint: evaluator judges the completed output
             yield { type: "supervising" };
             const evalAction = pipeline.feedOutcome(request.goal, criteria, lastResult, attempt);
             if (evalAction.kind !== "evaluate")
                 break;
             let evalText = "";
-            // Wrap harness eval messages in a RenderedContext (system messages → systemText, rest → turns).
             const evalMsgs = evalAction.messages ?? [];
             const evalContext = {
                 systemText: evalMsgs.filter((m) => m.role === "system").map((m) => m.content).join("\n\n"),
@@ -123,7 +127,6 @@ export class HarnessLoop {
                 return;
             }
             yield { type: "revising", verdict };
-            // Inject feedback as next turn's goal — agent sees its prior output + evaluator notes
             currentGoal = `${request.goal}\n\n[Attempt ${attempt} feedback: ${verdict.feedback}]`;
             lastResult = "";
             pipeline.reset();
@@ -131,3 +134,5 @@ export class HarnessLoop {
         yield { type: "max_attempts_reached" };
     }
 }
+// Re-export collectText so harness callers can use it without knowing runner internals.
+export { collectText };