@martinloop/mcp 0.1.3 → 0.2.0

package/dist/tools/list-runs.d.ts

@@ -0,0 +1,9 @@
+import { type RunSummary } from "./cockpit-support.js";
+export interface ListRunsInput {
+    runsDir?: string;
+    limit?: number;
+}
+export interface ListRunsOutput {
+    runs: RunSummary[];
+}
+export declare function listRunsTool(input: ListRunsInput): Promise<ListRunsOutput>;

package/dist/tools/list-runs.js

@@ -0,0 +1,7 @@
+import { listRunSummaries } from "./cockpit-support.js";
+export async function listRunsTool(input) {
+    return {
+        runs: await listRunSummaries(input)
+    };
+}
+//# sourceMappingURL=list-runs.js.map

package/dist/tools/preflight.d.ts

@@ -0,0 +1,62 @@
+import { type MartinEngine } from "./tool-support.js";
+export interface MartinPreflightInput {
+    objective: string;
+    workingDirectory?: string;
+    engine?: MartinEngine;
+    model?: string;
+    maxUsd?: number;
+    maxIterations?: number;
+    maxTokens?: number;
+    verificationPlan?: string[];
+    allowedPaths?: string[];
+    deniedPaths?: string[];
+    workspaceId?: string;
+    projectId?: string;
+}
+export interface MartinPreflightOutput {
+    ok: boolean;
+    summary: string;
+    warnings: string[];
+    readiness: {
+        mode: "live" | "stub";
+        liveMode: boolean;
+        engineReady: boolean;
+    };
+    normalized: {
+        objective: string;
+        workingDirectory: string;
+        engine: MartinEngine;
+        model?: string;
+        budget: {
+            maxUsd: number;
+            softLimitUsd: number;
+            maxIterations: number;
+            maxTokens: number;
+        };
+        verificationPlan: string[];
+        allowedPaths?: string[];
+        deniedPaths?: string[];
+        workspaceId: string;
+        projectId: string;
+    };
+    execution: {
+        requestedEngine: MartinEngine;
+        engineAvailability: {
+            available: boolean;
+            detail: string;
+            resolvedPath?: string;
+        };
+        runsRoot: string;
+        pathScope: {
+            repoRoot: string;
+            allowedPathsCount: number;
+            deniedPathsCount: number;
+            hasScopeConflicts: boolean;
+        };
+        expectedRunLayout: {
+            runDirectoryPattern: string;
+            loopRecordPathPattern: string;
+        };
+    };
+}
+export declare function martinPreflightTool(input: MartinPreflightInput): Promise<MartinPreflightOutput>;

package/dist/tools/preflight.js

@@ -0,0 +1,76 @@
+import { DEFAULT_BUDGET } from "../vendor/contracts/index.js";
+import { resolveRunsRoot } from "../vendor/core/index.js";
+import { resolveSafeRepoRoot } from "../server-validation.js";
+import { formatUsd, getEngineAvailability, resolveExecutionMode } from "./tool-support.js";
+export async function martinPreflightTool(input) {
+    const executionMode = resolveExecutionMode();
+    const workingDirectory = resolveSafeRepoRoot(input.workingDirectory);
+    const engine = input.engine ?? "claude";
+    const engineAvailability = getEngineAvailability(engine);
+    const warnings = [];
+    const allowedPaths = input.allowedPaths ?? [];
+    const deniedPaths = input.deniedPaths ?? [];
+    const overlappingScopes = allowedPaths.filter((candidate) => deniedPaths.includes(candidate));
+    const budget = {
+        ...DEFAULT_BUDGET,
+        ...(input.maxUsd !== undefined ? { maxUsd: input.maxUsd } : {}),
+        ...(input.maxIterations !== undefined ? { maxIterations: input.maxIterations } : {}),
+        ...(input.maxTokens !== undefined ? { maxTokens: input.maxTokens } : {})
+    };
+    if (!executionMode.liveMode) {
+        warnings.push("Stub mode is active; preflight only proves configuration shape, not live CLI readiness.");
+    }
+    else if (!engineAvailability.available) {
+        warnings.push(`Requested engine '${engine}' is not available on PATH.`);
+    }
+    if ((input.verificationPlan?.length ?? 0) === 0) {
+        warnings.push("No verificationPlan was provided; Martin can run, but completion confidence will be lower.");
+    }
+    if ((input.allowedPaths?.length ?? 0) === 0) {
+        warnings.push("No allowedPaths were provided; Martin will rely on the broader repo root scope.");
+    }
+    if (overlappingScopes.length > 0) {
+        warnings.push(`Some path patterns appear in both allowedPaths and deniedPaths: ${overlappingScopes.join(", ")}.`);
+    }
+    const ok = !executionMode.liveMode || engineAvailability.available;
+    return {
+        ok,
+        summary: ok
+            ? `Preflight ready for ${engine} in ${workingDirectory} with a ${formatUsd(budget.maxUsd)} budget cap.`
+            : `Preflight blocked: ${engine} is not available for live execution.`,
+        warnings,
+        readiness: {
+            mode: executionMode.mode,
+            liveMode: executionMode.liveMode,
+            engineReady: !executionMode.liveMode || engineAvailability.available
+        },
+        normalized: {
+            objective: input.objective,
+            workingDirectory,
+            engine,
+            ...(input.model ? { model: input.model } : {}),
+            budget,
+            verificationPlan: input.verificationPlan ?? [],
+            ...(input.allowedPaths ? { allowedPaths: input.allowedPaths } : {}),
+            ...(input.deniedPaths ? { deniedPaths: input.deniedPaths } : {}),
+            workspaceId: input.workspaceId ?? "ws_mcp",
+            projectId: input.projectId ?? "proj_mcp"
+        },
+        execution: {
+            requestedEngine: engine,
+            engineAvailability,
+            runsRoot: resolveRunsRoot(process.env),
+            pathScope: {
+                repoRoot: workingDirectory,
+                allowedPathsCount: allowedPaths.length,
+                deniedPathsCount: deniedPaths.length,
+                hasScopeConflicts: overlappingScopes.length > 0
+            },
+            expectedRunLayout: {
+                runDirectoryPattern: "<runsRoot>/<loopId>/",
+                loopRecordPathPattern: "<runsRoot>/<loopId>/loop-record.json"
+            }
+        }
+    };
+}
+//# sourceMappingURL=preflight.js.map

