open-agents-ai 0.187.526 → 0.187.528

package/dist/index.js

@@ -4842,10 +4842,10 @@ Try broader terms or use memory_read with a specific topic.`,
                 const data = JSON.parse(raw);
                 const topic = basename(file, ".json");
                 for (const [key, entry] of Object.entries(data)) {
-                  const dedup = `${topic}:${key}`;
-                  if (seen.has(dedup))
+                  const dedup2 = `${topic}:${key}`;
+                  if (seen.has(dedup2))
                     continue;
-                  seen.add(dedup);
+                  seen.add(dedup2);
                   if (entry?.value) {
                     entries.push({
                       topic,
@@ -524388,6 +524388,174 @@ var init_streaming_executor = __esm({
   }
 });
 
+// packages/orchestrator/dist/specDecomposer.js
+function isSourceModule(path8) {
+  if (!path8 || path8.includes(".."))
+    return false;
+  const cleaned = path8.trim().replace(/[`"',]+$/, "").replace(/\s+#.*$/, "");
+  if (!cleaned)
+    return false;
+  const dot = cleaned.lastIndexOf(".");
+  if (dot < 0)
+    return false;
+  const ext = cleaned.slice(dot).toLowerCase();
+  if (!SOURCE_EXTENSIONS.has(ext))
+    return false;
+  for (const re of EXCLUDE_PATTERNS) {
+    if (re.test(cleaned))
+      return false;
+  }
+  return true;
+}
+function extractFromTree(text) {
+  const lineRe = /^([ \t│]*)([├└])──\s+(\S+)/gm;
+  const out = [];
+  const parents = [];
+  let m2;
+  while ((m2 = lineRe.exec(text)) !== null) {
+    const prefix = m2[1];
+    const token = m2[3].replace(/\/+$/, "");
+    const depth = Math.floor(prefix.length / 4);
+    parents.length = depth;
+    const originalEndedWithSlash = m2[3].endsWith("/");
+    const hasExtension = token.includes(".") && !token.endsWith(".");
+    const isDir2 = originalEndedWithSlash || !hasExtension;
+    if (isDir2) {
+      parents[depth] = token;
+      continue;
+    }
+    const segments = parents.filter((p2) => p2 && p2.length > 0);
+    const fullPath = segments.length > 0 ? segments.join("/") + "/" + token : token;
+    if (isSourceModule(fullPath)) {
+      out.push({ path: fullPath });
+    }
+  }
+  return out;
+}
+function extractFromModuleSections(text) {
+  const re = /^#{2,4}\s+(?:Module|File):\s*[`"']?([^\s`"'\n]+)/gm;
+  const out = [];
+  let m2;
+  while ((m2 = re.exec(text)) !== null) {
+    const raw = m2[1].replace(/\/+$/, "");
+    if (isSourceModule(raw)) {
+      out.push({ path: raw });
+    }
+  }
+  return out;
+}
+function extractFromHeaderList(text) {
+  const re = /^#{3,4}\s+(?:Module:\s+)?[`"']?(src\/[^\s`"'\n]+\.[A-Za-z0-9]+)[`"']?/gm;
+  const out = [];
+  let m2;
+  while ((m2 = re.exec(text)) !== null) {
+    const raw = m2[1].replace(/\/+$/, "");
+    if (isSourceModule(raw)) {
+      out.push({ path: raw });
+    }
+  }
+  return out;
+}
+function decomposeSpec(taskText) {
+  if (!taskText || typeof taskText !== "string") {
+    return { modules: [], strategy: "none" };
+  }
+  const tree2 = dedup(extractFromTree(taskText));
+  if (tree2.length >= 3)
+    return { modules: tree2, strategy: "tree" };
+  const modSections = dedup(extractFromModuleSections(taskText));
+  if (modSections.length >= 3)
+    return { modules: modSections, strategy: "module-sections" };
+  const headers = dedup(extractFromHeaderList(taskText));
+  if (headers.length >= 3)
+    return { modules: headers, strategy: "module-headers" };
+  return { modules: [], strategy: "none" };
+}
+function dedup(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const e2 of items) {
+    if (seen.has(e2.path))
+      continue;
+    seen.add(e2.path);
+    out.push(e2);
+  }
+  return out;
+}
+function buildDecompositionDirective(modules, strategy) {
+  const moduleList = modules.slice(0, 30).map((m2, i2) => `  ${i2 + 1}. ${m2.path}`).join("\n");
+  const more = modules.length > 30 ? `
+  ... +${modules.length - 30} more` : "";
+  return [
+    `[SPEC DECOMPOSED — ${modules.length} modules detected via ${strategy}]`,
+    ``,
+    `Your task spec contains a clear module structure. To stay within context budget on a multi-module implementation, complete each module via sub_agent rather than in main context.`,
+    ``,
+    `Detected modules:`,
+    moduleList,
+    more,
+    ``,
+    `Recommended workflow:`,
+    `  1. Call todo_write with one todo per module (the orchestrator pre-populated this for you).`,
+    `  2. For EACH module, mark its todo in_progress, then call:`,
+    `       sub_agent({ subagent_type: "general", prompt: "Implement <module-path> per spec",`,
+    `                   relevantFiles: [{path:"<module-path>", content:"<existing or empty>"}], ... })`,
+    `  3. When sub_agent returns, mark the todo completed.`,
+    `  4. After ALL module todos are done, run the project's build/tests in main context.`,
+    `  5. If build/tests pass: call task_complete. If they fail: dispatch fix-up sub_agents for the failing module(s).`,
+    ``,
+    `Why this matters: implementing N modules in one context burns token budget linearly with N. sub_agent gives each module its own context window so the main context stays small for orchestration + integration verification.`,
+    ``,
+    `If you genuinely cannot use sub_agent for a module (e.g. it's a 3-line config file), inline editing in main context is fine — but for substantive modules, delegate.`
+  ].filter(Boolean).join("\n");
+}
+function buildDecompositionTodos(modules) {
+  return modules.map((m2, i2) => ({
+    id: `decomp-mod-${i2 + 1}`,
+    content: `Implement ${m2.path} (use sub_agent for focused context)`,
+    status: "pending"
+  }));
+}
+var SOURCE_EXTENSIONS, EXCLUDE_PATTERNS;
+var init_specDecomposer = __esm({
+  "packages/orchestrator/dist/specDecomposer.js"() {
+    "use strict";
+    SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+      ".ts",
+      ".tsx",
+      ".js",
+      ".jsx",
+      ".mjs",
+      ".cjs",
+      ".py",
+      ".pyi",
+      ".rs",
+      ".go",
+      ".java",
+      ".kt",
+      ".c",
+      ".cc",
+      ".cpp",
+      ".h",
+      ".hpp",
+      ".rb",
+      ".php",
+      ".swift",
+      ".scala",
+      ".clj",
+      ".lua"
+    ]);
+    EXCLUDE_PATTERNS = [
+      // Excluded directories — match anywhere in path (start-or-slash boundary).
+      /(^|\/)(node_modules|dist|build|out|target|\.git|\.next|coverage|__pycache__|venv|\.venv)\//,
+      // Test fixtures + samples — keep src/ tests but drop fixture/sample dirs.
+      /(^|\/)(fixtures|samples)\//,
+      // Package metadata / config — caller doesn't want decomposition for these.
+      /(^|\/)(package\.json|package-lock\.json|yarn\.lock|pnpm-lock\.yaml|tsconfig\.json|jest\.config\.[jt]s|vitest\.config\.[jt]s|\.eslintrc\.[a-z]+|Cargo\.toml|Cargo\.lock|go\.mod|go\.sum|pyproject\.toml|requirements\.txt|setup\.py|\.gitignore|\.npmignore|README\.md|LICENSE)$/
+    ];
+  }
+});
+
 // packages/orchestrator/dist/preflightSnapshot.js
 var preflightSnapshot_exports = {};
 __export(preflightSnapshot_exports, {
@@ -525432,7 +525600,7 @@ RECOVERY: cd to the directory containing '${file}', run a plain install with no
 });
 
 // packages/orchestrator/dist/agenticRunner.js
