@tea-agent/loop-agent 0.23.1 → 0.24.1

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

@@ -1,383 +1 @@
-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,
-    };
-}
+export * from "../../task/task-demand-routing.js";

package/docs/README.md

@@ -2,7 +2,7 @@
 
 `docs/` 是 loop-agent 源仓的治理文档根目录。新读者不需要先浏览所有文件，先按任务选择入口，再由目录 README 或 `docs/document-catalog.json` 判断文档身份。
 
-**维护日：2026-07-25** — 对齐 `@tea-agent/loop-agent@0.23.1`。版本事实以根 `CHANGELOG.md` 与 `package.json` 为准；能力短摘要见 `reports/current-capability-summary.md`。
+**维护日：2026-07-27** — 对齐 `@tea-agent/loop-agent@0.24.0`。版本事实以根 `CHANGELOG.md` 与 `package.json` 为准；能力短摘要见 `reports/current-capability-summary.md`。
 
 ## 我现在要做什么？
 

package/docs/architecture/README.md

@@ -2,7 +2,7 @@
 
 本目录是 loop-agent 维护者架构文档入口。每篇文档回答一个具体问题，不重复 `runtime-boundaries.md` 的依赖方向表与 governance-hook 表；遇到契约级事实请回到该文件。
 
-**维护日：2026-07-25** — 索引与演进叙述对齐仓库头 `@tea-agent/loop-agent@0.23.1`。边界表仍以 `runtime-boundaries.md` 与 `scripts/check-*.sh` 为准。
+**维护日：2026-07-27** — 索引与演进叙述对齐仓库头 `@tea-agent/loop-agent@0.24.0`。边界表仍以 `runtime-boundaries.md` 与 `scripts/check-*.sh` 为准。
 
 ## 阅读路径
 
@@ -11,10 +11,10 @@
 1. `runtime-boundaries.md` — runtime 层边界、依赖方向与治理 hook 的机器校验契约（**先读，是其他文档的边界真源**）。
 2. `agents-invariants.md` — `AGENTS.md`（source）与 init managed block 的「什么不能删」不变量契约（短语真源 + 行数 guardrail 语义）。
 3. `system-overview.md` — loop-agent / agent-worker / 治理层 / 外部系统的全景关系。
-3. `dag-execution.md` — Agent DAG 主调用链、rank 调度、executor、skill snapshot、生命周期。
-4. `worker-and-feature.md` — agent-worker 子进程边界、controller identity、Task Pool、Feature、Observe 与 Console。
-5. `facts-and-state.md` — `.harness/` 各根目录、canonical facts、derived read models 与不可变规则。
-6. `evolution.md` — 当前已实现能力 vs 第 3–6 月未来方向（明确标注规划/未实现）。
+4. `dag-execution.md` — Agent DAG 主调用链、rank 调度、executor、skill snapshot、生命周期。
+5. `worker-and-feature.md` — agent-worker 子进程边界、controller identity、Task Pool、Feature、Observe 与 Console。
+6. `facts-and-state.md` — `.harness/` 各根目录、canonical facts、derived read models 与不可变规则。
+7. `evolution.md` — 当前已实现能力 vs 第 3–6 月未来方向（明确标注规划/未实现）。
 
 ## 事实与规划的区分
 

package/docs/architecture/evolution.md

@@ -2,9 +2,9 @@
 
 本页区分 loop-agent **当前已实现**的架构能力与**未来规划**。当前事实以代码、发布 CLI、已完成计划为准；未来能力一律标「规划 / 未实现 / 前瞻」。权威源：`CHANGELOG.md`、`docs/reports/current-capability-summary.md`、ADR 0001–0005、`docs/exec-plans/completed/` 与 `docs/exec-plans/active/`。
 
-**对照版本：`@tea-agent/loop-agent@0.23.1`（2026-07-25）**。细节版本条目见根 `CHANGELOG.md`；本表只保留架构层可读摘要。
+**对照版本：`@tea-agent/loop-agent@0.24.0`（2026-07-27）**。细节版本条目见根 `CHANGELOG.md`；本表只保留架构层可读摘要。
 
-## 当前已实现（累计至 0.22.0）
+## 当前已实现（累计至 0.24.0）
 
 | 域 | 现状 | 权威入口 |
 | --- | --- | --- |
