helixmind 0.7.1 → 0.8.0

package/dist/cli/commands/chat.js

@@ -3,6 +3,7 @@ import { Writable } from 'node:stream';
 import { homedir } from 'node:os';
 import { join, basename } from 'node:path';
 import { writeFileSync } from 'node:fs';
+import { markPrepended } from '../core/stdin-envelope.js';
 import { ConfigStore } from '../config/store.js';
 import { createProvider, registerFreeModel } from '../providers/registry.js';
 import { registerModelContextLength } from '../providers/model-limits.js';
@@ -103,6 +104,7 @@ const HELP_CATEGORIES = [
             { cmd: '/context', label: '/context', description: 'Show context size & embeddings' },
             { cmd: '/compact', label: '/compact', description: 'Trigger spiral evolution' },
             { cmd: '/tokens', label: '/tokens', description: 'Show token usage & memory' },
+            { cmd: '/recap', label: '/recap', description: 'Toggle per-turn recap summary (on|off)' },
         ],
     },
     {
@@ -245,6 +247,7 @@ ${chalk.hex('#00ff88').bold('  Spiral Memory')}
   ${theme.primary('/context'.padEnd(22))} ${theme.dim('Show current context size & embeddings')}
   ${theme.primary('/compact'.padEnd(22))} ${theme.dim('Trigger spiral evolution (promote/demote nodes)')}
   ${theme.primary('/tokens'.padEnd(22))} ${theme.dim('Show token usage, checkpoints, memory')}
+  ${theme.primary('/recap [on|off]'.padEnd(22))} ${theme.dim('Toggle short summary line after each agent turn')}
 
 ${chalk.hex('#4169e1').bold('  Visualization & Brain')}
   ${theme.primary('/brain'.padEnd(22))} ${theme.dim('Show brain scope + open 3D visualization')}
@@ -508,6 +511,174 @@ export async function chatCommand(options) {
     let roundToolCalls = 0;
     let currentStepLabel = '';
     let currentStepFile = '';
+    // Recap tracking — per-round snapshot so we can summarise what just happened.
+    let roundStartTokensIn = 0;
+    let roundStartTokensOut = 0;
+    let roundStartTime = 0;
+    const roundToolCounts = new Map();
+    const roundFilesTouched = new Set();
+    let recapEnabled = true; // Can be toggled via /recap
+    // audit-016/v0.8.0: brain growth telemetry for the session-exit display.
+    // Captured lazily on first spiral access; the diff is rendered before
+    // graceful exit so users SEE memory compounding ("+12 patterns learned,
+    // 3 stale retired"). The first session shows just the absolute count.
+    let brainStartNodes = null;
+    let brainStartConfidence = null;
+    function captureBrainStart() {
+        if (brainStartNodes !== null)
+            return;
+        try {
+            brainStartNodes = spiralEngine?.status?.().total_nodes ?? null;
+        }
+        catch {
+            brainStartNodes = null;
+        }
+        try {
+            brainStartConfidence = jarvisIdentity?.getIdentity?.()?.traits?.confidence ?? null;
+        }
+        catch {
+            brainStartConfidence = null;
+        }
+    }
+    function renderBrainGrowth() {
+        if (!spiralEngine)
+            return;
+        let nodesNow;
+        try {
+            nodesNow = spiralEngine.status().total_nodes;
+        }
+        catch {
+            return;
+        }
+        const stale = (() => {
+            try {
+                return spiralEngine.getStaleSeenLifetime?.() ?? 0;
+            }
+            catch {
+                return 0;
+            }
+        })();
+        let confNow = null;
+        try {
+            confNow = jarvisIdentity?.getIdentity?.()?.traits?.confidence ?? null;
+        }
+        catch { /* ignore */ }
+        const parts = [];
+        if (brainStartNodes !== null) {
+            const delta = nodesNow - brainStartNodes;
+            if (delta > 0)
+                parts.push(chalk.green(`+${delta} pattern${delta !== 1 ? 's' : ''} learned`));
+            else if (delta < 0)
+                parts.push(chalk.dim(`${delta} compacted`));
+        }
+        if (stale > 0)
+            parts.push(chalk.yellow(`${stale} stale retired`));
+        if (confNow !== null && brainStartConfidence !== null && Math.abs(confNow - brainStartConfidence) > 0.001) {
+            const delta = confNow - brainStartConfidence;
+            const arrow = delta > 0 ? chalk.green('↑') : chalk.red('↓');
+            parts.push(`confidence ${brainStartConfidence.toFixed(2)}${arrow}${confNow.toFixed(2)}`);
+        }
+        if (parts.length === 0) {
+            parts.push(chalk.dim(`brain has ${nodesNow} pattern${nodesNow !== 1 ? 's' : ''}`));
+        }
+        process.stdout.write(chalk.dim('  🧠 ') + parts.join(chalk.dim(' · ')) + '\n');
+    }
+    function recordRoundTool(toolName, input) {
+        roundToolCounts.set(toolName, (roundToolCounts.get(toolName) ?? 0) + 1);
+        const fileTools = new Set(['read_file', 'write_file', 'edit_file']);
+        if (fileTools.has(toolName)) {
+            const p = typeof input?.path === 'string' ? input.path : null;
+            if (p)
+                roundFilesTouched.add(p);
+        }
+    }
+    function buildRecapLine() {
+        if (!recapEnabled)
+            return null;
+        const totalTools = [...roundToolCounts.values()].reduce((a, b) => a + b, 0);
+        const tokensIn = sessionTokensInput - roundStartTokensIn;
+        const tokensOut = sessionTokensOutput - roundStartTokensOut;
+        const elapsedMs = Date.now() - roundStartTime;
+        if (totalTools === 0 && tokensIn === 0 && tokensOut === 0)
+            return null;
+        const parts = [];
+        // Tool breakdown — compact verbs. Group reads (read_file/list_directory/
+        // search_files/find_files), writes (write_file/edit_file), shell, other.
+        const reads = (roundToolCounts.get('read_file') ?? 0)
+            + (roundToolCounts.get('list_directory') ?? 0)
+            + (roundToolCounts.get('search_files') ?? 0)
+            + (roundToolCounts.get('find_files') ?? 0);
+        const writes = (roundToolCounts.get('write_file') ?? 0)
+            + (roundToolCounts.get('edit_file') ?? 0);
+        const runs = roundToolCounts.get('run_command') ?? 0;
+        const gitOps = [...roundToolCounts.entries()]
+            .filter(([k]) => k.startsWith('git_'))
+            .reduce((sum, [, n]) => sum + n, 0);
+        const spiralOps = [...roundToolCounts.entries()]
+            .filter(([k]) => k.startsWith('spiral_'))
+            .reduce((sum, [, n]) => sum + n, 0);
+        const browserOps = [...roundToolCounts.entries()]
+            .filter(([k]) => k.startsWith('browser_'))
+            .reduce((sum, [, n]) => sum + n, 0);
+        if (reads > 0)
+            parts.push(`${reads} read${reads === 1 ? '' : 's'}`);
+        if (writes > 0) {
+            const fileNames = [...roundFilesTouched]
+                .map(p => p.split(/[\/\\]/).pop() ?? p)
+                .slice(0, 2);
+            if (writes === 1 && fileNames.length === 1) {
+                parts.push(`edited ${fileNames[0]}`);
+            }
+            else if (fileNames.length > 0) {
+                const suffix = writes > fileNames.length ? `+${writes - fileNames.length}` : '';
+                parts.push(`edited ${fileNames.join(', ')}${suffix}`);
+            }
+            else {
+                parts.push(`${writes} edit${writes === 1 ? '' : 's'}`);
+            }
+        }
+        if (runs > 0)
+            parts.push(`${runs} shell`);
+        if (gitOps > 0)
+            parts.push(`${gitOps} git`);
+        if (spiralOps > 0)
+            parts.push(`${spiralOps} spiral`);
+        if (browserOps > 0)
+            parts.push(`${browserOps} browser`);
+        // Other tools not caught above
+        const known = new Set([
+            'read_file', 'list_directory', 'search_files', 'find_files',
+            'write_file', 'edit_file', 'run_command',
+        ]);
+        const otherTotal = [...roundToolCounts.entries()]
+            .filter(([k]) => !known.has(k) && !k.startsWith('git_') && !k.startsWith('spiral_') && !k.startsWith('browser_'))
+            .reduce((sum, [, n]) => sum + n, 0);
+        if (otherTotal > 0)
+            parts.push(`${otherTotal} other`);
+        // Tokens
+        const totalTokens = tokensIn + tokensOut;
+        if (totalTokens >= 1000) {
+            parts.push(`${(totalTokens / 1000).toFixed(1)}k tokens`);
+        }
+        else if (totalTokens > 0) {
+            parts.push(`${totalTokens} tokens`);
+        }
+        // Time
+        if (elapsedMs >= 1000) {
+            const secs = Math.round(elapsedMs / 1000);
+            if (secs >= 60) {
+                const m = Math.floor(secs / 60);
+                const s = secs % 60;
+                parts.push(`${m}m${s > 0 ? ` ${s}s` : ''}`);
+            }
+            else {
+                parts.push(`${secs}s`);
+            }
+        }
+        if (parts.length === 0)
+            return null;
+        return chalk.dim(`  \u258E Recap: ${parts.join(' \u00B7 ')}`);
+    }
     // Timer tracking
     const sessionStartTime = Date.now();
     let currentSection = null;
@@ -633,6 +804,11 @@ export async function chatCommand(options) {
             const dataDir = resolveSpiralDir(scope, process.cwd());
             const spiralConfig = loadSpiralConfig(dataDir);
             const engine = new SpiralEngine(spiralConfig);
+            // audit-014/v0.8.0 "Compounds": pin engine to project root so
+            // store() can capture file provenance and the injection layer can
+            // detect stale recall. Without this, the [STALE] marking is silent
+            // and the compounds feature is effectively disabled.
+            engine.setProjectRoot(projectRoot);
             await engine.initialize();
             return engine;
         }
@@ -652,6 +828,8 @@ export async function chatCommand(options) {
         spiralInitPromise = initSpiralEngine(scope).then(async (engine) => {
             spiralEngine = engine;
             spiralInitPromise = null;
+            // audit-016: capture session-start metrics for the growth display.
+            captureBrainStart();
             if (engine && brainUrl) {
                 try {
                     const { startLiveBrain } = await import('../brain/generator.js');
@@ -2410,6 +2588,13 @@ export async function chatCommand(options) {
         ctrlCCount++;
         if (ctrlCCount >= 2) {
             process.stdout.write('\n');
+            // audit-016: brain growth display before saving + exit. Single
+            // line, only when a spiral exists, never blocks. Compounding made
+            // visible \u2014 the User-sp\u00fcrbare Pro-tier value moment.
+            try {
+                renderBrainGrowth();
+            }
+            catch { /* never block exit */ }
             renderInfo('Force exit \u2014 saving state...');
             if (spiralEngine) {
                 try {
@@ -2576,7 +2761,12 @@ export async function chatCommand(options) {
     {
         let lastRawEscTime = 0;
         const RAW_ESC_THRESHOLD = 800; // ms
-        process.stdin.prependListener('data', async (chunk) => {
+        // audit-005: tag the raw ESC detector so any modal-stdin envelope (rewind
+        // browser, plan browser, …) restores it via prependListener instead of
+        // .on(), preserving its first-in-line position. Without the tag, after
+        // the first modal exit readline's data parser could land before the ESC
+        // detector and break double-ESC + bracketed-paste detection.
+        const escDetector = markPrepended(async (chunk) => {
             if (fullScreenBrowserOpen)
                 return;
             const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
@@ -2685,6 +2875,7 @@ export async function chatCommand(options) {
             // Everything else (text, arrow keys, etc.) — don't reset timer
             // because arrow key \x1b[A could arrive just after a real ESC press
         });
+        process.stdin.prependListener('data', escDetector);
         async function openRewindBrowser() {
             // Don't re-enter if already open
             if (fullScreenBrowserOpen)
@@ -2715,13 +2906,20 @@ export async function chatCommand(options) {
             // Fullscreen overlay: suspend=false removes stdout hook entirely so the
             // Rewind browser can write directly to the terminal without buffering.
             chrome.deactivate({ suspend: false });
-            // CRITICAL: Remove ALL stdin data+keypress listeners to prevent readline's
-            // internal handler from buffering keypresses during Rewind navigation.
-            // The browser adds its own raw 'data' listener for arrow keys / ESC.
+            // audit-011: snapshot+restore data listeners only. Do NOT touch
+            // 'keypress' listeners — Node's readline attaches an internal data
+            // parser when the first keypress listener is added, and removeAll +
+            // re-add can cause it to register a second parser, which makes every
+            // typed character afterwards fire twice ("double-write" symptom).
+            // Keypress listeners are gated by fullScreenBrowserOpen anyway, so
+            // they're safe to leave attached during the modal.
+            //
+            // Restore data listeners with prepend-symmetry: any listener tagged
+            // via markPrepended() (the raw ESC detector at chat.ts:2915) is
+            // re-attached as prepended so readline's data parser cannot land in
+            // front of it after rl.resume().
             const savedDataListeners = process.stdin.rawListeners('data').slice();
-            const savedKeypressListeners = process.stdin.rawListeners('keypress').slice();
             process.stdin.removeAllListeners('data');
-            process.stdin.removeAllListeners('keypress');
             let didRevertWithMessage = false;
             try {
                 try {
@@ -2751,11 +2949,16 @@ export async function chatCommand(options) {
             }
             finally {
                 // Guaranteed listener restore, even if the browser or revert threw.
+                // Tagged listeners (raw ESC detector) re-attach as prepended.
+                const PREPENDED = Symbol.for('helixmind.stdin.prepended');
                 for (const listener of savedDataListeners) {
-                    process.stdin.on('data', listener);
-                }
-                for (const listener of savedKeypressListeners) {
-                    process.stdin.on('keypress', listener);
+                    const isPrepended = Boolean(listener[PREPENDED]);
+                    if (isPrepended) {
+                        process.stdin.prependListener('data', listener);
+                    }
+                    else {
+                        process.stdin.on('data', listener);
+                    }
                 }
                 if (!didRevertWithMessage) {
                     inputMgr.setLine('');
@@ -2956,6 +3159,24 @@ export async function chatCommand(options) {
         }
         // Persist to JSONL history (async, non-blocking)
         promptHistory.add(input, process.cwd()).catch(() => { });
+        // Handle /recap here (toggles local recapEnabled state in the closure).
+        const trimmedForRecap = input.trim();
+        if (trimmedForRecap === '/recap' || trimmedForRecap.startsWith('/recap ')) {
+            const arg = trimmedForRecap.split(/\s+/)[1]?.toLowerCase();
+            if (arg === 'on') {
+                recapEnabled = true;
+                renderInfo('Recap enabled \u2014 summary line after every agent turn.');
+            }
+            else if (arg === 'off') {
+                recapEnabled = false;
+                renderInfo('Recap disabled.');
+            }
+            else {
+                renderInfo(`Recap is ${recapEnabled ? 'ON' : 'OFF'}. Use /recap on | off to toggle.`);
+            }
+            showPrompt();
+            return;
+        }
         // Handle /feed directly here (needs access to inlineProgressActive flag)
         if (input.startsWith('/feed')) {
             const activeSpiral = spiralEngine ?? await ensureSpiralEngine(brainScope);
@@ -3547,6 +3768,12 @@ export async function chatCommand(options) {
         roundToolCalls = 0;
         currentStepLabel = '';
         currentStepFile = '';
+        // Recap: snapshot round-start state.
+        roundStartTokensIn = sessionTokensInput;
+        roundStartTokensOut = sessionTokensOutput;
+        roundStartTime = Date.now();
+        roundToolCounts.clear();
+        roundFilesTouched.clear();
         suggestionPanel.close(); // Close suggestions when agent starts
         agentRunning = true;
         chrome.promptActive = false; // Re-enable stdout hook redraws for agent output
@@ -3577,13 +3804,20 @@ export async function chatCommand(options) {
                 fullScreenBrowserOpen = true;
                 rl.pause();
                 chrome.deactivate({ suspend: false });
-                // Isolate stdin: remove all data listeners to prevent readline buffering
+                // audit-011: same envelope as openRewindBrowser. Snapshot only data
+                // listeners; restore with prepend-symmetry for tagged ones.
                 const savedPlanListeners = process.stdin.rawListeners('data').slice();
                 process.stdin.removeAllListeners('data');
                 const { choice } = await runPlanBrowser(plan);
-                // Restore stdin listeners
+                const PREPENDED = Symbol.for('helixmind.stdin.prepended');
                 for (const listener of savedPlanListeners) {
-                    process.stdin.on('data', listener);
+                    const isPrepended = Boolean(listener[PREPENDED]);
+                    if (isPrepended) {
+                        process.stdin.prependListener('data', listener);
+                    }
+                    else {
+                        process.stdin.on('data', listener);
+                    }
                 }
                 inputMgr.setLine('');
                 chrome.activate();
@@ -3763,9 +3997,13 @@ export async function chatCommand(options) {
                 await sendAgentMessage(input, agentHistory, provider, project, spiralEngine, config, permissions, undoStack, checkpointStore, agentController, activity, sessionBuffer, (inp, out) => {
                     sessionTokensInput += inp;
                     sessionTokensOutput += out;
-                }, () => {
+                }, (toolName) => {
                     sessionToolCalls++;
                     roundToolCalls++;
+                    // Recap: record tool invocation by name.
+                    if (typeof toolName === 'string') {
+                        recordRoundTool(toolName, undefined);
+                    }
                 }, () => {
                     // Activity started — readline stays active for type-ahead buffering.
                     // Muting is handled by activity.setMuteCallbacks (mute during LLM stream,
@@ -3774,11 +4012,46 @@ export async function chatCommand(options) {
                 }, effectiveValidation, bugJournal, browserController, visionProcessor, pushScreenshotToBrainFn, getJarvisContextForPrompt(), (label, tool) => {
                     currentStepLabel = label;
                     const fileTools = new Set(['read_file', 'write_file', 'edit_file']);
-                    currentStepFile = fileTools.has(tool) ? label.replace(/^(reading|writing|editing)\s+/, '') : '';
-                }, jarvisLearning);
+                    if (fileTools.has(tool)) {
+                        const file = label.replace(/^(reading|writing|editing)\s+/, '');
+                        currentStepFile = file;
+                        // Recap: track files touched so the summary can name them.
+                        if (file && (tool === 'write_file' || tool === 'edit_file')) {
+                            roundFilesTouched.add(file);
+                        }
+                    }
+                    else {
+                        currentStepFile = '';
+                    }
+                }, jarvisLearning, undefined, // runtime
+                undefined, // skillManager
+                // audit-006: feed validation outcome into identity calibration.
+                (status, taskCategory) => {
+                    if (!jarvisIdentity)
+                        return;
+                    if (status === 'passed') {
+                        jarvisIdentity.recordEvent({
+                            type: 'task_completed',
+                            taskId: `validation:${taskCategory}`,
+                            summary: 'validation passed',
+                        });
+                    }
+                    else if (status === 'errors' || status === 'max_loops') {
+                        jarvisIdentity.recordEvent({
+                            type: 'task_failed',
+                            taskId: `validation:${taskCategory}`,
+                            error: `validation ${status}`,
+                        });
+                    }
+                });
             }
         }
         agentRunning = false;
+        // Recap: emit a short summary of what just happened.
+        const recapLine = buildRecapLine();
+        if (recapLine) {
+            process.stdout.write(recapLine + '\n');
+        }
         // Keep simple message history for state persistence.
         // FIX: CHATFLOW-001 — also persist the assistant's reply, otherwise
         // saveState() writes a user-only transcript and checkpoint browser shows
@@ -3973,6 +4246,13 @@ export async function chatCommand(options) {
                 await spiralEngine.saveState(messages);
             }
             catch { /* best effort */ }
+            // audit-016: render the growth line BEFORE close so the spiral is
+            // still queryable. The graceful path (rl close → here) is the
+            // common exit; the force-exit path renders earlier (Ctrl+C×2).
+            try {
+                renderBrainGrowth();
+            }
+            catch { /* never block exit */ }
             spiralEngine.close();
         }
         // Close browser if open
@@ -4009,7 +4289,13 @@ async function runBackgroundSession(session, prompt, provider, project, spiralEn
         durationMs: session.elapsed,
     };
 }
-async function sendAgentMessage(input, agentHistory, provider, project, spiralEngine, config, permissions, undoStack, checkpointStore, controller, activity, sessionBuffer, onTokens, onToolCall, onAgentStart, validationOpts, bugJournal, browserController, visionProcessor, onBrowserScreenshot, jarvisContext, onStepInfo, learningJournal, runtime, skillManager) {
+async function sendAgentMessage(input, agentHistory, provider, project, spiralEngine, config, permissions, undoStack, checkpointStore, controller, activity, sessionBuffer, onTokens, onToolCall, onAgentStart, validationOpts, bugJournal, browserController, visionProcessor, onBrowserScreenshot, jarvisContext, onStepInfo, learningJournal, runtime, skillManager, 
+// audit-006: optional callback fired once per validation run. Used by the
+// foreground chat path to feed the result into JarvisIdentityManager so
+// confidence calibration actually updates after successful agent turns.
+// Background-session callers leave this undefined so they do not pollute
+// the user's confidence score with their own outcomes.
+onValidationComplete) {
     // User message was rendered by renderUserMessage() in the caller before entering here.
     const executionRoot = runtime?.executionRoot ?? process.cwd();
     // Intent Detection: Check if user wants to feed the codebase
@@ -4197,6 +4483,19 @@ async function sendAgentMessage(input, agentHistory, provider, project, spiralEn
                         process.stdout.write(renderValidationSummary(valResult, validationOpts.verbose) + '\n');
                         // Store stats in spiral
                         await storeValidationResult(valResult, classification.category, spiralEngine || undefined);
+                        // audit-006: bridge validation outcome into the identity
+                        // calibration layer. Previously the confidence score was
+                        // initialized at 0.5 and only nudged by proposal approvals and
+                        // the autonomous-task scheduler; the regular agent turn that
+                        // ran validation never updated it. This is why the user-visible
+                        // confidence stayed stuck at 0.52 across many sessions despite
+                        // successful fixes. We treat 'passed' as task_completed and
+                        // 'errors'/'max_loops' as task_failed; 'warnings' is neutral
+                        // (do not penalize).
+                        try {
+                            onValidationComplete?.(valResult.status, classification.category);
+                        }
+                        catch { /* never block on a calibration callback */ }
                     }
                 }
             }
@@ -5683,7 +5982,7 @@ async function handleSlashCommand(input, messages, agentHistory, config, spiralE
                     cancelLabel: 'Cancel',
                 });
                 if (modeIdx === docsItemIdx) {
-                    const docsUrl = 'https://helixmind.dev/docs/security-monitor';
+                    const docsUrl = 'https://helix-mind.ai/docs/security-monitor';
                     const { exec } = await import('node:child_process');
                     const { platform } = await import('node:os');
                     const openCmd = platform() === 'win32' ? `start "" "${docsUrl}"`