@tea-agent/loop-agent 0.23.1 → 0.24.1

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/app-data.js

@@ -41,6 +41,7 @@ export function openConsoleAppData(options) {
         interviews: path.join(repoNamespace, "interviews"),
         chats: path.join(repoNamespace, "chats"),
         chatSessions: path.join(repoNamespace, "chat-sessions"),
+        chatEvents: path.join(repoNamespace, "chat-events"),
     };
     for (const dir of [
         paths.drafts,
@@ -51,6 +52,7 @@ export function openConsoleAppData(options) {
         paths.interviews,
         paths.chats,
         paths.chatSessions,
+        paths.chatEvents,
     ]) {
         ensureSecureDir(dir);
     }

package/dist/worker/console/chat/artifact-card.js

@@ -0,0 +1,23 @@
+export const ARTIFACT_KINDS = ["operation", "contract", "dag", "report", "html"];
+export function artifactFromEventPayload(payload) {
+    const raw = payload.artifact;
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const candidate = raw;
+    if (candidate.schemaVersion !== 1 ||
+        typeof candidate.artifactId !== "string" || !candidate.artifactId ||
+        typeof candidate.kind !== "string" || !ARTIFACT_KINDS.includes(candidate.kind) ||
+        typeof candidate.previewHash !== "string")
+        return undefined;
+    for (const field of ["title", "summary", "htmlPreview", "reportText", "inspectHref"]) {
+        if (candidate[field] !== undefined && typeof candidate[field] !== "string")
+            return undefined;
+    }
+    return candidate;
+}
+export function mergeArtifactCardState(current, incoming) {
+    const index = current.findIndex((item) => item.artifactId === incoming.artifactId);
+    if (index < 0)
+        return [...current, incoming];
+    return current.map((item, candidate) => candidate === index ? { ...item, ...incoming } : item);
+}