open-agents-ai 0.31.2 → 0.31.4

package/dist/index.js

@@ -10990,6 +10990,7 @@ Rules:
       _pauseResolve = null;
       _sudoPassword = null;
       _sudoResolve = null;
+      _pendingCompaction = null;
       constructor(backend, options) {
         this.backend = backend;
         this.options = {
@@ -11012,6 +11013,39 @@ Rules:
       setContextWindowSize(size) {
         this.options.contextWindowSize = size;
       }
+      // -------------------------------------------------------------------------
+      // Context-aware limits — all dynamic values derived from contextWindowSize
+      // and modelTier. Call this instead of using hardcoded magic numbers.
+      // -------------------------------------------------------------------------
+      /**
+       * Compute all context-dependent limits from the current contextWindowSize
+       * and modelTier. Returns sensible defaults when contextWindowSize is 0.
+       */
+      contextLimits() {
+        const ctx = this.options.contextWindowSize;
+        const tier = this.options.modelTier ?? "large";
+        const compactionThreshold = ctx > 0 ? Math.min(this.options.compactionThreshold, Math.floor(ctx * 0.75)) : this.options.compactionThreshold;
+        const keepRecentDivisor = tier === "small" ? 2e3 : tier === "medium" ? 3e3 : 4e3;
+        const keepRecent = ctx > 0 ? Math.max(4, Math.min(12, Math.floor(ctx / keepRecentDivisor))) : 12;
+        const maxOutputTokens = ctx > 0 ? Math.min(this.options.maxTokens, Math.max(2048, Math.floor(ctx * 0.25))) : this.options.maxTokens;
+        const toolOutputMaxChars = ctx > 0 ? Math.max(2e3, Math.min(8e3, Math.floor(ctx * 0.5))) : 8e3;
+        const foldLineThreshold = tier === "small" ? 30 : tier === "medium" ? 35 : 40;
+        const foldHeadLines = tier === "small" ? 12 : tier === "medium" ? 16 : 20;
+        const foldTailLines = tier === "small" ? 5 : tier === "medium" ? 8 : 10;
+        const maxSummaryChars = ctx > 0 ? Math.max(2e3, Math.min(8e3, Math.floor(ctx * 0.2))) : 4e3;
+        const repetitionWindow = tier === "small" ? 6 : tier === "medium" ? 8 : 10;
+        return {
+          compactionThreshold,
+          keepRecent,
+          maxOutputTokens,
+          toolOutputMaxChars,
+          foldLineThreshold,
+          foldHeadLines,
+          foldTailLines,
+          maxSummaryChars,
+          repetitionWindow
+        };
+      }
       /** Register a tool for the agent to use */
       registerTool(tool) {
         this.tools.set(tool.name, tool);
@@ -11066,6 +11100,23 @@ Rules:
       get isPaused() {
         return this._paused;
       }
+      /**
+       * Request manual context compaction at the next turn boundary.
+       * The strategy controls how aggressively context is compressed:
+       * - "default"    — standard progressive summarization
+       * - "aggressive" — maximum compression, keep only decisions + errors
+       * - "decisions"  — extract action→outcome pairs, discard exploration
+       * - "errors"     — preserve error context, compress successes
+       * - "summary"    — high-level paragraph, minimal detail
+       */
+      requestCompaction(strategy = "default") {
+        this._pendingCompaction = strategy;
+        this.emit({
+          type: "compaction",
+          content: `Manual compaction requested (strategy: ${strategy})`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
       /**
        * If paused, block until resume() or abort() is called.
        * Returns true if the loop should continue, false if aborted while paused.
@@ -11093,7 +11144,8 @@ Rules:
       detectRepetition(recentToolCalls) {
         if (recentToolCalls.length < 4)
           return 0;
-        const window = recentToolCalls.slice(-8);
+        const { repetitionWindow } = this.contextLimits();
+        const window = recentToolCalls.slice(-repetitionWindow);
         const uniqueKeys = new Set(window.map((tc) => `${tc.name}:${tc.argsKey}`));
         const ratio = 1 - uniqueKeys.size / window.length;
         return ratio;
@@ -11212,9 +11264,15 @@ Integrate this guidance into your current approach. Continue working on the task
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             });
           }
-          const compacted = this.compactMessages(messages);
-          const ctxWindow = this.options.contextWindowSize;
-          const effectiveMaxTokens = ctxWindow > 0 ? Math.min(this.options.maxTokens, Math.max(2048, Math.floor(ctxWindow * 0.25))) : this.options.maxTokens;
+          let compacted;
+          if (this._pendingCompaction) {
+            const strategy = this._pendingCompaction;
+            this._pendingCompaction = null;
+            compacted = this.compactMessages(messages, strategy, true);
+          } else {
+            compacted = this.compactMessages(messages);
+          }
+          const { maxOutputTokens: effectiveMaxTokens } = this.contextLimits();
           const chatRequest = {
             messages: compacted,
             tools: toolDefs,
@@ -11313,8 +11371,7 @@ Integrate this guidance into your current approach. Continue working on the task
                   }
                 }
               }
-              const ctxW = this.options.contextWindowSize;
-              const maxLen = ctxW > 0 ? Math.max(2e3, Math.min(8e3, Math.floor(ctxW * 0.5))) : 8e3;
+              const { toolOutputMaxChars: maxLen } = this.contextLimits();
               const output = result.success ? result.output.length > maxLen ? this.foldOutput(result.output, maxLen) : result.output : `Error: ${result.error || "unknown error"}
 ${result.output.length > maxLen ? this.foldOutput(result.output, maxLen) : result.output}`;
               this.emit({
@@ -11467,7 +11524,14 @@ Integrate this guidance into your current approach. Continue working on the task
               }
               this.emit({ type: "user_interrupt", content: userMsg.replace(/\[IMAGE_BASE64:[^\]]+\]/, "[image]").slice(0, 200), turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
             }
-            const compactedMsgs = this.compactMessages(messages);
+            let compactedMsgs;
+            if (this._pendingCompaction) {
+              const strategy = this._pendingCompaction;
+              this._pendingCompaction = null;
+              compactedMsgs = this.compactMessages(messages, strategy, true);
+            } else {
+              compactedMsgs = this.compactMessages(messages);
+            }
             const chatRequest = { messages: compactedMsgs, tools: toolDefs, temperature: this.options.temperature, maxTokens: this.options.maxTokens, timeoutMs: this.options.requestTimeoutMs };
             let response;
             try {
@@ -11527,8 +11591,8 @@ Integrate this guidance into your current approach. Continue working on the task
                     }
                   }
                 }
-                const maxLen = 8e3;
-                const output = result.success ? result.output.length > maxLen ? result.output.slice(0, maxLen) + `
+                const { toolOutputMaxChars: maxLen2 } = this.contextLimits();
+                const output = result.success ? result.output.length > maxLen2 ? result.output.slice(0, maxLen2) + `
 ...(truncated)` : result.output : `Error: ${result.error || "unknown error"}
 ${result.output}`;
                 this.emit({ type: "tool_result", toolName: tc.name, content: output.slice(0, 200), success: result.success, turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
@@ -11629,11 +11693,12 @@ ${marker}` : marker);
       // -------------------------------------------------------------------------
       foldOutput(output, maxChars) {
         const lines = output.split("\n");
-        if (lines.length <= 40) {
+        const { foldLineThreshold, foldHeadLines, foldTailLines } = this.contextLimits();
+        if (lines.length <= foldLineThreshold) {
           return output.slice(0, maxChars) + "\n...(truncated)";
         }
-        const headLines = 20;
-        const tailLines = 10;
+        const headLines = foldHeadLines;
+        const tailLines = foldTailLines;
         const head = lines.slice(0, headLines).join("\n");
         const tail = lines.slice(-tailLines).join("\n");
         const omitted = lines.length - headLines - tailLines;
@@ -11650,7 +11715,7 @@ ${tail}`;
       // -------------------------------------------------------------------------
       // Context compaction
       // -------------------------------------------------------------------------
-      compactMessages(messages) {
+      compactMessages(messages, strategy = "default", force = false) {
         if (messages.length < 3)
           return messages;
         const totalChars = messages.reduce((sum, m) => {
@@ -11662,13 +11727,16 @@ ${tail}`;
           return sum;
         }, 0);
         const estimatedTokens = totalChars / 4;
-        const ctxWinThreshold = this.options.contextWindowSize > 0 ? Math.floor(this.options.contextWindowSize * 0.75) : Infinity;
-        const effectiveThreshold = Math.min(this.options.compactionThreshold, ctxWinThreshold);
-        if (estimatedTokens < effectiveThreshold) {
+        const limits = this.contextLimits();
+        if (!force && estimatedTokens < limits.compactionThreshold) {
+          return messages;
+        }
+        if (force && messages.length < 5)
           return messages;
+        let keepRecent = limits.keepRecent;
+        if (strategy === "aggressive" || strategy === "summary") {
+          keepRecent = Math.max(2, Math.floor(keepRecent / 2));
         }
-        const ctxWin = this.options.contextWindowSize;
-        const keepRecent = ctxWin > 0 ? Math.max(4, Math.min(12, Math.floor(ctxWin / 4e3))) : 12;
         const head = messages.slice(0, 2);
         if (messages.length <= 2 + keepRecent)
           return messages;
@@ -11697,16 +11765,35 @@ ${tail}`;
             nonCompactionMiddle.push(msg);
           }
         }
-        const newSummary = this.summarizeCompactedMessages(nonCompactionMiddle);
+        const maskedMiddle = this.maskOldObservations(nonCompactionMiddle);
+        let newSummary;
+        switch (strategy) {
+          case "aggressive":
+            newSummary = this.summarizeAggressive(maskedMiddle);
+            break;
+          case "decisions":
+            newSummary = this.summarizeDecisions(maskedMiddle);
+            break;
+          case "errors":
+            newSummary = this.summarizeErrors(maskedMiddle);
+            break;
+          case "summary":
+            newSummary = this.summarizeHighLevel(maskedMiddle);
+            break;
+          default:
+            newSummary = this.summarizeCompactedMessages(maskedMiddle);
+        }
         const combinedSummary = previousSummary ? this.progressiveSummarize(previousSummary, newSummary) : newSummary;
+        const strategyLabel = strategy !== "default" ? ` (${strategy})` : "";
+        const forceLabel = force ? " [manual]" : "";
         this.emit({
           type: "compaction",
-          content: `Compacted ${middle.length} messages${previousSummary ? " (progressive)" : ""}`,
+          content: `Compacted ${middle.length} messages${strategyLabel}${forceLabel}${previousSummary ? " (progressive)" : ""}`,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
         const compactionMsg = {
           role: "system",
-          content: `[Context compacted \u2014 summary of earlier work]
+          content: `[Context compacted${strategyLabel} \u2014 summary of earlier work]
 
 ${combinedSummary}
 
@@ -11722,13 +11809,13 @@ ${combinedSummary}
        * When the combined text exceeds the budget, condense the older summary.
        */
       progressiveSummarize(olderSummary, newerSummary) {
-        const MAX_SUMMARY_CHARS = 4e3;
+        const { maxSummaryChars } = this.contextLimits();
         const combined = `${olderSummary}
 
 ---
 
 ${newerSummary}`;
-        if (combined.length <= MAX_SUMMARY_CHARS) {
+        if (combined.length <= maxSummaryChars) {
           return combined;
         }
         const condensed = this.condenseSummary(olderSummary);
@@ -11737,8 +11824,8 @@ ${newerSummary}`;
 ---
 
 ${newerSummary}`;
-        if (result.length > MAX_SUMMARY_CHARS) {
-          const budget = MAX_SUMMARY_CHARS - newerSummary.length - 60;
+        if (result.length > maxSummaryChars) {
+          const budget = maxSummaryChars - newerSummary.length - 60;
           return budget > 200 ? `[Earlier work, condensed]
 ${olderSummary.slice(0, budget)}...
 
@@ -11772,6 +11859,56 @@ ${newerSummary}` : newerSummary;
         }
         return condensed.join("\n");
       }
+      /**
+       * Observation masking pre-pass: replace verbose tool outputs with compact
+       * placeholders. Errors and short outputs (<500 chars) are kept verbatim.
+       * Inspired by OpenHands' ObservationMaskingCondenser — zero LLM cost.
+       */
+      maskOldObservations(messages) {
+        const toolCallNames = /* @__PURE__ */ new Map();
+        for (const msg of messages) {
+          if (msg.tool_calls) {
+            for (const tc of msg.tool_calls) {
+              toolCallNames.set(tc.id, tc.function.name);
+            }
+          }
+        }
+        return messages.map((msg) => {
+          if (msg.role !== "tool" || typeof msg.content !== "string")
+            return msg;
+          const content = msg.content;
+          if (content.startsWith("Error:") || /^(FAIL|ERR!|TypeError|SyntaxError)/i.test(content))
+            return msg;
+          if (content.length < 500)
+            return msg;
+          const toolName = msg.tool_call_id ? toolCallNames.get(msg.tool_call_id) : void 0;
+          const lines = content.split("\n").length;
+          switch (toolName) {
+            case "file_read":
+              return { ...msg, content: `[file content: ${lines} lines, ${content.length} chars \u2014 omitted for compaction]` };
+            case "grep_search":
+              return { ...msg, content: `[grep results: ${lines} matches, ${content.length} chars \u2014 omitted for compaction]` };
+            case "find_files":
+              return { ...msg, content: `[find results: ${lines} files, omitted for compaction]` };
+            case "list_directory":
+              return { ...msg, content: `[directory listing: ${lines} entries, omitted for compaction]` };
+            case "web_fetch":
+              return { ...msg, content: `[web page content: ${content.length} chars \u2014 omitted for compaction]` };
+            case "web_search":
+              return { ...msg, content: `[search results: ${lines} results \u2014 omitted for compaction]` };
+            case "shell":
+            case "background_run":
+              if (/PASS|FAIL|error|warning/i.test(content))
+                return msg;
+              return { ...msg, content: `[command output: ${lines} lines, ${content.length} chars \u2014 omitted for compaction]` };
+            default:
+              if (content.length > 2e3) {
+                return { ...msg, content: `[${toolName ?? "tool"} output: ${content.length} chars \u2014 omitted for compaction]` };
+              }
+              return msg;
+          }
+        });
+      }
       /**
        * Extract a rich structured summary from compacted messages, preserving:
        * - Assistant analysis/reasoning text
@@ -11939,6 +12076,253 @@ ${newerSummary}` : newerSummary;
         return parts.join("\n");
       }
       // -------------------------------------------------------------------------
+      // Strategy-specific summarizers for manual /compact command
+      // -------------------------------------------------------------------------
+      /**
+       * Aggressive compaction: extract only key decisions and errors.
+       * Discards exploration, file reads, and search results entirely.
+       * Keeps: what files were changed, what errors occurred, what approach was chosen.
+       */
+      summarizeAggressive(messages) {
+        const decisions = [];
+        const errors = [];
+        const filesChanged = /* @__PURE__ */ new Map();
+        let toolCallCount = 0;
+        const toolCallMap = /* @__PURE__ */ new Map();
+        for (const msg of messages) {
+          if (msg.tool_calls) {
+            for (const tc of msg.tool_calls) {
+              toolCallCount++;
+              const args = (() => {
+                try {
+                  return JSON.parse(tc.function.arguments);
+                } catch {
+                  return {};
+                }
+              })();
+              toolCallMap.set(tc.id, { name: tc.function.name, args });
+              const name = tc.function.name;
+              if (name === "file_edit" || name === "file_write" || name === "batch_edit") {
+                const path = String(args.path || "");
+                if (path)
+                  filesChanged.set(path, name === "file_write" ? "created/rewritten" : "edited");
+              }
+            }
+          }
+          if (msg.role === "assistant" && typeof msg.content === "string" && msg.content.trim().length > 30) {
+            const text = msg.content.trim();
+            const decisionPatterns = /(?:I (?:will|need to|should|decided|chose|'ll)|Let me|The (?:fix|solution|approach|issue))[^.!?\n]{10,120}[.!?]/gi;
+            const matches = text.match(decisionPatterns);
+            if (matches) {
+              for (const m of matches.slice(0, 2))
+                decisions.push(m.trim());
+            }
+          }
+          if (msg.role === "tool" && typeof msg.content === "string") {
+            const tc = msg.tool_call_id ? toolCallMap.get(msg.tool_call_id) : void 0;
+            if (msg.content.startsWith("Error:") || /FAIL|ERR!/i.test(msg.content)) {
+              const ctx = tc ? `${tc.name}` : "tool";
+              errors.push(`${ctx}: ${msg.content.split("\n")[0]?.slice(0, 150)}`);
+            }
+          }
+        }
+        const parts = [];
+        parts.push(`## Aggressive Compact (${toolCallCount} tool calls compressed)
+`);
+        if (filesChanged.size > 0) {
+          parts.push("### Files Modified");
+          for (const [path, action] of filesChanged)
+            parts.push(`- \`${path}\` (${action})`);
+          parts.push("");
+        }
+        if (decisions.length > 0) {
+          parts.push("### Key Decisions");
+          for (const d of decisions.slice(0, 5))
+            parts.push(`- ${d}`);
+          parts.push("");
+        }
+        if (errors.length > 0) {
+          parts.push("### Errors (avoid repeating)");
+          for (const e of errors.slice(0, 5))
+            parts.push(`- ${e}`);
+        }
+        return parts.join("\n");
+      }
+      /**
+       * Decisions compaction: extract action→outcome pairs only.
+       * Each tool call becomes a single "did X → got Y" line.
+       */
+      summarizeDecisions(messages) {
+        const actionOutcomes = [];
+        const toolCallMap = /* @__PURE__ */ new Map();
+        for (const msg of messages) {
+          if (msg.tool_calls) {
+            for (const tc of msg.tool_calls) {
+              const args = (() => {
+                try {
+                  return JSON.parse(tc.function.arguments);
+                } catch {
+                  return {};
+                }
+              })();
+              toolCallMap.set(tc.id, { name: tc.function.name, args });
+            }
+          }
+          if (msg.role === "tool" && typeof msg.content === "string" && msg.tool_call_id) {
+            const tc = toolCallMap.get(msg.tool_call_id);
+            if (!tc)
+              continue;
+            const content = msg.content;
+            let action;
+            let outcome;
+            switch (tc.name) {
+              case "file_read":
+                action = `Read \`${tc.args.path}\``;
+                outcome = `${content.split("\n").length} lines`;
+                break;
+              case "file_write":
+                action = `Wrote \`${tc.args.path}\``;
+                outcome = content.startsWith("Error:") ? content.slice(0, 100) : "success";
+                break;
+              case "file_edit":
+                action = `Edited \`${tc.args.path}\``;
+                outcome = content.startsWith("Error:") ? content.slice(0, 100) : "applied";
+                break;
+              case "shell":
+              case "background_run":
+                action = `Ran \`${String(tc.args.command || "").slice(0, 60)}\``;
+                outcome = content.startsWith("Error:") ? "failed" : /PASS|success/i.test(content) ? "passed" : "completed";
+                break;
+              case "grep_search":
+                action = `Searched "${tc.args.pattern}"`;
+                outcome = `${(content.match(/\n/g) || []).length} matches`;
+                break;
+              default:
+                action = tc.name;
+                outcome = content.startsWith("Error:") ? "failed" : "ok";
+            }
+            actionOutcomes.push(`${action} \u2192 ${outcome}`);
+          }
+        }
+        const parts = [];
+        parts.push(`## Decision Log (${actionOutcomes.length} actions)
+`);
+        for (const ao of actionOutcomes)
+          parts.push(`- ${ao}`);
+        return parts.join("\n");
+      }
+      /**
+       * Error-preserving compaction: keep full error context for failure avoidance,
+       * aggressively compress successful operations to single lines.
+       */
+      summarizeErrors(messages) {
+        const errors = [];
+        const successes = [];
+        const toolCallMap = /* @__PURE__ */ new Map();
+        for (const msg of messages) {
+          if (msg.tool_calls) {
+            for (const tc of msg.tool_calls) {
+              const args = (() => {
+                try {
+                  return JSON.parse(tc.function.arguments);
+                } catch {
+                  return {};
+                }
+              })();
+              toolCallMap.set(tc.id, { name: tc.function.name, args });
+            }
+          }
+          if (msg.role === "tool" && typeof msg.content === "string" && msg.tool_call_id) {
+            const tc = toolCallMap.get(msg.tool_call_id);
+            if (!tc)
+              continue;
+            const content = msg.content;
+            const isError = content.startsWith("Error:") || /FAIL|ERR!|error:|TypeError|SyntaxError/i.test(content);
+            const action = tc.name === "shell" ? `\`${String(tc.args.command || "").slice(0, 80)}\`` : `${tc.name}(${String(tc.args.path || tc.args.pattern || "").slice(0, 60)})`;
+            if (isError) {
+              errors.push({
+                context: action,
+                error: content.slice(0, 300)
+              });
+            } else {
+              successes.push(`${action} \u2192 ok`);
+            }
+          }
+        }
+        const parts = [];
+        parts.push(`## Error-Focused Compact
+`);
+        if (errors.length > 0) {
+          parts.push("### Errors & Failures (preserve to avoid repeating)");
+          for (const { context, error } of errors.slice(0, 8)) {
+            parts.push(`- **${context}**:`);
+            parts.push(`  \`\`\`
+  ${error}
+  \`\`\``);
+          }
+          parts.push("");
+        }
+        if (successes.length > 0) {
+          parts.push(`### Successful Operations (${successes.length} total)`);
+          for (const s of successes.slice(0, 10))
+            parts.push(`- ${s}`);
+          if (successes.length > 10)
+            parts.push(`- ... and ${successes.length - 10} more`);
+        }
+        return parts.join("\n");
+      }
+      /**
+       * High-level summary: paragraph-form description of what was accomplished.
+       * Minimal detail, maximum compression — good for very long sessions.
+       */
+      summarizeHighLevel(messages) {
+        const filesModified = /* @__PURE__ */ new Set();
+        const filesRead = /* @__PURE__ */ new Set();
+        let shellCount = 0;
+        let toolCallCount = 0;
+        let lastAssistantText = "";
+        for (const msg of messages) {
+          if (msg.tool_calls) {
+            for (const tc of msg.tool_calls) {
+              toolCallCount++;
+              const args = (() => {
+                try {
+                  return JSON.parse(tc.function.arguments);
+                } catch {
+                  return {};
+                }
+              })();
+              const name = tc.function.name;
+              if (name === "file_edit" || name === "file_write" || name === "batch_edit") {
+                filesModified.add(String(args.path || ""));
+              } else if (name === "file_read") {
+                filesRead.add(String(args.path || ""));
+              } else if (name === "shell" || name === "background_run") {
+                shellCount++;
+              }
+            }
+          }
+          if (msg.role === "assistant" && typeof msg.content === "string" && msg.content.trim().length > 20) {
+            lastAssistantText = msg.content.trim();
+          }
+        }
+        const modList = Array.from(filesModified).filter(Boolean);
+        const readList = Array.from(filesRead).filter(Boolean);
+        const parts = [];
+        parts.push(`## Session Summary (${toolCallCount} tool calls)
+`);
+        parts.push(`Modified ${modList.length} file(s), read ${readList.length} file(s), ran ${shellCount} command(s).
+`);
+        if (modList.length > 0) {
+          parts.push(`Files changed: ${modList.slice(0, 8).map((f) => `\`${f}\``).join(", ")}${modList.length > 8 ? ` +${modList.length - 8} more` : ""}`);
+        }
+        if (lastAssistantText) {
+          parts.push(`
+Last analysis: ${lastAssistantText.slice(0, 300)}${lastAssistantText.length > 300 ? "..." : ""}`);
+        }
+        return parts.join("\n");
+      }
+      // -------------------------------------------------------------------------
       // Tool definition builder
       // -------------------------------------------------------------------------
       buildToolDefinitions() {
@@ -14057,6 +14441,8 @@ function renderSlashHelp() {
     ["/stats", "Show session dashboard (metrics, tool usage, task history)"],
     ["/stop", "Stop current task and save progress (alias: /pause)"],
     ["/resume", "Resume a previously stopped task"],
+    ["/compact", "Force context compaction now (default strategy)"],
+    ["/compact <strategy>", "Compact with strategy: aggressive, decisions, errors, summary"],
     ["/bruteforce", "Toggle brute-force mode (auto re-engage on turn limit)"],
     ["/tools", "List agent-created custom tools"],
     ["/skills", "List available AIWG skills"],
@@ -14426,6 +14812,7 @@ var init_render = __esm({
       "/verbose",
       "/dream",
       "/bruteforce",
+      "/compact",
       "/tools",
       "/skills",
       "/clear",
@@ -15599,11 +15986,12 @@ async function doSetup(config, rl) {
     const createModelfile = await ask(rl, `  Create optimized model "${c2.bold(customName)}" with ${ctx.label} context? (Y/n) `);
     if (createModelfile.toLowerCase() !== "n") {
       try {
+        const numPredict = Math.min(16384, Math.max(2048, Math.floor(ctx.numCtx * 0.25)));
         const modelfileContent = [
           `FROM ${selectedVariant.tag}`,
           `PARAMETER num_ctx ${ctx.numCtx}`,
           `PARAMETER temperature 0`,
-          `PARAMETER num_predict 16384`,
+          `PARAMETER num_predict ${numPredict}`,
           `PARAMETER stop "<|endoftext|>"`
         ].join("\n");
         const modelDir2 = join24(homedir9(), ".open-agents", "models");
@@ -16005,11 +16393,12 @@ function createExpandedVariant(baseModel, specs, sizeGB) {
   const customName = expandedModelName(baseModel);
   const ctx = calculateContextWindow(specs, sizeGB);
   try {
+    const numPredict = Math.min(16384, Math.max(2048, Math.floor(ctx.numCtx * 0.25)));
     const modelfileContent = [
       `FROM ${baseModel}`,
       `PARAMETER num_ctx ${ctx.numCtx}`,
       `PARAMETER temperature 0`,
-      `PARAMETER num_predict 16384`,
+      `PARAMETER num_predict ${numPredict}`,
       `PARAMETER stop "<|endoftext|>"`
     ].join("\n");
     const modelDir2 = join24(homedir9(), ".open-agents", "models");
@@ -16545,6 +16934,26 @@ async function handleSlashCommand(input, ctx) {
       }
       return "handled";
     }
+    case "compact":
+    case "gc": {
+      if (!ctx.hasActiveTask?.()) {
+        renderWarning("No active task to compact. Context compaction requires a running task.");
+        return "handled";
+      }
+      const validStrategies = ["default", "aggressive", "decisions", "errors", "summary"];
+      const strategy = arg && validStrategies.includes(arg) ? arg : "default";
+      if (arg && !validStrategies.includes(arg)) {
+        renderWarning(`Unknown strategy "${arg}". Valid: ${validStrategies.join(", ")}`);
+        return "handled";
+      }
+      const ok = ctx.requestCompaction?.(strategy) ?? false;
+      if (ok) {
+        renderInfo(`Compaction requested (strategy: ${c2.bold(strategy)}). Will apply at next turn boundary.`);
+      } else {
+        renderWarning("Could not request compaction.");
+      }
+      return "handled";
+    }
     default: {
       const skills = discoverSkills(ctx.repoRoot);
       const skill = skills.find((s) => s.name === cmd || s.name === cmd.replace(/_/g, "-"));
@@ -20983,7 +21392,7 @@ function createTaskCompleteTool() {
     }
   };
 }
-function buildTools(repoRoot, config) {
+function buildTools(repoRoot, config, contextWindowSize) {
   const executionTools = [
     new FileReadTool(repoRoot),
     new FileWriteTool(repoRoot),
@@ -21044,11 +21453,11 @@ function buildTools(repoRoot, config) {
   ];
   return [
     ...executionTools.map(adaptTool2),
-    createSubAgentTool(config, repoRoot),
+    createSubAgentTool(config, repoRoot, contextWindowSize),
     createTaskCompleteTool()
   ];
 }
-function createSubAgentTool(config, repoRoot) {
+function createSubAgentTool(config, repoRoot, ctxWindowSize) {
   return {
     name: "sub_agent",
     description: "Delegate a sub-task to an independent agent with its own context window. Each sub-agent creates an independent backend connection, enabling TRUE PARALLEL inference when the backend supports concurrent requests (Ollama with OLLAMA_NUM_PARALLEL > 1). BEST PRACTICE: Launch multiple sub_agent calls with background=true in ONE response to maximize parallelism. Check results via task_status/task_output.",
@@ -21069,13 +21478,18 @@ function createSubAgentTool(config, repoRoot) {
         return { success: false, output: "", error: "task is required" };
       }
       const backend = new OllamaAgenticBackend(config.backendUrl, config.model, config.apiKey);
+      const subCtxWindow = ctxWindowSize ?? 0;
+      const subTier = getModelTier(config.model);
+      const subCompaction = subTier === "small" ? 12e3 : subTier === "medium" ? 24e3 : 4e4;
       const subRunner = new AgenticRunner(backend, {
         maxTurns,
         maxTokens: 16384,
         temperature: 0,
         requestTimeoutMs: config.timeoutMs,
         taskTimeoutMs: config.timeoutMs * 2,
-        compactionThreshold: 4e4
+        compactionThreshold: subCompaction,
+        contextWindowSize: subCtxWindow,
+        modelTier: subTier
       });
       const subTools = [
         new FileReadTool(repoRoot),
@@ -21145,7 +21559,7 @@ function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce
     // effectively unlimited — no hard timeout, agent runs until complete or aborted
     contextWindowSize: contextWindowSize ?? 0
   });
-  const tools = buildTools(repoRoot, config);
+  const tools = buildTools(repoRoot, config, contextWindowSize);
   if (contextWindowSize && contextWindowSize > 0) {
     for (const tool of tools) {
       if ("setContextWindowSize" in tool && typeof tool.setContextWindowSize === "function") {
@@ -21572,7 +21986,9 @@ async function startInteractive(config, repoPath) {
     "/skills",
     "/pause",
     "/stop",
-    "/resume"
+    "/resume",
+    "/compact",
+    "/gc"
   ];
   const discoveredSkillNames = discoverSkills(repoRoot).map((s) => `/${s.name}`);
   const allCompletions = [.../* @__PURE__ */ new Set([...BUILTIN_COMMANDS, ...discoveredSkillNames])].sort();
@@ -21863,6 +22279,12 @@ async function startInteractive(config, repoPath) {
       statusBar.setCapabilities(caps);
     },
     hasActiveTask: () => activeTask !== null,
+    requestCompaction(strategy) {
+      if (!activeTask)
+        return false;
+      activeTask.runner.requestCompaction(strategy);
+      return true;
+    },
     abortTask() {
       if (!activeTask)
         return false;

package/package.json

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