@wundam/orchex 1.0.0-rc.27 → 1.0.0-rc.29

package/README.md

@@ -13,7 +13,7 @@ Your AI assistant does tasks one at a time. Orchex makes it do 10 at once — sa
 - **`orchex run`** — Describe what you want, get parallel execution. Auto-generates plans, previews waves, executes with ownership enforcement.
 - **`orchex learn`** — The advanced path. Paste a markdown plan, get executable parallel streams with dependency inference and anti-pattern detection.
 - **Self-Healing** — Categorized error analysis with targeted fix streams. Not blind retry. Model validation before execution prevents wasted API calls.
-- **Multi-LLM** — OpenAI, Gemini, Claude, DeepSeek, Ollama, AWS Bedrock. Dynamic model registry auto-discovers available models. Key-aware routing prevents "model not found" errors.
+- **Multi-LLM** — OpenAI, Gemini, Claude, DeepSeek, Kimi (Moonshot AI), Ollama, AWS Bedrock. Dynamic model registry auto-discovers available models. Key-aware routing prevents "model not found" errors.
 - **BYOK** — Bring your own API key from any supported provider. You control costs.
 
 ## Prerequisites
@@ -24,6 +24,7 @@ Your AI assistant does tasks one at a time. Orchex makes it do 10 at once — sa
   - `OPENAI_API_KEY` for OpenAI (GPT-4.1, o1, o3)
   - `GEMINI_API_KEY` for Google Gemini
   - `DEEPSEEK_API_KEY` for DeepSeek (V3, Coder, R1)
+  - `KIMI_API_KEY` for Kimi / Moonshot AI (K2, moonshot-v1; `MOONSHOT_API_KEY` alias accepted)
   - Configure Ollama for local models
   - `AWS_ACCESS_KEY_ID` + `AWS_SECRET_ACCESS_KEY` for AWS Bedrock
 

package/dist/artifacts.js

@@ -420,6 +420,10 @@ export async function writeArtifact(projectDir, streamId, artifact) {
     await fs.writeFile(artifactPath, JSON.stringify(artifact, null, 2), 'utf-8');
     return artifactPath;
 }
+// Artifact-application trust boundary. Plan-level ownership is enforced
+// upstream by validatePlan (src/intelligence/plan-contract.ts); this
+// function guards the different trust boundary where LLM-generated
+// artifacts try to apply their output.
 /**
  * Check whether all file operations fall within the stream's owns patterns.
  *

package/dist/cloud-executor.js

@@ -1,5 +1,17 @@
 import { extractArtifact } from './artifacts.js';
 import { validateOwnership } from './utils/ownership-validator.js';
+function parseProviderErrorBody(body) {
+    try {
+        const parsed = JSON.parse(body);
+        const message = parsed?.error?.message ?? parsed?.message;
+        if (typeof message === 'string')
+            return message;
+    }
+    catch {
+        // Not JSON — return null
+    }
+    return null;
+}
 /**
  * Returns actionable error messages for cloud API failures.
  * Status-code-specific guidance tells users exactly how to fix each error.
@@ -18,6 +30,16 @@ function formatCloudError(status, body) {
             const modelHint = modelMatch ? ` "${modelMatch[1]}"` : '';
             return `Model${modelHint} not found (404)${detail}.\n\nRun \`orchex config --model <model>\` to use a different model.`;
         }
+        case 400: {
+            const providerMsg = parseProviderErrorBody(body);
+            if (providerMsg && /credit balance|insufficient|billing/i.test(providerMsg)) {
+                return `LLM provider billing error (400): ${providerMsg}\n\nTop up credits at your provider's billing page, or switch providers with \`orchex config --provider <provider>\`.`;
+            }
+            if (providerMsg) {
+                return `LLM provider error (400): ${providerMsg}`;
+            }
+            return `Cloud API error: 400${detail}`;
+        }
         case 429:
             return `Quota exceeded (429)${detail}.\n\nYou've used all cloud runs for this period. Upgrade at https://orchex.dev/pricing`;
         default:
@@ -180,11 +202,18 @@ export class CloudExecutor {
                         };
                     }
                     if (job.status === 'failed') {
+                        const rawError = job.error ?? 'Cloud execution failed';
+                        const providerMsg = parseProviderErrorBody(rawError);
+                        const formattedError = providerMsg
+                            ? (/credit balance|insufficient|billing/i.test(providerMsg)
+                                ? `LLM provider billing error: ${providerMsg}\n\nTop up credits at your provider's billing page, or switch providers with \`orchex config --provider <provider>\`.`
+                                : `LLM provider error: ${providerMsg}`)
+                            : rawError;
                         return {
                             success: false,
                             rawResponse: job.output ?? '',
                             tokensUsed: job.tokensUsed ?? { input: 0, output: 0 },
-                            error: job.error ?? 'Cloud execution failed',
+                            error: formattedError,
                         };
                     }
                     // Job still pending/running - wait with adaptive interval

package/dist/config.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 export declare const PRODUCTION_URL = "https://orchex.dev";
-export declare const LLMProviderSchema: z.ZodEnum<["anthropic", "openai", "gemini", "ollama", "deepseek", "bedrock"]>;
+export declare const LLMProviderSchema: z.ZodEnum<["anthropic", "openai", "gemini", "ollama", "deepseek", "bedrock", "kimi"]>;
 export type LLMProvider = z.infer<typeof LLMProviderSchema>;
 /**
  * Detect the LLM provider based on available environment variables.
@@ -51,7 +51,7 @@ export declare const ConfigSchema: z.ZodObject<{
     /** User's subscription tier (synced from cloud on login) */
     tier: z.ZodDefault<z.ZodEnum<["free", "pro", "team", "enterprise"]>>;
     /** LLM provider (auto-detected if not set) */
