@tea-agent/loop-agent 0.24.11-beta.0 → 0.25.1

package/dist/worker/cli.js

@@ -31,8 +31,11 @@ import { approveFollowUp } from "./follow-up/approve.js";
 import { prepareFeatureDelivery } from "./delivery/package.js";
 import { previewFeatureCloseout, renderCloseoutPreview, } from "./closeout/preview.js";
 import { applyFeatureCloseout } from "./closeout/apply.js";
+import { advanceFeature, renderFeatureAdvance, } from "./feature/advance.js";
+import { diagnoseFeature, renderFeatureDoctor, } from "./feature/doctor.js";
+import { FEATURE_SCAFFOLD_TEMPLATES, ScaffoldError, scaffoldFeaturePacket, } from "./feature/scaffold.js";
 import { projectMonthlyMetrics } from "./metrics/projector.js";
-import { runFeatureFinalVerification } from "./delivery/final-verification.js";
+import { defaultFeatureEvidencePaths, runFeatureFinalVerification, } from "./delivery/final-verification.js";
 import { advanceGitCheckpoint } from "./delivery/git-transaction.js";
 export function buildAgentWorkerProgram() {
     const program = new Command();
@@ -41,7 +44,8 @@ export function buildAgentWorkerProgram() {
         .description("Local product-line worker utilities for TaskSpec validation")
         .version(readPackageVersion(path.dirname(path.dirname(path.dirname(fileURLToPath(import.meta.url))))) ?? "0.0.0", "-V, --version", "display version")
         .showHelpAfterError()
-        .showSuggestionAfterError();
+        .showSuggestionAfterError()
+        .enablePositionalOptions();
     const task = program.command("task").description("TaskSpec utilities");
     const batch = program
         .command("batch")
@@ -244,6 +248,125 @@ export function buildAgentWorkerProgram() {
         if (result.status === "failed" || result.status === "needs-action")
             process.exitCode = 1;
     });
+    feature
+        .command("advance")
+        .requiredOption("--feature-dir <dir>", "Feature directory containing acceptance.yaml and tasks/")
+        .requiredOption("--repo <repo-root>", "Target repo root")
+        .option("--task-id <id>", "Final verification TaskSpec id (default: resolve FINAL-VERIFY* from Feature review)")
+        .option("--loop-agent-bin <bin>", "loop-agent binary", "loop-agent")
+        .option("--evidence-mode <mode>", "Evidence aggregate for verify-final: auto, qa-execute, or typed", "auto")
+        .option("--qa-evidence <path>", "Override QA pass evidence path")
+        .option("--final-verification <path>", "Override final verification evidence path")
+        .option("--waivers <path>", "Repo-local acceptance waiver decisions JSON")
+        .option("--dry-run", "Run verify-final + delivery dry-run + closeout preview without Delivery writes or closeout apply")
+        .option("--apply", "After ready closeout preview, apply Feature Closeout (requires --owner)")
+        .option("--owner <owner>", "Closeout owner when using --apply")
+        .option("--expected-controller-version <version>", "Exact expected controller version")
+        .option("--expected-controller-fingerprint <value>", "Exact expected controller fingerprint sha256:<hex>")
+        .option("--json", "Emit stable JSON")
+        .description("Orchestrate ADR 0007 delivery path: verify-final → delivery → closeout preview[/apply]")
+        .action(async (options) => {
+        if (options.evidenceMode !== "auto" &&
+            options.evidenceMode !== "qa-execute" &&
+            options.evidenceMode !== "typed") {
+            throw new Error("feature advance --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", `feature-advance-${Date.now()}`),
+            resolveIdentity: true,
+        });
+        const result = await advanceFeature({
+            featureDir: path.resolve(options.featureDir),
+            repoRoot,
+            ...(options.taskId ? { taskId: options.taskId } : {}),
+            client,
+            controllerIdentity: client.getIdentity(),
+            controllerExpectation: buildIdentityExpectation(options),
+            evidenceMode: options.evidenceMode,
+            ...(options.qaEvidence
+                ? { qaEvidencePath: options.qaEvidence }
+                : {}),
+            ...(options.finalVerification
+                ? { finalVerificationPath: options.finalVerification }
+                : {}),
+            ...(options.waivers ? { waiverPath: options.waivers } : {}),
+            dryRun: options.dryRun ?? false,
+            apply: options.apply ?? false,
+            ...(options.owner ? { owner: options.owner } : {}),
+        });
+        process.stdout.write(options.json
+            ? `${JSON.stringify(result, null, 2)}\n`
+            : renderFeatureAdvance(result));
+        if (result.status === "failed" ||
+            result.status === "blocked") {
+            process.exitCode = 1;
+        }
+    });
+    feature
+        .command("doctor")
+        .requiredOption("--feature-dir <dir>", "Feature directory containing acceptance.yaml and tasks/")
+        .requiredOption("--repo <repo-root>", "Target repo root")
+        .option("--json", "Emit stable JSON")
+        .description("Read-only Feature delivery readiness diagnosis (evidence, pool states, dirty worktree)")
+        .action(async (options) => {
+        const result = await diagnoseFeature({
+            featureDir: path.resolve(options.featureDir),
+            repoRoot: path.resolve(options.repo),
+        });
+        process.stdout.write(options.json
+            ? `${JSON.stringify(result, null, 2)}\n`
+            : renderFeatureDoctor(result));
+        if (result.status === "blocked")
+            process.exitCode = 1;
+    });
+    feature
+        .command("scaffold")
+        .requiredOption("--repo <repo-root>", "Target repo root")
+        .option("--template <id>", `Locked template: ${FEATURE_SCAFFOLD_TEMPLATES.join(" | ")}`)
+        .option("--feature-id <id>", "Feature id (F-YYYY-NNN)")
+        .option("--title <text>", "Human title")
+        .option("--description <text>", "Optional longer description")
+        .option("--be-path <pattern>", "Repo-relative backend allowed path (repeatable)", (value, previous) => [...previous, value], [])
+        .option("--fe-path <pattern>", "Repo-relative frontend allowed path (repeatable)", (value, previous) => [...previous, value], [])
+        .option("--contract-path <path>", "fe-with-api contract path (default docs/contracts/<feature-id>/api.md)")
+        .option("--verify-command <command>", "Explicit verify command for implementation tasks (repeatable)", (value, previous) => [...previous, value], [])
+        .option("--batch <file>", "YAML/JSON batch list (mutually exclusive with single-feature flags)")
+        .option("--dry-run", "Parse/render/validate without writing features/")
+        .option("--json", "Emit stable JSON only")
+        .description("Deterministically scaffold a Feature Packet (no model, no Task Pool, no fullstack-v1 default)")
+        .action(async (options) => {
+        try {
+            const result = options.batch
+                ? await scaffoldFeaturePacket({
+                    repoRoot: path.resolve(options.repo),
+                    batchFile: path.resolve(options.batch),
+                    dryRun: options.dryRun ?? false,
+                })
+                : await scaffoldFeaturePacket({
+                    repoRoot: path.resolve(options.repo),
+                    dryRun: options.dryRun ?? false,
+                    feature: {
+                        featureId: options.featureId ?? "",
+                        title: options.title ?? "",
+                        template: (options.template ??
+                            ""),
+                        description: options.description,
+                        bePaths: options.bePath,
+                        fePaths: options.fePath,
+                        contractPath: options.contractPath,
+                        verifyCommands: options.verifyCommand,
+                    },
+                });
+            process.stdout.write(options.json
+                ? `${JSON.stringify(result, null, 2)}\n`
+                : renderFeatureScaffold(result));
+        }
+        catch (error) {
+            handleScaffoldCliError(error, options.json ?? false);
+        }
+    });
     feature
         .command("verify-final")
         .requiredOption("--feature-dir <dir>", "Feature directory containing acceptance.yaml and tasks/")
