@martinloop/mcp 0.5.1 → 0.5.5

package/dist/vendor/adapters/index.d.ts

@@ -1,6 +1,8 @@
 export { createDirectProviderAdapter, type DirectProviderAdapterOptions } from "./direct-provider.js";
-export { createAgentCliAdapter, createClaudeCliAdapter, createCodexCliAdapter, createGeminiCliAdapter, type AgentCliAdapterOptions, type ClaudeCliAdapterOptions, type CodexCliAdapterOptions, type GeminiCliAdapterOptions, type CliArgsBuilder } from "./claude-cli.js";
+export { createAgentCliAdapter, createClaudeCliAdapter, createGeminiCliAdapter, type AgentCliAdapterOptions, type ClaudeCliAdapterOptions, type GeminiCliAdapterOptions, type CliArgsBuilder } from "./claude-cli.js";
+export { createCodexCliAdapter, type CodexCliAdapterOptions } from "./codex-cli.js";
 export { createOpenAiCompatibleAdapter, resolveOpenAiCompatibleRuntimeConfig, type OpenAiCompatibleAdapterOptions } from "./openai-compatible.js";
 export { createVerifierOnlyAdapter, type VerifierOnlyAdapterOptions } from "./verifier-only.js";
-export { detectCodexHostPlatform, diagnoseCodexHost, probeCodexLaunch, resolveCliCommandAvailability, type CliCommandAvailability, type CodexHostDiagnosis, type CodexHostPlatform, type CodexLaunchProbeResult, checkCodexSandboxPreflight, probeFilesystemWriteCapability, type CodexSandboxPreflightOk, type CodexSandboxPreflightOutcome, type CodexSandboxPreflightReadOnly } from "./codex-launcher.js";
+/** @internal Test-only compatibility export. Public package builders strip this surface. */
+export { buildCodexExecArgs, buildCodexStdin, clearCodexCapabilityCacheForTests, detectCodexHostPlatform, diagnoseCodexHost, probeCodexCapabilities, probeCodexLaunch, resolveCliCommandAvailability, type CliCommandAvailability, type CodexApprovalCapability, type CodexAutonomyResolution, type CodexCapabilityFlag, type CodexCapabilityProfile, type CodexFlagScope, type CodexHostDiagnosis, type CodexHostPlatform, type CodexLaunchProbeResult, type CodexPromptTransport, type CodexSandboxCapability, checkCodexSandboxPreflight, probeFilesystemWriteCapability, type CodexSandboxPreflightOk, type CodexSandboxPreflightOutcome, type CodexSandboxPreflightReadOnly } from "./codex-launcher.js";
 export { createSpawnPlan, type SpawnLike, type SpawnPlan, type SubprocessResult, type VerificationOutcome } from "./cli-bridge.js";

package/dist/vendor/adapters/index.js

@@ -1,6 +1,8 @@
 export { createDirectProviderAdapter } from "./direct-provider.js";
-export { createAgentCliAdapter, createClaudeCliAdapter, createCodexCliAdapter, createGeminiCliAdapter } from "./claude-cli.js";
+export { createAgentCliAdapter, createClaudeCliAdapter, createGeminiCliAdapter } from "./claude-cli.js";
+export { createCodexCliAdapter } from "./codex-cli.js";
 export { createOpenAiCompatibleAdapter, resolveOpenAiCompatibleRuntimeConfig } from "./openai-compatible.js";
 export { createVerifierOnlyAdapter } from "./verifier-only.js";
-export { detectCodexHostPlatform, diagnoseCodexHost, probeCodexLaunch, resolveCliCommandAvailability, checkCodexSandboxPreflight, probeFilesystemWriteCapability } from "./codex-launcher.js";
+/** @internal Test-only compatibility export. Public package builders strip this surface. */
+export { buildCodexExecArgs, buildCodexStdin, clearCodexCapabilityCacheForTests, detectCodexHostPlatform, diagnoseCodexHost, probeCodexCapabilities, probeCodexLaunch, resolveCliCommandAvailability, checkCodexSandboxPreflight, probeFilesystemWriteCapability } from "./codex-launcher.js";
 export { createSpawnPlan } from "./cli-bridge.js";

package/dist/vendor/contracts/agent-execution.d.ts

@@ -0,0 +1,9 @@
+export declare const DEFAULT_AGENT_EXECUTION_INTENT: "governed-autonomous";
+export type AgentExecutionIntent = typeof DEFAULT_AGENT_EXECUTION_INTENT;
+/** Provider-neutral safety boundary every governed-autonomous adapter must honor. */
+export declare const GOVERNED_AUTONOMOUS_BOUNDARY: {
+    readonly interaction: "non-interactive";
+    readonly writeScope: "workspace-only";
+};
+export declare const DEFAULT_PROVIDER_EXECUTION_TIMEOUT_MS = 300000;
+export declare function normalizeProviderExecutionTimeoutMs(value: number | undefined): number;