package/dist/tools/run-dossier.d.ts

@@ -0,0 +1,8 @@
+import { buildRunDossier } from "./cockpit-support.js";
+export interface RunDossierInput {
+    loopId?: string;
+    runsDir?: string;
+    latest?: boolean;
+}
+export type RunDossierOutput = ReturnType<typeof buildRunDossier>;
+export declare function runDossierTool(input: RunDossierInput): Promise<RunDossierOutput>;

package/dist/tools/run-dossier.js

@@ -0,0 +1,6 @@
+import { buildRunDossier, loadSelectedRun } from "./cockpit-support.js";
+export async function runDossierTool(input) {
+    const loop = await loadSelectedRun(input);
+    return buildRunDossier(loop);
+}
+//# sourceMappingURL=run-dossier.js.map

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

@@ -0,0 +1,37 @@
+export type MartinEngine = "claude" | "codex";
+export interface LoopPreview {
+    loopId: string;
+    title: string;
+    objective: string;
+    status: string;
+    lifecycleState: string;
+    createdAt?: string;
+    updatedAt?: string;
+    attempts: number;
+    costUsd: number;
+    avoidedUsd: number;
+    pressure: string;
+    shouldStop: boolean;
+    remainingBudgetUsd: number;
+    remainingIterations: number;
+    remainingTokens: number;
+}
+export interface CliAvailability {
+    available: boolean;
+    detail: string;
+    resolvedPath?: string;
+}
+export interface ExecutionMode {
+    liveMode: boolean;
+    mode: "live" | "stub";
+}
+export interface RunStoreInspection {
+    exists: boolean;
+    loopCount: number;
+    latestRun?: LoopPreview;
+    warnings: string[];
+}
+export declare function resolveExecutionMode(): ExecutionMode;
+export declare function getEngineAvailability(engine: MartinEngine): CliAvailability;
+export declare function formatUsd(value: number): string;
+export declare function inspectRunsRoot(runsRoot?: string): Promise<RunStoreInspection>;

package/dist/tools/tool-support.js

