omnius 1.0.364 → 1.0.366

package/dist/index.js

@@ -17802,15 +17802,23 @@ function relationAllowed(edge, options2) {
     return false;
   return true;
 }
+function edgeAllowed(edge, options2, allowedSourceIds) {
+  if (!relationAllowed(edge, options2))
+    return false;
+  if (!allowedSourceIds)
+    return true;
+  return !!edge.sourceEpisodeId && allowedSourceIds.has(edge.sourceEpisodeId);
+}
 function selectInnerGraphCandidates(graph, candidates, options2 = {}) {
   const minDegree = Math.max(1, Math.floor(options2.minDegree ?? 2));
   const candidateEpisodeIds = [...new Set(candidates.map((candidate) => candidate.episode.id).filter(Boolean))];
+  const allowedSourceIds = options2.allowedSourceEpisodeIds?.length ? new Set(options2.allowedSourceEpisodeIds) : void 0;
   const candidateScore = new Map(candidates.map((candidate) => [candidate.episode.id, candidate.score ?? 0]));
   const candidateTimestamp = new Map(candidates.map((candidate) => [candidate.episode.id, candidate.episode.timestamp]));
   const sourceEdges = graph.currentEdgesForSourceEpisodes(candidateEpisodeIds, Math.max(1e3, candidateEpisodeIds.length * 20));
   const byNode = /* @__PURE__ */ new Map();
   for (const edge of sourceEdges) {
-    if (!relationAllowed(edge, options2))
+    if (!edgeAllowed(edge, options2, allowedSourceIds))
       continue;
     const episodeId = edge.sourceEpisodeId;
     if (!episodeId || !candidateEpisodeIds.includes(episodeId))
@@ -17828,7 +17836,7 @@ function selectInnerGraphCandidates(graph, candidates, options2 = {}) {
   const now2 = Date.now();
   const results = [];
   for (const entry of byNode.values()) {
-    const allEdges = graph.currentEdges(entry.node.id).filter((edge) => relationAllowed(edge, options2));
+    const allEdges = graph.currentEdges(entry.node.id).filter((edge) => edgeAllowed(edge, options2, allowedSourceIds));
     const degree = allEdges.length;
     if (degree < minDegree)
       continue;
@@ -17864,6 +17872,7 @@ function walkGraphFromSeed(graph, seed, options2 = {}) {
   const maxVisitedNodes = Math.max(1, Math.floor(options2.maxVisitedNodes ?? 64));
   const maxTraversedEdges = Math.max(1, Math.floor(options2.maxTraversedEdges ?? 160));
   const maxSourceEpisodes = Math.max(1, Math.floor(options2.maxSourceEpisodes ?? 80));
+  const allowedSourceIds = options2.allowedSourceEpisodeIds?.length ? new Set(options2.allowedSourceEpisodeIds) : void 0;
   const visited = /* @__PURE__ */ new Map();
   const depthByNodeId = {};
   const traversed = /* @__PURE__ */ new Map();
@@ -17882,7 +17891,7 @@ function walkGraphFromSeed(graph, seed, options2 = {}) {
     const item = queue.shift();
     if (item.depth >= maxDepth)
       continue;
-    const neighbors2 = graph.neighbors(item.node.id).filter(({ edge }) => relationAllowed(edge, options2)).sort((a2, b) => b.edge.confidence - a2.edge.confidence || b.node.mentionCount - a2.node.mentionCount);
+    const neighbors2 = graph.neighbors(item.node.id).filter(({ edge }) => edgeAllowed(edge, options2, allowedSourceIds)).sort((a2, b) => b.edge.confidence - a2.edge.confidence || b.node.mentionCount - a2.node.mentionCount);
     for (const { node, edge } of neighbors2) {
       if (traversed.size >= maxTraversedEdges)
         break;
@@ -558565,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)}
@@ -561348,7 +561424,7 @@ function sanitizeMessagesForCheckpoint(messages2) {
       deduped.push(m2);
       continue;
     }
-    if (i2 === lastFrameIdx) {
+    if (content.startsWith(CONTEXT_FRAME_MARKER)) {
       deduped.push(m2);
       continue;
     }
@@ -561363,6 +561439,10 @@ function sanitizeMessagesForCheckpoint(messages2) {
   for (const m2 of deduped) {
     if (m2.role === "system") {
       const content = typeof m2.content === "string" ? m2.content : "";
+      if (content.startsWith(CONTEXT_FRAME_MARKER)) {
+        capped.push(m2);
+        continue;
+      }
       if (sysChars + content.length > MAX_CHECKPOINT_SYSTEM_CHARS) {
         continue;
       }
@@ -563837,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 {
@@ -563892,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);
@@ -563940,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;
@@ -564169,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 });
@@ -564206,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;
@@ -564274,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;
@@ -564304,6 +564477,8 @@ function logPath2(omniusDir, sessionLogId) {
 function appendBoundaryToLog(omniusDir, handoff) {
   if (!logEnabled())
     return;
+  if (!shouldPersistTaskHandoff(handoff))
+    return;
   const id = tuiSessionLogId();
   if (!id)
     return;
@@ -564332,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 {
       }
@@ -565883,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),
@@ -565901,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)}`;
@@ -565919,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: [] },
@@ -570259,6 +570462,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)
@@ -570607,6 +570811,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 ?? "",
@@ -570658,7 +570863,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 });
@@ -570671,6 +570881,8 @@ ${parts.join("\n")}
         }
       }
       _saveCompletionLedgerSafe() {
+        if (!this.writesUserTaskArtifacts())
+          return;
         if (!this._completionLedger)
           return;
         try {
@@ -570682,8 +570894,9 @@ ${parts.join("\n")}
       }
       _initializeCompletionContract(task, context2, actualUserGoal) {
         const goalText = actualUserGoal || task;
-        this._completionContractSeedText = [goalText, context2 ?? ""].map((text2) => String(text2 || "").trim()).filter(Boolean).join("\n\n");
-        this._completionContract = inferCompletionContractFromTexts([this._completionContractSeedText], task);
+        const seedTexts = actualUserGoal ? [goalText] : [goalText, context2 ?? ""];
+        this._completionContractSeedText = seedTexts.map((text2) => String(text2 || "").trim()).filter(Boolean).join("\n\n");
+        this._completionContract = inferCompletionContractFromTexts([this._completionContractSeedText], goalText);
         this._persistCompletionContract(this._completionContract);
         return this._completionContract;
       }
@@ -575442,6 +575655,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();
@@ -575537,7 +575751,8 @@ Respond with your assessment, then take action.`;
         this._loadResolutionMemory();
         this._pauseResolve = null;
         this.pendingUserMessages.length = 0;
-        const userGoal = (actualUserGoal || cleanedTask).slice(0, 500);
+        const persistentTaskGoal = cleanForStorage(actualUserGoal || "") || cleanedTask;
+        const userGoal = persistentTaskGoal.slice(0, 500);
         this._taskState = {
           goal: userGoal,
           originalGoal: userGoal,
@@ -575583,11 +575798,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 {
@@ -575737,8 +575957,8 @@ ${_notes}`;
         }
         try {
           if (!this.options.subAgent) {
-            const _imp = Math.min(9, Math.max(3, 3 + Math.floor((task?.length || 0) / 250)));
-            const _kw = String(task || "").toLowerCase().match(/[a-z][a-z0-9_-]{3,}/g)?.filter((w) => ![
+            const _imp = Math.min(9, Math.max(3, 3 + Math.floor((persistentTaskGoal.length || 0) / 250)));
+            const _kw = String(persistentTaskGoal || "").toLowerCase().match(/[a-z][a-z0-9_-]{3,}/g)?.filter((w) => ![
               "this",
               "that",
               "with",
@@ -575750,14 +575970,14 @@ ${_notes}`;
               "please"
             ].includes(w)).slice(0, 6) ?? [];
             noteAfterTask({
-              summary: `Task: ${String(task).slice(0, 200)}`,
+              summary: `Task: ${persistentTaskGoal.slice(0, 200)}`,
               importance: _imp,
               keywords: _kw
             });
           }
         } catch {
         }
-        this._contextTree = new ContextTree(`sys-${systemPrompt.length}`, cleanedTask.slice(0, 200));
+        this._contextTree = new ContextTree(`sys-${systemPrompt.length}`, persistentTaskGoal.slice(0, 200));
         this.emit({
           type: "status",
           content: `Context assembled: ${contextComposition.sections.map((s2) => `${s2.label}(${s2.tokenEstimate}t)`).join(" + ")} = ~${contextComposition.totalTokenEstimate}t`,
@@ -575780,7 +576000,7 @@ TASK: ${scrubbedTask}` : scrubbedTask;
             contextFrame: {
               kind: "system_prompt",
               capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
-              taskPreview: cleanedTask.slice(0, 240),
+              taskPreview: persistentTaskGoal.slice(0, 240),
               assembledCharCount: systemPrompt.length,
               totalTokenEstimate: contextComposition.totalTokenEstimate,
               sections: contextComposition.sections.map((section, order) => ({
@@ -575801,13 +576021,13 @@ TASK: ${scrubbedTask}` : scrubbedTask;
             }
           });
         }
-        const missionCompletionContract = this.buildMissionCompletionContract(cleanedTask, context2);
+        const missionCompletionContract = this.buildMissionCompletionContract(persistentTaskGoal, context2);
         const messages2 = [
           { role: "system", content: systemPrompt },
           ...missionCompletionContract ? [{ role: "system", content: missionCompletionContract }] : [],
           { role: "user", content: userContent }
         ];
-        const preflightMemoryRecall = this._buildPreflightTaskMemoryRecall(cleanedTask);
+        const preflightMemoryRecall = this._buildPreflightTaskMemoryRecall(persistentTaskGoal);
         if (preflightMemoryRecall) {
           messages2.splice(messages2.length - 1, 0, {
             role: "system",
@@ -575863,6 +576083,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))
@@ -575871,7 +576093,7 @@ TASK: ${scrubbedTask}` : scrubbedTask;
             throw "skip-handoff-fresh";
           const omniusDir = this._workingDirectory ? _pathJoin(this._workingDirectory, ".omnius") : _pathJoin(process.cwd(), ".omnius");
           const chainPairs = loadMessagePairsFromLog(omniusDir, {
-            currentTask: cleanedTask
+            currentTask: persistentTaskGoal
           });
           if (chainPairs.length > 0) {
             messages2.splice(1, 0, ...chainPairs);
@@ -575883,7 +576105,7 @@ TASK: ${scrubbedTask}` : scrubbedTask;
           } else {
             const prior = readTaskHandoff(omniusDir, {
               currentSessionId: this._sessionId,
-              currentTask: cleanedTask
+              currentTask: persistentTaskGoal
             });
             if (prior) {
               const handoffPair = buildHandoffMessagePair(prior);
@@ -575899,6 +576121,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) {
@@ -575906,7 +576130,7 @@ TASK: ${scrubbedTask}` : scrubbedTask;
             }
           }
           if (this._reflectionBuffer) {
-            const reflections = this._reflectionBuffer.getRelevantReflections(cleanedTask, 3);
+            const reflections = this._reflectionBuffer.getRelevantReflections(persistentTaskGoal, 3);
             if (reflections.length > 0) {
               const reflectionCtx = this._reflectionBuffer.formatForContext(reflections);
               messages2.push({ role: "system", content: reflectionCtx });
@@ -575922,7 +576146,7 @@ TASK: ${scrubbedTask}` : scrubbedTask;
         if (process.env["OMNIUS_DISABLE_FAILURE_HANDOFF"] !== "1") {
           try {
             const failureHandoff = buildFailureModeHandoff({
-              taskGoal: cleanedTask,
+              taskGoal: persistentTaskGoal,
               errorPatterns: this._errorPatterns,
               toolCallLog,
               taskState: this._taskState,
@@ -576127,7 +576351,7 @@ TASK: ${scrubbedTask}` : scrubbedTask;
           })();
           const gate = this._evaluateCompletionProvenanceGate({
             summary: proposedSummary,
-            taskGoal: cleanedTask,
+            taskGoal: persistentTaskGoal,
             toolCallLog,
             answerText: lastAssistantText
           });
@@ -578497,6 +578721,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",
@@ -579977,6 +580238,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;
               }
@@ -580158,7 +580420,7 @@ Then use file_read on individual FILES inside it.`);
               }
               if (process.env["OMNIUS_DISABLE_FAILURE_HANDOFF"] !== "1" && !result.success && turn - lastFailureHandoffTurn >= 4) {
                 const runtimeHandoff = buildFailureModeHandoff({
-                  taskGoal: cleanedTask,
+                  taskGoal: persistentTaskGoal,
                   errorPatterns: this._errorPatterns,
                   toolCallLog,
                   taskState: this._taskState,
@@ -580531,7 +580793,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`,
@@ -580542,15 +580807,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;
               }
@@ -580568,19 +580834,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 {
@@ -581482,7 +581748,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",
@@ -581530,6 +581808,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) => {
@@ -581540,7 +581820,7 @@ ${this._completionCaveat}` : this._completionCaveat;
           };
           const consolidation = {
             sessionId: this._sessionId,
-            task: cleanedTask.slice(0, 500),
+            task: persistentTaskGoal.slice(0, 500),
             outcome: completed ? "success" : this.aborted ? "aborted" : runStatus === "incomplete_verification" ? "incomplete_verification" : "timeout",
             turns: messages2.filter((m2) => m2.role === "assistant").length,
             toolsUsed: [...new Set(toolCallLog.map((tc) => tc.name))],
@@ -581565,7 +581845,7 @@ ${this._completionCaveat}` : this._completionCaveat;
           fs11.mkdirSync(provenanceDir, { recursive: true });
           const provenanceGraph = {
             sessionId: this._sessionId,
-            task: cleanedTask.slice(0, 500),
+            task: persistentTaskGoal.slice(0, 500),
             outcome: consolidation.outcome,
             timestamp: consolidation.timestamp,
             // Full action trace — every tool call with sequence ordering
@@ -581615,7 +581895,7 @@ ${this._completionCaveat}` : this._completionCaveat;
           });
           if (completed && this.tools.has("memory_write")) {
             const memTool = this.tools.get("memory_write");
-            const lessonContent = `Task "${cleanedTask.slice(0, 100)}" completed successfully. Tools: ${consolidation.toolsUsed.join(", ")}. Files: ${consolidation.filesModified.slice(0, 3).join(", ")}. Duration: ${Math.round(durationMs / 1e3)}s, ${consolidation.turns} turns.`;
+            const lessonContent = `Task "${persistentTaskGoal.slice(0, 100)}" completed successfully. Tools: ${consolidation.toolsUsed.join(", ")}. Files: ${consolidation.filesModified.slice(0, 3).join(", ")}. Duration: ${Math.round(durationMs / 1e3)}s, ${consolidation.turns} turns.`;
             try {
               await memTool.execute({
                 topic: "task_lessons",
@@ -581633,15 +581913,18 @@ ${this._completionCaveat}` : this._completionCaveat;
             const transcriptPath = _pathJoin(omniusDir, "consolidations", `${this._sessionId}.json`);
             const handoff = buildTaskHandoff({
               sessionId: this._sessionId,
-              goal: cleanedTask,
+              goal: persistentTaskGoal,
               outcome,
               summary,
               filesModified: consolidation.filesModified,
               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);
@@ -581654,10 +581937,10 @@ ${this._completionCaveat}` : this._completionCaveat;
           });
         } catch {
         }
-        if (this._reflectionBuffer && !completed) {
+        if (this._reflectionBuffer && !completed && this.writesUserTaskArtifacts()) {
           try {
             const reflection = this._reflectionBuffer.addReflection({
-              taskGoal: cleanedTask,
+              taskGoal: persistentTaskGoal,
               sessionId: this._sessionId,
               turnsSpent: this._taskState.toolCallCount,
               failedApproaches: this._taskState.failedApproaches,
@@ -581677,9 +581960,9 @@ ${this._completionCaveat}` : this._completionCaveat;
           } catch {
           }
         }
-        if (this._episodeStore) {
+        if (this._episodeStore && this.writesUserTaskArtifacts()) {
           try {
-            const taskSummaryContent = `Task "${cleanedTask.slice(0, 200)}" ${completed ? "completed" : "ended"}: ${cleanForStorage(summary).slice(0, 300)}`;
+            const taskSummaryContent = `Task "${persistentTaskGoal.slice(0, 200)}" ${completed ? "completed" : "ended"}: ${cleanForStorage(summary).slice(0, 300)}`;
             if (this._crlMemoryStore) {
               this._crlMemoryStore.storeCRL({
                 content: taskSummaryContent,
@@ -581908,7 +582191,7 @@ ${this._completionCaveat}` : this._completionCaveat;
               await this.processPendingEmbeddings();
             }
             this.stopEmbeddingPipeline();
-            const gist = compressAndStore(this._episodeStore, this._sessionId, task, 10);
+            const gist = compressAndStore(this._episodeStore, this._sessionId, persistentTaskGoal, 10);
             if (gist) {
               this.emit({
                 type: "status",
@@ -581934,7 +582217,7 @@ ${this._completionCaveat}` : this._completionCaveat;
                 this._taskMemoryStore.insert({
                   sessionId: this._sessionId,
                   repoRoot: process.cwd(),
-                  goal: task.slice(0, 500),
+                  goal: persistentTaskGoal.slice(0, 500),
                   constraints: [],
                   filesTouched: [],
                   patches: [],
@@ -581961,7 +582244,7 @@ ${this._completionCaveat}` : this._completionCaveat;
             }
             if (this._proceduralMemoryStore && completed) {
               try {
-                const strategy = `Task "${task.slice(0, 100)}" completed using tools: ${(this._toolSequence || []).slice(0, 5).join(" → ")}`;
+                const strategy = `Task "${persistentTaskGoal.slice(0, 100)}" completed using tools: ${(this._toolSequence || []).slice(0, 5).join(" → ")}`;
                 this._proceduralMemoryStore.create({
                   content: strategy,
                   category: "strategy"
@@ -582117,7 +582400,7 @@ ${this._completionCaveat}` : this._completionCaveat;
             // 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: cleanedTask.slice(0, 1e3),
+            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",
@@ -582290,6 +582573,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.
@@ -654399,6 +654826,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
@@ -656908,6 +657336,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
@@ -657205,6 +657634,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,
@@ -657791,6 +658221,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
@@ -657874,6 +658305,7 @@ var init_emotion_engine = __esm({
           );
           const runner = new AgenticRunner(backend, {
             maxTurns: 3,
+            artifactMode: "internal",
             maxTokens: 512,
             temperature: 0.35,
             requestTimeoutMs: 2e4,
@@ -661267,6 +661699,38 @@ ${artifact.personaContext.slice(0, 3e3)}
     ""
   ].join("\n");
 }
+function daydreamExtractionFailed(artifact) {
+  const hasStructuredExtraction = artifact.tagging.length > 0 || artifact.summation.length > 0 || artifact.titling.length > 0 || artifact.extraction.length > 0 || artifact.linking.length > 0 || artifact.extractionFollowups.length > 0;
+  if (hasStructuredExtraction) return false;
+  return artifact.corpus.fallbacks.some(
+    (fallback) => /structured extraction unavailable|timeout|no valid json|backend unavailable/i.test(
+      fallback
+    )
+  );
+}
+function formatTelegramChannelDaydreamMetadataMarkdown(artifact) {
+  return [
+    `# Telegram Channel Daydream ${artifact.id}`,
+    "",
+    `Generated: ${artifact.generatedAt}`,
+    `Session: ${artifact.sessionKey}`,
+    `Chat: ${artifact.chatTitle || artifact.chatId} (${artifact.chatType})`,
+    "Mode: metadata-only; structured extraction did not complete.",
+    "",
+    "## Reflection Corpus",
+    artifact.corpus.stats ? [
+      `- retained messages: ${artifact.corpus.stats.retainedMessages}`,
+      `- candidate episodes: ${artifact.corpus.stats.candidateEpisodes}`,
+      `- selected episodes: ${artifact.corpus.stats.selectedEpisodes}`,
+      `- graph walk: ${artifact.corpus.stats.graphNodesVisited} node(s), ${artifact.corpus.stats.graphEdgesTraversed} edge(s)`
+    ].join("\n") : "- Not available",
+    artifact.corpus.fallbacks.length ? `- fallbacks: ${artifact.corpus.fallbacks.join("; ")}` : "- fallbacks: none",
+    "",
+    "## Context Notes",
+    artifact.contextEngineeringNotes.length ? artifact.contextEngineeringNotes.map((line) => `- ${line}`).join("\n") : "- None",
+    ""
+  ].join("\n");
+}
 function pruneTelegramChannelDaydreams(repoRoot, sessionKey, keep = DAYDREAM_ARTIFACT_RETENTION_LIMIT) {
   const dir = sessionDir(repoRoot, sessionKey);
   if (!existsSync144(dir)) return 0;
@@ -661292,7 +661756,7 @@ function writeTelegramChannelDaydream(repoRoot, artifact) {
   writeFileSync76(jsonPath, JSON.stringify(artifact, null, 2) + "\n", "utf8");
   writeFileSync76(
     markdownPath,
-    formatTelegramChannelDaydreamMarkdown(artifact),
+    daydreamExtractionFailed(artifact) ? formatTelegramChannelDaydreamMetadataMarkdown(artifact) : formatTelegramChannelDaydreamMarkdown(artifact),
     "utf8"
   );
   pruneTelegramChannelDaydreams(repoRoot, artifact.sessionKey);
@@ -661659,7 +662123,8 @@ async function buildTelegramReflectionCorpus(options2) {
           maxDepth: 2,
           maxVisitedNodes: 72,
           maxTraversedEdges: 180,
-          maxSourceEpisodes: 100
+          maxSourceEpisodes: 100,
+          allowedSourceEpisodeIds: candidateEpisodes.map((episode) => episode.id)
         }
       );
       if (graphWalk.seed) {
@@ -661673,7 +662138,8 @@ async function buildTelegramReflectionCorpus(options2) {
               maxDepth: 3,
               maxVisitedNodes: 96,
               maxTraversedEdges: 240,
-              maxSourceEpisodes: 120
+              maxSourceEpisodes: 120,
+              allowedSourceEpisodeIds: candidateEpisodes.map((episode) => episode.id)
             }
           );
           if (deeper.seed && deeper.sourceEpisodeIds.length >= graphWalk.sourceEpisodeIds.length) graphWalk = deeper;
@@ -663173,6 +663639,20 @@ function formatModelBytes(bytes) {
   }
   return `${value2 >= 10 || unit === 0 ? value2.toFixed(0) : value2.toFixed(1)} ${units[unit]}`;
 }
+function telegramMediaContextEvidenceTools(mediaContext) {
+  const tools = [];
+  if (/\[Vision analysis of image|Moondream|auxiliary_vision|vision model/i.test(
+    mediaContext
+  ))
+    tools.push("vision_ingress");
+  if (/\[OCR Text from image|ocr_image_advanced|Advanced text extraction|OCR:/i.test(
+    mediaContext
+  ))
+    tools.push("ocr_ingress");
+  if (/voice message transcribed|transcription/i.test(mediaContext))
+    tools.push("transcribe_ingress");
+  return tools;
+}
 function cleanTelegramDecisionNote(value2, maxLength = 260) {
   if (typeof value2 !== "string") return void 0;
   const clean5 = stripTelegramHiddenThinking(value2).replace(/\s+/g, " ").trim();
@@ -667351,7 +667831,7 @@ ${message2}`)
         if (isGroup) {
           this.markLastTelegramUserMessageMode(msg, "steering");
         } else {
-          this.recordTelegramUserMessage(msg, "steering", context2);
+          this.recordTelegramUserMessage(msg, "steering");
         }
         this.enqueueTelegramSubAgentContext(
           sessionKey,
@@ -670123,7 +670603,11 @@ ${mediaContext}` : ""
       recordTelegramUserMessage(msg, mode, textOverride) {
         const sessionKey = this.sessionKeyForMessage(msg);
         const mediaSummary = summarizeTelegramMessageAttachments(msg);
-        const text2 = normalizeTelegramOutboundLinks((textOverride ?? msg.text ?? "").trim()) || mediaSummary || "[non-text Telegram message]";
+        const overrideText = (textOverride ?? "").trim();
+        const useOverride = textOverride !== void 0 && !_TelegramBridge.isSyntheticMemoryText(overrideText);
+        const text2 = normalizeTelegramOutboundLinks(
+          (useOverride ? overrideText : msg.text ?? "").trim()
+        ) || mediaSummary || "[non-text Telegram message]";
         this.ensureTelegramConversationLoaded(sessionKey);
         const history = this.chatHistory.get(sessionKey) ?? [];
         const existing = Number.isFinite(msg.messageId) ? history.find(
@@ -670132,7 +670616,7 @@ ${mediaContext}` : ""
         if (existing) {
           if (existing.mode === "ambient" || mode !== "ambient")
             existing.mode = mode;
-          if (textOverride !== void 0 || !existing.text || existing.text === "[non-text Telegram message]") {
+          if (useOverride || !existing.text || existing.text === "[non-text Telegram message]" || _TelegramBridge.isSyntheticMemoryText(existing.text)) {
             existing.text = text2;
           }
           existing.speaker = existing.speaker || telegramSpeakerLabel(msg);
@@ -670544,6 +671028,8 @@ ${mediaContext}` : ""
         this.chatParticipants.set(sessionKey, participants);
       }
       updateTelegramAssociativeMemory(sessionKey, entry) {
+        const cleanText2 = stripTelegramHiddenThinking(entry.text || "").replace(/\s+/g, " ").trim();
+        if (!cleanText2 || _TelegramBridge.isSyntheticMemoryText(cleanText2)) return;
         const memory = this.telegramAssociativeMemoryForSession(sessionKey);
         const now2 = entry.ts ?? Date.now();
         memory.updatedAt = now2;
@@ -670760,11 +671246,14 @@ ${mediaContext}` : ""
         /Telegram response contract/,
         /Telegram link integrity contract/
       ];
+      static isSyntheticMemoryText(text2) {
+        const clean5 = String(text2 || "").replace(/\s+/g, " ").trim();
+        return _TelegramBridge.SYNTHETIC_MEMORY_PATTERNS.some((p2) => p2.test(clean5));
+      }
       updateTelegramMemoryCards(sessionKey, entry) {
         const text2 = stripTelegramHiddenThinking(entry.text || "").replace(/\s+/g, " ").trim();
         if (!text2 || text2.length < 3) return;
-        if (_TelegramBridge.SYNTHETIC_MEMORY_PATTERNS.some((p2) => p2.test(text2)))
-          return;
+        if (_TelegramBridge.isSyntheticMemoryText(text2)) return;
         if (entry.role === "assistant" && entry.mode && !["chat", "action"].includes(entry.mode))
           return;
         const speaker = telegramHistorySpeaker(entry);
@@ -676627,7 +677116,7 @@ ${creativeWorkspace}` : ""}`;
         if (result.status === "incomplete_verification") {
           subAgent.completionBoundarySeen = false;
         }
-        return selectTelegramFinalResponse({
+        const finalResponse = selectTelegramFinalResponse({
           visibleReplyText: subAgent.visibleReplyText,
           assistantText: subAgent.assistantText,
           streamText: subAgent.streamText,
@@ -676635,6 +677124,26 @@ ${creativeWorkspace}` : ""}`;
           summary: result.summary,
           completionBoundarySeen: subAgent.completionBoundarySeen
         });
+        const scrutinyText = [finalResponse, result.summary].filter(Boolean).join("\n");
+        const violations = auditPerceptionClaims(scrutinyText, {
+          toolsUsed: [
+            ...subAgent.successfulToolNamesThisRun,
+            ...telegramMediaContextEvidenceTools(mediaContext)
+          ]
+        });
+        if (violations.length > 0) {
+          this.subAgentViewCallbacks?.onWrite(
+            subAgent.viewId,
+            confabulationDirective(violations)
+          );
+          const needed = [...new Set(violations.map((v) => v.requiredTool))].join(
+            "; "
+          );
+          return finalResponse ? `${finalResponse}
+
+Verification note: I have not actually run ${needed} for the unsupported action claim above.` : `I have not actually run ${needed} yet, so I cannot verify that claim.`;
+        }
+        return finalResponse;
       }
       telegramScopedMemoryPrefix(chatId) {
         const raw = chatId === void 0 ? "unknown" : String(chatId);