aiden-runtime 4.1.4 → 4.5.0

package/dist/cli/v4/callbacks.js

@@ -19,6 +19,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CliCallbacks = void 0;
+exports.mapBlockerToCard = mapBlockerToCard;
 exports.renderApprovalBox = renderApprovalBox;
 const box_1 = require("./box");
 async function defaultPrompts() {
@@ -45,6 +46,68 @@ const DECISION_CHOICES = [
     { name: 'Deny', value: 'deny' },
 ];
 const KNOWN_TIERS = new Set(['safe', 'caution', 'dangerous']);
+// ── v4.3 Phase 3 — manual-blocker card mapping ────────────────────────────
+/** Best-effort hostname extraction; falls back to the raw URL. */
+function blockerHostname(url) {
+    try {
+        return new URL(url).hostname || url;
+    }
+    catch {
+        return url;
+    }
+}
+/**
+ * Map a BlockerSurface to the existing CapabilityCardData chrome.
+ * Pure helper — same shape per `BlockerKind`, parameterised by the
+ * blocker's URL + optional subtype for the body text. The renderer
+ * (`display.capabilityCard`) handles all rendering chrome; this
+ * function only fills the slots semantically.
+ *
+ * Public for unit tests; chatSession + callbacks consume via the
+ * `renderBlockerCardIfPresent` method below.
+ */
+function mapBlockerToCard(blocker) {
+    const host = blockerHostname(blocker.url);
+    const labels = {
+        captcha: {
+            title: `CAPTCHA challenge at ${host}`,
+            canStill: ['Solve the challenge in the browser tab', 'Cancel this task'],
+            cannot: ['Continue automatically without your action'],
+            fix: `I'll wait — solve the ${blocker.subtype ?? 'CAPTCHA'} challenge and tell me when ready.`,
+        },
+        login: {
+            title: `Sign-in required at ${host}`,
+            canStill: ['Sign in via the browser tab', 'Cancel this task'],
+            cannot: ['Continue without authentication'],
+            fix: `I'll wait — sign in and let me know when done.`,
+        },
+        '2fa': {
+            title: `Two-factor code required at ${host}`,
+            canStill: ['Enter the 2FA code in the browser tab', 'Cancel this task'],
+            cannot: ['Continue without the verification code'],
+            fix: `I'll wait — enter your code and tell me when complete.`,
+        },
+        verification: {
+            title: `Identity verification at ${host}`,
+            canStill: ['Complete the verification in the browser', 'Cancel this task'],
+            cannot: ['Continue without verification'],
+            fix: `I'll wait — finish the verification and tell me when done.`,
+        },
+        consent: {
+            title: `Consent banner at ${host}`,
+            canStill: ['Dismiss the banner in the browser', 'Continue if banner is dismissable'],
+            cannot: ['Reliably interact with content while the banner blocks it'],
+            fix: `Dismiss the cookie or privacy banner and I'll retry.`,
+        },
+    };
+    const t = labels[blocker.kind];
+    return {
+        title: `🛑 ${t.title}`,
+        canStill: t.canStill,
+        cannotReliably: t.cannot,
+        fix: t.fix,
+    };
+}
 function parseRiskTier(content) {
     const head = content.trim().toLowerCase().split(/\s+/)[0] ?? '';
     // Strip punctuation that might bleed in from JSON: "safe.", "caution,"...
@@ -63,6 +126,29 @@ class CliCallbacks {
         this.toolRows = new Map();
         this.toolStartTimes = new Map();
         this.firstToolFiredThisTurn = false;
+        // v4.1.5 Issue K — `firePhaseVerb` is the public entry point for the
+        // AidenCLI bridge. AidenAgent fires `onMemoryRefreshStart` etc.,
+        // aidenCLI's adapter calls into one of these `onPhase…` shims, each
+        // mapping a lifecycle event to a verb string. Defensive try/catch so
+        // a misbehaving display sink can't unwind the agent loop.
+        this.onMemoryRefreshStart = () => {
+            try {
+                this.phaseVerbHook?.('refreshing memory');
+            }
+            catch { /* defensive */ }
+        };
+        this.onPromptBuilt = (_info) => {
+            try {
+                this.phaseVerbHook?.('preparing prompt');
+            }
+            catch { /* defensive */ }
+        };
+        this.onProviderRequestStart = (_providerId) => {
+            try {
+                this.phaseVerbHook?.('calling provider');
+            }
+            catch { /* defensive */ }
+        };
         /**
          * Phase 23.5 — bound to AidenAgent.onToolCall. Emits one event row
          * per tool call: prints `[running]` on `before`, mutates the bracket
@@ -91,6 +177,14 @@ class CliCallbacks {
                     this.beforeToolHook?.();
                 }
                 catch { /* defensive */ }
+                // v4.1.5+ Path A — fire the loop-trace sink BEFORE row writes.
+                // Captures every tool's call.id + name (including hidden ones
+                // suppressed from the visible trail) so the trace covers the
+                // full agent loop, not just user-visible work.
+                try {
+                    this.toolTraceBeforeHook?.(call.id, call.name);
+                }
+                catch { /* defensive */ }
                 const handle = this.display.toolRow(call.name, call.arguments);
                 this.toolRows.set(call.id, handle);
                 this.toolStartTimes.set(call.id, Date.now());
@@ -109,14 +203,38 @@ class CliCallbacks {
                     this.afterEachToolHook?.(call.name);
                 }
                 catch { /* defensive */ }
+                // v4.1.5+ Path A — loop-trace sink fires even when handle was
+                // lost (rare; happens if before/after pairing slipped) so the
+                // trace never under-counts tool calls.
+                try {
+                    this.toolTraceAfterHook?.(call.id, call.name, call.arguments);
+                }
+                catch { /* defensive */ }
                 return;
             }
             const ms = Date.now() - startedAt;
             const err = result?.error;
             if (typeof err === 'string' && err.includes('URL provenance gate')) {
                 handle.blocked();
+                // v4.1.5+ Path A — blocked path still needs the trace sink so
+                // the URL-provenance failure mode shows up in loop diagnostics.
+                try {
+                    this.toolTraceAfterHook?.(call.id, call.name, call.arguments);
+                }
+                catch { /* defensive */ }
                 return;
             }
+            // v4.3 Phase 3 — render a structured "agent needs human help"
+            // card when the browser observer detected a manual blocker
+            // (CAPTCHA / login / 2FA / verification / consent). Renders for
+            // ALL trail-row outcomes below — the blocker is independent of
+            // the tool's own success/fail signal. Inline placement gives
+            // the user immediate awareness; the model's next reply will
+            // explain in prose. Defensive: missing fields silently skip.
+            try {
+                this.renderBlockerCardIfPresent(result);
+            }
+            catch { /* defensive */ }
             // v4.1.4 reply-quality polish — Part 1.6. Helper used by ALL
             // outcome branches below so the activity indicator gets re-armed
             // for the gap that follows this tool (next tool, or final reply).
@@ -127,6 +245,14 @@ class CliCallbacks {
                     this.afterEachToolHook?.(call.name);
                 }
                 catch { /* defensive */ }
+                // v4.1.5+ Path A — also fire the loop-trace `after` sink so the
+                // tracer can compute duration + capture args (hidden-from-trail
+                // tools still flow through here, by design — the trace must see
+                // them to detect lookup_tool_schema / skill_view loops).
+                try {
+                    this.toolTraceAfterHook?.(call.id, call.name, call.arguments);
+                }
+                catch { /* defensive */ }
             };
             if (typeof err === 'string' && err.includes('URL provenance gate')) {
                 handle.blocked();
@@ -301,12 +427,84 @@ Reply with ONE word: safe, caution, or dangerous.`;
             const label = files.length > 0 ? files.join(', ') : 'none';
             this.display.dim(`[memory] refreshed system prompt (${label})`);
         };
+        /**
+         * v4.1.6 Polish 2 — post-turn skill-proposal handler.
+         *
+         * chatSession calls this AFTER `agentTurn` has rendered the agent's
+         * reply on screen. Internally:
+         *   1. Reuses `promptSkillProposal` (the existing inquirer modal)
+         *      to ask the user "Save this as a reusable skill? Yes/No".
+         *   2. If accepted AND a SkillTeacher reference is wired, calls
+         *      `skillTeacher.handleProposal({...skipPrompt})` to build
+         *      the markdown + persist via skillManager.
+         *   3. Returns the result so chatSession can surface a confirmation
+         *      line if needed.
+         *
+         * Decoupled from the agent's `runConversation` so the inquirer no
+         * longer fires mid-turn (the v4.1.5 visual-smoke regression).
+         *
+         * Defensive — exceptions in any step return `{created: false,
+         * reason: 'error'}` so a misbehaving prompt or save can't break
+         * the chat loop. The inquirer modal itself catches input-stream
+         * exceptions via the existing try/catch in promptSkillProposal.
+         */
+        this.handleSkillProposal = async (proposal) => {
+            // Step 1: ask the user (reuses existing modal).
+            let accept;
+            try {
+                accept = await this.promptSkillProposal(proposal);
+            }
+            catch {
+                return { created: false, reason: 'prompt_error' };
+            }
+            if (!accept) {
+                return { created: false, reason: 'declined' };
+            }
+            // Step 2: persist via SkillTeacher when available. Test harnesses
+            // that don't wire a teacher just get the prompt without the save.
+            if (!this.skillTeacher) {
+                return { created: false, reason: 'no_skill_teacher_wired' };
+            }
+            try {
+                // Pass `promptUser: undefined` to bypass the modal in
+                // `handleProposal` (we already showed it above). The teacher
+                // sees tier === 'tier_3_propose' WITHOUT a prompt callback,
+                // which it interprets as `no_prompt_callback` and skips the
+                // save — so we need to call the create branch directly.
+                //
+                // SkillTeacher's tier-4 (auto) branch creates without
+                // prompting; we reuse that path by passing a stub that always
+                // returns true (user already accepted above).
+                const result = await this.skillTeacher.handleProposal(proposal, {
+                    promptUser: async () => true,
+                });
+                return result;
+            }
+            catch (err) {
+                return {
+                    created: false,
+                    reason: `create_failed: ${err instanceof Error ? err.message : String(err)}`,
+                };
+            }
+        };
         this.display = opts.display;
         this.auxiliaryClient = opts.auxiliaryClient;
         this.verboseMode = opts.verboseMode ?? 'normal';
         this.promptsPromise = opts.promptModule
             ? Promise.resolve(opts.promptModule)
             : defaultPrompts();
+        this.skillTeacher = opts.skillTeacher;
+    }
+    /**
+     * v4.1.6 Polish 2 — late-wire the SkillTeacher reference. aidenCLI
+     * constructs CliCallbacks early (the approval engine needs it
+     * stitched in), but SkillTeacher is built later in the boot
+     * sequence after skillLoader / skillManager are ready. Call this
+     * once after both exist so `handleSkillProposal` can persist
+     * accepted proposals.
+     */
+    setSkillTeacher(teacher) {
+        this.skillTeacher = teacher;
     }
     /** Update verbose mode at runtime (wired to /verbose). */
     setVerboseMode(mode) {
@@ -337,6 +535,56 @@ Reply with ONE word: safe, caution, or dangerous.`;
         this.beforeToolHook = opts.beforeTool;
         this.afterEachToolHook = opts.afterEachTool;
     }
