aiden-runtime 4.1.2 → 4.1.3

package/dist/cli/v4/aidenCLI.js

@@ -1449,6 +1449,12 @@ async function buildAgentRuntime(cliOpts, opts) {
         mcpClient,
         providerId,
         modelId,
+        // v4.1.3-prebump: forward the precedence-case label so the boot
+        // card can render a "where this choice came from" annotation.
+        // The case-3 (persisted-config) branch was confusing users who
+        // expected auto-pick to kick in — surfacing the source closes the
+        // information asymmetry.
+        bootSource,
         resumeSessionId,
         fallbackAdapter,
         personalityManager,
@@ -1475,6 +1481,10 @@ async function runInteractiveChat(cliOpts, opts) {
         config: runtime.config,
         initialProviderId: runtime.providerId,
         initialModelId: runtime.modelId,
+        // v4.1.3-prebump: pass through the precedence-case label so the
+        // boot card can render a dim source annotation under the version
+        // pill ("persisted from prior session" / "auto-picked" / …).
+        initialBootSource: runtime.bootSource,
         resumeSessionId: runtime.resumeSessionId,
         yoloMode: !!cliOpts.yolo,
         fallbackAdapter: runtime.fallbackAdapter,

package/dist/cli/v4/callbacks.js

@@ -102,6 +102,21 @@ class CliCallbacks {
             }
             if (err) {
                 handle.fail(ms);
+                // v4.1.3-essentials: when the tool's failure payload includes a
+                // structured capability card (auth missing, platform unsupported),
+                // render the card immediately after the fail row. The card sits
+                // on its own multi-line block — the fail row is still useful as
+                // the action timeline anchor; the card adds the state assessment
+                // the user actually needs. No card → plain failure surface.
+                if (result?.capabilityCard) {
+                    this.display.capabilityCard(result.capabilityCard);
+                }
+                return;
+            }
+            // v4.1.3-repl-polish: degraded outcome — tool completed but with a
+            // partial / best-effort result. Show in trail yellow instead of silent.
+            if (result?.degraded) {
+                handle.degraded(ms, result.degradedReason);
                 return;
             }
             handle.ok(ms);

package/dist/cli/v4/chatSession.js

@@ -59,6 +59,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BOOT_TRY_HINT = exports.ChatSession = void 0;
 exports.parseSessionBulletsResponse = parseSessionBulletsResponse;
 exports.renderCommandLabel = renderCommandLabel;
+exports.bootSourceLabel = bootSourceLabel;
 exports.detectOS = detectOS;
 exports.detectShell = detectShell;
 exports.formatStatusState = formatStatusState;
@@ -74,7 +75,12 @@ const sessionSummaryGate_1 = require("./sessionSummaryGate");
 const aidenPrompt_1 = __importDefault(require("./aidenPrompt"));
 const historyStore_1 = require("./historyStore");
 const modelMetadata_1 = require("../../core/v4/modelMetadata");
+// v4.1.3-prebump: classify provider errors so the catch path can show
+// a tailored action hint (e.g. groq 413 → "switch to chatgpt-plus")
+// instead of the generic "/model or aiden doctor" line.
+const errors_1 = require("../../providers/v4/errors");
 const sessionDistiller_1 = require("../../core/v4/sessionDistiller");
+const sessionEndCard_1 = require("./display/sessionEndCard");
 const version_1 = require("../../core/version");
 const distillationStore_1 = require("../../core/v4/distillationStore");
 const promotionCandidates_1 = require("../../core/v4/promotionCandidates");
@@ -154,7 +160,15 @@ const STATUS_BAR_WIDTH = 10;
  * Above this we abandon the LLM half (still write a deterministic-
  * only distillation so the session isn't lost) and exit honestly.
  */
-const SUMMARY_TIMEOUT_MS_DEFAULT = 4000;
+/**
+ * v4.1.3-essentials distillation-fix: bumped 4000 → 12000ms in
+ * lockstep with `sessionDistiller.DEFAULT_TIMEOUT_MS`. Same
+ * rationale — chatgpt-plus Codex cold-start latency for 800-token
+ * summaries regularly exceeds 4s, killing the distillation +
+ * promotion-prompt path. Env override `AIDEN_SUMMARY_TIMEOUT_MS`
+ * still respected.
+ */
+const SUMMARY_TIMEOUT_MS_DEFAULT = 12000;
 function resolveSummaryTimeoutMs() {
     const raw = process.env.AIDEN_SUMMARY_TIMEOUT_MS;
     if (!raw)
@@ -162,6 +176,35 @@ function resolveSummaryTimeoutMs() {
     const parsed = Number.parseInt(raw, 10);
     return Number.isFinite(parsed) && parsed > 0 ? parsed : SUMMARY_TIMEOUT_MS_DEFAULT;
 }
+/**
+ * v4.1.3-prebump: map a providerBootSelector precedence-case label to
+ * a human-readable hint rendered under the boot card's status pills.
+ *
+ * Returns `null` for the explicit-selection cases (`cli-flag`, with-or-
+ * without -partial) where the source isn't surprising. Annotates the
+ * persisted-config / auto-priority / hardcoded-fallback paths so users
+ * understand "why this provider, why now".
+ *
+ * Pure helper — exported for unit testing.
+ */
+function bootSourceLabel(source) {
+    switch (source) {
+        case 'persisted-config':
+            return '(persisted from prior session — /model to change)';
+        case 'config-partial':
+            return '(partial config + auto-resolved companion)';
+        case 'auto-priority':
+            return '(auto-picked — first authed provider)';
+        case 'hardcoded-fallback':
+            return '(no authed providers — using legacy default)';
+        case 'cli-flag':
+        case 'cli-flag-partial':
+            // Explicit CLI override — user knows why; no annotation.
+            return null;
+        default:
+            return null;
+    }
+}
 class ChatSession {
     constructor(opts) {
         this.opts = opts;
@@ -208,6 +251,13 @@ class ChatSession {
          * populated alongside it after a verified write.
          */
         this.lastDistillation = null;
+        /**
+         * Absolute path the most recent distillation JSON was written to.
+         * Captured at write-time and surfaced in the session-end card so the
+         * user has a concrete artifact to inspect or feed to recall_session.
+         * Null when the write failed or no distillation has been produced.
+         */
+        this.lastDistillationPath = null;
         this.currentProviderId = opts.initialProviderId;
         this.currentModelId = opts.initialModelId;
         this.modelMetadata = opts.modelMetadata ?? new modelMetadata_1.ModelMetadata();
@@ -298,6 +348,14 @@ class ChatSession {
                 catch (err) {
                     this.opts.display.warn(`Session summary skipped on ${sig}: ${err.message}`);
                 }
+                // v4.1.3-repl-polish: render session-end card before farewell when
+                // a distillation was written this session. Pass the on-disk path
+                // so the card surfaces the artifact location to the user.
+                if (this.lastDistillation) {
+                    for (const line of (0, sessionEndCard_1.renderSessionEndCard)(this.lastDistillation, (t, k) => this.opts.display.applyColors(t, k), this.lastDistillationPath)) {
+                        this.opts.display.write(line + '\n');
+                    }
+                }
                 this.opts.display.dim('Goodbye.');
                 process.exit(0);
             };
@@ -430,6 +488,12 @@ class ChatSession {
                         // is resumed in the same process (not today's behavior),
                         // otherwise they're skipped — documented in commit.
                         await this.maybeRunPromotion(promptApi);
+                        // v4.1.3-repl-polish: session-end card before farewell.
+                        if (this.lastDistillation) {
+                            for (const line of (0, sessionEndCard_1.renderSessionEndCard)(this.lastDistillation, (t, k) => this.opts.display.applyColors(t, k), this.lastDistillationPath)) {
+                                this.opts.display.write(line + '\n');
+                            }
+                        }
                         break;
                     }
                     if (result.clearHistory)
@@ -555,6 +619,15 @@ class ChatSession {
                 toolTrace: this.sessionToolTrace,
                 auxiliaryClient: this.opts.auxiliaryClient,
                 timeoutMs,
+                // v4.1.3-essentials distillation-fix: route the new
+                // diagnostic signal to a dim line so the user can see WHICH
+                // of the three failure classes fired (timeout / call-fail /
+                // unparseable JSON). Before this hook, all three converged
+                // on a silent `partial:true` and the downstream "no bullets"
+                // warning didn't distinguish them.
+                onDiagnostic: (msg) => {
+                    this.opts.display.dim(`[distill] ${msg}`);
+                },
             });
         }
         catch (err) {
@@ -569,6 +642,7 @@ class ChatSession {
             const dir = node_path_1.default.join(this.opts.paths.root, 'distillations');
             try {
                 const file = await (0, distillationStore_1.writeDistillation)(dir, dist);
+                this.lastDistillationPath = file;
                 this.opts.display.dim(`Session distillation${dist.partial ? ' (partial)' : ''} saved to ${file}`);
             }
             catch (err) {
@@ -896,7 +970,42 @@ class ChatSession {
             if (streamingActive)
                 this.opts.display.streamComplete();
             const msg = err?.message ?? String(err);
-            this.opts.display.printError(msg, 'Run `/model` to switch providers or `aiden doctor` to diagnose.');
+            // v4.1.3-prebump: classify the error so the suggestion below
+            // points at the actual fix instead of the generic "/model or
+            // doctor" line. 413 / 429 / auth get tailored hints; everything
+            // else keeps the legacy fallback. Use the live providerId so
+            // the user sees WHICH provider blew up (matters when fallback
+            // adapters rotate slots mid-turn).
+            const cls = (0, errors_1.classifyProviderError)(err);
+            const tailored = (0, errors_1.suggestForErrorClass)(cls, this.currentProviderId);
+            // v4.1.3-essentials: on `auth` class errors we have enough state
+            // (which provider, what to run) to render a capability card —
+            // structured "what auth's missing, what you can still do, how to
+            // fix" is more useful than the bare message + one-line hint.
+            // Other classes keep the printError single-line surface; their
+            // hints are already specific.
+            if (cls === 'auth') {
+                const p = this.currentProviderId;
+                this.opts.display.printError(msg);
+                this.opts.display.capabilityCard({
+                    title: `${p} authentication required`,
+                    canStill: [
+                        'Continue chatting if a non-auth provider is configured (run `/model`)',
+                        'Run `/auth status` to see which providers are signed in',
+                        'Run `aiden doctor --providers` for a fuller liveness probe',
+                    ],
+                    cannotReliably: [
+                        `Call ${p} until credentials are refreshed`,
+                        'Trust any cached responses that depended on this provider',
+                    ],
+                    fix: `Run \`/auth login ${p}\` if it's an OAuth provider, or set the ` +
+                        `relevant API key env var. Then retry — no need to restart Aiden.`,
+                });
+            }
+            else {
+                this.opts.display.printError(msg, tailored
+                    ?? 'Run `/model` to switch providers or `aiden doctor` to diagnose.');
+            }
             this.setStatusState({ kind: 'ready' });
             this.lastTurnElapsedMs = Date.now() - turnStartedAt;
         }
@@ -979,6 +1088,15 @@ class ChatSession {
             providerOk: !this.opts.unconfigured,
             version: version_1.VERSION,
         }) + '\n');
+        // v4.1.3-prebump: dim source annotation under the pills row so the
+        // user can see WHY this provider/model was chosen — closes the
+        // information gap that made Case 3 (persisted-config) look like a
+        // bug ("why is it still on groq when I auth'd chatgpt-plus?"). One
+        // line, dim, only when the source is informative.
+        const sourceLabel = bootSourceLabel(this.opts.initialBootSource);
+        if (sourceLabel) {
+            display.write(`  ${display.muted(sourceLabel)}\n`);
+        }
         // Tier-3.1b: rule + environment/capabilities block + rule + scroll
         // + bottom prompt hint. Skipped at <70 cols to keep the narrow
         // boot card from wrapping into noise.

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/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/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;
+}