aspectcode 0.4.0 → 1.0.0

package/dist/pipeline.js

@@ -1,15 +1,10 @@
 "use strict";
 /**
- * aspectcode pipeline — the single pipeline that does everything.
+ * aspectcode pipeline — analyze, generate, watch, evaluate.
  *
- * 1. Discover files → tree-sitter analysis
- * 2. Build KB in memory (architecture + map + context)
- * 3. Scan & read other AI tool instruction files as context
- * 4. Write static-template AGENTS.md for immediate feedback
- * 5. If API key present → LLM generates AGENTS.md from KB → overwrite
- *    If no API key → keep static AGENTS.md + warn
- * 6. If --kb flag → also write kb.md
- * 7. If not --once → watch for changes and repeat
+ * v2: After generating AGENTS.md, watch mode evaluates individual file
+ * changes in real time. Full probe-and-refine runs on first startup
+ * or when the user presses 'r'.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -45,7 +40,11 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveOwnership = resolveOwnership;
+exports.isIgnoredPath = isIgnoredPath;
+exports.isSupportedSourceFile = isSupportedSourceFile;
+exports.createFileWatcher = createFileWatcher;
+exports.resolveRunMode = resolveRunMode;
+exports.resolvePlatforms = resolvePlatforms;
 exports.runPipeline = runPipeline;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -59,17 +58,31 @@ const kbBuilder_1 = require("./kbBuilder");
 const toolIngestion_1 = require("./toolIngestion");
 const writer_1 = require("./writer");
 const optimize_1 = require("./optimize");
-const complaintProcessor_1 = require("./complaintProcessor");
 const prompts_1 = require("./ui/prompts");
 const store_1 = require("./ui/store");
 const summary_1 = require("./summary");
 const diffSummary_1 = require("./diffSummary");
-// ── Watch constants ──────────────────────────────────────────
-const DEBOUNCE_MS = 2000;
+const runtimeState_1 = require("./runtimeState");
+const preferences_1 = require("./preferences");
+const changeEvaluator_1 = require("./changeEvaluator");
+const dreamCycle_1 = require("./dreamCycle");
+const scopedRules_1 = require("./scopedRules");
+const autoResolve_1 = require("./autoResolve");
+const agentsMdRenderer_1 = require("./agentsMdRenderer");
+const usageTracker_1 = require("./usageTracker");
+const auth_1 = require("./auth");
+const optimizer_1 = require("@aspectcode/optimizer");
+// ── Constants ────────────────────────────────────────────────
+const EVAL_DEBOUNCE_MS = 500;
+const CO_CHANGE_SETTLE_MS = 5000;
+const AUTO_PROBE_IDLE_MS = 5 * 60 * 1000;
+const AUTO_PROBE_MIN_CHANGES = 20;
+const AUTO_PROBE_COOLDOWN_MS = 12 * 60 * 60 * 1000; // 12 hours
 const IGNORED_SEGMENTS = [
     '/node_modules/', '/.git/', '/dist/', '/build/', '/target/',
     '/coverage/', '/.next/', '/__pycache__/', '/.venv/', '/venv/',
     '/.pytest_cache/', '/.mypy_cache/', '/.tox/', '/htmlcov/',
+    '/.aspectcode/',
 ];
 function isIgnoredPath(filePath) {
     const normalized = filePath.replace(/\\/g, '/').toLowerCase();
@@ -79,25 +92,236 @@ function isSupportedSourceFile(filePath) {
     const ext = path.extname(filePath).toLowerCase();
     return core_1.SUPPORTED_EXTENSIONS.includes(ext);
 }
-// ── Single pipeline run ──────────────────────────────────────
-async function runOnce(ctx, ownership) {
+// ── Managed files for memory map ─────────────────────────────
+function fileMtime(filePath) {
+    try {
+        return fs.statSync(filePath).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+}
+function buildManagedFiles(root, preferenceCount, platforms = []) {
+    const files = [];
+    // ── Workspace-scope: AGENTS.md ──────────────────────────────
+    const agentsAbs = path.join(root, 'AGENTS.md');
+    if (fs.existsSync(agentsAbs)) {
+        files.push({ path: 'AGENTS.md', annotation: '', updatedAt: fileMtime(agentsAbs), category: 'agents', scope: 'workspace', owner: 'aspectcode' });
+    }
+    // ── Workspace-scope: platform instruction files ─────────────
+    if (platforms.includes('claude')) {
+        const claudeMdAbs = path.join(root, 'CLAUDE.md');
+        if (fs.existsSync(claudeMdAbs)) {
+            files.push({ path: 'CLAUDE.md', annotation: '○ user', updatedAt: fileMtime(claudeMdAbs), category: 'workspace-config', scope: 'workspace', owner: 'user' });
+        }
+    }
+    if (platforms.includes('cursor')) {
+        const cursorrules = path.join(root, '.cursorrules');
+        if (fs.existsSync(cursorrules)) {
+            files.push({ path: '.cursorrules', annotation: '○ user', updatedAt: fileMtime(cursorrules), category: 'workspace-config', scope: 'workspace', owner: 'user' });
+        }
+    }
+    // ── Workspace-scope: scoped rules from manifest ─────────────
+    const manifestPath = path.join(root, '.aspectcode', 'scoped-rules.json');
+    const manifestRulePaths = new Set();
+    let manifestNeedsCleanup = false;
+    if (fs.existsSync(manifestPath)) {
+        try {
+            const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+            const validRules = [];
+            for (const entry of manifest.rules ?? []) {
+                if (manifestRulePaths.has(entry.path))
+                    continue;
+                const absPath = path.join(root, entry.path);
+                // Skip files that no longer exist on disk
+                if (!fs.existsSync(absPath)) {
+                    manifestNeedsCleanup = true;
+                    continue;
+                }
+                manifestRulePaths.add(entry.path);
+                validRules.push(entry);
+                const cat = entry.path.startsWith('.claude/') ? 'claude-rule'
+                    : entry.path.startsWith('.cursor/') ? 'cursor-rule'
+                        : 'agents';
+                const ts = entry.updatedAt ? new Date(entry.updatedAt).getTime() : fileMtime(absPath);
+                files.push({ path: entry.path, annotation: '● active', updatedAt: ts, category: cat, scope: 'workspace', owner: 'aspectcode' });
+            }
+            // Clean stale entries from manifest so they don't persist across restarts
+            if (manifestNeedsCleanup) {
+                try {
+                    fs.writeFileSync(manifestPath, JSON.stringify({ version: 1, rules: validRules }, null, 2) + '\n');
+                }
+                catch { /* ignore write errors */ }
+            }
+        }
+        catch { /* malformed manifest */ }
+    }
+    // ── Workspace-scope: user-created scoped rules ──────────────
+    const platformRuleDirs = [];
+    if (platforms.includes('claude'))
+        platformRuleDirs.push({ dir: '.claude/rules', ext: '.md' });
+    if (platforms.includes('cursor'))
+        platformRuleDirs.push({ dir: '.cursor/rules', ext: '.mdc' });
+    for (const { dir: rulesDir, ext } of platformRuleDirs) {
+        const absDir = path.join(root, rulesDir);
+        try {
+            if (fs.existsSync(absDir)) {
+                for (const entry of fs.readdirSync(absDir)) {
+                    if (!entry.endsWith(ext))
+                        continue;
+                    if (entry.startsWith('ac-'))
+                        continue; // aspectcode-managed
+                    const relPath = `${rulesDir}/${entry}`;
+                    if (manifestRulePaths.has(relPath))
+                        continue; // already tracked
+                    files.push({ path: relPath, annotation: '○ user', updatedAt: fileMtime(path.join(absDir, entry)), category: 'user-rule', scope: 'workspace', owner: 'user' });
+                }
+            }
+        }
+        catch { /* unreadable dir */ }
+    }
+    // ── Workspace-scope: settings ───────────────────────────────
+    if (platforms.includes('claude')) {
+        const settingsLocal = path.join(root, '.claude', 'settings.local.json');
+        if (fs.existsSync(settingsLocal)) {
+            files.push({ path: '.claude/settings.local.json', annotation: '○ user', updatedAt: fileMtime(settingsLocal), category: 'workspace-config', scope: 'workspace', owner: 'user' });
+        }
+    }
+    // ── Workspace-scope: .aspectcode files ──────────────────────
+    if (preferenceCount > 0) {
+        files.push({ path: '☁  preferences', annotation: `${preferenceCount} learned`, updatedAt: 0, category: 'cloud', scope: 'workspace', owner: 'aspectcode' });
+    }
+    const dreamStatePath = path.join(root, '.aspectcode', 'dream-state.json');
+    if (fs.existsSync(dreamStatePath)) {
+        try {
+            const ds = JSON.parse(fs.readFileSync(dreamStatePath, 'utf-8'));
+            const lastDream = ds.lastDreamAt ? new Date(ds.lastDreamAt).getTime() : 0;
+            files.push({ path: '.aspectcode/dream-state.json', annotation: '', updatedAt: lastDream, category: 'aspectcode', scope: 'workspace', owner: 'aspectcode' });
+        }
+        catch {
+            files.push({ path: '.aspectcode/dream-state.json', annotation: '', updatedAt: 0, category: 'aspectcode', scope: 'workspace', owner: 'aspectcode' });
+        }
+    }
+    // ── Device-scope: ~/.claude/ memory (Claude Code only) ──────
+    if (platforms.includes('claude')) {
+        const home = require('os').homedir();
+        // Device-root CLAUDE.md
+        const deviceClaudeMd = path.join(home, '.claude', 'CLAUDE.md');
+        if (fs.existsSync(deviceClaudeMd)) {
+            files.push({ path: '~/.claude/CLAUDE.md', annotation: '○ device', updatedAt: fileMtime(deviceClaudeMd), category: 'device', scope: 'device', owner: 'device' });
+        }
+        // Project-level CLAUDE.md (~/.claude/projects/<hash>/CLAUDE.md)
+        const projectClaudeMd = findDeviceProjectClaudeMd(home, root);
+        if (projectClaudeMd) {
+            files.push({ path: '~/.claude/projects/.../CLAUDE.md', annotation: '○ device', updatedAt: fileMtime(projectClaudeMd), category: 'device', scope: 'device', owner: 'device' });
+        }
+    }
+    return files;
+}
+/** Find the project-level CLAUDE.md in ~/.claude/projects/<hash>/ for the given workspace. */
+function findDeviceProjectClaudeMd(home, root) {
+    const projectsBase = path.join(home, '.claude', 'projects');
+    if (!fs.existsSync(projectsBase))
+        return undefined;
+    const normalised = root.replace(/\\/g, '/');
+    const crypto = require('crypto');
+    // Try common hash strategies
+    const candidates = [
+        crypto.createHash('md5').update(normalised).digest('hex'),
+        crypto.createHash('sha256').update(normalised).digest('hex').slice(0, 32),
+        Buffer.from(normalised).toString('base64url'),
+        normalised.replace(/\//g, '-').replace(/^-/, ''),
+    ];
+    for (const candidate of candidates) {
+        const claudeMd = path.join(projectsBase, candidate, 'CLAUDE.md');
+        if (fs.existsSync(claudeMd))
+            return claudeMd;
+    }
+    // Fallback: scan project directories for CLAUDE.md
+    try {
+        for (const dir of fs.readdirSync(projectsBase)) {
+            const claudeMd = path.join(projectsBase, dir, 'CLAUDE.md');
+            if (fs.existsSync(claudeMd)) {
+                // Verify this directory is for our workspace by checking a jsonl file
+                const fullDir = path.join(projectsBase, dir);
+                const jsonls = fs.readdirSync(fullDir).filter((f) => f.endsWith('.jsonl'));
+                if (jsonls.length > 0) {
+                    try {
+                        const fd = fs.openSync(path.join(fullDir, jsonls[0]), 'r');
+                        const buf = Buffer.alloc(2048);
+                        const bytesRead = fs.readSync(fd, buf, 0, 2048, 0);
+                        fs.closeSync(fd);
+                        const sample = buf.slice(0, bytesRead).toString('utf-8');
+                        if (sample.includes(normalised) || sample.includes(root.replace(/\\/g, '\\\\'))) {
+                            return claudeMd;
+                        }
+                    }
+                    catch { /* skip */ }
+                }
+            }
+        }
+    }
+    catch { /* scan failed */ }
+    return undefined;
+}
+// ── File watcher ─────────────────────────────────────────────
+function createFileWatcher(root, onEvent) {
+    return fs.watch(root, { recursive: true }, (event, filename) => {
+        if (!filename)
+            return;
+        const posixPath = filename.replace(/\\/g, '/');
+        const abs = path.resolve(root, filename);
+        if (!isSupportedSourceFile(abs) || isIgnoredPath(abs))
+            return;
+        const type = event === 'rename'
+            ? (fs.existsSync(abs) ? 'add' : 'unlink')
+            : 'change';
+        onEvent(type, posixPath);
+    });
+}
+/**
+ * @param probeAndRefine  Run probe-based evaluation after LLM generation.
+ *                        Only on first run or when user presses 'r'.
+ */
+async function runOnce(ctx, ownership, probeAndRefine = false, preferences, activePlatforms = ['claude'], userSettings) {
     const { root, flags, log } = ctx;
     const config = (0, config_1.loadConfig)(root);
     const startMs = Date.now();
     store_1.store.resetRun();
     store_1.store.setRunStartMs(startMs);
-    store_1.store.addSetupNote(config ? 'config loaded' : 'no config');
-    // ── First-run detection ───────────────────────────────────
+    if (config)
+        store_1.store.addSetupNote('using config file');
+    // Clean stale manifest entries (files deleted by user)
+    const deletedSlugs = new Set();
+    const manifestPath = path.join(root, '.aspectcode', 'scoped-rules.json');
+    if (fs.existsSync(manifestPath)) {
+        try {
+            const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+            const validRules = [];
+            for (const entry of manifest.rules ?? []) {
+                if (fs.existsSync(path.join(root, entry.path))) {
+                    validRules.push(entry);
+                }
+                else {
+                    deletedSlugs.add(entry.slug);
+                }
+            }
+            if (deletedSlugs.size > 0) {
+                fs.writeFileSync(manifestPath, JSON.stringify({ version: 1, rules: validRules }, null, 2) + '\n');
+                log.debug(`Cleaned ${deletedSlugs.size} stale manifest entries`);
+            }
+        }
+        catch { /* ignore */ }
+    }
     const agentsPath = path.join(root, 'AGENTS.md');
-    const configPath = path.join(root, 'aspectcode.json');
-    if (!fs.existsSync(agentsPath) && !fs.existsSync(configPath)) {
+    if (!fs.existsSync(agentsPath)) {
         store_1.store.setFirstRun(true);
     }
     // ── 1. Discover & read files ──────────────────────────────
     store_1.store.setPhase('discovering');
     const workspace = await (0, workspace_1.loadWorkspaceFiles)(root, config, log, { quiet: flags.quiet, spin: ctx.spin });
     if (workspace.discoveredPaths.length === 0) {
-        log.warn('No source files found. Check your workspace or exclude patterns.');
+        log.warn('No source files found.');
         return { code: cli_1.ExitCode.ERROR, kbContent: '' };
     }
     // ── 2. Analyze ────────────────────────────────────────────
@@ -105,210 +329,963 @@ async function runOnce(ctx, ownership) {
     const model = await (0, core_1.analyzeRepoWithDependencies)(root, workspace.relativeFiles, workspace.absoluteFiles, workspace.host);
     spinAnalyze.stop(`Analyzed ${model.files.length} files, ${model.graph.edges.length} edges`);
     store_1.store.setStats(model.files.length, model.graph.edges.length);
-    // ── 3. Build KB content in memory ─────────────────────────
+    // ── 3. Build KB ───────────────────────────────────────────
     const spinKb = ctx.spin('Building knowledge base…', 'building-kb');
     const kbContent = (0, kbBuilder_1.buildKbContent)(model, root, workspace.relativeFiles);
     spinKb.stop('Knowledge base built');
-    // ── 4. Read other AI tool instruction files ───────────────
+    // ── 4. Read tool instruction files ────────────────────────
     const host = (0, emitters_1.createNodeEmitterHost)();
     const toolInstructions = await (0, toolIngestion_1.readToolInstructions)(host, root);
     if (toolInstructions.size > 0) {
-        const toolNames = [...toolInstructions.keys()].join(', ');
-        store_1.store.addSetupNote(`context: ${toolNames}`);
-        log.debug(`Read ${toolInstructions.size} AI tool instruction file(s) as context`);
-    }
-    // ── 5. Write static-template AGENTS.md for immediate feedback ─
-    //    Written to disk right away so the user sees output early,
-    //    even before the LLM generation finishes.
-    const baseContent = (0, emitters_1.generateCanonicalContentForMode)('safe', kbContent.length > 0);
-    if (!flags.dryRun) {
-        await (0, writer_1.writeAgentsMd)(host, root, baseContent, ownership);
-        store_1.store.addOutput('AGENTS.md written (base)');
-        log.debug('Base AGENTS.md written from static analysis');
-    }
-    // ── 6. LLM generation or static fallback ───────────────
-    store_1.store.setPhase('optimizing');
-    const optimizeResult = await (0, optimize_1.tryOptimize)(ctx, kbContent, toolInstructions, config, baseContent);
-    // ── 7. Write LLM-generated AGENTS.md ───────────────────
-    store_1.store.setPhase('writing');
-    if (flags.dryRun) {
-        log.info(logger_1.fmt.bold('Dry run — proposed AGENTS.md:'));
-        log.blank();
-        log.info(optimizeResult.content);
-        log.blank();
+        store_1.store.addSetupNote(`context: ${[...toolInstructions.keys()].join(', ')}`);
     }
-    else {
-        // Compute diff before overwriting (for watch-mode change summary)
-        let previousContent;
+    // ── 5. Build base content (directly from model, no KB extraction) ──
+    const baseContent = (0, agentsMdRenderer_1.renderAgentsMd)(model, path.basename(root));
+    // ── 6. Generate or skip ───────────────────────────────────
+    let finalContent = baseContent;
+    if (ctx.generate) {
+        if (!flags.dryRun) {
+            await (0, writer_1.writeAgentsMd)(host, root, baseContent, ownership);
+            store_1.store.addOutput('AGENTS.md written (base)');
+        }
+        store_1.store.setPhase('optimizing');
+        // Skip probe-and-refine if tier is already exhausted
+        const skipProbe = probeAndRefine && store_1.store.state.tierExhausted;
+        let optimizeResult;
         try {
-            if (fs.existsSync(agentsPath)) {
-                previousContent = fs.readFileSync(agentsPath, 'utf-8');
-            }
-        }
-        catch { /* ignore read errors */ }
-        await (0, writer_1.writeAgentsMd)(host, root, optimizeResult.content, ownership);
-        const modeLabel = ownership === 'section' ? ' (section)' : '';
-        const verb = optimizeResult.reasoning.length > 0 ? 'generated' : 'written';
-        store_1.store.addOutput(`AGENTS.md ${verb}${modeLabel}`);
-        log.success(`AGENTS.md ${verb}${modeLabel}`);
-        // Diff summary (skip on first write when previous was just the base template)
-        if (previousContent !== undefined && previousContent !== baseContent) {
-            const diff = (0, diffSummary_1.diffSummary)(previousContent, optimizeResult.content);
-            store_1.store.setDiffSummary(diff);
-        }
-        // Content summary for the dashboard
-        const summary = (0, summary_1.summarizeContent)(optimizeResult.content);
-        store_1.store.setSummary(summary);
-    }
-    // ── 8. Optionally write kb.md ─────────────────────────────
-    if (flags.kb && !flags.dryRun) {
-        await (0, writer_1.writeKbMd)(host, root, kbContent);
-        store_1.store.addOutput('kb.md written');
-        log.success('kb.md written');
+            optimizeResult = await (0, optimize_1.tryOptimize)(ctx, kbContent, toolInstructions, config, baseContent, skipProbe ? false : probeAndRefine, preferences, userSettings, []);
+        }
+        catch (err) {
+            if (err?.tierExhausted) {
+                store_1.store.setTierExhausted();
+                optimizeResult = { content: baseContent, reasoning: [], scopedRules: [], deleteSlugs: [] };
+            }
+            else {
+                throw err;
+            }
+        }
+        finalContent = optimizeResult.content;
+        store_1.store.setPhase('writing');
+        if (flags.dryRun) {
+            log.info(logger_1.fmt.bold('Dry run — proposed AGENTS.md:'));
+            log.blank();
+            log.info(finalContent);
+        }
+        else {
+            let previousContent;
+            try {
+                if (fs.existsSync(agentsPath)) {
+                    previousContent = fs.readFileSync(agentsPath, 'utf-8');
+                }
+            }
+            catch { /* ignore */ }
+            await (0, writer_1.writeAgentsMd)(host, root, finalContent, ownership);
+            const modeLabel = ownership === 'section' ? ' (section)' : '';
+            const verb = optimizeResult.reasoning.length > 0 ? 'generated' : 'written';
+            store_1.store.addOutput(`AGENTS.md ${verb}${modeLabel}`);
+            if (previousContent !== undefined && previousContent !== baseContent) {
+                store_1.store.setDiffSummary((0, diffSummary_1.diffSummary)(previousContent, finalContent));
+            }
+            store_1.store.setSummary((0, summary_1.summarizeContent)(finalContent));
+        }
     }
+    else {
+        store_1.store.setPhase('writing');
+        if (flags.dryRun) {
+            log.info(logger_1.fmt.bold('Dry run — proposed AGENTS.md (KB-custom):'));
+            log.blank();
+            log.info(baseContent);
+        }
+        else {
+            await (0, writer_1.writeAgentsMd)(host, root, baseContent, ownership);
+            store_1.store.addOutput('AGENTS.md written (KB-custom)');
+            store_1.store.setSummary((0, summary_1.summarizeContent)(baseContent));
+        }
+        // No LLM available — use static extraction for scoped rules
+        // No static rules in non-LLM path — dream cycle handles rules
+    }
+    // ── 7. Persist runtime state ───────────────────────────────
+    // Snapshot hub counts before updating state (for new-hub detection)
+    const hubCounts = new Map();
+    for (const hub of model.metrics.hubs) {
+        hubCounts.set(hub.file, hub.inDegree);
+    }
+    (0, runtimeState_1.updateRuntimeState)({
+        model,
+        kbContent,
+        agentsContent: finalContent,
+        fileContents: workspace.relativeFiles,
+        previousHubCounts: hubCounts,
+    });
+    // ── 8. Scoped rules are managed exclusively by the dream cycle.
+    //    No static rules written during runOnce.
+    // ── 9. Populate memory map ─────────────────────────────────
+    const prefs = await (0, preferences_1.loadPreferences)(root);
+    store_1.store.setManagedFiles(buildManagedFiles(root, prefs.preferences.length, activePlatforms));
     const elapsedMs = Date.now() - startMs;
     store_1.store.setElapsed(`${(elapsedMs / 1000).toFixed(1)}s`);
     store_1.store.setPhase('done');
-    log.info(logger_1.fmt.dim(`Done in ${(elapsedMs / 1000).toFixed(1)}s`));
     return { code: cli_1.ExitCode.OK, kbContent };
 }
-// ── Pipeline entry point ─────────────────────────────────────
-/**
- * Resolve AGENTS.md ownership mode.
- *
- * Called from main() BEFORE the ink dashboard is mounted, because
- * the interactive prompt uses raw stdin which conflicts with ink's useInput.
- */
-async function resolveOwnership(root) {
+// ── Resolve ownership mode ───────────────────────────────────
+async function resolveRunMode(root) {
     const config = (0, config_1.loadConfig)(root);
-    if (config?.ownership)
-        return config.ownership;
+    if (config?.ownership) {
+        return { ownership: config.ownership, generate: true };
+    }
+    const agentsPath = path.join(root, 'AGENTS.md');
+    let existingContent = null;
     try {
-        const fs = await Promise.resolve().then(() => __importStar(require('fs')));
-        const agentsPath = path.join(root, 'AGENTS.md');
         if (fs.existsSync(agentsPath)) {
-            const existing = fs.readFileSync(agentsPath, 'utf-8');
-            if ((0, writer_1.hasMarkers)(existing))
-                return 'section';
-            const idx = await (0, prompts_1.selectPrompt)('AGENTS.md already exists. How should AspectCode manage it?', ['Replace entire file (full ownership)', 'Own a section (preserve your content)'], 0);
+            existingContent = fs.readFileSync(agentsPath, 'utf-8');
+            if ((0, writer_1.hasMarkers)(existingContent))
+                return { ownership: 'section', generate: true };
+        }
+    }
+    catch { /* fall through */ }
+    try {
+        const hasExisting = existingContent !== null;
+        const options = hasExisting
+            ? ['Full control (replace entire file)', 'Section control (preserve your content)', 'Preview current AGENTS.md']
+            : ['Full control (replace entire file)', 'Section control (preserve your content)'];
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const idx = await (0, prompts_1.selectPrompt)('How should AspectCode manage AGENTS.md?', options, 0);
+            // Preview option — show content, then loop back to prompt
+            if (hasExisting && idx === 2) {
+                showFilePreview(existingContent);
+                continue;
+            }
             const ownership = idx === 1 ? 'section' : 'full';
+            // Save choice so we don't ask again
             (0, config_1.saveConfig)(root, { ownership });
-            return ownership;
+            return { ownership, generate: true };
+        }
+    }
+    catch {
+        return { ownership: 'full', generate: true };
+    }
+}
+/**
+ * Display file content in a scrollable pager-like view.
+ * Press any key to return.
+ */
+function showFilePreview(content) {
+    return new Promise((resolve) => {
+        const lines = content.split('\n');
+        const termHeight = process.stdout.rows || 24;
+        const visibleLines = termHeight - 4; // leave room for header/footer
+        let scrollOffset = 0;
+        const render = () => {
+            process.stdout.write('\x1b[2J\x1b[H'); // clear screen
+            process.stdout.write('\x1b[35m── AGENTS.md preview ──\x1b[0m\n\n');
+            const slice = lines.slice(scrollOffset, scrollOffset + visibleLines);
+            for (const line of slice) {
+                process.stdout.write(`  ${line}\n`);
+            }
+            const pct = lines.length <= visibleLines
+                ? 100
+                : Math.round(((scrollOffset + visibleLines) / lines.length) * 100);
+            process.stdout.write(`\n\x1b[90m  ↑/↓ scroll · q/esc to go back · ${pct}%\x1b[0m`);
+        };
+        render();
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.setEncoding('utf-8');
+        const onData = (key) => {
+            if (key === '\x1b[A' || key === 'k') {
+                scrollOffset = Math.max(0, scrollOffset - 1);
+                render();
+            }
+            else if (key === '\x1b[B' || key === 'j') {
+                scrollOffset = Math.min(Math.max(0, lines.length - visibleLines), scrollOffset + 1);
+                render();
+            }
+            else if (key === '\x1b[5~') {
+                // Page Up
+                scrollOffset = Math.max(0, scrollOffset - visibleLines);
+                render();
+            }
+            else if (key === '\x1b[6~') {
+                // Page Down
+                scrollOffset = Math.min(Math.max(0, lines.length - visibleLines), scrollOffset + visibleLines);
+                render();
+            }
+            else if (key === 'q' || key === '\x1b' || key === '\r' || key === '\n') {
+                process.stdin.setRawMode(false);
+                process.stdin.pause();
+                process.stdin.removeListener('data', onData);
+                process.stdout.write('\x1b[2J\x1b[H'); // clear screen
+                resolve();
+            }
+            else if (key === '\x03') {
+                process.stdin.setRawMode(false);
+                process.stdin.pause();
+                process.stdin.removeListener('data', onData);
+                process.exit(130);
+            }
+        };
+        process.stdin.on('data', onData);
+    });
+}
+// ── Platform resolution ─────────────────────────────────────
+const ALL_PLATFORMS = [
+    { id: 'claude', label: 'Claude Code', detect: ['.claude'] },
+    { id: 'cursor', label: 'Cursor', detect: ['.cursor', '.cursorrules'] },
+    { id: 'copilot', label: 'GitHub Copilot', detect: ['.github'] },
+    { id: 'windsurf', label: 'Windsurf', detect: ['.windsurfrules'] },
+    { id: 'codex', label: 'Codex', detect: [] },
+    { id: 'cline', label: 'Cline', detect: ['.clinerules'] },
+    { id: 'gemini', label: 'Gemini', detect: ['GEMINI.md'] },
+    { id: 'aider', label: 'Aider', detect: ['CONVENTIONS.md'] },
+];
+async function resolvePlatforms(root) {
+    const config = (0, config_1.loadConfig)(root);
+    const configured = (0, config_1.getConfigPlatforms)(config);
+    if (configured?.length) {
+        // Check if collaborator has a platform not in config
+        const declined = config?.declinedPlatforms ?? [];
+        const detected = ALL_PLATFORMS
+            .filter((p) => p.detect.some((d) => fs.existsSync(path.join(root, d))))
+            .map((p) => p.id);
+        const missing = detected.filter((d) => !configured.includes(d) && !declined.includes(d));
+        if (missing.length > 0) {
+            const names = missing.map((id) => ALL_PLATFORMS.find((p) => p.id === id)?.label ?? id).join(', ');
+            const { confirmPrompt } = await Promise.resolve().then(() => __importStar(require('./ui/prompts')));
+            const add = await confirmPrompt(`${names} detected but not configured. Add?`);
+            if (add) {
+                const updated = [...configured, ...missing];
+                (0, config_1.saveConfig)(root, { platforms: updated });
+                return updated;
+            }
+            else {
+                // Remember declined so we don't ask again
+                (0, config_1.saveConfig)(root, { declinedPlatforms: [...declined, ...missing] });
+            }
         }
+        return configured;
+    }
+    // First run: auto-detect + prompt
+    const detected = ALL_PLATFORMS
+        .filter((p) => p.detect.some((d) => fs.existsSync(path.join(root, d))))
+        .map((p) => p.id);
+    const preselected = detected.map((id) => ALL_PLATFORMS.findIndex((p) => p.id === id)).filter((i) => i >= 0);
+    try {
+        const { multiSelectPrompt } = await Promise.resolve().then(() => __importStar(require('./ui/prompts')));
+        const labels = ALL_PLATFORMS.map((p) => {
+            const det = detected.includes(p.id) ? ' (detected)' : '';
+            return `${p.label}${det}`;
+        });
+        const indices = await multiSelectPrompt('Which editors do you use?', labels, preselected);
+        const selected = indices.map((i) => ALL_PLATFORMS[i].id);
+        const platforms = selected.length > 0 ? selected : ['claude']; // default to Claude Code
+        (0, config_1.saveConfig)(root, { platforms });
+        return platforms;
     }
     catch {
-        // Non-interactive or read error — default to full
+        const platforms = detected.length > 0 ? detected : ['claude'];
+        (0, config_1.saveConfig)(root, { platforms });
+        return platforms;
     }
-    return 'full';
 }
+async function handleAssessmentAction(action, prefs, root, _ownership) {
+    if (!action.assessment)
+        return prefs;
+    const a = action.assessment;
+    const dir = path.dirname(a.file) + '/';
+    if (action.type === 'dismiss') {
+        // Dismiss → directory-scoped allow (broad: "this is fine here")
+        prefs = (0, preferences_1.addPreference)(prefs, {
+            rule: a.rule,
+            pattern: a.message,
+            disposition: 'allow',
+            directory: dir,
+            details: a.details,
+            dependencyContext: a.dependencyContext,
+        });
+        (0, preferences_1.savePreferences)(root, prefs);
+        store_1.store.setPreferenceCount(prefs.preferences.length);
+        store_1.store.setLearnedMessage(`Suppressed: ${a.rule} in ${dir}`);
+        store_1.store.resolveAssessment('dismiss');
+        (0, dreamCycle_1.addCorrection)('dismiss', a);
+    }
+    else if (action.type === 'confirm') {
+        // Confirm → file-scoped deny (specific: "this matters for this file")
+        prefs = (0, preferences_1.addPreference)(prefs, {
+            rule: a.rule,
+            pattern: a.message,
+            disposition: 'deny',
+            file: a.file,
+            directory: dir,
+            details: a.details,
+            suggestion: a.suggestion,
+            dependencyContext: a.dependencyContext,
+        });
+        (0, preferences_1.savePreferences)(root, prefs);
+        store_1.store.setPreferenceCount(prefs.preferences.length);
+        store_1.store.setLearnedMessage(`Enforced: ${a.rule} for ${a.file}`);
+        store_1.store.setRecommendProbe(true);
+        store_1.store.resolveAssessment('confirm');
+        (0, dreamCycle_1.addCorrection)('confirm', a);
+        // Don't directly modify AGENTS.md — the dream cycle handles integration cleanly
+    }
+    else if (action.type === 'skip') {
+        store_1.store.advanceAssessment();
+    }
+    store_1.store.setCorrectionCount((0, dreamCycle_1.getUnprocessedCount)());
+    return prefs;
+}
+// ── Main pipeline ────────────────────────────────────────────
 async function runPipeline(ctx) {
     const { root, flags, log, ownership } = ctx;
+    // Set terminal title
+    const projectName = path.basename(root);
+    process.stdout.write(`\x1b]0;aspectcode — ${projectName}\x07`);
     log.info(`${logger_1.fmt.bold('aspectcode')} — ${logger_1.fmt.cyan(root)}`);
     log.blank();
-    // ── Initial run ──────────────────────────────────────────
-    const result = await runOnce(ctx, ownership);
+    store_1.store.setRootPath(root);
+    // ── Show update message if available ──────────────────────
+    const updateMsg = globalThis.__updateMessage;
+    if (updateMsg)
+        store_1.store.setUpdateMessage(updateMsg);
+    // ── Set platforms from pre-resolved context ────────────────
+    const activePlatforms = ctx.platforms;
+    store_1.store.setPlatform(activePlatforms.join(', '));
+    // ── Check login status ────────────────────────────────────
+    const creds = (0, auth_1.loadCredentials)();
+    store_1.store.setUserEmail(creds?.email ?? '');
+    // ── Detect tier ──────────────────────────────────────────
+    const projectConfig = (0, config_1.loadConfig)(root);
+    const hasByokKey = !!(projectConfig?.apiKey || process.env.ASPECTCODE_LLM_KEY);
+    if (hasByokKey) {
+        store_1.store.setTierInfo('byok', 0, 0);
+    }
+    else if (creds) {
+        // Fetch tier + usage from verify endpoint
+        try {
+            const res = await fetch(`${auth_1.WEB_APP_URL}/api/cli/verify`, {
+                method: 'POST',
+                headers: { Authorization: `Bearer ${creds.token}` },
+            });
+            if (res.ok) {
+                const data = (await res.json());
+                const tier = (data.tier === 'PRO' ? 'pro' : 'free');
+                const used = data.usage?.tokensUsed ?? creds.tierTokensUsed ?? 0;
+                const cap = data.usage?.tokensCap ?? creds.tierTokensCap ?? 100000;
+                const resetAt = data.usage?.resetAt ?? '';
+                store_1.store.setTierInfo(tier, used, cap, resetAt || undefined);
+                if (used >= cap)
+                    store_1.store.setTierExhausted();
+                (0, auth_1.updateCredentials)({ tier, tierTokensUsed: used, tierTokensCap: cap });
+            }
+            else if (creds.tier) {
+                // Offline fallback — use cached tier
+                const used = creds.tierTokensUsed ?? 0;
+                const cap = creds.tierTokensCap ?? 100000;
+                store_1.store.setTierInfo(creds.tier, used, cap);
+                if (used >= cap)
+                    store_1.store.setTierExhausted();
+            }
+        }
+        catch {
+            // Offline — use cached tier if available
+            if (creds.tier) {
+                const used = creds.tierTokensUsed ?? 0;
+                const cap = creds.tierTokensCap ?? 100000;
+                store_1.store.setTierInfo(creds.tier, used, cap);
+                if (used >= cap)
+                    store_1.store.setTierExhausted();
+            }
+        }
+    }
+    // ── Load user settings from cloud ─────────────────────────
+    const userSettings = await (0, config_1.loadUserSettings)();
+    // Stash for Dashboard settings panel access
+    store_1.store._userSettings = userSettings;
+    // ── Initial run — only probe-and-refine on first run (no existing AGENTS.md)
+    const initialProbeAndRefine = !fs.existsSync(path.join(root, 'AGENTS.md'));
+    const result = await runOnce(ctx, ownership, initialProbeAndRefine, undefined, activePlatforms, userSettings);
+    ctx.generate = true;
     if (result.code !== cli_1.ExitCode.OK)
         return result.code;
-    // Keep track of latest KB for complaint processing
-    let latestKb = result.kbContent;
-    // ── --once: process any queued complaints, then exit ──────
-    if (flags.once) {
-        if (store_1.store.state.complaintQueue.length > 0) {
-            await (0, complaintProcessor_1.processComplaints)(ctx, ownership, latestKb);
-        }
+    if (flags.once)
         return cli_1.ExitCode.OK;
+    // ── Load preferences ───────────────────────────────────────
+    let prefs = await (0, preferences_1.loadPreferences)(root);
+    store_1.store.setPreferenceCount(prefs.preferences.length);
+    // ── Fetch community suggestions ───────────────────────────
+    if (store_1.store.state.userTier !== 'byok') {
+        // Detect primary language from analysis model
+        const state = (0, runtimeState_1.getRuntimeState)();
+        if (state.model) {
+            const langCounts = new Map();
+            for (const f of state.model.files) {
+                langCounts.set(f.language, (langCounts.get(f.language) ?? 0) + 1);
+            }
+            let primaryLang = '';
+            let maxCount = 0;
+            for (const [lang, count] of langCounts) {
+                if (count > maxCount) {
+                    primaryLang = lang;
+                    maxCount = count;
+                }
+            }
+            if (primaryLang) {
+                // Fetch community suggestions, filter to relevant ones, feed to dream cycle
+                const projectDirs = new Set(state.model.files.map((f) => {
+                    const parts = f.relativePath.split('/');
+                    return parts.length > 1 ? parts[0] + '/' : '';
+                }));
+                (0, preferences_1.fetchSuggestions)(primaryLang, undefined, { byok: false })
+                    .then((suggestions) => {
+                    // Filter out suggestions for directories that don't exist in this project
+                    const relevant = suggestions.filter((s) => {
+                        if (!s.directory)
+                            return true; // project-wide suggestions always apply
+                        return projectDirs.has(s.directory) || [...projectDirs].some((d) => s.directory.startsWith(d));
+                    });
+                    if (relevant.length > 0) {
+                        store_1.store.setSuggestions(relevant.map((s) => ({ rule: s.rule, disposition: s.disposition, directory: s.directory, suggestion: s.suggestion })));
+                    }
+                })
+                    .catch(() => { });
+                // Pro users: refresh suggestions every 10 minutes (interval cleaned up in shutdown)
+                if (store_1.store.state.userTier === 'pro') {
+                    store_1.store._suggestionsRefresh = { primaryLang };
+                }
+            }
+        }
     }
-    // ── Watch mode ────────────────────────────────────────────
+    // ── Resolve provider for auto-resolve in watch mode ────────
+    let watchProvider;
+    try {
+        const env = (0, optimizer_1.loadEnvFile)(root);
+        const watchCreds = (0, auth_1.loadCredentials)();
+        if (watchCreds)
+            env['ASPECTCODE_CLI_TOKEN'] = watchCreds.token;
+        if (projectConfig?.apiKey && !env['ASPECTCODE_LLM_KEY'])
+            env['ASPECTCODE_LLM_KEY'] = projectConfig.apiKey;
+        watchProvider = (0, usageTracker_1.withUsageTracking)((0, optimizer_1.resolveProvider)(env));
+    }
+    catch { /* no LLM — assessments go to user as before */ }
+    // ── Watch mode with real-time evaluation ───────────────────
     log.blank();
-    log.info(logger_1.fmt.dim('Watching for changes… (Ctrl+C to stop)'));
     store_1.store.setPhase('watching');
-    const chokidarModule = await Promise.resolve().then(() => __importStar(require('chokidar')));
-    const chokidar = chokidarModule.default ?? chokidarModule;
-    const watcher = chokidar.watch('.', {
-        cwd: root,
-        ignoreInitial: true,
-        awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 100 },
-        ignored: (watchedPath) => {
-            const abs = path.resolve(root, watchedPath);
-            return isIgnoredPath(abs);
-        },
-    });
-    let timer;
-    let running = false;
-    let pending = false;
+    // Refresh memory map every 10s to catch file deletions/additions
+    const memoryMapInterval = setInterval(() => {
+        if (stopped)
+            return;
+        store_1.store.setManagedFiles(buildManagedFiles(root, prefs.preferences.length, activePlatforms));
+    }, 10000);
+    let evalTimer;
+    let pipelineRunning = false;
     let stopped = false;
-    const triggerRun = async (reason) => {
+    let pendingEvalEvents = [];
+    // Pro: refresh suggestions once per day (checked every hour, skips if last fetch was <24h ago)
+    const suggestionsRefreshInfo = store_1.store._suggestionsRefresh;
+    let lastSuggestionsFetch = Date.now();
+    const SUGGESTIONS_REFRESH_MS = 24 * 60 * 60 * 1000;
+    const suggestionsInterval = suggestionsRefreshInfo ? setInterval(() => {
         if (stopped)
             return;
-        if (running) {
-            pending = true;
+        if (Date.now() - lastSuggestionsFetch < SUGGESTIONS_REFRESH_MS)
             return;
+        (0, preferences_1.fetchSuggestions)(suggestionsRefreshInfo.primaryLang, undefined, { byok: false })
+            .then((suggestions) => {
+            lastSuggestionsFetch = Date.now();
+            if (suggestions.length > 0 && !store_1.store.state.suggestionsDismissed) {
+                store_1.store.setSuggestions(suggestions.map((s) => ({ rule: s.rule, disposition: s.disposition, directory: s.directory, suggestion: s.suggestion })));
+            }
+        })
+            .catch(() => { });
+    }, 60 * 60 * 1000) : undefined;
+    // Co-change settle window — hold co-change assessments for 5s to see if dependents get updated
+    const pendingCoChange = new Map();
+    let settleTimer;
+    const recentlyChangedFiles = new Set();
+    function parseDependents(ctx) {
+        const match = ctx.match(/missing: \[([^\]]*)\]/);
+        if (!match)
+            return [];
+        return match[1].split(',').map((s) => s.trim()).filter(Boolean);
+    }
+    const resolveSettledCoChange = async (threshold, forwarded) => {
+        settleTimer = undefined;
+        const surviving = [];
+        for (const [, entry] of pendingCoChange) {
+            // Drop if all dependents were updated during settle window
+            const allUpdated = entry.dependents.length > 0 && entry.dependents.every((d) => recentlyChangedFiles.has(d));
+            if (!allUpdated)
+                surviving.push(entry.assessment);
         }
-        running = true;
+        pendingCoChange.clear();
+        if (surviving.length > 0 && watchProvider) {
+            try {
+                const results = await (0, autoResolve_1.autoResolveBatch)(surviving, prefs, watchProvider, { threshold });
+                for (const result of results) {
+                    if (result.autoResolved) {
+                        const a = result.assessment;
+                        const dir = path.dirname(a.file) + '/';
+                        if (result.decision === 'allow') {
+                            prefs = (0, preferences_1.addPreference)(prefs, { rule: a.rule, pattern: a.message, disposition: 'allow', directory: dir, details: a.details, dependencyContext: a.dependencyContext });
+                        }
+                        else {
+                            prefs = (0, preferences_1.addPreference)(prefs, { rule: a.rule, pattern: a.message, disposition: 'deny', file: a.file, directory: dir, details: a.details, suggestion: a.suggestion, dependencyContext: a.dependencyContext });
+                        }
+                        (0, dreamCycle_1.addCorrection)(result.decision === 'allow' ? 'dismiss' : 'confirm', a);
+                        const stats = { ...store_1.store.state.assessmentStats };
+                        stats.autoResolved++;
+                        store_1.store.state.assessmentStats = stats;
+                    }
+                    else {
+                        const a = result.assessment;
+                        a.llmRecommendation = { decision: result.decision, confidence: result.confidence, reasoning: result.reasoning };
+                        forwarded.push(a);
+                    }
+                }
+                (0, preferences_1.savePreferences)(root, prefs);
+                store_1.store.setPreferenceCount(prefs.preferences.length);
+                if (forwarded.length > 0)
+                    store_1.store.pushAssessments(forwarded);
+            }
+            catch (err) {
+                if (err?.tierExhausted)
+                    store_1.store.setTierExhausted();
+                store_1.store.pushAssessments(surviving);
+            }
+        }
+        else if (surviving.length > 0) {
+            store_1.store.pushAssessments(surviving);
+        }
+    };
+    // Auto-probe tracking
+    let lastChangeAt = Date.now();
+    let lastProbeAt = Date.now();
+    // Fire an immediate dream at session start to review/prune existing rules
+    let sessionDreamDone = false;
+    let lastDreamAt = Date.now();
+    const optLog = flags.quiet ? undefined : {
+        info(msg) { log.info(msg); },
+        warn(msg) { log.warn(msg); },
+        error(msg) { log.error(msg); },
+        debug(msg) { log.debug(msg); },
+    };
+    // ── Dream cycle (autonomous) ────────────────────────────────
+    const doDreamCycle = async () => {
+        if (pipelineRunning || stopped || store_1.store.state.tierExhausted)
+            return;
+        store_1.store.setDreamPrompt(false);
+        const state = (0, runtimeState_1.getRuntimeState)();
+        if (!state.agentsContent)
+            return;
+        let provider;
         try {
-            log.blank();
-            log.info(`${logger_1.fmt.bold('change detected:')} ${reason}`);
-            store_1.store.setLastChange(reason);
-            const runResult = await runOnce(ctx, ownership);
-            if (runResult.kbContent)
-                latestKb = runResult.kbContent;
+            const env = (0, optimizer_1.loadEnvFile)(root);
+            const creds = (0, auth_1.loadCredentials)();
+            if (creds && !env['ASPECTCODE_CLI_TOKEN'])
+                env['ASPECTCODE_CLI_TOKEN'] = creds.token;
+            provider = (0, usageTracker_1.withUsageTracking)((0, optimizer_1.resolveProvider)(env));
+        }
+        catch {
+            return;
+        }
+        store_1.store.setDreaming(true);
+        pipelineRunning = true;
+        try {
+            // Read current scoped rules for dream context
+            let scopedRulesContext = '';
+            try {
+                const manifestPath = path.join(root, '.aspectcode', 'scoped-rules.json');
+                if (fs.existsSync(manifestPath)) {
+                    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+                    const parts = [];
+                    for (const entry of manifest.rules ?? []) {
+                        try {
+                            const content = fs.readFileSync(path.join(root, entry.path), 'utf-8');
+                            parts.push(`### ${entry.slug} (${entry.path})\n${content}`);
+                        }
+                        catch { /* skip missing files */ }
+                    }
+                    scopedRulesContext = parts.join('\n---\n');
+                }
+            }
+            catch { /* ignore */ }
+            // Read user-authored .claude/rules/ and .claude/skills/ (read-only context for dream)
+            let userRulesContext = '';
+            try {
+                const USER_CONTEXT_CAP = 3000;
+                const userParts = [];
+                const claudeRulesDir = path.join(root, '.claude', 'rules');
+                if (fs.existsSync(claudeRulesDir)) {
+                    for (const file of fs.readdirSync(claudeRulesDir)) {
+                        if (file.startsWith('ac-'))
+                            continue;
+                        try {
+                            const content = fs.readFileSync(path.join(claudeRulesDir, file), 'utf-8');
+                            userParts.push(`### ${file} (user rule, read-only)\n${content}`);
+                        }
+                        catch { /* skip */ }
+                    }
+                }
+                const claudeSkillsDir = path.join(root, '.claude', 'skills');
+                if (fs.existsSync(claudeSkillsDir)) {
+                    for (const file of fs.readdirSync(claudeSkillsDir)) {
+                        try {
+                            const content = fs.readFileSync(path.join(claudeSkillsDir, file), 'utf-8');
+                            const truncated = content.length > 500
+                                ? content.slice(0, 500) + `\n... (truncated, ${content.length} chars total)`
+                                : content;
+                            userParts.push(`### ${file} (user skill, read-only)\n${truncated}`);
+                        }
+                        catch { /* skip */ }
+                    }
+                }
+                // Cap total user context
+                let combined = userParts.join('\n---\n');
+                if (combined.length > USER_CONTEXT_CAP) {
+                    combined = combined.slice(0, USER_CONTEXT_CAP) + '\n... (truncated)';
+                }
+                userRulesContext = combined;
+            }
+            catch { /* ignore */ }
+            // Format community suggestions for dream cycle context
+            let communitySuggestions;
+            const suggestions = store_1.store.state.suggestions;
+            if (suggestions.length > 0 && !store_1.store.state.suggestionsDismissed) {
+                communitySuggestions = suggestions
+                    .map((s) => `- [${s.rule}] ${s.suggestion}`)
+                    .join('\n');
+                // Mark as consumed so they're only integrated once
+                store_1.store.dismissSuggestions();
+            }
+            const result = await (0, dreamCycle_1.runDreamCycle)({
+                currentAgentsMd: state.agentsContent,
+                corrections: (0, dreamCycle_1.getCorrections)(),
+                provider,
+                log: optLog,
+                scopedRulesContext,
+                userRulesContext: userRulesContext || undefined,
+                communitySuggestions,
+            });
+            const host = (0, emitters_1.createNodeEmitterHost)();
+            await (0, writer_1.writeAgentsMd)(host, root, result.updatedAgentsMd, ownership);
+            (0, runtimeState_1.updateRuntimeState)({ agentsContent: result.updatedAgentsMd });
+            // Write any scoped rules from the dream cycle
+            if ((result.scopedRules.length > 0 || result.deleteSlugs.length > 0) && activePlatforms.length > 0) {
+                // Delete rules the dream cycle marked for removal
+                if (result.deleteSlugs.length > 0) {
+                    await (0, scopedRules_1.deleteScopedRules)(host, root, result.deleteSlugs);
+                }
+                if (result.scopedRules.length > 0) {
+                    await (0, scopedRules_1.writeRulesForPlatforms)(host, root, result.scopedRules, activePlatforms);
+                }
+            }
+            (0, dreamCycle_1.markProcessed)();
+            store_1.store.setCorrectionCount((0, dreamCycle_1.getUnprocessedCount)());
+            (0, dreamCycle_1.saveDreamState)(root, { lastDreamAt: new Date().toISOString() });
+            if (result.changes.length > 0) {
+                store_1.store.setLearnedMessage(`Refined: ${result.changes.join(', ')}`);
+            }
+            // Refresh memory map to reflect any new files
+            store_1.store.setManagedFiles(buildManagedFiles(root, (await (0, preferences_1.loadPreferences)(root)).preferences.length, activePlatforms));
+        }
+        catch (err) {
+            if (err?.tierExhausted) {
+                store_1.store.setTierExhausted();
+            }
+            else {
+                const msg = err instanceof Error ? err.message : String(err);
+                log.warn(`Dream cycle failed: ${msg}`);
+            }
+        }
+        finally {
+            pipelineRunning = false;
+            store_1.store.setDreaming(false);
+        }
+    };
+    // Auto-dream timer: fires every 30s, dreams if corrections exist and 2+ min since last dream
+    const AUTO_DREAM_INTERVAL_MS = 2 * 60 * 1000;
+    const autoDreamTimer = setInterval(() => {
+        if (stopped || pipelineRunning)
+            return;
+        const hasCorrections = (0, dreamCycle_1.getUnprocessedCount)() > 0;
+        const hasSuggestions = store_1.store.state.suggestions.length > 0 && !store_1.store.state.suggestionsDismissed;
+        if (!hasCorrections && !hasSuggestions)
+            return;
+        if (Date.now() - lastDreamAt < AUTO_DREAM_INTERVAL_MS)
+            return;
+        void doDreamCycle().then(() => { lastDreamAt = Date.now(); });
+    }, 30000);
+    // ── Session-start dream: review rules immediately ───────────
+    if (watchProvider) {
+        // Small delay to let the dashboard render first
+        setTimeout(() => {
+            if (stopped || pipelineRunning || sessionDreamDone)
+                return;
+            sessionDreamDone = true;
+            void doDreamCycle().then(() => { lastDreamAt = Date.now(); });
+        }, 3000);
+    }
+    // ── Auto-probe timer: fires after sustained activity + idle period ──
+    const autoProbeTimer = setInterval(() => {
+        if (stopped || pipelineRunning)
+            return;
+        const stats = store_1.store.state.assessmentStats;
+        if (stats.changes < AUTO_PROBE_MIN_CHANGES)
+            return;
+        if (Date.now() - lastChangeAt < AUTO_PROBE_IDLE_MS)
+            return;
+        if (Date.now() - lastProbeAt < AUTO_PROBE_COOLDOWN_MS)
+            return;
+        void doProbeAndRefine();
+    }, 60000);
+    // ── Probe and refine ──────────────────────────────────────
+    const doProbeAndRefine = async () => {
+        if (stopped || pipelineRunning)
+            return;
+        if (store_1.store.state.tierExhausted) {
+            store_1.store.setLearnedMessage('Token limit reached — upgrade or add your own key');
+            return;
+        }
+        // Run pending dream cycle before full probe-and-refine
+        // Dream before re-running if corrections exist
+        if ((0, dreamCycle_1.getUnprocessedCount)() > 0)
+            await doDreamCycle();
+        if (pipelineRunning)
+            return;
+        pipelineRunning = true;
+        if (evalTimer) {
+            clearTimeout(evalTimer);
+            evalTimer = undefined;
+        }
+        pendingEvalEvents.length = 0;
+        store_1.store.setRecommendProbe(false);
+        try {
+            await runOnce(ctx, ownership, true, prefs, activePlatforms, userSettings);
+            prefs = await (0, preferences_1.loadPreferences)(root);
+            store_1.store.setPreferenceCount(prefs.preferences.length);
             store_1.store.setPhase('watching');
+            lastProbeAt = Date.now();
         }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            log.error(`Pipeline failed: ${msg}`);
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            log.error(`Probe and refine failed: ${msg}`);
         }
         finally {
-            running = false;
-            if (pending && !stopped) {
-                pending = false;
-                void triggerRun('queued changes');
+            pipelineRunning = false;
+        }
+    };
+    // ── Evaluate file changes (fast, no LLM) ──────────────────
+    const RECOMMEND_THRESHOLD = 10;
+    const evaluateEvents = async (events) => {
+        const state = (0, runtimeState_1.getRuntimeState)();
+        if (!state.model || !state.agentsContent)
+            return;
+        for (const event of events) {
+            (0, changeEvaluator_1.trackChange)(event);
+            // Track add vs change counts
+            if (event.type === 'add')
+                store_1.store.incrementAddCount();
+            else if (event.type === 'change')
+                store_1.store.incrementChangeCount();
+            if (event.type !== 'unlink') {
+                try {
+                    const absPath = path.join(root, event.path);
+                    if (fs.existsSync(absPath)) {
+                        const content = fs.readFileSync(absPath, 'utf-8');
+                        state.fileContents?.set(event.path, content);
+                    }
+                }
+                catch { /* skip unreadable files */ }
+            }
+            const assessments = (0, changeEvaluator_1.evaluateChange)(event, {
+                model: state.model,
+                agentsContent: state.agentsContent,
+                preferences: prefs,
+                recentChanges: (0, changeEvaluator_1.getRecentChanges)(),
+                fileContents: state.fileContents,
+                previousHubCounts: state.previousHubCounts,
+            });
+            // Auto-resolve assessments with LLM when available
+            const actionable = assessments.filter((a) => a.type !== 'ok');
+            const threshold = flags.background ? 0.0 : (userSettings?.autoResolveThreshold ?? 0.8);
+            if (watchProvider && actionable.length > 0) {
+                // Split into cached (preference match) and uncached (need LLM)
+                const cached = [];
+                const uncached = [];
+                for (const a of actionable) {
+                    const match = (0, autoResolve_1.matchExistingPreference)(a, prefs);
+                    if (match) {
+                        cached.push({ result: match });
+                    }
+                    else {
+                        uncached.push(a);
+                    }
+                }
+                // Apply cached decisions immediately
+                for (const { result } of cached) {
+                    const a = result.assessment;
+                    (0, dreamCycle_1.addCorrection)(result.decision === 'allow' ? 'dismiss' : 'confirm', a);
+                    const stats = { ...store_1.store.state.assessmentStats };
+                    stats.autoResolved++;
+                    store_1.store.state.assessmentStats = stats;
+                }
+                // Batch-resolve uncached in a single LLM call
+                const forwarded = [];
+                if (uncached.length > 0) {
+                    // Check for co-change assessments that should wait for settle
+                    const coChange = [];
+                    const immediate = [];
+                    for (const a of uncached) {
+                        if (a.rule === 'co-change' && a.dependencyContext) {
+                            coChange.push(a);
+                        }
+                        else {
+                            immediate.push(a);
+                        }
+                    }
+                    // Hold co-change assessments for settle window
+                    if (coChange.length > 0) {
+                        for (const a of coChange) {
+                            pendingCoChange.set(a.file, { assessment: a, dependents: parseDependents(a.dependencyContext ?? ''), addedAt: Date.now() });
+                        }
+                        if (!settleTimer) {
+                            settleTimer = setTimeout(() => resolveSettledCoChange(threshold, forwarded), CO_CHANGE_SETTLE_MS);
+                        }
+                    }
+                    // Batch-resolve immediate assessments
+                    if (immediate.length > 0) {
+                        try {
+                            const results = await (0, autoResolve_1.autoResolveBatch)(immediate, prefs, watchProvider, { threshold });
+                            for (const result of results) {
+                                if (result.autoResolved) {
+                                    const a = result.assessment;
+                                    const dir = path.dirname(a.file) + '/';
+                                    if (result.decision === 'allow') {
+                                        prefs = (0, preferences_1.addPreference)(prefs, { rule: a.rule, pattern: a.message, disposition: 'allow', directory: dir, details: a.details, dependencyContext: a.dependencyContext });
+                                    }
+                                    else {
+                                        prefs = (0, preferences_1.addPreference)(prefs, { rule: a.rule, pattern: a.message, disposition: 'deny', file: a.file, directory: dir, details: a.details, suggestion: a.suggestion, dependencyContext: a.dependencyContext });
+                                    }
+                                    (0, dreamCycle_1.addCorrection)(result.decision === 'allow' ? 'dismiss' : 'confirm', a);
+                                    const stats = { ...store_1.store.state.assessmentStats };
+                                    stats.autoResolved++;
+                                    store_1.store.state.assessmentStats = stats;
+                                }
+                                else {
+                                    const a = result.assessment;
+                                    a.llmRecommendation = { decision: result.decision, confidence: result.confidence, reasoning: result.reasoning };
+                                    forwarded.push(a);
+                                }
+                            }
+                            (0, preferences_1.savePreferences)(root, prefs);
+                            store_1.store.setPreferenceCount(prefs.preferences.length);
+                            if (cached.length > 0 || results.some((r) => r.autoResolved)) {
+                                const autoCount = cached.length + results.filter((r) => r.autoResolved).length;
+                                store_1.store.setLearnedMessage(`Auto-resolved ${autoCount} assessment${autoCount === 1 ? '' : 's'}`);
+                            }
+                        }
+                        catch (err) {
+                            if (err?.tierExhausted) {
+                                store_1.store.setTierExhausted();
+                            }
+                            forwarded.push(...immediate);
+                        }
+                    }
+                    else if (cached.length > 0) {
+                        store_1.store.setLearnedMessage(`Auto-resolved ${cached.length} assessment${cached.length === 1 ? '' : 's'}`);
+                    }
+                }
+                else if (cached.length > 0) {
+                    store_1.store.setLearnedMessage(`Auto-resolved ${cached.length} assessment${cached.length === 1 ? '' : 's'}`);
+                }
+                store_1.store.pushAssessments(forwarded);
             }
+            else {
+                store_1.store.pushAssessments(assessments);
+            }
+            // Change flash for clean changes
+            const hasNonOk = assessments.some((a) => a.type !== 'ok');
+            if (!hasNonOk) {
+                store_1.store.setLastChangeFlash(`${event.path} — ok`);
+            }
+        }
+        // Auto-recommend probe-and-refine
+        const stats = store_1.store.state.assessmentStats;
+        if (stats.changes >= RECOMMEND_THRESHOLD && !store_1.store.state.recommendProbe) {
+            store_1.store.setRecommendProbe(true);
         }
     };
+    // ── File change handler ────────────────────────────────────
     const onFsEvent = (eventType, eventPath) => {
+        if (pipelineRunning)
+            return;
         const abs = path.resolve(root, eventPath);
         if (!isSupportedSourceFile(abs) || isIgnoredPath(abs))
             return;
-        if (timer)
-            clearTimeout(timer);
-        timer = setTimeout(() => {
-            timer = undefined;
-            void triggerRun(`${eventType}: ${eventPath.replace(/\\/g, '/')}`);
-        }, DEBOUNCE_MS);
+        const posixPath = eventPath.replace(/\\/g, '/');
+        pendingEvalEvents.push({ type: eventType, path: posixPath });
+        lastChangeAt = Date.now();
+        // Track recently changed files for co-change settle window
+        recentlyChangedFiles.add(posixPath);
+        setTimeout(() => recentlyChangedFiles.delete(posixPath), CO_CHANGE_SETTLE_MS + 1000);
+        if (evalTimer)
+            clearTimeout(evalTimer);
+        evalTimer = setTimeout(() => {
+            evalTimer = undefined;
+            const events = pendingEvalEvents.splice(0);
+            evaluateEvents(events);
+        }, EVAL_DEBOUNCE_MS);
     };
-    watcher.on('add', (p) => onFsEvent('add', p));
-    watcher.on('change', (p) => onFsEvent('change', p));
-    watcher.on('unlink', (p) => onFsEvent('unlink', p));
+    // ── Start watcher (must be after onFsEvent is defined) ─────
+    const watcher = createFileWatcher(root, onFsEvent);
     watcher.on('error', (e) => log.error(`Watcher error: ${String(e)}`));
-    await new Promise((resolve) => watcher.once('ready', resolve));
-    log.info(logger_1.fmt.dim('Watcher ready.'));
-    // ── Complaint polling — check for queued complaints periodically ──
-    const COMPLAINT_POLL_MS = 500;
-    const complaintPoll = setInterval(async () => {
-        if (stopped || running || store_1.store.state.complaintQueue.length === 0)
+    // ── Expose action handler for keyboard input ───────────────
+    const onAssessmentAction = (action) => {
+        if (action.type === 'probe-and-refine') {
+            void doProbeAndRefine();
             return;
-        running = true;
-        try {
-            await (0, complaintProcessor_1.processComplaints)(ctx, ownership, latestKb);
         }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            log.error(`Complaint processing failed: ${msg}`);
+        // Dream cycle is autonomous — no manual trigger
+        if (action.type === 'open-pricing') {
+            const { exec } = require('child_process');
+            const url = 'https://aspectcode.com/pricing';
+            const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start ""' : 'xdg-open';
+            exec(`${cmd} "${url}"`);
+            store_1.store.setLearnedMessage('opened pricing page');
+            return;
         }
-        finally {
-            running = false;
+        if (action.type === 'login') {
+            store_1.store.setLearnedMessage('opening browser…');
+            void (0, auth_1.startBackgroundLogin)().then((email) => {
+                if (email) {
+                    store_1.store.setUserEmail(email);
+                    store_1.store.setLearnedMessage(`logged in as ${email}`);
+                }
+                else {
+                    store_1.store.setLearnedMessage('login failed or timed out');
+                }
+            });
+            return;
         }
-    }, COMPLAINT_POLL_MS);
+        void handleAssessmentAction(action, prefs, root, ownership).then((updated) => {
+            prefs = updated;
+        });
+    };
+    store_1.store._onAssessmentAction = onAssessmentAction;
     return await new Promise((resolve) => {
         const shutdown = async (signal) => {
             if (stopped)
                 return;
             stopped = true;
-            clearInterval(complaintPoll);
-            if (timer) {
-                clearTimeout(timer);
-                timer = undefined;
+            clearInterval(memoryMapInterval);
+            clearInterval(autoDreamTimer);
+            clearInterval(autoProbeTimer);
+            if (suggestionsInterval)
+                clearInterval(suggestionsInterval);
+            if (evalTimer) {
+                clearTimeout(evalTimer);
+                evalTimer = undefined;
             }
             log.blank();
             log.info(logger_1.fmt.dim(`Stopping (${signal})…`));