aiden-runtime 4.1.4 → 4.1.5

package/dist/core/v4/loopTrace.js

@@ -0,0 +1,257 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/loopTrace.ts — Phase v4.1.5+ Path A.
+ *
+ * Env-var-gated per-turn audit log for diagnosing tool-call loops
+ * (the user-reported "30+ skill_view calls in 0ms each" failure mode
+ * from v4.1.5 visual smoke). Default OFF — adds zero overhead when
+ * `AIDEN_DEBUG_LOOP !== '1'`.
+ *
+ * When enabled, captures:
+ *   - Full tool-call sequence (name, args, timing) for the turn
+ *   - Assembled system prompt at turn start
+ *   - MEMORY.md + USER.md content hashes (sha256, first 12 hex)
+ *   - Recent skills list (last 10 `skill_view` calls)
+ *   - Conversation history snapshot (last 5 turns)
+ *
+ * Auto-writes to `<paths.logsDir>/loop-trace-{ISO-timestamp}.json` at
+ * turn end IF the turn triggered loop detection (10+ tool calls OR
+ * 5+ consecutive same-name). Quiet otherwise — non-loop turns don't
+ * spam the logs directory.
+ *
+ * A/B harness reproduction lesson: the original 30+ loop the user
+ * observed could not be reproduced with a fresh `[system, user]`
+ * history (see `scripts/smoke-prompt-bias-ab.ts` results). The loop
+ * is either stochastic gpt-5.5 behaviour, history-poisoning from
+ * prior turns, or MEMORY/USER context-specific. This logger captures
+ * the EXACT context next time the loop happens in live use so we
+ * can A/B against the real failure case.
+ *
+ * Pure module — no Display dependency, no event-emitter, no side
+ * effects beyond the gated file write. Safe to import from anywhere.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoopTracer = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const node_crypto_1 = __importDefault(require("node:crypto"));
+// ── Tracer ──────────────────────────────────────────────────────────────────
+const ARGS_CAP = 200;
+const HISTORY_TAIL_DEPTH = 5;
+const RECENT_SKILLS_MAX = 10;
+/**
+ * Tracks tool calls for one turn. Construct fresh per turn (the
+ * counters and recent-skills list are turn-scoped). Idempotent
+ * `finalize()` — multiple calls produce one file at most.
+ */
+class LoopTracer {
+    constructor(rawOpts) {
+        this.systemPrompt = '';
+        this.history = [];
+        this.toolStart = new Map();
+        this.sequence = [];
+        this.lastName = null;
+        this.consecSame = 0;
+        this.maxConsec = 0;
+        this.warnFired = false;
+        this.finalized = false;
+        this.recentSkills = [];
+        this.enabled = rawOpts.enabled ?? (process.env.AIDEN_DEBUG_LOOP === '1');
+        this.opts = {
+            paths: rawOpts.paths,
+            providerId: rawOpts.providerId,
+            modelId: rawOpts.modelId,
+            enabled: this.enabled,
+            toolCountThreshold: rawOpts.toolCountThreshold ?? 10,
+            consecSameThreshold: rawOpts.consecSameThreshold ?? 5,
+            warnConsecThreshold: rawOpts.warnConsecThreshold ?? 8,
+            onLoopWarning: rawOpts.onLoopWarning ?? (() => { }),
+        };
+    }
+    isEnabled() { return this.enabled; }
+    /**
+     * Set the assembled system prompt for this turn. Called once at turn
+     * start (before any tool calls). Stored verbatim; no truncation.
+     */
+    setSystemPrompt(prompt) {
+        if (!this.enabled)
+            return;
+        this.systemPrompt = prompt;
+    }
+    /**
+     * Set the turn's conversation history snapshot. The tracer keeps
+     * only the last `HISTORY_TAIL_DEPTH` messages on finalize.
+     */
+    setHistory(messages) {
+        if (!this.enabled)
+            return;
+        this.history = messages;
+    }
+    /**
+     * Record the start of a tool call. Pair with `endTool(id, name)` to
+     * capture the duration. Caller must pass a stable `id` (the tool
+     * call request id) so before/after pairs find each other.
+     */
+    startTool(id, _name) {
+        if (!this.enabled)
+            return;
+        this.toolStart.set(id, Date.now());
+    }
+    /**
+     * Record the end of a tool call. Computes duration from the matching
+     * `startTool` call. Updates consec-same counter; fires the live
+     * warning when threshold crosses.
+     */
+    endTool(id, name, args) {
+        if (!this.enabled)
+            return;
+        const start = this.toolStart.get(id);
+        this.toolStart.delete(id);
+        const durationMs = start === undefined ? 0 : (Date.now() - start);
+        let argsPreview;
+        try {
+            argsPreview = JSON.stringify(args ?? {});
+        }
+        catch {
+            argsPreview = String(args);
+        }
+        if (argsPreview.length > ARGS_CAP)
+            argsPreview = `${argsPreview.slice(0, ARGS_CAP - 1)}…`;
+        this.sequence.push({
+            name, argsPreview, durationMs,
+            ts: new Date().toISOString(),
+        });
+        // Consec-same accounting.
+        if (name === this.lastName) {
+            this.consecSame += 1;
+        }
+        else {
+            this.consecSame = 1;
+            this.lastName = name;
+        }
+        if (this.consecSame > this.maxConsec)
+            this.maxConsec = this.consecSame;
+        // Skill-view tracking (separate from sequence for quick reference).
+        if (name === 'skill_view' || name === 'lookup_tool_schema') {
+            const tk = args;
+            const target = tk?.name ?? tk?.toolName ?? '(unknown)';
+            this.recentSkills.push(target);
+            if (this.recentSkills.length > RECENT_SKILLS_MAX) {
+                this.recentSkills = this.recentSkills.slice(-RECENT_SKILLS_MAX);
+            }
+        }
+        // Live warning at the loud threshold.
+        if (!this.warnFired && this.consecSame >= this.opts.warnConsecThreshold) {
+            this.warnFired = true;
+            try {
+                this.opts.onLoopWarning(`[loop] same tool '${name}' called ${this.consecSame}× — Ctrl+C to interrupt`);
+            }
+            catch { /* defensive */ }
+        }
+    }
+    /**
+     * Compute whether a snapshot would be written if `finalize()` ran
+     * now. Useful for tests + the live warning path. Pure read.
+     */
+    shouldEmit() {
+        if (!this.enabled)
+            return false;
+        return (this.sequence.length >= this.opts.toolCountThreshold ||
+            this.maxConsec >= this.opts.consecSameThreshold);
+    }
+    /**
+     * Write the trace to disk if thresholds tripped. Idempotent —
+     * subsequent calls are no-ops. Returns the snapshot path or `null`
+     * if nothing was written.
+     */
+    async finalize() {
+        if (this.finalized)
+            return null;
+        this.finalized = true;
+        if (!this.enabled)
+            return null;
+        if (!this.shouldEmit())
+            return null;
+        const snapshot = await this.buildSnapshot();
+        const ts = snapshot.capturedAt.replace(/[:.]/g, '-');
+        const filename = `loop-trace-${ts}.json`;
+        const filePath = node_path_1.default.join(this.opts.paths.logsDir, filename);
+        try {
+            await node_fs_1.promises.mkdir(this.opts.paths.logsDir, { recursive: true });
+            await node_fs_1.promises.writeFile(filePath, JSON.stringify(snapshot, null, 2), 'utf8');
+            return filePath;
+        }
+        catch {
+            // Diagnostic logging must never break the turn. Silently swallow
+            // write failures — power user with AIDEN_DEBUG_LOOP=1 will notice
+            // missing files and can re-run with stricter perms if needed.
+            return null;
+        }
+    }
+    /** Test-accessor: synchronous read of the current consec-same state. */
+    getMaxConsecutive() { return this.maxConsec; }
+    /** Test-accessor: tool call count so far. */
+    getToolCount() { return this.sequence.length; }
+    // ── Internals ────────────────────────────────────────────────────────────
+    async buildSnapshot() {
+        const reason = this.maxConsec >= this.opts.consecSameThreshold
+            ? (this.sequence.length >= this.opts.toolCountThreshold
+                ? 'consecutive_same'
+                : 'consecutive_same')
+            : 'tool_count';
+        const memoryMdHash = await hashFileFirst12(this.opts.paths.memoryMd);
+        const userMdHash = await hashFileFirst12(this.opts.paths.userMd);
+        const historyTail = this.history.slice(-HISTORY_TAIL_DEPTH).map((m) => ({
+            role: m.role,
+            contentPreview: trunc(typeof m.content === 'string' ? m.content : JSON.stringify(m.content), 300),
+        }));
+        return {
+            schemaVersion: 1,
+            capturedAt: new Date().toISOString(),
+            reason,
+            toolCallCount: this.sequence.length,
+            maxConsecSame: this.maxConsec,
+            consecSameName: this.maxConsec >= 2 ? this.lastName : null,
+            toolSequence: this.sequence,
+            systemPrompt: this.systemPrompt,
+            memoryMdHash,
+            userMdHash,
+            recentSkills: this.recentSkills,
+            historyTail,
+            envHints: {
+                provider: this.opts.providerId,
+                model: this.opts.modelId,
+            },
+        };
+    }
+}
+exports.LoopTracer = LoopTracer;
+// ── Helpers ─────────────────────────────────────────────────────────────────
+/**
+ * Read a file and return the sha256 hash, first 12 hex chars.
+ * Returns `null` if the file is missing or unreadable. Pure-async.
+ * 12 hex is enough collision resistance for context-fingerprinting
+ * without bloating the trace file with full 64-char hashes.
+ */
+async function hashFileFirst12(filePath) {
+    try {
+        const content = await node_fs_1.promises.readFile(filePath, 'utf8');
+        const hash = node_crypto_1.default.createHash('sha256').update(content).digest('hex');
+        return hash.slice(0, 12);
+    }
+    catch {
+        return null;
+    }
+}
+function trunc(s, n) {
+    return s.length <= n ? s : `${s.slice(0, n - 1)}…`;
+}

