open-agents-ai 0.11.3 → 0.11.5

package/dist/index.js

@@ -6587,7 +6587,8 @@ Commands run non-interactively (CI=true). When running scaffolding tools:
           requestTimeoutMs: options?.requestTimeoutMs ?? 3e5,
           taskTimeoutMs: options?.taskTimeoutMs ?? 12e5,
           compactionThreshold: options?.compactionThreshold ?? 4e4,
-          dynamicContext: options?.dynamicContext ?? ""
+          dynamicContext: options?.dynamicContext ?? "",
+          streamEnabled: options?.streamEnabled ?? false
         };
       }
       /** Register a tool for the agent to use */
@@ -6683,13 +6684,14 @@ Integrate this guidance into your current approach. Continue working on the task
             });
           }
           const compacted = this.compactMessages(messages);
-          const response = await this.backend.chatCompletion({
+          const chatRequest = {
             messages: compacted,
             tools: toolDefs,
             temperature: this.options.temperature,
             maxTokens: this.options.maxTokens,
             timeoutMs: this.options.requestTimeoutMs
-          });
+          };
+          const response = this.options.streamEnabled && this.hasStreamingSupport() ? await this.streamingRequest(chatRequest, turn) : await this.backend.chatCompletion(chatRequest);
           totalTokens += response.usage?.totalTokens ?? 0;
           const choice = response.choices[0];
           if (!choice)
@@ -6829,36 +6831,112 @@ ${marker}` : marker);
         const middle = messages.slice(2, -keepRecent);
         if (middle.length === 0)
           return messages;
-        const summary = this.summarizeCompactedMessages(middle);
+        let previousSummary = "";
+        const nonCompactionMiddle = [];
+        for (const msg of middle) {
+          if (msg.role === "system" && typeof msg.content === "string" && msg.content.startsWith("[Context compacted")) {
+            previousSummary = msg.content.replace(/^\[Context compacted[^\]]*\]\s*/, "").replace(/\n\n\[Continue from[^\]]*\]\s*$/, "").trim();
+          } else {
+            nonCompactionMiddle.push(msg);
+          }
+        }
+        const newSummary = this.summarizeCompactedMessages(nonCompactionMiddle);
+        const combinedSummary = previousSummary ? this.progressiveSummarize(previousSummary, newSummary) : newSummary;
         this.emit({
           type: "compaction",
-          content: `Compacted ${middle.length} messages`,
+          content: `Compacted ${middle.length} messages${previousSummary ? " (progressive)" : ""}`,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
         const compactionMsg = {
           role: "system",
           content: `[Context compacted \u2014 summary of earlier work]
 
-${summary}
+${combinedSummary}
 
 [Continue from the recent context below. Do not repeat work already completed above.]`
         };
         return [...head, compactionMsg, ...recent];
       }
       /**
-       * Extract a structured summary from compacted messages, preserving:
-       * - Files read/written/edited
-       * - Shell commands run and their outcomes
-       * - Key decisions and findings
+       * Progressive summarization: merge an older compacted summary with a newer one.
+       * When the combined text exceeds the budget, condense the older summary.
+       */
+      progressiveSummarize(olderSummary, newerSummary) {
+        const MAX_SUMMARY_CHARS = 4e3;
+        const combined = `${olderSummary}
+
+---
+
+${newerSummary}`;
+        if (combined.length <= MAX_SUMMARY_CHARS) {
+          return combined;
+        }
+        const condensed = this.condenseSummary(olderSummary);
+        const result = `${condensed}
+
+---
+
+${newerSummary}`;
+        if (result.length > MAX_SUMMARY_CHARS) {
+          const budget = MAX_SUMMARY_CHARS - newerSummary.length - 60;
+          return budget > 200 ? `[Earlier work, condensed]
+${olderSummary.slice(0, budget)}...
+
+---
+
+${newerSummary}` : newerSummary;
+        }
+        return result;
+      }
+      /**
+       * Condense a summary by keeping section headings and only first 2 items under each.
+       */
+      condenseSummary(summary) {
+        const lines = summary.split("\n");
+        const condensed = [];
+        let itemCount = 0;
+        for (const line of lines) {
+          if (line.startsWith("##") || line.startsWith("---") || line.trim() === "") {
+            condensed.push(line);
+            itemCount = 0;
+          } else if (line.startsWith("- ") || line.startsWith("  - ")) {
+            if (itemCount < 2) {
+              condensed.push(line);
+            } else if (itemCount === 2) {
+              condensed.push("  - ...(condensed)");
+            }
+            itemCount++;
+          } else {
+            condensed.push(line);
+          }
+        }
+        return condensed.join("\n");
+      }
+      /**
+       * Extract a rich structured summary from compacted messages, preserving:
+       * - Assistant analysis/reasoning text
+       * - File contents examined (key snippets, not just names)
+       * - Specific code changes (old_string → new_string)
+       * - Shell command results (test pass/fail, build errors)
+       * - Search findings (grep/find results)
        * - Errors encountered
        */
       summarizeCompactedMessages(messages) {
-        const filesRead = /* @__PURE__ */ new Set();
-        const filesModified = /* @__PURE__ */ new Set();
-        const commandsRun = [];
+        const toolCallMap = /* @__PURE__ */ new Map();
+        const assistantAnalysis = [];
+        const filesRead = /* @__PURE__ */ new Map();
+        const filesModified = /* @__PURE__ */ new Map();
+        const commandResults = [];
+        const searchFindings = [];
         const errors = [];
         let toolCallCount = 0;
         for (const msg of messages) {
+          if (msg.role === "assistant" && typeof msg.content === "string" && msg.content.trim()) {
+            const text = msg.content.trim();
+            if (text.length > 20) {
+              assistantAnalysis.push(text.length > 400 ? text.slice(0, 400) + "..." : text);
+            }
+          }
           if (msg.tool_calls) {
             for (const tc of msg.tool_calls) {
               toolCallCount++;
@@ -6869,37 +6947,134 @@ ${summary}
                   return {};
                 }
               })();
+              toolCallMap.set(tc.id, { name: tc.function.name, args });
               const name = tc.function.name;
-              if (name === "file_read") {
-                filesRead.add(String(args.path || ""));
-              } else if (name === "file_write" || name === "file_edit" || name === "batch_edit") {
-                filesModified.add(String(args.path || ""));
-              } else if (name === "shell" || name === "background_run") {
-                const cmd = String(args.command || "").slice(0, 80);
-                if (cmd)
-                  commandsRun.push(cmd);
+              if (name === "file_edit") {
+                const path = String(args.path || "");
+                const oldStr = String(args.old_string || "").slice(0, 100);
+                const newStr = String(args.new_string || "").slice(0, 100);
+                if (path) {
+                  const changes = filesModified.get(path) || [];
+                  changes.push(`"${oldStr}" \u2192 "${newStr}"`);
+                  filesModified.set(path, changes);
+                }
+              } else if (name === "file_write") {
+                const path = String(args.path || "");
+                if (path) {
+                  if (!filesModified.has(path))
+                    filesModified.set(path, []);
+                  filesModified.get(path).push("(full file write)");
+                }
+              } else if (name === "batch_edit") {
+                const path = String(args.path || "");
+                if (path) {
+                  if (!filesModified.has(path))
+                    filesModified.set(path, []);
+                  filesModified.get(path).push("(batch edit)");
+                }
               }
             }
           }
-          if (msg.role === "tool" && typeof msg.content === "string") {
-            if (msg.content.startsWith("Error:")) {
-              errors.push(msg.content.slice(0, 150));
+          if (msg.role === "tool" && typeof msg.content === "string" && msg.tool_call_id) {
+            const tc = toolCallMap.get(msg.tool_call_id);
+            const content = msg.content;
+            if (!tc) {
+              if (content.startsWith("Error:"))
+                errors.push(content.slice(0, 200));
+              continue;
+            }
+            switch (tc.name) {
+              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);
+                if (path)
+                  filesRead.set(path, summary);
+                break;
+              }
+              case "shell":
+              case "background_run": {
+                const cmd = String(tc.args.command || "").slice(0, 100);
+                const hasError = content.startsWith("Error:") || /FAIL|ERR!/i.test(content);
+                const hasPass = /PASS|passed|✓|success/i.test(content);
+                let outcome;
+                if (hasError) {
+                  const errorLines = content.split("\n").filter((l) => /error|FAIL|✗|×|ERR!/i.test(l)).slice(0, 3);
+                  outcome = errorLines.length > 0 ? errorLines.join("; ").slice(0, 200) : content.slice(0, 200);
+                  errors.push(`\`${cmd}\`: ${outcome.slice(0, 150)}`);
+                } else if (hasPass) {
+                  outcome = "passed";
+                } else {
+                  outcome = content.slice(0, 150);
+                }
+                commandResults.push({ cmd, outcome });
+                break;
+              }
+              case "grep_search": {
+                const pattern = String(tc.args.pattern || "");
+                const matchCount = (content.match(/\n/g) || []).length;
+                searchFindings.push(`grep "${pattern}": ${matchCount} matches \u2014 ${content.slice(0, 150)}`);
+                break;
+              }
+              case "find_files": {
+                const pattern = String(tc.args.pattern || "");
+                const files = content.split("\n").filter(Boolean);
+                searchFindings.push(`find "${pattern}": ${files.length} files \u2014 ${files.slice(0, 5).join(", ")}`);
+                break;
+              }
+              default: {
+                if (content.startsWith("Error:"))
+                  errors.push(`${tc.name}: ${content.slice(0, 200)}`);
+              }
             }
           }
         }
         const parts = [];
