@tea-agent/loop-agent 0.41.1 → 0.42.0-next.10

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;
+}

package/dist/workflows/dag/artifact-revision-schema-registry.js

@@ -0,0 +1,31 @@
+import { backendPytestCollectionFactsSchema, backendTestExecutionReadinessSchema } from "./backend-test-pytest-collection.js";
+import { backendTestCaseManifestSchema } from "./backend-test-case-manifest.js";
+import { backendTestAnalysisContractSchema } from "./backend-test-analysis-contract.js";
+import { backendTestExecutionContractSchema } from "./backend-test-execution-contract.js";
+import { backendTestCaseCoverageFactsSchema } from "./backend-test-case-coverage-analysis.js";
+import { frontendImplementationContractSchema } from "./frontend-implementation-contract.js";
+/**
+ * Standalone artifact revision schema registry (exec-plan
+ * 2026-08-25-console-node-context-artifact-rerun W4.3 / M4 exit criteria).
+ *
+ * Maps a frozen produced-artifact `schemaId` to a deterministic zod validator
+ * that can check candidate revision bytes without run context. Declared
+ * schemaIds without an entry here are rejected fail-closed with
+ * ARTIFACT_REVISION_SCHEMA_INVALID — an artifact cannot be staged until its
+ * schema is registered. Never guessed, never silently passed.
+ */
+const ARTIFACT_REVISION_SCHEMAS = Object.freeze({
+    "backend-test-pytest-collection-v3": backendPytestCollectionFactsSchema,
+    "backend-test-execution-readiness-v2": backendTestExecutionReadinessSchema,
+    "backend-test-case-manifest-v1": backendTestCaseManifestSchema,
+    "backend-test-analysis-v2": backendTestAnalysisContractSchema,
+    "backend-test-execution-v1": backendTestExecutionContractSchema,
+    "backend-test-case-coverage-facts-v4": backendTestCaseCoverageFactsSchema,
+    "frontend-implementation-contract-v1": frontendImplementationContractSchema,
+});
+export function resolveArtifactRevisionSchema(schemaId) {
+    return ARTIFACT_REVISION_SCHEMAS[schemaId];
+}
+export function listArtifactRevisionSchemaIds() {
+    return Object.keys(ARTIFACT_REVISION_SCHEMAS).sort();
+}