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

package/CHANGELOG.md

@@ -59,17 +59,13 @@
 
 ## [Unreleased]
 
-- 新增 Pull Request 的只读 AI 自动审查：在创建、重新打开、转为 ready 或更新提交时检查 bug、测试缺口、runtime boundary、command registry、初始化投影与文档收敛，并更新单条 PR 评论；Fork PR 无模型密钥时安全跳过。
-- 修复私有仓库 AI PR 审查因通过网页 `*.diff` 地址拉取差异导致 404 的问题，改为经 GitHub API 获取 diff。
-- 新增 `.editorconfig` 与 `.gitattributes`，统一常见文本文件的 UTF-8、LF、缩进和文件末尾换行约定，减少不同 IDE 与操作系统产生的无意义差异；本轮不引入 Git hooks 或格式化依赖。
-- 新增面向内部研发人员的轻量 GitHub 协作指南和简短 Pull Request 模板，统一采用短分支、CI 与 Squash Merge 的最小协作闭环，不改变现有 Agent DAG 和发布流程。
-- 收紧 npm 发布包中的 `docs/` 范围：只保留 init/runtime 所需的治理文档、architecture、skills 与 templates；源仓库专属说明与 progress/report/exec-plan 等目录契约不再打进包内。
-- 收紧 npm 发布包中的 `scripts/`：只保留 `loop-agent knowledge` 实际调用的知识库脚本；源仓治理检查与 `.sh` 薄包装不再打进包内。
-- 新增内部测试版本夜间自动发布：达到提交门槛并通过发布检查后，自动更新版本、生成中文说明并发布 GitHub Release 与 npm；手动运行默认只做 dry-run。
-- 发布说明支持 OpenAI-compatible 模型，模型不可用时自动使用保守摘要。
-- 修复 PR #34 发布风险：合并到 main 后包版本被错误提升为 `0.14.1-beta.0`，现已恢复为 `0.14.0`；发布门禁由仅按 frontend 分支判断改为按版本号的 prerelease 状态限制 dist-tag（beta prerelease 只允许 `beta` tag，使用 `latest`/空/默认 tag 时 fail-closed；非 beta prerelease 如 alpha/rc 全局拒绝），避免在 main 上执行默认 `npm publish` 时把 prerelease 误发布到 `latest`。
-- `frontend` 分支继续保留本地 npm beta 发布门禁，并在合入 main 0.14.0 后把测试版本线调整为 `0.14.1-beta.0`，避免误推正式版本或 `latest`。
-- 前端实现 DAG 的 `frontendMock.policy=auto` 不再因为目标项目缺少 Mock 能力而阻塞；无确认 Mock 能力时跳过 Mock、保留真实请求默认路径，并在未真实联调时记录 `Frontend status: locally-validated` 与 `Real integration: pending`。
+- 修复前端 Mock 策略节点偶尔因解释性前言出现在 `MOCK_STRATEGY:` 之前而被 contract gate 误判失败的问题；节点现在通过显式首行协议生成稳定 canonical 输出，同时保留全局 `first-non-empty` 精确校验和原始 Pi 执行证据。
+- `agent-worker feature verify-final` 现可聚合 hash-bound `backend-test` / `frontend-test` Outcome，生成 Feature Verification Bundle v1；Delivery 与 Closeout 会重新验证 bundle、typed outcome、Feature/Task/workflow/controller identity 和 Delivery HEAD，任一漂移或篡改都会阻止交付。既有 `qa-execute` QA aggregate 继续兼容。
+- 新增 `fullstack-v1` Feature Profile：Feature Packet 可选 `feature.yaml` 声明 profile 与 scope，`agent-worker task validate-feature` 对 `fullstack-v1` packet 执行确定性结构门禁（required backend/frontend/backend-test/frontend-test workflow、frontend-test 依赖实现与后端验证、final-verify 覆盖、测试 workflow 不含产品写路径、writer writeSet 重叠须串行）。fullstack profile 必须有 scope；required AC 必须声明实现、验证与 evidence refs，任一门禁失败 fail closed 并输出阶段缺口与修复建议；未声明 profile 的 generic/legacy packet 行为零变化。
+- AcceptanceSpec `verification` 新增全部 optional 的 `implementation_task_refs`、`verification_task_refs`、`required_evidence`、`integration`（`not-applicable`/`mock-allowed`/`real-required`），保留 legacy `expected_task_refs`，schema 仍为 `.strict()`；Feature review 的 coverage 投影在 dual-mode 下复用 Task Outcome envelope 的 `integrationStatus`：实现 Done 但缺验证 evidence、或 `real-required` 仅由 mock/local 满足时，required AC 派生为 `awaiting-verification`（只读派生，非新状态机），Feature 不得被报告为 deliverable。
+- 为 TaskGraph 节点新增可选 `consumes`/`produces` 声明与 Ready Planner artifact gate：上游 Done 但必需产物（路径/sha256/schema/Feature/producer/source binding）不可验证时，下游以 `required-artifact-missing` 阻塞；artifact 资格是额外门禁，priority 不得越过 gate。gate 原因经 `ReadyExecutionPlan.blocked[*].artifactGate` 投影，供 Feature review、晨报与 Observe 共用。
+- Worker 现为四类 TaskSpec workflow 生成 hash-anchored Task Outcome，并在 promotion 前校验 `run_record`、`dag_json`、`shell_verification` 等已知 required output；Feature review、晨报与 Observe 可引用 outcome 证据，缺失或不一致会以 ContractMismatch/EnvFailure 失败收口。
+- TaskSpec 现支持可选 `execution.workflow`，可确定性物化为任务 DAG 类型并展示在 Worker、Task Pool、晨报与 Observe；旧 QA 任务保持原有执行行为，同时给出需人工选择测试 workflow 的迁移提示。
 
 ## [0.13.0] - 2026-07-18
 

