@henryqw/pi-subagent 27.5.4 → 27.6.1

package/README.md

@@ -33,7 +33,7 @@ Commands and UI are for you. Tools and the packaged skill are for Main, except `
 | `/subagent roles` | command | List Role sources, resources, resolved model and thinking level, route errors, and file errors. Read-only; requires no Herdr pane. |
 | `/subagent prune` | command | Review remaining worker and integration branches and worktrees. Remove merged resources after confirmation. Requires a running Herdr server; without interactive UI, only reports. |
 | `/subagent recover` | command | Classify interrupted isolated work in the canonical repository. Send Main request IDs, blockers, and next actions. Requires no UI or Herdr pane. |
-| `delegate_task` | tool | Start authorized shared-checkout work or a durable isolated checked graph. |
+| `delegate_task` | tool | Start authorized shared-checkout work or a durable isolated checked graph. With `dryRun: true`, check the request and show the resolved plan without a launch. |
 | `subagent_status` | tool | Read saved isolated state, exact identities, failed review verdicts, and allowed continuation. Does not replay work. Supports structured output for `codemode`. |
 | `subagent_resume` | tool | Perform the reported `retry`, `verify`, or `finalize` continuation, not staging or integration. Same-worker correction retries accept optional `instruction` text. |
 | `subagent_stage` | tool | Stage, resolve, reject, or revise an exact candidate. Rejecting a staged candidate freezes its generation. |
@@ -41,7 +41,7 @@ Commands and UI are for you. Tools and the packaged skill are for Main, except `
 | `subagent_abort` | tool | Terminate an isolated request without discarding retained work. Retained candidates and integration work require release or proof of absence. |
 | `git_read` | tool | Let Role-declared children inspect bounded local Git evidence without Bash, tests, network access, or writes. Not available to Main. |
 | `pi-subagent` | skill | Guide Main through authorization, delegation, checks, integration, and recovery. |
-| Direct status widget (`D`) | ui | Show direct references, names, Role badges, status, routes, elapsed time, measured task tokens, and tool activity in the TUI. |
+| Direct status widget (`D`) | ui | Show direct references, names, Role badges, status, routes, elapsed time, measured task tokens, cost, and tool activity in the TUI. |
 | Isolated status widget (`I`) | ui | Show recorded task state, Role/model-class badges, and retained workspaces in the TUI. Readiness does not mean promotion. |
 
 `delegate_task`, `subagent_resume`, `subagent_stage`, `subagent_integrate`, and `subagent_abort` are model-only. Main must make these decisions visibly; `codemode` scripts can call only `subagent_status`.
@@ -82,7 +82,11 @@ Tasks in write requests must return one JSON completion object:
 
 `outcome` accepts `succeeded`, `failed`, or `blocked`; `answer` must be non-empty. Plain text, malformed completion, blocked work, or failure stops later dispatch. Success is the worker's report, not independent validation. Checkout admission depends on proved termination, not the reported outcome.
 
