@tea-agent/loop-agent 0.35.1-beta.4 → 0.35.2

package/AGENTS.md

@@ -94,8 +94,6 @@ npm run build
 node bin/loop-agent.js --help
 ```
 
-- 改 `src/**` 后必须先 `npm run build` 再用 `bin/loop-agent.js`：bin 内置 stale-dist 守卫（src 比 dist 新即硬失败，`--ignore-stale-dist` 逃生），`--version` 会显示构建 git SHA，发布/自测前用它确认跑的是目标改动。
-
 文档站变更：`npm run docs:build`。init / architecture / skill entry / pack 定向验证见 verification-matrix。
 
 ## 交接

package/CHANGELOG.md

@@ -1,38 +1,55 @@
 # 更新日志
 
-## [0.35.1-beta.4] - 2026-08-15
+## [Unreleased]
 
-> 观察面板规范证据不再单列 openspec：读取与检索统一为「规范已读取 / 规范检索」，空态文案同步中性化（beta，发布到 `beta` dist-tag）。
+## [0.35.2] - 2026-08-15
 
-## [0.35.1-beta.3] - 2026-08-14
+### 重点更新
 
-> frontend-implementation DAG 优化 v9 全六阶段 + Console 展示层（beta，发布到 `beta` dist-tag）。
+- Operator Chat 处理详情对齐 pi-web：回合尾部的思考内容与工具调用摘要切分为可折叠「处理详情」，流式中思考可见，回合结束后自动折叠，最终回答单独成气泡
 
-## [Unreleased]
+### 新增
+
+- 对话时间线新增内联可折叠「处理详情」区块，集中展示模型思考与工具调用摘要，回合结束后自动折叠
+- turn-process 保留 SDK thinking blocks，流式传输与持久化均携带思考内容
 
 ### 改进
 
-- DAG runner 捕获 SIGTERM/SIGINT：外层硬超时或监督层杀进程时，先把 run 写成 `failed` 终态（含 `terminalReason` 与 `finishedAt`）再退出，不再留 orphaned RUNNING；agent-worker 硬超时改为 SIGTERM→宽限 10s→SIGKILL 两级，给终态落盘留窗口
-- prewrite gate 失败结果新增机器可读 `failureCode`（如 `mock-strategy-outside-allowed`、`verdict-not-pass`、`contract-invalid` 等），失败场景强制非空，下游路由不再解析散文
-- plan 节点的契约自校验改为 `schemaId → validator` 注册表（`contract-output-registry`），新增契约无需改 executor；契约 schema 层新增深度 null 归一（`z.preprocess` 递归删 null），模型对可选字段吐 null 不再炸 strict schema，必填字段 null 仍以清晰 Required 报错
-- VERDICT 归一更宽容：`VERDICT:pass`（缺空格）、尾部句号/感叹号等漂移在节点级即归一，减少无谓的 protocol-invalid 重试
-- 构建写入 `dist/build-stamp.json`（git SHA + 时间），`loop-agent --version` 显示构建来源；`bin/loop-agent.js` 在源码树内运行且 dist 落后于 src 时硬失败（`--ignore-stale-dist` 逃生），杜绝「改了没生效」的陈旧产物事故
-
-- `frontend-implementation` DAG 删除冗余的 `frontend-contract-json-pi` 与 `frontend-contract-json-validate-shell` 两个节点，`frontend-prewrite-gate-shell` 直接消费 plan/revision 的 candidate JSON，成为 candidate → canonical 的唯一转换点（standard 17→15、small 15→13、green path 13→11 节点 / 8→7 Pi）
-- prewrite gate 新增 `frontend-prewrite-result-v1` 分类 artifact（accepted / accepted-normalized / retryable-invalid / blocked），blocked/retryable-invalid 先落 artifact 再以结构化结果返回
-- 新增两层 writer 前置门禁：scheduler admission + executeDagNode 运行前 guard，仅在 classification 为 accepted/accepted-normalized 时放行 writer，否则 SKIPPED + `frontend-prewrite-not-authorized`，writer provider 调用次数为 0
-- 终态聚合对 candidate-contract-invalid / prewrite-blocked 强制 `failed`，防止「prewrite FINISHED + writer SKIPPED」误判 partial_failed
-- 删除 contract-json 节点后，frozen command label 提醒与 requirement coverage 指令迁移进 `frontend-plan-pi` / `frontend-plan-revision-pi` 提示，模型侧引导不丢失
-- `frontend-repair.ts` 的失败分类从 nodeId/stdout/stderr 字符串启发式改为结构化证据（verificationTargetId / commandLabel → commandCategory / exitCode / traceRef / changedPaths），字符串匹配降级为兜底
-- `review` 失败不再默认可自动修复：只有 finding 同时具备明确文件、行或符号、requirement/AC 且修复范围 ⊆ writeSet、不需重新规划 contract 时才进入自动 repair，否则转人工
-- `frontendRepairAssessment` 扩展结构化证据字段（verificationTargetId / commandLabel / exitCode / commandCategory / requirementIds / acceptanceCriteriaIds / fixScope / changedPaths / traceRef），缺必要证据时不再判定 repairable
-- `frontend-implement-pi` 与 `frontend-repair-pi` 共享同一 prompt builder / contract loader / writeSet guard，仅 phase 与 baseline 不同
-- 新增 `frontend-recovery-state-v1` / `frontend-recovery-result-v1` 类型与 schema；prewrite 判定 retryable-invalid 时不再直接失败，改为 parent 先终态收敛、写 recovery intent（phase=child-staging）
-- 新增 candidate continuation：带 commit point 的 staged child 创建（staging 目录 + rename + activation marker + requestId 幂等）、facts import 与 reset closure，parent/child 以 recoveryRootRunId 归一到同一全链统计
-- scheduler 对 recovery child 施加 activation marker 门禁（无有效 marker 不可调度/执行），fail-closed；continuation 配额按 root 统一限制（至多一次）
-- 新增 writer transient rollback 基元（`frontend-writer-rollback.ts`）：writeSet 内容快照（existing files + allowed-new）、逐文件 CAS 恢复（current hash 与 attempt hash 一致才恢复，否则 auto-recovery-blocked，禁止 `git reset --hard`）、可恢复事务式 rollback journal（pending→restoring→completed|blocked，含崩溃恢复 hash/CAS 重判）
-- 接入 writer transient partial-write 自动恢复（`frontend-writer-recovery.ts`）：writer provider 调用前捕获 baseline 快照、调用后记录 attempt 变更；终态聚合时对 transient partial write 先 CAS 回滚、再写 recovery intent 并顺序创建 child（重跑 `frontend-implement-pi`，导入上游 facts）；回滚无法证明完整 → `auto-recovery-blocked`，不建 child
-- 新增 frontend recovery root manifest（`frontend-recovery-root-manifest-v1`）：全链按 `recoveryRootRunId` 去重统计（parent/child 不重复计），`recovered` 收敛为逻辑 `finished`；6 个 outcome（none/recovered/candidate-contract-invalid/prewrite-blocked/repair-exhausted/auto-recovery-blocked）映射到稳定 recovery CTA
+- 命令面板 shortcut 优化：Operator 组单行展示，/task、/contract、/dag 分别跳转到任务与恢复页面
+
+### 修复
+
+- 修复「处理详情」思考折叠块背景引用未定义样式变量 --panel 的问题，改为确定性透明背景，消除 Console 样式变量完整性门禁对发布的拦截（视觉无变化）
+- 移除自指的 /help 命令项：输入 / 已弹出命令面板，不再单独提供重复的帮助入口
+
+## [0.35.1] - 2026-08-15
+
+### 重点更新
+
+- taskKind 显式契约全链路生效：页面显式选择的任务类型（含「后端研发（默认 DAG）」= standard）不再被 intake 语义识别或 DAG 生成阶段的语义分类改写；taskKindExplicit 从 CLI 标志 → 语义草稿 → task.json → DAG 路由全链路透传，显式 standard 跳过语义分类且不回写 taskKind
+- Console 任务向导提交反馈：导入/访谈/契约等长动作点击后立即显示进度文案与按钮 spinner，消除数十秒无反馈的「页面卡死」观感；导入结果新增自动发现引用文档与未解析引用的透明提示
+- Console intake 链路修复：任务导航上传 PRD 三件套后契约落地不再因工程边界缺失卡死；semantic intake 在缺失型边界缺口时接管并基于仓库布局推荐 allowedPaths/verify；文字录入「请参照这三个prd路径…」自动发现并导入引用文档；新的 PRD 导入重置 semantic intake 一次性 marker，失败后可重试
+
+### 新增
+
+- PRD 引用自动发现：无上传文档时从文字录入内容中提取 Unicode 路径 token，经 URL 剥离、存在性/大小/排除过滤与角色推断后按角色自动导入引用文件，并透出自动导入与未解析引用结果
+- 任务向导长动作（bootstrap/import/interview/contract）点击后立即在 flash 区域显示动作进度文案（含全链路阶段说明与预期时长），结束时被结果消息覆盖
+- PRD 导入主按钮增加 busy 态 spinner、「导入中…」文案与 aria-busy，新增旋转动画样式
+- 导入结果渲染自动导入的引用文档（路径：角色）与未解析引用警告
+
+### 改进
+
+- semantic intake 资格判定拆分缺失型（工程边界/taskKind 缺失时允许模型按仓库布局推荐）与非法型（路径策略/安全/重叠等仍维持拒绝），回归其 repo-layout-aware fallback 的设计意图
+- semantic intake 提示词增补正式 AC 标题逐字复制指引
+- task advance 对模型未推荐边界场景增加 SEMANTIC_INTAKE_BOUNDARY_UNRESOLVED 可操作提示，明确告知用户当前状态
+
+### 修复
+
+- 修复 Console 显式选择的 taskKind 被丢弃的问题：此前「未选择」与「显式选 standard」被混为一谈，仅在非 standard 时传递任务类型标志，导致 AI 语义识别（如推荐 backend-test）覆盖用户选择、DAG 被改道
+- 修复 DAG 生成阶段对显式 standard 仍执行语义分类并回写 taskKind 的问题：显式信息此前在契约落盘时丢失，现显式指定时跳过语义分类且不回写
+- 修复 PRD 三件套上传时工程边界缺失以 EMPTY_ALLOWED_PATHS blocking 卡死、semantic intake 拒绝接管、契约永不 apply 的问题
+- 修复文字录入「请参照这三个prd路径XXX」只物化一句话、引用文件从未导入的问题
+- 修复 semantic intake attempt marker 一次性失败后永不重试的问题：新的 PRD 导入会重置 marker，失败可随新证据重试
 
 ## [0.35.0] - 2026-08-13
 

package/bin/loop-agent.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { existsSync, readdirSync, statSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
@@ -13,42 +13,6 @@ if (!existsSync(cliEntry)) {
   process.exit(1);
 }
 
-/**
- * Stale-dist guard: when running from a source checkout (src/ present), refuse
- * to silently execute a dist/ that predates the latest source edit. The
- * classic failure mode is editing src/** and running the bin without
- * `npm run build`, which executes the previous build. Suppress with
- * --ignore-stale-dist when intentionally running a stale build.
- */
-const srcDir = join(packageRoot, "src");
-const ignoreStale = process.argv.includes("--ignore-stale-dist");
-if (ignoreStale) {
-  process.argv = process.argv.filter((arg) => arg !== "--ignore-stale-dist");
-}
-if (!ignoreStale && existsSync(srcDir)) {
-  const distCliMtime = statSync(cliEntry).mtimeMs;
-  let newestSrcMtime = 0;
-  const walk = (dir) => {
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-      const full = join(dir, entry.name);
-      if (entry.isDirectory()) {
-        walk(full);
-      } else {
-        const mtime = statSync(full).mtimeMs;
-        if (mtime > newestSrcMtime) newestSrcMtime = mtime;
-      }
-    }
-  };
-  walk(srcDir);
-  if (newestSrcMtime > distCliMtime) {
-    console.error(
-      `loop-agent: dist/ is stale relative to src/ (a source file is newer than ${cliEntry}).\n` +
-        `  Run \`npm run build\` before using the bin, or pass --ignore-stale-dist to run the stale build intentionally.`,
-    );
-    process.exit(1);
-  }
-}
-
 try {
   await import(pathToFileURL(cliEntry).href);
 } catch (error) {

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

@@ -308,7 +308,10 @@ export async function generateTaskDagUseCase(input) {
     if (hasAutomaticTaskSourceRoute &&
         candidateResult.template === "frontend-implementation") {
         const taskConfig = await loadTaskConfig(repoRoot, parsed.taskId);
-        if (!taskConfig.taskKind || taskConfig.taskKind === "standard") {
+        // Human-explicit taskKind (incl. explicit standard) is a hard contract:
+        // never rewrite task.json taskKind via semantic classification.
+        if (!taskConfig.taskKindExplicit &&
+            (!taskConfig.taskKind || taskConfig.taskKind === "standard")) {
             await writeTaskConfig(repoRoot, parsed.taskId, {
                 ...taskConfig,
                 taskKind: "frontend-implementation",

package/dist/application/task-lifecycle/advance.js

@@ -627,6 +627,7 @@ export async function advanceTaskLifecycle(input) {
                 flags: {
                     title: input.title,
                     taskKind: input.taskKind,
+                    taskKindExplicit: input.taskKindExplicit,
                     featureId: input.featureId,
                     allowedPaths: effectiveInput.allowedPaths,
                     forbiddenPaths: input.forbiddenPaths,
@@ -681,6 +682,7 @@ export async function advanceTaskLifecycle(input) {
                             flags: {
                                 title: input.title,
                                 taskKind: input.taskKind,
+                                taskKindExplicit: input.taskKindExplicit,
                                 featureId: input.featureId,
                                 allowedPaths: effectiveInput.allowedPaths,
                                 forbiddenPaths: input.forbiddenPaths,
@@ -700,6 +702,7 @@ export async function advanceTaskLifecycle(input) {
                                 flags: {
                                     title: input.title,
                                     taskKind: input.taskKind,
+                                    taskKindExplicit: input.taskKindExplicit,
                                     featureId: input.featureId,
                                     allowedPaths: effectiveInput.allowedPaths,
                                     forbiddenPaths: input.forbiddenPaths,
@@ -762,6 +765,17 @@ export async function advanceTaskLifecycle(input) {
                         message: prepareResult.error?.message ??
                             "PRD imported but intake incomplete; DAG not generated",
                     });
+                    // B2: semantic intake ran but the model declined to recommend an
+                    // engineering boundary — surface an actionable hint instead of a
+                    // bare EMPTY_ALLOWED_PATHS so the Console operator knows the fix.
+                    const gapCodesNow = new Set((prepareResult.gaps ?? []).map((gap) => gap.code));
+                    if (semanticIntakeAttemptedThisCall &&
+                        gapCodesNow.has("EMPTY_ALLOWED_PATHS")) {
+                        warnings.push({
+                            code: "SEMANTIC_INTAKE_BOUNDARY_UNRESOLVED",
+                            message: "semantic intake structured the requirement but no engineering boundary was recommended; fill allowedPaths in the Console wizard (工程边界) or pass --allowed-path",
+                        });
+                    }
                     for (const gap of prepareResult.gaps ?? []) {
                         if (gap.level === "blocking") {
                             warnings.push({ code: gap.code, message: gap.message });

package/dist/cli/program.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
-import { readCliVersionLabel } from "../shared/package-metadata.js";
+import { readPackageVersion } from "../shared/package-metadata.js";
 import { resolveAdapter } from "../adapters/index.js";
 import { runCoverageAudit } from "../commands/coverage-audit.js";
 import { runCoverageReport } from "../commands/coverage-report.js";
@@ -547,7 +547,7 @@ export function buildLoopAgentProgram(options) {
     program
         .name("loop-agent")
         .description("Loop Agent task and DAG automation CLI")
-        .version(readCliVersionLabel(path.dirname(path.dirname(path.dirname(fileURLToPath(import.meta.url))))) ?? "0.0.0", "-V, --version", "display version")
+        .version(readPackageVersion(path.dirname(path.dirname(path.dirname(fileURLToPath(import.meta.url))))) ?? "0.0.0", "-V, --version", "display version")
         .showHelpAfterError()
         .option("--repo-root <path>", "repository root")
         .option("--adapter <name>", "harness adapter name")

package/dist/commands/task-advance.js

@@ -252,6 +252,7 @@ function toUseCaseInput(repoRoot, taskId, options) {
         fromText: options.fromText,
         fromDraftPath: options.fromDraft,
         taskKind: options.taskKind,
+        taskKindExplicit: Boolean(options.taskKind?.trim()),
         featureId: options.featureId,
         allowedPaths: options.allowedPaths,
         forbiddenPaths: options.forbiddenPaths,

package/dist/executors/dag-pi-executor.js

@@ -520,33 +520,6 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
     }
     let result;
     try {
-        // Phase 5 (P1-9): capture the writeSet baseline BEFORE the writer provider
-        // call so a transient partial write can be rolled back and recovered via a
-        // staged child. Only frontend-implementation writers; a failed capture is a
-        // hard fail (no baseline → no rollback → no recovery). Dynamic import avoids
-        // an executor ↔ scheduler static cycle.
-        if (isWriteTask &&
-            (input.task.id === "frontend-implement-pi" ||
-                input.task.id === "frontend-repair-pi") &&
-            (input.task.writeSet?.length ?? 0) > 0) {
-            try {
-                const { captureFrontendWriterAttemptIntent } = await import("../workflows/dag/frontend-writer-recovery.js");
-                await captureFrontendWriterAttemptIntent({
-                    cwd: input.cwd,
-                    runDir: meta.runDir,
-                    writeSet: input.task.writeSet,
-                });
-            }
-            catch (error) {
-                return {
-                    ok: false,
-                    stdout: "",
-                    stderr: `frontend writer attempt baseline capture failed: ${error instanceof Error ? error.message : String(error)}`,
-                    failureCategory: "write-guard",
-                    durationMs: Date.now() - started,
-                };
-            }
-        }
         result = await piStepFn({
             attachedFiles: [],
             modelConfig: resolveDagPiModelConfig(input.model, input.thinking ? { thinking: input.thinking } : undefined),
@@ -718,23 +691,6 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
             const changedFiles = pathsChangedDuringRun(snapshotGitStatusPorcelain(beforeStatus), afterSnapshot, beforePathFingerprints, afterPathFingerprints);
             changeManifestAfterStatus = afterStatus;
             changeManifestChangedFiles = changedFiles;
-            // Phase 5: record the attempt changed paths/hashes into the rollback
-            // intent so a transient partial write can be CAS-restored.
-            if ((input.task.id === "frontend-implement-pi" ||
-                input.task.id === "frontend-repair-pi") &&
-                (input.task.writeSet?.length ?? 0) > 0) {
-                try {
-                    const { recordFrontendWriterAttempt } = await import("../workflows/dag/frontend-writer-recovery.js");
-                    await recordFrontendWriterAttempt({
-                        cwd: input.cwd,
-                        runDir: meta.runDir,
-                        changedPaths: changedFiles,
-                    });
-                }
-                catch {
-                    // best-effort: a missing intent (no baseline captured) is a no-op
-                }
-            }
             const guard = validateShellWriteGuardFromDiff({
                 changedFiles,
                 task: input.task,

package/dist/shared/package-metadata.js

@@ -45,48 +45,6 @@ export function readPackageName(packageDir) {
     }
     return undefined;
 }
-/**
- * Read the build stamp (git SHA + build time) written by the build pipeline
- * into `<packageDir>/dist/build-stamp.json`. `undefined` when absent (e.g.
- * running from source via tsx, or a hand-assembled package), which callers
- * treat as "no stamp available".
- */
-export function readBuildStamp(packageDir) {
-    try {
-        const raw = readFileSync(path.join(packageDir, "dist", "build-stamp.json"), "utf-8");
-        const parsed = JSON.parse(raw);
-        if (parsed.schemaVersion !== 1 ||
-            typeof parsed.version !== "string" ||
-            typeof parsed.builtAt !== "string")
-            return undefined;
-        return parsed;
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Human-readable CLI version label: plain version, enriched with the build
- * stamp (short git SHA + build date) when available so a stale dist/ that was
- * built from an old commit is immediately recognizable in `--version`.
- */
-export function readCliVersionLabel(packageDir) {
-    const version = readPackageVersion(packageDir) ?? "0.0.0";
-    const stamp = readBuildStamp(packageDir);
-    if (!stamp?.gitSha)
-        return version;
-    return `${version} (build ${stamp.gitSha.slice(0, 8)} ${stamp.builtAt.slice(0, 10)})`;
-}
-/**
- * Strip the build-stamp suffix from a CLI `--version` label, returning the bare
- * SemVer. Controller-identity/preflight comparisons must use this rather than
- * the raw label so a build-stamped `0.35.0 (build 7f8c5b5b …)` still matches
- * `packageVersion === "0.35.0"`.
- */
-export function normalizeCliVersionLabel(label) {
-    const match = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?/.exec(label.trim());
-    return match ? match[0] : label.trim();
-}
 /**
  * Compute the SHA-256 hash of a file on disk.
  *

package/dist/task/config-types.js

@@ -118,6 +118,8 @@ const taskConfigObjectSchema = z.object({
     sourceFiles: z.array(z.string()),
     /** standard: 本仓库需求实现；feature-study: 参考外部代码特性并在目标仓库落地；frontend-implementation: 前端实现 DAG；backend-test: 后端测试 DAG；knowledge-sync: 最终验证后回写测试知识库 DAG；knowledge-graph-bootstrap: AI 辅助业务知识图谱初始化 */
     taskKind: taskKindSchema.optional().default("standard"),
+    /** true = taskKind 由人类显式选择（含显式 standard）；DAG 路由必须尊重，不做语义改写。 */
+    taskKindExplicit: z.boolean().optional(),
     /** Feature 目录 id（如 F-2026-004）。knowledge-sync 必填（也可从 hardConstraints/需求正文/taskId 解析）；用于收窄 writeSet */
     featureId: z.string().min(1).optional(),
     referenceRepos: z.array(referenceRepoConfigSchema).optional().default([]),

package/dist/task/contract/project.js

@@ -152,6 +152,9 @@ export function mergeManagedTaskConfigFields(existing, draft) {
         ...existing,
         title: draft.title,
         taskKind: draft.taskKind,
+        ...(draft.taskKindExplicit !== undefined
+            ? { taskKindExplicit: draft.taskKindExplicit }
+            : {}),
         allowedPaths: canonicalizePathArray(draft.constraints.allowedPaths),
         ...(draft.constraints.allowedRoots !== undefined
             ? { allowedRoots: canonicalizePathArray(draft.constraints.allowedRoots) }

package/dist/task/contract/schema.js

@@ -57,6 +57,7 @@ export const taskContractDraftSchema = z
     taskId: z.string().min(1),
     title: z.string().min(1),
     taskKind: taskKindSchema,
+    taskKindExplicit: z.boolean().optional(),
     featureId: z.string().min(1).optional(),
     requirement: taskContractDraftRequirementSchema,
     constraints: taskContractDraftConstraintsSchema,

package/dist/task/source-prepare/build-draft.js

@@ -17,6 +17,11 @@ function resolveTaskKind(flags, baseDraft, existing) {
     const parsed = taskKindSchema.safeParse(candidate);
     return parsed.success ? parsed.data : String(candidate);
 }
+function resolveTaskKindExplicit(flags, baseDraft) {
+    if (flags.taskKindExplicit !== undefined)
+        return flags.taskKindExplicit;
+    return baseDraft?.taskKindExplicit ?? false;
+}
 function resolveTitle(taskId, flags, facts, baseDraft, existing) {
     return (trimNonEmpty(flags.title) ??
         trimNonEmpty(baseDraft?.title) ??
@@ -105,6 +110,7 @@ export function buildPrepareDraft(input) {
     const { taskId, existingTaskConfig, baseDraft, facts, flags, references } = input;
     const title = resolveTitle(taskId, flags, facts, baseDraft, existingTaskConfig);
     const taskKind = resolveTaskKind(flags, baseDraft, existingTaskConfig);
+    const taskKindExplicit = resolveTaskKindExplicit(flags, baseDraft);
     const featureId = trimNonEmpty(flags.featureId) ??
         trimNonEmpty(baseDraft?.featureId) ??
         trimNonEmpty(existingTaskConfig?.featureId) ??
@@ -170,6 +176,7 @@ export function buildPrepareDraft(input) {
         taskId,
         title,
         taskKind: taskKind,
+        taskKindExplicit,
         requirement: {
             objective,
             scope,

package/dist/task/source-prepare/semantic-intake.js

@@ -7,7 +7,7 @@
  * optional model recommendation (repo-layout-aware fallback for Console
  * web-wizard flows that never collect human paths).
  */
-import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readdir, readFile, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
 import { executePiStep } from "../../executors/pi-executor.js";
@@ -92,31 +92,39 @@ export function evaluateSemanticIntakeEligibility(input) {
             };
         }
     }
-    // Engineering-only gaps are not fixed by semantic intake.
-    const onlyEngineering = blocking.length > 0 &&
-        blocking.every((g) => g.code === "EMPTY_ALLOWED_PATHS" ||
-            g.code === "EMPTY_TASK_KIND" ||
-            g.code === "MISSING_FEATURE_ID" ||
+    // Invalid-value engineering gaps are NOT fixed by semantic intake (the
+    // model cannot repair a rejected path policy or an illegal overlap).
+    // Missing-value engineering gaps (EMPTY_ALLOWED_PATHS / EMPTY_TASK_KIND)
+    // ARE the documented Console web-wizard case: the wizard never collects
+    // human paths, so the repo-layout-aware model recommendation is the
+    // designed fallback (see module header). Keep them eligible.
+    const invalidEngineering = blocking.length > 0 &&
+        blocking.every((g) => g.code === "MISSING_FEATURE_ID" ||
             g.code === "PATH_POLICY" ||
             g.code.startsWith("UNSAFE_") ||
             g.code === "ALLOWED_FORBIDDEN_OVERLAP");
-    if (onlyEngineering) {
+    if (invalidEngineering) {
         return {
             eligible: false,
-            reason: "only engineering boundary gaps; provide --allowed-path / flags",
+            reason: "engineering boundary gaps carry invalid values; fix the flags/paths",
         };
     }
     const structural = codes.has("SEMANTIC_INTAKE_RECOMMENDED") ||
         blockingCodes.has("EMPTY_ACCEPTANCE") ||
         blockingCodes.has("EMPTY_OBJECTIVE") ||
-        blockingCodes.has("NO_PARSEABLE_REQUIREMENT");
+        blockingCodes.has("NO_PARSEABLE_REQUIREMENT") ||
+        blockingCodes.has("EMPTY_ALLOWED_PATHS") ||
+        blockingCodes.has("EMPTY_TASK_KIND");
     if (!structural && !input.force) {
         return {
             eligible: false,
             reason: "no structural requirement gaps for semantic intake",
         };
     }
-    return { eligible: true, reason: "structural intake gaps with imported sources" };
+    return {
+        eligible: true,
+        reason: "structural or engineering-boundary gaps with imported sources",
+    };
 }
 export function extractJsonObject(text) {
     const fenced = /```(?:json)?\s*([\s\S]*?)```/iu.exec(text);
@@ -206,6 +214,9 @@ export function buildDraftFromSemanticIntake(input) {
         taskId: input.taskId,
         title: input.semantic.title?.trim() || input.title,
         taskKind,
+        ...(explicitTaskKind || input.flags.taskKindExplicit
+            ? { taskKindExplicit: true }
+            : {}),
         requirement: {
             objective: input.semantic.objective.trim(),
             scope: input.semantic.scope.map((s) => s.trim()).filter(Boolean),
@@ -374,6 +385,7 @@ async function buildPrompt(input) {
         "Prefer smallest correct write boundary; do not invent product paths that are not in the layout hint.",
         "Do NOT rewrite or suggest editing the original PRD files.",
         "Prefer explicit text; use provenance derived for rephrasing; use inferred only when clearly implied — if you must invent ACs, leave acceptanceCriteria empty so the system can stop for clarification.",
+        "When documents embed formal AC headings (e.g. #### AC-FE-001 …), copy each AC verbatim under the SAME id with provenance explicit; do not rephrase or renumber them.",
         "Return exactly one JSON object, no markdown prose outside optional fence:",
         JSON.stringify({
             title: "optional string",
@@ -416,6 +428,21 @@ export async function readSemanticIntakeAttempted(repoRoot, taskId) {
         return false;
     }
 }
+/**
+ * C: a new PRD import is new evidence — clear the one-shot attempt marker
+ * so semantic intake may run again for the refreshed sources.
+ */
+export async function clearSemanticIntakeAttempt(repoRoot, taskId) {
+    const paths = getTaskPaths(repoRoot, taskId);
+    const marker = path.join(paths.taskDir, SEMANTIC_INTAKE_ATTEMPT_MARKER);
+    try {
+        await unlink(marker);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 async function writeAttemptMarker(repoRoot, taskId, payload) {
     const paths = getTaskPaths(repoRoot, taskId);
     const dir = path.join(paths.taskDir, "artifacts", "intake");

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

@@ -402,6 +402,16 @@ export function resolveTaskDagTemplateSelection(input) {
             reasons: [],
         };
     }
+    // Human-explicit standard (e.g. Console 后端研发默认 DAG) is a hard
+    // contract: semantic task-source classification must not rewrite it to a
+    // specialized template (which would also rewrite task.json taskKind).
+    if (input.taskKindExplicit) {
+        return {
+            template: requestedTemplate,
+            source: "taskKind",
+            reasons: ["taskKind standard was explicitly selected by human; semantic classification skipped"],
+        };
+    }
     const classification = classifyTaskDemand(input);
     if (classification.kind === "frontend") {
         const frontendSignals = classification.signals

package/dist/worker/console/chat/assistant-content.js

@@ -0,0 +1,110 @@
+/**
+ * Assistant content-block helpers shared by Pi event mapping and Operator Chat UI.
+ * Mirrors pi-web `lib/message-display.ts` (process vs answer split) without deferred fetch.
+ */
+function asRecord(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    return value;
+}
+function readString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+/** Parse a persisted/SSE content array; unknown shapes are dropped. */
+export function parseAssistantContent(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const blocks = [];
+    for (const item of value) {
+        const rec = asRecord(item);
+        if (!rec)
+            continue;
+        const type = readString(rec.type) ?? "";
+        if (type === "thinking" || type === "reasoning") {
+            const thinking = readString(rec.thinking) ?? readString(rec.text) ?? "";
+            blocks.push({ type: "thinking", thinking });
+            continue;
+        }
+        if (type === "toolCall" ||
+            type === "tool_call" ||
+            type === "toolUse" ||
+            type === "tool_use") {
+            const toolCallId = readString(rec.toolCallId) ?? readString(rec.id) ?? "";
+            if (!toolCallId)
+                continue;
+            const toolName = readString(rec.toolName) ?? readString(rec.name);
+            blocks.push({
+                type: "toolCall",
+                toolCallId,
+                ...(toolName ? { toolName } : {}),
+            });
+            continue;
+        }
+        if (type === "text" || type === "output_text" || type === "") {
+            const text = readString(rec.text);
+            if (text !== undefined)
+                blocks.push({ type: "text", text });
+        }
+    }
+    return blocks;
+}
+/**
+ * Extract ordered assistant content blocks from a Pi SDK message object.
+ * Thinking/reasoning blocks keep their own type so they never leak into answer text.
+ */
+export function extractAssistantContentBlocks(message) {
+    const rec = asRecord(message);
+    if (!rec)
+        return [];
+    const contents = Array.isArray(rec.content) ? rec.content : [];
+    const parts = Array.isArray(rec.parts) ? rec.parts : [];
+    const fromArrays = parseAssistantContent([...contents, ...parts]) ?? [];
+    if (fromArrays.length > 0)
+        return fromArrays;
+    const top = readString(rec.text);
+    return top ? [{ type: "text", text: top }] : [];
+}
+/**
+ * Latest assistant answer text (text blocks only). Thinking is excluded.
+ * Preserves the historical `{ text }` / `{ parts: [{ text }] }` fallbacks.
+ */
+export function extractAssistantText(message) {
+    return extractAssistantContentBlocks(message)
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join("");
+}
+export function isEmptyThinkingBlock(block, options = {}) {
+    return (block.type === "thinking" &&
+        !options.isStreaming &&
+        block.thinking.trim() === "");
+}
+export function getDisplayableAssistantBlocks(blocks, options = {}) {
+    return blocks.filter((block) => !isEmptyThinkingBlock(block, options));
+}
+function isFinalAnswerBlock(block) {
+    return block.type === "text";
+}
+export function splitFinalAssistantBlocks(blocks, options = {}) {
+    const displayable = getDisplayableAssistantBlocks(blocks, options);
+    let lastProcessIndex = -1;
+    for (let i = displayable.length - 1; i >= 0; i--) {
+        if (!isFinalAnswerBlock(displayable[i])) {
+            lastProcessIndex = i;
+            break;
+        }
+    }
+    if (lastProcessIndex === -1) {
+        return { answerBlocks: displayable, processBlocks: [] };
+    }
+    return {
+        answerBlocks: displayable.slice(lastProcessIndex + 1),
+        processBlocks: displayable.slice(0, lastProcessIndex + 1),
+    };
+}
+export function joinAssistantText(blocks) {
+    return blocks
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join("");
+}