open-agents-ai 0.187.35 → 0.187.37

package/README.md

@@ -38,8 +38,9 @@ An autonomous multi-turn tool-calling agent that reads your code, makes changes,
 - [Architecture](#architecture)
 - [Context Engineering](#context-engineering)
 - [Model-Tier Awareness](#model-tier-awareness)
+- [Live Code Knowledge Graph](#live-code-knowledge-graph)
 - [Auto-Expanding Context Window](#auto-expanding-context-window)
-- [Tools (61)](#tools-61)
+- [Tools (67+)](#tools-67)
 - [Ralph Loop — Iteration-First Design](#ralph-loop--iteration-first-design)
 - [Task Control](#task-control)
 - [COHERE Cognitive Framework](#cohere-cognitive-framework)
@@ -54,6 +55,7 @@ An autonomous multi-turn tool-calling agent that reads your code, makes changes,
 - [x402 Payment Rails & Nexus P2P](#x402-payment-rails--nexus-p2p)
 - [Sponsored Inference — Share Your GPU With the World](#sponsored-inference--share-your-gpu-with-the-world)
 - [COHERE Distributed Mind](#cohere-distributed-mind)
+- [Self-Improvement & Learning](#self-improvement--learning)
 - [Dream Mode — Creative Idle Exploration](#dream-mode--creative-idle-exploration)
 - [Blessed Mode — Infinite Warm Loop](#blessed-mode--infinite-warm-loop)
 - [Docker Sandbox & Collective Intelligence](#docker-sandbox--collective-intelligence)
@@ -778,16 +780,22 @@ C = A(c_instr, c_know, c_tools, c_mem, c_state, c_query)
 | `c_instr` | P0 (highest) | Core system instructions — immutable, cannot be overridden |
 | `c_state` | P10 | Personality profile, session state |
 | `c_know` | P20 | Dynamic project context, retrieved knowledge |
+| `c_retrieval` | P20 | Task-specific retrieval (RRF-fused lexical + semantic + graph expansion) |
+| `c_graph` | P20 | Live code knowledge graph (PageRank-ranked symbols, community summaries) |
+| `c_plan` | P20 | Plan skeleton (completed/current/pending steps, re-injected every turn) |
 | `c_tools` | P30 (lowest) | Tool outputs — may contain untrusted content |
 
 Key design decisions grounded in research:
 
 - **Instruction hierarchy** — 4-tier priority system (P0/P10/P20/P30) prevents prompt injection from tool outputs overriding system rules. Implemented across all 3 prompt tiers (large/medium/small) with model-appropriate verbosity
+- **Live code knowledge graph** — SQLite-backed graph (files/symbols/edges) auto-updates via filesystem watcher and post-edit hooks. PageRank-ranked symbols injected into every prompt. Louvain community detection compresses 1M+ LOC repos into ~200 navigable clusters. Research: [Codebase-Memory](https://arxiv.org/abs/2603.27277), [FastCode](https://arxiv.org/abs/2603.01012), [Stack Graphs](https://arxiv.org/abs/2211.01224)
+- **Plan-skeleton re-injection** — every turn includes a compact `[done/current/pending]` plan derived from task state, preventing goal drift in multi-step tasks. Research: [ReCAP](https://arxiv.org/abs/2510.23822) (+32% on multi-step tasks)
+- **Retrieval-augmented context** — Reciprocal Rank Fusion merges lexical search, semantic search, and graph expansion into a single ranked result set. Token-budgeted snippet packing ensures relevant code reaches the model without overflow
 - **Proactive quality guidance** — instead of banning tools after repeated use, the agent receives contextual next-step suggestions appended to tool output, preserving tool availability while steering toward productive actions
-- **Tiered system prompts** — large (≥30B), medium (8-29B), and small (≤7B) models get appropriately sized instruction sets, balancing capability with context budget
+- **Tiered system prompts** — large (>=30B), medium (8-29B), and small (<=7B) models get appropriately sized instruction sets, balancing capability with context budget
 - **Context composition tracing** — every context assembly emits a structured event showing section labels and token estimates for eval observability
 
-Research provenance: grounded in "A Survey of Context Engineering for LLMs" (context assembly equation), "Modular Prompt Optimization" (section-local textual gradients), "Reasoning Up the Instruction Ladder" (priority hierarchy), "GEPA" (reflective prompt evolution), and "Prompt Flow Integrity" (least-privilege context passing).
+Research provenance: grounded in "A Survey of Context Engineering for LLMs" (context assembly equation), "Modular Prompt Optimization" (section-local textual gradients), "Reasoning Up the Instruction Ladder" (priority hierarchy), "GEPA" (reflective prompt evolution), "Prompt Flow Integrity" (least-privilege context passing), [RepoMaster](https://arxiv.org/abs/2505.21577) (8K token budget validation), and [RIG](https://arxiv.org/abs/2601.10112) (flat graph format).
 
 
 
@@ -800,22 +808,32 @@ Open Agents classifies models into three tiers and adapts its behavior according
 
 | Tier | Parameters | Base Tools | System Prompt | Compaction |
 |------|-----------|------------|---------------|------------|
-| **Large** (≥30B) | 70B, 122B | All 47 tools | Full (344 lines) | 40K threshold |
-| **Medium** (8-29B) | 9B, 27B | 15 core tools | Condensed (100 lines) | 24K threshold |
-| **Small** (≤7B) | 4B, 1.5B | 6 base tools + explore_tools | Minimal (15 lines) | 12K threshold |
+| **Large** (>=30B) | 70B, 122B | All 67 tools | Full | 75% of context window |
+| **Medium** (8-29B) | 9B, 27B | 15 core + task-relevant | Condensed | 70% of context window |
+| **Small** (<=7B) | 4B, 1.5B | 6 base + explore_tools | Minimal + scaffolding | 65% of context window |
 
-### Tool Nesting for Small Models
+### Small Model Optimization (Research-Backed)
+
+Small models (4B-7B) receive 10+ optimizations that larger models don't need, each backed by published research:
 
-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:
+| Optimization | Research Basis | Impact |
+|-------------|---------------|--------|
+| **Plan-skeleton re-injection** | [ReCAP](https://arxiv.org/abs/2510.23822) (NeurIPS 2025) | +32% multi-step task completion |
+| **Goal re-injection after compaction** | [Lost in the Middle](https://arxiv.org/abs/2307.03172) | Prevents #1 cause of drift |
+| **Decomposition guidance** | [ReCode](https://arxiv.org/abs/2510.23564) | +20.9% for 7B, zero training cost |
+| **Structured error recovery** | [Polaris](https://arxiv.org/abs/2603.23129) | Actionable [RECOVERY] guidance per error type |
+| **LATS pivot directive** | [LATS](https://arxiv.org/abs/2310.04406) (ICML 2024) | Forces approach change after consecutive failures |
+| **Self-consistency voting** | [SRLM](https://arxiv.org/abs/2603.15653) | +22% via K-alternative majority voting (opt-in) |
+| **Tier-adaptive compaction** | [Codebase-Memory](https://arxiv.org/abs/2603.27277) | Context budget scales per tier, not hardcoded |
+| **Tool deferral** | [EASYTOOL](https://arxiv.org/abs/2401.06201), [Gorilla](https://arxiv.org/abs/2305.15334) | 60-80% tool token reduction via search |
+| **Best-of-N execution** | [SWE-RM](https://arxiv.org/abs/2512.21919) | +7-10 pts via N independent attempts (opt-in) |
+| **Recursive sub-agents** | [RLM](https://arxiv.org/abs/2512.24601), [Yang/Srebro](https://arxiv.org/abs/2603.02112) | Depth-tracked delegation (max 3), 100x effective context |
 
-- `file_read`, `file_write`, `file_edit`, `shell`, `task_complete`, `explore_tools`
+**Eval-verified result:** A 4B model completes a hard multi-file refactoring task in 20 turns (down from 25 before these optimizations) and passes 92% of core eval tasks.
 
-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.
+### Tool Nesting for Small Models
 
-This approach is substantiated by:
-- **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
+Small models use an **explore_tools** meta-tool pattern inspired by hierarchical API retrieval research ([ToolLLM](https://arxiv.org/abs/2307.16789)). Instead of presenting all 67 tools (which overwhelms small context windows), only core tools are loaded initially. The agent calls `explore_tools()` to discover additional capabilities, then activates specific tools as needed. This reduces tool schema tokens by ~80% while preserving access to the full toolset.
 
 ### Dynamic Context Limits
 
@@ -832,6 +850,61 @@ All context-dependent values scale automatically with the actual context window
 
 
 
+## Live Code Knowledge Graph
+
+<div align="right"><a href="#top">back to top</a></div>
+
+Open Agents builds and maintains a **persistent, auto-updating knowledge graph** of the codebase that scales from small projects to repositories with 1M+ lines of code.
+
+### How It Works
+
+```
+Source files  ──>  Regex symbol extraction  ──>  SQLite graph DB (.oa/index/code-graph.db)
+     |                                                    |
+     |  fs.watch() + debounce ──>  File hash check  ──>  Incremental re-index (per file)
+     |                                                    |
+     └── post-edit hook (file_write/edit) ─────────────>  Instant re-index of modified files
+```
+
+1. **Symbol extraction** parses every source file for functions, classes, types, interfaces, exports, and constants
+2. **Import graph** traces dependency relationships (which file imports which)
+3. **PageRank scoring** ranks files by how many other files depend on them
+4. **Community detection** (Louvain-inspired) groups related files into logical modules with summaries
+5. **Auto-update** via filesystem watcher and post-tool-edit hooks keeps the graph fresh as code changes
+
+### What the Agent Sees
+
+Each turn, the agent receives a compact graph summary (500-1500 tokens depending on model tier) showing:
+- The most important files ranked by cross-reference count
+- Their exported symbols (functions, classes, types)
+- Import relationships (what depends on what)
+
+For 1M+ LOC codebases, the Louvain community compression reduces 50K+ symbols into ~200 navigable module summaries, each with a name and key exports.
+
+### Graph Tools
+
+| Tool | What It Does |
+|------|-------------|
+| `repo_map` | PageRank-sorted codebase skeleton with token budget control |
+| `import_graph` | Show dependencies, dependents, and 1-hop transitive connections for any file |
+| `semantic_map` | Agent-curated notes, hotspot tracking, and file relationships across sessions |
+| `codebase_map` | High-level structural overview (directories, language breakdown) |
+| `file_explore` | Chunked exploration with overview/outline/search/chunk strategies |
+
+### Storage
+
+The graph persists in `.oa/index/code-graph.db` (SQLite with WAL mode) across sessions. Incremental updates mean editing a single file costs <50ms regardless of codebase size.
+
+### Research Basis
+
+- [Codebase-Memory](https://arxiv.org/abs/2603.27277) (2026) — Tree-Sitter + Louvain communities, Linux kernel 2.1M nodes in 3 minutes, incremental via XXH3 hashing
+- [FastCode](https://arxiv.org/abs/2603.01012) (2026) — 3-layer graph schema (dependency/inheritance/call), cleanest decomposition
+- [Stack Graphs](https://arxiv.org/abs/2211.01224) (GitHub production) — File-level isolation for incremental updates at millions-of-repos scale
+- [RepoMaster](https://arxiv.org/abs/2505.21577) (2025) — 8K token budget validated, +62.96% task-pass rate
+- [Code-Craft/HCGS](https://arxiv.org/abs/2504.08975) (2025) — Hierarchical code graph summaries, 82% retrieval precision improvement
+
+
+
 ## Auto-Expanding Context Window
 
 <div align="right"><a href="#top">back to top</a></div>
@@ -2334,6 +2407,36 @@ Inbound queries are scanned for prompt injection attempts before processing:
 
 
 
+## Self-Improvement & Learning
+
+<div align="right"><a href="#top">back to top</a></div>
+
+Open Agents includes infrastructure for the agent to learn from its own execution, improving over time without manual intervention.
+
+### Trajectory Logging
+
+Every completed task is logged to `.oa/trajectories/trajectories.jsonl` with full metadata: task description, outcome (pass/fail), tool calls made, files modified, failed approaches, and timing. This data feeds the rejection fine-tuning pipeline. Research: [Golubev et al.](https://arxiv.org/abs/2508.03501) showed RFT on passing trajectories alone improved Qwen-72B from 11% to 25% on SWE-bench.
+
+### Rejection Fine-Tuning Pipeline
+
+`scripts/rejection-ft.mjs` processes trajectory logs into training data:
+1. Filters to passing trajectories
+2. Grades on 5-level staged criteria (from [RL Recipe](https://arxiv.org/abs/2603.21972)): syntactically valid tool calls, productive exploration, task completion, files modified, efficiency
+3. Exports Ollama-compatible JSONL for fine-tuning
+
+### Inference-Time Self-Improvement
+
+| Technique | When | Research |
+|-----------|------|----------|
+| **Self-consistency voting** | High-stakes tool calls (opt-in K=3) | [SRLM](https://arxiv.org/abs/2603.15653) +22% |
+| **Best-of-N execution** | Eval/high-stakes tasks (opt-in N=3-5) | [SWE-RM](https://arxiv.org/abs/2512.21919) +7-10 pts |
+| **LATS pivot** | After 2+ consecutive failures | [LATS](https://arxiv.org/abs/2310.04406) +10-20% |
+| **Structured error recovery** | On tool failure (small/medium only) | [Polaris](https://arxiv.org/abs/2603.23129) +9% |
+| **Failed approach tracking** | Every task | Prevents repeating mistakes after compaction |
+| **Skill extraction** | Post-task via `/skillify` | Converts corrections into reusable SKILL.md |
+
+
+
 ## Dream Mode — Creative Idle Exploration
 
 <div align="right"><a href="#top">back to top</a></div>
@@ -3100,7 +3203,7 @@ Research papers applied: [AgentOccam](https://arxiv.org/abs/2410.13825) (ICLR 20
 
 ### Multi-Agent Architecture Evaluation (v0.187.4)
 
-43 tasks across 8 categories testing the Hannover-aligned agent spawning system: typed agents (general/explore/plan/coordinator), parallel delegation, inter-agent messaging, worktree isolation, and multi-step orchestration pipelines.
+43 tasks across 8 categories testing the multi-agent spawning system: typed agents (general/explore/plan/coordinator), parallel delegation, inter-agent messaging, worktree isolation, and multi-step orchestration pipelines.
 
 ```bash
 node eval/run-agentic.mjs ma-explore-01     # Single agent task

package/dist/index.js

@@ -292356,101 +292356,47 @@ function createDefaultBanner(version4 = "0.120.0") {
   const width = process.stdout.columns ?? 80;
   const rows = 3;
   const yellow = 178;
-  const bgDark = 234;
-  const particles = [
-    " ",
-    // 0: empty
-    "\u2801",
-    "\u2802",
-    // 1-2: sparse braille
-    "\u2596",
-    "\u2597",
-    // 3-4: ▖▗ single quadrants
-    "\u2598",
-    "\u259D",
-    // 5-6: ▘▝ upper quadrants
-    "\u259E",
-    "\u259A",
-    // 7-8: ▞▚ diagonals
-    "\xB7",
-    "\u2591",
-    // 9-10: · ░ (dot + light shade)
-    "\u2599",
-    "\u259B",
-    // 11-12: ▙▛ three-quarter fills
-    "\u2592",
-    // 13: ▒ medium shade
-    "\u259C",
-    "\u259F",
-    // 14-15: ▜▟ three-quarter fills
-    "\u2593",
-    // 16: ▓ dark shade
-    "\u2588"
-    // 17: █ full block
-  ];
-  const hash = (r2, c4, frame) => {
-    const x = r2 * 7 + c4 * 13 + frame * 3 + 37;
-    return (x * x * 31 + x * 17 + 59) % 97 / 97;
-  };
-  const frameCount = 8;
-  const frames = [];
-  for (let f2 = 0; f2 < frameCount; f2++) {
-    const grid = [];
-    for (let r2 = 0; r2 < rows; r2++) {
-      const row = [];
-      for (let c4 = 0; c4 < width; c4++) {
-        const fadeStart = Math.floor(width * 0.45);
-        const solidStart = Math.floor(width * 0.85);
-        if (c4 >= fadeStart) {
-          const progress = Math.min(1, (c4 - fadeStart) / Math.max(1, solidStart - fadeStart));
-          const wave = Math.sin(c4 * 0.15 + f2 * 0.5 + r2 * 1.2) * 0.15;
-          const density = progress * progress + wave;
-          const noise2 = hash(r2, c4, f2);
-          if (noise2 < density) {
-            const charIdx = Math.min(particles.length - 1, Math.floor(Math.max(0, density) * particles.length));
-            row.push({ char: particles[charIdx], fg: yellow, bg: bgDark, bold: false });
-          } else {
-            row.push({ char: " ", fg: 0, bg: bgDark, bold: false });
-          }
-        } else {
-          row.push({ char: " ", fg: 0, bg: bgDark, bold: false });
-        }
-      }
-      grid.push(row);
-    }
-    const mnemonic = getNodeMnemonic();
-    const versionText = `  OA v${version4}`;
-    const mnemonicSuffix = ` \xB7 ${mnemonic}`;
-    for (let i2 = 0; i2 < versionText.length && i2 < width; i2++) {
-      grid[0][i2] = { char: versionText[i2], fg: yellow, bg: bgDark, bold: true };
-    }
-    const mnemonicStart = versionText.length;
-    for (let i2 = 0; i2 < mnemonicSuffix.length && mnemonicStart + i2 < Math.floor(width * 0.44); i2++) {
-      grid[0][mnemonicStart + i2] = { char: mnemonicSuffix[i2], fg: 240, bg: bgDark, bold: false };
-    }
-    const cwd4 = process.cwd();
-    const shortCwd = cwd4.length > 40 ? "..." + cwd4.slice(-37) : cwd4;
-    const infoText = `  ${shortCwd}`;
-    for (let i2 = 0; i2 < infoText.length && i2 < Math.floor(width * 0.44); i2++) {
-      grid[1][i2] = { char: infoText[i2], fg: 245, bg: bgDark, bold: false };
-    }
-    const btnLabels = ["help", "voice", "cohere", "model"];
-    const btnBg = 236;
-    let bCol = 2;
-    for (const lbl of btnLabels) {
-      const padded = ` ${lbl} `;
-      for (let ci = 0; ci < padded.length && bCol + ci < Math.floor(width * 0.44); ci++) {
-        grid[2][bCol + ci] = { char: padded[ci], fg: 245, bg: btnBg, bold: false };
-      }
-      bCol += padded.length + 1;
-    }
-    frames.push({ grid, durationMs: 200 });
-  }
+  const bgBlack = 0;
+  const grid = [];
+  const innerW = width - 2;
+  const topRow = [];
+  topRow.push({ char: "\u256D", fg: yellow, bg: bgBlack, bold: false });
+  for (let c4 = 0; c4 < innerW; c4++) {
+    topRow.push({ char: "\u2500", fg: yellow, bg: bgBlack, bold: false });
+  }
+  topRow.push({ char: "\u256E", fg: yellow, bg: bgBlack, bold: false });
+  grid.push(topRow);
+  const mnemonic = getNodeMnemonic();
+  const cwd4 = process.cwd();
+  const shortCwd = cwd4.length > 30 ? "..." + cwd4.slice(-27) : cwd4;
+  const centerText = `Open Agents v${version4} \xB7 ${mnemonic} \xB7 ${shortCwd}`;
+  const textLen = centerText.length;
+  const leftPad = Math.max(0, Math.floor((innerW - textLen) / 2));
+  const rightPad = Math.max(0, innerW - textLen - leftPad);
+  const midRow = [];
+  midRow.push({ char: "\u2502", fg: yellow, bg: bgBlack, bold: false });
+  for (let i2 = 0; i2 < leftPad; i2++)
+    midRow.push({ char: " ", fg: 0, bg: bgBlack, bold: false });
+  for (let i2 = 0; i2 < centerText.length && i2 < innerW; i2++) {
+    midRow.push({ char: centerText[i2], fg: yellow, bg: bgBlack, bold: true });
+  }
+  for (let i2 = 0; i2 < rightPad; i2++)
+    midRow.push({ char: " ", fg: 0, bg: bgBlack, bold: false });
+  midRow.push({ char: "\u2502", fg: yellow, bg: bgBlack, bold: false });
+  grid.push(midRow);
+  const botRow = [];
+  botRow.push({ char: "\u2570", fg: yellow, bg: bgBlack, bold: false });
+  for (let c4 = 0; c4 < innerW; c4++) {
+    botRow.push({ char: "\u2500", fg: yellow, bg: bgBlack, bold: false });
+  }
+  botRow.push({ char: "\u256F", fg: yellow, bg: bgBlack, bold: false });
+  grid.push(botRow);
   return {
     id: "default-header",
     name: "OA Default Header",
     type: "default",
-    frames,
+    frames: [{ grid, durationMs: 0 }],
+    // Single static frame, no animation
     alignment: ["left", "center", "left"],
     flowSpeed: [0, 0, 0],
     author: "system",
@@ -299401,7 +299347,7 @@ function setTerminalTitle(task, version4) {
   const title = task ? `${task.slice(0, 60)} \xB7 ${ver}` : ver;
   process.stdout.write(`\x1B]2;${title}\x07`);
 }
-var EXPERT_TOOL_BASELINES, CONTEXT_SWITCH_OVERHEAD, TURN_PLANNING_OVERHEAD, DEFAULT_TOOL_BASELINE, CODE_READ_CHARS_PER_SEC, PROSE_READ_CHARS_PER_SEC, MIN_CONTENT_FOR_READING, CODE_CONTENT_TOOLS, PROSE_CONTENT_TOOLS, HumanSpeedTracker, PANEL_BG, CONTENT_BG, TEXT_PRIMARY, TEXT_DIM, PANEL_BG_SEQ, CONTENT_BG_SEQ, RESET, _isWindows, StatusBar;
+var EXPERT_TOOL_BASELINES, CONTEXT_SWITCH_OVERHEAD, TURN_PLANNING_OVERHEAD, DEFAULT_TOOL_BASELINE, CODE_READ_CHARS_PER_SEC, PROSE_READ_CHARS_PER_SEC, MIN_CONTENT_FOR_READING, CODE_CONTENT_TOOLS, PROSE_CONTENT_TOOLS, HumanSpeedTracker, PANEL_BG, CONTENT_BG, TEXT_PRIMARY, TEXT_DIM, BOX_COLOR, PANEL_BG_SEQ, CONTENT_BG_SEQ, BOX_TL, BOX_TR, BOX_BL, BOX_BR, BOX_H, BOX_V, BOX_FG, RESET, _isWindows, StatusBar;
 var init_status_bar = __esm({
   "packages/cli/dist/tui/status-bar.js"() {
     "use strict";
@@ -299567,12 +299513,20 @@ var init_status_bar = __esm({
         return this.toolCalls > 0;
       }
     };
-    PANEL_BG = 234;
-    CONTENT_BG = 233;
+    PANEL_BG = 0;
+    CONTENT_BG = 0;
     TEXT_PRIMARY = 178;
     TEXT_DIM = 240;
+    BOX_COLOR = 178;
     PANEL_BG_SEQ = `\x1B[48;5;${PANEL_BG}m`;
     CONTENT_BG_SEQ = `\x1B[48;5;${CONTENT_BG}m`;
+    BOX_TL = "\u256D";
+    BOX_TR = "\u256E";
+    BOX_BL = "\u2570";
+    BOX_BR = "\u256F";
+    BOX_H = "\u2500";
+    BOX_V = "\u2502";
+    BOX_FG = `\x1B[38;5;${BOX_COLOR}m`;
     RESET = "\x1B[0m";
     _isWindows = process.platform === "win32";
     StatusBar = class _StatusBar {
@@ -301378,7 +301332,7 @@ ${CONTENT_BG_SEQ}`);
         this._updateSuggestions();
         const inputLines = this.computeInputLineCount(termWidth);
         const suggestionRows = this._suggestions.length > 0 ? this._suggestions.length : 1;
-        const newHeight = 1 + inputLines + suggestionRows;
+        const newHeight = 1 + 1 + inputLines + suggestionRows;
         if (newHeight !== this._currentFooterHeight) {
           this._currentFooterHeight = newHeight;
           return true;
@@ -301390,7 +301344,7 @@ ${CONTENT_BG_SEQ}`);
         this._updateSuggestions();
         const inputLines = this.computeInputLineCount(termWidth);
         const suggestionRows = this._suggestions.length > 0 ? this._suggestions.length : 1;
-        return 1 + inputLines + suggestionRows !== this._currentFooterHeight;
+        return 1 + 1 + inputLines + suggestionRows !== this._currentFooterHeight;
       }
       /** Compute absolute row positions for all footer elements.
        *  Layout (top to bottom): input → suggestions/braille → metrics.
@@ -301516,12 +301470,17 @@ ${CONTENT_BG_SEQ}`);
         }
         const inputWrap = this.wrapInput(w);
         let buf = "\x1B[?7l";
+        const boxInner = w - 2;
+        buf += `\x1B[${pos.inputStartRow};1H${PANEL_BG_SEQ}\x1B[2K${BOX_FG}${BOX_TL}${BOX_H.repeat(Math.max(0, boxInner))}${BOX_TR}${RESET}`;
         for (let i2 = 0; i2 < inputWrap.lines.length; i2++) {
-          const row = pos.inputStartRow + i2;
+          const row = pos.inputStartRow + 1 + i2;
           const prefix = i2 === 0 ? this.promptText : " ".repeat(this.promptWidth);
-          buf += `\x1B[${row};1H${PANEL_BG_SEQ}\x1B[2K${prefix}${inputWrap.lines[i2]}${RESET}`;
+          const lineContent = `${prefix}${inputWrap.lines[i2]}`;
+          const visLen = this.promptWidth + (inputWrap.lines[i2]?.length ?? 0);
+          const pad = Math.max(0, boxInner - visLen);
+          buf += `\x1B[${row};1H${PANEL_BG_SEQ}\x1B[2K${BOX_FG}${BOX_V}${RESET}${PANEL_BG_SEQ}${lineContent}${" ".repeat(pad)}${BOX_FG}${BOX_V}${RESET}`;
         }
-        const cursorTermRow = pos.inputStartRow + inputWrap.cursorRow;
+        const cursorTermRow = pos.inputStartRow + 1 + inputWrap.cursorRow;
         if (pos.tabBarRow > 0) {
           buf += `\x1B[${pos.tabBarRow};1H${PANEL_BG_SEQ}\x1B[2K${RESET}`;
         }
@@ -301539,7 +301498,7 @@ ${CONTENT_BG_SEQ}`);
             buf += `${RESET}`;
           }
         } else {
-          buf += `\x1B[${pos.bufferRow};1H${PANEL_BG_SEQ}\x1B[2K${this.buildBufferContent(w)}${RESET}`;
+          buf += `\x1B[${pos.bufferRow};1H${PANEL_BG_SEQ}\x1B[2K${BOX_FG}${BOX_BL}${BOX_H.repeat(Math.max(0, boxInner))}${BOX_BR}${RESET}`;
         }
         buf += `\x1B[${pos.metricsRow};1H${PANEL_BG_SEQ}\x1B[2K${this.buildMetricsLine()}${RESET}`;
         const focusChar = this._getFocusQuadrant();

package/package.json

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