@tea-agent/loop-agent 0.44.0-next.10 → 0.44.0-next.12

package/dist/workflows/dag/hybrid/templates/standard.js

@@ -0,0 +1,265 @@
+/** DAG hybrid standard 模板族（含 reviewed/supervised 对 standard 的装饰关系入口）。 */
+import { assertValidDagSpec } from "../../validate.js";
+import { DEFAULT_DAG_EXECUTOR_MODELS, DEFAULT_DAG_OUTPUT_LANGUAGE, parseDagSpec } from "../../types.js";
+import { TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE, isCanonicalFinalVerifyShellRetryCandidate, isTargetTemplateImplementPi } from "../../retry-policy.js";
+import { applySddEmbeddedEnhancements } from "../../sdd-embedded.js";
+import { DEFAULT_VERIFY_TIMEOUT_MS } from "../../../../executors/shell-verification.js";
+import { resolveWriterComplexity, writerDeliveryContract } from "../types.js";
+import { GENERATED_DAG_RUNTIME_CONTRACT, HYBRID_DEFAULTS, HYBRID_SKILLS_BY_ROLE, STANDARD_GLOBAL_CONSTRAINTS, applyMavenVerificationPlanning, buildSourceContextBlock, buildVerifyEvidence, buildVerifyShellCommands, canonicalizeVerificationCommands, extractObjective, extractSuccessCriteria, mergeForbiddenPaths, resolveImplementPaths } from "../sources.js";
+import { applyDefaultReadOnlyRetryPolicy, isFrontendTestPathPattern, mapTaskComplexity, replaceSourceSegmentWithTestSegment, stampGeneratedArtifactBindings, } from "./shared.js";
+export function buildStandardHybridDagFromTask(sources) {
+    const { taskConfig } = sources;
+    const forbiddenPaths = mergeForbiddenPaths(taskConfig);
+    const implementPaths = resolveImplementPaths(taskConfig, {
+        repoRoot: sources.repoRoot,
+    });
+    const scoutPaths = deriveParallelScoutPaths(taskConfig);
+    const scoutComplexity = mapTaskComplexity(taskConfig.complexity);
+    const implementComplexity = resolveWriterComplexity(taskConfig);
+    const implementId = implementationNodeId();
+    const finalVerifyCommands = sources.verifyCommands?.final ?? [];
+    const finalVerifyPlan = canonicalizeVerificationCommands(finalVerifyCommands);
+    const plannedFinal = applyMavenVerificationPlanning({
+        repoRoot: sources.repoRoot,
+        commands: finalVerifyPlan.commands,
+        taskConfig,
+    });
+    const verifyShellCommands = buildVerifyShellCommands({
+        repoRoot: sources.repoRoot,
+        commands: plannedFinal.commands,
+        fallbackCommands: [],
+    });
+    const verifyShellTask = verifyShellCommands.length > 0
+        ? [
+            {
+                id: "verify-shell",
+                depends_on: [implementId],
+                role: "verifier",
+                executor: "shell",
+                complexity: "LOW",
+                writePolicy: "read-only",
+                allowedPaths: taskConfig.allowedPaths.length > 0
+                    ? taskConfig.allowedPaths
+                    : ["**"],
+                forbiddenPaths,
+                outputContract: "Archived final shell verification stdout/stderr with exit codes; no worktree writes.",
+                subtask_prompt: "Run the adapter-resolved final verification commands before read-only verification review.",
+                transientRetryProfile: TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE,
+                shell: {
+                    commands: verifyShellCommands,
+                    verifyEvidence: buildVerifyEvidence({
+                        phase: "final",
+                        quota: "full",
+                        commandSource: "adapter",
+                        commands: plannedFinal.commands,
+                        fallbackCommands: [],
+                        finalFullRequired: true,
+                        commandTimeoutMs: DEFAULT_VERIFY_TIMEOUT_MS,
+                        plan: finalVerifyPlan,
+                        preflight: sources.verificationPreflight,
+                    }),
+                    cwd: ".",
+                    timeoutMs: DEFAULT_VERIFY_TIMEOUT_MS,
+                    ...(plannedFinal.mavenVerificationPlan
+                        ? { mavenVerificationPlan: plannedFinal.mavenVerificationPlan }
+                        : {}),
+                },
+            },
+        ]
+        : [];
+    const sourceContext = buildSourceContextBlock(sources);
+    const globalConstraints = [
+        ...taskConfig.hardConstraints,
+        ...(sources.constraintMarkdown
+            ? [`See 执行约束.md in task source (${sources.taskId})`]
+            : []),
+        ...STANDARD_GLOBAL_CONSTRAINTS,
+    ];
+    const spec = {
+        version: 3,
+        title: `Hybrid DAG: ${taskConfig.title}`,
+        runtimeContract: GENERATED_DAG_RUNTIME_CONTRACT,
+        outputLanguage: sources.outputLanguage ?? DEFAULT_DAG_OUTPUT_LANGUAGE,
+        objective: extractObjective(sources.requirementMarkdown, taskConfig.title),
+        successCriteria: extractSuccessCriteria(sources.requirementMarkdown, sources.taskId),
+        globalConstraints,
+        defaults: {
+            ...HYBRID_DEFAULTS,
+            contextProfile: taskConfig.contextProfile,
+        },
+        skillsByRole: HYBRID_SKILLS_BY_ROLE,
+        executorModels: sources.executorModelMatrix ?? DEFAULT_DAG_EXECUTOR_MODELS,
+        tasks: [
+            {
+                id: "contract-pi",
+                depends_on: [],
+                role: "planner",
+                executor: "pi",
+                complexity: "MED",
+                writePolicy: "read-only",
+                allowedPaths: taskConfig.allowedPaths.length > 0 ? taskConfig.allowedPaths : ["**"],
+                forbiddenPaths,
+                outputContract: "Plain Markdown implementation contract (10 lines or fewer); no file writes.",
+                subtask_prompt: [
+                    "Read the task source materials and return a concise implementation contract (10 lines or fewer).",
+                    "Cover scope, risks, and verification expectations. Read-only: do not modify code, docs, artifacts, or repository files.",
+                    sourceContext,
+                ].join("\n\n"),
+            },
+            {
+                id: "scout-src",
+                depends_on: ["contract-pi"],
+                role: "scout",
+                executor: "pi",
+                complexity: scoutComplexity,
+                writePolicy: "read-only",
+                allowedPaths: scoutPaths.srcPaths,
+                forbiddenPaths,
+                outputContract: "Plain Markdown source reconnaissance summary; no file writes.",
+                subtask_prompt: [
+                    "Perform read-only source reconnaissance for the task scope.",
+                    "List key source files, existing patterns, and integration points. Do not modify files.",
+                    sourceContext,
+                ].join("\n\n"),
+            },
+            {
+                id: "scout-tests",
+                depends_on: ["contract-pi"],
+                role: "scout",
+                executor: "pi",
+                complexity: scoutComplexity,
+                writePolicy: "read-only",
+                allowedPaths: scoutPaths.testPaths,
+                forbiddenPaths,
+                outputContract: "Plain Markdown test coverage reconnaissance summary; no file writes.",
+                subtask_prompt: [
+                    "Perform read-only test reconnaissance for the task scope.",
+                    "List relevant tests, coverage gaps, and verification commands. Do not modify files.",
+                    sourceContext,
+                ].join("\n\n"),
+            },
+            {
+                id: "plan-pi",
+                depends_on: ["scout-src", "scout-tests"],
+                role: "planner",
+                executor: "pi",
+                complexity: "MED",
+                writePolicy: "read-only",
+                allowedPaths: taskConfig.allowedPaths.length > 0 ? taskConfig.allowedPaths : ["**"],
+                forbiddenPaths,
+                outputContract: "Plain Markdown implementation plan; no file writes.",
+                subtask_prompt: [
+                    "Based on contract-pi, scout-src, and scout-tests upstream output, return a minimal implementation plan.",
+                    "Identify ordered steps, narrow writeSet boundaries, and verification commands. Read-only: do not modify code, docs, artifacts, or repository files.",
+                    sourceContext,
+                ].join("\n\n"),
+            },
+            {
+                id: implementId,
+                depends_on: ["plan-pi"],
+                role: "implementer",
+                executor: "pi",
+                toolProfile: "write",
+                complexity: implementComplexity,
+                writePolicy: "exclusive",
+                writeSet: implementPaths.writeSet,
+                allowedPaths: implementPaths.allowedPaths,
+                forbiddenPaths,
+                writerOutcomePolicy: { type: "implementation-outcome-v1" },
+                transientRetryProfile: TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE,
+                subtask_prompt: [
+                    "Implement the approved plan with minimal focused changes.",
+                    "Stay within writeSet. Do not write root artifacts/** unless artifacts paths are explicitly declared in writeSet.",
+                    "Apply changes by calling the write/edit tools so files change on disk. Do not paste the new code in your response instead of writing it: the runner verifies the working-tree diff mechanically, and a response-only change is an empty diff that fails this node.",
+                    "Edit existing files with the structured edit/write tools. NEVER rewrite Markdown (or any file with quoting/backticks/indentation-sensitive content) via bash sed/awk/echo redirection: escaping mistakes silently corrupt the file and self-repair loops burn the run. If a bash text-substitution already damaged a file, restore the damaged region with the edit tool against the original content instead of stacking more substitutions.",
+                    "The plan node already designed the changes — that design is your input, not your output. Your job is to write those changes into the files in writeSet. The task is not done until the files on disk contain the changes.",
+                    "If the task only adds tests/docs that use existing code as-is, forbidden implementation paths (e.g. src/**) do not block you: you never need to write them. Write the tests/docs and report changed.",
+                    ...(implementPaths.docIndexCompanions.length > 0
+                        ? [
+                            `Doc index sync is MANDATORY: ${implementPaths.docIndexCompanions.join(", ")} are catalog index files for this writeSet. When you add, rename, or remove any indexed file, you MUST also update ${implementPaths.docIndexCompanions.join(" and ")} in the same run (append or fix the matching index entry following the existing line style). Verification runs check-doc-index and fails the run when a new file is missing from the index. Skipping this sync is not "minimal change" — it is an incomplete delivery.`,
+                        ]
+                        : []),
+                    writerDeliveryContract(taskConfig),
+                    sourceContext,
+                ]
+                    .filter((value) => Boolean(value))
+                    .join("\n\n"),
+            },
+            ...verifyShellTask,
+            {
+                id: "verify-pi",
+                depends_on: verifyShellTask.length > 0 ? ["verify-shell"] : [implementId],
+                role: "verifier",
+                executor: "pi",
+                complexity: "MED",
+                writePolicy: "read-only",
+                allowedPaths: taskConfig.allowedPaths.length > 0 ? taskConfig.allowedPaths : ["**"],
+                forbiddenPaths,
+                outputContract: "Plain Markdown verification matrix and residual risks; no file writes.",
+                subtask_prompt: [
+                    "Review upstream implementation and return the verification matrix.",
+                    `Task verifyMode=${taskConfig.verifyMode}, verifyPreset=${taskConfig.verifyPreset}.`,
+                    "List commands to run, expected pass/fail evidence, and residual risks. Read-only: do not modify code, docs, artifacts, or repository files.",
+                    sourceContext,
+                ].join("\n\n"),
+            },
+            {
+                id: "closeout-pi",
+                depends_on: ["verify-pi"],
+                failureAwareDependsOn: ["verify-pi"],
+                role: "closeout",
+                executor: "pi",
+                complexity: "MED",
+                writePolicy: "read-only",
+                allowedPaths: taskConfig.allowedPaths.length > 0
+                    ? [...taskConfig.allowedPaths, "docs/**"]
+                    : ["**", "docs/**"],
+                forbiddenPaths,
+                outputContract: "Plain Markdown closeout summary; no file writes.",
+                subtask_prompt: [
+                    "Return closeout summary: what changed, verification status, risks, and handoff notes.",
+                    "If upstream failure evidence or a failure-derived skip is present, report the run as failed/partial_failed and never infer a passing result.",
+                    "Read-only: do not modify code, docs, artifacts, or .harness/dag-runs/.",
+                    sourceContext,
+                ].join("\n\n"),
+            },
+        ],
+    };
+    applySddEmbeddedEnhancements(spec, sources.sddEmbeddedSkills ?? new Set());
+    stampTargetTemplateTransientRetryProfile(spec);
+    applyDefaultReadOnlyRetryPolicy(spec);
+    stampGeneratedArtifactBindings(spec);
+    parseDagSpec(spec);
+    assertValidDagSpec(spec);
+    return spec;
+}
+export function deriveParallelScoutPaths(taskConfig) {
+    const allowed = taskConfig.allowedPaths;
+    if (allowed.length === 0) {
+        return { srcPaths: ["**"], testPaths: ["**"] };
+    }
+    const srcPaths = allowed.filter((entry) => !isFrontendTestPathPattern(entry));
+    const explicitTestPaths = allowed.filter(isFrontendTestPathPattern);
+    const derivedTestPaths = allowed
+        .map(replaceSourceSegmentWithTestSegment)
+        .filter((entry) => Boolean(entry));
+    return {
+        srcPaths: srcPaths.length > 0 ? srcPaths : allowed,
+        testPaths: explicitTestPaths.length > 0
+            ? explicitTestPaths
+            : derivedTestPaths.length > 0
+                ? derivedTestPaths
+                : allowed,
+    };
+}
+export function implementationNodeId() {
+    return "implement-pi";
+}
+export function stampTargetTemplateTransientRetryProfile(spec) {
+    for (const task of spec.tasks) {
+        if (isTargetTemplateImplementPi(task) ||
+            isCanonicalFinalVerifyShellRetryCandidate(task)) {
+            task.transientRetryProfile = TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE;
+        }
+    }
+}

