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

package/dist/commands/knowledge.js

@@ -1,41 +1,104 @@
 import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
 import { curateKnowledgePatterns } from "../workflows/dag/knowledge-curator.js";
+export const KNOWLEDGE_CLI_SUBCOMMANDS = [
+    "curate",
+    "query",
+    "graph-init",
+    "graph-materialize",
+    "graph-promote",
+    "graph-incremental-prepare",
+];
+const USAGE = "usage: knowledge <curate|query|graph-init|graph-materialize|graph-promote|graph-incremental-prepare> ...";
+function packageRoot() {
+    // dist/commands/knowledge.js or src/commands/knowledge.ts → package/repo root
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+}
+function resolveScript(repoRoot, fileName) {
+    const candidates = [
+        path.join(repoRoot, "scripts", fileName),
+        path.join(packageRoot(), "scripts", fileName),
+    ];
+    for (const c of candidates) {
+        if (existsSync(c))
+            return c;
+    }
+    throw new Error(`knowledge script not found: ${fileName} (looked under repo scripts/ and package scripts/)`);
+}
+function runProcess(command, args, cwd) {
+    const result = spawnSync(command, args, {
+        cwd,
+        encoding: "utf8",
+        stdio: ["inherit", "pipe", "pipe"],
+    });
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+    if (result.error)
+        throw result.error;
+    if (result.status !== 0 && result.status !== null) {
+        process.exitCode = result.status;
+    }
+}
+function runNodeScript(repoRoot, scriptFile, forwardArgs) {
+    const scriptPath = resolveScript(repoRoot, scriptFile);
+    runProcess(process.execPath, [scriptPath, ...forwardArgs], repoRoot);
+}
+function runBashScript(repoRoot, scriptFile, forwardArgs) {
+    const scriptPath = resolveScript(repoRoot, scriptFile);
+    runProcess("bash", [scriptPath, ...forwardArgs], repoRoot);
+}
+function ensureRootFlag(repoRoot, rest) {
+    if (rest.includes("--root"))
+        return rest;
+    return ["--root", repoRoot, ...rest];
+}
 export function parseKnowledgeArgs(args) {
     const [command, ...rest] = args;
-    if (command !== "curate") {
-        throw new Error("usage: knowledge curate [--json|--markdown] [--output <path>]");
+    if (!command ||
+        !KNOWLEDGE_CLI_SUBCOMMANDS.includes(command)) {
+        throw new Error(USAGE);
     }
-    let outputPath;
-    let json = false;
-    let markdown = false;
-    for (let i = 0; i < rest.length; i += 1) {
-        const arg = rest[i];
-        if (arg === "--json") {
-            json = true;
-            continue;
-        }
-        if (arg === "--markdown") {
-            markdown = true;
-            continue;
+    if (command === "curate") {
+        let outputPath;
+        let json = false;
+        let markdown = false;
+        for (let i = 0; i < rest.length; i += 1) {
+            const arg = rest[i];
+            if (arg === "--json") {
+                json = true;
+                continue;
+            }
+            if (arg === "--markdown") {
+                markdown = true;
+                continue;
+            }
+            if (arg === "--output") {
+                outputPath = rest[++i];
+                if (!outputPath) {
+                    throw new Error("knowledge curate --output requires a path");
+                }
+                continue;
+            }
+            if (arg.startsWith("--output=")) {
+                outputPath = arg.slice("--output=".length);
+                continue;
+            }
+            throw new Error(`unknown knowledge curate argument: ${arg}`);
         }
-        if (arg === "--output") {
-            outputPath = rest[++i];
-            if (!outputPath)
-                throw new Error("knowledge curate --output requires a path");
-            continue;
-        }
-        if (arg.startsWith("--output=")) {
-            outputPath = arg.slice("--output=".length);
-            continue;
-        }
-        throw new Error(`unknown knowledge curate argument: ${arg}`);
+        if (!json && !markdown)
+            json = true;
+        return { command: "curate", outputPath, json, markdown };
     }
-    if (!json && !markdown)
-        json = true;
-    return { command, outputPath, json, markdown };
+    return {
+        command: command,
+        forward: rest,
+    };
 }
-export async function runKnowledge(repoRoot, args) {
-    const parsed = parseKnowledgeArgs(args);
+async function runCurate(repoRoot, parsed) {
     const result = await curateKnowledgePatterns({
         repoRoot,
         outputPath: parsed.outputPath,
@@ -50,7 +113,9 @@ export async function runKnowledge(repoRoot, args) {
         console.log(JSON.stringify({
             ok: result.ok,
             patternsPath: path.relative(repoRoot, result.patternsPath),
-            outputPath: result.outputPath ? path.relative(repoRoot, result.outputPath) : undefined,
+            outputPath: result.outputPath
+                ? path.relative(repoRoot, result.outputPath)
+                : undefined,
             patternCount: result.patternCount,
             safetyFindings: result.safetyFindings,
             message: result.message,
@@ -62,3 +127,36 @@ export async function runKnowledge(repoRoot, args) {
         process.stdout.write(result.proposalMarkdown);
     }
 }
+/**
+ * knowledge CLI:
+ * - curate: repair/learned guidance proposals (existing)
+ * - query / graph-*: thin wrappers over scripts/kb-*.{mjs,sh} for graph KB ops
+ */
+export async function runKnowledge(repoRoot, args) {
+    const parsed = parseKnowledgeArgs(args);
+    if (parsed.command === "curate") {
+        await runCurate(repoRoot, parsed);
+        return;
+    }
+    const forward = ensureRootFlag(repoRoot, parsed.forward);
+    switch (parsed.command) {
+        case "query":
+            runNodeScript(repoRoot, "kb-query.mjs", forward);
+            return;
+        case "graph-init":
+            // B1 skeleton is a bash script (no LLM)
+            runBashScript(repoRoot, "kb-bootstrap-init-skeleton.sh", forward);
+            return;
+        case "graph-materialize":
+            runNodeScript(repoRoot, "kb-graph-materialize.mjs", forward);
+            return;
+        case "graph-promote":
+            runNodeScript(repoRoot, "kb-graph-promote.mjs", forward);
+            return;
+        case "graph-incremental-prepare":
+            runNodeScript(repoRoot, "kb-graph-incremental-prepare.mjs", forward);
+            return;
+        default:
+            throw new Error(USAGE);
+    }
+}

package/dist/governance/manifest-types.js

@@ -43,6 +43,9 @@ export const workflowPolicyDagTemplateSchema = z.enum([
     "review-gated-dag",
     "supervised-implementation",
     "frontend-implementation",
+    "backend-test-dag",
+    "knowledge-sync-dag",
+    "knowledge-graph-bootstrap-dag",
 ]);
 export const workflowPolicyOutputLanguageSchema = z.enum(["zh-CN", "en"]);
 export const workflowPolicySchema = z

package/dist/shared/package-metadata.js

@@ -2,7 +2,9 @@ import { createHash } from "node:crypto";
 import { readFileSync, readdirSync, statSync } from "node:fs";
 import { realpathSync } from "node:fs";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { platform } from "node:os";
+export const LOOP_AGENT_PACKAGE_NAME = "@tea-agent/loop-agent";
 // ---------------------------------------------------------------------------
 // Public helpers
 // ---------------------------------------------------------------------------
@@ -351,3 +353,136 @@ function assertRegularFile(filePath, requested) {
     }
     throw new Error(`controller identity: resolved executable for ${JSON.stringify(requested)} is not a readable file: ${filePath}`);
 }
+// ---------------------------------------------------------------------------
+// Running-controller identity (in-process capture)
+// ---------------------------------------------------------------------------
+function safeRealpath(filePath) {
+    try {
+        return realpathSync(filePath);
+    }
+    catch {
+        return filePath;
+    }
+}
+/**
+ * Build a ControllerIdentityV1 from a readable entry file inside a Node package
+ * root. Returns `undefined` when any required identity component cannot be
+ * resolved. This reuses the same ControllerIdentityV1 protocol the Worker uses;
+ * it never invents a second identity shape.
+ */
+export function buildControllerIdentityFromEntry(input) {
+    const resolvedAt = (input.now ?? new Date()).toISOString();
+    const realEntry = safeRealpath(path.resolve(input.entry));
+    try {
+        if (!statSync(realEntry).isFile())
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    const packageRoot = findPackageRoot(path.dirname(realEntry));
+    if (!packageRoot)
+        return undefined;
+    const packageName = readPackageName(packageRoot);
+    if (!packageName)
+        return undefined;
+    const packageVersion = readPackageVersion(packageRoot);
+    if (!packageVersion)
+        return undefined;
+    const binarySha256 = computeBinarySha256(realEntry);
+    if (!binarySha256)
+        return undefined;
+    let packageFingerprint;
+    try {
+        packageFingerprint = computePackageFingerprint(packageRoot);
+    }
+    catch {
+        return undefined;
+    }
+    const isScript = isJavaScriptScript(realEntry);
+    const launch = isScript
+        ? { command: safeRealpath(process.execPath), argsPrefix: [realEntry] }
+        : { command: realEntry, argsPrefix: [] };
+    return {
+        schemaVersion: 1,
+        packageName,
+        binName: path.basename(realEntry),
+        requested: input.requested,
+        entry: path.resolve(input.entry),
+        realEntry,
+        launch,
+        binarySha256,
+        packageRoot,
+        packageVersion,
+        packageFingerprint,
+        resolvedAt,
+    };
+}
+/**
+ * Stable content anchor for a controller identity. Two identities are the same
+ * controller when their anchors are equal. Kept in sync with the Worker anchor
+ * so DAG-owned and Worker-owned identity facts are comparable.
+ */
+export function controllerIdentityAnchor(identity) {
+    return JSON.stringify({
+        schemaVersion: identity.schemaVersion,
+        packageName: identity.packageName,
+        binName: identity.binName,
+        requested: identity.requested,
+        entry: identity.entry,
+        realEntry: identity.realEntry,
+        launch: identity.launch,
+        binarySha256: identity.binarySha256,
+        packageRoot: identity.packageRoot,
+        packageVersion: identity.packageVersion,
+        packageFingerprint: identity.packageFingerprint,
+    });
+}
+export function controllerIdentitiesMatch(left, right) {
+    return Boolean(left && right && controllerIdentityAnchor(left) === controllerIdentityAnchor(right));
+}
+/**
+ * Resolve the identity of the controller that is executing this process.
+ *
+ * Preference order:
+ * 1. The launched CLI entry (argv[1]) when it resolves inside the loop-agent
+ *    package — this is the real controller binary in production.
+ * 2. The package that physically contains this module — always the loop-agent
+ *    package, which keeps identity resolvable under tests and source runs.
+ *
+ * Returns `undefined` when no loop-agent-rooted identity can be built. Callers
+ * treat `undefined` as legacy-unpinned rather than fabricating an identity.
+ */
+export function resolveRunningControllerIdentity(options) {
+    const argv = options?.argv ?? process.argv;
+    const entryArg = argv[1];
+    if (entryArg) {
+        try {
+            const abs = path.resolve(entryArg);
+            const root = findPackageRoot(path.dirname(abs));
+            if (root && readPackageName(root) === LOOP_AGENT_PACKAGE_NAME) {
+                const identity = buildControllerIdentityFromEntry({
+                    requested: entryArg,
+                    entry: abs,
+                    ...(options?.now ? { now: options.now } : {}),
+                });
+                if (identity)
+                    return identity;
+            }
+        }
+        catch {
+            // Fall back to the module location below.
+        }
+    }
+    try {
+        const moduleFile = fileURLToPath(import.meta.url);
+        return buildControllerIdentityFromEntry({
+            requested: entryArg ?? "loop-agent",
+            entry: moduleFile,
+            ...(options?.now ? { now: options.now } : {}),
+        });
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/task/config-types.js

@@ -11,6 +11,9 @@ export const taskKindSchema = z.enum([
     "standard",
     "feature-study",
     "frontend-implementation",
+    "backend-test",
+    "knowledge-sync",
+    "knowledge-graph-bootstrap",
 ]);
 export const referenceRepoConfigSchema = z.object({
     name: z.string().min(1),
@@ -61,8 +64,10 @@ const taskConfigObjectSchema = z.object({
     taskId: z.string(),
     title: z.string(),
     sourceFiles: z.array(z.string()),
-    /** standard: 本仓库需求实现；feature-study: 参考外部代码特性并在目标仓库落地；frontend-implementation: 使用前端实现 DAG 模板 */
+    /** standard: 本仓库需求实现；feature-study: 参考外部代码特性并在目标仓库落地；frontend-implementation: 前端实现 DAG；backend-test: 后端测试 DAG；knowledge-sync: 最终验证后回写测试知识库 DAG；knowledge-graph-bootstrap: AI 辅助业务知识图谱初始化 */
     taskKind: taskKindSchema.optional().default("standard"),
+    /** Feature 目录 id（如 F-2026-004）。knowledge-sync 必填（也可从 hardConstraints/需求正文/taskId 解析）；用于收窄 writeSet */
+    featureId: z.string().min(1).optional(),
     referenceRepos: z.array(referenceRepoConfigSchema).optional().default([]),
     referenceDocs: z.array(referenceDocConfigSchema).optional().default([]),
     referenceMaxFilesPerRepo: z.number().int().positive().optional(),

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")
@@ -326,7 +421,8 @@ export function buildAgentWorkerProgram() {
         .command("serve")
         .requiredOption("--repo <repo-root>", "Target repo root")
         .option("--port <port>", "HTTP port", "8787")
-        .option("--host <host>", "Bind host", "127.0.0.1")
+        .option("--host <host>", "Bind host (default 127.0.0.1; use 0.0.0.0 for LAN, no auth)", "127.0.0.1")
+        .option("--debug", "Log request source/method/path/status to stderr")
         .description("Start read-only observe HTTP server")
         .action(async (options) => {
         const repoRoot = path.resolve(options.repo);
@@ -334,6 +430,7 @@ export function buildAgentWorkerProgram() {
             repoRoot,
             host: options.host,
             port: Number.parseInt(options.port, 10),
+            debug: options.debug === true,
         });
         process.stdout.write(`${server.url}\n`);
         await new Promise((resolve) => {

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}`,
         };
     }