@deepstrike/sdk 0.1.1 → 0.1.4

package/dist/agent.js

@@ -2,13 +2,15 @@ import { executeTools } from "./tools/index.js";
 import { readSkillFile, scanSkillDir } from "./skills/loader.js";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 async function loadKernel() {
-    return import("@deepstrike/core");
+    const mod = await import("@deepstrike/core");
+    // CJS modules imported via ESM dynamic import expose exports under `.default`
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return mod.default ?? mod;
 }
 export class Agent {
     provider;
     options;
     tools = new Map();
-    blockedTools = new Set();
     extensions;
     skillDir;
     knowledgeSource;
@@ -16,6 +18,9 @@ export class Agent {
     dreamStore;
     interrupted = false;
     pendingInterrupt = false;
+    // Live telemetry — updated each runStreaming call
+    _turn = 0;
+    _pressure = 0;
     constructor(provider, options) {
         this.provider = provider;
         this.options = options;
@@ -25,6 +30,10 @@ export class Agent {
         this.signalSource = options.signalSource;
         this.dreamStore = options.dreamStore;
     }
+    /** Current turn index within the active run (0 before a run starts). */
+    get turn() { return this._turn; }
+    /** Context pressure ratio [0–1] from the kernel. Values > 0.8 trigger compression. */
+    get pressure() { return this._pressure; }
     interrupt() {
         this.interrupted = true;
     }
@@ -37,21 +46,26 @@ export class Agent {
         this.tools.delete(name);
         return this;
     }
-    blockTool(name) {
-        this.blockedTools.add(name);
-        return this;
-    }
+    /**
+     * Collect the full text response and return it.
+     * For richer control (streaming, tool events, token counts) use `runStreaming`.
+     */
     async run(goal, criteria, extensions) {
-        let result;
+        let content = "";
         for await (const evt of this.runStreaming(goal, criteria, extensions)) {
-            if (evt.type === "done")
-                result = evt;
+            if (evt.type === "text_delta")
+                content += evt.delta;
         }
-        return result ? `done in ${result.iterations} turns (${result.status})` : "done";
+        return content;
     }
     async *runStreaming(goal, criteria, extensions) {
         this.interrupted = false;
         this.pendingInterrupt = false;
+        this._turn = 0;
+        this._pressure = 0;
+        if (this.knowledgeSource) {
+            await this.knowledgeSource.init();
+        }
         const kernel = await loadKernel();
         const ext = { ...this.extensions, ...(extensions ?? {}) };
         const sm = new kernel.LoopStateMachine({
@@ -59,15 +73,20 @@ export class Agent {
             maxTurns: this.options.maxTurns ?? 25,
             timeoutMs: this.options.timeoutMs,
         });
-        // Create a per-run SignalRouter so dedup state doesn't leak across runs.
+        // Per-run SignalRouter — dedup state never leaks between runs.
         const router = new kernel.SignalRouter(256);
         const toolSchemas = Array.from(this.tools.values()).map(t => t.schema);
         sm.setTools(toolSchemas);
-        // Scan skill directory and register metadata with the kernel.
-        // The kernel will auto-inject the `skill` meta-tool into every CallLLM action.
+        if (this.options.systemPrompt) {
+            const tokens = Math.max(1, Math.ceil(this.options.systemPrompt.length / 4));
+            sm.addSystemMessage(this.options.systemPrompt, tokens);
+        }
+        for (const mem of this.options.initialMemory ?? []) {
+            sm.addMemoryMessage(mem, Math.max(1, Math.ceil(mem.length / 4)));
+        }
         if (this.skillDir) {
             const skillMetas = await scanSkillDir(this.skillDir);
-            sm.setAvailableSkills(skillMetas.map(m => ({
+            sm.setAvailableSkills(skillMetas.map((m) => ({
                 name: m.name,
                 description: m.description,
                 whenToUse: m.whenToUse,
@@ -75,17 +94,20 @@ export class Agent {
                 estimatedTokens: m.estimatedTokens ?? 0,
             })));
         }
-        // Enable the memory meta-tool when both dreamStore and agentId are provided.
         if (this.dreamStore && this.options.agentId) {
             sm.setMemoryEnabled(true);
         }
-        // Enable the knowledge meta-tool when a KnowledgeSource is configured.
         if (this.knowledgeSource) {
             sm.setKnowledgeEnabled(true);
         }
         let action = sm.start({ goal, criteria: criteria ?? [] });
-        let finalText = "";
+        const sessionStart = Date.now();
+        const sessionMsgs = [{ role: "user", content: goal }];
         while (!sm.isTerminal()) {
+            // Update telemetry
+            this._turn = sm.turn;
+            this._pressure = sm.pressure();
+            // Hard interrupt
             if (this.interrupted) {
                 action = sm.feedTimeout();
                 break;
@@ -95,18 +117,22 @@ export class Agent {
                 action = sm.feedTimeout();
                 break;
             }
+            // Drain context-compression observations
+            sm.takeObservations();
             // Poll signal source and route through kernel SignalRouter
             if (this.signalSource) {
                 const sig = await this.signalSource.nextSignal();
                 if (sig) {
+                    const sigAny = sig;
                     const kernelSig = {
                         id: crypto.randomUUID(),
-                        source: sig.source ?? "custom",
-                        signalType: sig.signalType ?? "event",
-                        urgency: sig.urgency ?? (sig.kind === "interrupt" ? "critical" : "normal"),
+                        source: sigAny.source ?? "custom",
+                        signalType: sigAny.signalType ?? "event",
+                        urgency: sigAny.urgency
+                            ?? (sig.kind === "interrupt" ? "critical" : "normal"),
                         summary: String(sig.payload?.goal ?? sig.kind),
                         payload: JSON.stringify(sig.payload ?? {}),
-                        dedupeKey: sig.dedupeKey ?? null,
+                        dedupeKey: sigAny.dedupeKey ?? null,
                         timestampMs: Date.now(),
                     };
                     const disposition = router.ingest(kernelSig, action.kind === "execute_tools");
@@ -114,20 +140,35 @@ export class Agent {
                         action = sm.feedTimeout();
                         break;
                     }
-                    if (disposition === "interrupt") {
+                    if (disposition === "interrupt")
                         this.pendingInterrupt = true;
-                    }
-                    // "queue" → buffered; "observe" / "ignore" / "dropped" → no action
                 }
             }
-            sm.takeObservations();
+            // Drain previously queued signals — apply any high-urgency ones
+            let queued = router.next();
+            while (queued) {
+                if (queued.urgency === "critical") {
+                    action = sm.feedTimeout();
+                    break;
+                }
+                if (queued.urgency === "high")
+                    this.pendingInterrupt = true;
+                queued = router.next();
+            }
+            if (this.interrupted || (sm.isTerminal()))
+                break;
             if (action.kind === "call_llm") {
-                finalText = "";
                 const finalToolCalls = [];
+                let finalText = "";
                 const messages = (action.messages ?? []);
                 const tools = (action.tools ?? []);
+                let turnTokens = 0;
                 try {
                     for await (const evt of this.provider.stream(messages, tools, Object.keys(ext).length ? ext : undefined)) {
+                        if (evt.type === "usage") {
+                            turnTokens = evt.totalTokens;
+                            continue;
+                        }
                         yield evt;
                         if (evt.type === "text_delta")
                             finalText += evt.delta;
@@ -142,45 +183,47 @@ export class Agent {
                     action = sm.feedTimeout();
                     break;
                 }
-                action = sm.feedLlmResponse({ role: "assistant", content: finalText, toolCalls: finalToolCalls });
+                action = sm.feedLlmResponse({ role: "assistant", content: finalText, toolCalls: finalToolCalls, tokenCount: turnTokens || undefined });
+                sessionMsgs.push({ role: "assistant", content: finalText, toolCalls: finalToolCalls });
             }
             else if (action.kind === "execute_tools") {
                 const allCalls = action.calls ?? [];
-                // Governance check: blocked tools + GovernancePipeline
+                // Governance evaluation
                 const permittedCalls = [];
+                const deniedResults = [];
                 for (const c of allCalls) {
-                    if (this.blockedTools.has(c.name)) {
-                        yield { type: "error", message: `tool blocked: ${c.name}` };
-                        continue;
-                    }
                     if (this.options.governance) {
                         const verdict = this.options.governance.evaluate(c.name, c.arguments);
                         if (verdict.kind === "deny") {
-                            yield { type: "error", message: `permission denied: ${c.name} — ${verdict.reason}` };
+                            const msg = `permission denied: ${c.name} — ${verdict.reason ?? ""}`;
+                            yield { type: "error", message: msg };
+                            deniedResults.push({ callId: c.id, name: c.name, output: msg, isError: true });
+                            continue;
+                        }
+                        if (verdict.kind === "rate_limited") {
+                            const msg = `rate limited: ${c.name} — retry after ${verdict.retryAfterMs ?? 0}ms`;
+                            yield { type: "error", message: msg };
+                            deniedResults.push({ callId: c.id, name: c.name, output: msg, isError: true });
                             continue;
                         }
                         if (verdict.kind === "ask_user") {
-                            yield { type: "permission_request", callId: c.id, toolName: c.name, arguments: c.arguments, reason: verdict.reason };
+                            yield { type: "permission_request", callId: c.id, toolName: c.name, arguments: c.arguments, reason: verdict.reason ?? "" };
+                            deniedResults.push({ callId: c.id, name: c.name, output: `awaiting user approval: ${c.name}`, isError: true });
                             continue;
                         }
                     }
                     permittedCalls.push(c);
                 }
-                const calls = permittedCalls;
-                // Intercept `skill` meta-tool calls: read file, return content as tool result.
-                const skillCalls = calls.filter((c) => c.name === "skill");
-                // Intercept `memory` meta-tool calls: search DreamStore, return entries as tool result.
-                const memoryCalls = calls.filter((c) => c.name === "memory");
-                // Intercept `knowledge` meta-tool calls: retrieve from KnowledgeSource.
-                const knowledgeCalls = calls.filter((c) => c.name === "knowledge");
-                const regularCalls = calls.filter((c) => c.name !== "skill" && c.name !== "memory" && c.name !== "knowledge");
+                const skillCalls = permittedCalls.filter((c) => c.name === "skill");
+                const memoryCalls = permittedCalls.filter((c) => c.name === "memory");
+                const knowledgeCalls = permittedCalls.filter((c) => c.name === "knowledge");
+                const regularCalls = permittedCalls.filter((c) => c.name !== "skill" && c.name !== "memory" && c.name !== "knowledge");
                 const skillResults = this.skillDir
                     ? await Promise.all(skillCalls.map(async (c) => {
                         const args = tryParseJson(c.arguments);
                         const name = String(args?.name ?? "");
                         const content = await readSkillFile(this.skillDir, name);
-                        const output = content ?? `Skill "${name}" not found.`;
-                        return { callId: c.id, name: c.name, output, isError: !content };
+                        return { callId: c.id, name: c.name, output: content ?? `Skill "${name}" not found.`, isError: !content };
                     }))
                     : skillCalls.map((c) => ({ callId: c.id, name: c.name, output: "No skill directory configured.", isError: true }));
                 const memoryResults = (this.dreamStore && this.options.agentId)
@@ -190,7 +233,7 @@ export class Agent {
                         const topK = typeof args?.top_k === "number" ? args.top_k : 5;
                         const entries = await this.dreamStore.search(this.options.agentId, query, topK);
                         const output = entries.length
-                            ? entries.map(e => `[score=${e.score.toFixed(3)}] ${e.text}`).join("\n---\n")
+                            ? entries.map((e) => `[score=${e.score.toFixed(3)}] ${e.text}`).join("\n---\n")
                             : "No relevant memories found.";
                         return { callId: c.id, name: c.name, output, isError: false };
                     }))
@@ -205,18 +248,18 @@ export class Agent {
                         return { callId: c.id, name: c.name, output, isError: false };
                     }))
                     : knowledgeCalls.map((c) => ({ callId: c.id, name: c.name, output: "Knowledge source not configured.", isError: true }));
-                // Yield all meta-tool results
                 for (const r of [...skillResults, ...memoryResults, ...knowledgeResults])
                     yield { type: "tool_result", callId: r.callId, name: r.name, content: r.output, isError: r.isError };
                 const results = await executeTools(regularCalls, this.tools);
                 for (const r of results) {
-                    const name = regularCalls.find(c => c.id === r.callId)?.name ?? "";
+                    const name = regularCalls.find((c) => c.id === r.callId)?.name ?? "";
                     yield { type: "tool_result", callId: r.callId, name, content: r.output, isError: r.isError };
                 }
                 action = sm.feedToolResults([
-                    ...skillResults,
-                    ...memoryResults,
-                    ...knowledgeResults,
+                    ...deniedResults.map(r => ({ callId: r.callId, output: r.output, isError: r.isError })),
+                    ...skillResults.map(r => ({ callId: r.callId, output: r.output, isError: r.isError })),
+                    ...memoryResults.map(r => ({ callId: r.callId, output: r.output, isError: r.isError })),
+                    ...knowledgeResults.map(r => ({ callId: r.callId, output: r.output, isError: r.isError })),
                     ...results.map(r => ({ callId: r.callId, output: r.output, isError: r.isError })),
                 ]);
             }
@@ -225,20 +268,38 @@ export class Agent {
             }
         }
         const result = action.result;
+        this._turn = sm.turn;
+        this._pressure = sm.pressure();
+        const status = result?.termination === "completed" ? "success" : (result?.termination ?? "error");
+        const iterations = result ? Math.max(1, result.turnsUsed) : 0;
+        if (this.options.dreamStore && this.options.agentId && sessionMsgs.length > 1) {
+            try {
+                await this.options.dreamStore.saveSession({
+                    sessionId: crypto.randomUUID(),
+                    agentId: this.options.agentId,
+                    messages: sessionMsgs,
+                    metadata: null,
+                    createdAtMs: sessionStart,
+                    updatedAtMs: Date.now(),
+                });
+            }
+            catch { /* session save failure must not surface to caller */ }
+        }
         yield {
             type: "done",
-            iterations: result?.turnsUsed ?? 0,
-            totalTokens: Number(result?.totalTokensUsed ?? 0),
-            status: result?.termination ?? "error",
+            iterations,
+            totalTokens: result?.totalTokensUsed ? Number(result.totalTokensUsed) : 0,
+            status,
         };
     }
     /**
-     * Trigger an idle dreaming cycle for the given agent.
+     * Trigger the idle dreaming cycle for this agent.
+     * Requires `dreamStore` and `agentId` to be configured.
      *
-     * Phase 1 — kernel rule-based analysis + LLM prompt assembly (kernel, pure computation)
-     * Phase 2 — LLM synthesis call (SDK, I/O here)
-     * Phase 3 — kernel parses + curates results (kernel, pure computation)
-     * Phase 4 — commit delta to DreamStore (SDK, I/O here)
+     * Phase 1 — kernel rule-based analysis + LLM prompt assembly
+     * Phase 2 — LLM synthesis call (I/O)
+     * Phase 3 — kernel parses + curates results
+     * Phase 4 — commit delta to DreamStore (I/O)
      */
     async dream(agentId, nowMs = Date.now()) {
         if (!this.dreamStore)
@@ -256,9 +317,7 @@ export class Agent {
                 role: m.role,
                 content: m.content,
                 tokenCount: m.tokenCount,
-                toolCalls: (m.toolCalls ?? []).map(tc => ({
-                    id: tc.id, name: tc.name, arguments: tc.arguments,
-                })),
+                toolCalls: (m.toolCalls ?? []).map(tc => ({ id: tc.id, name: tc.name, arguments: tc.arguments })),
             })),
             metadata: JSON.stringify(s.metadata ?? null),
             createdAtMs: s.createdAtMs,
@@ -271,7 +330,7 @@ export class Agent {
         }));
         const pipeline = new kernel.IdlePipeline(agentId);
         const action1 = pipeline.feedTrigger(kernelSessions, kernelMemories, nowMs);
-        if (action1.kind === "noop") {
+        if (action1.kind === "noop" || action1.kind === "aborted") {
             return { sessionsProcessed: 0, insightsExtracted: 0, entriesAdded: 0, entriesRemoved: 0 };
         }
         if (action1.kind !== "synthesize_insights") {

package/dist/harness/harness.d.ts

@@ -1,7 +1,18 @@
 import type { Agent } from "../agent.js";
+export interface Criterion {
+    text: string;
+    required: boolean;
+    weight?: number;
+}
+export interface CriterionResult {
+    criterion: string;
+    passed: boolean;
+    score: number;
+    feedback: string;
+}
 export interface HarnessRequest {
     goal: string;
-    criteria?: string[];
+    criteria?: Criterion[];
     extensions?: Record<string, unknown>;
 }
 export interface HarnessOutcome {
@@ -10,26 +21,29 @@ export interface HarnessOutcome {
     iterations: number;
     totalTokens: number;
     status: string;
-    /** Feedback from the evaluator LLM — injected into the next attempt's goal. */
+    overallScore?: number;
     feedback?: string;
+    details?: CriterionResult[];
+}
+export interface QualityGate {
+    evaluate(request: HarnessRequest, outcome: HarnessOutcome): Promise<boolean>;
 }
 export declare class SinglePassHarness {
     private agent;
     constructor(agent: Agent);
     run(request: HarnessRequest): Promise<HarnessOutcome>;
 }
+export declare class EvalLoopHarness {
+    private agent;
+    private gate;
+    private maxAttempts;
+    constructor(agent: Agent, gate: QualityGate, maxAttempts?: number);
+    run(request: HarnessRequest): Promise<HarnessOutcome>;
+}
 export interface HarnessLoopOptions {
     maxAttempts?: number;
-    /** Directory to write distilled skills into. Requires the agent to have skillDir set. */
     skillDir?: string;
 }
-/**
- * Eval loop with LLM-as-judge and feedback injection.
- *
- * Each failed attempt feeds the evaluator's feedback back into the next goal,
- * so the agent knows *why* it failed. On success, if the evaluator proposes a
- * skill candidate it is written to `skillDir` for future sessions to reuse.
- */
 export declare class HarnessLoop {
     private agent;
     private evalProvider;

package/dist/harness/harness.js

@@ -2,24 +2,20 @@ import { writeFile } from "fs/promises";
 import path from "path";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 async function loadKernel() {
-    return import("@deepstrike/core");
+    const mod = await import("@deepstrike/core");
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return mod.default ?? mod;
 }
 async function runOnce(agent, req) {
     let text = "";
     let done;
-    for await (const evt of agent.runStreaming(req.goal, req.criteria, req.extensions)) {
+    for await (const evt of agent.runStreaming(req.goal, req.criteria?.map(c => c.text), 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",
-    };
+    return { result: text, passed: false, iterations: done?.iterations ?? 0, totalTokens: done?.totalTokens ?? 0, status: done?.status ?? "error" };
 }
 export class SinglePassHarness {
     agent;
@@ -30,13 +26,25 @@ export class SinglePassHarness {
         return { ...await runOnce(this.agent, request), passed: true };
     }
 }
-/**
- * Eval loop with LLM-as-judge and feedback injection.
- *
- * Each failed attempt feeds the evaluator's feedback back into the next goal,
- * so the agent knows *why* it failed. On success, if the evaluator proposes a
- * skill candidate it is written to `skillDir` for future sessions to reuse.
- */
+export class EvalLoopHarness {
+    agent;
+    gate;
+    maxAttempts;
+    constructor(agent, gate, maxAttempts = 3) {
+        this.agent = agent;
+        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);
+            if (await this.gate.evaluate(request, outcome))
+                return { ...outcome, passed: true };
+        }
+        return outcome;
+    }
+}
 export class HarnessLoop {
     agent;
     evalProvider;
@@ -51,48 +59,40 @@ export class HarnessLoop {
     async run(request) {
         const kernel = await loadKernel();
         const pipeline = new kernel.EvalPipeline({ extractSkillOnPass: true });
+        const criteria = request.criteria ?? [];
         let outcome = { result: "", passed: false, iterations: 0, totalTokens: 0, status: "error" };
         let currentGoal = request.goal;
         for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
             outcome = await runOnce(this.agent, { ...request, goal: currentGoal });
-            // Phase 1: kernel builds eval prompt
-            const evalAction = pipeline.feedOutcome({
-                goal: request.goal,
-                criteria: request.criteria ?? [],
-                result: outcome.result,
-                attempt,
-            });
+            const evalAction = pipeline.feedOutcome(request.goal, criteria, outcome.result, attempt);
             if (evalAction.kind !== "evaluate")
                 break;
-            // Phase 2: SDK calls evaluator LLM
             let evalText = "";
             for await (const evt of this.evalProvider.stream(evalAction.messages ?? [], [], undefined)) {
                 if (evt.type === "text_delta")
                     evalText += evt.delta;
             }
-            // Phase 3: kernel parses verdict
-            const doneAction = pipeline.feedEvalResult({ content: evalText });
+            const doneAction = pipeline.feedEvalResult(evalText);
             if (doneAction.kind !== "done")
                 break;
-            const evalResult = doneAction.result;
-            outcome = { ...outcome, passed: evalResult.passed, feedback: evalResult.feedback };
-            if (evalResult.passed) {
-                if (evalResult.skillCandidate && this.skillDir) {
-                    const { name, description, whenToUse, content } = evalResult.skillCandidate;
-                    const frontmatter = [
-                        "---",
-                        `name: ${name}`,
-                        `description: ${description}`,
-                        whenToUse ? `when_to_use: ${whenToUse}` : null,
-                        "---",
-                        "",
-                    ].filter(l => l !== null).join("\n");
-                    await writeFile(path.join(this.skillDir, `${name}.md`), frontmatter + content, "utf8");
+            outcome = {
+                ...outcome,
+                passed: doneAction.passed ?? false,
+                overallScore: doneAction.overallScore ?? undefined,
+                feedback: doneAction.feedback ?? undefined,
+                details: doneAction.details ?? undefined,
+            };
+            if (doneAction.passed) {
+                if (doneAction.skill_candidate && this.skillDir) {
+                    const { name, description, whenToUse, content } = doneAction.skill_candidate;
+                    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");
                 }
                 return outcome;
             }
-            // Inject feedback into next attempt's goal
-            currentGoal = `${request.goal}\n\n[Previous attempt ${attempt} failed: ${evalResult.feedback}]`;
+            currentGoal = `${request.goal}\n\n[Previous attempt ${attempt} failed: ${doneAction.feedback}]`;
             pipeline.reset();
         }
         return outcome;

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { Agent } from "./agent.js";
 export type { AgentOptions } from "./agent.js";
 export { AnthropicProvider } from "./providers/anthropic.js";
-export { OpenAIProvider, QwenProvider, DeepSeekProvider, MiniMaxProvider } from "./providers/openai.js";
+export { OpenAIProvider, QwenProvider, DeepSeekProvider, MiniMaxProvider, KimiProvider } from "./providers/openai.js";
 export { OllamaProvider } from "./providers/ollama.js";
 export { CircuitBreaker, normalizeToolCall } from "./providers/base.js";
 export { tool, executeTools, readFile } from "./tools/index.js";
@@ -11,11 +11,13 @@ export type { SkillMetadata } from "./skills/loader.js";
 export { WorkingMemory } from "./memory/working.js";
 export type { DreamStore, DreamResult, SessionData, SessionMessage, MemoryEntry, CurationResult, CurationStats, } from "./memory/protocols.js";
 export type { KnowledgeSource } from "./knowledge/source.js";
-export { SinglePassHarness, HarnessLoop } from "./harness/harness.js";
-export type { HarnessRequest, HarnessOutcome, HarnessLoopOptions } from "./harness/harness.js";
+export { SinglePassHarness, EvalLoopHarness, HarnessLoop } from "./harness/harness.js";
+export type { HarnessRequest, HarnessOutcome, HarnessLoopOptions, QualityGate } from "./harness/harness.js";
 export { ScheduledPrompt } from "./signals/scheduled.js";
 export { SignalGateway } from "./signals/gateway.js";
 export type { RuntimeSignal, SignalSource } from "./signals/types.js";
 export { PermissionManager, PermissionMode } from "./safety/permissions.js";
-export type { PermissionDecision } from "./safety/permissions.js";
-export type { Message, ToolCall, ToolResult, ToolSchema, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, LLMProvider, RetryConfig, } from "./types.js";
+export type { PermissionDecision, Permission } from "./safety/permissions.js";
+export declare const Governance: typeof import("@deepstrike/core").Governance;
+export type { GovernanceVerdictObj as GovernanceVerdict } from "@deepstrike/core";
+export type { Message, ToolCall, ToolResult, ToolSchema, ContentPart, TextPart, ImagePart, AudioPart, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, LLMProvider, RetryConfig, TokenUsage, ProviderToolSpec, } from "./types.js";

package/dist/index.js

@@ -1,12 +1,19 @@
 export { Agent } from "./agent.js";
 export { AnthropicProvider } from "./providers/anthropic.js";
-export { OpenAIProvider, QwenProvider, DeepSeekProvider, MiniMaxProvider } from "./providers/openai.js";
+export { OpenAIProvider, QwenProvider, DeepSeekProvider, MiniMaxProvider, KimiProvider } from "./providers/openai.js";
 export { OllamaProvider } from "./providers/ollama.js";
 export { CircuitBreaker, normalizeToolCall } from "./providers/base.js";
 export { tool, executeTools, readFile } from "./tools/index.js";
 export { scanSkillDir, readSkillFile } from "./skills/loader.js";
 export { WorkingMemory } from "./memory/working.js";
-export { SinglePassHarness, HarnessLoop } from "./harness/harness.js";
+export { SinglePassHarness, EvalLoopHarness, HarnessLoop } from "./harness/harness.js";
 export { ScheduledPrompt } from "./signals/scheduled.js";
 export { SignalGateway } from "./signals/gateway.js";
 export { PermissionManager, PermissionMode } from "./safety/permissions.js";
+// Kernel Governance — full pipeline (Permission → Veto → RateLimit → Constraint → Audit)
+// @deepstrike/core is a CJS native addon; static ESM named re-export doesn't work,
+// so we load it via createRequire and re-export with proper types preserved.
+import { createRequire } from "module";
+const _cjsRequire = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const Governance = _cjsRequire("@deepstrike/core").Governance;

package/dist/knowledge/source.d.ts

@@ -1,3 +1,5 @@
 export interface KnowledgeSource {
     retrieve(goal: string, topK?: number): Promise<string[]>;
+    /** One-time warmup called before the first run (load index, open connection, etc.). */
+    init(): Promise<void>;
 }

package/dist/memory/protocols.d.ts

@@ -39,6 +39,8 @@ export interface DreamStore {
     commit(agentId: string, result: CurationResult, existing: MemoryEntry[]): Promise<void>;
     /** Semantic search over the agent's long-term memories. Called on demand during a run. */
     search(agentId: string, query: string, topK?: number): Promise<MemoryEntry[]>;
+    /** Persist a completed session for future consolidation via `Agent.dream()`. */
+    saveSession(data: SessionData): Promise<void>;
 }
 export interface DreamResult {
     sessionsProcessed: number;

package/dist/providers/anthropic.js

@@ -1,5 +1,5 @@
 import Anthropic from "@anthropic-ai/sdk";
-import { CircuitBreaker, normalizeToolCall } from "./base.js";
+import { CircuitBreaker, normalizeToolCall, toAnthropicContent } from "./base.js";
 export class AnthropicProvider {
     model;
     client;
@@ -24,7 +24,7 @@ export class AnthropicProvider {
         if (this.circuit.isOpen())
             throw new Error("Circuit breaker open");
         const system = messages.filter(m => m.role === "system").map(m => m.content).join("\n\n");
-        const msgs = messages.filter(m => m.role !== "system").map(m => ({ role: m.role, content: m.content }));
+        const msgs = messages.filter(m => m.role !== "system").map(m => ({ role: m.role, content: toAnthropicContent(m) }));
         let lastErr;
         for (let i = 0; i < this.maxRetries; i++) {
             try {
@@ -60,7 +60,7 @@ export class AnthropicProvider {
     }
     async *stream(messages, tools, extensions) {
         const system = messages.filter(m => m.role === "system").map(m => m.content).join("\n\n");
-        const msgs = messages.filter(m => m.role !== "system").map(m => ({ role: m.role, content: m.content }));
+        const msgs = messages.filter(m => m.role !== "system").map(m => ({ role: m.role, content: toAnthropicContent(m) }));
         const toolBlocks = {};
         const stream = this.client.messages.stream({
             model: this.model,

package/dist/providers/base.d.ts

@@ -13,3 +13,6 @@ export declare function normalizeToolCall(id: string, name: string, args: unknow
     name: string;
     arguments: string;
 } | null;
+import type { Message } from "../types.js";
+export declare function toAnthropicContent(msg: Message): string | Array<Record<string, unknown>>;
+export declare function toOpenAIContent(msg: Message): string | Array<Record<string, unknown>>;