@yanglaofish/fishtools 0.5.3 → 0.6.0

package/manual/packages/sdk/reports.js

@@ -0,0 +1,53 @@
+import {FlowError} from './index.js';
+import {assertSchema,validate} from './validation.js';
+
+const text={type:'string',pattern:'\\S'};
+const alerts={type:'array',items:{type:'object',properties:{level:{enum:['info','warning','error']},message:text},required:['level','message'],additionalProperties:false}};
+const conclusions={summary:text,alerts,recommendations:{type:'array',items:text}};
+export const reportSchema={
+  type:'object',
+  properties:{
+    kind:{const:'fst-report'},version:{const:1},title:text,...conclusions,
+    sections:{type:'array',items:{type:'object',properties:{title:text,...conclusions,data:true,columns:{type:'array',items:text,minItems:1,uniqueItems:true},titles:{type:'object',additionalProperties:text}},required:['title'],additionalProperties:false}},
+  },
+  required:['kind','version','title'],additionalProperties:false,
+};
+
+// 与落盘 JSON 边界一致，提前拒绝会被 JSON.stringify 静默改值的内容。
+function assertJson(value,ancestors=new Set()){
+  if(value===null||typeof value==='string'||typeof value==='boolean'||typeof value==='number'&&Number.isFinite(value))return;
+  if(typeof value!=='object'||!value||ancestors.has(value)||(!Array.isArray(value)&&![Object.prototype,null].includes(Object.getPrototypeOf(value))))throw new Error('报告必须为无循环引用的 JSON 数据');
+  ancestors.add(value);
+  try{
+    const list=Array.isArray(value),keys=Reflect.ownKeys(value);
+    if(list&&keys.length!==value.length+1)throw new Error('报告数组不能含空槽或附加属性');
+    for(const key of keys){
+      if(list&&key==='length')continue;
+      const field=Object.getOwnPropertyDescriptor(value,key);
+      if(typeof key!=='string'||!field.enumerable||!Object.hasOwn(field,'value')||list&&(!Number.isInteger(Number(key))||Number(key)<0||Number(key)>=value.length||String(Number(key))!==key))throw new Error('报告只能包含 JSON 可保留的普通数据属性');
+      assertJson(field.value,ancestors);
+    }
+  }finally{ancestors.delete(value);}
+}
+
+export function inspectReport(value){
+  try{
+    if(!value||typeof value!=='object'||Array.isArray(value))return {status:'none'};
+    const kind=Object.getOwnPropertyDescriptor(value,'kind');
+    if(kind&&!Object.hasOwn(kind,'value'))throw new Error('报告标记不能为访问器');
+    if(kind?.value!=='fst-report')return {status:'none'};
+    assertJson(value);
+    if(Number.isInteger(value.version)&&value.version!==1)return {status:'unsupported',message:`不支持报告版本 ${value.version}，已回退字段阅读。`};
+    const check=assertSchema(reportSchema,'报告',{useDefaults:false});
+    if(!check(value))return {status:'invalid',message:'报告格式无效，已回退字段阅读。',details:structuredClone(check.errors)};
+    return {status:'valid',report:value};
+  }catch(error){return {status:'invalid',message:`报告格式无效：${error.message}，已回退字段阅读。`};}
+}
+
+export function createReport(content){
+  try{assertJson(content);}catch(error){throw new FlowError(`报告格式无效：${error.message}`,{code:'REPORT_INVALID'});}
+  const value={kind:'fst-report',version:1,...content};
+  const result=inspectReport(value);
+  if(result.status!=='valid')throw new FlowError(result.message??'报告格式无效',{code:'REPORT_INVALID',details:result.details});
+  return validate(reportSchema,value,'报告',{useDefaults:false});
+}

package/node_modules/@mytools/core/README.md

@@ -27,6 +27,8 @@
 
 `createApplication({projectDir,pluginRegistryDir})` 可让多个工作区读取同一插件库；CLI 默认接入用户级全局库，程序未传此选项时保留工作区模式。分发包始终使用自身工作区安装状态。`listPlugins()` 返回 scope/source 和待配置原因；`pluginDefinition(id)` 返回作者声明。`app.resultsDir` 是业务文件根，`app.outputDir` 保留为日志根；插件 `ctx.outputDir` 与 `ctx.logDir` 分别对应本次业务目录和日志目录。
 
+已安装条目的加载或单插件契约错误隔离为 `runtime.status: 'unavailable'`，`listPlugins()` 返回 `loadError` 与来源，传递依赖者同样不可用。直接调用或检查引用它的流程抛出 `PLUGIN_UNAVAILABLE`；无关插件继续装配。纯卸载允许保留其他旧故障；新安装/链接严格检查。修复来源后须重新启动。此恢复不覆盖预置插件、明确的跨插件图错误和运行时初始化错误。
+
 `app.startShell(script,options)` 执行临时命令，`app.startAction(id,input,context)` 调用任意动作，两者均纳入运行记录与关闭等待。`startCommand(name,input,{expectedPlugin,...context})` 可固定命令提供者，启动时再次检查，防止参数填写期间被其他同名能力替换。`configureCommandPresets` 和 `configureShortcuts` 在备份、冲突检查与变更锁内保存项目设置；命令快捷项在用户明确设置时绑定提供者 ID，普通安装/卸载和未改变目标的整组保存不会重新绑定；已有未绑定项必须明确提供 plugin 或在界面重新选择目标。注册项变化通过定向宿主更新生效，导出快照保留所需定义与有效快捷项。
 
 本模块负责上述职责的实现、文档与回归；跨模块接口调整需要同时检查生产者与消费者。具体维护人员尚未指定。
