@martinloop/mcp 0.8.9 → 0.9.0

package/dist/tools/run-loop.js

@@ -4,6 +4,7 @@ import { normalizeSafePathPatterns, resolveSafeRepoRoot } from "../server-valida
 import { MartinToolError } from "./tool-errors.js";
 import { buildArtifactSummary, buildVerificationSummary, buildLoopPreview, buildRunRecordPaths, getEngineAvailability, resolveExecutionMode } from "./tool-support.js";
 import { normalizeLoopBudget } from "./workflow-governance.js";
+import { createFileRunControlSource } from "./run-controls.js";
 let proofModeVerifierSpawnImpl;
 let runStoreOverrideForTests;
 export function __setProofModeVerifierSpawnImplForTests(spawnImpl) {
@@ -210,6 +211,12 @@ export async function runLoopTool(input) {
         workspaceId: input.workspaceId ?? "ws_mcp",
         projectId: input.projectId ?? "proj_mcp",
         store: runStoreOverrideForTests ?? createFileRunStore({ runsRoot }),
+        // The in-memory store override is a verification-only composition with no
+        // durable run directory to serialize. Production always couples the file
+        // store and file control source over the same runs root.
+        runControlSource: runStoreOverrideForTests
+            ? undefined
+            : createFileRunControlSource(runsRoot),
         receiptScope,
         task: {
             title: input.objective.slice(0, 100),

package/dist/vendor/adapters/process-supervisor.d.ts

@@ -64,4 +64,16 @@ export declare function spawnSupervisedProcessForTest(command: string, args: rea
  * @internal - deterministic pure classification for process-supervisor tests
  */
 export declare function classifyPosixProcessGroupSnapshot(output: string, ownedGroupPid: number): "closed" | "alive" | "absent" | "invalid";
+type WindowsProcessTreeRow = {
+    ProcessId: number;
+    ParentProcessId: number;
+};
+/**
+ * Classify descendants that remain visible after a failed termination attempt.
+ * Two point-in-time snapshots cannot prove closure across the interval because
+ * a descendant may be created and reparented between them. Absence is therefore
+ * indeterminate and must retain the original termination failure.
+ * @internal - deterministic pure classification for process-supervisor tests
+ */
+export declare function classifyWindowsDescendantPostcondition(initialRows: WindowsProcessTreeRow[], postTerminationRows: WindowsProcessTreeRow[], rootPid: number): "closed" | "alive" | "invalid";
 export {};

package/dist/vendor/adapters/process-supervisor.js

@@ -456,6 +456,39 @@ function isErrno(error, code) {
     return typeof error === "object" && error !== null && "code" in error
         && String(error.code) === code;
 }
+/**
+ * Classify descendants that remain visible after a failed termination attempt.
+ * Two point-in-time snapshots cannot prove closure across the interval because
+ * a descendant may be created and reparented between them. Absence is therefore
+ * indeterminate and must retain the original termination failure.
+ * @internal - deterministic pure classification for process-supervisor tests
+ */
+export function classifyWindowsDescendantPostcondition(initialRows, postTerminationRows, rootPid) {
+    if (!isOwnedPid(rootPid))
+        return "invalid";
+    const allRows = [...initialRows, ...postTerminationRows];
+    if (allRows.some((row) => !isOwnedPid(row.ProcessId) || !Number.isSafeInteger(row.ParentProcessId))) {
+        return "invalid";
+    }
+    const ownedLineage = new Set([rootPid]);
+    const expandLineage = (rows) => {
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (const row of rows) {
+                if (ownedLineage.has(row.ParentProcessId) && !ownedLineage.has(row.ProcessId)) {
+                    ownedLineage.add(row.ProcessId);
+                    changed = true;
+                }
+            }
+        }
+    };
+    expandLineage(initialRows);
+    expandLineage(postTerminationRows);
+    return postTerminationRows.some((row) => ownedLineage.has(row.ProcessId))
+        ? "alive"
+        : "invalid";
+}
 async function terminateWindowsDescendantsAfterRootExit(rootPid, graceMs, waitImpl) {
     let rows;
     try {
@@ -471,11 +504,16 @@ async function terminateWindowsDescendantsAfterRootExit(rootPid, graceMs, waitIm
         childrenByParent.set(row.ParentProcessId, children);
     }
     const directChildren = childrenByParent.get(rootPid) ?? [];
+    let taskkillFailure;
     for (const childPid of directChildren) {
         const failure = await runTaskkill(childPid, spawnProcess, graceMs, waitImpl);
-        if (failure)
-            return failure;
+        taskkillFailure ??= failure;
     }
+    // Once taskkill has failed, a later process-table snapshot cannot prove the
+    // complete descendant set closed. Return the bounded failure immediately;
+    // starting another PowerShell query here could otherwise stall cleanup.
+    if (taskkillFailure)
+        return taskkillFailure;
     return { state: "closed" };
 }
 function readWindowsProcessTree() {

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

@@ -49,6 +49,10 @@ export function createVerifierOnlyAdapter(options = {}) {
             providerId: "verifier",
             model: "verify-only",
             transport: "cli",
+            budgetPreflight: {
+                pricePerMTokenUsd: 0,
+                basis: "Verifier-only execution launches no model provider."
+            },
             capabilities: createAdapterCapabilities({
                 usageSettlement: true,
                 diffArtifacts: true,

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

@@ -497,6 +497,12 @@ export interface RollbackBoundaryArtifact {
     trackedDirtyFiles: string[];
     untrackedFiles: string[];
     snapshots: RollbackFileSnapshot[];
+    /**
+     * Exact repo-relative roots owned by MartinLoop persistence for this run.
+     * These roots are not agent workspace mutations and must remain excluded
+     * from observation and rollback after the boundary is persisted/resumed.
+     */
+    managedPathExclusions?: string[];
     /**
      * Git-ignored files present at the boundary. Dependency and build output
      * directories are recorded as a single collapsed `dir/` entry.
@@ -557,4 +563,6 @@ export type { ChainIntegrityState, ContextCircuitBreakResult, ContextExclusionDe
 export { MISSION_SCHEMA_VERSION, MISSION_STATUSES, ALLOWED_MISSION_TRANSITIONS, createMissionRecord, isMissionTransitionAllowed } from './mission.js';
 export type { MissionStatus, MissionDecision, MissionBudget, MissionCost, MissionRunLink, MissionRunRole, MissionApproval, MissionOutcome, MissionEvent, MissionEventKind, MissionRecord, MissionDraft } from './mission.js';
 export { SWARM_LIVE_ENGINES, SWARM_ORCHESTRATION_STRATEGIES, SWARM_EVENT_TYPES, SWARM_PARENT_RECEIPT_SCHEMA_VERSION, SWARM_SCHEMA_VERSION, computeSwarmLivePlanHash, createSwarmLivePlan, createSwarmRunRecord, normalizeSwarmPathPattern, swarmConcretePathMatchesPattern, swarmPathPatternContains, swarmPathPatternsOverlap, validateSwarmConcretePath, validateSwarmChildReceiptLink, validateSwarmDeterministicDemoReceiptEvidence, validateSwarmChildContract, validateSwarmLiveEvent, validateSwarmLivePlan, validateSwarmLiveRevision, validateSwarmParentContract, validateSwarmRunRecord } from "./swarm.js";
+export { SWARM_CHILD_MAX_WALL_CLOCK_MS, SWARM_PARENT_VERIFIER_ALLOWANCE_MS, resolveSwarmDeadlineMs, } from "./swarm-timing.js";
+export type { SwarmExecutionShape } from "./swarm-timing.js";
 export type { SwarmAgentRecord, SwarmAgentStatus, SwarmBudgetLedger, SwarmBudgetLease, SwarmBudgetUsage, SwarmCandidate, SwarmChildContract, SwarmChildReceiptLink, SwarmChildWorkspaceRecord, SwarmCleanupRecord, SwarmCleanupState, SwarmConcretePathResult, SwarmConflictRecord, SwarmDependencyWaiver, SwarmDemoReferentialBindingState, SwarmDeterministicDemoReceiptEvidence, SwarmEvent, SwarmEventType, SwarmGlobalVerification, SwarmGlobalVerificationCommandState, SwarmIntegrationWorkspaceRecord, SwarmIntegrationStrategy, SwarmLeaseStatus, SwarmLiveEngine, SwarmLiveEngineProfile, SwarmLiveEvent, SwarmLivePlan, SwarmLivePlanDraft, SwarmLiveRevision, SwarmOrchestrationStrategy, SwarmOutcome, SwarmOutcomeState, SwarmParentContract, SwarmParentReceipt, SwarmPatchAdmission, SwarmPatchAdmissionReasonCode, SwarmPatchAdmissionState, SwarmPathPatternResult, SwarmPermissions, SwarmProcessCloseState, SwarmRecoveryPolicy, SwarmReceiptBlockedAction, SwarmReceiptReassignment, SwarmRunDraft, SwarmRunRecord, SwarmScope, SwarmStopDisposition, SwarmStopPolicy, SwarmTaskNode, SwarmTaskStatus, SwarmValidationError, SwarmValidationResult, SwarmVerifierMutationState, SwarmVerifierSubprocessResult, SwarmVerificationRecord, SwarmVerifierAuthority, SwarmVerifierWorkspaceRecord, SwarmWorkspaceKind, SwarmWorkspaceRecord, SwarmWorkspaceRemovalState, SwarmWorkspaceState } from "./swarm.js";

package/dist/vendor/contracts/index.js

@@ -283,3 +283,4 @@ export { EVIDENCE_STATUSES, EXECUTION_MODES, TEST_INTEGRITY_STATUSES, TEST_INTEG
 export { HANDOFF_SCHEMA_VERSION } from "./context-handoff.js";
 export { MISSION_SCHEMA_VERSION, MISSION_STATUSES, ALLOWED_MISSION_TRANSITIONS, createMissionRecord, isMissionTransitionAllowed } from './mission.js';
 export { SWARM_LIVE_ENGINES, SWARM_ORCHESTRATION_STRATEGIES, SWARM_EVENT_TYPES, SWARM_PARENT_RECEIPT_SCHEMA_VERSION, SWARM_SCHEMA_VERSION, computeSwarmLivePlanHash, createSwarmLivePlan, createSwarmRunRecord, normalizeSwarmPathPattern, swarmConcretePathMatchesPattern, swarmPathPatternContains, swarmPathPatternsOverlap, validateSwarmConcretePath, validateSwarmChildReceiptLink, validateSwarmDeterministicDemoReceiptEvidence, validateSwarmChildContract, validateSwarmLiveEvent, validateSwarmLivePlan, validateSwarmLiveRevision, validateSwarmParentContract, validateSwarmRunRecord } from "./swarm.js";
+export { SWARM_CHILD_MAX_WALL_CLOCK_MS, SWARM_PARENT_VERIFIER_ALLOWANCE_MS, resolveSwarmDeadlineMs, } from "./swarm-timing.js";

package/dist/vendor/contracts/swarm-timing.d.ts

@@ -0,0 +1,7 @@
+export declare const SWARM_CHILD_MAX_WALL_CLOCK_MS = 240000;
+export declare const SWARM_PARENT_VERIFIER_ALLOWANCE_MS = 120000;
+export interface SwarmExecutionShape {
+    agents: number;
+    maxConcurrency: number;
+}
+export declare function resolveSwarmDeadlineMs(shape: SwarmExecutionShape): number;

package/dist/vendor/contracts/swarm-timing.js

@@ -0,0 +1,22 @@
+export const SWARM_CHILD_MAX_WALL_CLOCK_MS = 240_000;
+export const SWARM_PARENT_VERIFIER_ALLOWANCE_MS = 120_000;
+const NODE_MAX_TIMER_DELAY_MS = 2_147_483_647;
+export function resolveSwarmDeadlineMs(shape) {
+    assertPositiveSafeInteger(shape.agents, "agents");
+    assertPositiveSafeInteger(shape.maxConcurrency, "maxConcurrency");
+    if (shape.maxConcurrency > shape.agents) {
+        throw new Error("maxConcurrency cannot exceed agents");
+    }
+    const executionWaves = Math.ceil(shape.agents / shape.maxConcurrency);
+    const deadlineMs = (executionWaves * SWARM_CHILD_MAX_WALL_CLOCK_MS
+        + SWARM_PARENT_VERIFIER_ALLOWANCE_MS);
+    if (!Number.isSafeInteger(deadlineMs) || deadlineMs > NODE_MAX_TIMER_DELAY_MS) {
+        throw new Error("derived deadline exceeds the Node timer maximum");
+    }
+    return deadlineMs;
+}
+function assertPositiveSafeInteger(value, label) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new Error(`${label} must be a positive safe integer`);
+    }
+}

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

@@ -7,7 +7,7 @@ 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";
-import { acquireRunExecutionLease, evaluateRunResumability, loadResumeCandidateBoundary, loadResumeVerifierFailure } from "./resume.js";
+import { acquireRunExecutionLease, readActiveRunExecutionLease, evaluateRunResumability, loadResumeCandidateBoundary, loadResumeVerifierFailure } from "./resume.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, listIgnoredFileChangesSinceBoundary, restoreRollbackBoundary };
@@ -23,7 +23,7 @@ export type { LocalIdentityAuthority } from "./identity.js";
 export { compileExecutionPolicy } from "./policy-compiler.js";
 export { assessTrajectory, decideCircuitBreak } from "./trajectory.js";
 export { calculateAvoidedUsd, calculateLoopAvoidedUsd } from "./savings.js";
-export { acquireRunExecutionLease, evaluateRunResumability, loadResumeCandidateBoundary, loadResumeVerifierFailure };
+export { acquireRunExecutionLease, readActiveRunExecutionLease, evaluateRunResumability, loadResumeCandidateBoundary, loadResumeVerifierFailure };
 export type { AvoidedUsdInput } from "./savings.js";
 export { classifyRoute, evaluatePreworkBurnPolicy } from "./routing.js";
 export type { RouteDecision, RouteClassificationInput } from "./routing.js";
@@ -206,6 +206,8 @@ export interface MartinAdapter {
         budgetPreflight?: {
             /** Estimated token floor required before the adapter can report first-turn usage. */
             minimumViableTokens?: number;
+            /** Adapter-specific provider price used by the admission estimate. */
+            pricePerMTokenUsd?: number;
             basis?: string;
         };
         capabilities?: {
@@ -291,6 +293,39 @@ export interface RunMartinInput {
     observedUsageGovernor?: MartinObservedUsageGovernor;
     /** Optional parent cancellation signal. Relayed into the active governed attempt. */
     signal?: AbortSignal;
+    /** Optional durable cooperative pause/continue source. */
+    runControlSource?: RunControlSource;
+    /** Poll interval while a cooperative pause is applied (default 250 ms). */
+    runControlPollIntervalMs?: number;
+}
+export interface RunControlCommand {
+    controlId: string;
+    loopId: string;
+    action: "pause" | "continue";
+    requestedAt: string;
+    /** Explicit local-process boundary; not an authenticated human identity. */
+    principal: "local_mcp_client";
+    receiptHash: string;
+    reason?: string;
+    expectedPreviousControlId?: string;
+}
+export interface RunControlSnapshot {
+    pause?: RunControlCommand;
+    continuedBy?: RunControlCommand;
+}
+export interface RunControlApplication {
+    loopId: string;
+    controlId: string;
+    action: "pause_applied" | "continue_applied";
+    appliedAt: string;
+    relatedControlId?: string;
+    receiptHash: string;
+}
+export interface RunControlSource {
+    poll(runId: string): Promise<RunControlSnapshot>;
+    recordApplication(application: RunControlApplication): Promise<void>;
+    /** Serialize terminal intent against new control receipts before persistence. */
+    recordTerminalIntent?(runId: string): Promise<void>;
 }
 export interface RunMartinResult {
     loop: LoopRecord;

package/dist/vendor/core/index.js

@@ -2,10 +2,10 @@ import { DEFAULT_AGENT_EXECUTION_INTENT, normalizeProviderExecutionTimeoutMs, ap
 import { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluateCostGovernor, evaluateBudgetPreflight, inferExit, isSafeUnverifiedDiscard, 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";
-import { captureRollbackBoundary, findEscapingLinks, listAttemptChangedFilesSinceBoundary, listIgnoredFileChangesSinceBoundary, restoreRollbackBoundary } from "./rollback.js";
+import { authenticateManagedPathExclusions, captureRollbackBoundary, filterManagedRollbackPaths, findEscapingLinks, listAttemptChangedFilesSinceBoundary, listIgnoredFileChangesSinceBoundary, restoreRollbackBoundary } from "./rollback.js";
 import { findWeakenedTestFiles } from "./test-integrity.js";
 import { compilePromptPacket } from "./compiler.js";
-import { makeLedgerEvent, resolveRunsRoot, runDir } from "./persistence/index.js";
+import { makeLedgerEvent, resolveReceiptIntegrityRoot, resolveRunsRoot, runDir } from "./persistence/index.js";
 import { createDefaultExitPolicy, evaluateExitPolicy, hashProgressState, toLegacyExitDecision } from "./exits.js";
 import { createFileExitSignalSource, isTerminalExitSignal, startExitSignalMonitor } from "./exit-signal.js";
 import { persistTerminationEnvelope } from "./termination-store.js";
@@ -14,7 +14,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";
-import { acquireRunExecutionLease, evaluateRunResumability, loadResumeCandidateBoundary, loadResumeVerifierFailure } from "./resume.js";
+import { acquireRunExecutionLease, readActiveRunExecutionLease, evaluateRunResumability, loadResumeCandidateBoundary, loadResumeVerifierFailure } from "./resume.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, listIgnoredFileChangesSinceBoundary, restoreRollbackBoundary };
 export { describeMalformedVerifier } from "./verifier-input.js";
@@ -24,7 +24,7 @@ export { createLocalIdentityAuthority, hasIdentityScope, issueIdentityToken, ver
 export { compileExecutionPolicy } from "./policy-compiler.js";
 export { assessTrajectory, decideCircuitBreak } from "./trajectory.js";
 export { calculateAvoidedUsd, calculateLoopAvoidedUsd } from "./savings.js";
-export { acquireRunExecutionLease, evaluateRunResumability, loadResumeCandidateBoundary, loadResumeVerifierFailure };
+export { acquireRunExecutionLease, readActiveRunExecutionLease, evaluateRunResumability, loadResumeCandidateBoundary, loadResumeVerifierFailure };
 // ─── Routing economics ─────────────────────────────────────────────────────
 export { classifyRoute, evaluatePreworkBurnPolicy } from "./routing.js";
 // ─── Test Integrity Validation ──────────────────────────────────────────────
@@ -217,6 +217,7 @@ export async function runMartin(input) {
             runsRoot: input.store.runsRoot,
             runId: loop.loopId,
             owner: resumeLoop ? "runMartin:resume" : "runMartin",
+            runControlCapable: input.runControlSource !== undefined,
             now: () => loop.updatedAt
         })
         : undefined;
@@ -236,6 +237,9 @@ export async function runMartin(input) {
         }, { now: now(), idFactory });
         const adapterChain = [input.adapter, ...(input.fallbackAdapters ?? [])];
         const runsRoot = input.store?.runsRoot ?? resolveRunsRoot();
+        const managedRollbackRoots = input.store?.runsRoot
+            ? [input.store.runsRoot, resolveReceiptIntegrityRoot()]
+            : [];
         const observesWorkspaceMutations = task.repoRoot !== undefined &&
             adapterChain.some((adapter) => adapter.metadata.capabilities?.workspaceMutations !== false);
         const touchedDuringExecution = new Set();
@@ -247,7 +251,8 @@ export async function runMartin(input) {
             try {
                 completionBoundary = await captureRollbackBoundary({
                     repoRoot: task.repoRoot,
-                    capturedAt: loop.createdAt
+                    capturedAt: loop.createdAt,
+                    managedRoots: managedRollbackRoots
                 });
                 if (!completionBoundary) {
                     completionBoundaryReason = "A run-wide file-effect observation boundary was not available.";
@@ -265,6 +270,7 @@ export async function runMartin(input) {
             const fileEffects = observeRunFileEffects({
                 repoRoot: task.repoRoot,
                 boundary: completionBoundary,
+                managedRoots: managedRollbackRoots,
                 touchedDuringExecution,
                 unavailableReason: completionBoundaryReason
             });
@@ -675,7 +681,84 @@ export async function runMartin(input) {
             const evaluation = evaluateExitPolicy(exitPolicy, currentExitSnapshot(phase, result));
             if (!evaluation.shouldExit)
                 return undefined;
-            return await selectTerminalEvaluation(evaluation);
+            const terminal = await selectTerminalEvaluation(evaluation);
+            await input.runControlSource?.recordTerminalIntent?.(loop.loopId);
+            return terminal;
+        }
+        async function waitForControlPoll(intervalMs) {
+            if (runController.signal.aborted)
+                return;
+            await new Promise((resolve) => {
+                let settled = false;
+                const finish = () => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    clearTimeout(timer);
+                    runController.signal.removeEventListener("abort", finish);
+                    resolve();
+                };
+                const timer = setTimeout(finish, intervalMs);
+                timer.unref?.();
+                runController.signal.addEventListener("abort", finish, { once: true });
+                if (runController.signal.aborted)
+                    finish();
+            });
+        }
+        async function awaitCooperativeRunControl() {
+            const source = input.runControlSource;
+            if (!source)
+                return undefined;
+            const initial = await source.poll(loop.loopId);
+            const pause = initial.pause;
+            if (!pause)
+                return undefined;
+            if (pause.loopId !== loop.loopId || pause.action !== "pause") {
+                throw new Error("Run control integrity check failed before pause application.");
+            }
+            await source.recordApplication({
+                loopId: loop.loopId,
+                controlId: pause.controlId,
+                action: "pause_applied",
+                appliedAt: now(),
+                receiptHash: pause.receiptHash
+            });
+            const pollIntervalMs = input.runControlPollIntervalMs ?? 250;
+            while (true) {
+                const terminal = await evaluateCheckpoint("pre_attempt");
+                if (terminal)
+                    return terminal;
+                await waitForControlPoll(pollIntervalMs);
+                // Cancellation aborts the wait immediately. Reconcile terminal state
+                // before polling cooperative receipts because the production control
+                // source intentionally clears pause/continue after a cancel receipt.
+                const awakenedTerminal = await evaluateCheckpoint("pre_attempt");
+                if (awakenedTerminal)
+                    return awakenedTerminal;
+                const snapshot = await source.poll(loop.loopId);
+                if (snapshot.pause) {
+                    if (snapshot.pause.controlId !== pause.controlId || snapshot.pause.loopId !== loop.loopId) {
+                        throw new Error("Run control integrity check failed while pause was applied.");
+                    }
+                    continue;
+                }
+                const continuedBy = snapshot.continuedBy;
+                if (!continuedBy ||
+                    continuedBy.loopId !== loop.loopId ||
+                    continuedBy.action !== "continue" ||
+                    continuedBy.expectedPreviousControlId !== pause.controlId) {
+                    throw new Error("Run control integrity check failed while releasing pause.");
+                }
+                await source.recordApplication({
+                    loopId: loop.loopId,
+                    controlId: continuedBy.controlId,
+                    action: "continue_applied",
+                    relatedControlId: pause.controlId,
+                    appliedAt: now(),
+                    receiptHash: continuedBy.receiptHash
+                });
+                return await evaluateCheckpoint("pre_attempt");
+            }
         }
         /**
          * Blocker 1 / Blocker 2 — Authoritative retained-candidate terminal restoration.
@@ -711,6 +794,7 @@ export async function runMartin(input) {
                 const rollbackOutcome = await restoreRollbackBoundary({
                     repoRoot: task.repoRoot,
                     boundary: capturedBoundary,
+                    managedRoots: managedRollbackRoots,
                     restoredAt,
                     decision: "DISCARD"
                 });
@@ -867,6 +951,9 @@ export async function runMartin(input) {
             if (preRunTerminal !== undefined)
                 return await terminateRun(preRunTerminal);
             while (loop.attempts.length < loop.budget.maxIterations) {
+                const controlTerminal = await awaitCooperativeRunControl();
+                if (controlTerminal !== undefined)
+                    return await terminateRun(controlTerminal);
                 const distilled = distillContext(loop, {
                     maxRecentAttempts: useCompressedContext ? 1 : (input.maxRecentAttempts ?? 3)
                 });
@@ -880,6 +967,7 @@ export async function runMartin(input) {
                     remainingBudgetUsd: distilled.constraints.remainingBudgetUsd,
                     remainingTokens: distilled.constraints.remainingTokens,
                     minimumViableTokens: executingAdapter.metadata.budgetPreflight?.minimumViableTokens,
+                    pricePerMTokenUsd: executingAdapter.metadata.budgetPreflight?.pricePerMTokenUsd,
                     // D2: pass remaining iterations so the preflight can compute a budget-aware cap
                     // rather than using the old rigid maxUsd * 0.25 that blocked viable attempts.
                     remainingIterations: distilled.constraints.remainingIterations
@@ -1117,7 +1205,8 @@ export async function runMartin(input) {
                 const rollbackBoundary = tracksWorkspaceMutations
                     ? await captureRollbackBoundary({
                         repoRoot: request.context.repoRoot,
-                        capturedAt: attemptStartedAt
+                        capturedAt: attemptStartedAt,
+                        managedRoots: managedRollbackRoots
                     })
                     : undefined;
                 // Persist attempt.started state before blocking on provider execution.
@@ -1352,10 +1441,14 @@ export async function runMartin(input) {
                 let weakenedTestFiles = [];
                 try {
                     changedFiles = tracksWorkspaceMutations
-                        ? resolveChangedFiles(result, request.context.repoRoot, rollbackBoundary)
+                        ? resolveChangedFiles(result, request.context.repoRoot, rollbackBoundary, managedRollbackRoots)
                         : [];
                     ignoredChanges = tracksWorkspaceMutations
-                        ? listIgnoredFileChangesSinceBoundary({ repoRoot: request.context.repoRoot, boundary: rollbackBoundary })
+                        ? listIgnoredFileChangesSinceBoundary({
+                            repoRoot: request.context.repoRoot,
+                            boundary: rollbackBoundary,
+                            managedRoots: managedRollbackRoots
+                        })
                         : ignoredChanges;
                     escapingLinks =
                         tracksWorkspaceMutations && request.context.repoRoot
@@ -1382,6 +1475,7 @@ export async function runMartin(input) {
                         rollbackOutcome = (await restoreRollbackBoundary({
                             repoRoot: request.context.repoRoot,
                             boundary: rollbackBoundary,
+                            managedRoots: managedRollbackRoots,
                             restoredAt: attemptCompletedAt,
                             decision: "DISCARD",
                             removePaths: ignoredChanges.created,
@@ -1495,6 +1589,7 @@ export async function runMartin(input) {
                         rollbackOutcome = await restoreRollbackBoundary({
                             repoRoot: request.context.repoRoot,
                             boundary: rollbackBoundary,
+                            managedRoots: managedRollbackRoots,
                             restoredAt: attemptCompletedAt,
                             decision: patchDecision.decision,
                             removePaths: violatingIgnoredPaths(filesystemDecision.violations, ignoredChanges.created),
@@ -1592,6 +1687,7 @@ export async function runMartin(input) {
                         rollbackOutcome = await restoreRollbackBoundary({
                             repoRoot: request.context.repoRoot,
                             boundary: rollbackBoundary,
+                            managedRoots: managedRollbackRoots,
                             restoredAt: attemptCompletedAt,
                             decision: patchDecision.decision
                         }) ?? undefined;
@@ -1724,6 +1820,7 @@ export async function runMartin(input) {
                     rollbackOutcome = await restoreRollbackBoundary({
                         repoRoot: request.context.repoRoot,
                         boundary: rollbackBoundary,
+                        managedRoots: managedRollbackRoots,
                         restoredAt: attemptCompletedAt,
                         decision: patchDecision?.decision ?? "DISCARD"
                     });
@@ -1733,6 +1830,7 @@ export async function runMartin(input) {
                     rollbackOutcome = await restoreRollbackBoundary({
                         repoRoot: request.context.repoRoot,
                         boundary: rollbackBoundary,
+                        managedRoots: managedRollbackRoots,
                         restoredAt: attemptCompletedAt,
                         decision: "DISCARD"
                     });
@@ -2001,6 +2099,7 @@ export async function runMartin(input) {
                     await restoreRollbackBoundary({
                         repoRoot: task.repoRoot,
                         boundary: preCandidateBoundary,
+                        managedRoots: managedRollbackRoots,
                         restoredAt: now(),
                         decision: "DISCARD"
                     });
@@ -2091,11 +2190,11 @@ function finalizeLoop(loop, decision, timestamp, idFactory, routingEconomicsInpu
     };
 }
 function observeRunFileEffects(input) {
-    const touchedDuringExecution = normalizeFileEffectPaths(input.touchedDuringExecution);
+    const observedTouchedDuringExecution = normalizeFileEffectPaths(input.touchedDuringExecution);
     if (!input.repoRoot || !input.boundary) {
         return {
             observationStatus: "unavailable",
-            touchedDuringExecution,
+            touchedDuringExecution: observedTouchedDuringExecution,
             netChangedAtCompletion: [],
             revertedBeforeCompletion: [],
             observationReason: input.unavailableReason ??
@@ -2103,9 +2202,12 @@ function observeRunFileEffects(input) {
         };
     }
     try {
+        const exclusions = authenticateManagedPathExclusions(input.repoRoot, input.boundary, input.managedRoots);
+        const touchedDuringExecution = filterManagedRollbackPaths(observedTouchedDuringExecution, exclusions);
         const netChangedAtCompletion = normalizeFileEffectPaths(listAttemptChangedFilesSinceBoundary({
             repoRoot: input.repoRoot,
             boundary: input.boundary,
+            managedRoots: input.managedRoots,
             includeBaselineSnapshotChanges: true
         }));
         const netChanged = new Set(netChangedAtCompletion);
@@ -2119,7 +2221,7 @@ function observeRunFileEffects(input) {
     catch (error) {
         return {
             observationStatus: "unavailable",
-            touchedDuringExecution,
+            touchedDuringExecution: observedTouchedDuringExecution,
             netChangedAtCompletion: [],
             revertedBeforeCompletion: [],
             observationReason: `Final file-effect observation was unavailable: ${fileEffectErrorMessage(error)}`
@@ -2234,11 +2336,15 @@ function violatingIgnoredPaths(violations, ignoredPaths) {
     const violating = new Set(violations.map((violation) => violation.file?.replace(/\/$/u, "")).filter(Boolean));
     return ignoredPaths.filter((filePath) => violating.has(filePath.replace(/\/$/u, "")));
 }
-function resolveChangedFiles(result, repoRoot, rollbackBoundary) {
-    const adapterReported = normalizeFileEffectPaths(result.execution?.changedFiles ?? []);
+function resolveChangedFiles(result, repoRoot, rollbackBoundary, managedRoots = []) {
+    const exclusions = repoRoot && rollbackBoundary
+        ? authenticateManagedPathExclusions(repoRoot, rollbackBoundary, managedRoots)
+        : [];
+    const adapterReported = filterManagedRollbackPaths(normalizeFileEffectPaths(result.execution?.changedFiles ?? []), exclusions);
     const gitObserved = listAttemptChangedFilesSinceBoundary({
         repoRoot,
         boundary: rollbackBoundary,
+        managedRoots,
         includeBaselineSnapshotChanges: true
     });
     return normalizeFileEffectPaths([...adapterReported, ...gitObserved]);

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

@@ -1,6 +1,6 @@
 export { makeLedgerEvent } from "./ledger.js";
 export type { LedgerEvent, LedgerEventDraft, LedgerEventKind } from "./ledger.js";
-export { resolveReceiptIntegrityPath, verifyReceiptIntegrityFromFiles, writeReceiptIntegrityMaterial } from "./integrity.js";
+export { resolveReceiptIntegrityRoot, resolveReceiptIntegrityPath, verifyReceiptIntegrityFromFiles, writeReceiptIntegrityMaterial } from "./integrity.js";
 export type { ReceiptIntegrityChainEntry, StoredReceiptIntegrityMaterial } from "./integrity.js";
 export { artifactDir, createFileRunStore, resolveRunsRoot, runDir } from "./store.js";
 export type { AttemptArtifacts, RunContract, RunStore } from "./store.js";

package/dist/vendor/core/persistence/index.js

@@ -1,5 +1,5 @@
 export { makeLedgerEvent } from "./ledger.js";
-export { resolveReceiptIntegrityPath, verifyReceiptIntegrityFromFiles, writeReceiptIntegrityMaterial } from "./integrity.js";
+export { resolveReceiptIntegrityRoot, resolveReceiptIntegrityPath, verifyReceiptIntegrityFromFiles, writeReceiptIntegrityMaterial } from "./integrity.js";
 export { artifactDir, createFileRunStore, resolveRunsRoot, runDir } from "./store.js";
 export { readAllLoopRecords, readLatestLoopRecord, readLatestLoopRecordFromFile, readLoopRecordsFromFile } from "./runs-reader.js";
 export { compileAndPersistContext } from "./compiler.js";

package/dist/vendor/core/persistence/integrity.d.ts

@@ -35,6 +35,7 @@ export declare function verifyReceiptIntegrityFromFiles(input: {
     runsRoot: string;
     loopRecordPath: string;
     ledgerPath: string;
+    integrityPath?: string;
 }): Promise<ReceiptIntegritySummary>;
 export declare function resolveReceiptIntegrityPath(runsRoot: string, runId: string): string;
 export declare function ensurePrivateIntegrityKey(runsRoot: string, keyFileName: string): Promise<[string, string] | undefined>;

package/dist/vendor/core/persistence/integrity.js

@@ -40,7 +40,7 @@ export async function writeReceiptIntegrityMaterial(input) {
     return material;
 }
 export async function verifyReceiptIntegrityFromFiles(input) {
-    const integrityPath = resolveReceiptIntegrityPath(input.runsRoot, input.runId);
+    const integrityPath = input.integrityPath ?? resolveReceiptIntegrityPath(input.runsRoot, input.runId);
     const [rawMaterial, rawLoopRecord, rawLedger, key] = await Promise.all([
         readFile(integrityPath, "utf8").catch(() => null),
         readFile(input.loopRecordPath, "utf8").catch(() => null),

package/dist/vendor/core/policy.js

@@ -385,7 +385,10 @@ function roundUsd(value) {
     return Math.round(value * 100) / 100;
 }
 export function evaluateBudgetPreflight(input) {
-    const pricePerMToken = input.pricePerMTokenUsd ?? 3.0;
+    const declaredPrice = input.pricePerMTokenUsd;
+    const validDeclaredPrice = declaredPrice === undefined
+        || (Number.isFinite(declaredPrice) && declaredPrice >= 0);
+    const pricePerMToken = validDeclaredPrice ? (declaredPrice ?? 3.0) : 3.0;
     const rawPromptTokens = Math.ceil(input.promptCharCount / 4);
     const estimatedPromptTokens = Math.ceil(rawPromptTokens * 1.2);
     const estimatedToolOverheadTokens = 800 + input.attemptCount * 200;
@@ -407,6 +410,13 @@ export function evaluateBudgetPreflight(input) {
         estimatedAttemptCostUsd,
         provenance
     };
+    if (!validDeclaredPrice) {
+        return {
+            allowed: false,
+            reason: "Preflight: invalid adapter price; pricePerMTokenUsd must be finite and non-negative.",
+            estimate
+        };
+    }
     if (input.remainingTokens !== undefined
         && estimatedMinimumViableTokens > 0
         && estimatedTotalTokens > input.remainingTokens) {