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

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

@@ -209,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):

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/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/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@wundam/orchex",
-  "version": "1.0.0-rc.7",
+  "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",