@tea-agent/loop-agent 0.24.4-beta.0 → 0.24.4

package/AGENTS.md

@@ -64,13 +64,21 @@
 
 ## 验证
 
-权威源：`docs/governance/verification-matrix.md`。常用：
+权威源：`docs/governance/verification-matrix.md`。
+
+默认节奏：编辑中只跑矩阵「最低验证」（typecheck + 定向 Vitest）；`git commit` 的 `pre-commit` 只做 `check-repo`；`git push` 的 `pre-push` 跑 `bash scripts/ci.sh`（全量 typecheck + `npm test`）。每个 clone 安装一次 hooks：`bash scripts/install-git-hooks.sh`。
+
+常用：
 
 ```bash
-npm run typecheck && npm test && npm run build
-node bin/loop-agent.js --help
-bash scripts/check-repo.sh
+# 编辑中
+npm run typecheck
+npx vitest run <相关测试路径>
+
+# push / 交付前（或依赖 pre-push）
 bash scripts/ci.sh
+npm run build
+node bin/loop-agent.js --help
 ```
 
 文档站变更：`npm run docs:build`。init / architecture / skill entry / pack 定向验证见 verification-matrix。

package/CHANGELOG.md

@@ -2,10 +2,30 @@
 
 ## [Unreleased]
 
+## [0.24.4] - 2026-07-28
+
+### 重点更新
+
+- 控制台「导入需求」支持多文件批量导入，自动合成可编辑正文后创建任务
+- 后端测试移除重复运行稳定性门槛，每次执行同时生成用户可读的 HTML 与 Markdown 报告
+- 本地 pre-push 钩子升级为执行完整 CI 流程，覆盖治理检查、类型检查与全量测试
+
+### 新增
+
+- 控制台「导入需求」支持选择或拖入一份或多份 Markdown/TXT 文档（严格 UTF-8，单文件 ≤8 MiB，最多 8 个），多文件分卷归档并合成可编辑正文后创建任务
+
 ### 改进
 
+- 后端测试 L-5 结论不再将重复运行稳定性作为门槛，每次执行同时产出用户可读的 HTML 与 Markdown 报告，内部 facts 文件保留用于审计
+- 本地 pre-push 钩子改为执行完整 CI 流程（治理检查 + 类型检查 + 全量测试），pre-commit 保持仅执行 check-repo
+- harness 中等复杂度（MED）模型调整为 grok-4.5，并同步对齐相关 smoke/init 断言
+- 归档已完成的设计文档与执行计划，刷新 0.24.x 六个月规划与能力摘要，并同步验证与 hooks 文档
+
+## [0.24.3] - 2026-07-28
+
+### 重点更新
+
 - 发布工作流改为发布已通过完整门禁并经 SHA-256 校验的 npm tarball，避免 `npm publish` 再次触发全量测试、类型检查与构建。
-- 默认 `standard` 实现任务在 React、Next.js 或 Vue 项目中直接选择 `frontend-implementation` DAG，不再依赖需求关键词；明确后端、文档/测试范围或前端否定仍保留对应通用流程。
 
 ## [0.24.2] - 2026-07-28
 

package/dist/application/dag/generate-task-dag.js

@@ -239,8 +239,10 @@ export async function generateTaskDagUseCase(input) {
         reasons: ["dag run-task validate did not report governanceProfile"],
     });
     const hasExplicitSpecializedTaskKind = candidateResult.templateSelection.source === "taskKind";
