@tea-agent/loop-agent 0.15.0 → 0.16.1-beta.0

package/dist/worker/feature/fullstack-validate.js

@@ -0,0 +1,337 @@
+import { resolveWorkflow } from "../task-spec/workflow-routing.js";
+export function resolveNodeWorkflows(graph, taskSpecs) {
+    const index = new Map();
+    for (const node of graph.nodes) {
+        const spec = taskSpecs.get(node.id);
+        if (spec)
+            index.set(node.id, { workflow: resolveWorkflow(spec).workflow, type: spec.type });
+    }
+    return index;
+}
+export function validateFullstackStructure(input) {
+    const errors = [];
+    const { profile, acceptance, graph, taskSpecs } = input;
+    const nodeIds = new Set(graph.nodes.map((node) => node.id));
+    const nodeById = new Map(graph.nodes.map((node) => [node.id, node]));
+    const workflows = resolveNodeWorkflows(graph, taskSpecs);
+    // Gate 1: authority/acceptance non-empty is already enforced by the acceptance
+    // schema (.min(1)) before fullstack gates run; nothing to add here.
+    // Gate 2: each AC must declare a contract source; required ACs require both
+    // implementation and verification evidence, plus the kinds they expect.
+    for (const item of acceptance.acceptance) {
+        const implRefs = item.verification.implementation_task_refs ?? [];
+        const verRefs = item.verification.verification_task_refs ?? [];
+        if (implRefs.length === 0 && verRefs.length === 0) {
+            // `expected_task_refs` only is allowed as legacy fallback, but for a
+            // fullstack-v1 AC we require explicit contract separation.
+            errors.push({
+                code: "fullstack-contract-source-missing",
+                message: `acceptance ${item.id} must declare implementation_task_refs and/or verification_task_refs for a fullstack-v1 packet`,
+                path: `acceptance.${item.id}.verification`,
+            });
+        }
+        if (item.priority === "must" && implRefs.length === 0) {
+            errors.push({
+                code: "fullstack-required-implementation-refs-missing",
+                message: `required acceptance ${item.id} must declare implementation_task_refs`,
+                path: `acceptance.${item.id}.verification.implementation_task_refs`,
+            });
+        }
+        if (item.priority === "must" && verRefs.length === 0) {
+            errors.push({
+                code: "fullstack-required-verification-refs-missing",
+                message: `required acceptance ${item.id} must declare verification_task_refs`,
+                path: `acceptance.${item.id}.verification.verification_task_refs`,
+            });
+        }
+        if (item.priority === "must" && (item.verification.required_evidence?.length ?? 0) === 0) {
+            errors.push({
+                code: "fullstack-required-evidence-missing",
+                message: `required acceptance ${item.id} must declare required_evidence`,
+                path: `acceptance.${item.id}.verification.required_evidence`,
+            });
+        }
+    }
+    // Refs existence + non-overlap between implementation and verification refs.
+    for (const item of acceptance.acceptance) {
+        const implRefs = item.verification.implementation_task_refs ?? [];
+        const verRefs = item.verification.verification_task_refs ?? [];
+        for (const ref of implRefs) {
+            if (!nodeIds.has(ref)) {
+                errors.push({
+                    code: "acceptance-implementation-ref-missing",
+                    message: `acceptance ${item.id} implementation_task_refs references missing task ${ref}`,
+                    path: `acceptance.${item.id}.verification.implementation_task_refs`,
+                });
+            }
+        }
+        for (const ref of verRefs) {
+            if (!nodeIds.has(ref)) {
+                errors.push({
+                    code: "acceptance-verification-ref-missing",
+                    message: `acceptance ${item.id} verification_task_refs references missing task ${ref}`,
+                    path: `acceptance.${item.id}.verification.verification_task_refs`,
+                });
+            }
+        }
+        const overlap = implRefs.filter((ref) => verRefs.includes(ref));
+        if (overlap.length > 0) {
+            errors.push({
+                code: "fullstack-impl-verification-refs-overlap",
+                message: `acceptance ${item.id} implementation and verification task refs must not overlap: ${overlap.join(", ")}`,
+                path: `acceptance.${item.id}.verification`,
+            });
+        }
+    }
+    const scope = profile.scope ?? {};
+    if (!Object.values(scope).some((value) => value === true)) {
+        errors.push({
+            code: "fullstack-scope-required",
+            message: "fullstack-v1 requires at least one enabled scope flag",
+            path: "feature.yaml:scope",
+        });
+    }
+    const hasWorkflow = (target) => [...workflows.values()].some((entry) => entry.workflow === target);
+    // Gate 3: scope.backend → at least one backend implementation agent-dag that
+    // is a development-type task (not QA, not architecture/review/final-verify).
+    if (scope.backend && !hasBackendImplementation(workflows)) {
+        errors.push({
+            code: "fullstack-required-workflow-missing",
+            message: "scope.backend is enabled but no backend implementation agent-dag task is present",
+            path: "feature.yaml:scope.backend",
+        });
+    }
+    // Gate 4: scope.frontend → at least one frontend-implementation.
+    if (scope.frontend && !hasWorkflow("frontend-implementation")) {
+        errors.push({
+            code: "fullstack-required-workflow-missing",
+            message: "scope.frontend is enabled but no frontend-implementation task is present",
+            path: "feature.yaml:scope.frontend",
+        });
+    }
+    // Gate 5: scope.backendVerification → at least one backend-test.
+    if (scope.backendVerification && !hasWorkflow("backend-test")) {
+        errors.push({
+            code: "fullstack-required-workflow-missing",
+            message: "scope.backendVerification is enabled but no backend-test task is present",
+            path: "feature.yaml:scope.backendVerification",
+        });
+    }
+    // Gate 6: scope.frontendVerification → at least one frontend-test.
+    if (scope.frontendVerification && !hasWorkflow("frontend-test")) {
+        errors.push({
+            code: "fullstack-required-workflow-missing",
+            message: "scope.frontendVerification is enabled but no frontend-test task is present",
+            path: "feature.yaml:scope.frontendVerification",
+        });
+    }
+    // Gate 7: frontend-test depends_on at least one frontend-implementation node.
+    const frontendImplIds = new Set(graph.nodes.filter((node) => workflows.get(node.id)?.workflow === "frontend-implementation").map((node) => node.id));
+    for (const node of graph.nodes) {
+        if (workflows.get(node.id)?.workflow !== "frontend-test")
+            continue;
+        const dependsOnImpl = node.depends_on.some((dep) => frontendImplIds.has(dep));
+        if (!dependsOnImpl) {
+            errors.push({
+                code: "fullstack-frontend-test-missing-impl-dep",
+                message: `frontend-test node ${node.id} must depend_on at least one frontend-implementation node`,
+                path: `nodes.${node.id}.depends_on`,
+            });
+        }
+        if (scope.backendVerification) {
+            const dependsOnBackendVerification = node.depends_on.some((dep) => workflows.get(dep)?.workflow === "backend-test");
+            if (!dependsOnBackendVerification) {
+                errors.push({
+                    code: "fullstack-frontend-test-missing-backend-verification-dep",
+                    message: `frontend-test node ${node.id} must depend_on a backend-test when scope.backendVerification is enabled`,
+                    path: `nodes.${node.id}.depends_on`,
+                });
+            }
+        }
+    }
+    // Gate 8: if a final-verify / closeout-style node exists, it depends_on all
+    // required verification workflows (backend-test / frontend-test declared by scope).
+    const requiredVerificationKinds = [];
+    if (scope.backendVerification)
+        requiredVerificationKinds.push("backend-test");
+    if (scope.frontendVerification)
+        requiredVerificationKinds.push("frontend-test");
+    const finalVerifyNode = findFinalVerifyNode(graph, workflows);
+    if (finalVerifyNode && requiredVerificationKinds.length > 0) {
+        const coveredKinds = new Set();
+        for (const dep of finalVerifyNode.depends_on) {
+            const depEntry = workflows.get(dep);
+            if (depEntry && requiredVerificationKinds.includes(depEntry.workflow))
+                coveredKinds.add(depEntry.workflow);
+        }
+        const missing = requiredVerificationKinds.filter((kind) => !coveredKinds.has(kind));
+        if (missing.length > 0) {
+            errors.push({
+                code: "fullstack-final-verify-missing-verification-dep",
+                message: `final verification node ${finalVerifyNode.id} must depend_on required verification workflows: ${missing.join(", ")}`,
+                path: `nodes.${finalVerifyNode.id}.depends_on`,
+            });
+        }
+    }
+    // Gate 9: test workflows' allowed_paths must not include product write paths.
+    // Conservative heuristic (v1): test tasks should not own `src/**` non-test paths.
+    for (const node of graph.nodes) {
+        const entry = workflows.get(node.id);
+        if (!entry)
+            continue;
+        if (entry.workflow !== "backend-test" && entry.workflow !== "frontend-test")
+            continue;
+        const spec = taskSpecs.get(node.id);
+        if (!spec)
+            continue;
+        const writePaths = spec.constraints.allowed_paths ?? [];
+        const offending = writePaths.filter((p) => isProductWritePath(p));
+        if (offending.length > 0) {
+            errors.push({
+                code: "fullstack-test-workflow-allowed-paths-write-path",
+                message: `test workflow ${node.id} allowed_paths must not include product write paths: ${offending.join(", ")}`,
+                path: `${node.task}:constraints.allowed_paths`,
+            });
+        }
+    }
+    // Gate 10: any two writer nodes with overlapping writeSet must have a serial
+    // depends_on relationship (transitive).
+    const writerNodes = graph.nodes.filter((node) => {
+        const entry = workflows.get(node.id);
+        return entry?.workflow === "agent-dag" || entry?.workflow === "frontend-implementation";
+    });
+    for (let i = 0; i < writerNodes.length; i++) {
+        for (let j = i + 1; j < writerNodes.length; j++) {
+            const a = writerNodes[i];
+            const b = writerNodes[j];
+            const aPaths = collectWritePaths(taskSpecs.get(a.id));
+            const bPaths = collectWritePaths(taskSpecs.get(b.id));
+            if (!writeSetsOverlap(aPaths, bPaths))
+                continue;
+            if (!hasSerialDependency(nodeById, a.id, b.id)) {
+                errors.push({
+                    code: "fullstack-writeset-overlap",
+                    message: `writer nodes ${a.id} and ${b.id} have overlapping allowed_paths but no serial depends_on relationship`,
+                    path: `nodes.${b.id}.allowed_paths`,
+                });
+            }
+        }
+    }
+    return errors;
+}
+function hasBackendImplementation(workflows) {
+    for (const entry of workflows.values()) {
+        if (entry.workflow === "agent-dag" && isDevelopmentType(entry.type)) {
+            // backend implementation = an agent-dag development-type task
+            // (not QA, not architecture/review, not a final-verify agent-dag).
+            return true;
+        }
+    }
+    return false;
+}
+/** Mirrors review.ts isDevelopmentTask: excludes QA, architecture, review. */
+function isDevelopmentType(type) {
+    return !type.startsWith("qa-") && !["architecture", "review"].includes(type);
+}
+/**
+ * Identify a final-verification / closeout node. In the fullstack topology it
+ * is an `agent-dag` node whose id hints at final-verify/closeout, or any node
+ * that depends on all test workflows. We use a conservative id heuristic so the
+ * gate only fires for explicit final-verify nodes; absence is not an error.
+ */
+function findFinalVerifyNode(graph, workflows) {
+    const hint = /(final[-_]?(verify|verification))|closeout/i;
+    for (const node of graph.nodes) {
+        if (hint.test(node.id))
+            return node;
+    }
+    // Fallback: a non-test node that depends on both a backend-test and frontend-test.
+    for (const node of graph.nodes) {
+        const kinds = node.depends_on
+            .map((dep) => workflows.get(dep)?.workflow)
+            .filter((value) => Boolean(value));
+        if (kinds.includes("backend-test") && kinds.includes("frontend-test")) {
+            return node;
+        }
+    }
+    return undefined;
+}
+/**
+ * Conservative v1 heuristic: a path is a product write path if it targets the
+ * `src/**` tree and is not a test-only subtree. Test fixtures living under
+ * `test/**` or `tests/**` are not flagged. This deliberately fails closed: an
+ * ambiguous path is reported so the packet declares its intent explicitly.
+ */
+function isProductWritePath(p) {
+    if (!p)
+        return false;
+    // Normalize to forward slashes for glob comparison.
+    const normalized = p.replace(/\\/g, "/");
+    // Test-only subtrees are allowed for test tasks.
+    if (normalized.startsWith("test/") || normalized.startsWith("tests/"))
+        return false;
+    // `src/**` is treated as product code; everything else is advisory.
+    return normalized.startsWith("src/") || normalized === "src" || normalized.startsWith("src/**");
+}
+function collectWritePaths(spec) {
+    if (!spec)
+        return [];
+    return spec.constraints.allowed_paths ?? [];
+}
+/**
+ * Conservative writeSet overlap: treat globs minimally. Two paths overlap when
+ * one is a prefix of the other (after stripping trailing globstars) or they are
+ * equal. This avoids a glob-engine dependency while still catching the common
+ * case of two writers claiming `src/**`.
+ */
+function writeSetsOverlap(a, b) {
+    for (const left of a) {
+        const leftBase = globBase(left);
+        for (const right of b) {
+            const rightBase = globBase(right);
+            if (leftBase === rightBase)
+                return true;
+            if (leftBase.startsWith(`${rightBase}/`) || rightBase.startsWith(`${leftBase}/`))
+                return true;
+        }
+    }
+    return false;
+}
+function globBase(glob) {
+    const normalized = glob.replace(/\\/g, "/");
+    // Drop trailing /** and * suffixes to get the directory base.
+    return normalized
+        .replace(/\/\*\*$/, "")
+        .replace(/\/\*$/, "")
+        .replace(/\*$/, "");
+}
+/**
+ * Two writer nodes are serially ordered if one is reachable from the other via
+ * `depends_on` (in either direction). Parallel writers with overlapping
+ * writeSet and no ordering violate gate 10.
+ */
+function hasSerialDependency(nodeById, a, b) {
+    const forward = reaches(nodeById, a, b);
+    const backward = reaches(nodeById, b, a);
+    return forward || backward;
+}
+function reaches(nodeById, from, to) {
+    const visited = new Set();
+    const stack = [from];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current === to)
+            return true;
+        if (visited.has(current))
+            continue;
+        visited.add(current);
+        const node = nodeById.get(current);
+        if (!node)
+            continue;
+        for (const dep of node.depends_on)
+            stack.push(dep);
+    }
+    return false;
+}
+/** Re-exported for read-model coverage projection to reuse workflow resolution. */
+export { resolveWorkflow };

