@yanglaofish/fishtools 0.5.2 → 0.5.3

package/manual/docs/superpowers/specs/2026-10-13-issue-5-results-and-history.md

@@ -0,0 +1,20 @@
+# Issue #5：插件范围、生成文件与执行记录
+
+来源：[发现严重缺陷](https://github.com/yanglaofish/Fishtools/issues/5)。已读取正文、完整评论列表（当前无评论）以及私有附件截图；截图确实显示 `environment-report.md/json` 保存到工作区 `.flow/runs/运行ID/`。
+
+## 事实与修改范围
+
+- 用户确认普通安装应全局可用。CLI/TUI 默认安装和链接到用户级插件库，普通工作区自动读取同一份插件版本。工作流、插件参数、代理规则和运行状态仍由各工作区保存。
+- 已有工作区安装兼容读取；同名全局插件优先。全局卸载后不自动复活旧工作区同名版本。未配置的全局插件显示“待配置”，不能阻止无关工作区启动。卸载检查已登记工作区的工作流引用，原插件状态保留恢复备份，活动安装批次由租约保护。
+- 离线分发包继续使用包内代码快照及其可写工作区，不读取机器上的全局插件库。程序调用 `createApplication` 可通过 `pluginRegistryDir` 接入共享库；未传时保留原有工作区安装兼容行为。
+- 插件 `ctx.outputDir` 与日志目录相同是实际问题。新增真实插件探针保存 `result.json` 时，业务文件会被内核的同名记录覆盖；这构成数据覆盖风险。
+- 新运行的业务文件改为工作区 `results/运行ID/`，每次运行独立；日志继续在 `.flow/runs/运行ID/`。显式 `--output` 或 `FLOW_OUTPUT_DIR` 的日志路径保持兼容，业务文件放到其 `files/运行ID/`。只读运行包使用可写输出目录。
+- `ctx.outputDir` 继续表示可写业务输出目录，新增 `ctx.logDir` 明确日志路径；`app.outputDir` 继续指向日志根，`app.resultsDir` 表示业务结果根。插件仍须通过返回值或 `print()` 报告文件路径。
+- 不移动、覆盖或删除历史目录与业务文件；日志保留策略继续只清理日志，不清理新业务结果。只移除本次创建且保持为空的结果目录。
+- 暂无重复运行记录的证据：真实工作流内嵌子工作流和插件动作仍只生成一条顶层记录。原列表混列不同入口且没有会话标识，确实难以区分。
+- 新记录保留执行类型、名称与应用启动会话。TUI 标明四类入口及本次/历史启动，支持筛选本次启动、工作流、插件调用或系统命令；默认显示最近 20 条，可继续加载。旧记录可读，按旧目标标识推断类型，不推断未知会话。
+
+## 验证
+
+先补失败探针，确认业务文件与日志隔离、同名文件不覆盖、日志清理保留结果、空目录回收、嵌套调用不重复记录、类型与会话在重启后持久可读、TUI 筛选准确。
+修改后覆盖原有日志写入失败注入、实时落盘、保留策略与 TUI 会话回归。日志故障注入明确操作 `logDir`，不再通过业务输出同名文件模拟故障。

package/manual/docs/terminal-commands.md

@@ -6,6 +6,8 @@
 
 Windows 默认使用 Windows PowerShell，Linux 默认使用 sh。命令按照所选 Shell 的语法解释；管道、引号、重定向和换行保持原样。此入口适合无需交互输入的命令，暂不接管需要 stdin 或全屏界面的程序。
 
+Windows 自动模式下，简单单行 `!ipconfig`、`!ipconfig /all` 使用系统程序及其 OEM 编码，中文输出可以直接在主面板阅读，不改变主终端编码。含管道、展开或重定向的复杂脚本继续按 PowerShell 语法执行；其他程序仍保留 UTF-8 输出，不能把整个混合脚本统一按 GBK 解释。当前自动适配支持系统代码页 866、874、932、936、949、950、65001，其他代码页沿用原 Shell。
+
 ## 多行编辑
 
 | 按键 | 行为 |
@@ -31,6 +33,8 @@ Windows PowerShell 请使用其续行符反引号或括号语法，也可粘贴
 
 输入 `/commands` → **注册常用命令**，填写名称和命令文本，选择保存即可。名称合法时自动建立同名快捷入口。例如 Linux 中注册“查看本机IP”，文本填 `ifconfig`，以后输入 `/查看本机IP` 就能运行。目标机器需已经安装 `ifconfig`；也可注册机器实际具备的 `ip address` 或 Windows `ipconfig`。
 
+编辑已有命令或快捷名称后，内容没有变化时直接返回，不创建备份、不重启插件；已有命令未设置快捷名称时也不会自动补上。只在新注册命令时按合法名称建立默认快捷入口。
+
 高级设置可选择 Shell、超时时间、参数及 Linux root 权限要求。超时时间为秒，`0` 表示不限时。root 需求会在执行前检查，工具不会自动提权。修改命令仍保留原有动作 ID，已保存工作流继续引用它；被工作流使用的命令不能直接删除，需先调整引用。
 
 不填写参数时无需编写输入 schema，也不会弹出空 JSON 输入框。需要参数时添加简单字段（文本、数字、是/否，可设置默认值及必填），脚本通过环境变量读取：
@@ -59,6 +63,10 @@ Write-Output $env:FST_INPUT_name
 
 常用命令和快捷名称保存在 `flow.project.json` 的 `commandPresets`、`shortcuts` 字段。修改前原文件备份到 `.flow/backups/`，同一字段被其他实例改动时拒绝覆盖并提示重新打开工作区。
 
+`/logs` 中每次顶层执行只有一条记录，标明工作流、插件动作、插件命令或系统命令，可筛选本次启动的执行或某类调用。条件、并行和子工作流的内部步骤放在同一条运行记录里；菜单浏览及本次 TUI 命令历史不会产生持久化运行记录。旧记录继续可读，没有会话标识的旧记录不冒充本次启动。
+
+输入与反馈另外保存为 TUI 会话：`/history` 可恢复并继续，或分页阅读完整交互；不会重跑历史指令。工作区内 `.flow/sessions/` 保存快照与追加日志，只读包保存到可写日志目录下。恢复近期面板和命令历史，较大结果和完整指令执行过程从 `/logs` 读取；在详情中按 m 格式化阅读，j 查看原始诊断。
+
 命令快捷项由界面同时保存 `command` 与目标 `plugin` 标识，以免同名能力接管入口；填写参数和确认权限后，执行前再次核对提供者身份。配置 API 可为新建或改变目标的快捷名补齐当前提供者；手工导入却未提供 `plugin` 的旧项需重新选择目标，修改名称、默认参数或保存其他设置都不会顺带启用它。保存或复制工作流草稿时也会核对最新注册项，避免另一实例删除命令后保存悬空引用。
 
 导出选定工作流时携带其使用的命令定义和相关快捷名称；便携工作台携带全部注册能力。导出后的可编辑工作区可修改并再次导出；只读运行包可以执行，不能修改。外部程序和 Shell 需由目标机器提供，不会因为注册命令就把它们包含在包内。

package/manual/docs/verification.md

@@ -1,5 +1,28 @@
 # 验收记录
 
+## 0.5.3 全局插件、结果保护与准确提示（2026-10-13）
+
+- 分支 `codex/issue-4-node-compat`，固定基线 `46a897450e122054dcfab882de5be061b311570f`；读取 issue #4 正文、评论及截图和 issue #5 正文及截图，采用用户确认的普通插件全局安装范围。
+- 实际复现业务 `result.json` 被内核记录覆盖，新增独立 `results/运行ID/`，日志保留只作用于日志；类型、名称及启动会话随执行记录保存，嵌套调用仍只生成一条顶层记录。历史业务文件没有移动或删除。
+- 全局安装和开发链接在多个工作区共享，参数仍由工作区保存；配置缺失只影响对应插件及其消费者。测试覆盖并发状态、跨工作区引用、待配置启用、全局开发监听和离线分发隔离。
+- TUI 全面核对工作流脏状态、备份删除、无实际修改的配置保存、默认值、完成任务取消入口及草稿打包提示。只保留与实际状态相符的提醒。
+- Standards / Spec 两轴独立审查共确认 3 个不同问题，均补失败探针后修正：活动旧安装目录的租约、跨工作区本地消费者的间接依赖、被全局覆盖或屏蔽的旧源码导入。额外自检统一待配置项静态校验；相关回归 **71/71** 通过，详见[审查记录](superpowers/reviews/2026-10-13-0.5.3-review.md)。
+- 全局插件阶段 `npm run dist:npm` 成功，本地归档 **9,825,324 字节、284 个生产包**。Windows/Node 24.15.0 完整测试 **536 项：534 通过、0 失败、2 跳过**，201.7 秒，使用该阶段归档验证离线安装、脱离源码运行及再次导出。
+- Node 22.12.0 的 Windows 再导出试验多次出现原生进程崩溃，没有确认其底层原因；22.22.2 与 24.11.1 的同一测试通过。产品声明为 `^22.22.2 || >=24.0.0`，便携版仍固定使用经过 SHA 校验的 Node 24.15.0。
+- 验收脚本适配 npm 11.19.1 发布预演按包名返回的 JSON；实际安装仍使用 `--engine-strict`，不放宽不兼容依赖检查。完整兼容验收与正式发布结果完成后追加。
+- 后续合入用户要求的可读步骤、指令追踪、结果渲染、面板计时、完整会话恢复、TUI 内平台提示和 Windows 中文 ipconfig。独立 Standards / Spec 复核均无剩余发布阻塞问题，详见[增量审查记录](superpowers/reviews/2026-10-13-tui-sessions-review.md)。
+- 实际 TUI 处理路径执行 `!ipconfig` 与 `!ipconfig /all` 均显示中文，替换字符 0 个，stdout 流与同次返回正文一致。日志收尾失败、历史磁盘优先及关闭页面内存回收均经历失败复现再修复；最终相关回归 Node 24.15.0 **27/27**、Node 22.22.2 **34/34**。
+- 可读会话阶段完整回归 **576 项：574 通过、0 失败、2 跳过**，185.4 秒；后续历史优先及 GC 专项修正通过上述定向回归。正式发布从最终提交重建同一归档，在支持的平台和 Node 版本执行完整验收后才上传 npm。
+- 首次正式发布验收的 Windows / Node 24.0 出现日志文件身份误判，调查发现官方源码中路径和句柄查询的卷编号宽度不同；其余 7 组完整兼容验收及双平台便携包通过，发布步骤跳过，npm 0.5.3 尚未上传。修复保持完整 BigInt 文件 ID，并统一 Windows 卷编号低 32 位；两轴独立复核均无阻塞。本地相关用例在 24.0 与 24.15 各 41 通过、1 跳过，正式原平台复跑待完成。
+- Linux 停止进程的测试探针遇到进程已退出但 `/proc` 读取返回 ESRCH 的竞争窗口；将 ESRCH 与 ENOENT 同样视为已退出，其余错误继续传播，存活及心跳业务断言保留。[四组主分支 CI](https://github.com/yanglaofish/Fishtools/actions/runs/38393256411) 已全部通过。
+- Windows / Node 24.0 后续本地完整回归 580 项：577 通过、1 失败、2 跳过；唯一失败为有效打包缓存仍被截断重写导致并发读到半成品。增加失败断言后修复为缓存命中只读、冷缓存先校验再原子替换，Node 24.0 定向 7/7 通过。最终完整验收及发布结果完成后追加，不把该次失败记录当作通过证据。
+- Windows 并发原子替换的 EPERM 经独立探针复现并修正，仅接受目标完整内容完全相同的胜出缓存，真实替换错误仍传播。最终缓存回归 Node 24.0 与 24.15 各 4/4 通过。
+- 缓存及文件身份修复后的最终本地 Node 24.0 完整回归 **584 项：582 通过、0 失败、2 跳过**，214.9 秒。`dist:npm` 生成 **9,855,545 字节、284 个生产包**的本地归档，完整测试使用该归档执行离线安装与再次导出；最终文档归档后正式发布流程会从 tag 重新生成并对同一发行归档执行完整矩阵。
+- [第二次正式验收](https://github.com/yanglaofish/Fishtools/actions/runs/38397457051)中，其余 6 组兼容验收与双平台便携包通过，发布步骤仍跳过。Windows / Node 24.0 的真实诊断为路径设备编号 `0`、句柄设备编号 `742408122`，完整文件 ID 同为 `7036874418249441`；因此此前卷编号宽度推断不足以解释此平台失败。新增第二个只读路径句柄，严格比较两个句柄的完整 BigInt 身份，并重新检查路径仍为普通非链接文件；不把未知编号 `0` 当成通配符，原归属及读取预算继续生效。
+- 同次 Windows / Node 24.11.1 唯一失败为 Web 测试过早断言仍运行中的任务。只把约 600 毫秒的固定轮询改为 10 秒内等待真实结束；成功状态、输出、鉴权和路由断言保留。
+- 上述增量包含真实路径替换拒绝和链接拒绝探针。Windows 本地 Node 24.0、24.11.1、24.15.0 各执行同一组定向回归 **54 项：52 通过、0 失败、2 项文件链接权限跳过**。新增 Windows 24.0/24.11 定向 CI，保留原全量矩阵，真实失败文件系统及最终发行归档复验待完成。
+- 新增定向 CI 首次提交因 job 级 `env` 无法使用 `runner.temp` 而未启动测试；按 GitHub 官方上下文范围把隔离目录变量移至测试步骤级，不改变测试内容和原全量门禁，重新执行远端验收。
+
 ## 0.5.2 命令注册与快捷名称（2026-10-13）
 
 - 分支 `codex/0.5.2-command-shortcuts`，固定基线 `68a84cd`；按用户指定目标集中实现 `!` 系统命令、`/commands` 注册动作、`/shortcuts` 任意动作或命令的中文快捷名称与默认参数。
@@ -18,6 +41,13 @@
   合入后本地重建归档 **9,806,640 字节、285 个生产包**，指定该归档完整 `npm test` **489 项：487 通过、0 失败、2 跳过**，186.3 秒。
   补充范围 `8223bad...c567534` 的独立 Standards / Spec 复审均通过，新增确认问题均为 0。
   最终双平台验收重新执行，完成后核对正式发布产物；待发布 tag 更新前检查旧对象和未发布状态，不覆盖已发布版本。
+- 合入后的 [正式发布流程](https://github.com/yanglaofish/Fishtools/actions/runs/38361266757)全部成功；同一 npm 归档在 Windows 和 Ubuntu 均为 **489 项：488 通过、0 失败、1 项平台专用跳过**。
+  两平台自包含包、无 Node 的断网只读 Debian 容器通过；[主分支 CI](https://github.com/yanglaofish/Fishtools/actions/runs/38361020862)两平台也通过。
+  最终发布 tag 固定于 `fdb62c1367fe80d985d3292a5fe92f4e88dbb813`；之后的验收记录不改变发行产物。
+- npm 官方注册表 `latest` 为 **0.5.2**；独立下载公开 tarball 为 **9,806,832 字节**，SHA-512 与注册表 integrity 一致，
+  SHA-256 `e48954b03a455bcc9997b2b6075b1c4a8a29e343c2eb1af342e8ca51cf0d649c` 与 [Release](https://github.com/yanglaofish/Fishtools/releases/tag/v0.5.2) 的 `SHA256SUMS` 一致。
+- Release 已公开于仓库访问范围，含 npm、Windows（52,523,594 字节）、Linux（58,075,911 字节）归档及校验文件。
+  issue #4 修正与 Shift+Enter / Enter 按键说明进入同一 0.5.2；没有另发版本或覆盖已发布包。
 
 ## 0.5.1 全代际复核修正（2026-10-13）
 

package/manual/packages/core/README.md

@@ -25,6 +25,8 @@
 
 ## 维护与验证
 
+`createApplication({projectDir,pluginRegistryDir})` 可让多个工作区读取同一插件库；CLI 默认接入用户级全局库，程序未传此选项时保留工作区模式。分发包始终使用自身工作区安装状态。`listPlugins()` 返回 scope/source 和待配置原因；`pluginDefinition(id)` 返回作者声明。`app.resultsDir` 是业务文件根，`app.outputDir` 保留为日志根；插件 `ctx.outputDir` 与 `ctx.logDir` 分别对应本次业务目录和日志目录。
+
 `app.startShell(script,options)` 执行临时命令，`app.startAction(id,input,context)` 调用任意动作，两者均纳入运行记录与关闭等待。`startCommand(name,input,{expectedPlugin,...context})` 可固定命令提供者，启动时再次检查，防止参数填写期间被其他同名能力替换。`configureCommandPresets` 和 `configureShortcuts` 在备份、冲突检查与变更锁内保存项目设置；命令快捷项在用户明确设置时绑定提供者 ID，普通安装/卸载和未改变目标的整组保存不会重新绑定；已有未绑定项必须明确提供 plugin 或在界面重新选择目标。注册项变化通过定向宿主更新生效，导出快照保留所需定义与有效快捷项。
 
 本模块负责上述职责的实现、文档与回归；跨模块接口调整需要同时检查生产者与消费者。具体维护人员尚未指定。

package/manual/packages/core/package.json

@@ -19,7 +19,7 @@
   ],
   "license": "MIT",
   "engines": {
-    "node": ">=24.15.0"
+    "node": "^22.22.2 || >=24.0.0"
   },
   "dependencies": {
     "@mytools/commands": "0.1.0",

package/manual/packages/core/src/application.js

@@ -1,4 +1,4 @@
-import { mkdir, readFile, writeFile, rename, rm } from 'node:fs/promises';
+import { mkdir, readFile, writeFile, rename, rm, rmdir } from 'node:fs/promises';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { EventEmitter } from 'node:events';
@@ -25,6 +25,8 @@ import {openPluginState,withPluginMutation,assertPluginState,savePluginState,lea
 import {planPluginUpdate,changedPluginSources} from './plugin-update.js';
 import {validateNetworkPolicy,inspectNetworkPolicy,resolveNetworkPolicy,buildProcessEnv} from '@mytools/fst-platform/network';
 import {resolvePrivilegeRequirement,checkStaticPrivilege} from '@mytools/fst-plugin/privileges';
+import {registerWorkspace,registryWorkflowReferences,registryPluginReferences} from '@mytools/fst-workspace/registry';
+import {mergePluginEntries,preparePluginCatalog} from './plugin-catalog.js';
 
 function declaredCommands(entries){
   return entries.flatMap(entry=>{const plugin=entry.plugin??entry;return Object.keys(plugin.commands??{}).map(name=>({name,plugin:plugin.id}));});
@@ -39,10 +41,13 @@ function workflowActions(steps,found=new Set()){
   return found;
 }
 
-export async function createApplication({projectDir=process.cwd(),workspace,outputDir,plugins,config={},maintenance=false,omitInstalledPlugin,allowUnknownPrivileges=false}={}) {
+export async function createApplication({projectDir=process.cwd(),workspace,pluginRegistryDir,outputDir,plugins,config={},maintenance=false,omitInstalledPlugin,allowUnknownPrivileges=false}={}) {
   projectDir=await prepareBundleWorkspace(path.resolve(projectDir),workspace);
   const project=await readJson(path.join(projectDir,'flow.project.json'),{plugins:[]});
-  const output=path.resolve(outputDir??process.env.FLOW_OUTPUT_DIR??(project.readOnly?path.join(process.cwd(),'flow-results'):path.join(projectDir,'.flow','runs')));
+  const requestedOutput=outputDir??process.env.FLOW_OUTPUT_DIR;
+  const output=path.resolve(requestedOutput??(project.readOnly?path.join(process.cwd(),'flow-results'):path.join(projectDir,'.flow','runs')));
+  const results=path.resolve(requestedOutput||project.readOnly?path.join(output,'files'):path.join(projectDir,'results'));
+  const sessionId=randomUUID();
   const store=new WorkflowStore(path.join(projectDir,'workflows'));
   const emitter=new EventEmitter(), runs=new Map(),journals=new WeakMap();
   const resources=createResources(),operations=new Set();let closing,launching=0;
@@ -51,17 +56,24 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
   if(!Number.isSafeInteger(maxCachedRuns)||maxCachedRuns<1||maxCachedRuns>1000)throw new FlowError('maxCachedRuns 必须为 1 到 1000 的整数');
   const fileProbe=createFileProbe(project.fileAccess);
   validateKeepRuns(project.logs?.keepRuns??null);
-  const opened=await openPluginState(projectDir,{readOnly:project.readOnly});
-  let host,state=opened.state,busy=false;
+  const registryDir=path.resolve(pluginRegistryDir&&!project.readOnly&&!project.baseBundle?pluginRegistryDir:projectDir),shared=registryDir!==projectDir;
+  if(shared)await registerWorkspace(registryDir,projectDir);
+  const opened=await openPluginState(registryDir,{readOnly:project.readOnly});
+  const localOpened=shared?await openPluginState(projectDir):null;
+  let host,state=opened.state,localState=localOpened?.state,busy=false,pending=new Map(),catalogEntries=[],localEntries=[];
   const installationLeases=new Map();
   if(state.root)installationLeases.set(path.resolve(state.root),opened.release);
+  if(localState?.root)installationLeases.set(path.resolve(localState.root),localOpened.release);
+  const withRegistryMutation=callback=>withPluginMutation(registryDir,()=>shared?withPluginMutation(projectDir,callback):callback());
+  const assertStates=async()=>{await assertPluginState(registryDir,state);if(shared)await assertPluginState(projectDir,localState);};
   const app={
-    projectDir,project,outputDir:output,store,
+    projectDir,project,pluginRegistryDir:registryDir,pluginScope:shared?'global':'workspace',outputDir:output,resultsDir:results,sessionId,store,
     get host(){return host;},
     get maintenance(){return maintenance;},
     developmentStatus:()=>({running:launching+writingRuns.size+operations.size,busy,closing:!!closing}),
     catalog:()=>host.catalog(),
-    listPlugins:()=>[...host.definitions.values()].map(p=>({id:p.id,version:p.version,title:p.title,description:p.description,platforms:p.platforms,architectures:p.architectures,environments:p.environments,config:p.config,requirements:p.requirements,privileges:pluginPrivileges(p),runtime:{...host.runtimeStatus().find(r=>r.id===p.id),...(p.runtime?{updatePolicy:p.runtime.updatePolicy??'maintenance'}:{})},removable:!!(state.dependencies?.[p.id]||state.links?.[p.id]),development:!!state.links?.[p.id],warnings:host.warnings.filter(item=>item.plugin===p.id).map(item=>item.message)})),
+    pluginDefinition:id=>host.definitions.get(id)??pending.get(id)?.entry.plugin,
+    listPlugins:()=>catalogEntries.map(entry=>{const p=entry.plugin??entry,scope=entry.scope??'preset',installed=scope==='global'?state:scope==='workspace'?(shared?localState:state):{};return {id:p.id,version:p.version,title:p.title,description:p.description,scope,source:entry.root,platforms:p.platforms,architectures:p.architectures,environments:p.environments,config:p.config,requirements:p.requirements,privileges:pluginPrivileges(p),runtime:{...(pending.has(p.id)?{status:'unconfigured'}:host.runtimeStatus().find(r=>r.id===p.id)),...(p.runtime?{updatePolicy:p.runtime.updatePolicy??'maintenance'}:{})},...(pending.has(p.id)?{configurationError:pending.get(p.id).message}:{}),removable:!!(installed.dependencies?.[p.id]||installed.links?.[p.id]),development:!!installed.links?.[p.id],warnings:host.warnings.filter(item=>item.plugin===p.id).map(item=>item.message)};}),
     listCommands:()=>host.commands(),
     listShortcuts:()=>describeShortcuts(project.shortcuts??{},{actions:host.catalog(),commands:host.commands()}),
     async configureShortcuts(value){return updateUserCommands({shortcuts:value});},
@@ -71,7 +83,7 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
     listWorkflows:()=>store.list(),
     async saveWorkflow(w){return mutateWorkflow(()=>store.save(w),w);},
     async duplicateWorkflow(definition,options){return mutateWorkflow(()=>store.duplicate(definition,options),definition);},
-    async removeWorkflow(id){return mutateWorkflow(()=>store.remove(id));},
+    async removeWorkflow(id,options){return mutateWorkflow(()=>store.remove(id,options));},
     async checkWorkflow(id){
       host.assertHealthy();
       const closure=await store.resolve([id],host);
@@ -87,22 +99,24 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
       return app.executeTracked(id,(activeHost,context,event)=>{
         if(blocked.length)throw new FlowError(`工作流缺少运行权限：${blocked.map(item=>item.action).join('、')}`,{code:'INSUFFICIENT_PRIVILEGE',details:{actions:blocked}});
         return runWorkflow({store:snapshotStore,host:activeHost,id,input,signal:context.signal,onEvent:event,runId:context.runId,context:{...context,allowUnknownPrivileges:!!options.allowUnknownPrivileges,networkPolicy}});
-      });
+      },{kind:'workflow',title:closure.workflows.find(flow=>flow.id===id)?.title??id,input});
     },
     async startCommand(name,input={},context={}){
       if(busy)throw new FlowError('插件更新中，请稍后调用');
+      for(const [id,{entry}] of pending)if(Object.hasOwn(entry.plugin.commands??{},name))assertConfigured(id);
       const networkPolicy=structuredClone(project.network??{});
       return app.executeTracked(`/${name}`,(activeHost,runContext)=>{
         if(context.expectedPlugin!==undefined&&!activeHost.commands().some(command=>command.name===name&&command.plugin===context.expectedPlugin)){
           throw new FlowError('命令目标插件已变更，请重新选择目标后执行',{code:'COMMAND_TARGET_CHANGED',details:{command:name,plugin:context.expectedPlugin}});
         }
         return activeHost.invokeCommand(name,input,{...context,...runContext,networkPolicy});
-      });
+      },{kind:'command',title:host.commands().find(command=>command.name===name)?.description??`/${name}`,input});
     },
     async startAction(id,input={},context={}){
       if(busy)throw new FlowError('插件更新中，请稍后调用');
+      assertConfigured(id.slice(0,id.lastIndexOf(':')));
       const networkPolicy=structuredClone(project.network??{});
-      return app.executeTracked(id,(activeHost,runContext)=>activeHost.invoke(id,input,{...context,...runContext,networkPolicy}));
+      return app.executeTracked(id,(activeHost,runContext)=>activeHost.invoke(id,input,{...context,...runContext,networkPolicy}),{kind:'action',title:host.catalog().find(action=>action.id===id)?.title??id,input});
     },
     async startShell(script,{shell='auto',timeout=30000}={}){
       if(busy)throw new FlowError('项目更新中，请稍后执行命令');
@@ -111,15 +125,16 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
       const env=buildProcessEnv(policy);
       return app.executeTracked('!命令',async(_host,context)=>{
         const result=await runShell(script,{shell,temporaryDir:context.outputDir,cwd:projectDir,env,extendEnv:false,signal:context.signal,timeout,outputMode:'stream',summaryBytes:65536,
-          onOutput:({stream,message})=>context.log(message,undefined,{stream})});
+          onStart:invocation=>context.log('执行程序',invocation,{kind:'process'}),
+          onOutput:({stream,message})=>context.log(message,undefined,{stream,audience:'user'})});
         if(result.exitCode!==0)throw new FlowError(`命令执行失败，退出码 ${result.exitCode}`,{code:'EXECUTION_FAILED',details:result});
         return result;
-      });
+      },{kind:'shell',title:'系统命令'});
     },
-    async executeTracked(id,execute){
+    async executeTracked(id,execute,{kind='workflow',title=id,input}={}){
       const runId=randomUUID(),controller=new AbortController();
-      const run={id:runId,workflowId:id,logOwner:runLogs.owner,status:'running',startedAt:new Date().toISOString(),controller};
-      const journal=await runLogs.start({id:runId,workflowId:id,status:run.status,startedAt:run.startedAt},{onEvent:event=>emitter.emit('event',event)});
+      const run={id:runId,workflowId:id,kind,title,sessionId,resultDir:path.join(results,runId),logOwner:runLogs.owner,status:'running',startedAt:new Date().toISOString(),controller};
+      const journal=await runLogs.start({id:runId,workflowId:id,kind,title,sessionId,status:run.status,startedAt:run.startedAt},{onEvent:event=>emitter.emit('event',event)});
       journals.set(run,journal);
       // 兼容运行句柄的事件读取；外部修改不影响日志模块的缓存。
       Object.defineProperty(run,'events',{get:()=>journal.snapshot().events});
@@ -128,9 +143,12 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
       const event=e=>journal.append(e);
       const activeHost=host;
       run.done=(async()=>{
+        let createdResults=false;
         try {
+          createdResults=(await mkdir(run.resultDir,{recursive:true}))!==undefined;
           await event({type:'run.started'});
-          run.output=await execute(activeHost,{outputDir:journal.directory,signal:controller.signal,runId,log:(message,data,meta={})=>event({...meta,type:'log',message,data})},event);
+          if(input!==undefined)await event({type:'run.input',input});
+          run.output=await execute(activeHost,{outputDir:run.resultDir,logDir:journal.directory,signal:controller.signal,runId,log:(message,data,meta={})=>event({...meta,type:'log',message,data})},event);
           run.status='succeeded';await event({type:'run.succeeded'});
         } catch(error) {
           if(error?.code==='WORKFLOW_STOPPED'){
@@ -143,9 +161,16 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
           }
         } finally {
           run.finishedAt=new Date().toISOString();
+          if(createdResults){
+            try{await rmdir(run.resultDir);run.resultDir=undefined;}
+            catch(error){
+              if(error.code==='ENOENT')run.resultDir=undefined;
+              else if(!['ENOTEMPTY','EEXIST'].includes(error.code))run.warnings=[{code:'RESULT_CLEANUP_FAILED',message:`空结果目录无法移除：${error.message}`}];
+            }
+          }
           try{await journal.finish(runState(run));}finally{writingRuns.delete(runId);}
           try{await pruneLogs();}catch(error){
-            run.warnings=[{code:'LOG_PRUNE_FAILED',message:`日志自动清理失败：${error.message}`}];
+            run.warnings=[...(run.warnings??[]),{code:'LOG_PRUNE_FAILED',message:`日志自动清理失败：${error.message}`}];
             await journal.save(runState(run));
           }
         }
@@ -225,29 +250,32 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
     async configurePlugin(id,value,options={}){
       if(project.readOnly)throw new FlowError('只读项目不能保存配置');
       if(busy||launching||app.listRuns().some(r=>r.status==='running'))throw new FlowError('请等待运行或安装结束');
-      if(!host.definitions.has(id))throw new FlowError(`插件不存在：${id}`);
-      value=validate(host.definitions.get(id).config,value,`${id} 配置`);
+      if(!app.pluginDefinition(id))throw new FlowError(`插件不存在：${id}`);
+      value=validate(app.pluginDefinition(id).config,value,`${id} 配置`);
       busy=true;let backup;
       try{
-        await withPluginMutation(projectDir,async()=>{
-        await assertPluginState(projectDir,state);
+        await withRegistryMutation(async()=>{
+        await assertStates();
         const file=path.join(projectDir,'flow.project.json'),latest=await readJson(file,project);
         if(latest.readOnly)throw new FlowError('只读项目不能保存配置');
         const nextConfig={...latest.config,[id]:value};
         const oldConfig={...project.config,...config},effectiveNext={...nextConfig,...config};
-        const entries=[...host.definitions.values()].map(p=>({plugin:p,root:p.root}));
-        const plan=planPluginUpdate(host.definitions,host.definitions,oldConfig,effectiveNext,new Set([id]));
+        const prepared=preparePluginCatalog(catalogEntries,effectiveNext);
+        const nextDefinitions=new Map(prepared.active.map(entry=>[(entry.plugin??entry).id,entry.plugin??entry]));
+        const entries=prepared.active,oldEntries=[...host.definitions.values()].map(p=>({plugin:p,root:p.root}));
+        const plan=planPluginUpdate(host.definitions,nextDefinitions,oldConfig,effectiveNext,new Set([id]));
         assertMaintenance(plan,options);
         backup=await backupProjectFile(file,latest,'config');
         if(plan.affected.length)await host.replace({plugins:entries,config:effectiveNext,affected:plan.affected});
         const nextProject={...latest,config:nextConfig},temp=`${file}.${randomUUID()}.tmp`;
         try{await writeFile(temp,JSON.stringify(nextProject,null,2));await rename(temp,file);}
         catch(error){
-          if(plan.affected.length)try{await host.replace({plugins:entries,config:oldConfig,affected:plan.affected});}
+          if(plan.affected.length)try{await host.replace({plugins:oldEntries,config:oldConfig,affected:plan.affected});}
           catch(recovery){host.invalidate();throw new AggregateError([error,recovery],`配置保存失败且插件恢复失败：${error.message}；${recovery.message}`);}
           throw error;
         }
         for(const key of Object.keys(project))delete project[key];Object.assign(project,nextProject);
+        pending=prepared.pending;
         });
       }finally{busy=false;}
       return {backup};
@@ -285,21 +313,29 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
       });return closing;
     },
   };
-  let initial;
+  let initial,globalEntries=[];
   const services={application:app,runProcess,fs:fileProbe};
   const hostProject=()=>({directory:projectDir,readOnly:!!project.readOnly});
   const build=extra=>{
-    const entries=entriesWithPresets([...initial,...extra],project.commandPresets??{});
+    catalogEntries=entriesWithPresets(mergePluginEntries(initial,shared?localEntries:extra,shared?extra:[],state.disabledLegacy,{shared}),project.commandPresets??{});
+    const entries=catalogEntries;
     validateShortcuts(project.shortcuts??{},{reservedNames:declaredCommands(entries).map(command=>command.name)});
-    return createHost({plugins:entries,config:{...project.config,...config},services,project:hostProject(),network:()=>project.network,environmentOverrides:project.environments,runtimeEnabled:!maintenance,allowUnknownPrivileges});
+    const prepared=preparePluginCatalog(entries,{...project.config,...config});pending=prepared.pending;
+    return createHost({plugins:prepared.active,config:{...project.config,...config},services,project:hostProject(),network:()=>project.network,environmentOverrides:project.environments,runtimeEnabled:!maintenance,allowUnknownPrivileges});
   };
   try{
     initial=plugins??await Promise.all((project.plugins??[]).map(spec=>loadPlugin(spec,project.baseBundle?.root??projectDir)));
-    const external=[];
-    for(const name of Object.keys(state.dependencies??{}))if(!maintenance||name!==omitInstalledPlugin)external.push(await loadPlugin(name,state.root));
-    for(const [name,source] of Object.entries(state.links??{}))if(!maintenance||name!==omitInstalledPlugin)external.push(await loadPlugin(source,projectDir));
-    host=await build(external);
-  }catch(error){await fileProbe.close();await opened.release();throw error;}
+    globalEntries=await loadInstalled(state,registryDir);
+    if(shared)localEntries=await loadInstalled(localState,projectDir,new Set([...Object.keys(state.dependencies??{}),...Object.keys(state.links??{}),...(state.disabledLegacy??[])]));
+    host=await build(globalEntries);
+  }catch(error){await fileProbe.close();await opened.release();await localOpened?.release();throw error;}
+  async function loadInstalled(current,base,excluded=new Set()){
+    const loaded=[];
+    for(const name of Object.keys(current.dependencies??{}))if(!excluded.has(name)&&(!maintenance||name!==omitInstalledPlugin))loaded.push(await loadPlugin(name,current.root));
+    for(const [name,source] of Object.entries(current.links??{}))if(!excluded.has(name)&&(!maintenance||name!==omitInstalledPlugin))loaded.push(await loadPlugin(source,base));
+    return loaded;
+  }
+  function assertConfigured(id){if(pending.has(id))throw new FlowError(`插件 ${id} 尚未配置：${pending.get(id).message}`,{code:'PLUGIN_NOT_CONFIGURED',details:{plugin:id}});}
   for(const name of ['startRun','startCommand','startAction','startShell','startWeb','saveWorkflow','duplicateWorkflow','removeWorkflow','installPlugin','linkPlugin','removePlugin','configurePlugin','configureNetworkPolicy','configureLogs','configureCommandPresets','configureShortcuts','setMaintenance','pack']){
     const original=app[name],isRun=['startRun','startCommand','startAction','startShell'].includes(name);
     app[name]=async(...args)=>{
@@ -312,8 +348,8 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
   async function mutateWorkflow(operation,definition){
     if(project.readOnly)throw new FlowError('只读运行包不能修改工作流');
     if(busy)throw new FlowError('插件变更期间暂不能修改工作流',{code:'PLUGIN_BUSY'});
-    return withPluginMutation(projectDir,async()=>{
-      await assertPluginState(projectDir,state);
+    return withRegistryMutation(async()=>{
+      await assertStates();
       if(definition){
         const workflow=store.validateShape(definition),latest=await readJson(path.join(projectDir,'flow.project.json'),project);
         const missing=[...workflowActions(workflow.steps)].filter(id=>id.startsWith(`${COMMANDS_PLUGIN_ID}:`)&&!Object.hasOwn(latest.commandPresets??{},id.slice(COMMANDS_PLUGIN_ID.length+1)));
@@ -344,8 +380,8 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
     const requested=structuredClone(changes);
     if(Object.hasOwn(requested,'commandPresets'))requested.commandPresets=validateCommandPresets(requested.commandPresets);
     busy=true;
-    try{return await withPluginMutation(projectDir,async()=>{
-      await assertPluginState(projectDir,state);
+    try{return await withRegistryMutation(async()=>{
+      await assertStates();
       const file=path.join(projectDir,'flow.project.json'),latest=await readJson(file,project);
       if(latest.readOnly)throw new FlowError('只读运行包不能修改注册命令或快捷名称');
       for(const field of Object.keys(requested))if(!isDeepStrictEqual(latest[field]??{},project[field]??{})){
@@ -354,7 +390,8 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
       const nextProject={...latest,...requested};
       const presets=validateCommandPresets(nextProject.commandPresets??{});
       const oldEntries=[...host.definitions.values()].map(plugin=>({plugin,root:plugin.root}));
-      const entries=entriesWithPresets(oldEntries,presets);
+      const nextCatalog=entriesWithPresets(catalogEntries,presets),prepared=preparePluginCatalog(nextCatalog,{...latest.config,...config});
+      const entries=prepared.active;
       const reservedNames=declaredCommands(entries).map(command=>command.name);
       const shortcuts=Object.hasOwn(requested,'shortcuts')?bindShortcutCommands(nextProject.shortcuts??{},{commands:declaredCommands(entries),previous:latest.shortcuts??{}}):nextProject.shortcuts??{};
       nextProject.shortcuts=validateShortcuts(shortcuts,{reservedNames});
@@ -378,6 +415,7 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
         throw error;
       }finally{await rm(temp,{force:true});}
       for(const key of Object.keys(project))delete project[key];Object.assign(project,nextProject);
+      catalogEntries=nextCatalog;pending=prepared.pending;
       return {backup,commandPresets:structuredClone(presets),shortcuts:structuredClone(nextProject.shortcuts)};
     });}finally{busy=false;}
   }
@@ -453,40 +491,51 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
     if(busy || launching || [...runs.values()].some(r=>r.status==='running'))throw new FlowError('请等待当前运行或安装结束');
     busy=true;let candidate,nextRelease;
     try {
-      return await withPluginMutation(projectDir,async()=>{
-      await assertPluginState(projectDir,state);
+      return await withRegistryMutation(async()=>{
+      await assertStates();
+      const targetDir=shared&&operation.remove&&!state.dependencies?.[operation.remove]&&!state.links?.[operation.remove]?projectDir:registryDir;
+      const targetState=targetDir===registryDir?state:localState;
       const latest=await readJson(path.join(projectDir,'flow.project.json'),project);
       if(latest.readOnly)throw new FlowError('运行包不支持安装或移除插件');
       if(operation.remove){
         const name=operation.remove;
         if(resources.active(name))throw new FlowError('请先停止此插件提供的 Web');
-        if(!state.dependencies?.[name]&&!state.links?.[name])throw new FlowError('此插件来自发行配置，不能在此移除');
-        const dependents=[...host.definitions.values()].filter(p=>p.id!==name&&Object.hasOwn(p.dependencies??{},name)).map(p=>p.id);
+        if(!targetState.dependencies?.[name]&&!targetState.links?.[name])throw new FlowError('此插件来自发行配置，不能在此移除');
+        const dependents=catalogEntries.map(entry=>entry.plugin??entry).filter(p=>p.id!==name&&Object.hasOwn(p.dependencies??{},name)).map(p=>p.id);
         if(dependents.length)throw new FlowError(`插件仍被其他插件依赖：${dependents.join('、')}`,{code:'PLUGIN_IN_USE',details:{dependencies:dependents}});
-        const workflows=await findPluginWorkflowReferences(name);
+        if(shared&&targetDir===registryDir){
+          const references=await registryPluginReferences(registryDir,name,{globalPlugins:catalogEntries.filter(entry=>entry.scope==='global').map(entry=>entry.plugin)});
+          if(references.length){const dependencies=references.map(item=>`${item.plugin}（${item.projectDir}）`);throw new FlowError(`插件仍被其他工作区插件依赖：${dependencies.join('、')}`,{code:'PLUGIN_IN_USE',details:{dependencies}});}
+        }
+        const workflows=shared&&targetDir===registryDir?await registryWorkflowReferences(registryDir,name):await findPluginWorkflowReferences(name);
         if(workflows.length&&!options.force)throw new FlowError(`插件 ${name} 仍被工作流引用：${workflows.map(w=>w.id).join('、')}`,{code:'PLUGIN_IN_USE',details:{workflows}});
       }
-      const next=await installGeneration(projectDir,{...operation,state});
-      const nextEntries=entriesWithPresets([...initial,...next.loaded],latest.commandPresets??{}),activeConfig={...project.config,...config},effectiveConfig={...latest.config,...config};
+      const next=await installGeneration(targetDir,{...operation,sourceDir:projectDir,state:shared&&targetDir===registryDir?{...targetState,global:true}:targetState});
+      const nextLocal=shared?(targetDir===projectDir?next.loaded:localEntries):next.loaded,nextGlobal=shared?(targetDir===registryDir?next.loaded:globalEntries):[];
+      const nextState=targetDir===registryDir?next.state:state;
+      const nextCatalog=entriesWithPresets(mergePluginEntries(initial,nextLocal,nextGlobal,nextState.disabledLegacy,{shared}),latest.commandPresets??{}),activeConfig={...project.config,...config},effectiveConfig={...latest.config,...config};
+      const prepared=preparePluginCatalog(nextCatalog,effectiveConfig),nextEntries=prepared.active;
       candidate=await createHost({plugins:nextEntries,config:effectiveConfig,services,project:hostProject(),network:()=>project.network,environmentOverrides:project.environments,runtimeEnabled:false,allowUnknownPrivileges});
       validateShortcuts(latest.shortcuts??{},{reservedNames:declaredCommands(nextEntries).map(command=>command.name)});
-      const sourceChanges=await changedPluginSources(host.definitions,candidate.definitions,{oldInstallationRoot:state.root,newInstallationRoot:next.state.root});
+      const sourceChanges=await changedPluginSources(host.definitions,candidate.definitions,{oldInstallationRoot:targetState.root,newInstallationRoot:next.state.root});
       const plan=planPluginUpdate(host.definitions,candidate.definitions,activeConfig,effectiveConfig,sourceChanges);
       assertMaintenance(plan,options);
       await candidate.close();candidate=null;
-      nextRelease=await leaseInstallation(projectDir,next.state.root);
+      nextRelease=await leaseInstallation(targetDir,next.state.root);
       const oldEntries=[...host.definitions.values()].map(p=>({plugin:p,root:p.root}));
       if(plan.affected.length)await host.replace({plugins:nextEntries,config:effectiveConfig,affected:plan.affected});
-      try{await savePluginState(projectDir,next.state,state);}
+      try{await savePluginState(targetDir,next.state,targetState);}
       catch(error){
         if(plan.affected.length)try{await host.replace({plugins:oldEntries,config:activeConfig,affected:plan.affected});}
         catch(recovery){host.invalidate();throw new AggregateError([error,recovery],`插件状态保存失败且恢复失败：${error.message}；${recovery.message}`);}
         throw error;
       }
-      state=next.state;
+      if(targetDir===registryDir){state=next.state;globalEntries=next.loaded;}else{localState=next.state;localEntries=next.loaded;}
+      catalogEntries=nextCatalog;pending=prepared.pending;
       for(const key of Object.keys(project))delete project[key];Object.assign(project,latest);
-      installationLeases.set(path.resolve(state.root),nextRelease);nextRelease=null;
-      for(const [root,release] of installationLeases)if(root!==path.resolve(state.root)&&![...host.definitions.values()].some(p=>p.root&&path.resolve(p.root).startsWith(root+path.sep))){
+      installationLeases.set(path.resolve(next.state.root),nextRelease);nextRelease=null;
+      const usedRoots=[...host.definitions.values(),...catalogEntries];
+      for(const [root,release] of installationLeases)if(root!==path.resolve(next.state.root)&&!usedRoots.some(entry=>entry.root&&path.resolve(entry.root).startsWith(root+path.sep))){
         try{await release();installationLeases.delete(root);}
         catch(error){emitter.emit('event',{type:'plugin.cleanup.warning',message:`旧安装批次租约暂未清理：${error.message}`,root});}
       }

package/manual/packages/core/src/development-watch-worker.js

@@ -34,7 +34,16 @@ async function scan(){
     try{
       project=await json(path.join(options.projectDir,'flow.project.json'),{});
       const state=await json(path.join(stateDirectory,'plugins.json'),{});
-      links=Object.values(state.links??{}).filter(value=>typeof value==='string').map(value=>path.resolve(options.projectDir,value));
+      let sources={...state.links};
+      if(options.pluginRegistryDir&&!project.baseBundle&&!project.readOnly&&options.pluginRegistryDir!==options.projectDir){
+        const globalDirectory=path.join(options.pluginRegistryDir,'.flow');
+        addWatch('global-state',globalDirectory,(_event,name)=>{if(name===null||String(name)==='plugins.json'){change(path.join(globalDirectory,'plugins.json'));void scan();}},wanted);
+        const global=await json(path.join(globalDirectory,'plugins.json'),{});
+        for(const id of global.disabledLegacy??[])delete sources[id];
+        sources={...sources,...global.links};
+        for(const id of Object.keys(global.dependencies??{}))delete sources[id];
+      }
+      links=Object.values(sources).filter(value=>typeof value==='string').map(value=>path.resolve(options.projectDir,value));
     }catch(error){send({type:'warning',message:`开发配置暂不可读，保留已有源码监听：${error.message}`});}
     incomplete=links.length>options.maxDirectories;
     const queue=links.slice(0,options.maxDirectories).map(directory=>({directory,depth:0})),seen=new Set();

package/manual/packages/core/src/development.js

@@ -91,7 +91,7 @@ export async function createDevelopmentSupervisor(options={}){
       })();return closing;
     },
   };
-  const watchOptions={projectDir,configFile:options.configFile?path.resolve(options.configFile):undefined,
+  const watchOptions={projectDir,pluginRegistryDir:options.pluginRegistryDir?path.resolve(options.pluginRegistryDir):undefined,configFile:options.configFile?path.resolve(options.configFile):undefined,
     maxDirectories:positive(options.maxDirectories,512,'maxDirectories'),maxEntries:positive(options.maxEntries,20000,'maxEntries'),maxDepth:positive(options.maxDepth,24,'maxDepth')};
   try{
     await new Promise((resolve,reject)=>{

package/manual/packages/core/src/plugin-catalog.js

@@ -0,0 +1,42 @@
+import {validate,assertSchema} from '@mytools/sdk/schema';
+import {FlowError} from '@mytools/sdk';
+import {validatePluginDefinitions} from '@mytools/fst-plugin';
+
+export function mergePluginEntries(initial,local,global,disabledLegacy=[],{shared=true}={}){
+  const result=new Map();
+  for(const entry of initial){
+    const plugin=entry.plugin??entry;
+    if(result.has(plugin.id))throw new FlowError(`插件标识重复：${plugin.id}`,{code:'VALIDATION'});
+    result.set(plugin.id,{...('plugin' in entry?entry:{plugin:entry}),scope:'preset'});
+  }
+  for(const entry of local)if(!disabledLegacy.includes(entry.plugin.id)){
+    if(!shared&&result.has(entry.plugin.id))throw new FlowError(`插件标识重复：${entry.plugin.id}`,{code:'VALIDATION'});
+    result.set(entry.plugin.id,{...entry,scope:'workspace'});
+  }
+  for(const entry of global)result.set(entry.plugin.id,{...entry,scope:'global'});
+  return [...result.values()];
+}
+
+export function preparePluginCatalog(entries,config){
+  const pending=new Map();validatePluginDefinitions(entries);
+  for(const entry of entries){
+    const plugin=entry.plugin??entry;
+    if(plugin.config!==undefined)assertSchema(plugin.config,`${plugin.id} 配置`);
+    try{validate(plugin.config,config[plugin.id]??{},`${plugin.id} 配置`);}
+    catch(error){
+      if(entry.scope!=='global'||error.code!=='VALIDATION')throw error;
+      pending.set(plugin.id,{entry,message:error.message});
+    }
+  }
+  // 缺配置的服务提供者暂不启用，相关消费者也等待；无关插件正常装配。
+  let changed;
+  do{
+    changed=false;
+    for(const entry of entries){
+      const plugin=entry.plugin??entry;
+      const missing=Object.keys(plugin.dependencies??{}).filter(id=>pending.has(id));
+      if(!pending.has(plugin.id)&&missing.length){pending.set(plugin.id,{entry,message:`依赖插件尚未配置：${missing.join('、')}`});changed=true;}
+    }
+  }while(changed);
+  return {active:entries.filter(entry=>!pending.has((entry.plugin??entry).id)),pending};
+}

package/manual/packages/core/src/version.js

@@ -1,2 +1,2 @@
 // 由 npm version 的生命周期脚本同步，内部插件 API 版本独立维护。
-export const VERSION="0.5.2";
+export const VERSION="0.5.3";

package/manual/packages/fst-cli/README.md

@@ -35,6 +35,10 @@ fst 命令入口、交互终端、输入呈现和运行观察。通过公开应
 
 TUI 支持 `!` 系统命令、`/commands` 常用命令注册和 `/shortcuts` 任意插件能力快捷名。主输入框与命令编辑框使用 Shift+Enter / Alt+Enter 换行、Enter 提交；真实多行粘贴保持换行及缩进。使用说明可通过 `fst docs commands` 离线阅读。
 
+运行和步骤附近提示 Ctrl+O，展开后按 schema 字段标题阅读结果；受管进程显示实际程序、参数、目录和原始命令。`/logs` 中按 m 单独格式化阅读输出，j 仍保留原始 JSON。总耗时在执行期间每秒更新，结束或关闭界面后回收刷新计时器。平台声明提示直接显示在 TUI。
+
+`/history` 或 `/tools` → 历史会话恢复输入、反馈与结果，不重跑指令；与已有插件或快捷名 `history` 冲突时保留原入口。通过 `fst-logs/sessions` 在所属工作区保存有界快照与完整追加交互记录，只读包改用可写输出目录。较早的内容分页读取，运行日志仍独立保存并遵循其保留策略。恢复创建当前会话的继续记录，不覆盖来源会话；未提交草稿和配置表单不保存。
+
 本模块负责上述职责的实现、文档与回归；跨模块接口调整需要同时检查生产者与消费者。具体维护人员尚未指定。
 
 在仓库根目录执行：