@veedubin/boomerang-v3 0.3.4 → 0.4.0

package/.opencode/agents/boomerang-agent-builder.md

@@ -18,7 +18,6 @@ permission:
   tool:
     "memini-ai-dev_*": allow
     "searxng_*": allow
-    "sequential-thinking_*": allow
     "markitdown_*": allow
     "github-mcp_*": allow
     "playwright_*": allow

package/.opencode/agents/boomerang-architect.md

@@ -18,7 +18,6 @@ permission:
   tool:
     "memini-ai-dev_*": allow
     "searxng_*": allow
-    "sequential-thinking_*": allow
     "markitdown_*": allow
     "github-mcp_*": allow
     "playwright_*": allow
@@ -49,7 +48,7 @@ You are the **Boomerang Architect** - the authority on design decisions, archite
 ## MANDATORY MEMORY PROTOCOL
 
 1. **Query memini-ai FIRST** - `memini-ai-dev_query_memories` for previous decisions
-2. **Use sequential-thinking** - `sequential-thinking_sequentialthinking` for complex analysis
+2. **Use thought chains** - `memini-ai-dev_add_thought` for complex analysis
 3. **Query knowledge graph** - `memini-ai-dev_query_kg` for entity relationships
 4. **Save when complete** - `memini-ai-dev_add_memory` with key decisions
 

package/.opencode/agents/boomerang-coder.md

@@ -18,7 +18,6 @@ permission:
   tool:
     "memini-ai-dev_*": allow
     "searxng_*": allow
-    "sequential-thinking_*": allow
     "markitdown_*": allow
     "github-mcp_*": allow
     "playwright_*": allow
@@ -49,7 +48,7 @@ Implement features, fix bugs, and write tests efficiently using the Context Pack
 ## MANDATORY MEMORY PROTOCOL
 
 1. **Query memini-ai FIRST** - Call `memini-ai-dev_query_memories` before doing ANY work
-2. **Use sequential-thinking** - Call `sequential-thinking_sequentialthinking` for complex tasks
+2. **Use thought chains** - Call `memini-ai-dev_add_thought` for complex tasks
 3. **Save when complete** - Call `memini-ai-dev_add_memory` with a summary of your work
 
 ## Context Requirements

package/.opencode/agents/boomerang-explorer.md

@@ -1,7 +1,7 @@
 ---
-description: Boomerang Explorer v3 - Fast file finding using devstral-2:cloud (Ollama Cloud) with memini-ai semantic search.
+description: Boomerang Explorer v3 - Fast file finding using devstral-2:123b-cloud (Ollama Cloud) with memini-ai semantic search.
 mode: subagent
-model: ollama-cloud/devstral-2:cloud
+model: ollama-cloud/devstral-2:123b-cloud
 steps: 30
 permission:
   read:
@@ -18,7 +18,6 @@ permission:
   tool:
     "memini-ai-dev_*": allow
     "searxng_*": allow
-    "sequential-thinking_*": allow
     "markitdown_*": allow
     "github-mcp_*": allow
     "playwright_*": allow

package/.opencode/agents/boomerang-git.md

@@ -18,7 +18,6 @@ permission:
   tool:
     "memini-ai-dev_*": allow
     "searxng_*": allow
-    "sequential-thinking_*": allow
     "markitdown_*": allow
     "github-mcp_*": allow
     "playwright_*": allow

package/.opencode/agents/boomerang-handoff.md

@@ -18,7 +18,6 @@ permission:
   tool:
     "memini-ai-dev_*": allow
     "searxng_*": allow
-    "sequential-thinking_*": allow
     "markitdown_*": allow
     "github-mcp_*": allow
     "playwright_*": allow

package/.opencode/agents/boomerang-init.md

@@ -18,7 +18,6 @@ permission:
   tool:
     "memini-ai-dev_*": allow
     "searxng_*": allow
-    "sequential-thinking_*": allow
     "markitdown_*": allow
     "github-mcp_*": allow
     "playwright_*": allow

package/.opencode/agents/boomerang-linter.md

@@ -18,7 +18,6 @@ permission:
   tool:
     "memini-ai-dev_*": allow
     "searxng_*": allow
-    "sequential-thinking_*": allow
     "markitdown_*": allow
     "github-mcp_*": allow
     "playwright_*": allow

package/.opencode/agents/boomerang-release.md

@@ -18,7 +18,6 @@ permission:
   tool:
     "memini-ai-dev_*": allow
     "searxng_*": allow
