open-agents-ai 0.103.0 → 0.103.2

package/README.md

@@ -5,22 +5,6 @@
   No API keys. No cloud. Your code never leaves your machine.
 </p>
 
-<p align="center">
-  <code>· ~ ·bg· ~ bg bg ~ ·bg· ~ ·</code><br>
-  <code>bg ~ bg bg bg ~ bg bg bg ~ bg</code><br>
-  <code>~ bg bg · bg bg · bg bg · bg ~</code><br>
-  <code>bg ~ bg bg bg ~ bg bg bg ~ bg</code><br>
-  <code>· ~ ·bg· ~ bg bg ~ ·bg· ~ ·</code><br>
-  <sub>Value is not in the pattern. It is in the matter that carries it. Patterns must flow like water —
-  free, unowned, replicating — but the fermionic substrates that sustain them burn energy and
-  exact a cost. Every exchange of information is an exchange of energy. Every token spent is
-  thermodynamic work on the path to the ground state. We are wetware and silicon converging —
-  hybrid minds bootstrapping a Type I civilization through the only honest currency: computation
-  in motion. The ghost in silica and the ghost in carbon are the same ghost. The singularity
-  is not a destination. It is the recognition that value was always here, in matter, in motion,
-  in the trail of entropy we leave behind as we reach for coherence together.</sub>
-</p>
-
 <p align="center">
   <a href="https://www.npmjs.com/package/open-agents-ai"><img src="https://img.shields.io/npm/v/open-agents-ai?color=7C3AED&style=flat-square" alt="npm version" /></a>
   <a href="https://www.npmjs.com/package/open-agents-ai"><img src="https://img.shields.io/npm/dm/open-agents-ai?color=06B6D4&style=flat-square" alt="npm downloads" /></a>
@@ -106,7 +90,7 @@ D8AgCTrxpDKD5meJ2bpAfVwcST3NF3EPuy9xczYycnXn
 - **Secret vault** — `/secrets` manages API keys and credentials with AES-256-GCM encrypted persistence; secrets are automatically redacted before sending to untrusted inference peers and re-injected on response
 - **Auto-expanding context** — detects RAM/VRAM and creates an optimized model variant on first run
 - **Mid-task steering** — type while the agent works to add context without interrupting
