@henryqw/pi-subagent 27.5.3 → 27.6.0

package/dist/runner.js

@@ -5,7 +5,7 @@ import { utf8Prefix } from "./ephemeral.js";
 import { createChildWorktree, finalizeChildWorktree, inspectWorktreeDirty } from "./worktree.js";
 import { runGit } from "./git-process.js";
 import { IntegrationGit } from "./integration-git.js";
-import { checkBatchPasses, CLEANUP_KINDS, isCleanCommitted, MAX_PERSISTED_RUNTIME_TEXT_BYTES, MAX_POSSIBLE_RESOURCES, parseExecuteRequest, parseIntegrationAction, integrationGenerationPasses, parseResumeRequest, parseStageRequest, reviewEvidencePasses, sameIdentity, RUN_STATE_VERSION, } from "./schema.js";
+import { checkBatchPasses, CLEANUP_KINDS, isCleanCommitted, MAX_PERSISTED_RUNTIME_TEXT_BYTES, MAX_POSSIBLE_RESOURCES, parseExecuteRequest, parseIntegrationAction, integrationGenerationPasses, parseResumeRequest, parseStageRequest, reusableCheckSource, reviewEvidencePasses, sameIdentity, formatCheckCommand, stagedCheckSources, RUN_STATE_VERSION, } from "./schema.js";
 import { FileRunStore, ProductiveRunLeaseBusyError } from "./store.js";
 const TRUNCATION_MARKER = "\n[truncated]";
 const TEXT_TASK_PROMPT_MAX_BYTES = 64 * 1024;
@@ -391,6 +391,11 @@ function exactCommandResults(results, checks) {
             && result.args.every((arg, argIndex) => arg === check.args[argIndex]);
     });
 }
+function reusedCheckLines(checks) {
+    return (checks?.results ?? []).flatMap((result) => result.reusedFrom
+        ? [`Combined check ${formatCheckCommand(result)} reused the passed preliminary result of ${result.reusedFrom.taskId}#${result.reusedFrom.attempt}@${result.reusedFrom.candidate.head} on the same tree; it did not run again.`]
+        : []);
+}
 function isCommitNudge(prompt) {
     return prompt.kind === "followup" && prompt.instruction === COMMIT_NUDGE_INSTRUCTION;
 }
@@ -592,6 +597,8 @@ export function nextIntegrationAction(state) {
                 return `Call subagent_integrate refresh with generation ${generation.number + 1}, expectedTip ${JSON.stringify(generation.combinedTip)}, and identical expectedMain and newMain; then restage the candidates and validate again.`;
             }
             return undefined;
+        case "promoted":
+            return `Promotion is proven, but cleanup retained resources; resolve the recorded cleanup failures without discarding work, then call subagent_integrate cleanup with ${exact}.`;
         default:
             return undefined;
     }
@@ -800,12 +807,12 @@ export class IsolatedRunner {
         if (error instanceof DurableRunStopped)
             throw error;
     }