-        parts.push(`${toolCallCount} tool calls were made in the compacted section.`);
+        parts.push(`## Compacted Work Summary (${toolCallCount} tool calls)
+`);
+        if (assistantAnalysis.length > 0) {
+          parts.push("### Agent Analysis");
+          for (const analysis of assistantAnalysis.slice(-5)) {
+            parts.push(`- ${analysis}`);
+          }
+          parts.push("");
+        }
         if (filesRead.size > 0) {
-          parts.push(`Files read: ${Array.from(filesRead).slice(0, 15).join(", ")}`);
+          parts.push("### Files Examined");
+          for (const [path, summary] of Array.from(filesRead).slice(0, 15)) {
+            parts.push(`- \`${path}\`: ${summary}`);
+          }
+          parts.push("");
         }
         if (filesModified.size > 0) {
-          parts.push(`Files modified: ${Array.from(filesModified).slice(0, 15).join(", ")}`);
+          parts.push("### Code Changes Made");
+          for (const [path, changes] of Array.from(filesModified).slice(0, 10)) {
+            parts.push(`- **${path}**:`);
+            for (const change of changes.slice(0, 3)) {
+              parts.push(`  - ${change}`);
+            }
+          }
+          parts.push("");
         }
-        if (commandsRun.length > 0) {
-          parts.push(`Commands run: ${commandsRun.slice(0, 8).join("; ")}`);
+        if (commandResults.length > 0) {
+          parts.push("### Commands Executed");
+          for (const { cmd, outcome } of commandResults.slice(0, 8)) {
+            parts.push(`- \`${cmd}\` \u2192 ${outcome}`);
+          }
+          parts.push("");
+        }
+        if (searchFindings.length > 0) {
+          parts.push("### Search Findings");
+          for (const finding of searchFindings.slice(0, 5)) {
+            parts.push(`- ${finding}`);
+          }
+          parts.push("");
         }
         if (errors.length > 0) {
-          parts.push(`Errors encountered: ${errors.slice(0, 3).join("; ")}`);
+          parts.push("### Errors Encountered");
+          for (const error of errors.slice(0, 5)) {
+            parts.push(`- ${error}`);
+          }
         }
         return parts.join("\n");
       }
@@ -6916,6 +7091,90 @@ ${summary}
           }
         }));
       }
