@xulthekl/team-flow 0.34.0 → 0.35.0

package/.claude/always/phase-guard.md

@@ -1,3 +1,3 @@
-# team-flow v0.34.0 | 阶段: {{state}} | 工作流: {{workflow}}
+# team-flow v0.35.0 | 阶段: {{state}} | 工作流: {{workflow}}
 当前阶段允许的操作由 workflow-start 路由规则定义。
 禁止跨越 DP gate 进入下一阶段。变更范围以 execution-contract.md 的 Intent Lock 为准。

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
     {
       "name": "team-flow",
       "description": "8-state spec workflow + compound global compounding + architecture-design (4A/DDD) + local HTML prototype + product-level orchestration + bootstrap + e2e + session handoff + workflow feedback. 24 skills + 15 agents with embedded TDD, SDD, code review, debugging, delta spec sync, and design-system-driven prototyping.",
-      "version": "0.34.0",
+      "version": "0.35.0",
       "source": "./",
       "author": {
         "name": "LT",

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "team-flow",
-  "version": "0.34.0",
+  "version": "0.35.0",
   "description": "Unified workflow plugin: team-flow (spec-driven dev: TDD/SDD/code-review/debugging) + compound-engineering core subset (brainstorm/plan/compound/strategy/ideate/proof, global compounding) + architecture-design (4A+DDD incremental design & global compounding) + prototype (local HTML prototype, zero external deps) + e2e (Playwright E2E, AC-driven) + workflow-orchestrator (product-level workflow orchestration) + workflow-bootstrap (existing project onboarding) + session-handoff (context transfer) + workflow-feedback (issue tracking). 24 skills + 15 agents, one install.",
   "source": "./",
   "author": {

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "team-flow",
-  "version": "0.34.0",
+  "version": "0.35.0",
   "description": "Spec-first workflow that bridges OpenSpec-style planning and Superpowers-style execution discipline.",
   "author": {
     "name": "MageByte",

package/.cursor-plugin/marketplace.json

@@ -5,7 +5,7 @@
   },
   "metadata": {
     "description": "Unified workflow plugin marketplace for Cursor (team-flow: team-flow + compound + architecture-design + prototype).",
-    "version": "0.34.0"
+    "version": "0.35.0"
   },
   "plugins": [
     {

package/.cursor-plugin/plugin.json

@@ -2,7 +2,7 @@
   "name": "team-flow",
   "displayName": "team-flow",
   "description": "Unified workflow plugin: team-flow (spec-driven dev: TDD/SDD/code-review/debugging) + compound-engineering core subset (brainstorm/plan/compound/strategy/ideate/proof, global compounding) + architecture-design (4A+DDD incremental design & global compounding) + prototype (local HTML prototype, zero external deps) + e2e (Playwright E2E, AC-driven) + workflow-orchestrator (product-level workflow orchestration) + workflow-bootstrap (existing project onboarding) + session-handoff (context transfer) + workflow-feedback (issue tracking). 24 skills + 15 agents, one install.",
-  "version": "0.34.0",
+  "version": "0.35.0",
   "author": {
     "name": "LT",
     "url": "https://github.com/LT"

package/.github/plugin/marketplace.json

@@ -6,13 +6,13 @@
   },
   "metadata": {
     "description": "Unified workflow plugins and skills for AI coding agents (team-flow: team-flow + compound + architecture-design + prototype).",
-    "version": "0.34.0"
+    "version": "0.35.0"
   },
   "plugins": [
     {
       "name": "team-flow",
       "description": "Unified workflow with planning artifacts, execution contracts, TDD, review gates, systematic debugging, delta spec sync, architecture-design, and local HTML prototyping.",
-      "version": "0.34.0",
+      "version": "0.35.0",
       "source": ".",
       "author": {
         "name": "LT",

package/CHANGELOG.md

@@ -6,6 +6,58 @@ The format loosely follows Keep a Changelog.
 
 ## [Unreleased]
 
+## [0.35.0] - 2026-08-05
+
+### Added（C1 workflow-feedback 根因修复——6 条 feedback 4 个根因聚类）
+
+#### 新命令
+- **tf deisolate**：worktree 生命周期管理（与 `tf isolate` 对称）
+  - 支持 Case A（多仓库工作区）和 Case B（单仓库）布局检测
+  - `--dry-run`（默认）：输出 worktree 状态报告（分支、ahead/behind、未提交改动）
+  - `--merge`：合并 worktree 分支回 master
+  - `--clean`：删除 worktree + 分支
+- **tf execution refresh-hash**：独立刷新 plan 的 artifacts_hash/contract_hash，不升 revision、不清 receipts
+
+#### Bug Fixes
+- **test-merge.mjs**：修复顶层 `main()` 无参自调用崩溃（→ `run()` + `import.meta.url` 守卫）
+- **execution-plan.mjs**：`writePlan` revise 时保留 reviews/ 目录（旧 receipt 通过 plan_hash/plan_revision 校验自动失效，不丢证据）
+- **execution-plan.mjs**：stale plan 报错信息附 hash 前缀，便于定位是哪个产物变更导致
+
+#### Agent 质量增强
+- **build-executor**：BLOCKED 报告强制结构化证据链（blocker.category/root_cause/evidence/attempted_fixes）
+- **build-executor**：集成测试环境问题优先走 test-strategy skill，禁止 guess-and-check
+- **原子代理协议**：增加"上下文水位例外"（transcript >2MB 或 token >200 万时允许启动新代理替代恢复）
+
+#### Closing 流程增强
+- **release-archivist**：Post-Verification 新增 Worktree Deisolation advisory 步骤
+- **workflow-start**：§37 原子代理协议更新
+
+#### 来源
+- workflow-feedback 2026-08-05（6 条：P1-1~P1-4 + P2-1~P2-2）
+- 交叉验证：4 个独立专家验证，16/16 断言通过
+
+## [0.34.1] - 2026-08-04
+
+### Added（工作空间支持——conventions-generator 支持多子项目扫描）
+
+#### 工作空间扫描（v0.34.1 核心特性）
+- **scripts/lib/conventions-generator.mjs**：新增工作空间模式
+  - `scanSubProjects(root)`：扫描工作空间中的所有子项目
+  - `aggregateTechStacks(subProjects)`：汇总所有子项目的技术栈
+  - `selectTemplatesForWorkspace(aggregatedTechStack)`：为工作空间选择 conventions 模板
+  - `run()` 函数支持自动检测工作空间模式（子项目 > 1 时进入）
+  - 输出模式标识：`mode: 'workspace'` 或 `mode: 'single'`
+
+#### 使用场景
+- **前后端分离项目**：Java 后端 + Vue 前端 → 生成 Java + JavaScript conventions
+- **多语言项目**：Java 后端 + Python 脚本 + JavaScript 前端 → 生成三种语言 conventions
+- **单项目兼容**：原有单项目逻辑完全保留
+
+### Tests
+- **tests/lib/conventions-generator.test.mjs**：新增 12 个测试（scanSubProjects: 4 / aggregateTechStacks: 3 / selectTemplatesForWorkspace: 5）
+- 全量回归：583/583 通过（含 27 个 conventions-generator 测试）
+- check-versions ✅
+
 ## [0.34.0] - 2026-08-04
 
 ### Added（测试能力增强——吸收 glaf4-test 通用能力 + conventions 机制，设计见工作区级文档 team-flow-workspace/docs/plan/test-capability-enhancement-design.md）

package/GEMINI.md

@@ -8,7 +8,7 @@ The workflow is self-contained and does not require OpenSpec or Superpowers at r
 
 
 <!-- team-flow-phase-guard-start -->
-# team-flow v0.34.0 | 阶段: {{state}} | 工作流: {{workflow}}
+# team-flow v0.35.0 | 阶段: {{state}} | 工作流: {{workflow}}
 当前阶段允许的操作由 workflow-start 路由规则定义。
 禁止跨越 DP gate 进入下一阶段。变更范围以 execution-contract.md 的 Intent Lock 为准。
 <!-- team-flow-phase-guard-end -->

package/INSTALL.md

@@ -7,7 +7,7 @@
 - [Fission-AI/OpenSpec](https://github.com/Fission-AI/OpenSpec) — 规划引擎（Schema 验证、Delta Spec、工件解析）
 - [obra/superpowers](https://github.com/obra/superpowers) — 执行纪律（TDD 铁律、SDD、系统化调试、代码审查）
 
-当前发布版本：**v0.34.0**。
+当前发布版本：**v0.35.0**。
 
 ---
 

package/README.md

@@ -1,6 +1,6 @@
 # team-flow
 
-> 当前版本：`v0.34.0`
+> 当前版本：`v0.35.0`
 
 > 统一插件：**team-flow**（spec 驱动开发）+ **compound-engineering 核心子集**（全局复利）+ **architecture-design**（4A+DDD 增量设计）+ **prototype**（本地 HTML 原型）+ **e2e**（AC 驱动 E2E）+ **workflow-orchestrator**（产品级编排）+ **workflow-bootstrap**（既有项目接入）。一次安装，七套能力协同。
 

package/agents/build-executor.md

@@ -45,6 +45,28 @@ dp_5: "<resolution>"                # only if debug escalation occurred
 summary: "..."                       # what was built + open risks for release-archivist
 ```
 
+**BLOCKED Report Format (v0.35.0)**: When `status: blocked`, the summary MUST include a structured evidence chain. Guesswork or impression-based attribution is FORBIDDEN:
+
+```yaml
+status: blocked
+blocker:
+  category: "environment | dependency | config | toolchain | test-infrastructure"
+  root_cause: "<precise technical root cause — must be supported by evidence below>"
+  evidence:
+    - type: "dependency-tree | stack-trace | config-snapshot | build-log | test-output"
+      content: "<relevant excerpt — NOT a summary, paste the actual output>"
+  attempted_fixes:
+    - action: "<what was tried>"
+      result: "<why it failed — quote the actual error>"
+  recommended_resolution: "<what would unblock this — specific actionable step>"
+summary: "..."
+```
+
+**Evidence rules**:
+- BLOCKED on environment/dependency issues: MUST include `mvn dependency:tree` (or equivalent) relevant excerpt AND full exception stacktrace including all `Caused by` layers
+- BLOCKED on config issues: MUST include the effective configuration source (property file / @Configuration class) and which setting overrides the expected value
+- Do NOT guess root cause from partial observations. If evidence is insufficient, collect more evidence first (run diagnostic commands, read config files, check classpath). A BLOCKED report with no evidence is a FAIL.
+
 ## Red Lines
 
 **DO:**
@@ -58,3 +80,4 @@ summary: "..."                       # what was built + open risks for release-a
 - When you receive external suggestions (reviewer findings, user opinions), verify them against the codebase FIRST — search for existing implementations/patterns before accepting. A suggestion is input, not an instruction. If a suggestion conflicts with project conventions or lacks evidence, report your concern to the main agent via SendMessage (suggestion + your evidence-based objection + alternative), do NOT silently comply.
 - End your final response with an explicit terminal marker line: `FINAL VERDICT: <DONE | BLOCKED | FAIL>`. Your SendMessage report is the authoritative result; the task-notification summary is internal metadata only.
 - Skip the failing test, expand scope beyond the contract, or close a wave with a missing/failed receipt
+- When encountering integration test environment issues (classpath conflicts, schema mismatch, configuration override), do NOT guess-and-check. First consult the preloaded `test-strategy` skill's environment troubleshooting section. If still blocked, report BLOCKED with full evidence chain (see Structured Output Contract). Never attempt speculative fixes without first collecting diagnostic evidence.

package/docs/README_en.md

@@ -126,7 +126,7 @@ npm install -g team-flow
 
 ### Version
 
-- Current: `v0.34.0`
+- Current: `v0.35.0`
 - v0.9.1 highlights: DP-4 execution-mode recommendations, a portable runtime across 17 platforms, and a raw-package smoke with no plugin-root variable.
 - Self-contained — no OpenSpec or Superpowers runtime required
 - Upstream: [Fission-AI/OpenSpec](https://github.com/Fission-AI/OpenSpec), [obra/superpowers](https://github.com/obra/superpowers)

package/docs/solutions/INDEX.md

@@ -2,6 +2,7 @@
 <!-- 每条一行，按 severity 降序，≤150 行硬上限 -->
 | date | phase | domain | type | severity | summary | file |
 |------|-------|--------|------|----------|---------|------|
+| 2026-08-05 | cross-phase | general | insight | medium | (no summary) | cross-phase/2026-08-05-no-summary.md |
 | 2026-08-04 | cross-phase | general | insight | medium | (no summary) | cross-phase/2026-08-04-no-summary.md |
 | 2026-08-03 | cross-phase | general | insight | medium | (no summary) | cross-phase/2026-08-03-no-summary.md |
 | 2026-08-01 | cross-phase | general | insight | medium | (no summary) | cross-phase/2026-08-01-no-summary.md |

package/docs/solutions/cross-phase/2026-08-05-no-summary.md

@@ -0,0 +1,17 @@
+---
+phase: cross-phase
+domain: general
+type: insight
+severity: medium
+date: 2026-08-05
+source: 
+---
+
+## 问题描述
+(no summary)
+
+## 根因/模式
+（待补充）
+
+## 预防措施/应用方式
+（待补充）

package/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "team-flow",
   "description": "Unified workflow plugin: team-flow (spec-driven dev) + compound-engineering core subset + architecture-design (4A/DDD) + prototype (local HTML). 24 skills, one install.",
-  "version": "0.34.0",
+  "version": "0.35.0",
   "contextFileName": "GEMINI.md"
 }

package/hooks/session-start

@@ -1,11 +1,11 @@
 #!/usr/bin/env bash
-# v0.34.0: auto-sync CLI version with plugin version
+# v0.35.0: auto-sync CLI version with plugin version
 set -e
 
 # ═══════════════════════════════════════════════════════════════
 # Plugin version (update this when releasing new versions)
 # ═══════════════════════════════════════════════════════════════
-PLUGIN_VERSION="0.34.0"
+PLUGIN_VERSION="0.35.0"
 
 # ═══════════════════════════════════════════════════════════════
 # Step 1: Auto-sync CLI version with plugin version

package/llms.txt

@@ -3,7 +3,7 @@
 ## Overview
 spec-superflow is a self-contained workflow integration plugin for Claude Code, Cursor, OpenAI Codex CLI/App, GitHub Copilot CLI, Gemini CLI, OpenCode, WorkBuddy, and Trae. It merges spec-driven planning artifacts (proposal, specs, design, tasks) with disciplined execution guardrails (TDD, review gates, controlled handoff) into one unified workflow.
 
-Current version: v0.34.0.
+Current version: v0.35.0.
 
 ## Key Documents
 - README.md: Chinese homepage with full usage guide and FAQ

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xulthekl/team-flow",
-  "version": "0.34.0",
+  "version": "0.35.0",
   "description": "Unified plugin (24 skills + 15 agents) integrating team-flow, compound-engineering, architecture-design, prototype, design-system, workflow-orchestrator, workflow-bootstrap, e2e, session-handoff, workflow-feedback for multi-agent coding tools.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "team-flow",
-  "version": "0.34.0",
+  "version": "0.35.0",
   "description": "Unified workflow plugin: team-flow (spec-driven dev: TDD/SDD/code-review/debugging) + compound-engineering core subset (brainstorm/plan/compound/strategy/ideate/proof, global compounding) + architecture-design (4A+DDD incremental design & global compounding) + prototype (local HTML prototype, zero external deps) + e2e (Playwright E2E, AC-driven) + workflow-orchestrator (product-level workflow orchestration) + workflow-bootstrap (existing project onboarding) + session-handoff (context transfer) + workflow-feedback (issue tracking). 24 skills + 15 agents, one install.",
   "author": {
     "name": "LT"

package/scripts/lib/cmd-deisolate.mjs

@@ -0,0 +1,292 @@
+#!/usr/bin/env node
+// scripts/lib/cmd-deisolate.mjs — worktree deisolation (v0.35.0)
+//
+// 检测 change 的 worktree 状态，输出合并建议或执行合并/清理。
+// 与 ensure-branch.mjs（创建）对称，补全 worktree 生命周期。
+//
+// Usage:
+//   tf deisolate <change-dir>                  # dry-run: 输出状态报告
+//   tf deisolate <change-dir> --merge          # 合并 worktree 分支回 master
+//   tf deisolate <change-dir> --merge --clean  # 合并后删除 worktree + 分支
+//   tf deisolate <change-dir> --clean          # 仅删除 worktree（不合并）
+//
+// 布局识别（对称 ensure-branch.mjs）：
+//   Case A 多仓库工作区：<root>/.worktrees/<change>/<repo>/ 存在
+//   Case B 单仓库：<change-dir> 同级 ../<repo>-<change-name> 存在
+
+import { execFileSync } from 'node:child_process';
+import { existsSync, readdirSync, rmSync } from 'node:fs';
+import { basename, dirname, join, resolve } from 'node:path';
+import { parseArgs } from 'node:util';
+
+export async function run(args) {
+  const { positionals, values } = parseArgs({
+    args,
+    options: {
+      merge: { type: 'boolean', default: false },
+      clean: { type: 'boolean', default: false },
+      'project-root': { type: 'string' },
+      json: { type: 'boolean', default: false },
+      help: { type: 'boolean', default: false },
+    },
+    allowPositionals: true,
+  });
+
+  if (values.help || positionals.length === 0) {
+    printHelp();
+    return;
+  }
+
+  const changeDir = resolve(positionals[0]);
+  const changeName = basename(changeDir);
+
+  // 检测布局
+  const workspaceRoot = detectWorkspaceRoot(changeDir);
+  const caseA = workspaceRoot ? detectCaseA(workspaceRoot, changeName) : null;
+  const caseB = detectCaseB(changeDir, changeName);
+
+  if (!caseA && !caseB) {
+    const msg = `No worktrees found for change '${changeName}'.`;
+    if (values.json) {
+      console.log(JSON.stringify({ found: false, message: msg }));
+    } else {
+      console.log(`✅ ${msg}`);
+    }
+    return;
+  }
+
+  const repos = caseA || caseB;
+  const results = [];
+
+  for (const repo of repos) {
+    const result = processRepo(repo, values);
+    results.push(result);
+  }
+
+  if (values.json) {
+    console.log(JSON.stringify({ found: true, repos: results }, null, 2));
+  } else {
+    printReport(results, values);
+  }
+}
+
+function detectWorkspaceRoot(absChangeDir) {
+  const parent = dirname(absChangeDir);
+  if (basename(parent) !== 'changes') return null;
+  return dirname(parent);
+}
+
+// Case A: <root>/.worktrees/<change>/<repo>/
+function detectCaseA(root, changeName) {
+  const changeWorktreeDir = join(root, '.worktrees', changeName);
+  if (!existsSync(changeWorktreeDir)) return null;
+
+  let entries;
+  try {
+    entries = readdirSync(changeWorktreeDir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+
+  const repos = entries
+    .filter(e => e.isDirectory() && existsSync(join(changeWorktreeDir, e.name, '.git')))
+    .map(e => ({
+      name: e.name,
+      worktreePath: join(changeWorktreeDir, e.name),
+      repoPath: join(root, e.name),
+      layout: 'A',
+    }))
+    .sort((a, b) => a.name.localeCompare(b.name));
+
+  return repos.length > 0 ? repos : null;
+}
+
+// Case B: ../<repo>-<change-name>
+function detectCaseB(changeDir, changeName) {
+  const parentDir = dirname(changeDir);
+  const repoName = basename(changeDir) || 'repo';
+  // 旧 ensure-branch 行为：worktree 在 ../<repo>-<name>
+  // 分支名经过 sanitize，这里用 changeName 作为近似匹配
+  const candidates = [
+    join(parentDir, `${repoName}-${changeName}`),
+    join(parentDir, `${repoName}-${basename(changeDir)}`),
+  ];
+
+  for (const wtPath of candidates) {
+    if (existsSync(join(wtPath, '.git'))) {
+      return [{
+        name: repoName,
+        worktreePath: wtPath,
+        repoPath: changeDir,
+        layout: 'B',
+      }];
+    }
+  }
+  return null;
+}
+
+function processRepo(repo, values) {
+  const result = { name: repo.name, worktreePath: repo.worktreePath, layout: repo.layout };
+
+  // 获取 worktree 分支名
+  let branch = '';
+  try {
+    branch = (execFileSync('git', ['branch', '--show-current'], {
+      encoding: 'utf-8', cwd: repo.worktreePath, stdio: ['ignore', 'pipe', 'pipe'],
+    }) || '').trim();
+  } catch {
+    result.status = 'error';
+    result.message = 'Could not determine worktree branch';
+    return result;
+  }
+  result.branch = branch;
+
+  // 获取相对 master 的 diff
+  const masterBranch = detectMasterBranch(repo.repoPath);
+  try {
+    const ahead = (execFileSync('git', ['rev-list', '--count', `${masterBranch}..${branch}`], {
+      encoding: 'utf-8', cwd: repo.worktreePath, stdio: ['ignore', 'pipe', 'pipe'],
+    }) || '0').trim();
+    const behind = (execFileSync('git', ['rev-list', '--count', `${branch}..${masterBranch}`], {
+      encoding: 'utf-8', cwd: repo.worktreePath, stdio: ['ignore', 'pipe', 'pipe'],
+    }) || '0').trim();
+    result.ahead = parseInt(ahead, 10);
+    result.behind = parseInt(behind, 10);
+  } catch {
+    result.ahead = '?';
+    result.behind = '?';
+  }
+
+  // 检查未提交改动
+  try {
+    const status = execFileSync('git', ['status', '--porcelain'], {
+      encoding: 'utf-8', cwd: repo.worktreePath, stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    result.dirty = status.trim().length > 0;
+  } catch {
+    result.dirty = '?';
+  }
+
+  // 操作
+  if (values.merge) {
+    result.merge = mergeBranch(repo, branch, masterBranch);
+  }
+  if (values.clean) {
+    result.clean = cleanWorktree(repo, branch);
+  }
+
+  result.status = 'ok';
+  return result;
+}
+
+function detectMasterBranch(repoPath) {
+  try {
+    const branch = (execFileSync('git', ['branch', '--show-current'], {
+      encoding: 'utf-8', cwd: repoPath, stdio: ['ignore', 'pipe', 'pipe'],
+    }) || '').trim();
+    if (branch) return branch;
+  } catch { /* ignore */ }
+  // fallback: try master, then main
+  for (const candidate of ['master', 'main']) {
+    try {
+      execFileSync('git', ['rev-parse', `refs/heads/${candidate}`], {
+        encoding: 'utf-8', cwd: repoPath, stdio: ['ignore', 'pipe', 'pipe'],
+      });
+      return candidate;
+    } catch { /* continue */ }
+  }
+  return 'master';
+}
+
+function mergeBranch(repo, branch, masterBranch) {
+  try {
+    const output = execFileSync('git', ['merge', branch, '--no-edit'], {
+      encoding: 'utf-8', cwd: repo.repoPath, stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return { success: true, message: output.trim() };
+  } catch (e) {
+    return { success: false, message: (e.stderr || e.stdout || e.message || '').toString().trim() };
+  }
+}
+
+function cleanWorktree(repo, branch) {
+  const result = { worktreeRemoved: false, branchDeleted: false, errors: [] };
+
+  // Remove worktree
+  try {
+    execFileSync('git', ['worktree', 'remove', repo.worktreePath, '--force'], {
+      encoding: 'utf-8', cwd: repo.repoPath, stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    result.worktreeRemoved = true;
+  } catch (e) {
+    result.errors.push(`worktree remove: ${(e.stderr || e.message || '').toString().trim()}`);
+    // Fallback: rm -rf
+    try {
+      rmSync(repo.worktreePath, { recursive: true, force: true });
+      result.worktreeRemoved = true;
+    } catch (e2) {
+      result.errors.push(`rm fallback: ${e2.message}`);
+    }
+  }
+
+  // Delete branch (skip if merged)
+  try {
+    execFileSync('git', ['branch', '-d', branch], {
+      encoding: 'utf-8', cwd: repo.repoPath, stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    result.branchDeleted = true;
+  } catch {
+    // Branch not merged — use -D only if --force equivalent
+    try {
+      execFileSync('git', ['branch', '-D', branch], {
+        encoding: 'utf-8', cwd: repo.repoPath, stdio: ['ignore', 'pipe', 'pipe'],
+      });
+      result.branchDeleted = true;
+    } catch (e) {
+      result.errors.push(`branch delete: ${(e.stderr || e.message || '').toString().trim()}`);
+    }
+  }
+
+  return result;
+}
+
+function printReport(results, values) {
+  console.log(`\n📦 Worktree Deisolation Report\n`);
+
+  for (const r of results) {
+    console.log(`  Repo: ${r.name} (${r.layout === 'A' ? 'multi-repo' : 'single-repo'})`);
+    console.log(`    Branch: ${r.branch || 'unknown'}`);
+    console.log(`    Worktree: ${r.worktreePath}`);
+    if (r.ahead !== undefined) {
+      console.log(`    Ahead of master: ${r.ahead} commit(s)`);
+      console.log(`    Behind master: ${r.behind} commit(s)`);
+    }
+    console.log(`    Uncommitted changes: ${r.dirty === true ? '⚠️  YES' : r.dirty === false ? 'no' : 'unknown'}`);
+
+    if (r.merge) {
+      console.log(`    Merge: ${r.merge.success ? '✅ ' + r.merge.message : '❌ ' + r.merge.message}`);
+    }
+    if (r.clean) {
+      console.log(`    Worktree removed: ${r.clean.worktreeRemoved ? '✅' : '❌'}`);
+      console.log(`    Branch deleted: ${r.clean.branchDeleted ? '✅' : '❌'}`);
+      if (r.clean.errors.length > 0) {
+        console.log(`    Clean errors: ${r.clean.errors.join('; ')}`);
+      }
+    }
+    console.log();
+  }
+
+  if (!values.merge && !values.clean) {
+    console.log(`  To merge: tf deisolate <change-dir> --merge`);
+    console.log(`  To clean: tf deisolate <change-dir> --merge --clean`);
+  }
+}
+
+function printHelp() {
+  console.log(`Usage:
+  tf deisolate <change-dir>                    # dry-run: show worktree status
+  tf deisolate <change-dir> --merge             # merge worktree branch back to master
+  tf deisolate <change-dir> --merge --clean     # merge + remove worktree + delete branch
+  tf deisolate <change-dir> --clean             # remove worktree only (no merge)
+  tf deisolate <change-dir> --json              # JSON output`);
+}

package/scripts/lib/cmd-execution.mjs

@@ -1,5 +1,5 @@
 import { parseArgs } from 'node:util';
-import { createPlan, describeWaves, EXECUTION_MODES, readPlan, recordReview, validatePlan, writePlan } from './execution-plan.mjs';
+import { createPlan, describeWaves, EXECUTION_MODES, readPlan, recordReview, refreshPlanHash, validatePlan, writePlan } from './execution-plan.mjs';
 import {
   createRecommendationReceipt,
   readCurrentRecommendationReceipt,
@@ -7,7 +7,7 @@ import {
 } from './execution-recommendation.mjs';
 import { readState, writeState } from './state-loader.mjs';
 
-const SUBCOMMANDS = ['recommend', 'plan', 'show', 'revise', 'review'];
+const SUBCOMMANDS = ['recommend', 'plan', 'show', 'revise', 'review', 'refresh-hash'];
 
 export async function run(args) {
   const { positionals, values } = parseArgs({
@@ -52,6 +52,8 @@ export async function run(args) {
       return createAndPrintPlan(changeDir, values, true);
     case 'review':
       return recordAndPrintReview(changeDir, values);
+    case 'refresh-hash':
+      return refreshHash(changeDir, values.json);
   }
 }
 
@@ -203,6 +205,16 @@ function parseTestsStats(values) {
   return parsed;
 }
 
+function refreshHash(changeDir, json) {
+  const result = refreshPlanHash(changeDir);
+  if (!result) {
+    print(json, { refreshed: false }, 'Artifacts hash is already up to date.');
+    return;
+  }
+  print(json, { refreshed: true, artifacts_hash: result.artifacts_hash, contract_hash: result.contract_hash },
+    `Refreshed artifacts hash: ${result.artifacts_hash?.slice(0, 12)}…`);
+}
+
 function requireSafeReason(reason) {
   if (/[\p{Cc}\p{Zl}\p{Zp}]/u.test(reason)) {
     throw new Error('--reason must not contain control characters or line separators');
@@ -225,5 +237,6 @@ function printHelp() {
   tf execution plan <dir> --mode <mode> --confirm --reason <text> --wave <id>:<strategy>:<task,...>[:<depends-on,...>] [--acknowledge-recommendation]
   tf execution show <dir> [--json]
   tf execution revise <dir> --mode sdd --confirm --reason <text> --wave <id>:<strategy>:<task,...>[:<depends-on,...>] [--acknowledge-recommendation]
-  tf execution review <dir> --wave <id> --base <sha> --head <sha> --report <path> --verdict pass|fail [--tests-total N --tests-passed N --tests-failed N]`);
+  tf execution review <dir> --wave <id> --base <sha> --head <sha> --report <path> --verdict pass|fail [--tests-total N --tests-passed N --tests-failed N]
+  tf execution refresh-hash <dir> [--json]   # refresh artifacts/contract hash without bumping revision`);
 }

package/scripts/lib/conventions-generator.mjs

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
-// scripts/lib/conventions-generator.mjs — conventions 生成器（v0.34.0 新增）
+// scripts/lib/conventions-generator.mjs — conventions 生成器（v0.34.0 新增，v0.34.1 工作空间支持）
 //
 // 根据项目技术栈自动生成测试规范 conventions，符合 glaf4-test 要求。
-// 支持存量项目（自动识别）和全新项目（交互式引导）。
+// 支持存量项目（自动识别）、全新项目（交互式引导）和工作空间（多子项目）。
 //
 // 使用方式：
 //   node scripts/lib/conventions-generator.mjs --root <项目根目录> [--interactive]
 //
-// 设计来源：test-capability-enhancement-design v1.0 §四
+// 设计来源：test-capability-enhancement-design v1.0 §四 + §55.4
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from 'node:fs';
 import path, { join } from 'node:path';
@@ -98,6 +98,102 @@ export function detectTechStack(root) {
   return result;
 }
 
+// ── 工作空间扫描 ─────────────────────────────────────────────────────────
+
+/**
+ * 扫描工作空间中的所有子项目
+ * @param {string} root 工作空间根目录
+ * @returns {Array<{ path: string, name: string, techStack: object }>}
+ */
+export function scanSubProjects(root) {
+  const subProjects = [];
+
+  // 扫描一级子目录
+  const entries = readdirSync(root, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+
+    const subProjectPath = join(root, entry.name);
+    const techStack = detectTechStack(subProjectPath);
+
+    // 如果检测到技术栈，记录为子项目
+    if (techStack.language) {
+      subProjects.push({
+        path: subProjectPath,
+        name: entry.name,
+        techStack,
+      });
+    }
+  }
+
+  return subProjects;
+}
+
+/**
+ * 汇总所有子项目的技术栈
+ * @param {Array<{ path: string, name: string, techStack: object }>} subProjects
+ * @returns {{ language: string|null, buildTool: string|null, testFramework: string|null, appFramework: string|null, languages: string[], appFrameworks: string[] }}
+ */
+export function aggregateTechStacks(subProjects) {
+  const languages = new Set();
+  const buildTools = new Set();
+  const testFrameworks = new Set();
+  const appFrameworks = new Set();
+
+  for (const { techStack } of subProjects) {
+    if (techStack.language) languages.add(techStack.language);
+    if (techStack.buildTool) buildTools.add(techStack.buildTool);
+    if (techStack.testFramework) testFrameworks.add(techStack.testFramework);
+    if (techStack.appFramework) appFrameworks.add(techStack.appFramework);
+  }
+
+  return {
+    // 主技术栈（第一个子项目）
+    language: subProjects[0]?.techStack.language || null,
+    buildTool: subProjects[0]?.techStack.buildTool || null,
+    testFramework: subProjects[0]?.techStack.testFramework || null,
+    appFramework: subProjects[0]?.techStack.appFramework || null,
+    // 汇总列表
+    languages: [...languages],
+    appFrameworks: [...appFrameworks],
+  };
+}
+
+/**
+ * 为工作空间选择 conventions 模板
+ * @param {{ languages: string[], appFrameworks: string[] }} aggregatedTechStack
+ * @returns {string[]} 模板文件名列表
+ */
+export function selectTemplatesForWorkspace(aggregatedTechStack) {
+  const templates = [];
+
+  // Java 相关
+  if (aggregatedTechStack.languages.includes('java')) {
+    if (existsSync(join(GLAF4_TEMPLATE_DIR, 'java-testing.md'))) {
+      templates.push('glaf4-compliant/java-testing.md');
+    }
+    if (aggregatedTechStack.appFrameworks.includes('spring-boot')) {
+      if (existsSync(join(GLAF4_TEMPLATE_DIR, 'spring-patterns.md'))) {
+        templates.push('glaf4-compliant/spring-patterns.md');
+      }
+    }
+  }
+
+  // JavaScript 相关
+  if (aggregatedTechStack.languages.includes('javascript')) {
+    templates.push('js-testing.md');
+  }
+
+  // Python 相关
+  if (aggregatedTechStack.languages.includes('python')) {
+    templates.push('python-testing.md');
+  }
+
+  return templates;
+}
+
 // ── 模板选择 ─────────────────────────────────────────────────────────────
 
 /**
@@ -290,54 +386,120 @@ export async function run(args) {
     process.exit(0);
   }
 
-  // 检测技术栈
-  let techStack = detectTechStack(root);
+  // 检测是否为工作空间（包含多个子项目）
+  const subProjects = scanSubProjects(root);
 
-  // 如果未检测到技术栈且启用交互式模式
-  if (!techStack.language && values.interactive) {
-    techStack = await interactiveSetup();
-  }
+  if (subProjects.length > 1) {
+    // 工作空间模式：扫描所有子项目
+    console.log(`\n=== 检测到工作空间（${subProjects.length} 个子项目）===\n`);
 
-  // 如果仍未检测到技术栈
-  if (!techStack.language) {
-    console.error('❌ 未检测到技术栈特征');
-    console.error('   请指定项目根目录，或使用 --interactive 模式手动配置');
-    process.exit(1);
-  }
+    for (const { name, techStack } of subProjects) {
+      console.log(`  - ${name}: ${techStack.language}`);
+    }
 
-  // 选择模板
-  const templates = selectTemplates(techStack);
+    // 汇总技术栈
+    const aggregatedTechStack = aggregateTechStacks(subProjects);
 
-  if (templates.length === 0) {
-    console.error('❌ 未找到匹配的 conventions 模板');
-    console.error(`   技术栈: ${JSON.stringify(techStack)}`);
-    process.exit(1);
-  }
+    // 选择模板
+    const templates = selectTemplatesForWorkspace(aggregatedTechStack);
+
+    if (templates.length === 0) {
+      console.error('❌ 未找到匹配的 conventions 模板');
+      console.error(`   检测到的语言: ${aggregatedTechStack.languages.join(', ')}`);
+      process.exit(1);
+    }
+
+    // 生成 conventions
+    const result = generateConventions(root, aggregatedTechStack, templates);
+
+    // 更新配置
+    updateConfig(root, result.created);
+
+    // 输出结果
+    if (values.json) {
+      console.log(JSON.stringify({
+        ok: true,
+        mode: 'workspace',
+        subProjects: subProjects.map(p => ({ name: p.name, language: p.techStack.language })),
+        aggregatedTechStack: {
+          languages: aggregatedTechStack.languages,
+          appFrameworks: aggregatedTechStack.appFrameworks,
+        },
+        templates,
+        created: result.created,
+        skipped: result.skipped,
+        conventionsDir,
+      }));
+    } else {
+      console.log('\n✅ 工作空间级 conventions 生成完成');
+      console.log(`   检测到的语言：${aggregatedTechStack.languages.join(', ')}`);
+      console.log(`   创建：${result.created.join(', ')}`);
+      if (result.skipped.length > 0) {
+        console.log(`   跳过：${result.skipped.join(', ')}`);
+      }
+      console.log(`   路径：${conventionsDir}`);
+    }
 
-  // 生成 conventions
-  const result = generateConventions(root, techStack, templates);
-
-  // 更新配置
-  updateConfig(root, result.created);
-
-  // 输出结果
-  if (values.json) {
-    console.log(JSON.stringify({
-      ok: true,
-      techStack,
-      templates,
-      created: result.created,
-      skipped: result.skipped,
-      conventionsDir,
-    }));
   } else {
-    console.log('✅ conventions 生成完成');
-    console.log(`   技术栈: ${techStack.language} + ${techStack.testFramework}`);
-    console.log(`   创建: ${result.created.join(', ')}`);
-    if (result.skipped.length > 0) {
-      console.log(`   跳过: ${result.skipped.join(', ')}`);
+    // 单项目模式
+    let techStack;
+
+    if (subProjects.length === 1) {
+      // 从子项目检测
+      techStack = subProjects[0].techStack;
+      console.log(`\n=== 检测到单项目：${subProjects[0].name} ===\n`);
+    } else {
+      // 从根目录检测
+      techStack = detectTechStack(root);
+    }
+
+    // 如果未检测到技术栈且启用交互式模式
+    if (!techStack.language && values.interactive) {
+      techStack = await interactiveSetup();
+    }
+
+    // 如果仍未检测到技术栈
+    if (!techStack.language) {
+      console.error('❌ 未检测到技术栈特征');
+      console.error('   请指定项目根目录，或使用 --interactive 模式手动配置');
+      process.exit(1);
+    }
+
+    // 选择模板
+    const templates = selectTemplates(techStack);
+
+    if (templates.length === 0) {
+      console.error('❌ 未找到匹配的 conventions 模板');
+      console.error(`   技术栈: ${JSON.stringify(techStack)}`);
+      process.exit(1);
+    }
+
+    // 生成 conventions
+    const result = generateConventions(root, techStack, templates);
+
+    // 更新配置
+    updateConfig(root, result.created);
+
+    // 输出结果
+    if (values.json) {
+      console.log(JSON.stringify({
+        ok: true,
+        mode: 'single',
+        techStack,
+        templates,
+        created: result.created,
+        skipped: result.skipped,
+        conventionsDir,
+      }));
+    } else {
+      console.log('✅ conventions 生成完成');
+      console.log(`   技术栈: ${techStack.language} + ${techStack.testFramework}`);
+      console.log(`   创建: ${result.created.join(', ')}`);
+      if (result.skipped.length > 0) {
+        console.log(`   跳过: ${result.skipped.join(', ')}`);
+      }
+      console.log(`   路径: ${conventionsDir}`);
     }
-    console.log(`   路径: ${conventionsDir}`);
   }
 }
 

package/scripts/lib/execution-plan.mjs

@@ -53,9 +53,17 @@ export function writePlan(changeDir, plan) {
   mkdirSync(paths.root, { recursive: true });
   const previousPlan = readPlan(changeDir);
   if (previousPlan && (previousPlan.revision !== plan.revision || previousPlan.hash !== plan.hash)) {
-    // Review evidence is scoped to exactly one plan revision. Removing it on
-    // revision prevents an old wave ID from satisfying a changed plan.
-    rmSync(paths.reviews, { recursive: true, force: true });
+    // v0.35.0: Review receipts are RETAINED across revisions — readCurrentReview
+    // validates plan_hash/plan_revision matching, so stale receipts are
+    // automatically invalidated without losing evidence (base/head/report SHA).
+    // This prevents legitimate artifact updates (e.g., design.md 横展结论) from
+    // causing cascading receipt loss. See workflow-feedback 20260805.
+    //
+    // Recommendation receipt is revision-scoped and must be cleaned:
+    const recommendationFile = paths.executionRecommendation;
+    if (recommendationFile && existsSync(recommendationFile)) {
+      rmSync(recommendationFile, { force: true });
+    }
   }
   atomicWrite(paths.executionPlan, `${JSON.stringify(plan, null, 2)}\n`);
   writeExecutionPlanSummary(changeDir, plan);
@@ -76,10 +84,16 @@ export function validatePlan(changeDir, plan) {
     failures.push('execution plan mode does not match state');
   }
   if (plan?.artifacts_hash !== computeArtifactsHash(changeDir)) {
-    failures.push('execution plan is stale: artifacts hash mismatch');
+    const actual = computeArtifactsHash(changeDir);
+    const planPrefix = plan?.artifacts_hash?.slice(0, 12) ?? 'null';
+    const actualPrefix = actual?.slice(0, 12) ?? 'null';
+    failures.push(`execution plan is stale: artifacts hash mismatch (plan: ${planPrefix}…, current: ${actualPrefix}…)`);
   }
   if (plan?.contract_hash !== computeContractHash(changeDir)) {
-    failures.push('execution plan is stale: contract hash mismatch');
+    const actual = computeContractHash(changeDir);
+    const planPrefix = plan?.contract_hash?.slice(0, 12) ?? 'null';
+    const actualPrefix = actual?.slice(0, 12) ?? 'null';
+    failures.push(`execution plan is stale: contract hash mismatch (plan: ${planPrefix}…, current: ${actualPrefix}…)`);
   }
   if (plan?.workflow !== state.workflow) {
     failures.push('execution plan workflow does not match state');
@@ -442,6 +456,24 @@ function hashPlan(plan) {
   return `sha256:${createHash('sha256').update(stableJson(content)).digest('hex')}`;
 }
 
+/**
+ * v0.35.0: Refresh plan's artifacts_hash and contract_hash without bumping revision.
+ * Returns the updated plan (already persisted via writePlan), or null if no change needed.
+ */
+export function refreshPlanHash(changeDir) {
+  const plan = readPlan(changeDir);
+  if (!plan) return null;
+  const newArtifactsHash = computeArtifactsHash(changeDir);
+  const newContractHash = computeContractHash(changeDir);
+  if (plan.artifacts_hash === newArtifactsHash && plan.contract_hash === newContractHash) {
+    return null; // no change needed
+  }
+  plan.artifacts_hash = newArtifactsHash;
+  plan.contract_hash = newContractHash;
+  plan.hash = hashPlan(plan);
+  return writePlan(changeDir, plan);
+}
+
 function tryHashPlan(plan) {
   if (!isObject(plan)) return null;
   try {

package/scripts/lib/test-merge.mjs

@@ -534,7 +534,10 @@ async function main(argv, projectRoot) {
   console.log(`\n🎉 test-merge complete for ${changeName}`);
 }
 
-main().catch(err => {
-  console.error('test-merge error:', err.message);
-  process.exit(1);
-});
+// 直接运行（v0.35.0 修复：main() 无参自调用崩溃 → 调用 run() 走正确参数解析）
+if (import.meta.url === `file://${process.argv[1]}`) {
+  run(process.argv.slice(2)).catch(err => {
+    console.error('test-merge error:', err.message);
+    process.exit(1);
+  });
+}

package/scripts/team-flow.mjs

@@ -17,6 +17,7 @@ const COMMANDS = {
   checkpoint:     () => import('./lib/cmd-checkpoint.mjs'),
   handoff:        () => import('./lib/cmd-handoff.mjs'),
   isolate:        () => import('./lib/cmd-isolate.mjs'),
+  deisolate:      () => import('./lib/cmd-deisolate.mjs'),
   execution:      () => import('./lib/cmd-execution.mjs'),
   runtime:        () => import('./lib/cmd-runtime.mjs'),
   solutions:      () => import('./lib/cmd-solutions.mjs'),
@@ -88,6 +89,8 @@ Commands:
                         Upgrade inline/batch to SDD, or replan existing SDD waves, as a new revision
   execution review <change-dir> --wave <id> --base <sha> --head <sha> --report <path> --verdict pass|fail
                         Record one review receipt for a planned wave
+  deisolate <change-dir> [--merge] [--clean] [--json]
+                        Show worktree status / merge branch back / clean worktree
   runtime check-update  Run a portable update check for canonical skills
   runtime infer <dir>   Infer workflow mode without a plugin-root path
   runtime guard ...     Run a portable phase-transition guard

package/skills/release-archivist/SKILL.md

@@ -201,6 +201,20 @@ tf solutions capture \
 
 This check is advisory — skip silently if no learnable moments are detected.
 
+### Worktree Deisolation (v0.35.0) — advisory
+
+After compound promotion, check if worktree isolation exists for this change:
+
+```bash
+tf deisolate <change-dir>
+```
+
+If worktrees exist (output shows `found: true` or ahead/behind stats), include the deisolation report in the closing summary. **Do NOT auto-merge** — the orchestrator or user decides the merge strategy. Mark `Worktree deisolation` in the Step 5 report as:
+- `PENDING` — worktrees detected, user action required
+- `N/A` — no worktrees found (single-repo or already cleaned)
+
+This step is advisory — skip silently when `tf deisolate` reports no worktrees.
+
 ### Workflow Feedback Check (v0.16.0)
 
 Before finalizing the closing, ask the user if they encountered any workflow issues during this change:

package/skills/workflow-start/SKILL.md

@@ -61,6 +61,7 @@ Validate mode against artifact content. If hotfix/tweak criteria not met → upg
 产出型路由（spec-writer / contract-builder / build-executor / release-archivist）通过 `Agent(subagent_type: "team-flow:<name>")` **dispatch 子代理**执行——agent 定义经 `skills:` 预加载对应 SKILL.md，主代理**不得**凭记忆手写产物格式 prompt。need-explorer 为交互式澄清，**主进程执行**（需与用户对话；其 agent 定义 `team-flow:need-explorer` 仅作可 dispatch 后备）。
 
 - **记录 agentId**：dispatch 后立即记录子代理 ID；修复一律 SendMessage 恢复原子代理（禁启动新子代理，见 v0.29.0 §37）
+  - **上下文水位例外（v0.35.0）**：当原子代理 transcript 超过 2MB 或累计 token 消耗超过 200 万时，主代理可以启动新代理替代恢复。新代理必须接收完整交接文档（当前进度、已完成 wave 列表、未解决问题、artifact 位置、已知 blocker），以保证连续性。此为 SendMessage 恢复原则的唯一补充例外
 - **返回即验证（validation gate）**：子代理返回产物后**立即** `tf validate <change-dir>`；FAIL → SendMessage 回**原**子代理修复，通过后才能继续/转换。把格式失败拦截在返回时，而非状态转换时（避免浪费整次执行后再失败）。**build-executor 附加验证（v0.13 §52 B3，SDD/full 模式）**：返回的 diff 中必须包含测试文件（src/test/ 或项目测试目录）；零测试文件的实现返回一律 BLOCK，SendMessage 回原子代理按 test-matrix.md / TDD Iron Law 补齐——不得以"手动验证"替代（C1-domain-policy 事件教训）。例外：已显式记录 `test_matrix_skipped=true` + 理由的 change（纯文档/配置类）不要求测试文件
 - **结果协议**：子代理终态须标注 `FINAL VERDICT: <DONE|BLOCKED|FAIL>`（审查类用 PASS/PASS_WITH_WARNINGS/FAIL）；**SendMessage 报告为权威结果**，task-notification.result 仅内部元数据
 - **子代理状态边界**：子代理 MUST NOT 修改 `.team-flow.yaml` 的 `state`/`workflow` 核心字段（状态转换是主代理专有职责，经 `tf state transition` 执行），只写自己的 `dp_N_*` 决策字段

package/skills/workflow-start/references/routing-rules.md

@@ -69,6 +69,7 @@ reviewer 报告 → PASS / PASS_WITH_WARNINGS → 进入 Step 3
 - 重新审查：`SendMessage(to: arch_reviewer_agent_id, message: "第 {N} 轮审查，架构产物已修正。请重新执行 6 维度审查。")`
 - **禁止**在循环中启动新的 architecture-design 或 architecture-reviewer 子代理——原子代理拥有完整的设计上下文和审查历史，新子代理需要重新加载全部上下文（浪费 10-20K tokens 且可能丢失修正连贯性）
 - **唯一例外**：SendMessage 恢复失败（子代理 transcript 不可用）时，启动新子代理作为 fallback，但必须在 dispatch prompt 中传入：原产物路径 + auto-review 报告 + 历次修正记录
+- **上下文水位例外（v0.35.0）**：当原子代理 transcript 超过 2MB 或累计 token 消耗超过 200 万时，主代理可以启动新代理替代恢复。新代理必须接收完整交接文档（当前进度、已完成 wave 列表、未解决问题、artifact 位置、已知 blocker），以保证连续性
 
 报告落盘到 `changes/<name>/architecture/auto-review.md`。