@martinloop/mcp 0.2.0 → 0.2.7

package/dist/tools/doctor.d.ts

@@ -1,4 +1,5 @@
 import { type LoopPreview, type MartinEngine } from "./tool-support.js";
+import { type MartinReadinessReport } from "./workflow-governance.js";
 export interface MartinDoctorInput {
     workingDirectory?: string;
     runsDir?: string;
@@ -30,6 +31,7 @@ export interface MartinDoctorOutput {
         loopCount: number;
         latestRun?: LoopPreview;
     };
+    readiness: MartinReadinessReport;
     warnings: string[];
 }
 export declare function martinDoctorTool(input: MartinDoctorInput): Promise<MartinDoctorOutput>;

package/dist/tools/doctor.js

@@ -1,6 +1,7 @@
 import { resolveRunsRoot } from "../vendor/core/index.js";
 import { resolveSafeRepoRoot, resolveSafeRunsRootPath } from "../server-validation.js";
 import { getEngineAvailability, inspectRunsRoot, resolveExecutionMode } from "./tool-support.js";
+import { buildReadinessReport, inspectRepoSignals } from "./workflow-governance.js";
 export async function martinDoctorTool(input) {
     const workingDirectory = resolveSafeRepoRoot(input.workingDirectory);
     const runsRoot = resolveSafeRunsRootPath(input.runsDir, resolveRunsRoot(process.env));
@@ -8,6 +9,8 @@ export async function martinDoctorTool(input) {
     const claude = getEngineAvailability("claude");
     const codex = getEngineAvailability("codex");
     const runStore = await inspectRunsRoot(runsRoot);
+    const signals = inspectRepoSignals(workingDirectory);
+    const readiness = buildReadinessReport(signals, runStore);
     const warnings = [];
     if (!runStore.exists) {
         warnings.push("Configured Martin runs root does not exist yet.");
@@ -23,11 +26,12 @@ export async function martinDoctorTool(input) {
     }
     warnings.push(...runStore.warnings);
     const status = warnings.length === 0 ? "ok" : "degraded";
+    const summary = status === "ok"
+        ? `Doctor passed: repo readiness ${readiness.score}/100 with ${runStore.loopCount} visible run(s).`
+        : `Doctor found ${warnings.length} issue(s); readiness ${readiness.score}/100 before live execution.`;
     return {
         status,
-        summary: status === "ok"
-            ? `Doctor passed: ${runStore.loopCount} run(s) visible in ${runsRoot}.`
-            : `Doctor found ${warnings.length} issue(s); review warnings before live execution.`,
+        summary,
         server: {
             name: "martin-loop",
             nodeVersion: process.version,
@@ -41,8 +45,16 @@ export async function martinDoctorTool(input) {
             liveMode: executionMode.liveMode
         },
         engines: {
-            claude,
-            codex
+            claude: {
+                available: claude.available,
+                detail: claude.detail,
+                ...(claude.resolvedPath ? { resolvedPath: claude.resolvedPath } : {})
+            },
+            codex: {
+                available: codex.available,
+                detail: codex.detail,
+                ...(codex.resolvedPath ? { resolvedPath: codex.resolvedPath } : {})
+            }
         },
         ...(input.engine ? { requestedEngine: input.engine } : {}),
         runStore: {
@@ -50,7 +62,7 @@ export async function martinDoctorTool(input) {
             loopCount: runStore.loopCount,
             ...(runStore.latestRun ? { latestRun: runStore.latestRun } : {})
         },
+        readiness,
         warnings
     };
 }
-//# sourceMappingURL=doctor.js.map

package/dist/tools/eval.d.ts

@@ -0,0 +1,24 @@
+export interface MartinEvalInput {
+    file?: string;
+    loopId?: string;
+    runsDir?: string;
+    latest?: boolean;
+}
+export interface MartinEvalOutput {
+    source: string;
+    sourceKind: "file" | "loop_id" | "latest" | "runs_root";
+    loopId: string;
+    score: number;
+    grade: "mergeable" | "mergeable_with_review" | "needs_review" | "blocked" | "insufficient_evidence";
+    checks: {
+        taskCompletion: "passed" | "warning" | "failed";
+        verifier: "passed" | "warning" | "failed";
+        diffDiscipline: "passed" | "warning" | "failed";
+        regressionRisk: "passed" | "warning" | "failed";
+        securityRisk: "passed" | "warning" | "failed";
+        reviewability: "passed" | "warning" | "failed";
+    };
+    warnings: string[];
+    summary: string;
+}
+export declare function martinEvalTool(input: MartinEvalInput): Promise<MartinEvalOutput>;

package/dist/tools/eval.js

@@ -0,0 +1,65 @@
+import { loadDetailedLoopRecord, readLedgerEvents } from "./run-store.js";
+import { buildVerificationSummary } from "./tool-support.js";
+import { assessRunRisk, inspectRepoSignals } from "./workflow-governance.js";
+export async function martinEvalTool(input) {
+    const detail = await loadDetailedLoopRecord(input);
+    const ledgerEvents = await readLedgerEvents(detail);
+    const verification = buildVerificationSummary(detail.loop, ledgerEvents);
+    const repoRoot = detail.loop.task?.repoRoot;
+    const signals = inspectRepoSignals(repoRoot ?? process.cwd());
+    const risk = assessRunRisk({
+        objective: detail.loop.task?.objective ?? detail.loop.loopId,
+        allowedPaths: detail.loop.task?.allowedPaths ?? [],
+        blockedPaths: detail.loop.task?.deniedPaths ?? [],
+        verifiers: detail.loop.task?.verificationPlan ?? [],
+        signals
+    });
+    const checks = {
+        taskCompletion: detail.loop.status === "completed" ? "passed" : detail.loop.status === "exited" ? "warning" : "failed",
+        verifier: verification.status === "passed"
+            ? "passed"
+            : verification.status === "failed"
+                ? "failed"
+                : "warning",
+        diffDiscipline: (detail.loop.task?.allowedPaths?.length ?? 0) > 0 ? "passed" : "warning",
+        regressionRisk: verification.status === "passed" ? "passed" : "warning",
+        securityRisk: risk.level === "high" ? "failed" : risk.level === "medium" ? "warning" : "passed",
+        reviewability: detail.loop.attempts.length > 0 && (detail.loop.events?.length ?? 0) > 0 ? "passed" : "warning"
+    };
+    let score = 100;
+    score -= checks.taskCompletion === "failed" ? 25 : checks.taskCompletion === "warning" ? 10 : 0;
+    score -= checks.verifier === "failed" ? 25 : checks.verifier === "warning" ? 10 : 0;
+    score -= checks.diffDiscipline === "warning" ? 8 : 0;
+    score -= checks.regressionRisk === "warning" ? 10 : 0;
+    score -= checks.securityRisk === "failed" ? 20 : checks.securityRisk === "warning" ? 10 : 0;
+    score -= checks.reviewability === "warning" ? 8 : 0;
+    score = Math.max(0, score);
+    const grade = verification.status === "unavailable"
+        ? "insufficient_evidence"
+        : score >= 90
+            ? "mergeable"
+            : score >= 75
+                ? "mergeable_with_review"
+                : score >= 55
+                    ? "needs_review"
+                    : "blocked";
+    const warnings = [...detail.warnings, ...verification.warnings, ...risk.reasons];
+    return {
+        source: detail.source,
+        sourceKind: detail.sourceKind,
+        loopId: detail.loop.loopId,
+        score,
+        grade,
+        checks: { ...checks },
+        warnings,
+        summary: grade === "mergeable"
+            ? `Run ${detail.loop.loopId} looks mergeable with verifier-backed completion.`
+            : grade === "mergeable_with_review"
+                ? `Run ${detail.loop.loopId} looks mergeable with review; inspect dossier and risk notes first.`
+                : grade === "needs_review"
+                    ? `Run ${detail.loop.loopId} needs review before promotion.`
+                    : grade === "insufficient_evidence"
+                        ? `Run ${detail.loop.loopId} does not have enough evidence for a safe promotion decision.`
+                        : `Run ${detail.loop.loopId} is blocked from promotion by verification or risk gaps.`
+    };
+}

package/dist/tools/get-attempt.d.ts

@@ -1,8 +1,15 @@
-import { getAttempt } from "./cockpit-support.js";
-export interface GetAttemptInput {
-    loopId: string;
-    attemptIndex: number;
+import { buildAttemptSummary, buildLoopPreview } from "./tool-support.js";
+export interface MartinGetAttemptInput {
+    file?: string;
+    loopId?: string;
     runsDir?: string;
+    attemptIndex?: number;
 }
-export type GetAttemptOutput = ReturnType<typeof getAttempt>;
-export declare function getAttemptTool(input: GetAttemptInput): Promise<GetAttemptOutput>;
+export interface MartinGetAttemptOutput {
+    source: string;
+    sourceKind: "file" | "loop_id" | "latest" | "runs_root";
+    loop: ReturnType<typeof buildLoopPreview>;
+    attempt: ReturnType<typeof buildAttemptSummary>;
+    warnings: string[];
+}
+export declare function martinGetAttemptTool(input: MartinGetAttemptInput): Promise<MartinGetAttemptOutput>;

package/dist/tools/get-attempt.js

@@ -1,6 +1,15 @@
-import { getAttempt, loadSelectedRun } from "./cockpit-support.js";
-export async function getAttemptTool(input) {
-    const loop = await loadSelectedRun({ loopId: input.loopId, runsDir: input.runsDir });
-    return getAttempt(loop, input.attemptIndex);
+import { buildAttemptArtifactsReference, buildAttemptSummary, buildLoopPreview } from "./tool-support.js";
+import { loadAttemptFromLoop } from "./run-store.js";
+export async function martinGetAttemptTool(input) {
+    const { detail, attempt } = await loadAttemptFromLoop(input);
+    const artifacts = detail.canonicalRunDirectory
+        ? await buildAttemptArtifactsReference(detail.runsRoot, detail.loop.loopId, attempt.index)
+        : undefined;
+    return {
+        source: detail.source,
+        sourceKind: detail.sourceKind,
+        loop: buildLoopPreview(detail.loop),
+        attempt: buildAttemptSummary(attempt, artifacts),
+        warnings: detail.warnings
+    };
 }
-//# sourceMappingURL=get-attempt.js.map

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

@@ -1,17 +1,24 @@
-import type { LoopRunRecord } from "../vendor/core/index.js";
-import { summarizeRun } from "./cockpit-support.js";
-export interface GetRunInput {
+import { buildArtifactSummary, buildBudgetSnapshot, buildCostSnapshot, buildLoopPreview, buildVerificationSummary } from "./tool-support.js";
+export interface MartinGetRunInput {
+    file?: string;
     loopId?: string;
     runsDir?: string;
     latest?: boolean;
 }
-export interface GetRunOutput {
-    summary: ReturnType<typeof summarizeRun>;
-    task: LoopRunRecord["task"];
-    budget: LoopRunRecord["budget"];
-    cost: LoopRunRecord["cost"];
-    attempts: LoopRunRecord["attempts"];
-    createdAt: string;
-    updatedAt: string;
+export interface MartinGetRunOutput {
+    source: string;
+    sourceKind: "file" | "loop_id" | "latest" | "runs_root";
+    loop: ReturnType<typeof buildLoopPreview>;
+    budget: ReturnType<typeof buildBudgetSnapshot>;
+    cost: ReturnType<typeof buildCostSnapshot>;
+    verification: ReturnType<typeof buildVerificationSummary>;
+    artifacts: ReturnType<typeof buildArtifactSummary>;
+    inspection: {
+        runsRoot: string;
+        canonicalRunDirectory?: string;
+        canonicalLoopRecordPath?: string;
+        ledgerPath?: string;
+    };
+    warnings: string[];
 }
-export declare function getRunTool(input: GetRunInput): Promise<GetRunOutput>;
+export declare function martinGetRunTool(input: MartinGetRunInput): Promise<MartinGetRunOutput>;

package/dist/tools/get-run.js

@@ -1,14 +1,23 @@
-import { loadSelectedRun, summarizeRun } from "./cockpit-support.js";
-export async function getRunTool(input) {
-    const loop = await loadSelectedRun(input);
+import { buildArtifactSummary, buildBudgetSnapshot, buildCostSnapshot, buildLoopPreview, buildVerificationSummary } from "./tool-support.js";
+import { loadDetailedLoopRecord, readLedgerEvents } from "./run-store.js";
+export async function martinGetRunTool(input) {
+    const detail = await loadDetailedLoopRecord(input);
+    const ledgerEvents = await readLedgerEvents(detail);
+    const verification = buildVerificationSummary(detail.loop, ledgerEvents);
     return {
-        summary: summarizeRun(loop),
-        task: loop.task,
-        budget: loop.budget,
-        cost: loop.cost,
-        attempts: loop.attempts,
-        createdAt: loop.createdAt,
-        updatedAt: loop.updatedAt
+        source: detail.source,
+        sourceKind: detail.sourceKind,
+        loop: buildLoopPreview(detail.loop),
+        budget: buildBudgetSnapshot(detail.loop.budget),
+        cost: buildCostSnapshot(detail.loop.cost),
+        verification,
+        artifacts: buildArtifactSummary(detail.loop),
+        inspection: {
+            runsRoot: detail.runsRoot,
+            ...(detail.canonicalRunDirectory ? { canonicalRunDirectory: detail.canonicalRunDirectory } : {}),
+            ...(detail.canonicalLoopRecordPath ? { canonicalLoopRecordPath: detail.canonicalLoopRecordPath } : {}),
+            ...(detail.ledgerPath ? { ledgerPath: detail.ledgerPath } : {})
+        },
+        warnings: [...detail.warnings, ...verification.warnings]
     };
 }
-//# sourceMappingURL=get-run.js.map

package/dist/tools/get-status.d.ts

@@ -1,3 +1,4 @@
+import { type LoopPreview } from "./tool-support.js";
 export interface GetStatusInput {
     /** JSON-serialized LoopRecord. */
     loopJson?: string;
@@ -11,6 +12,7 @@ export interface GetStatusInput {
     latest?: boolean;
 }
 export interface GetStatusOutput {
+    source: string;
     loopId: string;
     status: string;
     lifecycleState: string;
@@ -22,5 +24,22 @@ export interface GetStatusOutput {
     remainingBudgetUsd: number;
     remainingIterations: number;
     remainingTokens: number;
+    budget: {
+        maxUsd: number;
+        softLimitUsd: number;
+        maxIterations: number;
+        maxTokens: number;
+    };
+    inspection: {
+        loop: LoopPreview;
+    };
+    live: {
+        phase: string;
+        pauseState: "active" | "paused" | "cancellation_requested";
+        approvalState: "not_required" | "resume_requested";
+        commandsRun: number;
+        filesTouched: number;
+        verifierStep?: string;
+    };
 }
 export declare function getStatusTool(input: GetStatusInput): Promise<GetStatusOutput>;

package/dist/tools/get-status.js

@@ -1,8 +1,19 @@
 import { evaluateCostGovernor } from "../vendor/core/index.js";
 import { loadLoopRecordForStatus } from "./run-store.js";
+import { buildLoopPreview } from "./tool-support.js";
+import { readRunControlState } from "./run-controls.js";
 export async function getStatusTool(input) {
     const resolved = await loadLoopRecordForStatus(input);
     const loop = resolved.loop;
+    const control = input.loopJson !== undefined
+        ? {
+            requestedState: "active",
+            approvalState: "not_required",
+            receipts: []
+        }
+        : await readRunControlState(input);
+    const latestEvent = loop.events?.at(-1);
+    const changedFiles = loop.artifacts?.filter((artifact) => artifact.kind === "diff").length ?? 0;
     const costState = evaluateCostGovernor({
         budget: loop.budget,
         cost: {
@@ -14,6 +25,7 @@ export async function getStatusTool(input) {
         attemptsUsed: loop.attempts.length
     });
     return {
+        source: resolved.source,
         loopId: loop.loopId,
         status: loop.status,
         lifecycleState: loop.lifecycleState,
@@ -24,7 +36,23 @@ export async function getStatusTool(input) {
         shouldStop: costState.shouldStop,
         remainingBudgetUsd: costState.remainingBudgetUsd,
         remainingIterations: costState.remainingIterations,
-        remainingTokens: costState.remainingTokens
+        remainingTokens: costState.remainingTokens,
+        budget: {
+            maxUsd: loop.budget.maxUsd,
+            softLimitUsd: loop.budget.softLimitUsd,
+            maxIterations: loop.budget.maxIterations,
+            maxTokens: loop.budget.maxTokens
+        },
+        inspection: {
+            loop: buildLoopPreview(loop)
+        },
+        live: {
+            phase: latestEvent?.lifecycleState ?? loop.lifecycleState,
+            pauseState: control.requestedState,
+            approvalState: control.approvalState,
+            commandsRun: loop.attempts.length,
+            filesTouched: changedFiles,
+            ...(loop.task?.verificationPlan?.[0] ? { verifierStep: loop.task.verificationPlan[0] } : {})
+        }
     };
 }
-//# sourceMappingURL=get-status.js.map

package/dist/tools/get-verification-results.d.ts

@@ -1,11 +1,14 @@
-import { type VerificationResultSummary } from "./cockpit-support.js";
-export interface GetVerificationResultsInput {
+import { buildLoopPreview, buildVerificationSummary } from "./tool-support.js";
+export interface MartinGetVerificationResultsInput {
+    file?: string;
     loopId?: string;
     runsDir?: string;
-    latest?: boolean;
 }
-export interface GetVerificationResultsOutput {
-    loopId: string;
-    results: VerificationResultSummary[];
+export interface MartinGetVerificationResultsOutput {
+    source: string;
+    sourceKind: "file" | "loop_id" | "latest" | "runs_root";
+    loop: ReturnType<typeof buildLoopPreview>;
+    verification: ReturnType<typeof buildVerificationSummary>;
+    warnings: string[];
 }
-export declare function getVerificationResultsTool(input: GetVerificationResultsInput): Promise<GetVerificationResultsOutput>;
+export declare function martinGetVerificationResultsTool(input: MartinGetVerificationResultsInput): Promise<MartinGetVerificationResultsOutput>;

package/dist/tools/get-verification-results.js

@@ -1,9 +1,14 @@
-import { extractVerificationResults, loadSelectedRun } from "./cockpit-support.js";
-export async function getVerificationResultsTool(input) {
-    const loop = await loadSelectedRun(input);
+import { buildLoopPreview, buildVerificationSummary } from "./tool-support.js";
+import { loadDetailedLoopRecord, readLedgerEvents } from "./run-store.js";
+export async function martinGetVerificationResultsTool(input) {
+    const detail = await loadDetailedLoopRecord(input);
+    const ledgerEvents = await readLedgerEvents(detail);
+    const verification = buildVerificationSummary(detail.loop, ledgerEvents);
     return {
-        loopId: loop.loopId,
-        results: extractVerificationResults(loop)
+        source: detail.source,
+        sourceKind: detail.sourceKind,
+        loop: buildLoopPreview(detail.loop),
+        verification,
+        warnings: [...detail.warnings, ...verification.warnings]
     };
 }
-//# sourceMappingURL=get-verification-results.js.map

package/dist/tools/inspect-loop.d.ts

@@ -1,4 +1,5 @@
 import { type PortfolioSnapshot } from "../vendor/contracts/index.js";
+import { type LoopPreview } from "./tool-support.js";
 export interface InspectLoopInput {
     /** Optional path to a JSON, JSONL, or run-store directory under the Martin runs root. */
     file?: string;
@@ -9,5 +10,13 @@ export interface InspectLoopOutput {
     source: string;
     loopCount: number;
     portfolio: PortfolioSnapshot;
+    latestRun?: LoopPreview;
+    recentRuns: LoopPreview[];
+    statusBreakdown: Record<string, number>;
+    lifecycleBreakdown: Record<string, number>;
+    inspection: {
+        sourceKind: "file" | "runs_root";
+    };
+    warnings: string[];
 }
 export declare function inspectLoopTool(input: InspectLoopInput): Promise<InspectLoopOutput>;

package/dist/tools/inspect-loop.js

@@ -1,12 +1,21 @@
 import { buildPortfolioSnapshot } from "../vendor/contracts/index.js";
 import { loadLoopRecordsForInspect } from "./run-store.js";
+import { buildLoopCollectionSummary } from "./tool-support.js";
 export async function inspectLoopTool(input) {
     const inspection = await loadLoopRecordsForInspect(input);
     const loops = inspection.loops;
+    const summary = buildLoopCollectionSummary(inspection.loops);
     return {
         source: inspection.source,
         loopCount: loops.length,
-        portfolio: buildPortfolioSnapshot(loops)
+        portfolio: buildPortfolioSnapshot(loops),
+        ...(summary.latestRun ? { latestRun: summary.latestRun } : {}),
+        recentRuns: summary.recentRuns,
+        statusBreakdown: summary.statusBreakdown,
+        lifecycleBreakdown: summary.lifecycleBreakdown,
+        inspection: {
+            sourceKind: input.file ? "file" : "runs_root"
+        },
+        warnings: inspection.warnings
     };
 }
-//# sourceMappingURL=inspect-loop.js.map

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

@@ -1,9 +1,29 @@
-import { type RunSummary } from "./cockpit-support.js";
-export interface ListRunsInput {
+import { buildLoopPreview } from "./tool-support.js";
+export interface MartinListRunsInput {
     runsDir?: string;
     limit?: number;
+    status?: string;
+    lifecycleState?: string;
+    adapterId?: string;
+    model?: string;
+    updatedAfter?: string;
 }
-export interface ListRunsOutput {
-    runs: RunSummary[];
+export interface MartinListRunsOutput {
+    source: string;
+    runsRoot: string;
+    filters: {
+        limit: number;
+        status?: string;
+        lifecycleState?: string;
+        adapterId?: string;
+        model?: string;
+        updatedAfter?: string;
+    };
+    loopCount: number;
+    latestRun?: ReturnType<typeof buildLoopPreview>;
+    recentRuns: Array<ReturnType<typeof buildLoopPreview>>;
+    statusBreakdown: Record<string, number>;
+    lifecycleBreakdown: Record<string, number>;
+    warnings: string[];
 }
-export declare function listRunsTool(input: ListRunsInput): Promise<ListRunsOutput>;
+export declare function martinListRunsTool(input: MartinListRunsInput): Promise<MartinListRunsOutput>;

package/dist/tools/list-runs.js

@@ -1,7 +1,24 @@
-import { listRunSummaries } from "./cockpit-support.js";
-export async function listRunsTool(input) {
+import { buildLoopCollectionSummary, buildLoopPreview } from "./tool-support.js";
+import { listLoopRecords } from "./run-store.js";
+export async function martinListRunsTool(input) {
+    const result = await listLoopRecords(input);
+    const summary = buildLoopCollectionSummary(result.loops);
     return {
-        runs: await listRunSummaries(input)
+        source: result.source,
+        runsRoot: result.runsRoot,
+        filters: {
+            limit: input.limit ?? 20,
+            ...(input.status ? { status: input.status } : {}),
+            ...(input.lifecycleState ? { lifecycleState: input.lifecycleState } : {}),
+            ...(input.adapterId ? { adapterId: input.adapterId } : {}),
+            ...(input.model ? { model: input.model } : {}),
+            ...(input.updatedAfter ? { updatedAfter: input.updatedAfter } : {})
+        },
+        loopCount: result.loops.length,
+        ...(summary.latestRun ? { latestRun: summary.latestRun } : {}),
+        recentRuns: result.loops.map((loop) => buildLoopPreview(loop)),
+        statusBreakdown: summary.statusBreakdown,
+        lifecycleBreakdown: summary.lifecycleBreakdown,
+        warnings: result.warnings
     };
 }
-//# sourceMappingURL=list-runs.js.map

package/dist/tools/logs.d.ts

@@ -0,0 +1,25 @@
+export interface MartinLogsInput {
+    file?: string;
+    loopId?: string;
+    runsDir?: string;
+    latest?: boolean;
+    limit?: number;
+}
+export interface MartinLogsOutput {
+    source: string;
+    sourceKind: "file" | "loop_id" | "latest" | "runs_root";
+    loopId: string;
+    logCount: number;
+    live: {
+        lifecycleState: string;
+        pauseState: "active" | "paused" | "cancellation_requested";
+        approvalState: "not_required" | "resume_requested";
+    };
+    entries: Array<{
+        timestamp?: string;
+        source: "event" | "ledger" | "control";
+        kind: string;
+        payload: Record<string, unknown>;
+    }>;
+}
+export declare function martinLogsTool(input: MartinLogsInput): Promise<MartinLogsOutput>;

package/dist/tools/logs.js

@@ -0,0 +1,49 @@
+import { readRunControlState } from "./run-controls.js";
+import { loadDetailedLoopRecord, readLedgerEvents } from "./run-store.js";
+export async function martinLogsTool(input) {
+    const detail = await loadDetailedLoopRecord(input);
+    const ledgerEvents = await readLedgerEvents(detail);
+    const controls = await readRunControlState(detail);
+    const limit = input.limit ?? 20;
+    const eventEntries = (detail.loop.events ?? []).map((event) => ({
+        timestamp: event.timestamp,
+        source: "event",
+        kind: event.type,
+        payload: event.payload ?? {}
+    }));
+    const ledgerEntries = ledgerEvents.map((event) => ({
+        timestamp: event.timestamp,
+        source: "ledger",
+        kind: event.kind,
+        payload: (event.payload ?? {})
+    }));
+    const controlEntries = controls.receipts.map((receipt) => ({
+        timestamp: receipt.requestedAt,
+        source: "control",
+        kind: `run.${receipt.action}`,
+        payload: {
+            controlId: receipt.controlId,
+            ...(receipt.reason ? { reason: receipt.reason } : {}),
+            ...(receipt.requestedBy ? { requestedBy: receipt.requestedBy } : {})
+        }
+    }));
+    const entries = [...eventEntries, ...ledgerEntries, ...controlEntries]
+        .sort((left, right) => {
+        const leftTime = left.timestamp ? new Date(left.timestamp).getTime() : 0;
+        const rightTime = right.timestamp ? new Date(right.timestamp).getTime() : 0;
+        return rightTime - leftTime;
+    })
+        .slice(0, limit);
+    return {
+        source: detail.source,
+        sourceKind: detail.sourceKind,
+        loopId: detail.loop.loopId,
+        logCount: entries.length,
+        live: {
+            lifecycleState: detail.loop.lifecycleState,
+            pauseState: controls.requestedState,
+            approvalState: controls.approvalState
+        },
+        entries
+    };
+}

package/dist/tools/plan.d.ts

@@ -0,0 +1,20 @@
+import { type MartinPlanProposal, type MartinPolicyPack } from "./workflow-governance.js";
+export interface MartinPlanInput {
+    objective: string;
+    workingDirectory?: string;
+    context?: string;
+    verificationPlan?: string[];
+    allowedPaths?: string[];
+    deniedPaths?: string[];
+    policyPack?: MartinPolicyPack;
+    maxUsd?: number;
+    maxIterations?: number;
+    maxTokens?: number;
+    maxMinutes?: number;
+    maxFilesChanged?: number;
+    maxCommands?: number;
+}
+export interface MartinPlanOutput extends MartinPlanProposal {
+    workingDirectory: string;
+}
+export declare function martinPlanTool(input: MartinPlanInput): Promise<MartinPlanOutput>;

package/dist/tools/plan.js

@@ -0,0 +1,10 @@
+import { resolveSafeRepoRoot } from "../server-validation.js";
+import { buildPlanProposal } from "./workflow-governance.js";
+export async function martinPlanTool(input) {
+    const workingDirectory = resolveSafeRepoRoot(input.workingDirectory);
+    const proposal = buildPlanProposal(workingDirectory, input);
+    return {
+        workingDirectory,
+        ...proposal
+    };
+}