@@ -21,7 +21,7 @@
 | Frontend-test | 默认 short-chain RAG；内容/evidence 质量进入 advisory findings，路径与安全边界仍 fail-closed | `CHANGELOG.md [0.21.0]` / `[0.22.0]` |
 | Frontend-implementation | Contract / trace / repair / Mock assess；`ai_workspace` + 知识库 + `openspec` 规范发现；lint 基线债务隔离 | `CHANGELOG.md [0.22.0]` |
 | Inspect（原 Observe） | 统一 Console 的 `/inspect/` 只读运营面与富时间线；兼容期仍保留独立 `observe serve` | `website/docs/guides/observe-ui.md`、`CHANGELOG.md [Unreleased]` |
-| Local Operator Console | `agent-worker console serve\|doctor`（loopback）；Operate + Inspect、Happy Path / Interview / split view / recovery CTA；**非**远端多用户 Console | unify design；ADR 0005 |
+| Local Operator Console | `agent-worker console serve\|doctor`（loopback）；Operate + Inspect、Happy Path / Interview / split view / recovery CTA；**0.23.x 起含 General Operator Chat**（Pi SDK services session、operator-only tool surface）；**非**远端多用户 Console | unify design；ADR 0005；completed `2026-07-25-console-phase-4-general-operator-chat.md` |
 | Task Contract / operator surface | journaled `task contract *`；machine envelope；**DagSpec v4 `taskContractBinding`**（exclusive writer 强制） | `CHANGELOG.md [0.17.0]`–`[0.17.2]`；ADR 0005 |
 | DagSpec / repair | v3 `runtimeContract` + 显式 `repairNodeId`；新 writer 生成默认 v4 binding | `dag-execution.md`、`CHANGELOG.md [0.11.0]` / `[0.17.0]` |
 | 自适应 liveness | runner lease、Provider/tool/output 活动与 meaningful progress 分离；静默 stall 受控终止，退出未确认时禁止自动重试 | `dag-execution.md`、active `2026-07-23-dag-adaptive-liveness.md` |
@@ -52,7 +52,7 @@
 | fullstack Delivery / Final Verification live 闭环 | 进行中（active train） | `docs/exec-plans/active/2026-07-19-fullstack-dogfood-016x-release-train.md` |
 | Dynamic Workflow runtime limits 强执法、更广 profile | 设计输入 | `docs/design/active/dynamic-workflow-dag-engine-roadmap.md` |
 | Loop 与 Dynamic Workflow 更深双向集成 / 自动恢复 | 设计输入 | 同上；当前已有基础 `workflow` action |
-| Console Phase 4 General Operator Chat | 规划 / 未实现 | Console design residual |
+| Operator Chat 作为主操作会话（裸 bash 收敛、真 human gate、durable session/turn、Operation 闭环、完整 CLI action coverage、默认入口切换） | 设计输入 / 未达主会话门槛 | `docs/design/active/operator-chat-primary-session-roadmap.md`；Phase 4 General Operator Chat 本体已实现归档（`docs/exec-plans/completed/2026-07-25-console-phase-4-general-operator-chat.md`） |
 | Eval Lab auto-promote / RSI Level 1 产品声称 | **禁止**写成已交付 | Eval Lab design + active plan |
 
 > 本地 Operator Console 统一面（实际首发 0.19.0）已发布：单仓库、loopback、随 `@tea-agent/loop-agent` 同包、canonical mutation 只经 sibling CLI，Inspect 复用 GET-only Observe read model。它不是远端 Web Console，也不能把多租户/云编排需求偷渡进本地 Console。

package/docs/architecture/worker-and-feature.md

@@ -2,7 +2,7 @@
 
 本页说明 `agent-worker` 如何通过冻结的已发布 `loop-agent` 子进程执行 DAG（不 in-process import runtime kernel），以及其上的产品线 read model：TaskSpec、Task Pool、Feature 与统一 Operator Console（Operate + Inspect）。边界契约权威是 `runtime-boundaries.md` §Worker adapter。
 
-**维护校准：2026-07-25 / `@tea-agent/loop-agent@0.23.1`** — 统一 Operator Console（Operate + Inspect）、恢复操作面与自适应 liveness 已落地；细节以 `CHANGELOG.md` 与对应 active/completed plan 为准。
+**维护校准：2026-07-27 / `@tea-agent/loop-agent@0.24.0`** — 统一 Operator Console（Operate + Inspect）、恢复操作面与自适应 liveness 已落地；细节以 `CHANGELOG.md` 与对应 active/completed plan 为准。
 
 ## 核心事实：子进程，非 in-process
 