-    const hasAutomaticTaskSourceRoute = candidateResult.templateSelection.source === "task-source";
-    if (hasExplicitSpecializedTaskKind || hasAutomaticTaskSourceRoute) {
+    const hasSafeAutomaticTaskSourceRoute = candidateResult.templateSelection.source === "task-source" &&
+        profileRouting.selectedByProfile !== "supervised" &&
+        profileRouting.selectedTemplate !== "supervised-implementation";
+    if (hasExplicitSpecializedTaskKind || hasSafeAutomaticTaskSourceRoute) {
         profileRouting.selectedTemplate = candidateResult.template;
         profileRouting.source = hasExplicitSpecializedTaskKind
             ? "taskKind"
@@ -254,9 +256,10 @@ export async function generateTaskDagUseCase(input) {
             profileRouting.selectedByProfile = parsed.profile;
         }
     }
-    // Persist the automatic business workflow route while preserving the
-    // governance profile as a separate routing dimension.
-    if (hasAutomaticTaskSourceRoute && candidateResult.template === "frontend-implementation") {
+    // Persist only a safe automatic route. Explicit supervised/profile policy
+    // must remain authoritative and must not be weakened by this convenience
+    // marker. Keep taskId stable; frontend-implementation is the taskKind.
+    if (hasSafeAutomaticTaskSourceRoute && candidateResult.template === "frontend-implementation") {
         const taskConfig = await loadTaskConfig(repoRoot, parsed.taskId);
         if (!taskConfig.taskKind || taskConfig.taskKind === "standard") {
             await writeTaskConfig(repoRoot, parsed.taskId, {

package/dist/commands/init.js

@@ -2049,11 +2049,11 @@ function buildTargetFeatureWorkflow(input) {
         "",
         "## Specialized Task Kinds",
         "",
-        "- standard tasks first use the structured task type in `source/需求.md`, then combine `allowedPaths` with strong React/Next/Vue project evidence for deterministic routing.",
-        "- A frontend project defaults eligible implementation work to the frontend DAG without requirement keyword matching. Explicit backend, mixed, frontend-negated, and documentation/test-only scopes 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 selects the frontend implementation workflow and persists taskKind; explicit profiles, workflowPolicy, and supervised quality gates record governance strength without switching the business workflow back to a generic DAG.",
+        "- Automatic frontend classification never replaces a supervised template selected by an explicit profile, workflowPolicy, or the supervised quality gate.",
         "- A backend implementation does not select the backend test DAG. `backend-test` remains an explicit test-engineering workflow.",
         "- Explicit specialized `taskKind` values remain compatible and take precedence over task-source classification.",
         "",

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

@@ -298,11 +298,6 @@ export function classifyTaskDemand(input) {
             message: "allowedPaths include a backend-specific source path",
         });
     }
-    const allowedPathsOnlyCoverNonProductArtifacts = input.allowedPaths.length > 0 &&
-        input.allowedPaths.every((rawPath) => {
-            const allowedPath = normalizedAllowedPath(rawPath);
-            return matchesAny(allowedPath, NON_PRODUCT_ALLOWED_PATH_PATTERNS);
-        });
     const pathSupportedFrontendDelivery = frontendPath &&
         (titleSignals.pathSupportedFrontendDelivery ||
             requirementSignals.pathSupportedFrontendDelivery ||
@@ -333,27 +328,20 @@ export function classifyTaskDemand(input) {
             message: "task text contains user-visible interaction/state delivery and the project has strong frontend framework evidence",
         });
     }
-    const backendDelivery = titleSignals.backendDelivery || requirementSignals.backendDelivery;
-    const frontendProjectDefaultImplementation = hasStrongFrontendProjectEvidence &&
-        !backendDelivery &&
-        !frontendNegated &&
-        !allowedPathsOnlyCoverNonProductArtifacts;
-    if (frontendProjectDefaultImplementation) {
-        addSignal(signals, {
-            id: "frontend-project-default-implementation",
-            source: "project",
-            message: "frontend project evidence selects the frontend implementation workflow by default",
-        });
-    }
     const frontendDelivery = titleSignals.frontendDelivery ||
         requirementSignals.frontendDelivery ||
         pathSupportedFrontendDelivery ||
-        projectSupportedFrontendDelivery ||
-        frontendProjectDefaultImplementation;
+        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)
@@ -414,6 +402,13 @@ export function resolveTaskDagTemplateSelection(input) {
             reasons: [],
         };
     }
+    if (requestedTemplate !== "standard-dag") {
+        return {
+            template: requestedTemplate,
+            source: "requested-template",
+            reasons: [],
+        };
+    }
     const classification = classifyTaskDemand(input);
     if (classification.kind === "frontend") {
         const frontendSignals = classification.signals
@@ -428,14 +423,6 @@ export function resolveTaskDagTemplateSelection(input) {
             classification,
         };
     }
-    if (requestedTemplate !== "standard-dag") {
-        return {
-            template: requestedTemplate,
-            source: "requested-template",
-            reasons: [],
-            classification,
-        };
-    }
     return {
         template: requestedTemplate,
         source: "requested-template",

package/dist/worker/console/operator-actions.js

@@ -1490,9 +1490,14 @@ async function allocateUniqueTaskId(repoRoot, preferredId) {
 }
 async function dispatchBootstrapFromPrd(ctx, p) {
     const content = str(p.content) ?? str(p.fileText);
-    if (!content) {
+    if (!content?.trim()) {
         return invalid("bootstrapFromPrd", "content is required");
     }
+    const parsedDocs = parseBootstrapDocuments(p.documents);
+    if (!parsedDocs.ok) {
+        return invalid("bootstrapFromPrd", parsedDocs.message);
+    }
+    const documents = parsedDocs.documents;
     const taskKind = normalizeConsoleWorkflowKind(str(p.taskKind), "standard");
     const identity = deriveTaskIdentityFromPrd(content);
     let taskId;
@@ -1539,28 +1544,86 @@ async function dispatchBootstrapFromPrd(ctx, p) {
             }),
         };
     }
-    const staged = await stageUtf8Text(ctx.appData, content, {
-        extension: ".md",
-    });
-    const imported = await run(["import-prd", taskId, "--file", staged.path, "--json"], {
-        cwd: ctx.repoRoot,
-        artifactName: "bootstrap-import-prd",
-        expectJson: true,
-        timeoutMs: 60_000,
-    });
-    if (!imported.ok || imported.exitCode !== 0) {
-        return {
-            kind: "error",
-            status: 400,
-            body: operatorFailed({
-                command: "bootstrapFromPrd",
-                outcome: "rejected",
-                code: "INTERNAL_ERROR",
-                message: imported.stderr?.trim() ||
-                    `import-prd failed with exit ${imported.exitCode}`,
-                details: { exitCode: imported.exitCode, taskId },
-            }),
-        };
+    const succeededImports = [];
+    const importResults = [];
+    const runImportPrd = async (label, text, name) => {
+        const staged = await stageUtf8Text(ctx.appData, text, {
+            extension: ".md",
+        });
+        const imported = await run([
+            "import-prd",
+            taskId,
+            "--file",
+            staged.path,
+            "--name",
+            name,
+            "--role",
+            "requirement",
+            "--json",
+        ], {
+            cwd: ctx.repoRoot,
+            artifactName: `bootstrap-import-prd-${label}`,
+            expectJson: true,
+            timeoutMs: 60_000,
+        });
+        if (!imported.ok || imported.exitCode !== 0) {
+            return {
+                kind: "error",
+                status: 400,
+                body: operatorFailed({
+                    command: "bootstrapFromPrd",
+                    outcome: "rejected",
+                    code: "INTERNAL_ERROR",
+                    message: imported.stderr?.trim() ||
+                        `import-prd failed for "${name}" with exit ${imported.exitCode}. 任务已创建但不完整，请用 CLI 补 import-prd 或换 taskId 重试。`,
+                    details: {
+                        exitCode: imported.exitCode,
+                        taskId,
+                        failedName: name,
+                        succeededImports: [...succeededImports],
+                    },
+                }),
+            };
+        }
+        succeededImports.push(name);
+        importResults.push(imported.json ?? null);
+        return null;
+    };
+    if (documents && documents.length > 0) {
+        for (const doc of documents) {
+            const failure = await runImportPrd(doc.name, doc.content, doc.name);
+            if (failure)
+                return failure;
+        }
+        const composedFailure = await runImportPrd("composed", content, "composed");
+        if (composedFailure)
+            return composedFailure;
+    }
+    else {
+        const staged = await stageUtf8Text(ctx.appData, content, {
+            extension: ".md",
+        });
+        const imported = await run(["import-prd", taskId, "--file", staged.path, "--json"], {
+            cwd: ctx.repoRoot,
+            artifactName: "bootstrap-import-prd",
+            expectJson: true,
+            timeoutMs: 60_000,
+        });
+        if (!imported.ok || imported.exitCode !== 0) {
+            return {
+                kind: "error",
+                status: 400,
+                body: operatorFailed({
+                    command: "bootstrapFromPrd",
+                    outcome: "rejected",
+                    code: "INTERNAL_ERROR",
+                    message: imported.stderr?.trim() ||
+                        `import-prd failed with exit ${imported.exitCode}`,
+                    details: { exitCode: imported.exitCode, taskId },
+                }),
+            };
+        }
+        importResults.push(imported.json ?? null);
     }
     const draftSaved = await ctx.drafts.save({
         ...emptyDraft(taskId, title, { taskKind }),
@@ -1578,10 +1641,58 @@ async function dispatchBootstrapFromPrd(ctx, p) {
             identitySource: identity.source,
             preferredTaskId: identity.taskId,
             draftSha256: draftSaved.draftSha256,
-            import: imported.json ?? null,
+            import: importResults.length === 1 ? importResults[0] : null,
+            imports: importResults,
+            documentNames: documents && documents.length > 0
+                ? [...documents.map((d) => d.name), "composed"]
+                : undefined,
         }),
     };
 }
+const MAX_BOOTSTRAP_DOCUMENTS = 8;
+function parseBootstrapDocuments(raw) {
+    if (raw === undefined || raw === null) {
+        return { ok: true, documents: null };
+    }
+    if (!Array.isArray(raw)) {
+        return { ok: false, message: "documents must be an array" };
+    }
+    if (raw.length === 0) {
+        return { ok: true, documents: null };
+    }
+    if (raw.length > MAX_BOOTSTRAP_DOCUMENTS) {
+        return {
+            ok: false,
+            message: `documents supports at most ${MAX_BOOTSTRAP_DOCUMENTS} entries`,
+        };
+    }
+    const documents = [];
+    for (let i = 0; i < raw.length; i += 1) {
+        const entry = raw[i];
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+            return { ok: false, message: `documents[${i}] must be an object` };
+        }
+        const rec = entry;
+        const name = str(rec.name)?.trim();
+        const content = str(rec.content);
+        const fileName = str(rec.fileName)?.trim();
+        if (!name) {
+            return { ok: false, message: `documents[${i}].name is required` };
+        }
+        if (!content?.trim()) {
+            return {
+                ok: false,
+                message: `documents[${i}].content is required`,
+            };
+        }
+        documents.push({
+            name,
+            content,
+            ...(fileName ? { fileName } : {}),
+        });
+    }
+    return { ok: true, documents };
+}
 async function ensureDraft(ctx, taskId, title, options) {
     const existing = await ctx.drafts.get(taskId);
     if (existing) {