@tea-agent/loop-agent 0.39.0-next.8 → 0.39.0

package/dist/workflows/dag/rerun-plan.js

@@ -1,8 +1,9 @@
 import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { assertTaskContractBindingFresh } from "./task-contract-binding.js";
-import { isSafeReadOnlyPiRetryCandidate } from "./retry-policy.js";
+import { isSafeReadOnlyPiRetryCandidate, isTransportCrashedExclusiveWriter } from "./retry-policy.js";
 import { resolveDagTaskSourcePath } from "../../task/dag-source-paths.js";
+import { composeDagPromptOverridePrompt, MAX_DAG_RERUN_PROMPT_OVERRIDE_CHARS, } from "../../shared/dag-prompt-override.js";
 const REVIEW_VERDICT_RECOVERY_NODE_ID = "review-verdict-recovery-pi";
 const SAFE_SHELL_GATE_KEYS = [
     "verdictGate",
@@ -122,32 +123,56 @@ function hasDynamicRuntime(task) {
         task.dynamicCondition ||
         task.dynamicLoopUntil);
 }
-function shellHasDisallowedConfig(shell) {
-    if ((shell.commands?.length ?? 0) > 0)
-        return true;
+/**
+ * Narrow admission for the standard DAG's generated final verification node.
+ * `verifyEvidence` alone is metadata, not proof that an arbitrary shell is
+ * read-only, so custom shell ids and non-canonical shapes stay blocked.
+ */
+function isCanonicalGeneratedVerifyShell(task) {
+    if (task.executor !== "shell")
+        return false;
+    const shell = task.shell;
+    if (!shell)
+        return false;
+    const evidence = shell.verifyEvidence;
+    if (task.id !== "verify-shell")
+        return false;
+    if (task.role !== "verifier")
+        return false;
+    if (task.writePolicy !== "read-only")
+        return false;
+    if (!evidence)
+        return false;
+    if (evidence.phase !== "final")
+        return false;
+    if (evidence.quota !== "full")
+        return false;
+    if (evidence.commandSource !== "adapter")
+        return false;
+    if (evidence.finalFullRequired !== true)
+        return false;
+    if ((shell.commands?.length ?? 0) === 0)
+        return false;
+    if (evidence.commandCount !== shell.commands.length)
+        return false;
+    // Any side-effect-capable config disqualifies the node.
     if (shell.preset)
-        return true;
+        return false;
     if (shell.projectGovernanceGate)
-        return true;
+        return false;
     if (shell.frontendPrewriteGate)
-        return true;
+        return false;
     if (shell.frontendVerificationBundle)
-        return true;
+        return false;
     if (shell.frontendReviewContext)
-        return true;
+        return false;
     if (shell.backendTestPipeline)
-        return true;
-    if (shell.verifyEvidence)
-        return true;
-    if (shell.nonZeroExitPolicy)
-        return true;
+        return false;
+    if (shell.nonZeroExitPolicy === "record")
+        return false;
     if (shell.envAllowlist?.length)
-        return true;
-    if (shell.timeoutMs !== undefined)
-        return true;
-    if (shell.cwd)
-        return true;
-    return false;
+        return false;
+    return true;
 }
 function isSafeGateOnlyShell(task) {
     if (task.executor !== "shell")
@@ -155,9 +180,32 @@ function isSafeGateOnlyShell(task) {
     const shell = task.shell;
     if (!shell)
         return false;
-    if (shellHasDisallowedConfig(shell))
+    if (!SAFE_SHELL_GATE_KEYS.some((key) => shell[key] !== undefined)) {
+        return false;
+    }
+    // No side-effect-capable config may ride along on a gate-only shell.
+    // Deterministic/read-only riders are admitted: projectGovernanceGate (repo
+    // governance context path), cwd, and timeoutMs never execute commands, so
+    // the governance-standard gate stays rerun-eligible.
+    if ((shell.commands?.length ?? 0) > 0)
         return false;
-    return SAFE_SHELL_GATE_KEYS.some((key) => shell[key] !== undefined);
+    if (shell.preset)
+        return false;
+    if (shell.frontendPrewriteGate)
+        return false;
+    if (shell.frontendVerificationBundle)
+        return false;
+    if (shell.frontendReviewContext)
+        return false;
+    if (shell.backendTestPipeline)
+        return false;
+    if (shell.verifyEvidence)
+        return false;
+    if (shell.nonZeroExitPolicy)
+        return false;
+    if (shell.envAllowlist?.length)
+        return false;
+    return true;
 }
 function isStaticTask(task) {
     return task.executor === "static";
@@ -259,7 +307,10 @@ export function computeResetClosure(spec, effectiveFromNodeId) {
         ...collectReachableDescendants(spec, effectiveFromNodeId),
     ].sort();
 }
-export function assessResetClosureSafety(spec, resetNodeIds) {
+function isNeverStartedNodeStatus(status) {
+    return status === undefined || status === "SKIPPED" || status === "PENDING";
+}
+export function assessResetClosureSafety(spec, resetNodeIds, options = {}) {
     const tasks = taskById(spec);
     const blockingNodes = [];
     const reasonCodes = [];
@@ -267,7 +318,17 @@ export function assessResetClosureSafety(spec, resetNodeIds) {
         const task = tasks.get(nodeId);
         if (!task)
             continue;
+        if (options.parentNodes !== undefined &&
+            isNeverStartedNodeStatus(options.parentNodes[nodeId]?.status)) {
+            continue;
+        }
         if (isWriterTask(task, spec)) {
+            if (nodeId === options.allowedTransportWriterNodeId)
+                continue;
+            if (nodeId === options.allowedExclusiveShellFromNodeId &&
+                task.executor === "shell") {
+                continue;
+            }
             blockingNodes.push({
                 nodeId,
                 reasonCode: "restart-subgraph-contains-writer",
@@ -305,7 +366,8 @@ export function assessResetClosureSafety(spec, resetNodeIds) {
             continue;
         }
         if (task.executor === "shell") {
-            if (!isSafeGateOnlyShell(task)) {
+            if (!isSafeGateOnlyShell(task) &&
+                !isCanonicalGeneratedVerifyShell(task)) {
                 blockingNodes.push({
                     nodeId,
                     reasonCode: "restart-subgraph-contains-unsafe-shell",
@@ -320,6 +382,100 @@ export function assessResetClosureSafety(spec, resetNodeIds) {
         reasonCodes: [...new Set(reasonCodes)],
     };
 }
+/**
+ * Experimental prompt-override admission (fail-closed):
+ * - requires the internal switch (see shared/dag-prompt-override.ts);
+ * - the target must be a failed (ERROR) node inside the reset closure, so an
+ *   override can only adjust how an already-failed node retries — never a
+ *   finished, skipped, or not-yet-started node;
+ * - only `subtask_prompt` semantics change: "append" keeps the frozen base
+ *   and adds a marked addendum block, "replace" swaps the whole prompt;
+ *   base/final sha256 are recorded for provenance and bound into planHash.
+ */
+function assessPromptOverrides(input) {
+    const blockingNodes = [];
+    const reasonCodes = [];
+    const tasks = taskById(input.spec);
+    const resetSet = new Set(input.resetNodeIds);
+    const seen = new Set();
+    const entries = [];
+    if (!input.enabled) {
+        reasonCodes.push("prompt-override-disabled");
+    }
+    for (const override of input.overrides) {
+        const nodeId = override.nodeId?.trim() ?? "";
+        if (seen.has(nodeId)) {
+            blockingNodes.push({
+                nodeId,
+                reasonCode: "prompt-override-duplicate-node",
+            });
+            reasonCodes.push("prompt-override-duplicate-node");
+            continue;
+        }
+        seen.add(nodeId);
+        const task = tasks.get(nodeId);
+        if (!task) {
+            blockingNodes.push({
+                nodeId,
+                reasonCode: "prompt-override-node-missing",
+            });
+            reasonCodes.push("prompt-override-node-missing");
+            continue;
+        }
+        if (!resetSet.has(nodeId)) {
+            blockingNodes.push({
+                nodeId,
+                reasonCode: "prompt-override-outside-reset-closure",
+            });
+            reasonCodes.push("prompt-override-outside-reset-closure");
+            continue;
+        }
+        if (input.state.nodes[nodeId]?.status !== "ERROR") {
+            blockingNodes.push({
+                nodeId,
+                reasonCode: "prompt-override-node-not-failed",
+            });
+            reasonCodes.push("prompt-override-node-not-failed");
+            continue;
+        }
+        const mode = override.mode === "append" ? "append" : "replace";
+        const prompt = override.prompt ?? "";
+        if (!prompt.trim() ||
+            prompt.length > MAX_DAG_RERUN_PROMPT_OVERRIDE_CHARS) {
+            blockingNodes.push({
+                nodeId,
+                reasonCode: "prompt-override-invalid-prompt",
+            });
+            reasonCodes.push("prompt-override-invalid-prompt");
+            continue;
+        }
+        const basePromptSha256 = createHash("sha256")
+            .update(task.subtask_prompt, "utf8")
+            .digest("hex");
+        const finalPrompt = composeDagPromptOverridePrompt({
+            basePrompt: task.subtask_prompt,
+            text: prompt,
+            mode,
+        });
+        const promptSha256 = createHash("sha256")
+            .update(finalPrompt, "utf8")
+            .digest("hex");
+        if (promptSha256 === basePromptSha256) {
+            blockingNodes.push({
+                nodeId,
+                reasonCode: "prompt-override-unchanged",
+            });
+            reasonCodes.push("prompt-override-unchanged");
+            continue;
+        }
+        entries.push({ nodeId, mode, basePromptSha256, promptSha256 });
+    }
+    return {
+        entries: entries.length > 0 ? entries : undefined,
+        blockingNodes,
+        reasonCodes: [...new Set(reasonCodes)],
+    };
+}
 export function computePlanHash(planWithoutHash) {
     const canonical = JSON.stringify(sortKeysDeep(planWithoutHash));
     return createHash("sha256").update(canonical, "utf8").digest("hex");
@@ -448,6 +604,20 @@ export async function evaluateDagRerunPlan(input) {
         : [];
     const resetSet = new Set(resetNodeIds);
     const importedNodeIds = allNodeIds.filter((nodeId) => !resetSet.has(nodeId));
+    const tasksByIdForPlan = taskById(input.parentSpec);
+    const effectiveTask = effectiveFromNodeId
+        ? tasksByIdForPlan.get(effectiveFromNodeId)
+        : undefined;
+    const effectiveRecord = effectiveFromNodeId
+        ? input.parentState.nodes[effectiveFromNodeId]
+        : undefined;
+    const transportWriterRestart = Boolean(effectiveFromNodeId &&
+        effectiveRecord?.status === "ERROR" &&
+        isTransportCrashedExclusiveWriter(effectiveTask, effectiveRecord.failureCategory));
+    const convergenceWriterRestart = Boolean(transportWriterRestart &&
+        input.parentSpec.convergence?.enabled === true &&
+        input.parentState.convergence?.enabled === true &&
+        !input.parentState.convergence.terminalReason);
     const controllerIdentityMatched = input.currentControllerFingerprint === undefined ||
         input.parentControllerFingerprint === undefined ||
         input.currentControllerFingerprint === input.parentControllerFingerprint;
@@ -482,11 +652,11 @@ export async function evaluateDagRerunPlan(input) {
         reasonCodes.push("parent-lifecycle-ineligible");
         blockedReasons.push("parent-lifecycle-ineligible");
     }
-    if (input.parentSpec.convergence?.enabled) {
+    if (input.parentSpec.convergence?.enabled && !convergenceWriterRestart) {
         reasonCodes.push("convergence-rerun-unsupported");
         blockedReasons.push("convergence-rerun-unsupported");
     }
-    if (input.parentState.convergence?.enabled) {
+    if (input.parentState.convergence?.enabled && !convergenceWriterRestart) {
         reasonCodes.push("convergence-rerun-unsupported");
         blockedReasons.push("convergence-rerun-unsupported");
     }
@@ -530,7 +700,17 @@ export async function evaluateDagRerunPlan(input) {
             blockedReasons.push("ambiguous-skipped-rewrite");
         }
     }
-    const closureSafety = assessResetClosureSafety(input.parentSpec, resetNodeIds);
+    const closureSafety = assessResetClosureSafety(input.parentSpec, resetNodeIds, {
+        ...(transportWriterRestart && effectiveFromNodeId
+            ? { allowedTransportWriterNodeId: effectiveFromNodeId }
+            : {}),
+        parentNodes: input.parentState.nodes,
+        ...(effectiveFromNodeId &&
+            effectiveTask?.executor === "shell" &&
+            effectiveRecord?.status === "ERROR"
+            ? { allowedExclusiveShellFromNodeId: effectiveFromNodeId }
+            : {}),
+    });
     blockingNodes.push(...closureSafety.blockingNodes);
     for (const code of closureSafety.reasonCodes) {
         reasonCodes.push(code);
@@ -563,6 +743,22 @@ export async function evaluateDagRerunPlan(input) {
             blockingNodes.push({ nodeId, reasonCode: "parent-facts-invalid" });
         }
     }
+    let promptOverrideEntries;
+    if (input.promptOverrides !== undefined && input.promptOverrides.length > 0) {
+        const overrideAssessment = assessPromptOverrides({
+            spec: input.parentSpec,
+            state: input.parentState,
+            resetNodeIds,
+            overrides: input.promptOverrides,
+            enabled: input.promptOverrideEnabled === true,
+        });
+        blockingNodes.push(...overrideAssessment.blockingNodes);
+        for (const code of overrideAssessment.reasonCodes) {
+            reasonCodes.push(code);
+            blockedReasons.push(code);
+        }
+        promptOverrideEntries = overrideAssessment.entries;
+    }
     const uniqueReasonCodes = [...new Set(reasonCodes)];
     const uniqueBlockedReasons = [...new Set(blockedReasons)];
     const eligible = uniqueBlockedReasons.length === 0 &&
@@ -606,6 +802,7 @@ export async function evaluateDagRerunPlan(input) {
             parentLifecycle: input.parentLifecycle,
             workerManaged: input.workerManaged,
         }),
+        ...(promptOverrideEntries ? { promptOverrides: promptOverrideEntries } : {}),
     };
     return {
         ...planWithoutHash,

package/dist/workflows/dag/rerun-run.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { access, copyFile, mkdir, readdir, readFile } from "node:fs/promises";
 import path from "node:path";
 import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
+import { composeDagPromptOverridePrompt, isDagRerunPromptOverrideEnabled, } from "../../shared/dag-prompt-override.js";
 import { resolveRunningControllerIdentity } from "../../shared/package-metadata.js";
 import { readControllerIdentityArtifact, captureControllerIdentity } from "./controller-identity.js";
 import { DAG_RUNS_DIR, getDagRunDir, isDagNonExecutionLifecycle, locateDagRun, readDagRunSpec, readDagRunState, } from "./lifecycle.js";
@@ -190,6 +191,8 @@ export async function planDagRerun(input) {
             parentSpec: nonCompletedSpec,
             parentState: nonCompletedState,
             parentLifecycle,
+            promptOverrides: input.promptOverrides,
+            promptOverrideEnabled: isDagRerunPromptOverrideEnabled(),
             workerManaged: nonCompletedWorkerHints.workerManaged,
             workerAssociation: nonCompletedWorkerHints.workerManaged
                 ? {
@@ -229,6 +232,8 @@ export async function planDagRerun(input) {
         parentTerminalWorkspace,
         currentWorkspace,
         skillSnapshotOk,
+        promptOverrides: input.promptOverrides,
+        promptOverrideEnabled: isDagRerunPromptOverrideEnabled(),
         workerManaged: workerHints.workerManaged,
         workerAssociation: workerHints.workerManaged
             ? {
@@ -384,15 +389,57 @@ function buildPendingNodeRecord(task) {
         ...(task.outputMode ? { outputMode: task.outputMode } : {}),
     };
 }
+/**
+ * Stage the continuation spec with operator prompt overrides applied. The
+ * parent spec stays frozen; every override must match the plan entry (sha256
+ * of the composed final prompt and of the parent base prompt) so the
+ * two-phase planHash remains the single source of truth for what changed.
+ * "append" entries keep the frozen base and append the operator addendum in a
+ * marked block; "replace" entries swap the whole prompt.
+ */
+function applyPromptOverridesToSpec(input) {
+    const planned = new Map((input.plan.promptOverrides ?? []).map((entry) => [entry.nodeId, entry]));
+    const spec = structuredClone(input.spec);
+    for (const override of input.overrides) {
+        const entry = planned.get(override.nodeId);
+        if (!entry) {
+            throw new Error(`prompt override is not present in the rerun plan: ${override.nodeId}`);
+        }
+        const task = spec.tasks.find((candidate) => candidate.id === override.nodeId);
+        if (!task) {
+            throw new Error(`prompt override node missing from spec: ${override.nodeId}`);
+        }
+        if (sha256Hex(task.subtask_prompt) !== entry.basePromptSha256) {
+            throw new Error(`prompt override base prompt drifted from plan: ${override.nodeId}`);
+        }
+        const finalPrompt = composeDagPromptOverridePrompt({
+            basePrompt: task.subtask_prompt,
+            text: override.prompt,
+            mode: override.mode === "append" ? "append" : "replace",
+        });
+        if (sha256Hex(finalPrompt) !== entry.promptSha256) {
+            throw new Error(`prompt override text does not match the planned sha256: ${override.nodeId}`);
+        }
+        task.subtask_prompt = finalPrompt;
+    }
+    return spec;
+}
 async function stageContinuationRun(input) {
-    const { ranks } = topoSortToRanks(input.parentSpec);
-    const runId = await buildDagRunId(input.parentSpec, { cwd: input.cwd });
+    const specForRun = input.promptOverrides !== undefined && input.promptOverrides.length > 0
+        ? applyPromptOverridesToSpec({
+            spec: input.parentSpec,
+            plan: input.plan,
+            overrides: input.promptOverrides,
+        })
+        : input.parentSpec;
+    const { ranks } = topoSortToRanks(specForRun);
+    const runId = await buildDagRunId(specForRun, { cwd: input.cwd });
     const runDir = getDagRunDir(input.cwd, "active", runId);
     await prepareActiveRunDir(runDir);
-    await writeRunSpec(runDir, input.parentSpec);
+    await writeRunSpec(runDir, specForRun);
     const resetSet = new Set(input.plan.resetNodeIds);
     const importedSet = new Set(input.plan.importedNodeIds);
-    const tasksById = new Map(input.parentSpec.tasks.map((task) => [task.id, task]));
+    const tasksById = new Map(specForRun.tasks.map((task) => [task.id, task]));
     const importManifestNodes = [];
     const nodes = {};
     for (const nodeId of input.plan.importedNodeIds) {
@@ -433,6 +480,9 @@ async function stageContinuationRun(input) {
         reason: input.reason,
         requestId: input.requestId,
         planHash: input.plan.planHash,
+        ...(input.plan.promptOverrides
+            ? { promptOverrides: input.plan.promptOverrides }
+            : {}),
         createdAt,
     };
     const state = {
@@ -445,6 +495,9 @@ async function stageContinuationRun(input) {
         ranks,
         nodes,
         continuation,
+        ...(input.parentState.convergence
+            ? { convergence: structuredClone(input.parentState.convergence) }
+            : {}),
         ...(input.parentState.evaluation
             ? { evaluation: structuredClone(input.parentState.evaluation) }
             : {}),
@@ -479,7 +532,7 @@ async function stageContinuationRun(input) {
     await writeJsonAtomic(path.join(runDir, IMPORT_MANIFEST_REL_PATH), importManifest);
     await writeJsonAtomic(path.join(runDir, RERUN_PLAN_REL_PATH), input.plan);
     await writeRunState(runDir, state);
-    return { runId, runDir, state };
+    return { runId, runDir, state, spec: specForRun };
 }
 export async function executeDagRerun(input) {
     const existing = await readExistingOperatorRequest(input.cwd, input.requestId);
@@ -490,6 +543,7 @@ export async function executeDagRerun(input) {
         cwd: input.cwd,
         parentRunId: input.parentRunId,
         selectedNodeId: input.selectedNodeId,
+        promptOverrides: input.promptOverrides,
     });
     if (plan.planHash !== input.planHash) {
         return {
@@ -527,10 +581,11 @@ export async function executeDagRerun(input) {
         plan,
         reason: input.reason,
         requestId: input.requestId,
+        promptOverrides: input.promptOverrides,
     });
     const continuationOptions = {
         cwd: input.cwd,
-        spec: parentSpec,
+        spec: staged.spec,
         state: staged.state,
         runDir: staged.runDir,
         ...(input.maxConcurrent !== undefined

package/dist/workflows/dag/rerun-task.js

@@ -3,7 +3,8 @@ import path from "node:path";
 import { generateTaskDagUseCase } from "../../application/dag/generate-task-dag.js";
 import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
 import { DAG_RUNS_DIR, isTerminalDagRunStatus, locateDagRun, readDagRunSpec, readDagRunState, } from "./lifecycle.js";
-import { parseDagSpec } from "./types.js";
+import { deriveDagRerunFeedback } from "./rerun-feedback.js";
+import { parseDagSpec, } from "./types.js";
 export const RERUN_TASK_LINEAGE_REL_PATH = ".runtime/rerun-task-lineage.json";
 export function parseDagRerunTaskArgs(args) {
     if (args.length === 0) {
@@ -218,6 +219,7 @@ async function writeRerunTaskLineage(cwd, newRunId, input) {
         parentRunId: input.parentRunId,
         reason: input.reason,
         requestId: input.requestId,
+        feedback: input.feedback,
         createdAt: new Date().toISOString(),
     }, { repoRoot: cwd, allowCompletedFactsWrite: true });
 }
@@ -228,12 +230,30 @@ function blockedResult(input) {
         reason: input.reason,
         requestId: input.requestId,
         mode: "blocked",
+        feedback: input.feedback ?? {
+            inherited: false,
+            reason: "no-unresolved-verify-review-feedback",
+        },
         blockedReason: input.blockedReason,
         ...(input.note ? { note: input.note } : {}),
         ...(input.taskId ? { taskId: input.taskId } : {}),
         ...(input.conflictPaths ? { conflictPaths: input.conflictPaths } : {}),
     };
 }
+async function readGeneratedRerunFeedback(outputPath) {
+    const raw = JSON.parse(await readFile(outputPath, "utf8"));
+    return parseDagSpec(raw).rerunFeedback;
+}
+function summarizeFeedback(feedback, fallbackReason) {
+    return feedback
+        ? {
+            inherited: true,
+            sourceNodeId: feedback.sourceNodeId,
+            digest: feedback.digest,
+            bindingStatus: feedback.binding.status,
+        }
+        : { inherited: false, reason: fallbackReason };
+}
 function extractRunSummary(generateResult) {
     if (generateResult.mode === "generate+basic-validate")
         return undefined;
@@ -277,7 +297,26 @@ export async function rerunStandaloneTask(input) {
             note: eligibility.note,
         });
     }
+    let parentFeedback;
+    let missingFeedbackReason = "no-unresolved-verify-review-feedback";
+    try {
+        parentFeedback = await deriveDagRerunFeedback({
+            parentRunId: input.parentRunId,
+            taskId: taskResolution.taskId,
+            runDir: located.runDir,
+            spec,
+            state,
+        });
+    }
+    catch {
+        // Feedback is additive recovery context. A corrupt/missing historical
+        // artifact must be reported honestly but must not block an otherwise
+        // eligible full rerun.
+        missingFeedbackReason = "feedback-unavailable";
+    }
     const execute = input.execute ?? true;
+    let effectiveFeedback;
+    let expectedRerunFeedbackDigest;
     // AC-001 generated-output-conflict preflight: when a real execution is
     // requested, first generate the DAG draft (execute:false) so we can inspect
     // the regenerated spec's requireChangedFiles writer write sets against
@@ -296,15 +335,23 @@ export async function rerunStandaloneTask(input) {
             dryRun: false,
             profile: input.profile ?? "auto",
             profileExplicit: input.profileExplicit ?? false,
+            rerunFeedback: parentFeedback,
         });
         if (preflight.mode === "generate+basic-validate") {
             let conflictPaths = [];
             try {
                 const raw = await readFile(preflight.outputPath, "utf8");
                 const preflightSpec = parseDagSpec(JSON.parse(raw));
+                effectiveFeedback = preflightSpec.rerunFeedback;
+                expectedRerunFeedbackDigest = effectiveFeedback?.digest;
+                if (parentFeedback && !effectiveFeedback) {
+                    throw new Error("rerun feedback missing from generated preflight DAG");
+                }
                 conflictPaths = await assessGeneratedOutputConflict(preflightSpec, input.cwd);
             }
-            catch {
+            catch (error) {
+                if (parentFeedback)
+                    throw error;
                 // If the draft cannot be parsed, fall through to the real execution
                 // path: execution's own validation will surface the structural defect.
                 conflictPaths = [];
@@ -332,7 +379,17 @@ export async function rerunStandaloneTask(input) {
         dryRun: false,
         profile: input.profile ?? "auto",
         profileExplicit: input.profileExplicit ?? false,
+        rerunFeedback: parentFeedback,
+        expectedRerunFeedbackDigest,
     });
+    if (parentFeedback && !effectiveFeedback) {
+        effectiveFeedback = await readGeneratedRerunFeedback(generateResult.outputPath);
+    }
+    if (expectedRerunFeedbackDigest &&
+        effectiveFeedback?.digest !== expectedRerunFeedbackDigest) {
+        throw new Error(`rerun feedback drift after generation: expected ${expectedRerunFeedbackDigest}, got ${effectiveFeedback?.digest ?? "missing"}`);
+    }
+    const feedbackSummary = summarizeFeedback(effectiveFeedback, missingFeedbackReason);
     const newRunId = extractNewRunId(generateResult);
     const runSummary = extractRunSummary(generateResult);
     const completedSuccessfully = !execute ||
@@ -342,6 +399,7 @@ export async function rerunStandaloneTask(input) {
             parentRunId: input.parentRunId,
             reason: input.reason,
             requestId: input.requestId,
+            feedback: feedbackSummary,
         });
     }
     const result = {
@@ -350,6 +408,7 @@ export async function rerunStandaloneTask(input) {
         reason: input.reason,
         requestId: input.requestId,
         mode: "generate+validate+execute",
+        feedback: feedbackSummary,
         taskId: taskResolution.taskId,
         ...(newRunId ? { newRunId } : {}),
         ...(runSummary && !completedSuccessfully && "status" in runSummary