open-agents-ai 0.39.1 → 0.41.0

package/README.md

@@ -109,7 +109,7 @@ Long conversations consume context window tokens. Open Agents uses progressive c
 
 ### How It Works
 
-Compaction triggers automatically when estimated token usage reaches 75% of the model's context window. The system:
+Compaction triggers automatically when estimated token usage reaches a tier-proportional threshold of the model's context window. The system:
 
 1. **Preserves** the system prompt and initial user task (head messages)
 2. **Summarizes** middle messages (tool calls, results, exploration) into a structured digest
@@ -131,24 +131,63 @@ Six strategies are available via `/compact <strategy>`:
 
 ### Automatic Compaction
 
-Compaction thresholds scale dynamically with model size:
+Compaction thresholds scale **proportionally** with the model's actual context window size:
 
-| Model Tier | Threshold | Recent Messages Kept |
-|------------|-----------|---------------------|
-| Large (30B+) | 40,000 tokens (or 75% of context) | 12 messages |
-| Medium (8-29B) | 24,000 tokens (or 75% of context) | 8 messages |
-| Small (≤7B) | 12,000 tokens (or 75% of context) | 4-6 messages |
+| Model Tier | Normal Mode | Deep Context Mode | Recent Messages Kept |
+|------------|-------------|-------------------|---------------------|
+| Large (30B+) | 75% of context window | 85% of context window | 4-12 (normal) / 4-24 (deep) |
+| Medium (8-29B) | 70% of context window | 85% of context window | 4-12 (normal) / 4-24 (deep) |
+| Small (≤7B) | 65% of context window | 85% of context window | 4-12 (normal) / 4-24 (deep) |
 
-### Status Bar Context Tracking (`Ctx:`)
+For example, a 128K-context large model compacts at ~96K tokens in normal mode (75%) or ~109K tokens in deep mode (85%) — instead of the previous fixed 40K threshold that wasted 69% of available context.
 
-The status bar displays a live `Ctx:` gauge showing estimated context window usage:
+### Deep Context Mode (`/deep`)
+
+Toggle with `/deep` — relaxes compaction so large models leverage more of their context window for complex multi-step reasoning.
+
+When deep context is active:
+- **Compaction fires at 85%** of context instead of 65-75% — the model retains much more working memory
+- **Double the recent messages** (up to 24 instead of 12) preserved after compaction
+- **Richer summaries** — compression budget increased from 20% to 30% of context
+- **Larger tool outputs** — cap raised from 8K to 16K chars per tool result
+- **Relaxed output folding** — more head/tail lines preserved (50/25 instead of 20/10 for large models)
+
+This mirrors how human cognition works during deep problem-solving: situationally-relevant memories are transiently activated to occupy a larger portion of working memory, with the most relevant details in high-attention positions while supporting context backs them up. LLM attention mechanisms work similarly — earlier relevant context still influences generation even at lower positional weight.
+
+Use deep context for:
+- Complex multi-file refactoring or debugging
+- Architecture analysis across many files
+- Long debugging sessions where error context from earlier is critical
+- Tasks where the agent needs to reason about patterns across many files
+
+The setting persists to `.oa/settings.json`. Deep context is particularly valuable for models with 64K+ context windows (Qwen3.5-122B, Llama 3.1 70B, etc.) where the default thresholds were leaving significant capacity unused.
+
+### Status Bar Context Tracking (`Ctx:` + `SNR:`)
+
+The status bar displays a live `Ctx:` gauge showing estimated context window usage, plus an `SNR:` gauge showing context quality:
 
 ```
-In: 12,345 | Out: 4,567 | Ctx: 18,000/131,072 86% | Exp: 4.2x
-                           ^^^^^^^^^^^^^^^^^^^^^^^^
-                           Estimated tokens used / total context window
+In: 12,345 | Out: 4,567 | Ctx: 18,000/131,072 86% | SNR: 72% d'2.1 | Exp: 4.2x
+                           ^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^
+                           Context window usage        Signal-to-Noise Ratio
 ```
 
