@neurcode-ai/cli 0.19.2 → 0.19.4

package/dist/commands/session.js

@@ -62,6 +62,7 @@ exports.verifyAIChangeRecordForCli = verifyAIChangeRecordForCli;
 exports.structuralUnderstandingCommand = structuralUnderstandingCommand;
 exports.listSessionsCommand = listSessionsCommand;
 exports.endSessionCommand = endSessionCommand;
+exports.endSessionCommandWithDependencies = endSessionCommandWithDependencies;
 exports.sessionStatusCommand = sessionStatusCommand;
 exports.listLocalSessionsCommand = listLocalSessionsCommand;
 exports.currentLocalSessionCommand = currentLocalSessionCommand;
@@ -86,6 +87,7 @@ const repo_brain_impact_1 = require("../utils/repo-brain-impact");
 const structural_understanding_1 = require("../utils/structural-understanding");
 const agent_guard_supervisor_1 = require("../utils/agent-guard-supervisor");
 const hook_heartbeat_1 = require("../utils/hook-heartbeat");
+const profile_drift_recovery_1 = require("../utils/profile-drift-recovery");
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
@@ -459,6 +461,19 @@ function buildLocalGovernanceStatus(options = {}) {
         };
     }
     const recentEvents = session.events.slice(-10);
+    const staleness = (0, v0_governance_1.getProfileStaleness)(repoRoot);
+    const profileAction = (0, v0_governance_1.profileFreshnessActionForSession)(staleness, session.profileHash);
+    const pendingProfileDecisions = (0, profile_drift_recovery_1.pendingProfileDriftDecisions)(session);
+    const profileFreshness = (0, v0_governance_1.buildProfileFreshnessSignal)(staleness, profileAction, {
+        sessionProfileHash: session.profileHash,
+        ...(profileAction === 'session_restart_required'
+            ? {
+                recoveryReason: 'active_session_profile_changed',
+                recoveryCommand: profile_drift_recovery_1.PROFILE_DRIFT_RECOVERY_COMMAND,
+                unresolvedHumanDecisions: pendingProfileDecisions.length > 0,
+            }
+            : {}),
+    });
     const latestBlock = [...session.events].reverse().find((event) => event.type === 'check_block');
     const latestApprovalContext = approvalContextFrom(latestBlock);
     const suggestedApprovalPath = latestApprovalContext?.suggestedApprovalPath ||
