@martinloop/mcp 0.3.5 → 0.3.7

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

@@ -0,0 +1,295 @@
+import { cloneCircuitBreakDecision, cloneTrajectoryAssessment } from "../../../contracts/index.js";
+const STOP_WORDS = new Set([
+    "about",
+    "after",
+    "again",
+    "along",
+    "also",
+    "been",
+    "before",
+    "being",
+    "between",
+    "could",
+    "failed",
+    "failure",
+    "from",
+    "have",
+    "into",
+    "just",
+    "keep",
+    "made",
+    "make",
+    "need",
+    "only",
+    "over",
+    "same",
+    "should",
+    "still",
+    "than",
+    "that",
+    "their",
+    "them",
+    "then",
+    "there",
+    "these",
+    "they",
+    "this",
+    "those",
+    "touching",
+    "without",
+    "would"
+]);
+const STALL_FAILURE_CLASSES = new Set([
+    "logic_error",
+    "verification_failure",
+    "repo_grounding_failure",
+    "scope_creep",
+    "no_progress"
+]);
+export function assessTrajectory(input) {
+    const attempts = input.attempts.filter((attempt) => attempt.index > 0);
+    if (attempts.length === 0) {
+        return cloneTrajectoryAssessment({
+            status: "healthy",
+            confidence: "low",
+            summary: "No prior attempts exist, so Martin has no drift evidence yet.",
+            signals: []
+        });
+    }
+    const signals = [];
+    const recentAttempts = attempts.slice(-4);
+    const lastThree = recentAttempts.slice(-3);
+    const lastTwo = recentAttempts.slice(-2);
+    const oscillation = detectFailureOscillation(lastThree);
+    if (oscillation) {
+        signals.push(oscillation);
+    }
+    const repetition = detectAttemptRepetition(lastThree);
+    if (repetition) {
+        signals.push(repetition);
+    }
+    const verificationStall = detectVerificationStall(lastTwo);
+    if (verificationStall) {
+        signals.push(verificationStall);
+    }
+    const objectiveDrift = detectObjectiveDrift({
+        objective: input.objective,
+        verificationPlan: input.verificationPlan,
+        attempts: lastTwo
+    });
+    if (objectiveDrift) {
+        signals.push(objectiveDrift);
+    }
+    const status = deriveTrajectoryStatus(signals);
+    const confidence = deriveTrajectoryConfidence(signals);
+    const recommendedIntervention = deriveRecommendedIntervention(signals);
+    if (signals.length === 0) {
+        return cloneTrajectoryAssessment({
+            status: "healthy",
+            confidence: "medium",
+            summary: "Recent attempts stay aligned enough that Martin does not need a circuit break yet.",
+            signals: []
+        });
+    }
+    const summary = summarizeTrajectory(status, signals);
+    return cloneTrajectoryAssessment({
+        status,
+        confidence,
+        summary,
+        signals,
+        ...(recommendedIntervention ? { recommendedIntervention } : {})
+    });
+}
+export function decideCircuitBreak(input) {
+    const assessment = assessTrajectory(input);
+    const remainingIterations = input.remainingIterations ?? Number.POSITIVE_INFINITY;
+    const stopForHighSignal = assessment.signals.some((signal) => signal.severity === "high");
+    const stopForLateDrift = assessment.status === "drifting" &&
+        remainingIterations <= 1 &&
+        assessment.signals.some((signal) => signal.code === "objective_drift");
+    const stopForLateStall = assessment.status === "watch" &&
+        remainingIterations <= 1 &&
+        assessment.signals.some((signal) => signal.code === "verification_stall");
+    const shouldStop = stopForHighSignal || stopForLateDrift || stopForLateStall;
+    return cloneCircuitBreakDecision({
+        shouldStop,
+        reason: shouldStop
+            ? assessment.summary
+            : "Trajectory signals do not justify a hard circuit break yet.",
+        assessment,
+        ...(assessment.recommendedIntervention
+            ? { recommendedIntervention: assessment.recommendedIntervention }
+            : {})
+    });
+}
+function detectFailureOscillation(attempts) {
+    if (attempts.length < 3) {
+        return undefined;
+    }
+    const [first, second, third] = attempts;
+    if (!first?.failureClass ||
+        !second?.failureClass ||
+        !third?.failureClass ||
+        first.failureClass === second.failureClass ||
+        first.failureClass !== third.failureClass) {
+        return undefined;
+    }
+    return {
+        code: "failure_oscillation",
+        severity: "high",
+        summary: `Attempts ${first.index}, ${second.index}, and ${third.index} oscillate between failure classes instead of converging.`,
+        attemptIndexes: [first.index, second.index, third.index]
+    };
+}
+function detectAttemptRepetition(attempts) {
+    if (attempts.length < 3) {
+        return undefined;
+    }
+    const tokenSets = attempts.map((attempt) => toTokenSet(attempt.summary));
+    if (tokenSets.some((tokens) => tokens.size < 4)) {
+        return undefined;
+    }
+    const pairScores = [
+        jaccardSimilarity(tokenSets[0], tokenSets[1]),
+        jaccardSimilarity(tokenSets[1], tokenSets[2]),
+        jaccardSimilarity(tokenSets[0], tokenSets[2])
+    ];
+    if (pairScores.every((score) => score >= 0.55)) {
+        const matchedTerms = intersectSets(tokenSets[0], new Set(intersectSets(tokenSets[1], tokenSets[2])));
+        return {
+            code: "attempt_repetition",
+            severity: "high",
+            summary: `Attempts ${attempts.map((attempt) => attempt.index).join(", ")} are materially repetitive and are not exploring a new path.`,
+            attemptIndexes: attempts.map((attempt) => attempt.index),
+            ...(matchedTerms.length > 0 ? { matchedTerms: matchedTerms.slice(0, 6) } : {})
+        };
+    }
+    return undefined;
+}
+function detectVerificationStall(attempts) {
+    if (attempts.length < 2) {
+        return undefined;
+    }
+    const relevant = attempts.filter((attempt) => {
+        const failureClass = attempt.failureClass;
+        return failureClass !== undefined && STALL_FAILURE_CLASSES.has(failureClass);
+    });
+    if (relevant.length < 2) {
+        return undefined;
+    }
+    const tokenSets = relevant.map((attempt) => toTokenSet(attempt.summary));
+    const overlap = tokenSets
+        .slice(1)
+        .map((tokens, index) => jaccardSimilarity(tokenSets[index], tokens))
+        .reduce((highest, score) => Math.max(highest, score), 0);
+    if (overlap < 0.35) {
+        return undefined;
+    }
+    const latest = relevant.at(-1);
+    return {
+        code: "verification_stall",
+        severity: "medium",
+        summary: `Recent attempts keep landing on the same verifier-facing failure surface (${latest.failureClass}).`,
+        attemptIndexes: relevant.map((attempt) => attempt.index)
+    };
+}
+function detectObjectiveDrift(input) {
+    if (input.attempts.length < 2) {
+        return undefined;
+    }
+    const objectiveTerms = toTokenSet(`${input.objective} ${(input.verificationPlan ?? []).join(" ")}`);
+    if (objectiveTerms.size < 4) {
+        return undefined;
+    }
+    const summaryTerms = input.attempts.map((attempt) => toTokenSet(attempt.summary));
+    const overlaps = summaryTerms.map((terms) => jaccardSimilarity(terms, objectiveTerms));
+    if (overlaps.some((score) => score >= 0.18)) {
+        return undefined;
+    }
+    const sharedDriftTerms = intersectSets(summaryTerms[0], summaryTerms[1]);
+    if (sharedDriftTerms.length < 3) {
+        return undefined;
+    }
+    return {
+        code: "objective_drift",
+        severity: "medium",
+        summary: "Recent attempt summaries are converging on work that does not overlap with the original objective or verifier plan.",
+        attemptIndexes: input.attempts.map((attempt) => attempt.index),
+        matchedTerms: sharedDriftTerms.slice(0, 6)
+    };
+}
+function deriveTrajectoryStatus(signals) {
+    if (signals.some((signal) => signal.severity === "high")) {
+        return "stalled";
+    }
+    if (signals.some((signal) => signal.code === "objective_drift")) {
+        return "drifting";
+    }
+    if (signals.some((signal) => signal.severity === "medium")) {
+        return "watch";
+    }
+    return "healthy";
+}
+function deriveTrajectoryConfidence(signals) {
+    if (signals.some((signal) => signal.severity === "high")) {
+        return "high";
+    }
+    if (signals.some((signal) => signal.severity === "medium")) {
+        return "medium";
+    }
+    return "low";
+}
+function deriveRecommendedIntervention(signals) {
+    if (signals.some((signal) => signal.code === "failure_oscillation" || signal.code === "attempt_repetition")) {
+        return "escalate_human";
+    }
+    if (signals.some((signal) => signal.code === "objective_drift")) {
+        return "tighten_task";
+    }
+    if (signals.some((signal) => signal.code === "verification_stall")) {
+        return "run_verifier";
+    }
+    return undefined;
+}
+function summarizeTrajectory(status, signals) {
+    const lead = signals[0];
+    if (!lead) {
+        return "Trajectory is healthy.";
+    }
+    switch (status) {
+        case "stalled":
+            return `Trajectory stalled: ${lead.summary}`;
+        case "drifting":
+            return `Trajectory drift detected: ${lead.summary}`;
+        case "watch":
+            return `Trajectory warning: ${lead.summary}`;
+        default:
+            return lead.summary;
+    }
+}
+function toTokenSet(text) {
+    return new Set((text ?? "")
+        .toLowerCase()
+        .match(/[a-z][a-z0-9_/-]{2,}/g)
+        ?.flatMap((token) => splitCompositeToken(token))
+        .map((token) => token.trim())
+        .filter((token) => token.length >= 3 && !STOP_WORDS.has(token)) ?? []);
+}
+function splitCompositeToken(token) {
+    return token
+        .split(/[-_/]/g)
+        .flatMap((part) => part.split(/(?=[A-Z])/g))
+        .map((part) => part.toLowerCase())
+        .filter(Boolean);
+}
+function jaccardSimilarity(left, right) {
+    if (left.size === 0 || right.size === 0) {
+        return 0;
+    }
+    const intersection = intersectSets(left, right).length;
+    const union = new Set([...left, ...right]).size;
+    return union === 0 ? 0 : intersection / union;
+}
+function intersectSets(left, right) {
+    return [...left].filter((term) => right.has(term));
+}

