@wundam/orchex 1.0.0-rc.6 → 1.0.0-rc.8

package/README.md

@@ -19,7 +19,7 @@ Your AI assistant does tasks one at a time. Orchex makes it do 10 at once — sa
 ## Prerequisites
 
 - [Node.js](https://nodejs.org/) >= 18
-- LLM API key (one of the following):
+- LLM API key — set via environment variable **or** store on the [dashboard](https://orchex.dev/dashboard/keys) and sync with `orchex login`:
   - `ANTHROPIC_API_KEY` for Anthropic Claude
   - `OPENAI_API_KEY` for OpenAI (GPT-4.1, o1, o3)
   - `GEMINI_API_KEY` for Google Gemini
@@ -47,11 +47,11 @@ Connect to orchex cloud for managed execution:
 orchex login
 ```
 
-Your browser opens — log in or create a free account, click **Allow**. Token saved automatically.
+Your browser opens — log in or create a free account, click **Allow**. Token saved automatically. API keys stored on the dashboard are synced to your local machine so `orchex run` works without environment variables.
 
 ```bash
 orchex status          # Check tier and trial runs
-orchex logout          # Clear credentials
+orchex logout          # Clear credentials and cached keys
 orchex --help          # All commands
 ```
 

package/dist/cloud-sync.d.ts

@@ -0,0 +1,8 @@
+import type { Config } from './config.js';
+import type { ExecutionReport } from './intelligence/execution-report.js';
+/**
+ * Fire-and-forget sync of an execution report to the cloud dashboard.
+ * Only runs when user is logged in (mode=cloud + apiKey present).
+ * Never blocks or throws — network failures are silently ignored.
+ */
+export declare function syncReportToCloud(config: Config, report: ExecutionReport): Promise<void>;

package/dist/cloud-sync.js

@@ -0,0 +1,26 @@
+/**
+ * Fire-and-forget sync of an execution report to the cloud dashboard.
+ * Only runs when user is logged in (mode=cloud + apiKey present).
+ * Never blocks or throws — network failures are silently ignored.
+ */
+export async function syncReportToCloud(config, report) {
+    if (config.mode !== 'cloud' || !config.apiKey)
+        return;
+    const apiUrl = config.apiUrl;
+    try {
+        const resp = await fetch(`${apiUrl}/api/v1/history/sync`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${config.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ report }),
+        });
+        if (resp.status === 401) {
+            console.warn('Cloud sync: token expired. Run `orchex login` to re-authenticate.');
+        }
+    }
+    catch {
+        // Network error — silently skip
+    }
+}

package/dist/config.d.ts

@@ -7,6 +7,10 @@ export type LLMProvider = z.infer<typeof LLMProviderSchema>;
  * Priority: ORCHEX_PROVIDER env var > first available API key
  */
 export declare function detectProvider(): LLMProvider;
+/**
+ * Log the detected provider and masked key at startup.
+ */
+export declare function logProviderDetection(): void;
 /**
  * Get the API key for a specific provider from environment variables.
  */

package/dist/config.js

@@ -3,6 +3,8 @@ import * as path from 'path';
 import * as os from 'os';
 import { z } from 'zod';
 import { TierIdSchema } from './tiers.js';
+import { createLogger } from './logging.js';
+const log = createLogger('config');
 // Well-known URLs
 export const PRODUCTION_URL = 'https://orchex.dev';
 // ============================================================================
@@ -35,6 +37,19 @@ export function detectProvider() {
     // Default to Anthropic (original behavior)
     return 'anthropic';
 }
+function maskKey(key) {
+    if (key.length <= 8)
+        return '****';
+    return key.slice(0, 4) + '...' + key.slice(-4);
+}
+/**
+ * Log the detected provider and masked key at startup.
+ */
+export function logProviderDetection() {
+    const provider = detectProvider();
+    const key = getProviderApiKey(provider);
+    log.info({ provider, key: key ? maskKey(key) : 'none' }, 'provider_detected');
+}
 /**
  * Get the API key for a specific provider from environment variables.
  */

package/dist/index.js

@@ -190,6 +190,7 @@ ORCHESTRATION:
   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)
@@ -208,7 +209,7 @@ CONFIG:
   orchex config --staging           Configure for staging server (reads ORCHEX_API_URL)
 
 ENVIRONMENT VARIABLES:
-  ORCHEX_API_URL         Override API server URL (e.g. https://stage.orchex.dev)
+  ORCHEX_API_URL         Override API server URL (e.g. https://orchex.dev)
                          Priority: --api-url flag > ORCHEX_API_URL > config file > default
 
 MCP SERVER (invoked by your AI assistant):
@@ -506,40 +507,64 @@ async function handleRunCommand(args) {
     }
     // Check for existing orchestration
     if (await manifestExists(projectDir)) {
-        console.error('An active orchestration already exists. Run `orchex complete --archive` first.');
+        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 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);
-    // 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);
+    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() {
@@ -584,6 +609,30 @@ async function main() {
         }
         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] === '--version' || args[0] === '-v') {
         const { createRequire } = await import('module');
         const require = createRequire(import.meta.url);

package/dist/intelligence/cost-tracker.d.ts

@@ -2,7 +2,7 @@
  * Token cost tracking and estimation for Orchex Learn.
  * Provides cost estimation and aggregation for multi-provider token usage.
  */
-import type { TelemetryEvent } from '../telemetry/telemetry-types.js';
+import type { TelemetryEvent } from './event-types.js';
 /**
  * Token costs per 1000 tokens (in USD).
  * Prices as of February 2026 - should be updated periodically.

package/dist/intelligence/event-types.d.ts

@@ -0,0 +1,89 @@
+import type { ErrorCategory } from './error-analyzer.js';
+import type { BudgetViolationType } from '../types.js';
+export interface TelemetryEvent {
+    id: string;
+    sessionHash: string;
+    eventType: 'orchestration_start' | 'orchestration_complete' | 'stream_complete' | 'stream_failed' | 'self_heal_triggered';
+    timestamp: string;
+    durationMs?: number;
+    streamCount?: number;
+    waveCount?: number;
+    parallelCount?: number;
+    success?: boolean;
+    errorCategory?: ErrorCategory;
+    retryCount?: number;
+    selfHealCount?: number;
+    complexityScore?: number;
+    tokensInput?: number;
+    tokensOutput?: number;
+    provider?: string;
+    model?: string;
+    tier?: string;
+    /** Estimated context tokens before execution */
+    contextTokensEstimated?: number;
+    /** Actual context tokens from API response */
+    contextTokensActual?: number;
+    /** Budget utilization ratio (0-1) */
+    contextBudgetUtilization?: number;
+    /** Whether budget limits were exceeded */
+    budgetViolationType?: BudgetViolationType;
+    /** Provider's context window limit for this model */
+    providerContextLimit?: number;
+    /** Whether cache was hit */
+    cacheHit?: boolean;
+    /** Tokens read from cache */
+    cacheReadTokens?: number;
+    /** Tokens written to cache */
+    cacheWriteTokens?: number;
+    /** Milliseconds saved by parallel execution */
+    timeSavedMs?: number;
+    /** Hypothetical sequential execution time in ms */
+    sequentialMs?: number;
+    /** Actual parallel execution time in ms */
+    parallelMs?: number;
+    /** Stream name for category-based analysis */
+    streamName?: string;
+    /** SHA-256 hash of the prompt sent to LLM */
+    promptHash?: string;
+    /** SHA-256 hash of the artifact response */
+    artifactHash?: string;
+}
+export interface TelemetryAggregate {
+    period: string;
+    orchestrationsTotal: number;
+    orchestrationsSuccess: number;
+    orchestrationsFailed: number;
+    streamsTotal: number;
+    streamsSuccess: number;
+    streamsFailed: number;
+    avgDurationMs?: number;
+    p50DurationMs?: number;
+    p95DurationMs?: number;
+    errorsByCategory: Record<ErrorCategory, number>;
+    selfHealTriggered: number;
+    selfHealSuccess: number;
+    tokensInputTotal: number;
+    tokensOutputTotal: number;
+    /** Average context budget utilization (0-1) */
+    avgContextUtilization?: number;
+    /** Count of soft limit violations */
+    softViolationCount: number;
+    /** Count of hard limit violations */
+    hardViolationCount: number;
+    /** Streams that failed due to context exceeded */
+    contextExceededFailures: number;
+    /** Cache hit rate (0-1) */
+    cacheHitRate?: number;
+    /** Total tokens read from cache */
+    cacheReadTokensTotal: number;
+    /** Total tokens written to cache */
+    cacheWriteTokensTotal: number;
+    /** Estimated cost savings from cache */
+    estimatedCacheSavings?: number;
+    /** Total milliseconds saved by parallel execution */
+    timeSavedMsTotal: number;
+    /** Total hypothetical sequential time in ms */
+    sequentialMsTotal: number;
+    /** Total actual parallel time in ms */
+    parallelMsTotal: number;
+}

package/dist/intelligence/event-types.js

@@ -0,0 +1 @@
+export {};

package/dist/intelligence/execution-report.d.ts

@@ -13,6 +13,9 @@ export interface ReportStreamResult {
     executionTimeMs?: number;
     selfHealCount: number;
     errorCategory?: string;
+    provider?: string;
+    model?: string;
+    filesChanged?: string[];
 }
 /**
  * Full execution report — deterministic, no LLM needed.

package/dist/intelligence/execution-report.js

@@ -51,6 +51,9 @@ export function generateReport(manifest, responses, options) {
         executionTimeMs: sr.executionTimeMs,
         selfHealCount: fixStreamIds.has(sr.id) ? 1 : 0,
         errorCategory: sr.errorDetail?.category,
+        provider: sr.provider,
+        model: sr.model,
+        filesChanged: sr.filesChanged,
     }));
     // Token aggregation
     let totalInput = 0;

package/dist/intelligence/learning-engine.d.ts

@@ -2,7 +2,7 @@
  * Learning engine for adaptive threshold adjustment in Orchex Learn.
  * Correlates context characteristics with execution success and adapts thresholds.
  */
-import type { TelemetryEvent } from '../telemetry/telemetry-types.js';
+import type { TelemetryEvent } from './event-types.js';
 /**
  * Stream categories for per-category learning.
  * Canonical source of truth for stream categorization across all intelligence modules.

package/dist/intelligence/pattern-analyzer.d.ts

@@ -1,4 +1,4 @@
-import type { TelemetryAggregate } from '../telemetry/telemetry-types.js';
+import type { TelemetryAggregate } from './event-types.js';
 import type { ErrorCategory } from './error-analyzer.js';
 export interface RetryPattern {
     category: ErrorCategory;

package/dist/intelligence/slicing-metrics.d.ts

@@ -5,7 +5,7 @@
  * NOTE: StreamCategory and categorizeStream are imported from learning-engine.ts
  * to maintain a single source of truth for stream categorization.
  */
-import type { TelemetryEvent } from '../telemetry/telemetry-types.js';
+import type { TelemetryEvent } from './event-types.js';
 import type { StreamResult } from '../types.js';
 import { type StreamCategory, categorizeStream as categorizeStreamFromLearningEngine } from './learning-engine.js';
 export type { StreamCategory };

package/dist/orchestrator.js

@@ -12,7 +12,7 @@ import { runCommands } from './commands.js';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { loadConfig, getConfiguredModel } from './config.js';
-import { getTier } from './tiers.js';
+import { getTier, getEffectiveTier } from './tiers.js';
 import { broadcaster } from './execution-broadcaster.js';
 import { streamResultToTelemetryEvent, appendLocalEvents, runLearningCycle, } from './intelligence/learning-engine.js';
 import { routeStream, loadRoutingRules } from './intelligence/smart-router.js';
@@ -649,7 +649,14 @@ async function executeWaveInternal(projectDir, executor, options, logger) {
     // 7a. SELF-HEAL — generate fix streams for failed streams (tier-gated)
     const fixStreamsGenerated = [];
     const currentManifest = await loadManifest(projectDir);
-    const tier = getTier(config.tier ?? 'free');
+    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');
+    const tier = getTier(effectiveTierId);
     if (tier.selfHealing === 'full') {
         for (const sr of streamResults) {
             if (sr.status !== 'failed' || sr.id === 'unknown')

package/dist/tools.js

@@ -865,6 +865,18 @@ export function registerTools(server, executor, context) {
                                     done: true,
                                 }]);
                             await saveReportLocally(projectDir, report);
+                            // Sync to cloud if locally authenticated (no ToolContext historyStore)
+                            if (!context?.historyStore) {
+                                try {
+                                    const { loadConfig } = await import('./config.js');
+                                    const { syncReportToCloud } = await import('./cloud-sync.js');
+                                    const syncConfig = await loadConfig();
+                                    await syncReportToCloud(syncConfig, report);
+                                }
+                                catch {
+                                    // Sync is best-effort
+                                }
+                            }
                             const summary = generateLearningSummary(report);
                             await logger.info('execution_report_saved', {
                                 runId: report.runId,
@@ -980,6 +992,18 @@ export function registerTools(server, executor, context) {
                             const reportManifest = await loadManifest(projectDir);
                             const report = generateReport(reportManifest, [result]);
                             await saveReportLocally(projectDir, report);
+                            // Sync to cloud if locally authenticated (no ToolContext historyStore)
+                            if (!context?.historyStore) {
+                                try {
+                                    const { loadConfig } = await import('./config.js');
+                                    const { syncReportToCloud } = await import('./cloud-sync.js');
+                                    const syncConfig = await loadConfig();
+                                    await syncReportToCloud(syncConfig, report);
+                                }
+                                catch {
+                                    // Sync is best-effort
+                                }
+                            }
                             const summary = generateLearningSummary(report);
                             await logger.info('execution_report_saved', {
                                 runId: report.runId,
@@ -1637,6 +1661,18 @@ export function registerTools(server, executor, context) {
             const manifest = await loadManifest(projectDir);
             const report = generateReport(manifest, allResponses);
             await saveReportLocally(projectDir, report);
+            // Sync to cloud if locally authenticated (no ToolContext historyStore)
+            if (!context?.historyStore) {
+                try {
+                    const { loadConfig } = await import('./config.js');
+                    const { syncReportToCloud } = await import('./cloud-sync.js');
+                    const syncConfig = await loadConfig();
+                    await syncReportToCloud(syncConfig, report);
+                }
+                catch {
+                    // Sync is best-effort
+                }
+            }
             // 8. Generate learning summary
             const summary = generateLearningSummary(report);
             // 9. Mark first-run complete

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@wundam/orchex",
-  "version": "1.0.0-rc.6",
+  "mcpName": "com.orchex/orchex",
+  "version": "1.0.0-rc.8",
   "description": "Autopilot AI orchestration — auto-plan, parallelize, and execute with ownership enforcement",
   "type": "module",
   "main": "dist/index.js",
@@ -75,6 +76,8 @@
     "dist/config.d.ts",
     "dist/key-cache.js",
     "dist/key-cache.d.ts",
+    "dist/cloud-sync.js",
+    "dist/cloud-sync.d.ts",
     "dist/context-builder.js",
     "dist/context-builder.d.ts",
     "dist/cost.js",