package/dist/core/version.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 // AUTO-GENERATED by scripts/inject-version.js — do not edit by hand
-exports.VERSION = '4.1.4';
+exports.VERSION = '4.1.5';

package/dist/core/webSearch.js

@@ -7,6 +7,46 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.reliableWebSearch = reliableWebSearch;
 exports.deepResearch = deepResearch;
 exports.checkSearxNG = checkSearxNG;
+// core/webSearch.ts — Reliable web search with 4-method fallback chain
+//
+// Priority order:
+//   1. SearxNG (self-hosted, unlimited, Docker on port 8888)
+//   2. Brave Search API (if BRAVE_SEARCH_API_KEY env var set)
+//   3. DuckDuckGo Instant Answer API + HTML scrape
+//   4. Wikipedia (always available, good for factual queries)
+//
+// Usage:
+//   import { reliableWebSearch, deepResearch } from './webSearch'
+//   const result = await reliableWebSearch('query')
+// ── Debug logging (v4.1.5 Issue O) ────────────────────────────
+//
+// All `[webSearch]` / `[deepResearch]` chatter goes through these two
+// helpers, both gated on `process.env.AIDEN_DEBUG_WEB === '1'`. The
+// v4 REPL ran with these blasting unconditionally to stdout/stderr,
+// surfacing 20+ lines of fallback-chain diagnostics between the user
+// prompt and Aiden's reply on any web-search turn — overwhelming the
+// signal users actually wanted (the tool-trail row).
+//
+// Power users debugging a flaky search backend export the env var:
+//     AIDEN_DEBUG_WEB=1 aiden
+// Same pattern as `AIDEN_NO_REFORMAT`, `AIDEN_UI_ICONS`. Default off.
+//
+// `core/webSearch.ts` is shared with the legacy v3 path which has no
+// Display dependency, so we cannot route through `display.dim()` /
+// the v4 verbose-mode config. An env var is the lowest-friction
+// transport that works in both paths.
+function debugLog(...args) {
+    if (process.env.AIDEN_DEBUG_WEB === '1') {
+        // eslint-disable-next-line no-console
+        console.log(...args);
+    }
+}
+function debugWarn(...args) {
+    if (process.env.AIDEN_DEBUG_WEB === '1') {
+        // eslint-disable-next-line no-console
+        console.warn(...args);
+    }
+}
 // ── Constants ─────────────────────────────────────────────────
 const SEARXNG_URL = process.env.SEARXNG_URL || 'http://localhost:8888';
 const BRAVE_API_KEY = process.env.BRAVE_SEARCH_API_KEY || '';
