@martinloop/mcp 0.3.2 → 0.3.4

package/dist/vendor/core/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/package.json

@@ -1,75 +1,76 @@
-{
-  "name": "@martinloop/mcp",
-  "version": "0.3.2",
-  "mcpName": "io.github.Keesan12/martin-loop",
-  "private": false,
-  "type": "module",
-  "description": "Governed MCP server for AI coding agents with budgets, verifier gates, and inspectable runs.",
-  "license": "Apache-2.0",
-  "author": "MartinLoop contributors",
-  "homepage": "https://martinloop.com/",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Keesan12/martin-loop.git",
-    "directory": "packages/mcp"
-  },
-  "bugs": {
-    "url": "https://github.com/Keesan12/martin-loop/issues"
-  },
-  "keywords": [
-    "mcp",
-    "model-context-protocol",
-    "martin-loop",
-    "ai-agent",
-    "claude",
-    "codex",
-    "martin_doctor",
-    "martin_triage_runs",
-    "martin_run_dossier",
-    "mcp-resources",
-    "mcp-prompts"
-  ],
-  "bin": {
-    "mcp": "./dist/server.js",
-    "martin-loop-mcp": "./dist/server.js"
-  },
-  "exports": {
-    "./server.json": "./server.json",
-    "./package.json": "./package.json"
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "server.json"
-  ],
-  "engines": {
-    "node": ">=20.0.0"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "build": "node ./scripts/build-package.mjs",
-    "prepack": "pnpm build",
-    "smoke:pack": "node ./scripts/smoke-package.mjs",
-    "smoke:published": "node ./scripts/smoke-published-package.mjs",
-    "smoke:published:pack": "node ./scripts/smoke-published-package.mjs --package-spec=pack",
-    "verify:release": "node --test ../../scripts/tests/publish-mcp-workflow.test.mjs ../../scripts/tests/mcp-publish-reliability.test.mjs ../../scripts/tests/mcp-release-docs.test.mjs",
-    "test": "vitest run --maxWorkers=1",
-    "lint": "tsc -p tsconfig.json --noEmit",
-    "start": "node dist/server.js",
-    "inspect:live": "node ./scripts/inspect-live.mjs"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "@open-policy-agent/opa-wasm": "^1.10.0",
-    "@opentelemetry/api-logs": "^0.214.0",
-    "@opentelemetry/exporter-logs-otlp-http": "^0.214.0",
-    "@opentelemetry/resources": "^2.6.1",
-    "@opentelemetry/sdk-logs": "^0.214.0",
-    "ts-morph": "^21.0.0"
-  },
-  "devDependencies": {
-    "@martin/contracts": "workspace:*"
-  }
-}
+{
+  "name": "@martinloop/mcp",
+  "version": "0.3.4",
+  "mcpName": "io.github.Keesan12/martin-loop",
+  "private": false,
+  "type": "module",
+  "description": "Governed MCP server for AI coding agents with budgets, verifier gates, and inspectable runs.",
+  "license": "Apache-2.0",
+  "author": "MartinLoop contributors",
+  "homepage": "https://martinloop.com/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Keesan12/martin-loop.git",
+    "directory": "packages/mcp"
+  },
+  "bugs": {
+    "url": "https://github.com/Keesan12/martin-loop/issues"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "martin-loop",
+    "ai-agent",
+    "claude",
+    "codex",
+    "martin_doctor",
+    "martin_triage_runs",
+    "martin_run_dossier",
+    "mcp-resources",
+    "mcp-prompts"
+  ],
+  "bin": {
+    "mcp": "./dist/server.js",
+    "martin-loop-mcp": "./dist/server.js"
+  },
+  "exports": {
+    "./server.json": "./server.json",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "server.json"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "node ./scripts/build-package.mjs",
+    "prepack": "pnpm build",
+    "smoke:pack": "node ./scripts/smoke-package.mjs",
+    "smoke:published": "node ./scripts/smoke-published-package.mjs",
+    "smoke:published:pack": "node ./scripts/smoke-published-package.mjs --package-spec=pack",
+    "verify:release": "node --test ../../scripts/tests/publish-mcp-workflow.test.mjs ../../scripts/tests/mcp-publish-reliability.test.mjs ../../scripts/tests/mcp-release-docs.test.mjs",
+    "test:baseline": "node ./scripts/run-test-lane.mjs baseline",
+    "test": "vitest run --maxWorkers=1",
+    "lint": "tsc -p tsconfig.json --noEmit",
+    "start": "node dist/server.js",
+    "inspect:live": "node ./scripts/inspect-live.mjs"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@open-policy-agent/opa-wasm": "^1.10.0",
+    "@opentelemetry/api-logs": "^0.214.0",
+    "@opentelemetry/exporter-logs-otlp-http": "^0.214.0",
+    "@opentelemetry/resources": "^2.6.1",
+    "@opentelemetry/sdk-logs": "^0.214.0",
+    "ts-morph": "^21.0.0"
+  },
+  "devDependencies": {
+    "@martin/contracts": "workspace:*"
+  }
+}

package/server.json

@@ -1,21 +1,21 @@
-{
-  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
-  "name": "io.github.Keesan12/martin-loop",
-  "title": "Martin Loop",
-  "description": "Governed MCP server for AI coding agents with budgets, verifier gates, and inspectable runs.",
-  "repository": {
-    "url": "https://github.com/Keesan12/martin-loop",
-    "source": "github"
-  },
-  "version": "0.3.2",
-  "packages": [
-    {
-      "registryType": "npm",
-      "identifier": "@martinloop/mcp",
-      "version": "0.3.2",
-      "transport": {
-        "type": "stdio"
-      }
-    }
-  ]
-}
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.Keesan12/martin-loop",
+  "title": "Martin Loop",
+  "description": "Governed MCP server for AI coding agents with budgets, verifier gates, and inspectable runs.",
+  "repository": {
+    "url": "https://github.com/Keesan12/martin-loop",
+    "source": "github"
+  },
+  "version": "0.3.4",
+  "packages": [
+    {
+      "registryType": "npm",
+      "identifier": "@martinloop/mcp",
+      "version": "0.3.4",
+      "transport": {
+        "type": "stdio"
+      }
+    }
+  ]
+}