flower-trellis 0.4.1 → 0.4.3

package/README.md

@@ -52,6 +52,15 @@ flower-trellis init -u <your-name> -y
 # 升级 Trellis 并按新版本重新叠加强化包
 flower-trellis update
 
+# 检查当前项目是否需要更新(稳定 JSON,供 AI / hook 使用)
+flower-trellis self-check --json --target .
+
+# 执行受控自更新:升级 flower-trellis,再默认 --force 重叠加当前项目
+flower-trellis self-update --target . --yes
+
+# 管理启动更新检查策略
+flower-trellis update-check get --target .
+
 # 交互管理通用技能,并查看工作流强化包
 flower-trellis skill
 
@@ -70,6 +79,9 @@ flower-trellis -v
 |------|------|
 | `init` | 安装 Trellis 并叠加强化包(默认命令,裸跑等同 `init`) |
 | `update` | 升级 Trellis,并按新版本重新叠加强化包 |
+| `self-check` | 输出启动更新检查 JSON,供 Codex / Claude Code hook 和 AI 自动化读取 |
+| `self-update` | 受控升级 flower-trellis 并对目标项目执行完整 `flower-trellis update` 重叠加 |
+| `update-check` | 管理 `.trellis/.flower-manifest.json` 内的启动更新检查策略 |
 | `skill` | 打开交互菜单:启用或停用通用技能,只读查看工作流强化包 |
 | `uninstall` | 移除 Trellis 本体并清理强化包残留(支持 `-y` / `--dry-run`) |
 | `<其它命令>` | 原样透传给 Trellis,覆盖其现有及未来子命令 |
@@ -99,16 +111,93 @@ flower-trellis -v
 - **非交互**(`-y` 或非 TTY):仅打印一行升级提示,不弹确认、不阻塞。
 - **跳过检测**:经 `npx` 运行(本就是最新版)、或显式 `--no-update-check` / `FLOWER_NO_UPDATE_CHECK=1` 时不检测。
 
+### 启动更新检查
+
+运行 `flower-trellis init` / `flower-trellis update` 后,目标项目会安装轻量启动 hook:
+
+- Codex:向 `.codex/hooks.json` 的 `SessionStart` 追加 `.trellis/scripts/flower_update_hook.py`。
+- Claude Code:只向 `.claude/settings.json` 的 `SessionStart` `startup` matcher 追加该 hook,不挂 `clear` / `compact`。
+
+启动 hook 不会直接安装 npm 包,也不会直接改项目文件。它只调用:
+
+```bash
+flower-trellis self-check --json --target .
+```
+
+发现可更新或项目已铺版本不一致时,向 AI 注入 `<flower-update>` 上下文。无更新、离线、关闭检查、npx 临时运行时默认不打扰。
+
+检查分两层:
+
+- **本地一致性检查**:每次启动都会比对当前安装的 `flower-trellis` / 捆绑 Trellis 版本与项目 `.trellis/.flower-manifest.json` / `.trellis/.version`;不受 `intervalHours` 限制。
+- **远程版本探测**:访问 npm registry 读取 `flower-trellis` dist-tags;受 `intervalHours` 节流,带超时,失败静默。
+
+策略和缓存统一保存在 `.trellis/.flower-manifest.json` 的 `updateCheck`:
+
+```json
+{
+  "updateCheck": {
+    "enabled": true,
+    "policy": "ask",
+    "intervalHours": 8,
+    "lastCheckedAt": "2026-07-07T00:00:00.000Z",
+    "lastRemote": { "latest": "0.4.2", "beta": null },
+    "lastStatus": "update_available",
+    "lastErrorCode": null
+  }
+}
+```
+
+`policy` 可选:
+
+| policy | 行为 |
+|--------|------|
+| `off` | 不做启动更新检查,也不联网 |
+| `notify` | 只注入提示和手动命令,AI 不主动询问或执行 |
+| `ask` | 默认值;AI 发现可更新后先询问用户 |
+| `auto` | 安全条件满足时 AI 可执行 `self-update`;dirty 工作区或活跃任务等情况会降级为 `ask` |
+
+管理策略:
+
+```bash
+flower-trellis update-check get --target .
+flower-trellis update-check set --policy auto --interval-hours 12 --target .
+flower-trellis update-check disable --target .  # 只设置 enabled=false,不改 policy
+flower-trellis update-check enable --target .   # 只设置 enabled=true,沿用原 policy
+```
+
+执行更新:
+
+```bash
+# 预览,不写入
+flower-trellis self-update --target . --dry-run
+
+# 执行:先升级全局 flower-trellis,再对项目执行完整 update
+flower-trellis self-update --target . --yes
+```
+
+项目重叠加阶段默认等价于 Trellis 交互里的 **Apply Overwrite to all**:
+
+```bash
+flower-trellis update --target . --no-update-check --force
+```
+
+如需改用其它上游冲突策略,在 `--` 后透传:
+
+```bash
+flower-trellis self-update --target . --yes -- --skip-all
+flower-trellis self-update --target . --yes -- --create-new
+```
+
 ## 工作原理
 
 `init` 的执行流程:
 
 ```
-flower banner → 平台多选菜单 → Trellis 原生交互(模板 / monorepo / 冲突)→ 叠加强化包 → codex 后处理
+flower banner → 平台多选菜单 → Trellis 原生交互(模板 / monorepo / 冲突)→ 叠加强化包 → 平台后处理
 ```
 
 - **统一品牌头部**:Trellis 子进程在伪终端(`node-pty`)中运行,其原生的模板 / monorepo / 冲突等交互完整保留,但重复打印的启动 banner 被过滤,全程只呈现一个 flower banner。