package/dist/executors/dag-pi-executor.js

@@ -272,7 +272,7 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep) {
         persona,
         step,
     });
-    const mapped = mapPiResultToDagNodeResult(result);
+    const mapped = mapPiResultToDagNodeResult(result, input.task.firstProtocolLine);
     if (!isWriteTask) {
         return mapped;
     }
@@ -313,17 +313,57 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep) {
         durationMs: mapped.durationMs || Date.now() - started,
     };
 }
-export function mapPiResultToDagNodeResult(result) {
+export function mapPiResultToDagNodeResult(result, firstProtocolLine) {
+    const assistantText = canonicalizeProtocolFirstLine(result.assistantText, firstProtocolLine);
     return {
         ok: result.ok,
-        stdout: result.assistantText || result.stdout,
+        stdout: assistantText || result.stdout,
         stderr: result.stderr,
         failureCategory: result.failureCategory,
         durationMs: result.durationMs,
-        assistantText: result.assistantText,
+        assistantText,
         backend: result.backend,
         sdkAttempted: result.sdkAttempted,
         tokensUsed: result.tokensUsed,
         parsedEvents: result.parsedEvents,
     };
 }
+function canonicalizeProtocolFirstLine(assistantText, firstProtocolLine) {
+    if (!assistantText || !firstProtocolLine)
+        return assistantText;
+    const lines = assistantText.split(/\r?\n/);
+    let protocolIndex = -1;
+    let protocolLine = "";
+    for (const [index, line] of lines.entries()) {
+        const normalized = normalizeProtocolLine(line);
+        if (normalized.startsWith(firstProtocolLine)) {
+            protocolIndex = index;
+            protocolLine = normalized;
+            break;
+        }
+    }
+    if (protocolIndex < 0)
+        return assistantText;
+    if (protocolIndex === 0) {
+        return [protocolLine, ...lines.slice(1)].join("\n");
+    }
+    const before = lines.slice(0, protocolIndex);
+    const after = lines.slice(protocolIndex + 1);
+    while (before.at(-1)?.trim() === "" &&
+        after.at(0)?.trim() === "") {
+        after.shift();
+    }
+    const bodyLines = [...before, ...after];
+    while (bodyLines.at(0)?.trim() === "")
+        bodyLines.shift();
+    while (bodyLines.at(-1)?.trim() === "")
+        bodyLines.pop();
+    return bodyLines.length > 0
+        ? `${protocolLine}\n\n${bodyLines.join("\n")}`
+        : protocolLine;
+}
+function normalizeProtocolLine(line) {
+    const trimmed = line.trim();
+    const emphasized = trimmed.match(/^(\*{1,3})\s*(.*?)\s*\1$/);
+    return (emphasized?.[2] ?? trimmed).trim();
+}

package/dist/worker/cli.js

@@ -176,17 +176,20 @@ export function buildAgentWorkerProgram() {
         .command("verify-final")
         .requiredOption("--feature-dir <dir>", "Feature directory containing acceptance.yaml and tasks/")
         .requiredOption("--repo <repo-root>", "Target repo root")
-        .requiredOption("--task-id <id>", "Completed qa-execute TaskSpec to rerun as dedicated final verification")
+        .requiredOption("--task-id <id>", "Completed final verification TaskSpec; typed backend/frontend outcomes are aggregated when present")
         .option("--loop-agent-bin <bin>", "loop-agent binary", "loop-agent")
         .option("--json", "Emit stable JSON")
+        .option("--evidence-mode <mode>", "Evidence aggregate: auto, qa-execute, or typed", "auto")
         .option("--expected-controller-version <version>", "Exact expected controller version (fail before writes if mismatched)")
         .option("--expected-controller-fingerprint <value>", "Exact expected controller fingerprint sha256:<hex> (fail before writes if mismatched)")
         .description("Run an independent HEAD-bound final QA verification and project Delivery evidence")
         .action(async (options) => {
+        if (options.evidenceMode !== "auto" && options.evidenceMode !== "qa-execute" && options.evidenceMode !== "typed")
+            throw new Error("feature verify-final --evidence-mode must be auto, qa-execute, or typed");
         const repoRoot = path.resolve(options.repo);
         const client = new LoopAgentClient({ loopAgentBin: options.loopAgentBin, artifactRoot: path.join(getTaskPoolRoot(repoRoot), "artifacts", `final-verification-${Date.now()}`), resolveIdentity: true });
-        const result = await runFeatureFinalVerification({ featureDir: path.resolve(options.featureDir), repoRoot, taskId: options.taskId, client, controllerIdentity: client.getIdentity(), controllerExpectation: buildIdentityExpectation(options) });
-        process.stdout.write(options.json ? `${JSON.stringify(result, null, 2)}\n` : `Feature: ${result.featureId}\nFinal verification: ${result.workerRunId}\nQA evidence: ${result.qaEvidencePath}\nFinal evidence: ${result.finalVerificationPath}\n`);
+        const result = await runFeatureFinalVerification({ featureDir: path.resolve(options.featureDir), repoRoot, taskId: options.taskId, client, controllerIdentity: client.getIdentity(), controllerExpectation: buildIdentityExpectation(options), evidenceMode: options.evidenceMode });
+        process.stdout.write(options.json ? `${JSON.stringify(result, null, 2)}\n` : `Feature: ${result.featureId}\nFinal verification: ${result.workerRunId}\nEvidence mode: ${result.evidenceMode ?? "qa-execute"}\nQA evidence: ${result.qaEvidencePath}\nFinal evidence: ${result.finalVerificationPath}${result.bundleEvidencePath ? `\nVerification bundle: ${result.bundleEvidencePath}` : ""}\n`);
     });
     feature
         .command("delivery")

package/dist/worker/delivery/final-verification.js

@@ -8,11 +8,13 @@ import { controllerIdentitiesMatch, controllerIdentityExpectationFailure, resolv
 import { acceptanceSpecSchema } from "../task-graph/acceptance-schema.js";
 import { taskGraphSpecSchema } from "../task-graph/task-graph-schema.js";
 import { validateFeatureTaskGraph } from "../task-graph/validate.js";
-import { getRunsJsonlPath, getTaskPoolRoot, readJsonlFile, recordTaskPoolRun } from "../pool/run-store.js";
+import { getRunsJsonlPath, getTaskPoolRoot, readFeatureTaskPoolStates, readJsonlFile, recordTaskPoolRun } from "../pool/run-store.js";
+import { readVerifiedOutcome } from "../outcomes/store.js";
 import { buildWorkerRunId, runTaskSpec } from "../run-task/run-task.js";
 import { taskSpecSchema } from "../task-spec/schema.js";
 import { preflightTargetRepo } from "../preflight.js";
 import { gitTransactionRecordSchema, transactionRecordPath } from "./git-transaction.js";
+import { buildFeatureVerificationBundle, writeFeatureVerificationBundle, } from "./verification-bundle.js";
 const execFileAsync = promisify(execFile);
 export async function runFeatureFinalVerification(input) {
     const dependencies = {
@@ -103,11 +105,60 @@ export async function runFeatureFinalVerification(input) {
         allSpecs.set(graphNode.id, taskSpecSchema.parse(YAML.parse(await readFile(path.join(featureDir, "tasks", graphNode.task), "utf-8"))));
     }
     const acceptance = acceptanceSpecSchema.parse(YAML.parse(await readFile(path.join(featureDir, "acceptance.yaml"), "utf-8")));
-    const qaRuns = latestSuccessfulQaRuns(runs, allSpecs, taskSpec.id, featureId);
-    if (qaRuns.length === 0)
-        throw new Error("no prior successful qa-execute runs are available for the QA aggregate");
-    const coveredAcIds = [...new Set(qaRuns.flatMap((run) => allSpecs.get(run.taskId)?.acceptance_refs ?? []))];
     const requiredAcIds = acceptance.acceptance.filter((item) => item.priority === "must").map((item) => item.id);
+    const states = await readFeatureTaskPoolStates(repoRoot, featureId);
+    for (const [taskId, spec] of allSpecs) {
+        if ((spec.execution?.workflow === "backend-test" || spec.execution?.workflow === "frontend-test") && ["Failed", "Blocked"].includes(states[taskId]?.status ?? "")) {
+            throw new Error(`final verification has an unresolved typed test task: ${taskId}`);
+        }
+    }
+    const evidenceMode = input.evidenceMode ?? "auto";
+    let bundleRef;
+    let bundlePayload;
+    let qaRuns = latestSuccessfulQaRuns(runs, allSpecs, taskSpec.id, featureId);
+    let coveredAcIds = [...new Set(qaRuns.flatMap((run) => allSpecs.get(run.taskId)?.acceptance_refs ?? []))];
+    const typedCapable = requiredAcIds.length > 0 && requiredAcIds.every((acId) => {
+        const item = acceptance.acceptance.find((candidate) => candidate.id === acId);
+        const refs = item?.verification.verification_task_refs ?? [];
+        return refs.length > 0 && refs.every((taskId) => {
+            const workflow = allSpecs.get(taskId)?.execution?.workflow;
+            return workflow === "backend-test" || workflow === "frontend-test";
+        });
+    });
+    if (evidenceMode === "qa-execute" && !qaRuns.length) {
+        throw new Error("evidence-mode qa-execute requires at least one successful qa-execute run");
+    }
+    if ((evidenceMode === "auto" && typedCapable) || evidenceMode === "typed") {
+        const typedRuns = selectCurrentTypedVerificationRuns({
+            featureId,
+            acceptance: acceptance.acceptance,
+            specs: allSpecs,
+            states,
+            runs,
+        });
+        const outcomes = new Map();
+        for (const run of typedRuns) {
+            const outcome = await readVerifiedOutcome({ repoRoot, workerRunId: run.workerRunId, outcomePath: run.outcomePath, outcomeSha256: run.outcomeSha256 });
+            if (outcome)
+                outcomes.set(run.workerRunId, outcome);
+        }
+        const bundle = buildFeatureVerificationBundle({
+            featureId,
+            headSha,
+            runs: typedRuns,
+            specs: allSpecs,
+            outcomes,
+            acceptance: acceptance.acceptance,
+            implementationTaskIds: new Set(acceptance.acceptance.flatMap((item) => item.verification.implementation_task_refs ?? []).filter((taskId) => states[taskId]?.status === "Done")),
+            controllerIdentity,
+        });
+        bundleRef = await writeFeatureVerificationBundle(repoRoot, bundle);
+        bundlePayload = bundle;
+        qaRuns = typedRuns;
+        coveredAcIds = bundle.acceptance.filter((item) => item.status === "covered").map((item) => item.acId);
+    }
+    if (qaRuns.length === 0)
+        throw new Error("no prior successful typed test or qa-execute runs are available for the QA aggregate");
     for (const acId of requiredAcIds)
         if (!coveredAcIds.includes(acId))
             throw new Error(`QA aggregate does not cover required acceptance: ${acId}`);
@@ -118,10 +169,11 @@ export async function runFeatureFinalVerification(input) {
     const qaEvidencePath = path.join(evidenceDir, "qa-pass.json");
     const finalVerificationPath = path.join(evidenceDir, "final-verification.json");
     await writeEvidencePairAtomic(evidenceDir, {
-        qa: { schemaVersion: 1, featureId, verdict: "passed", acIds: requiredAcIds, runs: qaRuns.map(runRef) },
-        final: { schemaVersion: 1, featureId, kind: "final-verification", status: "passed", headSha, run: runRef(finalRun), shellSummary: { path: summaryRelative, sha256: createHash("sha256").update(summary).digest("hex") } },
+        qa: { schemaVersion: 1, featureId, verdict: "passed", acIds: requiredAcIds, runs: qaRuns.map(runRef), ...(bundleRef ? { bundle: bundleRef } : {}) },
+        final: { schemaVersion: 1, featureId, kind: "final-verification", status: "passed", headSha, run: runRef(finalRun), shellSummary: { path: summaryRelative, sha256: createHash("sha256").update(summary).digest("hex") }, ...(bundleRef ? { bundle: bundleRef } : {}) },
+        ...(bundlePayload ? { bundle: bundlePayload } : {}),
     });
-    return { schemaVersion: 1, featureId, taskId: taskSpec.id, workerRunId: finalRun.workerRunId, headSha, qaEvidencePath: repoRef(repoRoot, qaEvidencePath), finalVerificationPath: repoRef(repoRoot, finalVerificationPath), qaRunCount: qaRuns.length, ...(controllerIdentity ? { controllerIdentity } : {}) };
+    return { schemaVersion: 1, featureId, taskId: taskSpec.id, workerRunId: finalRun.workerRunId, headSha, qaEvidencePath: repoRef(repoRoot, qaEvidencePath), finalVerificationPath: repoRef(repoRoot, finalVerificationPath), qaRunCount: qaRuns.length, ...(bundleRef ? { bundleEvidencePath: bundleRef.path, bundleSha256: bundleRef.sha256, evidenceMode: "typed" } : { evidenceMode: "qa-execute" }), ...(controllerIdentity ? { controllerIdentity } : {}) };
 }
 export function latestSuccessfulQaRuns(runs, specs, excludedTaskId, featureId) {
     const byTask = new Map();
@@ -130,6 +182,40 @@ export function latestSuccessfulQaRuns(runs, specs, excludedTaskId, featureId) {
             byTask.set(run.taskId, run);
     return [...byTask.values()].sort((a, b) => a.taskId.localeCompare(b.taskId));
 }
+/**
+ * Typed verification is bound to the canonical Feature-scoped Task Pool state,
+ * never to an arbitrary historical success in runs.jsonl. Each required AC
+ * verification task must be Done and identify exactly one succeeded run.
+ */
+function selectCurrentTypedVerificationRuns(input) {
+    const requiredTaskIds = [
+        ...new Set(input.acceptance.flatMap((item) => item.verification.verification_task_refs ?? [])),
+    ];
+    const selected = [];
+    for (const taskId of requiredTaskIds) {
+        const spec = input.specs.get(taskId);
+        const workflow = spec?.execution?.workflow;
+        if (workflow !== "backend-test" && workflow !== "frontend-test") {
+            throw new Error(`typed verification TaskSpec is not a typed test: ${taskId}`);
+        }
+        const state = input.states[taskId];
+        if (state?.status !== "Done" || !state.workerRunId) {
+            throw new Error(`required typed verification task is not Done: ${taskId}`);
+        }
+        const matches = input.runs.filter((run) => run.featureId === input.featureId &&
+            run.taskId === taskId &&
+            run.workerRunId === state.workerRunId);
+        if (matches.length !== 1) {
+            throw new Error(`current Task Pool run is missing or ambiguous: ${taskId}`);
+        }
+        const run = matches[0];
+        if (run.status !== "succeeded" || run.workflow !== workflow) {
+            throw new Error(`current Task Pool run is not a succeeded typed test: ${taskId}`);
+        }
+        selected.push(run);
+    }
+    return selected;
+}
 async function reusableFinalRun(repoRoot, runs, taskId, featureId, record, now, controllerIdentity) {
     const latestCheckpointAt = Math.max(...record.checkpoints.map((entry) => new Date(entry.createdAt).getTime()));
     for (const run of [...runs].reverse()) {
@@ -162,6 +248,8 @@ export async function writeEvidencePairAtomic(evidenceDir, value, fs = { rm }) {
     await mkdir(staging, { recursive: true });
     await writeFile(path.join(staging, "qa-pass.json"), `${JSON.stringify(value.qa, null, 2)}\n`);
     await writeFile(path.join(staging, "final-verification.json"), `${JSON.stringify(value.final, null, 2)}\n`);
+    if (value.bundle)
+        await writeFile(path.join(staging, "feature-verification-bundle.json"), `${JSON.stringify(value.bundle, null, 2)}\n`);
     let backedUp = false;
     try {
         await rename(evidenceDir, backup);

package/dist/worker/delivery/package.js

@@ -12,6 +12,7 @@ import { taskGraphSpecSchema } from "../task-graph/task-graph-schema.js";
 import { validateFeatureTaskGraph } from "../task-graph/validate.js";
 import { taskSpecSchema } from "../task-spec/schema.js";
 import { gitTransactionRecordSchema, transactionRecordPath } from "./git-transaction.js";
+import { readVerifiedBundle, verifyBundleCurrentStateBindings, verifyBundleOutcomes, verifyBundleTaskSpecBindings } from "./verification-bundle.js";
 const execFileAsync = promisify(execFile);
 const hashedRefSchema = z.object({ path: z.string().min(1), sha256: z.string().regex(/^[a-f0-9]{64}$/) }).strict();
 export const acceptanceCoverageArtifactSchema = z.object({
@@ -76,8 +77,8 @@ const evidenceRunSchema = z.object({
     recordedAt: z.string().datetime(),
     controllerIdentity: controllerIdentityEvidenceSchema.optional(),
 }).strict();
-const qaEvidenceSchema = z.object({ schemaVersion: z.literal(1), featureId: z.string(), verdict: z.literal("passed"), acIds: z.array(z.string()).min(1), runs: z.array(evidenceRunSchema).min(1) }).strict();
-const finalVerificationSchema = z.object({ schemaVersion: z.literal(1), featureId: z.string(), kind: z.literal("final-verification"), status: z.literal("passed"), headSha: z.string().regex(/^[a-f0-9]{40}$/), run: evidenceRunSchema, shellSummary: hashedRefSchema }).strict();
+const qaEvidenceSchema = z.object({ schemaVersion: z.literal(1), featureId: z.string(), verdict: z.literal("passed"), acIds: z.array(z.string()).min(1), runs: z.array(evidenceRunSchema).min(1), bundle: hashedRefSchema.optional() }).strict();
+const finalVerificationSchema = z.object({ schemaVersion: z.literal(1), featureId: z.string(), kind: z.literal("final-verification"), status: z.literal("passed"), headSha: z.string().regex(/^[a-f0-9]{40}$/), run: evidenceRunSchema, shellSummary: hashedRefSchema, bundle: hashedRefSchema.optional() }).strict();
 const workerRunEvidenceSchema = z.object({ schemaVersion: z.literal(1), status: z.literal("succeeded"), workerRunId: z.string(), businessId: z.string(), featureId: z.string(), reportDecision: z.object({ succeeded: z.literal(true) }).passthrough(), commands: z.array(z.object({ name: z.string(), result: z.object({ ok: z.literal(true) }).passthrough() }).passthrough()).min(1), controllerIdentity: controllerIdentityEvidenceSchema.optional() }).passthrough();
 export async function prepareFeatureDelivery(input) {
     const repoRoot = path.resolve(input.repoRoot);
@@ -111,6 +112,10 @@ export async function prepareFeatureDelivery(input) {
         taskSpecs.set(node.id, taskSpecSchema.parse(YAML.parse(await readFile(path.join(featureDir, "tasks", node.task), "utf-8"))));
     const qaFact = await canonicalQaEvidence(repoRoot, input.qaEvidencePath, featureId, runs, taskSpecs, now, blockers);
     const finalFact = record ? await canonicalFinalEvidence(repoRoot, input.finalVerificationPath, featureId, runs, taskSpecs, record, now, blockers) : undefined;
+    if (qaFact?.data.bundle || finalFact?.data.bundle) {
+        if (!qaFact?.data.bundle || !finalFact?.data.bundle || qaFact.data.bundle.path !== finalFact.data.bundle.path || qaFact.data.bundle.sha256 !== finalFact.data.bundle.sha256)
+            blockers.push("QA and final verification do not bind the same Feature Verification Bundle");
+    }
     if (qaFact && finalFact && qaFact.data.runs.some((entry) => entry.workerRunId === finalFact.data.run.workerRunId))
         blockers.push("final verification must use a dedicated run not included in the QA aggregate");
     const qaEvidence = qaFact?.ref;
@@ -340,11 +345,20 @@ async function canonicalQaEvidence(repoRoot, ref, featureId, runs, specs, now, b
         const data = qaEvidenceSchema.parse(JSON.parse(await readFile(await safeRepoPath(repoRoot, ref), "utf-8")));
         if (data.featureId !== featureId)
             throw new Error("Feature ownership mismatch");
+        const bundle = data.bundle ? await readVerifiedBundle({ repoRoot, ref: data.bundle }) : undefined;
+        if (data.bundle && (!bundle || bundle.featureId !== featureId || !await verifyBundleOutcomes(repoRoot, bundle) || !verifyBundleTaskSpecBindings(bundle, specs) || !await verifyBundleCurrentStateBindings(repoRoot, bundle)))
+            throw new Error("Feature Verification Bundle is missing, changed, has invalid typed outcomes, no longer matches TaskSpecs, or no longer matches current Task Pool state");
+        const typedByRun = new Map((bundle ? [...bundle.backendTests, ...bundle.frontendTests] : []).map((entry) => [entry.workerRunId, entry]));
         for (const entry of data.runs) {
-            const run = assertEvidenceRun(entry, featureId, runs, specs, now, true);
+            const run = assertEvidenceRun(entry, featureId, runs, specs, now, !bundle);
+            if (bundle) {
+                const typed = typedByRun.get(entry.workerRunId);
+                if (!typed || typed.taskId !== entry.taskId || run.workflow !== typed.workflow)
+                    throw new Error(`QA bundle run is not a declared typed outcome: ${entry.workerRunId}`);
+            }
             await readCanonicalWorkerRun(repoRoot, run);
         }
-        const allowedAcIds = new Set(data.runs.flatMap((entry) => specs.get(entry.taskId)?.acceptance_refs ?? []));
+        const allowedAcIds = bundle ? new Set(bundle.acceptance.filter((item) => item.status === "covered").map((item) => item.acId)) : new Set(data.runs.flatMap((entry) => specs.get(entry.taskId)?.acceptance_refs ?? []));
         for (const acId of data.acIds)
             if (!allowedAcIds.has(acId))
                 throw new Error(`QA run scope does not cover ${acId}`);
@@ -363,6 +377,11 @@ async function canonicalFinalEvidence(repoRoot, ref, featureId, runs, specs, rec
         const data = finalVerificationSchema.parse(JSON.parse(await readFile(await safeRepoPath(repoRoot, ref), "utf-8")));
         if (data.featureId !== featureId)
             throw new Error("Feature ownership mismatch");
+        if (data.bundle) {
+            const bundle = await readVerifiedBundle({ repoRoot, ref: data.bundle });
+            if (!bundle || bundle.featureId !== featureId || bundle.headSha !== record.lastCheckpoint || !await verifyBundleOutcomes(repoRoot, bundle) || !verifyBundleTaskSpecBindings(bundle, specs) || !await verifyBundleCurrentStateBindings(repoRoot, bundle))
+                throw new Error("Feature Verification Bundle is missing, changed, does not bind the Delivery HEAD, no longer matches TaskSpecs, or no longer matches current Task Pool state");
+        }
         const taskPoolRun = assertEvidenceRun(data.run, featureId, runs, specs, now, true);
         if (data.headSha !== record.lastCheckpoint)
             throw new Error("final verification is not bound to Delivery HEAD");