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

package/dist/worker/cli.js

@@ -14,10 +14,15 @@ import { createCompositeProgressReporter } from "./observability/progress-compos
 import { createRoutedWorkerEventStore } from "./observability/event-store.js";
 import { buildGlobalSnapshot } from "./observability/read-model.js";
 import { createObserveServer } from "./observe/server.js";
-import { getTaskPoolRoot, prepareTaskPoolRetry } from "./pool/run-store.js";
+import { diagnoseTaskPoolStates, formatDoctorHuman, loadOperatorMapping } from "./pool/doctor.js";
+import { migrateTaskPoolStates } from "./pool/migrate-state.js";
+import { getTaskPoolRoot, prepareTaskPoolRetry, readFeatureTaskPoolStates } from "./pool/run-store.js";
+import { TaskPoolStateError } from "./pool/types.js";
 import { taskSpecSchema } from "./task-spec/schema.js";
 import { validateTaskSpec } from "./task-spec/validate.js";
 import { validateFeatureTaskGraph } from "./task-graph/validate.js";
+import { taskGraphSpecSchema } from "./task-graph/task-graph-schema.js";
+import { planReadyTasks } from "./task-graph/ready-planner.js";
 import { renderFeatureReview, reviewFeature } from "./feature/review.js";
 import { renderFeatureRun, runFeature } from "./feature/run.js";
 import { draftFollowUpDecision } from "./follow-up/factory.js";
