@tea-agent/loop-agent 0.24.10 → 0.25.0

package/dist/worker/feature/doctor.js

@@ -0,0 +1,223 @@
+import { access } from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { defaultFeatureEvidencePaths } from "../delivery/final-verification.js";
+import { transactionRecordPath } from "../delivery/git-transaction.js";
+import { readFeatureTaskPoolStates } from "../pool/run-store.js";
+import { validateFeatureTaskGraph } from "../task-graph/validate.js";
+import { reviewFeature } from "./review.js";
+import { resolveFinalVerifyTaskId } from "./advance.js";
+const execFileAsync = promisify(execFile);
+/**
+ * Read-only Feature delivery readiness doctor (not pool migrate / not auto-repair).
+ */
+export async function diagnoseFeature(input) {
+    const featureDir = path.resolve(input.featureDir);
+    const repoRoot = path.resolve(input.repoRoot);
+    const findings = [];
+    const nextCommands = [];
+    const validation = await validateFeatureTaskGraph(featureDir);
+    const featureId = validation.featureId || "unknown";
+    if (!validation.ok) {
+        findings.push({
+            id: "feature-validation",
+            severity: "error",
+            message: `Feature Packet invalid: ${validation.errors.map((e) => e.code).join(", ")}`,
+            evidence: validation.errors.flatMap((e) => (e.path ? [e.path] : [])),
+            suggestedCommand: `agent-worker task validate-feature ${JSON.stringify(featureDir)}`,
+        });
+    }
+    let review;
+    try {
+        review = await reviewFeature({ featureDir, repoRoot });
+    }
+    catch (error) {
+        findings.push({
+            id: "feature-review",
+            severity: "error",
+            message: error instanceof Error ? error.message : String(error),
+        });
+    }
+    const finalTaskId = review ? resolveFinalVerifyTaskId(review) : null;
+    const defaults = defaultFeatureEvidencePaths(featureId);
+    const deliveryManifestRel = `.harness/task-pool/artifacts/features/${featureId}/delivery/delivery-manifest.json`;
+    const gitTxAbs = transactionRecordPath(repoRoot, featureId);
+    const gitTxRel = path.relative(repoRoot, gitTxAbs).replace(/\\/g, "/");
+    const evidence = {
+        qaPass: {
+            path: defaults.qaEvidencePath,
+            present: await exists(path.join(repoRoot, defaults.qaEvidencePath)),
+        },
+        finalVerification: {
+            path: defaults.finalVerificationPath,
+            present: await exists(path.join(repoRoot, defaults.finalVerificationPath)),
+        },
+        bundle: {
+            path: defaults.bundleEvidencePath,
+            present: await exists(path.join(repoRoot, defaults.bundleEvidencePath)),
+        },
+        deliveryManifest: {
+            path: deliveryManifestRel,
+            present: await exists(path.join(repoRoot, deliveryManifestRel)),
+        },
+        gitTransaction: {
+            path: gitTxRel,
+            present: await exists(gitTxAbs),
+        },
+    };
+    const statesById = validation.ok
+        ? await readFeatureTaskPoolStates(repoRoot, featureId)
+        : {};
+    const states = Object.values(statesById);
+    const taskSummary = {
+        total: states.length,
+        done: states.filter((s) => s.status === "Done").length,
+        failed: states.filter((s) => s.status === "Failed").length,
+        running: states.filter((s) => s.status === "Running").length,
+        ready: states.filter((s) => s.status === "Ready").length,
+        other: states.filter((s) => !["Done", "Failed", "Running", "Ready"].includes(s.status)).length,
+    };
+    if (taskSummary.running > 0) {
+        const running = states.filter((s) => s.status === "Running");
+        findings.push({
+            id: "running-tasks",
+            severity: "warn",
+            message: `${taskSummary.running} task(s) still Running`,
+            evidence: running.map((s) => s.taskId),
+            suggestedCommand: `agent-worker task reconcile <task-id> --feature-id ${JSON.stringify(featureId)} --repo ${JSON.stringify(repoRoot)} --action abandon`,
+        });
+    }
+    if (taskSummary.failed > 0) {
+        const failed = states.filter((s) => s.status === "Failed");
+        findings.push({
+            id: "failed-tasks",
+            severity: "warn",
+            message: `${taskSummary.failed} task(s) Failed`,
+            evidence: failed.map((s) => s.taskId),
+            suggestedCommand: `agent-worker task retry <task-id> --feature-id ${JSON.stringify(featureId)} --repo ${JSON.stringify(repoRoot)} --reason <reason>`,
+        });
+    }
+    const dirty = await gitDirty(repoRoot);
+    if (dirty.dirty) {
+        findings.push({
+            id: "dirty-worktree",
+            severity: "warn",
+            message: "Target repo worktree is dirty (may block Delivery/closeout)",
+            evidence: dirty.lines.slice(0, 20),
+        });
+    }
+    if (!evidence.gitTransaction.present && taskSummary.done > 0) {
+        findings.push({
+            id: "missing-git-transaction",
+            severity: "info",
+            message: "No Feature git transaction record yet (expected before checkpointed Delivery)",
+            evidence: [evidence.gitTransaction.path],
+        });
+    }
+    const allTasksDone = review &&
+        review.tasks.length > 0 &&
+        review.tasks.every((t) => t.status === "Done");
+    if (allTasksDone) {
+        if (!evidence.qaPass.present || !evidence.finalVerification.present) {
+            findings.push({
+                id: "missing-final-evidence",
+                severity: "info",
+                message: "Implementation/QA tasks Done but verify-final evidence missing (ADR 0007)",
+                evidence: [
+                    evidence.qaPass.path,
+                    evidence.finalVerification.path,
+                ].filter((p, i) => i === 0 ? !evidence.qaPass.present : !evidence.finalVerification.present),
+                suggestedCommand: finalTaskId
+                    ? `agent-worker feature advance --feature-dir ${JSON.stringify(featureDir)} --repo ${JSON.stringify(repoRoot)} --task-id ${JSON.stringify(finalTaskId)} --dry-run --json`
+                    : `agent-worker feature verify-final --feature-dir ${JSON.stringify(featureDir)} --repo ${JSON.stringify(repoRoot)} --task-id <FINAL-VERIFY-id> --json`,
+            });
+            if (finalTaskId) {
+                nextCommands.push(`agent-worker feature advance --feature-dir ${JSON.stringify(featureDir)} --repo ${JSON.stringify(repoRoot)} --task-id ${JSON.stringify(finalTaskId)} --json`);
+            }
+        }
+        else if (!evidence.deliveryManifest.present) {
+            findings.push({
+                id: "missing-delivery",
+                severity: "info",
+                message: "Final evidence present but Delivery Package not written",
+                suggestedCommand: `agent-worker feature advance --feature-dir ${JSON.stringify(featureDir)} --repo ${JSON.stringify(repoRoot)}${finalTaskId ? ` --task-id ${JSON.stringify(finalTaskId)}` : ""} --json`,
+            });
+            nextCommands.push(`agent-worker feature advance --feature-dir ${JSON.stringify(featureDir)} --repo ${JSON.stringify(repoRoot)}${finalTaskId ? ` --task-id ${JSON.stringify(finalTaskId)}` : ""} --json`);
+        }
+        else if (review?.status === "deliverable") {
+            findings.push({
+                id: "ready-for-closeout",
+                severity: "info",
+                message: "Feature is deliverable; preview or apply closeout",
+                suggestedCommand: `agent-worker feature closeout --feature-dir ${JSON.stringify(featureDir)} --repo ${JSON.stringify(repoRoot)} --json`,
+            });
+            nextCommands.push(`agent-worker feature advance --feature-dir ${JSON.stringify(featureDir)} --repo ${JSON.stringify(repoRoot)}${finalTaskId ? ` --task-id ${JSON.stringify(finalTaskId)}` : ""} --apply --owner <owner> --json`);
+        }
+    }
+    else if (review?.status === "ready") {
+        nextCommands.push(`agent-worker feature run --feature-dir ${JSON.stringify(featureDir)} --repo ${JSON.stringify(repoRoot)} --limit 1 --json`);
+    }
+    const hasError = findings.some((f) => f.severity === "error");
+    const hasWarn = findings.some((f) => f.severity === "warn");
+    const status = hasError ? "blocked" : hasWarn ? "attention" : "healthy";
+    if (nextCommands.length === 0 && review?.nextAction?.command) {
+        nextCommands.push(review.nextAction.command);
+    }
+    return {
+        schemaVersion: 1,
+        featureId,
+        status,
+        ...(review ? { reviewStatus: review.status } : {}),
+        finalTaskId,
+        evidence,
+        taskSummary,
+        findings,
+        nextCommands,
+    };
+}
+export function renderFeatureDoctor(result) {
+    const lines = [
+        `Feature: ${result.featureId}`,
+        `Doctor: ${result.status}${result.reviewStatus ? ` (review=${result.reviewStatus})` : ""}`,
+        `Tasks: total=${result.taskSummary.total} done=${result.taskSummary.done} failed=${result.taskSummary.failed} running=${result.taskSummary.running} ready=${result.taskSummary.ready}`,
+        `Final task: ${result.finalTaskId ?? "none"}`,
+        `Evidence: qa=${result.evidence.qaPass.present ? "yes" : "no"} final=${result.evidence.finalVerification.present ? "yes" : "no"} bundle=${result.evidence.bundle.present ? "yes" : "no"} delivery=${result.evidence.deliveryManifest.present ? "yes" : "no"}`,
+        ...result.findings.map((f) => `${severityMark(f.severity)} ${f.id}: ${f.message}${f.suggestedCommand ? `\n  → ${f.suggestedCommand}` : ""}`),
+    ];
+    if (result.nextCommands.length) {
+        lines.push("Next commands:");
+        for (const cmd of result.nextCommands)
+            lines.push(`  - ${cmd}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+function severityMark(severity) {
+    if (severity === "error")
+        return "✗";
+    if (severity === "warn")
+        return "!";
+    return "·";
+}
+async function exists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function gitDirty(repoRoot) {
+    try {
+        const { stdout } = await execFileAsync("git", ["status", "--short", "--branch"], { cwd: repoRoot, encoding: "utf8" });
+        const lines = stdout
+            .split(/\r?\n/)
+            .map((l) => l.trimEnd())
+            .filter((l) => l && !l.startsWith("##"));
+        return { dirty: lines.length > 0, lines };
+    }
+    catch {
+        return { dirty: false, lines: [] };
+    }
+}

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

@@ -66,13 +66,21 @@ export function projectNextAction(input, status) {
         };
     }
     if (status === "awaiting_qa") {
+        const finalish = input.tasks.find((task) => /(final[-_]?(verify|verification))|closeout/i.test(task.taskId));
+        if (finalish && (finalish.status === "Done" || finalish.status === "Ready")) {
+            return {
+                kind: "advance_delivery",
+                label: "运行 feature advance（verify-final 权威路径）",
+                command: `agent-worker feature advance ${featureArgs} --task-id ${quote(finalish.taskId)}`,
+            };
+        }
         return { kind: "complete_qa", label: "补齐 QA verdict 与 required AC 证据" };
     }
     if (status === "deliverable") {
         return {
-            kind: "prepare_closeout",
-            label: "预览 Feature Closeout gates",
-            command: `agent-worker feature closeout ${featureArgs}`,
+            kind: "advance_delivery",
+            label: "编排 verify-final → delivery → closeout（ADR 0007）",
+            command: `agent-worker feature advance ${featureArgs}`,
         };
     }
     return null;