-- **按平台铺设技能**:Claude 铺到 `.claude/skills`,Codex / Gemini 等铺到 `.agents/skills`;并对 codex 做后处理(兼容清理旧 `config.toml` 的 `[features.multi_agent_v2]`,在保留上游 hooks 的基础上补全 `SessionStart`)。
+- **按平台铺设技能**:Claude 铺到 `.claude/skills`,Codex / Gemini 等铺到 `.agents/skills`;并做平台后处理:Codex 兼容清理旧 `config.toml` 的 `[features.multi_agent_v2]`,在保留上游 hooks 的基础上补全 `SessionStart`;Claude Code 只在 `startup` SessionStart 挂载启动更新检查。
 - **幂等执行**:`workflow.md` 注入前先按 `BEGIN/END` 标记清除旧块再重注入(块数恒定,不会翻倍,首次注入前备份到 `.trellis/.backup-flower/`);技能文件覆盖式铺设,并通过 `.trellis/.flower-manifest.json` 记录已铺路径,升级时删除已淘汰项。
 - **上线事项账本**:强化包通过 finish-work skill override 在归档前智能识别 SQL、配置、批处理 / 部署脚本 / 数据修复、外部系统 / 依赖平台等上线事项,必要时写入任务 `release.md`;`trellis-release` 可在正式上线前核对任务文档、`release.md` 和 git 证据,生成 `YYYY-MM-DD-<release-slug>.md` 格式的版本 / 批次操作单。
 - **安全中止**:`Ctrl+C` 取消后不会继续叠加。

package/enhancements/MANIFEST.json