+      // -------------------------------------------------------------------------
+      // Streaming support — parallel path that emits token events
+      // -------------------------------------------------------------------------
+      /** Check whether the backend supports SSE streaming */
+      hasStreamingSupport() {
+        return typeof this.backend.chatCompletionStream === "function";
+      }
+      /**
+       * Streaming request: calls the SSE endpoint, emits stream events,
+       * assembles and returns the same response format as chatCompletion().
+       * The non-streaming chatCompletion path is NEVER touched by this code.
+       */
+      async streamingRequest(request, turn) {
+        const backend = this.backend;
+        let content = "";
+        let inThinkTag = false;
+        const toolCallAccumulators = /* @__PURE__ */ new Map();
+        this.emit({ type: "stream_start", turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+        for await (const chunk of backend.chatCompletionStream(request)) {
+          if (this.aborted)
+            break;
+          if (chunk.type === "content" && chunk.content) {
+            content += chunk.content;
+            let kind = inThinkTag ? "thinking" : "content";
+            const fragment = chunk.content;
+            if (fragment.includes("<think>")) {
+              inThinkTag = true;
+              kind = "thinking";
+            }
+            if (fragment.includes("</think>")) {
+              inThinkTag = false;
+              kind = "content";
+            }
+            this.emit({
+              type: "stream_token",
+              content: fragment,
+              streamKind: kind,
+              turn,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+          if (chunk.type === "tool_call_delta") {
+            const idx = chunk.toolCallIndex ?? 0;
+            if (!toolCallAccumulators.has(idx)) {
+              toolCallAccumulators.set(idx, {
+                id: chunk.toolCallId ?? crypto.randomUUID(),
+                name: chunk.toolCallName ?? "",
+                args: ""
+              });
+            }
+            const acc = toolCallAccumulators.get(idx);
+            if (chunk.toolCallName)
+              acc.name = chunk.toolCallName;
+            if (chunk.toolCallId)
+              acc.id = chunk.toolCallId;
+            if (chunk.toolCallArgs) {
+              acc.args += chunk.toolCallArgs;
+              this.emit({
+                type: "stream_token",
+                content: chunk.toolCallArgs,
+                streamKind: "tool_args",
+                turn,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+            }
+          }
+        }
+        this.emit({ type: "stream_end", content, turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+        const cleanContent = content.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
+        const toolCalls = toolCallAccumulators.size > 0 ? Array.from(toolCallAccumulators.values()).map((tc) => {
+          let args;
+          try {
+            args = JSON.parse(tc.args);
+          } catch {
+            args = { _raw: tc.args };
+          }
+          return { id: tc.id, name: tc.name, arguments: args };
+        }) : void 0;
+        return {
+          choices: [{ message: { content: cleanContent || null, toolCalls } }],
+          usage: void 0
+          // SSE responses typically don't include usage in chunks
+        };
+      }
     };
     OllamaAgenticBackend = class {
       baseUrl;
@@ -6975,6 +7234,79 @@ ${summary}
           usage: usage ? { totalTokens: usage.total_tokens ?? 0 } : void 0
         };
       }
+      /**
+       * SSE streaming variant — yields StreamChunks as tokens arrive.
+       * Uses `stream: true` and `think: true` so thinking tokens are visible.
+       * The existing chatCompletion() method is completely unmodified.
+       */
+      async *chatCompletionStream(request) {
+        const body = {
+          model: this.model,
+          messages: request.messages,
+          tools: request.tools,
+          temperature: request.temperature,
+          max_tokens: request.maxTokens,
+          stream: true,
+          think: true
+        };
+        const resp = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body),
+          signal: AbortSignal.timeout(request.timeoutMs)
+        });
+        if (!resp.ok) {
+          const text = await resp.text().catch(() => "");
+          const isHtml = text.trimStart().startsWith("<!") || text.trimStart().startsWith("<html");
+          const detail = isHtml ? `(received HTML error page \u2014 backend may be behind a proxy/CDN that is timing out)` : text.slice(0, 200);
+          throw new Error(`Backend HTTP ${resp.status}: ${detail}`);
+        }
+        let sseBuffer = "";
+        const decoder = new TextDecoder();
+        for await (const rawChunk of resp.body) {
+          sseBuffer += decoder.decode(rawChunk, { stream: true });
+          const parts = sseBuffer.split("\n\n");
+          sseBuffer = parts.pop();
+          for (const part of parts) {
+            const line = part.trim();
+            if (!line)
+              continue;
+            if (line === "data: [DONE]")
+              return;
+            if (!line.startsWith("data: "))
+              continue;
+            try {
+              const data = JSON.parse(line.slice(6));
+              const choices = data.choices ?? [];
+              const choice = choices[0];
+              if (!choice)
+                continue;
+              const delta = choice.delta;
+              const finishReason = choice.finish_reason;
+              if (delta?.content) {
+                yield { type: "content", content: delta.content };
+              }
+              const tcDeltas = delta?.tool_calls;
+              if (tcDeltas) {
+                for (const tcd of tcDeltas) {
+                  const fn = tcd.function;
+                  yield {
+                    type: "tool_call_delta",
+                    toolCallIndex: tcd.index ?? 0,
+                    toolCallId: tcd.id || void 0,
+                    toolCallName: fn?.name || void 0,
+                    toolCallArgs: fn?.arguments || void 0
+                  };
+                }
+              }
+              if (finishReason) {
+                yield { type: "finish", finishReason };
+              }
+            } catch {
+            }
+          }
+        }
+      }
     };
   }
 });
@@ -7232,6 +7564,7 @@ function renderSlashHelp() {
     ["/update", "Check for updates and auto-install"],
     ["/voice", "Toggle TTS voice feedback (GLaDOS)"],
     ["/voice <model>", "Set voice: glados, overwatch"],
+    ["/stream", "Toggle real-time token streaming (pastel syntax highlighting)"],
     ["/verbose", "Toggle verbose mode"],
     ["/clear", "Clear the screen"],
     ["/help", "Show this help"],
@@ -7509,6 +7842,7 @@ var init_render = __esm({
       "/config",
       "/update",
       "/voice",
+      "/stream",
       "/verbose",
       "/clear",
       "/help",
@@ -7595,6 +7929,13 @@ async function handleSlashCommand(input, ctx) {
       }
       return "handled";
     }
+    case "stream": {
+      const isOn = ctx.streamToggle();
+      const save = hasLocal ? ctx.saveLocalSettings.bind(ctx) : ctx.saveSettings.bind(ctx);
+      save({ stream: isOn });
+      renderInfo(`Token streaming: ${isOn ? "on" : "off"}${hasLocal ? " (project-local)" : ""}` + (isOn ? " \u2014 thinking tokens in grey italics, responses with pastel syntax highlighting" : ""));
+      return "handled";
+    }
     default:
       renderWarning(`Unknown command: /${cmd}. Type /help for available commands.`);
       return "handled";
@@ -8647,14 +8988,62 @@ function getEnvironment(repoRoot) {
   ];
   return lines.join("\n");
 }
-function buildProjectContext(repoRoot) {
+function loadTaskMemories(repoRoot, store) {
+  try {
+    let tasks = store.listByRepo(repoRoot);
+    if (tasks.length === 0) {
+      tasks = store.recent(10);
+    }
+    if (tasks.length === 0)
+      return "";
+    const lines = ["Recent agent tasks (cross-session memory):"];
+    for (const t of tasks.slice(0, 10)) {
+      const date = t.createdAt.split("T")[0];
+      const files = t.filesTouched.slice(0, 5).join(", ");
+      lines.push(`- [${date}] ${t.goal.slice(0, 100)} \u2192 ${t.outcome}${files ? ` (files: ${files})` : ""}`);
+      if (t.notes) {
+        lines.push(`  Notes: ${t.notes.slice(0, 150)}`);
+      }
+    }
+    return lines.join("\n");
+  } catch {
+    return "";
+  }
+}
+function loadFailurePatterns(store) {
+  try {
+    const unresolved = store.listUnresolved();
+    if (unresolved.length === 0)
+      return "";
+    const seen = /* @__PURE__ */ new Set();
+    const unique = unresolved.filter((f) => {
+      if (seen.has(f.fingerprint))
+        return false;
+      seen.add(f.fingerprint);
+      return true;
+    });
+    if (unique.length === 0)
+      return "";
+    const lines = ["Known failure patterns (avoid repeating these):"];
+    for (const f of unique.slice(0, 8)) {
+      const file = f.filePath ? ` in ${f.filePath}` : "";
+      lines.push(`- [${f.failureType}]${file}: ${f.errorMessage.slice(0, 150)}`);
+    }
+    return lines.join("\n");
+  } catch {
+    return "";
+  }
+}
+function buildProjectContext(repoRoot, stores) {
   return {
     projectInstructions: loadProjectFiles(repoRoot),
     projectMap: loadProjectMap(repoRoot),
     gitInfo: getGitInfo(repoRoot),
     memoryContext: loadMemoryContext(repoRoot),
     sessionHistory: loadSessionHistory(repoRoot),
-    environment: getEnvironment(repoRoot)
+    environment: getEnvironment(repoRoot),
+    taskMemories: stores?.taskMemoryStore ? loadTaskMemories(repoRoot, stores.taskMemoryStore) : "",
+    failurePatterns: stores?.failureStore ? loadFailurePatterns(stores.failureStore) : ""
   };
 }
 function formatContextForPrompt(ctx) {
@@ -8688,6 +9077,20 @@ Use this context to avoid re-learning known patterns. Update with memory_write i
     sections.push(`## Session History
 
 ${ctx.sessionHistory}`);
+  }
+  if (ctx.taskMemories) {
+    sections.push(`## Cross-Session Task Memory
+
+${ctx.taskMemories}
+
+Use this history to avoid re-doing completed work and to learn from past approaches.`);
+  }
+  if (ctx.failurePatterns) {
+    sections.push(`## Known Failure Patterns
+
+${ctx.failurePatterns}
+
+Avoid approaches that led to these failures. If you encounter these errors, try a different strategy.`);
   }
   return sections.join("\n\n");
 }
@@ -8698,6 +9101,354 @@ var init_project_context = __esm({
   }
 });
 
