@martinloop/mcp 0.3.6 → 0.3.7

package/dist/vendor/adapters/claude-cli.d.ts

@@ -11,14 +11,14 @@
  *
  * MCP tools and integration tests use the same factories.
  */
-import type { MartinAdapter, MartinAdapterRequest } from "../core/index.js";
+import type { MartinAdapter } from "../core/index.js";
 import { type SpawnLike } from "./cli-bridge.js";
 /**
  * Given a prompt string, returns the full argv array to pass to spawn().
  * Example for Claude:  () => ["--output-format", "json", "--print"]
  * Example for Codex:   () => ["exec", "--sandbox", "workspace-write", "-"]
  */
-export type CliArgsBuilder = (prompt: string, request: MartinAdapterRequest) => string[];
+export type CliArgsBuilder = (prompt: string) => string[];
 export type CliStdinBuilder = (prompt: string) => string | undefined;
 export interface AgentCliAdapterOptions {
     /** The executable to spawn (e.g. "claude", "codex"). */

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

@@ -239,15 +239,13 @@ function extractGeminiJsonResult(stdout, modelLabel) {
         })
     };
 }
-function createStreamingUsageInspector(capUsd, modelLabel, promptTokenEstimate) {
+function createStreamingUsageInspector(capUsd, modelLabel) {
     const pricing = (modelLabel ? MODEL_PRICING[modelLabel] : undefined) ??
         { inputPer1K: BLENDED_INPUT_COST_PER_1K, outputPer1K: BLENDED_OUTPUT_COST_PER_1K };
     // 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).
-    const largeContext = promptTokenEstimate > 10_000;
-    const effectiveCapRatio = largeContext ? 0.7 : 0.8;
-    const effectiveCapUsd = capUsd * effectiveCapRatio;
+    const effectiveCapUsd = capUsd * 0.8;
     // 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.
@@ -271,7 +269,7 @@ function createStreamingUsageInspector(capUsd, modelLabel, promptTokenEstimate)
     const checkBudgetExceeded = (terminate) => {
         if (capUsd > 0 && cumulativeUsd > effectiveCapUsd) {
             terminate(`Streaming usage cap exceeded after ${String(turns)} turn(s): cumulative cost ~$${cumulativeUsd.toFixed(4)} ` +
-                `surpassed the per-attempt cap $${capUsd.toFixed(4)} (${String(Math.round(effectiveCapRatio * 100))}% threshold: $${effectiveCapUsd.toFixed(4)}). ` +
+                `surpassed the per-attempt cap $${capUsd.toFixed(4)} (80% threshold: $${effectiveCapUsd.toFixed(4)}). ` +
                 `Subprocess terminated to bound runaway overspend.`);
         }
     };
@@ -302,23 +300,11 @@ function createStreamingUsageInspector(capUsd, modelLabel, promptTokenEstimate)
         if (turnTokensIn === 0 && turnTokensOut === 0) {
             return;
         }
-        const turnUsd = (turnTokensIn / 1000) * pricing.inputPer1K + (turnTokensOut / 1000) * pricing.outputPer1K;
-        const remainingBudgetBeforeTurn = Math.max(capUsd - cumulativeUsd, 0);
-        if (capUsd > 0 && remainingBudgetBeforeTurn > 0 && turnUsd > remainingBudgetBeforeTurn * 0.5) {
-            cumulativeUsd += turnUsd;
-            tokensIn += turnTokensIn;
-            tokensOut += turnTokensOut;
-            turns += 1;
-            usageEventSeen = true;
-            terminate(`Single turn spend ~$${turnUsd.toFixed(4)} consumed more than 50% of the remaining per-attempt budget ` +
-                `($${remainingBudgetBeforeTurn.toFixed(4)} before the turn). Subprocess terminated to prevent a one-turn overshoot.`);
-            return;
-        }
         tokensIn += turnTokensIn;
         tokensOut += turnTokensOut;
         turns += 1;
         usageEventSeen = true;
-        cumulativeUsd += turnUsd;
+        cumulativeUsd += (turnTokensIn / 1000) * pricing.inputPer1K + (turnTokensOut / 1000) * pricing.outputPer1K;
         checkBudgetExceeded(terminate);
     };
     const ingestLine = (line, terminate) => {
@@ -477,7 +463,7 @@ export function createAgentCliAdapter(options) {
                     };
                 }
             }
