omnius 1.0.498 → 1.0.500

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)
@@ -583224,6 +583249,13 @@ ${parts.join("\n")}
           toolProfile: options2?.toolProfile ?? void 0,
           bruteForce: options2?.bruteForce ?? true,
           bruteForceMaxCycles: options2?.bruteForceMaxCycles ?? 100,
+          // TODO-USAGE: default the empty-plan elicitation ON. Without it, a run
+          // that starts with no todos NEVER receives the "create a todo plan"
+          // nudge (the existing-plan reminder only fires once todos already exist —
+          // a chicken-and-egg that left live runs planning-free). Turning it on
+          // prompts the model to decompose into a checklist at the empty state,
+          // which also feeds the per-todo context compression on completion.
+          elicitTodoCreation: options2?.elicitTodoCreation ?? true,
           allowTurnExtension: options2?.allowTurnExtension ?? true,
           completionProvenanceGuard: options2?.completionProvenanceGuard ?? true,
           backwardPassReview: options2?.backwardPassReview,
@@ -589417,6 +589449,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 +589571,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 +598058,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 +598288,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 +598380,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 +609078,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)
@@ -679499,6 +679628,26 @@ var init_stream_renderer = __esm({
         }
         this.scheduleFlush(kind);
       }
+      /**
+       * Flush any buffered partial line and close the current row WITHOUT ending
+       * the stream. Call this before out-of-band output (a tool box, a live block)
+       * interleaves with an in-progress assistant stream: it forces the reasoning
+       * streamed so far to land ABOVE the interleaved block instead of the tail
+       * leaking BELOW it. Safe to call when idle (no-op if nothing is pending).
+       */
+      flushPendingLine() {
+        if (!this.enabled) return;
+        this.cancelFlush();
+        if (this.lineBuffer.length > 0) {
+          const kind = this.inThinkBlock ? "thinking" : this.inToolArgs ? "tool_args" : "content";
+          this.writeHighlighted(this.lineBuffer, kind);
+          this.lineBuffer = "";
+        }
+        if (this.lineStarted) {
+          process.stdout.write("\n");
+          this.lineStarted = false;
+        }
+      }
       /** Called when streaming ends for this response */
       onStreamEnd() {
         if (!this.enabled) return;
@@ -679619,8 +679768,11 @@ var init_stream_renderer = __esm({
               this.writeRaw("\n");
               this.lineStarted = false;
             } else if (text3.length > remaining) {
-              const head = text3.slice(0, firstChunkLen).replace(/\s+$/, "");
-              const tail = text3.slice(firstChunkLen).replace(/^\s+/, "");
+              const window2 = text3.slice(0, firstChunkLen);
+              const sp = window2.replace(/\s+$/, "").lastIndexOf(" ");
+              const wb = sp > 0 ? sp : firstChunkLen;
+              const head = text3.slice(0, wb).replace(/\s+$/, "");
+              const tail = text3.slice(wb).replace(/^\s+/, "");
               this.writeRaw(highlight(head) + "\n");
               this.lineStarted = false;
               text3 = tail;
@@ -679634,8 +679786,8 @@ var init_stream_renderer = __esm({
           for (let i2 = 0; i2 < lines.length; i2++) {
             const isFirst = i2 === 0;
             const isLast = i2 === lines.length - 1;
-            const lp = isBlockquote && !isFirst ? "  │  " : isFirst ? usePrefix : "     ";
-            const chunk = isBlockquote && !isFirst ? "> " + lines[i2].replace(/^\s+/, "") : lines[i2];
+            const lp = isFirst ? usePrefix : "  │  ";
+            const chunk = isFirst ? lines[i2] : isBlockquote ? "> " + lines[i2].replace(/^\s+/, "") : lines[i2].replace(/^\s+/, "");
             const needsNewline = !isLast || trailingNewline;
             this.writeRaw(
               dimText(lp) + highlight(chunk) + (needsNewline ? "\n" : "")
@@ -742973,6 +743125,7 @@ function gatherMemorySnippets(root) {
   return snippets;
 }
 async function createSteeringIntakeBackend(config, repoRoot) {
+  const normalizeSteeringBaseUrl = (url) => url.replace(/\/(v1|api)\/?$/i, "").replace(/\/+$/, "");
   if (config.backendType === "nexus") {
     const nexusTool = new NexusTool(repoRoot);
     await nexusTool.execute({ action: "connect" });
@@ -742985,12 +743138,8 @@ async function createSteeringIntakeBackend(config, repoRoot) {
       false
     );
   }
-  return new OllamaAgenticBackend(
-    config.backendUrl,
-    config.model,
-    config.apiKey,
-    false
-  );
+  const steeringBaseUrl = normalizeSteeringBaseUrl(config.backendUrl);
+  return new OllamaAgenticBackend(steeringBaseUrl, config.model, config.apiKey, false);
 }
 function formatTaskCompletionMeta(meta) {
   if (!meta) return "no prior task metrics recorded";
@@ -744517,6 +744666,7 @@ ${entry.fullContent}`
 `
           );
         } else {
+          stream?.renderer.flushPendingLine?.();
           renderToolCallStart(
             event.toolName ?? "unknown",
             event.toolArgs ?? {},

package/npm-shrinkwrap.json

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

package/package.json

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