@tea-agent/loop-agent 0.23.1 → 0.24.1

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

@@ -29,6 +29,7 @@ import { buildFrontendCaseEvidenceValidateShellSnippet, buildFrontendTestOutcome
 import { classifyFrontendRisk, } from "./frontend-risk.js";
 import { discoverFrontendProjectCapability, } from "./frontend-project-capability.js";
 import { FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID, loadFrontendImplementationContractJsonSchema, } from "./frontend-implementation-contract.js";
+import { serializeDagTaskSourcePath } from "../../task/dag-source-paths.js";
 const REQUIREMENT_FILE = "需求.md";
 const CONSTRAINT_FILE = "执行约束.md";
 const REFERENCE_DIRECTORY = "references";
@@ -1062,8 +1063,12 @@ function deriveFrontendBehaviorPaths(taskConfig) {
         return explicitTestPaths;
     return taskConfig.allowedPaths;
 }
-function toTaskRelativeSourcePath(sources, absolutePath) {
-    return path.relative(sources.taskDir, absolutePath).replaceAll(path.sep, "/");
+function toDagSourcePath(sources, absolutePath) {
+    return serializeDagTaskSourcePath({
+        repoRoot: sources.repoRoot,
+        taskDir: sources.taskDir,
+        absolutePath,
+    });
 }
 function extractExplicitRequirementIds(...markdownInputs) {
     const ids = [];
@@ -1124,7 +1129,7 @@ function buildDagSourceBinding(sources) {
         taskId: sources.taskId,
         sources: sourceEntries.map((source) => ({
             kind: source.kind,
-            path: toTaskRelativeSourcePath(sources, source.path),
+            path: toDagSourcePath(sources, source.path),
             sha256: createHash("sha256")
                 .update(source.markdown, "utf8")
                 .digest("hex"),
@@ -1149,13 +1154,13 @@ function buildBackendTestAnalysisSourceBindingContract(sources) {
     };
 }
 function buildSourceContextBlock(sources) {
-    const requirementRef = toTaskRelativeSourcePath(sources, sources.requirementPath);
+    const requirementRef = toDagSourcePath(sources, sources.requirementPath);
     const requirementExcerpt = excerptMarkdown(sources.requirementMarkdown, {
         sourceRef: requirementRef,
     });
     const parts = ["## Task source: 需求.md", requirementExcerpt.text];
     if (sources.constraintMarkdown) {
-        const constraintRef = toTaskRelativeSourcePath(sources, sources.constraintPath);
+        const constraintRef = toDagSourcePath(sources, sources.constraintPath);
         const constraintExcerpt = excerptMarkdown(sources.constraintMarkdown, {
             sourceRef: constraintRef,
         });
@@ -1165,7 +1170,7 @@ function buildSourceContextBlock(sources) {
         const relativePath = path
             .relative(path.join(sources.taskDir, "source"), reference.path)
             .replaceAll(path.sep, "/");
-        const referenceRef = toTaskRelativeSourcePath(sources, reference.path);
+        const referenceRef = toDagSourcePath(sources, reference.path);
         const referenceExcerpt = excerptMarkdown(reference.markdown, {
             sourceRef: referenceRef,
         });
@@ -1289,7 +1294,7 @@ export async function loadTaskHybridSources(repoRoot, taskId) {
     };
     return sources;
 }
-async function prepareFrontendMockSources(sources) {
+async function prepareFrontendMockSources(sources, discoveredProjectCapability) {
     const repoRoot = sources.repoRoot ?? process.cwd();
     const capability = await discoverFrontendMockCapability(repoRoot, sources.taskConfig);
     const sourceMockVerifyCommands = extractFrontendMockVerifyCommandsFromMarkdown({
@@ -1302,7 +1307,8 @@ async function prepareFrontendMockSources(sources) {
             capability.verifyCommands.push(command);
         }
     }
-    const projectCapability = await discoverFrontendProjectCapability(repoRoot);
+    const projectCapability = discoveredProjectCapability ??
+        (await discoverFrontendProjectCapability(repoRoot));
     const frontendRisk = classifyFrontendRisk({
         title: sources.taskConfig.title,
         requirementMarkdown: sources.requirementMarkdown,
@@ -1936,6 +1942,8 @@ async function buildFrontendHybridDagFromTask(sources) {
             "## Critical rules",
             "- verificationTargets is a TOP-LEVEL required array",
             "- uiStates items use name/applicable/expectedBehavior/implementationTargets/verificationTargetIds/notApplicableReason",
+            "- Use uiStates: [] for frontend logic changes with no user-visible UI state. Do not invent UI states.",
+            "- For applicable=true, provide non-empty expectedBehavior plus non-empty implementationTargets and verificationTargetIds. For applicable=false, provide non-empty notApplicableReason and omit expectedBehavior instead of emitting an empty string.",
             "- mockApi.productionDefaultOff must always be true (including strategy: not-needed)",
             "- All implementation files, verification files, symbols, and commands must be discovered from the current target workspace and current task. Never copy paths, symbols, or commands from the loop-agent repository, an example task, or prior run output.",
             "- Use relative POSIX paths rooted at the target workspace. Do not assume a particular src/test directory layout; preserve the target project's actual app/, packages/, spec/, __tests__, or other layout.",
@@ -2299,11 +2307,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                     ...(lintShellCommands.length > 0
                         ? ["frontend-lint-baseline-shell"]
                         : []),
-                    "frontend-plan-revision-pi",
-                    "frontend-final-design-review-pi",
-                    "frontend-plan-pi",
                 ],
-                dependsPolicy: "all-or-condition-skip",
                 role: "implementer",
                 executor: "pi",
                 toolProfile: "write",
@@ -2316,6 +2320,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                 outputContract: "Markdown delivery summary with Contract Ref (path/schema/hash), Changed Files, Requirements Implemented, UI States, Tests Changed, Verification Attempts, Deviations, and Residual Risks. Follow fixed stages: contract confirm → tests → component/state → API/Mock → focused checks → diff cleanup.",
                 subtask_prompt: [
                     "Implement against the validated run-owned Frontend Implementation Contract from frontend-prewrite-gate-shell (path/schema/hash). Do not rebuild the contract from Markdown alone.",
+                    "The canonical contract already contains the approved requirement, target-file, UI-state, verification, design, and Mock/API decisions. Do not re-open task sources, OpenSpec, AI workspace, plan/revision, or design-review prose, and do not repeat broad repository research. Inspect only contract target files and directly related local code needed to implement them.",
                     "Execute in fixed stages and report each in the delivery summary: (1) Contract confirm, (2) Tests sync, (3) Component/UI state implementation, (4) API/Mock wiring per contract.mockApi, (5) Focused checks behind frozen entrypoints only, (6) Diff cleanup.",
                     "Map every requirement id and applicable UI state from the contract to concrete files. Do not invent shell verification commands; only frozen static/behavior entrypoints will run.",
                     "Implement only the approved Mock strategy carried by the validated contract. Preserve the real request path as the default, require explicit test/dev activation, and never comment out or replace the real request with inline data.",
@@ -2323,8 +2328,6 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "For native, browser-intercept, or request-adapter, implement contract-aligned fixtures/states and a dev/test-only activation boundary in this same writer. For not-needed, do not add Mock files or a framework and state the positive reason.",
                     "Do not write root artifacts/** unless explicitly included in writeSet. Do not claim Browser/visual verification.",
                     writerDeliveryContract(taskConfig),
-                    sourceContext,
-                    mockContextBlock,
                 ]
                     .filter((value) => Boolean(value))
                     .join("\n\n"),
@@ -2379,11 +2382,10 @@ async function buildFrontendHybridDagFromTask(sources) {
                 subtask_prompt: [
                     "Read contracts/frontend-repair-assessment.json and the validated frontend implementation contract.",
                     "This node runs only for eligible=true. Apply the smallest fix for the classified repairable failure inside the original implement writeSet only.",
+                    "The repair assessment and canonical implementation contract are complete inputs for this phase. Do not re-open task sources, OpenSpec, AI workspace, plan/revision, or design-review prose, and do not repeat repository-wide discovery.",
                     "Do not change lint/type/test config, do not add .skip/.only, do not comment out real requests, do not default-enable Mock, do not add dependencies.",
                     "Do not re-plan requirements or expand allowed paths. Browser/visual remain not-run.",
                     writerDeliveryContract(taskConfig),
-                    sourceContext,
-                    mockContextBlock,
                 ]
                     .filter((value) => Boolean(value))
                     .join("\n\n"),
@@ -2449,19 +2451,7 @@ async function buildFrontendHybridDagFromTask(sources) {
             },
             {
                 id: "frontend-review-pi",
-                depends_on: [
-                    "frontend-review-context-shell",
-                    "frontend-reverify-shell",
-                    "frontend-repair-pi",
-                    "frontend-verify-assess-shell",
-                    implementId,
-                    "frontend-prewrite-gate-shell",
-                    "frontend-plan-pi",
-                    "frontend-design-review-pi",
-                    "frontend-plan-revision-pi",
-                    "frontend-final-design-review-pi",
-                ],
-                dependsPolicy: "all-or-condition-skip",
+                depends_on: ["frontend-review-context-shell"],
                 role: "reviewer",
                 executor: "pi",
                 complexity: "HIGH",
@@ -2477,13 +2467,11 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "Read contracts/frontend-review-context.json from frontend-review-context-shell. It binds the validated implementation contract, frontend lint assessment when lint is configured, effective initial-or-post-repair verification trace, repair assessment, and the run-owned actual diff (contracts/frontend-worktree-diff.json + artifacts/diff_patch.patch). Do not claim actual diff is missing when those artifacts exist; do not invent a diff from the implementation summary alone. Trace proves command/file/symbol binding only—not semantic correctness.",
                     "Treat lint status exactly as passed | baseline-debt | failed | unavailable. baseline-debt may continue only with intact evidence and zero diagnostics on writer-changed files; report the tolerated debt count and never rewrite it as lint passed. Typecheck, build, and test still require successful final exits.",
                     "Flag .skip/.only, deleted or weakened tests, unauthorized config changes, Mock-only evidence claimed as real integration, and Browser/visual claims (always not-run in this workflow).",
-                    "Use the direct contract and the effective plan/design branch: original plan plus initial pass when revision was skipped, or revised plan plus final design review when revision ran. Do not infer them from the implementation summary.",
+                    "The contract embedded in frontend-review-context.json is the effective reviewed plan materialized by the prewrite gate. Do not re-open task sources, OpenSpec, AI workspace, plan/revision, design-review, writer summary, or verification node prose. Inspect only the canonical review context, its bound diff, and diff-referenced files when semantic review requires source code.",
                     "Treat a commented-out real request, default-enabled Mock, production entrypoint importing test mocks, API/fixture contract drift, unauthorized Mock dependency/path, or missing behavior evidence for the selected strategy as at least Important. 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 verify that the real request remains the default and the Real Integration Gap is preserved.",
                     "Inspect the frontend-verify-assess-shell or selected frontend-reverify-shell evidence in the review context directly, including the production/default-real-path static check, and require Mock activation to be off for that check.",
                     "Distinguish Mock-backed evidence from real API integration evidence and preserve the Real Integration Gap when the backend was not exercised.",
                     "Review implementation quality, behavior/state coverage, verification evidence, and maintainability. Read-only: do not modify files.",
-                    sourceContext,
-                    mockContextBlock,
                 ].join("\n\n"),
             },
             {
@@ -2512,15 +2500,9 @@ async function buildFrontendHybridDagFromTask(sources) {
             {
                 id: "frontend-closeout-pi",
                 depends_on: [
-                    "frontend-review-gate-shell",
-                    "frontend-review-pi",
                     "frontend-review-context-shell",
-                    "frontend-reverify-shell",
-                    "frontend-repair-pi",
-                    "frontend-verify-assess-shell",
-                    "frontend-prewrite-gate-shell",
+                    "frontend-review-gate-shell",
                 ],
-                dependsPolicy: "all-or-condition-skip",
                 role: "closeout",
                 executor: "pi",
                 complexity: "MED",
@@ -2533,12 +2515,11 @@ async function buildFrontendHybridDagFromTask(sources) {
                 outputContract: "Markdown closeout summary with Changes, Mock Decision / Strategy / Files / Verification / Production Boundary, Verification Evidence, Review Result, Frontend Status, Real Integration Status, Known Risks, and Follow-up. No file writes.",
                 subtask_prompt: [
                     "Return a frontend closeout summary covering Mock decision/strategy/files/verification/production boundary, changes, verification evidence, review result, known risks, and follow-up.",
+                    "Use only the canonical frontend-review-context.json plus the final frontend review gate verdict. Do not re-open task sources, OpenSpec, AI workspace, plan/revision, design-review, writer, repair, or verification prose, and do not perform new repository research during closeout.",
                     "Include a coverage matrix for each requirement id, applicable UI state, and verification target/check with status passed|failed|not-run|blocked|unavailable. Report lint separately as passed|baseline-debt|failed|unavailable; baseline-debt is explicit debt, not passed. Always state Browser accessibility verification: not-run and Visual regression: not-run. Use contracts/frontend-review-context.json and the effective frontend-verify-assess-shell or frontend-reverify-shell facts; do not invent Browser evidence from component tests.",
                     `When only Mock-backed evidence passed, state exactly Frontend status: mock-validated and Real integration: pending, summarize the Real Integration Gap, and name ${taskConfig.taskId}-real-api-integration-verify as the explicit follow-up task to create/run after backend readiness. This follow-up is not auto-created or auto-executed. Never describe Mock evidence as real API integration.`,
                     `When Mock was skipped in auto mode and no real API evidence passed, state exactly Frontend status: locally-validated and Real integration: pending, summarize the Real Integration Gap, and name ${taskConfig.taskId}-real-api-integration-verify as the explicit follow-up task when backend readiness matters.`,
                     "Read-only: do not modify code, docs, artifacts, or .harness/dag-runs/.",
-                    sourceContext,
-                    mockContextBlock,
                 ].join("\n\n"),
             },
         ],
@@ -3349,10 +3330,11 @@ async function buildBackendTestHybridDag(sources) {
         executor: "pi", toolProfile: "write", complexity: "HIGH", writePolicy: "exclusive",
         writeSet: ["testcase/**/test_*.py", "testcase/**/helpers/**", "testcase/**/factories/**"],
         allowedPaths: Array.from(new Set([...ro, "testcase/**"])), forbiddenPaths: forbidden,
-        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; no JSON and no pytest execution.",
+        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 at least one real pytest test function or pytest test class method region, preferably as `test_BE_<MODULE>_<NNN>_<description>` and in that function/method docstring. Module-level functions and class-based pytest methods are both supported. Multiple test functions may cover one Case ID; assertions come only from 预期结果/Expected Results and setup comes only from 前置条件 plus any optional 测试数据/自动化映射 or their legacy English aliases.",
+            "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`, and `testcase/md/order-api.md` maps to `testcase/test_order_api.py`. 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.",
             "Compare timestamps and other semantically equivalent protocol values by parsed meaning, not byte-for-byte serialization. In particular, normalize valid ISO-8601 instants before equality/order assertions so differences such as omitted trailing fractional seconds do not create TestBug failures; preserve exact-string assertions only when the Markdown explicitly requires representation equality.",
             "Before logging, recursively redact sensitive keys and header values including authorization, proxy-authorization, cookie, set-cookie, token, password, secret, api key and credentials. Never print full Authorization/Cookie values. Apply bounded truncation to serialized request and response bodies (with an explicit truncation marker) so large payloads cannot flood pytest or report artifacts.",
@@ -4939,11 +4921,22 @@ function assertNoGovernanceFlagOnDisallowedTemplate(spec, template) {
     }
 }
 export async function buildHybridDagFromTask(sources, options = {}) {
+    const routingProjectCapability = sources.taskConfig.taskKind === "standard" &&
+        (options.template === undefined || options.template === "standard-dag") &&
+        sources.repoRoot
+        ? await discoverFrontendProjectCapability(sources.repoRoot)
+        : sources.frontendProjectCapability;
     const selection = resolveTaskDagTemplateSelection({
         taskKind: sources.taskConfig.taskKind,
         title: sources.taskConfig.title,
         requirementMarkdown: sources.requirementMarkdown,
         allowedPaths: sources.taskConfig.allowedPaths,
+        frontendProject: routingProjectCapability
+            ? {
+                framework: routingProjectCapability.framework,
+                evidencePaths: routingProjectCapability.evidencePaths,
+            }
+            : undefined,
         requestedTemplate: options.template,
     });
     return buildHybridDagForTemplate(sources, selection.template);
@@ -5565,17 +5558,27 @@ export function defaultHybridDagOutputPath(taskId) {
     return path.join(os.tmpdir(), `${taskId}-hybrid-dag.json`);
 }
 export async function writeHybridDagDraft(sources, outputPath, options = {}) {
+    const routingProjectCapability = sources.taskConfig.taskKind === "standard" &&
+        (options.template === undefined || options.template === "standard-dag")
+        ? await discoverFrontendProjectCapability(sources.repoRoot ?? process.cwd())
+        : sources.frontendProjectCapability;
     const templateSelection = resolveTaskDagTemplateSelection({
         taskKind: sources.taskConfig.taskKind,
         title: sources.taskConfig.title,
         requirementMarkdown: sources.requirementMarkdown,
         allowedPaths: sources.taskConfig.allowedPaths,
+        frontendProject: routingProjectCapability
+            ? {
+                framework: routingProjectCapability.framework,
+                evidencePaths: routingProjectCapability.evidencePaths,
+            }
+            : undefined,
         requestedTemplate: options.template,
     });
     const template = templateSelection.template;
     assertTaskAllowedPathsPreflight(sources.taskConfig);
     const preparedSources = template === "frontend-implementation"
-        ? await prepareFrontendMockSources(sources)
+        ? await prepareFrontendMockSources(sources, routingProjectCapability)
         : sources;
     const spec = await buildHybridDagForTemplate(preparedSources, template);
     if (preparedSources.repoRoot && dagHasWriterExecution(spec)) {

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

@@ -1,9 +1,8 @@
 import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { getTaskPaths } from "../../task/runtime.js";
 import { assertTaskContractBindingFresh } from "./task-contract-binding.js";
 import { isSafeReadOnlyPiRetryCandidate } from "./retry-policy.js";
+import { resolveDagTaskSourcePath } from "../../task/dag-source-paths.js";
 const REVIEW_VERDICT_RECOVERY_NODE_ID = "review-verdict-recovery-pi";
 const SAFE_SHELL_GATE_KEYS = [
     "verdictGate",
@@ -403,15 +402,12 @@ export async function evaluateLiveDagRerunBindings(input) {
     let sourceBindingMatched = true;
     if (sourceBinding) {
         try {
-            const taskPaths = getTaskPaths(input.cwd, sourceBinding.taskId);
             for (const source of sourceBinding.sources) {
-                const sourcePath = path.resolve(taskPaths.taskDir, source.path);
-                const sourceRoot = path.resolve(taskPaths.sourceDir);
-                if (sourcePath !== sourceRoot &&
-                    !sourcePath.startsWith(`${sourceRoot}${path.sep}`)) {
-                    sourceBindingMatched = false;
-                    break;
-                }
+                const sourcePath = resolveDagTaskSourcePath({
+                    workspaceRoot: input.cwd,
+                    taskId: sourceBinding.taskId,
+                    sourcePath: source.path,
+                });
                 const bytes = await readFile(sourcePath);
                 if (createHash("sha256").update(bytes).digest("hex") !== source.sha256) {
                     sourceBindingMatched = false;