package/dist/vendor/adapters/openai-compatible.js

@@ -166,70 +166,103 @@ export function createOpenAiCompatibleAdapter(options) {
                     failure: { message: "budget_preflight_exceeded", classHint: "budget_pressure" }
                 };
             }
-            // Call the OpenAI-compatible endpoint
+            // Call the OpenAI-compatible endpoint with exponential-backoff retry on
+            // transient failures (429 rate-limit, 503/5xx server errors, network errors).
+            // Auth errors (401/403) and bad-request errors (400) are not retried — they
+            // indicate a permanent configuration problem.
+            const MAX_RETRIES = 3;
+            const RETRYABLE_STATUS = new Set([429, 500, 502, 503, 504]);
             const endpoint = `${baseUrl}/v1/chat/completions`;
             let responseText = "";
             let tokensIn = estimated.tokensIn;
             let tokensOut = 0;
-            const controller = new AbortController();
-            const timer = setTimeout(() => controller.abort(), timeoutMs);
-            try {
-                const headers = { "Content-Type": "application/json" };
-                if (apiKey)
-                    headers["Authorization"] = `Bearer ${apiKey}`;
-                // OpenRouter requires a site URL header for attribution
-                if (baseUrl.includes("openrouter")) {
-                    headers["HTTP-Referer"] = "https://martinloop.com";
-                    headers["X-Title"] = "MartinLoop";
-                }
-                const res = await fetchFn(endpoint, {
-                    method: "POST",
-                    headers,
-                    body: JSON.stringify({
-                        model,
-                        messages: [
-                            { role: "system", content: systemPrompt },
-                            { role: "user", content: prompt }
-                        ],
-                        temperature: 0.2,
-                        max_tokens: 8192
-                    }),
-                    signal: controller.signal
-                });
-                const body = (await res.json());
-                if (!res.ok || body.error) {
-                    const errMsg = body.error?.message ?? `HTTP ${res.status}`;
-                    return {
-                        status: "failed",
-                        summary: `${model} API error: ${errMsg}`,
-                        usage: normalizeUsage({ actualUsd: 0, tokensIn: 0, tokensOut: 0, provenance: "unavailable" }),
-                        verification: { passed: false, summary: "API call failed before verifier." },
-                        failure: { message: errMsg, classHint: "infrastructure_error" }
-                    };
+            const headers = { "Content-Type": "application/json" };
+            if (apiKey)
+                headers["Authorization"] = `Bearer ${apiKey}`;
+            if (baseUrl.includes("openrouter")) {
+                headers["HTTP-Referer"] = "https://martinloop.com";
+                headers["X-Title"] = "MartinLoop";
+            }
+            const requestBody = JSON.stringify({
+                model,
+                messages: [
+                    { role: "system", content: systemPrompt },
+                    { role: "user", content: prompt }
+                ],
+                temperature: 0.2,
+                max_tokens: 8192
+            });
+            let lastError = "";
+            let succeeded = false;
+            for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+                const controller = new AbortController();
+                const timer = setTimeout(() => controller.abort(), timeoutMs);
+                try {
+                    const res = await fetchFn(endpoint, {
+                        method: "POST",
+                        headers,
+                        body: requestBody,
+                        signal: controller.signal
+                    });
+                    const body = (await res.json());
+                    if (!res.ok || body.error) {
+                        const errMsg = body.error?.message ?? `HTTP ${res.status}`;
+                        if (RETRYABLE_STATUS.has(res.status) && attempt < MAX_RETRIES - 1) {
+                            lastError = errMsg;
+                            // Exponential backoff: 1s, 2s, 4s
+                            await new Promise((resolve) => setTimeout(resolve, 1000 * Math.pow(2, attempt)));
+                            continue;
+                        }
+                        return {
+                            status: "failed",
+                            summary: `${model} API error: ${errMsg}`,
+                            usage: normalizeUsage({ actualUsd: 0, tokensIn: 0, tokensOut: 0, provenance: "unavailable" }),
+                            verification: { passed: false, summary: "API call failed before verifier." },
+                            failure: { message: errMsg, classHint: "infrastructure_error" }
+                        };
+                    }
+                    responseText = body.choices?.[0]?.message?.content ?? "";
+                    if (body.usage) {
+                        tokensIn = body.usage.prompt_tokens ?? tokensIn;
+                        tokensOut = body.usage.completion_tokens ?? 0;
+                    }
+                    else {
+                        tokensOut = Math.ceil(responseText.length / CHARS_PER_TOKEN);
+                    }
+                    succeeded = true;
+                    break;
                 }
-                responseText = body.choices?.[0]?.message?.content ?? "";
-                if (body.usage) {
-                    tokensIn = body.usage.prompt_tokens ?? tokensIn;
-                    tokensOut = body.usage.completion_tokens ?? 0;
+                catch (error) {
+                    const isAbort = error instanceof Error && error.name === "AbortError";
+                    if (isAbort || attempt === MAX_RETRIES - 1) {
+                        const message = isAbort
+                            ? `${model} request timed out after ${timeoutMs}ms`
+                            : String(error);
+                        return {
+                            status: "failed",
+                            summary: message,
+                            usage: normalizeUsage({ actualUsd: 0, tokensIn: 0, tokensOut: 0, provenance: "unavailable" }),
+                            verification: { passed: false, summary: isAbort ? "Request timed out." : "Network error." },
+                            failure: { message, classHint: "infrastructure_error" }
+                        };
+                    }
+                    // Transient network error — retry with backoff
+                    lastError = String(error);
+                    await new Promise((resolve) => setTimeout(resolve, 1000 * Math.pow(2, attempt)));
                 }
-                else {
-                    tokensOut = Math.ceil(responseText.length / CHARS_PER_TOKEN);
+                finally {
+                    clearTimeout(timer);
                 }
             }
-            catch (error) {
-                const isAbort = error instanceof Error && error.name === "AbortError";
-                const message = isAbort ? `${model} request timed out after ${timeoutMs}ms` : String(error);
+            if (!succeeded) {
                 return {
                     status: "failed",
-                    summary: message,
+                    summary: `${model} API error after ${MAX_RETRIES} attempts: ${lastError}`,
                     usage: normalizeUsage({ actualUsd: 0, tokensIn: 0, tokensOut: 0, provenance: "unavailable" }),
-                    verification: { passed: false, summary: isAbort ? "Request timed out." : "Network error." },
-                    failure: { message, classHint: "infrastructure_error" }
+                    verification: { passed: false, summary: "API call failed after retries." },
+                    failure: { message: lastError, classHint: "infrastructure_error" }
                 };
             }
-            finally {
-                clearTimeout(timer);
-            }
             if (!responseText.trim()) {
                 return {
                     status: "failed",

package/dist/vendor/adapters/verifier-only.js

@@ -20,11 +20,11 @@ export function createVerifierOnlyAdapter(options = {}) {
             const shouldTrackVerifierWrites = request.context.verificationPlan.length > 0 ||
                 (request.context.verificationStack?.length ?? 0) > 0;
             const baselineChangedFiles = shouldTrackVerifierWrites
-                ? new Set(await readGitChangedFiles(workingDirectory, 5_000))
+                ? new Set(await readGitChangedFiles(workingDirectory, 5_000, options.spawnImpl))
                 : new Set();
             const verification = await runVerification(request.context.verificationPlan, workingDirectory, verifyTimeoutMs, request.context.verificationStack, options.spawnImpl);
             const changedFiles = shouldTrackVerifierWrites
-                ? (await readGitChangedFiles(workingDirectory, 5_000)).filter((file) => !baselineChangedFiles.has(file))
+                ? (await readGitChangedFiles(workingDirectory, 5_000, options.spawnImpl)).filter((file) => !baselineChangedFiles.has(file))
                 : [];
             const execution = { changedFiles };
             if (verification.passed) {

package/dist/vendor/contracts/index.d.ts

@@ -1,6 +1,6 @@
 export type LoopStatus = "queued" | "running" | "verifying" | "completed" | "failed" | "exited";
 export type LoopLifecycleState = "created" | "running" | "verifying" | "completed" | "budget_exit" | "diminishing_returns" | "stuck_exit" | "human_escalation";
-export declare const FAILURE_CLASSES: readonly ["logic_error", "hallucination", "syntax_error", "type_error", "test_regression", "scope_creep", "no_progress", "repo_grounding_failure", "verification_failure", "environment_mismatch", "budget_pressure", "safety_leash_blocked"];
+export declare const FAILURE_CLASSES: readonly ["logic_error", "hallucination", "syntax_error", "type_error", "test_regression", "scope_creep", "no_progress", "repo_grounding_failure", "verification_failure", "environment_mismatch", "budget_pressure", "safety_leash_blocked", "sandbox_write_blocked"];
 export type FailureClass = (typeof FAILURE_CLASSES)[number];
 export type InterventionType = "compress_context" | "change_model" | "tighten_task" | "switch_adapter" | "run_verifier" | "escalate_human" | "stop_loop";
 export type LoopEventType = "run.started" | "attempt.started" | "attempt.completed" | "failure.classified" | "intervention.selected" | "verification.completed" | "budget.updated" | "run.completed";
@@ -23,7 +23,7 @@ export interface LoopTask {
     acceptanceCriteria?: string[];
 }
 export type ExecutionProfile = "strict_local" | "ci_safe" | "staging_controlled" | "research_untrusted";
-export type MutationMode = "edit" | "verify_only";
+export type MutationMode = "edit";
 export interface ApprovalPolicy {
     dependencyAdds?: boolean;
     migrations?: boolean;

package/dist/vendor/contracts/index.js

@@ -11,6 +11,7 @@ export const FAILURE_CLASSES = [
     "environment_mismatch",
     "budget_pressure",
     "safety_leash_blocked",
+    "sandbox_write_blocked",
 ];
 export { MARTIN_ERROR_CATEGORIES } from "./operator.js";
 export const DEFAULT_BUDGET = {

package/dist/vendor/core/compiler.js

@@ -8,15 +8,10 @@ export function compilePromptPacket(request) {
     const priorFailurePatterns = request.previousAttempts
         .filter((a) => a.failureClass && a.intervention)
         .map((a) => `${a.failureClass}:${a.intervention}`);
-    const guidanceParts = request.context.mutationMode === "verify_only"
-        ? [
-            "Do not modify files.",
-            "Run the verifier only and report whether it passed."
-        ]
-        : [
-            "Only modify files directly required to satisfy the contract.",
-            "Do not touch files outside the allowed paths."
-        ];
+    const guidanceParts = [
+        "Only modify files directly required to satisfy the contract.",
+        "Do not touch files outside the allowed paths."
+    ];
     if (request.context.allowedPaths && request.context.allowedPaths.length > 0) {
         guidanceParts.push(`Allowed paths: ${request.context.allowedPaths.join(", ")}.`);
     }

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

@@ -14,8 +14,12 @@ export { createLocalIdentityAuthority, hasIdentityScope, issueIdentityToken, ver
 export type { LocalIdentityAuthority } from "./identity.js";
 export { compileExecutionPolicy } from "./policy-compiler.js";
 export { assessTrajectory, decideCircuitBreak } from "./trajectory.js";
-export { classifyRoute, evaluatePreworkBurnPolicy } from "./routing.js";
-export type { RouteDecision, RouteClassificationInput } from "./routing.js";
+export { classifyRoute, evaluatePreworkBurnPolicy, resolveModelForTier, selectBestEngine } from "./routing.js";
+export type { RouteDecision, RouteClassificationInput, AvailableEngine } from "./routing.js";
+export { validateTestIntegrity, snapshotTestFiles, identifyNewTests, findTestFiles, isTestFile, extractImports, hasTrivialAssertionsOnly, importsPreExistingCode } from "./test-integrity.js";
+export type { TestIntegrityReport, TestIntegrityFinding } from "./test-integrity.js";
+export { analyzeRepoStyle, buildPromptDirectives } from "./repo-analyzer.js";
+export type { RepoStyleProfile } from "./repo-analyzer.js";
 export { runContextIntegrityPrecheck } from "./context-integrity.js";
 export type { ContextIntegrityPrecheck, ContextIntegrityVerdict } from "./context-integrity.js";
 export { compilePromptPacket } from "./compiler.js";
@@ -24,6 +28,10 @@ export { createFileRunStore, makeLedgerEvent, readAllLoopRecords, readLatestLoop
 export type { AttemptArtifacts, LedgerEvent, LedgerEventKind, LoopAttemptRecord, LoopRunRecord, ReceiptIntegrityChainEntry, RunContract, RunStore, StoredReceiptIntegrityMaterial } from "./persistence/index.js";
 export { compileAndPersistContext } from "./persistence/index.js";
 export type { CompileResult } from "./persistence/index.js";
+export { appendMemory, readMemoryEntries, getPreference, buildMemorySummary, recordPreference, recordConsent } from "./persistence/memory-store.js";
+export type { MemoryEntry, MemoryKind, MemorySummary } from "./persistence/memory-store.js";
+export { appendTraceEntry, readTraceEntries, aggregateTraces, getHistoricalDirectSuccessRate } from "./persistence/trace-store.js";
+export type { TraceEntry, TraceAggregation } from "./persistence/trace-store.js";
 export interface MartinAdapterRequest {
     loopId: string;
     attemptId: string;