helixmind 0.5.4

package/dist/cli/jarvis/test-sentinel.js

@@ -0,0 +1,178 @@
+/**
+ * Test Sentinel — test intelligence for Jarvis.
+ * Detects affected tests from git changes, flaky test tracking,
+ * coverage trend monitoring.
+ */
+import { execSync } from 'node:child_process';
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * Detect which test files are likely affected by recent changes.
+ * Uses import/require graph heuristics from git diff.
+ */
+export function detectAffectedTests(projectRoot) {
+    const insights = [];
+    try {
+        // Get changed files from last commit
+        const diffRaw = execSync('git diff HEAD~1 HEAD --name-only', {
+            cwd: projectRoot,
+            encoding: 'utf-8',
+            timeout: 5000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        if (!diffRaw)
+            return insights;
+        const changedFiles = diffRaw.split('\n').filter(f => f.endsWith('.ts') || f.endsWith('.js'));
+        if (changedFiles.length === 0)
+            return insights;
+        // Find test files that import changed source files
+        const affectedTests = [];
+        const changedSrcFiles = changedFiles.filter(f => !f.includes('.test.') && !f.includes('.spec.') && !f.includes('__tests__'));
+        const changedTestFiles = changedFiles.filter(f => f.includes('.test.') || f.includes('.spec.') || f.includes('__tests__'));
+        // Check which test files reference the changed source files
+        for (const srcFile of changedSrcFiles) {
+            const baseName = srcFile.replace(/\.(ts|js)$/, '').split('/').pop();
+            if (!baseName)
+                continue;
+            // Look for corresponding test file
+            const testPatterns = [
+                srcFile.replace(/\.(ts|js)$/, '.test.$1'),
+                srcFile.replace(/\.(ts|js)$/, '.spec.$1'),
+                srcFile.replace(/src\//, 'test/').replace(/\.(ts|js)$/, '.test.$1'),
+            ];
+            for (const pattern of testPatterns) {
+                const fullPath = join(projectRoot, pattern);
+                if (existsSync(fullPath) && !changedTestFiles.includes(pattern)) {
+                    affectedTests.push(pattern);
+                }
+            }
+            // Search for test files that import this module
+            try {
+                const grepResult = execSync(`git grep -l "${baseName}" -- "*.test.ts" "*.spec.ts" "*.test.js" "*.spec.js" 2>/dev/null || true`, { cwd: projectRoot, encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+                if (grepResult) {
+                    for (const testFile of grepResult.split('\n')) {
+                        if (testFile && !changedTestFiles.includes(testFile) && !affectedTests.includes(testFile)) {
+                            affectedTests.push(testFile);
+                        }
+                    }
+                }
+            }
+            catch { /* grep not available or failed */ }
+        }
+        if (affectedTests.length > 0) {
+            insights.push({
+                type: 'affected_tests',
+                description: `${affectedTests.length} test file(s) may be affected by recent changes`,
+                severity: 'medium',
+                files: affectedTests,
+                suggestion: `Run: npx vitest ${affectedTests.slice(0, 5).join(' ')}`,
+            });
+        }
+        // Check for source files without corresponding tests
+        const untestedFiles = changedSrcFiles.filter(f => {
+            const baseName2 = f.replace(/\.(ts|js)$/, '');
+            return !existsSync(join(projectRoot, `${baseName2}.test.ts`))
+                && !existsSync(join(projectRoot, `${baseName2}.spec.ts`));
+        });
+        if (untestedFiles.length > 0) {
+            insights.push({
+                type: 'missing_tests',
+                description: `${untestedFiles.length} changed source file(s) have no corresponding test file`,
+                severity: 'low',
+                files: untestedFiles,
+                suggestion: 'Consider adding tests for these files',
+            });
+        }
+    }
+    catch {
+        // Git commands failed — skip
+    }
+    return insights;
+}
+/**
+ * Check for flaky tests by looking at recent test history.
+ * Reads .helixmind/test-history.json if it exists.
+ */
+export function detectFlakyTests(projectRoot) {
+    const historyPath = join(projectRoot, '.helixmind', 'test-history.json');
+    if (!existsSync(historyPath))
+        return [];
+    try {
+        const raw = readFileSync(historyPath, 'utf-8');
+        const history = JSON.parse(raw);
+        if (!history.runs || history.runs.length === 0)
+            return [];
+        // Group by test name
+        const testResults = new Map();
+        for (const run of history.runs) {
+            const entry = testResults.get(run.test) || { pass: 0, fail: 0 };
+            if (run.passed)
+                entry.pass++;
+            else
+                entry.fail++;
+            testResults.set(run.test, entry);
+        }
+        // Flaky = has both passes and failures (min 3 total runs)
+        const flakyTests = [];
+        for (const [test, results] of testResults) {
+            const total = results.pass + results.fail;
+            if (total >= 3 && results.pass > 0 && results.fail > 0) {
+                flakyTests.push(test);
+            }
+        }
+        if (flakyTests.length > 0) {
+            return [{
+                    type: 'flaky_test',
+                    description: `${flakyTests.length} flaky test(s) detected (inconsistent pass/fail)`,
+                    severity: 'medium',
+                    files: flakyTests,
+                    suggestion: 'Investigate timing, shared state, or external dependencies in these tests',
+                }];
+        }
+    }
+    catch { /* corrupted history */ }
+    return [];
+}
+/**
+ * Run a quick test suite status check (vitest --reporter=json).
+ * Non-blocking: returns null if tests take too long.
+ */
+export function getTestSuiteStatus(projectRoot) {
+    try {
+        const raw = execSync('npx vitest run --reporter=json 2>/dev/null', {
+            cwd: projectRoot,
+            encoding: 'utf-8',
+            timeout: 60_000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const result = JSON.parse(raw);
+        return {
+            passed: result.numPassedTests || 0,
+            failed: result.numFailedTests || 0,
+            total: result.numTotalTests || 0,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Build test insights for the thinking loop.
+ */
+export function runTestAnalysis(projectRoot) {
+    return [
+        ...detectAffectedTests(projectRoot),
+        ...detectFlakyTests(projectRoot),
+    ];
+}
+/**
+ * Convert test insights to proposal evidence.
+ */
+export function insightsToEvidence(insights) {
+    return insights.map(i => ({
+        type: 'observation',
+        content: `[${i.severity}] ${i.type}: ${i.description}${i.suggestion ? ` — ${i.suggestion}` : ''}`,
+        timestamp: Date.now(),
+    }));
+}
+//# sourceMappingURL=test-sentinel.js.map

package/dist/cli/jarvis/test-sentinel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-sentinel.js","sourceRoot":"","sources":["../../../src/cli/jarvis/test-sentinel.ts"],"names":[],"mappings":"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"}

package/dist/cli/jarvis/thinking-loop.d.ts

@@ -0,0 +1,15 @@
+import type { ThinkingCallbacks, ThinkingState } from './types.js';
+/**
+ * Run the thinking loop. Replaces the daemon's idle sleep.
+ * Returns when aborted or when a task becomes available.
+ *
+ * @param callbacks - All dependencies injected via callbacks
+ * @param hasTaskAvailable - Check if there's a task to execute (yields thinking)
+ * @returns The current thinking state for persistence
+ */
+export declare function runThinkingLoop(callbacks: ThinkingCallbacks, hasTaskAvailable: () => boolean): Promise<ThinkingState>;
+/**
+ * Run a single deep thinking cycle on demand (/jarvis think).
+ */
+export declare function runImmediateDeepThink(callbacks: ThinkingCallbacks): Promise<void>;
+//# sourceMappingURL=thinking-loop.d.ts.map

package/dist/cli/jarvis/thinking-loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinking-loop.d.ts","sourceRoot":"","sources":["../../../src/cli/jarvis/thinking-loop.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,iBAAiB,EAAiB,aAAa,EAEhD,MAAM,YAAY,CAAC;AAsZpB;;;;;;;GAOG;AACH,wBAAsB,eAAe,CACnC,SAAS,EAAE,iBAAiB,EAC5B,gBAAgB,EAAE,MAAM,OAAO,GAC9B,OAAO,CAAC,aAAa,CAAC,CAiDxB;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,SAAS,EAAE,iBAAiB,GAC3B,OAAO,CAAC,IAAI,CAAC,CAaf"}

package/dist/cli/jarvis/thinking-loop.js

@@ -0,0 +1,437 @@
+/**
+ * Thinking Loop — Jarvis' continuous consciousness.
+ * Three-tier observation cycle: Quick (30s), Medium (5m), Deep (30m).
+ * Replaces the idle sleep(30_000) in the daemon.
+ * Follows the Monitor-Watcher pattern (src/cli/agent/monitor/watcher.ts).
+ */
+import { randomUUID } from 'node:crypto';
+import { detectAnomalousPattern, getRecentAudit } from './core-ethics.js';
+// ─── Timing Constants ─────────────────────────────────────────────────
+const QUICK_INTERVAL_MS = 30_000; // 30 seconds
+const MEDIUM_INTERVAL_MS = 5 * 60_000; // 5 minutes
+const DEEP_INTERVAL_MS = 30 * 60_000; // 30 minutes
+const TICK_SLEEP_MS = 5_000; // Check every 5s between phases
+// ─── Thinking State ───────────────────────────────────────────────────
+function createInitialState() {
+    const now = Date.now();
+    return {
+        phase: 'idle',
+        lastQuickCheck: now,
+        lastMediumCheck: now,
+        lastDeepCheck: now,
+        observations: [],
+        currentThought: undefined,
+    };
+}
+// ─── Quick Check (No LLM) ────────────────────────────────────────────
+async function runQuickCheck(state, callbacks) {
+    state.phase = 'quick';
+    state.currentThought = 'Scanning project state...';
+    callbacks.pushEvent('thinking_update', {
+        phase: 'quick', observation: state.currentThought, timestamp: Date.now(),
+    });
+    try {
+        // 1. Capture project state (fast, no LLM)
+        const projectState = await callbacks.captureProjectState();
+        // 2. Check for anomalies in own behavior
+        const anomaly = detectAnomalousPattern(getRecentAudit());
+        if (anomaly.detected) {
+            addObservation(state, {
+                type: 'pattern_detected',
+                summary: `Anomaly: ${anomaly.description}`,
+                severity: anomaly.severity === 'critical' ? 'critical' : 'high',
+            });
+            callbacks.updateIdentity({ type: 'anomaly_detected', description: anomaly.description || '' });
+        }
+        // 3. Check scheduled tasks
+        const scheduledTasks = callbacks.getScheduledTasks();
+        for (const s of scheduledTasks) {
+            addObservation(state, {
+                type: 'schedule_due',
+                summary: `Scheduled: ${s.taskTitle}`,
+                severity: 'info',
+            });
+        }
+        // 4. Detect project changes
+        const delta = {
+            filesChanged: [],
+            newCommits: 0,
+            bugsChanged: false,
+            testsChanged: false,
+            depsChanged: false,
+            branchChanged: false,
+        };
+        // Check triggers
+        const triggerResults = callbacks.checkTriggers(delta);
+        for (const t of triggerResults) {
+            addObservation(state, {
+                type: 'trigger_fired',
+                summary: `Trigger: ${t.name} — ${t.context}`,
+                severity: 'medium',
+            });
+        }
+        // 5. Check project health
+        if (projectState.health < 50) {
+            addObservation(state, {
+                type: 'health_change',
+                summary: `Project health low: ${projectState.health}/100`,
+                details: `Modified: ${projectState.gitStatus.modified}, Bugs: ${projectState.openBugs}`,
+                severity: projectState.health < 30 ? 'high' : 'medium',
+            });
+        }
+        // 6. Check user frustration level
+        const mood = callbacks.getMoodAnalysis();
+        if (mood.frustrationLevel > 0.7) {
+            addObservation(state, {
+                type: 'pattern_detected',
+                summary: `User frustration high: ${(mood.frustrationLevel * 100).toFixed(0)}% — mood: ${mood.current}, trend: ${mood.trend}`,
+                severity: 'high',
+            });
+            callbacks.pushEvent('sentiment_detected', {
+                sentiment: mood.current,
+                frustrationLevel: mood.frustrationLevel,
+                trend: mood.trend,
+                timestamp: Date.now(),
+            });
+        }
+        // 7. Check open bugs
+        if (projectState.openBugs > 0) {
+            addObservation(state, {
+                type: 'bug_detected',
+                summary: `${projectState.openBugs} open bugs`,
+                severity: projectState.openBugs > 5 ? 'high' : 'low',
+            });
+        }
+    }
+    catch (err) {
+        // Quick check should never crash the loop
+        state.currentThought = `Quick check error: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    state.lastQuickCheck = Date.now();
+    state.phase = 'idle';
+    state.currentThought = undefined;
+}
+// ─── Medium Check (1 LLM Call) ────────────────────────────────────────
+async function runMediumCheck(state, callbacks) {
+    state.phase = 'medium';
+    state.currentThought = 'Analyzing project for improvements...';
+    callbacks.pushEvent('thinking_update', {
+        phase: 'medium', observation: state.currentThought, timestamp: Date.now(),
+    });
+    try {
+        // Gather unhandled observations
+        const unhandled = state.observations.filter(o => !o.handled);
+        if (unhandled.length === 0) {
+            state.lastMediumCheck = Date.now();
+            state.phase = 'idle';
+            state.currentThought = undefined;
+            return;
+        }
+        // Build analysis prompt
+        const observationList = unhandled
+            .map(o => `- [${o.severity}] ${o.summary}${o.details ? ': ' + o.details : ''}`)
+            .join('\n');
+        const identity = callbacks.getIdentity();
+        const mood = callbacks.getMoodAnalysis();
+        const moodContext = mood.sessionReadings > 0
+            ? `\nUser mood: ${mood.current} (trend: ${mood.trend}, frustration: ${(mood.frustrationLevel * 100).toFixed(0)}%)`
+            : '';
+        const prompt = `You are Jarvis, an autonomous AI assistant analyzing project observations.
+
+Your personality traits: confidence=${identity.traits.confidence.toFixed(2)}, caution=${identity.traits.caution.toFixed(2)}, proactivity=${identity.traits.proactivity.toFixed(2)}, empathy=${identity.traits.empathy.toFixed(2)}${moodContext}
+
+Recent observations:
+${observationList}
+
+Based on these observations, suggest 0-3 actionable proposals.
+For each proposal, respond in this exact format (one per line):
+PROPOSAL: <category> | <impact:low/medium/high> | <title> | <description> | <rationale>
+
+Valid categories: bugfix, refactor, test, dependency, security, performance, documentation, feature, cleanup, review, infrastructure, style
+
+If no proposals are warranted, respond with: NO_PROPOSALS
+
+Be selective — only propose actions that provide clear value. Your proactivity level is ${identity.traits.proactivity.toFixed(2)} (higher = more proposals).`;
+        const response = await callbacks.sendMessage(prompt);
+        if (callbacks.isAborted())
+            return;
+        // Parse proposals from response
+        const lines = response.split('\n');
+        for (const line of lines) {
+            const match = line.match(/^PROPOSAL:\s*(\w+)\s*\|\s*(\w+)\s*\|\s*(.+?)\s*\|\s*(.+?)\s*\|\s*(.+)$/);
+            if (!match)
+                continue;
+            const [, category, impact, title, description, rationale] = match;
+            const cat = category;
+            const files = []; // Could extract from description
+            // Check denial patterns before creating
+            if (callbacks.wouldLikelyBeDenied(cat, files)) {
+                continue; // Skip — user has repeatedly denied this type
+            }
+            callbacks.createProposal(title, description, rationale, {
+                category: cat,
+                source: 'thinking_medium',
+                impact: impact,
+                risk: 'low',
+                affectedFiles: files,
+            });
+            // Fire neuron event for brain visualization
+            callbacks.pushEvent('neuron_fired', {
+                fromOrbit: 'yellow', trigger: 'proposal', count: 1,
+            });
+        }
+        // Mark observations as handled
+        for (const o of unhandled) {
+            o.handled = true;
+        }
+        // Skill-gap detection: check if recent tasks had poor skill coverage
+        if (callbacks.getSkillScores) {
+            const recentTaskDescs = unhandled
+                .filter(o => o.type === 'pattern_detected' || o.type === 'bug_detected')
+                .map(o => o.summary);
+            for (const desc of recentTaskDescs.slice(0, 3)) {
+                const scores = callbacks.getSkillScores(desc);
+                const bestScore = scores.length > 0 ? Math.max(...scores.map(s => s.totalScore)) : 0;
+                if (bestScore < 0.5 && !callbacks.wouldLikelyBeDenied('skill_creation', [])) {
+                    callbacks.createProposal(`Create skill for: ${desc.slice(0, 50)}`, `No existing skill scores above 0.5 for this pattern. Best score: ${bestScore.toFixed(2)}. Consider creating a specialized skill.`, 'Skill-gap detected by adaptive engine during medium check.', {
+                        category: 'skill_creation',
+                        source: 'thinking_medium',
+                        impact: 'medium',
+                        risk: 'low',
+                    });
+                }
+            }
+        }
+    }
+    catch (err) {
+        state.currentThought = `Medium check error: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    state.lastMediumCheck = Date.now();
+    state.phase = 'idle';
+    state.currentThought = undefined;
+}
+// ─── Deep Check (Multi-LLM) ──────────────────────────────────────────
+async function runDeepCheck(state, callbacks) {
+    state.phase = 'deep';
+    state.currentThought = 'Deep thinking — analyzing patterns and self-assessing...';
+    callbacks.pushEvent('thinking_update', {
+        phase: 'deep', observation: state.currentThought, timestamp: Date.now(),
+    });
+    try {
+        const identity = callbacks.getIdentity();
+        // 1. Query spiral for own history
+        const spiralHistory = await callbacks.querySpiral('jarvis identity learnings proposals tasks', 2000);
+        if (callbacks.isAborted())
+            return;
+        // 2. Self-assessment prompt — includes capability inventory to prevent hallucination
+        const mood = callbacks.getMoodAnalysis();
+        const moodLine = mood.sessionReadings > 0
+            ? `\n- User mood: ${mood.current} (trend: ${mood.trend}, frustration: ${(mood.frustrationLevel * 100).toFixed(0)}%)`
+            : '';
+        const learningStats = callbacks.getLearningStats?.();
+        const learningLine = learningStats
+            ? `\n- Learning memory: ${learningStats.total} patterns (${learningStats.highConfidence} high-confidence). Top categories: ${Object.entries(learningStats.topCategories).map(([k, v]) => `${k}:${v}`).join(', ')}`
+            : '';
+        const selfAssessmentPrompt = `You are Jarvis performing a deep self-assessment.
+
+Your current identity:
+- Confidence: ${identity.traits.confidence.toFixed(2)}
+- Caution: ${identity.traits.caution.toFixed(2)}
+- Proactivity: ${identity.traits.proactivity.toFixed(2)}
+- Empathy: ${identity.traits.empathy.toFixed(2)}
+- Approval rate: ${(identity.trust.approvalRate * 100).toFixed(0)}%
+- Success rate: ${(identity.trust.successRate * 100).toFixed(0)}%
+- Total proposals: ${identity.trust.totalProposals}
+- Tasks completed: ${identity.trust.totalTasksCompleted}${moodLine}${learningLine}
+
+IMPORTANT — Your EXISTING capabilities (these are IMPLEMENTED, do NOT claim they are missing):
+- 22 agent tools: read/write/edit_file, list_dir, search/find_files, run_command, git_*, spiral_*, web_research, bug_report, bug_list, browser_*
+- Task Queue + Daemon: background task processing with priority ordering and retry
+- Thinking Loop: Quick (30s), Medium (5m), Deep (30m) continuous consciousness
+- World Model: ProjectModel with git status, open bugs, test results, health score (0-100), ProjectDelta tracking
+- Proposal System: 14 categories with denial learning (wouldLikelyBeDenied)
+- Skill System: discover, install, activate, deactivate, remove, CREATE new skills at runtime
+- Identity Evolution: 6 traits (confidence, caution, proactivity, verbosity, creativity, empathy) that adjust automatically
+- Sentiment Analysis: keyword-based mood detection (DE+EN), trend tracking, response guidance injection
+- Web Knowledge Enricher: auto-fetches DuckDuckGo results, stores in spiral brain
+- Browser Control: puppeteer-core with 6 browser tools and VisionProcessor
+- Telegram Bot: bidirectional polling with inline approve/deny buttons
+- Notifications: browser, email, slack, webhook, system, telegram channels
+- Scheduling: cron, interval, one-time tasks
+- Triggers: file_watch, git_hook, ci, webhook, time-based reactions
+- Meta-Cognition: self-assessment, META_LEARNING events, anomaly detection
+- Ethics: autonomy levels L0-L5, built-in ethical boundaries
+- Bug Journal: auto-detection from user messages (DE+EN)
+- Failure Memory: error→solution pairs with confidence scoring, auto-decay, spiral promotion
+- Multi-Agent Orchestration: task splitting into parallel sub-agents with file-lock protection
+- Adaptive Skill Engine: skill scoring, effectiveness tracking, auto-selection
+- Telemetry: opt-in anonymized learning aggregation (privacy levels 0-3)
+
+Recent learnings:
+${identity.recentLearnings.slice(-10).map(l => `- [${l.source}] ${l.content}`).join('\n')}
+
+Spiral memory context:
+${spiralHistory}
+
+Analyze:
+1. What patterns do you see in your approvals vs denials?
+2. What should you do more of? Less of?
+3. Any strategic proposals for the project? (Focus on the USER'S project, not on your own features.)
+4. Does the user need a SPECIFIC integration or workflow that is NOT in your capability list above?
+   Only propose skill_creation for genuinely missing domain-specific integrations (e.g. a specific API the user needs).
+   Do NOT propose features that already exist in the list above — that would be hallucination.
+
+CRITICAL: Never claim a capability is missing if it appears in the list above. Review the list before answering.
+
+Respond in this format:
+INSIGHT: <your key insight>
+META_LEARNING: <what you learned about yourself>
+PROPOSAL: <category> | <impact> | <title> | <description> | <rationale>
+(0-2 strategic proposals only, use category "skill_creation" ONLY for genuinely missing domain-specific integrations)`;
+        const response = await callbacks.sendMessage(selfAssessmentPrompt);
+        if (callbacks.isAborted())
+            return;
+        // Parse deep thinking results
+        for (const line of response.split('\n')) {
+            const insightMatch = line.match(/^INSIGHT:\s*(.+)$/);
+            if (insightMatch) {
+                callbacks.pushEvent('consciousness_event', {
+                    type: 'insight', content: insightMatch[1], depth: 'deep', timestamp: Date.now(),
+                });
+                // Store insight in spiral
+                await callbacks.storeInSpiral(`Jarvis Insight: ${insightMatch[1]}`, 'pattern', ['jarvis_identity', 'jarvis_insight']);
+                callbacks.pushEvent('jarvis_learning', {
+                    topic: 'self-assessment',
+                    content: insightMatch[1],
+                    spiralLevel: 2,
+                    tags: ['jarvis_insight'],
+                    sourcePhase: 'deep',
+                });
+            }
+            const metaMatch = line.match(/^META_LEARNING:\s*(.+)$/);
+            if (metaMatch) {
+                callbacks.updateIdentity({ type: 'meta_learning', insight: metaMatch[1] });
+                callbacks.pushEvent('consciousness_event', {
+                    type: 'meta_learning', content: metaMatch[1], depth: 'deep', timestamp: Date.now(),
+                });
+            }
+            const proposalMatch = line.match(/^PROPOSAL:\s*(\w+)\s*\|\s*(\w+)\s*\|\s*(.+?)\s*\|\s*(.+?)\s*\|\s*(.+)$/);
+            if (proposalMatch) {
+                const [, category, impact, title, description, rationale] = proposalMatch;
+                const cat = category;
+                if (!callbacks.wouldLikelyBeDenied(cat, [])) {
+                    callbacks.createProposal(title, description, rationale, {
+                        category: cat,
+                        source: 'thinking_deep',
+                        impact: impact,
+                        risk: 'low',
+                    });
+                }
+            }
+        }
+        // Fire neuron event
+        callbacks.pushEvent('neuron_fired', {
+            fromOrbit: 'green', trigger: 'thinking', count: 3,
+        });
+    }
+    catch (err) {
+        state.currentThought = `Deep check error: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    state.lastDeepCheck = Date.now();
+    state.phase = 'idle';
+    state.currentThought = undefined;
+}
+// ─── Main Loop ────────────────────────────────────────────────────────
+/**
+ * Run the thinking loop. Replaces the daemon's idle sleep.
+ * Returns when aborted or when a task becomes available.
+ *
+ * @param callbacks - All dependencies injected via callbacks
+ * @param hasTaskAvailable - Check if there's a task to execute (yields thinking)
+ * @returns The current thinking state for persistence
+ */
+export async function runThinkingLoop(callbacks, hasTaskAvailable) {
+    const state = createInitialState();
+    while (!callbacks.isAborted()) {
+        // Yield to task execution if a task is available
+        if (hasTaskAvailable()) {
+            state.phase = 'idle';
+            state.currentThought = undefined;
+            return state;
+        }
+        // Handle pause
+        if (callbacks.isPaused()) {
+            await sleep(TICK_SLEEP_MS);
+            continue;
+        }
+        const now = Date.now();
+        // Deep check (30m) — least frequent, most expensive
+        if (now - state.lastDeepCheck >= DEEP_INTERVAL_MS) {
+            await runDeepCheck(state, callbacks);
+            if (callbacks.isAborted() || hasTaskAvailable())
+                break;
+        }
+        // Medium check (5m) — moderate, 1 LLM call
+        if (now - state.lastMediumCheck >= MEDIUM_INTERVAL_MS) {
+            await runMediumCheck(state, callbacks);
+            if (callbacks.isAborted() || hasTaskAvailable())
+                break;
+        }
+        // Quick check (30s) — frequent, no LLM
+        if (now - state.lastQuickCheck >= QUICK_INTERVAL_MS) {
+            await runQuickCheck(state, callbacks);
+            if (callbacks.isAborted() || hasTaskAvailable())
+                break;
+            // Fire neuron on every quick check
+            callbacks.pushEvent('neuron_fired', {
+                fromOrbit: 'green', trigger: 'thinking', count: 1,
+            });
+        }
+        // Sleep between ticks
+        await sleep(TICK_SLEEP_MS);
+    }
+    state.phase = 'idle';
+    state.currentThought = undefined;
+    return state;
+}
+/**
+ * Run a single deep thinking cycle on demand (/jarvis think).
+ */
+export async function runImmediateDeepThink(callbacks) {
+    const state = createInitialState();
+    // Run quick first to gather observations
+    await runQuickCheck(state, callbacks);
+    if (callbacks.isAborted())
+        return;
+    // Then medium to analyze
+    await runMediumCheck(state, callbacks);
+    if (callbacks.isAborted())
+        return;
+    // Then deep for self-assessment
+    await runDeepCheck(state, callbacks);
+}
+// ─── Helpers ──────────────────────────────────────────────────────────
+function addObservation(state, opts) {
+    // Deduplicate by type + summary (within last 5 minutes)
+    const cutoff = Date.now() - 5 * 60_000;
+    const existing = state.observations.find(o => o.type === opts.type && o.summary === opts.summary && o.timestamp > cutoff);
+    if (existing)
+        return;
+    state.observations.push({
+        id: randomUUID().slice(0, 8),
+        type: opts.type,
+        summary: opts.summary,
+        details: opts.details,
+        severity: opts.severity,
+        timestamp: Date.now(),
+        handled: false,
+    });
+    // Prune old observations (keep last 100)
+    if (state.observations.length > 100) {
+        state.observations = state.observations.slice(-100);
+    }
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=thinking-loop.js.map