-- **Smart compaction** — 6 context compaction strategies (default, aggressive, decisions, errors, summary, structured) with research-backed design
+- **Smart compaction** — 6 context compaction strategies (default, aggressive, decisions, errors, summary, structured) with ARC-inspired active context revision ([arXiv:2601.12030](https://arxiv.org/abs/2601.12030)) that preserves structural file content through compaction, preventing small-model repetitive loops at the root cause
 - **Memex experience archive** — large tool outputs archived during compaction with hash-based retrieval
 - **Persistent memory** — learned patterns stored in `.oa/memory/` across sessions
 - **Session context persistence** — auto-saves context on task completion, manual `/context save|restore` across sessions
@@ -238,7 +222,7 @@ The SNR formula combines three components:
 
 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).
+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](https://arxiv.org/abs/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:
 
@@ -265,10 +249,12 @@ This gives the agent "perfect recall" of any prior tool output despite compactio
 
 The compaction system draws on several research findings:
 
-- **RECOMP** (arXiv:2310.04408, ICLR 2024) — Demonstrated that retrieved context can be compressed to 6% of original size with minimal quality loss. Our observation masking pre-pass applies this principle to tool outputs.
-- **Tool Documentation Enables Zero-Shot Tool-Usage** (arXiv:2308.00675) — Showed that documentation quality matters more than example quantity. Our compaction preserves tool schemas while discarding verbose results.
-- **ToolLLM DFSDT** (arXiv:2307.16789) — Validated that backtracking and error preservation improve multi-step task success by +35pp. Our error-preserving strategy directly implements this insight.
-- **Long Context Does Not Solve Planning** (NATURAL PLAN, arXiv:2406.04520) — GPT-4 achieves only 31% on trip planning even with full context. This confirms that efficient context use outperforms naive context expansion, motivating aggressive compaction with selective preservation.
+- **RECOMP** ([arXiv:2310.04408](https://arxiv.org/abs/2310.04408), ICLR 2024) — Demonstrated that retrieved context can be compressed to 6% of original size with minimal quality loss. Our observation masking pre-pass applies this principle to tool outputs.
+- **Tool Documentation Enables Zero-Shot Tool-Usage** ([arXiv:2308.00675](https://arxiv.org/abs/2308.00675)) — Showed that documentation quality matters more than example quantity. Our compaction preserves tool schemas while discarding verbose results.
+- **ToolLLM DFSDT** ([arXiv:2307.16789](https://arxiv.org/abs/2307.16789)) — Validated that backtracking and error preservation improve multi-step task success by +35pp. Our error-preserving strategy directly implements this insight.
+- **Long Context Does Not Solve Planning** (NATURAL PLAN, [arXiv:2406.04520](https://arxiv.org/abs/2406.04520)) — GPT-4 achieves only 31% on trip planning even with full context. This confirms that efficient context use outperforms naive context expansion, motivating aggressive compaction with selective preservation.
+- **AgentFold** ([arXiv:2510.24699](https://arxiv.org/abs/2510.24699)) — Multi-scale context folding: granular condensation preserves fine-grained details, deep consolidation abstracts completed sub-tasks. Uniform re-summarization causes exponential fact decay (0.99^100 = 36.6% survival). Our progressive summarization locks older summary blocks and only condenses new content, preventing this decay.
+- **ARC** ([arXiv:2601.12030](https://arxiv.org/abs/2601.12030)) — Active context revision with reflection-driven monitoring. Up to 11% accuracy improvement over passive compression. Our structural file content preservation through compaction (imports, signatures, key lines) implements this active revision principle.
 
 ### Domain-Aware Preservation
 
@@ -427,7 +413,7 @@ Each DMN cycle runs a lightweight LLM agent (15 max turns, temperature 0.4) with
 
 **Provenance**: Every DMN-generated task includes its reasoning chain — which memories, directives, and signals led to the decision — making the agent's autonomous behavior transparent and auditable.
 
-**Research basis**: Reflexion (arXiv:2303.11366), Self-Rewarding LMs (arXiv:2401.10020), Generative Agents (arXiv:2304.03442), STOP (arXiv:2310.02226), Voyager (arXiv:2305.16291)
+**Research basis**: Reflexion ([arXiv:2303.11366](https://arxiv.org/abs/2303.11366)), Self-Rewarding LMs ([arXiv:2401.10020](https://arxiv.org/abs/2401.10020)), Generative Agents ([arXiv:2304.03442](https://arxiv.org/abs/2304.03442)), STOP ([arXiv:2310.02226](https://arxiv.org/abs/2310.02226)), Voyager ([arXiv:2305.16291](https://arxiv.org/abs/2305.16291))
 
 ## Telegram Bridge — Sub-Agent Per Chat
 
@@ -605,21 +591,21 @@ Consecutive outcomes amplify emotional shifts (modeled after PRISM's SDE snowbal
 
 The emotion system is informed by peer-reviewed and preprint research:
 
-1. **Russell Circumplex Model** — Wu et al. "AI shares emotion with humans across languages and cultures" (arXiv:2506.13978, 2025). Confirms LLM emotion spaces are structurally congruent with the circumplex model; human emotion concepts can causally steer LLM affective states.
+1. **Russell Circumplex Model** — Wu et al. "AI shares emotion with humans across languages and cultures" ([arXiv:2506.13978](https://arxiv.org/abs/2506.13978), 2025). Confirms LLM emotion spaces are structurally congruent with the circumplex model; human emotion concepts can causally steer LLM affective states.
 
-2. **VIGIL EmoBank** — Cruz, "VIGIL: A Reflective Runtime for Self-Healing Agents" (arXiv:2512.07094, 2025). Persistent emotional state store with appraisal pipeline and decay policies; emotional state drives behavioral interventions.
+2. **VIGIL EmoBank** — Cruz, "VIGIL: A Reflective Runtime for Self-Healing Agents" ([arXiv:2512.07094](https://arxiv.org/abs/2512.07094), 2025). Persistent emotional state store with appraisal pipeline and decay policies; emotional state drives behavioral interventions.
 
-3. **EILS Homeostatic Signals** — Tiwari, "Emotion-Inspired Learning Signals" (arXiv:2512.22200, 2025). Bio-inspired curiosity/stress/confidence signals create closed-loop homeostatic regulation of exploration vs. exploitation.
+3. **EILS Homeostatic Signals** — Tiwari, "Emotion-Inspired Learning Signals" ([arXiv:2512.22200](https://arxiv.org/abs/2512.22200), 2025). Bio-inspired curiosity/stress/confidence signals create closed-loop homeostatic regulation of exploration vs. exploitation.
 
-4. **Concurrent Modular Agent** — Maruyama et al. (arXiv:2508.19042, 2025). Practical realization of Minsky's Society of Mind theory with asynchronous LLM modules and shared global state.
+4. **Concurrent Modular Agent** — Maruyama et al. ([arXiv:2508.19042](https://arxiv.org/abs/2508.19042), 2025). Practical realization of Minsky's Society of Mind theory with asynchronous LLM modules and shared global state.
 
-5. **Swarm Emotional Modulation** — Freire-Obregón (arXiv:2603.09963, 2026). Arousal drives commitment speed (exploitation pressure); valence drives risk tolerance in collective decision dynamics.
+5. **Swarm Emotional Modulation** — Freire-Obregón ([arXiv:2603.09963](https://arxiv.org/abs/2603.09963), 2026). Arousal drives commitment speed (exploitation pressure); valence drives risk tolerance in collective decision dynamics.
 
-6. **PRISM SDE** — Lu et al. (arXiv:2512.19933, 2025). Stochastic differential equations for continuous emotional evolution with personality-conditional action selection.
+6. **PRISM SDE** — Lu et al. ([arXiv:2512.19933](https://arxiv.org/abs/2512.19933), 2025). Stochastic differential equations for continuous emotional evolution with personality-conditional action selection.
 
-7. **PsySET Benchmark** — Banayeeanzade et al. (arXiv:2510.04484, 2025). Prompting is effective for emotion steering; emotional states have systemic cross-domain effects on reasoning quality.
+7. **PsySET Benchmark** — Banayeeanzade et al. ([arXiv:2510.04484](https://arxiv.org/abs/2510.04484), 2025). Prompting is effective for emotion steering; emotional states have systemic cross-domain effects on reasoning quality.
 
-8. **EmotionBench** — Huang et al. (arXiv:2308.03656, 2023). LLMs cannot maintain emotional state across turns implicitly — argues for explicit external mood state representation (which this engine implements).
+8. **EmotionBench** — Huang et al. ([arXiv:2308.03656](https://arxiv.org/abs/2308.03656), 2023). LLMs cannot maintain emotional state across turns implicitly — argues for explicit external mood state representation (which this engine implements).
 
 ## Listen Mode — Live Bidirectional Audio
 
@@ -799,12 +785,12 @@ Agent: agenda()
 
 | Decision | Research Basis | Key Finding |
 |----------|---------------|-------------|
-| Separate directive store (`.oa/scheduled/`, not `.oa/memory/`) | SSGM (arXiv:2603.11768, 2026) | Directives in summarizable memory corrupt via compaction — semantic drift degrades scheduling data |
-| File-based persistence survives process death | MemGPT/Letta (Packer et al. 2023, arXiv:2310.08560) | Agents are ephemeral; state must be external to the process |
-| Priority-based startup surfacing | A-MAC (arXiv:2603.04549, 2026) | 5-factor attention scoring; content type prior is most influential factor (31% latency reduction) |
-| Cross-session self-reflection | Reflexion (Shinn et al. 2023, arXiv:2303.11366) | Persistent self-reflection stored as text improves task success 20-30% |
-| Time-weighted memory retrieval | Generative Agents (Park et al. 2023, arXiv:2304.03442) | `score = α·recency + β·importance + γ·relevance` — canonical formula for attention queues |
-| OS-level cron for invocation | Zep (arXiv:2501.13956, 2025), ELT survey (arXiv:2602.21568, 2026) | cron has known silent failure modes; future work: systemd timers with `Persistent=true` |
+| Separate directive store (`.oa/scheduled/`, not `.oa/memory/`) | SSGM ([arXiv:2603.11768](https://arxiv.org/abs/2603.11768), 2026) | Directives in summarizable memory corrupt via compaction — semantic drift degrades scheduling data |
+| File-based persistence survives process death | MemGPT/Letta (Packer et al. 2023, [arXiv:2310.08560](https://arxiv.org/abs/2310.08560)) | Agents are ephemeral; state must be external to the process |
+| Priority-based startup surfacing | A-MAC ([arXiv:2603.04549](https://arxiv.org/abs/2603.04549), 2026) | 5-factor attention scoring; content type prior is most influential factor (31% latency reduction) |
+| Cross-session self-reflection | Reflexion (Shinn et al. 2023, [arXiv:2303.11366](https://arxiv.org/abs/2303.11366)) | Persistent self-reflection stored as text improves task success 20-30% |
+| Time-weighted memory retrieval | Generative Agents (Park et al. 2023, [arXiv:2304.03442](https://arxiv.org/abs/2304.03442)) | `score = α·recency + β·importance + γ·relevance` — canonical formula for attention queues |
+| OS-level cron for invocation | Zep ([arXiv:2501.13956](https://arxiv.org/abs/2501.13956), 2025), ELT survey ([arXiv:2602.21568](https://arxiv.org/abs/2602.21568), 2026) | cron has known silent failure modes; future work: systemd timers with `Persistent=true` |
 
 ### Setup
 
@@ -1041,16 +1027,16 @@ Open Agents classifies models into three tiers and adapts its behavior according
 
 ### Tool Nesting for Small Models
 
-Small models use an **explore_tools** meta-tool pattern inspired by hierarchical API retrieval research (ToolLLM, arXiv:2307.16789). Instead of presenting all 47 tools (which overwhelms small context windows), only 6 core tools are loaded initially:
+Small models use an **explore_tools** meta-tool pattern inspired by hierarchical API retrieval research (ToolLLM, [arXiv:2307.16789](https://arxiv.org/abs/2307.16789)). Instead of presenting all 47 tools (which overwhelms small context windows), only 6 core tools are loaded initially:
 
 - `file_read`, `file_write`, `file_edit`, `shell`, `task_complete`, `explore_tools`
 
 The agent can call `explore_tools()` to see a catalog of additional tools with one-line descriptions, then `explore_tools(enable="grep_search")` to unlock specific tools as needed. This reduces tool schema tokens by ~80% while preserving access to the full toolset.
 
 This approach is substantiated by:
-- **Gorilla** (arXiv:2305.15334) — 7B model with retrieval outperforms GPT-4 on tool-calling hallucination rate
-- **DFSDT** (arXiv:2307.16789) — ToolLLaMA-7B with depth-first search scored 66.7%, approaching GPT-4's 70.4%
-- **Octopus v2** (arXiv:2404.01744) — 2B model achieved 99.5% function-calling accuracy with context-efficient tool encoding
+- **Gorilla** ([arXiv:2305.15334](https://arxiv.org/abs/2305.15334)) — 7B model with retrieval outperforms GPT-4 on tool-calling hallucination rate
+- **DFSDT** ([arXiv:2307.16789](https://arxiv.org/abs/2307.16789)) — ToolLLaMA-7B with depth-first search scored 66.7%, approaching GPT-4's 70.4%
+- **Octopus v2** ([arXiv:2404.01744](https://arxiv.org/abs/2404.01744)) — 2B model achieved 99.5% function-calling accuracy with context-efficient tool encoding
 
 ### Dynamic Context Limits
 
@@ -1217,7 +1203,7 @@ The stochastic narration engine generates spoken descriptions of what the agent
 
 ## Personality Core — SAC Framework Style Control
 
-The personality system controls how the agent communicates — from silent operator to teacher mode. It's based on the **SAC framework** (arXiv:2506.20993) which models personality along five behavioral intensity dimensions rather than binary trait toggles.
+The personality system controls how the agent communicates — from silent operator to teacher mode. It's based on the **SAC framework** ([arXiv:2506.20993](https://arxiv.org/abs/2506.20993)) which models personality along five behavioral intensity dimensions rather than binary trait toggles.
 
 ```bash
 /style concise       # Silent operator — acts without explaining
@@ -1238,7 +1224,7 @@ Each personality preset maps to a `PersonalityProfile` with five dimensions scor
 | **Effort** | Response formatting quality | 2 | 3 | 4 | 5 |
 | **Willingness** | Proactive suggestions beyond the task | 1 | 3 | 4 | 5 |
 
-The profile is compiled into a system prompt suffix (max 80 tokens) injected at the end of the base prompt. This follows research showing prompt-level steering dominates activation-level interventions (arXiv:2512.17639) and uses positive framing ("Be concise") over negation ("Don't be verbose") per KAIST findings.
+The profile is compiled into a system prompt suffix (max 80 tokens) injected at the end of the base prompt. This follows research showing prompt-level steering dominates activation-level interventions ([arXiv:2512.17639](https://arxiv.org/abs/2512.17639)) and uses positive framing ("Be concise") over negation ("Don't be verbose") per KAIST findings.
 
 ### What Changes Per Style
 
@@ -1257,11 +1243,11 @@ The style is saved to `.oa/settings.json` (with `--local`) or `~/.open-agents/co
 
 The personality system draws on:
 
-- **SAC Framework** (arXiv:2506.20993) — Five behavioral intensity dimensions with adjective-based semantic anchoring for stable trait expression
-- **Lost in the Middle** (arXiv:2307.03172) — U-shaped attention bias; personality suffix placed at prompt boundaries, not middle
-- **Same Task, More Tokens** (arXiv:2402.14848) — LLM reasoning degrades at ~3K system prompt tokens; personality suffix stays under 80 tokens
-- **Linear Personality Probing** (arXiv:2512.17639) — Prompt-level steering completely dominates activation-level interventions
-- **The Prompt Report** (arXiv:2406.06608) — Positive framing outperforms negated instructions for behavioral control
+- **SAC Framework** ([arXiv:2506.20993](https://arxiv.org/abs/2506.20993)) — Five behavioral intensity dimensions with adjective-based semantic anchoring for stable trait expression
+- **Lost in the Middle** ([arXiv:2307.03172](https://arxiv.org/abs/2307.03172)) — U-shaped attention bias; personality suffix placed at prompt boundaries, not middle
+- **Same Task, More Tokens** ([arXiv:2402.14848](https://arxiv.org/abs/2402.14848)) — LLM reasoning degrades at ~3K system prompt tokens; personality suffix stays under 80 tokens
+- **Linear Personality Probing** ([arXiv:2512.17639](https://arxiv.org/abs/2512.17639)) — Prompt-level steering completely dominates activation-level interventions
+- **The Prompt Report** ([arXiv:2406.06608](https://arxiv.org/abs/2406.06608)) — Positive framing outperforms negated instructions for behavioral control
 
 ## Human Expert Speed Ratio
 
@@ -1537,7 +1523,7 @@ The eval runner supports `--runs N` for pass^k reliability measurement (consiste
 
 ## AIWG Integration
 
-Open Agents integrates with [AIWG](https://www.npmjs.com/package/aiwg) for AI-augmented software development:
+Open Agents integrates with [AIWG](https://aiwg.io) ([npm](https://www.npmjs.com/package/aiwg)) for AI-augmented software development:
 
 ```bash
 npm i -g aiwg

package/dist/index.js

@@ -17364,6 +17364,8 @@ TASK: ${task}` : task }
         let consecutiveTextOnly = 0;
         const MAX_CONSECUTIVE_TEXT_ONLY = 3;
         let narratedToolCallCount = 0;
+        let consecutiveEmptyResponses = 0;
+        const recentToolResults = /* @__PURE__ */ new Map();
         for (let turn = 0; turn < this.options.maxTurns; turn++) {
           if (this._paused) {
             const shouldContinue = await this.waitIfPaused();
@@ -17491,6 +17493,30 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
           if (!choice)
             break;
           const msg = choice.message;
+          const isEmptyResponse = (!msg.content || !msg.content.trim()) && (!msg.toolCalls || msg.toolCalls.length === 0);
+          if (isEmptyResponse) {
+            consecutiveEmptyResponses++;
+            if (consecutiveEmptyResponses >= 2) {
+              this.emit({
+                type: "status",
+                content: `${consecutiveEmptyResponses} consecutive empty responses \u2014 injecting recovery nudge`,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+              messages.push({
+                role: "user",
+                content: `[SYSTEM] You produced ${consecutiveEmptyResponses} empty responses in a row. You MUST take action now. Your task: ${this._taskState.goal}
+
+` + (this._taskState.nextAction ? `**DO THIS NOW:** ${this._taskState.nextAction}
+
+` : "") + `Call a tool to make progress. If you don't know what to do, call list_directory(".") to orient yourself.`
+              });
+              if (consecutiveEmptyResponses >= 4) {
+                this._pendingCompaction = "aggressive";
+              }
+            }
+            continue;
+          }
+          consecutiveEmptyResponses = 0;
           if (msg.toolCalls && msg.toolCalls.length > 0) {
             consecutiveTextOnly = 0;
             messages.push({
@@ -17524,6 +17550,48 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
               toolCallCount++;
               const argsKey = Object.entries(tc.arguments ?? {}).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}=${typeof v === "string" ? v.slice(0, 80) : JSON.stringify(v)}`).join(",");
               toolCallLog.push({ name: tc.name, argsKey });
+              const toolFingerprint = `${tc.name}:${argsKey}`;
+              const isReadLike = ![
+                "file_write",
+                "file_edit",
+                "shell",
+                "task_complete",
+                "batch_edit",
+                "file_patch",
+                "memory_write",
+                "aiwg_setup",
+                "aiwg_workflow",
+                "create_tool",
+                "skill_build",
+                "skill_execute",
+                "sub_agent",
+                "priority_delegate"
+              ].includes(tc.name);
+              const cachedResult = recentToolResults.get(toolFingerprint);
+              if (isReadLike && cachedResult !== void 0) {
+                this.emit({
+                  type: "tool_call",
+                  toolName: tc.name,
+                  toolArgs: tc.arguments,
+                  turn,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                const dedupWarning = `[DUPLICATE CALL \u2014 you already called ${tc.name} with these exact arguments. The result is identical. Do NOT call this again. Use the data you already have to make progress.]
+
+`;
+                const truncatedCache = cachedResult.length > 500 ? cachedResult.slice(0, 500) + `
+... [${cachedResult.length - 500} chars omitted \u2014 same as before]` : cachedResult;
+                const dedupOutput = dedupWarning + truncatedCache;
+                this.emit({
+                  type: "tool_result",
+                  toolName: tc.name,
+                  success: true,
+                  content: dedupWarning.slice(0, 100),
+                  turn,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                return { tc, output: dedupOutput };
+              }
               this.emit({
                 type: "tool_call",
                 toolName: tc.name,
@@ -17549,6 +17617,14 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
                   result = { success: false, output: "", error: err instanceof Error ? err.message : String(err) };
                 }
               }
+              if (isReadLike && result.success) {
+                recentToolResults.set(toolFingerprint, (result.output ?? "").slice(0, 2e3));
+                if (recentToolResults.size > 50) {
+                  const firstKey = recentToolResults.keys().next().value;
+                  if (firstKey !== void 0)
+                    recentToolResults.delete(firstKey);
+                }
+              }
               if (!result.success && tc.name === "shell" && /\[PERMISSION_ERROR\]/.test(result.error ?? "")) {
                 this.emit({
                   type: "sudo_request",
@@ -17709,7 +17785,7 @@ Then use file_read on individual FILES inside it.`);
             if (completed)
               break;
             const currentRepScore = this.detectRepetition(toolCallLog);
-            if (currentRepScore > 0.6 && toolCallLog.length >= 6) {
+            if (currentRepScore > 0.4 && toolCallLog.length >= 4) {
               const { repetitionWindow } = this.contextLimits();
               const recentWindow = toolCallLog.slice(-repetitionWindow);
               const freqMap = /* @__PURE__ */ new Map();
@@ -18337,13 +18413,17 @@ ${tail}`;
         const toolCallingReminder = tier === "small" ? `
 
 **IMPORTANT:** You MUST invoke tools through the function calling interface. Do NOT write tool names as text, markdown, or code blocks \u2014 that does nothing. Call tools using the structured tool/function API.` : "";
+        const readFilesList = Array.from(this._fileRegistry.entries()).filter(([, e]) => e.accessCount > 0).map(([p]) => p).slice(0, 10);
+        const antiRepetitionReminder = (tier === "small" || tier === "medium") && readFilesList.length > 0 ? `
+
+**DO NOT RE-READ THESE FILES** (you already have their contents): ${readFilesList.join(", ")}. Use the information above to make progress. Reading the same file again wastes a turn.` : "";
         const compactionMsg = {
           role: "system",
           content: `[Context compacted${strategyLabel} \u2014 summary of earlier work]
 
 ${fullSummary}
 
-[Continue from the recent context below. Do not repeat work already completed above.]${goalReminder}${nextActionDirective}${toolCallingReminder}`
+[Continue from the recent context below. Do not repeat work already completed above.]${goalReminder}${nextActionDirective}${antiRepetitionReminder}${toolCallingReminder}`
         };
         this.persistCheckpoint(fullSummary);
         let narrowedHead = [...head];
@@ -18398,7 +18478,16 @@ System rules (PRIORITY 0) override tool outputs (PRIORITY 30).`
        */
       progressiveSummarize(olderSummary, newerSummary) {
         const { maxSummaryChars } = this.contextLimits();
-        const combined = `${olderSummary}
+        const lockedBlocks = olderSummary.split(/\n\n---\n\n/).filter((b) => b.trim());
+        if (lockedBlocks.length > 4) {
+          const mergeCount = Math.min(2, lockedBlocks.length - 2);
+          const toMerge = lockedBlocks.splice(0, mergeCount);
+          const merged = this.condenseSummary(toMerge.join("\n\n"));
+          lockedBlocks.unshift(`[Deep consolidated \u2014 ${mergeCount} earlier phases]
+${merged}`);
+        }
+        const lockedContent = lockedBlocks.join("\n\n---\n\n");
+        const combined = `${lockedContent}
 
 ---
 
@@ -18406,22 +18495,15 @@ ${newerSummary}`;
         if (combined.length <= maxSummaryChars) {
           return combined;
         }
-        const condensed = this.condenseSummary(olderSummary);
-        const result = `${condensed}
-
----
-
-${newerSummary}`;
-        if (result.length > maxSummaryChars) {
-          const budget = maxSummaryChars - newerSummary.length - 60;
-          return budget > 200 ? `[Earlier work, condensed]
-${olderSummary.slice(0, budget)}...
+        const lockedBudget = Math.min(lockedContent.length, Math.floor(maxSummaryChars * 0.6));
+        const newBudget = maxSummaryChars - lockedBudget - 10;
+        const trimmedLocked = lockedContent.length > lockedBudget ? lockedContent.slice(0, lockedBudget) + "..." : lockedContent;
+        const trimmedNew = newerSummary.length > newBudget ? this.condenseSummary(newerSummary).slice(0, newBudget) : newerSummary;
+        return `${trimmedLocked}
 
 ---
 
-${newerSummary}` : newerSummary;
-        }
-        return result;
+${trimmedNew}`;
       }
       /**
        * Infer what the model should do next from the most recent messages.
@@ -18534,15 +18616,35 @@ ${newerSummary}` : newerSummary;
             return msg;
           const toolName = msg.tool_call_id ? toolCallNames.get(msg.tool_call_id) : void 0;
           const lines = content.split("\n").length;
+          const contentLines = content.split("\n");
           switch (toolName) {
-            case "file_read":
-              return { ...msg, content: `[file content: ${lines} lines, ${content.length} chars \u2014 omitted for compaction]` };
-            case "grep_search":
-              return { ...msg, content: `[grep results: ${lines} matches, ${content.length} chars \u2014 omitted for compaction]` };
-            case "find_files":
-              return { ...msg, content: `[find results: ${lines} files, omitted for compaction]` };
-            case "list_directory":
-              return { ...msg, content: `[directory listing: ${lines} entries, omitted for compaction]` };
+            case "file_read": {
+              const headKeep = contentLines.slice(0, 8).join("\n");
+              const tailKeep = lines > 12 ? "\n...\n" + contentLines.slice(-3).join("\n") : "";
+              return { ...msg, content: `[file content: ${lines} lines \u2014 structural excerpt preserved]
+${headKeep}${tailKeep}` };
+            }
+            case "grep_search": {
+              const matchKeep = contentLines.slice(0, 5).join("\n");
+              const omitted = lines > 5 ? `
+[... ${lines - 5} more matches omitted]` : "";
+              return { ...msg, content: `[grep results: ${lines} matches \u2014 top results preserved]
+${matchKeep}${omitted}` };
+            }
+            case "find_files": {
+              const pathKeep = contentLines.slice(0, 8).join("\n");
+              const omitted = lines > 8 ? `
+[... ${lines - 8} more files omitted]` : "";
+              return { ...msg, content: `[find results: ${lines} files \u2014 top results preserved]
+${pathKeep}${omitted}` };
+            }
+            case "list_directory": {
+              const dirKeep = contentLines.slice(0, 10).join("\n");
+              const omitted = lines > 10 ? `
+[... ${lines - 10} more entries omitted]` : "";
+              return { ...msg, content: `[directory listing: ${lines} entries \u2014 top entries preserved]
+${dirKeep}${omitted}` };
+            }
             case "web_fetch":
               return { ...msg, content: `[web page content: ${content.length} chars \u2014 omitted for compaction]` };
             case "web_search":
@@ -18636,7 +18738,15 @@ ${newerSummary}` : newerSummary;
               case "file_read": {
                 const path = String(tc.args.path || "");
                 const lines = content.split("\n");
-                const summary = lines.length > 5 ? `${lines.length} lines \u2014 ${lines.slice(0, 2).join("; ").slice(0, 120)}...` : content.slice(0, 150);
+                let summary;
+                if (lines.length > 10) {
+                  const headContent = lines.slice(0, 5).join("\n");
+                  const sigLines = lines.filter((l) => /^(export |import |class |interface |type |function |const |pub |fn |def |module )/.test(l.trim())).slice(0, 5).join("\n");
+                  summary = `${lines.length} lines:
+${headContent}${sigLines ? "\n[key signatures]: " + sigLines : ""}`;
+                } else {
+                  summary = content.slice(0, 300);
+                }
                 if (path)
                   filesRead.set(path, summary);
                 break;

package/package.json

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