omnius 1.0.465 → 1.0.466

package/dist/index.js

@@ -566840,7 +566840,9 @@ function loadIgnoreFile(path12) {
     return [];
   }
 }
-function shouldIgnore(relPath, base3, patterns) {
+function shouldIgnore(relPath, base3, absPath, patterns) {
+  if (existsSync92(join103(absPath, "pyvenv.cfg")))
+    return true;
   for (const p2 of patterns) {
     if (!p2)
       continue;
@@ -566873,16 +566875,32 @@ function scanWorkspace(opts) {
   let dirsVisited = 0;
   const stack = [root];
   const visited = /* @__PURE__ */ new Set();
-  while (stack.length > 0) {
-    if (files.length >= maxFiles) {
-      truncated = true;
-      break;
+  const considerFile = (file) => {
+    totalBytes += file.bytes;
+    if (files.length < maxFiles) {
+      files.push(file);
+      return;
+    }
+    truncated = true;
+    let oldestIndex = 0;
+    for (let i2 = 1; i2 < files.length; i2++) {
+      if (files[i2].mtimeMs < files[oldestIndex].mtimeMs)
+        oldestIndex = i2;
     }
+    if (file.mtimeMs > files[oldestIndex].mtimeMs) {
+      files[oldestIndex] = file;
+    }
+  };
+  while (stack.length > 0) {
     const dir = stack.pop();
     if (visited.has(dir))
       continue;
     visited.add(dir);
     dirsVisited++;
+    if (dirsVisited > maxDirs) {
+      truncated = true;
+      break;
+    }
     if (dirs.length < maxDirs) {
       try {
         const st = statSync32(dir);
@@ -566901,15 +566919,12 @@ function scanWorkspace(opts) {
       continue;
     }
     entries.sort();
+    const dirsToVisit = [];
     for (const entry of entries) {
-      if (files.length >= maxFiles) {
-        truncated = true;
-        break;
-      }
       const abs = join103(dir, entry);
       const rel = relative8(root, abs);
       const base3 = basename22(abs);
-      if (shouldIgnore(rel, base3, patterns))
+      if (shouldIgnore(rel, base3, abs, patterns))
         continue;
       let st;
       try {
@@ -566918,13 +566933,15 @@ function scanWorkspace(opts) {
         continue;
       }
       if (st.isDirectory()) {
-        stack.push(abs);
+        dirsToVisit.push(abs);
         continue;
       }
       if (!st.isFile())
         continue;
-      files.push({ abs, rel, bytes: st.size, mtimeMs: st.mtimeMs });
-      totalBytes += st.size;
+      considerFile({ abs, rel, bytes: st.size, mtimeMs: st.mtimeMs });
+    }
+    for (let i2 = dirsToVisit.length - 1; i2 >= 0; i2--) {
+      stack.push(dirsToVisit[i2]);
     }
   }
   files.sort((a2, b) => a2.rel.localeCompare(b.rel));
@@ -566955,6 +566972,7 @@ function ensureTreeNode(root, rel) {
 function renderWorkspaceTree(scan, opts = {}) {
   const maxLines = Math.max(10, Math.min(2e3, opts.maxLines ?? 120));
   const includeFileSizes = opts.includeFileSizes !== false;
+  const sortBy = opts.sortBy ?? "path";
   const root = {
     name: ".",
     children: /* @__PURE__ */ new Map(),
@@ -566975,10 +566993,38 @@ function renderWorkspaceTree(scan, opts = {}) {
       directory: false
     });
   }
+  const annotate = (node) => {
+    if (!node.directory && node.file) {
+      node.latestMtimeMs = node.file.mtimeMs;
+      node.selectedFileCount = 1;
+      return { latest: node.file.mtimeMs, files: 1 };
+    }
+    let latest = 0;
+    let files = 0;
+    for (const child of node.children.values()) {
+      const stats = annotate(child);
+      latest = Math.max(latest, stats.latest);
+      files += stats.files;
+    }
+    node.latestMtimeMs = latest;
+    node.selectedFileCount = files;
+    return { latest, files };
+  };
+  annotate(root);
   const lines = ["./"];
   let truncated = false;
   const walk2 = (node, depth) => {
     const children2 = [...node.children.values()].sort((a2, b) => {
+      if (sortBy === "recent") {
+        const aFiles = a2.selectedFileCount ?? 0;
+        const bFiles = b.selectedFileCount ?? 0;
+        if (aFiles > 0 !== bFiles > 0)
+          return aFiles > 0 ? -1 : 1;
+        const aMtime = a2.latestMtimeMs ?? 0;
+        const bMtime = b.latestMtimeMs ?? 0;
+        if (aMtime !== bMtime)
+          return bMtime - aMtime;
+      }
       if (a2.directory !== b.directory)
         return a2.directory ? -1 : 1;
       return a2.name.localeCompare(b.name);
@@ -567057,12 +567103,23 @@ var init_world_state_disk_scan = __esm({
       ".venv",
       "venv",
       "env",
+      "site-packages",
+      ".eggs",
+      "__pypackages__",
+      // Embedded/device and package-manager dependency/build caches
+      ".pio",
+      ".platformio",
+      "libdeps",
       // Rust / Go test / build outputs are caught by "target"/"build"
       // Editor swap / lock-only files — case-by-case skip, see file filter below
       // Omnius's own state dirs
       ".omnius",
       ".aiwg",
       ".ralph",
+      ".claude",
+      ".codex",
+      ".factory",
+      ".warp",
       // Next/Vite/etc. caches (broadly cross-framework — every JS bundler has one)
       ".next",
       ".nuxt",
@@ -575515,7 +575572,7 @@ var init_focusSupervisor = __esm({
           prior.ignoredCount++;
           this.ignoredDirectiveStreak++;
           this.lastIgnoredDirectiveTurn = input.turn;
-          if ((prior.requiredNextAction === "read_authoritative_target" || prior.requiredNextAction === "use_cached_evidence") && input.cachedResult && (input.duplicateHitCount ?? 0) >= Math.max(1, this.repeatGateMax - 1)) {
+          if (prior.requiredNextAction === "read_authoritative_target" && input.cachedResult && (input.duplicateHitCount ?? 0) >= Math.max(1, this.repeatGateMax - 1)) {
             const deadlockDirective = this.setDirective({
               turn: input.turn,
               state: "terminal_incomplete",
@@ -578528,7 +578585,7 @@ function classifyThinkOutcome(raw) {
   }
   return null;
 }
-var TOOL_SUBSETS, TOOL_AUTO_DEMOTE_TURNS, TOOL_ACTION_REASON_KEYS, TOOL_ACTION_REASON_SCOPES, READ_ONLY_ACTION_REASON_OPTIONAL_TOOLS, TOOL_ACTION_REASON_SCHEMA, SYSTEM_PROMPT, SYSTEM_PROMPT_MEDIUM, SYSTEM_PROMPT_SMALL, VISUAL_TOOLS, AUDIO_TOOLS, SOCIAL_TOOLS, SPATIAL_TOOLS, CODE_TOOLS, AgenticRunner, OllamaAgenticBackend;
+var TOOL_SUBSETS, TOOL_AUTO_DEMOTE_TURNS, TOOL_ACTION_REASON_KEYS, TOOL_ACTION_REASON_SCOPES, READ_ONLY_ACTION_REASON_OPTIONAL_TOOLS, STATE_UPDATE_ACTION_REASON_SYNTHESIS_TOOLS, TOOL_ACTION_REASON_SCHEMA, SYSTEM_PROMPT, SYSTEM_PROMPT_MEDIUM, SYSTEM_PROMPT_SMALL, VISUAL_TOOLS, AUDIO_TOOLS, SOCIAL_TOOLS, SPATIAL_TOOLS, CODE_TOOLS, AgenticRunner, OllamaAgenticBackend;
 var init_agenticRunner = __esm({
   "packages/orchestrator/dist/agenticRunner.js"() {
     "use strict";
@@ -578652,6 +578709,9 @@ var init_agenticRunner = __esm({
       "web_fetch",
       "tool_search"
     ]);
+    STATE_UPDATE_ACTION_REASON_SYNTHESIS_TOOLS = /* @__PURE__ */ new Set([
+      "todo_write"
+    ]);
     TOOL_ACTION_REASON_SCHEMA = {
       type: "object",
       description: "Compact public action contract for this exact tool call. Do not include hidden chain-of-thought; use concise task-state facts.",
@@ -580012,10 +580072,13 @@ ${parts.join("\n")}
       }
       _maybeMarkFocusTerminalIncomplete(input) {
         if (input.decision.kind === "pass")
-          return;
+          return null;
         const directive = input.decision.directive;
         if (directive.state !== "terminal_incomplete" || directive.requiredNextAction !== "report_incomplete") {
-          return;
+          return null;
+        }
+        if (this._completionIncompleteVerification) {
+          return this._completionIncompleteVerification.summary;
         }
         const reason = directive.reason;
         const blocked = input.blockedTool ? `Blocked tool: ${input.blockedTool}.` : "";
@@ -580033,6 +580096,10 @@ ${parts.join("\n")}
           "Next action:",
           'Call task_complete with status="incomplete" or status="blocked", or provide the missing evidence if a valid recovery action remains.'
         ].filter((line) => line.length > 0).join("\n");
+        this._completionIncompleteVerification = {
+          reason: "focus_supervisor_terminal",
+          summary: focusTerminalSummary
+        };
         this.emit({
           type: "status",
           content: `Focus supervisor terminal directive: ${reason.slice(0, 220)}`,
@@ -580051,6 +580118,7 @@ ${parts.join("\n")}
           this._saveCompletionLedgerSafe();
           this._focusTerminalLedgerRecorded = true;
         }
+        return focusTerminalSummary;
       }
       _buildFocusContextSnapshot() {
         const last2 = this._lastFocusContextSnapshot;
@@ -583722,22 +583790,24 @@ ${latest.output || ""}`.trim();
         const artifactLines = intEnv("OMNIUS_CONTEXT_TREE_ARTIFACT_LINES", 1800, 100, 4e3);
         try {
           const scan = scanWorkspace({ root, maxFiles, maxDirs });
-          const compactTree = renderWorkspaceTree(scan, { maxLines: contextLines });
-          const fullTree = renderWorkspaceTree(scan, { maxLines: artifactLines });
+          const compactTree = renderWorkspaceTree(scan, { maxLines: contextLines, sortBy: "recent" });
+          const fullTree = renderWorkspaceTree(scan, { maxLines: artifactLines, sortBy: "recent" });
           const totalBytes = scan.files.reduce((sum, file) => sum + file.bytes, 0);
           const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
           const focusSnapshot = this._focusSupervisor?.snapshot();
-          const recentActions = this._adversaryToolOutcomes.slice(-12).map((item) => ({
+          const recentActions = this._recentToolActionsForWorldState().slice(-12).map((item) => ({
             turn: item.turn,
             tool: item.tool,
             success: item.succeeded,
             path: item.path,
             stateVersion: item.stateVersion,
-            preview: item.preview.slice(0, 240)
+            preview: item.preview.slice(0, 240),
+            actionReason: item.actionReason ?? void 0
           }));
           const recentActionLines = recentActions.slice(-6).map((item) => {
             const path12 = item.path ? ` path=${item.path}` : "";
-            return `- turn=${item.turn} ${item.tool} ${item.success ? "ok" : "err"}${path12}: ${item.preview.replace(/\s+/g, " ").slice(0, 160)}`;
+            const reason = item.actionReason ? ` reason=${[item.actionReason.scope, item.actionReason.intent].filter(Boolean).join(":").replace(/\s+/g, " ").slice(0, 120)}` : "";
+            return `- turn=${item.turn} ${item.tool} ${item.success ? "ok" : "err"}${path12}${reason}: ${item.preview.replace(/\s+/g, " ").slice(0, 160)}`;
           });
           const treeDir = _pathJoin(this.omniusStateDir(), "world-state", "tree");
           const turnName = `turn-${String(turn).padStart(4, "0")}`;
@@ -589780,6 +589850,14 @@ Respond with EXACTLY this structure before your next tool call:
               const realFileMutation = this._isRealProjectMutation(tc.name, result);
               const observedStateMutation = realFileMutation || shellFilesystemMutation || result.success === true && result.mutated === true;
               const realMutationPaths = realFileMutation ? this._extractToolTargetPaths(tc.name, tc.arguments, result) : [];
+              this._recordRecentToolOutcomeForWorldState({
+                turn,
+                toolName: resolvedTool?.name ?? tc.name,
+                toolCallId: tc.id,
+                args: tc.arguments,
+                result,
+                actionReason: toolActionReason
+              });
               if (observedStateMutation) {
                 this._markAdversaryObservedStateMutation();
               }
@@ -591549,6 +591627,8 @@ ${sr.result.output}`;
                   }
                 }
                 const results = await executeBatch(batch2, async (call) => {
+                  if (this._completionIncompleteVerification)
+                    return null;
                   const originalTc = rawToolCalls.find((tc) => tc.id === call.id);
                   const fp = buildBatchFp(call);
                   const firstId = batchFingerprintFirstId.get(fp);
@@ -593926,10 +594006,32 @@ ${marker}` : marker);
         const explicit = this._extractToolActionReason(args);
         if (explicit)
           return explicit;
+        if (this._shouldSynthesizeMissingToolActionReason(toolName, args)) {
+          return this._synthesizeStateUpdateToolActionReason(toolName, args);
+        }
         if (this._toolActionReasonPolicy(toolName, args) !== "optional")
           return null;
         return this._synthesizeReadOnlyToolActionReason(toolName, args);
       }
+      _shouldSynthesizeMissingToolActionReason(toolName, _args) {
+        if (this._toolActionReasonPolicy(toolName, _args) === "disabled") {
+          return false;
+        }
+        const canonical = this.lookupRegisteredTool(toolName)?.name ?? toolName;
+        return STATE_UPDATE_ACTION_REASON_SYNTHESIS_TOOLS.has(canonical);
+      }
+      _synthesizeStateUpdateToolActionReason(toolName, args) {
+        const canonical = this.lookupRegisteredTool(toolName)?.name ?? toolName;
+        const goal = this._taskState.currentStep || this._taskState.nextAction || this._taskState.goal || this._taskState.originalGoal || "current task";
+        const todoCount = Array.isArray(args["todos"]) ? args["todos"].length : null;
+        return {
+          task_anchor: String(goal).replace(/\s+/g, " ").trim().slice(0, 160),
+          intent: `Update visible task state with ${canonical}.`,
+          evidence: todoCount === null ? "Model omitted public action_reason; runtime synthesized bookkeeping metadata without authorizing project mutation." : `Model supplied ${todoCount} todo item(s); runtime synthesized bookkeeping metadata without authorizing project mutation.`,
+          expected_result: "Session checklist reflects the current task state.",
+          scope: "state_update"
+        };
+      }
       _synthesizeReadOnlyToolActionReason(toolName, args) {
         const canonical = this.lookupRegisteredTool(toolName)?.name ?? toolName;
         const goal = this._taskState.currentStep || this._taskState.nextAction || this._taskState.goal || this._taskState.originalGoal || "current task";
@@ -593951,6 +594053,9 @@ ${marker}` : marker);
         if (!raw || typeof raw === "string" && !raw.trim()) {
           if (policy === "optional")
             return null;
+          if (this._shouldSynthesizeMissingToolActionReason(toolName, args)) {
+            return null;
+          }
           return [
             "[TOOL ACTION REASON CONTRACT]",
             `This side-effectful tool call must include action_reason: { task_anchor, intent, evidence, expected_result, scope }.`,
@@ -595798,6 +595903,10 @@ ${trimmedNew}`;
       // we add a second analysis path that catches mismatches in real-time.
       /** Track recent tool outcomes for the adversary */
       _adversaryToolOutcomes = [];
+      /** Execution-time action ledger used by world-state artifacts. Unlike the
+       * adversary buffer, this is populated directly after tool execution and does
+       * not depend on raw tool messages surviving compaction. */
+      _recentToolOutcomes = [];
       /** Monotonic counter for observed local state changes.
        *  Redundant-action classification is only valid within the same state
        *  version; a repeated verifier after an edit is fresh evidence. */
@@ -595902,6 +596011,38 @@ ${trimmedNew}`;
         }
         return { preview: snippet || content.slice(0, 160) };
       }
+      _recordRecentToolOutcomeForWorldState(input) {
+        const content = input.result.success === true ? String(input.result.output ?? "") : String(input.result.error ?? input.result.output ?? "");
+        const outcomeEvidence = this.buildAdversaryToolOutcomeEvidence(input.toolName, input.args, content, input.result.success === true);
+        const fingerprint = input.args ? this._buildToolFingerprint(input.toolName, input.args) : void 0;
+        const alreadySeen = this._recentToolOutcomes.some((outcome) => {
+          if (input.toolCallId && outcome.toolCallId === input.toolCallId) {
+            return true;
+          }
+          return outcome.turn === input.turn && outcome.tool === input.toolName && outcome.fingerprint === fingerprint;
+        });
+        if (alreadySeen)
+          return;
+        this._recentToolOutcomes.push({
+          turn: input.turn,
+          tool: input.toolName,
+          toolCallId: input.toolCallId,
+          argsKey: input.args ? this._buildExactArgsKey(input.args) : void 0,
+          fingerprint,
+          stateVersion: this._adversaryStateVersion,
+          succeeded: input.result.success === true,
+          actionReason: input.actionReason,
+          ...outcomeEvidence
+        });
+        while (this._recentToolOutcomes.length > 40) {
+          this._recentToolOutcomes.shift();
+        }
+      }
+      _recentToolActionsForWorldState() {
+        if (this._recentToolOutcomes.length > 0)
+          return this._recentToolOutcomes;
+        return this._adversaryToolOutcomes;
+      }
       /**
        * Adversary: post-turn meta-analysis.
        *

package/npm-shrinkwrap.json

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

package/package.json

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