@10et/cli 1.0.0

package/dist/lib/stratus-client.js

@@ -0,0 +1,739 @@
+/**
+ * Stratus X1 Reasoning API Client
+ *
+ * Provides reasoning-based analysis and synthesis capabilities
+ * for Context Hub journal entries and project documentation.
+ * Extended with world model dynamics prediction support.
+ *
+ * @purpose Client for calling Stratus X1 reasoning API to synthesize context and predict dynamics
+ */
+import { readFileSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+const CIRCUIT_BREAKER_THRESHOLD = 3;
+const CIRCUIT_BREAKER_WINDOW_MS = 5 * 60 * 1000; // 5 minutes
+const CIRCUIT_BREAKER_RESET_MS = 5 * 60 * 1000; // 5 minutes to half-open
+// ============================================================================
+// Stratus Client
+// ============================================================================
+export class StratusClient {
+    baseUrl;
+    apiKey;
+    model;
+    timeout;
+    circuitBreaker = {
+        failures: [],
+        isOpen: false,
+    };
+    /**
+     * Check if circuit breaker is open (should skip Stratus calls)
+     */
+    isCircuitOpen() {
+        if (!this.circuitBreaker.isOpen)
+            return false;
+        // Check if enough time has passed to try again (half-open)
+        const now = Date.now();
+        if (this.circuitBreaker.openedAt &&
+            now - this.circuitBreaker.openedAt > CIRCUIT_BREAKER_RESET_MS) {
+            // Try to close the circuit
+            this.circuitBreaker.isOpen = false;
+            this.circuitBreaker.openedAt = undefined;
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Record a failure for circuit breaker
+     */
+    recordFailure() {
+        const now = Date.now();
+        this.circuitBreaker.failures.push(now);
+        // Clean up old failures outside the window
+        this.circuitBreaker.failures = this.circuitBreaker.failures.filter(ts => now - ts < CIRCUIT_BREAKER_WINDOW_MS);
+        // Check if we should open the circuit
+        if (this.circuitBreaker.failures.length >= CIRCUIT_BREAKER_THRESHOLD) {
+            this.circuitBreaker.isOpen = true;
+            this.circuitBreaker.openedAt = now;
+        }
+    }
+    /**
+     * Record a success for circuit breaker
+     */
+    recordSuccess() {
+        this.circuitBreaker.failures = [];
+        this.circuitBreaker.isOpen = false;
+        this.circuitBreaker.openedAt = undefined;
+    }
+    readDotenv() {
+        try {
+            const envPath = resolve(process.cwd(), ".env");
+            if (!existsSync(envPath))
+                return {};
+            const content = readFileSync(envPath, "utf-8");
+            const result = {};
+            for (const line of content.split("\n")) {
+                const match = line.match(/^([A-Z_][A-Z0-9_]*)=(.+)$/);
+                if (match)
+                    result[match[1]] = match[2].trim().replace(/^["']|["']$/g, "");
+            }
+            return result;
+        }
+        catch {
+            return {};
+        }
+    }
+    constructor(options = {}) {
+        // Read .env file first (shell env may have stale keys)
+        const dotenv = this.readDotenv();
+        this.baseUrl = options.baseUrl || dotenv.STRATUS_API_URL || process.env.STRATUS_API_URL || "https://api.stratus.run";
+        this.apiKey = options.apiKey || dotenv.STRATUS_API_KEY || process.env.STRATUS_API_KEY || "";
+        this.model = options.model || "stratus-x1ac-base-claude-sonnet-4-5";
+        this.timeout = options.timeout || 30000; // 30 seconds default
+    }
+    /**
+     * Call Stratus reasoning API with a prompt
+     */
+    async reason(prompt, options = {}) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const startTime = Date.now();
+        try {
+            const request = {
+                model: this.model,
+                messages: [{ role: "user", content: prompt }],
+                temperature: options.temperature ?? 0.7,
+                max_tokens: options.maxTokens ?? 2000
+            };
+            const headers = {
+                "Content-Type": "application/json"
+            };
+            if (this.apiKey) {
+                headers["Authorization"] = `Bearer ${this.apiKey}`;
+            }
+            const response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(request),
+                signal: controller.signal
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Stratus API error (${response.status}): ${errorText}`);
+            }
+            const result = await response.json();
+            try {
+                const { telemetry } = await import('./telemetry.js');
+                const { estimateCost } = await import('./model-pricing.js');
+                const durationMs = Date.now() - startTime;
+                const modelName = result.stratus?.execution_llm || result.model || this.model;
+                telemetry.track({
+                    category: 'performance',
+                    event: 'stratus:api_call',
+                    duration_ms: durationMs,
+                    success: true,
+                    model_name: modelName,
+                    stratus_model: result.stratus?.model,
+                    execution_llm: result.stratus?.execution_llm,
+                    prompt_tokens: result.usage?.prompt_tokens,
+                    completion_tokens: result.usage?.completion_tokens,
+                    total_tokens: result.usage?.total_tokens,
+                    estimated_cost_usd: result.usage
+                        ? estimateCost(modelName, result.usage.prompt_tokens, result.usage.completion_tokens)
+                        : undefined,
+                    stratus_confidence: result.stratus?.confidence,
+                    planning_time_ms: result.stratus?.planning_time_ms,
+                    execution_time_ms: result.stratus?.execution_time_ms,
+                    feature_context: options.featureContext,
+                });
+            }
+            catch {
+                // telemetry is fire-and-forget
+            }
+            return result;
+        }
+        catch (error) {
+            if (error.name === "AbortError") {
+                throw new Error(`Stratus request timed out after ${this.timeout}ms`);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    /**
+     * Synthesize journal entries into structured summary
+     */
+    async synthesizeJournalEntries(entries, options = {}) {
+        const focus = options.focus || "all";
+        // Build focused prompt based on what user wants
+        const focusInstructions = {
+            decisions: "Focus on key decisions made, including the options considered and rationale for each choice.",
+            problems: "Focus on problems encountered and how they were solved, including root causes and learnings.",
+            progress: "Focus on what was accomplished, current status, and momentum toward goals.",
+            all: "Provide a comprehensive analysis covering decisions, problems solved, progress made, and next steps."
+        };
+        const prompt = `Analyze these journal entries from a software project.
+
+Journal Entries:
+${JSON.stringify(entries, null, 2)}
+
+${focusInstructions[focus]}
+
+Provide a structured summary in the following format:
+
+## Summary
+{2-3 sentence overview of what happened}
+
+## Key Decisions Made
+{List decisions with brief rationale - format: "Decision: Rationale"}
+
+## Problems Solved
+{List problems and their solutions - format: "Problem: Solution"}
+
+## Incomplete Items
+{List what's stubbed, planned, or not yet done}
+
+## Next Steps
+{What should happen next}
+
+Be concise but specific. Cite entry timestamps when referencing specific work.`;
+        const startTime = Date.now();
+        const response = await this.reason(prompt, {
+            temperature: 0.7,
+            maxTokens: 2000,
+            featureContext: 'synthesis',
+        });
+        const executionTime = Date.now() - startTime;
+        const content = response.choices[0]?.message?.content || "";
+        // Parse structured response
+        const synthesis = this.parseStructuredSummary(content);
+        return {
+            ...synthesis,
+            rawResponse: content,
+            confidence: response.stratus?.confidence,
+            executionTime
+        };
+    }
+    /**
+     * Parse Stratus response into structured format
+     */
+    parseStructuredSummary(content) {
+        const result = {
+            summary: "",
+            decisions: [],
+            problemsSolved: [],
+            incompleteItems: [],
+            nextSteps: []
+        };
+        // Extract summary
+        const summaryMatch = content.match(/## Summary\s*\n([\s\S]*?)(?=\n##|$)/i);
+        if (summaryMatch) {
+            result.summary = summaryMatch[1].trim();
+        }
+        // Extract decisions
+        const decisionsMatch = content.match(/## Key Decisions Made\s*\n([\s\S]*?)(?=\n##|$)/i);
+        if (decisionsMatch) {
+            const decisionsText = decisionsMatch[1].trim();
+            const lines = decisionsText.split('\n').filter(l => l.trim());
+            for (const line of lines) {
+                const match = line.match(/[-*]\s*(.+?):\s*(.+)/);
+                if (match) {
+                    result.decisions.push({
+                        decision: match[1].trim(),
+                        rationale: match[2].trim()
+                    });
+                }
+                else if (line.startsWith('-') || line.startsWith('*')) {
+                    // Fallback for lines without clear separator
+                    const text = line.replace(/^[-*]\s*/, '').trim();
+                    result.decisions.push({
+                        decision: text,
+                        rationale: ""
+                    });
+                }
+            }
+        }
+        // Extract problems solved
+        const problemsMatch = content.match(/## Problems Solved\s*\n([\s\S]*?)(?=\n##|$)/i);
+        if (problemsMatch) {
+            const problemsText = problemsMatch[1].trim();
+            const lines = problemsText.split('\n').filter(l => l.trim());
+            for (const line of lines) {
+                const match = line.match(/[-*]\s*(.+?):\s*(.+)/);
+                if (match) {
+                    result.problemsSolved.push({
+                        problem: match[1].trim(),
+                        solution: match[2].trim()
+                    });
+                }
+                else if (line.startsWith('-') || line.startsWith('*')) {
+                    const text = line.replace(/^[-*]\s*/, '').trim();
+                    result.problemsSolved.push({
+                        problem: text,
+                        solution: ""
+                    });
+                }
+            }
+        }
+        // Extract incomplete items
+        const incompleteMatch = content.match(/## Incomplete Items\s*\n([\s\S]*?)(?=\n##|$)/i);
+        if (incompleteMatch) {
+            const incompleteText = incompleteMatch[1].trim();
+            result.incompleteItems = incompleteText
+                .split('\n')
+                .filter(l => l.trim())
+                .map(l => l.replace(/^[-*]\s*/, '').trim());
+        }
+        // Extract next steps
+        const nextStepsMatch = content.match(/## Next Steps\s*\n([\s\S]*?)(?=\n##|$)/i);
+        if (nextStepsMatch) {
+            const nextStepsText = nextStepsMatch[1].trim();
+            result.nextSteps = nextStepsText
+                .split('\n')
+                .filter(l => l.trim())
+                .map(l => l.replace(/^[-*]\s*/, '').trim());
+        }
+        return result;
+    }
+    /**
+     * Format synthesis result as human-readable text
+     */
+    formatSynthesis(synthesis) {
+        const lines = [];
+        lines.push("# Context Synthesis\n");
+        if (synthesis.summary) {
+            lines.push(synthesis.summary);
+            lines.push("");
+        }
+        if (synthesis.decisions.length > 0) {
+            lines.push("## Key Decisions");
+            for (const { decision, rationale } of synthesis.decisions) {
+                if (rationale) {
+                    lines.push(`- **${decision}**: ${rationale}`);
+                }
+                else {
+                    lines.push(`- ${decision}`);
+                }
+            }
+            lines.push("");
+        }
+        if (synthesis.problemsSolved.length > 0) {
+            lines.push("## Problems Solved");
+            for (const { problem, solution } of synthesis.problemsSolved) {
+                if (solution) {
+                    lines.push(`- **${problem}**: ${solution}`);
+                }
+                else {
+                    lines.push(`- ${problem}`);
+                }
+            }
+            lines.push("");
+        }
+        if (synthesis.incompleteItems.length > 0) {
+            lines.push("## Incomplete Items");
+            for (const item of synthesis.incompleteItems) {
+                lines.push(`- ${item}`);
+            }
+            lines.push("");
+        }
+        if (synthesis.nextSteps.length > 0) {
+            lines.push("## Next Steps");
+            for (const step of synthesis.nextSteps) {
+                lines.push(`- ${step}`);
+            }
+            lines.push("");
+        }
+        if (synthesis.confidence !== undefined) {
+            lines.push(`_Confidence: ${(synthesis.confidence * 100).toFixed(0)}%_`);
+        }
+        if (synthesis.executionTime !== undefined) {
+            lines.push(`_Analysis time: ${(synthesis.executionTime / 1000).toFixed(1)}s_`);
+        }
+        return lines.join("\n");
+    }
+    // ==========================================================================
+    // World Model Dynamics Prediction Methods
+    // ==========================================================================
+    /**
+     * Predict the outcome of an action given the current state
+     * Used by dynamics-model.ts when historical aggregation isn't sufficient
+     *
+     * NOTE: Uses temperature=0 for prediction consistency per refinements doc.
+     * Circuit-breaker: if Stratus fails 3x in 5 min, returns fallback immediately.
+     *
+     * @param state - Current world state
+     * @param action - Action to predict outcome for
+     * @param context - Optional similar historical transitions for context
+     * @returns Predicted outcome with confidence and reasoning
+     */
+    async predictOutcome(state, action, context = []) {
+        // Check circuit breaker - fallback immediately if open
+        if (this.isCircuitOpen()) {
+            return {
+                outcome: {
+                    timestamp: Date.now(),
+                    immediate: {
+                        evalScoreChange: 0,
+                        commitCreated: false,
+                    },
+                },
+                confidence: 0.1,
+                reasoning: "Circuit breaker open - Stratus temporarily unavailable, using fallback",
+                source: "fallback",
+            };
+        }
+        const startTime = Date.now();
+        const stateDesc = this.formatWorldStateForPrompt(state);
+        const actionDesc = this.formatActionForPrompt(action);
+        const contextDesc = context.length > 0
+            ? this.formatContextTransitions(context)
+            : "No similar historical transitions available.";
+        const prompt = `You are predicting the outcome of an AI agent action in a software development system.
+
+## Current System State
+${stateDesc}
+
+## Proposed Action
+${actionDesc}
+
+## Historical Context
+${contextDesc}
+
+## Task
+Predict the likely outcome of this action. Consider:
+1. Immediate effects (eval score change, build status, test results, commit creation)
+2. Medium-term effects (downstream agent impact, human intervention needed, system stability)
+3. What could go wrong and what's likely to succeed
+
+Respond in JSON format:
+{
+  "immediate": {
+    "evalScoreChange": <number between -1 and 1, or null if unknown>,
+    "buildStatus": "success" | "failed" | null,
+    "testResults": {"passed": <number>, "failed": <number>} | null,
+    "commitCreated": <boolean>
+  },
+  "mediumTerm": {
+    "downstreamEvalImpact": {"<agent_id>": <delta>},
+    "humanInterventionRequired": <boolean>,
+    "systemStability": <number 0-1>
+  },
+  "confidence": <number 0-1>,
+  "reasoning": "<brief explanation>"
+}`;
+        try {
+            const response = await this.reason(prompt, {
+                temperature: 0, // Always use temperature=0 for prediction consistency
+                maxTokens: 1000,
+                featureContext: "dynamics_prediction",
+            });
+            const content = response.choices[0]?.message?.content || "{}";
+            const executionTimeMs = Date.now() - startTime;
+            // Parse JSON response
+            const parsed = this.parseJsonFromResponse(content);
+            // Validate JSON structure
+            if (!this.validatePredictionResponse(parsed)) {
+                this.recordFailure();
+                return {
+                    outcome: {
+                        timestamp: Date.now(),
+                        immediate: {
+                            evalScoreChange: 0,
+                            commitCreated: false,
+                        },
+                    },
+                    confidence: 0.1,
+                    reasoning: "Invalid response structure from Stratus",
+                    source: "fallback",
+                };
+            }
+            const outcome = {
+                timestamp: Date.now(),
+                immediate: {
+                    evalScoreChange: parsed.immediate?.evalScoreChange ?? null,
+                    buildStatus: parsed.immediate?.buildStatus ?? null,
+                    testResults: parsed.immediate?.testResults ?? null,
+                    commitCreated: parsed.immediate?.commitCreated ?? false,
+                },
+                mediumTerm: parsed.mediumTerm ? {
+                    downstreamEvalImpact: parsed.mediumTerm.downstreamEvalImpact || {},
+                    humanInterventionRequired: parsed.mediumTerm.humanInterventionRequired ?? false,
+                    systemStability: parsed.mediumTerm.systemStability ?? 0.8,
+                } : undefined,
+            };
+            // Record success for circuit breaker
+            this.recordSuccess();
+            return {
+                outcome,
+                confidence: parsed.confidence ?? response.stratus?.confidence ?? 0.5,
+                reasoning: parsed.reasoning || "Predicted via Stratus reasoning",
+                source: "stratus_inference",
+                stratusMetadata: {
+                    model: response.stratus?.model || this.model,
+                    executionTimeMs,
+                    brainSignal: response.stratus?.execution_llm,
+                },
+            };
+        }
+        catch (error) {
+            // Record failure for circuit breaker
+            this.recordFailure();
+            // Return fallback prediction on error
+            return {
+                outcome: {
+                    timestamp: Date.now(),
+                    immediate: {
+                        evalScoreChange: 0,
+                        commitCreated: false,
+                    },
+                },
+                confidence: 0.1,
+                reasoning: `Prediction failed: ${error instanceof Error ? error.message : "unknown error"}`,
+                source: "fallback",
+            };
+        }
+    }
+    /**
+     * Validate prediction response structure
+     */
+    validatePredictionResponse(parsed) {
+        // Must have immediate object with commitCreated boolean
+        if (!parsed.immediate || typeof parsed.immediate !== "object")
+            return false;
+        if (typeof parsed.immediate.commitCreated !== "boolean" &&
+            parsed.immediate.commitCreated !== undefined)
+            return false;
+        // confidence must be a number if present
+        if (parsed.confidence !== undefined &&
+            (typeof parsed.confidence !== "number" || parsed.confidence < 0 || parsed.confidence > 1)) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Generate counterfactual scenarios for a completed transition
+     *
+     * @param transition - The actual transition that occurred
+     * @param alternativeActions - Alternative actions to evaluate
+     * @returns Array of counterfactual scenarios
+     */
+    async generateCounterfactuals(transition, alternativeActions) {
+        const scenarios = [];
+        const stateDesc = this.formatWorldStateForPrompt(transition.priorState);
+        const actualActionDesc = this.formatActionForPrompt(transition.action);
+        const actualOutcomeDesc = this.formatOutcomeForPrompt(transition.outcome);
+        for (const altAction of alternativeActions) {
+            const altActionDesc = this.formatActionForPrompt(altAction);
+            const prompt = `You are analyzing a counterfactual scenario for an AI agent system.
+
+## Initial State
+${stateDesc}
+
+## What Actually Happened
+Action: ${actualActionDesc}
+Outcome: ${actualOutcomeDesc}
+
+## Counterfactual: What If This Action Was Taken Instead?
+${altActionDesc}
+
+## Task
+Predict what would have happened if the alternative action was taken instead.
+Assign a probability mass (0-1) representing how likely this alternative scenario is.
+
+Respond in JSON format:
+{
+  "immediate": {
+    "evalScoreChange": <number>,
+    "buildStatus": "success" | "failed" | null,
+    "commitCreated": <boolean>
+  },
+  "probabilityMass": <number 0-1>,
+  "reasoning": "<explanation of why this outcome would occur>"
+}`;
+            try {
+                const response = await this.reason(prompt, {
+                    temperature: 0.4,
+                    maxTokens: 800,
+                    featureContext: "counterfactual",
+                });
+                const content = response.choices[0]?.message?.content || "{}";
+                const parsed = this.parseJsonFromResponse(content);
+                const scenario = {
+                    baseTransitionId: transition.id,
+                    alternativeAction: altAction,
+                    predictedOutcome: {
+                        timestamp: Date.now(),
+                        immediate: {
+                            evalScoreChange: parsed.immediate?.evalScoreChange ?? 0,
+                            buildStatus: parsed.immediate?.buildStatus,
+                            commitCreated: parsed.immediate?.commitCreated ?? false,
+                        },
+                    },
+                    probabilityMass: parsed.probabilityMass ?? 0.3,
+                    stratusReasoning: parsed.reasoning || "Counterfactual generated via Stratus",
+                    counterfactualType: this.determineCounterfactualType(transition.action, altAction),
+                    generatedAt: Date.now(),
+                };
+                scenarios.push(scenario);
+            }
+            catch {
+                // Skip failed counterfactuals
+            }
+        }
+        return scenarios;
+    }
+    /**
+     * Simulate a multi-step trajectory from a starting state
+     *
+     * @param state - Starting state
+     * @param actionSequence - Sequence of actions to simulate
+     * @param maxSteps - Maximum steps to simulate
+     * @returns Simulated trajectory of state transitions
+     */
+    async simulateTrajectory(state, actionSequence, maxSteps = 5) {
+        const trajectory = [];
+        let currentState = state;
+        const steps = Math.min(actionSequence.length, maxSteps);
+        for (let i = 0; i < steps; i++) {
+            const action = actionSequence[i];
+            const prediction = await this.predictOutcome(currentState, action);
+            // Create synthetic posterior state based on prediction
+            const posteriorState = {
+                ...currentState,
+                timestamp: Date.now() + (i + 1) * 60000, // Advance by 1 minute per step
+                agentState: {
+                    ...currentState.agentState,
+                    lastEvalScore: currentState.agentState.lastEvalScore +
+                        (prediction.outcome.immediate.evalScoreChange || 0),
+                    actionHistory: [...currentState.agentState.actionHistory, action.actionType].slice(-10),
+                    consecutiveFailures: prediction.outcome.immediate.evalScoreChange > 0
+                        ? 0
+                        : currentState.agentState.consecutiveFailures + 1,
+                },
+                systemState: {
+                    ...currentState.systemState,
+                    buildStatus: prediction.outcome.immediate.buildStatus
+                        ? { ...currentState.systemState.buildStatus, default: prediction.outcome.immediate.buildStatus }
+                        : currentState.systemState.buildStatus,
+                },
+            };
+            const transition = {
+                id: `sim_${Date.now()}_${i}`,
+                priorState: currentState,
+                action,
+                posteriorState,
+                outcome: prediction.outcome,
+                causalLinks: [],
+                invariantViolations: [],
+            };
+            trajectory.push(transition);
+            currentState = posteriorState;
+        }
+        return trajectory;
+    }
+    // ==========================================================================
+    // Helper Methods for World Model
+    // ==========================================================================
+    /**
+     * Format WorldState for prompt
+     */
+    formatWorldStateForPrompt(state) {
+        return `Agent: ${state.agentId}
+Timestamp: ${new Date(state.timestamp).toISOString()}
+
+System State:
+- Active agents: ${state.systemState.activeAgents.join(", ") || "none"}
+- Hub connections: ${state.systemState.hubConnections}
+- Build status: ${JSON.stringify(state.systemState.buildStatus)}
+- File locks: ${state.systemState.fileLocks.length}
+- Pending evals: ${state.systemState.pendingEvals}
+
+Context State:
+- Recent commits (24h): ${state.contextState.recentCommits}
+- Open PRs: ${state.contextState.openPRs}
+- Failing tests: ${state.contextState.failingTests}
+- Code churn: ${state.contextState.codeChurn} lines
+- Human activity: ${state.contextState.humanActivity}
+
+Agent State:
+- Last eval score: ${state.agentState.lastEvalScore.toFixed(4)}
+- Reward EMA: ${state.agentState.rewardEMA.toFixed(4)}
+- Consecutive failures: ${state.agentState.consecutiveFailures}
+- Recent actions: ${state.agentState.actionHistory.join(", ") || "none"}`;
+    }
+    /**
+     * Format AgentAction for prompt
+     */
+    formatActionForPrompt(action) {
+        let desc = `Agent: ${action.agentId}
+Type: ${action.actionType}
+Confidence: ${action.confidence?.toFixed(2) || "unknown"}`;
+        if (Object.keys(action.actionPayload).length > 0) {
+            desc += `\nPayload: ${JSON.stringify(action.actionPayload, null, 2)}`;
+        }
+        return desc;
+    }
+    /**
+     * Format WorldOutcome for prompt
+     */
+    formatOutcomeForPrompt(outcome) {
+        const parts = [
+            `Eval score change: ${outcome.immediate.evalScoreChange ?? "N/A"}`,
+            `Build status: ${outcome.immediate.buildStatus ?? "N/A"}`,
+            `Commit created: ${outcome.immediate.commitCreated}`,
+        ];
+        if (outcome.immediate.testResults) {
+            parts.push(`Tests: ${outcome.immediate.testResults.passed} passed, ${outcome.immediate.testResults.failed} failed`);
+        }
+        if (outcome.mediumTerm) {
+            parts.push(`Human intervention required: ${outcome.mediumTerm.humanInterventionRequired}`);
+            parts.push(`System stability: ${outcome.mediumTerm.systemStability}`);
+        }
+        return parts.join("\n");
+    }
+    /**
+     * Format historical transitions for context
+     */
+    formatContextTransitions(transitions) {
+        const summaries = transitions.slice(0, 3).map((t, i) => {
+            const delta = t.outcome.immediate.evalScoreChange ?? 0;
+            return `${i + 1}. Action: ${t.action.actionType}, Delta: ${delta >= 0 ? "+" : ""}${delta.toFixed(4)}, Build: ${t.outcome.immediate.buildStatus || "N/A"}`;
+        });
+        return `Similar historical transitions (${transitions.length} total):\n${summaries.join("\n")}`;
+    }
+    /**
+     * Determine counterfactual type
+     */
+    determineCounterfactualType(actual, alternative) {
+        if (alternative.actionType === "skip")
+            return "baseline";
+        if (alternative.agentId !== actual.agentId)
+            return "scheduling";
+        return "action";
+    }
+    /**
+     * Parse JSON from LLM response (handles markdown code blocks)
+     */
+    parseJsonFromResponse(content) {
+        // Try to extract JSON from markdown code block
+        const jsonMatch = content.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+        const jsonStr = jsonMatch ? jsonMatch[1] : content;
+        try {
+            return JSON.parse(jsonStr.trim());
+        }
+        catch {
+            // Try to find any JSON object in the response
+            const objMatch = jsonStr.match(/\{[\s\S]*\}/);
+            if (objMatch) {
+                try {
+                    return JSON.parse(objMatch[0]);
+                }
+                catch {
+                    return {};
+                }
+            }
+            return {};
+        }
+    }
+}
+//# sourceMappingURL=stratus-client.js.map