aiden-runtime 4.1.5 → 4.6.0

package/dist/cli/v4/display/capabilityCard.js

@@ -67,6 +67,32 @@ function renderCapabilityCard(data, colorize) {
     // Compose the inner rows that boxSharp will wrap. Each row is the
     // CONTENT (no border) — boxSharp adds the side borders + padding.
     const rows = [];
+    // v4.2 Phase 3 — optional "what happened" one-liner above the
+    // canStill section. Rendered as a muted-tone line so it reads as
+    // context, not action. Skipped cleanly when absent → v4.1.3
+    // capability-card behaviour preserved for non-Phase-3 callers.
+    if (data.whatHappened) {
+        rows.push('');
+        rows.push(colorize(truncToContent(data.whatHappened), 'muted'));
+    }
+    // v4.2 Phase 3 — optional failure-category pill row. Each entry
+    // renders as `<category>(<count>)` separated by " · " bullets.
+    // Pre-sorted by the generator (desc count then category priority);
+    // renderer just formats. Skipped cleanly when absent.
+    if (data.failuresByCategory && data.failuresByCategory.length > 0) {
+        const pills = data.failuresByCategory
+            .map((p) => `${p.category}(${p.count})`)
+            .join(' · ');
+        const label = colorize('Failures:', 'error');
+        rows.push(`${label} ${truncToContent(pills)}`);
+    }
+    // v4.3 Phase 5 — optional one-line browser context summary
+    // (active tab, blocker kind, other-tab count, stale-ref retries).
+    // Already pre-formatted by recoveryReport's `buildBrowserContextLine`.
+    // Rendered as a muted-tone line below the Failures: row when present.
+    if (data.browserContext) {
+        rows.push(colorize(truncToContent(data.browserContext), 'muted'));
+    }
     if (data.canStill.length > 0) {
         rows.push('');
         rows.push(heading('Can still:'));

package/dist/cli/v4/display.js

@@ -523,14 +523,21 @@ class Display {
                 return (0, box_1.truncateVisible)(text, INTERIOR);
             return text + ' '.repeat(INTERIOR - v);
         };
+        // v4.5 TUI polish — add a leading + trailing blank line so the
+        // box has visual breathing room from the lines above/below, and
+        // a trailing interior blank so contact info doesn't crowd the
+        // bottom border.
         return [
+            '',
             lidIndent + lid,
             wallIndent + pipe + ' '.repeat(INTERIOR) + pipe,
             wallIndent + pipe + padInner(`   ${heart}  ${val('Built solo')}`) + pipe,
             wallIndent + pipe + padInner(`   ${lab('GitHub:')}  ${val('github.com/taracodlabs/aiden')}`) + pipe,
             wallIndent + pipe + padInner(`   ${lab('Web:')}     ${val('aiden.taracod.com')}`) + pipe,
             wallIndent + pipe + padInner(`   ${lab('Contact:')} ${val('contact@taracod.com')}`) + pipe,
+            wallIndent + pipe + ' '.repeat(INTERIOR) + pipe,
             wallIndent + pipe + lid + pipe,
+            '',
         ].join('\n');
     }
     /**
@@ -929,22 +936,25 @@ class Display {
             }
         };
         const eraseLine = () => {
-            // Walk up to the indicator's row(s) + erase. Cursor lands at
-            // col 0 of the (now empty) verb row. NO trailing newline here:
-            // the caller is about to write content on this row, and
-            // whatever they write will include their own `\n` to flush
-            // the buffer. If we emitted `\n` here, we'd leave a phantom
-            // blank row before the caller's content.
+            // Walk up to the indicator's row(s) + erase, then drop ONE
+            // newline so the cursor lands on a blank line BELOW the
+            // indicator's old footprint. v4.1.6 polish: previous behavior
+            // left the cursor at col 0 of the just-erased row so caller
+            // writes (agentHeader, tool row, etc.) sat tight against where
+            // the indicator had been. v4.1.5 visual smoke flagged the
+            // wave-bar→`┃ Aiden` proximity as feeling cramped. The
+            // trailing `\n` gains one visible blank row of breathing space
+            // AND adds another Windows ConPTY flush trigger (Issue M).
             //
             // v4.1.5 Issue K — with wave bar enabled, walk up 2 rows (two
             // up-1+erase sequences). Without the bar, walk up 1 row.
             if (!isTty || !printed)
                 return;
             if (waveBarEnabled) {
-                out.write(`${ANSI_UP_ERASE}${ANSI_UP_ERASE}`);
+                out.write(`${ANSI_UP_ERASE}${ANSI_UP_ERASE}\n`);
             }
             else {
-                out.write(ANSI_UP_ERASE);
+                out.write(`${ANSI_UP_ERASE}\n`);
             }
         };
         // Initial paint — only on TTY. Indicator + `\n` so the buffer

package/dist/cli/v4/replyRenderer.js

@@ -43,32 +43,38 @@ function paint(kind) {
     return (text) => (0, skinEngine_1.getSkinEngine)().applyColors(text, kind);
 }
 /**
- * v4.1.3-essentials: bold (`**foo**`) markdown emphasis renders as
- * ANSI bold + underline. Previously painted 'brand' (orange) which
- * collided with the heading hierarchy. Briefly tried bold + bright-
- * white; landed on bold + underline because underline carries
- * emphasis without consuming a color slot — the palette stays
- * available for state semantics (yellow=degraded, red=error, etc.).
+ * v4.1.3-essentials → v4.5 TUI polish: bold (`**foo**`) markdown
+ * emphasis renders as plain ANSI bold. Earlier iterations tried
+ * 'brand' (orange, collided with heading hierarchy), bright-white
+ * (low contrast on dark themes), and bold+underline (made bulleted
+ * list items look like clickable hyperlinks — user feedback after
+ * v4.5 Phase 8 stabilisation).
  *
- * ANSI sequence: `\x1b[1m\x1b[4m{text}\x1b[24m\x1b[22m` — bold ON +
- * underline ON, then underline OFF + bold OFF. Reset order matters
- * (underline first, bold second) so the closing codes don't reorder
- * styles surprisingly on terminals that batch SGR updates.
+ * Landed on bold-only: weight carries emphasis, no color slot
+ * consumed, and no underline confusion with terminal URL/path
+ * auto-highlight features.
  *
- * Bypasses the skin system intentionally — bold-as-underline is an
- * opinionated default for this slice. Same caveat as the prior bold-
- * as-color iteration: nested markdown loses the outer style after
- * close (pre-existing limitation of the painter-stack architecture).
+ * ANSI sequence: `\x1b[1m{text}\x1b[22m` — bold ON, bold OFF.
+ *
+ * Bypasses the skin system intentionally — emphasis is an
+ * opinionated default for this slice. Same caveat as the prior
+ * bold-as-color iteration: nested markdown loses the outer style
+ * after close (pre-existing limitation of the painter-stack
+ * architecture).
  *
  * Honors `NO_COLOR=1` per the standard (skips the wrap entirely).
- * Strictly speaking `NO_COLOR` is about color and underline isn't
- * a color, but the wrap still emits ANSI escapes; honoring the env
- * var keeps output paste-safe in scripted contexts.
+ * Strictly speaking `NO_COLOR` is about color, but the wrap still
+ * emits ANSI escapes; honoring the env var keeps output paste-safe
+ * in scripted contexts.
+ *
+ * Function name: `paintEmphasis` rather than `paintBold` because
+ * the latter is already taken by a different (parameterised) helper
+ * below.
  */
-function paintBoldUnderline(text) {
+function paintEmphasis(text) {
     if (process.env.NO_COLOR && process.env.NO_COLOR !== '')
         return text;
-    return `\x1b[1m\x1b[4m${text}\x1b[24m\x1b[22m`;
+    return `\x1b[1m${text}\x1b[22m`;
 }
 /**
  * v4.1.3-essentials reply-polish: bold-on + skin paint + bold-off.
@@ -367,10 +373,12 @@ function getReplyRenderer() {
         hr: () => paint('muted')('─'.repeat((0, frame_1.getBodyWidth)())) + '\n',
         listitem: renderListItem,
         paragraph: (text) => `${text}\n\n`,
-        // v4.1.3-essentials: bold renders as ANSI bold + underline
-        // (was 'brand' / orange, then bright-white; landed on underline
-        // so the color palette stays available for state semantics).
-        strong: paintBoldUnderline,
+        // v4.1.3-essentials → v4.5 TUI polish: bold renders as plain ANSI
+        // bold. Earlier iterations tried orange (collision with headings),
+        // bright-white (low contrast), and bold+underline (made bulleted
+        // **labels** look like clickable links — user feedback after v4.5
+        // Phase 8 stabilisation). Weight alone carries emphasis.
+        strong: paintEmphasis,
         em: paint('muted'),
         // v4.1.3-essentials reply-polish: inline `` `code` `` — strip
         // the literal backticks (used to leak into the visible output)

package/dist/cli/v4/updateBootPrompt.js

@@ -0,0 +1,170 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/updateBootPrompt.ts — v4.5 update system.
+ *
+ * Boxed three-option prompt rendered after the boot card / status
+ * pills, before the bottomPromptHint (Q-U5(b) position). When an
+ * update is available AND not skipped, the user sees:
+ *
+ *   ┌─────────────────────────────────────────────────────────┐
+ *   │  ◆ Aiden 4.5.1 available (you're on 4.5.0)              │
+ *   │                                                         │
+ *   │  What's new: bug fix for IMAP reconnect on Windows      │
+ *   │                                                         │
+ *   │  Update now? (y/n/later)                                │
+ *   │    y       — update now, restart after                  │
+ *   │    n       — skip this version (don't ask again)        │
+ *   │    later   — remind me next session                     │
+ *   └─────────────────────────────────────────────────────────┘
+ *
+ * Behavior (Q-U2(a)):
+ *   - 5-second timeout defaults to 'later' (no state change)
+ *   - 'y' triggers `executeInstall` via the method-aware dispatch
+ *   - 'n' persists `skippedVersion = status.latest` to the cache
+ *   - 'later' is a no-op (re-prompt next session)
+ *
+ * Display sink: writes via the supplied `display`. Keypress capture
+ * uses raw stdin mode so the user can press a single key — no Enter
+ * needed for y/n. 'later' is the timeout default; an explicit 'l'
+ * keypress also maps to it.
+ *
+ * Designed to be skippable: if stdin isn't a TTY (CI / piped /
+ * non-interactive), short-circuits to 'later' immediately so boot
+ * doesn't hang.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderBootUpdateBox = renderBootUpdateBox;
+exports.showBootUpdatePrompt = showBootUpdatePrompt;
+const DEFAULT_TIMEOUT_MS = 5000;
+/**
+ * Pure box renderer — public so tests can assert the rendered shape
+ * without driving stdin.
+ */
+function renderBootUpdateBox(status, method) {
+    const innerWidth = 60;
+    const pad = (s) => {
+        const visible = s.replace(/\x1b\[[0-9;]*[A-Za-z]/g, '');
+        const len = visible.length;
+        if (len >= innerWidth)
+            return s.slice(0, innerWidth);
+        return s + ' '.repeat(innerWidth - len);
+    };
+    const top = '┌' + '─'.repeat(innerWidth) + '┐';
+    const bottom = '└' + '─'.repeat(innerWidth) + '┘';
+    const blank = '│' + ' '.repeat(innerWidth) + '│';
+    const lines = [];
+    lines.push(top);
+    lines.push(blank);
+    lines.push('│' + pad(`  ◆ Aiden ${status.latest} available (you're on ${status.installed})`) + '│');
+    if (status.releaseNotes && status.releaseNotes.length > 0) {
+        lines.push(blank);
+        lines.push('│' + pad(`  What's new: ${status.releaseNotes}`) + '│');
+    }
+    lines.push(blank);
+    lines.push('│' + pad(`  Update now? (y/n/later)`) + '│');
+    lines.push('│' + pad(`    y       — update via ${method.method}`) + '│');
+    lines.push('│' + pad(`    n       — skip ${status.latest} (don't ask again)`) + '│');
+    lines.push('│' + pad(`    later   — remind me next session (default in 5s)`) + '│');
+    lines.push(blank);
+    lines.push(bottom);
+    return lines;
+}
+/**
+ * Show the prompt and resolve with the user's choice. Never throws
+ * — returns 'later' on any error / timeout / non-TTY.
+ */
+async function showBootUpdatePrompt(input) {
+    // Test seam — short-circuit before any I/O.
+    if (input._testChoice)
+        return input._testChoice;
+    const isTTY = input.isTTY ?? Boolean(input.stdin?.isTTY ?? process.stdin.isTTY);
+    // Non-interactive stdin → silently default to 'later'. Boot must
+    // not hang in CI / piped contexts.
+    if (!isTTY)
+        return 'later';
+    if (!input.status.updateAvailable || !input.status.latest)
+        return 'later';
+    if (input.status.skipped)
+        return 'later';
+    // Render the box.
+    for (const line of renderBootUpdateBox(input.status, input.method)) {
+        input.display.write(line + '\n');
+    }
+    const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const stdin = input.stdin ?? process.stdin;
+    return await captureSingleKey(stdin, timeoutMs);
+}
+/**
+ * Read ONE keypress from stdin in raw mode. Maps:
+ *   - 'y' / 'Y' → 'install'
+ *   - 'n' / 'N' → 'skip'
+ *   - 'l' / 'L' / Enter / any other key → 'later'
+ *   - Timeout                          → 'later'
+ *
+ * Restores stdin's prior pause/resume + rawMode state so the
+ * subsequent REPL prompt isn't broken.
+ */
+function captureSingleKey(stdin, timeoutMs) {
+    return new Promise((resolve) => {
+        let done = false;
+        const wasRaw = stdin.isRaw === true;
+        const wasPaused = stdin.isPaused();
+        const cleanup = () => {
+            if (done)
+                return;
+            done = true;
+            try {
+                stdin.removeListener('data', onData);
+            }
+            catch { /* noop */ }
+            try {
+                if (!wasRaw && stdin.setRawMode)
+                    stdin.setRawMode(false);
+            }
+            catch { /* noop */ }
+            if (wasPaused)
+                try {
+                    stdin.pause();
+                }
+                catch { /* noop */ }
+            clearTimeout(timer);
+        };
+        const onData = (chunk) => {
+            const raw = chunk.toString();
+            const ch = raw.length > 0 ? raw[0].toLowerCase() : '';
+            let choice;
+            if (ch === 'y')
+                choice = 'install';
+            else if (ch === 'n')
+                choice = 'skip';
+            else
+                choice = 'later';
+            cleanup();
+            resolve(choice);
+        };
+        try {
+            if (stdin.setRawMode && !wasRaw)
+                stdin.setRawMode(true);
+            if (wasPaused)
+                stdin.resume();
+            stdin.on('data', onData);
+        }
+        catch {
+            cleanup();
+            resolve('later');
+            return;
+        }
+        const timer = setTimeout(() => {
+            cleanup();
+            resolve('later');
+        }, timeoutMs);
+        if (typeof timer.unref === 'function')
+            timer.unref();
+    });
+}

package/dist/core/playwrightBridge.js

@@ -58,11 +58,14 @@ exports.pwClickFirstResult = pwClickFirstResult;
 exports.pwType = pwType;
 exports.pwScroll = pwScroll;
 exports.pwSnapshot = pwSnapshot;
+exports.pwSnapshotHash = pwSnapshotHash;
+exports.pwSnapshotTabs = pwSnapshotTabs;
 exports.pwGetUrl = pwGetUrl;
 exports.pwClose = pwClose;
 exports.getActiveBrowserPage = getActiveBrowserPage;
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
+const crypto_1 = __importDefault(require("crypto"));
 const paths_1 = require("./paths");
 // ── Lazy-import Playwright so the server boots even if playwright
 //    is not installed (tools will return a clear error message).
@@ -410,6 +413,132 @@ async function pwSnapshot() {
         return { ok: false, error: e.message };
     }
 }
+/**
+ * v4.3 Phase 1 — structured page-state snapshot used by the BrowserState
+ * observer. Captures URL + title + body-text hash + recursive iframe-tree
+ * hash in a single in-page evaluate. Truncates body innerText to 5 000
+ * chars before hashing so cost stays bounded for large pages.
+ *
+ * Cross-origin iframe srcs are surfaced (URL is visible); attempting to
+ * read `iframe.contentDocument` on a cross-origin frame throws — the
+ * recursive walker catches and skips, recording only the iframe's src.
+ *
+ * Returns `ok: false` when the browser is closed or evaluate fails.
+ * Caller (BrowserState.captureState) treats `ok: false` as "snapshot
+ * unavailable, embed no sidecar this call".
+ */
+async function pwSnapshotHash() {
+    try {
+        const page = await ensurePage();
+        const url = page.url();
+        const title = await page.title();
+        // eslint-disable-next-line no-undef
+        const data = await page.evaluate(() => {
+            const doc = globalThis.document;
+            const text = (doc?.body?.innerText ?? '');
+            // Recursive iframe URL walk. Cross-origin iframes throw on
+            // contentDocument access — catch and record just the src.
+            const urls = [];
+            function walk(d) {
+                try {
+                    const iframes = Array.from(d.querySelectorAll('iframe'));
+                    for (const f of iframes) {
+                        urls.push(String(f.src ?? ''));
+                        try {
+                            if (f.contentDocument)
+                                walk(f.contentDocument);
+                        }
+                        catch { /* cross-origin */ }
+                    }
+                }
+                catch { /* defensive */ }
+            }
+            walk(doc);
+            return { text, frame_urls: urls.join('|') };
+        });
+        const dom_text_hash = crypto_1.default.createHash('sha256').update(data.text.slice(0, 5000)).digest('hex');
+        const frame_tree_hash = crypto_1.default.createHash('sha256').update(data.frame_urls).digest('hex');
+        return { ok: true, url, title, dom_text_hash, frame_tree_hash };
+    }
+    catch (e) {
+        return { ok: false, error: e.message };
+    }
+}
+// ── v4.3 Phase 4 — multi-tab snapshot ─────────────────────────────────────
+//
+// Persistent context can hold many pages (target=_blank, window.open,
+// CDP popups). Aiden's tools still target `_activePage` only — Phase 4
+// is DATA-ONLY: it records what tabs exist, who opened whom, and which
+// is the active one, so v4.4+ cross-tab orchestration has a foundation.
+//
+// `_tabIdMap` is a WeakMap that assigns each observed Page a stable
+// `tab_id` (`tab-1`, `tab-2`, ...). When a Page closes, Playwright drops
+// its reference and the WeakMap entry GCs naturally — no manual cleanup.
+const _tabIdMap = new WeakMap();
+let _nextTabIdCounter = 0;
+function getOrAssignTabId(page) {
+    let id = _tabIdMap.get(page);
+    if (!id) {
+        _nextTabIdCounter += 1;
+        id = `tab-${_nextTabIdCounter}`;
+        _tabIdMap.set(page, id);
+    }
+    return id;
+}
+/**
+ * v4.3 Phase 4 — enumerate all pages in the persistent context and
+ * return their wire-data form. Stable `tab_id` per Page via the
+ * `_tabIdMap` WeakMap. The opener Page is looked up the same way, so
+ * `opener_id` is stable across reconciliations as long as the parent
+ * still exists.
+ *
+ * Cheap — `context.pages()` is in-process; the per-page work is one
+ * `url()` getter and one async `title()` call. Total cost scales
+ * linearly with the number of tabs; for typical sessions (1-5 tabs)
+ * it's well under 50ms.
+ *
+ * Returns `ok: false` when the browser is closed. Caller (BrowserState
+ * .reconcileTabs) treats `ok: false` as "no reconciliation this cycle".
+ */
+async function pwSnapshotTabs() {
+    try {
+        const ctx = await ensureContext();
+        const pages = ctx.pages();
+        const tabs = [];
+        for (const p of pages) {
+            // Skip pages already closed mid-walk (rare race).
+            if (typeof p.isClosed === 'function' && p.isClosed())
+                continue;
+            const tab_id = getOrAssignTabId(p);
+            const url = (typeof p.url === 'function') ? p.url() : '';
+            // title() can throw if the page navigated mid-walk; default to empty.
+            let title = '';
+            try {
+                title = await p.title();
+            }
+            catch { /* defensive */ }
+            // opener() returns the parent Page (or null). Same WeakMap lookup.
+            let opener_id = null;
+            try {
+                const opener = typeof p.opener === 'function' ? await p.opener() : null;
+                if (opener)
+                    opener_id = _tabIdMap.get(opener) ?? null;
+            }
+            catch { /* defensive */ }
+            tabs.push({
+                tab_id,
+                url,
+                title,
+                is_active: p === _activePage,
+                opener_id,
+            });
+        }
+        return { ok: true, tabs };
+    }
+    catch (e) {
+        return { ok: false, error: e.message };
+    }
+}
 /** Return the URL currently loaded in the active browser page. */
 async function pwGetUrl() {
     try {