open-agents-ai 0.32.1 → 0.32.2

package/README.md

@@ -29,7 +29,7 @@ An autonomous multi-turn tool-calling agent that reads your code, makes changes,
 
 ## Features
 
-- **35 autonomous tools** — file I/O, shell, grep, web search/fetch, memory, sub-agents, background tasks, image/OCR, git, diagnostics, vision, desktop automation, structured files, code sandbox
+- **35+ autonomous tools** — file I/O, shell, grep, web search/fetch/crawl, memory, sub-agents, background tasks, image/OCR, git, diagnostics, vision, desktop automation, structured files, code sandbox
 - **Moondream vision** — see and interact with the desktop via Moondream VLM (caption, query, detect, point-and-click)
 - **Desktop automation** — vision-guided clicking: describe a UI element in natural language, the agent finds and clicks it
 - **Auto-install desktop deps** — screenshot, mouse, OCR, and image tools auto-install missing system packages (scrot, xdotool, tesseract, imagemagick) on first use
@@ -46,13 +46,18 @@ An autonomous multi-turn tool-calling agent that reads your code, makes changes,
 - **Code sandbox** — isolated code execution in subprocess or Docker (JS, Python, Bash, TypeScript)
 - **Structured file reading** — parse CSV, TSV, JSON, Markdown tables with binary format detection
 - **Multi-provider web search** — DuckDuckGo (free), Tavily (structured), Jina AI (markdown) with auto-detection
+- **Web crawling** — multi-page web scraping with Crawlee/Playwright for deep documentation extraction
 - **Task templates** — specialized system prompts and tool recommendations for code, document, analysis, plan tasks
 - **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** — long conversations compressed preserving files, commands, errors, decisions
+- **Smart compaction** — 6 context compaction strategies (default, aggressive, decisions, errors, summary, structured) with research-backed design
+- **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
 - **Self-learning** — auto-fetches docs from the web when encountering unfamiliar APIs
-- **Seamless `/update`** — in-place update and reload without losing context
+- **Seamless `/update`** — in-place update and reload with automatic context save/restore
+- **Task control** — `/pause` (gentle halt at turn boundary), `/stop` (immediate kill), `/resume` to continue
+- **Model-tier awareness** — dynamic tool sets, prompt complexity, and context limits scale with model size (small/medium/large)
 
 ## How It Works
 
@@ -92,6 +97,110 @@ The loop tracks iteration history, generates completion reports saved to `.aiwg/
 /ralph-abort      # Cancel running loop
 ```
 
+## Context Compaction — Research-Backed Memory Management
+
+Long conversations consume context window tokens. Open Agents uses progressive context compaction to compress older messages while preserving critical information — decisions, errors, file states, and task progress.
+
+### How It Works
+
+Compaction triggers automatically when estimated token usage reaches 75% 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
+3. **Keeps** recent messages verbatim (scaled by model tier and context size)
+4. **Archives** large tool outputs to the Memex experience archive (retrievable by hash ID via `memex_retrieve`)
+
+### Compaction Strategies
+
+Six strategies are available via `/compact <strategy>`:
+
+| Strategy | What It Preserves | Best For |
+|----------|-------------------|----------|
+| `default` | Progressive summarization — decisions, errors, file changes, task state | General use |
+| `aggressive` | Only key decisions and errors, maximum compression | Very long sessions |
+| `decisions` | Action→outcome pairs only, discards exploration | Decision-heavy workflows |
+| `errors` | Full error context preserved, successes compressed | Debugging sessions |
+| `summary` | High-level paragraph summary, minimal detail | Quick context reset |
+| `structured` | LLM-generated structured summary via a separate inference call | Highest quality summaries |
+
+### Automatic Compaction
+
+Compaction thresholds scale dynamically with model 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 |
+
+### Memex Experience Archive
+
+During compaction, large tool outputs (file reads, grep results, command output) are archived with a short hash ID. The agent can recover any archived result using `memex_retrieve`:
+
+```
+Agent: memex_retrieve(id="a3f2c1")
+       → [Full original content of the archived tool result]
+```
+
+This gives the agent "perfect recall" of any prior tool output despite compaction.
+
+### Design Rationale
+
+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.
+
+### Domain-Aware Preservation
+
+Compaction summaries include:
+- **Task state** — current phase, goals, progress, blockers
+- **File registry** — per-file metadata (last action, line count, purpose) for files touched during the session
+- **Memex index** — hash IDs and one-line summaries of archived tool outputs
+
+This ensures the agent can resume coherently after compaction without re-reading files or re-running commands.
+
+## Task Control
+
+### Pause, Stop, Resume, Destroy
+
+| Command | Behavior |
+|---------|----------|
+| `/pause` | **Gentle halt** — lets the current inference turn finish, then stops before the next turn. No new tool calls or inference will begin until `/resume`. |
+| `/stop` | **Immediate kill** — aborts the current inference mid-stream, saves task state for later resumption. |
+| `/resume` | **Continue** — resumes a paused or stopped task from where it left off. Also resumes tasks saved by `/stop` or interrupted by `/update`. |
+| `/destroy` | **Nuclear option** — aborts any active task, deletes the `.oa/` directory, clears the console, and exits to shell. |
+
+### Session Context Persistence
+
+Context is automatically saved on every task completion and preserved across `/update` restarts.
+
+```bash
+/context save      # Force-save current session context
+/context restore   # Load previous session context into next task
+/context show      # Show saved context status (entries, last saved)
+```
+
+The system maintains a rolling window of the last 20 session entries in `.oa/context/session-context.json`. When you run `/context restore`, the last 10 entries are formatted into a restore prompt and injected into your next task, giving the agent continuity across sessions.
+
+During `/update`, context is automatically saved before the process restarts and restored when the new version resumes your task.
+
+### Auto-Restore on Startup
+
+When you launch `oa` in a workspace that has saved session context from a previous run, you'll be prompted to restore it:
+
+```
+ℹ Previous session found (5 entries, last active 2h ago)
+ℹ Last task: fix the auth bug in src/middleware.ts
+ℹ Restore previous context? (y/n)
+❯ y
+ℹ Context restored from 5 session(s). Will be injected into your next task.
+```
+
+Type `y` to restore — the previous session context will be prepended to your next task, giving the agent full continuity. Type `n` (or anything else) to start fresh. The prompt only appears on fresh starts, not on `/update` resumes (which auto-restore context).
+
 ## Dream Mode — Creative Idle Exploration
 
 When you're not actively tasking the agent, Dream Mode lets it creatively explore your codebase and generate improvement proposals autonomously. The system models real human sleep architecture with four stages per cycle:
