@martinloop/mcp 0.8.9 → 0.8.10

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const MARTIN_MCP_PACKAGE_VERSION = "0.8.9";
+export declare const MARTIN_MCP_PACKAGE_VERSION = "0.8.10";

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.8.9";
+export const MARTIN_MCP_PACKAGE_VERSION = "0.8.10";

package/dist/vendor/adapters/process-supervisor.d.ts

@@ -64,4 +64,16 @@ export declare function spawnSupervisedProcessForTest(command: string, args: rea
  * @internal - deterministic pure classification for process-supervisor tests
  */
 export declare function classifyPosixProcessGroupSnapshot(output: string, ownedGroupPid: number): "closed" | "alive" | "absent" | "invalid";
+type WindowsProcessTreeRow = {
+    ProcessId: number;
+    ParentProcessId: number;
+};
+/**
+ * Classify descendants that remain visible after a failed termination attempt.
+ * Two point-in-time snapshots cannot prove closure across the interval because
+ * a descendant may be created and reparented between them. Absence is therefore
+ * indeterminate and must retain the original termination failure.
+ * @internal - deterministic pure classification for process-supervisor tests
+ */
+export declare function classifyWindowsDescendantPostcondition(initialRows: WindowsProcessTreeRow[], postTerminationRows: WindowsProcessTreeRow[], rootPid: number): "closed" | "alive" | "invalid";
 export {};

package/dist/vendor/adapters/process-supervisor.js

@@ -456,6 +456,39 @@ function isErrno(error, code) {
     return typeof error === "object" && error !== null && "code" in error
         && String(error.code) === code;
 }
+/**
+ * Classify descendants that remain visible after a failed termination attempt.
+ * Two point-in-time snapshots cannot prove closure across the interval because
+ * a descendant may be created and reparented between them. Absence is therefore
+ * indeterminate and must retain the original termination failure.
+ * @internal - deterministic pure classification for process-supervisor tests
+ */
+export function classifyWindowsDescendantPostcondition(initialRows, postTerminationRows, rootPid) {
+    if (!isOwnedPid(rootPid))
+        return "invalid";
+    const allRows = [...initialRows, ...postTerminationRows];
+    if (allRows.some((row) => !isOwnedPid(row.ProcessId) || !Number.isSafeInteger(row.ParentProcessId))) {
+        return "invalid";
+    }
+    const ownedLineage = new Set([rootPid]);
+    const expandLineage = (rows) => {
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (const row of rows) {
+                if (ownedLineage.has(row.ParentProcessId) && !ownedLineage.has(row.ProcessId)) {
+                    ownedLineage.add(row.ProcessId);
+                    changed = true;
+                }
+            }
+        }
+    };
+    expandLineage(initialRows);
+    expandLineage(postTerminationRows);
+    return postTerminationRows.some((row) => ownedLineage.has(row.ProcessId))
+        ? "alive"
+        : "invalid";
+}
 async function terminateWindowsDescendantsAfterRootExit(rootPid, graceMs, waitImpl) {
     let rows;
     try {
@@ -471,11 +504,16 @@ async function terminateWindowsDescendantsAfterRootExit(rootPid, graceMs, waitIm
         childrenByParent.set(row.ParentProcessId, children);
     }
     const directChildren = childrenByParent.get(rootPid) ?? [];
+    let taskkillFailure;
     for (const childPid of directChildren) {
         const failure = await runTaskkill(childPid, spawnProcess, graceMs, waitImpl);
-        if (failure)
-            return failure;
+        taskkillFailure ??= failure;
     }
+    // Once taskkill has failed, a later process-table snapshot cannot prove the
+    // complete descendant set closed. Return the bounded failure immediately;
+    // starting another PowerShell query here could otherwise stall cleanup.
+    if (taskkillFailure)
+        return taskkillFailure;
     return { state: "closed" };
 }
 function readWindowsProcessTree() {

package/dist/vendor/adapters/verifier-only.js

@@ -49,6 +49,10 @@ export function createVerifierOnlyAdapter(options = {}) {
             providerId: "verifier",
             model: "verify-only",
             transport: "cli",
+            budgetPreflight: {
+                pricePerMTokenUsd: 0,
+                basis: "Verifier-only execution launches no model provider."
+            },
             capabilities: createAdapterCapabilities({
                 usageSettlement: true,
                 diffArtifacts: true,

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

@@ -206,6 +206,8 @@ export interface MartinAdapter {
         budgetPreflight?: {
             /** Estimated token floor required before the adapter can report first-turn usage. */
             minimumViableTokens?: number;
+            /** Adapter-specific provider price used by the admission estimate. */
+            pricePerMTokenUsd?: number;
             basis?: string;
         };
         capabilities?: {

package/dist/vendor/core/index.js

@@ -880,6 +880,7 @@ export async function runMartin(input) {
                     remainingBudgetUsd: distilled.constraints.remainingBudgetUsd,
                     remainingTokens: distilled.constraints.remainingTokens,
                     minimumViableTokens: executingAdapter.metadata.budgetPreflight?.minimumViableTokens,
+                    pricePerMTokenUsd: executingAdapter.metadata.budgetPreflight?.pricePerMTokenUsd,
                     // D2: pass remaining iterations so the preflight can compute a budget-aware cap
                     // rather than using the old rigid maxUsd * 0.25 that blocked viable attempts.
                     remainingIterations: distilled.constraints.remainingIterations

package/dist/vendor/core/policy.js

@@ -385,7 +385,10 @@ function roundUsd(value) {
     return Math.round(value * 100) / 100;
 }
 export function evaluateBudgetPreflight(input) {
-    const pricePerMToken = input.pricePerMTokenUsd ?? 3.0;
+    const declaredPrice = input.pricePerMTokenUsd;
+    const validDeclaredPrice = declaredPrice === undefined
+        || (Number.isFinite(declaredPrice) && declaredPrice >= 0);
+    const pricePerMToken = validDeclaredPrice ? (declaredPrice ?? 3.0) : 3.0;
     const rawPromptTokens = Math.ceil(input.promptCharCount / 4);
     const estimatedPromptTokens = Math.ceil(rawPromptTokens * 1.2);
     const estimatedToolOverheadTokens = 800 + input.attemptCount * 200;
@@ -407,6 +410,13 @@ export function evaluateBudgetPreflight(input) {
         estimatedAttemptCostUsd,
         provenance
     };
+    if (!validDeclaredPrice) {
+        return {
+            allowed: false,
+            reason: "Preflight: invalid adapter price; pricePerMTokenUsd must be finite and non-negative.",
+            estimate
+        };
+    }
     if (input.remainingTokens !== undefined
         && estimatedMinimumViableTokens > 0
         && estimatedTotalTokens > input.remainingTokens) {

package/dist/vendor/core/verified-handoff.js

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: MartinLoop contributors
 // SPDX-License-Identifier: Apache-2.0
 import { createHash } from "node:crypto";
+import { posix, win32 } from "node:path";
 // ---------------------------------------------------------------------------
 // Mapping: granular TestIntegrityStatus → public TestIntegrityVerdict
 //
@@ -88,6 +89,65 @@ export function deriveVerifiedHandoffLifecycleTruth(loop) {
         evidenceAvailable: true,
     };
 }
+function sameOptionalVerifierFilesystemPath(actual, expected) {
+    if (actual === undefined || expected === undefined) {
+        return actual === expected;
+    }
+    return sameVerifierFilesystemPath(actual, expected);
+}
+function classifyVerifierFilesystemPath(value) {
+    // Persisted Windows bindings are expected to be drive-absolute or UNC.
+    // Do not use win32.isAbsolute() here because it also classifies POSIX-style
+    // root paths such as "/repo" as Windows root-relative paths.
+    if (/^[A-Za-z]:[\\/]/u.test(value) || /^\\\\/u.test(value) || /^\/\//u.test(value)) {
+        return "windows";
+    }
+    if (value.startsWith("/")) {
+        return "posix";
+    }
+    return "relative";
+}
+function stripTrailingVerifierSeparators(value, kind) {
+    if (kind === "windows") {
+        // Preserve drive roots (C:\\) and UNC share roots while removing harmless
+        // trailing separators from ordinary persisted paths.
+        if (/^[a-z]:\\$/iu.test(value) || /^\\\\[^\\]+\\[^\\]+\\?$/u.test(value)) {
+            return value;
+        }
+        return value.replace(/[\\/]+$/u, "");
+    }
+    if (kind === "posix") {
+        return value === "/" ? value : value.replace(/\/+$/u, "");
+    }
+    return value;
+}
+function normalizeVerifierFilesystemPath(value) {
+    const kind = classifyVerifierFilesystemPath(value);
+    if (kind === "windows") {
+        return {
+            kind,
+            value: stripTrailingVerifierSeparators(win32.normalize(value), kind).toLowerCase(),
+        };
+    }
+    if (kind === "posix") {
+        return {
+            kind,
+            value: stripTrailingVerifierSeparators(posix.normalize(value), kind),
+        };
+    }
+    // Relative verifier bindings are legacy/non-canonical. Normalize only their
+    // separators/dot segments and keep comparison case-sensitive/fail-closed.
+    return {
+        kind,
+        value: stripTrailingVerifierSeparators(posix.normalize(value.replace(/\\/gu, "/")), kind),
+    };
+}
+function sameVerifierFilesystemPath(actual, expected) {
+    const normalizedActual = normalizeVerifierFilesystemPath(actual);
+    const normalizedExpected = normalizeVerifierFilesystemPath(expected);
+    return (normalizedActual.kind === normalizedExpected.kind &&
+        normalizedActual.value === normalizedExpected.value);
+}
 export function verifierActuallyPassed(evidence, expected) {
     if (!evidence?.passed || !evidence.binding || !evidence.steps) {
         return false;
@@ -98,8 +158,8 @@ export function verifierActuallyPassed(evidence, expected) {
     if (evidence.binding.runId !== expected.runId ||
         evidence.binding.workspaceId !== expected.workspaceId ||
         (evidence.binding.attemptId ?? undefined) !== (expected.attemptId ?? undefined) ||
-        evidence.binding.cwd !== expected.cwd ||
-        (evidence.binding.runsRoot ?? undefined) !== (expected.runsRoot ?? undefined) ||
+        !sameVerifierFilesystemPath(evidence.binding.cwd, expected.cwd) ||
+        !sameOptionalVerifierFilesystemPath(evidence.binding.runsRoot, expected.runsRoot) ||
         (evidence.binding.executionProfile ?? undefined) !== (expected.executionProfile ?? undefined) ||
         JSON.stringify(evidence.binding.allowedNetworkDomains ?? []) !== JSON.stringify(expected.allowedNetworkDomains ?? []) ||
         JSON.stringify(evidence.binding.commands) !== JSON.stringify(expected.commands)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@martinloop/mcp",
-  "version": "0.8.9",
+  "version": "0.8.10",
   "mcpName": "io.github.Keesan12/martin-loop",
   "private": false,
   "type": "module",
@@ -74,13 +74,9 @@
     "mcpb:smoke": "node ./mcpb/smoke-mcpb.mjs"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@modelcontextprotocol/sdk": "^1.32.2",
     "@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"
+    "zod": "^4.6.7"
   },
   "devDependencies": {
     "@anthropic-ai/mcpb": "2.1.2",

package/server.json

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