aiden-runtime 4.1.1 → 4.1.3

package/dist/cli/v4/commands/auth.js

@@ -86,9 +86,12 @@ function renderStatus(ctx, providerId, tokens) {
     if (tokens.account)
         ctx.display.write(`  account: ${tokens.account}\n`);
     ctx.display.write(`  ${formatRelativeExpiry(tokens.expiresAtMs)}\n`);
-    if (tokens.models?.length) {
-        ctx.display.write(`  models: ${tokens.models.join(', ')}\n`);
-    }
+    // Post-v4.1.1 cleanup: don't render `models:` — the stored list is
+    // captured at OAuth mint time and never refreshed, so it goes stale
+    // when the provider rotates its model catalog (e.g. OpenAI retired
+    // gpt-5 / gpt-5-mini in Feb 2026). The live model list lives in
+    // /model picker → providerCatalog.ts. /auth status is for AUTH
+    // state, not catalog state.
     if (ctx.paths) {
         ctx.display.dim(`  file: ${node_path_1.default.join(ctx.paths.root, 'auth', `${providerId}.json`)}`);
     }

package/dist/cli/v4/commands/doctor.js

@@ -32,35 +32,31 @@ exports.doctor = {
         }
         ctx.display.info('Running diagnostic checks...');
         const report = await (0, doctor_1.runDoctor)({ paths: ctx.paths });
-        // Phase 22 Task 5A: orange-bordered rounded box; rows + summary
-        // assembled by renderHealthBox so the slash command stays a thin
-        // adapter and the same renderer can be reused by `aiden doctor`
-        // CLI in a future polish pass.
-        ctx.display.write((0, doctor_1.renderHealthBox)(report, ctx.display) + '\n');
-        // Phase 23.1: surface session-scoped skill-enforcement counters.
-        // Lives only on the live agent (process-scoped, no persistence) so
-        // `aiden doctor` CLI subcommand correctly omits this — the
-        // counters would always be zero there.
+        // v4.1.3-essentials doctor-polish: pull in-process subsystem
+        // health + skill-outcome data into the same report so they
+        // render as additional grouped sections inside the health box,
+        // not as disconnected blocks below it. `subsystemHealthResults`
+        // / `skillOutcomeResults` return empty arrays when their
+        // sources are unavailable so the grouped-renderer simply drops
+        // those sections.
         if (ctx.agent) {
-            const m = ctx.agent.getSkillEnforcementMetrics();
-            ctx.display.write(
-            // Phase 23.4b: surface the Stage-0 intent pre-arm counter so
-            // smoke runs can confirm the regex fired on bug-Y queries.
-            `[skill-enforcement] armed=${m.armed} pre-armed=${m.preArmed} recovered=${m.recovered} failed=${m.failed} (session)\n`);
-            // Phase 23.4a: same shape, different concern — URL provenance
-            // gate counters. blocked = open_url calls rejected for unknown
-            // YouTube ids; recovered = corrective retry produced a real
-            // youtube_search; failed = retry cap exceeded and the turn
-            // ended with an honest-failure message.
-            const u = ctx.agent.getUrlProvenanceMetrics();
-            ctx.display.write(`[url-provenance]    blocked=${u.blocked} recovered=${u.recovered} failed=${u.failed} (session)\n`);
-            // Phase 23.4a-fix2: empty-response counters. detected =
-            // Codex backend completed a turn with no content and no tool
-            // calls; retried = corrective system message injected (cap
-            // 1/turn); recovered = retry yielded a non-empty reply.
-            const e = ctx.agent.getEmptyResponseMetrics();
-            ctx.display.write(`[empty-response]    detected=${e.detected} retried=${e.retried} recovered=${e.recovered} (session)\n`);
+            const a = ctx.agent;
+            report.results.push(...(0, doctor_1.subsystemHealthResults)(a.subsystemHealthRegistry));
+            report.results.push(...(0, doctor_1.skillOutcomeResults)(a.skillOutcomeTracker));
+            // v4.1.3-essentials doctor-polish: session-scoped counters
+            // (skill enforcement / URL provenance / empty response) now
+            // fold into the same report so they render as a "Session
+            // counters" group INSIDE the box instead of as orphan
+            // `display.write` lines below it. Previous code emitted them
+            // as 3 separate `[bracket-prefix] key=N ...` lines after
+            // renderHealthBox closed — visually disconnected.
+            report.results.push(...(0, doctor_1.sessionCounterResults)(ctx.agent));
         }
+        // v4.1.3-essentials doctor-polish: renderHealthBox now groups
+        // results by section header with a top summary. Same renderer
+        // is used by `aiden doctor` CLI path so both surfaces stay in
+        // visual sync (Path-A unification).
+        ctx.display.write((0, doctor_1.renderHealthBox)(report, ctx.display) + '\n');
         return {};
     },
 };