@@ -40,6 +45,58 @@ export function buildAgentWorkerProgram() {
     const report = program.command("report").description("Task Pool reporting utilities");
     const observe = program.command("observe").description("Observe UI server and snapshot utilities");
     const feature = program.command("feature").description("Feature-level review and delivery workflow");
+    const pool = program.command("pool").description("Task Pool state doctor and migration utilities");
+    pool
+        .command("doctor")
+        .requiredOption("--repo <repo-root>", "Target repo root")
+        .option("--json", "Emit stable JSON instead of the human summary")
+        .option("--mapping <file>", "Optional operator mapping JSON (taskId -> featureId)")
+        .description("Inventory legacy and v2 Task Pool states (read-only)")
+        .action(async (options) => {
+        const repoRoot = path.resolve(options.repo);
+        const mapping = await loadOperatorMapping(options.mapping);
+        const report = await diagnoseTaskPoolStates(repoRoot, { mapping });
+        process.stdout.write(options.json ? `${JSON.stringify(report, null, 2)}\n` : formatDoctorHuman(report));
+    });
+    pool
+        .command("migrate-state")
+        .requiredOption("--repo <repo-root>", "Target repo root")
+        .option("--dry-run", "Plan migration without writes (default when --apply is omitted)")
+        .option("--apply", "Apply migration (requires --owner and --reason)")
+        .option("--owner <owner>", "Migration owner for apply")
+        .option("--reason <reason>", "Why migration is being applied")
+        .option("--mapping <file>", "Optional operator mapping JSON (taskId -> featureId)")
+        .option("--json", "Emit stable JSON")
+        .description("Migrate legacy flat Task Pool states to feature-scoped v2 (default dry-run)")
+        .action(async (options) => {
+        try {
+            const result = await migrateTaskPoolStates({
+                repoRoot: path.resolve(options.repo),
+                apply: options.apply === true,
+                ...(options.owner ? { owner: options.owner } : {}),
+                ...(options.reason ? { reason: options.reason } : {}),
+                ...(options.mapping ? { mappingPath: options.mapping } : {}),
+            });
+            process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+            if (result.status === "failed")
+                process.exitCode = 1;
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            const code = error instanceof TaskPoolStateError ? error.code : "task-pool-migrate-failed";
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify({
+                    schemaVersion: 1,
+                    status: "failed",
+                    error: { code, message: detail },
+                }, null, 2)}\n`);
+            }
+            else {
+                process.stderr.write(`${detail}\n`);
+            }
+            process.exitCode = 1;
+        }
+    });
     feature
         .command("review")
         .requiredOption("--feature-dir <dir>", "Feature directory containing acceptance.yaml and tasks/")
@@ -206,12 +263,14 @@ export function buildAgentWorkerProgram() {
         .command("retry")
         .argument("<task-id>", "Failed Task Pool task to requeue")
         .requiredOption("--repo <repo-root>", "Target repo root")
+        .option("--feature-id <feature-id>", "Canonical Feature id for the Task Pool state (required when identity is ambiguous)")
         .option("--reason <reason>", "Why the failure is safe to retry")
         .description("Explicitly requeue a failed task; the next run-ready uses a new workerRunId")
         .action(async (taskId, options) => {
         const result = await prepareTaskPoolRetry({
             repoRoot: path.resolve(options.repo),
             taskId,
+            ...(options.featureId ? { featureId: options.featureId } : {}),
             ...(options.reason ? { reason: options.reason } : {}),
         });
         process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
@@ -268,6 +327,42 @@ export function buildAgentWorkerProgram() {
             handleFollowUpCliError(error, options.json ?? false, "approve-followup");
         }
     });
+    batch
+        .command("plan-ready")
+        .requiredOption("--feature-dir <dir>", "Feature directory containing tasks/task-graph.yaml")
+        .requiredOption("--repo <repo-root>", "Target repo root")
+        .option("--limit <count>", "Maximum ready tasks to select")
+        .option("--json", "Emit stable JSON (default human summary)")
+        .description("Preview the read-only priority-aware ready plan without writing state or artifacts")
+        .action(async (options) => {
+        // Strict zero-write preview: load graph + specs + feature-scoped states only.
+        const featureDir = path.resolve(options.featureDir);
+        const repoRoot = path.resolve(options.repo);
+        const graph = taskGraphSpecSchema.parse(YAML.parse(await readFile(path.join(featureDir, "tasks", "task-graph.yaml"), "utf-8")));
+        const taskSpecs = new Map();
+        for (const node of graph.nodes) {
+            const taskFile = node.task ?? `${node.id}.yaml`;
+            taskSpecs.set(node.id, taskSpecSchema.parse(YAML.parse(await readFile(path.join(featureDir, "tasks", taskFile), "utf-8"))));
+        }
+        const selectionLimit = options.limit
+            ? Number.parseInt(options.limit, 10)
+            : graph.nodes.length;
+        if (!Number.isInteger(selectionLimit) || selectionLimit < 1) {
+            process.stderr.write("selectionLimit must be a positive integer\n");
+            process.exitCode = 1;
+            return;
+        }
+        const plan = planReadyTasks({
+            featureId: graph.feature_id,
+            graph,
+            taskSpecs,
+            states: await readFeatureTaskPoolStates(repoRoot, graph.feature_id),
+            selectionLimit,
+        });
+        process.stdout.write(options.json
+            ? `${JSON.stringify(plan, null, 2)}\n`
+            : `Selected: ${plan.selected.map((task) => task.taskId).join(", ") || "none"}\nDeferred: ${plan.deferred.map((task) => task.taskId).join(", ") || "none"}\nBlocked: ${plan.blocked.length}\n`);
+    });
     batch
         .command("run-ready")
         .requiredOption("--feature-dir <dir>", "Feature directory containing tasks/task-graph.yaml")

package/dist/worker/delivery/package.js

@@ -6,7 +6,7 @@ import { promisify } from "node:util";
 import YAML from "yaml";
 import { z } from "zod";
 import { controllerIdentitiesMatch, LOOP_AGENT_PACKAGE_NAME, } from "../loop-agent/loop-agent-client.js";
-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 { validateFeatureTaskGraph } from "../task-graph/validate.js";
@@ -104,7 +104,7 @@ export async function prepareFeatureDelivery(input) {
     }
     const acceptance = acceptanceSpecSchema.parse(YAML.parse(await readFile(path.join(featureDir, "acceptance.yaml"), "utf-8")));
     const graph = taskGraphSpecSchema.parse(YAML.parse(await readFile(path.join(featureDir, "tasks", "task-graph.yaml"), "utf-8")));
-    const states = await readAllTaskPoolStates(repoRoot);
+    const states = await readFeatureTaskPoolStates(repoRoot, featureId);
     const runs = await readJsonlFile(getRunsJsonlPath(repoRoot));
     const taskSpecs = new Map();
     for (const node of graph.nodes)
@@ -208,7 +208,7 @@ export async function validateDeliveryPackage(input) {
         blockers.push(`Git worktree is not clean for Closeout: ${closeoutStatus}`);
     const graph = taskGraphSpecSchema.parse(YAML.parse(await readFile(path.join(featureDir, "tasks", "task-graph.yaml"), "utf-8")));
     const acceptance = acceptanceSpecSchema.parse(YAML.parse(await readFile(path.join(featureDir, "acceptance.yaml"), "utf-8")));
-    const states = await readAllTaskPoolStates(repoRoot);
+    const states = await readFeatureTaskPoolStates(repoRoot, featureId);
     const specs = new Map();
     for (const node of graph.nodes)
         specs.set(node.id, taskSpecSchema.parse(YAML.parse(await readFile(path.join(featureDir, "tasks", node.task), "utf-8"))));

package/dist/worker/feature/decision-loader.js

@@ -46,16 +46,47 @@ async function auditTaskPoolFacts(repoRoot) {
     }
     const stateDir = path.join(getTaskPoolRoot(repoRoot), "states");
     try {
-        for (const entry of await readdir(stateDir))
-            if (entry.endsWith(".json"))
+        for (const entry of await readdir(stateDir, { withFileTypes: true })) {
+            if (entry.isFile() && entry.name.endsWith(".json")) {
                 try {
-                    const parsed = taskPoolStateFactSchema.safeParse(JSON.parse(await readFile(path.join(stateDir, entry), "utf-8")));
-                    if (!parsed.success || parsed.data.taskId !== entry.slice(0, -5))
-                        warnings.push(`Task Pool state is semantically invalid: ${entry}`);
+                    const parsed = taskPoolStateFactSchema.safeParse(JSON.parse(await readFile(path.join(stateDir, entry.name), "utf-8")));
+                    if (!parsed.success || parsed.data.taskId !== entry.name.slice(0, -5)) {
+                        warnings.push(`Task Pool state is semantically invalid: ${entry.name}`);
+                    }
+                    else {
+                        warnings.push(`legacy Task Pool state requires migration: ${entry.name}`);
+                    }
                 }
                 catch {
-                    warnings.push(`Task Pool state is corrupt: ${entry}`);
+                    warnings.push(`Task Pool state is corrupt: ${entry.name}`);
                 }
+                continue;
+            }
+            if (!entry.isDirectory())
+                continue;
+            const featureId = entry.name;
+            try {
+                for (const stateName of await readdir(path.join(stateDir, featureId))) {
+                    if (!stateName.endsWith(".json"))
+                        continue;
+                    const relative = `${featureId}/${stateName}`;
+                    try {
+                        const parsed = taskPoolStateFactSchema.safeParse(JSON.parse(await readFile(path.join(stateDir, featureId, stateName), "utf-8")));
+                        const expectedTaskId = stateName.slice(0, -5);
+                        if (!parsed.success || parsed.data.taskId !== expectedTaskId || parsed.data.featureId !== featureId) {
+                            warnings.push(`Task Pool state is semantically invalid: ${relative}`);
+                        }
+                    }
+                    catch {
+                        warnings.push(`Task Pool state is corrupt: ${relative}`);
+                    }
+                }
+            }
+            catch (error) {
+                if (!isNotFound(error))
+                    warnings.push(`Task Pool states for ${featureId} are unreadable: ${message(error)}`);
+            }
+        }
     }
     catch (error) {
         if (!isNotFound(error))

package/dist/worker/feature/next-action.js

@@ -35,7 +35,7 @@ export function projectNextAction(input, status) {
             return {
                 kind: "retry_task",
                 label: `重试环境失败任务 ${failed.taskId}`,
-                command: `agent-worker task retry ${quote(failed.taskId)} --repo ${quote(input.repoRoot)}`,
+                command: `agent-worker task retry ${quote(failed.taskId)} --feature-id ${quote(input.featureId)} --repo ${quote(input.repoRoot)}`,
             };
         }
         return {
@@ -51,9 +51,17 @@ export function projectNextAction(input, status) {
         };
     }
     if (status === "ready") {
+        const selected = input.planning?.selected[0];
+        const deferredCount = input.planning?.deferred.length ?? 0;
+        const blockedCount = input.planning?.blocked.length ?? 0;
+        const reasonSuffix = selected && (deferredCount > 0 || blockedCount > 0)
+            ? `；deferred ${deferredCount} / blocked ${blockedCount}`
+            : "";
         return {
             kind: "run_feature",
-            label: "执行当前 Ready tasks",
+            label: selected
+                ? `执行最高优先级 Ready task ${selected.taskId} (${selected.priority})${reasonSuffix}`
+                : "执行当前 Ready tasks",
             command: `agent-worker batch run-ready ${featureArgs}`,
         };
     }

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(),