@@ -268,24 +377,48 @@ The TUI features an animated multilingual phrase carousel, live metrics bar with
 
 | Command | Description |
 |---------|-------------|
-| `/help` | Show all available commands |
-| `/model <name>` | Switch to a different Ollama model |
+| **Model & Endpoint** | |
+| `/model <name>` | Switch to a different model |
+| `/models` | List all available models |
 | `/endpoint <url>` | Connect to a remote vLLM or OpenAI-compatible API |
+| `/endpoint <url> --auth <key>` | Set endpoint with Bearer auth |
+| **Task Control** | |
+| `/pause` | Pause after current turn finishes (gentle halt) |
+| `/stop` | Kill current inference immediately, save state |
+| `/resume` | Resume a paused or stopped task |
+| `/destroy` | Remove `.oa/` folder, kill all tasks, clear console, exit |
+| **Context & Memory** | |
+| `/context save` | Force-save session context to `.oa/context/` |
+| `/context restore` | Restore context from previous sessions into next task |
+| `/context show` | Show saved session context status |
+| `/compact` | Force context compaction now (default strategy) |
+| `/compact <strategy>` | Compact with strategy: `aggressive`, `decisions`, `errors`, `summary`, `structured` |
+| **Audio & Vision** | |
 | `/voice [model]` | Toggle TTS voice (GLaDOS, Overwatch) |
 | `/listen [mode]` | Toggle live microphone transcription |
 | `/dream [mode]` | Start dream mode (default, deep, lucid) |
-| `/stream` | Toggle streaming token display |
+| **Display & Behavior** | |
+| `/stream` | Toggle streaming token display with pastel syntax highlighting |
 | `/bruteforce` | Toggle brute-force mode (auto re-engage on turn limit) |
-| `/tools` | List available tools |
-| `/skills` | List/search available skills |
-| `/update` | Check for and install updates (seamless reload) |
+| `/verbose` | Toggle verbose mode |
+| **Tools & Skills** | |
+| `/tools` | List agent-created custom tools |
+| `/skills [keyword]` | List/search available AIWG skills |
+| `/<skill-name> [args]` | Invoke an AIWG skill directly |
+| **Metrics & Updates** | |
 | `/cost` | Show token cost breakdown for the current session |
 | `/evaluate` | Score the last completed task with LLM-as-judge |
-| `/stats` | Show session metrics (turns, tools, tokens, files) |
+| `/stats` | Show session dashboard (turns, tools, tokens, files, task history) |
 | `/task-type <type>` | Set task type for specialized prompts (code, document, analysis, plan) |
