omnius 1.0.212 → 1.0.214

package/dist/index.js

@@ -4896,6 +4896,29 @@ var init_shell = __esm({
       hasSudoPassword() {
         return this._sudoPassword !== null;
       }
+      isConcurrencySafe(args) {
+        return this.isReadOnly(args);
+      }
+      isReadOnly(args) {
+        const command = String(args["command"] ?? "").trim();
+        if (!command || args["stdin"] !== void 0)
+          return false;
+        const normalized = command.replace(/\s+/g, " ");
+        if (/\bcd\b/.test(normalized))
+          return false;
+        if (/[<>]|\|\s*(?:tee|xargs)\b|\btee\b/.test(normalized))
+          return false;
+        if (/\b(?:sudo|su|rm|mv|cp|touch|mkdir|rmdir|chmod|chown|ln|truncate|dd|patch|apply_patch)\b/.test(normalized)) {
+          return false;
+        }
+        if (/\bgit\s+(?:add|commit|checkout|switch|reset|clean|push|pull|merge|rebase|apply|am|stash|tag)\b/.test(normalized)) {
+          return false;
+        }
+        if (/\b(?:npm|pnpm|yarn|bun)\s+(?:install|i|ci|add|remove|run|test|build)\b/.test(normalized)) {
+          return false;
+        }
+        return /^(?:pwd|ls\b|find\b|rg\b|grep\b|cat\b|head\b|tail\b|wc\b|sed\s+-n\b|awk\b|git\s+(?:status|diff|log|show|branch|rev-parse|ls-files|grep)\b|which\b|command\s+-v\b|node\s+--version\b|node\s+-v\b|python(?:3)?\s+--version\b)/.test(normalized);
+      }
       async execute(args) {
         const start2 = performance.now();
         const command = args["command"];
@@ -6112,6 +6135,7 @@ var init_file_read = __esm({
     ];
     FileReadTool = class {
       name = "file_read";
+      aliases = ["read_file", "read", "cat"];
       description = "Read the contents of a file. For large files (200+ lines), returns a structural preview with signatures — use offset/limit to read specific sections.";
       parameters = {
         type: "object",
@@ -6127,6 +6151,12 @@ var init_file_read = __esm({
       constructor(workingDir) {
         this.workingDir = workingDir;
       }
+      isConcurrencySafe() {
+        return true;
+      }
+      isReadOnly() {
+        return true;
+      }
       /** Set actual context window size for proportional auto-windowing */
       setContextWindowSize(size) {
         this._contextWindowSize = size;
@@ -6662,6 +6692,7 @@ var init_grep_search = __esm({
     MAX_OUTPUT_LINES = 100;
     GrepSearchTool = class {
       name = "grep_search";
+      aliases = ["grep", "ripgrep", "search_text"];
       description = "Search file contents using regex patterns. Returns matching lines with file paths and line numbers.";
       parameters = {
         type: "object",
@@ -6685,6 +6716,12 @@ var init_grep_search = __esm({
       constructor(workingDir) {
         this.workingDir = workingDir;
       }
+      isConcurrencySafe() {
+        return true;
+      }
+      isReadOnly() {
+        return true;
+      }
       async execute(args) {
         const pattern = args["pattern"];
         const searchPath = resolve4(this.workingDir, args["path"] ?? ".");
@@ -6767,6 +6804,7 @@ var init_glob_find = __esm({
     MAX_RESULTS = 50;
     GlobFindTool = class {
       name = "find_files";
+      aliases = ["glob", "find"];
       description = "Find files matching a glob pattern. Returns list of matching file paths.";
       parameters = {
         type: "object",
@@ -6786,6 +6824,12 @@ var init_glob_find = __esm({
       constructor(workingDir) {
         this.workingDir = workingDir;
       }
+      isConcurrencySafe() {
+        return true;
+      }
+      isReadOnly() {
+        return true;
+      }
       async execute(args) {
         const pattern = args["pattern"];
         const searchPath = resolve5(this.workingDir, args["path"] ?? ".");
@@ -24373,6 +24417,7 @@ var init_list_directory = __esm({
     MAX_ENTRIES = 100;
     ListDirectoryTool = class {
       name = "list_directory";
+      aliases = ["ls", "dir"];
       description = "List files and directories at a given path. Shows file sizes and types. Output includes full relative paths you can use directly in subsequent tool calls.";
       parameters = {
         type: "object",
@@ -24388,6 +24433,12 @@ var init_list_directory = __esm({
       constructor(workingDir) {
         this.workingDir = workingDir;
       }
+      isConcurrencySafe() {
+        return true;
+      }
+      isReadOnly() {
+        return true;
+      }
       async execute(args) {
         const rawPath = args["path"];
         const dirPath = typeof rawPath === "string" && rawPath.trim() ? rawPath : ".";
@@ -551582,28 +551633,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 +551672,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 +551733,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;
   }
 });
 
@@ -555234,7 +555284,8 @@ function partitionToolCalls(calls, readOnlyHints) {
   const batches = [];
   let currentConcurrent = [];
   for (const call of calls) {
-    if (isConcurrencySafe(call.name, readOnlyHints)) {
+    const safe = typeof call.concurrencySafe === "boolean" ? call.concurrencySafe : isConcurrencySafe(call.name, readOnlyHints);
+    if (safe) {
       currentConcurrent.push(call);
     } else {
       if (currentConcurrent.length > 0) {
@@ -555892,13 +555943,18 @@ var init_streaming_executor = __esm({
       executeFn = null;
       constructor(config) {
         this.config = {
-          maxConcurrent: config?.maxConcurrent ?? 5
+          maxConcurrent: config?.maxConcurrent ?? 5,
+          concurrencyResolver: config?.concurrencyResolver
         };
       }
       /** Set the tool execution function */
       setExecutor(fn) {
         this.executeFn = fn;
       }
+      /** Update the parsed-input concurrency classifier. */
+      setConcurrencyResolver(fn) {
+        this.config.concurrencyResolver = fn;
+      }
       /** Number of tools tracked */
       get size() {
         return this.tools.size;
@@ -555919,7 +555975,7 @@ var init_streaming_executor = __esm({
           name: name10,
           args: partialArgs ?? {},
           state: "queued",
-          concurrencySafe: isConcurrencySafe(name10),
+          concurrencySafe: this.resolveConcurrencySafe(name10, partialArgs ?? {}),
           finalized: false,
           queuedAt: Date.now()
         });
@@ -555934,6 +555990,7 @@ var init_streaming_executor = __esm({
         if (!entry)
           return;
         entry.args = args;
+        entry.concurrencySafe = this.resolveConcurrencySafe(entry.name, args);
         entry.finalized = true;
         if (entry.state === "queued") {
           this.processQueue();
@@ -556031,6 +556088,15 @@ var init_streaming_executor = __esm({
           return true;
         return false;
       }
+      resolveConcurrencySafe(name10, args) {
+        try {
+          const resolved = this.config.concurrencyResolver?.(name10, args);
+          if (typeof resolved === "boolean")
+            return resolved;
+        } catch {
+        }
+        return isConcurrencySafe(name10);
+      }
       entryFingerprint(entry) {
         return `${entry.name}:${stableValueKey(entry.args)}`;
       }
@@ -558656,8 +558722,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 +559072,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 +559098,23 @@ 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;
+        this._streamingExecutor.setConcurrencyResolver((name10, args) => this.resolveToolConcurrencySafe(name10, args));
       }
       /** Update context window size (e.g. after querying Ollama /api/show) */
       setContextWindowSize(size) {
@@ -559050,7 +559122,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 +559898,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 +561442,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 +561454,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 +561468,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 +561522,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 +561777,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 +561846,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
           }),
@@ -562020,7 +562116,8 @@ ${blob}
         return Object.entries(args ?? {}).sort(([a2], [b]) => a2.localeCompare(b)).map(([k, v]) => `${k}=${this._formatExactArgValue(v)}`).join(",");
       }
       _buildToolFingerprint(name10, args) {
-        return `${name10}:${this._buildExactArgsKey(args)}`;
+        const canonical = this.lookupRegisteredTool(name10)?.name ?? name10;
+        return `${canonical}:${this._buildExactArgsKey(args)}`;
       }
       _dedupeToolCallsForResponse(toolCalls, turn) {
         if (toolCalls.length <= 1)
@@ -562226,32 +562323,45 @@ ${blob}
       }
       /** Register a tool for the agent to use */
       registerTool(tool) {
-        if (!this.isToolAllowedByProfile(tool.name))
+        if (!this.isToolAllowedByProfile(tool.name, tool.aliases))
           return;
         this.tools.set(tool.name, tool);
         if (tool.name === "generate_image") {
           this.maybeInstallImagePromptExpander(tool);
         }
       }
-      isToolAllowedByProfile(name10) {
-        const profile = this.options.toolProfile;
-        if (!profile)
-          return true;
+      toolNameVariants(name10) {
         const raw = String(name10 ?? "").trim();
+        if (!raw)
+          return [];
         const lastSegment = raw.split(/[.:/]/).filter(Boolean).pop() ?? raw;
-        const candidates = /* @__PURE__ */ new Set([
+        return Array.from(new Set([
           raw,
           raw.toLowerCase(),
+          raw.replace(/[-\s]+/g, "_"),
           raw.replace(/^functions[._:-]/i, ""),
           raw.replace(/^tools[._:-]/i, ""),
           lastSegment,
-          lastSegment.toLowerCase()
-        ]);
+          lastSegment.toLowerCase(),
+          lastSegment.replace(/[-\s]+/g, "_")
+        ].filter(Boolean)));
+      }
+      isToolAllowedByProfile(name10, aliases) {
+        const profile = this.options.toolProfile;
+        if (!profile)
+          return true;
+        const candidates = /* @__PURE__ */ new Set();
+        for (const value2 of [name10, ...aliases ?? []]) {
+          for (const variant of this.toolNameVariants(value2)) {
+            candidates.add(variant);
+          }
+        }
         const allow = Array.isArray(profile.allow) ? profile.allow.filter(Boolean) : [];
-        if (allow.length > 0)
-          return allow.some((toolName) => candidates.has(toolName));
+        if (allow.length > 0) {
+          return allow.some((toolName) => this.toolNameVariants(toolName).some((candidate) => candidates.has(candidate)));
+        }
         const deny = Array.isArray(profile.deny) ? profile.deny.filter(Boolean) : [];
-        return !deny.some((toolName) => candidates.has(toolName));
+        return !deny.some((toolName) => this.toolNameVariants(toolName).some((candidate) => candidates.has(candidate)));
       }
       toolProfileDenial(name10) {
         const profileName = this.options.toolProfile?.name || "active tool profile";
@@ -562329,20 +562439,14 @@ Rewrite it now for ${ctx3.model}.`;
         const direct = this.tools.get(raw);
         if (direct)
           return { name: raw, tool: direct };
-        const lastSegment = raw.split(/[.:/]/).filter(Boolean).pop() ?? raw;
-        const candidates = /* @__PURE__ */ new Set([
-          raw,
-          raw.toLowerCase(),
-          raw.replace(/[-\s]+/g, "_"),
-          raw.replace(/^functions[._:-]/i, ""),
-          raw.replace(/^tools[._:-]/i, ""),
-          lastSegment,
-          lastSegment.toLowerCase(),
-          lastSegment.replace(/[-\s]+/g, "_")
-        ]);
+        const candidates = new Set(this.toolNameVariants(raw));
         const lowerIndex = /* @__PURE__ */ new Map();
-        for (const registeredName of this.tools.keys()) {
-          lowerIndex.set(registeredName.toLowerCase(), registeredName);
+        for (const [registeredName, tool] of this.tools) {
+          for (const value2 of [registeredName, ...tool.aliases ?? []]) {
+            for (const variant of this.toolNameVariants(value2)) {
+              lowerIndex.set(variant.toLowerCase(), registeredName);
+            }
+          }
         }
         for (const candidate of candidates) {
           const exact = this.tools.get(candidate);
@@ -562354,8 +562458,47 @@ Rewrite it now for ${ctx3.model}.`;
         }
         return null;
       }
+      resolveToolConcurrencySafe(name10, args) {
+        const resolved = this.lookupRegisteredTool(name10);
+        const tool = resolved?.tool;
+        try {
+          if (typeof tool?.isConcurrencySafe === "function") {
+            return !!tool.isConcurrencySafe(args);
+          }
+          if (typeof tool?.isReadOnly === "function") {
+            return !!tool.isReadOnly(args);
+          }
+        } catch {
+        }
+        return isConcurrencySafe(resolved?.name ?? name10);
+      }
+      toolResultMaxSize(tool) {
+        const max = tool?.maxResultSizeChars;
+        return typeof max === "number" && Number.isFinite(max) && max > 0 ? max : void 0;
+      }
+      applyRegisteredToolResultTriage(result, toolName, tool) {
+        return applyToolResultTriage(result, {
+          workingDir: this._workingDirectory || process.cwd(),
+          toolName,
+          maxOutputSize: this.toolResultMaxSize(tool)
+        });
+      }
+      async validateToolInput(tool, args, toolName) {
+        if (typeof tool.validateInput !== "function")
+          return null;
+        const validation = await tool.validateInput(args, {
+          toolName,
+          workingDir: this._workingDirectory || process.cwd()
+        });
+        if (validation?.result === true)
+          return null;
+        if (validation?.result === false) {
+          return validation.message || "custom validation failed";
+        }
+        return null;
+      }
       unknownToolError(name10) {
-        const names = Array.from(this.tools.keys()).sort();
+        const names = Array.from(this.tools.values()).map((tool) => tool.aliases?.length ? `${tool.name} (aliases: ${tool.aliases.join("|")})` : tool.name).sort();
         const preview = names.slice(0, 80).join(", ");
         const suffix = names.length > 80 ? `, ... ${names.length - 80} more` : "";
         return `Unknown tool: ${name10}. Registered tools (${names.length}): ${preview}${suffix}`;
@@ -562369,6 +562512,7 @@ Rewrite it now for ${ctx3.model}.`;
         for (const t2 of this.tools.values()) {
           list.push({
             name: t2.name,
+            ...t2.aliases?.length ? { aliases: t2.aliases } : {},
             description: t2.description,
             parameters: t2.parameters
           });
@@ -562380,10 +562524,10 @@ Rewrite it now for ${ctx3.model}.`;
        * Validates against inputSchema if present and returns the tool result.
        */
       async runToolByName(name10, args) {
-        if (!this.isToolAllowedByProfile(name10)) {
+        const resolved = this.lookupRegisteredTool(name10);
+        if (!this.isToolAllowedByProfile(resolved?.name ?? name10, resolved?.tool.aliases)) {
           return this.toolProfileDenial(name10);
         }
-        const resolved = this.lookupRegisteredTool(name10);
         if (!resolved) {
           return { success: false, output: "", error: this.unknownToolError(name10) };
         }
@@ -562399,12 +562543,17 @@ Rewrite it now for ${ctx3.model}.`;
             error: `Invalid args for ${resolved.name}: ${e2?.message || String(e2)}`
           };
         }
+        const validationError = await this.validateToolInput(tool, args, resolved.name);
+        if (validationError) {
+          return {
+            success: false,
+            output: "",
+            error: `Invalid args for ${resolved.name}: ${validationError}. Check the parameter values and try again.`
+          };
+        }
         try {
           const result = await tool.execute(args);
-          return applyToolResultTriage(result, {
-            workingDir: this._workingDirectory || process.cwd(),
-            toolName: tool.name ?? "tool"
-          });
+          return this.applyRegisteredToolResultTriage(result, resolved.name, tool);
         } catch (e2) {
           return { success: false, output: "", error: e2?.message || String(e2) };
         }
@@ -562602,8 +562751,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 +562850,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 +563286,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 +563389,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 +564412,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 +564422,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 +564764,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 +564808,7 @@ ${memoryLines.join("\n")}`
                 compactionThreshold: limits.compactionThreshold,
                 toolCallCount,
                 keepRecent: limits.keepRecent,
-                littlemanOutcomes: this._littlemanToolOutcomes.length,
+                adversaryOutcomes: this._adversaryToolOutcomes.length,
                 headroom: limits.compactionThreshold - estTokens
               }
             });
@@ -564740,19 +564925,17 @@ ${memoryLines.join("\n")}`
                     if (jsonMatch) {
                       try {
                         const parsed = JSON.parse(jsonMatch[1]);
-                        if (parsed.tool && this.tools.has(parsed.tool)) {
-                          const tool = this.tools.get(parsed.tool);
+                        const resolvedParsedTool = parsed.tool ? this.lookupRegisteredTool(parsed.tool) : null;
+                        if (parsed.tool && resolvedParsedTool) {
+                          const tool = resolvedParsedTool.tool;
                           const rawResult = await tool.execute(parsed.args ?? {});
-                          const result = applyToolResultTriage(rawResult, {
-                            workingDir: this._workingDirectory || process.cwd(),
-                            toolName: parsed.tool
-                          });
+                          const result = this.applyRegisteredToolResultTriage(rawResult, resolvedParsedTool.name, tool);
                           messages2.push({ role: "assistant", content });
                           messages2.push({
                             role: "user",
                             content: `Tool result (${parsed.tool}): ${result.output.slice(0, 2e3)}`
                           });
-                          if (parsed.tool === "task_complete") {
+                          if (resolvedParsedTool.name === "task_complete") {
                             completed = true;
                             summary = String(parsed.args?.summary ?? content);
                           }
@@ -564986,16 +565169,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 +565463,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 +565509,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 +565526,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",
@@ -565494,6 +565592,9 @@ ${header}${truncatedCache}${generationCompletionHint}`,
                     }
                   }
                 }
+                if (!validationError) {
+                  validationError = await this.validateToolInput(tool, tc.arguments, resolvedTool?.name ?? tc.name);
+                }
                 if (validationError) {
                   result = {
                     success: false,
@@ -565582,10 +565683,7 @@ ${header}${truncatedCache}${generationCompletionHint}`,
                         } else {
                           result = await tool.execute(finalArgs);
                         }
-                        result = applyToolResultTriage(result, {
-                          workingDir: this._workingDirectory || process.cwd(),
-                          toolName: tc.name
-                        });
+                        result = this.applyRegisteredToolResultTriage(result, resolvedTool?.name ?? tc.name, tool);
                         if (tc.name === "shell" && result.success === true) {
                           const semanticErr = this._detectSemanticShellFailure(result.output ?? "");
                           if (semanticErr) {
@@ -566455,6 +566553,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)
@@ -566824,10 +566927,8 @@ Then use file_read on individual FILES inside it.`);
               await this._streamingExecutor.waitAll();
               const streamResults = this._streamingExecutor.drainCompleted();
               for (const sr of streamResults) {
-                sr.result = applyToolResultTriage(sr.result, {
-                  workingDir: this._workingDirectory || process.cwd(),
-                  toolName: sr.name
-                });
+                const resolvedStreamTool = this.lookupRegisteredTool(sr.name);
+                sr.result = this.applyRegisteredToolResultTriage(sr.result, resolvedStreamTool?.name ?? sr.name, resolvedStreamTool?.tool);
               }
               const handledIds = /* @__PURE__ */ new Set();
               for (const sr of streamResults) {
@@ -566865,22 +566966,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 +567021,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;
                       }
                     }
                   }
@@ -566946,7 +567045,8 @@ ${sr.result.output}`;
               const batchToolCalls = rawToolCalls.map((tc) => ({
                 name: tc.name,
                 args: tc.arguments,
-                id: tc.id
+                id: tc.id,
+                concurrencySafe: this.resolveToolConcurrencySafe(tc.name, tc.arguments)
               }));
               const batches = partitionToolCalls(batchToolCalls);
               for (const batch2 of batches) {
@@ -567013,22 +567113,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 +567138,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();
@@ -567225,6 +567324,9 @@ Call task_complete(summary="...") NOW with whatever you have.`
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
             }
+            const pendingBeforeAdversary = this.pendingUserMessages.length;
+            this.adversaryObserve(messages2, turn);
+            const adversaryAddedGuidance = this.pendingUserMessages.length > pendingBeforeAdversary;
             if (/task.?complete|all tests pass/i.test(content)) {
               const completionArgs = { summary: content };
               if (holdNoProgressTaskComplete(completionArgs, turn) || holdProvenanceTaskComplete(completionArgs, turn)) {
@@ -567236,7 +567338,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 ? `
 
@@ -567340,6 +567442,12 @@ Your most recent tool calls SUCCEEDED. If the task is complete, call task_comple
                 content: "Continue working. Use tools to read files, make changes, and run validation. Call task_complete when done."
               });
             }
+            if (adversaryAddedGuidance) {
+              while (this.pendingUserMessages.length > 0) {
+                const userMsg = this.pendingUserMessages.shift();
+                await this.appendInjectedUserMessage(userMsg, messages2, turn);
+              }
+            }
           }
           try {
             const turnLogTail = toolCallLog.filter((t2) => t2.turn === turn || t2.turn === void 0);
@@ -567487,7 +567595,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 {
@@ -567677,10 +567786,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                 } else {
                   try {
                     result = await tool.execute(tc.arguments);
-                    result = applyToolResultTriage(result, {
-                      workingDir: this._workingDirectory || process.cwd(),
-                      toolName: tc.name
-                    });
+                    result = this.applyRegisteredToolResultTriage(result, resolvedTool?.name ?? tc.name, tool);
                   } catch (err) {
                     result = {
                       success: false,
@@ -567699,10 +567805,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                   if (pw2 && tool) {
                     try {
                       result = await tool.execute(tc.arguments);
-                      result = applyToolResultTriage(result, {
-                        workingDir: this._workingDirectory || process.cwd(),
-                        toolName: tc.name
-                      });
+                      result = this.applyRegisteredToolResultTriage(result, resolvedTool?.name ?? tc.name, tool);
                     } catch (err) {
                       result = {
                         success: false,
@@ -567797,8 +567900,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 +567973,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,38 +570061,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) {
-        if (this.options.modelTier === "large")
-          return;
+      adversaryObserve(messages2, turn) {
         const recent = messages2.slice(-6);
         for (const msg of recent) {
           if (msg.role === "tool" && typeof msg.content === "string") {
@@ -570017,10 +570116,16 @@ ${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({
+            const alreadySeen = this._adversaryToolOutcomes.some((o2) => {
+              if (msg.tool_call_id && o2.toolCallId === msg.tool_call_id)
+                return true;
+              return o2.turn === turn && o2.tool === toolName && o2.fingerprint === fingerprint;
+            });
+            if (!alreadySeen) {
+              this._adversaryToolOutcomes.push({
                 turn,
                 tool: toolName,
+                toolCallId: msg.tool_call_id,
                 argsKey,
                 fingerprint,
                 succeeded,
@@ -570029,27 +570134,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 +570188,68 @@ ${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 newestAssistant = [...recent].reverse().find((m2) => m2.role === "assistant");
+          const lastToolCalls = newestAssistant?.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 +570262,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,
@@ -571164,6 +571319,7 @@ ${transcript}`
           }
         }
         const getDesc = (tool) => dynamicDescs.get(tool.name) ?? tool.description;
+        const aliasText = (tool) => Array.isArray(tool.aliases) && tool.aliases.length > 0 ? ` aliases:${tool.aliases.join(",")}` : "";
         const getCustomToolMetadata = (tool) => {
           const meta = tool.customToolMetadata;
           return meta?.isCustomTool === true ? meta : void 0;
@@ -571200,7 +571356,7 @@ Example: ${tool.name}(${JSON.stringify(meta.examples[0].args ?? {})})` : "";
         };
         const getIndexLabel = (tool) => {
           const meta = getCustomToolMetadata(tool);
-          const desc = `${getDesc(tool)} ${customToolSearchText(tool)}`.toLowerCase().replace(/[`"'()[\]{}:;,.!?/\\|-]+/g, " ");
+          const desc = `${getDesc(tool)} ${aliasText(tool)} ${customToolSearchText(tool)}`.toLowerCase().replace(/[`"'()[\]{}:;,.!?/\\|-]+/g, " ");
           const keywords2 = Array.from(new Set(desc.split(/\s+/).filter((word2) => word2.length > 2 && !STOPWORDS3.has(word2) && !tool.name.toLowerCase().includes(word2)))).slice(0, 4);
           const base3 = keywords2.length > 0 ? `${tool.name}(${keywords2.join(",")})` : tool.name;
           if (!meta)
@@ -571234,7 +571390,7 @@ Example: ${tool.name}(${JSON.stringify(meta.examples[0].args ?? {})})` : "";
           if (CORE_TOOLS3.has(tool.name))
             continue;
           const customMeta = getCustomToolMetadata(tool);
-          const toolText = `${tool.name} ${getDesc(tool)} ${customToolSearchText(tool)}`.toLowerCase();
+          const toolText = `${tool.name} ${aliasText(tool)} ${getDesc(tool)} ${customToolSearchText(tool)}`.toLowerCase();
           const toolWords = toolText.split(/\s+/).filter((w) => w.length > 2);
           let score = 0;
           for (const tw of toolWords) {
@@ -571245,7 +571401,7 @@ Example: ${tool.name}(${JSON.stringify(meta.examples[0].args ?? {})})` : "";
                 score += 1;
             }
           }
-          if (taskText.includes(tool.name.replace(/_/g, " ")) || taskText.includes(tool.name)) {
+          if (taskText.includes(tool.name.replace(/_/g, " ")) || taskText.includes(tool.name) || (tool.aliases ?? []).some((alias) => taskText.includes(alias.toLowerCase()))) {
             score += customMeta ? 16 : 10;
           }
           if (wants3dModelGeneration) {
@@ -571398,6 +571554,9 @@ ${catalog}`,
                       continue;
                     lines.push("");
                     lines.push(`## ${tool.name}`);
+                    if (tool.aliases?.length) {
+                      lines.push(`Aliases: ${tool.aliases.join(", ")}`);
+                    }
                     lines.push(`${getDesc(tool)}${customToolDetails(tool)}`);
                     lines.push(`Parameters: ${JSON.stringify(tool.parameters)}`);
                   }
@@ -571410,7 +571569,7 @@ ${catalog}`,
                 }
                 return { success: true, output: lines.join("\n") };
               }
-              const matches = deferred.filter((t2) => t2.name.toLowerCase().includes(query) || getDesc(t2).toLowerCase().includes(query) || customToolSearchText(t2).toLowerCase().includes(query)).sort((a2, b) => {
+              const matches = deferred.filter((t2) => t2.name.toLowerCase().includes(query) || (t2.aliases ?? []).some((alias) => alias.toLowerCase().includes(query)) || getDesc(t2).toLowerCase().includes(query) || customToolSearchText(t2).toLowerCase().includes(query)).sort((a2, b) => {
                 const scoreTool = (tool) => {
                   const meta = getCustomToolMetadata(tool);
                   let score = 0;
@@ -571418,6 +571577,10 @@ ${catalog}`,
                     score += 30;
                   if (tool.name.toLowerCase().includes(query))
                     score += 10;
+                  if ((tool.aliases ?? []).some((alias) => alias.toLowerCase() === query))
+                    score += 24;
+                  if ((tool.aliases ?? []).some((alias) => alias.toLowerCase().includes(query)))
+                    score += 8;
                   if (getDesc(tool).toLowerCase().includes(query))
                     score += 4;
                   if (customToolSearchText(tool).toLowerCase().includes(query))
@@ -571448,7 +571611,9 @@ ${catalog}`,
                 activatedToolsRef.add(t2.name);
               const result = matches.map((t2) => {
                 const paramsStr = JSON.stringify(t2.parameters, null, 2);
-                return `## ${t2.name}
+                const aliases = t2.aliases?.length ? `
+Aliases: ${t2.aliases.join(", ")}` : "";
+                return `## ${t2.name}${aliases}
 ${getDesc(t2)}${customToolDetails(t2)}
 
 Parameters:
@@ -651081,7 +651246,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
@@ -681052,15 +681217,31 @@ function adaptTool6(tool) {
   }
   return {
     name: tool.name,
+    aliases: tool.aliases,
     description: tool.description,
     parameters: tool.parameters,
+    inputSchema: tool.inputSchema,
+    prompt: tool.prompt,
+    executeStream: tool.executeStream,
+    validateInput: tool.validateInput,
+    isConcurrencySafe: tool.isConcurrencySafe,
+    isReadOnly: tool.isReadOnly,
+    maxResultSizeChars: tool.maxResultSizeChars,
     async execute(args) {
       const result = await tool.execute(args);
       return {
         success: result.success,
         output: result.output,
         error: result.error,
-        llmContent: result.llmContent
+        llmContent: result.llmContent,
+        mutated: result.mutated,
+        mutatedFiles: result.mutatedFiles,
+        diff: result.diff,
+        dryRun: result.dryRun,
+        noop: result.noop,
+        partial: result.partial,
+        beforeHash: result.beforeHash,
+        afterHash: result.afterHash
       };
     }
   };
@@ -683444,8 +683625,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 +684110,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 +685869,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 +685903,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();
       }