flower-trellis 0.6.10-beta.7 → 0.6.10-beta.9

package/README.md

@@ -100,6 +100,7 @@ flower-trellis -v
 | `trellis` | 项目级关闭、恢复或检查全部平台中的 Trellis 集成 |
 | `self-check` | 输出启动更新检查 JSON,供 Codex / Claude Code hook 和 AI 自动化读取 |
 | `self-update` | 受控升级 flower-trellis 并对目标项目执行完整 `flower-trellis update` 重叠加 |
+| `update-all` | 扫描指定父目录并组合显式项目，批量追平 Flower/Trellis 版本 |
 | `update-check` | 管理 `.flower/settings.json` 内的启动更新策略和提示节流 |
 | `telemetry` | 查询、启用或停用用户级匿名安装遥测 |
 | `plugin` | 管理 Flower Plugin、Marketplace 来源、GitLab 授权和作者校验 |
@@ -116,6 +117,7 @@ flower-trellis -v
 | `--skills <a,b,...>` | 只安装指定技能(可省略 `trellis-` 前缀) |
 | `--variant <old\|0.5\|0.6>` | 强制指定强化包变体(默认按 `.trellis/.version` 自动选) |
 | `--target <dir>` | 目标目录(默认当前目录) |
+| `--root <dir>` | `update-all` 扫描的父目录，可重复传入 |
 | `--no-update-check` | 本次跳过 flower-trellis 新版本检测(等价环境变量 `FLOWER_NO_UPDATE_CHECK=1`) |
 | `--backup-retention <n>` | `update` 成功后保留最近 n 份 `.trellis/.backup-<timestamp>` 快照(默认 1，`0` 表示本次不清理) |
 
@@ -363,6 +365,15 @@ flower-trellis self-update --target . --dry-run
 flower-trellis self-update --target . --yes
 ```
 
+批量更新集中目录和零散项目时，可重复组合 `--root` 与 `--target`，真实路径会去重：
+
+```bash
+flower-trellis update-all --root ~/projects --target /work/other-project --dry-run
+flower-trellis update-all --root ~/projects --target /work/other-project --yes
+```
+
+`--dry-run` 只读列出各项目预检结果，不安装 CLI，也不写项目或更新缓存；真实执行必须加 `--yes`。命令先检查每个项目的 Git clean 状态、活动任务和版本证据；脏工作区、活动任务及无法安全比较版本的项目会跳过并标明原因。远端版本无法确认时只追平到本机已安装版本。全局 Flower CLI 最多安装一次，随后按项目顺序执行完整 `update`；某项目失败仍继续后续项目。末尾汇总逐项结果，有跳过或失败时退出码为 `1`。命令不修改应用版本，也不自动提交或推送；更新后需按各 Git 仓库分别确认变更。
+
 项目重叠加阶段默认等价于 Trellis 交互里的 **Apply Overwrite to all**:
 
 ```bash

package/enhancements/0.6/.agents/skills/trellis-task-brief/SKILL.md

@@ -18,7 +18,8 @@ description: "从最新 prd.md、design.md、implement.md 生成、刷新、校
 - 每次运行都重新读取最新 `prd.md`、`design.md if present`、`implement.md if present`。
 - 已存在的 `brief.md` 不能作为跳过同步的理由。
 - `brief.md` 必须以三件套为准覆盖旧内容；无法从三件套追溯的旧内容不能保留为事实。
-- 不要在 `brief.md` 里发明三件套没有表达的新需求。必填字段缺失时写“未明确”，并提示应补充三件套；没有相关内容时直接省略 `Risks / Deferred` 整节。
+- 不要在 `brief.md` 里发明三件套没有表达的新需求。必填字段缺失时写“未明确”，并提示应补充三件套；没有明确技术机制时省略 `Technical Overview`，没有具体风险时省略 `Risks`。
+- `Goal` 保持一句话，`Scope` 只写本轮纳入的行为或改动对象；延期事项归入 `Non-Goals`，不另设栏目，也不把范围、方案和验收写成同义复述。
 - 写回 `brief.md` 后，必须在当前对话中展示 brief 正文；不要只给文件路径。
 - Phase 1.4 前必须展示完整 brief。除上方经 runner 校验的 Auto-Loop Action 例外外，默认等待用户确认后再运行 `task.py start`；只有用户明确把当前任务或最终 Brief 与“展示后直接开始 / 不用再次确认 / 视为已确认”绑定时，才可在范围未变化的前提下免除第二次确认。
 - “开始做吧”“按你建议来”“可以创建任务”等普通实现或建任务意图不是 Brief 预授权，不能据此跳过确认。
@@ -45,12 +46,12 @@ description: "从最新 prd.md、design.md、implement.md 生成、刷新、校
    - 若最终内容扩大范围、仍有未解决 Open Questions，或新增权限、安全、隐私、生产、费用、真实数据、破坏性公开契约、外部系统边界，则预授权失效。
 5. 从最新三件套提取：
    - `Goal`：任务目标一句话。
