open-agents-ai 0.11.4 → 0.11.6

package/dist/index.js

@@ -6831,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++;
@@ -6871,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 (commandResults.length > 0) {
+          parts.push("### Commands Executed");
+          for (const { cmd, outcome } of commandResults.slice(0, 8)) {
+            parts.push(`- \`${cmd}\` \u2192 ${outcome}`);
+          }
+          parts.push("");
         }
-        if (commandsRun.length > 0) {
-          parts.push(`Commands run: ${commandsRun.slice(0, 8).join("; ")}`);
+        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");
       }
@@ -8815,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) {
@@ -8856,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");
 }
@@ -8866,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;
@@ -9330,15 +9913,17 @@ var init_voice = __esm({
       }
       /**
        * Speak text asynchronously (non-blocking).
-       * Queues if already speaking; drops if queue gets too deep.
+       * Long text is chunked on sentence/line boundaries for reliable TTS.
+       * Chunks are queued FIFO and played back-to-back without cutoff.
        */
       speak(text) {
         if (!this.enabled || !this.ready)
           return;
-        if (this.speakQueue.length >= 3) {
+        const chunks = this.chunkText(text);
+        if (this.speakQueue.length >= 30) {
           this.speakQueue.length = 0;
         }
-        this.speakQueue.push(text);
+        this.speakQueue.push(...chunks);
         if (!this.speaking) {
           this.drainQueue().catch(() => {
           });
@@ -9352,13 +9937,47 @@ var init_voice = __esm({
         this.config = null;
       }
       // -------------------------------------------------------------------------
+      // Text chunking for long TTS input
+      // -------------------------------------------------------------------------
+      /**
+       * Split long text into sentence-sized chunks suitable for ONNX TTS.
+       * Splits on: newlines (list items, paragraphs), then sentence-ending
+       * punctuation (.!?). Short text (<= 200 chars) passes through unchanged.
+       */
+      chunkText(text) {
+        if (text.length <= 200)
+          return [text];
+        const chunks = [];
+        const lines = text.split(/\n+/);
+        for (const line of lines) {
+          const trimmed = line.replace(/^[\s\-*•]+/, "").trim();
+          if (!trimmed)
+            continue;
+          if (trimmed.length <= 200) {
+            chunks.push(trimmed);
+          } else {
+            const sentences = trimmed.split(/(?<=[.!?])\s+/);
+            for (const sentence of sentences) {
+              const s = sentence.trim();
+              if (s)
+                chunks.push(s);
+            }
+          }
+        }
+        return chunks.length > 0 ? chunks : [text.slice(0, 200)];
+      }
+      // -------------------------------------------------------------------------
       // Queue drain
       // -------------------------------------------------------------------------
+      /**
+       * Drain the speak queue FIFO — each item is synthesized and played to
+       * completion before the next starts.  Items play back-to-back without
+       * cutting off previous audio.
+       */
       async drainQueue() {
         this.speaking = true;
         while (this.speakQueue.length > 0) {
-          const text = this.speakQueue.pop();
-          this.speakQueue.length = 0;
+          const text = this.speakQueue.shift();
           try {
             await this.synthesizeAndPlay(text);
           } catch {
@@ -9478,7 +10097,6 @@ var init_voice = __esm({
       // Audio playback (system default speakers)
       // -------------------------------------------------------------------------
       async playWav(path) {
-        this.killPlayback();
         const cmd = this.getPlayCommand(path);
         if (!cmd)
           return;
@@ -9499,7 +10117,13 @@ var init_voice = __esm({
             resolve14();
           });
           setTimeout(() => {
-            this.killPlayback();
+            if (this.currentPlayback === child) {
+              try {
+                child.kill("SIGTERM");
+              } catch {
+              }
+              this.currentPlayback = null;
+            }
             resolve14();
           }, 15e3);
         });
@@ -10097,8 +10721,8 @@ Use task_status("${taskId}") or task_output("${taskId}") to check progress.`
     }
   };
 }
-function startTask(task, config, repoRoot, voice, stream) {
-  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, {
@@ -10112,9 +10736,16 @@ function startTask(task, config, repoRoot, voice, stream) {
     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);
@@ -10189,6 +10820,22 @@ function startTask(task, config, repoRoot, voice, stream) {
       });
     } 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 };
 }
@@ -10200,6 +10847,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)
@@ -10330,6 +10988,12 @@ async function startInteractive(config, repoPath) {
       if (carousel.isRunning)
         carousel.stop();
       voiceEngine.dispose();
+      if (memoryDb) {
+        try {
+          closeDb(memoryDb);
+        } catch {
+        }
+      }
       rl.close();
     },
     async voiceToggle() {
@@ -10421,12 +11085,36 @@ ${c2.dim("Goodbye!")}
       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;
     }
@@ -10513,6 +11201,7 @@ var init_interactive = __esm({
     init_commands();
     init_setup();
     init_project_context();
+    init_dist6();
     init_oa_directory();
     init_render();
     init_carousel();
@@ -10715,7 +11404,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();
@@ -10822,7 +11511,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();
   }

package/package.json

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