@martinloop/mcp 0.8.7 → 0.8.9

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

@@ -1,4 +1,4 @@
-import type { BudgetPreflightEstimate, CostProvenance, EvidenceVector, FailureClass, InterventionType, LoopAttempt, LoopBudget, LoopCost, LoopLifecycleState, LoopStatus, PatchDecisionArtifact, PatchScore, PolicyPhase } from "../contracts/index.js";
+import type { BudgetPreflightEstimate, CostProvenance, EvidenceVector, FailureClass, InterventionType, LoopAttempt, LoopBudget, LoopCost, LoopLifecycleState, LoopStatus, PatchDecisionArtifact, PatchDecisionReasonCode, PatchScore, PolicyPhase } from "../contracts/index.js";
 export interface FailureAssessment {
     failureClass: FailureClass;
     rationale: string;
@@ -106,6 +106,17 @@ export interface BudgetPreflightInput {
     remainingTokens?: number;
     /** Adapter-declared estimated floor required to admit a credible first turn. */
     minimumViableTokens?: number;
+    /**
+     * Remaining iterations allowed. Used to compute a budget-aware per-attempt cap
+     * that reserves capacity for verifier and at least one repair attempt.
+     * When omitted, the preflight uses remaining budget divided by a conservative
+     * factor to prevent over-allocation on the first attempt.
+     */
+    remainingIterations?: number;
+    /**
+     * Explicit per-attempt spending cap. When set, overrides the computed cap.
+     * Only use when the caller has specific rate-limiting requirements.
+     */
     perAttemptCapUsd?: number;
     pricePerMTokenUsd?: number;
 }
@@ -158,5 +169,11 @@ export interface EvaluatedPatchDecision extends PatchDecisionArtifact {
     score: PatchScore;
 }
 export declare function selectRecoveryRecipe(evidence: EvidenceVector): RecoveryDecision;
+/**
+ * Returns true ONLY when every reason code is in the explicit allowlist of
+ * retainable soft failures.  Unknown or future reason codes default to UNSAFE
+ * (fail-closed), preventing silent candidate retention for unrecognized states.
+ */
+export declare function isSafeUnverifiedDiscard(reasonCodes: readonly PatchDecisionReasonCode[]): boolean;
 export declare function evaluatePatchDecision(input: PatchDecisionInput): EvaluatedPatchDecision;
 export declare function scorePatchDecision(input: PatchDecisionInput): PatchScore;

package/dist/vendor/core/policy.js

@@ -244,17 +244,42 @@ export function inferExit(input) {
             reason: "Oscillating failure pattern detected — loop is cycling without measurable progress."
         };
     }
+    // C2 — progress-aware repetition check.
+    // Two consecutive attempts with the same failureClass are NOT necessarily
+    // the same state. If the verifierScore improved (e.g. fewer failing tests),
+    // that is measurable progress and we must not stop prematurely.
+    // Only stop when the failure class repeated AND there is no measurable improvement:
+    //   - verifierScore did not increase, AND
+    //   - candidate diff did not change (candidateRetained with same failure)
     const lastTwo = input.loop.attempts.slice(-2);
-    const repeatedFailure = lastTwo.length === 2 &&
+    const repeatedFailureClass = lastTwo.length === 2 &&
         lastTwo.every((attempt) => attempt.failureClass &&
             attempt.failureClass === lastTwo[0]?.failureClass &&
             attempt.failureClass === input.lastFailure?.failureClass);
