aiden-runtime 4.1.1 → 4.1.2

package/dist/cli/v4/chatSession.js

@@ -19,11 +19,45 @@
  *   5. Re-renders the status line after every turn.
  *
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BOOT_TRY_HINT = exports.ChatSession = void 0;
+exports.parseSessionBulletsResponse = parseSessionBulletsResponse;
 exports.renderCommandLabel = renderCommandLabel;
 exports.detectOS = detectOS;
 exports.detectShell = detectShell;
@@ -36,14 +70,70 @@ exports.formatDuration = formatDuration;
 exports.renderMemoryConfirmations = renderMemoryConfirmations;
 const display_1 = require("./display");
 const uiBuild_1 = require("./uiBuild");
+const sessionSummaryGate_1 = require("./sessionSummaryGate");
 const aidenPrompt_1 = __importDefault(require("./aidenPrompt"));
 const historyStore_1 = require("./historyStore");
 const modelMetadata_1 = require("../../core/v4/modelMetadata");
+const sessionDistiller_1 = require("../../core/v4/sessionDistiller");
+const version_1 = require("../../core/version");
+const distillationStore_1 = require("../../core/v4/distillationStore");
+const promotionCandidates_1 = require("../../core/v4/promotionCandidates");
+const promotionPrompt_1 = require("./promotionPrompt");
+const node_path_1 = __importDefault(require("node:path"));
 const bracketedPaste_1 = require("./bracketedPaste");
 const pasteCompression_1 = require("./pasteCompression");
 const pasteIntercept_1 = require("./pasteIntercept");
 const shellInterpolation_1 = require("./shellInterpolation");
 const resizeGuard_1 = require("./resizeGuard");