@@ -21,7 +61,7 @@ async function searchViaSearxNG(query) {
             signal: AbortSignal.timeout(SEARCH_TIMEOUT),
         });
         if (!res.ok) {
-            console.warn(`[webSearch] SearxNG returned ${res.status}`);
+            debugWarn(`[webSearch] SearxNG returned ${res.status}`);
             return null;
         }
         const data = await res.json();
@@ -35,11 +75,11 @@ async function searchViaSearxNG(query) {
             return null;
         const lines = results.map(r => `**${r.title}**\n${r.snippet}\n${r.url}`);
         const output = `[SearxNG Results for "${query}"]\n\n${lines.join('\n\n')}`;
-        console.log(`[webSearch] SearxNG: ${results.length} results`);
+        debugLog(`[webSearch] SearxNG: ${results.length} results`);
         return { success: true, output, method: 'searxng', results };
     }
     catch (e) {
-        console.warn(`[webSearch] SearxNG failed: ${e.message}`);
+        debugWarn(`[webSearch] SearxNG failed: ${e.message}`);
         return null;
     }
 }
@@ -58,7 +98,7 @@ async function searchViaBrave(query) {
             signal: AbortSignal.timeout(SEARCH_TIMEOUT),
         });
         if (!res.ok) {
-            console.warn(`[webSearch] Brave API returned ${res.status}`);
+            debugWarn(`[webSearch] Brave API returned ${res.status}`);
             return null;
         }
         const data = await res.json();
