@ekkos/cli 1.3.7 → 1.3.9

package/dist/commands/run.js

@@ -49,6 +49,7 @@ const doctor_1 = require("./doctor");
 const stream_tailer_1 = require("../capture/stream-tailer");
 const jsonl_rewriter_1 = require("../capture/jsonl-rewriter");
 const transcript_repair_1 = require("../capture/transcript-repair");
+const living_docs_manager_js_1 = require("../local/living-docs-manager.js");
 // Try to load node-pty (may fail on Node 24+)
 // IMPORTANT: This must be awaited in run() to avoid racey false fallbacks.
 let pty = null;
@@ -85,6 +86,244 @@ function getConfig(options) {
     };
     /* eslint-enable no-restricted-syntax */
 }
+const MAX_OUTPUT_1M_MODELS = '128000';
+const MAX_OUTPUT_200K_OPUS_SONNET = '32768';
+let runtimeClaudeCodeVersion = null;
+let runtimeClaudeContextWindow = 'auto';
+let runtimeClaudeLaunchModel;
+function normalizeContextWindowOption(value) {
+    const normalized = (value || '').trim().toLowerCase();
+    if (normalized === '200k' || normalized === '200000')
+        return '200k';
+    if (normalized === '1m' || normalized === '1000000')
+        return '1m';
+    return 'auto';
+}
+function normalizeRequestedLaunchModel(value) {
+    if (typeof value !== 'string')
+        return {};
+    const raw = (value || '').trim();
+    if (!raw)
+        return {};
+    if (raw.toLowerCase() === 'default') {
+        return {};
+    }
+    const oneMillionMatch = raw.match(/^(.*)\[1m\]$/i);
+    if (oneMillionMatch) {
+        return {
+            model: oneMillionMatch[1].trim(),
+            syntheticContextWindow: '1m',
+        };
+    }
+    const lower = raw.toLowerCase();
+    if (lower.endsWith('-200k')) {
+        return {
+            model: raw.slice(0, -5).trim(),
+            syntheticContextWindow: '200k',
+        };
+    }
+    if (lower.endsWith('-1m')) {
+        return {
+            model: raw.slice(0, -3).trim(),
+            syntheticContextWindow: '1m',
+        };
+    }
+    return { model: raw };
+}
+function modelSupportsOneMillionContext(model) {
+    const normalized = (model || 'default').trim().toLowerCase();
+    if (!normalized || normalized === 'default')
+        return true;
+    if (normalized === 'opus' || normalized === 'sonnet')
+        return true;
+    return normalized.includes('claude-opus-4-6') || normalized.includes('claude-sonnet-4-6');
+}
+function buildClaudeLaunchModelArg(model, contextWindow) {
+    if (!model)
+        return undefined;
+    const normalized = normalizeRequestedLaunchModel(model).model;
+    if (!normalized)
+        return undefined;
+    if (contextWindow === '1m' && modelSupportsOneMillionContext(normalized)) {
+        return `${normalized}[1m]`;
+    }
+    return normalized;
+}
+function isTwoHundredKFixedOutputModel(model) {
+    const normalized = (model || '').trim().toLowerCase();
+    if (!normalized)
+        return false;
+    if (normalized === 'opus' || normalized === 'sonnet')
+        return true;
+    return /^claude-(?:opus|sonnet)-4-(?:5|6)(?:$|-)/.test(normalized);
+}
+function resolveClaudeMaxOutputTokens(model, contextWindow) {
+    if (process.env.EKKOS_MAX_OUTPUT_TOKENS) {
+        return process.env.EKKOS_MAX_OUTPUT_TOKENS;
+    }
+    if (contextWindow === '200k' && isTwoHundredKFixedOutputModel(model)) {
+        return MAX_OUTPUT_200K_OPUS_SONNET;
+    }
+    return MAX_OUTPUT_1M_MODELS;
+}
+function shouldOpenLaunchSelector(options) {
+    return options.model === true;
+}
+function renderClaudeLaunchSelectorIntro() {
+    const neonCyan = chalk_1.default.hex('#00f5ff');
+    const acidGreen = chalk_1.default.hex('#9dff00');
+    const signalAmber = chalk_1.default.hex('#ffb300');
+    const steel = chalk_1.default.hex('#8a92a6');
+    const width = 68;
+    const line = (text) => {
+        const pad = Math.max(0, width - stripAnsi(text).length);
+        return `${neonCyan('║')} ${text}${' '.repeat(pad)}${neonCyan('║')}`;
+    };
+    console.log('');
+    console.log(neonCyan('╔══════════════════════════════════════════════════════════════════════╗'));
+    console.log(line(chalk_1.default.white.bold('ekkOS.dev // PULSE')));
+    console.log(neonCyan('╠══════════════════════════════════════════════════════════════════════╣'));
+    console.log(line(`${acidGreen('200K')} ${steel('compat lane')} ${chalk_1.default.white('// Opus/Sonnet 4.5/4.6 => 32,768 output')}`));
+    console.log(line(`${signalAmber(' 1M')} ${steel('wide lane')}   ${chalk_1.default.white('// Opus/Sonnet 4.6 => 128,000 output')}`));
+    console.log(line(steel('Pick a launch vector, then a fixed runtime profile. No hidden context prompt.')));
+    console.log(neonCyan('╚══════════════════════════════════════════════════════════════════════╝'));
+    console.log('');
+}
+function buildLaunchModeChoices() {
+    return [
+        {
+            name: `${chalk_1.default.hex('#00f5ff').bold('Fresh boot')} ${chalk_1.default.gray('// new shell')}`,
+            value: 'fresh',
+        },
+        {
+            name: `${chalk_1.default.hex('#9dff00').bold('Resume recent')} ${chalk_1.default.gray('// latest thread')}`,
+            value: 'continue',
+        },
+        {
+            name: `${chalk_1.default.hex('#ffb300').bold('Resume by ID')} ${chalk_1.default.gray('// targeted reconnect')}`,
+            value: 'resume',
+        },
+    ];
+}
+function buildLaunchModelChoices() {
+    const cyan = chalk_1.default.hex('#00f5ff');
+    const amber = chalk_1.default.hex('#ffb300');
+    const green = chalk_1.default.hex('#00ff88');
+    return [
+        {
+            name: `${cyan.bold('Auto route')} ${chalk_1.default.gray('// Claude decides profile')}`,
+            value: 'default',
+        },
+        {
+            name: `${cyan.bold('Claude Opus 4.5')} ${green('[200K]')} ${chalk_1.default.gray('// out 32,768')}`,
+            value: 'claude-opus-4-5',
+        },
+        {
+            name: `${cyan.bold('Claude Opus 4.6')} ${green('[200K]')} ${chalk_1.default.gray('// out 32,768')}`,
+            value: 'claude-opus-4-6-200k',
+        },
+        {
+            name: `${cyan.bold('Claude Opus 4.6')} ${amber('[1M]')} ${chalk_1.default.gray('// out 128,000')}`,
+            value: 'claude-opus-4-6-1m',
+        },
+        {
+            name: `${cyan.bold('Claude Sonnet 4.5')} ${green('[200K]')} ${chalk_1.default.gray('// out 32,768')}`,
+            value: 'claude-sonnet-4-5',
+        },
+        {
+            name: `${cyan.bold('Claude Sonnet 4.6')} ${green('[200K]')} ${chalk_1.default.gray('// out 32,768')}`,
+            value: 'claude-sonnet-4-6-200k',
+        },
+        {
+            name: `${cyan.bold('Claude Sonnet 4.6')} ${amber('[1M]')} ${chalk_1.default.gray('// out 128,000')}`,
+            value: 'claude-sonnet-4-6-1m',
+        },
+        {
+            name: `${cyan.bold('Claude Haiku 4.5')} ${green('[200K]')} ${chalk_1.default.gray('// fast lane')}`,
+            value: 'claude-haiku-4-5',
+        },
+    ];
+}
+async function resolveClaudeLaunchSelection(options) {
+    const requestedModel = normalizeRequestedLaunchModel(typeof options.model === 'string' ? options.model : process.env.EKKOS_CLAUDE_MODEL);
+    let model = requestedModel.model;
+    let contextWindow = requestedModel.syntheticContextWindow
+        || normalizeContextWindowOption(options.contextWindow || process.env.EKKOS_CLAUDE_CONTEXT_WINDOW);
+    let continueLast = options.continueLast || false;
+    let resumeSession = (options.resumeSession || '').trim();
+    const shouldShowLaunchWindow = shouldOpenLaunchSelector(options)
+        && process.stdin.isTTY === true
+        && process.stdout.isTTY === true
+        && process.env.EKKOS_DISABLE_LAUNCH_WINDOW !== '1';
+    if (!shouldShowLaunchWindow) {
+        if (!modelSupportsOneMillionContext(model)) {
+            contextWindow = '200k';
+        }
+        return {
+            model,
+            contextWindow,
+            continueLast: !!continueLast && !resumeSession,
+            resumeSession: resumeSession || undefined,
+        };
+    }
+    const { default: inquirer } = await Promise.resolve().then(() => __importStar(require('inquirer')));
+    renderClaudeLaunchSelectorIntro();
+    const defaultLaunchMode = resumeSession ? 'resume' : continueLast ? 'continue' : 'fresh';
+    const firstPrompt = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'launchMode',
+            message: chalk_1.default.hex('#00f5ff').bold('>> Boot vector'),
+            default: defaultLaunchMode,
+            pageSize: 3,
+            loop: false,
+            choices: buildLaunchModeChoices(),
+        },
+        {
+            type: 'list',
+            name: 'model',
+            message: chalk_1.default.hex('#00f5ff').bold('>> Model lane'),
+            default: model || 'default',
+            pageSize: 8,
+            loop: false,
+            choices: buildLaunchModelChoices(),
+        },
+    ]);
+    const selectedProfile = normalizeRequestedLaunchModel(firstPrompt.model);
+    model = firstPrompt.model === 'default' ? undefined : selectedProfile.model;
+    continueLast = firstPrompt.launchMode === 'continue';
+    resumeSession = firstPrompt.launchMode === 'resume' ? resumeSession : '';
+    if (firstPrompt.launchMode === 'resume') {
+        const resumePrompt = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'resumeSession',
+                message: 'Claude session ID',
+                default: resumeSession,
+                validate: (value) => value.trim().length > 0 || 'Session ID is required',
+            },
+        ]);
+        resumeSession = resumePrompt.resumeSession.trim();
+    }
+    if (firstPrompt.model === 'default') {
+        contextWindow = 'auto';
+    }
+    else if (selectedProfile.syntheticContextWindow) {
+        contextWindow = selectedProfile.syntheticContextWindow;
+    }
+    else if (!modelSupportsOneMillionContext(model)) {
+        contextWindow = '200k';
+    }
+    else {
+        contextWindow = 'auto';
+    }
+    return {
+        model,
+        contextWindow,
+        continueLast,
+        resumeSession: resumeSession || undefined,
+    };
+}
 // ═══════════════════════════════════════════════════════════════════════════
 // PATTERN MATCHING
 // ═══════════════════════════════════════════════════════════════════════════
