omnius 1.0.478 → 1.0.479

package/dist/index.js

@@ -552586,7 +552586,7 @@ var init_agent_tool = __esm({
           },
           subagent_type: {
             type: "string",
-            enum: ["general", "explore", "plan", "coordinator"],
+            enum: ["general", "explore", "plan", "coordinator", "fixer"],
             description: "Agent type determining tool access and behavior (default: general)"
           },
           deployment_pattern: {
@@ -576243,6 +576243,13 @@ function failureProgressSignal(text2) {
   }
   return lines > 0 ? lines : void 0;
 }
+function isVerificationCommand(toolName, output) {
+  if (isEditTool(toolName))
+    return false;
+  if (toolName !== "shell" && toolName !== "background_run")
+    return false;
+  return failureProgressSignal(output) != null;
+}
 function actionFamily(toolName, args, cwd4) {
   if (isEditTool(toolName)) {
     const path13 = primaryPath(args);
@@ -576704,10 +576711,24 @@ var init_focusSupervisor = __esm({
             // Root fix: progress = the action's error count dropped, not that an
             // edit happened. Extract the signal from the action's own output so a
             // futile edit loop (rebuilding with the same error count) escalates.
-            failureSignal: failureProgressSignal(input.output || input.error)
+            failureSignal: failureProgressSignal(input.output || input.error),
+            // Build-as-feedback: a build/test command is the verification oracle,
+            // never a failing action to abandon. When set, the breaker caps this
+            // family below terminal abandon and escalates to decompose-and-delegate.
+            isVerificationFeedback: isVerificationCommand(input.toolName, input.output || input.error)
           });
           this.sawMutationSinceFailure = false;
-          if (verdict.tier === "abandon") {
+          if (verdict.recommendedAction === "decompose_and_delegate") {
+            this.setDirective({
+              turn: input.turn,
+              state: "forced_replan",
+              reason: verdict.reason,
+              requiredNextAction: this.resolveRequiredNextAction("delegate_isolated_fix"),
+              forbiddenActionFamilies: [
+                actionFamily(input.toolName, input.args, this.familyCwd)
+              ]
+            });
+          } else if (verdict.tier === "abandon") {
             this.markTerminalIncomplete(verdict.reason, input.turn);
           } else if (verdict.tier === "stalled") {
             this.setDirective({
@@ -576902,7 +576923,10 @@ var init_convergence_breaker = __esm({
         }
         const sessionCount = Math.max(1, obs.sessionCount);
         const totalRounds = Math.max(1, base3 + sessionCount - dec);
-        const tier = this.tierFor(totalRounds);
+        let tier = this.tierFor(totalRounds);
+        if (obs.isVerificationFeedback && tier === "abandon") {
+          tier = "stalled";
+        }
         this.live.set(obs.family, { totalRounds, tier });
         const carry = this.store.load(obs.family);
         this.store.save({
@@ -576911,7 +576935,7 @@ var init_convergence_breaker = __esm({
           lastSample: obs.sample ?? carry?.lastSample,
           updatedAtMs: Date.now()
         });
-        return this.verdict(obs.family, totalRounds, tier, obs.sample);
+        return this.verdict(obs.family, totalRounds, tier, obs.sample, obs.isVerificationFeedback ?? false);
       }
       /** Clear a family's carry when its underlying work is verified/complete. */
       resolve(family) {
@@ -576939,8 +576963,18 @@ var init_convergence_breaker = __esm({
           return "converging_warn";
         return "healthy";
       }
-      verdict(family, totalRounds, tier, sample) {
+      verdict(family, totalRounds, tier, sample, verificationFeedback = false) {
         const suffix = sample ? `: ${sample}` : "";
+        if (verificationFeedback && (tier === "stalled" || tier === "abandon")) {
+          return {
+            tier: "stalled",
+            tripped: true,
+            totalRounds,
+            family,
+            reason: `verification command "${family}" has reported the same diagnostic set for ${totalRounds} rounds without shrinking. The build is FEEDBACK, not a failing action — do NOT abandon and do NOT re-run it blindly. Decompose its diagnostics: pick the single top implicated file/symbol, delegate an isolated investigate→fix sub-task for it (sub_agent), then re-run the build to test. Repeat until the diagnostic count drops${suffix}`,
+            recommendedAction: "decompose_and_delegate"
+          };
+        }
         switch (tier) {
           case "abandon":
             return {
@@ -577513,6 +577547,39 @@ var init_longhaul_integration = __esm({
        * Uses the model's own compiler output — no separate compiler run. Generic
        * across gcc/clang/tsc; returns null when there's nothing structural.
        */
+      /**
+       * B (delegation): turn a stuck build's diagnostics into an ACTIONABLE isolated
+       * sub-task. The main loop is the orchestrator — it holds trajectory and
+       * delegates; it must not keep re-running the build in a saturating context.
+       * This picks the single top structural diagnostic (a file+symbol the compiler
+       * named) and returns the exact `sub_agent` call to spawn an isolated,
+       * small-context worker that fixes JUST that unit, then folds a one-line result
+       * back. Generic: symbols/files come from the compiler's own output, no
+       * toolchain literals. Returns null when the output has no nameable structural
+       * unit (nothing concrete to delegate).
+       */
+      buildDelegationDirective(output) {
+        try {
+          const diags = parseCompilerDiagnostics(String(output || ""));
+          const structural = diags.filter((d2) => d2.kind === "signature_mismatch" || d2.kind === "duplicate_definition" || d2.kind === "unknown_member" || d2.kind === "unknown_symbol" || d2.kind === "type_error");
+          const top = structural.find((d2) => d2.file && d2.symbol) ?? structural.find((d2) => d2.file) ?? diags.find((d2) => d2.file) ?? structural[0] ?? diags[0];
+          if (!top)
+            return null;
+          const file = top.file ?? "the top implicated file";
+          const symbol3 = top.symbol ? ` symbol \`${top.symbol}\`` : "";
+          const kind = top.kind.replace(/_/g, " ");
+          const contractHint = top.symbol && this.lockedSource.has(top.symbol) ? ` The locked contract for \`${top.symbol}\` lives in ${this.lockedSource.get(top.symbol)} — match it exactly.` : "";
+          return `[DELEGATE — build is feedback, not the task] The build reported a stable diagnostic set. Do NOT re-run the build and do NOT keep editing in this context. Delegate ONE isolated fix to a seeded sub-agent, then re-run the build to test:
+  sub_agent({
+    subagent_type: "fixer",
+    description: "fix ${top.symbol ?? file}",
+    prompt: "In ${file}, resolve the ${kind}${symbol3}. Read ONLY ${file} (and the file that declares${symbol3 || " the offending symbol"}). Make the minimal edit to satisfy the contract. Do not touch unrelated files. Report a one-line outcome.${contractHint}"
+  })
+The sub-agent works in its own small context; when it folds back, run the build once to verify the diagnostic count dropped, then delegate the next one. This is fan-out/converge — keep THIS context on trajectory, not on the raw fix.`;
+        } catch {
+          return null;
+        }
+      }
       diagnosticGuidance(output) {
         try {
           const diags = parseCompilerDiagnostics(String(output || ""));
@@ -593012,6 +593079,16 @@ ${specDir}` : specDir;
 
 ${diag}` : diag;
                     }
+                    const focusDir = this._focusSupervisor?.snapshot().directive;
+                    const wantsDelegation = focusDir?.requiredNextAction === "delegate_isolated_fix" || this._decomp2GateActive;
+                    if (wantsDelegation) {
+                      const delegateDir = lh.buildDelegationDirective(result.output ?? result.error ?? "");
+                      if (delegateDir) {
+                        runtimeSystemGuidance = runtimeSystemGuidance ? `${runtimeSystemGuidance}
+
+${delegateDir}` : delegateDir;
+                      }
+                    }
                   }
                 }
               } catch {
@@ -603393,7 +603470,7 @@ function resolveAgentTools(type, availableTools) {
 function buildAgentTypeSummary() {
   return _registry2.buildTypeSummary();
 }
-var CORE_TOOLS2, READ_ONLY_TOOLS, COORDINATOR_TOOLS, AGENT_DISALLOWED_TOOLS, GENERAL_AGENT, EXPLORE_AGENT, PLAN_AGENT, COORDINATOR_AGENT, AgentTypeRegistry, _registry2;
+var CORE_TOOLS2, READ_ONLY_TOOLS, COORDINATOR_TOOLS, AGENT_DISALLOWED_TOOLS, GENERAL_AGENT, EXPLORE_AGENT, PLAN_AGENT, COORDINATOR_AGENT, FIXER_TOOLS, FIXER_AGENT, AgentTypeRegistry, _registry2;
 var init_agent_types = __esm({
   "packages/orchestrator/dist/agent-types.js"() {
     "use strict";
@@ -603516,6 +603593,34 @@ var init_agent_types = __esm({
       canSpawnAgents: true,
       systemPromptAddition: "You are a coordinator agent. Your role is to break down complex tasks into sub-tasks and delegate them to worker agents. You CANNOT edit files directly — you must spawn agents to do the work. Monitor their progress via task notifications and coordinate their efforts."
     };
+    FIXER_TOOLS = [
+      "file_read",
+      "file_edit",
+      "file_patch",
+      "shell",
+      // run the build/test to verify its own fix
+      "grep",
+      "glob",
+      "task_complete"
+    ];
+    FIXER_AGENT = {
+      type: "fixer",
+      description: "Isolated single-unit fix worker. Minimal tools (read/edit/build/locate). Dispatched to resolve ONE named diagnostic in ONE file against the locked contract, then report a one-line outcome. Use for delegated build-diagnostic fixes in the fan-out/converge loop.",
+      allowedTools: [...FIXER_TOOLS],
+      disallowedTools: [
+        "file_write",
+        // prefer targeted edit/patch over whole-file writes
+        "agent",
+        "send_message",
+        ...AGENT_DISALLOWED_TOOLS
+      ],
+      maxTurns: 0,
+      // unlimited; halt only on task_complete or abort
+      model: "inherit",
+      isolation: "none",
+      canSpawnAgents: false,
+      systemPromptAddition: "You are an isolated FIX worker with a deliberately small context and tool set. You were given ONE specific diagnostic to resolve in ONE file. Read ONLY that file and the file that declares the offending symbol; make the MINIMAL edit to satisfy the locked contract; run the build once to confirm your change reduced the error; then call task_complete with a single-line outcome (what you changed and whether it verified). Do NOT refactor, do NOT touch unrelated files, do NOT expand scope. Fold back fast."
+    };
     AgentTypeRegistry = class {
       types = /* @__PURE__ */ new Map();
       constructor() {
@@ -603523,6 +603628,7 @@ var init_agent_types = __esm({
         this.register(EXPLORE_AGENT);
         this.register(PLAN_AGENT);
         this.register(COORDINATOR_AGENT);
+        this.register(FIXER_AGENT);
       }
       /** Register a new agent type (or override existing) */
       register(def) {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.478",
+  "version": "1.0.479",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.478",
+      "version": "1.0.479",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

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