@@ -283,18 +406,30 @@ export function buildAgentWorkerProgram() {
         .command("delivery")
         .requiredOption("--feature-dir <dir>", "Feature directory containing acceptance.yaml and tasks/")
         .requiredOption("--repo <repo-root>", "Target repo root")
-        .requiredOption("--qa-evidence <path>", "Repo-local QA pass evidence")
-        .requiredOption("--final-verification <path>", "Repo-local fresh final verification evidence")
+        .option("--qa-evidence <path>", "Repo-local QA pass evidence (default: .harness/task-pool/evidence/<featureId>/qa-pass.json from verify-final)")
+        .option("--final-verification <path>", "Repo-local final verification evidence (default: .../final-verification.json from verify-final)")
         .option("--waivers <path>", "Repo-local acceptance waiver decisions JSON")
         .option("--dry-run", "Validate and show the Delivery Package plan without writes")
         .option("--json", "Emit stable JSON")
         .description("Validate checkpointed Feature evidence and prepare a local Delivery Package")
         .action(async (options) => {
+        const featureDir = path.resolve(options.featureDir);
+        const repoRoot = path.resolve(options.repo);
+        // ADR 0007: default to verify-final evidence locations when omitted.
+        let qaEvidencePath = options.qaEvidence;
+        let finalVerificationPath = options.finalVerification;
+        if (!qaEvidencePath || !finalVerificationPath) {
+            const validation = await validateFeatureTaskGraph(featureDir);
+            const defaults = defaultFeatureEvidencePaths(validation.featureId);
+            qaEvidencePath = qaEvidencePath ?? defaults.qaEvidencePath;
+            finalVerificationPath =
+                finalVerificationPath ?? defaults.finalVerificationPath;
+        }
         const result = await prepareFeatureDelivery({
-            featureDir: path.resolve(options.featureDir),
-            repoRoot: path.resolve(options.repo),
-            qaEvidencePath: options.qaEvidence,
-            finalVerificationPath: options.finalVerification,
+            featureDir,
+            repoRoot,
+            qaEvidencePath,
+            finalVerificationPath,
             ...(options.waivers ? { waiverPath: options.waivers } : {}),
             dryRun: options.dryRun ?? false,
         });
@@ -593,18 +728,17 @@ export function buildAgentWorkerProgram() {
         process.stdout.write(`${JSON.stringify(snapshot)}\n`);
     });
     consoleCmd
-        .command("serve")
-        .requiredOption("--repo <repo-root>", "Target repo root")
+        .description("Loop Operator Console (local); bare `agent-worker console` starts it directly (repo defaults to current working directory, port defaults to 8790)")
+        .enablePositionalOptions()
+        .passThroughOptions()
+        .option("--repo <repo-root>", "Target repo root (default: current working directory)", process.cwd())
         .option("--port <port>", "HTTP port", "8790")
         .option("--host <host>", "Bind host (default 127.0.0.1; use 0.0.0.0 for LAN, no network auth)", "127.0.0.1")
         .option("--debug", "Log request source/method/path/status to stderr")
         .option("--app-data <path>", "Override Console application-data root (Draft/Operation/confirmation)")
-        .description("Start Loop Operator Console HTTP server (Operate + Inspect; static SPA + Operator API)")
         .action(async (options) => {
-        const { createConsoleServer } = await import("./console/server.js");
-        const repoRoot = path.resolve(options.repo);
-        const server = await createConsoleServer({
-            repoRoot,
+        await runConsoleServe({
+            repoRoot: path.resolve(options.repo),
             host: options.host,
             port: Number.parseInt(options.port, 10),
             debug: options.debug === true,
@@ -612,13 +746,25 @@ export function buildAgentWorkerProgram() {
                 ? path.resolve(options.appData)
                 : undefined,
         });
-        process.stdout.write(`${server.url}\n`);
-        await new Promise((resolve) => {
-            const shutdown = () => resolve();
-            process.once("SIGINT", shutdown);
-            process.once("SIGTERM", shutdown);
+    });
+    consoleCmd
+        .command("serve")
+        .option("--repo <repo-root>", "Target repo root (default: current working directory)", process.cwd())
+        .option("--port <port>", "HTTP port", "8790")
+        .option("--host <host>", "Bind host (default 127.0.0.1; use 0.0.0.0 for LAN, no network auth)", "127.0.0.1")
+        .option("--debug", "Log request source/method/path/status to stderr")
+        .option("--app-data <path>", "Override Console application-data root (Draft/Operation/confirmation)")
+        .description("Start Loop Operator Console HTTP server (compat entry; equivalent to bare `agent-worker console`)")
+        .action(async (options) => {
+        await runConsoleServe({
+            repoRoot: path.resolve(options.repo),
+            host: options.host,
+            port: Number.parseInt(options.port, 10),
+            debug: options.debug === true,
+            appDataRoot: options.appData
+                ? path.resolve(options.appData)
+                : undefined,
         });
-        await server.close();
     });
     consoleCmd
         .command("doctor")
@@ -693,11 +839,80 @@ export async function main(argv = process.argv) {
 async function readTaskYaml(taskSpecPath) {
     return YAML.parse(await readFile(taskSpecPath, "utf-8"));
 }
+/** Shared console serve entry used by both bare `console` and `console serve`. */
+async function runConsoleServe(options) {
+    const { createConsoleServer } = await import("./console/server.js");
+    try {
+        const server = await createConsoleServer({
+            repoRoot: options.repoRoot,
+            host: options.host,
+            port: options.port,
+            debug: options.debug === true,
+            appDataRoot: options.appDataRoot,
+        });
+        process.stdout.write(`${server.url}\n`);
+        await new Promise((resolve) => {
+            const shutdown = () => resolve();
+            process.once("SIGINT", shutdown);
+            process.once("SIGTERM", shutdown);
+        });
+        await server.close();
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        const code = error?.code;
+        const isPortInUse = code === "EADDRINUSE" ||
+            /listen EADDRINUSE/i.test(detail) ||
+            /address already in use/i.test(detail);
+        if (isPortInUse) {
+            process.stderr.write(`端口 ${options.port} 已被占用，请使用 --port <port> 指定其它端口后重试。\n`);
+            process.exit(1);
+        }
+        process.stderr.write(`${detail}\n`);
+        process.exit(1);
+    }
+}
 function handlePoolRecoveryCliError(error) {
     const detail = error instanceof Error ? error.message : String(error);
     process.stderr.write(`${detail}\n`);
     process.exitCode = 1;
 }
+function handleScaffoldCliError(error, json) {
+    const code = error instanceof ScaffoldError ? error.code : "write-failed";
+    const message = error instanceof Error ? error.message : String(error);
+    const details = error instanceof ScaffoldError ? error.details : undefined;
+    if (json) {
+        process.stdout.write(`${JSON.stringify({
+            schemaVersion: 1,
+            ok: false,
+            code,
+            message,
+            ...(details !== undefined ? { details } : {}),
+        }, null, 2)}\n`);
+    }
+    else {
+        process.stderr.write(`${message}\n`);
+    }
+    process.exitCode = 1;
+}
+function renderFeatureScaffold(result) {
+    const lines = [
+        result.dryRun
+            ? `Feature scaffold dry-run: ${result.features.length} packet(s) validated`
+            : `Feature scaffold wrote ${result.features.length} packet(s)`,
+        "",
+    ];
+    for (const feature of result.features) {
+        lines.push(`- ${feature.featureId} [${feature.template}] → ${feature.featureDir}`);
+    }
+    if (!result.dryRun && result.writtenPaths.length > 0) {
+        lines.push("", "Written:");
+        for (const p of result.writtenPaths)
+            lines.push(`  ${p}`);
+    }
+    lines.push("");
+    return `${lines.join("\n")}\n`;
+}
 function handleFollowUpCliError(error, json, action) {
     const detail = error instanceof Error ? error.message : String(error);
     if (!json)

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

@@ -16,6 +16,18 @@ import { preflightTargetRepo } from "../preflight.js";
 import { gitTransactionRecordSchema, transactionRecordPath } from "./git-transaction.js";
 import { buildFeatureVerificationBundle, writeFeatureVerificationBundle, } from "./verification-bundle.js";
 const execFileAsync = promisify(execFile);
+/**
+ * Canonical Delivery evidence locations written by `feature verify-final`
+ * (ADR 0007). Paths are repo-relative with forward slashes.
+ */
+export function defaultFeatureEvidencePaths(featureId) {
+    const base = `.harness/task-pool/evidence/${featureId}`;
+    return {
+        qaEvidencePath: `${base}/qa-pass.json`,
+        finalVerificationPath: `${base}/final-verification.json`,
+        bundleEvidencePath: `${base}/feature-verification-bundle.json`,
+    };
+}
 export async function runFeatureFinalVerification(input) {
     const dependencies = {
         preflight: preflightTargetRepo,

package/dist/worker/delivery/git-transaction.js

@@ -101,11 +101,12 @@ export async function finalizeGitTask(transaction, outcome) {
     await assertTransactionPosition(transaction.repoRoot, current);
     const currentIgnored = await readIgnoredBaseline(transaction.repoRoot);
     const ignoredBaselineByPath = new Map(current.ignoredBaseline.map((entry) => [entry.path, entry.sha256]));
-    const changedBaselineIgnored = currentIgnored.filter((entry) => ignoredBaselineByPath.has(entry.path) && ignoredBaselineByPath.get(entry.path) !== entry.sha256).map((entry) => entry.path);
-    const missingBaselineIgnored = current.ignoredBaseline.filter((entry) => !currentIgnored.some((candidate) => candidate.path === entry.path)).map((entry) => entry.path);
-    if (changedBaselineIgnored.length > 0 || missingBaselineIgnored.length > 0) {
-        throw new Error(`pre-existing ignored file changed during Git transaction: ${[...changedBaselineIgnored, ...missingBaselineIgnored].join(", ")}`);
-    }
+    const changedBaselineIgnored = currentIgnored
+        .filter((entry) => ignoredBaselineByPath.has(entry.path) && ignoredBaselineByPath.get(entry.path) !== entry.sha256)
+        .map((entry) => entry.path);
+    const missingBaselineIgnored = current.ignoredBaseline
+        .filter((entry) => !currentIgnored.some((candidate) => candidate.path === entry.path))
+        .map((entry) => entry.path);
     const existing = current.checkpoints.find((entry) => entry.workerRunId === outcome.workerRunId);
     if (outcome.status === "reused" || existing) {
         if (!existing)
@@ -123,12 +124,28 @@ export async function finalizeGitTask(transaction, outcome) {
     const newIgnored = currentIgnored.map((entry) => entry.path).filter((entry) => !ignoredBaselineByPath.has(entry));
     if (outcome.status === "succeeded") {
         const allowedPaths = expandAllowedPathsForWorkflow(resolveWorkflow(outcome.taskSpec).workflow, outcome.taskSpec.constraints.allowed_paths);
+        const isAllowedEvidencePath = (entry) => !isSensitivePath(entry) &&
+            !isEphemeralToolCachePath(entry) &&
+            allowedPaths.some((glob) => matchesGlob(entry, glob));
+        // Pre-existing ignored evidence under allowed_paths may be rewritten by
+        // FINAL-VERIFY smoke / verify-final and must force-add into the checkpoint.
+        // Other baseline ignored mutations remain fail-closed (e.g. dist/, secrets).
+        const blockedBaselineChanged = changedBaselineIgnored.filter((entry) => !isAllowedEvidencePath(entry));
+        const blockedBaselineMissing = missingBaselineIgnored.filter((entry) => !isEphemeralToolCachePath(entry) && !isAllowedEvidencePath(entry));
+        if (blockedBaselineChanged.length > 0 || blockedBaselineMissing.length > 0) {
+            throw new Error(`pre-existing ignored file changed during Git transaction: ${[...blockedBaselineChanged, ...blockedBaselineMissing].join(", ")}`);
+        }
         // Evidence under allowed_paths may be gitignored for local convenience (e.g.
         // reports/welcome/** smoke JSON) but must still checkpoint for Task Pool Done.
         // Sensitive / out-of-scope ignored files remain fail-closed; ephemeral tool
         // caches neither block nor force-add.
         const forceAddIgnored = [];
         const blockedIgnored = [];
+        const rewrittenBaselineEvidence = changedBaselineIgnored.filter((entry) => isAllowedEvidencePath(entry));
+        for (const entry of rewrittenBaselineEvidence) {
+            if (!forceAddIgnored.includes(entry))
+                forceAddIgnored.push(entry);
+        }
         for (const entry of newIgnored) {
             if (isEphemeralToolCachePath(entry))
                 continue;
@@ -137,7 +154,8 @@ export async function finalizeGitTask(transaction, outcome) {
                 continue;
             }
             if (allowedPaths.some((glob) => matchesGlob(entry, glob))) {
-                forceAddIgnored.push(entry);
+                if (!forceAddIgnored.includes(entry))
+                    forceAddIgnored.push(entry);
             }
             else {
                 blockedIgnored.push(entry);
@@ -166,7 +184,10 @@ export async function finalizeGitTask(transaction, outcome) {
             await assertTransactionPosition(transaction.repoRoot, { ...current, lastCheckpoint: commit });
             await assertCheckpointMetadata(transaction.repoRoot, commit, outcome.taskSpec, outcome.workerRunId);
             const afterCommitIgnored = await readIgnoredBaseline(transaction.repoRoot);
-            assertIgnoredBaselineUnchanged(current.ignoredBaseline.filter((entry) => !isEphemeralToolCachePath(entry.path)), afterCommitIgnored.filter((entry) => !isEphemeralToolCachePath(entry.path)));
+            // force-add may promote allowed evidence from ignored → tracked; drop those
+            // paths from the post-commit baseline equality check.
+            const forceAdded = new Set(forceAddIgnored);
+            assertIgnoredBaselineUnchanged(current.ignoredBaseline.filter((entry) => !isEphemeralToolCachePath(entry.path) && !forceAdded.has(entry.path)), afterCommitIgnored.filter((entry) => !isEphemeralToolCachePath(entry.path) && !forceAdded.has(entry.path)));
         }
         catch (error) {
             const branch = await git(transaction.repoRoot, ["branch", "--show-current"]).catch(() => "");
@@ -199,6 +220,10 @@ export async function finalizeGitTask(transaction, outcome) {
             changedFiles: checkpointFiles,
         };
     }
+    // Failed / keep-diff paths still fail closed on unexpected baseline ignored mutations.
+    if (changedBaselineIgnored.length > 0 || missingBaselineIgnored.length > 0) {
+        throw new Error(`pre-existing ignored file changed during Git transaction: ${[...changedBaselineIgnored, ...missingBaselineIgnored].join(", ")}`);
+    }
     const artifactDir = path.join(path.dirname(transaction.recordPath), "failures", outcome.workerRunId);
     await captureFailureArtifacts(transaction.repoRoot, artifactDir, changes, newIgnored, outcome);
     if (outcome.keepFailedDiff) {

package/dist/worker/delivery/package.js

@@ -284,11 +284,15 @@ export async function validateDeliveryPackage(input) {
             blockers.push(`Acceptance coverage status is not derivable: ${ac.id}`);
         if (JSON.stringify([...item.blockedBy].sort()) !== JSON.stringify([...blockedBy].sort()))
             blockers.push(`Acceptance blockers changed: ${ac.id}`);
-        for (const ref of expectedRefs)
-            if (!item.evidence.some((candidate) => candidate.path === ref.path && candidate.sha256 === ref.sha256))
-                blockers.push(`Acceptance run evidence is missing: ${ac.id}`);
-        if (qa?.data.acIds.includes(ac.id) && !item.evidence.some((candidate) => candidate.path === qa.ref.path && candidate.sha256 === qa.ref.sha256))
-            blockers.push(`Acceptance QA evidence is missing: ${ac.id}`);
+        // partial / missing / blocked should-ACs intentionally omit full evidence lists
+        // (only must ACs covered by QA require run+QA hash binding).
+        if (expectedStatus === "covered") {
+            for (const ref of expectedRefs)
+                if (!item.evidence.some((candidate) => candidate.path === ref.path && candidate.sha256 === ref.sha256))
+                    blockers.push(`Acceptance run evidence is missing: ${ac.id}`);
+            if (qa?.data.acIds.includes(ac.id) && !item.evidence.some((candidate) => candidate.path === qa.ref.path && candidate.sha256 === qa.ref.sha256))
+                blockers.push(`Acceptance QA evidence is missing: ${ac.id}`);
+        }
         for (const ref of item.evidence)
             if (!await hashedRefValid(repoRoot, ref))
                 blockers.push(`Acceptance evidence changed: ${item.acId}`);

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

@@ -404,7 +404,23 @@ export async function verifyBundleOutcomes(repoRoot, bundle) {
             return false;
         if (JSON.stringify(verified.artifacts) !== JSON.stringify(outcome.artifacts))
             return false;
-        if (!await verifyArtifactRefs(repoRoot, outcome.artifacts))
+        // Rehash only durable typed evidence. run_record/dag_json may be rewritten
+        // after outcome projection (worker-run-record appends report commands).
+        const evidenceArtifacts = outcome.artifacts.filter((artifact) => {
+            const kind = artifact.kind ?? "";
+            if (kind === "run_record" || kind === "dag_json")
+                return false;
+            if (kind === "backend-test-result" ||
+                kind === "frontend-test-result" ||
+                kind.includes("backend-test-result") ||
+                kind.includes("frontend-test-result")) {
+                return true;
+            }
+            // Unknown kinds: still rehash unless clearly infrastructure paths.
+            return (!artifact.path.includes("worker-run-record") &&
+                !artifact.path.includes("-dag.json"));
+        });
+        if (!await verifyArtifactRefs(repoRoot, evidenceArtifacts))
             return false;
     }
     return true;
@@ -417,9 +433,12 @@ export function verifyBundleTaskSpecBindings(bundle, specs) {
             return false;
         taskIds.add(outcome.taskId);
         const spec = specs.get(outcome.taskId);
+        // Typed verification tasks may be qa-execute (frontend-test) or qa-testcode
+        // (backend-test Markdown-first). Delivery binds on feature_id + workflow.
+        const typedVerificationTypes = new Set(["qa-execute", "qa-testcode"]);
         if (!spec ||
             spec.feature_id !== bundle.featureId ||
-            spec.type !== "qa-execute" ||
+            !typedVerificationTypes.has(spec.type) ||
             spec.execution?.workflow !== outcome.workflow)
             return false;
     }
@@ -460,9 +479,11 @@ async function verifyArtifactRefs(repoRoot, artifacts) {
         return false;
     }
     for (const artifact of artifacts) {
-        if (path.isAbsolute(artifact.path))
-            return false;
-        const lexical = path.resolve(canonicalRepoRoot, artifact.path);
+        // Accept absolute paths only when they resolve inside the repo (legacy
+        // envelopes may store abs paths). Prefer relative for new projections.
+        const lexical = path.isAbsolute(artifact.path)
+            ? path.resolve(artifact.path)
+            : path.resolve(canonicalRepoRoot, artifact.path);
         let resolved;
         let content;
         try {