package/docs/templates/backend-test-dag.json

@@ -202,8 +202,8 @@
         ".harness/dag-runs/**",
         "artifacts/**"
       ],
-      "outputContract": "Convert every final automatable Markdown case into pytest assets whose actual test function region contains the exact Case ID, preferably in the function name or docstring; no JSON and no pytest execution.",
-      "subtask_prompt": "Convert testcase/md/** to pytest using upstream environment and advisory validation evidence plus only bounded pytest config/conftest. A FAIL advisory report does not authorize inventing missing behavior; use the final Markdown facts that are present.\n\nEnsure every final Markdown Case ID appears in at least one real pytest test function or pytest test class method region, preferably as `test_BE_<MODULE>_<NNN>_<description>` and in that function/method docstring. Module-level functions and class-based pytest methods are both supported. Multiple test functions may cover one Case ID; assertions come only from 预期结果/Expected Results and setup comes only from 前置条件 plus any optional 测试数据/自动化映射 or their legacy English aliases.\n\nGenerate a reusable HTTP logging helper (or equivalent client wrapper) and call it for every interface request. The request log must include method, URL/path, and request parameters (query plus JSON/body/payload summary). The response log must include status code and response result (JSON/text/body summary), and both records must be visible in pytest stdout/stderr without changing assertions.\n\nCompare timestamps and other semantically equivalent protocol values by parsed meaning, not byte-for-byte serialization. In particular, normalize valid ISO-8601 instants before equality/order assertions so differences such as omitted trailing fractional seconds do not create TestBug failures; preserve exact-string assertions only when the Markdown explicitly requires representation equality.\n\nBefore logging, recursively redact sensitive keys and header values including authorization, proxy-authorization, cookie, set-cookie, token, password, secret, api key and credentials. Never print full Authorization/Cookie values. Apply bounded truncation to serialized request and response bodies (with an explicit truncation marker) so large payloads cannot flood pytest or report artifacts.\n\nDo not read source/**, add cases, reassign ACs, modify conftest/config/production code, use skip/xfail, swallow assertions, execute pytest, or emit JSON. For best-effort cleanup, catch only the narrow transport exception actually raised by the selected HTTP client (for example `requests.RequestException` or `urllib.error.URLError`); never use bare `except`, `Exception`, or `BaseException` with `pass`."
+      "outputContract": "Convert every final automatable Markdown case into pytest assets whose actual test function region contains the exact Case ID, preferably in the function name or docstring. Each testcase/md/<module>.md (excluding README.md) maps one-to-one to testcase/test_<module>.py; never merge or split modules. No JSON and no pytest execution.",
+      "subtask_prompt": "Convert testcase/md/** to pytest using upstream environment and advisory validation evidence plus only bounded pytest config/conftest. A FAIL advisory report does not authorize inventing missing behavior; use the final Markdown facts that are present.\n\nEnsure every final Markdown Case ID appears in at least one real pytest test function or pytest test class method region, preferably as `test_BE_<MODULE>_<NNN>_<description>` and in that function/method docstring. Module-level functions and class-based pytest methods are both supported. Multiple test functions may cover one Case ID; assertions come only from 预期结果/Expected Results and setup comes only from 前置条件 plus any optional 测试数据/自动化映射 or their legacy English aliases.\n\nName each generated pytest file so it corresponds one-to-one with its source Markdown module file: for each `testcase/md/<module>.md` (excluding README.md), emit exactly one `testcase/test_<module>.py`. The <module> stem is the Markdown filename without the `.md` extension, lowercased and with non-alphanumeric characters replaced by underscores. For example, `testcase/md/resource_notes.md` maps to `testcase/test_resource_notes.py`, and `testcase/md/order-api.md` maps to `testcase/test_order_api.py`. Never merge multiple Markdown modules into one pytest file, never split one module across several files, and never invent pytest filenames unrelated to the Markdown modules.\n\nGenerate a reusable HTTP logging helper (or equivalent client wrapper) and call it for every interface request. The request log must include method, URL/path, and request parameters (query plus JSON/body/payload summary). The response log must include status code and response result (JSON/text/body summary), and both records must be visible in pytest stdout/stderr without changing assertions.\n\nCompare timestamps and other semantically equivalent protocol values by parsed meaning, not byte-for-byte serialization. In particular, normalize valid ISO-8601 instants before equality/order assertions so differences such as omitted trailing fractional seconds do not create TestBug failures; preserve exact-string assertions only when the Markdown explicitly requires representation equality.\n\nBefore logging, recursively redact sensitive keys and header values including authorization, proxy-authorization, cookie, set-cookie, token, password, secret, api key and credentials. Never print full Authorization/Cookie values. Apply bounded truncation to serialized request and response bodies (with an explicit truncation marker) so large payloads cannot flood pytest or report artifacts.\n\nDo not read source/**, add cases, reassign ACs, modify conftest/config/production code, use skip/xfail, swallow assertions, execute pytest, or emit JSON. For best-effort cleanup, catch only the narrow transport exception actually raised by the selected HTTP client (for example `requests.RequestException` or `urllib.error.URLError`); never use bare `except`, `Exception`, or `BaseException` with `pass`."
     },
     {
       "id": "backend-test-traceability-gate-shell",

package/docs/templates/frontend-implementation-contract.schema.json

@@ -11,7 +11,7 @@
     "riskLevel": { "enum": ["small", "standard", "high-risk"] },
     "targets": { "type": "object", "additionalProperties": false, "required": ["files"], "properties": { "files": { "type": "array", "minItems": 1, "items": { "$ref": "#/$defs/path" } }, "routes": { "type": "array", "items": { "type": "string", "pattern": "^/" } }, "publicApiChanges": { "type": "array", "items": { "type": "string", "minLength": 1 } } } },
     "requirements": { "type": "array", "minItems": 1, "items": { "type": "object", "additionalProperties": false, "required": ["id", "implementationTargets", "verificationTargetIds"], "properties": { "id": { "$ref": "#/$defs/requirementId" }, "implementationTargets": { "type": "array", "items": { "$ref": "#/$defs/path" } }, "verificationTargetIds": { "type": "array", "items": { "type": "string", "minLength": 1 } }, "evidenceGap": { "$ref": "#/$defs/gap" } } } },
-    "uiStates": { "type": "array", "minItems": 1, "items": { "type": "object", "additionalProperties": false, "required": ["name", "applicable"], "properties": { "name": { "type": "string", "minLength": 1 }, "applicable": { "type": "boolean" }, "expectedBehavior": { "type": "string", "minLength": 1 }, "implementationTargets": { "type": "array", "items": { "$ref": "#/$defs/path" } }, "verificationTargetIds": { "type": "array", "items": { "type": "string", "minLength": 1 } }, "notApplicableReason": { "type": "string", "minLength": 1 } } } },
+    "uiStates": { "type": "array", "items": { "type": "object", "additionalProperties": false, "required": ["name", "applicable"], "properties": { "name": { "type": "string", "minLength": 1 }, "applicable": { "type": "boolean" }, "expectedBehavior": { "type": "string", "minLength": 1 }, "implementationTargets": { "type": "array", "items": { "$ref": "#/$defs/path" } }, "verificationTargetIds": { "type": "array", "items": { "type": "string", "minLength": 1 } }, "notApplicableReason": { "type": "string", "minLength": 1 } }, "allOf": [{ "if": { "properties": { "applicable": { "const": true } }, "required": ["applicable"] }, "then": { "required": ["expectedBehavior", "implementationTargets", "verificationTargetIds"], "properties": { "implementationTargets": { "minItems": 1 }, "verificationTargetIds": { "minItems": 1 } } } }, { "if": { "properties": { "applicable": { "const": false } }, "required": ["applicable"] }, "then": { "required": ["notApplicableReason"] } }] } },
     "interactions": { "type": "array", "items": { "type": "object", "additionalProperties": false, "required": ["name", "implementationTargets", "verificationTargetIds"], "properties": { "name": { "type": "string", "minLength": 1 }, "implementationTargets": { "type": "array", "items": { "$ref": "#/$defs/path" } }, "verificationTargetIds": { "type": "array", "items": { "type": "string" } } } } },
     "mockApi": { "type": "object", "additionalProperties": false, "required": ["strategy", "productionDefaultOff", "activation", "endpoints"], "properties": { "strategy": { "enum": ["native", "browser-intercept", "request-adapter", "not-needed"] }, "productionDefaultOff": { "const": true }, "activation": { "type": "string", "minLength": 1 }, "endpoints": { "type": "array", "items": { "type": "object", "additionalProperties": false, "required": ["method", "path"], "properties": { "method": { "enum": ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"] }, "path": { "type": "string", "pattern": "^/" }, "fixture": { "$ref": "#/$defs/path" }, "consumer": { "$ref": "#/$defs/path" } } } } } },
     "designEvidence": { "type": "object", "additionalProperties": false, "required": ["source", "paths", "conflicts"], "properties": { "source": { "type": "string", "minLength": 1 }, "paths": { "type": "array", "items": { "$ref": "#/$defs/path" } }, "conflicts": { "type": "array", "items": { "type": "string", "minLength": 1 } } } },

package/harness.json

@@ -59,7 +59,7 @@
     "pi": {
       "description": "Pi planning, review, diagnosis, and bounded writing when DAG toolProfile=write",
       "LOW": "gpt-5.3-codex-spark",
-      "MED": "gpt-5.5",
+      "MED": "glm-5.2",
       "HIGH": "gpt-5.6-sol"
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.23.1",
+  "version": "0.24.1",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",

package/skills/frontend-implementation/SKILL.md

@@ -29,6 +29,13 @@ rules, commands, or retrievals. Scout/planners locate and explicitly read applic
 specs; only successful paired reads count. Lockfile-only, fixture-only, or unread
 search hits do not prove a reusable Mock service.
 
+This broad discovery rule applies only to contract, scout, and plan phases. For
+`frontend-implement-pi`, the run-owned
+`contracts/frontend-implementation-contract.json` is the approved semantic input;
+do not repeat task-source, OpenSpec, AI workspace, plan, or repository-wide
+discovery. For `frontend-repair-pi`, consume that contract plus
+`contracts/frontend-repair-assessment.json` and make only the bounded repair.
+
 ## Implementation Discipline
 
 - Reuse confirmed specs, components, tokens, helpers, APIs, mocks, schemas, and tests.

package/skills/frontend-implementation/references/node-contracts.md

@@ -6,7 +6,7 @@ Pre-write nodes are read-only. Preserve IDs, labels, commands, language, require
 
 - **`frontend-contract-pi`**: `Scope`, `Non-goals`, `Acceptance Criteria`, `UI States`, `Target Runtime Environment`, `Risks`, `Verification Expectations`. No guessed requirements.
 - **`frontend-scout-pi`**: routes, components, tokens, data/API/Mock, scripts, tests, assets. Fact vs inference vs gap. Query the knowledge base when available and always search+read `openspec/schemas/`, `openspec/project-specs/`, and `ai_workspace/` before repo fallback. Output stack, routes, components, styling, conventions, state/data, test entry points, reuse, risks.
-- **`frontend-plan-pi` + conditional design loop**: AC → steps, in-bound files, UI states, reuse, deps, Mock/API strategy, activation/rollback, frozen verify entrypoints, real-integration gap, and exactly one `frontend-implementation-contract-v1` JSON object. Prefer native Mock; browser intercept only with existing e2e; request-adapter only for a reversible seam. `auto` may select `not-needed` when no project Mock capability exists, while keeping real requests default and recording the gap; `required` cannot. Initial design pass uses the original plan; only exact `request-revision` runs read-only revision plus final review. Small-risk runs one design review only.
+- **`frontend-plan-pi` + conditional design loop**: AC → steps, in-bound files, applicable UI states, reuse, deps, Mock/API strategy, activation/rollback, frozen verify entrypoints, real-integration gap, and exactly one `frontend-implementation-contract-v1` JSON object. Use `uiStates: []` for logic-only changes with no user-visible UI state; do not invent UI states. Applicable states require behavior/implementation/verification, while non-applicable states require a reason and omit empty behavior placeholders. Prefer native Mock; browser intercept only with existing e2e; request-adapter only for a reversible seam. `auto` may select `not-needed` when no project Mock capability exists, while keeping real requests default and recording the gap; `required` cannot. Initial design pass uses the original plan; only exact `request-revision` runs read-only revision plus final review. Small-risk runs one design review only.
 - **`frontend-prewrite-gate-shell`**: the sole write authorization. Resolve effective plan/review, require exact pass, retain every REQ/BR/AC id, enforce Mock policy, validate schema/source binding, and materialize `contracts/frontend-implementation-contract.json`. Fallback is allowed only when a conditional primary is absent; an existing malformed primary fails closed. Generation-time blocked Mock produces one deterministic blocking shell node and no writer.
 - **`frontend-implement-pi`**: sole exclusive writer. Stay in `writeSet`; real requests default-on; Mock reversible, dev/test-only, production-off. Atomic handler/intercept/adapter with consumer+tests. Stop on forbidden paths or guesses. Output changed files, behavior, UI states, styling notes, verification attempted, residual risks. Optional mock-verify when frozen; static+behavior always; behavior must prove page consumption. Skipped-Mock `not-needed` keeps real integration pending unless the real backend path has fresh evidence.
 

package/skills/frontend-verification/SKILL.md

@@ -30,9 +30,10 @@ verdict/findings, and required browser, visual, manual, or knowledge evidence.
   `frontend-lint-assessment-v1` proving only pre-writer diagnostics on unchanged
   files. Report debt count, changed files, and raw evidence. Typecheck/build/test do
   not support debt.
-- Resolve design evidence from parallel sources: query the available knowledge
-  connector and always read task-relevant `<repoRoot>/openspec/schemas/`,
-  `<repoRoot>/openspec/project-specs/`, and `<repoRoot>/ai_workspace/`. Connector format is TODO; never invent it.
+- Use design and requirement evidence already bound inside
+  `contracts/frontend-review-context.json`. Closeout must not query connectors,
+  re-open task sources, OpenSpec, AI workspace, upstream model prose, or start new
+  repository research.
 - Separate Mock service/handler checks from page consumption and record the
   dev/test-only boundary; handler tests alone do not prove page use.
 

package/skills/loop-agent/references/hybrid-dag.md

@@ -14,7 +14,7 @@
 
 此 policy 驱动 `dag run-task --profile auto`：CLI 仍要求显式 `dag run-task`、`dag validate`、`run-dag`，但 `--profile auto` 在确定性 candidate `governanceProfile` 推断后应用 `workflowPolicy.dag.profileRouting`。生成器还会把 `outputLanguage` 写入 DagSpec，runner 在每个 Pi/Cursor 节点 prompt 中注入语言规则；代码、命令、路径、JSON 字段与 gate token 保持原样。`humanGatePolicy` 是默认人机边界声明；真实暂停仍由 DAG 节点的 `decisionGate.mode: "pause-on-human"` 与 decision envelope 触发。无 profile 的 `dag run-task <task-id>` 仍为 standard-compatible，供 legacy/review workflow。
 
-对于默认 `standard` 任务，生成器根据标题、`source/需求.md` 和结构化 `allowedPaths` 做保守、确定性的需求分类。只有高置信的前端实现需求自动选择 `frontend-implementation` DAG；后端、前后端混合、明确排除前端或证据不足的需求继续使用 governance profile 选出的模板。分类不会把普通后端实现路由到 `backend-test`，也不会替换由显式 profile、`workflowPolicy` 或 supervised quality gate 选中的 supervised 模板。
+对于默认 `standard` 任务，生成器组合标题、`source/需求.md`、结构化 `allowedPaths`、React/Next/Vue 强工程证据与用户可见交互/状态语义，做保守、确定性的需求分类。即使需求没有显式写出“前端/UI/页面”，工程证据与产品交付语义共同成立时也会自动选择 `frontend-implementation` DAG；框架证据单独不足以触发。后端、前后端混合、明确排除前端、文档/测试维护或证据不足的需求继续使用 governance profile 选出的模板。分类不会把普通后端实现路由到 `backend-test`，也不会替换由显式 profile、`workflowPolicy` 或 supervised quality gate 选中的 supervised 模板。
 
 前端专用链保留独立 contract/scout；plan 同时选择 Mock/API 策略并输出结构化 implementation contract。design initial pass 直接使用原计划，只有 request-revision 才运行 revision/final review；small-risk 只执行一次 design review。`frontend-prewrite-gate-shell` 合并生效 verdict、REQ/BR/AC 覆盖、Mock policy 和 contract 物化，是唯一写入授权。实现后 `frontend-verify-assess-shell` 合并 Mock/static/behavior/trace/assessment；只有 `eligible=true` 才运行同 writeSet 的 repair 和 `frontend-reverify-shell`。`frontend-review-context-shell` 绑定真实 diff 与有效验证证据后再 review/closeout。standard/high-risk 为 15 个顶层节点，small-risk 为 13；绿色路径执行 11 个节点、7 次 Pi。生成期 blocked Mock 只生成一个确定性阻塞节点且没有 writer。