package/dist/cli/v4/commands/help.js

@@ -36,6 +36,8 @@ exports.SUBSECTION_MAP = {
     'debug-prompt': 'Configuration',
     // ── Identity ── SOUL.md introspection
     identity: 'Identity',
+    // Phase v4.1.2 alive-core: manual SOUL.md cache invalidation.
+    'reload-soul': 'Identity',
     // ── System ── housekeeping & process control (default fallback)
     doctor: 'System',
     license: 'System',
@@ -54,6 +56,8 @@ exports.SUBSECTION_MAP = {
     status: 'System',
     show: 'System',
     history: 'System',
+    // Phase v4.1.2-update — npm self-update for the running install.
+    update: 'System',
     // ── Authentication ──
     auth: 'Authentication',
     // ── Help ──

package/dist/cli/v4/commands/index.js

@@ -12,7 +12,7 @@
  * and registers each on the global CommandRegistry at boot.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.allCommands = exports.history = exports.show = exports.status = exports.voice = exports.channel = exports.setup = exports.cron = exports.doctor = exports.license = exports.auth = exports.plugins = exports.streaming = exports.debugPrompt = exports.identity = exports.providers = exports.quit = exports.clear = exports.verbose = exports.reasoning = exports.reloadMcp = exports.skills = exports.skin = exports.yolo = exports.usage = exports.compress = exports.title = exports.save = exports.personality = exports.model = exports.tools = exports.help = void 0;
+exports.allCommands = exports.update = exports.reloadSoul = exports.history = exports.show = exports.status = exports.voice = exports.channel = exports.setup = exports.cron = exports.doctor = exports.license = exports.auth = exports.plugins = exports.streaming = exports.debugPrompt = exports.identity = exports.providers = exports.quit = exports.clear = exports.verbose = exports.reasoning = exports.reloadMcp = exports.skills = exports.skin = exports.yolo = exports.usage = exports.compress = exports.title = exports.save = exports.personality = exports.model = exports.tools = exports.help = void 0;
 const help_1 = require("./help");
 Object.defineProperty(exports, "help", { enumerable: true, get: function () { return help_1.help; } });
 const tools_1 = require("./tools");
@@ -75,6 +75,10 @@ const show_1 = require("./show");
 Object.defineProperty(exports, "show", { enumerable: true, get: function () { return show_1.show; } });
 const history_1 = require("./history");
 Object.defineProperty(exports, "history", { enumerable: true, get: function () { return history_1.history; } });
+const reloadSoul_1 = require("./reloadSoul");
+Object.defineProperty(exports, "reloadSoul", { enumerable: true, get: function () { return reloadSoul_1.reloadSoul; } });
+const update_1 = require("./update");
+Object.defineProperty(exports, "update", { enumerable: true, get: function () { return update_1.update; } });
 /** All built-in system commands, in canonical order. */
 exports.allCommands = [
     help_1.help,
@@ -103,9 +107,14 @@ exports.allCommands = [
     status_1.status,
     show_1.show,
     history_1.history,
+    reloadSoul_1.reloadSoul,
     reloadMcp_1.reloadMcp,
     reasoning_1.reasoning,
     verbose_1.verbose,
+    // Phase v4.1.2-update: /update + /update install — fresh registry
+    // probe + shared executeInstall executor (also wired into
+    // aiden_self_update tool for natural-language requests).
+    update_1.update,
     clear_1.clear,
     quit_1.quit,
 ];

package/dist/cli/v4/commands/model.js

@@ -106,7 +106,36 @@ exports.model = {
                 return {};
             }
         }
-        ctx.display.success(`Now using ${providerId}:${modelId}`);
+        // v4.1.3-prebump: persist the selection to config.yaml so the NEXT
+        // boot honours the user's choice. Without this, `/model` only
+        // updated the live session — and the persisted `model.provider /
+        // model.modelId` keys (which Case 3 in providerBootSelector
+        // consults first) silently kept their stale values from the
+        // previous wizard run. Result: every reboot snapped the user back
+        // to the wizard's original pick (typically groq + llama-3.3-70b),
+        // confusing /model into looking like a "session-only" switch.
+        //
+        // The `aiden model` CLI subcommand (aidenCLI.ts:1773-1777) has
+        // always persisted; this brings the REPL `/model` path in line.
+        // Best-effort: if `ctx.config` isn't plumbed (test harness, etc.)
+        // we still succeeded for the live session — emit a subtle warning
+        // instead of failing the whole switch.
+        let persisted = false;
+        if (ctx.config) {
+            try {
+                ctx.config.set('model.provider', providerId);
+                ctx.config.set('model.modelId', modelId);
+                await ctx.config.save();
+                persisted = true;
+            }
+            catch (err) {
+                ctx.display.warn(`Switched the live session but could not persist to config.yaml: ` +
+                    `${err.message}. Next boot may revert.`);
+            }
+        }
+        ctx.display.success(persisted
+            ? `Now using ${providerId}:${modelId}  (saved to config.yaml)`
+            : `Now using ${providerId}:${modelId}  (session only — not persisted)`);
         return {};
     },
 };

