omnius 1.0.212 → 1.0.213

package/dist/index.js

@@ -551582,28 +551582,38 @@ var init_personality = __esm({
 });
 
 // packages/orchestrator/dist/critic.js
-function buildForceProgressBlockMessage(call, hits) {
+function buildCriticGuidanceMessage(call, hits, opts = {}) {
   const argPreview = JSON.stringify(call.args ?? {}).slice(0, 200);
-  return `[FORCED PROGRESS BLOCK — duplicate ${call.tool} call skipped; this is not a tool failure. You have called ${call.tool}(${argPreview}) ${hits} times with identical arguments. The runtime did not re-run the tool; it is returning the prior result below so you can proceed without retrying.
-
-Progress is REQUIRED before this tool will run again with the same arguments. To proceed, do one of these:
-  • file_write or file_edit to make progress, OR
-  • todo_write that advances the plan, OR
-  • task_complete (if all phases are done), OR
-  • Call a different tool or use different arguments.]`;
+  const cached = opts.cachedResult ? `
+Prior evidence preview:
+${opts.cachedResult.slice(0, 700)}` : "";
+  const source = opts.adversaryFlag ? "The adversary recognized this exact tool call as already observed earlier." : `This is exact repeat #${hits} for the same ${call.tool} arguments.`;
+  return `[ADVERSARY GUIDANCE — non-blocking]
+Observation: ${source}
+Call: ${call.tool}(${argPreview})
+Root cause hypothesis: the run is losing track of already-observed evidence, usually after path confusion, compaction, or an over-broad discovery loop.
+Corrective action: let this call's result inform the next step once, then pivot to a concrete action.
+Suggested next actions: edit/write the implicated file, run verification, read a different specific file, or complete with evidence. Prefer not to repeat this exact call again unless the filesystem, browser, or page state changed.${cached}`;
 }
 function buildCachedResultEnvelope(result) {
-  return `[CACHED RESULT — you already have this information from a prior identical call. Do NOT call this tool again with the same arguments.]
+  return `[PRIOR RESULT — already observed by a prior identical call]
 ${result}`;
 }
 function evaluate2(inputs) {
-  const { proposedCall, fingerprint, isReadLike, recentToolResults, dedupHitCount, observerRedundantBlock } = inputs;
-  if (observerRedundantBlock) {
+  const { proposedCall, fingerprint, isReadLike, recentToolResults, dedupHitCount, adversaryRedundantSignal } = inputs;
+  if (adversaryRedundantSignal) {
     const cached = recentToolResults.get(fingerprint);
+    const cachedResult = cached ? buildCachedResultEnvelope(cached.result) : void 0;
     return {
-      decision: "observer_block",
-      reason: "Littleman observer flagged this fingerprint as redundant",
-      cachedResult: cached ? buildCachedResultEnvelope(cached.result) : null
+      decision: "guidance",
+      reason: "Adversary flagged this fingerprint as redundant",
+      hitNumber: (dedupHitCount.get(fingerprint) ?? 0) + 1,
+      guidanceMessage: buildCriticGuidanceMessage(proposedCall, (dedupHitCount.get(fingerprint) ?? 0) + 1, {
+        cachedResult,
+        adversaryFlag: true
+      }),
+      cachedResult,
+      compacted: cached?.compacted
     };
   }
   const cacheEligible = isReadLike || proposedCall.tool === "shell";
@@ -551611,24 +551621,16 @@ function evaluate2(inputs) {
     const cached = recentToolResults.get(fingerprint);
     if (cached !== void 0) {
       const hits = (dedupHitCount.get(fingerprint) ?? 0) + 1;
-      const threshold = proposedCall.tool === "shell" ? SHELL_THRESHOLD : FS_THRESHOLD;
-      if (hits >= threshold) {
-        return {
-          decision: "force_progress_block",
-          reason: `${proposedCall.tool} fingerprint hit count ${hits} >= ${threshold}`,
-          hitNumber: hits,
-          blockMessage: buildForceProgressBlockMessage(proposedCall, hits),
-          cachedResult: buildCachedResultEnvelope(cached.result),
-          compacted: cached.compacted
-        };
-      }
       const cachedEnvelope = buildCachedResultEnvelope(cached.result);
       return {
-        decision: "serve_cached",
-        reason: cached.compacted ? "post-compaction cache re-serve" : `duplicate call #${hits} (still under ${threshold}-hit gate)`,
+        decision: "guidance",
+        reason: cached.compacted ? "post-compaction duplicate evidence" : `duplicate call #${hits}`,
         cachedResult: cachedEnvelope,
         compacted: cached.compacted,
-        hitNumber: hits
+        hitNumber: hits,
+        guidanceMessage: buildCriticGuidanceMessage(proposedCall, hits, {
+          cachedResult: cachedEnvelope
+        })
       };
     }
   }
@@ -551680,12 +551682,9 @@ function isStagnant(signals, opts) {
     return false;
   return signals.completedDelta <= 0 && signals.filesDelta < filesDeltaMin && signals.failureSum >= failureThreshold && signals.variantCount >= variantThreshold;
 }
-var SHELL_THRESHOLD, FS_THRESHOLD;
 var init_critic = __esm({
   "packages/orchestrator/dist/critic.js"() {
     "use strict";
-    SHELL_THRESHOLD = 2;
-    FS_THRESHOLD = 3;
   }
 });
 
