@yanglaofish/fishtools 0.5.0 → 0.5.1

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

@@ -1,12 +1,21 @@
 import {readableValue,readableError,readableTimeline} from './run-presentation.js';
 import {runStatuses} from './run-viewer.js';
+import {createStepSummaries} from '@mytools/fst-logs/steps';
+import {previewRun} from '@mytools/fst-logs/preview';
+
+const feedRecord=(record,maxBytes)=>{
+  const {stepSummaries,stepSummaryBytes,stepsTruncated,...state}=record;
+  return previewRun({...state,events:[...(state.events??[])]},{maxValueBytes:Math.min(maxBytes,65536)});
+};
 
 // 主面板按事件到达顺序追加；运行快照另存，配置菜单不会清掉执行记录。
 export class RunFeed{
   constructor(refresh,{maxEvents=1000,maxBytes=1048576,maxRuns=50}={}){Object.assign(this,{refresh,maxEvents,maxBytes,maxRuns});this.runs=new Map();this.entries=[];this.subscriptions=new Map();this.expanded=false;this.dropped=0;}
   track({app,runId,title,input}){
     if(this.runs.has(runId))return;
-    const record=app.getRun(runId),item={app,record,title,input,count:0,ended:false,steps:new Map(),catalog:new Map((app.catalog?.()??[]).map(action=>[action.id,action]))};
+    const raw=app.getRun(runId),record=feedRecord(raw,this.maxBytes),bounded=previewRun({input},{maxValueBytes:Math.min(this.maxBytes,65536)});
+    const item={app,record,title,input:bounded.input,inputTruncated:bounded.inputTruncated,count:0,ended:false,steps:createStepSummaries({maxEvents:this.maxEvents,maxMemoryBytes:this.maxBytes}),catalog:new Map((app.catalog?.()??[]).map(action=>[action.id,action]))};
+    for(const summary of raw.stepSummaries??[])item.steps.append(summary);
     this.runs.set(runId,item);
     this.entries.push({type:'start',item});
     if(!this.subscriptions.has(app))this.subscriptions.set(app,app.subscribe(event=>{
@@ -30,12 +39,13 @@ export class RunFeed{
     if(event?.type&&!['run.succeeded','run.failed','run.cancelled','run.stopped'].includes(event.type)){item.record.events.push(event);events=[event];item.count++;}
     else{
       const record=item.app.getRun(item.record.id);if(!record)return;
-      item.record={...record,events:[...(record.events??[])]};
+      item.record=feedRecord(record,this.maxBytes);
+      for(const summary of record.stepSummaries??[])item.steps.append(summary);
       events=record.events.filter((e,index)=>e.seq!==undefined?e.seq>item.count:index>=item.count);
       item.count=record.eventCount??record.events.length;
     }
     const {record}=item;
-    for(const event of events)if(event.type.startsWith('step.'))item.steps.set(event.callPath,{...item.steps.get(event.callPath),...event});
+    for(const event of events)item.steps.append(event);
     if(events.length){
       const last=this.entries.at(-1);
       if(last?.type==='events'&&last.item===item)last.events.push(...events);
@@ -59,7 +69,6 @@ export class RunFeed{
     this.entries=this.entries.filter(entry=>!entry.events||entry.events.length);
     for(const item of this.runs.values()){
       item.record.events=this.entries.filter(e=>e.item===item&&e.events).flatMap(e=>e.events);
-      while(item.steps.size>this.maxEvents)item.steps.delete(item.steps.keys().next().value);
     }
     const ended=[...this.runs.values()].filter(item=>item.ended);
     for(const item of ended.slice(0,Math.max(0,ended.length-this.maxRuns))){this.runs.delete(item.record.id);this.entries=this.entries.filter(e=>e.item!==item);this.dropped++;}
@@ -75,10 +84,14 @@ export class RunFeed{
     for(const event of entry.events){
       const key=`${item.record.id}\0${event.callPath}`;
       if(event.type.startsWith('step.')&&!seen.has(key)){
-        seen.add(key);const latest=item.steps.get(event.callPath),action=item.catalog.get(latest.action);
-        const status=latest.type.slice(5),symbols={started:'●',succeeded:'✓',failed:'✗',cancelled:'×',skipped:'–',stopped:'■'};
-        const name=action?.title??latest.action??latest.stepId??latest.callPath;
-        rows.push(`${symbols[status]??'·'} ${name} · ${status==='started'?'执行中':runStatuses[status]??status}${latest.durationMs!==undefined?' · '+latest.durationMs+' ms':''}${action?.plugin?' · '+action.plugin:''} · ${latest.callPath}`);
+        seen.add(key);const latest=item.steps.get(event.callPath);
+        if(!latest)rows.push(`· ${event.action??event.stepId??event.callPath} · 摘要已省略 · ${event.callPath}`);
+        else{
+          const action=item.catalog.get(latest.action);
+          const status=latest.type.slice(5),symbols={started:'●',succeeded:'✓',failed:'✗',cancelled:'×',skipped:'–',stopped:'■'};
+          const name=action?.title??latest.action??latest.stepId??latest.callPath;
+          rows.push(`${symbols[status]??'·'} ${name} · ${status==='started'?'执行中':runStatuses[status]??status}${latest.durationMs!==undefined?' · '+latest.durationMs+' ms':''}${action?.plugin?' · '+action.plugin:''} · ${latest.callPath}`);
+        }
       }
       if(event.type==='log'&&event.audience==='user')rows.push(`[${event.callPath??item.record.workflowId}] ${event.message??''}${event.data!==undefined?'\n'+readableValue(event.data):''}`);
       if(event.type==='step.failed'&&![...item.steps.values()].some(step=>step.type==='step.failed'&&step.callPath?.startsWith(event.callPath+'/')))rows.push(`✗ ${event.callPath}\n${readableError(event.error??{message:event.message})}`);
@@ -86,18 +99,20 @@ export class RunFeed{
     }
     return rows.length?`${item.title??item.record.workflowId} · ${item.record.id.slice(0,8)}\n${rows.join('\n')}`:'';
   }
-  text(){const seen=new Set();return (this.dropped?'主面板仅保留近期摘要；完整日志可在 /logs 中按 p 分页阅读。\n\n':'')+this.entries.map(entry=>{
+  text(){const seen=new Set();return (this.dropped?'主面板仅保留近期摘要；超出预算的事件和步骤摘要已省略。完整日志可在 /logs 中按 p 分页阅读。\n\n':'')+this.entries.map(entry=>{
     if(entry.type==='message')return entry.text;
     const {record,title,input}=entry.item,label=`${title??record.workflowId} · ${record.id.slice(0,8)}`;
     if(entry.type==='start')return [
       `› ${record.workflowId.startsWith('/')?record.workflowId:'/run '+record.workflowId} · ${label}`,
       `状态：${runStatuses[record.status]??record.status}`,
       this.expanded&&input&&Object.keys(input).length?'输入\n'+readableValue(input):'',
+      this.expanded&&entry.item.inputTruncated?'输入较大，主面板仅显示摘要。':'',
     ].filter(Boolean).join('\n');
     if(entry.type==='events')return this.expanded?`${label}\n${readableTimeline(entry.events,{values:true})}`:this.compactEvents(entry,seen);
     return [`结果 · ${label} · ${runStatuses[record.status]??record.status}`,
       ...(record.warnings??[]).map(warning=>`警告：${warning.message}`),
       this.expanded&&record.output!==undefined?readableValue(record.output):'',record.error&&(this.expanded||![...entry.item.steps.values()].some(step=>step.type==='step.failed'))?readableError(record.error,{details:this.expanded}):'',record.reason??'',
+      this.expanded&&record.outputTruncated?'结果较大，主面板仅显示摘要；完整结果请在 /logs 中按 p 分页阅读。':'',
     ].filter(Boolean).join('\n');
   }).filter(Boolean).join('\n\n');}
   close(){if(this.refreshTimer)clearTimeout(this.refreshTimer);this.refreshTimer=null;for(const unsubscribe of this.subscriptions.values())unsubscribe();this.subscriptions.clear();}

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

@@ -13,6 +13,8 @@
 | --- | --- |
 | `@mytools/fst-logs` | `./src/run-logs.js` |
 | `@mytools/fst-logs/markdown` | `./src/markdown-log.js` |
+| `@mytools/fst-logs/steps` | `./src/step-summaries.js` |
+| `@mytools/fst-logs/preview` | `./src/run-preview.js` |
 | `@mytools/fst-logs/package.json` | `./package.json` |
 
 仅依赖 exports 声明的入口，禁止消费者跨包读取 src/bin 私有文件。入口路径由本模块维护，修改协议时同步消费方回归。
@@ -35,6 +37,15 @@
 
 快照与历史元数据另有 `stepSummaries`、`stepSummaryBytes`、`stepsTruncated`。步骤摘要按 callPath（缺少时按 stepId）保留最新状态，仅包含类型、定位、动作、时间、序号、耗时及有界原因/错误，不缓存 input/output。步骤摘要使用独立的 maxEvents/maxMemoryBytes 预算，因此两份缓存合计最多为两倍 maxMemoryBytes；单条步骤摘要仍受 maxEventBytes 限制。普通日志淘汰不影响步骤状态；步骤本身超预算淘汰时 stepsTruncated 为 true，展示端应把无法确认的步骤显示为未知状态。
 
+`createStepSummaries(policy)` 从 `/steps` 入口提供同一套摘要缓存，日志写入器与 TUI 共用。
+`append(event)` 更新状态并刷新淘汰顺序；`get(callPath)`、`values()` 和 `snapshot()` 返回副本。
+`snapshot()` 包含上述三个步骤摘要字段，`size` 为保留条数。
+
+`previewRun(record,{maxValueBytes=65536})` 从 `/preview` 入口提供展示与历史元数据共用的结果投影。
+input/output、error、reason 等字段转为有界 JSON 预览，过大时标记 `<字段>Truncated:true`；业务数据对象不变。
+定位字段与 events/stepSummaries 保留，后两者由各自缓存预算负责；展示端应裁去不使用的缓存副本。
+maxValueBytes 至少为 2，连预览本身也容不下时省略字段值并保留截断标记。
+
 队列预算在追加时检查。未等待 append 的插件同样受到预算约束；超限返回 `LOG_QUEUE_LIMIT` 拒绝，并使 finish 失败。拒绝已安装内部处理，调用方仍可 await 观察失败，不会产生未处理拒绝。`LOG_DISK_LIMIT` 表示可选磁盘预算不足，拒绝完整追加而不静默截断。磁盘预算与队列预算都计算 JSONL 和 Markdown。建议插件等待 append，以便磁盘写入形成背压。
 
 `read`/`list` 仅读取受限的 result.json 元数据，运行中的 read 回退到归属元数据；不加载 JSONL 或 Markdown 正文。巨大旧 result.json 超过读取预算时，read 明确返回 `LOG_METADATA_LIMIT`，list 跳过该记录。旧版本缺少归属信息时仅在 `allowLegacy:true` 下可读。

package/node_modules/@mytools/fst-logs/package.json

@@ -6,6 +6,8 @@
   "main": "src/run-logs.js",
   "exports": {
     ".": "./src/run-logs.js",
+    "./steps": "./src/step-summaries.js",
+    "./preview": "./src/run-preview.js",
     "./markdown": "./src/markdown-log.js",
     "./package.json": "./package.json"
   },

package/node_modules/@mytools/fst-logs/src/run-logs.js

@@ -2,7 +2,9 @@ import path from 'node:path';
 import {readdir,readFile,lstat,unlink,rmdir,mkdir,writeFile,appendFile,open} from 'node:fs/promises';
 import {FlowError} from '@mytools/sdk';
 import {markdownHeader,markdownEvent,markdownResult} from './markdown-log.js';
-import {logPolicy,jsonSize,preview,eventPreview} from './log-bounds.js';
+import {logPolicy,jsonSize,eventPreview} from './log-bounds.js';
+import {createStepSummaries} from './step-summaries.js';
+import {previewRun} from './run-preview.js';
 
 const validId=id=>typeof id==='string'&&/^[a-f0-9-]{36}$/.test(id);
 const logFiles=['run.md','events.jsonl','result.json','run.meta.json'];
@@ -68,15 +70,15 @@ export function createRunLogs(directory,{projectDir,allowLegacy=false,...options
   return {
     list,read,owner,policy:Object.freeze({...policy}),
     async start(initial,{onEvent=()=>{}}={}){
-      const directory=location(initial.id),events=[],sizes=[],steps=new Map();
+      const directory=location(initial.id),events=[],sizes=[],steps=createStepSummaries(policy);
       await mkdir(root,{recursive:true});
       const rootStat=await lstat(root);if(!rootStat.isDirectory()||rootStat.isSymbolicLink())throw new FlowError('日志根目录无效');
       await mkdir(directory,{recursive:true});
       await safeDirectory(initial.id);
       for(const name of logFiles){try{await lstat(path.join(directory,name));throw new FlowError('运行日志已存在，拒绝覆盖');}catch(error){if(error.code!=='ENOENT')throw error;}}
       const markdownFile=path.join(directory,'run.md');
-      let writes=Promise.resolve(),failure=null,pendingBytes=0,diskBytes=0,resultBytes=0,eventCount=0,eventBytes=2,eventsTruncated=false,stepSummaryBytes=2,stepsTruncated=false,finished=false;
-      const snapshot=state=>structuredClone({...initial,...state,logOwner:owner,events,eventCount,eventBytes,eventsTruncated,stepSummaries:[...steps.values()].map(entry=>entry.event),stepSummaryBytes,stepsTruncated});
+      let writes=Promise.resolve(),failure=null,pendingBytes=0,diskBytes=0,resultBytes=0,eventCount=0,eventBytes=2,eventsTruncated=false,finished=false;
+      const snapshot=state=>structuredClone({...initial,...state,logOwner:owner,events,eventCount,eventBytes,eventsTruncated,...steps.snapshot()});
       const reject=error=>{failure??=error;const promise=Promise.reject(failure);promise.catch(()=>{});return promise;};
       function diskCheck(extra){if(policy.maxDiskBytes!==null&&diskBytes+extra>policy.maxDiskBytes)throw new FlowError('日志磁盘预算已满',{code:'LOG_DISK_LIMIT',details:{maxDiskBytes:policy.maxDiskBytes}});}
       const queue=(bytes,operation)=>{
@@ -95,28 +97,11 @@ export function createRunLogs(directory,{projectDir,allowLegacy=false,...options
         while(events.length>policy.maxEvents||eventBytes>policy.maxMemoryBytes){
           const removed=sizes.shift();events.shift();eventBytes-=removed+(events.length?1:0);eventsTruncated=true;
         }
-        if(typeof full.type==='string'&&full.type.startsWith('step.')&&(full.callPath!==undefined||full.stepId!==undefined)){
-          const lightweight={};
-          for(const key of ['type','callPath','stepId','action','time','seq','durationMs','reason','error'])if(full[key]!==undefined)lightweight[key]=full[key];
-          const summary=eventPreview(lightweight,policy.maxEventBytes),key=summary.callPath??summary.stepId;
-          if(key!==undefined&&summary.callPath===full.callPath&&summary.stepId===full.stepId){
-            const previous=steps.get(key);
-            if(previous){steps.delete(key);stepSummaryBytes-=previous.bytes+(steps.size?1:0);}
-            const bytes=Buffer.byteLength(JSON.stringify(summary));steps.set(key,{event:summary,bytes});stepSummaryBytes+=bytes+(steps.size>1?1:0);
-            while(steps.size>policy.maxEvents||stepSummaryBytes>policy.maxMemoryBytes){
-              const oldest=steps.keys().next().value,removed=steps.get(oldest);steps.delete(oldest);stepSummaryBytes-=removed.bytes+(steps.size?1:0);stepsTruncated=true;
-            }
-          }else stepsTruncated=true;
-        }
+        steps.append(full);
         onEvent(structuredClone(event));
       }
       function metadata(state){
-        const run={...initial,...state,logOwner:owner,events,eventCount,eventBytes,eventsTruncated,stepSummaries:[...steps.values()].map(entry=>entry.event),stepSummaryBytes,stepsTruncated};
-        for(const key of Object.keys(run)){
-          if(['events','stepSummaries','id','workflowId','logOwner','status','startedAt','finishedAt'].includes(key))continue;
-          if(run[key]===undefined)continue;
-          const bounded=preview(run[key],policy.maxEventBytes);run[key]=bounded.value;if(bounded.truncated)run[`${key}Truncated`]=true;
-        }
+        const run=previewRun({...initial,...state,logOwner:owner,events,eventCount,eventBytes,eventsTruncated,...steps.snapshot()},{maxValueBytes:policy.maxEventBytes});
         const text=JSON.stringify(run);
         if(Buffer.byteLength(text)>metadataLimit)throw new FlowError('运行记录元数据超过写入预算',{code:'LOG_METADATA_LIMIT'});
         return text;

package/node_modules/@mytools/fst-logs/src/run-preview.js

@@ -0,0 +1,18 @@
+import {FlowError} from '@mytools/sdk';
+import {defaults,preview,jsonSize} from './log-bounds.js';
+
+const retainedFields=new Set(['events','stepSummaries','id','workflowId','logOwner','status','startedAt','finishedAt']);
+
+// 路由信息与已有独立预算的缓存保留；业务正文和诊断字段只投影有界预览。
+export function previewRun(record,{maxValueBytes=defaults.maxEventBytes}={}){
+  if(!Number.isSafeInteger(maxValueBytes)||maxValueBytes<2)throw new FlowError('结果预览 maxValueBytes 必须为至少 2 的整数字节数');
+  const run={...record};
+  for(const key of Object.keys(run)){
+    if(retainedFields.has(key)||run[key]===undefined)continue;
+    const bounded=preview(run[key],maxValueBytes);
+    if(jsonSize(bounded.value,maxValueBytes)>maxValueBytes)delete run[key];
+    else run[key]=bounded.value;
+    if(bounded.truncated)run[`${key}Truncated`]=true;
+  }
+  return run;
+}

package/node_modules/@mytools/fst-logs/src/step-summaries.js

@@ -0,0 +1,28 @@
+import {logPolicy,eventPreview} from './log-bounds.js';
+
+// 日志写入器与展示端共用轻量摘要，避免各端重新缓存业务 input/output。
+export function createStepSummaries(options={}){
+  const policy=logPolicy(options),steps=new Map();
+  let bytes=2,truncated=false;
+  return {
+    append(full){
+      if(typeof full.type!=='string'||!full.type.startsWith('step.')||(full.callPath===undefined&&full.stepId===undefined))return;
+      const lightweight={};
+      for(const key of ['type','callPath','stepId','action','time','seq','durationMs','reason','error'])if(full[key]!==undefined)lightweight[key]=full[key];
+      const summary=eventPreview(lightweight,policy.maxEventBytes),key=summary.callPath??summary.stepId;
+      if(key===undefined||summary.callPath!==full.callPath||summary.stepId!==full.stepId){truncated=true;return;}
+      const previous=steps.get(key);
+      if(previous){steps.delete(key);bytes-=previous.bytes+(steps.size?1:0);}
+      const size=Buffer.byteLength(JSON.stringify(summary));
+      steps.set(key,{event:summary,bytes:size});bytes+=size+(steps.size>1?1:0);
+      while(steps.size>policy.maxEvents||bytes>policy.maxMemoryBytes){
+        const oldest=steps.keys().next().value,removed=steps.get(oldest);
+        steps.delete(oldest);bytes-=removed.bytes+(steps.size?1:0);truncated=true;
+      }
+    },
+    get size(){return steps.size;},
+    get(key){return structuredClone(steps.get(key)?.event);},
+    values(){return [...steps.values()].map(entry=>structuredClone(entry.event));},
+    snapshot(){return {stepSummaries:this.values(),stepSummaryBytes:bytes,stepsTruncated:truncated};},
+  };
+}

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

@@ -16,6 +16,7 @@
 | `@mytools/fst-platform/bundle` | `./src/bundle.js` |
 | `@mytools/fst-platform/json` | `./src/json.js` |
 | `@mytools/fst-platform/npm` | `./src/npm.js` |
+| `@mytools/fst-platform/network` | `./src/network.js` |
 | `@mytools/fst-platform/fs` | `./src/file-probe.js` |
 | `@mytools/fst-platform/package.json` | `./package.json` |
 
@@ -31,6 +32,11 @@
 node --test tests/modules.test.js tests/process.test.js tests/environments.test.js
 ```
 
+## 子进程环境
+
+`runProcess(file,args,{env,extendEnv=true})` 默认把 `env` 覆盖到宿主环境上。
+当调用方已按动作代理规则构造完整环境时，传 `extendEnv:false`，防止已移除的代理变量被重新继承。
+
 ## 隔离文件探测
 
 `createFileProbe({timeout=2000,maxConcurrent=2,maxPending=16,allowRemote=false})` 创建只读探测器。

package/node_modules/@mytools/fst-platform/src/process.js

@@ -7,7 +7,7 @@ import path from 'node:path';
 const outputText=bytes=>bytes??new Uint8Array();
 const stripFinalNewline=text=>text.endsWith('\r\n')?text.slice(0,-2):text.endsWith('\n')?text.slice(0,-1):text;
 
-export async function runProcess(file,args=[],{cwd,env,signal,timeout=30000,maxBuffer=4*1024*1024,encoding='utf8',onOutput,outputMode='buffer',summaryBytes=65536}={}) {
+export async function runProcess(file,args=[],{cwd,env,extendEnv=true,signal,timeout=30000,maxBuffer=4*1024*1024,encoding='utf8',onOutput,outputMode='buffer',summaryBytes=65536}={}) {
   if(!['buffer','stream'].includes(outputMode))throw new TypeError('outputMode 必须为 buffer 或 stream');
   const streaming=outputMode==='stream';
   if(streaming&&typeof onOutput!=='function')throw new TypeError('stream 模式必须提供 onOutput 消费输出');
@@ -34,7 +34,7 @@ export async function runProcess(file,args=[],{cwd,env,signal,timeout=30000,maxB
   }
   catch(cause){throw new FlowError(`未找到程序：${file}`,{code:'ENOENT',details:{executable:file},cause});}
   // Execa 收集原始字节；文本只在这里按同一编码解码，避免返回值被默认 UTF-8 解码。
-  const child=execa(executable,args,{cwd,env,reject:false,windowsHide:true,maxBuffer,buffer:!streaming,timeout:0,shell:false,encoding:'buffer',stripFinalNewline:false});
+  const child=execa(executable,args,{cwd,env,extendEnv,reject:false,windowsHide:true,maxBuffer,buffer:!streaming,timeout:0,shell:false,encoding:'buffer',stripFinalNewline:false});
   let reason,killing,outputError,outputFailed=false,outputWrites=Promise.resolve();
   let markStopped;const stopped=new Promise(resolve=>{markStopped=resolve;});
   const outputBytes={stdout:0,stderr:0},tails={stdout:'',stderr:''};let outputTruncated=false;

package/node_modules/@mytools/fst-plugin/src/host.js

@@ -57,7 +57,8 @@ export async function createHost({ plugins = [], config = {}, services = {}, pro
     const http=createHttpClient(resolved,{signal:context.signal});
     if(typeof bound.runProcess==='function'){
       const execute=bound.runProcess;
-      bound.runProcess=(file,args,options={})=>execute(file,args,{...options,env:buildProcessEnv(resolved,{overrides:options.env})});
+      // 已构造完整环境；禁止进程层再次合并宿主代理，恢复被策略移除的变量。
+      bound.runProcess=(file,args,options={})=>execute(file,args,{...options,env:buildProcessEnv(resolved,{overrides:options.env}),extendEnv:false});
     }
     bound.http={fetch:(input,options)=>http.fetch(input,options)};
     return {capabilities:{...bound,projectDir,stateDir,environments},close:()=>http.close()};
@@ -100,7 +101,7 @@ export async function createHost({ plugins = [], config = {}, services = {}, pro
   const runtime=createRuntime(ctx,definitions,{enabled:runtimeEnabled});
   let unusable=false;
   const assertReadable=()=>{
-    if(unusable)throw new FlowError('插件更新和恢复均失败，请重启应用',{code:'PLUGIN_RUNTIME_UNUSABLE'});
+    if(unusable)throw new FlowError('插件运行状态无法确认，请重启应用',{code:'PLUGIN_RUNTIME_UNUSABLE'});
   };
   const assertHealthy=()=>{runtime.assertOpen();assertReadable();};
   function registerPlugin(plugin,settings){
@@ -151,7 +152,8 @@ export async function createHost({ plugins = [], config = {}, services = {}, pro
       const oldDefinitions=new Map([...definitions].filter(([id])=>selected.has(id)));
       const oldSettings=new Map([...settingsById].filter(([id])=>selected.has(id)));
       const switchDefinitions=async(targets,settings)=>{
-        await runtime.remove(selected);
+        try{await runtime.remove(selected);}
+        catch(error){unusable=true;throw error;}
         for(const id of selected){definitions.delete(id);settingsById.delete(id);}
         for(const [id,plugin] of targets)if(selected.has(id)){
           definitions.set(id,plugin);
@@ -165,8 +167,9 @@ export async function createHost({ plugins = [], config = {}, services = {}, pro
       for(const [id,plugin] of next)if(selected.has(id))nextSettings.set(id,validate(plugin.config,nextConfig[id]??{},`${id} 配置`));
       try{await switchDefinitions(next,nextSettings);}
       catch(error){
+        if(unusable)throw error;
         try{
-          runtime.clearErrors();
+          runtime.clearActivationErrors();
           await switchDefinitions(oldDefinitions,oldSettings);
         }catch(recovery){unusable=true;throw new AggregateError([error,recovery],`插件更新失败且恢复失败：${error.message}；${recovery.message}`);}
         throw error;

package/node_modules/@mytools/fst-plugin/src/runtime.js

@@ -36,11 +36,11 @@ export function createRuntime(ctx,definitions,{enabled=true}={}){
   const reservedContext=new ctx.constructor();
   let graph=validateRuntimes(definitions,reservedContext);
   const forks=new Map(),scopes=new Map(),errors=[],pending=new Set();let closing;
-  const record=(id,error)=>errors.push({plugin:id,message:error?.message??String(error)});
+  const record=(id,error,phase='activation')=>errors.push({plugin:id,phase,message:error?.message??String(error)});
   const track=(id,callback)=>{
     // 同步撤销注册，只有异步尾部进入等待集合，避免服务重激活时旧清理删掉新注册。
-    let result;try{result=callback();}catch(error){record(id,error);return;}
-    const task=Promise.resolve(result).catch(e=>record(id,e)).finally(()=>pending.delete(task));
+    let result;try{result=callback();}catch(error){record(id,error,'dispose');return;}
+    const task=Promise.resolve(result).catch(e=>record(id,e,'dispose')).finally(()=>pending.delete(task));
     pending.add(task);return task;
   };
   // 3.18.1 的 reset 会调用 dispose，但不等待 Promise；此适配只补齐等待和错误传播。
@@ -72,7 +72,7 @@ export function createRuntime(ctx,definitions,{enabled=true}={}){
             // 初始化可能仍在取得资源；先等其结束，再执行本次激活登记的清理。
             while(activation.tasks.size)await Promise.allSettled([...activation.tasks]);
             for(const dispose of activation.disposers.splice(0)){
-              try{await dispose();}catch(error){record(plugin.id,error);}
+              try{await dispose();}catch(error){record(plugin.id,error,'dispose');}
             }
           })();
         });
@@ -100,7 +100,10 @@ export function createRuntime(ctx,definitions,{enabled=true}={}){
       await ctx.start();await runtime.ready();
     },
     reindex(){graph=validateRuntimes(definitions,reservedContext);},
-    clearErrors(){errors.length=0;},
+    clearActivationErrors(){
+      // 启动失败可以在清理成功后恢复；清理失败必须保留，不能假定资源已释放。
+      for(let index=errors.length-1;index>=0;index--)if(errors[index].phase!=='dispose')errors.splice(index,1);
+    },
     async remove(ids){
       // 先撤销消费者再撤销提供者；旧作用域清理结束后才能注册新作用域。
       const selected=new Set(ids);