@martinloop/mcp 0.3.5 → 0.3.7

package/dist/vendor/adapters/core/src/routing.js

@@ -0,0 +1,336 @@
+/**
+ * Route classification and compression for governed agent runs.
+ *
+ * Decides whether a task needs manager/planner orchestration or can go
+ * directly to a worker, based on task complexity signals. Prevents
+ * wasted coordination cost (Pre Work Burn) on simple tasks.
+ */
+import { DEFAULT_ROUTING_POLICY } from "../../../contracts/index.js";
+const SECURITY_KEYWORDS = [
+    "auth", "authentication", "authorization", "credential", "secret",
+    "token", "password", "oauth", "jwt", "session", "csrf", "xss",
+    "injection", "encryption", "certificate", "tls", "ssl", "permission"
+];
+const ARCHITECTURE_KEYWORDS = [
+    "refactor", "architecture", "redesign", "restructure", "migration",
+    "database schema", "api design", "service boundary", "microservice",
+    "event sourcing", "cqrs", "distributed"
+];
+const MIGRATION_KEYWORDS = [
+    "migration", "migrate", "upgrade", "downgrade", "schema change",
+    "data migration", "database migration", "breaking change"
+];
+const MULTI_FILE_KEYWORDS = [
+    "across", "all files", "every file", "codebase-wide", "global",
+    "rename everywhere", "update all", "system-wide"
+];
+function extractComplexitySignals(input) {
+    const lower = input.objective.toLowerCase();
+    return {
+        objectiveLength: input.objective.length,
+        fileCount: input.scopedFileCount ?? estimateFileCount(input),
+        hasSecurityKeywords: SECURITY_KEYWORDS.some((kw) => lower.includes(kw)),
+        hasArchitectureKeywords: ARCHITECTURE_KEYWORDS.some((kw) => lower.includes(kw)),
+        hasMigrationKeywords: MIGRATION_KEYWORDS.some((kw) => lower.includes(kw)),
+        hasMultiFileKeywords: MULTI_FILE_KEYWORDS.some((kw) => lower.includes(kw)),
+        verifierCount: input.verificationPlan.length,
+        budgetUsd: input.budgetUsd,
+        scopeRestricted: (input.allowedPaths?.length ?? 0) > 0 || (input.deniedPaths?.length ?? 0) > 0
+    };
+}
+function estimateFileCount(input) {
+    const pathCount = (input.allowedPaths?.length ?? 0) + (input.deniedPaths?.length ?? 0);
+    if (pathCount > 0)
+        return pathCount;
+    // Heuristic: short objectives with specific file refs → 1-2 files
+    const fileRefs = input.objective.match(/[\w/.-]+\.\w{1,5}/g);
+    return fileRefs?.length ?? 1;
+}
+// ---------------------------------------------------------------------------
+// Confidence scoring
+// ---------------------------------------------------------------------------
+function calculateDirectConfidence(signals, input) {
+    let confidence = 0.7; // Base: most tasks can go direct
+    // Boost for simple tasks
+    if (signals.objectiveLength < 200)
+        confidence += 0.1;
+    if (signals.fileCount <= 2)
+        confidence += 0.1;
+    if (signals.scopeRestricted)
+        confidence += 0.05;
+    if (signals.verifierCount === 1)
+        confidence += 0.05;
+    // Penalize for complex tasks
+    if (signals.hasSecurityKeywords)
+        confidence -= 0.25;
+    if (signals.hasArchitectureKeywords)
+        confidence -= 0.2;
+    if (signals.hasMigrationKeywords)
+        confidence -= 0.3;
+    if (signals.hasMultiFileKeywords)
+        confidence -= 0.15;
+    if (signals.objectiveLength > 500)
+        confidence -= 0.1;
+    if (signals.fileCount > 5)
+        confidence -= 0.15;
+    if (signals.budgetUsd > 10)
+        confidence -= 0.1;
+    // Historical evidence
+    if (input.historicalDirectSuccessRate !== undefined) {
+        confidence = confidence * 0.6 + input.historicalDirectSuccessRate * 0.4;
+    }
+    return Math.max(0, Math.min(1, confidence));
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Cost-aware model tier routing
+//
+// Engine-agnostic tier system — each engine maps tiers to real model IDs.
+// Never pay for reasoning/orchestration on simple tasks.
+//
+// Tier → concrete model per engine:
+//   haiku  → claude-haiku-4-5, gpt-4o-mini, gemini-2.5-flash, deepseek-chat, qwen3-8b,  llama-3.1-8b
+//   sonnet → claude-sonnet-4-6, gpt-4o,     gemini-2.5-pro,  deepseek-r1,   qwen3-32b, llama-3.3-70b
+//   opus   → claude-opus-4-6,  o3,          gemini-2.5-ultra, deepseek-r1-671b, qwen3-235b, llama-3.1-405b
+//
+// Pricing reference (USD per 1M tokens, approx 2026):
+//   haiku:  $0.80 input / $4.00 output  (~1x baseline)
+//   sonnet: $3.00 input / $15.00 output (~4x haiku)
+//   opus:   $15.00 input / $75.00 output (~19x haiku)
+// ---------------------------------------------------------------------------
+const SONNET_AVG_COST_PER_USD_BUDGET = 0.35; // sonnet uses ~35% of budget on average
+const HAIKU_AVG_COST_PER_USD_BUDGET = 0.10; // haiku uses ~10% — ~3.5x cheaper
+function selectModelTier(mode) {
+    // Route already encodes complexity. Direct = passed the simplicity check → haiku.
+    if (mode === "direct")
+        return "haiku";
+    if (mode === "manager")
+        return "sonnet";
+    return "opus";
+}
+/**
+ * Resolve a tier to a concrete model ID for a specific engine.
+ * Allows downstream adapters to switch models automatically.
+ */
+export function resolveModelForTier(tier, engine) {
+    const matrix = {
+        claude: {
+            haiku: "claude-haiku-4-5-20251001",
+            sonnet: "claude-sonnet-4-6",
+            opus: "claude-opus-4-6"
+        },
+        codex: {
+            haiku: "gpt-4o-mini",
+            sonnet: "gpt-4.1",
+            opus: "o3"
+        },
+        gemini: {
+            haiku: "gemini-2.5-flash",
+            sonnet: "gemini-2.5-pro",
+            opus: "gemini-2.5-ultra"
+        },
+        openai: {
+            haiku: "gpt-4o-mini",
+            sonnet: "gpt-4o",
+            opus: "o3"
+        },
+        deepseek: {
+            haiku: "deepseek-chat",
+            sonnet: "deepseek-r1",
+            opus: "deepseek-r1"
+        },
+        qwen: {
+            haiku: "qwen/qwen3-8b",
+            sonnet: "qwen/qwen3-32b",
+            opus: "qwen/qwen3-235b-a22b"
+        },
+        llama: {
+            haiku: "meta-llama/llama-3.1-8b-instruct",
+            sonnet: "meta-llama/llama-3.3-70b-instruct",
+            opus: "meta-llama/llama-3.1-405b-instruct"
+        }
+    };
+    const engineKey = engine.toLowerCase().split("-")[0] ?? engine;
+    const claudeMatrix = matrix.claude;
+    return matrix[engineKey]?.[tier] ?? claudeMatrix?.[tier] ?? "claude-sonnet-4-6";
+}
+function estimateSavingVsSonnet(tier, budgetUsd) {
+    if (tier === "sonnet")
+        return 0;
+    if (tier === "haiku")
+        return Math.round((SONNET_AVG_COST_PER_USD_BUDGET - HAIKU_AVG_COST_PER_USD_BUDGET) * budgetUsd * 100) / 100;
+    // opus costs more than sonnet — negative saving
+    return Math.round(-1 * SONNET_AVG_COST_PER_USD_BUDGET * budgetUsd * 0.5 * 100) / 100;
+}
+/**
+ * Select the best available engine for a given tier requirement.
+ *
+ * When multiple engines are available, picks the cheapest that meets
+ * the capability requirement. Falls back gracefully:
+ * - If required tier unavailable, upgrades to next tier of same engine
+ * - If only one engine family available, uses its best equivalent
+ *
+ * @param requiredTier - Minimum capability tier needed
+ * @param availableEngines - What's installed and authenticated
+ * @returns Best engine ID and concrete model to use
+ */
+export function selectBestEngine(requiredTier, availableEngines) {
+    const available = availableEngines.filter((e) => e.available);
+    if (available.length === 0) {
+        // Nothing detected — default to claude (user must install)
+        return {
+            engineId: "claude",
+            model: resolveModelForTier(requiredTier, "claude"),
+            reasoning: "No engines detected. Defaulting to claude. Run martin doctor for setup instructions."
+        };
+    }
+    const tierRank = {
+        haiku: 0, sonnet: 1, opus: 2
+    };
+    const requiredRank = tierRank[requiredTier];
+    // Find the cheapest engine that meets or exceeds the required tier
+    const eligible = available
+        .filter((e) => tierRank[e.capabilityTier] >= requiredRank)
+        .sort((a, b) => {
+        // Sort by cost (cheap first), then by exact tier match
+        const costOrder = { cheap: 0, mid: 1, expensive: 2 };
+        if (costOrder[a.costTier] !== costOrder[b.costTier]) {
+            return costOrder[a.costTier] - costOrder[b.costTier];
+        }
+        // Prefer exact tier match over overqualified
+        const aExact = a.capabilityTier === requiredTier ? 0 : 1;
+        const bExact = b.capabilityTier === requiredTier ? 0 : 1;
+        return aExact - bExact;
+    });
+    if (eligible.length > 0) {
+        const best = eligible[0];
+        const model = resolveModelForTier(requiredTier, best.id);
+        return {
+            engineId: best.id,
+            model,
+            reasoning: `Selected ${best.id} (${model}) as cheapest available engine for ${requiredTier}-tier task.`
+        };
+    }
+    // All available engines are below required tier — upgrade to best available
+    const best = available.sort((a, b) => tierRank[b.capabilityTier] - tierRank[a.capabilityTier])[0];
+    const model = resolveModelForTier(best.capabilityTier, best.id);
+    return {
+        engineId: best.id,
+        model,
+        reasoning: `No ${requiredTier}-tier engine available. Upgrading to ${best.id} (${model}) — best available.`
+    };
+}
+export function classifyRoute(input) {
+    const policy = { ...DEFAULT_ROUTING_POLICY, ...input.policy };
+    const signals = extractComplexitySignals(input);
+    const directConfidence = calculateDirectConfidence(signals, input);
+    const reason = [];
+    const blockedSteps = [];
+    // Policy override: forced mode
+    if (policy.mode === "direct") {
+        const tier = selectModelTier("direct");
+        return {
+            selectedMode: "direct",
+            confidence: 1,
+            expectedCostUsd: estimateDirectCost(input.budgetUsd),
+            expectedPreworkBurnPct: 5,
+            reason: ["Policy forces direct execution mode."],
+            blockedSteps: ["manager", "planner", "router", "consensus"],
+            compressed: true,
+            compressionSummary: "Policy: direct mode — skipping all orchestration.",
+            recommendedModelTier: tier,
+            estimatedSavingVsSonnetUsd: estimateSavingVsSonnet(tier, input.budgetUsd)
+        };
+    }
+    if (policy.mode === "consensus") {
+        const tier = selectModelTier("consensus");
+        return {
+            selectedMode: "consensus",
+            confidence: 0.5,
+            expectedCostUsd: input.budgetUsd * 0.8,
+            expectedPreworkBurnPct: 35,
+            reason: ["Policy forces consensus mode."],
+            blockedSteps: [],
+            compressed: false,
+            recommendedModelTier: tier,
+            estimatedSavingVsSonnetUsd: estimateSavingVsSonnet(tier, input.budgetUsd)
+        };
+    }
+    // Adaptive routing
+    if (directConfidence >= policy.skipOrchestrationIfConfidenceAbove) {
+        reason.push(`Direct confidence ${(directConfidence * 100).toFixed(0)}% exceeds threshold ${(policy.skipOrchestrationIfConfidenceAbove * 100).toFixed(0)}%.`);
+        if (signals.objectiveLength < 200)
+            reason.push("Short, focused objective.");
+        if (signals.fileCount <= 2)
+            reason.push(`Scoped to ${String(signals.fileCount)} file(s).`);
+        if (signals.scopeRestricted)
+            reason.push("Path scope is restricted.");
+        blockedSteps.push("manager", "consensus");
+        const tier = selectModelTier("direct");
+        return {
+            selectedMode: "direct",
+            confidence: directConfidence,
+            expectedCostUsd: estimateDirectCost(input.budgetUsd),
+            expectedPreworkBurnPct: 8,
+            reason,
+            blockedSteps,
+            compressed: true,
+            compressionSummary: `Compressed from manager→planner→worker to direct worker. Estimated savings: ${String(Math.round(input.budgetUsd * 0.3 * 100) / 100)} USD.`,
+            recommendedModelTier: tier,
+            estimatedSavingVsSonnetUsd: estimateSavingVsSonnet(tier, input.budgetUsd)
+        };
+    }
+    // Complex task — needs orchestration
+    if (signals.hasSecurityKeywords)
+        reason.push("Security-sensitive task detected.");
+    if (signals.hasMigrationKeywords)
+        reason.push("Migration task detected.");
+    if (signals.hasArchitectureKeywords)
+        reason.push("Architectural scope detected.");
+    if (signals.fileCount > 5)
+        reason.push(`Touches ${String(signals.fileCount)}+ files.`);
+    const needsConsensus = signals.hasSecurityKeywords && signals.hasMigrationKeywords;
+    const mode = needsConsensus ? "consensus" : "manager";
+    const tier = selectModelTier(mode);
+    return {
+        selectedMode: mode,
+        confidence: directConfidence,
+        expectedCostUsd: input.budgetUsd * (needsConsensus ? 0.8 : 0.6),
+        expectedPreworkBurnPct: needsConsensus ? 40 : 25,
+        reason,
+        blockedSteps: needsConsensus ? [] : ["consensus"],
+        compressed: false,
+        recommendedModelTier: tier,
+        estimatedSavingVsSonnetUsd: estimateSavingVsSonnet(tier, input.budgetUsd)
+    };
+}
+function estimateDirectCost(budgetUsd) {
+    // Direct execution typically uses 30-50% of budget
+    return Math.round(budgetUsd * 0.35 * 100) / 100;
+}
+/**
+ * Checks whether a run's Pre Work Burn exceeds the routing policy limits.
+ * Returns a block reason if exceeded, undefined if within bounds.
+ */
+export function evaluatePreworkBurnPolicy(preworkCostUsd, totalCostUsd, policy = {}) {
+    const resolved = { ...DEFAULT_ROUTING_POLICY, ...policy };
+    if (!resolved.enabled) {
+        return { exceeded: false };
+    }
+    if (preworkCostUsd > resolved.maxPreworkCostUsd) {
+        return {
+            exceeded: true,
+            reason: `Pre-work cost $${preworkCostUsd.toFixed(2)} exceeds routing policy cap of $${resolved.maxPreworkCostUsd.toFixed(2)}.`
+        };
+    }
+    const burnPct = totalCostUsd > 0 ? (preworkCostUsd / totalCostUsd) * 100 : 0;
+    if (burnPct > resolved.maxPreworkBudgetPct) {
+        return {
+            exceeded: true,
+            reason: `Pre Work Burn at ${burnPct.toFixed(0)}% exceeds routing policy cap of ${String(resolved.maxPreworkBudgetPct)}%.`
+        };
+    }
+    return { exceeded: false };
+}

package/dist/vendor/adapters/core/src/test-integrity.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Test Integrity Validator
+ *
+ * Detects circular test validation — the problem where AI agents generate
+ * tests that only pass because they test the agent's own output, not real
+ * behavior. A test that passes on both the pre-change and post-change
+ * codebase proves nothing about the change.
+ *
+ * Strategy:
+ * 1. Snapshot which test files existed before the agent ran
+ * 2. After the run, identify NEW test files the agent created
+ * 3. For each new test: check if it imports/references pre-existing code
+ *    (real test) or only references agent-generated code (circular test)
+ * 4. Flag tests that don't exercise any pre-existing function
+ *
+ * This module provides the analysis primitives. The verification pipeline
+ * calls these during the post-run verification step.
+ */
+export interface TestIntegrityReport {
+    totalNewTests: number;
+    realTests: number;
+    suspiciousTests: number;
+    findings: TestIntegrityFinding[];
+    verdict: "pass" | "warn" | "fail";
+    summary: string;
+}
+export interface TestIntegrityFinding {
+    filePath: string;
+    issue: "no_pre_existing_imports" | "self_referential" | "trivial_assertion" | "empty_test";
+    severity: "high" | "medium" | "low";
+    detail: string;
+}
+/**
+ * Detect test files in a directory tree.
+ */
+export declare function findTestFiles(rootDir: string): string[];
+/**
+ * Check if a filename matches test file patterns.
+ */
+export declare function isTestFile(filename: string, fullPath?: string): boolean;
+/**
+ * Snapshot existing test files before an agent run.
+ */
+export declare function snapshotTestFiles(rootDir: string): Set<string>;
+/**
+ * Identify new test files created during an agent run.
+ */
+export declare function identifyNewTests(rootDir: string, preRunSnapshot: Set<string>): string[];
+/**
+ * Extract import paths from a TypeScript/JavaScript file.
+ */
+export declare function extractImports(content: string): string[];
+/**
+ * Check if a test file contains only trivial assertions.
+ */
+export declare function hasTrivialAssertionsOnly(content: string): boolean;
+/**
+ * Check if a test file imports any pre-existing source files.
+ */
+export declare function importsPreExistingCode(testContent: string, preRunSourceFiles: Set<string>): boolean;
+/**
+ * Validate the integrity of tests created during a governed run.
+ */
+export declare function validateTestIntegrity(rootDir: string, preRunTestSnapshot: Set<string>, preRunSourceFiles: Set<string>): TestIntegrityReport;

package/dist/vendor/adapters/core/src/test-integrity.js

@@ -0,0 +1,197 @@
+/**
+ * Test Integrity Validator
+ *
+ * Detects circular test validation — the problem where AI agents generate
+ * tests that only pass because they test the agent's own output, not real
+ * behavior. A test that passes on both the pre-change and post-change
+ * codebase proves nothing about the change.
+ *
+ * Strategy:
+ * 1. Snapshot which test files existed before the agent ran
+ * 2. After the run, identify NEW test files the agent created
+ * 3. For each new test: check if it imports/references pre-existing code
+ *    (real test) or only references agent-generated code (circular test)
+ * 4. Flag tests that don't exercise any pre-existing function
+ *
+ * This module provides the analysis primitives. The verification pipeline
+ * calls these during the post-run verification step.
+ */
+import { readFileSync, readdirSync, existsSync } from "node:fs";
+import { join, relative } from "node:path";
+const TEST_FILE_PATTERNS = [
+    /\.test\.[tj]sx?$/,
+    /\.spec\.[tj]sx?$/,
+    /\/__tests__\//,
+    /\/tests?\//
+];
+const TRIVIAL_ASSERTION_PATTERNS = [
+    /expect\(true\)\.toBe\(true\)/,
+    /expect\(1\)\.toBe\(1\)/,
+    /expect\(\)\.toBeUndefined\(\)/,
+    /assert\.ok\(true\)/,
+    /expect\(.*\)\.toBeDefined\(\)/,
+    /expect\(typeof\s+\w+\)\.toBe\(['"]\w+['"]\)/
+];
+const IMPORT_PATTERN = /(?:import\s+.*from\s+['"]([^'"]+)['"]|require\s*\(\s*['"]([^'"]+)['"]\s*\))/g;
+/**
+ * Detect test files in a directory tree.
+ */
+export function findTestFiles(rootDir) {
+    const results = [];
+    function walk(dir) {
+        if (!existsSync(dir))
+            return;
+        try {
+            const entries = readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = join(dir, entry.name);
+                if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git")
+                    continue;
+                if (entry.isDirectory()) {
+                    walk(fullPath);
+                }
+                else if (entry.isFile() && isTestFile(entry.name, fullPath)) {
+                    results.push(relative(rootDir, fullPath));
+                }
+            }
+        }
+        catch {
+            // Permission denied or inaccessible — skip silently
+        }
+    }
+    walk(rootDir);
+    return results;
+}
+/**
+ * Check if a filename matches test file patterns.
+ */
+export function isTestFile(filename, fullPath) {
+    const checkPath = fullPath ?? filename;
+    return TEST_FILE_PATTERNS.some((pattern) => pattern.test(checkPath));
+}
+/**
+ * Snapshot existing test files before an agent run.
+ */
+export function snapshotTestFiles(rootDir) {
+    return new Set(findTestFiles(rootDir));
+}
+/**
+ * Identify new test files created during an agent run.
+ */
+export function identifyNewTests(rootDir, preRunSnapshot) {
+    const currentTests = findTestFiles(rootDir);
+    return currentTests.filter((testPath) => !preRunSnapshot.has(testPath));
+}
+/**
+ * Extract import paths from a TypeScript/JavaScript file.
+ */
+export function extractImports(content) {
+    const imports = [];
+    let match;
+    const pattern = new RegExp(IMPORT_PATTERN.source, "g");
+    while ((match = pattern.exec(content)) !== null) {
+        const importPath = match[1] ?? match[2];
+        if (importPath)
+            imports.push(importPath);
+    }
+    return imports;
+}
+/**
+ * Check if a test file contains only trivial assertions.
+ */
+export function hasTrivialAssertionsOnly(content) {
+    const assertionLines = content.split("\n").filter((line) => /expect\(|assert\.|should\./i.test(line));
+    if (assertionLines.length === 0)
+        return true;
+    return assertionLines.every((line) => TRIVIAL_ASSERTION_PATTERNS.some((pattern) => pattern.test(line)));
+}
+/**
+ * Check if a test file imports any pre-existing source files.
+ */
+export function importsPreExistingCode(testContent, preRunSourceFiles) {
+    const imports = extractImports(testContent);
+    return imports.some((importPath) => {
+        // Relative imports that reference pre-existing files
+        if (importPath.startsWith(".") || importPath.startsWith("/")) {
+            // Normalize: strip extension, check if any pre-existing source matches
+            const normalized = importPath.replace(/\.[tj]sx?$/, "");
+            return [...preRunSourceFiles].some((srcFile) => {
+                const normalizedSrc = srcFile.replace(/\.[tj]sx?$/, "");
+                return normalizedSrc.endsWith(normalized) || normalized.endsWith(normalizedSrc);
+            });
+        }
+        // Package imports always count as real (they reference pre-existing deps)
+        return true;
+    });
+}
+/**
+ * Validate the integrity of tests created during a governed run.
+ */
+export function validateTestIntegrity(rootDir, preRunTestSnapshot, preRunSourceFiles) {
+    const newTests = identifyNewTests(rootDir, preRunTestSnapshot);
+    const findings = [];
+    for (const testPath of newTests) {
+        const fullPath = join(rootDir, testPath);
+        let content;
+        try {
+            content = readFileSync(fullPath, "utf8");
+        }
+        catch {
+            findings.push({
+                filePath: testPath,
+                issue: "empty_test",
+                severity: "high",
+                detail: "Test file could not be read."
+            });
+            continue;
+        }
+        if (content.trim().length === 0) {
+            findings.push({
+                filePath: testPath,
+                issue: "empty_test",
+                severity: "high",
+                detail: "Test file is empty."
+            });
+            continue;
+        }
+        if (hasTrivialAssertionsOnly(content)) {
+            findings.push({
+                filePath: testPath,
+                issue: "trivial_assertion",
+                severity: "high",
+                detail: "Test contains only trivial assertions (expect(true).toBe(true) or equivalent)."
+            });
+            continue;
+        }
+        if (!importsPreExistingCode(content, preRunSourceFiles)) {
+            findings.push({
+                filePath: testPath,
+                issue: "no_pre_existing_imports",
+                severity: "medium",
+                detail: "Test does not import any pre-existing source code. May be testing only agent-generated output."
+            });
+        }
+    }
+    const suspiciousTests = findings.filter((f) => f.severity === "high").length;
+    const realTests = newTests.length - suspiciousTests;
+    const verdict = suspiciousTests > 0 && suspiciousTests >= newTests.length * 0.5
+        ? "fail"
+        : suspiciousTests > 0
+            ? "warn"
+            : "pass";
+    const summary = newTests.length === 0
+        ? "No new test files detected."
+        : verdict === "pass"
+            ? `${newTests.length} new test(s) validated — all reference pre-existing code.`
+            : verdict === "warn"
+                ? `${suspiciousTests} of ${newTests.length} new test(s) flagged for review.`
+                : `Test integrity check failed: ${suspiciousTests} of ${newTests.length} new test(s) appear circular or trivial.`;
+    return {
+        totalNewTests: newTests.length,
+        realTests,
+        suspiciousTests,
+        findings,
+        verdict,
+        summary
+    };
+}

package/dist/vendor/adapters/core/src/trajectory.d.ts

@@ -0,0 +1,18 @@
+import { type CircuitBreakDecision, type TrajectoryAssessment } from "../../../contracts/index.js";
+export declare function assessTrajectory(input: {
+    objective: string;
+    verificationPlan?: string[];
+    attempts: TrajectoryAttemptLike[];
+}): TrajectoryAssessment;
+export declare function decideCircuitBreak(input: {
+    objective: string;
+    verificationPlan?: string[];
+    attempts: TrajectoryAttemptLike[];
+    remainingIterations?: number;
+}): CircuitBreakDecision;
+interface TrajectoryAttemptLike {
+    index: number;
+    summary?: string;
+    failureClass?: string;
+}
+export {};