package/dist/vendor/contracts/agent-execution.js

@@ -0,0 +1,14 @@
+export const DEFAULT_AGENT_EXECUTION_INTENT = "governed-autonomous";
+/** Provider-neutral safety boundary every governed-autonomous adapter must honor. */
+export const GOVERNED_AUTONOMOUS_BOUNDARY = {
+    interaction: "non-interactive",
+    writeScope: "workspace-only"
+};
+export const DEFAULT_PROVIDER_EXECUTION_TIMEOUT_MS = 300_000;
+export function normalizeProviderExecutionTimeoutMs(value) {
+    const resolved = value ?? DEFAULT_PROVIDER_EXECUTION_TIMEOUT_MS;
+    if (!Number.isFinite(resolved) || resolved <= 0) {
+        throw new Error("providerExecutionTimeoutMs must be a positive finite number.");
+    }
+    return resolved;
+}

package/dist/vendor/contracts/index.d.ts

@@ -8,6 +8,9 @@
  * portfolio snapshots and routing economics.
  */
 import type { TerminationEnvelopeV1 } from "./exits.js";
+import type { AgentExecutionIntent } from "./agent-execution.js";
+export { DEFAULT_AGENT_EXECUTION_INTENT, DEFAULT_PROVIDER_EXECUTION_TIMEOUT_MS, GOVERNED_AUTONOMOUS_BOUNDARY, normalizeProviderExecutionTimeoutMs } from "./agent-execution.js";
+export type { AgentExecutionIntent } from "./agent-execution.js";
 export type LoopStatus = "queued" | "running" | "verifying" | "completed" | "failed" | "exited";
 export type LoopLifecycleState = "created" | "running" | "verifying" | "completed" | "budget_exit" | "diminishing_returns" | "stuck_exit" | "human_escalation" | "wall_clock" | "error_threshold" | "external_event";
 export declare const FAILURE_CLASSES: readonly ["logic_error", "hallucination", "syntax_error", "type_error", "test_regression", "scope_creep", "no_progress", "repo_grounding_failure", "verification_failure", "environment_mismatch", "budget_pressure", "safety_leash_blocked", "sandbox_write_blocked"];
