@yanglaofish/fishtools 0.5.0 → 0.5.2

package/manual/docs/verification.md

@@ -1,12 +1,50 @@
 # 验收记录
 
+## 0.5.2 命令注册与快捷名称（2026-10-13）
+
+- 分支 `codex/0.5.2-command-shortcuts`，固定基线 `68a84cd`；按用户指定目标集中实现 `!` 系统命令、`/commands` 注册动作、`/shortcuts` 任意动作或命令的中文快捷名称与默认参数。
+  主输入框和命令编辑框均为 **Shift+Enter 换行、Enter 提交**，Alt+Enter 兼容备用，粘贴保留多行、缩进和引号。
+- 独立 Standards / Spec 审查分别确认 3 项（最高 P1）与 3 项（最高 P2），均已修正。
+  最终生产代码 `30d7472`、探针与记录补充 `7fa6178` 两次独立复审均通过；详见[审查记录](superpowers/reviews/2026-10-13-command-shortcuts-review.md)。
+- 修正真实 Windows 长脚本参数限制、命令名称冲突漏查、快捷目标身份变化、跨实例过期工作流草稿，以及整组保存自动启用旧别名的问题。
+  全量测试还复现并修正输出超限时管道提前关闭留下后代进程的问题；原心跳断言与新增七种进程树停止探针均通过。
+  后续一次单字节文件大小变化未在 164 次诊断中复现，保留事实，不认定原因；最终同时检查进程状态和实际内容。
+- `npm run dist:npm` 成功，本地归档 9,804,373 字节、285 个生产包。
+  指定该归档后完整 `npm test` **489 项：487 通过、0 失败、2 跳过**，175.1 秒；包含离线全局安装、脱离源码运行和再次导出。
+  本机 Windows/Node 24.15.0；POSIX 保存失败注入与未开放权限的文件 symlink 跳过，目录 junction 回归执行。
+- [首次正式验收](https://github.com/yanglaofish/Fishtools/actions/runs/38358232278)：Ubuntu **488 通过、0 失败、1 跳过**，便携包及断网只读容器通过；Windows **486 通过、2 失败、1 跳过**。
+  两项失败均为 Shell 展开 `RUNNER~1` 短路径后与测试字面路径不等，真实 `C:\PROGRA~1` 诊断复现并核对为同一目录。修正测试为 `realpath` 的目录身份比较，生产执行目录行为未变。
+  发布任务被跳过，npm 0.5.2 与 GitHub Release 尚不存在。用户明确要求同时合入 [issue #4](superpowers/specs/2026-10-13-issue-4-workflow-menu.md) 的复制入口修正：列表每个工作流只出现一次，进入管理页后复制；相关专项 **26/26** 通过。
+  合入后本地重建归档 **9,806,640 字节、285 个生产包**，指定该归档完整 `npm test` **489 项：487 通过、0 失败、2 跳过**，186.3 秒。
+  补充范围 `8223bad...c567534` 的独立 Standards / Spec 复审均通过，新增确认问题均为 0。
+  最终双平台验收重新执行，完成后核对正式发布产物；待发布 tag 更新前检查旧对象和未发布状态，不覆盖已发布版本。
+
+## 0.5.1 全代际复核修正（2026-10-13）
+
+- 分支 `codex/review-0.5.0-followup`，以 0.4.0 `f529244` 至 0.5.0 后验收提交 `d26a0ee` 为固定范围执行独立 Standards / Spec 审查。
+  共确认 6 项问题：直连子进程重新继承代理、清理失败后重复启动资源、嵌套 stop 的权限误拦、TUI 摘要淘汰崩溃、步骤缓存超预算、最终结果缓存超预算。
+  均先失败复现再修正；修补后的两个独立复审无剩余阻断问题，详见[审查记录](superpowers/reviews/2026-10-13-0.5.0-followup-review.md)。
+- logs 提供统一步骤缓存与结果投影，TUI 不重新持有完整大正文；真实 2 MiB 输入/输出验证业务 done 与完整 JSONL 不受影响。
+  实际子进程验证三种代理模式、正常/失败清理恢复与 Linux 普通用户嵌套 stop 的执行边界。
+- `npm run dist:npm` 成功，0.5.1 本地归档 9,757,761 字节、284 个生产包；用该归档执行完整 `npm test` **382 项：381 通过、0 失败、1 跳过**，166.0 秒。
+  包括离线全局安装、脱离源码运行与再次导出。Windows 文件 symlink 权限导致一项跳过，目录 junction 回归执行。
+- 产品和 CLI 同步为 0.5.1，保持工作流与内部插件 API 格式兼容。发布 tag 固定于 `1fff499`，后续验收记录不改变发行产物。
+- [正式发布流程](https://github.com/yanglaofish/Fishtools/actions/runs/38329427621)全部成功：同一 npm 归档在 Windows **382/382**、Ubuntu **381/382（1 项 Windows 专用跳过）**通过，零失败。
+  两平台自包含包、无 Node 的断网只读 Debian 容器检查通过；[普通主分支 CI](https://github.com/yanglaofish/Fishtools/actions/runs/38329413252)也成功。
+- npm 官方注册表 `latest` 已为 **0.5.1**，独立下载公开 tarball 验证：9,757,768 字节，SHA-512 与注册表 integrity 一致，
+  SHA-256 `ca1463a00a8227abe6a71c0f0627f2e881902703f8a3c9bc7267ce49ea6691a9` 与 Release 的 `SHA256SUMS` 一致。
+- [GitHub Release](https://github.com/yanglaofish/Fishtools/releases/tag/v0.5.1)已公开于仓库访问范围，包含 npm、Windows（52,457,324 字节）、Linux（58,024,913 字节）归档及校验文件。
+  发布说明补齐本轮修正及审查记录链接；发布任务首次运行即成功，没有重复上传或改动已发布版本。
+
 ## 0.5.0 发布前验证（2026-10-13）
 
 - 分支 `codex/kernel-runtime-readiness`，固定基线 `002260b`。完成动作级代理、权限预检、工作流复制与删除、引用保护、定向插件更新及恢复；双轴审查与修复见[审查记录](superpowers/reviews/2026-10-13-kernel-runtime-release-review.md)。
 - 审查补齐项目配置及工作流覆盖保存的备份、卸载期间的并发保护、恢复失败后的停止运行、代理实际生效模式和失效引用提示，以及权限不足时的失败日志。原有宿主关闭后能力列表行为已恢复。
 - Windows Node 24.15.0 上 `npm run dist:npm` 成功；最终 npm 归档 `dist/yanglaofish-fishtools-0.5.0.tgz` 为 9,750,617 字节，收集 284 个生产包。Web 构建成功；仅有第三方 `use client` 指令提示。
 - 设置 `FISHTOOLS_TEST_NPM_ARCHIVE` 指向最终归档后运行完整 `npm test`，**374 项：373 通过、0 失败、1 跳过**，164.2 秒。覆盖 npm 离线全局安装、脱离源码运行、再次导出、代理规则、权限、备份与并发卸载。跳过的是本机未开放文件符号链接权限的 Windows 用例；目录 junction 仍执行。
-- 本节仅记录本地 Windows 验证。Linux 与 Windows 的远端发布门禁、npm 实际发布和 GitHub Release 以 `v0.5.0` 工作流结果为准。
+- [v0.5.0 发布工作流](https://github.com/yanglaofish/Fishtools/actions/runs/38282818908)最终全部成功：Windows **374/374**，Ubuntu **373/374**、1 项跳过；两平台便携包与无 Node 的断网只读 Linux 容器验收通过。
+- npm 官方源已公开 `@yanglaofish/fishtools@0.5.0`，`latest` 指向 0.5.0；[GitHub Release](https://github.com/yanglaofish/Fishtools/releases/tag/v0.5.0)已公开，包含 npm、Windows、Linux 归档及 `SHA256SUMS`。
+- npm 首次接受上传后处理超过发布脚本的 5 分钟等待上限；注册表可见后仅重试失败的发布任务，归档完整性匹配，随后完成 Release，未重复创建版本。
 
 ## 完整内核能力演进（2026-10-12，本地未发布）
 

package/manual/packages/core/README.md

@@ -6,7 +6,7 @@
 
 组合各能力模块、协调运行与关闭、提供 CLI/Web 共用应用接口及导出声明快照。日志写入和缓存由 logs 负责；导出实现通过可选 pack 依赖加载。
 
-内部依赖：`@mytools/sdk`、`@mytools/fst-platform`、`@mytools/fst-logs`、`@mytools/fst-workflow`、`@mytools/fst-plugin`、`@mytools/fst-workspace`、`@mytools/pack`。
+内部依赖：`@mytools/sdk`、`@mytools/fst-platform`、`@mytools/fst-logs`、`@mytools/fst-workflow`、`@mytools/fst-plugin`、`@mytools/fst-workspace`、官方 `@mytools/commands`、`@mytools/pack`。
 `@mytools/pack` 是可选 peer 依赖；普通发行包含它，只读发行省略它。既有 `/process`、`/bundle`、`/environments` 子入口保留兼容转发。
 
 ## 公开入口
@@ -25,6 +25,8 @@
 
 ## 维护与验证
 
+`app.startShell(script,options)` 执行临时命令，`app.startAction(id,input,context)` 调用任意动作，两者均纳入运行记录与关闭等待。`startCommand(name,input,{expectedPlugin,...context})` 可固定命令提供者，启动时再次检查，防止参数填写期间被其他同名能力替换。`configureCommandPresets` 和 `configureShortcuts` 在备份、冲突检查与变更锁内保存项目设置；命令快捷项在用户明确设置时绑定提供者 ID，普通安装/卸载和未改变目标的整组保存不会重新绑定；已有未绑定项必须明确提供 plugin 或在界面重新选择目标。注册项变化通过定向宿主更新生效，导出快照保留所需定义与有效快捷项。
+
 本模块负责上述职责的实现、文档与回归；跨模块接口调整需要同时检查生产者与消费者。具体维护人员尚未指定。
 
 在仓库根目录执行：

package/manual/packages/core/package.json

@@ -22,6 +22,7 @@
     "node": ">=24.15.0"
   },
   "dependencies": {
+    "@mytools/commands": "0.1.0",
     "@mytools/sdk": "0.1.0",
     "@mytools/fst-platform": "0.1.0",
     "@mytools/fst-logs": "0.1.0",

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

@@ -1,4 +1,4 @@
-import { mkdir, readFile, writeFile, rename } from 'node:fs/promises';
+import { mkdir, readFile, writeFile, rename, rm } from 'node:fs/promises';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { EventEmitter } from 'node:events';
@@ -7,6 +7,9 @@ import { createHost } from '@mytools/fst-plugin';
 import { WorkflowStore } from '@mytools/fst-workspace/workflows';
 import { runWorkflow } from '@mytools/fst-workflow';
 import { runProcess } from '@mytools/fst-platform';
+import {runShell} from '@mytools/fst-platform/shell';
+import {COMMANDS_PLUGIN_ID,commandsPluginRoot,createCommandsPlugin,validateCommandPresets} from '@mytools/commands';
+import {validateShortcuts,describeShortcuts,bindShortcutCommands} from '@mytools/fst-workspace/shortcuts';
 import {createFileProbe} from '@mytools/fst-platform/fs';
 import {readJson} from '@mytools/fst-platform/json';
 import {loadPlugin} from '@mytools/fst-plugin/loader';
@@ -20,9 +23,22 @@ import {createExportSnapshot} from './export-snapshot.js';
 import {createRunLogs,validateKeepRuns} from '@mytools/fst-logs';
 import {openPluginState,withPluginMutation,assertPluginState,savePluginState,leaseInstallation} from '@mytools/fst-workspace/installations';
 import {planPluginUpdate,changedPluginSources} from './plugin-update.js';
-import {validateNetworkPolicy,inspectNetworkPolicy} from '@mytools/fst-platform/network';
+import {validateNetworkPolicy,inspectNetworkPolicy,resolveNetworkPolicy,buildProcessEnv} from '@mytools/fst-platform/network';
 import {resolvePrivilegeRequirement,checkStaticPrivilege} from '@mytools/fst-plugin/privileges';
 
+function declaredCommands(entries){
+  return entries.flatMap(entry=>{const plugin=entry.plugin??entry;return Object.keys(plugin.commands??{}).map(name=>({name,plugin:plugin.id}));});
+}
+
+function workflowActions(steps,found=new Set()){
+  for(const step of steps??[]){
+    if(step.action)found.add(step.action);
+    if(step.branch){workflowActions(step.branch.then,found);workflowActions(step.branch.else,found);}
+    if(step.parallel)workflowActions(step.parallel.steps,found);
+  }
+  return found;
+}
+
 export async function createApplication({projectDir=process.cwd(),workspace,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:[]});
@@ -47,9 +63,14 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
     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)})),
     listCommands:()=>host.commands(),
+    listShortcuts:()=>describeShortcuts(project.shortcuts??{},{actions:host.catalog(),commands:host.commands()}),
+    async configureShortcuts(value){return updateUserCommands({shortcuts:value});},
+    async configureCommandPresets(value,options={}){
+      return updateUserCommands({commandPresets:value,...(options.shortcuts!==undefined?{shortcuts:options.shortcuts}:{})},options);
+    },
     listWorkflows:()=>store.list(),
-    async saveWorkflow(w){return mutateWorkflow(()=>store.save(w));},
-    async duplicateWorkflow(definition,options){return mutateWorkflow(()=>store.duplicate(definition,options));},
+    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 checkWorkflow(id){
       host.assertHealthy();
@@ -71,7 +92,29 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
     async startCommand(name,input={},context={}){
       if(busy)throw new FlowError('插件更新中，请稍后调用');
       const networkPolicy=structuredClone(project.network??{});
-      return app.executeTracked(`/${name}`,(activeHost,runContext)=>activeHost.invokeCommand(name,input,{...context,...runContext,networkPolicy}));
+      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});
+      });
+    },
+    async startAction(id,input={},context={}){
+      if(busy)throw new FlowError('插件更新中，请稍后调用');
+      const networkPolicy=structuredClone(project.network??{});
+      return app.executeTracked(id,(activeHost,runContext)=>activeHost.invoke(id,input,{...context,...runContext,networkPolicy}));
+    },
+    async startShell(script,{shell='auto',timeout=30000}={}){
+      if(busy)throw new FlowError('项目更新中，请稍后执行命令');
+      if(!Number.isSafeInteger(timeout)||timeout<0||timeout>2147483647)throw new FlowError('命令超时必须为 0 到 2147483647 毫秒，0 表示不限时',{code:'VALIDATION'});
+      const policy=resolveNetworkPolicy(structuredClone(project.network??{}));
+      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})});
+        if(result.exitCode!==0)throw new FlowError(`命令执行失败，退出码 ${result.exitCode}`,{code:'EXECUTION_FAILED',details:result});
+        return result;
+      });
     },
     async executeTracked(id,execute){
       const runId=randomUUID(),controller=new AbortController();
@@ -245,7 +288,11 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
   let initial;
   const services={application:app,runProcess,fs:fileProbe};
   const hostProject=()=>({directory:projectDir,readOnly:!!project.readOnly});
-  const build=extra=>createHost({plugins:[...initial,...extra],config:{...project.config,...config},services,project:hostProject(),network:()=>project.network,environmentOverrides:project.environments,runtimeEnabled:!maintenance,allowUnknownPrivileges});
+  const build=extra=>{
+    const entries=entriesWithPresets([...initial,...extra],project.commandPresets??{});
+    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});
+  };
   try{
     initial=plugins??await Promise.all((project.plugins??[]).map(spec=>loadPlugin(spec,project.baseBundle?.root??projectDir)));
     const external=[];
@@ -253,8 +300,8 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
     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;}
