@neurcode-ai/cli 0.9.27 → 0.9.29

package/dist/commands/verify.js

@@ -54,6 +54,10 @@ const ignore_1 = require("../utils/ignore");
 const project_root_1 = require("../utils/project-root");
 const brain_context_1 = require("../utils/brain-context");
 const policy_packs_1 = require("../utils/policy-packs");
+const custom_policy_rules_1 = require("../utils/custom-policy-rules");
+const policy_exceptions_1 = require("../utils/policy-exceptions");
+const policy_governance_1 = require("../utils/policy-governance");
+const policy_audit_1 = require("../utils/policy-audit");
 // Import chalk with fallback
 let chalk;
 try {
@@ -78,21 +82,21 @@ catch {
  * Check if a file path should be excluded from verification analysis
  * Excludes internal/system files that should not count towards plan adherence
  */
-const IGNORED_METADATA_FILES = new Set(['neurcode.config.json']);
-const IGNORED_DIRECTORIES = ['.neurcode/'];
+const IGNORED_METADATA_FILE_PATTERN = /(^|\/)neurcode\.config\.json$/i;
+const IGNORED_DIRECTORIES = ['.git/', 'node_modules/'];
 function isExcludedFile(filePath) {
     // Normalize path separators (handle both / and \)
     const normalizedPath = filePath.replace(/\\/g, '/');
     // Ignore specific metadata files (these should never be scope/policy violations)
-    if (IGNORED_METADATA_FILES.has(normalizedPath)) {
+    if (IGNORED_METADATA_FILE_PATTERN.test(normalizedPath)) {
+        return true;
+    }
+    // Ignore .neurcode internals at any nesting level (monorepo-safe)
+    if (/(^|\/)\.neurcode\//.test(normalizedPath)) {
         return true;
     }
     // Check if path starts with any excluded prefix
-    const excludedPrefixes = [
-        ...IGNORED_DIRECTORIES,
-        '.git/',
-        'node_modules/',
-    ];
+    const excludedPrefixes = [...IGNORED_DIRECTORIES];
     // Check prefixes
     for (const prefix of excludedPrefixes) {
         if (normalizedPath.startsWith(prefix)) {
@@ -203,76 +207,17 @@ function getRuntimeIgnoreSetFromEnv() {
         .map((item) => toUnixPath(item.trim()))
         .filter(Boolean));
 }
-/**
- * Map a dashboard custom policy (natural language) to a policy-engine Rule.
- * Supports "No console.log", "No debugger", and generic line patterns.
- */
-function customPolicyToRule(p) {
-    const sev = p.severity === 'high' ? 'block' : 'warn';
-    const text = (p.rule_text || '').trim().toLowerCase();
-    if (!text)
-        return null;
-    // Known patterns -> suspicious-keywords (checks added lines for these strings)
-    if (/console\.log|no\s+console\.log|do not use console\.log|ban console\.log/.test(text)) {
-        return {
-            id: `custom-${p.id}`,
-            name: 'No console.log',
-            description: p.rule_text,
-            enabled: true,
-            severity: sev,
-            type: 'suspicious-keywords',
-            keywords: ['console.log'],
-        };
-    }
-    if (/debugger|no\s+debugger|do not use debugger/.test(text)) {
-        return {
-            id: `custom-${p.id}`,
-            name: 'No debugger',
-            description: p.rule_text,
-            enabled: true,
-            severity: sev,
-            type: 'suspicious-keywords',
-            keywords: ['debugger'],
-        };
-    }
-    if (/eval\s*\(|no\s+eval|do not use eval/.test(text)) {
-        return {
-            id: `custom-${p.id}`,
-            name: 'No eval',
-            description: p.rule_text,
-            enabled: true,
-            severity: sev,
-            type: 'suspicious-keywords',
-            keywords: ['eval('],
-        };
-    }
-    // Fallback: line-pattern on added lines using a safe regex from the rule text
-    // Use first quoted phrase or first alphanumeric phrase as pattern
-    const quoted = /['"`]([^'"`]+)['"`]/.exec(p.rule_text);
-    const phrase = quoted?.[1] ?? p.rule_text.replace(/^(no|don't|do not use|ban|avoid)\s+/i, '').trim().slice(0, 80);
-    if (!phrase)
-        return null;
-    const escaped = phrase.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    return {
-        id: `custom-${p.id}`,
-        name: `Custom: ${p.rule_text.slice(0, 50)}`,
-        description: p.rule_text,
-        enabled: true,
-        severity: sev,
-        type: 'line-pattern',
-        pattern: escaped,
-        matchType: 'added',
-    };
-}
 async function buildEffectivePolicyRules(client, projectRoot, useDashboardPolicies) {
     const defaultPolicy = (0, policy_engine_1.createDefaultPolicy)();
     const customRules = [];
+    const customPolicies = [];
     const installedPack = (0, policy_packs_1.getInstalledPolicyPackRules)(projectRoot);
     const policyPackRules = installedPack?.rules ? [...installedPack.rules] : [];
     if (useDashboardPolicies) {
-        const customPolicies = await client.getActiveCustomPolicies();
-        for (const p of customPolicies) {
-            const r = customPolicyToRule(p);
+        const loadedCustomPolicies = await client.getActiveCustomPolicies();
+        for (const p of loadedCustomPolicies) {
+            customPolicies.push(p);
+            const r = (0, custom_policy_rules_1.customPolicyToRule)(p);
             if (r) {
                 customRules.push(r);
             }
@@ -281,34 +226,183 @@ async function buildEffectivePolicyRules(client, projectRoot, useDashboardPolici
     return {
         allRules: [...defaultPolicy.rules, ...policyPackRules, ...customRules],
         customRules,
+        customPolicies,
         policyPackRules,
         policyPack: installedPack,
+        includeDashboardPolicies: useDashboardPolicies,
+    };
+}
+const POLICY_AUDIT_FILE = 'neurcode.policy.audit.log.jsonl';
+function isEnabledFlag(value) {
+    if (!value)
+        return false;
+    const normalized = value.trim().toLowerCase();
+    return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
+}
+function policyLockMismatchMessage(mismatches) {
+    if (mismatches.length === 0) {
+        return 'Policy lock baseline check failed';
+    }
+    return `Policy lock mismatch: ${mismatches.map((item) => `[${item.code}] ${item.message}`).join('; ')}`;
+}
+function toPolicyLockViolations(mismatches) {
+    return mismatches.map((item) => ({
+        file: 'neurcode.policy.lock.json',
+        rule: `policy_lock:${item.code.toLowerCase()}`,
+        severity: 'block',
+        message: item.message,
+    }));
+}
+function resolvePolicyDecisionFromViolations(violations) {
+    let hasWarn = false;
+    for (const violation of violations) {
+        const severity = String(violation.severity || '').toLowerCase();
+        if (severity === 'block') {
+            return 'block';
+        }
+        if (severity === 'warn') {
+            hasWarn = true;
+        }
+    }
+    return hasWarn ? 'warn' : 'allow';
+}
+function explainExceptionEligibilityReason(reason) {
+    switch (reason) {
+        case 'approval_required':
+            return 'exception exists but approvals are required';
+        case 'insufficient_approvals':
+            return 'exception exists but approval threshold is not met';
+        case 'self_approval_only':
+            return 'exception only has requester self-approval';
+        case 'approver_not_allowed':
+            return 'exception approvals are from non-allowlisted approvers';
+        default:
+            return 'exception is inactive or expired';
+    }
+}
+function resolveAuditIntegrityStatus(requireIntegrity, auditIntegrity) {
+    const issues = [...auditIntegrity.issues];
+    if (requireIntegrity && auditIntegrity.count === 0) {
+        issues.push('audit chain has no events; commit neurcode.policy.audit.log.jsonl');
+    }
+    return {
+        valid: issues.length === 0,
+        issues,
     };
 }
 /**
  * Execute policy-only verification (General Governance mode)
  * Returns the exit code to use
  */
-async function executePolicyOnlyMode(options, diffFiles, ignoreFilter, projectRoot, config, client) {
+async function executePolicyOnlyMode(options, diffFiles, ignoreFilter, projectRoot, config, client, source) {
     if (!options.json) {
         console.log(chalk.cyan('🛡️  General Governance mode (policy only, no plan linked)\n'));
     }
     let policyViolations = [];
     let policyDecision = 'allow';
+    const requirePolicyLock = options.requirePolicyLock === true || isEnabledFlag(process.env.NEURCODE_VERIFY_REQUIRE_POLICY_LOCK);
+    const skipPolicyLock = options.skipPolicyLock === true || isEnabledFlag(process.env.NEURCODE_VERIFY_SKIP_POLICY_LOCK);
+    const lockRead = (0, policy_packs_1.readPolicyLockFile)(projectRoot);
+    const includeDashboardPolicies = lockRead.lock
+        ? lockRead.lock.customPolicies.mode === 'dashboard'
+        : Boolean(config.apiKey);
+    let effectiveRulesLoadError = null;
     let effectiveRules = {
         allRules: (0, policy_engine_1.createDefaultPolicy)().rules,
         customRules: [],
+        customPolicies: [],
         policyPackRules: [],
         policyPack: null,
+        includeDashboardPolicies,
     };
     try {
-        effectiveRules = await buildEffectivePolicyRules(client, projectRoot, Boolean(config.apiKey));
+        effectiveRules = await buildEffectivePolicyRules(client, projectRoot, includeDashboardPolicies);
     }
     catch (error) {
+        effectiveRulesLoadError = error instanceof Error ? error.message : 'Unknown error';
+        const installedPack = (0, policy_packs_1.getInstalledPolicyPackRules)(projectRoot);
+        const fallbackPolicyPackRules = installedPack?.rules ? [...installedPack.rules] : [];
+        effectiveRules = {
+            allRules: [...(0, policy_engine_1.createDefaultPolicy)().rules, ...fallbackPolicyPackRules],
+            customRules: [],
+            customPolicies: [],
+            policyPackRules: fallbackPolicyPackRules,
+            policyPack: installedPack,
+            includeDashboardPolicies,
+        };
         if (!options.json) {
             console.log(chalk.dim('   Could not load dashboard custom policies, using local/default policy rules only'));
         }
     }
+    let policyLockEvaluation = {
+        enforced: false,
+        matched: true,
+        lockPresent: lockRead.lock !== null,
+        lockPath: lockRead.path,
+        mismatches: [],
+    };
+    if (!skipPolicyLock) {
+        const currentSnapshot = (0, policy_packs_1.buildPolicyStateSnapshot)({
+            policyPack: effectiveRules.policyPack,
+            policyPackRules: effectiveRules.policyPackRules,
+            customPolicies: effectiveRules.customPolicies,
+            customRules: effectiveRules.customRules,
+            includeDashboardPolicies: effectiveRules.includeDashboardPolicies,
+        });
+        const lockValidation = (0, policy_packs_1.evaluatePolicyLock)(projectRoot, currentSnapshot, {
+            requireLock: requirePolicyLock,
+        });
+        policyLockEvaluation = {
+            enforced: lockValidation.enforced,
+            matched: lockValidation.matched,
+            lockPresent: lockValidation.lockPresent,
+            lockPath: lockValidation.lockPath,
+            mismatches: [...lockValidation.mismatches],
+        };
+        if (effectiveRulesLoadError && includeDashboardPolicies) {
+            policyLockEvaluation.mismatches.unshift({
+                code: 'POLICY_LOCK_CUSTOM_POLICIES_MISMATCH',
+                message: `Failed to load dashboard custom policies: ${effectiveRulesLoadError}`,
+            });
+            policyLockEvaluation.matched = false;
+        }
+    }
+    if (policyLockEvaluation.enforced && !policyLockEvaluation.matched) {
+        const message = policyLockMismatchMessage(policyLockEvaluation.mismatches);
+        if (options.json) {
+            console.log(JSON.stringify({
+                grade: 'F',
+                score: 0,
+                verdict: 'FAIL',
+                violations: toPolicyLockViolations(policyLockEvaluation.mismatches),
+                message,
+                scopeGuardPassed: true,
+                bloatCount: 0,
+                bloatFiles: [],
+                plannedFilesModified: 0,
+                totalPlannedFiles: 0,
+                adherenceScore: 0,
+                mode: 'policy_only',
+                policyOnly: true,
+                policyOnlySource: source,
+                policyLock: {
+                    enforced: true,
+                    matched: false,
+                    path: policyLockEvaluation.lockPath,
+                    mismatches: policyLockEvaluation.mismatches,
+                },
+            }, null, 2));
+        }
+        else {
+            console.log(chalk.red('❌ Policy lock baseline mismatch.'));
+            console.log(chalk.dim(`   Lock file: ${policyLockEvaluation.lockPath}`));
+            policyLockEvaluation.mismatches.forEach((item) => {
+                console.log(chalk.red(`   • [${item.code}] ${item.message}`));
+            });
+            console.log(chalk.dim('\n   If drift is intentional, regenerate baseline with `neurcode policy lock`.\n'));
+        }
+        return 2;
+    }
     if (!options.json && effectiveRules.customRules.length > 0) {
         console.log(chalk.dim(`   Evaluating ${effectiveRules.customRules.length} custom policy rule(s) from dashboard`));
     }
@@ -322,7 +416,39 @@ async function executePolicyOnlyMode(options, diffFiles, ignoreFilter, projectRo
     const policyResult = (0, policy_engine_1.evaluateRules)(diffFilesForPolicy, effectiveRules.allRules);
     policyViolations = (policyResult.violations || []);
     policyViolations = policyViolations.filter((v) => !ignoreFilter(v.file));
-    policyDecision = policyViolations.length > 0 ? policyResult.decision : 'allow';
+    const governance = (0, policy_governance_1.readPolicyGovernanceConfig)(projectRoot);
+    const auditIntegrity = (0, policy_audit_1.verifyPolicyAuditIntegrity)(projectRoot);
+    const auditIntegrityStatus = resolveAuditIntegrityStatus(governance.audit.requireIntegrity, auditIntegrity);
+    const configuredPolicyExceptions = (0, policy_exceptions_1.readPolicyExceptions)(projectRoot);
+    const exceptionDecision = (0, policy_exceptions_1.applyPolicyExceptions)(policyViolations, configuredPolicyExceptions, {
+        requireApproval: governance.exceptionApprovals.required,
+        minApprovals: governance.exceptionApprovals.minApprovals,
+        disallowSelfApproval: governance.exceptionApprovals.disallowSelfApproval,
+        allowedApprovers: governance.exceptionApprovals.allowedApprovers,
+    });
+    const suppressedViolations = exceptionDecision.suppressedViolations.filter((item) => !ignoreFilter(item.file));
+    const blockedViolations = exceptionDecision.blockedViolations
+        .filter((item) => !ignoreFilter(item.file))
+        .map((item) => ({
+        file: item.file,
+        rule: item.rule,
+        severity: 'block',
+        message: `Exception ${item.exceptionId} cannot be applied: ${explainExceptionEligibilityReason(item.eligibilityReason)}`,
+        ...(item.line != null ? { line: item.line } : {}),
+    }));
+    policyViolations = [
+        ...exceptionDecision.remainingViolations.filter((item) => !ignoreFilter(item.file)),
+        ...blockedViolations,
+    ];
+    if (governance.audit.requireIntegrity && !auditIntegrityStatus.valid) {
+        policyViolations.push({
+            file: POLICY_AUDIT_FILE,
+            rule: 'policy_audit_integrity',
+            severity: 'block',
+            message: `Policy audit chain is invalid: ${auditIntegrityStatus.issues.join('; ') || 'unknown issue'}`,
+        });
+    }
+    policyDecision = resolvePolicyDecisionFromViolations(policyViolations);
     const effectiveVerdict = policyDecision === 'block' ? 'FAIL' : policyDecision === 'warn' ? 'WARN' : 'PASS';
     const grade = effectiveVerdict === 'PASS' ? 'A' : effectiveVerdict === 'WARN' ? 'C' : 'F';
     const score = effectiveVerdict === 'PASS' ? 100 : effectiveVerdict === 'WARN' ? 50 : 0;
@@ -338,6 +464,42 @@ async function executePolicyOnlyMode(options, diffFiles, ignoreFilter, projectRo
         : policyViolations.length > 0
             ? `Policy violations: ${policyViolations.map((v) => `${v.file}: ${v.message || v.rule}`).join('; ')}`
             : 'Policy check completed';
+    const policyExceptionsSummary = {
+        configured: configuredPolicyExceptions.length,
+        active: exceptionDecision.activeExceptions.length,
+        usable: exceptionDecision.usableExceptions.length,
+        matched: exceptionDecision.matchedExceptionIds.length,
+        suppressed: suppressedViolations.length,
+        blocked: blockedViolations.length,
+        matchedExceptionIds: exceptionDecision.matchedExceptionIds,
+        suppressedViolations: suppressedViolations.map((item) => ({
+            file: item.file,
+            rule: item.rule,
+            severity: item.severity,
+            message: item.message,
+            exceptionId: item.exceptionId,
+            reason: item.reason,
+            expiresAt: item.expiresAt,
+            ...(item.line != null ? { startLine: item.line } : {}),
+        })),
+        blockedViolations: blockedViolations.map((item) => ({
+            file: item.file,
+            rule: item.rule,
+            severity: item.severity,
+            message: item.message,
+            ...(item.line != null ? { startLine: item.line } : {}),
+        })),
+    };
+    const policyGovernanceSummary = {
+        exceptionApprovals: governance.exceptionApprovals,
+        audit: {
+            requireIntegrity: governance.audit.requireIntegrity,
+            valid: auditIntegrityStatus.valid,
+            issues: auditIntegrityStatus.issues,
+            lastHash: auditIntegrity.lastHash,
+            eventCount: auditIntegrity.count,
+        },
+    };
     if (options.json) {
         console.log(JSON.stringify({
             grade,
@@ -351,7 +513,17 @@ async function executePolicyOnlyMode(options, diffFiles, ignoreFilter, projectRo
             plannedFilesModified: 0,
             totalPlannedFiles: 0,
             adherenceScore: score,
+            mode: 'policy_only',
             policyOnly: true,
+            policyOnlySource: source,
+            policyLock: {
+                enforced: policyLockEvaluation.enforced,
+                matched: policyLockEvaluation.matched,
+                path: policyLockEvaluation.lockPath,
+                mismatches: policyLockEvaluation.mismatches,
+            },
+            policyExceptions: policyExceptionsSummary,
+            policyGovernance: policyGovernanceSummary,
             ...(effectiveRules.policyPack
                 ? {
                     policyPack: {
@@ -374,6 +546,15 @@ async function executePolicyOnlyMode(options, diffFiles, ignoreFilter, projectRo
                 console.log(chalk.red(`   • ${v.file}: ${v.message || v.rule}`));
             });
         }
+        if (policyExceptionsSummary.suppressed > 0) {
+            console.log(chalk.yellow(`   Policy exceptions applied: ${policyExceptionsSummary.suppressed}`));
+        }
+        if (policyExceptionsSummary.blocked > 0) {
+            console.log(chalk.red(`   Policy exceptions blocked by approval governance: ${policyExceptionsSummary.blocked}`));
+        }
+        if (governance.audit.requireIntegrity && !auditIntegrityStatus.valid) {
+            console.log(chalk.red('   Policy audit integrity check failed'));
+        }
         console.log(chalk.dim(`\n${message}`));
     }
     return effectiveVerdict === 'FAIL' ? 2 : effectiveVerdict === 'WARN' ? 1 : 0;
@@ -551,16 +732,20 @@ async function verifyCommand(options) {
             console.log(chalk.dim(`   Found ${summary.totalFiles} file(s) changed`));
             console.log(chalk.dim(`   ${summary.totalAdded} lines added, ${summary.totalRemoved} lines removed\n`));
         }
+        const runPolicyOnlyModeAndExit = async (source) => {
+            const exitCode = await executePolicyOnlyMode(options, diffFiles, shouldIgnore, projectRoot, config, client, source);
+            const changedFiles = diffFiles.map((f) => f.path);
+            const verdict = exitCode === 2 ? 'FAIL' : exitCode === 1 ? 'WARN' : 'PASS';
+            recordVerifyEvent(verdict, `policy_only_source=${source};exit=${exitCode}`, changedFiles);
+            process.exit(exitCode);
+        };
         // ============================================
         // --policy-only: General Governance (policy only, no plan enforcement)
         // ============================================
         if (options.policyOnly) {
-            const exitCode = await executePolicyOnlyMode(options, diffFiles, shouldIgnore, projectRoot, config, client);
-            const changedFiles = diffFiles.map((f) => f.path);
-            const verdict = exitCode === 2 ? 'FAIL' : exitCode === 1 ? 'WARN' : 'PASS';
-            recordVerifyEvent(verdict, `policy_only=true;exit=${exitCode}`, changedFiles);
-            process.exit(exitCode);
+            await runPolicyOnlyModeAndExit('explicit');
         }
+        const requirePlan = options.requirePlan === true || process.env.NEURCODE_VERIFY_REQUIRE_PLAN === '1';
         // Get planId: Priority 1: options flag, Priority 2: state file (.neurcode/config.json), Priority 3: legacy config
         let planId = options.planId;
         if (!planId) {
@@ -593,19 +778,43 @@ async function verifyCommand(options) {
                 }
             }
         }
-        // If no planId found, fall back to General Governance (Policy Only) mode
+        // If no planId found, either enforce strict requirement or fall back to policy-only mode.
         if (!planId) {
+            if (requirePlan) {
+                const changedFiles = diffFiles.map((f) => f.path);
+                recordVerifyEvent('FAIL', 'missing_plan_id;require_plan=true', changedFiles);
+                if (options.json) {
+                    console.log(JSON.stringify({
+                        grade: 'F',
+                        score: 0,
+                        verdict: 'FAIL',
+                        violations: [],
+                        adherenceScore: 0,
+                        bloatCount: 0,
+                        bloatFiles: [],
+                        plannedFilesModified: 0,
+                        totalPlannedFiles: 0,
+                        message: 'Plan ID is required in strict mode. Run "neurcode plan" first or pass --plan-id.',
+                        scopeGuardPassed: false,
+                        mode: 'plan_required',
+                        policyOnly: false,
+                    }, null, 2));
+                }
+                else {
+                    console.log(chalk.red('❌ Plan ID is required in strict mode.'));
+                    console.log(chalk.dim('   Run "neurcode plan" first or pass --plan-id <id>.'));
+                    console.log(chalk.dim('   Use --policy-only only when intentionally running general governance checks.'));
+                }
+                process.exit(1);
+            }
             if (!options.json) {
                 console.log(chalk.yellow('⚠️  No Plan ID found. Falling back to General Governance (Policy Only).'));
             }
-            options.policyOnly = true;
-            const exitCode = await executePolicyOnlyMode(options, diffFiles, shouldIgnore, projectRoot, config, client);
-            const changedFiles = diffFiles.map((f) => f.path);
-            const verdict = exitCode === 2 ? 'FAIL' : exitCode === 1 ? 'WARN' : 'PASS';
-            recordVerifyEvent(verdict, `policy_only=fallback;exit=${exitCode}`, changedFiles);
-            process.exit(exitCode);
+            await runPolicyOnlyModeAndExit('fallback_missing_plan');
+        }
+        if (!planId) {
+            throw new Error('Plan ID resolution failed unexpectedly');
         }
-        // At this point, planId is guaranteed to be defined
         const finalPlanId = planId;
         // ============================================
         // STRICT SCOPE GUARD - Deterministic Check
@@ -692,6 +901,8 @@ async function verifyCommand(options) {
                         totalPlannedFiles: planFiles.length,
                         message: `Scope violation: ${filteredViolations.length} file(s) modified outside the plan`,
                         scopeGuardPassed: false,
+                        mode: 'plan_enforced',
+                        policyOnly: false,
                     };
                     // CRITICAL: Print JSON first, then exit
                     console.log(JSON.stringify(jsonOutput, null, 2));
@@ -731,7 +942,113 @@ async function verifyCommand(options) {
                 console.log('');
             }
         }
+        const requirePolicyLock = options.requirePolicyLock === true || isEnabledFlag(process.env.NEURCODE_VERIFY_REQUIRE_POLICY_LOCK);
+        const skipPolicyLock = options.skipPolicyLock === true || isEnabledFlag(process.env.NEURCODE_VERIFY_SKIP_POLICY_LOCK);
+        const lockRead = (0, policy_packs_1.readPolicyLockFile)(projectRoot);
+        const useDashboardPolicies = lockRead.lock
+            ? lockRead.lock.customPolicies.mode === 'dashboard'
+            : Boolean(config.apiKey);
+        let effectiveRulesLoadError = null;
+        let effectiveRules = {
+            allRules: (0, policy_engine_1.createDefaultPolicy)().rules,
+            customRules: [],
+            customPolicies: [],
+            policyPackRules: [],
+            policyPack: null,
+            includeDashboardPolicies: useDashboardPolicies,
+        };
+        try {
+            effectiveRules = await buildEffectivePolicyRules(client, projectRoot, useDashboardPolicies);
+        }
+        catch (error) {
+            effectiveRulesLoadError = error instanceof Error ? error.message : 'Unknown error';
+            const installedPack = (0, policy_packs_1.getInstalledPolicyPackRules)(projectRoot);
+            const fallbackPolicyPackRules = installedPack?.rules ? [...installedPack.rules] : [];
+            effectiveRules = {
+                allRules: [...(0, policy_engine_1.createDefaultPolicy)().rules, ...fallbackPolicyPackRules],
+                customRules: [],
+                customPolicies: [],
+                policyPackRules: fallbackPolicyPackRules,
+                policyPack: installedPack,
+                includeDashboardPolicies: useDashboardPolicies,
+            };
+            if (!options.json) {
+                console.log(chalk.dim('   Could not load dashboard custom policies, continuing with local/default rules only'));
+            }
+        }
+        let policyLockEvaluation = {
+            enforced: false,
+            matched: true,
+            lockPresent: lockRead.lock !== null,
+            lockPath: lockRead.path,
+            mismatches: [],
+        };
+        if (!skipPolicyLock) {
+            const currentSnapshot = (0, policy_packs_1.buildPolicyStateSnapshot)({
+                policyPack: effectiveRules.policyPack,
+                policyPackRules: effectiveRules.policyPackRules,
+                customPolicies: effectiveRules.customPolicies,
+                customRules: effectiveRules.customRules,
+                includeDashboardPolicies: effectiveRules.includeDashboardPolicies,
+            });
+            const lockValidation = (0, policy_packs_1.evaluatePolicyLock)(projectRoot, currentSnapshot, {
+                requireLock: requirePolicyLock,
+            });
+            policyLockEvaluation = {
+                enforced: lockValidation.enforced,
+                matched: lockValidation.matched,
+                lockPresent: lockValidation.lockPresent,
+                lockPath: lockValidation.lockPath,
+                mismatches: [...lockValidation.mismatches],
+            };
+            if (effectiveRulesLoadError && useDashboardPolicies) {
+                policyLockEvaluation.mismatches.unshift({
+                    code: 'POLICY_LOCK_CUSTOM_POLICIES_MISMATCH',
+                    message: `Failed to load dashboard custom policies: ${effectiveRulesLoadError}`,
+                });
+                policyLockEvaluation.matched = false;
+            }
+            if (policyLockEvaluation.enforced && !policyLockEvaluation.matched) {
+                const message = policyLockMismatchMessage(policyLockEvaluation.mismatches);
+                recordVerifyEvent('FAIL', 'policy_lock_mismatch', diffFiles.map((f) => f.path), finalPlanId);
+                if (options.json) {
+                    console.log(JSON.stringify({
+                        grade: 'F',
+                        score: 0,
+                        verdict: 'FAIL',
+                        violations: toPolicyLockViolations(policyLockEvaluation.mismatches),
+                        adherenceScore: 0,
+                        bloatCount: 0,
+                        bloatFiles: [],
+                        plannedFilesModified: 0,
+                        totalPlannedFiles: 0,
+                        message,
+                        scopeGuardPassed,
+                        mode: 'plan_enforced',
+                        policyOnly: false,
+                        policyLock: {
+                            enforced: true,
+                            matched: false,
+                            path: policyLockEvaluation.lockPath,
+                            mismatches: policyLockEvaluation.mismatches,
+                        },
+                    }, null, 2));
+                }
+                else {
+                    console.log(chalk.red('\n❌ Policy lock baseline mismatch'));
+                    console.log(chalk.dim(`   Lock file: ${policyLockEvaluation.lockPath}`));
+                    policyLockEvaluation.mismatches.forEach((item) => {
+                        console.log(chalk.red(`   • [${item.code}] ${item.message}`));
+                    });
+                    console.log(chalk.dim('\n   If this drift is intentional, regenerate baseline with `neurcode policy lock`.\n'));
+                }
+                process.exit(2);
+            }
+        }
         // Check user tier - Policy Compliance and A-F Grading are PRO features
+        const governance = (0, policy_governance_1.readPolicyGovernanceConfig)(projectRoot);
+        const auditIntegrity = (0, policy_audit_1.verifyPolicyAuditIntegrity)(projectRoot);
+        const auditIntegrityStatus = resolveAuditIntegrityStatus(governance.audit.requireIntegrity, auditIntegrity);
         const { getUserTier } = await Promise.resolve().then(() => __importStar(require('../utils/tier')));
         const tier = await getUserTier();
         if (tier === 'FREE') {
@@ -759,36 +1076,105 @@ async function verifyCommand(options) {
                     totalPlannedFiles: 0,
                     message: 'Basic file change summary (PRO required for policy verification)',
                     scopeGuardPassed: false,
+                    mode: 'plan_enforced',
+                    policyOnly: false,
                     tier: 'FREE',
+                    policyLock: {
+                        enforced: policyLockEvaluation.enforced,
+                        matched: policyLockEvaluation.matched,
+                        path: policyLockEvaluation.lockPath,
+                        mismatches: policyLockEvaluation.mismatches,
+                    },
+                    policyGovernance: {
+                        exceptionApprovals: governance.exceptionApprovals,
+                        audit: {
+                            requireIntegrity: governance.audit.requireIntegrity,
+                            valid: auditIntegrityStatus.valid,
+                            issues: auditIntegrityStatus.issues,
+                            lastHash: auditIntegrity.lastHash,
+                            eventCount: auditIntegrity.count,
+                        },
+                    },
                 }, null, 2));
             }
             process.exit(0);
         }
         let policyViolations = [];
         let policyDecision = 'allow';
-        let effectiveRules = {
-            allRules: (0, policy_engine_1.createDefaultPolicy)().rules,
-            customRules: [],
-            policyPackRules: [],
-            policyPack: null,
+        const diffFilesForPolicy = diffFiles.filter((f) => !shouldIgnore(f.path));
+        const policyResult = (0, policy_engine_1.evaluateRules)(diffFilesForPolicy, effectiveRules.allRules);
+        policyViolations = policyResult.violations.filter((v) => !shouldIgnore(v.file));
+        const configuredPolicyExceptions = (0, policy_exceptions_1.readPolicyExceptions)(projectRoot);
+        const exceptionDecision = (0, policy_exceptions_1.applyPolicyExceptions)(policyViolations, configuredPolicyExceptions, {
+            requireApproval: governance.exceptionApprovals.required,
+            minApprovals: governance.exceptionApprovals.minApprovals,
+            disallowSelfApproval: governance.exceptionApprovals.disallowSelfApproval,
+            allowedApprovers: governance.exceptionApprovals.allowedApprovers,
+        });
+        const suppressedPolicyViolations = exceptionDecision.suppressedViolations.filter((item) => !shouldIgnore(item.file));
+        const blockedPolicyViolations = exceptionDecision.blockedViolations
+            .filter((item) => !shouldIgnore(item.file))
+            .map((item) => ({
+            file: item.file,
+            rule: item.rule,
+            severity: 'block',
+            message: `Exception ${item.exceptionId} cannot be applied: ${explainExceptionEligibilityReason(item.eligibilityReason)}`,
+            ...(item.line != null ? { line: item.line } : {}),
+        }));
+        policyViolations = [
+            ...exceptionDecision.remainingViolations.filter((item) => !shouldIgnore(item.file)),
+            ...blockedPolicyViolations,
+        ];
+        if (governance.audit.requireIntegrity && !auditIntegrityStatus.valid) {
+            policyViolations.push({
+                file: POLICY_AUDIT_FILE,
+                rule: 'policy_audit_integrity',
+                severity: 'block',
+                message: `Policy audit chain is invalid: ${auditIntegrityStatus.issues.join('; ') || 'unknown issue'}`,
+            });
+        }
+        policyDecision = resolvePolicyDecisionFromViolations(policyViolations);
+        const policyExceptionsSummary = {
+            configured: configuredPolicyExceptions.length,
+            active: exceptionDecision.activeExceptions.length,
+            usable: exceptionDecision.usableExceptions.length,
+            matched: exceptionDecision.matchedExceptionIds.length,
+            suppressed: suppressedPolicyViolations.length,
+            blocked: blockedPolicyViolations.length,
+            matchedExceptionIds: exceptionDecision.matchedExceptionIds,
+            suppressedViolations: suppressedPolicyViolations.map((item) => ({
+                file: item.file,
+                rule: item.rule,
+                severity: item.severity,
+                message: item.message,
+                exceptionId: item.exceptionId,
+                reason: item.reason,
+                expiresAt: item.expiresAt,
+                ...(item.line != null ? { startLine: item.line } : {}),
+            })),
+            blockedViolations: blockedPolicyViolations.map((item) => ({
+                file: item.file,
+                rule: item.rule,
+                severity: item.severity,
+                message: item.message,
+                ...(item.line != null ? { startLine: item.line } : {}),
+            })),
         };
-        try {
-            effectiveRules = await buildEffectivePolicyRules(client, projectRoot, Boolean(config.apiKey));
-            const diffFilesForPolicy = diffFiles.filter((f) => !shouldIgnore(f.path));
-            const policyResult = (0, policy_engine_1.evaluateRules)(diffFilesForPolicy, effectiveRules.allRules);
-            policyViolations = policyResult.violations.filter((v) => !shouldIgnore(v.file));
-            policyDecision = policyViolations.length > 0 ? policyResult.decision : 'allow';
-            if (!options.json && effectiveRules.customRules.length > 0) {
-                console.log(chalk.dim(`   Evaluating ${effectiveRules.customRules.length} custom policy rule(s) from dashboard`));
-            }
-            if (!options.json && effectiveRules.policyPack && effectiveRules.policyPackRules.length > 0) {
-                console.log(chalk.dim(`   Evaluating policy pack: ${effectiveRules.policyPack.packName} (${effectiveRules.policyPack.packId}@${effectiveRules.policyPack.version}, ${effectiveRules.policyPackRules.length} rule(s))`));
-            }
+        const policyGovernanceSummary = {
+            exceptionApprovals: governance.exceptionApprovals,
+            audit: {
+                requireIntegrity: governance.audit.requireIntegrity,
+                valid: auditIntegrityStatus.valid,
+                issues: auditIntegrityStatus.issues,
+                lastHash: auditIntegrity.lastHash,
+                eventCount: auditIntegrity.count,
+            },
+        };
+        if (!options.json && effectiveRules.customRules.length > 0) {
+            console.log(chalk.dim(`   Evaluating ${effectiveRules.customRules.length} custom policy rule(s) from dashboard`));
         }
-        catch (error) {
-            if (!options.json) {
-                console.log(chalk.dim('   Could not load dashboard custom policies, continuing with local/default rules only'));
-            }
+        if (!options.json && effectiveRules.policyPack && effectiveRules.policyPackRules.length > 0) {
+            console.log(chalk.dim(`   Evaluating policy pack: ${effectiveRules.policyPack.packName} (${effectiveRules.policyPack.packId}@${effectiveRules.policyPack.version}, ${effectiveRules.policyPackRules.length} rule(s))`));
         }
         // Prepare diff stats and changed files for API
         const diffStats = {
@@ -834,9 +1220,12 @@ async function verifyCommand(options) {
             // Apply custom policy verdict: block from dashboard overrides API verdict
             const policyBlock = policyDecision === 'block' && policyViolations.length > 0;
             const effectiveVerdict = policyBlock ? 'FAIL' : verifyResult.verdict;
-            const effectiveMessage = policyBlock
+            const policyMessageBase = policyBlock
                 ? `Custom policy violations: ${policyViolations.map(v => `${v.file}: ${v.message || v.rule}`).join('; ')}. ${verifyResult.message}`
                 : verifyResult.message;
+            const effectiveMessage = policyExceptionsSummary.suppressed > 0
+                ? `${policyMessageBase} Policy exceptions suppressed ${policyExceptionsSummary.suppressed} violation(s).`
+                : policyMessageBase;
             // Calculate grade from effective verdict and score
             // CRITICAL: 0/0 planned files = 'F' (Incomplete), not 'B'
             // Bloat automatically drops grade by at least one letter
@@ -882,7 +1271,13 @@ async function verifyCommand(options) {
             const changedPathsForBrain = diffFiles
                 .flatMap((file) => [file.path, file.oldPath])
                 .filter((value) => Boolean(value));
-            recordVerifyEvent(effectiveVerdict, `adherence=${verifyResult.adherenceScore};bloat=${verifyResult.bloatCount};scopeGuard=${scopeGuardPassed ? 1 : 0};policy=${policyDecision}`, changedPathsForBrain, finalPlanId);
+            recordVerifyEvent(effectiveVerdict, `adherence=${verifyResult.adherenceScore};bloat=${verifyResult.bloatCount};scopeGuard=${scopeGuardPassed ? 1 : 0};policy=${policyDecision};policyExceptions=${policyExceptionsSummary.suppressed}`, changedPathsForBrain, finalPlanId);
+            const shouldForceGovernancePass = scopeGuardPassed &&
+                !policyBlock &&
+                (effectiveVerdict === 'PASS' ||
+                    ((verifyResult.verdict === 'FAIL' || verifyResult.verdict === 'WARN') &&
+                        policyViolations.length === 0 &&
+                        verifyResult.bloatCount > 0));
             // If JSON output requested, output JSON and exit
             if (options.json) {
                 const filteredBloatFiles = (verifyResult.bloatFiles || []).filter((f) => !shouldIgnore(f));
@@ -912,6 +1307,16 @@ async function verifyCommand(options) {
                     bloatFiles: filteredBloatFiles,
                     plannedFilesModified: verifyResult.plannedFilesModified,
                     totalPlannedFiles: verifyResult.totalPlannedFiles,
+                    mode: 'plan_enforced',
+                    policyOnly: false,
+                    policyLock: {
+                        enforced: policyLockEvaluation.enforced,
+                        matched: policyLockEvaluation.matched,
+                        path: policyLockEvaluation.lockPath,
+                        mismatches: policyLockEvaluation.mismatches,
+                    },
+                    policyExceptions: policyExceptionsSummary,
+                    policyGovernance: policyGovernanceSummary,
                     ...(policyViolations.length > 0 && { policyDecision }),
                     ...(effectiveRules.policyPack
                         ? {
@@ -948,7 +1353,7 @@ async function verifyCommand(options) {
                     });
                 }
                 // Exit based on effective verdict (same logic as below)
-                if (scopeGuardPassed && !policyBlock) {
+                if (shouldForceGovernancePass) {
                     process.exit(0);
                 }
                 if (effectiveVerdict === 'FAIL') {
@@ -971,6 +1376,25 @@ async function verifyCommand(options) {
                     bloatFiles: displayBloatFiles,
                     bloatCount: displayBloatFiles.length,
                 }, policyViolations);
+                if (policyExceptionsSummary.suppressed > 0) {
+                    console.log(chalk.yellow(`\n⚠️  Policy exceptions applied: ${policyExceptionsSummary.suppressed}`));
+                    if (policyExceptionsSummary.matchedExceptionIds.length > 0) {
+                        console.log(chalk.dim(`   Exception IDs: ${policyExceptionsSummary.matchedExceptionIds.join(', ')}`));
+                    }
+                }
+                if (policyExceptionsSummary.blocked > 0) {
+                    console.log(chalk.red(`\n⛔ Policy exceptions blocked by approval governance: ${policyExceptionsSummary.blocked}`));
+                    const sample = policyExceptionsSummary.blockedViolations.slice(0, 5);
+                    sample.forEach((item) => {
+                        console.log(chalk.red(`   • ${item.file}: ${item.message || item.rule}`));
+                    });
+                }
+                if (governance.audit.requireIntegrity && !auditIntegrityStatus.valid) {
+                    console.log(chalk.red('\n⛔ Policy audit integrity enforcement is enabled and chain verification failed.'));
+                    auditIntegrityStatus.issues.slice(0, 5).forEach((issue) => {
+                        console.log(chalk.red(`   • ${issue}`));
+                    });
+                }
             }
             // Report to Neurcode Cloud if --record flag is set
             if (options.record) {
@@ -1001,9 +1425,9 @@ async function verifyCommand(options) {
                     );
                 }
             }
-            // Governance takes priority over Grading
-            // If Scope Guard passed (all files approved or allowed) and no policy block, always PASS
-            if (scopeGuardPassed && !policyBlock) {
+            // Governance override: keep PASS only when scope guard passes and failure is due
+            // to server-side bloat mismatch (allowed files unknown to verify API).
+            if (shouldForceGovernancePass) {
                 if ((verifyResult.verdict === 'FAIL' || verifyResult.verdict === 'WARN') && policyViolations.length === 0) {
                     if (!options.json) {
                         console.log(chalk.yellow('\n⚠️  Plan deviation allowed'));
@@ -1011,6 +1435,9 @@ async function verifyCommand(options) {
                         console.log(chalk.dim('   Governance check passed - proceeding with exit code 0.\n'));
                     }
                 }
+                if (!options.json && policyExceptionsSummary.suppressed > 0) {
+                    console.log(chalk.yellow(`   Policy exceptions applied: ${policyExceptionsSummary.suppressed}`));
+                }
                 process.exit(0);
             }
             // If scope guard didn't pass (or failed to check) or policy blocked, use effective verdict