@martinloop/mcp 0.8.7 → 0.8.8

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

@@ -1,4 +1,4 @@
-import type { BudgetPreflightEstimate, CostProvenance, EvidenceVector, FailureClass, InterventionType, LoopAttempt, LoopBudget, LoopCost, LoopLifecycleState, LoopStatus, PatchDecisionArtifact, PatchScore, PolicyPhase } from "../contracts/index.js";
+import type { BudgetPreflightEstimate, CostProvenance, EvidenceVector, FailureClass, InterventionType, LoopAttempt, LoopBudget, LoopCost, LoopLifecycleState, LoopStatus, PatchDecisionArtifact, PatchDecisionReasonCode, PatchScore, PolicyPhase } from "../contracts/index.js";
 export interface FailureAssessment {
     failureClass: FailureClass;
     rationale: string;
@@ -106,6 +106,17 @@ export interface BudgetPreflightInput {
     remainingTokens?: number;
     /** Adapter-declared estimated floor required to admit a credible first turn. */
     minimumViableTokens?: number;
+    /**
+     * Remaining iterations allowed. Used to compute a budget-aware per-attempt cap
+     * that reserves capacity for verifier and at least one repair attempt.
+     * When omitted, the preflight uses remaining budget divided by a conservative
+     * factor to prevent over-allocation on the first attempt.
+     */
+    remainingIterations?: number;
+    /**
+     * Explicit per-attempt spending cap. When set, overrides the computed cap.
+     * Only use when the caller has specific rate-limiting requirements.
+     */
     perAttemptCapUsd?: number;
     pricePerMTokenUsd?: number;
 }
@@ -158,5 +169,11 @@ export interface EvaluatedPatchDecision extends PatchDecisionArtifact {
     score: PatchScore;
 }
 export declare function selectRecoveryRecipe(evidence: EvidenceVector): RecoveryDecision;
+/**
+ * Returns true ONLY when every reason code is in the explicit allowlist of
+ * retainable soft failures.  Unknown or future reason codes default to UNSAFE
+ * (fail-closed), preventing silent candidate retention for unrecognized states.
+ */
+export declare function isSafeUnverifiedDiscard(reasonCodes: readonly PatchDecisionReasonCode[]): boolean;
 export declare function evaluatePatchDecision(input: PatchDecisionInput): EvaluatedPatchDecision;
 export declare function scorePatchDecision(input: PatchDecisionInput): PatchScore;

package/dist/vendor/core/policy.js

@@ -244,17 +244,42 @@ export function inferExit(input) {
             reason: "Oscillating failure pattern detected — loop is cycling without measurable progress."
         };
     }
+    // C2 — progress-aware repetition check.
+    // Two consecutive attempts with the same failureClass are NOT necessarily
+    // the same state. If the verifierScore improved (e.g. fewer failing tests),
+    // that is measurable progress and we must not stop prematurely.
+    // Only stop when the failure class repeated AND there is no measurable improvement:
+    //   - verifierScore did not increase, AND
+    //   - candidate diff did not change (candidateRetained with same failure)
     const lastTwo = input.loop.attempts.slice(-2);
-    const repeatedFailure = lastTwo.length === 2 &&
+    const repeatedFailureClass = lastTwo.length === 2 &&
         lastTwo.every((attempt) => attempt.failureClass &&
             attempt.failureClass === lastTwo[0]?.failureClass &&
             attempt.failureClass === input.lastFailure?.failureClass);