+| `/update` | Check for and install updates (seamless context-preserving reload) |
+| `/update auto\|manual` | Set update mode (auto after task completion, or manual only) |
+| **General** | |
 | `/config` | Show current configuration |
 | `/clear` | Clear the screen |
-| `/exit` | Quit |
+| `/help` | Show all available commands |
+| `/quit` | Exit |
+
+All settings commands accept `--local` to save to project `.oa/settings.json` instead of global config.
 
 ### Mid-Task Steering
 
@@ -300,30 +433,32 @@ While the agent is working (shown by the `+` prompt), type to add context:
   ⎿  Edit: src/auth.ts
 ```
 
-## Tools (35)
+## Tools (37)
 
 | Tool | Description |
 |------|-------------|
 | **File Operations** | |
-| `file_read` | Read file contents with line numbers (offset/limit) |
-| `file_write` | Create or overwrite files |
-| `file_edit` | Precise string replacement in files |
+| `file_read` | Read file contents with line numbers (offset/limit for large files) |
+| `file_write` | Create or overwrite files with automatic directory creation |
+| `file_edit` | Precise string replacement in files (preferred over rewriting) |
+| `file_patch` | Edit specific line ranges in large files (replace, insert_before/after, delete) |
 | `batch_edit` | Multiple edits across files in one call |
-| `list_directory` | List directory contents |
+| `list_directory` | List directory contents with types and sizes |
 | **Search & Navigation** | |
-| `grep_search` | Search file contents with regex (ripgrep) |
-| `find_files` | Find files by glob pattern |
-| `codebase_map` | High-level project structure overview |
+| `grep_search` | Search file contents with regex (ripgrep with grep fallback) |
+| `find_files` | Find files by glob pattern (excludes node_modules/.git) |
+| `codebase_map` | High-level project structure overview with directory tree |
 | **Shell & Execution** | |
-| `shell` | Execute any shell command |
+| `shell` | Execute any shell command (non-interactive, CI=true) |
 | `code_sandbox` | Isolated code execution (JS, Python, Bash, TS) in subprocess or Docker |
-| `background_run` | Run shell command in background |
+| `background_run` | Run shell command in background, returns task ID |
 | `task_status` | Check background task status |
 | `task_output` | Read background task output |
 | `task_stop` | Stop a background task |
 | **Web** | |
 | `web_search` | Search the web (DuckDuckGo, Tavily, Jina AI — auto-detected) |
-| `web_fetch` | Fetch and extract text from web pages |
+| `web_fetch` | Fetch and extract text from web pages (HTML stripping) |
+| `web_crawl` | Multi-page web scraping with Crawlee/Playwright for deep documentation |
 | **Structured Data** | |
 | `structured_file` | Generate CSV, TSV, JSON, Markdown tables, Excel-compatible files |
 | `read_structured_file` | Parse CSV, TSV, JSON, Markdown tables with binary detection |
@@ -332,24 +467,27 @@ While the agent is working (shown by the `+` prompt), type to add context:
 | `desktop_click` | Vision-guided clicking: describe a UI element, agent finds and clicks it |
 | `desktop_describe` | Screenshot + Moondream caption/query for desktop awareness |
 | `image_read` | Read images (base64 + OCR) |
-| `screenshot` | Capture screen/window |
-| `ocr` | Extract text from images (Tesseract) |
+| `screenshot` | Capture screen/window/active window |
+| `ocr` | Extract text from images (Tesseract with multi-variant preprocessing) |
+| `ocr_pdf` | Add searchable text layer to scanned/image PDFs |
+| `pdf_to_text` | Extract text from PDF using pdftotext (Poppler) |
+| `transcribe_file` | Transcribe audio/video to text (Whisper) |
 | **Memory & Knowledge** | |
-| `memory_read` | Read from persistent memory store |
-| `memory_write` | Store patterns for future sessions |
+| `memory_read` | Read from persistent memory store by topic |
+| `memory_write` | Store facts/patterns in persistent memory with provenance tracking |
+| `memex_retrieve` | Recover full tool output archived during context compaction by hash ID |
 | **Git & Diagnostics** | |
-| `diagnostic` | Lint/typecheck/test/build validation pipeline |
-| `git_info` | Structured git status, log, diff, branch info |
+| `diagnostic` | Lint/typecheck/test/build validation pipeline in one call |
+| `git_info` | Structured git status, log, diff, branch, staged/unstaged files |
 | **Agents & Skills** | |
-| `sub_agent` | Delegate to an independent agent |
-| `create_tool` | Create reusable custom tools at runtime |
+| `create_tool` | Create reusable custom tools from workflow at runtime |
 | `manage_tools` | List, inspect, delete custom tools |
 | `skill_list` | Discover available AIWG skills |
 | `skill_execute` | Run an AIWG skill |
 | **AIWG SDLC** | |
 | `aiwg_setup` | Deploy AIWG SDLC framework |
-| `aiwg_health` | Analyze SDLC health |
-| `aiwg_workflow` | Execute AIWG workflows |
+| `aiwg_health` | Analyze project SDLC health and readiness |
+| `aiwg_workflow` | Execute AIWG commands and workflows |
 
 Read-only tools execute concurrently when called in the same turn. Mutating tools run sequentially.
 
@@ -366,6 +504,41 @@ On startup and `/model` switch, Open Agents detects your RAM/VRAM and creates an
 | 8GB+ | 8K tokens |
 | < 8GB | 4K tokens |
 
+## Model-Tier Awareness
+
+Open Agents classifies models into three tiers and adapts its behavior accordingly:
+
+| Tier | Parameters | Base Tools | System Prompt | Compaction |
+|------|-----------|------------|---------------|------------|
+| **Large** (≥30B) | 70B, 122B | All 37 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 |
+
+### 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 37 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
+
+### Dynamic Context Limits
+
+All context-dependent values scale automatically with the actual context window size:
+
+| Setting | How It Scales |
+|---------|---------------|
+| Compaction threshold | min(tier default, 75% of context window) |
+| Recent messages kept | 1 message per 2-4K of context (tier-dependent) |
+| Max output tokens | 25% of context window (min 2048) |
+| Tool output cap | 2K-8K chars (scales with context) |
+| File read limits | 80-120 line cap for small/medium context windows |
+
 ## Voice Feedback (TTS)
 
 ```bash
