@martinloop/mcp 0.5.5 → 0.5.7

package/dist/tools/run-store.js

@@ -641,7 +641,7 @@ function validateInspectableLoopRecord(value) {
         !isFiniteNumber(budget["maxUsd"]) ||
         !isFiniteNumber(budget["softLimitUsd"]) ||
         !Number.isInteger(budget["maxIterations"]) ||
-        !Number.isInteger(budget["maxTokens"]) ||
+        (budget["maxTokens"] !== undefined && !Number.isInteger(budget["maxTokens"])) ||
         !isRecord(cost) ||
         !isFiniteNumber(cost["actualUsd"]) ||
         !isFiniteNumber(cost["tokensIn"]) ||

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

@@ -6,7 +6,8 @@ export interface InspectableLoopAttempt extends LoopAttemptRecord {
     attemptId?: string;
     summary?: string;
 }
-export interface InspectableLoopRecord extends Omit<LoopRunRecord, "attempts" | "task"> {
+export interface InspectableLoopRecord extends Omit<LoopRunRecord, "attempts" | "task" | "budget"> {
+    budget: LoopBudget;
     attempts: InspectableLoopAttempt[];
     task?: LoopTask;
     artifacts?: LoopArtifact[];
@@ -33,7 +34,7 @@ export interface LoopPreview {
     shouldStop: boolean;
     remainingBudgetUsd: number;
     remainingIterations: number;
-    remainingTokens: number;
+    remainingTokens?: number;
     lastAttempt?: AttemptSummary;
     routingEconomics?: Record<string, unknown>;
 }

package/dist/tools/tool-support.js

@@ -157,7 +157,9 @@ export function buildLoopPreview(loop) {
         shouldStop: costState.shouldStop,
         remainingBudgetUsd: costState.remainingBudgetUsd,
         remainingIterations: costState.remainingIterations,
-        remainingTokens: costState.remainingTokens,
+        ...(costState.remainingTokens !== undefined
+            ? { remainingTokens: costState.remainingTokens }
+            : {}),
         ...(lastAttempt ? { lastAttempt: buildAttemptSummary(lastAttempt) } : {}),
         ...(loop.routingEconomics ? { routingEconomics: buildRoutingEconomicsSummary(loop.routingEconomics) } : {})
     };
@@ -291,7 +293,12 @@ export function buildCostSnapshot(cost) {
     };
 }
 export function buildBudgetSnapshot(budget) {
-    return { maxUsd: budget.maxUsd, softLimitUsd: budget.softLimitUsd, maxIterations: budget.maxIterations, maxTokens: budget.maxTokens };
+    return {
+        maxUsd: budget.maxUsd,
+        softLimitUsd: budget.softLimitUsd,
+        maxIterations: budget.maxIterations,
+        ...(budget.maxTokens !== undefined ? { maxTokens: budget.maxTokens } : {})
+    };
 }
 export function buildSuggestedResourceUris(loopId) {
     return ["martin://server/health", "martin://runs/recent", "martin://runs/triage", "martin://runs/latest", "martin://runs/latest/summary", "martin://runs/latest/proof-card", "martin://runs/latest/budget-status", "martin://runs/latest/verifier-evidence", "martin://runs/latest/rollback-evidence", "martin://policies/current", "martin://repo/risk-map", "martin://verifiers/results", "martin://agent/next-step", `martin://runs/${loopId}`, `martin://runs/${loopId}/dossier`, `martin://runs/${loopId}/verification`, "martin://guides/mcp-usage", "martin://guides/agent-start", "martin://guides/publish-readiness"];

package/dist/tools/workflow-governance.d.ts

@@ -50,7 +50,7 @@ export interface MartinPlanBudget {
     maxUsd: number;
     softLimitUsd: number;
     maxIterations: number;
-    maxTokens: number;
+    maxTokens?: number;
     maxMinutes: number;
     maxFilesChanged: number;
     maxCommands: number;

package/dist/tools/workflow-governance.js

@@ -271,7 +271,7 @@ export function normalizeLoopBudget(overrides = {}) {
         maxUsd,
         softLimitUsd,
         maxIterations: overrides.maxIterations ?? DEFAULT_BUDGET.maxIterations,
-        maxTokens: overrides.maxTokens ?? DEFAULT_BUDGET.maxTokens
+        ...(overrides.maxTokens !== undefined ? { maxTokens: overrides.maxTokens } : {})
     };
 }
 export function assessRunRisk(input) {

package/dist/vendor/adapters/claude-cli.js

@@ -749,6 +749,7 @@ export function createAgentCliAdapter(options) {
                 workspaceId: request.workspaceId,
                 cwd: workingDirectory,
             });
+            const verificationConfigured = verification.binding.commands.length > 0;
             // Check for zero-diff (agent ran but made no file changes)
             const postRunChangedFiles = gitRepoRoot
                 ? await readGitChangedFiles(gitRepoRoot, 5_000, options.spawnImpl)
@@ -791,7 +792,7 @@ export function createAgentCliAdapter(options) {
             }
             // Derive structural classHint from evidence, not keyword scanning
             const structuralHint = inferStructuralClassHint(agentText, verification.summary, agentResult.exitCode, request.context.objective);
-            if (verification.passed) {
+            if (verification.passed || !verificationConfigured) {
                 return {
                     status: "completed",
                     summary,

package/dist/vendor/adapters/cli-bridge.js

@@ -154,7 +154,13 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
         commands: steps.map((step) => step.command),
     };
     if (steps.length === 0) {
-        return { passed: true, summary: "No verification commands specified.", steps: [], binding: executionBinding };
+        return {
+            passed: false,
+            summary: "No verification commands specified; execution is not VERIFIED.",
+            steps: [],
+            warnings: ["Execution completed without verifier evidence."],
+            binding: executionBinding,
+        };
     }
     const failedSteps = [];
     const stepOutcomes = [];

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

@@ -4,5 +4,6 @@ export { createCodexCliAdapter, type CodexCliAdapterOptions } from "./codex-cli.
 export { createOpenAiCompatibleAdapter, resolveOpenAiCompatibleRuntimeConfig, type OpenAiCompatibleAdapterOptions } from "./openai-compatible.js";
 export { createVerifierOnlyAdapter, type VerifierOnlyAdapterOptions } from "./verifier-only.js";
 /** @internal Test-only compatibility export. Public package builders strip this surface. */
+export { createStubAgentCliAdapter, type StubAgentCliAdapterOptions, createStubDirectProviderAdapter, type StubDirectProviderAdapterOptions } from "./stub-agent-cli.js";
 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

@@ -4,5 +4,6 @@ export { createCodexCliAdapter } from "./codex-cli.js";
 export { createOpenAiCompatibleAdapter, resolveOpenAiCompatibleRuntimeConfig } from "./openai-compatible.js";
 export { createVerifierOnlyAdapter } from "./verifier-only.js";
 /** @internal Test-only compatibility export. Public package builders strip this surface. */
+export { createStubAgentCliAdapter, createStubDirectProviderAdapter } from "./stub-agent-cli.js";
 export { buildCodexExecArgs, buildCodexStdin, clearCodexCapabilityCacheForTests, detectCodexHostPlatform, diagnoseCodexHost, probeCodexCapabilities, probeCodexLaunch, resolveCliCommandAvailability, checkCodexSandboxPreflight, probeFilesystemWriteCapability } from "./codex-launcher.js";
 export { createSpawnPlan } from "./cli-bridge.js";

package/dist/vendor/adapters/openai-compatible.js

@@ -347,11 +347,14 @@ export function createOpenAiCompatibleAdapter(options) {
                     ? (await readGitChangedFiles(workingDirectory, 5_000)).filter((file) => !baselineChangedFiles.has(file))
                     : []
             };
+            const verificationConfigured = verification.binding.commands.length > 0;
             return {
-                status: verification.passed ? "completed" : "failed",
+                status: verification.passed || !verificationConfigured ? "completed" : "failed",
                 summary: verification.passed
                     ? `${model} completed the task. Verifier passed.`
-                    : `${model} completed but verifier failed: ${verification.summary}`,
+                    : !verificationConfigured
+                        ? `${model} completed the task without verifier evidence; outcome is not VERIFIED.`
+                        : `${model} completed but verifier failed: ${verification.summary}`,
                 usage: normalizeOpenAiCompatibleUsage({
                     model,
                     tokensIn,
@@ -362,7 +365,7 @@ export function createOpenAiCompatibleAdapter(options) {
                 }),
                 verification,
                 execution,
-                ...(verification.passed ? {} : {
+                ...(verification.passed || !verificationConfigured ? {} : {
                     failure: { message: verification.summary }
                 })
             };

package/dist/vendor/adapters/stub-agent-cli.d.ts

@@ -0,0 +1,9 @@
+import type { MartinAdapter, MartinAdapterRequest, MartinAdapterResult } from "../core/index.js";
+export interface StubAgentCliAdapterOptions {
+    command: string[];
+    profile?: string;
+    label?: string;
+    responder?: (request: MartinAdapterRequest) => Promise<MartinAdapterResult> | MartinAdapterResult;
+}
+export declare function createStubAgentCliAdapter(options: StubAgentCliAdapterOptions): MartinAdapter;
+export { createStubDirectProviderAdapter, type StubDirectProviderAdapterOptions } from "./stub-direct-provider.js";

package/dist/vendor/adapters/stub-agent-cli.js

@@ -0,0 +1,43 @@
+import { createAdapterCapabilities } from "./runtime-support.js";
+export function createStubAgentCliAdapter(options) {
+    const metadata = {
+        command: options.command.join(" "),
+        providerId: "agent-cli",
+        model: options.profile ?? options.command[0] ?? "default",
+        transport: "cli",
+        capabilities: createAdapterCapabilities(),
+        ...(options.profile ? { profile: options.profile } : {})
+    };
+    return {
+        adapterId: `agent-cli:stub:${options.command.join(":")}`,
+        kind: "agent-cli",
+        label: options.label ?? `Stub agent CLI (${options.command.join(" ")})`,
+        metadata,
+        async execute(request) {
+            if (options.responder) {
+                return await options.responder(request);
+            }
+            return {
+                status: "failed",
+                summary: `Stub agent CLI ${options.command.join(" ")} did not execute a live session.`,
+                usage: {
+                    actualUsd: 0,
+                    tokensIn: 0,
+                    tokensOut: 0,
+                    provenance: "unavailable"
+                },
+                verification: {
+                    passed: false,
+                    summary: "No CLI execution was attempted."
+                },
+                failure: {
+                    message: `Agent CLI ${options.command.join(" ")} is not configured for live execution.`,
+                    classHint: "environment_mismatch"
+                }
+            };
+        }
+    };
+}
+// Internal test-compatibility re-export. Public builders remove the entire
+// stub compatibility surface before constructing distributable packages.
+export { createStubDirectProviderAdapter } from "./stub-direct-provider.js";

package/dist/vendor/adapters/stub-direct-provider.d.ts

@@ -0,0 +1,8 @@
+import type { MartinAdapter, MartinAdapterRequest, MartinAdapterResult } from "../core/index.js";
+export interface StubDirectProviderAdapterOptions {
+    providerId: string;
+    model: string;
+    label?: string;
+    responder?: (request: MartinAdapterRequest) => Promise<MartinAdapterResult> | MartinAdapterResult;
+}
+export declare function createStubDirectProviderAdapter(options: StubDirectProviderAdapterOptions): MartinAdapter;

package/dist/vendor/adapters/stub-direct-provider.js

@@ -0,0 +1,16 @@
+import { createDirectProviderAdapter } from "./direct-provider.js";
+export function createStubDirectProviderAdapter(options) {
+    const adapter = createDirectProviderAdapter({
+        providerId: options.providerId,
+        model: options.model,
+        label: options.label ?? `Stub direct provider (${options.providerId}/${options.model})`,
+        capabilities: {
+            workspaceMutations: false
+        },
+        responder: options.responder
+    });
+    return {
+        ...adapter,
+        adapterId: `direct:stub:${options.providerId}:${options.model}`,
+    };
+}

package/dist/vendor/adapters/verifier-only.js

@@ -26,7 +26,7 @@ export function createVerifierOnlyAdapter(options = {}) {
             const verification = await runVerification(request.context.verificationPlan, workingDirectory, verifyTimeoutMs, request.context.verificationStack, options.spawnImpl, {
                 runId: request.loopId,
                 workspaceId: request.workspaceId,
-                cwd: workingDirectory
+                cwd: workingDirectory,
             });
             const changedFiles = shouldTrackVerifierWrites
                 ? (await readGitChangedFiles(workingDirectory, 5_000)).filter((file) => !baselineChangedFiles.has(file))

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

@@ -14,7 +14,7 @@ export function cloneExecutionPolicy(policy) {
             maxUsd: policy.budget.maxUsd,
             softLimitUsd: policy.budget.softLimitUsd,
             maxIterations: policy.budget.maxIterations,
-            maxTokens: policy.budget.maxTokens
+            ...(policy.budget.maxTokens !== undefined ? { maxTokens: policy.budget.maxTokens } : {})
         },
         governance: {
             policyProfile: policy.governance.policyProfile,

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

@@ -44,7 +44,7 @@ export interface ExitPolicyV1 {
     };
     budget: {
         maxUsd: number;
-        maxTokens: number;
+        maxTokens?: number;
     };
     wallClock: {
         maxElapsedMs: number;

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

@@ -5,7 +5,7 @@ export type GovernanceSnapshot = {
     policyProfile: PolicyProfile;
     maxUsd: number;
     softLimitUsd: number;
-    maxTokens: number;
+    maxTokens?: number;
     maxIterations: number;
     allowedAdapters: string[];
     allowedModels: string[];

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

@@ -63,7 +63,7 @@ export interface LoopBudget {
     maxUsd: number;
     softLimitUsd: number;
     maxIterations: number;
-    maxTokens: number;
+    maxTokens?: number;
 }
 export interface LoopCost {
     actualUsd: number;

package/dist/vendor/contracts/index.js

@@ -27,8 +27,7 @@ export { MARTIN_ERROR_CATEGORIES } from "./operator.js";
 export const DEFAULT_BUDGET = {
     maxUsd: 25,
     softLimitUsd: 15,
-    maxIterations: 8,
-    maxTokens: 80_000
+    maxIterations: 8
 };
 export const EMPTY_COST = {
     actualUsd: 0,

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

@@ -1,4 +1,4 @@
-export declare const MARTIN_ERROR_CATEGORIES: readonly ["invalid_input", "environment", "auth", "not_found", "store_unreadable", "verification_failed", "policy_blocked", "budget_exit", "transient", "install_failed"];
+export declare const MARTIN_ERROR_CATEGORIES: readonly ["invalid_input", "environment", "auth", "not_found", "store_unreadable", "verification_failed", "policy_blocked", "budget_exit", "transient"];
 export type MartinErrorCategory = (typeof MARTIN_ERROR_CATEGORIES)[number];
 export type MartinOutputMode = "human" | "json" | "quiet";
 export interface MartinRunSelector {

package/dist/vendor/contracts/operator.js

@@ -7,6 +7,5 @@ export const MARTIN_ERROR_CATEGORIES = [
     "verification_failed",
     "policy_blocked",
     "budget_exit",
-    "transient",
-    "install_failed"
+    "transient"
 ];

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

@@ -20,7 +20,7 @@ export interface CompilerAdapterRequest {
         focus: string;
         remainingBudgetUsd: number;
         remainingIterations: number;
-        remainingTokens: number;
+        remainingTokens?: number;
     };
     previousAttempts: LoopAttempt[];
 }
@@ -41,7 +41,7 @@ export interface PromptPacket {
     budgetEnvelope: {
         remainingBudgetUsd: number;
         remainingIterations: number;
-        remainingTokens: number;
+        remainingTokens?: number;
     };
 }
 /**

package/dist/vendor/core/compiler.js

@@ -41,7 +41,9 @@ export function compilePromptPacket(request) {
         budgetEnvelope: {
             remainingBudgetUsd: request.context.remainingBudgetUsd,
             remainingIterations: request.context.remainingIterations,
-            remainingTokens: request.context.remainingTokens
+            ...(request.context.remainingTokens !== undefined
+                ? { remainingTokens: request.context.remainingTokens }
+                : {})
         }
     };
 }

package/dist/vendor/core/exits.js

@@ -26,7 +26,10 @@ export function createDefaultExitPolicy(budget, overrides = {}) {
         schemaVersion: "exit-policy/1",
         goal: { verifierRequired: true, minimumScore: 1 },
         turns: { max: budget.maxIterations },
-        budget: { maxUsd: budget.maxUsd, maxTokens: budget.maxTokens },
+        budget: {
+            maxUsd: budget.maxUsd,
+            ...(budget.maxTokens !== undefined ? { maxTokens: budget.maxTokens } : {})
+        },
         wallClock: { maxElapsedMs: 30 * 60 * 1000 },
         progress: { windowSize: 3, unchangedStateLimit: 3 },
         errors: { maxConsecutive: 3 },
@@ -49,7 +52,9 @@ export function createDefaultExitPolicy(budget, overrides = {}) {
 export function validateExitPolicy(policy) {
     assertFinitePositive("turns.max", policy.turns.max);
     assertFinitePositive("budget.maxUsd", policy.budget.maxUsd);
-    assertFinitePositive("budget.maxTokens", policy.budget.maxTokens);
+    if (policy.budget.maxTokens !== undefined) {
+        assertFinitePositive("budget.maxTokens", policy.budget.maxTokens);
+    }
     assertFinitePositive("wallClock.maxElapsedMs", policy.wallClock.maxElapsedMs);
     assertFinitePositive("progress.windowSize", policy.progress.windowSize);
     assertFinitePositive("progress.unchangedStateLimit", policy.progress.unchangedStateLimit);
@@ -117,13 +122,13 @@ export function evaluateExitPolicy(policy, snapshot) {
     }
     // 5. Budget cap
     const usdExceeded = snapshot.actualUsd >= policy.budget.maxUsd;
-    const tokensExceeded = snapshot.tokensUsed >= policy.budget.maxTokens;
+    const tokensExceeded = policy.budget.maxTokens !== undefined && snapshot.tokensUsed >= policy.budget.maxTokens;
     if (usdExceeded || tokensExceeded) {
         push("budget_cap", "Run token or dollar budget reached.", {
             actualUsd: snapshot.actualUsd,
             maxUsd: policy.budget.maxUsd,
             tokensUsed: snapshot.tokensUsed,
-            maxTokens: policy.budget.maxTokens,
+            ...(policy.budget.maxTokens !== undefined ? { maxTokens: policy.budget.maxTokens } : {}),
             usdExceeded,
             tokensExceeded
         });

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

@@ -9,6 +9,7 @@ export interface RepoGroundingIndex {
     createdAt: string;
     fileCount: number;
     files: RepoGroundingFile[];
+    trackedPaths?: string[];
     repositoryFingerprint?: string;
 }
 export interface RepoGroundingHit {

package/dist/vendor/core/grounding.js

@@ -1,7 +1,10 @@
 import { createHash } from "node:crypto";
+import { execFile } from "node:child_process";
 import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { extname, join, relative } from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
 const TEXT_EXTENSIONS = new Set([
     ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
     ".json", ".md", ".yaml", ".yml", ".py", ".go",
@@ -42,21 +45,42 @@ export async function loadOrBuildRepoGroundingIndex(repoRoot) {
 export async function buildRepoGroundingIndex(repoRoot, repositoryFingerprint) {
     const files = [];
     const discovered = await walk(repoRoot, repoRoot, files, { count: 0 });
+    const trackedPaths = await loadTrackedPaths(repoRoot);
     return {
         schemaVersion: "martin.grounding.v1",
         repoRoot,
         createdAt: new Date().toISOString(),
         fileCount: discovered.count,
         files,
+        ...(trackedPaths.length > 0 ? { trackedPaths } : {}),
         repositoryFingerprint: repositoryFingerprint ?? await computeRepositoryFingerprint(repoRoot)
     };
 }
 async function computeRepositoryFingerprint(repoRoot) {
     const entries = [];
     await collectFingerprintEntries(repoRoot, repoRoot, entries, { count: 0 });
+    for (const trackedPath of await loadTrackedPaths(repoRoot)) {
+        entries.push(`tracked:${trackedPath}`);
+    }
     entries.sort();
     return createHash("sha256").update(entries.join("\n")).digest("hex");
 }
+async function loadTrackedPaths(repoRoot) {
+    try {
+        const { stdout } = await execFileAsync("git", ["-C", repoRoot, "ls-files", "-z"], {
+            encoding: "utf8",
+            windowsHide: true
+        });
+        return stdout
+            .split("\0")
+            .map((filePath) => filePath.trim().replace(/\\/g, "/"))
+            .filter(Boolean)
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
 async function collectFingerprintEntries(repoRoot, currentDir, entries, state) {
     if (state.count >= MAX_FILES)
         return;
@@ -193,7 +217,10 @@ function tokenize(input) {
 export function scanPatchForGroundingViolations(diff, index, options = {}) {
     const violations = [];
     const resolvedFiles = [];
-    const indexedPaths = new Set(index.files.map((file) => file.path));
+    const indexedPaths = new Set([
+        ...index.files.map((file) => file.path),
+        ...(index.trackedPaths ?? [])
+    ]);
     const indexedSymbols = new Set(index.files.flatMap((file) => file.symbols.map((symbol) => symbol.toLowerCase())));
     const referencedFiles = new Set();
     const addedFiles = new Set();

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

@@ -75,7 +75,7 @@ export interface MartinAdapterRequest {
         focus: string;
         remainingBudgetUsd: number;
         remainingIterations: number;
-        remainingTokens: number;
+        remainingTokens?: number;
     };
     previousAttempts: LoopAttempt[];
     /** Abort signal propagated from the harness — adapters should honour it. */
@@ -165,7 +165,7 @@ export interface DistilledContext {
     constraints: {
         remainingBudgetUsd: number;
         remainingIterations: number;
-        remainingTokens: number;
+        remainingTokens?: number;
     };
 }
 export interface AttemptPolicyDecision {

package/dist/vendor/core/index.js

@@ -1,5 +1,3 @@
-import { spawnSync } from "node:child_process";
-import { isAbsolute, relative, resolve } from "node:path";
 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";
@@ -154,7 +152,9 @@ export function distillContext(loop, options = {}) {
         constraints: {
             remainingBudgetUsd: roundUsd(loop.budget.maxUsd - loop.cost.actualUsd),
             remainingIterations: Math.max(loop.budget.maxIterations - loop.attempts.length, 0),
-            remainingTokens: Math.max(loop.budget.maxTokens - loop.cost.tokensIn - loop.cost.tokensOut, 0)
+            ...(loop.budget.maxTokens !== undefined
+                ? { remainingTokens: Math.max(loop.budget.maxTokens - loop.cost.tokensIn - loop.cost.tokensOut, 0) }
+                : {})
         }
     };
 }
@@ -796,6 +796,7 @@ export async function runMartin(input) {
             const attemptCompletedAt = now();
             const compiledContext = compilePromptPacket(request);
             const expectedVerifierBinding = resolveExpectedVerifierBinding(request);
+            const verifierConfigured = expectedVerifierBinding.commands.length > 0;
             const verification = normalizeVerificationOutcome(result, expectedVerifierBinding);
             // PATCH → VERIFY
             currentPhase = "VERIFY";
@@ -1135,17 +1136,12 @@ export async function runMartin(input) {
             // Uses the task's repoRoot to build/load the grounding index, then scans any diff
             let groundingScanResult;
             const patchDiff = buildPatchDiff(result, changedFiles);
-            const workspaceMutationCapable = executingAdapter.metadata.capabilities?.workspaceMutations !== false;
-            const hasReportedOrObservedChanges = changedFiles.length > 0 || (result.execution?.changedFiles?.length ?? 0) > 0;
-            const groundingEvidenceRequired = result.status === "completed" && workspaceMutationCapable && hasReportedOrObservedChanges;
-            let groundingEvidenceAvailable = !groundingEvidenceRequired;
-            if (groundingEvidenceRequired && patchDiff && input.task.repoRoot) {
+            if (patchDiff && input.task.repoRoot) {
                 try {
                     const groundingIndex = await loadOrBuildRepoGroundingIndex(input.task.repoRoot);
-                    groundingScanResult = reconcileExistingGroundingFiles(scanPatchForGroundingViolations(patchDiff, groundingIndex, {
+                    groundingScanResult = scanPatchForGroundingViolations(patchDiff, groundingIndex, {
                         allowedPaths: input.task.allowedPaths
-                    }), input.task.repoRoot, rollbackBoundary);
-                    groundingEvidenceAvailable = true;
+                    });
                     if (input.store && groundingScanResult.violations.length > 0) {
                         await input.store.appendLedger(loop.loopId, makeLedgerEvent({
                             kind: "grounding.violations_found",
@@ -1161,22 +1157,10 @@ export async function runMartin(input) {
                     }
                 }
                 catch {
-                    // Availability is persisted below so scanner failures and missing
-                    // grounding inputs follow the same recover-forward trust contract.
+                    // Grounding scan is best-effort — never fail the loop because of a scan error
                 }
             }
-            if (groundingEvidenceRequired && !groundingEvidenceAvailable) {
-                // The completed work remains useful, but unavailable grounding evidence
-                // cannot be converted into a zero-violation governance claim.
-                loop = {
-                    ...loop,
-                    metadata: {
-                        ...loop.metadata,
-                        groundingEvidenceStatus: "unavailable"
-                    }
-                };
-            }
-            const shouldEvaluatePatchTruth = result.status === "completed" && tracksWorkspaceMutations && groundingEvidenceAvailable;
+            const shouldEvaluatePatchTruth = result.status === "completed" && tracksWorkspaceMutations && verifierConfigured;
             let patchDecision;
             if (shouldEvaluatePatchTruth) {
                 patchDecision = evaluatePatchDecision({
@@ -1237,7 +1221,7 @@ export async function runMartin(input) {
                 }
                 else {
                     await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                        kind: verification.passed ? "attempt.kept" : "attempt.discarded",
+                        kind: verification.passed || !verifierConfigured ? "attempt.kept" : "attempt.discarded",
                         runId: loop.loopId,
                         attemptIndex: currentAttemptIndex,
                         payload: { reason: verification.summary }
@@ -1314,6 +1298,7 @@ export async function runMartin(input) {
                 lastResult: effectiveResult,
                 lastFailure: failure,
                 costState,
+                verificationRequired: verifierConfigured,
                 canSwitchAdapter: failure?.recommendedIntervention === "switch_adapter" &&
                     adapterChain[currentAdapterIndex] !== undefined &&
                     currentAdapter.adapterId !== executingAdapter.adapterId
@@ -1578,9 +1563,6 @@ function mergeCostProvenance(previous, current) {
     return COST_PROVENANCE_RANK[current] < COST_PROVENANCE_RANK[previous] ? current : previous;
 }
 function resolveChangedFiles(result, repoRoot, rollbackBoundary) {
-    if (repoRoot && rollbackBoundary?.headRef) {
-        return listAttemptChangedFilesSinceBoundary({ repoRoot, boundary: rollbackBoundary });
-    }
     if (result.execution?.changedFiles !== undefined) {
         return result.execution.changedFiles;
     }
@@ -1601,41 +1583,6 @@ function buildPatchDiff(result, changedFiles) {
     }
     return undefined;
 }
-function reconcileExistingGroundingFiles(scan, repoRoot, boundary) {
-    const resolvedFiles = new Set(scan.resolvedFiles);
-    const violations = scan.violations.filter((violation) => {
-        if (violation.kind !== "file_not_found") {
-            return true;
-        }
-        const absolutePath = resolve(repoRoot, violation.reference);
-        const relativePath = relative(repoRoot, absolutePath);
-        const isInsideRepo = relativePath.length > 0 && !relativePath.startsWith("..") && !isAbsolute(relativePath);
-        if (!isInsideRepo || !isTrackedRepoFileAtBoundary(repoRoot, violation.reference, boundary)) {
-            return true;
-        }
-        resolvedFiles.add(violation.reference);
-        return false;
-    });
-    return {
-        ...scan,
-        violations,
-        resolvedFiles: [...resolvedFiles]
-    };
-}
-function isTrackedRepoFileAtBoundary(repoRoot, filePath, boundary) {
-    if (!boundary) {
-        return false;
-    }
-    const normalizedPath = filePath.replace(/\\/gu, "/");
-    if (boundary.snapshots.some((snapshot) => snapshot.existed && snapshot.path === normalizedPath)) {
-        return true;
-    }
-    if (!boundary.headRef) {
-        return false;
-    }
-    const result = spawnSync("git", ["-C", repoRoot, "cat-file", "-e", `${boundary.headRef}:${normalizedPath}`], { encoding: "utf8", stdio: "ignore", windowsHide: true });
-    return result.status === 0;
-}
 function createBudgetSettlement(input) {
     const totalActualUsd = getUsageUsd(input.usage);
     return {