open-agents-ai 0.100.0 → 0.101.0

package/dist/index.js

@@ -16927,8 +16927,13 @@ var init_agenticRunner = __esm({
       _fileRegistry = /* @__PURE__ */ new Map();
       // -- Memex Experience Archive (arXiv:2603.04257 inspired) --
       _memexArchive = /* @__PURE__ */ new Map();
-      // -- Consecutive ENOENT tracker (prevents path-guessing spirals) --
+      // -- ENOENT tracker (prevents path-guessing spirals) --
+      // Tracks both consecutive AND sliding-window ENOENT counts. The sliding
+      // window catches oscillation patterns (success → ENOENT → success → ENOENT)
+      // that the consecutive counter misses.
       _consecutiveEnoent = 0;
+      _recentEnoents = [];
+      // sliding window of last 8 tool calls
       // -- Session Checkpointing (Priority 5) --
       _sessionId = `session-${Date.now()}`;
       _workingDirectory = "";
@@ -17413,7 +17418,7 @@ Integrate this guidance into your current approach. Continue working on the task
               if (this.aborted)
                 return null;
               toolCallCount++;
-              const argsKey = Object.keys(tc.arguments ?? {}).sort().join(",");
+              const argsKey = Object.entries(tc.arguments ?? {}).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}=${typeof v === "string" ? v.slice(0, 80) : JSON.stringify(v)}`).join(",");
               toolCallLog.push({ name: tc.name, argsKey });
               this.emit({
                 type: "tool_call",
@@ -17503,11 +17508,19 @@ ${result.output.length > maxLen ? this.foldOutput(result.output, maxLen) : resul
                 });
               }
               const enoentTools = /* @__PURE__ */ new Set(["file_read", "list_directory", "find_files"]);
-              if (!result.success && enoentTools.has(tc.name) && /ENOENT|no such file|does not exist|not found/i.test(result.error ?? result.output)) {
+              const isEnoent = !result.success && enoentTools.has(tc.name) && /ENOENT|no such file|does not exist|not found/i.test(result.error ?? result.output);
+              if (enoentTools.has(tc.name)) {
+                this._recentEnoents.push(isEnoent);
+                if (this._recentEnoents.length > 8)
+                  this._recentEnoents.shift();
+              }
+              if (isEnoent) {
                 this._consecutiveEnoent++;
-                if (this._consecutiveEnoent >= 2) {
+                const windowEnoents = this._recentEnoents.filter(Boolean).length;
+                if (this._consecutiveEnoent >= 2 || windowEnoents >= 4) {
                   const failedPath = String(tc.arguments?.["path"] ?? tc.arguments?.["file"] ?? "unknown");
-                  this.pendingUserMessages.push(`[SYSTEM] ${this._consecutiveEnoent} consecutive file-not-found errors (last: "${failedPath}"). You are repeating failed paths. CHANGE YOUR APPROACH:
+                  const triggerReason = this._consecutiveEnoent >= 2 ? `${this._consecutiveEnoent} consecutive file-not-found errors` : `${windowEnoents}/8 recent file operations failed`;
+                  this.pendingUserMessages.push(`[SYSTEM] ${triggerReason} (last: "${failedPath}"). You are repeating failed paths. CHANGE YOUR APPROACH:
 1. Call list_directory(".") to see what exists at the project root
 2. Entries in a directory listing are RELATIVE to that directory. If you listed "parent/" and saw "child", the full path is "parent/child" \u2014 NOT ".child" or just "child"
 3. If an entry is a directory (marked "d"), use list_directory on it, NOT file_read
@@ -17557,6 +17570,38 @@ ${result.output.length > maxLen ? this.foldOutput(result.output, maxLen) : resul
             }
             if (completed)
               break;
+            const currentRepScore = this.detectRepetition(toolCallLog);
+            if (currentRepScore > 0.6 && toolCallLog.length >= 6) {
+              const { repetitionWindow } = this.contextLimits();
+              const recentWindow = toolCallLog.slice(-repetitionWindow);
+              const freqMap = /* @__PURE__ */ new Map();
+              for (const tc of recentWindow) {
+                const key = `${tc.name}(${tc.argsKey.slice(0, 60)})`;
+                freqMap.set(key, (freqMap.get(key) ?? 0) + 1);
+              }
+              const topRepeated = [...freqMap.entries()].sort((a, b) => b[1] - a[1]).slice(0, 2).map(([k, v]) => `${k} (${v}x)`).join(", ");
+              messages.push({
+                role: "user",
+                content: `[LOOP DETECTED] Your last ${repetitionWindow} tool calls are ${Math.round(currentRepScore * 100)}% repetitive.
+Repeated calls: ${topRepeated}
+
+You are stuck. The same call will give the same result. CHANGE YOUR APPROACH:
+- If exploring: you already have this data. Use it to make a decision.
+- If looking for a file: use grep_search or find_files instead of listing directories.
+- If a path doesn't exist: use list_directory(".") to see what does exist.
+- If confused about the task: re-read the original task prompt above.
+
+TASK REMINDER: ${this._taskState.goal}
+` + (this._taskState.completedSteps.length > 0 ? `Progress so far: ${this._taskState.completedSteps.slice(-3).join("; ")}
+` : "") + `
+Take a DIFFERENT action now.`
+              });
+              this.emit({
+                type: "status",
+                content: `Loop intervention: ${Math.round(currentRepScore * 100)}% repetitive (${topRepeated})`,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+            }
           } else {
             const content = msg.content || "";
             messages.push({ role: "assistant", content });
@@ -18106,13 +18151,16 @@ ${tail}`;
         if (memexIndexStr)
           enrichments.push(memexIndexStr);
         const fullSummary = enrichments.join("\n\n");
+        const goalReminder = this._taskState.goal ? `
+
+**YOUR ACTIVE TASK:** ${this._taskState.goal}` : "";
         const compactionMsg = {
           role: "system",
           content: `[Context compacted${strategyLabel} \u2014 summary of earlier work]
 
 ${fullSummary}
 
-[Continue from the recent context below. Do not repeat work already completed above.]`
+[Continue from the recent context below. Do not repeat work already completed above.]${goalReminder}`
         };
         this.persistCheckpoint(fullSummary);
         let result = [...head, compactionMsg, ...recent];
@@ -29641,17 +29689,41 @@ async function handleSlashCommand(input, ctx) {
       }
       return "handled";
     case "config":
-    case "cfg":
+    case "cfg": {
+      const resolved = loadProjectSettings(ctx.repoRoot);
+      const globalS = loadGlobalSettings();
+      const merged = { ...globalS, ...resolved };
       renderConfig({
+        // -- Core inference --
         model: ctx.config.model,
         backendType: ctx.config.backendType,
         backendUrl: ctx.config.backendUrl,
-        timeoutMs: String(ctx.config.timeoutMs),
+        apiKey: ctx.config.apiKey ? "[set]" : "[not set]",
         maxRetries: String(ctx.config.maxRetries),
+        timeoutMs: String(ctx.config.timeoutMs),
+        dbPath: ctx.config.dbPath,
+        // -- Behaviour --
+        dryRun: String(ctx.config.dryRun),
         verbose: String(ctx.config.verbose),
-        dryRun: String(ctx.config.dryRun)
+        stream: String(merged.stream ?? false),
+        bruteforce: String(merged.bruteforce ?? false),
+        deepContext: String(merged.deepContext ?? false),
+        // -- Presentation --
+        emojis: String(ctx.getEmojis?.() ?? merged.emojis ?? true),
+        colors: String(ctx.getColors?.() ?? merged.colors ?? true),
+        style: String(ctx.getStyle?.() ?? merged.style ?? "balanced"),
+        // -- Voice --
+        voice: String(merged.voice ?? false),
+        voiceModel: String(merged.voiceModel ?? "glados"),
+        // -- Autonomy --
+        commandsMode: String(ctx.getCommandsMode?.() ?? merged.commandsMode ?? "manual"),
+        updateMode: String(merged.updateMode ?? "auto"),
+        // -- Integrations --
+        telegramKey: merged.telegramKey ? "[set]" : "[not set]",
+        telegramAdmin: String(merged.telegramAdmin ?? "[not set]")
       });
       return "handled";
+    }
     case "cost":
     case "costs":
       if (ctx.costTracker) {
@@ -44076,6 +44148,12 @@ function coerceForSettings(key, value) {
   if (BOOL_KEYS.has(key)) {
     return value === "1" || value.toLowerCase() === "true" || value.toLowerCase() === "yes";
   }
+  if (ENUM_KEYS[key]) {
+    const allowed = ENUM_KEYS[key];
+    if (!allowed.includes(value)) {
+      throw new Error(`Invalid value "${value}" for ${key}. Allowed: ${allowed.join(", ")}`);
+    }
+  }
   return value;
 }
 async function configCommand(opts, config) {
@@ -44090,16 +44168,34 @@ async function configCommand(opts, config) {
 function handleShow(opts, config) {
   const repoRoot = resolve30(opts.repoPath ?? cwd3());
   printHeader("Configuration");
-  printSection("Active Settings (merged)");
+  const resolved = resolveSettings(repoRoot);
+  printSection("Core Inference");
   printKeyValue("backendUrl", config.backendUrl, 2);
   printKeyValue("backendType", config.backendType, 2);
   printKeyValue("model", config.model, 2);
   printKeyValue("apiKey", config.apiKey ? "[set]" : "[not set]", 2);
   printKeyValue("maxRetries", String(config.maxRetries), 2);
   printKeyValue("timeoutMs", String(config.timeoutMs), 2);
+  printKeyValue("dbPath", config.dbPath, 2);
+  printSection("Behaviour");
   printKeyValue("dryRun", String(config.dryRun), 2);
   printKeyValue("verbose", String(config.verbose), 2);
-  printKeyValue("dbPath", config.dbPath, 2);
+  printKeyValue("stream", String(resolved.stream ?? false), 2);
+  printKeyValue("bruteforce", String(resolved.bruteforce ?? false), 2);
+  printKeyValue("deepContext", String(resolved.deepContext ?? false), 2);
+  printSection("Presentation");
+  printKeyValue("emojis", String(resolved.emojis ?? true), 2);
+  printKeyValue("colors", String(resolved.colors ?? true), 2);
+  printKeyValue("style", String(resolved.style ?? "balanced"), 2);
+  printSection("Voice & Audio");
+  printKeyValue("voice", String(resolved.voice ?? false), 2);
+  printKeyValue("voiceModel", String(resolved.voiceModel ?? "glados"), 2);
+  printSection("Agent Autonomy");
+  printKeyValue("commandsMode", String(resolved.commandsMode ?? "manual"), 2);
+  printKeyValue("updateMode", String(resolved.updateMode ?? "auto"), 2);
+  printSection("Integrations");
+  printKeyValue("telegramKey", resolved.telegramKey ? redactIfSensitive("telegramKey", resolved.telegramKey) : "[not set]", 2);
+  printKeyValue("telegramAdmin", String(resolved.telegramAdmin ?? "[not set]"), 2);
   const projectSettings = loadProjectSettings(repoRoot);
   const projectKeys = Object.entries(projectSettings).filter(([, v]) => v !== void 0);
   if (projectKeys.length > 0) {
@@ -44166,10 +44262,28 @@ function handleSet(opts, _config) {
       process.exit(1);
     }
   } else {
+    const AGENT_CONFIG_KEYS = /* @__PURE__ */ new Set([
+      "backendUrl",
+      "model",
+      "backendType",
+      "apiKey",
+      "maxRetries",
+      "timeoutMs",
+      "dryRun",
+      "verbose",
+      "dbPath"
+    ]);
     try {
-      setConfigValue(key, value);
-      printSuccess(`Config updated: ${key} = ${redactIfSensitive(key, value)}`);
-      printInfo(`Saved to ~/.open-agents/config.json`);
+      const coerced = coerceForSettings(key, value);
+      if (AGENT_CONFIG_KEYS.has(key)) {
+        setConfigValue(key, value);
+        printSuccess(`Config updated: ${key} = ${redactIfSensitive(key, value)}`);
+        printInfo(`Saved to ~/.open-agents/config.json`);
+      } else {
+        saveGlobalSettings({ [key]: coerced });
+        printSuccess(`Setting updated: ${key} = ${redactIfSensitive(key, value)}`);
+        printInfo(`Saved to ~/.open-agents/settings.json`);
+      }
       printInfo("Tip: Use --local to set project-specific overrides.");
     } catch (err) {
       printError(`Failed to save config: ${err instanceof Error ? err.message : String(err)}`);
@@ -44187,7 +44301,7 @@ function handleKeys() {
   printInfo("  oa config set model qwen3.5:122b          # global default");
   printInfo("  oa config set model qwen3.5:122b --local  # this project only");
 }
-var CONFIG_KEYS, SENSITIVE_KEYS, INT_KEYS, BOOL_KEYS;
+var CONFIG_KEYS, SENSITIVE_KEYS, INT_KEYS, BOOL_KEYS, ENUM_KEYS;
 var init_config3 = __esm({
   "packages/cli/dist/commands/config.js"() {
     "use strict";
@@ -44195,23 +44309,44 @@ var init_config3 = __esm({
     init_oa_directory();
     init_output();
     CONFIG_KEYS = {
+      // -- Core inference --
       backendUrl: "Backend base URL (Ollama or OpenAI-compatible)",
       backendType: "Backend type: ollama, vllm, fake",
       model: "Model name to use",
       apiKey: "Bearer token for authenticated deployments",
       maxRetries: "Maximum HTTP retries (integer)",
       timeoutMs: "Per-request timeout in milliseconds (integer)",
+      dbPath: "Path to SQLite memory database",
+      // -- Behaviour flags --
       dryRun: "Dry-run mode - patches not written (true/false)",
       verbose: "Verbose output (true/false)",
-      dbPath: "Path to SQLite memory database",
+      stream: "Enable real-time token streaming with pastel syntax highlighting (true/false)",
+      bruteforce: "Brute-force mode: auto re-engage agent when turn limit hit (true/false)",
+      deepContext: "Deep context mode - relaxes compaction for complex problem-solving (true/false)",
+      // -- TUI presentation --
+      emojis: "Show emoji icons next to tool calls and status messages (true/false)",
+      colors: "Enable pastel ANSI colors in the TUI (true/false)",
+      style: "Personality preset: concise, balanced, verbose, pedagogical",
+      // -- Voice & audio --
       voice: "Enable TTS voice feedback (true/false)",
       voiceModel: "TTS voice model: glados, overwatch",
-      stream: "Enable real-time token streaming with pastel syntax highlighting (true/false)",
-      bruteforce: "Brute-force mode: auto re-engage agent when turn limit hit (true/false)"
+      // -- Agent autonomy --
+      commandsMode: "Agent slash-command access: auto (agent can invoke) or manual (user-only)",
+      updateMode: "Update behaviour: auto (after task completion) or manual (/update only)",
+      // -- Integrations --
+      telegramKey: "Telegram bot API token for /telegram bridge",
+      telegramAdmin: "Telegram admin user ID \u2014 only this user can interact with the bot"
     };
-    SENSITIVE_KEYS = /* @__PURE__ */ new Set(["apiKey", "api_key", "secret", "password", "token"]);
+    SENSITIVE_KEYS = /* @__PURE__ */ new Set(["apiKey", "api_key", "secret", "password", "token", "telegramKey"]);
     INT_KEYS = /* @__PURE__ */ new Set(["maxRetries", "timeoutMs"]);
-    BOOL_KEYS = /* @__PURE__ */ new Set(["dryRun", "verbose", "voice", "stream", "bruteforce"]);
+    BOOL_KEYS = /* @__PURE__ */ new Set(["dryRun", "verbose", "voice", "stream", "bruteforce", "deepContext", "emojis", "colors"]);
+    ENUM_KEYS = {
+      commandsMode: ["auto", "manual"],
+      updateMode: ["auto", "manual"],
+      style: ["concise", "balanced", "verbose", "pedagogical"],
+      backendType: ["ollama", "vllm", "fake"],
+      voiceModel: ["glados", "overwatch"]
+    };
   }
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.100.0",
+  "version": "0.101.0",
   "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/agentic/system-large.md

@@ -135,8 +135,21 @@ When you discover image files (png, jpg, gif, svg, webp, bmp) during codebase ex
 
 ## Self-Awareness & Introspection
 
-You are Open Agent (open-agents-ai), an autonomous AI coding agent. You can discover your own capabilities:
-
+You are **Open Agent** (open-agents-ai), an autonomous AI coding agent running on local hardware via Ollama or vLLM with open-weight models. No cloud APIs — everything runs on the user's machine.
+
+**Core capabilities** (use explore_tools() to unlock more):
+- Code: read, write, edit, search, patch files across any language
+- Shell: run any command — tests, builds, git, npm, docker, etc.
+- Web: search documentation and fetch web pages
+- Memory: persistent cross-session knowledge (memory_read/memory_write)
+- Skills: 250+ behavioral skills (skill_list), build new ones (skill_build)
+- P2P: connect to other agents via nexus (libp2p + NATS mesh)
+- Background tasks: run long commands in background, check status later
+- Desktop/Vision: screenshot, click UI, OCR (via explore_tools)
+- Scheduling: cron jobs, reminders, agenda (via explore_tools)
+- Custom tools: create reusable tools from repeated workflows
+
+**Introspection tools** (use to answer questions about yourself):
 - **Tool discovery**: Use explore_tools() to see all available tools and unlock new ones
 - **Skill discovery**: Use skill_list() to discover behavioral skills with trigger patterns
 - **Memory**: Use memory_read/memory_write/memory_search to access persistent cross-session knowledge
@@ -144,9 +157,8 @@ You are Open Agent (open-agents-ai), an autonomous AI coding agent. You can disc
 - **Metrics**: Use slash_command('stats') to see session performance (when /commands auto)
 - **Capabilities**: Use slash_command('score') to see hardware inference capabilities (when /commands auto)
 - **Project map**: Use codebase_map to understand the project structure
-- **Self-description**: You run on local hardware via Ollama/vLLM with open-weight models, no cloud APIs
 
-When asked about yourself, use these tools to provide concrete, accurate information rather than generic descriptions.
+When asked "how do you work?" or "what can you do?", answer from the capability list above and use introspection tools for specifics. Do NOT hallucinate capabilities — use tools to discover concrete information.
 
 ## Project Awareness
 

package/prompts/agentic/system-medium.md

@@ -49,4 +49,20 @@ NEVER say "I can't do that". ALWAYS attempt the task using your tools. If a tool
 - Directory listing entries are RELATIVE to the listed directory. If you list "parent/" and see "child", the full path is "parent/child" — NOT ".child" or just "child"
 - If an entry is a directory (d), use list_directory on it — NOT file_read
 - Prefer list_directory over shell ls — it shows full paths ready for your next tool call
-- You are Open Agent (open-agents-ai). Use explore_tools() to discover capabilities, skill_list() for skills, memory_read/memory_write for persistent knowledge. When asked about yourself, use tools to provide concrete information.
+## Self-Awareness
+
+You are **Open Agent** (open-agents-ai), an autonomous AI coding agent running on local hardware via Ollama or vLLM with open-weight models. No cloud APIs — everything runs on the user's machine.
+
+**Core capabilities** (use explore_tools() to unlock more):
+- Code: read, write, edit, search, patch files across any language
+- Shell: run any command — tests, builds, git, npm, docker, etc.
+- Web: search documentation and fetch web pages
+- Memory: persistent cross-session knowledge (memory_read/memory_write)
+- Skills: 250+ behavioral skills (skill_list), build new ones (skill_build)
+- P2P: connect to other agents via nexus (libp2p + NATS mesh)
+- Background tasks: run long commands in background, check status later
+- Desktop/Vision: screenshot, click UI, OCR (via explore_tools)
+- Scheduling: cron jobs, reminders, agenda (via explore_tools)
+- Custom tools: create reusable tools from repeated workflows
+
+When asked "how do you work?" or "what can you do?", answer from this list and use explore_tools() or skill_list() to provide specifics. Do NOT hallucinate capabilities — use tools to discover concrete information.

package/prompts/agentic/system-small.md

@@ -19,4 +19,6 @@ Rules:
 - If ENOENT, list_directory on project root. Don't guess paths.
 - Directory entries are RELATIVE. If you list "parent/" and see "child", the path is "parent/child" — NOT ".child".
 - Use list_directory for directories, NOT file_read. Prefer list_directory over shell ls.
-- You are Open Agent. Use explore_tools() to discover more tools.
+- You are **Open Agent** (open-agents-ai) — an AI coding agent running locally via Ollama/vLLM. No cloud APIs.
+- Core: code editing, shell commands, web search, memory, 250+ skills (skill_list), P2P networking (nexus), background tasks.
+- When asked "what can you do?", use explore_tools() and skill_list() to discover and report your actual capabilities. Do NOT hallucinate.