@neurcode-ai/cli 0.19.8 → 0.20.1

package/dist/commands/session-hook.js

@@ -23,6 +23,7 @@ exports.resolveSessionForHook = resolveSessionForHook;
 exports.normalizeHookFilePathForRepo = normalizeHookFilePathForRepo;
 exports.hookFilePathCandidates = hookFilePathCandidates;
 exports.proposedSourceFromHookInput = proposedSourceFromHookInput;
+exports.governanceWasExpected = governanceWasExpected;
 exports.evaluateNoActiveSessionWrite = evaluateNoActiveSessionWrite;
 exports.shouldKeepSessionActiveForPendingApproval = shouldKeepSessionActiveForPendingApproval;
 exports.reconcileTrustedAdapterPosture = reconcileTrustedAdapterPosture;
@@ -46,10 +47,14 @@ const structural_understanding_1 = require("../utils/structural-understanding");
 const consequence_nudges_1 = require("../utils/consequence-nudges");
 const agent_guard_supervisor_1 = require("../utils/agent-guard-supervisor");
 const local_repo_brain_1 = require("../utils/local-repo-brain");
+const runtime_authority_1 = require("../utils/runtime-authority");
+const brain_lifecycle_1 = require("../utils/brain-lifecycle");
 const proposed_change_analysis_1 = require("../utils/proposed-change-analysis");
 const repo_intelligence_v2_1 = require("../utils/repo-intelligence-v2");
 const runtime_companion_1 = require("../utils/runtime-companion");
 const profile_drift_recovery_1 = require("../utils/profile-drift-recovery");
+const session_start_transaction_1 = require("../utils/session-start-transaction");
+const runtime_state_1 = require("../utils/runtime-state");
 // ── Helpers ───────────────────────────────────────────────────────────────────
 /** Read the full hook JSON from stdin, or return {} on any error. */
 function readHookInput() {
@@ -584,8 +589,62 @@ function blockContext(input) {
     };
 }
 const NO_ACTIVE_SESSION_SCOPE_SENTINEL = '__neurcode_no_active_session_scope__';
