omnius 1.0.365 → 1.0.367

package/dist/index.js

@@ -558574,6 +558574,73 @@ function buildCriticPacketFromLedger(ledger) {
   }
   return lines.join("\n");
 }
+function appendUnresolved(items, text2, source) {
+  const clean5 = cleanText(text2, 500);
+  if (!clean5)
+    return items;
+  if (items.some((item) => item.text === clean5 && item.source === source)) {
+    return items;
+  }
+  return [
+    ...items,
+    {
+      id: nextId2("unresolved", items.length),
+      text: clean5,
+      source,
+      recordedAtIso: nowIso2()
+    }
+  ];
+}
+function isMutationEvidence(entry) {
+  if (entry.kind === "file_change")
+    return true;
+  return entry.success === true && /^(file_write|file_edit|file_patch|batch_edit)$/.test(entry.toolName ?? "");
+}
+function isSuccessfulVerificationEvidence(entry) {
+  if (entry.success !== true)
+    return false;
+  const text2 = `${entry.toolName ?? ""} ${entry.summary}`.toLowerCase();
+  return /\b(test|tests|tested|verify|verified|verification|build|built|compile|compiled|tsc|vitest|jest|pytest|go test|cargo test|pass|passed|success)\b/.test(text2);
+}
+function isFailedVerificationEvidence(entry) {
+  if (entry.success !== false)
+    return false;
+  const text2 = `${entry.toolName ?? ""} ${entry.summary}`.toLowerCase();
+  return /\b(test|tests|verify|verification|build|compile|tsc|vitest|jest|pytest|go test|cargo test)\b/.test(text2);
+}
+function isStaleEditEvidence(entry) {
+  if (entry.success !== false)
+    return false;
+  const text2 = entry.summary.toLowerCase();
+  return /stale edit loop blocked|old[_ -]?string|old text|expected[_ -]?hash|context mismatch|no occurrences|could not find/.test(text2);
+}
+function finalizeCompletionLedgerTruth(ledger) {
+  let unresolved = [...ledger.unresolved];
+  let lastMutation = -1;
+  let lastVerification = -1;
+  ledger.evidence.forEach((entry, index) => {
+    if (isMutationEvidence(entry))
+      lastMutation = index;
+    if (isSuccessfulVerificationEvidence(entry))
+      lastVerification = index;
+    if (isFailedVerificationEvidence(entry)) {
+      unresolved = appendUnresolved(unresolved, `Verification failed or did not prove success: ${entry.summary}`, entry.id);
+    }
+    if (isStaleEditEvidence(entry)) {
+      unresolved = appendUnresolved(unresolved, `Stale edit failure remains unresolved: ${entry.summary}`, entry.id);
+    }
+  });
+  if (lastVerification >= 0 && lastMutation > lastVerification) {
+    unresolved = appendUnresolved(unresolved, "File changes occurred after the last successful verification; final verification is stale.", "verification_freshness");
+  }
+  const status = ledger.status === "blocked" || ledger.status === "request_changes" ? ledger.status : unresolved.length > 0 ? "incomplete_verification" : ledger.status;
+  return {
+    ...ledger,
+    unresolved,
+    status,
+    updatedAtIso: nowIso2()
+  };
+}
 function saveCompletionLedger(filePath, ledger) {
   mkdirSync49(dirname28(filePath), { recursive: true });
   writeFileSync40(filePath, `${JSON.stringify(ledger, null, 2)}
@@ -563850,11 +563917,59 @@ ${text2}` : SUMMARY_PREFIX;
   }
 });
 
