@yanglaofish/fishtools 0.2.0 → 0.3.0

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

@@ -0,0 +1,211 @@
+import { mkdir, appendFile, writeFile, rename, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { EventEmitter } from 'node:events';
+import { createHost } from './host.js';
+import { WorkflowStore } from './workflows.js';
+import { runWorkflow } from './engine.js';
+import { runProcess } from './process.js';
+import { readJson, loadPlugin, installGeneration } from './plugins.js';
+import { FlowError } from '@mytools/sdk';
+import {prepareBundleWorkspace} from './bundle-workspace.js';
+import {validate} from './validation.js';
+import {createResources} from './resources.js';
+import {errorRecord} from './diagnostics.js';
+import {markdownHeader,markdownEvent,markdownResult} from './markdown-log.js';
+import {createRunLogs,validateKeepRuns} from './run-logs.js';
+
+export async function createApplication({projectDir=process.cwd(),workspace,outputDir,plugins,config={},maintenance=false}={}) {
+  projectDir=await prepareBundleWorkspace(path.resolve(projectDir),workspace);
+  const project=await readJson(path.join(projectDir,'flow.project.json'),{plugins:[]});
+  const output=path.resolve(outputDir??process.env.FLOW_OUTPUT_DIR??(project.readOnly?path.join(process.cwd(),'flow-results'):path.join(projectDir,'.flow','runs')));
+  const store=new WorkflowStore(path.join(projectDir,'workflows'));
+  const emitter=new EventEmitter(), runs=new Map();
+  const resources=createResources(),operations=new Set();let closing,launching=0;
+  const runLogs=createRunLogs(output,{projectDir,allowLegacy:output===path.join(projectDir,'.flow','runs')}),writingRuns=new Set();
+  validateKeepRuns(project.logs?.keepRuns??null);
+  let host,state=await readJson(path.join(projectDir,'.flow','plugins.json'),{}),busy=false;
+  const app={
+    projectDir,project,outputDir:output,store,
+    get host(){return host;},
+    get maintenance(){return maintenance;},
+    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,runtime:host.runtimeStatus().find(r=>r.id===p.id),removable:!!state.dependencies?.[p.id]})),
+    listCommands:()=>host.commands(),
+    listWorkflows:()=>store.list(),
+    async saveWorkflow(w){if(project.readOnly)throw new FlowError('此分发包仅用于运行；请在开发项目中编辑');return store.save(w);},
+    async removeWorkflow(id){if(project.readOnly)throw new FlowError('只读项目不能删除工作流');return store.remove(id);},
+    checkWorkflow:id=>store.resolve([id],host),
+    subscribe(fn){emitter.on('event',fn);return ()=>emitter.off('event',fn);},
+    async startRun(id,input={}) {
+      if(busy) throw new FlowError('插件更新中，请稍后运行');
+      const closure=await store.resolve([id],host);
+      const snapshotStore={resolve:async()=>structuredClone(closure),childId:ref=>store.childId(ref)};
+      return app.executeTracked(id,(activeHost,context,event)=>runWorkflow({store:snapshotStore,host:activeHost,id,input,signal:context.signal,onEvent:event,runId:context.runId,context}));
+    },
+    async startCommand(name,input={},context={}){
+      if(busy)throw new FlowError('插件更新中，请稍后调用');
+      return app.executeTracked(`/${name}`,(activeHost,runContext)=>activeHost.invokeCommand(name,input,{...context,...runContext}));
+    },
+    async executeTracked(id,execute){
+      const runId=randomUUID(),dir=path.join(output,runId),controller=new AbortController();
+      await mkdir(dir,{recursive:true});
+      const run={id:runId,workflowId:id,logOwner:runLogs.owner,status:'running',startedAt:new Date().toISOString(),events:[],controller};
+      runs.set(runId,run);
+      writingRuns.add(runId);
+      const markdownFile=path.join(dir,'run.md');
+      let writes=writeFile(markdownFile,markdownHeader(run));
+      const event=e=>{
+        const full={time:new Date().toISOString(),runId,...e};run.events.push(full);
+        emitter.emit('event',full);
+        const {output:ignored,...record}=full;
+        writes=writes.then(async()=>{
+          await appendFile(path.join(dir,'events.jsonl'),JSON.stringify(record)+'\n');
+          await appendFile(markdownFile,markdownEvent(full));
+        });
+        return writes;
+      };
+      const activeHost=host;
+      run.done=(async()=>{
+        try {
+          await event({type:'run.started'});
+          run.output=await execute(activeHost,{outputDir:dir,signal:controller.signal,runId,log:(message,data,meta={})=>event({...meta,type:'log',message,data})},event);
+          run.status='succeeded';await event({type:'run.succeeded'});
+        } catch(error) {
+          if(error?.code==='WORKFLOW_STOPPED'){
+            run.status='stopped';run.reason=error.details?.reason??error.message;
+            await event({type:'run.stopped',reason:run.reason});
+          }else{
+            run.status=error?.code==='EXECUTION_FAILED'?'failed':controller.signal.aborted||['PROMPT_CANCELLED','CANCELLED'].includes(error?.code)?'cancelled':'failed';
+            run.error=errorRecord(error);
+            await event({type:`run.${run.status}`,message:run.error.message,code:run.error.code,plugin:run.error.plugin,action:run.error.action,command:run.error.command,details:run.error.details,error:run.error});
+          }
+        } finally {
+          run.finishedAt=new Date().toISOString();
+          await writes;
+          await appendFile(markdownFile,markdownResult(app.getRun(runId)));
+          await writeFile(path.join(dir,'result.json'),JSON.stringify(snapshotRun(run),null,2));
+          writingRuns.delete(runId);
+          try{await pruneLogs();}catch(error){
+            await event({type:'log',message:`日志自动清理失败：${error.message}`});
+            await writeFile(path.join(dir,'result.json'),JSON.stringify(snapshotRun(run),null,2));
+          }
+        }
+        return snapshotRun(run);
+      })();
+      return run;
+    },
+    getRun(id){const r=runs.get(id);return r?snapshotRun(r):null;},
+    async readRun(id){if(runs.has(id))return app.getRun(id);if(!/^[a-f0-9-]{36}$/.test(id))throw new FlowError('运行 ID 无效');return JSON.parse(await readFile(path.join(output,id,'result.json'),'utf8'));},
+    listRuns:()=>[...runs.keys()].map(id=>{const {events,...r}=app.getRun(id);return r;}),
+    logSettings:()=>({keepRuns:project.logs?.keepRuns??null}),
+    async listRunHistory(){
+      const records=new Map((await runLogs.list()).map(r=>[r.id,r]));
+      for(const id of runs.keys())records.set(id,app.getRun(id));
+      return [...records.values()].sort((a,b)=>Date.parse(b.finishedAt??b.startedAt)-Date.parse(a.finishedAt??a.startedAt)||b.id.localeCompare(a.id)).map(({events,output,...r})=>r);
+    },
+    async readLog(id){
+      const run=runs.get(id);
+      if(run&&writingRuns.has(id))return markdownHeader(run)+run.events.map(markdownEvent).join('');
+      return runLogs.markdown(id);
+    },
+    async configureLogs(keepRuns){
+      validateKeepRuns(keepRuns);if(project.readOnly)throw new FlowError('只读运行包不能保存日志设置');
+      if(busy)throw new FlowError('项目正在更新，请稍后修改日志设置');
+      busy=true;
+      try{
+        const logs={...project.logs,keepRuns},file=path.join(projectDir,'flow.project.json'),temp=`${file}.${randomUUID()}.tmp`;
+        await mkdir(projectDir,{recursive:true});await writeFile(temp,JSON.stringify({...project,logs},null,2));await rename(temp,file);project.logs=logs;
+        await pruneLogs();
+      }finally{busy=false;}
+    },
+    cancelRun(id){const r=runs.get(id);if(r?.status==='running')r.controller.abort();return !!r;},
+    async installPlugin(source){return change({add:source});},
+    async removePlugin(name){if(resources.active(name))throw new FlowError('请先停止此插件提供的 Web');if(!state.dependencies?.[name])throw new FlowError('此插件来自发行配置，不能在此移除');return change({remove:name});},
+    async pack(options){const {packApplication}=await import('@mytools/pack');return packApplication(app,options);},
+    async packPlan(options){const {planApplication}=await import('@mytools/pack');return planApplication(app,options);},
+    async configurePlugin(id,value){
+      if(project.readOnly)throw new FlowError('只读项目不能保存配置');
+      assertMutable();
+      if(resources.active(id))throw new FlowError('请先停止此插件提供的 Web，再修改配置');
+      if(busy||launching||app.listRuns().some(r=>r.status==='running'))throw new FlowError('请等待运行或安装结束');
+      if(!host.definitions.has(id))throw new FlowError(`插件不存在：${id}`);
+      value=validate(host.definitions.get(id).config,value,`${id} 配置`);
+      busy=true;let nextHost;
+      try{
+        const nextConfig={...project.config,[id]:value};
+        nextHost=await createHost({plugins:[...host.definitions.values()].map(p=>({plugin:p,root:p.root})),config:{...nextConfig,...config},services,environmentOverrides:project.environments,runtimeEnabled:!maintenance});
+        const nextProject={...project,config:nextConfig},file=path.join(projectDir,'flow.project.json'),temp=`${file}.${randomUUID()}.tmp`;
+        await writeFile(temp,JSON.stringify(nextProject,null,2));await rename(temp,file);
+        const old=host;host=nextHost;nextHost=null;project.config=nextConfig;await old.close();
+      }finally{try{if(nextHost)await nextHost.close();}finally{busy=false;}}
+    },
+    async setMaintenance(enabled){
+      if(typeof enabled!=='boolean')throw new FlowError('维护模式必须为布尔值');
+      if(enabled===maintenance)return;
+      if(busy||launching||app.listRuns().some(r=>r.status==='running'))throw new FlowError('请等待运行或安装结束');
+      if([...host.definitions.values()].some(p=>p.runtime&&resources.active(p.id)))throw new FlowError('请先停止运行时插件提供的 Web');
+      busy=true;
+      try{
+        const entries=[...host.definitions.values()].map(p=>({plugin:p,root:p.root}));
+        if(enabled){maintenance=true;await host.close();}
+        const next=await createHost({plugins:entries,config:{...project.config,...config},services,environmentOverrides:project.environments,runtimeEnabled:!enabled});
+        const old=host;host=next;maintenance=enabled;if(!enabled)await old.close();
+      }finally{busy=false;}
+    },
+    startWeb(options){
+      if(busy)throw new FlowError('插件更新中，请稍后启动 Web');
+      const owner=[...host.definitions.values()].find(p=>p.services?.web)?.id;
+      return resources.own(()=>host.service('web',options),owner);
+    },
+    close(){
+      closing??=Promise.resolve().then(async()=>{
+        for(const r of runs.values())if(r.status==='running')r.controller.abort();
+        await Promise.allSettled([...operations]);
+        for(const r of runs.values())if(r.status==='running')r.controller.abort();
+        await Promise.allSettled([...runs.values()].map(r=>r.done));
+        const errors=[];
+        try{await resources.close();}catch(error){errors.push(error);}
+        try{await host.close();}catch(error){errors.push(error);}
+        if(errors.length)throw new AggregateError(errors,`应用关闭失败：${errors.map(e=>e.message).join('；')}`);
+      });return closing;
+    },
+  };
+  const initial=plugins??await Promise.all((project.plugins??[]).map(spec=>loadPlugin(spec,project.baseBundle?.root??projectDir)));
+  const services={application:app,runProcess};
+  const build=extra=>createHost({plugins:[...initial,...extra],config:{...project.config,...config},services,environmentOverrides:project.environments,runtimeEnabled:!maintenance});
+  const external=[];
+  for(const name of Object.keys(state.dependencies??{}))external.push(await loadPlugin(name,state.root));
+  host=await build(external);
+  for(const name of ['startRun','startCommand','startWeb','saveWorkflow','removeWorkflow','installPlugin','removePlugin','configurePlugin','configureLogs','setMaintenance','pack']){
+    const original=app[name],isRun=['startRun','startCommand'].includes(name);
+    app[name]=async(...args)=>{
+      if(closing)throw new FlowError('应用已关闭');
+      if(isRun)launching++;
+      const task=Promise.resolve().then(()=>original.apply(app,args));operations.add(task);
+      try{return await task;}finally{operations.delete(task);if(isRun)launching--;}
+    };
+  }
+  function assertMutable(){if(!maintenance&&host.hasRuntime)throw new FlowError('运行时插件已启动，请先进入维护模式再修改插件或配置');}
+  function snapshotRun(run){const {done,controller,...result}=run;return structuredClone(result);}
+  async function pruneLogs(){for(const id of await runLogs.prune(project.logs?.keepRuns??null,writingRuns))runs.delete(id);}
+  async function change(operation){
+    if(project.readOnly)throw new FlowError('运行包不支持安装或移除插件');
+    assertMutable();
+    if(busy || launching || [...runs.values()].some(r=>r.status==='running'))throw new FlowError('请等待当前运行或安装结束');
+    busy=true;let nextHost;
+    try {
+      const next=await installGeneration(projectDir,{...operation,state});
+      for(const p of host.definitions.values())if(resources.active(p.id)){
+        const candidate=[...initial,...next.loaded].find(e=>(e.plugin??e).id===p.id);
+        if(!candidate||candidate.root!==p.root||(candidate.plugin??candidate).version!==p.version)throw new FlowError('请先停止活动 Web，再替换其提供者');
+      }
+      nextHost=await build(next.loaded);
+      const file=path.join(projectDir,'.flow','plugins.json'),temp=`${file}.tmp`;
+      await writeFile(temp,JSON.stringify(next.state,null,2));await rename(temp,file);
+      const old=host;host=nextHost;nextHost=null;state=next.state;await old.close();
+      return app.listPlugins();
+    } finally {try{if(nextHost)await nextHost.close();}finally{busy=false;}}
+  }
+  return app;
+}

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