-  for(const name of ['startRun','startCommand','startWeb','saveWorkflow','duplicateWorkflow','removeWorkflow','installPlugin','linkPlugin','removePlugin','configurePlugin','configureNetworkPolicy','configureLogs','setMaintenance','pack']){
-    const original=app[name],isRun=['startRun','startCommand'].includes(name);
+  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)=>{
       if(closing)throw new FlowError('应用已关闭');
       if(isRun)launching++;
@@ -262,11 +309,16 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
       try{return await task;}finally{operations.delete(task);if(isRun)launching--;}
     };
   }
-  async function mutateWorkflow(operation){
+  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);
+      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)));
+        if(missing.length)throw new FlowError('引用的注册命令已删除，请重新选择动作后保存',{code:'COMMAND_NOT_FOUND',details:{actions:missing}});
+      }
       return operation();
     });
   }
@@ -280,6 +332,55 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
     await writeFile(backup,original,{flag:'wx',mode:0o600});
     return backup;
   }
+  function entriesWithPresets(entries,presets){
+    const definition=createCommandsPlugin(presets);
+    const result=entries.filter(entry=>(entry.plugin??entry).id!==COMMANDS_PLUGIN_ID);
+    if(Object.keys(definition.actions).length)result.push({plugin:definition,root:commandsPluginRoot});
+    return result;
+  }
+  async function updateUserCommands(changes,options={}){
+    if(project.readOnly)throw new FlowError('只读运行包不能修改注册命令或快捷名称');
+    if(busy||launching||app.listRuns().some(run=>run.status==='running'))throw new FlowError('请等待运行或安装结束');
+    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);
+      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]??{})){
+        throw new FlowError('注册命令或快捷名称已被另一实例修改，请重新打开工作区再保存',{code:'USER_COMMANDS_CONFLICT',details:{field}});
+      }
+      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 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});
+      const removed=new Set(Object.keys(project.commandPresets??{}).filter(id=>!Object.hasOwn(presets,id)).map(id=>`${COMMANDS_PLUGIN_ID}:${id}`));
+      if(removed.size){
+        const workflows=(await findPluginWorkflowReferences(COMMANDS_PLUGIN_ID)).filter(workflow=>workflow.actions.some(action=>removed.has(action)));
+        if(workflows.length)throw new FlowError(`命令仍被工作流使用：${workflows.map(workflow=>workflow.title).join('、')}`,{code:'COMMAND_IN_USE',details:{workflows}});
+      }
+      const effectiveConfig={...latest.config,...config},oldConfig={...project.config,...config};
+      const nextDefinitions=new Map(entries.map(entry=>{const plugin=entry.plugin??entry;return [plugin.id,plugin];}));
+      const changed=new Set(isDeepStrictEqual(presets,project.commandPresets??{})?[]:[COMMANDS_PLUGIN_ID]);
+      const plan=planPluginUpdate(host.definitions,nextDefinitions,oldConfig,effectiveConfig,changed);
+      assertMaintenance(plan,options);
+      const backup=await backupProjectFile(file,latest,'commands');
+      if(plan.affected.length)await host.replace({plugins:entries,config:effectiveConfig,affected:plan.affected});
+      const 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:oldEntries,config:oldConfig,affected:plan.affected});}
+        catch(recovery){host.invalidate();throw new AggregateError([error,recovery],`命令设置保存失败且恢复失败：${error.message}；${recovery.message}`);}
+        throw error;
+      }finally{await rm(temp,{force:true});}
+      for(const key of Object.keys(project))delete project[key];Object.assign(project,nextProject);
+      return {backup,commandPresets:structuredClone(presets),shortcuts:structuredClone(nextProject.shortcuts)};
+    });}finally{busy=false;}
+  }
   function pluginPrivileges(plugin){
     const report=action=>{
       const requirement=resolvePrivilegeRequirement(plugin,action);
@@ -293,7 +394,15 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
     if(active.length)throw new FlowError(`请先停止受影响插件提供的 Web：${active.join('、')}`,{code:'WEB_ACTIVE',details:{plugins:active}});
   }
   function workflowPrivileges(closure,entryId){
-    const flows=new Map(closure.workflows.map(w=>[w.id,w])),report=[];
+    const flows=new Map(closure.workflows.map(w=>[w.id,w])),report=[],stoppingFlows=new Map();
+    const mayStopFlow=id=>{
+      if(!stoppingFlows.has(id))stoppingFlows.set(id,(flows.get(id)?.steps??[]).some(mayStopStep));
+      return stoppingFlows.get(id);
+    };
+    const mayStopStep=step=>!!step.stop
+      ||!!step.workflow&&mayStopFlow(store.childId(step.workflow))
+      ||!!step.branch&&[...step.branch.then,...(step.branch.else??[])].some(mayStopStep)
+      ||!!step.parallel&&step.parallel.steps.some(mayStopStep);
     const visit=(id,mandatory)=>{
       const workflow=flows.get(id);
       if(!workflow)return;
@@ -308,8 +417,9 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
           }
           if(step.workflow)visit(store.childId(step.workflow),needed);
           if(step.branch){steps(step.branch.then,false);steps(step.branch.else??[],false);}
-          if(step.parallel)steps(step.parallel.steps,needed);
-          if(step.stop)available=false;
+          // 并行兄弟可能在动作开始前停止整组；嵌套 stop 也会传播到后续步骤。
+          if(step.parallel)steps(step.parallel.steps,needed&&!step.parallel.steps.some(mayStopStep));
+          if(mayStopStep(step))available=false;
         }
       };
       steps(workflow.steps,mandatory);
