omnius 1.0.369 → 1.0.370

package/dist/index.js

@@ -295152,7 +295152,13 @@ var init_todo_write = __esm({
 - completed: fully done (tests pass, code works, goal met)
 - blocked: stuck on a dependency (include blocker text)
 
-Mark tasks complete IMMEDIATELY after finishing — don't batch. Never mark completed if tests are failing or implementation is partial. The user watches this list in the chat UI in real time. Canonical call shape: todo_write({"todos":[{"content":"Inspect files","status":"in_progress"},{"content":"Make changes","status":"pending"},{"content":"Verify results","status":"pending"}]})`;
+## Nested decomposition
+- Use stable ids plus parentId to create subtasks under a parent objective.
+- Work on leaf subtasks; a parent is completed only after every child is completed with evidence.
+- When evidence changes the plan, rewrite the tree: add new child todos, block invalidated children with root cause, and keep the parent in_progress/blocked until the child set is truthful.
+- If a tool fails for a child, do not mark that child completed. Reconfigure it: re-read/observe current state, choose a different target/tool, or leave it blocked.
+
+Mark tasks complete IMMEDIATELY after finishing — don't batch. Never mark completed if tests are failing or implementation is partial. The user watches this list in the chat UI in real time. Canonical call shape: todo_write({"todos":[{"id":"p1","content":"Implement feature","status":"in_progress"},{"id":"c1","parentId":"p1","content":"Inspect files","status":"in_progress"},{"id":"c2","parentId":"p1","content":"Make changes","status":"pending"},{"id":"c3","parentId":"p1","content":"Verify results","status":"pending"}]})`;
       parameters = {
         type: "object",
         required: ["todos"],
@@ -295170,7 +295176,7 @@ Mark tasks complete IMMEDIATELY after finishing — don't batch. Never mark comp
                   type: "string",
                   enum: ["pending", "in_progress", "completed", "blocked"]
                 },
-                parentId: { type: "string", description: "Parent todo id for sub-tasks" },
+                parentId: { type: "string", description: "Parent todo id for nested sub-tasks. Parents summarize objectives; children carry concrete implementation/verification work. Never complete a parent until every child is completed with evidence." },
                 blocker: { type: "string", description: "Reason this is blocked (status=blocked only)" },
                 verifyCommand: {
                   type: "string",
@@ -295287,6 +295293,7 @@ Mark tasks complete IMMEDIATELY after finishing — don't batch. Never mark comp
           const reminder = "Todos have been modified successfully. Ensure that you continue to use the todo list to track your progress. Mark the current task in_progress and the next task pending. Proceed with the current task.";
           const payload = {
             reminder,
+            decompositionContract: "Use parentId for sub-todos. Keep parents in_progress/blocked until all children are completed with objective evidence. When tool evidence invalidates a child, rewrite that child as blocked or split it into new children instead of overclaiming completion.",
             oldTodos: result.oldTodos,
             newTodos: result.newTodos,
             verificationNudgeNeeded
@@ -295295,9 +295302,10 @@ Mark tasks complete IMMEDIATELY after finishing — don't batch. Never mark comp
             payload["inputRepair"] = Array.from(new Set(repairNotes));
             payload["canonicalShape"] = {
               todos: [
-                { content: "Inspect files", status: "in_progress" },
-                { content: "Make changes", status: "pending" },
-                { content: "Verify results", status: "pending" }
+                { id: "p1", content: "Implement the requested change", status: "in_progress" },
+                { id: "c1", parentId: "p1", content: "Inspect files", status: "in_progress" },
+                { id: "c2", parentId: "p1", content: "Make changes", status: "pending" },
+                { id: "c3", parentId: "p1", content: "Verify results", status: "pending" }
               ]
             };
           }
@@ -546587,6 +546595,32 @@ ${content.slice(0, 500)}`,
   }
 });
 
+// packages/execution/dist/tools/clip-feature-python.js
+var CLIP_FEATURE_HELPERS_PY;
+var init_clip_feature_python = __esm({
+  "packages/execution/dist/tools/clip-feature-python.js"() {
+    "use strict";
+    CLIP_FEATURE_HELPERS_PY = `
+def _omnius_feature_tensor(features):
+    if hasattr(features, "image_embeds"):
+        return features.image_embeds
+    if hasattr(features, "text_embeds"):
+        return features.text_embeds
+    if hasattr(features, "pooler_output"):
+        return features.pooler_output
+    if hasattr(features, "last_hidden_state"):
+        return features.last_hidden_state[:, 0]
+    if isinstance(features, (tuple, list)):
+        return features[0]
+    return features
+
+def _omnius_normalized_features(features):
+    tensor = _omnius_feature_tensor(features)
+    return tensor / tensor.norm(dim=-1, keepdim=True)
+`;
+  }
+});
+
 // packages/execution/dist/tools/visual-memory.js
 import { execSync as execSync39 } from "node:child_process";
 import { existsSync as existsSync66, mkdirSync as mkdirSync39, writeFileSync as writeFileSync31, readFileSync as readFileSync48 } from "node:fs";
@@ -546639,19 +546673,38 @@ function normalizeVisualMemoryAction(args) {
 }
 function summarizeProcessFailure(stdout, stderr) {
   const normalize2 = (text2) => text2.replace(/\r/g, "\n").split("\n").map((line) => line.trim()).filter(Boolean);
-  const lines = [
-    ...normalize2(stderr).map((line) => `stderr: ${line}`),
-    ...normalize2(stdout).map((line) => `stdout: ${line}`)
+  const stderrLines = normalize2(stderr);
+  const stdoutLines = normalize2(stdout);
+  const tagged = [
+    ...stderrLines.map((line) => `stderr: ${line}`),
+    ...stdoutLines.map((line) => `stdout: ${line}`)
   ];
-  if (lines.length === 0)
+  if (tagged.length === 0)
     return "Vision ML script failed";
-  return lines.slice(-24).join("\n").slice(-1800);
+  const exceptionRe = /(?:^|\s)(?:[A-Za-z_][\w.]*Error|[A-Za-z_][\w.]*Exception|AssertionError|KeyboardInterrupt|SystemExit):\s+.+$/;
+  const tracebackIdx = tagged.findIndex((line) => /Traceback \(most recent call last\):/.test(line));
+  const exceptionLine = [...stderrLines, ...stdoutLines].slice().reverse().find((line) => exceptionRe.test(line) && !/\bwarning:/i.test(line));
+  const parts = [];
+  if (exceptionLine) {
+    parts.push(`Root cause: ${exceptionLine}`);
+  }
+  if (tracebackIdx >= 0) {
+    parts.push("Traceback:");
+    parts.push(...tagged.slice(tracebackIdx).slice(0, 18));
+  }
+  const tail = tagged.slice(-24);
+  for (const line of tail) {
+    if (!parts.includes(line))
+      parts.push(line);
+  }
+  return parts.join("\n").slice(0, 2200);
 }
 var VMEM_DIR, VENV_DIR2, VENV_PY, VENV_PIP2, VISUAL_MEMORY_ACTIONS, VisualMemoryTool;
 var init_visual_memory = __esm({
   "packages/execution/dist/tools/visual-memory.js"() {
     "use strict";
     init_cuda_device_filter();
+    init_clip_feature_python();
     VMEM_DIR = join80(homedir20(), ".omnius", "visual-memory");
     VENV_DIR2 = join80(homedir20(), ".omnius", "vision-ml-venv");
     VENV_PY = join80(VENV_DIR2, "bin", "python3");
@@ -546994,6 +547047,8 @@ import torch
 from PIL import Image
 from transformers import CLIPProcessor, CLIPModel
 
+${CLIP_FEATURE_HELPERS_PY}
+
 image_path = ${pyLiteral(image)}
 label = ${pyLiteral(label)}
 aliases = ${JSON.stringify(aliases)}
@@ -547007,16 +547062,14 @@ processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
 img = Image.open(image_path).convert("RGB")
 inputs = processor(images=img, return_tensors="pt")
 with torch.no_grad():
-    image_features = model.get_image_features(**inputs)
-    image_features = image_features / image_features.norm(dim=-1, keepdim=True)
+    image_features = _omnius_normalized_features(model.get_image_features(**inputs))
 
 embedding = image_features[0].cpu().numpy().tolist()
 
 # Also embed the text label and aliases for cross-modal retrieval
 text_inputs = processor(text=aliases, return_tensors="pt", padding=True)
 with torch.no_grad():
-    text_features = model.get_text_features(**text_inputs)
-    text_features = text_features / text_features.norm(dim=-1, keepdim=True)
+    text_features = _omnius_normalized_features(model.get_text_features(**text_inputs))
 
 text_embeddings = {}
 for i, alias in enumerate(aliases):
@@ -547089,6 +547142,8 @@ import torch
 from PIL import Image
 from transformers import CLIPProcessor, CLIPModel
 
+${CLIP_FEATURE_HELPERS_PY}
+
 model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
 processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
 
@@ -547097,8 +547152,7 @@ img = Image.open(${pyLiteral(image)}).convert("RGB")
 # Get image embedding
 inputs = processor(images=img, return_tensors="pt")
 with torch.no_grad():
-    image_features = model.get_image_features(**inputs)
-    image_features = image_features / image_features.norm(dim=-1, keepdim=True)
+    image_features = _omnius_normalized_features(model.get_image_features(**inputs))
 
 query = image_features[0].cpu().numpy()
 
@@ -547160,8 +547214,7 @@ extra_labels = ${JSON.stringify(extraLabels)}
 if extra_labels:
     text_inputs = processor(text=extra_labels, return_tensors="pt", padding=True)
     with torch.no_grad():
-        text_features = model.get_text_features(**text_inputs)
-        text_features = text_features / text_features.norm(dim=-1, keepdim=True)
+        text_features = _omnius_normalized_features(model.get_text_features(**text_inputs))
 
     for i, label in enumerate(extra_labels):
         sim = float(np.dot(query, text_features[i].cpu().numpy()))
@@ -547320,6 +547373,7 @@ var MM_DIR, MM_INDEX, MultimodalMemoryTool;
 var init_multimodal_memory = __esm({
   "packages/execution/dist/tools/multimodal-memory.js"() {
     "use strict";
+    init_clip_feature_python();
     MM_DIR = join81(homedir21(), ".omnius", "multimodal-episodes");
     MM_INDEX = join81(MM_DIR, "index.json");
     MultimodalMemoryTool = class {
@@ -547413,13 +547467,13 @@ var init_multimodal_memory = __esm({
 import json, torch
 from PIL import Image
 from transformers import CLIPProcessor, CLIPModel
+${CLIP_FEATURE_HELPERS_PY}
 model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
 processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
 img = Image.open("${imagePath}").convert("RGB")
 inputs = processor(images=img, return_tensors="pt")
 with torch.no_grad():
-    features = model.get_image_features(**inputs)
-    features = features / features.norm(dim=-1, keepdim=True)
+    features = _omnius_normalized_features(model.get_image_features(**inputs))
 print(json.dumps(features[0].cpu().numpy().tolist()))
 `;
                 const scriptFile = join81(tmpdir17(), `mm-clip-${Date.now()}.py`);
@@ -547639,12 +547693,12 @@ Recall later: multimodal_memory action=recall query="${personName}"`,
             const clipTextScript = `
 import json, torch
 from transformers import CLIPProcessor, CLIPModel
+${CLIP_FEATURE_HELPERS_PY}
 model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
 processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
 inputs = processor(text=["${query.replace(/"/g, '\\"').replace(/\n/g, " ")}"], return_tensors="pt", padding=True)
 with torch.no_grad():
-    features = model.get_text_features(**inputs)
-    features = features / features.norm(dim=-1, keepdim=True)
+    features = _omnius_normalized_features(model.get_text_features(**inputs))
 print(json.dumps(features[0].cpu().numpy().tolist()))
 `;
             const scriptFile = join81(tmpdir17(), `mm-clipq-${Date.now()}.py`);
@@ -567219,7 +567273,6 @@ function normalizeFailurePatterns(patterns) {
   });
 }
 function buildFailureModeHandoff(input) {
-  const patterns = normalizeFailurePatterns(input.errorPatterns).slice(0, input.maxPatterns ?? 10);
   const toolCalls = input.toolCallLog ?? [];
   const maxRecentCalls = input.maxRecentCalls ?? 8;
   const recentCalls = maxRecentCalls > 0 ? toolCalls.slice(-maxRecentCalls) : [];
@@ -567231,6 +567284,7 @@ function buildFailureModeHandoff(input) {
   const currentStep = cleanInline(input.taskState?.currentStep, 180);
   const nextAction = cleanInline(input.taskState?.nextAction, 180);
   const goal = cleanInline(input.taskGoal || input.taskState?.goal || input.taskState?.originalGoal || "", 260);
+  const patterns = normalizeFailurePatterns(input.errorPatterns).slice(0, input.maxPatterns ?? 10);
   if (patterns.length === 0 && recentCalls.length === 0 && modified.length === 0 && failedApproaches.length === 0 && !goal) {
     return null;
   }
@@ -568200,6 +568254,10 @@ function resolutionSystemPrompt() {
     "  - exit code 0 on an unrelated command does not resolve the request.",
     "  - Doing PART of the request, or adjacent work, is NOT resolution.",
     "  - If the request had multiple parts, EVERY part must be addressed.",
+    "  - If the original request explicitly allows a degraded fallback such as",
+    "    documenting/reporting a tool failure, that fallback can resolve the task",
+    "    only when the failure is clearly disclosed and the requested fallback",
+    "    artifact/report/verifier is evidenced.",
     "",
     "Respond with ONLY a JSON object, no prose, no code fences:",
     '{"resolved": true|false,',
@@ -568211,6 +568269,25 @@ function resolutionSystemPrompt() {
     "original request. When in doubt, resolved=false and name what is missing."
   ].join("\n");
 }
+function detectExplicitDegradedCompletion(i2) {
+  const original = i2.originalGoal.toLowerCase();
+  const summary = i2.proposedSummary.toLowerCase();
+  const evidence = `${i2.actionsDigest}
+${i2.evidenceDigest}`.toLowerCase();
+  const permitsFallback = /\bif\b[\s\S]{0,160}\b(?:fails?|failed|failure|blocked|unavailable|cannot|can't|unable)\b[\s\S]{0,180}\b(?:document|report|note|record|summari[sz]e|explain)\b/.test(original) || /\b(?:document|report|note|record|summari[sz]e|explain)\b[\s\S]{0,180}\b(?:fails?|failed|failure|blocked|unavailable|cannot|can't|unable)\b/.test(original) || /\b(?:fallback|degraded|best effort|best-effort|honestly document|document honestly)\b/.test(original);
+  if (!permitsFallback)
+    return null;
+  const disclosesFailure = /\b(?:fail(?:ed|ure)?|blocked|unable|could not|couldn't|cannot|can't|degraded|partial|not available|unavailable)\b/.test(summary);
+  if (!disclosesFailure)
+    return null;
+  const hasFallbackEvidence = /\b(?:passed|success|succeeded|verified|wrote|created|saved|report|artifact|file changed|files changed|last test outcome: passed|exit code 0)\b/.test(evidence) || /\b(?:verifier|verification|report)\b/.test(summary);
+  if (!hasFallbackEvidence)
+    return null;
+  return {
+    accepted: true,
+    reason: "original request explicitly allowed a degraded/failure-report fallback and the completion disclosed the failure with fallback evidence"
+  };
+}
 function buildResolutionPrompt(i2) {
   return [
     "ORIGINAL REQUEST (what the user actually asked for):",
@@ -568261,6 +568338,134 @@ var init_completion_resolution_verifier = __esm({
   }
 });
 
+// packages/orchestrator/dist/todoTruth.js
+function normalizeText2(value2) {
+  return value2.toLowerCase().replace(/[_-]+/g, " ").replace(/[^a-z0-9./ ]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function extractArg(argsKey, key) {
+  if (!argsKey)
+    return "";
+  const re = new RegExp(`(?:^|,)${key}=([^,]+)`);
+  return argsKey.match(re)?.[1]?.trim() ?? "";
+}
+function toolAliases(toolName) {
+  const normalized = normalizeText2(toolName);
+  const spaceAlias = normalizeText2(toolName.replace(/_/g, " "));
+  const compactAlias = toolName.toLowerCase().replace(/[^a-z0-9]+/g, "");
+  return [...new Set([normalized, spaceAlias, compactAlias].filter(Boolean))];
+}
+function todoMentionsFailedCall(todo, call) {
+  if (NON_WORK_TOOLS.has(call.name))
+    return false;
+  const content = normalizeText2(todo.content);
+  const compactContent2 = todo.content.toLowerCase().replace(/[^a-z0-9]+/g, "");
+  const mentionsTool = toolAliases(call.name).some((alias) => {
+    if (alias.length <= 2)
+      return false;
+    if (/^[a-z0-9]+$/.test(alias) && alias === call.name.toLowerCase().replace(/[^a-z0-9]+/g, "")) {
+      return compactContent2.includes(alias);
+    }
+    return content.includes(alias);
+  });
+  if (!mentionsTool)
+    return false;
+  const action = normalizeText2(extractArg(call.argsKey, "action"));
+  if (!action)
+    return true;
+  return content.includes(action) || action.length <= 2;
+}
+function evidenceLine(call) {
+  const preview = String(call.outputPreview ?? "").split("\n").map((line) => line.trim()).find(Boolean);
+  const action = extractArg(call.argsKey, "action");
+  const detail = preview || "tool returned failure";
+  return `${call.name}${action ? ` ${action}` : ""}: ${detail}`.slice(0, 260);
+}
+function hasLaterSuccessForSameFamily(calls, failedIndex) {
+  const failed = calls[failedIndex];
+  if (!failed)
+    return false;
+  const failedAction = normalizeText2(extractArg(failed.argsKey, "action"));
+  for (let i2 = failedIndex + 1; i2 < calls.length; i2++) {
+    const next = calls[i2];
+    if (!next || next.success !== true || next.name !== failed.name)
+      continue;
+    const nextAction = normalizeText2(extractArg(next.argsKey, "action"));
+    if (!failedAction || !nextAction || failedAction === nextAction)
+      return true;
+  }
+  return false;
+}
+function firstUnresolvedChild(todo, childrenByParent) {
+  const id = todo.id;
+  if (!id)
+    return null;
+  const children2 = childrenByParent.get(id) ?? [];
+  return children2.find((child) => child.status === "blocked") ?? children2.find((child) => child.status === "in_progress") ?? children2.find((child) => child.status === "pending") ?? null;
+}
+function reconcileCompletedTodosWithEvidence(input) {
+  const nextTodos = input.todos.map((todo) => ({ ...todo }));
+  const downgrades = [];
+  const childrenByParent = /* @__PURE__ */ new Map();
+  for (const todo of nextTodos) {
+    if (!todo.parentId)
+      continue;
+    const arr = childrenByParent.get(todo.parentId) ?? [];
+    arr.push(todo);
+    childrenByParent.set(todo.parentId, arr);
+  }
+  for (const todo of nextTodos) {
+    if (todo.status !== "completed")
+      continue;
+    const unresolvedChild = firstUnresolvedChild(todo, childrenByParent);
+    if (unresolvedChild) {
+      const childStatus = unresolvedChild.status;
+      const targetStatus = childStatus === "blocked" ? "blocked" : "in_progress";
+      const blocker2 = childStatus === "blocked" ? `Child todo blocked: ${unresolvedChild.content}${unresolvedChild.blocker ? ` (${unresolvedChild.blocker})` : ""}` : `Child todo not complete: [${childStatus}] ${unresolvedChild.content}`;
+      downgrades.push({
+        id: todo.id,
+        content: todo.content,
+        from: "completed",
+        to: targetStatus,
+        blocker: blocker2,
+        evidence: blocker2
+      });
+      todo.status = targetStatus;
+      todo.blocker = blocker2;
+      continue;
+    }
+    const startTurn = todo.id && input.todoStartTurnById?.has(todo.id) ? input.todoStartTurnById.get(todo.id) : 0;
+    const relevantCalls = input.toolCallLog.filter((call) => (call.turn ?? 0) >= startTurn);
+    const failedIndex = relevantCalls.findIndex((call) => call.success === false && todoMentionsFailedCall(todo, call) && !hasLaterSuccessForSameFamily(relevantCalls, relevantCalls.indexOf(call)));
+    if (failedIndex < 0)
+      continue;
+    const failed = relevantCalls[failedIndex];
+    const evidence = evidenceLine(failed);
+    const blocker = `Completion claim contradicted by failed ${failed.name} evidence. Reconfigure this subtask: verify whether the goal is already satisfied, choose a different target/tool, or leave the todo blocked with the root cause.`;
+    downgrades.push({
+      id: todo.id,
+      content: todo.content,
+      from: "completed",
+      to: "blocked",
+      blocker,
+      evidence
+    });
+    todo.status = "blocked";
+    todo.blocker = `${blocker} Evidence: ${evidence}`;
+  }
+  return {
+    todos: nextTodos,
+    changed: downgrades.length > 0,
+    downgrades
+  };
+}
+var NON_WORK_TOOLS;
+var init_todoTruth = __esm({
+  "packages/orchestrator/dist/todoTruth.js"() {
+    "use strict";
+    NON_WORK_TOOLS = /* @__PURE__ */ new Set(["todo_write", "todo_read", "task_complete"]);
+  }
+});
+
 // packages/orchestrator/dist/evidenceBranch.js
 function buildStructuralPreview2(lines, path12, query) {
   const n2 = lines.length;
@@ -570467,6 +570672,7 @@ var init_agenticRunner = __esm({
     init_evidenceLedger();
     init_adversaryStream();
     init_completion_resolution_verifier();
+    init_todoTruth();
     init_evidenceBranch();
     init_resolution_memory();
     init_contextEngine();
@@ -570642,6 +570848,7 @@ var init_agenticRunner = __esm({
       // Research: Kumaran et al. (2016) — complementary learning systems
       //           Fast learning from errors → immediate behavioral change
       _errorPatterns = /* @__PURE__ */ new Map();
+      _taskRelevantErrorPatterns = /* @__PURE__ */ new Map();
       _errorGuidanceInjected = /* @__PURE__ */ new Set();
       // prevent duplicate injection per turn
       // REG-26 (Patch C): Reflexion-style structured failure memory. Indexed by
@@ -571219,6 +571426,145 @@ ${parts.join("\n")}
       writesUserTaskArtifacts() {
         return this.options.artifactMode === "user-task" && !this.options.subAgent;
       }
+      _backendModelLabel(backend = this.backend) {
+        const b = backend;
+        const direct = b["model"] ?? b["resolvedModel"] ?? b["modelName"];
+        if (typeof direct === "string" && direct.trim())
+          return direct.trim();
+        const nested = b["config"];
+        if (nested && typeof nested === "object") {
+          const model = nested["model"];
+          if (typeof model === "string" && model.trim())
+            return model.trim();
+        }
+        return "unknown";
+      }
+      _emitModelResolutionTelemetry(purpose, turn) {
+        try {
+          const backendName = this.backend.constructor?.name ?? "unknown";
+          const resolved = this._backendModelLabel(this.backend);
+          this.emit({
+            type: "status",
+            content: `Model resolution: purpose=${purpose} resolved=${resolved} backend=${backendName}`,
+            turn,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        } catch {
+        }
+      }
+      _cosineSimilarity(a2, b) {
+        if (!a2 || !b || a2.length !== b.length || a2.length === 0)
+          return 0;
+        let dot = 0;
+        let na = 0;
+        let nb = 0;
+        for (let i2 = 0; i2 < a2.length; i2++) {
+          const av = a2[i2] ?? 0;
+          const bv = b[i2] ?? 0;
+          dot += av * bv;
+          na += av * av;
+          nb += bv * bv;
+        }
+        const denom = Math.sqrt(na) * Math.sqrt(nb);
+        return denom > 0 ? dot / denom : 0;
+      }
+      _embeddingBaseUrl() {
+        const raw = this.backend["baseUrl"] || "http://localhost:11434";
+        return raw.replace(/\/v1\/?$/, "");
+      }
+      _failurePatternText(pattern) {
+        return [
+          `signature: ${pattern.signature}`,
+          pattern.tool ? `tool: ${pattern.tool}` : "",
+          pattern.errorType ? `errorType: ${pattern.errorType}` : "",
+          pattern.guidance ? `guidance: ${pattern.guidance}` : ""
+        ].filter(Boolean).join("\n");
+      }
+      async _inferRelevantFailurePatternSignatures(taskGoal, candidates, maxPatterns) {
+        if (candidates.length === 0)
+          return /* @__PURE__ */ new Set();
+        try {
+          this._emitModelResolutionTelemetry("failure_pattern_relevance");
+          const backend = this._auxInferenceBackend();
+          const resp = await backend.chatCompletion({
+            messages: [
+              {
+                role: "system",
+                content: "You select prior failure patterns that are semantically relevant to the active task. Return only JSON."
+              },
+              {
+                role: "user",
+                content: JSON.stringify({
+                  taskGoal,
+                  max: maxPatterns,
+                  candidates: candidates.slice(0, 30).map((pattern) => ({
+                    signature: pattern.signature,
+                    tool: pattern.tool,
+                    errorType: pattern.errorType,
+                    guidance: pattern.guidance
+                  })),
+                  outputSchema: { relevant: ["signature"] }
+                })
+              }
+            ],
+            tools: [],
+            temperature: 0,
+            maxTokens: 500,
+            timeoutMs: 2e4
+          });
+          const raw = resp.choices?.[0]?.message?.content ?? "";
+          const start2 = raw.indexOf("{");
+          const end = raw.lastIndexOf("}");
+          if (start2 < 0 || end <= start2)
+            return /* @__PURE__ */ new Set();
+          const parsed = JSON.parse(raw.slice(start2, end + 1));
+          return new Set((parsed.relevant ?? []).map((item) => String(item)).filter((signature) => candidates.some((pattern) => pattern.signature === signature)).slice(0, maxPatterns));
+        } catch {
+          return /* @__PURE__ */ new Set();
+        }
+      }
+      async _selectTaskRelevantErrorPatterns(taskGoal, maxPatterns) {
+        const candidates = normalizeFailurePatterns(this._errorPatterns).slice(0, 40);
+        if (!taskGoal.trim() || candidates.length === 0)
+          return /* @__PURE__ */ new Map();
+        const selected = /* @__PURE__ */ new Map();
+        let selectedBy = "none";
+        try {
+          const embeddings = await generateEmbeddingBatch([taskGoal, ...candidates.map((pattern) => this._failurePatternText(pattern))], { baseUrl: this._embeddingBaseUrl(), timeoutMs: 12e3 });
+          const query = embeddings[0]?.vector;
+          const minScore = Number.parseFloat(process.env["OMNIUS_FAILURE_PATTERN_SIM_MIN"] ?? "0.58");
+          if (query) {
+            const scored = candidates.map((pattern, index) => ({
+              pattern,
+              score: embeddings[index + 1]?.vector ? this._cosineSimilarity(query, embeddings[index + 1].vector) : 0
+            })).filter((item) => item.score >= minScore).sort((a2, b) => b.score - a2.score).slice(0, maxPatterns);
+            for (const item of scored) {
+              const raw = this._errorPatterns.get(item.pattern.signature);
+              if (raw)
+                selected.set(item.pattern.signature, raw);
+            }
+            if (selected.size > 0)
+              selectedBy = "vector";
+          }
+        } catch {
+        }
+        if (selected.size === 0) {
+          const relevant = await this._inferRelevantFailurePatternSignatures(taskGoal, candidates, maxPatterns);
+          for (const signature of relevant) {
+            const raw = this._errorPatterns.get(signature);
+            if (raw)
+              selected.set(signature, raw);
+          }
+          if (selected.size > 0)
+            selectedBy = "inference";
+        }
+        this.emit({
+          type: "status",
+          content: `Failure handoff semantic selection: ${selected.size}/${candidates.length} persisted pattern(s) selected by ${selectedBy}`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return selected;
+      }
       _persistCompletionContract(contract) {
         if (!this.writesUserTaskArtifacts())
           return;
@@ -572584,7 +572930,7 @@ ${context2 ?? ""}`;
           `Task affect: uncertainty=${affect.uncertainty.toFixed(2)} frustration=${affect.frustration.toFixed(2)} confidence=${affect.confidence.toFixed(2)} momentum=${affect.momentum.toFixed(2)}`
         ].join("\n");
       }
-      _buildPreflightTaskMemoryRecall(taskGoal) {
+      async _buildPreflightTaskMemoryRecall(taskGoal) {
         if (process.env["OMNIUS_DISABLE_PREFLIGHT_MEMORY_RECALL"] === "1")
           return "";
         if (this.options.stateDir || this.options.subAgent)
@@ -572593,17 +572939,31 @@ ${context2 ?? ""}`;
           return "";
         try {
           const query = taskGoal.slice(0, 1e3);
-          const results = this._episodeStore.search({ query, limit: 6 });
-          const useful = results.filter((entry) => typeof entry.content === "string" && entry.content.trim().length >= 30).slice(0, 4);
+          const embedding = await generateEmbedding(query, {
+            baseUrl: this._embeddingBaseUrl(),
+            timeoutMs: 1e4
+          });
+          if (!embedding?.vector)
+            return "";
+          const results = this._episodeStore.search({ query, limit: 12 }, {
+            queryEmbedding: embedding.vector,
+            lexicalWeight: 0,
+            embeddingWeight: 1
+          });
+          const minScore = Number.parseFloat(process.env["OMNIUS_PREFLIGHT_MEMORY_SIM_MIN"] ?? "0.58");
+          const useful = results.map((entry) => ({
+            entry,
+            score: entry.embedding ? this._cosineSimilarity(embedding.vector, entry.embedding) : 0
+          })).filter(({ entry, score }) => typeof entry.content === "string" && entry.content.trim().length >= 30 && score >= minScore).sort((a2, b) => b.score - a2.score).slice(0, 3);
           if (useful.length === 0)
             return "";
-          const lines = useful.map((entry, index) => {
-            const tool = typeof entry.metadata?.["toolName"] === "string" ? ` tool=${entry.metadata["toolName"]}` : "";
-            return `${index + 1}. ${entry.content.replace(/\s+/g, " ").slice(0, 260)}${tool}`;
+          const lines = useful.map(({ entry, score }, index) => {
+            const tool = typeof entry.toolName === "string" && entry.toolName ? ` tool=${entry.toolName}` : "";
+            return `${index + 1}. sim=${score.toFixed(3)} ${entry.content.replace(/\s+/g, " ").slice(0, 260)}${tool}`;
           });
           return [
             `[PREFLIGHT MEMORY RECALL]`,
-            `Retrieved task-relevant prior episodes before the first action. Use these as hypotheses, not truth; verify against current files/UI.`,
+            `Retrieved vector-similar prior episodes before the first action. Use these as hypotheses, not truth; verify against current files/UI.`,
             ...lines,
             `If the current task resembles one of these, prefer the remembered working verification path and avoid the remembered failure pattern.`
           ].join("\n");
@@ -572716,9 +573076,26 @@ ${shellLines.join("\n")}` : "Commands run: none"
         const failCount = toolCallLog.filter((e2) => e2.success === false).length;
         evidenceParts.push(`Failed tool calls this run: ${failCount}`);
         const evidenceDigest = evidenceParts.join("\n");
+        const degraded = detectExplicitDegradedCompletion({
+          originalGoal,
+          actionsDigest,
+          evidenceDigest,
+          proposedSummary
+        });
+        if (degraded) {
+          this._resolutionGateRejections = 0;
+          this.emit({
+            type: "status",
+            content: `Resolution gate accepted explicit degraded completion: ${degraded.reason}`,
+            turn,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          return { proceed: true };
+        }
         let verdict = null;
         try {
           const backend = this._auxInferenceBackend();
+          this._emitModelResolutionTelemetry("completion_resolution", turn);
           for (let attempt = 0; attempt < 2 && !verdict; attempt++) {
             const resp = await backend.chatCompletion({
               messages: [
@@ -576151,6 +576528,7 @@ Respond with your assessment, then take action.`;
         this.pendingUserMessages.length = 0;
         const persistentTaskGoal = cleanForStorage(actualUserGoal || "") || cleanedTask;
         const userGoal = persistentTaskGoal.slice(0, 500);
+        this._taskRelevantErrorPatterns = process.env["OMNIUS_DISABLE_FAILURE_HANDOFF"] === "1" ? /* @__PURE__ */ new Map() : await this._selectTaskRelevantErrorPatterns(persistentTaskGoal, 10);
         this._taskState = {
           goal: userGoal,
           originalGoal: userGoal,
@@ -576195,6 +576573,7 @@ Respond with your assessment, then take action.`;
           contextWindowSize: this.options.contextWindowSize ?? 0,
           verbose: false
         });
+        this._emitModelResolutionTelemetry("main");
         this._hookManager.runSessionHook("session_start", this._sessionId);
         if (this.writesUserTaskArtifacts()) {
           this._initializeCompletionContract(task, context2, actualUserGoal);
@@ -576425,7 +576804,7 @@ TASK: ${scrubbedTask}` : scrubbedTask;
           ...missionCompletionContract ? [{ role: "system", content: missionCompletionContract }] : [],
           { role: "user", content: userContent }
         ];
-        const preflightMemoryRecall = this._buildPreflightTaskMemoryRecall(persistentTaskGoal);
+        const preflightMemoryRecall = await this._buildPreflightTaskMemoryRecall(persistentTaskGoal);
         if (preflightMemoryRecall) {
           messages2.splice(messages2.length - 1, 0, {
             role: "system",
@@ -576545,7 +576924,7 @@ TASK: ${scrubbedTask}` : scrubbedTask;
           try {
             const failureHandoff = buildFailureModeHandoff({
               taskGoal: persistentTaskGoal,
-              errorPatterns: this._errorPatterns,
+              errorPatterns: this._taskRelevantErrorPatterns,
               toolCallLog,
               taskState: this._taskState,
               maxPatterns: 10,
@@ -580022,13 +580401,15 @@ Respond with EXACTLY this structure before your next tool call:
                   default:
                     guidance = `This tool failed previously with a similar error. Review the error message carefully and adjust your approach before retrying.`;
                 }
-                this._errorPatterns.set(sig, {
+                const learnedPattern = {
                   count,
                   guidance,
                   lastSeen: Date.now(),
                   tool: tc.name,
                   errorType
-                });
+                };
+                this._errorPatterns.set(sig, learnedPattern);
+                this._taskRelevantErrorPatterns.set(sig, learnedPattern);
                 if (this._failureStore) {
                   try {
                     this._failureStore.insert({
@@ -580078,13 +580459,48 @@ Respond with EXACTLY this structure before your next tool call:
                 }
                 if (tc.name === "todo_write") {
                   try {
-                    const _todosNow = this.readSessionTodos() || [];
+                    let _todosNow = this.readSessionTodos() || [];
                     for (const _tp of _todosNow) {
                       const _tpId = _tp.id;
                       if (_tp.status === "in_progress" && _tpId && !this._todoInProgressTurn.has(_tpId)) {
                         this._todoInProgressTurn.set(_tpId, turn);
                       }
                     }
+                    const truth = reconcileCompletedTodosWithEvidence({
+                      todos: _todosNow,
+                      toolCallLog,
+                      todoStartTurnById: this._todoInProgressTurn
+                    });
+                    if (truth.changed) {
+                      const sid = this._sessionId || process.env["OMNIUS_SESSION_ID"] || "default";
+                      writeTodos(sid, truth.todos.map((t2) => ({
+                        id: t2.id,
+                        content: t2.content,
+                        status: t2.status,
+                        parentId: t2.parentId,
+                        blocker: t2.blocker,
+                        verifyCommand: t2.verifyCommand,
+                        declaredArtifacts: t2.declaredArtifacts
+                      })));
+                      _todosNow = this.readSessionTodos() || truth.todos;
+                      const downgradeLines = truth.downgrades.slice(0, 6).map((d2) => `- ${d2.content}: ${d2.from} -> ${d2.to}; ${d2.evidence}`).join("\n");
+                      messages2.push({
+                        role: "system",
+                        content: [
+                          `[TODO TRUTH RECONCILIATION]`,
+                          `One or more completed todo claims contradicted the evidence or nested child status and were rewritten in the active todo list.`,
+                          downgradeLines,
+                          ``,
+                          `Reconfigure the affected subtask tree now: read/verify the current state, choose a different tool or target if the prior route failed, or leave the child todo blocked with the root cause. Do not mark a parent completed until every child is completed with evidence.`
+                        ].join("\n")
+                      });
+                      this.emit({
+                        type: "status",
+                        content: `Todo truth reconciled ${truth.downgrades.length} completed claim(s) from evidence/nested child state`,
+                        turn,
+                        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                      });
+                    }
                     if (!this._newFieldNudgeFired) {
                       this._todoWritesObservedForNudge++;
                       const _anyFieldUsed = _todosNow.some((t2) => typeof t2.verifyCommand === "string" || Array.isArray(t2.declaredArtifacts));
@@ -580824,7 +581240,7 @@ Then use file_read on individual FILES inside it.`);
               if (process.env["OMNIUS_DISABLE_FAILURE_HANDOFF"] !== "1" && !result.success && turn - lastFailureHandoffTurn >= 4) {
                 const runtimeHandoff = buildFailureModeHandoff({
                   taskGoal: persistentTaskGoal,
-                  errorPatterns: this._errorPatterns,
+                  errorPatterns: this._taskRelevantErrorPatterns,
                   toolCallLog,
                   taskState: this._taskState,
                   maxPatterns: 5,
@@ -584348,7 +584764,7 @@ ${content.slice(0, 8e3)}
           try {
             const compactFailureHandoff = buildFailureModeHandoff({
               taskGoal: this._taskState.goal,
-              errorPatterns: this._errorPatterns,
+              errorPatterns: this._taskRelevantErrorPatterns,
               taskState: this._taskState,
               maxPatterns: 6,
               maxRecentCalls: 0
@@ -613124,6 +613540,33 @@ function buildTodoProgressBar(todos, maxWidth) {
   if (truncated && maxWidth > 0) out += `${DIM_LABEL}…${RESET3}`;
   return out;
 }
+function orderTodosForDisplay(todos) {
+  const byParent = /* @__PURE__ */ new Map();
+  const byId = new Set(todos.map((t2) => t2.id));
+  const roots = [];
+  for (const todo of todos) {
+    if (todo.parentId && byId.has(todo.parentId)) {
+      const arr = byParent.get(todo.parentId) ?? [];
+      arr.push(todo);
+      byParent.set(todo.parentId, arr);
+    } else {
+      roots.push(todo);
+    }
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (todo, depth) => {
+    if (seen.has(todo.id)) return;
+    seen.add(todo.id);
+    out.push({ ...todo, depth: Math.min(depth, 4) });
+    for (const child of byParent.get(todo.id) ?? []) {
+      visit(child, depth + 1);
+    }
+  };
+  for (const root of roots) visit(root, 0);
+  for (const todo of todos) visit(todo, 0);
+  return out;
+}
 function render() {
   if (!_enabled) return;
   if (!panelEffectivelyVisible()) {
@@ -613149,16 +613592,18 @@ function render() {
   const progressBar = buildTodoProgressBar(_lastTodos, maxBarWidth);
   const headerText = `${headerPrefix}${progressBar}`;
   lines.push(headerText);
-  const visible = _lastTodos.slice(0, MAX_VISIBLE_ROWS - 1);
+  const displayTodos = orderTodosForDisplay(_lastTodos);
+  const visible = displayTodos.slice(0, MAX_VISIBLE_ROWS - 1);
   for (const t2 of visible) {
     const { mark, color } = statusToAnsi(t2.status);
     const contentWidth = Math.max(4, cols - 8);
-    const contentText = t2.content + (t2.blocker ? ` (blocked: ${t2.blocker})` : "");
+    const indent2 = t2.depth > 0 ? `${"  ".repeat(t2.depth - 1)}- ` : "";
+    const contentText = indent2 + t2.content + (t2.blocker ? ` (blocked: ${t2.blocker})` : "");
     const truncated = truncate2(contentText, contentWidth);
     lines.push(`${color}${mark}${RESET3} ${color}${truncated}${RESET3}`);
   }
-  if (_lastTodos.length > visible.length) {
-    const more = _lastTodos.length - visible.length;
+  if (displayTodos.length > visible.length) {
+    const more = displayTodos.length - visible.length;
     lines[lines.length - 1] = `${DIM_LABEL}… +${more} more${RESET3}`;
   }
   let out = HIDE + SAVE;
@@ -717470,6 +717915,7 @@ When done, either call task_complete with your answer, or use FINAL_VAR(variable
       },
       async () => {
         const result = await runner.run(effectiveTask, systemContext);
+        _apiCallbacks?.onRunResult?.(result);
         const tokens = {
           total: result.totalTokens,
           estimated: result.estimatedTokens
@@ -723752,6 +724198,7 @@ async function runWithTUI(task, config, repoPath2, callbacks) {
     }
   }
   _apiCallbacks = callbacks ?? null;
+  const headlessMode = Boolean(callbacks);
   await bootstrapMcpAndPlugins(repoRoot);
   renderCompactHeader(config.model);
   renderUserMessage(task);
@@ -723762,6 +724209,10 @@ async function runWithTUI(task, config, repoPath2, callbacks) {
   try {
     const handle2 = startTask(task, config, repoRoot);
     await handle2.promise;
+    if (headlessMode) {
+      _apiCallbacks = null;
+      return;
+    }
     try {
       const ikDir = join174(repoRoot, ".omnius", "identity");
       const ikFile = join174(ikDir, "self-state.json");
@@ -724045,6 +724496,10 @@ Rules:
     } catch {
     }
   } catch (err) {
+    if (headlessMode) {
+      _apiCallbacks = null;
+      throw err;
+    }
     try {
       const ikFile = join174(repoRoot, ".omnius", "identity", "self-state.json");
       if (existsSync161(ikFile)) {
@@ -724271,6 +724726,7 @@ async function runJson(task, config, repoPath2) {
   let result;
   const assistantTexts = [];
   const toolCallLog = [];
+  let runnerResult = null;
   try {
     await runWithTUI(task, config, repoPath2, {
       onAssistantText: (text2) => {
@@ -724294,13 +724750,29 @@ async function runJson(task, config, repoPath2) {
       },
       onStatus: (content) => {
         origWrite(JSON.stringify({ type: "status", content }) + "\n");
+      },
+      onRunResult: (runResult) => {
+        runnerResult = {
+          status: runResult.status,
+          completed: runResult.completed,
+          summary: runResult.summary,
+          turns: runResult.turns,
+          toolCalls: runResult.toolCalls,
+          filesEdited: runResult.filesEdited,
+          testsRun: runResult.testsRun
+        };
       }
     });
+    const rr = runnerResult;
     result = {
-      status: "completed",
-      summary: extractSummary(captured),
+      status: rr?.completed ? "completed" : rr?.status ?? "completed",
+      summary: rr?.summary || extractSummary(captured),
+      turns: rr?.turns,
+      toolCalls: rr?.toolCalls,
+      filesModified: rr?.filesEdited,
+      testsRun: rr?.testsRun,
       durationMs: Date.now() - startTime,
-      exitCode: 0
+      exitCode: rr && !rr.completed ? 2 : 0
     };
   } catch (err) {
     result = {
@@ -724324,7 +724796,14 @@ async function runJson(task, config, repoPath2) {
     result.tool_calls = toolCallLog;
   }
   process.stdout.write(JSON.stringify(result, null, 2) + "\n");
-  if (result.exitCode !== 0) process.exit(1);
+  if (result.exitCode !== 0) process.exit(result.exitCode);
+  if (shouldForceJsonExit()) process.exit(0);
+}
+function shouldForceJsonExit() {
+  if (process.env["OMNIUS_JSON_NO_FORCE_EXIT"] === "1") return false;
+  if (process.env["VITEST"] === "true" || process.env["NODE_ENV"] === "test")
+    return false;
+  return true;
 }
 function extractSummary(captured) {
   const all2 = captured.join("");

package/npm-shrinkwrap.json

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

package/package.json

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