@tea-agent/loop-agent 0.16.1 → 0.16.3

package/dist/workflows/dag/lifecycle.js

@@ -4,7 +4,7 @@ import { hostname as localHostname } from "node:os";
 import { writeJsonAtomic, } from "../../infrastructure/harness/atomic-write.js";
 import { parseDagSpec } from "./types.js";
 import { normalizeDagFailureCategory, } from "./failure-category.js";
-import { routeDagFailure } from "./failure-routing.js";
+import { dagProductLineFailureCategoryValues, routeDagFailure, } from "./failure-routing.js";
 const DAG_LIFECYCLE_SCAN_ORDER = [
     "paused",
     "active",
@@ -663,6 +663,36 @@ function findDoctorFailureNode(state) {
         rawFailureCategory: selected[1].failureCategory,
     };
 }
+async function readRunOwnedBackendTestClassification(runDir) {
+    try {
+        const raw = JSON.parse(await readFile(path.join(runDir, "classify-backend-test-result-pi.json"), "utf-8"));
+        const text = raw.assistantText ?? raw.stdout;
+        if (typeof text !== "string")
+            return undefined;
+        const trimmed = text.trim();
+        const fenced = trimmed.match(/^```json\s*([\s\S]*?)\s*```$/i);
+        const classification = JSON.parse(fenced?.[1] ?? trimmed);
+        return typeof classification.category === "string" &&
+            dagProductLineFailureCategoryValues.includes(classification.category)
+            ? classification.category
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function resolveDoctorFailureRouting(input) {
+    const classifiedCategory = await readRunOwnedBackendTestClassification(input.runDir);
+    if (classifiedCategory) {
+        return routeDagFailure({
+            rawFailureCategory: classifiedCategory,
+            normalizedFailureCategory: "unknown",
+            nodeId: input.nodeId,
+            productLineFailureCategory: classifiedCategory,
+        });
+    }
+    return routeDagFailure(input);
+}
 async function formatDagDoctorMarkdown(repoRoot, runId) {
     const located = await locateDagRun(repoRoot, runId);
     if (!located) {
@@ -675,7 +705,8 @@ async function formatDagDoctorMarkdown(repoRoot, runId) {
         (state.status === "paused" ? "human-required" : state.failureCategory);
     const failureStatus = state.status === "paused" ? "paused" : failure.status;
     const normalizedCategory = normalizeDagFailureCategory(rawFailureCategory, failureStatus ?? state.status);
-    const routing = routeDagFailure({
+    const routing = await resolveDoctorFailureRouting({
+        runDir: located.runDir,
         rawFailureCategory,
         normalizedFailureCategory: normalizedCategory,
         nodeId: failure.nodeId,

package/dist/workflows/dag/scheduler.js

@@ -1,14 +1,58 @@
 import { isPauseOnHumanDecisionGate } from "./decision-envelope.js";
+import { evaluateConditionExpression } from "./dynamic-runtime/condition.js";
 export function isConditionSkippedReason(reason) {
     return Boolean(reason?.startsWith("condition "));
 }
-function shouldSkipNode(node, task, nodes) {
-    if (!node || node.status !== "PENDING")
-        return false;
-    return task.depends_on.some((depId) => {
+/**
+ * Dependency readiness for PENDING nodes.
+ *
+ * Default (`dependsPolicy: all`): any ERROR/SKIPPED dependency → skip (cascades
+ * exclusive condition branches). Unsettled → wait. All FINISHED → run.
+ *
+ * `all-or-condition-skip`: exclusive-branch tips that were condition-SKIPPED are
+ * soft; the node runs when every dep is FINISHED or soft condition-skip and at
+ * least one is FINISHED (OR-join after condition). Opt-in only — never default.
+ */
+function dependencyReadiness(task, nodes) {
+    if (task.depends_on.length === 0)
+        return "run";
+    const softConditionJoin = task.dependsPolicy === "all-or-condition-skip";
+    let hasFinished = false;
+    let hasPendingUpstream = false;
+    let hasHardBlock = false;
+    for (const depId of task.depends_on) {
         const dep = nodes[depId];
-        return !dep || dep.status === "ERROR" || dep.status === "SKIPPED";
-    });
+        if (!dep) {
+            hasHardBlock = true;
+            continue;
+        }
+        if (dep.status === "FINISHED") {
+            hasFinished = true;
+            continue;
+        }
+        if (dep.status === "PENDING" || dep.status === "RUNNING") {
+            hasPendingUpstream = true;
+            continue;
+        }
+        if (dep.status === "ERROR") {
+            hasHardBlock = true;
+            continue;
+        }
+        if (dep.status === "SKIPPED") {
+            if (softConditionJoin &&
+                isConditionSkippedReason(dep.skippedReason)) {
+                continue;
+            }
+            hasHardBlock = true;
+        }
+    }
+    if (hasPendingUpstream)
+        return "wait";
+    if (hasHardBlock)
+        return "skip";
+    if (hasFinished)
+        return "run";
+    return "skip";
 }
 function conditionSkippedByAncestor(task, nodes) {
     return task.depends_on.some((depId) => isConditionSkippedReason(nodes[depId]?.skippedReason));
@@ -27,18 +71,44 @@ async function mapConcurrent(items, limit, fn) {
 export async function executeDagRanksOnce(input) {
     let pausedByNodeId;
     for (const rank of input.ranks) {
-        const runnable = rank.filter((id) => {
+        const pending = rank.filter((id) => {
             const node = input.state.nodes[id];
+            return node?.status === "PENDING";
+        });
+        const runnable = pending.filter((id) => {
             const task = input.tasksById.get(id);
-            if (!node || node.status !== "PENDING")
-                return false;
-            return !shouldSkipNode(node, task, input.state.nodes);
+            return dependencyReadiness(task, input.state.nodes) === "run";
         });
-        const blocked = rank.filter((id) => {
-            const node = input.state.nodes[id];
+        const conditionSettled = [];
+        for (const id of runnable) {
+            const task = input.tasksById.get(id);
+            if (!task.runIf)
+                continue;
+            try {
+                if (!evaluateConditionExpression(task.runIf, input.state)) {
+                    const node = input.state.nodes[id];
+                    node.status = "SKIPPED";
+                    node.skippedReason = `condition runIf did not match: ${task.runIf}`;
+                    node.finishedAt = new Date().toISOString();
+                    conditionSettled.push(id);
+                }
+            }
+            catch (error) {
+                const node = input.state.nodes[id];
+                node.status = "ERROR";
+                node.failureCategory = "invalid-output";
+                node.stderr = error instanceof Error ? error.message : String(error);
+                node.finishedAt = new Date().toISOString();
+                conditionSettled.push(id);
+            }
+        }
+        if (conditionSettled.length > 0)
+            await input.persistState();
+        const conditionSkippedSet = new Set(conditionSettled);
+        const actuallyRunnable = runnable.filter((id) => !conditionSkippedSet.has(id));
+        const blocked = pending.filter((id) => {
             const task = input.tasksById.get(id);
-            return (node?.status === "PENDING" &&
-                shouldSkipNode(node, task, input.state.nodes));
+            return dependencyReadiness(task, input.state.nodes) === "skip";
         });
         for (const id of blocked) {
             const node = input.state.nodes[id];
@@ -50,12 +120,12 @@ export async function executeDagRanksOnce(input) {
         if (blocked.length > 0) {
             await input.persistState();
         }
-        const pauseGateRunnable = runnable.filter((id) => {
+        const pauseGateRunnable = actuallyRunnable.filter((id) => {
             const task = input.tasksById.get(id);
             return isPauseOnHumanDecisionGate(task);
         });
-        const regularRunnable = runnable.filter((id) => !pauseGateRunnable.includes(id));
-        const rankWriterNodeIds = runnable.filter((id) => {
+        const regularRunnable = actuallyRunnable.filter((id) => !pauseGateRunnable.includes(id));
+        const rankWriterNodeIds = actuallyRunnable.filter((id) => {
             const task = input.tasksById.get(id);
             return (task?.executor === "pi" &&
                 task.toolProfile === "write" &&

package/dist/workflows/dag/types.js

@@ -59,6 +59,14 @@ export const dagVerdictGateSchema = z.object({
     fromNodeId: z
         .string()
         .regex(/^[a-z][a-z0-9-]*$/, "fromNodeId must be kebab-case"),
+    /**
+     * Optional fallback node ids when the primary `fromNodeId` JSON is absent
+     * (e.g. exclusive condition branch skip). Tried in order after primary.
+     * Prefer listing the post-revision / final reviewer first when both may exist.
+     */
+    fallbackFromNodeIds: z
+        .array(z.string().regex(/^[a-z][a-z0-9-]*$/, "fallbackFromNodeIds must be kebab-case"))
+        .optional(),
     accept: z.array(z.string().min(1)).min(1),
     lineMode: z.enum(["first-non-empty", "first-verdict-line"]).optional(),
     label: z.string().min(1).optional(),
@@ -76,8 +84,11 @@ export const dagRequirementCoverageGateSchema = z.object({
 });
 export const dagJsonArtifactSchemaIdSchema = z.enum([
     "backend-test-analysis-v1",
+    "backend-test-analysis-v2",
     "backend-test-execution-v1",
     "backend-test-result-v1",
+    "backend-test-classification-v1",
+    "backend-test-semantic-review-v1",
     "backend-test-case-manifest-v1",
     "frontend-implementation-contract-v1",
 ]);
@@ -86,6 +97,7 @@ export const dagJsonArtifactGateSchema = z.object({
     schemaId: dagJsonArtifactSchemaIdSchema,
     artifactName: z.string().regex(/^[a-z0-9][a-z0-9._-]*\.json$/),
     outputDir: z.string().regex(/^[a-z0-9][a-z0-9._-]*$/),
+    junitRelativePath: z.string().min(1).optional(),
 });
 export const ENV_VAR_NAME_PATTERN = /^[A-Z_][A-Z0-9_]*$/;
 export const dagVersionSchema = z
@@ -129,12 +141,22 @@ export const dagNodeStatusSchema = z.enum([
     "ERROR",
     "SKIPPED",
 ]);
+export const dagBackendTestPipelineSchema = z.enum([
+    "contracts",
+    "semantic-initial",
+    "semantic-final",
+    "execute-parse-initial",
+    "classification-eligibility",
+    "repair-safety-traceability",
+    "finalize-effective-result",
+]);
 export const dagShellConfigSchema = z.object({
     commands: z.array(z.string()).default([]),
     preset: dagShellPresetSchema.optional(),
     verdictGate: dagVerdictGateSchema.optional(),
     requirementCoverageGate: dagRequirementCoverageGateSchema.optional(),
     jsonArtifactGate: dagJsonArtifactGateSchema.optional(),
+    backendTestPipeline: dagBackendTestPipelineSchema.optional(),
     verifyEvidence: dagShellVerifyEvidenceSchema.optional(),
     repairArtifactGate: dagRepairArtifactGateSchema.optional(),
     /** fail (default): any nonzero command fails the node. record: finish node FINISHED with failure facts for downstream assess/repair. */
@@ -255,6 +277,15 @@ export const dagConvergenceSpecSchema = z
 export const dagTaskSchema = z.object({
     id: z.string().regex(/^[a-z][a-z0-9-]*$/, "task id must be kebab-case"),
     depends_on: z.array(z.string()).default([]),
+    /**
+     * How SKIPPED upstreams affect readiness.
+     * - all (default): any SKIPPED/ERROR dependency blocks (cascade exclusive branches)
+     * - all-or-condition-skip: condition-branch SKIPPED tips count as soft; node runs when
+     *   every dep is FINISHED or soft condition-skip and at least one is FINISHED (OR-join)
+     */
+    dependsPolicy: z.enum(["all", "all-or-condition-skip"]).optional(),
+    /** Execute only when this fail-closed condition resolves true after dependencies settle. */
+    runIf: z.string().min(1).optional(),
     complexity: dagComplexitySchema,
     subtask_prompt: z.string().min(1),
     subtask_prompt_source: z

package/dist/workflows/dag/validate.js

@@ -137,18 +137,24 @@ function validateVerdictGateConfig(task, spec, issues) {
         return;
     }
     const upstreamIds = new Set(task.depends_on);
-    if (!upstreamIds.has(verdictGate.fromNodeId)) {
-        issues.push({
-            type: "invalid-verdict-gate-config",
-            message: `task ${task.id} shell.verdictGate.fromNodeId "${verdictGate.fromNodeId}" must appear in depends_on`,
-        });
-    }
-    const upstreamTask = spec.tasks.find((candidate) => candidate.id === verdictGate.fromNodeId);
-    if (upstreamTask && upstreamTask.executor === "shell") {
-        issues.push({
-            type: "invalid-verdict-gate-config",
-            message: `task ${task.id} shell.verdictGate.fromNodeId "${verdictGate.fromNodeId}" must reference a non-shell upstream verdict node`,
-        });
+    const sourceNodeIds = [
+        verdictGate.fromNodeId,
+        ...(verdictGate.fallbackFromNodeIds ?? []),
+    ];
+    for (const sourceId of sourceNodeIds) {
+        if (!upstreamIds.has(sourceId)) {
+            issues.push({
+                type: "invalid-verdict-gate-config",
+                message: `task ${task.id} shell.verdictGate source "${sourceId}" must appear in depends_on`,
+            });
+        }
+        const upstreamTask = spec.tasks.find((candidate) => candidate.id === sourceId);
+        if (upstreamTask && upstreamTask.executor === "shell") {
+            issues.push({
+                type: "invalid-verdict-gate-config",
+                message: `task ${task.id} shell.verdictGate source "${sourceId}" must reference a non-shell upstream verdict node`,
+            });
+        }
     }
     for (const accepted of verdictGate.accept) {
         if (accepted.trim().length === 0) {
@@ -440,10 +446,10 @@ function validateShellTaskConfig(task, spec, issues) {
         return;
     }
     const commands = resolveShellCommands(shell);
-    if (commands.length === 0 && !shell.jsonArtifactGate) {
+    if (commands.length === 0 && !shell.jsonArtifactGate && !shell.backendTestPipeline) {
         issues.push({
             type: "missing-shell-commands",
-            message: `shell task ${task.id} requires shell.preset, shell.verdictGate, and/or non-empty shell.commands`,
+            message: `shell task ${task.id} requires shell.preset, shell.verdictGate, shell.jsonArtifactGate, shell.backendTestPipeline, and/or non-empty shell.commands`,
         });
     }
     if (commands.some((command) => command.trim().length === 0)) {

package/docs/templates/agent-dag.schema.json

@@ -212,7 +212,15 @@
             "fromNodeId": {
               "type": "string",
               "pattern": "^[a-z][a-z0-9-]*$",
-              "description": "Upstream node id whose canonical JSON output in the runner-injected current run directory ($HARNESS_DAG_RUN_DIR/<fromNodeId>.json) supplies the verdict line."
+              "description": "Primary upstream node id whose canonical JSON output in the runner-injected current run directory ($HARNESS_DAG_RUN_DIR/<fromNodeId>.json) supplies the verdict line."
+            },
+            "fallbackFromNodeIds": {
+              "type": "array",
+              "items": {
+                "type": "string",
+                "pattern": "^[a-z][a-z0-9-]*$"
+              },
+              "description": "Optional fallback upstream node ids tried in order when the primary JSON output is absent, for example when an exclusive condition branch was skipped. Each source must also appear in the gate task depends_on list."
             },
             "accept": {
               "type": "array",
@@ -242,6 +250,9 @@
             "label": { "type": "string", "minLength": 1 }
           }
         },
+        "backendTestPipeline": {
+          "enum": ["contracts", "semantic-initial", "semantic-final", "execute-parse-initial", "classification-eligibility", "repair-safety-traceability", "finalize-effective-result"]
+        },
         "verifyEvidence": { "$ref": "#/$defs/shellVerifyEvidence" },
         "repairArtifactGate": { "$ref": "#/$defs/repairArtifactGate" },
         "envAllowlist": {
@@ -258,7 +269,8 @@
         { "required": ["commands"], "properties": { "commands": { "minItems": 1 } } },
         { "required": ["preset"] },
         { "required": ["verdictGate"] },
-        { "required": ["requirementCoverageGate"] }
+        { "required": ["requirementCoverageGate"] },
+        { "required": ["backendTestPipeline"] }
       ]
     },
     "staticConfig": {
@@ -327,6 +339,17 @@
           "items": { "type": "string", "pattern": "^[a-z][a-z0-9-]*$" },
           "default": []
         },
+        "dependsPolicy": {
+          "type": "string",
+          "enum": ["all", "all-or-condition-skip"],
+          "default": "all",
+          "description": "Dependency join policy. all is fail-closed on any skipped/error dependency. all-or-condition-skip treats only condition-branch skips as soft and runs after all dependencies settle when at least one dependency finished."
+        },
+        "runIf": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Optional fail-closed node execution condition evaluated after dependencies settle. False records an explicit condition skip; malformed selectors fail the node."
+        },
         "complexity": { "$ref": "#/$defs/complexity" },
         "subtask_prompt": {
           "type": "string",

package/docs/templates/backend-test-analysis.schema.json

@@ -1,23 +1,14 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://tea-agent.dev/schemas/backend-test-analysis-v1.json",
-  "title": "Backend Test Analysis v1",
+  "$id": "https://tea-agent.dev/schemas/backend-test-analysis-v2.json",
+  "title": "Backend Test Analysis v2",
+  "description": "The runtime accepts v1 input for compatibility and normalizes it to this v2 artifact.",
   "type": "object",
   "additionalProperties": false,
   "required": ["schemaVersion", "sourceBinding", "acceptanceCriteria", "endpoints", "dataModels", "businessRules", "stateTransitions", "boundaryConstraints", "externalDependencies", "risks", "evidenceGaps"],
   "properties": {
-    "schemaVersion": { "const": 1 },
-    "sourceBinding": {
-      "type": "object", "additionalProperties": false,
-      "required": ["taskId", "requirementPath", "requirementSha256", "referencePaths", "requirementIds"],
-      "properties": {
-        "taskId": { "type": "string", "minLength": 1 },
-        "requirementPath": { "type": "string", "minLength": 1 },
-        "requirementSha256": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
-        "referencePaths": { "type": "array", "items": { "type": "string", "minLength": 1 } },
-        "requirementIds": { "type": "array", "items": { "type": "string", "pattern": "^(REQ|BR|AC)-[A-Z0-9]+(-[A-Z0-9]+)*$" } }
-      }
-    },
+    "schemaVersion": { "const": 2 },
+    "sourceBinding": { "$ref": "#/$defs/sourceBinding" },
     "acceptanceCriteria": { "type": "array", "items": { "$ref": "#/$defs/acceptanceCriterion" } },
     "endpoints": { "type": "array", "items": { "$ref": "#/$defs/endpoint" } },
     "dataModels": { "type": "array", "items": { "$ref": "#/$defs/evidencedDescription" } },
@@ -30,10 +21,12 @@
   },
   "$defs": {
     "sourceRef": { "type": "string", "minLength": 1 },
-    "field": { "type": "object", "additionalProperties": false, "required": ["name"], "properties": { "name": { "type": "string", "minLength": 1 }, "type": { "type": "string", "minLength": 1 }, "required": { "type": "boolean" }, "description": { "type": "string" } } },
+    "sourceBinding": { "type": "object", "additionalProperties": false, "required": ["taskId", "requirementPath", "requirementSha256", "referencePaths", "requirementIds"], "properties": { "taskId": { "type": "string", "minLength": 1 }, "requirementPath": { "type": "string", "minLength": 1 }, "requirementSha256": { "type": "string", "pattern": "^[a-f0-9]{64}$" }, "referencePaths": { "type": "array", "items": { "type": "string", "minLength": 1 } }, "requirementIds": { "type": "array", "items": { "type": "string", "pattern": "^(REQ|BR|AC)-[A-Z0-9]+(-[A-Z0-9]+)*$" } } } },
+    "field": { "type": "object", "additionalProperties": false, "required": ["name", "sourceRefs"], "properties": { "name": { "type": "string", "minLength": 1 }, "type": { "type": "string", "minLength": 1 }, "required": { "type": "boolean" }, "description": { "type": "string" }, "format": { "type": "string", "minLength": 1 }, "comparison": { "enum": ["exact", "parseable-only", "semantic"] }, "precision": { "type": "string", "minLength": 1 }, "sourceRefs": { "type": "array", "items": { "$ref": "#/$defs/sourceRef" } } } },
+    "responseBody": { "type": "object", "additionalProperties": false, "required": ["kind", "ordering"], "properties": { "kind": { "enum": ["array", "object", "scalar", "empty", "unknown"] }, "itemSchemaRef": { "type": "string", "minLength": 1 }, "ordering": { "enum": ["specified", "unspecified", "not-applicable"] }, "description": { "type": "string", "minLength": 1 } } },
     "errorCase": { "type": "object", "additionalProperties": false, "required": ["description"], "properties": { "status": { "type": "integer", "minimum": 400, "maximum": 599 }, "code": { "type": "string", "minLength": 1 }, "messageField": { "type": "string", "minLength": 1 }, "description": { "type": "string", "minLength": 1 } } },
     "acceptanceCriterion": { "type": "object", "additionalProperties": false, "required": ["id", "text", "sourceRef"], "properties": { "id": { "type": "string", "pattern": "^AC-[A-Z0-9]+(-[A-Z0-9]+)*$" }, "text": { "type": "string", "minLength": 1 }, "sourceRef": { "$ref": "#/$defs/sourceRef" } } },
-    "endpoint": { "type": "object", "additionalProperties": false, "required": ["id", "method", "path", "requestFields", "responseFields", "successStatuses", "errorCases"], "properties": { "id": { "type": "string", "minLength": 1 }, "method": { "enum": ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"] }, "path": { "type": "string", "pattern": "^/" }, "requestFields": { "type": "array", "items": { "$ref": "#/$defs/field" } }, "responseFields": { "type": "array", "items": { "$ref": "#/$defs/field" } }, "successStatuses": { "type": "array", "items": { "type": "integer", "minimum": 100, "maximum": 399 } }, "errorCases": { "type": "array", "items": { "$ref": "#/$defs/errorCase" } } } },
+    "endpoint": { "type": "object", "additionalProperties": false, "required": ["id", "method", "path", "requestFields", "responseFields", "responseBody", "successStatuses", "errorCases", "sourceRefs"], "properties": { "id": { "type": "string", "minLength": 1 }, "method": { "enum": ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"] }, "path": { "type": "string", "pattern": "^/" }, "requestFields": { "type": "array", "items": { "$ref": "#/$defs/field" } }, "responseFields": { "type": "array", "items": { "$ref": "#/$defs/field" } }, "responseBody": { "$ref": "#/$defs/responseBody" }, "successStatuses": { "type": "array", "items": { "type": "integer", "minimum": 100, "maximum": 399 } }, "errorCases": { "type": "array", "items": { "$ref": "#/$defs/errorCase" } }, "sourceRefs": { "type": "array", "items": { "$ref": "#/$defs/sourceRef" } } } },
     "evidencedDescription": { "type": "object", "additionalProperties": false, "required": ["id", "description", "sourceRef"], "properties": { "id": { "type": "string", "minLength": 1 }, "description": { "type": "string", "minLength": 1 }, "sourceRef": { "$ref": "#/$defs/sourceRef" } } },
     "businessRule": { "type": "object", "additionalProperties": false, "required": ["id", "text", "sourceRef"], "properties": { "id": { "type": "string", "minLength": 1 }, "text": { "type": "string", "minLength": 1 }, "sourceRef": { "$ref": "#/$defs/sourceRef" } } },
     "stateTransition": { "type": "object", "additionalProperties": false, "required": ["from", "to", "trigger", "sourceRef"], "properties": { "from": { "type": "string", "minLength": 1 }, "to": { "type": "string", "minLength": 1 }, "trigger": { "type": "string", "minLength": 1 }, "sourceRef": { "$ref": "#/$defs/sourceRef" } } },