@martinloop/mcp 0.8.3 → 0.8.5

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const MARTIN_MCP_PACKAGE_VERSION = "0.8.3";
+export declare const MARTIN_MCP_PACKAGE_VERSION = "0.8.5";

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

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

@@ -63,6 +63,8 @@ export interface AgentCliAdapterOptions {
     streamingTokenCap?: boolean;
     /** Provider detail-token fields are already included in input/output token totals. */
     streamingUsageDetailsIncludedInTotals?: boolean;
+    /** Whether provider usage arrives incrementally or only on a terminal event. */
+    streamingUsageReportingMode?: "incremental" | "terminal";
     /** Estimated floor used by the host to reject impossible token caps before spawning. */
     budgetPreflight?: {
         minimumViableTokens: number;

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

@@ -383,7 +383,7 @@ function extractGeminiJsonResult(stdout, modelLabel) {
         })
     };
 }
-function createStreamingUsageInspector(capUsd, modelLabel, promptTokenEstimate, capTokens, detailTokensIncludedInTotals = false, observedUsageGovernor) {
+function createStreamingUsageInspector(capUsd, modelLabel, promptTokenEstimate, capTokens, detailTokensIncludedInTotals = false, observedUsageGovernor, usageReportingMode = "incremental") {
     let pricingResolution = resolveModelPricing(modelLabel);
     // 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
@@ -424,15 +424,22 @@ function createStreamingUsageInspector(capUsd, modelLabel, promptTokenEstimate,
                 finalObservationPublished = true;
             try {
                 const decision = observedUsageGovernor({ cumulativeUsd, cumulativeTokens, turns, final });
-                if (decision.action === "terminate") {
+                if (decision.action === "terminate" && !(usageReportingMode === "terminal" && final)) {
                     terminate(`Parent observed-usage governor terminated the subprocess: ${decision.reason}.`);
                 }
             }
             catch (error) {
-                terminate(`Parent observed-usage governor failed closed: ${error instanceof Error ? error.message : String(error)}.`);
+                if (!(usageReportingMode === "terminal" && final)) {
+                    terminate(`Parent observed-usage governor failed closed: ${error instanceof Error ? error.message : String(error)}.`);
+                }
             }
             return;
         }
+        // Codex reports authoritative usage on turn.completed, after the provider
+        // turn and its workspace edits have already finished. Record that terminal
+        // settlement, but do not kill and discard completed work at this point.
+        if (usageReportingMode === "terminal" && final)
+            return;
         if (capTokens !== undefined && capTokens > 0 && cumulativeTokens > capTokens) {
             terminate(`Streaming token lease exceeded after ${String(turns)} turn(s): observed ${String(cumulativeTokens)} tokens ` +
                 `surpassed the per-attempt token cap ${String(capTokens)}. Subprocess terminated to prevent additional token usage.`);
@@ -557,7 +564,7 @@ function createStreamingUsageInspector(capUsd, modelLabel, promptTokenEstimate,
             }
             return;
         }
-        extractUsageFromEvent(event, terminate);
+        extractUsageFromEvent(event, terminate, usageReportingMode === "terminal" && event.type === "turn.completed");
     };
     return {
         onChunk: (chunk, terminate) => {
@@ -572,7 +579,8 @@ function createStreamingUsageInspector(capUsd, modelLabel, promptTokenEstimate,
             const bytesCeiling = blendedCostPerChar && blendedCostPerChar > 0
                 ? Math.ceil((capUsd / blendedCostPerChar) * 2)
                 : undefined;
-            if (!usageEventSeen && capUsd > 0 && bytesCeiling !== undefined && totalBytes > bytesCeiling) {
+            if (usageReportingMode === "incremental" &&
+                !usageEventSeen && capUsd > 0 && bytesCeiling !== undefined && 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)}.`);
@@ -582,7 +590,8 @@ function createStreamingUsageInspector(capUsd, modelLabel, promptTokenEstimate,
             // without a single usage event, estimate spend from byte volume and
             // enforce the cap. This catches cases where Claude's event format
             // changed but bytes are still flowing.
-            if (!usageEventSeen &&
+            if (usageReportingMode === "incremental" &&
+                !usageEventSeen &&
                 capUsd > 0 &&
                 firstChunkAt !== undefined &&
                 Date.now() - firstChunkAt > USAGE_BLIND_TIMEOUT_MS &&
@@ -726,7 +735,7 @@ export function createAgentCliAdapter(options) {
             const streamingUsage = options.streamingUsageCap &&
                 (request.context.remainingBudgetUsd > 0 ||
                     (options.streamingTokenCap && (request.context.remainingTokens ?? 0) > 0))
-                ? createStreamingUsageInspector(request.context.remainingBudgetUsd, options.model ?? options.command, estimatedUsage.tokensIn, options.streamingTokenCap ? request.context.remainingTokens : undefined, options.streamingUsageDetailsIncludedInTotals, request.observedUsageGovernor)
+                ? createStreamingUsageInspector(request.context.remainingBudgetUsd, options.model ?? options.command, estimatedUsage.tokensIn, options.streamingTokenCap ? request.context.remainingTokens : undefined, options.streamingUsageDetailsIncludedInTotals, request.observedUsageGovernor, options.streamingUsageReportingMode)
                 : undefined;
             const agentResult = await runSubprocess(options.executionCommand ?? options.command, args, {
                 cwd: workingDirectory,

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

@@ -51,6 +51,7 @@ export function createCodexCliAdapter(options = {}) {
         streamingUsageCap: true,
         streamingTokenCap: true,
         streamingUsageDetailsIncludedInTotals: true,
+        streamingUsageReportingMode: "terminal",
         budgetPreflight: {
             minimumViableTokens: CODEX_MINIMUM_VIABLE_TOKEN_BUDGET,
             basis: CODEX_TOKEN_BUDGET_PREFLIGHT_BASIS

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

@@ -57,4 +57,11 @@ export declare function spawnSupervisedProcess(command: string, args: readonly s
 export declare function spawnSupervisedProcessForTest(command: string, args: readonly string[], options: SpawnSupervisedProcessOptions & {
     spawnImpl: ProcessSpawnLike;
 }, seams: ProcessSupervisorTestSeams): Promise<SupervisedProcessResult>;
+/**
+ * Classify an OS process-table snapshot with PID, PGID and STAT columns.
+ * POSIX Z means terminated but not yet reaped; other states remain live.
+ * Malformed or empty output must never assert cleanup success.
+ * @internal - deterministic pure classification for process-supervisor tests
+ */
+export declare function classifyPosixProcessGroupSnapshot(output: string, ownedGroupPid: number): "closed" | "alive" | "absent" | "invalid";
 export {};

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

@@ -327,14 +327,21 @@ async function terminatePosixGroupAfterRootExit(pid, killGroup, graceMs, waitImp
     const initial = probePosixProcessGroup(target, killGroup);
     if (initial === "closed")
         return { state: "closed" };
-    if (initial instanceof Error)
+    if (initial instanceof Error) {
+        if (isErrno(initial, "EPERM") && await confirmInactivePosixGroup(pid, killGroup)) {
+            return { state: "closed" };
+        }
         return cleanupFailure("termination_failed", initial);
+    }
     try {
         killGroup(target, "SIGTERM");
     }
     catch (error) {
         if (isErrno(error, "ESRCH"))
             return { state: "closed" };
+        if (isErrno(error, "EPERM") && await confirmInactivePosixGroup(pid, killGroup)) {
+            return { state: "closed" };
+        }
         return cleanupFailure("termination_failed", error);
     }
     if (await waitForPosixGroupExit(target, killGroup, graceMs, waitImpl))
@@ -345,14 +352,30 @@ async function terminatePosixGroupAfterRootExit(pid, killGroup, graceMs, waitImp
     catch (error) {
         if (isErrno(error, "ESRCH"))
             return { state: "closed" };
+        if (isErrno(error, "EPERM") && await confirmInactivePosixGroup(pid, killGroup)) {
+            return { state: "closed" };
+        }
         return cleanupFailure("termination_failed", error);
     }
     if (await waitForPosixGroupExit(target, killGroup, graceMs, waitImpl))
         return { state: "closed" };
+    // A reparented, already-terminated descendant can remain as a zombie in the
+    // process table. On POSIX, kill(-pgid, 0) still sees that process group even
+    // though its remaining members cannot execute code. Prove the absence of
+    // *runnable* group members rather than treating an unreapable zombie as live.
+    // Do not turn an unreadable/ambiguous process snapshot into success.
+    const snapshot = await inspectPosixProcessGroupMembers(pid);
+    if (snapshot === "closed" || (snapshot === "absent" && probePosixProcessGroup(target, killGroup) === "closed")) {
+        return { state: "closed" };
+    }
+    if (snapshot instanceof Error)
+        return cleanupFailure("termination_failed", snapshot);
     return {
         state: "failed",
         code: "tree_close_timeout",
-        message: "Owned POSIX process group remained live after SIGTERM and SIGKILL."
+        message: snapshot === "invalid"
+            ? "Could not prove owned POSIX group closure from the process table."
+            : "Owned POSIX process group still has live members after SIGTERM and SIGKILL."
     };
 }
 async function waitForPosixGroupExit(target, killGroup, durationMs, waitImpl) {
@@ -367,6 +390,14 @@ async function waitForPosixGroupExit(target, killGroup, durationMs, waitImpl) {
     }
     return probePosixProcessGroup(target, killGroup) === "closed";
 }
+async function confirmInactivePosixGroup(ownedGroupPid, killGroup) {
+    const snapshot = await inspectPosixProcessGroupMembers(ownedGroupPid);
+    if (snapshot === "closed")
+        return true; // Observed owned members are all defunct zombies.
+    // An absent group is not proof on its own after EPERM. Require an ESRCH re-probe.
+    return snapshot === "absent"
+        && probePosixProcessGroup(-ownedGroupPid, killGroup) === "closed";
+}
 function probePosixProcessGroup(target, killGroup) {
     try {
         killGroup(target, 0);
@@ -378,6 +409,49 @@ function probePosixProcessGroup(target, killGroup) {
         return error instanceof Error ? error : new Error(String(error));
     }
 }
+/**
+ * Classify an OS process-table snapshot with PID, PGID and STAT columns.
+ * POSIX Z means terminated but not yet reaped; other states remain live.
+ * Malformed or empty output must never assert cleanup success.
+ * @internal - deterministic pure classification for process-supervisor tests
+ */
+export function classifyPosixProcessGroupSnapshot(output, ownedGroupPid) {
+    if (!isOwnedPid(ownedGroupPid))
+        return "invalid";
+    let observed = 0;
+    let matchingGroupMembers = 0;
+    for (const line of output.split(/\r?\n/u)) {
+        if (!line.trim())
+            continue;
+        const match = /^\s*(\d+)\s+(\d+)\s+(\S+)\s*$/u.exec(line);
+        if (!match)
+            return "invalid";
+        observed += 1;
+        if (Number(match[2]) === ownedGroupPid) {
+            matchingGroupMembers += 1;
+            if (!match[3].startsWith("Z"))
+                return "alive";
+        }
+    }
+    if (observed === 0)
+        return "invalid";
+    return matchingGroupMembers > 0 ? "closed" : "absent";
+}
+async function inspectPosixProcessGroupMembers(ownedGroupPid) {
+    return new Promise((resolveResult) => {
+        execFile("ps", ["-axo", "pid=,pgid=,stat="], {
+            encoding: "utf8",
+            timeout: 2_000,
+            maxBuffer: 8 * 1024 * 1024
+        }, (error, stdout) => {
+            if (error) {
+                resolveResult(error);
+                return;
+            }
+            resolveResult(classifyPosixProcessGroupSnapshot(stdout, ownedGroupPid));
+        });
+    });
+}
 function isErrno(error, code) {
     return typeof error === "object" && error !== null && "code" in error
         && String(error.code) === code;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@martinloop/mcp",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "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.3",
+  "version": "0.8.5",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@martinloop/mcp",
-      "version": "0.8.3",
+      "version": "0.8.5",
       "transport": {
         "type": "stdio"
       }