+/**
+ * Phase v4.1.2 session-summary-followup: parse the auxiliary client's
+ * JSON-array response into a clean `string[]` of bullets. Defensive —
+ * tries direct JSON.parse first, then a fenced-code-block strip, then
+ * a "first [...] block" extraction. Returns null when nothing usable
+ * comes out so the caller can retry once with a stricter prompt.
+ *
+ * Exported for unit tests.
+ */
+function parseSessionBulletsResponse(raw) {
+    if (typeof raw !== 'string' || raw.trim().length === 0)
+        return null;
+    const tryParseArray = (s) => {
+        try {
+            const parsed = JSON.parse(s);
+            if (!Array.isArray(parsed))
+                return null;
+            const strings = parsed
+                .filter((x) => typeof x === 'string')
+                .map((x) => x.trim())
+                .filter((x) => x.length > 0);
+            return strings.length > 0 ? strings : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    // 1. Try the response as-is.
+    const direct = tryParseArray(raw.trim());
+    if (direct)
+        return direct;
+    // 2. Strip Markdown code fences if present (```json ... ``` or ``` ... ```).
+    const fenceMatch = raw.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (fenceMatch && fenceMatch[1]) {
+        const inFence = tryParseArray(fenceMatch[1].trim());
+        if (inFence)
+            return inFence;
+    }
+    // 3. Extract the first balanced [...] block from anywhere in the text.
+    const bracketStart = raw.indexOf('[');
+    const bracketEnd = raw.lastIndexOf(']');
+    if (bracketStart >= 0 && bracketEnd > bracketStart) {
+        const slice = raw.slice(bracketStart, bracketEnd + 1);
+        const extracted = tryParseArray(slice);
+        if (extracted)
+            return extracted;
+    }
+    return null;
+}
 /**
  * Tier-3.1 helper: render a slash-command label honouring the
  * `AIDEN_UI_ICONS` opt-in. Default OFF — emoji icons are gated to
@@ -55,18 +145,23 @@ function renderCommandLabel(cmd) {
         ? `${cmd.icon} /${cmd.name}`
         : `/${cmd.name}`;
 }
-/** Aiden version pulled from package.json at require-time; falls back
- *  to a static literal so TS compiles without a JSON resolution wobble. */
-const AIDEN_VERSION = (() => {
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        return require('../../package.json').version ?? '4.0.0';
-    }
-    catch {
-        return '4.0.0';
-    }
-})();
 const STATUS_BAR_WIDTH = 10;
+/**
+ * Phase v4.1.2-memory-AB: hard cap on the session distillation
+ * auxiliary call. Default 4000 ms — comfortable headroom for
+ * chatgpt-plus (typical ~1-2s), generous for groq (typical <1s).
+ * Override via `AIDEN_SUMMARY_TIMEOUT_MS` env var for power users.
+ * 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;
+function resolveSummaryTimeoutMs() {
+    const raw = process.env.AIDEN_SUMMARY_TIMEOUT_MS;
+    if (!raw)
+        return SUMMARY_TIMEOUT_MS_DEFAULT;
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : SUMMARY_TIMEOUT_MS_DEFAULT;
+}
 class ChatSession {
     constructor(opts) {
         this.opts = opts;
@@ -88,6 +183,31 @@ class ChatSession {
         // provider used last turn (so a switch surfaces as `groq ──→ together`).
         this.lastTurnElapsedMs = 0;
         this.lastFooterProvider = null;
+        /**
+         * Phase v4.1.2-memory-AB:
+         * Accumulated tool-call trace across every `runConversation` call
+         * in this ChatSession instance. Fed to the session distiller at
+         * exit to derive deterministic fields (files_touched, tools_used).
+         * Reset only when ChatSession itself is re-instantiated.
+         */
+        this.sessionToolTrace = [];
+        /**
+         * Phase v4.1.2-memory-AB:
+         * Idempotency flag. Set ONLY after a successful summary write
+         * (verified-on-disk via MemoryGuard). A failed or timed-out attempt
+         * leaves this `false` so the next exit path retries — matches the
+         * "honest by design / best-effort, log clearly" stance.
+         * Scoped to ChatSession instance lifetime (no DB persistence).
+         */
+        this.summarized = false;
+        /**
+         * Phase v4.1.2-memory-D:
+         * Last successful distillation, cached so the promotion-prompt flow
+         * (`/quit` path only — SIGINT/SIGTERM skip) can extract candidates
+         * without re-driving the auxiliary LLM. Mirrors `summarized` —
+         * populated alongside it after a verified write.
+         */
+        this.lastDistillation = null;
         this.currentProviderId = opts.initialProviderId;
         this.currentModelId = opts.initialModelId;
         this.modelMetadata = opts.modelMetadata ?? new modelMetadata_1.ModelMetadata();
@@ -129,6 +249,11 @@ class ChatSession {
             paths: this.opts.paths,
         });
         this.opts.agent.setProvider(adapter);
+        // Phase v4.1.2-bug2: keep the prompt's Runtime slot in lockstep
+        // with the routed provider. Without this, the agent's adapter
+        // swaps correctly but its system prompt keeps self-describing as
+        // the boot-time provider/model for the rest of the session.
+        this.opts.agent.setActiveModel(providerId, modelId);
         this.currentProviderId = providerId;
         this.currentModelId = modelId;
     }
@@ -152,15 +277,49 @@ class ChatSession {
         }
         // 2. Boxed startup card.
         await this.renderStartupCard();
-        // 3. Optional SIGINT handler.
+        // 3. Optional SIGINT / SIGTERM handlers.
+        //
+        // Phase v4.1.2-memory-AB: SIGINT used to do `process.exit(0)` directly,
+        // bypassing session_summary + the new distillation file. The Ctrl-C
+        // path is the most common premature exit, so it's now hooked too.
+        // Both signals route to the same async-with-timeout helper; on
+        // timeout (default 4s, override AIDEN_SUMMARY_TIMEOUT_MS) the exit
+        // proceeds anyway with a dim log line — honest about the skip.
         let sigintHandler = null;
