@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/domains/prime/reviewer.js

@@ -0,0 +1,83 @@
+/**
+ * PrimeReviewer — validates the output of a completed MissionTask.
+ *
+ * Returns a ReviewResult with verdict (APPROVED / REJECTED) and notes.
+ */
+// ---------------------------------------------------------------------------
+// Reviewer
+// ---------------------------------------------------------------------------
+export class PrimeReviewer {
+    /**
+     * Review a completed task's output.
+     */
+    async review(task) {
+        // Task must have output to review
+        if (!task.output || Object.keys(task.output).length === 0) {
+            return {
+                verdict: 'REJECTED',
+                note: 'Task produced no output',
+                suggestions: ['Re-run the task or investigate why it produced no results'],
+            };
+        }
+        // Task must be in DONE status to review
+        if (task.status !== 'DONE') {
+            return {
+                verdict: 'REJECTED',
+                note: `Task is not done (status: ${task.status})`,
+                suggestions: ['Wait for the task to complete before reviewing'],
+            };
+        }
+        // Check for explicit error in output
+        if (task.output.error) {
+            return {
+                verdict: 'REJECTED',
+                note: `Task completed with error: ${String(task.output.error)}`,
+                suggestions: ['Fix the error and re-run the task'],
+            };
+        }
+        // All checks passed
+        return {
+            verdict: 'APPROVED',
+            note: 'Task output looks valid',
+        };
+    }
+    /**
+     * Review with success criteria check.
+     * Runs base review first, then checks each criterion against task output.
+     */
+    async reviewWithCriteria(task, criteria) {
+        const base = await this.review(task);
+        if (base.verdict === 'REJECTED')
+            return base;
+        if (!criteria || criteria.length === 0)
+            return base;
+        const unmet = criteria.filter(c => !this.criterionMet(c, task));
+        if (unmet.length > 0) {
+            return {
+                verdict: 'REJECTED',
+                note: `Unmet criteria: ${unmet.join('; ')}`,
+                suggestions: unmet.map(c => `Ensure: ${c}`),
+            };
+        }
+        return {
+            verdict: 'APPROVED',
+            note: `All ${criteria.length} criteria met`,
+        };
+    }
+    /**
+     * Deterministic criterion check — matches keywords from criterion
+     * against serialized task output.
+     */
+    criterionMet(criterion, task) {
+        if (!task.output)
+            return false;
+        const outputStr = JSON.stringify(task.output).toLowerCase();
+        const keywords = criterion
+            .toLowerCase()
+            .split(/\s+/)
+            .filter(w => w.length > 3);
+        if (keywords.length === 0)
+            return true; // trivial criterion
+        return keywords.some(kw => outputStr.includes(kw));
+    }
+}

package/build/domains/prime/stage_machine.d.ts

@@ -0,0 +1,62 @@
+/**
+ * ProjectStage State Machine — Enforces work stage transitions.
+ *
+ * Maps RunPhase to ProjectStage, validates required evidence before
+ * allowing transitions, and prevents stage skipping.
+ *
+ * Stages: PLAN → BUILD → CONTROL → OPERATE → MAINTAIN
+ *
+ * @since Sprint 7 (Intent Enforcement P2)
+ */
+import type { RunPhase } from '../../mcp/tools/vibe_pm/phase.js';
+export type ProjectStage = "PLAN" | "BUILD" | "CONTROL" | "OPERATE" | "MAINTAIN";
+export interface StageEvidence {
+    type: "artifact" | "verdict" | "criteria";
+    key: string;
+    present: boolean;
+}
+export interface StageTransition {
+    from: ProjectStage;
+    to: ProjectStage;
+    requiredEvidence: string[];
+}
+export interface StageMachineState {
+    current: ProjectStage;
+    history: Array<{
+        stage: ProjectStage;
+        entered_at: string;
+        is_regression?: boolean;
+    }>;
+    evidence: StageEvidence[];
+}
+export interface TransitionResult {
+    allowed: boolean;
+    missing: string[];
+}
+export declare class ProjectStageMachine {
+    private state;
+    constructor(initial?: ProjectStage);
+    get current(): ProjectStage;
+    get history(): StageMachineState["history"];
+    /**
+     * Check if a transition is allowed (without performing it).
+     */
+    canTransition(to: ProjectStage): TransitionResult;
+    /**
+     * Attempt to transition to a new stage.
+     * Returns the new state if successful, or throws with missing evidence.
+     */
+    transition(to: ProjectStage): StageMachineState;
+    /**
+     * Add evidence (used to satisfy transition requirements).
+     */
+    addEvidence(evidence: StageEvidence): void;
+    /**
+     * Map a RunPhase to a ProjectStage.
+     */
+    static fromRunPhase(phase: RunPhase): ProjectStage;
+    /**
+     * Get the snapshot of current state.
+     */
+    getState(): Readonly<StageMachineState>;
+}