-   - `Scope`：本轮实现范围。
-   - `Non-Goals`：明确不做的范围。
-   - `Key Decisions`：已经收敛、存在实质方案分叉且会改变产品行为、范围、UX、兼容性、风险或核心架构的决定；只提炼最终选择及其影响，不复制完整决策台账。
-   - `Key Context`：关键文件、模块、入口和约束。
-   - `Risks / Deferred`：仍需在实现或验证中关注的风险，以及明确延后的事项；没有内容时不生成该 section。
-   - `Acceptance`：主要验收标准。
+   - `Scope`：本轮纳入的行为或改动对象；不重复技术原理、取舍或验收。
+   - `Non-Goals`：明确不做或延后的范围。
+   - `Technical Overview`：来源材料已明确技术机制时，简述触发入口、主要处理或数据流、关键校验或状态变化及结果；不复制完整设计或实施步骤，没有依据时省略整节。
+   - `Context & Decisions`：影响实施判断的既有事实、关键文件或模块、入口、硬约束，以及已收敛且会改变产品行为、范围、UX、兼容性、风险或核心架构的取舍及原因；不复制完整决策台账，也不重复概览中的流程。
+   - `Risks`：仍需在实现或验证中关注的具体风险；没有内容时省略整节。
+   - `Acceptance`：主要可验证的验收标准；负向范围声明仅在需要回归验证时保留。
    - `Next Step`：只写进入下一阶段后的一个直接动作，不展开完整实施计划。
 6. 写回 `<task>/brief.md`。如果文件已存在，仍用最新三件套派生内容覆盖旧正文。
 7. 在对话中展示 brief 正文，并说明来源文件：
@@ -69,23 +70,23 @@ description: "从最新 prd.md、design.md、implement.md 生成、刷新、校
 
 ## Scope
 
-- <本轮要做的事情>
+- <本轮纳入的行为或改动对象，不复述原理、取舍或验收>
 
 ## Non-Goals
 
-- <本轮明确不做的事情>
+- <本轮明确不做或延后的事情>
 
-## Key Decisions
+## Technical Overview
 
-- <已经收敛且影响实施批准的关键决定>
+- <仅在规划材料明确技术机制时，概述入口、处理流、关键校验和结果；否则省略整节>
 
-## Key Context
+## Context & Decisions
 
-- <关键文件、模块、入口和约束>
+- <影响实施的既有事实、入口、约束，以及关键取舍与原因，不复述流程>
 
-## Risks / Deferred
+## Risks
 
-- <仅在存在相关风险或明确延后事项时生成；否则省略整个 section>
+- <仅在存在具体风险时生成；否则省略整个 section>
 
 ## Acceptance
 
@@ -118,7 +119,7 @@ Phase 1.4 review 前：
 已按你对当前 Brief 的明确预授权完成复核；范围未扩大、无未解决问题，继续启动任务。
 ```
 
-规划评审或用户明确要求查看时，完整展示 `brief.md` 正文，不压缩、不摘录、不改写字段结构，保留 Non-Goals、关键决定和验收条件。
+规划评审或用户明确要求查看时，完整展示 `brief.md` 正文，不压缩、不摘录、不改写字段结构，保留 Non-Goals、技术概览（若有）、关键决定和验收条件。
 
 ## 不要做
 

package/enhancements/0.6/.claude/skills/trellis-task-brief/SKILL.md

@@ -18,7 +18,8 @@ description: "从最新 prd.md、design.md、implement.md 生成、刷新、校
 - 每次运行都重新读取最新 `prd.md`、`design.md if present`、`implement.md if present`。
 - 已存在的 `brief.md` 不能作为跳过同步的理由。
 - `brief.md` 必须以三件套为准覆盖旧内容；无法从三件套追溯的旧内容不能保留为事实。
-- 不要在 `brief.md` 里发明三件套没有表达的新需求。必填字段缺失时写“未明确”，并提示应补充三件套；没有相关内容时直接省略 `Risks / Deferred` 整节。
+- 不要在 `brief.md` 里发明三件套没有表达的新需求。必填字段缺失时写“未明确”，并提示应补充三件套；没有明确技术机制时省略 `Technical Overview`，没有具体风险时省略 `Risks`。
+- `Goal` 保持一句话，`Scope` 只写本轮纳入的行为或改动对象；延期事项归入 `Non-Goals`，不另设栏目，也不把范围、方案和验收写成同义复述。
 - 写回 `brief.md` 后，必须在当前对话中展示 brief 正文；不要只给文件路径。
 - Phase 1.4 前必须展示完整 brief。除上方经 runner 校验的 Auto-Loop Action 例外外，默认等待用户确认后再运行 `task.py start`；只有用户明确把当前任务或最终 Brief 与“展示后直接开始 / 不用再次确认 / 视为已确认”绑定时，才可在范围未变化的前提下免除第二次确认。
 - “开始做吧”“按你建议来”“可以创建任务”等普通实现或建任务意图不是 Brief 预授权，不能据此跳过确认。
@@ -45,12 +46,12 @@ description: "从最新 prd.md、design.md、implement.md 生成、刷新、校
    - 若最终内容扩大范围、仍有未解决 Open Questions，或新增权限、安全、隐私、生产、费用、真实数据、破坏性公开契约、外部系统边界，则预授权失效。
 5. 从最新三件套提取：
    - `Goal`：任务目标一句话。
-   - `Scope`：本轮实现范围。
-   - `Non-Goals`：明确不做的范围。
-   - `Key Decisions`：已经收敛、存在实质方案分叉且会改变产品行为、范围、UX、兼容性、风险或核心架构的决定；只提炼最终选择及其影响，不复制完整决策台账。
-   - `Key Context`：关键文件、模块、入口和约束。
-   - `Risks / Deferred`：仍需在实现或验证中关注的风险，以及明确延后的事项；没有内容时不生成该 section。
-   - `Acceptance`：主要验收标准。
+   - `Scope`：本轮纳入的行为或改动对象；不重复技术原理、取舍或验收。
+   - `Non-Goals`：明确不做或延后的范围。
+   - `Technical Overview`：来源材料已明确技术机制时，简述触发入口、主要处理或数据流、关键校验或状态变化及结果；不复制完整设计或实施步骤，没有依据时省略整节。
+   - `Context & Decisions`：影响实施判断的既有事实、关键文件或模块、入口、硬约束，以及已收敛且会改变产品行为、范围、UX、兼容性、风险或核心架构的取舍及原因；不复制完整决策台账，也不重复概览中的流程。
+   - `Risks`：仍需在实现或验证中关注的具体风险；没有内容时省略整节。
+   - `Acceptance`：主要可验证的验收标准；负向范围声明仅在需要回归验证时保留。
    - `Next Step`：只写进入下一阶段后的一个直接动作，不展开完整实施计划。
 6. 写回 `<task>/brief.md`。如果文件已存在，仍用最新三件套派生内容覆盖旧正文。
 7. 在对话中展示 brief 正文，并说明来源文件：
@@ -69,23 +70,23 @@ description: "从最新 prd.md、design.md、implement.md 生成、刷新、校
 
 ## Scope
 
-- <本轮要做的事情>
+- <本轮纳入的行为或改动对象，不复述原理、取舍或验收>
 
 ## Non-Goals
 
-- <本轮明确不做的事情>
+- <本轮明确不做或延后的事情>
 
-## Key Decisions
+## Technical Overview
 
-- <已经收敛且影响实施批准的关键决定>
+- <仅在规划材料明确技术机制时，概述入口、处理流、关键校验和结果；否则省略整节>
 
-## Key Context
+## Context & Decisions
 
-- <关键文件、模块、入口和约束>
+- <影响实施的既有事实、入口、约束，以及关键取舍与原因，不复述流程>
 
-## Risks / Deferred
+## Risks
 
-- <仅在存在相关风险或明确延后事项时生成；否则省略整个 section>
+- <仅在存在具体风险时生成；否则省略整个 section>
 
 ## Acceptance
 
@@ -118,7 +119,7 @@ Phase 1.4 review 前：
 已按你对当前 Brief 的明确预授权完成复核；范围未扩大、无未解决问题，继续启动任务。
 ```
 
