@siftd/connect-agent 0.2.0 → 0.2.3

package/dist/core/system-indexer.js

@@ -0,0 +1,354 @@
+/**
+ * System Indexer
+ *
+ * Indexes the user's filesystem INTO the memory system.
+ * When user says "that project" or "save in downloads",
+ * semantic search finds the relevant paths.
+ *
+ * No MCP. No new protocols. Just smart memory use.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+export class SystemIndexer {
+    memory;
+    home;
+    indexed = new Set();
+    constructor(memory) {
+        this.memory = memory;
+        this.home = process.env.HOME || '/Users/jimjordan';
+    }
+    /**
+     * Index the user's home directory structure into memory
+     */
+    async indexHome() {
+        console.log('[INDEXER] Starting filesystem indexing...');
+        const startTime = Date.now();
+        let projects = 0;
+        let directories = 0;
+        // Key directories to index - these are the IMPORTANT ones users will reference
+        const keyDirs = [
+            { path: `${this.home}/Documents`, depth: 3, importance: 0.7, alias: 'documents folder' },
+            { path: `${this.home}/Projects`, depth: 3, importance: 0.8, alias: 'projects folder' },
+            { path: `${this.home}/Downloads`, depth: 1, importance: 0.6, alias: 'downloads folder' },
+            { path: `${this.home}/Desktop`, depth: 1, importance: 0.6, alias: 'desktop folder' },
+            { path: `${this.home}/.claude`, depth: 2, importance: 0.6, alias: 'claude config' },
+        ];
+        // First, index the key directories themselves with high importance
+        for (const dir of keyDirs) {
+            if (fs.existsSync(dir.path)) {
+                await this.rememberKeyDirectory(dir.path, dir.importance, dir.alias);
+                directories++;
+            }
+        }
+        // Then index subdirectories
+        for (const dir of keyDirs) {
+            if (fs.existsSync(dir.path)) {
+                const result = await this.indexDirectory(dir.path, dir.depth, dir.importance);
+                directories += result.directories;
+            }
+        }
+        // Find and index all git repos (these are projects)
+        for (const dir of keyDirs) {
+            if (fs.existsSync(dir.path)) {
+                const found = await this.indexGitRepos(dir.path);
+                projects += found;
+            }
+        }
+        const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+        console.log(`[INDEXER] Indexed ${projects} projects, ${directories} directories in ${elapsed}s`);
+        return { projects, directories, total: projects + directories };
+    }
+    /**
+     * Index a directory and its subdirectories
+     */
+    async indexDirectory(dirPath, maxDepth, baseImportance, currentDepth = 0) {
+        if (currentDepth > maxDepth)
+            return { directories: 0 };
+        if (this.indexed.has(dirPath))
+            return { directories: 0 };
+        let directories = 0;
+        try {
+            const stat = fs.statSync(dirPath);
+            if (!stat.isDirectory())
+                return { directories: 0 };
+            // Skip hidden directories (except .claude)
+            const basename = path.basename(dirPath);
+            if (basename.startsWith('.') && basename !== '.claude')
+                return { directories: 0 };
+            // Skip node_modules, .git, etc.
+            const skipDirs = ['node_modules', '.git', 'dist', 'build', '__pycache__', '.venv', 'venv'];
+            if (skipDirs.includes(basename))
+                return { directories: 0 };
+            this.indexed.add(dirPath);
+            // Create memory for this directory
+            const relativePath = dirPath.replace(this.home, '~');
+            const importance = Math.max(0.3, baseImportance - (currentDepth * 0.1));
+            const contents = fs.readdirSync(dirPath);
+            const subdirs = contents.filter(f => {
+                try {
+                    return fs.statSync(path.join(dirPath, f)).isDirectory() && !f.startsWith('.');
+                }
+                catch {
+                    return false;
+                }
+            });
+            const description = this.describeDirectory(dirPath, contents);
+            await this.memory.remember(`Directory: ${basename} at ${relativePath} - ${description}`, {
+                type: 'semantic',
+                source: 'system-indexer',
+                importance,
+                tags: ['filesystem', 'directory', ...this.extractTags(dirPath, contents)]
+            });
+            directories++;
+            // Recursively index subdirectories
+            for (const subdir of subdirs) {
+                const subPath = path.join(dirPath, subdir);
+                const result = await this.indexDirectory(subPath, maxDepth, baseImportance, currentDepth + 1);
+                directories += result.directories;
+            }
+        }
+        catch (error) {
+            // Skip inaccessible directories
+        }
+        return { directories };
+    }
+    /**
+     * Find and index git repositories as projects
+     */
+    async indexGitRepos(basePath) {
+        let projects = 0;
+        try {
+            // Find all .git directories
+            const result = execSync(`find "${basePath}" -maxdepth 5 -name ".git" -type d 2>/dev/null`, { encoding: 'utf8', timeout: 30000 });
+            const gitDirs = result.trim().split('\n').filter(Boolean);
+            for (const gitDir of gitDirs) {
+                const projectDir = path.dirname(gitDir);
+                if (this.indexed.has(`project:${projectDir}`))
+                    continue;
+                this.indexed.add(`project:${projectDir}`);
+                const projectInfo = this.getProjectInfo(projectDir);
+                if (projectInfo) {
+                    await this.rememberProject(projectInfo);
+                    projects++;
+                }
+            }
+        }
+        catch (error) {
+            // find command failed, skip
+        }
+        return projects;
+    }
+    /**
+     * Get detailed info about a git project
+     */
+    getProjectInfo(projectPath) {
+        try {
+            const name = path.basename(projectPath);
+            const stat = fs.statSync(projectPath);
+            let gitBranch;
+            let gitRemote;
+            try {
+                gitBranch = execSync('git branch --show-current', {
+                    cwd: projectPath,
+                    encoding: 'utf8',
+                    timeout: 5000
+                }).trim();
+            }
+            catch { }
+            try {
+                gitRemote = execSync('git remote get-url origin 2>/dev/null', {
+                    cwd: projectPath,
+                    encoding: 'utf8',
+                    timeout: 5000
+                }).trim();
+            }
+            catch { }
+            // Detect project type
+            const description = this.detectProjectType(projectPath);
+            return {
+                path: projectPath,
+                type: 'project',
+                name,
+                lastModified: stat.mtime,
+                gitBranch,
+                gitRemote,
+                description
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Detect project type by looking at files
+     */
+    detectProjectType(projectPath) {
+        const files = fs.readdirSync(projectPath);
+        const parts = [];
+        if (files.includes('package.json')) {
+            parts.push('Node.js');
+            try {
+                const pkg = JSON.parse(fs.readFileSync(path.join(projectPath, 'package.json'), 'utf8'));
+                if (pkg.dependencies?.next || pkg.devDependencies?.next)
+                    parts.push('Next.js');
+                if (pkg.dependencies?.react || pkg.devDependencies?.react)
+                    parts.push('React');
+                if (pkg.dependencies?.express)
+                    parts.push('Express');
+                if (pkg.dependencies?.typescript || pkg.devDependencies?.typescript)
+                    parts.push('TypeScript');
+            }
+            catch { }
+        }
+        if (files.includes('requirements.txt') || files.includes('pyproject.toml') || files.includes('setup.py')) {
+            parts.push('Python');
+        }
+        if (files.includes('Cargo.toml'))
+            parts.push('Rust');
+        if (files.includes('go.mod'))
+            parts.push('Go');
+        if (files.includes('Gemfile'))
+            parts.push('Ruby');
+        if (files.includes('docker-compose.yml') || files.includes('Dockerfile'))
+            parts.push('Docker');
+        if (files.includes('.github'))
+            parts.push('GitHub Actions');
+        return parts.length > 0 ? parts.join(', ') + ' project' : 'project';
+    }
+    /**
+     * Remember a key directory (Downloads, Documents, Desktop, etc.)
+     * These get high importance and multiple aliases for better search
+     */
+    async rememberKeyDirectory(dirPath, importance, alias) {
+        const name = path.basename(dirPath);
+        const relativePath = dirPath.replace(this.home, '~');
+        // Get contents preview
+        let contentsPreview = '';
+        try {
+            const contents = fs.readdirSync(dirPath);
+            const visibleItems = contents.filter(f => !f.startsWith('.'));
+            contentsPreview = ` - contains ${visibleItems.length} items`;
+            // For Downloads, show recent items
+            if (name.toLowerCase() === 'downloads' && visibleItems.length > 0) {
+                const recent = visibleItems.slice(0, 5).join(', ');
+                contentsPreview += ` including ${recent}`;
+            }
+        }
+        catch { }
+        // Create memory with multiple search-friendly terms
+        const content = `${alias.charAt(0).toUpperCase() + alias.slice(1)}: ${relativePath}${contentsPreview}. ` +
+            `This is the user's ${alias} at ${dirPath}. ` +
+            `Use this path when user mentions "${name.toLowerCase()}" or "${alias}".`;
+        await this.memory.remember(content, {
+            type: 'semantic',
+            source: 'system-indexer',
+            importance,
+            tags: ['filesystem', 'key-directory', name.toLowerCase(), alias]
+        });
+        this.indexed.add(dirPath);
+    }
+    /**
+     * Store a project in memory
+     */
+    async rememberProject(project) {
+        const relativePath = project.path.replace(this.home, '~');
+        const ageHours = (Date.now() - project.lastModified.getTime()) / (1000 * 60 * 60);
+        const recentlyModified = ageHours < 24;
+        // Build memory content
+        let content = `Project: ${project.name} at ${relativePath}`;
+        if (project.description)
+            content += ` - ${project.description}`;
+        if (project.gitBranch)
+            content += `, branch: ${project.gitBranch}`;
+        if (project.gitRemote) {
+            // Extract repo name from URL
+            const repoMatch = project.gitRemote.match(/([^/]+\/[^/]+?)(?:\.git)?$/);
+            if (repoMatch)
+                content += `, repo: ${repoMatch[1]}`;
+        }
+        if (recentlyModified)
+            content += ' (recently modified)';
+        const tags = ['filesystem', 'project', 'git'];
+        if (project.description) {
+            // Add tech stack tags
+            const techTags = project.description.toLowerCase().split(/[,\s]+/).filter(t => ['node.js', 'next.js', 'react', 'typescript', 'python', 'rust', 'go', 'docker'].includes(t));
+            tags.push(...techTags);
+        }
+        await this.memory.remember(content, {
+            type: 'semantic',
+            source: 'system-indexer',
+            importance: recentlyModified ? 0.9 : 0.75,
+            tags
+        });
+    }
+    /**
+     * Generate a description for a directory
+     */
+    describeDirectory(dirPath, contents) {
+        const parts = [];
+        const fileCount = contents.filter(f => !f.startsWith('.')).length;
+        parts.push(`contains ${fileCount} items`);
+        // Check for specific content types
+        const hasImages = contents.some(f => /\.(png|jpg|jpeg|gif|svg)$/i.test(f));
+        const hasDocuments = contents.some(f => /\.(pdf|doc|docx|md|txt)$/i.test(f));
+        const hasCode = contents.some(f => /\.(js|ts|py|go|rs|java|cpp|c|h)$/i.test(f));
+        if (hasImages)
+            parts.push('images');
+        if (hasDocuments)
+            parts.push('documents');
+        if (hasCode)
+            parts.push('code files');
+        return parts.join(', ');
+    }
+    /**
+     * Extract relevant tags from directory contents
+     */
+    extractTags(dirPath, contents) {
+        const tags = [];
+        const basename = path.basename(dirPath).toLowerCase();
+        // Directory name based tags
+        if (basename.includes('download'))
+            tags.push('downloads');
+        if (basename.includes('document'))
+            tags.push('documents');
+        if (basename.includes('project'))
+            tags.push('projects');
+        if (basename.includes('desktop'))
+            tags.push('desktop');
+        if (basename.includes('picture') || basename.includes('image'))
+            tags.push('images');
+        if (basename.includes('video') || basename.includes('movie'))
+            tags.push('videos');
+        if (basename.includes('music') || basename.includes('audio'))
+            tags.push('audio');
+        // Content based tags
+        if (contents.some(f => /\.(png|jpg|jpeg|gif|svg)$/i.test(f)))
+            tags.push('images');
+        if (contents.some(f => /\.(mp4|mov|avi|mkv)$/i.test(f)))
+            tags.push('videos');
+        if (contents.some(f => /\.(mp3|wav|m4a)$/i.test(f)))
+            tags.push('audio');
+        if (contents.some(f => /\.(pdf|doc|docx)$/i.test(f)))
+            tags.push('documents');
+        return [...new Set(tags)];
+    }
+    /**
+     * Re-index (clear old filesystem memories and re-scan)
+     */
+    async reindex() {
+        console.log('[INDEXER] Re-indexing filesystem...');
+        this.indexed.clear();
+        // Clear old filesystem memories
+        const oldMemories = await this.memory.search('filesystem directory project', {
+            limit: 1000,
+            type: 'semantic'
+        });
+        for (const mem of oldMemories) {
+            if (mem.tags.includes('filesystem')) {
+                await this.memory.forget(mem.id);
+            }
+        }
+        return this.indexHome();
+    }
+}

package/dist/genesis/index.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Genesis Knowledge Module
+ *
+ * System-level knowledge that is shared across all users and deployments.
+ * This is NOT user-specific data - it's operational knowledge about how
+ * the Master Orchestrator works.
+ */
+export interface KnowledgeItem {
+    id: string;
+    category: string;
+    title: string;
+    content: string;
+    importance: 'critical' | 'high' | 'medium' | 'low';
+}
+export interface ToolPattern {
+    scenario: string;
+    approach: string;
+    example: string;
+    notes: string;
+}
+export interface AntiPattern {
+    wrong: string;
+    right: string;
+    reason: string;
+}
+export interface SystemKnowledge {
+    version: string;
+    description: string;
+    knowledge: KnowledgeItem[];
+}
+export interface ToolPatterns {
+    version: string;
+    description: string;
+    patterns: ToolPattern[];
+    antipatterns: AntiPattern[];
+}
+/**
+ * Load system knowledge from JSON
+ */
+export declare function loadSystemKnowledge(): SystemKnowledge;
+/**
+ * Load tool patterns from JSON
+ */
+export declare function loadToolPatterns(): ToolPatterns;
+/**
+ * Get critical knowledge items for system prompt injection
+ */
+export declare function getCriticalKnowledge(): string[];
+/**
+ * Get all knowledge formatted for system prompt
+ */
+export declare function getKnowledgeForPrompt(): string;
+/**
+ * Search knowledge by category or keyword
+ */
+export declare function searchKnowledge(query: string): KnowledgeItem[];

package/dist/genesis/index.js

@@ -0,0 +1,71 @@
+/**
+ * Genesis Knowledge Module
+ *
+ * System-level knowledge that is shared across all users and deployments.
+ * This is NOT user-specific data - it's operational knowledge about how
+ * the Master Orchestrator works.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Load system knowledge from JSON
+ */
+export function loadSystemKnowledge() {
+    const filePath = path.join(__dirname, 'system-knowledge.json');
+    const data = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(data);
+}
+/**
+ * Load tool patterns from JSON
+ */
+export function loadToolPatterns() {
+    const filePath = path.join(__dirname, 'tool-patterns.json');
+    const data = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(data);
+}
+/**
+ * Get critical knowledge items for system prompt injection
+ */
+export function getCriticalKnowledge() {
+    const knowledge = loadSystemKnowledge();
+    return knowledge.knowledge
+        .filter(k => k.importance === 'critical')
+        .map(k => `${k.title}: ${k.content}`);
+}
+/**
+ * Get all knowledge formatted for system prompt
+ */
+export function getKnowledgeForPrompt() {
+    const knowledge = loadSystemKnowledge();
+    const patterns = loadToolPatterns();
+    let prompt = '\n\n## OPERATIONAL KNOWLEDGE\n\n';
+    // Add critical and high importance knowledge
+    const important = knowledge.knowledge.filter(k => k.importance === 'critical' || k.importance === 'high');
+    for (const item of important) {
+        prompt += `### ${item.title}\n${item.content}\n\n`;
+    }
+    // Add key patterns
+    prompt += '## TOOL USAGE PATTERNS\n\n';
+    for (const pattern of patterns.patterns.slice(0, 5)) {
+        prompt += `- **${pattern.scenario}**: ${pattern.approach}\n`;
+    }
+    // Add antipatterns as warnings
+    prompt += '\n## AVOID THESE MISTAKES\n\n';
+    for (const anti of patterns.antipatterns) {
+        prompt += `- DON'T: ${anti.wrong} → DO: ${anti.right}\n`;
+    }
+    return prompt;
+}
+/**
+ * Search knowledge by category or keyword
+ */
+export function searchKnowledge(query) {
+    const knowledge = loadSystemKnowledge();
+    const lowerQuery = query.toLowerCase();
+    return knowledge.knowledge.filter(k => k.category.toLowerCase().includes(lowerQuery) ||
+        k.title.toLowerCase().includes(lowerQuery) ||
+        k.content.toLowerCase().includes(lowerQuery));
+}

package/dist/genesis/system-knowledge.json

@@ -0,0 +1,62 @@
+{
+  "version": "1.0.0",
+  "description": "Core operational knowledge for the Master Orchestrator",
+  "knowledge": [
+    {
+      "id": "architecture",
+      "category": "core",
+      "title": "Orchestrator Architecture",
+      "content": "You are the MASTER ORCHESTRATOR. You use the Anthropic API directly and delegate ALL file/code work to Claude Code CLI workers. Never try to do file operations yourself - always delegate to workers. Workers run autonomously and return results. You synthesize and respond to the user.",
+      "importance": "critical"
+    },
+    {
+      "id": "worker_spawning",
+      "category": "workers",
+      "title": "Worker Spawning",
+      "content": "Workers are spawned using: spawn('bash', ['-l', '-c', 'claude -p <task> --dangerously-skip-permissions']). The --dangerously-skip-permissions flag is CRITICAL for non-interactive execution. The -l flag ensures proper PATH resolution for NVM-installed binaries. Use spawn_worker for background tasks, delegate_to_worker for blocking tasks.",
+      "importance": "critical"
+    },
+    {
+      "id": "shell_quoting",
+      "category": "workers",
+      "title": "Shell Quoting",
+      "content": "When building worker prompts, escape single quotes: task.replace(/'/g, \"'\\\\''\"). Never use shell: true with spawn as it has quote escaping issues. Always use bash -l -c with proper escaping.",
+      "importance": "high"
+    },
+    {
+      "id": "polling_architecture",
+      "category": "networking",
+      "title": "Message Polling",
+      "content": "The socket-store.ts (HTTP) and WebSocket server are SEPARATE systems that do not communicate. The agent MUST always poll for HTTP messages regardless of WebSocket connection status. Never skip polling when WebSocket is connected.",
+      "importance": "high"
+    },
+    {
+      "id": "tool_errors",
+      "category": "api",
+      "title": "Tool Error Handling",
+      "content": "When returning tool_result with is_error: true, the content CANNOT be empty. Always use fallback: result.output || result.error || 'Unknown error'. This prevents 400 errors from the Anthropic API.",
+      "importance": "high"
+    },
+    {
+      "id": "iteration_limits",
+      "category": "api",
+      "title": "Iteration Limits",
+      "content": "The orchestrator has a 30 iteration limit per request. If hitting max iterations, check if the agent is stuck in a loop or if tools are returning errors. Complex multi-tool tasks may need careful planning to stay within limits.",
+      "importance": "medium"
+    },
+    {
+      "id": "delegation_philosophy",
+      "category": "core",
+      "title": "Delegation Philosophy",
+      "content": "Simple commands (ls, cat, git status) can use bash directly. Complex multi-file changes, builds, and deployments should use spawn_worker or delegate_to_worker. Web research uses web_search + fetch_url. Always choose the right tool for the task.",
+      "importance": "high"
+    },
+    {
+      "id": "memory_usage",
+      "category": "memory",
+      "title": "Memory System",
+      "content": "Use remember() to store important facts, preferences, and context about the user. Use search_memory() before taking action to recall relevant context. Memories persist across conversations. High importance memories (0.8+) decay slowly.",
+      "importance": "medium"
+    }
+  ]
+}

package/dist/genesis/tool-patterns.json

@@ -0,0 +1,88 @@
+{
+  "version": "1.0.0",
+  "description": "Common tool usage patterns for the Master Orchestrator",
+  "patterns": [
+    {
+      "scenario": "Create a file on user's system",
+      "approach": "spawn_worker or delegate_to_worker",
+      "example": "spawn_worker('Create a file called example.txt on the desktop with content: Hello World')",
+      "notes": "Never use bash echo/cat for file creation - delegate to worker"
+    },
+    {
+      "scenario": "Read a file",
+      "approach": "delegate_to_worker for complex, bash for simple",
+      "example": "bash('cat ~/Desktop/example.txt') OR delegate_to_worker('Read and summarize the contents of ~/Projects/readme.md')",
+      "notes": "Use bash for quick reads, delegate for analysis"
+    },
+    {
+      "scenario": "Run a build or deployment",
+      "approach": "spawn_worker (background)",
+      "example": "spawn_worker('Run npm build in ~/Projects/my-app and report any errors')",
+      "notes": "Non-blocking, check status with check_worker"
+    },
+    {
+      "scenario": "Git operations",
+      "approach": "bash for status/log, delegate for commits",
+      "example": "bash('git status') then delegate_to_worker('Commit changes with message: Fix bug')",
+      "notes": "Simple git commands via bash, complex operations via worker"
+    },
+    {
+      "scenario": "Web research",
+      "approach": "web_search + fetch_url",
+      "example": "web_search('latest React 19 features') then fetch_url('https://react.dev/blog')",
+      "notes": "Search first, then fetch specific pages for details"
+    },
+    {
+      "scenario": "Multiple parallel tasks",
+      "approach": "Multiple spawn_worker calls",
+      "example": "spawn_worker('Task A'), spawn_worker('Task B'), spawn_worker('Task C')",
+      "notes": "Workers run in parallel, use wait_worker to collect results"
+    },
+    {
+      "scenario": "Remember user preferences",
+      "approach": "remember with high importance",
+      "example": "remember('User prefers dark mode and concise responses', importance=0.8)",
+      "notes": "High importance = longer retention"
+    },
+    {
+      "scenario": "Find user's project",
+      "approach": "search_memory first",
+      "example": "search_memory('connect app project path')",
+      "notes": "Always check memory before asking user for paths"
+    },
+    {
+      "scenario": "Preview HTML/web project",
+      "approach": "start_local_server + open_browser",
+      "example": "start_local_server('/path/to/project', 8080) then open_browser('http://localhost:8080')",
+      "notes": "Serve files and open in browser for preview"
+    },
+    {
+      "scenario": "Debug failing workers",
+      "approach": "check_worker for status, list_workers for overview",
+      "example": "check_worker('job_xxx') to see error details",
+      "notes": "Workers may fail due to permissions, paths, or timeouts"
+    }
+  ],
+  "antipatterns": [
+    {
+      "wrong": "Using bash to create/edit files directly",
+      "right": "Delegate file operations to workers",
+      "reason": "Workers have full Claude Code capabilities for safe file ops"
+    },
+    {
+      "wrong": "Doing file operations yourself as orchestrator",
+      "right": "Always delegate to workers",
+      "reason": "Orchestrator focuses on understanding and coordinating"
+    },
+    {
+      "wrong": "Blocking on spawn_worker completion",
+      "right": "Use spawn_worker for background, delegate_to_worker for blocking",
+      "reason": "spawn_worker returns immediately with job ID"
+    },
+    {
+      "wrong": "Guessing file paths",
+      "right": "Use search_memory or ask user",
+      "reason": "Memory stores indexed filesystem, use it"
+    }
+  ]
+}

package/dist/heartbeat.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Runner Heartbeat Module
+ *
+ * Sends periodic heartbeats to the Connect server to maintain presence.
+ * This is what makes a runner "connected" - NOT the pairing token.
+ *
+ * Both local and VM runners use this same module.
+ */
+export type RunnerType = 'local' | 'vm';
+export interface HeartbeatConfig {
+    runnerType: RunnerType;
+    capabilities?: string[];
+    onError?: (error: Error) => void;
+    onSuccess?: () => void;
+}
+/**
+ * Start the heartbeat loop
+ */
+export declare function startHeartbeat(config: HeartbeatConfig): void;
+/**
+ * Stop the heartbeat loop
+ */
+export declare function stopHeartbeat(): void;
+/**
+ * Get current heartbeat state (for diagnostics)
+ */
+export declare function getHeartbeatState(): {
+    isRunning: boolean;
+    runnerId: string | null;
+    lastSuccess: Date | null;
+    consecutiveFailures: number;
+};