@tea-agent/loop-agent 0.12.0 → 0.13.0-alpha.0

package/dist/worker/feature/ready-plan-projection.js

@@ -0,0 +1,81 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import YAML from "yaml";
+import { planReadyTasks, } from "../task-graph/ready-planner.js";
+import { taskGraphSpecSchema } from "../task-graph/task-graph-schema.js";
+import { taskSpecSchema } from "../task-spec/schema.js";
+/** Single Feature-side entry to M1 planReadyTasks; never reimplements ordering. */
+export function projectReadyPlan(input) {
+    return planReadyTasks(input);
+}
+/**
+ * Apply a tighter selectionLimit to an existing planner projection.
+ * Eligible order is preserved from planReadyTasks; this does not re-sort.
+ */
+export function applySelectionLimit(plan, selectionLimit) {
+    if (!Number.isInteger(selectionLimit) || selectionLimit < 1) {
+        throw new Error("selectionLimit must be a positive integer");
+    }
+    const selected = plan.eligible.slice(0, selectionLimit);
+    const deferred = plan.eligible.slice(selectionLimit).map((candidate) => ({
+        ...candidate,
+        reasonCode: "selection-limit",
+        selectedAhead: selected.map((item) => item.taskId),
+    }));
+    return {
+        ...plan,
+        selectionLimit,
+        selected,
+        deferred,
+        summary: {
+            ...plan.summary,
+            selected: selected.length,
+            deferred: deferred.length,
+        },
+    };
+}
+export function selectedTaskIds(plan) {
+    return plan.selected.map((item) => item.taskId);
+}
+export function summarizePlanReasons(plan) {
+    return {
+        selected: plan.selected.map((item) => ({ taskId: item.taskId, priority: item.priority })),
+        deferred: plan.deferred.map((item) => ({
+            taskId: item.taskId,
+            reasonCode: item.reasonCode,
+            selectedAhead: item.selectedAhead,
+        })),
+        blocked: plan.blocked.map((item) => ({
+            taskId: item.taskId,
+            reasonCode: item.reasonCode,
+            reason: item.reason,
+            blockedBy: item.blockedBy,
+        })),
+    };
+}
+export async function loadReadyPlanInputs(featureDir) {
+    const resolved = path.resolve(featureDir);
+    const graphRaw = YAML.parse(await readFile(path.join(resolved, "tasks", "task-graph.yaml"), "utf-8"));
+    const graph = taskGraphSpecSchema.parse(graphRaw);
+    const taskSpecs = new Map();
+    for (const node of graph.nodes) {
+        const value = YAML.parse(await readFile(path.join(resolved, "tasks", node.task), "utf-8"));
+        taskSpecs.set(node.id, taskSpecSchema.parse(value));
+    }
+    return { featureId: graph.feature_id, graph, taskSpecs };
+}
+export async function projectReadyPlanForFeature(input) {
+    try {
+        const loaded = await loadReadyPlanInputs(input.featureDir);
+        return projectReadyPlan({
+            featureId: input.featureId || loaded.featureId,
+            graph: loaded.graph,
+            taskSpecs: loaded.taskSpecs,
+            states: input.states,
+            selectionLimit: input.selectionLimit,
+        });
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/worker/feature/reducer.js

@@ -10,7 +10,7 @@ const STATUS_LABELS = {
 };
 export function reduceFeature(input) {
     const status = deriveStatus(input);
-    const readyTasks = input.tasks.filter((task) => isReady(task.taskId, input));
+    const readyTasks = input.planning?.eligible ?? input.tasks.filter((task) => isReady(task.taskId, input));
     const blockingItems = [];
     const resolvedFailures = new Set(input.resolvedFailureTaskIds ?? []);
     for (const error of input.validationErrors) {
@@ -88,6 +88,7 @@ export function reduceFeature(input) {
             closeout: input.closeout?.path ?? null,
         },
         projectionWarnings: [...input.projectionWarnings],
+        ...(input.planning ? { planning: input.planning } : {}),
     };
 }
 function deriveStatus(input) {

package/dist/worker/feature/review.js

@@ -3,12 +3,14 @@ import { access, readFile, realpath } from "node:fs/promises";
 import path from "node:path";
 import YAML from "yaml";
 import { z } from "zod";
-import { getRunsJsonlPath, getTaskPoolRoot, readAllTaskPoolStates, readJsonlFile } from "../pool/run-store.js";
+import { getRunsJsonlPath, getTaskPoolRoot, readFeatureTaskPoolStates, readJsonlFile } from "../pool/run-store.js";
 import { acceptanceSpecSchema } from "../task-graph/acceptance-schema.js";
 import { taskGraphSpecSchema } from "../task-graph/task-graph-schema.js";
+import { taskSpecSchema } from "../task-spec/schema.js";
 import { validateFeatureTaskGraph } from "../task-graph/validate.js";
 import { followUpActionCardSchema, followUpApprovalSchema, followUpDraftSchema, followUpEvidenceSchema } from "../follow-up/schema.js";
 import { readFollowUpIndex, resolveRepoFile, sha256File as sha256FollowUpFile } from "../follow-up/store.js";
+import { projectReadyPlan } from "./ready-plan-projection.js";
 import { reduceFeature } from "./reducer.js";
 export async function reviewFeature(input) {
     const projection = await loadFeatureProjection(input);
@@ -67,7 +69,7 @@ async function loadFeatureProjection(input) {
     let states = {};
     let runs = [];
     try {
-        states = await readAllTaskPoolStates(repoRoot);
+        states = await readFeatureTaskPoolStates(repoRoot, validation.featureId);
         runs = await readJsonlFile(getRunsJsonlPath(repoRoot));
     }
     catch (error) {
@@ -86,6 +88,20 @@ async function loadFeatureProjection(input) {
         return valid;
     });
     const graphNodes = graph.success ? graph.data.nodes : [];
+    let planning;
+    if (graph.success) {
+        try {
+            const taskSpecs = new Map();
+            for (const node of graph.data.nodes) {
+                const value = YAML.parse(await readFile(path.join(featureDir, "tasks", node.task), "utf-8"));
+                taskSpecs.set(node.id, taskSpecSchema.parse(value));
+            }
+            planning = projectReadyPlan({ featureId: validation.featureId, graph: graph.data, taskSpecs, states, selectionLimit: Math.max(graph.data.nodes.length, 1) });
+        }
+        catch (error) {
+            projectionWarnings.push(`Ready Planner projection is unavailable: ${message(error)}`);
+        }
+    }
     let pendingFollowUps = [];
     let actionCards = [];
     let resolvedFailureTaskIds = [];
@@ -292,6 +308,7 @@ async function loadFeatureProjection(input) {
         ...((await exists(morningReportPath)) ? { morningReport: morningReportPath } : {}),
         ...((await exists(observeSnapshotPath)) ? { observeSnapshot: observeSnapshotPath } : {}),
         projectionWarnings,
+        ...(planning ? { planning } : {}),
     };
 }
 async function exists(filePath) {

package/dist/worker/feature/run.js

@@ -5,11 +5,12 @@ import { buildGlobalSnapshot } from "../observability/read-model.js";
 import { createSnapshotStore } from "../observability/snapshot-store.js";
 import { preflightTargetRepo } from "../preflight.js";
 import { noopProgressReporter } from "../progress-reporter.js";
-import { getTaskPoolRoot } from "../pool/run-store.js";
+import { getTaskPoolRoot, listLegacyStateFiles } from "../pool/run-store.js";
 import { writeMorningReport } from "../report/morning-report.js";
 import { buildBatchRunId, runReadyTasks } from "../runner/run-ready.js";
 import { validateFeatureTaskGraph } from "../task-graph/validate.js";
 import { reviewFeature } from "./review.js";
+import { applySelectionLimit, selectedTaskIds } from "./ready-plan-projection.js";
 import { finalizeGitTask, startGitTransaction } from "../delivery/git-transaction.js";
 export async function runFeature(options) {
     const featureDir = path.resolve(options.featureDir);
@@ -125,7 +126,13 @@ export async function runFeature(options) {
             controllerIdentity });
     }
     before = beforeStep.value;
-    const readyTasks = before.tasks.filter((task) => task.status === "Ready").map((task) => task.taskId);
+    const fullReadyPlan = before.planning;
+    const readyPlan = fullReadyPlan
+        ? applySelectionLimit(fullReadyPlan, limitApplied)
+        : undefined;
+    const readyTasks = readyPlan
+        ? selectedTaskIds(readyPlan)
+        : before.tasks.filter((task) => task.status === "Ready").map((task) => task.taskId);
     if (options.dryRun) {
         steps.push({ ...planned("run-ready", readyTasks.length > 0 ? `execute at most ${limitApplied} Ready task` : "no Ready task"), artifacts: [expectedArtifacts.batchRun] }, { ...planned("morning-report", "refresh morning report"), artifacts: [expectedArtifacts.morningReport] }, { ...planned("observe-snapshot", "refresh Observe snapshot"), artifacts: [expectedArtifacts.observeSnapshot] }, planned("review-after", "derive final Feature review"));
         return {
@@ -138,6 +145,7 @@ export async function runFeature(options) {
             statusAfter: before.status,
             steps,
             readyTasks,
+            ...(readyPlan ? { readyPlan } : {}),
             executedTasks: [],
             artifacts: { batchRun: null, morningReport: null, observeSnapshot: null, ...(checkpointMode ? { gitTransaction: expectedArtifacts.gitTransaction ?? null } : {}) },
             expectedArtifacts,
@@ -151,6 +159,22 @@ export async function runFeature(options) {
         };
     }
     if (readyTasks.length > 0 && limitApplied > 0) {
+        const legacyStates = await listLegacyStateFiles(repoRoot);
+        if (legacyStates.length > 0) {
+            return failedResult({
+                featureId,
+                mode: "executed",
+                steps,
+                limitApplied,
+                code: "task-pool-state-migration-required",
+                message: `cannot execute Ready tasks while legacy Task Pool states require migration: ${legacyStates.map((item) => item.taskId).join(", ")}`,
+                evidence: legacyStates.map((item) => item.path),
+                expectedArtifacts,
+                controllerIdentity,
+                before,
+                readyTasks,
+            });
+        }
         progress.batch(`feature ${featureId}: executing ${Math.min(readyTasks.length, limitApplied)} of ${readyTasks.length} Ready task(s)`);
         const runStep = await timedStep(steps, "run-ready", async () => dependencies.runReady({
             repoRoot,
@@ -226,6 +250,7 @@ export async function runFeature(options) {
         statusAfter: after.value.status,
         steps,
         readyTasks,
+        ...(readyPlan ? { readyPlan } : {}),
         executedTasks: batch?.tasks ?? [],
         artifacts: { batchRun: batch?.batchRunPath ?? null, morningReport: report.value, observeSnapshot: snapshot.value, ...(gitTransaction ? { gitTransaction: gitTransaction.recordPath } : {}) },
         expectedArtifacts,

package/dist/worker/follow-up/approve.js

@@ -99,6 +99,8 @@ async function executeApproval(input) {
         }
         await input.faultInjector?.("before-state-write");
         await writeTaskPoolState(input.repoRoot, {
+            schemaVersion: 2,
+            featureId: input.featureId,
             taskId: loaded.draft.proposed_task_id,
             status: "Ready",
             updatedAt: (input.now ?? new Date()).toISOString(),
@@ -201,7 +203,7 @@ async function loadApprovalInputs(input) {
         entry, draft, draftPath, evidencePath, approvalPath, existingApproval,
         taskSpecPath: path.join(input.featureDir, "tasks", `${draft.proposed_task_id}.yaml`),
         graphPath: path.join(input.featureDir, "tasks", "task-graph.yaml"),
-        statePath: getTaskStatePath(input.repoRoot, draft.proposed_task_id),
+        statePath: getTaskStatePath(input.repoRoot, { featureId: input.featureId, taskId: draft.proposed_task_id }),
         featureId: input.featureId,
         featureDir: input.featureDir,
         repoRoot: input.repoRoot,
@@ -237,8 +239,9 @@ async function assertApprovalPreconditions(loaded) {
     const graph = taskGraphSpecSchema.parse(YAML.parse(await readFile(loaded.graphPath, "utf-8")));
     if (graph.nodes.some((node) => node.id === loaded.draft.proposed_task_id))
         throw new Error(`proposed graph node already exists: ${loaded.draft.proposed_task_id}`);
-    if (await readTaskPoolState(loaded.repoRoot, loaded.draft.proposed_task_id))
+    if (await readTaskPoolState(loaded.repoRoot, { featureId: loaded.featureId, taskId: loaded.draft.proposed_task_id })) {
         throw new Error(`Task Pool state already exists: ${loaded.draft.proposed_task_id}`);
+    }
 }
 function resultFromApproval(approval, repoRoot, approvalPath, idempotent) {
     return {

package/dist/worker/follow-up/factory.js

@@ -99,7 +99,7 @@ export async function draftFollowUpDecision(input, productBugOnly = false) {
                     generated_from: { feature_id: run.featureId, task_id: input.taskId, worker_run_id: input.workerRunId, failure_category: category },
                     action: policy.action,
                     label: policy.label,
-                    ...(policy.recommendedCommand === "task-retry" ? { command: `agent-worker task retry ${JSON.stringify(input.taskId)} --repo ${JSON.stringify(repoRoot)}` } : {}),
+                    ...(policy.recommendedCommand === "task-retry" ? { command: `agent-worker task retry ${JSON.stringify(input.taskId)} --feature-id ${JSON.stringify(run.featureId)} --repo ${JSON.stringify(repoRoot)}` } : {}),
                     evidence_refs: evidenceRefs,
                     dedupe_key: dedupeKey,
                     created_at: (input.now ?? new Date()).toISOString(),