+// packages/memory/dist/db.js
+import Database from "better-sqlite3";
+function initDb(dbPath) {
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  runMigrations(db);
+  return db;
+}
+function closeDb(db) {
+  db.close();
+}
+function runMigrations(db) {
+  db.exec(`
+    -- repo_profiles: one row per repository root.
+    CREATE TABLE IF NOT EXISTS repo_profiles (
+      repo_root       TEXT    PRIMARY KEY,
+      languages       TEXT    NOT NULL DEFAULT '[]',   -- JSON array
+      frameworks      TEXT    NOT NULL DEFAULT '[]',   -- JSON array
+      build_system    TEXT    NOT NULL DEFAULT '',
+      test_commands   TEXT    NOT NULL DEFAULT '[]',   -- JSON array
+      lint_commands   TEXT    NOT NULL DEFAULT '[]',   -- JSON array
+      package_manager TEXT    NOT NULL DEFAULT '',
+      notes           TEXT,
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      updated_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+    );
+
+    -- file_summaries: one row per (repo_root, file_path) pair.
+    CREATE TABLE IF NOT EXISTS file_summaries (
+      file_path       TEXT    NOT NULL,
+      repo_root       TEXT    NOT NULL,
+      purpose         TEXT    NOT NULL DEFAULT '',
+      exports         TEXT    NOT NULL DEFAULT '[]',   -- JSON array
+      imports         TEXT    NOT NULL DEFAULT '[]',   -- JSON array
+      domain          TEXT    NOT NULL DEFAULT '',
+      risk_level      TEXT    NOT NULL DEFAULT 'low',  -- low | medium | high
+      related_tests   TEXT    NOT NULL DEFAULT '[]',   -- JSON array
+      notes           TEXT,
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      updated_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      PRIMARY KEY (file_path)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_file_summaries_repo
+      ON file_summaries (repo_root);
+
+    CREATE INDEX IF NOT EXISTS idx_file_summaries_domain
+      ON file_summaries (domain);
+
+    CREATE INDEX IF NOT EXISTS idx_file_summaries_risk
+      ON file_summaries (risk_level);
+
+    -- task_memory: historical record of agent tasks.
+    CREATE TABLE IF NOT EXISTS task_memory (
+      id              TEXT    PRIMARY KEY,
+      session_id      TEXT    NOT NULL,
+      repo_root       TEXT    NOT NULL,
+      goal            TEXT    NOT NULL DEFAULT '',
+      constraints     TEXT    NOT NULL DEFAULT '[]',   -- JSON array
+      files_touched   TEXT    NOT NULL DEFAULT '[]',   -- JSON array
+      patches         TEXT    NOT NULL DEFAULT '[]',   -- JSON array
+      outcome         TEXT    NOT NULL DEFAULT 'unknown', -- success | failure | partial | unknown
+      quality_score   REAL,
+      notes           TEXT,
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_task_memory_session
+      ON task_memory (session_id);
+
+    CREATE INDEX IF NOT EXISTS idx_task_memory_repo
+      ON task_memory (repo_root);
+
+    CREATE INDEX IF NOT EXISTS idx_task_memory_outcome
+      ON task_memory (outcome);
+
+    -- patch_history: individual file diffs applied by the agent.
+    CREATE TABLE IF NOT EXISTS patch_history (
+      id              TEXT    PRIMARY KEY,
+      task_id         TEXT    NOT NULL,
+      session_id      TEXT    NOT NULL,
+      repo_root       TEXT    NOT NULL,
+      file_path       TEXT    NOT NULL,
+      diff            TEXT    NOT NULL DEFAULT '',
+      status          TEXT    NOT NULL DEFAULT 'applied', -- applied | reverted | pending | failed
+      applied_at      TEXT,
+      reverted_at     TEXT,
+      notes           TEXT,
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_patch_history_task
+      ON patch_history (task_id);
+
+    CREATE INDEX IF NOT EXISTS idx_patch_history_file
+      ON patch_history (file_path);
+
+    CREATE INDEX IF NOT EXISTS idx_patch_history_status
+      ON patch_history (status);
+
+    -- failures: fingerprinted failure events for pattern detection.
+    CREATE TABLE IF NOT EXISTS failures (
+      id              TEXT    PRIMARY KEY,
+      task_id         TEXT    NOT NULL,
+      session_id      TEXT    NOT NULL,
+      repo_root       TEXT    NOT NULL,
+      failure_type    TEXT    NOT NULL DEFAULT '',
+      fingerprint     TEXT    NOT NULL DEFAULT '',
+      file_path       TEXT,
+      error_message   TEXT    NOT NULL DEFAULT '',
+      context         TEXT,                            -- JSON object or null
+      resolved        INTEGER NOT NULL DEFAULT 0,      -- 0 = false, 1 = true
+      resolved_at     TEXT,
+      notes           TEXT,
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_failures_type
+      ON failures (failure_type);
+
+    CREATE INDEX IF NOT EXISTS idx_failures_fingerprint
+      ON failures (fingerprint);
+
+    CREATE INDEX IF NOT EXISTS idx_failures_resolved
+      ON failures (resolved);
+
+    -- validation_runs: results of lint / test / build / typecheck runs.
+    CREATE TABLE IF NOT EXISTS validation_runs (
+      id              TEXT    PRIMARY KEY,
+      task_id         TEXT    NOT NULL,
+      session_id      TEXT    NOT NULL,
+      repo_root       TEXT    NOT NULL,
+      run_type        TEXT    NOT NULL DEFAULT '',     -- test | lint | build | typecheck
+      command         TEXT    NOT NULL DEFAULT '',
+      passed          INTEGER NOT NULL DEFAULT 0,      -- 0 = false, 1 = true
+      duration_ms     INTEGER,
+      output          TEXT,
+      error_output    TEXT,
+      coverage_percent REAL,
+      notes           TEXT,
+      created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_validation_runs_task
+      ON validation_runs (task_id);
+
+    CREATE INDEX IF NOT EXISTS idx_validation_runs_run_type
+      ON validation_runs (run_type);
+
+    CREATE INDEX IF NOT EXISTS idx_validation_runs_passed
+      ON validation_runs (passed);
+  `);
+}
+var init_db = __esm({
+  "packages/memory/dist/db.js"() {
+    "use strict";
+  }
+});
+
+// packages/memory/dist/repoProfileStore.js
+var init_repoProfileStore = __esm({
+  "packages/memory/dist/repoProfileStore.js"() {
+    "use strict";
+  }
+});
+
+// packages/memory/dist/fileSummaryStore.js
+var init_fileSummaryStore = __esm({
+  "packages/memory/dist/fileSummaryStore.js"() {
+    "use strict";
+  }
+});
+
+// packages/memory/dist/taskMemoryStore.js
+import { randomUUID } from "node:crypto";
+function rowToTask(row) {
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    repoRoot: row.repo_root,
+    goal: row.goal,
+    constraints: JSON.parse(row.constraints),
+    filesTouched: JSON.parse(row.files_touched),
+    patches: JSON.parse(row.patches),
+    outcome: row.outcome,
+    qualityScore: row.quality_score ?? null,
+    notes: row.notes ?? null,
+    createdAt: row.created_at
+  };
+}
+var TaskMemoryStore;
+var init_taskMemoryStore = __esm({
+  "packages/memory/dist/taskMemoryStore.js"() {
+    "use strict";
+    TaskMemoryStore = class {
+      db;
+      constructor(db) {
+        this.db = db;
+      }
+      /**
+       * Insert a new task record and return its auto-generated id.
+       */
+      insert(input) {
+        const id = randomUUID();
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        this.db.prepare(`INSERT INTO task_memory
+           (id, session_id, repo_root, goal, constraints,
+            files_touched, patches, outcome, quality_score, notes, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, input.sessionId, input.repoRoot, input.goal, JSON.stringify(input.constraints), JSON.stringify(input.filesTouched), JSON.stringify(input.patches), input.outcome, input.qualityScore ?? null, input.notes ?? null, now);
+        return id;
+      }
+      /** Retrieve a task record by id, or `null` if not found. */
+      getById(id) {
+        const row = this.db.prepare("SELECT * FROM task_memory WHERE id = ?").get(id);
+        return row ? rowToTask(row) : null;
+      }
+      /** List all tasks associated with a session. */
+      listBySession(sessionId) {
+        const rows = this.db.prepare("SELECT * FROM task_memory WHERE session_id = ? ORDER BY created_at DESC").all(sessionId);
+        return rows.map(rowToTask);
+      }
+      /** List all tasks for a repository root. */
+      listByRepo(repoRoot) {
+        const rows = this.db.prepare("SELECT * FROM task_memory WHERE repo_root = ? ORDER BY created_at DESC").all(repoRoot);
+        return rows.map(rowToTask);
+      }
+      /** List tasks filtered by outcome. */
+      listByOutcome(outcome) {
+        const rows = this.db.prepare("SELECT * FROM task_memory WHERE outcome = ? ORDER BY created_at DESC").all(outcome);
+        return rows.map(rowToTask);
+      }
+      /**
+       * Return the N most recently created tasks across all sessions and repos.
+       * Useful for building a rolling context window.
+       */
+      recent(limit) {
+        const rows = this.db.prepare("SELECT * FROM task_memory ORDER BY created_at DESC LIMIT ?").all(limit);
+        return rows.map(rowToTask);
+      }
+    };
+  }
+});
+
+// packages/memory/dist/patchHistoryStore.js
+var init_patchHistoryStore = __esm({
+  "packages/memory/dist/patchHistoryStore.js"() {
+    "use strict";
+  }
+});
+
+// packages/memory/dist/failureStore.js
+import { randomUUID as randomUUID2 } from "node:crypto";
+function rowToFailure(row) {
+  return {
+    id: row.id,
+    taskId: row.task_id,
+    sessionId: row.session_id,
+    repoRoot: row.repo_root,
+    failureType: row.failure_type,
+    fingerprint: row.fingerprint,
+    filePath: row.file_path ?? null,
+    errorMessage: row.error_message,
+    context: row.context !== null ? JSON.parse(row.context) : null,
+    resolved: row.resolved === 1,
+    resolvedAt: row.resolved_at ?? null,
+    notes: row.notes ?? null,
+    createdAt: row.created_at
+  };
+}
+var FailureStore;
+var init_failureStore = __esm({
+  "packages/memory/dist/failureStore.js"() {
+    "use strict";
+    FailureStore = class {
+      db;
+      constructor(db) {
+        this.db = db;
+      }
+      /**
+       * Record a new failure event and return its auto-generated id.
+       */
+      insert(input) {
+        const id = randomUUID2();
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        this.db.prepare(`INSERT INTO failures
+           (id, task_id, session_id, repo_root, failure_type,
+            fingerprint, file_path, error_message, context,
+            resolved, resolved_at, notes, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, input.taskId, input.sessionId, input.repoRoot, input.failureType, input.fingerprint, input.filePath ?? null, input.errorMessage, input.context !== null ? JSON.stringify(input.context) : null, input.resolved ? 1 : 0, input.resolvedAt ?? null, input.notes ?? null, now);
+        return id;
+      }
+      /** Retrieve a failure by id, or `null` if not found. */
+      getById(id) {
+        const row = this.db.prepare("SELECT * FROM failures WHERE id = ?").get(id);
+        return row ? rowToFailure(row) : null;
+      }
+      /** List failures filtered by type. */
+      listByType(failureType) {
+        const rows = this.db.prepare("SELECT * FROM failures WHERE failure_type = ? ORDER BY created_at DESC").all(failureType);
+        return rows.map(rowToFailure);
+      }
+      /** List all failures sharing the same content fingerprint. */
+      listByFingerprint(fingerprint) {
+        const rows = this.db.prepare("SELECT * FROM failures WHERE fingerprint = ? ORDER BY created_at DESC").all(fingerprint);
+        return rows.map(rowToFailure);
+      }
+      /** List all failures that have not yet been marked as resolved. */
+      listUnresolved() {
+        const rows = this.db.prepare("SELECT * FROM failures WHERE resolved = 0 ORDER BY created_at DESC").all();
+        return rows.map(rowToFailure);
+      }
+      /**
+       * Mark a failure as resolved.
+       *
+       * @param id         - The failure record id.
+       * @param resolvedAt - ISO timestamp string of resolution time.
+       */
+      markResolved(id, resolvedAt) {
+        this.db.prepare(`UPDATE failures
+         SET resolved = 1, resolved_at = ?
+         WHERE id = ?`).run(resolvedAt, id);
+      }
+    };
+  }
+});
+
+// packages/memory/dist/validationStore.js
+var init_validationStore = __esm({
+  "packages/memory/dist/validationStore.js"() {
+    "use strict";
+  }
+});
+
+// packages/memory/dist/index.js
+var init_dist6 = __esm({
+  "packages/memory/dist/index.js"() {
+    "use strict";
+    init_db();
+    init_repoProfileStore();
+    init_fileSummaryStore();
+    init_taskMemoryStore();
+    init_patchHistoryStore();
+    init_failureStore();
+    init_validationStore();
+  }
+});
+
 // packages/cli/dist/tui/carousel.js
 function fg(code, text) {
   return isTTY3 ? `\x1B[38;5;${code}m${text}\x1B[0m` : text;
@@ -9502,6 +10253,266 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
   }
 });
 
