@martinloop/mcp 0.6.4 → 0.6.5

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const MARTIN_MCP_PACKAGE_VERSION = "0.6.4";
+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.4";
+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/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

@@ -6,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";
@@ -391,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) {
@@ -418,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 })));

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.4",
+  "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.4",
+  "version": "0.6.5",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@martinloop/mcp",
-      "version": "0.6.4",
+      "version": "0.6.5",
       "transport": {
         "type": "stdio"
       }