-import { existsSync as _fsExistsSync, readFileSync as _fsReadFileSync } from "node:fs";
+import { existsSync as _fsExistsSync, readFileSync as _fsReadFileSync, writeFileSync as _fsWriteFileSync, mkdirSync as _fsMkdirSync } from "node:fs";
 import { join as _pathJoin } from "node:path";
 import { homedir as _osHomedir } from "node:os";
 import { z as z15 } from "zod";
@@ -525665,6 +525833,7 @@ var init_agenticRunner = __esm({
     init_hooks();
     init_app_state();
     init_streaming_executor();
+    init_specDecomposer();
     TOOL_SUBSETS = {
       web: ["web_search", "web_fetch", "web_crawl"],
       code: ["file_patch", "file_explore", "batch_edit", "file_read", "file_write", "file_edit"],
@@ -526005,6 +526174,18 @@ var init_agenticRunner = __esm({
       //
       // Kill switch: OA_DISABLE_REG61_COERCE=1 disables BOTH set and enforce.
       _reg61PerpetualGateActive = false;
+      // DECOMP-2 (root-cause from batch531-midi-decomp, 2026-05-03): compelling
+      // sub_agent delegation. DECOMP-1's informational directive was ignored
+      // (0 sub_agent calls in 466 tool-call run despite directive at turn 1).
+      // Mirrors the BFC-61.G escalation arc: when the agent has edited
+      // ≥THRESHOLD distinct files in main context WITHOUT calling sub_agent,
+      // the dispatcher BLOCKS edits to NEW files (paths not yet edited) until
+      // sub_agent is invoked. Edits to already-touched files are still allowed
+      // (current-module finishing work). sub_agent dispatch clears the gate.
+      // Kill switch: OA_DISABLE_DECOMP2=1.
+      _decomp2MainContextFiles = /* @__PURE__ */ new Set();
+      _decomp2SubAgentCalls = 0;
+      _decomp2GateActive = false;
       // MEM_PATH item #9: adaptive retrieval cache. When the (goalHash, recent-tool-sig)
       // hasn't changed since last retrieval, skip the PPR call entirely and reuse
       // the previous memoryLines.
@@ -528335,6 +528516,9 @@ Respond with your assessment, then take action.`;
         this._aborting = false;
         this._reg61CooldownUntilTurn = -1;
         this._reg61PerpetualGateActive = false;
+        this._decomp2MainContextFiles = /* @__PURE__ */ new Set();
+        this._decomp2SubAgentCalls = 0;
+        this._decomp2GateActive = false;
         if (!globalThis.__oa_rca1_sigterm_installed) {
           globalThis.__oa_rca1_sigterm_installed = true;
           const _sigtermHandler = () => {
@@ -528474,6 +528658,46 @@ TASK: ${task}` : task;
           { role: "system", content: systemPrompt },
           { role: "user", content: userContent }
         ];
+        if (process.env["OA_DISABLE_DECOMP1"] !== "1") {
+          try {
+            const _taskBodyForDecomp = typeof userContent === "string" ? userContent : "";
+            const _decomp = decomposeSpec(_taskBodyForDecomp);
+            if (_decomp.modules.length > 0) {
+              const _directive = buildDecompositionDirective(_decomp.modules, _decomp.strategy);
+              messages2.push({ role: "system", content: _directive });
+              const _todos = buildDecompositionTodos(_decomp.modules);
+              try {
+                const sid = process.env["OA_SESSION_ID"] || this._sessionId || "default";
+                const safe = sid.replace(/[^a-zA-Z0-9_.-]/g, "_");
+                const fp = _pathJoin(_osHomedir(), ".open-agents", "todos", `${safe}.json`);
+                const dir = _pathJoin(_osHomedir(), ".open-agents", "todos");
+                try {
+                  _fsMkdirSync(dir, { recursive: true });
+                } catch {
+                }
+                let _existing = [];
+                try {
+                  if (_fsExistsSync(fp)) {
+                    const _parsed = JSON.parse(_fsReadFileSync(fp, "utf-8"));
+                    if (Array.isArray(_parsed))
+                      _existing = _parsed;
+                  }
+                } catch {
+                }
+                if (_existing.length === 0) {
+                  _fsWriteFileSync(fp, JSON.stringify(_todos, null, 2), "utf-8");
+                }
+              } catch {
+              }
+              this.emit({
+                type: "status",
+                content: `DECOMP-1 SPEC DECOMPOSED — ${_decomp.modules.length} modules detected via ${_decomp.strategy}; directive injected + todos pre-populated`,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+            }
+          } catch {
+          }
+        }
         try {
           if (this.options.subAgent)
             throw "skip-handoff-subagent";
@@ -530379,7 +530603,18 @@ ${memoryLines.join("\n")}`
                 // agents used to ignore REG-61.
                 "web_search",
                 "task_complete",
-                "ask_user"
+                "ask_user",
+                // DECOMP-1: sub-agent dispatch is productive work (it spawns
+                // a focused-context implementation worker). Block-listing
+                // sub_agent here would defeat the spec-decomposition pattern
+                // — agents would be forced into main-context edits even when
+                // delegation is the right move. sub_agent calls do NOT clear
+                // the gate (we want the agent to also produce direct edits
+                // for orchestration glue / integration), but they're allowed
+                // through.
+                "sub_agent",
+                "priority_delegate",
+                "background_run"
               ]);
               if (REG61_EDIT_TOOLS.has(tc.name) && this._reg61PerpetualGateActive) {
                 this._reg61PerpetualGateActive = false;
@@ -530434,6 +530669,71 @@ ${memoryLines.join("\n")}`
                 });
                 return { tc, output: reg61BlockMsg };
               }
+              if (this._decomp2GateActive && process.env["OA_DISABLE_DECOMP2"] !== "1") {
+                const DECOMP2_EDIT_TOOLS = /* @__PURE__ */ new Set([
+                  "file_write",
+                  "file_edit",
+                  "batch_edit",
+                  "file_patch"
+                ]);
+                if (DECOMP2_EDIT_TOOLS.has(tc.name)) {
+                  const _editPath = tc.arguments?.["path"] ?? "";
+                  const _isNewFile = _editPath && !this._decomp2MainContextFiles.has(_editPath);
+                  if (_isNewFile) {
+                    this.emit({
+                      type: "tool_call",
+                      toolName: tc.name,
+                      toolArgs: tc.arguments,
+                      turn,
+                      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                    });
+                    const _filesList = [...this._decomp2MainContextFiles].slice(0, 8).map((p2) => `  • ${p2}`).join("\n");
+                    const _moreFiles = this._decomp2MainContextFiles.size > 8 ? `
+  ... +${this._decomp2MainContextFiles.size - 8} more` : "";
+                    const decomp2Msg = [
+                      `[BLOCKED — DECOMP-2 main-context exhaustion]`,
+                      ``,
+                      `You have already edited ${this._decomp2MainContextFiles.size} distinct files in main context without invoking sub_agent. Continuing to edit ANOTHER new file ('${_editPath}') will keep your context window saturated and trigger compaction thrashing.`,
+                      ``,
+                      `Files you've already edited (will accept further edits to these):`,
+                      _filesList,
+                      _moreFiles,
+                      ``,
+                      `For the next module, you MUST use sub_agent. Workflow:`,
+                      `  1. Pick a pending todo (the orchestrator pre-populated module todos via DECOMP-1).`,
+                      `  2. Call sub_agent({`,
+                      `       subagent_type: "general",`,
+                      `       prompt: "Implement <module-path> per spec",`,
+                      `       relevantFiles: [{path: "<module-path>", content: "" /* or existing content */}],`,
+                      `       constraints: ["Stay within <module-path>; integration verification happens later"],`,
+                      `     })`,
+                      `  3. After sub_agent returns, mark the todo completed.`,
+                      ``,
+                      `Why this matters: spreading edits across N files in main context burns ~N × file_size tokens. sub_agent gives the next module a focused context window.`,
+                      ``,
+                      `If you have ALREADY edited '${_editPath}' (this is a continuation), the orchestrator's set must have missed it — call file_read to verify, then re-edit. Otherwise, dispatch sub_agent now.`
+                    ].join("\n");
+                    this.emit({
+                      type: "tool_result",
+                      toolName: tc.name,
+                      success: false,
+                      content: decomp2Msg.slice(0, 120),
+                      turn,
+                      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                    });
+                    this.emit({
+                      type: "status",
+                      content: `DECOMP-2 NEW-FILE BLOCK — rejected ${tc.name}('${_editPath}') at turn ${turn}; gate stays active until sub_agent is invoked`,
+                      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                    });
+                    this._tagSyntheticFailure({
+                      mode: "step_repetition",
+                      rationale: `DECOMP-2 new-file block on '${tc.name}'(${_editPath}) — agent has spread edits across ${this._decomp2MainContextFiles.size} files without sub_agent`
+                    });
+                    return { tc, output: decomp2Msg };
+                  }
+                }
+              }
               const PROGRESS_GATE_BYPASS_TOOLS = /* @__PURE__ */ new Set([
                 "todo_write",
                 "todo_read",
@@ -531541,6 +531841,30 @@ Respond with EXACTLY this structure before your next tool call:
                   if (this._fileWriteTimestamps.length > 200) {
                     this._fileWriteTimestamps.shift();
                   }
+                  const _editPath = tc.arguments?.["path"] ?? "";
+                  if (_editPath && typeof _editPath === "string") {
+                    this._decomp2MainContextFiles.add(_editPath);
+                    const DECOMP2_FILE_SPREAD_THRESHOLD = 5;
+                    if (!this._decomp2GateActive && this._decomp2MainContextFiles.size >= DECOMP2_FILE_SPREAD_THRESHOLD && this._decomp2SubAgentCalls === 0 && process.env["OA_DISABLE_DECOMP2"] !== "1") {
+                      this._decomp2GateActive = true;
+                      this.emit({
+                        type: "status",
+                        content: `DECOMP-2 NEW-FILE GATE ACTIVATED — ${this._decomp2MainContextFiles.size} distinct files edited in main context, 0 sub_agent calls; further edits to NEW files will be blocked until sub_agent is invoked`,
+                        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                      });
+                    }
+                  }
+                }
+              }
+              if (tc.name === "sub_agent" || tc.name === "priority_delegate" || tc.name === "background_run") {
+                this._decomp2SubAgentCalls++;
+                if (this._decomp2GateActive) {
+                  this._decomp2GateActive = false;
+                  this.emit({
+                    type: "status",
+                    content: `DECOMP-2 GATE CLEARED — '${tc.name}' satisfied delegation directive at turn ${turn}`,
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  });
                 }
               }
               if (result && result.success === false) {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.526",
+  "version": "0.187.528",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "open-agents-ai",
-      "version": "0.187.526",
+      "version": "0.187.528",
       "hasInstallScript": true,
       "license": "CC-BY-NC-4.0",
       "dependencies": {

package/package.json

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