@ekkos/cli 0.2.6 → 0.2.8

package/dist/commands/stream.js

@@ -0,0 +1,340 @@
+"use strict";
+/**
+ * ekkos stream - Stream capture status and management
+ *
+ * Shows live status of stream capture for debugging and support.
+ */
+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.streamStatus = streamStatus;
+exports.streamList = streamList;
+const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const STREAM_CACHE_DIR = path.join(os.homedir(), '.ekkos', 'cache', 'sessions');
+/**
+ * Get the state machine file path for a session
+ */
+function getStateMachinePath(sessionId) {
+    return path.join(STREAM_CACHE_DIR, `${sessionId}.state.json`);
+}
+/**
+ * Get the checkpoint file path for a session
+ */
+function getCheckpointPath(sessionId) {
+    return path.join(STREAM_CACHE_DIR, `${sessionId}.checkpoint.json`);
+}
+/**
+ * Get the stream log path for a session
+ */
+function getStreamLogPath(sessionId) {
+    return path.join(STREAM_CACHE_DIR, `${sessionId}.stream.jsonl`);
+}
+/**
+ * Find most recent session with stream data
+ */
+function findMostRecentSession() {
+    try {
+        if (!fs.existsSync(STREAM_CACHE_DIR))
+            return null;
+        const files = fs.readdirSync(STREAM_CACHE_DIR)
+            .filter(f => f.endsWith('.stream.jsonl'))
+            .map(f => ({
+            sessionId: f.replace('.stream.jsonl', ''),
+            mtime: fs.statSync(path.join(STREAM_CACHE_DIR, f)).mtimeMs
+        }))
+            .sort((a, b) => b.mtime - a.mtime);
+        return files.length > 0 ? files[0].sessionId : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Load stream state machine from disk
+ */
+function loadStateMachine(sessionId) {
+    try {
+        const statePath = getStateMachinePath(sessionId);
+        if (fs.existsSync(statePath)) {
+            return JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return null;
+}
+/**
+ * Load checkpoint from disk
+ */
+function loadCheckpoint(sessionId) {
+    try {
+        const checkpointPath = getCheckpointPath(sessionId);
+        if (fs.existsSync(checkpointPath)) {
+            return JSON.parse(fs.readFileSync(checkpointPath, 'utf-8'));
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return null;
+}
+/**
+ * Get stream log stats
+ */
+function getStreamLogStats(sessionId) {
+    const logPath = getStreamLogPath(sessionId);
+    if (!fs.existsSync(logPath)) {
+        return { exists: false, size: 0, lines: 0 };
+    }
+    const stat = fs.statSync(logPath);
+    let lines = 0;
+    try {
+        const content = fs.readFileSync(logPath, 'utf-8');
+        lines = content.split('\n').filter(l => l.trim()).length;
+    }
+    catch {
+        // Ignore errors
+    }
+    return { exists: true, size: stat.size, lines };
+}
+/**
+ * Format state with color
+ */
+function formatState(state) {
+    switch (state) {
+        case 'idle':
+            return chalk_1.default.gray('● idle');
+        case 'assistant_streaming':
+            return chalk_1.default.green('◉ streaming');
+        case 'tool_running':
+            return chalk_1.default.yellow('◉ tool running');
+        case 'interrupted':
+            return chalk_1.default.red('○ interrupted');
+        case 'wall_hit':
+            return chalk_1.default.red('✗ wall hit');
+        default:
+            return chalk_1.default.gray('? unknown');
+    }
+}
+/**
+ * Format bytes as human-readable
+ */
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+/**
+ * Format timestamp as relative time
+ */
+function formatRelativeTime(ts) {
+    const now = Date.now();
+    const then = new Date(ts).getTime();
+    const diff = now - then;
+    if (diff < 1000)
+        return 'just now';
+    if (diff < 60000)
+        return `${Math.floor(diff / 1000)}s ago`;
+    if (diff < 3600000)
+        return `${Math.floor(diff / 60000)}m ago`;
+    if (diff < 86400000)
+        return `${Math.floor(diff / 3600000)}h ago`;
+    return `${Math.floor(diff / 86400000)}d ago`;
+}
+/**
+ * Display stream status
+ */
+async function streamStatus(options) {
+    const sessionId = options.session || findMostRecentSession();
+    if (!sessionId) {
+        console.log(chalk_1.default.yellow('No active stream sessions found.'));
+        console.log(chalk_1.default.gray('Start a session with: ekkos run'));
+        return;
+    }
+    const state = loadStateMachine(sessionId);
+    const checkpoint = loadCheckpoint(sessionId);
+    const logStats = getStreamLogStats(sessionId);
+    if (options.json) {
+        console.log(JSON.stringify({
+            session_id: sessionId,
+            state,
+            checkpoint,
+            log_stats: logStats,
+        }, null, 2));
+        return;
+    }
+    // Header
+    console.log('');
+    console.log(chalk_1.default.cyan.bold('═══════════════════════════════════════════════════════════════'));
+    console.log(chalk_1.default.cyan.bold('  ekkOS Stream Status'));
+    console.log(chalk_1.default.cyan.bold('═══════════════════════════════════════════════════════════════'));
+    console.log('');
+    // Session info
+    console.log(chalk_1.default.white.bold('Session'));
+    console.log(chalk_1.default.gray(`  ID: ${sessionId}`));
+    if (state?.session_name) {
+        console.log(chalk_1.default.gray(`  Name: ${state.session_name}`));
+    }
+    console.log('');
+    // State machine
+    console.log(chalk_1.default.white.bold('State Machine'));
+    if (state) {
+        console.log(`  State: ${formatState(state.state)}`);
+        console.log(chalk_1.default.gray(`  Entered: ${formatRelativeTime(state.state_entered_at)}`));
+        console.log(chalk_1.default.gray(`  Current turn: ${state.current_turn_id}`));
+        console.log(chalk_1.default.gray(`  Last complete: ${state.last_complete_turn_id}`));
+    }
+    else {
+        console.log(chalk_1.default.gray('  No state machine found'));
+    }
+    console.log('');
+    // In-progress content
+    if (state && state.in_progress_total_chars > 0) {
+        console.log(chalk_1.default.white.bold('In-Progress Content'));
+        console.log(chalk_1.default.gray(`  Total chars: ${state.in_progress_total_chars.toLocaleString()}`));
+        if (state.in_progress_text_head) {
+            console.log(chalk_1.default.gray(`  Head (512 chars): "${state.in_progress_text_head.slice(0, 60)}..."`));
+        }
+        if (state.in_progress_text_tail) {
+            const tailPreview = state.in_progress_text_tail.slice(-60);
+            console.log(chalk_1.default.gray(`  Tail (8KB): "...${tailPreview}"`));
+        }
+        console.log('');
+    }
+    // Open loops
+    if (state && state.open_loops.length > 0) {
+        console.log(chalk_1.default.yellow.bold('⚠️  Open Loops'));
+        for (const loop of state.open_loops) {
+            console.log(chalk_1.default.yellow(`  • ${loop.type}: ${loop.name} (${formatRelativeTime(loop.started_at)})`));
+        }
+        console.log('');
+    }
+    // Stream log stats
+    console.log(chalk_1.default.white.bold('Stream Log'));
+    if (logStats.exists) {
+        console.log(chalk_1.default.gray(`  Path: ${getStreamLogPath(sessionId)}`));
+        console.log(chalk_1.default.gray(`  Size: ${formatBytes(logStats.size)}`));
+        console.log(chalk_1.default.gray(`  Events: ${logStats.lines.toLocaleString()}`));
+    }
+    else {
+        console.log(chalk_1.default.gray('  No stream log found'));
+    }
+    console.log('');
+    // Checkpoint
+    console.log(chalk_1.default.white.bold('Last Checkpoint'));
+    if (checkpoint) {
+        console.log(chalk_1.default.gray(`  Time: ${formatRelativeTime(checkpoint.checkpoint_ts)}`));
+        console.log(chalk_1.default.gray(`  Turn: ${checkpoint.turn_id}`));
+        console.log(chalk_1.default.gray(`  Chars: ${checkpoint.total_chars.toLocaleString()}`));
+        console.log(chalk_1.default.gray(`  Events since: ${checkpoint.events_since_last_checkpoint}`));
+    }
+    else {
+        console.log(chalk_1.default.gray('  No checkpoint found'));
+    }
+    console.log('');
+    // Metrics
+    if (state) {
+        console.log(chalk_1.default.white.bold('Metrics'));
+        console.log(chalk_1.default.gray(`  Bytes captured: ${formatBytes(state.stream_bytes_captured)}`));
+        console.log(chalk_1.default.gray(`  Events captured: ${state.events_captured.toLocaleString()}`));
+        console.log(chalk_1.default.gray(`  Last event: ${formatRelativeTime(state.last_event_ts)}`));
+        console.log('');
+    }
+    // Footer
+    console.log(chalk_1.default.cyan.bold('═══════════════════════════════════════════════════════════════'));
+    console.log('');
+    // Watch mode
+    if (options.watch) {
+        console.log(chalk_1.default.gray('Watching for changes... (Ctrl+C to exit)'));
+        const interval = setInterval(async () => {
+            console.clear();
+            await streamStatus({ ...options, watch: false });
+            console.log(chalk_1.default.gray('Watching for changes... (Ctrl+C to exit)'));
+        }, 1000);
+        process.on('SIGINT', () => {
+            clearInterval(interval);
+            process.exit(0);
+        });
+        // Keep process alive
+        await new Promise(() => { });
+    }
+}
+/**
+ * List all sessions with stream data
+ */
+function streamList() {
+    console.log('');
+    console.log(chalk_1.default.cyan.bold('Stream Sessions'));
+    console.log('');
+    if (!fs.existsSync(STREAM_CACHE_DIR)) {
+        console.log(chalk_1.default.gray('No stream cache directory found.'));
+        return;
+    }
+    const files = fs.readdirSync(STREAM_CACHE_DIR)
+        .filter(f => f.endsWith('.stream.jsonl'))
+        .map(f => {
+        const sessionId = f.replace('.stream.jsonl', '');
+        const stat = fs.statSync(path.join(STREAM_CACHE_DIR, f));
+        const state = loadStateMachine(sessionId);
+        return {
+            sessionId,
+            sessionName: state?.session_name,
+            state: state?.state || 'unknown',
+            mtime: stat.mtimeMs,
+            size: stat.size,
+        };
+    })
+        .sort((a, b) => b.mtime - a.mtime);
+    if (files.length === 0) {
+        console.log(chalk_1.default.gray('No stream sessions found.'));
+        return;
+    }
+    for (const file of files) {
+        const name = file.sessionName || file.sessionId.slice(0, 8);
+        const stateStr = formatState(file.state);
+        const sizeStr = formatBytes(file.size);
+        const timeStr = formatRelativeTime(new Date(file.mtime).toISOString());
+        console.log(`  ${stateStr} ${chalk_1.default.white(name)} ${chalk_1.default.gray(`(${sizeStr}, ${timeStr})`)}`);
+    }
+    console.log('');
+}

package/dist/index.js

@@ -10,11 +10,13 @@ const test_1 = require("./commands/test");
 const status_1 = require("./commands/status");
 const run_1 = require("./commands/run");
 const doctor_1 = require("./commands/doctor");
+const stream_1 = require("./commands/stream");
+const state_1 = require("./utils/state");
 const chalk_1 = __importDefault(require("chalk"));
 commander_1.program
     .name('ekkos')
     .description('ekkOS memory CLI for AI coding assistants')
-    .version('0.2.0')
+    .version('0.2.8')
     .addHelpText('beforeAll', chalk_1.default.cyan('\n  made by ekkOS_ with ❤️\n'));
 // Main init command (combined auth + setup)
 commander_1.program
@@ -61,6 +63,61 @@ commander_1.program
     .action((options) => {
     (0, doctor_1.doctor)({ fix: options.fix, json: options.json });
 });
+// Stream command - stream capture status and management
+const streamCmd = commander_1.program
+    .command('stream')
+    .description('Stream capture status and management');
+streamCmd
+    .command('status')
+    .description('Show stream capture status for current session')
+    .option('-s, --session <id>', 'Session ID to check')
+    .option('-w, --watch', 'Watch mode - refresh every second')
+    .option('-j, --json', 'Output machine-readable JSON')
+    .action((options) => {
+    (0, stream_1.streamStatus)({
+        session: options.session,
+        watch: options.watch,
+        json: options.json
+    });
+});
+streamCmd
+    .command('list')
+    .description('List all sessions with stream data')
+    .action(() => {
+    (0, stream_1.streamList)();
+});
+// Sessions command - list active Claude Code sessions (swarm support)
+commander_1.program
+    .command('sessions')
+    .description('List active Claude Code sessions (for swarm/multi-session support)')
+    .option('-j, --json', 'Output machine-readable JSON')
+    .action((options) => {
+    const sessions = (0, state_1.getActiveSessions)();
+    if (options.json) {
+        console.log(JSON.stringify(sessions, null, 2));
+        return;
+    }
+    console.log('');
+    console.log(chalk_1.default.cyan.bold('🐝 Active ekkOS Sessions'));
+    console.log('');
+    if (sessions.length === 0) {
+        console.log(chalk_1.default.gray('  No active sessions found.'));
+        console.log(chalk_1.default.gray('  Run `ekkos run` to start a session.'));
+    }
+    else {
+        console.log(chalk_1.default.gray(`  ${sessions.length} active session${sessions.length > 1 ? 's' : ''}:`));
+        console.log('');
+        for (const session of sessions) {
+            const age = Math.round((Date.now() - new Date(session.startedAt).getTime()) / 1000 / 60);
+            const lastBeat = Math.round((Date.now() - new Date(session.lastHeartbeat).getTime()) / 1000);
+            console.log(`  ${chalk_1.default.green('●')} ${chalk_1.default.bold(session.sessionName)}`);
+            console.log(`    ${chalk_1.default.gray('PID:')} ${session.pid}`);
+            console.log(`    ${chalk_1.default.gray('Path:')} ${session.projectPath}`);
+            console.log(`    ${chalk_1.default.gray('Age:')} ${age} min  ${chalk_1.default.gray('Last seen:')} ${lastBeat}s ago`);
+            console.log('');
+        }
+    }
+});
 // Deprecated setup command (redirects to init)
 commander_1.program
     .command('setup')

package/dist/restore/RestoreOrchestrator.d.ts

@@ -20,6 +20,12 @@ export declare class RestoreOrchestrator {
      * Main restore function - attempts tiers in order
      */
     restore(options?: RestoreOptions): Promise<CacheResult<RestorePayload>>;
+    /**
+     * Tier -1: Restore from stream log (has mid-turn content)
+     * This is checked FIRST because stream logs have the most recent data,
+     * including in-progress turns that haven't been sealed yet.
+     */
+    private restoreFromStreamLog;
     /**
      * Tier 0: Restore from local JSONL cache
      */

package/dist/restore/RestoreOrchestrator.js

@@ -49,9 +49,11 @@ const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const LocalSessionStore_js_1 = require("../cache/LocalSessionStore.js");
 const types_js_1 = require("../cache/types.js");
+const stream_tailer_js_1 = require("../capture/stream-tailer.js");
 // API configuration
 const MEMORY_API_URL = process.env.EKKOS_API_URL || 'https://api.ekkos.dev';
 const CONFIG_PATH = path.join(os.homedir(), '.ekkos', 'config.json');
+const STREAM_CACHE_DIR = path.join(os.homedir(), '.ekkos', 'cache', 'sessions');
 /**
  * Load auth token from config
  */
@@ -102,6 +104,14 @@ class RestoreOrchestrator {
                 latency_ms: Date.now() - startTime,
             };
         }
+        // Try Tier -1: Stream log (has mid-turn content, most recent data)
+        const streamResult = await this.restoreFromStreamLog(sessionId, sessionName || '', lastN);
+        if (streamResult.success && streamResult.data) {
+            return {
+                ...streamResult,
+                latency_ms: Date.now() - startTime,
+            };
+        }
         // Try Tier 0: Local cache
         const localResult = await this.restoreFromLocal(sessionId, sessionName || '', lastN);
         if (localResult.success && localResult.data) {
@@ -133,6 +143,117 @@ class RestoreOrchestrator {
             latency_ms: Date.now() - startTime,
         };
     }
+    /**
+     * Tier -1: Restore from stream log (has mid-turn content)
+     * This is checked FIRST because stream logs have the most recent data,
+     * including in-progress turns that haven't been sealed yet.
+     */
+    async restoreFromStreamLog(sessionId, sessionName, lastN) {
+        const startTime = Date.now();
+        // Find stream log file
+        const streamLogPath = path.join(STREAM_CACHE_DIR, `${sessionId}.stream.jsonl`);
+        if (!fs.existsSync(streamLogPath)) {
+            return {
+                success: false,
+                error: 'No stream log found',
+                source: 'stream',
+                latency_ms: Date.now() - startTime,
+            };
+        }
+        try {
+            const { turns: streamTurns, latestTurnId } = await (0, stream_tailer_js_1.reconstructTurnFromEvents)(streamLogPath);
+            if (streamTurns.size === 0) {
+                return {
+                    success: false,
+                    error: 'Stream log empty',
+                    source: 'stream',
+                    latency_ms: Date.now() - startTime,
+                };
+            }
+            // Get the latest turn (may be in_progress)
+            const latestTurn = streamTurns.get(latestTurnId);
+            if (!latestTurn) {
+                return {
+                    success: false,
+                    error: 'Could not find latest turn in stream',
+                    source: 'stream',
+                    latency_ms: Date.now() - startTime,
+                };
+            }
+            // Check if latest turn is in_progress (mid-generation)
+            const isInProgress = latestTurn.status === 'in_progress';
+            // Build turns array
+            const turnsArray = [];
+            for (const [turnId, turn] of streamTurns) {
+                turnsArray.push({
+                    turn_id: turnId,
+                    ts: new Date().toISOString(),
+                    user_query: turn.user_query,
+                    assistant_response: turn.assistant_stream, // Use stream content, not sealed response
+                    tools_used: turn.tools.filter(t => t.kind === 'tool_use').map(t => t.name || 'unknown'),
+                    files_referenced: [],
+                    is_complete: turn.status === 'complete',
+                });
+            }
+            // Sort by turn_id
+            turnsArray.sort((a, b) => a.turn_id - b.turn_id);
+            // Get last N turns
+            const restoredTurns = turnsArray.slice(-lastN);
+            // For in-progress turns, apply middle-truncation (preserve tail)
+            let latestAssistantStream = latestTurn.assistant_stream;
+            if (isInProgress && latestAssistantStream.length > 12000) {
+                latestAssistantStream = (0, stream_tailer_js_1.middleTruncate)(latestAssistantStream, {
+                    headChars: 2000,
+                    tailChars: 8000,
+                    maxTotal: 12000,
+                });
+            }
+            // Detect open loops (incomplete tools)
+            const openLoops = (0, stream_tailer_js_1.detectOpenLoops)(latestTurn.tools);
+            const payload = {
+                session_id: sessionId,
+                session_name: sessionName || 'unknown',
+                source: 'stream',
+                restored_turns: restoredTurns,
+                latest: {
+                    user_query: latestTurn.user_query,
+                    assistant_response: latestAssistantStream,
+                },
+                pending_turn: isInProgress
+                    ? {
+                        turn_id: latestTurnId,
+                        user_query: latestTurn.user_query,
+                        ts: new Date().toISOString(),
+                    }
+                    : undefined,
+                directives: [],
+                patterns: [],
+                metadata: {
+                    acked_turn_id: latestTurnId,
+                    last_flush_ts: new Date().toISOString(),
+                    token_estimate: Math.ceil(latestAssistantStream.length / 4),
+                    complete_turn_count: turnsArray.filter(t => t.is_complete).length,
+                    has_pending: isInProgress,
+                    is_stream_restore: true,
+                    open_loops: openLoops,
+                },
+            };
+            return {
+                success: true,
+                data: payload,
+                source: 'stream',
+                latency_ms: Date.now() - startTime,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: err instanceof Error ? err.message : String(err),
+                source: 'stream',
+                latency_ms: Date.now() - startTime,
+            };
+        }
+    }
     /**
      * Tier 0: Restore from local JSONL cache
      */
@@ -432,35 +553,66 @@ class RestoreOrchestrator {
      * Format RestorePayload as system-reminder markdown
      */
     formatAsSystemReminder(payload) {
+        const isStreamRestore = payload.metadata?.is_stream_restore;
+        const isInProgress = payload.metadata?.has_pending && isStreamRestore;
+        const openLoops = payload.metadata?.open_loops;
         const lines = [
             '<system-reminder>',
             'CONTEXT RESTORED (ekkOS /continue)',
             `Session: ${payload.session_name} (${payload.session_id})`,
-            `Source: ${payload.source}`,
-            `Turns restored: ${payload.restored_turns.length}`,
-            '',
-            '## Last User Request',
-            payload.latest.user_query,
-            '',
-            '## Last Assistant Response',
-            payload.latest.assistant_response.slice(0, 2000),
-            payload.latest.assistant_response.length > 2000 ? '\n[...truncated...]' : '',
+            `Source: ${payload.source}${isStreamRestore ? ' (real-time stream)' : ''}`,
+            isInProgress ? `Status: IN_PROGRESS (mid-turn restore)` : `Turns restored: ${payload.restored_turns.length}`,
             '',
-            '## Recent Turns (older → newer)',
         ];
-        // Add turn summaries (skip last one since it's shown in detail above)
-        const turnsToShow = payload.restored_turns.slice(0, -1);
-        for (let i = 0; i < turnsToShow.length; i++) {
-            const turn = turnsToShow[i];
-            const userSnippet = turn.user_query.slice(0, 100) + (turn.user_query.length > 100 ? '...' : '');
-            const assistantSnippet = turn.assistant_response.slice(0, 100) + (turn.assistant_response.length > 100 ? '...' : '');
-            lines.push(`${i + 1}) U: ${userSnippet}`);
-            lines.push(`   A: ${assistantSnippet}`);
+        // For stream restores with in-progress turns, show special format
+        if (isInProgress && isStreamRestore) {
+            // Show open loops if any
+            if (openLoops && openLoops.length > 0) {
+                lines.push('## Open Loops (machine-derived)');
+                for (const loop of openLoops) {
+                    lines.push(`- ⚠️ ${loop.detail}`);
+                }
+                lines.push('');
+            }
+            // Show last user request
+            lines.push('## Last User Request');
+            lines.push(payload.latest.user_query);
+            lines.push('');
+            // Show assistant stream with tail preserved
+            lines.push('## Assistant Stream (tail-preserved for resume)');
+            lines.push(payload.latest.assistant_response);
+            lines.push('');
+            // Special instruction for mid-turn resume
+            lines.push('INSTRUCTION: Continue from the exact point shown above.');
+            lines.push('Do not recap. Do not restart. Continue the sentence/action if mid-sentence.');
+            lines.push('Start your response with: "✓ Continuing -"');
+        }
+        else {
+            // Standard restore format
+            lines.push('## Last User Request');
+            lines.push(payload.latest.user_query);
+            lines.push('');
+            lines.push('## Last Assistant Response');
+            lines.push(payload.latest.assistant_response.slice(0, 2000));
+            if (payload.latest.assistant_response.length > 2000) {
+                lines.push('\n[...truncated...]');
+            }
+            lines.push('');
+            lines.push('## Recent Turns (older → newer)');
+            // Add turn summaries (skip last one since it's shown in detail above)
+            const turnsToShow = payload.restored_turns.slice(0, -1);
+            for (let i = 0; i < turnsToShow.length; i++) {
+                const turn = turnsToShow[i];
+                const userSnippet = turn.user_query.slice(0, 100) + (turn.user_query.length > 100 ? '...' : '');
+                const assistantSnippet = turn.assistant_response.slice(0, 100) + (turn.assistant_response.length > 100 ? '...' : '');
+                lines.push(`${i + 1}) U: ${userSnippet}`);
+                lines.push(`   A: ${assistantSnippet}`);
+            }
+            lines.push('');
+            lines.push('INSTRUCTION: Resume seamlessly where you left off.');
+            lines.push('Do not ask "what were we doing?"');
+            lines.push('Start your response with: "✓ Continuing -"');
         }
-        lines.push('');
-        lines.push('INSTRUCTION: Resume seamlessly where you left off.');
-        lines.push('Do not ask "what were we doing?"');
-        lines.push('Start your response with: "✓ Continuing -"');
         lines.push('</system-reminder>');
         return lines.join('\n');
     }