@neurcode-ai/cli 0.9.31 → 0.9.32

package/dist/commands/plan.js

@@ -49,6 +49,7 @@ const plan_cache_1 = require("../utils/plan-cache");
 const neurcode_context_1 = require("../utils/neurcode-context");
 const brain_context_1 = require("../utils/brain-context");
 const project_root_1 = require("../utils/project-root");
+const plan_slo_1 = require("../utils/plan-slo");
 // Import chalk with fallback for plain strings if not available
 let chalk;
 try {
@@ -84,6 +85,12 @@ function scanFiles(dir, baseDir, maxFiles = 200) {
                     break;
                 const fullPath = (0, path_1.join)(currentDir, entry);
                 const relativePath = (0, path_1.relative)(baseDir, fullPath);
+                const normalizedRelativePath = toUnixPath(relativePath);
+                if (normalizedRelativePath === '' ||
+                    normalizedRelativePath === '.' ||
+                    normalizedRelativePath.startsWith('..')) {
+                    continue;
+                }
                 // Skip hidden files and directories
                 if (entry.startsWith('.')) {
                     // Allow .env, .gitignore, etc. but skip .git, .next, etc.
@@ -97,7 +104,11 @@ function scanFiles(dir, baseDir, maxFiles = 200) {
                 if (ignoreDirs.has(entry))
                     continue;
                 try {
-                    const stat = (0, fs_1.statSync)(fullPath);
+                    const stat = (0, fs_1.lstatSync)(fullPath);
+                    if (stat.isSymbolicLink()) {
+                        // Skip symlinked entries to avoid escaping repository boundaries.
+                        continue;
+                    }
                     if (stat.isDirectory()) {
                         scan(fullPath);
                     }
@@ -190,35 +201,316 @@ function displayPlan(plan) {
     }
     console.log('');
 }
-/**
- * Ensure asset map exists, creating it silently if needed
- */
-async function ensureAssetMap(cwd) {
-    let map = (0, map_1.loadAssetMap)(cwd);
-    if (!map) {
-        // Silently create the map if it doesn't exist
-        try {
-            const { ProjectScanner } = await Promise.resolve().then(() => __importStar(require('../services/mapper/ProjectScanner')));
-            const scanner = new ProjectScanner(cwd);
-            map = await scanner.scan();
-            // Save it
-            const { writeFileSync, mkdirSync } = await Promise.resolve().then(() => __importStar(require('fs')));
-            const neurcodeDir = (0, path_1.join)(cwd, '.neurcode');
-            if (!(0, fs_1.existsSync)(neurcodeDir)) {
-                mkdirSync(neurcodeDir, { recursive: true });
-            }
-            const mapPath = (0, path_1.join)(neurcodeDir, 'asset-map.json');
-            writeFileSync(mapPath, JSON.stringify(map, null, 2) + '\n', 'utf-8');
+function parseRatio(raw) {
+    if (!raw)
+        return null;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed < 0 || parsed > 1)
+        return null;
+    return parsed;
+}
+function parsePercent(raw) {
+    if (!raw)
+        return null;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed < 0 || parsed > 100)
+        return null;
+    return Math.floor(parsed);
+}
+function getEscalationGuardPath(cwd) {
+    return (0, path_1.join)(cwd, '.neurcode', 'asset-map-escalation-guard.json');
+}
+function loadEscalationGuardState(cwd) {
+    const pathValue = getEscalationGuardPath(cwd);
+    if (!(0, fs_1.existsSync)(pathValue)) {
+        return {
+            version: 1,
+            updatedAt: new Date(0).toISOString(),
+            consecutiveBreaches: 0,
+        };
+    }
+    try {
+        const raw = JSON.parse((0, fs_1.readFileSync)(pathValue, 'utf-8'));
+        return {
+            version: 1,
+            updatedAt: typeof raw.updatedAt === 'string' ? raw.updatedAt : new Date(0).toISOString(),
+            consecutiveBreaches: typeof raw.consecutiveBreaches === 'number' && Number.isFinite(raw.consecutiveBreaches) && raw.consecutiveBreaches > 0
+                ? Math.floor(raw.consecutiveBreaches)
+                : 0,
+            lastBreachAt: typeof raw.lastBreachAt === 'string' ? raw.lastBreachAt : undefined,
+            lastReason: typeof raw.lastReason === 'string' ? raw.lastReason : undefined,
+            cooldownUntil: typeof raw.cooldownUntil === 'string' ? raw.cooldownUntil : undefined,
+        };
+    }
+    catch {
+        return {
+            version: 1,
+            updatedAt: new Date(0).toISOString(),
+            consecutiveBreaches: 0,
+        };
+    }
+}
+function saveEscalationGuardState(cwd, state) {
+    const pathValue = getEscalationGuardPath(cwd);
+    const dir = (0, path_1.join)(cwd, '.neurcode');
+    if (!(0, fs_1.existsSync)(dir)) {
+        (0, fs_1.mkdirSync)(dir, { recursive: true });
+    }
+    (0, fs_1.writeFileSync)(pathValue, JSON.stringify(state, null, 2) + '\n', 'utf-8');
+}
+function computeEscalationCanaryBucket(cwd) {
+    const seed = (process.env.NEURCODE_ASSET_MAP_ESCALATE_CANARY_SEED || 'neurcode-escalation-v1').trim();
+    const digest = (0, crypto_1.createHash)('sha1')
+        .update(`${(0, path_1.resolve)(cwd)}|${seed}`, 'utf-8')
+        .digest('hex');
+    const bucketRaw = parseInt(digest.slice(0, 8), 16);
+    if (!Number.isFinite(bucketRaw))
+        return 0;
+    return Math.abs(bucketRaw % 100);
+}
+function resolveEscalationPolicy(cwd) {
+    const enabledByEnv = parseBooleanFlag(process.env.NEURCODE_ASSET_MAP_ESCALATE_DEEPEN, true);
+    const canaryPercent = parsePercent(process.env.NEURCODE_ASSET_MAP_ESCALATE_CANARY_PERCENT) ?? 100;
+    const canaryBucket = computeEscalationCanaryBucket(cwd);
+    if (!enabledByEnv) {
+        return {
+            enabled: false,
+            reason: 'env_disabled',
+            canaryPercent,
+            canaryBucket,
+        };
+    }
+    const state = loadEscalationGuardState(cwd);
+    const nowMs = Date.now();
+    const cooldownMs = state.cooldownUntil ? Date.parse(state.cooldownUntil) : NaN;
+    if (Number.isFinite(cooldownMs) && cooldownMs > nowMs) {
+        return {
+            enabled: false,
+            reason: 'kill_switch_cooldown',
+            canaryPercent,
+            canaryBucket,
+            cooldownUntil: state.cooldownUntil,
+        };
+    }
+    if (canaryBucket >= canaryPercent) {
+        return {
+            enabled: false,
+            reason: 'canary_excluded',
+            canaryPercent,
+            canaryBucket,
+        };
+    }
+    return {
+        enabled: true,
+        reason: 'enabled',
+        canaryPercent,
+        canaryBucket,
+    };
+}
+function updateEscalationGuardForBuild(cwd, escalationEnabled, buildStartedAtMs) {
+    if (!escalationEnabled) {
+        return { killSwitchTripped: false };
+    }
+    const maxBuildMs = parsePositiveInt(process.env.NEURCODE_ASSET_MAP_ESCALATE_KILL_MAX_BUILD_MS) ?? 5000;
+    const maxRssKb = parsePositiveInt(process.env.NEURCODE_ASSET_MAP_ESCALATE_KILL_MAX_RSS_KB) ?? (512 * 1024);
+    const minBreaches = parsePositiveInt(process.env.NEURCODE_ASSET_MAP_ESCALATE_KILL_BREACHES) ?? 3;
+    const cooldownMinutes = parsePositiveInt(process.env.NEURCODE_ASSET_MAP_ESCALATE_KILL_COOLDOWN_MINUTES) ?? 60;
+    const elapsedMs = Math.max(0, Date.now() - buildStartedAtMs);
+    const rssKb = Math.max(0, Math.floor(process.memoryUsage().rss / 1024));
+    const breachReasons = [];
+    if (elapsedMs > maxBuildMs) {
+        breachReasons.push(`build_ms>${maxBuildMs}`);
+    }
+    if (rssKb > maxRssKb) {
+        breachReasons.push(`rss_kb>${maxRssKb}`);
+    }
+    const state = loadEscalationGuardState(cwd);
+    const nowIso = new Date().toISOString();
+    let killSwitchTripped = false;
+    let cooldownUntil;
+    if (breachReasons.length > 0) {
+        const nextBreaches = state.consecutiveBreaches + 1;
+        state.consecutiveBreaches = nextBreaches;
+        state.lastBreachAt = nowIso;
+        state.lastReason = breachReasons.join(',');
+        if (nextBreaches >= minBreaches) {
+            killSwitchTripped = true;
+            const cooldownMs = Date.now() + cooldownMinutes * 60 * 1000;
+            cooldownUntil = new Date(cooldownMs).toISOString();
+            state.cooldownUntil = cooldownUntil;
+            state.consecutiveBreaches = 0;
         }
-        catch (error) {
-            // If mapping fails, continue without it (graceful degradation)
-            if (process.env.DEBUG) {
-                console.warn(chalk.yellow(`⚠️  Could not generate asset map: ${error instanceof Error ? error.message : 'Unknown error'}`));
-            }
-            return null;
+    }
+    else {
+        state.consecutiveBreaches = 0;
+        state.lastReason = undefined;
+        state.lastBreachAt = undefined;
+    }
+    state.updatedAt = nowIso;
+    saveEscalationGuardState(cwd, state);
+    return {
+        killSwitchTripped,
+        cooldownUntil,
+    };
+}
+function computeAssetMapIntentFingerprint(intent) {
+    const tokens = (intent || '')
+        .toLowerCase()
+        .match(/[a-z0-9_]{3,}/g);
+    if (!tokens || tokens.length === 0)
+        return null;
+    const filtered = Array.from(new Set(tokens))
+        .filter((token) => token.length >= 3)
+        .slice(0, 24)
+        .sort();
+    if (filtered.length === 0)
+        return null;
+    return (0, crypto_1.createHash)('sha1').update(filtered.join('|'), 'utf-8').digest('hex');
+}
+function decideAssetMapRefresh(map, intentForAdaptiveDeepen) {
+    if (process.env.NEURCODE_ASSET_MAP_FORCE_REFRESH === '1') {
+        return { refresh: true, reason: 'forced_refresh' };
+    }
+    const nowMs = Date.now();
+    const scannedAtMs = Date.parse(map.scannedAt || '');
+    const ageMs = Number.isFinite(scannedAtMs) ? Math.max(0, nowMs - scannedAtMs) : Number.POSITIVE_INFINITY;
+    const maxAgeMinutes = parsePositiveInt(process.env.NEURCODE_ASSET_MAP_MAX_AGE_MINUTES) ?? 360;
+    const minRefreshIntervalMinutes = parsePositiveInt(process.env.NEURCODE_ASSET_MAP_MIN_REFRESH_INTERVAL_MINUTES) ?? 20;
+    const minRefreshIntervalMs = minRefreshIntervalMinutes * 60 * 1000;
+    const staleByAge = ageMs > maxAgeMinutes * 60 * 1000;
+    if (staleByAge) {
+        return { refresh: true, reason: 'stale_age' };
+    }
+    const withinMinRefreshInterval = ageMs < minRefreshIntervalMs;
+    const stats = map.scanStats;
+    const indexedSourceFiles = Math.max(1, stats?.indexedSourceFiles || Object.keys(map.files || {}).length || 1);
+    const shallowIndexedSourceFiles = stats?.shallowIndexedSourceFiles || 0;
+    const shallowRatio = shallowIndexedSourceFiles / indexedSourceFiles;
+    const shallowRatioThreshold = parseRatio(process.env.NEURCODE_ASSET_MAP_SHALLOW_RATIO_REFRESH_THRESHOLD) ?? 0.3;
+    const shallowPressure = shallowIndexedSourceFiles > 0 && shallowRatio >= shallowRatioThreshold;
+    const shallowFailures = (stats?.shallowIndexFailures || 0) > 0;
+    const cappedCoverage = Boolean(stats?.cappedByMaxSourceFiles);
+    const refreshOnCapped = process.env.NEURCODE_ASSET_MAP_REFRESH_ON_CAPPED !== '0';
+    if (shallowFailures && !withinMinRefreshInterval) {
+        return { refresh: true, reason: 'shallow_index_failures' };
+    }
+    if (cappedCoverage && refreshOnCapped && !withinMinRefreshInterval) {
+        return { refresh: true, reason: 'capped_coverage' };
+    }
+    if (shallowPressure && !withinMinRefreshInterval) {
+        const currentIntentFingerprint = computeAssetMapIntentFingerprint(intentForAdaptiveDeepen);
+        const previousIntentFingerprint = map.scanContext?.adaptiveIntentFingerprint || null;
+        if (currentIntentFingerprint && previousIntentFingerprint && currentIntentFingerprint !== previousIntentFingerprint) {
+            return { refresh: true, reason: 'intent_shift_on_shallow_map' };
+        }
+        if ((stats?.adaptiveDeepenedFiles || 0) === 0) {
+            return { refresh: true, reason: 'shallow_pressure_without_deepening' };
+        }
+    }
+    return { refresh: false };
+}
+async function buildAssetMap(cwd, intentForAdaptiveDeepen) {
+    const escalationPolicy = resolveEscalationPolicy(cwd);
+    const startedAtMs = Date.now();
+    let escalationKillSwitchTripped = false;
+    let escalationKillSwitchCooldownUntil;
+    try {
+        const { ProjectScanner } = await Promise.resolve().then(() => __importStar(require('../services/mapper/ProjectScanner')));
+        const scanner = new ProjectScanner(cwd, {
+            maxSourceFiles: parsePositiveInt(process.env.NEURCODE_ASSET_MAP_MAX_FILES) ?? 800,
+            maxFileBytes: parsePositiveInt(process.env.NEURCODE_ASSET_MAP_MAX_BYTES) ?? (512 * 1024),
+            shallowScanBytes: parsePositiveInt(process.env.NEURCODE_ASSET_MAP_SHALLOW_SCAN_BYTES) ?? (256 * 1024),
+            shallowScanWindows: parsePositiveInt(process.env.NEURCODE_ASSET_MAP_SHALLOW_SCAN_WINDOWS) ?? 5,
+            adaptiveDeepenIntent: intentForAdaptiveDeepen || '',
+            maxAdaptiveDeepenFiles: parsePositiveInt(process.env.NEURCODE_ASSET_MAP_ADAPTIVE_DEEPEN_FILES) ?? 3,
+            maxAdaptiveDeepenTotalBytes: parsePositiveInt(process.env.NEURCODE_ASSET_MAP_ADAPTIVE_DEEPEN_TOTAL_BYTES) ?? (2 * 1024 * 1024),
+            enableAdaptiveEscalation: escalationPolicy.enabled,
+            adaptiveEscalationShallowRatioThreshold: parseRatio(process.env.NEURCODE_ASSET_MAP_ESCALATE_SHALLOW_RATIO) ?? 0.35,
+            adaptiveEscalationMinCandidates: parsePositiveInt(process.env.NEURCODE_ASSET_MAP_ESCALATE_MIN_CANDIDATES) ?? 3,
+            maxAdaptiveEscalationFiles: parsePositiveInt(process.env.NEURCODE_ASSET_MAP_ESCALATE_MAX_FILES) ?? 2,
+            maxAdaptiveEscalationTotalBytes: parsePositiveInt(process.env.NEURCODE_ASSET_MAP_ESCALATE_MAX_BYTES) ?? (1024 * 1024),
+        });
+        const map = await scanner.scan();
+        const killSwitchUpdate = updateEscalationGuardForBuild(cwd, escalationPolicy.enabled, startedAtMs);
+        escalationKillSwitchTripped = killSwitchUpdate.killSwitchTripped;
+        escalationKillSwitchCooldownUntil = killSwitchUpdate.cooldownUntil;
+        const { writeFileSync, mkdirSync } = await Promise.resolve().then(() => __importStar(require('fs')));
+        const neurcodeDir = (0, path_1.join)(cwd, '.neurcode');
+        if (!(0, fs_1.existsSync)(neurcodeDir)) {
+            mkdirSync(neurcodeDir, { recursive: true });
+        }
+        const mapPath = (0, path_1.join)(neurcodeDir, 'asset-map.json');
+        writeFileSync(mapPath, JSON.stringify(map, null, 2) + '\n', 'utf-8');
+        return {
+            map,
+            escalationPolicy,
+            escalationKillSwitchTripped,
+            escalationKillSwitchCooldownUntil,
+        };
+    }
+    catch (error) {
+        if (process.env.DEBUG) {
+            console.warn(chalk.yellow(`⚠️  Could not generate asset map: ${error instanceof Error ? error.message : 'Unknown error'}`));
         }
+        return {
+            map: null,
+            escalationPolicy,
+            escalationKillSwitchTripped: false,
+            escalationKillSwitchCooldownUntil: undefined,
+        };
+    }
+}
+async function ensureAssetMap(cwd, intentForAdaptiveDeepen) {
+    if (process.env.NEURCODE_DISABLE_ASSET_MAP === '1') {
+        return {
+            map: null,
+            generated: false,
+            refreshed: false,
+        };
+    }
+    const existingMap = (0, map_1.loadAssetMap)(cwd);
+    if (!existingMap) {
+        const generated = await buildAssetMap(cwd, intentForAdaptiveDeepen);
+        return {
+            map: generated.map,
+            generated: Boolean(generated.map),
+            refreshed: false,
+            refreshReason: generated.map ? 'missing' : undefined,
+            escalationPolicy: generated.escalationPolicy,
+            escalationKillSwitchTripped: generated.escalationKillSwitchTripped,
+            escalationKillSwitchCooldownUntil: generated.escalationKillSwitchCooldownUntil,
+        };
+    }
+    const refreshDecision = decideAssetMapRefresh(existingMap, intentForAdaptiveDeepen);
+    if (!refreshDecision.refresh) {
+        return {
+            map: existingMap,
+            generated: false,
+            refreshed: false,
+        };
+    }
+    const refreshed = await buildAssetMap(cwd, intentForAdaptiveDeepen);
+    if (!refreshed.map) {
+        return {
+            map: existingMap,
+            generated: false,
+            refreshed: false,
+            refreshReason: refreshDecision.reason,
+            refreshFailed: true,
+            escalationPolicy: refreshed.escalationPolicy,
+            escalationKillSwitchTripped: refreshed.escalationKillSwitchTripped,
+            escalationKillSwitchCooldownUntil: refreshed.escalationKillSwitchCooldownUntil,
+        };
     }
-    return map;
+    return {
+        map: refreshed.map,
+        generated: false,
+        refreshed: true,
+        refreshReason: refreshDecision.reason,
+        escalationPolicy: refreshed.escalationPolicy,
+        escalationKillSwitchTripped: refreshed.escalationKillSwitchTripped,
+        escalationKillSwitchCooldownUntil: refreshed.escalationKillSwitchCooldownUntil,
+    };
 }
 function detectIntentMode(intent) {
     const normalized = (0, plan_cache_1.normalizeIntent)(intent);
@@ -282,6 +574,141 @@ function parsePositiveInt(raw) {
         return null;
     return Math.floor(parsed);
 }
+function parseBooleanFlag(raw, fallback) {
+    if (!raw || !raw.trim())
+        return fallback;
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on') {
+        return true;
+    }
+    if (normalized === '0' || normalized === 'false' || normalized === 'no' || normalized === 'off') {
+        return false;
+    }
+    return fallback;
+}
+function parseConfidenceScoreThreshold(raw) {
+    if (!raw)
+        return null;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed))
+        return null;
+    if (parsed < 0 || parsed > 100)
+        return null;
+    return Math.floor(parsed);
+}
+function buildPlanCoverageConfidence(input) {
+    const fileTreeCountSafe = Math.max(1, input.fileTreeCount);
+    const selectionCoverageRatio = input.filesUsedForGeneration / fileTreeCountSafe;
+    const readableSelectionRatio = input.selectedByScout > 0 ? input.readableSelected / input.selectedByScout : 1;
+    const mapStats = input.assetMap?.scanStats;
+    const metrics = {
+        fileTreeCount: input.fileTreeCount,
+        fileTreeCapped: input.fileTreeCapped,
+        selectedByScout: input.selectedByScout,
+        readableSelected: input.readableSelected,
+        filesUsedForGeneration: input.filesUsedForGeneration,
+        selectionCoverageRatio,
+        readableSelectionRatio,
+        usedFallbackSelection: input.usedFallbackSelection,
+        assetMapAvailable: Boolean(input.assetMap),
+        assetMapExports: input.assetMap?.globalExports.length || 0,
+        assetMapCapped: Boolean(mapStats?.cappedByMaxSourceFiles),
+        shallowIndexedSourceFiles: mapStats?.shallowIndexedSourceFiles || 0,
+        shallowIndexFailures: mapStats?.shallowIndexFailures || 0,
+        adaptiveDeepenedFiles: mapStats?.adaptiveDeepenedFiles || 0,
+        adaptiveDeepenSkippedBudget: mapStats?.adaptiveDeepenSkippedBudget || 0,
+        adaptiveEscalationTriggered: Boolean(mapStats?.adaptiveEscalationTriggered),
+        adaptiveEscalationReason: mapStats?.adaptiveEscalationReason || null,
+        adaptiveEscalationDeepenedFiles: mapStats?.adaptiveEscalationDeepenedFiles || 0,
+        adaptiveEscalationSkippedBudget: mapStats?.adaptiveEscalationSkippedBudget || 0,
+    };
+    let score = 100;
+    const reasons = [];
+    if (metrics.fileTreeCapped) {
+        score -= 12;
+        reasons.push('File tree context hit the cap and may miss relevant paths.');
+    }
+    if (metrics.usedFallbackSelection) {
+        score -= 14;
+        reasons.push('Semantic Scout fallback was used instead of ranked file selection.');
+    }
+    if (metrics.selectionCoverageRatio < 0.04) {
+        score -= 22;
+        reasons.push('Very low file coverage for this intent.');
+    }
+    else if (metrics.selectionCoverageRatio < 0.1) {
+        score -= 14;
+        reasons.push('Low file coverage for this intent.');
+    }
+    else if (metrics.selectionCoverageRatio < 0.2) {
+        score -= 8;
+        reasons.push('Moderate file coverage; consider expanding selected files.');
+    }
+    if (metrics.readableSelectionRatio < 0.7) {
+        score -= 10;
+        reasons.push('Many selected files were unreadable and dropped from planning.');
+    }
+    else if (metrics.readableSelectionRatio < 0.9) {
+        score -= 4;
+        reasons.push('Some selected files were unreadable and excluded.');
+    }
+    if (metrics.fileTreeCount >= 30 && metrics.filesUsedForGeneration < 5) {
+        score -= 8;
+        reasons.push('Plan uses a small file set relative to repository size.');
+    }
+    if (!metrics.assetMapAvailable) {
+        score -= 10;
+        reasons.push('Asset map unavailable; toolbox context was not injected.');
+    }
+    else {
+        if (metrics.assetMapCapped) {
+            score -= 8;
+            reasons.push('Asset map indexing was capped before full repository coverage.');
+        }
+        if (metrics.shallowIndexFailures > 0) {
+            score -= 10;
+            reasons.push('Some oversized files could not be indexed, reducing context completeness.');
+        }
+        if (metrics.shallowIndexedSourceFiles > 0 && metrics.adaptiveDeepenedFiles === 0) {
+            score -= 4;
+            reasons.push('Oversized files remained shallow-indexed with no adaptive deepening.');
+        }
+        if (metrics.adaptiveDeepenSkippedBudget > 0) {
+            score -= 4;
+            reasons.push('Adaptive deepening skipped candidates due to budget constraints.');
+        }
+        if (metrics.adaptiveEscalationTriggered && metrics.adaptiveEscalationDeepenedFiles === 0) {
+            score -= 3;
+            reasons.push('Escalation pass triggered but could not fully parse additional oversized files.');
+        }
+        if (metrics.adaptiveEscalationSkippedBudget > 0) {
+            score -= 2;
+            reasons.push('Escalation deepening skipped candidates due to strict byte/file limits.');
+        }
+    }
+    score = Math.max(0, Math.min(100, score));
+    const level = score >= 80 ? 'high' : score >= 60 ? 'medium' : 'low';
+    const status = score >= 70 ? 'sufficient' : score >= 50 ? 'warning' : 'insufficient';
+    if (reasons.length === 0) {
+        reasons.push('Context coverage is strong for this plan run.');
+    }
+    return {
+        score,
+        level,
+        status,
+        reasons,
+        metrics,
+    };
+}
+function displayPlanCoverageConfidence(coverage) {
+    const scoreColor = coverage.level === 'high' ? chalk.green : coverage.level === 'medium' ? chalk.yellow : chalk.red;
+    console.log(chalk.bold.white('Context Confidence:'), scoreColor(`${coverage.score}/100 (${coverage.level.toUpperCase()})`));
+    if (coverage.level !== 'high') {
+        for (const reason of coverage.reasons.slice(0, 3)) {
+            console.log(chalk.dim(`  • ${reason}`));
+        }
+    }
+}
 function parseSnapshotMode(raw) {
     if (!raw)
         return null;
@@ -453,6 +880,62 @@ function emitCachedPlanHit(input) {
     return persistedPlan;
 }
 async function planCommand(intent, options) {
+    const planStartedAtMs = Date.now();
+    let planRootForSlo = (0, path_1.resolve)(process.cwd());
+    try {
+        planRootForSlo = (0, project_root_1.resolveNeurcodeProjectRoot)(process.cwd());
+    }
+    catch {
+        // Fallback to current working directory when root resolution fails.
+    }
+    let planIntentModeForSlo = 'implementation';
+    let planCachedForSlo = false;
+    let planSuccessForSlo = false;
+    let planEscalationPolicyForSlo = null;
+    let planEscalationKillSwitchTrippedForSlo = false;
+    let planEscalationKillSwitchCooldownUntilForSlo = null;
+    let planSloEventFlushed = false;
+    const flushPlanSloEvent = (exitCode) => {
+        if (planSloEventFlushed) {
+            return;
+        }
+        planSloEventFlushed = true;
+        const coverageMetrics = coverageConfidence?.metrics;
+        const rssKb = Math.max(0, Math.floor(process.memoryUsage().rss / 1024));
+        try {
+            (0, plan_slo_1.appendPlanSloEvent)(planRootForSlo, {
+                timestamp: new Date().toISOString(),
+                intentMode: planIntentModeForSlo,
+                cached: planCachedForSlo,
+                success: planSuccessForSlo && exitCode === 0,
+                exitCode,
+                elapsedMs: Math.max(0, Date.now() - planStartedAtMs),
+                rssKb,
+                coverageScore: coverageConfidence?.score ?? null,
+                coverageLevel: coverageConfidence?.level ?? null,
+                coverageStatus: coverageConfidence?.status ?? null,
+                adaptiveEscalationTriggered: coverageMetrics?.adaptiveEscalationTriggered === true,
+                adaptiveEscalationReason: coverageMetrics?.adaptiveEscalationReason || null,
+                adaptiveEscalationDeepenedFiles: coverageMetrics?.adaptiveEscalationDeepenedFiles || 0,
+                escalationPolicyEnabled: planEscalationPolicyForSlo?.enabled ?? null,
+                escalationPolicyReason: planEscalationPolicyForSlo?.reason ?? null,
+                escalationCanaryPercent: planEscalationPolicyForSlo?.canaryPercent ?? null,
+                escalationCanaryBucket: planEscalationPolicyForSlo?.canaryBucket ?? null,
+                escalationKillSwitchTripped: planEscalationKillSwitchTrippedForSlo,
+                escalationKillSwitchCooldownUntil: planEscalationKillSwitchCooldownUntilForSlo || planEscalationPolicyForSlo?.cooldownUntil || null,
+                fileTreeCount: coverageMetrics?.fileTreeCount ?? null,
+                filesUsedForGeneration: coverageMetrics?.filesUsedForGeneration ?? null,
+            });
+        }
+        catch {
+            // SLO logging is best-effort and should never block plan command.
+        }
+    };
+    const onPlanProcessExit = (code) => {
+        flushPlanSloEvent(code);
+    };
+    process.once('exit', onPlanProcessExit);
+    let coverageConfidence;
     try {
         if (!intent || !intent.trim()) {
             if (options.json) {
@@ -505,12 +988,38 @@ async function planCommand(intent, options) {
         // If the same user/org/project runs the same intent against the same repo snapshot,
         // return the cached plan immediately (no network, no file scanning).
         const cwd = (0, project_root_1.resolveNeurcodeProjectRoot)(process.cwd());
+        const homeDir = (0, path_1.resolve)(process.env.HOME || process.env.USERPROFILE || '');
+        if (homeDir &&
+            cwd === homeDir &&
+            process.cwd() !== homeDir &&
+            process.env.NEURCODE_ALLOW_HOME_ROOT !== '1') {
+            const message = [
+                'Resolved project root points to your home directory, which can mix unrelated repositories.',
+                'Run `neurcode init` from this repository root to isolate Neurcode state.',
+                'Set NEURCODE_ALLOW_HOME_ROOT=1 only if you intentionally want home-directory scope.',
+            ].join(' ');
+            if (options.json) {
+                emitPlanJson({
+                    success: false,
+                    cached: false,
+                    mode: 'implementation',
+                    planId: null,
+                    sessionId: null,
+                    projectId: options.projectId || null,
+                    timestamp: new Date().toISOString(),
+                    message,
+                });
+            }
+            console.error(chalk.red(`❌ ${message}`));
+            process.exit(1);
+        }
         const orgId = (0, state_1.getOrgId)();
         const stateProjectId = (0, state_1.getProjectId)();
         const finalProjectIdEarly = options.projectId || stateProjectId || config.projectId;
         const shouldUseCache = options.cache !== false && process.env.NEURCODE_PLAN_NO_CACHE !== '1';
         const normalizedIntent = (0, plan_cache_1.normalizeIntent)(intent);
         const intentMode = detectIntentMode(intent);
+        planIntentModeForSlo = intentMode;
         const isReadOnlyAnalysis = intentMode === 'analysis';
         const nearIntentSimilarityFloor = isReadOnlyAnalysis ? 0.66 : undefined;
         const policyVersionHash = (0, plan_cache_1.computePolicyVersionHash)(cwd);
@@ -557,8 +1066,12 @@ async function planCommand(intent, options) {
                     jsonMode: options.json === true,
                     intentMode,
                 });
+                planCachedForSlo = true;
+                planSuccessForSlo = persisted;
                 if (!persisted)
                     process.exit(2);
+                flushPlanSloEvent(0);
+                process.removeListener('exit', onPlanProcessExit);
                 return;
             }
             const near = (0, plan_cache_1.findNearCachedPlan)(cwd, {
@@ -585,8 +1098,12 @@ async function planCommand(intent, options) {
                     jsonMode: options.json === true,
                     intentMode,
                 });
+                planCachedForSlo = true;
+                planSuccessForSlo = persisted;
                 if (!persisted)
                     process.exit(2);
+                flushPlanSloEvent(0);
+                process.removeListener('exit', onPlanProcessExit);
                 return;
             }
             const miss = (0, plan_cache_1.diagnosePlanCacheMiss)(cwd, {
@@ -719,12 +1236,16 @@ async function planCommand(intent, options) {
         };
         // Step B: Scan file tree (paths only, no content)
         console.log(chalk.dim(`📂 Scanning file tree in ${cwd}...`));
-        const fileTree = scanFiles(cwd, cwd, 200);
+        const planFileTreeMaxFiles = Math.min(parsePositiveInt(process.env.NEURCODE_PLAN_FILE_TREE_MAX_FILES) ?? 200, 5000);
+        const fileTree = scanFiles(cwd, cwd, planFileTreeMaxFiles);
         if (fileTree.length === 0) {
             console.warn(chalk.yellow('⚠️  No files found in current directory'));
             process.exit(1);
         }
         console.log(chalk.dim(`Found ${fileTree.length} files in project`));
+        if (fileTree.length >= planFileTreeMaxFiles) {
+            console.log(chalk.dim(`📎 File tree context capped at ${planFileTreeMaxFiles} files. Set NEURCODE_PLAN_FILE_TREE_MAX_FILES to increase.`));
+        }
         // Load Neurcode static context (repo + local + org/project) early so it can:
         // - influence plan generation
         // - participate in the cache key (avoid stale cached plans after context edits)
@@ -775,8 +1296,12 @@ async function planCommand(intent, options) {
                     jsonMode: options.json === true,
                     intentMode,
                 });
+                planCachedForSlo = true;
+                planSuccessForSlo = persisted;
                 if (!persisted)
                     process.exit(2);
+                flushPlanSloEvent(0);
+                process.removeListener('exit', onPlanProcessExit);
                 return;
             }
             const near = (0, plan_cache_1.findNearCachedPlan)(cwd, {
@@ -803,8 +1328,12 @@ async function planCommand(intent, options) {
                     jsonMode: options.json === true,
                     intentMode,
                 });
+                planCachedForSlo = true;
+                planSuccessForSlo = persisted;
                 if (!persisted)
                     process.exit(2);
+                flushPlanSloEvent(0);
+                process.removeListener('exit', onPlanProcessExit);
                 return;
             }
             const miss = (0, plan_cache_1.diagnosePlanCacheMiss)(cwd, {
@@ -850,9 +1379,75 @@ async function planCommand(intent, options) {
             }
         }
         // Step 3: Load or create asset map for context injection (toolbox summary)
+        let assetMapForCoverage = null;
         try {
-            const map = await ensureAssetMap(cwd);
+            const assetMapResolution = await ensureAssetMap(cwd, enrichedIntent);
+            const map = assetMapResolution.map;
+            assetMapForCoverage = map;
+            if (assetMapResolution.escalationPolicy) {
+                planEscalationPolicyForSlo = assetMapResolution.escalationPolicy;
+            }
+            if (assetMapResolution.escalationKillSwitchTripped) {
+                planEscalationKillSwitchTrippedForSlo = true;
+            }
+            if (assetMapResolution.escalationKillSwitchCooldownUntil) {
+                planEscalationKillSwitchCooldownUntilForSlo = assetMapResolution.escalationKillSwitchCooldownUntil;
+            }
+            if (assetMapResolution.generated) {
+                console.log(chalk.dim('♻️  Generated fresh asset map for this repository.'));
+            }
+            else if (assetMapResolution.refreshed) {
+                console.log(chalk.dim(`♻️  Refreshed asset map (${assetMapResolution.refreshReason || 'policy_trigger'}).`));
+            }
+            else if (assetMapResolution.refreshFailed) {
+                console.log(chalk.yellow(`⚠️  Asset map refresh failed (${assetMapResolution.refreshReason || 'unknown'}), using previous cached map.`));
+            }
+            if (assetMapResolution.escalationPolicy && (assetMapResolution.generated || assetMapResolution.refreshed)) {
+                const escalationPolicy = assetMapResolution.escalationPolicy;
+                if (escalationPolicy.enabled) {
+                    console.log(chalk.dim(`🧪 Escalation policy: enabled (canary=${escalationPolicy.canaryBucket}/${escalationPolicy.canaryPercent}).`));
+                }
+                else {
+                    let detail = `reason=${escalationPolicy.reason}`;
+                    if (escalationPolicy.reason === 'canary_excluded') {
+                        detail += `, canary=${escalationPolicy.canaryBucket}/${escalationPolicy.canaryPercent}`;
+                    }
+                    if (escalationPolicy.reason === 'kill_switch_cooldown' && escalationPolicy.cooldownUntil) {
+                        detail += `, cooldownUntil=${escalationPolicy.cooldownUntil}`;
+                    }
+                    console.log(chalk.yellow(`⚠️  Adaptive escalation disabled (${detail}).`));
+                }
+            }
+            if (assetMapResolution.escalationKillSwitchTripped) {
+                console.log(chalk.yellow(`⚠️  Escalation kill switch tripped; cooldown active until ${assetMapResolution.escalationKillSwitchCooldownUntil || 'later'}.`));
+            }
             if (map && map.globalExports.length > 0) {
+                if (map.scanStats?.cappedByMaxSourceFiles) {
+                    console.log(chalk.yellow(`⚠️  Asset map coverage capped at ${map.scanStats.indexedSourceFiles} files (limit ${map.scanStats.maxSourceFiles}).`));
+                    console.log(chalk.dim('   Increase NEURCODE_ASSET_MAP_MAX_FILES for broader coverage.'));
+                }
+                if ((map.scanStats?.skippedBySize || 0) > 0) {
+                    console.log(chalk.dim(`📦 Asset map shallow-indexed ${map.scanStats?.skippedBySize} oversized source files (> ${map.scanStats?.maxFileBytes} bytes).`));
+                }
+                if ((map.scanStats?.shallowIndexFailures || 0) > 0) {
+                    console.log(chalk.yellow(`⚠️  Asset map could not shallow-index ${map.scanStats?.shallowIndexFailures} oversized file(s).`));
+                }
+                if ((map.scanStats?.adaptiveDeepenedFiles || 0) > 0) {
+                    console.log(chalk.dim(`🧠 Adaptive deepened ${map.scanStats?.adaptiveDeepenedFiles} oversized file(s) for this intent.`));
+                }
+                if ((map.scanStats?.adaptiveDeepenSkippedBudget || 0) > 0) {
+                    console.log(chalk.dim(`📎 Adaptive deepening skipped ${map.scanStats?.adaptiveDeepenSkippedBudget} candidate(s) due to budget.`));
+                }
+                if (map.scanStats?.adaptiveEscalationTriggered) {
+                    const escalationReason = map.scanStats?.adaptiveEscalationReason || 'policy_trigger';
+                    console.log(chalk.dim(`🎯 Adaptive escalation pass triggered (${escalationReason}).`));
+                }
+                if ((map.scanStats?.adaptiveEscalationDeepenedFiles || 0) > 0) {
+                    console.log(chalk.dim(`🚀 Escalation deepened ${map.scanStats?.adaptiveEscalationDeepenedFiles} additional oversized file(s).`));
+                }
+                if ((map.scanStats?.adaptiveEscalationSkippedBudget || 0) > 0) {
+                    console.log(chalk.dim(`📎 Escalation skipped ${map.scanStats?.adaptiveEscalationSkippedBudget} candidate(s) due to escalation budget limits.`));
+                }
                 // Pass intent to generateToolboxSummary for relevance filtering
                 const toolboxSummary = (0, toolbox_service_1.generateToolboxSummary)(map, enrichedIntent);
                 if (toolboxSummary) {
@@ -998,12 +1593,14 @@ async function planCommand(intent, options) {
         // Step C: Pass 1 - The Semantic Scout (select relevant files)
         console.log(chalk.dim('🔍 Semantic Scout: Selecting relevant files...'));
         let selectedFiles = [];
+        let usedFallbackSelection = false;
         try {
             selectedFiles = await client.selectFiles(enhancedIntent, fileTree, projectSummary);
             // Handle empty selection (fallback to top 10 files)
             if (selectedFiles.length === 0) {
                 console.log(chalk.yellow('⚠️  No files selected by Semantic Scout, using fallback (top 10 files)'));
                 selectedFiles = fileTree.slice(0, 10);
+                usedFallbackSelection = true;
             }
             console.log(chalk.green(`✅ Semantic Scout selected ${selectedFiles.length} file(s) from ${fileTree.length} total`));
             if (process.env.DEBUG) {
@@ -1015,6 +1612,7 @@ async function planCommand(intent, options) {
             console.warn(chalk.yellow(`⚠️  File selection failed: ${error instanceof Error ? error.message : 'Unknown error'}`));
             console.log(chalk.yellow('   Using fallback: top 10 files from tree'));
             selectedFiles = fileTree.slice(0, 10);
+            usedFallbackSelection = true;
         }
         // Step D: Content Load - Verify selected files exist and are readable
         const validFiles = [];
@@ -1047,6 +1645,38 @@ async function planCommand(intent, options) {
             filesToUse = filesToUse.slice(0, 8);
             console.log(chalk.dim(`🔎 Analysis mode: narrowed to ${filesToUse.length} top file(s)`));
         }
+        coverageConfidence = buildPlanCoverageConfidence({
+            fileTreeCount: fileTree.length,
+            fileTreeCapped: fileTree.length >= planFileTreeMaxFiles,
+            selectedByScout: selectedFiles.length,
+            readableSelected: validFiles.length,
+            filesUsedForGeneration: filesToUse.length,
+            usedFallbackSelection,
+            assetMap: assetMapForCoverage,
+        });
+        displayPlanCoverageConfidence(coverageConfidence);
+        const minConfidenceScore = parseConfidenceScoreThreshold(process.env.NEURCODE_PLAN_MIN_CONFIDENCE_SCORE);
+        if (minConfidenceScore !== null && coverageConfidence.score < minConfidenceScore) {
+            const message = [
+                `Context confidence score ${coverageConfidence.score}/100 is below required threshold ${minConfidenceScore}.`,
+                'Increase file/asset-map coverage or relax NEURCODE_PLAN_MIN_CONFIDENCE_SCORE.',
+            ].join(' ');
+            if (options.json) {
+                emitPlanJson({
+                    success: false,
+                    cached: false,
+                    mode: intentMode,
+                    planId: null,
+                    sessionId: null,
+                    projectId: finalProjectIdForGuard || null,
+                    timestamp: new Date().toISOString(),
+                    coverage: coverageConfidence,
+                    message,
+                });
+            }
+            console.error(chalk.red(`❌ ${message}`));
+            process.exit(1);
+        }
         // Step E: Pass 2 - The Architect (generate plan with selected files)
         console.log(chalk.dim('🤖 Generating plan with selected files...\n'));
         const response = await client.generatePlan(enhancedIntent, filesToUse, finalProjectId, ticketMetadata, projectSummary);
@@ -1547,6 +2177,7 @@ async function planCommand(intent, options) {
                     timestamp: response.timestamp,
                     telemetry: response.telemetry,
                     snapshot: snapshotSummary,
+                    coverage: coverageConfidence,
                     message: missingPlanMessage,
                     plan: response.plan,
                 });
@@ -1595,10 +2226,14 @@ async function planCommand(intent, options) {
                 timestamp: response.timestamp,
                 telemetry: response.telemetry,
                 snapshot: snapshotSummary,
+                coverage: coverageConfidence,
                 message: 'Plan generated and persisted',
                 plan: response.plan,
             });
         }
+        planSuccessForSlo = true;
+        flushPlanSloEvent(0);
+        process.removeListener('exit', onPlanProcessExit);
     }
     catch (error) {
         if (options.json) {
@@ -1610,6 +2245,7 @@ async function planCommand(intent, options) {
                 sessionId: null,
                 projectId: options.projectId || null,
                 timestamp: new Date().toISOString(),
+                coverage: coverageConfidence,
                 message: error instanceof Error ? error.message : 'Unknown error',
             });
         }