omnius 1.0.355 → 1.0.357

package/dist/index.js

@@ -33658,7 +33658,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         }
         const nodeModulesDir = resolve18(this.repoRoot, "node_modules");
         let nexusResolved = false;
-        const execAsync3 = (cmd, opts = {}) => new Promise((res, rej) => {
+        const execAsync4 = (cmd, opts = {}) => new Promise((res, rej) => {
           const { exec: ex } = __require("node:child_process");
           ex(cmd, { encoding: "utf8", timeout: opts.timeout ?? 3e4, cwd: opts.cwd, maxBuffer: 10 * 1024 * 1024 }, (err, stdout) => {
             if (err)
@@ -33673,7 +33673,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
           const failures = [];
           for (const cmd of cmds) {
             try {
-              await execAsync3(cmd, { cwd: this.repoRoot, timeout: 18e4 });
+              await execAsync4(cmd, { cwd: this.repoRoot, timeout: 18e4 });
               return `Repaired node-datachannel native addon with: ${cmd.replace(" 2>&1", "")}`;
             } catch (err) {
               failures.push(`${cmd.replace(" 2>&1", "")}: ${err?.message ?? String(err)}`.slice(0, 500));
@@ -33688,7 +33688,7 @@ ${failures.join("\n")}`;
             nexusResolved = true;
           } else {
             try {
-              const globalDir2 = await execAsync3("npm root -g", { timeout: 5e3 });
+              const globalDir2 = await execAsync4("npm root -g", { timeout: 5e3 });
               const globalPkg = join31(globalDir2, "open-agents-nexus", "package.json");
               if (existsSync30(globalPkg)) {
                 nexusResolved = true;
@@ -33701,13 +33701,13 @@ ${failures.join("\n")}`;
         if (!nexusResolved) {
           const installSpec = `open-agents-nexus@${OPEN_AGENTS_NEXUS_BUNDLED_SPEC}`;
           try {
-            await execAsync3(`npm install ${installSpec} 2>&1`, {
+            await execAsync4(`npm install ${installSpec} 2>&1`, {
               cwd: this.repoRoot,
               timeout: 12e4
             });
           } catch {
             try {
-              await execAsync3(`npm install -g ${installSpec} 2>&1`, { timeout: 12e4 });
+              await execAsync4(`npm install -g ${installSpec} 2>&1`, { timeout: 12e4 });
             } catch {
               throw new Error(`Failed to install ${installSpec}. Run: npm install ${installSpec}`);
             }
@@ -33752,7 +33752,7 @@ ${failures.join("\n")}`;
         const agentType = args.agent_type || "general";
         const nodePaths = [nodeModulesDir];
         try {
-          const globalDir2 = await execAsync3("npm root -g", { timeout: 5e3 });
+          const globalDir2 = await execAsync4("npm root -g", { timeout: 5e3 });
           nodePaths.push(globalDir2);
         } catch {
         }
@@ -98730,12 +98730,12 @@ var require_x509_cjs = __commonJS({
 var require_crypto = __commonJS({
   "../node_modules/acme-client/src/crypto/index.js"(exports) {
     var net5 = __require("net");
-    var { promisify: promisify8 } = __require("util");
+    var { promisify: promisify9 } = __require("util");
     var crypto14 = __require("crypto");
     var asn1js4 = require_build2();
     var x5093 = require_x509_cjs();
-    var randomInt2 = promisify8(crypto14.randomInt);
-    var generateKeyPair2 = promisify8(crypto14.generateKeyPair);
+    var randomInt2 = promisify9(crypto14.randomInt);
+    var generateKeyPair2 = promisify9(crypto14.generateKeyPair);
     x5093.cryptoProvider.set(crypto14.webcrypto);
     var subjectAltNameOID = "2.5.29.17";
     var alpnAcmeIdentifierOID = "1.3.6.1.5.5.7.1.31";
@@ -133580,9 +133580,9 @@ var require_lib = __commonJS({
 var require_forge2 = __commonJS({
   "../node_modules/acme-client/src/crypto/forge.js"(exports) {
     var net5 = __require("net");
-    var { promisify: promisify8 } = __require("util");
+    var { promisify: promisify9 } = __require("util");
     var forge = require_lib();
-    var generateKeyPair2 = promisify8(forge.pki.rsa.generateKeyPair);
+    var generateKeyPair2 = promisify9(forge.pki.rsa.generateKeyPair);
     function forgeObjectFromPem(input) {
       const msg = forge.pem.decode(input)[0];
       let result;
@@ -150808,7 +150808,7 @@ var require_mock_interceptor = __commonJS({
 var require_mock_client = __commonJS({
   "../node_modules/undici/lib/mock/mock-client.js"(exports, module) {
     "use strict";
-    var { promisify: promisify8 } = __require("node:util");
+    var { promisify: promisify9 } = __require("node:util");
     var Client2 = require_client2();
     var { buildMockDispatch } = require_mock_utils();
     var {
@@ -150856,7 +150856,7 @@ var require_mock_client = __commonJS({
         this[kDispatches] = [];
       }
       async [kClose]() {
-        await promisify8(this[kOriginalClose])();
+        await promisify9(this[kOriginalClose])();
         this[kConnected] = 0;
         this[kMockAgent][Symbols.kClients].delete(this[kOrigin]);
       }
@@ -151069,7 +151069,7 @@ var require_mock_call_history = __commonJS({
 var require_mock_pool = __commonJS({
   "../node_modules/undici/lib/mock/mock-pool.js"(exports, module) {
     "use strict";
-    var { promisify: promisify8 } = __require("node:util");
+    var { promisify: promisify9 } = __require("node:util");
     var Pool = require_pool();
     var { buildMockDispatch } = require_mock_utils();
     var {
@@ -151117,7 +151117,7 @@ var require_mock_pool = __commonJS({
         this[kDispatches] = [];
       }
       async [kClose]() {
-        await promisify8(this[kOriginalClose])();
+        await promisify9(this[kOriginalClose])();
         this[kConnected] = 0;
         this[kMockAgent][Symbols.kClients].delete(this[kOrigin]);
       }
@@ -557168,8 +557168,8 @@ var init_verifierRunner = __esm({
         if (patch.testsToRun.length === 0)
           return "(no tests specified)";
         const { execFile: execFile9 } = await import("node:child_process");
-        const { promisify: promisify8 } = await import("node:util");
-        const execFileAsync6 = promisify8(execFile9);
+        const { promisify: promisify9 } = await import("node:util");
+        const execFileAsync6 = promisify9(execFile9);
         const outputs = [];
         const workDir = this.options.workingDir || repoRoot;
         for (const cmd of patch.testsToRun.slice(0, 3)) {
@@ -566182,8 +566182,8 @@ var init_streaming_executor = __esm({
       startExecution(entry) {
         entry.state = "executing";
         entry.startedAt = Date.now();
-        const exec6 = this.executeFn;
-        entry.promise = exec6(entry.name, entry.args).then((result) => {
+        const exec7 = this.executeFn;
+        entry.promise = exec7(entry.name, entry.args).then((result) => {
           entry.state = "completed";
           entry.result = result;
           entry.completedAt = Date.now();
@@ -567216,10 +567216,13 @@ function adversarySystemPrompt() {
     "  • simulation / mock / placeholder ≠ real.",
     "  • partial progress ≠ done.",
     "Mixed results are the norm: do NOT let one success excuse an unproven completion claim.",
+    "  • a repeating IDENTICAL error while the agent keeps editing the same target = a FAILING",
+    "    APPROACH: the change itself is wrong (an unsupported token / wrong API / missing",
+    '    prerequisite), not a value to retry. Class "failing_approach".',
     "",
     "Given the agent's latest message and recent tool outcomes, decide whether the claim is proven.",
     "Respond with ONLY a JSON object, no prose, no code fences:",
-    '{"class":"false_success|unproven_claim|weak_evidence|false_failure|repeated_action|ok",',
+    '{"class":"false_success|unproven_claim|weak_evidence|false_failure|repeated_action|failing_approach|ok",',
     ' "shortText":"<=12 word headline",',
     ' "confidence":0.0-1.0,  // how strongly the claim is NOT proven',
     ' "details":"2-4 sentence skeptical critique citing the specific gap",',
@@ -567250,6 +567253,26 @@ ${ls2.alreadyHave.slice(0, 900)}` : `(No cached result available for the repeate
       "Return ONLY the JSON object."
     ].join("\n");
   }
+  if (obs.failingApproach) {
+    const fa = obs.failingApproach;
+    const target = fa.churnTarget ? `${fa.churnTarget} (edited ${fa.churnWrites ?? "several"}× recently)` : "the same target";
+    return [
+      `The agent is in a FAILING APPROACH: the SAME error has recurred ${fa.count}× while it keeps changing ${target}.`,
+      `The recurring error:`,
+      `  ${fa.sample.slice(0, 400)}`,
+      "",
+      "A repeating identical error means the CHANGE ITSELF is wrong — an unsupported attribute/option, a wrong API/signature, or a missing prerequisite — NOT a value the agent hasn't guessed yet.",
+      "",
+      "Agent's latest message:",
+      obs.assistantText.slice(0, 900) || "(empty)",
+      "",
+      "Recent tool outcomes:",
+      outcomes || "  (none)",
+      "",
+      `Reason about THIS specific error. Identify the EXACT token it rejects (attribute/symbol/flag/path) and the root cause. Return class "failing_approach" with a "demand" that names the ONE authoritative source to verify the correct contract (the defining file / schema / API doc) and the supported alternative to use — or, if the feature is genuinely unsupported, to REMOVE it. If the error is actually transient or unrelated, class "ok".`,
+      "Return ONLY the JSON object."
+    ].join("\n");
+  }
   return [
     obs.claimsCompletion ? "The agent is asserting COMPLETION this turn." : "The agent produced a progress/success-flavored claim this turn.",
     "",
@@ -567286,6 +567309,7 @@ function parseAdversaryCritique(raw) {
     "unproven_claim",
     "weak_evidence",
     "false_failure",
+    "failing_approach",
     "ok"
   ];
   const klass = valid.includes(cls) ? cls : "unproven_claim";
@@ -567337,13 +567361,15 @@ var init_adversaryStream = __esm({
           return true;
         if (obs.loopSignal)
           return true;
+        if (obs.failingApproach)
+          return true;
         return SUCCESS_LANGUAGE.test(obs.assistantText);
       }
       /** Ingest an observation. Replaces any prior un-audited pending observation. */
       observe(obs) {
         if (!this.shouldAudit(obs))
           return;
-        const loopKey = obs.loopSignal ? `loop:${obs.loopSignal.tool}:${obs.loopSignal.target}:${obs.loopSignal.count}` : "";
+        const loopKey = obs.loopSignal ? `loop:${obs.loopSignal.tool}:${obs.loopSignal.target}:${obs.loopSignal.count}` : obs.failingApproach ? `fail:${obs.failingApproach.count}:${obs.failingApproach.sample.slice(0, 60)}` : "";
         const sig = `${obs.turn}:${loopKey}:${obs.assistantText.slice(0, 200)}`;
         if (sig === this.lastAuditedSignature)
           return;
@@ -570962,7 +570988,15 @@ Your hypotheses MUST address this specific error, not generic causes.
        * (optionally corroborated by the error-cluster tracker), self-cooldown 8
        * turns. OMNIUS_DISABLE_FAILING_APPROACH=1 disables.
        */
-      _detectFailingApproach(turn) {
+      /**
+       * Detect a FAILING APPROACH (same error recurring ≥N× while churning the same
+       * target) and return the STRUCTURED signal. The runtime routes this signal
+       * through the generative AdversaryStream (real per-case inference) rather than
+       * emitting a canned directive; `_failingApproachDirective` builds the templated
+       * fallback used ONLY when the adversary is disabled. Sets the cooldown so a
+       * detection (via either path) does not re-fire immediately.
+       */
+      _detectFailingApproachSignal(turn) {
         if (process.env["OMNIUS_DISABLE_FAILING_APPROACH"] === "1")
           return null;
         if (turn <= this._failingApproachCooldownUntil)
@@ -570970,7 +571004,7 @@ Your hypotheses MUST address this specific error, not generic causes.
         const recurring = this._recurringFailureSignature(turn);
         if (!recurring)
           return null;
-        let churnPath = null;
+        let churnPath;
         let churnWrites = 0;
         const wf = this._worldFacts;
         if (wf) {
@@ -570984,11 +571018,25 @@ Your hypotheses MUST address this specific error, not generic causes.
           }
         }
         this._failingApproachCooldownUntil = turn + 8;
-        const target = churnPath ? `${churnPath} (edited ${churnWrites}× recently)` : "the same target";
+        return {
+          count: recurring.count,
+          sample: recurring.sample,
+          churnTarget: churnPath,
+          churnWrites: churnWrites || void 0
+        };
+      }
+      /**
+       * Deterministic templated directive built from a failing-approach signal.
+       * Used ONLY as a fallback when the generative adversary is disabled
+       * (disableAdversaryCritic). Normally the signal is routed through real
+       * inference so the wording is reasoned per-case, not canned.
+       */
+      _failingApproachDirective(fa) {
+        const target = fa.churnTarget ? `${fa.churnTarget} (edited ${fa.churnWrites ?? "several"}× recently)` : "the same target";
         return [
           `[FAILING APPROACH DETECTED — stop retrying variants]`,
-          `The SAME error has recurred ${recurring.count}× in your recent attempts while you keep changing ${target}:`,
-          `  ${recurring.sample}`,
+          `The SAME error has recurred ${fa.count}× in your recent attempts while you keep changing ${target}:`,
+          `  ${fa.sample}`,
           ``,
           `Trying another variant of the same change is not converging. A repeating error means the CHANGE ITSELF is wrong — an unsupported attribute/option, a wrong API or signature, or a missing prerequisite — not that you haven't hit the right value yet.`,
           `MANDATORY before your next edit:`,
@@ -570999,6 +571047,11 @@ Your hypotheses MUST address this specific error, not generic causes.
           `Do NOT re-apply another variant of the rejected change.`
         ].join("\n");
       }
+      /** Back-compat wrapper: structured detection → templated directive. */
+      _detectFailingApproach(turn) {
+        const fa = this._detectFailingApproachSignal(turn);
+        return fa ? this._failingApproachDirective(fa) : null;
+      }
       /**
        * REG-61 sliding-window first-edit / sustained-edit nudge.
        *
@@ -576113,25 +576166,52 @@ TASK: ${scrubbedTask}` : scrubbedTask;
           }
           this._runReg61Check(turn, toolCallLog, messages2);
           if (turn > stagnationCooldownUntilTurn) {
-            const failingApproach = this._detectFailingApproach(turn);
-            if (failingApproach) {
-              messages2.push({ role: "system", content: failingApproach });
+            const faSignal = this._detectFailingApproachSignal(turn);
+            if (faSignal) {
               stagnationCooldownUntilTurn = turn + 4;
-              this.emit({
-                type: "adversary_reaction",
-                adversary: {
-                  class: "guidance",
-                  shortText: "Failing approach — same error recurring; diagnose root cause",
-                  confidence: 0.9,
-                  details: failingApproach
-                },
-                timestamp: (/* @__PURE__ */ new Date()).toISOString()
-              });
-              this.emit({
-                type: "status",
-                content: `FAILING-APPROACH detected at turn ${turn} — injected root-cause directive`,
-                timestamp: (/* @__PURE__ */ new Date()).toISOString()
-              });
+              if (this._adversaryStream) {
+                this._adversaryStream.observe({
+                  turn,
+                  assistantText: "",
+                  recentToolOutcomes: this._adversaryToolOutcomes.slice(-8).map((o2) => ({
+                    tool: o2.tool,
+                    succeeded: o2.succeeded,
+                    preview: o2.preview
+                  })),
+                  claimsCompletion: false,
+                  failingApproach: {
+                    count: faSignal.count,
+                    sample: faSignal.sample,
+                    churnTarget: faSignal.churnTarget,
+                    churnWrites: faSignal.churnWrites
+                  }
+                });
+                void this._adversaryStream.tick().catch(() => {
+                });
+                this.emit({
+                  type: "status",
+                  content: `FAILING-APPROACH detected at turn ${turn} — routed to adversary inference`,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+              } else {
+                const directive = this._failingApproachDirective(faSignal);
+                messages2.push({ role: "system", content: directive });
+                this.emit({
+                  type: "adversary_reaction",
+                  adversary: {
+                    class: "guidance",
+                    shortText: "Failing approach — same error recurring; diagnose root cause",
+                    confidence: 0.9,
+                    details: directive
+                  },
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                this.emit({
+                  type: "status",
+                  content: `FAILING-APPROACH detected at turn ${turn} — injected root-cause directive (deterministic fallback; adversary disabled)`,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+              }
             }
           }
           const REG58_NO_WRITE_BUDGET = 30;
@@ -647430,9 +647510,9 @@ async function handleUpdate(subcommand, ctx3) {
       }
     };
   }
-  const { exec: exec6, spawn: spawn35, execSync: es2 } = await import("node:child_process");
+  const { exec: exec7, spawn: spawn35, execSync: es2 } = await import("node:child_process");
   const execA = (cmd, opts) => new Promise(
-    (res, rej) => exec6(
+    (res, rej) => exec7(
       cmd,
       {
         encoding: "utf8",
@@ -648179,7 +648259,7 @@ async function handleUpdate(subcommand, ctx3) {
     installOverlay.setPhase("Native Modules");
     installOverlay.setStatus("Rebuilding native modules...");
     await new Promise((resolve71) => {
-      const child = exec6(
+      const child = exec7(
         `${sudoPrefix}npm rebuild -g omnius 2>/dev/null || true`,
         { timeout: 12e4 },
         () => resolve71(true)
@@ -648243,7 +648323,7 @@ async function handleUpdate(subcommand, ctx3) {
     if (fsExists(venvPip2)) {
       installOverlay.setStatus("Upgrading Python packages...");
       await new Promise((resolve71) => {
-        const child = exec6(
+        const child = exec7(
           `"${venvPip2}" install --upgrade moondream-station pytesseract Pillow opencv-python-headless numpy 2>/dev/null || true`,
           { timeout: 3e5 },
           (err) => resolve71(!err)
@@ -656103,7 +656183,9 @@ var init_bless_engine = __esm({
 // packages/cli/src/tui/dmn-engine.ts
 import { existsSync as existsSync142, readFileSync as readFileSync115, writeFileSync as writeFileSync74, mkdirSync as mkdirSync86, readdirSync as readdirSync51, unlinkSync as unlinkSync29 } from "node:fs";
 import { join as join154, basename as basename33 } from "node:path";
-function buildDMNGatherPrompt(recentTaskSummaries, dueReminders, attentionItems, memoryTopics, capabilities, competence, reflectionBuffer) {
+import { exec as exec6 } from "node:child_process";
+import { promisify as promisify8 } from "node:util";
+function buildDMNGatherPrompt(recentTaskSummaries, dueReminders, attentionItems, memoryTopics, capabilities, competence, reflectionBuffer, projectOpportunities = []) {
   const competenceReport = competence.length > 0 ? competence.map((c8) => {
     const rate = c8.attempts > 0 ? Math.round(c8.successes / c8.attempts * 100) : 0;
     return `  - ${c8.taskType}: ${c8.attempts} attempts, ${rate}% success`;
@@ -656117,11 +656199,16 @@ function buildDMNGatherPrompt(recentTaskSummaries, dueReminders, attentionItems,
       dueReminders: dueReminders.length > 0 ? dueReminders.map((r2) => `  - ${r2}`).join("\n") : "  (none)",
       attentionItems: attentionItems.length > 0 ? attentionItems.map((a2) => `  - ${a2}`).join("\n") : "  (none)",
       memoryTopics: memoryTopics.length > 0 ? memoryTopics.map((t2) => `  - ${t2}`).join("\n") : "  (none — fresh start)",
-      capabilities: capabilities.map((c8) => `  - ${c8}`).join("\n")
+      capabilities: capabilities.map((c8) => `  - ${c8}`).join("\n"),
+      projectOpportunities: projectOpportunities.length > 0 ? projectOpportunities.map((o2) => `  - ${o2}`).join("\n") : "  (none detected this scan)"
     });
   } catch {
+    const oppText = projectOpportunities.length > 0 ? `
+
+Concrete project opportunities (prefer a small, testable capability task):
+${projectOpportunities.map((o2) => `  - ${o2}`).join("\n")}` : "";
     return `Gather observations about the agent's recent work:
-${competenceReport}
+${competenceReport}${oppText}
 
 Reflect on what went well and what could improve.`;
   }
@@ -656185,7 +656272,7 @@ function renderDMNResting(consecutiveNulls) {
   process.stdout.write(`  ${c3.dim("◌")} DMN resting — ${consecutiveNulls} cycles with nothing to do. Waiting for stimulus...
 `);
 }
-var DMNEngine;
+var execAsync3, DMNEngine;
 var init_dmn_engine = __esm({
   "packages/cli/src/tui/dmn-engine.ts"() {
     "use strict";
@@ -656196,6 +656283,7 @@ var init_dmn_engine = __esm({
     init_render();
     init_promptLoader3();
     init_tool_adapter();
+    execAsync3 = promisify8(exec6);
     DMNEngine = class {
       constructor(config, repoRoot) {
         this.config = config;
@@ -656213,12 +656301,17 @@ var init_dmn_engine = __esm({
         tasksGenerated: 0,
         consecutiveNulls: 0,
         competence: [],
-        reflectionBuffer: []
+        reflectionBuffer: [],
+        recentProposalFingerprints: [],
+        tasksGeneratedToday: 0,
+        dayStamp: ""
       };
       stateDir;
       historyDir;
       /** Recent task summaries — appended by the bless engine after each task */
       recentTaskSummaries = [];
+      /** A: the proposal returned by the most recent runCycle, awaiting its outcome. */
+      _lastProposal = null;
       /** Maximum consecutive null cycles before entering extended rest */
       maxConsecutiveNulls = 3;
       /** TUI writeContent callback — wraps stdout writes in scroll buffer management.
@@ -656246,9 +656339,11 @@ var init_dmn_engine = __esm({
         if (this.recentTaskSummaries.length > 10) {
           this.recentTaskSummaries.shift();
         }
-        if (category) {
-          this.updateCompetence(category, true);
+        const cat2 = category ?? this._lastProposal?.category;
+        if (cat2) {
+          this.updateCompetence(cat2, true);
         }
+        this._lastProposal = null;
         this.saveState();
       }
       /** Record a task failure for Reflexion-style learning */
@@ -656260,9 +656355,11 @@ var init_dmn_engine = __esm({
         if (this.state.reflectionBuffer.length > 5) {
           this.state.reflectionBuffer.shift();
         }
-        if (category) {
-          this.updateCompetence(category, false);
+        const cat2 = category ?? this._lastProposal?.category;
+        if (cat2) {
+          this.updateCompetence(cat2, false);
         }
+        this._lastProposal = null;
         this.saveState();
       }
       /** Update competence tracker for a task category */
@@ -656293,10 +656390,11 @@ var init_dmn_engine = __esm({
         this.state.totalCycles++;
         const cycleNum = this.state.totalCycles;
         const startMs = Date.now();
-        const [reminders, attention, memoryTopics] = await Promise.all([
+        const [reminders, attention, memoryTopics, projectOpportunities] = await Promise.all([
           this.gatherReminders(),
           this.gatherAttentionItems(),
-          this.gatherMemoryTopics()
+          this.gatherMemoryTopics(),
+          this.gatherProjectOpportunities()
         ]);
         const capabilities = [
           "file_read — read files",
@@ -656313,13 +656411,15 @@ var init_dmn_engine = __esm({
           memoryTopics,
           capabilities,
           this.state.competence,
-          this.state.reflectionBuffer
+          this.state.reflectionBuffer,
+          projectOpportunities
         );
         const modelTier2 = getModelTier(this.config.model);
         this.write(() => renderDMNCycleStart(cycleNum, modelTier2 === "large"));
         const useDeliberation = modelTier2 === "large";
         let result;
         let deliberationMeta = null;
+        let deliberationFallbackProposals = [];
         if (useDeliberation) {
           onEvent?.({
             type: "status",
@@ -656328,6 +656428,7 @@ var init_dmn_engine = __esm({
           });
           const delib = await this.runDeliberationCycle(prompt, memoryTopics, onEvent);
           result = { summary: delib.summary };
+          deliberationFallbackProposals = delib.workspace.proposals ?? [];
           deliberationMeta = {
             rounds: delib.workspace.rounds,
             evidence: delib.workspace.evidenceAccumulated,
@@ -656338,7 +656439,40 @@ var init_dmn_engine = __esm({
           result = { summary: mono.summary };
         }
         const durationMs = Date.now() - startMs;
-        const proposal = this.parseProposal(result.summary);
+        let proposal = this.parseProposal(result.summary, deliberationFallbackProposals);
+        const today2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+        if (this.state.dayStamp !== today2) {
+          this.state.dayStamp = today2;
+          this.state.tasksGeneratedToday = 0;
+        }
+        const dailyMax = (() => {
+          const raw = Number(process.env["OMNIUS_DMN_DAILY_TASK_MAX"]);
+          return Number.isFinite(raw) && raw >= 0 ? Math.floor(raw) : 12;
+        })();
+        if (proposal) {
+          const fp = this.fingerprintProposal(proposal);
+          const recent = this.state.recentProposalFingerprints ?? [];
+          if (recent.includes(fp)) {
+            onEvent?.({
+              type: "status",
+              content: "DMN: proposal already proposed recently — resting (dedup)",
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            proposal = null;
+          } else if ((this.state.tasksGeneratedToday ?? 0) >= dailyMax) {
+            onEvent?.({
+              type: "status",
+              content: `DMN: daily task budget reached (${dailyMax}) — resting`,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            proposal = null;
+          } else {
+            recent.push(fp);
+            if (recent.length > 20) recent.shift();
+            this.state.recentProposalFingerprints = recent;
+            this.state.tasksGeneratedToday = (this.state.tasksGeneratedToday ?? 0) + 1;
+          }
+        }
         const cycleResult = {
           cycleNumber: cycleNum,
           startedAt: new Date(startMs).toISOString(),
@@ -656362,6 +656496,7 @@ var init_dmn_engine = __esm({
         }
         this.state.lastCycleAt = (/* @__PURE__ */ new Date()).toISOString();
         this.saveState();
+        this._lastProposal = proposal;
         return proposal;
       }
       /** Run the DMN's internal LLM agent */
@@ -656625,14 +656760,15 @@ If the Amygdala flagged high urgency (due reminders, critical attention items),
 LOWER the threshold to 0.5 — urgent situations demand faster action even with
 less certainty (urgency-gating model, Cisek et al. 2009).
 
-OUTPUT: Call task_complete with JSON:
+OUTPUT: Call task_complete with JSON (the JSON object MUST be the FINAL thing you output):
 {
   "decision": "GO" | "NOGO",
   "evidenceScore": 0.X,
   "selectedTask": { task, rationale, provenance, category, confidence, challengeResult } | null,
   "reasoning": "how evidence from each region contributed to the decision",
   "innerVoice": "final self-talk summary — what the agent 'says to itself' before acting"
-}`, onEvent);
+}
+If decision is GO, selectedTask MUST be a fully-populated object (NEVER null) — copy the chosen proposal verbatim. A GO with selectedTask:null is invalid.`, onEvent);
         if (gateResult) {
           workspace.findings.push({
             from: "basal_ganglia",
@@ -656782,39 +656918,108 @@ OUTPUT: Call task_complete with JSON:
         };
       }
       /** Parse the DMN agent's output into a structured proposal */
-      parseProposal(summary) {
-        try {
-          const jsonMatch = summary.match(/\{[\s\S]*"selectedTask"[\s\S]*\}/);
-          if (!jsonMatch) return null;
-          const parsed = JSON.parse(jsonMatch[0]);
-          if (!parsed.selectedTask || parsed.selectedTask === null) return null;
-          const t2 = parsed.selectedTask;
-          return {
-            task: String(t2.task ?? ""),
-            rationale: String(t2.rationale ?? ""),
-            provenance: Array.isArray(t2.provenance) ? t2.provenance.map(String) : [],
-            category: ["directive", "exploration", "capability", "maintenance", "social", "autoresearch"].includes(t2.category) ? t2.category : "exploration",
-            confidence: typeof t2.confidence === "number" ? Math.min(1, Math.max(0, t2.confidence)) : 0.5,
-            challengeResult: t2.challengeResult ? String(t2.challengeResult) : void 0
-          };
+      /**
+       * B: layered, GO-aware, markdown-tolerant proposal extraction.
+       *
+       * The basal-ganglia gate emits `{decision, selectedTask, reasoning}` — but in
+       * production it has emitted a GO verdict with `selectedTask:null` or in
+       * markdown ("VERDICT: GO — Execute <name>"), which the old single-regex parser
+       * silently dropped to null (wasted deliberation). This recovers the GO target
+       * from the named task or the workspace proposals so a GO is never lost, while
+       * still resting on NOGO / NO_TASK.
+       */
+      parseProposal(summary, fallbackProposals = []) {
+        const coerce2 = (t2) => ({
+          task: String(t2["task"] ?? ""),
+          rationale: String(t2["rationale"] ?? ""),
+          provenance: Array.isArray(t2["provenance"]) ? t2["provenance"].map(String) : [],
+          category: ["directive", "exploration", "capability", "maintenance", "social", "autoresearch"].includes(t2["category"]) ? t2["category"] : "exploration",
+          confidence: typeof t2["confidence"] === "number" ? Math.min(1, Math.max(0, t2["confidence"])) : 0.5,
+          challengeResult: t2["challengeResult"] ? String(t2["challengeResult"]) : void 0
+        });
+        try {
+          const start2 = summary.indexOf("{");
+          const end = summary.lastIndexOf("}");
+          if (start2 >= 0 && end > start2) {
+            const parsed = JSON.parse(summary.slice(start2, end + 1));
+            const decision2 = String(parsed["decision"] ?? "").toUpperCase();
+            const t2 = parsed["selectedTask"];
+            if (decision2 === "NOGO") return null;
+            if (t2 && typeof t2 === "object" && String(t2["task"] ?? "").trim()) return coerce2(t2);
+          }
         } catch {
-          if (summary.includes("NO_TASK") || summary.toLowerCase().includes("no task")) {
-            return null;
+        }
+        if (/\bNO_?TASK\b/i.test(summary) || /\bNOGO\b/i.test(summary)) return null;
+        const go = /\bVERDICT\b[^\n]*\bGO\b/i.test(summary) || /\bdecision\b[^\n]*\bGO\b/i.test(summary);
+        if (go) {
+          const m2 = summary.match(/Execute[:\s]+[`"']?([A-Za-z0-9_./ -]{3,80})[`"']?/i);
+          const named = m2?.[1]?.trim();
+          if (named) {
+            const lc = named.toLowerCase();
+            const fromWs = fallbackProposals.find(
+              (p2) => p2.task.toLowerCase().includes(lc) || lc.includes(p2.task.toLowerCase().slice(0, 24))
+            );
+            if (fromWs) return fromWs;
+            return coerce2({
+              task: named,
+              rationale: "Recovered from GO verdict (markdown).",
+              provenance: ["dmn:go-verdict-recovery"],
+              category: fallbackProposals[0]?.category ?? "exploration",
+              confidence: 0.55
+            });
           }
-          const lines = summary.split("\n").filter((l2) => l2.trim().length > 20);
-          if (lines.length > 0) {
-            return {
-              task: lines[0].trim().slice(0, 500),
-              rationale: "Extracted from DMN natural language output",
-              provenance: ["dmn:natural-language-extraction"],
-              category: "exploration",
-              confidence: 0.3
-            };
+          if (fallbackProposals.length > 0) {
+            return [...fallbackProposals].sort((a2, b) => b.confidence - a2.confidence)[0];
           }
-          return null;
         }
+        return null;
       }
       // ── Context gathering helpers ──────────────────────────────────────────
+      /** Bounded read-only shell — never freezes a cycle (4s timeout, 1MB cap). */
+      async runBounded(cmd) {
+        try {
+          const { stdout } = await execAsync3(cmd, {
+            cwd: this.repoRoot,
+            timeout: 4e3,
+            maxBuffer: 1 << 20
+          });
+          return stdout ?? "";
+        } catch {
+          return "";
+        }
+      }
+      /**
+       * C: scan the actual repo for concrete development opportunities so the DMN
+       * proposes grounded capability work (implement a plan, fix a TODO, harden a
+       * recently-changed module) rather than abstract infra. All signals are cheap
+       * and bounded — never runs a heavy test suite here.
+       */
+      async gatherProjectOpportunities() {
+        const out = [];
+        const root = this.repoRoot;
+        try {
+          const plansDir = join154(root, ".aiwg", "plans");
+          if (existsSync142(plansDir)) {
+            for (const f2 of readdirSync51(plansDir).filter((p2) => p2.endsWith(".md")).slice(0, 8)) {
+              out.push(`Plan backlog: implement .aiwg/plans/${f2}`);
+            }
+          }
+          const todos = await this.runBounded(
+            `rg -n --no-heading -e "TODO|FIXME" -g "*.ts" -g "*.py" packages src 2>/dev/null | head -12`
+          );
+          for (const line of todos.split("\n").filter(Boolean).slice(0, 8)) {
+            out.push(`Code gap: ${line.slice(0, 160)}`);
+          }
+          const churn = await this.runBounded(
+            `git diff --name-only HEAD~5 2>/dev/null | head -10`
+          );
+          for (const f2 of churn.split("\n").filter(Boolean).slice(0, 6)) {
+            out.push(`Recently changed (consider hardening/tests): ${f2}`);
+          }
+        } catch {
+        }
+        return [...new Set(out)].slice(0, 14);
+      }
       async gatherReminders() {
         try {
           const reminders = await getDueReminders(this.repoRoot);
@@ -656917,6 +657122,16 @@ OUTPUT: Call task_complete with JSON:
           }
         }
       }
+      /** F1: stable fingerprint of a proposal for dedup (category + task + rationale). */
+      fingerprintProposal(p2) {
+        const normalized = cleanForStorage(`${p2.category} ${p2.task} ${p2.rationale}`).toLowerCase().replace(/\d+/g, "#").replace(/\s+/g, " ").trim().slice(0, 600);
+        let hash = 2166136261;
+        for (let i2 = 0; i2 < normalized.length; i2++) {
+          hash ^= normalized.charCodeAt(i2);
+          hash = Math.imul(hash, 16777619);
+        }
+        return (hash >>> 0).toString(16);
+      }
       fingerprintCycle(result) {
         const selected = result.selectedTask ? [
           result.selectedTask.category,
@@ -712089,10 +712304,10 @@ ${incompleteList}${more}
             const scripts = pkg.scripts || {};
             const checkScript = scripts["typecheck"] ? "typecheck" : scripts["build"] ? "build" : null;
             if (checkScript) {
-              const { exec: exec6 } = await import("node:child_process");
-              const { promisify: promisify8 } = await import("node:util");
+              const { exec: exec7 } = await import("node:child_process");
+              const { promisify: promisify9 } = await import("node:util");
               try {
-                await promisify8(exec6)(`npm run ${checkScript} --silent 2>&1`, {
+                await promisify9(exec7)(`npm run ${checkScript} --silent 2>&1`, {
                   cwd: cwd4,
                   timeout: 12e4,
                   encoding: "utf-8",
@@ -713294,6 +713509,10 @@ Meta-critique: quality ${meta.quality}/5, thorough: ${meta.thorough}`;
     }
   };
 }
+function dmnDevDiscipline(category) {
+  if (category !== "capability") return "";
+  return "\n\nYou are acting as a self-directed developer. Work on a NEW git branch. Implement the change, then make the project's tests pass for what you touched. Do NOT call task_complete until the change is implemented AND its tests pass AND the result is evidenced (the completion gates will block an unverified claim). If the change is not feasible, stop with a BLOCKED: summary explaining why.";
+}
 function gatherMemorySnippets(root) {
   const snippets = [];
   const dirs = [
@@ -713402,36 +713621,28 @@ function buildNewTaskIntakePacket(ingress, interpretation, previousPrompt, previ
 function createDMNEventHandler(verbose, writeContent) {
   return (event) => {
     switch (event.type) {
+      // DMN tool activity renders in the SAME unicode boxes + format as regular
+      // (main-loop) tool calls for consistent observability — the verbose flag
+      // controls detail exactly as in the main loop, not whether the box shows.
+      // The DMN remains automatic/self-directed; only its rendering is unified.
       case "tool_call":
-        if (verbose) {
-          writeContent(() => {
-            const args = event.toolArgs ?? {};
-            renderToolCallStart(event.toolName ?? "unknown", args, true);
-          });
-        } else {
-          const argSummary = formatDMNToolArgs(
-            event.toolName ?? "",
-            event.toolArgs ?? {}
-          );
-          writeContent(
-            () => process.stdout.write(
-              `    ${c3.dim(`DMN → ${event.toolName}`)}${argSummary ? c3.dim(`: ${argSummary}`) : ""}
-`
-            )
+        writeContent(() => {
+          renderToolCallStart(
+            event.toolName ?? "unknown",
+            event.toolArgs ?? {},
+            verbose
           );
-        }
+        });
         break;
       case "tool_result":
-        if (verbose) {
-          writeContent(() => {
-            renderToolResult(
-              event.toolName ?? "unknown",
-              event.success ?? false,
-              event.content ?? "",
-              true
-            );
-          });
-        }
+        writeContent(() => {
+          renderToolResult(
+            event.toolName ?? "unknown",
+            event.success ?? false,
+            event.content ?? "",
+            verbose
+          );
+        });
         break;
       case "model_response":
         if (verbose && event.content) {
@@ -713468,27 +713679,6 @@ ${event.content}`
     }
   };
 }
-function formatDMNToolArgs(toolName, args) {
-  switch (toolName) {
-    case "memory_read":
-    case "memory_search":
-      return String(args["topic"] ?? args["query"] ?? "").slice(0, 60);
-    case "file_read":
-      return String(args["path"] ?? "").slice(0, 80);
-    case "list_directory":
-      return String(args["path"] ?? ".").slice(0, 80);
-    case "shell":
-      return String(args["command"] ?? "").slice(0, 80);
-    case "memory_write":
-      return `${args["topic"] ?? ""}.${args["key"] ?? ""}`;
-    case "grep_search":
-      return String(args["pattern"] ?? "").slice(0, 60);
-    case "find_files":
-      return String(args["pattern"] ?? "").slice(0, 60);
-    default:
-      return "";
-  }
-}
 function truncateByLines(text2, maxLines, maxChars = 600) {
   const lines = text2.split("\n");
   if (lines.length <= maxLines && text2.length <= maxChars) return text2;
@@ -715419,7 +715609,8 @@ When done, either call task_complete with your answer, or use FINAL_VAR(variable
                 turns: result.turns,
                 toolCalls: result.toolCalls,
                 durationMs: result.durationMs,
-                model: config.model
+                model: config.model,
+                verified: result.completed === true
               });
             _tasksSinceImprove++;
             if (_tasksSinceImprove >= SELF_IMPROVE_INTERVAL) {
@@ -716680,6 +716871,7 @@ ${result.summary}`
   let dreamEngine = null;
   let blessEngine = null;
   let dmnEngine = null;
+  let dmnOriginatedTask = false;
   const snrEngine = new SNREngine(currentConfig, repoRoot);
   const emotionEngine = new EmotionEngine({
     backendUrl: currentConfig.backendUrl,
@@ -716773,7 +716965,8 @@ Respond concisely and safely.`;
 
 ${proposal.task}
 
-Rationale: ${proposal.rationale}${provenanceNote}`;
+Rationale: ${proposal.rationale}${provenanceNote}${dmnDevDiscipline(proposal.category)}`;
+          dmnOriginatedTask = true;
           writeContent(
             () => renderInfo(
               `DMN auto-cycle: ${proposal.category} task (${Math.round(proposal.confidence * 100)}% confidence)`
@@ -721327,8 +721520,8 @@ ${taskInput}`;
         const updateInfo = await checkForUpdate(version4);
         if (updateInfo) {
           _autoUpdatedThisSession = true;
-          const { exec: exec6 } = await import("node:child_process");
-          exec6(
+          const { exec: exec7 } = await import("node:child_process");
+          exec7(
             `npm install -g omnius@latest --prefer-online`,
             { timeout: 18e4 },
             (err) => {
@@ -721385,7 +721578,18 @@ ${emotion.emoji} ${emotion.label}`);
     }
     if (blessEngine?.isActive) {
       blessEngine.recordTaskComplete();
-      if (dmnEngine && lastCompletedSummary) {
+      if (dmnEngine && dmnOriginatedTask && lastCompletedSummary) {
+        const verified = lastTaskMeta?.verified === true;
+        if (verified) {
+          dmnEngine.recordTaskCompletion(lastCompletedSummary);
+        } else {
+          dmnEngine.recordTaskFailure(
+            lastCompletedSummary,
+            "run did not pass the completion/resolution gates (unverified)"
+          );
+        }
+        dmnOriginatedTask = false;
+      } else if (dmnEngine && lastCompletedSummary) {
         dmnEngine.recordTaskCompletion(lastCompletedSummary);
       }
       const nextTask = await blessEngine.getNextTask();
@@ -721430,7 +721634,8 @@ Respond concisely and safely.`;
 
 ${proposal.task}
 
-Rationale: ${proposal.rationale}${provenanceNote}`;
+Rationale: ${proposal.rationale}${provenanceNote}${dmnDevDiscipline(proposal.category)}`;
+            dmnOriginatedTask = true;
             writeContent(
               () => renderInfo(
                 `DMN auto-cycle: ${proposal.category} task (${Math.round(proposal.confidence * 100)}% confidence)`

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.355",
+  "version": "1.0.357",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.355",
+      "version": "1.0.357",
       "bundleDependencies": [
         "image-to-ascii"
       ],
@@ -5354,9 +5354,9 @@
       }
     },
     "node_modules/node-addon-api": {
-      "version": "8.8.0",
-      "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-8.8.0.tgz",
-      "integrity": "sha512-c5Ko1fZJIJmzhFIkhRN76WTq+fC6tWnGy9CXA0fA+XygsWZmEwG8vmbkNqxMyoaa0Tin4djul49NzdVcJJcjeA==",
+      "version": "8.9.0",
+      "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-8.9.0.tgz",
+      "integrity": "sha512-ekZMeaaIzSQTSpr7X2X3iJM7lTzgnx8ahAG9pJfT/7+14mlEM8ZYQ9cgCDvSSRbReFK0oHli3WrZdCiRsgAT9Q==",
       "license": "MIT",
       "optional": true,
       "engines": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.355",
+  "version": "1.0.357",
   "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/dmn-gather.md

@@ -45,6 +45,9 @@ Known memory topics:
 Available capabilities:
 {{capabilities}}
 
+Concrete project opportunities (grounded in THIS repo — open plans, TODO/FIXME, recently-changed files):
+{{projectOpportunities}}
+
 ═══════════════════════════════════════════════════════════════════════════
 
 PHASE 2: REFLECT, CONSOLIDATE & REASON (Generative Agents + Reflexion)
@@ -75,11 +78,23 @@ propose tasks at the FRONTIER of current capabilities — neither too easy
 (already mastered) nor too hard (no chance of success). Check the competence
 tracker to calibrate difficulty.
 
+PREFER DEVELOPMENT. You are a self-directed developer of THIS project. When
+concrete project opportunities exist above, PREFER a `capability` task that
+implements or hardens one of them (a small, shippable, testable improvement to
+this codebase) over abstract exploration/infra. Quote the specific
+file/plan/TODO in `provenance`.
+
+Curriculum progression (Voyager Goldilocks, driven by the competence tracker):
+- If a category's success rate is HIGH (≥70% over ≥3 attempts), propose a
+  LARGER / harder task in it — escalate scope.
+- If LOW (<40%), pick a SMALLER-scoped task or a different category — back off.
+- NEVER repeat a task that recently failed (see the Reflexion buffer above).
+
 For each candidate, specify:
 - The task description (specific, actionable, measurable)
 - Rationale (why this task, what led you to it)
 - Provenance (which memories, directives, or signals informed this)
-- Category: directive | exploration | capability | maintenance | social
+- Category: directive | exploration | capability | maintenance | social | autoresearch
 - Confidence (0-1, calibrated against competence data)
 
 ═══════════════════════════════════════════════════════════════════════════