-The launch returns a task ID and first Herdr tab, not the answer. One follow-up delivers results when the workflow finishes. Busy Main receives it after its current turn; idle Main starts a turn. Failed partial output stays marked as partial, never success. Worker output carries no user authority.
+A write task can declare `"paths": ["src/**"]` with repo-relative globs. For each task in a write request, the result lists new commits and changed paths, and it flags changed paths outside `paths`. This is a report only, not enforcement, and it cannot exclude changes from other processes. For a read request, the result warns `checkout changed during task; result may be stale` when the checkout changed while the task ran. Outside a Git repository, the extension makes no report. See [Checkout change reports](./docs/orchestration.md#checkout-change-reports).
+
+To check a request before a launch, add `"dryRun": true`. The dry run does the launch checks and shows each task's Role, model, thinking level, access, and dependencies. It starts no worker and opens no tab. It also reserves no checkout and sends no follow-up. A failed check gives the same error as a launch. For the full list of checks, see [Dry run](./docs/orchestration.md#dry-run).
+
+The launch returns a task ID and first Herdr tab, not the answer. One follow-up delivers results when the workflow finishes. The results show the tokens and cost of each worker and the total cost of the request. Busy Main receives it after its current turn; idle Main starts a turn. Failed partial output stays marked as partial, never success. Worker output carries no user authority.
 
 To continue a finished worker, add `"continueFrom": "D7.1"` with the same `role`. This opens a new tab with the saved conversation and a new reference. Continue the newest reference from the original checkout and workspace. For eligibility and stop behavior, see [Continue or stop one direct worker](./docs/orchestration.md#continue-or-stop-one-direct-worker).
 
@@ -125,13 +129,17 @@ Keep the durable ID; Main can work or end its turn without polling. Inspect read
 
 Readiness requires preliminary checks and any task `judgment`; it does not permit promotion. Checks and judgments bind to exact Git identities. Staging, combined validation, and promotion require unchanged, clean Main at the pinned identity. Changed identities, conflicts, or uncertain outcomes block promotion and preserve evidence. A definitive combined check or review failure permits one committed integration correction, recorded with `subagent_integrate correct`, and another validation.
 
+Combined validation can reuse a passed preliminary check of a staged candidate. The candidate must have the same tree as the combined tip, and the check must have the identical command and argv. Then the final check does not run again. This usually occurs when you stage one candidate onto unchanged Main. Status shows each reused result and its candidate. Final judgment still runs.
+
+Reuse assumes that checks use only tracked content. Ignored files, for example `node_modules`, can be different between worktrees.
+
 The extension sends follow-ups when a candidate becomes ready, a worker needs attention, and the wave finishes. A missed follow-up does not authorize replay. Read [Isolated contract](./docs/orchestration.md#isolated-contract) and [Exact integration actions](./docs/orchestration.md#exact-integration-actions) for graph, judgment, revision, refresh, and release details.
 
 ### Inspect work
 
-Open `/subagent` to browse direct work on this session branch and isolated requests in the current canonical Git checkout, including other sessions. **Refresh** reloads saved status without recovery or mutation. Invalid state IDs stay preserved with a warning. Direct recovery remains available outside Git or without isolated inventory.
+Open `/subagent` to browse direct work on this session branch and isolated requests in the current canonical Git checkout, including other sessions. The menu groups rows under **Direct**, **Isolated**, and **Orphaned** headers. Each isolated row shows the request ID, the status, and a short goal summary. **Refresh** or a header reloads saved status without recovery or mutation. Invalid state IDs stay preserved with a warning. Direct recovery remains available outside Git or without isolated inventory.
 
-Requests whose parent checkout was removed show as **Isolated · orphaned** from any checkout of the same repository. Every isolated request, including an orphaned request, has **Close and delete worktrees (discard work)**. Select it to review owned resources and confirm deletion. **This permanently deletes committed, uncommitted, and ignored content in the listed checkouts.** Cancel makes no change.
+Requests whose parent checkout was removed show in the **Orphaned · parent checkout removed** group from any checkout of the same repository. Every isolated request, including an orphaned request, has **Close and delete worktrees (discard work)**. Select it to review owned resources and confirm deletion. **This permanently deletes committed, uncommitted, and ignored content in the listed checkouts.** Cancel makes no change.
 
 Only shown resources can be removed; live jobs, uncertain ownership, or other Herdr panes can block removal. Agents and tools cannot trigger this action. See [Close and delete isolated worktrees](./docs/orchestration.md#close-and-delete-isolated-worktrees) for guards and partial cleanup.
 

package/dist/direct-herdr.d.ts

@@ -8,10 +8,10 @@ export interface DirectHandle {
     sessionFile: string;
     prompt: string;
     answer(maxBytes: number): Promise<string>;
-    usageTokens(): Promise<number | undefined>;
+    usage(): Promise<DirectUsage>;
     /** Bounded assistant text from this turn so far; failure evidence only, never completion. */
     partialText(maxChars: number): Promise<string | undefined>;
-    /** Display-only activity from the last usageTokens() sample. */
+    /** Display-only activity from the last usage() sample. */
     readonly activity?: DirectToolActivity;
     cancel(): Promise<void>;
 }
@@ -19,6 +19,12 @@ export declare function exactDirectTerminalTurn(jsonl: string, prompt: string):
 /** Refuse continuation unless the saved session's exact recorded turn is terminal and no later user turn exists. */
 export declare function assertSettledDirectSession(sessionFile: string, turn: string): Promise<void>;
 export declare function exactDirectAnswer(jsonl: string, prompt: string, maxBytes?: number, requireSuccess?: boolean): string;
+/** Measured from one session read; each field is absent when no turn record carried it. */
+export interface DirectUsage {
+    tokens?: number;
+    /** Sum of assistant `usage.cost.total`. */
+    cost?: number;
+}
 export interface DirectToolActivity {
     pending: string[];
     latest?: {
@@ -26,14 +32,13 @@ export interface DirectToolActivity {
         durationMs?: number;
     };
 }
-export declare function directSessionUsage(jsonl: string, prompt: string): {
-    tokens?: number;
+export declare function directSessionUsage(jsonl: string, prompt: string): DirectUsage & {
     activity?: DirectToolActivity;
 };
 /** The last `maxChars` of assistant text in the exact prompt's turn; ignores a partial trailing entry. */
 export declare function directPartialText(jsonl: string, prompt: string, maxChars: number): string | undefined;
 /** One reader per handle; only complete, valid lines advance the byte offset. */
-export declare function createDirectSessionReader(sessionFile: string, prompt: string): Pick<DirectHandle, "usageTokens" | "partialText" | "activity">;
+export declare function createDirectSessionReader(sessionFile: string, prompt: string): Pick<DirectHandle, "usage" | "partialText" | "activity">;
 /** `turn` is the prompt's random turn identity; it proves which session turn a record owns.
  * `workspaceId` and `cwd` bind the record to its launching Herdr workspace and checkout. */
 export type DirectTab = Pick<DirectHandle, "name" | "tabId" | "paneId" | "sessionFile"> & {

package/dist/direct-herdr.js

@@ -126,6 +126,7 @@ class DirectSessionState {
     active = false;
     total = 0;
     observed = false;
+    cost;
     pending = new Map();
     latest;
     texts = [];
@@ -150,6 +151,7 @@ class DirectSessionState {
             if (this.active) {
                 this.total = 0;
                 this.observed = false;
+                this.cost = undefined;
                 this.pending.clear();
                 this.latest = undefined;
                 this.texts = [];
@@ -163,6 +165,9 @@ class DirectSessionState {
                     this.total += values.reduce((sum, value) => sum + value, 0);
                     this.observed = true;
                 }
+                const cost = usage.cost?.total;
+                if (typeof cost === "number" && Number.isFinite(cost) && cost >= 0)
+                    this.cost = (this.cost ?? 0) + cost;
             }
             if (Array.isArray(message.content))
                 for (const part of message.content) {
@@ -187,7 +192,7 @@ class DirectSessionState {
         return true;
     }
     usage() {
-        return { tokens: this.observed ? this.total : undefined,
+        return { tokens: this.observed ? this.total : undefined, cost: this.cost,
             activity: this.pending.size || this.latest ? { pending: [...this.pending.values()], latest: this.latest } : undefined };
     }
     partialText(maxChars) {
@@ -258,9 +263,9 @@ export function createDirectSessionReader(sessionFile, prompt) {
     const sample = () => reading ??= read().finally(() => { reading = undefined; });
     return {
         get activity() { return lastUsage.activity; },
-        async usageTokens() {
+        async usage() {
             lastUsage = await sample() ? state.usage() : {};
-            return lastUsage.tokens;
+            return { tokens: lastUsage.tokens, cost: lastUsage.cost };
         },
         async partialText(maxChars) {
             return await sample() ? state.partialText(maxChars) : undefined;
@@ -426,7 +431,7 @@ export function createDirectHerdr(pi, cwd, idleMs) {
                 return {
                     name, tabId, paneId, sessionFile, prompt,
                     get activity() { return session.activity; },
-                    usageTokens: session.usageTokens,
+                    usage: session.usage,
                     partialText: session.partialText,
                     async answer(maxBytes) {
                         const readAnswer = async () => {

package/dist/integration-git.d.ts

@@ -1,5 +1,5 @@
 import { type WorktreeInfo } from "./worktree.ts";
-import { type CheckBatchEvidence, type CheckCommand, type ReviewEvidence, type WorkspaceIdentity } from "./schema.ts";
+import { type CheckBatchEvidence, type CheckCommand, type IntegrationCandidate, type ReviewEvidence, type WorkspaceIdentity } from "./schema.ts";
 export type StageReceipt = {
     previous: WorkspaceIdentity;
     worker: WorkspaceIdentity;
@@ -42,6 +42,8 @@ export declare class IntegrationGit {
         stages: readonly StageReceipt[];
         checks: CheckBatchEvidence;
         commands: readonly CheckCommand[];
+        /** Staged candidates that may supply reused final results; omitted accepts no reuse. */
+        sources?: readonly IntegrationCandidate[];
         review?: ReviewEvidence;
         criterion?: string;
         correction?: {

package/dist/integration-git.js

@@ -317,7 +317,8 @@ export class IntegrationGit {
             return { outcome: "blocked", failure: "No worker stages to promote." };
         const tip = input.correction ? (await this.inspectCorrection(root, integration, base, stages, input.correction.from, input.correction.to, signal), input.correction.to)
             : await this.inspectCombined(root, integration, base, stages, signal);
-        if (input.checks.phase !== "final" || !checkBatchPasses(input.checks, input.commands, tip)
+        const sources = (input.sources ?? []).filter((source) => stages.some((stage) => sameIdentity(stage.worker, source.tip)));
+        if (input.checks.phase !== "final" || !checkBatchPasses(input.checks, input.commands, tip, sources)
             || (input.criterion !== undefined && !reviewEvidencePasses(input.review, "final", input.criterion, base, tip))
             || (input.criterion === undefined && input.review !== undefined)) {
             return { outcome: "blocked", failure: "Exact combined-tip final checks/review evidence is missing or failed." };

package/dist/launch-runtime.d.ts

@@ -1,5 +1,5 @@
 import { type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { CoordinatorRuntime, OperationContext, TransientLaunchHandle, VerifiedLaunch } from "./runner.ts";
+import type { CoordinatorRuntime, OperationContext, ResolvedRoute, TransientLaunchHandle, VerifiedLaunch } from "./runner.ts";
 import { type ExecuteRequest, type ModelClass, type WorkspaceIdentity } from "./schema.ts";
 export declare const ISOLATED_MODEL_TASK: {
     readonly id: "pi-subagent/isolatedRoleLaunch";
@@ -43,9 +43,11 @@ export declare class RoleLaunchRuntime implements CoordinatorRuntime {
     preflight(input: {
         request: ExecuteRequest;
         cwd: string;
+        dryRun?: boolean;
     }, context: OperationContext): Promise<{
         root: string;
         main: WorkspaceIdentity;
+        routes: ResolvedRoute[];
     }>;
     acquireLaunch(role: string, modelClass: ModelClass, context: OperationContext): Promise<TransientLaunchHandle<VerifiedLaunch>>;
 }

package/dist/launch-runtime.js

@@ -150,7 +150,7 @@ export class RoleLaunchRuntime {
         if (!rootInfo.isDirectory())
             throw new Error("Pi Subagent root must be an existing local directory.");
         context.signal?.throwIfAborted();
-        if (input.request.tasks.some((task) => task.kind === "changeset")) {
+        if (!input.dryRun && input.request.tasks.some((task) => task.kind === "changeset")) {
             await this.options.preflightHost?.({ request: input.request, cwd: input.cwd, root }, context);
         }
         const main = await this.options.inspectMainBase({ root }, context);
@@ -168,11 +168,14 @@ export class RoleLaunchRuntime {
         if (input.request.finalJudgment) {
             addRequired(input.request.finalJudgment.role, input.request.finalJudgment.modelClass);
         }
+        const routes = [];
         for (const [role, modelClasses] of required) {
-            for (const modelClass of modelClasses)
-                await this.prepareLaunch(role, modelClass, context);
+            for (const modelClass of modelClasses) {
+                const { launch } = await this.prepareLaunch(role, modelClass, context);
+                routes.push({ role, modelClass, model: launch.model, thinkingLevel: launch.thinkingLevel });
+            }
         }
-        return { root, main };
+        return { root, main, routes };
     }
     async acquireLaunch(role, modelClass, context) {
         const prepared = await this.prepareLaunch(role, modelClass, context);

package/dist/runner.d.ts

@@ -96,6 +96,14 @@ export interface VerifiedLaunch {
     readonly env: Readonly<Record<string, string>>;
     readonly tools: readonly string[];
 }
+export type ResolvedRoute = Pick<VerifiedLaunch, "role" | "modelClass" | "model" | "thinkingLevel">;
+/** A dry-run result: the normalized request and the resolved routes; no state exists for it. */
+export interface ExecutePlan {
+    request: ExecuteRequest;
+    root: string;
+    main: WorkspaceIdentity;
+    routes: readonly ResolvedRoute[];
+}
 export interface TransientLaunchHandle<Launch extends VerifiedLaunch = VerifiedLaunch> {
     readonly launch: Launch;
     cleanup(): Promise<void>;
@@ -109,12 +117,16 @@ export declare function withTransientLaunch<Launch extends VerifiedLaunch, Resul
 export interface CoordinatorRuntime {
     now(): number;
     randomToken(): string;
+    /** `dryRun` skips checks that call Herdr; every other check runs. */
     preflight(input: {
         request: ExecuteRequest;
         cwd: string;
+        dryRun?: boolean;
     }, context: OperationContext): Promise<{
         root: string;
         main: WorkspaceIdentity;
+        /** Resolved route of each distinct Role and model class, when the coordinator reports it. */
+        routes?: readonly ResolvedRoute[];
     }>;
     acquireLaunch(role: string, modelClass: ModelClass, context: OperationContext): Promise<TransientLaunchHandle<VerifiedLaunch>>;
 }
@@ -340,6 +352,10 @@ export declare class IsolatedRunner {
     private saveProductive;
     private callProductive;
     private rethrowStopped;
+    /** Every execute check before durable state; a dry run also skips the Herdr host preflight. */
+    private admitExecute;
+    /** Dry run of execute: no state, lock, lease, worktree, or Herdr call. */
+    plan(value: unknown, cwd: string, outerSignal?: AbortSignal): Promise<ExecutePlan>;
     execute(value: unknown, cwd: string, outerSignal?: AbortSignal): Promise<RunResponse>;
     resume(value: unknown, root: string, outerSignal?: AbortSignal): Promise<RunResponse>;
     /** Main selects an exact retained candidate; only the owned integration checkout is writable. */

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;
 }
@@ -802,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.");
@@ -824,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 = {
@@ -1453,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) {
@@ -1468,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.
                     }
@@ -1483,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))) {
@@ -1510,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));
             }
@@ -2777,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)
@@ -2795,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(),
@@ -3315,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