@@ -472,6 +487,7 @@ function buildLocalGovernanceStatus(options = {}) {
         status: session.status,
         goal: session.contract.goal,
         profileHash: session.profileHash,
+        profileFreshness,
         scopeMode: session.contract.scopeMode,
         planCoherenceMode: session.contract.planCoherenceMode ?? 'warn',
         agentPlan: session.contract.agentPlan ?? null,
@@ -533,6 +549,14 @@ function localGovernanceStatusCommand(options = {}) {
     console.log(`Session: ${chalk.white(activeStatus.sessionId)} ${activeStatus.active ? chalk.green('active') : chalk.dim(activeStatus.status)}`);
     console.log(`Goal:    ${chalk.white(truncate(activeStatus.goal))}`);
     console.log(`Scope:   ${chalk.white(activeStatus.scopeMode)}`);
+    console.log(`Profile: ${chalk.white(activeStatus.profileFreshness.status)} cache · ` +
+        `${chalk.white(activeStatus.profileFreshness.sessionCompatibility)} session`);
+    if (activeStatus.profileFreshness.sessionCompatibility === 'incompatible') {
+        console.log(chalk.yellow(`Hashes:  session ${activeStatus.profileHash.slice(0, 12)} · ` +
+            `current ${activeStatus.profileFreshness.currentProfileHash.slice(0, 12)}`));
+        console.log(chalk.yellow(`Recover: ${profile_drift_recovery_1.PROFILE_DRIFT_RECOVERY_COMMAND} ` +
+            `(--force abandons unresolved operator state${activeStatus.profileFreshness.unresolvedHumanDecisions ? '; unresolved decisions are present' : ''})`));
+    }
     console.log(`Plan:    ${chalk.white(activeStatus.planCoherenceMode)}${activeStatus.agentPlanRevision ? chalk.dim(` · rev ${activeStatus.agentPlanRevision}`) : ''}`);
     console.log(`Agent:   ${chalk.white(activeStatus.agentInvocation.status.replace(/_/g, ' '))}` +
         chalk.dim(` · score ${activeStatus.agentInvocation.score}`) +
@@ -1484,11 +1508,15 @@ function extractRecordAndReceipt(value) {
 function collectChangeRecordImpactPaths(record) {
     const facts = record?.accountability?.facts ?? {};
     const pathTokens = record?.intent?.contract?.target?.pathTokens ?? [];
+    const intentSummaryPaths = record?.intent?.summary?.paths ?? [];
+    const expectedPathGlobs = record?.intent?.expectedPathGlobs ?? [];
     const candidates = [
         ...(Array.isArray(facts.touchedPaths) ? facts.touchedPaths : []),
         ...(Array.isArray(facts.allowedPaths) ? facts.allowedPaths : []),
         ...(Array.isArray(facts.warnedPaths) ? facts.warnedPaths : []),
         ...(Array.isArray(pathTokens) ? pathTokens : []),
+        ...(Array.isArray(intentSummaryPaths) ? intentSummaryPaths : []),
+        ...(Array.isArray(expectedPathGlobs) ? expectedPathGlobs : []),
     ];
     return Array.from(new Set(candidates
         .filter((p) => typeof p === 'string' && p.trim().length > 0)
@@ -1954,157 +1982,294 @@ async function listSessionsCommand(options) {
  * End a session
  */
 async function endSessionCommand(options) {
+    return endSessionCommandWithDependencies(options);
+}
+function endSessionOutput(options, payload, exitCode = 0) {
+    if (options.json) {
+        console.log(JSON.stringify({ ...payload, exitCode }, null, 2));
+    }
+    else if (payload.ok === true) {
+        console.log(chalk.green(String(payload.message || 'Session ended.')));
+        if (payload.sessionId)
+            console.log(chalk.dim(`Session: ${payload.sessionId}`));
+        if (payload.replayHash)
+            console.log(chalk.dim(`replayHash: ${payload.replayHash}`));
+    }
+    else {
+        console.error(chalk.red(String(payload.message || payload.error || 'Session end failed.')));
+        const candidates = Array.isArray(payload.candidates) ? payload.candidates : [];
+        for (const candidate of candidates) {
+            const item = candidate;
+            console.error(chalk.dim(`  ${item.sessionId || 'unknown'}: ${item.command || ''}`));
+        }
+    }
+    process.exitCode = exitCode;
+}
+async function finishLocalGovernanceSession(repoRoot, session) {
+    if (session.status === 'finished') {
+        return {
+            ok: true,
+            ended: false,
+            mode: 'local',
+            status: 'already_finished',
+            sessionId: session.sessionId,
+            replayHash: session.replayHash || null,
+            message: `Local governance session ${session.sessionId} is already finished.`,
+        };
+    }
+    (0, governance_runtime_1.appendEvent)(repoRoot, session.sessionId, {
+        type: 'user_decision',
+        ts: new Date().toISOString(),
+        decision: 'local_session_end_requested',
+        message: 'Operator ended the local governance session.',
+        detail: {
+            source: 'local_cli',
+            command: 'session end',
+        },
+    });
+    const finished = (0, governance_runtime_1.finishSession)(repoRoot, session.sessionId, {
+        reason: 'local_session_end_requested',
+    });
+    if (!finished)
+        throw new Error(`Local governance session ${session.sessionId} could not be finished.`);
+    (0, agent_guard_supervisor_1.stopSupervisorOnSessionCompletion)(repoRoot);
+    let liveStatusPublished = true;
     try {
-        const config = (0, config_1.loadConfig)();
-        if (!config.apiKey) {
-            config.apiKey = (0, config_1.requireApiKey)();
+        await (0, runtime_live_1.publishRuntimeLiveStatus)(repoRoot, finished);
+    }
+    catch {
+        liveStatusPublished = false;
+    }
+    const replay = (0, governance_runtime_1.replaySession)(finished);
+    return {
+        ok: true,
+        ended: true,
+        mode: 'local',
+        status: finished.status,
+        sessionId: finished.sessionId,
+        replayHash: finished.replayHash,
+        replayVerified: replay.matchesOriginal,
+        liveStatusPublished,
+        recordPath: `.neurcode/sessions/${finished.sessionId}.json`,
+        evidencePath: (0, node_path_1.relative)(repoRoot, (0, governance_runtime_1.aiChangeRecordPath)(repoRoot, finished.sessionId)).replace(/\\/g, '/'),
+        message: `Local governance session ${finished.sessionId} ended with replay-valid evidence.`,
+    };
+}
+async function endSessionCommandWithDependencies(options, dependencies = {}) {
+    const repoRoot = (0, v0_governance_1.resolveRepoRoot)(options.dir || process.cwd());
+    const isInteractive = dependencies.isInteractive ??
+        (() => Boolean(process.stdin.isTTY && process.stdout.isTTY));
+    const prompt = dependencies.prompt ?? promptUser;
+    try {
+        if (options.sessionId) {
+            const local = (0, governance_runtime_1.loadSession)(repoRoot, options.sessionId);
+            if (local) {
+                endSessionOutput(options, await finishLocalGovernanceSession(repoRoot, local));
+                return;
+            }
+            if (options.local) {
+                endSessionOutput(options, {
+                    ok: false,
+                    ended: false,
+                    mode: 'local',
+                    reason: 'local_session_not_found',
+                    sessionId: options.sessionId,
+                    message: `Local governance session ${options.sessionId} was not found.`,
+                }, 2);
+                return;
+            }
         }
-        const client = new api_client_1.ApiClient(config);
-        let sessionId = options.sessionId;
-        // If no session ID provided, try to get from state
-        if (!sessionId) {
-            const stateSessionId = (0, state_1.getSessionId)();
-            sessionId = stateSessionId || undefined;
-            if (!sessionId) {
-                // List active sessions and let user choose
-                (0, messages_1.printInfo)('No Active Session', 'Looking for active sessions...');
-                const sessions = await client.getSessions(config.projectId, 10);
-                const activeSessions = sessions.filter(s => s.status === 'active');
-                if (activeSessions.length === 0) {
-                    (0, messages_1.printInfo)('No Active Sessions', 'There are no active sessions to end.');
+        else {
+            const records = scanSessionRecords(repoRoot);
+            if (records.active.length === 1) {
+                endSessionOutput(options, await finishLocalGovernanceSession(repoRoot, records.active[0]));
+                return;
+            }
+            if (records.active.length > 1) {
+                if (!isInteractive()) {
+                    endSessionOutput(options, {
+                        ok: false,
+                        ended: false,
+                        mode: 'local',
+                        reason: 'multiple_local_sessions_noninteractive',
+                        candidates: records.active.map((session) => ({
+                            sessionId: session.sessionId,
+                            command: `neurcode session end --session-id ${session.sessionId}`,
+                        })),
+                        malformedRecords: records.malformed,
+                        message: 'Multiple active local governance sessions were found; noninteractive selection is disabled.',
+                    }, 2);
                     return;
                 }
-                if (activeSessions.length === 1) {
-                    sessionId = activeSessions[0].sessionId;
-                    const title = activeSessions[0].title || activeSessions[0].intentDescription || 'Untitled';
-                    (0, messages_1.printInfo)('Found Active Session', `Ending: ${title}`);
-                }
-                else {
-                    // Multiple active sessions - let user choose
-                    (0, messages_1.printSection)('Multiple Active Sessions');
-                    activeSessions.forEach((session, index) => {
-                        const title = session.title || session.intentDescription || 'Untitled';
-                        console.log(chalk.cyan(`  ${index + 1}.`), chalk.white(title));
-                        console.log(chalk.dim(`     ${session.sessionId.substring(0, 20)}...`));
-                    });
-                    console.log('');
-                    const answer = await promptUser(chalk.bold('Select session to end (1-' + activeSessions.length + '): '));
-                    const choice = parseInt(answer, 10);
-                    if (choice >= 1 && choice <= activeSessions.length) {
-                        sessionId = activeSessions[choice - 1].sessionId;
-                    }
-                    else {
-                        (0, messages_1.printError)('Invalid Selection', undefined, ['Please run the command again and select a valid number']);
-                        process.exit(1);
-                    }
+                console.log(chalk.bold('Multiple active local governance sessions'));
+                records.active.forEach((session, index) => {
+                    console.log(`  ${index + 1}. ${session.sessionId} · ${truncate(session.contract.goal, 72)}`);
+                });
+                const answer = await prompt(`Select local session to end (1-${records.active.length}): `);
+                const selected = Number.parseInt(answer, 10);
+                if (!Number.isInteger(selected) || selected < 1 || selected > records.active.length) {
+                    endSessionOutput(options, {
+                        ok: false,
+                        ended: false,
+                        mode: 'local',
+                        reason: 'invalid_local_selection',
+                        message: 'No local session was ended.',
+                    }, 2);
+                    return;
                 }
+                endSessionOutput(options, await finishLocalGovernanceSession(repoRoot, records.active[selected - 1]));
+                return;
+            }
+            if (options.local) {
+                endSessionOutput(options, {
+                    ok: true,
+                    ended: false,
+                    mode: 'local',
+                    reason: 'no_active_local_session',
+                    malformedRecords: records.malformed,
+                    message: 'No active local governance session found.',
+                });
+                return;
             }
         }
-        if (!sessionId) {
-            (0, messages_1.printError)('No Session Specified', undefined, [
-                'No session ID provided and no active session found',
-                'Usage: neurcode session end [session-id]',
-                'Or set a session: neurcode init'
-            ]);
-            process.exit(1);
+        let config = null;
+        let client = dependencies.cloudClient;
+        if (!client) {
+            config = (0, config_1.loadConfig)();
+            if (!config.apiKey)
+                config.apiKey = (0, config_1.requireApiKey)();
+            client = new api_client_1.ApiClient(config);
         }
-        // Get session details first
-        try {
-            const sessionData = await client.getSession(sessionId);
-            const session = sessionData.session;
-            if (session.status === 'completed') {
-                (0, messages_1.printWarning)('Session Already Completed', `Session "${session.title || session.intentDescription || sessionId}" is already ended.`);
+        let sessionId = options.sessionId;
+        if (!sessionId) {
+            const stateSessionId = (0, state_1.getSessionId)() || undefined;
+            if (stateSessionId && (0, governance_runtime_1.loadSession)(repoRoot, stateSessionId)) {
+                const local = (0, governance_runtime_1.loadSession)(repoRoot, stateSessionId);
+                endSessionOutput(options, await finishLocalGovernanceSession(repoRoot, local));
                 return;
             }
-            if (session.status === 'cancelled') {
-                (0, messages_1.printWarning)('Session Already Cancelled', `Session "${session.title || session.intentDescription || sessionId}" was already cancelled.`);
+            sessionId = stateSessionId;
+        }
+        if (!sessionId) {
+            const sessions = await client.getSessions(options.projectId || config?.projectId, 20);
+            const active = sessions.filter((session) => session.status === 'active');
+            if (active.length === 0) {
+                endSessionOutput(options, {
+                    ok: true,
+                    ended: false,
+                    mode: 'cloud',
+                    reason: 'no_active_cloud_session',
+                    message: 'No active local or cloud session found.',
+                });
                 return;
             }
-            // Show session summary
-            const title = session.title || session.intentDescription || 'Untitled Session';
-            const filesCount = sessionData.files?.length || 0;
-            (0, messages_1.printSection)('Session Summary');
-            console.log(chalk.white(`   Title: ${title}`));
-            console.log(chalk.white(`   Files Changed: ${filesCount}`));
-            console.log(chalk.dim(`   Session ID: ${sessionId}`));
-            console.log('');
-            // Confirm before ending
-            const confirm = await promptUser(chalk.bold('End this session? (y/n): '));
-            if (confirm.toLowerCase() !== 'y' && confirm.toLowerCase() !== 'yes') {
-                (0, messages_1.printInfo)('Cancelled', 'Session was not ended.');
+            if (active.length > 1 && !isInteractive()) {
+                endSessionOutput(options, {
+                    ok: false,
+                    ended: false,
+                    mode: 'cloud',
+                    reason: 'multiple_cloud_sessions_noninteractive',
+                    candidates: active.map((session) => ({
+                        sessionId: session.sessionId,
+                        command: `neurcode session end --session-id ${session.sessionId}`,
+                    })),
+                    message: 'Multiple active cloud sessions were found; noninteractive selection is disabled.',
+                }, 2);
                 return;
             }
-            await client.endSession(sessionId);
-            // Clear session ID from local state if it matches the ended session
-            try {
-                const currentSessionId = (0, state_1.getSessionId)();
-                if (currentSessionId === sessionId) {
-                    const { clearSessionId } = await Promise.resolve().then(() => __importStar(require('../utils/state')));
-                    clearSessionId();
-                }
-            }
-            catch {
-                // Non-critical - continue if state clearing fails
+            if (active.length === 1) {
+                sessionId = active[0].sessionId;
             }
-            const firstName = await (0, messages_1.getUserFirstName)();
-            await (0, messages_1.printSuccessBanner)('Session Completed', `Great work, ${firstName}! Your session has been marked as complete.`);
-            (0, messages_1.printSuccess)('Session Ended Successfully', `"${title}" is now marked as completed.\n   View in dashboard: dashboard.neurcode.com`);
-            // Display Session ROI Summary
-            try {
-                // Fetch ROI summary from API
-                const apiUrl = config.apiUrl || process.env.NEURCODE_API_URL || 'https://api.neurcode.com';
-                const roiUrl = `${apiUrl}/api/v1/roi/summary?timeRange=7d`;
-                const roiResponse = await fetch(roiUrl, {
-                    headers: {
-                        'Authorization': `Bearer ${config.apiKey}`,
-                        'Content-Type': 'application/json',
-                    },
-                }).catch(() => null);
-                if (roiResponse && roiResponse.ok) {
-                    const roiData = await roiResponse.json().catch(() => null);
-                    if (roiData && roiData.totalCapitalSaved) {
-                        const capitalSaved = typeof roiData.totalCapitalSaved === 'string'
-                            ? parseFloat(roiData.totalCapitalSaved)
-                            : roiData.totalCapitalSaved;
-                        const formattedAmount = capitalSaved.toFixed(2);
-                        const dashboardUrl = 'https://neurcode.com/dashboard';
-                        console.log('');
-                        console.log(chalk.cyan('📊'), chalk.bold.white('Current Session ROI:'), chalk.green.bold(`+$${formattedAmount}`));
-                        console.log(chalk.dim(`   View full report: ${dashboardUrl}`));
-                        console.log('');
-                    }
+            else {
+                active.forEach((session, index) => {
+                    const title = session.title || session.intentDescription || 'Untitled';
+                    console.log(`  ${index + 1}. ${title} · ${session.sessionId}`);
+                });
+                const answer = await prompt(`Select cloud session to end (1-${active.length}): `);
+                const selected = Number.parseInt(answer, 10);
+                if (!Number.isInteger(selected) || selected < 1 || selected > active.length) {
+                    endSessionOutput(options, {
+                        ok: false,
+                        ended: false,
+                        mode: 'cloud',
+                        reason: 'invalid_cloud_selection',
+                        message: 'No cloud session was ended.',
+                    }, 2);
+                    return;
                 }
-            }
-            catch {
-                // Silently fail - ROI summary is a nice-to-have
+                sessionId = active[selected - 1].sessionId;
             }
         }
-        catch (error) {
-            if (error.message?.includes('not found') || error.message?.includes('404')) {
-                (0, messages_1.printError)('Session Not Found', error, [
-                    `Session "${sessionId}" could not be found`,
-                    'List your sessions: neurcode session list',
-                    'Verify the session ID is correct'
-                ]);
-            }
-            else {
-                throw error;
-            }
+        if (!sessionId) {
+            endSessionOutput(options, {
+                ok: false,
+                ended: false,
+                mode: 'cloud',
+                reason: 'cloud_session_not_resolved',
+                message: 'No cloud session could be resolved.',
+            }, 2);
+            return;
         }
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            if (error.message.includes('401') || error.message.includes('403')) {
-                await (0, messages_1.printAuthError)(error);
+        const sessionData = await client.getSession(sessionId);
+        const session = sessionData.session;
+        if (session.status === 'completed' || session.status === 'cancelled') {
+            endSessionOutput(options, {
+                ok: true,
+                ended: false,
+                mode: 'cloud',
+                status: session.status,
+                sessionId,
+                message: `Cloud session ${sessionId} is already ${session.status}.`,
+            });
+            return;
+        }
+        if (isInteractive()) {
+            const confirm = await prompt(`End cloud session ${sessionId}? (y/n): `);
+            if (!['y', 'yes'].includes(confirm.toLowerCase())) {
+                endSessionOutput(options, {
+                    ok: true,
+                    ended: false,
+                    mode: 'cloud',
+                    reason: 'operator_cancelled',
+                    sessionId,
+                    message: 'Cloud session was not ended.',
+                });
+                return;
             }
-            else {
-                (0, messages_1.printError)('Failed to End Session', error);
+        }
+        await client.endSession(sessionId);
+        try {
+            if ((0, state_1.getSessionId)() === sessionId) {
+                const { clearSessionId } = await Promise.resolve().then(() => __importStar(require('../utils/state')));
+                clearSessionId();
             }
         }
-        else {
-            (0, messages_1.printError)('Failed to End Session', String(error));
+        catch {
+            // Legacy local cloud pointer cleanup is best-effort.
         }
-        process.exit(1);
+        endSessionOutput(options, {
+            ok: true,
+            ended: true,
+            mode: 'cloud',
+            status: 'completed',
+            sessionId,
+            message: `Cloud session ${sessionId} ended successfully.`,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const notFound = /not found|404/i.test(message);
+        endSessionOutput(options, {
+            ok: false,
+            ended: false,
+            mode: 'unknown',
+            reason: notFound ? 'session_not_found' : 'session_end_failed',
+            sessionId: options.sessionId || null,
+            error: message,
+            message: notFound
+                ? `Session ${options.sessionId || ''} was not found locally or in the cloud.`.trim()
+                : `Failed to end session: ${message}`,
+        }, notFound ? 2 : 1);
     }
 }
 /**