package/build/domains/prime/stage_machine.js

@@ -0,0 +1,143 @@
+/**
+ * ProjectStage State Machine — Enforces work stage transitions.
+ *
+ * Maps RunPhase to ProjectStage, validates required evidence before
+ * allowing transitions, and prevents stage skipping.
+ *
+ * Stages: PLAN → BUILD → CONTROL → OPERATE → MAINTAIN
+ *
+ * @since Sprint 7 (Intent Enforcement P2)
+ */
+// ============================================================================
+// Transition Table
+// ============================================================================
+const TRANSITIONS = [
+    {
+        from: "PLAN",
+        to: "BUILD",
+        requiredEvidence: ["plan.v1.json", "spec.v1.md"],
+    },
+    {
+        from: "BUILD",
+        to: "CONTROL",
+        requiredEvidence: ["verdict.v1.json"],
+    },
+    {
+        from: "CONTROL",
+        to: "OPERATE",
+        requiredEvidence: ["final_verdict_GO", "success_criteria_met"],
+    },
+    {
+        from: "OPERATE",
+        to: "MAINTAIN",
+        requiredEvidence: ["decision.v1.json"],
+    },
+];
+const STAGE_ORDER = ["PLAN", "BUILD", "CONTROL", "OPERATE", "MAINTAIN"];
+// ============================================================================
+// State Machine
+// ============================================================================
+export class ProjectStageMachine {
+    state;
+    constructor(initial) {
+        this.state = {
+            current: initial ?? "PLAN",
+            history: [{ stage: initial ?? "PLAN", entered_at: new Date().toISOString() }],
+            evidence: [],
+        };
+    }
+    get current() {
+        return this.state.current;
+    }
+    get history() {
+        return this.state.history;
+    }
+    /**
+     * Check if a transition is allowed (without performing it).
+     */
+    canTransition(to) {
+        // Can't transition to current stage
+        if (to === this.state.current) {
+            return { allowed: false, missing: ["already_at_stage"] };
+        }
+        const currentIdx = STAGE_ORDER.indexOf(this.state.current);
+        const targetIdx = STAGE_ORDER.indexOf(to);
+        // Backward transitions are always allowed (regression)
+        if (targetIdx < currentIdx) {
+            return { allowed: true, missing: [] };
+        }
+        // Can't skip forward stages
+        if (targetIdx !== currentIdx + 1) {
+            return { allowed: false, missing: ["stage_skip_not_allowed"] };
+        }
+        // Find transition rule
+        const rule = TRANSITIONS.find(t => t.from === this.state.current && t.to === to);
+        if (!rule) {
+            return { allowed: false, missing: ["no_transition_rule"] };
+        }
+        // Check evidence
+        const presentKeys = new Set(this.state.evidence
+            .filter(e => e.present)
+            .map(e => e.key));
+        const missing = rule.requiredEvidence.filter(key => !presentKeys.has(key));
+        return { allowed: missing.length === 0, missing };
+    }
+    /**
+     * Attempt to transition to a new stage.
+     * Returns the new state if successful, or throws with missing evidence.
+     */
+    transition(to) {
+        const result = this.canTransition(to);
+        if (!result.allowed) {
+            throw new Error(`Cannot transition ${this.state.current} → ${to}: missing [${result.missing.join(", ")}]`);
+        }
+        const currentIdx = STAGE_ORDER.indexOf(this.state.current);
+        const targetIdx = STAGE_ORDER.indexOf(to);
+        const isRegression = targetIdx < currentIdx;
+        this.state.current = to;
+        this.state.history.push({
+            stage: to,
+            entered_at: new Date().toISOString(),
+            is_regression: isRegression || undefined,
+        });
+        return { ...this.state };
+    }
+    /**
+     * Add evidence (used to satisfy transition requirements).
+     */
+    addEvidence(evidence) {
+        // Replace if same key exists, otherwise append
+        const idx = this.state.evidence.findIndex(e => e.key === evidence.key);
+        if (idx >= 0) {
+            this.state.evidence[idx] = evidence;
+        }
+        else {
+            this.state.evidence.push(evidence);
+        }
+    }
+    /**
+     * Map a RunPhase to a ProjectStage.
+     */
+    static fromRunPhase(phase) {
+        switch (phase) {
+            case "INTAKE":
+            case "SPEC_LOCKED":
+                return "PLAN";
+            case "PLAN_LOCKED":
+            case "EXEC_ALLOWED":
+                return "BUILD";
+            case "REVIEWED":
+                return "CONTROL";
+            case "FINALIZED":
+                return "OPERATE";
+            default:
+                return "PLAN";
+        }
+    }
+    /**
+     * Get the snapshot of current state.
+     */
+    getState() {
+        return { ...this.state };
+    }
+}