-    if (repeatedFailure && input.lastFailure) {
+    // Measure progress using REAL evidence from actual verifier step results.
+    // Multiple signals are checked; any one constituting real progress allows continuation.
+    const measurableProgressOccurred = (() => {
+        const [prev, curr] = lastTwo;
+        if (!prev || !curr)
+            return false;
+        // Signal 1: verifierScore improved (computed from real passing/total step ratio)
+        const prevScore = prev.verifierScore ?? 0;
+        const currScore = curr.verifierScore ?? 0;
+        if (currScore > prevScore)
+            return true;
+        // Signal 2: fewer failing verifier steps than previous attempt (monotonic improvement)
+        if (prev.failingVerifierStepCount !== undefined &&
+            curr.failingVerifierStepCount !== undefined &&
+            curr.failingVerifierStepCount < prev.failingVerifierStepCount)
+            return true;
+        return false;
+    })();
+    if (repeatedFailureClass && !measurableProgressOccurred && input.lastFailure) {
         return {
             shouldExit: true,
             lifecycleState: "diminishing_returns",
             status: "exited",
-            reason: `Martin exited because ${input.lastFailure.failureClass} repeated across consecutive attempts.`
+            reason: `Martin exited because ${input.lastFailure.failureClass} repeated across consecutive attempts with no measurable progress (score, step count, or failure surface unchanged).`
         };
     }
     if (input.lastFailure?.failureClass === "environment_mismatch" &&
@@ -398,11 +423,34 @@ export function evaluateBudgetPreflight(input) {
             estimate
         };
     }
-    const perAttemptCap = input.perAttemptCapUsd ?? Math.max(input.remainingBudgetUsd * 0.2, 0.05);
+    // D2 — Budget-aware per-attempt cap.
+    //
+    // Old behavior: rigid maxUsd * 0.25 — blocked viable attempts when total budget
+    // was large (e.g. $0.30 cost blocked on $1.00 budget because 0.30 > 0.25).
+    //
+    // New behavior: if an explicit cap is provided, honor it. Otherwise compute a
+    // cap that reserves budget for the verifier and at least one repair attempt beyond
+    // the current one, giving the provider meaningful runway.
+    //
+    // Formula: cap = remainingBudget / (remainingIterations + 1)
+    //   +1 accounts for the current attempt being the "next" attempt.
+    //   Minimum cap of $0.05 prevents degenerate near-zero rejections.
+    const perAttemptCap = (() => {
+        if (input.perAttemptCapUsd !== undefined)
+            return input.perAttemptCapUsd;
+        const iters = input.remainingIterations;
+        if (iters !== undefined && iters > 0) {
+            // Divide remaining budget evenly across remaining iterations.
+            return Math.max(roundUsd(input.remainingBudgetUsd / iters), 0.05);
+        }
+        // No iteration information: allow up to 80% of remaining budget per attempt
+        // (down from the old 25%-of-total which was frequently too low).
+        return Math.max(roundUsd(input.remainingBudgetUsd * 0.8), 0.05);
+    })();
     if (estimatedAttemptCostUsd > perAttemptCap) {
         return {
             allowed: false,
-            reason: `Preflight: estimated attempt cost $${estimatedAttemptCostUsd} exceeds per-attempt cap $${roundUsd(perAttemptCap)}.`,
+            reason: `Preflight: estimated attempt cost $${estimatedAttemptCostUsd} exceeds per-attempt cap $${roundUsd(perAttemptCap)} (remaining budget $${input.remainingBudgetUsd}, ${input.remainingIterations ?? "?"} iterations left).`,
             estimate
         };
     }
@@ -517,6 +565,41 @@ export function selectRecoveryRecipe(evidence) {
         intervention: "escalate_human"
     };
 }
