@martinloop/mcp 0.5.0 → 0.5.3

package/dist/vendor/core/red-blue/red-phase.d.ts

@@ -20,6 +20,7 @@ export interface MockModelClient {
         findings: RedFinding[];
         tokensUsed: number;
         costUsd: number;
+        model?: string;
     }>;
 }
 export interface RunRedPhaseOptions {
@@ -47,7 +48,7 @@ export interface PatchInput {
  *
  * - baseline: programmatic probes only, no model call
  * - high_risk: paranoid programmatic scan, no model call
- * - release_critical: paranoid scan + one Haiku model call
+ * - release_critical: paranoid scan + one configured model-client call
  */
 export declare function runRedPhase(patch: PatchInput, tier: RiskTier, blueBudgetUsd: number, options?: RunRedPhaseOptions): Promise<RedFindings>;
 /**

package/dist/vendor/core/red-blue/red-phase.js

@@ -1,4 +1,4 @@
-import { PROBE_COUNTS, RED_PHASE_MODEL, resolveRedBudgetPolicy } from "./risk-tiers.js";
+import { PROBE_COUNTS, resolveRedBudgetPolicy } from "./risk-tiers.js";
 // ─── Programmatic probes ──────────────────────────────────────────────────────
 function runProgrammaticProbes(patch, paranoid) {
     const findings = [];
@@ -62,7 +62,7 @@ function runProgrammaticProbes(patch, paranoid) {
  *
  * - baseline: programmatic probes only, no model call
  * - high_risk: paranoid programmatic scan, no model call
- * - release_critical: paranoid scan + one Haiku model call
+ * - release_critical: paranoid scan + one configured model-client call
  */
 export async function runRedPhase(patch, tier, blueBudgetUsd, options = {}) {
     const policy = resolveRedBudgetPolicy(tier, blueBudgetUsd);
@@ -77,7 +77,7 @@ export async function runRedPhase(patch, tier, blueBudgetUsd, options = {}) {
         const result = await options.modelClient.complete(prompt);
         findings = [...findings, ...result.findings];
         modelCallMade = true;
-        modelUsed = RED_PHASE_MODEL;
+        modelUsed = result.model;
         budgetUsedUsd += result.costUsd;
     }
     const result = {

package/dist/vendor/core/red-blue/risk-tiers.d.ts

@@ -4,7 +4,7 @@ export interface RedBudgetPolicy {
     blueBudgetUsd: number;
     /** Cap on Red phase spend: 30% / 100% / 150% of Blue */
     redBudgetCapUsd: number;
-    /** Only release_critical permits a Haiku model call */
+    /** Only release_critical permits an optional configured model-client call. */
     modelCallAllowed: boolean;
 }
 /**
@@ -15,8 +15,6 @@ export declare function resolveRedBudgetPolicy(tier: RiskTier, blueBudgetUsd: nu
  * Probe counts per tier.
  * baseline = standard 6-probe sweep
  * high_risk = paranoid 12-probe sweep
- * release_critical = paranoid 12-probe sweep + model
+ * release_critical = paranoid 12-probe sweep + configured model client
  */
 export declare const PROBE_COUNTS: Record<RiskTier, number>;
-/** The only model ever permitted in the Red phase. */
-export declare const RED_PHASE_MODEL: "claude-haiku-4-5-20251001";

package/dist/vendor/core/red-blue/risk-tiers.js

@@ -21,12 +21,10 @@ export function resolveRedBudgetPolicy(tier, blueBudgetUsd) {
  * Probe counts per tier.
  * baseline = standard 6-probe sweep
  * high_risk = paranoid 12-probe sweep
- * release_critical = paranoid 12-probe sweep + model
+ * release_critical = paranoid 12-probe sweep + configured model client
  */
 export const PROBE_COUNTS = {
     baseline: 6,
     high_risk: 12,
     release_critical: 12
 };
-/** The only model ever permitted in the Red phase. */
-export const RED_PHASE_MODEL = "claude-haiku-4-5-20251001";

package/dist/vendor/core/routing.d.ts

@@ -15,14 +15,6 @@ export interface RouteDecision {
     blockedSteps: string[];
     compressed: boolean;
     compressionSummary?: string;
-    /**
-     * Recommended model tier based on task complexity and route.
-     * Follows cost-aware routing: direct → haiku/sonnet, manager → sonnet,
-     * consensus → opus. Never use a more expensive model than the task needs.
-     */
-    recommendedModelTier: "haiku" | "sonnet" | "opus";
-    /** Estimated cost saving vs always using sonnet */
-    estimatedSavingVsSonnetUsd: number;
 }
 export interface RouteClassificationInput {
     objective: string;
@@ -37,40 +29,6 @@ export interface RouteClassificationInput {
     /** Historical success rate for similar tasks with direct execution (0-1). */
     historicalDirectSuccessRate?: number;
 }
-/**
- * Resolve a tier to a concrete model ID for a specific engine.
- * Allows downstream adapters to switch models automatically.
- */
-export declare function resolveModelForTier(tier: RouteDecision["recommendedModelTier"], engine: "claude" | "codex" | "gemini" | "openai" | string): string;
-/**
- * Available engine registry — describes what's installed and its capability.
- * Populated by doctor/preflight from PATH and env var detection.
- */
-export interface AvailableEngine {
-    id: string;
-    available: boolean;
-    /** Cost tier: cheap < mid < expensive */
-    costTier: "cheap" | "mid" | "expensive";
-    /** Capability tier: determines which task types this engine can handle */
-    capabilityTier: "haiku" | "sonnet" | "opus";
-}
-/**
- * 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 declare function selectBestEngine(requiredTier: RouteDecision["recommendedModelTier"], availableEngines: AvailableEngine[]): {
-    engineId: string;
-    model: string;
-    reasoning: string;
-};
 export declare function classifyRoute(input: RouteClassificationInput): RouteDecision;
 /**
  * Checks whether a run's Pre Work Burn exceeds the routing policy limits.

package/dist/vendor/core/routing.js

@@ -84,144 +84,6 @@ function calculateDirectConfidence(signals, input) {
 // ---------------------------------------------------------------------------
 // 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);
@@ -230,7 +92,6 @@ export function classifyRoute(input) {
     const blockedSteps = [];
     // Policy override: forced mode
     if (policy.mode === "direct") {
-        const tier = selectModelTier("direct");
         return {
             selectedMode: "direct",
             confidence: 1,
@@ -239,13 +100,10 @@ export function classifyRoute(input) {
             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)
+            compressionSummary: "Policy: direct mode — skipping all orchestration."
         };
     }
     if (policy.mode === "consensus") {
-        const tier = selectModelTier("consensus");
         return {
             selectedMode: "consensus",
             confidence: 0.5,
@@ -253,9 +111,7 @@ export function classifyRoute(input) {
             expectedPreworkBurnPct: 35,
             reason: ["Policy forces consensus mode."],
             blockedSteps: [],
-            compressed: false,
-            recommendedModelTier: tier,
-            estimatedSavingVsSonnetUsd: estimateSavingVsSonnet(tier, input.budgetUsd)
+            compressed: false
         };
     }
     // Adaptive routing
@@ -268,7 +124,6 @@ export function classifyRoute(input) {
         if (signals.scopeRestricted)
             reason.push("Path scope is restricted.");
         blockedSteps.push("manager", "consensus");
-        const tier = selectModelTier("direct");
         return {
             selectedMode: "direct",
             confidence: directConfidence,
@@ -277,9 +132,7 @@ export function classifyRoute(input) {
             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)
+            compressionSummary: `Compressed from manager→planner→worker to direct worker. Estimated savings: ${String(Math.round(input.budgetUsd * 0.3 * 100) / 100)} USD.`
         };
     }
     // Complex task — needs orchestration
@@ -293,7 +146,6 @@ export function classifyRoute(input) {
         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,
@@ -301,9 +153,7 @@ export function classifyRoute(input) {
         expectedPreworkBurnPct: needsConsensus ? 40 : 25,
         reason,
         blockedSteps: needsConsensus ? [] : ["consensus"],
-        compressed: false,
-        recommendedModelTier: tier,
-        estimatedSavingVsSonnetUsd: estimateSavingVsSonnet(tier, input.budgetUsd)
+        compressed: false
     };
 }
 function estimateDirectCost(budgetUsd) {

package/dist/vendor/core/verified-handoff.d.ts

@@ -1,4 +1,4 @@
-import type { LoopRecord, ReceiptIntegritySummary, TestIntegrityStatus, TestIntegrityVerdict, VerifiedHandoffOutcome, VerifiedHandoffRecoveryV1, VerifiedHandoffRequirementV1, VerifiedHandoffScopeV1, VerifiedHandoffTestIntegrityV1, VerifiedHandoffV1 } from "../contracts/index.js";
+import type { ExecutionMode, LoopRecord, ReceiptIntegritySummary, TestIntegrityStatus, TestIntegrityVerdict, VerifiedHandoffOutcome, VerifiedHandoffRecoveryV1, VerifiedHandoffRequirementV1, VerifiedHandoffScopeV1, VerifiedHandoffTestIntegrityV1, VerifiedHandoffV1 } from "../contracts/index.js";
 export declare function toTestIntegrityVerdict(status: TestIntegrityStatus): TestIntegrityVerdict;
 export interface VerifierExecutionBinding {
     runId: string;
@@ -30,8 +30,13 @@ export declare function resolveVerifiedHandoffOutcome(input: {
     changedFileCount?: number;
     definitionOfDonePreSatisfied?: boolean;
     evidenceContradicted?: boolean;
+    governanceClaimEligible?: boolean;
     unresolvedWorkCount: number;
 }): VerifiedHandoffOutcome;
+export declare function deriveVerifiedHandoffExecutionBoundary(loop: LoopRecord): {
+    executionMode: ExecutionMode;
+    governanceClaimEligible: boolean;
+};
 export interface BuildVerifiedHandoffInput {
     loop: LoopRecord;
     generatedAt?: string;

package/dist/vendor/core/verified-handoff.js

@@ -57,6 +57,7 @@ export function resolveVerifiedHandoffOutcome(input) {
         return "STOPPED";
     }
     if (input.executionStatus === "failed" ||
+        input.governanceClaimEligible === false ||
         input.evidenceContradicted === true ||
         (input.mutationRequired === true &&
             (input.changedFileCount ?? 0) === 0 &&
@@ -80,6 +81,29 @@ export function resolveVerifiedHandoffOutcome(input) {
     }
     return "NEEDS_REVIEW";
 }
+const SIMULATED_ADAPTER_PATTERN = /(?:^|:)(?:stub|fixture|synthetic)(?::|$)/u;
+function isExecutionMode(value) {
+    return value === "governed" || value === "verification_only" || value === "simulated";
+}
+export function deriveVerifiedHandoffExecutionBoundary(loop) {
+    const adapterIds = loop.attempts.map((attempt) => attempt.adapterId);
+    const hasSimulatedAdapter = adapterIds.some((adapterId) => adapterId === "direct:proof:no-mutation" ||
+        SIMULATED_ADAPTER_PATTERN.test(adapterId));
+    const hasVerifierOnlyAdapter = adapterIds.some((adapterId) => adapterId === "direct:verifier:verify-only");
+    const persistedMode = isExecutionMode(loop.metadata["executionMode"])
+        ? loop.metadata["executionMode"]
+        : undefined;
+    const groundingEvidenceAvailable = loop.metadata["groundingEvidenceStatus"] !== "unavailable";
+    const executionMode = hasSimulatedAdapter
+        ? "simulated"
+        : hasVerifierOnlyAdapter
+            ? "verification_only"
+            : persistedMode ?? (adapterIds.length > 0 ? "governed" : "simulated");
+    return {
+        executionMode,
+        governanceClaimEligible: executionMode === "governed" && adapterIds.length > 0 && groundingEvidenceAvailable,
+    };
+}
 function toEvidenceStatus(status) {
     switch (status) {
         case "passed":
@@ -132,6 +156,7 @@ export function buildVerifiedHandoff(input) {
         summary: input.testIntegrity?.summary ??
             "Test integrity was not evaluated for this run.",
     };
+    const executionBoundary = deriveVerifiedHandoffExecutionBoundary(input.loop);
     const outcome = resolveVerifiedHandoffOutcome({
         lifecycleState: input.loop.lifecycleState,
         executionStatus: input.executionStatus,
@@ -143,6 +168,7 @@ export function buildVerifiedHandoff(input) {
         changedFileCount: scope.changedFiles.length,
         definitionOfDonePreSatisfied: input.definitionOfDonePreSatisfied,
         evidenceContradicted: input.evidenceContradicted ?? input.verification.status === "contradicted",
+        governanceClaimEligible: executionBoundary.governanceClaimEligible,
         unresolvedWorkCount: unresolvedWork.length,
     });
     const handoffId = `vh_${createHash("sha256")
@@ -163,6 +189,8 @@ export function buildVerifiedHandoff(input) {
             verificationPlan: input.loop.task.verificationPlan,
         },
         outcome,
+        executionMode: executionBoundary.executionMode,
+        governanceClaimEligible: executionBoundary.governanceClaimEligible,
         sourceStatus: {
             status: input.loop.status,
             lifecycleState: input.loop.lifecycleState,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@martinloop/mcp",
-  "version": "0.5.0",
+  "version": "0.5.3",
   "mcpName": "io.github.Keesan12/martin-loop",
   "private": false,
   "type": "module",
@@ -59,7 +59,10 @@
     "test": "vitest run --maxWorkers=1",
     "lint": "tsc -p tsconfig.json --noEmit",
     "start": "node dist/server.js",
-    "inspect:live": "node ./scripts/inspect-live.mjs"
+    "inspect:live": "node ./scripts/inspect-live.mjs",
+    "mcpb:build": "node ./mcpb/build-mcpb.mjs",
+    "mcpb:validate": "mcpb validate ./dist-mcpb/martinloop",
+    "mcpb:smoke": "node ./mcpb/smoke-mcpb.mjs"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
@@ -71,6 +74,7 @@
     "ts-morph": "^21.0.0"
   },
   "devDependencies": {
+    "@anthropic-ai/mcpb": "2.1.2",
     "@martin/contracts": "workspace:*"
   }
 }

package/server.json

@@ -7,12 +7,12 @@
     "url": "https://github.com/Keesan12/martin-loop",
     "source": "github"
   },
-  "version": "0.5.0",
+  "version": "0.5.3",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@martinloop/mcp",
-      "version": "0.5.0",
+      "version": "0.5.3",
       "transport": {
         "type": "stdio"
       }

package/dist/vendor/adapters/stub-direct-provider.d.ts

@@ -1,8 +0,0 @@
-import type { MartinAdapter, MartinAdapterRequest, MartinAdapterResult } from "../core/index.js";
-export interface StubDirectProviderAdapterOptions {
-    providerId: string;
-    model: string;
-    label?: string;
-    responder?: (request: MartinAdapterRequest) => Promise<MartinAdapterResult> | MartinAdapterResult;
-}
-export declare function createStubDirectProviderAdapter(options: StubDirectProviderAdapterOptions): MartinAdapter;

package/dist/vendor/adapters/stub-direct-provider.js

@@ -1,12 +0,0 @@
-import { createDirectProviderAdapter } from "./direct-provider.js";
-export function createStubDirectProviderAdapter(options) {
-    return createDirectProviderAdapter({
-        providerId: options.providerId,
-        model: options.model,
-        label: options.label ?? `Stub direct provider (${options.providerId}/${options.model})`,
-        capabilities: {
-            workspaceMutations: false
-        },
-        responder: options.responder
-    });
-}