omnius 1.0.356 → 1.0.358

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();
@@ -567542,6 +567542,27 @@ var init_completion_resolution_verifier = __esm({
 });
 
 // packages/orchestrator/dist/evidenceBranch.js
+function buildStructuralPreview2(lines, path12, query) {
+  const n2 = lines.length;
+  const clip3 = (l2) => l2.length > 180 ? l2.slice(0, 180) + "…" : l2;
+  const head = lines.slice(0, HEAD_LINES2).map((l2, i2) => `${i2 + 1}: ${clip3(l2)}`);
+  const isStructural = (l2) => /^\s*(<[A-Za-z!]|#{1,6}\s|def |class |function |export |interface |type |async |public |private |\[[^\]]+\]|[A-Za-z_][\w.]*\s*=)/.test(l2) && l2.trim().length > 0 && l2.trim().length <= 180;
+  const markers = [];
+  for (let i2 = HEAD_LINES2; i2 < n2; i2++) {
+    const l2 = lines[i2];
+    if (isStructural(l2))
+      markers.push(`${i2 + 1}: ${clip3(l2.trim())}`);
+  }
+  const MAX_MARKERS = 30;
+  const sampled = markers.length > MAX_MARKERS ? Array.from({ length: MAX_MARKERS }, (_, k) => markers[Math.floor(k * markers.length / MAX_MARKERS)]) : markers;
+  return [
+    `[STRUCTURAL PREVIEW] "${query}" was not directly located in ${path12} (${n2} lines). Navigate by the structure below and re-read a SPECIFIC region with offset/limit — do NOT re-read the whole file:`,
+    "Head:",
+    ...head,
+    sampled.length ? "Section markers (line: content):" : "(no clear section markers)",
+    ...sampled
+  ].filter(Boolean).join("\n").slice(0, 1600);
+}
 function queryTerms(query) {
   return [
     ...new Set(query.toLowerCase().replace(/[^a-z0-9_<>./-]+/g, " ").split(/\s+/).filter((w) => w.length > 2 && !STOPWORDS2.has(w)))
@@ -567692,17 +567713,20 @@ async function extractEvidence(opts) {
       const ends = kept.map((s2) => s2.end);
       const snippetLower = claim2.toLowerCase();
       const covered = terms2.filter((t2) => snippetLower.includes(t2)).length;
-      return {
-        path: path12,
-        query,
-        claim: claim2,
-        sourceStart: starts.length ? Math.min(...starts) : null,
-        sourceEnd: ends.length ? Math.max(...ends) : null,
-        fileVersion,
-        confidence: Math.min(1, covered / Math.max(1, terms2.length)),
-        exploredLines: lines.length,
-        injectedChars: claim2.length
-      };
+      const grepConfidence = Math.min(1, covered / Math.max(1, terms2.length));
+      if (grepConfidence >= EXTRACT_CONFIDENCE_FLOOR) {
+        return {
+          path: path12,
+          query,
+          claim: claim2,
+          sourceStart: starts.length ? Math.min(...starts) : null,
+          sourceEnd: ends.length ? Math.max(...ends) : null,
+          fileVersion,
+          confidence: grepConfidence,
+          exploredLines: lines.length,
+          injectedChars: claim2.length
+        };
+      }
     }
   }
   const windows = lines.length <= WINDOW_LINES * 2 ? [{ start: 1, end: lines.length, text: content, score: 1 }] : selectWindows(lines, terms2);
@@ -567725,7 +567749,7 @@ async function extractEvidence(opts) {
       parsed = null;
     }
   }
-  const claim = parsed && parsed.found && parsed.claim ? parsed.claim : `No evidence for "${query}" found in the explored windows of ${path12}.`;
+  const claim = parsed && parsed.found && parsed.claim ? parsed.claim : buildStructuralPreview2(lines, path12, query);
   return {
     path: path12,
     query,
@@ -567743,7 +567767,7 @@ function shouldBranchRead(contentLength, lineCount, hasExplicitSmallRange, thres
     return false;
   return contentLength > thresholdChars || lineCount > 200;
 }
-var WINDOW_LINES, SNIPPET_CONTEXT, HEAD_LINES2, MAX_SNIPPET_LINES, STOPWORDS2;
+var WINDOW_LINES, SNIPPET_CONTEXT, HEAD_LINES2, MAX_SNIPPET_LINES, EXTRACT_CONFIDENCE_FLOOR, STOPWORDS2;
 var init_evidenceBranch = __esm({
   "packages/orchestrator/dist/evidenceBranch.js"() {
     "use strict";
@@ -567751,6 +567775,7 @@ var init_evidenceBranch = __esm({
     SNIPPET_CONTEXT = 4;
     HEAD_LINES2 = 10;
     MAX_SNIPPET_LINES = 220;
+    EXTRACT_CONFIDENCE_FLOOR = 0.3;
     STOPWORDS2 = /* @__PURE__ */ new Set([
       "the",
       "and",
@@ -615029,35 +615054,105 @@ ${CONTENT_BG_SEQ}`);
           (seq) => seq.endsWith("m") ? seq : ""
         );
       }
-      reflowContentLines(livePartialLine, width) {
+      /** Resolve a dynamic-block sentinel line to its registered renderer's lines
+       *  at the given width, or null if it is not a (live) sentinel. */
+      dynamicBlockLines(line, maxWidth) {
+        if (!line.startsWith(this.DYNAMIC_BLOCK_MARK_PREFIX) || !line.endsWith(this.DYNAMIC_BLOCK_MARK_SUFFIX)) {
+          return null;
+        }
+        const id = line.slice(
+          this.DYNAMIC_BLOCK_MARK_PREFIX.length,
+          line.length - this.DYNAMIC_BLOCK_MARK_SUFFIX.length
+        );
+        const renderer = this._dynamicBlocks.get(id);
+        if (!renderer) return [];
+        try {
+          return renderer(maxWidth);
+        } catch {
+          return [];
+        }
+      }
+      /** Reflowed-row COUNT for one buffer line at width — dynamic-block aware.
+       *  Static lines are a cache-hit `.length` (no allocation), so the count pass
+       *  over the whole backlog is cheap. */
+      rowCountForSourceLine(line, maxWidth) {
+        const block = this.dynamicBlockLines(line, maxWidth);
+        if (block !== null) {
+          let n2 = 0;
+          for (const seg of block) n2 += this.reflowContentLine(seg, maxWidth).length;
+          return n2;
+        }
+        return this.reflowContentLine(line, maxWidth).length;
+      }
+      /** Reflowed rows (with bufferIdx) for one buffer line — built ONLY for the
+       *  lines actually inside the viewport window. */
+      rowsForSourceLine(line, idx, maxWidth) {
+        const block = this.dynamicBlockLines(line, maxWidth);
+        if (block !== null) {
+          return block.flatMap(
+            (seg) => this.reflowContentLine(seg, maxWidth).map((s2) => ({
+              line: s2,
+              bufferIdx: idx
+            }))
+          );
+        }
+        return this.reflowContentLine(line, maxWidth).map((segment) => ({
+          line: segment,
+          bufferIdx: idx
+        }));
+      }
+      /** Total reflowed row count at width (cheap — cache-hit counts, no big array
+       *  allocation). Used for scroll bounds. */
+      reflowedRowCount(livePartialLine, width) {
         const maxWidth = Math.max(16, width);
         const source = livePartialLine ? [...this._contentLines, livePartialLine] : this._contentLines;
-        return source.flatMap((line, idx) => {
-          if (line.startsWith(this.DYNAMIC_BLOCK_MARK_PREFIX) && line.endsWith(this.DYNAMIC_BLOCK_MARK_SUFFIX)) {
-            const id = line.slice(
-              this.DYNAMIC_BLOCK_MARK_PREFIX.length,
-              line.length - this.DYNAMIC_BLOCK_MARK_SUFFIX.length
-            );
-            const renderer = this._dynamicBlocks.get(id);
-            if (!renderer) return [];
-            let blockLines;
-            try {
-              blockLines = renderer(maxWidth);
-            } catch {
-              return [];
-            }
-            return blockLines.flatMap(
-              (segment) => this.reflowContentLine(segment, maxWidth).map((s2) => ({
-                line: s2,
-                bufferIdx: idx
-              }))
-            );
-          }
-          return this.reflowContentLine(line, maxWidth).map((segment) => ({
-            line: segment,
-            bufferIdx: idx
-          }));
-        });
+        let total = 0;
+        for (let i2 = 0; i2 < source.length; i2++) {
+          total += this.rowCountForSourceLine(source[i2], maxWidth);
+        }
+        return total;
+      }
+      /**
+       * VIRTUALIZED reflow — produce ONLY the viewport window's rows (the visible
+       * `viewportRows` reflowed rows at the given scroll offset). Repaint cost is
+       * O(viewport + dynamic blocks) instead of O(scrollback), so a long session
+       * never re-wraps the whole 10k-line backlog on every paint (the lag-after-
+       * thousands-of-lines stall). Returns the window rows IN ORDER (index 0 = top
+       * visible row), the total row count (for the scrollbar/bounds), and the
+       * clamped scroll offset.
+       */
+      reflowContentWindow(livePartialLine, width, viewportRows, scrollOffset) {
+        const maxWidth = Math.max(16, width);
+        const source = livePartialLine ? [...this._contentLines, livePartialLine] : this._contentLines;
+        const h = Math.max(0, viewportRows);
+        let totalRows = 0;
+        const counts = new Array(source.length);
+        for (let i2 = 0; i2 < source.length; i2++) {
+          const c8 = this.rowCountForSourceLine(source[i2], maxWidth);
+          counts[i2] = c8;
+          totalRows += c8;
+        }
+        const maxOffset = Math.max(0, totalRows - h);
+        const off = scrollOffset < 0 ? 0 : scrollOffset > maxOffset ? maxOffset : scrollOffset;
+        const startIdx = Math.max(0, totalRows - h - off);
+        const endIdx = startIdx + h;
+        const rows = [];
+        let cursor = 0;
+        for (let i2 = 0; i2 < source.length && cursor < endIdx; i2++) {
+          const c8 = counts[i2];
+          const lineStart = cursor;
+          cursor += c8;
+          if (cursor <= startIdx) continue;
+          if (lineStart >= endIdx) break;
+          const lr = this.rowsForSourceLine(source[i2], i2, maxWidth);
+          const from3 = Math.max(0, startIdx - lineStart);
+          const to = Math.min(c8, endIdx - lineStart);
+          for (let k = from3; k < to; k++) {
+            const r2 = lr[k];
+            if (r2) rows.push(r2);
+          }
+        }
+        return { rows, totalRows, startIdx, scrollOffset: off };
       }
       // Memoize per-line reflow: it is a PURE function of (line, width), and
       // reflowContentLines re-wraps the entire scrollback every repaint. Caching
@@ -615201,7 +615296,7 @@ ${CONTENT_BG_SEQ}`);
       maxContentScrollOffset(width = termCols(), livePartialLine = this.getLiveBufferedLine()) {
         return Math.max(
           0,
-          this.reflowContentLines(livePartialLine, width).length - this.contentHeight
+          this.reflowedRowCount(livePartialLine, width) - this.contentHeight
         );
       }
       clampContentScrollOffset(width = termCols()) {
@@ -615330,26 +615425,30 @@ ${CONTENT_BG_SEQ}`);
         const w = termCols();
         const _perfOn = process.env["OMNIUS_TUI_PERF"] === "1";
         const _t0 = _perfOn ? performance.now() : 0;
-        const reflowedLines = this.reflowContentLines(livePartialLine, w);
+        const win = this.reflowContentWindow(
+          livePartialLine,
+          w,
+          h,
+          this._contentScrollOffset
+        );
+        const reflowedLines = win.rows;
         if (_perfOn) {
           const _ms = performance.now() - _t0;
           if (_ms > 8) {
             try {
               process.stderr.write(
-                `[TUI-PERF] reflow ${_ms.toFixed(1)}ms (lines=${reflowedLines.length}, w=${w})
+                `[TUI-PERF] reflow ${_ms.toFixed(1)}ms (window=${win.rows.length}/${win.totalRows} rows, w=${w})
 `
               );
             } catch {
             }
           }
         }
-        const totalLines = reflowedLines.length;
-        const maxOffset = Math.max(0, totalLines - h);
-        if (this._contentScrollOffset > maxOffset) {
-          this._contentScrollOffset = maxOffset;
+        if (win.scrollOffset !== this._contentScrollOffset) {
+          this._contentScrollOffset = win.scrollOffset;
           if (this._contentScrollOffset === 0) this._autoScroll = true;
         }
-        const startIdx = Math.max(0, totalLines - h - this._contentScrollOffset);
+        const startIdx = 0;
         this._lastPaintReflow = reflowedLines;
         this._lastPaintStartIdx = startIdx;
         const headerSafeFloor = layout().headerBottom + 1;
@@ -615402,8 +615501,8 @@ ${CONTENT_BG_SEQ}`);
           }
         }
         if (this._contentScrollOffset > 0) {
-          const linesAbove = startIdx;
-          const pct = totalLines > 0 ? Math.round((startIdx + h) / totalLines * 100) : 100;
+          const linesAbove = win.startIdx;
+          const pct = win.totalRows > 0 ? Math.round((win.startIdx + h) / win.totalRows * 100) : 100;
           const indicator = ` ↑ ${linesAbove} lines above · ${pct}% · PgDn/End to return `;
           const pad = Math.max(0, w - indicator.length);
           buf += `\x1B[${this.scrollRegionTop};1H\x1B[7m${indicator}${" ".repeat(pad)}\x1B[0m`;
@@ -647510,9 +647609,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",
@@ -648259,7 +648358,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)
@@ -648323,7 +648422,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)
@@ -656183,7 +656282,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`;
@@ -656197,11 +656298,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.`;
   }
@@ -656265,7 +656371,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";
@@ -656276,6 +656382,7 @@ var init_dmn_engine = __esm({
     init_render();
     init_promptLoader3();
     init_tool_adapter();
+    execAsync3 = promisify8(exec6);
     DMNEngine = class {
       constructor(config, repoRoot) {
         this.config = config;
@@ -656293,12 +656400,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.
@@ -656326,9 +656438,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 */
@@ -656340,9 +656454,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 */
@@ -656373,10 +656489,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",
@@ -656393,13 +656510,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",
@@ -656408,6 +656527,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,
@@ -656418,7 +656538,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(),
@@ -656442,6 +656595,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 */
@@ -656705,14 +656859,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",
@@ -656862,39 +657017,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);
@@ -656997,6 +657221,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,
@@ -662172,18 +662406,27 @@ function deriveVisualEvidencePlan(request) {
   const needsText = /\b(text|read|ocr|extract|label|word|number|what does it say|transcript|character|letter|digit|spell|transcribe|copy|quote|type|what is written)\b/i.test(prompt);
   const needsScene = /\b(what|who|where|describe|scene|object|person|identify|tell me about|explain|see|show|happening|look like|recogniz)\b/i.test(prompt) && !needsText;
   const needsUI = /\b(ui|button|menu|dialog|window|interface|screen|dashboard|form|field|input|select|option|dropdown)\b/i.test(prompt);
+  const comprehensive = (reason) => ({
+    stages: [
+      { kind: "low_fidelity_observation", required: false },
+      { kind: "ocr", required: true },
+      { kind: "auxiliary_vision", required: true }
+    ],
+    reason
+  });
   switch (detail) {
     case "low":
-      return { stages: [{ kind: "low_fidelity_observation", required: true }], reason: "low detail requested" };
+      return { stages: [{ kind: "low_fidelity_observation", required: true }], reason: "low detail explicitly requested" };
     case "text":
-      return { stages: [{ kind: "low_fidelity_observation", required: false }, { kind: "ocr", required: true }, { kind: "auxiliary_vision", required: false }], reason: "text extraction requested" };
+      return comprehensive("text extraction requested — full vision still runs for classification");
+    case "visual":
+      return comprehensive("visual analysis requested");
     case "full":
-      return { stages: [{ kind: "low_fidelity_observation", required: false }, { kind: "ocr", required: needsText || needsUI }, { kind: "auxiliary_vision", required: true }], reason: "full detail requested" };
+      return comprehensive("full detail requested");
     default:
-      const stages = [{ kind: "low_fidelity_observation", required: false }];
-      if (needsText || needsUI) stages.push({ kind: "ocr", required: true });
-      if (needsScene || needsUI) stages.push({ kind: "auxiliary_vision", required: !needsText && !needsUI });
-      return { stages, reason: needsText ? "text evidence needed" : needsScene ? "scene analysis needed" : needsUI ? "UI/document analysis needed" : "auto" };
+      return comprehensive(
+        needsText ? "comprehensive (text emphasis)" : needsScene ? "comprehensive (scene emphasis)" : needsUI ? "comprehensive (UI/document emphasis)" : "comprehensive (full vision + OCR on all media)"
+      );
   }
 }
 async function executeVisualEvidencePlan(resolution, plan, executor) {
@@ -662227,6 +662470,7 @@ __export(vision_ingress_exports, {
   isTesseractAvailable: () => isTesseractAvailable,
   isVisionModel: () => isVisionModel,
   queryVisionModel: () => queryVisionModel,
+  resolveVisionModel: () => resolveVisionModel,
   runVisionIngress: () => runVisionIngress
 });
 import { execFileSync as execFileSync10 } from "node:child_process";
@@ -662355,25 +662599,32 @@ async function queryVisionModel(modelName, imagePath, prompt = "Describe what yo
     return "";
   }
 }
+function resolveVisionModel(currentModel) {
+  if (currentModel && isVisionModel(currentModel)) return currentModel;
+  const env2 = (process.env["OMNIUS_VISION_MODEL"] || "").trim();
+  if (env2) return env2;
+  return "moondream";
+}
 async function runVisionIngress(image, currentModel) {
   const ocrText = advancedOcr(image.path);
   let visionDescription = "";
   let visionUsed = false;
-  if (currentModel && isVisionModel(currentModel)) {
-    visionDescription = await queryVisionModel(currentModel, image.path);
+  const visionModel = resolveVisionModel(currentModel);
+  if (visionModel) {
+    visionDescription = await queryVisionModel(visionModel, image.path);
     visionUsed = visionDescription.length > 0;
   }
   const parts = [];
   if (ocrText.length > 0) {
-    parts.push(`[OCR Text from pasted image]
+    parts.push(`[OCR Text from image]
 ${ocrText}`);
   }
   if (visionDescription.length > 0) {
-    parts.push(`[Vision analysis of pasted image (model: ${currentModel})]
+    parts.push(`[Vision analysis of image (model: ${visionModel})]
 ${visionDescription}`);
   }
   if (parts.length === 0) {
-    parts.push(`[Image pasted at ${image.path} — no text detected by OCR, no vision model available for analysis]`);
+    parts.push(`[Image at ${image.path} — OCR found no text and the vision model (${visionModel}) returned no description; treat as UNCOMPREHENDED and re-run telegram_image_analyze with detail='full' before answering.]`);
   }
   const contextBlock = parts.join("\n\n");
   return {
@@ -665062,7 +665313,7 @@ Public Telegram vision and media stack
 
 Public Telegram runs have the full scoped media-analysis stack for media posted in this chat:
 - Use telegram_media_recent to find recent scoped media, then use path/media aliases 'reply' and 'latest' instead of exposing local paths to users.
-- For image questions, prefer telegram_image_analyze first. It resolves omitted/reply/latest media, starts with low-fidelity image intake, uses basic OCR as the text extraction probe, escalates to advanced OCR when text is dense or under-extracted, and escalates to Moondream vision when visual QA/captioning is needed.
+- MANDATORY: whenever one or more images are present (posted, replied-to, or recent), run a FULL comprehension pass on EVERY image BEFORE responding — telegram_image_analyze with detail='full' (advanced OCR + Moondream vision) on each; if a burst of images was posted, enumerate them with telegram_media_recent and analyze ALL of them. Base the answer ONLY on the extracted content (objects, scene, any text). NEVER answer from metadata alone (count, size, timestamp, caption), never claim you can't say what's pictured without running vision, and never offer to analyze only "the ones you care about" — full vision on all of them IS the job. Do not stop until every image is fully comprehended.
 - Use ocr for quick image text extraction, ocr_image_advanced when basic OCR shows dense or degraded text, image_read for image metadata + multimodal image payload, and vision for direct Moondream captioning, visual QA, object detection, or pointing.
 - Use pdf_to_text for embedded-text PDFs and ocr_pdf for scanned PDFs.
 - Use video_understand and transcribe_file for video/audio media posted in this chat.
@@ -675775,7 +676026,7 @@ ${currentTelegramPrompt}`;
             TELEGRAM_LINK_INTEGRITY_CONTRACT,
             "If a user explicitly states a durable preference for reply cadence/order, call telegram_preference_set. Do not infer or classify reply-mode preferences from keywords, style, tone, or task type.",
             TELEGRAM_EVIDENCE_SUFFICIENCY_CONTRACT,
-            "You have the full scoped Telegram media-analysis stack by default: telegram_image_analyze, telegram_media_recent, image_read, ocr, ocr_image_advanced, vision, pdf_to_text, ocr_pdf, transcribe_file, video_understand, audio_analyze, and identity_memory. For image questions, prefer telegram_image_analyze first; it resolves omitted/reply/latest media, starts with low-fidelity image intake, uses basic OCR as the text extraction probe, escalates to advanced OCR when text is dense or under-extracted, and escalates to Moondream vision when visual QA/captioning is needed.",
+            "You have the full scoped Telegram media-analysis stack by default: telegram_image_analyze, telegram_media_recent, image_read, ocr, ocr_image_advanced, vision, pdf_to_text, ocr_pdf, transcribe_file, video_understand, audio_analyze, and identity_memory. MANDATORY image handling: whenever one or more images are present in the message (or a referenced/recent message), you MUST run a FULL comprehension pass on EVERY image before you respond — call telegram_image_analyze with detail='full' (advanced OCR + Moondream vision) on each, and if multiple images were sent in a burst, analyze ALL of them (use telegram_media_recent to enumerate them). Base your answer ONLY on the actual extracted content (objects, scene, and any text). NEVER answer from metadata alone (count, file size, timestamp, caption) and NEVER say you 'can't say what's pictured without running vision' or offer to analyze 'the ones you care about' — running full vision on all of them IS your job. Do not stop until every image is fully comprehended; if a pass returns nothing, retry with detail='full' or image_read+ocr_image_advanced+vision before concluding.",
             formatIdentityMemoryContext(chatLabel || "Telegram private chat"),
             reminderToolContract,
             "If the user asks you to create an image, audio file, video, 3D/CAD model, or document artifact, create it with the scoped creative tools. Freshly generated artifacts are recorded and automatically attached to this Telegram chat when the turn completes, so do not call telegram_send_file for those same artifacts unless the user asked for a specific caption, existing/unrecorded file, or non-default target.",
@@ -679615,7 +679866,7 @@ ${knownList}` : "Private-user telegram_send_file target must be this DM or a kno
        * Downloads the file, runs it through the appropriate pipeline,
        * caches it, and returns a text description for the agent.
        */
-      async processMedia(msg, source = "message") {
+      async processMedia(msg, source = "message", eager = false) {
         const media = source === "reply" ? msg.replyToMedia : msg.media;
         if (!media) return "";
         const { type, fileId, fileUniqueId, mimeType, caption } = media;
@@ -679624,6 +679875,12 @@ ${knownList}` : "Private-user telegram_send_file target must be this DM or a kno
         const sourceLabel = source === "reply" ? "replied-to " : "";
         const mediaAlias = sourceMessageId ? `message_id:${sourceMessageId}` : source === "reply" ? "reply" : "latest";
         const safeCaption = caption ? ` — caption: ${telegramContextJsonString(caption, 220)}` : "";
+        const cacheKey = `${String(msg.chatId)}:${String(sourceMessageId ?? 0)}:${fileUniqueId}`;
+        const existingEntry = this.mediaCache.get(cacheKey);
+        if (existingEntry && existsSync146(existingEntry.localPath)) {
+          existingEntry.cachedAt = Date.now();
+          return existingEntry.extractedContent || `[${sourceLabel}${type} received: path_alias=${mediaAlias}${safeCaption}]`;
+        }
         let ext = ".bin";
         if (isImageMedia) ext = telegramImageExtension(media);
         else if (type === "audio" || type === "voice") ext = ".ogg";
@@ -679647,10 +679904,7 @@ ${knownList}` : "Private-user telegram_send_file target must be this DM or a kno
           caption,
           cachedAt: Date.now()
         };
-        this.mediaCache.set(
-          `${String(msg.chatId)}:${String(sourceMessageId ?? 0)}:${fileUniqueId}`,
-          cacheEntry
-        );
+        this.mediaCache.set(cacheKey, cacheEntry);
         const metadataKey = String(msg.chatId);
         if (!this.mediaMetadata.has(metadataKey)) {
           this.mediaMetadata.set(metadataKey, []);
@@ -679663,7 +679917,7 @@ ${knownList}` : "Private-user telegram_send_file target must be this DM or a kno
           username: msg.username
         });
         let description = `[${type}${caption ? `: ${caption}` : ""}]`;
-        if (isImageMedia) {
+        if (isImageMedia && !eager) {
           let visionContext = "";
           try {
             const { runVisionIngress: runVisionIngress2, formatImageContextPrefix: formatImageContextPrefix2 } = await Promise.resolve().then(() => (init_vision_ingress(), vision_ingress_exports));
@@ -680762,6 +681016,10 @@ ${caption}\r
                 if (this.adminUserId && !this.agentConfig) {
                   if (!isAdmin) continue;
                 }
+                if (msg.media) {
+                  void this.processMedia(msg, "message", true).catch(() => {
+                  });
+                }
                 if (this.agentConfig && this.repoRoot) {
                   this.handleMessageWithSubAgent(msg).catch((err) => {
                     this.tuiWrite(
@@ -712169,10 +712427,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",
@@ -713374,6 +713632,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 = [
@@ -713482,36 +713744,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) {
@@ -713548,27 +713802,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;
@@ -715499,7 +715732,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) {
@@ -716760,6 +716994,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,
@@ -716853,7 +717088,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)`
@@ -721407,8 +721643,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) => {
@@ -721465,7 +721701,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();
@@ -721510,7 +721757,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.356",
+  "version": "1.0.358",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.356",
+      "version": "1.0.358",
       "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.356",
+  "version": "1.0.358",
   "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)
 
 ═══════════════════════════════════════════════════════════════════════════