@wundam/orchex 1.0.0-rc.2 → 1.0.0-rc.21

package/dist/index.js

@@ -2,7 +2,9 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { exec as execChildProcess } from 'child_process';
 import { registerTools, setProjectDir } from './tools.js';
-import { loadConfig, saveConfig, maskConfigForDisplay, PRODUCTION_URL, LLMProviderSchema } from './config.js';
+import { ORCHEX_INSTRUCTIONS } from './mcp-instructions.js';
+import { registerResources } from './mcp-resources.js';
+import { loadConfig, saveConfig, maskConfigForDisplay, resolveApiUrl, PRODUCTION_URL, LLMProviderSchema } from './config.js';
 import { buildVerificationMessage, buildStatusMessage, parseLoginApiResponse, } from './login-helpers.js';
 /** Opens browser cross-platform. Errors are silently ignored — URL already printed to terminal. */
 function openBrowser(url) {
@@ -12,18 +14,12 @@ function openBrowser(url) {
     execChildProcess(cmd, () => { });
 }
 async function handleLoginCommand(args) {
-    let apiUrl = PRODUCTION_URL;
     const apiUrlIdx = args.indexOf('--api-url');
-    if (apiUrlIdx !== -1 && args[apiUrlIdx + 1])
-        apiUrl = args[apiUrlIdx + 1];
-    const stagingIdx = args.indexOf('--staging');
-    if (stagingIdx !== -1) {
-        const stagingUrl = process.env.ORCHEX_STAGING_URL;
-        if (!stagingUrl) {
-            console.warn('⚠  --staging used but ORCHEX_STAGING_URL is not set. Using production URL.');
-        }
-        apiUrl = stagingUrl ?? PRODUCTION_URL;
+    const flagValue = apiUrlIdx !== -1 ? args[apiUrlIdx + 1] : undefined;
+    if (args.includes('--staging')) {
+        console.warn('⚠  orchex login --staging is no longer needed. Set ORCHEX_API_URL=<url> in your environment instead.');
     }
+    const apiUrl = await resolveApiUrl(flagValue);
     // Step 1: Start device auth
     let startData;
     try {
@@ -86,6 +82,15 @@ async function handleLoginCommand(args) {
             const body = await meResp.json();
             const me = body.user;
             if (me) {
+                // Sync tier + trial info to local config for offline tier resolution
+                await saveConfig({
+                    mode: 'cloud',
+                    apiUrl,
+                    apiKey: token,
+                    tier: me.tier,
+                    trialRunsRemaining: me.trialRunsRemaining,
+                    accountCreatedAt: me.createdAt ?? undefined,
+                });
                 console.log(`\n✓ Logged in as ${me.email}`);
                 const expiryDays = me.tier === 'free' ? 30 : 90;
                 const expiryDate = new Date(Date.now() + expiryDays * 24 * 60 * 60 * 1000).toLocaleDateString();
@@ -96,7 +101,54 @@ async function handleLoginCommand(args) {
                     console.log(`  Tier:   ${me.tier.charAt(0).toUpperCase() + me.tier.slice(1)}`);
                 }
                 console.log(`  Token expires: ${expiryDate}`);
-                console.log(`  Config saved to ~/.orchex/config.json\n`);
+                console.log(`  Config saved to ~/.orchex/config.json`);
+                // Sync BYOK keys to local cache
+                try {
+                    const { writeKeyCache } = await import('./key-cache.js');
+                    const keysResp = await fetch(`${apiUrl}/api/v1/keys/resolve`, {
+                        headers: { 'Authorization': `Bearer ${token}` },
+                    });
+                    if (keysResp.ok) {
+                        const { keys } = (await keysResp.json());
+                        if (keys.length > 0) {
+                            await writeKeyCache({ keys, fetchedAt: new Date().toISOString() });
+                            console.log(`  Keys:   ${keys.length} provider key(s) synced`);
+                        }
+                    }
+                }
+                catch {
+                    // Non-fatal — keys can be fetched on-demand later
+                }
+                // Fetch entitlement JWT (non-fatal — login succeeds even if this fails)
+                try {
+                    const entResp = await fetch(`${apiUrl}/api/v1/entitlements/me`, {
+                        headers: { 'Authorization': `Bearer ${token}` },
+                    });
+                    if (entResp.ok) {
+                        const { jwt: entitlementJwt } = await entResp.json();
+                        const { readKeyCacheRaw, writeKeyCache: writeKC } = await import('./key-cache.js');
+                        // IMPORTANT: Use readKeyCacheRaw() — NOT readKeyCache() — to avoid
+                        // the 1hr BYOK TTL wiping existing keys when cache is older than 1hr.
+                        const existingCache = await readKeyCacheRaw();
+                        await writeKC({
+                            keys: existingCache?.keys ?? [],
+                            fetchedAt: existingCache?.fetchedAt ?? new Date().toISOString(),
+                            entitlementJwt,
+                        });
+                    }
+                }
+                catch {
+                    // Non-fatal — entitlement sync is best-effort
+                }
+                // Also cache model registry for offline use
+                try {
+                    const { fetchAndCacheModels } = await import('./model-cache.js');
+                    await fetchAndCacheModels(apiUrl);
+                }
+                catch {
+                    // Non-fatal — model registry can be fetched on-demand later
+                }
+                console.log('');
                 return;
             }
         }
@@ -112,8 +164,10 @@ async function handleLogoutCommand() {
         console.log('Not logged in (no API key configured).');
         return;
     }
-    await saveConfig({ mode: 'local', apiKey: undefined });
-    console.log('Logged out. Local mode enabled.');
+    const { clearKeyCache } = await import('./key-cache.js');
+    await clearKeyCache();
+    await saveConfig({ mode: 'local', apiKey: undefined, tier: 'free' });
+    console.log('Logged out. Local mode enabled. Cached keys cleared.');
 }
 async function handleStatusCommand(args) {
     const config = await loadConfig();
@@ -152,6 +206,26 @@ async function handleStatusCommand(args) {
         }
         else {
             console.log(buildStatusMessage(me));
+            // Show entitlement status if JWT is cached
+            try {
+                const { getCachedEntitlement } = await import('./key-cache.js');
+                const { loadPublicKey } = await import('./entitlements/resolve.js');
+                const publicKeyPem = await loadPublicKey();
+                const claims = await getCachedEntitlement(publicKeyPem);
+                if (claims) {
+                    const srcLabel = claims.src.charAt(0).toUpperCase() + claims.src.slice(1);
+                    const unlimitedFields = Object.entries(claims.eff)
+                        .filter(([, v]) => v === -1)
+                        .map(([k]) => k);
+                    const desc = unlimitedFields.length > 0
+                        ? `unlimited: ${unlimitedFields.join(', ')}`
+                        : 'custom limits';
+                    console.log(`  Entitlement: ${srcLabel} (${desc})`);
+                }
+            }
+            catch {
+                // No entitlement info — skip silently
+            }
         }
     }
     catch (err) {
@@ -160,7 +234,14 @@ async function handleStatusCommand(args) {
 }
 function printHelp() {
     console.log(`
-orchex — Parallel AI orchestration with ownership enforcement
+orchex — Autopilot AI orchestration with ownership enforcement
+
+ORCHESTRATION:
+  orchex run "intent"        Auto-plan and execute from natural language
+  orchex run "..." --yes     Skip approval prompt (auto-approve)
+  orchex run "..." --dry-run Generate plan only, don't execute
+  orchex run "..." --provider openai --model gpt-4.1
+  orchex complete --archive  Archive active orchestration and unblock future runs
 
 CLOUD COMMANDS:
   orchex login           Authenticate with orchex cloud (opens browser)
@@ -168,10 +249,25 @@ CLOUD COMMANDS:
   orchex status          Show login state, tier, and trial runs
   orchex status --json   Output as JSON (for scripting)
 
+LEARNING:
+  orchex reset-learning --confirm              Reset all learning data
+  orchex reset-learning --confirm --patterns-only   Reset detected patterns only
+  orchex reset-learning --confirm --reports-only     Reset execution reports only
+
 CONFIG:
   orchex config          Show current config (apiKey masked)
   orchex config --api-key <token>   Save API key manually
-  orchex config --staging           Configure for staging server
+  orchex config --staging           Configure for staging server (reads ORCHEX_API_URL)
+
+ENVIRONMENT VARIABLES:
+  ORCHEX_API_URL         Override API server URL (e.g. https://orchex.dev)
+                         Priority: --api-url flag > ORCHEX_API_URL > config file > default
+
+SETUP:
+  setup [options]     Auto-configure MCP server for your IDE
+                      --ide <name>   Target specific IDE
+                      --dry-run      Preview changes
+                      --force        Overwrite existing
 
 MCP SERVER (invoked by your AI assistant):
   npx @wundam/orchex     Start the MCP server
@@ -220,11 +316,19 @@ async function handleConfigCommand(args) {
                 updates.apiKey = value;
                 i++;
                 break;
-            case '--staging':
-                // Shorthand: --staging sets mode=cloud and apiUrl to staging
+            case '--staging': {
+                // Shorthand: --staging sets mode=cloud and apiUrl to staging env
                 updates.mode = 'cloud';
-                updates.apiUrl = process.env.ORCHEX_STAGING_URL ?? PRODUCTION_URL;
+                if (process.env.ORCHEX_STAGING_URL && !process.env.ORCHEX_API_URL) {
+                    console.warn('⚠  ORCHEX_STAGING_URL is deprecated. Use ORCHEX_API_URL instead.');
+                }
+                const stagingTarget = process.env.ORCHEX_API_URL ?? process.env.ORCHEX_STAGING_URL;
+                if (!stagingTarget) {
+                    console.warn('⚠  --staging used but ORCHEX_API_URL is not set. Defaulting to production URL.');
+                }
+                updates.apiUrl = stagingTarget ?? PRODUCTION_URL;
                 break;
+            }
             case '--local':
                 // Shorthand: --local sets mode=local
                 updates.mode = 'local';
@@ -240,6 +344,13 @@ async function handleConfigCommand(args) {
                     process.exit(1);
                 }
                 updates.provider = value;
+                // Warn if setting non-Anthropic provider while in cloud mode
+                {
+                    const currentConfig = await loadConfig();
+                    if ((currentConfig.mode === 'cloud' || updates.mode === 'cloud') && value !== 'anthropic') {
+                        console.warn(`\u26A0  Warning: Cloud mode currently only supports Anthropic. Provider "${value}" will be ignored in cloud execution.`);
+                    }
+                }
                 i++;
                 break;
             case '--model':
@@ -266,6 +377,283 @@ async function handleConfigCommand(args) {
     console.log('Config updated:');
     console.log(JSON.stringify(maskConfigForDisplay(config), null, 2));
 }
+async function handleRunCommand(args) {
+    // Parse flags
+    let providerFlag;
+    let modelFlag;
+    let autoApprove = false;
+    let dryRun = false;
+    let projectDir = process.cwd();
+    const positionalArgs = [];
+    for (let i = 0; i < args.length; i++) {
+        const flag = args[i];
+        switch (flag) {
+            case '--yes':
+            case '-y':
+                autoApprove = true;
+                break;
+            case '--dry-run':
+                dryRun = true;
+                break;
+            case '--provider':
+                providerFlag = args[++i];
+                break;
+            case '--model':
+                modelFlag = args[++i];
+                break;
+            case '--project-dir':
+                projectDir = args[++i];
+                break;
+            default:
+                if (!flag.startsWith('--')) {
+                    positionalArgs.push(flag);
+                }
+                else {
+                    console.error(`Unknown flag: ${flag}`);
+                    console.error('Usage: orchex run "intent" [--yes] [--dry-run] [--provider NAME] [--model NAME]');
+                    process.exit(1);
+                }
+        }
+    }
+    const intent = positionalArgs.join(' ').trim();
+    if (!intent) {
+        console.error('Error: Missing intent. Usage: orchex run "Add user authentication"');
+        process.exit(1);
+    }
+    // Dynamic imports (these are local-only modules)
+    const { gatherProjectContext, generatePlan, parsePlanDocument, extractDeliverables, processDeliverables, buildDependencyGraph, generateStreams, toInitFormat, formatPlanPreview, formatPlanPreviewText, detectSequentialEdits, autoFixSequentialEdits, createDiagnostics, } = await import('./intelligence/index.js');
+    const { calculateWaves } = await import('./waves.js');
+    const { createExecutor } = await import('./executors/index.js');
+    const { initOrchestration, loadManifest, manifestExists } = await import('./manifest.js');
+    const { executeWave } = await import('./orchestrator.js');
+    const { generateReport, saveReportLocally, generateLearningSummary } = await import('./intelligence/index.js');
+    // First-run check
+    const { isFirstRun, getFirstRunSuggestion, markFirstRunComplete } = await import('./intelligence/index.js');
+    if (await isFirstRun(projectDir)) {
+        console.log('\n' + getFirstRunSuggestion() + '\n');
+    }
+    console.log(`\nGenerating plan for: "${intent}"\n`);
+    // Create executor — priority: env var > cached BYOK key > error
+    const config = await loadConfig();
+    const resolvedProvider = providerFlag
+        ? providerFlag
+        : (await import('./config.js')).getConfiguredProvider(config);
+    // Try env var first (existing behavior)
+    const { getProviderApiKey } = await import('./config.js');
+    let apiKey = getProviderApiKey(resolvedProvider);
+    // Fallback: cached BYOK key from login sync
+    if (!apiKey && resolvedProvider !== 'ollama' && resolvedProvider !== 'bedrock') {
+        const { getCachedApiKey } = await import('./key-cache.js');
+        apiKey = await getCachedApiKey(resolvedProvider);
+        // Fallback: fetch fresh from cloud if logged in and cache miss/expired
+        if (!apiKey && config.mode === 'cloud' && config.apiKey) {
+            try {
+                const { writeKeyCache } = await import('./key-cache.js');
+                const resolvedApiUrl = await (await import('./config.js')).resolveApiUrl();
+                const resp = await fetch(`${resolvedApiUrl}/api/v1/keys/resolve`, {
+                    headers: { 'Authorization': `Bearer ${config.apiKey}` },
+                });
+                if (resp.ok) {
+                    const { keys } = (await resp.json());
+                    if (keys.length > 0) {
+                        await writeKeyCache({ keys, fetchedAt: new Date().toISOString() });
+                        apiKey = keys.find(k => k.provider === resolvedProvider)?.apiKey;
+                    }
+                }
+            }
+            catch {
+                // Non-fatal — will error below if no key found
+            }
+        }
+    }
+    if (!apiKey && resolvedProvider !== 'ollama' && resolvedProvider !== 'bedrock') {
+        const envVarName = resolvedProvider === 'anthropic' ? 'ANTHROPIC_API_KEY'
+            : resolvedProvider === 'openai' ? 'OPENAI_API_KEY'
+                : resolvedProvider === 'gemini' ? 'GEMINI_API_KEY'
+                    : 'DEEPSEEK_API_KEY';
+        console.error(`No API key found for provider "${resolvedProvider}".`);
+        console.error('Options:');
+        console.error(`  1. Set env var: export ${envVarName}=<key>`);
+        console.error('  2. Store a key at https://orchex.dev/dashboard/keys and run `orchex login`');
+        process.exit(1);
+    }
+    const exec = createExecutor({ provider: resolvedProvider, ...(apiKey ? { apiKey } : {}) });
+    // Resolve tier BEFORE plan generation so we can pass stream budget to the LLM
+    const { checkTierLimits } = await import('./tier-gating.js');
+    let effectiveTier;
+    try {
+        const { resolveEntitledTier, loadPublicKey } = await import('./entitlements/resolve.js');
+        const publicKey = await loadPublicKey();
+        effectiveTier = await resolveEntitledTier(config, publicKey);
+    }
+    catch {
+        // Fallback if entitlement module not available
+        const { getEffectiveTier, getEffectiveLimits } = await import('./tiers.js');
+        const effectiveTierId = config.mode === 'cloud' && config.apiKey
+            ? getEffectiveTier({
+                tier: config.tier ?? 'free',
+                createdAt: config.accountCreatedAt ?? new Date().toISOString(),
+                trialRunsRemaining: config.trialRunsRemaining ?? 0,
+            })
+            : (config.tier ?? 'free');
+        effectiveTier = getEffectiveLimits(effectiveTierId, null);
+    }
+    const maxStreams = effectiveTier.maxParallelAgents === -1 ? undefined : effectiveTier.maxParallelAgents;
+    // Generate plan
+    let planResult;
+    try {
+        planResult = await generatePlan(intent, projectDir, exec, { model: modelFlag, provider: resolvedProvider, maxStreams });
+    }
+    catch (err) {
+        console.error(`Plan generation failed: ${err.message}`);
+        process.exit(1);
+    }
+    // Run through learn pipeline
+    const diagnostics = createDiagnostics();
+    const plan = parsePlanDocument(planResult.planMarkdown);
+    const rawDeliverables = extractDeliverables(plan, { diagnostics });
+    const deliverables = processDeliverables(rawDeliverables);
+    if (deliverables.length === 0) {
+        console.error('Plan generated no deliverables. Try a more specific intent.');
+        process.exit(1);
+    }
+    const graph = buildDependencyGraph(deliverables, { diagnostics });
+    const result = generateStreams(deliverables, graph, {
+        validateAntiPatterns: true,
+        projectDir,
+        diagnostics,
+    });
+    // Sequential diagnostics
+    const seqDiag = detectSequentialEdits(result.streams);
+    const initStreams = toInitFormat(result);
+    const streamDefs = Object.fromEntries(Object.entries(initStreams).map(([id, s]) => [id, {
+            name: s.name, deps: s.deps || [], owns: s.owns || [],
+            reads: s.reads || [], setup: [], plan: s.plan,
+            verify: s.verify || [], status: 'pending', attempts: 0,
+        }]));
+    const { waves } = calculateWaves({
+        feature: plan.title, streams: streamDefs,
+        status: 'pending', created: new Date().toISOString(),
+    });
+    // Enforce tier limits on the generated plan (safety net)
+    const tierCheck = checkTierLimits({ tier: effectiveTier, streams: streamDefs, projectDir, mode: config.mode });
+    if (!tierCheck.allowed) {
+        console.error(`Tier limit exceeded: ${tierCheck.error}`);
+        if (tierCheck.suggestion)
+            console.error(tierCheck.suggestion);
+        process.exit(1);
+    }
+    const waveList = waves.map(w => ({ number: w.number, streams: w.streams.map(s => s.id) }));
+    const allWarnings = [...result.warnings, ...diagnostics.warnings];
+    // Validate models for each stream and build model decisions map
+    const { resolveModel } = await import('./model-validator.js');
+    const { resolveApiUrl, DEFAULT_MODELS } = await import('./config.js');
+    const { estimatePlannedCost } = await import('./intelligence/index.js');
+    const modelApiUrl = config.mode === 'cloud' && config.apiKey ? await resolveApiUrl() : undefined;
+    const modelDecisions = {};
+    for (const [id, stream] of Object.entries(initStreams)) {
+        const suggestedProvider = stream.suggestedProvider ?? resolvedProvider;
+        const suggestedModel = DEFAULT_MODELS[suggestedProvider] ?? modelFlag;
+        const validation = await resolveModel(suggestedProvider, suggestedModel, modelApiUrl);
+        // Estimate cost using cost-tracker
+        const ownedLines = (stream.owns ?? []).length * 100; // rough estimate
+        const costEstimate = estimatePlannedCost(ownedLines * 4, validation.resolvedModel); // ~4 tokens/line
+        modelDecisions[id] = {
+            provider: suggestedProvider,
+            model: validation.resolvedModel,
+            estimatedCostUsd: costEstimate.finalCost,
+            fallback: validation.wasFallback ? `${validation.originalModel} → ${validation.resolvedModel}` : undefined,
+        };
+    }
+    const preview = formatPlanPreview(initStreams, waveList, allWarnings, seqDiag, modelDecisions);
+    // Show preview
+    console.log(formatPlanPreviewText(preview));
+    if (dryRun) {
+        console.log('--- Generated Plan Markdown ---\n');
+        console.log(planResult.planMarkdown);
+        console.log('\n(Dry run — no execution)');
+        process.exit(0);
+    }
+    // Approval
+    if (!autoApprove) {
+        const readline = await import('readline');
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const answer = await new Promise(resolve => {
+            rl.question('Execute this plan? [y/N] ', resolve);
+        });
+        rl.close();
+        if (answer.toLowerCase() !== 'y' && answer.toLowerCase() !== 'yes') {
+            console.log('Aborted.');
+            process.exit(0);
+        }
+    }
+    // Auto-fix sequential edits before execution
+    if (seqDiag.length > 0) {
+        autoFixSequentialEdits(result.streams);
+        console.log(`Auto-fixed ${seqDiag.length} sequential edit conflict(s).`);
+    }
+    // Check for existing orchestration
+    if (await manifestExists(projectDir)) {
+        console.error('An active orchestration already exists. Run `orchex complete --archive` to clear it.');
+        process.exit(1);
+    }
+    // Init and execute
+    console.log(`\nInitializing orchestration: "${plan.title}"\n`);
+    await initOrchestration(projectDir, plan.title, streamDefs);
+    const allResponses = [];
+    let executionError;
+    try {
+        let done = false;
+        let waveNum = 1;
+        while (!done) {
+            console.log(`Executing wave ${waveNum}...`);
+            const response = await executeWave(projectDir, exec, { model: modelFlag });
+            allResponses.push(response);
+            const completed = response.streams.filter(s => s.status === 'complete').length;
+            const failed = response.streams.filter(s => s.status === 'failed').length;
+            console.log(`  Wave ${waveNum}: ${completed} complete, ${failed} failed`);
+            done = response.done;
+            waveNum++;
+        }
+        // Generate report
+        const manifest = await loadManifest(projectDir);
+        const report = generateReport(manifest, allResponses);
+        const reportPath = await saveReportLocally(projectDir, report);
+        // Sync report to cloud dashboard (fire-and-forget, only if logged in)
+        const { syncReportToCloud } = await import('./cloud-sync.js');
+        await syncReportToCloud(config, report);
+        // Learning summary
+        const summary = generateLearningSummary(report);
+        console.log('\n--- Orchex learned ---');
+        for (const insight of summary) {
+            console.log(`  ${insight}`);
+        }
+        console.log(`\nReport saved: ${reportPath}`);
+        console.log(`Quality score: ${report.planQualityScore}/100\n`);
+        // Mark first-run complete after successful orchestration
+        if (await isFirstRun(projectDir)) {
+            await markFirstRunComplete(projectDir);
+        }
+    }
+    catch (err) {
+        executionError = err;
+        console.error(`\nExecution error: ${executionError.message}`);
+    }
+    finally {
+        // Always archive to unblock future runs
+        try {
+            const { archiveOrchestration } = await import('./manifest.js');
+            const archiveName = await archiveOrchestration(projectDir);
+            console.log(`Orchestration archived: ${archiveName}`);
+        }
+        catch {
+            // Best-effort — report is already saved if execution succeeded
+        }
+    }
+    if (executionError) {
+        process.exit(1);
+    }
+}
 async function main() {
     const args = process.argv.slice(2);
     // Handle CLI config command (not MCP)
@@ -285,6 +673,65 @@ async function main() {
         await handleStatusCommand(args.slice(1));
         return;
     }
+    if (args[0] === 'run') {
+        await handleRunCommand(args.slice(1));
+        return;
+    }
+    if (args[0] === 'reset-learning') {
+        const { resetLearning } = await import('./intelligence/index.js');
+        const subArgs = args.slice(1);
+        const confirm = subArgs.includes('--confirm');
+        const patternsOnly = subArgs.includes('--patterns-only');
+        const reportsOnly = subArgs.includes('--reports-only');
+        try {
+            const result = await resetLearning(process.cwd(), { confirm, patternsOnly, reportsOnly });
+            console.log(result.message);
+            for (const f of result.deleted) {
+                console.log(`  - ${f}`);
+            }
+        }
+        catch (err) {
+            console.error(err.message);
+            process.exit(1);
+        }
+        return;
+    }
+    if (args[0] === 'complete') {
+        const { manifestExists, archiveOrchestration } = await import('./manifest.js');
+        const subArgs = args.slice(1);
+        const pdFlag = subArgs.indexOf('--project-dir');
+        const projectDir = pdFlag !== -1 && subArgs[pdFlag + 1] ? subArgs[pdFlag + 1] : process.cwd();
+        if (!(await manifestExists(projectDir))) {
+            console.log('No active orchestration to archive.');
+            return;
+        }
+        if (subArgs.includes('--archive')) {
+            try {
+                const archiveName = await archiveOrchestration(projectDir);
+                console.log(`Orchestration archived: ${archiveName}`);
+            }
+            catch (err) {
+                console.error(`Archive failed: ${err.message}`);
+                process.exit(1);
+            }
+        }
+        else {
+            console.error('Usage: orchex complete --archive');
+        }
+        return;
+    }
+    if (args[0] === 'setup') {
+        const { handleSetupCommand } = await import('./setup/index.js');
+        await handleSetupCommand(args.slice(1));
+        return;
+    }
+    if (args[0] === '--version' || args[0] === '-v') {
+        const { createRequire } = await import('module');
+        const require = createRequire(import.meta.url);
+        const pkg = require('../package.json');
+        console.log(pkg.version);
+        process.exit(0);
+    }
     if (args[0] === '--help' || args[0] === '-h' || args[0] === 'help') {
         printHelp();
         process.exit(0);
@@ -295,11 +742,9 @@ async function main() {
         setProjectDir(args[pdIdx + 1]);
     }
     // Start MCP server
-    const server = new McpServer({
-        name: 'orchex',
-        version: '1.0.0',
-    });
+    const server = new McpServer({ name: 'orchex', version: '1.0.0' }, { instructions: ORCHEX_INSTRUCTIONS, capabilities: { logging: {} } });
     registerTools(server);
+    registerResources(server);
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }

package/dist/intelligence/index.d.ts

@@ -0,0 +1,44 @@
+export { gatherProjectContext, generatePlan } from './auto-planner.js';
+export { parsePlanDocument, getSectionsAtLevel, isUnpopulatedTemplate } from './plan-parser.js';
+export { extractDeliverables, processDeliverables, formatDeliverablesReport } from './deliverable-extractor.js';
+export type { Deliverable } from './deliverable-extractor.js';
+export { buildDependencyGraph, formatDependencyReport } from './dependency-inferrer.js';
+export { generateStreams, formatStreamsForReview, toInitFormat, extractPrerequisites } from './stream-generator.js';
+export { formatPlanPreview, formatPlanPreviewText, type ModelDecision } from './plan-preview.js';
+export { detectSequentialEdits, autoFixSequentialEdits } from './sequential-diagnostics.js';
+export type { SequentialEditDiagnostic } from './sequential-diagnostics.js';
+export { createDiagnostics, detectOwnershipConflicts } from './diagnostics.js';
+export type { LearnDiagnostics } from './diagnostics.js';
+export { generateReport, saveReportLocally } from './execution-report.js';
+export type { ExecutionReport, ReportStreamResult } from './execution-report.js';
+export { generateLearningSummary } from './learning-summary.js';
+export { isFirstRun, getFirstRunSuggestion, markFirstRunComplete } from './first-run.js';
+export { resetLearning } from './reset-learning.js';
+export { analyzeError } from './error-analyzer.js';
+export type { ErrorCategory, ErrorAnalysis } from './error-analyzer.js';
+export { evaluateCompletion } from './iteration-evaluator.js';
+export type { StreamResultSummary } from './iteration-evaluator.js';
+export { DEFAULT_THRESHOLDS, categorizeStream, getRecommendedLimit, getThresholds, streamResultToTelemetryEvent, appendLocalEvents, runLearningCycle, } from './learning-engine.js';
+export type { LearnedThresholds, LearningStreamResult } from './learning-engine.js';
+export { createDetector } from './anti-pattern-detector.js';
+export type { AntiPatternIssue, BatchAnalysisResult } from './anti-pattern-detector.js';
+export { generateAllSuggestions, getSuggestionsSummary } from './split-suggester.js';
+export type { InteractiveSuggestion } from './split-suggester.js';
+export { autoMergeOwnershipConflicts } from './ownership-resolver.js';
+export { suggestProvider, classifyTask } from './model-routing.js';
+export { applyPartialApproval, rollbackStream } from './interactive-approval.js';
+export { generateFixStream } from './self-healer.js';
+export { cleanupOrphanFixStreams, getFixChainInfo, isFixStream, getOriginalStreamId, onStreamComplete } from './fix-stream-manager.js';
+export { routeStream, loadRoutingRules } from './smart-router.js';
+export type { RouteDecision, RouteOptions } from './smart-router.js';
+export { detectPatterns, formatPatterns, patternsToPromptHints, savePatterns, loadPatterns, adaptReport } from './pattern-detector.js';
+export type { DetectorInput } from './pattern-detector.js';
+export { pruneUnusedFiles, estimateTokens, generateCachingHints } from './context-optimizer.js';
+export { checkBudget, createBudgetConfig, ContextBudgetExceededError } from './budget-enforcer.js';
+export type { BudgetCheckResult } from './budget-enforcer.js';
+export { extractRelevantChunks } from './file-chunker.js';
+export { getModelCosts, estimatePlannedCost } from './cost-tracker.js';
+export { extractImports, resolveImportPath } from './heuristics.js';
+export { findMatchingTemplate, applyTemplate, suggestSplit } from './slicing-templates.js';
+export { optimizeTopology } from './topology-optimizer.js';
+export type { TopologyInput, TopologyReport } from './topology-optimizer.js';