grov 0.5.11 → 0.6.13

package/dist/cli/agents/registry.d.ts

@@ -0,0 +1,17 @@
+export type AgentType = 'cli' | 'ide';
+export interface CliAgent {
+    id: string;
+    name: string;
+    description: string;
+    type: AgentType;
+    command: string;
+    requirements: string[];
+    configPath: string;
+    isConfigured: () => boolean;
+}
+export declare function getAllCliAgents(): CliAgent[];
+export declare function getCliAgentsByType(type: AgentType): CliAgent[];
+export declare function getCliAgentById(id: string): CliAgent | undefined;
+export declare function isAnyAgentConfigured(): boolean;
+export declare function getConfiguredAgents(): CliAgent[];
+export declare function getFirstConfiguredAgent(): CliAgent | null;

package/dist/cli/agents/registry.js

@@ -0,0 +1,132 @@
+// Centralized agent registry for CLI operations
+// Add new agents here - all CLI commands will see them
+import { existsSync, readFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { parse } from 'smol-toml';
+const CLAUDE_SETTINGS_PATH = join(homedir(), '.claude', 'settings.json');
+const CODEX_CONFIG_PATH = join(homedir(), '.codex', 'config.toml');
+const CURSOR_MCP_PATH = join(homedir(), '.cursor', 'mcp.json');
+const ZED_SETTINGS_PATH = join(homedir(), '.config', 'zed', 'settings.json');
+const ANTIGRAVITY_MCP_PATH = join(homedir(), '.gemini', 'antigravity', 'mcp_config.json');
+const AGENTS = [
+    {
+        id: 'claude',
+        name: 'Claude Code',
+        description: "Anthropic's coding agent",
+        type: 'cli',
+        command: 'claude',
+        requirements: ['Claude Code CLI (npm i -g @anthropic-ai/claude-code)'],
+        configPath: CLAUDE_SETTINGS_PATH,
+        isConfigured: () => {
+            if (!existsSync(CLAUDE_SETTINGS_PATH))
+                return false;
+            try {
+                const settings = JSON.parse(readFileSync(CLAUDE_SETTINGS_PATH, 'utf-8'));
+                return settings.env?.ANTHROPIC_BASE_URL === 'http://127.0.0.1:8080';
+            }
+            catch {
+                return false;
+            }
+        },
+    },
+    {
+        id: 'codex',
+        name: 'Codex',
+        description: "OpenAI's CLI agent",
+        type: 'cli',
+        command: 'codex',
+        requirements: ['OPENAI_API_KEY environment variable', 'Codex CLI (npm i -g @openai/codex)'],
+        configPath: CODEX_CONFIG_PATH,
+        isConfigured: () => {
+            if (!existsSync(CODEX_CONFIG_PATH))
+                return false;
+            try {
+                const content = readFileSync(CODEX_CONFIG_PATH, 'utf-8');
+                const config = parse(content);
+                return config.model_provider === 'grov' && !!config.model_providers?.grov;
+            }
+            catch {
+                return false;
+            }
+        },
+    },
+    {
+        id: 'cursor',
+        name: 'Cursor',
+        description: 'Cursor IDE',
+        type: 'ide',
+        command: 'cursor',
+        requirements: ['Cursor IDE installed'],
+        configPath: CURSOR_MCP_PATH,
+        isConfigured: () => {
+            if (!existsSync(CURSOR_MCP_PATH))
+                return false;
+            try {
+                const config = JSON.parse(readFileSync(CURSOR_MCP_PATH, 'utf-8'));
+                return !!config.mcpServers?.grov;
+            }
+            catch {
+                return false;
+            }
+        },
+    },
+    {
+        id: 'zed',
+        name: 'Zed',
+        description: 'Zed Editor',
+        type: 'ide',
+        command: 'zed',
+        requirements: ['Zed Editor installed'],
+        configPath: ZED_SETTINGS_PATH,
+        isConfigured: () => {
+            if (!existsSync(ZED_SETTINGS_PATH))
+                return false;
+            try {
+                const config = JSON.parse(readFileSync(ZED_SETTINGS_PATH, 'utf-8'));
+                return !!config.context_servers?.grov;
+            }
+            catch {
+                return false;
+            }
+        },
+    },
+    {
+        id: 'antigravity',
+        name: 'Antigravity',
+        description: 'Google Antigravity IDE',
+        type: 'ide',
+        command: 'antigravity',
+        requirements: ['Antigravity IDE installed'],
+        configPath: ANTIGRAVITY_MCP_PATH,
+        isConfigured: () => {
+            if (!existsSync(ANTIGRAVITY_MCP_PATH))
+                return false;
+            try {
+                const config = JSON.parse(readFileSync(ANTIGRAVITY_MCP_PATH, 'utf-8'));
+                return !!config.mcpServers?.grov;
+            }
+            catch {
+                return false;
+            }
+        },
+    },
+];
+export function getAllCliAgents() {
+    return AGENTS;
+}
+export function getCliAgentsByType(type) {
+    return AGENTS.filter(a => a.type === type);
+}
+export function getCliAgentById(id) {
+    return AGENTS.find(a => a.id === id);
+}
+export function isAnyAgentConfigured() {
+    return AGENTS.some(a => a.isConfigured());
+}
+export function getConfiguredAgents() {
+    return AGENTS.filter(a => a.isConfigured());
+}
+export function getFirstConfiguredAgent() {
+    return AGENTS.find(a => a.isConfigured()) ?? null;
+}

package/dist/cli/commands/agents.d.ts

@@ -0,0 +1 @@
+export declare function agents(): void;

package/dist/cli/commands/agents.js

@@ -0,0 +1,48 @@
+// grov agents - List supported agents and setup instructions
+import { getCliAgentsByType } from '../agents/registry.js';
+const green = '\x1b[32m';
+const dim = '\x1b[90m';
+const cyan = '\x1b[36m';
+const reset = '\x1b[0m';
+export function agents() {
+    const cliAgents = getCliAgentsByType('cli');
+    const ideAgents = getCliAgentsByType('ide');
+    console.log('\nSupported Agents');
+    console.log('================\n');
+    console.log('CLI AGENTS (require proxy running)');
+    console.log('──────────────────────────────────');
+    for (const agent of cliAgents) {
+        printAgent(agent);
+    }
+    console.log('IDE AGENTS (native integration, no proxy)');
+    console.log('─────────────────────────────────────────');
+    for (const agent of ideAgents) {
+        printAgent(agent);
+    }
+    console.log('Quick Start');
+    console.log('───────────\n');
+    console.log(`${cyan}CLI AGENTS${reset} (Claude Code, Codex):`);
+    console.log('  1. grov init <agent>');
+    console.log('  2. grov proxy (keep running)');
+    console.log('  3. Use agent in another terminal\n');
+    console.log(`${cyan}IDE AGENTS${reset} (Cursor, Zed):`);
+    console.log('  1. grov init <agent>');
+    console.log('  2. Restart your IDE');
+    console.log('  3. Use normally - grov runs automatically\n');
+    console.log(`Troubleshooting: ${cyan}grov doctor <agent>${reset} for detailed checks\n`);
+}
+function printAgent(agent) {
+    const configured = agent.isConfigured();
+    const statusIcon = configured ? `${green}●${reset}` : `${dim}○${reset}`;
+    const statusText = configured ? `${green}Configured${reset}` : `${dim}Not configured${reset}`;
+    console.log(`${statusIcon} ${agent.name} - ${agent.description}`);
+    console.log(`   Status: ${statusText}`);
+    if (!configured) {
+        console.log(`   Setup:  grov init ${agent.id}`);
+        console.log('   Requires:');
+        for (const req of agent.requirements) {
+            console.log(`     • ${req}`);
+        }
+    }
+    console.log('');
+}

package/dist/cli/commands/disable.d.ts

@@ -0,0 +1 @@
+export declare function disable(agentName?: 'claude' | 'codex' | 'cursor' | 'antigravity' | 'zed'): Promise<void>;

package/dist/cli/commands/disable.js

@@ -0,0 +1,179 @@
+// grov disable - Remove proxy/MCP configuration
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { getAgentByName } from '../../integrations/proxy/agents/index.js';
+import { removeProjectRulesPointer } from '../../integrations/mcp/clients/cursor/rules-installer.js';
+export async function disable(agentName = 'claude') {
+    // Cursor: MCP-based disable
+    if (agentName === 'cursor') {
+        console.log('Disabling grov for Cursor...\n');
+        // 1. Remove MCP registration (global)
+        const mcpResult = removeCursorMcp();
+        // 2. Remove stop hook (global)
+        const hooksResult = removeCursorHooks();
+        // 3. Remove project rules pointer (keeps .grov/)
+        const projectDir = process.cwd();
+        const pointerRemoved = removeProjectRulesPointer(projectDir);
+        if (mcpResult) {
+            console.log('  - MCP server unregistered');
+        }
+        else {
+            console.log('  = MCP server was not registered');
+        }
+        if (hooksResult) {
+            console.log('  - Stop hook removed');
+        }
+        else {
+            console.log('  = Stop hook was not configured');
+        }
+        if (pointerRemoved) {
+            console.log('  - Removed .cursor/rules/90_grov.mdc');
+        }
+        else {
+            console.log('  = .cursor/rules/90_grov.mdc was not present');
+        }
+        console.log('\n.grov/ folder preserved (contains your rules).');
+        console.log('Restart Cursor to apply changes.');
+        return;
+    }
+    // Antigravity: MCP-based disable
+    if (agentName === 'antigravity') {
+        console.log('Disabling grov for Antigravity...\n');
+        const mcpResult = removeAntigravityMcp();
+        if (mcpResult) {
+            console.log('  - MCP server unregistered');
+        }
+        else {
+            console.log('  = MCP server was not registered');
+        }
+        console.log('\nRestart Antigravity to apply changes.');
+        return;
+    }
+    // Zed: MCP-based disable
+    if (agentName === 'zed') {
+        console.log('Disabling grov for Zed...\n');
+        const mcpResult = removeZedMcp();
+        if (mcpResult) {
+            console.log('  - Context server unregistered');
+        }
+        else {
+            console.log('  = Context server was not registered');
+        }
+        console.log('\nRestart Zed to apply changes.');
+        return;
+    }
+    // Claude/Codex: proxy-based disable
+    const agent = getAgentByName(agentName);
+    if (!agent) {
+        console.error(`Unknown agent: ${agentName}`);
+        console.error('Supported agents: claude, codex, cursor');
+        process.exit(1);
+    }
+    const settings = agent.getSettings();
+    const result = settings.setProxyEnabled(false);
+    if (result.action === 'removed') {
+        console.log(`Grov disabled for ${agentName}.`);
+        console.log('  - Proxy configuration removed');
+    }
+    else {
+        console.log(`Grov was not configured for ${agentName}.`);
+    }
+    console.log(`\nConfig file: ${settings.getConfigPath()}`);
+    const targetName = agentName === 'claude' ? 'Anthropic' : 'OpenAI';
+    console.log(`\n${agentName} will now connect directly to ${targetName}.`);
+}
+/**
+ * Remove grov MCP from ~/.cursor/mcp.json
+ */
+function removeCursorMcp() {
+    const mcpPath = join(homedir(), '.cursor', 'mcp.json');
+    if (!existsSync(mcpPath)) {
+        return false;
+    }
+    try {
+        const content = readFileSync(mcpPath, 'utf-8');
+        const config = JSON.parse(content);
+        if (!config.mcpServers?.grov) {
+            return false;
+        }
+        delete config.mcpServers.grov;
+        writeFileSync(mcpPath, JSON.stringify(config, null, 2));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Remove grov hook from ~/.cursor/hooks.json
+ */
+function removeCursorHooks() {
+    const hooksPath = join(homedir(), '.cursor', 'hooks.json');
+    if (!existsSync(hooksPath)) {
+        return false;
+    }
+    try {
+        const content = readFileSync(hooksPath, 'utf-8');
+        const config = JSON.parse(content);
+        if (!config.hooks?.stop) {
+            return false;
+        }
+        const originalLength = config.hooks.stop.length;
+        config.hooks.stop = config.hooks.stop.filter((h) => !h.command?.includes('grov capture-hook'));
+        if (config.hooks.stop.length === originalLength) {
+            return false;
+        }
+        writeFileSync(hooksPath, JSON.stringify(config, null, 2));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Remove grov MCP from ~/.gemini/antigravity/mcp_config.json
+ */
+function removeAntigravityMcp() {
+    const mcpConfigPath = join(homedir(), '.gemini', 'antigravity', 'mcp_config.json');
+    if (!existsSync(mcpConfigPath)) {
+        return false;
+    }
+    try {
+        const content = readFileSync(mcpConfigPath, 'utf-8');
+        const config = JSON.parse(content);
+        if (!config.mcpServers?.grov) {
+            return false;
+        }
+        delete config.mcpServers.grov;
+        writeFileSync(mcpConfigPath, JSON.stringify(config, null, 2));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Remove grov from ~/.config/zed/settings.json context_servers
+ */
+function removeZedMcp() {
+    const settingsPath = join(homedir(), '.config', 'zed', 'settings.json');
+    if (!existsSync(settingsPath)) {
+        return false;
+    }
+    try {
+        const content = readFileSync(settingsPath, 'utf-8');
+        // Remove comments for parsing
+        const cleanContent = content.replace(/^\s*\/\/.*$/gm, '');
+        const config = JSON.parse(cleanContent);
+        if (!config.context_servers?.grov) {
+            return false;
+        }
+        delete config.context_servers.grov;
+        writeFileSync(settingsPath, JSON.stringify(config, null, 2));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/cli/commands/doctor.d.ts

@@ -0,0 +1 @@
+export declare function doctor(agent?: string): Promise<void>;

package/dist/cli/commands/doctor.js

@@ -0,0 +1,157 @@
+// grov doctor - Check setup and diagnose issues
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { request } from 'undici';
+import { readCredentials, getSyncStatus } from '../../core/cloud/credentials.js';
+import { initDatabase } from '../../core/store/database.js';
+import { getAllCliAgents, getCliAgentById } from '../agents/registry.js';
+const DB_PATH = join(homedir(), '.grov', 'memory.db');
+export async function doctor(agent) {
+    console.log('\nGrov Doctor');
+    console.log('===========\n');
+    if (!agent) {
+        await runGeneralChecks();
+        console.log('\n--- Agent Status ---\n');
+        for (const a of getAllCliAgents()) {
+            const configured = a.isConfigured();
+            const icon = configured ? '\x1b[32m●\x1b[0m' : '\x1b[90m○\x1b[0m';
+            const status = configured ? 'Configured' : 'Not configured';
+            console.log(`${icon} ${a.name}: ${status}`);
+            if (!configured) {
+                console.log(`  \x1b[90m→ grov init ${a.id}\x1b[0m`);
+            }
+        }
+        console.log('\n\x1b[90mRun grov doctor <agent> for detailed checks\x1b[0m');
+    }
+    else if (agent === 'claude') {
+        await runClaudeChecks();
+    }
+    else if (agent === 'codex') {
+        await runCodexChecks();
+    }
+    else if (agent === 'cursor') {
+        await runCursorChecks();
+    }
+    else if (agent === 'antigravity') {
+        await runAntigravityChecks();
+    }
+    else if (agent === 'zed') {
+        await runZedChecks();
+    }
+    else {
+        console.log(`Unknown agent: ${agent}`);
+        console.log('Supported: claude, codex, cursor, antigravity, zed');
+    }
+    console.log('');
+}
+async function runGeneralChecks() {
+    const proxyRunning = await checkProxy();
+    printCheck('Proxy', proxyRunning, 'Running on port 8080', 'Not running', 'grov proxy');
+    const creds = readCredentials();
+    printCheck('Login', !!creds, creds ? `Logged in as ${creds.email}` : 'Not logged in', 'Not logged in', 'grov login');
+    const syncStatus = getSyncStatus();
+    const syncOk = syncStatus?.enabled && syncStatus?.teamId;
+    const syncMsg = syncOk
+        ? `Team ${syncStatus.teamId.substring(0, 8)}...`
+        : syncStatus?.teamId ? 'Disabled' : 'No team';
+    printCheck('Cloud Sync', !!syncOk, syncMsg, syncMsg, 'grov sync --enable --team <id>');
+    const dbStats = checkDatabase();
+    const dbOk = dbStats.tasks > 0 || dbStats.sessions > 0;
+    const dbMsg = `${dbStats.tasks} tasks, ${dbStats.unsynced} unsynced, ${dbStats.sessions} active`;
+    printCheck('Local Database', dbOk, dbMsg, 'Empty', 'Use Claude/Codex with proxy, or Cursor with MCP');
+}
+async function runClaudeChecks() {
+    console.log('Claude Code Checks\n');
+    const proxyRunning = await checkProxy();
+    printCheck('Proxy', proxyRunning, 'Running on port 8080', 'Not running', 'grov proxy');
+    const agent = getCliAgentById('claude');
+    if (agent) {
+        printCheck('ANTHROPIC_BASE_URL', agent.isConfigured(), 'Configured for proxy', 'Not configured', 'grov init claude');
+        printCheck('Settings file', existsSync(agent.configPath), agent.configPath, 'Not found', 'Run claude once to create settings');
+    }
+}
+async function runCodexChecks() {
+    console.log('Codex CLI Checks\n');
+    const proxyRunning = await checkProxy();
+    printCheck('Proxy', proxyRunning, 'Running on port 8080', 'Not running', 'grov proxy');
+    const agent = getCliAgentById('codex');
+    if (agent) {
+        printCheck('model_provider', agent.isConfigured(), 'Set to grov', 'Not configured', 'grov init codex');
+        printCheck('Config file', existsSync(agent.configPath), agent.configPath, 'Not found', 'Run codex once to create config');
+    }
+    const apiKey = process.env.OPENAI_API_KEY;
+    const hasApiKey = !!(apiKey && apiKey.length > 10);
+    const shell = process.env.SHELL?.includes('zsh') ? '~/.zshrc' : '~/.bashrc';
+    const apiKeyFix = process.platform === 'win32'
+        ? 'setx OPENAI_API_KEY "sk-..." (permanent)'
+        : `Add to ${shell}: export OPENAI_API_KEY=sk-...`;
+    printCheck('OPENAI_API_KEY', hasApiKey, 'Set', 'NOT SET - Codex will not work', apiKeyFix);
+}
+async function checkProxy() {
+    try {
+        const res = await request('http://127.0.0.1:8080/health', {
+            headersTimeout: 2000,
+            bodyTimeout: 2000
+        });
+        return res.statusCode === 200;
+    }
+    catch {
+        return false;
+    }
+}
+async function runCursorChecks() {
+    console.log('Cursor Checks\n');
+    const agent = getCliAgentById('cursor');
+    if (agent) {
+        printCheck('MCP Server', agent.isConfigured(), 'Registered in ~/.cursor/mcp.json', 'Not registered', 'grov init cursor');
+    }
+    const projectDir = process.cwd();
+    const hasGrovRules = existsSync(join(projectDir, '.grov', 'rules.mdc'));
+    printCheck('Project Rules', hasGrovRules, '.grov/rules.mdc exists', 'Not found', 'grov init cursor');
+    const hasPointer = existsSync(join(projectDir, '.cursor', 'rules', '90_grov.mdc'));
+    printCheck('Cursor Pointer', hasPointer, '.cursor/rules/90_grov.mdc exists', 'Not found', 'grov init cursor');
+    const cursorDir = join(homedir(), '.cursor');
+    printCheck('Cursor Installed', existsSync(cursorDir), '~/.cursor exists', 'Not found', 'Install Cursor IDE');
+}
+function checkDatabase() {
+    if (!existsSync(DB_PATH)) {
+        return { tasks: 0, unsynced: 0, sessions: 0 };
+    }
+    try {
+        const db = initDatabase();
+        const tasks = db.prepare('SELECT COUNT(*) as c FROM tasks').get().c;
+        const unsynced = db.prepare('SELECT COUNT(*) as c FROM tasks WHERE synced_at IS NULL').get().c;
+        const sessions = db.prepare("SELECT COUNT(*) as c FROM session_states WHERE status = 'active'").get().c;
+        return { tasks, unsynced, sessions };
+    }
+    catch {
+        return { tasks: 0, unsynced: 0, sessions: 0 };
+    }
+}
+function printCheck(name, ok, successMsg, failMsg, fix) {
+    const icon = ok ? '\x1b[32m✓\x1b[0m' : '\x1b[31m✗\x1b[0m';
+    const msg = ok ? successMsg : failMsg;
+    console.log(`${icon} ${name}: ${msg}`);
+    if (!ok) {
+        console.log(`  \x1b[90m→ ${fix}\x1b[0m`);
+    }
+}
+async function runAntigravityChecks() {
+    console.log('Antigravity Checks\n');
+    const agent = getCliAgentById('antigravity');
+    if (agent) {
+        printCheck('MCP Server', agent.isConfigured(), 'Registered in ~/.gemini/antigravity/mcp_config.json', 'Not registered', 'grov init antigravity');
+    }
+    const antigravityDir = join(homedir(), '.gemini', 'antigravity');
+    printCheck('Antigravity Installed', existsSync(antigravityDir), '~/.gemini/antigravity exists', 'Not found', 'Install Antigravity IDE');
+}
+async function runZedChecks() {
+    console.log('Zed Checks\n');
+    const agent = getCliAgentById('zed');
+    if (agent) {
+        printCheck('Context Server', agent.isConfigured(), 'Registered in ~/.config/zed/settings.json', 'Not registered', 'grov init zed');
+    }
+    const zedConfigDir = join(homedir(), '.config', 'zed');
+    printCheck('Zed Installed', existsSync(zedConfigDir), '~/.config/zed exists', 'Not found', 'Install Zed Editor');
+}

package/dist/{commands → cli/commands}/drift-test.js

@@ -4,37 +4,57 @@
 // NOTE: This command creates mock STEPS from the prompt for testing.
 // In real usage, steps are tracked by the proxy from Claude's actions.
 import 'dotenv/config';
-import { getSessionState, createSessionState } from '../lib/store.js';
-import { extractIntent } from '../lib/llm-extractor.js';
-import { checkDrift, checkDriftBasic, isDriftCheckAvailable, scoreToCorrectionLevel } from '../lib/drift-checker-proxy.js';
-import { buildCorrection, formatCorrectionForInjection } from '../lib/correction-builder-proxy.js';
+import { getSessionState, createSessionState } from '../../core/store/store.js';
+import { analyzeTaskContext } from '../../core/extraction/llm-extractor.js';
+import { checkDrift, scoreToCorrectionLevel } from '../../core/extraction/drift-checker-proxy.js';
+import { buildCorrection, formatCorrectionForInjection } from '../../core/extraction/correction-builder-proxy.js';
+// CLI uses env var for auth (not proxy headers)
+// Creates mock headers matching what Claude Code would send
+function getCliHeaders() {
+    const apiKey = process.env.ANTHROPIC_API_KEY || process.env.GROV_API_KEY;
+    if (!apiKey)
+        return null;
+    return {
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+        'content-type': 'application/json',
+    };
+}
 export async function driftTest(prompt, options) {
     console.log('=== GROV DRIFT TEST ===\n');
-    // Check API availability
-    const llmAvailable = isDriftCheckAvailable();
-    console.log(`Anthropic API: ${llmAvailable ? 'AVAILABLE' : 'NOT AVAILABLE (using fallback)'}`);
+    // Get headers from env (CLI mode)
+    const headers = getCliHeaders();
+    console.log(`Anthropic API: ${headers ? 'AVAILABLE' : 'NOT AVAILABLE (using fallback)'}`);
     console.log('');
+    if (!headers) {
+        console.log('Set ANTHROPIC_API_KEY or GROV_API_KEY to enable LLM drift checking.');
+        return;
+    }
     // Get or create session state
     let sessionState = options.session ? getSessionState(options.session) : null;
     // If no session, create a test one with provided or extracted goal
     if (!sessionState) {
         console.log('No session provided, creating test session...');
         const goalText = options.goal || prompt;
-        const intent = await extractIntent(goalText);
-        console.log('\n--- Extracted Intent ---');
-        console.log(`Goal: ${intent.goal}`);
-        console.log(`Scope: ${intent.expected_scope.join(', ') || 'none'}`);
-        console.log(`Constraints: ${intent.constraints.join(', ') || 'none'}`);
-        console.log(`Keywords: ${intent.keywords.join(', ')}`);
+        // Use analyzeTaskContext with mock context to extract goal and constraints
+        const mockConversation = [{ role: 'user', content: goalText }];
+        const taskAnalysis = await analyzeTaskContext(null, // no existing session
+        goalText, // latest user message
+        [], // no recent steps
+        '', // no assistant response yet
+        mockConversation, // conversation history
+        headers);
+        console.log('\n--- Task Analysis ---');
+        console.log(`Goal: ${taskAnalysis.current_goal}`);
+        console.log(`Action: ${taskAnalysis.action}`);
+        console.log(`Constraints: ${(taskAnalysis.constraints || []).join(', ') || 'none'}`);
         console.log('');
         // Create temporary session state
         sessionState = createSessionState({
             session_id: options.session || 'test-session-' + Date.now(),
             project_path: process.cwd(),
-            original_goal: intent.goal,
-            expected_scope: intent.expected_scope,
-            constraints: intent.constraints,
-            keywords: intent.keywords,
+            original_goal: taskAnalysis.current_goal,
+            constraints: taskAnalysis.constraints || [],
             task_type: 'main',
         });
     }
@@ -88,15 +108,8 @@ export async function driftTest(prompt, options) {
     console.log('');
     // Run drift check
     console.log('--- Running Drift Check ---');
-    let result;
-    if (llmAvailable) {
-        console.log('Using LLM-based detection...');
-        result = await checkDrift(driftInput);
-    }
-    else {
-        console.log('Using basic (fallback) detection...');
-        result = checkDriftBasic(driftInput);
-    }
+    console.log('Using LLM-based detection...');
+    const result = await checkDrift(driftInput, headers);
     console.log('');
     console.log('--- Drift Check Result ---');
     console.log(`Score: ${result.score}/10`);

package/dist/cli/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function init(agentName?: 'claude' | 'codex' | 'cursor' | 'antigravity' | 'zed'): Promise<void>;