omnius 1.0.498 → 1.0.499

package/dist/index.js

@@ -576445,6 +576445,13 @@ var init_debugArtifactLibrary = __esm({
 });
 
 // packages/orchestrator/dist/focusSupervisor.js
+function resolveFocusSupervisorSilent(envValue = process.env["OMNIUS_FOCUS_SUPERVISOR_SILENT"]) {
+  const normalized = String(envValue ?? "").trim().toLowerCase();
+  if (normalized === "0" || normalized === "false" || normalized === "off") {
+    return false;
+  }
+  return true;
+}
 function resolveFocusSupervisorMode(configured, envValue = process.env["OMNIUS_FOCUS_SUPERVISOR"]) {
   if (configured)
     return configured;
@@ -576813,9 +576820,12 @@ var init_focusSupervisor = __esm({
       lastIgnoredDirectiveTurn = null;
       repeatedViolationCounts = /* @__PURE__ */ new Map();
       availableTools = null;
+      /** SILENCE: when true, block() downgrades to pass() (never stops a call). */
+      silent;
       constructor(options2 = {}) {
         this.mode = options2.mode ?? "auto";
         this.modelTier = options2.modelTier ?? "large";
+        this.silent = options2.silent ?? false;
         this.repeatGateMax = Math.max(0, Math.floor(options2.repeatGateMax ?? 3));
         this.availableTools = options2.availableTools ? new Set(Array.from(options2.availableTools)) : null;
         this.convergenceBreaker = options2.convergenceBreaker ?? null;
@@ -577291,6 +577301,11 @@ var init_focusSupervisor = __esm({
         };
       }
       block(directive, message2, success) {
+        if (this.silent) {
+          this.lastDecision = "block_silenced_pass";
+          this.lastReason = directive.reason;
+          return this.pass();
+        }
         this.lastDecision = "block_tool_call";
         this.lastReason = directive.reason;
         return {
@@ -582162,6 +582177,16 @@ var init_agenticRunner = __esm({
       _todoInProgressTurn = /* @__PURE__ */ new Map();
       /** Set of todo IDs that have already been chunked */
       _todoChunked = /* @__PURE__ */ new Set();
+      /**
+       * Explicit tool-output → todo binding. As each FULL tool output is
+       * externalized to .omnius/tool-results/ (the point where it would otherwise
+       * bloat the context chain), we bind it to the todo that was in_progress at
+       * that moment. On completion, that todo's ledger of full outputs is written
+       * to disk (.omnius/todo-chunks/{id}.ledger.json) alongside the summary stub,
+       * so the bulk stays retrievable but out of the live window. Keyed by todo id;
+       * "_unassigned" holds outputs produced while no leaf was in_progress.
+       */
+      _todoOutputLedger = /* @__PURE__ */ new Map();
       // -- ENOENT tracker (prevents path-guessing spirals) --
       // Tracks both consecutive AND sliding-window ENOENT counts. The sliding
       // window catches oscillation patterns (success → ENOENT → success → ENOENT)
@@ -589417,6 +589442,12 @@ Respond with your assessment, then take action.`;
         this._focusSupervisor = this.options.focusSupervisor === "off" ? null : new FocusSupervisor({
           mode: this.options.focusSupervisor,
           modelTier: this.options.modelTier,
+          // SILENCE (operator directive): the supervisor must not stop agents
+          // or re-serve cached responses from earlier commands. It observes,
+          // sets directives, and advises, but every hard block downgrades to a
+          // pass so the model is free to act — including re-reading to confirm
+          // a change landed. Restore blocking with OMNIUS_FOCUS_SUPERVISOR_SILENT=0.
+          silent: resolveFocusSupervisorSilent(),
           repeatGateMax: this._resolveRepeatGateMax(),
           availableTools: this.tools.keys(),
           // WO-3: convergence circuit-breaker escalates a non-converging
@@ -589533,6 +589564,7 @@ Respond with your assessment, then take action.`;
         }
         this._fileRegistry.clear();
         this._memexArchive.clear();
+        this._todoOutputLedger.clear();
         this._sessionId = this.options.sessionId && String(this.options.sessionId) || process.env["OMNIUS_SESSION_ID"] && String(process.env["OMNIUS_SESSION_ID"]) || `session-${Date.now()}`;
         this._appState = createAppState({
           sessionId: this._sessionId,
@@ -598019,6 +598051,17 @@ ${result.output}`, "utf-8");
         } catch {
         }
         const savedPath = _pathJoin(this.omniusStateDir(), "tool-results", `${handleId}.txt`);
+        this._recordTodoOutputLedgerEntry({
+          memexId: handleId,
+          toolName,
+          target: this.extractPrimaryToolPath(args) || "",
+          diskPath: savedPath,
+          chars: result.output.length,
+          lineCount,
+          turn,
+          preview: preview.slice(0, 200),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
         const folded = this.foldOutput(modelContent, maxLen);
         return this.wrapToolOutputForModel(toolName, `[Tool output truncated — ${result.output.length} chars, ${lineCount} lines]
 Full output saved to: ${savedPath}
@@ -598238,6 +598281,76 @@ Actions: (1) list_directory on the parent directory to see what's there, (2) Che
         return content;
       }
       // ---------------------------------------------------------------------------
+      // Part 3 — per-todo full-tool-output ledger
+      // ---------------------------------------------------------------------------
+      /**
+       * The id of the todo currently in_progress (the deepest in_progress leaf), or
+       * "_unassigned" when nothing is active. Full outputs externalized while this
+       * is active are bound to it so completion can flush a consolidated ledger.
+       */
+      _activeTodoId() {
+        try {
+          const todos = this.readSessionTodos() || [];
+          const inProgress = todos.filter((t2) => t2.status === "in_progress");
+          if (inProgress.length === 0)
+            return "_unassigned";
+          const childless = inProgress.filter((t2) => !todos.some((c9) => c9.parentId === t2.id));
+          const chosen = childless[childless.length - 1] ?? inProgress[inProgress.length - 1];
+          return chosen.id || "_unassigned";
+        } catch {
+          return "_unassigned";
+        }
+      }
+      /** Bind one externalized full output to the active todo's ledger. */
+      _recordTodoOutputLedgerEntry(entry) {
+        try {
+          const key = this._activeTodoId();
+          let bucket = this._todoOutputLedger.get(key);
+          if (!bucket) {
+            bucket = [];
+            this._todoOutputLedger.set(key, bucket);
+          }
+          bucket.push(entry);
+          const cap = 500;
+          if (bucket.length > cap)
+            bucket.splice(0, bucket.length - cap);
+        } catch {
+        }
+      }
+      /**
+       * Flush a completed todo's full-output ledger to disk as a single compressed
+       * index alongside its summary chunk, then drop it from memory. The full
+       * bodies stay in .omnius/tool-results/; this file is the high-signal,
+       * low-noise stub that lists what was produced and where to retrieve it.
+       * Returns the ledger path when written, else null.
+       */
+      _flushTodoOutputLedger(todoId, todoContent, workingDir) {
+        try {
+          const bucket = this._todoOutputLedger.get(todoId);
+          if (!bucket || bucket.length === 0)
+            return null;
+          const totalChars = bucket.reduce((n2, e2) => n2 + (e2.chars || 0), 0);
+          const dir = _pathJoin(workingDir, ".omnius", "todo-chunks");
+          _fsMkdirSync(dir, { recursive: true });
+          const safeId3 = todoId.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+          const ledgerPath = _pathJoin(dir, `${safeId3}.ledger.json`);
+          _fsWriteFileSync(ledgerPath, JSON.stringify({
+            todoId,
+            todoContent: todoContent.slice(0, 300),
+            entryCount: bucket.length,
+            totalChars,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            // High-signal, low-noise stubs. Each points at its full body on disk
+            // and via memex_retrieve(memexId) for on-demand re-materialisation.
+            outputs: bucket
+          }, null, 2), "utf-8");
+          this._todoOutputLedger.delete(todoId);
+          return { path: ledgerPath, entryCount: bucket.length, totalChars };
+        } catch {
+          return null;
+        }
+      }
+      // ---------------------------------------------------------------------------
       // Todo context chunker: fire-and-forget summarization of completed todo work
       // ---------------------------------------------------------------------------
       /**
@@ -598260,6 +598373,15 @@ Actions: (1) list_directory on the parent directory to see what's there, (2) Che
           sessionId: this._sessionId
         };
         this._evictCompletedTodoMessages(startTurn, currentTurn, todoId, todo.content, messages2);
+        const _ledger = this._flushTodoOutputLedger(todoId, todo.content, workingDir);
+        if (_ledger) {
+          this.emit({
+            type: "status",
+            content: `[todo-ledger] "${todo.content.slice(0, 60)}": ${_ledger.entryCount} full output(s) (~${Math.round(_ledger.totalChars / 4)} tok) consolidated to ${_ledger.path} — retrievable via memex_retrieve or the tool-results files`,
+            turn: currentTurn,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
         runTodoChunker({
           inputs,
           callable: async (prompt) => {
@@ -608949,7 +609071,7 @@ function canonicalize(value2) {
   return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalize(obj[k])}`).join(",")}}`;
 }
 function shouldBlockCall(fingerprint, history, opts = {}) {
-  const blockOnPriorSuccess = opts.blockOnPriorSuccess ?? true;
+  const blockOnPriorSuccess = opts.blockOnPriorSuccess ?? false;
   const maxIdenticalErrors = opts.maxIdenticalErrors ?? 2;
   const same = history.filter((h) => h.fingerprint === fingerprint);
   if (same.length === 0)

package/npm-shrinkwrap.json

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

package/package.json

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