@tea-agent/loop-agent 0.5.0 → 0.7.0

package/dist/worker/runner/run-ready.js

@@ -2,10 +2,10 @@ import { createHash } from "node:crypto";
 import { readFile, writeFile, mkdir } from "node:fs/promises";
 import path from "node:path";
 import YAML from "yaml";
-import { deriveFailureRoute } from "../pool/failure-routing.js";
+import { deriveFailureRoute, deriveFailureRouteFromError, } from "../pool/failure-routing.js";
 import { findRunByWorkerRunId, getTaskPoolRoot, readAllTaskPoolStates, recordTaskPoolRun, writeTaskPoolState, } from "../pool/run-store.js";
 import { runTaskSpec, } from "../run-task/run-task.js";
-import { formatDuration, noopProgressReporter } from "../progress-reporter.js";
+import { formatDuration, noopProgressReporter, } from "../progress-reporter.js";
 import { computeReadyQueue } from "../task-graph/ready-queue.js";
 import { taskGraphSpecSchema } from "../task-graph/task-graph-schema.js";
 import { taskSpecSchema } from "../task-spec/schema.js";
@@ -23,18 +23,43 @@ export async function runReadyTasks(options) {
     const total = limitedTaskIds.length;
     let index = 0;
     const batchStartedAt = Date.now();
+    emit(progress, {
+        type: "readyQueue.computed",
+        source: "worker",
+        label: `ready queue: ${total} task${total === 1 ? "" : "s"} ready`,
+        batchRunId,
+    });
     progress.batch(`batch ${batchRunId}: feature=${graph.feature_id}, ${total} task${total === 1 ? "" : "s"} ready → starting`);
+    emit(progress, {
+        type: "batch.started",
+        source: "worker",
+        label: `batch ${batchRunId}: feature=${graph.feature_id}, ${total} task${total === 1 ? "" : "s"} ready`,
+        batchRunId,
+        status: "running",
+    });
     for (const taskId of limitedTaskIds) {
         index += 1;
         const node = graph.nodes.find((candidate) => candidate.id === taskId);
         const taskSpecPath = path.join(options.featureDir, "tasks", node?.task ?? `${taskId}.yaml`);
         const taskSpec = await loadTaskSpec(taskSpecPath);
-        const workerRunId = options.workerRunIdForTask?.(taskId, taskSpec) ??
-            buildStableWorkerRunId(taskId, taskSpec, now);
+        const retryOfWorkerRunId = states[taskId]?.retryOfWorkerRunId;
+        const workerRunId = retryOfWorkerRunId
+            ? buildRetryWorkerRunId(taskId, retryOfWorkerRunId, now)
+            : options.workerRunIdForTask?.(taskId, taskSpec) ??
+                buildStableWorkerRunId(taskId, taskSpec, now);
         if (workerRunId) {
             const existing = await findRunByWorkerRunId(options.repoRoot, workerRunId);
             if (existing) {
                 progress.task(`task ${index}/${total} ${taskId}: reuse existing run ${workerRunId}`);
+                emit(progress, {
+                    type: "task.reused",
+                    source: "worker",
+                    label: `task ${taskId}: reuse existing run ${workerRunId}`,
+                    batchRunId,
+                    taskId,
+                    workerRunId,
+                    status: "reused",
+                });
                 tasks.push({
                     taskId,
                     workerRunId,
@@ -46,6 +71,15 @@ export async function runReadyTasks(options) {
         }
         const taskStartedAt = Date.now();
         progress.task(`task ${index}/${total} ${taskId} "${taskSpec.title}" (${workerRunId})`);
+        emit(progress, {
+            type: "task.started",
+            source: "worker",
+            label: `task ${index}/${total} ${taskId}`,
+            batchRunId,
+            taskId,
+            workerRunId,
+            status: "running",
+        });
         progress.step(`preflight → materialize → dag-run-task → validate → run-dag → report`);
         let result;
         try {
@@ -54,6 +88,16 @@ export async function runReadyTasks(options) {
                 status: "Running",
                 updatedAt: new Date().toISOString(),
                 workerRunId,
+                ...(retryOfWorkerRunId ? { retryOfWorkerRunId } : {}),
+            });
+            emit(progress, {
+                type: "state.updated",
+                source: "worker",
+                label: `task pool state: ${taskId} → Running`,
+                batchRunId,
+                taskId,
+                workerRunId,
+                status: "running",
             });
             result = await runner({
                 repoRoot: options.repoRoot,
@@ -72,7 +116,18 @@ export async function runReadyTasks(options) {
         }
         catch (error) {
             const message = errorMessage(error);
+            const failure = deriveFailureRouteFromError(message, taskId);
             progress.note(`task ${taskId}: ERROR ${message}`);
+            emit(progress, {
+                type: "task.finished",
+                source: "worker",
+                label: `task ${taskId} run-error`,
+                batchRunId,
+                taskId,
+                workerRunId,
+                status: "failed",
+                message,
+            });
             try {
                 await recordTaskPoolRun({
                     repoRoot: options.repoRoot,
@@ -85,6 +140,8 @@ export async function runReadyTasks(options) {
                         status: "run-error",
                         recordedAt: new Date().toISOString(),
                         error: message,
+                        failure,
+                        ...(retryOfWorkerRunId ? { retryOfWorkerRunId } : {}),
                     },
                 });
             }
@@ -106,6 +163,29 @@ export async function runReadyTasks(options) {
             continue;
         }
         const failure = deriveFailureRoute(result);
+        emit(progress, {
+            type: "task.finished",
+            source: "worker",
+            label: `task ${taskId} ${result.status}`,
+            batchRunId,
+            taskId,
+            workerRunId: result.workerRunId,
+            status: result.status,
+            durationMs: Date.now() - taskStartedAt,
+        });
+        if (failure) {
+            emit(progress, {
+                type: "failure.routed",
+                source: "worker",
+                label: `failure routed: ${failure.category}`,
+                batchRunId,
+                taskId,
+                workerRunId: result.workerRunId,
+                failureCategory: failure.category,
+                recommendedFollowUp: failure.recommendedFollowUpKind,
+                status: "failed",
+            });
+        }
         if (result.status === "succeeded") {
             progress.step(`✓ ${taskId} succeeded in ${formatDuration(Date.now() - taskStartedAt)} (promoted + closed out)`);
         }
@@ -124,6 +204,7 @@ export async function runReadyTasks(options) {
             dagPath: result.dagPath,
             recordedAt: new Date().toISOString(),
             ...(failure ? { failure } : {}),
+            ...(retryOfWorkerRunId ? { retryOfWorkerRunId } : {}),
             ...(result.failureArtifacts ? { failureArtifacts: result.failureArtifacts } : {}),
         };
         try {
@@ -160,8 +241,22 @@ export async function runReadyTasks(options) {
     await mkdir(path.dirname(batchRunPath), { recursive: true });
     await writeFile(batchRunPath, `${JSON.stringify(output, null, 2)}\n`, "utf-8");
     progress.batch(`batch ${batchRunId} ${output.status}: ${summary.succeeded} succeeded, ${summary.failed} failed, ${summary.reused} reused in ${formatDuration(Date.now() - batchStartedAt)} → ${batchRunPath}`);
+    emit(progress, {
+        type: "batch.finished",
+        source: "worker",
+        label: `batch ${batchRunId} ${output.status}`,
+        batchRunId,
+        status: output.status === "completed" ? "succeeded" : "failed",
+        durationMs: Date.now() - batchStartedAt,
+    });
     return output;
 }
+function emit(progress, input) {
+    const structured = progress;
+    if (typeof structured.event !== "function")
+        return;
+    void structured.event(input).catch(() => { });
+}
 export function buildBatchRunId(now) {
     return `batch-${now.toISOString().replace(/[-:.]/g, "").slice(0, 15)}`;
 }
@@ -177,6 +272,19 @@ export function buildStableWorkerRunId(taskId, taskSpec, now) {
         .slice(0, 10);
     return `wr-${date}-${slug}-${hash}`;
 }
+/** A retry is a distinct execution attempt and must not collide with failed evidence. */
+export function buildRetryWorkerRunId(taskId, previousWorkerRunId, now) {
+    const date = now.toISOString().slice(0, 10).replace(/-/g, "");
+    const slug = taskId
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    const hash = createHash("sha256")
+        .update(`${previousWorkerRunId}:${now.toISOString()}`)
+        .digest("hex")
+        .slice(0, 10);
+    return `wr-${date}-${slug}-retry-${hash}`;
+}
 async function loadTaskGraph(featureDir) {
     const graphPath = path.join(featureDir, "tasks", "task-graph.yaml");
     return taskGraphSpecSchema.parse(YAML.parse(await readFile(graphPath, "utf-8")));

package/dist/worker/task-spec/schema.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { verifyModeSchema, verifyPresetSchema, verifyQuotaSchema, } from "../../task/config-types.js";
+import { taskCapabilitySchema, verifyModeSchema, verifyPresetSchema, verifyQuotaSchema, } from "../../task/config-types.js";
 export const taskSpecTypeSchema = z.enum([
     "architecture",
     "backend-feature",
@@ -42,6 +42,7 @@ export const taskSpecSchema = z
     type: taskSpecTypeSchema,
     priority: z.enum(["P0", "P1", "P2", "P3"]).optional().default("P2"),
     risk_level: taskSpecRiskLevelSchema,
+    capabilities: z.array(taskCapabilitySchema).optional(),
     depends_on: z.array(z.string().min(1)).optional().default([]),
     source_docs: z
         .object({