package/dist/workflows/dag/hybrid/types.js

@@ -0,0 +1,32 @@
+export const INTERACTIVE_UI_DELIVERY_CONTRACT = [
+    "[INTERACTIVE_UI_DELIVERY_CONTRACT]",
+    "This is an interactive UI delivery task.",
+    "A helper-only, data-only, validation-only, or serializable-view implementation does not satisfy the task.",
+    "Before editing: identify the existing UI framework and component conventions, the real render/integration point, and the user-interaction test seam.",
+    "Required delivery: a framework-native visible component; integration into the declared route or parent; user interaction and visible error rendering; component-level tests using the repository's UI test stack.",
+    "The completion summary must list the component path, integration path, interaction test path, and DOM assertions mapped to acceptance criteria. If any item is missing, do not claim completion.",
+    "[/INTERACTIVE_UI_DELIVERY_CONTRACT]",
+].join("\n");
+export function isInteractiveUiTask(taskConfig) {
+    return taskConfig.capabilities?.includes("interactive-ui") ?? false;
+}
+export function writerDeliveryContract(taskConfig) {
+    return isInteractiveUiTask(taskConfig)
+        ? INTERACTIVE_UI_DELIVERY_CONTRACT
+        : null;
+}
+export function resolveWriterComplexity(taskConfig) {
+    if (isInteractiveUiTask(taskConfig))
+        return "HIGH";
+    if (taskConfig.complexity === "small")
+        return "MED";
+    if (taskConfig.complexity === "large")
+        return "HIGH";
+    return "MED";
+}
+export function resolveEnabledExecutors(manifestExecutors) {
+    return Object.entries(manifestExecutors)
+        .filter(([, config]) => config.enabled !== false)
+        .map(([name]) => name)
+        .filter((name) => name === "pi");
+}