@martinloop/mcp 0.3.6 → 0.3.8

package/dist/vendor/adapters/claude-cli.js

@@ -17,22 +17,18 @@ import { createAdapterCapabilities, normalizeStructuredErrors, normalizeUsage }
 // ---------------------------------------------------------------------------
 // Cost estimation
 //
-// Token costs are estimated using a blended average across top models:
-// Anthropic Sonnet, OpenAI GPT-4o Mini, Gemini Flash, Meta Llama 3.
-// Override at runtime with --input-cost-per-1k / --output-cost-per-1k CLI
-// flags or martin.config.yaml pricing section.
+// Streaming enforcement needs a model-specific estimate until Claude emits
+// authoritative total_cost_usd on the final result event. Unknown Claude
+// models are never assigned another model's price.
 // ---------------------------------------------------------------------------
 const BLENDED_INPUT_COST_PER_1K = 0.003; // $/1K input tokens
 const BLENDED_OUTPUT_COST_PER_1K = 0.012; // $/1K output tokens
-// Per-model overrides for common Claude models (fallback: blended average)
+// USD per 1K tokens. Claude cache creation uses the documented default
+// five-minute rate; cache reads are priced independently from fresh input.
 const MODEL_PRICING = {
-    "claude-opus-4-6": { inputPer1K: 0.015, outputPer1K: 0.075 },
-    "claude-sonnet-4-6": { inputPer1K: 0.003, outputPer1K: 0.015 },
-    "claude-haiku-4-5": { inputPer1K: 0.00025, outputPer1K: 0.00125 },
-    // Keep legacy names working
-    "claude-opus": { inputPer1K: 0.015, outputPer1K: 0.075 },
-    "claude-sonnet": { inputPer1K: 0.003, outputPer1K: 0.015 },
-    "claude-haiku": { inputPer1K: 0.00025, outputPer1K: 0.00125 },
+    "claude-opus-4-6": { inputPer1K: 0.005, cachedInputPer1K: 0.0005, cacheCreationInputPer1K: 0.00625, outputPer1K: 0.025 },
+    "claude-sonnet-4-6": { inputPer1K: 0.003, cachedInputPer1K: 0.0003, cacheCreationInputPer1K: 0.00375, outputPer1K: 0.015 },
+    "claude-haiku-4-5": { inputPer1K: 0.001, cachedInputPer1K: 0.0001, cacheCreationInputPer1K: 0.00125, outputPer1K: 0.005 },
     // OpenAI coding models
     "codex": { inputPer1K: 0.00125, cachedInputPer1K: 0.000125, outputPer1K: 0.01 },
     "gpt-5-codex": { inputPer1K: 0.00125, cachedInputPer1K: 0.000125, outputPer1K: 0.01 },
@@ -41,6 +37,37 @@ const MODEL_PRICING = {
     "gpt-5.2-codex": { inputPer1K: 0.00175, cachedInputPer1K: 0.000175, outputPer1K: 0.014 },
     "codex-mini-latest": { inputPer1K: 0.0015, cachedInputPer1K: 0.000375, outputPer1K: 0.006 }
 };
+const CLAUDE_MODEL_ALIASES = [
+    { canonicalModelId: "claude-opus-4-6", aliases: [/^claude-opus-4-6-\d{8}$/u, /^claude-opus$/u] },
+    { canonicalModelId: "claude-sonnet-4-6", aliases: [/^claude-sonnet-4-6-\d{8}$/u, /^claude-sonnet$/u] },
+    { canonicalModelId: "claude-haiku-4-5", aliases: [/^claude-haiku-4-5-\d{8}$/u, /^claude-haiku$/u] }
+];
+function resolveModelPricing(modelLabel) {
+    const normalized = modelLabel?.trim().toLowerCase();
+    if (!normalized) {
+        return { status: "unknown" };
+    }
+    const exact = MODEL_PRICING[normalized];
+    if (exact) {
+        return { status: "exact", canonicalModelId: normalized, pricing: exact };
+    }
+    for (const family of CLAUDE_MODEL_ALIASES) {
+        if (family.aliases.some((alias) => alias.test(normalized))) {
+            return {
+                status: "alias",
+                canonicalModelId: family.canonicalModelId,
+                pricing: MODEL_PRICING[family.canonicalModelId]
+            };
+        }
+    }
+    return { status: "unknown" };
+}
+function calculateUsageCost(usage, pricing) {
+    return ((usage.inputTokens / 1000) * pricing.inputPer1K +
+        (usage.cachedInputTokens / 1000) * (pricing.cachedInputPer1K ?? pricing.inputPer1K) +
+        (usage.cacheCreationInputTokens / 1000) * (pricing.cacheCreationInputPer1K ?? pricing.inputPer1K) +
+        (usage.outputTokens / 1000) * pricing.outputPer1K);
+}
 function extractUsage(parsed, modelLabel) {
     if (!parsed?.usage) {
         return normalizeUsage({
@@ -50,34 +77,38 @@ function extractUsage(parsed, modelLabel) {
             provenance: "unavailable"
         });
     }
-    const promptTokens = (parsed.usage.inputTokens ?? parsed.usage.input_tokens ?? 0) +
-        (parsed.usage.cacheCreationInputTokens ?? parsed.usage.cache_creation_input_tokens ?? 0);
+    const promptTokens = parsed.usage.inputTokens ?? parsed.usage.input_tokens ?? 0;
+    const cacheCreationInputTokens = parsed.usage.cacheCreationInputTokens ?? parsed.usage.cache_creation_input_tokens ?? 0;
     const cachedInputTokens = parsed.usage.cacheReadInputTokens ?? parsed.usage.cache_read_input_tokens ?? 0;
-    const tokensIn = promptTokens + cachedInputTokens;
+    const tokensIn = promptTokens + cachedInputTokens + cacheCreationInputTokens;
     const tokensOut = parsed.usage.outputTokens ?? parsed.usage.output_tokens ?? 0;
-    const pricing = (modelLabel ? MODEL_PRICING[modelLabel] : undefined) ??
-        { inputPer1K: BLENDED_INPUT_COST_PER_1K, outputPer1K: BLENDED_OUTPUT_COST_PER_1K };
+    const pricingResolution = resolveModelPricing(modelLabel);
     // Prefer Claude's own authoritative total_cost_usd (present on the final
     // `result` event in json/stream-json output) over our pricing-table estimate,
     // which can drift from real billed cost (cache discounts, surcharges, etc).
     const hasAuthoritativeCost = typeof parsed.total_cost_usd === "number";
     const actualUsd = hasAuthoritativeCost
         ? parsed.total_cost_usd
-        : (promptTokens / 1000) * pricing.inputPer1K +
-            (cachedInputTokens / 1000) * (pricing.cachedInputPer1K ?? pricing.inputPer1K) +
-            (tokensOut / 1000) * pricing.outputPer1K;
+        : pricingResolution.pricing
+            ? calculateUsageCost({
+                inputTokens: promptTokens,
+                cachedInputTokens,
+                cacheCreationInputTokens,
+                outputTokens: tokensOut
+            }, pricingResolution.pricing)
+            : 0;
     return normalizeUsage({
         actualUsd: Number(actualUsd.toFixed(6)),
         tokensIn,
         tokensOut,
         cachedInputTokens,
-        provenance: hasAuthoritativeCost ? "actual" : "estimated",
+        provenance: hasAuthoritativeCost ? "actual" : pricingResolution.pricing ? "estimated" : "unavailable",
         providerSettlement: {
             providerId: "claude",
             model: modelLabel ?? "claude",
             transport: "cli",
             source: "claude_json",
-            inputTokens: promptTokens,
+            inputTokens: promptTokens + cacheCreationInputTokens,
             cachedInputTokens,
             outputTokens: tokensOut,
             rawUsageAvailable: true,
@@ -240,8 +271,7 @@ function extractGeminiJsonResult(stdout, modelLabel) {
     };
 }
 function createStreamingUsageInspector(capUsd, modelLabel, promptTokenEstimate) {
-    const pricing = (modelLabel ? MODEL_PRICING[modelLabel] : undefined) ??
-        { inputPer1K: BLENDED_INPUT_COST_PER_1K, outputPer1K: BLENDED_OUTPUT_COST_PER_1K };
+    let pricingResolution = resolveModelPricing(modelLabel);
     // Safety margin: terminate at 80% of cap to bound one-turn overshoot.
     // Without this, a single expensive turn can blow past the cap before the
     // next check fires (proven live: $1.50 cap → $28.42 actual).
@@ -251,10 +281,12 @@ function createStreamingUsageInspector(capUsd, modelLabel, promptTokenEstimate)
     // Token-count ceiling fallback: if no usage events are ever parsed (e.g.
     // Claude changes its stream-json event format), use raw byte volume as a
     // last-resort circuit breaker. Derived from budget / blended cost per char.
-    const blendedCostPerChar = (pricing.inputPer1K / 1000 / 4) + (pricing.outputPer1K / 1000 / 4);
-    const bytesCeiling = blendedCostPerChar > 0
-        ? Math.ceil((capUsd / blendedCostPerChar) * 2)
-        : 100_000_000;
+    const resolveBlendedCostPerChar = () => {
+        const pricing = pricingResolution.pricing;
+        return pricing
+            ? (pricing.inputPer1K / 1000 / 4) + (pricing.outputPer1K / 1000 / 4)
+            : undefined;
+    };
     // Time-based fallback: if we receive data but no usage events for this long,
     // estimate spend from byte volume and enforce the cap. Prevents the inspector
     // from going blind when Claude changes its stream-json event format.
@@ -276,6 +308,9 @@ function createStreamingUsageInspector(capUsd, modelLabel, promptTokenEstimate)
         }
     };
     const extractUsageFromEvent = (event, terminate) => {
+        if (event.type === "system" && event.subtype === "init" && typeof event.model === "string") {
+            pricingResolution = resolveModelPricing(event.model);
+        }
         // Check for authoritative total_cost_usd on ANY event — if Claude reports
         // cost exceeding cap, terminate immediately regardless of event type.
         if (typeof event.total_cost_usd === "number" && event.total_cost_usd > 0) {
@@ -295,16 +330,27 @@ function createStreamingUsageInspector(capUsd, modelLabel, promptTokenEstimate)
             return;
         }
         const usageRecord = usage;
-        const turnTokensIn = (usageRecord.input_tokens ?? usageRecord.inputTokens ?? 0) +
-            (usageRecord.cache_read_input_tokens ?? usageRecord.cacheReadInputTokens ?? 0) +
-            (usageRecord.cache_creation_input_tokens ?? usageRecord.cacheCreationInputTokens ?? 0);
+        const turnInputTokens = usageRecord.input_tokens ?? usageRecord.inputTokens ?? 0;
+        const turnCachedInputTokens = usageRecord.cache_read_input_tokens ?? usageRecord.cacheReadInputTokens ?? 0;
+        const turnCacheCreationInputTokens = usageRecord.cache_creation_input_tokens ?? usageRecord.cacheCreationInputTokens ?? 0;
+        const turnTokensIn = turnInputTokens + turnCachedInputTokens + turnCacheCreationInputTokens;
         const turnTokensOut = usageRecord.output_tokens ?? usageRecord.outputTokens ?? 0;
         if (turnTokensIn === 0 && turnTokensOut === 0) {
             return;
         }
-        const turnUsd = (turnTokensIn / 1000) * pricing.inputPer1K + (turnTokensOut / 1000) * pricing.outputPer1K;
+        const turnUsd = pricingResolution.pricing
+            ? calculateUsageCost({
+                inputTokens: turnInputTokens,
+                cachedInputTokens: turnCachedInputTokens,
+                cacheCreationInputTokens: turnCacheCreationInputTokens,
+                outputTokens: turnTokensOut
+            }, pricingResolution.pricing)
+            : undefined;
         const remainingBudgetBeforeTurn = Math.max(capUsd - cumulativeUsd, 0);
-        if (capUsd > 0 && remainingBudgetBeforeTurn > 0 && turnUsd > remainingBudgetBeforeTurn * 0.5) {
+        if (turnUsd !== undefined &&
+            capUsd > 0 &&
+            remainingBudgetBeforeTurn > 0 &&
+            turnUsd > remainingBudgetBeforeTurn * 0.5) {
             cumulativeUsd += turnUsd;
             tokensIn += turnTokensIn;
             tokensOut += turnTokensOut;
@@ -318,7 +364,9 @@ function createStreamingUsageInspector(capUsd, modelLabel, promptTokenEstimate)
         tokensOut += turnTokensOut;
         turns += 1;
         usageEventSeen = true;
-        cumulativeUsd += turnUsd;
+        if (turnUsd !== undefined) {
+            cumulativeUsd += turnUsd;
+        }
         checkBudgetExceeded(terminate);
     };
     const ingestLine = (line, terminate) => {
@@ -333,10 +381,14 @@ function createStreamingUsageInspector(capUsd, modelLabel, promptTokenEstimate)
         catch {
             return;
         }
-        extractUsageFromEvent(event, terminate);
+        // result events contain aggregate usage that duplicates previously streamed
+        // assistant-message usage events — skip to avoid double-counting.
         if (event.type === "result") {
             finalResult = event;
         }
+        else {
+            extractUsageFromEvent(event, terminate);
+        }
     };
     return {
         onChunk: (chunk, terminate) => {
@@ -347,7 +399,11 @@ function createStreamingUsageInspector(capUsd, modelLabel, promptTokenEstimate)
             // Token-count ceiling fallback: if we've ingested a lot of bytes but
             // never seen a single usage event, the event format may have changed
             // and the inspector is silently blind. Terminate as a last resort.
-            if (!usageEventSeen && capUsd > 0 && totalBytes > bytesCeiling) {
+            const blendedCostPerChar = resolveBlendedCostPerChar();
+            const bytesCeiling = blendedCostPerChar && blendedCostPerChar > 0
+                ? Math.ceil((capUsd / blendedCostPerChar) * 2)
+                : undefined;
+            if (!usageEventSeen && capUsd > 0 && bytesCeiling !== undefined && totalBytes > bytesCeiling) {
                 terminate(`Streaming byte ceiling exceeded (${String(totalBytes)} bytes > ${String(bytesCeiling)} ceiling) ` +
                     `without any usage events parsed. The Claude stream-json event format may have changed. ` +
                     `Subprocess terminated as a fallback budget guard for cap $${capUsd.toFixed(4)}.`);
@@ -362,8 +418,8 @@ function createStreamingUsageInspector(capUsd, modelLabel, promptTokenEstimate)
                 firstChunkAt !== undefined &&
                 Date.now() - firstChunkAt > USAGE_BLIND_TIMEOUT_MS &&
                 totalBytes > 10_000) {
-                const estimatedUsd = totalBytes * blendedCostPerChar;
-                if (estimatedUsd > effectiveCapUsd) {
+                const estimatedUsd = blendedCostPerChar === undefined ? undefined : totalBytes * blendedCostPerChar;
+                if (estimatedUsd !== undefined && estimatedUsd > effectiveCapUsd) {
                     terminate(`No usage events received after ${String(Math.round((Date.now() - firstChunkAt) / 1000))}s ` +
                         `(${String(totalBytes)} bytes). Estimated cost ~$${estimatedUsd.toFixed(4)} exceeds cap ` +
                         `$${capUsd.toFixed(4)}. Subprocess terminated to prevent unmetered spend.`);
@@ -457,11 +513,11 @@ export function createAgentCliAdapter(options) {
         },
         async execute(request) {
             const prompt = buildPrompt(request);
-            const estimatedUsage = estimateUsage(prompt, options.model ?? options.command);
+            const estimatedUsage = estimateUsage(prompt, options.model ?? options.command, options.command);
             // Preflight: bail if projected cost exceeds remaining budget
             if (request.context.remainingBudgetUsd > 0) {
-                const projected = estimatePromptCost(prompt, options.model ?? "");
-                if (projected > request.context.remainingBudgetUsd * 0.95) {
+                const projected = estimatePromptCost(prompt, options.model ?? "", options.command);
+                if (projected !== undefined && projected > request.context.remainingBudgetUsd * 0.95) {
                     return {
                         status: "failed",
                         summary: `Preflight: projected cost $${projected.toFixed(4)} exceeds remaining budget $${request.context.remainingBudgetUsd.toFixed(4)}.`,
@@ -536,10 +592,14 @@ export function createAgentCliAdapter(options) {
                 };
             }
             if (agentResult.exitCode !== 0 && agentResult.stdout.trim().length === 0) {
+                const fullStderr = agentResult.stderr.trim();
+                const stderrSnippet = fullStderr ? fullStderr.slice(0, 2000) : "(no stderr)";
+                const stdoutLen = agentResult.stdout.length;
+                const diagnosticSummary = `${options.command} exited (code ${String(agentResult.exitCode)}) with empty stdout (${String(stdoutLen)} bytes). stderr: ${stderrSnippet}`;
                 const failureMessage = formatPreVerifierSubprocessFailure(options.command, agentResult.stderr, agentResult.exitCode);
                 return {
                     status: "failed",
-                    summary: `${options.command} subprocess exited before verifier execution.`,
+                    summary: diagnosticSummary,
                     usage: normalizeUsage({
                         actualUsd: 0,
                         tokensIn: 0,
@@ -548,6 +608,9 @@ export function createAgentCliAdapter(options) {
                     }),
                     verification: { passed: false, summary: `Verifier not run: ${failureMessage}` },
                     failure: {
+                        // Raw stderr is preserved in diagnosticSummary above; use the
+                        // normalized/classified message here so downstream consumers and
+                        // tests get a consistent, parseable failure signal.
                         message: failureMessage
                     }
                 };
@@ -810,12 +873,15 @@ export function createClaudeCliAdapter(options = {}) {
             "--verbose",
             "--print",
             "--dangerously-skip-permissions",
-            // Prevent the child Claude process from loading the parent's MCP servers.
-            // Without this, a MartinLoop MCP server in the user's config gets spawned
-            // inside the governed subprocess, causing conflicts and "MCP server being
-            // overwritten" errors.
-            "--strict-mcp-config",
-            ...(request.context.remainingTokens > 0 ? ["--max-tokens", String(request.context.remainingTokens)] : []),
+            // Subprocess isolation strategy:
+            // --bare: skips hooks (prevents SessionEnd/hook failures causing non-zero exits),
+            //   MCP server loading, LSP, CLAUDE.md discovery, and background prefetches.
+            //   Requires ANTHROPIC_API_KEY (OAuth/keychain auth not available in bare mode).
+            // --strict-mcp-config: fallback when ANTHROPIC_API_KEY is not set — still
+            //   prevents parent MCP servers from being inherited by the subprocess.
+            ...(process.env["ANTHROPIC_API_KEY"] ? ["--bare"] : ["--strict-mcp-config"]),
+            // NOTE: --max-tokens does not exist in the claude CLI. Token cap enforcement
+            // is handled at the MartinLoop layer via streamingUsageCap, not via subprocess flags.
             ...modelArgs,
             ...extraArgs
         ],
@@ -915,21 +981,13 @@ function buildPrompt(request) {
     const lines = [];
     const mutationMode = request.context.mutationMode ?? "edit";
     lines.push("You are running in autonomous agentic mode.");
-    if (mutationMode === "verify_only") {
-        lines.push("DO NOT EDIT FILES. Run the verifier only and report whether it passes.");
-        lines.push("Do not ask for confirmation. Do not ask clarifying questions.");
-    }
-    else {
-        lines.push("MAKE ALL REQUIRED FILE EDITS NOW. Do not ask for confirmation. Do not ask clarifying questions.");
-        lines.push("Do not explain what you found without also making the changes. Edit the files and complete the task.");
-    }
+    lines.push("MAKE ALL REQUIRED FILE EDITS NOW. Do not ask for confirmation. Do not ask clarifying questions.");
+    lines.push("Do not explain what you found without also making the changes. Edit the files and complete the task.");
     lines.push("");
     lines.push("If PROGRESS.md exists in your working directory, read it first for context from prior attempts.");
     lines.push("If it does not exist, proceed with the objective below.");
     lines.push("");
-    lines.push(mutationMode === "verify_only"
-        ? "Complete the following verification-only task without making file changes."
-        : "Complete the following coding task. Make all necessary file changes.");
+    lines.push("Complete the following coding task. Make all necessary file changes.");
     lines.push("When you are done, the verification commands listed below must pass.");
     lines.push("");
     lines.push("OBJECTIVE:");
@@ -967,9 +1025,7 @@ function buildPrompt(request) {
     lines.push(`  Attempt ${String(attemptNumber)}`);
     lines.push(`  Remaining budget: $${String(request.context.remainingBudgetUsd)} USD`);
     lines.push(`  Remaining iterations: ${String(request.context.remainingIterations)}`);
-    lines.push(mutationMode === "verify_only"
-        ? "  Do not modify files; only run verification."
-        : "  Do not expand scope beyond what is needed to pass verification.");
+    lines.push("  Do not expand scope beyond what is needed to pass verification.");
     lines.push("");
     if (request.previousAttempts.length > 0) {
         lines.push("PRIOR FAILED ATTEMPTS (learn from these — do not repeat the same mistakes):");
@@ -1040,21 +1096,27 @@ function sanitizeForPrompt(input) {
     }
     return redactSecretsForPrompt(out);
 }
-function estimatePromptCost(promptText, model) {
+function estimatePromptCost(promptText, model, providerCommand) {
     const inputTokens = Math.ceil(promptText.length / 3.5);
     const outputTokens = 2000;
-    const pricing = MODEL_PRICING[model] ?? { inputPer1K: BLENDED_INPUT_COST_PER_1K, outputPer1K: BLENDED_OUTPUT_COST_PER_1K };
+    const pricing = resolveModelPricing(model).pricing ?? (providerCommand === "claude"
+        ? undefined
+        : { inputPer1K: BLENDED_INPUT_COST_PER_1K, outputPer1K: BLENDED_OUTPUT_COST_PER_1K });
+    if (!pricing) {
+        return undefined;
+    }
     return (inputTokens / 1000) * pricing.inputPer1K + (outputTokens / 1000) * pricing.outputPer1K;
 }
-function estimateUsage(promptText, model) {
+function estimateUsage(promptText, model, providerCommand) {
     const inputTokens = Math.ceil(promptText.length / 3.5);
     const outputTokens = 2_000;
+    const estimatedUsd = estimatePromptCost(promptText, model, providerCommand);
     return normalizeUsage({
-        actualUsd: estimatePromptCost(promptText, model),
-        estimatedUsd: estimatePromptCost(promptText, model),
+        actualUsd: estimatedUsd ?? 0,
+        ...(estimatedUsd === undefined ? {} : { estimatedUsd }),
         tokensIn: inputTokens,
         tokensOut: outputTokens,
-        provenance: "estimated"
+        provenance: estimatedUsd === undefined ? "unavailable" : "estimated"
     });
 }
 function redactSecretsForPrompt(input) {

package/dist/vendor/adapters/codex-launcher.js

@@ -357,6 +357,10 @@ function discoverCommandOffPath(command, platform, env) {
         const localAppData = env.LOCALAPPDATA;
         if (localAppData)
             dirs.push(join(localAppData, "OpenAI", "Codex", "bin"));
+        // Claude Code native installer places binary at %USERPROFILE%\.local\bin
+        const userProfile = env.USERPROFILE ?? env.HOMEPATH;
+        if (userProfile)
+            dirs.push(join(userProfile, ".local", "bin"));
         if (home)
             dirs.push(join(home, "scoop", "shims"));
     }
@@ -383,8 +387,13 @@ function discoverCommandOffPath(command, platform, env) {
     return undefined;
 }
 function suggestInstall(command) {
+    if (command === "claude") {
+        const installCmd = process.platform === "win32"
+            ? "irm https://claude.ai/install.ps1 | iex"
+            : "curl -fsSL https://claude.ai/install.sh | bash";
+        return `Install with: ${installCmd}`;
+    }
     const installs = {
-        claude: "Install with: npm install -g @anthropic-ai/claude-code",
         codex: "Install with: npm install -g @openai/codex",
         gemini: "Install with: npm install -g @google/gemini-cli"
     };

package/dist/vendor/adapters/contracts/src/context-graph.d.ts

@@ -0,0 +1,48 @@
+export type ContextGraphNodeKind = "source_file" | "document" | "manifest" | "script" | "config";
+export type ContextGraphEdgeKind = "imports" | "documents";
+export interface ContextGraphNode {
+    nodeId: string;
+    path: string;
+    kind: ContextGraphNodeKind;
+    language?: string;
+    sizeBytes: number;
+    headings: string[];
+    symbols: string[];
+    keywords: string[];
+    imports: string[];
+}
+export interface ContextGraphEdge {
+    fromNodeId: string;
+    toNodeId: string;
+    kind: ContextGraphEdgeKind;
+}
+export interface ContextGraphSnapshot {
+    schemaVersion: "martin.context-graph.v1";
+    repoRoot: string;
+    createdAt: string;
+    nodeCount: number;
+    edgeCount: number;
+    truncated: boolean;
+    nodes: ContextGraphNode[];
+    edges: ContextGraphEdge[];
+}
+export interface ContextQuery {
+    text?: string;
+    terms?: string[];
+    pathPrefix?: string;
+    kinds?: ContextGraphNodeKind[];
+    limit?: number;
+}
+export interface ContextGraphBuildOptions {
+    maxFiles?: number;
+    maxFileBytes?: number;
+}
+export interface ContextGraphHit {
+    nodeId: string;
+    path: string;
+    kind: ContextGraphNodeKind;
+    score: number;
+    matchedTerms: string[];
+    reasons: string[];
+}
+export declare function cloneContextGraphSnapshot(snapshot: ContextGraphSnapshot): ContextGraphSnapshot;

package/dist/vendor/adapters/contracts/src/context-graph.js

@@ -0,0 +1,26 @@
+export function cloneContextGraphSnapshot(snapshot) {
+    return {
+        schemaVersion: snapshot.schemaVersion,
+        repoRoot: snapshot.repoRoot,
+        createdAt: snapshot.createdAt,
+        nodeCount: snapshot.nodeCount,
+        edgeCount: snapshot.edgeCount,
+        truncated: snapshot.truncated,
+        nodes: snapshot.nodes.map((node) => ({
+            nodeId: node.nodeId,
+            path: node.path,
+            kind: node.kind,
+            ...(node.language ? { language: node.language } : {}),
+            sizeBytes: node.sizeBytes,
+            headings: [...node.headings],
+            symbols: [...node.symbols],
+            keywords: [...node.keywords],
+            imports: [...node.imports]
+        })),
+        edges: snapshot.edges.map((edge) => ({
+            fromNodeId: edge.fromNodeId,
+            toNodeId: edge.toNodeId,
+            kind: edge.kind
+        }))
+    };
+}

package/dist/vendor/adapters/contracts/src/execution-policy.d.ts

@@ -0,0 +1,78 @@
+import type { ApprovalPolicy, LoopBudget, LoopTask, MutationMode } from "./index.js";
+import type { DestructiveActionPolicy, PolicyProfile, TelemetryDestination } from "./governance.js";
+export interface ExecutionPolicy {
+    configPath: string;
+    budget: LoopBudget;
+    governance: {
+        policyProfile: PolicyProfile;
+        telemetryDestination: TelemetryDestination;
+        destructiveActionPolicy: DestructiveActionPolicy;
+    };
+    task: {
+        verificationPlan: string[];
+        mutationMode?: MutationMode;
+        repoRoot?: string;
+        allowedPaths?: string[];
+        deniedPaths?: string[];
+        acceptanceCriteria?: string[];
+        approvalPolicy?: ApprovalPolicy;
+    };
+    provenance: ExecutionPolicyProvenanceEntry[];
+}
+export interface ExecutionPolicyProvenanceEntry {
+    field: string;
+    source: "default" | "config" | "request";
+    value: string;
+}
+export interface ExecutionPolicyDefaults {
+    budget: LoopBudget;
+    policyProfile: PolicyProfile;
+    telemetryDestination: TelemetryDestination;
+    destructiveActionPolicy: DestructiveActionPolicy;
+    verifierRules: string[];
+}
+export interface ExecutionPolicyConfigInput {
+    policyProfile?: string;
+    budget?: Partial<LoopBudget>;
+    governance?: {
+        destructiveActionPolicy?: string;
+        telemetryDestination?: string;
+        verifierRules?: string[];
+    };
+}
+export interface ExecutionPolicyRequestInput {
+    budget: LoopBudget;
+    budgetOverrides?: Partial<Record<keyof LoopBudget, true>>;
+    policyProfile?: string;
+    telemetryDestination?: string;
+    verificationPlan?: string[];
+    mutationMode?: LoopTask["mutationMode"];
+    repoRoot?: string;
+    allowedPaths?: string[];
+    deniedPaths?: string[];
+    acceptanceCriteria?: string[];
+    approvalPolicy?: ApprovalPolicy;
+}
+export interface ExecutionPolicyCompileInput {
+    configPath: string;
+    defaults: ExecutionPolicyDefaults;
+    config?: ExecutionPolicyConfigInput;
+    request: ExecutionPolicyRequestInput;
+}
+export type RoutingMode = "direct" | "manager" | "adaptive" | "consensus";
+export interface RoutingPolicy {
+    enabled: boolean;
+    mode: RoutingMode;
+    /** Max percentage of total budget that can be spent before first code change. */
+    maxPreworkBudgetPct: number;
+    /** Hard dollar cap on pre-work spend. */
+    maxPreworkCostUsd: number;
+    /** Max model calls allowed for manager/router/planner before worker starts. */
+    maxManagerCalls: number;
+    /** Skip orchestration entirely if task confidence is above this threshold (0-1). */
+    skipOrchestrationIfConfidenceAbove: number;
+    /** Force direct execution for tasks classified as simple. */
+    requireDirectForSimpleTasks: boolean;
+}
+export declare const DEFAULT_ROUTING_POLICY: RoutingPolicy;
+export declare function cloneExecutionPolicy(policy: ExecutionPolicy): ExecutionPolicy;

package/dist/vendor/adapters/contracts/src/execution-policy.js

@@ -0,0 +1,43 @@
+export const DEFAULT_ROUTING_POLICY = {
+    enabled: true,
+    mode: "adaptive",
+    maxPreworkBudgetPct: 25,
+    maxPreworkCostUsd: 2.0,
+    maxManagerCalls: 2,
+    skipOrchestrationIfConfidenceAbove: 0.85,
+    requireDirectForSimpleTasks: true
+};
+export function cloneExecutionPolicy(policy) {
+    return {
+        configPath: policy.configPath,
+        budget: {
+            maxUsd: policy.budget.maxUsd,
+            softLimitUsd: policy.budget.softLimitUsd,
+            maxIterations: policy.budget.maxIterations,
+            maxTokens: policy.budget.maxTokens
+        },
+        governance: {
+            policyProfile: policy.governance.policyProfile,
+            telemetryDestination: policy.governance.telemetryDestination,
+            destructiveActionPolicy: policy.governance.destructiveActionPolicy
+        },
+        task: {
+            verificationPlan: [...policy.task.verificationPlan],
+            ...(policy.task.mutationMode ? { mutationMode: policy.task.mutationMode } : {}),
+            ...(policy.task.repoRoot ? { repoRoot: policy.task.repoRoot } : {}),
+            ...(policy.task.allowedPaths ? { allowedPaths: [...policy.task.allowedPaths] } : {}),
+            ...(policy.task.deniedPaths ? { deniedPaths: [...policy.task.deniedPaths] } : {}),
+            ...(policy.task.acceptanceCriteria
+                ? { acceptanceCriteria: [...policy.task.acceptanceCriteria] }
+                : {}),
+            ...(policy.task.approvalPolicy
+                ? {
+                    approvalPolicy: {
+                        ...policy.task.approvalPolicy
+                    }
+                }
+                : {})
+        },
+        provenance: policy.provenance.map((entry) => ({ ...entry }))
+    };
+}

package/dist/vendor/adapters/contracts/src/governance.d.ts

@@ -0,0 +1,24 @@
+export type PolicyProfile = "strict" | "balanced" | "overnight" | "debug";
+export type DestructiveActionPolicy = "never" | "approval" | "allowed";
+export type TelemetryDestination = "local-only" | "control-plane";
+export type GovernanceSnapshot = {
+    policyProfile: PolicyProfile;
+    maxUsd: number;
+    softLimitUsd: number;
+    maxTokens: number;
+    maxIterations: number;
+    allowedAdapters: string[];
+    allowedModels: string[];
+    destructiveActionPolicy: DestructiveActionPolicy;
+    approvalRequired: boolean;
+    verifierRules: string[];
+    escalationRoute: string;
+    telemetryDestination: TelemetryDestination;
+    retentionPolicy: string;
+    provenance: Array<{
+        field: string;
+        value: string;
+        source: string;
+    }>;
+};
+export declare function createGovernanceSnapshot(snapshot: GovernanceSnapshot): GovernanceSnapshot;

package/dist/vendor/adapters/contracts/src/governance.js

@@ -0,0 +1,11 @@
+export function createGovernanceSnapshot(snapshot) {
+    return {
+        ...snapshot,
+        allowedAdapters: [...snapshot.allowedAdapters],
+        allowedModels: [...snapshot.allowedModels],
+        verifierRules: [...snapshot.verifierRules],
+        provenance: snapshot.provenance.map((entry) => ({
+            ...entry
+        }))
+    };
+}