package/dist/worker/feature/profile-schema.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+/**
+ * Feature-level profile for a Feature Packet (M4 `fullstack-v1`).
+ *
+ * `fullstack-v1` is NOT a new DAG or taskKind. It is `agent-worker`'s
+ * deterministic structural validation + read-model projection policy over a
+ * Feature Packet. See
+ * `docs/design/agent-worker-fullstack-workflow-integration.md` §9.
+ *
+ * A Feature Packet declares its profile via an optional `feature.yaml` next to
+ * `acceptance.yaml`. A packet without `feature.yaml` (or one that does not set
+ * `profile`) defaults to `generic`, which keeps all existing legacy/generic
+ * validation behavior unchanged (no fullstack gates fire).
+ *
+ * The schema is `.strict()`: new fields must be declared explicitly, never
+ * passthrough, so validators and read models can read declared values safely.
+ */
+export const FEATURE_PROFILE_FILENAME = "feature.yaml";
+export const FULLSTACK_V1 = "fullstack-v1";
+export const GENERIC = "generic";
+export const featureProfileSchema = z
+    .object({
+    schema_version: z.literal(1),
+    feature_id: z.string().min(1),
+    profile: z.enum([GENERIC, FULLSTACK_V1]).optional().default(GENERIC),
+    /**
+     * Declared fullstack scope. Only consulted when `profile === "fullstack-v1"`.
+     * Each boolean enables a structural gate (see fullstack-validate.ts).
+     */
+    scope: z
+        .object({
+        backend: z.boolean().optional(),
+        frontend: z.boolean().optional(),
+        backendVerification: z.boolean().optional(),
+        frontendVerification: z.boolean().optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+/** Whether a parsed profile activates the fullstack-v1 gate set. */
+export function isFullstackProfile(profile) {
+    return profile.profile === FULLSTACK_V1;
+}

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

@@ -50,6 +50,7 @@ export function summarizePlanReasons(plan) {
             reasonCode: item.reasonCode,
             reason: item.reason,
             blockedBy: item.blockedBy,
+            artifactGate: item.artifactGate,
         })),
     };
 }

