@tea-agent/loop-agent 0.24.0 → 0.24.2-beta.0

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

@@ -0,0 +1,432 @@
+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,
+];
+/**
+ * User-visible product behavior that is commonly described without naming the
+ * frontend technology or artifact. These signals are never sufficient alone:
+ * they must be backed by a frontend source path or strong project framework
+ * evidence.
+ */
+const CONTEXT_SUPPORTED_FRONTEND_DELIVERY_PATTERNS = [
+    /(?:用户|运营人员|管理员|访客|客户)[^。！？；，,\n]{0,24}(?:列表|筛选|搜索|表单|按钮|弹窗|提示|通知|状态|工作台|导航|菜单|导出|下载)/,
+    /(?:点击|输入|选择|提交|筛选|搜索|翻页|跳转|关闭|打开|导出|下载)[^。！？；，,\n]{0,24}(?:显示|展示|提示|状态|结果|页面|工作台|错误|成功|失败|加载|下载)/,
+    /(?:字段错误|下载状态|加载中|加载失败|空状态|错误状态|成功状态|结果数量|表单校验|用户可见)/,
+    /\b(?:user|operator|admin|visitor|customer)\b[^.?!;\n]{0,48}\b(?:list|filter|search|form|button|modal|toast|notification|state|dashboard|navigation|menu|export|download)\b/i,
+    /\b(?:click|type|select|submit|filter|search|paginate|navigate|close|open|export|download)\b[^.?!;\n]{0,48}\b(?:show|display|feedback|state|result|page|dashboard|error|success|failure|loading|download)\b/i,
+    /\b(?:field error|download state|loading state|empty state|error state|success state|result count|form validation|user-visible)\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 contextSupportedFrontendDelivery = 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;
+        }
+        if (!negated &&
+            !documentationOnly &&
+            matchesAny(clause, CONTEXT_SUPPORTED_FRONTEND_DELIVERY_PATTERNS)) {
+            contextSupportedFrontendDelivery = 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,
+        contextSupportedFrontendDelivery,
+        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");
+    const frontendFramework = input.frontendProject?.framework ?? "unknown";
+    const hasStrongFrontendProjectEvidence = frontendFramework === "react" ||
+        frontendFramework === "next" ||
+        frontendFramework === "vue";
+    if (hasStrongFrontendProjectEvidence) {
+        addSignal(signals, {
+            id: `frontend-project-${frontendFramework}`,
+            source: "project",
+            message: `project has strong ${frontendFramework} framework evidence`,
+        });
+    }
+    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 ||
+            titleSignals.contextSupportedFrontendDelivery ||
+            requirementSignals.contextSupportedFrontendDelivery);
+    if (pathSupportedFrontendDelivery) {
+        const supportedByRequirement = requirementSignals.pathSupportedFrontendDelivery ||
+            requirementSignals.contextSupportedFrontendDelivery;
+        addSignal(signals, {
+            id: supportedByRequirement
+                ? "frontend-path-supported-delivery-requirement"
+                : "frontend-path-supported-delivery-title",
+            source: supportedByRequirement ? "requirement" : "title",
+            message: "task text contains a frontend UI artifact and allowedPaths provide frontend source-path evidence",
+        });
+    }
+    const projectSupportedFrontendDelivery = hasStrongFrontendProjectEvidence &&
+        (titleSignals.contextSupportedFrontendDelivery ||
+            requirementSignals.contextSupportedFrontendDelivery);
+    if (projectSupportedFrontendDelivery) {
+        addSignal(signals, {
+            id: requirementSignals.contextSupportedFrontendDelivery
+                ? "frontend-project-supported-delivery-requirement"
+                : "frontend-project-supported-delivery-title",
+            source: requirementSignals.contextSupportedFrontendDelivery
+                ? "requirement"
+                : "title",
+            message: "task text contains user-visible interaction/state delivery and the project has strong frontend framework evidence",
+        });
+    }
+    const frontendDelivery = titleSignals.frontendDelivery ||
+        requirementSignals.frontendDelivery ||
+        pathSupportedFrontendDelivery ||
+        projectSupportedFrontendDelivery;
+    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,
+    };
+}