+        let sigtermHandler = null;
+        let exitHandler = null;
         if (this.opts.installSignalHandler !== false) {
-            sigintHandler = () => {
+            const makeHandler = (sig) => async () => {
                 this.opts.display.write('\n');
+                this.opts.display.dim(`Got ${sig.toUpperCase()} — saving session before exit…`);
+                try {
+                    await this.maybeAutoSummarizeWithTimeout(sig);
+                }
+                catch (err) {
+                    this.opts.display.warn(`Session summary skipped on ${sig}: ${err.message}`);
+                }
                 this.opts.display.dim('Goodbye.');
                 process.exit(0);
             };
+            sigintHandler = makeHandler('sigint');
+            sigtermHandler = makeHandler('sigterm');
             process.on('SIGINT', sigintHandler);
+            process.on('SIGTERM', sigtermHandler);
+            // Last-resort safety net: synchronous-only hook, so we can't run
+            // the auxiliary call here. Just log when we exited without
+            // summarizing so the user knows where to look for missing data.
+            exitHandler = () => {
+                if (!this.summarized) {
+                    // Best-effort one-liner — stderr because stdout may be torn
+                    // down already.
+                    try {
+                        process.stderr.write('[aiden] process exiting without session summary — ' +
+                            'distillation file not written for this session.\n');
+                    }
+                    catch { /* nothing to do */ }
+                }
+            };
+            process.on('exit', exitHandler);
         }
         // 4. Main loop.
         // Tier-3.1.1: feed the new aidenPrompt with live slash commands +
@@ -254,8 +413,25 @@ class ChatSession {
                         // Phase 18: raw text prompt for /auth login OAuth code paste.
                         prompt: (msg) => promptApi.readLine(msg),
                     });
-                    if (result.exit)
+                    if (result.exit) {
+                        // Phase v4.1.2 alive-core / Phase v4.1.2-memory-AB:
+                        // auto-trigger session distillation on /quit when the
+                        // session was substantive (≥3 user turns). SIGINT and
+                        // SIGTERM now also hit this path via their own handlers
+                        // above; the in-memory `summarized` flag prevents double-
+                        // writes. The /quit path tags exit_path='quit' so the
+                        // distillation file records which exit class fired.
+                        await this.maybeAutoSummarizeWithTimeout('quit');
+                        // Phase v4.1.2-memory-D: promotion prompt — only on /quit,
+                        // NEVER from signal handlers (async stdin in a signal
+                        // handler context is unsafe). Distillation files from
+                        // SIGINT-exited sessions stay on disk; their candidates
+                        // surface on the next `/quit` only if the conversation
+                        // is resumed in the same process (not today's behavior),
+                        // otherwise they're skipped — documented in commit.
+                        await this.maybeRunPromotion(promptApi);
                         break;
+                    }
                     if (result.clearHistory)
                         this.history = [];
                     // Phase 23.6 — v3 doesn't print a status footer after slash