-    async execute(value, cwd, outerSignal) {
+    /** Every execute check before durable state; a dry run also skips the Herdr host preflight. */
+    async admitExecute(value, cwd, scope, dryRun) {
         const request = parseExecuteRequest(value);
         const policy = Object.freeze({ ...this.currentPolicy() });
-        const scope = new ProductiveScope(outerSignal);
         const canonicalCwd = realpathSync.native(cwd);
-        const prepared = await scope.call(async (context) => await this.coordinatorRuntime.preflight({ request, cwd: canonicalCwd }, context));
+        const prepared = await scope.call(async (context) => await this.coordinatorRuntime.preflight({ request, cwd: canonicalCwd, ...(dryRun ? { dryRun } : {}) }, context));
         const root = realpathSync.native(prepared.root);
         if (root !== prepared.root)
             throw new Error("Preflight repository root must be canonical.");
@@ -822,6 +829,16 @@ export class IsolatedRunner {
         if (this.hasAnyActiveControl(root)) {
             throw new Error("Another Pi Subagent request has active changeset work in this repository.");
         }
+        return { request, policy, root, preparedMain, routes: prepared.routes ?? [] };
+    }
+    /** Dry run of execute: no state, lock, lease, worktree, or Herdr call. */
+    async plan(value, cwd, outerSignal) {
+        const { request, root, preparedMain, routes } = await this.admitExecute(value, cwd, new ProductiveScope(outerSignal), true);
+        return { request, root, main: preparedMain, routes };
+    }
+    async execute(value, cwd, outerSignal) {
+        const scope = new ProductiveScope(outerSignal);
+        const { request, policy, root, preparedMain } = await this.admitExecute(value, cwd, scope, false);
         return await this.withProductiveRun(root, async (lifecycle) => {
             const createdAt = this.coordinatorRuntime.now();
             const state = {
@@ -1062,6 +1079,8 @@ export class IsolatedRunner {
                 if (action.action === "reject" && allocationByKind(attempt, "agent")) {
                     if (await this.terminateWithSafety(handle, task, attempt, action.candidate, scope.signal))
                         task.status = "rejected";
+                    else
+                        this.attention(task, `Worker termination is unproved: ${attempt.termination.failure}`);
                     await this.saveProductive(handle);
                 }
                 if (action.action === "revise") {
@@ -1449,10 +1468,11 @@ export class IsolatedRunner {
                         throw new Error("Combined tip changed the admitted canonical root test script.");
                     }
                     await this.requireExactIntegration(handle, generation, receipts, scope);
-                    const checks = await this.runCheckBatch(handle, request.finalChecks, action.expectedTip, "final", scope, undefined, generation.worktree.path);
+                    const sources = stagedCheckSources(generation, state.integration.candidates);
+                    const checks = await this.runCheckBatch(handle, request.finalChecks, action.expectedTip, "final", scope, undefined, generation.worktree.path, request.finalChecks.map((check) => reusableCheckSource(check, action.expectedTip, sources)));
                     generation.checks = checks;
                     await this.saveProductive(handle);
-                    if (!checkBatchPasses(checks, request.finalChecks, action.expectedTip))
+                    if (!checkBatchPasses(checks, request.finalChecks, action.expectedTip, sources))
                         throw new Error("Combined full-suite check failed or changed the integration tip.");
                     await this.requireExactIntegration(handle, generation, receipts, scope);
                     if (request.finalJudgment) {
@@ -1464,12 +1484,12 @@ export class IsolatedRunner {
                         }
                     }
                     await this.requireExactIntegration(handle, generation, receipts, scope);
-                    if (!integrationGenerationPasses(generation, request))
+                    if (!integrationGenerationPasses(generation, request, state.integration.candidates))
                         throw new Error("Combined validation is incomplete.");
                     generation.status = "ready";
                 }
                 catch (error) {
-                    if (integrationGenerationPasses(generation, request)) {
+                    if (integrationGenerationPasses(generation, request, state.integration.candidates)) {
                         delete generation.checks;
                         delete generation.review; // Drift invalidates otherwise passing evidence.
                     }
@@ -1479,7 +1499,7 @@ export class IsolatedRunner {
                 await this.saveProductive(handle);
                 return this.response(state);
             }
-            if (generation.status !== "ready" || !integrationGenerationPasses(generation, request)) {
+            if (generation.status !== "ready" || !integrationGenerationPasses(generation, request, state.integration.candidates)) {
                 throw new Error("Promotion requires exact successful combined validation.");
             }
             for (const definition of request.tasks.filter((task) => hasChangesetDependency(state, task.id))) {
@@ -1506,6 +1526,7 @@ export class IsolatedRunner {
                 outcome = await scope.call((context) => this.integrationGit.promote({
                     root, integration: generation.worktree, base: generation.expectedMain, stages: receipts,
                     checks: generation.checks, commands: request.finalChecks,
+                    sources: stagedCheckSources(generation, state.integration.candidates),
                     review: generation.review, criterion: request.finalJudgment?.criterion, correction: generation.correction,
                 }, context.signal));
             }
@@ -1605,101 +1626,123 @@ export class IsolatedRunner {
         // Promotion proves selection independently of worker or checkout cleanup.
         for (const stage of generation.stages)
             changesetTaskState(state, stage.taskId).status = "completed";
+        const generationCleanup = generation.cleanup ??= [{ kind: "worktree", status: "pending" }, { kind: "branch", status: "pending" }];
+        const stepLists = [...generation.stages.map((stage) => changesetTaskState(state, stage.taskId).attempts[stage.attempt - 1].cleanup),
+            generationCleanup];
+        // Record each failure on the step it blocks; other stages and the integration checkout continue.
+        const blocked = (steps, error) => {
+            const step = steps.find((item) => item.status === "running") ?? steps.find((item) => item.status !== "completed");
+            if (step)
+                step.failure = bounded(`Cleanup requires attention: ${errorText(error)}`);
+        };
         await this.saveProductive(handle);
+        let main;
         try {
-            const main = await this.callProductive(handle, scope, (context) => this.gitRuntime.inspectMain({ root: state.root }, context));
-            if (!sameIdentity(main, promoted))
-                throw new Error("Main changed or became dirty after promotion; cleanup is blocked.");
+            main = await this.callProductive(handle, scope, (context) => this.gitRuntime.inspectMain({ root: state.root }, context));
+        }
+        catch (error) {
+            for (const steps of stepLists)
+                blocked(steps, error);
+        }
+        if (main && !sameIdentity(main, promoted)) {
+            for (const steps of stepLists)
+                blocked(steps, new Error("Main changed or became dirty after promotion; cleanup is blocked."));
+        }
+        else if (main) {
             for (const stage of generation.stages) {
                 const task = changesetTaskState(state, stage.taskId);
                 const attempt = task.attempts[stage.attempt - 1];
-                const candidate = state.integration.candidates.find((item) => item.taskId === stage.taskId && item.attempt === stage.attempt
-                    && sameIdentity(item.tip, stage.source));
-                const worker = allocationByKind(attempt, "worktree")?.worktree;
-                if (!worker)
-                    throw new Error("Promoted worker lacks a proven checkout.");
-                candidate.worker = "release_pending";
-                await this.saveProductive(handle);
-                if (attempt.termination?.status !== "terminated") {
-                    if (attempt.termination) {
-                        const result = await this.callProductive(handle, scope, (context) => this.hostRuntime.reconcileWorkerTermination({
-                            task: changesetTaskRequest(state, task.taskId), attempt,
-                            workerId: attempt.termination.workerId, candidate: stage.source,
-                        }, context));
-                        if (result.outcome !== "terminated")
-                            throw new Error("Worker termination cannot be proved; never replay termination.");
-                        attempt.termination = { status: "terminated", workerId: attempt.termination.workerId,
-                            candidate: stage.source, at: this.coordinatorRuntime.now() };
-                        await this.saveProductive(handle);
-                    }
-                    else if (!await this.terminateWithSafety(handle, task, attempt, stage.source, scope.signal)) {
-                        throw new Error("Worker termination was not proved.");
-                    }
+                try {
+                    await this.cleanupPromotedStage(handle, generation, receipts, promoted, stage, task, attempt, scope);
+                }
+                catch (error) {
+                    blocked(attempt.cleanup, error);
                 }
-                for (const kind of CLEANUP_KINDS) {
-                    const step = attempt.cleanup.find((item) => item.kind === kind);
+                await this.saveProductive(handle);
+            }
+            try {
+                for (const step of generationCleanup) {
                     if (step.status === "completed")
                         continue;
                     step.status = "running";
                     await this.saveProductive(handle);
-                    if (kind === "worker_tab" || kind === "workspace") {
-                        const result = await this.callProductive(handle, scope, (context) => this.hostRuntime.cleanupHost({
-                            requestId: state.request.id, kind, task: changesetTaskRequest(state, task.taskId), attempt,
-                        }, context));
-                        if (result.outcome === "blocked")
-                            throw new Error(result.failure);
-                    }
-                    else {
-                        const result = await this.callProductive(handle, scope, (context) => this.integrationGit.cleanup(state.root, generation.worktree, worker, generation.expectedMain, receipts, promoted, kind, context.signal, generation.correction));
-                        if (result.outcome !== "ready")
-                            throw new Error(result.failure);
-                    }
+                    const result = await this.callProductive(handle, scope, (context) => this.integrationGit.cleanup(state.root, generation.worktree, generation.worktree, generation.expectedMain, receipts, promoted, step.kind, context.signal, generation.correction));
+                    if (result.outcome !== "ready")
+                        throw new Error(result.failure);
                     step.status = "completed";
                     delete step.failure;
                     await this.saveProductive(handle);
                 }
-                candidate.worker = "released";
-                // Same-attempt revisions share this exact worker checkout; release historical
-                // rejected tips only after the physical checkout has been proved removed.
-                for (const old of state.integration.candidates.filter((item) => item.decision === "rejected"
-                    && item.taskId === stage.taskId && item.attempt === stage.attempt))
-                    old.worker = "released";
-                await this.saveProductive(handle);
             }
-            generation.cleanup ??= [{ kind: "worktree", status: "pending" }, { kind: "branch", status: "pending" }];
-            await this.saveProductive(handle);
-            for (const kind of ["worktree", "branch"]) {
-                const step = generation.cleanup.find((item) => item.kind === kind);
-                if (step.status === "completed")
-                    continue;
-                step.status = "running";
-                await this.saveProductive(handle);
-                const result = await this.callProductive(handle, scope, (context) => this.integrationGit.cleanup(state.root, generation.worktree, generation.worktree, generation.expectedMain, receipts, promoted, kind, context.signal, generation.correction));
-                if (result.outcome !== "ready")
-                    throw new Error(result.failure);
-                step.status = "completed";
-                delete step.failure;
-                await this.saveProductive(handle);
+            catch (error) {
+                blocked(generationCleanup, error);
             }
         }
-        catch (error) {
-            generation.failure = undefined; // Promotion remains proven; cleanup evidence stays inspectable.
-            const pending = generation.cleanup?.find((step) => step.status === "running")
-                ?? generation.stages.flatMap((stage) => changesetTaskState(state, stage.taskId).attempts[stage.attempt - 1].cleanup)
-                    .find((step) => step.status === "running");
-            if (pending)
-                pending.failure = bounded(`Cleanup requires attention: ${errorText(error)}`);
-            await this.saveProductive(handle);
-        }
-        if (state.tasks.every((task) => task.status === "completed" || task.status === "rejected")
+        // Promotion remains proven; the request stays visible until every promoted resource is released.
+        if (stepLists.every((steps) => steps.every((step) => step.status === "completed"))
+            && state.tasks.every((task) => task.status === "completed" || task.status === "rejected")
             && state.integration.candidates.every((candidate) => candidate.decision || generation.stages.some((stage) => stage.taskId === candidate.taskId && stage.attempt === candidate.attempt && sameIdentity(stage.source, candidate.tip)))) {
             state.final = { status: "passed", identity: promoted, checks: generation.checks,
                 ...(generation.review ? { review: generation.review } : {}) };
             state.status = "completed";
             state.accepted = true;
             state.acceptedAt = this.coordinatorRuntime.now();
+        }
+        await this.saveProductive(handle);
+    }
+    async cleanupPromotedStage(handle, generation, receipts, promoted, stage, task, attempt, scope) {
+        const state = handle.state;
+        const candidate = state.integration.candidates.find((item) => item.taskId === stage.taskId && item.attempt === stage.attempt
+            && sameIdentity(item.tip, stage.source));
+        const worker = allocationByKind(attempt, "worktree")?.worktree;
+        if (!worker)
+            throw new Error("Promoted worker lacks a proven checkout.");
+        candidate.worker = "release_pending";
+        await this.saveProductive(handle);
+        if (attempt.termination?.status !== "terminated") {
+            if (attempt.termination) {
+                const result = await this.callProductive(handle, scope, (context) => this.hostRuntime.reconcileWorkerTermination({
+                    task: changesetTaskRequest(state, task.taskId), attempt,
+                    workerId: attempt.termination.workerId, candidate: stage.source,
+                }, context));
+                if (result.outcome !== "terminated")
+                    throw new Error("Worker termination cannot be proved; never replay termination.");
+                attempt.termination = { status: "terminated", workerId: attempt.termination.workerId,
+                    candidate: stage.source, at: this.coordinatorRuntime.now() };
+                await this.saveProductive(handle);
+            }
+            else if (!await this.terminateWithSafety(handle, task, attempt, stage.source, scope.signal)) {
+                throw new Error(`Worker termination was not proved: ${attempt.termination.failure}`);
+            }
+        }
+        for (const kind of CLEANUP_KINDS) {
+            const step = attempt.cleanup.find((item) => item.kind === kind);
+            if (step.status === "completed")
+                continue;
+            step.status = "running";
+            await this.saveProductive(handle);
+            if (kind === "worker_tab" || kind === "workspace") {
+                const result = await this.callProductive(handle, scope, (context) => this.hostRuntime.cleanupHost({
+                    requestId: state.request.id, kind, task: changesetTaskRequest(state, task.taskId), attempt,
+                }, context));
+                if (result.outcome === "blocked")
+                    throw new Error(result.failure);
+            }
+            else {
+                const result = await this.callProductive(handle, scope, (context) => this.integrationGit.cleanup(state.root, generation.worktree, worker, generation.expectedMain, receipts, promoted, kind, context.signal, generation.correction));
+                if (result.outcome !== "ready")
+                    throw new Error(result.failure);
+            }
+            step.status = "completed";
+            delete step.failure;
             await this.saveProductive(handle);
         }
+        candidate.worker = "released";
+        // Same-attempt revisions share this exact worker checkout; release historical
+        // rejected tips only after the physical checkout has been proved removed.
+        for (const old of state.integration.candidates.filter((item) => item.decision === "rejected"
+            && item.taskId === stage.taskId && item.attempt === stage.attempt))
+            old.worker = "released";
     }
     async requireExactIntegration(handle, generation, receipts, scope, allowDirtyMain = false) {
         const root = handle.state.root;
@@ -2736,7 +2779,6 @@ export class IsolatedRunner {
             if (result.outcome !== "terminated") {
                 const failure = boundedRuntimeText(result.failure, "Worker termination failure");
                 attempt.termination = { status: "unknown", workerId, candidate, failure };
-                this.attention(task, `Worker termination is unproved: ${failure}`);
                 return false;
             }
             attempt.termination = { status: "terminated", workerId, candidate, at: this.coordinatorRuntime.now() };
@@ -2745,7 +2787,6 @@ export class IsolatedRunner {
         catch (error) {
             this.rethrowStopped(error);
             attempt.termination = { status: "unknown", workerId, candidate, failure: errorText(error) };
-            this.attention(task, `Worker termination is unproved: ${errorText(error)}`);
             return false;
         }
         finally {
@@ -2753,17 +2794,19 @@ export class IsolatedRunner {
             await save();
         }
     }
-    async runCheckBatch(handle, checks, candidate, phase, scope, taskId, root = handle.state.root) {
+    async runCheckBatch(handle, checks, candidate, phase, scope, taskId, root = handle.state.root, reuse = []) {
         const attempt = taskId ? latestAttempt(changesetTaskState(handle.state, taskId)) : undefined;
+        // Run every non-reused check, even none, so the runtime still proves the post-check identity.
+        const run = checks.filter((_, index) => !reuse[index]);
         const result = await this.callProductive(handle, scope, async (context) => await this.gitRuntime.runChecks({
             root,
             scope: phase === "final" ? "final" : "task",
             ...(taskId ? { taskId, attempt } : {}),
-            checks,
+            checks: run,
             candidate,
         }, context));
         const identityAfter = runtimeIdentity(result.identityAfter, "Post-check identity");
-        if (!exactCommandResults(result.results, checks)) {
+        if (!exactCommandResults(result.results, run)) {
             throw new Error("Check runtime did not return one result with the exact command and argv for every declared check.");
         }
         if (result.results.some((item) => !Number.isSafeInteger(item.code)
@@ -2771,23 +2814,29 @@ export class IsolatedRunner {
             || typeof item.stdout !== "string" || typeof item.stderr !== "string")) {
             throw new Error("Check runtime returned malformed result evidence.");
         }
-        const commandsPassed = result.results.every((item) => item.code === 0 && !item.killed);
+        let ran = 0;
+        const results = checks.map((check, index) => {
+            const reusedFrom = reuse[index];
+            return reusedFrom ? { ...check, code: 0, killed: false, stdout: "", stderr: "" } : result.results[ran++];
+        });
+        const commandsPassed = results.every((item) => item.code === 0 && !item.killed);
         const identityMatches = sameIdentity(identityAfter, candidate);
         const passed = identityMatches && commandsPassed;
-        let diagnosticIndex = passed ? -1 : result.results.findIndex((item) => item.code !== 0 || item.killed);
+        let diagnosticIndex = passed ? -1 : results.findIndex((item) => item.code !== 0 || item.killed);
         if (diagnosticIndex < 0 && commandsPassed && !identityMatches)
-            diagnosticIndex = result.results.length - 1;
+            diagnosticIndex = results.length - 1;
         const evidence = {
             phase,
             candidate,
             identityAfter,
-            results: result.results.map((item, index) => ({
+            results: results.map((item, index) => ({
                 command: item.command,
                 args: [...item.args],
                 code: item.code,
                 killed: item.killed ?? false,
                 stdout: index === diagnosticIndex ? bounded(item.stdout) : "",
                 stderr: index === diagnosticIndex ? bounded(item.stderr) : "",
+                ...(reuse[index] ? { reusedFrom: reuse[index] } : {}),
             })),
             passed,
             at: this.coordinatorRuntime.now(),
@@ -3291,6 +3340,7 @@ export class IsolatedRunner {
                     ...(state.integration.generations.at(-1).failure ? [`Integration: ${state.integration.generations.at(-1).failure}`] : []),
                     ...(state.integration.generations.at(-1).promotion?.failure ? [`Promotion: ${state.integration.generations.at(-1).promotion.failure}`] : []),
                     ...(state.integration.generations.at(-1).checks?.passed === false ? ["Combined checks failed; Main was not changed."] : []),
+                    ...reusedCheckLines(state.integration.generations.at(-1).checks),
                     ...(state.integration.generations.at(-1).status === "promoted" ? ["Promotion proven; worker cleanup is pending or completed. Use subagent_integrate cleanup with the exact tip if interrupted."] : []),
                 ] : []),
                 ...(state.integration.generations.some((item) => item.status === "superseded" && item.worktree

package/dist/schema.d.ts

@@ -10,6 +10,11 @@ export declare const CheckCommandSchema: Type.TObject<{
     command: Type.TString;
     args: Type.TArray<Type.TString>;
 }>;
+/** One display form for a check command; quoted args keep argv boundaries visible. */
+export declare function formatCheckCommand({ command, args }: {
+    command: string;
+    args: readonly string[];
+}): string;
 export declare const JudgmentSchema: Type.TObject<{
     role: Type.TString;
     modelClass: Type.TUnion<[Type.TLiteral<"fast">, Type.TLiteral<"balanced">, Type.TLiteral<"frontier">, Type.TLiteral<"fav">]>;
@@ -291,6 +296,7 @@ export type HostAllocationPlan = WorkspaceAllocationPlan | WorkerTabAllocationPl
 export type PromptRecord = Static<typeof PromptRecordSchema>;
 export type CommandEvidence = Static<typeof CommandEvidenceSchema>;
 export type CheckBatchEvidence = Static<typeof CheckBatchEvidenceSchema>;
+export type ReusedCheckSource = NonNullable<CommandEvidence["reusedFrom"]>;
 export type ReviewEvidence = Static<typeof ReviewEvidenceSchema>;
 export type WorkerTermination = Static<typeof WorkerTerminationSchema>;
 export declare const CLEANUP_KINDS: readonly ["worker_tab", "workspace", "worktree", "branch"];
@@ -430,6 +436,16 @@ declare const CommandEvidenceSchema: Type.TObject<{
     killed: Type.TBoolean;
     stdout: Type.TString;
     stderr: Type.TString;
+    reusedFrom: Type.TOptional<Type.TObject<{
+        taskId: Type.TString;
+        attempt: Type.TInteger;
+        candidate: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+    }>>;
 }>;
 declare const CheckBatchEvidenceSchema: Type.TObject<{
     phase: Type.TUnion<[Type.TLiteral<"preliminary">, Type.TLiteral<"final">]>;
@@ -452,6 +468,16 @@ declare const CheckBatchEvidenceSchema: Type.TObject<{
         killed: Type.TBoolean;
         stdout: Type.TString;
         stderr: Type.TString;
+        reusedFrom: Type.TOptional<Type.TObject<{
+            taskId: Type.TString;
+            attempt: Type.TInteger;
+            candidate: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+        }>>;
     }>>;
     passed: Type.TBoolean;
     at: Type.TInteger;
@@ -619,6 +645,16 @@ declare const TaskAttemptSchema: Type.TObject<{
             killed: Type.TBoolean;
             stdout: Type.TString;
             stderr: Type.TString;
+            reusedFrom: Type.TOptional<Type.TObject<{
+                taskId: Type.TString;
+                attempt: Type.TInteger;
+                candidate: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+            }>>;
         }>>;
         passed: Type.TBoolean;
         at: Type.TInteger;
@@ -807,6 +843,16 @@ declare const ChangesetTaskStateSchema: Type.TObject<{
                 killed: Type.TBoolean;
                 stdout: Type.TString;
                 stderr: Type.TString;
+                reusedFrom: Type.TOptional<Type.TObject<{
+                    taskId: Type.TString;
+                    attempt: Type.TInteger;
+                    candidate: Type.TObject<{
+                        branch: Type.TString;
+                        head: Type.TString;
+                        index: Type.TString;
+                        tree: Type.TString;
+                    }>;
+                }>>;
             }>>;
             passed: Type.TBoolean;
             at: Type.TInteger;
@@ -1086,6 +1132,16 @@ declare const TaskStateSchema: Type.TUnion<[Type.TObject<{
                 killed: Type.TBoolean;
                 stdout: Type.TString;
                 stderr: Type.TString;
+                reusedFrom: Type.TOptional<Type.TObject<{
+                    taskId: Type.TString;
+                    attempt: Type.TInteger;
+                    candidate: Type.TObject<{
+                        branch: Type.TString;
+                        head: Type.TString;
+                        index: Type.TString;
+                        tree: Type.TString;
+                    }>;
+                }>>;
             }>>;
             passed: Type.TBoolean;
             at: Type.TInteger;
@@ -1206,6 +1262,16 @@ declare const IntegrationCandidateSchema: Type.TObject<{
             killed: Type.TBoolean;
             stdout: Type.TString;
             stderr: Type.TString;
+            reusedFrom: Type.TOptional<Type.TObject<{
+                taskId: Type.TString;
+                attempt: Type.TInteger;
+                candidate: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+            }>>;
         }>>;
         passed: Type.TBoolean;
         at: Type.TInteger;
@@ -1350,6 +1416,16 @@ declare const IntegrationGenerationSchema: Type.TObject<{
             killed: Type.TBoolean;
             stdout: Type.TString;
             stderr: Type.TString;
+            reusedFrom: Type.TOptional<Type.TObject<{
+                taskId: Type.TString;
+                attempt: Type.TInteger;
+                candidate: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+            }>>;
         }>>;
         passed: Type.TBoolean;
         at: Type.TInteger;
@@ -1470,6 +1546,16 @@ export declare const IntegrationStateSchema: Type.TObject<{
                 killed: Type.TBoolean;
                 stdout: Type.TString;
                 stderr: Type.TString;
+                reusedFrom: Type.TOptional<Type.TObject<{
+                    taskId: Type.TString;
+                    attempt: Type.TInteger;
+                    candidate: Type.TObject<{
+                        branch: Type.TString;
+                        head: Type.TString;
+                        index: Type.TString;
+                        tree: Type.TString;
+                    }>;
+                }>>;
             }>>;
             passed: Type.TBoolean;
             at: Type.TInteger;
@@ -1590,6 +1676,16 @@ export declare const IntegrationStateSchema: Type.TObject<{
                 killed: Type.TBoolean;
                 stdout: Type.TString;
                 stderr: Type.TString;
+                reusedFrom: Type.TOptional<Type.TObject<{
+                    taskId: Type.TString;
+                    attempt: Type.TInteger;
+                    candidate: Type.TObject<{
+                        branch: Type.TString;
+                        head: Type.TString;
+                        index: Type.TString;
+                        tree: Type.TString;
+                    }>;
+                }>>;
             }>>;
             passed: Type.TBoolean;
             at: Type.TInteger;
@@ -1918,6 +2014,16 @@ declare const RunStateSchema: Type.TObject<{
                     killed: Type.TBoolean;
                     stdout: Type.TString;
                     stderr: Type.TString;
+                    reusedFrom: Type.TOptional<Type.TObject<{
+                        taskId: Type.TString;
+                        attempt: Type.TInteger;
+                        candidate: Type.TObject<{
+                            branch: Type.TString;
+                            head: Type.TString;
+                            index: Type.TString;
+                            tree: Type.TString;
+                        }>;
+                    }>>;
                 }>>;
                 passed: Type.TBoolean;
                 at: Type.TInteger;
@@ -2031,6 +2137,16 @@ declare const RunStateSchema: Type.TObject<{
                     killed: Type.TBoolean;
                     stdout: Type.TString;
                     stderr: Type.TString;
+                    reusedFrom: Type.TOptional<Type.TObject<{
+                        taskId: Type.TString;
+                        attempt: Type.TInteger;
+                        candidate: Type.TObject<{
+                            branch: Type.TString;
+                            head: Type.TString;
+                            index: Type.TString;
+                            tree: Type.TString;
+                        }>;
+                    }>>;
                 }>>;
                 passed: Type.TBoolean;
                 at: Type.TInteger;
@@ -2151,6 +2267,16 @@ declare const RunStateSchema: Type.TObject<{
                     killed: Type.TBoolean;
                     stdout: Type.TString;
                     stderr: Type.TString;
+                    reusedFrom: Type.TOptional<Type.TObject<{
+                        taskId: Type.TString;
+                        attempt: Type.TInteger;
+                        candidate: Type.TObject<{
+                            branch: Type.TString;
+                            head: Type.TString;
+                            index: Type.TString;
+                            tree: Type.TString;
+                        }>;
+                    }>>;
                 }>>;
                 passed: Type.TBoolean;
                 at: Type.TInteger;
@@ -2281,6 +2407,16 @@ declare const RunStateSchema: Type.TObject<{
                 killed: Type.TBoolean;
                 stdout: Type.TString;
                 stderr: Type.TString;
+                reusedFrom: Type.TOptional<Type.TObject<{
+                    taskId: Type.TString;
+                    attempt: Type.TInteger;
+                    candidate: Type.TObject<{
+                        branch: Type.TString;
+                        head: Type.TString;
+                        index: Type.TString;
+                        tree: Type.TString;
+                    }>;
+                }>>;
             }>>;
             passed: Type.TBoolean;
             at: Type.TInteger;
@@ -2445,11 +2581,16 @@ export declare function parseIdOnly(value: unknown): IdOnly;
 export declare function parseResumeRequest(value: unknown): ResumeRequest;
 export declare function sameIdentity(left: WorkspaceIdentity, right: WorkspaceIdentity): boolean;
 export declare function isCleanCommitted(identity: WorkspaceIdentity): boolean;
-export declare function checkBatchPasses(evidence: CheckBatchEvidence | undefined, checks: readonly CheckCommand[], candidate: WorkspaceIdentity): boolean;
+/** Reused results pass only when they still cite one of `sources` exactly; no sources accept no reuse. */
+export declare function checkBatchPasses(evidence: CheckBatchEvidence | undefined, checks: readonly CheckCommand[], candidate: WorkspaceIdentity, sources?: readonly IntegrationCandidate[]): boolean;
+/** Candidates exactly staged in this generation; only they can supply reused final results. */
+export declare function stagedCheckSources(generation: IntegrationGeneration, candidates: readonly IntegrationCandidate[]): IntegrationCandidate[];
+/** A passed preliminary result stands in for a final check only on the same tree with identical command and argv. */
+export declare function reusableCheckSource(check: CheckCommand, tip: WorkspaceIdentity, sources: readonly IntegrationCandidate[]): ReusedCheckSource | undefined;
 export declare function reviewEvidencePasses(evidence: ReviewEvidence | undefined, phase: ReviewEvidence["phase"], criterion: string, base: WorkspaceIdentity, tip: WorkspaceIdentity): boolean;
 /** Check the persisted integration projection against the request before recovery or promotion. */
 export declare function parseIntegrationState(value: unknown, request: ExecuteRequest): IntegrationState;
 /** Passing final evidence is bound to the exact assembled identity, not any worker tip. */
-export declare function integrationGenerationPasses(generation: IntegrationGeneration, request: ExecuteRequest): boolean;
+export declare function integrationGenerationPasses(generation: IntegrationGeneration, request: ExecuteRequest, candidates: readonly IntegrationCandidate[]): boolean;
 export declare function parseRunState(value: unknown): RunState;
 export {};