@@ -73,11 +113,11 @@ async function searchViaBrave(query) {
         }));
         const lines = results.map(r => `**${r.title}**\n${r.snippet}\n${r.url}`);
         const output = `[Brave Search Results for "${query}"]\n\n${lines.join('\n\n')}`;
-        console.log(`[webSearch] Brave: ${results.length} results`);
+        debugLog(`[webSearch] Brave: ${results.length} results`);
         return { success: true, output, method: 'brave', results };
     }
     catch (e) {
-        console.warn(`[webSearch] Brave failed: ${e.message}`);
+        debugWarn(`[webSearch] Brave failed: ${e.message}`);
         return null;
     }
 }
@@ -108,7 +148,7 @@ async function searchViaDDG(query) {
         }
     }
     catch (e) {
-        console.warn(`[webSearch] DDG Instant failed: ${e.message}`);
+        debugWarn(`[webSearch] DDG Instant failed: ${e.message}`);
     }
     // DDG HTML scrape — get snippet text + page content
     try {
@@ -164,12 +204,12 @@ async function searchViaDDG(query) {
             parts.push(...validPages);
     }
     catch (e) {
-        console.warn(`[webSearch] DDG HTML scrape failed: ${e.message}`);
+        debugWarn(`[webSearch] DDG HTML scrape failed: ${e.message}`);
     }
     if (parts.length === 0)
         return null;
     const output = `[DuckDuckGo Results for "${query}"]\n\n${parts.join('\n\n')}`;
-    console.log(`[webSearch] DDG: ${parts.length} sections`);
+    debugLog(`[webSearch] DDG: ${parts.length} sections`);
     return { success: true, output, method: 'ddg' };
 }
 // ── METHOD 4: Wikipedia ───────────────────────────────────────
@@ -193,11 +233,11 @@ async function searchViaWikipedia(query) {
             .filter(s => s.length > 20);
         const extra = snippets.length > 0 ? `\n\nRelated: ${snippets.join(' | ')}` : '';
         const output = `[Wikipedia: ${wiki.title}]\n${wiki.extract.slice(0, 1500)}${extra}`;
-        console.log(`[webSearch] Wikipedia: ${wiki.extract.length} chars for "${wiki.title}"`);
+        debugLog(`[webSearch] Wikipedia: ${wiki.extract.length} chars for "${wiki.title}"`);
         return { success: true, output, method: 'wikipedia' };
     }
     catch (e) {
-        console.warn(`[webSearch] Wikipedia failed: ${e.message}`);
+        debugWarn(`[webSearch] Wikipedia failed: ${e.message}`);
         return null;
     }
 }
@@ -229,11 +269,11 @@ async function fetchWeather(query) {
                 out += `  ${day.date}: High ${day.maxtempC}°C / Low ${day.mintempC}°C${mid ? ' — ' + mid : ''}\n`;
             }
         }
-        console.log(`[webSearch] Weather: retrieved for "${city}"`);
+        debugLog(`[webSearch] Weather: retrieved for "${city}"`);
         return { success: true, output: out.trim(), method: 'wttr.in' };
     }
     catch (e) {
-        console.warn(`[webSearch] Weather failed: ${e.message}`);
+        debugWarn(`[webSearch] Weather failed: ${e.message}`);
         return null;
     }
 }
