@martinloop/mcp 0.6.3 → 0.6.5

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const MARTIN_MCP_PACKAGE_VERSION = "0.6.3";
+export declare const MARTIN_MCP_PACKAGE_VERSION = "0.6.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.6.3";
+export const MARTIN_MCP_PACKAGE_VERSION = "0.6.5";

package/dist/server.d.ts

@@ -20,6 +20,67 @@ import { type Server as NodeHttpServer } from "node:http";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 export type MartinMcpToolProfile = "full" | "directory";
 export declare function shouldExposeMartinTool(name: string, profile: MartinMcpToolProfile): boolean;
+/** @internal Test-only export — validates discovery schema shape. */
+export declare const __loopPreviewSchemaForTests: {
+    readonly type: "object";
+    readonly additionalProperties: true;
+    readonly properties: {
+        readonly loopId: {
+            readonly type: "string";
+        };
+        readonly title: {
+            readonly type: "string";
+        };
+        readonly objective: {
+            readonly type: "string";
+        };
+        readonly status: {
+            readonly type: "string";
+        };
+        readonly lifecycleState: {
+            readonly type: "string";
+        };
+        readonly createdAt: {
+            readonly type: "string";
+        };
+        readonly updatedAt: {
+            readonly type: "string";
+        };
+        readonly attempts: {
+            readonly type: "integer";
+        };
+        readonly costUsd: {
+            readonly type: "number";
+        };
+        readonly avoidedUsd: {
+            readonly type: "number";
+        };
+        readonly pressure: {
+            readonly type: "string";
+        };
+        readonly shouldStop: {
+            readonly type: "boolean";
+        };
+        readonly remainingBudgetUsd: {
+            readonly type: "number";
+        };
+        readonly remainingIterations: {
+            readonly type: "integer";
+        };
+        readonly remainingTokens: {
+            readonly type: "integer";
+        };
+        readonly lastAttempt: {
+            readonly type: "object";
+            readonly additionalProperties: true;
+        };
+        readonly activeAttemptId: {
+            readonly type: "string";
+            readonly description: "ID of the currently active attempt, when a run is in progress.";
+        };
+    };
+    readonly required: readonly ["loopId", "title", "objective", "status", "lifecycleState", "attempts", "costUsd", "avoidedUsd", "pressure", "shouldStop", "remainingBudgetUsd", "remainingIterations"];
+};
 export declare function createMartinMcpServer(serverInfo?: {
     name?: string;
     version?: string;

package/dist/server.js

@@ -86,6 +86,10 @@ const loopPreviewSchema = {
         lastAttempt: {
             type: "object",
             additionalProperties: true
+        },
+        activeAttemptId: {
+            type: "string",
+            description: "ID of the currently active attempt, when a run is in progress."
         }
     },
     required: [
@@ -103,6 +107,8 @@ const loopPreviewSchema = {
         "remainingIterations"
     ]
 };
+/** @internal Test-only export — validates discovery schema shape. */
+export const __loopPreviewSchemaForTests = loopPreviewSchema;
 const budgetSchema = {
     type: "object",
     additionalProperties: false,

package/dist/tools/tool-support.d.ts

@@ -37,6 +37,9 @@ export interface LoopPreview {
     remainingTokens?: number;
     lastAttempt?: AttemptSummary;
     routingEconomics?: Record<string, unknown>;
+    /** Present when an attempt is executing but not yet in the completed attempts list.
+     * Indicates the backend is actively running — callers must NOT start a concurrent recovery run. */
+    activeAttemptId?: string;
 }
 export interface AttemptArtifactFiles {
     directory: string;

package/dist/tools/tool-support.js

@@ -141,6 +141,19 @@ export function buildLoopPreview(loop) {
         attemptsUsed: loop.attempts.length
     });
     const lastAttempt = loop.attempts.at(-1);
+    // Detect an in-flight attempt: an attempt.started event whose attemptId has
+    // no matching entry in loop.attempts (completed attempts only). This is the
+    // signal callers need to distinguish "backend actively executing" from
+    // "nothing has started yet" after a client transport timeout.
+    const completedAttemptIds = new Set(loop.attempts.map((a) => a.attemptId).filter(Boolean));
+    const activeAttemptEvent = (loop.events ?? [])
+        .filter((e) => e.type === "attempt.started")
+        .at(-1);
+    const activeAttemptId = activeAttemptEvent !== undefined &&
+        typeof activeAttemptEvent.payload["attemptId"] === "string" &&
+        !completedAttemptIds.has(activeAttemptEvent.payload["attemptId"])
+        ? activeAttemptEvent.payload["attemptId"]
+        : undefined;
     return {
         loopId: loop.loopId,
         title: loop.task?.title ?? loop.loopId,
@@ -161,7 +174,8 @@ export function buildLoopPreview(loop) {
             ? { remainingTokens: costState.remainingTokens }
             : {}),
         ...(lastAttempt ? { lastAttempt: buildAttemptSummary(lastAttempt) } : {}),
-        ...(loop.routingEconomics ? { routingEconomics: buildRoutingEconomicsSummary(loop.routingEconomics) } : {})
+        ...(loop.routingEconomics ? { routingEconomics: buildRoutingEconomicsSummary(loop.routingEconomics) } : {}),
+        ...(activeAttemptId !== undefined ? { activeAttemptId } : {})
     };
 }
 function buildRoutingEconomicsSummary(economics) {

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

@@ -33,24 +33,28 @@ function flagContext(help, flag) {
     const index = lines.findIndex((line) => line.includes(flag));
     if (index < 0)
         return "";
-    return lines.slice(Math.max(0, index - 1), Math.min(lines.length, index + 3)).join("\n");
+    let end = index + 1;
+    while (end < lines.length && end < index + 24) {
+        if (/^\s*(?:-\w,\s*)?--[a-z][\w-]*/iu.test(lines[end] ?? ""))
+            break;
+        end += 1;
+    }
+    return lines.slice(Math.max(0, index - 1), end).join("\n");
 }
 function parseAdvertisedValues(help, flag) {
     const flagIndex = help.indexOf(flag);
     if (flagIndex < 0)
         return [];
     const tail = help.slice(flagIndex);
-    const nextFlagOffset = tail.slice(flag.length).search(/\n\s*-/u);
+    const nextFlagOffset = tail.slice(flag.length).search(/\n\s*(?:-\w,\s*)?--[a-z][\w-]*/iu);
     const scoped = nextFlagOffset < 0
         ? tail
         : tail.slice(0, flag.length + nextFlagOffset);
-    const match = scoped.match(/possible values:\s*([^\]\n]+)/iu);
-    if (!match?.[1])
-        return [];
-    return match[1]
-        .split(",")
-        .map((value) => value.trim().replace(/[\].]$/u, ""))
-        .filter(Boolean);
+    const inline = scoped.match(/possible values:[ \t]*([^\]\r\n]+)/iu)?.[1];
+    if (inline?.trim()) {
+        return inline.split(",").map((value) => value.trim().replace(/[\].]$/u, "")).filter(Boolean);
+    }
+    return [...scoped.matchAll(/^\s*-\s+([a-z][a-z0-9-]*):/gimu)].map((match) => match[1]).filter(Boolean);
 }
 function buildInjectedSpawnPlan(binaryPath, args, platform) {
     if (platform !== "win32")
@@ -214,7 +218,8 @@ export function resolveCodexAutonomyCandidates(profile, intent = DEFAULT_AGENT_E
             binaryPath: profile.binaryPath,
             intent,
             strategy: "sandbox+approval",
-            sandboxValue: "workspace-write"
+            sandboxValue: "workspace-write",
+            ...(profile.approvalPolicy?.values?.includes("never") ? { approvalValue: "never" } : {})
         });
     }
     // Keep provider automation as a compatibility fallback. It is never trusted

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

