dsh-plugin-teamflow 0.1.3 → 0.1.5

package/CHANGELOG.md

@@ -2,6 +2,38 @@
 
 > 本插件首次公开发布版本为 **v0.1.0**；发布前的内部迭代（v0.3~v0.13）记录于 `AGENTS.md` §5，对外统一归到 v0.1.0。
 
+## [0.1.5] - 2026-09-01
+
+### 新增
+- **patch 档兑现「单 agent 直改 + 自测即交付」**：阶段集精简为确认单 → 单 agent 直改（2 段，无技术方案/QA/验收），开发完成（自测通过）即统一收口提交。UI 微调（按钮换位置/挪控件/改文案/间距/颜色）、常量调整、单点修复、回滚、笔误修正走最轻路径
+
+### 改进
+- **需求分诊重构为模型主导**：档位判断交给模型（自然语言语义，天然双语）；正则收窄为确定性护栏（架构信号强升/UI 不低于轻量档/显式设计升档）。UI 微调类需求（不改变行为/交互逻辑）不再误判标准档
+- **分诊输出失败自动纠错重试**：只输出开场白无 JSON 时带提示重试一次，仍失败才走正则兜底
+
+### 修复
+- **外部中止（aborted）不再误报「预算熔断」**：重启等外部中止单独标记，明确引导断点续跑（补跑失败任务，已完成任务复用）
+- **patch 档不再误跑架构蓝图**（技术方案块补 `enabled('tech')` 门控）
+- **分支名不再被档位词污染**（「显式的用 patch 模式」不再产出 `feat/patch`）
+- **provider 错误细节记录**（阶段失败记录底层错误信息）
+
+## [0.1.4] - 2026-08-29
+
+### 修复
+- **分支决策死循环**：用户确认「新建分支」后重发启动参数仍会再次弹出分支决策（干净工作区场景）。修复：决策选项增加显式确认值，自定义分支名/工作区处理参数均视为已确认
+- **护栏误杀大文件任务**：大文件「读-改-读-改」是正常模式（每次修改后必须重读确认），可能被误判为推理复读而中止。修复：复读判定升级为状态判定——有实际修改进展时不中止，仅纯复读（零进展）才中止
+- **QA/验收只读任务不再被误杀**：执行测试脚本视为进展信号，只读分析任务（不做文件修改）不再被复读检测误伤
+- **退化中止不再自动重试**：真退化（推理复读死循环）后自动重试大概率在污染会话内复现且持续烧钱——改为直接需人工介入，引导 `teamflow_resume`（全新会话续跑）
+- **断点续跑尊重未闭环的 QA 缺陷**：阻断缺陷仍 open 时 resume 回到 QA 修复-复验闭环，不再带着已知缺陷直接进产品验收；验收失败过的 run 同样正确回 QA
+- **历史失败记录保留**：resume 不再清除失败的阶段记录（审计可追溯）
+
+### 新增
+- **提测门禁**：开发阶段有任务失败（哪怕 1 个）→ 需人工介入，不再自动进入 QA（失败任务是已知缺口，QA 检查必然重复报告）；resume 精确补跑失败任务（已完成任务产物复用，不重跑）
+- **README 界面预览**：5 张真实工作台截图（流水线视图/看板/阶段详情/看板任务详情/团队选择）
+
+### 其他
+- pnpm-lockfile 同步（依赖调整后 CI 的 frozen-lockfile 校验失败，已修复）
+
 ## [0.1.3] - 2026-08-29
 
 ### 新增

package/README.en.md