@@ -558656,8 +558655,8 @@ var init_agenticRunner = __esm({
       // WO-KG-15
       _retrievalContextCache = null;
       // WO-KG-15: cache per-run
-      // Observer world-model and cohort stats
-      _observerMode = "both";
+      // Adversary world-model and cohort stats
+      _adversaryMode = "both";
       _worldFacts = { files: /* @__PURE__ */ new Map(), lastTest: {}, lastLists: /* @__PURE__ */ new Map() };
       // REG-7-root: Track file writes since last todo_write call. When this
       // counter climbs without a todo update, the agent has likely batched
@@ -559006,6 +559005,8 @@ var init_agenticRunner = __esm({
       _sessionId = `session-${Date.now()}`;
       _workingDirectory = "";
       constructor(backend, options2) {
+        const adversaryMode = options2?.adversaryMode ?? options2?.observerMode ?? "both";
+        const disableAdversaryCritic = options2?.disableAdversaryCritic ?? options2?.disableStepCritic ?? false;
         this.backend = backend;
         this.options = {
           maxTurns: options2?.maxTurns ?? 60,
@@ -559030,19 +559031,22 @@ var init_agenticRunner = __esm({
           bruteForceMaxCycles: options2?.bruteForceMaxCycles ?? 100,
           allowTurnExtension: options2?.allowTurnExtension ?? true,
           completionProvenanceGuard: options2?.completionProvenanceGuard ?? true,
+          disableAdversaryCritic,
+          disableStepCritic: disableAdversaryCritic,
           modelTier: options2?.modelTier ?? "large",
           contextWindowSize: options2?.contextWindowSize ?? 0,
           personality: options2?.personality ?? PERSONALITY_PRESETS.balanced,
           personalityName: options2?.personalityName ?? "",
           finalVarResolver: options2?.finalVarResolver ?? void 0,
-          observerMode: options2?.observerMode ?? "both",
+          adversaryMode,
+          observerMode: adversaryMode,
           // Phase 4 — sub-agent isolation flag (defaults false). When true, this
           // runner skips cross-task handoff inheritance from the parent's
           // session.
           subAgent: options2?.subAgent ?? false,
           skipCrossTaskHandoff: options2?.skipCrossTaskHandoff ?? false
         };
-        this._observerMode = this.options.observerMode;
+        this._adversaryMode = this.options.adversaryMode;
       }
       /** Update context window size (e.g. after querying Ollama /api/show) */
       setContextWindowSize(size) {
@@ -559050,7 +559054,10 @@ var init_agenticRunner = __esm({
       }
       /** Set the working directory for session checkpointing */
       setWorkingDirectory(dir) {
-        this._workingDirectory = dir;
+        this._workingDirectory = _pathResolve(dir);
+      }
+      authoritativeWorkingDirectory() {
+        return _pathResolve(this._workingDirectory || process.cwd());
       }
       /** State root for runner-owned memory/artifacts. Defaults to cwd/.omnius. */
       omniusStateDir() {
@@ -559823,7 +559830,7 @@ ${result.output ?? ""}`;
        * checklist via todo_write, and only then call task_complete.
        */
       /**
-       * REG-39c: tag a SYNTHETIC failure (FORCED PROGRESS BLOCK / observer
+       * REG-39c: tag a SYNTHETIC failure (FORCED PROGRESS BLOCK / adversary
        * block / budget exhausted). These paths return early from
        * executeSingle BEFORE the main result-handling code, so the normal
        * MAST tagging miss them. This helper lets each return-early site
@@ -561367,7 +561374,7 @@ ${latest.output || ""}`.trim();
           }
         }
         const sections = [
-          "[KNOWLEDGE — cached tool results already known to the runtime. Do NOT re-call these tools with the same arguments:]"
+          "[KNOWLEDGE — cached tool results already known to the runtime. Repeating an exact read/list/search/shell call is a wasted action and will be blocked or served from cache:]"
         ];
         if (compactedCount > 0) {
           sections.push(`Compacted cached entries still count as already-known results (${compactedCount}); an exact repeat will be served from cache or skipped, not produce new information.`);
@@ -561379,6 +561386,7 @@ ${latest.output || ""}`.trim();
         if (dirsListed.length > 0) {
           const unique2 = [...new Set(dirsListed)].slice(0, 15);
           sections.push(`Directories already listed (${unique2.length}): ${unique2.join(", ")}`);
+          sections.push(`Do not call list_directory again on these exact directories unless you changed their contents. Use the listed child paths directly with file_read/edit/delegation.`);
         }
         if (searches.length > 0) {
           const unique2 = [...new Set(searches)].slice(0, 15);
@@ -561392,6 +561400,23 @@ ${latest.output || ""}`.trim();
           return null;
         return sections.join("\n");
       }
+      _renderRuntimeRootBlock() {
+        const authoritative = this.authoritativeWorkingDirectory();
+        const proc = _pathResolve(process.cwd());
+        const lines = [
+          `[RUNTIME ROOT — authoritative]`,
+          `Current working directory for this run: ${authoritative}`,
+          `All relative file/tool paths resolve under this directory unless the tool call uses an absolute path.`,
+          `Do not infer cwd from old tasks, shell transcripts, memory, or prior browser sessions.`
+        ];
+        if (proc !== authoritative) {
+          lines.push(`Process cwd differs (${proc}); treat the run cwd above as authoritative for repo/project work.`);
+        }
+        if (this._worldFacts.lastCwd && this._worldFacts.lastCwd !== authoritative) {
+          lines.push(`Last shell cd target was command-local only: ${this._worldFacts.lastCwd}. It does not change the run cwd.`);
+        }
+        return lines.join("\n");
+      }
       _insertContextFrame(messages2, frame) {
         if (!frame)
           return;
@@ -561429,7 +561454,7 @@ ${latest.output || ""}`.trim();
         add2(this._activeContextItem("task_state", "todo-state", "turn.todos", "Todo state", input.todoBlock, 80));
         add2(this._activeContextItem("recent_failure", "recent-failures", "turn.failures", "Recent failures", input.failureBlock, 95));
         add2(this._activeContextItem("recent_failure", "write-churn", "turn.churn", "Write churn", input.churnBlock, 75));
-        add2(this._activeContextItem("tool_cache", "tool-cache", "turn.tool-cache", "Tool cache", input.toolCacheBlock, 65));
+        add2(this._activeContextItem("tool_cache", "tool-cache", "turn.tool-cache", "Tool cache", input.toolCacheBlock, 92));
         add2(this._activeContextItem("anchor", "anchors", "turn.anchors", "Relevant anchors", input.anchorsBlock, 50));
         add2(this._activeContextItem("environment", "environment", "turn.environment", "Environment", input.environmentBlock, 35));
         if (this._lastPprMemoryLines.length > 0) {
@@ -561684,7 +561709,10 @@ ${chunk.content}`, {
       async _buildTurnContextFrame(turn, messages2, recentToolResults, environmentBlock) {
         this._contextLedger.clearSources("turn.");
         this._contextLedger.prune(turn);
-        const goalBlock = this._taskState.goal ? `Active task: ${this._taskState.goal}` : null;
+        const goalBlock = [
+          this._renderRuntimeRootBlock(),
+          this._taskState.goal ? `Active task: ${this._taskState.goal}` : null
+        ].filter(Boolean).join("\n\n");
         const filesystemBlock = this._renderFilesystemStateBlock(turn);
         const todoBlock = this._renderTodoStateBlock(turn);
         const failureBlock = this._renderRecentFailuresBlock(turn);
@@ -561750,7 +561778,7 @@ ${this._lastPprMemoryLines.slice(0, 5).join("\n")}` : null;
           signalFromBlock("tool_cache", "turn.tool-cache", toolCacheBlock, {
             id: "tool-cache",
             dedupeKey: "turn.tool-cache",
-            priority: 65,
+            priority: 92,
             createdTurn: turn,
             ttlTurns: 1
           }),
@@ -562602,8 +562630,8 @@ ${notice}`;
         const window2 = recentToolCalls.slice(-repetitionWindow);
         const uniqueKeys = new Set(window2.map((tc) => `${tc.name}:${tc.argsKey}`));
         const ratio = 1 - uniqueKeys.size / window2.length;
-        if (ratio > 0.4 && this._littlemanToolOutcomes.length >= 3) {
-          const recentOutcomes = this._littlemanToolOutcomes.slice(-6);
+        if (ratio > 0.4 && this._adversaryToolOutcomes.length >= 3) {
+          const recentOutcomes = this._adversaryToolOutcomes.slice(-6);
           const uniquePreviews = new Set(recentOutcomes.map((o2) => o2.preview.slice(0, 40)));
           if (uniquePreviews.size >= 3) {
             return Math.max(0, ratio - 0.4);
@@ -562701,6 +562729,9 @@ Respond with your assessment, then take action.`;
         this._lastActiveForgettingReport = null;
         this._lastContextConsolidationTurn = -1e3;
         this._contextFrameBuilder = new ContextFrameBuilder();
+        if (!this._workingDirectory) {
+          this._workingDirectory = _pathResolve(process.cwd());
+        }
         if (!this.options.disablePersistentMemory && !this._memoryInitialized) {
           try {
             const path12 = await import("node:path");
@@ -563134,10 +563165,10 @@ TASK: ${scrubbedTask}` : scrubbedTask;
         this._hookDenyHintCount = 0;
         this._selfConsistencyVotes = 0;
         this._retrievalContextCache = null;
-        this._observerMode = this.options.observerMode ?? "both";
+        this._adversaryMode = this.options.adversaryMode ?? "both";
         this._worldFacts = { files: /* @__PURE__ */ new Map(), lastTest: {}, lastLists: /* @__PURE__ */ new Map() };
         this._argCohorts.clear();
-        this._littlemanRedundantBlocks.clear();
+        this._adversaryRedundantSignals.clear();
         this._lastTodoWriteTurn = -1;
         this._lastTodoReminderTurn = -1;
         let pendingConstraintWarnings = [];
@@ -563237,14 +563268,44 @@ TASK: ${scrubbedTask}` : scrubbedTask;
           });
           if (gate.proceed)
             return false;
-          messages2.push({ role: "system", content: gate.feedback });
+          messages2.push({
+            role: "system",
+            content: `${gate.feedback}
+
+[ADVISORY ONLY] This critique does not block task_complete; use it to improve the next run or visible evidence if the task continues.`
+          });
           this.emit({
             type: "status",
-            content: `task_complete held by completion provenance guard: ${gate.reason}`,
+            content: `completion provenance critique emitted without blocking: ${gate.reason}`,
+            turn,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          this.emit({
+            type: "adversary_reaction",
+            adversary: {
+              class: "guidance",
+              shortText: "Completion provenance critique emitted",
+              confidence: 0.9,
+              details: gate.reason
+            },
+            turn,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          return false;
+        };
+        const emitBackwardPassAdvisory = (feedback, turn) => {
+          messages2.push({
+            role: "system",
+            content: `${feedback}
+
+[ADVISORY ONLY] Backward-pass critique is non-blocking; do not treat this as a tool failure or completion refusal.`
+          });
+          this.emit({
+            type: "status",
+            content: "backward-pass critique emitted without blocking completion",
             turn,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
-          return true;
         };
         const turnCap = this.options.maxTurns && this.options.maxTurns > 0 ? this.options.maxTurns : Number.MAX_SAFE_INTEGER;
         for (let turn = 0; turn < turnCap; turn++) {
@@ -564230,8 +564291,8 @@ ${_staleSamples.join("\n")}` : ``,
             nextSelfEval = now + selfEvalInterval;
           }
           const turnsRemaining = this.options.maxTurns - turn;
-          if (this.options.allowTurnExtension && turnsRemaining <= 3 && turnsRemaining > 0 && this._littlemanToolOutcomes.length >= 2) {
-            const recentOutcomes = this._littlemanToolOutcomes.slice(-6);
+          if (this.options.allowTurnExtension && turnsRemaining <= 3 && turnsRemaining > 0 && this._adversaryToolOutcomes.length >= 2) {
+            const recentOutcomes = this._adversaryToolOutcomes.slice(-6);
             const recentSuccesses = recentOutcomes.filter((o2) => o2.succeeded).length;
             const uniqueResults = new Set(recentOutcomes.map((o2) => o2.preview.slice(0, 40))).size;
             const isActive = recentSuccesses >= 2 && uniqueResults >= 2;
@@ -564240,16 +564301,16 @@ ${_staleSamples.join("\n")}` : ``,
               this.options.maxTurns += extension3;
               this.emit({
                 type: "status",
-                content: `Littleman triage: activity detected (${recentSuccesses} recent successes, ${uniqueResults} unique results) — extending turn limit by ${extension3} (now ${this.options.maxTurns})`,
+                content: `Adversary triage: activity detected (${recentSuccesses} recent successes, ${uniqueResults} unique results) — extending turn limit by ${extension3} (now ${this.options.maxTurns})`,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
               const detailsLines = recentOutcomes.map((o2) => `- ${o2.tool}: ${o2.succeeded ? "OK" : "ERR"} — ${o2.preview}`);
               this.emit({
-                type: "debug_littleman",
+                type: "debug_adversary",
                 turn,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString(),
                 content: `Timeout triage: EXTENDED by ${extension3} turns (active session detected)`,
-                littlemanAction: {
+                adversaryAction: {
                   detection: "none",
                   recentSuccesses,
                   recentFailures: recentOutcomes.length - recentSuccesses,
@@ -564582,6 +564643,9 @@ ${memoryLines.join("\n")}`
             maxTokens: effectiveMaxTokens,
             timeoutMs: this.options.requestTimeoutMs
           };
+          if ((this.options.contextWindowSize ?? 0) > 0) {
+            chatRequest.numCtx = this.options.contextWindowSize;
+          }
           if (this.options.memoryPrefix)
             chatRequest.memoryPrefix = this.options.memoryPrefix;
           if (this.options.memoryPrefixHash)
@@ -564623,7 +564687,7 @@ ${memoryLines.join("\n")}`
                 compactionThreshold: limits.compactionThreshold,
                 toolCallCount,
                 keepRecent: limits.keepRecent,
-                littlemanOutcomes: this._littlemanToolOutcomes.length,
+                adversaryOutcomes: this._adversaryToolOutcomes.length,
                 headroom: limits.compactionThreshold - estTokens
               }
             });
@@ -564986,16 +565050,19 @@ ${memoryLines.join("\n")}`
               const cohort = this._argCohorts.get(cohortKey);
               if (cohort && cohort.failure >= 3 && cohort.success === 0) {
                 this.emit({
-                  type: "observer_reaction",
+                  type: "adversary_reaction",
                   timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-                  observer: {
+                  adversary: {
                     class: "arg_cohort_risk",
                     shortText: `${tc.name} with similar args has failed ${cohort.failure}× recently`,
                     confidence: 0.85
                   }
                 });
-                if (this._observerMode === "skillcoach" || this._observerMode === "both") {
-                  this.pendingUserMessages.push(`⚠ ${tc.name} with similar arguments has failed ${cohort.failure}× recently. Try a different approach first: read relevant files, adjust arguments, or verify prerequisites.`);
+                if (this._adversaryMode === "skillcoach" || this._adversaryMode === "both") {
+                  this.pendingUserMessages.push(`[ADVERSARY CRITIQUE — non-blocking]
+Evidence: ${tc.name} with similar arguments has failed ${cohort.failure}× recently.
+Root cause hypothesis: the argument family may be wrong, a prerequisite may be missing, or the tool is being used before enough state is known.
+Corrective action: try a different approach first: read relevant files, adjust arguments, or verify prerequisites.`);
                 }
               }
               if (this._errorPatterns.size > 0) {
@@ -565277,19 +565344,11 @@ ${memoryLines.join("\n")}`
               ].includes(tc.name);
               const isStatefulBrowserTool = this._isStatefulBrowserTool(tc.name);
               const isReadLike = !isStatefulBrowserTool && (baseIsReadLike || tc.name === "shell" && this._isShellCommandReadOnly(tc.arguments?.["command"] ?? tc.arguments?.["cmd"] ?? ""));
-              const observerRedundantBlock = this._littlemanRedundantBlocks.has(toolFingerprint);
-              if (observerRedundantBlock) {
-                this._littlemanRedundantBlocks.delete(toolFingerprint);
+              const adversaryRedundantSignal = this._adversaryRedundantSignals.has(toolFingerprint);
+              if (adversaryRedundantSignal) {
+                this._adversaryRedundantSignals.delete(toolFingerprint);
               }
-              const markSyntheticToolLog = (outputPreview) => {
-                const lastLog = toolCallLog[_toolLogTailIdx];
-                if (!lastLog)
-                  return;
-                lastLog.success = true;
-                lastLog.mutated = false;
-                lastLog.mutatedFiles = [];
-                lastLog.outputPreview = outputPreview.slice(0, 100);
-              };
+              let criticGuidance = null;
               {
                 const _reflStem = buildStem(tc.name, tc.arguments ?? {});
                 if (!this._reflectionsInjectedThisTurn.has(_reflStem)) {
@@ -565331,7 +565390,10 @@ ${memoryLines.join("\n")}`
                   }
                 }
               }
-              const criticDecision = evaluate2({
+              const criticDecision = this.options.disableAdversaryCritic === true ? {
+                decision: "pass",
+                reason: "adversary critic disabled for isolated evaluation"
+              } : evaluate2({
                 proposedCall: { tool: tc.name, args: tc.arguments ?? {} },
                 fingerprint: toolFingerprint,
                 isReadLike,
@@ -565345,116 +565407,33 @@ ${memoryLines.join("\n")}`
                 stagnationSignals: null,
                 // stagnation gate handled at top-of-turn
                 stagnationGateActive: false,
-                observerRedundantBlock
+                adversaryRedundantSignal
               });
-              if (criticDecision.decision === "observer_block") {
-                this.emit({
-                  type: "tool_call",
-                  toolName: tc.name,
-                  toolArgs: tc.arguments,
-                  turn,
-                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                });
-                const blockMsg = criticDecision.cachedResult ? `[BLOCKED — this tool+args already succeeded. Re-served from cache:]
-
-${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confirmed this tool already succeeded with these arguments on a prior turn. Do NOT re-run. Use your prior findings to proceed.]`;
-                markSyntheticToolLog(blockMsg);
-                this.emit({
-                  type: "tool_result",
-                  toolName: tc.name,
-                  success: true,
-                  content: blockMsg.slice(0, 100),
-                  turn,
-                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                });
-                this._tagSyntheticFailure({
-                  mode: "step_repetition",
-                  rationale: `observer-block on ${tc.name} fingerprint flagged redundant`
-                });
-                return { tc, output: blockMsg, success: true };
-              }
-              if (criticDecision.decision === "force_progress_block") {
+              if (criticDecision.decision === "guidance") {
                 dedupHitCount.set(toolFingerprint, criticDecision.hitNumber);
                 const _existingFp = recentToolResults.get(toolFingerprint);
                 if (_existingFp !== void 0) {
                   recentToolResults.delete(toolFingerprint);
                   recentToolResults.set(toolFingerprint, _existingFp);
                 }
+                criticGuidance = criticDecision.guidanceMessage;
                 this.emit({
-                  type: "tool_call",
-                  toolName: tc.name,
-                  toolArgs: tc.arguments,
-                  turn,
+                  type: "adversary_reaction",
+                  adversary: {
+                    class: "guidance",
+                    shortText: `Adversary guidance for repeated ${tc.name} call`,
+                    confidence: 0.9,
+                    details: criticDecision.reason
+                  },
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
                 this.emit({
-                  type: "tool_result",
-                  toolName: tc.name,
-                  success: true,
-                  content: `[SKIPPED DUPLICATE — exact ${tc.name} call not re-run; cached result returned.]`.slice(0, 120),
-                  turn,
-                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                });
-                this._tagSyntheticFailure({
-                  mode: "step_repetition",
-                  rationale: `force_progress_block on ${tc.name} after ${criticDecision.hitNumber} identical calls`
-                });
-                const generationCompletionHint = isGenerationArtifactSuccess(tc.name, criticDecision.cachedResult) ? `
-
-[GENERATION ALREADY COMPLETE] This exact ${tc.name} call already succeeded. Do not call it again. Use the cached artifact/path above; if delivery is needed, send it, otherwise call task_complete.` : "";
-                const header = criticDecision.compacted ? `[RE-SERVED FROM CACHE — the original result was compacted from context. Here is the data again. Do not retry this exact call.]
-
-` : `[SKIPPED DUPLICATE — exact ${tc.name} call not re-run. The cached result below is from the prior successful call. Do not retry this exact call.]
-
-`;
-                const truncatedCache = criticDecision.cachedResult.length > 500 ? criticDecision.cachedResult.slice(0, 500) + `
-... [${criticDecision.cachedResult.length - 500} chars omitted — same as before]` : criticDecision.cachedResult;
-                markSyntheticToolLog(`${criticDecision.blockMessage}
-
-${truncatedCache}`);
-                return {
-                  tc,
-                  output: `${criticDecision.blockMessage}
-
-${header}${truncatedCache}${generationCompletionHint}`,
-                  success: true
-                };
-              }
-              if (criticDecision.decision === "serve_cached") {
-                dedupHitCount.set(toolFingerprint, criticDecision.hitNumber);
-                const _existingFp = recentToolResults.get(toolFingerprint);
-                if (_existingFp !== void 0) {
-                  recentToolResults.delete(toolFingerprint);
-                  recentToolResults.set(toolFingerprint, _existingFp);
-                }
-                this.emit({
-                  type: "tool_call",
-                  toolName: tc.name,
-                  toolArgs: tc.arguments,
-                  turn,
-                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                });
-                const generationCompletionHint = isGenerationArtifactSuccess(tc.name, criticDecision.cachedResult) ? `
-
-[GENERATION ALREADY COMPLETE] This exact ${tc.name} call already succeeded. Do not call it again. Use the cached artifact/path above; if delivery is needed, send it, otherwise call task_complete.` : "";
-                const header = criticDecision.compacted ? `[RE-SERVED FROM CACHE — the original result was compacted from context. Here is the data again. No need to call this tool again.]
-
-` : `[DUPLICATE CALL #${criticDecision.hitNumber} — you already called ${tc.name} with these exact arguments. The result is identical. Do NOT call this again. Use the data you already have to make progress. One more identical call will trigger a hard progress block.]
-
-`;
-                const truncatedCache = criticDecision.cachedResult.length > 500 ? criticDecision.cachedResult.slice(0, 500) + `
-... [${criticDecision.cachedResult.length - 500} chars omitted — same as before]` : criticDecision.cachedResult;
-                const dedupOutput = header + truncatedCache + generationCompletionHint;
-                markSyntheticToolLog(dedupOutput);
-                this.emit({
-                  type: "tool_result",
+                  type: "status",
                   toolName: tc.name,
-                  success: true,
-                  content: header.slice(0, 100),
+                  content: `Adversary guidance emitted for ${tc.name}; tool call will still execute`,
                   turn,
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
-                return { tc, output: dedupOutput, success: true };
               }
               this.emit({
                 type: "tool_call",
@@ -566455,6 +566434,11 @@ Respond with EXACTLY this structure before your next tool call:
                 result = await this.offloadEmbeddedImageResult(result, tc.name, turn);
               }
               let output = this.normalizeToolOutput(result, tc.name, tc.arguments, turn);
+              if (criticGuidance) {
+                output += `
+
+${criticGuidance}`;
+              }
               if (!result.success && (this.options.modelTier === "small" || this.options.modelTier === "medium")) {
                 const recovery = this.buildRecoveryGuidance(tc.name, result.error ?? "", tc.arguments);
                 if (recovery)
@@ -566865,22 +566849,21 @@ ${sr.result.output}`;
                       }
                       const _bp1 = await this._runBackwardPassReview(turn);
                       if (_bp1 && !_bp1.proceed && _bp1.feedback) {
-                        messages2.push({ role: "system", content: _bp1.feedback });
-                      } else {
-                        completed = true;
-                        summary = extractTaskCompleteSummary(matchTc.arguments);
-                        if (summary && !this._assistantTextEmitted) {
-                          this.emit({
-                            type: "assistant_text",
-                            content: summary,
-                            source: "task_complete_summary",
-                            turn,
-                            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                          });
-                          this._assistantTextEmitted = true;
-                        }
-                        break;
+                        emitBackwardPassAdvisory(_bp1.feedback, turn);
+                      }
+                      completed = true;
+                      summary = extractTaskCompleteSummary(matchTc.arguments);
+                      if (summary && !this._assistantTextEmitted) {
+                        this.emit({
+                          type: "assistant_text",
+                          content: summary,
+                          source: "task_complete_summary",
+                          turn,
+                          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                        });
+                        this._assistantTextEmitted = true;
                       }
+                      break;
                     }
                   }
                 }
@@ -566921,22 +566904,21 @@ ${sr.result.output}`;
                         }
                         const _bp2 = await this._runBackwardPassReview(turn);
                         if (_bp2 && !_bp2.proceed && _bp2.feedback) {
-                          messages2.push({ role: "system", content: _bp2.feedback });
-                        } else {
-                          completed = true;
-                          summary = extractTaskCompleteSummary(r2.tc.arguments);
-                          if (summary && !this._assistantTextEmitted) {
-                            this.emit({
-                              type: "assistant_text",
-                              content: summary,
-                              source: "task_complete_summary",
-                              turn,
-                              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                            });
-                            this._assistantTextEmitted = true;
-                          }
-                          break;
+                          emitBackwardPassAdvisory(_bp2.feedback, turn);
                         }
+                        completed = true;
+                        summary = extractTaskCompleteSummary(r2.tc.arguments);
+                        if (summary && !this._assistantTextEmitted) {
+                          this.emit({
+                            type: "assistant_text",
+                            content: summary,
+                            source: "task_complete_summary",
+                            turn,
+                            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                          });
+                          this._assistantTextEmitted = true;
+                        }
+                        break;
                       }
                     }
                   }
@@ -567013,22 +566995,21 @@ ${sr.result.output}`;
                         }
                         const _bp3 = await this._runBackwardPassReview(turn);
                         if (_bp3 && !_bp3.proceed && _bp3.feedback) {
-                          messages2.push({ role: "system", content: _bp3.feedback });
-                        } else {
-                          completed = true;
-                          summary = extractTaskCompleteSummary(r2.tc.arguments);
-                          if (summary && !this._assistantTextEmitted) {
-                            this.emit({
-                              type: "assistant_text",
-                              content: summary,
-                              source: "task_complete_summary",
-                              turn,
-                              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                            });
-                            this._assistantTextEmitted = true;
-                          }
-                          break;
+                          emitBackwardPassAdvisory(_bp3.feedback, turn);
                         }
+                        completed = true;
+                        summary = extractTaskCompleteSummary(r2.tc.arguments);
+                        if (summary && !this._assistantTextEmitted) {
+                          this.emit({
+                            type: "assistant_text",
+                            content: summary,
+                            source: "task_complete_summary",
+                            turn,
+                            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                          });
+                          this._assistantTextEmitted = true;
+                        }
+                        break;
                       }
                     }
                   }
@@ -567039,7 +567020,7 @@ ${sr.result.output}`;
             }
             if (completed)
               break;
-            this.littlemanObserve(messages2, turn);
+            this.adversaryObserve(messages2, turn);
             const currentRepScore = this.detectRepetition(toolCallLog);
             if (currentRepScore > 0.4 && toolCallLog.length >= 4) {
               const { repetitionWindow } = this.contextLimits();
@@ -567236,7 +567217,7 @@ Call task_complete(summary="...") NOW with whatever you have.`
             }
             if (isThinkOnly) {
               if (consecutiveThinkOnly >= MAX_CONSECUTIVE_THINK_ONLY) {
-                const recentSuccesses = this._littlemanToolOutcomes.slice(-3).filter((o2) => o2.succeeded);
+                const recentSuccesses = this._adversaryToolOutcomes.slice(-3).filter((o2) => o2.succeeded);
                 const hasRecentSuccess = recentSuccesses.length > 0;
                 const successHint = hasRecentSuccess ? `
 
@@ -567487,7 +567468,8 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
               tools: toolDefs,
               temperature: this.options.temperature,
               maxTokens: this.options.maxTokens,
-              timeoutMs: this.options.requestTimeoutMs
+              timeoutMs: this.options.requestTimeoutMs,
+              numCtx: this.options.contextWindowSize || void 0
             };
             let response;
             try {
@@ -567797,8 +567779,7 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                     }
                     const _bp4 = await this._runBackwardPassReview(turn);
                     if (_bp4 && !_bp4.proceed && _bp4.feedback) {
-                      messages2.push({ role: "system", content: _bp4.feedback });
-                      continue;
+                      emitBackwardPassAdvisory(_bp4.feedback, turn);
                     }
                     completed = true;
                     summary = extractTaskCompleteSummary(tc.arguments);
@@ -567871,7 +567852,7 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
               }
               if (isThinkOnlyBF) {
                 if (consecutiveThinkOnly >= MAX_CONSECUTIVE_THINK_ONLY) {
-                  const recentSucc = this._littlemanToolOutcomes.slice(-3).filter((o2) => o2.succeeded);
+                  const recentSucc = this._adversaryToolOutcomes.slice(-3).filter((o2) => o2.succeeded);
                   const succHint = recentSucc.length > 0 ? "\n\nYour most recent tool calls SUCCEEDED. If the task is complete, call task_complete now with a summary." : "";
                   messages2.push({
                     role: "user",
@@ -569959,36 +569940,35 @@ ${newerSummary}`;
 ${trimmedNew}`;
       }
       // -------------------------------------------------------------------------
-      // Littleman Observer — parallel meta-analysis of the main loop
+      // Adversary — parallel meta-analysis of the main loop
       // -------------------------------------------------------------------------
-      // Inspired by Hannover's fireCompanionObserver (src/buddy/observer.ts).
       // Runs after each tool turn to detect when the model has lost track of
       // what happened and inject corrections before the next inference.
       //
       // This is the architectural fix for the "I see both tools have been failing"
       // regression: instead of only fixing the data the model sees (mask/summary),
       // we add a second analysis path that catches mismatches in real-time.
-      /** Track recent tool outcomes for the littleman observer */
-      _littlemanToolOutcomes = [];
-      /** WO-FIX-C: Tool fingerprints the littleman has flagged as redundant.
-       *  Checked in executeSingle to block re-execution and return cached data. */
-      _littlemanRedundantBlocks = /* @__PURE__ */ new Set();
+      /** Track recent tool outcomes for the adversary */
+      _adversaryToolOutcomes = [];
+      /** WO-FIX-C: Tool fingerprints the adversary has flagged as redundant.
+       *  Checked in executeSingle to attach advisory guidance before dispatch. */
+      _adversaryRedundantSignals = /* @__PURE__ */ new Set();
       /** Reflexion pattern: task-local failure-indexed reflection buffer.
        *  Generates typed self-reflections on task failure and injects them
        *  into the next attempt's context for active learning. */
       _reflectionBuffer = null;
       /**
-       * Littleman observer: post-turn meta-analysis.
+       * Adversary: post-turn meta-analysis.
        *
        * Examines the last few messages looking for contradictions between
        * actual tool outcomes and the model's stated understanding. When it
        * detects the model claiming failure after success (or vice versa),
-       * it injects a corrective message.
+       * it injects a corrective non-blocking critique.
        *
        * Also detects repeated actions — when the model re-does something
-       * that already succeeded, the littleman nudges it to move on.
+       * that already succeeded, the adversary nudges it to move on.
        */
-      littlemanObserve(messages2, turn) {
+      adversaryObserve(messages2, turn) {
         if (this.options.modelTier === "large")
           return;
         const recent = messages2.slice(-6);
@@ -570017,8 +569997,8 @@ ${trimmedNew}`;
             }
             const argsKey = toolArgs ? this._buildExactArgsKey(toolArgs) : void 0;
             const fingerprint = toolArgs ? this._buildToolFingerprint(toolName, toolArgs) : void 0;
-            if (!this._littlemanToolOutcomes.some((o2) => o2.turn === turn && o2.tool === toolName && o2.fingerprint === fingerprint)) {
-              this._littlemanToolOutcomes.push({
+            if (!this._adversaryToolOutcomes.some((o2) => o2.turn === turn && o2.tool === toolName && o2.fingerprint === fingerprint)) {
+              this._adversaryToolOutcomes.push({
                 turn,
                 tool: toolName,
                 argsKey,
@@ -570029,27 +570009,47 @@ ${trimmedNew}`;
             }
           }
         }
-        while (this._littlemanToolOutcomes.length > 20)
-          this._littlemanToolOutcomes.shift();
+        while (this._adversaryToolOutcomes.length > 20)
+          this._adversaryToolOutcomes.shift();
         const emitReaction = (cls, shortText, confidence2, details2) => {
           this.emit({
-            type: "observer_reaction",
+            type: "adversary_reaction",
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            observer: { class: cls, shortText, confidence: confidence2, details: details2 }
+            adversary: { class: cls, shortText, confidence: confidence2, details: details2 }
           });
         };
+        const buildAdversaryCritique = (input) => {
+          const alternatives = input.alternatives && input.alternatives.length > 0 ? `
+Alternatives:
+${input.alternatives.map((item) => `- ${item}`).join("\n")}` : "";
+          return [
+            `[ADVERSARY CRITIQUE — non-blocking]`,
+            `Evidence: ${input.evidence}`,
+            `Root cause hypothesis: ${input.hypothesis}`,
+            `Corrective action: ${input.correctiveAction}${alternatives}`
+          ].join("\n");
+        };
         const lastAssistant = [...recent].reverse().find((m2) => m2.role === "assistant" && typeof m2.content === "string");
         if (lastAssistant && typeof lastAssistant.content === "string") {
           const text = lastAssistant.content.toLowerCase();
           const claimsFailure = /(?:fail|error|didn't work|not working|unable to|cannot|couldn't|both .* fail|tools? (?:have |has )?been fail)/i.test(text);
           if (claimsFailure) {
-            const recentOutcomes = this._littlemanToolOutcomes.slice(-4);
+            const recentOutcomes = this._adversaryToolOutcomes.slice(-4);
             const successes = recentOutcomes.filter((o2) => o2.succeeded);
             if (successes.length >= 1) {
               const successList = successes.map((o2) => `${o2.tool}: ${o2.preview.slice(0, 60)}`).join("; ");
               emitReaction("false_failure", `Claimed failure, but recent tools succeeded (${successes.length})`, 0.9, successList);
-              if (this._observerMode === "skillcoach" || this._observerMode === "both") {
-                this.pendingUserMessages.push(`⚠ Correction: recent tools DID succeed. Do not retry them. Successful results: ${successList}. Use them to advance the task.`);
+              if (this._adversaryMode === "skillcoach" || this._adversaryMode === "both") {
+                this.pendingUserMessages.push(buildAdversaryCritique({
+                  evidence: `Recent tools succeeded: ${successList}.`,
+                  hypothesis: "The main loop is interpreting uncertainty or partial progress as failure and may be about to discard usable evidence.",
+                  correctiveAction: "Use the successful results to advance the task, then verify the next concrete step.",
+                  alternatives: [
+                    "Edit or run the next verification step that follows from the successful output.",
+                    "Read a different targeted file if the successful result exposed a new path or symbol.",
+                    "Complete only if the successful output is sufficient evidence for the user's request."
+                  ]
+                }));
               }
               this.emit({
                 type: "status",
@@ -570063,47 +570063,67 @@ ${trimmedNew}`;
           const text = lastAssistant.content.toLowerCase();
           const claimsSuccess = /(done|fixed|success|passed|complete)/i.test(text);
           if (claimsSuccess) {
-            const recentOutcomes = this._littlemanToolOutcomes.slice(-4);
+            const recentOutcomes = this._adversaryToolOutcomes.slice(-4);
             const failures = recentOutcomes.filter((o2) => !o2.succeeded);
             const successes = recentOutcomes.filter((o2) => o2.succeeded);
             if (failures.length > 0 && successes.length === 0) {
               const failList = failures.map((o2) => `${o2.tool}: ${o2.preview.slice(0, 60)}`).join("; ");
               emitReaction("false_success", `Claimed success, but recent tools failed (${failures.length})`, 0.9, failList);
-              if (this._observerMode === "skillcoach" || this._observerMode === "both") {
-                this.pendingUserMessages.push(`⚠ Your recent tools show errors (${failures.length}). Verify the last tool output and correct the issue before claiming success.`);
+              if (this._adversaryMode === "skillcoach" || this._adversaryMode === "both") {
+                this.pendingUserMessages.push(buildAdversaryCritique({
+                  evidence: `Recent tools show errors (${failures.length}): ${failList}.`,
+                  hypothesis: "The main loop is prematurely compressing intent into success language before the verifier produced evidence.",
+                  correctiveAction: "Inspect the failed output, identify the implicated path/symbol/command, and run one focused corrective step before claiming success.",
+                  alternatives: [
+                    "Read the smallest relevant source region around the failed symbol.",
+                    "Patch the implicated code or configuration.",
+                    "Run the same verifier only after a state-changing fix."
+                  ]
+                }));
               }
             }
           }
         }
-        const lastToolCalls = recent.filter((m2) => m2.role === "assistant" && m2.tool_calls?.length).flatMap((m2) => m2.tool_calls ?? []);
-        for (const tc of lastToolCalls) {
-          const name10 = tc.function.name;
-          if (this._isStatefulBrowserTool(name10))
-            continue;
-          let args = {};
-          try {
-            args = JSON.parse(tc.function.arguments);
-          } catch {
-          }
-          const argsKey = this._buildExactArgsKey(args);
-          const fingerprint = this._buildToolFingerprint(name10, args);
-          const prior = this._littlemanToolOutcomes.find((o2) => o2.succeeded && o2.tool === name10 && o2.fingerprint === fingerprint && o2.turn < turn);
-          if (prior) {
-            this._littlemanRedundantBlocks.add(fingerprint);
-            emitReaction("redundant_action", `Already ran ${name10} successfully on turn ${prior.turn}`, 0.8, prior.preview);
-            if (this._observerMode === "skillcoach" || this._observerMode === "both") {
-              this.pendingUserMessages.push(`⚠ You already ran ${name10} successfully on turn ${prior.turn} with exact arguments (${argsKey.slice(0, 120)}). Do NOT re-run it. Use the existing result and proceed.`);
+        if (this.options.disableAdversaryCritic !== true) {
+          const lastToolCalls = recent.filter((m2) => m2.role === "assistant" && m2.tool_calls?.length).flatMap((m2) => m2.tool_calls ?? []);
+          for (const tc of lastToolCalls) {
+            const name10 = tc.function.name;
+            if (this._isStatefulBrowserTool(name10))
+              continue;
+            let args = {};
+            try {
+              args = JSON.parse(tc.function.arguments);
+            } catch {
+            }
+            const argsKey = this._buildExactArgsKey(args);
+            const fingerprint = this._buildToolFingerprint(name10, args);
+            const prior = this._adversaryToolOutcomes.find((o2) => o2.succeeded && o2.tool === name10 && o2.fingerprint === fingerprint && o2.turn < turn);
+            if (prior) {
+              this._adversaryRedundantSignals.add(fingerprint);
+              emitReaction("redundant_action", `Already ran ${name10} successfully on turn ${prior.turn}`, 0.8, prior.preview);
+              if (this._adversaryMode === "skillcoach" || this._adversaryMode === "both") {
+                this.pendingUserMessages.push(buildAdversaryCritique({
+                  evidence: `${name10} already succeeded on turn ${prior.turn} with exact arguments (${argsKey.slice(0, 120)}). Prior preview: ${prior.preview}`,
+                  hypothesis: "The main loop may have lost track of previously observed evidence because of context pressure, path confusion, or repeated discovery.",
+                  correctiveAction: "Let this duplicate run execute if needed, but treat the prior result as evidence and pivot afterward unless state has changed.",
+                  alternatives: [
+                    "Use the prior result to edit/write, verify, or finish with evidence.",
+                    "Read a different specific file or selector if the current evidence is insufficient.",
+                    "Repeat exact arguments only when filesystem, browser, or page state changed."
+                  ]
+                }));
+              }
+              this.emit({
+                type: "status",
+                content: `\x1B[38;5;178m⚠ Adversary noted redundant ${name10} call (succeeded on turn ${prior.turn}); action remains allowed\x1B[0m`,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+              break;
             }
-            this.emit({
-              type: "status",
-              content: `\x1B[38;5;178m⚠ Prevented redundant ${name10} call (succeeded on turn ${prior.turn})\x1B[0m`,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            });
-            break;
           }
         }
         {
-          const recentCalls = this._littlemanToolOutcomes.slice(-5);
+          const recentCalls = this._adversaryToolOutcomes.slice(-5);
           if (recentCalls.length >= 3) {
             let consecutiveShortResults = 0;
             for (let i2 = recentCalls.length - 1; i2 >= 0; i2--) {
@@ -570116,30 +570136,39 @@ ${trimmedNew}`;
             }
             if (consecutiveShortResults >= 3) {
               emitReaction("idle_think", `Consecutive output without input: ${consecutiveShortResults}`, 0.7);
-              if (this._observerMode === "skillcoach" || this._observerMode === "both") {
-                this.pendingUserMessages.push(`⚠ You have sent ${consecutiveShortResults} consecutive outputs without reading any input. Alternate: receive input, then respond. Call your input tool now.`);
+              if (this._adversaryMode === "skillcoach" || this._adversaryMode === "both") {
+                this.pendingUserMessages.push(buildAdversaryCritique({
+                  evidence: `${consecutiveShortResults} consecutive output-like calls occurred without an input-like observation.`,
+                  hypothesis: "The loop may be acting from stale state instead of re-observing the environment.",
+                  correctiveAction: "Take one input/observation step before another output step.",
+                  alternatives: [
+                    "Call the input/listen/poll tool for the current environment.",
+                    "Read the current UI/page state before clicking or typing again.",
+                    "If the task is already complete, finish with the concrete evidence already observed."
+                  ]
+                }));
               }
               this.emit({
                 type: "status",
-                content: `\x1B[38;5;178m⚠ Blocked runaway output (${consecutiveShortResults} consecutive sends without receive)\x1B[0m`,
+                content: `\x1B[38;5;178m⚠ Adversary flagged runaway-output risk (${consecutiveShortResults} consecutive sends without receive); action remains allowed\x1B[0m`,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
             }
           }
         }
-        const succCount = this._littlemanToolOutcomes.filter((o2) => o2.succeeded).length;
-        const failCount = this._littlemanToolOutcomes.filter((o2) => !o2.succeeded).length;
-        const lastFour = this._littlemanToolOutcomes.slice(-4);
+        const succCount = this._adversaryToolOutcomes.filter((o2) => o2.succeeded).length;
+        const failCount = this._adversaryToolOutcomes.filter((o2) => !o2.succeeded).length;
+        const lastFour = this._adversaryToolOutcomes.slice(-4);
         const details = [
           `Recent tool outcomes:`,
           ...lastFour.map((o2) => `- ${o2.tool}: ${o2.succeeded ? "OK" : "ERR"} — ${o2.preview}`)
         ].join("\n");
         this.emit({
-          type: "debug_littleman",
+          type: "debug_adversary",
           turn,
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          content: `Littleman: ${this._littlemanToolOutcomes.length} tracked outcomes (${succCount} ok, ${failCount} err)`,
-          littlemanAction: {
+          content: `Adversary: ${this._adversaryToolOutcomes.length} tracked outcomes (${succCount} ok, ${failCount} err)`,
+          adversaryAction: {
             detection: "none",
             recentSuccesses: succCount,
             recentFailures: failCount,
@@ -651081,7 +651110,7 @@ ${conversationStream}`
           // off default rather than the global config's value.
           thinking: false,
           // Telegram sub-agent runs must be bounded. Brute-force re-engagement and
-          // the Littleman near-cap turn extension are appropriate for the full TUI
+          // the Adversary near-cap turn extension are appropriate for the full TUI
           // session but cause Telegram to silently outgrow its nominal maxTurns,
           // which is how the Snow Crash PDF loop reached 60+ turns of self-talk.
           ...TELEGRAM_SUB_AGENT_BOUNDED_OPTIONS
@@ -683444,8 +683473,8 @@ ${entry.fullContent}`
   let streamTextBuffer = "";
   let lastAssistantText = "";
   let lastProvenancePath = null;
-  let showLittleman = false;
-  const littlemanBuffer = [];
+  let showAdversary = false;
+  const adversaryBuffer = [];
   const contentWrite = (fn) => {
     if (isNeovimActive()) {
       const origWrite = process.stdout.write;
@@ -683929,24 +683958,24 @@ ${entry.fullContent}`
           if (snap) {
             contentWrite(
               () => renderInfo(
-                `\x1B[38;5;243m[ctx] ${snap.messageCount} msgs | ~${snap.estimatedTokens} tok | headroom: ${snap.headroom} | tools: ${snap.toolCallCount} | littleman: ${snap.littlemanOutcomes} tracked\x1B[0m`
+                `\x1B[38;5;243m[ctx] ${snap.messageCount} msgs | ~${snap.estimatedTokens} tok | headroom: ${snap.headroom} | tools: ${snap.toolCallCount} | adversary: ${snap.adversaryOutcomes} tracked\x1B[0m`
               )
             );
           }
         }
         break;
-      case "debug_littleman":
-        if (event.littlemanAction) {
-          const lm = event.littlemanAction;
+      case "debug_adversary":
+        if (event.adversaryAction) {
+          const lm = event.adversaryAction;
           if (lm.intervention) {
             const simple = `⚠ ${lm.intervention}`;
             contentWrite(() => renderInfo(simple));
           }
           if (lm.details) {
-            littlemanBuffer.push(lm.details);
-            if (littlemanBuffer.length > 50)
-              littlemanBuffer.splice(0, littlemanBuffer.length - 50);
-            if (showLittleman) {
+            adversaryBuffer.push(lm.details);
+            if (adversaryBuffer.length > 50)
+              adversaryBuffer.splice(0, adversaryBuffer.length - 50);
+            if (showAdversary) {
               const det = String(lm.details);
               contentWrite(() => {
                 process.stdout.write(c3.dim(det) + "\n");
@@ -685688,8 +685717,8 @@ This is an independent background session started from /background.`
   origTtyWriteRef = null;
   statusBar.setNeovimFocusChecker(() => isNeovimFocused());
   let _escapeHandler = null;
-  let showLittleman = false;
-  const littlemanBuffer = [];
+  let showAdversary = false;
+  const adversaryBuffer = [];
   statusBar.hookDirectInput(
     rl,
     () => {
@@ -685722,26 +685751,26 @@ This is an independent background session started from /background.`
       }
     },
     () => {
-      showLittleman = !showLittleman;
+      showAdversary = !showAdversary;
       if (statusBar.isActive) {
         try {
           statusBar.jumpToLive();
         } catch {
         }
         statusBar.beginContentWrite();
-        if (showLittleman) {
-          renderInfo("Littleman details: shown");
-          const dump = littlemanBuffer.slice(-10).join("\n");
+        if (showAdversary) {
+          renderInfo("Adversary details: shown");
+          const dump = adversaryBuffer.slice(-10).join("\n");
           if (dump.trim()) {
             process.stdout.write(`
-  ${c3.dim("[littleman recap]")}
+  ${c3.dim("[adversary recap]")}
 `);
             for (const line of dump.split("\n")) {
               process.stdout.write("  " + c3.dim(line) + "\n");
             }
           }
         } else {
-          renderInfo("Littleman details: hidden");
+          renderInfo("Adversary details: hidden");
         }
         statusBar.endContentWrite();
       }

package/npm-shrinkwrap.json

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

package/package.json

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