-规划评审或用户明确要求查看时，完整展示 `brief.md` 正文，不压缩、不摘录、不改写字段结构，保留 Non-Goals、关键决定和验收条件。
+规划评审或用户明确要求查看时，完整展示 `brief.md` 正文，不压缩、不摘录、不改写字段结构，保留 Non-Goals、技术概览（若有）、关键决定和验收条件。
 
 ## 不要做
 

package/enhancements/0.6/overrides/conflicts.json

@@ -138,7 +138,7 @@
           "## Planning Handoff",
           "<!-- BEGIN skill-garden patch brainstorm-planning-readiness v0.6 -->\n8. Load `trellis-task-brief`",
           "Only valid explicit preauthorization for the current final Brief, as defined by `trellis-task-brief`, permits same-turn start within unchanged scope.",
-          "The final Brief must cover Goal, Scope, Non-Goals, Key Decisions, Key Context, Acceptance, one-hop Next Step",
+          "The final Brief must cover a one-sentence Goal, a Scope limited to included changes, Non-Goals, Context & Decisions, Acceptance, and one-hop Next Step",
           "Ordinary implementation intent expressed before the final artifacts and full Brief are shown authorizes planning only",
           "unresolved items are `- [ ]`",
           "Do not write bare placeholders"
@@ -162,7 +162,7 @@
           "## Planning Handoff",
           "<!-- BEGIN skill-garden patch brainstorm-planning-readiness v0.6 -->\n8. Load `trellis-task-brief`",
           "Only valid explicit preauthorization for the current final Brief, as defined by `trellis-task-brief`, permits same-turn start within unchanged scope.",
-          "The final Brief must cover Goal, Scope, Non-Goals, Key Decisions, Key Context, Acceptance, one-hop Next Step",
+          "The final Brief must cover a one-sentence Goal, a Scope limited to included changes, Non-Goals, Context & Decisions, Acceptance, and one-hop Next Step",
           "Ordinary implementation intent expressed before the final artifacts and full Brief are shown authorizes planning only",
           "unresolved items are `- [ ]`",
           "Do not write bare placeholders"

package/enhancements/0.6/overrides/patches/skills/trellis-brainstorm/planning-handoff/summary-shape-content.md

@@ -1 +1 @@
-The final Brief must cover Goal, Scope, Non-Goals, Key Decisions, Key Context, Acceptance, one-hop Next Step, and relevant Risks / Deferred items.
+The final Brief must cover a one-sentence Goal, a Scope limited to included changes, Non-Goals, Context & Decisions, Acceptance, and one-hop Next Step; include Technical Overview only when the planning artifacts define a technical mechanism, and Risks only when relevant.

package/enhancements/MANIFEST.json