+// packages/cli/dist/tui/stream-renderer.js
+function fg256(code, text) {
+  return isTTY4 ? `\x1B[38;5;${code}m${text}\x1B[0m` : text;
+}
+function dimText(text) {
+  return isTTY4 ? `\x1B[2m${text}\x1B[0m` : text;
+}
+function dimItalic(text) {
+  return isTTY4 ? `\x1B[2;3m${text}\x1B[0m` : text;
+}
+var isTTY4, PASTEL, StreamRenderer;
+var init_stream_renderer = __esm({
+  "packages/cli/dist/tui/stream-renderer.js"() {
+    "use strict";
+    isTTY4 = process.stdout.isTTY ?? false;
+    PASTEL = {
+      key: 222,
+      // light gold — JSON keys
+      string: 183,
+      // light lavender — "string values"
+      number: 156,
+      // soft green — 42, 3.14
+      boolean: 114,
+      // mint green — true, false
+      null: 109,
+      // grey-blue — null
+      bracket: 75,
+      // soft blue — { } [ ]
+      colon: 245,
+      // neutral grey — : ,
+      keyword: 117,
+      // sky blue — function, return, if, else
+      comment: 243,
+      // dim grey — // comments
+      thinking: 245,
+      // neutral grey for thinking tokens
+      toolArg: 111
+      // dim periwinkle for tool arg tokens
+    };
+    StreamRenderer = class {
+      lineBuffer = "";
+      inThinkBlock = false;
+      inCodeBlock = false;
+      codeLang = "";
+      lineStarted = false;
+      flushTimer = null;
+      enabled = false;
+      tokenCount = 0;
+      startTime = 0;
+      /** Track if we're mid-tool-arg display */
+      inToolArgs = false;
+      /** Called when a new model response starts streaming */
+      onStreamStart() {
+        this.lineBuffer = "";
+        this.inThinkBlock = false;
+        this.inCodeBlock = false;
+        this.codeLang = "";
+        this.lineStarted = false;
+        this.inToolArgs = false;
+        this.enabled = true;
+        this.tokenCount = 0;
+        this.startTime = Date.now();
+        this.cancelFlush();
+      }
+      /**
+       * Feed a streamed token into the renderer.
+       * Tokens are buffered per-line and flushed with syntax highlighting.
+       */
+      write(token, kind) {
+        if (!this.enabled)
+          return;
+        this.tokenCount++;
+        if (kind === "tool_args" && !this.inToolArgs) {
+          this.flushPartial(kind);
+          this.inToolArgs = true;
+        } else if (kind !== "tool_args" && this.inToolArgs) {
+          this.flushPartial(kind);
+          this.inToolArgs = false;
+        }
+        for (const char of token) {
+          this.lineBuffer += char;
+          if (char === "\n") {
+            this.flushLine(kind);
+          }
+        }
+        this.scheduleFlush(kind);
+      }
+      /** Called when streaming ends for this response */
+      onStreamEnd() {
+        if (!this.enabled)
+          return;
+        this.cancelFlush();
+        if (this.lineBuffer.length > 0) {
+          const kind = this.inThinkBlock ? "thinking" : this.inToolArgs ? "tool_args" : "content";
+          this.writeHighlighted(this.lineBuffer, kind);
+          this.lineBuffer = "";
+        }
+        if (this.lineStarted) {
+          process.stdout.write("\n");
+          this.lineStarted = false;
+        }
+        this.enabled = false;
+      }
+      /** Get streaming stats */
+      getStats() {
+        return {
+          tokens: this.tokenCount,
+          durationMs: Date.now() - this.startTime
+        };
+      }
+      // -------------------------------------------------------------------------
+      // Internal rendering
+      // -------------------------------------------------------------------------
+      /**
+       * Flush a complete line (ending with \n) with full syntax highlighting.
+       */
+      flushLine(kind) {
+        const line = this.lineBuffer;
+        this.lineBuffer = "";
+        if (!line || line === "\n") {
+          if (this.lineStarted) {
+            process.stdout.write("\n");
+            this.lineStarted = false;
+          } else {
+            process.stdout.write("\n");
+          }
+          return;
+        }
+        if (line.includes("<think>")) {
+          this.inThinkBlock = true;
+          const after = line.replace(/<think>/g, "");
+          if (after.trim()) {
+            this.writeHighlighted(after, "thinking");
+          }
+          return;
+        }
+        if (line.includes("</think>")) {
+          this.inThinkBlock = false;
+          const after = line.replace(/<\/think>/g, "");
+          if (after.trim()) {
+            this.writeHighlighted(after, "content");
+          }
+          return;
+        }
+        const trimmedLine = line.replace(/\n$/, "");
+        if (trimmedLine.trimStart().startsWith("```")) {
+          if (this.inCodeBlock) {
+            this.writeRaw(dimText("  \u23BF  ") + dimText("```") + "\n");
+            this.inCodeBlock = false;
+            this.codeLang = "";
+            this.lineStarted = false;
+          } else {
+            this.codeLang = trimmedLine.replace(/```/g, "").trim();
+            this.writeRaw(dimText("  \u23BF  ") + dimText("```" + this.codeLang) + "\n");
+            this.inCodeBlock = true;
+            this.lineStarted = false;
+          }
+          return;
+        }
+        const effectiveKind = this.inThinkBlock ? "thinking" : kind;
+        this.writeHighlighted(line, effectiveKind);
+      }
+      /**
+       * Write a highlighted line/fragment to stdout.
+       */
+      writeHighlighted(text, kind) {
+        const raw = text.replace(/\n$/, "");
+        if (!raw)
+          return;
+        const prefix = this.lineStarted ? "" : "  \u23BF  ";
+        let rendered;
+        switch (kind) {
+          case "thinking":
+            rendered = dimItalic(raw);
+            break;
+          case "tool_args":
+            rendered = this.highlightJson(raw, true);
+            break;
+          case "content":
+            if (this.inCodeBlock) {
+              rendered = this.highlightCode(raw);
+            } else if (this.looksLikeJson(raw)) {
+              rendered = this.highlightJson(raw, false);
+            } else {
+              rendered = raw;
+            }
+            break;
+        }
+        const hasNewline = text.endsWith("\n");
+        this.writeRaw(dimText(prefix) + rendered + (hasNewline ? "\n" : ""));
+        this.lineStarted = !hasNewline;
+      }
+      /** Write raw ANSI text to stdout */
+      writeRaw(text) {
+        process.stdout.write(text);
+      }
+      /** Flush partial buffer (non-newline-terminated tokens) */
+      flushPartial(kind) {
+        if (this.lineBuffer.length === 0)
+          return;
+        const effectiveKind = this.inThinkBlock ? "thinking" : kind;
+        this.writeHighlighted(this.lineBuffer, effectiveKind);
+        this.lineBuffer = "";
+      }
+      /** Schedule a timer to flush partial buffer (for streaming smoothness) */
+      scheduleFlush(kind) {
+        this.cancelFlush();
+        this.flushTimer = setTimeout(() => {
+          if (this.lineBuffer.length > 0) {
+            this.flushPartial(kind);
+          }
+        }, 80);
+      }
+      cancelFlush() {
+        if (this.flushTimer) {
+          clearTimeout(this.flushTimer);
+          this.flushTimer = null;
+        }
+      }
+      // -------------------------------------------------------------------------
+      // Syntax highlighting — pastel palette
+      // -------------------------------------------------------------------------
+      /** Check if a string looks like JSON (starts with { [ " or has key: patterns) */
+      looksLikeJson(text) {
+        const trimmed = text.trimStart();
+        return trimmed.startsWith("{") || trimmed.startsWith("[") || trimmed.startsWith("}") || trimmed.startsWith("]") || /^\s*"[^"]+"\s*:/.test(trimmed);
+      }
+      /**
+       * Highlight a JSON line with pastel colors.
+       * @param dim If true, apply dimmer colors (for tool args)
+       */
+      highlightJson(line, dim) {
+        const colorKey = dim ? PASTEL.toolArg : PASTEL.key;
+        const colorStr = dim ? PASTEL.toolArg : PASTEL.string;
+        let result = line;
+        result = result.replace(/"([^"]*)"(\s*:)/g, (_m, key, colon) => fg256(colorKey, `"${key}"`) + fg256(PASTEL.colon, colon));
+        result = result.replace(/(:\s*)"([^"]*)"/g, (_m, prefix, val) => fg256(PASTEL.colon, prefix) + fg256(colorStr, `"${val}"`));
+        result = result.replace(/(:\s*)(\d+\.?\d*)/g, (_m, prefix, num) => fg256(PASTEL.colon, prefix) + fg256(PASTEL.number, num));
+        result = result.replace(/(:\s*)(true|false)/g, (_m, prefix, bool) => fg256(PASTEL.colon, prefix) + fg256(PASTEL.boolean, bool));
+        result = result.replace(/(:\s*)(null)/g, (_m, prefix, n) => fg256(PASTEL.colon, prefix) + fg256(PASTEL.null, n));
+        result = result.replace(/([{}[\]])/g, (_m, b) => fg256(PASTEL.bracket, b));
+        return dim ? dimText(result) : result;
+      }
+      /**
+       * Highlight a code line with basic pastel syntax coloring.
+       */
+      highlightCode(line) {
+        let result = line;
+        result = result.replace(/"([^"]*)"/g, (_m, s) => fg256(PASTEL.string, `"${s}"`));
+        result = result.replace(/'([^']*)'/g, (_m, s) => fg256(PASTEL.string, `'${s}'`));
+        result = result.replace(/\b(\d+\.?\d*)\b/g, (_m, n) => fg256(PASTEL.number, n));
+        result = result.replace(/\b(true|false|null|undefined|None|True|False)\b/g, (_m, kw) => fg256(PASTEL.boolean, kw));
+        result = result.replace(/\b(function|const|let|var|return|if|else|for|while|import|export|from|class|async|await|def|self|try|catch|finally|throw|new|typeof|instanceof)\b/g, (_m, kw) => fg256(PASTEL.keyword, kw));
+        result = result.replace(/(\/\/.*$|#.*$)/gm, (_m, c3) => fg256(PASTEL.comment, c3));
+        return result;
+      }
+    };
+  }
+});
+
 // packages/cli/dist/tui/interactive.js
 import * as readline2 from "node:readline";
 import { cwd } from "node:process";