+    /**
+     * v4.1.5 Issue K — set/clear the phase-verb sink. chatSession
+     * registers a closure that captures the per-turn indicator handle
+     * and forwards calls to `indicator.setVerb(verb)`. Cleared between
+     * turns by passing `undefined`. Optional — non-indicator callers
+     * (test harnesses with stub displays) get no-op behaviour.
+     */
+    setPhaseVerbHook(fn) {
+        this.phaseVerbHook = fn;
+    }
+    /**
+     * v4.1.5+ Path A — register a per-turn tool-trace sink for the
+     * loop-trace logger. `before` fires with the call's id+name BEFORE
+     * the row writes; `after` fires post-execution with the same id +
+     * the call's args (for skill-name extraction in trace context).
+     * Cleared between turns by passing `undefined`.
+     *
+     * Separate from `setActivityIndicatorHooks` because the activity
+     * hook is name-only and fires for visible-trail purposes; this
+     * one captures FULL call data including hidden tools (which the
+     * trail suppresses via TRAIL_HIDE_TOOLS but the trace must see).
+     */
+    setToolTraceHook(opts) {
+        this.toolTraceBeforeHook = opts.before;
+        this.toolTraceAfterHook = opts.after;
+    }
+    /**
+     * v4.3 Phase 3 — render a manual-blocker card when the browser
+     * observer detected a CAPTCHA / login / 2FA / verification /
+     * consent surface on the page. Reuses the existing capabilityCard
+     * chrome via a `mapBlockerToCard` semantic mapping — no new layout
+     * code, no new dedicated card component.
+     *
+     * Defensive: silently skips when the field shape doesn't match
+     * (no browserState, no blocker, unrecognised kind). Never throws
+     * — caller wraps in try/catch defensively.
+     *
+     * The blocker info is structural data emitted by the observer
+     * HOC (`tools/v4/browser/_observer.ts`); the renderer reads it
+     * from `result.result.browserState.blocker` after every browser
+     * tool call. Inline placement gives users immediate awareness
+     * before the model's next reply lands.
+     */
+    renderBlockerCardIfPresent(result) {
+        const inner = (result?.result ?? null);
+        const blocker = inner?.browserState?.blocker;
+        if (!blocker)
+            return;
+        this.display.capabilityCard(mapBlockerToCard(blocker));
+    }
 }
 exports.CliCallbacks = CliCallbacks;
 // Tier-3.1 (v4.1-tier3.1): replaced 🟢/🟡/🔴 emoji badges with