omnius 1.0.452 → 1.0.454

package/dist/index.js

@@ -14361,6 +14361,22 @@ var init_file_edit = __esm({
           }
           const occurrences = countOccurrences(content, oldString);
           if (occurrences === 0) {
+            const alreadyAppliedLines = newString.length > 0 ? findMatchLines(content, newString) : [];
+            if (alreadyAppliedLines.length > 0) {
+              const lineInfo = alreadyAppliedLines.length === 1 ? `line ${alreadyAppliedLines[0]}` : `${alreadyAppliedLines.length} locations (lines ${alreadyAppliedLines.join(", ")})`;
+              return {
+                success: true,
+                output: `[ALREADY APPLIED — ${filePath} already contains the requested new_string at ${lineInfo}; old_string is absent. No disk changes were made.]`,
+                durationMs: performance.now() - start2,
+                mutated: false,
+                mutatedFiles: [],
+                diff: buildCompactDiff(oldString, newString),
+                noop: true,
+                alreadyApplied: true,
+                beforeHash,
+                afterHash: beforeHash
+              };
+            }
             const snippet = findClosestSnippet(content, oldString, 5);
             let errorMsg = `old_string not found in ${filePath}.`;
             if (snippet) {
@@ -28439,6 +28455,9 @@ function findMatchOffsetsBatch(haystack, needle) {
   }
   return offsets;
 }
+function findMatchLinesBatch(haystack, needle) {
+  return findMatchOffsetsBatch(haystack, needle).map((offset) => haystack.slice(0, offset).split("\n").length);
+}
 function countOccurrences2(haystack, needle) {
   let count = 0;
   let pos = 0;
@@ -28587,6 +28606,7 @@ var init_batch_edit = __esm({
         }
         const results = [];
         let successCount = 0;
+        let alreadyAppliedCount = 0;
         let failCount = 0;
         const pendingWrites = [];
         for (const [fullPath, fileEdits] of byFile) {
@@ -28607,10 +28627,18 @@ var init_batch_edit = __esm({
             }
             const originalContent = content;
             let fileSuccessCount = 0;
+            let fileAlreadyAppliedCount = 0;
             let fileFailed = false;
             for (const edit of fileEdits) {
               const occurrences = countOccurrences2(content, edit.old_string);
               if (occurrences === 0) {
+                const alreadyAppliedLines = edit.new_string.length > 0 ? findMatchLinesBatch(content, edit.new_string) : [];
+                if (alreadyAppliedLines.length > 0) {
+                  const lineInfo = alreadyAppliedLines.length === 1 ? `line ${alreadyAppliedLines[0]}` : `${alreadyAppliedLines.length} locations (lines ${alreadyAppliedLines.join(", ")})`;
+                  results.push(`ALREADY_APPLIED: ${edit.relPath} already contains requested new_string at ${lineInfo}; old_string is absent`);
+                  fileAlreadyAppliedCount++;
+                  continue;
+                }
                 const snippet = findClosestSnippet(content, edit.old_string, 5);
                 if (snippet) {
                   const pct = Math.round(snippet.similarity * 100);
@@ -28657,6 +28685,8 @@ ${s2.content}`;
             const afterHash = contentHash(content);
             if (afterHash === beforeHash) {
               results.push(`NO-OP: ${fileEdits[0].relPath} batch produced no disk changes`);
+              successCount += fileAlreadyAppliedCount;
+              alreadyAppliedCount += fileAlreadyAppliedCount;
               continue;
             }
             pendingWrites.push({
@@ -28667,7 +28697,8 @@ ${s2.content}`;
               afterHash,
               editCount: fileSuccessCount
             });
-            successCount += fileSuccessCount;
+            successCount += fileSuccessCount + fileAlreadyAppliedCount;
+            alreadyAppliedCount += fileAlreadyAppliedCount;
           } catch (error) {
             results.push(`ERROR: ${fullPath}: ${error instanceof Error ? error.message : String(error)}`);
             failCount++;
@@ -28692,7 +28723,7 @@ ${s2.content}`;
         ].join("\n") : dryRun ? [
           `BATCH_VALIDATED_ONLY: ${appliedCount} edit(s) validated, 0 failed across ${byFile.size} file(s).`,
           `NO FILES WERE MODIFIED. Call again with dry_run=false to apply this atomic batch.`
-        ].join("\n") : `BATCH_COMMITTED: ${appliedCount} edit(s) applied, 0 failed across ${byFile.size} file(s).`;
+        ].join("\n") : pendingWrites.length === 0 && alreadyAppliedCount > 0 ? `BATCH_NOOP_ALREADY_APPLIED: ${alreadyAppliedCount} edit(s) already satisfied, 0 failed across ${byFile.size} file(s).` : `BATCH_COMMITTED: ${appliedCount} edit(s) satisfied (${pendingWrites.reduce((sum, write2) => sum + write2.editCount, 0)} applied, ${alreadyAppliedCount} already applied), 0 failed across ${byFile.size} file(s).`;
         const detailOutput = failCount === 0 ? dryRun ? results.join("\n") : results.map((line) => line.replace(/^VALIDATED_ONLY:/, "APPLIED:").replace(/ pending atomic commit/g, "")).join("\n") : results.join("\n");
         return {
           success: failCount === 0,
@@ -28703,6 +28734,7 @@ ${detailOutput}`,
           mutated: failCount === 0 && !dryRun && pendingWrites.length > 0,
           mutatedFiles: failCount === 0 && !dryRun ? pendingWrites.map((w) => w.relPath) : [],
           noop: failCount === 0 && pendingWrites.length === 0,
+          alreadyApplied: failCount === 0 && alreadyAppliedCount > 0,
           dryRun: dryRun || void 0,
           partial: false,
           beforeHash: pendingWrites.length === 1 ? pendingWrites[0].beforeHash : void 0,
@@ -298462,11 +298494,12 @@ var init_todo_write = __esm({
 
 ## Nested decomposition
 - Use stable ids plus parentId to create subtasks under a parent objective.
+- Prefer a parent + child leaf todos for any active objective that has multiple concrete actions; the TUI renders the active branch indented for the user and for your next-turn context.
 - 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"}]})`;
+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 nested shape: todo_write({"todos":[{"id":"p1","content":"Implement feature","status":"in_progress","children":[{"id":"c1","content":"Inspect files","status":"in_progress"},{"id":"c2","content":"Make changes","status":"pending"},{"id":"c3","content":"Verify results","status":"pending"}]}]})`;
       parameters = {
         type: "object",
         required: ["todos"],
@@ -298643,11 +298676,15 @@ 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.",
+            decompositionContract: "Use parentId for sub-todos. Split the active objective into concrete child leaf todos whenever it contains multiple remaining actions. 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
           };
+          const hasNestedTodos = incoming.some((todo) => typeof todo.parentId === "string" && todo.parentId.trim().length > 0);
+          if (incoming.length >= 3 && !hasNestedTodos) {
+            payload["decompositionHint"] = "This checklist is still flat. If the current in_progress item expands into multiple actions, rewrite it as a parent with child todos using stable ids and parentId/children so the active branch stays visible.";
+          }
           if (repairNotes.length > 0) {
             payload["inputRepair"] = Array.from(new Set(repairNotes));
             payload["canonicalShape"] = {
@@ -573482,7 +573519,7 @@ function recordContextWindowDump(input) {
     const payload = JSON.stringify(record, null, 2);
     writeFileSync48(filePath, payload, "utf-8");
     writeFileSync48(join111(dir, `latest-${record.agentType}.json`), payload, "utf-8");
-    if (record.agentType === "main") {
+    if (record.agentType === "main" || record.agentType === "sub-agent" || record.agentType === "adversary") {
       writeFileSync48(join111(dir, "latest.json"), payload, "utf-8");
     }
     appendFileSync9(join111(dir, "index.jsonl"), JSON.stringify(toSummary(record, filePath)) + "\n", "utf-8");
@@ -574296,6 +574333,10 @@ function updateGlobalIndex(paths, runIndex) {
     schemaVersion: 1,
     updatedAt: now2,
     root: paths.root,
+    runCount: 0,
+    latestRun: null,
+    diagnoses: {},
+    anchors: [],
     runs: []
   };
   next.updatedAt = now2;
@@ -574315,8 +574356,35 @@ function updateGlobalIndex(paths, runIndex) {
     entry,
     ...next.runs.filter((item) => item.runId !== runIndex.runId)
   ].slice(0, 100);
+  next.runCount = next.runs.length;
+  next.latestRun = {
+    runId: runIndex.runId,
+    sessionId: runIndex.sessionId,
+    cwd: runIndex.cwd,
+    updatedAt: runIndex.updatedAt,
+    eventCount: runIndex.summary.eventCount,
+    failureCount: runIndex.summary.failureCount,
+    focusBlockCount: runIndex.summary.focusBlockCount,
+    suspiciousShellCount: runIndex.summary.suspiciousShellCount,
+    readmePath: runIndex.readmePath,
+    indexPath: runIndex.indexPath
+  };
+  next.diagnoses = aggregateGlobalDiagnoses(next.runs);
+  next.anchors = buildAnchors(runIndex.cwd, runIndex.runId, paths);
   writeFileSync49(paths.globalIndexPath, JSON.stringify(next, null, 2), "utf-8");
 }
+function aggregateGlobalDiagnoses(runs) {
+  const totals = {};
+  for (const run2 of runs) {
+    const index = readJson2(run2.indexPath);
+    if (!index?.diagnoses)
+      continue;
+    for (const [name10, count] of Object.entries(index.diagnoses)) {
+      totals[name10] = (totals[name10] ?? 0) + count;
+    }
+  }
+  return Object.fromEntries(Object.entries(totals).sort((a2, b) => b[1] - a2[1] || a2[0].localeCompare(b[0])));
+}
 function buildAnchors(cwd4, runId, paths, extra = []) {
   const omniusDir = join112(cwd4, ".omnius");
   const raw = [
@@ -574701,14 +574769,13 @@ function resolveFocusSupervisorMode(configured, envValue = process.env["OMNIUS_F
 function violatesDirective(directive, input) {
   if (input.toolName === "task_complete") {
     const completionStatus = normalizeCompletionStatus(input.completionStatus ?? input.args?.["status"] ?? input.args?.["completion_status"] ?? input.args?.["completionStatus"]);
-    const reportsDegradedCompletion = completionStatus === "blocked" || completionStatus === "incomplete" || completionStatus === "needs_input";
-    if (directive.requiredNextAction === "use_cached_evidence") {
-      return false;
-    }
-    if (reportsDegradedCompletion && (directive.requiredNextAction === "read_authoritative_target" || directive.requiredNextAction === "report_blocked" || directive.requiredNextAction === "report_incomplete")) {
-      return false;
+    const summaryText = typeof input.args?.["summary"] === "string" ? input.args["summary"] : "";
+    const summaryReportsDegraded = /^\s*(BLOCKED|INCOMPLETE|NEEDS[_ -]?INPUT)\b\s*:?/i.test(summaryText);
+    const reportsDegradedCompletion = completionStatus === "blocked" || completionStatus === "incomplete" || completionStatus === "needs_input" || summaryReportsDegraded;
+    if (directive.requiredNextAction === "report_blocked" || directive.requiredNextAction === "report_incomplete" || directive.state === "terminal_incomplete") {
+      return !reportsDegradedCompletion;
     }
-    return directive.requiredNextAction !== "report_blocked" && directive.requiredNextAction !== "report_incomplete";
+    return false;
   }
   if (input.toolName === "ask_user")
     return false;
@@ -574989,6 +575056,11 @@ var init_focusSupervisor = __esm({
         const family = actionFamily(input.toolName, input.args);
         const prior = this.directive;
         if (prior && violatesDirective(prior, input)) {
+          if (prior.state === "warn") {
+            this.lastDecision = "warn_not_enforced";
+            this.lastReason = prior.reason;
+            return this.pass();
+          }
           const strict = this.shouldStrictlyIntervene(input.context);
           const sameTurnAsDirective = input.turn <= prior.createdTurn;
           const alreadyCountedThisTurn = this.lastIgnoredDirectiveTurn === input.turn;
@@ -575105,6 +575177,10 @@ var init_focusSupervisor = __esm({
           this.clearSatisfiedDirective("mutation landed", input.turn);
           return;
         }
+        if (input.success && input.alreadyApplied) {
+          this.clearSatisfiedDirective("requested edit already applied", input.turn);
+          return;
+        }
         if (input.runtimeAuthored) {
           this.lastDecision = "runtime_authored_not_satisfied";
           this.lastReason = "runtime-authored control result did not execute the requested tool";
@@ -577627,7 +577703,7 @@ function computeTodoReminder(input) {
   if (!input.todos || input.todos.length === 0) {
     if (input.elicitCreateOnEmptyTodos) {
       const content2 = `<system-reminder>
-No todo plan exists yet. Consider using the todo_write tool to create a plan for the current task — break the goal into ordered steps, mark the first step in_progress, and keep the rest pending. This helps you stay organized and track progress. Make sure that you NEVER mention this reminder to the user.
+No todo plan exists yet. Consider using the todo_write tool to create a plan for the current task — break the goal into parent objectives and child leaf subtasks when the work has multiple actions, mark the active leaf in_progress, and keep the rest pending. This helps you stay organized and track progress. Make sure that you NEVER mention this reminder to the user.
 </system-reminder>`;
       return { shouldInject: true, content: content2, reason: "elicit_create" };
     }
@@ -577647,9 +577723,9 @@ No todo plan exists yet. Consider using the todo_write tool to create a plan for
       return { shouldInject: false, content: null, reason: "recent_reminder" };
     }
   }
-  const todoItems = input.todos.slice(0, 12).map((t2, i2) => `${i2 + 1}. [${t2.status}] ${t2.content}`).join("\n");
+  const todoItems = formatTodoReminderItems(input.todos, 12);
   const content = `<system-reminder>
-The todo_write tool hasn't been used recently. Review your todo list below. If you're working on a task, mark it in_progress. When you complete a task, mark it completed immediately — don't batch completions. If the list is stale, clean it up. Make sure that you NEVER mention this reminder to the user.
+The todo_write tool hasn't been used recently. Review your todo list below. If you're working on a task, mark the active leaf in_progress. When you complete a leaf task, mark it completed immediately — don't batch completions. If the current item has multiple remaining actions, decompose it with stable ids and parentId/children instead of flattening the list. If the list is stale, clean it up. Make sure that you NEVER mention this reminder to the user.
 
 Here are the existing contents of your todo list:
 
@@ -577657,6 +577733,40 @@ ${todoItems}
 </system-reminder>`;
   return { shouldInject: true, content, reason: "injected" };
 }
+function formatTodoReminderItems(todos, maxRows) {
+  const byId = new Map(todos.filter((todo) => typeof todo.id === "string" && todo.id.trim().length > 0).map((todo) => [todo.id, todo]));
+  const byParent = /* @__PURE__ */ new Map();
+  const roots = [];
+  for (const todo of todos) {
+    if (todo.parentId && byId.has(todo.parentId)) {
+      const siblings = byParent.get(todo.parentId) ?? [];
+      siblings.push(todo);
+      byParent.set(todo.parentId, siblings);
+    } else {
+      roots.push(todo);
+    }
+  }
+  const rows = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (todo, depth) => {
+    if (rows.length >= maxRows || seen.has(todo))
+      return;
+    seen.add(todo);
+    const indent2 = "  ".repeat(Math.min(depth, 4));
+    rows.push(`${indent2}- [${todo.status}] ${todo.content}`);
+    if (!todo.id)
+      return;
+    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);
+  if (todos.length > rows.length)
+    rows.push(`... +${todos.length - rows.length} more`);
+  return rows.join("\n");
+}
 function stripThinkBlocks(s2) {
   if (!s2)
     return s2;
@@ -577946,6 +578056,7 @@ var init_agenticRunner = __esm({
     init_context_compressor();
     init_reflectionBuffer();
     init_taskHandoff();
+    init_artifactQuality();
     init_messageLog();
     init_contextTree();
     init_codeGraphLink();
@@ -578844,16 +578955,21 @@ ${parts.join("\n")}
             lines.push("implementation_state=mutation evidence is already recorded; do not treat discovery as the active phase");
           }
         }
-        const todos = this.readSessionTodos() ?? [];
+        const todos = this._normalizeTodosForPrompt(this.readSessionTodos() ?? []);
         if (todos.length > 0) {
-          const inProgress = todos.filter((todo) => todo.status === "in_progress");
-          const pending2 = todos.filter((todo) => todo.status === "pending");
-          const blocked = todos.filter((todo) => todo.status === "blocked");
-          lines.push(`todo_counts=in_progress:${inProgress.length} pending:${pending2.length} blocked:${blocked.length}`);
-          if (inProgress[0]) {
-            lines.push(`todo_current=${inProgress[0].content.slice(0, 180)}`);
+          const index = this._todoTreeIndex(todos);
+          const leaves = this._todoLeaves(todos, index);
+          const active = this._activeTodoForPrompt(todos, index);
+          const inProgress = leaves.filter((todo) => todo.status === "in_progress");
+          const pending2 = leaves.filter((todo) => todo.status === "pending");
+          const blocked = leaves.filter((todo) => todo.status === "blocked");
+          const completed = leaves.filter((todo) => todo.status === "completed");
+          lines.push(`todo_leaf_counts=completed:${completed.length} in_progress:${inProgress.length} pending:${pending2.length} blocked:${blocked.length}`);
+          if (active) {
+            const branch = this._todoPath(active, index).map((todo) => todo.content.slice(0, 64)).join(" > ");
+            lines.push(`todo_active_branch=${branch.slice(0, 220)}`);
           } else if (pending2.length > 0) {
-            lines.push("todo_contract=mark exactly one pending todo in_progress before using the checklist as progress");
+            lines.push("todo_contract=mark one pending leaf todo in_progress before using the checklist as progress");
           }
         }
         if (lines.length === 2)
@@ -578863,7 +578979,7 @@ ${parts.join("\n")}
       }
       _workboardTargetCardId(snapshot, toolName, result, meta = {}) {
         const byId = new Map(snapshot.cards.map((card) => [card.id, card]));
-        if (this._isProjectEditTool(toolName) && this._isRealProjectMutation(toolName, result)) {
+        if (this._isProjectEditTool(toolName) && (this._isRealProjectMutation(toolName, result) || result?.alreadyApplied === true)) {
           return byId.has("implement-repair") ? "implement-repair" : null;
         }
         if (toolName === "shell" && meta.shellFilesystemMutation === true) {
@@ -578889,9 +579005,9 @@ ${parts.join("\n")}
         const dir = this._workboardDir();
         let current = snapshot;
         const byId = () => new Map(current.cards.map((card) => [card.id, card]));
-        const editMutation = this._isProjectEditTool(toolName) && this._isRealProjectMutation(toolName, result) || toolName === "shell" && result?.success === true && meta.shellFilesystemMutation === true;
+        const editEvidence = this._isProjectEditTool(toolName) && (this._isRealProjectMutation(toolName, result) || result?.alreadyApplied === true) || toolName === "shell" && result?.success === true && meta.shellFilesystemMutation === true;
         try {
-          if (editMutation) {
+          if (editEvidence) {
             let cards = byId();
             const discovery = cards.get("discover-current-state");
             if (discovery && discovery.status !== "verified" && discovery.evidence.length > 0) {
@@ -578924,7 +579040,7 @@ ${parts.join("\n")}
                 cardId: implementation2.id,
                 actor,
                 updates: { status: "in_progress", lane: "worker" },
-                decisionReason: "Real project mutation landed; implementation is now the active phase."
+                decisionReason: result?.alreadyApplied === true ? "Requested implementation edit was already present on disk; implementation evidence is now active." : "Real project mutation landed; implementation is now the active phase."
               });
             }
           }
@@ -578961,7 +579077,7 @@ ${parts.join("\n")}
           return;
         if (meta.focusDecisionKind === "block_tool_call")
           return;
-        if (result?.success === true && this._isProjectEditTool(toolName) && !this._isRealProjectMutation(toolName, result)) {
+        if (result?.success === true && this._isProjectEditTool(toolName) && !this._isRealProjectMutation(toolName, result) && result.alreadyApplied !== true) {
           return;
         }
         const dir = this._workboardDir();
@@ -580430,6 +580546,127 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
           return null;
         }
       }
+      _normalizeTodosForPrompt(todos) {
+        return todos.map((todo, index) => {
+          const rawId = todo.id;
+          const id2 = typeof rawId === "string" && rawId.trim().length > 0 ? rawId.trim() : `prompt-${index}`;
+          const rawParentId = todo.parentId;
+          const parentId = typeof rawParentId === "string" && rawParentId.trim().length > 0 ? rawParentId.trim() : void 0;
+          const createdAt = typeof todo.createdAt === "number" ? todo.createdAt : 0;
+          const updatedAt = typeof todo.updatedAt === "number" ? todo.updatedAt : createdAt;
+          return {
+            ...todo,
+            id: id2,
+            ...parentId ? { parentId } : {},
+            createdAt,
+            updatedAt
+          };
+        });
+      }
+      _todoTreeIndex(todos) {
+        const byId = new Map(todos.map((todo) => [todo.id, todo]));
+        const byParent = /* @__PURE__ */ new Map();
+        const roots = [];
+        for (const todo of todos) {
+          if (todo.parentId && byId.has(todo.parentId)) {
+            const siblings = byParent.get(todo.parentId) ?? [];
+            siblings.push(todo);
+            byParent.set(todo.parentId, siblings);
+          } else {
+            roots.push(todo);
+          }
+        }
+        return { byId, byParent, roots };
+      }
+      _todoDisplayStatus(todo, index, seen = /* @__PURE__ */ new Set()) {
+        if (seen.has(todo.id))
+          return todo.status;
+        seen.add(todo.id);
+        const children2 = index.byParent.get(todo.id) ?? [];
+        if (children2.length === 0)
+          return todo.status;
+        const childStatuses = children2.map((child) => this._todoDisplayStatus(child, index, new Set(seen)));
+        if (childStatuses.some((status) => status === "blocked"))
+          return "blocked";
+        if (childStatuses.some((status) => status === "in_progress"))
+          return "in_progress";
+        if (childStatuses.every((status) => status === "completed"))
+          return "completed";
+        if (todo.status === "completed")
+          return "in_progress";
+        return todo.status;
+      }
+      _todoLeafStats(todo, index) {
+        const children2 = index.byParent.get(todo.id) ?? [];
+        if (children2.length === 0)
+          return null;
+        let completed = 0;
+        let total = 0;
+        const seen = /* @__PURE__ */ new Set();
+        const visit = (node) => {
+          if (seen.has(node.id))
+            return;
+          seen.add(node.id);
+          const nested = index.byParent.get(node.id) ?? [];
+          if (nested.length === 0) {
+            total++;
+            if (node.status === "completed")
+              completed++;
+            return;
+          }
+          for (const child of nested)
+            visit(child);
+        };
+        for (const child of children2)
+          visit(child);
+        return { completed, total };
+      }
+      _todoLeaves(todos, index = this._todoTreeIndex(todos)) {
+        const leaves = todos.filter((todo) => (index.byParent.get(todo.id) ?? []).length === 0);
+        return leaves.length > 0 ? leaves : todos;
+      }
+      _todoPath(todo, index) {
+        const path12 = [todo];
+        const seen = /* @__PURE__ */ new Set([todo.id]);
+        let cursor = todo;
+        while (cursor?.parentId && index.byId.has(cursor.parentId)) {
+          const parent = index.byId.get(cursor.parentId);
+          if (!parent || seen.has(parent.id))
+            break;
+          path12.unshift(parent);
+          seen.add(parent.id);
+          cursor = parent;
+        }
+        return path12;
+      }
+      _activeTodoForPrompt(todos, index = this._todoTreeIndex(todos)) {
+        const leaves = this._todoLeaves(todos, index);
+        return leaves.find((todo) => todo.status === "in_progress") ?? todos.find((todo) => this._todoDisplayStatus(todo, index) === "in_progress") ?? todos.find((todo) => this._todoDisplayStatus(todo, index) === "blocked") ?? todos.find((todo) => this._todoDisplayStatus(todo, index) === "pending") ?? null;
+      }
+      _orderedTodosForPrompt(todos) {
+        const index = this._todoTreeIndex(todos);
+        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),
+            displayStatus: this._todoDisplayStatus(todo, index),
+            childStats: this._todoLeafStats(todo, index)
+          });
+          for (const child of index.byParent.get(todo.id) ?? []) {
+            visit(child, depth + 1);
+          }
+        };
+        for (const root of index.roots)
+          visit(root, 0);
+        for (const todo of todos)
+          visit(todo, 0);
+        return out;
+      }
       _normalizeCommandForValidationMatch(command) {
         return normalizeShellCommand(command);
       }
@@ -580584,7 +580821,9 @@ ${modelVisible}` : modelVisible || result.error || displayOutput || "";
         const realFileMutation = input.realFileMutation ?? this._isRealProjectMutation(input.toolName, input.result);
         const attemptedTargetPaths = this._extractToolTargetPaths(input.toolName, input.args, input.result);
         const realMutationPaths = input.realMutationPaths ?? (realFileMutation ? attemptedTargetPaths : []);
-        if (input.result.success === true && this._isProjectEditTool(input.toolName) && !realFileMutation) {
+        const shellVerification = input.toolName === "shell" && input.result.runtimeAuthored !== true && this._shellResultLooksLikeVerification(input.args, input.result);
+        const shellVerificationFamily = shellVerification ? this._shellVerificationFamily(input.args) : "";
+        if (input.result.success === true && this._isProjectEditTool(input.toolName) && !realFileMutation && input.result.alreadyApplied !== true) {
           return;
         }
         if (this._shouldSuppressCompletionDiscoveryEvidence(input.toolName, input.result, attemptedTargetPaths)) {
@@ -580596,9 +580835,9 @@ ${modelVisible}` : modelVisible || result.error || displayOutput || "";
           outputPreview: (input.outputPreview ?? this._toolEvidencePreview(input.result, void 0, 1200, input.toolName)).toString().slice(0, input.toolName === "audio_analyze" || input.toolName === "video_understand" ? 1200 : 500),
           argsKey: input.argsKey.slice(0, 300),
           targetPaths: attemptedTargetPaths,
-          role: input.result.completionEvidenceRole ?? (realFileMutation ? "mutation" : input.result.runtimeAuthored === true ? "blocker" : void 0),
-          family: input.result.completionEvidenceFamily ?? (input.result.runtimeAuthored === true ? "runtime_control" : void 0),
-          verificationImpact: input.result.completionVerificationImpact ?? (realFileMutation ? "invalidates" : void 0),
+          role: input.result.completionEvidenceRole ?? (input.result.alreadyApplied === true ? "mutation" : realFileMutation ? "mutation" : input.result.runtimeAuthored === true ? "blocker" : shellVerification ? "verification" : void 0),
+          family: input.result.completionEvidenceFamily ?? (input.result.runtimeAuthored === true ? "runtime_control" : shellVerification ? shellVerificationFamily : void 0),
+          verificationImpact: input.result.completionVerificationImpact ?? (input.result.alreadyApplied === true ? "neutral" : realFileMutation ? "invalidates" : void 0),
           metrics: input.result.completionEvidenceMetrics
         });
         if (realFileMutation && realMutationPaths.length > 0) {
@@ -580617,6 +580856,20 @@ ${modelVisible}` : modelVisible || result.error || displayOutput || "";
         }
         this._saveCompletionLedgerSafe();
       }
+      _shellVerificationFamily(args) {
+        const command = String(args?.["command"] ?? args?.["cmd"] ?? "").trim();
+        const normalized = normalizeShellCommand(command);
+        return `shell:${(normalized || command || "verification").slice(0, 160)}`;
+      }
+      _shellResultLooksLikeVerification(args, result) {
+        const command = String(args?.["command"] ?? args?.["cmd"] ?? "");
+        if (!command.trim())
+          return false;
+        const text2 = `${command}
+${result.output ?? ""}
+${result.error ?? ""}`;
+        return /\b(test|tests|vitest|jest|pytest|go test|cargo test|npm test|pnpm test|yarn test|typecheck|tsc|build|verify|verification|check)\b/i.test(text2);
+      }
       _shouldSuppressCompletionDiscoveryEvidence(toolName, result, targetPaths) {
         if (result.success !== true)
           return false;
@@ -581097,6 +581350,9 @@ ${context2 ?? ""}`;
         const originalGoal = (this._taskState.originalGoal || this._taskState.goal || "").trim();
         if (!originalGoal)
           return { proceed: true };
+        if (/^\s*(BLOCKED|INCOMPLETE|NEEDS_INPUT)\b\s*:?/i.test(proposedSummary)) {
+          return { proceed: true };
+        }
         const actionable = toolCallLog.some((e2) => e2.mutated || e2.name === "shell" || e2.name === "file_write" || e2.name === "file_edit");
         if (!actionable)
           return { proceed: true };
@@ -581319,6 +581575,9 @@ ${outTail || "(no output captured)"}`,
         const _verify = await this._runCompletionVerifyGate(turn);
         if (!_verify.proceed)
           return _verify;
+        if (this.options.backwardPassReview === false || this.options.disableAdversaryCritic === true) {
+          return { proceed: true };
+        }
         const _resolution = await this._runResolutionGate(turn, proposedSummary, toolCallLog);
         if (!_resolution.proceed) {
           return {
@@ -581662,14 +581921,18 @@ ${_checks}`
         const parts = [];
         const todos = this.readSessionTodos();
         if (todos && todos.length > 0) {
-          const current = todos.find((t2) => t2.status === "in_progress");
-          const completedN = todos.filter((t2) => t2.status === "completed").length;
+          const index = this._todoTreeIndex(todos);
+          const leaves = this._todoLeaves(todos, index);
+          const current = this._activeTodoForPrompt(todos, index);
+          const completedN = leaves.filter((t2) => t2.status === "completed").length;
+          const totalN = leaves.length;
           if (current) {
-            parts.push(`[plan: ${completedN}/${todos.length} complete · currently: ${current.content.slice(0, 80)}]`);
+            const path12 = this._todoPath(current, index).map((todo) => todo.content.slice(0, 64)).join(" > ");
+            parts.push(`[plan: ${completedN}/${totalN} leaf tasks complete · active: ${path12.slice(0, 160)}]`);
           } else {
-            const nextPending = todos.find((t2) => t2.status === "pending");
+            const nextPending = leaves.find((t2) => t2.status === "pending");
             if (nextPending) {
-              parts.push(`[plan: ${completedN}/${todos.length} complete · next: ${nextPending.content.slice(0, 80)}]`);
+              parts.push(`[plan: ${completedN}/${totalN} leaf tasks complete · next: ${nextPending.content.slice(0, 80)}]`);
             }
           }
         }
@@ -582641,36 +582904,73 @@ ${latest.output || ""}`.trim();
        */
       _renderTodoStateBlock(turn) {
         try {
-          const todos = this.readSessionTodos();
+          const todos = this._normalizeTodosForPrompt(this.readSessionTodos() ?? []);
           if (!todos || todos.length === 0)
             return null;
+          const index = this._todoTreeIndex(todos);
+          const leaves = this._todoLeaves(todos, index);
+          const completedLeaves = leaves.filter((t2) => t2.status === "completed");
+          const active = this._activeTodoForPrompt(todos, index);
+          const activePath = active ? this._todoPath(active, index).map((todo) => todo.content.slice(0, 80)).join(" > ") : "";
           const lines = [
-            "[CURRENT TODO PLAN — already in your state, no need to call todo_write to see it]"
+            "[CURRENT TODO PLAN — already in your state, no need to call todo_write to see it]",
+            `leaf_progress=${completedLeaves.length}/${leaves.length}`
           ];
-          const inProg = todos.filter((t2) => t2.status === "in_progress");
-          const pending2 = todos.filter((t2) => t2.status === "pending");
-          const done = todos.filter((t2) => t2.status === "completed");
-          const blocked = todos.filter((t2) => t2.status === "blocked");
-          if (inProg.length > 0) {
-            lines.push(`▶ in_progress (${inProg.length}):`);
-            for (const t2 of inProg)
-              lines.push(`  • ${t2.content}`);
-          }
-          if (pending2.length > 0) {
-            lines.push(`◯ pending (${pending2.length}):`);
-            for (const t2 of pending2.slice(0, 8))
-              lines.push(`  • ${t2.content}`);
-            if (pending2.length > 8)
-              lines.push(`  … +${pending2.length - 8} more`);
+          if (activePath)
+            lines.push(`active_branch=${activePath.slice(0, 220)}`);
+          const ordered = this._orderedTodosForPrompt(todos);
+          const activeIndex = active ? ordered.findIndex((entry) => entry.todo.id === active.id) : -1;
+          let visible = ordered;
+          if (ordered.length > 14) {
+            const selected = [];
+            const seen = /* @__PURE__ */ new Set();
+            const add3 = (entry) => {
+              if (!entry || selected.length >= 13 || seen.has(entry.todo.id))
+                return;
+              selected.push(entry);
+              seen.add(entry.todo.id);
+            };
+            if (active && activeIndex >= 0) {
+              const pathIds = new Set(this._todoPath(active, index).map((t2) => t2.id));
+              for (const entry of ordered) {
+                if (pathIds.has(entry.todo.id) && entry.todo.id !== active.id)
+                  add3(entry);
+              }
+              const siblings = active.parentId ? index.byParent.get(active.parentId) ?? [] : index.roots;
+              const siblingIndex = siblings.findIndex((t2) => t2.id === active.id);
+              if (siblingIndex > 0) {
+                add3(ordered.find((entry) => entry.todo.id === siblings[siblingIndex - 1]?.id));
+              }
+              add3(ordered[activeIndex]);
+              for (let i2 = siblingIndex + 1; i2 < siblings.length && selected.length < 13; i2++) {
+                add3(ordered.find((entry) => entry.todo.id === siblings[i2]?.id));
+              }
+              for (const child of index.byParent.get(active.id) ?? []) {
+                add3(ordered.find((entry) => entry.todo.id === child.id));
+              }
+              for (let i2 = activeIndex + 1; i2 < ordered.length && selected.length < 13; i2++) {
+                add3(ordered[i2]);
+              }
+            }
+            visible = selected.length > 0 ? selected : ordered.slice(0, 13);
           }
-          if (blocked.length > 0) {
-            lines.push(`✕ blocked (${blocked.length}):`);
-            for (const t2 of blocked)
-              lines.push(`  • ${t2.content}${t2.blocker ? ` — ${t2.blocker}` : ""}`);
+          const statusMark = {
+            completed: "OK",
+            in_progress: ">>",
+            pending: "--",
+            blocked: "!!"
+          };
+          lines.push("tree:");
+          for (const entry of visible) {
+            const indent2 = "  ".repeat(entry.depth);
+            const childSuffix = entry.childStats && entry.childStats.total > 0 ? ` [${entry.childStats.completed}/${entry.childStats.total}]` : "";
+            const blocker = entry.todo.blocker ? ` blocker=${entry.todo.blocker.slice(0, 120)}` : "";
+            lines.push(`${indent2}${statusMark[entry.displayStatus]} ${entry.todo.content.slice(0, 140)}${childSuffix}${blocker}`);
           }
-          if (done.length > 0) {
-            lines.push(`✓ completed (${done.length}): ${done.map((t2) => t2.content.slice(0, 40)).join(" | ")}`);
+          if (ordered.length > visible.length) {
+            lines.push(`... +${ordered.length - visible.length} more todo node(s)`);
           }
+          lines.push("decomposition_contract=Use stable ids plus parentId for subtasks. If the active item has multiple remaining actions, rewrite it as a parent with concrete child leaf todos; work leaf-first and do not complete a parent before all children are complete with evidence.");
           lines.push(`(turn ${turn} — call todo_write ONLY to update state, never to re-read this plan)`);
           return lines.join("\n");
         } catch {
@@ -583217,6 +583517,7 @@ ${chunk.content}`, {
           this._taskState.goal ? `Active task: (see user message above — the goal block defers to the user message as the authoritative source)` : null
         ].filter(Boolean).join("\n\n");
         const filesystemBlock = this._renderFilesystemStateBlock(turn);
+        const artifactContractBlock = this._contractRegistry.format(15);
         const todoBlock = this._renderTodoStateBlock(turn);
         const failureBlock = this._renderRecentFailuresBlock(turn);
         const churnBlock = this._renderWriteChurnBlock(turn);
@@ -583259,6 +583560,13 @@ ${this._lastPprMemoryLines.slice(0, 5).join("\n")}` : null;
             createdTurn: turn,
             ttlTurns: 1
           }),
+          signalFromBlock("known_files", "turn.artifact-contracts", artifactContractBlock, {
+            id: "artifact-contracts",
+            dedupeKey: "turn.artifact-contracts",
+            priority: 86,
+            createdTurn: turn,
+            ttlTurns: 1
+          }),
           signalFromBlock("action_contract", "turn.next-action-contract", actionContractBlock, {
             id: "next-action-contract",
             dedupeKey: "turn.next-action-contract",
@@ -584588,7 +584896,6 @@ Respond with your assessment, then take action.`;
         const hardDeadlineMs = Number.isFinite(taskTimeoutMs) && taskTimeoutMs > 0 ? start2 + taskTimeoutMs : Number.POSITIVE_INFINITY;
         let timedOut = false;
         let timeoutSummary = "";
-        let _timeoutAdvisoryInjected = false;
         const remainingTaskMs = () => Number.isFinite(hardDeadlineMs) ? Math.max(0, hardDeadlineMs - Date.now()) : Number.POSITIVE_INFINITY;
         const boundedRequestTimeoutMs = () => {
           const configured = Number.isFinite(this.options.requestTimeoutMs) && this.options.requestTimeoutMs > 0 ? this.options.requestTimeoutMs : 3e5;
@@ -584618,7 +584925,8 @@ Respond with your assessment, then take action.`;
             return false;
           if (Date.now() < hardDeadlineMs)
             return false;
-          return !_timeoutAdvisoryInjected;
+          markTaskTimedOut(phase, turn);
+          return true;
         };
         const selfEvalInterval = taskTimeoutMs;
         let nextSelfEval = start2 + selfEvalInterval;
@@ -586647,12 +586955,13 @@ ${_staleSamples.join("\n")}` : ``,
                 content: `[TASK DECOMPOSITION — Multi-step task detected]
 
 MANDATORY FIRST ACTION: Call todo_write NOW with the complete plan.
-Each todo item is { content: "what to do", status: "pending" | "in_progress" | "completed" | "blocked" }.
-Mark item 1 as in_progress, the rest as pending.
+Each todo item is { id, content, status, parentId? } or a parent with children/subtasks. Use stable ids.
+Represent broad objectives as parent todos and concrete work as child leaf todos. Mark the active leaf in_progress, the rest pending.
 Only count substantive work phases. Do NOT count observing a tool result, reporting findings, or calling task_complete as todo phases.
-Example: todo_write({todos: [{content: "read source files", status: "in_progress"}, {content: "make changes", status: "pending"}, {content: "run tests", status: "pending"}]})
+Example: todo_write({todos: [{id: "impl", content: "Implement requested change", status: "in_progress", children: [{id: "inspect", content: "Read relevant files", status: "in_progress"}, {id: "edit", content: "Make scoped edits", status: "pending"}, {id: "verify", content: "Run verification", status: "pending"}]}]})
 
-After EACH phase finishes, call todo_write AGAIN with item N marked completed and item N+1 marked in_progress.
+After EACH leaf finishes, call todo_write AGAIN with that leaf completed and the next leaf in_progress.
+If new work is discovered, decompose the current leaf into children or add siblings under the same parent instead of flattening a long list.
 The user watches this checklist update live in the chat UI. Without it they cannot see your plan or track progress.
 
 Then complete these phases IN ORDER:
@@ -586971,10 +587280,6 @@ ${memoryLines.join("\n")}`
           this.proactivePrune(compacted, turn);
           this.microcompact(compacted, recentToolResults);
           this._insertContextFrame(compacted, await this._buildTurnContextFrame(turn, compacted, recentToolResults, environmentBlock));
-          const contractBlock = this._contractRegistry.format(15);
-          if (contractBlock) {
-            compacted.push({ role: "system", content: contractBlock });
-          }
           this.gcSystemMessages(compacted);
           let requestMessages = sanitizeHistoryThink(compacted);
           {
@@ -588639,7 +588944,7 @@ Respond with EXACTLY this structure before your next tool call:
                 } else if (tc.name === "shell") {
                   const cmd = String(tc.arguments?.["command"] ?? "");
                   if (/\b(npm|pnpm|yarn)\s+test\b|\bjest\b|\bvitest\b/i.test(cmd)) {
-                    const passed = /PASS|✓\s*all/i.test(result.output) && !/FAIL|✗/i.test(result.output);
+                    const passed = /\b(PASS|pass|passed|success|ok)\b|✓\s*all/i.test(result.output) && !/FAIL|✗/i.test(result.output);
                     this._worldFacts.lastTest = {
                       passed,
                       summary: result.output.slice(0, 200),
@@ -589106,7 +589411,8 @@ Respond with EXACTLY this structure before your next tool call:
                   const _shellCmd2 = String(tc.arguments?.["command"] ?? tc.arguments?.["cmd"] ?? "");
                   const _declaredVerify = this._matchedDeclaredVerifyCommand(_shellCmd2);
                   const _lastVerifier = this._lastVerifierResult;
-                  const _noTodoDirectValidation = !_declaredVerify && (this.readSessionTodos() || []).length === 0 && this._taskState.modifiedFiles.size > 0 && _lastVerifier?.outcomeClass === "verified";
+                  const _directShellValidation = result.success === true && this._shellResultLooksLikeVerification(tc.arguments, result);
+                  const _noTodoDirectValidation = !_declaredVerify && (this.readSessionTodos() || []).length === 0 && this._taskState.modifiedFiles.size > 0 && (_lastVerifier?.outcomeClass === "verified" || _directShellValidation);
                   const _legacyGenericValidation = process.env["OMNIUS_ENABLE_GENERIC_COMPLETION_COMMAND_HEURISTIC"] === "1" && /\b(build|test|run\b|start\b|serve\b|verify|check)\b/i.test(_shellCmd2);
                   if (_declaredVerify || _noTodoDirectValidation || _legacyGenericValidation) {
                     this._lastBuildSuccessTurn = turn;
@@ -589281,7 +589587,7 @@ Respond with EXACTLY this structure before your next tool call:
               }
               const cacheableMemoryNoop = tc.name === "memory_write" && result.success && result.noop;
               const cacheableProjectWriteNoop = this._isProjectEditTool(tc.name) && result.success && !this._isRealProjectMutation(tc.name, result) && (result.noop === true || result.mutated === false);
-              if (isReadLike && result.success || tc.name === "shell" || cacheableMemoryNoop || cacheableProjectWriteNoop) {
+              if (isReadLike && result.success && result.runtimeAuthored !== true || tc.name === "shell" && result.runtimeAuthored !== true || cacheableMemoryNoop || cacheableProjectWriteNoop) {
                 recentToolResults.set(toolFingerprint, {
                   result: tc.name === "shell" ? this._buildShellCacheResult(tc.arguments, result) : (
                     // Read-like results are SERVED BACK to the model when the
@@ -589400,7 +589706,7 @@ Respond with EXACTLY this structure before your next tool call:
                   }
                 }
               }
-              if (!result.success) {
+              if (!result.success && result.runtimeAuthored !== true) {
                 this._recentFailures.push({
                   tool: tc.name,
                   fingerprint: toolFingerprint,
@@ -589638,7 +589944,7 @@ ${bookkeepingGuidance}` : bookkeepingGuidance;
                 argsPreview: toolArgsPreview,
                 targetPaths: toolTargetPaths,
                 family: result.completionEvidenceFamily ?? (result.runtimeAuthored === true ? "runtime_control" : void 0),
-                role: result.completionEvidenceRole ?? (realFileMutation || shellFilesystemMutation ? "mutation" : result.runtimeAuthored === true ? "blocker" : void 0),
+                role: result.completionEvidenceRole ?? (result.alreadyApplied === true ? "mutation" : realFileMutation || shellFilesystemMutation ? "mutation" : result.runtimeAuthored === true ? "blocker" : void 0),
                 turn
               });
               if (this._toolEvents.length > 200)
@@ -589787,6 +590093,7 @@ Evidence: ${evidencePreview}`.slice(0, 500);
                   mutated: realFileMutation || shellFilesystemMutation,
                   isReadLike,
                   noop: tc.name === "todo_write" ? this._isTodoWriteNoopResult(result) : result.noop,
+                  alreadyApplied: result.alreadyApplied === true,
                   runtimeAuthored: result.runtimeAuthored === true
                 });
                 const focusSnapshotAfter = this._focusSupervisor?.snapshot();
@@ -590885,10 +591192,6 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
               }
             }
             this._insertContextFrame(compactedMsgs, await this._buildTurnContextFrame(turn, compactedMsgs, void 0, bfEnvironmentBlock));
-            const bfContractBlock = this._contractRegistry.format(15);
-            if (bfContractBlock) {
-              compactedMsgs.push({ role: "system", content: bfContractBlock });
-            }
             this.gcSystemMessages(compactedMsgs);
             const modelFacingMessages = sanitizeHistoryThink(compactedMsgs);
             const chatRequest = {
@@ -591431,7 +591734,7 @@ ${this._completionCaveat}` : this._completionCaveat;
         if (this._completionLedger) {
           this._completionLedger = finalizeCompletionLedgerTruth(this._completionLedger);
           this._saveCompletionLedgerSafe();
-          if (completed && this._completionLedger.status === "incomplete_verification") {
+          if (completed && this._completionLedger.status === "incomplete_verification" && this.options.backwardPassReview !== false && !this._completionCaveat) {
             completed = false;
             const unresolvedSummary = this._completionLedger.unresolved.slice(-3).map((item) => item.text).join("; ");
             const caveat = unresolvedSummary ? `Incomplete verification: ${unresolvedSummary}` : "Incomplete verification: unresolved evidence remains in the completion ledger.";
@@ -592093,33 +592396,49 @@ ${caveat}` : caveat;
         this._saveWorkboard();
         await this._hookManager.runSessionHook("session_end", this._sessionId);
         try {
-          const fs11 = await import("node:fs");
-          const path12 = await import("node:path");
-          const trajDir = path12.join(this.omniusStateDir(), "trajectories");
-          fs11.mkdirSync(trajDir, { recursive: true });
-          const trajectory = {
-            id: this._sessionId,
-            // CLEAN task — this file is the prerequisite for ALL future RL/RFT
-            // training. Storing the scaffolded version would teach future models
-            // to reproduce signpost text as part of their task understanding.
-            task: persistentTaskGoal.slice(0, 1e3),
-            outcome: completed ? "pass" : this.aborted ? "aborted" : runStatus === "incomplete_verification" ? "incomplete_verification" : "timeout",
-            model: this.backend.model ?? "unknown",
-            modelTier: this.options.modelTier ?? "large",
-            turns: messages2.filter((m2) => m2.role === "assistant").length,
-            toolCalls: toolCallLog.map((tc) => ({
-              name: tc.name,
-              argsFingerprint: tc.argsKey.slice(0, 100)
-            })),
-            totalToolCalls: toolCallCount,
-            totalTokens,
-            filesModified: [...this._taskState.modifiedFiles.keys()],
-            failedApproaches: this._taskState.failedApproaches,
-            completedSteps: this._taskState.completedSteps,
-            durationMs,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          };
-          fs11.appendFileSync(path12.join(trajDir, `trajectories.jsonl`), JSON.stringify(trajectory) + "\n", "utf-8");
+          const trajectoryQuality = assessTaskArtifactQuality({
+            artifactMode: this.options.artifactMode,
+            goal: persistentTaskGoal,
+            summary,
+            toolsUsed: toolCallLog.map((tc) => tc.name),
+            filesTouched: [...this._taskState.modifiedFiles.keys()],
+            turns: messages2.filter((m2) => m2.role === "assistant").length
+          });
+          if (!trajectoryQuality.eligible) {
+            this.emit({
+              type: "status",
+              content: `Trajectory log skipped: ${trajectoryQuality.reason ?? "not eligible"}`,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          } else {
+            const fs11 = await import("node:fs");
+            const path12 = await import("node:path");
+            const trajDir = path12.join(this.omniusStateDir(), "trajectories");
+            fs11.mkdirSync(trajDir, { recursive: true });
+            const trajectory = {
+              id: this._sessionId,
+              // CLEAN task — this file is the prerequisite for ALL future RL/RFT
+              // training. Storing the scaffolded version would teach future models
+              // to reproduce signpost text as part of their task understanding.
+              task: persistentTaskGoal.slice(0, 1e3),
+              outcome: completed ? "pass" : this.aborted ? "aborted" : runStatus === "incomplete_verification" ? "incomplete_verification" : "timeout",
+              model: this.backend.model ?? "unknown",
+              modelTier: this.options.modelTier ?? "large",
+              turns: messages2.filter((m2) => m2.role === "assistant").length,
+              toolCalls: toolCallLog.map((tc) => ({
+                name: tc.name,
+                argsFingerprint: tc.argsKey.slice(0, 100)
+              })),
+              totalToolCalls: toolCallCount,
+              totalTokens,
+              filesModified: [...this._taskState.modifiedFiles.keys()],
+              failedApproaches: this._taskState.failedApproaches,
+              completedSteps: this._taskState.completedSteps,
+              durationMs,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            };
+            fs11.appendFileSync(path12.join(trajDir, `trajectories.jsonl`), JSON.stringify(trajectory) + "\n", "utf-8");
+          }
         } catch {
         }
         let filesEdited;
@@ -592615,7 +592934,7 @@ ${marker}` : marker);
         if (!target)
           return;
         const targetPathKey = this.staleEditPathKey(target.path);
-        if (this._isRealProjectMutation(toolName, result)) {
+        if (this._isRealProjectMutation(toolName, result) || result.alreadyApplied === true) {
           for (const [key2, entry] of this._staleEditFamilies) {
             if (entry.pathKey === targetPathKey)
               this._staleEditFamilies.delete(key2);
@@ -629489,6 +629808,8 @@ var init_overlay_lock = __esm({
 // packages/cli/src/tui/tui-tasks-renderer.ts
 var tui_tasks_renderer_exports = {};
 __export(tui_tasks_renderer_exports, {
+  __testOrderTodosForDisplay: () => __testOrderTodosForDisplay,
+  __testSelectPanelTodoRows: () => __testSelectPanelTodoRows,
   getTuiTasksScope: () => getTuiTasksScope,
   onTuiTasksHeightChange: () => onTuiTasksHeightChange,
   refreshTuiTasks: () => refreshTuiTasks,
@@ -629646,7 +629967,7 @@ function computeTargetHeight() {
   if (!_lastTodos || _lastTodos.length === 0) return 0;
   const allDone = _lastTodos.every((t2) => t2 && t2.status === "completed");
   if (allDone) return 0;
-  const itemRows = Math.min(_lastTodos.length, MAX_VISIBLE_ROWS - 1);
+  const itemRows = selectPanelTodoRows(_lastTodos, MAX_VISIBLE_ROWS - 1).rowCount;
   return 1 + itemRows;
 }
 function applyHeightChange(nextHeight) {
@@ -629724,9 +630045,9 @@ function buildTodoProgressBar(todos, maxWidth) {
   if (truncated && maxWidth > 0) out += `${DIM_LABEL}…${RESET3}`;
   return out;
 }
-function orderTodosForDisplay(todos) {
+function buildTodoTreeIndex(todos) {
   const byParent = /* @__PURE__ */ new Map();
-  const byId = new Set(todos.map((t2) => t2.id));
+  const byId = new Map(todos.map((t2) => [t2.id, t2]));
   const roots = [];
   for (const todo of todos) {
     if (todo.parentId && byId.has(todo.parentId)) {
@@ -629737,20 +630058,146 @@ function orderTodosForDisplay(todos) {
       roots.push(todo);
     }
   }
+  return { byId, byParent, roots };
+}
+function childLeafStats(todo, index) {
+  const children2 = index.byParent.get(todo.id) ?? [];
+  if (children2.length === 0) return void 0;
+  let completed = 0;
+  let total = 0;
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (seen.has(node.id)) return;
+    seen.add(node.id);
+    const nested = index.byParent.get(node.id) ?? [];
+    if (nested.length === 0) {
+      total++;
+      if (node.status === "completed") completed++;
+      return;
+    }
+    for (const child of nested) visit(child);
+  };
+  for (const child of children2) visit(child);
+  return { completed, total };
+}
+function displayStatusFor(todo, index, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(todo.id)) return todo.status;
+  seen.add(todo.id);
+  const children2 = index.byParent.get(todo.id) ?? [];
+  if (children2.length === 0) return todo.status;
+  const childStatuses = children2.map((child) => displayStatusFor(child, index, new Set(seen)));
+  if (childStatuses.some((status) => status === "blocked")) return "blocked";
+  if (childStatuses.some((status) => status === "in_progress")) return "in_progress";
+  if (childStatuses.every((status) => status === "completed")) return "completed";
+  if (todo.status === "completed") return "in_progress";
+  return todo.status;
+}
+function toDisplayTodo(todo, depth, index) {
+  return {
+    ...todo,
+    depth: Math.min(depth, 4),
+    displayStatus: displayStatusFor(todo, index),
+    childSummary: childLeafStats(todo, index)
+  };
+}
+function orderTodosForDisplay(todos) {
+  const index = buildTodoTreeIndex(todos);
   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) ?? []) {
+    out.push(toDisplayTodo(todo, depth, index));
+    for (const child of index.byParent.get(todo.id) ?? []) {
       visit(child, depth + 1);
     }
   };
-  for (const root of roots) visit(root, 0);
+  for (const root of index.roots) visit(root, 0);
   for (const todo of todos) visit(todo, 0);
   return out;
 }
+function leafTodosForProgress(todos) {
+  const index = buildTodoTreeIndex(todos);
+  const leaves = todos.filter((todo) => (index.byParent.get(todo.id) ?? []).length === 0);
+  return leaves.length > 0 ? leaves : todos;
+}
+function activeDisplayIndex(displayTodos) {
+  const inProgressLeaf = displayTodos.findIndex(
+    (todo, index, all2) => todo.status === "in_progress" && !all2.some((candidate) => candidate.parentId === todo.id)
+  );
+  if (inProgressLeaf >= 0) return inProgressLeaf;
+  const inProgress = displayTodos.findIndex((todo) => todo.displayStatus === "in_progress");
+  if (inProgress >= 0) return inProgress;
+  const blocked = displayTodos.findIndex((todo) => todo.displayStatus === "blocked");
+  if (blocked >= 0) return blocked;
+  return displayTodos.findIndex((todo) => todo.displayStatus === "pending");
+}
+function selectFocusedTodoItems(todos, maxItems) {
+  const displayTodos = orderTodosForDisplay(todos);
+  if (maxItems <= 0) return [];
+  if (displayTodos.length <= maxItems) return displayTodos;
+  const activeIndex = activeDisplayIndex(displayTodos);
+  if (activeIndex < 0 || activeIndex < maxItems) return displayTodos.slice(0, maxItems);
+  const rawIndex = buildTodoTreeIndex(todos);
+  const displayById = new Map(displayTodos.map((todo) => [todo.id, todo]));
+  const selected = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add3 = (todo) => {
+    if (!todo || selected.length >= maxItems || seen.has(todo.id)) return;
+    selected.push(todo);
+    seen.add(todo.id);
+  };
+  const active = displayTodos[activeIndex];
+  const ancestors = [];
+  let cursor = active;
+  while (cursor?.parentId && rawIndex.byId.has(cursor.parentId)) {
+    const parent = rawIndex.byId.get(cursor.parentId);
+    if (!parent) break;
+    const displayParent = displayById.get(parent.id);
+    if (displayParent) ancestors.unshift(displayParent);
+    cursor = parent;
+  }
+  for (const ancestor of ancestors) add3(ancestor);
+  const siblings = active.parentId ? rawIndex.byParent.get(active.parentId) ?? [] : rawIndex.roots;
+  const activeSiblingIndex = siblings.findIndex((todo) => todo.id === active.id);
+  if (activeSiblingIndex > 0) add3(displayById.get(siblings[activeSiblingIndex - 1].id));
+  add3(active);
+  for (let i2 = activeSiblingIndex + 1; i2 < siblings.length && selected.length < maxItems; i2++) {
+    add3(displayById.get(siblings[i2].id));
+  }
+  const activeChildren = rawIndex.byParent.get(active.id) ?? [];
+  for (const child of activeChildren) add3(displayById.get(child.id));
+  for (let i2 = activeIndex + 1; i2 < displayTodos.length && selected.length < maxItems; i2++) {
+    add3(displayTodos[i2]);
+  }
+  for (let i2 = activeIndex - 1; i2 >= 0 && selected.length < maxItems; i2--) {
+    add3(displayTodos[i2]);
+  }
+  return selected;
+}
+function selectPanelTodoRows(todos, maxRows) {
+  const displayTodos = orderTodosForDisplay(todos);
+  if (maxRows <= 0 || displayTodos.length === 0) {
+    return { items: [], omitted: displayTodos.length, rowCount: 0 };
+  }
+  if (displayTodos.length <= maxRows) {
+    return { items: displayTodos, omitted: 0, rowCount: displayTodos.length };
+  }
+  const itemBudget = Math.max(1, maxRows - 1);
+  const items = selectFocusedTodoItems(todos, itemBudget);
+  const omitted = Math.max(0, displayTodos.length - items.length);
+  return {
+    items,
+    omitted,
+    rowCount: Math.min(maxRows, items.length + (omitted > 0 ? 1 : 0))
+  };
+}
+function __testOrderTodosForDisplay(todos) {
+  return orderTodosForDisplay(todos);
+}
+function __testSelectPanelTodoRows(todos, maxRows) {
+  return selectPanelTodoRows(todos, maxRows);
+}
 function render() {
   if (!_enabled) return;
   if (!panelEffectivelyVisible()) {
@@ -629766,29 +630213,30 @@ function render() {
   }
   const L = layout();
   const cols = Math.max(20, termCols());
-  const completed = _lastTodos.filter((t2) => t2.status === "completed").length;
-  const total = _lastTodos.length;
+  const progressTodos = leafTodosForProgress(_lastTodos);
+  const completed = progressTodos.filter((t2) => t2.status === "completed").length;
+  const total = progressTodos.length;
   const headerColor = ACCENT;
   const lines = [];
   const headerPrefix = `tasks ${headerColor}${completed}/${total}${RESET3} `;
   const headerPrefixWidth = visualLen(headerPrefix);
   const maxBarWidth = Math.max(0, cols - 2 - headerPrefixWidth);
-  const progressBar = buildTodoProgressBar(_lastTodos, maxBarWidth);
+  const progressBar = buildTodoProgressBar(progressTodos, maxBarWidth);
   const headerText = `${headerPrefix}${progressBar}`;
   lines.push(headerText);
-  const displayTodos = orderTodosForDisplay(_lastTodos);
-  const visible = displayTodos.slice(0, MAX_VISIBLE_ROWS - 1);
+  const selection = selectPanelTodoRows(_lastTodos, MAX_VISIBLE_ROWS - 1);
+  const visible = selection.items;
   for (const t2 of visible) {
-    const { mark, color } = statusToAnsi(t2.status);
+    const { mark, color } = statusToAnsi(t2.displayStatus);
     const contentWidth = Math.max(4, cols - 8);
-    const indent2 = t2.depth > 0 ? `${"  ".repeat(t2.depth - 1)}- ` : "";
-    const contentText = indent2 + t2.content + (t2.blocker ? ` (blocked: ${t2.blocker})` : "");
+    const indent2 = t2.depth > 0 ? `${"  ".repeat(t2.depth)}- ` : "";
+    const childSummary = t2.childSummary && t2.childSummary.total > 0 ? ` [${t2.childSummary.completed}/${t2.childSummary.total}]` : "";
+    const contentText = indent2 + t2.content + childSummary + (t2.blocker ? ` (blocked: ${t2.blocker})` : "");
     const truncated = truncate2(contentText, contentWidth);
     lines.push(`${color}${mark}${RESET3} ${color}${truncated}${RESET3}`);
   }
-  if (displayTodos.length > visible.length) {
-    const more = displayTodos.length - visible.length;
-    lines[lines.length - 1] = `${DIM_LABEL}… +${more} more${RESET3}`;
+  if (selection.omitted > 0) {
+    lines.push(`${DIM_LABEL}… +${selection.omitted} more${RESET3}`);
   }
   let out = HIDE + SAVE;
   const newTop = L.tasksTop;

package/npm-shrinkwrap.json

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

package/package.json

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