+/**
+ * Explicit allowlist of reason codes that are SAFE to retain as an unverified
+ * candidate for the next repair attempt.
+ *
+ * FAIL-CLOSED: any reason code NOT in this set causes an immediate rollback.
+ * This prevents future or unknown reason codes from silently becoming "safe."
+ *
+ * Retainable only when ALL of these are also true:
+ *  - scope_violation is absent (agent stayed within allowed paths)
+ *  - safety_violation is absent (no secret/tenancy/test-integrity violation)
+ *  - workspace observation was authoritative (changed files were tracked)
+ *  - provider did not crash/fail (status !== "failed")
+ *
+ * no_code_change is explicitly NOT retainable — there is nothing to repair.
+ * Use a different recovery strategy instead.
+ */
+const RETAINABLE_SOFT_REASON_CODES = new Set([
+    "verifier_not_improved",
+    "low_novelty_no_progress",
+    "large_diff_no_improvement",
+    "grounding_failure",
+    "verifier_regressed", // actual test regression — retry with different approach
+]);
+/**
+ * Returns true ONLY when every reason code is in the explicit allowlist of
+ * retainable soft failures.  Unknown or future reason codes default to UNSAFE
+ * (fail-closed), preventing silent candidate retention for unrecognized states.
+ */
+export function isSafeUnverifiedDiscard(reasonCodes) {
+    if (reasonCodes.length === 0) {
+        // No specific signal — we don't know why it's being discarded; fail closed.
+        return false;
+    }
+    return reasonCodes.every((code) => RETAINABLE_SOFT_REASON_CODES.has(code));
+}
 export function evaluatePatchDecision(input) {
     const score = scorePatchDecision(input);
     const reasonCodes = [...score.reasonCodes];
@@ -624,21 +707,41 @@ function tokenizeDiff(diff) {
     return tokens;
 }
 function decidePatchOutcome(input, reasonCodes) {
+    // 1. Explicit human approval required — always escalate regardless of verifier.
+    // 2. Safety violation — always escalate.
     if (input.humanApprovalRequired || reasonCodes.includes("safety_violation")) {
         return "ESCALATE";
     }
+    // 3. Scope violation — hard boundary: out-of-scope writes are never kept,
+    //    even if the verifier passes, because the change violated the task contract.
+    if (reasonCodes.includes("scope_violation")) {
+        return "DISCARD";
+    }
+    // 4. Required mutation is absent — a green generic test suite is not proof
+    //    that the requested work happened.  Discard if:
+    //      - a code change was required (mutation_required = edit mode)
+    //      - no files were actually changed
+    //      - the task was not pre-satisfied by the existing codebase
+    //    Note: the scorer already suppresses no_code_change when
+    //    definitionOfDonePreSatisfied is true, so that legitimate case passes through.
+    if (reasonCodes.includes("no_code_change")) {
+        return "DISCARD";
+    }
+    // 5. Passing verifier is the authoritative signal and overrides lower-confidence
+    //    heuristics such as grounding failure.  A grounding heuristic (symbol
+    //    resolution, repo anatomy check) is weaker evidence than an actual passing
+    //    host-run test exit code.
+    if (input.verificationPassed) {
+        return "KEEP";
+    }
+    // 6. Non-passing verifier: discard on any remaining negative heuristic signal.
     if (reasonCodes.includes("grounding_failure") ||
-        reasonCodes.includes("scope_violation") ||
-        reasonCodes.includes("no_code_change") ||
         reasonCodes.includes("verifier_regressed") ||
         reasonCodes.includes("large_diff_no_improvement") ||
         reasonCodes.includes("low_novelty_no_progress") ||
         reasonCodes.includes("verifier_not_improved")) {
         return "DISCARD";
     }
-    if (input.verificationPassed) {
-        return "KEEP";
-    }
     return "DISCARD";
 }
 function buildPatchDecisionSummary(decision, reasonCodes, summary) {

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

@@ -0,0 +1,39 @@
+import type { LoopRecord, RollbackBoundaryArtifact } from "../contracts/index.js";
+export interface RunExecutionLease {
+    schemaVersion: "martin.execution-lease.v1";
+    runId: string;
+    token: string;
+    owner: string;
+    pid: number;
+    hostname: string;
+    acquiredAt: string;
+}
+export interface AcquiredRunExecutionLease {
+    lease: RunExecutionLease;
+    path: string;
+    release(): Promise<void>;
+}
+export interface ResumeVerifierFailure {
+    command: string;
+    exitCode?: number;
+    crashed?: boolean;
+    timedOut?: boolean;
+    failureExcerpt: string;
+    attemptId: string;
+    attemptIndex: number;
+}
+export interface ResumabilityDecision {
+    allowed: boolean;
+    reason: string;
+}
+export declare function evaluateRunResumability(loop: LoopRecord): ResumabilityDecision;
+export declare function loadResumeCandidateBoundary(runsRoot: string, loop: LoopRecord): Promise<RollbackBoundaryArtifact | undefined>;
+export declare function loadResumeVerifierFailure(runsRoot: string, loop: LoopRecord): Promise<ResumeVerifierFailure | undefined>;
+export declare function acquireRunExecutionLease(input: {
+    runsRoot: string;
+    runId: string;
+    owner: string;
+    now?: () => string;
+    host?: string;
+    pid?: number;
+}): Promise<AcquiredRunExecutionLease>;

package/dist/vendor/core/resume.js

@@ -0,0 +1,196 @@
+/// <reference types="node" />
+import { createHash, randomBytes } from "node:crypto";
+import { mkdir, open, readFile, unlink } from "node:fs/promises";
+import { hostname } from "node:os";
+import { join } from "node:path";
+import { artifactDir } from "./persistence/index.js";
+export function evaluateRunResumability(loop) {
+    if (loop.terminationEnvelope) {
+        return { allowed: false, reason: "The run already has authoritative terminal evidence." };
+    }
+    if (!["queued", "running", "verifying"].includes(loop.status)) {
+        return { allowed: false, reason: `Run status ${loop.status} is terminal and cannot be continued.` };
+    }
+    if (!["created", "running", "verifying"].includes(loop.lifecycleState)) {
+        return {
+            allowed: false,
+            reason: `Run lifecycle ${loop.lifecycleState} is terminal and cannot be continued.`
+        };
+    }
+    if (loop.task.taskClass === "irreversible" || loop.task.approvalPolicy?.externalWrites === true) {
+        return {
+            allowed: false,
+            reason: "Automatic execution continuation is disabled for irreversible/external-write tasks."
+        };
+    }
+    if (loop.attempts.length >= loop.budget.maxIterations) {
+        return { allowed: false, reason: "The run has no remaining iteration authority." };
+    }
+    if (loop.cost.actualUsd >= loop.budget.maxUsd) {
+        return { allowed: false, reason: "The run has no remaining USD budget authority." };
+    }
+    if (loop.budget.maxTokens !== undefined &&
+        loop.cost.tokensIn + loop.cost.tokensOut >= loop.budget.maxTokens) {
+        return { allowed: false, reason: "The run has no remaining token budget authority." };
+    }
+    const started = new Set(loop.events
+        .filter((event) => event.type === "attempt.started")
+        .map((event) => String(event.payload["attemptId"] ?? ""))
+        .filter(Boolean));
+    for (const event of loop.events) {
+        if (event.type === "attempt.completed") {
+            const attemptId = String(event.payload["attemptId"] ?? "");
+            if (attemptId)
+                started.delete(attemptId);
+        }
+    }
+    if (started.size > 0) {
+        return {
+            allowed: false,
+            reason: "A persisted attempt is still marked active; provider-process ownership is uncertain."
+        };
+    }
+    return { allowed: true, reason: "Persisted run has remaining safe execution authority." };
+}
+export async function loadResumeCandidateBoundary(runsRoot, loop) {
+    const latestAttempt = loop.attempts.at(-1);
+    if (latestAttempt?.candidateRetained !== true)
+        return undefined;
+    // Recover the first rollback boundary in the current contiguous retained-candidate
+    // suffix. Earlier retained candidates that were later discarded must not become
+    // authority for a new resume.
+    let firstRetainedAttempt = latestAttempt;
+    for (let index = loop.attempts.length - 2; index >= 0; index -= 1) {
+        const candidate = loop.attempts[index];
+        if (candidate?.candidateRetained !== true)
+            break;
+        firstRetainedAttempt = candidate;
+    }
+    const path = join(artifactDir(runsRoot, loop.loopId, firstRetainedAttempt.index), "rollback-boundary.json");
+    const raw = await readFile(path, "utf8").catch((error) => {
+        if (error.code === "ENOENT") {
+            throw new Error(`Cannot continue ${loop.loopId}: retained candidate boundary evidence is missing for attempt ${firstRetainedAttempt.index}.`);
+        }
+        throw error;
+    });
+    return JSON.parse(raw);
+}
+export async function loadResumeVerifierFailure(runsRoot, loop) {
+    const attempt = loop.attempts.at(-1);
+    if (!attempt || attempt.verifierScore === 1)
+        return undefined;
+    const path = join(artifactDir(runsRoot, loop.loopId, attempt.index), "verification.json");
+    const raw = await readFile(path, "utf8").catch((error) => {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    });
+    if (!raw)
+        return undefined;
+    const verification = JSON.parse(raw);
+    const step = verification.steps?.find((candidate) => candidate.launched === true &&
+        (candidate.crashed === true ||
+            candidate.timedOut === true ||
+            (candidate.exitCode !== undefined && candidate.exitCode !== 0)));
+    const excerpt = (step?.detail ??
+        [verification.summary, ...(verification.warnings ?? [])].filter(Boolean).join("\n")).trim();
+    return {
+        command: step?.command ?? loop.task.verificationPlan[0] ?? "unknown",
+        ...(!step?.crashed && !step?.timedOut && step?.exitCode !== undefined
+            ? { exitCode: step.exitCode }
+            : {}),
+        ...(step?.crashed ? { crashed: true } : {}),
+        ...(step?.timedOut ? { timedOut: true } : {}),
+        failureExcerpt: excerpt.slice(-1500),
+        attemptId: attempt.attemptId,
+        attemptIndex: attempt.index
+    };
+}
+export async function acquireRunExecutionLease(input) {
+    const now = input.now ?? (() => new Date().toISOString());
+    const host = input.host ?? hostname();
+    const pid = input.pid ?? process.pid;
+    const directory = join(input.runsRoot, ".execution-leases");
+    const leaseFile = `${createHash("sha256").update(input.runId).digest("hex")}.json`;
+    const path = join(directory, leaseFile);
+    await mkdir(directory, { recursive: true });
+    const token = `${pid}-${randomBytes(16).toString("hex")}`;
+    const lease = {
+        schemaVersion: "martin.execution-lease.v1",
+        runId: input.runId,
+        token,
+        owner: input.owner,
+        pid,
+        hostname: host,
+        acquiredAt: now()
+    };
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        try {
+            const handle = await open(path, "wx", 0o600);
+            try {
+                await handle.writeFile(`${JSON.stringify(lease, null, 2)}\n`, "utf8");
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+            return {
+                lease,
+                path,
+                async release() {
+                    try {
+                        const existing = JSON.parse(await readFile(path, "utf8"));
+                        if (existing.token === token)
+                            await unlink(path);
+                    }
+                    catch (error) {
+                        if (error.code !== "ENOENT")
+                            throw error;
+                    }
+                }
+            };
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            const existing = await readLease(path);
+            if (!existing)
+                continue;
+            if (existing.hostname !== host) {
+                throw new Error(`Run ${input.runId} is leased by ${existing.owner} on ${existing.hostname}; refusing cross-host takeover.`);
+            }
+            if (isProcessAlive(existing.pid)) {
+                throw new Error(`Run ${input.runId} is already executing under ${existing.owner} (pid ${existing.pid}).`);
+            }
+            await unlink(path).catch((unlinkError) => {
+                if (unlinkError.code !== "ENOENT")
+                    throw unlinkError;
+            });
+        }
+    }
+    throw new Error(`Unable to acquire execution lease for run ${input.runId}.`);
+}
+async function readLease(path) {
+    try {
+        return JSON.parse(await readFile(path, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw new Error(`Existing execution lease is unreadable: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function isProcessAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return true;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ESRCH")
+            return false;
+        return true;
+    }
+}

package/dist/vendor/core/rollback.js

@@ -6,8 +6,11 @@ import { dirname, isAbsolute, relative, resolve } from "node:path";
 import { DEPENDENCY_AND_BUILD_DIRECTORIES, isInsideDependencyOrBuildDirectory } from "./output-directories.js";
 /** Past this many ignored files, further ignored directories stay collapsed. */
 const MAX_EXPANDED_IGNORED_FILES = 20_000;
+const MAX_HASHED_IGNORED_FILE_BYTES = 8 * 1024 * 1024;
+const MAX_HASHED_IGNORED_TOTAL_BYTES = 16 * 1024 * 1024;
 const MAX_IGNORED_SNAPSHOT_BYTES = 64 * 1024 * 1024;
 const ignoredContentSnapshots = new WeakMap();
+const ignoredObservations = new WeakMap();
 /** Git listings of large untracked or ignored trees exceed spawnSync's 1 MiB default. */
 const GIT_LIST_MAX_BUFFER_BYTES = 64 * 1024 * 1024;
 export class RollbackStateUnavailableError extends Error {
@@ -50,7 +53,12 @@ export async function captureRollbackBoundary(input) {
     for (const filePath of snapshotPaths) {
         snapshots.push(await readRollbackSnapshot(input.repoRoot, filePath));
     }
-    const ignoredFiles = readIgnoredInventory(input.repoRoot);
+    const observedIgnoredFiles = readIgnoredInventory(input.repoRoot);
+    const ignoredFiles = observedIgnoredFiles.map(({ path, size, mtimeMs }) => ({
+        path,
+        size,
+        mtimeMs
+    }));
     const headRef = readGitScalar(input.repoRoot, ["rev-parse", "HEAD"]);
     const headBranch = readHeadBranch(input.repoRoot);
     const boundary = {
@@ -63,6 +71,7 @@ export async function captureRollbackBoundary(input) {
         snapshots,
         ignoredFiles
     };
+    ignoredObservations.set(boundary, new Map(observedIgnoredFiles.map((entry) => [entry.path, entry])));
     ignoredContentSnapshots.set(boundary, captureIgnoredContent(input.repoRoot, ignoredFiles));
     return boundary;
 }
@@ -75,6 +84,7 @@ export function listIgnoredFileChangesSinceBoundary(input) {
         return makeIgnoredFileChanges([], [], []);
     }
     const baseline = new Map(input.boundary.ignoredFiles.map((entry) => [entry.path, entry]));
+    const baselineObservations = ignoredObservations.get(input.boundary);
     const created = [];
     const modified = [];
     const currentEntries = readIgnoredInventory(input.repoRoot);
@@ -87,15 +97,23 @@ export function listIgnoredFileChangesSinceBoundary(input) {
         if (!previous) {
             created.push(entry.path);
         }
-        else if (!entry.path.endsWith("/") &&
-            (previous.sha256 !== undefined && entry.sha256 !== undefined
-                ? previous.sha256 !== entry.sha256
-                : previous.size !== entry.size || previous.mtimeMs !== entry.mtimeMs)) {
+        else if (!entry.path.endsWith("/") && ignoredObservationChanged(previous, baselineObservations?.get(entry.path), entry)) {
             modified.push(entry.path);
         }
     }
     return makeIgnoredFileChanges(created.sort(), modified.sort(), deleted.sort());
 }
+function ignoredObservationChanged(previous, previousObservation, current) {
+    if (previousObservation?.sha256 !== undefined && current.sha256 !== undefined) {
+        return previousObservation.sha256 !== current.sha256;
+    }
+    if (previousObservation !== undefined) {
+        return previous.size !== current.size ||
+            previous.mtimeMs !== current.mtimeMs ||
+            previousObservation.ctimeMs !== current.ctimeMs;
+    }
+    return previous.size !== current.size || previous.mtimeMs !== current.mtimeMs;
+}
 function makeIgnoredFileChanges(created, modified, deleted) {
     const changes = { created, modified };
     // Preserve the historical enumerable shape when there are no deletions while
@@ -345,25 +363,31 @@ function readIgnoredInventory(repoRoot) {
     ]));
     const inventory = [];
     let expanded = 0;
+    const hashBudget = { remainingBytes: MAX_HASHED_IGNORED_TOTAL_BYTES };
     for (const entry of collapsed) {
         const isDirectory = entry.endsWith("/");
         const leaf = entry.replace(/\/$/u, "").split("/").at(-1) ?? entry;
-        if (isDirectory &&
-            (DEPENDENCY_AND_BUILD_DIRECTORIES.has(leaf) || expanded >= MAX_EXPANDED_IGNORED_FILES)) {
-            inventory.push({ path: entry, size: 0, mtimeMs: 0 });
+        if (isDirectory && DEPENDENCY_AND_BUILD_DIRECTORIES.has(leaf)) {
+            inventory.push({ path: entry, size: 0, mtimeMs: 0, ctimeMs: 0 });
             continue;
         }
+        if (isDirectory && expanded >= MAX_EXPANDED_IGNORED_FILES) {
+            throw new RollbackStateUnavailableError(`Ignored rollback inventory exceeds the ${String(MAX_EXPANDED_IGNORED_FILES)}-file observation limit at ${entry}`);
+        }
         const files = isDirectory
             ? collapsePathsThroughLinks(repoRoot, readGitLines(repoRoot, ["ls-files", "--others", "--ignored", "--exclude-standard", "--", entry]))
             : [entry];
         for (const filePath of files) {
-            inventory.push(stampIgnoredFile(repoRoot, filePath));
+            if (expanded >= MAX_EXPANDED_IGNORED_FILES) {
+                throw new RollbackStateUnavailableError(`Ignored rollback inventory exceeds the ${String(MAX_EXPANDED_IGNORED_FILES)}-file observation limit at ${entry}`);
+            }
+            inventory.push(stampIgnoredFile(repoRoot, filePath, hashBudget));
             expanded += 1;
         }
     }
     return inventory.sort((left, right) => left.path.localeCompare(right.path));
 }
-function stampIgnoredFile(repoRoot, filePath) {
+function stampIgnoredFile(repoRoot, filePath, hashBudget) {
     try {
         const absolutePath = resolveRepoPath(repoRoot, filePath, { allowLeafLink: true });
         const link = isLinkPath(repoRoot, filePath);
@@ -371,10 +395,16 @@ function stampIgnoredFile(repoRoot, filePath) {
         const stamp = {
             path: normalizeRepoPath(filePath),
             size: stats.size,
-            mtimeMs: Math.trunc(stats.mtimeMs)
+            mtimeMs: Math.trunc(stats.mtimeMs),
+            ctimeMs: Math.trunc(stats.ctimeMs)
         };
-        if (!link && stats.isFile() && !isInsideDependencyOrBuildDirectory(filePath)) {
+        if (!link &&
+            stats.isFile() &&
+            stats.size <= MAX_HASHED_IGNORED_FILE_BYTES &&
+            stats.size <= hashBudget.remainingBytes &&
+            !isInsideDependencyOrBuildDirectory(filePath)) {
             stamp.sha256 = createHash("sha256").update(readFileSync(absolutePath)).digest("hex");
+            hashBudget.remainingBytes -= stats.size;
         }
         return stamp;
     }
@@ -383,7 +413,7 @@ function stampIgnoredFile(repoRoot, filePath) {
             throw new RollbackStateUnavailableError(`Unable to authenticate ignored rollback path ${normalizeRepoPath(filePath)}: ${toErrorMessage(error)}`);
         }
         // Vanished between listing and stat; record presence only so later comparison fails closed.
-        return { path: normalizeRepoPath(filePath), size: -1, mtimeMs: -1 };
+        return { path: normalizeRepoPath(filePath), size: -1, mtimeMs: -1, ctimeMs: -1 };
     }
 }
 function captureIgnoredContent(repoRoot, ignoredFiles) {

package/dist/vendor/core/test-integrity.js

@@ -226,43 +226,66 @@ export function findWeakenedTestFiles(input) {
     if (candidates.length === 0) {
         return [];
     }
-    const removedLines = listFilesWithRemovedLines(input.repoRoot, input.baseRef, candidates);
-    return [...removedLines].filter((filePath) => isWeakened(input, filePath)).sort();
+    const changedLines = listChangedTestFiles(input.repoRoot, input.baseRef, candidates);
+    for (const filePath of candidates) {
+        if (!changedLines.has(filePath) &&
+            readBaseContent(input.repoRoot, input.baseRef, filePath) === undefined &&
+            readWorkingContent(input.repoRoot, filePath) !== undefined) {
+            // Untracked files are absent from `git diff --numstat` but still belong
+            // to the caller's observed changed-file set.
+            changedLines.set(filePath, false);
+        }
+    }
+    return [...changedLines.entries()]
+        .filter(([filePath, removedLines]) => isWeakened(input, filePath, removedLines))
+        .map(([filePath]) => filePath)
+        .sort();
 }
-/** Files among `candidates` that lost at least one line (or are binary) since `baseRef`. */
-function listFilesWithRemovedLines(repoRoot, baseRef, candidates) {
+/** Modified files among `candidates`, with whether they lost a line (or are binary). */
+function listChangedTestFiles(repoRoot, baseRef, candidates) {
     const result = spawnSync("git", ["diff", "--numstat", "--no-renames", "-z", baseRef, "--", ...candidates], { cwd: repoRoot, encoding: "utf8", maxBuffer: 16 * 1024 * 1024 });
     if (result.status !== 0 || typeof result.stdout !== "string") {
         const detail = typeof result.stderr === "string" ? result.stderr.trim() : "";
         throw new Error(`Test-change inspection failed: ${detail || `git exited with ${String(result.status)}`}`);
     }
-    const removed = new Set();
+    const changed = new Map();
     for (const record of result.stdout.split("\0")) {
-        const [, deletions, filePath] = record.split("\t");
-        if (filePath && deletions !== undefined && (deletions === "-" || Number(deletions) > 0)) {
-            removed.add(filePath.trim());
+        const [additions, deletions, filePath] = record.split("\t");
+        if (filePath && additions !== undefined && deletions !== undefined) {
+            changed.set(filePath.trim(), deletions === "-" || Number(deletions) > 0);
         }
     }
-    return removed;
+    return changed;
 }
 /** Cap on file size the surface analysis reads; larger files use the strict rule. */
 const MAX_SURFACE_BYTES = 2 * 1024 * 1024;
-function isWeakened(input, filePath) {
+const BASE_CONTENT_UNINSPECTABLE = Symbol("base-content-uninspectable");
+function isWeakened(input, filePath, removedLines) {
     const before = readBaseContent(input.repoRoot, input.baseRef, filePath);
-    if (before === undefined) {
+    if (before === BASE_CONTENT_UNINSPECTABLE) {
         return true;
     }
+    if (before === undefined) {
+        const after = readWorkingContent(input.repoRoot, filePath);
+        // New tests are welcome, but focus/skip/expected-failure markers can still
+        // suppress the authoritative suite and therefore require approval.
+        return after === undefined || testSurfaceWeakened("", after, filePath);
+    }
     const after = readWorkingContent(input.repoRoot, filePath);
     if (after === undefined) {
         // Deleted, replaced by a link, unreadable or oversized: cannot prove it still asserts.
         return true;
     }
     if (!hasTestSurface(extractTestSurface(before, filePath))) {
-        return true;
+        return removedLines || testSurfaceWeakened(before, after, filePath);
     }
     return testSurfaceWeakened(before, after, filePath);
 }
 function readBaseContent(repoRoot, baseRef, filePath) {
+    const exists = spawnSync("git", ["cat-file", "-e", `${baseRef}:${filePath}`], { cwd: repoRoot });
+    if (exists.status !== 0) {
+        return undefined;
+    }
     const result = spawnSync("git", ["show", `${baseRef}:${filePath}`], {
         cwd: repoRoot,
         encoding: "utf8",
@@ -270,7 +293,7 @@ function readBaseContent(repoRoot, baseRef, filePath) {
     });
     return result.status === 0 && typeof result.stdout === "string" && result.stdout.length <= MAX_SURFACE_BYTES
         ? result.stdout
-        : undefined;
+        : BASE_CONTENT_UNINSPECTABLE;
 }
 function readWorkingContent(repoRoot, filePath) {
     const absolutePath = join(repoRoot, filePath);