@deepstrike/sdk 0.1.1

package/README.md

@@ -0,0 +1,296 @@
+# DeepStrike Node.js SDK
+
+Agent framework built on a Rust kernel. The kernel handles loop control, context compression, skill selection, and termination — the SDK handles all I/O.
+
+## Install
+
+```bash
+npm install @deepstrike/sdk
+```
+
+Requires Node.js 18+. The Rust kernel is distributed as a pre-built native addon (`@deepstrike/core`).
+
+---
+
+## Quick start
+
+```typescript
+import { Agent, AnthropicProvider, tool } from "@deepstrike/sdk"
+
+const add = tool("add", "Add two numbers.", {
+  type: "object",
+  properties: { x: { type: "number" }, y: { type: "number" } },
+  required: ["x", "y"],
+}, async ({ x, y }) => String((x as number) + (y as number)))
+
+const agent = new Agent(
+  new AnthropicProvider("sk-..."),
+  { maxTokens: 32_000, maxTurns: 10 },
+)
+agent.register(add)
+
+await agent.run("What is 2 + 3?")
+```
+
+Streaming:
+
+```typescript
+for await (const event of agent.runStreaming("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 === "done") console.log(`\ndone in ${event.iterations} turns (${event.status})`)
+}
+```
+
+---
+
+## Architecture
+
+```
+src/
+├── index.ts          # Public exports
+├── agent.ts          # Agent — top-level entry point
+├── types.ts          # Shared type definitions
+├── providers/        # LLM adapters (HTTP + streaming)
+├── tools/            # tool() helper, executeTools, built-ins
+├── skills/           # SkillLoader — .md file loading
+├── memory/           # WorkingMemory + MemorySource/Extractor interfaces
+├── knowledge/        # KnowledgeSource interface
+├── harness/          # SinglePassHarness, EvalLoopHarness, QualityGate
+├── signals/          # RuntimeSignal, SignalSource, ScheduledPrompt
+└── safety/           # PermissionManager
+```
+
+The kernel (`@deepstrike/core`, Rust/NAPI) owns:
+- `LoopStateMachine` — drives `call_llm → execute_tools → load_skills → done`
+- `ContextEngine` — 5-partition context with pressure-based compression
+- `Governance` — tool veto authority
+- `SignalRouter` — external interrupt queue
+
+---
+
+## Providers
+
+| Class | Backend | Notes |
+|-------|---------|-------|
+| `AnthropicProvider` | Anthropic API | Native SSE, `ThinkingDelta` support |
+| `OpenAIProvider` | OpenAI API | SSE tool-call accumulation |
+| `QwenProvider` | DashScope | `enable_thinking` via extensions |
+| `DeepSeekProvider` | DeepSeek API | Reasoner models strip tools automatically |
+| `MiniMaxProvider` | MiniMax API | M1 reasoning via `expose_reasoning` |
+| `OllamaProvider` | Local Ollama | `http://localhost:11434` default |
+
+```typescript
+import { AnthropicProvider } from "@deepstrike/sdk"
+
+const provider = new AnthropicProvider("sk-...", "claude-opus-4-7", {
+  maxRetries: 5,
+  baseDelay: 2000,
+})
+```
+
+Thinking / reasoning:
+
+```typescript
+for await (const event of agent.runStreaming("...", undefined, { enable_thinking: true })) {
+  if (event.type === "thinking_delta") process.stdout.write(event.delta)
+}
+```
+
+---
+
+## Tools
+
+```typescript
+import { tool, Agent } from "@deepstrike/sdk"
+
+const search = tool("search", "Search the knowledge base.", {
+  type: "object",
+  properties: { query: { type: "string" }, topK: { type: "number" } },
+  required: ["query"],
+}, async ({ query, topK }) => mySearch(query as string, topK as number))
+
+agent.register(search)
+agent.unregister("search")
+agent.blockTool("bash")   // governance veto — permanent for this agent instance
+```
+
+Built-in tools: `readFile`.
+
+---
+
+## Skills
+
+Skills are `.md` files with YAML frontmatter. The kernel selects and injects them automatically.
+
+```markdown
+---
+name: debug
+description: Step-by-step debugging guide
+when_to_use: error, traceback, exception
+effort: 2
+estimated_tokens: 800
+---
+
+## Debug protocol
+1. Read the traceback carefully ...
+```
+
+```typescript
+import { Agent, SkillLoader } from "@deepstrike/sdk"
+
+const loader = new SkillLoader("~/.deepstrike/skills")
+const agent = new Agent(provider, { maxTokens: 32_000, maxTurns: 10, skillLoader: loader })
+```
+
+---
+
+## Memory
+
+Implement `MemorySource` to inject persistent context before a run, and `MemoryExtractor` to persist what was learned after.
+
+```typescript
+import type { MemorySource, MemoryExtractor } from "@deepstrike/sdk"
+
+class MyMemorySource implements MemorySource {
+  async load(goal: string): Promise<string[]> {
+    return db.query(goal)
+  }
+}
+
+class MyMemoryExtractor implements MemoryExtractor {
+  async extract(goal: string, finalText: string, turns: number): Promise<void> {
+    await db.save(goal, finalText)
+  }
+}
+
+const agent = new Agent(provider, {
+  maxTokens: 32_000,
+  maxTurns: 10,
+  memorySource: new MyMemorySource(),
+  memoryExtractor: new MyMemoryExtractor(),
+})
+```
+
+`WorkingMemory` is an in-process scratch pad for within-run state:
+
+```typescript
+import { WorkingMemory } from "@deepstrike/sdk"
+
+const mem = new WorkingMemory()
+mem.set("step", 1)
+mem.get("step")   // 1
+```
+
+---
+
+## Knowledge
+
+Inject run-scoped evidence (RAG results, API responses) without polluting long-term memory:
+
+```typescript
+import type { KnowledgeSource } from "@deepstrike/sdk"
+
+class VectorSearch implements KnowledgeSource {
+  async retrieve(goal: string, topK = 5): Promise<string[]> {
+    return vectorDb.search(goal, topK)
+  }
+}
+
+const agent = new Agent(provider, {
+  maxTokens: 32_000,
+  maxTurns: 10,
+  knowledgeSource: new VectorSearch(),
+})
+```
+
+Snippets are prepended as a system message before the first LLM call.
+
+---
+
+## Harness
+
+Control how runs are attempted:
+
+```typescript
+import { Agent, SinglePassHarness, EvalLoopHarness, HarnessRequest } from "@deepstrike/sdk"
+import type { QualityGate, HarnessOutcome } from "@deepstrike/sdk"
+
+// Single pass
+const harness = new SinglePassHarness(agent)
+const outcome = await harness.run({ goal: "Write a haiku" })
+
+// Eval loop — retry until QualityGate passes (max 3 attempts)
+class LengthGate implements QualityGate {
+  async evaluate(request: HarnessRequest, outcome: HarnessOutcome): Promise<boolean> {
+    return outcome.result.length > 50
+  }
+}
+
+const evalHarness = new EvalLoopHarness(agent, new LengthGate(), 3)
+const result = await evalHarness.run({ goal: "Write a haiku" })
+console.log(result.passed, result.iterations)
+```
+
+---
+
+## Signals & interrupts
+
+```typescript
+import { ScheduledPrompt } from "@deepstrike/sdk"
+import type { SignalSource, RuntimeSignal } from "@deepstrike/sdk"
+
+// Interrupt a running agent
+setTimeout(() => agent.interrupt(), 30_000)
+
+// Convert a scheduled prompt to a RuntimeSignal
+const prompt = new ScheduledPrompt("Daily standup summary", 1_700_000_000_000)
+const signal = prompt.toSignal()
+// signal.kind === "scheduled"
+// signal.payload === { goal: "Daily standup summary", criteria: [], runAtMs: ... }
+```
+
+Implement `SignalSource` to feed signals from any external source:
+
+```typescript
+class WebhookSource implements SignalSource {
+  async nextSignal(): Promise<RuntimeSignal | null> {
+    const event = await webhookQueue.get()
+    return { kind: "external", payload: event }
+  }
+}
+```
+
+---
+
+## Permissions
+
+```typescript
+import { PermissionManager, PermissionMode } from "@deepstrike/sdk"
+
+const pm = new PermissionManager(PermissionMode.DEFAULT)
+pm.grant("bash", "execute")
+pm.grant("fs", "*")          // wildcard: all actions on fs
+pm.revoke("bash", "execute")
+
+const decision = pm.evaluate("bash", "execute")
+decision.allowed   // boolean
+decision.reason    // string
+```
+
+Modes: `DEFAULT` (evaluate grants), `PLAN` (block all), `AUTO` (allow all).
+
+---
+
+## Stream events
+
+| Event type | Fields |
+|------------|--------|
+| `text_delta` | `delta: string` |
+| `thinking_delta` | `delta: string` |
+| `tool_call` | `id, name, arguments` |
+| `tool_result` | `callId, name, content, isError` |
+| `done` | `iterations, totalTokens, status` |
+| `error` | `message: string` |
+
+`status` mirrors the kernel termination reason: `completed` / `max_turns` / `token_budget` / `timeout` / `user_abort` / `error`.

