@tea-agent/loop-agent 0.26.1 → 0.26.3

package/CHANGELOG.md

@@ -2,6 +2,53 @@
 
 ## [Unreleased]
 
+## [0.26.3] - 2026-08-02
+
+### 重点更新
+
+- DAG 无害工具副产物自动恢复
+- 提升前端验证命令的精确度与失败分类
+- 隔离测试固件与运行环境标记
+
+### 新增
+
+- DAG 无害工具副产物自动恢复：自动清理 Git Bash 误用 `> nul` / `2> nul` 在仓库根目录生成的普通非 symlink untracked `nul` 文件，避免其干扰 Git 状态复查与变更清单生成
+
+### 改进
+
+- 精确限定前端验证命令的作用域，提升验证执行的准确性
+- 更精准地分类前端验证失败原因，避免模糊报错
+- 将运行器标记与测试固件进行安全隔离，防止测试环境干扰
+
+### 修复
+
+- 修复配置验证目标错误处理符号引用的问题
+- 修复 DAG 执行中无害的根目录 nul 副产物导致流程异常的问题
+
+## [0.26.2] - 2026-08-02
+
+### 重点更新
+
+- 后端测试在执行前新增有界的 pytest 收集修复机制，安全且精准地自动修复生成测试中的不一致问题
+- 全面加固 DAG 审查协议与前端契约边界，提升执行稳定性
+- 修复 Observe 看板轮询刷新时的交互状态保留问题，优化使用体验
+
+### 新增
+
+- 后端测试在业务 pytest 执行前新增有界的收集（collection）修复机制：仅对生成的测试目录中可唯一归因的语法、导入、模块或参数化不一致进行最多一次自动修复，且严格禁止修改生产代码或放宽断言
+
+### 改进
+
+- 加固 DAG 审查协议与追踪门禁，提升执行稳定性
+- 加固前端 DAG 契约边界
+- 稳定 Linux 环境下的测试收集固件（fixture）
+- 对齐受监督的 DAG 收尾拓扑结构
+
+### 修复
+
+- 修复 Observe 看板在轮询刷新时破坏 DAG 图视口 DOM 的问题，确保拖动与滚动状态不被销毁
+- 修复节点检查器在内容未变时重建内容的问题，现支持异步标签页安全恢复滚动位置
+
 ## [0.26.1] - 2026-08-02
 
 ### 新增

package/dist/application/dag/generate-task-dag.js

@@ -12,6 +12,9 @@ import { validateDagUseCase } from "./validate-dag.js";
 import { runDagUseCase } from "./run-dag.js";
 import { getTaskPaths, loadTaskConfig } from "../../task/runtime.js";
 import { writeTaskConfig } from "../../infrastructure/harness/task-store.js";