@@ -0,0 +1,93 @@
+import { randomUUID } from 'node:crypto';
+import { FlowError } from '@mytools/sdk';
+import { bind, validate, emptyObject } from './validation.js';
+import {errorRecord} from './diagnostics.js';
+import {evaluateCondition,childLists} from './control.js';
+
+export async function runWorkflow({store,host,id,input={},signal,onEvent=()=>{},runId=randomUUID(),context={}}) {
+  const closure=await store.resolve([id],host);
+  const snapshot=new Map(closure.workflows.map(w=>[w.id,w]));
+  const emit=event=>onEvent({time:new Date().toISOString(),runId,...event});
+  const failures=new WeakMap();
+  const checkCancelled=currentSignal=>{if(currentSignal?.aborted)throw new FlowError('运行已取消',{code:'CANCELLED'});};
+  const skip=async(step,w,path,message)=>{
+    const callPath=`${path}/${step.id}`;
+    await emit({type:'step.skipped',workflowId:w.id,stepId:step.id,callPath,action:step.action,message});
+    for(const list of childLists(step))for(const child of list)await skip(child,w,callPath,message);
+    if(step.workflow){const child=snapshot.get(store.childId(step.workflow));for(const node of child.steps)await skip(node,child,callPath,message);}
+  };
+  const sequence=async(steps,w,base,path,currentSignal,reportFailure)=>{
+    const state={inputs:base.inputs,steps:{...base.steps}},outputs={};
+    for(let i=0;i<steps.length;i++){
+      try{
+        const result=await executeStep(steps[i],w,state,path,currentSignal,reportFailure);
+        state.steps[steps[i].id]=result;
+        if(Object.hasOwn(result,'output'))outputs[steps[i].id]=result.output;
+      }catch(error){
+        for(const pending of steps.slice(i+1))await skip(pending,w,path,error.code==='WORKFLOW_STOPPED'?'工作流已提前结束':'前序步骤失败或运行已取消');
+        throw error;
+      }
+    }
+    checkCancelled(currentSignal);return {state,outputs};
+  };
+  const parallel=async(group,w,state,path,currentSignal,reportFailure)=>{
+    const controller=new AbortController(),combined=currentSignal?AbortSignal.any([currentSignal,controller.signal]):controller.signal;
+    const results=new Array(group.steps.length);let next=0,firstError;
+    // 叶子先锁定首因，再写事件；父控制节点的异步收尾不能改变失败顺序。
+    const fail=error=>{if(!firstError){firstError=error;reportFailure?.(error);controller.abort(error);}};
+    const worker=async()=>{
+      while(!firstError&&next<group.steps.length){
+        const index=next++,step=group.steps[index];
+        try{results[index]=await executeStep(step,w,{inputs:state.inputs,steps:{...state.steps}},path,combined,fail);}
+        catch(error){fail(error);}
+      }
+    };
+    // 等待所有已启动任务清理，避免 Promise.all 首次拒绝后仍有后台动作执行。
+    await Promise.all(Array.from({length:Math.min(group.concurrency??4,group.steps.length)},worker));
+    if(firstError){for(const step of group.steps.slice(next))await skip(step,w,path,'并行组已停止调度');throw firstError;}
+    return Object.fromEntries(group.steps.flatMap((step,index)=>Object.hasOwn(results[index]??{},'output')?[[step.id,results[index].output]]:[]));
+  };
+  const executeStep=async(step,w,state,parentPath,currentSignal,reportFailure)=>{
+    const callPath=`${parentPath}/${step.id}`,start=Date.now(),base={workflowId:w.id,stepId:step.id,callPath,action:step.action};
+    try{
+      checkCancelled(currentSignal);
+      if(step.when&&!evaluateCondition(step.when,state)){await skip(step,w,parentPath,'执行条件不满足');return {status:'skipped'};}
+      const args=step.action||step.workflow?bind(step.with??{},state):{};
+      await emit({type:'step.started',...base,input:args});
+      let output;
+      if(step.action)output=await host.invoke(step.action,args,{
+        ...context,signal:currentSignal,runId,stepId:step.id,callPath,workflow:w,
+        log:(message,data,meta={})=>emit({type:'log',stream:meta.stream,...(meta.audience==='user'?{audience:'user'}:{}),...base,message,data}),
+      });
+      else if(step.workflow)output=await execute(store.childId(step.workflow),args,callPath,currentSignal,reportFailure);
+      else if(step.branch){
+        const matched=evaluateCondition(step.branch.condition,state);
+        for(const unused of matched?(step.branch.else??[]):step.branch.then)await skip(unused,w,callPath,'未选择此分支');
+        output=(await sequence(matched?step.branch.then:(step.branch.else??[]),w,state,callPath,currentSignal,reportFailure)).outputs;
+      }else if(step.parallel)output=await parallel(step.parallel,w,state,callPath,currentSignal,reportFailure);
+      else throw new FlowError(step.stop.reason,{code:'WORKFLOW_STOPPED',details:{reason:step.stop.reason}});
+      checkCancelled(currentSignal);
+      await emit({type:'step.succeeded',...base,durationMs:Date.now()-start,output});
+      return {status:'succeeded',output};
+    }catch(cause){
+      const origin=failures.get(cause),propagated=origin&&(origin===callPath||origin.startsWith(callPath+'/'));
+      const cancelled=propagated?cause.code==='CANCELLED':!!currentSignal?.aborted,stopped=!cancelled&&cause.code==='WORKFLOW_STOPPED',error=errorRecord(cause);
+      const failure=propagated||stopped?cause:Object.assign(new FlowError(`${callPath}: ${error.message}`,{code:cancelled?'CANCELLED':'EXECUTION_FAILED',cause,details:error.details}),{plugin:error.plugin,action:error.action});
+      if(!failures.has(failure))failures.set(failure,callPath);
+      reportFailure?.(failure);
+      await emit({type:cancelled?'step.cancelled':stopped?'step.stopped':'step.failed',...base,plugin:error.plugin,message:error.message,code:error.code,details:error.details,error:stopped?undefined:error,durationMs:Date.now()-start});
+      throw failure;
+    }
+  };
+  const execute=async(workflowId,values,callPath,currentSignal,reportFailure)=>{
+    checkCancelled(currentSignal);
+    const w=snapshot.get(workflowId),state={inputs:validate(w.inputs??emptyObject,values,`${workflowId} 输入`),steps:{}};
+    await emit({type:'workflow.started',workflowId,callPath});
+    try{
+      const result=await sequence(w.steps,w,state,callPath,currentSignal,reportFailure),output=bind(w.outputs??{},result.state);
+      checkCancelled(currentSignal);
+      await emit({type:'workflow.succeeded',workflowId,callPath});return output;
+    }catch(error){if(error.code==='WORKFLOW_STOPPED')await emit({type:'workflow.stopped',workflowId,callPath,message:error.details.reason});throw error;}
+  };
+  return execute(id,input,id,signal);
+}

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