@@ -1,7 +1,7 @@
 {
-  "syncedAt": "2026-09-26T04:08:42.758Z",
+  "syncedAt": "2026-09-28T00:53:21.902Z",
   "syncedFrom": "vendor/skill-garden",
-  "sourceCommit": "eb848932da1890aaf66804b69c483072b1685b05",
+  "sourceCommit": "410f810c389bd60fcaf237b05dd4cfde8ee15b36",
   "common": {
     "codexSkills": [
       "aliyun-ops",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flower-trellis",
-  "version": "0.6.10-beta.7",
+  "version": "0.6.10-beta.9",
   "description": "一键安装/升级 Trellis 并自动融合 skill-garden 强化包(默认 Claude + agents)",
   "type": "module",
   "bin": {
@@ -70,9 +70,9 @@
     "commit-and-tag-version": "^12.7.3"
   },
   "flowerReleaseNotes": {
-    "version": "0.6.10-beta.7",
+    "version": "0.6.10-beta.9",
     "source": "CHANGELOG.md",
-    "body": "### ✨ 新功能 Features\n\n* **flower:** 支持自动 GC 提交默认放行 ([79ef652](https://github.com/SilentFlower/flower-trellis/commit/79ef652abf793c4b84e8b5150b4808be02ad3eec))\n* **flower:** 默认只保留一份升级备份并支持 Sol 提示 ([7704dc9](https://github.com/SilentFlower/flower-trellis/commit/7704dc9e190abc5d6e57de517e2dfc0ec31cbbae))",
+    "body": "### ✨ 新功能 Features\n\n* **flower:** 支持批量更新多个项目 ([ef32c2e](https://github.com/SilentFlower/flower-trellis/commit/ef32c2e47dcf326c83aceb67549e3374fc68fa01))",
     "truncated": false
   },
   "optionalDependencies": {

package/src/cli.js

@@ -78,6 +78,7 @@ function printHelp() {
   flower-trellis self-check --json [--manual] [--target <dir>]
                                                         输出启动更新检查 JSON
   flower-trellis self-update --target <dir> --yes        自更新 + 项目重叠加
+  flower-trellis update-all --root <dir> --target <dir>   批量发现并更新多个项目
   flower-trellis update-check <get|set|disable|enable|snooze|skip|reset>
                                                         管理启动更新策略
   flower-trellis telemetry <status|enable|disable>       管理匿名安装遥测
@@ -98,6 +99,7 @@ flower 自有 flag:
   --skills <a,b,...>       只装指定技能(支持去 trellis- 前缀匹配)
   --variant <old|0.5|0.6>  强制强化包变体(默认按 .trellis/.version 自动选)
   --target <dir>           目标目录(默认当前目录)
+  --root <dir>             update-all 扫描目录(可重复)
   --no-update-check        本次跳过 flower-trellis 新版本检测(等价 FLOWER_NO_UPDATE_CHECK=1)
   --backup-retention <n>   update 成功后保留最近 n 份升级备份(默认 ${DEFAULT_UPDATE_BACKUP_RETENTION},0=不清理)
 
@@ -172,6 +174,10 @@ async function main() {
     } else if (cmd === "self-update") {
       const { selfUpdate } = await import("./commands/self-update.js");
       await selfUpdate(ctx);
+    } else if (cmd === "update-all") {
+      const { updateAll } = await import("./commands/update-all.js");
+      const code = await updateAll(ctx);
+      if (code !== 0) process.exitCode = code;
     } else if (cmd === "update-check") {
       const { updateCheck } = await import("./commands/update-check.js");
       await updateCheck(ctx);

package/src/commands/update-all.js

@@ -0,0 +1,289 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { hasHelpFlag } from "../lib/cli-args.js";
+import { gitSafety } from "../lib/self-check.js";
+import { readProjectVersions } from "../lib/telemetry-context.js";
+import {
+  compareVersions,
+  fetchPackageDistTags,
+  getUpdateRecommendation,
+  installFlowerVersion,
+} from "../lib/update-check.js";
+import { ProjectStore } from "../plugin/state/project-store.js";
+import { discoverFlowerProjects, gitRepositoryRoot, projectTaskSafety } from "../lib/update-all-projects.js";
+import { flowerVersion, trellisVersion } from "../lib/versions.js";
+
+/** 打印批量更新命令帮助。 */
+function printUpdateAllHelp() {
+  console.log(`flower-trellis update-all — 批量更新多个 Flower 项目
+
+用法:
+  flower-trellis update-all --root <dir> [--root <dir>...] --dry-run
+  flower-trellis update-all --target <dir> [--target <dir>...] --yes
+  flower-trellis update-all --root <dir> --target <dir> --yes
+
+选项:
+  --root <dir>       扫描指定父目录，可重复
+  --target <dir>     指定已安装 Flower 的项目，可重复
+  --dry-run          只读预览，不安装 CLI 或修改项目与缓存
+  -y, --yes          确认真实更新
+  --no-update-check  不查询远端，仅追平已安装的 Flower/Trellis 版本
+
+脏 Git 工作区、活动任务和版本证据缺失的项目会跳过；有跳过或失败时退出码为 1。
+远端无法确认时仅使用本机版本。项目更新后需分别确认 Git 变更，本命令不提交或推送。`);
+}
+
+/** 定位 npm 全局安装的入口，保证后续子进程确实使用安装后的包。 */
+function installedCliScript() {
+  const result = spawnSync("npm", ["root", "-g"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    shell: process.platform === "win32",
+  });
+  if (result.error || result.status !== 0) {
+    throw new Error(`无法定位 npm 全局目录(${result.error?.message || result.stderr?.trim() || `退出码 ${result.status ?? 1}`})`);
+  }
+  const script = path.join(String(result.stdout).trim(), "flower-trellis", "bin", "flower-trellis.js");
+  if (!fs.existsSync(script)) throw new Error(`全局 Flower CLI 不存在: ${script}`);
+  return script;
+}
+
+/** 通过 Node 参数数组启动已安装 CLI，路径不交给 shell 拼接。 */
+function runInstalledCli(script, args, options = {}) {
+  return spawnSync(process.execPath, [script, ...args], {
+    cwd: options.cwd,
+    env: { ...process.env, FLOWER_NO_UPDATE_CHECK: "1", ...options.env },
+    encoding: options.capture ? "utf8" : undefined,
+    stdio: options.capture ? ["ignore", "pipe", "pipe"] : "inherit",
+  });
+}
+
+/** 从新进程读取实际 CLI 版本，避免全局安装后继续信任旧模块缓存。 */
+function inspectInstalledCli() {
+  const script = installedCliScript();
+  const packageRoot = path.dirname(path.dirname(script));
+  const result = runInstalledCli(script, ["self-check", "--json", "--target", packageRoot, "--no-update-check"], {
+    cwd: packageRoot,
+    capture: true,
+    env: { FLOWER_NO_TELEMETRY: "1" },
+  });
+  if (result.error || result.status !== 0) {
+    throw new Error(`已安装 CLI 版本核对失败(${result.error?.message || result.stderr?.trim() || `退出码 ${result.status ?? 1}`})`);
+  }
+  try {
+    const current = JSON.parse(result.stdout).current;
+    if (!current?.flowerVersion || !current?.bundledTrellisVersion) throw new Error("缺少版本字段");
+    return { flower: current.flowerVersion, trellis: current.bundledTrellisVersion, script };
+  } catch (error) {
+    throw new Error(`已安装 CLI 版本结果无效(${error.message})`);
+  }
+}
+
+/** 使用已安装 CLI 完整更新一个项目。 */
+function runProjectUpdate(target, installed) {
+  return runInstalledCli(installed.script, ["update", "--target", target, "--no-update-check", "--force", "-y"], { cwd: target });
+}
+
+/** 将子进程失败转换为可读原因。 */
+function processFailure(result) {
+  return result?.error?.message || `退出码 ${result?.status ?? 1}`;
+}
+
+/** 防止把已安装版本较新的项目降级，或把无法比较的版本误判为相同。 */
+function versionBlockReason(project, desired) {
+  for (const key of ["flower", "trellis"]) {
+    const relation = compareVersions(project[key], desired[key]);
+    if (relation === 1) return `${key} 项目版本高于目标版本(${project[key]} > ${desired[key]})`;
+    if (relation === 0 && project[key] !== desired[key]) {
+      return `${key} 版本无法比较(${project[key]} / ${desired[key]})`;
+    }
+  }
+  return null;
+}
+
+/** 校验现代 Plugin 状态后读取项目版本，避免旧 manifest 掩盖损坏状态。 */
+function readValidatedProjectVersions(target) {
+  const store = new ProjectStore(target);
+  store.readLock();
+  store.readState();
+  return readProjectVersions(target);
+}
+
+/** 输出逐项目状态和计数；结果块供 AI 接续独立 Git 确认。 */
+function printResult(rows, options, log) {
+  const labels = {
+    planned: "待更新",
+    updated: "已更新",
+    up_to_date: "已是最新版",
+    skipped: "跳过",
+    failed: "失败",
+  };
+  for (const row of rows) {
+    const prefix = row.status === "updated" ? "  ✓ " : "  · ";
+    log(`${prefix}${labels[row.status]}: ${row.target}${row.reason ? ` (${row.reason})` : ""}`);
+  }
+  const counts = Object.fromEntries(Object.keys(labels).map((status) => [status, rows.filter((row) => row.status === status).length]));
+  log(`  · 汇总: 待更新 ${counts.planned}，已更新 ${counts.updated}，已是最新版 ${counts.up_to_date}，跳过 ${counts.skipped}，失败 ${counts.failed}`);
+  if (options.dryRun) {
+    log("  · 写入:否");
+    return;
+  }
+  const attempted = rows.filter((row) => row.attempted);
+  if (attempted.length > 0) {
+    log("<flower-update-result>");
+    log(`status: ${counts.failed || counts.skipped ? "partial" : "completed"}`);
+    log(`updated_targets: ${JSON.stringify(rows.filter((row) => row.status === "updated").map((row) => row.target))}`);
+    log(`attempted_targets: ${JSON.stringify(attempted.map((row) => row.target))}`);
+    log("post_action: run_trellis_push_confirmation");
+    log("ai_instruction: 各项目按所属 Git 仓库分别加载并遵循 trellis-push，展示精确文件范围和提交信息，等待确认；不要自动提交或推送。");
+    log("</flower-update-result>");
+  }
+}
+
+/**
+ * 批量更新显式指定或在根目录发现的 Flower 项目。
+ * @param {object} ctx CLI 解析上下文
+ * @param {{fetchTags?:Function,install?:Function,inspectCli?:Function,updateProject?:Function,log?:Function}} [options] 测试替身
+ * @returns {Promise<number>} 0 表示全部完成，1 表示存在未完成项目
+ */
+export async function updateAll(ctx, options = {}) {
+  if (hasHelpFlag(ctx.passthrough)) {
+    printUpdateAllHelp();
+    return 0;
+  }
+  const flags = ctx.passthrough;
+  const unknown = flags.filter((arg) => !["--dry-run", "--yes", "-y"].includes(arg));
+  if (unknown.length || ctx.forwarded?.length) {
+    throw new Error(`update-all 不支持参数: ${[...unknown, ...(ctx.forwarded || [])].join(" ")}`);
+  }
+  const dryRun = flags.includes("--dry-run");
+  if (!dryRun && !flags.includes("--yes") && !flags.includes("-y")) {
+    throw new Error("update-all 执行写入前需要 --yes；如需预览请使用 --dry-run");
+  }
+  if (!ctx.roots.length && !ctx.targets.length) {
+    throw new Error("update-all 至少需要一个 --root 或 --target");
+  }
+
+  const log = options.log || console.log;
+  const { projects, errors } = discoverFlowerProjects(ctx.roots, ctx.targets);
+  const rows = errors.map(({ target, reason }) => ({ target, status: "failed", reason }));
+  if (!projects.length && !errors.length) {
+    rows.push({ target: ctx.roots.join(", "), status: "failed", reason: "未发现已安装 Flower 的项目" });
+  }
+  const gitChecks = new Map();
+  for (const target of projects) {
+    const gitRoot = gitRepositoryRoot(target);
+    if (!gitRoot) {
+      rows.push({ target, status: "skipped", reason: "不是 Git 工作区" });
+      continue;
+    }
+    if (!gitChecks.has(gitRoot)) gitChecks.set(gitRoot, gitSafety(gitRoot));
+    const git = gitChecks.get(gitRoot);
+    if (!git.clean) {
+      rows.push({ target, status: "skipped", reason: git.reason === "dirty_worktree" ? `Git 工作区有 ${git.dirtyCount} 项变动` : `Git 检查失败(${git.reason})` });
+      continue;
+    }
+    const taskSafety = projectTaskSafety(target);
+    if (!taskSafety.safe) {
+      rows.push({ target, status: "skipped", reason: taskSafety.reason });
+      continue;
+    }
+    try {
+      const version = readValidatedProjectVersions(target);
+      if (!version.flower || !version.trellis) {
+        rows.push({ target, status: "skipped", reason: "Flower/Trellis 项目版本证据缺失" });
+        continue;
+      }
+      rows.push({ target, status: "candidate", version });
+    } catch (error) {
+      rows.push({ target, status: "skipped", reason: `读取项目版本失败(${error.message})` });
+    }
+  }
+
+  const local = { flower: flowerVersion(), trellis: trellisVersion() };
+  let tags = null;
+  if (projects.length && ctx.updateCheck !== false && !process.env.FLOWER_NO_UPDATE_CHECK) {
+    try {
+      tags = await (options.fetchTags || fetchPackageDistTags)();
+    } catch {
+      tags = null;
+    }
+  }
+  const recommendation = getUpdateRecommendation(local.flower, tags);
+  const desiredFlower = recommendation?.version || local.flower;
+  log(`update-all ${dryRun ? "dry-run" : "执行"}:`);
+  log(`  · 远端版本: ${tags ? `已确认(${recommendation ? recommendation.version : "无更新"})` : "未确认，仅使用本机版本"}`);
+  log(`  · 目标 Flower: ${desiredFlower}`);
+  log(`  · 目标 Trellis: ${recommendation ? "安装新版 CLI 后核对" : local.trellis}`);
+  if (recommendation) log(`  · 全局升级: ${recommendation.command}`);
+
+  for (const row of rows) {
+    if (row.status !== "candidate") continue;
+    const reason = versionBlockReason(row.version, { flower: desiredFlower, trellis: recommendation ? row.version.trellis : local.trellis });
+    if (reason) {
+      row.status = "skipped";
+      row.reason = reason;
+    } else if (recommendation || row.version.flower !== local.flower || row.version.trellis !== local.trellis) {
+      row.status = "planned";
+    } else {
+      row.status = "up_to_date";
+    }
+  }
+
+  if (!dryRun && rows.some((row) => row.status === "planned")) {
+    let installed = local;
+    const firstPlanned = rows.find((row) => row.status === "planned").target;
+    try {
+      if (recommendation) {
+        log("  · 正在安装 Flower 新版本");
+        const result = (options.install || installFlowerVersion)(recommendation.version, { cwd: firstPlanned });
+        if (result?.status !== 0) throw new Error(`全局安装失败(${processFailure(result)})`);
+      }
+      installed = (options.inspectCli || inspectInstalledCli)();
+      if (installed.flower !== desiredFlower || !installed.trellis || installed.trellis === "(未安装)") {
+        throw new Error(`已安装 CLI 版本不符(Flower ${installed.flower || "unknown"}，Trellis ${installed.trellis || "unknown"})`);
+      }
+    } catch (error) {
+      for (const row of rows) {
+        if (row.status === "planned") {
+          row.status = "failed";
+          row.reason = error.message;
+        }
+      }
+      printResult(rows, { dryRun }, log);
+      return 1;
+    }
+
+    for (const row of rows) {
+      if (row.status !== "planned") continue;
+      const reason = versionBlockReason(row.version, installed);
+      if (reason) {
+        row.status = "skipped";
+        row.reason = reason;
+        continue;
+      }
+      if (row.version.flower === installed.flower && row.version.trellis === installed.trellis) {
+        row.status = "up_to_date";
+        continue;
+      }
+      log(`  · 正在更新: ${row.target}`);
+      row.attempted = true;
+      try {
+        const result = (options.updateProject || runProjectUpdate)(row.target, installed);
+        if (result?.status !== 0) throw new Error(processFailure(result));
+        const actual = readValidatedProjectVersions(row.target);
+        if (actual.flower !== installed.flower || actual.trellis !== installed.trellis) {
+          throw new Error(`更新后版本未追平(Flower ${actual.flower || "unknown"}，Trellis ${actual.trellis || "unknown"})`);
+        }
+        row.status = "updated";
+      } catch (error) {
+        row.status = "failed";
+        row.reason = `项目更新失败(${error.message})`;
+      }
+    }
+  }
+
+  printResult(rows, { dryRun }, log);
+  return rows.some((row) => row.status === "failed" || row.status === "skipped") || projects.length === 0 ? 1 : 0;
+}

package/src/constants.js

@@ -108,6 +108,7 @@ export const OWN_FLAGS = {
   "--skills": true,
   "--variant": true,
   "--target": true,
+  "--root": true,
   "--no-update-check": false,
   "--backup-retention": true,
 };

package/src/lib/cli-args.js

@@ -25,6 +25,8 @@ export function parseCliArgs(argv, cwd = process.cwd()) {
   let variant = null;
   let target = cwd;
   let targetExplicit = false;
+  const targets = [];
+  const roots = [];
   let updateCheck = true;
   let backupRetention = DEFAULT_UPDATE_BACKUP_RETENTION;
   const skills = [];
@@ -60,10 +62,26 @@ export function parseCliArgs(argv, cwd = process.cwd()) {
       case "--variant":
         variant = argv[++i] || null;
         break;
-      case "--target":
+      case "--target": {
+        const value = argv[i + 1];
+        if (command === "update-all" && (!value || value.startsWith("-"))) {
+          targets.push(null);
+          break;
+        }
         target = path.resolve(cwd, argv[++i] || ".");
         targetExplicit = true;
+        if (command === "update-all") targets.push(target);
         break;
+      }
+      case "--root": {
+        if (command !== "update-all") {
+          passthrough.push(a);
+          break;
+        }
+        const value = argv[i + 1];
+        roots.push(!value || value.startsWith("-") ? null : path.resolve(cwd, argv[++i]));
+        break;
+      }
       case "--no-update-check":
         updateCheck = false;
         break;
@@ -88,6 +106,8 @@ export function parseCliArgs(argv, cwd = process.cwd()) {
     ctx: {
       target: path.resolve(target),
       targetExplicit,
+      targets,
+      roots,
       passthrough,
       enhance,
       enhanceOnly,

package/src/lib/self-check.js

@@ -124,11 +124,16 @@ async function fetchMissingReleaseNotes(target, projectEvidence, writeCache, ran
   return releaseNotes;
 }
 
-/** 检查目标目录 git 工作区是否 clean。 */
-function gitSafety(target) {
+/**
+ * 检查目标目录 Git 工作区是否干净。
+ * @param {string} target 目标目录
+ * @returns {{clean:boolean,reason:string|null,dirtyCount?:number}} 检查结果
+ */
+export function gitSafety(target) {
   const common = {
     cwd: target,
     encoding: "utf8",
+    env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" },
     shell: process.platform === "win32",
     stdio: ["ignore", "pipe", "pipe"],
     timeout: 1500,
@@ -147,8 +152,12 @@ function gitSafety(target) {
     : { clean: true, reason: null, dirtyCount: 0 };
 }
 
-/** 递归查找 active / in_progress Trellis 任务。 */
-function hasActiveTask(target) {
+/**
+ * 查找 active 或 in_progress 的 Trellis 任务。
+ * @param {string} target 项目根目录
+ * @returns {boolean} 是否存在活动任务
+ */
+export function hasActiveTask(target) {
   const tasksDir = path.join(target, ".trellis", "tasks");
   const stack = [tasksDir];
   while (stack.length) {

package/src/lib/update-all-projects.js

@@ -0,0 +1,160 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+
+const SKIP_DIRECTORIES = new Set([".git", ".trellis", ".flower", "node_modules"]);
+const INACTIVE_TASK_STATUSES = new Set(["planning", "completed", "done"]);
+
+/** 判断目录是否已有 Flower 安装记录。 */
+function isFlowerProject(directory) {
+  const trellis = path.join(directory, ".trellis");
+  const hasLock = fs.existsSync(path.join(directory, ".flower", "plugin-lock.json"));
+  const hasManifest = fs.existsSync(path.join(trellis, ".flower-manifest.json"));
+  if (!hasLock && !hasManifest) return false;
+  try {
+    const stat = fs.lstatSync(trellis);
+    if (stat.isSymbolicLink()) throw new Error(".trellis 是软链接");
+    return stat.isDirectory();
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+
+/** 把用户输入解析为真实目录，避免重复路径与符号链接循环。 */
+function resolveDirectory(input) {
+  if (!input) return { directory: null, reason: "缺少目录路径" };
+  try {
+    const directory = fs.realpathSync(path.resolve(input));
+    if (!fs.statSync(directory).isDirectory()) {
+      return { directory: null, reason: "目标不是目录" };
+    }
+    return { directory, reason: null };
+  } catch (error) {
+    return { directory: null, reason: `无法读取目录(${error.code || error.message})` };
+  }
+}
+
+/**
+ * 在显式根目录与目标路径中发现 Flower 项目。
+ * @param {string[]} roots 允许扫描的父目录
+ * @param {string[]} targets 显式项目目录
+ * @returns {{projects:string[],errors:Array<{target:string,reason:string}>}} 去重项目与输入错误
+ */
+export function discoverFlowerProjects(roots, targets) {
+  const projects = new Set();
+  const errors = [];
+
+  for (const input of targets) {
+    const { directory, reason } = resolveDirectory(input);
+    if (!directory) {
+      errors.push({ target: input || "--target", reason });
+      continue;
+    }
+    try {
+      if (isFlowerProject(directory)) projects.add(directory);
+      else errors.push({ target: input, reason: "目标不是已安装 Flower 项目" });
+    } catch (error) {
+      errors.push({ target: input, reason: `无法读取安装记录(${error.code || error.message})` });
+    }
+  }
+
+  for (const input of roots) {
+    const { directory, reason } = resolveDirectory(input);
+    if (!directory) {
+      errors.push({ target: input || "--root", reason });
+      continue;
+    }
+    const stack = [directory];
+    while (stack.length) {
+      const current = stack.pop();
+      try {
+        if (isFlowerProject(current)) projects.add(current);
+      } catch (error) {
+        errors.push({ target: current, reason: `无法读取安装记录(${error.code || error.message})` });
+      }
+      try {
+        const entries = fs.readdirSync(current, { withFileTypes: true })
+          .filter((entry) => entry.isDirectory() && !SKIP_DIRECTORIES.has(entry.name))
+          .sort((a, b) => b.name.localeCompare(a.name));
+        for (const entry of entries) stack.push(path.join(current, entry.name));
+      } catch (error) {
+        errors.push({ target: current, reason: `无法扫描目录(${error.code || error.message})` });
+      }
+    }
+  }
+
+  return { projects: [...projects].sort(), errors };
+}
+
+/**
+ * 读取项目所属 Git 根，用于共享写入前的安全检查。
+ * @param {string} target Flower 项目目录
+ * @returns {string|null} Git 根真实路径；无法读取时返回 null
+ */
+export function gitRepositoryRoot(target) {
+  const result = spawnSync("git", ["rev-parse", "--show-toplevel"], {
+    cwd: target,
+    encoding: "utf8",
+    shell: process.platform === "win32",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 1500,
+  });
+  if (result.error || result.status !== 0) return null;
+  try {
+    return fs.realpathSync(String(result.stdout || "").trim());
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 严格检查批量更新目标的任务状态；不可读状态不能等同于没有活动任务。
+ * @param {string} target Flower 项目目录
+ * @returns {{safe:boolean,reason:string|null}} 是否允许进入更新队列
+ */
+export function projectTaskSafety(target) {
+  const tasksDir = path.join(target, ".trellis", "tasks");
+  let rootStat;
+  try {
+    rootStat = fs.lstatSync(tasksDir);
+  } catch (error) {
+    return error.code === "ENOENT"
+      ? { safe: true, reason: null }
+      : { safe: false, reason: `无法读取任务目录(${error.code || error.message})` };
+  }
+  if (!rootStat.isDirectory()) return { safe: false, reason: "任务目录不是普通目录" };
+
+  const stack = [tasksDir];
+  while (stack.length) {
+    const directory = stack.pop();
+    let entries;
+    try {
+      entries = fs.readdirSync(directory, { withFileTypes: true });
+    } catch (error) {
+      return { safe: false, reason: `无法读取任务目录(${error.code || error.message})` };
+    }
+    for (const entry of entries) {
+      const absolute = path.join(directory, entry.name);
+      if (entry.isSymbolicLink()) return { safe: false, reason: `任务目录含软链接:${path.relative(target, absolute)}` };
+      if (entry.isDirectory()) {
+        stack.push(absolute);
+        continue;
+      }
+      if (entry.name !== "task.json") continue;
+      if (!entry.isFile()) return { safe: false, reason: `任务记录不是普通文件:${path.relative(target, absolute)}` };
+      try {
+        const data = JSON.parse(fs.readFileSync(absolute, "utf8"));
+        if (data?.status === "in_progress" || data?.status === "active") {
+          return { safe: false, reason: "存在活动 Trellis 任务" };
+        }
+        if (!INACTIVE_TASK_STATUSES.has(data?.status)) {
+          return { safe: false, reason: `任务记录状态无法确认:${path.relative(target, absolute)}` };
+        }
+      } catch (error) {
+        return { safe: false, reason: `任务记录损坏或不可读:${path.relative(target, absolute)} (${error.code || error.message})` };
+      }
+    }
+  }
+  return { safe: true, reason: null };
+}