-    provider: z.ZodOptional<z.ZodEnum<["anthropic", "openai", "gemini", "ollama", "deepseek", "bedrock"]>>;
+    provider: z.ZodOptional<z.ZodEnum<["anthropic", "openai", "gemini", "ollama", "deepseek", "bedrock", "kimi"]>>;
     /** LLM model (uses provider default if not set) */
     model: z.ZodOptional<z.ZodString>;
     /** Cached trial runs remaining (synced from cloud on login) */
@@ -77,13 +77,13 @@ export declare const ConfigSchema: z.ZodObject<{
         endpoint?: string | undefined;
     };
     apiKey?: string | undefined;
-    provider?: "anthropic" | "openai" | "gemini" | "ollama" | "deepseek" | "bedrock" | undefined;
+    provider?: "anthropic" | "openai" | "gemini" | "ollama" | "deepseek" | "bedrock" | "kimi" | undefined;
     model?: string | undefined;
     trialRunsRemaining?: number | undefined;
     accountCreatedAt?: string | undefined;
 }, {
     apiKey?: string | undefined;
-    provider?: "anthropic" | "openai" | "gemini" | "ollama" | "deepseek" | "bedrock" | undefined;
+    provider?: "anthropic" | "openai" | "gemini" | "ollama" | "deepseek" | "bedrock" | "kimi" | undefined;
     mode?: "local" | "cloud" | undefined;
     apiUrl?: string | undefined;
     tier?: "free" | "pro" | "team" | "enterprise" | undefined;

package/dist/config.js

@@ -10,7 +10,7 @@ export const PRODUCTION_URL = 'https://orchex.dev';
 // ============================================================================
 // LLM Provider Configuration
 // ============================================================================
-export const LLMProviderSchema = z.enum(['anthropic', 'openai', 'gemini', 'ollama', 'deepseek', 'bedrock']);
+export const LLMProviderSchema = z.enum(['anthropic', 'openai', 'gemini', 'ollama', 'deepseek', 'bedrock', 'kimi']);
 /**
  * Detect the LLM provider based on available environment variables.
  * Priority: ORCHEX_PROVIDER env var > first available API key
@@ -18,7 +18,7 @@ export const LLMProviderSchema = z.enum(['anthropic', 'openai', 'gemini', 'ollam
 export function detectProvider() {
     // Explicit provider override
     const explicit = process.env.ORCHEX_PROVIDER?.toLowerCase();
-    if (explicit && ['anthropic', 'openai', 'gemini', 'ollama', 'deepseek', 'bedrock'].includes(explicit)) {
+    if (explicit && ['anthropic', 'openai', 'gemini', 'ollama', 'deepseek', 'bedrock', 'kimi'].includes(explicit)) {
         return explicit;
     }
     // Auto-detect from available API keys (priority order)
@@ -30,6 +30,8 @@ export function detectProvider() {
         return 'gemini';
     if (process.env.DEEPSEEK_API_KEY)
         return 'deepseek';
+    if (process.env.KIMI_API_KEY || process.env.MOONSHOT_API_KEY)
+        return 'kimi';
     if (process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY)
         return 'bedrock';
     if (process.env.OLLAMA_BASE_URL || process.env.OLLAMA_HOST)
@@ -63,6 +65,8 @@ export function getProviderApiKey(provider) {
             return process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY;
         case 'deepseek':
             return process.env.DEEPSEEK_API_KEY;
+        case 'kimi':
+            return process.env.KIMI_API_KEY || process.env.MOONSHOT_API_KEY;
         case 'bedrock':
             return undefined; // Bedrock uses AWS credentials, not API key
         case 'ollama':
@@ -76,6 +80,8 @@ export function getProviderBaseUrl(provider) {
     switch (provider) {
         case 'deepseek':
             return process.env.DEEPSEEK_BASE_URL || 'https://api.deepseek.com/v1';
+        case 'kimi':
+            return process.env.KIMI_BASE_URL || 'https://api.moonshot.ai/v1';
         case 'ollama':
             return process.env.OLLAMA_BASE_URL || process.env.OLLAMA_HOST || 'http://localhost:11434';
         default:
@@ -93,6 +99,7 @@ export const DEFAULT_MODELS = {
     deepseek: 'deepseek-coder',
     bedrock: 'claude-3.5-sonnet',
     ollama: 'llama3.3:70b',
+    kimi: 'kimi-k2-0905-preview',
 };
 /**
  * Get the configured provider.

package/dist/cost.js

@@ -10,6 +10,7 @@ export const PROVIDER_RATES = {
     openai: { input: 0.03, output: 0.06 }, // GPT-4 Turbo
     gemini: { input: 0.00075, output: 0.003 }, // Gemini 1.5 Pro, 2026 pricing
     deepseek: { input: 0.00014, output: 0.0006 }, // Deepseek-VL
+    kimi: { input: 0.0006, output: 0.0025 }, // Kimi K2 rate (Q1 2026 public)
     ollama: { input: 0, output: 0 }, // Local, free
 };
 import { getModelCosts } from './intelligence/index.js';

package/dist/executors/base.d.ts

@@ -91,9 +91,9 @@ export { Semaphore };
  * Default models for each provider.
  * Re-exported from config.ts for backward compatibility.
  */
-export declare const DEFAULT_MODELS: Record<"anthropic" | "openai" | "gemini" | "ollama" | "deepseek" | "bedrock", string>;
+export declare const DEFAULT_MODELS: Record<"anthropic" | "openai" | "gemini" | "ollama" | "deepseek" | "bedrock" | "kimi", string>;
 /**
  * Map a generic model name to provider-specific model.
  * Allows users to specify "claude-sonnet-4-5" and it gets translated appropriately.
  */
-export declare function mapModelToProvider(requestedModel: string, provider: 'anthropic' | 'openai' | 'gemini' | 'ollama' | 'deepseek'): string;
+export declare function mapModelToProvider(requestedModel: string, provider: 'anthropic' | 'openai' | 'gemini' | 'ollama' | 'deepseek' | 'kimi'): string;

package/dist/executors/base.js

@@ -198,6 +198,9 @@ export function mapModelToProvider(requestedModel, provider) {
     if (requestedModel.startsWith('deepseek-')) {
         return requestedModel;
     }
+    if (requestedModel.startsWith('kimi-') || requestedModel.startsWith('moonshot-')) {
+        return requestedModel;
+    }
     if (requestedModel.includes(':') || requestedModel.startsWith('llama') || requestedModel.startsWith('mistral')) {
         return requestedModel;
     }

package/dist/executors/index.d.ts

@@ -12,6 +12,7 @@ export { GeminiExecutor } from './gemini-executor.js';
 export { OllamaExecutor } from './ollama-executor.js';
 export { DeepseekExecutor } from './deepseek-executor.js';
 export { BedrockExecutor } from './bedrock-executor.js';
+export { KimiExecutor } from './kimi-executor.js';
 export * from './base.js';
 /**
  * Options for creating an executor.

package/dist/executors/index.js

@@ -11,6 +11,7 @@ import { GeminiExecutor } from './gemini-executor.js';
 import { OllamaExecutor } from './ollama-executor.js';
 import { DeepseekExecutor } from './deepseek-executor.js';
 import { BedrockExecutor } from './bedrock-executor.js';
+import { KimiExecutor } from './kimi-executor.js';
 // Re-export individual executors
 export { ClaudeExecutor } from '../claude-executor.js';
 export { OpenAIExecutor } from './openai-executor.js';
@@ -18,6 +19,7 @@ export { GeminiExecutor } from './gemini-executor.js';
 export { OllamaExecutor } from './ollama-executor.js';
 export { DeepseekExecutor } from './deepseek-executor.js';
 export { BedrockExecutor } from './bedrock-executor.js';
+export { KimiExecutor } from './kimi-executor.js';
 // Re-export base utilities
 export * from './base.js';
 /**
@@ -90,6 +92,15 @@ export function createExecutor(options = {}) {
                 timeoutMs: options.timeoutMs,
                 maxConcurrency: options.maxConcurrency,
             }));
+        case 'kimi':
+            return new KimiExecutor(defined({
+                apiKey: options.apiKey ?? getProviderApiKey('kimi'),
+                baseUrl: options.baseUrl ?? getProviderBaseUrl('kimi'),
+                maxRetries: options.maxRetries,
+                retryDelayMs: options.retryDelayMs,
+                timeoutMs: options.timeoutMs,
+                maxConcurrency: options.maxConcurrency,
+            }));
         case 'bedrock':
             return new BedrockExecutor(defined({
                 maxRetries: options.maxRetries,
@@ -98,7 +109,7 @@ export function createExecutor(options = {}) {
                 maxConcurrency: options.maxConcurrency,
             }));
         default:
-            throw new Error(`Unknown provider: ${provider}. Supported: anthropic, openai, gemini, ollama, deepseek, bedrock`);
+            throw new Error(`Unknown provider: ${provider}. Supported: anthropic, openai, gemini, ollama, deepseek, bedrock, kimi`);
     }
 }
 /**
@@ -116,6 +127,7 @@ export function getProviderStatus() {
         ollama: 'Ollama (local)',
         deepseek: 'DeepSeek',
         bedrock: 'AWS Bedrock',
+        kimi: 'Kimi (Moonshot AI)',
     };
     if (provider === 'ollama') {
         return {
@@ -162,6 +174,8 @@ export function listConfiguredProviders() {
         configured.push('gemini');
     if (process.env.DEEPSEEK_API_KEY)
         configured.push('deepseek');
+    if (process.env.KIMI_API_KEY || process.env.MOONSHOT_API_KEY)
+        configured.push('kimi');
     if (process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY)
         configured.push('bedrock');
     if (process.env.OLLAMA_BASE_URL || process.env.OLLAMA_HOST)
@@ -189,6 +203,7 @@ export async function getFullStatus() {
         ollama: 'Ollama (local)',
         deepseek: 'DeepSeek',
         bedrock: 'AWS Bedrock',
+        kimi: 'Kimi (Moonshot AI)',
     };
     if (provider === 'ollama') {
         return {

package/dist/executors/kimi-executor.d.ts

@@ -0,0 +1,18 @@
+import type { ExecutorStrategy, ExecutionRequest, ExecutionResult } from '../types.js';
+import { ExecutorConfig } from './base.js';
+export interface KimiExecutorConfig extends ExecutorConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare class KimiExecutor implements ExecutorStrategy {
+    readonly provider = "kimi";
+    private config;
+    private semaphore;
+    private apiKey;
+    private baseUrl;
+    constructor(config?: Partial<KimiExecutorConfig>);
+    execute(request: ExecutionRequest): Promise<ExecutionResult>;
+    private executeWithRetry;
+    private callApi;
+    private buildMessages;
+}

package/dist/executors/kimi-executor.js

@@ -0,0 +1,136 @@
+import { DEFAULT_EXECUTOR_CONFIG, Semaphore, sleep, isRetryableError, calculateBackoff, extractArtifactDetailed, buildOpenAIMessages, DEFAULT_MODELS, withCircuitBreaker, classifyExecutionError, } from './base.js';
+const KIMI_BASE_URL = 'https://api.moonshot.ai/v1';
+const KIMI_MAX_OUTPUT_TOKENS = 8192;
+export class KimiExecutor {
+    provider = 'kimi';
+    config;
+    semaphore;
+    apiKey;
+    baseUrl;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_EXECUTOR_CONFIG, ...config };
+        this.apiKey = config.apiKey ?? process.env.KIMI_API_KEY ?? process.env.MOONSHOT_API_KEY ?? '';
+        this.baseUrl = config.baseUrl ?? process.env.KIMI_BASE_URL ?? KIMI_BASE_URL;
+        this.semaphore = new Semaphore(this.config.maxConcurrency);
+        if (!this.apiKey) {
+            throw new Error('Kimi API key required. Set KIMI_API_KEY environment variable.');
+        }
+    }
+    async execute(request) {
+        const release = await this.semaphore.acquire();
+        try {
+            return await withCircuitBreaker(this.provider, request.model, () => this.executeWithRetry(request));
+        }
+        finally {
+            release();
+        }
+    }
+    async executeWithRetry(request) {
+        let lastError;
+        for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
+            if (attempt > 0 && lastError) {
+                const classified = classifyExecutionError(lastError);
+                const delay = classified.retryAfterMs ?? calculateBackoff(attempt, this.config.retryDelayMs);
+                await sleep(delay);
+            }
+            try {
+                return await this.callApi(request);
+            }
+            catch (error) {
+                lastError = error;
+                if (!isRetryableError(error)) {
+                    return {
+                        success: false,
+                        rawResponse: '',
+                        tokensUsed: { input: 0, output: 0 },
+                        error: lastError.message,
+                    };
+                }
+                if (attempt === this.config.maxRetries) {
+                    break;
+                }
+            }
+        }
+        return {
+            success: false,
+            rawResponse: '',
+            tokensUsed: { input: 0, output: 0 },
+            error: `Failed after ${this.config.maxRetries + 1} attempts: ${lastError?.message}`,
+        };
+    }
+    async callApi(request) {
+        // Kimi models: kimi-k2-*, kimi-latest, moonshot-v1-*
+        const model = (request.model.startsWith('kimi-') || request.model.startsWith('moonshot-'))
+            ? request.model
+            : DEFAULT_MODELS.kimi;
+        const effectiveTimeout = request.timeoutMs ?? this.config.timeoutMs;
+        const messages = this.buildMessages(request);
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), effectiveTimeout);
+        try {
+            const response = await fetch(`${this.baseUrl}/chat/completions`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.apiKey}`,
+                },
+                body: JSON.stringify({
+                    model,
+                    messages,
+                    max_tokens: Math.min(request.maxTokens, KIMI_MAX_OUTPUT_TOKENS),
+                    stream: false,
+                }),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                const errorBody = await response.text().catch(() => 'Unknown error');
+                const error = new Error(`Kimi API error: ${response.status} ${errorBody}`);
+                error.status = response.status;
+                throw error;
+            }
+            const data = await response.json();
+            const rawResponse = data.choices?.[0]?.message?.content ?? '';
+            const { artifact, diagnostic } = extractArtifactDetailed(rawResponse);
+            if (!artifact) {
+                const errorDetail = diagnostic.jsonRepaired
+                    ? `Artifact JSON was repaired but still invalid (strategy: ${diagnostic.strategy})`
+                    : diagnostic.error ?? 'No valid orchex-artifact block found in response';
+                return {
+                    success: false,
+                    rawResponse,
+                    tokensUsed: {
+                        input: data.usage?.prompt_tokens ?? 0,
+                        output: data.usage?.completion_tokens ?? 0,
+                    },
+                    error: errorDetail,
+                };
+            }
+            return {
+                success: true,
+                rawResponse,
+                artifact,
+                tokensUsed: {
+                    input: data.usage?.prompt_tokens ?? 0,
+                    output: data.usage?.completion_tokens ?? 0,
+                },
+            };
+        }
+        catch (error) {
+            if (error.name === 'AbortError') {
+                return {
+                    success: false,
+                    rawResponse: '',
+                    tokensUsed: { input: 0, output: 0 },
+                    error: `API call timed out after ${effectiveTimeout}ms`,
+                };
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    buildMessages(request) {
+        return buildOpenAIMessages(request);
+    }
+}

package/dist/index.js

@@ -6,6 +6,7 @@ import { ORCHEX_INSTRUCTIONS } from './mcp-instructions.js';
 import { registerResources } from './mcp-resources.js';
 import { broadcaster } from './execution-broadcaster.js';
 import { loadConfig, saveConfig, maskConfigForDisplay, resolveApiUrl, PRODUCTION_URL, LLMProviderSchema } from './config.js';
+import { analyzeError } from './intelligence/index.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) {
@@ -335,11 +336,11 @@ async function handleConfigCommand(args) {
                 updates.mode = 'local';
                 break;
             case '--provider':
+                const validProviders = LLMProviderSchema.options;
                 if (!value) {
-                    console.error('Error: --provider requires a value (anthropic, openai, gemini, deepseek, ollama)');
+                    console.error(`Error: --provider requires a value (${validProviders.join(', ')})`);
                     process.exit(1);
                 }
-                const validProviders = LLMProviderSchema.options;
                 if (!validProviders.includes(value)) {
                     console.error(`Error: Invalid provider "${value}". Valid: ${validProviders.join(', ')}`);
                     process.exit(1);
@@ -619,6 +620,17 @@ async function handleRunCommand(args) {
     }
     // Init and execute
     console.log(`\nInitializing orchestration: "${plan.title}"\n`);
+    // Plan-contract boundary (Session 13): fail fast on invalid streams before
+    // they reach the legacy 5-layer validation. Additive — existing layers stay
+    // in place as defense-in-depth until Session 14 consolidates them.
+    {
+        const { validatePlan, formatPlanValidationErrors } = await import('./intelligence/index.js');
+        const validation = validatePlan(streamDefs, projectDir);
+        if (!validation.ok) {
+            console.error('Plan validation failed:\n' + formatPlanValidationErrors(validation.errors));
+            process.exit(1);
+        }
+    }
     await initOrchestration(projectDir, plan.title, streamDefs);
     const allResponses = [];
     let executionError;
@@ -638,9 +650,13 @@ async function handleRunCommand(args) {
                         process.stdout.write(`  ✓ ${event.data.streamId} — complete${dur}\n`);
                         break;
                     }
-                    case 'stream_failed':
-                        process.stdout.write(`  ✗ ${event.data.streamId} — failed: ${String(event.data.error).slice(0, 100)}\n`);
+                    case 'stream_failed': {
+                        const errStr = String(event.data.error);
+                        const analysis = analyzeError(errStr);
+                        const categoryTag = analysis.category !== 'unknown' ? ` [${analysis.category}]` : '';
+                        process.stdout.write(`  ✗ ${event.data.streamId} — failed${categoryTag}: ${errStr.slice(0, 200)}\n`);
                         break;
+                    }
                     case 'stream_rate_limited':
                         process.stdout.write(`  ⏳ ${event.data.streamId} — rate limited (retry in ${Math.round((event.data.retryAfterMs ?? 0) / 1000)}s)\n`);
                         break;

package/dist/intelligence/index.d.ts

@@ -1,10 +1,12 @@
-export { gatherProjectContext, generatePlan } from './auto-planner.js';
+export { gatherProjectContext, generatePlan, extractSpecPaths } 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 { validatePlan, formatPlanValidationErrors, StreamDefinitionSchema as PlanContractStreamSchema } from './plan-contract.js';
+export type { PlanValidationError, ValidatePlanResult, StreamDefinition as PlanContractStream } from './plan-contract.js';
+export { formatPlanPreview, formatPlanPreviewText, generatePlanPreview, type ModelDecision, type PlanPreview, type GeneratePlanPreviewInput, type GeneratePlanPreviewResult, } from './plan-preview.js';
 export { detectSequentialEdits, autoFixSequentialEdits } from './sequential-diagnostics.js';
 export type { SequentialEditDiagnostic } from './sequential-diagnostics.js';
 export { createDiagnostics, detectOwnershipConflicts } from './diagnostics.js';