clementine-agent 1.15.0 → 1.16.0

package/dist/agent/assistant.d.ts

@@ -200,6 +200,27 @@ export declare class PersonalAssistant {
      * to avoid blocking the user's query.
      */
     private buildLocalSummary;
+    private buildLocalSummaryFromTurns;
+    /**
+     * Walk a chronological list of transcript turns and pair adjacent
+     * user→assistant rows. Drops 'system' rows and orphan tail user turns
+     * (which represent in-flight messages with no reply yet).
+     */
+    private pairTranscriptTurns;
+    /**
+     * Build a short summary of older turns (older than what's already cached
+     * in `lastExchanges`) for restart-restore prompt injection. Returns ''
+     * if there's nothing older or no memory store. Capped at 600 chars.
+     */
+    private buildOlderTurnsContext;
+    /**
+     * Reconstruct context after the SDK reports the session is dead
+     * ("no conversation found"). Pulls last N turns from the transcripts
+     * table (hydrating `lastExchanges` if the cache is too thin) and
+     * builds a recovery prefix that gets prepended to the retry prompt.
+     * Mirrors the buildContextRecoveredPrompt pattern used by autocompact.
+     */
+    private buildSessionDeathRecoveryPrompt;
     /**
      * Auto-save a lightweight handoff file when a session rotates.
      * Uses in-memory exchange history — no LLM call.

package/dist/agent/assistant.js

@@ -2368,13 +2368,19 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         if (key && this.restoredSessions.has(key)) {
             const exchanges = this.lastExchanges.get(key) ?? [];
             if (exchanges.length > 0) {
+                const olderSummary = this.buildOlderTurnsContext(key, exchanges);
                 const historyLines = [];
                 for (const ex of exchanges.slice(-5)) {
                     historyLines.push(`You said: ${ex.user.slice(0, 800)}`);
                     historyLines.push(`I replied: ${ex.assistant.slice(0, 800)}`);
                 }
-                effectivePrompt =
-                    `[Conversation context from before restart (our recent messages):\n${historyLines.join('\n')}]\n\n${effectivePrompt}`;
+                const blocks = [];
+                if (olderSummary)
+                    blocks.push(`[Older session summary: ${olderSummary}]`);
+                blocks.push(`[Conversation context from before restart (our recent messages):\n${historyLines.join('\n')}]`);
+                const prefix = blocks.join('\n\n');
+                logger.debug({ sessionKey: key, prefixLen: prefix.length, hasOlder: !!olderSummary }, 'Restart restore prefix assembled');
+                effectivePrompt = `${prefix}\n\n${effectivePrompt}`;
             }
             this.restoredSessions.delete(key); // Only inject once per restored session
         }
@@ -2838,10 +2844,11 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                                         break;
                                     }
                                     else if (lower.includes('no conversation found') || lower.includes('conversation not found') || lower.includes('session not found')) {
-                                        // Stale session — clear and retry with fresh session
-                                        logger.warn({ sessionKey }, 'Stale session ID — clearing and retrying');
+                                        // Stale session — clear and reconstruct context from transcripts before retrying
+                                        logger.warn({ sessionKey }, 'Stale session ID — reconstructing context from transcripts');
                                         if (sessionKey) {
                                             this.sessions.delete(sessionKey);
+                                            prompt = this.buildSessionDeathRecoveryPrompt(prompt, sessionKey);
                                         }
                                         staleSession = true;
                                         break; // Break inner stream loop — staleSession flag triggers retry
@@ -2947,10 +2954,11 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                             "I've reset the session. Try again — I'll keep result sets smaller this time.");
                     }
                     else if (errStr.includes('no conversation found') || errStr.includes('conversation not found') || errStr.includes('session not found')) {
-                        // Stale session — clear and retry
-                        logger.warn({ sessionKey }, 'Stale session ID (exception) — clearing and retrying');
+                        // Stale session — clear and reconstruct context from transcripts before retrying
+                        logger.warn({ sessionKey }, 'Stale session ID (exception) — reconstructing context from transcripts');
                         if (sessionKey) {
                             this.sessions.delete(sessionKey);
+                            prompt = this.buildSessionDeathRecoveryPrompt(prompt, sessionKey);
                         }
                         continue; // Retry with fresh session
                     }
@@ -3312,17 +3320,116 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
      * to avoid blocking the user's query.
      */
     buildLocalSummary(sessionKey) {
-        const exchanges = this.lastExchanges.get(sessionKey) ?? [];
-        if (exchanges.length === 0)
+        return this.buildLocalSummaryFromTurns(this.lastExchanges.get(sessionKey) ?? []);
+    }
+    buildLocalSummaryFromTurns(turns, opts) {
+        if (turns.length === 0)
             return '';
-        const recent = exchanges.slice(-5);
+        const take = opts?.take ?? 5;
+        const userMax = opts?.userMax ?? 200;
+        const assistantMax = opts?.assistantMax ?? 300;
+        const recent = turns.slice(-take);
+        const baseIndex = opts?.startIndex ?? (turns.length - recent.length);
         const lines = recent.map((ex, i) => {
-            const userSnippet = ex.user.slice(0, 200).replace(/\n/g, ' ');
-            const assistantSnippet = ex.assistant.slice(0, 300).replace(/\n/g, ' ');
-            return `- Exchange ${exchanges.length - recent.length + i + 1}: User asked about "${userSnippet}" / I responded "${assistantSnippet}"`;
+            const userSnippet = ex.user.slice(0, userMax).replace(/\n/g, ' ');
+            const assistantSnippet = ex.assistant.slice(0, assistantMax).replace(/\n/g, ' ');
+            return `- Exchange ${baseIndex + i + 1}: User asked about "${userSnippet}" / I responded "${assistantSnippet}"`;
         });
         return lines.join('\n');
     }
+    /**
+     * Walk a chronological list of transcript turns and pair adjacent
+     * user→assistant rows. Drops 'system' rows and orphan tail user turns
+     * (which represent in-flight messages with no reply yet).
+     */
+    pairTranscriptTurns(turns) {
+        const pairs = [];
+        let pendingUser = null;
+        for (const turn of turns) {
+            if (turn.role === 'user') {
+                pendingUser = turn.content;
+            }
+            else if (turn.role === 'assistant' && pendingUser !== null) {
+                pairs.push({ user: pendingUser, assistant: turn.content });
+                pendingUser = null;
+            }
+        }
+        return pairs;
+    }
+    /**
+     * Build a short summary of older turns (older than what's already cached
+     * in `lastExchanges`) for restart-restore prompt injection. Returns ''
+     * if there's nothing older or no memory store. Capped at 600 chars.
+     */
+    buildOlderTurnsContext(sessionKey, cachedExchanges) {
+        if (cachedExchanges.length === 0)
+            return '';
+        if (!this.memoryStore || typeof this.memoryStore.getTranscriptTail !== 'function')
+            return '';
+        try {
+            const skipTurns = cachedExchanges.length * 2;
+            const older = this.memoryStore.getTranscriptTail(sessionKey, skipTurns, 40);
+            if (!older || older.length === 0)
+                return '';
+            const pairs = this.pairTranscriptTurns(older);
+            if (pairs.length === 0)
+                return '';
+            const summary = this.buildLocalSummaryFromTurns(pairs, {
+                take: pairs.length,
+                userMax: 120,
+                assistantMax: 180,
+            });
+            return summary.slice(0, 600);
+        }
+        catch (err) {
+            logger.debug({ err, sessionKey }, 'buildOlderTurnsContext failed — non-fatal');
+            return '';
+        }
+    }
+    /**
+     * Reconstruct context after the SDK reports the session is dead
+     * ("no conversation found"). Pulls last N turns from the transcripts
+     * table (hydrating `lastExchanges` if the cache is too thin) and
+     * builds a recovery prefix that gets prepended to the retry prompt.
+     * Mirrors the buildContextRecoveredPrompt pattern used by autocompact.
+     */
+    buildSessionDeathRecoveryPrompt(prompt, sessionKey) {
+        if (!sessionKey || !this.memoryStore)
+            return prompt;
+        try {
+            let exchanges = this.lastExchanges.get(sessionKey) ?? [];
+            // Hydrate from transcripts if the cache is too thin
+            if (exchanges.length < 3 && typeof this.memoryStore.getTranscriptTail === 'function') {
+                const recent = this.memoryStore.getTranscriptTail(sessionKey, 0, SESSION_EXCHANGE_HISTORY_SIZE * 2);
+                const hydrated = this.pairTranscriptTurns(recent ?? []);
+                if (hydrated.length > exchanges.length) {
+                    exchanges = hydrated;
+                    this.lastExchanges.set(sessionKey, hydrated.slice(-SESSION_EXCHANGE_HISTORY_SIZE));
+                }
+            }
+            const olderSummary = this.buildOlderTurnsContext(sessionKey, exchanges);
+            const recentLines = [];
+            for (const ex of exchanges.slice(-5)) {
+                recentLines.push(`You said: ${ex.user.slice(0, 800)}`);
+                recentLines.push(`I replied: ${ex.assistant.slice(0, 800)}`);
+            }
+            if (!olderSummary && recentLines.length === 0)
+                return prompt;
+            const blocks = ['[Recovering context after session expired.'];
+            if (olderSummary)
+                blocks.push(`Older session summary: ${olderSummary}`);
+            if (recentLines.length > 0) {
+                blocks.push(`Recent messages:\n${recentLines.join('\n')}`);
+            }
+            const prefix = blocks.join('\n') + ']';
+            logger.debug({ sessionKey, prefixLen: prefix.length }, 'Session-death recovery prefix assembled');
+            return `${prefix}\n\n${prompt}`;
+        }
+        catch (err) {
+            logger.debug({ err, sessionKey }, 'buildSessionDeathRecoveryPrompt failed — non-fatal');
+            return prompt;
+        }
+    }
     /**
      * Auto-save a lightweight handoff file when a session rotates.
      * Uses in-memory exchange history — no LLM call.

package/dist/memory/store.d.ts

@@ -473,6 +473,13 @@ export declare class MemoryStore {
      * Get all turns for a given session, ordered chronologically.
      */
     getSessionTranscript(sessionKey: string): TranscriptTurn[];
+    /**
+     * Get user/assistant transcript turns from the tail of a session, skipping
+     * the most recent `skipFromTail` turns. Returned chronologically. Used to
+     * reconstruct context older than what's already in the in-memory cache,
+     * for restart restore and SDK session-death recovery.
+     */
+    getTranscriptTail(sessionKey: string, skipFromTail: number, limit?: number): TranscriptTurn[];
     /**
      * Get recent transcript activity across all sessions since a given timestamp.
      * Returns a compact summary of what happened (sessions, message counts, snippets).

package/dist/memory/store.js

@@ -2393,6 +2393,30 @@ export class MemoryStore {
             createdAt: row.created_at,
         }));
     }
+    /**
+     * Get user/assistant transcript turns from the tail of a session, skipping
+     * the most recent `skipFromTail` turns. Returned chronologically. Used to
+     * reconstruct context older than what's already in the in-memory cache,
+     * for restart restore and SDK session-death recovery.
+     */
+    getTranscriptTail(sessionKey, skipFromTail, limit = 40) {
+        const rows = this.conn
+            .prepare(`SELECT session_key, role, content, model, created_at
+         FROM transcripts
+         WHERE session_key = ? AND role IN ('user','assistant')
+         ORDER BY created_at DESC, id DESC
+         LIMIT ? OFFSET ?`)
+            .all(sessionKey, limit, Math.max(0, skipFromTail));
+        return rows
+            .map((row) => ({
+            sessionKey: row.session_key,
+            role: row.role,
+            content: row.content,
+            model: row.model,
+            createdAt: row.created_at,
+        }))
+            .reverse();
+    }
     /**
      * Get recent transcript activity across all sessions since a given timestamp.
      * Returns a compact summary of what happened (sessions, message counts, snippets).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clementine-agent",
-  "version": "1.15.0",
+  "version": "1.16.0",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",