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

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

@@ -586,6 +586,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();
@@ -829,7 +858,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";
@@ -839,13 +887,7 @@ 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);
 	const exportBtn = el("button", "btn btn-secondary", "导出 HTML");
@@ -879,9 +921,10 @@ export function renderSessionTimeline(content, nodeId, options = {}) {
 	toolbar.appendChild(exportBtn);
 	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)),
 	);
@@ -895,6 +938,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];
@@ -973,3 +1023,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/outcomes/adapters.js

@@ -98,6 +98,24 @@ class FrontendImplementationAdapter {
         };
     }
 }
+/**
+ * `backend-test-analysis` — read-only requirements/API analysis. It produces
+ * the strict Backend Test Analysis v2 contract without claiming that tests or
+ * a real integration ran.
+ */
+class BackendTestAnalysisAdapter {
+    workflow = "backend-test-analysis";
+    project(input) {
+        return {
+            artifacts: [
+                ...canonicalArtifacts(input),
+                ...structuredArtifactsFromReport(input.dagReportRun),
+            ],
+            acceptanceCoverage: [...input.acceptanceRefs],
+            integrationStatus: { mock: false, real: false },
+        };
+    }
+}
 /**
  * `backend-test` — generates + executes backend tests. Integration status is
  * `real: true` only when the report completed (a real test execution); mock is
@@ -139,6 +157,7 @@ class FrontendTestAdapter {
 const ADAPTERS = new Map([
     ["agent-dag", new AgentDagAdapter()],
     ["frontend-implementation", new FrontendImplementationAdapter()],
+    ["backend-test-analysis", new BackendTestAnalysisAdapter()],
     ["backend-test", new BackendTestAdapter()],
     ["frontend-test", new FrontendTestAdapter()],
 ]);

package/dist/worker/outcomes/types.js

@@ -24,6 +24,7 @@ export const outcomeFailureCategorySchema = z.enum([
 export const OUTCOME_WORKFLOWS = [
     "agent-dag",
     "frontend-implementation",
+    "backend-test-analysis",
     "backend-test",
     "frontend-test",
 ];

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 } : {}),

package/dist/worker/task-spec/workflow-routing.js

@@ -11,6 +11,7 @@ export const workflowSchema = z.enum([
     "agent-dag",
     "frontend-implementation",
     "backend-test",
+    "backend-test-analysis",
     "frontend-test",
 ]);
 /**
@@ -23,6 +24,7 @@ export const WORKFLOW_TASK_KIND = {
     "agent-dag": "standard",
     "frontend-implementation": "frontend-implementation",
     "backend-test": "backend-test",
+    "backend-test-analysis": "backend-test-analysis",
     "frontend-test": "frontend-test",
 };
 /**
@@ -48,7 +50,7 @@ export function legacyDefaultWorkflow(type) {
 }
 /** Migration guidance surfaced whenever a legacy QA type lacks an explicit workflow. */
 export const LEGACY_QA_MIGRATION_GUIDANCE = "Legacy qa-casegen/qa-testcode/qa-execute tasks no longer auto-select a backend or frontend workflow. " +