@@ -37,6 +39,10 @@
 node --test tests/modules.test.js tests/application.test.js tests/lifecycle.test.js tests/module-interfaces.test.js
 ```
 
+## 输入预览
+
+应用接口 `app.previewInput(target, input)` 读取目标动作或命令的当前有效输入及来源；`target` 为 `插件ID:动作名` 或 `/命令名`。由宿主使用当前有效配置解析，返回脱离原对象的 `{value, fields}`，不回写输入，也不暴露整份配置。预览允许缺参，执行时仍作完整校验。验证见 `tests/effective-inputs.test.js`。
+
 ## 开发监督进程
 
 `createDevelopmentSupervisor({projectDir,entry,args,env,configFile,onEvent})` 启动文件监听 worker 和应用子进程，返回 `status()`、幂等 `close()`。父进程不加载插件运行模块；每次重启使用全新的 Node 进程，完整更新 ESM 导入依赖。`bindDevelopmentChild(app,{details,closePresentation})` 通过 IPC 报告就绪，收到重启请求后等待 `app.developmentStatus()` 的运行和管理操作均为空闲，再调用 `app.close()` 及界面清理。

package/node_modules/@mytools/core/src/application.js

@@ -7,6 +7,7 @@ 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 {createProcessRunner} from '@mytools/fst-platform/managed-process';
 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';
@@ -27,6 +28,7 @@ import {validateNetworkPolicy,inspectNetworkPolicy,resolveNetworkPolicy,buildPro
 import {resolvePrivilegeRequirement,checkStaticPrivilege} from '@mytools/fst-plugin/privileges';
 import {registerWorkspace,registryWorkflowReferences,registryPluginReferences} from '@mytools/fst-workspace/registry';
 import {mergePluginEntries,preparePluginCatalog} from './plugin-catalog.js';
+import {loadInstalledEntry} from './plugin-loading.js';
 
 function declaredCommands(entries){
   return entries.flatMap(entry=>{const plugin=entry.plugin??entry;return Object.keys(plugin.commands??{}).map(name=>({name,plugin:plugin.id}));});
@@ -73,8 +75,9 @@ export async function createApplication({projectDir=process.cwd(),workspace,plug
     developmentStatus:()=>({running:launching+writingRuns.size+operations.size,busy,closing:!!closing}),
     catalog:()=>host.catalog(),
     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)};}),
+    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:pending.get(p.id).status??'unconfigured'}:host.runtimeStatus().find(r=>r.id===p.id)),...(p.runtime?{updatePolicy:p.runtime.updatePolicy??'maintenance'}:{})},...(pending.has(p.id)?(pending.get(p.id).status==='unavailable'?{loadError:pending.get(p.id).error}:{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(),
+    previewInput:(target,input)=>host.previewInput(target,input),
     listShortcuts:()=>describeShortcuts(project.shortcuts??{},{actions:host.catalog(),commands:host.commands()}),
     async configureShortcuts(value){return updateUserCommands({shortcuts:value});},
     async configureCommandPresets(value,options={}){
@@ -86,7 +89,7 @@ export async function createApplication({projectDir=process.cwd(),workspace,plug
     async removeWorkflow(id,options){return mutateWorkflow(()=>store.remove(id,options));},
     async checkWorkflow(id){
       host.assertHealthy();
-      const closure=await store.resolve([id],host);
+      const closure=await store.resolve([id],{...host,actions:{get(action){assertConfigured(action.slice(0,action.lastIndexOf(':')));return host.actions.get(action);}}});
       return {...closure,privileges:workflowPrivileges(closure,id)};
     },
     subscribe(fn){emitter.on('event',fn);return ()=>emitter.off('event',fn);},
@@ -125,8 +128,7 @@ export async function createApplication({projectDir=process.cwd(),workspace,plug
       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,
-          onStart:invocation=>context.log('执行程序',invocation,{kind:'process'}),
-          onOutput:({stream,message})=>context.log(message,undefined,{stream,audience:'user'})});
+          runProcess:createProcessRunner({signal:context.signal,log:context.log,audience:'user'})});
         if(result.exitCode!==0)throw new FlowError(`命令执行失败，退出码 ${result.exitCode}`,{code:'EXECUTION_FAILED',details:result});
         return result;
       },{kind:'shell',title:'系统命令'});
@@ -331,11 +333,15 @@ export async function createApplication({projectDir=process.cwd(),workspace,plug
   }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));
+    for(const name of Object.keys(current.dependencies??{}))if(!excluded.has(name)&&(!maintenance||name!==omitInstalledPlugin))loaded.push(await loadInstalledEntry(name,name,current.root));
+    for(const [name,source] of Object.entries(current.links??{}))if(!excluded.has(name)&&(!maintenance||name!==omitInstalledPlugin))loaded.push(await loadInstalledEntry(name,source,base,{linked:true}));
     return loaded;
   }
-  function assertConfigured(id){if(pending.has(id))throw new FlowError(`插件 ${id} 尚未配置：${pending.get(id).message}`,{code:'PLUGIN_NOT_CONFIGURED',details:{plugin:id}});}
+  function assertConfigured(id){
+    const failure=pending.get(id);if(!failure)return;
+    if(failure.status==='unavailable')throw new FlowError(`插件 ${id} 不可用（${failure.entry.root??'未知来源'}）：${failure.message}`,{code:'PLUGIN_UNAVAILABLE',details:{plugin:id,source:failure.entry.root,error:failure.error}});
+    throw new FlowError(`插件 ${id} 尚未配置：${failure.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)=>{
@@ -466,7 +472,7 @@ export async function createApplication({projectDir=process.cwd(),workspace,plug
   }
   async function findPluginWorkflowReferences(id){
     const refs=[];
-    for(const workflow of await store.list()){
+    for(const workflow of await store.list({strict:true})){
       const actions=[...workflowActions(workflow.steps)].filter(action=>action.startsWith(`${id}:`));
       if(actions.length)refs.push({id:workflow.id,title:workflow.title??workflow.id,actions});
     }
@@ -510,7 +516,7 @@ export async function createApplication({projectDir=process.cwd(),workspace,plug
         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(targetDir,{...operation,sourceDir:projectDir,state:shared&&targetDir===registryDir?{...targetState,global:true}:targetState});
+      const next=await installGeneration(targetDir,{...operation,sourceDir:projectDir,state:shared&&targetDir===registryDir?{...targetState,global:true}:targetState,recoverInstalled:loadInstalledEntry});
       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};

package/node_modules/@mytools/core/src/plugin-catalog.js

@@ -18,9 +18,28 @@ export function mergePluginEntries(initial,local,global,disabledLegacy=[],{share
 }
 
 export function preparePluginCatalog(entries,config){
-  const pending=new Map();validatePluginDefinitions(entries);
+  const pending=new Map(),unavailable=new Set();
+  for(const entry of entries)if(entry.unavailable){
+    const id=entry.plugin.id;unavailable.add(id);
+    pending.set(id,{entry,status:'unavailable',message:entry.unavailable.message,error:entry.unavailable});
+  }
+  // 故障依赖的消费者显式不可用，直到用户修复来源并重新启动。
+  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){
+        const message=`依赖插件不可用：${missing.join('、')}`;
+        pending.set(plugin.id,{entry,status:'unavailable',message,error:{message,phase:'dependency',dependencies:missing}});changed=true;
+      }
+    }
+  }while(changed);
+  validatePluginDefinitions(entries,{unavailable,blocked:new Set(pending.keys())});
   for(const entry of entries){
     const plugin=entry.plugin??entry;
+    if(pending.has(plugin.id))continue;
     if(plugin.config!==undefined)assertSchema(plugin.config,`${plugin.id} 配置`);
     try{validate(plugin.config,config[plugin.id]??{},`${plugin.id} 配置`);}
     catch(error){
@@ -29,7 +48,6 @@ export function preparePluginCatalog(entries,config){
     }
   }
   // 缺配置的服务提供者暂不启用，相关消费者也等待；无关插件正常装配。
-  let changed;
   do{
     changed=false;
     for(const entry of entries){

package/node_modules/@mytools/core/src/plugin-loading.js

@@ -0,0 +1,24 @@
+import path from 'node:path';
+import {loadPlugin} from '@mytools/fst-plugin/loader';
+import {validatePluginDefinition} from '@mytools/fst-plugin';
+import {assertSchema} from '@mytools/sdk/schema';
+import {FlowError} from '@mytools/sdk';
+import {errorRecord} from '@mytools/sdk/diagnostics';
+
+// 已安装插件加载失败时保留注册身份，避免错误导出破坏管理和卸载入口。
+export async function loadInstalledEntry(id,spec,base,{linked=false}={}){
+  let loaded,phase='load';
+  const source=linked?path.resolve(base,spec):path.join(base,'node_modules',id);
+  try{
+    loaded=await loadPlugin(spec,base);phase='contract';
+    const plugin=validatePluginDefinition(loaded);
+    if(plugin.id!==id)throw new FlowError(`插件导出标识 ${plugin.id} 与已安装标识 ${id} 不一致`,{code:'VALIDATION'});
+    if(plugin.config!==undefined)assertSchema(plugin.config,`${id} 配置`);
+    return loaded;
+  }catch(error){
+    const original=loaded?.plugin,plugin={id};
+    for(const key of ['version','title','description'])if(typeof original?.[key]==='string')plugin[key]=original[key];
+    if(original?.dependencies&&typeof original.dependencies==='object'&&!Array.isArray(original.dependencies))plugin.dependencies=original.dependencies;
+    return {plugin,root:loaded?.root??source,unavailable:{...errorRecord(error),phase}};
+  }
+}

package/node_modules/@mytools/core/src/version.js

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

package/node_modules/@mytools/fst-cli/README.md

@@ -6,6 +6,8 @@
 
 fst 命令入口、交互终端、输入呈现和运行观察。通过公开应用和模块接口工作，业务执行不在界面中重复实现。
 
+支持 SDK 的 `fst-report` v1 业务报告：主面板默认显示结论、分组和表格，以缩进区分报告标题、结论和组内数据。执行入口、输入及实际指令始终可见；Ctrl+O 展开原始输出与诊断，运行详情中的 `m` 提供专用阅读，`j` 保留原始 JSON。报告的提醒等级只代表插件的业务判断，不改变运行状态。旧文本/Markdown/结构化输出保持兼容；损坏和未知版本报告提示后回退字段阅读。
+
 内部依赖：`@mytools/sdk`、`@mytools/core`、`@mytools/fst-workspace`、`@mytools/fst-platform`、`@mytools/fst-plugin`、`@mytools/fst-devtools`、`@mytools/fst-logs`。
 ## 公开入口
 
@@ -35,7 +37,9 @@ fst 命令入口、交互终端、输入呈现和运行观察。通过公开应
 
 TUI 支持 `!` 系统命令、`/commands` 常用命令注册和 `/shortcuts` 任意插件能力快捷名。主输入框与命令编辑框使用 Shift+Enter / Alt+Enter 换行、Enter 提交；真实多行粘贴保持换行及缩进。使用说明可通过 `fst docs commands` 离线阅读。
 
-运行和步骤附近提示 Ctrl+O，展开后按 schema 字段标题阅读结果；受管进程显示实际程序、参数、目录和原始命令。`/logs` 中按 m 单独格式化阅读输出，j 仍保留原始 JSON。总耗时在执行期间每秒更新，结束或关闭界面后回收刷新计时器。平台声明提示直接显示在 TUI。
+空 `/` 只列精简入口；输入前缀后搜索全部已注册命令，例如 `/env` 可找到 `envprobe.*`，`/envprobe.` 可继续缩小范围。唯一且没有名称冲突的命令命名空间也可打开所属插件能力菜单；原插件 ID 入口保留。从插件管理或能力菜单实际启动命令后，其完整命令名进入上下键历史及持久会话；取消参数或启动失败不新增执行条目，参数保留在运行记录中，不拼入可召回命令。
+
+运行和步骤附近提示 Ctrl+O 展开原始输出与诊断；输入及受管进程的实际程序、参数、目录和原始命令默认可见。stdout/stderr（包括感叹号透传）默认折叠，print 用户反馈和业务报告缩进展示。`/logs` 中按 m 单独格式化阅读输出，j 仍保留原始 JSON。总耗时在执行期间每秒更新，结束或关闭界面后回收刷新计时器。平台声明提示直接显示在 TUI。
 
 `/history` 或 `/tools` → 历史会话恢复输入、反馈与结果，不重跑指令；与已有插件或快捷名 `history` 冲突时保留原入口。通过 `fst-logs/sessions` 在所属工作区保存有界快照与完整追加交互记录，只读包改用可写输出目录。较早的内容分页读取，运行日志仍独立保存并遵循其保留策略。恢复创建当前会话的继续记录，不覆盖来源会话；未提交草稿和配置表单不保存。
 

package/node_modules/@mytools/fst-cli/src/terminal/command-menu.js

@@ -1,7 +1,7 @@
 import {randomUUID} from 'node:crypto';
 import {isDeepStrictEqual} from 'node:util';
 import {isCommandName} from '@mytools/fst-plugin/contracts';
-import {editValue} from './schema.js';
+import {editValue,editInput} from './schema.js';
 
 export async function runShortcut(session,entry,args=[]){
   if(!entry.available)throw new Error(`快捷名称 /${entry.name} 已失效：${entry.reason??'目标不存在'}`);
@@ -153,7 +153,8 @@ async function editShortcut(session,oldName){
     }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:'快捷名称默认参数'});
+      const preview=app.previewInput?value=>app.previewInput(target.action??`/${target.command}`,value):undefined;
+      target.input=await editInput(ui,metadata.input??{type:'object',properties:{},additionalProperties:false},target.input??{},{baseDir:session.baseDir,required:true,label:'快捷名称默认参数',preview});
     }else if(choice==='save'){
       const next=structuredClone(app.project.shortcuts??{});if(oldName)delete next[oldName];
       if(Object.hasOwn(next,name)){ui.show('快捷名称已经存在，请选择其他名称。');continue;}

package/node_modules/@mytools/fst-cli/src/terminal/file-autocomplete.js

@@ -0,0 +1,106 @@
+import path from 'node:path';
+import {homedir} from 'node:os';
+import {CombinedAutocompleteProvider} from '@mariozechner/pi-tui';
+import {createFileProbe} from '@mytools/fst-platform/fs';
+import {cleanText as safe} from './theme.js';
+
+function budget(value,fallback,max){return Number.isSafeInteger(value)&&value>0?Math.min(value,max):fallback;}
+export function createAutocompleteProbe(options={}){
+  return options.probe??createFileProbe({timeout:budget(options.timeout,1200,10000),maxConcurrent:1,maxPending:1,allowRemote:options.allowRemote===true});
+}
+function remote(value){
+  const normalized=value.replaceAll('/','\\');
+  if(/^\\\\[?.]\\/u.test(normalized))return /^\\\\[?.]\\UNC(?:\\|$)/iu.test(normalized)||/^\\\\[?.]\\GLOBALROOT\\Device\\(?:Mup|LanmanRedirector|WebDavRedirector)(?:\\|$)/iu.test(normalized);
+  return /^\\\\/u.test(normalized)||/^\\(?:\?\?\\UNC|Device\\(?:Mup|LanmanRedirector|WebDavRedirector))(?:\\|$)/iu.test(normalized);
+}
+
+// 同步接口只查有界缓存；所有文件 I/O 交给可取消的隔离探测进程。
+export class FileAutocomplete extends CombinedAutocompleteProvider{
+  constructor(commands=[],baseDir=process.cwd(),workflows=[],options={}){
+    super(commands,baseDir);this.baseDir=baseDir;this.workflows=workflows;
+    this.defaultCommands=new CombinedAutocompleteProvider(commands.filter(command=>!command.searchOnly),baseDir);
+    this.files=options.files!==false;this.allowRemote=options.allowRemote===true;
+    this.entryLimit=budget(options.entryLimit,1000,10000);this.maxItems=budget(options.maxItems,100,100);
+    this.cacheLimit=budget(options.cacheLimit,16,64);this.cacheTtl=budget(options.cacheTtl,5000,60000);
+    this.timeout=budget(options.timeout,1200,10000);this.debounceMs=options.debounceMs===0?0:budget(options.debounceMs,40,500);
+    this.probe=createAutocompleteProbe(options);this.ownsProbe=options.ownsProbe!==false;
+    this.onUpdate=options.onUpdate;this.cache=new Map();this.closed=false;
+  }
+  cancelPending(){
+    const pending=this.pending;this.pending=null;
+    if(pending){clearTimeout(pending.timer);pending.controller.abort();}
+  }
+  close(){
+    if(this.closing)return this.closing;
+    this.closed=true;this.cancelPending();this.cache.clear();this.onUpdate=null;
+    return this.closing=Promise.resolve(this.ownsProbe?this.probe.close():undefined);
+  }
+  schedule(directory,snapshot){
+    if(this.pending?.directory===directory){this.pending.snapshot=snapshot;return;}
+    this.cancelPending();
+    const pending={directory,snapshot,controller:new AbortController()};this.pending=pending;
+    pending.timer=setTimeout(async()=>{
+      let result;
+      try{result=await this.probe.readDirectory(directory,{limit:this.entryLimit,timeout:this.timeout,signal:pending.controller.signal});}
+      catch{result={status:'error',incomplete:true,reason:'probeFailed'};}
+      if(this.closed||this.pending!==pending||pending.controller.signal.aborted)return;
+      this.pending=null;
+      // 错误和超时也短暂缓存，避免按键触发无限重试。
+      const cached={status:result.status,incomplete:result.incomplete,reason:result.reason,
+        value:result.status==='ok'?result.value.slice(0,this.entryLimit):[],expires:Date.now()+this.cacheTtl};
+      this.cache.delete(directory);this.cache.set(directory,cached);
+      while(this.cache.size>this.cacheLimit)this.cache.delete(this.cache.keys().next().value);
+      this.lastResult={status:cached.status,incomplete:cached.incomplete,reason:cached.reason};
+      this.onUpdate?.(pending.snapshot);
+    },this.debounceMs);
+  }
+  getSuggestions(lines,line,col){
+    if(this.closed)return null;
+    const text=(lines[line]??'').slice(0,col);
+    const prefix=text.match(/(?:^|\s)(@"[^"\n]*|@[^\s]*)$/)?.[1];
+    if(!prefix){
+      if(text==='/'){this.cancelPending();return this.defaultCommands.getSuggestions(lines,line,col);}
+      const run=text.match(/^\/run\s+([^@"\s]*)$/);
+      if(run){
+        this.cancelPending();
+        const query=run[1].toLowerCase(),items=this.workflows.filter(flow=>`${flow.id} ${flow.title??''}`.toLowerCase().includes(query)).slice(0,this.maxItems).map(flow=>({value:flow.id,label:flow.title??flow.id,description:flow.id,workflow:true}));
+        return items.length?{prefix:run[1],items}:null;
+      }
+      // 只把命令交给上游，不能回落到它的同步文件系统实现。
+      if(/^\/[^\s/]*(?:\s.*)?$/.test(text)){this.cancelPending();return super.getSuggestions(lines,line,col);}
+    }
+    if(!this.files)return null;
+    const filePrefix=prefix??this.extractPathPrefix(text,false);
+    if(filePrefix===null){this.cancelPending();return null;}
+    const raw=filePrefix.replace(/^@/,'').replace(/^"/,'').replaceAll('\\','/');
+    // 解析前判定，避免 POSIX resolve 抹掉 UNC 的双斜杠或 Windows 设备前缀。
+    if(!this.allowRemote&&(remote(raw)||remote(this.baseDir))){
+      this.cancelPending();this.lastResult={status:'skipped',incomplete:true,reason:'remotePath'};return null;
+    }
+    const expanded=raw.startsWith('~/')?path.join(homedir(),raw.slice(2)):raw==='~'?homedir():raw;
+    const absolute=path.resolve(this.baseDir,expanded||'.');
+    const directory=!raw||raw==='~'||raw.endsWith('/')?absolute:path.dirname(absolute);
+    const query=!raw||raw==='~'||raw.endsWith('/')?'':path.basename(absolute).toLowerCase();
+    const cached=this.cache.get(directory);
+    if(!cached||cached.expires<=Date.now()){
+      this.schedule(directory,{lines:[...lines],line,col});return null;
+    }
+    if(this.pending?.directory!==directory)this.cancelPending();
+    this.lastResult={status:cached.status,incomplete:cached.incomplete,reason:cached.reason};
+    const items=cached.value.filter(entry=>entry.name.toLowerCase().startsWith(query)).map(entry=>{
+      // 链接只作为链接候选，不逐个 stat 目标。用户显式输入 / 后才读取其内容。
+      const dir=entry.type==='directory',head=raw==='~'?'~/':raw.slice(0,raw.lastIndexOf('/')+1),file=head+entry.name+(dir?'/':'');
+      return {value:`${prefix?'@':''}${/[\s"]/.test(file)?JSON.stringify(file):file}`,label:safe(entry.name)+(dir?'/':''),description:dir?'目录':entry.type==='symlink'?'符号链接':'文件',directory:dir,file:true};
+    }).sort((a,b)=>Number(b.directory)-Number(a.directory)||a.label.localeCompare(b.label)).slice(0,this.maxItems);
+    return items.length?{prefix:filePrefix,items,incomplete:cached.incomplete}:null;
+  }
+  getForceFileSuggestions(lines,line,col){return this.getSuggestions(lines,line,col);}
+  applyCompletion(lines,line,col,item,prefix){
+    if(item.workflow){const next=[...lines],before=lines[line].slice(0,col-prefix.length),text=item.value+' ';next[line]=before+text+lines[line].slice(col);return {lines:next,cursorLine:line,cursorCol:before.length+text.length};}
+    if(!item.file&&!prefix.startsWith('@'))return super.applyCompletion(lines,line,col,item,prefix);
+    const before=lines[line].slice(0,col-prefix.length);
+    let after=lines[line].slice(col);if(after.startsWith('"'))after=after.slice(1);
+    const completed=item.value+(item.directory?'':' '),next=[...lines];next[line]=before+completed+after;
+    return {lines:next,cursorLine:line,cursorCol:before.length+completed.length-(item.directory&&item.value.endsWith('"')?1:0)};
+  }
+}

package/node_modules/@mytools/fst-cli/src/terminal/log-viewer.js

@@ -1,17 +1,18 @@
 import { Markdown, matchesKey, truncateToWidth } from '@mariozechner/pi-tui';
 import { mouseWheel } from './run-viewer.js';
-import {palette,markdownTheme} from './theme.js';
+import {cleanText,palette,markdownTheme} from './theme.js';
 
 const theme=markdownTheme();
 
-// 文本已由 TerminalView 的 safe 清理；每次只向 Overlay 提交当前窗口内的行。
+// 每次只向 Overlay 提交当前窗口内的行；动态结果在消费时清理控制字符。
 export class MarkdownLogViewer{
   constructor({title,text,terminal,onClose,requestRender}){
     this.title=title.replace(/\s+/g,' ');this.terminal=terminal;this.onClose=onClose;this.requestRender=requestRender;
-    this.markdown=new Markdown(text,0,0,theme);this.offset=0;
+    this.source=text;this.markdown=new Markdown(typeof text==='function'?'':cleanText(text),0,0,theme);this.offset=0;
   }
   invalidate(){this.markdown.invalidate();}
   layout(width){
+    if(typeof this.source==='function'&&this.sourceWidth!==width){this.markdown.setText(cleanText(this.source(width)));this.sourceWidth=width;}
     const height=Math.max(1,this.terminal.rows);
     const pageSize=Math.max(1,height-2);
     // Markdown 自身缓存同一宽度的完整渲染，滚动时不重新解析日志。

package/node_modules/@mytools/fst-cli/src/terminal/navigation.js

@@ -1,4 +1,4 @@
-import {builtinCommands} from '@mytools/fst-plugin/contracts';
+import {builtinCommands,isCommandName} from '@mytools/fst-plugin/contracts';
 
 const visible=['workflows','run','pack','logs','plugin','commands','shortcuts','config','tools','help','exit'];
 // 入口由插件 ID 推导；冲突时加前缀，不能覆盖内置或作者注册的命令。
@@ -18,3 +18,25 @@ export function commandMenu(plugins,commands,shortcuts=[]){
   }
   return entries;
 }
+
+// 空斜杠保持精简；输入前缀后可搜索所有可执行命令及无歧义的插件命名空间。
+export function commandCompletions(plugins,commands,shortcuts=[]){
+  const entries=commandMenu(plugins,commands,shortcuts),used=new Set(entries.map(entry=>entry.name));
+  const menuLength=entries.length,aliases=[];
+  for(const command of [...builtinCommands,...commands])if(!used.has(command.name)){
+    used.add(command.name);entries.push({name:command.name,description:command.description??command.name,searchOnly:true});
+  }
+  const namespaces=new Map();
+  for(const command of commands){
+    if(!command.name.includes('.'))continue;
+    const name=command.name.split('.')[0];
+    if(!namespaces.has(name))namespaces.set(name,new Set());
+    namespaces.get(name).add(command.plugin);
+  }
+  for(const [name,owners] of namespaces)if(owners.size===1&&!used.has(name)&&isCommandName(name)){
+    const id=[...owners][0],plugin=plugins.find(plugin=>plugin.id===id);
+    if(!plugin)continue;
+    used.add(name);aliases.push({name,plugin:id,searchOnly:true,description:`[插件] ${plugin.title??id} · 选择能力`});
+  }
+  return [...entries.slice(0,menuLength),...aliases,...entries.slice(menuLength)];
+}

package/node_modules/@mytools/fst-cli/src/terminal/presentation.js

@@ -4,7 +4,7 @@ export const logo=[
   '▀   ▀▀▀ ▀▀▀ ▀ ▀',
 ].join('\n');
 
-export const pluginStatus=plugin=>({ready:'可用',pending:'等待服务',failed:'失败',stopped:'已停止',unconfigured:'待配置'})[plugin.runtime?.status]??'未知';
+export const pluginStatus=plugin=>({ready:'可用',pending:'等待服务',failed:'失败',stopped:'已停止',unconfigured:'待配置',unavailable:'不可用'})[plugin.runtime?.status]??'未知';
 
 export function gettingStarted(flows,{readOnly=false}={}){
   const sample=flows.find(w=>w.id==='hello')??flows[0];
@@ -36,6 +36,7 @@ export function pluginDetails(plugin,actions,commands){
     plugin.description??'作者尚未提供用途说明。',
     `标识：${plugin.id}\n\n版本：${plugin.version}\n\n来源：${({global:'用户级全局安装或链接',workspace:'工作区安装或链接（兼容旧版）',preset:'发行包内置 / 项目预置'})[plugin.scope]??(plugin.removable?'工作区安装或链接':'发行包内置 / 项目预置')}${plugin.source?`\n\n代码位置：${plugin.source}`:''}\n\n状态：${pluginStatus(plugin)}`,
     ...(plugin.configurationError?[`配置状态：${plugin.configurationError}\n\n在当前工作区设置插件配置后启用。`]:[]),
+    ...(plugin.loadError?[`不可用原因：${plugin.loadError.message}\n\n修复上述插件来源后重启，或从插件管理移除此插件。`]:[]),
     ...(plugin.runtime?.missing?.length?[`缺少服务：${plugin.runtime.missing.join(', ')}`]:[]),
     `更新方式：${!plugin.runtime?.updatePolicy?'无运行时服务':plugin.runtime.updatePolicy==='automatic'?'可自动短暂停止并重启':'需要本次维护确认'}\n\n插件权限：${privilege(plugin,plugin)}`,
     `声明平台：${plugin.platforms?.join(', ')??'作者未声明'}\n\n声明架构：${plugin.architectures?.join(', ')??'作者未声明'}`,

package/node_modules/@mytools/fst-cli/src/terminal/report-presentation.js

@@ -0,0 +1,38 @@
+import {inspectReport} from '@mytools/sdk/reports';
+import {cleanText as clean} from './theme.js';
+import {isDeepStrictEqual} from 'node:util';
+
+const levels={info:'提示',warning:'警告',error:'错误'};
+function conclusions(value){
+  return [value.summary&&`摘要：${value.summary}`,...(value.alerts??[]).map(alert=>`${levels[alert.level]}：${alert.message}`),
+    ...(value.recommendations?.length?['建议：',...value.recommendations.map((text,index)=>`  ${index+1}. ${text}`)]:[])].filter(Boolean);
+}
+function dataSchema(section){
+  const properties=Object.fromEntries(Object.entries(section.titles??{}).map(([key,title])=>[key,{title}]));
+  return {'x-fst-table':section.columns,properties,items:{properties},additionalProperties:{properties}};
+}
+
+// 整个输出或 report 字段均可承载报告，不猜测其他同名业务字段的含义。
+export function outputReport(value){
+  if(value?.kind==='fst-report')return value;
+  if(value?.report?.kind==='fst-report')return value.report;
+}
+
+export function forwardedReport(output,finalOutput){
+  const report=outputReport(output);
+  return report&&isDeepStrictEqual(report,outputReport(finalOutput))?report:undefined;
+}
+
+export function renderReport(value,{indent='',render,truncated=false}){
+  if(truncated&&value?.kind==='fst-report')return clean(`${indent}报告内容为摘要，完整结果请在 /logs 中按 p 分页阅读。\n${render(value,indent,undefined,{raw:true})}`);
+  const result=inspectReport(value);
+  if(result.status==='none')return;
+  if(result.status!=='valid')return clean(`${indent}${result.message}\n${render(value,indent,undefined,{raw:true})}`);
+  const inset=(text,padding)=>String(text).split('\n').map(line=>' '.repeat(padding)+line).join('\n');
+  const lines=[`报告：${value.title}`,...conclusions(value).map(text=>inset(text,2))];
+  for(const section of value.sections??[]){
+    lines.push('',inset(`── ${section.title} ──`,2),...conclusions(section).map(text=>inset(text,4)));
+    if(Object.hasOwn(section,'data'))lines.push(inset(render(section.data,'',dataSchema(section),{inset:4}),4));
+  }
+  return clean(lines.join('\n')).split('\n').map(line=>indent+line).join('\n');
+}

package/node_modules/@mytools/fst-cli/src/terminal/result-table.js

@@ -0,0 +1,66 @@
+import {visibleWidth} from '@mariozechner/pi-tui';
+import {cleanText as clean} from './theme.js';
+
+const heading=value=>clean(String(value).replace(/[\r\n\t]+/g,' '));
+const record=value=>value!==null&&typeof value==='object'&&!Array.isArray(value);
+const scalar=value=>value===null||['string','number','boolean'].includes(typeof value);
+const empty=value=>value==null||value===''||typeof value==='object'&&Object.keys(value).length===0;
+const text=value=>value===undefined?'未提供':value===null?'空值':value===''?'空字符串':typeof value==='boolean'?(value?'是':'否'):clean(value);
+const sameKeys=(a,b)=>a.length===b.length&&a.every(key=>b.includes(key));
+
+// 表格只选择阅读列；完整的长值、复杂值和其余字段在表后按行号展开。
+export function resultTable(value,{schema,width,indent,label,render}){
+  const available=width-visibleWidth(indent);
+  if(!Number.isFinite(available)||available<40)return;
+  const list=Array.isArray(value),entries=list?value.map((item,index)=>[String(index+1),item]):Object.entries(value);
+  if(entries.length<2||entries.some(([,item])=>!record(item)))return;
+  const firstKeys=Object.keys(entries[0][1]),declared=schema?.['x-fst-table'];
+  const explicit=Array.isArray(declared)&&declared.length>0&&declared.every(key=>typeof key==='string')&&new Set(declared).size===declared.length;
+  if(!explicit&&!entries.every(([,item])=>sameKeys(firstKeys,Object.keys(item))))return;
+  const rowSchema=list?(Array.isArray(schema?.items)?undefined:schema?.items):schema?.additionalProperties;
+  const candidates=(explicit?declared:firstKeys).filter(key=>entries.every(([,item])=>item[key]===undefined||scalar(item[key]))&&entries.some(([,item])=>item[key]!==undefined&&(explicit||item[key]!==null&&item[key]!=='')));
+  if(candidates.length<(explicit?1:2))return;
+  const duplicate=!explicit&&!list?candidates.find(name=>entries.every(([key,item])=>item[name]===key)):undefined;
+  const common=!explicit?candidates.filter(key=>key!==duplicate&&entries.every(([,item])=>item[key]===entries[0][1][key])&&visibleWidth(text(entries[0][1][key]))<=24&&!/[\r\n\t]/.test(text(entries[0][1][key]))):[];
+  const ordered=candidates.filter(key=>key!==duplicate&&!common.includes(key));
+  if(!explicit)ordered.sort((a,b)=>Number(entries.some(([,item])=>/[\r\n\t]/.test(text(item[a]))||visibleWidth(text(item[a]))>24))-Number(entries.some(([,item])=>/[\r\n\t]/.test(text(item[b]))||visibleWidth(text(item[b]))>24)));
+  // 条目键也可能很长，序号始终可定位；完整键在表后的对应条目显示。
+  const identity={key:null,title:list?'序号':duplicate?heading(label(duplicate,rowSchema?.properties?.[duplicate])):'条目',values:entries.map(([key])=>list?key:clean(key)),width:0};
+  const columns=[identity,...ordered.map(key=>({key,title:heading(label(key,rowSchema?.properties?.[key])),values:entries.map(([,item])=>text(item[key]))}))];
+  for(const column of columns)column.width=column.values.reduce((size,value)=>Math.max(size,/[\r\n\t]/.test(value)||visibleWidth(value)>24?Math.max(6,Math.min(24,visibleWidth(value))):visibleWidth(value)),visibleWidth(column.title));
+  const selected=[];let used=1;
+  for(const column of columns){
+    if(used+column.width+3>available||selected.length>=7){if(column===identity)return;continue;}
+    selected.push(column);used+=column.width+3;
+  }
+  if(selected.length<2&&!common.length)return;
+  let folded=false;
+  const detailRows=[],border=(left,middle,right)=>indent+left+selected.map(column=>'─'.repeat(column.width+2)).join(middle)+right;
+  const line=values=>indent+'│'+values.map((value,index)=>' '+value+' '.repeat(selected[index].width-visibleWidth(value)+1)).join('│')+'│';
+  const lines=[border('┌','┬','┐'),line(selected.map(column=>column.title)),border('├','┼','┤')];
+  entries.forEach(([key,item],index)=>{
+    const details=Object.create(null);let longKey=false;
+    const values=selected.map(column=>{
+      const value=column.values[index];
+      if(/[\r\n\t]/.test(value)||visibleWidth(value)>column.width){
+        if(column.key===null)longKey=true;else details[column.key]=item[column.key];
+        return '见下文';
+      }
+      return value;
+    });
+    for(const [name,value] of Object.entries(item))if(name!==duplicate&&!common.includes(name)&&!selected.some(column=>column.key===name)){
+      if(empty(value))folded=true;else details[name]=value;
+    }
+    lines.push(line(values));
+    if(longKey||Object.keys(details).length){
+      const identityText=list?`[${index+1}]`:`[${index+1}] ${clean(key)}`;
+      const body=render(details,indent+'  ',rowSchema);
+      detailRows.push(`${indent}${identityText} · 补充字段${longKey?'（完整条目键）':''}${body.includes('\n')?'\n'+body:'：'+body.trimStart()}`);
+    }
+  });
+  lines.push(border('└','┴','┘'));
+  if(common.length)lines.push(`${indent}共有字段：${common.map(key=>`${label(key,rowSchema?.properties?.[key])}：${text(entries[0][1][key])}`).join(' · ')}`);
+  if(folded)lines.push(`${indent}空字段已折叠；/logs → j 查看原始数据。`);
+  if(detailRows.length)lines.push(`${indent}补充字段（对应表格行，保留全文）：`,...detailRows);
+  return lines.join('\n');
+}