@martinloop/mcp 0.3.2 → 0.3.4

package/dist/tools/tool-support.js

@@ -3,6 +3,7 @@ import { readdir, stat } from "node:fs/promises";
 import { join } from "node:path";
 import { evaluateCostGovernor, resolveRunsRoot } from "../vendor/core/index.js";
 import { readAllLoopRecordsSafely } from "./run-store.js";
+export const MARTIN_ENGINE_VALUES = ["claude", "codex", "gemini"];
 const CLI_CACHE_TTL_MS = 60_000;
 const RUN_STORE_CACHE_TTL_MS = 5_000;
 const cliAvailabilityCache = new Map();
@@ -30,14 +31,16 @@ export function detectCliAvailability(command) {
             command,
             available: true,
             locator,
-            detail: `${command} is available on PATH.`,
+            detail: isOnPathDirectly(command, resolvedPath)
+                ? `${command} is available on PATH.`
+                : `${command} found at ${resolvedPath} (not on PATH, auto-discovered).`,
             ...(resolvedPath ? { resolvedPath } : {})
         }
         : {
             command,
             available: false,
             locator,
-            detail: `${command} is not available on PATH.`
+            detail: `${command} is not installed. ${suggestInstallCommand(command)}`
         };
     cliAvailabilityCache.set(cacheKey, {
         expiresAt: Date.now() + CLI_CACHE_TTL_MS,
@@ -48,13 +51,6 @@ export function detectCliAvailability(command) {
 function findCommandOnPath(command) {
     const pathKey = Object.keys(process.env).find((key) => key.toLowerCase() === "path");
     const rawPath = pathKey ? process.env[pathKey] : undefined;
-    if (!rawPath) {
-        return undefined;
-    }
-    const pathEntries = rawPath
-        .split(process.platform === "win32" ? ";" : ":")
-        .map((entry) => entry.trim())
-        .filter(Boolean);
     const hasExtension = /\.[A-Za-z0-9]+$/u.test(command);
     const candidateNames = process.platform === "win32" && !hasExtension
         ? (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD")
@@ -63,7 +59,25 @@ function findCommandOnPath(command) {
             .filter(Boolean)
             .map((extension) => `${command}${extension.toLowerCase()}`)
         : [command];
-    for (const directory of pathEntries) {
+    // 1. Search PATH entries
+    if (rawPath) {
+        const pathEntries = rawPath
+            .split(process.platform === "win32" ? ";" : ":")
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+        for (const directory of pathEntries) {
+            for (const candidateName of candidateNames) {
+                const candidatePath = join(directory, candidateName);
+                if (isExecutablePath(candidatePath)) {
+                    return candidatePath;
+                }
+            }
+        }
+    }
+    // 2. Search common install locations when PATH didn't find it.
+    //    This catches CLIs installed via npm/brew/pip that aren't on the
+    //    current shell's PATH (common in IDEs, CI, and agent environments).
+    for (const directory of discoverCommonInstallDirectories(command)) {
         for (const candidateName of candidateNames) {
             const candidatePath = join(directory, candidateName);
             if (isExecutablePath(candidatePath)) {
@@ -73,6 +87,49 @@ function findCommandOnPath(command) {
     }
     return undefined;
 }
+/**
+ * Returns directories where CLI tools are commonly installed but may not
+ * be on PATH. Checked only as a fallback after PATH search fails.
+ */
+function discoverCommonInstallDirectories(command) {
+    const dirs = [];
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+    if (process.platform === "win32") {
+        // npm global bin (Roaming)
+        const appData = process.env.APPDATA;
+        if (appData) {
+            dirs.push(join(appData, "npm"));
+        }
+        // Codex desktop install
+        const localAppData = process.env.LOCALAPPDATA;
+        if (localAppData) {
+            dirs.push(join(localAppData, "OpenAI", "Codex", "bin"));
+        }
+        // Scoop
+        if (home) {
+            dirs.push(join(home, "scoop", "shims"));
+        }
+    }
+    else {
+        // Common Unix install paths
+        dirs.push("/usr/local/bin", "/opt/homebrew/bin");
+        if (home) {
+            dirs.push(join(home, ".local", "bin"), // pip, pipx
+            join(home, ".npm-global", "bin"), // npm prefix
+            join(home, ".bun", "bin"), // bun
+            join(home, ".cargo", "bin"), // cargo
+            join(home, "go", "bin") // go install
+            );
+        }
+        // nvm managed node
+        const nvmDir = process.env.NVM_DIR;
+        if (nvmDir) {
+            const nvmBin = join(nvmDir, "current", "bin");
+            dirs.push(nvmBin);
+        }
+    }
+    return dirs.filter(Boolean);
+}
 function isExecutablePath(candidatePath) {
     try {
         accessSync(candidatePath, process.platform === "win32" ? constants.F_OK : constants.X_OK);
@@ -82,6 +139,39 @@ function isExecutablePath(candidatePath) {
         return false;
     }
 }
+/**
+ * Returns true if the resolved path is inside a directory that's already
+ * on PATH (i.e., it was found via normal PATH lookup, not auto-discovery).
+ */
+function isOnPathDirectly(command, resolvedPath) {
+    const pathKey = Object.keys(process.env).find((key) => key.toLowerCase() === "path");
+    const rawPath = pathKey ? process.env[pathKey] : undefined;
+    if (!rawPath)
+        return false;
+    const pathEntries = rawPath
+        .split(process.platform === "win32" ? ";" : ":")
+        .map((entry) => entry.trim().replace(/[\\/]+$/u, ""))
+        .filter(Boolean);
+    const resolvedDir = resolvedPath
+        .replace(/[\\/][^\\/]+$/u, "")
+        .replace(/[\\/]+$/u, "");
+    return pathEntries.some((entry) => entry.toLowerCase() === resolvedDir.toLowerCase());
+}
+/**
+ * Returns a platform-specific one-liner install command for a known CLI.
+ */
+function suggestInstallCommand(command) {
+    const npmInstalls = {
+        claude: "npm install -g @anthropic-ai/claude-code",
+        codex: "npm install -g @openai/codex",
+        gemini: "npm install -g @google/gemini-cli"
+    };
+    const install = npmInstalls[command];
+    if (install) {
+        return `Install with: ${install}`;
+    }
+    return `Install ${command} and ensure it is on PATH.`;
+}
 export function getEngineAvailability(engine) {
     return detectCliAvailability(engine);
 }
@@ -181,18 +271,22 @@ export function buildVerificationSummary(loop, ledgerEvents = []) {
     const latestEvidence = selectedEvidence.evidence;
     if (!latestEvidence) {
         return {
-            status: "unavailable",
+            status: "not_run",
             eventCount: verificationEvents.length,
             ledgerEventCount: verificationLedgerEvents.length,
             warnings
         };
     }
+    const contradicted = latestEvidence.passed === true &&
+        warnings.some((warning) => warning.toLowerCase().includes("conflicts for the latest attempt"));
     return {
-        status: latestEvidence.passed === true
-            ? "passed"
-            : latestEvidence.passed === false
-                ? "failed"
-                : "unavailable",
+        status: contradicted
+            ? "contradicted"
+            : latestEvidence.passed === true
+                ? "passed"
+                : latestEvidence.passed === false
+                    ? "failed"
+                    : "not_run",
         eventCount: verificationEvents.length,
         ledgerEventCount: verificationLedgerEvents.length,
         ...(latestEvidence.attemptIndex !== undefined ? { latestAttemptIndex: latestEvidence.attemptIndex } : {}),
@@ -205,7 +299,7 @@ export function buildVerificationSummary(loop, ledgerEvents = []) {
 }
 export function resolveReceiptIntegrity(loop) {
     return (loop.receiptIntegrity ?? {
-        state: "unsigned",
+        state: "selector_noncanonical",
         reason: "Receipt integrity metadata was not available on the loop record."
     });
 }
@@ -397,7 +491,7 @@ function selectLatestVerificationEvidence(loop, verificationEvents, verification
         .map((candidate) => candidate.passed)
         .filter((candidate) => typeof candidate === "boolean"));
     if (distinctStatuses.size > 1) {
-        warnings.push("Verification evidence conflicts for the latest attempt; reporting status as unavailable.");
+        warnings.push("Verification evidence conflicts for the latest attempt; marking verification as contradicted.");
         return { warnings };
     }
     return {

package/dist/tools/triage-runs.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { decideCircuitBreak } from "../vendor/core/index.js";
 import { buildLoopPreview, buildSuggestedPromptNames, buildSuggestedResourceUris, buildVerificationSummary } from "./tool-support.js";
 import { listLoopRecords, readLedgerEvents } from "./run-store.js";
 import { resolveSafeLoopRecordPath } from "../server-validation.js";
@@ -14,6 +15,16 @@ export async function martinTriageRunsTool(input) {
     const findings = await Promise.all(listed.loops.map(async (loop) => {
         try {
             const preview = buildLoopPreview(loop);
+            const trajectory = decideCircuitBreak({
+                objective: loop.task?.objective ?? loop.loopId,
+                verificationPlan: loop.task?.verificationPlan,
+                attempts: loop.attempts.map((attempt) => ({
+                    index: attempt.index,
+                    summary: attempt.summary,
+                    failureClass: attempt.failureClass
+                })),
+                remainingIterations: preview.remainingIterations
+            });
             let ledgerEvents = [];
             const canonicalLoopRecordPath = resolveSafeLoopRecordPath(loop.loopId, listed.runsRoot);
             ledgerEvents = await readLedgerEvents({
@@ -26,7 +37,7 @@ export async function martinTriageRunsTool(input) {
                 canonicalLoopRecordPath
             });
             const verification = buildVerificationSummary(loop, ledgerEvents);
-            return buildTriageFinding(preview, verification);
+            return buildTriageFinding(preview, verification, trajectory);
         }
         catch {
             warnings.push(`Skipped triage for '${loop.loopId}' because its run record or verification evidence is unreadable.`);
@@ -59,13 +70,17 @@ export async function martinTriageRunsTool(input) {
         warnings
     };
 }
-function buildTriageFinding(loop, verification) {
+function buildTriageFinding(loop, verification, trajectory) {
     const reasonCodes = [];
     let severity = "low";
     if (verification.status === "failed") {
         reasonCodes.push("verification_failed");
         severity = maxSeverity(severity, "critical");
     }
+    if (verification.status === "contradicted") {
+        reasonCodes.push("verification_contradicted");
+        severity = maxSeverity(severity, "critical");
+    }
     if (loop.pressure === "hard_limit" || loop.shouldStop) {
         reasonCodes.push("budget_hard_limit");
         severity = maxSeverity(severity, "critical");
@@ -78,8 +93,12 @@ function buildTriageFinding(loop, verification) {
         reasonCodes.push("diminishing_returns");
         severity = maxSeverity(severity, "high");
     }
-    if (verification.status === "unavailable" && loop.attempts > 0) {
-        reasonCodes.push("verification_unavailable");
+    if (trajectory.shouldStop || trajectory.assessment.status === "stalled") {
+        reasonCodes.push("trajectory_stalled");
+        severity = maxSeverity(severity, "critical");
+    }
+    if (verification.status === "not_run" && loop.attempts > 0) {
+        reasonCodes.push("verification_not_run");
         severity = maxSeverity(severity, "medium");
     }
     if (loop.pressure === "soft_limit") {
@@ -104,6 +123,9 @@ function buildTriageFinding(loop, verification) {
     };
 }
 function summarizeFinding(loop, verification, severity, reasonCodes) {
+    if (reasonCodes.includes("trajectory_stalled")) {
+        return `Severity ${severity}: ${loop.loopId} should not spend another attempt before operator review.`;
+    }
     if (reasonCodes.includes("verification_failed")) {
         return `Severity ${severity}: ${loop.loopId} failed verification after ${loop.attempts} attempt(s).`;
     }
@@ -113,8 +135,11 @@ function summarizeFinding(loop, verification, severity, reasonCodes) {
     if (reasonCodes.includes("status_failed")) {
         return `Severity ${severity}: ${loop.loopId} is currently failed/${loop.lifecycleState}.`;
     }
-    if (reasonCodes.includes("verification_unavailable")) {
-        return `Severity ${severity}: ${loop.loopId} has ${loop.attempts} attempt(s) but verification is unavailable.`;
+    if (reasonCodes.includes("verification_contradicted")) {
+        return `Severity ${severity}: ${loop.loopId} has contradictory verification evidence and needs operator review.`;
+    }
+    if (reasonCodes.includes("verification_not_run")) {
+        return `Severity ${severity}: ${loop.loopId} has ${loop.attempts} attempt(s) but verification was not recorded.`;
     }
     if (reasonCodes.includes("budget_soft_limit")) {
         return `Severity ${severity}: ${loop.loopId} is at soft-limit pressure with ${loop.remainingBudgetUsd.toFixed(2)} USD remaining.`;

package/dist/vendor/adapters/claude-cli.d.ts

@@ -33,7 +33,7 @@ export interface AgentCliAdapterOptions {
     workingDirectory?: string;
     /** Timeout for the agent subprocess in ms. Defaults to 300_000 (5 min). */
     timeoutMs?: number;
-    /** Timeout per verification command in ms. Defaults to 60_000 (1 min). */
+    /** Timeout per verification command in ms. Defaults to 120_000 (2 min). */
     verifyTimeoutMs?: number;
     /** Human-readable label shown in loop records. */
     label?: string;

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

@@ -242,12 +242,66 @@ function extractGeminiJsonResult(stdout, modelLabel) {
 function createStreamingUsageInspector(capUsd, modelLabel) {
     const pricing = (modelLabel ? MODEL_PRICING[modelLabel] : undefined) ??
         { inputPer1K: BLENDED_INPUT_COST_PER_1K, outputPer1K: BLENDED_OUTPUT_COST_PER_1K };
+    // Safety margin: terminate at 80% of cap to bound one-turn overshoot.
+    // Without this, a single expensive turn can blow past the cap before the
+    // next check fires (proven live: $1.50 cap → $28.42 actual).
+    const effectiveCapUsd = capUsd * 0.8;
+    // Token-count ceiling fallback: if no usage events are ever parsed (e.g.
+    // Claude changes its stream-json event format), use raw byte volume as a
+    // last-resort circuit breaker. Derived from budget / blended cost per char.
+    const blendedCostPerChar = (pricing.inputPer1K / 1000 / 4) + (pricing.outputPer1K / 1000 / 4);
+    const bytesCeiling = blendedCostPerChar > 0
+        ? Math.ceil((capUsd / blendedCostPerChar) * 2)
+        : 100_000_000;
     let buffer = "";
     let cumulativeUsd = 0;
     let tokensIn = 0;
     let tokensOut = 0;
     let turns = 0;
+    let totalBytes = 0;
+    let usageEventSeen = false;
     let finalResult;
+    const checkBudgetExceeded = (terminate) => {
+        if (capUsd > 0 && cumulativeUsd > effectiveCapUsd) {
+            terminate(`Streaming usage cap exceeded after ${String(turns)} turn(s): cumulative cost ~$${cumulativeUsd.toFixed(4)} ` +
+                `surpassed the per-attempt cap $${capUsd.toFixed(4)} (80% threshold: $${effectiveCapUsd.toFixed(4)}). ` +
+                `Subprocess terminated to bound runaway overspend.`);
+        }
+    };
+    const extractUsageFromEvent = (event, terminate) => {
+        // Check for authoritative total_cost_usd on ANY event — if Claude reports
+        // cost exceeding cap, terminate immediately regardless of event type.
+        if (typeof event.total_cost_usd === "number" && event.total_cost_usd > 0) {
+            cumulativeUsd = event.total_cost_usd;
+            checkBudgetExceeded(terminate);
+            return;
+        }
+        // Extract usage from any event shape that carries it:
+        //   - { type: "assistant", message: { usage: { ... } } }  (original format)
+        //   - { usage: { input_tokens, output_tokens, ... } }      (top-level usage)
+        //   - { message: { usage: { ... } } }                      (nested without type check)
+        const usage = (event.message && typeof event.message === "object" && "usage" in event.message
+            ? event.message.usage
+            : undefined) ??
+            (event.usage && typeof event.usage === "object" ? event.usage : undefined);
+        if (!usage || typeof usage !== "object") {
+            return;
+        }
+        const usageRecord = usage;
+        const turnTokensIn = (usageRecord.input_tokens ?? usageRecord.inputTokens ?? 0) +
+            (usageRecord.cache_read_input_tokens ?? usageRecord.cacheReadInputTokens ?? 0) +
+            (usageRecord.cache_creation_input_tokens ?? usageRecord.cacheCreationInputTokens ?? 0);
+        const turnTokensOut = usageRecord.output_tokens ?? usageRecord.outputTokens ?? 0;
+        if (turnTokensIn === 0 && turnTokensOut === 0) {
+            return;
+        }
+        tokensIn += turnTokensIn;
+        tokensOut += turnTokensOut;
+        turns += 1;
+        usageEventSeen = true;
+        cumulativeUsd += (turnTokensIn / 1000) * pricing.inputPer1K + (turnTokensOut / 1000) * pricing.outputPer1K;
+        checkBudgetExceeded(terminate);
+    };
     const ingestLine = (line, terminate) => {
         const trimmed = line.trim();
         if (!trimmed) {
@@ -260,30 +314,25 @@ function createStreamingUsageInspector(capUsd, modelLabel) {
         catch {
             return;
         }
-        if (event.type === "assistant" && event.message?.usage) {
-            const usage = event.message.usage;
-            const turnTokensIn = (usage.input_tokens ?? usage.inputTokens ?? 0) +
-                (usage.cache_read_input_tokens ?? usage.cacheReadInputTokens ?? 0) +
-                (usage.cache_creation_input_tokens ?? usage.cacheCreationInputTokens ?? 0);
-            const turnTokensOut = usage.output_tokens ?? usage.outputTokens ?? 0;
-            tokensIn += turnTokensIn;
-            tokensOut += turnTokensOut;
-            turns += 1;
-            cumulativeUsd += (turnTokensIn / 1000) * pricing.inputPer1K + (turnTokensOut / 1000) * pricing.outputPer1K;
-            if (capUsd > 0 && cumulativeUsd > capUsd) {
-                terminate(`Streaming usage cap exceeded after ${String(turns)} turn(s): cumulative cost ~$${cumulativeUsd.toFixed(4)} ` +
-                    `surpassed the per-attempt cap $${capUsd.toFixed(4)} (derived from remaining loop budget). ` +
-                    `Subprocess terminated to bound runaway overspend.`);
-            }
-            return;
-        }
+        extractUsageFromEvent(event, terminate);
         if (event.type === "result") {
             finalResult = event;
         }
     };
     return {
         onChunk: (chunk, terminate) => {
-            buffer += chunk.toString("utf8");
+            const chunkStr = chunk.toString("utf8");
+            totalBytes += chunk.byteLength;
+            buffer += chunkStr;
+            // Token-count ceiling fallback: if we've ingested a lot of bytes but
+            // never seen a single usage event, the event format may have changed
+            // and the inspector is silently blind. Terminate as a last resort.
+            if (!usageEventSeen && capUsd > 0 && totalBytes > bytesCeiling) {
+                terminate(`Streaming byte ceiling exceeded (${String(totalBytes)} bytes > ${String(bytesCeiling)} ceiling) ` +
+                    `without any usage events parsed. The Claude stream-json event format may have changed. ` +
+                    `Subprocess terminated as a fallback budget guard for cap $${capUsd.toFixed(4)}.`);
+                return;
+            }
             let newlineIndex = buffer.indexOf("\n");
             while (newlineIndex !== -1) {
                 const line = buffer.slice(0, newlineIndex);
@@ -349,7 +398,7 @@ function inferStructuralClassHint(agentOutput, verificationSummary, exitCode, ob
 export function createAgentCliAdapter(options) {
     const workingDirectory = options.workingDirectory ?? process.cwd();
     const timeoutMs = options.timeoutMs ?? 300_000;
-    const verifyTimeoutMs = options.verifyTimeoutMs ?? 60_000;
+    const verifyTimeoutMs = options.verifyTimeoutMs ?? 120_000;
     const adapterId = `agent-cli:${options.adapterIdSuffix ?? options.command}`;
     const supportsJsonOutput = options.supportsJsonOutput === true;
     const supportsUsageSettlement = supportsJsonOutput || options.command === "codex" || options.command === "gemini";
@@ -883,7 +932,8 @@ function buildPrompt(request) {
         for (const attempt of request.previousAttempts) {
             const failurePart = attempt.failureClass ? ` [${attempt.failureClass}]` : "";
             const interventionPart = attempt.intervention ? ` -> intervention: ${attempt.intervention}` : "";
-            lines.push(`  Attempt ${String(attempt.index)}${failurePart}: ${sanitizeForPrompt(attempt.summary ?? "")}${interventionPart}`);
+            const diagPart = attempt.diagnosticHint ? `\n    DIAGNOSIS: ${sanitizeForPrompt(attempt.diagnosticHint)}` : "";
+            lines.push(`  Attempt ${String(attempt.index)}${failurePart}: ${sanitizeForPrompt(attempt.summary ?? "")}${interventionPart}${diagPart}`);
         }
         lines.push("");
     }
@@ -976,6 +1026,7 @@ function redactSecretsForPrompt(input) {
         .replace(/\bAIza[0-9A-Za-z_-]{30,}\b/gu, "[REDACTED_SECRET]")
         .replace(/-----BEGIN(?:\s+[A-Z0-9]+)*\s+PRIVATE KEY-----[\s\S]*?-----END(?:\s+[A-Z0-9]+)*\s+PRIVATE KEY-----/gu, "[REDACTED_SECRET]")
         .replace(/\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/gu, "[REDACTED_SECRET]")
+        .replace(/\b(?:api[_-]?key|secret|password|token)\s*[:=]\s*["']?[A-Za-z0-9_\-/+=]{8,}["']?/giu, "[REDACTED_SECRET]")
         .replace(/\B\.env(?!\.example\b)(?:\.[A-Za-z0-9._-]+)?\b/giu, "[REDACTED_PATH]");
 }
 function extractStructuredErrors(stderr, stdout) {

package/dist/vendor/adapters/cli-bridge.d.ts

@@ -77,4 +77,10 @@ export interface SpawnPlan {
     args: string[];
 }
 export declare function createSpawnPlan(command: string, args: string[], cwd: string, preserveRawForInjectedSpawn: boolean): SpawnPlan;
+/**
+ * Returns true if the command string contains shell operators that cannot be
+ * passed as literal arguments to spawn(). These must be routed through a
+ * platform shell (cmd.exe /c or sh -c) so the operator is interpreted.
+ */
+export declare function containsShellOperator(command: string): boolean;
 export declare function splitCommand(command: string): string[];

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

@@ -9,6 +9,7 @@ export async function runSubprocess(command, args, options) {
         let outputCapped = false;
         let terminationReason;
         let settled = false;
+        let exited = false;
         let outputBytes = 0;
         const stdoutChunks = [];
         const stderrChunks = [];
@@ -35,12 +36,12 @@ export async function runSubprocess(command, args, options) {
             return;
         }
         const trackOutput = (chunks, chunk) => {
+            if (outputCapped || timedOut || terminationReason) {
+                return;
+            }
             chunks.push(chunk);
             outputBytes += chunk.byteLength;
-            if (options.maxOutputBytes !== undefined &&
-                !outputCapped &&
-                !timedOut &&
-                outputBytes > options.maxOutputBytes) {
+            if (options.maxOutputBytes !== undefined && outputBytes > options.maxOutputBytes) {
                 outputCapped = true;
                 proc.kill("SIGTERM");
             }
@@ -53,10 +54,23 @@ export async function runSubprocess(command, args, options) {
             proc.kill("SIGTERM");
         };
         proc.stdout?.on("data", (chunk) => {
+            if (outputCapped || timedOut || terminationReason) {
+                return;
+            }
             trackOutput(stdoutChunks, chunk);
-            options.onStdoutChunk?.(chunk, terminateEarly);
+            if (options.onStdoutChunk) {
+                try {
+                    options.onStdoutChunk(chunk, terminateEarly);
+                }
+                catch (error) {
+                    terminateEarly(`stdout inspector error: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
         });
         proc.stderr?.on("data", (chunk) => {
+            if (outputCapped || timedOut || terminationReason) {
+                return;
+            }
             trackOutput(stderrChunks, chunk);
         });
         proc.stdin?.on("error", (error) => {
@@ -68,9 +82,15 @@ export async function runSubprocess(command, args, options) {
             stderrChunks.push(Buffer.from(`${error.message}\n`, "utf8"));
         });
         const timer = setTimeout(() => {
+            if (settled || exited || proc.exitCode !== null) {
+                return;
+            }
             timedOut = true;
             proc.kill("SIGTERM");
         }, options.timeoutMs);
+        proc.on("exit", () => {
+            exited = true;
+        });
         proc.on("error", (error) => {
             clearTimeout(timer);
             resolveOnce({ exitCode: 1, stdout: "", stderr: error.message, launched: false });
@@ -117,8 +137,30 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
     const stepOutcomes = [];
     const warnings = [];
     for (const step of steps) {
-        const parts = splitCommand(step.command);
-        const [bin, ...args] = parts;
+        let bin;
+        let args;
+        if (containsShellOperator(step.command)) {
+            // Shell operators (&&, ||, ;, |) cannot be passed as literal arguments
+            // to spawn(). Route through the platform shell so the operator is
+            // interpreted correctly.
+            if (process.platform === "win32") {
+                bin = process.env.ComSpec || "cmd.exe";
+                args = ["/d", "/c", step.command];
+            }
+            else {
+                bin = "sh";
+                args = ["-c", step.command];
+            }
+        }
+        else {
+            const parts = splitCommand(step.command);
+            const first = parts[0];
+            if (!first) {
+                continue;
+            }
+            bin = first;
+            args = parts.slice(1);
+        }
         if (!bin) {
             continue;
         }
@@ -200,6 +242,10 @@ export function resolveGitRepositoryRoot(workingDirectory) {
     if (cached !== undefined) {
         return cached ?? undefined;
     }
+    if (!existsSync(resolvedWorkingDirectory)) {
+        gitRepositoryRootCache.set(resolvedWorkingDirectory, null);
+        return undefined;
+    }
     const visited = [];
     let current = resolvedWorkingDirectory;
     while (true) {
@@ -318,6 +364,44 @@ function windowsPathDirectories() {
         .map((entry) => entry.trim().replace(/^"|"$/g, ""))
         .filter(Boolean);
 }
+/**
+ * Returns true if the command string contains shell operators that cannot be
+ * passed as literal arguments to spawn(). These must be routed through a
+ * platform shell (cmd.exe /c or sh -c) so the operator is interpreted.
+ */
+export function containsShellOperator(command) {
+    // Match &&, ||, ;, or | that are NOT inside quotes.
+    // Simple heuristic: scan outside of single/double quoted regions.
+    let inSingle = false;
+    let inDouble = false;
+    for (let i = 0; i < command.length; i += 1) {
+        const ch = command[i];
+        if (ch === "'" && !inDouble) {
+            inSingle = !inSingle;
+            continue;
+        }
+        if (ch === '"' && !inSingle) {
+            inDouble = !inDouble;
+            continue;
+        }
+        if (inSingle || inDouble) {
+            continue;
+        }
+        if (ch === "&" && command[i + 1] === "&") {
+            return true;
+        }
+        if (ch === "|" && command[i + 1] === "|") {
+            return true;
+        }
+        if (ch === ";") {
+            return true;
+        }
+        if (ch === "|" && command[i + 1] !== "|") {
+            return true;
+        }
+    }
+    return false;
+}
 export function splitCommand(command) {
     const tokens = [];
     let current = "";