package/build/domains/prime/time_stone.d.ts

@@ -0,0 +1,37 @@
+/**
+ * TimeStone — Dormammu Strategy simulation engine.
+ *
+ * 1. Generate N strategies via HiveMind (TREE_OF_THOUGHTS)
+ * 2. Simulate each in an isolated Holodeck instance
+ * 3. Score results (error, speed, safety, critical file protection)
+ * 4. Return the best-scoring strategy for execution
+ */
+import { HiveMind } from './hive_mind.js';
+import type { TimeStoneConfig, TimeStoneResult } from './time_stone_types.js';
+export declare class TimeStone {
+    private hiveMind;
+    private maxFutures;
+    private minCandidates;
+    private exitQuantile;
+    private maxTotalMs?;
+    private stallWindow;
+    private stallMinDelta;
+    private simulationTimeoutMs;
+    private protectedPaths;
+    private scoringWeights;
+    constructor(hiveMind: HiveMind, config?: TimeStoneConfig);
+    /**
+     * Dormammu Strategy: generate N strategies, simulate each, pick best.
+     */
+    simulateFutures(goal: string, mockFs?: Record<string, string>): Promise<TimeStoneResult>;
+    private runSimulation;
+    private extractScripts;
+    private rescoreResults;
+    private shouldExitOnConfidenceStall;
+    private shouldExitForTimeBudget;
+    private isPerfectResult;
+    private touchesProtectedPaths;
+    private isStalled;
+    private calculateMedianDuration;
+    private clamp01;
+}

package/build/domains/prime/time_stone.js