@@ -0,0 +1,110 @@
+import { spawnSync } from "node:child_process";
+import { readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { evaluateCostGovernor, readLatestLoopRecordFromFile, resolveRunsRoot } from "../vendor/core/index.js";
+export function resolveExecutionMode() {
+    const liveMode = process.env.MARTIN_LIVE !== "false";
+    return {
+        liveMode,
+        mode: liveMode ? "live" : "stub"
+    };
+}
+export function getEngineAvailability(engine) {
+    const locator = process.platform === "win32" ? "where.exe" : "which";
+    const result = spawnSync(locator, [engine], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+    const resolvedPath = result.status === 0
+        ? (result.stdout ?? "")
+            .split(/\r?\n/u)
+            .map((line) => line.trim())
+            .find(Boolean)
+        : undefined;
+    return result.status === 0
+        ? {
+            available: true,
+            detail: `${engine} is available on PATH.`,
+            ...(resolvedPath ? { resolvedPath } : {})
+        }
+        : {
+            available: false,
+            detail: `${engine} is not available on PATH.`
+        };
+}
+export function formatUsd(value) {
+    return `$${value.toFixed(2)}`;
+}
+export async function inspectRunsRoot(runsRoot = resolveRunsRoot(process.env)) {
+    let exists = false;
+    try {
+        exists = (await stat(runsRoot)).isDirectory();
+    }
+    catch {
+        exists = false;
+    }
+    if (!exists) {
+        return {
+            exists: false,
+            loopCount: 0,
+            warnings: []
+        };
+    }
+    const warnings = [];
+    const loops = [];
+    const entries = await readdir(runsRoot, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const loopRecordPath = join(runsRoot, entry.name, "loop-record.json");
+        try {
+            const loop = await readLatestLoopRecordFromFile(loopRecordPath);
+            if (!loop) {
+                continue;
+            }
+            const costState = evaluateCostGovernor({
+                budget: loop.budget,
+                cost: {
+                    actualUsd: loop.cost.actualUsd,
+                    avoidedUsd: loop.cost.avoidedUsd ?? 0,
+                    tokensIn: loop.cost.tokensIn,
+                    tokensOut: loop.cost.tokensOut
+                },
+                attemptsUsed: loop.attempts.length
+            });
+            loops.push({
+                loopId: loop.loopId,
+                title: loop.task?.title ?? loop.loopId,
+                objective: loop.task?.objective ?? "Loop record summary",
+                status: loop.status,
+                lifecycleState: loop.lifecycleState,
+                ...(loop.createdAt ? { createdAt: loop.createdAt } : {}),
+                ...(loop.updatedAt ? { updatedAt: loop.updatedAt } : {}),
+                attempts: loop.attempts.length,
+                costUsd: loop.cost.actualUsd,
+                avoidedUsd: loop.cost.avoidedUsd ?? 0,
+                pressure: costState.pressure,
+                shouldStop: costState.shouldStop,
+                remainingBudgetUsd: costState.remainingBudgetUsd,
+                remainingIterations: costState.remainingIterations,
+                remainingTokens: costState.remainingTokens
+            });
+        }
+        catch {
+            warnings.push(`Skipped unreadable loop record for '${entry.name}'.`);
+        }
+    }
+    loops.sort((left, right) => {
+        const leftTime = Date.parse(left.updatedAt ?? left.createdAt ?? "");
+        const rightTime = Date.parse(right.updatedAt ?? right.createdAt ?? "");
+        return (Number.isFinite(rightTime) ? rightTime : 0) - (Number.isFinite(leftTime) ? leftTime : 0);
+    });
+    return {
+        exists: true,
+        loopCount: loops.length,
+        ...(loops[0] ? { latestRun: loops[0] } : {}),
+        warnings
+    };
+}
+//# sourceMappingURL=tool-support.js.map

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@martinloop/mcp",
-  "version": "0.1.3",
-  "mcpName": "io.github.keesan12/martin-loop",
+  "version": "0.2.0",
+  "mcpName": "io.github.Keesan12/martin-loop",
   "private": false,
   "type": "module",
-  "description": "Governed MCP server for AI coding agents with budgets, verifier gates, policy checks, and audit trails.",
-  "license": "MIT",
+  "description": "Governed MCP server for AI coding agents with budgets, verifier gates, and inspectable runs.",
+  "license": "Apache-2.0",
   "author": "Vakeesan Mahalingam and Gobi Shanthan",
   "homepage": "https://martinloop.com/",
   "repository": {
@@ -22,7 +22,11 @@
     "martin-loop",
     "ai-agent",
     "claude",
-    "codex"
+    "codex",
+    "martin_doctor",
+    "martin_preflight",
+    "martin_list_runs",
+    "martin_run_dossier"
   ],
   "bin": {
     "mcp": "./dist/server.js",
@@ -49,6 +53,7 @@
     "smoke:pack": "node ./scripts/smoke-package.mjs",
     "smoke:published": "node ./scripts/smoke-published-package.mjs",
     "smoke:published:pack": "node ./scripts/smoke-published-package.mjs --package-spec=pack",
+    "verify:release": "node --test ../../scripts/tests/publish-mcp-workflow.test.mjs ../../scripts/tests/mcp-publish-reliability.test.mjs ../../scripts/tests/mcp-release-docs.test.mjs",
     "test": "vitest run",
     "lint": "tsc -p tsconfig.json --noEmit",
     "start": "node dist/server.js"

package/server.json

@@ -1,18 +1,18 @@
 {
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
-  "name": "io.github.keesan12/martin-loop",
+  "name": "io.github.Keesan12/martin-loop",
   "title": "Martin Loop",
-  "description": "Governed MCP server for AI coding agents with budgets, verifier gates, policy checks, and audit trails.",
+  "description": "Governed MCP server for AI coding agents with budgets, verifier gates, and inspectable runs.",
   "repository": {
     "url": "https://github.com/Keesan12/martin-loop",
     "source": "github"
   },
-  "version": "0.1.3",
+  "version": "0.2.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@martinloop/mcp",
-      "version": "0.1.3",
+      "version": "0.2.0",
       "transport": {
         "type": "stdio"
       }