+import { runFrontendPreflight } from "../../task/frontend-preflight.js";
+import { observeTaskContract } from "../../task/contract/observe.js";
+import { adoptTaskContract } from "../../task/contract/adopt.js";
 const PLACEHOLDER_WRITESET_MARKER = "REPLACE/WITH";
 function buildValidateInput(repoRoot, dagPath, parsed) {
     return {
@@ -243,6 +246,36 @@ export async function generateTaskDagUseCase(input) {
     // before any expensive DAG generation or execution. Empty/consistent
     // repos stay compatible so the default DAG flow is unblocked.
     await assertExecPlanIndexConsistent(repoRoot);
+    const preflightTaskConfig = await loadTaskConfig(repoRoot, parsed.taskId);
+    const frontendScope = await runFrontendPreflight({
+        repoRoot,
+        taskId: parsed.taskId,
+        taskConfig: preflightTaskConfig,
+    });
+    if (frontendScope) {
+        await writeTaskConfig(repoRoot, parsed.taskId, {
+            ...preflightTaskConfig,
+            allowedPaths: [
+                ...new Set([
+                    frontendScope.entrypoint,
+                    ...frontendScope.implementationPaths,
+                    ...frontendScope.testPaths,
+                ]),
+            ],
+        });
+        const state = await observeTaskContract({ repoRoot, taskId: parsed.taskId });
+        if (!state.ref || !state.observedCanonicalHash) {
+            throw new Error("frontend preflight could not reconcile the managed Task Contract");
+        }
+        await adoptTaskContract({
+            repoRoot,
+            taskId: parsed.taskId,
+            expectedRevision: state.ref.revision,
+            expectedObservedHash: state.observedCanonicalHash,
+            requestId: `frontend-preflight-${parsed.taskId}-${randomUUID()}`,
+            requestPayloadSha256: randomUUID().replaceAll("-", "").padEnd(64, "0"),
+        });
+    }
     const candidateResult = await initHybridDagFromTask(repoRoot, parsed.taskId, {
         outputPath: parsed.outputPath,
         template: "standard-dag",

package/dist/commands/task-source-prepare.js

@@ -18,6 +18,7 @@ const USAGE = `usage:
     [--task-kind <TaskKind>]
     [--feature-id <string>]
     [--allowed-path <glob>]...
+    [--allowed-root <glob>]...
     [--forbidden-path <glob>]...
     [--no-default-forbidden-paths]
     [--invariant <text>]...
@@ -113,6 +114,10 @@ export function parseTaskSourcePrepareArgs(args) {
             options.allowedPaths = pushList(options.allowedPaths, next());
             continue;
         }
+        if (token === "--allowed-root") {
+            options.allowedRoots = pushList(options.allowedRoots, next());
+            continue;
+        }
         if (token === "--forbidden-path") {
             options.forbiddenPaths = pushList(options.forbiddenPaths, next());
             continue;
@@ -264,6 +269,7 @@ function buildFlags(options) {
         taskKind: options.taskKind,
         featureId: options.featureId,
         allowedPaths: options.allowedPaths,
+        allowedRoots: options.allowedRoots,
         forbiddenPaths: options.forbiddenPaths,
         noDefaultForbiddenPaths: options.noDefaultForbiddenPaths,
         invariants: options.invariants,

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

@@ -3,7 +3,7 @@ import { createHash } from "node:crypto";
 import { writeDagNodeJsonArtifact, writeTextArtifactFile, } from "../infrastructure/harness/artifact-store.js";
 import { executePiStep, } from "./pi-executor.js";
 import { redactPromptForLog, truncateOutput, } from "../shared/output-truncation.js";
-import { GitStatusUnavailableError, pathsChangedDuringRun, readGitStatusPorcelain, snapshotGitStatusPathFingerprints, snapshotGitStatusPorcelain, validateShellWriteGuard, } from "./shell-write-guard.js";
+import { GitStatusUnavailableError, pathsChangedDuringRun, readGitStatusPorcelain, recoverRootNulArtifact, snapshotGitStatusPathFingerprints, snapshotGitStatusPorcelain, validateShellWriteGuard, } from "./shell-write-guard.js";
 import { redactSecrets, truncateUtf8Preview } from "../shared/preview.js";
 export const DAG_PI_READONLY_TOOLS = ["read", "grep", "find", "ls"];
 export const DAG_PI_WRITE_TOOLS = [
@@ -259,6 +259,7 @@ export async function writePiExecutorArtifacts(artifactsDir, input) {
 }
 const DEFAULT_DAG_PI_WRITE_GUARD_DEPENDENCIES = {
     readGitStatusPorcelain,
+    recoverRootNulArtifact,
 };
 export async function executeDagPiNode(input, meta, piStepFn = executePiStep, writeGuardDependencies = DEFAULT_DAG_PI_WRITE_GUARD_DEPENDENCIES) {
     const started = Date.now();
@@ -360,10 +361,105 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
     let changeManifestAfterStatus;
     let changeManifestChangedFiles;
     if (beforeStatus !== undefined) {
+        let recoveryEvidence;
+        let removalPendingRecheck;
         try {
-            const afterStatus = await writeGuardDependencies.readGitStatusPorcelain(input.cwd, { phase: "pi-writer-after" });
-            const afterSnapshot = snapshotGitStatusPorcelain(afterStatus);
-            const afterPathFingerprints = await snapshotGitStatusPathFingerprints(input.cwd, afterSnapshot);
+            let afterStatus = await writeGuardDependencies.readGitStatusPorcelain(input.cwd, { phase: "pi-writer-after" });
+            let afterSnapshot = snapshotGitStatusPorcelain(afterStatus);
+            let afterPathFingerprints = await snapshotGitStatusPathFingerprints(input.cwd, afterSnapshot);
+            // Benign tool artifact recovery: a new untracked bounded regular file
+            // literally named `nul` at the repository root is removed with
+            // the Node file API, then git status is recaptured so the guard,
+            // outcome validation and change manifest only ever see the
+            // sanitized diff. Every non-matching candidate stays fail-closed.
+            if (afterSnapshot.has("nul")) {
+                const recoverRootNulArtifactFn = writeGuardDependencies.recoverRootNulArtifact ??
+                    recoverRootNulArtifact;
+                const recovery = await recoverRootNulArtifactFn({
+                    rootCwd: input.cwd,
+                    beforeSnapshot: snapshotGitStatusPorcelain(beforeStatus),
+                    afterSnapshot,
+                    afterPathFingerprints,
+                    candidateAuthorized: validateShellWriteGuardFromDiff({
+                        changedFiles: ["nul"],
+                        task: input.task,
+                        concurrentSiblingWriteSets: meta.concurrentSiblingWriteSets,
+                    }).ok,
+                });
+                const beforeStatusSha256 = createHash("sha256")
+                    .update(beforeStatus)
+                    .digest("hex");
+                const afterStatusSha256 = createHash("sha256")
+                    .update(afterStatus)
+                    .digest("hex");
+                if (recovery.action === "removed") {
+                    const evidenceBase = {
+                        candidatePath: "nul",
+                        reason: recovery.reason,
+                        action: "recovered",
+                        result: "removed",
+                        observedSizeBytes: recovery.observedSizeBytes,
+                        removedAt: recovery.removedAt,
+                        beforeStatusSha256,
+                        afterStatusSha256,
+                    };
+                    removalPendingRecheck = evidenceBase;
+                    const recheckedStatus = await writeGuardDependencies.readGitStatusPorcelain(input.cwd, {
+                        phase: "pi-writer-after-recheck",
+                    });
+                    const recheckedSnapshot = snapshotGitStatusPorcelain(recheckedStatus);
+                    afterStatus = recheckedStatus;
+                    afterSnapshot = recheckedSnapshot;
+                    afterPathFingerprints = await snapshotGitStatusPathFingerprints(input.cwd, recheckedSnapshot);
+                    recoveryEvidence = {
+                        ...evidenceBase,
+                        recheck: {
+                            statusSha256: createHash("sha256")
+                                .update(recheckedStatus)
+                                .digest("hex"),
+                            nulStillPresent: recheckedSnapshot.has("nul"),
+                        },
+                    };
+                    removalPendingRecheck = undefined;
+                }
+                else if (recovery.action === "skipped") {
+                    recoveryEvidence = {
+                        candidatePath: "nul",
+                        reason: recovery.reason,
+                        action: "skipped",
+                        result: "kept",
+                        ...(recovery.observedSizeBytes === undefined
+                            ? {}
+                            : { observedSizeBytes: recovery.observedSizeBytes }),
+                        beforeStatusSha256,
+                        afterStatusSha256,
+                        recheck: {
+                            statusSha256: afterStatusSha256,
+                            nulStillPresent: true,
+                        },
+                    };
+                }
+                else {
+                    recoveryEvidence = {
+                        candidatePath: "nul",
+                        reason: recovery.reason,
+                        action: "failed",
+                        result: "removal-failed",
+                        observedSizeBytes: recovery.observedSizeBytes,
+                        errorDetail: recovery.errorDetail,
+                        beforeStatusSha256,
+                        afterStatusSha256,
+                        recheck: {
+                            statusSha256: afterStatusSha256,
+                            nulStillPresent: true,
+                        },
+                    };
+                    writeGuardOk = false;
+                    writeGuardViolations = [
+                        `nul artifact removal failed: ${recovery.errorDetail}`,
+                    ];
+                }
+            }
             const changedFiles = pathsChangedDuringRun(snapshotGitStatusPorcelain(beforeStatus), afterSnapshot, beforePathFingerprints, afterPathFingerprints);
             changeManifestAfterStatus = afterStatus;
             changeManifestChangedFiles = changedFiles;
@@ -372,16 +468,35 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
                 task: input.task,
                 concurrentSiblingWriteSets: meta.concurrentSiblingWriteSets,
             });
-            writeGuardOk = guard.ok;
-            writeGuardViolations = guard.violations;
+            writeGuardOk = writeGuardOk && guard.ok;
+            writeGuardViolations = [...writeGuardViolations, ...guard.violations];
         }
         catch (error) {
             await persistGitWriteGuardDiagnostics(meta.runDir, input.task.id, error);
+            if (removalPendingRecheck) {
+                // The artifact was already deleted but the recheck read failed:
+                // record the recovery facts with the recheck failure so the
+                // evidence trail stays complete while the node remains failed.
+                recoveryEvidence = {
+                    ...removalPendingRecheck,
+                    recheck: {
+                        failed: true,
+                        errorDetail: boundedRecoveryErrorDetail(error),
+                    },
+                };
+            }
             writeGuardOk = false;
             writeGuardViolations = [
                 `git status unavailable: ${error instanceof Error ? error.message : String(error)}`,
             ];
         }
+        if (recoveryEvidence) {
+            await persistBenignToolArtifactRecovery({
+                runDir: meta.runDir,
+                nodeId: input.task.id,
+                evidence: recoveryEvidence,
+            });
+        }
     }
     let writerOutcomeViolation;
     if (mapped.ok && input.task.writerOutcomePolicy) {
@@ -624,9 +739,7 @@ async function persistWriterGitBaseline(input) {
         nodeId: input.nodeId,
         phase: "pi-writer-before",
         capturedAt: new Date().toISOString(),
-        statusSha256: createHash("sha256")
-            .update(input.beforeStatus)
-            .digest("hex"),
+        statusSha256: createHash("sha256").update(input.beforeStatus).digest("hex"),
         dirtyPaths: [...input.beforeSnapshot.keys()].sort(),
         pathFingerprintsSha256: createHash("sha256")
             .update(JSON.stringify(fingerprintEntries))
@@ -639,6 +752,40 @@ async function persistGitWriteGuardDiagnostics(runDir, nodeId, error) {
         return;
     await writeDagNodeJsonArtifact(runDir, nodeId, "git-write-guard-diagnostics.json", error.diagnostics);
 }
+function boundedRecoveryErrorDetail(error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return detail.length <= 1000
+        ? detail
+        : `${detail.slice(0, 1000)}...[truncated]`;
+}
+/**
+ * Persist bounded run-owned evidence for a recognized repository-root `nul`
+ * candidate: candidate path, reason, action, result and recheck facts plus
+ * status hashes. Never records environment variables or secrets.
+ */
+async function persistBenignToolArtifactRecovery(input) {
+    const artifact = {
+        schemaVersion: 1,
+        nodeId: input.nodeId,
+        candidatePath: input.evidence.candidatePath,
+        reason: input.evidence.reason,
+        action: input.evidence.action,
+        result: input.evidence.result,
+        ...(input.evidence.observedSizeBytes === undefined
+            ? {}
+            : { observedSizeBytes: input.evidence.observedSizeBytes }),
+        ...(input.evidence.errorDetail
+            ? { errorDetail: input.evidence.errorDetail }
+            : {}),
+        ...(input.evidence.removedAt
+            ? { removedAt: input.evidence.removedAt }
+            : {}),
+        beforeStatusSha256: input.evidence.beforeStatusSha256,
+        afterStatusSha256: input.evidence.afterStatusSha256,
+        recheck: input.evidence.recheck,
+    };
+    await writeDagNodeJsonArtifact(input.runDir, input.nodeId, "benign-tool-artifact-recovery.json", artifact);
+}
 /**
  * Validate the writer's observed diff against its declared write boundary.
  * Inlined mirror of runPostRunWriteGuard that reuses the already-computed diff

package/dist/executors/shell-executor.js

@@ -24,6 +24,7 @@ import { materializeBackendTestExecutionContract } from "../workflows/dag/backen
 import { analyzeBackendTestCaseCoverage, analyzeBackendTestMarkdownPytestCorrespondence, materializeBackendTestCaseManifestFromFacts, } from "../workflows/dag/backend-test-case-coverage-analysis.js";
 import { materializeBackendTestResultFromPytestHtml, materializeBackendTestResultFromRunDir, parsePytestHtmlReport } from "../workflows/dag/backend-test-result-contract.js";
 import { collectBackendTestHumanCaseCatalog, collectBackendTestMappedPytestScripts, collectJacocoCoverage, hasBlockingBackendMarkdownSafetyFindings, inspectBackendTestEnvironment, requiredBackendMarkdownCaseAcIds, renderBackendTestFacts, renderBackendTestHtml, renderBackendTestL5Dashboard, redactBackendTestOutput, validateBackendMarkdownCases, validateBackendMarkdownTraceability, writeRunReport, } from "../workflows/dag/backend-test-markdown-workflow.js";
+import { assessBackendPytestCollection, assertBackendPytestCollectionFresh, buildBackendPytestAssetInventory, materializeEffectiveBackendPytestCollection, readBackendPytestCollectionFacts, writeBackendPytestCollectionArtifacts, } from "../workflows/dag/backend-test-pytest-collection.js";
 import { computeL5ReportMetrics } from "../workflows/dag/l5-report-metrics.js";
 import { buildBackendTestCanonicalResultFromInitialShellSnippet, materializeBackendTestClassification, } from "../workflows/dag/backend-test-classification-contract.js";
 import { backendTestSemanticReviewSchema, materializeBackendTestSemanticReview, } from "../workflows/dag/backend-test-semantic-review-contract.js";
@@ -476,6 +477,114 @@ async function executeBackendTestPipeline(input, meta) {
                 };
             }
         }
+        else if (pipeline === "markdown-collection-assess") {
+            const mappedScripts = await collectBackendTestMappedPytestScripts(input.cwd);
+            const inventory = await buildBackendPytestAssetInventory(input.cwd, mappedScripts);
+            const shellQuote = (value) => `'${value.replaceAll("'", `'"'"'`)}'`;
+            const targets = mappedScripts.map(shellQuote).join(" ");
+            const command = `PYTHONDONTWRITEBYTECODE=1 python -m pytest --collect-only -q -p no:cacheprovider ${targets}`;
+            const [result] = await executePipelineCommands(input, meta, [command]);
+            if (!result)
+                throw new Error("backend pytest collection command did not produce a result");
+            if (["spawn-error", "timeout", "termination-unconfirmed"].includes(result.failureCategory ?? "")) {
+                return {
+                    ok: false,
+                    stdout: result.stdout,
+                    stderr: result.stderr || "backend pytest collection could not start",
+                    failureCategory: result.failureCategory,
+                    durationMs: Date.now() - started,
+                };
+            }
+            const facts = assessBackendPytestCollection({
+                phase: "initial",
+                mappedScripts,
+                inventory,
+                exitCode: result.exitCode ?? 2,
+                stdout: result.stdout,
+                stderr: result.stderr,
+            });
+            const artifacts = await writeBackendPytestCollectionArtifacts({
+                runDir: meta.runDir,
+                stem: "initial",
+                facts,
+            });
+            outputs.push(`collectionFacts=${artifacts.factsPath}`, `collectionReport=${artifacts.reportPath}`);
+            return {
+                ok: true,
+                stdout: JSON.stringify({
+                    status: facts.status,
+                    repairEligible: facts.repairEligible,
+                    pytestExitCode: facts.pytestExitCode,
+                    collectedItemCount: facts.collectedItemCount,
+                    factsPath: "contracts/backend-test-pytest-collection-initial.json",
+                }),
+                stderr: "",
+                durationMs: Date.now() - started,
+            };
+        }
+        else if (pipeline === "markdown-collection-effective") {
+            const initial = await readBackendPytestCollectionFacts(path.join(meta.runDir, "contracts", "backend-test-pytest-collection-initial.json"));
+            let effective;
+            if (initial.status === "PASS") {
+                effective = await materializeEffectiveBackendPytestCollection({
+                    workspaceRoot: input.cwd,
+                    initial,
+                });
+            }
+            else if (initial.status === "REPAIRABLE") {
+                const mappedScripts = await collectBackendTestMappedPytestScripts(input.cwd);
+                const inventory = await buildBackendPytestAssetInventory(input.cwd, mappedScripts);
+                const shellQuote = (value) => `'${value.replaceAll("'", `'"'"'`)}'`;
+                const targets = mappedScripts.map(shellQuote).join(" ");
+                const command = `PYTHONDONTWRITEBYTECODE=1 python -m pytest --collect-only -q -p no:cacheprovider ${targets}`;
+                const [result] = await executePipelineCommands(input, meta, [command]);
+                if (!result)
+                    throw new Error("backend pytest final collection command did not produce a result");
+                if (["spawn-error", "timeout", "termination-unconfirmed"].includes(result.failureCategory ?? "")) {
+                    return {
+                        ok: false,
+                        stdout: result.stdout,
+                        stderr: result.stderr || "backend pytest final collection could not start",
+                        failureCategory: result.failureCategory,
+                        durationMs: Date.now() - started,
+                    };
+                }
+                const finalFacts = assessBackendPytestCollection({
+                    phase: "final",
+                    mappedScripts,
+                    inventory,
+                    exitCode: result.exitCode ?? 2,
+                    stdout: result.stdout,
+                    stderr: result.stderr,
+                });
+                effective = await materializeEffectiveBackendPytestCollection({
+                    workspaceRoot: input.cwd,
+                    initial,
+                    final: finalFacts,
+                });
+            }
+            else {
+                throw new Error("backend pytest collection is blocked and does not authorize repair");
+            }
+            const artifacts = await writeBackendPytestCollectionArtifacts({
+                runDir: meta.runDir,
+                stem: "effective",
+                facts: effective,
+            });
+            return {
+                ok: true,
+                stdout: JSON.stringify({
+                    status: effective.status,
+                    collectionSource: effective.collectionSource,
+                    repairAttempt: effective.repairAttempt,
+                    collectedItemCount: effective.collectedItemCount,
+                    factsPath: "contracts/backend-test-pytest-collection-effective.json",
+                    reportPath: artifacts.reportPath,
+                }),
+                stderr: "",
+                durationMs: Date.now() - started,
+            };
+        }
         else if (pipeline === "markdown-traceability") {
             let report;
             try {
@@ -542,6 +651,8 @@ async function executeBackendTestPipeline(input, meta) {
             outputs.push(`manifest=${manifestPath}`, `materializationStatus=${manifest.materializationStatus ?? "available"}`, `coverageSummary.explicitAcCount=${summary?.explicitAcCount ?? "unavailable"}`, `coverageSummary.coveredAcCount=${summary?.coveredAcCount ?? "unavailable"}`, `coverageSummary.caseCount=${summary?.caseCount ?? "unavailable"}`, `coverageSummary.generatedCount=${summary?.generatedCount ?? "unavailable"}`, `ruleCoverageSummary.ruleCount=${manifest.ruleCoverageSummary?.ruleCount ?? "unavailable"}`, `correspondenceSummary.exactCorrespondenceCount=${manifest.correspondenceSummary?.exactCorrespondenceCount ?? "unavailable"}`, `correspondenceSummary.primarySymbolCount=${manifest.correspondenceSummary?.primarySymbolCount ?? "unavailable"}`, `correspondenceSummary.testPoints=${manifest.correspondenceSummary?.mappedTestPointCount ?? "unavailable"}/${manifest.correspondenceSummary?.testPointCount ?? "unavailable"}`, `correspondenceSummary.variantTestPointCount=${manifest.correspondenceSummary?.variantTestPointCount ?? "unavailable"}`, `correspondenceSummary.assertionTestPointCount=${manifest.correspondenceSummary?.assertionTestPointCount ?? "unavailable"}`, `correspondenceSummary.crossCuttingTestPointCount=${manifest.correspondenceSummary?.crossCuttingTestPointCount ?? "unavailable"}`, `correspondenceSummary.unclassifiedTestPointCount=${manifest.correspondenceSummary?.unclassifiedTestPointCount ?? "unavailable"}`, `correspondenceSummary.duplicateBindingTestPointCount=${manifest.correspondenceSummary?.duplicateBindingTestPointCount ?? "unavailable"}`);
         }
         else if (pipeline === "markdown-execute-html") {
+            const effectiveCollection = await readBackendPytestCollectionFacts(path.join(meta.runDir, "contracts", "backend-test-pytest-collection-effective.json"));
+            await assertBackendPytestCollectionFresh(input.cwd, effectiveCollection);
             const mappedScripts = await collectBackendTestMappedPytestScripts(input.cwd);
             const shellQuote = (value) => `'${value.replaceAll("'", `'"'"'`)}'`;
             const pytestTargets = mappedScripts.map(shellQuote).join(" ");

package/dist/executors/shell-presets.js

@@ -15,7 +15,10 @@ function escapeShellSingleQuoted(value) {
 /**
  * Build a single shell command that reads `$HARNESS_DAG_RUN_DIR/<fromNodeId>.json`
  * (injected by the shell executor from runtime meta), parses a single candidate
- * verdict line from `assistantText ?? stdout`, and accepts only exact verdict values.
+ * verdict from `assistantText ?? stdout`, and accepts only exact verdict values.
+ * Sources:
+ * - verdict-line: line-based legacy VERDICT protocol
+ * - json-review-verdict: structured review JSON with verdict: pass/request-revision
  * Modes:
  * - first-non-empty: first non-empty line
  * - first-verdict-line: first line matching /^VERDICT:/ after trim and optional whole-line Markdown emphasis normalization
@@ -25,6 +28,7 @@ function escapeShellSingleQuoted(value) {
  */
 export function buildVerdictGateShellCommand(gate) {
     const gateLabel = gate.label ?? `${gate.fromNodeId} verdict`;
+    const source = gate.source ?? "verdict-line";
     const lineMode = gate.lineMode ?? "first-non-empty";
     const candidateNodeIds = [
         gate.fromNodeId,
@@ -32,8 +36,10 @@ export function buildVerdictGateShellCommand(gate) {
     ];
     const config = {
         label: gateLabel,
+        source,
         lineMode,
         accept: gate.accept,
+        routingAccept: gate.routingAccept ?? [],
         candidateNodeIds,
     };
     const configLiteral = escapeShellSingleQuoted(JSON.stringify(config));
@@ -48,10 +54,12 @@ export function buildVerdictGateShellCommand(gate) {
         'if(!file){console.error("missing "+cfg.label+" JSON output (tried: "+cfg.candidateNodeIds.join(", ")+")");process.exit(1);}',
         'const raw=JSON.parse(fs.readFileSync(file,"utf8"));',
         'const text=String(raw.assistantText ?? raw.stdout ?? "");',
+        'const extractJson=(value)=>{const text=String(value).trim();const fenced=[...text.matchAll(/```(?:json)?\\s*([\\s\\S]*?)\\s*```/gi)];const source=fenced.length===1?String(fenced[0][1]).trim():text;for(let start=0;start<source.length;start+=1){if(source[start]!=="{")continue;let depth=0,inString=false,escaped=false;for(let i=start;i<source.length;i+=1){const ch=source[i];if(inString){if(escaped){escaped=false;}else if(ch==="\\\\"){escaped=true;}else if(ch===String.fromCharCode(34)){inString=false;}continue;}if(ch===String.fromCharCode(34)){inString=true;continue;}if(ch==="{"){depth+=1;}else if(ch===String.fromCharCode(125)){depth-=1;if(depth===0){const candidate=source.slice(start,i+1);try{const parsed=JSON.parse(candidate);if(parsed&&typeof parsed==="object"&&!Array.isArray(parsed))return candidate;}catch{}break;}}}}return "";};',
+        'let first="";',
+        'if(cfg.source==="json-review-verdict"){const jsonText=extractJson(text);if(!jsonText){console.error(cfg.label+" gate blocked: missing JSON review verdict");process.exit(1);}let parsed;try{parsed=JSON.parse(jsonText);}catch(error){console.error(cfg.label+" gate blocked: invalid JSON review verdict: "+error.message);process.exit(1);}first=String(parsed&&parsed.verdict||"");}',
         'const normalize=(value)=>{const trimmed=String(value).trim();const emphasized=trimmed.match(/^\\*{1,3}\\s*(VERDICT:[^*]+?)\\s*\\*{1,3}$/);return (emphasized?emphasized[1]:trimmed).trim();};',
-        'const lines=text.split(/\\r?\\n/).map(normalize);',
-        'const first=cfg.lineMode==="first-verdict-line"? (lines.find((value)=>/^VERDICT:/.test(value))??"") : (lines.find((value)=>value.length>0)??"");',
-        'if(!cfg.accept.includes(first)){console.error(cfg.label+" gate blocked: "+(first||"missing VERDICT line"));process.exit(1);}',
+        'if(cfg.source!=="json-review-verdict"){const lines=text.split(/\\r?\\n/).map(normalize);first=cfg.lineMode==="first-verdict-line"? (lines.find((value)=>/^VERDICT:/.test(value))??"") : (lines.find((value)=>value.length>0)??"");}',
+        'const routing=Array.isArray(cfg.routingAccept)?cfg.routingAccept:[];if(!cfg.accept.includes(first)&&!routing.includes(first)){console.error(cfg.label+" gate blocked: "+(first|| (cfg.source==="json-review-verdict"?"missing JSON verdict":"missing VERDICT line")));process.exit(1);}',
         'process.stdout.write(first+"\\n");',
     ].join("");
     return `node -e '${escapeShellSingleQuoted(program)}' '${configLiteral}'`;