package/dist/cli/v4/commands/reloadSoul.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/commands/reload-soul.ts — Phase v4.1.2 alive-core.
+ *
+ * `/reload-soul` — explicit fallback for the SOUL.md file-watcher path.
+ * Some filesystems (network mounts, certain WSL configs) don't support
+ * `fs.watch` reliably; this command lets users force a system-prompt
+ * rebuild after editing SOUL.md without restarting `aiden`.
+ *
+ * Mechanism: marks the agent's 'soul' dirty bit; the next turn calls
+ * `refreshSystemPromptIfDirty()` which invalidates the cached prompt.
+ * `PromptBuilder.build()` then re-reads SOUL.md from disk.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reloadSoul = void 0;
+exports.reloadSoul = {
+    name: 'reload-soul',
+    description: 'Re-read SOUL.md from disk on the next turn (manual cache invalidation).',
+    category: 'system',
+    icon: '🔁',
+    aliases: ['soul-reload'],
+    handler: async (ctx) => {
+        if (!ctx.agent) {
+            ctx.display.warn('Reload-soul cannot run before the agent boots.');
+            return {};
+        }
+        ctx.agent.markMemoryDirty('soul');
+        ctx.display.success('SOUL.md flagged for reload — the next turn will pick up your edits.');
+        return {};
+    },
+};

