@tea-agent/loop-agent 0.39.0-next.29 → 0.39.0-next.30

package/dist/worker/observe/static/views/dag-inspector.js

@@ -11,7 +11,14 @@ import {
 } from "../constants.js";
 import { clearNode, el } from "../dom.js";
 import { attemptFailureLabel } from "../dag-history-labels.js";
-import { fetchJson, fetchSpecEvidenceFile, fetchDagNodeInput, fetchDagNodeProcess } from "../api.js";
+import {
+	fetchJson,
+	fetchSpecEvidenceFile,
+	fetchDagNodeInput,
+	fetchDagNodeProcess,
+	postOperatorAction,
+	fetchOperatorOperation,
+} from "../api.js";
 import { badge, formatMs, prettyJsonBlock } from "../format.js";
 import { renderMarkdown, renderInspectorDocument } from "../markdown-render.js";
 import {
@@ -978,8 +985,304 @@ async function renderDagNodeInput(content, dagRunId, node) {
 	finishInputRender();
 }
 
+/**
+ * Experimental prompt-override rerun tab. Only reachable when the server
+ * injected the mutation token (switch on). Every node shows its frozen
+ * subtask_prompt here; only FAILED (ERROR) nodes additionally get the editor +
+ * restart flow: preflight (dagRerunPlan) binds the edit into planHash, dagRerun
+ * executes it as a Console operation, and on success we jump to the new run.
+ */
+async function renderPromptRestart(content, dagRunId, node) {
+	const nodeId = node.nodeId;
+	clearNode(content);
+
+	const loading = el("p", "muted", "正在加载冻结提示词…");
+	loading.setAttribute("role", "status");
+	loading.setAttribute("aria-live", "polite");
+	content.appendChild(loading);
+	const input = await fetchDagNodeInput(dagRunId, nodeId);
+	if (
+		!content.isConnected ||
+		content.dataset.dagNodeId !== String(nodeId) ||
+		content.dataset.dagRunId !== String(dagRunId) ||
+		activeInspectorTab() !== "prompt-restart"
+	) {
+		return;
+	}
+	clearNode(content);
+
+	if (!input.ok || !input.body?.available) {
+		const error = el("p", "node-input-error", "无法读取该节点的冻结提示词。");
+		error.setAttribute("role", "alert");
+		content.appendChild(error);
+		return;
+	}
+	const basePrompt =
+		typeof input.body.prompt?.text === "string" ? input.body.prompt.text : "";
+	if (!basePrompt) {
+		const error = el("p", "node-input-error", "该节点没有冻结提示词。");
+		error.setAttribute("role", "alert");
+		content.appendChild(error);
+		return;
+	}
+
+	if (node.status !== "ERROR") {
+		// Non-failed nodes still show their frozen prompt — read-only.
+		const hint = el(
+			"p",
+			"muted",
+			`当前节点状态为 ${node.status ?? "unknown"}；仅失败（ERROR）节点支持编辑提示词并重启，以下为该节点冻结提示词（只读）。`,
+		);
+		hint.setAttribute("role", "status");
+		content.appendChild(hint);
+		const pre = document.createElement("pre");
+		pre.className = "prompt-restart-readonly";
+		pre.setAttribute("data-testid", "prompt-restart-readonly");
+		pre.textContent = basePrompt;
+		content.appendChild(pre);
+		return;
+	}
+
+	if (input.body.prompt?.truncated === true) {
+		const error = el(
+			"p",
+			"node-input-error",
+			"冻结提示词被截断，为避免误替换请改用 CLI（dag rerun --prompt-override）。",
+		);
+		error.setAttribute("role", "alert");
+		content.appendChild(error);
+		return;
+	}
+
+	const box = el("div", "prompt-restart-box");
+	box.appendChild(
+		el(
+			"p",
+			"muted",
+			"编辑该失败节点的提示词并从它重启：父 run spec 保持冻结，将创建带修改提示词的续跑 run（实验能力，仅 ERROR 节点）。",
+		),
+	);
+
+	const modeRow = el("div", "prompt-restart-mode");
+	modeRow.appendChild(el("span", "muted", "编辑模式"));
+	const modeSelect = document.createElement("select");
+	modeSelect.className = "prompt-restart-mode-select";
+	modeSelect.setAttribute("data-testid", "prompt-restart-mode");
+	const appendOption = document.createElement("option");
+	appendOption.value = "append";
+	appendOption.textContent =
+		"追加指令（推荐）：保留原提示词，在末尾追加 operator_addendum 块";
+	const replaceOption = document.createElement("option");
+	replaceOption.value = "replace";
+	replaceOption.textContent = "全文替换（高级）：替换整个提示词";
+	modeSelect.appendChild(appendOption);
+	modeSelect.appendChild(replaceOption);
+	modeSelect.value = "append";
+	modeRow.appendChild(modeSelect);
+	box.appendChild(modeRow);
+
+	const baseLabel = el("label", "prompt-restart-field");
+	baseLabel.appendChild(
+		el("span", "muted", `冻结提示词（只读底稿 · ${nodeId}）`),
+	);
+	const baseBlock = document.createElement("pre");
+	baseBlock.className = "prompt-restart-readonly";
+	baseBlock.setAttribute("data-testid", "prompt-restart-base");
+	baseBlock.textContent = basePrompt;
+	baseLabel.appendChild(baseBlock);
+	box.appendChild(baseLabel);
+
+	const addendumLabel = el("label", "prompt-restart-field");
+	addendumLabel.appendChild(
+		el(
+			"span",
+			"muted",
+			"追加指令（将包裹为 <operator_addendum> 块附加到原提示词末尾）",
+		),
+	);
+	const addendumArea = document.createElement("textarea");
+	addendumArea.className = "prompt-restart-textarea";
+	addendumArea.rows = 6;
+	addendumArea.placeholder = "例如：重点检查 X 边界；输出前先自检 Y 约束…";
+	addendumArea.setAttribute("data-testid", "prompt-restart-addendum");
+	addendumLabel.appendChild(addendumArea);
+	box.appendChild(addendumLabel);
+
+	const replaceLabel = el("label", "prompt-restart-field");
+	replaceLabel.appendChild(el("span", "muted", `完整提示词（${nodeId}）`));
+	const replaceArea = document.createElement("textarea");
+	replaceArea.className = "prompt-restart-textarea";
+	replaceArea.rows = 16;
+	replaceArea.value = basePrompt;
+	replaceArea.setAttribute("data-testid", "prompt-restart-textarea");
+	replaceLabel.appendChild(replaceArea);
+	box.appendChild(replaceLabel);
+
+	const applyModeVisibility = () => {
+		const append = modeSelect.value === "append";
+		baseLabel.style.display = append ? "" : "none";
+		addendumLabel.style.display = append ? "" : "none";
+		replaceLabel.style.display = append ? "none" : "";
+	};
+	modeSelect.addEventListener("change", applyModeVisibility);
+	applyModeVisibility();
+
+	const reasonLabel = el("label", "prompt-restart-field");
+	reasonLabel.appendChild(el("span", "muted", "重启原因（结构化说明）"));
+	const reasonArea = document.createElement("textarea");
+	reasonArea.className = "prompt-restart-textarea";
+	reasonArea.rows = 3;
+	reasonArea.value = `operator-prompt-override / run=${dagRunId} / node=${nodeId} / 手工编辑失败节点提示词后重启`;
+	reasonArea.setAttribute("data-testid", "prompt-restart-reason");
+	reasonLabel.appendChild(reasonArea);
+	box.appendChild(reasonLabel);
+
+	const row = el("div", "prompt-restart-actions");
+	const submit = document.createElement("button");
+	submit.type = "button";
+	submit.className = "prompt-restart-submit";
+	submit.textContent = "资格预检并重启";
+	submit.setAttribute("data-testid", "prompt-restart-submit");
+	row.appendChild(submit);
+	box.appendChild(row);
+
+	const status = el("p", "prompt-restart-status", "");
+	status.setAttribute("role", "status");
+	status.setAttribute("aria-live", "polite");
+	box.appendChild(status);
+
+	content.appendChild(box);
+
+	const setStatus = (text, isError = false) => {
+		status.textContent = text ?? "";
+		status.classList.toggle("prompt-restart-error", isError);
+	};
+
+	submit.addEventListener("click", () => {
+		void (async () => {
+			const mode = modeSelect.value === "replace" ? "replace" : "append";
+			const prompt =
+				mode === "append" ? addendumArea.value : replaceArea.value;
+			const reason = reasonArea.value.trim();
+			if (!prompt.trim()) {
+				setStatus(
+					mode === "append" ? "追加指令不能为空。" : "提示词不能为空。",
+					true,
+				);
+				return;
+			}
+			if (mode === "replace" && prompt === basePrompt) {
+				setStatus("提示词未修改；如需按原提示词重跑请使用恢复工作台。", true);
+				return;
+			}
+			if (!reason) {
+				setStatus("需要填写重启原因。", true);
+				return;
+			}
+			submit.disabled = true;
+			try {
+				setStatus("正在做重跑资格预检（dagRerunPlan）…");
+				const overrides = [{ nodeId, prompt, mode }];
+				const planRes = await postOperatorAction("dagRerunPlan", {
+					runId: dagRunId,
+					fromNode: nodeId,
+					promptOverrides: overrides,
+				});
+				const plan = planRes.body?.result ?? null;
+				if (!planRes.ok || plan?.eligible !== true || !plan?.planHash) {
+					setStatus(
+						planRes.body?.error?.message ??
+							plan?.blockedReasons?.join(", ") ??
+							"资格预检未通过。",
+						true,
+					);
+					return;
+				}
+
+				const est = plan.estimatedExecution;
+				const estText = est
+					? `（将执行 ${est.nodeCount ?? "?"} 个节点 / ${est.piCallCount ?? "?"} 次 Pi 调用）`
+					: "";
+				setStatus(`预检通过${estText}，正在提交续跑（dagRerun）…`);
+				const clientRequestId = `inspect-prompt-restart-${Date.now()}-${Math.random()
+					.toString(36)
+					.slice(2, 10)}`;
+				const runRes = await postOperatorAction(
+					"dagRerun",
+					{
+						runId: dagRunId,
+						fromNode: nodeId,
+						planHash: plan.planHash,
+						reason,
+						promptOverrides: overrides,
+					},
+					clientRequestId,
+				);
+				const operationId = runRes.body?.operationId;
+				if (!runRes.ok || !operationId) {
+					setStatus(runRes.body?.error?.message ?? "提交续跑失败。", true);
+					return;
+				}
+
+				const op = await pollOperationToTerminal(operationId, (text) =>
+					setStatus(text),
+				);
+				if (op?.state === "succeeded") {
+					const newRunId =
+						op.dagRunId ?? op.result?.newRunId ?? op.runSummary?.runId ?? null;
+					if (newRunId) {
+						setStatus(`重启完成，新 run：${newRunId}`);
+						const open = document.createElement("button");
+						open.type = "button";
+						open.className = "prompt-restart-submit";
+						open.textContent = "打开新 run";
+						open.addEventListener("click", () => {
+							window.location.hash = `#/dag/${encodeURIComponent(String(newRunId))}`;
+						});
+						row.appendChild(open);
+					} else {
+						setStatus("重启完成（未能解析新 run id，请在 DAG 历史中查看）。");
+					}
+				} else if (op) {
+					setStatus(
+						`续跑操作终态：${op.state}${op.errorMessage ? ` — ${op.errorMessage}` : ""}`,
+						true,
+					);
+				} else {
+					setStatus("等待超时：操作仍在运行，可在操作台查看进度。", true);
+				}
+			} catch (err) {
+				setStatus(err instanceof Error ? err.message : String(err), true);
+			} finally {
+				submit.disabled = false;
+			}
+		})();
+	});
+}
+
+/** Poll a Console operation until a terminal state; null on poll budget end. */
+async function pollOperationToTerminal(operationId, onProgress) {
+	const terminal = new Set([
+		"succeeded",
+		"failed",
+		"timed-out",
+		"needs-reconcile",
+	]);
+	for (let attempt = 0; attempt < 1200; attempt += 1) {
+		const res = await fetchOperatorOperation(operationId);
+		const op = res.body?.operation ?? res.body;
+		const state = op?.state ?? "";
+		if (res.ok && terminal.has(state)) {
+			return op;
+		}
+		onProgress(`续跑执行中…（${state || "queued"}）`);
+		await new Promise((resolve) => setTimeout(resolve, 3000));
+	}
+	return null;
+}
+
 function activeInspectorTab() {
-	return ["input", "timeline", "spec-evidence"].includes(
+	return ["input", "timeline", "spec-evidence", "prompt-restart"].includes(
 		uiState.dagInspectorTab,
 	)
 		? uiState.dagInspectorTab
@@ -1734,6 +2037,8 @@ function fillDagInspectorContent(content, dagRunId, node) {
 	);
 	if (activeTab === "spec-evidence") {
 		void renderSpecEvidence(content, dagRunId, node.nodeId);
+	} else if (activeTab === "prompt-restart") {
+		void renderPromptRestart(content, dagRunId, node);
 	} else if (activeTab === "timeline") {
 		const attemptBuilt = buildAttemptBar(dagRunId, node);
 		if (attemptBuilt?.bar) content.appendChild(attemptBuilt.bar);
@@ -1801,6 +2106,14 @@ function buildDagInspectorHeader(dagRunId, node) {
 		["timeline", "执行过程", "ri-route-line"],
 		["spec-evidence", "规范证据", "ri-book-open-line"],
 	];
+	// Experimental prompt-override rerun: the server injects the SCOPED
+	// inspect mutation token into /inspect HTML only while
+	// HARNESS_DAG_RERUN_PROMPT_OVERRIDE is enabled (and it only authorizes
+	// dagRerunPlan/dagRerun). No token → no tab → the inspector stays
+	// strictly read-only.
+	if (globalThis.__INSPECT_MUTATION_TOKEN__) {
+		tabDefs.push(["prompt-restart", "提示词重启", "ri-restart-line"]);
+	}
 	const tabs = el("div", "dag-inspector-tabs");
 	tabs.setAttribute("role", "tablist");
 	tabs.setAttribute("aria-label", "节点检查器面板");

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

@@ -3,6 +3,7 @@ import { readFile } from "node:fs/promises";
 import { assertTaskContractBindingFresh } from "./task-contract-binding.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",
@@ -381,6 +382,100 @@ export function assessResetClosureSafety(spec, resetNodeIds, options = {}) {
         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");
@@ -648,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 &&
@@ -691,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 = {
@@ -482,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);
@@ -493,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 {
@@ -530,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.39.0-next.29",
+  "version": "0.39.0-next.30",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",

package/dist/worker/console/static/assets/channel-DWcZjWB3.js

@@ -1 +0,0 @@
-import{ag as o,ah as n}from"./mermaid.core-Dmy4lSGv.js";const t=(a,r)=>o.lang.round(n.parse(a)[r]);export{t as c};

package/dist/worker/console/static/assets/classDiagram-JCYQIIEL-IjoI3dqU.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-GF5L2VYU-DBa14MSI.js";import{_ as i}from"./mermaid.core-Dmy4lSGv.js";import"./chunk-5VM5RSS4-DdKW7-fL.js";import"./chunk-XXDRQBXY-B1T2yAIe.js";import"./chunk-KBJHAD2P-lgPogpcX.js";import"./chunk-2GRJ4B5K-BxmiogQE.js";import"./index-CqWlWE4l.js";var n={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{n as diagram};

package/dist/worker/console/static/assets/classDiagram-v2-OCEON4UE-IjoI3dqU.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-GF5L2VYU-DBa14MSI.js";import{_ as i}from"./mermaid.core-Dmy4lSGv.js";import"./chunk-5VM5RSS4-DdKW7-fL.js";import"./chunk-XXDRQBXY-B1T2yAIe.js";import"./chunk-KBJHAD2P-lgPogpcX.js";import"./chunk-2GRJ4B5K-BxmiogQE.js";import"./index-CqWlWE4l.js";var n={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{n as diagram};

package/dist/worker/console/static/assets/stateDiagram-v2-UEYNNEHI-C6MII0D1.js

@@ -1 +0,0 @@
-import{s as r,b as e,a,S as s}from"./chunk-5RXB4S5H-DTrT1Vze.js";import{_ as i}from"./mermaid.core-Dmy4lSGv.js";import"./chunk-XXDRQBXY-B1T2yAIe.js";import"./chunk-KBJHAD2P-lgPogpcX.js";import"./chunk-2GRJ4B5K-BxmiogQE.js";import"./index-CqWlWE4l.js";var u={parser:a,get db(){return new s(2)},renderer:e,styles:r,init:i(t=>{t.state||(t.state={}),t.state.arrowMarkerAbsolute=t.arrowMarkerAbsolute},"init")};export{u as diagram};

package/dist/worker/console/static/assets/swimlanesDiagram-ULZ7WXOC-D_tk0V8D.js

@@ -1,8 +0,0 @@
-import{c as r,s as e}from"./flowDiagram-UKHOOZJN-35krh9WG.js";import{_ as a}from"./mermaid.core-Dmy4lSGv.js";import"./chunk-5VM5RSS4-DdKW7-fL.js";import"./chunk-XXDRQBXY-B1T2yAIe.js";import"./chunk-KBJHAD2P-lgPogpcX.js";import"./chunk-2GRJ4B5K-BxmiogQE.js";import"./channel-DWcZjWB3.js";import"./index-CqWlWE4l.js";var o=a(t=>`${e(t)}
-  .swimlane.cluster rect {
-    stroke: ${t.clusterBorder} !important;
-  }
-  [data-look="neo"].cluster rect {
-    filter: none;
-  }
-`,"getStyles"),s=o,n=r({defaultLayout:"swimlane",styles:s});export{n as diagram};