@@ -476,13 +649,16 @@ Create `AGENTS.md`, `OA.md`, or `.open-agents.md` in your project root for agent
 ```
 .oa/
 ├── config.json        # Project config overrides
-├── settings.json      # TUI settings
-├── memory/            # Persistent memory store
+├── settings.json      # TUI settings (model, endpoint, voice, stream, etc.)
+├── memory/            # Persistent memory store (topics, patterns, facts)
 ├── dreams/            # Dream mode proposals & checkpoints
 ├── transcripts/       # Audio/video transcriptions
 ├── index/             # Cached codebase index
-├── context/           # Auto-generated project context
-└── history/           # Session history
+├── context/           # Session context persistence
+│   └── session-context.json  # Rolling 20-entry context window
+├── session/           # Compaction summaries for crash recovery
+├── history/           # Session history
+└── pending-task.json  # Saved task state for /stop and /update resume
 ```
 
 ## Model Support
@@ -541,10 +717,10 @@ The agent auto-detects the provider, normalizes the URL (strips `/v1/chat/comple
 
 ## Evaluation Suite
 
-23 evaluation tasks test the agent's autonomous capabilities across coding, web research, SDLC analysis, and tool creation:
+33 evaluation tasks test the agent's autonomous capabilities across coding, web research, SDLC analysis, tool creation, and multi-file reasoning:
 
 ```bash
-node eval/run-agentic.mjs                          # Run all 23 tasks
+node eval/run-agentic.mjs                          # Run all tasks
 node eval/run-agentic.mjs 04-add-test              # Single task
 node eval/run-agentic.mjs --model qwen2.5-coder:32b  # Different model
 ```
@@ -574,15 +750,23 @@ node eval/run-agentic.mjs --model qwen2.5-coder:32b  # Different model
 | 21 | Large file patch | Precision Editing |
 | 22 | Skill discovery | Skill System |
 | 23 | Skill execution | Skill System |
+| 24-30 | Additional coding tasks | Various |
+| 31 | Web extractor bug fixes (3 bugs) | Multi-Bug Fix |
+| 32 | CSV pipeline across 3 files | Multi-File Tracking |
+| 33 | FSM bug fixes + factory implementation | State Machine |
+
+Tasks 31-33 are designed for small model (≤9B) evaluation using `file_edit` patterns instead of `file_write` to avoid JSON truncation issues with smaller models.
 
-### Benchmark Results (Qwen3.5-122B)
+### Benchmark Results
 
 ```
-Pass rate: 100% (8/8 core tasks)
-Total: 39 turns, 55 tool calls, ~10 minutes
-Average: 4.9 turns/task, 6.9 tools/task
+Qwen3.5-122B: 100% pass rate (30/30 tasks)
+Qwen3.5-27B:  100% pass rate (30/30 tasks)
+Qwen3.5-9B:   100% pass rate (tasks 31-33, file_edit-optimized)
 ```
 
+The eval runner includes model-tier-aware features: automatic tool set filtering, HTTP 500 recovery with file_edit hints, loop detection with tool banning, and tier-based output truncation.
+
 ## AIWG Integration
 
 Open Agents integrates with [AIWG](https://www.npmjs.com/package/aiwg) for AI-augmented software development:
@@ -602,10 +786,12 @@ oa "analyze this project's SDLC health and set up documentation"
 
 ## Architecture
 
-The core is `AgenticRunner` — a multi-turn tool-calling loop:
+The core is `AgenticRunner` — a multi-turn tool-calling loop with context management:
 
 ```
 User task → System prompt + tools → LLM → tool_calls → Execute → Feed results → LLM
+                                          ↓                                      ↑
+                                    Compaction check ─── Memex archive ─── Context restore
                                           (repeat until task_complete or max turns)
 ```
 
@@ -614,6 +800,8 @@ User task → System prompt + tools → LLM → tool_calls → Execute → Feed
 - **Parallel-safe** — read-only tools concurrent, mutating tools sequential
 - **Observable** — every tool call and result emitted as a real-time event
 - **Bounded** — max turns, timeout, output limits prevent runaway loops
+- **Context-aware** — dynamic compaction, Memex archiving, session persistence, model-tier scaling
+- **Brute-force** — optional auto re-engagement when turn limit is hit (keeps going until task_complete or user abort)
 
 ## License
 

package/dist/index.js

@@ -22029,6 +22029,19 @@ import { createRequire as createRequire2 } from "node:module";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 import { readFileSync as readFileSync18, rmSync as rmSync2 } from "node:fs";
 import { existsSync as existsSync24 } from "node:fs";
+function formatTimeAgo(date) {
+  const seconds = Math.floor((Date.now() - date.getTime()) / 1e3);
+  if (seconds < 60)
+    return "just now";
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60)
+    return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24)
+    return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
 function getVersion() {
   try {
     const require2 = createRequire2(import.meta.url);
@@ -22699,6 +22712,7 @@ async function startInteractive(config, repoPath) {
   let sessionFilesTouched = [];
   let sessionToolCallCount = 0;
   let restoredSessionContext = null;
+  let pendingSessionRestore = false;
   let sessionSudoPassword = null;
   let sudoPromptPending = false;
   const idlePrompt = `${c2.bold(c2.white("\u276F "))}`;
@@ -23123,6 +23137,24 @@ async function startInteractive(config, repoPath) {
     }
   };
   showPrompt();
+  if (!isResumed) {
+    const savedCtx = loadSessionContext(repoRoot);
+    if (savedCtx && savedCtx.entries.length > 0) {
+      const lastEntry = savedCtx.entries[savedCtx.entries.length - 1];
+      const lastTime = lastEntry.savedAt ? new Date(lastEntry.savedAt) : null;
+      const timeAgo = lastTime ? formatTimeAgo(lastTime) : "unknown";
+      const lastTask = lastEntry.task?.slice(0, 80) || "unknown";
+      setTimeout(() => {
+        writeContent(() => {
+          renderInfo(`Previous session found (${savedCtx.entries.length} entries, last active ${timeAgo})`);
+          renderInfo(`Last task: ${lastTask}${lastEntry.task && lastEntry.task.length > 80 ? "..." : ""}`);
+          renderInfo(`Restore previous context? (y/n)`);
+        });
+        showPrompt();
+        pendingSessionRestore = true;
+      }, 150);
+    }
+  }
   if (hasTaskToResume) {
     const pendingTask = loadPendingTask(repoRoot);
     if (pendingTask) {
@@ -23166,6 +23198,22 @@ ${sessionCtx}` : "",
   }
   rl.on("line", (line) => {
     const input = line.trim();
+    if (pendingSessionRestore) {
+      pendingSessionRestore = false;
+      const answer = input.toLowerCase();
+      if (answer === "y" || answer === "yes") {
+        const prompt = buildContextRestorePrompt(repoRoot);
+        if (prompt) {
+          restoredSessionContext = prompt;
+          const info = loadSessionContext(repoRoot);
+          writeContent(() => renderInfo(`Context restored from ${info?.entries.length ?? 0} session(s). Will be injected into your next task.`));
+        }
+      } else {
+        writeContent(() => renderInfo("Starting fresh."));
+      }
+      showPrompt();
+      return;
+    }
     if (!input) {
       if (pasteBuffer.length > 0) {
         flushPasteBuffer();

package/package.json

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