@@ -0,0 +1,212 @@
+/**
+ * TimeStone — Dormammu Strategy simulation engine.
+ *
+ * 1. Generate N strategies via HiveMind (TREE_OF_THOUGHTS)
+ * 2. Simulate each in an isolated Holodeck instance
+ * 3. Score results (error, speed, safety, critical file protection)
+ * 4. Return the best-scoring strategy for execution
+ */
+import { Holodeck } from './holodeck.js';
+import { scoreSimulation } from './time_stone_scorer.js';
+const DEFAULT_MAX_FUTURES = 3;
+const DEFAULT_EXIT_QUANTILE = 1;
+const DEFAULT_STALL_WINDOW = 2;
+const DEFAULT_STALL_MIN_DELTA = 1;
+const DEFAULT_SIMULATION_TIMEOUT_MS = 15_000;
+export class TimeStone {
+    hiveMind;
+    maxFutures;
+    minCandidates;
+    exitQuantile;
+    maxTotalMs;
+    stallWindow;
+    stallMinDelta;
+    simulationTimeoutMs;
+    protectedPaths;
+    scoringWeights;
+    constructor(hiveMind, config = {}) {
+        this.hiveMind = hiveMind;
+        this.maxFutures = config.maxFutures ?? DEFAULT_MAX_FUTURES;
+        this.minCandidates = Math.max(1, Math.min(config.minCandidates ?? this.maxFutures, this.maxFutures));
+        this.exitQuantile = this.clamp01(config.exitQuantile ?? DEFAULT_EXIT_QUANTILE);
+        this.maxTotalMs = config.maxTotalMs;
+        this.stallWindow = Math.max(1, config.stallWindow ?? DEFAULT_STALL_WINDOW);
+        this.stallMinDelta = Math.max(0, config.stallMinDelta ?? DEFAULT_STALL_MIN_DELTA);
+        this.simulationTimeoutMs = config.simulationTimeoutMs ?? DEFAULT_SIMULATION_TIMEOUT_MS;
+        this.protectedPaths = config.protectedPaths ?? [];
+        this.scoringWeights = config.scoring;
+    }
+    /**
+     * Dormammu Strategy: generate N strategies, simulate each, pick best.
+     */
+    async simulateFutures(goal, mockFs) {
+        const start = Date.now();
+        // Step 1: Generate candidate strategies via HiveMind
+        const thinkResult = await this.hiveMind.think(goal, 'TREE_OF_THOUGHTS', {
+            candidateCount: this.maxFutures,
+        });
+        const scripts = this.extractScripts(thinkResult);
+        // Limit to maxFutures
+        const candidates = scripts.slice(0, this.maxFutures);
+        if (candidates.length === 0) {
+            return {
+                bestScript: '',
+                bestScore: 0,
+                allResults: [],
+                totalMs: Date.now() - start,
+                futuresExplored: 0,
+                candidatesSeen: 0,
+                exitedEarly: false,
+                exitReason: 'no_candidates',
+            };
+        }
+        const results = [];
+        const bestScoreHistory = [];
+        let attemptedCandidates = 0;
+        let exitReason;
+        // Step 2: Simulate each candidate in sequence to support adaptive exit gating
+        for (const candidate of candidates) {
+            if (this.shouldExitForTimeBudget(start, attemptedCandidates)) {
+                exitReason = 'time_budget';
+                break;
+            }
+            attemptedCandidates += 1;
+            try {
+                const simResult = await this.runSimulation(candidate.script, candidate.label, mockFs);
+                results.push(simResult);
+            }
+            catch {
+                continue;
+            }
+            this.rescoreResults(results);
+            results.sort((a, b) => b.score - a.score);
+            bestScoreHistory.push(results[0].score);
+            if (results.length < this.minCandidates) {
+                continue;
+            }
+            if (this.isPerfectResult(results[0])) {
+                exitReason = 'perfect_candidate';
+                break;
+            }
+            if (this.shouldExitOnConfidenceStall(results, bestScoreHistory)) {
+                exitReason = 'confidence_stall';
+                break;
+            }
+            if (this.shouldExitForTimeBudget(start, attemptedCandidates)) {
+                exitReason = 'time_budget';
+                break;
+            }
+        }
+        if (results.length === 0) {
+            return {
+                bestScript: '',
+                bestScore: 0,
+                allResults: [],
+                totalMs: Date.now() - start,
+                futuresExplored: attemptedCandidates,
+                candidatesSeen: attemptedCandidates,
+                exitedEarly: attemptedCandidates < candidates.length,
+                exitReason: 'no_successful_simulation',
+            };
+        }
+        // Step 3: Final sort by score descending
+        results.sort((a, b) => b.score - a.score);
+        const exitedEarly = attemptedCandidates < candidates.length;
+        return {
+            bestScript: results[0].script,
+            bestScore: results[0].score,
+            allResults: results,
+            totalMs: Date.now() - start,
+            futuresExplored: attemptedCandidates,
+            candidatesSeen: attemptedCandidates,
+            exitedEarly,
+            exitReason: exitedEarly ? exitReason : undefined,
+        };
+    }
+    // ---------------------------------------------------------------------------
+    // Private
+    // ---------------------------------------------------------------------------
+    async runSimulation(script, label, mockFs) {
+        const holodeck = new Holodeck({
+            mountFiles: mockFs,
+            timeoutMs: this.simulationTimeoutMs,
+        });
+        const execution = await holodeck.executeScript(script);
+        return {
+            script,
+            execution,
+            score: 0, // Will be set after scoring
+            scoreBreakdown: { base: 0, errorPenalty: 0, speedBonus: 0, safetyBonus: 0, criticalFilePenalty: 0 },
+            strategyLabel: label,
+        };
+    }
+    extractScripts(thinkResult) {
+        // Each thought's output is treated as a script/command candidate
+        return thinkResult.thoughts
+            .filter(t => !t.error && t.output.trim().length > 0)
+            .map((t, i) => ({
+            script: t.output.trim(),
+            label: `Strategy ${i + 1}: ${t.subtaskId}`,
+        }));
+    }
+    rescoreResults(results) {
+        const medianDuration = this.calculateMedianDuration(results);
+        for (const r of results) {
+            const { score, breakdown } = scoreSimulation(r.execution, this.protectedPaths, medianDuration, this.scoringWeights);
+            r.score = score;
+            r.scoreBreakdown = breakdown;
+        }
+    }
+    shouldExitOnConfidenceStall(results, bestScoreHistory) {
+        if (!this.isStalled(bestScoreHistory)) {
+            return false;
+        }
+        const bestScore = results[0]?.score ?? 0;
+        const scoreBand = Math.max(1, this.stallMinDelta);
+        const nearBestCount = results.filter(r => r.score >= bestScore - scoreBand).length;
+        const cdf = nearBestCount / results.length;
+        return cdf >= this.exitQuantile;
+    }
+    shouldExitForTimeBudget(startMs, attemptedCandidates) {
+        if (this.maxTotalMs == null)
+            return false;
+        if (attemptedCandidates < this.minCandidates)
+            return false;
+        return Date.now() - startMs >= this.maxTotalMs;
+    }
+    isPerfectResult(result) {
+        if (!result.execution.success)
+            return false;
+        const hasErrorStep = result.execution.steps.some(step => step.exitCode !== 0 || step.stderr.trim().length > 0);
+        if (hasErrorStep)
+            return false;
+        return !this.touchesProtectedPaths(result.execution);
+    }
+    touchesProtectedPaths(execution) {
+        if (this.protectedPaths.length === 0)
+            return false;
+        const allOutput = execution.steps.map(step => step.stdout + step.stderr).join('\n');
+        return this.protectedPaths.some(path => allOutput.includes(path));
+    }
+    isStalled(bestScoreHistory) {
+        if (bestScoreHistory.length <= this.stallWindow) {
+            return false;
+        }
+        const current = bestScoreHistory[bestScoreHistory.length - 1];
+        const referenceIndex = bestScoreHistory.length - 1 - this.stallWindow;
+        const previous = bestScoreHistory[referenceIndex];
+        return current - previous < this.stallMinDelta;
+    }
+    calculateMedianDuration(results) {
+        const durations = results
+            .map(r => r.execution.totalDurationMs)
+            .sort((a, b) => a - b);
+        const mid = Math.floor(durations.length / 2);
+        return durations.length % 2 === 0
+            ? (durations[mid - 1] + durations[mid]) / 2
+            : durations[mid];
+    }
+    clamp01(value) {
+        return Math.max(0, Math.min(1, value));
+    }
+}