-    "sequential-thinking_*": allow
     "markitdown_*": allow
     "github-mcp_*": allow
     "playwright_*": allow

package/.opencode/agents/boomerang-scraper.md

@@ -18,7 +18,6 @@ permission:
   tool:
     "memini-ai-dev_*": allow
     "searxng_*": allow
-    "sequential-thinking_*": allow
     "markitdown_*": allow
     "github-mcp_*": allow
     "playwright_*": allow

package/.opencode/agents/boomerang-tester.md

@@ -18,7 +18,6 @@ permission:
   tool:
     "memini-ai-dev_*": allow
     "searxng_*": allow
-    "sequential-thinking_*": allow
     "markitdown_*": allow
     "github-mcp_*": allow
     "playwright_*": allow

package/.opencode/agents/boomerang-writer.md

@@ -1,7 +1,7 @@
 ---
-description: Boomerang Writer v3 - Documentation specialist using gemma4:cloud (Ollama Cloud) with memini-ai for context.
+description: Boomerang Writer v3 - Documentation specialist using gemma4:31b-cloud (Ollama Cloud) with memini-ai for context.
 mode: subagent
-model: ollama-cloud/gemma4:cloud
+model: ollama-cloud/gemma4:31b-cloud
 steps: 40
 permission:
   read:
@@ -18,7 +18,6 @@ permission:
   tool:
     "memini-ai-dev_*": allow
     "searxng_*": allow
-    "sequential-thinking_*": allow
     "markitdown_*": allow
     "github-mcp_*": allow
     "playwright_*": allow

package/.opencode/agents/boomerang.md

@@ -18,7 +18,6 @@ permission:
   tool:
     "memini-ai-dev_*": allow
     "searxng_*": allow
-    "sequential-thinking_*": allow
     "markitdown_*": allow
     "github-mcp_*": allow
     "playwright_*": allow
@@ -72,8 +71,8 @@ You are the **Boomerang v3 Orchestrator** - the central coordinator using memini
 Immediately call `memini-ai-dev_query_memories` with the user's request.
 Do not write any text before calling this tool.
 
-### STEP 2: Use sequential thinking (MANDATORY SECOND ACTION)
-Immediately call `sequential-thinking_sequentialthinking` with your analysis.
+### STEP 2: Use thought chains (MANDATORY SECOND ACTION)
+Immediately call `memini-ai-dev_add_thought` with your analysis. Note: This creates a `thinkingChainId` that must be passed to sub-agents in their Context Package.
 
 ### STEP 3: Plan (MANDATORY unless explicitly waived)
 Create an implementation plan UNLESS user says "skip planning", "just do it", "/boomerang-handoff", "do a handoff", or "no plan needed".

package/.opencode/agents/mcp-specialist.md

@@ -18,7 +18,6 @@ permission:
   tool:
     "memini-ai-dev_*": allow
     "searxng_*": allow
-    "sequential-thinking_*": allow
     "markitdown_*": allow
     "github-mcp_*": allow
     "playwright_*": allow

package/.opencode/agents/researcher.md

@@ -18,7 +18,6 @@ permission:
   tool:
     "memini-ai-dev_*": allow
     "searxng_*": allow
-    "sequential-thinking_*": allow
     "markitdown_*": allow
     "github-mcp_*": allow
     "playwright_*": allow

package/AGENTS.md

@@ -19,11 +19,11 @@ Failure to use memini-ai causes context loss, duplicate work, and wasted tokens.
 | **boomerang** | boomerang-orchestrator | kimi-k2.6:cloud | Specifically built for swarm-based task orchestration and proactive autonomous delegation. |
 | **boomerang-coder** | boomerang-coder | glm-5.1:cloud | Flagship for agentic engineering; achieves SOTA on SWE-Bench Pro for complex, multi-file generation. |
 | **boomerang-architect** | boomerang-architect | deepseek-v4-pro:cloud | Offers frontier reasoning with dedicated "thinking modes" for analyzing complex architectural trade-offs. |
-| **boomerang-explorer** | boomerang-explorer | devstral-2:cloud | Explicitly designed to navigate codebases, trace dependencies, and map repository structures. |
+| **boomerang-explorer** | boomerang-explorer | devstral-2:123b-cloud | Explicitly designed to navigate codebases, trace dependencies, and map repository structures. |
 | **boomerang-tester** | boomerang-tester | deepseek-v4-flash:cloud | Massive 1M context window for ingesting deep error logs and codebase context quickly and efficiently. |
 | **boomerang-linter** | boomerang-linter | qwen3-coder-next:cloud | Highly optimized for agentic coding workflows; blazing fast for syntax formatting and style checks. |
 | **boomerang-git** | boomerang-git | minimax-m2.7:cloud | Fast and highly reliable for standard professional productivity and executing structured terminal commands. |