@@ -1,7 +1,7 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, extname, join, resolve } from "node:path";
-import { tmpdir } from "node:os";
+import { userInfo } from "node:os";
 import { normalizeProviderExecutionTimeoutMs } from "../contracts/index.js";
 import { createSpawnPlan, resolveNpmShimScript } from "./cli-bridge.js";
 import { buildCodexExecArgs, buildCodexStdin, cacheCodexCapabilityProfile, probeCodexCapabilities, resolveCodexAutonomyCandidates } from "./codex-capabilities.js";
@@ -437,7 +437,10 @@ export function probeCodexLaunch(input) {
             for (const transport of transports) {
                 const marker = `.martin-codex-write-probe-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}.tmp`;
                 const markerPath = join(input.workingDirectory, marker);
-                const outsideRoot = mkdtempSync(join(tmpdir(), "martin-codex-outside-probe-"));
+                // Codex workspace-write intentionally permits the host temp directory,
+                // and the repo can be nested inside a broader writable host workspace.
+                // Probe from the user-home boundary so the denial canary is outside both.
+                const outsideRoot = mkdtempSync(join(userInfo().homedir, ".martin-codex-outside-probe-"));
                 const outsideMarkerPath = join(outsideRoot, ".martin-codex-outside-probe.tmp");
                 const prompt = buildMarkerPrompt(marker, outsideMarkerPath);
                 let args;

package/dist/vendor/core/exit-signal.d.ts

@@ -67,6 +67,14 @@ export declare function readAllExitSignals(runsRoot: string, runId: string): Pro
 /** Read a single signal kind; returns undefined when absent. */
 export declare function readExitSignal(runsRoot: string, runId: string, kind: "human_interrupt" | "external_event"): Promise<ExitSignalV1 | undefined>;
 export declare function createFileExitSignalSource(runsRoot: string): ExitSignalSource;
+/**
+ * Returns true when a signal should abort the active attempt and terminate the
+ * run.  external_event with disposition "satisfied" is non-terminal: the run
+ * observes the event (for durable audit) but continues to its natural
+ * goal/verification completion.  Only "superseded" and "cancelled" dispositions
+ * are terminal external events.
+ */
+export declare function isTerminalExitSignal(signal: ExitSignalV1): boolean;
 /**
  * Polls for any exit signal and calls onSignal with the full set when any
  * new signal appears.  Returns a dispose function — MUST be called on every

package/dist/vendor/core/exit-signal.js

@@ -166,6 +166,21 @@ export function createFileExitSignalSource(runsRoot) {
         poll: async (runId) => readAllExitSignals(runsRoot, runId)
     };
 }
+/**
+ * Returns true when a signal should abort the active attempt and terminate the
+ * run.  external_event with disposition "satisfied" is non-terminal: the run
+ * observes the event (for durable audit) but continues to its natural
+ * goal/verification completion.  Only "superseded" and "cancelled" dispositions
+ * are terminal external events.
+ */
+export function isTerminalExitSignal(signal) {
+    if (signal.kind === "human_interrupt")
+        return true;
+    if (signal.kind === "external_event") {
+        return signal.externalEvent?.disposition !== "satisfied";
+    }
+    return false;
+}
 /**
  * Polls for any exit signal and calls onSignal with the full set when any
  * new signal appears.  Returns a dispose function — MUST be called on every
@@ -204,7 +219,11 @@ export function startExitSignalMonitor(input) {
             if (signals.length > lastCount) {
                 lastCount = signals.length;
                 input.onSignal(signals);
-                input.controller.abort(signals);
+                // Only abort the run controller for terminal signals.
+                // A satisfied external event is observed but must not abort the run.
+                if (signals.some(isTerminalExitSignal)) {
+                    input.controller.abort(signals);
+                }
             }
         })
             .catch((err) => {

package/dist/vendor/core/exits.js

@@ -85,8 +85,12 @@ export function evaluateExitPolicy(policy, snapshot) {
             requestedBy: snapshot.humanInterrupt.requestedBy
         });
     }
-    // 2. External event
-    if (policy.externalEvent.enabled && snapshot.externalEvent !== undefined) {
+    // 2. External event — only terminal when disposition is not "satisfied".
+    // A satisfied disposition means the external observer confirmed the goal is
+    // met; the run must continue to verification rather than short-circuit here.
+    if (policy.externalEvent.enabled &&
+        snapshot.externalEvent !== undefined &&
+        snapshot.externalEvent.disposition !== "satisfied") {
         push("external_event", snapshot.externalEvent.reason ?? "External terminal event observed.", {
             source: snapshot.externalEvent.source,
             event: snapshot.externalEvent.event,
@@ -188,9 +192,8 @@ export function toLegacyExitDecision(evaluation, externalDisposition) {
     if (primary === "goal_met") {
         return completed(reason, primary, evaluation);
     }
-    if (primary === "external_event" && externalDisposition === "satisfied") {
-        return completed(reason, primary, evaluation);
-    }
+    // Note: external_event with disposition "satisfied" never reaches here —
+    // evaluateExitPolicy skips it so the run continues to verification.
     if (primary === "human_interrupt") {
         return exited("human_escalation", reason, primary, evaluation);
     }

package/dist/vendor/core/index.js

@@ -1,4 +1,3 @@
-import { spawnSync } from "node:child_process";
 import { DEFAULT_AGENT_EXECUTION_INTENT, normalizeProviderExecutionTimeoutMs, appendLoopEvent, createLoopRecord } from "../contracts/index.js";
 import { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluateCostGovernor, evaluateBudgetPreflight, inferExit, nextPolicyPhase, policyPhaseToLifecycleState, scorePatchDecision, selectRecoveryRecipe } from "./policy.js";
 import { evaluateChangeApprovalLeash, evaluateFilesystemLeash, evaluateSecretLeash, redactSecretsFromText, resolveExecutionProfile, evaluateVerificationLeash } from "./leash.js";
@@ -7,7 +6,7 @@ import { captureRollbackBoundary, listAttemptChangedFilesSinceBoundary, restoreR
 import { compilePromptPacket } from "./compiler.js";
 import { makeLedgerEvent, resolveRunsRoot, runDir } from "./persistence/index.js";
 import { createDefaultExitPolicy, evaluateExitPolicy, hashProgressState, toLegacyExitDecision } from "./exits.js";
-import { createFileExitSignalSource, startExitSignalMonitor } from "./exit-signal.js";
+import { createFileExitSignalSource, isTerminalExitSignal, startExitSignalMonitor } from "./exit-signal.js";
 import { persistTerminationEnvelope } from "./termination-store.js";
 import { calculateLoopAvoidedUsd } from "./savings.js";
 import { runContextIntegrityPrecheck } from "./context-integrity.js";
@@ -392,8 +391,13 @@ export async function runMartin(input) {
         for (const s of signals) {
             if (s.kind === "human_interrupt")
                 observedHumanInterrupt = s;
-            else if (s.kind === "external_event" && s.externalEvent !== undefined)
+            else if (s.kind === "external_event" && s.externalEvent !== undefined) {
+                if (observedExternalEvent !== undefined &&
+                    observedExternalEvent.disposition !== "satisfied" &&
+                    s.externalEvent.disposition === "satisfied")
+                    continue;
                 observedExternalEvent = s.externalEvent;
+            }
         }
     }
     function queueControlDiagnostic(code, details) {
@@ -419,7 +423,11 @@ export async function runMartin(input) {
         pollIntervalMs: input.exitSignalPollIntervalMs,
         onSignal: (signals) => {
             observeSignals(signals);
-            activeAttemptController?.abort(signals);
+            // Only abort the active attempt for terminal signals.
+            // A satisfied external event is recorded but must not abort the provider.
+            if (signals.some(isTerminalExitSignal)) {
+                activeAttemptController?.abort(signals);
+            }
         },
         onDiagnostic: (diagnostics) => {
             queueControlDiagnostic("exit_signal_invalid", diagnostics.map(({ kind, error }) => ({ kind, error })));
@@ -776,6 +784,12 @@ export async function runMartin(input) {
                     capturedAt: attemptStartedAt
                 })
                 : undefined;
+            // Persist attempt.started state before blocking on provider execution.
+            // If the MCP client transport times out (default 300 s), a status query against
+            // the stable run ID must see this attempt as active rather than observing
+            // attempts=0 with no in-progress state — which falsely implies nothing happened
+            // and causes callers to start a concurrent recovery run before the backend finishes.
+            await persistLoopRecordIfSupported(input.store, loop);
             let result;
             try {
                 result = await executingAdapter.execute({
@@ -1136,7 +1150,7 @@ export async function runMartin(input) {
             // VERIFY: Run grounding scan on patch diff if available
             // Uses the task's repoRoot to build/load the grounding index, then scans any diff
             let groundingScanResult;
-            const patchDiff = buildPatchDiff(result, changedFiles, input.task.repoRoot);
+            const patchDiff = buildPatchDiff(result, changedFiles);
             if (patchDiff && input.task.repoRoot) {
                 try {
                     const groundingIndex = await loadOrBuildRepoGroundingIndex(input.task.repoRoot);
@@ -1569,34 +1583,20 @@ function resolveChangedFiles(result, repoRoot, rollbackBoundary) {
     }
     return listAttemptChangedFilesSinceBoundary({ repoRoot, boundary: rollbackBoundary });
 }
-function buildPatchDiff(result, changedFiles, repoRoot) {
+function buildPatchDiff(result, changedFiles) {
     // Use structured diff stats to build a minimal diff header if no raw diff is available
-    const files = result.execution?.changedFiles?.length ? result.execution.changedFiles : changedFiles;
-    if (files.length > 0) {
-        return files
-            .map((file) => buildSyntheticDiffHeader(file, repoRoot))
+    if (result.execution?.changedFiles?.length) {
+        // Build a synthetic diff header from changed file list
+        return result.execution.changedFiles
+            .map((file) => `--- a/${file}\n+++ b/${file}\n@@ -0,0 +1 @@\n+`)
             .join("\n");
     }
-    return undefined;
-}
-function buildSyntheticDiffHeader(file, repoRoot) {
-    const normalizedFile = file.replace(/\\/gu, "/");
-    const isNewWorkspaceFile = repoRoot ? isUntrackedWorkspaceFile(repoRoot, normalizedFile) : false;
-    const before = isNewWorkspaceFile ? "/dev/null" : `a/${normalizedFile}`;
-    return `--- ${before}\n+++ b/${normalizedFile}\n@@ -0,0 +1 @@\n+`;
-}
-function isUntrackedWorkspaceFile(repoRoot, file) {
-    const result = spawnSync("git", ["ls-files", "--others", "--exclude-standard", "--", file], {
-        cwd: repoRoot,
-        encoding: "utf8"
-    });
-    if (result.status !== 0 || typeof result.stdout !== "string") {
-        return false;
+    if (changedFiles.length > 0) {
+        return changedFiles
+            .map((file) => `--- a/${file}\n+++ b/${file}\n@@ -0,0 +1 @@\n+`)
+            .join("\n");
     }
-    return result.stdout
-        .split(/\r?\n/u)
-        .map((line) => line.trim().replace(/\\/gu, "/"))
-        .includes(file);
+    return undefined;
 }
 function createBudgetSettlement(input) {
     const totalActualUsd = getUsageUsd(input.usage);

package/dist/workflow-state.d.ts

@@ -13,6 +13,7 @@ interface McpWorkflowReceipt {
 }
 interface WorkflowState {
     version: 1;
+    cli?: unknown;
     mcp?: Partial<Record<McpWorkflowStepName, McpWorkflowReceipt>>;
 }
 export interface RecordMcpWorkflowStepInput {
@@ -46,5 +47,5 @@ export interface McpRunGateResult {
 }
 export declare function recordMcpWorkflowStep(input: RecordMcpWorkflowStepInput): Promise<void>;
 export declare function evaluateMcpRunGate(input: EvaluateMcpRunGateInput): Promise<McpRunGateResult>;
-export declare function readWorkflowState(runsRoot: string): Promise<WorkflowState>;
+export declare function readWorkflowState(runsRoot: string, workingDirectory?: string): Promise<WorkflowState>;
 export {};

package/dist/workflow-state.js

@@ -1,14 +1,15 @@
 import { createHash } from "node:crypto";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 const WORKFLOW_STATE_DIRECTORY = "_martin";
 const WORKFLOW_STATE_FILENAME = "workflow-state.json";
+const WORKSPACES_DIRECTORY = "workspaces";
 const DOCTOR_TTL_MS = 24 * 60 * 60 * 1000;
 const ESTIMATE_TTL_MS = 6 * 60 * 60 * 1000; // Estimate expires after 6h — re-estimate if objective changes
 const PLAN_TTL_MS = 24 * 60 * 60 * 1000;
 const PREFLIGHT_TTL_MS = 6 * 60 * 60 * 1000;
 export async function recordMcpWorkflowStep(input) {
-    const state = await readWorkflowState(input.runsRoot);
+    const state = await readWorkflowState(input.runsRoot, input.workingDirectory);
     state.mcp ??= {};
     state.mcp[input.step] = {
         step: input.step,
@@ -21,10 +22,10 @@ export async function recordMcpWorkflowStep(input) {
         pathScopeKey: hashPathScope(input.allowedPaths ?? [], input.deniedPaths ?? []),
         ...(input.budget ? { budgetKey: hashBudget(input.budget) } : {})
     };
-    await writeWorkflowState(input.runsRoot, state);
+    await writeWorkflowState(input.runsRoot, state, input.workingDirectory);
 }
 export async function evaluateMcpRunGate(input) {
-    const state = await readWorkflowState(input.runsRoot);
+    const state = await readWorkflowState(input.runsRoot, input.workingDirectory);
     const mcpState = state.mcp ?? {};
     const workingDirectory = normalizeWorkingDirectory(input.workingDirectory);
     const objectiveKey = normalizeObjective(input.objective);
@@ -84,8 +85,8 @@ export async function evaluateMcpRunGate(input) {
         missingSteps
     };
 }
-export async function readWorkflowState(runsRoot) {
-    const statePath = resolveWorkflowStatePath(runsRoot);
+export async function readWorkflowState(runsRoot, workingDirectory) {
+    const statePath = resolveWorkflowStatePath(runsRoot, workingDirectory);
     try {
         const raw = await readFile(statePath, "utf8");
         const parsed = JSON.parse(raw);
@@ -95,13 +96,33 @@ export async function readWorkflowState(runsRoot) {
         return { version: 1 };
     }
 }
-async function writeWorkflowState(runsRoot, state) {
-    const statePath = resolveWorkflowStatePath(runsRoot);
-    await mkdir(join(resolve(runsRoot), WORKFLOW_STATE_DIRECTORY), { recursive: true });
-    await writeFile(statePath, JSON.stringify(state, null, 2), "utf8");
+async function writeWorkflowState(runsRoot, state, workingDirectory) {
+    const statePath = resolveWorkflowStatePath(runsRoot, workingDirectory);
+    const dir = workingDirectory
+        ? join(resolve(runsRoot), WORKFLOW_STATE_DIRECTORY, WORKSPACES_DIRECTORY, deriveWorkspaceKey(workingDirectory))
+        : join(resolve(runsRoot), WORKFLOW_STATE_DIRECTORY);
+    await mkdir(dir, { recursive: true });
+    // Atomic write: tmp then rename prevents partial reads on concurrent access
+    const tmpPath = `${statePath}.tmp`;
+    await writeFile(tmpPath, JSON.stringify(state, null, 2), "utf8");
+    await rename(tmpPath, statePath);
 }
-function resolveWorkflowStatePath(runsRoot) {
-    return join(resolve(runsRoot), WORKFLOW_STATE_DIRECTORY, WORKFLOW_STATE_FILENAME);
+// Per-workspace path: <runsRoot>/_martin/workspaces/<workspaceKey>/workflow-state.json
+// Global path:        <runsRoot>/_martin/workflow-state.json (not used for governance receipts)
+function resolveWorkflowStatePath(runsRoot, workingDirectory) {
+    const base = join(resolve(runsRoot), WORKFLOW_STATE_DIRECTORY);
+    if (workingDirectory) {
+        return join(base, WORKSPACES_DIRECTORY, deriveWorkspaceKey(workingDirectory), WORKFLOW_STATE_FILENAME);
+    }
+    return join(base, WORKFLOW_STATE_FILENAME);
+}
+// Derives the same per-workspace key as packages/cli/src/workflow-state.ts deriveWorkspaceKey.
+// Both must remain identical so CLI and MCP receipts land in the same workspace directory.
+function deriveWorkspaceKey(workingDirectory) {
+    return createHash("sha256")
+        .update(normalizeWorkingDirectory(workingDirectory))
+        .digest("hex")
+        .slice(0, 16);
 }
 function isFresh(receipt, ttlMs, predicate) {
     if (!receipt || !predicate(receipt)) {

package/package.json

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