dsh-my-guardian 0.4.0 → 0.4.2

package/CHANGELOG.md

@@ -5,94 +5,25 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.4.0] - 2026-09-07
+## [0.4.2] - 2026-09-17
 
 ### 变更
 
-- feat(observability): #155 插件状态查询聚合——统一 status-query 事件 + /plugin-status API (#170)
-- chore(plugins): #165 清理失效的 dsh.client.inject 声明（13 插件） (#167)
-- feat(guard): #144 启动名册静态预检——startup-issues.json + 面板置顶 + 不阻断启动 (#151)
+- docs: skill 合并 12→10 并拆分超限文件，修 observability 聚合端点缺陷
+- docs(清理): #341 文档瘦身 23765 → 8309 行并固化精简规范 (#348)
+- feat(gates): #323 新增包发布卫生门禁（pack 内容 + 字段断言 + README 引用面） (#333)
+- chore(cleanup): #315 清理 unused-local-variable/useless-expression（含共享件假阳性判定） (#319)
+- fix(test): cucumber-js --import glob 改用双引号，兼容 Windows
+- fix(security): 批量修复 'Insecure temporary file' 安全漏洞
+- fix: 移除未使用的stat导入，修复文件系统竞争条件
+- fix: update tests and rebuild client.js for new icons
+- chore: 项目全面优化和完善
 
-## [0.3.6] - 2026-09-04
+## [0.4.1] - 2026-09-10
 
 ### 变更
 
