clementine-agent 1.15.0 → 1.17.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.
@@ -4662,13 +4769,28 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             // Periodic progress beacon — sends a status update every 5 minutes
             // so the user knows the task is still alive during long phases.
             // Capped at 3 messages per phase to prevent notification spam.
+            // Also refreshes status.json so dashboard polls see liveness even
+            // when the SDK stream hasn't emitted a result yet.
             const BEACON_INTERVAL_MS = 5 * 60 * 1000;
             const MAX_BEACONS_PER_PHASE = 3;
             let beaconCount = 0;
             const beaconTimer = setInterval(() => {
+                const mins = Math.round((Date.now() - phaseStart) / 60_000);
+                try {
+                    writeStatus({
+                        jobName,
+                        status: 'running',
+                        phase,
+                        startedAt,
+                        maxHours: effectiveMaxHours,
+                        phaseStartedAt: new Date(phaseStart).toISOString(),
+                        phaseElapsedMin: mins,
+                        toolCallsThisPhase: phaseToolCount,
+                    });
+                }
+                catch { /* non-fatal */ }
                 if (this.onPhaseProgress && beaconCount < MAX_BEACONS_PER_PHASE) {
                     beaconCount++;
-                    const mins = Math.round((Date.now() - phaseStart) / 60_000);
                     try {
                         // Conversational beacon — no technical jargon
                         const msg = mins < 3
@@ -4719,6 +4841,22 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                         // Capture terminal reason for execution advisor
                         this._lastTerminalReason = result.terminal_reason ?? undefined;
                         this.logQueryResult(result, 'unleashed', `unleashed:${jobName}`, jobName);
+                        // Refresh status.json the moment the SDK reports result —
+                        // even if the underlying stream stalls afterward, the dashboard
+                        // sees liveness instead of a frozen "phase 0 / running" row.
+                        try {
+                            writeStatus({
+                                jobName,
+                                status: 'running',
+                                phase,
+                                startedAt,
+                                maxHours: effectiveMaxHours,
+                                lastResultAt: new Date().toISOString(),
+                                lastResultIsError: !!result.is_error,
+                                toolCallsThisPhase: phaseToolCount,
+                            });
+                        }
+                        catch { /* non-fatal */ }
                         // Detect dollar-budget exceeded (strict marker — see cron
                         // handler above for the reasoning).
                         if (result.is_error && 'result' in result) {

package/dist/agent/complexity-classifier.js

@@ -50,6 +50,21 @@ const CHAIN_MARKERS = [
     /\bonce\s+(that|you)\b.*,/i,
     /\bnext\b.*,/i,
 ];
+/**
+ * Patterns that look like a pasted error message or stack trace.
+ * Error pastes are long and entity-heavy (file paths, quoted strings,
+ * "Error:" prefixes), which previously tripped the deepWorthy gate
+ * even when the user was just asking "what's wrong with this?". We
+ * still allow the plan-first directive to fire; we just don't auto-spawn
+ * an expensive multi-phase background task on a debug request.
+ */
+const ERROR_PASTE_MARKERS = [
+    /\b(Error|Exception|Traceback|Stack ?trace):\s/i,
+    /^\s*at\s+[\w.$<>]+\s*\(/m, // JS/TS stack frame: "at foo.bar (file:line)"
+    /\bfailed:\s*Error\b/i,
+    /Reached maximum number of turns/i,
+    /\bENOENT\b|\bECONNREFUSED\b|\bETIMEDOUT\b/,
+];
 /**
  * Phrasings that explicitly ask for plan-first behavior. Triggers
  * regardless of other heuristics.
@@ -148,7 +163,14 @@ export function classifyComplexity(text) {
         isLong,
         entities >= 3,
     ].filter(Boolean).length;
-    const deepWorthy = strongCount >= 2;
+    // Suppress deepWorthy on pasted error messages. They're long and
+    // entity-heavy (file paths, quoted strings) but the user is asking
+    // "what's wrong here?", not requesting sustained autonomous work.
+    // The plan-first path still fires when complex=true.
+    const looksLikeErrorPaste = ERROR_PASTE_MARKERS.some((re) => re.test(trimmed));
+    if (looksLikeErrorPaste)
+        signals.push('error-paste');
+    const deepWorthy = strongCount >= 2 && !looksLikeErrorPaste;
     if (complex) {
         return {
             complex: true,

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.17.0",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",