@martinloop/mcp 0.5.3 → 0.5.6

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/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,4 @@
-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 +13,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 +159,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 +658,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 +750,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,
@@ -787,6 +794,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";
@@ -1126,17 +1134,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",
@@ -1152,22 +1155,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({
@@ -1228,7 +1219,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 }
@@ -1305,6 +1296,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
@@ -1569,9 +1561,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;
     }
@@ -1592,41 +1581,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 {

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

@@ -97,6 +97,7 @@ export declare function inferExit(input: {
     lastFailure?: FailureAssessment;
     costState: CostGovernorState;
     canSwitchAdapter?: boolean;
+    verificationRequired?: boolean;
 }): ExitDecision;
 export interface BudgetPreflightInput {
     promptCharCount: number;

package/dist/vendor/core/policy.js

@@ -210,6 +210,14 @@ export function calculateCostPerOutcome(input) {
     };
 }
 export function inferExit(input) {
+    if (input.lastResult.status === "completed" && input.verificationRequired === false) {
+        return {
+            shouldExit: true,
+            lifecycleState: "completed",
+            status: "completed",
+            reason: "Execution-only work completed without verifier evidence; outcome is not VERIFIED."
+        };
+    }
     if (input.lastResult.status === "completed" && input.lastResult.verification.passed) {
         return {
             shouldExit: true,

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

@@ -1,4 +1,7 @@
 import type { PatchDecision, RollbackBoundaryArtifact, RollbackOutcomeArtifact } from "../contracts/index.js";
+export declare class RollbackStateUnavailableError extends Error {
+    constructor(message: string);
+}
 export declare function listAttemptChangedFilesSinceBoundary(input: {
     repoRoot?: string;
     boundary?: RollbackBoundaryArtifact;

package/dist/vendor/core/rollback.js

@@ -1,7 +1,12 @@
 import { spawnSync } from "node:child_process";
-import { readFileSync } from "node:fs";
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname, relative, resolve } from "node:path";
+export class RollbackStateUnavailableError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "RollbackStateUnavailableError";
+    }
+}
 export function listAttemptChangedFilesSinceBoundary(input) {
     if (!input.repoRoot) {
         return [];
@@ -12,24 +17,11 @@ export function listAttemptChangedFilesSinceBoundary(input) {
     }
     const baselineTracked = new Set(input.boundary.trackedDirtyFiles);
     const baselineUntracked = new Set(input.boundary.untrackedFiles);
-    const baselineContentChanges = input.boundary.snapshots
-        .filter((snapshot) => snapshot.existed && repoFileDiffersFromSnapshot(input.repoRoot, snapshot))
-        .map((snapshot) => snapshot.path);
     return uniqueSorted([
         ...repoState.trackedDirtyFiles.filter((filePath) => !baselineTracked.has(filePath)),
-        ...repoState.untrackedFiles.filter((filePath) => !baselineUntracked.has(filePath)),
-        ...baselineContentChanges
+        ...repoState.untrackedFiles.filter((filePath) => !baselineUntracked.has(filePath))
     ]);
 }
-function repoFileDiffersFromSnapshot(repoRoot, snapshot) {
-    try {
-        const current = readFileSync(resolveRepoPath(repoRoot, snapshot.path));
-        return current.toString("base64") !== snapshot.contentBase64;
-    }
-    catch {
-        return true;
-    }
-}
 export async function captureRollbackBoundary(input) {
     if (!input.repoRoot) {
         return undefined;
@@ -147,6 +139,7 @@ function readRepoState(repoRoot) {
     };
 }
 function readGitLines(repoRoot, args) {
+    let lastFailure = "unknown Git failure";
     for (let attempt = 0; attempt < 2; attempt++) {
         const result = spawnSync("git", args, {
             cwd: repoRoot,
@@ -158,13 +151,14 @@ function readGitLines(repoRoot, args) {
                 .map((line) => normalizeRepoPath(line))
                 .filter(Boolean));
         }
+        lastFailure = gitFailureMessage(result);
         // Retry once after a short delay — handles git lock-file contention
         // that occurs when another process holds .git/index.lock.
         if (attempt === 0 && result.status !== 0) {
-            spawnSync("sleep", ["0.5"], { encoding: "utf8" });
+            delaySynchronously(500);
         }
     }
-    return [];
+    throw new RollbackStateUnavailableError(`Git rollback state unavailable for ${args.join(" ")}: ${lastFailure}`);
 }
 function readGitScalar(repoRoot, args) {
     const result = spawnSync("git", args, {
@@ -172,7 +166,7 @@ function readGitScalar(repoRoot, args) {
         encoding: "utf8"
     });
     if (result.status !== 0 || typeof result.stdout !== "string") {
-        return undefined;
+        throw new RollbackStateUnavailableError(`Git rollback state unavailable for ${args.join(" ")}: ${gitFailureMessage(result)}`);
     }
     const value = result.stdout.trim();
     return value.length > 0 ? value : undefined;
@@ -188,7 +182,10 @@ async function readRollbackSnapshot(repoRoot, filePath) {
             contentBase64: contents.toString("base64")
         };
     }
-    catch {
+    catch (error) {
+        if (!isFileNotFoundError(error)) {
+            throw new RollbackStateUnavailableError(`Rollback snapshot unavailable for ${normalizeRepoPath(filePath)}: ${toErrorMessage(error)}`);
+        }
         return {
             path: normalizeRepoPath(filePath),
             existed: false,
@@ -214,7 +211,7 @@ function restoreTrackedFileFromHead(repoRoot, filePath) {
         return;
     }
     // Retry once after a short delay (git lock-file contention)
-    spawnSync("sleep", ["0.5"], { encoding: "utf8" });
+    delaySynchronously(500);
     const retry = spawnSync("git", ["restore", "--staged", "--worktree", "--source=HEAD", "--", filePath], { cwd: repoRoot, encoding: "utf8" });
     if (retry.status === 0) {
         return;
@@ -264,3 +261,19 @@ function emptyRepoState() {
 function toErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function gitFailureMessage(result) {
+    if (result.error) {
+        return result.error.message;
+    }
+    if (typeof result.stderr === "string" && result.stderr.trim().length > 0) {
+        return result.stderr.trim();
+    }
+    return `git exited with status ${String(result.status)}`;
+}
+function isFileNotFoundError(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function delaySynchronously(milliseconds) {
+    const signal = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+    Atomics.wait(signal, 0, 0, milliseconds);
+}