-- fix(guardian): 事件日志不再访问 entry.id getter——构造期 parent.tree 未就绪会抛错炸掉 DSH 启动（隔离实例复现）
-- fix(guardian): 诊断面板可读性 + entry 标识修复——插件失败时不再"看不懂/兜不住"
-- fix(guardian): #86 发版一致性修复——package.json 0.3.5 + CHANGELOG 0.3.5 段（rebase 冲突还原恢复）
-- chore(release): dsh-my-guardian v0.3.5（#86 依赖预检 + 验证清单）
-- feat(guardian): #86 候选区插件依赖预检 + 失败分类 (#124)
-- docs: #106 安装命令统一加 --trust-lockfile (#113)
-
-## [0.3.5] - 2026-09-04
-
-### 新增
-
-- [#86](https://github.com/baosfeng/my-dsh-plugins/issues/86) 候选区插件依赖预检 + 失败分类：热挂载前校验依赖就绪，失败按类别诊断（缺失依赖/锁定冲突/加载错误），诊断面板展示分类详情
-
-### 变更
-
-- 验证清单与效果图同步（发版前功能级验证归档）
-
-## [0.3.4] - 2026-09-02
-
-### 变更
-
-- fix(scripts): #72 插件依赖未随安装自动安装（dsh-shared 未发布 npm） (#96)
-
-## [0.3.3] - 2026-09-01
-
-### 变更
-
-- fix(ui): 9 个插件未定义 token danger-primary 改用 error-primary（DSH 主题仅定义 business/error/success/warn）
-
-## [0.3.2] - 2026-08-28
-
-### 变更
-
-- feat(ui): dsh-my-guardian 插件治理面板翻新——开关/图标/日志层级（issue #54）
-- refactor(shared): 抽取 dsh-shared 共享工具包，10 个插件迁移消除重复实现（issue #45）
-- chore(deps): 升级 react 19 兼容性——13 个插件 peer 声明 ^18.2.0 || ^19.2.0（issue #49）
-- style(format): 全仓 prettier 格式化（issue #44）
-- fix(ci): 并行化后的两个失败——Syntax check 对无 lib 的插件（dsh-plugin-dev-mode）用 if 结构；guardian waitFor 超时 3s→10s（并行环境更稳）
-
-## [0.3.1] - 2026-08-27
-
-### 变更
-
-- **npm 包名改为 `dsh-my-guardian`**：`bsfeng-dsh-guardian` → `dsh-my-guardian`，与 `dsh-my-*` 系列（dsh-my-skill-manager / dsh-my-plugin-manager / dsh-my-memory）统一，目录名 = 包名 = tag 名，避免与 npm 上他人同名包（`dsh-guardian`，lss1213）混淆。安装命令变为 `dsh plugin --profile web add dsh-my-guardian`。API 路径（`/guardian/api/*`）、状态文件路径（`$DSH_HOME/guardian/state.json`）、插件行 id（`guardian`）保持兼容。
-
-## [0.3.0] - 2026-08-26
-
-### 变更
-
-- refactor(guardian): 移除 dsh-better-sidebar 第三方依赖（#22）
-- docs+test: 全面审查修复——文档同步补全 + mermaid 测试增强
-
-## [0.2.1] - 2026-08-25
-
-### 变更
-
-- **npm 页面元数据优化**：description 改为中英双语（中文在前）；README 效果截图引用改为绝对 URL（unpkg），npm 包页面可直接显示图片。
-
-## [0.2.0] - 2026-08-25
-
-### 变更
-
-- **npm 包名改为 `bsfeng-dsh-guardian`**：npm 上 `dsh-guardian` 已被他人占用（lss1213 的插件），按用户确认改为 bsfeng 前缀。安装命令变为 `dsh plugin --profile web add link:<仓库路径>/plugins/dsh-guardian`（link 安装 key 同步）。API 路径（`/guardian/api/*`）与状态文件路径（`$DSH_HOME/guardian/state.json`）保持兼容。
-- **Server 端按 P2 模块拆分**：`lib/index.js`（636 行）拆分为 state/fence/events/mount/api 子模块；**Client 端方案 B 拆分**（src 模板 + 5 片段 + build 拼接）。
-- **README 补充真实 DSH 实例效果截图**（assets/panel-main.png + panel-error-detail.png，隔离实例实测）。
-- 行为不变（重构 + 改名）。
-
-## [0.1.0] - 2026-08-23
-
-### Added
-
-- 插件治理（dsh-guardian）首个版本：
-  - **两段式加载**：新插件写入候选区 `cordis.staged.json`（与 `cordis.patch.yml` 同目录），DSH 启动完成后由守护插件逐个热挂载，不阻塞启动。
-  - **失败隔离**：候选插件挂载失败自动记录（尝试次数 + 错误），连续失败 3 次冻结，不再自动重试。
-  - **成功转正**：挂载成功的插件自动进入守护插件的持久化清单（`$DSH_HOME/guardian/state.json`），后续每次启动自动恢复。
-  - **安全模式**：一键跳过所有候选/已转正插件的加载，快速恢复被插件搞坏的环境。
-  - **诊断面板**：dsh-better-sidebar 侧边栏页签（状态列表 / 重试 / 移除 / 错误详情 / 安全模式开关）。
-  - **事件监控**：`hmr/config-update-failed`、`loader/entry-init`、`loader/partial-dispose` 诊断事件记录。
-  - HTTP API `/guardian/api/*`（loopback 信任围栏）。
+- chore(quality): 补 TS 源码尺寸门禁 + dsh-my-guardian 契约测试
+- feat(ts): 补齐 dsh-my-context / dsh-my-guardian 的 client 端迁移
+- feat(dsh-my-guard): migrate to TypeScript
+- fix(dsh-my-guardian): 设置页 slots 首屏时序修复（ctx.get strict=false + 防回归测试）

package/README.md

@@ -1,132 +1,55 @@
 # dsh-my-guardian — 插件守护
 
-> DSH（DeepSeek Harness）插件隔离与失败兜底：**新装/刚更新的插件先进候选区，由守护插件在启动完成后逐个热挂载——成功自动转正，失败自动隔离记录，连续失败冻结，一键安全模式**，配套侧边栏诊断面板。
+[![插件生态](https://img.shields.io/badge/插件生态-topic%20dsh-4d6bfe)](https://github.com/topics/dsh)
 
-## 为什么需要
+**dsh-my-guardian**：DSH 插件隔离与失败兜底——新装/刚更新的插件先进候选区，启动完成后由守护插件逐个热挂载，成功自动转正、失败自动隔离、连续失败冻结，附一键安全模式与侧边栏诊断面板。
 
-DSH 的 Cordis 插件加载是 **all-or-nothing**：启动时任何插件 `import` 失败 / `apply` 抛错 / 依赖缺失，整个 `dsh web` 都会起不来（fail-loud 退出）。装一个新插件把环境搞坏，是插件用户最常踩的坑。
-
-本插件借鉴 VS Code（Extension Host 崩溃自动重启 + 禁用问题扩展）、IntelliJ（Dynamic Plugins 运行时装卸）、systemd（失败计数超限即停）的思路，利用 DSH loader 的**运行时动态挂载 API**（失败可捕获、可回滚），把"新插件"从启动路径挪到启动之后：
+![插件守护面板：候选失败隔离 + 转正运行中 + 安全模式开关](https://unpkg.com/dsh-my-guardian/assets/panel-main.png)
 
-```
-cordis.patch.yml（核心区：只放稳定插件，守护插件自身）
-        ↓ 新插件写进
-cordis.staged.json（候选区）
-        ↓ DSH 启动完成后
-守护插件逐个依赖预检 + 热挂载
-        ├─ 成功 → 自动转正（进入持久化清单，每次启动自动恢复）
-        └─ 失败 → 自动隔离（记录次数 + 失败类型/错误，连续 3 次冻结）
-```
+![失败自动隔离：错误详情可查](https://unpkg.com/dsh-my-guardian/assets/panel-error-detail.png)
 
 ## 功能
 
-- **两段式加载**：新装/更新插件先进候选区，启动不阻塞、坏插件不拖垮进程。
-- **失败自动隔离**：挂载失败自动记录（尝试次数 + 失败类型 + 错误摘要），连续失败 **3 次冻结**，需手动重试。
-- **挂载前依赖预检**：候选插件挂载前检查 `peerDependencies`——仓库内 `dsh-*` 依赖是否安装、官方依赖版本是否满足；缺失/不满足即标记「依赖缺失」并给出安装建议（如 `dsh plugin add <依赖>`），不进入挂载。
-- **成功自动转正**：挂载成功的插件进入持久化清单（`$DSH_HOME/guardian/state.json`），后续每次启动自动恢复挂载。
-- **安全模式**：一键跳过所有候选/已转正插件，快速恢复被插件搞坏的环境。
-- **诊断面板**：dsh-better-sidebar 侧边栏"插件守护"页签——状态列表 / 重试 / 移除 / 错误详情 / 失败分类徽标 / 安全模式开关 / 最近事件。
-- **运行中热挂载**：DSH 运行期间往候选区加条目，自动挂载，无需重启。
+- **两段式加载**：新插件先进候选区，坏插件不再拖垮 `dsh web` 启动（DSH 启动名册是 all-or-nothing，任一插件失败即整个进程起不来）。
+- **失败自动隔离**：挂载失败记录尝试次数 + 失败类型 + 错误摘要，连续失败 **3 次冻结**，需手动重试。
+- **挂载前依赖预检**：检查候选插件 `peerDependencies` 是否安装、版本是否满足，不满足标记「依赖缺失」并给安装建议，不进入挂载。
+- **成功自动转正**：挂载成功的插件进入持久化清单，后续启动自动恢复。
+- **运行中热挂载**：运行期间往候选区加条目即自动挂载，无需重启。
+- **安全模式**：一键跳过全部候选/已转正插件，快速救回被插件搞坏的环境。
+- **诊断面板**：侧边栏「插件守护」页签（宿主原生扩展点）——状态列表 / 重试 / 移除 / 错误详情 / 失败分类徽标 / 安全模式开关 / 最近事件。
 
 ## 安装
 
-> 💡 **npm 安装（普通用户推荐）**：`dsh plugin --profile web add dsh-my-guardian --trust-lockfile`——无需克隆本仓库；以下 link 方式供本仓库开发者使用。依赖 `dsh-shared`（server 端共享工具包）随 npm 自动安装，无需手动处理。
-
-### 方式一：dsh plugin（推荐）
+> 💡 **npm 安装（普通用户推荐）**：`dsh plugin --profile web add dsh-my-guardian --trust-lockfile`——无需克隆本仓库；依赖 `dsh-shared` 随 npm 自动安装。link 方式供本仓库开发者使用。
 
 ```sh
-# 1) 克隆本仓库（任意目录）
 git clone https://github.com/baosfeng/my-dsh-plugins.git
-# 2) 以本地 link 方式安装（将 <仓库路径> 替换为上面的克隆目录）
 dsh plugin --profile web add link:<仓库路径>/plugins/dsh-my-guardian
 ```
 
-装完**硬刷新浏览器**（Cmd/Ctrl+Shift+R）。
-
-### 方式二：手动
-
-1. 克隆本仓库后，在 `~/.dsh/profiles/web/package.json` 的 dependencies 增加 `"dsh-my-guardian": "link:<仓库路径>/plugins/dsh-my-guardian"`
-2. `cd ~/.dsh/profiles/web && pnpm install`
-3. 在 `~/.dsh/profiles/web/cordis.patch.yml` 的 insert 列表**第一行**加：
-
-```yaml
-- insert:
-    - id: guardian
-      name: 'dsh-my-guardian'
-```
-
-> ⚠️ **守护插件自身必须放在正式核心区第一行**（它自己是"看门狗"：启动时加载，随后才管理候选插件）。
+装完**硬刷新浏览器**（Cmd/Ctrl+Shift+R）。手动安装：在 profile 的 `cordis.patch.yml` insert 列表**第一行**加 `id: guardian` / `name: 'dsh-my-guardian'`——守护插件自己是看门狗，必须最先加载。
 
 ## 使用
 
-### 候选区文件
-
-新建 `~/.dsh/profiles/web/cordis.staged.json`（与 `cordis.patch.yml` 同目录）：
+候选区文件 `~/.dsh/profiles/web/cordis.staged.json`（与 `cordis.patch.yml` 同目录），每项为 `{ id, name, config? }`：`id` 唯一标识、`name` 插件包名（profile 内可解析）、`config` 可选配置。
 
 ```json
 [{ "id": "my-plugin", "name": "dsh-my-plugin", "config": { "option": 1 } }]
 ```
 
-- `id`：唯一标识（不能与现有插件行 id 冲突）
-- `name`：插件包名（profile node_modules 中可解析）
-- `config`：可选，插件的配置
-
-写入文件后守护插件会自动挂载；挂载成功该条自动从候选文件移除（转正），失败则保留（状态记录在面板中可见）。
-
-### 面板
-
-侧边栏 → "插件守护"页签：
+写入后自动挂载：成功则该条从候选文件移除（转正），失败则保留。面板状态：运行中（可移除）/ 待加载（安全模式等）/ 失败 ×N（重试或移除）/ 冻结（连续失败 3 次，重试解除冻结）。失败条目带失败类型徽标（依赖缺失 / 代码错误 / 其他），依赖缺失时附安装建议命令。
 
-| 状态    | 含义                   | 操作                   |
-| ------- | ---------------------- | ---------------------- |
-| 运行中  | 已挂载                 | 移除                   |
-| 待加载  | 尚未处理（安全模式等） | —                      |
-| 失败 ×N | 挂载失败 N 次          | 重试 / 移除            |
-| 冻结    | 连续失败 3 次          | 重试（解除冻结）/ 移除 |
-
-失败条目额外带**失败类型徽标**（依赖缺失 / 代码错误 / 其他），依赖缺失时并展示安装建议命令（如 `dsh plugin add dsh-shared`）。
-
-### 启动名册静态预检（issue #144）
-
-候选区只兜住"走候选区"的插件；**直接写进启动名册（`cordis.patch.yml` / profile / bundles）的插件仍由 DSH 启动时 all-or-nothing 加载**。守护在每次启动时对名册做静态预检（不实际加载插件）：
-
-- **包可解析**：名册中 `dsh-*` 插件的包必须在 profile node_modules 中存在
-- **peerDependencies 满足**：复用候选挂载的依赖预检
-- **无重复 entry id**：名册中同一 id 出现多次（加载时 `EntryGroup.update` 会抛 `duplicate loader entry id`）
-
-发现的问题写入 `$DSH_HOME/guardian/startup-issues.json`（原子写，名册健康也写空报告 + 检查时间），面板「最近事件」顶部**置顶**展示启动区问题，每条给出修复命令（`dsh plugin add ...`）与移除提示。**预检失败不阻断启动**——只记录、只告警，最坏情况是为启动失败留下排查记录。
-
-### 效果截图（真实 DSH 实例验证）
-
-侧边栏"插件守护"诊断面板（独立 3081 端口隔离 DSH 实例实测）：
-
-![插件守护面板：候选失败隔离 + 转正运行中 + 安全模式开关](https://unpkg.com/dsh-my-guardian/assets/panel-main.png)
-
-![失败自动隔离：错误详情可查](https://unpkg.com/dsh-my-guardian/assets/panel-error-detail.png)
-
-> 截图环境：隔离 DSH 验证实例（`/tmp/dsh-3085`，端口 3085）。候选区写入 `fake-needy`（peer 依赖 `fake-never-installed-dep` 缺失 → 依赖预检拦截，分类徽标「依赖缺失」+ 安装建议 `dsh plugin add fake-never-installed-dep` + 自动隔离冻结）与 `fake-simple`（无依赖 → 热挂载成功自动转正「运行中」）。
+**启动名册静态预检**：直接写进 `cordis.patch.yml` / profile / bundles 的插件仍由 DSH 启动时 all-or-nothing 加载，守护每次启动对名册做静态预检（包可解析、`peerDependencies` 满足、无重复 entry id），问题写入 `$DSH_HOME/guardian/startup-issues.json` 并在面板「最近事件」置顶展示；**预检只记录告警，不阻断启动**。
 
 ## 配置
 
-**无应用层配置项**（`apply(ctx)` 不接收 config 参数，设置页无可视化配置入口；插件激活即生效）。运行时状态与开关：
-
-- **状态文件**：`$DSH_HOME/guardian/state.json`（`~/.dsh/guardian/state.json`）——持久化候选/转正清单、失败次数、安全模式、事件日志。损坏自动降级为空状态，不影响启动。
-- **安全模式**：面板开关（或直接编辑 `state.json` 的 `safeMode: true`）。开启后所有候选/已转正插件不再加载；恢复环境后关闭开关即重新加载。
+**无应用层配置项**（插件激活即生效）。运行时状态：`$DSH_HOME/guardian/state.json` 持久化候选/转正清单、失败次数、安全模式与事件日志（损坏自动降级为空状态）；**安全模式**为面板开关，也可直接编辑 `state.json` 的 `safeMode: true`，开启后候选/已转正插件都不加载。
 
 ## 诚实的边界
 
-- 本插件提供的是**加载时序与失败处置的兜底隔离**，不是进程级资源隔离（server 端插件仍在同一 Node 进程，client 端仍在同一浏览器页面）。进程级隔离需要 DSH 框架支持 worker/子进程 + RPC（演进建议见 [docs/插件治理/概述.md](../../docs/插件治理/概述.md)）。
-- **启动阶段的正式核心区（`cordis.patch.yml`）仍遵循 all-or-nothing**。请把一切新插件先放入候选区验证，稳定后再考虑放核心区。
-
-## 依赖
-
-| 依赖                 | 用途                                                                                                           | 可选           |
-| -------------------- | -------------------------------------------------------------------------------------------------------------- | -------------- |
-| `cordis`             | 插件运行时                                                                                                     | 是（宿主提供） |
-| `dsh-better-sidebar` | 侧边栏「插件守护」诊断面板（**可选增强，不参与依赖声明**：未安装时自动跳过面板注册，API / 候选区治理不受影响） | 否（可选增强） |
-| `react`              | client 端组件                                                                                                  | 是（宿主提供） |
-| `dsh-my-notify`      | 失败 / 冻结事件浏览器通知                                                                                      | 是             |
+- 提供的是**加载时序与失败处置的兜底隔离**，不是进程级资源隔离（server 端插件仍在同一 Node 进程，client 端仍在同一浏览器页面）。
+- **启动阶段的正式核心区（`cordis.patch.yml`）仍遵循 all-or-nothing**：新插件请先进候选区验证，稳定后再考虑放核心区。
 
 ## 相关文档
 
-→ [插件治理概述](../../docs/插件治理/概述.md) · [需求清单](../../docs/插件治理/需求清单.md)
+→ [插件治理概述](../../docs/插件治理/概述.md)

package/lib/api.js

@@ -3,196 +3,191 @@
  * webServer service may mount after the guardian; poll ticks retry until it
  * appears), trust fence, method dispatch and the panel snapshot.
  */
-import { readStagedFile, writeStagedFile } from './state.js'
-import { isTrustedApiRequest, readJsonBody, writeJson } from 'dsh-shared'
-
+import { readStagedFile, writeStagedFile } from './state.js';
+import { isTrustedApiRequest, readJsonBody, writeJson } from 'dsh-shared';
 /** Bind the API entry points to one guardian instance's shared state. */
 export function createApi(ctx, shared) {
-  return {
-    ensureApi: () => ensureApi(ctx, shared),
-    snapshot: () => snapshot(shared),
-  }
+    return {
+        ensureApi: () => ensureApi(ctx, shared),
+        snapshot: () => snapshot(shared),
+    };
 }
-
 /**
  * Register the /guardian/api routes once the webServer service appears
  * (optional surface; CLI profiles skip it). Retried on every poll tick.
  */
 function ensureApi(ctx, shared) {
-  if (shared.apiRegistered) return
-  const webServer = ctx.get('webServer')
-  if (webServer === undefined) return
-  const webRuntime = ctx.get('webRuntime')
-  shared.apiRegistered = true
-  try {
-    ctx.effect(
-      () =>
-        webServer.register({
-          kind: 'prefix',
-          path: '/guardian/api',
-          handler: (request, response) => handleApiRequest(ctx, shared, webRuntime, request, response),
-        }),
-      'dsh-my-guardian: /guardian/api routes',
-    )
-  } catch (error) {
-    // registration failed: allow a later poll tick to retry
-    shared.apiRegistered = false
-    ctx.logger?.warn(
-      `[dsh-my-guardian] api registration failed: ${error instanceof Error ? error.message : String(error)}`,
-    )
-  }
+    if (shared.apiRegistered)
+        return;
+    const webServer = ctx.get('webServer');
+    if (webServer === undefined)
+        return;
+    const webRuntime = ctx.get('webRuntime');
+    shared.apiRegistered = true;
+    try {
+        ctx.effect(() => webServer.register({
+            kind: 'prefix',
+            path: '/guardian/api',
+            handler: (request, response) => handleApiRequest(ctx, shared, webRuntime, request, response),
+        }), 'dsh-my-guardian: /guardian/api routes');
+    }
+    catch (error) {
+        // registration failed: allow a later poll tick to retry
+        shared.apiRegistered = false;
+        ctx.logger?.warn(`[dsh-my-guardian] api registration failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
 }
-
 /** Unified route handler: fence → method dispatch → 404/error fallback. */
 async function handleApiRequest(ctx, shared, webRuntime, request, response) {
-  if (!isTrustedApiRequest(request, webRuntime?.trustedHosts ?? [])) {
-    writeJson(response, 403, { ok: false, error: { code: 'forbidden', message: 'forbidden' } })
-    return
-  }
-  const url = new URL(request.url ?? '/', 'http://dsh.internal')
-  const method = url.pathname.startsWith('/guardian/api/') ? url.pathname.slice('/guardian/api/'.length) : ''
-  try {
-    await dispatchApiMethod(ctx, shared, method, request, response)
-  } catch (error) {
-    writeJson(response, 400, {
-      ok: false,
-      error: { message: error instanceof Error ? error.message : String(error) },
-    })
-  }
+    if (!isTrustedApiRequest(request, webRuntime?.trustedHosts ?? [])) {
+        writeJson(response, 403, { ok: false, error: { code: 'forbidden', message: 'forbidden' } });
+        return;
+    }
+    const url = new URL(request.url ?? '/', 'http://dsh.internal');
+    const method = url.pathname.startsWith('/guardian/api/') ? url.pathname.slice('/guardian/api/'.length) : '';
+    try {
+        // 启动扫描（loadState + promoted 挂载 + API 注册）完成前不派发：否则
+        // retry/state 会读到"半加载"的空 state——CI 上实测变成 404 not found
+        // （固定 sleep 赌 loadState 跑完，慢机器上必然偶发赌输）。
+        await shared.bootPromise;
+        await dispatchApiMethod(ctx, shared, method, request, response);
+    }
+    catch (error) {
+        writeJson(response, 400, {
+            ok: false,
+            error: { message: error instanceof Error ? error.message : String(error) },
+        });
+    }
 }
-
 /** Dispatch one API method to its handler; unknown methods get 404. */
 async function dispatchApiMethod(ctx, shared, method, request, response) {
-  if (method === 'state' && request.method === 'GET') {
-    writeJson(response, 200, { ok: true, value: shared.snapshot() })
-    return
-  }
-  if (request.method !== 'POST') {
-    writeJson(response, 404, { ok: false, error: { message: 'unknown guardian API method' } })
-    return
-  }
-  if (method === 'staged') {
-    await handleStagedPost(ctx, shared, request, response)
-    return
-  }
-  if (method === 'retry') {
-    await handleRetryPost(ctx, shared, request, response)
-    return
-  }
-  if (method === 'remove') {
-    await handleRemovePost(ctx, shared, request, response)
-    return
-  }
-  if (method === 'safemode') {
-    await handleSafemodePost(ctx, shared, request, response)
-    return
-  }
-  writeJson(response, 404, { ok: false, error: { message: 'unknown guardian API method' } })
+    if (method === 'state' && request.method === 'GET') {
+        writeJson(response, 200, { ok: true, value: shared.snapshot() });
+        return;
+    }
+    if (request.method !== 'POST') {
+        writeJson(response, 404, { ok: false, error: { message: 'unknown guardian API method' } });
+        return;
+    }
+    if (method === 'staged') {
+        await handleStagedPost(ctx, shared, request, response);
+        return;
+    }
+    if (method === 'retry') {
+        await handleRetryPost(ctx, shared, request, response);
+        return;
+    }
+    if (method === 'remove') {
+        await handleRemovePost(ctx, shared, request, response);
+        return;
+    }
+    if (method === 'safemode') {
+        await handleSafemodePost(ctx, shared, request, response);
+        return;
+    }
+    writeJson(response, 404, { ok: false, error: { message: 'unknown guardian API method' } });
 }
-
 /** POST /guardian/api/staged — add a candidate entry and mount it. */
-async function handleStagedPost(ctx, shared, request, response) {
-  const payload = await readJsonBody(request)
-  const id = typeof payload.id === 'string' ? payload.id : ''
-  const name = typeof payload.name === 'string' ? payload.name : ''
-  if (id === '' || name === '') {
-    writeJson(response, 400, { ok: false, error: { message: 'id and name are required' } })
-    return
-  }
-  if (shared.conflictOf(id) !== null) {
-    writeJson(response, 409, { ok: false, error: { message: `id "${id}" already in use` } })
-    return
-  }
-  const entries = await readStagedFile(shared.stagedFile)
-  if (entries.some((item) => item?.id === id)) {
-    writeJson(response, 409, {
-      ok: false,
-      error: { message: `"${id}" already in the staged file` },
-    })
-    return
-  }
-  entries.push({ id, name, ...(payload.config !== undefined ? { config: payload.config } : {}) })
-  const writeError = await writeStagedFile(shared.stagedFile, entries)
-  if (writeError !== null) throw writeError
-  await shared.scanStaged()
-  writeJson(response, 200, { ok: true, value: shared.snapshot() })
+async function handleStagedPost(_ctx, shared, request, response) {
+    const payload = await readJsonBody(request);
+    const id = typeof payload.id === 'string' ? payload.id : '';
+    const name = typeof payload.name === 'string' ? payload.name : '';
+    if (id === '' || name === '') {
+        writeJson(response, 400, { ok: false, error: { message: 'id and name are required' } });
+        return;
+    }
+    if (shared.conflictOf(id) !== null) {
+        writeJson(response, 409, { ok: false, error: { message: `id "${id}" already in use` } });
+        return;
+    }
+    const entries = await readStagedFile(shared.stagedFile);
+    if (entries.some((item) => item?.id === id)) {
+        writeJson(response, 409, {
+            ok: false,
+            error: { message: `"${id}" already in the staged file` },
+        });
+        return;
+    }
+    entries.push({ id, name, ...(payload.config !== undefined ? { config: payload.config } : {}) });
+    const writeError = await writeStagedFile(shared.stagedFile, entries);
+    if (writeError !== null)
+        throw writeError;
+    await shared.scanStaged();
+    writeJson(response, 200, { ok: true, value: shared.snapshot() });
 }
-
 /** POST /guardian/api/retry — manual unfreeze of a staged/promoted entry. */
-async function handleRetryPost(ctx, shared, request, response) {
-  const payload = await readJsonBody(request)
-  const id = typeof payload.id === 'string' ? payload.id : ''
-  const outcome = await shared.retryEntry(id)
-  if (outcome === null) {
-    writeJson(response, 404, { ok: false, error: { message: `no such entry "${id}"` } })
-  } else {
-    writeJson(response, 200, { ok: true, value: { outcome } })
-  }
+async function handleRetryPost(_ctx, shared, request, response) {
+    const payload = await readJsonBody(request);
+    const id = typeof payload.id === 'string' ? payload.id : '';
+    const outcome = await shared.retryEntry(id);
+    if (outcome === null) {
+        writeJson(response, 404, { ok: false, error: { message: `no such entry "${id}"` } });
+    }
+    else {
+        writeJson(response, 200, { ok: true, value: { outcome } });
+    }
 }
-
 /** POST /guardian/api/remove — drop an entry everywhere. */
-async function handleRemovePost(ctx, shared, request, response) {
-  const payload = await readJsonBody(request)
-  const id = typeof payload.id === 'string' ? payload.id : ''
-  await shared.removeEntry(id)
-  writeJson(response, 200, { ok: true, value: shared.snapshot() })
+async function handleRemovePost(_ctx, shared, request, response) {
+    const payload = await readJsonBody(request);
+    const id = typeof payload.id === 'string' ? payload.id : '';
+    await shared.removeEntry(id);
+    writeJson(response, 200, { ok: true, value: shared.snapshot() });
 }
-
 /** POST /guardian/api/safemode — toggle safe mode (R5). */
-async function handleSafemodePost(ctx, shared, request, response) {
-  const payload = await readJsonBody(request)
-  const enabled = payload.enabled === true
-  shared.state.safeMode = enabled
-  shared.logEvent('safe-mode', enabled ? 'safe mode enabled' : 'safe mode disabled')
-  if (enabled) {
-    for (const id of [...shared.mounted]) await shared.unmount(id)
-  } else {
-    shared.attempted.clear()
-    await shared.scanStaged()
-    await shared.mountPromoted()
-  }
-  shared.persistSoon()
-  writeJson(response, 200, { ok: true, value: shared.snapshot() })
+async function handleSafemodePost(_ctx, shared, request, response) {
+    const payload = await readJsonBody(request);
+    const enabled = payload.enabled === true;
+    shared.state.safeMode = enabled;
+    shared.logEvent('safe-mode', enabled ? 'safe mode enabled' : 'safe mode disabled');
+    if (enabled) {
+        for (const id of [...shared.mounted])
+            await shared.unmount(id);
+    }
+    else {
+        shared.attempted.clear();
+        await shared.scanStaged();
+        await shared.mountPromoted();
+    }
+    shared.persistSoon();
+    writeJson(response, 200, { ok: true, value: shared.snapshot() });
 }
-
 /** One row for the panel: status + failure-classification fields (issue #86). */
 function entrySnapshot(shared, id, record, isStaged) {
-  const status = shared.mounted.has(id)
-    ? 'running'
-    : record.frozen
-      ? 'frozen'
-      : record.attempts > 0
-        ? 'failed'
-        : 'pending'
-  const item = {
-    id,
-    name: record.name,
-    attempts: record.attempts,
-    frozen: record.frozen,
-    lastError: record.lastError,
-    lastFailedAt: record.lastFailedAt,
-    failureType: record.failureType ?? null,
-    missingDeps: record.missingDeps ?? [],
-    installHint: record.installHint ?? null,
-    status,
-  }
-  if (!isStaged) item.promotedAt = record.promotedAt
-  return item
+    const status = shared.mounted.has(id)
+        ? 'running'
+        : record.frozen
+            ? 'frozen'
+            : record.attempts > 0
+                ? 'failed'
+                : 'pending';
+    const item = {
+        id,
+        name: record.name,
+        attempts: record.attempts,
+        frozen: record.frozen,
+        lastError: record.lastError,
+        lastFailedAt: record.lastFailedAt,
+        failureType: record.failureType ?? null,
+        missingDeps: record.missingDeps ?? [],
+        installHint: record.installHint ?? null,
+        status,
+    };
+    if (!isStaged)
+        item.promotedAt = record.promotedAt;
+    return item;
 }
-
 /** Snapshot for the panel (leaf values only). */
 function snapshot(shared) {
-  const stagedList = Object.entries(shared.state.staged).map(([id, record]) => entrySnapshot(shared, id, record, true))
-  const promotedList = Object.entries(shared.state.promoted).map(([id, record]) =>
-    entrySnapshot(shared, id, record, false),
-  )
-  return {
-    safeMode: shared.state.safeMode,
-    staged: stagedList,
-    promoted: promotedList,
-    events: shared.state.events.slice(-10),
-    // startup-roster pre-check report (issue #144): empty array = healthy
-    startupIssues: Array.isArray(shared.startupIssues) ? shared.startupIssues : [],
-    startupCheckedAt: typeof shared.startupCheckedAt === 'number' ? shared.startupCheckedAt : null,
-  }
+    const stagedList = Object.entries(shared.state.staged).map(([id, record]) => entrySnapshot(shared, id, record, true));
+    const promotedList = Object.entries(shared.state.promoted).map(([id, record]) => entrySnapshot(shared, id, record, false));
+    return {
+        safeMode: shared.state.safeMode,
+        staged: stagedList,
+        promoted: promotedList,
+        events: shared.state.events.slice(-10),
+        // startup-roster pre-check report (issue #144): empty array = healthy
+        startupIssues: Array.isArray(shared.startupIssues) ? shared.startupIssues : [],
+        startupCheckedAt: typeof shared.startupCheckedAt === 'number' ? shared.startupCheckedAt : null,
+    };
 }