@tea-agent/loop-agent 0.39.2 → 0.40.0-beta.1

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

@@ -364,7 +364,7 @@ export async function renderDagDetail(dagRunId, initial = true) {
 			"page-action-btn",
 			"在操作台中止此运行 →",
 		);
-		interruptLink.href = `/#/recovery?dagRunId=${encodeURIComponent(dag.dagRunId)}&intent=interrupt`;
+		interruptLink.href = `/#/operate/recovery?dagRunId=${encodeURIComponent(dag.dagRunId)}&intent=interrupt`;
 		interruptLink.setAttribute("data-testid", "inspect-dag-interrupt-link");
 		interruptLink.title = "只跳转到操作台 Recovery，不会在观测页执行中止";
 		primaryEntries.push(["协作中止", interruptLink]);
@@ -482,6 +482,7 @@ export function startDagPolling(dagRunId, initial = true) {
 		const active = await renderDagDetail(dagRunId, isInitial);
 		if (generation !== uiState.pollingGeneration || !active) return;
 		const delay = detailPollDelay("running", isPageVisible());
+		if (delay == null) return;
 		uiState.dagPollTimer = setTimeout(() => {
 			uiState.dagPollTimer = null;
 			void poll(false);

package/dist/worker/observe/static/views/dashboard.js

@@ -84,7 +84,7 @@ let dashboardLoadingNode = null;
 
 /**
  * 「昨夜班次」条带：夜间结果在观测侧的唯一一级呈现（替代旧「夜间任务」tab）。
- * 管理动作（晨审处置）始终落在操作侧 /#/night，保持 Inspect 只读不变式。
+ * 管理动作（晨审处置）始终落在操作侧 /#/operate/night，保持 Inspect 只读不变式。
  */
 async function renderNightStrip() {
 	const strip = document.getElementById("dashboard-night");
@@ -118,14 +118,14 @@ async function renderNightStrip() {
 
 	const actions = el("div", "night-strip-actions");
 	const detail = el("a", "page-action-btn", "夜间详情");
-	detail.href = "#/night";
+	detail.href = "/#/inspect/night";
 	detail.addEventListener("click", (e) => {
 		e.preventDefault();
 		navigate("/night");
 	});
 	actions.appendChild(detail);
 	const manage = el("a", "page-action-btn night-strip-manage", "晨审处置 →");
-	manage.href = "/#/night";
+	manage.href = "/#/operate/night";
 	manage.title = "夜间计划的管理与晨审处置在操作台完成（Inspect 保持只读）";
 	actions.appendChild(manage);
 	strip.appendChild(actions);
@@ -738,10 +738,12 @@ export function startDashboardPolling(scrollTo) {
 	const poll = async (initialScrollTo) => {
 		await renderDashboard(initialScrollTo);
 		if (generation !== uiState.pollingGeneration) return;
+		const delay = dashboardPollDelay();
+		if (delay == null) return;
 		uiState.dashboardTimer = setTimeout(() => {
 			uiState.dashboardTimer = null;
 			void poll();
-		}, dashboardPollDelay());
+		}, delay);
 	};
 	void poll(scrollTo);
 }

package/dist/worker/observe/static/views/night.js

@@ -46,8 +46,8 @@ export async function renderNightJobs(scheduleId) {
 	showView("night");
 	bindNightToolbar();
 	const crumbs = [
-		{ label: UI_TEXT.dashboard, href: "#/" },
-		{ label: UI_TEXT.nightJobs, href: "#/night" },
+		{ label: UI_TEXT.dashboard, href: "/#/inspect" },
+		{ label: UI_TEXT.nightJobs, href: "/#/inspect/night" },
 	];
 	if (scheduleId) crumbs.push({ label: scheduleId });
 	setBreadcrumb(crumbs);

package/dist/worker/observe/static/views/pool.js

@@ -93,6 +93,7 @@ function startPoolAutoPolling() {
 		if (generation !== uiState.pollingGeneration) return;
 		if (!poolAutoRefreshEnabled()) return;
 		const delay = isPageVisible() ? POOL_POLL_MS : dashboardPollDelay();
+		if (delay == null) return;
 		uiState.poolTimer = setTimeout(() => {
 			uiState.poolTimer = null;
 			void poll();

package/dist/worker/observe/static/views/run.js

@@ -50,6 +50,7 @@ import {
 } from "../relations.js";
 import { copyText, renderRecommendedCommand } from "../copy.js";
 import {
+	fetchWithWorkspaceScope,
 	isPageVisible,
 	detailPollDelay,
 	dashboardPollDelay,
@@ -126,7 +127,7 @@ export function renderInlineArtifactList(container, artifacts) {
 		list.appendChild(li);
 		void (async () => {
 			try {
-				const res = await fetch(artifactUrl(artifactPath));
+				const res = await fetchWithWorkspaceScope(artifactUrl(artifactPath));
 				const text = await res.text();
 				if (!res.ok) {
 					let message = text;
@@ -444,6 +445,7 @@ export function startRunPolling(workerRunId, initial = true) {
 		const active = await renderRun(workerRunId, isInitial);
 		if (generation !== uiState.pollingGeneration || !active) return;
 		const delay = detailPollDelay("running", isPageVisible());
+		if (delay == null) return;
 		uiState.runPollTimer = setTimeout(() => {
 			uiState.runPollTimer = null;
 			void poll(false);

package/dist/worker/observe/static/views/session-timeline.js

@@ -480,6 +480,35 @@ export function buildRichTimelineItems(events, options = {}) {
 	return items;
 }
 
+const EXECUTION_RECORD_FILTERS = Object.freeze([
+	["all", "全部"],
+	["model", "模型消息"],
+	["tools", "工具与进程"],
+]);
+
+function normalizeExecutionRecordFilter(value) {
+	return value === "model" || value === "tools" ? value : "all";
+}
+
+export function filterExecutionRecordItems(items, filter) {
+	const normalized = normalizeExecutionRecordFilter(filter);
+	if (normalized === "all") return items;
+	return items.filter((item) => {
+		const protocolEvents = Array.isArray(item.protocolEvents)
+			? item.protocolEvents
+			: [item.event];
+		const toolProtocol =
+			item.kind === "protocol" &&
+			protocolEvents.some((event) => {
+				const role = event?.message?.role ?? event?.role;
+				return role === "tool" || role === "toolResult";
+			});
+		const modelFact =
+			item.kind === "turn" || (item.kind === "protocol" && !toolProtocol);
+		return normalized === "model" ? modelFact : !modelFact;
+	});
+}
+
 function ensureOpenDetailsSet() {
 	if (!(uiState.sessionTimelineOpenDetails instanceof Set)) {
 		uiState.sessionTimelineOpenDetails = new Set();
@@ -723,7 +752,26 @@ export function renderSessionTimeline(content, nodeId, options = {}) {
 	}
 
 	const showProtocol = Boolean(uiState.sessionTimelineShowProtocol);
+	const activeFilter = normalizeExecutionRecordFilter(
+		uiState.executionRecordFilter,
+	);
 	const toolbar = el("div", "process-timeline-toolbar");
+	const filterGroup = el("div", "process-timeline-filter-group");
+	filterGroup.setAttribute("role", "group");
+	filterGroup.setAttribute("aria-label", "筛选执行记录");
+	for (const [filter, label] of EXECUTION_RECORD_FILTERS) {
+		const button = document.createElement("button");
+		button.type = "button";
+		button.className = "process-timeline-toggle process-timeline-filter";
+		button.setAttribute("aria-pressed", String(activeFilter === filter));
+		button.textContent = label;
+		button.addEventListener("click", () => {
+			uiState.executionRecordFilter = filter;
+			rerenderSessionTimeline(content, nodeId, options);
+		});
+		filterGroup.appendChild(button);
+	}
+	toolbar.appendChild(filterGroup);
 	const protocolToggle = document.createElement("button");
 	protocolToggle.type = "button";
 	protocolToggle.className = "process-timeline-toggle";
@@ -733,20 +781,15 @@ export function renderSessionTimeline(content, nodeId, options = {}) {
 		: "展开原始协议事件";
 	protocolToggle.addEventListener("click", () => {
 		uiState.sessionTimelineShowProtocol = !showProtocol;
-		const parent = content;
-		const scrollTop = parent.scrollTop;
-		const scrollLeft = parent.scrollLeft;
-		while (parent.firstChild) parent.removeChild(parent.firstChild);
-		renderSessionTimeline(parent, nodeId, options);
-		parent.scrollTop = scrollTop;
-		parent.scrollLeft = scrollLeft;
+		rerenderSessionTimeline(content, nodeId, options);
 	});
 	toolbar.appendChild(protocolToggle);
 	content.appendChild(toolbar);
 
-	const timelineItems = buildRichTimelineItems(visible.events, {
-		showProtocol,
-	});
+	const timelineItems = filterExecutionRecordItems(
+		buildRichTimelineItems(visible.events, { showProtocol }),
+		activeFilter,
+	);
 	const hasEventTimes = visible.events.some((event) =>
 		Boolean(sessionEventTimestamp(event)),
 	);
@@ -760,6 +803,13 @@ export function renderSessionTimeline(content, nodeId, options = {}) {
 		);
 	}
 
+	if (timelineItems.length === 0) {
+		content.appendChild(
+			el("p", "empty", "当前筛选下没有可显示的执行记录。"),
+		);
+		return;
+	}
+
 	const ul = el("ul", "process-timeline process-timeline-rich");
 	for (let index = 0; index < timelineItems.length; index += 1) {
 		const item = timelineItems[index];
@@ -838,3 +888,18 @@ export function renderSessionTimeline(content, nodeId, options = {}) {
 		content.scrollTop = timelineState.scrollTop;
 	}
 }
+
+function rerenderSessionTimeline(content, nodeId, options) {
+	const scrollTop = content.scrollTop;
+	const scrollLeft = content.scrollLeft;
+	const preserved = [...content.children].filter((child) =>
+		String(child.className ?? "")
+			.split(/\s+/)
+			.includes("dag-inspector-attempt-bar"),
+	);
+	while (content.firstChild) content.removeChild(content.firstChild);
+	for (const child of preserved) content.appendChild(child);
+	renderSessionTimeline(content, nodeId, options);
+	content.scrollTop = scrollTop;
+	content.scrollLeft = scrollLeft;
+}

package/dist/worker/observe/static/views/task.js

@@ -86,7 +86,7 @@ export async function renderTaskDetail(featureId, taskId) {
 	showView("task");
 	setBreadcrumb([
 		{ label: UI_TEXT.dashboard, href: "#/" },
-		{ label: "资源池", href: "#/pool" },
+		{ label: "资源池", href: "/#/inspect/pool" },
 		{ label: displayLabel },
 	]);
 

package/dist/worker/pool/attempt-lease.js

@@ -1,6 +1,7 @@
 import { randomBytes } from "node:crypto";
 import { mkdir, readFile, readdir, unlink } from "node:fs/promises";
 import path from "node:path";
+import { acquireDirLock } from "../../infrastructure/console/dir-lock.js";
 import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
 import { assertSafeTaskPoolId, getTaskPoolRoot, } from "./run-store.js";
 import { TASK_POOL_STATE_ERROR_CODES, TaskPoolStateError } from "./types.js";
@@ -19,6 +20,20 @@ export function getAttemptLeasePath(repoRoot, featureId, taskId) {
     }
     return leasePath;
 }
+function getAttemptLeaseMutationLockPath(repoRoot, featureId, taskId) {
+    assertSafeTaskPoolId(featureId, "featureId");
+    assertSafeTaskPoolId(taskId, "taskId");
+    return path.join(getAttemptLeasesRoot(repoRoot), "_locks", `${featureId}__${taskId}.lock`);
+}
+async function withAttemptLeaseMutationLock(repoRoot, featureId, taskId, operation) {
+    const lock = await acquireDirLock(getAttemptLeaseMutationLockPath(repoRoot, featureId, taskId));
+    try {
+        return await operation();
+    }
+    finally {
+        await lock.release();
+    }
+}
 function isLeaseRecord(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return false;
@@ -30,7 +45,11 @@ function isLeaseRecord(value) {
         typeof record.batchRunId === "string" &&
         typeof record.token === "string" &&
         typeof record.acquiredAt === "string" &&
-        typeof record.renewedAt === "string");
+        typeof record.renewedAt === "string" &&
+        (record.revisionId === undefined || typeof record.revisionId === "string") &&
+        (record.controllerAnchor === undefined ||
+            typeof record.controllerAnchor === "string") &&
+        (record.claimId === undefined || typeof record.claimId === "string"));
 }
 export async function readAttemptLease(repoRoot, featureId, taskId) {
     const leasePath = getAttemptLeasePath(repoRoot, featureId, taskId);
@@ -47,82 +66,94 @@ export async function readAttemptLease(repoRoot, featureId, taskId) {
 }
 /**
  * Acquire Task-scoped attempt lease before beginWorkerAttempt.
- * Same identity+token reuse is idempotent; different active identity → conflict.
+ * Same identity+claim reuse is idempotent; a competing admission or active
+ * identity conflicts. The Task-scoped mutation lock closes cross-process
+ * read-before-rename and release-vs-successor races.
  */
 export async function acquireAttemptLease(input) {
-    const now = input.now ?? new Date();
-    const existing = await readAttemptLease(input.repoRoot, input.featureId, input.taskId);
-    if (existing) {
-        if (existing.workerRunId === input.workerRunId &&
-            existing.batchRunId === input.batchRunId &&
-            existing.featureId === input.featureId &&
-            existing.taskId === input.taskId) {
-            return { status: "idempotent-reuse", lease: existing };
+    return withAttemptLeaseMutationLock(input.repoRoot, input.featureId, input.taskId, async () => {
+        const now = input.now ?? new Date();
+        const existing = await readAttemptLease(input.repoRoot, input.featureId, input.taskId);
+        if (existing) {
+            if (existing.workerRunId === input.workerRunId &&
+                existing.batchRunId === input.batchRunId &&
+                existing.featureId === input.featureId &&
+                existing.taskId === input.taskId &&
+                existing.revisionId === input.revisionId &&
+                existing.controllerAnchor === input.controllerAnchor &&
+                existing.claimId === input.claimId) {
+                return { status: "idempotent-reuse", lease: existing };
+            }
+            throw new TaskPoolStateError(TASK_POOL_STATE_ERROR_CODES.CONFLICT, `attempt-lease-conflict for ${input.featureId}/${input.taskId}: held by ${existing.workerRunId}`);
         }
-        throw new TaskPoolStateError(TASK_POOL_STATE_ERROR_CODES.CONFLICT, `attempt-lease-conflict for ${input.featureId}/${input.taskId}: held by ${existing.workerRunId}`);
-    }
-    const lease = {
-        schemaVersion: 1,
-        featureId: input.featureId,
-        taskId: input.taskId,
-        workerRunId: input.workerRunId,
-        batchRunId: input.batchRunId,
-        acquiredAt: now.toISOString(),
-        renewedAt: now.toISOString(),
-        token: `atk-${randomBytes(8).toString("hex")}`,
-        ownerProcess: { pid: process.pid },
-        ...(input.revisionId ? { revisionId: input.revisionId } : {}),
-        ...(input.controllerAnchor
-            ? { controllerAnchor: input.controllerAnchor }
-            : {}),
-    };
-    await mkdir(path.dirname(getAttemptLeasePath(input.repoRoot, input.featureId, input.taskId)), {
-        recursive: true,
+        const lease = {
+            schemaVersion: 1,
+            featureId: input.featureId,
+            taskId: input.taskId,
+            workerRunId: input.workerRunId,
+            batchRunId: input.batchRunId,
+            acquiredAt: now.toISOString(),
+            renewedAt: now.toISOString(),
+            token: `atk-${randomBytes(8).toString("hex")}`,
+            ownerProcess: { pid: process.pid },
+            ...(input.revisionId ? { revisionId: input.revisionId } : {}),
+            ...(input.controllerAnchor
+                ? { controllerAnchor: input.controllerAnchor }
+                : {}),
+            ...(input.claimId ? { claimId: input.claimId } : {}),
+        };
+        await mkdir(path.dirname(getAttemptLeasePath(input.repoRoot, input.featureId, input.taskId)), {
+            recursive: true,
+        });
+        await writeJsonAtomic(getAttemptLeasePath(input.repoRoot, input.featureId, input.taskId), lease, { repoRoot: input.repoRoot });
+        const confirmed = await readAttemptLease(input.repoRoot, input.featureId, input.taskId);
+        if (!confirmed) {
+            throw new Error(`failed to persist attempt lease for ${input.featureId}/${input.taskId}`);
+        }
+        if (confirmed.token !== lease.token) {
+            throw new TaskPoolStateError(TASK_POOL_STATE_ERROR_CODES.CONFLICT, `attempt-lease-conflict race for ${input.featureId}/${input.taskId}`);
+        }
+        return { status: "acquired", lease: confirmed };
     });
-    await writeJsonAtomic(getAttemptLeasePath(input.repoRoot, input.featureId, input.taskId), lease, { repoRoot: input.repoRoot });
-    const confirmed = await readAttemptLease(input.repoRoot, input.featureId, input.taskId);
-    if (!confirmed) {
-        throw new Error(`failed to persist attempt lease for ${input.featureId}/${input.taskId}`);
-    }
-    if (confirmed.workerRunId !== input.workerRunId) {
-        throw new TaskPoolStateError(TASK_POOL_STATE_ERROR_CODES.CONFLICT, `attempt-lease-conflict race for ${input.featureId}/${input.taskId}`);
-    }
-    return { status: "acquired", lease: confirmed };
 }
 export async function renewAttemptLease(input) {
-    const existing = await readAttemptLease(input.repoRoot, input.featureId, input.taskId);
-    if (!existing) {
-        throw new TaskPoolStateError(TASK_POOL_STATE_ERROR_CODES.CONFLICT, `cannot renew missing lease for ${input.featureId}/${input.taskId}`);
-    }
-    if (existing.token !== input.token || existing.workerRunId !== input.workerRunId) {
-        throw new TaskPoolStateError(TASK_POOL_STATE_ERROR_CODES.CONFLICT, `cannot renew lease: CAS token/identity mismatch for ${input.featureId}/${input.taskId}`);
-    }
-    const renewed = {
-        ...existing,
-        renewedAt: (input.now ?? new Date()).toISOString(),
-    };
-    await writeJsonAtomic(getAttemptLeasePath(input.repoRoot, input.featureId, input.taskId), renewed, { repoRoot: input.repoRoot });
-    return renewed;
+    return withAttemptLeaseMutationLock(input.repoRoot, input.featureId, input.taskId, async () => {
+        const existing = await readAttemptLease(input.repoRoot, input.featureId, input.taskId);
+        if (!existing) {
+            throw new TaskPoolStateError(TASK_POOL_STATE_ERROR_CODES.CONFLICT, `cannot renew missing lease for ${input.featureId}/${input.taskId}`);
+        }
+        if (existing.token !== input.token || existing.workerRunId !== input.workerRunId) {
+            throw new TaskPoolStateError(TASK_POOL_STATE_ERROR_CODES.CONFLICT, `cannot renew lease: CAS token/identity mismatch for ${input.featureId}/${input.taskId}`);
+        }
+        const renewed = {
+            ...existing,
+            renewedAt: (input.now ?? new Date()).toISOString(),
+        };
+        await writeJsonAtomic(getAttemptLeasePath(input.repoRoot, input.featureId, input.taskId), renewed, { repoRoot: input.repoRoot });
+        return renewed;
+    });
 }
 /**
  * Release active lease after terminal/recovery evidence. Moves to lease-history then deletes active locator.
  */
 export async function releaseAttemptLease(input) {
-    const existing = await readAttemptLease(input.repoRoot, input.featureId, input.taskId);
-    if (!existing)
-        return;
-    if (existing.token !== input.token || existing.workerRunId !== input.workerRunId) {
-        throw new TaskPoolStateError(TASK_POOL_STATE_ERROR_CODES.CONFLICT, `cannot release lease: CAS token/identity mismatch for ${input.featureId}/${input.taskId}`);
-    }
-    const historyRoot = path.join(getAttemptLeasesRoot(input.repoRoot), "_history");
-    await mkdir(historyRoot, { recursive: true });
-    const historyPath = path.join(historyRoot, `${input.featureId}__${input.taskId}__${existing.workerRunId}.json`);
-    const activePath = getAttemptLeasePath(input.repoRoot, input.featureId, input.taskId);
-    await writeJsonAtomic(historyPath, {
-        ...existing,
-        releasedAt: (input.now ?? new Date()).toISOString(),
-    }, { repoRoot: input.repoRoot });
-    await unlink(activePath).catch(() => { });
+    await withAttemptLeaseMutationLock(input.repoRoot, input.featureId, input.taskId, async () => {
+        const existing = await readAttemptLease(input.repoRoot, input.featureId, input.taskId);
+        if (!existing)
+            return;
+        if (existing.token !== input.token || existing.workerRunId !== input.workerRunId) {
+            throw new TaskPoolStateError(TASK_POOL_STATE_ERROR_CODES.CONFLICT, `cannot release lease: CAS token/identity mismatch for ${input.featureId}/${input.taskId}`);
+        }
+        const historyRoot = path.join(getAttemptLeasesRoot(input.repoRoot), "_history");
+        await mkdir(historyRoot, { recursive: true });
+        const historyPath = path.join(historyRoot, `${input.featureId}__${input.taskId}__${existing.workerRunId}.json`);
+        const activePath = getAttemptLeasePath(input.repoRoot, input.featureId, input.taskId);
+        await writeJsonAtomic(historyPath, {
+            ...existing,
+            releasedAt: (input.now ?? new Date()).toISOString(),
+        }, { repoRoot: input.repoRoot });
+        await unlink(activePath).catch(() => { });
+    });
 }
 export function decideAttemptLeaseReclaim(input) {
     if (input.hasTerminalEvidence) {

package/dist/worker/pool/begin-attempt-with-lease.js

@@ -19,6 +19,7 @@ export async function beginWorkerAttemptWithLease(input) {
         ...(input.controllerAnchor
             ? { controllerAnchor: input.controllerAnchor }
             : {}),
+        ...(input.leaseClaimId ? { claimId: input.leaseClaimId } : {}),
         ...(input.now ? { now: input.now } : {}),
     });
     const begun = await beginWorkerAttempt(input);

package/dist/worker/pool/reconcile.js

@@ -3,6 +3,8 @@ import path from "node:path";
 import { executeDagReconcileRun } from "../../workflows/dag/reconcile-run.js";
 import { assessDagRunLiveness, assessDagRunRecoveryEligibility, locateDagRun, readDagRunState, } from "../../workflows/dag/lifecycle.js";
 import { appendTaskPoolEvent, findRunByWorkerRunId, getTaskPoolRoot, readTaskPoolState, writeTaskPoolState, } from "./run-store.js";
+import { readRunOwner } from "./run-owner-store.js";
+import { readAttemptLease, releaseAttemptLease } from "./attempt-lease.js";
 const RECOVERABLE_LIVENESS = new Set([
     "active",
     "node-quiet",
@@ -110,6 +112,17 @@ export async function reconcileTaskPoolAbandon(input) {
         idempotent: false,
         evidencePath: operatorRecovery.evidencePath,
     });
+    const lease = await readAttemptLease(input.repoRoot, input.featureId, input.taskId);
+    if (lease?.workerRunId === input.workerRunId) {
+        await releaseAttemptLease({
+            repoRoot: input.repoRoot,
+            featureId: input.featureId,
+            taskId: input.taskId,
+            token: lease.token,
+            workerRunId: input.workerRunId,
+            now: input.now,
+        });
+    }
     return {
         schemaVersion: 1,
         status: "Failed",
@@ -201,7 +214,6 @@ export async function markTaskPoolFailed(input) {
     };
 }
 async function validateWorkerDagAssociation(input) {
-    const run = await validateWorkerRunOwnership(input);
     const dagLocated = await locateDagRun(input.repoRoot, input.dagRunId);
     if (!dagLocated) {
         throw new Error(`dag run not found: ${input.dagRunId}`);
@@ -210,6 +222,39 @@ async function validateWorkerDagAssociation(input) {
     if (dagState.runId !== input.dagRunId) {
         throw new Error(`dag run identity mismatch: expected ${input.dagRunId}, found ${dagState.runId}`);
     }
+    let run = await findRunByWorkerRunId(input.repoRoot, input.workerRunId);
+    if (!run) {
+        const owner = await readRunOwner(input.repoRoot, input.workerRunId);
+        const association = dagState.workerAssociation;
+        const authority = dagState.continuation?.workerContinuationAuthority;
+        if (!owner ||
+            owner.featureId !== input.featureId ||
+            owner.taskId !== input.taskId ||
+            owner.workerRunId !== input.workerRunId ||
+            owner.revisionId === undefined ||
+            input.dagRunId !== input.workerRunId ||
+            association?.workerRunId !== input.workerRunId ||
+            association.featureId !== input.featureId ||
+            association.taskId !== input.taskId ||
+            authority?.childWorkerRunId !== input.workerRunId ||
+            authority.parentWorkerRunId === input.workerRunId ||
+            authority.revisionId !== owner.revisionId) {
+            throw new Error(`worker run not found: ${input.workerRunId}`);
+        }
+        run = {
+            schemaVersion: 1,
+            batchRunId: owner.batchRunId,
+            workerRunId: owner.workerRunId,
+            featureId: owner.featureId,
+            taskId: owner.taskId,
+            status: "run-error",
+            attemptKind: "artifact-continuation",
+            recordedAt: owner.registeredAt,
+        };
+    }
+    else if (run.featureId !== input.featureId || run.taskId !== input.taskId) {
+        throw new Error(`worker run ownership mismatch: expected ${input.featureId}/${input.taskId}, found ${run.featureId}/${run.taskId}`);
+    }
     const linked = await proveWorkerDagLink(input.repoRoot, run, input.workerRunId, input.dagRunId);
     if (!linked) {
         throw new Error(`worker run ${input.workerRunId} is not associated with dag run ${input.dagRunId}`);

package/dist/worker/pool/run-store.js

@@ -350,6 +350,8 @@ function eventFromRun(run) {
         taskId: run.taskId,
         featureId: run.featureId,
         status: run.status,
+        ...(run.attemptKind ? { attemptKind: run.attemptKind } : {}),
+        ...(run.continuation ? { continuation: run.continuation } : {}),
     };
 }
 function isNotFound(error) {

package/dist/worker/pool/state-projection.js

@@ -47,6 +47,8 @@ export function stateFromRun(run) {
         status: projectTaskPoolStatusFromRun(run),
         updatedAt: run.recordedAt,
         workerRunId: run.workerRunId,
+        ...(run.attemptKind ? { attemptKind: run.attemptKind } : {}),
+        ...(run.continuation ? { continuation: run.continuation } : {}),
         ...(run.runRecordPath ? { lastRunRecordPath: run.runRecordPath } : {}),
         ...(run.failure ? { failure: run.failure } : {}),
         ...(run.failureV2 ? { failureV2: run.failureV2 } : {}),