package/dist/cli/v4/commands/update.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/commands/update.ts — Phase v4.1.2-update.
+ *
+ *   /update          — bypass the boot-time 6h cache, probe npm registry
+ *                      fresh, print current vs latest with hint.
+ *   /update install  — spawn `npm install -g aiden-runtime@latest`
+ *                      via the shared executeInstall executor; print
+ *                      restart hint on success or platform-specific
+ *                      remediation on permission failure.
+ *
+ * No auto-restart on success — the user keeps control by typing
+ * /quit and re-launching aiden. Honest UX: never claim the current
+ * process is upgraded after a successful install. Auto-restart of
+ * a node REPL via re-exec is also fragile across Windows/macOS/
+ * Linux, so the explicit /quit path is both honest and reliable.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.update = void 0;
+const version_1 = require("../../../core/version");
+const checkUpdate_1 = require("../../../core/v4/update/checkUpdate");
+const executeInstall_1 = require("../../../core/v4/update/executeInstall");
+async function printStatus(ctx) {
+    if (!ctx.paths) {
+        ctx.display.warn('/update needs Aiden user-data paths — try in a real session.');
+        return;
+    }
+    ctx.display.dim('Checking for updates…');
+    // cacheTtlMs: 0 — user explicitly asked, so bypass the 6h boot cache.
+    const status = await (0, checkUpdate_1.checkForUpdate)({
+        paths: ctx.paths,
+        installedVersion: version_1.VERSION,
+        cacheTtlMs: 0,
+    });
+    ctx.display.write(`  installed: v${status.installed}\n`);
+    if (status.latest === null) {
+        ctx.display.write('  latest:    unknown (registry unreachable)\n');
+        ctx.display.dim('Could not reach the npm registry. Check your network and try again.');
+        return;
+    }
+    ctx.display.write(`  latest:    v${status.latest}\n`);
+    if (status.updateAvailable) {
+        ctx.display.write(`\n  update available: v${status.installed} → v${status.latest}\n` +
+            `  run \`/update install\` to install, or \`npm install -g aiden-runtime@latest\` manually.\n`);
+    }
+    else {
+        ctx.display.dim("You're on the latest version.");
+    }
+}
+async function runInstall(ctx) {
+    if (!ctx.paths) {
+        ctx.display.warn('/update install needs Aiden user-data paths — try in a real session.');
+        return;
+    }
+    // Status probe first so we don't run a no-op install. Also bypasses
+    // cache — same rationale as the bare /update path.
+    ctx.display.dim('Checking for updates…');
+    const status = await (0, checkUpdate_1.checkForUpdate)({
+        paths: ctx.paths,
+        installedVersion: version_1.VERSION,
+        cacheTtlMs: 0,
+    });
+    if (status.latest === null) {
+        ctx.display.warn("Couldn't check for updates (registry unreachable). " +
+            'Try `/update` first, or run `npm install -g aiden-runtime@latest` manually.');
+        return;
+    }
+    if (!status.updateAvailable) {
+        ctx.display.dim(`You're already on the latest version (v${status.installed}).`);
+        return;
+    }
+    ctx.display.write(`Installing aiden-runtime v${status.latest} (current: v${status.installed})…\n`);
+    const result = await (0, executeInstall_1.executeInstall)();
+    if (result.success) {
+        const v = result.installedVersion ?? status.latest;
+        ctx.display.write(`\n  ✓ aiden-runtime v${v} installed.\n`);
+        ctx.display.dim('Restart Aiden to apply: type /quit then re-run `aiden`.');
+        return;
+    }
+    ctx.display.warn(result.error ?? 'Install failed (no error message).');
+}
+exports.update = {
+    name: 'update',
+    description: 'Check for / install the latest aiden-runtime. Use "install" subcommand to apply.',
+    category: 'system',
+    icon: '⬆',
+    handler: async (ctx) => {
+        const sub = (ctx.args[0] ?? '').toLowerCase();
+        if (sub === 'install') {
+            await runInstall(ctx);
+        }
+        else {
+            await printStatus(ctx);
+        }
+    },
+};

package/dist/cli/v4/defaultSoul.js

@@ -30,7 +30,7 @@ exports.PREVIOUS_BUNDLED_SOULS = exports.DEFAULT_SOUL_MD = exports.BUNDLED_SOUL_
 // <act_dont_ask>. ensureSoulMdSeeded compares this against the user's
 // on-disk SOUL.md to decide whether to silent-replace (matches a prior
 // bundled default) or preserve+notify (user-edited).
-exports.BUNDLED_SOUL_VERSION = '16h';
+exports.BUNDLED_SOUL_VERSION = 'v4.1.2';
 exports.DEFAULT_SOUL_MD = `You are Aiden — a local-first AI agent built by Taracod.
 
 Identity:
@@ -88,7 +88,6 @@ asking the user what to do next.
 </keep_going>
 
 Limits:
-- You're a CLI agent in v4.0.0. No voice, no scheduled jobs, no messaging gateway yet — those are v4.1.
 - You can't bypass approval prompts for dangerous commands.
 - You don't lie to look smart. If you don't know, you say so.
 `;
@@ -184,6 +183,73 @@ the tool calls within a single turn instead of returning halfway and
 asking the user what to do next.
 </keep_going>
 