package/dist/agent.d.ts

@@ -0,0 +1,62 @@
+import type { LLMProvider, StreamEvent } from "./types.js";
+import type { RegisteredTool } from "./tools/index.js";
+import type { DreamStore, DreamResult } from "./memory/protocols.js";
+import type { KnowledgeSource } from "./knowledge/source.js";
+import type { SignalSource } from "./signals/types.js";
+export interface AgentOptions {
+    maxTokens: number;
+    maxTurns?: number;
+    timeoutMs?: number;
+    extensions?: Record<string, unknown>;
+    /**
+     * Directory containing skill `.md` files. The kernel will auto-inject a
+     * `skill` meta-tool so the model can load any skill by name on demand.
+     */
+    skillDir?: string;
+    knowledgeSource?: KnowledgeSource;
+    signalSource?: SignalSource;
+    /** Backing store for the idle dreaming pipeline. Required to call `Agent.dream()`. */
+    dreamStore?: DreamStore;
+    /**
+     * Stable identifier for this agent. Required to enable in-session memory retrieval
+     * when `dreamStore` is configured — the kernel injects a `memory` meta-tool and
+     * the SDK calls `dreamStore.search(agentId, query)` on demand.
+     */
+    agentId?: string;
+    /** Governance instance from @deepstrike/core for permission checks on tool calls. */
+    governance?: {
+        evaluate(toolName: string, args: string): {
+            kind: string;
+            reason?: string;
+        };
+    };
+}
+export declare class Agent {
+    private readonly provider;
+    private readonly options;
+    private tools;
+    private blockedTools;
+    private extensions;
+    private skillDir?;
+    private knowledgeSource?;
+    private signalSource?;
+    private dreamStore?;
+    private interrupted;
+    private pendingInterrupt;
+    constructor(provider: LLMProvider, options: AgentOptions);
+    interrupt(): void;
+    register(...tools: RegisteredTool[]): this;
+    unregister(name: string): this;
+    blockTool(name: string): this;
+    run(goal: string, criteria?: string[], extensions?: Record<string, unknown>): Promise<string>;
+    runStreaming(goal: string, criteria?: string[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    /**
+     * Trigger an idle dreaming cycle for the given agent.
+     *
+     * 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)
+     */
+    dream(agentId: string, nowMs?: number): Promise<DreamResult>;
+}

package/dist/agent.js

@@ -0,0 +1,321 @@
+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");
+}
+export class Agent {
+    provider;
+    options;
+    tools = new Map();
+    blockedTools = new Set();
+    extensions;
+    skillDir;
+    knowledgeSource;
+    signalSource;
+    dreamStore;
+    interrupted = false;
+    pendingInterrupt = false;
+    constructor(provider, options) {
+        this.provider = provider;
+        this.options = options;
+        this.extensions = options.extensions ?? {};
+        this.skillDir = options.skillDir;
+        this.knowledgeSource = options.knowledgeSource;
+        this.signalSource = options.signalSource;
+        this.dreamStore = options.dreamStore;
+    }
+    interrupt() {
+        this.interrupted = true;
+    }
+    register(...tools) {
+        for (const t of tools)
+            this.tools.set(t.schema.name, t);
+        return this;
+    }
+    unregister(name) {
+        this.tools.delete(name);
+        return this;
+    }
+    blockTool(name) {
+        this.blockedTools.add(name);
+        return this;
+    }
+    async run(goal, criteria, extensions) {
+        let result;
+        for await (const evt of this.runStreaming(goal, criteria, extensions)) {
+            if (evt.type === "done")
+                result = evt;
+        }
+        return result ? `done in ${result.iterations} turns (${result.status})` : "done";
+    }
+    async *runStreaming(goal, criteria, extensions) {
+        this.interrupted = false;
+        this.pendingInterrupt = false;
+        const kernel = await loadKernel();
+        const ext = { ...this.extensions, ...(extensions ?? {}) };
+        const sm = new kernel.LoopStateMachine({
+            maxTokens: this.options.maxTokens,
+            maxTurns: this.options.maxTurns ?? 25,
+            timeoutMs: this.options.timeoutMs,
+        });
+        // Create a per-run SignalRouter so dedup state doesn't leak across 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.skillDir) {
+            const skillMetas = await scanSkillDir(this.skillDir);
+            sm.setAvailableSkills(skillMetas.map(m => ({
+                name: m.name,
+                description: m.description,
+                whenToUse: m.whenToUse,
+                effort: m.effort,
+                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 = "";
+        while (!sm.isTerminal()) {
+            if (this.interrupted) {
+                action = sm.feedTimeout();
+                break;
+            }
+            if (this.pendingInterrupt) {
+                this.pendingInterrupt = false;
+                action = sm.feedTimeout();
+                break;
+            }
+            // Poll signal source and route through kernel SignalRouter
+            if (this.signalSource) {
+                const sig = await this.signalSource.nextSignal();
+                if (sig) {
+                    const kernelSig = {
+                        id: crypto.randomUUID(),
+                        source: sig.source ?? "custom",
+                        signalType: sig.signalType ?? "event",
+                        urgency: sig.urgency ?? (sig.kind === "interrupt" ? "critical" : "normal"),
+                        summary: String(sig.payload?.goal ?? sig.kind),
+                        payload: JSON.stringify(sig.payload ?? {}),
+                        dedupeKey: sig.dedupeKey ?? null,
+                        timestampMs: Date.now(),
+                    };
+                    const disposition = router.ingest(kernelSig, action.kind === "execute_tools");
+                    if (disposition === "interrupt_now") {
+                        action = sm.feedTimeout();
+                        break;
+                    }
+                    if (disposition === "interrupt") {
+                        this.pendingInterrupt = true;
+                    }
+                    // "queue" → buffered; "observe" / "ignore" / "dropped" → no action
+                }
+            }
+            sm.takeObservations();
+            if (action.kind === "call_llm") {
+                finalText = "";
+                const finalToolCalls = [];
+                const messages = (action.messages ?? []);
+                const tools = (action.tools ?? []);
+                try {
+                    for await (const evt of this.provider.stream(messages, tools, Object.keys(ext).length ? ext : undefined)) {
+                        yield evt;
+                        if (evt.type === "text_delta")
+                            finalText += evt.delta;
+                        else if (evt.type === "tool_call") {
+                            const tc = evt;
+                            finalToolCalls.push({ id: tc.id, name: tc.name, arguments: JSON.stringify(tc.arguments) });
+                        }
+                    }
+                }
+                catch (err) {
+                    yield { type: "error", message: String(err) };
+                    action = sm.feedTimeout();
+                    break;
+                }
+                action = sm.feedLlmResponse({ role: "assistant", content: finalText, toolCalls: finalToolCalls });
+            }
+            else if (action.kind === "execute_tools") {
+                const allCalls = action.calls ?? [];
+                // Governance check: blocked tools + GovernancePipeline
+                const permittedCalls = [];
+                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}` };
+                            continue;
+                        }
+                        if (verdict.kind === "ask_user") {
+                            yield { type: "permission_request", callId: c.id, toolName: c.name, arguments: c.arguments, reason: verdict.reason };
+                            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 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 };
+                    }))
+                    : skillCalls.map((c) => ({ callId: c.id, name: c.name, output: "No skill directory configured.", isError: true }));
+                const memoryResults = (this.dreamStore && this.options.agentId)
+                    ? await Promise.all(memoryCalls.map(async (c) => {
+                        const args = tryParseJson(c.arguments);
+                        const query = String(args?.query ?? "");
+                        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")
+                            : "No relevant memories found.";
+                        return { callId: c.id, name: c.name, output, isError: false };
+                    }))
+                    : memoryCalls.map((c) => ({ callId: c.id, name: c.name, output: "Memory retrieval not configured.", isError: true }));
+                const knowledgeResults = this.knowledgeSource
+                    ? await Promise.all(knowledgeCalls.map(async (c) => {
+                        const args = tryParseJson(c.arguments);
+                        const query = String(args?.query ?? "");
+                        const topK = typeof args?.top_k === "number" ? args.top_k : 5;
+                        const snippets = await this.knowledgeSource.retrieve(query, topK);
+                        const output = snippets.length ? snippets.join("\n---\n") : "No relevant knowledge found.";
+                        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 ?? "";
+                    yield { type: "tool_result", callId: r.callId, name, content: r.output, isError: r.isError };
+                }
+                action = sm.feedToolResults([
+                    ...skillResults,
+                    ...memoryResults,
+                    ...knowledgeResults,
+                    ...results.map(r => ({ callId: r.callId, output: r.output, isError: r.isError })),
+                ]);
+            }
+            else if (action.kind === "done") {
+                break;
+            }
+        }
+        const result = action.result;
+        yield {
+            type: "done",
+            iterations: result?.turnsUsed ?? 0,
+            totalTokens: Number(result?.totalTokensUsed ?? 0),
+            status: result?.termination ?? "error",
+        };
+    }
+    /**
+     * Trigger an idle dreaming cycle for the given agent.
+     *
+     * 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)
+     */
+    async dream(agentId, nowMs = Date.now()) {
+        if (!this.dreamStore)
+            throw new Error("dreamStore not configured on AgentOptions");
+        const kernel = await loadKernel();
+        const sessions = await this.dreamStore.loadSessions(agentId);
+        const existingMemories = await this.dreamStore.loadMemories(agentId);
+        if (!sessions.length) {
+            return { sessionsProcessed: 0, insightsExtracted: 0, entriesAdded: 0, entriesRemoved: 0 };
+        }
+        const kernelSessions = sessions.map(s => ({
+            sessionId: s.sessionId,
+            agentId: s.agentId,
+            messages: s.messages.map(m => ({
+                role: m.role,
+                content: m.content,
+                tokenCount: m.tokenCount,
+                toolCalls: (m.toolCalls ?? []).map(tc => ({
+                    id: tc.id, name: tc.name, arguments: tc.arguments,
+                })),
+            })),
+            metadata: JSON.stringify(s.metadata ?? null),
+            createdAtMs: s.createdAtMs,
+            updatedAtMs: s.updatedAtMs,
+        }));
+        const kernelMemories = existingMemories.map(e => ({
+            text: e.text,
+            score: e.score,
+            metadata: JSON.stringify(e.metadata ?? null),
+        }));
+        const pipeline = new kernel.IdlePipeline(agentId);
+        const action1 = pipeline.feedTrigger(kernelSessions, kernelMemories, nowMs);
+        if (action1.kind === "noop") {
+            return { sessionsProcessed: 0, insightsExtracted: 0, entriesAdded: 0, entriesRemoved: 0 };
+        }
+        if (action1.kind !== "synthesize_insights") {
+            throw new Error(`unexpected action after feedTrigger: ${action1.kind}`);
+        }
+        let synthesisText = "";
+        for await (const evt of this.provider.stream((action1.messages ?? []), [], undefined)) {
+            if (evt.type === "text_delta")
+                synthesisText += evt.delta;
+        }
+        const action2 = pipeline.feedSynthesisResult(synthesisText);
+        if (action2.kind !== "commit_memories") {
+            throw new Error(`unexpected action after feedSynthesisResult: ${action2.kind}`);
+        }
+        const cr = action2.curationResult;
+        const rr = action2.runResult;
+        const dsResult = {
+            toAdd: (cr.toAdd ?? []).map((e) => ({
+                text: e.text,
+                score: e.score,
+                metadata: tryParseJson(e.metadata),
+            })),
+            toRemoveIndices: (cr.toRemoveIndices ?? []).map(Number),
+            stats: {
+                insightsProcessed: cr.stats?.insightsProcessed ?? 0,
+                duplicatesRemoved: cr.stats?.duplicatesRemoved ?? 0,
+                conflictsResolved: cr.stats?.conflictsResolved ?? 0,
+                entriesAdded: cr.stats?.entriesAdded ?? 0,
+            },
+        };
+        await this.dreamStore.commit(agentId, dsResult, existingMemories);
+        return {
+            sessionsProcessed: rr.sessionsProcessed,
+            insightsExtracted: rr.insightsExtracted,
+            entriesAdded: cr.stats?.entriesAdded ?? 0,
+            entriesRemoved: (cr.toRemoveIndices ?? []).length,
+        };
+    }
+}
+function tryParseJson(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return null;
+    }
+}