@tea-agent/loop-agent 0.13.0-alpha.0 → 0.13.0

package/dist/workflows/dag/node-execution.js

@@ -1,3 +1,5 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { recordDecisionEnvelopeForNode, shouldPauseOnHumanEscalation, writeHumanEscalationArtifacts, } from "./decision-envelope.js";
 import { writeNodeRecord, writeNodeSkillArtifacts } from "./run-store.js";
@@ -405,6 +407,13 @@ export async function executeDagNode(input) {
             assistantText: node.assistantText,
         });
         Object.assign(node, artifactMeta);
+        if (task.shell?.jsonArtifactGate) {
+            const artifactPath = path.join(runDir, task.shell.jsonArtifactGate.outputDir, task.shell.jsonArtifactGate.artifactName);
+            const bytes = await readFile(artifactPath);
+            node.structuredArtifactPath = artifactPath;
+            node.structuredArtifactSha256 = createHash("sha256").update(bytes).digest("hex");
+            node.structuredArtifactSchemaId = task.shell.jsonArtifactGate.schemaId;
+        }
     }
     state.nodes[nodeId].nodeRecordPath = path.join(runDir, `${nodeId}.json`);
     await writeNodeRecord(runDir, nodeId, state.nodes[nodeId]);

package/dist/workflows/dag/prompt.js

@@ -73,6 +73,15 @@ export function buildUpstreamContext(task, upstream, maxChars = MAX_UPSTREAM_CHA
             : record.assistantArtifactPath;
         const { preview, truncated } = formatStdoutPreview(upstreamText, maxChars);
         let section = `## Upstream output: ${depId}\n${preview}`;
+        if (record.structuredArtifactPath) {
+            section += [
+                "",
+                "Validated structured artifact (read-only runner evidence — use read tool to fetch; do not edit):",
+                `- path: ${record.structuredArtifactPath}`,
+                `- schema: ${record.structuredArtifactSchemaId ?? "unknown"}`,
+                `- sha256: ${record.structuredArtifactSha256 ?? "unknown"}`,
+            ].join("\n");
+        }
         if (truncated && artifactPath) {
             section += formatUpstreamArtifactPointerMap(record, artifactKind);
         }

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

@@ -13,12 +13,51 @@ export const repairArtifactSchema = z.object({
     schemaVersion: z.literal(1),
     verdict: z.enum(["pass", "request-revision"]),
     failureClass: repairFailureClassSchema,
-    rootCause: z.string().min(1),
+    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),
 });
+/**
+ * Canonical rootCause substituted when a `verdict: "pass"` repair artifact
+ * arrives with an empty or whitespace-only rootCause. Keeps the persisted
+ * RepairArtifact schema-valid without weakening request-revision diagnostics.
+ */
+export const PASS_VERDICT_DEFAULT_ROOT_CAUSE = "No repair required.";
+/**
+ * Normalize model-emitted repair artifacts deterministically at the parser
+ * boundary: a `verdict: "pass"` artifact with an empty/whitespace-only
+ * rootCause is rewritten to the canonical default so it still satisfies the
+ * strict schema. request-revision and other fields are left untouched so the
+ * strict diagnostics and write boundaries remain fail-closed.
+ */
+function normalizePassArtifactRootCause(parsed) {
+    if (parsed &&
+        typeof parsed === "object" &&
+        !Array.isArray(parsed) &&
+        parsed.verdict === "pass") {
+        const record = parsed;
+        const rootCause = record.rootCause;
+        if (typeof rootCause === "string" && rootCause.trim().length === 0) {
+            return { ...record, rootCause: PASS_VERDICT_DEFAULT_ROOT_CAUSE };
+        }
+    }
+    return parsed;
+}
+/**
+ * Render a single Zod issue as a field-path-aware message so callers can locate
+ * invalid repair-artifact fields instead of seeing bare min-length text.
+ */
+function describeZodIssue(issue) {
+    const path = issue.path && issue.path.length > 0 ? issue.path.join(".") : "(root)";
+    if (issue.message && !/^String must contain/.test(issue.message)) {
+        return `field "${path}": ${issue.message} (code ${issue.code})`;
+    }
+    return `field "${path}" is invalid (code ${issue.code})`;
+}
 const REPAIR_ARTIFACT_FENCE = /```(?:REPAIR_ARTIFACT_JSON|json)\s*([\s\S]*?)```/gi;
 function extractCandidateJsonBlocks(text) {
     const blocks = [];
@@ -42,11 +81,12 @@ export function parseRepairArtifactFromText(text) {
     for (const candidate of candidates) {
         try {
             const parsed = JSON.parse(candidate);
-            const result = repairArtifactSchema.safeParse(parsed);
+            const normalized = normalizePassArtifactRootCause(parsed);
+            const result = repairArtifactSchema.safeParse(normalized);
             if (result.success) {
                 return { ok: true, artifact: result.data };
             }
-            errors.push(result.error.issues.map((issue) => issue.message).join(", "));
+            errors.push(result.error.issues.map((issue) => describeZodIssue(issue)).join(", "));
         }
         catch (error) {
             errors.push(error instanceof Error ? error.message : String(error));

package/dist/workflows/dag/report.js

@@ -186,6 +186,20 @@ const dagRunReportEntrySchema = z
         runtimeContractReason: z.string().optional(),
     })
         .optional(),
+    evaluationAssociation: z.discriminatedUnion("status", [
+        z.object({ status: z.literal("absent-legacy") }).strict(),
+        z
+            .object({
+            status: z.literal("present"),
+            campaignId: z.string().min(1),
+            candidateId: z.string().min(1),
+            bundleHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+            seed: z.number().int().nonnegative(),
+            split: z.enum(["public", "private", "held_out"]).optional(),
+            taskRef: z.string().min(1).optional(),
+        })
+            .strict(),
+    ]),
     executorJsonl: dagArtifactRefSchema,
     nodes: z.array(dagNodeReportRowSchema),
 })