-    "Add `execution.workflow` with one of: agent-dag, frontend-implementation, backend-test, frontend-test. " +
+    "Add `execution.workflow` with one of: agent-dag, frontend-implementation, backend-test-analysis, backend-test, frontend-test. " +
     "Use backend-test for backend-only test generation/execution, frontend-test for browser/UI tests, " +
     "or agent-dag when the QA task is a generic agent study.";
 export class WorkflowRoutingError extends Error {
@@ -120,10 +122,13 @@ export function validateWorkflowCompatibility(taskSpec) {
     }
     const issues = [];
     const type = taskSpec.type;
-    if (type === "backend-feature" && explicit !== "agent-dag" && explicit !== "backend-test") {
+    if (type === "backend-feature" &&
+        explicit !== "agent-dag" &&
+        explicit !== "backend-test-analysis" &&
+        explicit !== "backend-test") {
         issues.push({
             code: "workflow-type-incompatible",
-            message: `backend-feature is incompatible with workflow "${explicit}" (expected agent-dag or backend-test)`,
+            message: `backend-feature is incompatible with workflow "${explicit}" (expected agent-dag, backend-test-analysis, or backend-test)`,
             path: "execution.workflow",
         });
     }

package/dist/workflows/dag/artifact-bindings.js

@@ -0,0 +1,149 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { canonicalSha256 } from "../../shared/context-transfer.js";
+export function buildArtifactBindingGraph(spec) {
+    const consumers = new Map();
+    for (const task of spec.tasks) {
+        for (const binding of task.consumesArtifacts ?? []) {
+            const nodeIds = consumers.get(binding.artifactId) ?? [];
+            nodeIds.push(task.id);
+            consumers.set(binding.artifactId, nodeIds);
+        }
+    }
+    const artifacts = spec.tasks
+        .flatMap((task) => (task.producesArtifacts ?? []).map((artifact) => ({
+        ...artifact,
+        producerNodeId: task.id,
+        directConsumerNodeIds: [...(consumers.get(artifact.artifactId) ?? [])].sort(),
+    })))
+        .sort((a, b) => a.artifactId.localeCompare(b.artifactId));
+    const available = artifacts.length > 0;
+    const payload = { schemaVersion: 1, artifacts };
+    return {
+        ...payload,
+        available,
+        ...(available ? {} : { reasonCode: "ARTIFACT_BINDING_UNAVAILABLE" }),
+        artifactGraphSha256: canonicalSha256(payload),
+    };
+}
+function collectDescendants(spec, roots) {
+    const children = new Map();
+    for (const task of spec.tasks) {
+        for (const parent of task.depends_on) {
+            const values = children.get(parent) ?? [];
+            values.push(task.id);
+            children.set(parent, values);
+        }
+    }
+    const queue = [...roots];
+    const seen = new Set();
+    while (queue.length > 0) {
+        const nodeId = queue.shift();
+        if (seen.has(nodeId))
+            continue;
+        seen.add(nodeId);
+        queue.push(...(children.get(nodeId) ?? []));
+    }
+    return spec.tasks.map((task) => task.id).filter((nodeId) => seen.has(nodeId));
+}
+export function computeArtifactImpact(spec, artifactId) {
+    const graph = buildArtifactBindingGraph(spec);
+    const artifact = graph.artifacts.find((entry) => entry.artifactId === artifactId);
+    if (!artifact || artifact.directConsumerNodeIds.length === 0)
+        return undefined;
+    const affectedNodeIds = collectDescendants(spec, artifact.directConsumerNodeIds);
+    const affectedSet = new Set(affectedNodeIds);
+    const importedNodeIds = spec.tasks
+        .map((task) => task.id)
+        .filter((nodeId) => !affectedSet.has(nodeId));
+    return {
+        artifactId,
+        producerNodeId: artifact.producerNodeId,
+        directConsumerNodeIds: artifact.directConsumerNodeIds,
+        effectiveFromNodeId: affectedNodeIds[0],
+        affectedNodeIds,
+        importedNodeIds,
+    };
+}
+function runtimeArtifactFields(node, kind) {
+    if (kind === "structured") {
+        return {
+            path: node.structuredArtifactPath,
+            sha256: node.structuredArtifactSha256,
+            schemaId: node.structuredArtifactSchemaId,
+        };
+    }
+    if (kind === "assistant") {
+        return { path: node.assistantArtifactPath, sha256: node.assistantSha256 };
+    }
+    return { path: node.stdoutArtifactPath, sha256: node.stdoutSha256 };
+}
+export async function materializeDeclaredArtifactFacts(input) {
+    const facts = [];
+    for (const declaration of input.task.producesArtifacts ?? []) {
+        const runtime = runtimeArtifactFields(input.node, declaration.kind);
+        const base = { ...declaration, revisionEligible: false };
+        if (!runtime.path || !runtime.sha256) {
+            facts.push({
+                ...base,
+                status: "missing",
+                reasonCode: "ARTIFACT_NOT_MATERIALIZED",
+            });
+            continue;
+        }
+        const relativePath = path
+            .relative(input.runDir, runtime.path)
+            .split(path.sep)
+            .join("/");
+        if (relativePath !== declaration.path) {
+            facts.push({
+                ...base,
+                status: "mismatch",
+                sha256: runtime.sha256,
+                reasonCode: "ARTIFACT_PATH_MISMATCH",
+            });
+            continue;
+        }
+        if (declaration.schemaId !== runtime.schemaId) {
+            facts.push({
+                ...base,
+                status: "mismatch",
+                sha256: runtime.sha256,
+                reasonCode: "ARTIFACT_SCHEMA_MISMATCH",
+            });
+            continue;
+        }
+        let bytes;
+        try {
+            bytes = await readFile(runtime.path);
+        }
+        catch {
+            facts.push({
+                ...base,
+                status: "missing",
+                reasonCode: "ARTIFACT_NOT_MATERIALIZED",
+            });
+            continue;
+        }
+        const actualSha256 = createHash("sha256").update(bytes).digest("hex");
+        if (actualSha256 !== runtime.sha256) {
+            facts.push({
+                ...base,
+                status: "mismatch",
+                sha256: actualSha256,
+                bytes: bytes.byteLength,
+                reasonCode: "ARTIFACT_HASH_MISMATCH",
+            });
+            continue;
+        }
+        facts.push({
+            ...base,
+            status: "materialized",
+            sha256: actualSha256,
+            bytes: bytes.byteLength,
+            revisionEligible: declaration.revisionPolicy === "replace-file",
+        });
+    }
+    return facts;
+}