-            const args = options.argsBuilder(prompt, request);
+            const args = options.argsBuilder(prompt);
             const stdinData = options.stdinBuilder?.(prompt);
             // Live cumulative-cost circuit breaker: a single attempt should never be
             // allowed to spend more than the loop has left. `--output-format json`
@@ -486,7 +472,7 @@ export function createAgentCliAdapter(options) {
             // instant projected spend crosses what remains — bounding the worst case
             // to roughly one turn's overshoot rather than the entire runaway session.
             const streamingUsage = options.streamingUsageCap && request.context.remainingBudgetUsd > 0
-                ? createStreamingUsageInspector(request.context.remainingBudgetUsd, options.model ?? options.command, estimatedUsage.tokensIn)
+                ? createStreamingUsageInspector(request.context.remainingBudgetUsd, options.model ?? options.command)
                 : undefined;
             const agentResult = await runSubprocess(options.command, args, {
                 cwd: workingDirectory,
@@ -536,10 +522,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 +538,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
                     }
                 };
@@ -804,18 +797,21 @@ export function createClaudeCliAdapter(options = {}) {
         supportsJsonOutput: true,
         streamingUsageCap: true,
         spawnImpl: options.spawnImpl,
-        argsBuilder: (_prompt, request) => [
+        argsBuilder: (_prompt) => [
             "--output-format",
             "stream-json",
             "--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 +911,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 +955,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):");

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
+        }))
+    };
+}

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

@@ -0,0 +1,29 @@
+export type IdentityAlgorithm = "ed25519";
+export type IdentityRole = "governor" | "verifier" | "worker" | "reviewer" | "observer";
+export interface IdentityClaims {
+    subject: string;
+    issuer: string;
+    role: IdentityRole;
+    scopes: string[];
+    issuedAt: string;
+    expiresAt?: string;
+    workspaceId?: string;
+    sessionId?: string;
+    metadata?: Record<string, string>;
+}
+export interface IdentityToken {
+    schemaVersion: "martin.identity.v1";
+    algorithm: IdentityAlgorithm;
+    keyId: string;
+    claims: IdentityClaims;
+    signature: string;
+}
+export interface IdentityAttestation {
+    valid: boolean;
+    verifiedAt: string;
+    reason: string;
+    token: IdentityToken;
+}
+export declare function cloneIdentityClaims(claims: IdentityClaims): IdentityClaims;
+export declare function cloneIdentityToken(token: IdentityToken): IdentityToken;
+export declare function cloneIdentityAttestation(attestation: IdentityAttestation): IdentityAttestation;

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

@@ -0,0 +1,30 @@
+export function cloneIdentityClaims(claims) {
+    return {
+        subject: claims.subject,
+        issuer: claims.issuer,
+        role: claims.role,
+        scopes: [...claims.scopes],
+        issuedAt: claims.issuedAt,
+        ...(claims.expiresAt ? { expiresAt: claims.expiresAt } : {}),
+        ...(claims.workspaceId ? { workspaceId: claims.workspaceId } : {}),
+        ...(claims.sessionId ? { sessionId: claims.sessionId } : {}),
+        ...(claims.metadata ? { metadata: { ...claims.metadata } } : {})
+    };
+}
+export function cloneIdentityToken(token) {
+    return {
+        schemaVersion: token.schemaVersion,
+        algorithm: token.algorithm,
+        keyId: token.keyId,
+        claims: cloneIdentityClaims(token.claims),
+        signature: token.signature
+    };
+}
+export function cloneIdentityAttestation(attestation) {
+    return {
+        valid: attestation.valid,
+        verifiedAt: attestation.verifiedAt,
+        reason: attestation.reason,
+        token: cloneIdentityToken(attestation.token)
+    };
+}