open-agents-ai 0.41.0 → 0.42.0

package/dist/index.js

@@ -23250,13 +23250,21 @@ var init_dream_engine = __esm({
             }
             let previousFindings = "";
             const cycleResults = [];
+            const modelTier = getModelTier(this.config.model);
             for (const stage of SLEEP_STAGES) {
               if (this.abortController.signal.aborted)
                 break;
               renderDreamStage(stage.name, stage.label, stage.description);
               const startMs = Date.now();
-              const prompt = buildDreamPrompt(mode, stage, cycle, totalCycles, previousFindings, this.dreamsDir);
-              const result = await this.runDreamAgent(prompt, mode === "lucid" ? "full" : "sandboxed", onEvent);
+              let result;
+              if (stage.name === "REM" && modelTier === "large") {
+                renderInfo("REM: Multi-agent creative mode \u2014 parallel Visionary + Pragmatist + Cross-Pollinator");
+                const remResult = await this.runMultiAgentREM(cycle, totalCycles, previousFindings, mode === "lucid" ? "full" : "sandboxed", onEvent);
+                result = { summary: remResult.summary, turns: 0, toolCalls: 0 };
+              } else {
+                const prompt = buildDreamPrompt(mode, stage, cycle, totalCycles, previousFindings, this.dreamsDir);
+                result = await this.runDreamAgent(prompt, mode === "lucid" ? "full" : "sandboxed", onEvent);
+              }
               const durationMs = Date.now() - startMs;
               const cycleResult = {
                 cycle,
@@ -23341,6 +23349,122 @@ Dreams directory: ${this.dreamsDir}`);
           toolCalls: result.toolCalls
         };
       }
+      /**
+       * Run a multi-agent REM stage — parallel creative voices that cross-pollinate.
+       *
+       * During real REM sleep, distant brain regions form novel associations through
+       * reduced prefrontal inhibition (Walker 2017, "Why We Sleep"). This is modeled
+       * as 3 parallel agents with distinct creative perspectives, whose outputs are
+       * then synthesized by a consolidation agent.
+       *
+       * Architecture:
+       * - Visionary: bold, transformative ideas (high temperature)
+       * - Pragmatist: practical improvements grounded in current codebase
+       * - Cross-Pollinator: draws inspiration from unrelated domains
+       * - Synthesizer: merges all perspectives into actionable proposals
+       */
+      async runMultiAgentREM(cycleNum, totalCycles, previousFindings, toolMode, onEvent) {
+        const dreamContextBase = `DREAM REM STAGE \u2014 Creative Expansion (Cycle ${cycleNum}/${totalCycles})
+
+PREVIOUS FINDINGS FROM EARLIER STAGES:
+${previousFindings}
+
+RULES:
+- Read any file in the workspace freely for analysis
+- ALL written output goes to .oa/dreams/ using file_write
+- Be specific: include file paths, function signatures, implementation steps`;
+        onEvent?.({
+          type: "status",
+          content: "REM: Parallel creative agents activating \u2014 Visionary + Pragmatist + Cross-Pollinator...",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        const [visionaryResult, pragmatistResult, crossResult] = await Promise.allSettled([
+          this.runDreamAgent(`${dreamContextBase}
+
+You are the VISIONARY \u2014 the bold, uninhibited creative voice.
+Think BIG. What would transform this project? What would make it 10x better?
+Ignore feasibility constraints for now \u2014 that's someone else's job.
+
+Generate at least 3 transformative ideas:
+- What paradigm shifts could the architecture undergo?
+- What emerging technologies could be leveraged?
+- What would the project look like in 2 years if we were fearless?
+
+Write your visions to .oa/dreams/cycle-${cycleNum}-rem-visionary.md
+Then call task_complete with a summary of your boldest ideas.`, toolMode, (event) => {
+            if (onEvent) {
+              onEvent({ ...event, content: event.type === "status" ? `[Visionary] ${event.content ?? ""}` : event.content });
+            }
+          }),
+          this.runDreamAgent(`${dreamContextBase}
+
+You are the PRAGMATIST \u2014 the grounded improvement specialist.
+What practical improvements would deliver the most value RIGHT NOW?
+Focus on: code quality, test coverage, performance, DX, documentation, reliability.
+
+Generate at least 3 practical proposals, each with:
+- Problem statement (specific, measurable)
+- Solution with implementation plan (specific files, functions, steps)
+- Estimated effort (hours/days)
+- Expected impact (quantified if possible)
+
+Write proposals to .oa/dreams/cycle-${cycleNum}-rem-pragmatist.md
+Then call task_complete with a summary of your top proposals.`, toolMode, (event) => {
+            if (onEvent) {
+              onEvent({ ...event, content: event.type === "status" ? `[Pragmatist] ${event.content ?? ""}` : event.content });
+            }
+          }),
+          this.runDreamAgent(`${dreamContextBase}
+
+You are the CROSS-POLLINATOR \u2014 the interdisciplinary connector.
+Draw inspiration from UNRELATED fields to improve this project:
+- How would a game designer approach the UX?
+- What can biological systems teach about the architecture?
+- What patterns from music, art, or nature apply here?
+- What can adjacent industries (fintech, biotech, aerospace) offer?
+
+Generate at least 3 cross-domain insights and how to apply them here.
+Be specific about the mapping from the source domain to this codebase.
+
+Write insights to .oa/dreams/cycle-${cycleNum}-rem-cross-pollinator.md
+Then call task_complete with a summary of your cross-domain connections.`, toolMode, (event) => {
+            if (onEvent) {
+              onEvent({ ...event, content: event.type === "status" ? `[Cross-Pollinator] ${event.content ?? ""}` : event.content });
+            }
+          })
+        ]);
+        const perspectives = [];
+        if (visionaryResult.status === "fulfilled")
+          perspectives.push(`VISIONARY:
+${visionaryResult.value.summary}`);
+        if (pragmatistResult.status === "fulfilled")
+          perspectives.push(`PRAGMATIST:
+${pragmatistResult.value.summary}`);
+        if (crossResult.status === "fulfilled")
+          perspectives.push(`CROSS-POLLINATOR:
+${crossResult.value.summary}`);
+        onEvent?.({
+          type: "status",
+          content: `REM: Synthesizing ${perspectives.length} creative perspectives...`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        const synthesisResult = await this.runDreamAgent(`DREAM REM \u2014 SYNTHESIS PHASE (Cycle ${cycleNum}/${totalCycles})
+
+Three creative voices have explored this codebase from different angles.
+Your job: merge their outputs into a unified, prioritized set of proposals.
+
+${perspectives.join("\n\n---\n\n")}
+
+INSTRUCTIONS:
+1. Identify the strongest ideas from each perspective
+2. Find SYNERGIES: where do different perspectives reinforce each other?
+3. Rate each merged proposal: impact (1-10), feasibility (1-10), novelty (1-10)
+4. Create a prioritized PROPOSAL-INDEX with the top 5-7 ideas
+5. Write the synthesized proposals to .oa/dreams/cycle-${cycleNum}-rem-synthesis.md
+
+After synthesis, call task_complete with the final prioritized summary.`, toolMode, onEvent);
+        return synthesisResult;
+      }
       /** Build tools appropriate for the dream mode */
       buildDreamTools(toolMode) {
         if (toolMode === "full") {
@@ -23798,19 +23922,29 @@ function adaptTool2(tool) {
     }
   };
 }
-function renderDMNCycleStart(cycleNum) {
+function renderDMNCycleStart(cycleNum, deliberation = false) {
   process.stdout.write(`
   ${c2.magenta("\u25CE")} ${c2.bold("DMN Cycle")} #${cycleNum} \u2014 self-reflection activating...
 `);
-  process.stdout.write(`    ${c2.dim("Scanning memories, directives, and environmental signals")}
+  if (deliberation) {
+    process.stdout.write(`    ${c2.dim("Multi-agent deliberation: PFC + Hippocampus + Amygdala + Critic + Gate")}
+`);
+  } else {
+    process.stdout.write(`    ${c2.dim("Scanning memories, directives, and environmental signals")}
 `);
+  }
 }
-function renderDMNCycleComplete(cycleNum, durationMs, proposal) {
+function renderDMNCycleComplete(cycleNum, durationMs, proposal, deliberationMeta) {
   const secs = (durationMs / 1e3).toFixed(1);
   const conf = Math.round(proposal.confidence * 100);
   process.stdout.write(`
   ${c2.green("\u25C9")} ${c2.bold("DMN")} #${cycleNum} complete ${c2.dim(`(${secs}s)`)}
 `);
+  if (deliberationMeta) {
+    const evPct = Math.round(deliberationMeta.evidence * 100);
+    process.stdout.write(`    ${c2.dim("Deliberation")}: ${deliberationMeta.rounds} rounds | evidence: ${evPct}%
+`);
+  }
   process.stdout.write(`    ${c2.bold("Next task")}: ${proposal.task.slice(0, 120)}${proposal.task.length > 120 ? "..." : ""}
 `);
   process.stdout.write(`    ${c2.dim("Category")}: ${proposal.category} | ${c2.dim("Confidence")}: ${conf}%
@@ -23825,6 +23959,14 @@ function renderDMNCycleComplete(cycleNum, durationMs, proposal) {
     process.stdout.write(`    ${c2.dim("Challenge")}: ${proposal.challengeResult.slice(0, 150)}
 `);
   }
+  if (deliberationMeta && deliberationMeta.innerVoice.length > 0) {
+    process.stdout.write(`    ${c2.dim("Inner Voice")}:
+`);
+    for (const voice of deliberationMeta.innerVoice.slice(-3)) {
+      process.stdout.write(`      ${c2.dim(">")} ${c2.dim(voice.slice(0, 120))}
+`);
+    }
+  }
   process.stdout.write("\n");
 }
 function renderDMNCycleNull(cycleNum, durationMs) {
@@ -23925,7 +24067,6 @@ var init_dmn_engine = __esm({
         this.state.totalCycles++;
         const cycleNum = this.state.totalCycles;
         const startMs = Date.now();
-        renderDMNCycleStart(cycleNum);
         const [reminders, attention, memoryTopics] = await Promise.all([
           this.gatherReminders(),
           this.gatherAttentionItems(),
@@ -23943,7 +24084,28 @@ var init_dmn_engine = __esm({
           "sub_agent \u2014 delegate subtasks to independent agents"
         ];
         const prompt = buildDMNGatherPrompt(this.recentTaskSummaries, reminders, attention, memoryTopics, capabilities, this.state.competence, this.state.reflectionBuffer);
-        const result = await this.runDMNAgent(prompt, onEvent);
+        const modelTier = getModelTier(this.config.model);
+        renderDMNCycleStart(cycleNum, modelTier === "large");
+        const useDeliberation = modelTier === "large";
+        let result;
+        let deliberationMeta = null;
+        if (useDeliberation) {
+          onEvent?.({
+            type: "status",
+            content: "DMN: Multi-agent deliberation mode (brain-region sub-agents)",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          const delib = await this.runDeliberationCycle(prompt, memoryTopics, onEvent);
+          result = { summary: delib.summary };
+          deliberationMeta = {
+            rounds: delib.workspace.rounds,
+            evidence: delib.workspace.evidenceAccumulated,
+            innerVoice: delib.workspace.innerVoice
+          };
+        } else {
+          const mono = await this.runDMNAgent(prompt, onEvent);
+          result = { summary: mono.summary };
+        }
         const durationMs = Date.now() - startMs;
         const proposal = this.parseProposal(result.summary);
         const cycleResult = {
@@ -23953,13 +24115,16 @@ var init_dmn_engine = __esm({
           memoriesScanned: memoryTopics.length,
           proposalsGenerated: proposal ? 1 : 0,
           selectedTask: proposal,
-          reasoning: result.summary
+          reasoning: result.summary,
+          deliberation: useDeliberation,
+          deliberationRounds: deliberationMeta?.rounds,
+          evidenceScore: deliberationMeta?.evidence
         };
         this.saveCycleResult(cycleResult);
         if (proposal) {
           this.state.tasksGenerated++;
           this.state.consecutiveNulls = 0;
-          renderDMNCycleComplete(cycleNum, durationMs, proposal);
+          renderDMNCycleComplete(cycleNum, durationMs, proposal, deliberationMeta ?? void 0);
         } else {
           this.state.consecutiveNulls++;
           renderDMNCycleNull(cycleNum, durationMs);
@@ -24017,6 +24182,349 @@ DMN state directory: ${this.stateDir}`);
           this.createTaskCompleteTool()
         ];
       }
+      // ── Multi-Agent Deliberation ─────────────────────────────────────────
+      /**
+       * Run a multi-agent deliberation cycle inspired by brain region interactions.
+       *
+       * Architecture mirrors the cortical-basal ganglia loop:
+       * 1. PARALLEL GATHER: PFC + Hippocampus + Amygdala scan context simultaneously
+       * 2. WORKSPACE BROADCAST: findings shared to global workspace (Baars 1988)
+       * 3. COLLABORATIVE PROPOSAL: PFC generates task candidates from gathered context
+       * 4. ADVERSARIAL CHALLENGE: Inner Critic challenges proposals (ACC/DLPFC)
+       * 5. THRESHOLD GATE: Basal Ganglia evaluates via drift-diffusion model
+       *    (Ratcliff & McKoon 2008) — evidence accumulates until crossing threshold
+       *
+       * Self-talk dynamics (Alderson-Day & Fernyhough 2015):
+       * - Inner Voice (Broca's area) provides verbal reasoning throughout
+       * - Positive self-talk boosts confidence (Hatzigeorgiadis et al. 2011)
+       * - Critical self-talk corrects errors (dorsal ACC error monitoring)
+       */
+      async runDeliberationCycle(contextSummary, memoryTopics, onEvent) {
+        const workspace = {
+          findings: [],
+          proposals: [],
+          challenges: [],
+          evidenceAccumulated: 0,
+          rounds: 0,
+          innerVoice: []
+        };
+        workspace.innerVoice.push("Waking up... what needs my attention right now?");
+        onEvent?.({
+          type: "status",
+          content: `DMN Inner Voice: "${workspace.innerVoice[0]}"`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        onEvent?.({
+          type: "status",
+          content: "DMN Phase 1: Parallel gather \u2014 PFC, Hippocampus, Amygdala activating...",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        const [pfcResult, hippoResult, amygResult] = await Promise.allSettled([
+          this.runBrainRegionAgent("pfc_planner", `${contextSummary}
+
+You are the PREFRONTAL CORTEX \u2014 the executive planner.
+Your role: strategic goal tracking and task proposal generation.
+
+INSTRUCTIONS:
+1. Read the context above carefully
+2. Use memory_search to find standing directives, goals, and unfinished work
+3. Identify the most strategically valuable next actions
+4. Propose 2-3 specific, actionable task candidates with rationale
+
+For each proposal include: task description, category (directive/exploration/capability/maintenance/social), confidence (0-1), and provenance (which memories/signals led here).
+
+Call task_complete with a JSON object: { "findings": "your strategic assessment", "proposals": [...], "confidence": 0.X }`, onEvent),
+          this.runBrainRegionAgent("hippocampus", `${contextSummary}
+
+You are the HIPPOCAMPUS \u2014 the memory navigator.
+Your role: deep memory retrieval, pattern recognition, temporal context.
+
+INSTRUCTIONS:
+1. Use memory_search extensively with varied queries: goals, patterns, history, skills, failures
+2. Read specific memory topics that seem relevant
+3. Look for PATTERNS: what recurring themes exist? What has been tried before?
+4. Find CONNECTIONS: how do different memories relate to each other?
+5. Identify temporal patterns: what was the agent doing recently? What's the momentum?
+
+Focus on surfacing the MOST RELEVANT memories and their interconnections.
+Look especially for things that other agents might miss \u2014 subtle patterns,
+forgotten goals, dormant capabilities.
+
+Call task_complete with: { "findings": "memory patterns and connections found", "memories": ["key findings"], "confidence": 0.X }`, onEvent),
+          this.runBrainRegionAgent("amygdala", `${contextSummary}
+
+You are the AMYGDALA \u2014 the risk and value sentinel.
+Your role: assess emotional valence, urgency, risk, and motivational state.
+
+INSTRUCTIONS:
+1. Review the context for URGENCY signals: due reminders, attention items, failures
+2. Assess RISK: what could go wrong? What actions might cause harm?
+3. Evaluate VALUE: what actions would have the highest positive impact?
+4. Check MOOD: based on recent successes/failures, is the agent in a state to
+   take on ambitious tasks, or should it focus on safer maintenance?
+5. Rate overall readiness: is this a time for bold exploration or cautious consolidation?
+
+Think like the brain's early warning system \u2014 flag dangers, but also flag opportunities.
+The amygdala doesn't just detect threats; it also signals reward anticipation.
+
+Call task_complete with: { "findings": "risk/value assessment", "risks": ["identified risks"], "urgency": 0.X, "mood": "description", "confidence": 0.X }`, onEvent)
+        ]);
+        if (pfcResult.status === "fulfilled") {
+          workspace.findings.push({
+            from: "pfc_planner",
+            content: pfcResult.value,
+            confidence: this.extractConfidence(pfcResult.value),
+            proposals: this.extractProposals(pfcResult.value)
+          });
+        }
+        if (hippoResult.status === "fulfilled") {
+          workspace.findings.push({
+            from: "hippocampus",
+            content: hippoResult.value,
+            confidence: this.extractConfidence(hippoResult.value),
+            memories: this.extractList(hippoResult.value, "memories")
+          });
+        }
+        if (amygResult.status === "fulfilled") {
+          workspace.findings.push({
+            from: "amygdala",
+            content: amygResult.value,
+            confidence: this.extractConfidence(amygResult.value),
+            risks: this.extractList(amygResult.value, "risks")
+          });
+        }
+        const gatherSummaryParts = [];
+        if (pfcResult.status === "fulfilled")
+          gatherSummaryParts.push("PFC has strategic proposals");
+        if (hippoResult.status === "fulfilled")
+          gatherSummaryParts.push("Hippocampus found memory patterns");
+        if (amygResult.status === "fulfilled")
+          gatherSummaryParts.push("Amygdala assessed risk/value");
+        const failCount = [pfcResult, hippoResult, amygResult].filter((r) => r.status === "rejected").length;
+        if (failCount > 0)
+          gatherSummaryParts.push(`${failCount} region(s) failed to respond`);
+        const voiceTransition = gatherSummaryParts.length > 0 ? `OK, initial scan complete. ${gatherSummaryParts.join(", ")}. Let me challenge these before deciding...` : "Scan produced sparse results. Need to be extra careful with what little I have...";
+        workspace.innerVoice.push(voiceTransition);
+        onEvent?.({
+          type: "status",
+          content: `DMN Inner Voice: "${voiceTransition}"`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        onEvent?.({
+          type: "status",
+          content: "DMN Phase 2: Inner Critic \u2014 adversarial challenge...",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        const workspaceSummary = workspace.findings.map((f) => `[${f.from}] ${f.content.slice(0, 500)}`).join("\n\n");
+        const criticResult = await this.runBrainRegionAgent("inner_critic", `You are the INNER CRITIC \u2014 the anterior cingulate cortex and right DLPFC.
+Your role: conflict detection, error monitoring, adversarial challenge.
+
+The following brain regions have completed their analysis:
+
+${workspaceSummary}
+
+INSTRUCTIONS:
+1. DETECT CONFLICTS: Do the PFC and Amygdala disagree? Are there contradictions?
+2. CHALLENGE PROPOSALS: For each task proposed by the PFC, ask:
+   - Is this actually useful or just busywork?
+   - Does the Hippocampus evidence support this direction?
+   - Does the Amygdala's risk assessment flag problems?
+   - Is the confidence rating justified by evidence?
+3. SELF-TALK: Provide constructive but honest internal dialogue:
+   - "The PFC wants X, but the Amygdala warns about Y \u2014 we should..."
+   - "The Hippocampus found a pattern suggesting Z is more important..."
+4. RATE EACH PROPOSAL: score 0-1 for viability after your challenge
+
+Be rigorous but not destructive. The goal is to IMPROVE proposals, not kill them all.
+Like healthy self-criticism, challenge to strengthen, not to paralyze.
+
+Call task_complete with: { "findings": "challenge results", "challenges": ["specific challenges"], "revisedScores": {"task_description": score}, "recommendation": "your verdict", "confidence": 0.X }`, onEvent);
+        if (criticResult) {
+          workspace.findings.push({
+            from: "inner_critic",
+            content: criticResult,
+            confidence: this.extractConfidence(criticResult)
+          });
+          workspace.challenges = this.extractList(criticResult, "challenges");
+        }
+        workspace.rounds++;
+        const challengeCount = workspace.challenges.length;
+        const criticConfidence = criticResult ? this.extractConfidence(criticResult) : 0.5;
+        const voicePostCritic = challengeCount > 2 ? `The critic raised ${challengeCount} concerns (conf: ${Math.round(criticConfidence * 100)}%). Some proposals may not survive. Let me weigh the evidence carefully...` : challengeCount > 0 ? `Only ${challengeCount} challenge(s) \u2014 proposals are holding up well. Time to decide.` : "Critic had nothing major to add. Proposals look solid. Moving to decision gate.";
+        workspace.innerVoice.push(voicePostCritic);
+        onEvent?.({
+          type: "status",
+          content: `DMN Inner Voice: "${voicePostCritic}"`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        onEvent?.({
+          type: "status",
+          content: "DMN Phase 3: Basal Ganglia Gate \u2014 evidence accumulation...",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        const allFindings = workspace.findings.map((f) => `[${f.from}] ${f.content.slice(0, 400)}`).join("\n\n");
+        const innerVoiceContext = workspace.innerVoice.map((v, i) => `  ${i + 1}. "${v}"`).join("\n");
+        const gateResult = await this.runBrainRegionAgent("basal_ganglia", `You are the BASAL GANGLIA \u2014 the action selection gate.
+Your role: accumulate evidence from all brain regions and decide Go or NoGo.
+
+BRAIN REGION FINDINGS:
+${allFindings}
+
+INNER VOICE THREAD (self-talk throughout deliberation):
+${innerVoiceContext}
+
+DECISION FRAMEWORK (Drift-Diffusion Model):
+You accumulate evidence from each region toward an action threshold.
+- PFC Planner confidence \u2192 +evidence toward Go
+- Hippocampus memory support \u2192 +evidence if memories align with proposal
+- Amygdala risk assessment \u2192 -evidence if high risk, +evidence if high opportunity
+- Inner Critic verdict \u2192 -evidence if strong challenges, +evidence if proposals survived
+
+THRESHOLD: 0.7 (supermajority confidence across regions)
+- If evidence \u2265 0.7 \u2192 GO: select the best task for execution
+- If evidence < 0.7 \u2192 NOGO: rest, the agent is not ready to act
+- If evidence 0.5-0.7 \u2192 BORDERLINE: select task but lower confidence
+
+URGENCY MODULATION:
+If the Amygdala flagged high urgency (due reminders, critical attention items),
+LOWER the threshold to 0.5 \u2014 urgent situations demand faster action even with
+less certainty (urgency-gating model, Cisek et al. 2009).
+
+OUTPUT: Call task_complete with JSON:
+{
+  "decision": "GO" | "NOGO",
+  "evidenceScore": 0.X,
+  "selectedTask": { task, rationale, provenance, category, confidence, challengeResult } | null,
+  "reasoning": "how evidence from each region contributed to the decision",
+  "innerVoice": "final self-talk summary \u2014 what the agent 'says to itself' before acting"
+}`, onEvent);
+        if (gateResult) {
+          workspace.findings.push({
+            from: "basal_ganglia",
+            content: gateResult,
+            confidence: this.extractConfidence(gateResult)
+          });
+          workspace.evidenceAccumulated = this.extractConfidence(gateResult);
+          const decision = gateResult.includes('"GO"') || gateResult.toLowerCase().includes("decision.*go") ? "go" : "nogo";
+          const evScore = Math.round(workspace.evidenceAccumulated * 100);
+          const voiceFinal = decision === "go" ? `Decision: GO (evidence ${evScore}%). I know what to do next. Let's move.` : `Decision: NOGO (evidence ${evScore}%). Not enough clarity to act. Better to rest and gather more information.`;
+          workspace.innerVoice.push(voiceFinal);
+          onEvent?.({
+            type: "status",
+            content: `DMN Inner Voice: "${voiceFinal}"`,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          const innerVoiceMatch = gateResult.match(/"innerVoice"\s*:\s*"([^"]+)"/);
+          if (innerVoiceMatch) {
+            workspace.innerVoice.push(`[Gate] ${innerVoiceMatch[1]}`);
+          }
+        }
+        workspace.rounds++;
+        const fullSummary = workspace.findings.map((f) => `[${f.from}] ${f.content}`).join("\n\n---\n\n");
+        return { summary: gateResult || fullSummary, workspace };
+      }
+      /**
+       * Run a single brain-region sub-agent.
+       * Each region gets read-only memory access and a focused prompt.
+       * Limited to 8 turns — brain regions are fast, specialized processors.
+       */
+      async runBrainRegionAgent(role, prompt, onEvent) {
+        const backend = new OllamaAgenticBackend(this.config.backendUrl, this.config.model, this.config.apiKey);
+        const modelTier = getModelTier(this.config.model);
+        const runner = new AgenticRunner(backend, {
+          maxTurns: 8,
+          // Brain regions are fast, focused
+          maxTokens: 4096,
+          temperature: role === "amygdala" ? 0.2 : role === "pfc_planner" ? 0.5 : 0.3,
+          requestTimeoutMs: this.config.timeoutMs,
+          taskTimeoutMs: this.config.timeoutMs,
+          compactionThreshold: modelTier === "small" ? 8e3 : 16e3,
+          modelTier
+        });
+        const tools = [
+          new FileReadTool(this.repoRoot),
+          new GrepSearchTool(this.repoRoot),
+          new GlobFindTool(this.repoRoot),
+          new ListDirectoryTool(this.repoRoot),
+          new MemoryReadTool(this.repoRoot),
+          new MemorySearchTool(this.repoRoot)
+        ];
+        if (role === "pfc_planner") {
+          tools.push(new MemoryWriteTool(this.repoRoot));
+        }
+        runner.registerTools([
+          ...tools.map(adaptTool2),
+          {
+            name: "task_complete",
+            description: `Signal that the ${role} analysis is complete.`,
+            parameters: {
+              type: "object",
+              properties: {
+                summary: { type: "string", description: "JSON with your findings" }
+              },
+              required: ["summary"]
+            },
+            async execute(args) {
+              return { success: true, output: args["summary"] || "{}" };
+            }
+          }
+        ]);
+        if (onEvent) {
+          runner.onEvent((event) => {
+            const taggedEvent = {
+              ...event,
+              content: event.type === "status" ? `[${role}] ${event.content ?? ""}` : event.content
+            };
+            onEvent(taggedEvent);
+          });
+        }
+        const result = await runner.run(prompt, `Brain region: ${role}. Working directory: ${this.repoRoot}`);
+        return result.summary || "{}";
+      }
+      // ── Deliberation helpers ──────────────────────────────────────────────
+      extractConfidence(summary) {
+        try {
+          const match = summary.match(/"confidence"\s*:\s*([\d.]+)/);
+          if (match)
+            return Math.min(1, Math.max(0, parseFloat(match[1])));
+          const evidenceMatch = summary.match(/"evidenceScore"\s*:\s*([\d.]+)/);
+          if (evidenceMatch)
+            return Math.min(1, Math.max(0, parseFloat(evidenceMatch[1])));
+        } catch {
+        }
+        return 0.5;
+      }
+      extractProposals(summary) {
+        try {
+          const match = summary.match(/"proposals"\s*:\s*\[[\s\S]*?\]/);
+          if (!match)
+            return [];
+          const arr = JSON.parse(match[0].replace(/^"proposals"\s*:\s*/, ""));
+          return arr.map((p) => ({
+            task: String(p.task ?? ""),
+            rationale: String(p.rationale ?? ""),
+            provenance: Array.isArray(p.provenance) ? p.provenance.map(String) : [],
+            category: ["directive", "exploration", "capability", "maintenance", "social"].includes(String(p.category)) ? String(p.category) : "exploration",
+            confidence: typeof p.confidence === "number" ? p.confidence : 0.5,
+            challengeResult: p.challengeResult ? String(p.challengeResult) : void 0
+          }));
+        } catch {
+          return [];
+        }
+      }
+      extractList(summary, key) {
+        try {
+          const regex = new RegExp(`"${key}"\\s*:\\s*\\[[\\s\\S]*?\\]`);
+          const match = summary.match(regex);
+          if (!match)
+            return [];
+          const arr = JSON.parse(match[0].replace(new RegExp(`^"${key}"\\s*:\\s*`), ""));
+          return arr.map(String);
+        } catch {
+          return [];
+        }
+      }
+      // ── End Multi-Agent Deliberation ──────────────────────────────────────
       createTaskCompleteTool() {
         return {
           name: "task_complete",
@@ -26041,6 +26549,63 @@ function gatherMemorySnippets(root) {
   }
   return snippets;
 }
+function createDMNEventHandler(verbose, writeContent) {
+  return (event) => {
+    switch (event.type) {
+      case "tool_call":
+        if (verbose) {
+          writeContent(() => {
+            const args = event.toolArgs ?? {};
+            renderToolCallStart(event.toolName ?? "unknown", args, true);
+          });
+        } else {
+          const argSummary = formatDMNToolArgs(event.toolName ?? "", event.toolArgs ?? {});
+          writeContent(() => process.stdout.write(`    ${c2.dim(`DMN \u2192 ${event.toolName}`)}${argSummary ? c2.dim(`: ${argSummary}`) : ""}
+`));
+        }
+        break;
+      case "tool_result":
+        if (verbose) {
+          writeContent(() => {
+            renderToolResult(event.toolName ?? "unknown", event.success ?? false, event.content ?? "", true);
+          });
+        }
+        break;
+      case "model_response":
+        if (verbose && event.content) {
+          const preview = event.content.length > 200 ? event.content.slice(0, 200) + "..." : event.content;
+          writeContent(() => renderVerbose(`DMN thinking: ${preview}`));
+        }
+        break;
+      case "token_usage":
+        if (verbose && event.tokenUsage) {
+          writeContent(() => renderVerbose(`DMN tokens \u2014 prompt: ${event.tokenUsage.promptTokens} | completion: ${event.tokenUsage.completionTokens} | ctx: ~${event.tokenUsage.estimatedContextTokens.toLocaleString()}`));
+        }
+        break;
+    }
+  };
+}
+function formatDMNToolArgs(toolName, args) {
+  switch (toolName) {
+    case "memory_read":
+    case "memory_search":
+      return String(args["topic"] ?? args["query"] ?? "").slice(0, 60);
+    case "file_read":
+      return String(args["path"] ?? "").slice(0, 80);
+    case "list_directory":
+      return String(args["path"] ?? ".").slice(0, 80);
+    case "shell":
+      return String(args["command"] ?? "").slice(0, 80);
+    case "memory_write":
+      return `${args["topic"] ?? ""}.${args["key"] ?? ""}`;
+    case "grep_search":
+      return String(args["pattern"] ?? "").slice(0, 60);
+    case "find_files":
+      return String(args["pattern"] ?? "").slice(0, 60);
+    default:
+      return "";
+  }
+}
 function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce, statusBar, sudoCallback, costTracker, onComplete, taskType, contextWindowSize, modelCaps, personality, deepContext, onCompaction) {
   const voiceStyleMap = {
     concise: 1,
@@ -26623,12 +27188,8 @@ Respond concisely and safely.`;
       statusBar.setProcessing(true);
       statusBar.setBrailleMetrics({ isDreaming: true });
       try {
-        const proposal = await dmnEngine.runCycle((event) => {
-          if (event.type === "tool_call") {
-            writeContent(() => process.stdout.write(`    ${c2.dim(`DMN \u2192 ${event.toolName}`)}
-`));
-          }
-        });
+        const dmnHandler = createDMNEventHandler(currentConfig.verbose ?? false, writeContent);
+        const proposal = await dmnEngine.runCycle(dmnHandler);
         statusBar.setProcessing(false);
         statusBar.setBrailleMetrics({ isDreaming: false });
         if (proposal) {
@@ -26914,10 +27475,14 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
       statusBar.setProcessing(true);
       statusBar.setBrailleMetrics({ isDreaming: true });
       dreamEngine.start(mode, (event) => {
+        const isVerbose = currentConfig.verbose ?? false;
         if (event.type === "tool_call") {
-          writeContent(() => renderToolCallStart(event.toolName ?? "unknown", event.toolArgs ?? {}));
+          writeContent(() => renderToolCallStart(event.toolName ?? "unknown", event.toolArgs ?? {}, isVerbose));
         } else if (event.type === "tool_result") {
-          writeContent(() => renderToolResult(event.toolName ?? "unknown", event.success ?? false, event.content ?? ""));
+          writeContent(() => renderToolResult(event.toolName ?? "unknown", event.success ?? false, event.content ?? "", isVerbose));
+        } else if (event.type === "model_response" && isVerbose && event.content) {
+          const preview = event.content.length > 300 ? event.content.slice(0, 300) + "..." : event.content;
+          writeContent(() => renderVerbose(`Dream thinking: ${preview}`));
         } else if (event.type === "token_usage" && event.tokenUsage) {
           statusBar.updateMetrics({
             ...event.tokenUsage,
@@ -27635,12 +28200,8 @@ Respond concisely and safely.`;
         statusBar.setProcessing(true);
         statusBar.setBrailleMetrics({ isDreaming: true });
         try {
-          const proposal = await dmnEngine.runCycle((event) => {
-            if (event.type === "tool_call") {
-              writeContent(() => process.stdout.write(`    ${c2.dim(`DMN \u2192 ${event.toolName}`)}
-`));
-            }
-          });
+          const dmnHandler = createDMNEventHandler(currentConfig.verbose ?? false, writeContent);
+          const proposal = await dmnEngine.runCycle(dmnHandler);
           statusBar.setProcessing(false);
           statusBar.setBrailleMetrics({ isDreaming: false });
           if (proposal) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.41.0",
+  "version": "0.42.0",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",