@@ -290,11 +529,6 @@ const isWindows = os.platform() === 'win32';
 // Core ekkOS patches (eviction, context management) work with all recent versions
 // Cosmetic patches may fail on newer versions but don't affect functionality
 const PINNED_CLAUDE_VERSION = 'latest';
-// Max output tokens for Claude responses
-// Default: 16384 (safe for Sonnet 4.5)
-// Opus 4.5 supports up to 64k - set EKKOS_MAX_OUTPUT_TOKENS=32768 or =65536 to use higher limits
-// Configurable via environment variable
-const EKKOS_MAX_OUTPUT_TOKENS = process.env.EKKOS_MAX_OUTPUT_TOKENS || '16384';
 const proxy_url_1 = require("../utils/proxy-url");
 // Track proxy mode for getEkkosEnv (set by run() based on options)
 let proxyModeEnabled = true;
@@ -315,12 +549,13 @@ let cliSessionName = null;
 let cliSessionId = null;
 /**
  * Get environment with ekkOS enhancements
- * - Sets CLAUDE_CODE_MAX_OUTPUT_TOKENS to 32k for longer responses
+ * - Sets CLAUDE_CODE_MAX_OUTPUT_TOKENS dynamically for the selected Claude profile
  * - Routes API through ekkOS proxy for seamless context eviction (when enabled)
  * - Sets EKKOS_PROXY_MODE to signal JSONL rewriter to disable eviction
  * - Passes session headers for eviction/retrieval context tracking
  */
 function getEkkosEnv() {
+    const maxOutputTokens = resolveClaudeMaxOutputTokens(runtimeClaudeLaunchModel, runtimeClaudeContextWindow);
     /* eslint-disable no-restricted-syntax -- System env spreading, not API key access */
     const env = {
         ...process.env,
@@ -332,8 +567,18 @@ function getEkkosEnv() {
         // Native autocompact would compact without ekkOS saving state first, causing knowledge loss.
         // Only ekkOS-wrapped sessions get this; vanilla `claude` keeps autocompact on.
         DISABLE_AUTO_COMPACT: 'true',
+        // Align Claude's advertised output ceiling with the chosen model/context profile.
+        // 1M Opus/Sonnet gets 128K; 200K Opus/Sonnet 4.5/4.6 is forced to 32,768.
+        // The proxy also enforces this server-side in case Claude Code ignores the env var.
+        CLAUDE_CODE_MAX_OUTPUT_TOKENS: maxOutputTokens,
     };
     /* eslint-enable no-restricted-syntax */
+    if (runtimeClaudeContextWindow === '200k') {
+        env.CLAUDE_CODE_DISABLE_1M_CONTEXT = '1';
+    }
+    else {
+        delete env.CLAUDE_CODE_DISABLE_1M_CONTEXT;
+    }
     // Check if proxy is disabled via env var or options
     // eslint-disable-next-line no-restricted-syntax -- Feature flag, not API key
     const proxyDisabled = process.env.EKKOS_DISABLE_PROXY === '1' || !proxyModeEnabled;
@@ -346,7 +591,9 @@ function getEkkosEnv() {
         if (!cliSessionName) {
             cliSessionId = crypto.randomUUID();
             cliSessionName = (0, state_1.uuidToWords)(cliSessionId);
-            console.log(chalk_1.default.gray(`  📂 Session: ${cliSessionName}`));
+            if (process.env.EKKOS_NO_SPLASH !== '1') {
+                console.log(chalk_1.default.gray(`  📂 Session: ${cliSessionName}`));
+            }
         }
         // Get full userId from config (NOT the truncated version from auth token)
         // Config has full UUID like "d4532ba0-0a86-42ce-bab4-22aa62b55ce6"
@@ -366,7 +613,10 @@ function getEkkosEnv() {
         // CRITICAL: Embed user/session in URL path since ANTHROPIC_HEADERS doesn't work
         // Claude Code SDK doesn't forward custom headers, but it DOES use ANTHROPIC_BASE_URL
         // Gateway extracts from URL: /proxy/{userId}/{sessionName}/v1/messages
-        const proxyUrl = (0, proxy_url_1.buildProxyUrl)(userId, cliSessionName, process.cwd(), cliSessionId);
+        const proxyUrl = (0, proxy_url_1.buildProxyUrl)(userId, cliSessionName, process.cwd(), cliSessionId, {
+            claudeCodeVersion: runtimeClaudeCodeVersion || undefined,
+            claudeContextWindow: runtimeClaudeContextWindow,
+        });
         env.ANTHROPIC_BASE_URL = proxyUrl;
         // Proxy URL contains userId + project path — don't leak to terminal
     }
@@ -504,7 +754,9 @@ function resolveClaudePath() {
         // No system Claude found — fall through to ekkOS-managed install
     }
     // ekkOS-managed installation (for pinned versions or no system Claude)
-    if (fs.existsSync(EKKOS_CLAUDE_BIN) && checkClaudeVersion(EKKOS_CLAUDE_BIN)) {
+    // When 'latest', skip the slow `claude --version` subprocess — any version is fine.
+    const ekkosClaudeExists = fs.existsSync(EKKOS_CLAUDE_BIN);
+    if (ekkosClaudeExists && (PINNED_CLAUDE_VERSION === 'latest' || checkClaudeVersion(EKKOS_CLAUDE_BIN))) {
         return EKKOS_CLAUDE_BIN;
     }
     // Auto-install to ekkOS-managed directory
@@ -575,6 +827,105 @@ function resolveGlobalClaudePath() {
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
+function formatPulseLaunchMode(options) {
+    if (options.resumeSession)
+        return `RESUME // ${options.resumeSession}`;
+    if (options.continueLast)
+        return 'CONTINUE // most recent Claude thread';
+    return 'FRESH // new interactive shell';
+}
+function formatPulseModel(model) {
+    const normalized = (model || '').trim().toLowerCase();
+    if (!normalized)
+        return 'Claude default';
+    if (normalized === 'opus')
+        return 'Opus alias';
+    if (normalized === 'sonnet')
+        return 'Sonnet alias';
+    if (normalized === 'claude-opus-4-5')
+        return 'Claude Opus 4.5';
+    if (normalized === 'claude-opus-4-6')
+        return 'Claude Opus 4.6';
+    if (normalized === 'claude-sonnet-4-5')
+        return 'Claude Sonnet 4.5';
+    if (normalized === 'claude-sonnet-4-6')
+        return 'Claude Sonnet 4.6';
+    if (normalized === 'claude-haiku-4-5')
+        return 'Claude Haiku 4.5';
+    return model || 'Claude default';
+}
+function formatPulseContextLine(contextWindow) {
+    if (contextWindow === '200k') {
+        return '200K // 200,000 token window // forced 32,768 output';
+    }
+    if (contextWindow === '1m') {
+        return '1M // 1,000,000 token window // unlocked 128,000 output';
+    }
+    return 'AUTO // ekkOS resolves 200K vs 1M from the selected profile';
+}
+async function showPulseLaunchLoader(options) {
+    const cyan = chalk_1.default.hex('#00f0ff');
+    const amber = chalk_1.default.hex('#ffb800');
+    const green = chalk_1.default.hex('#00ff88');
+    const steel = chalk_1.default.hex('#7a7a8e');
+    const panel = chalk_1.default.hex('#111118');
+    const wordmark = [
+        '██████╗ ██╗   ██╗██╗     ███████╗███████╗',
+        '██╔══██╗██║   ██║██║     ██╔════╝██╔════╝',
+        '██████╔╝██║   ██║██║     ███████╗█████╗  ',
+        '██╔═══╝ ██║   ██║██║     ╚════██║██╔══╝  ',
+        '██║     ╚██████╔╝███████╗███████║███████╗',
+        '╚═╝      ╚═════╝ ╚══════╝╚══════╝╚══════╝',
+    ];
+    const stages = [
+        'arming pulse launcher',
+        'syncing dashboard split',
+        'routing claude session',
+    ];
+    const barWidth = 26;
+    const panelInnerWidth = 76;
+    const buildPanelLine = (labelColor, label, value) => {
+        const content = ` ${label.padEnd(7)} ${value}`;
+        const pad = Math.max(0, panelInnerWidth - stripAnsi(content).length);
+        return `  ${cyan('║')} ${labelColor(label.padEnd(7))} ${chalk_1.default.white(value)}${' '.repeat(pad)}${cyan('║')}`;
+    };
+    const headerContent = ' ekkOS.dev // PULSE BOOTSTRAP   live launch matrix for Claude + dashboard';
+    const headerPad = Math.max(0, panelInnerWidth - headerContent.length);
+    console.log('');
+    for (const [idx, line] of wordmark.entries()) {
+        const color = idx % 2 === 0 ? cyan.bold : chalk_1.default.white.bold;
+        console.log('  ' + color(line));
+        await sleep(22);
+    }
+    console.log('  ' + amber('▔').repeat(54));
+    console.log(cyan('  ╔══════════════════════════════════════════════════════════════════════════════╗'));
+    console.log(`  ${cyan('║')}${chalk_1.default.white.bold(' ekkOS.dev // PULSE BOOTSTRAP')}${steel('   live launch matrix for Claude + dashboard')}${' '.repeat(headerPad)}${cyan('║')}`);
+    console.log(buildPanelLine(green, 'MODE', formatPulseLaunchMode(options)));
+    console.log(buildPanelLine(green, 'MODEL', formatPulseModel(typeof options.model === 'string' ? options.model : undefined)));
+    console.log(buildPanelLine(amber, 'WINDOW', formatPulseContextLine(normalizeContextWindowOption(options.contextWindow))));
+    console.log(buildPanelLine(steel, 'PATH', 'selector -> dashboard -> claude -> proxy'));
+    console.log(cyan('  ╚══════════════════════════════════════════════════════════════════════════════╝'));
+    console.log(`  ${green('200K')} ${steel('// Opus/Sonnet 4.5/4.6 => 32,768 output')}`);
+    console.log(`  ${amber('1M  ')} ${steel('// Opus/Sonnet 4.6 => 128,000 output')}`);
+    console.log('');
+    for (const stage of stages) {
+        for (let filled = 0; filled <= barWidth; filled += 1) {
+            const complete = '█'.repeat(filled);
+            const pending = '░'.repeat(barWidth - filled);
+            process.stdout.write(`\r  ${amber('[')}${cyan(complete)}${steel(pending)}${amber(']')} ${chalk_1.default.white(stage)}`);
+            await sleep(16);
+        }
+        process.stdout.write('\n');
+    }
+    console.log(`  ${green('READY')}   ${panel('dashboard split armed')} ${steel('// selector handoff imminent')}`);
+    if (options.bypass) {
+        console.log(`  ${amber('BYPASS')}  ${chalk_1.default.white('permission prompts disabled for this launch')}`);
+    }
+    if (options.verbose) {
+        console.log(`  ${steel('TRACE')}   ${steel('verbose telemetry enabled')}`);
+    }
+    console.log('');
+}
 /**
  * Show morning dreams with WOW factor right after sparkle animation.
  * Colorful, lively, readable — real magic moment. Then pause for Enter.
@@ -811,6 +1162,9 @@ function writeSessionFiles(sessionId, sessionName) {
  * Launch ekkos run + dashboard in isolated tmux panes (60/40 split)
  */
 function launchWithDashboard(options) {
+    // Prune dead-PID entries from active-sessions.json so the dashboard
+    // (and resolveSessionName) never cross-bind to stale sessions after restart.
+    (0, state_1.getActiveSessions)();
     const tmuxSession = `ekkos-${Date.now().toString(36)}`;
     const launchTime = Date.now();
     // Pre-generate session name so dashboard can start immediately (no polling).
@@ -831,6 +1185,15 @@ function launchWithDashboard(options) {
         runArgs.push('--skip-inject');
     if (options.noProxy)
         runArgs.push('--skip-proxy');
+    if (options.continueLast)
+        runArgs.push('--continue-last');
+    if (options.resumeSession)
+        runArgs.push('--resume-session', options.resumeSession);
+    if (typeof options.model === 'string')
+        runArgs.push('--model', options.model);
+    if (options.contextWindow && options.contextWindow !== 'auto') {
+        runArgs.push('--context-window', options.contextWindow);
+    }
     const ekkosCmd = process.argv[1]; // Path to ekkos CLI
     const cwd = process.cwd();
     const termCols = process.stdout.columns ?? 160;
@@ -916,6 +1279,15 @@ function launchWithWindowsTerminal(options) {
         runArgs.push('--skip-inject');
     if (options.noProxy)
         runArgs.push('--skip-proxy');
+    if (options.continueLast)
+        runArgs.push('--continue-last');
+    if (options.resumeSession)
+        runArgs.push('--resume-session', options.resumeSession);
+    if (typeof options.model === 'string')
+        runArgs.push('--model', options.model);
+    if (options.contextWindow && options.contextWindow !== 'auto') {
+        runArgs.push('--context-window', options.contextWindow);
+    }
     // Write a temp batch file to avoid all quoting issues
     // wt.exe doesn't resolve PATH for npm global bins — must use `cmd /c`
     const batPath = path.join(os.tmpdir(), `ekkos-wt-${Date.now()}.cmd`);
@@ -963,6 +1335,14 @@ async function run(options) {
     const verbose = options.verbose || false;
     const bypass = options.bypass || false;
     const noInject = options.noInject || false;
+    const suppressPreClaudeOutput = process.env.EKKOS_NO_SPLASH === '1';
+    const launchSelection = await resolveClaudeLaunchSelection(options);
+    options.model = launchSelection.model;
+    options.contextWindow = launchSelection.contextWindow;
+    options.continueLast = launchSelection.continueLast;
+    options.resumeSession = launchSelection.resumeSession;
+    runtimeClaudeLaunchModel = launchSelection.model;
+    runtimeClaudeContextWindow = launchSelection.contextWindow;
     // Honour -s flag: lock the session name before getEkkosEnv() can mint a new one.
     // This is critical for --dashboard mode where launchWithDashboard() pre-generates
     // a session name and passes it via -s so the dashboard and run command agree.
@@ -973,11 +1353,28 @@ async function run(options) {
     // Set proxy mode based on options (used by getEkkosEnv)
     proxyModeEnabled = !(options.noProxy || false);
     if (proxyModeEnabled) {
-        console.log(chalk_1.default.cyan('  🧠 ekkOS_Continuum Loaded!'));
+        if (!suppressPreClaudeOutput && !options.pulse) {
+            console.log(chalk_1.default.cyan('  🧠 ekkOS_Continuum Loaded!'));
+        }
     }
-    else if (verbose) {
+    else if (verbose && !suppressPreClaudeOutput) {
         console.log(chalk_1.default.yellow('  ⏭️  API proxy disabled (--no-proxy)'));
     }
+    let pulseIntroShown = false;
+    if (options.pulse
+        && process.env.EKKOS_REMOTE_SESSION !== '1'
+        && process.env.EKKOS_NO_SPLASH !== '1'
+        && process.stdout.isTTY === true) {
+        await showPulseLaunchLoader({
+            model: options.model,
+            contextWindow: options.contextWindow,
+            continueLast: options.continueLast,
+            resumeSession: options.resumeSession,
+            bypass: options.bypass,
+            verbose: options.verbose,
+        });
+        pulseIntroShown = true;
+    }
     // ══════════════════════════════════════════════════════════════════════════
     // DASHBOARD MODE: Launch via tmux (Unix) or Windows Terminal split pane
     // ══════════════════════════════════════════════════════════════════════════
@@ -1043,16 +1440,45 @@ async function run(options) {
     // ══════════════════════════════════════════════════════════════════════════
     (0, state_1.ensureEkkosDir)();
     (0, state_1.clearAutoClearFlag)();
+    // Construct manager early but defer .start() until Claude's first idle prompt
+    // (filesystem scans run only after Claude is fully loaded and waiting for input)
+    let localLivingDocsManager = null;
+    if (process.env.EKKOS_LOCAL_LIVING_DOCS !== '0') {
+        try {
+            localLivingDocsManager = new living_docs_manager_js_1.LocalLivingDocsManager({
+                targetPath: process.cwd(),
+                apiUrl: process.env.EKKOS_API_URL || MEMORY_API_URL,
+                apiKey: (0, state_1.getAuthToken)(),
+                timeZone: process.env.EKKOS_USER_TIMEZONE || Intl.DateTimeFormat().resolvedOptions().timeZone,
+                onLog: message => dlog(message),
+            });
+            // .start() deferred to first idle prompt — see idle detection below (~line 2685)
+        }
+        catch (err) {
+            dlog(`[LivingDocs:Local] Failed to start: ${err.message}`);
+        }
+    }
     // Resolve Claude path
     const rawClaudePath = resolveClaudePath();
     const isNpxMode = rawClaudePath.startsWith('npx:');
     const pinnedVersion = isNpxMode ? rawClaudePath.split(':')[1] : null;
     const claudePath = isNpxMode ? 'npx' : rawClaudePath;
+    runtimeClaudeCodeVersion = pinnedVersion || getClaudeVersion(claudePath);
     // Build args early
     const earlyArgs = [];
     if (isNpxMode) {
         earlyArgs.push(`@anthropic-ai/claude-code@${pinnedVersion}`);
     }
+    if (options.resumeSession) {
+        earlyArgs.push('--resume', options.resumeSession);
+    }
+    else if (options.continueLast) {
+        earlyArgs.push('--continue');
+    }
+    const launchModelArg = buildClaudeLaunchModelArg(options.model, options.contextWindow);
+    if (launchModelArg) {
+        earlyArgs.push('--model', launchModelArg);
+    }
     if (bypass) {
         earlyArgs.push('--dangerously-skip-permissions');
     }
@@ -1115,7 +1541,7 @@ async function run(options) {
     // ══════════════════════════════════════════════════════════════════════════
     // STARTUP BANNER WITH COLOR PULSE ANIMATION
     // ══════════════════════════════════════════════════════════════════════════
-    const skipFancyIntro = process.env.EKKOS_REMOTE_SESSION === '1' || process.env.EKKOS_NO_SPLASH === '1' || !!process.env.TMUX;
+    const skipFancyIntro = pulseIntroShown || process.env.EKKOS_REMOTE_SESSION === '1' || suppressPreClaudeOutput || !!process.env.TMUX;
     if (!skipFancyIntro) {
         const logoLines = [
             '                      ▄▄▄▄▄    ▄▄▄▄▄▄▄     ▄▄▄ ▄▄ ▄▄',
@@ -1297,7 +1723,7 @@ async function run(options) {
         }
         console.log('');
     }
-    else {
+    else if (!suppressPreClaudeOutput) {
         // Static banner for Windows / remote / no-splash — no cursor manipulation
         console.log('');
         console.log(chalk_1.default.hex('#FF6B35').bold('  ekkOS_Pulse') + chalk_1.default.gray('  —  Context is finite. Intelligence isn\'t.'));
@@ -1313,7 +1739,9 @@ async function run(options) {
     // ══════════════════════════════════════════════════════════════════════════
     // MAGIC MOMENT: Morning dreams right after sparkle, before Claude appears
     // ══════════════════════════════════════════════════════════════════════════
-    await showMorningDreamsIfNeeded();
+    if (!suppressPreClaudeOutput && !options.pulse) {
+        await showMorningDreamsIfNeeded();
+    }
     // ══════════════════════════════════════════════════════════════════════════
     // ANIMATION COMPLETE: Mark ready and flush buffered Claude output
     // ══════════════════════════════════════════════════════════════════════════
@@ -1321,6 +1749,7 @@ async function run(options) {
     // Clear terminal to prevent startup banner artifacts bleeding into Claude Code's Ink TUI
     process.stdout.write('\x1B[2J\x1B[H');
     dlog(`Animation complete. shellReady=${shellReady}, buffered=${bufferedOutput.length} chunks`);
+    // Living docs .start() is deferred further — triggers on first idle prompt (Claude fully loaded)
     // Show loading indicator if Claude is still initializing
     if (shellReady && bufferedOutput.length === 0) {
         process.stdout.write(chalk_1.default.gray('  Connecting to Claude...'));
@@ -1367,6 +1796,7 @@ async function run(options) {
     // Tracks idle→active transitions to print the session banner once per turn
     // ══════════════════════════════════════════════════════════════════════════
     let wasIdle = false; // Start as NOT idle — first idle→active fires after startup
+    let livingDocsStarted = false; // Deferred until Claude's first idle prompt
     let turnCount = 0; // Incremented each time a new turn banner prints
     let lastBannerTime = Date.now(); // Grace period so startup output doesn't trigger banner
     // Stream tailer for mid-turn context capture (must be declared before polling code)
@@ -1802,9 +2232,21 @@ async function run(options) {
     }
     if (verbose) {
         // Show Claude version
-        const ccVersion = pinnedVersion || PINNED_CLAUDE_VERSION;
+        const ccVersion = runtimeClaudeCodeVersion || pinnedVersion || PINNED_CLAUDE_VERSION;
         const versionStr = `Claude Code v${ccVersion}`;
         console.log(chalk_1.default.gray(`  🤖 ${versionStr}`));
+        if (options.model) {
+            console.log(chalk_1.default.gray(`  🧩 Model: ${buildClaudeLaunchModelArg(options.model, options.contextWindow)}`));
+        }
+        if (options.contextWindow && options.contextWindow !== 'auto') {
+            console.log(chalk_1.default.gray(`  🪟 Context: ${options.contextWindow}`));
+        }
+        if (options.continueLast) {
+            console.log(chalk_1.default.gray('  ↩ Continue: most recent Claude conversation'));
+        }
+        if (options.resumeSession) {
+            console.log(chalk_1.default.gray(`  ↪ Resume: ${options.resumeSession}`));
+        }
         if (currentSession) {
             console.log(chalk_1.default.green(`  📍 Session: ${currentSession}`));
         }
@@ -2324,6 +2766,20 @@ async function run(options) {
         // We check the raw outputBuffer (stripped) so the idle regex fires reliably.
         if (IDLE_PROMPT_REGEX.test(stripAnsi(outputBuffer))) {
             wasIdle = true;
+            // Start living docs on first idle prompt — Claude is fully loaded, won't compete for I/O
+            if (!livingDocsStarted && localLivingDocsManager) {
+                livingDocsStarted = true;
+                // Use setImmediate so the current data handler returns first
+                setImmediate(() => {
+                    try {
+                        localLivingDocsManager.start();
+                        dlog('[LivingDocs:Local] Manager started (first idle prompt)');
+                    }
+                    catch (err) {
+                        dlog(`[LivingDocs:Local] Failed to start: ${err.message}`);
+                    }
+                });
+            }
         }
         // ══════════════════════════════════════════════════════════════════════════
         // ORPHAN TOOL_RESULT DETECTION (LOCAL MODE ONLY)
@@ -2711,6 +3167,7 @@ Use Perplexity for deep research. Be thorough but efficient. Start now.`;
     // Handle PTY exit
     shell.onExit(async ({ exitCode }) => {
         (0, state_1.clearAutoClearFlag)();
+        localLivingDocsManager?.stop();
         stopStreamTailer(); // Stop stream capture
         (0, state_1.unregisterActiveSession)(); // Remove from active sessions registry
         cleanupInstanceFile(instanceId); // Clean up instance file
@@ -2730,6 +3187,7 @@ Use Perplexity for deep research. Be thorough but efficient. Start now.`;
     // Cleanup on exit signals
     const cleanup = () => {
         (0, state_1.clearAutoClearFlag)();
+        localLivingDocsManager?.stop();
         stopStreamTailer(); // Stop stream capture
         (0, state_1.unregisterActiveSession)(); // Remove from active sessions registry
         cleanupInstanceFile(instanceId); // Clean up instance file