helixmind 0.7.2 → 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';
@@ -517,6 +518,71 @@ export async function chatCommand(options) {
     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']);
@@ -738,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;
         }
@@ -757,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');
@@ -2515,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 {
@@ -2681,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);
@@ -2790,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)
@@ -2820,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 {
@@ -2856,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('');
@@ -3706,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();
@@ -3918,7 +4023,27 @@ export async function chatCommand(options) {
                     else {
                         currentStepFile = '';
                     }
-                }, jarvisLearning);
+                }, 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;
@@ -4121,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
@@ -4157,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
@@ -4345,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 */ }
                     }
                 }
             }
@@ -5831,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}"`