package/dist/worker/console/chat/compaction-errors.js

@@ -0,0 +1,64 @@
+/**
+ * Map Pi SDK / runtime compact failures to Operator Console HTTP errors.
+ * Keeps user-facing copy Chinese and actionable; raw SDK strings stay in `raw`.
+ */
+export function classifyChatCompactionFailure(error) {
+    const raw = error instanceof Error ? error.message : String(error);
+    if (raw === "CHAT_TURN_ACTIVE" || /cannot compact an active turn/i.test(raw)) {
+        return {
+            status: 409,
+            code: "TURN_ACTIVE",
+            message: "对话进行中，请等待当前回合结束后再压缩。",
+            raw,
+        };
+    }
+    if (raw === "COMPACTION_UNSUPPORTED") {
+        return {
+            status: 501,
+            code: "COMPACTION_UNSUPPORTED",
+            message: "当前会话运行时不支持上下文压缩。",
+            raw,
+        };
+    }
+    if (/Nothing to compact|session too small/i.test(raw)) {
+        return {
+            status: 400,
+            code: "COMPACTION_TOO_SMALL",
+            message: "会话内容太少，暂无法压缩。多轮对话后再试。",
+            raw,
+        };
+    }
+    if (/Already compacted/i.test(raw)) {
+        return {
+            status: 400,
+            code: "COMPACTION_ALREADY_DONE",
+            message: "最近已压缩，暂无更多可压缩内容。",
+            raw,
+        };
+    }
+    if (/No model|model selected|未选择模型/i.test(raw)) {
+        return {
+            status: 400,
+            code: "COMPACTION_NO_MODEL",
+            message: "未选择可用模型，无法压缩上下文。",
+            raw,
+        };
+    }
+    if (/Compaction cancelled/i.test(raw)) {
+        return {
+            status: 409,
+            code: "COMPACTION_CANCELLED",
+            message: "上下文压缩已取消。",
+            raw,
+        };
+    }
+    if (/chat session not found/i.test(raw)) {
+        return { status: 404, code: "NOT_FOUND", message: raw, raw };
+    }
+    return {
+        status: 409,
+        code: "COMPACTION_FAILED",
+        message: raw.trim() || "上下文压缩失败",
+        raw,
+    };
+}

package/dist/worker/console/chat/interview-adapter.js