@@ -16,6 +16,8 @@ export async function createHost({ plugins = [], config = {}, services = {}, env
   const commandNames=new Set(),commands=new Map();
   function bindContext(context){
     const bound={...services,...context},execute=bound.runProcess;
+    // 面向用户的输出与诊断日志共用持久化通道，只区分默认可见性。
+    bound.print=(message,data)=>Promise.resolve(bound.log?.(message,data,{audience:'user'}));
     if(typeof execute==='function')bound.runProcess=(file,args,options={})=>{
       const signal=context.signal&&options.signal?AbortSignal.any([context.signal,options.signal]):context.signal??options.signal;
       return execute(file,args,{...options,signal,onOutput:async({stream,message})=>{

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

@@ -0,0 +1,135 @@
+import {FlowError} from '@mytools/sdk';
+
+// 静态声明用于诊断与打包，运行时激活仍由 Cordis inject 驱动。
+export function validateRuntimes(definitions,ctx){
+  const providers=new Map(),ordered=[],visiting=new Set(),visited=new Set();
+  for(const p of definitions.values()){
+    const r=p.runtime;if(r===undefined)continue;
+    if(!r||typeof r.apply!=='function')throw new FlowError(`${p.id} runtime 必须提供 apply`);
+    for(const key of ['provides','inject']){
+      const names=r[key]??[];
+      if(!Array.isArray(names)||names.some(n=>typeof n!=='string'||!/^\w[\w.-]*$/.test(n)||n in ctx)||new Set(names).size!==names.length)throw new FlowError(`${p.id} runtime.${key} 服务名称无效或重复`);
+    }
+    for(const name of r.provides??[]){
+      if(providers.has(name))throw new FlowError(`服务重复：${name}（${providers.get(name)}、${p.id}）`);
+      providers.set(name,p.id);
+    }
+  }
+  function visit(id){
+    if(visiting.has(id))throw new FlowError(`服务循环依赖：${[...visiting,id].join(' → ')}`);
+    if(visited.has(id))return;
+    visiting.add(id);const p=definitions.get(id);
+    for(const name of p.runtime?.inject??[]){
+      const owner=providers.get(name);
+      if(!owner)throw new FlowError(`${id} 缺少服务提供者：${name}`);
+      if(owner!==id&&!Object.hasOwn(p.dependencies??{},owner))throw new FlowError(`${id} 的 dependencies 必须声明服务 ${name} 的提供者 ${owner}`);
+      visit(owner);
+    }
+    visiting.delete(id);visited.add(id);ordered.push(id);
+  }
+  for(const id of definitions.keys())visit(id);
+  return {providers,ordered};
+}
+
+export function createRuntime(ctx,definitions,{enabled=true}={}){
+  const {providers,ordered}=validateRuntimes(definitions,ctx);
+  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 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));
+    pending.add(task);return task;
+  };
+  // 3.18.1 的 reset 会调用 dispose，但不等待 Promise；此适配只补齐等待和错误传播。
+  ctx.on('internal/listener',function(name,listener,options){
+    if(name!=='dispose')return;
+    const wrapped=()=>track(this.runtime.name??'host',listener),list=this.scope.disposables;
+    list[options.prepend?'unshift':'push'](wrapped);
+    return ()=>{const i=list.indexOf(wrapped);if(i>=0)list.splice(i,1);};
+  },{prepend:true,global:true});
+  ctx.on('internal/error',function(error){record(this?.runtime?.name??'host',error);},{global:true});
+  const drain=async()=>{while(pending.size)await Promise.all([...pending]);};
+  const failure=()=>new FlowError(`插件生命周期失败：${errors.map(e=>`${e.plugin}: ${e.message}`).join('；')}`,{code:'PLUGIN_RUNTIME',details:{errors:structuredClone(errors)}});
+  const runtime={
+    hasRuntime:[...definitions.values()].some(p=>p.runtime),
+    register(plugin,settings,register){
+      if(!enabled&&plugin.runtime)return;
+      const fork=ctx.plugin({name:plugin.id,inject:plugin.runtime?.inject??[],apply(scope){
+        const activation={scope,active:true,tasks:new Set(),disposers:[]};
+        scopes.set(plugin.id,activation);
+        const initialize=callback=>{
+          const task=Promise.resolve().then(callback);
+          activation.tasks.add(task);
+          return task.finally(()=>activation.tasks.delete(task));
+        };
+        scope.on('dispose',()=>{
+          activation.active=false;
+          if(scopes.get(plugin.id)===activation)scopes.delete(plugin.id);
+          return (async()=>{
+            // 初始化可能仍在取得资源；先等其结束，再执行本次激活登记的清理。
+            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);}
+            }
+          })();
+        });
+        register(scope);
+        const managed=new Proxy(scope,{get(target,name){
+          if(name==='on')return(event,listener,options={})=>{
+            if(event==='dispose'){
+              activation.disposers[options.prepend?'unshift':'push'](listener);
+              return()=>{const i=activation.disposers.indexOf(listener);if(i>=0)activation.disposers.splice(i,1);};
+            }
+            if(event==='ready')return scope.on(event,()=>initialize(listener),options);
+            return scope.on(event,listener,options);
+          };
+          if(name==='set')return(...args)=>{
+            if(!activation.active||closing)throw new FlowError(`${plugin.id} 激活作用域已失效`);
+            return scope.set(...args);
+          };
+          return Reflect.get(target,name);
+        }});
+        if(plugin.runtime)scope.on('ready',()=>initialize(()=>plugin.runtime.apply(managed,settings)));
+      }});
+      forks.set(plugin.id,fork);
+    },
+    async start(){
+      await ctx.start();await drain();
+      if(errors.length)throw failure();
+      if(!enabled)return;
+      for(const [name,id] of providers)if(ctx.get(name)==null)throw new FlowError(`${id} 未提供声明的服务：${name}`,{code:'PLUGIN_RUNTIME'});
+      for(const p of runtime.status())if(p.status!=='ready')throw new FlowError(`${p.id} 服务尚未就绪：${p.missing.join(', ')}`,{code:'PLUGIN_RUNTIME'});
+    },
+    status(){return [...definitions.values()].map(p=>{
+      const state=forks.get(p.id)?.runtime.status,missing=(p.runtime?.inject??[]).filter(n=>ctx.get(n)==null);
+      const error=errors.findLast(e=>e.plugin===p.id);
+      return {id:p.id,status:closing||!enabled&&p.runtime?'stopped':state===3?'failed':state===2&&forks.get(p.id)?.runtime.isActive&&!missing.length?'ready':'pending',missing,...(error?{error:error.message}:{})};
+    });},
+    assertActive(id){
+      if(closing)throw new FlowError('插件宿主已停止');
+      if(runtime.status().find(p=>p.id===id)?.status!=='ready'||!scopes.has(id))throw new FlowError(`插件 ${id} 当前不可用`,{code:'PLUGIN_RUNTIME',details:runtime.status().find(p=>p.id===id)});
+    },
+    bindServices(id){
+      runtime.assertActive(id);const activation=scopes.get(id);
+      return name=>runtime.getService(id,name,activation);
+    },
+    getService(id,name,activation){
+      if(!activation?.active||scopes.get(id)!==activation)throw new FlowError(`${id} 激活作用域已失效`);
+      runtime.assertActive(id);
+      const p=definitions.get(id);
+      if(![...(p.runtime?.inject??[]),...(p.runtime?.provides??[])].includes(name))throw new FlowError(`${id} 未声明服务：${name}`);
+      const value=activation.scope.get(name);
+      if(value==null)throw new FlowError(`${id} 服务不可用：${name}`);
+      return value;
+    },
+    assertOpen(){if(closing)throw new FlowError('插件宿主已停止');},
+    close(){
+      closing??=Promise.resolve().then(async()=>{
+        // 消费者先关闭，等待其使用完服务；注册撤销和依赖停用由 Cordis 执行。
+        for(const id of [...ordered].reverse()){forks.get(id)?.dispose();await drain();}
+        await ctx.stop();await drain();if(errors.length)throw failure();
+      });return closing;
+    },
+  };return runtime;
+}

package/manual/packages/core/src/terminal/run-feed.js

@@ -0,0 +1,78 @@
+import {readableValue,readableError,readableTimeline} from './run-presentation.js';
+import {runStatuses} from './run-viewer.js';
+
+// 主面板按事件到达顺序追加；运行快照另存，配置菜单不会清掉执行记录。
+export class RunFeed{
+  constructor(refresh){this.refresh=refresh;this.runs=new Map();this.entries=[];this.subscriptions=new Map();this.expanded=false;}
+  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]))};
+    this.runs.set(runId,item);
+    this.entries.push({type:'start',item});
+    if(!this.subscriptions.has(app))this.subscriptions.set(app,app.subscribe(event=>{
+      const item=this.runs.get(event.runId);if(!item||item.app!==app)return;
+      this.update(item,event);this.release(app);
+      if(event.type==='log'&&!item.ended)this.scheduleRefresh();
+      else this.flushRefresh();
+    }));
+    this.update(item);this.release(app);this.refresh();
+  }
+  scheduleRefresh(){
+    if(this.refreshTimer)return;
+    this.refreshTimer=setTimeout(()=>{this.refreshTimer=null;this.refresh();},100);
+  }
+  flushRefresh(){
+    if(this.refreshTimer){clearTimeout(this.refreshTimer);this.refreshTimer=null;}
+    this.refresh();
+  }
+  update(item,event){
+    if(event?.type&&!['run.succeeded','run.failed','run.cancelled','run.stopped'].includes(event.type))item.record.events.push(event);
+    else{
+      const record=item.app.getRun(item.record.id);if(!record)return;
+      item.record={...record,events:[...(record.events??[])]};
+    }
+    const {record}=item,events=record.events.slice(item.count);item.count=record.events.length;
+    for(const event of events)if(event.type.startsWith('step.'))item.steps.set(event.callPath,{...item.steps.get(event.callPath),...event});
+    if(events.length){
+      const last=this.entries.at(-1);
+      if(last?.type==='events'&&last.item===item)last.events.push(...events);
+      else this.entries.push({type:'events',item,events});
+    }
+    if(record.status!=='running'&&!item.ended){item.ended=true;this.entries.push({type:'result',item});}
+  }
+  release(app){
+    if([...this.runs.values()].some(item=>item.app===app&&!item.ended))return;
+    this.subscriptions.get(app)?.();this.subscriptions.delete(app);
+  }
+  message(text){this.entries.push({type:'message',text});this.refresh();}
+  compactEvents(entry,seen){
+    const {item}=entry,rows=[];
+    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}`);
+      }
+      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})}`);
+      if(event.type==='step.stopped'||event.type==='step.skipped')rows.push(`${event.callPath}：${event.reason??event.message??''}`);
+    }
+    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.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):'',
+    ].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}`,
+      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??'',
+    ].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();}
+}