@@ -18,6 +18,28 @@ requirement → PRD (based on existing patterns / product memory, archived to pr
             → product acceptance (update product memory)
 ```
 
+## Screenshots
+
+1. Pipeline view — stage serpentine lanes + node cards (status / duration / tokens / subagent session)
+
+   ![Pipeline view](docs/screenshots/pipeline-view.png)
+
+2. Backlog board — draggable lanes for requirements / tasks / defects
+
+   ![Backlog board](docs/screenshots/board.png)
+
+3. Stage detail drawer — full stage artifacts + token breakdown + "🎬 jump to subagent session"
+
+   ![Stage detail](docs/screenshots/stage-detail.png)
+
+4. Board task detail — task-card drawer (requirement text / assignments / event timeline / subtasks / defects / tokens)
+
+   ![Board task detail](docs/screenshots/board-task-detail.png)
+
+5. Team selector — 🏭 button + team dropdown
+
+   ![Team selector](docs/screenshots/team-selector.png)
+
 ## Core Features
 
 - **Anti-fake-delivery**: ① Substantive validation — outputs containing rejection phrases ("I cannot complete", etc.) or below the per-stage length floor are treated as undelivered and routed to retry / human intervention; ② Token circuit breaker — a single stage accumulating 60k budget stops retries; ③ Context-exhaustion failures are not retried (retrying the same prompt likely reproduces); ④ Product-level concurrency lock — only one active pipeline per product at a time, preventing requirement state from stepping on itself; ⑤ Full stage outputs are retained (memory + disk) for the detail drawer and checkpoint resume.

package/README.md

@@ -18,6 +18,28 @@ TeamFlow 团队研发流水线 —— DeepSeek Harness 可分发插件（`dsh pl
      → 产品验收（更新产品记忆）
 ```
 
+## 界面预览
+
+1. 流水线视图——阶段蛇形泳道 + 节点卡片（状态/耗时/token/子代理会话）
+
+   ![流水线视图](docs/screenshots/pipeline-view.png)
+
+2. Backlog 看板——需求/任务/缺陷拖拽泳道
+
+   ![Backlog 看板](docs/screenshots/board.png)
+
+3. 阶段详情抽屉——阶段性产物全文 + token 明细 +「🎬 跳转子代理会话」
+
+   ![阶段详情](docs/screenshots/stage-detail.png)
+
+4. 看板任务详情——任务卡抽屉（需求原文/分配/事件时间线/子卡/缺陷/token）
+
+   ![看板任务详情](docs/screenshots/board-task-detail.png)
+
+5. 团队选择——🏭 按钮 + 团队下拉
+
+   ![团队选择](docs/screenshots/team-selector.png)
+
 ## 核心特性
 
 - **防假交付**：① 实质校验——拒绝措辞（"我无法完成"等）或低于阶段长度下限的输出视为未交付，走重试/需人工；② token 熔断——单阶段累计 60k 预算，超限停止重试；③ 上下文耗尽类失败不重试（重试同一 prompt 大概率复现）；④ 产品级并发锁——同一产品同时只允许一条活跃流水线，防需求状态互踩；⑤ 阶段产物全文保留（内存 + 磁盘，供详情抽屉与断点续跑读取）。

package/lib/host.mjs

@@ -157,9 +157,7 @@ const STAGE_POLICY = {
 			key: "scaffold",
 			when: (o) => !!o.needScaffold
 		},
-		{ key: "tech" },
-		{ key: "dev" },
-		{ key: "acceptance" }
+		{ key: "dev" }
 	]
 };
 /** 按档位 + 条件展开实际执行阶段集（纯函数；未知档回退 full）。 */
@@ -266,7 +264,24 @@ function deriveBranchSlug(requirement, reqId, triageSlug, branchName) {
 	if (branchName && /^[a-z0-9][a-z0-9-_]*$/i.test(branchName)) return String(branchName).replace(/[^a-z0-9-]/gi, "-").toLowerCase().slice(0, 40);
 	if (triageSlug && /^[a-z0-9-]{3,24}$/i.test(triageSlug)) return triageSlug;
 	const en = String(requirement || "").match(/[a-zA-Z][a-zA-Z0-9-]{2,23}/g);
-	if (en && en.length) return en[0].toLowerCase().slice(0, 40);
+	if (en && en.length) {
+		const NOISE = /* @__PURE__ */ new Set([
+			"patch",
+			"lite",
+			"tech",
+			"full",
+			"medium",
+			"mode",
+			"the",
+			"and",
+			"for",
+			"with",
+			"use",
+			"using"
+		]);
+		const hit = en.find((w) => !NOISE.has(w.toLowerCase()));
+		if (hit) return hit.toLowerCase().slice(0, 40);
+	}
 	const num = String(reqId || "").match(/\d+/);
 	if (num) return `r${num[0]}`;
 	return "feature";
@@ -971,6 +986,17 @@ function verifyReqBugs(journal) {
 	}
 	if (touched) store.persist();
 }
+/** 该需求是否存在未闭环的阻断缺陷（P0/P1/P2 仍 open）——resume 断点定位与 QA 复用判定依赖。
+* 实锤 run tf-mte906e9：QA 修复子代理失败 → run failed，但 QA 阶段本身 done（缺陷已登记），
+* 旧 interruptedPhaseOf 直接定位产品验收 → 带缺陷代码进验收。
+* ⚠️ store key 与 resumeRun/storeFor 解析一致（workspace || product || default），否则查错 store 误判无缺陷。 */
+function hasOpenBlockingBugs(journal) {
+	try {
+		return storeFor(journal.workspace || journal.product || "default").bugs.some((b) => b.reqId === journal.reqId && b.status === "open" && b.severity !== "P3");
+	} catch (e) {
+		return false;
+	}
+}
 /** 默认团队配置文件内容。 */
 const DEFAULT_TEAMS_FILE = {
 	version: 1,
@@ -1195,16 +1221,25 @@ function totalTokensOf(usage) {
 *    的健康节奏工作到第 25 分钟被击落（tf-mt8fbavd dev 尝试一）。
 *
 * 设计原则：【只看进度信号，无任何时间配额】慢吞吐的合法任务永远不该被打断：
-*  A. 复读检测：滑动窗口内同一规范化流式片段出现 ≥ GUARD_REPEAT_LIMIT 次（逐字复读 = 真退化）
-*     → outcome='degenerated'（豁免预算门，允许一次干净重试）。
+*  A. 复读检测：滑动窗口内同一规范化流式片段出现 ≥ GUARD_REPEAT_LIMIT 次，且窗口内零变更进展
+*     （无 edit/write 等写操作）→ 真退化（纯推理打转）→ outcome='degenerated'（豁免预算门，允许一次干净重试）。
+*     ⚠️ 状态判定（实锤 run tf-mte906e9）：大文件 read-edit 循环是正常模式——模型反复 read 同一大文件
+*     （每次 edit 后内容已变，必须重读确认）、输出高度相似的「读后分析」，逐字片段在 400 条窗口内
+*     可累积 ≥12 次——伴随 edit/write 变更调用时只记录观察，不中止（否则大文件修改任务全被误杀）。
 *  B. 挂死检测：连续 GUARD_SILENCE_MS 一个新事件都没有（provider 层挂起/连接静默死亡）
 *     → outcome='stalled'（走正常预算门 → 熔断转人工，不自动重试烧钱）。
 *  C. 空转检测：会话仍在产出事件，但连续 GUARD_NO_TOOL_MS 没有任何工具调用
 *    （纯推理打转/改写式循环；正常 agent 每分钟都在调工具）→ outcome='stalled'。
+*    兜底关系：复读判定放宽后，edit 后陷入死循环的漏网场景由 C（长时间无工具调用）兜住。
 *
 * 中止方式：run.dispose() → run.result 结算。outcome 命名刻意避开 isUnretryable 的
 * /token|context|limit/ 正则；只有 'degenerated' 享受干净重试豁免（runner.withRetry）。
 */
+/** 进展工具（复读状态判定）：变更类写操作 + 脚本执行。
+* 「有进展」= 大文件 read-edit 循环（dev）或只读分析任务的 read+跑脚本循环（QA/验收）均属正常模式；
+* 纯 read 循环（反复整读同一文件却无变更/无脚本执行）= 真退化。实锤 run tf-mte906e9：QA 重跑
+* 只读分析（不 edit）→ 旧判定「零变更进展」误杀，第 2 次 provider error 后 450k 熔断。 */
+const PROGRESS_TOOLS = /^(edit|write|create|apply_patch|patch|remove|delete|rm|mkdir|move|rename|append|bash|pwsh|shell|powershell)$/i;
 /** 与 metering 同款事件访问器（session.events 可能是数组或返回数组的函数）。 */
 function eventsOf(run) {
 	const local = run && run.localAgent;
@@ -1267,6 +1302,8 @@ function startStageGuard(opts) {
 	const warnedReads = /* @__PURE__ */ new Set();
 	const scriptCounts = /* @__PURE__ */ new Map();
 	const warnedScripts = /* @__PURE__ */ new Set();
+	let lastMutationAt = 0;
+	let repeatWarned = false;
 	function warnOnce(key, set, message, hint) {
 		if (set.has(key)) return;
 		set.add(key);
@@ -1323,8 +1360,21 @@ function startStageGuard(opts) {
 				const counts = /* @__PURE__ */ new Map();
 				for (const w of window) counts.set(w, (counts.get(w) || 0) + 1);
 				for (const [, n] of counts) if (n >= 12) {
-					fire(`推理复读（同一片段在近 ${window.length} 条流式片段中出现 ${n} 次）`, "degenerated");
-					return;
+					if (lastMutationAt > 0) {
+						if (!repeatWarned) {
+							repeatWarned = true;
+							try {
+								journal.logs.push({
+									t: Date.now(),
+									level: "warn",
+									message: `${label} 复读计数达阈值但检测到变更进展（read-edit 循环属正常模式），不中止；仅零变更进展的纯复读才中止`
+								});
+							} catch (e) {}
+						}
+					} else {
+						fire(`推理复读（同一片段在近 ${window.length} 条流式片段中出现 ${n} 次，且窗口内零变更进展）`, "degenerated");
+						return;
+					}
 				}
 				observeToolCalls(newEvents);
 				if (newEvents.some((ev) => ev?.type === "step/end")) flushReminders(run);
@@ -1332,9 +1382,12 @@ function startStageGuard(opts) {
 			}
 			for (const ev of events.slice(-200)) {
 				const e = ev;
-				if (e && (e.type === "tool-call-chunks" || e.type === "tool/call")) {
+				if (!e) continue;
+				if (e.type === "tool-call-chunks" || e.type === "tool/call") {
 					seenToolCall = true;
 					lastToolSignalAt = Date.now();
+					const d = e.data || e;
+					if (d && typeof d.name === "string" && PROGRESS_TOOLS.test(d.name)) lastMutationAt = Date.now();
 					break;
 				}
 			}
@@ -1531,6 +1584,7 @@ async function runAgent(journal, parent, label, phase, prompt, signal) {
 		}
 		stage.status = "failed";
 		stage.outcome = stop === "completed" && text ? "insubstantial" : stop || "error";
+		const errDetail = result && result.error;
 		if (stage.outcome === "insubstantial") {
 			stage.summary = "产出未通过实质校验（含拒绝措辞或内容过短），视为未交付";
 			journal.logs.push({
@@ -1539,11 +1593,11 @@ async function runAgent(journal, parent, label, phase, prompt, signal) {
 				message: `${label} 产出未通过实质校验（拒绝措辞/内容过短）`
 			});
 		} else {
-			stage.summary = `未产出有效结果（stopReason=${stop || "unknown"}）`;
+			stage.summary = `未产出有效结果（stopReason=${stop || "unknown"}${errDetail ? `，error=${String(errDetail).slice(0, 200)}` : ""}）`;
 			journal.logs.push({
 				t: Date.now(),
 				level: "error",
-				message: `${label} 未产出有效结果（stopReason=${stop || "unknown"}）`
+				message: `${label} ${stage.summary}`
 			});
 		}
 		return null;
@@ -1605,7 +1659,33 @@ async function withRetry(journal, parent, label, phase, prompt, signal) {
 				stageTokens
 			};
 		}
-		if (!!!(lastStage && lastStage.outcome === "degenerated") && stageTokens >= 6e4) {
+		if (lastStage && lastStage.outcome === "aborted") {
+			journal.logs.push({
+				t: Date.now(),
+				level: "warn",
+				message: `${label} 被外部中止（aborted），未正常产出——非预算问题；可 teamflow_resume 续跑（补跑失败任务，已完成任务复用）`
+			});
+			journal.humanIntervention = true;
+			return {
+				text: null,
+				attempts,
+				stageTokens
+			};
+		}
+		if (lastStage && lastStage.outcome === "degenerated") {
+			journal.logs.push({
+				t: Date.now(),
+				level: "warn",
+				message: `${label} 进行中护栏中止（退化/推理复读），不再自动重试（污染会话内重试大概率复现且烧钱）；可 teamflow_resume 以全新会话续跑`
+			});
+			journal.humanIntervention = true;
+			return {
+				text: null,
+				attempts,
+				stageTokens
+			};
+		}
+		if (stageTokens >= 6e4) {
 			journal.logs.push({
 				t: Date.now(),
 				level: "error",
@@ -2117,8 +2197,8 @@ ${vision ? "[Visual re-check] If QA saved screenshots under the task folder, spo
 5. Chinese Markdown.
 6. [State] End with a state block (phase="acceptance"), summary = acceptance conclusion, verdict = "accepted/rework/reject/needs-human", extra.done = confirmation of this delivery.${STATE_BLOCK_INSTRUCTION}`;
 /** 需求分诊模型 prompt（模型驱动 triage；供 core/triage.runTriage 使用）。 */
-const TRIAGE_PROMPT = (requirement, opts, pre) => `You are a senior research-dev triage analyst. Do ONE thing: analyze which pipeline mode this dev requirement fits, then give the conclusion. No code, no scope speculation.
-[RAW REQUIREMENT]
+const TRIAGE_PROMPT = (requirement, opts, pre, retryHint) => `You are a senior research-dev triage analyst. Do ONE thing: analyze which pipeline mode this dev requirement fits, then give the conclusion. No code, no scope speculation.
+${retryHint ? `[RETRY — YOUR LAST REPLY FAILED]\n${retryHint}\n` : ""}[RAW REQUIREMENT]
 ${requirement}
 ${pre.rationale.length ? `\n[REGEX PRE-FILTER SIGNALS (reference only; judge semantically, don't blindly follow)]\n${pre.rationale.join("\n")}` : ""}
 \n[OPTIONAL SIGNAL] UI work needed: ${opts && opts.needDesign ? "yes" : "not flagged"}
@@ -2132,12 +2212,12 @@ ${pre.rationale.length ? `\n[REGEX PRE-FILTER SIGNALS (reference only; judge sem
 
 [JUDGMENT POINTS]
 1. Distinguish "user-visible functional change" vs "internal tech change": refactors/optimizations, even large code volume, usually go tech, not full.
-2. UI/visual/interaction/buttons/pages involved → at least medium (excludes patch/tech).
+2. **UI feature work** (new screens/components/interactions/pages) → at least medium (excludes patch/tech). **UI micro-adjustments** — moving a button, relocating a control, changing copy/labels, spacing/padding, color tweaks, "move the button", "switch the button position" — are patch-or-lite material, NOT medium: no new interaction logic, no design phase worth the token cost. The line: does it change behavior/interaction logic (medium) or just placement/appearance of existing elements (patch/lite)?
 3. hotfix/single-point/pure numeric/pure docs → patch; clear "add feature X" → pick lite/medium/full by size.
 4. Focused change (even with tests/regression) → lite/tech by nature; not necessarily full.
 5. [M1 ARCHITECTURE CRITERION (important)] **Architecture-level changes** — persistence/localStorage/database/standalone module/abstraction/cross-many-files without an existing reusable wrapper (like a localStorage wrapper, storage layer, state management) — even if they look like "small features", go **at least medium** (must pass the architecture stage and produce a blueprint, avoiding scattered local implementations by dev); such changes collapse under a light "micro feature" tier. Tech-driven rework (refactor/optimize/arch upgrade) is itself tech (tech also runs the lightweight blueprint now).
 
-[OUTPUT] one JSON object only (no other text):
+[OUTPUT] JSON object ONLY — no commentary, no preface, no closing text. The FIRST character of your reply must be '{'. Do NOT say anything like "here is the JSON" or "Let me output the JSON" — output the object itself:
 { "mode": "patch|lite|tech|medium|full", "slug": "<topic words> (3-24 lowercase letters/digits/hyphens, e.g. wallkick-toggle, 7bag-random; used to name the task folder)", "kind": "one-word nature", "needDesign": true|false, "complexity": "small|medium|large", "rationale": ["key argument 1","key argument 2"], "confidence": "high|medium|low" }`;
 /** tech 档 PRD：技术变更单（无功能 AC，重范围/目标/改动面/回归）。 */
 const techChangePrompt = (requirement, root, runId, state) => `You are the senior tech lead. The current workspace IS the target project. This is a **tech-driven rework** requirement (refactor/optimize/upgrade/architecture/dependencies/tech debt) — the product doesn't need a full feature PRD, but needs a **技术变更单** (tech change sheet) as the contract for dev/QA/acceptance and memory write-back.
@@ -2217,140 +2297,72 @@ const MODE_REGISTRY = {
 		desc: "单行/常量/版本号/hotfix：单 agent 直改+自测即交付（无独立 QA）"
 	}
 };
-/** 关键词信号集（命中 → 加重某档倾向）。 */
-const SIGNALS = [
-	{
-		mode: "patch",
-		words: [
-			"hotfix",
-			"热修",
-			"修复 bug",
-			"修 bug",
-			"改个 bug",
-			"版本号",
-			"常量",
-			"一行",
-			"bump",
-			"回滚",
-			"卫生",
-			"笔误",
-			"拼写"
-		]
-	},
-	{
-		mode: "tech",
-		words: [
-			"重构",
-			"优化",
-			"升级",
-			"架构",
-			"性能",
-			"依赖",
-			"脚手架",
-			"缓存",
-			"清理",
-			"遗留债",
-			"工程",
-			"内部改造",
-			"技术债"
-		]
-	},
-	{
-		mode: "lite",
-		words: [
-			"微功能",
-			"小功能",
-			"小增强",
-			"加个",
-			"补一个",
-			"轻微",
-			"顺手"
-		]
-	},
-	{
-		mode: "medium",
-		words: [
-			"界面",
-			"UI",
-			"视觉",
-			"页面",
-			"按钮",
-			"样式",
-			"交互",
-			"布局",
-			"组件",
-			"持久化",
-			"localStorage",
-			"本地存储",
-			"存储",
-			"保存",
-			"恢复",
-			"存档",
-			"独立模块",
-			"抽象",
-			"存储层",
-			"sessionStorage",
-			"IndexedDB",
-			"跨模块",
-			"数据层"
-		]
-	},
-	{
-		mode: "full",
-		words: [
-			"跨模块",
-			"完整",
-			"大型",
-			"对接",
-			"集成",
-			"模块化",
-			"重构为",
-			"二期",
-			"平台"
-		]
-	}
+/** 确定性护栏关键词（双语，仅 fallback 兜底用；主路由是模型——TRIAGE_PROMPT 语义判断）。
+* 架构信号：持久化/存储/独立模块/抽象/跨模块——防「轻档位局部实现塌方」（M1 架构护栏）。
+* UI 信号：UI 相关需求不得落 patch/tech（无设计/QA 的档位）——最低 lite。 */
+const ARCH_SIGNALS = [
+	"持久化",
+	"存储",
+	"保存",
+	"恢复",
+	"存档",
+	"独立模块",
+	"抽象",
+	"存储层",
+	"localStorage",
+	"sessionStorage",
+	"IndexedDB",
+	"跨模块",
+	"数据层",
+	"persistence",
+	"storage",
+	"database",
+	"数据库",
+	"standalone module",
+	"abstraction"
 ];
-/** 对原始需求做启发式分诊。返回建议 mode + 判定理由 + 置信。 */
+const UI_SIGNALS = [
+	"界面",
+	"UI",
+	"视觉",
+	"页面",
+	"按钮",
+	"样式",
+	"交互",
+	"布局",
+	"组件",
+	"page",
+	"button",
+	"style",
+	"layout",
+	"component",
+	"visual",
+	"interaction"
+];
+/** 对原始需求做启发式分诊（兜底路径专用）。返回建议 mode + 判定理由 + 置信。
+* 只做确定性护栏（架构强升/UI 禁轻档/needDesign 升档）——不再逐词匹配五档信号：
+* 主路由是模型（TRIAGE_PROMPT 语义判断，天然双语），正则兜底在模型不可用时宁重勿漏（默认 full）。 */
 function suggestMode(requirement, opts) {
 	const text = String(requirement || "");
-	const hits = [];
-	for (const sig of SIGNALS) for (const w of sig.words) if (text.includes(w)) hits.push({
-		mode: sig.mode,
-		word: w
-	});
-	const rationale = hits.map((h) => `命中「${h.word}」→ ${h.mode}`);
-	const countOf = (m) => hits.filter((h) => h.mode === m).length;
+	const rationale = [];
 	let mode = "full";
-	if (countOf("patch") > 0) mode = "patch";
-	else if (countOf("tech") > 0 && countOf("medium") === 0 && countOf("full") === 0) mode = "tech";
-	else if (countOf("lite") > 0 && countOf("medium") === 0) mode = "lite";
-	else if (countOf("medium") > 0 || opts && opts.needDesign) mode = "medium";
-	else if (hits.length === 0) mode = "full";
-	if ((mode === "patch" || mode === "tech") && opts && opts.needDesign) mode = "medium";
-	if (mode === "patch" && (countOf("tech") > 0 || text.includes("新增") || text.includes("功能"))) mode = "lite";
-	const architectureSignals = [
-		"持久化",
-		"localStorage",
-		"本地存储",
-		"存储",
-		"保存",
-		"恢复",
-		"存档",
-		"独立模块",
-		"抽象",
-		"存储层",
-		"sessionStorage",
-		"IndexedDB",
-		"跨模块",
-		"数据层"
-	];
-	if ((mode === "lite" || mode === "tech" || mode === "patch") && architectureSignals.some((w) => text.includes(w))) {
+	const archHit = ARCH_SIGNALS.find((w) => text.includes(w));
+	if (archHit) {
 		mode = "medium";
-		rationale.push(`架构护栏：需求含「${architectureSignals.find((w) => text.includes(w))}」→ 强升 medium（需架构阶段）`);
+		rationale.push(`架构护栏：需求含「${archHit}」→ 强升 medium（需架构阶段产蓝图，防塌）`);
 	}
-	const kind = mode === "patch" ? "热修/单点" : mode === "tech" ? "技术驱动改造" : mode === "lite" ? "微功能" : mode === "medium" ? "标准功能(含UI)" : "完整需求";
-	const confidence = mode === "patch" ? "high" : hits.length >= 2 ? "medium" : "low";
-	if (rationale.length === 0) rationale.push("无强信号，默认 full（护栏优先）");
+	const uiHit = !archHit ? UI_SIGNALS.find((w) => text.includes(w)) : void 0;
+	if (uiHit) {
+		mode = mode === "full" ? "lite" : mode;
+		rationale.push(`UI 护栏：需求含「${uiHit}」→ 不低于 lite（UI 改动需 QA/验收）`);
+	}
+	if (opts && opts.needDesign && mode !== "medium") {
+		mode = "medium";
+		rationale.push("needDesign=true → 强升 medium（显式要求设计阶段）");
+	}
+	if (rationale.length === 0) rationale.push("无强护栏信号，默认 full（模型不可用时宁重勿漏）");
+	const kind = mode === "medium" ? "标准功能(含UI)" : mode === "lite" ? "微功能" : "完整需求";
+	const confidence = mode === "medium" && !opts?.needDesign ? "medium" : "low";
 	return {
 		mode,
 		kind,
@@ -2408,29 +2420,36 @@ function fallbackVerdict(requirement, opts) {
 		source: "fallback"
 	};
 }
-/** 模型驱动分诊：spawn「分诊分析师」子代理思考一轮；子代理不可用/超时/解析失败 → 正则兜底。 */
+/** 模型驱动分诊：spawn「分诊分析师」子代理思考一轮；子代理不可用/超时/解析失败 → 正则兜底。
+* 解析失败先带纠错提示重试一次（实锤 run tf-mtfo8exi：模型输出「Let me output the JSON.」开场白
+* 后无 JSON——首轮输出预算被思考耗尽/模型停早；重试提示直接输出 JSON 对象本身）。 */
 async function runTriage(requirement, opts, parent, signal) {
 	const subagents = runtime.subagents;
 	if (!subagents || typeof subagents.start !== "function") return fallbackVerdict(requirement, opts);
 	const pre = suggestMode(requirement, opts);
-	let run = null;
-	try {
-		run = await subagents.start(providerName(), {
-			label: "需求分诊",
-			prompt: [{
-				type: "text",
-				text: TRIAGE_PROMPT(requirement, opts, pre)
-			}],
-			parent,
-			signal
-		});
-		const result = await Promise.race([run.result, new Promise((_, rej) => setTimeout(() => rej(/* @__PURE__ */ new Error("triage 超时（90s）")), 9e4))]);
-		const parsed = parseVerdictText(extractText(result && result.output));
-		if (parsed) return parsed;
-	} catch (e) {} finally {
-		if (run && run.dispose) try {
-			await run.dispose();
-		} catch (e) {}
+	for (let attempt = 1; attempt <= 2; attempt++) {
+		let run = null;
+		try {
+			const hint = attempt > 1 ? "Your previous reply contained only a preface (e.g. \"Let me output the JSON.\") with NO JSON object — that is a failed reply. Reply now with the JSON object ITSELF as the first and only content, starting with {." : "";
+			run = await subagents.start(providerName(), {
+				label: "需求分诊",
+				prompt: [{
+					type: "text",
+					text: TRIAGE_PROMPT(requirement, opts, pre, hint)
+				}],
+				parent,
+				signal
+			});
+			const result = await Promise.race([run.result, new Promise((_, rej) => setTimeout(() => rej(/* @__PURE__ */ new Error("triage 超时（90s）")), 9e4))]);
+			const parsed = parseVerdictText(extractText(result && result.output));
+			if (parsed) return parsed;
+		} catch (e) {
+			if (attempt === 2) {}
+		} finally {
+			if (run && run.dispose) try {
+				await run.dispose();
+			} catch (e) {}
+		}
 	}
 	return fallbackVerdict(requirement, opts);
 }
@@ -2579,6 +2598,7 @@ function buildResumeProducts(journal) {
 * 全部完成仍被中断（理论极端）→ 从产品验收继续。
 */
 function interruptedPhaseOf(journal) {
+	if (hasOpenBlockingBugs(journal)) return "QA 测试";
 	for (const phase of PHASE_ORDER) {
 		const phaseStages = (journal.stages || []).filter((s) => s.phase === phase);
 		if (phaseStages.length === 0) continue;
@@ -2586,6 +2606,24 @@ function interruptedPhaseOf(journal) {
 	}
 	return "产品验收";
 }
+/** 开发任务定义（单一来源）：架构蓝图自动拆 > 调用方显式 tasks > 整体开发兜底。
+* resume 补跑与正常执行共用（defByTitle 按 title 匹配失败子卡）。 */
+function buildDevTaskDefs(journal, tasks) {
+	const blueprintTasks = journal.blueprint && Array.isArray(journal.blueprint.tasks) && journal.blueprint.tasks.length ? journal.blueprint.tasks.map((t) => ({
+		title: t.title || "开发任务",
+		files: Array.isArray(t.files) ? t.files : [],
+		spec: t.spec || ""
+	})) : [];
+	return blueprintTasks.length ? blueprintTasks : tasks.length > 0 ? tasks.map((t) => ({
+		title: t.title,
+		spec: t.spec,
+		files: []
+	})) : [{
+		title: "整体开发",
+		spec: "按技术方案/需求实现全部改动",
+		files: []
+	}];
+}
 /**
 * 执行流水线。resume = null 全新运行；resume = { phase, products } 从断点续跑：
 * phase 之前的阶段直接复用 products 产物（跳过执行），从 phase 阶段开始重跑。
@@ -2906,74 +2944,98 @@ async function executePipeline(journal, parent, requirement, options, signal, re
 			}
 		}
 		let tech = null;
-		if (resumed("技术方案")) {
-			tech = resume.products.tech;
-			timeline.tech = tech;
-			logSkip("技术方案");
-		} else {
-			const isHeavy = !options.lite && options.mode !== "tech" && options.mode !== "patch";
-			journal.logs.push({
-				t: Date.now(),
-				level: "phase",
-				message: isHeavy ? "进入阶段：技术方案" : "进入阶段：架构蓝图"
-			});
-			const label = isHeavy ? "高级全栈工程师 · 技术方案" : "架构师 · 架构蓝图";
-			const techR = await withRetry(journal, parent, label, "技术方案", isHeavy ? techPrompt(prd, design, scaffold, tasks, root, journal.id, state) : architectPrompt(prd, root, journal.id, state), signal);
-			if (!techR.text) throw stageFailError(label, techR);
-			tech = techR.text;
-			timeline.tech = tech;
-			mergeStageState("tech", tech);
-			let bd = extractBlueprint(tech);
-			if (!bd || bd.summary === void 0) try {
-				const techFile = journal.runDocs && journal.workspacePath ? `${journal.workspacePath}/${journal.runDocs}/TECHNICAL.md` : null;
-				if (techFile && existsSync(techFile)) bd = extractBlueprint(readFileSync(techFile, "utf8"));
-				if (bd) journal.logs.push({
+		if (enabled("tech")) {
+			if (resumed("技术方案")) {
+				tech = resume.products.tech;
+				timeline.tech = tech;
+				logSkip("技术方案");
+			} else {
+				const isHeavy = !options.lite && options.mode !== "tech" && options.mode !== "patch";
+				journal.logs.push({
 					t: Date.now(),
-					level: "info",
-					message: "蓝图从任务夹 TECHNICAL.md 提取（模型把蓝图写进了文档而非回复输出）"
+					level: "phase",
+					message: isHeavy ? "进入阶段：技术方案" : "进入阶段：架构蓝图"
 				});
-			} catch (e) {}
-			if (bd && bd.summary !== void 0) try {
-				state.__runCtx = state.__runCtx || {};
-				state.__runCtx.blueprint = bd.render;
-				journal.blueprint = {
-					modules: bd.modules,
-					tasks: bd.tasks
-				};
-			} catch (e) {}
-			else if (/<!-- blueprint -->/.test(String(tech))) journal.logs.push({
-				t: Date.now(),
-				level: "warn",
-				message: "技术方案蓝图块解析失败（JSON 畸形），开发任务将回退整体开发——TECHNICAL.md 蓝图块需人工检查"
-			});
-			noteTaskStageUsage(journal);
-			if (journal.cancelled) return;
+				const label = isHeavy ? "高级全栈工程师 · 技术方案" : "架构师 · 架构蓝图";
+				const techR = await withRetry(journal, parent, label, "技术方案", isHeavy ? techPrompt(prd, design, scaffold, tasks, root, journal.id, state) : architectPrompt(prd, root, journal.id, state), signal);
+				if (!techR.text) throw stageFailError(label, techR);
+				tech = techR.text;
+				timeline.tech = tech;
+				mergeStageState("tech", tech);
+				let bd = extractBlueprint(tech);
+				if (!bd || bd.summary === void 0) try {
+					const techFile = journal.runDocs && journal.workspacePath ? `${journal.workspacePath}/${journal.runDocs}/TECHNICAL.md` : null;
+					if (techFile && existsSync(techFile)) bd = extractBlueprint(readFileSync(techFile, "utf8"));
+					if (bd) journal.logs.push({
+						t: Date.now(),
+						level: "info",
+						message: "蓝图从任务夹 TECHNICAL.md 提取（模型把蓝图写进了文档而非回复输出）"
+					});
+				} catch (e) {}
+				if (bd && bd.summary !== void 0) try {
+					state.__runCtx = state.__runCtx || {};
+					state.__runCtx.blueprint = bd.render;
+					journal.blueprint = {
+						modules: bd.modules,
+						tasks: bd.tasks
+					};
+				} catch (e) {}
+				else if (/<!-- blueprint -->/.test(String(tech))) journal.logs.push({
+					t: Date.now(),
+					level: "warn",
+					message: "技术方案蓝图块解析失败（JSON 畸形），开发任务将回退整体开发——TECHNICAL.md 蓝图块需人工检查"
+				});
+				noteTaskStageUsage(journal);
+				if (journal.cancelled) return;
+			}
 		}
 		let devResults = null;
 		if (resumed("开发")) {
 			devResults = resume.products.dev || [];
-			timeline.dev = devResults;
-			logSkip("开发");
+			const failedSubs = (storeFor(scopeKey).tasks || []).filter((t) => t.reqId === journal.reqId && t.parentId === journal.taskId && (t.status === "failed" || t.failed === true));
+			if (failedSubs.length > 0) {
+				const defs = buildDevTaskDefs(journal, tasks);
+				const defByTitle = new Map(defs.map((d) => [d.title, d]));
+				const rerunDefs = failedSubs.map((s) => {
+					const key = String(s.title || "").replace(/^开发 · /, "");
+					return defByTitle.get(key) || {
+						title: key,
+						spec: s.spec || "按技术方案实现该任务改动",
+						files: []
+					};
+				}).filter(Boolean);
+				const reused = devResults.filter((r) => r && !rerunDefs.some((d) => d.title === r.title));
+				journal.logs.push({
+					t: Date.now(),
+					level: "warn",
+					message: `断点续跑开发：复用 ${reused.length} 个已完成任务，补跑 ${rerunDefs.length} 个失败任务`
+				});
+				const rerun = await runPool(rerunDefs, maxConcurrency, async (task) => {
+					const devR = await withRetry(journal, parent, `开发 · ${task.title}（补跑）`, "开发", devPrompt(task, tech, prd, root, journal.id, state), signal);
+					const ok = !!devR.text;
+					return {
+						title: task.title,
+						failed: !ok,
+						output: devR.text || "开发失败（Agent 未产出结果）"
+					};
+				});
+				for (const t of rerun) {
+					const sub = failedSubs.find((s) => String(s.title || "").replace(/^开发 · /, "") === t.title);
+					if (sub) completeSubtask(journal, sub.id, t.failed, t.output ? snippet(t.output, 1e3) : null, null);
+				}
+				devResults = [...reused, ...rerun];
+				timeline.dev = devResults;
+			} else {
+				timeline.dev = devResults;
+				logSkip("开发");
+			}
 		} else {
 			journal.logs.push({
 				t: Date.now(),
 				level: "phase",
 				message: "进入阶段：开发"
 			});
-			const blueprintTasks = journal.blueprint && Array.isArray(journal.blueprint.tasks) && journal.blueprint.tasks.length ? journal.blueprint.tasks.map((t) => ({
-				title: t.title || "开发任务",
-				files: Array.isArray(t.files) ? t.files : [],
-				spec: t.spec || ""
-			})) : [];
-			const devTaskDefs = blueprintTasks.length ? blueprintTasks : tasks.length > 0 ? tasks.map((t) => ({
-				title: t.title,
-				spec: t.spec,
-				files: []
-			})) : [{
-				title: "整体开发",
-				spec: "按技术方案/需求实现全部改动",
-				files: []
-			}];
+			const devTaskDefs = buildDevTaskDefs(journal, tasks);
 			const mergedDefs = [];
 			for (const t of devTaskDefs) {
 				const hit = t.files && t.files.length ? mergedDefs.find((m) => m.files.some((f) => t.files.includes(f))) : void 0;
@@ -2990,7 +3052,7 @@ async function executePipeline(journal, parent, requirement, options, signal, re
 			journal.logs.push({
 				t: Date.now(),
 				level: "info",
-				message: `开发阶段开始，任务数：${mergedDefs.length}（并发 ${maxConcurrency}${blueprintTasks.length ? "，源自架构蓝图自动拆解" : ""}）`
+				message: `开发阶段开始，任务数：${mergedDefs.length}（并发 ${maxConcurrency}${journal.blueprint && Array.isArray(journal.blueprint.tasks) && journal.blueprint.tasks.length ? "，源自架构蓝图自动拆解" : ""}）`
 			});
 			advanceTask(journal, "running", null, "开发开始（待办 → 开发中）", { by: "dev" });
 			const subCards = mergedDefs.map((dt) => createSubtask(journal, dt.title, dt.spec));
@@ -3034,17 +3096,10 @@ async function executePipeline(journal, parent, requirement, options, signal, re
 				}
 				journal.logs.push({
 					t: Date.now(),
-					level: "warn",
-					message: `开发完成，失败任务数：${failedCount}（需人工介入）`
+					level: "error",
+					message: `开发失败任务数：${failedCount}/${devResults.length}（提测门禁拦截）：停止流水线，需人工介入——处理后可 teamflow_resume 从开发阶段补跑失败任务（已完成任务复用）`
 				});
-				if (failedCount >= devResults.length) {
-					journal.logs.push({
-						t: Date.now(),
-						level: "error",
-						message: `开发任务全部失败（${failedCount}/${devResults.length}）：停止流水线，需人工介入——可用 teamflow_resume 从开发阶段重跑`
-					});
-					throw new Error(`开发任务全部失败（${failedCount}/${devResults.length}）：无产物可测，停止流水线`);
-				}
+				throw new Error(`开发失败任务 ${failedCount}/${devResults.length}：提测门禁拦截，不进 QA（已知缺口，QA 检查轮必然重复报告）`);
 			} else {
 				advanceTask(journal, "testable", null, "开发完成待测试（开发中 → 待测试）", { by: "dev" });
 				journal.logs.push({
@@ -3065,7 +3120,7 @@ async function executePipeline(journal, parent, requirement, options, signal, re
 				message: "当前档位阶段集不含独立 QA：跳过（单点修复，开发自测兜底）"
 			});
 			qa = "（独立 QA 跳过：当前档位由开发自测兜底）";
-		} else if (resumed("QA 测试")) {
+		} else if (resumed("QA 测试") && !hasOpenBlockingBugs(journal)) {
 			qa = resume.products.qa;
 			timeline.qa = qa;
 			logSkip("QA 测试");
@@ -3159,7 +3214,22 @@ async function executePipeline(journal, parent, requirement, options, signal, re
 			if (journal.cancelled) return;
 		}
 		persistJournal(journal);
-		if (!qaBlocked) {
+		if (!enabled("acceptance")) {
+			journal.logs.push({
+				t: Date.now(),
+				level: "info",
+				message: "patch 档交付完成：单 agent 直改 + 自测即收口（无独立 QA/验收）"
+			});
+			advanceTask(journal, "accepted", null, "patch 直改交付（自测通过）", { by: "dev" });
+			const store = storeFor(scopeKey);
+			const req = store.find("req", journal.reqId);
+			if (req && req.status !== "accepted") {
+				store.pushEvent(req, req.status, "accepted", "patch 交付通过（自测）");
+				req.status = "accepted";
+				store.persist();
+			}
+			journal.status = "completed";
+		} else if (!qaBlocked) {
 			journal.logs.push({
 				t: Date.now(),
 				level: "phase",
@@ -3451,7 +3521,7 @@ function resumeRun(runId, sessionId) {
 			level: "warn",
 			message: `断点续跑：从「${resumePhase}」继续（已完成阶段复用产物）`
 		});
-		j.stages = (j.stages || []).filter((s) => s.status === "done");
+		j.stages = (j.stages || []).filter((s) => s.status !== "running" && s.status !== "pending");
 		runs.set(id, j);
 		persistJournal(j);
 		executePipeline(j, agent, j.requirement, j.options, void 0, {
@@ -3553,7 +3623,7 @@ function registerTools(ctx) {
 	};
 	T({
 		name: "teamflow_start",
-		description: "Start the team R&D pipeline (background async): runs the stages per team config (PRD→design→tech→dev→QA→acceptance). Specify teamId (matches teams.json) or pick a team via the UI \"+\" button first so messages auto-match. Stage failures auto-retry; beyond threshold → rework/human intervention; per-stage token usage recorded. NOTE: after calling, the implementation work is done by pipeline subagents — the main thread MUST NOT write code or run verifications for it. requirement must be a faithful transcription of the user's words; do not invent file paths / tech claims without code verification (downstream stages build the PRD from it). Branch decision: when the return status is \"needs-decision\", ASK THE USER to pick one of the options (or take their custom input, e.g. a branch name), then RE-CALL this tool with the chosen branchPolicy / branchName / preAction / commitMessage parameters. Pass branchPolicy=\"keep\" when the user chooses to stay on the current branch.",
+		description: "Start the team R&D pipeline (background async): runs the stages per team config (PRD→design→tech→dev→QA→acceptance). Specify teamId (matches teams.json) or pick a team via the UI \"+\" button first so messages auto-match. Stage failures auto-retry; beyond threshold → rework/human intervention; per-stage token usage recorded. NOTE: after calling, the implementation work is done by pipeline subagents — the main thread MUST NOT write code or run verifications for it. requirement must be a faithful transcription of the user's words; do not invent file paths / tech claims without code verification (downstream stages build the PRD from it). Branch decision: when the return status is \"needs-decision\", ASK THE USER to pick one of the options (or take their custom input, e.g. a branch name), then RE-CALL this tool passing the CHOSEN OPTION VALUE as branchPolicy (\"new\" = confirmed create branch, \"keep\" = stay), optionally combined with preAction / branchName / commitMessage. Pass branchPolicy=\"keep\" when the user chooses to stay on the current branch.",
 		parameters: {
 			requirement: {
 				type: "string",
@@ -3590,7 +3660,7 @@ function registerTools(ctx) {
 			},
 			branchPolicy: {
 				type: "string",
-				description: "Branch policy: \"auto\" (default) — create a feature branch feat/<branchName|slug> from the current HEAD; \"keep\" — stay on current branch. When auto and a decision is needed (dirty workspace / on main etc.), the tool returns needs-decision for you to ask the user first."
+				description: "Branch policy: \"auto\" (default, triggers needs-decision when not yet confirmed) — create a feature branch feat/<branchName|slug> from the current HEAD; \"keep\" — stay on current branch; \"new\" — the confirmed value returned by needs-decision options (user already picked \"create branch\"), pass it back as-is to proceed. When auto and a decision is needed (dirty workspace / on main etc.), the tool returns needs-decision for you to ask the user first."
 			},
 			branchName: {
 				type: "string",
@@ -3642,7 +3712,7 @@ function registerTools(ctx) {
 					const opts = Array.isArray(value.options) ? value.options.map((o, i) => `${i + 1}. ${o.label}`).join("\n") : "";
 					return [{
 						type: "text",
-						text: `【分支决策】${value.question}\n${opts}\n（也可自定义输入）——请询问用户选择，确认后以 teamflow_start 的 branchPolicy/branchName/preAction/commitMessage 参数重新调用。`
+						text: `【分支决策】${value.question}\n${opts}\n（也可自定义输入）——请询问用户选择，确认后把所选选项的 value 作为 branchPolicy 重新调用 teamflow_start（如 'new'/'keep'；脏工作区选项可拆为 branchPolicy + preAction 组合），自定义分支名则传 branchName。`
 					}];
 				}
 				if (value && value.status === "needs-confirmation") return [{
@@ -3692,7 +3762,8 @@ function registerTools(ctx) {
 					preAction: args.preAction === "stash" || args.preAction === "commit" ? args.preAction : null,
 					commitMessage: typeof args.commitMessage === "string" && args.commitMessage.trim() ? args.commitMessage.trim() : null
 				};
-				if (options.branchPolicy === "auto" && !options.preAction && exec && exec.agent) {
+				const branchConfirmed = args.branchPolicy === "new";
+				if (options.branchPolicy === "auto" && !branchConfirmed && !options.branchName && !options.preAction && exec && exec.agent) {
 					const sc = workspaceScopeOf(exec.agent);
 					if (sc.path) try {
 						const s = runSanityCheck(sc.path);
@@ -3706,7 +3777,7 @@ function registerTools(ctx) {
 								question = `工作区 ${sc.path} 当前在 main 分支（工作区干净）。流水线默认在特性分支上开发，请选择：`;
 								optionsList = [{
 									label: "基于 main 新建分支开发（推荐，分支名取需求 slug，可自定义）",
-									value: "auto"
+									value: "new"
 								}, {
 									label: "直接在 main 上开发",
 									value: "keep"
@@ -3734,7 +3805,7 @@ function registerTools(ctx) {
 									value: "keep"
 								}, {
 									label: "基于当前分支再新建子分支开发",
-									value: "auto"
+									value: "new"
 								}];
 							} else {
 								question = `工作区 ${sc.path} 当前在特性分支 ${s.branch}，且有 ${dirtyN} 处未提交改动。请选择启动方式：`;
@@ -3761,7 +3832,7 @@ function registerTools(ctx) {
 								status: "needs-decision",
 								question,
 								options: optionsList,
-								note: "选项之外可自定义输入（如指定分支名）。确认选择后，请以 teamflow_start 的 branchPolicy / branchName / preAction / commitMessage 参数重新调用本工具。"
+								note: "选项之外可自定义输入（如指定分支名）。确认选择后，请以 teamflow_start 的 branchPolicy（回传所选选项 value，如 new/keep）与 branchName/preAction/commitMessage 参数重新调用本工具。"
 							};
 						}
 					} catch (e) {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-teamflow",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "TeamFlow 团队研发流水线（TypeScript）：需求→PRD→设计→架构→技术方案→并行开发→QA→验收；backlog 持久化 + 断点续跑 + 完成汇报 + 防假交付；Web 团队工作台（conversation.view tab + 拖拽看板）",
   "type": "module",
   "main": "./lib/host.mjs",