aiden-runtime 4.1.3 → 4.1.5

package/dist/cli/v4/replyRenderer.js

@@ -27,10 +27,16 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getReplyRenderer = getReplyRenderer;
+exports.normalizeBlankLines = normalizeBlankLines;
 exports._resetForTests = _resetForTests;
 const marked_1 = require("marked");
 const skinEngine_1 = require("./skinEngine");
 const syntaxHighlight_1 = require("./syntaxHighlight");
+// v4.1.4 reply-quality polish: single source of truth for frame math.
+// Replaces 3 inline `Math.min(process.stdout.columns ?? 80, 100) - 4`
+// callsites in this file with `getBodyWidth()` and adds soft-wrap for
+// code-block lines that previously overflowed the viewport.
+const frame_1 = require("./display/frame");
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const TerminalRenderer = require('marked-terminal').default ?? require('marked-terminal');
 function paint(kind) {
@@ -120,7 +126,11 @@ const CODE_BG_ON = '\x1b[48;2;50;50;60m';
 const CODE_BG_OFF = '\x1b[49m';
 function renderCodeBlock(code, lang) {
     const sk = (0, skinEngine_1.getSkinEngine)();
-    const width = Math.min(process.stdout.columns ?? 80, 100) - 4;
+    // v4.1.4 reply-quality polish: width sourced from frame.ts. Same
+    // visual budget as the v4.1.3 formula (cols capped at 100, minus
+    // gutter+2) — but expressed via the shared helper so it tracks any
+    // future width-policy change in one place.
+    const width = (0, frame_1.getBodyWidth)();
     const langLabel = (lang ?? '').trim();
     // v4.1.3-essentials reply-polish: language tag on the top rule
     // already shipped; keep it. Bottom rule unlabeled (closing fence).
@@ -131,26 +141,43 @@ function renderCodeBlock(code, lang) {
     const body = (0, syntaxHighlight_1.isSupportedLang)(langLabel)
         ? (0, syntaxHighlight_1.highlightCode)(code, langLabel)
         : code;
-    // v4.1.3-essentials reply-polish: each body line gets:
-    //   - 2-space outer indent (existing reply container indent)
+    // v4.1.4 reply-quality polish: per-line soft wrap. The rail + bg
+    // chrome adds 4 visible columns (` │ `, padding spaces around the
+    // line). Subtract those so wrap math targets the actual content
+    // budget. `hard: true` ensures even pathological long tokens
+    // (minified JS, hashes) break instead of escaping the frame.
+    //
+    // Width inside the body of a code line:
+    //   gutter (3) + `│ ` (2) + leading-space (1) + CONTENT + trailing-space (1)
+    // → content budget = width - gutter - 4. We further cap at width to
+    //   keep the fence rule aligned with the body's right margin.
+    const contentBudget = Math.max(8, width - frame_1.GUTTER - 4);
+    // v4.1.3-essentials reply-polish (preserved): each body line gets:
+    //   - frame gutter (was 2-space outer indent; now uses shared GUTTER)
     //   - left rail `│ ` painted muted (mirrors blockquote's `┃ ` rail
     //     with a different glyph so they're visually distinct)
     //   - 24-bit dark background wrapping the rail + content (subtle
     //     "this is code" affordance without going full TUI box-frame)
-    //
-    // Strip the optional ANSI-only NO_COLOR gate by emitting bg codes
-    // unconditionally — the skin engine already short-circuits inner
-    // paint calls when NO_COLOR is set, and bare bg codes degrade
-    // gracefully on terminals that don't render them.
     const rail = sk.applyColors('│', 'muted');
-    const indented = body
-        .split('\n')
-        .map((ln) => `  ${rail} ${CODE_BG_ON} ${ln} ${CODE_BG_OFF}`)
-        .join('\n');
+    const gutter = (0, frame_1.getIndent)(0);
+    // Wrap each source line independently — code-block semantics demand
+    // that a "logical line" remains visible as one continued unit even
+    // when soft-wrapped. The CODE_BG painting closes per VISUAL line so
+    // a wrap break doesn't bleed bg across the rail of the next row.
+    const wrappedLines = [];
+    for (const srcLine of body.split('\n')) {
+        const wrapped = (0, frame_1.wrap)(srcLine, contentBudget, { trim: false, hard: true });
+        for (const visualLine of wrapped.split('\n')) {
+            wrappedLines.push(`${gutter}${rail} ${CODE_BG_ON} ${visualLine} ${CODE_BG_OFF}`);
+        }
+    }
+    const indented = wrappedLines.join('\n');
+    // Top + bottom fence rules sit at the gutter too — visually anchors
+    // the block as a unit inside the assistant frame.
     return [
-        sk.applyColors(top, 'muted'),
+        `${gutter}${sk.applyColors(top, 'muted')}`,
         indented,
-        sk.applyColors(bot, 'muted'),
+        `${gutter}${sk.applyColors(bot, 'muted')}`,
         '',
     ].join('\n') + '\n';
 }
@@ -222,6 +249,97 @@ function renderHeading(text, depth) {
 function renderListItem(text) {
     return text;
 }
+/**
+ * v4.1.4 reply-quality polish — Fix C helper.
+ *
+ * Render a single list item's tokens correctly, expanding inline
+ * emphasis (strong, em, codespan) that the prior `parser.parse` path
+ * silently stranded as raw text.
+ *
+ * Marked v15 token shapes for list items:
+ *
+ *   Tight list (default — no blank lines between items):
+ *     list_item.tokens = [
+ *       { type: 'text', text: '**bold**',
+ *         tokens: [ { type: 'strong', ... } ]   ← inline children
+ *       }
+ *     ]
+ *
+ *   Loose list (blank line between items, OR an item with multiple
+ *   paragraphs):
+ *     list_item.tokens = [
+ *       { type: 'paragraph', tokens: [ inline children… ] },
+ *       { type: 'paragraph', tokens: [ … ] },
+ *     ]
+ *
+ *   Nested list (a list-token inside an item):
+ *     list_item.tokens = [
+ *       { type: 'text', tokens: [...] },   ← the item's own text first
+ *       { type: 'list', items: [...] },    ← then the nested list
+ *     ]
+ *
+ *   Item with fenced code block:
+ *     list_item.tokens = [
+ *       { type: 'text', ... },
+ *       { type: 'code', text: '…', lang: '…' },
+ *     ]
+ *
+ * Dispatch rules:
+ *   - `text` with nested `.tokens`     → parseInline(tokens)
+ *   - `text` with only `.text`          → fall through to raw text
+ *   - `paragraph`                       → parseInline(paragraph.tokens) + '\n'
+ *   - `list` / `code` / other block     → parser.parse([token]) (block path)
+ *
+ * Returns the joined rendered string. Pure-ish: depends on marked's
+ * parser instance (closure-captured) but never mutates it.
+ */
+function renderListItemTokens(it, parser) {
+    const toks = Array.isArray(it.tokens) ? it.tokens : [];
+    if (toks.length === 0)
+        return it.text ?? '';
+    const out = [];
+    for (const raw of toks) {
+        if (typeof raw !== 'object' || raw === null)
+            continue;
+        const tk = raw;
+        const type = tk.type;
+        // Inline-only wrapper (tight-list common case). The `text` outer
+        // token holds inline children we want to expand into ANSI.
+        if (type === 'text') {
+            if (Array.isArray(tk.tokens) && tk.tokens.length > 0 && parser.parseInline) {
+                out.push(parser.parseInline(tk.tokens));
+            }
+            else {
+                out.push(tk.text ?? '');
+            }
+            continue;
+        }
+        // Paragraph block (loose-list case). Marked wraps each paragraph's
+        // inline content in `.tokens`; render those inline + append a
+        // newline so multi-paragraph items stack visually.
+        if (type === 'paragraph') {
+            if (Array.isArray(tk.tokens) && tk.tokens.length > 0 && parser.parseInline) {
+                out.push(parser.parseInline(tk.tokens));
+                out.push('\n');
+            }
+            else {
+                out.push(tk.text ?? '');
+            }
+            continue;
+        }
+        // Nested list, fenced code, or any other block-level token. The
+        // block parser handles these via the normal dispatch (which calls
+        // back into our own `renderer.list` override for nested lists —
+        // depth counter is already incremented before we got here).
+        if (parser.parse) {
+            out.push(parser.parse([tk]));
+            continue;
+        }
+        // Last-resort fallback: drop the token's text in raw.
+        out.push(tk.text ?? '');
+    }
+    return out.join('');
+}
 /**
  * Singleton — caching is fine since options bind to the active skin
  * via paint callbacks (which read getSkinEngine() each call).
@@ -246,7 +364,7 @@ function getReplyRenderer() {
         // need for the 4-tier hierarchy. The prototype-level `renderer.heading`
         // override below owns the depth extraction + tier selection end-to-end.
         // marked-terminal's stripped-args call path never reaches our callback.
-        hr: () => paint('muted')('─'.repeat(Math.min(process.stdout.columns ?? 80, 100) - 4)) + '\n',
+        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
@@ -274,7 +392,12 @@ function getReplyRenderer() {
         link: (assembled) => paint('accent')(assembled),
         href: paint('accent'),
         text: (text) => text,
-        width: Math.min(process.stdout.columns ?? 80, 100),
+        // v4.1.4 reply-quality polish: marked-terminal's `width` is the
+        // *outer* canvas it formats into. Frame-aware body width keeps the
+        // tables / hr / hard-wrap targets inside our gutter envelope.
+        // `reflowText: false` (below) stays off — we own prose wrap via
+        // frame.wrap() in the display layer, not here.
+        width: (0, frame_1.getBodyWidth)(),
         showSectionPrefix: false,
         reflowText: false,
         tab: 2,
@@ -417,17 +540,32 @@ function getReplyRenderer() {
             const tok = body;
             isOrdered = tok.ordered === true;
             startNum = typeof tok.start === 'number' ? tok.start : 1;
-            // marked v15: renderer instance has a `parser` field pointing
-            // back to the Parser; `Parser.parse(tokens)` walks the token
-            // tree dispatching back to renderer methods (including this
-            // very `list` override for nested lists, which is what makes
-            // the depth counter increment properly).
+            // v4.1.4 reply-quality polish — Fix C (token-type dispatch).
+            //
+            // Prior implementation called `parser.parse(it.tokens)` and let
+            // marked's block-parser dispatch each token. For tight-list items
+            // marked v15 wraps the item's content in a `text`-type outer
+            // token whose `.tokens` array holds the actual inline tokens
+            // (strong, em, codespan…). `parser.parse` dispatched the outer
+            // wrapper to `renderer.text` (our `opts.text` = identity), which
+            // returned the RAW raw `**bold**` source string — never recursing
+            // into the inline children. Result: literal asterisks in every
+            // bullet that contained inline emphasis.
+            //
+            // Fix: walk each top-level token by type. Tight-list items have
+            // a `text` wrapper → use `parseInline` on its nested tokens to
+            // expand strong/em/codespan. Loose-list items have block-level
+            // `paragraph`/`list`/`code` tokens → those need block-level
+            // recursion (delegates back to our list override for nested
+            // lists, preserving the depth counter).
+            //
+            // Confirmed against marked v15 token shapes from `marked.lexer`
+            // (see scripts/smoke-issue-c-tokens.ts).
             const parser = this.parser;
             items = (tok.items ?? []).map((it) => {
-                if (it.tokens && parser?.parse) {
-                    return parser.parse(it.tokens);
-                }
-                return it.text ?? '';
+                if (!parser)
+                    return it.text ?? '';
+                return renderListItemTokens(it, parser);
             });
         }
         else {
@@ -485,7 +623,21 @@ function getReplyRenderer() {
                 // if other code transiently swaps the renderer.
                 marked_1.marked.setOptions({ renderer: renderer });
                 const out = marked_1.marked.parse(text);
-                return typeof out === 'string' ? out : String(out);
+                const raw = typeof out === 'string' ? out : String(out);
+                // v4.1.4 Part 1.6 Issue I — collapse excess vertical spacing.
+                //
+                // Our `opts.paragraph` callback emits `text\n\n`, our
+                // `renderCodeBlock` ends with `\n\n`, and marked-terminal's
+                // outer block dispatch ALSO emits `\n\n` between adjacent
+                // blocks. Result: 4 newlines (3 visible blank lines) between
+                // paragraphs, after code blocks, between paragraphs and lists.
+                // Root-cause fix would require auditing marked-terminal's
+                // between-block separator across every override (risk-prone).
+                // Band-aid: collapse any run of 3+ newlines down to exactly 2
+                // (= one blank line). Mechanically safe — can only REMOVE
+                // excess whitespace, never add bad spacing. Existing single-
+                // blank-line gaps pass through unchanged.
+                return normalizeBlankLines(raw);
             }
             catch {
                 return text;
@@ -494,6 +646,24 @@ function getReplyRenderer() {
     };
     return cachedRenderer;
 }
+/**
+ * v4.1.4 Part 1.6 Issue I — collapse runs of 3+ consecutive newlines
+ * down to exactly 2 (a single blank line). Exported for unit-test
+ * access; pure with no side effects.
+ *
+ * Confirmed via `scripts/smoke-issue-i-spacing.ts`:
+ *   - "A\n\n\n\nB"    → "A\n\nB"     (2 paras → 1 blank line)
+ *   - "A\n\n\n\n\nB"  → "A\n\nB"     (3+ blanks all collapse)
+ *   - "A\n\nB"        → "A\n\nB"     (already correct, unchanged)
+ *   - "A\nB"          → "A\nB"       (single newline preserved)
+ *   - "A\n"           → "A\n"        (trailing pass-through)
+ *
+ * Does NOT touch the list-under-padding case (lists ending with a
+ * single `\n` before a paragraph) — that's a v4.1.5 follow-up.
+ */
+function normalizeBlankLines(text) {
+    return text.replace(/\n{3,}/g, '\n\n');
+}
 /** Test reset — drops the cached renderer so a skin change picks up. */
 function _resetForTests() {
     cachedRenderer = null;

package/dist/cli/v4/skinEngine.js

@@ -49,9 +49,15 @@ const DEFAULT_SKIN = {
         error: [0xf4, 0x47, 0x47],
         warn: [0xff, 0xc1, 0x07],
         success: [0x4c, 0xaf, 0x50],
-        // v4.1.3-repl-polish: muted is now true grey (#888) so it reads as
-        // genuinely secondary. The soft-cyan that was here moved to 'session'.
-        muted: [0x88, 0x88, 0x88],
+        // v4.1.4 reply-quality polish: muted shifts from neutral grey
+        // (#888888) to warm Aiden-tinted dim (#b8a89a). Mid-grey at +56
+        // brightness on red/green channels with a slight cool-down on
+        // blue, putting muted in the same warm family as brand orange
+        // (#FF6B35) without competing with it. Reads as "intentional
+        // dim" rather than washed-out terminal grey. Used by tool-trail
+        // gutter, status footer, code-block rail, blockquote rail, and
+        // display.dim() — surfaces the user reads constantly.
+        muted: [0xb8, 0xa8, 0x9a],
         heading: BRAND_ORANGE,
         // v4.1.3-repl-polish: session = soft cyan (ex-muted); used for IDs
         // and the session-end card header labels.
@@ -84,7 +90,12 @@ const LIGHT_SKIN = {
         error: [0xb0, 0x10, 0x10],
         warn: [0x80, 0x60, 0x00],
         success: [0x1b, 0x5e, 0x20],
-        muted: [0x60, 0x60, 0x60],
+        // v4.1.4 reply-quality polish: proportional warm-shift for the
+        // light skin too. Was neutral #606060; new value #7a6e5e keeps the
+        // dark-on-light contrast budget but adds the same warm tint as the
+        // default skin's muted so themed surfaces feel coherent across
+        // skin switches.
+        muted: [0x7a, 0x6e, 0x5e],
         heading: [0xc4, 0x42, 0x10],
         session: [0x00, 0x55, 0x88],
         degraded: [0x80, 0x60, 0x00],

package/dist/cli/v4/toolPreview.js

@@ -29,9 +29,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TOOL_PRIMARY_ARG = void 0;
 exports.buildToolPreview = buildToolPreview;
 /**
- * Map of tool-name → name of the property in `args` that should render
- * as the at-a-glance preview. Stable contract; tests assert specific
- * entries.
+ * Map of tool-name → preview extractor (string key OR function).
+ * Stable contract; tests assert specific entries.
  */
 exports.TOOL_PRIMARY_ARG = {
     // ── terminal / execution ─────────────────────────────────────────────
@@ -70,6 +69,16 @@ exports.TOOL_PRIMARY_ARG = {
     skill_view: 'name',
     skill_manage: 'action',
     skills_list: '',
+    // v4.1.5 Phase 1d (Q-Q1-a) — registry introspection tool. Args
+    // shape: `{ toolName: 'web_search' }`. The agent uses this to
+    // discover unfamiliar tool schemas during planning. Surface the
+    // target tool name so the trail row (when not suppressed via
+    // TRAIL_HIDE_TOOLS) reads as the introspected tool, not raw JSON.
+    // Note: most callers see this tool suppressed entirely from the
+    // visible trail via the TRAIL_HIDE_TOOLS set in display.ts; the
+    // extractor exists for code paths that DON'T suppress (verbose
+    // mode, log-file capture).
+    lookup_tool_schema: 'toolName',
     // ── sessions ─────────────────────────────────────────────────────────
     session_search: 'query',
     session_list: '',
@@ -100,6 +109,37 @@ exports.TOOL_PRIMARY_ARG = {
     media_transport: 'target',
     media_key: 'action',
     app_input: 'app',
+    // ── v4.1.4 Phase 3b' (Issue H) ───────────────────────────────────────
+    // app_launch needs custom logic: when `app === 'explorer.exe'` the
+    // binary is just the URI dispatcher and the meaningful target is in
+    // `args[0]` (e.g. 'spotify:track/...'). Surface the protocol scheme
+    // ('spotify') rather than the dispatch binary. Falls through to the
+    // app name for normal exe launches.
+    app_launch: (args) => {
+        if (!args || typeof args !== 'object')
+            return '';
+        const a = args;
+        const appRaw = typeof a.app === 'string' ? a.app.trim() : '';
+        // URI-protocol case: explorer.exe + 'scheme:...' in args[0].
+        if (appRaw.toLowerCase() === 'explorer.exe' && Array.isArray(a.args)) {
+            const first = a.args[0];
+            if (typeof first === 'string' && first.length > 0) {
+                // Scheme requires ≥2 chars so Windows drive letters
+                // (`C:/path`) don't mis-detect as the scheme `C`. Real URI
+                // schemes (spotify, vscode, http, file, etc.) are all
+                // multi-char by RFC.
+                const m = first.match(/^([A-Za-z][A-Za-z0-9+.-]+):/);
+                if (m)
+                    return m[1]; // 'spotify:track/...' → 'spotify'
+                return first; // No protocol — surface the raw arg
+            }
+        }
+        return appRaw;
+    },
+    // Clipboard write — the actual text being copied is the meaningful
+    // target. Reads have no args worth showing (empty schema).
+    clipboard_write: 'text',
+    clipboard_read: '',
 };
 /**
  * Maximum visible characters for the preview value. Long commands /
@@ -121,28 +161,47 @@ function buildToolPreview(toolName, args) {
     if (!Object.prototype.hasOwnProperty.call(exports.TOOL_PRIMARY_ARG, toolName)) {
         return null;
     }
-    const argKey = exports.TOOL_PRIMARY_ARG[toolName];
-    if (argKey === '')
-        return '';
-    if (!args || typeof args !== 'object')
-        return '';
-    const raw = args[argKey];
-    if (raw === undefined || raw === null)
-        return '';
+    const extractor = exports.TOOL_PRIMARY_ARG[toolName];
+    // v4.1.4 Phase 3b' (Issue H1): function extractor path. Used by
+    // tools whose preview can't be expressed as a single key lookup
+    // (e.g. app_launch with URI-protocol routing through explorer.exe).
     let str;
-    if (typeof raw === 'string') {
-        str = raw;
-    }
-    else if (typeof raw === 'number' || typeof raw === 'boolean') {
-        str = String(raw);
-    }
-    else {
+    if (typeof extractor === 'function') {
         try {
-            str = JSON.stringify(raw);
+            const out = extractor(args);
+            str = typeof out === 'string' ? out : '';
         }
         catch {
+            // Extractor threw — degrade to empty preview rather than crash
+            // the tool-row render. The tool name + state cluster still
+            // carries enough info.
+            str = '';
+        }
+    }
+    else {
+        // String-key path (legacy, unchanged behaviour).
+        const argKey = extractor;
+        if (argKey === '')
+            return '';
+        if (!args || typeof args !== 'object')
+            return '';
+        const raw = args[argKey];
+        if (raw === undefined || raw === null)
+            return '';
+        if (typeof raw === 'string') {
+            str = raw;
+        }
+        else if (typeof raw === 'number' || typeof raw === 'boolean') {
             str = String(raw);
         }
+        else {
+            try {
+                str = JSON.stringify(raw);
+            }
+            catch {
+                str = String(raw);
+            }
+        }
     }
     // Collapse whitespace so multi-line commands stay on one preview row.
     str = str.replace(/\s+/g, ' ').trim();

package/dist/core/toolRegistry.js

@@ -1388,7 +1388,13 @@ exports.TOOLS = {
             return { success: false, output: '', error: `No research results for: ${topic}` };
         }
         const combined = results.join('\n\n');
-        console.log(`[deep_research] Complete: ${combined.length} chars across ${results.length} passes`);
+        // v4.1.5 Issue O — gated behind AIDEN_DEBUG_WEB to match the
+        // webSearch.ts debug-helper convention. Default off; power users
+        // export the env var to see the research chain.
+        if (process.env.AIDEN_DEBUG_WEB === '1') {
+            // eslint-disable-next-line no-console
+            console.log(`[deep_research] Complete: ${combined.length} chars across ${results.length} passes`);
+        }
         return { success: true, output: combined.slice(0, 15000) };
     },
     // Activate a specialist agent persona — actual synthesis happens in respond phase

package/dist/core/v4/aidenAgent.js

@@ -103,6 +103,10 @@ class AidenAgent {
         this.onCompression = opts.onCompression;
         this.refreshMemorySnapshot = opts.refreshMemorySnapshot;
         this.onMemoryRefresh = opts.onMemoryRefresh;
+        // v4.1.5 Issue K — phase hooks (all optional, fire defensively).
+        this.onMemoryRefreshStart = opts.onMemoryRefreshStart;
+        this.onPromptBuilt = opts.onPromptBuilt;
+        this.onProviderRequestStart = opts.onProviderRequestStart;
         this.lookupSkillRequiredTools = opts.lookupSkillRequiredTools;
         // Phase v4.1.2-slice3: optional health registry (constructor-
         // injected per the slice3 decision tree — no singleton). When
@@ -386,6 +390,14 @@ class AidenAgent {
         // / 'user' need a snapshot refresh first.
         const needsSnapshot = this.memoryDirty.has('memory') || this.memoryDirty.has('user');
         if (needsSnapshot && this.refreshMemorySnapshot) {
+            // v4.1.5 Issue K — fire BEFORE the file I/O so the display layer
+            // can switch the activity verb to "refreshing memory" while the
+            // read is in flight. Defensive try/catch so a misbehaving hook
+            // never blocks the refresh.
+            try {
+                this.onMemoryRefreshStart?.();
+            }
+            catch { /* defensive */ }
             let snapshot;
             try {
                 snapshot = await this.refreshMemorySnapshot();
@@ -410,6 +422,21 @@ class AidenAgent {
         if (this.cachedSystemPrompt !== null)
             return this.cachedSystemPrompt;
         this.cachedSystemPrompt = await this.promptBuilder.build(this.promptBuilderOptions);
+        // v4.1.5 Issue K — fire AFTER the prompt has been assembled, with
+        // cardinality so the display layer can surface "preparing prompt:
+        // N tools, M skills" or similar. Only fires when the cache MISSED
+        // (which is what made us actually build); cached returns skip the
+        // hook because nothing was prepared this turn. Defensive try/catch.
+        if (this.onPromptBuilt) {
+            try {
+                this.onPromptBuilt({
+                    tools: this.tools.length,
+                    skills: this.promptBuilderOptions.skillsList?.length ?? 0,
+                    memoryFacts: countMemoryFacts(this.promptBuilderOptions.memorySnapshot),
+                });
+            }
+            catch { /* defensive */ }
+        }
         return this.cachedSystemPrompt;
     }
     async narrowTools(userMsg, history) {
@@ -629,6 +656,18 @@ class AidenAgent {
      */
     async callProvider(messages, tools, runOptions) {
         const wantStream = runOptions.stream === true && typeof this.provider.callStream === 'function';
+        // v4.1.5 Issue K — fire just before the HTTP request opens, so the
+        // display layer can transition the activity verb from local-prep
+        // ("preparing prompt", "selecting tools") to a network verb
+        // ("calling provider"). The wait for TTFT (time-to-first-token) is
+        // the longest gap in most turns and is what the wave bar covers.
+        // Fires for both streaming and non-streaming paths — caller may use
+        // it to add a one-shot indicator on non-streaming providers too.
+        // Defensive try/catch (a misbehaving hook must not block dispatch).
+        try {
+            this.onProviderRequestStart?.(this.providerId);
+        }
+        catch { /* defensive */ }
         if (!wantStream) {
             return this.provider.call({ messages, tools });
         }
@@ -650,6 +689,15 @@ class AidenAgent {
             else if (evt.type === 'tool_call') {
                 runOptions.onToolCallStart?.(evt.toolCall);
             }
+            else if (evt.type === 'progress') {
+                // v4.1.4 Part 1.6 — drive the per-turn token progress bar.
+                // Defensive try/catch — a misbehaving display sink must not
+                // tear down the stream consumer.
+                try {
+                    runOptions.onProgress?.(evt.outputTokens, evt.maxTokens);
+                }
+                catch { /* progress sink errors don't block streaming */ }
+            }
             else if (evt.type === 'done') {
                 finalOutput = evt.output;
             }
@@ -662,6 +710,30 @@ class AidenAgent {
 }
 exports.AidenAgent = AidenAgent;
 // ── Free helpers ────────────────────────────────────────────────────────
+/**
+ * v4.1.5 Issue K — best-effort count of "memory facts" from a
+ * MemorySnapshot. Counts markdown bullet-list lines (`- `) in both
+ * MEMORY.md and USER.md. This is a fuzzy proxy — the agent stores
+ * facts as bullets by convention but free-form prose can also carry
+ * fact-like content. Surfaced verbatim to the display layer; treat as
+ * "approximately N items in the persistent memory file" rather than
+ * a precise inventory.
+ */
+function countMemoryFacts(snapshot) {
+    if (!snapshot || typeof snapshot !== 'object')
+        return 0;
+    const s = snapshot;
+    let count = 0;
+    for (const md of [s.memoryMd, s.userMd]) {
+        if (typeof md !== 'string' || md.length === 0)
+            continue;
+        for (const line of md.split('\n')) {
+            if (line.trim().startsWith('- '))
+                count += 1;
+        }
+    }
+    return count;
+}
 function lastUserMessageContent(history) {
     for (let i = history.length - 1; i >= 0; i--) {
         const m = history[i];