open-agents-ai 0.187.556 → 0.187.558

package/dist/index.js

@@ -1443,10 +1443,10 @@ var init_security_classifier = __esm({
     RULES = [
       // ── Critical sensitive: tool registry / identity / worktree / sponsorship
       { match: /^(create_tool|manage_tools|skill_build|tool_creator)$/, info: CRITICAL_SENSITIVE },
-      { match: /^(identity_kernel|reflection_integrity|cohere_constraints)$/, info: CRITICAL_SENSITIVE },
+      { match: /^(identity_kernel|reflection_integrity|reflect|cohere_constraints)$/, info: CRITICAL_SENSITIVE },
       { match: /^(enter_worktree|exit_worktree)$/, info: CRITICAL_SENSITIVE },
       { match: /^(aiwg_setup|aiwg_health|aiwg_workflow)$/, info: CRITICAL_SENSITIVE },
-      { match: /^(expose|sponsor|nexus_register)/, info: CRITICAL_SENSITIVE },
+      { match: /^(expose|sponsor|nexus_register|wallet_|x402|payment|spend)/, info: CRITICAL_SENSITIVE },
       // ── Hardware peripherals
       { match: /^(camera_capture|audio_capture|audio_playback|audio_analyze|asr_listen)$/, info: HARDWARE_DEVICE },
       { match: /^(wifi_control|bluetooth_scan|sdr_scan|flipper_zero|meshtastic|gps_location)$/, info: HARDWARE_DEVICE },
@@ -1471,22 +1471,22 @@ var init_security_classifier = __esm({
       // ── Network reads (safe)
       { match: /^(web_search|web_fetch)$/, info: NETWORK_READ },
       // ── Network outbound (mutating or remote inference)
-      { match: /^(image_generate|vision|video_understand)$/, info: NETWORK_OUTBOUND },
+      { match: /^(image_generate|generate_image|vision|video_understand)$/, info: NETWORK_OUTBOUND },
       { match: /^(transcribe_file|transcribe_url|youtube_download)$/, info: NETWORK_OUTBOUND },
       { match: /^(fortemi_bridge)$/, info: NETWORK_OUTBOUND },
       // ── Memory tools
       { match: /^(memory_read|memory_search)$/, info: MEMORY_READ },
-      { match: /^(memory_write|memory_metabolism|multimodal_memory|visual_memory|embedding_store)$/, info: MEMORY_WRITE },
+      { match: /^(memory_write|memory_metabolism|memory_metabolize|multimodal_memory|visual_memory|embedding_store)$/, info: MEMORY_WRITE },
       // ── Local writes (fs mutation)
-      { match: /^(file_write|file_edit|file_patch|batch_edit|notebook_edit|structured_file|image_resize)$/, info: LOCAL_WRITE },
+      { match: /^(file_write|file_edit|file_patch|batch_edit|notebook_edit|structured_file|create_structured_file|image_resize)$/, info: LOCAL_WRITE },
       { match: /^(working_notes|todo_write)$/, info: LOCAL_WRITE },
       { match: /^(scheduler|reminder|agenda)$/, info: SCHEDULER_REMINDER },
-      { match: /^(exploration_culture)$/, info: LOCAL_WRITE },
+      { match: /^(exploration_culture|explore)$/, info: LOCAL_WRITE },
       // ── Task control
       { match: /^(task_status|task_output|task_stop)$/, info: TASK_CONTROL },
       // ── Local reads (inspection)
-      { match: /^(file_read|file_explore|list_directory|grep_search|glob_find)$/, info: LOCAL_READ },
-      { match: /^(image_read|ocr|ocr_pdf|ocr_image_advanced|pdf_to_text|structured_read)$/, info: LOCAL_READ },
+      { match: /^(file_read|file_explore|list_directory|grep_search|glob_find|find_files)$/, info: LOCAL_READ },
+      { match: /^(image_read|ocr|ocr_pdf|ocr_image_advanced|pdf_to_text|structured_read|read_structured_file)$/, info: LOCAL_READ },
       { match: /^(symbol_search|impact_analysis|code_neighbors|repo_map|codebase_map|semantic_map|import_graph)$/, info: LOCAL_READ },
       { match: /^(diagnostic|git_info|environment_snapshot|process_health|todo_read|explore_tools)$/, info: LOCAL_READ },
       { match: /^(log_explore|log_packet|change_log|phase_recall|code_graph)$/, info: LOCAL_READ },
@@ -1504,6 +1504,106 @@ var init_security_classifier = __esm({
   }
 });
 
+// packages/execution/dist/tools/tool-manifest.js
+function clearToolManifestCache() {
+  probeCache.clear();
+}
+function defaultExposureForTool(name10, security) {
+  if (security.risk === "critical" || security.risk === "high" || security.categories.includes("hardware") || security.categories.includes("agent") || security.categories.includes("sensitive")) {
+    return "profile-opt-in";
+  }
+  if (!security.off_device_allowed || security.categories.includes("exec")) {
+    return "local-only";
+  }
+  if (/(^|_)(x402|wallet|payment|spend|sponsor|expose)(_|$)/.test(name10)) {
+    return "profile-opt-in";
+  }
+  return "trusted-default";
+}
+function buildToolManifestFromModule(mod2, options2 = {}) {
+  const cwd4 = options2.cwd ?? process.cwd();
+  const ttlMs = options2.ttlMs ?? DEFAULT_TTL_MS;
+  const now = options2.now ?? Date.now();
+  const entries = [];
+  for (const [className, value2] of Object.entries(mod2)) {
+    if (!isExecutableToolClass(value2))
+      continue;
+    const probe = probeToolClass(className, value2, cwd4, now, ttlMs);
+    if (!probe.result.available || !probe.result.name)
+      continue;
+    const security = classifyTool(probe.result.name);
+    entries.push({
+      name: probe.result.name,
+      className,
+      description: probe.result.description ?? "",
+      parameters: probe.result.parameters ?? null,
+      security,
+      defaultExposure: defaultExposureForTool(probe.result.name, security),
+      availability: {
+        available: true,
+        cached: probe.cached,
+        checkedAt: probe.checkedAt
+      }
+    });
+  }
+  entries.sort((a2, b) => a2.name.localeCompare(b.name));
+  return entries;
+}
+function toolCategoriesInclude(entry, category) {
+  return entry.security.categories.includes(category);
+}
+function isExecutableToolClass(value2) {
+  if (typeof value2 !== "function")
+    return false;
+  const proto = value2.prototype;
+  return typeof proto?.execute === "function";
+}
+function probeToolClass(className, ToolClass, cwd4, now, ttlMs) {
+  const cacheKey = `${className}:${cwd4}`;
+  const cached = probeCache.get(cacheKey);
+  if (cached && cached.expiresAt > now) {
+    return { result: cached.result, cached: true, checkedAt: cached.checkedAt };
+  }
+  const checkedAt = new Date(now).toISOString();
+  const result = instantiateForMetadata(ToolClass, cwd4);
+  probeCache.set(cacheKey, { result, checkedAt, expiresAt: now + ttlMs });
+  return { result, cached: false, checkedAt };
+}
+function instantiateForMetadata(ToolClass, cwd4) {
+  let inst = null;
+  let lastError = null;
+  for (const args of [[], [cwd4]]) {
+    try {
+      inst = new ToolClass(...args);
+      break;
+    } catch (err) {
+      lastError = err;
+    }
+  }
+  if (!inst || typeof inst.name !== "string") {
+    return {
+      available: false,
+      reason: lastError instanceof Error ? lastError.message : "tool did not expose a string name"
+    };
+  }
+  const tool = inst;
+  return {
+    available: true,
+    name: tool.name,
+    description: typeof tool.description === "string" ? tool.description : "",
+    parameters: tool.parameters ?? null
+  };
+}
+var DEFAULT_TTL_MS, probeCache;
+var init_tool_manifest = __esm({
+  "packages/execution/dist/tools/tool-manifest.js"() {
+    "use strict";
+    init_security_classifier();
+    DEFAULT_TTL_MS = 3e4;
+    probeCache = /* @__PURE__ */ new Map();
+  }
+});
+
 // packages/execution/dist/process-kill.js
 import { execSync } from "node:child_process";
 function killProcessTree(pid, signal = "SIGKILL") {
@@ -511573,12 +511673,14 @@ __export(dist_exports, {
   buildScaffoldedPrompt: () => buildScaffoldedPrompt,
   buildSkillsSummary: () => buildSkillsSummary,
   buildSubProcessArgs: () => buildSubProcessArgs,
+  buildToolManifestFromModule: () => buildToolManifestFromModule,
   canInvokeTool: () => canInvokeTool,
   checkConstraints: () => checkConstraints,
   checkDesktopDeps: () => checkDesktopDeps,
   classifyTool: () => classifyTool,
   clearExploreNotes: () => clearExploreNotes,
   clearImportGraphCache: () => clearImportGraphCache,
+  clearToolManifestCache: () => clearToolManifestCache,
   clearWorkingNotes: () => clearWorkingNotes,
   closeAllCodeGraphDBs: () => closeAllCodeGraphDBs,
   codeGraphDBExists: () => codeGraphDBExists,
@@ -511588,6 +511690,7 @@ __export(dist_exports, {
   createFortemiBridgeTools: () => createFortemiBridgeTools,
   createTransport: () => createTransport,
   createWorktree: () => createWorktree2,
+  defaultExposureForTool: () => defaultExposureForTool,
   deleteTodos: () => deleteTodos,
   detectElevationMethod: () => detectElevationMethod,
   detectSearchProvider: () => detectSearchProvider,
@@ -511676,6 +511779,7 @@ __export(dist_exports, {
   stopFullSubAgent: () => stopFullSubAgent,
   summarizeLog: () => summarizeLog,
   todoDir: () => todoDir,
+  toolCategoriesInclude: () => toolCategoriesInclude,
   touchFile: () => touchFile,
   validateSlug: () => validateSlug,
   venvBinDir: () => venvBinDir,
@@ -511690,6 +511794,7 @@ var init_dist5 = __esm({
     "use strict";
     init_tool_executor();
     init_security_classifier();
+    init_tool_manifest();
     init_shell();
     init_debate();
     init_replay_with_intervention();
@@ -513951,12 +514056,12 @@ function buildStagnationDiagnostic(signals) {
     ``,
     `2. STATE A HYPOTHESIS in writing — what specifically is wrong? "I think X is failing because Y." Be concrete. Do NOT propose a fix yet.`,
     ``,
-    `3. VERIFY ONE ASSUMPTION — pick the ONE thing you most BELIEVE to be true and test it with the smallest possible command native to whatever ecosystem you're in. Examples of the *shape* (not the exact commands):`,
+    `3. VERIFY ONE ASSUMPTION — pick the ONE local thing you most BELIEVE to be true and test it with the smallest possible read/grep/test command. Examples of the *shape* (not the exact commands):`,
     `     • Is this artifact present on disk? (one read of the path)`,
     `     • Does this import / reference resolve? (read 5 lines around it)`,
     `     • Is this environment value set? (one query)`,
     `     • Is this binary on PATH? (one which/where)`,
-    `     • Don't know what an error means? web_search("<exact error string>")`,
+    `     • Don't know what an error means? Re-read the full local error, extract the implicated path/symbol/config key/command, and verify that target locally before changing anything.`,
     ``,
     `4. CHECK SILENT FAILURES — package managers and build systems frequently report "success" while silently dropping artifacts you needed. Don't trust summary output ("added N", "build complete") without verifying the SPECIFIC artifact exists.`,
     ``,
@@ -514086,7 +514191,7 @@ function renderReflectionMessage(r2) {
   }
   if (r2.attempts >= 3) {
     lines.push(``);
-    lines.push(`[FORCED — your intrinsic knowledge has not resolved this in ${r2.attempts} attempts. Your NEXT call MUST be \`web_search("${r2.wentWrong.replace(/"/g, '\\"').slice(0, 120)}")\` (or close-equivalent). Read the top result before making another fix attempt.]`);
+    lines.push(`[FORCED - local failure loop detected after ${r2.attempts} attempts. Your NEXT move must be anchored to the local error above: name one implicated path/symbol/config key or failing command, verify that target with the smallest local read/grep/test step, then make one targeted edit or declare the exact blocker. Do not web_search for a codebase-local failure unless the current user task explicitly requires external documentation.]`);
   }
   lines.push(`VERIFY this hypothesis with a single small command BEFORE retrying the same tool. If you retry without verifying, you will likely fail the same way.]`);
   return lines.join("\n");
@@ -523569,9 +523674,9 @@ function handoffEnabled() {
 function handoffTtlMs() {
   const raw = process.env["OA_TASK_HANDOFF_TTL_MS"];
   if (!raw)
-    return DEFAULT_TTL_MS;
+    return DEFAULT_TTL_MS2;
   const n2 = Number.parseInt(raw, 10);
-  return Number.isFinite(n2) && n2 > 0 ? n2 : DEFAULT_TTL_MS;
+  return Number.isFinite(n2) && n2 > 0 ? n2 : DEFAULT_TTL_MS2;
 }
 function handoffPath(oaDir) {
   return path5.join(oaDir, "handoffs", "latest.json");
@@ -523685,11 +523790,11 @@ If you need verbatim details from the prior task (specific code, exact error mes
   };
   return [boundary, summary];
 }
-var DEFAULT_TTL_MS, MAX_SUMMARY_CHARS, MAX_FILES, MAX_TOOLS, MAX_LAST_ACTIONS;
+var DEFAULT_TTL_MS2, MAX_SUMMARY_CHARS, MAX_FILES, MAX_TOOLS, MAX_LAST_ACTIONS;
 var init_taskHandoff = __esm({
   "packages/orchestrator/dist/taskHandoff.js"() {
     "use strict";
-    DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
+    DEFAULT_TTL_MS2 = 24 * 60 * 60 * 1e3;
     MAX_SUMMARY_CHARS = 8e3;
     MAX_FILES = 30;
     MAX_TOOLS = 24;
@@ -526133,6 +526238,7 @@ RECOVERY: cd to the directory containing '${file}', run a plain install with no
 
 // packages/orchestrator/dist/agenticRunner.js
 import { existsSync as _fsExistsSync, readFileSync as _fsReadFileSync, writeFileSync as _fsWriteFileSync, mkdirSync as _fsMkdirSync } from "node:fs";
+import { createHash as _createHash } from "node:crypto";
 import { join as _pathJoin } from "node:path";
 import { homedir as _osHomedir } from "node:os";
 import { z as z15 } from "zod";
@@ -526495,9 +526601,9 @@ var init_agenticRunner = __esm({
       _lastBuildSuccessCommand = "";
       // REG-31: prevent duplicate completion suggestion per turn
       _completionPromptInjectedThisTurn = false;
-      // REG-32: one-shot per-stem nudge toward web_search on opaque errors.
+      // REG-32: one-shot per-stem nudge toward local triage on opaque errors.
       // Closes the gap where qwen3.6 pivots away from a single failure (different
-      // stem on next turn) and never triggers REG-26/28's retry-based web_search
+      // stem on next turn) and never triggers REG-26/28's retry-based local
       // escalations. Fires on the FIRST failure of a stem when the local
       // diagnostic can't help (unknown category or long multi-line error with
       // no extractable subject).
@@ -526539,7 +526645,7 @@ var init_agenticRunner = __esm({
       // writes ARE happening (just earlier in the run). Detect: in last
       // 12 turns, ld+sh count >= 25 + fw growth <= 2 + recent shell
       // failure exists. Fire CRITICAL halt instructing the agent to stop
-      // exploring and either web_search or fix one specific thing.
+      // exploring and either locally triage the failure or fix one specific thing.
       // Cooldown 8 turns after firing.
       _wideExplorationCooldownUntilTurn = -1;
       // REG-45: sticky cross-turn escalation. The dispatch-time reflection
@@ -526698,8 +526804,8 @@ var init_agenticRunner = __esm({
       //
       // Semantics: when REG-61 fires, this latch goes true. While true, every
       // non-bypass tool call gets BLOCKED with a synthetic error result. The
-      // bypass set includes the 4 creative-edit tools plus web_search /
-      // task_complete / ask_user (escape hatches). Any creative edit dispatch
+      // bypass set includes the 4 creative-edit tools plus task_complete /
+      // ask_user / explicit web-task escape hatches. Any creative edit dispatch
       // clears the latch ("directive satisfied"). Shell, file_read, todo_*,
       // grep_search, list_directory etc. are NOT in bypass — those are the
       // exact patterns batch528/529 agents used to ignore REG-61.
@@ -526710,10 +526816,11 @@ var init_agenticRunner = __esm({
       // sub_agent delegation. DECOMP-1's informational directive was ignored
       // (0 sub_agent calls in 466 tool-call run despite directive at turn 1).
       // Mirrors the BFC-61.G escalation arc: when the agent has edited
-      // ≥THRESHOLD distinct files in main context WITHOUT calling sub_agent,
+      // ≥THRESHOLD distinct files in main context WITHOUT successful sub_agent,
       // the dispatcher BLOCKS edits to NEW files (paths not yet edited) until
-      // sub_agent is invoked. Edits to already-touched files are still allowed
-      // (current-module finishing work). sub_agent dispatch clears the gate.
+      // sub_agent succeeds. Edits to already-touched files are still allowed
+      // (current-module finishing work). Failed or malformed delegation does
+      // not clear the gate.
       // Kill switch: OA_DISABLE_DECOMP2=1.
       _decomp2MainContextFiles = /* @__PURE__ */ new Set();
       _decomp2SubAgentCalls = 0;
@@ -527249,7 +527356,7 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
        *   - kill-switch `OA_DISABLE_DECOMP2` is not set
        *
        * Already-touched paths pass through (current-module finishing work allowed).
-       * sub_agent / web_search / task_complete pass through (not creative-edit tools).
+       * sub_agent / task_complete / explicit web-task tools pass through (not creative-edit tools).
        */
       _maybeDecomp2Block(tc, turn) {
         if (!this._decomp2GateActive)
@@ -527291,7 +527398,7 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
         ].join("\n");
         this.emit({
           type: "status",
-          content: `DECOMP-2 NEW-FILE BLOCK — rejected ${tc.name}('${_editPath}') at turn ${turn}; gate stays active until sub_agent is invoked`,
+          content: `DECOMP-2 NEW-FILE BLOCK — rejected ${tc.name}('${_editPath}') at turn ${turn}; gate stays active until sub_agent succeeds`,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
         this._tagSyntheticFailure({
@@ -527312,8 +527419,9 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
        * Side effects when fired:
        *   - On successful creative edit: adds path to `_decomp2MainContextFiles`,
        *     possibly activates `_decomp2GateActive` (emits status).
-       *   - On sub_agent / priority_delegate / background_run: increments
-       *     counter, clears gate (emits status).
+       *   - On successful sub_agent / priority_delegate / background_run:
+       *     increments counter, clears gate (emits status). Failed or malformed
+       *     delegation attempts do not satisfy the gate.
        *
        * Pure post-dispatch: caller invokes AFTER the tool result is in hand,
        * regardless of which loop the dispatch happened in.
@@ -527330,13 +527438,23 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
               this._decomp2GateActive = true;
               this.emit({
                 type: "status",
-                content: `DECOMP-2 NEW-FILE GATE ACTIVATED — ${this._decomp2MainContextFiles.size} distinct files edited in main context, 0 sub_agent calls; further edits to NEW files will be blocked until sub_agent is invoked`,
+                content: `DECOMP-2 NEW-FILE GATE ACTIVATED — ${this._decomp2MainContextFiles.size} distinct files edited in main context, 0 successful sub_agent calls; further edits to NEW files will be blocked until sub_agent succeeds`,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
             }
           }
         }
         if (tc.name === "sub_agent" || tc.name === "priority_delegate" || tc.name === "background_run") {
+          if (result?.success !== true) {
+            if (this._decomp2GateActive) {
+              this.emit({
+                type: "status",
+                content: `DECOMP-2 DELEGATION FAILED — '${tc.name}' did not clear gate at turn ${turn}; fix delegation arguments/result before editing another new file`,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+            }
+            return;
+          }
           this._decomp2SubAgentCalls++;
           if (this._decomp2GateActive) {
             this._decomp2GateActive = false;
@@ -527883,8 +528001,13 @@ ${body}`;
             scanTurn++;
             for (const tc of msg.tool_calls) {
               const name10 = tc.function.name;
-              const argsRaw = (tc.function.arguments ?? "").slice(0, 200);
-              const fp = `${name10}|${argsRaw}`;
+              let parsedArgs;
+              try {
+                parsedArgs = JSON.parse(tc.function.arguments || "{}");
+              } catch {
+                parsedArgs = void 0;
+              }
+              const fp = parsedArgs ? this._buildToolFingerprint(name10, parsedArgs) : `${name10}:raw#sha256:${_createHash("sha256").update(tc.function.arguments ?? "").digest("hex").slice(0, 20)}`;
               let resultIdx = -1;
               for (let j = i2 + 1; j < Math.min(messages2.length, i2 + 8); j++) {
                 const r2 = messages2[j];
@@ -528565,6 +528688,42 @@ ${body}`;
         lines.push(`(turn ${turn} — failures auto-expire after 10 turns; cleared on success or successful retry)`);
         return lines.join("\n");
       }
+      /**
+       * Render a short, local-code-first nudge from the freshest failure signal.
+       * This is intentionally not a web-search suggestion: most coding-agent loops
+       * are caused by ignoring local compiler/test output, not by missing internet
+       * knowledge. The nudge points at the exact local error, path, symbol, or
+       * command the next move should be anchored to.
+       */
+      _renderLocalFailureNudge(turn) {
+        const fresh = this._recentFailures.filter((f2) => turn - f2.turn <= 10);
+        const latest = fresh[fresh.length - 1];
+        if (!latest) {
+          return [
+            `[LOCAL ERROR-INFORMED NUDGE]`,
+            `No fresh tool failure is recorded. Use the active todo, files already touched, and the last visible test/build output to pick the smallest plausible local edit. If there is no local target, declare the specific blocker instead of looping.`
+          ].join("\n");
+        }
+        const raw = `${latest.error || ""}
+${latest.output || ""}`.trim();
+        const firstLine = raw.split(/\r?\n/).find((l2) => l2.trim().length > 0)?.trim().slice(0, 220) || "(no error line captured)";
+        const command = latest.tool === "shell" ? String(latest.args["command"] ?? latest.args["cmd"] ?? "").slice(0, 220) : "";
+        const pathMatches = Array.from(new Set((raw.match(/(?:[A-Za-z]:)?(?:\.{1,2}\/|\/)?[\w@./-]+\.(?:[cm]?tsx?|jsx?|json|css|html|md|ya?ml|py|go|rs|java|kt|rb|php|c|cc|cpp|h|hpp|sh|sql)(?::\d+(?::\d+)?)?/g) ?? []).filter((p2) => !/^https?:\/\//i.test(p2)).map((p2) => p2.slice(0, 160)))).slice(0, 4);
+        const quotedSubjects = Array.from(raw.matchAll(/["'`]([^"'`\n]{3,100})["'`]/g)).map((m2) => m2[1].trim()).filter((s2) => s2.length >= 3 && !/^https?:\/\//i.test(s2)).slice(0, 4);
+        const lines = [
+          `[LOCAL ERROR-INFORMED NUDGE]`,
+          `Last failing tool: ${latest.tool} (turn ${latest.turn})`,
+          `First error line: ${firstLine}`
+        ];
+        if (command)
+          lines.push(`Failing local command: ${command}`);
+        if (pathMatches.length > 0)
+          lines.push(`Local paths named by error: ${pathMatches.join(", ")}`);
+        if (quotedSubjects.length > 0)
+          lines.push(`Quoted local subjects: ${quotedSubjects.join(", ")}`);
+        lines.push(`Next useful move: anchor on the local signal above. Pick one implicated path/symbol or the file most directly connected to the failing command, make one small targeted edit, then run the failing local command once. If no local target exists after one focused local inspection, declare the blocker. Do not spend the next move on web search for a codebase-local failure.`);
+        return lines.join("\n");
+      }
       /**
        * REG-3: Render the current todo list as a compact transient block so the
        * agent can read its own plan without calling todo_read or re-emitting
@@ -528899,6 +529058,69 @@ ${blob}
         }
         return `${tool}#${(h >>> 0).toString(16)}`;
       }
+      /**
+       * Build an exact, deterministic tool-argument key for cache/dedupe identity.
+       *
+       * Older call sites truncated values before forming the fingerprint, so two
+       * different long paths/queries/commands with the same prefix could be treated
+       * as duplicate reads. This keeps the human-readable `path=...` shape for
+       * diagnostics, but appends a hash whenever a value must be shortened for log
+       * size. The hash is computed over the full canonical value.
+       */
+      _buildExactArgsKey(args) {
+        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)}`;
+      }
+      _formatExactArgValue(value2) {
+        const canonical = this._canonicalArgValue(value2);
+        const oneLine = canonical.replace(/\r/g, "\\r").replace(/\n/g, "\\n");
+        if (oneLine.length <= 240) {
+          return this._escapeArgsKeyValue(oneLine);
+        }
+        const head = oneLine.slice(0, 160);
+        const tail = oneLine.slice(-40);
+        const hash = _createHash("sha256").update(canonical).digest("hex").slice(0, 20);
+        return `${this._escapeArgsKeyValue(head)}...${this._escapeArgsKeyValue(tail)}#sha256:${hash}`;
+      }
+      _escapeArgsKeyValue(value2) {
+        return value2.replace(/\\/g, "\\\\").replace(/,/g, "\\,");
+      }
+      _canonicalArgValue(value2, seen = /* @__PURE__ */ new WeakSet()) {
+        if (typeof value2 === "string")
+          return value2;
+        if (value2 === null)
+          return "#null";
+        if (value2 === void 0)
+          return "#undefined";
+        if (typeof value2 === "number")
+          return `#number:${Number.isNaN(value2) ? "NaN" : String(value2)}`;
+        if (typeof value2 === "boolean")
+          return `#boolean:${String(value2)}`;
+        if (typeof value2 === "bigint")
+          return `#bigint:${String(value2)}`;
+        if (typeof value2 === "symbol")
+          return `#symbol:${String(value2.description ?? "")}`;
+        if (typeof value2 === "function")
+          return `#function:${value2.name || "anonymous"}`;
+        if (value2 instanceof Date)
+          return `#date:${value2.toISOString()}`;
+        if (Array.isArray(value2)) {
+          if (seen.has(value2))
+            return "#cycle";
+          seen.add(value2);
+          return `#array:[${value2.map((v) => this._canonicalArgValue(v, seen)).join(",")}]`;
+        }
+        if (typeof value2 === "object") {
+          if (seen.has(value2))
+            return "#cycle";
+          seen.add(value2);
+          const entries = Object.entries(value2).sort(([a2], [b]) => a2.localeCompare(b)).map(([k, v]) => `${JSON.stringify(k)}:${this._canonicalArgValue(v, seen)}`);
+          return `#object:{${entries.join(",")}}`;
+        }
+        return String(value2);
+      }
       /** Register a tool for the agent to use */
       registerTool(tool) {
         this.tools.set(tool.name, tool);
@@ -530043,7 +530265,9 @@ If this matches your current shape, try it before continuing.`
                     ``,
                     `  (a) PRODUCE: emit a file_write / file_edit / file_patch / shell-mutation that creates or changes content. Even a partial draft of the next planned file is progress.`,
                     ``,
-                    `  (b) WEB SEARCH: if a SPECIFIC error string or unknown API is blocking you, run \`web_search\` with the exact error / API name. External knowledge is faster than guessing.`,
+                    `  (b) ERROR-INFORMED LOCAL TRIAGE: anchor on the freshest local failure, identify the implicated file/path/symbol/command, then make one targeted local move instead of broad exploration.`,
+                    ``,
+                    this._renderLocalFailureNudge(turn),
                     ``,
                     `  (c) DEBATE: if you've tried 3+ approaches and they all hit the same wall, invoke \`debate\` with the failed task as the prompt — get a second opinion.`,
                     ``,
@@ -530212,7 +530436,9 @@ ${_staleSamples.join("\n")}` : ``,
                     ``,
                     `  (b) DELETE-AND-RESTART: If the file has been rewritten ${_wtWorstCount} times, the current approach is wrong. Either delete the file and try a fundamentally different design, OR revert to a known-good earlier version (use git, working_notes, or memory_search to find one).`,
                     ``,
-                    `  (c) WEB-SEARCH: If the error is framework- or version-specific (config files often are), web_search the EXACT error string + relevant tool name. External knowledge beats blind iteration.`,
+                    `  (c) ERROR-INFORMED LOCAL TRIAGE: use the exact failing local command and error line to identify one implicated path/symbol/config key, then inspect or change only that target. Do not search online for a codebase-local failure.`,
+                    ``,
+                    this._renderLocalFailureNudge(turn),
                     ``,
                     `  (d) DECLARE BLOCKED: If the file's correct shape genuinely isn't knowable from the spec + this codebase, call task_complete with a summary that names this specific file as the blocker. Don't burn more turns on it.`,
                     ``,
@@ -531273,7 +531499,7 @@ ${memoryLines.join("\n")}`
                 });
               } catch {
               }
-              const argsKey = Object.entries(tc.arguments ?? {}).sort(([a2], [b]) => a2.localeCompare(b)).map(([k, v]) => `${k}=${typeof v === "string" ? v.slice(0, 160) : JSON.stringify(v).slice(0, 160)}`).join(",");
+              const argsKey = this._buildExactArgsKey(tc.arguments ?? {});
               toolCallLog.push({ name: tc.name, argsKey, turn, timestampMs: Date.now() });
               const _toolLogTailIdx = toolCallLog.length - 1;
               this._toolLastUsedTurn.set(tc.name, turn);
@@ -531358,8 +531584,8 @@ ${memoryLines.join("\n")}`
               const REG61_BYPASS_TOOLS = /* @__PURE__ */ new Set([
                 ...REG61_EDIT_TOOLS,
                 // Escape hatches: explicitly allowed while gate is active so
-                // the agent can: search for unknown info (web_search), exit
-                // cleanly (task_complete), or escalate to human (ask_user).
+                // the agent can exit cleanly (task_complete), escalate to human
+                // (ask_user), or complete an explicit web task without deadlock.
                 // shell, file_read, todo_*, grep_search, list_directory are
                 // NOT in bypass — those are the exact patterns batch528/529
                 // agents used to ignore REG-61.
@@ -531388,6 +531614,7 @@ ${memoryLines.join("\n")}`
                 });
                 const _dbgLoop = this._detectDebugLoop(toolCallLog);
                 const _debugLoopSampleSafe = (_dbgLoop.repeatedSample ?? "").slice(0, 120);
+                const _localFailureNudge = this._renderLocalFailureNudge(turn);
                 const reg61BlockMsg = _dbgLoop.detected ? [
                   `[BLOCKED — REG-61 directive in effect — REG-66 DEBUG-LOOP detected]`,
                   ``,
@@ -531405,10 +531632,11 @@ ${memoryLines.join("\n")}`
                   ``,
                   `Issue EXACTLY ONE of: file_write / file_edit / batch_edit / file_patch on a single concrete change. The edit must actually change disk state; dry-runs and no-ops do not clear this directive.`,
                   ``,
-                  `Allowed bypasses (will not be blocked but will not clear the directive either):`,
-                  `  • web_search    — search the EXACT recurring error string`,
-                  `  • task_complete — exit if you genuinely cannot identify any plausible perturbation`,
-                  `  • ask_user      — escalate to human (if available)`,
+                  _localFailureNudge,
+                  ``,
+                  `Allowed exits (will not be blocked but will not clear the directive either):`,
+                  `  * task_complete - exit if you genuinely cannot identify any plausible local perturbation`,
+                  `  * ask_user      - escalate to human (if available)`,
                   ``,
                   `Once you make a real edit, the directive clears and you'll see the new test result.`
                 ].join("\n") : [
@@ -531422,10 +531650,11 @@ ${memoryLines.join("\n")}`
                   `  • batch_edit   — multiple find/replace edits in one call`,
                   `  • file_patch   — apply a version-checked line-range patch`,
                   ``,
-                  `These tools are also allowed while the directive is active (will not be blocked, will not clear the gate):`,
-                  `  • web_search    — for genuinely-unknown APIs / error strings`,
-                  `  • task_complete — to exit if you cannot make any progress`,
-                  `  • ask_user      — to escalate to human (if available)`,
+                  _localFailureNudge,
+                  ``,
+                  `These exits are also allowed while the directive is active (will not be blocked, will not clear the gate):`,
+                  `  * task_complete - to exit if you cannot make any local progress`,
+                  `  * ask_user      - to escalate to human (if available)`,
                   ``,
                   `Until you issue a creative edit that actually changes disk, ALL of these will be BLOCKED again on every turn: file_read, file_explore, list_directory, grep_search, shell, todo_write, todo_read, memory_read, memory_write, etc. Pick the smallest concrete change that moves work forward.`
                 ].join("\n");
@@ -531541,7 +531770,7 @@ ${memoryLines.join("\n")}`
                 }
                 toolCallBudget.set(tc.name, budgetRemaining - 1);
               }
-              const toolFingerprint = `${tc.name}:${argsKey}`;
+              const toolFingerprint = this._buildToolFingerprint(tc.name, tc.arguments ?? {});
               const baseIsReadLike = ![
                 "file_write",
                 "file_edit",
@@ -532520,22 +532749,19 @@ Respond with EXACTLY this structure before your next tool call:
                 }
                 if (!_prior && !this._opaqueErrorHintInjected.has(_refStem) && _entry.subject == null && (categorizeError(_refErr) === "unknown" || _refErr.length > 100)) {
                   this._opaqueErrorHintInjected.add(_refStem);
-                  const _searchQuery = _entry.wentWrong.replace(/"/g, '\\"').slice(0, 200);
                   pushSoftInjection("system", [
-                    `[OPAQUE ERROR — local diagnostic patterns cannot pinpoint a specific target to verify. Error class is unrecognized or output is substantial enough that external context is likely needed.]`,
+                    `[OPAQUE LOCAL ERROR — local diagnostic patterns cannot yet pinpoint a specific target to verify. Error class is unrecognized or output is substantial enough that a structured local triage step is needed.]`,
                     ``,
                     `Tool: ${tc.name}`,
                     `Error: "${_entry.wentWrong}"`,
                     ``,
-                    `Before attempting a fix or pivoting to a different command, run a web search of the exact error string:`,
-                    ``,
-                    `  web_search({"query": "${_searchQuery}"})`,
+                    `Before attempting a fix or pivoting to a different command, extract one local target from the failure: path, symbol, config key, import name, or failing command. Then inspect or edit only that target.`,
                     ``,
-                    `A 30-second external lookup is more reliable than local guesses for framework/version-specific errors your training data may not cover.`
+                    this._renderLocalFailureNudge(turn)
                   ].join("\n"));
                   this.emit({
                     type: "status",
-                    content: `REG-32 opaque-error nudge fired for stem '${_refStem.slice(0, 60)}' — suggested web_search('${_searchQuery.slice(0, 80)}')`,
+                    content: `REG-32 opaque-error local nudge fired for stem '${_refStem.slice(0, 60)}'`,
                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
                   });
                 }
@@ -532924,11 +533150,7 @@ ${sr.result.output}`;
                   break;
                 const batchFingerprintFirstId = /* @__PURE__ */ new Map();
                 const batchInFlight = /* @__PURE__ */ new Map();
-                const buildBatchFp = (call) => {
-                  const args = call.args ?? {};
-                  const argsKey = Object.entries(args).sort(([a2], [b]) => a2.localeCompare(b)).map(([k, v]) => `${k}=${typeof v === "string" ? v.slice(0, 160) : JSON.stringify(v).slice(0, 160)}`).join(",");
-                  return `${call.name}:${argsKey}`;
-                };
+                const buildBatchFp = (call) => this._buildToolFingerprint(call.name, call.args ?? {});
                 for (const call of batch2.calls) {
                   const fp = buildBatchFp(call);
                   if (!batchFingerprintFirstId.has(fp)) {
@@ -533321,7 +533543,7 @@ You have used ${totalTurns} turns and ${toolCallCount} tool calls so far. The ta
 1. ASSESS: What have you accomplished so far? What specific part remains?
 2. DIAGNOSE: If stuck, what exactly is blocking? Read error output carefully.
 3. PIVOT: If the current approach failed, try a different strategy.
-4. INVESTIGATE: Use grep_search, find_files, web_search to find answers.
+4. INVESTIGATE: Use grep_search, find_files, file_read, and small local test commands to find answers. Use web_search only when the task explicitly depends on external documentation.
 5. SIMPLIFY: Break remaining work into the smallest possible steps.
 6. VERIFY: Run tests/build after EVERY change.
 
@@ -533471,7 +533693,7 @@ Integrate this guidance into your current approach. Continue working on the task
                 if (this.aborted)
                   break;
                 toolCallCount++;
-                const bfArgsKey = Object.entries(tc.arguments ?? {}).sort(([a2], [b]) => a2.localeCompare(b)).map(([k, v]) => `${k}=${typeof v === "string" ? v.slice(0, 160) : JSON.stringify(v).slice(0, 160)}`).join(",");
+                const bfArgsKey = this._buildExactArgsKey(tc.arguments ?? {});
                 toolCallLog.push({ name: tc.name, argsKey: bfArgsKey });
                 this._toolLastUsedTurn.set(tc.name, turn);
                 if (this._contextTree) {
@@ -535049,19 +535271,27 @@ ${trimmedNew}`;
             const succeeded = !isError2;
             const preview = msg.content.slice(0, 80);
             let toolName = "unknown";
+            let toolArgs;
             if (msg.tool_call_id) {
               for (const m2 of recent) {
                 if (m2.tool_calls) {
                   for (const tc of m2.tool_calls) {
                     if (tc.id === msg.tool_call_id) {
                       toolName = tc.function.name;
+                      try {
+                        toolArgs = JSON.parse(tc.function.arguments || "{}");
+                      } catch {
+                        toolArgs = void 0;
+                      }
                     }
                   }
                 }
               }
             }
-            if (!this._littlemanToolOutcomes.some((o2) => o2.turn === turn && o2.tool === toolName)) {
-              this._littlemanToolOutcomes.push({ turn, tool: toolName, succeeded, preview });
+            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({ turn, tool: toolName, argsKey, fingerprint, succeeded, preview });
             }
           }
         }
@@ -535115,14 +535345,14 @@ ${trimmedNew}`;
             args = JSON.parse(tc.function.arguments);
           } catch {
           }
-          const argsKey = name10 === "shell" ? String(args.command ?? "").slice(0, 60) : name10 === "web_fetch" ? String(args.url ?? "").slice(0, 80) : String(args.path ?? args.url ?? args.query ?? "").slice(0, 60);
-          const prior = this._littlemanToolOutcomes.find((o2) => o2.succeeded && o2.tool === name10 && o2.preview.includes(argsKey.slice(0, 30)) && o2.turn < turn);
+          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) {
-            const blockKey = `${name10}:${argsKey}`;
-            this._littlemanRedundantBlocks.add(blockKey);
+            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 similar arguments. Do NOT re-run it. Use the existing result and proceed.`);
+              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.`);
             }
             this.emit({
               type: "status",
@@ -589983,37 +590213,20 @@ async function handleListTools(ctx3) {
       sendJson(res, 200, { data: [], pagination: { limit: 50, offset: 0, total: 0, has_more: false } });
       return true;
     }
-    const classify = mod2.classifyTool;
-    const tools = [];
-    for (const [key, value2] of Object.entries(mod2)) {
-      if (typeof value2 !== "function") continue;
-      const proto = value2.prototype;
-      if (!proto || typeof proto.execute !== "function") continue;
-      let inst = null;
-      try {
-        inst = new value2();
-      } catch {
-        try {
-          inst = new value2(process.cwd());
-        } catch {
-          inst = null;
-        }
+    const buildManifest = mod2.buildToolManifestFromModule;
+    const tools = buildManifest ? buildManifest(mod2, { cwd: process.cwd() }).map((entry) => ({
+      name: entry.name,
+      class: entry.className,
+      description: entry.description ?? "",
+      parameters: entry.parameters ?? null,
+      security: entry.security ?? void 0,
+      default_exposure: entry.defaultExposure,
+      availability: entry.availability,
+      endpoints: {
+        call: `/v1/tools/${encodeURIComponent(entry.name)}/call`,
+        schema: `/v1/tools/${encodeURIComponent(entry.name)}`
       }
-      if (!inst || typeof inst.name !== "string") continue;
-      const name10 = inst.name;
-      const security = classify ? classify(name10) : null;
-      tools.push({
-        name: name10,
-        class: key,
-        description: inst.description ?? "",
-        parameters: inst.parameters ?? null,
-        security: security ?? void 0,
-        endpoints: {
-          call: `/v1/tools/${encodeURIComponent(name10)}/call`,
-          schema: `/v1/tools/${encodeURIComponent(name10)}`
-        }
-      });
-    }
+    })) : [];
     tools.sort((a2, b) => a2.name.localeCompare(b.name));
     const filterCat = url.searchParams.get("category");
     const filterScope = url.searchParams.get("scope");
@@ -590058,26 +590271,8 @@ async function handleGetTool(ctx3, name10) {
       }));
       return true;
     }
-    const classify = mod2.classifyTool;
-    let found = null;
-    for (const [key, value2] of Object.entries(mod2)) {
-      if (typeof value2 !== "function") continue;
-      const proto = value2.prototype;
-      if (!proto || typeof proto.execute !== "function") continue;
-      let inst2 = null;
-      try {
-        inst2 = new value2();
-      } catch {
-        try {
-          inst2 = new value2(process.cwd());
-        } catch {
-          inst2 = null;
-        }
-      }
-      if (!inst2 || inst2.name !== name10) continue;
-      found = { instance: inst2, className: key };
-      break;
-    }
+    const buildManifest = mod2.buildToolManifestFromModule;
+    const found = buildManifest ? buildManifest(mod2, { cwd: process.cwd() }).find((entry) => entry.name === name10) : null;
     if (!found) {
       sendProblem(res, problemDetails({
         type: P.notFound,
@@ -590088,14 +590283,14 @@ async function handleGetTool(ctx3, name10) {
       }));
       return true;
     }
-    const inst = found.instance;
-    const security = classify ? classify(name10) : null;
     const body = {
       name: name10,
       class: found.className,
-      description: inst.description ?? "",
-      parameters: inst.parameters ?? null,
-      security: security ?? void 0,
+      description: found.description ?? "",
+      parameters: found.parameters ?? null,
+      security: found.security ?? void 0,
+      default_exposure: found.defaultExposure,
+      availability: found.availability,
       endpoints: {
         call: `/v1/tools/${encodeURIComponent(name10)}/call`,
         schema: `/v1/tools/${encodeURIComponent(name10)}`