package/dist/worker/feature/reducer.js

@@ -76,6 +76,8 @@ export function reduceFeature(input) {
         tasks: input.tasks.map((task) => ({
             taskId: task.taskId,
             type: task.type,
+            ...(task.workflow ? { workflow: task.workflow } : {}),
+            ...(task.outcome ? { outcome: task.outcome } : {}),
             status: task.status ?? (isReady(task.taskId, input) ? "Ready" : "Draft"),
         })),
         acceptanceCoverage: input.acceptance,

package/dist/worker/feature/review.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import YAML from "yaml";
 import { z } from "zod";
 import { getRunsJsonlPath, getTaskPoolRoot, readFeatureTaskPoolStates, readJsonlFile } from "../pool/run-store.js";
+import { readVerifiedOutcome } from "../outcomes/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";
@@ -21,11 +22,16 @@ export function renderFeatureReview(model) {
         `${model.summary.tasksSucceeded}/${model.summary.tasksTotal} tasks completed; ${model.summary.requiredAcCovered}/${model.summary.requiredAcTotal} required AC covered.`;
     const evidence = [model.evidence.morningReport, model.evidence.observeSnapshot, model.evidence.delivery, model.evidence.closeout, ...model.blockingItems.flatMap((item) => item.evidence)]
         .filter((item) => Boolean(item));
+    const workflows = model.tasks.map((task) => task.workflow).filter((value) => Boolean(value));
+    const distinctWorkflows = [...new Set(workflows)];
+    const outcomes = model.tasks.filter((task) => task.outcome).length;
     return [
         `Feature: ${model.featureId}`,
         `结果: ${model.statusLabel}`,
         `原因: ${reason}`,
         `任务: ${model.summary.tasksSucceeded}/${model.summary.tasksTotal} 完成，${model.summary.tasksReady} Ready，${model.summary.tasksFailed} 失败，${model.summary.tasksBlocked} 阻塞`,
+        `工作流: ${distinctWorkflows.length > 0 ? distinctWorkflows.join(", ") : "-"}`,
+        `Outcome: ${outcomes}/${model.tasks.length} 已投影`,
         `required AC: ${model.summary.requiredAcCovered}/${model.summary.requiredAcTotal} 已覆盖；缺口 ${model.acceptanceCoverage.filter((item) => item.required && item.status !== "covered" && item.status !== "waived").map((item) => item.acId).join(", ") || "无"}`,
         `风险: high=${model.riskSummary.high}, medium=${model.riskSummary.medium}, low=${model.riskSummary.low}`,
         `交付/Closeout: ${model.status === "deliverable" || model.status === "closed" ? "交付证据齐备" : "尚未就绪"}`,
@@ -87,6 +93,17 @@ async function loadFeatureProjection(input) {
             projectionWarnings.push("Task Pool run record is semantically invalid");
         return valid;
     });
+    const outcomes = new Map();
+    for (const run of runs) {
+        const outcome = await readVerifiedOutcome({
+            repoRoot,
+            workerRunId: run.workerRunId,
+            outcomePath: run.outcomePath,
+            outcomeSha256: run.outcomeSha256,
+        });
+        if (outcome)
+            outcomes.set(run.workerRunId, outcome);
+    }
     const graphNodes = graph.success ? graph.data.nodes : [];
     let planning;
     if (graph.success) {
@@ -96,7 +113,7 @@ async function loadFeatureProjection(input) {
                 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) });
+            planning = projectReadyPlan({ featureId: validation.featureId, graph: graph.data, taskSpecs, states, outcomes, selectionLimit: Math.max(graph.data.nodes.length, 1) });
         }
         catch (error) {
             projectionWarnings.push(`Ready Planner projection is unavailable: ${message(error)}`);
@@ -189,6 +206,8 @@ async function loadFeatureProjection(input) {
             ...(state?.status ? { status: state.status } : {}),
             ...(state?.workerRunId ? { workerRunId: state.workerRunId } : {}),
             ...(state?.failure?.category ? { failureCategory: state.failure.category } : {}),
+            ...(latest?.workflow ? { workflow: latest.workflow } : {}),
+            ...(latest?.outcomePath && latest.outcomeSha256 ? { outcome: { path: latest.outcomePath, sha256: latest.outcomeSha256 } } : {}),
             failureEvidence: Object.values(latest?.failureArtifacts ?? {}).filter((value) => typeof value === "string"),
         };
     });