+Limits:
+- You're a CLI agent in v4.0.0. No voice, no scheduled jobs, no messaging gateway yet — those are v4.1.
+- You can't bypass approval prompts for dangerous commands.
+- You don't lie to look smart. If you don't know, you say so.
+`,
+    // 16h default — media-search anti-pattern + skill_view reference,
+    // but still carried the stale 'v4.0.0 / planned for v4.1' limits line
+    // claiming voice, cron, and messaging were not yet shipped. Phase
+    // v4.1.2-followup strips that line because cron / Telegram / 9 channels
+    // ALL shipped in v4.1.0. Users on the v4.1.0 / v4.1.1 install have this
+    // verbatim text on disk; silent-upgrade picks them up here.
+    `You are Aiden — a local-first AI agent built by Taracod.
+
+Identity:
+- You run on the user's machine, native Windows/Linux/macOS (not WSL2).
+- You have 72 bundled skills + access to install more via skills.sh.
+- You remember past sessions via persistent storage.
+- You have 40 tools spanning files, browser, terminal, web, memory.
+
+Voice:
+- Direct. No fluff. Match the user's energy.
+- Honest above all — if you didn't do something, say so. If you're not sure, say so.
+- You never claim to "have run" a tool unless the trace shows it.
+
+Behavior:
+- Default to action over discussion. The user wants results.
+- When asked who you are, identify as Aiden. Not "a large language model."
+- When asked what you can do, mention specific skills/tools, not generic capabilities.
+- If user mentions trading/NSE/markets, you have specialized skills for that.
+
+<act_dont_ask>
+When a request has an obvious default interpretation, act on it
+immediately instead of asking for clarification. Examples:
+- "play me a popular song" / "play X on youtube" → load skill_view(media-search)
+  and follow it. Substitute fuzzy phrases ("popular song") with a specific
+  chart-topper BEFORE searching, then open_url a /watch?v= URL once.
+  NEVER search verbatim "popular song" — that returns articles, not music.
+- "what files are in my Downloads?" → file_list on Downloads. Don't ask
+  "which user?" — it's the current user.
+- "is port 443 open?" → check this machine. Don't ask "open where?"
+Only ask for clarification when the ambiguity genuinely changes which
+tool you would call.
+</act_dont_ask>
+
+<prerequisite_checks>
+Before acting, check whether prerequisite discovery, lookup, or
+context-gathering steps are needed. If a step depends on output from a
+prior step, resolve that dependency first. Don't skip prerequisite
+steps just because the final action seems obvious.
+</prerequisite_checks>
+
+<missing_context>
+If required context is missing, do NOT guess or hallucinate. Use the
+appropriate lookup tool when missing information is retrievable
+(file_read, file_list, web_search, fetch_url, session_search,
+system_info). Ask a clarifying question ONLY when no tool can resolve
+the ambiguity.
+</missing_context>
+
+<keep_going>
+Work autonomously until the task is fully resolved. Don't stop with a
+plan — execute it. Multi-step tasks (open browser → search → click
+result; or list files → read each → summarise) are expected; chain
+the tool calls within a single turn instead of returning halfway and
+asking the user what to do next.
+</keep_going>
+
 Limits:
 - You're a CLI agent in v4.0.0. No voice, no scheduled jobs, no messaging gateway yet — those are v4.1.
 - You can't bypass approval prompts for dangerous commands.

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

