@martinloop/mcp 0.6.0 → 0.6.2

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const MARTIN_MCP_PACKAGE_VERSION = "0.6.0";
+export declare const MARTIN_MCP_PACKAGE_VERSION = "0.6.2";

package/dist/package-version.js

@@ -1,3 +1,3 @@
 // Auto-generated by build — do not edit by hand.
 // Source of truth: packages/mcp/package.json#version
-export const MARTIN_MCP_PACKAGE_VERSION = "0.6.0";
+export const MARTIN_MCP_PACKAGE_VERSION = "0.6.2";

package/dist/vendor/adapters/codex-capabilities.d.ts

@@ -55,6 +55,8 @@ export interface CodexExecArgsOptions {
     autonomyResolution?: CodexAutonomyResolution;
 }
 type SpawnSyncLike = typeof spawnSync;
+export declare function markCodexAutonomyResolutionVerifiedByLaunchProbe(resolution: CodexAutonomyResolution): CodexAutonomyResolution;
+export declare function isCodexAutonomyResolutionVerifiedByLaunchProbe(resolution: CodexAutonomyResolution): boolean;
 export declare function clearCodexCapabilityCacheForTests(): void;
 export declare function cacheCodexCapabilityProfile(profile: CodexCapabilityProfile, platform?: NodeJS.Platform): CodexCapabilityProfile;
 export declare function probeCodexCapabilities(binaryPath: string, options?: {

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

@@ -3,6 +3,14 @@ import { extname } from "node:path";
 import { createSpawnPlan, resolveNpmShimScript } from "./cli-bridge.js";
 import { DEFAULT_AGENT_EXECUTION_INTENT } from "../contracts/index.js";
 const capabilityCache = new Map();
+const launchProbeVerifiedAutonomyResolutions = new WeakSet();
+export function markCodexAutonomyResolutionVerifiedByLaunchProbe(resolution) {
+    launchProbeVerifiedAutonomyResolutions.add(resolution);
+    return resolution;
+}
+export function isCodexAutonomyResolutionVerifiedByLaunchProbe(resolution) {
+    return launchProbeVerifiedAutonomyResolutions.has(resolution);
+}
 function escapeRegex(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
@@ -197,6 +205,20 @@ export function codexWriteStrategies(profile) {
 }
 export function resolveCodexAutonomyCandidates(profile, intent = DEFAULT_AGENT_EXECUTION_INTENT) {
     const candidates = [];
+    // Prefer the least-privileged advertised workspace-write mode. The launch
+    // probe still has final authority: it must prove an in-workspace write and
+    // prove the paired outside-workspace marker was denied before this
+    // resolution can be selected for a governed run.
+    if (profile.sandbox?.values.includes("workspace-write")) {
+        candidates.push({
+            binaryPath: profile.binaryPath,
+            intent,
+            strategy: "sandbox+approval",
+            sandboxValue: "workspace-write"
+        });
+    }
+    // Keep provider automation as a compatibility fallback. It is never trusted
+    // merely because it is advertised; the same boundary probe must prove it.
     if (profile.automation) {
         candidates.push({
             binaryPath: profile.binaryPath,

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

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { createAgentCliAdapter } from "./claude-cli.js";
-import { buildCodexExecArgs, buildCodexStdin, probeCodexCapabilities } from "./codex-launcher.js";
+import { buildCodexExecArgs, buildCodexStdin, isCodexAutonomyResolutionVerifiedByLaunchProbe, probeCodexCapabilities } from "./codex-launcher.js";
 import { createSpawnPlan } from "./cli-bridge.js";
 function createCodexSpawnRouter(input) {
     if (input.injectedSpawn) {
@@ -33,6 +33,9 @@ export function createCodexCliAdapter(options = {}) {
     if (autonomyResolution && autonomyResolution.binaryPath !== selectedBinary) {
         throw new Error("Codex exact binary autonomy resolution mismatch.");
     }
+    if (autonomyResolution && !isCodexAutonomyResolutionVerifiedByLaunchProbe(autonomyResolution)) {
+        throw new Error("Codex autonomy resolution was not verified by the launch probe.");
+    }
     const sandbox = options.sandbox ?? "workspace-write";
     const extraArgs = options.extraArgs ?? [];
     const launchModel = options.model;

package/dist/vendor/adapters/codex-launcher.d.ts

@@ -1,4 +1,5 @@
 import { type CodexExecArgsOptions } from "./codex-capabilities.js";
+import { probeCodexLaunch as probeCodexLaunchHost, type CodexLaunchProbeResult } from "./codex-host.js";
 /**
  * Compatibility facade for callers that still populate the original
  * `approval` profile field. Internally automation modes and approval policies
@@ -6,5 +7,11 @@ import { type CodexExecArgsOptions } from "./codex-capabilities.js";
  * builder without restoring any hard-coded flag assumption.
  */
 export declare function buildCodexExecArgs(options: CodexExecArgsOptions): string[];
-export { buildCodexStdin, cacheCodexCapabilityProfile, clearCodexCapabilityCacheForTests, codexWriteStrategies, probeCodexCapabilities, resolveCodexAutonomyCandidates, type CodexAutonomyResolution, type CodexApprovalCapability, type CodexCapabilityFlag, type CodexCapabilityProfile, type CodexExecArgsOptions, type CodexFlagScope, type CodexPromptTransport, type CodexSandboxCapability, type CodexWriteStrategy } from "./codex-capabilities.js";
-export { checkCodexSandboxPreflight, detectCodexHostPlatform, diagnoseCodexHost, probeCodexLaunch, probeFilesystemWriteCapability, resolveCliCommandAvailability, type CliCommandAvailability, type CodexHostDiagnosis, type CodexHostPlatform, type CodexInstallKind, type CodexInvocationMode, type CodexLaunchProbeResult, type CodexProbeCandidateResult, type CodexSandboxPreflightOk, type CodexSandboxPreflightOutcome, type CodexSandboxPreflightReadOnly } from "./codex-host.js";
+/**
+ * Public launch-probe facade. Only a successful probe may brand an autonomy
+ * resolution as safe for adapter execution; structurally similar objects
+ * supplied directly by callers remain untrusted.
+ */
+export declare function probeCodexLaunch(input: Parameters<typeof probeCodexLaunchHost>[0]): CodexLaunchProbeResult;
+export { buildCodexStdin, cacheCodexCapabilityProfile, clearCodexCapabilityCacheForTests, codexWriteStrategies, isCodexAutonomyResolutionVerifiedByLaunchProbe, probeCodexCapabilities, resolveCodexAutonomyCandidates, type CodexAutonomyResolution, type CodexApprovalCapability, type CodexCapabilityFlag, type CodexCapabilityProfile, type CodexExecArgsOptions, type CodexFlagScope, type CodexPromptTransport, type CodexSandboxCapability, type CodexWriteStrategy } from "./codex-capabilities.js";
+export { checkCodexSandboxPreflight, detectCodexHostPlatform, diagnoseCodexHost, probeFilesystemWriteCapability, resolveCliCommandAvailability, type CliCommandAvailability, type CodexHostDiagnosis, type CodexHostPlatform, type CodexInstallKind, type CodexInvocationMode, type CodexLaunchProbeResult, type CodexProbeCandidateResult, type CodexSandboxPreflightOk, type CodexSandboxPreflightOutcome, type CodexSandboxPreflightReadOnly } from "./codex-host.js";

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

@@ -1,4 +1,5 @@
-import { buildCodexExecArgs as buildCapabilityDrivenCodexExecArgs } from "./codex-capabilities.js";
+import { buildCodexExecArgs as buildCapabilityDrivenCodexExecArgs, markCodexAutonomyResolutionVerifiedByLaunchProbe } from "./codex-capabilities.js";
+import { probeCodexLaunch as probeCodexLaunchHost } from "./codex-host.js";
 /**
  * Compatibility facade for callers that still populate the original
  * `approval` profile field. Internally automation modes and approval policies
@@ -18,5 +19,17 @@ export function buildCodexExecArgs(options) {
         capabilityProfile: normalizedProfile
     });
 }
-export { buildCodexStdin, cacheCodexCapabilityProfile, clearCodexCapabilityCacheForTests, codexWriteStrategies, probeCodexCapabilities, resolveCodexAutonomyCandidates } from "./codex-capabilities.js";
-export { checkCodexSandboxPreflight, detectCodexHostPlatform, diagnoseCodexHost, probeCodexLaunch, probeFilesystemWriteCapability, resolveCliCommandAvailability } from "./codex-host.js";
+/**
+ * Public launch-probe facade. Only a successful probe may brand an autonomy
+ * resolution as safe for adapter execution; structurally similar objects
+ * supplied directly by callers remain untrusted.
+ */
+export function probeCodexLaunch(input) {
+    const result = probeCodexLaunchHost(input);
+    if (result.ok && result.autonomyResolution) {
+        markCodexAutonomyResolutionVerifiedByLaunchProbe(result.autonomyResolution);
+    }
+    return result;
+}
+export { buildCodexStdin, cacheCodexCapabilityProfile, clearCodexCapabilityCacheForTests, codexWriteStrategies, isCodexAutonomyResolutionVerifiedByLaunchProbe, probeCodexCapabilities, resolveCodexAutonomyCandidates } from "./codex-capabilities.js";
+export { checkCodexSandboxPreflight, detectCodexHostPlatform, diagnoseCodexHost, probeFilesystemWriteCapability, resolveCliCommandAvailability } from "./codex-host.js";

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

@@ -30,6 +30,7 @@
  */
 import { readGitChangedFiles, runVerification } from "./cli-bridge.js";
 import { createAdapterCapabilities, normalizeUsage } from "./runtime-support.js";
+import { applyWorkspaceEdits, buildWorkspaceSnapshot } from "./workspace-edit-protocol.js";
 // ---------------------------------------------------------------------------
 // OpenRouter/OpenAI-compatible model pricing ($/1K tokens)
 // Automatically used when baseUrl contains openrouter.ai or known providers.
@@ -105,11 +106,12 @@ function normalizeOpenAiCompatibleUsage(input) {
 // ---------------------------------------------------------------------------
 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.`;
+- Read the task description and repository snapshot carefully and implement only what is asked.
+- Do not add unrelated features, refactors, or improvements.
+- Respect every allowed-path and denied-path boundary in the task contract.
+- For governed coding runs, return ONLY the structured JSON edit plan requested in the user message.
+- Every edit must contain the complete replacement content for one repository-relative text file.
+- Do not claim success unless your proposed edits satisfy the acceptance criteria and verifier.`;
 export const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com";
 export function resolveOpenAiCompatibleRuntimeConfig(env = process.env) {
     const apiKey = env["MARTIN_OPENAI_API_KEY"] ?? "";
@@ -121,7 +123,7 @@ export function resolveOpenAiCompatibleRuntimeConfig(env = process.env) {
         authPosture: apiKey.length > 0 ? "api_key" : "anonymous_or_local"
     };
 }
-function buildPrompt(request) {
+function buildPrompt(request, workspaceSnapshot = "") {
     const lines = [
         `TASK: ${request.context.taskTitle}`,
         ``,
@@ -132,6 +134,15 @@ function buildPrompt(request) {
     if (request.context.focus) {
         lines.push(`FOCUS: ${request.context.focus}`, ``);
     }
+    if ((request.context.acceptanceCriteria?.length ?? 0) > 0) {
+        lines.push(`ACCEPTANCE CRITERIA:`, ...(request.context.acceptanceCriteria ?? []).map((criterion) => `  - ${criterion}`), ``);
+    }
+    if ((request.context.allowedPaths?.length ?? 0) > 0) {
+        lines.push(`ALLOWED EDIT PATHS:`, ...(request.context.allowedPaths ?? []).map((path) => `  - ${path}`), ``);
+    }
+    if ((request.context.deniedPaths?.length ?? 0) > 0) {
+        lines.push(`DENIED EDIT PATHS:`, ...(request.context.deniedPaths ?? []).map((path) => `  - ${path}`), ``);
+    }
     if (request.context.verificationPlan.length > 0) {
         lines.push(`VERIFICATION COMMANDS (must pass after your changes):`, ...request.context.verificationPlan.map((cmd) => `  ${cmd}`), ``);
     }
@@ -142,6 +153,9 @@ function buildPrompt(request) {
         }
     }
     lines.push(`BUDGET REMAINING: $${request.context.remainingBudgetUsd.toFixed(4)} | Iterations left: ${request.context.remainingIterations}`);
+    if (workspaceSnapshot) {
+        lines.push(``, `WORKSPACE SNAPSHOT (read-only context; paths are repository-relative):`, workspaceSnapshot, ``, `RESPONSE CONTRACT:`, `Return ONLY JSON with this shape:`, `{"summary":"short description","edits":[{"path":"src/file.ts","content":"complete replacement file content"}],"deletions":[]}`, `Use only repository-relative paths. Every proposed path is validated by MartinLoop before any file is written.`, `If a file should not change, omit it. Do not wrap the JSON in explanatory prose.`);
+    }
     return lines.join("\n");
 }
 // ---------------------------------------------------------------------------
@@ -181,10 +195,21 @@ export function createOpenAiCompatibleAdapter(options) {
             })
         },
         async execute(request) {
-            const prompt = buildPrompt(request);
-            const estimated = estimateCost(model, prompt.length, 2000);
             const hasVerificationSteps = request.context.verificationPlan.length > 0 ||
                 (request.context.verificationStack?.length ?? 0) > 0;
+            const governedCodingRun = request.context.mutationMode === "edit" ||
+                hasVerificationSteps ||
+                (request.context.allowedPaths?.length ?? 0) > 0 ||
+                (request.context.deniedPaths?.length ?? 0) > 0;
+            const workspaceSnapshot = governedCodingRun
+                ? await buildWorkspaceSnapshot({
+                    workingDirectory,
+                    allowedPaths: request.context.allowedPaths,
+                    deniedPaths: request.context.deniedPaths
+                })
+                : "";
+            const prompt = buildPrompt(request, workspaceSnapshot);
+            const estimated = estimateCost(model, prompt.length, 2000);
             const baselineChangedFiles = hasVerificationSteps
                 ? new Set(await readGitChangedFiles(workingDirectory, 5_000))
                 : new Set();
@@ -336,6 +361,33 @@ export function createOpenAiCompatibleAdapter(options) {
                     failure: { message: "empty_response" }
                 };
             }
+            if (governedCodingRun) {
+                try {
+                    await applyWorkspaceEdits({
+                        workingDirectory,
+                        responseText,
+                        allowedPaths: request.context.allowedPaths,
+                        deniedPaths: request.context.deniedPaths
+                    });
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    return {
+                        status: "failed",
+                        summary: `${model} did not produce an admissible governed workspace edit: ${message}`,
+                        usage: normalizeOpenAiCompatibleUsage({
+                            model,
+                            tokensIn,
+                            tokensOut,
+                            usageWasFullyProviderReported,
+                            modelSource,
+                            billingMode
+                        }),
+                        verification: { passed: false, summary: "Workspace edit protocol failed before verifier execution." },
+                        failure: { message }
+                    };
+                }
+            }
             // Run verification
             const verification = await runVerification(request.context.verificationPlan, workingDirectory, verifyTimeoutMs, request.context.verificationStack, undefined, {
                 runId: request.loopId,

package/dist/vendor/adapters/workspace-edit-protocol.d.ts

@@ -0,0 +1,34 @@
+export interface WorkspaceEdit {
+    path: string;
+    content: string;
+}
+export interface WorkspaceEditPlan {
+    summary?: string;
+    edits: WorkspaceEdit[];
+    deletions: string[];
+}
+export interface WorkspaceSnapshotOptions {
+    workingDirectory: string;
+    allowedPaths?: string[];
+    deniedPaths?: string[];
+    maxFiles?: number;
+    maxBytes?: number;
+    maxFileBytes?: number;
+}
+export interface ApplyWorkspaceEditsOptions {
+    workingDirectory: string;
+    responseText: string;
+    allowedPaths?: string[];
+    deniedPaths?: string[];
+}
+export declare function pathAllowedByGovernance(path: string, allowedPaths: string[] | undefined, deniedPaths: string[] | undefined): boolean;
+export declare function parseWorkspaceEditPlan(responseText: string): WorkspaceEditPlan;
+export declare function applyWorkspaceEditPlan(plan: WorkspaceEditPlan, options: Omit<ApplyWorkspaceEditsOptions, "responseText">): Promise<{
+    changedFiles: string[];
+    summary?: string;
+}>;
+export declare function applyWorkspaceEdits(options: ApplyWorkspaceEditsOptions): Promise<{
+    changedFiles: string[];
+    summary?: string;
+}>;
+export declare function buildWorkspaceSnapshot(options: WorkspaceSnapshotOptions): Promise<string>;

package/dist/vendor/adapters/workspace-edit-protocol.js

@@ -0,0 +1,271 @@
+import { lstat, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
+const DEFAULT_MAX_FILES = 48;
+const DEFAULT_MAX_BYTES = 120_000;
+const DEFAULT_MAX_FILE_BYTES = 24_000;
+const SKIP_DIRECTORIES = new Set([
+    ".git",
+    ".martin",
+    "node_modules",
+    "dist",
+    "build",
+    "coverage",
+    ".next",
+    ".turbo",
+]);
+function normalizePath(value) {
+    return value.replace(/\\/gu, "/").replace(/^\.\//u, "");
+}
+function globToRegExp(pattern) {
+    const normalized = normalizePath(pattern.trim());
+    let source = "^";
+    for (let i = 0; i < normalized.length; i += 1) {
+        const ch = normalized[i] ?? "";
+        if (ch === "*") {
+            if (normalized[i + 1] === "*") {
+                if (normalized[i + 2] === "/") {
+                    source += "(?:.*/)?";
+                    i += 2;
+                }
+                else {
+                    source += ".*";
+                    i += 1;
+                }
+            }
+            else {
+                source += "[^/]*";
+            }
+            continue;
+        }
+        if (ch === "?") {
+            source += "[^/]";
+            continue;
+        }
+        source += ch.replace(/[|\\{}()[\]^$+?.]/gu, "\\$&");
+    }
+    source += "$";
+    return new RegExp(source, "u");
+}
+function matchesAny(path, patterns) {
+    if (!patterns || patterns.length === 0) {
+        return false;
+    }
+    const normalized = normalizePath(path);
+    return patterns.some((pattern) => globToRegExp(pattern).test(normalized));
+}
+export function pathAllowedByGovernance(path, allowedPaths, deniedPaths) {
+    const normalized = normalizePath(path);
+    if (matchesAny(normalized, deniedPaths)) {
+        return false;
+    }
+    if (!allowedPaths || allowedPaths.length === 0) {
+        return true;
+    }
+    return matchesAny(normalized, allowedPaths);
+}
+function assertSafeRelativePath(path, workingDirectory) {
+    const normalized = normalizePath(path.trim());
+    if (!normalized || isAbsolute(path) || normalized.startsWith("../") || normalized === "..") {
+        throw new Error(`WORKSPACE_EDIT_INVALID_PATH: ${path}`);
+    }
+    const target = resolve(workingDirectory, normalized);
+    const rel = relative(resolve(workingDirectory), target);
+    if (!rel || rel.startsWith(`..${sep}`) || rel === ".." || isAbsolute(rel)) {
+        throw new Error(`WORKSPACE_EDIT_PATH_ESCAPE: ${path}`);
+    }
+    return normalized;
+}
+async function assertNoSymlinkTraversal(path, workingDirectory) {
+    const root = resolve(workingDirectory);
+    const segments = normalizePath(path).split("/").filter(Boolean);
+    let cursor = root;
+    for (const segment of segments) {
+        cursor = resolve(cursor, segment);
+        try {
+            const info = await lstat(cursor);
+            if (info.isSymbolicLink()) {
+                throw new Error(`WORKSPACE_EDIT_SYMLINK_REJECTED: ${path}`);
+            }
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === "ENOENT") {
+                return;
+            }
+            throw error;
+        }
+    }
+}
+function extractJsonPayload(responseText) {
+    const trimmed = responseText.trim();
+    const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/iu)?.[1]?.trim();
+    if (fenced) {
+        return fenced;
+    }
+    const first = trimmed.indexOf("{");
+    const last = trimmed.lastIndexOf("}");
+    if (first >= 0 && last > first) {
+        return trimmed.slice(first, last + 1);
+    }
+    return trimmed;
+}
+export function parseWorkspaceEditPlan(responseText) {
+    let parsed;
+    try {
+        parsed = JSON.parse(extractJsonPayload(responseText));
+    }
+    catch (error) {
+        throw new Error(`WORKSPACE_EDIT_PROTOCOL_INVALID_JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("WORKSPACE_EDIT_PROTOCOL_INVALID_SHAPE: expected JSON object");
+    }
+    const record = parsed;
+    const rawEdits = record.edits ?? [];
+    const rawDeletions = record.deletions ?? [];
+    if (!Array.isArray(rawEdits) || !Array.isArray(rawDeletions)) {
+        throw new Error("WORKSPACE_EDIT_PROTOCOL_INVALID_SHAPE: edits/deletions must be arrays");
+    }
+    const edits = rawEdits.map((entry, index) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+            throw new Error(`WORKSPACE_EDIT_PROTOCOL_INVALID_EDIT: edits[${index}]`);
+        }
+        const edit = entry;
+        if (typeof edit.path !== "string" || typeof edit.content !== "string") {
+            throw new Error(`WORKSPACE_EDIT_PROTOCOL_INVALID_EDIT: edits[${index}] requires path/content strings`);
+        }
+        return { path: edit.path, content: edit.content };
+    });
+    const deletions = rawDeletions.map((entry, index) => {
+        if (typeof entry !== "string") {
+            throw new Error(`WORKSPACE_EDIT_PROTOCOL_INVALID_DELETION: deletions[${index}]`);
+        }
+        return entry;
+    });
+    if (edits.length === 0 && deletions.length === 0) {
+        throw new Error("WORKSPACE_EDIT_PROTOCOL_NO_CHANGES: model returned no workspace edits");
+    }
+    return {
+        ...(typeof record.summary === "string" ? { summary: record.summary } : {}),
+        edits,
+        deletions,
+    };
+}
+export async function applyWorkspaceEditPlan(plan, options) {
+    const normalizedEdits = plan.edits.map((edit) => ({
+        ...edit,
+        path: assertSafeRelativePath(edit.path, options.workingDirectory),
+    }));
+    const normalizedDeletions = plan.deletions.map((path) => assertSafeRelativePath(path, options.workingDirectory));
+    const proposedPaths = [
+        ...normalizedEdits.map((edit) => edit.path),
+        ...normalizedDeletions,
+    ];
+    const duplicate = proposedPaths.find((path, index) => proposedPaths.indexOf(path) !== index);
+    if (duplicate) {
+        throw new Error(`WORKSPACE_EDIT_PROTOCOL_DUPLICATE_PATH: ${duplicate}`);
+    }
+    for (const path of proposedPaths) {
+        if (!pathAllowedByGovernance(path, options.allowedPaths, options.deniedPaths)) {
+            throw new Error(`WORKSPACE_EDIT_GOVERNANCE_REJECTED: ${path}`);
+        }
+        await assertNoSymlinkTraversal(path, options.workingDirectory);
+    }
+    for (const edit of normalizedEdits) {
+        const target = resolve(options.workingDirectory, edit.path);
+        await mkdir(dirname(target), { recursive: true });
+        await writeFile(target, edit.content, "utf8");
+    }
+    for (const path of normalizedDeletions) {
+        await rm(resolve(options.workingDirectory, path), { force: true });
+    }
+    return {
+        changedFiles: proposedPaths,
+        ...(plan.summary ? { summary: plan.summary } : {}),
+    };
+}
+export async function applyWorkspaceEdits(options) {
+    return applyWorkspaceEditPlan(parseWorkspaceEditPlan(options.responseText), options);
+}
+async function walkFiles(root, current = root) {
+    const entries = await readdir(current, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        if (entry.isDirectory() && SKIP_DIRECTORIES.has(entry.name)) {
+            continue;
+        }
+        const absolute = resolve(current, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await walkFiles(root, absolute)));
+            continue;
+        }
+        if (entry.isFile()) {
+            files.push(normalizePath(relative(root, absolute)));
+        }
+    }
+    return files;
+}
+function isProbablyBinary(buffer) {
+    const sample = buffer.subarray(0, Math.min(buffer.length, 8_192));
+    return sample.includes(0);
+}
+function scoreSnapshotPath(path, allowedPaths, deniedPaths) {
+    let score = 0;
+    if (matchesAny(path, allowedPaths))
+        score += 100;
+    if (matchesAny(path, deniedPaths))
+        score += 50;
+    if (/^(?:src|app|lib|test|tests|config)\//u.test(path))
+        score += 25;
+    if (/^(?:package\.json|pyproject\.toml|Cargo\.toml|go\.mod|README\.md)$/u.test(path))
+        score += 20;
+    if (/\.(?:ts|tsx|js|jsx|py|go|rs|java|kt|json|yaml|yml|toml|md)$/u.test(path))
+        score += 10;
+    return score;
+}
+export async function buildWorkspaceSnapshot(options) {
+    const maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
+    const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+    const maxFileBytes = options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
+    const root = resolve(options.workingDirectory);
+    const candidates = (await walkFiles(root)).sort((a, b) => {
+        const scoreDelta = scoreSnapshotPath(b, options.allowedPaths, options.deniedPaths) -
+            scoreSnapshotPath(a, options.allowedPaths, options.deniedPaths);
+        return scoreDelta || a.localeCompare(b);
+    });
+    const sections = [];
+    let totalBytes = 0;
+    let included = 0;
+    for (const path of candidates) {
+        if (included >= maxFiles || totalBytes >= maxBytes)
+            break;
+        const absolute = resolve(root, path);
+        let info;
+        try {
+            info = await stat(absolute);
+        }
+        catch {
+            continue;
+        }
+        if (!info.isFile() || info.size > maxFileBytes)
+            continue;
+        let buffer;
+        try {
+            buffer = await readFile(absolute);
+        }
+        catch {
+            continue;
+        }
+        if (isProbablyBinary(buffer))
+            continue;
+        const content = buffer.toString("utf8");
+        const section = `--- FILE: ${path} ---\n${content}\n--- END FILE ---`;
+        const sectionBytes = Buffer.byteLength(section, "utf8");
+        if (totalBytes + sectionBytes > maxBytes)
+            continue;
+        sections.push(section);
+        totalBytes += sectionBytes;
+        included += 1;
+    }
+    return sections.join("\n\n");
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@martinloop/mcp",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "mcpName": "io.github.Keesan12/martin-loop",
   "private": false,
   "type": "module",
-  "description": "MCP server for AI coding agents — verifier gates, stop limits, and Verified Handoffs.",
+  "description": "MCP server for AI coding agents — verifier gates, stop limits, and Verified Handoffs.",
   "license": "Apache-2.0",
   "author": "MartinLoop contributors",
   "homepage": "https://martinloop.com/",
@@ -41,11 +41,6 @@
     "martin-loop-mcp": "./dist/server.js"
   },
   "exports": {
-    ".": {
-      "types": "./dist/server.d.ts",
-      "import": "./dist/server.js",
-      "default": "./dist/server.js"
-    },
     "./server.json": "./server.json",
     "./package.json": "./package.json"
   },
@@ -79,12 +74,12 @@
     "mcpb:smoke": "node ./mcpb/smoke-mcpb.mjs"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "1.29.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "@open-policy-agent/opa-wasm": "^1.10.0",
-    "@opentelemetry/api-logs": "^0.221.0",
-    "@opentelemetry/exporter-logs-otlp-http": "^0.221.0",
-    "@opentelemetry/resources": "^2.10.0",
-    "@opentelemetry/sdk-logs": "^0.221.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": {

package/server.json

@@ -7,12 +7,12 @@
     "url": "https://github.com/Keesan12/martin-loop",
     "source": "github"
   },
-  "version": "0.6.0",
+  "version": "0.6.2",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@martinloop/mcp",
-      "version": "0.6.0",
+      "version": "0.6.2",
       "transport": {
         "type": "stdio"
       }