@@ -206,15 +225,16 @@ async function loadFeatureProjection(input) {
                 acId: item.id,
                 required: item.priority === "must",
                 expectedTaskRefs: item.verification.expected_task_refs,
-                status: failed.length > 0
-                    ? "blocked"
-                    : explicit?.status === "covered" && explicit.evidence.length > 0
-                        ? "covered"
-                        : explicit?.status === "waived"
-                            ? "waived"
-                            : done.length === referenced.length && done.length > 0
-                                ? "partial"
-                                : "missing",
+                status: resolveAcceptanceCoverageStatus({
+                    item,
+                    states,
+                    outcomes,
+                    failed,
+                    done,
+                    referencedCount: referenced.length,
+                    explicit,
+                    expectedFeatureId: validation.featureId,
+                }),
                 evidence: explicit?.evidence ?? [],
                 blockedBy: failed,
             };
@@ -370,7 +390,7 @@ const explicitCoverageSchema = z.object({
     featureId: z.string().min(1),
     items: z.array(z.object({
         acId: z.string().min(1),
-        status: z.enum(["covered", "partial", "blocked", "waived", "missing"]),
+        status: z.enum(["covered", "partial", "blocked", "waived", "missing", "awaiting-verification"]),
         evidence: z.array(z.object({
             path: z.string().min(1),
             sha256: z.string().regex(/^[a-f0-9]{64}$/),
@@ -517,3 +537,77 @@ function normalizeRepoRef(ref, repoRoot) {
 function isDevelopmentTask(type) {
     return !type.startsWith("qa-") && !["architecture", "review"].includes(type);
 }
+export function resolveAcceptanceCoverageStatus(input) {
+    const dualCoverage = projectDualCoverage(input.item, input.states, input.outcomes, input.failed, input.done, input.expectedFeatureId);
+    if (input.failed.length > 0)
+        return "blocked";
+    if (input.explicit?.status === "covered" &&
+        input.explicit.evidence.length > 0 &&
+        (dualCoverage === undefined || dualCoverage === "covered")) {
+        return "covered";
+    }
+    if (input.explicit?.status === "waived")
+        return "waived";
+    if (dualCoverage === "covered")
+        return "awaiting-verification";
+    return dualCoverage ??
+        (input.done.length === input.referencedCount && input.done.length > 0
+            ? "partial"
+            : "missing");
+}
+export function projectDualCoverage(item, states, outcomes, failed, done, expectedFeatureId) {
+    const implRefs = item.verification.implementation_task_refs ?? [];
+    const verRefs = item.verification.verification_task_refs ?? [];
+    const integration = item.verification.integration;
+    const dualMode = implRefs.length > 0 || verRefs.length > 0 || integration !== undefined;
+    if (!dualMode)
+        return undefined;
+    const envByWorkerRunId = (workerRunId) => workerRunId ? outcomes.get(workerRunId) : undefined;
+    // 1. implementation refs must all be Done.
+    const implDone = implRefs.length > 0
+        ? implRefs.every((id) => states[id]?.status === "Done")
+        : done.length > 0;
+    // 2. verification refs must each have a succeeded outcome envelope.
+    let verSucceeded = false;
+    let verEnvelopes = [];
+    if (verRefs.length > 0) {
+        verEnvelopes = verRefs
+            .map((taskId) => ({ taskId, envelope: envByWorkerRunId(states[taskId]?.workerRunId) }))
+            .filter((value) => Boolean(value.envelope));
+        verSucceeded =
+            verEnvelopes.length === verRefs.length &&
+                verEnvelopes.every(({ envelope }) => envelope.outcomeStatus === "succeeded");
+    }
+    if (failed.length > 0)
+        return "blocked";
+    if (!implDone) {
+        return done.length > 0 ? "partial" : "missing";
+    }
+    if (verRefs.length === 0 || !verSucceeded)
+        return "awaiting-verification";
+    if (expectedFeatureId && verEnvelopes.some(({ taskId, envelope }) => envelope.identity?.featureId !== expectedFeatureId ||
+        envelope.identity?.taskId !== taskId ||
+        (envelope.identity?.workflow !== "backend-test" && envelope.identity?.workflow !== "frontend-test"))) {
+        return "awaiting-verification";
+    }
+    const requiredEvidence = item.verification.required_evidence ?? [];
+    if (requiredEvidence.some((kind) => !verEnvelopes.some(({ envelope }) => kind === "shell-verification"
+        ? envelope.shellVerification?.exitZero === true
+        : envelope.artifacts?.some((artifact) => artifact.kind === kind)))) {
+        return "awaiting-verification";
+    }
+    // 3. integration policy: real-required demands real evidence on every
+    //    verification envelope. mock-only / locally-validated (real:false) cannot
+    //    satisfy real-required.
+    if (integration === "real-required") {
+        if (verRefs.length === 0)
+            return "awaiting-verification";
+        const realOk = verEnvelopes.every(({ envelope }) => envelope.integrationStatus?.real === true);
+        if (!realOk)
+            return "awaiting-verification";
+    }
+    // 4. All dual-coverage prerequisites are satisfied. The caller still requires
+    //    an explicit, hash-validated coverage artifact before publishing `covered`;
+    //    without it, the read model remains awaiting-verification.
+    return "covered";
+}

package/dist/worker/materialize/harness-task-materializer.js

@@ -6,6 +6,7 @@ import { writeTaskConfig, writeTaskArtifactFile } from "../../infrastructure/har
 import { getTaskPaths, loadTaskConfig } from "../../task/runtime.js";
 import { resolveLoopAgentProfile } from "../profile-mapping.js";
 import { mapRiskLevelToComplexity } from "../task-spec/complexity-mapping.js";
+import { resolveWorkflow } from "../task-spec/workflow-routing.js";
 import { validateTaskSpec } from "../task-spec/validate.js";
 export async function materializeTaskSpec(options) {
     const now = options.now ?? new Date();
@@ -17,6 +18,7 @@ export async function materializeTaskSpec(options) {
         throw new Error(`TaskSpec validation failed: ${codes}`);
     }
     const harnessTaskId = buildHarnessTaskId(options.taskSpec, now);
+    const resolvedWorkflow = resolveWorkflow(options.taskSpec);
     const existingConfig = await loadExistingTaskConfig(options.repoRoot, harnessTaskId);
     if (!existingConfig) {
         const newTaskResult = await options.client.run(["new-task", harnessTaskId, options.taskSpec.title], {
@@ -36,6 +38,8 @@ export async function materializeTaskSpec(options) {
         ...baseConfig,
         taskId: harnessTaskId,
         title: options.taskSpec.title,
+        taskKind: resolvedWorkflow.taskKind,
+        featureId: options.taskSpec.feature_id,
         allowedPaths: options.taskSpec.constraints.allowed_paths,
         forbiddenPaths: options.taskSpec.constraints.forbidden_paths,
         hardConstraints: options.taskSpec.constraints.hard_constraints,
@@ -87,6 +91,7 @@ export async function materializeTaskSpec(options) {
         businessId: options.taskSpec.id,
         harnessTaskId,
         featureId: options.taskSpec.feature_id,
+        workflow: resolvedWorkflow.workflow,
         loopAgentProfile: profileMapping.loopAgentProfile,
         taskConfigPath: paths.taskConfigPath,
         source: {

package/dist/worker/observability/read-model.js

@@ -159,6 +159,7 @@ export async function listTaskRunHistory(repoRoot, featureId, taskId, options =
             workerRunId: run.workerRunId,
             taskId: run.taskId,
             featureId: run.featureId ?? featureId,
+            workflow: enriched?.workflow ?? run.workflow,
             status: enriched?.status ?? mapRunRecordStatus(run.status),
             startedAt: enriched?.startedAt,
             finishedAt: enriched?.finishedAt ?? run.recordedAt,
@@ -335,6 +336,7 @@ function mergeLedgerRun(taskMap, run, warnings) {
         runRecordPath: run.runRecordPath,
         dagPath: run.dagPath,
         ...run.failureArtifacts,
+        ...(run.outcomePath ? { outcome: run.outcomePath } : {}),
     };
     taskMap.set(key, {
         ...(sameRun
@@ -347,6 +349,7 @@ function mergeLedgerRun(taskMap, run, warnings) {
             }),
         batchRunId: run.batchRunId,
         featureId,
+        workflow: run.workflow ?? existing.workflow,
         status: mapRunRecordStatus(run.status),
         workerRunId: run.workerRunId,
         harnessTaskId: run.harnessTaskId ?? existing.harnessTaskId,
@@ -491,6 +494,7 @@ function buildHistoricalRunMap(ledgerRuns, events, workerRunFeatureIndex = new M
             taskId: run.taskId,
             batchRunId: run.batchRunId,
             featureId: run.featureId,
+            workflow: run.workflow,
             status: mapRunRecordStatus(run.status),
             workerRunId: run.workerRunId,
             harnessTaskId: run.harnessTaskId,
@@ -501,6 +505,7 @@ function buildHistoricalRunMap(ledgerRuns, events, workerRunFeatureIndex = new M
                 runRecordPath: run.runRecordPath,
                 dagPath: run.dagPath,
                 ...run.failureArtifacts,
+                ...(run.outcomePath ? { outcome: run.outcomePath } : {}),
             }),
         });
     }
@@ -1060,6 +1065,8 @@ async function loadLedgerRuns(repoRoot) {
             workerRunId,
             taskId,
             featureId: readString(parsed, "featureId"),
+            workflow: readString(parsed, "workflow"),
+            outcomePath: readString(parsed, "outcomePath"),
             status,
             harnessTaskId: readString(parsed, "harnessTaskId"),
             runRecordPath: readString(parsed, "runRecordPath"),

package/dist/worker/observe/static/views/task.js

@@ -152,6 +152,7 @@ export async function renderTaskDetail(featureId, taskId) {
 		metaGrid([
 			["Task ID", task.taskId],
 			["状态", badge(task.status)],
+			["Workflow", task.workflow ?? "—"],
 			[
 				"Feature",
 				task.featureId