+// packages/orchestrator/dist/artifactQuality.js
+function isInternalArtifactPrompt(text2) {
+  const raw = String(text2 ?? "");
+  if (!raw.trim())
+    return false;
+  return INTERNAL_PROMPT_PATTERNS.some((pattern) => pattern.test(raw));
+}
+function assessTaskArtifactQuality(input) {
+  if (input.artifactMode === "internal") {
+    return { eligible: false, reason: "internal artifact mode" };
+  }
+  const goal = String(input.goal ?? "");
+  const summary = String(input.summary ?? "");
+  if (isInternalArtifactPrompt(goal) || isInternalArtifactPrompt(summary)) {
+    return { eligible: false, reason: "internal helper prompt" };
+  }
+  const toolsUsed = input.toolsUsed ?? [];
+  const filesTouched = input.filesTouched ?? [];
+  const turns = input.turns ?? 0;
+  if (turns <= 0 && toolsUsed.length === 0) {
+    return { eligible: false, reason: "zero-turn no-tool artifact" };
+  }
+  if (!summary.trim() && toolsUsed.length === 0 && filesTouched.length === 0) {
+    return { eligible: false, reason: "empty no-evidence artifact" };
+  }
+  return { eligible: true };
+}
+var INTERNAL_PROMPT_PATTERNS;
+var init_artifactQuality = __esm({
+  "packages/orchestrator/dist/artifactQuality.js"() {
+    "use strict";
+    INTERNAL_PROMPT_PATTERNS = [
+      /\byou are an emotion center\b/i,
+      /\bemotion center\b.*\brespond with one emoji\b/i,
+      /\byou are the agent's private reflection process\b/i,
+      /\bprefrontal cortex gating evaluator\b/i,
+      /\bdentate gyrus pattern separation evaluator\b/i,
+      /\bsnr evaluator\b/i,
+      /\byou are the prefrontal cortex\b/i,
+      /\byou are the hippocampus\b/i,
+      /\byou are the amygdala\b/i,
+      /\byou are the inner critic\b/i,
+      /\byou are the basal ganglia\b/i
+    ];
+  }
+});
+
 // packages/orchestrator/dist/reflectionBuffer.js
 var MAX_REFLECTIONS, MAX_TOTAL, TaskReflectionBuffer;
 var init_reflectionBuffer = __esm({
   "packages/orchestrator/dist/reflectionBuffer.js"() {
     "use strict";
+    init_artifactQuality();
     MAX_REFLECTIONS = 5;
     MAX_TOTAL = 50;
     TaskReflectionBuffer = class {
@@ -563905,6 +564020,18 @@ var init_reflectionBuffer = __esm({
        */
       addReflection(params) {
         const { taskGoal, sessionId, turnsSpent, failedApproaches, toolCallLog, lastError, failedPaths } = params;
+        const goalCoreForQuality = this.extractUserGoalCore(taskGoal) || taskGoal;
+        const quality = assessTaskArtifactQuality({
+          goal: goalCoreForQuality,
+          summary: lastError,
+          toolsUsed: toolCallLog.map((entry) => entry.tool),
+          filesTouched: failedPaths || [],
+          turns: turnsSpent
+        });
+        if (!quality.eligible) {
+          const reason = quality.reason || "low-quality artifact";
+          throw new Error("Reflection rejected: " + reason);
+        }
         const taskFingerprint = this.computeFingerprint(taskGoal);
         const errorType = this.classifyError(toolCallLog, failedApproaches, lastError, turnsSpent);
         const failedTools = [...new Set(toolCallLog.filter((t2) => !t2.success).map((t2) => t2.tool))].slice(0, 5);
@@ -563953,23 +564080,26 @@ var init_reflectionBuffer = __esm({
         const fingerprint = this.computeFingerprint(taskGoal);
         const goalLower = goalCore.toLowerCase();
         const goalWords = new Set(goalLower.split(/\s+/).filter((w) => w.length > 3));
-        const scored = this.state.reflections.map((r2) => {
-          let score = 0;
+        const scored = this.state.reflections.filter((r2) => !isInternalArtifactPrompt(r2.taskGoal) && !isInternalArtifactPrompt(r2.whatFailed) && !isInternalArtifactPrompt(r2.whatToDoDifferently)).map((r2) => {
+          let baseScore = 0;
           if (r2.taskFingerprint === fingerprint)
-            score += 5;
+            baseScore += 5;
           const rWords = new Set(r2.taskGoal.toLowerCase().split(/\s+/).filter((w) => w.length > 3));
           let overlap = 0;
           for (const w of goalWords)
             if (rWords.has(w))
               overlap++;
-          score += overlap;
+          baseScore += overlap;
+          if (baseScore <= 0)
+            return { reflection: r2, score: 0, relevant: false };
+          let score = baseScore;
           const hoursAgo = (Date.now() - r2.timestamp) / 36e5;
           score += Math.max(0, 2 - hoursAgo * 0.1);
           score += r2.confidence * 2;
-          return { reflection: r2, score };
+          return { reflection: r2, score, relevant: true };
         });
         scored.sort((a2, b) => b.score - a2.score);
-        const results = scored.slice(0, maxResults).filter((s2) => s2.score > 1).map((s2) => s2.reflection);
+        const results = scored.filter((s2) => s2.relevant && s2.score > 1).slice(0, maxResults).map((s2) => s2.reflection);
         this.state.totalConsumed += results.length;
         this.persist();
         return results;
@@ -564182,23 +564312,50 @@ function buildTaskHandoff(params) {
     const argHint = tc.argsKey ? ` ${tc.argsKey.slice(0, 80)}` : "";
     return `${tc.name}${argHint}`;
   });
+  const artifactMode = params.artifactMode ?? "user-task";
+  const filesTouched = [...new Set(params.filesModified)].slice(0, MAX_FILES);
+  const toolsUsed = [...new Set(params.toolsUsed)].slice(0, MAX_TOOLS);
+  const quality = assessTaskArtifactQuality({
+    artifactMode,
+    goal: params.goal,
+    summary: params.summary,
+    filesTouched,
+    toolsUsed,
+    turns: params.turns
+  });
   return {
     v: 2,
     sessionId: params.sessionId,
     priorGoal: params.goal.slice(0, 500),
     priorOutcome: params.outcome,
     priorSummary: (params.summary || "").slice(0, MAX_SUMMARY_CHARS),
-    filesTouched: [...new Set(params.filesModified)].slice(0, MAX_FILES),
-    toolsUsed: [...new Set(params.toolsUsed)].slice(0, MAX_TOOLS),
+    filesTouched,
+    toolsUsed,
     lastActions,
     turns: params.turns,
     endedAt: Date.now(),
+    artifactMode,
+    quality,
     ...params.transcriptPath ? { transcriptPath: params.transcriptPath } : {}
   };
 }
+function shouldPersistTaskHandoff(handoff) {
+  if (handoff.quality && handoff.quality.eligible === false)
+    return false;
+  return assessTaskArtifactQuality({
+    artifactMode: handoff.artifactMode,
+    goal: handoff.priorGoal,
+    summary: handoff.priorSummary,
+    toolsUsed: handoff.toolsUsed,
+    filesTouched: handoff.filesTouched,
+    turns: handoff.turns
+  }).eligible;
+}
 function writeTaskHandoff(omniusDir, handoff) {
   if (!handoffEnabled())
     return;
+  if (!shouldPersistTaskHandoff(handoff))
+    return;
   try {
     const file = handoffPath(omniusDir);
     fs4.mkdirSync(path5.dirname(file), { recursive: true });
@@ -564219,6 +564376,8 @@ function readTaskHandoff(omniusDir, opts) {
       return null;
     }
     const handoff = parsed;
+    if (!shouldPersistTaskHandoff(handoff))
+      return null;
     const sameSession = handoff.sessionId === opts.currentSessionId;
     if (!sameSession) {
       const age = Date.now() - handoff.endedAt;
@@ -564287,6 +564446,7 @@ var DEFAULT_TTL_MS2, MAX_SUMMARY_CHARS, MAX_FILES, MAX_TOOLS, MAX_LAST_ACTIONS;
 var init_taskHandoff = __esm({
   "packages/orchestrator/dist/taskHandoff.js"() {
     "use strict";
+    init_artifactQuality();
     DEFAULT_TTL_MS2 = 24 * 60 * 60 * 1e3;
     MAX_SUMMARY_CHARS = 8e3;
     MAX_FILES = 30;
@@ -564317,6 +564477,8 @@ function logPath2(omniusDir, sessionLogId) {
 function appendBoundaryToLog(omniusDir, handoff) {
   if (!logEnabled())
     return;
+  if (!shouldPersistTaskHandoff(handoff))
+    return;
   const id = tuiSessionLogId();
   if (!id)
     return;
@@ -564345,7 +564507,9 @@ function loadBoundaryRecords(omniusDir) {
       try {
         const parsed = JSON.parse(lines[i2]);
         if (parsed && parsed.v === 1 && parsed.handoff && typeof parsed.recordedAt === "number") {
-          records.push(parsed);
+          const record = parsed;
+          if (shouldPersistTaskHandoff(record.handoff))
+            records.push(record);
         }
       } catch {
       }
@@ -565896,7 +566060,7 @@ function heuristicSummarize(inputs) {
     }
   }
   return {
-    functionalSummary: `Completed: ${inputs.todoContent.slice(0, 120)} (heuristic summary — use memex_retrieve(expand=true) for full context)`,
+    functionalSummary: `Work recorded: ${inputs.todoContent.slice(0, 120)} (heuristic summary — use memex_retrieve(expand=true) for full context)`,
     keyFiles: [...files].slice(0, 30),
     criticalSymbols: {
       defined: [...new Set(symbolsDefined)].slice(0, 50),
@@ -565914,6 +566078,31 @@ function heuristicSummarize(inputs) {
     ].join("\n")
   };
 }
+function hasExplicitVerification(text2) {
+  const raw = String(text2 || "").trim();
+  if (!raw)
+    return false;
+  if (/^\(?no verification detected\)?$/i.test(raw))
+    return false;
+  if (/\b(no verification|not verified|not run|missing verification|none detected)\b/i.test(raw))
+    return false;
+  return /\b(pass|passed|success|succeeded|verified|tests?|build|compile|tsc|vitest|jest|pytest|go test|cargo test)\b/i.test(raw);
+}
+function deriveChunkStatus(verdict, toolCalls) {
+  if ((verdict.unresolved || []).length > 0)
+    return "blocked";
+  if (toolCalls.some((tc) => !tc.success))
+    return "partial";
+  if (!hasExplicitVerification(verdict.verification || ""))
+    return "unverified";
+  return "completed";
+}
+function statusAwareFunctionalSummary(summary, status, fallback) {
+  const raw = (summary || fallback).trim();
+  if (status === "completed")
+    return raw;
+  return raw.replace(/^completed\s*:?/i, "Work recorded:");
+}
 async function runTodoChunker(opts) {
   const startMs = Date.now();
   const memexId = `todo-ctx-${sanitizeId(opts.inputs.todoId).slice(0, 20)}`;
@@ -565932,11 +566121,12 @@ async function runTodoChunker(opts) {
     usedFallback = true;
   }
   const estimatedTokens = Math.round(opts.inputs.transcript.length / 4);
+  const status = deriveChunkStatus(verdict, opts.inputs.toolCalls);
   const chunk = {
     todoId: opts.inputs.todoId,
     todoContent: opts.inputs.todoContent,
-    status: "completed",
-    functionalSummary: verdict.functionalSummary || `Completed: ${opts.inputs.todoContent.slice(0, 120)}`,
+    status,
+    functionalSummary: statusAwareFunctionalSummary(verdict.functionalSummary, status, `Work recorded: ${opts.inputs.todoContent.slice(0, 120)}`),
     detailSummary: verdict.detailSummary || "",
     keyFiles: verdict.keyFiles || [],
     criticalSymbols: verdict.criticalSymbols || { defined: [], modified: [] },
@@ -567404,6 +567594,9 @@ function adversarySystemPrompt() {
     "  • started ≠ running — a PID or a log line is not a liveness probe.",
     "  • exit code 0 / 'build complete' ≠ success — the specific artifact must exist.",
     "  • an edit ≠ a fix — the failing command must be re-run and pass.",
+    "  • file_write/file_read tool outcomes ARE first-class evidence for narrow file existence/content claims.",
+    "    Do not demand shell/cat proof when a successful file_write is followed by file_read evidence for the same path.",
+    "  • If a shell integrity check is truly needed, demand a newline-safe command such as: printf '\n---sha256---\n'; sha256sum <path>. Do not use brittle cat <path> && sha256sum <path> as the default.",
     "  • simulation / mock / placeholder ≠ real.",
     "  • partial progress ≠ done.",
     "Mixed results are the norm: do NOT let one success excuse an unproven completion claim.",
@@ -567424,7 +567617,11 @@ function adversarySystemPrompt() {
   ].join("\n");
 }
 function buildObservationPrompt(obs, recentLedger) {
-  const outcomes = obs.recentToolOutcomes.slice(-8).map((o2) => `  - ${o2.tool}: ${o2.succeeded ? "OK" : "FAIL"} — ${o2.preview.slice(0, 120)}`).join("\n");
+  const outcomes = obs.recentToolOutcomes.slice(-8).map((o2) => {
+    const target = o2.path ? ` path=${o2.path}` : "";
+    const evidence = o2.evidence ? ` | evidence: ${o2.evidence.slice(0, 220)}` : "";
+    return `  - ${o2.tool}: ${o2.succeeded ? "OK" : "FAIL"}${target} — ${o2.preview.slice(0, 160)}${evidence}`;
+  }).join("\n");
   const priorDoubts = recentLedger.slice(-3).filter((e2) => e2.verdict !== "ok").map((e2) => `  - turn ${e2.turn}: ${e2.verdict} — demanded: ${e2.demand}`).join("\n");
   if (obs.loopSignal) {
     const ls2 = obs.loopSignal;
@@ -567479,6 +567676,47 @@ ${priorDoubts}` : "",
     "Audit this. Return ONLY the JSON object."
   ].join("\n");
 }
+function deterministicFileProofPaths(obs) {
+  const writes = /* @__PURE__ */ new Set();
+  const reads = /* @__PURE__ */ new Set();
+  for (const outcome of obs.recentToolOutcomes) {
+    if (!outcome.succeeded || !outcome.path)
+      continue;
+    if (/^(file_write|file_edit|file_patch|batch_edit)$/.test(outcome.tool)) {
+      writes.add(outcome.path);
+    }
+    if (outcome.tool === "file_read")
+      reads.add(outcome.path);
+  }
+  const proven = /* @__PURE__ */ new Set();
+  for (const path12 of writes)
+    if (reads.has(path12))
+      proven.add(path12);
+  return proven;
+}
+function hasRecentNonFileFailure(obs) {
+  return obs.recentToolOutcomes.some((outcome) => !outcome.succeeded && !/^(file_write|file_edit|file_patch|batch_edit|file_read|task_complete)$/.test(outcome.tool));
+}
+function isNarrowFileCompletionClaim(text2) {
+  return /\b(file|path|created|wrote|written|exists|content|reads?back|verified by read|single line)\b/i.test(text2);
+}
+function critiqueContradictedByFileProof(obs, critique2) {
+  if (!obs.claimsCompletion)
+    return false;
+  if (hasRecentNonFileFailure(obs))
+    return false;
+  if (!isNarrowFileCompletionClaim(obs.assistantText))
+    return false;
+  if (deterministicFileProofPaths(obs).size === 0)
+    return false;
+  if (critique2.class === "ok")
+    return false;
+  const text2 = critique2.shortText + "\n" + critique2.details + "\n" + critique2.demand;
+  return /no tool output|tool output|file creation|file exists|file content|cat\b|sha256|hash|unverified|unproven|readback|read back/i.test(text2);
+}
+function hasDeterministicFileCompletionProof(obs) {
+  return obs.claimsCompletion && !hasRecentNonFileFailure(obs) && isNarrowFileCompletionClaim(obs.assistantText) && deterministicFileProofPaths(obs).size > 0;
+}
 function parseAdversaryCritique(raw) {
   if (!raw)
     return null;
@@ -567549,7 +567787,7 @@ var init_adversaryStream = __esm({
        */
       shouldAudit(obs) {
         if (obs.claimsCompletion)
-          return true;
+          return !hasDeterministicFileCompletionProof(obs);
         if (obs.loopSignal)
           return true;
         if (obs.failingApproach)
@@ -567597,6 +567835,15 @@ var init_adversaryStream = __esm({
           }
           if (!critique2)
             return null;
+          if (critiqueContradictedByFileProof(obs, critique2)) {
+            critique2 = {
+              class: "ok",
+              shortText: "file proof present",
+              confidence: 0.05,
+              details: "The recent file_write/file_read outcomes provide deterministic evidence for this narrow file existence/content claim.",
+              demand: ""
+            };
+          }
           this.ledger.push({
             ts: Date.now(),
             turn: obs.turn,
@@ -570272,6 +570519,7 @@ var init_agenticRunner = __esm({
        */
       _completionCaveat = null;
       _completionLedger = null;
+      _staleEditFamilies = /* @__PURE__ */ new Map();
       // ── WO-AM-01/04/10: Associative memory stores ──
       // Episode store: every tool call → persistent episode with importance + decay
       // Temporal KG: entities + relations with temporal validity (valid_from/valid_until)
@@ -570620,6 +570868,7 @@ ${parts.join("\n")}
           memoryPrefix: options2?.memoryPrefix ?? "",
           memoryPrefixHash: options2?.memoryPrefixHash ?? "",
           stateDir: options2?.stateDir ?? "",
+          artifactMode: options2?.artifactMode ?? "user-task",
           disablePersistentMemory: options2?.disablePersistentMemory ?? false,
           disableCodebaseMap: options2?.disableCodebaseMap ?? false,
           sessionId: options2?.sessionId ?? "",
@@ -570671,7 +570920,12 @@ ${parts.join("\n")}
         const configured = (this.options.stateDir || "").trim();
         return configured ? _pathResolve(configured) : _pathJoin(process.cwd(), ".omnius");
       }
+      writesUserTaskArtifacts() {
+        return this.options.artifactMode === "user-task" && !this.options.subAgent;
+      }
       _persistCompletionContract(contract) {
+        if (!this.writesUserTaskArtifacts())
+          return;
         try {
           const dir = _pathJoin(this.omniusStateDir(), "completion-contracts");
           _fsMkdirSync(dir, { recursive: true });
@@ -570684,6 +570938,8 @@ ${parts.join("\n")}
         }
       }
       _saveCompletionLedgerSafe() {
+        if (!this.writesUserTaskArtifacts())
+          return;
         if (!this._completionLedger)
           return;
         try {
@@ -575456,6 +575712,7 @@ Respond with your assessment, then take action.`;
         this._completionIncompleteVerification = null;
         this._completionCaveat = null;
         this._completionLedger = null;
+        this._staleEditFamilies.clear();
         this._lastWorldStateTurn = -1;
         this._fileWritesSinceLastWorldState = 0;
         this._resetVisualEvidenceState();
@@ -575598,11 +575855,16 @@ Respond with your assessment, then take action.`;
           verbose: false
         });
         this._hookManager.runSessionHook("session_start", this._sessionId);
-        this._initializeCompletionContract(task, context2, actualUserGoal);
-        this._completionLedger = createCompletionLedger({
-          runId: this._sessionId,
-          goal: userGoal
-        });
+        if (this.writesUserTaskArtifacts()) {
+          this._initializeCompletionContract(task, context2, actualUserGoal);
+          this._completionLedger = createCompletionLedger({
+            runId: this._sessionId,
+            goal: userGoal
+          });
+        } else {
+          this._completionContract = null;
+          this._completionLedger = null;
+        }
         this._sessionStartMs = Date.now();
         if (process.env["OMNIUS_DISABLE_PREFLIGHT"] !== "1") {
           try {
@@ -575878,6 +576140,8 @@ TASK: ${scrubbedTask}` : scrubbedTask;
         try {
           if (this.options.subAgent)
             throw "skip-handoff-subagent";
+          if (!this.writesUserTaskArtifacts())
+            throw "skip-handoff-artifact-mode";
           if (this.options.skipCrossTaskHandoff)
             throw "skip-handoff-caller-optout";
           if (/<task-handoff>|<session-recap>/.test(task))
@@ -575914,6 +576178,8 @@ TASK: ${scrubbedTask}` : scrubbedTask;
         } catch {
         }
         try {
+          if (!this.writesUserTaskArtifacts())
+            throw "skip-reflection-artifact-mode";
           if (!this._reflectionBuffer) {
             const omniusDir = this.options.stateDir ? _pathJoin(this.omniusStateDir(), "memory") : this._workingDirectory ? _pathJoin(this._workingDirectory, ".omnius", "memory") : null;
             if (omniusDir) {
@@ -576007,6 +576273,9 @@ TASK: ${scrubbedTask}` : scrubbedTask;
             backend: this._auxInferenceBackend(),
             persistPath,
             onCritique: (critique2, sourceTurn) => {
+              if (completed || this._completionIncompleteVerification || this.aborted) {
+                return;
+              }
               if (this._adversaryMode === "skillcoach" || this._adversaryMode === "both") {
                 this.pendingUserMessages.push(AdversaryStream.formatInjection(critique2));
               }
@@ -578512,6 +578781,43 @@ Use the saved fact to continue the promised synthesis or next concrete step, or
                   systemGuidance: repeatNoopMsg
                 };
               }
+              const staleEditBlock = this.staleEditPreflightBlock(tc.name, tc.arguments ?? {});
+              if (staleEditBlock) {
+                this.emit({
+                  type: "tool_call",
+                  toolName: tc.name,
+                  toolArgs: tc.arguments,
+                  turn,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                this.emit({
+                  type: "tool_result",
+                  toolName: tc.name,
+                  success: false,
+                  content: staleEditBlock.slice(0, 120),
+                  turn,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                this._tagSyntheticFailure({
+                  mode: "step_repetition",
+                  rationale: "stale edit family retried without fresh read or mutation"
+                });
+                if (this._completionLedger) {
+                  this._completionLedger = recordToolEvidence(this._completionLedger, {
+                    name: tc.name,
+                    success: false,
+                    outputPreview: staleEditBlock.slice(0, 500),
+                    argsKey: tc.arguments ? JSON.stringify(tc.arguments).slice(0, 300) : ""
+                  });
+                  this._saveCompletionLedgerSafe();
+                }
+                return {
+                  tc,
+                  output: staleEditBlock,
+                  success: false,
+                  systemGuidance: staleEditBlock
+                };
+              }
               const baseIsReadLike = ![
                 "file_write",
                 "file_edit",
@@ -578626,7 +578932,9 @@ Use the saved fact to continue the promised synthesis or next concrete step, or
                     recentToolOutcomes: this._adversaryToolOutcomes.slice(-8).map((o2) => ({
                       tool: o2.tool,
                       succeeded: o2.succeeded,
-                      preview: o2.preview
+                      preview: o2.preview,
+                      path: o2.path,
+                      evidence: o2.evidence
                     })),
                     claimsCompletion: false,
                     loopSignal: {
@@ -579992,6 +580300,7 @@ Evidence: ${evidencePreview}`.slice(0, 500);
               }
               const filePath = typeof tc.arguments?.path === "string" ? tc.arguments.path : "";
               recordToolExecution(this._appState, tc.name, performance.now() - toolStart, result.success, filePath || void 0);
+              this.noteStaleEditGuardOutcome(tc.name, tc.arguments ?? {}, result, turn);
               if (tc.name === "todo_write") {
                 this._lastTodoWriteTurn = turn;
               }
@@ -580546,7 +580855,10 @@ ${sr.result.output}`;
               loopInterventionCount++;
               const loopTier2 = this.options.modelTier ?? "large";
               const maxInterventions = loopTier2 === "small" ? 3 : loopTier2 === "medium" ? 5 : 8;
+              let loopCircuitBreakerFired = false;
+              const loopInterventionOrdinal = loopInterventionCount;
               if (loopInterventionCount >= maxInterventions) {
+                loopCircuitBreakerFired = true;
                 this.emit({
                   type: "status",
                   content: `Loop circuit breaker: ${loopInterventionCount} interventions — requesting user guidance`,
@@ -580557,15 +580869,16 @@ ${sr.result.output}`;
                   role: "system",
                   content: `LOOP CIRCUIT BREAKER: ${loopInterventionCount} interventions attempted but repetition continues.
 
-MANDATORY: You MUST call ask_user to request guidance from the user. Present your options:
+MANDATORY: Change state before taking another action. Choose one:
 1. Try a completely different approach
-2. Provide more context or clarification
-3. Accept partial results and pivot to a related task
-4. Abort this specific subtask and move on
+2. Re-read the exact current target once if the loop is caused by a stale edit
+3. Run verification if files changed since the last successful check
+4. Call ask_user if user input is the real blocker
+5. Report blocked/incomplete with the concrete blocker if no safe progress path remains
 
 Your partial progress: ${partialResults}
 
-Call ask_user(question="I've hit a repetitive loop. How would you like me to proceed?", options=[...]) NOW.`
+Do not call task_complete solely because this circuit breaker fired.`
                 });
                 loopInterventionCount = 0;
               }
@@ -580583,19 +580896,19 @@ Call ask_user(question="I've hit a repetitive loop. How would you like me to pro
               }
               const findingsSummary = findings.length > 0 ? `
 
-Here is what you ALREADY found (use this for your summary):
-${findings.slice(0, 8).map((f2, i2) => `${i2 + 1}. ${f2}`).join("\n")}` : "\n\nYou found no actionable results. Report that the information could not be found.";
+Here is what you ALREADY found. Use this to choose the next non-repetitive action:
+${findings.slice(0, 8).map((f2, i2) => `${i2 + 1}. ${f2}`).join("\n")}` : "\n\nYou found no actionable results. Ask for guidance or report the specific blocker; do not invent completion.";
               messages2.push({
                 role: "system",
-                content: `LOOP DETECTED (intervention ${loopInterventionCount}/${maxInterventions}). The last ${repetitionWindow} tool calls are ${Math.round(currentRepScore * 100)}% repetitive: ${topRepeated}.
+                content: `LOOP DETECTED (intervention ${loopInterventionOrdinal}/${maxInterventions}). The last ${repetitionWindow} tool calls are ${Math.round(currentRepScore * 100)}% repetitive: ${topRepeated}.
 
-MANDATORY: You MUST call task_complete on your next response. Do NOT call ${[...freqMap.keys()].map((k) => k.split("(")[0]).filter((v, i2, a2) => a2.indexOf(v) === i2).join(", ")} again. These tools have returned the same results multiple times.` + findingsSummary + `
+RECOVERY REQUIRED: Do not call task_complete just because repetition was detected. Do NOT call ${[...freqMap.keys()].map((k) => k.split("(")[0]).filter((v, i2, a2) => a2.indexOf(v) === i2).join(", ")} again with the same arguments. These tools have returned the same results multiple times. Choose a different concrete action: read the exact current target once if an edit failed, run verification if files changed, use a different tool or target, or call ask_user when user input is the real blocker.` + findingsSummary + `
 
-Call task_complete(summary="...") NOW with whatever you have.`
+Only call task_complete when the task is actually complete and the evidence is fresh. If work is partial, report the blocker explicitly instead of completing.`
               });
               this.emit({
                 type: "status",
-                content: `Loop intervention ${loopInterventionCount}/${maxInterventions}: ${Math.round(currentRepScore * 100)}% repetitive (${topRepeated})`,
+                content: `Loop intervention ${loopInterventionOrdinal}/${maxInterventions}: ${Math.round(currentRepScore * 100)}% repetitive (${topRepeated})${loopCircuitBreakerFired ? " (circuit breaker advisory)" : ""}`,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
               try {
@@ -581497,7 +581810,19 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
 
 ${this._completionCaveat}` : this._completionCaveat;
         }
-        const runStatus = completed ? "completed" : this._completionLedger?.status === "blocked" || this._completionLedger?.status === "request_changes" ? "incomplete_verification" : this._completionIncompleteVerification ? "incomplete_verification" : "incomplete";
+        if (this._completionLedger) {
+          this._completionLedger = finalizeCompletionLedgerTruth(this._completionLedger);
+          this._saveCompletionLedgerSafe();
+          if (completed && this._completionLedger.status === "incomplete_verification") {
+            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.";
+            summary = summary ? `${summary}
+
+${caveat}` : caveat;
+          }
+        }
+        const runStatus = completed ? "completed" : this._completionLedger?.status === "blocked" || this._completionLedger?.status === "request_changes" || this._completionLedger?.status === "incomplete_verification" ? "incomplete_verification" : this._completionIncompleteVerification ? "incomplete_verification" : "incomplete";
         this._emitMASTSummary("run-end");
         this.emit({
           type: "complete",
@@ -581545,6 +581870,8 @@ ${this._completionCaveat}` : this._completionCaveat;
           }
         }
         try {
+          if (!this.writesUserTaskArtifacts())
+            throw "skip-user-task-consolidation";
           const extractPaths = (entries, toolNames) => {
             return [
               ...new Set(entries.filter((tc) => toolNames.includes(tc.name)).map((tc) => {
@@ -581655,8 +581982,11 @@ ${this._completionCaveat}` : this._completionCaveat;
               toolsUsed: consolidation.toolsUsed,
               toolCallLog,
               turns: consolidation.turns,
-              transcriptPath
+              transcriptPath,
+              artifactMode: this.options.artifactMode
             });
+            if (!shouldPersistTaskHandoff(handoff))
+              throw "skip-low-quality-handoff";
             writeTaskHandoff(omniusDir, handoff);
             appendBoundaryToLog(omniusDir, handoff);
             trimLog(omniusDir);
@@ -581669,7 +581999,7 @@ ${this._completionCaveat}` : this._completionCaveat;
           });
         } catch {
         }
-        if (this._reflectionBuffer && !completed) {
+        if (this._reflectionBuffer && !completed && this.writesUserTaskArtifacts()) {
           try {
             const reflection = this._reflectionBuffer.addReflection({
               taskGoal: persistentTaskGoal,
@@ -581692,7 +582022,7 @@ ${this._completionCaveat}` : this._completionCaveat;
           } catch {
           }
         }
-        if (this._episodeStore) {
+        if (this._episodeStore && this.writesUserTaskArtifacts()) {
           try {
             const taskSummaryContent = `Task "${persistentTaskGoal.slice(0, 200)}" ${completed ? "completed" : "ended"}: ${cleanForStorage(summary).slice(0, 300)}`;
             if (this._crlMemoryStore) {
@@ -582305,6 +582635,150 @@ ${marker}` : marker);
       // -------------------------------------------------------------------------
       // Output folding — keep head + tail, omit middle (preserves errors at end)
       // -------------------------------------------------------------------------
+      isEditToolName(name10) {
+        return name10 === "file_edit" || name10 === "file_patch" || name10 === "batch_edit";
+      }
+      extractPrimaryToolPath(args) {
+        if (!args)
+          return "";
+        const direct = args["path"] ?? args["file"] ?? args["filePath"] ?? args["file_path"];
+        if (typeof direct === "string" && direct.trim())
+          return direct.trim();
+        const edits = args["edits"];
+        if (Array.isArray(edits)) {
+          for (const edit of edits) {
+            if (!edit || typeof edit !== "object")
+              continue;
+            const rec = edit;
+            const editPath = rec["path"] ?? rec["file"] ?? rec["filePath"] ?? rec["file_path"];
+            if (typeof editPath === "string" && editPath.trim())
+              return editPath.trim();
+          }
+        }
+        return "";
+      }
+      staleEditTarget(toolName, args) {
+        if (!this.isEditToolName(toolName) || !args)
+          return null;
+        const path12 = this.extractPrimaryToolPath(args);
+        const parts = [];
+        const directKeys = [
+          "old_string",
+          "oldString",
+          "oldText",
+          "search",
+          "expected_old_string",
+          "expectedHash",
+          "expected_hash",
+          "start_line"
+        ];
+        for (const key of directKeys) {
+          const value2 = args[key];
+          if (typeof value2 === "string" || typeof value2 === "number") {
+            parts.push(key + "=" + String(value2));
+          }
+        }
+        const edits = args["edits"];
+        if (Array.isArray(edits)) {
+          for (const edit of edits.slice(0, 6)) {
+            if (!edit || typeof edit !== "object")
+              continue;
+            const rec = edit;
+            const oldValue = rec["old_string"] ?? rec["oldString"] ?? rec["oldText"] ?? rec["search"] ?? rec["expected_old_string"];
+            const editPath = rec["path"] ?? rec["file"] ?? rec["filePath"] ?? rec["file_path"];
+            if (typeof editPath === "string" || typeof oldValue === "string") {
+              parts.push(String(editPath ?? path12) + "=" + String(oldValue ?? ""));
+            }
+          }
+        }
+        if (!path12 && parts.length === 0)
+          return null;
+        const normalized = parts.join("\n").replace(/\s+/g, " ").trim() || JSON.stringify(args).slice(0, 1e3);
+        return {
+          path: path12 || "(unknown)",
+          targetHash: this.quickHash(normalized),
+          preview: normalized.slice(0, 160)
+        };
+      }
+      classifyStaleEditFailure(toolName, result) {
+        if (!this.isEditToolName(toolName) || result.success)
+          return null;
+        const text2 = String((result.error ?? "") + "\n" + (result.output ?? "")).toLowerCase();
+        if (/ambiguous|multiple occurrences|matches more than once/.test(text2))
+          return "ambiguous_old_string";
+        if (/expected[_ -]?hash|hash mismatch|stale hash|beforehash|afterhash/.test(text2))
+          return "stale_expected_hash";
+        if (/expected.*content|content.*did not match|context mismatch|patch failed|hunk failed/.test(text2))
+          return "stale_expected_content";
+        if (/atomic.*abort|batch.*abort|skipped/.test(text2) && toolName === "batch_edit")
+          return "atomic_batch_abort";
+        if (/old[_ -]?string|old text|old content|not found|no occurrences|0 occurrences|could not find/.test(text2))
+          return "stale_old_string";
+        return null;
+      }
+      staleEditFamilyKey(toolName, path12, errorKind, targetHash) {
+        return toolName + ":" + path12 + ":" + errorKind + ":" + targetHash;
+      }
+      staleEditPreflightBlock(toolName, args) {
+        const target = this.staleEditTarget(toolName, args);
+        if (!target)
+          return null;
+        for (const entry of this._staleEditFamilies.values()) {
+          if (entry.tool !== toolName || entry.path !== target.path || entry.targetHash !== target.targetHash)
+            continue;
+          const hasFreshRead = entry.lastReadTurn > entry.lastFailureTurn;
+          const hasFreshMutation = entry.lastMutationTurn > entry.lastFailureTurn;
+          if (entry.count >= 2 && !hasFreshRead && !hasFreshMutation) {
+            return [
+              "[STALE EDIT LOOP BLOCKED] " + toolName + " has already failed " + entry.count + " times for " + entry.path + " (" + entry.errorKind + ").",
+              "Do not retry the same stale edit target again. First file_read the current file content once, then either:",
+              "1. confirm the desired change is already present and run verification,",
+              "2. build a new edit from the exact current text, or",
+              "3. choose a different target if this edit is no longer relevant.",
+              "Previous stale target preview: " + entry.preview
+            ].join("\n");
+          }
+        }
+        return null;
+      }
+      noteStaleEditGuardOutcome(toolName, args, result, turn) {
+        const path12 = this.extractPrimaryToolPath(args);
+        if (toolName === "file_read" && path12 && result.success) {
+          for (const entry of this._staleEditFamilies.values()) {
+            if (entry.path === path12)
+              entry.lastReadTurn = turn;
+          }
+          return;
+        }
+        if (!this.isEditToolName(toolName))
+          return;
+        const target = this.staleEditTarget(toolName, args);
+        if (!target)
+          return;
+        if (result.success && result.mutated !== false) {
+          for (const [key2, entry] of this._staleEditFamilies) {
+            if (entry.path === target.path)
+              this._staleEditFamilies.delete(key2);
+          }
+          return;
+        }
+        const errorKind = this.classifyStaleEditFailure(toolName, result);
+        if (!errorKind)
+          return;
+        const key = this.staleEditFamilyKey(toolName, target.path, errorKind, target.targetHash);
+        const existing = this._staleEditFamilies.get(key);
+        this._staleEditFamilies.set(key, {
+          count: (existing?.count ?? 0) + 1,
+          path: target.path,
+          tool: toolName,
+          errorKind,
+          targetHash: target.targetHash,
+          lastFailureTurn: turn,
+          lastReadTurn: existing?.lastReadTurn ?? -1,
+          lastMutationTurn: existing?.lastMutationTurn ?? -1,
+          preview: target.preview
+        });
+      }
       /**
        * Quick non-cryptographic hash for Memex experience IDs.
        * Produces a short hex string (8 chars) from input.
@@ -583638,6 +584112,39 @@ ${trimmedNew}`;
        *  Generates typed self-reflections on task failure and injects them
        *  into the next attempt's context for active learning. */
       _reflectionBuffer = null;
+      buildAdversaryToolOutcomeEvidence(toolName, toolArgs, content, succeeded) {
+        const pathValue = toolArgs?.["path"] ?? toolArgs?.["file"] ?? toolArgs?.["filePath"] ?? toolArgs?.["file_path"];
+        const path12 = typeof pathValue === "string" && pathValue.trim() ? pathValue.trim() : void 0;
+        const compact3 = content.replace(/\s+/g, " ").trim();
+        const snippet = compact3.slice(0, 160);
+        const digest3 = _createHash("sha256").update(content).digest("hex").slice(0, 16);
+        const lineCount = content.length > 0 ? content.split("\n").length : 0;
+        if (toolName === "file_read") {
+          const evidence = path12 ? `file_read confirmed path=${path12}; lines=${lineCount}; sha256=${digest3}` : `file_read confirmed content; lines=${lineCount}; sha256=${digest3}`;
+          return {
+            path: path12,
+            evidence,
+            preview: `${evidence}; content="${snippet}"`
+          };
+        }
+        if (/^(file_write|file_edit|file_patch|batch_edit)$/.test(toolName)) {
+          const evidence = path12 ? `${toolName} succeeded for path=${path12}; output_sha256=${digest3}` : `${toolName} succeeded; output_sha256=${digest3}`;
+          return {
+            path: path12,
+            evidence,
+            preview: `${evidence}; output="${snippet}"`
+          };
+        }
+        if (toolName === "shell") {
+          const command = typeof toolArgs?.["command"] === "string" ? String(toolArgs["command"]) : void 0;
+          return {
+            path: command,
+            evidence: succeeded ? `shell exited successfully; stdout_sha256=${digest3}` : `shell failed; output_sha256=${digest3}`,
+            preview: snippet || content.slice(0, 160)
+          };
+        }
+        return { preview: snippet || content.slice(0, 160) };
+      }
       /**
        * Adversary: post-turn meta-analysis.
        *
@@ -583651,29 +584158,10 @@ ${trimmedNew}`;
        */
       adversaryObserve(messages2, turn) {
         const recent = messages2.slice(-6);
-        if (this._adversaryStream) {
-          const lastAssistantMsg = [...recent].reverse().find((m2) => m2.role === "assistant" && typeof m2.content === "string");
-          const assistantText = typeof lastAssistantMsg?.content === "string" ? lastAssistantMsg.content.replace(/<think>[\s\S]*?<\/think>/g, "").trim() : "";
-          if (assistantText) {
-            this._adversaryStream.observe({
-              turn,
-              assistantText,
-              recentToolOutcomes: this._adversaryToolOutcomes.slice(-8).map((o2) => ({
-                tool: o2.tool,
-                succeeded: o2.succeeded,
-                preview: o2.preview
-              })),
-              claimsCompletion: /task.?complete|all tests pass|\bdone\b|\bcomplete(d)?\b/i.test(assistantText)
-            });
-            void this._adversaryStream.tick().catch(() => {
-            });
-          }
-        }
         for (const msg of recent) {
           if (msg.role === "tool" && typeof msg.content === "string") {
             const isError2 = msg.content.startsWith("Error:") || /^(FAIL|ERR!|TypeError)/i.test(msg.content);
             const succeeded = !isError2;
-            const preview = msg.content.slice(0, 80);
             let toolName = "unknown";
             let toolArgs;
             if (msg.tool_call_id) {
@@ -583700,6 +584188,7 @@ ${trimmedNew}`;
               return o2.turn === turn && o2.tool === toolName && o2.fingerprint === fingerprint;
             });
             if (!alreadySeen) {
+              const outcomeEvidence = this.buildAdversaryToolOutcomeEvidence(toolName, toolArgs, msg.content, succeeded);
               this._adversaryToolOutcomes.push({
                 turn,
                 tool: toolName,
@@ -583707,13 +584196,34 @@ ${trimmedNew}`;
                 argsKey,
                 fingerprint,
                 succeeded,
-                preview
+                ...outcomeEvidence
               });
             }
           }
         }
         while (this._adversaryToolOutcomes.length > 20)
           this._adversaryToolOutcomes.shift();
+        if (this._adversaryStream && !this._completionIncompleteVerification) {
+          const lastAssistantMsg = [...recent].reverse().find((m2) => m2.role === "assistant" && typeof m2.content === "string");
+          const assistantText = typeof lastAssistantMsg?.content === "string" ? lastAssistantMsg.content.replace(/<think>[\s\S]*?<\/think>/g, "").trim() : "";
+          if (assistantText) {
+            const claimsCompletion = /task.?complete|all tests pass|\bdone\b|\bcomplete(d)?\b/i.test(assistantText);
+            this._adversaryStream.observe({
+              turn,
+              assistantText,
+              recentToolOutcomes: this._adversaryToolOutcomes.slice(-8).map((o2) => ({
+                tool: o2.tool,
+                succeeded: o2.succeeded,
+                preview: o2.preview,
+                path: o2.path,
+                evidence: o2.evidence
+              })),
+              claimsCompletion
+            });
+            void this._adversaryStream.tick().catch(() => {
+            });
+          }
+        }
         for (const [key, val] of this._adversaryRecentFlags) {
           if (turn - val.lastTurn > _AgenticRunner.ADVERSARY_FLAG_TTL)
             this._adversaryRecentFlags.delete(key);
@@ -654414,6 +654924,7 @@ Call task_complete with the JSON array when done.`,
         const runner = new AgenticRunner(backend, {
           maxTurns: 5,
           // Evaluators are very focused — 5 turns max
+          artifactMode: "internal",
           maxTokens: 4096,
           temperature: 0,
           // Deterministic scoring
@@ -656923,6 +657434,7 @@ var init_dmn_engine = __esm({
         const runner = new AgenticRunner(backend, {
           maxTurns: 15,
           // DMN is lightweight — don't burn too many turns
+          artifactMode: "internal",
           maxTokens: 8192,
           temperature: 0.4,
           // Slightly creative for exploratory reasoning
@@ -657220,6 +657732,7 @@ If decision is GO, selectedTask MUST be a fully-populated object (NEVER null)
         const runner = new AgenticRunner(backend, {
           maxTurns: 8,
           // Brain regions are fast, focused
+          artifactMode: "internal",
           maxTokens: 4096,
           temperature: role === "amygdala" ? 0.2 : role === "pfc_planner" ? 0.5 : 0.3,
           requestTimeoutMs: this.config.timeoutMs,
@@ -657806,6 +658319,7 @@ var init_emotion_engine = __esm({
           );
           const runner = new AgenticRunner(backend, {
             maxTurns: 1,
+            artifactMode: "internal",
             maxTokens: 64,
             temperature: 0.9,
             // High temperature for creative expression
@@ -657889,6 +658403,7 @@ var init_emotion_engine = __esm({
           );
           const runner = new AgenticRunner(backend, {
             maxTurns: 3,
+            artifactMode: "internal",
             maxTokens: 512,
             temperature: 0.35,
             requestTimeoutMs: 2e4,

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.365",
+  "version": "1.0.367",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.365",
+      "version": "1.0.367",
       "bundleDependencies": [
         "image-to-ascii"
       ],
@@ -430,9 +430,9 @@
       }
     },
     "node_modules/@helia/utils/node_modules/cborg": {
-      "version": "5.1.4",
-      "resolved": "https://registry.npmjs.org/cborg/-/cborg-5.1.4.tgz",
-      "integrity": "sha512-EDoD59RBV51H5ar6i29ut7AyOJi0BUIEhtbnJJac3qYcMG74Db6eVce/dIh+Wh6tVwBi7cRWDXmdms+fKPQvcQ==",
+      "version": "5.1.5",
+      "resolved": "https://registry.npmjs.org/cborg/-/cborg-5.1.5.tgz",
+      "integrity": "sha512-1qJ/E8jF1dmJlBm6V1z91iWTWfCK9SuCxPDLod+Ne7CMCASOQh346b+487oFt/zoBQW+XS5wNvMgV+7gs5sJJA==",
       "license": "Apache-2.0",
       "bin": {
         "cborg": "lib/bin.js"
@@ -461,9 +461,9 @@
       }
     },
     "node_modules/@ipld/dag-cbor/node_modules/cborg": {
-      "version": "5.1.4",
-      "resolved": "https://registry.npmjs.org/cborg/-/cborg-5.1.4.tgz",
-      "integrity": "sha512-EDoD59RBV51H5ar6i29ut7AyOJi0BUIEhtbnJJac3qYcMG74Db6eVce/dIh+Wh6tVwBi7cRWDXmdms+fKPQvcQ==",
+      "version": "5.1.5",
+      "resolved": "https://registry.npmjs.org/cborg/-/cborg-5.1.5.tgz",
+      "integrity": "sha512-1qJ/E8jF1dmJlBm6V1z91iWTWfCK9SuCxPDLod+Ne7CMCASOQh346b+487oFt/zoBQW+XS5wNvMgV+7gs5sJJA==",
       "license": "Apache-2.0",
       "bin": {
         "cborg": "lib/bin.js"
@@ -480,9 +480,9 @@
       }
     },
     "node_modules/@ipld/dag-json/node_modules/cborg": {
-      "version": "5.1.4",
-      "resolved": "https://registry.npmjs.org/cborg/-/cborg-5.1.4.tgz",
-      "integrity": "sha512-EDoD59RBV51H5ar6i29ut7AyOJi0BUIEhtbnJJac3qYcMG74Db6eVce/dIh+Wh6tVwBi7cRWDXmdms+fKPQvcQ==",
+      "version": "5.1.5",
+      "resolved": "https://registry.npmjs.org/cborg/-/cborg-5.1.5.tgz",
+      "integrity": "sha512-1qJ/E8jF1dmJlBm6V1z91iWTWfCK9SuCxPDLod+Ne7CMCASOQh346b+487oFt/zoBQW+XS5wNvMgV+7gs5sJJA==",
       "license": "Apache-2.0",
       "bin": {
         "cborg": "lib/bin.js"
@@ -4293,9 +4293,9 @@
       }
     },
     "node_modules/ipns/node_modules/cborg": {
-      "version": "5.1.4",
-      "resolved": "https://registry.npmjs.org/cborg/-/cborg-5.1.4.tgz",
-      "integrity": "sha512-EDoD59RBV51H5ar6i29ut7AyOJi0BUIEhtbnJJac3qYcMG74Db6eVce/dIh+Wh6tVwBi7cRWDXmdms+fKPQvcQ==",
+      "version": "5.1.5",
+      "resolved": "https://registry.npmjs.org/cborg/-/cborg-5.1.5.tgz",
+      "integrity": "sha512-1qJ/E8jF1dmJlBm6V1z91iWTWfCK9SuCxPDLod+Ne7CMCASOQh346b+487oFt/zoBQW+XS5wNvMgV+7gs5sJJA==",
       "license": "Apache-2.0",
       "bin": {
         "cborg": "lib/bin.js"

package/package.json

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