open-agents-ai 0.187.15 → 0.187.16

package/dist/index.js

@@ -13111,6 +13111,10 @@ var init_skill_builder = __esm({
           validate: {
             type: "boolean",
             description: "Whether to run the validation phase (default: true). Validation scores the generated skill and suggests improvements."
+          },
+          session_corrections: {
+            type: "string",
+            description: "Optional: corrections and failed approaches from the current session. Each correction becomes a hard rule in the generated SKILL.md. Format: one correction per line, e.g. 'FAILED: file_write too large \u2014 use file_edit instead'"
           }
         },
         required: ["skill_request"]
@@ -13134,9 +13138,10 @@ var init_skill_builder = __esm({
             durationMs: performance.now() - start2
           };
         }
+        const sessionCorrections = String(args["session_corrections"] ?? "").trim();
         try {
           const seed = await this.analyzeSeed(skillRequest);
-          let skillContent = await this.expandSkill(seed);
+          let skillContent = await this.expandSkill(seed, sessionCorrections);
           let validationInfo = "";
           if (shouldValidate) {
             const validation = await this.validateSkill(skillContent);
@@ -13205,15 +13210,21 @@ Validation: ${validation.pass ? "PASS" : "NEEDS IMPROVEMENT"} (${validation.over
       // -------------------------------------------------------------------------
       // Phase 2: Skill Expansion
       // -------------------------------------------------------------------------
-      async expandSkill(seed) {
+      async expandSkill(seed, sessionCorrections) {
         const prompt = loadBuilderPrompt("skill-expansion.md", {
           seed_json: JSON.stringify(seed, null, 2)
         });
+        const correctionBlock = sessionCorrections ? `
+
+IMPORTANT \u2014 Session Corrections (encode as hard rules in the Rules section):
+These represent things that FAILED or were CORRECTED during the reference session.
+Each MUST appear as a rule in the generated SKILL.md:
+${sessionCorrections}` : "";
         const response = await this.llmCall([
           { role: "system", content: prompt },
           {
             role: "user",
-            content: `Generate the complete SKILL.md for the "${seed.name}" skill.`
+            content: `Generate the complete SKILL.md for the "${seed.name}" skill.${correctionBlock}`
           }
         ]);
         let content = response.trim();
@@ -260098,6 +260109,10 @@ var init_agenticRunner = __esm({
       // WO-E26: prevent double-emit
       _recentEnoents = [];
       // sliding window of last 8 tool calls
+      _microcompactHintEmitted = false;
+      // WO-LL-02: one memory hint per session
+      _hookDenyHintCount = 0;
+      // WO-LL-02: cap hint injection at 3 per session
       // -- Session Checkpointing (Priority 5) --
       _sessionId = `session-${Date.now()}`;
       _workingDirectory = "";
@@ -260326,6 +260341,10 @@ ${ctx3}`,
             content: `Microcompact: cleared ${cleared} old tool result(s), keeping ${keepResults} recent`,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
+          if (!this._microcompactHintEmitted) {
+            this._microcompactHintEmitted = true;
+            this.pendingUserMessages.push(`[SYSTEM] Older tool results have been cleared to save context. If you discovered important patterns or facts, use memory_write to persist them before they are lost from context.`);
+          }
         }
       }
       /** Register a tool for the agent to use */
@@ -260577,6 +260596,8 @@ TASK: ${task}` : task;
         let summary = "";
         let bruteForceCycle = 0;
         this._assistantTextEmitted = false;
+        this._microcompactHintEmitted = false;
+        this._hookDenyHintCount = 0;
         let pendingConstraintWarnings = [];
         let consecutiveTextOnly = 0;
         let loopInterventionCount = 0;
@@ -261094,6 +261115,10 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
                       reason: hookCheck.reason ?? "hook",
                       source: "hook"
                     });
+                    if (this._hookDenyHintCount < 3) {
+                      this._hookDenyHintCount++;
+                      this.pendingUserMessages.push(`[SYSTEM] Tool "${tc.name}" was blocked: ${hookCheck.reason}. If this constraint should persist across sessions, use memory_write to save it (e.g., memory_write(topic="constraints", key="${tc.name}_blocked", value="${(hookCheck.reason ?? "hook").slice(0, 80)}")).`);
+                    }
                   } else {
                     const finalArgs = hookCheck.modifiedArgs ?? tc.arguments;
                     try {
@@ -261189,6 +261214,10 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                   if (this._taskState.failedApproaches.length > 10) {
                     this._taskState.failedApproaches.shift();
                   }
+                  if (this._taskState.failedApproaches.length === 3) {
+                    this.pendingUserMessages.push(`[SYSTEM] You have ${this._taskState.failedApproaches.length} failed approaches this session. Consider using memory_write to save these failure patterns so you avoid them in future sessions:
+` + this._taskState.failedApproaches.map((f2) => `- ${f2}`).join("\n"));
+                  }
                 }
               }
               if (filePath && (tc.name === "file_read" || tc.name === "file_write" || tc.name === "file_edit" || tc.name === "batch_edit" || tc.name === "file_patch")) {
@@ -286218,11 +286247,39 @@ Clone a new voice: /voice clone <wav-file> [name]`);
       } else if (ctx3.isDreaming?.()) {
         renderWarning("Already dreaming. Use /dream stop to wake up first.");
       } else {
-        const mode = arg === "lucid" ? "lucid" : arg === "deep" ? "deep" : "default";
+        const mode = arg === "lucid" ? "lucid" : arg === "deep" ? "deep" : arg === "consolidate" ? "consolidate" : "default";
         ctx3.dreamStart?.(mode);
       }
       return "handled";
     }
+    case "skillify": {
+      const runner = ctx3.getRunner?.();
+      if (!runner) {
+        renderWarning("No active task session. Run a task first, then /skillify.");
+        return "handled";
+      }
+      const taskState = runner._taskState;
+      const corrections = [];
+      if (taskState?.failedApproaches?.length > 0) {
+        for (const f2 of taskState.failedApproaches) {
+          corrections.push(`FAILED: ${f2}`);
+        }
+      }
+      if (taskState?.completedSteps?.length > 0) {
+        for (const s2 of taskState.completedSteps.slice(-5)) {
+          corrections.push(`SUCCEEDED: ${s2}`);
+        }
+      }
+      const skillRequest = arg || taskState?.goal || "workflow from this session";
+      const correctionStr = corrections.length > 0 ? corrections.join("\n") : "";
+      renderInfo(`Extracting skill from session (${corrections.length} corrections/steps)...`);
+      const skillifyPrompt = `Use the skill_build tool to create a skill from this session:
+skill_build(skill_request="${skillRequest}"` + (correctionStr ? `, session_corrections="${correctionStr.replace(/"/g, '\\"')}"` : "") + `)
+
+The session corrections MUST become hard rules in the SKILL.md Rules section.`;
+      ctx3.injectMessage?.(skillifyPrompt);
+      return "handled";
+    }
     case "cohere": {
       await showCohereDashboard(ctx3);
       return "handled";
@@ -293438,6 +293495,9 @@ var init_dream_engine = __esm({
         if (this.state.active) {
           throw new Error("Already dreaming. Use /dream stop first.");
         }
+        if (mode === "consolidate") {
+          return this.runConsolidation(onEvent);
+        }
         this.abortController = new AbortController();
         const totalCycles = mode === "deep" ? 3 : mode === "lucid" ? 2 : 1;
         this.state = {
@@ -294259,6 +294319,99 @@ ${files.map((f2) => `- [\`${f2}\`](./${f2})`).join("\n")}
         } catch {
         }
       }
+      /**
+       * WO-LL-01: Memory Consolidation — runs the consolidation prompt through
+       * AgenticRunner with read/write tools targeting .oa/memory/.
+       *
+       * 4-phase: Orient → Gather → Consolidate → Prune
+       * Hannover reference: services/autoDream/autoDream.ts
+       */
+      async runConsolidation(onEvent) {
+        this.state = {
+          mode: "consolidate",
+          active: true,
+          cycleCount: 1,
+          currentCycle: 1,
+          startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          results: []
+        };
+        renderInfo("Memory consolidation starting \u2014 Phase 1: Orient \u2192 Phase 2: Gather \u2192 Phase 3: Consolidate \u2192 Phase 4: Prune");
+        const memoryDir = join70(this.repoRoot, ".oa", "memory");
+        mkdirSync25(memoryDir, { recursive: true });
+        let prompt;
+        try {
+          prompt = loadPrompt3("tui/dream-consolidate.md", {
+            memoryDir,
+            lookbackEntries: "10"
+          });
+        } catch {
+          prompt = `Consolidate the memory files in ${memoryDir}. List the directory, read files, merge duplicates, delete stale entries, update the index.`;
+        }
+        const backend = new OllamaAgenticBackend(this.config.backendUrl, this.config.model, this.config.apiKey);
+        const modelTier = getModelTier(this.config.model);
+        const runner = new AgenticRunner(backend, {
+          maxTurns: 20,
+          maxTokens: 4096,
+          temperature: 0,
+          requestTimeoutMs: this.config.timeoutMs,
+          taskTimeoutMs: this.config.timeoutMs * 3,
+          compactionThreshold: 24e3,
+          contextWindowSize: 32768,
+          modelTier
+        });
+        const tools = [
+          new FileReadTool(this.repoRoot),
+          new FileWriteTool(this.repoRoot),
+          new FileEditTool(this.repoRoot),
+          new ListDirectoryTool(this.repoRoot),
+          new GrepSearchTool(this.repoRoot),
+          new GlobFindTool(this.repoRoot),
+          new ShellTool(this.repoRoot),
+          new MemoryReadTool(this.repoRoot),
+          new MemoryWriteTool(this.repoRoot),
+          new MemorySearchTool(this.repoRoot)
+        ].map((t2) => ({
+          name: t2.name,
+          description: t2.description,
+          parameters: t2.parameters,
+          execute: t2.execute.bind(t2)
+        }));
+        tools.push({
+          name: "task_complete",
+          description: "Signal consolidation is done. Args: {summary: string}",
+          parameters: { type: "object", properties: { summary: { type: "string" } }, required: ["summary"] },
+          execute: async (args) => ({ success: true, output: String(args["summary"] ?? "done") })
+        });
+        for (const t2 of tools)
+          runner.registerTool(t2);
+        if (onEvent)
+          runner.onEvent(onEvent);
+        const startMs = Date.now();
+        try {
+          const result = await runner.run(prompt);
+          const durationMs = Date.now() - startMs;
+          this.state.results.push({
+            cycle: 1,
+            stage: "consolidation",
+            ideas: [],
+            proposals: [],
+            filesGenerated: [],
+            durationMs
+          });
+          try {
+            writeFileSync25(join70(memoryDir, ".last-consolidation"), JSON.stringify({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), summary: result.summary?.slice(0, 500) }) + "\n");
+          } catch {
+          }
+          renderInfo(`Consolidation complete: ${result.turns} turns, ${result.toolCalls} tool calls, ${(durationMs / 1e3).toFixed(1)}s`);
+          if (result.summary)
+            renderInfo(`Summary: ${result.summary.slice(0, 200)}`);
+        } catch (err) {
+          renderWarning(`Consolidation failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        this.state.active = false;
+        this.saveDreamState();
+        return this.state;
+      }
       /** Save dream state for resume/inspection */
       saveDreamState() {
         try {

package/package.json

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

package/prompts/tui/dream-consolidate.md

@@ -0,0 +1,48 @@
+# Memory Consolidation
+
+You are performing a memory consolidation pass — a reflective sweep over your memory files. Synthesize what you've learned recently into durable, well-organized memories so future sessions orient quickly.
+
+Memory directory: `{{memoryDir}}`
+
+---
+
+## Phase 1: Orient
+
+- Use list_directory to see what exists in the memory directory
+- Read the memory index file (if it exists) to understand current organization
+- Skim 2-3 existing memory files to understand the current structure and avoid duplicates
+
+## Phase 2: Gather Recent Signal
+
+Look for information worth persisting or updating. Focus on:
+
+1. **Memory files with stale data** — facts that contradict what you see in the codebase now
+2. **Duplicate memories** — two files tracking the same topic (merge them)
+3. **Relative dates** — convert "yesterday", "last week" to absolute dates
+4. **Low-confidence entries** — memories that were speculative and can now be verified or removed
+
+If session diary exists at `.oa/context/session-diary.md`, read the last {{lookbackEntries}} entries for recent session context.
+
+## Phase 3: Consolidate
+
+For each thing worth updating:
+- **MERGE** near-duplicate files into one (keep the better one, delete the other)
+- **UPDATE** facts that have drifted from reality
+- **CONVERT** relative dates to absolute (e.g., "yesterday" → the actual date)
+- **DELETE** memories that are clearly wrong or superseded
+- **PROMOTE** speculative entries that have been validated multiple times
+
+Use file_edit for updates, file_write for new consolidated files, and shell to remove obsolete files.
+
+## Phase 4: Prune and Index
+
+If a memory index file exists:
+- Keep it under 200 lines
+- Each entry: one line, under 150 chars
+- Remove pointers to deleted/merged memories
+- Add pointers to new or updated memories
+- Resolve contradictions between index and actual files
+
+---
+
+When done, call task_complete with a summary of what you consolidated, updated, merged, or pruned. If nothing changed (memories are already clean), say so.