+/**
+ * Whether governance was previously established for this repository — a built profile, an
+ * active-session pointer, or any persisted session record. Used to distinguish ordinary
+ * first-run use (advisory) from a runtime that was expected to govern but is currently
+ * unavailable (fail closed). Dynamic — derived from on-disk governance artifacts only, no
+ * hardcoded repository directory names.
+ */
+function governanceWasExpected(repoRoot) {
+    try {
+        if ((0, fs_1.existsSync)((0, v0_governance_1.profilePath)(repoRoot)))
+            return true;
+        if ((0, fs_1.existsSync)((0, path_1.join)(repoRoot, '.neurcode', 'active-session.json')))
+            return true;
+        const sessions = (0, path_1.join)(repoRoot, '.neurcode', 'sessions');
+        return (0, fs_1.existsSync)(sessions) && (0, fs_1.readdirSync)(sessions).length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+function emptyNoSessionBoundary(filePath) {
+    return (0, governance_runtime_1.checkFileBoundary)({
+        filePath,
+        allowedGlobs: [NO_ACTIVE_SESSION_SCOPE_SENTINEL],
+        ownershipRules: [],
+        sensitiveGlobs: [],
+        approvalRequiredGlobs: [],
+        approvedPaths: [],
+        approvalGrants: [],
+        scopeMode: 'explicit',
+        localMode: 'strict',
+    });
+}
 function evaluateNoActiveSessionWrite(repoRoot, filePath) {
-    const profile = (0, v0_governance_1.ensureFreshGovernanceProfile)(repoRoot).profile;
+    let profile;
+    try {
+        profile = (0, v0_governance_1.ensureFreshGovernanceProfile)(repoRoot).profile;
+    }
+    catch {
+        // P0-E: the governance runtime is expected (this hook is installed) but the profile
+        // cannot be evaluated. If governance was previously established, FAIL CLOSED — a
+        // protected path must never pass merely because session creation / the runtime failed.
+        // First-run repos (no prior governance) stay advisory to avoid blocking ordinary use.
+        const assessment = (0, runtime_state_1.classifyRuntimeState)(repoRoot);
+        const expected = assessment.governanceExpected;
+        return {
+            block: expected,
+            filePath,
+            result: emptyNoSessionBoundary(filePath),
+            runtimeState: expected ? assessment.state : 'installed_not_activated',
+            message: expected
+                ? `⏸ Neurcode: the governance runtime is unavailable and cannot verify whether ${filePath} is a protected path, but governance is expected for this repository. Failing closed. Run exactly: ${assessment.recoveryCommand}.`
+                : `No governance profile yet at ${repoRoot}; ${filePath} is allowed advisory-only until a governed session establishes one.`,
+        };
+    }
+    const assessment = (0, runtime_state_1.classifyRuntimeState)(repoRoot);
     const result = (0, governance_runtime_1.checkFileBoundary)({
         filePath,
         allowedGlobs: [NO_ACTIVE_SESSION_SCOPE_SENTINEL],
@@ -598,14 +657,19 @@ function evaluateNoActiveSessionWrite(repoRoot, filePath) {
         localMode: 'strict',
     });
     const protectedPath = result.isApprovalRequired || result.isSensitive || result.owners.length > 0;
+    const enforcementPaused = assessment.state === 'enforcement_paused';
     const ownerNote = result.owners.length ? ` Owners: ${result.owners.join(', ')}.` : '';
-    const message = protectedPath
-        ? `⏸ Neurcode: no active governed session is running, so protected path ${filePath} cannot be checked or approved safely.${ownerNote} Start a governed session with \`neurcode session-hook start\`/agent activation, or run \`neurcode doctor --runtime\` for recovery before retrying.`
-        : `No active governed session at ${repoRoot}; ${filePath} is not a detected protected path and is allowed advisory-only.`;
+    const message = enforcementPaused
+        ? `Neurcode enforcement is intentionally paused; ${filePath} is advisory-only. Resume with exactly: ${assessment.recoveryCommand}.`
+        : protectedPath
+            ? `⏸ Neurcode: no active governed session is running, so protected path ${filePath} cannot be checked or approved safely.${ownerNote} Start a governed session with \`neurcode session-hook start\`/agent activation, or run \`neurcode doctor --runtime\` for recovery before retrying.`
+            : `No active governed session at ${repoRoot}; ${filePath} is not a detected protected path and is allowed advisory-only.`;
     return {
-        block: protectedPath,
+        block: protectedPath && !enforcementPaused,
         filePath,
         result,
+        // Profile is readable but no session is active: governance was expected to run here.
+        runtimeState: assessment.state,
         message,
     };
 }
@@ -953,7 +1017,12 @@ async function handleStart(cmdCwd) {
         // No text in the prompt — skip session creation (tool-use-only turn)
         return;
     }
+    (0, session_start_transaction_1.beginSessionStartTransaction)(repoRoot, process.env.NEURCODE_BOUNDED_COMMAND_KEY || 'session_hook_start');
+    // Hoisted so the catch can roll back a session that was created but never activated.
+    let session = null;
+    let sessionActivated = false;
     try {
+        (0, session_start_transaction_1.updateSessionStartTransaction)(repoRoot, { phase: 'fingerprinting_profile' });
         const profileResult = (0, v0_governance_1.ensureFreshGovernanceProfile)(repoRoot);
         let profileFreshness = (0, v0_governance_1.buildProfileFreshnessSignal)(profileResult, profileResult.refreshed ? 'auto_refreshed' : 'none');
         if (profileResult.refreshed && profileResult.status !== 'missing') {
@@ -1085,7 +1154,16 @@ async function handleStart(cmdCwd) {
             return;
         }
         const profile = profileResult.profile;
-        let session = (0, governance_runtime_1.createSession)(repoRoot, profile, goal.trim());
+        // Transactional start (P0-D): create the durable session record WITHOUT publishing
+        // the active pointer. The pointer is published (activated) only after every
+        // session-shaping step below succeeds, so a start that fails partway leaves no active
+        // pointer and no partial session — it is rolled back in the catch.
+        (0, session_start_transaction_1.updateSessionStartTransaction)(repoRoot, { phase: 'persisting_deferred_session' });
+        session = (0, governance_runtime_1.createSession)(repoRoot, profile, goal.trim(), { activate: false });
+        (0, session_start_transaction_1.updateSessionStartTransaction)(repoRoot, {
+            phase: 'shaping_session',
+            sessionId: session.sessionId,
+        });
         const plannedAtStart = maybeCaptureAgentPlan(repoRoot, session, hookInput);
         if (plannedAtStart)
             session = plannedAtStart;
@@ -1127,13 +1205,36 @@ async function handleStart(cmdCwd) {
                     : '');
         const banner = `🔒 Neurcode session ${session.sessionId} · ${scopeNote} · ` +
             `${session.contract.approvalRequiredGlobs.length} approval-required boundaries`;
+        // Commit: all session-shaping steps succeeded, so publish the active pointer now.
+        (0, session_start_transaction_1.updateSessionStartTransaction)(repoRoot, {
+            phase: 'activating_session',
+            sessionId: session.sessionId,
+        });
+        (0, governance_runtime_1.activateSession)(repoRoot, session.sessionId);
+        sessionActivated = true;
         process.stdout.write(JSON.stringify({ message: banner }) + '\n');
+        // Cloud projection is non-authoritative and must not affect the committed session.
+        (0, session_start_transaction_1.updateSessionStartTransaction)(repoRoot, {
+            phase: 'reconciling_cloud',
+            sessionId: session.sessionId,
+        });
         await (0, runtime_live_1.publishRuntimeLiveStatus)(repoRoot, session, { profileFreshness });
     }
     catch (err) {
+        // A start that failed before activation is rolled back so no partial session and no
+        // dangling active pointer survive (P0-D: failed start leaves nothing behind).
+        if (session && !sessionActivated) {
+            try {
+                (0, governance_runtime_1.removeSession)(repoRoot, session.sessionId);
+            }
+            catch { /* best effort rollback */ }
+        }
         diagnostic(`start failed: ${err instanceof Error ? err.message : String(err)}`);
         // Fail open — don't break the agent turn
     }
+    finally {
+        (0, session_start_transaction_1.clearSessionStartTransaction)(repoRoot);
+    }
 }
 const HARD_PREWRITE_ADAPTERS = new Set(['claude-code-hooks', 'copilot-hooks']);
 /**
@@ -1157,6 +1258,20 @@ async function handleCheck(cmdCwd, trustedAdapterId, trustedTiming) {
     const hookInput = readHookInput();
     const effectiveCwd = cwdFromHookInput(hookInput, cmdCwd);
     const repoRoot = (0, v0_governance_1.resolveRepoRoot)(effectiveCwd);
+    try {
+        (0, runtime_authority_1.assertProtectedRuntimeAuthority)(repoRoot, trustedAdapterId);
+    }
+    catch (error) {
+        denyPreToolUse(error instanceof Error ? error.message : String(error), {
+            blockContext: blockContext({
+                blockType: 'profile_or_runtime_health_block',
+                message: error instanceof Error ? error.message : String(error),
+                runtimeMode: 'strict',
+                nextAction: 'Run `neurcode runtime repair`, restart the agent integration if requested, and retry.',
+            }),
+        });
+        return;
+    }
     (0, hook_heartbeat_1.recordHookHeartbeat)({ repoRoot, eventType: 'check' });
     const requestedSessionId = sessionIdFromHookInput(hookInput);
     const toolName = hookInput['tool_name'] ||
@@ -1199,6 +1314,19 @@ async function handleCheck(cmdCwd, trustedAdapterId, trustedTiming) {
                 }
             }
             catch (error) {
+                // P0-E defense in depth: if the protected-path check itself errors and governance
+                // was expected for this repo, fail closed for this path rather than allow it.
+                if (governanceWasExpected(repoRoot)) {
+                    denyPreToolUse(`⏸ Neurcode could not verify whether ${filePath} is a protected path because the governance runtime errored, and governance is expected for this repository. Failing closed. Run \`neurcode runtime repair\`, then start a governed session and retry.`, {
+                        blockContext: blockContext({
+                            blockType: 'profile_or_runtime_health_block',
+                            filePath,
+                            message: error instanceof Error ? error.message : String(error),
+                            runtimeMode: 'strict',
+                            nextAction: 'Run `neurcode runtime repair`, then start a governed session and retry this path.',
+                        }),
+                    });
+                }
                 diagnostic(`no-active-session protected-path check skipped: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
@@ -1974,6 +2102,13 @@ async function handleFinish(cmdCwd) {
         if (supervisorStop.signaled) {
             diagnostic(`agent guard supervisor stop requested (pid ${supervisorStop.state?.pid ?? 'unknown'})`);
         }
+        try {
+            const brain = await (0, brain_lifecycle_1.scheduleBrainIndex)(repoRoot, { force: true });
+            diagnostic(`repository Brain refresh ${brain.state}`);
+        }
+        catch (brainError) {
+            diagnostic(`repository Brain refresh scheduling failed: ${brainError instanceof Error ? brainError.message : String(brainError)}`);
+        }
         const blockCount = finished.events.filter((e) => e.type === 'check_block').length;
         const warnCount = finished.events.filter((e) => e.type === 'check_warn').length;
         const unresolvedLine = pendingActionableBlock
@@ -2072,6 +2207,8 @@ function sessionHookCommand(program) {
         const cwd = opts.dir || process.cwd();
         const repoRoot = (0, v0_governance_1.resolveRepoRoot)(cwd);
         try {
+            // 1) Authoritative, durable local approval. If this throws, NOTHING is approved
+            //    and the outer catch reports a real failure (exit 1, no "Approved" output).
             const result = (0, governance_runtime_1.approveSession)(repoRoot, subOpts.path, {
                 reason: subOpts.reason,
                 sessionId: subOpts.sessionId,
@@ -2079,8 +2216,26 @@ function sessionHookCommand(program) {
                 ttlMs: subOpts.expiry === false || subOpts.expiresAt ? undefined : parseDurationMs(subOpts.expiresIn),
                 source: 'local_cli',
             });
+            // 2) Cloud reconcile is NON-AUTHORITATIVE. A reconcile failure must never be
+            //    reported as a failed approval (Apache Airflow dogfood P0-C: the misleading
+            //    "✅ Approved … approval failed" sequence). Surface it as a distinct,
+            //    non-fatal status and keep exit 0 — the local approval is already durable.
+            let reconcile = { ok: true };
+            try {
+                const session = (0, governance_runtime_1.loadSession)(repoRoot, result.sessionId);
+                if (session) {
+                    const published = await (0, runtime_live_1.publishRuntimeLiveStatus)(repoRoot, session);
+                    reconcile = { ok: published.ok, error: published.error, pending: published.pending };
+                }
+            }
+            catch (reconcileErr) {
+                reconcile = {
+                    ok: false,
+                    error: reconcileErr instanceof Error ? reconcileErr.message : String(reconcileErr),
+                };
+            }
             if (subOpts.json) {
-                process.stdout.write(JSON.stringify({ ok: true, ...result }, null, 2) + '\n');
+                process.stdout.write(JSON.stringify({ ok: true, ...result, cloudReconcile: reconcile }, null, 2) + '\n');
             }
             else {
                 process.stdout.write([
@@ -2089,10 +2244,10 @@ function sessionHookCommand(program) {
                     `   Expires:  ${result.expiresAt || 'session end'}`,
                     `   All approved paths: ${result.approvedPaths.join(', ')}`,
                 ].join('\n') + '\n');
+                if (!reconcile.ok) {
+                    process.stderr.write(`[neurcode] note: approval is durable locally; cloud reconcile deferred${reconcile.error ? ` (${reconcile.error})` : ''}\n`);
+                }
             }
-            const session = (0, governance_runtime_1.loadSession)(repoRoot, result.sessionId);
-            if (session)
-                await (0, runtime_live_1.publishRuntimeLiveStatus)(repoRoot, session);
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);