@tea-agent/loop-agent 0.26.2 → 0.26.4

package/dist/workflows/dag/frontend-verification-trace.js

@@ -37,6 +37,9 @@ function symbolEvidenceCandidates(symbol) {
         return [symbol, describeTitle, "describe("];
     return [symbol];
 }
+function isConfigurationVerificationFile(file) {
+    return /(?:^|\/)(?:package\.json|tsconfig(?:\.[^/]+)?\.json|(?:vite|webpack|rollup|docusaurus)\.config\.[cm]?[jt]s)$/.test(file.replace(/\\/g, "/"));
+}
 async function assertFileAndSymbol(input) {
     const issues = [];
     const absolute = path.resolve(input.workspaceRoot, input.file);
@@ -94,6 +97,7 @@ export async function runFrontendVerificationTraceGate(input) {
             .join("; ")}`);
     }
     const contract = parsed.data;
+    const requiresBehaviorVerification = contract.verificationTargets.some((target) => target.type !== "static");
     // Prefer post-repair reverify nodes when present (M3); else initial verify nodes (M2).
     const staticCandidates = [
         "frontend-static-reverify-shell",
@@ -146,7 +150,8 @@ export async function runFrontendVerificationTraceGate(input) {
         if (input.evidence.static.commandLabels.length === 0) {
             throw new Error("trace: no successful static verification commands in current run");
         }
-        if (input.evidence.behavior.commandLabels.length === 0) {
+        if (requiresBehaviorVerification &&
+            input.evidence.behavior.commandLabels.length === 0) {
             throw new Error("trace: no successful behavior verification commands in current run");
         }
     }
@@ -181,7 +186,12 @@ export async function runFrontendVerificationTraceGate(input) {
         const fileIssues = await assertFileAndSymbol({
             workspaceRoot: input.workspaceRoot,
             file: target.file,
-            symbol: target.symbol,
+            // Configuration files prove that the command's entrypoint exists;
+            // they do not expose source symbols. LLMs sometimes derive a
+            // filename fragment such as "build" from tsconfig.build.json.
+            symbol: isConfigurationVerificationFile(target.file)
+                ? undefined
+                : target.symbol,
         });
         issues.push(...fileIssues);
         const status = issues.length ? "failed" : "ok";

package/dist/workflows/dag/governance-profile.js

@@ -106,7 +106,7 @@ function writeSetMatchesAnyPattern(writeSet, patterns) {
 function shellCommandLooksDeterministic(command) {
     const normalized = command.replace(/["']/g, "");
     return (/\bnpx vitest run\b/.test(normalized) ||
-        /\bnpm (?:run )?(?:lint|typecheck|test)\b/.test(normalized) ||
+        /\bnpm(?:\s+--prefix\s+\S+)*\s+(?:run\s+)?(?:lint|typecheck|test|build)\b/.test(normalized) ||
         /check-repo\.sh/.test(normalized) ||
         /\bshell\.preset\b/.test(normalized) ||
         /loop-agent-standard-verify/.test(normalized));

package/dist/workflows/dag/init-hybrid.js

@@ -13,6 +13,7 @@ import { DEFAULT_READ_ONLY_PI_RETRY_POLICY, PROTOCOL_AWARE_PI_RETRY_POLICY, STRU
 import { REVIEW_JSON_VERDICT_OUTPUT_PROTOCOL, REVIEW_VERDICT_OUTPUT_PROTOCOL, } from "./output-protocol.js";
 import { resolveAdapter } from "../../adapters/index.js";
 import { loadHarnessManifest } from "../../governance/harness.js";
+import { mergeDocumentIndexCompanions } from "../../governance/document-index-closure.js";
 import { buildAuthoritySurfaceAuditNode, buildAuthoritySurfaceGateNode, resolveAuthoritySurfaceAudit, } from "./authority-surface.js";
 import { applySddEmbeddedEnhancements, probeRepoLocalSddSkills, } from "./sdd-embedded.js";
 import { discoverProjectGovernancePresence } from "./project-governance-context.js";
@@ -721,9 +722,28 @@ function mergeForbiddenPaths(taskConfig) {
     ]);
     return [...merged];
 }
-function resolveImplementPaths(taskConfig) {
+function resolveImplementPaths(taskConfig, options = {}) {
     if (taskConfig.allowedPaths.length > 0) {
         const allowed = [...taskConfig.allowedPaths];
+        const forbidden = mergeForbiddenPaths(taskConfig);
+        const repoRoot = options.repoRoot;
+        // Only consult the catalog when writer paths can touch docs/* so non-docs
+        // temp fixtures without a catalog keep working; docs writers still fail closed.
+        const mayNeedDocIndex = allowed.some((entry) => {
+            const normalized = entry.replace(/\\/g, "/").replace(/^\.\//, "");
+            return normalized === "docs" || normalized.startsWith("docs/");
+        });
+        if (repoRoot && mayNeedDocIndex) {
+            const merged = mergeDocumentIndexCompanions({
+                repoRoot,
+                paths: allowed,
+                forbiddenPaths: forbidden,
+            });
+            return {
+                allowedPaths: merged.paths,
+                writeSet: [...merged.paths],
+            };
+        }
         return {
             allowedPaths: allowed,
             writeSet: [...allowed],
@@ -786,7 +806,9 @@ function applyMavenVerificationPlanning(input) {
     if (!input.repoRoot || !input.commands || input.commands.length === 0) {
         return { commands: input.commands };
     }
-    const implement = resolveImplementPaths(input.taskConfig);
+    const implement = resolveImplementPaths(input.taskConfig, {
+        repoRoot: input.repoRoot,
+    });
     const planned = planMavenVerification({
         repoRoot: input.repoRoot,
         commands: input.commands,
@@ -890,7 +912,9 @@ function chooseFrontendVerifyCommands(input) {
     if (input.parsedCommands.length > 0) {
         return { commands: input.parsedCommands, commandSource: "inline" };
     }
-    if (input.adapterCommands && input.adapterCommands.length > 0) {
+    if (input.allowAdapter !== false &&
+        input.adapterCommands &&
+        input.adapterCommands.length > 0) {
         return { commands: input.adapterCommands, commandSource: "adapter" };
     }
     return { commandSource: "inline" };
@@ -1513,7 +1537,9 @@ function mergeFinalVerifyCommands(repoRoot, taskConfig, adapterCommands) {
 export function buildStandardHybridDagFromTask(sources) {
     const { taskConfig } = sources;
     const forbiddenPaths = mergeForbiddenPaths(taskConfig);
-    const implementPaths = resolveImplementPaths(taskConfig);
+    const implementPaths = resolveImplementPaths(taskConfig, {
+        repoRoot: sources.repoRoot,
+    });
     const scoutPaths = deriveParallelScoutPaths(taskConfig);
     const scoutComplexity = mapTaskComplexity(taskConfig.complexity);
     const implementComplexity = resolveWriterComplexity(taskConfig);
@@ -2074,7 +2100,9 @@ async function buildFrontendHybridDagFromTask(sources) {
         frontendMockMode: mockMode,
     };
     const forbiddenPaths = mergeForbiddenPaths(taskConfig);
-    const implementPaths = resolveImplementPaths(taskConfig);
+    const implementPaths = resolveImplementPaths(taskConfig, {
+        repoRoot: sources.repoRoot,
+    });
     const implementId = frontendImplementationNodeId();
     const mockContextBlock = resolveFrontendMockContextBlock(frontendSources);
     const capabilityContextBlock = resolveFrontendCapabilityContextBlock(frontendSources);
@@ -2158,7 +2186,7 @@ async function buildFrontendHybridDagFromTask(sources) {
         "Frontend planning must consume the read-only Mock assessment strategy produced after scouting; MOCK_STRATEGY: blocked must not pass the deterministic Mock contract gate.",
         "Mock implementations must preserve the real request path as the default, require explicit test/dev activation, and never rely on commenting out the real request.",
         "Mock-backed behavior evidence proves only the documented frontend contract, never real API integration.",
-        "frontend-implementation DAGs must complete deterministic static verification and behavior verification before final review.",
+        "frontend-implementation DAGs must complete deterministic static verification before final review. Behavior verification is also required when the task declares a behavior entrypoint or the implementation contract contains a non-static verification target; static-only contracts must map every target to the declared static entrypoint.",
         "frontend review must block closeout unless review verdict is exactly VERDICT: pass.",
         `Frontend risk classification: ${frontendRisk.selectedRisk} — ${frontendRisk.reason}`,
         frontendRisk.forceFullGates
@@ -2183,6 +2211,10 @@ async function buildFrontendHybridDagFromTask(sources) {
         ...explicitFrontendVerifyCommands.behaviorCommands,
     ].map(verifyCommandKey));
     const adapterVerifyCommands = (sources.verifyCommands?.final ?? []).filter((command) => !explicitCommandKeys.has(verifyCommandKey(command)));
+    const hasDeclaredFrontendVerification = explicitFrontendVerifyCommands.staticCommands.length > 0 ||
+        explicitFrontendVerifyCommands.behaviorCommands.length > 0 ||
+        parsedFrontendVerifyCommands.staticCommands.length > 0 ||
+        parsedFrontendVerifyCommands.behaviorCommands.length > 0;
     const staticVerifyCommands = chooseFrontendVerifyCommands({
         explicitCommands: explicitFrontendVerifyCommands.staticCommands,
         parsedCommands: parsedFrontendVerifyCommands.staticCommands,
@@ -2197,6 +2229,9 @@ async function buildFrontendHybridDagFromTask(sources) {
         explicitCommands: explicitFrontendVerifyCommands.behaviorCommands,
         parsedCommands: parsedFrontendVerifyCommands.behaviorCommands,
         adapterCommands: adapterVerifyCommands,
+        // A declared task verifier owns this task's verification boundary. A
+        // static-only task must not inherit unrelated root-level test commands.
+        allowAdapter: !hasDeclaredFrontendVerification,
     });
     const staticShellCommands = buildVerifyShellCommands({
         repoRoot: sources.repoRoot,
@@ -2211,8 +2246,13 @@ async function buildFrontendHybridDagFromTask(sources) {
     const behaviorShellCommands = buildVerifyShellCommands({
         repoRoot: sources.repoRoot,
         commands: behaviorVerifyCommands.commands,
-        fallbackCommands: behaviorFallbackCommands,
+        fallbackCommands: hasDeclaredFrontendVerification
+            ? []
+            : behaviorFallbackCommands,
     });
+    const effectiveBehaviorFallbackCommands = hasDeclaredFrontendVerification
+        ? []
+        : behaviorFallbackCommands;
     const staticVerifyEvidence = buildVerifyEvidence({
         phase: "intermediate",
         quota: strategy.intermediateQuota ?? "full",
@@ -2238,7 +2278,7 @@ async function buildFrontendHybridDagFromTask(sources) {
         quota: "full",
         commandSource: behaviorVerifyCommands.commandSource,
         commands: behaviorVerifyCommands.commands,
-        fallbackCommands: behaviorFallbackCommands,
+        fallbackCommands: effectiveBehaviorFallbackCommands,
         commandTexts: behaviorShellCommands,
         finalFullRequired: true,
         commandTimeoutMs: DEFAULT_VERIFY_TIMEOUT_MS,
@@ -2352,7 +2392,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                 subtask_prompt: [
                     "Audit the frontend plan before implementation.",
                     "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
-                    "Request revision when the Mock strategy is MOCK_STRATEGY: blocked, missing, unsupported by repository evidence, inconsistent with the API contract, outside authorized paths/dependencies, unable to prove production-default-off behavior with the fixed production/default-real-path static check, or missing deterministic behavior verification for the selected strategy. Mock strategies require Mock-backed evidence. not-needed requires applicable real/no-remote behavior evidence unless auto mode explicitly skipped Mock because no project Mock capability exists; in that case the plan must preserve the real request path and record the Real Integration Gap.",
+                    "Request revision when the Mock strategy is MOCK_STRATEGY: blocked, missing, unsupported by repository evidence, inconsistent with the API contract, outside authorized paths/dependencies, unable to prove production-default-off behavior with the fixed production/default-real-path static check, or missing deterministic behavior verification for a declared behavior target or selected Mock strategy. Mock strategies require Mock-backed evidence. A static-only contract is allowed only when every verification target is static and maps to a declared static entrypoint. not-needed otherwise requires applicable real/no-remote behavior evidence unless auto mode explicitly skipped Mock because no project Mock capability exists; in that case the plan must preserve the real request path and record the Real Integration Gap.",
                     "Also request revision for missing applicable UI states, unsupported dependency additions, design-system drift without reason, weak interaction coverage, broad scope, inline fake data, schema drift, or missing deterministic verification commands.",
                     "Read-only: do not modify repository files.",
                     fixedVerificationContext,
@@ -3586,7 +3626,7 @@ async function buildBackendTestHybridDag(sources) {
         outputContract: "Convert every final automatable Markdown case into pytest assets whose actual test function region contains the exact Case ID, preferably in the function name or docstring. Each testcase/md/<module>.md (excluding README.md) maps one-to-one to testcase/test_<module>.py; never merge or split modules. No JSON and no pytest execution.",
         subtask_prompt: [
             "Convert testcase/md/** to pytest using upstream environment and advisory validation evidence plus only bounded pytest config/conftest. A FAIL advisory report does not authorize inventing missing behavior; use the final Markdown facts that are present.",
-            "Ensure every final Markdown Case ID appears in exactly one primary pytest test function or pytest test class method region, using the exact `primary symbol` declared by Markdown. The symbol must start with `test_BE_<MODULE>_<NNN>_` so every parameterized collected item remains associated with its Case. Module-level functions and class-based pytest methods are both supported. Only `变体测试点` may use stable `pytest.param(..., id=\"TP-...\")` IDs, and every atomic variant ID must appear exactly once with a genuine input/state/outcome change. Use `pytest.param(..., id=...)` for every row; do not use decorator-level `ids=[...]`, generated suffixes, or IDs that extend/shorten the exact Markdown TP. Do not parameterize `场景断言测试点` or `横切证据测试点`; execute all assertion checkpoints within the same business journey/item and use shared helpers for cross-cutting evidence. The primary symbol docstring must contain exact metadata lines `Case-ID: BE-...`, `Assertion-Test-Points: TP-...;TP-...` and `Cross-Cutting-Test-Points: TP-...;TP-...` (use `none` when empty). No Test Point may be invented, renamed, omitted or bound in two modes. The generated pytest collection shape must equal the Markdown prediction `sum(max(1, variant count per Case))`; keep it at or below the task's explicit budget by removing duplicate execution, never by collapsing multiple parameter rows under a coarse family TP. Assertions come only from 预期结果 and setup comes only from 前置条件/测试数据/自动化映射.",
+            'Ensure every final Markdown Case ID appears in exactly one primary pytest test function or pytest test class method region, using the exact `primary symbol` declared by Markdown. The symbol must start with `test_BE_<MODULE>_<NNN>_` so every parameterized collected item remains associated with its Case. Module-level functions and class-based pytest methods are both supported. Only `变体测试点` may use stable `pytest.param(..., id="TP-...")` IDs, and every atomic variant ID must appear exactly once with a genuine input/state/outcome change. Use `pytest.param(..., id=...)` for every row; do not use decorator-level `ids=[...]`, generated suffixes, or IDs that extend/shorten the exact Markdown TP. Do not parameterize `场景断言测试点` or `横切证据测试点`; execute all assertion checkpoints within the same business journey/item and use shared helpers for cross-cutting evidence. The primary symbol docstring must contain exact metadata lines `Case-ID: BE-...`, `Assertion-Test-Points: TP-...;TP-...` and `Cross-Cutting-Test-Points: TP-...;TP-...` (use `none` when empty). No Test Point may be invented, renamed, omitted or bound in two modes. The generated pytest collection shape must equal the Markdown prediction `sum(max(1, variant count per Case))`; keep it at or below the task\'s explicit budget by removing duplicate execution, never by collapsing multiple parameter rows under a coarse family TP. Assertions come only from 预期结果 and setup comes only from 前置条件/测试数据/自动化映射.',
             "Name each generated pytest file so it corresponds one-to-one with its source Markdown module file: for each `testcase/md/<module>.md` (excluding README.md), emit exactly one `testcase/test_<module>.py`. The <module> stem is the Markdown filename without the `.md` extension, lowercased and with non-alphanumeric characters replaced by underscores. For example, `testcase/md/resource_notes.md` maps to `testcase/test_resource_notes.py`, `testcase/md/health.md` maps to `testcase/test_health.py`, `testcase/md/BE-HEALTH.md` maps to `testcase/test_be_health.py`, and `testcase/md/order-api.md` maps to `testcase/test_order_api.py`. If Markdown automation mapping names a different path than this module stem path, still write the module stem path and do not invent prefixes such as `test_be_*` unless the module filename itself normalizes to that stem. Never merge multiple Markdown modules into one pytest file, never split one module across several files, and never invent pytest filenames unrelated to the Markdown modules.",
             "Generate a reusable HTTP logging helper (or equivalent client wrapper) and call it for every interface request. The request log must include method, URL/path, and request parameters (query plus JSON/body/payload summary). The response log must include status code and response result (JSON/text/body summary), and both records must be visible in pytest stdout/stderr without changing assertions.",
             "HTTP response header names are case-insensitive. If the helper stores a lower-case normalized header map, every Content-Type or other header assertion must query the lower-case key (for example `content-type`) or use an explicitly case-insensitive accessor; never call a case-sensitive plain dict with `Content-Type` when the stored key is lower-case. Preserve the actual media-type assertion rather than dropping it.",
@@ -4125,12 +4165,20 @@ function buildFrontendTestHybridDag(sources) {
         forbiddenPaths: forbidden,
         outputContract: "Deterministic frontend L-5 Markdown and self-contained HTML dashboard derived only from frontend-test-result-v1.",
         subtask_prompt: "Render the authoritative frontend L-5 report from frontend-test-result-v1. Do not use Pi prose or invent code coverage. Missing line/branch coverage remains unavailable and makes L-5 NOT READY.",
-        shell: { frontendTestL5Report: {}, commands: [], cwd: ".", timeoutMs: 120000 },
+        shell: {
+            frontendTestL5Report: {},
+            commands: [],
+            cwd: ".",
+            timeoutMs: 120000,
+        },
     });
     if (strictOutcomeGate) {
         tasks.push({
             id: "frontend-test-result-outcome-gate-shell",
-            depends_on: ["materialize-frontend-test-result-shell", "frontend-test-l5-report-shell"],
+            depends_on: [
+                "materialize-frontend-test-result-shell",
+                "frontend-test-l5-report-shell",
+            ],
             role: "verifier",
             executor: "shell",
             complexity: "LOW",
@@ -4148,7 +4196,10 @@ function buildFrontendTestHybridDag(sources) {
     }
     tasks.push({
         id: "frontend-test-retrospect-pi",
-        depends_on: ["materialize-frontend-test-result-shell", "frontend-test-l5-report-shell"],
+        depends_on: [
+            "materialize-frontend-test-result-shell",
+            "frontend-test-l5-report-shell",
+        ],
         role: "closeout",
         executor: "pi",
         toolProfile: "write",
@@ -5379,7 +5430,7 @@ function buildReviewVerdictRecoveryNode(sources) {
         writePolicy: "read-only",
         allowedPaths: commonReadOnlyPaths(sources),
         forbiddenPaths: commonForbiddenPaths(sources),
-        outputContract: 'Structured JSON review verdict only, preserving the original review conclusion/findings without substantive changes. No file writes.',
+        outputContract: "Structured JSON review verdict only, preserving the original review conclusion/findings without substantive changes. No file writes.",
         outputProtocol: REVIEW_JSON_VERDICT_OUTPUT_PROTOCOL,
         subtask_prompt: [
             "Normalize the output format of review-pi; this is the single read-only format-recovery attempt for the review verdict protocol.",
@@ -5734,8 +5785,9 @@ function buildProcessSupervisorNode(sources) {
             "Supervise the implementation process after soft verification.",
             "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
             "Immediately after the verdict, include one fenced block labelled REPAIR_ARTIFACT_JSON with this JSON shape:",
-            '{"schemaVersion":1,"verdict":"pass|request-revision","failureClass":"syntax|runtime|logic|boundary|environment|governance|unknown","rootCause":"one concise reason","fixScope":["path/or/component"],"invariant":"behavior or contract to preserve","evidenceRefs":["relative/path/or/node"],"rawLogFallbackAllowed":false}',
+            '{"schemaVersion":1,"verdict":"pass|request-revision","failureClass":"syntax|runtime|logic|boundary|environment|governance|unknown","rootCause":"one concise reason","fixScope":["path/or/component"],"invariant":"behavior or contract to preserve","evidenceRefs":["relative/path/or/node"],"rawLogFallbackAllowed":false,"disposition":"repairable|blocked-boundary|no-op-pass","requiredScope":["out-of-boundary/path"]}',
             `For request-revision, fixScope must be inside ${repairId} allowedPaths/writeSet. For pass, use an empty fixScope array.`,
+            "disposition defaults to repairable when omitted (backward compatible). Use blocked-boundary when the needed fix is outside repair write authority; put the out-of-boundary paths in requiredScope (report-only, never expands write authority). Use no-op-pass only when no code change is warranted.",
             `Audit boundary drift, verification gaps, and whether ${repairId} should perform bounded fixes. Read-only: do not modify files.`,
             buildSourceContextBlock(sources),
         ].join("\n\n"),
@@ -5771,7 +5823,9 @@ function buildProcessGateNode(sources) {
     };
 }
 function buildRepairNode(sources) {
-    const implement = resolveImplementPaths(sources.taskConfig);
+    const implement = resolveImplementPaths(sources.taskConfig, {
+        repoRoot: sources.repoRoot,
+    });
     return {
         id: repairNodeId(),
         depends_on: ["process-gate-shell", "process-supervisor-pi"],

package/dist/workflows/dag/repair-artifact.js

@@ -9,17 +9,31 @@ export const repairFailureClassSchema = z.enum([
     "governance",
     "unknown",
 ]);
+export const repairDispositionSchema = z.enum([
+    "repairable",
+    "blocked-boundary",
+    "no-op-pass",
+]);
 export const repairArtifactSchema = z.object({
     schemaVersion: z.literal(1),
     verdict: z.enum(["pass", "request-revision"]),
     failureClass: repairFailureClassSchema,
-    rootCause: z
-        .string()
-        .min(1, { message: 'repair artifact field "rootCause" must be a non-empty string' }),
+    rootCause: z.string().min(1, {
+        message: 'repair artifact field "rootCause" must be a non-empty string',
+    }),
     fixScope: z.array(z.string().min(1)).default([]),
     invariant: z.string().min(1),
     evidenceRefs: z.array(z.string().min(1)).default([]),
     rawLogFallbackAllowed: z.boolean().default(false),
+    /**
+     * Optional disposition for convergence routing. Omitted values are treated as
+     * `repairable` for backward compatibility with older artifacts.
+     */
+    disposition: repairDispositionSchema.optional(),
+    /**
+     * Report-only out-of-boundary paths. Never expands write authority.
+     */
+    requiredScope: z.array(z.string().min(1)).optional(),
 });
 /**
  * Canonical rootCause substituted when a `verdict: "pass"` repair artifact
@@ -117,7 +131,23 @@ function scopeWithinPatterns(scope, patterns) {
 }
 export function validateRepairArtifactScope(input) {
     const { artifact, repairTask } = input;
+    const disposition = artifact.disposition ?? "repairable";
+    const requiredScope = artifact.requiredScope ?? [];
+    for (const scope of requiredScope) {
+        if (!isPathLikeScope(scope)) {
+            return {
+                ok: false,
+                reason: `requiredScope "${scope}" must be a concrete path or glob (report-only; does not expand write authority)`,
+            };
+        }
+    }
     if (artifact.verdict === "pass") {
+        if (disposition === "blocked-boundary") {
+            return {
+                ok: false,
+                reason: "pass repair artifact cannot use blocked-boundary disposition",
+            };
+        }
         if (artifact.fixScope.length > 0) {
             return {
                 ok: false,
@@ -126,6 +156,67 @@ export function validateRepairArtifactScope(input) {
         }
         return { ok: true, artifact };
     }
+    if (disposition === "no-op-pass") {
+        return {
+            ok: false,
+            reason: "request-revision repair artifact cannot use no-op-pass disposition",
+        };
+    }
+    // blocked-boundary may report empty fixScope (nothing in-boundary to fix)
+    // while requiredScope describes the out-of-boundary need.
+    if (disposition === "blocked-boundary") {
+        if (requiredScope.length === 0) {
+            return {
+                ok: false,
+                reason: "blocked-boundary request-revision requires non-empty requiredScope (report-only)",
+            };
+        }
+        if (!repairTask) {
+            return {
+                ok: false,
+                reason: "repair artifact gate cannot find downstream repair task",
+            };
+        }
+        const allowed = repairTask.allowedPaths ?? [];
+        const writeSet = repairTask.writeSet ?? [];
+        const forbidden = repairTask.forbiddenPaths ?? [];
+        const hasOutOfBoundaryRequiredScope = requiredScope.some((scope) => {
+            const normalized = normalizePath(scope);
+            return (!scopeWithinPatterns(scope, allowed) ||
+                !scopeWithinPatterns(scope, writeSet) ||
+                forbidden.some((pattern) => pathMatchesPattern(normalized, pattern)));
+        });
+        if (!hasOutOfBoundaryRequiredScope) {
+            return {
+                ok: false,
+                reason: "blocked-boundary requiredScope must include a path outside repair task allowedPaths/writeSet",
+            };
+        }
+        if (artifact.fixScope.length > 0) {
+            for (const scope of artifact.fixScope) {
+                if (!isPathLikeScope(scope)) {
+                    return {
+                        ok: false,
+                        reason: `fixScope "${scope}" must be a concrete path or glob inside repair task allowedPaths/writeSet`,
+                    };
+                }
+                if (!scopeWithinPatterns(scope, allowed) ||
+                    !scopeWithinPatterns(scope, writeSet)) {
+                    return {
+                        ok: false,
+                        reason: `fixScope "${scope}" is outside repair task allowedPaths/writeSet`,
+                    };
+                }
+                if (forbidden.some((pattern) => pathMatchesPattern(normalizePath(scope), pattern))) {
+                    return {
+                        ok: false,
+                        reason: `fixScope "${scope}" matches repair task forbiddenPaths`,
+                    };
+                }
+            }
+        }
+        return { ok: true, artifact };
+    }
     if (artifact.fixScope.length === 0) {
         return {
             ok: false,
@@ -148,7 +239,8 @@ export function validateRepairArtifactScope(input) {
                 reason: `fixScope "${scope}" must be a concrete path or glob inside repair task allowedPaths/writeSet`,
             };
         }
-        if (!scopeWithinPatterns(scope, allowed) || !scopeWithinPatterns(scope, writeSet)) {
+        if (!scopeWithinPatterns(scope, allowed) ||
+            !scopeWithinPatterns(scope, writeSet)) {
             return {
                 ok: false,
                 reason: `fixScope "${scope}" is outside repair task allowedPaths/writeSet`,
@@ -255,12 +347,16 @@ export function resolveRepairTaskForGate(input) {
     };
 }
 export function formatRepairArtifactForPrompt(artifact) {
+    const disposition = artifact.disposition ?? "repairable";
+    const requiredScope = artifact.requiredScope ?? [];
     return [
         "Repair artifact:",
         `- verdict: ${artifact.verdict}`,
         `- failureClass: ${artifact.failureClass}`,
         `- rootCause: ${artifact.rootCause}`,
+        `- disposition: ${disposition}`,
         `- fixScope: ${artifact.fixScope.length > 0 ? artifact.fixScope.join(", ") : "(none)"}`,
+        `- requiredScope: ${requiredScope.length > 0 ? requiredScope.join(", ") : "(none)"}`,
         `- invariant: ${artifact.invariant}`,
         `- evidenceRefs: ${artifact.evidenceRefs.length > 0 ? artifact.evidenceRefs.join(", ") : "(none)"}`,
     ].join("\n");

package/dist/workflows/dag/rerun-plan.js

@@ -254,7 +254,10 @@ export function computeResetClosure(spec, effectiveFromNodeId) {
     if (!tasks.has(effectiveFromNodeId)) {
         return [];
     }
-    return [effectiveFromNodeId, ...collectReachableDescendants(spec, effectiveFromNodeId)].sort();
+    return [
+        effectiveFromNodeId,
+        ...collectReachableDescendants(spec, effectiveFromNodeId),
+    ].sort();
 }
 export function assessResetClosureSafety(spec, resetNodeIds) {
     const tasks = taskById(spec);
@@ -355,7 +358,8 @@ function computeVerificationPolicy(spec, parentRunId, resetNodeIds, importedNode
 function deriveSuggestedAction(input) {
     if (input.eligible)
         return "dag-rerun";
-    if (input.workerManaged || input.reasonCodes.includes("worker-managed-rerun-unsupported")) {
+    if (input.workerManaged ||
+        input.reasonCodes.includes("worker-managed-rerun-unsupported")) {
         return "worker-task-retry";
     }
     if (input.parentLifecycle === "paused")
@@ -449,7 +453,8 @@ export async function evaluateDagRerunPlan(input) {
         input.currentControllerFingerprint === input.parentControllerFingerprint;
     const workspaceMatched = input.parentTerminalWorkspace?.fingerprint !== undefined &&
         input.currentWorkspace?.fingerprint !== undefined &&
-        input.parentTerminalWorkspace.fingerprint === input.currentWorkspace.fingerprint;
+        input.parentTerminalWorkspace.fingerprint ===
+            input.currentWorkspace.fingerprint;
     const skillSnapshotVerified = input.skillSnapshotOk !== false;
     const sourceBindingMatched = input.bindingStatus?.sourceBindingMatched ?? true;
     const taskContractBindingMatched = input.bindingStatus?.taskContractBindingMatched ?? true;
@@ -499,7 +504,8 @@ export async function evaluateDagRerunPlan(input) {
         blockedReasons.push("workspace-checkpoint-missing");
     }
     else if (input.currentWorkspace?.fingerprint &&
-        input.parentTerminalWorkspace.fingerprint !== input.currentWorkspace.fingerprint) {
+        input.parentTerminalWorkspace.fingerprint !==
+            input.currentWorkspace.fingerprint) {
         reasonCodes.push("workspace-drift");
         blockedReasons.push("workspace-drift");
     }
@@ -566,9 +572,10 @@ export async function evaluateDagRerunPlan(input) {
     const totalPi = countExecutorNodes(input.parentSpec, allNodeIds, "pi");
     const resetPi = countExecutorNodes(input.parentSpec, resetNodeIds, "pi");
     const resetShell = countExecutorNodes(input.parentSpec, resetNodeIds, "shell");
-    const workerAssociation = input.workerAssociation ?? (input.workerManaged
-        ? { kind: "worker-managed" }
-        : { kind: "standalone" });
+    const workerAssociation = input.workerAssociation ??
+        (input.workerManaged
+            ? { kind: "worker-managed" }
+            : { kind: "standalone" });
     const planWithoutHash = {
         schemaVersion: 1,
         eligible,

package/dist/workflows/dag/types.js

@@ -163,7 +163,7 @@ export const dagFrontendVerificationBundleSchema = z
     mockCommands: z.array(z.string()).default([]),
     lintCommands: z.array(z.string().min(1)).optional(),
     staticCommands: z.array(z.string()).min(1),
-    behaviorCommands: z.array(z.string()).min(1),
+    behaviorCommands: z.array(z.string()).default([]),
     mockEvidence: dagShellVerifyEvidenceSchema.optional(),
     lintEvidence: dagShellVerifyEvidenceSchema.optional(),
     staticEvidence: dagShellVerifyEvidenceSchema,
@@ -391,6 +391,12 @@ export const dagShellConfigSchema = z.object({
     repairArtifactGate: dagRepairArtifactGateSchema.optional(),
     /** fail (default): any nonzero command fails the node. record: finish node FINISHED with failure facts for downstream assess/repair. */
     nonZeroExitPolicy: z.enum(["fail", "record"]).optional(),
+    /**
+     * When true/omitted, stop after the first failed command (runtime default true).
+     * When false, continue executing remaining commands and aggregate failures.
+     * Optional on the schema so existing shell literals stay valid; executor applies default.
+     */
+    failFast: z.boolean().optional(),
     envAllowlist: z.array(z.string()).optional(),
     timeoutMs: z.number().optional(),
     cwd: z.string().optional(),

package/dist/workflows/dag/workspace-checkpoint.js

@@ -94,11 +94,47 @@ function computeFingerprint(input) {
         gitHeadSha: input.gitHeadSha,
         statusPorcelainSha256: input.statusPorcelainSha256,
         changedPaths: input.changedPaths,
+        stableGovernanceInputs: input.stableGovernanceInputs,
     });
     return sha256Hex(payload);
 }
+/**
+ * Stable Task Contract governance inputs for same-run hard-verify reuse.
+ * Explicitly excludes `.harness/dag-runs/**` and other runner-owned volatile facts.
+ */
+export function listStableGovernanceInputPaths(taskId) {
+    const safeTaskId = String(taskId ?? "").trim();
+    if (!safeTaskId ||
+        safeTaskId.includes("..") ||
+        safeTaskId.includes("/") ||
+        safeTaskId.includes("\\")) {
+        return [];
+    }
+    const base = `.harness/tasks/${safeTaskId}`;
+    return [
+        `${base}/task.json`,
+        `${base}/dag.json`,
+        `${base}/source/需求.md`,
+        `${base}/source/执行约束.md`,
+        `${base}/source/source-manifest.json`,
+    ];
+}
+async function hashStableGovernanceInputs(repoRoot, taskId) {
+    const paths = listStableGovernanceInputPaths(taskId);
+    const entries = [];
+    for (const relPath of paths) {
+        const hashed = await hashWorkspacePath(repoRoot, relPath, "modified");
+        entries.push({
+            path: relPath,
+            contentSha256: hashed.contentSha256 ?? sha256Hex(`missing:${relPath}`),
+        });
+    }
+    entries.sort((a, b) => a.path.localeCompare(b.path));
+    return entries;
+}
 /**
  * Capture a workspace checkpoint for the current working tree.
+ * When `taskId` is provided, fingerprint includes stable ignored Task Contract inputs.
  */
 export async function captureWorkspaceCheckpoint(repoRoot, options) {
     const capturedAt = (options?.now ?? new Date()).toISOString();
@@ -127,10 +163,15 @@ export async function captureWorkspaceCheckpoint(repoRoot, options) {
         });
     }
     changedPaths.sort((a, b) => a.path.localeCompare(b.path));
+    const taskId = options?.taskId?.trim();
+    const stableGovernanceInputs = taskId
+        ? await hashStableGovernanceInputs(repoRoot, taskId)
+        : undefined;
     const fingerprint = computeFingerprint({
         gitHeadSha,
         statusPorcelainSha256,
         changedPaths,
+        stableGovernanceInputs,
     });
     return {
         schemaVersion: 1,
@@ -138,6 +179,7 @@ export async function captureWorkspaceCheckpoint(repoRoot, options) {
         gitHeadSha,
         statusPorcelainSha256,
         changedPaths,
+        ...(stableGovernanceInputs ? { stableGovernanceInputs } : {}),
         fingerprint,
     };
 }

package/docs/templates/init-managed-agents.md

@@ -29,7 +29,7 @@
 主会话（含 openCode、Cursor Chat、其他宿主 agent）= **operator-only**；skills 与本文件是纪律文档，**不能**替代 `task.json` / DAG `writeSet` / runtime 执法。
 
 | 类别 | 规则 |
-|---|---|
+| --- | --- |
 | **允许** | 已发布 `loop-agent` / `agent-worker` CLI；只读 status/doctor/report/inspect/observe；准备 `source/*` 与 `task.json` 边界；human gate；shell 验证与 handoff。 |
 | **禁止** | 绕过 CLI 用宿主 Edit/Write/ApplyPatch 直接改业务实现；CLI/DAG 失败后「救火改文件」；用聊天自述代替 shell 验证。 |
 | **失败时** | `dag doctor` / `dag report` / `dag reconcile-run`（及适用 worker reconcile）；修正任务源/`task.json`/DAG 后经 CLI 重跑。 |
@@ -40,7 +40,7 @@
 ### 自然语言入口路由
 
 | 用户表达 | 入口 | 执行动作 |
-|---|---|---|
+| --- | --- | --- |
 | loop-agent 初始化 / loop agent 初始化 / loop agent初始化 / 初始化 loop-agent | 初始化 | 完成确定性初始化闭环 |
 | 初始化更新校验 / 检查初始化更新 / loop-agent 初始化更新校验 / loop agent初始化更新校验 | 更新校验 | 只读报告，不写入 |
 | 初始化对齐 / 升级后对齐 / reconcile 初始化 / loop-agent 初始化对齐 | 升级对齐 | 自动应用确定性安全动作；surface 缺失、人工决策、活跃 DAG/Worker 或 Worker 状态无法确认时零写入 |
@@ -127,7 +127,7 @@ agent-worker console serve --repo . --port 8790   # 兼容入口，等价于上
 
 live run 先用 `loop-agent dag status --run-id <run-id>` 看 lifecycle 与 liveness；用 `loop-agent dag report --run-id <run-id> --markdown` 读 facts；失败/paused 用 `loop-agent dag doctor --run-id <run-id> --markdown`。生命周期对齐先只读运行 `loop-agent dag reconcile-run --run-id <run-id>`；只有 runner 已停止且 operator 明确提供 `--action supersede|abandon --reason "..."` 时才允许变更。失败 run 用 `loop-agent dag closeout-draft --run-id <run-id>` 生成 failure handoff，不要写成成功 closeout。
 
-Runner heartbeat 只证明 lease；Provider/tool/output 活动才代表 meaningful progress，不得仅凭运行时长结束节点。恢复：status/doctor/report → classify → reconcile/replan → CLI 重跑 → shell verify。**禁止**把主会话直接 Edit 业务代码当作恢复手段。
+Operator 须持续监控 live run，直到 controller 报告 run 已结束（节点/流程终态如 `FINISHED`、`FAILED` 或 `partial_failed`），或 Decision Gate **需要 approve**；不要在节点仍运行时假定完成。判活须组合 runner heartbeat、session events 与 `dag doctor` liveness/provider meaningful progress；Runner heartbeat 只证明 lease，alone ≠ progress，不得仅凭运行时长结束节点。exclusive writer（如 `implement-pi` / `repair-pi`）运行期间：主会话与其他 writer **不得并发修改工作区**，以免 write-guard 错误归因；只读 status/doctor/report/observe 与 approve/reject/resume CLI 仍允许。恢复：status/doctor/report → classify → reconcile/replan → CLI 重跑 → shell verify。**禁止**把主会话直接 Edit 业务代码当作恢复手段。
 
 ### 运行态与验证
 

package/harness.json

@@ -59,7 +59,7 @@
     "pi": {
       "description": "Pi planning, review, diagnosis, and bounded writing when DAG toolProfile=write",
       "LOW": "minimax-m3",
-      "MED": {"model": "deepseek/deepseek-v4-flash","thinking": "max"},
+      "MED": "grok-4.5",
       "HIGH": "gpt-5.6-sol"
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.26.2",
+  "version": "0.26.4",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",