@@ -9669,8 +10680,8 @@ Use task_status("${taskId}") or task_output("${taskId}") to check progress.`
     }
   };
 }
-function startTask(task, config, repoRoot, voice) {
-  const projectCtx = buildProjectContext(repoRoot);
+function startTask(task, config, repoRoot, voice, stream, taskStores) {
+  const projectCtx = buildProjectContext(repoRoot, taskStores?.contextStores);
   const dynamicContext = formatContextForPrompt(projectCtx);
   const backend = new OllamaAgenticBackend(config.backendUrl.replace(/\/$/, ""), config.model);
   const runner = new AgenticRunner(backend, {
@@ -9680,12 +10691,20 @@ function startTask(task, config, repoRoot, voice) {
     requestTimeoutMs: config.timeoutMs,
     taskTimeoutMs: config.timeoutMs * 4,
     compactionThreshold: 4e4,
-    dynamicContext
+    dynamicContext,
+    streamEnabled: stream?.enabled ?? false
   });
   runner.registerTools(buildTools(repoRoot, config));
+  const filesTouched = /* @__PURE__ */ new Set();
   runner.onEvent((event) => {
     switch (event.type) {
       case "tool_call":
+        if (event.toolArgs?.path && typeof event.toolArgs.path === "string") {
+          const name = event.toolName ?? "";
+          if (name === "file_write" || name === "file_edit" || name === "batch_edit") {
+            filesTouched.add(event.toolArgs.path);
+          }
+        }
         if (voice?.enabled) {
           const desc = describeToolCall(event.toolName ?? "unknown", event.toolArgs ?? {});
           renderVoiceText(desc);
@@ -9704,10 +10723,23 @@ function startTask(task, config, repoRoot, voice) {
         }
         break;
       case "model_response":
-        if (config.verbose && event.content) {
+        if (config.verbose && !stream?.enabled && event.content) {
           renderAssistantText(event.content);
         }
         break;
+      case "stream_start":
+        if (stream?.enabled)
+          stream.renderer.onStreamStart();
+        break;
+      case "stream_token":
+        if (stream?.enabled) {
+          stream.renderer.write(event.content ?? "", event.streamKind ?? "content");
+        }
+        break;
+      case "stream_end":
+        if (stream?.enabled)
+          stream.renderer.onStreamEnd();
+        break;
       case "user_interrupt":
         break;
       case "compaction":
@@ -9747,6 +10779,22 @@ function startTask(task, config, repoRoot, voice) {
       });
     } catch {
     }
+    if (taskStores?.taskMemoryStore) {
+      try {
+        taskStores.taskMemoryStore.insert({
+          sessionId,
+          repoRoot,
+          goal: task.slice(0, 500),
+          constraints: [],
+          filesTouched: Array.from(filesTouched).slice(0, 50),
+          patches: [],
+          outcome: result.completed ? "success" : "partial",
+          qualityScore: null,
+          notes: result.summary.slice(0, 500)
+        });
+      } catch {
+      }
+    }
   });
   return { runner, promise };
 }
@@ -9758,6 +10806,17 @@ async function startInteractive(config, repoPath) {
   }
   initOaDirectory(repoRoot);
   const savedSettings = resolveSettings(repoRoot);
+  let memoryDb = null;
+  let taskMemoryStore = null;
+  let failureStore = null;
+  let contextStores;
+  try {
+    memoryDb = initDb(config.dbPath);
+    taskMemoryStore = new TaskMemoryStore(memoryDb);
+    failureStore = new FailureStore(memoryDb);
+    contextStores = { taskMemoryStore, failureStore };
+  } catch {
+  }
   if (savedSettings.model)
     config = { ...config, model: savedSettings.model };
   if (savedSettings.backendUrl)
@@ -9777,6 +10836,7 @@ async function startInteractive(config, repoPath) {
     config = { ...config, dryRun: savedSettings.dryRun };
   if (savedSettings.dbPath)
     config = { ...config, dbPath: savedSettings.dbPath };
+  let streamEnabled = savedSettings.stream ?? false;
   if (!isResumed) {
     const needsSetup = isFirstRun() || !await isModelAvailable(config);
     if (needsSetup && config.backendType === "ollama") {
@@ -9820,6 +10880,7 @@ async function startInteractive(config, repoPath) {
 `);
   }
   const voiceEngine = new VoiceEngine();