@@ -241,7 +281,7 @@ async function fetchWeather(query) {
 async function reliableWebSearch(query) {
     if (!query?.trim())
         return { success: false, output: '', error: 'No query provided' };
-    console.log(`[webSearch] Query: "${query}"`);
+    debugLog(`[webSearch] Query: "${query}"`);
     // Weather shortcut
     if (/weather|temperature|forecast|rain|snow|sunny|cloudy|humidity|wind/i.test(query)) {
         const weather = await fetchWeather(query);
@@ -251,28 +291,28 @@ async function reliableWebSearch(query) {
     // Method 1 — SearxNG
     const searxResult = await searchViaSearxNG(query);
     if (searxResult) {
-        console.log(`[webSearch] ✓ SearxNG succeeded`);
+        debugLog(`[webSearch] ✓ SearxNG succeeded`);
         return { success: true, output: searxResult.output.slice(0, 10000) };
     }
     // Method 2 — Brave
     const braveResult = await searchViaBrave(query);
     if (braveResult) {
-        console.log(`[webSearch] ✓ Brave succeeded`);
+        debugLog(`[webSearch] ✓ Brave succeeded`);
         return { success: true, output: braveResult.output.slice(0, 10000) };
     }
     // Method 3 — DDG
     const ddgResult = await searchViaDDG(query);
     if (ddgResult) {
-        console.log(`[webSearch] ✓ DDG succeeded`);
+        debugLog(`[webSearch] ✓ DDG succeeded`);
         return { success: true, output: ddgResult.output.slice(0, 10000) };
     }
     // Method 4 — Wikipedia
     const wikiResult = await searchViaWikipedia(query);
     if (wikiResult) {
-        console.log(`[webSearch] ✓ Wikipedia fallback`);
+        debugLog(`[webSearch] ✓ Wikipedia fallback`);
         return { success: true, output: wikiResult.output };
     }
-    console.warn(`[webSearch] All methods failed for: "${query}"`);
+    debugWarn(`[webSearch] All methods failed for: "${query}"`);
     return {
         success: false,
         output: '',
@@ -283,24 +323,24 @@ async function reliableWebSearch(query) {
 async function deepResearch(topic) {
     if (!topic?.trim())
         return { success: false, output: '', error: 'No topic provided' };
-    console.log(`[deepResearch] Topic: "${topic}"`);
+    debugLog(`[deepResearch] Topic: "${topic}"`);
     const parts = [];
     // Pass 1: Broad
-    console.log(`[deepResearch] Pass 1: broad`);
+    debugLog(`[deepResearch] Pass 1: broad`);
     const broad = await reliableWebSearch(topic);
     if (broad.success && broad.output.length > 100) {
         parts.push(`=== PASS 1: BROAD RESEARCH ===\n${broad.output}`);
     }
     // Pass 2: Latest 2026
     const latestQ = `${topic} 2026 latest`;
-    console.log(`[deepResearch] Pass 2: latest — "${latestQ}"`);
+    debugLog(`[deepResearch] Pass 2: latest — "${latestQ}"`);
     const latest = await reliableWebSearch(latestQ);
     if (latest.success && latest.output.length > 100) {
         parts.push(`=== PASS 2: LATEST (2026) ===\n${latest.output}`);
     }
     // Pass 3: Comparison / review
     const compareQ = `best top ${topic} comparison review`;
-    console.log(`[deepResearch] Pass 3: comparison — "${compareQ}"`);
+    debugLog(`[deepResearch] Pass 3: comparison — "${compareQ}"`);
     const compare = await reliableWebSearch(compareQ);
     if (compare.success && compare.output.length > 100) {
         parts.push(`=== PASS 3: COMPARISON & REVIEWS ===\n${compare.output}`);
@@ -309,7 +349,7 @@ async function deepResearch(topic) {
         return { success: false, output: '', error: `No research results found for: ${topic}` };
     }
     const combined = parts.join('\n\n');
-    console.log(`[deepResearch] Complete: ${combined.length} chars across ${parts.length} passes`);
+    debugLog(`[deepResearch] Complete: ${combined.length} chars across ${parts.length} passes`);
     return { success: true, output: combined.slice(0, 15000) };
 }
 // ── SearxNG health check ──────────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiden-runtime",
-  "version": "4.1.4",
+  "version": "4.1.5",
   "publishConfig": {
     "access": "public"
   },

package/plugins/aiden-plugin-cdp-browser/.granted-permissions.json

@@ -0,0 +1,8 @@
+{
+  "version": 1,
+  "granted": [
+    "browser",
+    "subprocess",
+    "network"
+  ]
+}