+**SNR (Signal-to-Noise Ratio)** — measures how much of the agent's memory context is relevant to the current task vs noise. Inspired by neuroscience signal detection theory:
+
+- **d-prime (d')**: psychophysics metric measuring separation between signal and noise distributions. d' >= 2.0 = excellent discrimination, d' ≈ 1.0 = moderate, d' <= 0.5 = noisy
+- **Signal**: memory entries with high keyword overlap to the current task (PFC gating analogy)
+- **Noise**: entries with low relevance or high redundancy (dentate gyrus pattern separation)
+- **Sparsity**: how much of the context is unique vs redundant (sparse distributed memory)
+
+The SNR formula combines three components:
+- 50% **signal proportion** (relevant entries / total entries)
+- 30% **d-prime quality** (normalized to 0-1 from the 0-3 d' range)
+- 20% **sparsity** (1 - average pairwise n-gram overlap)
+
+Color coding: green (>=70%), yellow (40-70%), red (<40%). SNR is evaluated at task start and task completion. In deep context mode with `/deep`, parallel evaluator agents (PFC Relevance Evaluator + Dentate Gyrus Noise Detector) can run a full consensus-based evaluation.
+
+Research basis: d-prime from signal detection theory (Green & Swets 1966), hippocampal pattern separation (Yassa & Stark 2011), PFC gating (Miller & Cohen 2001), biased competition (Desimone & Duncan 1995), multi-agent debate (Du et al., arXiv:2305.14325).
+
 This gauge reflects the **post-compaction** token count — when compaction fires, the `Ctx:` value drops to match the actual compressed message history. The compaction warning message shows the before/after:
 
 ```

package/dist/index.js

@@ -6133,8 +6133,8 @@ async function loadTranscribeCli() {
   const nvmBase = join15(homedir6(), ".nvm", "versions", "node");
   if (existsSync12(nvmBase)) {
     try {
-      const { readdirSync: readdirSync12 } = await import("node:fs");
-      for (const ver of readdirSync12(nvmBase)) {
+      const { readdirSync: readdirSync14 } = await import("node:fs");
+      for (const ver of readdirSync14(nvmBase)) {
         const tcPath = join15(nvmBase, ver, "lib", "node_modules", "transcribe-cli");
         if (existsSync12(join15(tcPath, "dist", "index.js"))) {
           const { createRequire: createRequire4 } = await import("node:module");
@@ -13180,6 +13180,7 @@ Rules:
           taskTimeoutMs: options?.taskTimeoutMs ?? 36e5,
           // 60 min
           compactionThreshold: options?.compactionThreshold ?? 4e4,
+          deepContext: options?.deepContext ?? false,
           dynamicContext: options?.dynamicContext ?? "",
           streamEnabled: options?.streamEnabled ?? false,
           bruteForce: options?.bruteForce ?? true,
@@ -13225,19 +13226,47 @@ Rules:
       /**
        * Compute all context-dependent limits from the current contextWindowSize
        * and modelTier. Returns sensible defaults when contextWindowSize is 0.
+       *
+       * Key insight: LLM attention is most effective when the most relevant content
+       * sits in high-attention positions (start and end of context). Rather than
+       * compacting aggressively and losing detail, we scale thresholds proportionally
+       * to the model's actual context window so larger models can leverage more of
+       * their capacity. The deepContext flag further relaxes limits for complex
+       * multi-step reasoning where earlier context carries critical signal.
+       *
+       * Context utilization targets:
+       * - Small models:  compact at ~65% (limited attention span, aggressive helps)
+       * - Medium models: compact at ~70% (balanced)
+       * - Large models:  compact at ~75% (plenty of room, let attention work)
+       * - Deep context:  compact at ~85% (trust the model's full attention window)
        */
       contextLimits() {
         const ctx = this.options.contextWindowSize;
         const tier = this.options.modelTier ?? "large";
-        const compactionThreshold = ctx > 0 ? Math.min(this.options.compactionThreshold, Math.floor(ctx * 0.75)) : this.options.compactionThreshold;
-        const keepRecentDivisor = tier === "small" ? 2e3 : tier === "medium" ? 3e3 : 4e3;
-        const keepRecent = ctx > 0 ? Math.max(4, Math.min(12, Math.floor(ctx / keepRecentDivisor))) : 12;
+        const deep = this.options.deepContext ?? false;
+        let compactionThreshold;
+        if (ctx > 0) {
+          const factor = deep ? 0.85 : tier === "small" ? 0.65 : tier === "medium" ? 0.7 : 0.75;
+          compactionThreshold = Math.floor(ctx * factor);
+        } else {
+          compactionThreshold = deep ? 8e4 : this.options.compactionThreshold;
+        }
+        const keepRecentMax = deep ? 24 : 12;
+        let keepRecent;
+        if (ctx > 0) {
+          const keepRecentDivisor = tier === "small" ? 2e3 : tier === "medium" ? 3e3 : 4e3;
+          keepRecent = Math.max(4, Math.min(keepRecentMax, Math.floor(ctx / keepRecentDivisor)));
+        } else {
+          keepRecent = deep ? 20 : 12;
+        }
         const maxOutputTokens = ctx > 0 ? Math.min(this.options.maxTokens, Math.max(2048, Math.floor(ctx * 0.25))) : this.options.maxTokens;
-        const toolOutputMaxChars = ctx > 0 ? Math.max(2e3, Math.min(8e3, Math.floor(ctx * 0.5))) : 8e3;
-        const foldLineThreshold = tier === "small" ? 30 : tier === "medium" ? 35 : 40;
-        const foldHeadLines = tier === "small" ? 12 : tier === "medium" ? 16 : 20;
-        const foldTailLines = tier === "small" ? 5 : tier === "medium" ? 8 : 10;
-        const maxSummaryChars = ctx > 0 ? Math.max(2e3, Math.min(8e3, Math.floor(ctx * 0.2))) : 4e3;
+        const toolOutputCeiling = deep ? 16e3 : 8e3;
+        const toolOutputMaxChars = ctx > 0 ? Math.max(2e3, Math.min(toolOutputCeiling, Math.floor(ctx * (deep ? 0.8 : 0.5)))) : toolOutputCeiling;
+        const foldLineThreshold = deep ? tier === "small" ? 50 : tier === "medium" ? 80 : 120 : tier === "small" ? 30 : tier === "medium" ? 35 : 40;
+        const foldHeadLines = deep ? tier === "small" ? 20 : tier === "medium" ? 30 : 50 : tier === "small" ? 12 : tier === "medium" ? 16 : 20;
+        const foldTailLines = deep ? tier === "small" ? 10 : tier === "medium" ? 15 : 25 : tier === "small" ? 5 : tier === "medium" ? 8 : 10;
+        const maxSummaryCeiling = deep ? 16e3 : 8e3;
+        const maxSummaryChars = ctx > 0 ? Math.max(2e3, Math.min(maxSummaryCeiling, Math.floor(ctx * (deep ? 0.3 : 0.2)))) : deep ? 8e3 : 4e3;
         const repetitionWindow = tier === "small" ? 6 : tier === "medium" ? 8 : 10;
         return {
           compactionThreshold,
@@ -14040,8 +14069,8 @@ ${marker}` : marker);
           return;
         try {
           const { mkdirSync: mkdirSync14, writeFileSync: writeFileSync13 } = __require("node:fs");
-          const { join: join42 } = __require("node:path");
-          const sessionDir = join42(this._workingDirectory, ".oa", "session", this._sessionId);
+          const { join: join43 } = __require("node:path");
+          const sessionDir = join43(this._workingDirectory, ".oa", "session", this._sessionId);
           mkdirSync14(sessionDir, { recursive: true });
           const checkpoint = {
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -14054,7 +14083,7 @@ ${marker}` : marker);
             memexEntryCount: this._memexArchive.size,
             fileRegistrySize: this._fileRegistry.size
           };
-          writeFileSync13(join42(sessionDir, "checkpoint.json"), JSON.stringify(checkpoint, null, 2));
+          writeFileSync13(join43(sessionDir, "checkpoint.json"), JSON.stringify(checkpoint, null, 2));
         } catch {
         }
       }
@@ -15958,8 +15987,8 @@ var init_listen = __esm({
         const nvmBase = join27(homedir8(), ".nvm", "versions", "node");
         if (existsSync19(nvmBase)) {
           try {
-            const { readdirSync: readdirSync12 } = await import("node:fs");
-            for (const ver of readdirSync12(nvmBase)) {
+            const { readdirSync: readdirSync14 } = await import("node:fs");
+            for (const ver of readdirSync14(nvmBase)) {
               const tcPath = join27(nvmBase, ver, "lib", "node_modules", "transcribe-cli");
               if (existsSync19(join27(tcPath, "dist", "index.js"))) {
                 const { createRequire: createRequire4 } = await import("node:module");
@@ -16189,10 +16218,10 @@ transcribe-cli error: ${transcribeCliError}` : "";
             wordTimestamps: false
           });
           if (outputDir) {
-            const { basename: basename15 } = await import("node:path");
+            const { basename: basename16 } = await import("node:path");
             const transcriptDir = join27(outputDir, ".oa", "transcripts");
             mkdirSync5(transcriptDir, { recursive: true });
-            const outFile = join27(transcriptDir, `${basename15(filePath)}.txt`);
+            const outFile = join27(transcriptDir, `${basename16(filePath)}.txt`);
             writeFileSync5(outFile, result.text, "utf-8");
           }
           return {
@@ -16578,18 +16607,18 @@ function renderTaskAborted() {
 ${c2.yellow("\u26A0")} ${c2.bold("Task aborted by user")}
 `);
 }
-function renderToolCallStart(toolName, args) {
+function renderToolCallStart(toolName, args, verbose) {
   const icon = TOOL_ICONS[toolName] ?? "\u{1F527}";
   const label = TOOL_LABELS[toolName] ?? toolName;
-  const argsSummary = formatToolArgs(toolName, args);
+  const argsSummary = formatToolArgs(toolName, args, verbose);
   const colorFn = _colorsEnabled ? TOOL_COLORS[toolName] ?? c2.dim : (t) => t;
   const emojiPrefix = _emojisEnabled ? `${icon} ` : "";
   process.stdout.write(`
   ${c2.dim("\u23BF")}  ${emojiPrefix}${colorFn(c2.bold(label))}${argsSummary ? c2.dim(": ") + argsSummary : ""}
 `);
 }
-function renderToolResult(toolName, success, output) {
-  const maxW = getTermWidth() - 10;
+function renderToolResult(toolName, success, output, verbose) {
+  const maxW = verbose ? Math.max(getTermWidth() - 10, 200) : getTermWidth() - 10;
   const prefix = `  ${c2.dim("\u23BF")}  `;
   switch (toolName) {
     case "file_write": {
@@ -16647,18 +16676,47 @@ function renderToolResult(toolName, success, output) {
 `);
     return;
   }
-  const maxLines = 6;
+  const maxLines = verbose ? 200 : 6;
   const shown = lines.slice(0, maxLines);
   for (const line of shown) {
-    if (isRawJsonDump(line)) {
+    if (isRawJsonDump(line) && !verbose) {
       process.stdout.write(`${prefix}${c2.dim("(content omitted)")}
 `);
       return;
     }
-    const cropped = line.length > maxW ? line.slice(0, maxW - 3) + "..." : line;
-    const formatted = formatMarkdownLine(cropped);
-    process.stdout.write(`${prefix}${formatted === cropped ? highlightToolOutput(cropped) : formatted}
+    if (verbose) {
+      const termW = getTermWidth() - 10;
+      if (line.length > termW) {
+        let remaining = line;
+        let first = true;
+        while (remaining.length > 0) {
+          if (remaining.length <= termW) {
+            const formatted2 = formatMarkdownLine(remaining);
+            process.stdout.write(`${first ? prefix : prefix + "  "}${formatted2 === remaining ? highlightToolOutput(remaining) : formatted2}
+`);
+            break;
+          }
+          let breakAt = remaining.lastIndexOf(" ", termW);
+          if (breakAt < termW * 0.3)
+            breakAt = termW;
+          const chunk = remaining.slice(0, breakAt);
+          remaining = remaining.slice(breakAt).trimStart();
+          const formatted = formatMarkdownLine(chunk);
+          process.stdout.write(`${first ? prefix : prefix + "  "}${formatted === chunk ? highlightToolOutput(chunk) : formatted}
+`);
+          first = false;
+        }
+      } else {
+        const formatted = formatMarkdownLine(line);
+        process.stdout.write(`${prefix}${formatted === line ? highlightToolOutput(line) : formatted}
+`);
+      }
+    } else {
+      const cropped = line.length > maxW ? line.slice(0, maxW - 3) + "..." : line;
+      const formatted = formatMarkdownLine(cropped);
+      process.stdout.write(`${prefix}${formatted === cropped ? highlightToolOutput(cropped) : formatted}
 `);
+    }
   }
   if (lines.length > maxLines) {
     process.stdout.write(`${prefix}${c2.dim(`... ${lines.length - maxLines} more lines`)}
@@ -16914,6 +16972,7 @@ function renderSlashHelp() {
     ["/compact", "Force context compaction now (default strategy)"],
     ["/compact <strategy>", "Compact with strategy: aggressive, decisions, errors, summary, structured"],
     ["/bruteforce", "Toggle brute-force mode (auto re-engage on turn limit)"],
+    ["/deep", "Toggle deep context \u2014 relaxes compaction so large models use 85% of context"],
     ["/tools", "List agent-created custom tools"],
     ["/skills", "List available AIWG skills"],
     ["/skills <keyword>", "Filter skills by name or trigger"],
@@ -16996,8 +17055,8 @@ function renderConfig(config) {
   }
   process.stdout.write("\n");
 }
-function formatToolArgs(toolName, args) {
-  const maxArg = Math.max(40, getTermWidth() - 20);
+function formatToolArgs(toolName, args, verbose) {
+  const maxArg = verbose ? 1e4 : Math.max(40, getTermWidth() - 20);
   switch (toolName) {
     case "file_read":
     case "file_write":
@@ -19451,6 +19510,18 @@ async function handleSlashCommand(input, ctx) {
       renderInfo(`Brute-force mode: ${isOn ? "on" : "off"}${hasLocal ? " (project-local)" : ""}` + (isOn ? " \u2014 agent will auto re-engage when turn limit is hit, reassess and try creative strategies" : ""));
       return "handled";
     }
+    case "deep":
+    case "deep-context": {
+      if (!ctx.deepContextToggle) {
+        renderWarning("Deep context not available");
+        return "handled";
+      }
+      const isOn = ctx.deepContextToggle();
+      const save = hasLocal ? ctx.saveLocalSettings.bind(ctx) : ctx.saveSettings.bind(ctx);
+      save({ deepContext: isOn });
+      renderInfo(`Deep context mode: ${isOn ? "ON" : "OFF"}${hasLocal ? " (project-local)" : ""}` + (isOn ? " \u2014 compaction relaxed to 85% of context window. Large models will retain more working memory for complex reasoning." : " \u2014 compaction restored to default thresholds."));
+      return "handled";
+    }
     case "emojis":
     case "emoji": {
       const current = ctx.getEmojis?.() ?? true;
@@ -19871,17 +19942,17 @@ async function handleUpdate(subcommand, ctx) {
   try {
     const { createRequire: createRequire4 } = await import("node:module");
     const { fileURLToPath: fileURLToPath10 } = await import("node:url");
-    const { dirname: dirname13, join: join42 } = await import("node:path");
-    const { existsSync: existsSync29 } = await import("node:fs");
+    const { dirname: dirname13, join: join43 } = await import("node:path");
+    const { existsSync: existsSync30 } = await import("node:fs");
     const req = createRequire4(import.meta.url);
     const thisDir = dirname13(fileURLToPath10(import.meta.url));
     const candidates = [
-      join42(thisDir, "..", "package.json"),
-      join42(thisDir, "..", "..", "package.json"),
-      join42(thisDir, "..", "..", "..", "package.json")
+      join43(thisDir, "..", "package.json"),
+      join43(thisDir, "..", "..", "package.json"),
+      join43(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
-      if (existsSync29(pkgPath)) {
+      if (existsSync30(pkgPath)) {
         const pkg = req(pkgPath);
         if (pkg.name === "open-agents-ai" || pkg.name === "@open-agents/cli") {
           currentVersion = pkg.version ?? "0.0.0";
@@ -24071,6 +24142,348 @@ DMN state directory: ${this.stateDir}`);
   }
 });
 
+// packages/cli/dist/tui/snr-engine.js
+import { existsSync as existsSync27, readdirSync as readdirSync12, readFileSync as readFileSync20 } from "node:fs";
+import { join as join37, basename as basename14 } from "node:path";
+function computeDPrime(signalScores, noiseScores) {
+  if (signalScores.length === 0 || noiseScores.length === 0)
+    return 0;
+  const mean = (arr) => arr.reduce((s, v) => s + v, 0) / arr.length;
+  const variance = (arr, mu) => arr.reduce((s, v) => s + (v - mu) ** 2, 0) / Math.max(1, arr.length - 1);
+  const muSignal = mean(signalScores);
+  const muNoise = mean(noiseScores);
+  const varSignal = variance(signalScores, muSignal);
+  const varNoise = variance(noiseScores, muNoise);
+  const pooledStd = Math.sqrt((varSignal + varNoise) / 2);
+  if (pooledStd === 0)
+    return muSignal > muNoise ? 3 : 0;
+  return (muSignal - muNoise) / pooledStd;
+}
+function computeSparsity(entries) {
+  if (entries.length <= 1)
+    return 1;
+  const ngramSets = entries.map((e) => {
+    const words = e.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+    const ngrams = /* @__PURE__ */ new Set();
+    for (let i = 0; i < words.length - 1; i++) {
+      ngrams.add(`${words[i]} ${words[i + 1]}`);
+    }
+    return ngrams;
+  });
+  let totalPairs = 0;
+  let totalJaccard = 0;
+  for (let i = 0; i < ngramSets.length; i++) {
+    for (let j = i + 1; j < ngramSets.length; j++) {
+      const a = ngramSets[i];
+      const b = ngramSets[j];
+      if (a.size === 0 && b.size === 0)
+        continue;
+      const intersection = new Set([...a].filter((x) => b.has(x)));
+      const union = /* @__PURE__ */ new Set([...a, ...b]);
+      totalJaccard += union.size > 0 ? intersection.size / union.size : 0;
+      totalPairs++;
+    }
+  }
+  if (totalPairs === 0)
+    return 1;
+  const avgOverlap = totalJaccard / totalPairs;
+  return Math.max(0, Math.min(1, 1 - avgOverlap));
+}
+function adaptTool3(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters,
+    async execute(args) {
+      const result = await tool.execute(args);
+      return { success: result.success, output: result.output, error: result.error };
+    }
+  };
+}
+function renderSNRUpdate(score) {
+  const pct = Math.round(score.ratio * 100);
+  const color = pct >= 70 ? c2.green : pct >= 40 ? c2.yellow : c2.red;
+  const capWarn = score.capacityWarning ? c2.red(" [CAPACITY]") : "";
+  process.stdout.write(`  ${color("\u25C8")} SNR: ${color(`${pct}%`)} (d'=${score.dPrime.toFixed(1)}, signal=${score.signalCount}/${score.entriesEvaluated}, sparsity=${Math.round(score.sparsity * 100)}%) [${score.evaluators.join("+")}]${capWarn}
+`);
+}
+var SNREngine;
+var init_snr_engine = __esm({
+  "packages/cli/dist/tui/snr-engine.js"() {
+    "use strict";
+    init_dist5();
+    init_dist2();
+    init_project_context();
+    init_render();
+    SNREngine = class {
+      config;
+      repoRoot;
+      lastScore = null;
+      evaluationCount = 0;
+      constructor(config, repoRoot) {
+        this.config = config;
+        this.repoRoot = repoRoot;
+      }
+      get score() {
+        return this.lastScore;
+      }
+      /**
+       * Quick local-only SNR estimation (no LLM calls, fast).
+       * @param contextSlots — total context window tokens (for Hopfield capacity warning)
+       */
+      computeLocalSNR(currentTask, contextEntries, contextSlots) {
+        if (contextEntries.length === 0) {
+          return this.makeScore(1, 3, 0, 0, 0, 1, ["local-empty"]);
+        }
+        const taskTerms = new Set(currentTask.toLowerCase().split(/\s+/).filter((w) => w.length > 3).map((w) => w.replace(/[^a-z0-9]/g, "")));
+        const scores = contextEntries.map((entry) => {
+          const entryTerms = entry.toLowerCase().split(/\s+/).filter((w) => w.length > 3).map((w) => w.replace(/[^a-z0-9]/g, ""));
+          const matchCount = entryTerms.filter((t) => taskTerms.has(t)).length;
+          const score2 = entryTerms.length > 0 ? matchCount / Math.sqrt(entryTerms.length) : 0;
+          return { entry, score: score2 };
+        });
+        const allScores = scores.map((s) => s.score);
+        const mean = allScores.reduce((a, b) => a + b, 0) / allScores.length;
+        const std = Math.sqrt(allScores.reduce((a, v) => a + (v - mean) ** 2, 0) / allScores.length);
+        const threshold = mean + 0.5 * std;
+        const signalScores = allScores.filter((s) => s >= threshold);
+        const noiseScores = allScores.filter((s) => s < threshold);
+        const dPrime = computeDPrime(signalScores.length > 0 ? signalScores : [mean], noiseScores.length > 0 ? noiseScores : [0]);
+        const sparsity = computeSparsity(contextEntries);
+        const signalProportion = signalScores.length / allScores.length;
+        const dPrimeNorm = Math.min(1, Math.max(0, dPrime / 3));
+        const ratio = 0.5 * signalProportion + 0.3 * dPrimeNorm + 0.2 * sparsity;
+        const capacityWarning = contextSlots ? contextEntries.length > Math.floor(contextSlots * 0.138) : false;
+        const score = this.makeScore(ratio, dPrime, contextEntries.length, signalScores.length, noiseScores.length, sparsity, ["local-keyword"], capacityWarning);
+        this.lastScore = score;
+        this.evaluationCount++;
+        return score;
+      }
+      /**
+       * Full SNR evaluation using parallel LLM evaluator agents.
+       * Mirrors PFC gating + multi-agent debate (Du et al. 2023).
+       *
+       * Spawns 2 lightweight agents with different evaluation perspectives:
+       * - "Relevance Evaluator" — scores entries by task relevance (PFC role)
+       * - "Noise Detector" — identifies redundant/stale/irrelevant entries (DG role)
+       *
+       * Their consensus determines the final SNR.
+       */
+      async evaluateWithAgents(currentTask, memoryTopics, onEvent) {
+        const entries = this.loadMemoryEntries(memoryTopics);
+        if (entries.length === 0) {
+          const score2 = this.makeScore(1, 3, 0, 0, 0, 1, ["agents-empty"]);
+          this.lastScore = score2;
+          return score2;
+        }
+        const entrySummaries = entries.map((e, i) => `[${i}] topic=${e.topic} key=${e.key}: ${e.value.slice(0, 200)}${e.value.length > 200 ? "..." : ""}`);
+        const entriesBlock = entrySummaries.join("\n");
+        const [relevanceResult, noiseResult] = await Promise.allSettled([
+          this.runEvaluatorAgent("relevance", `You are a Prefrontal Cortex Gating Evaluator. Your role is to assess which
+memory entries are RELEVANT to the current task.
+
+CURRENT TASK: ${currentTask}
+
+MEMORY ENTRIES TO EVALUATE:
+${entriesBlock}
+
+For each entry, output a JSON array of objects:
+[{"index": 0, "score": 0.8, "reason": "directly related to task"}, ...]
+
+Score 0-1 where:
+- 1.0 = directly relevant to the current task
+- 0.7 = supporting context (useful background)
+- 0.4 = marginally relevant
+- 0.1 = not relevant to current task
+
+Call task_complete with the JSON array when done.`, onEvent),
+          this.runEvaluatorAgent("noise", `You are a Dentate Gyrus Pattern Separation Evaluator. Your role is to identify
+NOISE in the memory context \u2014 entries that are redundant, stale, or interfering.
+
+CURRENT TASK: ${currentTask}
+
+MEMORY ENTRIES TO EVALUATE:
+${entriesBlock}
+
+For each entry, output a JSON array of objects:
+[{"index": 0, "noise_score": 0.2, "reason": "unique, not redundant"}, ...]
+
+Noise score 0-1 where:
+- 1.0 = pure noise (completely redundant, stale, or interfering with task)
+- 0.7 = mostly noise (outdated or largely redundant with another entry)
+- 0.4 = moderate noise (some overlap with other entries)
+- 0.1 = clean signal (unique, fresh, non-interfering)
+
+Look for: duplicate information, outdated facts, entries that contradict
+newer entries, entries about completely unrelated topics.
+
+Call task_complete with the JSON array when done.`, onEvent)
+        ]);
+        const relevanceScores = this.parseEvaluatorResult(relevanceResult.status === "fulfilled" ? relevanceResult.value : "", entries.length, 0.5);
+        const noiseScores = this.parseEvaluatorResult(noiseResult.status === "fulfilled" ? noiseResult.value : "", entries.length, 0.5);
+        const combinedScores = entries.map((_, i) => {
+          const rel = relevanceScores[i] ?? 0.5;
+          const noise = noiseScores[i] ?? 0.5;
+          const votes = [rel, 1 - noise].sort((a, b) => a - b);
+          return (votes[0] + votes[1]) / 2;
+        });
+        const mean = combinedScores.reduce((a, b) => a + b, 0) / combinedScores.length;
+        const std = Math.sqrt(combinedScores.reduce((a, v) => a + (v - mean) ** 2, 0) / combinedScores.length);
+        const threshold = Math.max(0.3, mean);
+        const signalEntries = combinedScores.filter((s) => s >= threshold);
+        const noiseEntries = combinedScores.filter((s) => s < threshold);
+        const dPrime = computeDPrime(signalEntries.length > 0 ? signalEntries : [mean], noiseEntries.length > 0 ? noiseEntries : [0.1]);
+        const sparsity = computeSparsity(entries.map((e) => e.value));
+        const signalProportion = signalEntries.length / combinedScores.length;
+        const dPrimeNorm = Math.min(1, Math.max(0, dPrime / 3));
+        const ratio = 0.5 * signalProportion + 0.3 * dPrimeNorm + 0.2 * sparsity;
+        const evaluators = [
+          relevanceResult.status === "fulfilled" ? "relevance-agent" : "relevance-failed",
+          noiseResult.status === "fulfilled" ? "noise-agent" : "noise-failed"
+        ];
+        const score = this.makeScore(ratio, dPrime, entries.length, signalEntries.length, noiseEntries.length, sparsity, evaluators);
+        this.lastScore = score;
+        this.evaluationCount++;
+        return score;
+      }
+      // ── Evaluator agent ──────────────────────────────────────────────────
+      async runEvaluatorAgent(name, 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: 5,
+          // Evaluators are very focused — 5 turns max
+          maxTokens: 4096,
+          temperature: 0,
+          // Deterministic scoring
+          requestTimeoutMs: this.config.timeoutMs,
+          taskTimeoutMs: this.config.timeoutMs,
+          compactionThreshold: modelTier === "small" ? 8e3 : 16e3,
+          modelTier
+        });
+        const tools = [
+          new MemoryReadTool(this.repoRoot),
+          new MemorySearchTool(this.repoRoot)
+        ];
+        runner.registerTools([
+          ...tools.map(adaptTool3),
+          {
+            name: "task_complete",
+            description: "Signal evaluation is complete with your scored results.",
+            parameters: {
+              type: "object",
+              properties: {
+                summary: { type: "string", description: "JSON array of scored entries" }
+              },
+              required: ["summary"]
+            },
+            async execute(args) {
+              return { success: true, output: args["summary"] || "[]" };
+            }
+          }
+        ]);
+        if (onEvent)
+          runner.onEvent(onEvent);
+        const result = await runner.run(prompt, `SNR Evaluator (${name}). Working directory: ${this.repoRoot}`);
+        return result.summary || "[]";
+      }
+      // ── Memory loading ───────────────────────────────────────────────────
+      loadMemoryEntries(topics) {
+        const entries = [];
+        const dirs = [
+          join37(this.repoRoot, ".oa", "memory"),
+          join37(this.repoRoot, ".open-agents", "memory")
+        ];
+        for (const dir of dirs) {
+          if (!existsSync27(dir))
+            continue;
+          try {
+            const files = readdirSync12(dir).filter((f) => f.endsWith(".json"));
+            for (const f of files) {
+              const topic = basename14(f, ".json");
+              if (topics.length > 0 && !topics.includes(topic))
+                continue;
+              try {
+                const data = JSON.parse(readFileSync20(join37(dir, f), "utf-8"));
+                for (const [key, val] of Object.entries(data)) {
+                  const value = typeof val === "object" && val !== null && "value" in val ? String(val.value) : String(val);
+                  entries.push({ topic, key, value });
+                }
+              } catch {
+              }
+            }
+          } catch {
+          }
+        }
+        return entries;
+      }
+      // ── Result parsing ───────────────────────────────────────────────────
+      parseEvaluatorResult(summary, entryCount, defaultScore) {
+        const scores = new Array(entryCount).fill(defaultScore);
+        try {
+          const jsonMatch = summary.match(/\[[\s\S]*\]/);
+          if (!jsonMatch)
+            return scores;
+          const parsed = JSON.parse(jsonMatch[0]);
+          for (const item of parsed) {
+            const idx = typeof item.index === "number" ? item.index : -1;
+            const score = typeof item.score === "number" ? item.score : typeof item.noise_score === "number" ? item.noise_score : defaultScore;
+            if (idx >= 0 && idx < entryCount) {
+              scores[idx] = Math.max(0, Math.min(1, score));
+            }
+          }
+        } catch {
+        }
+        return scores;
+      }
+      // ── Memory pruning recommendations ──────────────────────────────────
+      /**
+       * Identify low-SNR memory entries that should be pruned.
+       * Mirrors synaptic downscaling during slow-wave sleep — weak connections
+       * (low-relevance, high-redundancy entries) are depotentiated.
+       *
+       * Returns topics+keys of entries scoring below the noise threshold.
+       * Does NOT delete anything — the caller decides what to do with the list.
+       */
+      getPruningCandidates(currentTask, noiseThreshold = 0.3) {
+        const entries = this.loadMemoryEntries([]);
+        if (entries.length === 0)
+          return [];
+        const taskTerms = new Set(currentTask.toLowerCase().split(/\s+/).filter((w) => w.length > 3).map((w) => w.replace(/[^a-z0-9]/g, "")));
+        const candidates = [];
+        for (const entry of entries) {
+          const entryTerms = entry.value.toLowerCase().split(/\s+/).filter((w) => w.length > 3).map((w) => w.replace(/[^a-z0-9]/g, ""));
+          const matchCount = entryTerms.filter((t) => taskTerms.has(t)).length;
+          const relevance = entryTerms.length > 0 ? matchCount / Math.sqrt(entryTerms.length) : 0;
+          if (relevance < noiseThreshold) {
+            candidates.push({
+              topic: entry.topic,
+              key: entry.key,
+              score: relevance,
+              reason: relevance === 0 ? "no keyword overlap with current task" : `low relevance (${(relevance * 100).toFixed(0)}% < ${(noiseThreshold * 100).toFixed(0)}% threshold)`
+            });
+          }
+        }
+        return candidates.sort((a, b) => a.score - b.score);
+      }
+      // ── Helpers ──────────────────────────────────────────────────────────
+      makeScore(ratio, dPrime, total, signal, noise, sparsity, evaluators, capacityWarning = false) {
+        return {
+          ratio: Math.max(0, Math.min(1, ratio)),
+          dPrime: Math.max(0, dPrime),
+          entriesEvaluated: total,
+          signalCount: signal,
+          noiseCount: noise,
+          sparsity: Math.max(0, Math.min(1, sparsity)),
+          evaluatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          evaluators,
+          capacityWarning
+        };
+      }
+    };
+  }
+});
+
 // packages/cli/dist/tui/telegram-bridge.js
 function renderTelegramStart(botUsername, adminId) {
   process.stdout.write(`
@@ -24327,7 +24740,7 @@ function themeForTool(toolName) {
       return THEME_DEFAULT;
   }
 }
-var DENSITY, WAVE, THEME_DEFAULT, THEME_FILE, THEME_SHELL, THEME_WEB, THEME_SEARCH, THEME_MEMORY, THEME_SKILL, THEME_TOOL_CREATE, DEFAULT_METRICS, BrailleSpinner;
+var DENSITY, WAVE, THEME_DEFAULT, THEME_FILE, THEME_SHELL, THEME_WEB, THEME_SEARCH, THEME_MEMORY, THEME_SKILL, THEME_TOOL_CREATE, THEME_DREAM, DEFAULT_METRICS, BrailleSpinner;
 var init_braille_spinner = __esm({
   "packages/cli/dist/tui/braille-spinner.js"() {
     "use strict";
@@ -24384,10 +24797,16 @@ var init_braille_spinner = __esm({
       ramp: [237, 173, 174, 179, 180, 215, 216, 222, 229],
       speed: 2
     };
+    THEME_DREAM = {
+      ramp: [237, 94, 130, 136, 172, 178, 179, 214, 220],
+      speed: 1
+    };
     DEFAULT_METRICS = {
       contextPct: 0,
       tokenRate: 0,
-      isStreaming: false
+      isStreaming: false,
+      snr: 0.5,
+      isDreaming: false
     };
     BrailleSpinner = class {
       frame = 0;
@@ -24439,6 +24858,10 @@ var init_braille_spinner = __esm({
           this._metrics.tokenRate = metrics.tokenRate;
         if (metrics.isStreaming !== void 0)
           this._metrics.isStreaming = metrics.isStreaming;
+        if (metrics.snr !== void 0)
+          this._metrics.snr = Math.max(0, Math.min(1, metrics.snr));
+        if (metrics.isDreaming !== void 0)
+          this._metrics.isDreaming = metrics.isDreaming;
       }
       /**
        * Render the current animation frame as an ANSI-colored string.
@@ -24450,28 +24873,41 @@ var init_braille_spinner = __esm({
        *   used — gentle ripples at low usage, full waves at high usage.
        * - Slinky: a secondary slow sine wave creates organic compression and
        *   expansion across columns, making the wave feel elastic and alive.
+       * - SNR entropy: low SNR injects phase jitter per-column (noisy neural signal),
+       *   high SNR produces smooth coherent waves (clean signal propagation).
+       * - Dream mode: slower, deeper breathing with warm amber color override.
        */
       render(width) {
         const cycleLen = WAVE.length;
-        const baseSpeed = this.theme.speed;
         const m = this._metrics;
-        const breathPhase = Math.sin(this.frame * 0.08);
+        const activeTheme = m.isDreaming ? THEME_DREAM : this.theme;
+        const activeColorRamp = m.isDreaming ? buildColorRamp(THEME_DREAM.ramp) : this.colorRamp;
+        const baseSpeed = activeTheme.speed;
+        const breathRate = m.isDreaming ? 0.04 : 0.08;
+        const breathPhase = Math.sin(this.frame * breathRate);
         let speed;
         if (m.isStreaming && m.tokenRate > 0) {
           const rateBoost = Math.min(4, m.tokenRate / 8);
           speed = baseSpeed + rateBoost + breathPhase * 0.3;
+        } else if (m.isDreaming) {
+          speed = baseSpeed * 0.6 + breathPhase * 1.2;
         } else {
           speed = baseSpeed + breathPhase * 0.8;
         }
         const pressure = Math.max(0, Math.min(100, m.contextPct)) / 100;
         const densityScale = 0.3 + pressure * 0.7;
+        const snr = m.snr;
+        const entropy = Math.max(0, 1 - snr);
         const slinkyFreq = 0.02 + (m.isStreaming ? 0.01 : 0);
         const slinkyAmp = 1.5 + pressure * 2;
+        const jitterSeed = this.frame * 7919;
         let buf = "";
         let lastColor = -1;
         for (let col = 0; col < width; col++) {
           const slinkyOffset = Math.sin(col * 0.1 + this.frame * slinkyFreq) * slinkyAmp;
-          const rawPhase = col * speed + this.frame + slinkyOffset;
+          const jitterHash = Math.sin((col * 127 + jitterSeed) * 1e-3) * 2 + Math.cos((col * 311 + jitterSeed) * 7e-4) * 1.5;
+          const snrJitter = jitterHash * entropy * 3;
+          const rawPhase = col * speed + this.frame + slinkyOffset + snrJitter;
           const normalizedPhase = (rawPhase % cycleLen + cycleLen) % cycleLen;
           const waveIdx = Math.round(normalizedPhase) % cycleLen;
           let amplitude;
@@ -24489,7 +24925,7 @@ var init_braille_spinner = __esm({
           }
           scaledIdx = Math.max(0, Math.min(cycleLen - 1, scaledIdx));
           const ch = WAVE[scaledIdx];
-          const color = this.colorRamp[scaledIdx];
+          const color = activeColorRamp[scaledIdx];
           if (color !== lastColor) {
             buf += `\x1B[38;5;${color}m`;
             lastColor = color;
@@ -24801,6 +25237,13 @@ var init_status_bar = __esm({
       setActiveTool(toolName) {
         this._brailleSpinner.setTool(toolName);
       }
+      /**
+       * Forward metrics directly to the braille spinner.
+       * Used for SNR, dream mode, and other neural activity indicators.
+       */
+      setBrailleMetrics(metrics) {
+        this._brailleSpinner.setMetrics(metrics);
+      }
       /** Context window size to display. Can be updated if model changes. */
       setContextWindowSize(size) {
         this.metrics.contextWindowSize = size;
@@ -24827,6 +25270,21 @@ var init_status_bar = __esm({
       recordSpeedTaskEnd() {
         this._speedTracker.taskEnd();
       }
+      /** SNR (Signal-to-Noise Ratio) from context quality evaluation */
+      _snr = null;
+      /** Update the SNR gauge with a new evaluation result */
+      setSNR(ratio, dPrime, capacityWarning) {
+        this._snr = { ratio, dPrime, capacityWarning };
+        this._brailleSpinner.setMetrics({ snr: ratio });
+        if (this.active)
+          this.renderFooterPreserveCursor();
+      }
+      /** Clear the SNR gauge (e.g., when starting a fresh task) */
+      clearSNR() {
+        this._snr = null;
+        if (this.active)
+          this.renderFooterPreserveCursor();
+      }
       /** Model capabilities — shown as emoji indicators on the status bar */
       _caps = {
         vision: false,
@@ -25033,6 +25491,14 @@ var init_status_bar = __esm({
           const costStr = m.estimatedCost < 0.01 ? `$${m.estimatedCost.toFixed(4)}` : m.estimatedCost < 1 ? `$${m.estimatedCost.toFixed(3)}` : `$${m.estimatedCost.toFixed(2)}`;
           costLabel = pipe + pastel2(222, "Cost: ") + c2.bold(costStr);
         }
+        let snrLabel = "";
+        if (this._snr) {
+          const snrPct = Math.round(this._snr.ratio * 100);
+          const snrColor = snrPct >= 70 ? c2.green : snrPct >= 40 ? c2.yellow : c2.red;
+          const dPrimeStr = this._snr.dPrime.toFixed(1);
+          const capStr = this._snr.capacityWarning ? c2.red(" !CAP") : "";
+          snrLabel = pipe + pastel2(183, "SNR: ") + snrColor(c2.bold(`${snrPct}%`)) + c2.dim(` d'${dPrimeStr}`) + capStr;
+        }
         let speedLabel = "";
         if (this._speedTracker.hasData) {
           const ratio = this._speedTracker.getSpeedRatio();
@@ -25056,7 +25522,7 @@ var init_status_bar = __esm({
         if (this._caps.thinking)
           capParts.push("\u{1F9E0}");
         const capsLabel = capParts.length > 0 ? pipe + pastel2(183, capParts.join(" ")) : "";
-        return ` ${tokInLabel}${pipe}${tokOutLabel}${pipe}${ctxLabel}${speedLabel}${costLabel}${capsLabel}${recordingLabel}`;
+        return ` ${tokInLabel}${pipe}${tokOutLabel}${pipe}${ctxLabel}${snrLabel}${speedLabel}${costLabel}${capsLabel}${recordingLabel}`;
       }
       // -------------------------------------------------------------------------
       // Private
@@ -25335,11 +25801,11 @@ var init_status_bar = __esm({
 import * as readline2 from "node:readline";
 import { Writable } from "node:stream";
 import { cwd } from "node:process";
-import { resolve as resolve23, join as join37, dirname as dirname11, extname as extname9 } from "node:path";
+import { resolve as resolve23, join as join38, dirname as dirname11, extname as extname9 } from "node:path";
 import { createRequire as createRequire2 } from "node:module";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
-import { readFileSync as readFileSync20, rmSync as rmSync2 } from "node:fs";
-import { existsSync as existsSync27 } from "node:fs";
+import { readFileSync as readFileSync21, rmSync as rmSync2, readdirSync as readdirSync13 } from "node:fs";
+import { existsSync as existsSync28 } from "node:fs";
 function formatTimeAgo(date) {
   const seconds = Math.floor((Date.now() - date.getTime()) / 1e3);
   if (seconds < 60)
@@ -25358,12 +25824,12 @@ function getVersion() {
     const require2 = createRequire2(import.meta.url);
     const thisDir = dirname11(fileURLToPath8(import.meta.url));
     const candidates = [
-      join37(thisDir, "..", "package.json"),
-      join37(thisDir, "..", "..", "package.json"),
-      join37(thisDir, "..", "..", "..", "package.json")
+      join38(thisDir, "..", "package.json"),
+      join38(thisDir, "..", "..", "package.json"),
+      join38(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
-      if (existsSync27(pkgPath)) {
+      if (existsSync28(pkgPath)) {
         const pkg = require2(pkgPath);
         if (pkg.name === "open-agents-ai" || pkg.name === "@open-agents/cli") {
           return pkg.version ?? "0.0.0";
@@ -25374,7 +25840,7 @@ function getVersion() {
   }
   return "0.0.0";
 }
-function adaptTool3(tool) {
+function adaptTool4(tool) {
   return {
     name: tool.name,
     description: tool.description,
@@ -25470,7 +25936,7 @@ function buildTools(repoRoot, config, contextWindowSize) {
     new AgendaTool(repoRoot)
   ];
   return [
-    ...executionTools.map(adaptTool3),
+    ...executionTools.map(adaptTool4),
     createSubAgentTool(config, repoRoot, contextWindowSize),
     createTaskCompleteTool()
   ];
@@ -25522,7 +25988,7 @@ function createSubAgentTool(config, repoRoot, ctxWindowSize) {
         new MemoryReadTool(repoRoot),
         new MemoryWriteTool(repoRoot)
       ];
-      subRunner.registerTools(subTools.map(adaptTool3));
+      subRunner.registerTools(subTools.map(adaptTool4));
       subRunner.registerTool(createTaskCompleteTool());
       if (background) {
         const promise = subRunner.run(task, `Working directory: ${repoRoot}`).then((result2) => {
@@ -25552,7 +26018,30 @@ Use task_status("${taskId}") or task_output("${taskId}") to check progress.`
     }
   };
 }
-function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce, statusBar, sudoCallback, costTracker, onComplete, taskType, contextWindowSize, modelCaps, personality) {
+function gatherMemorySnippets(root) {
+  const snippets = [];
+  const dirs = [
+    join38(root, ".oa", "memory"),
+    join38(root, ".open-agents", "memory")
+  ];
+  for (const dir of dirs) {
+    if (!existsSync28(dir))
+      continue;
+    try {
+      for (const f of readdirSync13(dir).filter((f2) => f2.endsWith(".json"))) {
+        const data = JSON.parse(readFileSync21(join38(dir, f), "utf-8"));
+        for (const val of Object.values(data)) {
+          const v = typeof val === "object" && val !== null && "value" in val ? String(val.value) : String(val);
+          if (v.length > 10)
+            snippets.push(v);
+        }
+      }
+    } catch {
+    }
+  }
+  return snippets;
+}
+function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce, statusBar, sudoCallback, costTracker, onComplete, taskType, contextWindowSize, modelCaps, personality, deepContext, onCompaction) {
   const voiceStyleMap = {
     concise: 1,
     balanced: 3,
@@ -25576,6 +26065,7 @@ function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce
     taskTimeoutMs: 36e5,
     // 60 minutes — never give up prematurely
     compactionThreshold,
+    deepContext: deepContext ?? false,
     dynamicContext,
     modelTier,
     streamEnabled: stream?.enabled ?? false,
@@ -25686,7 +26176,7 @@ ${entry.fullContent}`
             renderVoiceText(desc);
             voice.speak(desc);
           }
-          renderToolCallStart(event.toolName ?? "unknown", event.toolArgs ?? {});
+          renderToolCallStart(event.toolName ?? "unknown", event.toolArgs ?? {}, config.verbose);
         });
         break;
       case "tool_result": {
@@ -25702,7 +26192,7 @@ ${entry.fullContent}`
         const toolDurationMs = toolCallStartMs > 0 ? Date.now() - toolCallStartMs : 0;
         toolCallStartMs = 0;
         contentWrite(() => {
-          renderToolResult(event.toolName ?? "unknown", event.success ?? false, event.content ?? "");
+          renderToolResult(event.toolName ?? "unknown", event.success ?? false, event.content ?? "", config.verbose);
           if (config.verbose && toolDurationMs > 0) {
             const durStr = toolDurationMs < 1e3 ? `${toolDurationMs}ms` : `${(toolDurationMs / 1e3).toFixed(1)}s`;
             const sizeStr = resultLen > 0 ? ` | ${resultLen.toLocaleString()} chars (~${Math.ceil(resultLen / 4).toLocaleString()} tokens)` : "";
@@ -25764,6 +26254,8 @@ ${entry.fullContent}`
         break;
       case "compaction":
         contentWrite(() => renderWarning(`Context compacted: ${event.content}`));
+        if (onCompaction)
+          onCompaction();
         break;
       case "status":
         contentWrite(() => renderInfo(event.content ?? ""));
@@ -25924,6 +26416,7 @@ async function startInteractive(config, repoPath) {
   let streamEnabled = savedSettings.stream ?? false;
   let bruteForceEnabled = savedSettings.bruteforce ?? true;
   let currentStyle = PRESET_NAMES.includes(savedSettings.style) ? savedSettings.style : "balanced";
+  let deepContextEnabled = savedSettings.deepContext ?? false;
   if (savedSettings.emojis !== void 0)
     setEmojisEnabled(savedSettings.emojis);
   if (savedSettings.colors !== void 0)
@@ -26067,6 +26560,37 @@ async function startInteractive(config, repoPath) {
   let dreamEngine = null;
   let blessEngine = null;
   let dmnEngine = null;
+  const snrEngine = new SNREngine(config, repoRoot);
+  let pendingSNREval = null;
+  function scheduleAgentSNREval(taskPrompt) {
+    if (pendingSNREval)
+      return;
+    pendingSNREval = (async () => {
+      try {
+        const score = await snrEngine.evaluateWithAgents(taskPrompt, []);
+        statusBar.setSNR(score.ratio, score.dPrime, score.capacityWarning);
+        renderSNRUpdate(score);
+      } catch {
+      } finally {
+        pendingSNREval = null;
+      }
+    })();
+  }
+  function compactionSNRCallback() {
+    if (!deepContextEnabled)
+      return void 0;
+    return () => {
+      try {
+        const memSnippets = gatherMemorySnippets(repoRoot);
+        if (memSnippets.length > 0 && lastSubmittedPrompt) {
+          const snr = snrEngine.computeLocalSNR(lastSubmittedPrompt, memSnippets, resolvedContextWindowSize);
+          statusBar.setSNR(snr.ratio, snr.dPrime, snr.capacityWarning);
+          scheduleAgentSNREval(lastSubmittedPrompt);
+        }
+      } catch {
+      }
+    };
+  }
   let telegramBridge = null;
   let activeTelegramChatId = null;
   let dmnRetriggerTimer = null;
@@ -26096,6 +26620,8 @@ Respond concisely and safely.`;
         return;
       }
       writeContent(() => renderInfo("DMN re-activating..."));
+      statusBar.setProcessing(true);
+      statusBar.setBrailleMetrics({ isDreaming: true });
       try {
         const proposal = await dmnEngine.runCycle((event) => {
           if (event.type === "tool_call") {
@@ -26103,6 +26629,8 @@ Respond concisely and safely.`;
 `));
           }
         });
+        statusBar.setProcessing(false);
+        statusBar.setBrailleMetrics({ isDreaming: false });
         if (proposal) {
           const provenanceNote = proposal.provenance.length > 0 ? `
 
@@ -26118,6 +26646,8 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
           scheduleDMNRetrigger(6e4);
         }
       } catch (err) {
+        statusBar.setProcessing(false);
+        statusBar.setBrailleMetrics({ isDreaming: false });
         writeContent(() => renderWarning(`DMN cycle error: ${err instanceof Error ? err.message : String(err)}`));
         scheduleDMNRetrigger(6e4);
       }
@@ -26175,6 +26705,7 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
     "/telegram",
     "/compact",
     "/gc",
+    "/deep",
     "/style",
     "/personality"
   ];
@@ -26336,6 +26867,10 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
       bruteForceEnabled = !bruteForceEnabled;
       return bruteForceEnabled;
     },
+    deepContextToggle() {
+      deepContextEnabled = !deepContextEnabled;
+      return deepContextEnabled;
+    },
     setStyle(preset) {
       currentStyle = preset;
     },
@@ -26376,6 +26911,8 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
       }
       dreamEngine = new DreamEngine(currentConfig, repoRoot);
       writeContent(() => renderDreamStart(mode));
+      statusBar.setProcessing(true);
+      statusBar.setBrailleMetrics({ isDreaming: true });
       dreamEngine.start(mode, (event) => {
         if (event.type === "tool_call") {
           writeContent(() => renderToolCallStart(event.toolName ?? "unknown", event.toolArgs ?? {}));
@@ -26389,10 +26926,14 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
           });
         }
       }).then((state) => {
+        statusBar.setProcessing(false);
+        statusBar.setBrailleMetrics({ isDreaming: false });
         writeContent(() => renderDreamEnd(state));
         dreamEngine = null;
         showPrompt();
       }).catch((err) => {
+        statusBar.setProcessing(false);
+        statusBar.setBrailleMetrics({ isDreaming: false });
         writeContent(() => renderError(`Dream error: ${err instanceof Error ? err.message : String(err)}`));
         dreamEngine = null;
         showPrompt();
@@ -26402,6 +26943,8 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
       if (dreamEngine?.isActive) {
         dreamEngine.stop();
         dreamEngine = null;
+        statusBar.setProcessing(false);
+        statusBar.setBrailleMetrics({ isDreaming: false });
       }
     },
     isDreaming() {
@@ -26615,8 +27158,8 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       return true;
     },
     destroyProject() {
-      const oaPath = join37(repoRoot, OA_DIR);
-      if (existsSync27(oaPath)) {
+      const oaPath = join38(repoRoot, OA_DIR);
+      if (existsSync28(oaPath)) {
         try {
           rmSync2(oaPath, { recursive: true, force: true });
           writeContent(() => renderInfo(`Removed ${OA_DIR}/ directory.`));
@@ -26875,7 +27418,7 @@ Execute this skill now. Follow the behavioral guidance above.`;
             toolPatternStore: toolPatternStore ?? void 0
           }, bruteForceEnabled, statusBar, handleSudoRequest, costTracker, (summary) => {
             lastCompletedSummary = summary;
-          }, currentTaskType, resolvedContextWindowSize, resolvedCaps, currentStyle);
+          }, currentTaskType, resolvedContextWindowSize, resolvedCaps, currentStyle, deepContextEnabled, compactionSNRCallback());
           activeTask = task;
           showPrompt();
           await task.promise;
@@ -26890,13 +27433,13 @@ Execute this skill now. Follow the behavioral guidance above.`;
       }
     }
     const cleanPath = input.replace(/^['"]|['"]$/g, "").trim();
-    const isImage = isImagePath(cleanPath) && existsSync27(resolve23(repoRoot, cleanPath));
-    const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync27(resolve23(repoRoot, cleanPath));
+    const isImage = isImagePath(cleanPath) && existsSync28(resolve23(repoRoot, cleanPath));
+    const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync28(resolve23(repoRoot, cleanPath));
     if (activeTask) {
       if (isImage) {
         try {
           const imgPath = resolve23(repoRoot, cleanPath);
-          const imgBuffer = readFileSync20(imgPath);
+          const imgBuffer = readFileSync21(imgPath);
           const base64 = imgBuffer.toString("base64");
           const ext = extname9(cleanPath).toLowerCase();
           const mime = ext === ".png" ? "image/png" : ext === ".gif" ? "image/gif" : ext === ".webp" ? "image/webp" : "image/jpeg";
@@ -26965,6 +27508,14 @@ Summarize or analyze this transcription as appropriate.`;
     const displayText = isImage ? `[Image: ${cleanPath}]` : inputLineCount > 1 ? `[pasted ${inputLineCount} lines]` : fullInput;
     writeContent(() => renderUserMessage(displayText));
     lastSubmittedPrompt = fullInput;
+    try {
+      const memSnippets = gatherMemorySnippets(repoRoot);
+      if (memSnippets.length > 0) {
+        const snr = snrEngine.computeLocalSNR(fullInput, memSnippets, resolvedContextWindowSize);
+        statusBar.setSNR(snr.ratio, snr.dPrime, snr.capacityWarning);
+      }
+    } catch {
+    }
     let taskInput = fullInput;
     if (restoredSessionContext) {
       taskInput = `${restoredSessionContext}
@@ -26987,7 +27538,7 @@ NEW TASK: ${fullInput}`;
         toolPatternStore: toolPatternStore ?? void 0
       }, bruteForceEnabled, statusBar, handleSudoRequest, costTracker, (summary) => {
         lastCompletedSummary = summary;
-      }, currentTaskType, resolvedContextWindowSize, resolvedCaps, currentStyle);
+      }, currentTaskType, resolvedContextWindowSize, resolvedCaps, currentStyle, deepContextEnabled, compactionSNRCallback());
       activeTask = task;
       showPrompt();
       await task.promise;
@@ -27016,6 +27567,17 @@ NEW TASK: ${fullInput}`;
     } finally {
       statusBar.setProcessing(false);
       statusBar.recordSpeedTaskEnd();
+      try {
+        const memSnippets = gatherMemorySnippets(repoRoot);
+        if (memSnippets.length > 0 && lastSubmittedPrompt) {
+          const snr = snrEngine.computeLocalSNR(lastSubmittedPrompt, memSnippets, resolvedContextWindowSize);
+          statusBar.setSNR(snr.ratio, snr.dPrime, snr.capacityWarning);
+        }
+      } catch {
+      }
+      if (deepContextEnabled && lastSubmittedPrompt) {
+        scheduleAgentSNREval(lastSubmittedPrompt);
+      }
       if (activeTask) {
         sessionFilesTouched = Array.from(activeTask.filesTouched);
         sessionToolCallCount = activeTask.toolCallCount;
@@ -27070,6 +27632,8 @@ Respond concisely and safely.`;
       }
       if (dmnEngine) {
         writeContent(() => renderInfo("No queued tasks \u2014 DMN self-reflection activating..."));
+        statusBar.setProcessing(true);
+        statusBar.setBrailleMetrics({ isDreaming: true });
         try {
           const proposal = await dmnEngine.runCycle((event) => {
             if (event.type === "tool_call") {
@@ -27077,6 +27641,8 @@ Respond concisely and safely.`;
 `));
             }
           });
+          statusBar.setProcessing(false);
+          statusBar.setBrailleMetrics({ isDreaming: false });
           if (proposal) {
             const provenanceNote = proposal.provenance.length > 0 ? `
 
@@ -27096,6 +27662,8 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
             scheduleDMNRetrigger(cooldownSec * 1e3);
           }
         } catch (err) {
+          statusBar.setProcessing(false);
+          statusBar.setBrailleMetrics({ isDreaming: false });
           writeContent(() => renderWarning(`DMN cycle error: ${err instanceof Error ? err.message : String(err)}`));
           if (blessEngine?.isActive) {
             scheduleDMNRetrigger(6e4);
@@ -27210,6 +27778,7 @@ var init_interactive = __esm({
     init_dream_engine();
     init_bless_engine();
     init_dmn_engine();
+    init_snr_engine();
     init_telegram_bridge();
     init_status_bar();
     init_dist6();
@@ -27248,7 +27817,7 @@ import { glob } from "glob";
 import ignore from "ignore";
 import { readFile as readFile14, stat as stat4 } from "node:fs/promises";
 import { createHash } from "node:crypto";
-import { join as join38, relative as relative3, extname as extname10, basename as basename14 } from "node:path";
+import { join as join39, relative as relative3, extname as extname10, basename as basename15 } from "node:path";
 var DEFAULT_EXCLUDE, LANGUAGE_MAP, CodebaseIndexer;
 var init_codebase_indexer = __esm({
   "packages/indexer/dist/codebase-indexer.js"() {
@@ -27292,7 +27861,7 @@ var init_codebase_indexer = __esm({
         const ig = ignore.default();
         if (this.config.respectGitignore) {
           try {
-            const gitignoreContent = await readFile14(join38(this.config.rootDir, ".gitignore"), "utf-8");
+            const gitignoreContent = await readFile14(join39(this.config.rootDir, ".gitignore"), "utf-8");
             ig.add(gitignoreContent);
           } catch {
           }
@@ -27307,7 +27876,7 @@ var init_codebase_indexer = __esm({
         for (const relativePath of files) {
           if (ig.ignores(relativePath))
             continue;
-          const fullPath = join38(this.config.rootDir, relativePath);
+          const fullPath = join39(this.config.rootDir, relativePath);
           try {
             const fileStat = await stat4(fullPath);
             if (fileStat.size > this.config.maxFileSize)
@@ -27330,7 +27899,7 @@ var init_codebase_indexer = __esm({
       }
       buildTree(files) {
         const root = {
-          name: basename14(this.config.rootDir),
+          name: basename15(this.config.rootDir),
           path: this.config.rootDir,
           type: "directory",
           children: []
@@ -27353,7 +27922,7 @@ var init_codebase_indexer = __esm({
               if (!child) {
                 child = {
                   name: part,
-                  path: join38(current.path, part),
+                  path: join39(current.path, part),
                   type: "directory",
                   children: []
                 };
@@ -27436,13 +28005,13 @@ __export(index_repo_exports, {
   indexRepoCommand: () => indexRepoCommand
 });
 import { resolve as resolve24 } from "node:path";
-import { existsSync as existsSync28, statSync as statSync10 } from "node:fs";
+import { existsSync as existsSync29, statSync as statSync10 } from "node:fs";
 import { cwd as cwd2 } from "node:process";
 async function indexRepoCommand(opts, _config) {
   const repoRoot = resolve24(opts.repoPath ?? cwd2());
   printHeader("Index Repository");
   printInfo(`Indexing: ${repoRoot}`);
-  if (!existsSync28(repoRoot)) {
+  if (!existsSync29(repoRoot)) {
     printError(`Path does not exist: ${repoRoot}`);
     process.exit(1);
   }
@@ -27694,7 +28263,7 @@ var config_exports = {};
 __export(config_exports, {
   configCommand: () => configCommand
 });
-import { join as join39, resolve as resolve25 } from "node:path";
+import { join as join40, resolve as resolve25 } from "node:path";
 import { homedir as homedir13 } from "node:os";
 import { cwd as cwd3 } from "node:process";
 function redactIfSensitive(key, value) {
@@ -27753,7 +28322,7 @@ function handleShow(opts, config) {
     }
   }
   printSection("Config File");
-  printInfo(`~/.open-agents/config.json (${join39(homedir13(), ".open-agents", "config.json")})`);
+  printInfo(`~/.open-agents/config.json (${join40(homedir13(), ".open-agents", "config.json")})`);
   printSection("Priority Chain");
   printInfo("  1. CLI flags (--model, --backend-url, etc.)");
   printInfo("  2. Project .oa/settings.json (--local)");
@@ -27792,7 +28361,7 @@ function handleSet(opts, _config) {
       const coerced = coerceForSettings(key, value);
       saveProjectSettings(repoRoot, { [key]: coerced });
       printSuccess(`Project override set: ${key} = ${redactIfSensitive(key, value)}`);
-      printInfo(`Saved to ${join39(repoRoot, ".oa", "settings.json")}`);
+      printInfo(`Saved to ${join40(repoRoot, ".oa", "settings.json")}`);
       printInfo("This override applies only when running in this workspace.");
     } catch (err) {
       printError(`Failed to save: ${err instanceof Error ? err.message : String(err)}`);
@@ -28012,7 +28581,7 @@ __export(eval_exports, {
 });
 import { tmpdir as tmpdir7 } from "node:os";
 import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync12 } from "node:fs";
-import { join as join40 } from "node:path";
+import { join as join41 } from "node:path";
 async function evalCommand(opts, config) {
   const suiteName = opts.suite ?? "basic";
   const suite = SUITES[suiteName];
@@ -28133,9 +28702,9 @@ async function evalCommand(opts, config) {
   process.exit(failed > 0 ? 1 : 0);
 }
 function createTempEvalRepo() {
-  const dir = join40(tmpdir7(), `open-agents-eval-${Date.now()}`);
+  const dir = join41(tmpdir7(), `open-agents-eval-${Date.now()}`);
   mkdirSync13(dir, { recursive: true });
-  writeFileSync12(join40(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
+  writeFileSync12(join41(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
   return dir;
 }
 var BASIC_SUITE, FULL_SUITE, SUITES;
@@ -28195,7 +28764,7 @@ init_updater();
 import { parseArgs as nodeParseArgs2 } from "node:util";
 import { createRequire as createRequire3 } from "node:module";
 import { fileURLToPath as fileURLToPath9 } from "node:url";
-import { dirname as dirname12, join as join41 } from "node:path";
+import { dirname as dirname12, join as join42 } from "node:path";
 
 // packages/cli/dist/cli.js
 import { createInterface } from "node:readline";
@@ -28302,7 +28871,7 @@ init_output();
 function getVersion2() {
   try {
     const require2 = createRequire3(import.meta.url);
-    const pkgPath = join41(dirname12(fileURLToPath9(import.meta.url)), "..", "package.json");
+    const pkgPath = join42(dirname12(fileURLToPath9(import.meta.url)), "..", "package.json");
     const pkg = require2(pkgPath);
     return pkg.version;
   } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.39.1",
+  "version": "0.41.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",