@@ -268,6 +444,10 @@ class ChatSession {
         finally {
             if (sigintHandler)
                 process.off('SIGINT', sigintHandler);
+            if (sigtermHandler)
+                process.off('SIGTERM', sigtermHandler);
+            if (exitHandler)
+                process.off('exit', exitHandler);
             if (pasteEnabled)
                 (0, bracketedPaste_1.disableBracketedPaste)(stdout);
             restorePasteInterceptor();
@@ -275,6 +455,326 @@ class ChatSession {
         }
     }
     // ── Inner: a single agent turn ─────────────────────────────────────
+    /**
+     * Phase v4.1.2 alive-core (refined v4.1.2-followup-2): auto-trigger
+     * `session_summary` on /quit when the session was substantive
+     * (≥3 user turns). The synthetic prompt forces the model to call
+     * the tool — prose-only responses are not acceptable.
+     *
+     * Every non-success path is logged explicitly so users always know
+     * what happened:
+     *   - threshold-skip → log: "session too short, skipping summary"
+     *   - unconfigured-skip → log: "no provider, skipping summary"
+     *   - tool-not-called (model returned prose) → log a clear warning
+     *   - tool-errored (throw) → log the error verbatim
+     *   - tool-succeeded → log the absolute MEMORY.md path
+     *
+     * Post-run verification: compare MEMORY.md size+mtime before vs
+     * after the synthetic turn. If unchanged, the model didn't actually
+     * fire the tool and the user gets a "run /session-summary manually
+     * next time" hint.
+     *
+     * SIGINT and crash paths skip this method entirely because the
+     * signal handler does process.exit(0) before this slash-command
+     * branch runs.
+     */
+    /**
+     * Phase v4.1.2-memory-AB: combined Phase A (reliable session-end
+     * firing) + Phase B (structured distillation) entry point.
+     *
+     * Drives one auxiliary-LLM call, produces a SessionDistillation,
+     * writes the distillation JSON to <paths.root>/distillations/, AND
+     * writes the bullets-only summary to MEMORY.md via the existing
+     * sessionSummaryTool — both artifacts populated from the single
+     * LLM call (no extra cost over the previous Path D).
+     *
+     * Idempotency: `this.summarized` is set to true ONLY on full
+     * success (MEMORY.md write verified). Failed or timed-out attempts
+     * leave the flag false so the next exit path retries. Lightweight
+     * in-memory flag pattern — clears on normal completion, only set
+     * after a fully verified write.
+     *
+     * Timeout: SUMMARY_TIMEOUT_MS_DEFAULT (4s) override via env var.
+     * On timeout the LLM result is treated as empty → distillation
+     * file written with `partial: true` + deterministic fields only;
+     * MEMORY.md not updated (no bullets to write).
+     *
+     * Honest logging: every skip / timeout / partial path produces a
+     * user-visible dim or warn line. No silent drops.
+     */
+    async maybeAutoSummarizeWithTimeout(exitPath) {
+        // Idempotency check first — cheapest possible bail.
+        if (this.summarized) {
+            this.opts.display.dim(`Session already summarized; skipping ${exitPath} re-fire.`);
+            return;
+        }
+        const userTurns = this.history.filter((m) => m.role === 'user').length;
+        const memoryPath = this.opts.paths?.memoryMd;
+        const gate = (0, sessionSummaryGate_1.shouldAutoSummarize)({
+            userTurns,
+            unconfigured: !!this.opts.unconfigured,
+            memoryPath,
+        });
+        if (gate.fire === false) {
+            switch (gate.reason) {
+                case 'short':
+                    this.opts.display.dim(`Skipping session summary — only ${userTurns} user turn(s), need ${sessionSummaryGate_1.SESSION_SUMMARY_MIN_TURNS}+.`);
+                    return;
+                case 'unconfigured':
+                    this.opts.display.dim('Skipping session summary — no provider configured.');
+                    return;
+                case 'no-paths':
+                    this.opts.display.dim('Skipping session summary — no aiden paths wired (test mode?).');
+                    return;
+            }
+        }
+        if (!this.opts.auxiliaryClient || !this.opts.memoryGuard || !this.opts.memoryManager) {
+            this.opts.display.warn('Skipping session summary — auxiliary client / memory plumbing not wired ' +
+                '(this is normal in test mode; real CLI sessions get all three).');
+            return;
+        }
+        const timeoutMs = resolveSummaryTimeoutMs();
+        const memoryPathSafe = memoryPath;
+        this.opts.display.dim(`Generating session distillation via auxiliary client (timeout ${timeoutMs}ms)…`);
+        // Snapshot MEMORY.md state to detect post-write whether the write
+        // actually advanced the file — preserves the verify-on-disk check
+        // from the pre-AB path.
+        const before = await this.snapshotMemoryStat(memoryPathSafe);
+        // Single auxiliary call → SessionDistillation. distillSession
+        // owns its own internal timeout, so we don't need an outer race
+        // here; the deterministic fields populate regardless of LLM
+        // outcome (so even a full timeout produces a useful artifact).
+        let dist;
+        try {
+            dist = await (0, sessionDistiller_1.distillSession)({
+                sessionId: this.sessionId ?? `unbound-${Date.now()}`,
+                startedAt: new Date(this.startedAt).toISOString(),
+                exitPath,
+                userTurns,
+                messages: this.history,
+                toolTrace: this.sessionToolTrace,
+                auxiliaryClient: this.opts.auxiliaryClient,
+                timeoutMs,
+            });
+        }
+        catch (err) {
+            this.opts.display.warn(`Session distillation failed: ${err.message}. ` +
+                `MEMORY.md unchanged at: ${memoryPathSafe}`);
+            return;
+        }
+        // Persist the distillation JSON. Failures are recorded into the
+        // slice3 subsystem health surface (when the agent wires one) and
+        // logged here; they don't block the MEMORY.md write.
+        if (this.opts.paths?.root) {
+            const dir = node_path_1.default.join(this.opts.paths.root, 'distillations');
+            try {
+                const file = await (0, distillationStore_1.writeDistillation)(dir, dist);
+                this.opts.display.dim(`Session distillation${dist.partial ? ' (partial)' : ''} saved to ${file}`);
+            }
+            catch (err) {
+                this.opts.display.warn(`Distillation write failed: ${err.message}. ` +
+                    `(Continuing to MEMORY.md update.)`);
+            }
+        }
+        // Update MEMORY.md `## Recent sessions` via the existing tool — no
+        // change to its on-disk shape (back-compat per slice's hard
+        // constraint). Skip when bullets are empty (full LLM timeout) —
+        // a zero-bullet entry would just be noise in MEMORY.md.
+        if (dist.bullets.length === 0) {
+            this.opts.display.warn(`Session summary skipped MEMORY.md update — auxiliary returned no bullets ` +
+                `(distillation file may still have deterministic fields).`);
+            return;
+        }
+        try {
+            const { sessionSummaryTool } = await Promise.resolve().then(() => __importStar(require('../../tools/v4/memory/sessionSummary')));
+            const result = await sessionSummaryTool.execute({ bullets: dist.bullets, trigger: 'auto-quit' }, {
+                cwd: process.cwd(),
+                paths: this.opts.paths,
+                memory: this.opts.memoryManager,
+                memoryGuard: this.opts.memoryGuard,
+            });
+            if (!result.success) {
+                this.opts.display.warn(`Session summary failed: ${result.error ?? 'unknown error'}. ` +
+                    `MEMORY.md may be unchanged at: ${memoryPathSafe}`);
+                return;
+            }
+        }
+        catch (err) {
+            this.opts.display.warn(`Session summary failed during write: ${err.message}. ` +
+                `MEMORY.md unchanged at: ${memoryPathSafe}`);
+            return;
+        }
+        const after = await this.snapshotMemoryStat(memoryPathSafe);
+        if ((0, sessionSummaryGate_1.memoryGrewBetween)(before, after)) {
+            this.opts.display.dim(`Session summary saved to ${memoryPathSafe}`);
+            // Mark summarized ONLY after both writes verified — partial
+            // states leave the flag false so the next exit path retries.
+            this.summarized = true;
+            // Phase v4.1.2-memory-D: cache the distillation for the promotion
+            // flow. The /quit handler (and only /quit) consults this to build
+            // candidates without re-driving the auxiliary LLM.
+            this.lastDistillation = dist;
+        }
+        else {
+            this.opts.display.warn(`Session summary write completed but MEMORY.md size+mtime did not advance. ` +
+                `Check ${memoryPathSafe} manually.`);
+        }
+    }
+    /**
+     * Phase v4.1.2-memory-D: promotion-prompt flow.
+     *
+     * Called from the `/quit` path ONLY (NOT from SIGINT/SIGTERM
+     * handlers — async stdin can't be safely driven from a signal
+     * handler context). Builds candidates from `this.history` +
+     * `this.lastDistillation`, dedups against the existing
+     * `## Durable facts` section in MEMORY.md, prompts the user,
+     * persists approved selections.
+     *
+     * Gates (any false → silent no-op):
+     *   - this.summarized              (need a fresh distillation)
+     *   - this.lastDistillation        (set alongside summarized)
+     *   - this.opts.memoryManager      (real CLI sessions only)
+     *   - this.opts.memoryGuard        (real CLI sessions only)
+     *
+     * UX rules per Phase D's Q5 first-run experience:
+     *   - 0 candidates AND 0 totalBeforeDedup → completely silent
+     *   - 0 candidates AFTER dedup, but some were dropped → dim line
+     *     "N candidates already in durable facts — nothing new to promote"
+     *   - >0 candidates → prompt for approval, write approved
+     */
+    async maybeRunPromotion(api) {
+        if (!this.summarized || !this.lastDistillation)
+            return;
+        if (!this.opts.memoryManager || !this.opts.memoryGuard)
+            return;
+        let existingBody;
+        try {
+            existingBody = await (0, promotionPrompt_1.readExistingDurableFactsBody)(this.opts.memoryManager);
+        }
+        catch (err) {
+            this.opts.display.warn(`Could not read existing durable facts: ${err.message}. ` +
+                `Promotion skipped.`);
+            return;
+        }
+        const built = (0, promotionCandidates_1.extractCandidates)(this.history, this.lastDistillation, existingBody);
+        // Silent on truly empty sessions; reward the user on "all already saved".
+        if (built.candidates.length === 0) {
+            if (built.totalBeforeDedup === 0) {
+                return; // no signals + no distillation gold to promote — silent
+            }
+            if (built.dedupedAgainstExisting > 0) {
+                this.opts.display.dim(`${built.dedupedAgainstExisting} candidate${built.dedupedAgainstExisting === 1 ? '' : 's'} ` +
+                    `already in durable facts — nothing new to promote.`);
+            }
+            return;
+        }
+        let approved;
+        try {
+            approved = await (0, promotionPrompt_1.promptForApproval)(api, this.opts.display, built.candidates);
+        }
+        catch (err) {
+            // The prompt API throwing is rare (broken stdin, etc.) — log
+            // and skip; no auto-write on error per "opt-in by design".
+            this.opts.display.warn(`Promotion prompt failed: ${err.message}. ` +
+                `Nothing was written to durable facts.`);
+            return;
+        }
+        if (approved.length === 0)
+            return; // user replied skip / none / unparseable
+        try {
+            const result = await (0, promotionPrompt_1.writeApprovedDurableFacts)(this.opts.memoryManager, this.opts.memoryGuard, approved);
+            if (result.ok && result.verified) {
+                this.opts.display.dim(`Promoted ${approved.length} fact${approved.length === 1 ? '' : 's'} ` +
+                    `to MEMORY.md \`## Durable facts\`.`);
+            }
+            else {
+                this.opts.display.warn(`Durable-facts write completed but did not verify: ` +
+                    `${result.reason ?? 'unknown'}. Inspect MEMORY.md manually.`);
+            }
+        }
+        catch (err) {
+            this.opts.display.warn(`Durable-facts write failed: ${err.message}. ` +
+                `MEMORY.md may be unchanged.`);
+        }
+    }
+    /**
+     * Phase v4.1.2 session-summary-followup: ask the auxiliary client
+     * for a JSON array of 5 session-summary bullets. One retry on
+     * malformed output with a stricter "JSON only" reminder, then we
+     * surface the failure honestly via the caller's warn() log.
+     *
+     * Returns `null` when both attempts fail to yield a valid array.
+     */
+    async requestSessionBulletsFromAuxiliary() {
+        const aux = this.opts.auxiliaryClient;
+        const transcript = this.buildSessionTranscriptForSummary();
+        const promptStrict = (extraNote) => [
+            'Summarize this session in EXACTLY 5 short bullets. Focus on:',
+            '- what we worked on',
+            '- decisions made',
+            '- files / commits changed',
+            '- problems solved',
+            '- open items',
+            '',
+            'Respond with ONLY a JSON array of 5 strings. No prose. No explanation. ' +
+                'No code fences. No leading or trailing text.',
+            '',
+            'Example: ["Shipped v4.1.1 to npm", "Diagnosed OAuth bug", "Patched tool schema", "Added doctor --providers", "Queued auxiliary fallback"]',
+            '',
+            extraNote,
+            '',
+            'Session transcript:',
+            transcript,
+        ].filter((s) => s.length > 0).join('\n');
+        const attempt = async (note) => {
+            const res = await aux.call({
+                purpose: 'session_summary',
+                prompt: promptStrict(note),
+                maxTokens: 800,
+                timeoutMs: 30000,
+            });
+            return parseSessionBulletsResponse(res.content);
+        };
+        const first = await attempt('');
+        if (first)
+            return first;
+        const second = await attempt('STRICT: Your previous response was not parseable. Return ONLY the JSON array, nothing else.');
+        return second;
+    }
+    /**
+     * Compress recent history into a transcript blob the auxiliary
+     * client can summarise. Caps to the last 30 messages so the
+     * auxiliary prompt stays under typical small-model context limits;
+     * the auxiliary's `maxTokens: 800` output budget bounds the cost.
+     */
+    buildSessionTranscriptForSummary() {
+        const recent = this.history.slice(-30);
+        const lines = [];
+        for (const m of recent) {
+            const role = m.role === 'user' ? 'USER' : m.role === 'assistant' ? 'AIDEN' : m.role.toUpperCase();
+            const content = typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
+            // Truncate any single message to 800 chars so a giant paste
+            // doesn't blow the prompt budget.
+            const trimmed = content.length > 800 ? `${content.slice(0, 800)}…` : content;
+            lines.push(`${role}: ${trimmed}`);
+        }
+        return lines.join('\n\n');
+    }
+    /**
+     * Read MEMORY.md size + mtime for the pre/post-write comparison in
+     * `maybeAutoSummarize`. Missing file is normalised to zeros so the
+     * "did MEMORY.md grow" comparison is well-defined even on fresh installs.
+     */
+    async snapshotMemoryStat(p) {
+        try {
+            const { promises: fsPromises } = await Promise.resolve().then(() => __importStar(require('node:fs')));
+            const stat = await fsPromises.stat(p);
+            return { size: stat.size, mtime: stat.mtimeMs };
+        }
+        catch {
+            return { size: 0, mtime: 0 };
+        }
+    }
     async runAgentTurn(userInput) {
         // Phase 30.2.1 — explore mode: short-circuit BEFORE building the
         // turn-status spinner / agent call. The wizard skipped, so there's
@@ -368,6 +868,12 @@ class ChatSession {
             // Unverified writes get a quieter line so the user knows the model
             // tried but the round-trip didn't confirm.
             renderMemoryConfirmations(result.toolCallTrace, this.opts.display);
+            // Phase v4.1.2-memory-AB: accumulate the turn's tool-call trace
+            // so the session distiller can derive deterministic fields
+            // (files_touched / tools_used) at exit.
+            if (result.toolCallTrace && result.toolCallTrace.length > 0) {
+                this.sessionToolTrace.push(...result.toolCallTrace);
+            }
             // When streaming was active and emitted the final content already,
             // skip the markdown re-render — we'd otherwise duplicate text.
             if (result.finalContent && !streamingActive) {
@@ -444,7 +950,7 @@ class ChatSession {
         const cols = display.cols();
         const isNarrow = cols < 60;
         const showEnvCapBlock = cols >= 70;
-        const version = AIDEN_VERSION;
+        const version = version_1.VERSION;
         display.write('\n');
         if (isNarrow) {
             // Compact — single-line text logo + one-line capability summary.
@@ -462,12 +968,16 @@ class ChatSession {
             display.write('\n');
         }
         // Status pills.
+        // Phase v4.1.2-version-display: append the running version as the
+        // fifth pill so users see what they're on without invoking
+        // `aiden --version`. Sourced from the build-injected core/version.ts.
         display.write(display.statusPillsRow({
             coreOnline: true,
             mode: 'auto',
             model: this.currentModelId,
             memoryActive: true,
             providerOk: !this.opts.unconfigured,
+            version: version_1.VERSION,
         }) + '\n');
         // Tier-3.1b: rule + environment/capabilities block + rule + scroll
         // + bottom prompt hint. Skipped at <70 cols to keep the narrow

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/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 ──