+  const streamRenderer = new StreamRenderer();
   if (savedSettings.voice) {
     voiceEngine.toggle().catch(() => {
     });
@@ -9886,6 +10947,12 @@ async function startInteractive(config, repoPath) {
       if (carousel.isRunning)
         carousel.stop();
       voiceEngine.dispose();
+      if (memoryDb) {
+        try {
+          closeDb(memoryDb);
+        } catch {
+        }
+      }
       rl.close();
     },
     async voiceToggle() {
@@ -9894,6 +10961,10 @@ async function startInteractive(config, repoPath) {
     async voiceSetModel(id) {
       return voiceEngine.setModel(id);
     },
+    streamToggle() {
+      streamEnabled = !streamEnabled;
+      return streamEnabled;
+    },
     saveSettings(settings) {
       try {
         saveProjectSettings(repoRoot, settings);
@@ -9970,12 +11041,39 @@ ${c2.dim("Goodbye!")}
     }
     renderUserMessage(isImage ? `[Image: ${cleanPath}]` : fullInput);
     try {
-      const task = startTask(fullInput, currentConfig, repoRoot, voiceEngine);
+      const task = startTask(fullInput, currentConfig, repoRoot, voiceEngine, {
+        enabled: streamEnabled,
+        renderer: streamRenderer
+      }, {
+        contextStores,
+        taskMemoryStore: taskMemoryStore ?? void 0,
+        failureStore: failureStore ?? void 0
+      });
       activeTask = task;
       showPrompt();
       await task.promise;
     } catch (err) {
-      renderError(err instanceof Error ? err.message : String(err));
+      const errMsg = err instanceof Error ? err.message : String(err);
+      renderError(errMsg);
+      if (failureStore) {
+        try {
+          const { createHash: createHash2 } = await import("node:crypto");
+          failureStore.insert({
+            taskId: "",
+            sessionId: `${Date.now()}`,
+            repoRoot,
+            failureType: "runtime-error",
+            fingerprint: createHash2("sha256").update(errMsg.slice(0, 200)).digest("hex").slice(0, 16),
+            filePath: null,
+            errorMessage: errMsg.slice(0, 500),
+            context: null,
+            resolved: false,
+            resolvedAt: null,
+            notes: `Task: ${fullInput.slice(0, 200)}`
+          });
+        } catch {
+        }
+      }
     } finally {
       activeTask = null;
     }
@@ -10062,10 +11160,12 @@ var init_interactive = __esm({
     init_commands();
     init_setup();
     init_project_context();
+    init_dist6();
     init_oa_directory();
     init_render();
     init_carousel();
     init_voice();
+    init_stream_renderer();
     taskManager = new BackgroundTaskManager();
   }
 });
@@ -10263,7 +11363,7 @@ var init_embeddings = __esm({
 });
 
 // packages/indexer/dist/index.js
-var init_dist6 = __esm({
+var init_dist7 = __esm({
   "packages/indexer/dist/index.js"() {
     "use strict";
     init_codebase_indexer();
@@ -10370,7 +11470,7 @@ async function indexRepoCommand(opts, _config) {
 var init_index_repo = __esm({
   "packages/cli/dist/commands/index-repo.js"() {
     "use strict";
-    init_dist6();
+    init_dist7();
     init_spinner();
     init_output();
   }
@@ -10671,10 +11771,11 @@ var init_config3 = __esm({
       verbose: "Verbose output (true/false)",
       dbPath: "Path to SQLite memory database",
       voice: "Enable TTS voice feedback (true/false)",
-      voiceModel: "TTS voice model: glados, overwatch"
+      voiceModel: "TTS voice model: glados, overwatch",
+      stream: "Enable real-time token streaming with pastel syntax highlighting (true/false)"
     };
     INT_KEYS = /* @__PURE__ */ new Set(["maxRetries", "timeoutMs"]);
-    BOOL_KEYS = /* @__PURE__ */ new Set(["dryRun", "verbose", "voice"]);
+    BOOL_KEYS = /* @__PURE__ */ new Set(["dryRun", "verbose", "voice", "stream"]);
   }
 });