@martinloop/mcp 0.3.6 → 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

@@ -72,12 +72,12 @@ function estimateCost(model, inputChars, outputChars) {
 // ---------------------------------------------------------------------------
 // Prompt builder
 // ---------------------------------------------------------------------------
-const DEFAULT_SYSTEM_PROMPT = `You are an expert software engineer executing a governed coding task.
-Follow these rules exactly:
-- Read the task description carefully and implement only what is asked.
-- Do not add features, refactors, or improvements beyond the stated task.
-- If the task asks you to write or modify code, output the complete file content with changes applied.
-- Be precise, minimal, and test-backed in all changes.
+const DEFAULT_SYSTEM_PROMPT = `You are an expert software engineer executing a governed coding task.
+Follow these rules exactly:
+- Read the task description carefully and implement only what is asked.
+- Do not add features, refactors, or improvements beyond the stated task.
+- If the task asks you to write or modify code, output the complete file content with changes applied.
+- Be precise, minimal, and test-backed in all changes.
 - State what you changed and why at the end of your response.`;
 export const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com";
 export const DEFAULT_OPENAI_MODEL = "gpt-4.1-mini";

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

@@ -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/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.js

@@ -186,7 +186,6 @@ export async function runMartin(input) {
     let currentAdapterIndex = 0;
     let currentAdapter = adapterChain[currentAdapterIndex] ?? input.adapter;
     let useCompressedContext = false;
-    const isVerifyOnly = input.task.mutationMode === "verify_only";
     const executionProfile = resolveExecutionProfile({
         executionProfile: input.task.executionProfile,
         allowedNetworkDomains: input.task.allowedNetworkDomains
@@ -684,93 +683,7 @@ export async function runMartin(input) {
         // a git repo) and silently return [], which would falsely trigger no_code_change.
         const changedFileEvidenceAvailable = result.execution?.changedFiles !== undefined || changedFiles.length > 0;
         const isVerifierOnlyAdapter = executingAdapter.adapterId === "direct:verifier:verify-only";
-        const patchTruthCountsEdits = !isVerifyOnly && !isVerifierOnlyAdapter && changedFileEvidenceAvailable;
-        if (isVerifyOnly && changedFiles.length > 0) {
-            const patchDecision = evaluatePatchDecision({
-                verificationPassed: verification.passed,
-                previousVerifierScore,
-                verifierScore: verification.passed ? 1 : 0,
-                scopeViolationCount: changedFiles.length,
-                changedFileCount: changedFiles.length,
-                diffNovelty: 1,
-                diffStats: result.execution?.diffStats,
-                costUsd: getUsageUsd(result.usage),
-                summary: result.summary
-            });
-            const verifyOnlyExitDecision = {
-                shouldExit: true,
-                lifecycleState: "human_escalation",
-                status: "exited",
-                reason: "Verify-only mode forbids file changes.",
-                failureClass: "safety_leash_blocked",
-                safetySurface: "filesystem",
-                reasonCode: "verify_only_write_attempt"
-            };
-            const rollbackOutcome = await restoreRollbackBoundary({
-                repoRoot: request.context.repoRoot,
-                boundary: rollbackBoundary,
-                restoredAt: attemptCompletedAt,
-                decision: patchDecision.decision
-            });
-            if (input.store) {
-                const verifyOnlyViolation = {
-                    kind: "path_not_allowed",
-                    message: `Verify-only mode forbids changed files: ${changedFiles.join(", ")}`,
-                    file: changedFiles[0]
-                };
-                await input.store.writeAttemptArtifacts(loop.loopId, currentAttemptIndex, {
-                    compiledContext,
-                    leash: createLeashArtifact({
-                        surface: "filesystem",
-                        reason: verifyOnlyExitDecision.reason,
-                        violations: [verifyOnlyViolation]
-                    }, currentAttemptIndex),
-                    patchScore: patchDecision.score,
-                    patchDecision: toPatchDecisionArtifact(patchDecision),
-                    ...(rollbackBoundary ? { rollbackBoundary } : {}),
-                    ...(rollbackOutcome ? { rollbackOutcome } : {})
-                });
-                await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                    kind: "safety.violations_found",
-                    runId: loop.loopId,
-                    attemptIndex: currentAttemptIndex,
-                    payload: {
-                        surface: "filesystem",
-                        blocked: true,
-                        attemptIndex: currentAttemptIndex,
-                        violations: [
-                            {
-                                kind: "path_not_allowed",
-                                message: verifyOnlyExitDecision.reason,
-                                files: changedFiles
-                            }
-                        ]
-                    }
-                }));
-                await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                    kind: "attempt.discarded",
-                    runId: loop.loopId,
-                    attemptIndex: currentAttemptIndex,
-                    payload: {
-                        decision: patchDecision.decision,
-                        reason: patchDecision.summary,
-                        reasonCodes: patchDecision.reasonCodes,
-                        score: patchDecision.score.score
-                    }
-                }));
-                await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                    kind: "run.exited",
-                    runId: loop.loopId,
-                    payload: createRunExitPayload(verifyOnlyExitDecision)
-                }));
-            }
-            const finalizedLoop = finalizeLoop(loop, verifyOnlyExitDecision, now(), idFactory);
-            await persistLoopRecordIfSupported(input.store, finalizedLoop);
-            return {
-                loop: finalizedLoop,
-                decision: verifyOnlyExitDecision
-            };
-        }
+        const patchTruthCountsEdits = !isVerifierOnlyAdapter && changedFileEvidenceAvailable;
         const filesystemDecision = evaluateFilesystemLeash({
             repoRoot: request.context.repoRoot,
             changedFiles,

package/dist/vendor/core/rollback.js

@@ -29,12 +29,11 @@ export async function captureRollbackBoundary(input) {
     for (const filePath of snapshotPaths) {
         snapshots.push(await readRollbackSnapshot(input.repoRoot, filePath));
     }
+    const headRef = readGitScalar(input.repoRoot, ["rev-parse", "HEAD"]);
     return {
         strategy: "git_head_plus_snapshot",
         capturedAt: input.capturedAt,
-        ...(readGitScalar(input.repoRoot, ["rev-parse", "HEAD"])
-            ? { headRef: readGitScalar(input.repoRoot, ["rev-parse", "HEAD"]) }
-            : {}),
+        ...(headRef ? { headRef } : {}),
         trackedDirtyFiles: repoState.trackedDirtyFiles,
         untrackedFiles: repoState.untrackedFiles,
         snapshots

package/package.json

@@ -1,76 +1,76 @@
-{
-  "name": "@martinloop/mcp",
-  "version": "0.3.6",
-  "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:*"
-  }
-}
+{
+  "name": "@martinloop/mcp",
+  "version": "0.3.7",
+  "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:*"
+  }
+}