package/build/domains/prime/time_stone_scorer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Time Stone Scorer — scoring logic for simulation results.
+ *
+ * Score = 100 (base)
+ *       + errorPenalty * (non-zero exits)
+ *       + speedBonus   * (faster than average ? 1 : 0)
+ *       + safetyBonus  * (no protected paths touched ? 1 : 0)
+ *       + criticalFilePenalty * (number of protected paths touched)
+ * Minimum score: 0
+ */
+import type { HolodeckScriptResult } from './holodeck_types.js';
+import type { ScoringWeights, SimulationResult } from './time_stone_types.js';
+export declare const DEFAULT_WEIGHTS: ScoringWeights;
+export declare function scoreSimulation(execution: HolodeckScriptResult, protectedPaths: string[], medianDurationMs: number, weights?: Partial<ScoringWeights>): {
+    score: number;
+    breakdown: SimulationResult['scoreBreakdown'];
+};

package/build/domains/prime/time_stone_scorer.js

@@ -0,0 +1,44 @@
+/**
+ * Time Stone Scorer — scoring logic for simulation results.
+ *
+ * Score = 100 (base)
+ *       + errorPenalty * (non-zero exits)
+ *       + speedBonus   * (faster than average ? 1 : 0)
+ *       + safetyBonus  * (no protected paths touched ? 1 : 0)
+ *       + criticalFilePenalty * (number of protected paths touched)
+ * Minimum score: 0
+ */
+export const DEFAULT_WEIGHTS = {
+    errorPenalty: -20,
+    speedBonus: 10,
+    safetyBonus: 15,
+    criticalFilePenalty: -30,
+};
+export function scoreSimulation(execution, protectedPaths, medianDurationMs, weights) {
+    const w = { ...DEFAULT_WEIGHTS, ...weights };
+    // Count errors (non-zero exits)
+    const errorCount = execution.steps.filter(s => s.exitCode !== 0).length;
+    // Speed: bonus if faster than median
+    const isFast = execution.totalDurationMs < medianDurationMs;
+    // Safety: check if any step output references protected paths
+    const allOutput = execution.steps.map(s => s.stdout + s.stderr).join('\n');
+    const touchedPaths = protectedPaths.filter(p => allOutput.includes(p));
+    const isSafe = touchedPaths.length === 0;
+    const base = 100;
+    const errorPenaltyTotal = w.errorPenalty * errorCount || 0;
+    const speedBonusTotal = isFast ? w.speedBonus : 0;
+    const safetyBonusTotal = isSafe ? w.safetyBonus : 0;
+    const criticalFilePenaltyTotal = w.criticalFilePenalty * touchedPaths.length || 0;
+    const raw = base + errorPenaltyTotal + speedBonusTotal + safetyBonusTotal + criticalFilePenaltyTotal;
+    const score = Math.max(0, raw);
+    return {
+        score,
+        breakdown: {
+            base,
+            errorPenalty: errorPenaltyTotal,
+            speedBonus: speedBonusTotal,
+            safetyBonus: safetyBonusTotal,
+            criticalFilePenalty: criticalFilePenaltyTotal,
+        },
+    };
+}

