@tea-agent/loop-agent 0.24.0 → 0.24.1

package/CHANGELOG.md

@@ -2,6 +2,49 @@
 
 ## [Unreleased]
 
+### 改进
+
+- 夜间自动发布固定为 patch 通道（当前 `0.x.y` 上 +0.0.1，例如 `0.24.1 -> 0.24.2`），不再因 `feat:` 自动跳到 `0.x.0`。
+- 新增人工主版本工作流 `manual-minor-release.yml`，仅在显式触发时强制 bump minor，产出 `v0.x.0`。
+- 发布通道可将文档版本钉死/漂移降为告警（`LOOP_AGENT_DOC_VERSION_REFS=warn`），避免 nightly/prepublish 被安装文档旧精确串误阻塞；结构性文档治理仍 fail-closed。
+
+### 修复
+
+- 发布流程不再被合法的旧版本引用误阻塞：文档 catalog 现可用 `current`/`floating`/`minimum`/`range`/`historical` 五类语义声明版本引用，审查时基线等历史证据保留当时真实精确版本并通过检查，仅当前安装入口的精确钉死仍判为漂移。
+- Nightly Release 现在在版本号与 CHANGELOG 准备完成之后、push/打 tag/发布 npm/创建 GitHub Release 之前运行最终 release tree 门禁（测试、构建、仓库治理、`npm pack` 干跑），避免在未通过最终门禁的发布树产生远端副作用。
+- Nightly Release 的 commit/tag、npm publish、GitHub Release 三步现支持幂等恢复：重跑时探测目标对象是否存在，一致则跳过、冲突则 fail closed（不 force-push、不重写 tag、不重复发布），可补齐半发布状态。
+- 文档版本治理的 `minimum`/`range` 声明现会校验文档正文实际出现的精确版本串与声明门槛/范围一致；仅元数据通过而正文钉死低于门槛或不满足范围的版本时仍判失败，避免安装入口借 minimum/range 声明悄悄钉死旧版本。
+
+## [0.24.1] - 2026-07-27
+
+### 重点更新
+
+- 后端测试 HTML 报告全面升级，采用更清晰的可折叠用例卡片设计，直观展示脱敏的请求与响应详情。
+- 彻底修复了 Windows 环境下因 cmd.exe 与 bash 嵌套引号转义不当，导致前端与初始化测试固件执行失败的问题。
+- 前端实现 DAG 大幅优化，复用现有 run-owned canonical artifacts，有效精简了常规全绿路径的直接依赖节点数量。
+
+### 新增
+
+- 后端测试第 7 节点现使用 pytest-html 生成自包含报告，并新增解析器从其 JSON island 提取每条用例的结果与日志。
+- 后端测试生成的 pytest 文件名现可与 Markdown 模块建立一对一清晰映射。
+
+### 改进
+
+- 后端测试 HTML 报告对齐 R04 模板样式：改用全 inline style 设计，包含渐变 banner、可折叠用例卡片、状态胶囊以及请求参数与响应结果分块展示。
+- 前端 canonical implementation contract 允许纯逻辑修改使用空的 UI state，不再强制虚构，并会确定性移除不适用状态下的空输出。
+- 前端实现 DAG 的多个节点（如 frontend-implement-pi、frontend-review-pi 等）直接依赖得到收敛，不再重复读取完整任务源或上游冗余文本。
+
+### 修复
+
+- 修复后端测试 HTML 报告中请求参数显示为空的问题：渲染器现已兼容 payload= 键或 JSON request_record 格式的请求摘要。
+- 修复后端测试报告无法获取请求/响应日志的问题：兼容 HTTP_REQUEST 与 HTTP REQUEST 两种日志前缀，并在解析前正确解码 HTML 实体。
+- 修复 shell-executor 在 Windows 环境下因反斜杠路径导致 runDir 损坏的问题，确保路径注入稳定。
+- 修复前端 worktree baseline 解析 git status 时因提前 trim 导致未暂存文件路径丢失首字符的解析缺陷。
+- 统一 DAG 任务源路径生成与运行时解析基准，解决 freshness、rerun 与预览共享不一致的问题。
+- 修复前端项目在需求未显式提及 UI 时被误判保留为标准任务的问题，提升了基于工程证据与交互语义的任务类型推断准确度。
+- 修复前端 lint baseline 在 Windows 下因路径解析逻辑缺陷，拒绝相对路径输出导致评估误报为不可用的问题。
+- 修复多个测试固件在 Windows 下因嵌套 Shell 引号剥离导致命令执行输出为空或报错的问题（涉及 composite-shell 与 init-command）。
+
 ## [0.24.0] - 2026-07-27
 
 ### 新增