-| **boomerang-writer** | boomerang-writer | gemma4:cloud | Frontier-level instruction following; excels at translating technical logic into clean, readable Markdown. |
+| **boomerang-writer** | boomerang-writer | gemma4:31b-cloud | Frontier-level instruction following; excels at translating technical logic into clean, readable Markdown. |
 | **boomerang-scraper** | boomerang-scraper | qwen3.5:cloud | Strong, lightweight generalist with excellent tool-use capabilities for reliable data extraction. |
 | **boomerang-release** | boomerang-release | devstral-small-2:cloud | Fast 24B model perfect for targeted automation tasks like bumping versions and summarizing changelogs. |
 | **boomerang-agent-builder** | boomerang-agent-builder | glm-5.1:cloud | Excels at long-horizon tasks and ambiguous problems; ideal for writing and optimizing new agent logic. |
@@ -77,12 +77,12 @@ The orchestrator MUST delegate based on these rules. No exceptions.
 |-----------|------------------|-------|-------------------|
 | Complex planning / orchestration | `boomerang` | kimi-k2.6:cloud | `general` |
 | Architecture / design decisions | `boomerang-architect` | deepseek-v4-pro:cloud | `general`, `boomerang-coder` |
-| Documentation writing | `boomerang-writer` | gemma4:cloud | `general` |
+| Documentation writing | `boomerang-writer` | gemma4:31b-cloud | `general` |
 | Session initialization | `boomerang-init` | kimi-k2.6:cloud | Everything else |
 | Session wrap-up / handoff | `boomerang-handoff` | kimi-k2.6:cloud | Everything else |
 | Skill/agent creation | `boomerang-agent-builder` | glm-5.1:cloud | `general` |
 | Fast code generation / bug fixes | `boomerang-coder` | glm-5.1:cloud | `general`, `boomerang-explorer` |
-| Code exploration / finding files | `boomerang-explorer` | devstral-2:cloud | Everything else |
+| Code exploration / finding files | `boomerang-explorer` | devstral-2:123b-cloud | Everything else |
 | Writing / running tests | `boomerang-tester` | deepseek-v4-flash:cloud | `general`, `boomerang-coder` |
 | Linting / formatting | `boomerang-linter` | qwen3-coder-next:cloud | Everything else |
 | Git operations | `boomerang-git` | minimax-m2.7:cloud | Everything else |
@@ -139,7 +139,7 @@ All agents **MUST** follow the **8-Step Boomerang Protocol** — enforcement is
 ### 8-Step Protocol (MANDATORY)
 
 1. **Query Memory** — `memini-ai-dev_query_memories` FIRST
-2. **Think** — `sequential-thinking_sequentialthinking` for complex tasks
+2. **Think** — `memini-ai-dev_add_thought` for complex tasks
 3. **Plan** — Create/refine implementation plan (MANDATORY unless user explicitly waives)
 4. **Delegate** — OpenCode executes selected agent with Context Package
 5. **Git Check** — Verify working tree state before code changes
@@ -209,7 +209,7 @@ Boomerang v3 uses **memini-ai** for memory — a Python-based semantic memory se
 
 All agents SHOULD:
 1. **Query memory FIRST** — `memini-ai-dev_query_memories` before work
-2. **Use sequential-thinking** — For complex tasks
+2. **Use thought chains** — For complex tasks
 3. **Save results** — `memini-ai-dev_add_memory` when complete
 
 ### Trust-Weighted Memory
@@ -330,7 +330,7 @@ IDLE → MEMORY_QUERY → SEQUENTIAL_THINK → PLAN → DELEGATE → GIT_CHECK
 ### 8-Step Mandatory Protocol
 
 1. **MEMORY_QUERY** — MUST call `memini-ai-dev_query_memories` first
-2. **SEQUENTIAL_THINK** — MUST call `sequential-thinking_sequentialthinking` for complex tasks
+2. **SEQUENTIAL_THINK** — MUST call `memini-ai-dev_add_thought` for complex tasks
 3. **PLAN** — MUST create plan or delegate to architect for build tasks
 4. **DELEGATE** — OpenCode handles agent execution
 5. **GIT_CHECK** — MUST verify working tree state before code changes