-    if (repeatedFailure && input.lastFailure) {
+    // Measure progress using REAL evidence from actual verifier step results.
+    // Multiple signals are checked; any one constituting real progress allows continuation.
+    const measurableProgressOccurred = (() => {
+        const [prev, curr] = lastTwo;
+        if (!prev || !curr)
+            return false;
+        // Signal 1: verifierScore improved (computed from real passing/total step ratio)
+        const prevScore = prev.verifierScore ?? 0;
+        const currScore = curr.verifierScore ?? 0;
+        if (currScore > prevScore)
+            return true;
+        // Signal 2: fewer failing verifier steps than previous attempt (monotonic improvement)
+        if (prev.failingVerifierStepCount !== undefined &&
+            curr.failingVerifierStepCount !== undefined &&
+            curr.failingVerifierStepCount < prev.failingVerifierStepCount)
+            return true;
+        return false;
+    })();
+    if (repeatedFailureClass && !measurableProgressOccurred && input.lastFailure) {
         return {
             shouldExit: true,
             lifecycleState: "diminishing_returns",
             status: "exited",
-            reason: `Martin exited because ${input.lastFailure.failureClass} repeated across consecutive attempts.`
+            reason: `Martin exited because ${input.lastFailure.failureClass} repeated across consecutive attempts with no measurable progress (score, step count, or failure surface unchanged).`
         };
     }
     if (input.lastFailure?.failureClass === "environment_mismatch" &&
@@ -398,11 +423,34 @@ export function evaluateBudgetPreflight(input) {
             estimate
         };
     }
-    const perAttemptCap = input.perAttemptCapUsd ?? Math.max(input.remainingBudgetUsd * 0.2, 0.05);
+    // D2 — Budget-aware per-attempt cap.
+    //
+    // Old behavior: rigid maxUsd * 0.25 — blocked viable attempts when total budget
+    // was large (e.g. $0.30 cost blocked on $1.00 budget because 0.30 > 0.25).
+    //
+    // New behavior: if an explicit cap is provided, honor it. Otherwise compute a
+    // cap that reserves budget for the verifier and at least one repair attempt beyond
+    // the current one, giving the provider meaningful runway.
+    //
+    // Formula: cap = remainingBudget / (remainingIterations + 1)
+    //   +1 accounts for the current attempt being the "next" attempt.
+    //   Minimum cap of $0.05 prevents degenerate near-zero rejections.
+    const perAttemptCap = (() => {
+        if (input.perAttemptCapUsd !== undefined)
+            return input.perAttemptCapUsd;
+        const iters = input.remainingIterations;
+        if (iters !== undefined && iters > 0) {
+            // Divide remaining budget evenly across remaining iterations.
+            return Math.max(roundUsd(input.remainingBudgetUsd / iters), 0.05);
+        }
+        // No iteration information: allow up to 80% of remaining budget per attempt
+        // (down from the old 25%-of-total which was frequently too low).
+        return Math.max(roundUsd(input.remainingBudgetUsd * 0.8), 0.05);
+    })();
     if (estimatedAttemptCostUsd > perAttemptCap) {
         return {
             allowed: false,
-            reason: `Preflight: estimated attempt cost $${estimatedAttemptCostUsd} exceeds per-attempt cap $${roundUsd(perAttemptCap)}.`,
+            reason: `Preflight: estimated attempt cost $${estimatedAttemptCostUsd} exceeds per-attempt cap $${roundUsd(perAttemptCap)} (remaining budget $${input.remainingBudgetUsd}, ${input.remainingIterations ?? "?"} iterations left).`,
             estimate
         };
     }
@@ -517,6 +565,41 @@ export function selectRecoveryRecipe(evidence) {
         intervention: "escalate_human"
     };
 }