package/dist/commands/init.js

@@ -2049,8 +2049,8 @@ function buildTargetFeatureWorkflow(input) {
         "",
         "## Specialized Task Kinds",
         "",
-        "- standard tasks are classified conservatively from the task title, `source/需求.md`, and structured `allowedPaths`.",
-        "- Only high-confidence frontend implementation demands select the frontend DAG automatically; backend, mixed, negated, and unknown demands keep the template selected by the normal governance profile.",
+        "- standard tasks are classified conservatively by combining the task title, `source/需求.md`, structured `allowedPaths`, strong React/Next/Vue project evidence, and user-visible interaction/state semantics.",
+        "- An implicit frontend demand selects the frontend DAG only when project or frontend-path evidence is paired with product-delivery semantics; framework evidence alone is insufficient. Backend, mixed, negated, documentation/test maintenance, and unknown demands keep the template selected by the normal governance profile.",
         "- `frontend-mock-assess-pi` reads Mock/API/schema evidence and selects `native|browser-intercept|request-adapter|not-needed|blocked` before frontend planning; its deterministic gate rejects blocked or malformed output, while the existing frontend implementer remains the only writer.",
         "- Mock-backed verification never proves real API integration. When the backend was not exercised, closeout must retain the gap and name `<task-id>-real-api-integration-verify`; that follow-up is explicitly created/run after backend readiness, never automatic.",
         "- Automatic frontend classification never replaces a supervised template selected by an explicit profile, workflowPolicy, or the supervised quality gate.",

package/dist/task/dag-source-paths.js

@@ -0,0 +1,50 @@
+import path from "node:path";
+import { getTaskPaths } from "./runtime.js";
+function toPosixPath(filePath) {
+    return filePath.replaceAll(path.sep, "/");
+}
+function isOutside(basePath, candidatePath) {
+    const relative = path.relative(basePath, candidatePath);
+    return (relative === ".." ||
+        relative.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(relative));
+}
+/**
+ * Serialize a task source path for DAG prompts and source bindings.
+ *
+ * Production generation always supplies repoRoot, so emitted paths are
+ * directly readable from the DAG executor's repository-root cwd. The
+ * task-relative fallback is retained only for in-memory builders/tests that
+ * intentionally do not have a repository root.
+ */
+export function serializeDagTaskSourcePath(input) {
+    const sourceRoot = path.resolve(input.taskDir, "source");
+    const basePath = path.resolve(input.repoRoot ?? input.taskDir);
+    const absolutePath = path.resolve(input.absolutePath);
+    if (absolutePath === sourceRoot ||
+        isOutside(sourceRoot, absolutePath) ||
+        isOutside(basePath, absolutePath)) {
+        throw new Error(`task source path is outside the current task source directory: ${input.absolutePath}`);
+    }
+    return toPosixPath(path.relative(basePath, absolutePath));
+}
+/**
+ * Resolve both current repository-relative bindings and legacy task-relative
+ * bindings, then require the result to remain inside the bound task's source
+ * directory. This is the single runtime path interpretation for DAG sources.
+ */
+export function resolveDagTaskSourcePath(input) {
+    if (path.isAbsolute(input.sourcePath)) {
+        throw new Error(`absolute DAG task source path is forbidden: ${input.sourcePath}`);
+    }
+    const taskPaths = getTaskPaths(input.workspaceRoot, input.taskId);
+    const nativeSourcePath = input.sourcePath.replaceAll("/", path.sep);
+    const absolutePath = input.sourcePath.startsWith(".harness/")
+        ? path.resolve(input.workspaceRoot, nativeSourcePath)
+        : path.resolve(taskPaths.taskDir, nativeSourcePath);
+    const sourceRoot = path.resolve(taskPaths.sourceDir);
+    if (absolutePath === sourceRoot || isOutside(sourceRoot, absolutePath)) {
+        throw new Error(`DAG task source path is outside task ${input.taskId} source directory: ${input.sourcePath}`);
+    }
+    return absolutePath;
+}

package/dist/task/frontend-project-capability.js

@@ -0,0 +1,316 @@
+/**
+ * Generation-time frontend project capability discovery (M5/M6).
+ * Strong evidence only: package.json deps, config files, source imports.
+ * Lockfile-only or directory-name-only must NOT activate adapters.
+ */
+import { readFile, readdir, stat } from "node:fs/promises";
+import path from "node:path";
+import { OPENSPEC_SPEC_DIRS, OPENSPEC_SPEC_EXT_RE } from "../shared/openspec-spec.js";
+async function exists(filePath) {
+    try {
+        await stat(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readJson(filePath) {
+    try {
+        return JSON.parse(await readFile(filePath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function allDeps(pkg) {
+    return {
+        ...(pkg.dependencies ?? {}),
+        ...(pkg.devDependencies ?? {}),
+        ...(pkg.peerDependencies ?? {}),
+    };
+}
+function hasDep(deps, name) {
+    return Object.hasOwn(deps, name);
+}
+async function listOpenspec(repoRoot) {
+    const out = [];
+    for (const specDir of OPENSPEC_SPEC_DIRS) {
+        const root = path.join(repoRoot, specDir);
+        if (!(await exists(root)))
+            continue;
+        await walk(root, 0);
+    }
+    return out.slice(0, 40);
+    async function walk(dir, depth) {
+        if (depth > 4)
+            return;
+        let entries = [];
+        try {
+            entries = await readdir(dir);
+        }
+        catch {
+            return;
+        }
+        for (const name of entries) {
+            const full = path.join(dir, name);
+            try {
+                const info = await stat(full);
+                if (info.isDirectory())
+                    await walk(full, depth + 1);
+                else if (OPENSPEC_SPEC_EXT_RE.test(name)) {
+                    out.push(path.relative(repoRoot, full).replace(/\\/g, "/"));
+                }
+            }
+            catch {
+                // skip
+            }
+        }
+    }
+}
+export function buildAdapterGuidance(capability) {
+    const lines = [
+        "## Frontend project capability (generation-time)",
+        `Framework: ${capability.framework}${capability.frameworkVersion ? `@${capability.frameworkVersion}` : ""}`,
+        `Evidence: ${capability.evidencePaths.join(", ") || "(none)"}`,
+        "Rules: openspec specs and task sources outrank adapter tips; do not invent APIs for unknown versions; lockfile-only is not enough.",
+    ];
+    if (capability.framework === "react") {
+        lines.push("React adapter: prefer function components + hooks; reuse existing Testing Library / Vitest patterns; do not introduce new state libs without authorization.");
+    }
+    else if (capability.framework === "next") {
+        lines.push("Next.js adapter: respect App vs Pages router from evidence; keep server/client boundaries explicit; avoid guessing cache/navigation APIs across major versions.");
+    }
+    else if (capability.framework === "vue") {
+        lines.push("Vue adapter: prefer Composition API if project already uses it; reuse Pinia/Vue Router/Vue Query only when evidenced; Vitest + Vue Test Utils when present.");
+    }
+    else {
+        lines.push("Unknown framework: use generic frontend-implementation skill only; do not assume React/Vue/Next APIs.");
+    }
+    if (capability.a11y.status === "present") {
+        lines.push(`A11y tools present: ${capability.a11y.tools.join(", ")}. Report static/component-level evidence only; Browser a11y remains not-run.`);
+    }
+    else {
+        lines.push("A11y tools: absent/unknown — mark a11y checks unavailable/not-run; do not install tools.");
+    }
+    if (capability.designEvidence.normativePaths.length) {
+        lines.push(`Normative design paths: ${capability.designEvidence.normativePaths.slice(0, 8).join(", ")}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Discover frontend project capability from repo root.
+ * Strong evidence: package.json direct deps + config/bootstrap files.
+ */
+export async function discoverFrontendProjectCapability(repoRoot) {
+    const evidencePaths = [];
+    const reasons = [];
+    const pkgPath = path.join(repoRoot, "package.json");
+    const pkgRaw = await readJson(pkgPath);
+    if (!pkgRaw || typeof pkgRaw !== "object") {
+        const openspec = await listOpenspec(repoRoot);
+        const base = {
+            schemaVersion: 1,
+            framework: "unknown",
+            state: [],
+            dataFetching: [],
+            componentLibrary: [],
+            style: [],
+            testRunner: [],
+            mock: [],
+            a11y: { status: "unknown", tools: [], evidencePaths: [] },
+            evidencePaths: openspec.slice(0, 5),
+            reasons: ["package.json missing or unreadable"],
+            designEvidence: {
+                normativePaths: openspec,
+                advisoryPaths: [],
+                conflicts: [],
+            },
+        };
+        if (openspec.length) {
+            base.reasons.push(`openspec spec files discovered: ${openspec.slice(0, 5).join(", ")}`);
+        }
+        return { ...base, adapterGuidance: buildAdapterGuidance(base) };
+    }
+    evidencePaths.push("package.json");
+    const deps = allDeps(pkgRaw);
+    // Lockfile alone does not activate
+    for (const lock of ["package-lock.json", "pnpm-lock.yaml", "yarn.lock"]) {
+        if (await exists(path.join(repoRoot, lock))) {
+            reasons.push(`${lock} present but not used as sole activation evidence`);
+        }
+    }
+    let framework = "unknown";
+    let frameworkVersion;
+    const configHits = [];
+    const nextConfig = ["next.config.js", "next.config.mjs", "next.config.ts"];
+    for (const name of nextConfig) {
+        if (await exists(path.join(repoRoot, name))) {
+            configHits.push(name);
+            evidencePaths.push(name);
+        }
+    }
+    if (hasDep(deps, "next") && configHits.some((c) => c.startsWith("next"))) {
+        framework = "next";
+        frameworkVersion = deps.next?.replace(/^[^\d]*/, "");
+        reasons.push("next dependency + next.config*");
+    }
+    else if (hasDep(deps, "next") && configHits.length === 0) {
+        // dep without config: still weak if only transitive — require direct dep
+        framework = "next";
+        frameworkVersion = deps.next?.replace(/^[^\d]*/, "");
+        reasons.push("next direct dependency (config not found)");
+        evidencePaths.push("package.json#dependencies.next");
+    }
+    if (framework === "unknown") {
+        const vueConfig = ["vite.config.ts", "vite.config.js", "vue.config.js"];
+        let vueCfg = false;
+        for (const name of vueConfig) {
+            if (await exists(path.join(repoRoot, name))) {
+                vueCfg = true;
+                evidencePaths.push(name);
+            }
+        }
+        if (hasDep(deps, "vue") && (vueCfg || hasDep(deps, "nuxt"))) {
+            framework = "vue";
+            frameworkVersion = deps.vue?.replace(/^[^\d]*/, "");
+            reasons.push("vue direct dependency + config/tooling");
+        }
+    }
+    if (framework === "unknown" && hasDep(deps, "react")) {
+        // Need config or jsx tooling — not lockfile-only
+        const reactCfg = (await exists(path.join(repoRoot, "vite.config.ts"))) ||
+            (await exists(path.join(repoRoot, "vite.config.js"))) ||
+            (await exists(path.join(repoRoot, "webpack.config.js"))) ||
+            hasDep(deps, "react-scripts") ||
+            hasDep(deps, "vite");
+        if (reactCfg) {
+            framework = "react";
+            frameworkVersion = deps.react?.replace(/^[^\d]*/, "");
+            reasons.push("react direct dependency + bundler/tooling evidence");
+            evidencePaths.push("package.json#dependencies.react");
+        }
+        else {
+            reasons.push("react listed but no strong config/bundler evidence — framework=unknown");
+        }
+    }
+    const state = [];
+    for (const lib of [
+        "redux",
+        "@reduxjs/toolkit",
+        "zustand",
+        "jotai",
+        "recoil",
+        "pinia",
+        "vuex",
+    ]) {
+        if (hasDep(deps, lib))
+            state.push(lib);
+    }
+    const dataFetching = [];
+    for (const lib of [
+        "@tanstack/react-query",
+        "swr",
+        "axios",
+        "@tanstack/vue-query",
+        "ofetch",
+    ]) {
+        if (hasDep(deps, lib))
+            dataFetching.push(lib);
+    }
+    const componentLibrary = [];
+    for (const lib of [
+        "antd",
+        "@mui/material",
+        "element-plus",
+        "vuetify",
+        "@chakra-ui/react",
+    ]) {
+        if (hasDep(deps, lib))
+            componentLibrary.push(lib);
+    }
+    const style = [];
+    for (const lib of [
+        "tailwindcss",
+        "sass",
+        "less",
+        "styled-components",
+        "@emotion/react",
+    ]) {
+        if (hasDep(deps, lib))
+            style.push(lib);
+    }
+    const testRunner = [];
+    for (const lib of [
+        "vitest",
+        "jest",
+        "@testing-library/react",
+        "@testing-library/vue",
+        "@playwright/test",
+    ]) {
+        if (hasDep(deps, lib))
+            testRunner.push(lib);
+    }
+    const mock = [];
+    for (const lib of ["msw", "nock", "miragejs"]) {
+        if (hasDep(deps, lib))
+            mock.push(lib);
+    }
+    const a11yTools = [];
+    const a11yEvidence = [];
+    for (const lib of [
+        "eslint-plugin-jsx-a11y",
+        "@axe-core/react",
+        "jest-axe",
+        "vitest-axe",
+        "axe-core",
+    ]) {
+        if (hasDep(deps, lib)) {
+            a11yTools.push(lib);
+            a11yEvidence.push(`package.json#${lib}`);
+        }
+    }
+    const a11y = {
+        status: (a11yTools.length > 0 ? "present" : "absent"),
+        tools: a11yTools,
+        evidencePaths: a11yEvidence,
+    };
+    let router;
+    if (hasDep(deps, "react-router-dom") || hasDep(deps, "react-router")) {
+        router = "react-router";
+    }
+    if (framework === "next")
+        router = router ?? "next-router";
+    if (hasDep(deps, "vue-router"))
+        router = "vue-router";
+    const openspec = await listOpenspec(repoRoot);
+    const designEvidence = {
+        normativePaths: openspec,
+        advisoryPaths: [],
+        conflicts: [],
+    };
+    if (openspec.length)
+        evidencePaths.push(...openspec.slice(0, 5));
+    const base = {
+        schemaVersion: 1,
+        framework,
+        frameworkVersion,
+        router,
+        state,
+        dataFetching,
+        componentLibrary,
+        style,
+        testRunner,
+        mock,
+        a11y,
+        packageManager: (await exists(path.join(repoRoot, "pnpm-lock.yaml")))
+            ? "pnpm"
+            : (await exists(path.join(repoRoot, "yarn.lock")))
+                ? "yarn"
+                : "npm",
+        evidencePaths: [...new Set(evidencePaths)],
+        reasons,
+        designEvidence,
+    };
+    return { ...base, adapterGuidance: buildAdapterGuidance(base) };
+}