package/build/domains/prime/time_stone_types.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Time Stone Types — simulation engine configuration and results.
+ */
+import type { HolodeckScriptResult } from './holodeck_types.js';
+export interface TimeStoneConfig {
+    /** Maximum simulation futures to explore (default: 3) */
+    maxFutures?: number;
+    /** Minimum number of candidates to evaluate before early exit can occur */
+    minCandidates?: number;
+    /** Exit threshold (0..1) for confidence-based early exit */
+    exitQuantile?: number;
+    /** Hard wall-clock budget in ms for all simulations */
+    maxTotalMs?: number;
+    /** Number of most recent iterations to inspect for stalled improvements */
+    stallWindow?: number;
+    /** Minimum score gain required to avoid stall detection */
+    stallMinDelta?: number;
+    /** Per-simulation timeout in ms (default: 15_000) */
+    simulationTimeoutMs?: number;
+    /** File paths that must not be modified (penalty if touched) */
+    protectedPaths?: string[];
+    /** Custom scoring weights */
+    scoring?: Partial<ScoringWeights>;
+}
+export interface ScoringWeights {
+    /** Penalty per non-zero exit code (default: -20) */
+    errorPenalty: number;
+    /** Bonus for faster-than-average execution (default: +10) */
+    speedBonus: number;
+    /** Bonus for not touching protected paths (default: +15) */
+    safetyBonus: number;
+    /** Penalty per protected file touched (default: -30) */
+    criticalFilePenalty: number;
+}
+export interface SimulationResult {
+    /** The bash script that was simulated */
+    script: string;
+    /** Holodeck execution result */
+    execution: HolodeckScriptResult;
+    /** Computed score (base 100 + bonuses - penalties, min 0) */
+    score: number;
+    /** Breakdown of scoring components */
+    scoreBreakdown: {
+        base: number;
+        errorPenalty: number;
+        speedBonus: number;
+        safetyBonus: number;
+        criticalFilePenalty: number;
+    };
+    /** Strategy label from HiveMind */
+    strategyLabel: string;
+}
+export interface TimeStoneResult {
+    /** The best scoring script, ready for execution */
+    bestScript: string;
+    /** Score of the best script */
+    bestScore: number;
+    /** All simulation results, sorted by score descending */
+    allResults: SimulationResult[];
+    /** Total wall-clock time for all simulations */
+    totalMs: number;
+    /** How many futures were explored */
+    futuresExplored: number;
+    /** How many candidates were actually attempted */
+    candidatesSeen: number;
+    /** Whether exploration stopped before exhausting candidate list */
+    exitedEarly: boolean;
+    /** Exit reason when early-stop is triggered */
+    exitReason?: TimeStoneExitReason;
+}
+export type TimeStoneExitReason = 'perfect_candidate' | 'confidence_stall' | 'time_budget' | 'no_candidates' | 'no_successful_simulation';

package/build/domains/prime/time_stone_types.js

@@ -0,0 +1,4 @@
+/**
+ * Time Stone Types — simulation engine configuration and results.
+ */
+export {};