@@ -27,6 +30,10 @@ export interface LoopTask {
     executionProfile?: ExecutionProfile;
     allowedNetworkDomains?: string[];
     approvalPolicy?: ApprovalPolicy;
+    /** Provider-neutral execution posture. Defaults to governed autonomous execution. */
+    agentExecutionIntent?: AgentExecutionIntent;
+    /** Hard wall-clock limit for one provider coding process. */
+    providerExecutionTimeoutMs?: number;
     /** Glob patterns for files the agent is allowed to modify. Empty = no restriction. */
     allowedPaths?: string[];
     /** Glob patterns for files the agent must never modify. */
@@ -103,6 +110,8 @@ export interface ReceiptScope {
     writableRoot?: string;
     /** How the effective sandbox was determined. */
     capabilitySource?: "probe" | "configured" | "unknown";
+    agentExecutionIntent?: AgentExecutionIntent;
+    providerExecutionTimeoutMs?: number;
     /** Enforced demo changes (DEMO.md-only enforcement output). */
     demoChangedFiles?: string[];
 }

package/dist/vendor/contracts/index.js

@@ -7,6 +7,7 @@
  * creating and managing loop records, handling events, validating batches, and tracking
  * portfolio snapshots and routing economics.
  */
+export { DEFAULT_AGENT_EXECUTION_INTENT, DEFAULT_PROVIDER_EXECUTION_TIMEOUT_MS, GOVERNED_AUTONOMOUS_BOUNDARY, normalizeProviderExecutionTimeoutMs } from "./agent-execution.js";
 export const FAILURE_CLASSES = [
     "logic_error",
     "hallucination",

package/dist/vendor/core/grounding.js

@@ -196,7 +196,14 @@ export function scanPatchForGroundingViolations(diff, index, options = {}) {
     const indexedPaths = new Set(index.files.map((file) => file.path));
     const indexedSymbols = new Set(index.files.flatMap((file) => file.symbols.map((symbol) => symbol.toLowerCase())));
     const referencedFiles = new Set();
+    const addedFiles = new Set();
     const diffFilePattern = /^(?:---|\+\+\+)\s+[ab]\/(.+)$/gm;
+    const addedFilePattern = /^---\s+\/dev\/null\r?\n\+\+\+\s+b\/(.+)$/gm;
+    for (const match of diff.matchAll(addedFilePattern)) {
+        const filePath = match[1]?.trim();
+        if (filePath)
+            addedFiles.add(filePath);
+    }
     for (const match of diff.matchAll(diffFilePattern)) {
         const filePath = match[1]?.trim();
         if (filePath && filePath !== "/dev/null") {
@@ -204,7 +211,7 @@ export function scanPatchForGroundingViolations(diff, index, options = {}) {
         }
     }
     for (const filePath of referencedFiles) {
-        if (indexedPaths.has(filePath)) {
+        if (indexedPaths.has(filePath) || addedFiles.has(filePath)) {
             resolvedFiles.push(filePath);
         }
         else {
@@ -227,7 +234,7 @@ export function scanPatchForGroundingViolations(diff, index, options = {}) {
     }
     const addedLinePattern = /^\+(?!\+\+)(.+)$/gm;
     const importPattern = /(?:import|require)\s*(?:.*\s+from\s+)?['"]([^'"]+)['"]/g;
-    const identifierPattern = /\b([A-Za-z_][A-Za-z0-9_]{2,})\b/g;
+    const callableIdentifierPattern = /(?<!\.)\b([A-Za-z_][A-Za-z0-9_]*)\s*\(/g;
     const symbolKeywords = new Set([
         "const",
         "let",
@@ -244,10 +251,33 @@ export function scanPatchForGroundingViolations(diff, index, options = {}) {
         "true",
         "false",
         "null",
-        "undefined"
+        "undefined",
+        "if",
+        "for",
+        "while",
+        "switch",
+        "catch",
+        "typeof"
     ]);
-    for (const lineMatch of diff.matchAll(addedLinePattern)) {
-        const line = lineMatch[1] ?? "";
+    const addedLines = [...diff.matchAll(addedLinePattern)].map((match) => match[1] ?? "");
+    const declaredSymbols = new Set();
+    const declarationPattern = /\b(?:function|class|interface|type|enum|const|let|var)\s+([A-Za-z_][A-Za-z0-9_]*)/g;
+    for (const line of addedLines) {
+        for (const declarationMatch of line.matchAll(declarationPattern)) {
+            const symbol = declarationMatch[1];
+            if (symbol)
+                declaredSymbols.add(symbol.toLowerCase());
+        }
+        if (/^\s*import\b/u.test(line)) {
+            const importClause = line.match(/^\s*import\s+(.+?)\s+from\s+['"]/u)?.[1] ?? "";
+            for (const importSymbol of importClause.matchAll(/\b(?:as\s+)?([A-Za-z_][A-Za-z0-9_]*)\b/g)) {
+                const symbol = importSymbol[1];
+                if (symbol && symbol !== "as")
+                    declaredSymbols.add(symbol.toLowerCase());
+            }
+        }
+    }
+    for (const line of addedLines) {
         for (const importMatch of line.matchAll(importPattern)) {
             const reference = importMatch[1] ?? "";
             if (!reference.startsWith(".") && !reference.startsWith("/")) {
@@ -259,6 +289,9 @@ export function scanPatchForGroundingViolations(diff, index, options = {}) {
             const hasMatch = index.files.some((file) => {
                 const withoutExt = file.path.replace(/\.(js|ts|tsx|jsx)$/, "");
                 return withoutExt.endsWith(normalized) || withoutExt.includes(normalized);
+            }) || [...addedFiles].some((filePath) => {
+                const withoutExt = filePath.replace(/\.(js|ts|tsx|jsx)$/, "");
+                return withoutExt.endsWith(normalized) || withoutExt.includes(normalized);
             });
             if (!hasMatch) {
                 violations.push({
@@ -268,13 +301,15 @@ export function scanPatchForGroundingViolations(diff, index, options = {}) {
                 });
             }
         }
-        for (const symbolMatch of line.matchAll(identifierPattern)) {
+        for (const symbolMatch of line.matchAll(callableIdentifierPattern)) {
             const symbol = symbolMatch[1];
             if (!symbol)
                 continue;
             if (symbolKeywords.has(symbol))
                 continue;
-            if (symbol.toUpperCase() === symbol)
+            if (/^[A-Z]/u.test(symbol))
+                continue;
+            if (declaredSymbols.has(symbol.toLowerCase()))
                 continue;
             if (indexedSymbols.has(symbol.toLowerCase()))
                 continue;

package/dist/vendor/core/index.d.ts

@@ -1,4 +1,4 @@
-import { type ApprovalPolicy, type ContextHandoffReceipt, type CostProvenance, type ExecutionProfile, type FailureClass, type InterventionType, type LoopArtifact, type LoopAttempt, type LoopBudget, type ProviderUsageSettlement, type MutationMode, type LoopRecord, type LoopTask, type ReceiptScope } from "../contracts/index.js";
+import { type ApprovalPolicy, type AgentExecutionIntent, type ContextHandoffReceipt, type CostProvenance, type ExecutionProfile, type FailureClass, type InterventionType, type LoopArtifact, type LoopAttempt, type LoopBudget, type ProviderUsageSettlement, type MutationMode, type LoopRecord, type LoopTask, type ReceiptScope } from "../contracts/index.js";
 import { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluateCostGovernor, evaluateBudgetPreflight, inferExit, nextPolicyPhase, policyPhaseToLifecycleState, scorePatchDecision, selectRecoveryRecipe, type ExitDecision } from "./policy.js";
 import { evaluateChangeApprovalLeash, evaluateFilesystemLeash, evaluateSecretLeash, redactSecretsFromText, resolveExecutionProfile, evaluateVerificationLeash } from "./leash.js";
 import { buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations } from "./grounding.js";
@@ -7,7 +7,8 @@ import { type RunStore } from "./persistence/index.js";
 import { type ExitPolicyOverrides } from "./exits.js";
 import { type ExitSignalSource } from "./exit-signal.js";
 import { type VerifierExecutionBinding } from "./verified-handoff.js";
-export type { ApprovalPolicy, BudgetPreflightEstimate, BudgetSettlement, CostProvenance, EvidenceVector, ExecutionProfile, FailureClass, InterventionType, PatchDecision, PatchDecisionArtifact, PatchDecisionReasonCode, PatchScore, MutationMode, RollbackBoundaryArtifact, RollbackBoundaryStrategy, RollbackFileSnapshot, RollbackOutcomeArtifact, RollbackOutcomeStatus, PolicyPhase, CallStage, AgentRole, FirstDelta, RoutingEconomics } from "../contracts/index.js";
+export type { AgentExecutionIntent, ApprovalPolicy, BudgetPreflightEstimate, BudgetSettlement, CostProvenance, EvidenceVector, ExecutionProfile, FailureClass, InterventionType, PatchDecision, PatchDecisionArtifact, PatchDecisionReasonCode, PatchScore, MutationMode, RollbackBoundaryArtifact, RollbackBoundaryStrategy, RollbackFileSnapshot, RollbackOutcomeArtifact, RollbackOutcomeStatus, PolicyPhase, CallStage, AgentRole, FirstDelta, RoutingEconomics } from "../contracts/index.js";
+export { DEFAULT_AGENT_EXECUTION_INTENT, DEFAULT_PROVIDER_EXECUTION_TIMEOUT_MS, GOVERNED_AUTONOMOUS_BOUNDARY, normalizeProviderExecutionTimeoutMs } from "../contracts/index.js";
 export { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluateCostGovernor, evaluateBudgetPreflight, inferExit, nextPolicyPhase, policyPhaseToLifecycleState, scorePatchDecision, selectRecoveryRecipe, evaluateVerificationLeash, evaluateFilesystemLeash, evaluateChangeApprovalLeash, evaluateSecretLeash, resolveExecutionProfile, redactSecretsFromText, buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations, captureRollbackBoundary, listAttemptChangedFilesSinceBoundary, restoreRollbackBoundary };
 export type { BudgetPreflightDecision, BudgetPreflightInput, CostGovernorState, EvidenceVectorInput, EvaluatedPatchDecision, ExitDecision, FailureAssessment, PatchDecisionInput, RecoveryDecision, RecoveryRecipe } from "./policy.js";
 export type { ResolvedExecutionProfile, SafetyLeashDecision, SafetyViolation } from "./leash.js";
@@ -69,6 +70,8 @@ export interface MartinAdapterRequest {
         executionProfile?: ExecutionProfile;
         allowedNetworkDomains?: string[];
         approvalPolicy?: ApprovalPolicy;
+        agentExecutionIntent?: AgentExecutionIntent;
+        providerExecutionTimeoutMs?: number;
         focus: string;
         remainingBudgetUsd: number;
         remainingIterations: number;

package/dist/vendor/core/index.js

@@ -1,6 +1,6 @@
 import { spawnSync } from "node:child_process";
 import { isAbsolute, relative, resolve } from "node:path";
-import { appendLoopEvent, createLoopRecord } from "../contracts/index.js";
+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";
 import { buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations } from "./grounding.js";
@@ -15,6 +15,7 @@ import { runContextIntegrityPrecheck } from "./context-integrity.js";
 import { decideCircuitBreak } from "./trajectory.js";
 import { verifyContextHandoff, decideContextCircuitBreak } from "./context-handoff.js";
 import { verifierActuallyPassed, } from "./verified-handoff.js";
+export { DEFAULT_AGENT_EXECUTION_INTENT, DEFAULT_PROVIDER_EXECUTION_TIMEOUT_MS, GOVERNED_AUTONOMOUS_BOUNDARY, normalizeProviderExecutionTimeoutMs } from "../contracts/index.js";
 export { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluateCostGovernor, evaluateBudgetPreflight, inferExit, nextPolicyPhase, policyPhaseToLifecycleState, scorePatchDecision, selectRecoveryRecipe, evaluateVerificationLeash, evaluateFilesystemLeash, evaluateChangeApprovalLeash, evaluateSecretLeash, resolveExecutionProfile, redactSecretsFromText, buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations, captureRollbackBoundary, listAttemptChangedFilesSinceBoundary, restoreRollbackBoundary };
 export { buildContextGraphSnapshot, queryContextGraph } from "./context-graph.js";
 export { createLocalIdentityAuthority, hasIdentityScope, issueIdentityToken, verifyIdentityToken } from "./identity.js";
@@ -160,12 +161,16 @@ export function distillContext(loop, options = {}) {
 export async function runMartin(input) {
     const now = input.now ?? (() => new Date().toISOString());
     const idFactory = input.idFactory;
+    const providerExecutionTimeoutMs = normalizeProviderExecutionTimeoutMs(input.task.providerExecutionTimeoutMs);
+    const agentExecutionIntent = input.task.agentExecutionIntent ?? DEFAULT_AGENT_EXECUTION_INTENT;
     let loop = createLoopRecord({
         workspaceId: input.workspaceId,
         projectId: input.projectId,
-        task: input.task,
+        task: { ...input.task, agentExecutionIntent, providerExecutionTimeoutMs },
         budget: input.budget,
-        ...(input.receiptScope ? { receiptScope: input.receiptScope } : {}),
+        ...(input.receiptScope
+            ? { receiptScope: { ...input.receiptScope, agentExecutionIntent, providerExecutionTimeoutMs } }
+            : {}),
         ...(input.teamId ? { teamId: input.teamId } : {}),
         ...(input.metadata ? { metadata: input.metadata } : {})
     }, { now: now(), idFactory });
@@ -655,6 +660,8 @@ export async function runMartin(input) {
                             ? { allowedNetworkDomains: loop.task.allowedNetworkDomains }
                             : {}),
                         ...(loop.task.approvalPolicy ? { approvalPolicy: loop.task.approvalPolicy } : {}),
+                        agentExecutionIntent: loop.task.agentExecutionIntent ?? DEFAULT_AGENT_EXECUTION_INTENT,
+                        providerExecutionTimeoutMs: normalizeProviderExecutionTimeoutMs(loop.task.providerExecutionTimeoutMs),
                         focus: distilled.focus,
                         remainingBudgetUsd: distilled.constraints.remainingBudgetUsd,
                         remainingIterations: distilled.constraints.remainingIterations,
@@ -745,6 +752,8 @@ export async function runMartin(input) {
                         ? { allowedNetworkDomains: loop.task.allowedNetworkDomains }
                         : {}),
                     ...(loop.task.approvalPolicy ? { approvalPolicy: loop.task.approvalPolicy } : {}),
+                    agentExecutionIntent: loop.task.agentExecutionIntent ?? DEFAULT_AGENT_EXECUTION_INTENT,
+                    providerExecutionTimeoutMs: normalizeProviderExecutionTimeoutMs(loop.task.providerExecutionTimeoutMs),
                     focus: distilled.focus,
                     remainingBudgetUsd: distilled.constraints.remainingBudgetUsd,
                     remainingIterations: distilled.constraints.remainingIterations,

package/dist/vendor/presentation/governed-plan.d.ts

@@ -0,0 +1,33 @@
+import type { LoopBudget, ReceiptScope } from "../contracts/index.js";
+import { type RenderEnvironment } from "./theme.js";
+export type PlanStageState = "READY" | "BLOCKED" | "NEXT" | "CONDITIONAL";
+export interface GovernedPlanStage {
+    label: string;
+    state: PlanStageState;
+    gate: string;
+    purpose: string;
+}
+export interface GovernedRunPlanView {
+    ready: boolean;
+    task: string;
+    engine: string;
+    mode: "live" | "proof";
+    budget: LoopBudget;
+    verifier: string[];
+    receiptScope: ReceiptScope;
+    policyProfile: string;
+    blockingIssues: string[];
+    warnings: string[];
+    stages: GovernedPlanStage[];
+}
+export declare function buildGovernedPlanStages(input: Pick<GovernedRunPlanView, "ready" | "engine" | "verifier" | "blockingIssues">): GovernedPlanStage[];
+export declare function renderGovernedRunPlan(input: GovernedRunPlanView, options?: {
+    width?: number;
+    environment?: RenderEnvironment;
+}): string;
+/**
+ * Renders a GovernedRunPlanView as plain Markdown (no ANSI).
+ */
+export declare function renderGovernedRunPlanMarkdown(input: GovernedRunPlanView, options?: {
+    includeStatus?: boolean;
+}): string;

package/dist/vendor/presentation/governed-plan.js

@@ -0,0 +1,146 @@
+import { renderTable } from "./table.js";
+import { horizontalRule, terminalWidth, truncateVisible } from "./text.js";
+import { bold, paint, } from "./theme.js";
+function stageTone(state) {
+    switch (state) {
+        case "READY":
+            return "success";
+        case "BLOCKED":
+            return "danger";
+        case "NEXT":
+            return "info";
+        case "CONDITIONAL":
+            return "warning";
+    }
+}
+export function buildGovernedPlanStages(input) {
+    const blocked = !input.ready || input.blockingIssues.length > 0;
+    return [
+        {
+            label: "Contract & scope",
+            state: blocked ? "BLOCKED" : "READY",
+            gate: "request + paths",
+            purpose: "Bind the task to its governed workspace",
+        },
+        {
+            label: "Budget & policy",
+            state: blocked ? "BLOCKED" : "READY",
+            gate: "hard cap + policy",
+            purpose: "Arm execution limits before work starts",
+        },
+        {
+            label: "Agent execution",
+            state: blocked ? "BLOCKED" : "NEXT",
+            gate: input.engine,
+            purpose: "Run the selected coding agent",
+        },
+        {
+            label: "Verification",
+            state: input.verifier.length > 0 && !blocked ? "NEXT" : "BLOCKED",
+            gate: input.verifier.length > 0 ? input.verifier.join(", ") : "no verifier",
+            purpose: "Run configured completion checks",
+        },
+        {
+            label: "Recovery",
+            state: "CONDITIONAL",
+            gate: "stop / fail",
+            purpose: "Preserve rollback and recovery evidence",
+        },
+        {
+            label: "Proof",
+            state: blocked ? "BLOCKED" : "NEXT",
+            gate: "receipt",
+            purpose: "Produce the final governed record",
+        },
+    ];
+}
+function bounded(line, width) {
+    return truncateVisible(line, width);
+}
+export function renderGovernedRunPlan(input, options = {}) {
+    const environment = options.environment ?? {};
+    const width = terminalWidth(options.width);
+    const rows = input.stages.map((stage) => ({
+        ...stage,
+        renderedState: paint(stage.state, stageTone(stage.state), environment),
+    }));
+    const lines = [
+        horizontalRule(width, "━"),
+        bounded(bold("MARTINLOOP", environment) +
+            " ▸ " +
+            paint("GOVERNED RUN PLAN", input.ready ? "success" : "danger", environment), width),
+        horizontalRule(width, "━"),
+        "",
+        bounded(paint("Task".padEnd(18), "info", environment) + input.task, width),
+        bounded(paint("Engine".padEnd(18), "info", environment) + input.engine, width),
+        bounded(paint("Mode".padEnd(18), "info", environment) + input.mode, width),
+        "",
+        renderTable(rows, [
+            { header: "STAGE", value: (row) => row.label, minWidth: 18, maxWidth: 24 },
+            {
+                header: "STATUS",
+                value: (row) => row.renderedState,
+                minWidth: 12,
+                maxWidth: 14,
+            },
+            { header: "GATE", value: (row) => row.gate, minWidth: 18, maxWidth: 36 },
+            { header: "PURPOSE", value: (row) => row.purpose, minWidth: 24 },
+        ], width),
+        "",
+        bounded(bold("Budget cap", environment) +
+            "  " +
+            paint("$" + input.budget.maxUsd.toFixed(2), "success", environment), width),
+        bounded(bold("Soft limit", environment) +
+            "  $" +
+            input.budget.softLimitUsd.toFixed(2), width),
+        bounded(bold("Attempts", environment) + "    " + input.budget.maxIterations, width),
+        bounded(bold("Verifier", environment) +
+            "    " +
+            (input.verifier.join(", ") || "NOT CONFIGURED"), width),
+        bounded(bold("Policy", environment) + "      " + input.policyProfile, width),
+    ];
+    if (input.blockingIssues.length > 0) {
+        lines.push("", bold("BLOCKING", environment), ...input.blockingIssues.map((issue) => bounded("  " + paint("✗", "danger", environment) + " " + issue, width)));
+    }
+    if (input.warnings.length > 0) {
+        lines.push("", bold("WARNINGS", environment), ...input.warnings.map((warning) => bounded("  " + paint("!", "warning", environment) + " " + warning, width)));
+    }
+    lines.push("", input.ready
+        ? paint("✓ READY TO EXECUTE", "success", environment)
+        : paint("✗ PREFLIGHT BLOCKED", "danger", environment), horizontalRule(width, "━"));
+    return lines.map((line) => bounded(line, width)).join("\n");
+}
+/**
+ * Renders a GovernedRunPlanView as plain Markdown (no ANSI).
+ */
+export function renderGovernedRunPlanMarkdown(input, options = {}) {
+    void options;
+    const lines = [
+        `## MartinLoop Governed Run Plan — ${input.ready ? "READY" : "BLOCKED"}`,
+        "",
+        "| Field | Value |",
+        "|-------|-------|",
+        `| Task | ${input.task} |`,
+        `| Engine | ${input.engine} |`,
+        `| Mode | ${input.mode} |`,
+        `| Budget cap | $${input.budget.maxUsd.toFixed(2)} |`,
+        `| Soft limit | $${input.budget.softLimitUsd.toFixed(2)} |`,
+        `| Max attempts | ${input.budget.maxIterations} |`,
+        `| Verifier | ${input.verifier.join(", ") || "NOT CONFIGURED"} |`,
+        `| Policy | ${input.policyProfile} |`,
+        "",
+        "### Stages",
+        "",
+        "| Stage | Status | Gate | Purpose |",
+        "|-------|--------|------|---------|",
+        ...input.stages.map((s) => `| ${s.label} | ${s.state} | ${s.gate} | ${s.purpose} |`),
+    ];
+    if (input.blockingIssues.length > 0) {
+        lines.push("", "### Blocking Issues", "", ...input.blockingIssues.map((issue) => `- ✗ ${issue}`));
+    }
+    if (input.warnings.length > 0) {
+        lines.push("", "### Warnings", "", ...input.warnings.map((w) => `- ${w}`));
+    }
+    lines.push("", input.ready ? "**✓ READY TO EXECUTE**" : "**✗ PREFLIGHT BLOCKED**");
+    return lines.join("\n");
+}

package/dist/vendor/presentation/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./governed-plan.js";
+export * from "./motion.js";
+export * from "./status.js";
+export * from "./table.js";
+export * from "./text.js";
+export * from "./theme.js";
+export * from "./verified-handoff.js";

package/dist/vendor/presentation/index.js

@@ -0,0 +1,7 @@
+export * from "./governed-plan.js";
+export * from "./motion.js";
+export * from "./status.js";
+export * from "./table.js";
+export * from "./text.js";
+export * from "./theme.js";
+export * from "./verified-handoff.js";

package/dist/vendor/presentation/motion.d.ts

@@ -0,0 +1,12 @@
+import { type RenderEnvironment } from "./theme.js";
+export interface MotionEnvironment extends RenderEnvironment {
+    readonly outputMode?: "human" | "json" | "quiet";
+    readonly stdinIsTty?: boolean;
+    readonly stdoutIsTty?: boolean;
+    readonly ci?: boolean;
+    readonly noMotion?: boolean;
+}
+export declare function canAnimate(env?: MotionEnvironment): boolean;
+export declare function animateBannerShine(input: string, env?: MotionEnvironment): Promise<void>;
+export declare function withSpinner<T>(label: string, task: () => Promise<T>, env?: MotionEnvironment): Promise<T>;
+export declare function writeHumanOutputWithShine(text: string, env?: MotionEnvironment): Promise<void>;

package/dist/vendor/presentation/motion.js

@@ -0,0 +1,123 @@
+import { setTimeout as sleep } from "node:timers/promises";
+import { paint, terminalAnsi } from "./theme.js";
+import { stripAnsi } from "./text.js";
+function envFlag(name) {
+    const value = process.env[name];
+    return value === "1" || value === "true" || value === "yes";
+}
+export function canAnimate(env = {}) {
+    const mode = env.outputMode ?? "human";
+    if (mode !== "human") {
+        return false;
+    }
+    const noColor = env.noColor ?? Object.prototype.hasOwnProperty.call(process.env, "NO_COLOR");
+    if (noColor) {
+        return false;
+    }
+    const stdoutTty = env.stdoutIsTty ?? process.stdout.isTTY === true;
+    if (!stdoutTty) {
+        return false;
+    }
+    const ci = env.ci ?? Boolean(process.env.CI);
+    if (ci) {
+        return false;
+    }
+    const noMotion = env.noMotion ??
+        (envFlag("MARTIN_NO_MOTION") || envFlag("MARTIN_REDUCED_MOTION"));
+    if (noMotion) {
+        return false;
+    }
+    const term = env.term ?? process.env.TERM;
+    return term !== "dumb";
+}
+function shineCharacter(character, distance, env) {
+    if (character === " ") {
+        return character;
+    }
+    if (distance === 0) {
+        return paint(character, "plain", { ...env, color: "always" });
+    }
+    if (distance === 1) {
+        return paint(character, "info", { ...env, color: "always" });
+    }
+    return paint(character, "brand", { ...env, color: "always" });
+}
+export async function animateBannerShine(input, env = {}) {
+    if (!canAnimate(env)) {
+        return;
+    }
+    const target = [...stripAnsi(input)].slice(0, 100);
+    if (target.length === 0) {
+        return;
+    }
+    try {
+        process.stdout.write(terminalAnsi.hideCursor);
+        for (let center = -2; center < target.length + 4; center += 1) {
+            const frame = target
+                .map((character, index) => shineCharacter(character, Math.abs(index - center), env))
+                .join("");
+            process.stdout.write(terminalAnsi.cursorHome +
+                terminalAnsi.eraseLine +
+                frame +
+                terminalAnsi.reset);
+            await sleep(18);
+        }
+    }
+    finally {
+        process.stdout.write(terminalAnsi.cursorHome +
+            terminalAnsi.eraseLine +
+            terminalAnsi.reset +
+            terminalAnsi.showCursor);
+    }
+}
+const spinnerFrames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+export async function withSpinner(label, task, env = {}) {
+    if (!canAnimate(env)) {
+        return task();
+    }
+    let frame = 0;
+    process.stdout.write(terminalAnsi.hideCursor);
+    const timer = setInterval(() => {
+        const glyph = spinnerFrames[frame % spinnerFrames.length] ?? "•";
+        frame += 1;
+        process.stdout.write(terminalAnsi.cursorHome +
+            terminalAnsi.eraseLine +
+            paint(glyph, "brand", { ...env, color: "always" }) +
+            " " +
+            label);
+    }, 70);
+    try {
+        return await task();
+    }
+    finally {
+        clearInterval(timer);
+        process.stdout.write(terminalAnsi.cursorHome +
+            terminalAnsi.eraseLine +
+            terminalAnsi.reset +
+            terminalAnsi.showCursor);
+    }
+}
+export async function writeHumanOutputWithShine(text, env = {}) {
+    if (!text) {
+        return;
+    }
+    if (!canAnimate(env)) {
+        process.stdout.write(text + "\n");
+        return;
+    }
+    const lines = text.split("\n");
+    const headingIndex = lines.findIndex((line) => stripAnsi(line).toUpperCase().includes("MARTINLOOP"));
+    if (headingIndex < 0) {
+        process.stdout.write(text + "\n");
+        return;
+    }
+    if (headingIndex > 0) {
+        process.stdout.write(lines.slice(0, headingIndex).join("\n") + "\n");
+    }
+    const heading = lines[headingIndex] ?? "";
+    await animateBannerShine(heading, env);
+    process.stdout.write(heading + "\n");
+    if (headingIndex < lines.length - 1) {
+        process.stdout.write(lines.slice(headingIndex + 1).join("\n") + "\n");
+    }
+}

package/dist/vendor/presentation/status.d.ts

@@ -0,0 +1,8 @@
+import type { MartinTone } from "./theme.js";
+export type ProofStatus = "VERIFIED" | "NEEDS_REVIEW" | "STOPPED" | "FAILED" | "RUNNING" | "PENDING";
+export interface StatusPresentation {
+    readonly glyph: string;
+    readonly label: string;
+    readonly tone: MartinTone;
+}
+export declare function statusPresentation(status: ProofStatus): StatusPresentation;

package/dist/vendor/presentation/status.js

@@ -0,0 +1,11 @@
+const presentations = {
+    VERIFIED: { glyph: "✓", label: "VERIFIED", tone: "success" },
+    NEEDS_REVIEW: { glyph: "!", label: "NEEDS REVIEW", tone: "warning" },
+    STOPPED: { glyph: "■", label: "STOPPED", tone: "danger" },
+    FAILED: { glyph: "×", label: "FAILED", tone: "danger" },
+    RUNNING: { glyph: "◆", label: "RUNNING", tone: "info" },
+    PENDING: { glyph: "○", label: "PENDING", tone: "muted" },
+};
+export function statusPresentation(status) {
+    return presentations[status];
+}

package/dist/vendor/presentation/table.d.ts

@@ -0,0 +1,11 @@
+export interface TableColumn<Row> {
+    readonly header: string;
+    readonly value: (row: Row) => string;
+    readonly minWidth?: number;
+    readonly maxWidth?: number;
+}
+export interface RenderTableOptions {
+    readonly separator?: string;
+    readonly width?: number;
+}
+export declare function renderTable<Row>(rows: readonly Row[], columns: readonly TableColumn<Row>[], options?: RenderTableOptions | number): string;