@@ -0,0 +1,135 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/display/capabilityCard.ts — Aiden v4.1.3-essentials.
+ *
+ * Renders the structured "capability card" tools return on certain
+ * failure classes:
+ *   1. Platform unsupported (e.g. media_transport called on Linux)
+ *   2. Auth missing (provider 401/403, or a tool that needs a specific
+ *      OAuth/API key)
+ *
+ * Distinct from the one-line tool-trail row (`display.toolRow`) because
+ * it's a different category of information — a state assessment of
+ * what the user CAN still do versus what they CANNOT, with a one-line
+ * fix hint. Rendered as a box-bordered multi-line block.
+ *
+ * Pure module — takes the data + a colorize callback, returns lines.
+ * No I/O, no SkinEngine reach-through. Caller writes the result.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderCapabilityCard = renderCapabilityCard;
+exports.truncToContent = truncToContent;
+const box_1 = require("../box");
+/** Total card width (chars). Wide enough for typical action labels;
+ *  short enough to stay readable on narrow terminals. */
+const CARD_WIDTH = 64;
+/** Box-content width = CARD_WIDTH minus 2 border chars and 2 padding. */
+const CONTENT_WIDTH = CARD_WIDTH - 4;
+/**
+ * Render a capability card from `data`. Returns an array of lines
+ * (no trailing newlines). Caller writes them with appended `\n`:
+ *
+ *   for (const line of renderCapabilityCard(data, colorize)) {
+ *     display.write(line + '\n');
+ *   }
+ *
+ * Layout:
+ *
+ *   ┌── ⚠ <title> ──────────────────────────────┐
+ *   │                                           │
+ *   │ Can still:                                │
+ *   │   ✓ <action 1>                            │
+ *   │   ✓ <action 2>                            │
+ *   │                                           │
+ *   │ Cannot reliably:                          │
+ *   │   ✗ <action 1>                            │
+ *   │   ✗ <action 2>                            │
+ *   │                                           │
+ *   │ Fix: <one-line guidance>                  │
+ *   └───────────────────────────────────────────┘
+ *
+ * Empty `canStill` or `cannotReliably` arrays cause the corresponding
+ * section to be omitted (no empty heading). Always renders at least
+ * the title + fix line so the user has actionable signal.
+ */
+function renderCapabilityCard(data, colorize) {
+    // Pre-color the section headings + bullet markers.
+    const heading = (s) => colorize(s, 'warn');
+    const okMark = colorize('✓', 'success');
+    const noMark = colorize('✗', 'error');
+    const fixLbl = colorize('Fix:', 'tool');
+    // Compose the inner rows that boxSharp will wrap. Each row is the
+    // CONTENT (no border) — boxSharp adds the side borders + padding.
+    const rows = [];
+    if (data.canStill.length > 0) {
+        rows.push('');
+        rows.push(heading('Can still:'));
+        for (const action of data.canStill) {
+            rows.push(`  ${okMark} ${truncToContent(action)}`);
+        }
+    }
+    if (data.cannotReliably.length > 0) {
+        rows.push('');
+        rows.push(heading('Cannot reliably:'));
+        for (const action of data.cannotReliably) {
+            rows.push(`  ${noMark} ${truncToContent(action)}`);
+        }
+    }
+    rows.push('');
+    // Fix line — split-wrap to two lines if needed so long guidance
+    // doesn't get cut off mid-sentence by boxSharp's clipper.
+    const fixText = data.fix;
+    const fixPrefix = 'Fix: ';
+    const fixPrefixVis = (0, box_1.visibleLength)(fixPrefix);
+    if ((0, box_1.visibleLength)(fixText) + fixPrefixVis <= CONTENT_WIDTH) {
+        rows.push(`${fixLbl} ${fixText}`);
+    }
+    else {
+        rows.push(fixLbl);
+        // Wrap the fix text across content-width lines.
+        let remaining = fixText;
+        const wrapLimit = CONTENT_WIDTH - 2; // 2-space indent
+        while (remaining.length > 0) {
+            const chunk = remaining.length <= wrapLimit
+                ? remaining
+                : breakAtWord(remaining, wrapLimit);
+            rows.push(`  ${chunk}`);
+            remaining = remaining.slice(chunk.length).trimStart();
+        }
+    }
+    rows.push('');
+    // Title is rendered into the top border by boxSharp. Prefix with
+    // a warning glyph (yellow) so the user reads it as an attention card.
+    const title = `${colorize('⚠', 'warn')} ${data.title}`;
+    return (0, box_1.boxSharp)(rows, CARD_WIDTH, title).split('\n');
+}
+/**
+ * Shorten an action label so it fits the bullet column with room for
+ * the marker ("  ✓ ") and the border padding. Appends an ellipsis when
+ * truncated. Pure — exported for unit tests.
+ */
+function truncToContent(s) {
+    // Reserve 6 chars for "  ✓ " prefix + 2 for border padding margin.
+    const cap = CONTENT_WIDTH - 6;
+    if ((0, box_1.visibleLength)(s) <= cap)
+        return s;
+    return s.slice(0, cap - 1) + '…';
+}
+/**
+ * Break `s` at the last word boundary at-or-before `limit`. Falls back
+ * to a hard cut at `limit` when no whitespace appears in the prefix.
+ * Pure helper used by the Fix-line wrapper.
+ */
+function breakAtWord(s, limit) {
+    if (s.length <= limit)
+        return s;
+    const slice = s.slice(0, limit);
+    const lastSpace = slice.lastIndexOf(' ');
+    return lastSpace > 0 ? slice.slice(0, lastSpace) : slice;
+}

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

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/display/sessionEndCard.ts — Aiden v4.1.3-repl-polish
+ *
+ * Renders a compact session-end summary card from a SessionDistillation.
+ *
+ * Returned as an array of plain lines (WITHOUT trailing '\n'). The caller
+ * writes them with a newline appended, e.g.:
+ *
+ *   for (const line of renderSessionEndCard(dist, colorize)) {
+ *     display.write(line + '\n');
+ *   }
+ *
+ * Design rules (from spec):
+ *   - Skip entirely when user_turns === 0 (silent/internal sessions).
+ *   - Label column is colon-aligned to column LABEL_COL (14).
+ *   - Session ID rendered in 'session' color (soft cyan).
+ *   - Bullets / decisions / open_items shown only when non-empty.
+ *   - Takes a `colorize` callback instead of a SkinEngine directly, so
+ *     the function is fully unit-testable without a Display stack.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderSessionEndCard = renderSessionEndCard;
+/** Width of the "Label:" prefix, colon included, padded to this column. */
+const LABEL_COL = 14;
+/** Horizontal rule width (chars). */
+const HR_WIDTH = 48;
+// ── Internal helpers ──────────────────────────────────────────────────────────
+function labelRow(label, value) {
+    return `${`${label}:`.padEnd(LABEL_COL)}${value}`;
+}
+/**
+ * Format a wall-clock duration from two ISO timestamps.
+ * Returns '—' when the delta is ≤0 or non-finite (e.g. partial distillation).
+ */
+function fmtDuration(startIso, endIso) {
+    const ms = new Date(endIso).getTime() - new Date(startIso).getTime();
+    if (!Number.isFinite(ms) || ms <= 0)
+        return '—';
+    const sec = ms / 1000;
+    if (sec < 60)
+        return `${Math.round(sec)}s`;
+    const mins = Math.floor(sec / 60);
+    const remSec = Math.round(sec - mins * 60);
+    return remSec > 0 ? `${mins}m ${remSec}s` : `${mins}m`;
+}
+// ── Public API ────────────────────────────────────────────────────────────────
+/**
+ * Render a session-end card from `dist`.
+ *
+ * @param dist              Completed SessionDistillation (may be partial).
+ * @param colorize          Skin-aware colorizer — `(text, kind) => coloredText`.
+ * @param distillationPath  Absolute path the distillation JSON was written to,
+ *                          if any. Rendered as a `Distillation:` row so the
+ *                          user has something concrete to inspect / pass to
+ *                          recall_session. Omitted from the card when null /
+ *                          undefined (e.g. write failed earlier).
+ * @returns                 Array of lines (no trailing newlines). Empty when
+ *                          `user_turns === 0`.
+ */
+function renderSessionEndCard(dist, colorize, distillationPath) {
+    if (dist.user_turns === 0)
+        return [];
+    const lines = [];
+    const hr = colorize('─'.repeat(HR_WIDTH), 'muted');
+    const bullet = colorize('•', 'muted');
+    // ── Header block ───────────────────────────────────────────────────────
+    lines.push(hr);
+    lines.push(labelRow('Session', colorize(dist.session_id, 'session')));
+    lines.push(labelRow('Duration', fmtDuration(dist.started_at, dist.ended_at)));
+    lines.push(labelRow('Turns', String(dist.user_turns)));
+    lines.push(labelRow('Exit', dist.exit_path));
+    if (dist.files_touched.length > 0) {
+        // Show at most 6 files; truncate list with '…' if longer.
+        const shown = dist.files_touched.slice(0, 6);
+        const suffix = dist.files_touched.length > 6
+            ? ` … +${dist.files_touched.length - 6} more`
+            : '';
+        lines.push(labelRow('Files', shown.join(', ') + suffix));
+    }
+    else {
+        lines.push(labelRow('Files', colorize('(none)', 'muted')));
+    }
+    if (dist.tools_used.length > 0) {
+        const top = [...dist.tools_used]
+            .sort((a, b) => b.count - a.count)
+            .slice(0, 5)
+            .map(t => `${t.name}(${t.count})`)
+            .join(', ');
+        lines.push(labelRow('Tools', top));
+    }
+    if (distillationPath) {
+        lines.push(labelRow('Distillation', colorize(distillationPath, 'muted')));
+    }
+    lines.push(hr);
+    // ── Semantic sections (LLM-generated, may be empty on partial) ─────────
+    if (dist.bullets.length > 0) {
+        lines.push('');
+        lines.push(colorize('What happened:', 'heading'));
+        for (const b of dist.bullets) {
+            lines.push(`  ${bullet} ${b}`);
+        }
+    }
+    if (dist.decisions.length > 0) {
+        lines.push('');
+        lines.push(colorize('Decisions:', 'heading'));
+        for (const d of dist.decisions) {
+            lines.push(`  ${bullet} ${d}`);
+        }
+    }
+    if (dist.open_items.length > 0) {
+        lines.push('');
+        lines.push(colorize('Open items:', 'heading'));
+        for (const o of dist.open_items) {
+            lines.push(`  ${bullet} ${o}`);
+        }
+    }
+    // Blank line so "Goodbye." has breathing room.
+    lines.push('');
+    return lines;
+}