@@ -1,5 +1,5 @@
 {
-  "syncedAt": "2026-07-06T15:58:44.168Z",
+  "syncedAt": "2026-07-07T06:55:11.344Z",
   "syncedFrom": "vendor/skill-garden",
   "sourceCommit": "5fdebe60e923c91ba912461b99413b5c8e11a38c",
   "common": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flower-trellis",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "一键安装/升级 Trellis 并自动融合 skill-garden 强化包(默认 Claude + agents)",
   "type": "module",
   "bin": {

package/src/assets/flower_update_hook.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""SessionStart 启动更新检查 hook。
+
+脚本只做只读检查和上下文注入:调用 `flower-trellis self-check --json`,
+发现可执行更新时输出 `<flower-update>` 块。失败、离线、无更新或关闭检查时静默退出,
+避免影响 Codex / Claude Code 正常启动。
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+
+ACTIONABLE_STATUSES = {"update_available", "project_out_of_sync"}
+
+
+def _debug(message: str) -> None:
+    """在显式调试时输出简短错误。"""
+    if os.environ.get("FLOWER_UPDATE_HOOK_DEBUG"):
+        print(f"flower_update_hook: {message}", file=sys.stderr)
+
+
+def _project_dir(hook_input: dict) -> Path:
+    """从平台环境变量或 hook stdin 解析项目目录。"""
+    for name in (
+        "CLAUDE_PROJECT_DIR",
+        "CODEX_PROJECT_DIR",
+        "CURSOR_PROJECT_DIR",
+        "GEMINI_PROJECT_DIR",
+        "QODER_PROJECT_DIR",
+        "CODEBUDDY_PROJECT_DIR",
+        "TRAE_PROJECT_DIR",
+    ):
+        value = os.environ.get(name)
+        if value:
+            return Path(value).resolve()
+    return Path(str(hook_input.get("cwd") or ".")).resolve()
+
+
+def _run_self_check(project_dir: Path) -> dict | None:
+    """执行 flower-trellis self-check 并解析 JSON。"""
+    try:
+        result = subprocess.run(
+            [
+                "flower-trellis",
+                "self-check",
+                "--json",
+                "--target",
+                str(project_dir),
+            ],
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=8,
+            cwd=str(project_dir),
+        )
+    except (subprocess.TimeoutExpired, FileNotFoundError, PermissionError) as exc:
+        _debug(str(exc))
+        return None
+    if result.returncode != 0:
+        _debug(result.stderr.strip() or f"退出码 {result.returncode}")
+        return None
+    try:
+        data = json.loads(result.stdout)
+    except json.JSONDecodeError as exc:
+        _debug(f"JSON 解析失败:{exc}")
+        return None
+    return data if isinstance(data, dict) else None
+
+
+def _format_context(data: dict) -> str:
+    """把 self-check JSON 转成给 AI 读取的短上下文块。"""
+    current = data.get("current") or {}
+    project = data.get("project") or {}
+    remote = data.get("remote") or {}
+    ai = data.get("ai") or {}
+    safety = data.get("safety") or {}
+    lines = [
+        "<flower-update>",
+        f"status: {data.get('status')}",
+        f"policy: {data.get('policy')}",
+        f"current_flower: {current.get('flowerVersion')}",
+        f"project_flower: {project.get('flowerVersion')}",
+        f"bundled_trellis: {current.get('bundledTrellisVersion')}",
+        f"project_trellis: {project.get('trellisVersion')}",
+    ]
+    if remote.get("tags"):
+        lines.append(f"remote: {json.dumps(remote.get('tags'), ensure_ascii=False)}")
+    command = (data.get("commands") or {}).get("recommended") or ai.get("command")
+    if command:
+        lines.append(f"recommended_command: {command}")
+    if safety.get("reasons"):
+        lines.append(f"safety_reasons: {', '.join(safety.get('reasons') or [])}")
+    if ai.get("instruction"):
+        lines.append(f"ai_instruction: {ai.get('instruction')}")
+    lines.append("</flower-update>")
+    return "\n".join(lines)
+
+
+def _emit_context(context: str) -> None:
+    """同时兼容 Codex / Claude Code / Cursor 风格的 hook JSON 输出。"""
+    result = {
+        "suppressOutput": True,
+        "systemMessage": "flower-trellis update context injected",
+        "hookSpecificOutput": {
+            "hookEventName": "SessionStart",
+            "additionalContext": context,
+        },
+        "additional_context": context,
+    }
+    print(json.dumps(result, ensure_ascii=False), flush=True)
+
+
+def main() -> None:
+    try:
+        hook_input = json.loads(sys.stdin.read() or "{}")
+        if not isinstance(hook_input, dict):
+            hook_input = {}
+    except json.JSONDecodeError:
+        hook_input = {}
+
+    data = _run_self_check(_project_dir(hook_input))
+    if not data or data.get("status") not in ACTIONABLE_STATUSES:
+        return
+    _emit_context(_format_context(data))
+
+
+if __name__ == "__main__":
+    main()

package/src/cli.js

@@ -66,6 +66,9 @@ function printHelp() {
 用法:
   flower-trellis [init] [trellis flags] [flower flags]   安装 + 叠加强化包(默认命令)
   flower-trellis update [trellis flags] [flower flags]   升级 + 按新版本重新叠加
+  flower-trellis self-check --json [--target <dir>]      输出启动更新检查 JSON
+  flower-trellis self-update --target <dir> --yes        自更新 + 项目重叠加
+  flower-trellis update-check <get|set|disable|enable>   管理启动更新策略
   flower-trellis skill [flower flags]                    交互管理通用技能
   flower-trellis uninstall [-y | --dry-run]              卸载 + 清理强化残留
   flower-trellis <其它命令> [...]                        透传给 trellis(面向未来)
@@ -79,6 +82,12 @@ flower 自有 flag:
   --target <dir>           目标目录(默认当前目录)
   --no-update-check        本次跳过 flower-trellis 新版本检测(等价 FLOWER_NO_UPDATE_CHECK=1)
 
+启动更新检查:
+  self-check --json                 稳定输出检查 JSON
+  self-update --yes [--dry-run]     执行或预览全局更新与项目 update
+  update-check set --policy <off|notify|ask|auto> [--interval-hours <n>]
+  update-check disable|enable       只切换 enabled,不覆盖已选 policy
+
 命令别名:flower-trellis 可简写为 ftl 或 ft(三者完全等价)。
 init / update 启动时会顺带检测 flower-trellis 自身是否有新版(联网、带超时,失败静默)。
 skill 可启用或停用通用技能，并只读展示工作流强化包。
@@ -99,9 +108,17 @@ function parse(argv) {
   let updateCheck = true;
   const skills = [];
   const passthrough = [];
+  const forwarded = [];
 
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
+    if (a === "--") {
+      forwarded.push(...argv.slice(i + 1));
+      if (command !== "self-update") {
+        passthrough.push(...argv.slice(i + 1));
+      }
+      break;
+    }
     // 第一个非 flag token 视为子命令
     if (command === null && !a.startsWith("-")) {
       command = a;
@@ -143,6 +160,7 @@ function parse(argv) {
       skills,
       variant,
       updateCheck,
+      forwarded,
     },
   };
 }
@@ -179,6 +197,15 @@ async function main() {
     } else if (cmd === "update") {
       const { update } = await import("./commands/update.js");
       await update(ctx);
+    } else if (cmd === "self-check") {
+      const { selfCheck } = await import("./commands/self-check.js");
+      await selfCheck(ctx);
+    } else if (cmd === "self-update") {
+      const { selfUpdate } = await import("./commands/self-update.js");
+      await selfUpdate(ctx);
+    } else if (cmd === "update-check") {
+      const { updateCheck } = await import("./commands/update-check.js");
+      await updateCheck(ctx);
     } else if (cmd === "skill") {
       const { skill } = await import("./commands/skill.js");
       await skill(ctx);

package/src/commands/self-check.js

@@ -0,0 +1,19 @@
+import { buildSelfCheck } from "../lib/self-check.js";
+
+/**
+ * flower-trellis self-check:输出结构化启动更新检查结果。
+ *
+ * 供 Codex / Claude Code SessionStart hook 和 AI 自动化读取。无论是否发现更新,
+ * 都稳定输出 JSON,避免 hook 侧靠空 stdout 猜状态。
+ *
+ * @param {object} ctx 见 cli.js 的 parse()
+ * @returns {Promise<void>}
+ */
+export async function selfCheck(ctx) {
+  const forceRemote = ctx.passthrough.includes("--force-remote");
+  if (ctx.updateCheck === false) {
+    process.env.FLOWER_NO_UPDATE_CHECK = "1";
+  }
+  const result = await buildSelfCheck(ctx.target, { forceRemote });
+  console.log(JSON.stringify(result, null, 2));
+}

package/src/commands/self-update.js

@@ -0,0 +1,108 @@
+import { spawnSync } from "node:child_process";
+import {
+  buildSelfCheck,
+  projectUpdateCommand,
+  projectUpdateForwardArgs,
+  safetyState,
+} from "../lib/self-check.js";
+
+/** 判断参数里是否包含指定 flag。 */
+function hasFlag(args, name) {
+  return args.includes(name);
+}
+
+/** 执行命令并在失败时给出统一错误。 */
+function runCommand(command, args, cwd, failureMessage) {
+  const res = spawnSync(command, args, {
+    cwd,
+    stdio: "inherit",
+    shell: process.platform === "win32",
+  });
+  if (res.status !== 0) {
+    const reason = res.error ? res.error.message : `退出码 ${res.status ?? 1}`;
+    throw new Error(`${failureMessage}(${reason})`);
+  }
+}
+
+/**
+ * flower-trellis self-update:执行受控自更新与项目重叠加。
+ *
+ * 默认项目 update 阶段追加 `--force`,等价 Trellis 交互里的 Apply Overwrite to all。
+ * 用户可通过 `--` 透传 `--skip-all` / `--create-new` 等上游冲突策略覆盖默认。
+ *
+ * @param {object} ctx 见 cli.js 的 parse()
+ * @returns {Promise<void>}
+ */
+export async function selfUpdate(ctx) {
+  const dryRun = hasFlag(ctx.passthrough, "--dry-run");
+  const yes = hasFlag(ctx.passthrough, "--yes") || hasFlag(ctx.passthrough, "-y");
+  const projectOnly = hasFlag(ctx.passthrough, "--project-only");
+  const forwarded = ctx.forwarded || [];
+  const projectArgs = [
+    "update",
+    "--target",
+    ctx.target,
+    "--no-update-check",
+    ...projectUpdateForwardArgs(forwarded),
+  ];
+  const check = await buildSelfCheck(ctx.target, {
+    writeCache: !dryRun,
+    forceRemote: !projectOnly,
+  });
+  const shouldInstallFlower = !projectOnly && check.status === "update_available" && check.recommendation;
+  const effectiveSafety = check.safety || safetyState(
+    ctx.target,
+    projectOnly ? "project_out_of_sync" : check.status,
+    projectUpdateCommand(ctx.target, forwarded),
+  );
+
+  if (dryRun) {
+    console.log("self-update dry-run:");
+    if (shouldInstallFlower) {
+      console.log(`  · 全局升级:${check.recommendation.command}`);
+    } else {
+      console.log("  · 全局升级:跳过");
+    }
+    console.log(`  · 项目更新:${projectUpdateCommand(ctx.target, forwarded)}`);
+    console.log(`  · 当前状态:${check.status}`);
+    console.log(`  · 目标:${ctx.target}`);
+    console.log(`  · 当前 flower:${check.current?.flowerVersion || "unknown"}`);
+    console.log(`  · 项目 flower:${check.project?.flowerVersion || "unknown"}`);
+    console.log(`  · 捆绑 Trellis:${check.current?.bundledTrellisVersion || "unknown"}`);
+    console.log(`  · 项目 Trellis:${check.project?.trellisVersion || "unknown"}`);
+    console.log(
+      `  · 安全检查:${effectiveSafety.safe ? "通过" : `需确认(${effectiveSafety.reasons.join(", ") || "无可用结果"})`}`,
+    );
+    console.log(`  · 写入:否`);
+    return;
+  }
+
+  if (!yes) {
+    throw new Error("self-update 执行写入前需要 --yes;如需预览请使用 --dry-run");
+  }
+
+  if (!shouldInstallFlower && !projectOnly && check.status !== "project_out_of_sync") {
+    console.log(`  · 当前状态:${check.status},无需执行 self-update`);
+    return;
+  }
+
+  if (shouldInstallFlower) {
+    runCommand(
+      "npm",
+      ["i", "-g", `flower-trellis@${check.recommendation.tag}`],
+      ctx.target,
+      "全局 flower-trellis 升级失败",
+    );
+  } else {
+    console.log("  · 跳过全局 flower-trellis 升级");
+  }
+
+  runCommand(
+    "flower-trellis",
+    projectArgs,
+    ctx.target,
+    "目标项目重叠加失败,请手动运行:" + projectUpdateCommand(ctx.target, forwarded),
+  );
+
+  console.log(`\n🌸 flower-trellis self-update 完成 → ${ctx.target}`);
+}

package/src/commands/update-check.js

@@ -0,0 +1,86 @@
+import fs from "node:fs";
+import path from "node:path";
+import {
+  manifestPath,
+  readManifest,
+  readUpdateCheck,
+  writeUpdateCheck,
+} from "../lib/manifest.js";
+
+const POLICIES = new Set(["off", "notify", "ask", "auto"]);
+
+/** 读取 flag 后面的取值。 */
+function optionValue(args, name) {
+  const index = args.indexOf(name);
+  if (index === -1) return null;
+  return args[index + 1] || null;
+}
+
+/** 确保目标是 Trellis 项目。 */
+function assertTrellisProject(target) {
+  if (!fs.existsSync(path.join(target, ".trellis"))) {
+    throw new Error(`目标不是 Trellis 项目:${target}`);
+  }
+}
+
+/**
+ * flower-trellis update-check:管理 manifest 内的启动更新检查策略。
+ *
+ * @param {object} ctx 见 cli.js 的 parse()
+ */
+export async function updateCheck(ctx) {
+  const args = ctx.passthrough;
+  const action = args.find((arg) => !arg.startsWith("-")) || "get";
+  assertTrellisProject(ctx.target);
+
+  if (action === "get") {
+    const manifest = readManifest(ctx.target);
+    console.log(`manifest: ${manifestPath(ctx.target)}`);
+    console.log(JSON.stringify(readUpdateCheck(ctx.target), null, 2));
+    if (!manifest) console.log("  · manifest 不存在,当前显示默认策略");
+    return;
+  }
+
+  if (action === "set") {
+    const policy = optionValue(args, "--policy");
+    const intervalText = optionValue(args, "--interval-hours");
+    const patch = {};
+    if (policy) {
+      if (!POLICIES.has(policy)) {
+        throw new Error("policy 只能是 off / notify / ask / auto");
+      }
+      patch.policy = policy;
+      patch.enabled = policy !== "off";
+    }
+    if (intervalText !== null) {
+      const intervalHours = Number(intervalText);
+      if (!Number.isFinite(intervalHours) || intervalHours < 0) {
+        throw new Error("--interval-hours 必须是非负数字");
+      }
+      patch.intervalHours = intervalHours;
+    }
+    if (!Object.keys(patch).length) {
+      throw new Error("update-check set 需要 --policy 或 --interval-hours");
+    }
+    writeUpdateCheck(ctx.target, patch);
+    console.log("  ✓ updateCheck 策略已更新");
+    console.log(JSON.stringify(readUpdateCheck(ctx.target), null, 2));
+    return;
+  }
+
+  if (action === "disable") {
+    writeUpdateCheck(ctx.target, { enabled: false });
+    console.log("  ✓ 启动更新检查已关闭(policy 保留)");
+    console.log(JSON.stringify(readUpdateCheck(ctx.target), null, 2));
+    return;
+  }
+
+  if (action === "enable") {
+    writeUpdateCheck(ctx.target, { enabled: true });
+    console.log("  ✓ 启动更新检查已启用(policy 沿用)");
+    console.log(JSON.stringify(readUpdateCheck(ctx.target), null, 2));
+    return;
+  }
+
+  throw new Error("update-check 只支持 get / set / disable / enable");
+}

package/src/lib/apply-enhancements.js

@@ -5,6 +5,8 @@ import { copyScriptAssets } from "./copy-scripts.js";
 import { injectWorkflow } from "./workflow-inject.js";
 import { injectSkillOverrides } from "./skill-override-inject.js";
 import { applyCodexTweaks } from "./codex-tweaks.js";
+import { applyClaudeTweaks } from "./claude-tweaks.js";
+import { copyFlowerAssets } from "./flower-assets.js";
 import { readManifest, writeManifest } from "./manifest.js";
 import { flowerVersion } from "./versions.js";
 import { rmrf } from "./fs-utils.js";
@@ -63,8 +65,11 @@ export function applyEnhancements(target, opts = {}) {
     variantDir,
     skills,
   );
-  const installed = [...skillInstalled, ...scriptInstalled];
-  const newPaths = [...skillPaths, ...scriptPaths];
+  const { installed: flowerInstalled, paths: flowerPaths } = skills.length === 0
+    ? copyFlowerAssets(target)
+    : { installed: [], paths: [] };
+  const installed = [...skillInstalled, ...scriptInstalled, ...flowerInstalled];
+  const newPaths = [...skillPaths, ...scriptPaths, ...flowerPaths];
   const where = [];
   if (newPaths.some((p) => p.startsWith(".claude/skills"))) where.push(".claude/skills");
   if (newPaths.some((p) => p.startsWith(".agents/skills"))) where.push(".agents/skills");
@@ -152,5 +157,10 @@ export function applyEnhancements(target, opts = {}) {
     console.log(`  ✓ codex 调整:${seg};hooks.json 已合并 SessionStart;${dispatch}`);
   }
 
+  const claude = applyClaudeTweaks(target);
+  if (claude.applied) {
+    console.log("  ✓ claude 调整:settings.json 已合并 startup 更新检查 hook");
+  }
+
   return { variant, installed };
 }

package/src/lib/claude-tweaks.js

@@ -0,0 +1,98 @@
+import fs from "node:fs";
+import path from "node:path";
+import { FLOWER_UPDATE_HOOK_REL } from "./flower-assets.js";
+
+const WORKFLOW_HOOK_SCRIPT = ".claude/hooks/inject-workflow-state.py";
+const DEFAULT_COMMAND = `python3 ${FLOWER_UPDATE_HOOK_REL}`;
+
+/** 容错读取 Claude settings JSON。 */
+function readSettings(settingsPath) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+    if (parsed && typeof parsed === "object") {
+      const hooks = parsed.hooks && typeof parsed.hooks === "object" ? parsed.hooks : {};
+      return { ...parsed, hooks };
+    }
+  } catch {
+    // 缺失或损坏时用空配置重建,避免后处理阻断 init/update。
+  }
+  return { hooks: {} };
+}
+
+/** 从 Claude UserPromptSubmit hook 推导 Python 命令前缀。 */
+function flowerUpdateCommand(config) {
+  const groups = Array.isArray(config.hooks.UserPromptSubmit)
+    ? config.hooks.UserPromptSubmit
+    : [];
+  for (const group of groups) {
+    const hooks = Array.isArray(group?.hooks) ? group.hooks : [];
+    for (const hook of hooks) {
+      if (hook?.type !== "command" || typeof hook.command !== "string") continue;
+      if (hook.command.includes(WORKFLOW_HOOK_SCRIPT)) {
+        return hook.command.replace(WORKFLOW_HOOK_SCRIPT, FLOWER_UPDATE_HOOK_REL);
+      }
+    }
+  }
+  return DEFAULT_COMMAND;
+}
+
+/** 判断 hook 列表里是否已有 flower update hook。 */
+function hasFlowerHook(hooks) {
+  return hooks.some(
+    (hook) => hook?.type === "command" &&
+      typeof hook.command === "string" &&
+      hook.command.includes(FLOWER_UPDATE_HOOK_REL),
+  );
+}
+
+/** 合并 Claude startup hook,并确保 clear / compact 不运行 update hook。 */
+function mergeClaudeHooks(settingsPath) {
+  const config = readSettings(settingsPath);
+  const groups = Array.isArray(config.hooks.SessionStart)
+    ? config.hooks.SessionStart
+    : [];
+  const command = flowerUpdateCommand(config);
+  let startup = groups.find((group) => group?.matcher === "startup");
+  if (!startup) {
+    startup = { matcher: "startup", hooks: [] };
+    groups.unshift(startup);
+  }
+  if (!Array.isArray(startup.hooks)) startup.hooks = [];
+
+  let changed = false;
+  for (const group of groups) {
+    if (group === startup || !Array.isArray(group?.hooks)) continue;
+    const before = group.hooks.length;
+    group.hooks = group.hooks.filter(
+      (hook) => !(hook?.type === "command" &&
+        typeof hook.command === "string" &&
+        hook.command.includes(FLOWER_UPDATE_HOOK_REL)),
+    );
+    if (group.hooks.length !== before) changed = true;
+  }
+
+  if (!hasFlowerHook(startup.hooks)) {
+    startup.hooks.push({ type: "command", command, timeout: 8 });
+    changed = true;
+  }
+
+  config.hooks.SessionStart = groups;
+  const desired = JSON.stringify(config, null, 2) + "\n";
+  const current = fs.existsSync(settingsPath) ? fs.readFileSync(settingsPath, "utf8") : "";
+  if (current === desired) return changed;
+  fs.writeFileSync(settingsPath, desired);
+  return true;
+}
+
+/**
+ * Claude Code 平台后处理入口。仅当 `.claude/` 存在时执行。
+ *
+ * @param {string} target 目标项目根
+ * @returns {{applied:boolean,settingsWritten?:boolean}}
+ */
+export function applyClaudeTweaks(target) {
+  const claudeDir = path.join(target, ".claude");
+  if (!fs.existsSync(claudeDir)) return { applied: false };
+  const settingsWritten = mergeClaudeHooks(path.join(claudeDir, "settings.json"));
+  return { applied: true, settingsWritten };
+}

package/src/lib/codex-tweaks.js

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import { FLOWER_UPDATE_HOOK_REL } from "./flower-assets.js";
 
 /**
  * flower-trellis 对 Trellis 生成的 codex 配置的定制后处理。
@@ -239,23 +240,40 @@ function sessionStartCommand(config) {
   return `python3 -X utf8 ${SESSION_START_SCRIPT}`;
 }
 
-/**
- * 构造 flower 额外需要的 SessionStart hook。UserPromptSubmit 由 Trellis 上游维护,这里不覆盖。
- * @param {{hooks: object}} config hooks.json 配置
- * @returns {Array<object>} SessionStart hook 数组
- */
-function sessionStartHook(config) {
-  return [
-    {
-      hooks: [
-        {
-          type: "command",
-          command: sessionStartCommand(config),
-          timeout: 30,
-        },
-      ],
-    },
-  ];
+/** 从 Trellis SessionStart 命令推导 flower update hook 命令。 */
+function flowerUpdateCommand(config) {
+  const command = sessionStartCommand(config);
+  if (command.includes(SESSION_START_SCRIPT)) {
+    return command.replace(SESSION_START_SCRIPT, FLOWER_UPDATE_HOOK_REL);
+  }
+  return `python3 -X utf8 ${FLOWER_UPDATE_HOOK_REL}`;
+}
+
+/** 判断 hooks 数组里是否已有指定命令。 */
+function hasCommand(hooks, commandNeedle) {
+  return hooks.some(
+    (hook) => hook?.type === "command" &&
+      typeof hook.command === "string" &&
+      hook.command.includes(commandNeedle),
+  );
+}
+
+/** 向 SessionStart 合并单个 command hook,保留既有自定义 hook。 */
+function ensureSessionStartCommand(groups, command, timeout, needle) {
+  for (const group of groups) {
+    const hooks = Array.isArray(group?.hooks) ? group.hooks : [];
+    if (hasCommand(hooks, needle)) return false;
+  }
+  groups.push({
+    hooks: [
+      {
+        type: "command",
+        command,
+        timeout,
+      },
+    ],
+  });
+  return true;
 }
 
 /**
@@ -269,7 +287,12 @@ function sessionStartHook(config) {
  */
 function mergeHooks(hooksPath) {
   const config = readHooksConfig(hooksPath);
-  config.hooks.SessionStart = sessionStartHook(config);
+  const groups = Array.isArray(config.hooks.SessionStart)
+    ? config.hooks.SessionStart
+    : [];
+  ensureSessionStartCommand(groups, sessionStartCommand(config), 30, SESSION_START_SCRIPT);
+  ensureSessionStartCommand(groups, flowerUpdateCommand(config), 8, FLOWER_UPDATE_HOOK_REL);
+  config.hooks.SessionStart = groups;
 
   const desired = JSON.stringify(config, null, 2) + "\n";
   const current = fs.existsSync(hooksPath) ? fs.readFileSync(hooksPath, "utf8") : "";

package/src/lib/flower-assets.js

@@ -0,0 +1,29 @@
+import path from "node:path";
+import { copyPath } from "./fs-utils.js";
+import { PKG_ROOT } from "./paths.js";
+
+/** flower 自有启动更新 hook 脚本名。 */
+export const FLOWER_UPDATE_HOOK = "flower_update_hook.py";
+
+/** flower 自有启动更新 hook 在目标项目内的相对路径。 */
+export const FLOWER_UPDATE_HOOK_REL = `.trellis/scripts/${FLOWER_UPDATE_HOOK}`;
+
+/**
+ * 复制 flower 自有脚本资产。
+ *
+ * 这些脚本属于 flower-trellis 自身能力,不从 skill-garden 快照同步,避免和
+ * `enhancements/<variant>/scripts` 的边界混淆。
+ *
+ * @param {string} target 目标项目根
+ * @returns {{installed:string[],paths:string[]}} 已安装资产和 manifest 路径
+ */
+export function copyFlowerAssets(target) {
+  copyPath(
+    path.join(PKG_ROOT, "src", "assets", FLOWER_UPDATE_HOOK),
+    path.join(target, ...FLOWER_UPDATE_HOOK_REL.split("/")),
+  );
+  return {
+    installed: [`script:${FLOWER_UPDATE_HOOK}`],
+    paths: [FLOWER_UPDATE_HOOK_REL],
+  };
+}

package/src/lib/manifest.js

@@ -11,6 +11,16 @@ import path from "node:path";
  * 放在 .trellis/ 下,随项目的 Trellis 生命周期存在(uninstall 删 .trellis 时一并消失)。
  */
 const MANIFEST_REL = path.join(".trellis", ".flower-manifest.json");
+const UPDATE_POLICIES = new Set(["off", "notify", "ask", "auto"]);
+const DEFAULT_UPDATE_CHECK = {
+  enabled: true,
+  policy: "ask",
+  intervalHours: 8,
+  lastCheckedAt: null,
+  lastRemote: null,
+  lastStatus: null,
+  lastErrorCode: null,
+};
 
 /** manifest 文件的绝对路径。 */
 export function manifestPath(target) {
@@ -26,7 +36,82 @@ export function readManifest(target) {
   }
 }
 
-/** 写入 manifest。 */
+/**
+ * 归一化启动更新检查配置。
+ *
+ * 用户策略字段启用保守默认值;缓存字段只保留结构化摘要,避免把网络错误细节写入项目。
+ *
+ * @param {object|null|undefined} value 原始 updateCheck 字段
+ * @returns {{enabled:boolean,policy:string,intervalHours:number,lastCheckedAt:string|null,lastRemote:object|null,lastStatus:string|null,lastErrorCode:string|null}} 归一化后的 updateCheck
+ */
+export function normalizeUpdateCheck(value) {
+  const raw = value && typeof value === "object" ? value : {};
+  const policy = UPDATE_POLICIES.has(raw.policy) ? raw.policy : DEFAULT_UPDATE_CHECK.policy;
+  const interval = Number(raw.intervalHours);
+  const intervalHours = Number.isFinite(interval) && interval >= 0
+    ? interval
+    : DEFAULT_UPDATE_CHECK.intervalHours;
+  const lastRemote = raw.lastRemote && typeof raw.lastRemote === "object"
+    ? {
+        latest: typeof raw.lastRemote.latest === "string" ? raw.lastRemote.latest : null,
+        beta: typeof raw.lastRemote.beta === "string" ? raw.lastRemote.beta : null,
+      }
+    : null;
+
+  return {
+    enabled: typeof raw.enabled === "boolean" ? raw.enabled : DEFAULT_UPDATE_CHECK.enabled,
+    policy,
+    intervalHours,
+    lastCheckedAt: typeof raw.lastCheckedAt === "string" ? raw.lastCheckedAt : null,
+    lastRemote,
+    lastStatus: typeof raw.lastStatus === "string" ? raw.lastStatus : null,
+    lastErrorCode: typeof raw.lastErrorCode === "string" ? raw.lastErrorCode : null,
+  };
+}
+
+/**
+ * 读取 manifest 里的启动更新检查配置。
+ *
+ * @param {string} target 目标项目根
+ * @returns {ReturnType<typeof normalizeUpdateCheck>} 归一化后的配置
+ */
+export function readUpdateCheck(target) {
+  return normalizeUpdateCheck(readManifest(target)?.updateCheck);
+}
+
+/**
+ * 写入启动更新检查配置,保留 manifest 其它安装清单字段。
+ *
+ * @param {string} target 目标项目根
+ * @param {object} patch 要合并进 updateCheck 的字段
+ * @returns {object} 写入后的 manifest
+ */
+export function writeUpdateCheck(target, patch) {
+  const current = readManifest(target) || {};
+  const updateCheck = normalizeUpdateCheck({
+    ...normalizeUpdateCheck(current.updateCheck),
+    ...(patch || {}),
+  });
+  const next = { ...current, updateCheck };
+  fs.writeFileSync(manifestPath(target), JSON.stringify(next, null, 2) + "\n");
+  return next;
+}
+
+/**
+ * 写入 manifest。
+ *
+ * 若调用方没有显式传入 `updateCheck`,保留目标项目已有策略与缓存,避免全装重写时覆盖用户选择。
+ *
+ * @param {string} target 目标项目根
+ * @param {object} data manifest 新内容
+ */
 export function writeManifest(target, data) {
-  fs.writeFileSync(manifestPath(target), JSON.stringify(data, null, 2) + "\n");
+  const current = readManifest(target);
+  const next = { ...data };
+  if (Object.prototype.hasOwnProperty.call(data, "updateCheck")) {
+    next.updateCheck = normalizeUpdateCheck(data.updateCheck);
+  } else {
+    next.updateCheck = normalizeUpdateCheck(current?.updateCheck);
+  }
+  fs.writeFileSync(manifestPath(target), JSON.stringify(next, null, 2) + "\n");
 }

package/src/lib/self-check.js

@@ -0,0 +1,352 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { readManifest, readUpdateCheck, writeUpdateCheck } from "./manifest.js";
+import { fetchPackageDistTags, getUpdateRecommendation } from "./update-check.js";
+import { isRunningViaNpx } from "./runtime-env.js";
+import { flowerVersion, trellisVersion } from "./versions.js";
+
+/** 上游 trellis update 支持的批量冲突处理参数。 */
+const CONFLICT_FLAGS = new Set(["-f", "--force", "-s", "--skip-all", "-n", "--create-new"]);
+
+/** 给命令建议使用的保守 shell 引号。 */
+function shellQuote(value) {
+  const text = String(value || "");
+  if (/^[A-Za-z0-9_./:=@+-]+$/.test(text)) return text;
+  return `'${text.replace(/'/g, "'\\''")}'`;
+}
+
+/** 读取目标项目的 `.trellis/.version`。 */
+function readProjectTrellisVersion(target) {
+  try {
+    const text = fs.readFileSync(path.join(target, ".trellis", ".version"), "utf8").trim();
+    return text || null;
+  } catch {
+    return null;
+  }
+}
+
+/** 判断远程探测缓存是否仍在 interval 内。 */
+function isRemoteCacheFresh(updateCheck, now = new Date()) {
+  if (!updateCheck.lastCheckedAt) return false;
+  const checkedAt = new Date(updateCheck.lastCheckedAt).getTime();
+  if (!Number.isFinite(checkedAt)) return false;
+  return now.getTime() - checkedAt < updateCheck.intervalHours * 60 * 60 * 1000;
+}
+
+/** 检查目标目录 git 工作区是否 clean。 */
+function gitSafety(target) {
+  const common = {
+    cwd: target,
+    encoding: "utf8",
+    shell: process.platform === "win32",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 1500,
+  };
+  const root = spawnSync("git", ["rev-parse", "--is-inside-work-tree"], common);
+  if (root.error || root.status !== 0 || String(root.stdout || "").trim() !== "true") {
+    return { clean: false, reason: "not_git_repo" };
+  }
+  const status = spawnSync("git", ["status", "--porcelain"], common);
+  if (status.error || status.status !== 0) return { clean: false, reason: "git_status_failed" };
+  const dirty = String(status.stdout || "")
+    .split(/\r?\n/)
+    .filter((line) => line.trim());
+  return dirty.length
+    ? { clean: false, reason: "dirty_worktree", dirtyCount: dirty.length }
+    : { clean: true, reason: null, dirtyCount: 0 };
+}
+
+/** 递归查找 active / in_progress Trellis 任务。 */
+function hasActiveTask(target) {
+  const tasksDir = path.join(target, ".trellis", "tasks");
+  const stack = [tasksDir];
+  while (stack.length) {
+    const dir = stack.pop();
+    let entries = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const abs = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(abs);
+        continue;
+      }
+      if (entry.name !== "task.json") continue;
+      try {
+        const data = JSON.parse(fs.readFileSync(abs, "utf8"));
+        if (data?.status === "in_progress" || data?.status === "active") {
+          return true;
+        }
+      } catch {
+        // 损坏任务文件不阻断版本检查;auto 安全门槛另由可读性结果降级。
+      }
+    }
+  }
+  return false;
+}
+
+/** 判断当前 shell 是否可直接调用 flower-trellis 命令。 */
+function hasFlowerCommand() {
+  const res = spawnSync("flower-trellis", ["-v"], {
+    encoding: "utf8",
+    shell: process.platform === "win32",
+    stdio: ["ignore", "ignore", "ignore"],
+    timeout: 1500,
+  });
+  return !res.error && res.status === 0;
+}
+
+/**
+ * 生成项目更新阶段参数。
+ *
+ * 默认追加 `--force`,对应 Trellis 交互里的 Apply Overwrite to all。若用户显式透传
+ * 其它批量冲突策略,则尊重用户选择,不再追加默认覆盖策略。
+ *
+ * @param {string[]} forwarded 透传给项目 update 的参数
+ * @returns {string[]} 项目 update 透传参数
+ */
+export function projectUpdateForwardArgs(forwarded = []) {
+  const hasConflictStrategy = forwarded.some((arg) => CONFLICT_FLAGS.has(arg));
+  return hasConflictStrategy ? [...forwarded] : ["--force", ...forwarded];
+}
+
+/**
+ * 生成手动项目更新命令。
+ *
+ * @param {string} target 目标项目根
+ * @param {string[]} forwarded 透传参数
+ * @returns {string} 可执行命令
+ */
+export function projectUpdateCommand(target, forwarded = []) {
+  const args = [
+    "flower-trellis",
+    "update",
+    "--target",
+    target,
+    "--no-update-check",
+    ...projectUpdateForwardArgs(forwarded),
+  ];
+  return args.map(shellQuote).join(" ");
+}
+
+/**
+ * 生成 self-update 命令。
+ *
+ * @param {string} target 目标项目根
+ * @param {{projectOnly?: boolean}} options 命令选项
+ * @returns {string} 可执行命令
+ */
+export function selfUpdateCommand(target, options = {}) {
+  const args = ["flower-trellis", "self-update", "--target", target, "--yes"];
+  if (options.projectOnly) args.push("--project-only");
+  return args.map(shellQuote).join(" ");
+}
+
+/** 根据 policy 和安全检查结果生成 AI 动作指令。 */
+function actionForPolicy(policy, command, safety) {
+  if (policy === "notify") {
+    return {
+      mode: "notify",
+      instruction: "只告知用户发现更新和手动命令,不要主动询问或执行。",
+      command,
+    };
+  }
+  if (policy === "auto" && safety.safe) {
+    return {
+      mode: "auto",
+      instruction: "安全条件满足,可以直接执行受控更新命令。",
+      command,
+    };
+  }
+  return {
+    mode: "ask",
+    instruction: "先询问用户是否执行更新;用户确认后再运行推荐命令。",
+    command,
+    downgradedFromAuto: policy === "auto",
+    downgradeReasons: policy === "auto" ? safety.reasons : [],
+  };
+}
+
+/** 计算 auto 策略安全门槛。 */
+export function safetyState(target, status, command) {
+  const git = gitSafety(target);
+  const activeTask = hasActiveTask(target);
+  const flowerCommand = hasFlowerCommand();
+  const reasons = [];
+  if (!git.clean) reasons.push(git.reason);
+  if (activeTask) reasons.push("active_task");
+  if (!flowerCommand) reasons.push("flower_command_missing");
+  if (!command) reasons.push("missing_command");
+  if (process.env.FLOWER_NO_UPDATE_CHECK) reasons.push("disabled_by_env");
+  if (!["update_available", "project_out_of_sync"].includes(status)) reasons.push("status_not_actionable");
+  return {
+    safe: reasons.length === 0,
+    reasons,
+    git,
+    activeTask,
+    flowerCommand,
+  };
+}
+
+/**
+ * 构建启动自更新检查结果。
+ *
+ * @param {string} target 目标项目根
+ * @param {{writeCache?: boolean, forceRemote?: boolean}} options 检查选项
+ * @returns {Promise<object>} 结构化检查结果
+ */
+export async function buildSelfCheck(target, options = {}) {
+  const writeCache = options.writeCache !== false;
+  const forceRemote = options.forceRemote === true;
+  const now = new Date();
+  const absoluteTarget = path.resolve(target);
+  const trellisDir = path.join(absoluteTarget, ".trellis");
+  const manifest = readManifest(absoluteTarget);
+  const updateCheck = readUpdateCheck(absoluteTarget);
+  const currentFlower = flowerVersion();
+  const currentTrellis = trellisVersion();
+  const projectTrellis = readProjectTrellisVersion(absoluteTarget);
+  const projectFlower = typeof manifest?.flowerVersion === "string" ? manifest.flowerVersion : null;
+
+  const base = {
+    status: "up_to_date",
+    checkedAt: now.toISOString(),
+    target: absoluteTarget,
+    policy: updateCheck.policy,
+    updateCheck,
+    current: {
+      flowerVersion: currentFlower,
+      bundledTrellisVersion: currentTrellis,
+    },
+    project: {
+      flowerVersion: projectFlower,
+      trellisVersion: projectTrellis,
+      manifestPresent: Boolean(manifest),
+    },
+    remote: {
+      tags: updateCheck.lastRemote,
+      fromCache: false,
+      skipped: false,
+      errorCode: null,
+    },
+    recommendation: null,
+    commands: {},
+    safety: null,
+    ai: null,
+    reason: null,
+  };
+
+  if (!fs.existsSync(trellisDir)) {
+    return { ...base, status: "skipped", reason: "not_trellis_project" };
+  }
+  if (process.env.FLOWER_NO_UPDATE_CHECK || !updateCheck.enabled || updateCheck.policy === "off") {
+    return { ...base, status: "disabled", reason: "disabled" };
+  }
+  if (isRunningViaNpx(import.meta.url)) {
+    return { ...base, status: "skipped", reason: "npx_runtime" };
+  }
+
+  const projectOutOfSync =
+    (projectFlower && projectFlower !== currentFlower) ||
+    (projectTrellis && projectTrellis !== currentTrellis);
+
+  if (projectOutOfSync) {
+    const command = selfUpdateCommand(absoluteTarget, { projectOnly: true });
+    const result = {
+      ...base,
+      status: "project_out_of_sync",
+      reason: "local_version_mismatch",
+      commands: {
+        recommended: command,
+        projectUpdate: projectUpdateCommand(absoluteTarget),
+      },
+    };
+    const safety = safetyState(absoluteTarget, result.status, command);
+    result.safety = safety;
+    result.ai = actionForPolicy(updateCheck.policy, command, safety);
+    return result;
+  }
+
+  let tags = updateCheck.lastRemote;
+  if (!forceRemote && isRemoteCacheFresh(updateCheck, now)) {
+    const recommendation = getUpdateRecommendation(currentFlower, tags);
+    if (recommendation) {
+      const command = selfUpdateCommand(absoluteTarget);
+      const result = {
+        ...base,
+        status: "update_available",
+        reason: "cached_remote_update",
+        remote: { ...base.remote, tags, fromCache: true, skipped: true },
+        recommendation,
+        commands: { recommended: command, npm: recommendation.command },
+      };
+      const safety = safetyState(absoluteTarget, result.status, command);
+      result.safety = safety;
+      result.ai = actionForPolicy(updateCheck.policy, command, safety);
+      return result;
+    }
+    return {
+      ...base,
+      status: "skipped",
+      reason: "interval_not_elapsed",
+      remote: { ...base.remote, tags, fromCache: true, skipped: true },
+    };
+  }
+
+  tags = await fetchPackageDistTags();
+  if (!tags) {
+    if (writeCache && manifest) {
+      writeUpdateCheck(absoluteTarget, {
+        lastCheckedAt: now.toISOString(),
+        lastStatus: "offline",
+        lastErrorCode: "fetch_failed",
+      });
+    }
+    return {
+      ...base,
+      status: "offline",
+      reason: "fetch_failed",
+      remote: { ...base.remote, tags: updateCheck.lastRemote, errorCode: "fetch_failed" },
+    };
+  }
+
+  const recommendation = getUpdateRecommendation(currentFlower, tags);
+  const status = recommendation ? "update_available" : "up_to_date";
+  if (writeCache && manifest) {
+    writeUpdateCheck(absoluteTarget, {
+      lastCheckedAt: now.toISOString(),
+      lastRemote: tags,
+      lastStatus: status,
+      lastErrorCode: null,
+    });
+  }
+
+  if (!recommendation) {
+    return {
+      ...base,
+      status,
+      remote: { ...base.remote, tags },
+    };
+  }
+
+  const command = selfUpdateCommand(absoluteTarget);
+  const result = {
+    ...base,
+    status,
+    remote: { ...base.remote, tags },
+    recommendation,
+    commands: {
+      recommended: command,
+      npm: recommendation.command,
+      projectUpdate: projectUpdateCommand(absoluteTarget),
+    },
+  };
+  const safety = safetyState(absoluteTarget, result.status, command);
+  result.safety = safety;
+  result.ai = actionForPolicy(updateCheck.policy, command, safety);
+  return result;
+}