@@ -318,14 +428,9 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
   }
   async function findPluginWorkflowReferences(id){
     const refs=[];
-    const collect=(steps,found)=>{for(const step of steps??[]){
-      if(typeof step.action==='string'&&step.action.startsWith(`${id}:`))found.add(step.action);
-      if(step.branch){collect(step.branch.then,found);collect(step.branch.else,found);}
-      if(step.parallel)collect(step.parallel.steps,found);
-    }};
     for(const workflow of await store.list()){
-      const found=new Set();collect(workflow.steps,found);
-      if(found.size)refs.push({id:workflow.id,title:workflow.title??workflow.id,actions:[...found]});
+      const actions=[...workflowActions(workflow.steps)].filter(action=>action.startsWith(`${id}:`));
+      if(actions.length)refs.push({id:workflow.id,title:workflow.title??workflow.id,actions});
     }
     return refs;
   }
@@ -362,8 +467,9 @@ export async function createApplication({projectDir=process.cwd(),workspace,outp
         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=[...initial,...next.loaded],activeConfig={...project.config,...config},effectiveConfig={...latest.config,...config};
+      const nextEntries=entriesWithPresets([...initial,...next.loaded],latest.commandPresets??{}),activeConfig={...project.config,...config},effectiveConfig={...latest.config,...config};
       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 plan=planPluginUpdate(host.definitions,candidate.definitions,activeConfig,effectiveConfig,sourceChanges);
       assertMaintenance(plan,options);

package/manual/packages/core/src/export-snapshot.js

@@ -1,5 +1,6 @@
 import {fileURLToPath} from 'node:url';
 import {FlowError} from '@mytools/sdk';
+import {COMMANDS_PLUGIN_ID} from '@mytools/commands';
 
 function selectedNetwork(network,ids){
   if(!network)return undefined;
@@ -28,6 +29,24 @@ export async function createExportSnapshot({store,host,project},{entries,portabl
   for(const id of closure.plugins)ids.add(id);
   if(includeWeb){if(!web)throw new FlowError('未安装提供 Web 服务的插件');ids.add(web.id);}
   for(const id of ids)for(const dependency of Object.keys(host.definitions.get(id)?.dependencies??{}))ids.add(dependency);
+  const usedActions=new Set();
+  const scan=steps=>{for(const step of steps??[]){
+    if(step.action)usedActions.add(step.action);
+    if(step.branch){scan(step.branch.then);scan(step.branch.else);}
+    if(step.parallel)scan(step.parallel.steps);
+  }};
+  for(const workflow of closure.workflows)scan(workflow.steps);
+  const commandPresets=Object.fromEntries(Object.entries(project.commandPresets??{}).filter(([id])=>ids.has(COMMANDS_PLUGIN_ID)&&(portable||usedActions.has(`${COMMANDS_PLUGIN_ID}:${id}`))));
+  const commandAllowed=id=>!id.startsWith(`${COMMANDS_PLUGIN_ID}:`)||Object.hasOwn(commandPresets,id.slice(COMMANDS_PLUGIN_ID.length+1));
+  const commands=new Map(host.commands().map(command=>[command.name,command]));
+  const shortcuts=Object.fromEntries(Object.entries(project.shortcuts??{}).filter(([,target])=>{
+    if(target.action){
+      const action=host.actions.get(target.action);
+      return action&&ids.has(action.plugin)&&commandAllowed(target.action);
+    }
+    const command=commands.get(target.command);
+    return command&&target.plugin===command.plugin&&ids.has(command.plugin)&&(!command.action||commandAllowed(`${command.plugin}:${command.action}`));
+  }));
   const plugins=[...ids].map(id=>{
     const p=host.definitions.get(id);
     if(!p?.root)throw new FlowError('内存中临时定义的插件不能打包，请先安装为标准包');
@@ -37,6 +56,6 @@ export async function createExportSnapshot({store,host,project},{entries,portabl
       ['actions',Object.fromEntries(Object.entries(p.actions??{}).map(([name,action])=>[name,{environments:action.environments,requirements:action.requirements}]))],
     ]);
   });
-  return structuredClone({entries,closure,plugins,project:{environments:project.environments,network:selectedNetwork(project.network,ids),logs:project.logs,baseBundle:project.baseBundle},
+  return structuredClone({entries,closure,plugins,project:{environments:project.environments,network:selectedNetwork(project.network,ids),logs:project.logs,baseBundle:project.baseBundle,commandPresets,shortcuts},
     toolRoot:fileURLToPath(new URL('../../fst-cli',import.meta.url))});
 }

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

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

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

@@ -6,7 +6,7 @@
 
 fst 命令入口、交互终端、输入呈现和运行观察。通过公开应用和模块接口工作，业务执行不在界面中重复实现。
 
-内部依赖：`@mytools/sdk`、`@mytools/core`、`@mytools/fst-workspace`、`@mytools/fst-platform`、`@mytools/fst-plugin`、`@mytools/fst-devtools`。
+内部依赖：`@mytools/sdk`、`@mytools/core`、`@mytools/fst-workspace`、`@mytools/fst-platform`、`@mytools/fst-plugin`、`@mytools/fst-devtools`、`@mytools/fst-logs`。
 ## 公开入口
 
 | 导入路径 | 实现位置 |
@@ -33,6 +33,8 @@ fst 命令入口、交互终端、输入呈现和运行观察。通过公开应
 
 ## 维护与验证
 
+TUI 支持 `!` 系统命令、`/commands` 常用命令注册和 `/shortcuts` 任意插件能力快捷名。主输入框与命令编辑框使用 Shift+Enter / Alt+Enter 换行、Enter 提交；真实多行粘贴保持换行及缩进。使用说明可通过 `fst docs commands` 离线阅读。
+
 本模块负责上述职责的实现、文档与回归；跨模块接口调整需要同时检查生产者与消费者。具体维护人员尚未指定。
 
 在仓库根目录执行：
@@ -52,3 +54,8 @@ node --test tests/modules.test.js tests/cli.test.js tests/terminal.test.js
 ## 完整日志分页
 
 `fst logs` 列出历史，`fst logs <id> --cursor 0 --limit 65536 --json` 返回正文和下一页字节游标。TUI 运行详情按 `p` 打开完整日志，每页读取后可前后翻页或刷新。主面板保留有界近期摘要；日志清理失败显示维护警告。细节见 `fst docs generation`。
+
+主面板通过 `fst-logs/steps` 共用步骤摘要缓存，按最近更新顺序淘汰，同时限制条数和字节量。
+摘要不保存业务 input/output；缺失的状态显示“摘要已省略”，已有错误仍可查看。
+运行输入、最终结果与错误通过 `fst-logs/preview` 保存有界预览，避免业务完成后又缓存完整大结果。
+展开时明确提示结果为摘要，完整结果仍在日志中；不会替换业务调用方取得的完整输出。

package/manual/packages/fst-cli/package.json

@@ -36,6 +36,7 @@
   "dependencies": {
     "@mytools/sdk": "0.1.0",
     "@mytools/core": "0.1.0",
+    "@mytools/fst-logs": "0.1.0",
     "@mytools/fst-workspace": "0.1.0",
     "@mytools/fst-platform": "0.1.0",
     "@mytools/fst-plugin": "0.1.0",

package/manual/packages/fst-cli/src/terminal/command-menu.js

@@ -0,0 +1,186 @@
+import {randomUUID} from 'node:crypto';
+import {isCommandName} from '@mytools/fst-plugin/contracts';
+import {editValue} from './schema.js';
+
+export async function runShortcut(session,entry,args=[]){
+  if(!entry.available)throw new Error(`快捷名称 /${entry.name} 已失效：${entry.reason??'目标不存在'}`);
+  const {app}=session,target=entry.target;
+  if(target.command){
+    const command=app.listCommands().find(command=>command.name===target.command&&command.plugin===target.plugin);
+    if(!command)throw new Error(`快捷名称 /${entry.name} 的目标命令不存在`);
+    return session.pluginCommand({...command,name:entry.name,targetName:command.name,shortcutInput:entry.input??{}},args);
+  }
+  const action=app.catalog().find(action=>action.id===target.action);
+  if(!action)throw new Error(`快捷名称 /${entry.name} 的目标动作不存在`);
+  const plugin=action.plugin??action.id.slice(0,action.id.lastIndexOf(':'));
+  return session.pluginCommand({...action,name:entry.name,plugin,action:action.id.slice(plugin.length+1),actionId:action.id,shortcutInput:entry.input??{}},args);
+}
+
+async function parameters(session,value={}){
+  const result=structuredClone(value),{ui}=session;
+  for(;;){
+    const choice=await ui.select('命令参数（脚本通过 FST_INPUT_参数名 环境变量读取）',[
+      ...Object.entries(result).map(([name,field])=>({value:`field:${name}`,label:field.title??name,description:`${name} · ${field.type}`})),
+      {value:'new',label:'添加参数'},{value:'back',label:'完成参数设置'},
+    ]);
+    if(choice==='back')return result;
+    const existing=choice.startsWith('field:')?choice.slice(6):undefined;
+    if(existing){
+      const operation=await ui.select(`参数 ${existing}`,[{value:'edit',label:'编辑'},{value:'remove',label:'删除'},{value:'back',label:'返回'}]);
+      if(operation==='back')continue;
+      if(operation==='remove'){delete result[existing];continue;}
+    }
+    const name=existing??(await ui.input('参数名（英文字母、数字、下划线，不能以数字开头）',{files:false})).trim();
+    if(!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)||['__proto__','constructor','prototype'].includes(name)){ui.show('参数名无效，请重新填写。');continue;}
+    if(!existing&&Object.hasOwn(result,name)){ui.show('参数名已经存在。');continue;}
+    const title=await ui.input('参数显示名称',{value:result[name]?.title??name,files:false});
+    const type=await ui.select('参数类型',[{value:'string',label:'文本'},{value:'number',label:'数字'},{value:'boolean',label:'是 / 否'}]);
+    const field={title,type,required:await ui.confirm('这个参数必须填写吗？')};
+    if(await ui.confirm('设置默认值吗？'))field.default=await editValue(ui,{type},result[name]?.default,{baseDir:session.baseDir,required:true,label:'默认值'});
+    result[name]=field;
+  }
+}
+
+async function editPreset(session,id,current){
+  const {ui,app}=session,preset=structuredClone(current??{shell:'auto'});
+  preset.title=(await ui.input('常用命令名称',{value:preset.title??'',files:false})).trim();
+  preset.script=await ui.input('命令文本 · Shift+Enter 换行，Enter 提交（Alt+Enter 备用）',{value:preset.script??'',files:false,multiline:true});
+  const action=`@mytools/commands:${id}`;
+  const oldName=Object.keys(app.project.shortcuts??{}).find(name=>app.project.shortcuts[name].action===action);
+  let shortcut=oldName??(isCommandName(preset.title)?preset.title:'');
+  for(;;){
+    const choice=await ui.select('常用命令设置',[
+      {value:'save',label:'保存',description:shortcut?`快捷执行 /${shortcut}`:'只注册工作流动作'},
+      {value:'title',label:'修改名称'},{value:'script',label:'编辑多行命令'},
+      {value:'shortcut',label:'快捷名称',description:shortcut||'未设置'},
+      {value:'shell',label:'命令解释器',description:preset.shell??'auto'},
+      {value:'timeout',label:'超时时间',description:preset.timeout===0?'不限时':`${(preset.timeout??30000)/1000} 秒`},
+      {value:'parameters',label:'参数',description:`${Object.keys(preset.parameters??{}).length} 项，可不设置`},
+      {value:'root',label:'Linux root 权限要求',description:preset.requireRoot?'需要 root':'按当前用户权限执行'},
+      {value:'back',label:'取消，返回'},
+    ]);
+    if(choice==='back')return;
+    if(choice==='title')preset.title=(await ui.input('常用命令名称',{value:preset.title,files:false})).trim();
+    else if(choice==='script')preset.script=await ui.input('命令文本 · Shift+Enter 换行，Enter 提交（Alt+Enter 备用）',{value:preset.script,files:false,multiline:true});
+    else if(choice==='shortcut')shortcut=(await ui.input('快捷名称（支持中文，不含空格或 /；留空不设置）',{value:shortcut,files:false})).trim();
+    else if(choice==='shell')preset.shell=await ui.select('命令解释器',[
+      {value:'auto',label:'按系统选择（Windows PowerShell / Linux sh）'},
+      {value:'powershell',label:'Windows PowerShell'},{value:'pwsh',label:'PowerShell 7（pwsh）'},
+      {value:'sh',label:'sh'},{value:'bash',label:'bash'},
+    ]);
+    else if(choice==='timeout'){
+      const seconds=Number(await ui.input('超时时间（秒，0 表示不限时）',{value:String((preset.timeout??30000)/1000),files:false}));
+      if(!Number.isFinite(seconds)||!Number.isSafeInteger(seconds*1000)||seconds<0||seconds*1000>2147483647){ui.show('超时时间无效。');continue;}
+      preset.timeout=seconds*1000;
+    }else if(choice==='parameters')preset.parameters=await parameters(session,preset.parameters);
+    else if(choice==='root')preset.requireRoot=await ui.confirm('这个命令在 Linux 上必须使用 root 吗？执行前会检查，不会自动提权。');
+    else if(choice==='save'){
+      const next={...app.project.commandPresets,[id]:preset},shortcuts=structuredClone(app.project.shortcuts??{});
+      if(oldName)delete shortcuts[oldName];
+      if(shortcut){
+        if(Object.hasOwn(shortcuts,shortcut)){ui.show(`快捷名称 /${shortcut} 已存在，请选择其他名称。`);continue;}
+        shortcuts[shortcut]={...(oldName?app.project.shortcuts[oldName]:{}),action};
+      }
+      try{
+        const result=await session.withMaintenance(options=>app.configureCommandPresets(next,{...options,shortcuts}));
+        if(result===null){ui.show('已取消保存。');continue;}
+        ui.show(`常用命令已保存，修改前配置已备份。${shortcut?`输入 /${shortcut} 可直接运行。`:''}也可在工作流中添加此动作。`);
+        return;
+      }catch(error){ui.show(`保存失败：${error.message}`);}
+    }
+  }
+}
+
+export async function commandPresetsMenu(session){
+  const {app,ui}=session;
+  for(;;){
+    const choice=await ui.select('常用命令',[
+      ...(!app.project.readOnly?[{value:'new',label:'注册常用命令'}]:[]),
+      ...Object.entries(app.project.commandPresets??{}).map(([id,preset])=>({value:`preset:${id}`,label:preset.title,description:id})),
+      {value:'back',label:'返回主面板'},
+    ]);
+    if(choice==='back')return;
+    if(choice==='new'){session.writable();await editPreset(session,`command-${randomUUID().slice(0,8)}`);continue;}
+    const id=choice.slice(7),preset=app.project.commandPresets?.[id];if(!preset)continue;
+    const operation=await ui.select(preset.title,[{value:'run',label:'运行'},
+      ...(!app.project.readOnly?[{value:'edit',label:'编辑'},{value:'remove',label:'删除注册项'}]:[]),{value:'back',label:'返回'}]);
+    if(operation==='run')await runShortcut(session,{name:preset.title,target:{action:`@mytools/commands:${id}`},input:{},available:true});
+    else if(operation==='edit'){session.writable();await editPreset(session,id,preset);}
+    else if(operation==='remove'){
+      session.writable();if(!await ui.confirm(`删除 ${preset.title}？指向它的快捷名称会显示失效；引用中的工作流需先调整。`))continue;
+      const next=structuredClone(app.project.commandPresets);delete next[id];
+      try{const result=await session.withMaintenance(options=>app.configureCommandPresets(next,options));if(result!==null)ui.show('注册项已删除，修改前配置已备份。');}
+      catch(error){ui.show(`删除失败：${error.message}`);}
+    }
+  }
+}
+
+function targets(app){
+  return [...app.catalog().map(action=>({value:`action:${action.id}`,label:`动作：${action.title??action.id}`,description:action.id})),
+    ...app.listCommands().map(command=>({value:`command:${command.name}`,label:`命令：/${command.name}`,description:command.description}))];
+}
+function shortcutTarget(app,selected){
+  if(selected.startsWith('action:'))return {action:selected.slice(7)};
+  const name=selected.slice(8),command=app.listCommands().find(command=>command.name===name);
+  if(!command)throw new Error('目标命令已失效，请重新选择');
+  return {command:name,plugin:command.plugin};
+}
+async function editShortcut(session,oldName){
+  const {app,ui}=session,old=app.project.shortcuts?.[oldName];
+  let name=(await ui.input('快捷名称（支持中文，不含空格或 /）',{value:oldName??'',files:false})).trim();
+  let target=old?structuredClone(old):{};
+  if(!old){
+    const choices=targets(app);if(!choices.length){ui.show('当前没有可选择的插件动作或命令。');return;}
+    const selected=await ui.select('选择快捷名称指向的能力',choices);
+    target=shortcutTarget(app,selected);
+  }
+  for(;;){
+    const choice=await ui.select(`快捷名称 /${name}`,[
+      {value:'save',label:'保存'},{value:'name',label:'修改快捷名称'},
+      {value:'target',label:'选择目标',description:target.action??target.command},
+      {value:'input',label:'设置默认参数',description:'可留空，运行时按需要填写'},
+      {value:'back',label:'取消，返回'},
+    ]);
+    if(choice==='back')return;
+    if(choice==='name')name=(await ui.input('快捷名称',{value:name,files:false})).trim();
+    else if(choice==='target'){
+      const selected=await ui.select('选择目标',targets(app));
+      target=shortcutTarget(app,selected);
+    }else if(choice==='input'){
+      const metadata=target.action?app.catalog().find(action=>action.id===target.action):app.listCommands().find(command=>command.name===target.command&&command.plugin===target.plugin);
+      if(!metadata){ui.show('目标已失效，请先重新选择目标。');continue;}
+      target.input=await editValue(ui,metadata.input??{type:'object',properties:{},additionalProperties:false},target.input??{},{baseDir:session.baseDir,required:true,label:'快捷名称默认参数'});
+    }else if(choice==='save'){
+      const next=structuredClone(app.project.shortcuts??{});if(oldName)delete next[oldName];
+      if(Object.hasOwn(next,name)){ui.show('快捷名称已经存在，请选择其他名称。');continue;}
+      next[name]=target;
+      try{await app.configureShortcuts(next);ui.show('快捷名称已保存，修改前配置已备份。');return;}
+      catch(error){ui.show(`保存失败：${error.message}`);}
+    }
+  }
+}
+
+export async function shortcutsMenu(session){
+  const {app,ui}=session;
+  for(;;){
+    const entries=app.listShortcuts(),choice=await ui.select('自定义快捷名称',[
+      ...(!app.project.readOnly?[{value:'new',label:'添加快捷名称'}]:[]),
+      ...entries.map(entry=>({value:`shortcut:${entry.name}`,label:`/${entry.name}${entry.available?'':' [失效]'}`,description:entry.available?entry.description:entry.reason})),
+      {value:'back',label:'返回主面板'},
+    ]);
+    if(choice==='back')return;
+    if(choice==='new'){session.writable();await editShortcut(session);continue;}
+    const name=choice.slice(9),entry=entries.find(entry=>entry.name===name);if(!entry)continue;
+    const operation=await ui.select(`/${name}`,[
+      ...(entry.available?[{value:'run',label:'运行'}]:[]),
+      ...(!app.project.readOnly?[{value:'edit',label:'编辑'},{value:'remove',label:'删除快捷名称'}]:[]),{value:'back',label:'返回'},
+    ]);
+    if(operation==='run')await runShortcut(session,entry);
+    else if(operation==='edit'){session.writable();await editShortcut(session,name);}
+    else if(operation==='remove'){
+      session.writable();if(!await ui.confirm(`删除快捷名称 /${name}？`))continue;
+      const next=structuredClone(app.project.shortcuts??{});delete next[name];
+      await app.configureShortcuts(next);ui.show('快捷名称已删除，插件能力仍可使用。');
+    }
+  }
+}

package/manual/packages/fst-cli/src/terminal/navigation.js

@@ -1,10 +1,11 @@
 import {builtinCommands} from '@mytools/fst-plugin/contracts';
 
-const visible=['workflows','run','pack','logs','plugin','config','tools','help','exit'];
+const visible=['workflows','run','pack','logs','plugin','commands','shortcuts','config','tools','help','exit'];
 // 入口由插件 ID 推导；冲突时加前缀，不能覆盖内置或作者注册的命令。
-export function commandMenu(plugins,commands){
+export function commandMenu(plugins,commands,shortcuts=[]){
   const entries=builtinCommands.filter(command=>visible.includes(command.name)).map(command=>({...command,description:`[内置] ${command.description}`}));
-  const used=new Set([...builtinCommands.map(c=>c.name),...commands.map(c=>c.name)]);
+  const used=new Set([...builtinCommands.map(c=>c.name),...commands.map(c=>c.name),...shortcuts.map(entry=>entry.name)]);
+  entries.push(...shortcuts.map(entry=>({name:entry.name,shortcut:true,description:`[快捷] ${entry.available?entry.description:`已失效：${entry.reason}`}`})));
   const groups=plugins.filter(plugin=>commands.some(c=>c.plugin===plugin.id)).sort((a,b)=>a.id.localeCompare(b.id));
   for(const plugin of groups){
     const leaf=plugin.id.split('/').at(-1).replace(/[^\w.-]/g,'-');