+/**
+ * Explicit allowlist of reason codes that are SAFE to retain as an unverified
+ * candidate for the next repair attempt.
+ *
+ * FAIL-CLOSED: any reason code NOT in this set causes an immediate rollback.
+ * This prevents future or unknown reason codes from silently becoming "safe."
+ *
+ * Retainable only when ALL of these are also true:
+ *  - scope_violation is absent (agent stayed within allowed paths)
+ *  - safety_violation is absent (no secret/tenancy/test-integrity violation)
+ *  - workspace observation was authoritative (changed files were tracked)
+ *  - provider did not crash/fail (status !== "failed")
+ *
+ * no_code_change is explicitly NOT retainable — there is nothing to repair.
+ * Use a different recovery strategy instead.
+ */
+const RETAINABLE_SOFT_REASON_CODES = new Set([
+    "verifier_not_improved",
+    "low_novelty_no_progress",
+    "large_diff_no_improvement",
+    "grounding_failure",
+    "verifier_regressed", // actual test regression — retry with different approach
+]);
+/**
+ * Returns true ONLY when every reason code is in the explicit allowlist of
+ * retainable soft failures.  Unknown or future reason codes default to UNSAFE
+ * (fail-closed), preventing silent candidate retention for unrecognized states.
+ */
+export function isSafeUnverifiedDiscard(reasonCodes) {
+    if (reasonCodes.length === 0) {
+        // No specific signal — we don't know why it's being discarded; fail closed.
+        return false;
+    }
+    return reasonCodes.every((code) => RETAINABLE_SOFT_REASON_CODES.has(code));
+}
 export function evaluatePatchDecision(input) {
     const score = scorePatchDecision(input);
     const reasonCodes = [...score.reasonCodes];
@@ -624,21 +707,41 @@ function tokenizeDiff(diff) {
     return tokens;
 }
 function decidePatchOutcome(input, reasonCodes) {
+    // 1. Explicit human approval required — always escalate regardless of verifier.
+    // 2. Safety violation — always escalate.
     if (input.humanApprovalRequired || reasonCodes.includes("safety_violation")) {
         return "ESCALATE";
     }
+    // 3. Scope violation — hard boundary: out-of-scope writes are never kept,
+    //    even if the verifier passes, because the change violated the task contract.
+    if (reasonCodes.includes("scope_violation")) {
+        return "DISCARD";
+    }
+    // 4. Required mutation is absent — a green generic test suite is not proof
+    //    that the requested work happened.  Discard if:
+    //      - a code change was required (mutation_required = edit mode)
+    //      - no files were actually changed
+    //      - the task was not pre-satisfied by the existing codebase
+    //    Note: the scorer already suppresses no_code_change when
+    //    definitionOfDonePreSatisfied is true, so that legitimate case passes through.
+    if (reasonCodes.includes("no_code_change")) {
+        return "DISCARD";
+    }
+    // 5. Passing verifier is the authoritative signal and overrides lower-confidence
+    //    heuristics such as grounding failure.  A grounding heuristic (symbol
+    //    resolution, repo anatomy check) is weaker evidence than an actual passing
+    //    host-run test exit code.
+    if (input.verificationPassed) {
+        return "KEEP";
+    }
+    // 6. Non-passing verifier: discard on any remaining negative heuristic signal.
     if (reasonCodes.includes("grounding_failure") ||
-        reasonCodes.includes("scope_violation") ||
-        reasonCodes.includes("no_code_change") ||
         reasonCodes.includes("verifier_regressed") ||
         reasonCodes.includes("large_diff_no_improvement") ||
         reasonCodes.includes("low_novelty_no_progress") ||
         reasonCodes.includes("verifier_not_improved")) {
         return "DISCARD";
     }
-    if (input.verificationPassed) {
-        return "KEEP";
-    }
     return "DISCARD";
 }
 function buildPatchDecisionSummary(decision, reasonCodes, summary) {

package/dist/vendor/core/rollback.js

@@ -6,8 +6,11 @@ import { dirname, isAbsolute, relative, resolve } from "node:path";
 import { DEPENDENCY_AND_BUILD_DIRECTORIES, isInsideDependencyOrBuildDirectory } from "./output-directories.js";
 /** Past this many ignored files, further ignored directories stay collapsed. */
 const MAX_EXPANDED_IGNORED_FILES = 20_000;
+const MAX_HASHED_IGNORED_FILE_BYTES = 8 * 1024 * 1024;
+const MAX_HASHED_IGNORED_TOTAL_BYTES = 16 * 1024 * 1024;
 const MAX_IGNORED_SNAPSHOT_BYTES = 64 * 1024 * 1024;
 const ignoredContentSnapshots = new WeakMap();
+const ignoredObservations = new WeakMap();
 /** Git listings of large untracked or ignored trees exceed spawnSync's 1 MiB default. */
 const GIT_LIST_MAX_BUFFER_BYTES = 64 * 1024 * 1024;
 export class RollbackStateUnavailableError extends Error {
@@ -50,7 +53,12 @@ export async function captureRollbackBoundary(input) {
     for (const filePath of snapshotPaths) {
         snapshots.push(await readRollbackSnapshot(input.repoRoot, filePath));
     }
-    const ignoredFiles = readIgnoredInventory(input.repoRoot);
+    const observedIgnoredFiles = readIgnoredInventory(input.repoRoot);
+    const ignoredFiles = observedIgnoredFiles.map(({ path, size, mtimeMs }) => ({
+        path,
+        size,
+        mtimeMs
+    }));
     const headRef = readGitScalar(input.repoRoot, ["rev-parse", "HEAD"]);
     const headBranch = readHeadBranch(input.repoRoot);
     const boundary = {
@@ -63,6 +71,7 @@ export async function captureRollbackBoundary(input) {
         snapshots,
         ignoredFiles
     };
+    ignoredObservations.set(boundary, new Map(observedIgnoredFiles.map((entry) => [entry.path, entry])));
     ignoredContentSnapshots.set(boundary, captureIgnoredContent(input.repoRoot, ignoredFiles));
     return boundary;
 }
@@ -75,6 +84,7 @@ export function listIgnoredFileChangesSinceBoundary(input) {
         return makeIgnoredFileChanges([], [], []);
     }
     const baseline = new Map(input.boundary.ignoredFiles.map((entry) => [entry.path, entry]));
+    const baselineObservations = ignoredObservations.get(input.boundary);
     const created = [];
     const modified = [];
     const currentEntries = readIgnoredInventory(input.repoRoot);
@@ -87,15 +97,23 @@ export function listIgnoredFileChangesSinceBoundary(input) {
         if (!previous) {
             created.push(entry.path);
         }
-        else if (!entry.path.endsWith("/") &&
-            (previous.sha256 !== undefined && entry.sha256 !== undefined
-                ? previous.sha256 !== entry.sha256
-                : previous.size !== entry.size || previous.mtimeMs !== entry.mtimeMs)) {
+        else if (!entry.path.endsWith("/") && ignoredObservationChanged(previous, baselineObservations?.get(entry.path), entry)) {
             modified.push(entry.path);
         }
     }
     return makeIgnoredFileChanges(created.sort(), modified.sort(), deleted.sort());
 }
+function ignoredObservationChanged(previous, previousObservation, current) {
+    if (previousObservation?.sha256 !== undefined && current.sha256 !== undefined) {
+        return previousObservation.sha256 !== current.sha256;
+    }
+    if (previousObservation !== undefined) {
+        return previous.size !== current.size ||
+            previous.mtimeMs !== current.mtimeMs ||
+            previousObservation.ctimeMs !== current.ctimeMs;
+    }
+    return previous.size !== current.size || previous.mtimeMs !== current.mtimeMs;
+}
 function makeIgnoredFileChanges(created, modified, deleted) {
     const changes = { created, modified };
     // Preserve the historical enumerable shape when there are no deletions while
@@ -345,25 +363,31 @@ function readIgnoredInventory(repoRoot) {
     ]));
     const inventory = [];
     let expanded = 0;
+    const hashBudget = { remainingBytes: MAX_HASHED_IGNORED_TOTAL_BYTES };
     for (const entry of collapsed) {
         const isDirectory = entry.endsWith("/");
         const leaf = entry.replace(/\/$/u, "").split("/").at(-1) ?? entry;
-        if (isDirectory &&
-            (DEPENDENCY_AND_BUILD_DIRECTORIES.has(leaf) || expanded >= MAX_EXPANDED_IGNORED_FILES)) {
-            inventory.push({ path: entry, size: 0, mtimeMs: 0 });
+        if (isDirectory && DEPENDENCY_AND_BUILD_DIRECTORIES.has(leaf)) {
+            inventory.push({ path: entry, size: 0, mtimeMs: 0, ctimeMs: 0 });
             continue;
         }
+        if (isDirectory && expanded >= MAX_EXPANDED_IGNORED_FILES) {
+            throw new RollbackStateUnavailableError(`Ignored rollback inventory exceeds the ${String(MAX_EXPANDED_IGNORED_FILES)}-file observation limit at ${entry}`);
+        }
         const files = isDirectory
             ? collapsePathsThroughLinks(repoRoot, readGitLines(repoRoot, ["ls-files", "--others", "--ignored", "--exclude-standard", "--", entry]))
             : [entry];
         for (const filePath of files) {
-            inventory.push(stampIgnoredFile(repoRoot, filePath));
+            if (expanded >= MAX_EXPANDED_IGNORED_FILES) {
+                throw new RollbackStateUnavailableError(`Ignored rollback inventory exceeds the ${String(MAX_EXPANDED_IGNORED_FILES)}-file observation limit at ${entry}`);
+            }
+            inventory.push(stampIgnoredFile(repoRoot, filePath, hashBudget));
             expanded += 1;
         }
     }
     return inventory.sort((left, right) => left.path.localeCompare(right.path));
 }
-function stampIgnoredFile(repoRoot, filePath) {
+function stampIgnoredFile(repoRoot, filePath, hashBudget) {
     try {
         const absolutePath = resolveRepoPath(repoRoot, filePath, { allowLeafLink: true });
         const link = isLinkPath(repoRoot, filePath);
@@ -371,10 +395,16 @@ function stampIgnoredFile(repoRoot, filePath) {
         const stamp = {
             path: normalizeRepoPath(filePath),
             size: stats.size,
-            mtimeMs: Math.trunc(stats.mtimeMs)
+            mtimeMs: Math.trunc(stats.mtimeMs),
+            ctimeMs: Math.trunc(stats.ctimeMs)
         };
-        if (!link && stats.isFile() && !isInsideDependencyOrBuildDirectory(filePath)) {
+        if (!link &&
+            stats.isFile() &&
+            stats.size <= MAX_HASHED_IGNORED_FILE_BYTES &&
+            stats.size <= hashBudget.remainingBytes &&
+            !isInsideDependencyOrBuildDirectory(filePath)) {
             stamp.sha256 = createHash("sha256").update(readFileSync(absolutePath)).digest("hex");
+            hashBudget.remainingBytes -= stats.size;
         }
         return stamp;
     }
@@ -383,7 +413,7 @@ function stampIgnoredFile(repoRoot, filePath) {
             throw new RollbackStateUnavailableError(`Unable to authenticate ignored rollback path ${normalizeRepoPath(filePath)}: ${toErrorMessage(error)}`);
         }
         // Vanished between listing and stat; record presence only so later comparison fails closed.
-        return { path: normalizeRepoPath(filePath), size: -1, mtimeMs: -1 };
+        return { path: normalizeRepoPath(filePath), size: -1, mtimeMs: -1, ctimeMs: -1 };
     }
 }
 function captureIgnoredContent(repoRoot, ignoredFiles) {

package/dist/vendor/core/test-integrity.js

@@ -226,43 +226,66 @@ export function findWeakenedTestFiles(input) {
     if (candidates.length === 0) {
         return [];
     }
-    const removedLines = listFilesWithRemovedLines(input.repoRoot, input.baseRef, candidates);
-    return [...removedLines].filter((filePath) => isWeakened(input, filePath)).sort();
+    const changedLines = listChangedTestFiles(input.repoRoot, input.baseRef, candidates);
+    for (const filePath of candidates) {
+        if (!changedLines.has(filePath) &&
+            readBaseContent(input.repoRoot, input.baseRef, filePath) === undefined &&
+            readWorkingContent(input.repoRoot, filePath) !== undefined) {
+            // Untracked files are absent from `git diff --numstat` but still belong
+            // to the caller's observed changed-file set.
+            changedLines.set(filePath, false);
+        }
+    }
+    return [...changedLines.entries()]
+        .filter(([filePath, removedLines]) => isWeakened(input, filePath, removedLines))
+        .map(([filePath]) => filePath)
+        .sort();
 }
-/** Files among `candidates` that lost at least one line (or are binary) since `baseRef`. */
-function listFilesWithRemovedLines(repoRoot, baseRef, candidates) {
+/** Modified files among `candidates`, with whether they lost a line (or are binary). */
+function listChangedTestFiles(repoRoot, baseRef, candidates) {
     const result = spawnSync("git", ["diff", "--numstat", "--no-renames", "-z", baseRef, "--", ...candidates], { cwd: repoRoot, encoding: "utf8", maxBuffer: 16 * 1024 * 1024 });
     if (result.status !== 0 || typeof result.stdout !== "string") {
         const detail = typeof result.stderr === "string" ? result.stderr.trim() : "";
         throw new Error(`Test-change inspection failed: ${detail || `git exited with ${String(result.status)}`}`);
     }
-    const removed = new Set();
+    const changed = new Map();
     for (const record of result.stdout.split("\0")) {
-        const [, deletions, filePath] = record.split("\t");
-        if (filePath && deletions !== undefined && (deletions === "-" || Number(deletions) > 0)) {
-            removed.add(filePath.trim());
+        const [additions, deletions, filePath] = record.split("\t");
+        if (filePath && additions !== undefined && deletions !== undefined) {
+            changed.set(filePath.trim(), deletions === "-" || Number(deletions) > 0);
         }
     }
-    return removed;
+    return changed;
 }
 /** Cap on file size the surface analysis reads; larger files use the strict rule. */
 const MAX_SURFACE_BYTES = 2 * 1024 * 1024;
-function isWeakened(input, filePath) {
+const BASE_CONTENT_UNINSPECTABLE = Symbol("base-content-uninspectable");
+function isWeakened(input, filePath, removedLines) {
     const before = readBaseContent(input.repoRoot, input.baseRef, filePath);
-    if (before === undefined) {
+    if (before === BASE_CONTENT_UNINSPECTABLE) {
         return true;
     }
+    if (before === undefined) {
+        const after = readWorkingContent(input.repoRoot, filePath);
+        // New tests are welcome, but focus/skip/expected-failure markers can still
+        // suppress the authoritative suite and therefore require approval.
+        return after === undefined || testSurfaceWeakened("", after, filePath);
+    }
     const after = readWorkingContent(input.repoRoot, filePath);
     if (after === undefined) {
         // Deleted, replaced by a link, unreadable or oversized: cannot prove it still asserts.
         return true;
     }
     if (!hasTestSurface(extractTestSurface(before, filePath))) {
-        return true;
+        return removedLines || testSurfaceWeakened(before, after, filePath);
     }
     return testSurfaceWeakened(before, after, filePath);
 }
 function readBaseContent(repoRoot, baseRef, filePath) {
+    const exists = spawnSync("git", ["cat-file", "-e", `${baseRef}:${filePath}`], { cwd: repoRoot });
+    if (exists.status !== 0) {
+        return undefined;
+    }
     const result = spawnSync("git", ["show", `${baseRef}:${filePath}`], {
         cwd: repoRoot,
         encoding: "utf8",
@@ -270,7 +293,7 @@ function readBaseContent(repoRoot, baseRef, filePath) {
     });
     return result.status === 0 && typeof result.stdout === "string" && result.stdout.length <= MAX_SURFACE_BYTES
         ? result.stdout
-        : undefined;
+        : BASE_CONTENT_UNINSPECTABLE;
 }
 function readWorkingContent(repoRoot, filePath) {
     const absolutePath = join(repoRoot, filePath);

package/dist/vendor/core/test-surface.js

@@ -28,8 +28,11 @@ const CASE_PATTERNS = [
 ];
 const SKIP_PATTERNS = [
     /\b(?:test|it|describe|context|suite)\s*\.\s*(?:skip|todo)\b/gu,
+    /\b(?:test|it)\s*\.\s*failing\b/gu,
+    /\b(?:test|it|describe|context|suite|specify)\s*\.\s*only\b/gu,
+    /\bf(?:it|describe)\s*\(/gu,
     /\bx(?:it|describe|test|context)\s*\(/gu,
-    /@pytest\.mark\.skip\w*|\bpytest\.skip\s*\(|@unittest\.skip\w*|\bself\.skipTest\s*\(/gu,
+    /@pytest\.mark\.(?:skip\w*|xfail)|\bpytest\.(?:skip|xfail)\s*\(|@unittest\.(?:skip\w*|expectedFailure)|\bself\.skipTest\s*\(/gu,
     /\bt\.Skip\w*\s*\(/gu,
     /#\[ignore\b/gu,
     /@Disabled\b|@Ignore\b/gu

package/dist/vendor/core/verifier-input.d.ts

@@ -1,2 +1,4 @@
 /** Returns a reason when a verifier would be parsed differently from what the operator intended. */
-export declare function describeMalformedVerifier(command: string): string | undefined;
+export declare function describeMalformedVerifier(command: string, options?: {
+    detectShellFold?: boolean;
+}): string | undefined;

package/dist/vendor/core/verifier-input.js

@@ -7,6 +7,10 @@ const MARTIN_OWNED_OPTIONS = new Set([
 ]);
 const MARTIN_ENGINES = new Set(["auto", "claude", "codex", "gemini", "openai"]);
 const MARTIN_EXECUTABLES = new Set(["martin", "martin-loop", "martin.cmd", "martin-loop.cmd"]);
+const LAUNCHER_BOOLEAN_OPTIONS = new Set([
+    "-s", "--silent", "-y", "--yes", "--no-install", "--offline", "--prefer-offline", "--no-color"
+]);
+const LAUNCHER_VALUE_OPTIONS = new Set(["--cwd", "--dir", "--filter", "--package", "-p", "--workspace", "-w"]);
 function foldedMartinOptions(tokens) {
     const folded = [];
     tokens.forEach((token, index) => {
@@ -24,12 +28,15 @@ function foldedMartinOptions(tokens) {
     return folded;
 }
 /** Returns a reason when a verifier would be parsed differently from what the operator intended. */
-export function describeMalformedVerifier(command) {
+export function describeMalformedVerifier(command, options = {}) {
     const quote = findUnterminatedQuote(command);
     if (quote !== undefined)
         return `--verify value has an unterminated quote (${quote}): ${command}`;
+    if (options.detectShellFold === false)
+        return undefined;
     const tokens = command.trim().split(/\s+/u);
-    const executable = tokens[0]?.replace(/^["']|["']$/gu, "").toLowerCase() ?? "";
+    const executableIndex = resolveLaunchedExecutableIndex(tokens);
+    const executable = normalizeExecutableToken(tokens[executableIndex] ?? "");
     if (MARTIN_EXECUTABLES.has(executable))
         return undefined;
     const swallowed = foldedMartinOptions(tokens);
@@ -39,6 +46,47 @@ export function describeMalformedVerifier(command) {
     }
     return undefined;
 }
+function resolveLaunchedExecutableIndex(tokens) {
+    const launcher = normalizeExecutableToken(tokens[0] ?? "");
+    if (launcher === "node")
+        return 1;
+    if (launcher === "npx" || launcher === "pnpx") {
+        return skipLauncherOptions(tokens, 1);
+    }
+    if (launcher === "pnpm" || launcher === "npm" || launcher === "yarn") {
+        const actionIndex = skipLauncherOptions(tokens, 1);
+        const action = normalizeExecutableToken(tokens[actionIndex] ?? "");
+        if (action !== "exec" && action !== "dlx")
+            return 0;
+        return skipLauncherOptions(tokens, actionIndex + 1);
+    }
+    return 0;
+}
+function skipLauncherOptions(tokens, start) {
+    let index = start;
+    while (index < tokens.length) {
+        const token = tokens[index] ?? "";
+        if (token === "--" || LAUNCHER_BOOLEAN_OPTIONS.has(token) || token.startsWith("--color=")) {
+            index += 1;
+            continue;
+        }
+        if (LAUNCHER_VALUE_OPTIONS.has(token)) {
+            index += 2;
+            continue;
+        }
+        if ([...LAUNCHER_VALUE_OPTIONS].some((option) => token.startsWith(`${option}=`))) {
+            index += 1;
+            continue;
+        }
+        break;
+    }
+    return index;
+}
+function normalizeExecutableToken(token) {
+    const unquoted = token.replace(/^["']|["']$/gu, "");
+    const basename = unquoted.split(/[\\/]/u).at(-1)?.toLowerCase() ?? "";
+    return basename.endsWith(".js") ? basename.slice(0, -3) : basename;
+}
 function findUnterminatedQuote(command) {
     let quote;
     for (let index = 0; index < command.length; index += 1) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@martinloop/mcp",
-  "version": "0.8.7",
+  "version": "0.8.8",
   "mcpName": "io.github.Keesan12/martin-loop",
   "private": false,
   "type": "module",

package/server.json

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