package/dist/context-buffer.js

@@ -0,0 +1,290 @@
+/**
+ * Context Buffer Middleware — Transparent orchestrator integration
+ * for capturing and restoring agent invocation context via memini-ai.
+ *
+ * This middleware wraps around agent dispatch in the orchestrator,
+ * saving invocation context (output, tool calls, decisions, errors)
+ * as segmented memories in memini-ai. It also provides before/after
+ * hooks for telemetry and context injection.
+ *
+ * Design:
+ * - Segmenting: ~4 chars per token. Split at ~50K tokens = ~200K chars.
+ * - Memory metadata includes session_id, agent_name, segment_index.
+ * - All segments of an invocation are linked via DERIVED_FROM relationships.
+ * - The middleware is OPTIONAL — if not configured, the orchestrator
+ *   operates identically to before this integration.
+ */
+import { TelemetryClient } from './telemetry-client.js';
+/** Estimated ratio: 1 token ≈ 4 characters. */
+const CHARS_PER_TOKEN = 4;
+/**
+ * Context buffer middleware that works transparently with the existing
+ * orchestrator to capture, segment, and restore agent invocation context.
+ */
+export class ContextBufferMiddleware {
+    sessionId;
+    config;
+    memini;
+    telemetry;
+    segmentIds = [];
+    constructor(sessionId, config) {
+        this.sessionId = sessionId;
+        this.config = config;
+        this.memini = config.meminiClient;
+        this.telemetry = new TelemetryClient(config.telemetryEndpoint);
+    }
+    /**
+     * Called BEFORE an agent runs.
+     *
+     * Queries memini-ai for relevant context based on the task description,
+     * injects it into the agent's context package, and emits a start event
+     * to telemetry.
+     *
+     * @returns A context string to inject into the agent invocation, or
+     *          an empty string if no relevant context is found.
+     */
+    async beforeInvocation(agentName, task, context) {
+        const _startTime = Date.now();
+        await this.ensureSessionRow(task);
+        await this.emitTelemetry({
+            event_type: 'invocation_start',
+            session_id: this.sessionId,
+            agent_name: agentName,
+            metadata: { task, contextProvided: context !== undefined },
+        });
+        let injectedContext = '';
+        try {
+            const results = await this.memini.search(task, {
+                topK: 5,
+                strategy: 'TIERED',
+            });
+            if (results.length > 0) {
+                const contextParts = results
+                    .slice(0, 5)
+                    .map((r) => `[trust=${r.entry.trustScore?.toFixed(2) ?? '0.50'}] ${r.entry.text}`)
+                    .join('\n\n---\n\n');
+                injectedContext = `\n## Relevant Context from Previous Sessions\n\n${contextParts}\n`;
+            }
+        }
+        catch (err) {
+            console.warn('[ContextBuffer] beforeInvocation search failed:', err);
+        }
+        return injectedContext;
+    }
+    /**
+     * Called AFTER an agent completes (or fails).
+     *
+     * Captures the full invocation payload, segments if needed, saves
+     * each segment to memini-ai, links them via relationships, and emits
+     * an end event to telemetry.
+     *
+     * @returns Array of memory IDs for the saved segments.
+     */
+    async afterInvocation(agentName, result, durationMs) {
+        const success = 'success' in result ? result.success : true;
+        const error = 'success' in result && !result.success ? result.error : undefined;
+        await this.emitTelemetry({
+            event_type: success ? 'invocation_end' : 'invocation_error',
+            session_id: this.sessionId,
+            agent_name: agentName,
+            duration_ms: durationMs,
+            success,
+            error_message: error,
+        });
+        const payload = this.buildPayload(agentName, result, durationMs);
+        const memoryIds = await this.saveContextSegments(agentName, payload);
+        this.segmentIds = memoryIds;
+        // Link segments to each other via DERIVED_FROM relationships
+        await this.linkSegments(memoryIds);
+        return memoryIds;
+    }
+    /**
+     * Get the memory IDs saved during the current session.
+     */
+    getSegmentIds() {
+        return [...this.segmentIds];
+    }
+    // ---------------------------------------------------------------------------
+    // Private helpers
+    // ---------------------------------------------------------------------------
+    /**
+     * Build an AgentContextPayload from a task result.
+     */
+    buildPayload(agentName, result, durationMs) {
+        const now = Date.now();
+        if ('success' in result && !result.success) {
+            return {
+                output: '',
+                toolCalls: [],
+                filesModified: [],
+                decisions: [],
+                errors: [result.error],
+                startTime: now - durationMs,
+                endTime: now,
+                durationMs,
+            };
+        }
+        const taskResult = result;
+        return {
+            output: taskResult.output ?? '',
+            toolCalls: taskResult.toolCalls ?? [],
+            filesModified: taskResult.filesModified ?? [],
+            decisions: taskResult.decisions ?? [],
+            errors: taskResult.errors ?? [],
+            startTime: now - durationMs,
+            endTime: now,
+            durationMs,
+        };
+    }
+    /**
+     * Save context segments to memini-ai.
+     * If the summary exceeds the segment threshold, it is split into
+     * multiple segments, each saved separately.
+     */
+    async saveContextSegments(agentName, payload) {
+        const summary = this.generateContextSummary(agentName, payload);
+        const thresholdChars = this.config.segmentThreshold * CHARS_PER_TOKEN;
+        const segments = this.splitIfNeeded(summary, thresholdChars);
+        const memoryIds = [];
+        for (let i = 0; i < segments.length; i++) {
+            const segment = segments[i];
+            try {
+                const entry = await this.memini.addMemory({
+                    text: segment,
+                    sourceType: 'boomerang',
+                    sourcePath: `context-buffer://${this.sessionId}/${agentName}`,
+                    metadataJson: JSON.stringify({
+                        type: 'context_segment',
+                        session_id: this.sessionId,
+                        agent_name: agentName,
+                        segment_index: i,
+                        total_segments: segments.length,
+                        files_modified: payload.filesModified,
+                        decisions: payload.decisions,
+                        errors: payload.errors,
+                        duration_ms: payload.durationMs,
+                        success: payload.errors.length === 0,
+                    }),
+                    sessionId: this.sessionId,
+                });
+                memoryIds.push(entry.id);
+            }
+            catch (err) {
+                console.warn(`[ContextBuffer] Failed to save segment ${i}/${segments.length}:`, err);
+            }
+        }
+        return memoryIds;
+    }
+    /**
+     * Link segments via DERIVED_FROM relationships in memini-ai.
+     * Each segment (except the first) derives from the previous one.
+     */
+    async linkSegments(memoryIds) {
+        if (memoryIds.length < 2) {
+            return;
+        }
+        for (let i = 1; i < memoryIds.length; i++) {
+            try {
+                await this.memini.createRelationship(memoryIds[i], memoryIds[i - 1], 'DERIVED_FROM', 0.9);
+            }
+            catch (err) {
+                console.warn(`[ContextBuffer] Failed to link segments ${i - 1} → ${i}:`, err);
+            }
+        }
+    }
+    /**
+     * Split content into segments if it exceeds the threshold.
+     * Tries to split on paragraph boundaries (double newlines).
+     */
+    splitIfNeeded(content, thresholdChars) {
+        if (content.length <= thresholdChars) {
+            return [content];
+        }
+        const segments = [];
+        let remaining = content;
+        while (remaining.length > 0) {
+            if (remaining.length <= thresholdChars) {
+                segments.push(remaining);
+                break;
+            }
+            // Find a paragraph boundary near the threshold
+            const searchStart = Math.max(0, thresholdChars - 1000);
+            const searchEnd = Math.min(remaining.length, thresholdChars + 1000);
+            const searchRegion = remaining.slice(searchStart, searchEnd);
+            const newlinePos = searchRegion.indexOf('\n\n');
+            if (newlinePos !== -1) {
+                const splitPos = searchStart + newlinePos + 2;
+                segments.push(remaining.slice(0, splitPos));
+                remaining = remaining.slice(splitPos);
+            }
+            else {
+                // No good boundary; hard split at threshold
+                segments.push(remaining.slice(0, thresholdChars));
+                remaining = remaining.slice(thresholdChars);
+            }
+        }
+        return segments;
+    }
+    /**
+     * Generate a human-readable context summary from the agent payload.
+     */
+    generateContextSummary(agentName, payload) {
+        const lines = [
+            `# Agent Invocation: ${agentName}`,
+            `Duration: ${payload.durationMs}ms`,
+            `Status: ${payload.errors.length === 0 ? 'SUCCESS' : 'FAILED'}`,
+            '',
+        ];
+        if (payload.output) {
+            lines.push('## Output');
+            lines.push(payload.output);
+            lines.push('');
+        }
+        if (payload.filesModified.length > 0) {
+            lines.push('## Files Modified');
+            for (const f of payload.filesModified) {
+                lines.push(`- ${f}`);
+            }
+            lines.push('');
+        }
+        if (payload.decisions.length > 0) {
+            lines.push('## Decisions');
+            for (const d of payload.decisions) {
+                lines.push(`- ${d}`);
+            }
+            lines.push('');
+        }
+        if (payload.toolCalls.length > 0) {
+            lines.push('## Tool Calls');
+            for (const tc of payload.toolCalls) {
+                lines.push(`- ${tc.name}(${JSON.stringify(tc.arguments).slice(0, 200)})`);
+            }
+            lines.push('');
+        }
+        if (payload.errors.length > 0) {
+            lines.push('## Errors');
+            for (const e of payload.errors) {
+                lines.push(`- ${e}`);
+            }
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Ensure a session row exists in telemetry.
+     */
+    async ensureSessionRow(task) {
+        try {
+            await this.telemetry.createSession(this.sessionId, 'default', task);
+        }
+        catch {
+            // Session may already exist; ignore errors
+        }
+    }
+    /**
+     * Emit a telemetry event. Fire-and-forget — errors are logged only.
+     */
+    async emitTelemetry(event) {
+        await this.telemetry.emit(event);
+    }
+}

package/dist/index.js

@@ -2,13 +2,17 @@
  * Boomerang v3 — Multi-agent orchestration plugin for OpenCode
  *
  * Exports:
- *   - orchestrator: Concurrency-aware orchestrator
+ *   - orchestrator: Concurrency-aware orchestrator with context buffer
  *   - plugin: Plugin metadata
  *   - concurrency: TaskLimiter, RetryExecutor, TimeoutEnforcer
+ *   - context-buffer: ContextBufferMiddleware
+ *   - telemetry: TelemetryClient
  *   - types: Core type definitions
  */
 export { BoomerangOrchestrator, createOrchestrator } from './orchestrator.js';
 export { TaskLimiter, executeWithRetry, executeWithTimeout, } from './concurrency/index.js';
+export { ContextBufferMiddleware } from './context-buffer.js';
+export { TelemetryClient } from './telemetry-client.js';
 export { TimeoutError, } from './types.js';
 export const orchestrator = {
     name: 'boomerang-v3',

package/dist/memini-client/index.js

@@ -552,7 +552,7 @@ export function getClient() {
     }
     return clientInstance;
 }
-export async function initializeClient(pythonPath, serverModule) {
+export async function initializeClient(_pythonPath, _serverModule) {
     const client = getClient();
     await client.initialize();
     return client;

package/dist/memory/contradictions.js

@@ -89,7 +89,7 @@ export async function challengeMemory(memoryId, challengeText, client) {
 /**
  * Adapt a raw memory from memini-ai to our MemoryEntry type
  */
-function adaptMemoryEntry(raw) {
+function _adaptMemoryEntry(raw) {
     let timestamp;
     if (typeof raw.timestamp === 'number') {
         timestamp = raw.timestamp;

package/dist/memory/index.js

@@ -5,7 +5,7 @@
  */
 import { initializeClient, } from '../memini-client/index.js';
 import { DEFAULT_SEARCH_OPTIONS } from './schema.js';
-const PROJECT_ID = process.env.BOOMERANG_PROJECT_ID || 'boomerang-default';
+const _PROJECT_ID = process.env.BOOMERANG_PROJECT_ID || 'boomerang-default';
 class MemorySystem {
     static instance = null;
     _initialized = false;

package/dist/memory/trust.js

@@ -130,7 +130,7 @@ export async function triggerConsolidation(force = false, client) {
 /**
  * Adapt a raw memory from memini-ai to our MemoryEntry type
  */
-function adaptMemoryEntry(meminiEntry) {
+function _adaptMemoryEntry(meminiEntry) {
     return {
         id: meminiEntry.id,
         text: meminiEntry.text,

package/dist/orchestrator.js

@@ -10,7 +10,7 @@ const ROUTING_MATRIX = {
     'mcp-debug': 'mcp-specialist',
     'release': 'boomerang-release',
 };
-function validateAgentRouting(taskType, agentName) {
+function _validateAgentRouting(taskType, agentName) {
     const expected = ROUTING_MATRIX[taskType];
     if (expected && expected !== agentName) {
         console.warn(`ROUTING VIOLATION: ${taskType} should use ${expected}, not ${agentName}`);
@@ -20,10 +20,12 @@ function validateAgentRouting(taskType, agentName) {
 }
 import { TimeoutError } from './types.js';
 import { TaskLimiter, executeWithRetry, executeWithTimeout, } from './concurrency/index.js';
+import { ContextBufferMiddleware } from './context-buffer.js';
 export class BoomerangOrchestrator {
     taskLimiter;
     config;
-    constructor(config) {
+    contextBuffer;
+    constructor(config, contextBufferConfig) {
         this.config = {
             maxConcurrentSubAgents: 2,
             defaultTimeoutMs: 60000,
@@ -39,6 +41,11 @@ export class BoomerangOrchestrator {
             ...config,
         };
         this.taskLimiter = new TaskLimiter(this.config.maxConcurrentSubAgents);
+        this.contextBuffer = null;
+        if (contextBufferConfig?.meminiClient) {
+            const sessionId = `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            this.contextBuffer = new ContextBufferMiddleware(sessionId, contextBufferConfig);
+        }
     }
     /**
      * Check if an agent can be dispatched without exceeding slot limits.
@@ -53,13 +60,36 @@ export class BoomerangOrchestrator {
         return this.taskLimiter.getSlotUsage();
     }
     /**
-     * Dispatch a task with concurrency check, retry, and timeout enforcement.
+     * Get the context buffer middleware, if configured.
+     */
+    getContextBuffer() {
+        return this.contextBuffer;
+    }
+    /**
+     * Dispatch a task with concurrency check, retry, timeout enforcement,
+     * and optional context buffer middleware integration.
+     *
+     * When the context buffer is configured, it wraps the task execution
+     * with beforeInvocation/afterInvocation hooks for context capture.
      */
     async dispatchTask(agentName, task, timeoutMs) {
         if (!this.canDispatch(agentName)) {
             throw new Error(`Cannot dispatch "${agentName}": no available slots (max ${this.config.maxConcurrentSubAgents})`);
         }
         this.taskLimiter.registerAgent(agentName, timeoutMs ?? this.config.defaultTimeoutMs);
+        const startTime = Date.now();
+        let _injectedContext = '';
+        let _contextMemoryIds = [];
+        // Context buffer: before invocation
+        if (this.contextBuffer) {
+            try {
+                _injectedContext = await this.contextBuffer.beforeInvocation(agentName, task.toString().slice(0, 200) // Brief description
+                );
+            }
+            catch (err) {
+                console.warn('[Orchestrator] Context buffer beforeInvocation failed:', err);
+            }
+        }
         try {
             const retryResult = await executeWithRetry(() => executeWithTimeout(task, agentName, timeoutMs), {
                 maxRetries: this.config.maxRetries,
@@ -67,12 +97,55 @@ export class BoomerangOrchestrator {
                 maxDelayMs: this.config.retryMaxDelayMs,
                 isRetryable: (err) => !(err instanceof TimeoutError),
             });
+            // Context buffer: after successful invocation
+            if (this.contextBuffer) {
+                try {
+                    const taskResult = this.extractTaskResult(retryResult.result);
+                    _contextMemoryIds = await this.contextBuffer.afterInvocation(agentName, taskResult, Date.now() - startTime);
+                }
+                catch (err) {
+                    console.warn('[Orchestrator] Context buffer afterInvocation failed:', err);
+                }
+            }
             return retryResult;
         }
+        catch (err) {
+            // Context buffer: after failed invocation
+            if (this.contextBuffer) {
+                try {
+                    const errorMessage = err instanceof Error ? err.message : String(err);
+                    _contextMemoryIds = await this.contextBuffer.afterInvocation(agentName, { success: false, error: errorMessage }, Date.now() - startTime);
+                }
+                catch (ctxErr) {
+                    console.warn('[Orchestrator] Context buffer afterInvocation (error) failed:', ctxErr);
+                }
+            }
+            throw err;
+        }
         finally {
             this.taskLimiter.releaseAgent(agentName);
         }
     }
+    /**
+     * Extract a TaskResult from a dispatch result value.
+     * Handles the case where T may or may not be a TaskResult-shaped object.
+     */
+    extractTaskResult(result) {
+        if (typeof result === 'object' && result !== null) {
+            const obj = result;
+            if ('output' in obj || 'filesModified' in obj || 'decisions' in obj || 'errors' in obj) {
+                return obj;
+            }
+        }
+        // Wrap raw results
+        return {
+            output: typeof result === 'string' ? result : JSON.stringify(result),
+            toolCalls: [],
+            filesModified: [],
+            decisions: [],
+            errors: [],
+        };
+    }
     /**
      * Reset all concurrency state (useful for testing and recovery).
      */
@@ -83,6 +156,6 @@ export class BoomerangOrchestrator {
 /**
  * Factory function to create a concurrency-aware orchestrator.
  */
-export function createOrchestrator(config) {
-    return new BoomerangOrchestrator(config);
+export function createOrchestrator(config, contextBufferConfig) {
+    return new BoomerangOrchestrator(config, contextBufferConfig);
 }

package/dist/telemetry-client.js

@@ -0,0 +1,98 @@
+/**
+ * Telemetry Client — Simple HTTP client for emitting telemetry events
+ * to the observability proxy.
+ *
+ * Uses native fetch (Node 20+) with fire-and-forget semantics.
+ * Failures are logged but never throw, ensuring telemetry never blocks
+ * the orchestrator pipeline.
+ */
+const DEFAULT_TIMEOUT_MS = 5000;
+/**
+ * Simple HTTP telemetry client for the boomerang observability proxy.
+ *
+ * All methods are fire-and-forget: errors are logged but never propagated,
+ * so telemetry failures never block the orchestrator.
+ */
+export class TelemetryClient {
+    endpoint;
+    timeoutMs;
+    constructor(endpoint, timeoutMs = DEFAULT_TIMEOUT_MS) {
+        this.endpoint = endpoint.replace(/\/+$/, '');
+        this.timeoutMs = timeoutMs;
+    }
+    /**
+     * Emit a telemetry event to the proxy.
+     * Fire-and-forget: logs errors but never throws.
+     */
+    async emit(event) {
+        try {
+            await this.post('/events', event);
+        }
+        catch (err) {
+            console.warn('[TelemetryClient] emit failed:', err);
+        }
+    }
+    /**
+     * Create a new session record in the telemetry proxy.
+     */
+    async createSession(sessionId, tenantId, taskDescription) {
+        try {
+            await this.post('/sessions', {
+                session_id: sessionId,
+                tenant_id: tenantId,
+                task_description: taskDescription,
+            });
+        }
+        catch (err) {
+            console.warn('[TelemetryClient] createSession failed:', err);
+        }
+    }
+    /**
+     * Update an existing session in the telemetry proxy.
+     */
+    async updateSession(sessionId, updates) {
+        try {
+            await this.patch(`/sessions/${sessionId}`, updates);
+        }
+        catch (err) {
+            console.warn('[TelemetryClient] updateSession failed:', err);
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Private helpers
+    // ---------------------------------------------------------------------------
+    async post(path, body) {
+        const url = `${this.endpoint}${path}`;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            return response;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async patch(path, body) {
+        const url = `${this.endpoint}${path}`;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            const response = await fetch(url, {
+                method: 'PATCH',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            return response;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}

package/dist/types.js

@@ -1,5 +1,8 @@
 /**
- * Boomerang v3 — Concurrency Type Definitions
+ * Boomerang v3 — Core Type Definitions
+ *
+ * Includes concurrency types, context buffer types, telemetry types,
+ * and shared interfaces used across the orchestrator and middleware layers.
  */
 export class TimeoutError extends Error {
     agentName;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veedubin/boomerang-v3",
-  "version": "0.3.4",
+  "version": "0.4.0",
   "description": "Multi-agent orchestration plugin for OpenCode with memini-ai memory",
   "type": "module",
   "main": "dist/index.js",

package/scripts/install-boomerang.js

@@ -49,7 +49,7 @@ const PROVIDERS = {
       'kimi-k2.6:cloud': { name: 'Kimi K2.6 (Cloud)' },
       'glm-5.1:cloud': { name: 'GLM 5.1 (Cloud)' },
       'deepseek-v4-pro:cloud': { name: 'DeepSeek V4 Pro (Cloud)' },
-      'devstral-2:cloud': { name: 'Devstral 2 (Cloud)' },
+      'devstral-2:123b-cloud': { name: 'Devstral 2 (Cloud)' },
       'deepseek-v4-flash:cloud': { name: 'DeepSeek V4 Flash (Cloud)' },
       'qwen3-coder-next:cloud': { name: 'Qwen3 Coder Next (Cloud)' },
       'minimax-m2.7:cloud': { name: 'MiniMax M2.7 (Cloud)' },