@@ -3,6 +3,7 @@ import { applyGrillMeAnswer, emptyDraft, isDraftStructurallyComplete, listDraftG
 import { InterviewSessionStore } from "../interview/session.js";
 import { DraftStore } from "../draft-store.js";
 import { normalizeConsoleWorkflowKind } from "../workflow-kinds.js";
+import { discoverFrontendProjectCapability } from "../../../task/frontend-project-capability.js";
 import { scrubSecrets } from "./explore-tools.js";
 function redact(value) {
     const raw = JSON.stringify(value);
@@ -38,11 +39,23 @@ export class ChatInterviewAdapter {
         const missingFields = listDraftGaps(draft.draft);
         return { outcome: missingFields.length === 0 ? "complete" : "questions-required", fresh, missingFields, ...(reason ? { reason } : {}), ...(assessmentId ? { assessmentId } : {}), draftSha256: draft.draftSha256 };
     }
+    async nextQuestion(draft) {
+        const question = nextGrillMeQuestion(draft);
+        if (question?.gapId !== "taskKind")
+            return question;
+        const capability = await discoverFrontendProjectCapability(this.appData.repoRoot);
+        return nextGrillMeQuestion(draft, {
+            frontendProject: {
+                framework: capability.framework,
+                evidencePaths: capability.evidencePaths,
+            },
+        });
+    }
     async start(input) {
         const interview = await this.interviews.create({ taskId: input.taskId, operatorSessionId: input.operatorSessionId });
         const base = emptyDraft(input.taskId, input.title);
         const draft = await this.drafts.save({ ...base, ...input.initialDraft, requirement: { ...base.requirement, ...input.initialDraft?.requirement }, constraints: { ...base.constraints, ...input.initialDraft?.constraints }, verification: { ...base.verification, ...input.initialDraft?.verification }, schemaVersion: 1, taskId: input.taskId });
-        const question = nextGrillMeQuestion(draft.draft);
+        const question = await this.nextQuestion(draft.draft);
         const savedInterview = await this.interviews.setCurrentQuestion(interview.sessionId, question ? { id: question.id, text: question.text, affectsFields: question.affectsFields, risk: question.risk } : undefined, question ? "awaiting-user-answer" : "draft-ready");
         this.append(input.operatorSessionId, interview.sessionId, "interview-turn", { interviewSessionId: interview.sessionId, taskId: input.taskId, state: savedInterview.state, ...(question ? { question } : {}) });
         this.append(input.operatorSessionId, interview.sessionId, "draft", { taskId: input.taskId, draft: draft.draft, draftSha256: draft.draftSha256 });
@@ -59,7 +72,7 @@ export class ChatInterviewAdapter {
         const current = await this.drafts.get(interview.taskId);
         if (!current)
             throw new Error(`draft not found: ${interview.taskId}`);
-        const question = nextGrillMeQuestion(current.draft);
+        const question = await this.nextQuestion(current.draft);
         if (!question || question.id !== input.questionId)
             throw new Error("draft gap does not match current question");
         const applied = applyGrillMeAnswer(current.draft, question, { response: input.response, text: input.text });
@@ -70,7 +83,7 @@ export class ChatInterviewAdapter {
         const draft = await this.drafts.save(applied);
         await this.interviews.recordAnswer(interview.sessionId, { questionId: input.questionId, response: input.response, ...(input.text ? { text: input.text } : {}), at: new Date().toISOString() });
         const projected = recommendation ? { ...draft.draft, taskKind: recommendation } : draft.draft;
-        const nextQuestion = nextGrillMeQuestion(projected);
+        const nextQuestion = await this.nextQuestion(projected);
         const savedInterview = await this.interviews.setCurrentQuestion(interview.sessionId, nextQuestion ? { id: nextQuestion.id, text: nextQuestion.text, affectsFields: nextQuestion.affectsFields, risk: nextQuestion.risk } : undefined, nextQuestion ? "awaiting-user-answer" : "awaiting-confirmation");
         this.append(input.operatorSessionId, interview.sessionId, "interview-turn", { interviewSessionId: interview.sessionId, taskId: interview.taskId, state: savedInterview.state, answer: { questionId: input.questionId, response: input.response, ...(input.text ? { text: input.text } : {}) }, ...(nextQuestion ? { question: nextQuestion } : {}) });
         this.append(input.operatorSessionId, interview.sessionId, "draft", { taskId: interview.taskId, draft: draft.draft, draftSha256: draft.draftSha256, ...(recommendation ? { taskKindRecommendation: recommendation } : {}) });
@@ -112,7 +125,7 @@ export class ChatInterviewAdapter {
         const draft = await this.drafts.get(interview.taskId);
         if (!draft)
             return undefined;
-        const question = nextGrillMeQuestion(draft.draft);
+        const question = await this.nextQuestion(draft.draft);
         let fresh = false;
         let reason;
         if (interview.assessmentId) {

package/dist/worker/console/chat/routes.js

@@ -25,6 +25,7 @@ import { listRepoDirectory, readRepoPreview, RepoBrowserError, } from "./repo-br
 import { projectRuntimeContext } from "./runtime-context.js";
 import { patchModelsConfig, readModelsConfig, readPackageInventory, readSkillPreferences, writeSkillPreferences, } from "./pi-console-config.js";
 import { ChatInterviewAdapter, projectChatInterviewState } from "./interview-adapter.js";
+import { classifyChatCompactionFailure } from "./compaction-errors.js";
 import { evaluateMutationGate, isMutationMethod, } from "../security.js";
 import { dispatchOperatorAction } from "../operator-actions.js";
 import { makeHumanGateCard } from "./human-gate-card.js";
@@ -1414,7 +1415,11 @@ export async function handleChatCompact(req, res, deps, sessionId) {
         sendJson(res, 200, { ok: true, snapshot, eventId: event.eventId });
     }
     catch (error) {
-        sendJson(res, 409, { ok: false, error: { code: "COMPACTION_FAILED", message: error instanceof Error ? error.message : String(error) } });
+        const classified = classifyChatCompactionFailure(error);
+        sendJson(res, classified.status, {
+            ok: false,
+            error: { code: classified.code, message: classified.message },
+        });
     }
 }
 export async function handleChatMessages(res, deps, sessionId, url) {

package/dist/worker/console/interview/grill-me.js

@@ -4,16 +4,39 @@
  * assessment when required fields are present.
  */
 import { consoleWorkflowKindPromptList, normalizeConsoleWorkflowKind, } from "../workflow-kinds.js";
+import { classifyTaskDemand, } from "../../../task/task-demand-routing.js";
 const GAP_ORDER = [
     "objective",
     "scope",
     "nonGoals",
     "acceptanceCriteria",
-    "taskKind",
     "allowedPaths",
+    "taskKind",
     "forbiddenPaths",
     "verifyCommands",
 ];
+function requirementMarkdownFromDraft(draft) {
+    const requirement = draft.requirement ?? {};
+    return [
+        "# 需求",
+        requirement.objective ?? "",
+        ...(requirement.scope ?? []),
+        ...(requirement.acceptanceCriteria ?? []).map((item) => `${item.id}: ${item.text}`),
+        "## 非目标",
+        ...(requirement.nonGoals ?? []),
+    ].join("\n");
+}
+export function recommendTaskKindForDraft(draft, context = {}) {
+    const classification = classifyTaskDemand({
+        title: draft.title,
+        requirementMarkdown: requirementMarkdownFromDraft(draft),
+        allowedPaths: draft.constraints?.allowedPaths ?? [],
+        frontendProject: context.frontendProject,
+    });
+    return classification.kind === "frontend"
+        ? "frontend-implementation"
+        : "standard";
+}
 function hasText(value) {
     return typeof value === "string" && value.trim().length > 0;
 }
@@ -44,7 +67,7 @@ export function listDraftGaps(draft) {
 export function isDraftStructurallyComplete(draft) {
     return listDraftGaps(draft).length === 0;
 }
-export function buildQuestionForGap(gapId, draft) {
+export function buildQuestionForGap(gapId, draft, context = {}) {
     const taskId = draft.taskId;
     const questions = {
         objective: {
@@ -83,7 +106,7 @@ export function buildQuestionForGap(gapId, draft) {
             id: `q-${gapId}`,
             gapId,
             text: `流程类型（taskKind）应设为？(${consoleWorkflowKindPromptList()})`,
-            recommendation: "standard",
+            recommendation: recommendTaskKindForDraft(draft, context),
             affectsFields: ["taskKind"],
             risk: "medium",
         },
@@ -114,11 +137,11 @@ export function buildQuestionForGap(gapId, draft) {
     };
     return questions[gapId];
 }
-export function nextGrillMeQuestion(draft) {
+export function nextGrillMeQuestion(draft, context = {}) {
     const gaps = listDraftGaps(draft);
     for (const gapId of GAP_ORDER) {
         if (gaps.includes(gapId))
-            return buildQuestionForGap(gapId, draft);
+            return buildQuestionForGap(gapId, draft, context);
     }
     return undefined;
 }