@@ -502,6 +516,9 @@ export async function buildDagRunReportEntry(input) {
         pausedByNodeId: input.state.pausedByNodeId,
         pauseReason: input.state.pauseReason,
         ...summarizeControllerIdentityForReport(input.state.controllerIdentityRef, input.spec),
+        evaluationAssociation: input.state.evaluation
+            ? { status: "present", ...input.state.evaluation }
+            : { status: "absent-legacy" },
         nodes,
     };
     const primaryNode = resolvePrimaryFailureNode(partialEntry);
@@ -757,7 +774,9 @@ function formatConvergenceSummary(run) {
         `- convergence: enabled=${convergence.enabled}, pass=${convergence.currentPass}/${convergence.maxPasses}, terminal=${convergence.terminalReason ?? "-"}`,
     ];
     for (const pass of convergence.passHistory) {
-        const verifySummary = pass.verifyPhase || pass.verifyQuota || pass.verifyCommandCount !== undefined
+        const verifySummary = pass.verifyPhase ||
+            pass.verifyQuota ||
+            pass.verifyCommandCount !== undefined
             ? `, verify=${pass.verifyPhase ?? "-"} quota=${pass.verifyQuota ?? "-"} commands=${pass.verifyCommandCount ?? "-"}`
             : "";
         lines.push(`- pass ${pass.pass}: ${pass.status}, reason=${pass.reason}, hardVerify=${pass.hardVerifyStatus ?? "-"}(${pass.hardVerifyFailureCategory ?? "-"})${verifySummary}, artifacts=${pass.artifactRefs.length}`);
@@ -809,6 +828,21 @@ export function formatDagReportMarkdown(report) {
             `- runDir: ${run.runDir}`,
             `- startedAt: ${run.startedAt}`,
             `- finishedAt: ${run.finishedAt ?? "-"}`,
+            ...(run.evaluationAssociation.status === "present"
+                ? [
+                    `- evaluationAssociation: present`,
+                    `- campaignId: ${run.evaluationAssociation.campaignId}`,
+                    `- candidateId: ${run.evaluationAssociation.candidateId}`,
+                    `- bundleHash: ${run.evaluationAssociation.bundleHash}`,
+                    `- seed: ${run.evaluationAssociation.seed}`,
+                    ...(run.evaluationAssociation.split
+                        ? [`- split: ${run.evaluationAssociation.split}`]
+                        : []),
+                    ...(run.evaluationAssociation.taskRef
+                        ? [`- taskRef: ${run.evaluationAssociation.taskRef}`]
+                        : []),
+                ]
+                : ["- evaluationAssociation: absent/legacy"]),
             `- executorJsonl: ${run.executorJsonl.path} (${run.executorJsonl.exists ? "exists" : "missing"})`,
             ...formatConvergenceSummary(run),
             "",

package/dist/workflows/dag/runner.js

@@ -1,6 +1,7 @@
 import { readdir, readFile } from "node:fs/promises";
 import { hostname } from "node:os";
 import path from "node:path";
+import { readCandidateRecord } from "../../infrastructure/evaluation/candidate-store.js";
 import { CANONICAL_TASK_ID_PATTERN, formatLocalCompactDate, } from "../../task/runtime.js";
 import { getDagRunDir, isTerminalDagRunStatus, locateDagRun, readHumanApprovalArtifact, requireActiveDagRun, } from "./lifecycle.js";
 import { moveToCompletedRunDir, moveToPausedRunDir, prepareActiveRunDir, writeRunSpec, writeRunState, } from "./run-store.js";
@@ -15,7 +16,7 @@ import { relocateConvergenceArtifactPaths, relocateRunArtifactPaths, } from "./u
 import { createSkillSnapshot, prepareSkillSnapshotForContinuation, writeSkillSnapshot, } from "./skill-snapshot.js";
 import { buildNodePrompt, buildNodePromptWithResolvedSkillInstructions, executeDagNode, } from "./node-execution.js";
 import { runConvergencePassController, shouldEnableDagConvergence, } from "./convergence/controller.js";
-import { executeDagRanksOnce, isConditionSkippedReason, } from "./scheduler.js";
+import { executeDagRanksOnce, isConditionSkippedReason } from "./scheduler.js";
 import { topoSortToRanks } from "./topo.js";
 import { parseDagSpec, resolveModelForTask, } from "./types.js";
 import { executeDynamicCondition } from "./dynamic-runtime/condition.js";
@@ -134,6 +135,7 @@ export function createInitialRunState(spec, opts, ranks, runId = opts.runId ?? "
         status: opts.initOnly || opts.dryRun ? "pending" : "running",
         ranks,
         nodes,
+        ...(spec.evaluation ? { evaluation: { ...spec.evaluation } } : {}),
         ...(shouldEnableDagConvergence(spec)
             ? {
                 convergence: {
@@ -146,9 +148,32 @@ export function createInitialRunState(spec, opts, ranks, runId = opts.runId ?? "
             : {}),
     };
 }
+export function assertFrozenEvaluationBinding(spec, state) {
+    const declared = spec.evaluation;
+    const frozen = state.evaluation;
+    if (!declared && !frozen)
+        return;
+    if (!declared ||
+        !frozen ||
+        JSON.stringify(declared) !== JSON.stringify(frozen)) {
+        throw new Error(`dag run ${state.runId} evaluation binding drifted between run.json and state.json; refuse to continue`);
+    }
+}
+export async function assertEvaluationBindingPreflight(cwd, binding) {
+    if (!binding)
+        return;
+    const record = await readCandidateRecord(cwd, binding.candidateId);
+    if (record.manifest.bundleHash !== binding.bundleHash) {
+        throw new Error(`evaluation bundleHash mismatch for ${binding.candidateId}: declared ${binding.bundleHash}, registry ${record.manifest.bundleHash}`);
+    }
+    if (!["eligible", "experimenting", "accepted"].includes(record.status)) {
+        throw new Error(`evaluation candidate ${binding.candidateId} lifecycle status ${record.status} is not executable`);
+    }
+}
 export async function runDag(spec, opts) {
     assertValidDagSpec(spec);
-    // Capability preflight must fail closed before any run directory or node work.
+    // Candidate identity is validated before run-id allocation or directory creation.
+    await assertEvaluationBindingPreflight(opts.cwd, spec.evaluation);
     const runningIdentity = resolveRunningControllerIdentity();
     if (!runningIdentity) {
         throw new Error("running controller identity could not be resolved; refuse to create an unpinned DAG run");
@@ -242,6 +267,7 @@ export async function resumeDagRun(opts) {
     if (isTerminalDagRunStatus(state.status)) {
         throw new Error(`dag run ${opts.runId} is already terminal (status=${state.status})`);
     }
+    assertFrozenEvaluationBinding(spec, state);
     // Runtime contract + controller identity must be re-verified before executing
     // any remaining node on resume; drift fails closed.
     const runningIdentity = resolveRunningControllerIdentity();

package/dist/workflows/dag/skill-instructions.js

@@ -3,8 +3,8 @@ import { access, readFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-export const DEFAULT_SKILL_INSTRUCTION_MAX_CHARS = 2_500;
-export const DEFAULT_SKILL_INSTRUCTION_TOTAL_MAX_CHARS = 10_000;
+export const DEFAULT_SKILL_INSTRUCTION_MAX_CHARS = 3_000;
+export const DEFAULT_SKILL_INSTRUCTION_TOTAL_MAX_CHARS = 12_000;
 const SKILL_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
 async function fileExists(filePath) {
     try {
@@ -413,7 +413,9 @@ async function findFirstExistingFile(candidates) {
 async function resolveLearnedPatternInstructions(input) {
     const repoSlug = path.basename(input.cwd).replace(/[^A-Za-z0-9_-]+/g, "-");
     const candidates = [
+        normalizeCandidate(path.join(input.cwd, ".agents", "skills", "loop-agent", "references", "learned", `${repoSlug}.md`)),
         normalizeCandidate(path.join(input.cwd, "skills", "loop-agent", "references", "learned", `${repoSlug}.md`)),
+        normalizeCandidate(path.join(input.cwd, ".agents", "skills", "loop-agent", "references", "learned", "default.md")),
         normalizeCandidate(path.join(input.cwd, "skills", "loop-agent", "references", "learned", "default.md")),
         normalizeCandidate(path.join(input.cwd, "tools", "loop-agent", "skill", "references", "learned", `${repoSlug}.md`)),
         normalizeCandidate(path.join(input.cwd, "tools", "loop-agent", "skill", "references", "learned", "default.md")),

package/dist/workflows/dag/task-demand-routing.js

@@ -0,0 +1,383 @@
+const OUT_OF_SCOPE_HEADING = /^(?:非目标|不包含|范围外|不在范围|out\s+of\s+scope|non[-\s]?goals?)(?:\s*(?:[（(].*[）)]|[:：].*|[/—–-]\s*.*))?$/i;
+const FRONTEND_TASK_TYPE = /^\s*(?:[-*]\s*)?task\s+type\s*:\s*frontend-feature\s*$/im;
+const BACKEND_TASK_TYPE = /^\s*(?:[-*]\s*)?task\s+type\s*:\s*backend-feature\s*$/im;
+const FRONTEND_NEGATION_PATTERNS = [
+    /(?:不涉及|无需|不需要|不包含|不修改|不实现|不交付|不要|禁止|不得|排除).{0,16}(?:前端(?:页面|组件|界面|功能|交互)?|页面|组件|界面|用户界面|浏览器交互)/,
+    /(?:前端(?:页面|组件|界面|功能|交互)?|页面|组件|界面|用户界面).{0,12}(?:不在(?:本次)?范围|无需|不需要|不修改|不实现|不交付|不要|禁止|不得)/,
+    /(?:不涉及|无需|不需要|不包含|不修改|不实现|不交付|不要|禁止|不得|排除).{0,16}(?<![A-Za-z0-9_])UI(?![A-Za-z0-9_])/i,
+    /(?<![A-Za-z0-9_])UI(?![A-Za-z0-9_]).{0,12}(?:不在(?:本次)?范围|无需|不需要|不修改|不实现|不交付|不要|禁止|不得)/i,
+    /\b(?:backend|server[-\s]?side)\s+only\b/i,
+    /\b(?:no|without)\s+(?:frontend|front[-\s]?end|ui|user\s+interface)\b/i,
+    /\b(?:do\s+not|don't|must\s+not|should\s+not)\s+(?:(?:add|implement|build|create|update|modify|fix|refactor|render|style|change|touch)\s+)?(?:(?:the|any|a|an)\s+)?(?:frontend|front[-\s]?end|ui|user\s+interface|page|component|form|modal|dialog)\b/i,
+    /\bwithout\s+(?:(?:adding|implementing|building|creating|updating|modifying|fixing|refactoring|rendering|styling|changing|touching)\s+)?(?:(?:the|any|a|an)\s+)?(?:frontend|front[-\s]?end|ui|user\s+interface|page|component|form|modal|dialog)\b/i,
+    /\b(?:frontend|front[-\s]?end|ui|user\s+interface|page|component|form|modal|dialog)\b[^.?!;\n]{0,20}\b(?:is|are)?\s*(?:out\s+of\s+scope|excluded|not\s+(?:required|needed)|unchanged)\b/i,
+];
+const FRONTEND_DELIVERY_PATTERNS = [
+    /(?:新增|实现|开发|修改|重构|修复|优化|创建|渲染|搭建|改造)[^。！？；，,\n]{0,24}(?:前端(?:页面|组件|界面|功能|交互)|页面|组件|界面|表单|弹窗|对话框|用户界面|浏览器(?:页面|交互|行为))/,
+    /(?:前端(?:页面|组件|界面|功能|交互)|页面|组件|界面|表单|弹窗|对话框|用户界面|浏览器交互)[^。！？；，,\n]{0,16}(?:新增|实现|开发|修改|重构|修复|优化|创建|渲染|搭建|改造)/,
+    /\b(?:add|implement|build|create|update|modify|fix|refactor|render|style)\b[^.?!;\n]{0,48}\b(?:front[-\s]?end\s+(?:page|component|view|form|modal|interaction|ui)|ui|form|modal|dialog|dashboard|navigation|toast|button|dropdown|user\s+interface|browser\s+interaction)\b/i,
+];
+const PATH_SUPPORTED_FRONTEND_DELIVERY_PATTERNS = [
+    /(?:新增|实现|开发|修改|重构|修复|优化|创建|渲染|搭建|改造)[^。！？；，,\n]{0,24}(?:页(?!\p{Script=Han})|表格|列表|按钮|导航|菜单|标签页|下拉框|选择器|提示|通知|加载状态|空状态|错误状态|交互|样式|布局)/u,
+    /(?:新增|实现|开发|修改|重构|修复|优化|创建|渲染|搭建|改造)[^。！？；，,\n]{0,24}(?<![A-Za-z0-9_])(?:DOM|UI|React|Vue|Svelte|Angular)(?![A-Za-z0-9_])/i,
+    /\b(?:add|implement|build|create|update|modify|fix|refactor|render|style)\b[^.?!;\n]{0,48}\b(?:page|component|screen|layout|dom|react|vue|svelte|angular)\b/i,
+];
+const BACKEND_DELIVERY_PATTERNS = [
+    /(?:新增|实现|开发|修改|重构|修复|提供|创建|调整|优化|迁移|扩展)[^。！？；，,\n]{0,24}(?:后端(?:服务|接口|逻辑|API)?|服务端(?:服务|接口|逻辑)?|接口|数据库|数据表(?!格)|数据库索引|索引|控制器|服务层|仓储层)/i,
+    /(?:后端(?:服务|接口|逻辑|API)?|服务端(?:服务|接口|逻辑)?|接口|数据库|数据表(?!格)|数据库索引|控制器|服务层|仓储层)[^。！？；，,\n]{0,16}(?:新增|实现|开发|修改|重构|修复|提供|创建|调整|优化|迁移|扩展)/i,
+    /(?:新增|实现|开发|修改|重构|修复|提供|创建|调整|优化|迁移|扩展)[^。！？；，,\n]{0,24}(?<![A-Za-z0-9_])API(?![A-Za-z0-9_])/i,
+    /(?<![A-Za-z0-9_])API(?![A-Za-z0-9_])[^。！？；，,\n]{0,16}(?:新增|实现|开发|修改|重构|修复|提供|创建|调整|优化|迁移|扩展)/i,
+    /\b(?:add|implement|build|create|update|modify|fix|refactor|migrate|extend)\b[^.?!;\n]{0,48}\b(?:backend|server[-\s]?side|api|endpoint|database|migration|controller|service|repository)\b/i,
+];
+const BACKEND_NEGATION_PATTERNS = [
+    /(?:不涉及|无需|不需要|不包含|不修改|不实现|不交付|不要|禁止|不得|排除).{0,16}(?:后端|服务端|接口|数据库|数据表(?!格)|索引)/,
+    /(?:不涉及|无需|不需要|不包含|不修改|不实现|不交付|不要|禁止|不得|排除).{0,16}(?<![A-Za-z0-9_])API(?![A-Za-z0-9_])/i,
+    /\b(?:no|without)\s+(?:backend|server[-\s]?side|api|endpoint|database)\b/i,
+    /\b(?:do\s+not|don't|must\s+not|should\s+not)\s+(?:(?:add|implement|build|create|update|modify|fix|refactor|migrate|change|touch)\s+)?(?:(?:the|any|a|an)\s+)?(?:backend|server[-\s]?side|api|endpoint|database)\b/i,
+];
+const FRONTEND_PATH_PATTERNS = [
+    /(?:^|\/)apps\/web\/src(?:\/|$)/i,
+    /(?:^|\/)(?:frontend|client)(?:\/|$)/i,
+    /(?:^|\/)src\/(?:pages?|components?|views?)(?:\/|$)/i,
+    /\.(?:tsx|jsx|vue|svelte|css|scss|less)(?:$|[*?])/i,
+];
+const BACKEND_PATH_PATTERNS = [
+    /(?:^|\/)(?:backend|server|api|controllers?|services?|repositories?|db|database|migrations?)(?:\/|$)/i,
+    /\.(?:sql)(?:$|[*?])/i,
+];
+const NON_PRODUCT_PATH_SEGMENT = /(?:^|\/)(?:docs?|skills?|tests?|__tests__|e2e|cypress)(?:\/|$)/i;
+const FRONTEND_PATH_EXCLUSIONS = NON_PRODUCT_PATH_SEGMENT;
+const DOCUMENTATION_ONLY_MARKERS = /(?:文档|说明|指南|规范|测试用例|测试计划|评审|审查|\b(?:docs?|documentation|guide|specification|test\s+cases?|test\s+plan|review)\b)/i;
+const DOCUMENTATION_ONLY_ACTIONS = /(?:新增|实现|开发|创建|编写|更新|修改|重构|修复|优化|渲染|搭建|改造|补充|生成|评审|审查|\b(?:add|implement|build|create|write|update|modify|refactor|fix|optimize|render|style|document|review|generate)\b)/i;
+const PRODUCT_AND_DOCUMENT_DELIVERY = /(?:新增|实现|开发|修改|重构|修复|优化|创建|渲染|搭建|改造)[^。！？；，,\n]{0,24}(?:前端|页面|组件|界面|表单|交互|样式|布局|DOM|UI|React|Vue|Svelte|Angular|源码|代码)[^。！？；，,\n]{0,16}(?:并|同时|以及|和|与|\band\b)[^。！？；，,\n]{0,16}(?:文档|说明|指南|规范|\b(?:docs?|documentation|guide)\b)/i;
+const TEST_ONLY_MARKERS = /(?:测试|用例|\b(?:e2e|unit|integration|component)\s+tests?\b|\btests?\b)/i;
+const PRODUCT_AND_TEST_DELIVERY = /(?:并|同时|以及|和|与|\band\b).{0,12}(?:添加|新增|编写|补充|测试|\b(?:add|write|test)\b)/i;
+const NON_PRODUCT_ALLOWED_PATH_PATTERNS = [
+    NON_PRODUCT_PATH_SEGMENT,
+    /\.(?:test|spec)\.[^/]+$/i,
+    /\.cy\.[^/]+$/i,
+    /\.mdx?(?:$|[*?])/i,
+];
+const SPECIAL_TEMPLATE_BY_TASK_KIND = {
+    "frontend-implementation": "frontend-implementation",
+    "frontend-test": "frontend-test-dag",
+    "backend-test": "backend-test-dag",
+    "knowledge-sync": "knowledge-sync-dag",
+    "knowledge-graph-bootstrap": "knowledge-graph-bootstrap-dag",
+};
+const TASK_KIND_ROUTING_REASON = {
+    "frontend-implementation": 'taskKind "frontend-implementation" selects the dedicated frontend DAG template',
+    "frontend-test": 'taskKind "frontend-test" selects the dedicated frontend test DAG template',
+    "backend-test": 'taskKind "backend-test" selects the dedicated backend test DAG template',
+    "knowledge-sync": 'taskKind "knowledge-sync" selects the dedicated knowledge-sync DAG template',
+    "knowledge-graph-bootstrap": 'taskKind "knowledge-graph-bootstrap" selects the dedicated knowledge-graph bootstrap DAG template',
+};
+const SPECIAL_REQUESTED_TEMPLATES = new Set([
+    "frontend-implementation",
+    "frontend-test-dag",
+    "backend-test-dag",
+    "knowledge-sync-dag",
+    "knowledge-graph-bootstrap-dag",
+]);
+function stripOutOfScopeSections(markdown) {
+    const output = [];
+    let skippedHeadingLevel = null;
+    for (const line of markdown.split(/\r?\n/)) {
+        const heading = /^(#{1,6})\s+(.+?)\s*$/.exec(line.trim());
+        if (heading) {
+            const level = heading[1].length;
+            if (skippedHeadingLevel !== null && level <= skippedHeadingLevel) {
+                skippedHeadingLevel = null;
+            }
+            if (OUT_OF_SCOPE_HEADING.test(heading[2].trim())) {
+                skippedHeadingLevel = level;
+                continue;
+            }
+        }
+        if (skippedHeadingLevel === null)
+            output.push(line);
+    }
+    return output.join("\n");
+}
+function stripFencedCodeBlocks(markdown) {
+    const output = [];
+    let fenceCharacter = null;
+    for (const line of markdown.split(/\r?\n/)) {
+        const fence = /^\s*(`{3,}|~{3,})/.exec(line);
+        if (fence) {
+            const character = fence[1][0];
+            if (fenceCharacter === null)
+                fenceCharacter = character;
+            else if (fenceCharacter === character)
+                fenceCharacter = null;
+            continue;
+        }
+        if (fenceCharacter === null)
+            output.push(line);
+    }
+    return output.join("\n");
+}
+/**
+ * Normalize task prose before deterministic demand/capability signal checks.
+ * Examples and explicit non-goals must not become positive routing evidence.
+ */
+export function normalizeTaskRequirementText(markdown) {
+    return stripOutOfScopeSections(stripFencedCodeBlocks(markdown));
+}
+function splitClauses(text) {
+    return text
+        .split(/[。！？!?；;，,\r\n]+/)
+        .map((clause) => clause.trim())
+        .filter(Boolean);
+}
+function matchesAny(value, patterns) {
+    return patterns.some((pattern) => pattern.test(value));
+}
+function isFrontendNegated(clause) {
+    return matchesAny(clause, FRONTEND_NEGATION_PATTERNS);
+}
+function isDocumentationOnlyClause(clause) {
+    if (!DOCUMENTATION_ONLY_ACTIONS.test(clause))
+        return false;
+    if (DOCUMENTATION_ONLY_MARKERS.test(clause)) {
+        return !PRODUCT_AND_DOCUMENT_DELIVERY.test(clause);
+    }
+    return TEST_ONLY_MARKERS.test(clause) && !PRODUCT_AND_TEST_DELIVERY.test(clause);
+}
+function masksExistingBackendDependency(clause) {
+    return clause
+        .replace(/(?:调用|使用|消费|对接|依赖)(?:现有|已有)?[^。！？；，,\n]{0,12}(?:后端|服务端|API|接口)/gi, " ")
+        .replace(/\b(?:call|consume|use|integrate\s+with|depend\s+on)\b[^.?!;\n]{0,24}\b(?:existing|current)?\s*(?:backend|server[-\s]?side|api|endpoint)\b/gi, " ");
+}
+function addSignal(signals, signal) {
+    if (signals.some((current) => current.id === signal.id))
+        return;
+    signals.push(signal);
+}
+function collectTextSignals(input) {
+    let frontendDelivery = false;
+    let pathSupportedFrontendDelivery = false;
+    let backendDelivery = false;
+    let frontendNegated = false;
+    for (const clause of splitClauses(input.text)) {
+        const negated = isFrontendNegated(clause);
+        frontendNegated ||= negated;
+        const documentationOnly = isDocumentationOnlyClause(clause);
+        if (!negated &&
+            !documentationOnly &&
+            matchesAny(clause, FRONTEND_DELIVERY_PATTERNS)) {
+            frontendDelivery = true;
+            addSignal(input.signals, {
+                id: `frontend-delivery-${input.source}`,
+                source: input.source,
+                message: `${input.source} contains an implementation action and a frontend UI deliverable`,
+            });
+        }
+        if (!negated &&
+            !documentationOnly &&
+            matchesAny(clause, PATH_SUPPORTED_FRONTEND_DELIVERY_PATTERNS)) {
+            pathSupportedFrontendDelivery = true;
+        }
+        const backendClause = masksExistingBackendDependency(clause);
+        if (!matchesAny(clause, BACKEND_NEGATION_PATTERNS) &&
+            matchesAny(backendClause, BACKEND_DELIVERY_PATTERNS)) {
+            backendDelivery = true;
+            addSignal(input.signals, {
+                id: `backend-delivery-${input.source}`,
+                source: input.source,
+                message: `${input.source} contains an implementation action and a backend deliverable`,
+            });
+        }
+    }
+    return {
+        frontendDelivery,
+        pathSupportedFrontendDelivery,
+        backendDelivery,
+        frontendNegated,
+    };
+}
+function normalizedAllowedPath(value) {
+    return value.trim().replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function reasonsForClassification(input) {
+    const signalIds = input.signals.map((signal) => signal.id);
+    const reasons = [`task demand classified as ${input.kind}`];
+    if (signalIds.length > 0)
+        reasons.push(`signals: ${signalIds.join(", ")}`);
+    if (input.blockers.length > 0)
+        reasons.push(`blockers: ${input.blockers.join(", ")}`);
+    return reasons;
+}
+export function classifyTaskDemand(input) {
+    const signals = [];
+    const blockers = [];
+    const requirement = normalizeTaskRequirementText(input.requirementMarkdown);
+    const hasFrontendTaskType = FRONTEND_TASK_TYPE.test(requirement);
+    const hasBackendTaskType = BACKEND_TASK_TYPE.test(requirement);
+    if (hasFrontendTaskType) {
+        addSignal(signals, {
+            id: "task-type-frontend-feature",
+            source: "requirement",
+            message: "requirement contains the materialized frontend-feature task type",
+        });
+    }
+    if (hasBackendTaskType) {
+        addSignal(signals, {
+            id: "task-type-backend-feature",
+            source: "requirement",
+            message: "requirement contains the materialized backend-feature task type",
+        });
+    }
+    const titleSignals = collectTextSignals({
+        text: input.title,
+        source: "title",
+        signals,
+    });
+    const requirementSignals = collectTextSignals({
+        text: requirement,
+        source: "requirement",
+        signals,
+    });
+    const frontendNegated = titleSignals.frontendNegated || requirementSignals.frontendNegated;
+    if (frontendNegated)
+        blockers.push("frontend-negated");
+    let frontendPath = false;
+    let backendPath = false;
+    for (const rawPath of input.allowedPaths) {
+        const allowedPath = normalizedAllowedPath(rawPath);
+        if (!FRONTEND_PATH_EXCLUSIONS.test(allowedPath) &&
+            matchesAny(allowedPath, FRONTEND_PATH_PATTERNS)) {
+            frontendPath = true;
+        }
+        if (matchesAny(allowedPath, BACKEND_PATH_PATTERNS))
+            backendPath = true;
+    }
+    if (frontendPath) {
+        addSignal(signals, {
+            id: "frontend-path",
+            source: "allowed-path",
+            message: "allowedPaths include a frontend-specific source path",
+        });
+    }
+    if (backendPath) {
+        addSignal(signals, {
+            id: "backend-path",
+            source: "allowed-path",
+            message: "allowedPaths include a backend-specific source path",
+        });
+    }
+    const pathSupportedFrontendDelivery = frontendPath &&
+        (titleSignals.pathSupportedFrontendDelivery ||
+            requirementSignals.pathSupportedFrontendDelivery);
+    if (pathSupportedFrontendDelivery) {
+        addSignal(signals, {
+            id: requirementSignals.pathSupportedFrontendDelivery
+                ? "frontend-path-supported-delivery-requirement"
+                : "frontend-path-supported-delivery-title",
+            source: requirementSignals.pathSupportedFrontendDelivery
+                ? "requirement"
+                : "title",
+            message: "task text contains a frontend UI artifact and allowedPaths provide frontend source-path evidence",
+        });
+    }
+    const frontendDelivery = titleSignals.frontendDelivery ||
+        requirementSignals.frontendDelivery ||
+        pathSupportedFrontendDelivery;
+    const allowedPathsOnlyCoverNonProductArtifacts = input.allowedPaths.length > 0 &&
+        input.allowedPaths.every((rawPath) => {
+            const allowedPath = normalizedAllowedPath(rawPath);
+            return matchesAny(allowedPath, NON_PRODUCT_ALLOWED_PATH_PATTERNS);
+        });
+    if (allowedPathsOnlyCoverNonProductArtifacts && frontendDelivery) {
+        blockers.push("non-product-allowed-paths");
+    }
+    const eligibleFrontendDelivery = frontendDelivery && !allowedPathsOnlyCoverNonProductArtifacts;
+    const backendDelivery = titleSignals.backendDelivery || requirementSignals.backendDelivery;
+    const taskTypeConflict = (hasFrontendTaskType && (backendDelivery || frontendNegated)) ||
+        (hasBackendTaskType && eligibleFrontendDelivery);
+    if (taskTypeConflict)
+        blockers.push("task-type-conflict");
+    let kind;
+    if ((hasFrontendTaskType && hasBackendTaskType) || taskTypeConflict) {
+        kind = "mixed";
+    }
+    else if (hasFrontendTaskType) {
+        kind = "frontend";
+    }
+    else if (hasBackendTaskType) {
+        kind = "backend";
+    }
+    else if (eligibleFrontendDelivery && backendDelivery) {
+        kind = "mixed";
+    }
+    else if (eligibleFrontendDelivery && frontendNegated) {
+        kind = "mixed";
+    }
+    else if (eligibleFrontendDelivery) {
+        kind = "frontend";
+    }
+    else if (backendDelivery) {
+        kind = "backend";
+    }
+    else {
+        kind = "unknown";
+    }
+    return {
+        kind,
+        signals,
+        blockers,
+        reasons: reasonsForClassification({ kind, signals, blockers }),
+    };
+}
+export function resolveTaskDagTemplateSelection(input) {
+    const requestedTemplate = input.requestedTemplate ?? "standard-dag";
+    const taskKindTemplate = SPECIAL_TEMPLATE_BY_TASK_KIND[input.taskKind];
+    if (taskKindTemplate) {
+        return {
+            template: taskKindTemplate,
+            source: "taskKind",
+            reasons: [TASK_KIND_ROUTING_REASON[input.taskKind]],
+        };
+    }
+    if (SPECIAL_REQUESTED_TEMPLATES.has(requestedTemplate)) {
+        return {
+            template: requestedTemplate,
+            source: "requested-template",
+            reasons: [],
+        };
+    }
+    if (input.taskKind !== "standard") {
+        return {
+            template: requestedTemplate,
+            source: "requested-template",
+            reasons: [],
+        };
+    }
+    if (requestedTemplate !== "standard-dag") {
+        return {
+            template: requestedTemplate,
+            source: "requested-template",
+            reasons: [],
+        };
+    }
+    const classification = classifyTaskDemand(input);
+    if (classification.kind === "frontend") {
+        const frontendSignals = classification.signals
+            .map((signal) => signal.id)
+            .filter((id) => id === "task-type-frontend-feature" || id.startsWith("frontend-"));
+        return {
+            template: "frontend-implementation",
+            source: "task-source",
+            reasons: [
+                `task source classified as frontend from signals: ${frontendSignals.join(", ")}`,
+            ],
+            classification,
+        };
+    }
+    return {
+        template: requestedTemplate,
+        source: "requested-template",
+        reasons: [],
+        classification,
+    };
+}