@weavecode/weave 0.0.0-stage → 0.1.0

package/node_modules/@weavecode/server/dist/hooks/plugin-loader.d.ts

@@ -0,0 +1,175 @@
+import { type HookRule } from '@weavecode/core';
+import type { HookRuleRepository } from '../repositories/hook-rules.js';
+import type { LibraryRepository } from '../repositories/libraries.js';
+import type { PluginStateRepository } from '../repositories/plugin-states.js';
+import type { HookEventBus } from './bus.js';
+import { type HookRuleRegistry } from './registry.js';
+/** plugin 处理器返回值：prompt 入池（pending），additionalContext 注入当前会话。 */
+export interface PluginHandlerResult {
+    additionalContext?: string;
+    prompt?: string;
+}
+/** handler.mjs 的执行上下文（A2 扩展点②的最小服务面）。 */
+export interface PluginHandlerContext {
+    event: unknown;
+    rule: HookRule;
+    config: Record<string, unknown>;
+    logger: {
+        debug: (msg: string) => void;
+        info: (msg: string) => void;
+        warn: (msg: string) => void;
+        error: (msg: string) => void;
+    };
+}
+/** handler.mjs default 导出形状。 */
+export interface PluginHandler {
+    type: string;
+    execute(ctx: PluginHandlerContext): Promise<PluginHandlerResult | void> | PluginHandlerResult | void;
+}
+/** 插件日志器：统一 `[plugin:<id>]` 前缀（loader 订阅转发与 dispatcher 处理器共用）。 */
+export declare function createPluginLogger(pluginId: string): PluginHandlerContext['logger'];
+/** 订阅模块（扩展点⑦）default 导出形状：只读观察采集事件流。 */
+export interface PluginSubscriber {
+    onEvent(ctx: {
+        eventType: string;
+        payload: unknown;
+        sessionId: string | null;
+        config: Record<string, unknown>;
+        logger: PluginHandlerContext['logger'];
+    }): void | Promise<void>;
+}
+/** dispatcher 侧的插件宿主接口（解耦 loader 具体实现，便于测试注入）。 */
+export interface PluginHost {
+    getHandler(pluginId: string, handlerType: string): PluginHandler | undefined;
+    getConfig(pluginId: string): Record<string, unknown>;
+    /** ⑦ 事件订阅转发：每个采集事件 fire-and-forget 通知（可选，测试可不实现）。 */
+    notifyEvent?(eventType: string, payload: unknown, sessionId: string | null): void;
+}
+export type PluginLoadStatus = 'active' | 'rejected' | 'disabled';
+/** HTTP 路由面的插件管理接口（loader 异步就绪前返回空/失败，不阻塞 daemon 启动）。 */
+export interface PluginManager {
+    list(): LoadedPluginInfo[];
+    setPluginEnabled(pluginId: string, enabled: boolean): boolean;
+    /** 重扫全部已登记根（安装/卸载后立即生效，不等热重载防抖）。 */
+    reloadAll(): Promise<void>;
+    /** 手动重新扫描（dashboard 按钮）：重登记当前项目集的插件根 → 重扫 → 重挂 watcher。 */
+    rescan(): Promise<void>;
+}
+export interface LoadedPluginInfo {
+    /** manifest.id（manifest 校验失败时回退为目录名）。 */
+    id: string;
+    name: string;
+    version: string;
+    dir: string;
+    /** 扫描根的安装档（ToolScope 词表：user = 数据目录/市场根，无 local 档）。 */
+    scope: 'builtin' | 'user' | 'project';
+    projectId: number | null;
+    status: PluginLoadStatus;
+    /** rejected/disabled 的原因（校验错误、重复 id、handler 加载失败等）。 */
+    error?: string;
+    ruleCount: number;
+}
+export declare class WeavePluginLoader implements PluginHost {
+    private readonly deps;
+    private readonly handlers;
+    private readonly configs;
+    private readonly plugins;
+    /** ⑦ 事件订阅者：pluginId → {events, subscriber}（disabled/删除时摘除）。 */
+    private readonly subscribers;
+    /** 已登记的扫描根 → 作用域（热重载时按根重扫用；deep = 批 10 工具包深度根）。 */
+    private readonly roots;
+    private watchStop;
+    constructor(deps: {
+        rules: HookRuleRepository;
+        registry: HookRuleRegistry;
+        states: PluginStateRepository;
+        /** 可选：插件变更帧（plugin.reloaded/plugin.toggled）推送源。 */
+        bus?: HookEventBus;
+    });
+    list(): LoadedPluginInfo[];
+    getHandler(pluginId: string, handlerType: string): PluginHandler | undefined;
+    getConfig(pluginId: string): Record<string, unknown>;
+    /**
+     * 扫描一个插件根目录（其一级子目录各为一个插件包）并加载全部插件。
+     * 单个插件失败（校验/重复/handler 加载）只标记 rejected，不影响其他插件。
+     * 幂等：同 id 再次加载 = 覆盖式重载（规则 upsert，handler map 替换）；
+     * **上次在、本次消失的插件**（目录删除/改坏）规则级联删除、handler 卸载。
+     */
+    loadRoot(root: string, scope: 'builtin' | 'user' | 'project', projectId: number | null): Promise<LoadedPluginInfo[]>;
+    /**
+     * 批 10：工具包深度扫描根（内置仓 `plugins/<scope>/<pack>/` 与 managed
+     * 市场资源根）。单层 readdir 见不到 depth-3 嵌套——先递归发现含
+     * `weave-plugin.json` 的包位再逐包装载；其余成分（CC 原生/裸表面）由
+     * toolkit 服务走文件管线，不进本加载器。
+     * 首见的 weave 成分行默认 **停用**（工具包 opt-in：包开关 = plugin_states
+     * 级联事实，用户 enable 后才生效）；已有状态行（用户/既有安装）保持不变。
+     */
+    loadToolkitRoot(root: string, scope: 'builtin' | 'user' | 'project', projectId: number | null): Promise<LoadedPluginInfo[]>;
+    /** 工具包 weave 成分首见即落 `enabled=false`（无状态行时）。 */
+    private ensureToolkitDefaultDisabled;
+    /** 本根上次注册的插件 id（更深注册根名下的不归本根管，防深度/浅层互删）。 */
+    private priorIdsUnder;
+    /** 扫描收尾：消失插件级联删规则/卸 handler，刷新索引并推送重载帧。 */
+    private finalizeScan;
+    /**
+     * 热重载：watch 全部已登记根目录，文件/目录变更防抖后按根重扫。
+     * 深度根（批 10 工具包）用更大 watch depth——pack 在 level 2，其内容在 level 3+。
+     * 返回 stop 函数。daemon 关闭时调用。
+     */
+    watchRoots(debounceMs?: number): () => void;
+    /** 重扫全部已登记根（安装/卸载 API 调用；不等热重载防抖窗口）。 */
+    reloadAll(): Promise<void>;
+    /** 停掉当前一代 watcher（重新监听前、daemon 关闭时调用；可重复调用）。 */
+    stopWatching(): void;
+    /**
+     * 重新监听（dashboard 手动「重新扫描」）：按当前项目集重登记根 → 停旧 watcher
+     * → 重扫 → 对当前存在的根重挂。启动时不存在的根挂不上 watcher（chokidar 会上溯
+     * 到祖先目录，见 watchRoots），运行期才建起来的根靠这一下重新纳管；项目集也重读，
+     * 运行期新登记项目的 `.weave/plugins` 否则要等重启才被登记。
+     */
+    rescanRoots(projects: ReadonlyArray<{
+        id: number;
+        path: string;
+    }>, libraries?: Pick<LibraryRepository, 'list'>): Promise<void>;
+    /** 插件级开关：写 plugin_states 并级联启停其全部规则（保留规则级差异）。 */
+    setPluginEnabled(pluginId: string, enabled: boolean): boolean;
+    private unloadHandlers;
+    /**
+     * ⑦ 事件订阅转发：每个采集事件通知全部订阅了该事件的插件。
+     * fire-and-forget + 吞错——订阅者慢/挂永不阻塞 ingest 响应路径。
+     */
+    notifyEvent(eventType: string, payload: unknown, sessionId: string | null): void;
+    private emitReload;
+    private loadOne;
+    /** 相对路径解析 + 越界拒绝（entry/规则/模板文件统一走这里防路径穿越）。 */
+    private resolveWithin;
+}
+/**
+ * 登记并扫描全部插件根：工具包扫描根（内置仓 `plugins/` + M3 managed 市场资源根，批 10/
+ * 装载桥）→ 内置规则包根（内置仓 `rules/`）→ 全局 `<configDir>/weave/plugins/`
+ * → 各注册项目 `<project>/.weave/plugins/`。放在约定位置即被识别（用户决策的接入形态）。
+ * 工具包根先注册：浅层根扫描据此跳过已登记的深度根（不生成幽灵包位）。
+ * 任一根目录失败不抛（loadRoot 内部已吞 readdir 错误）。
+ * 启动装载与运行期「重新扫描」共用这一份派生——分两处必然漂移。
+ */
+export declare function registerPluginRoots(loader: WeavePluginLoader, deps: {
+    libraries?: Pick<LibraryRepository, 'list'>;
+}, projects: ReadonlyArray<{
+    id: number;
+    path: string;
+}>): Promise<LoadedPluginInfo[]>;
+/** SPI 全量加载：建 loader + 登记全部根（见 registerPluginRoots）。 */
+export declare function loadAllPlugins(deps: {
+    rules: HookRuleRepository;
+    registry: HookRuleRegistry;
+    states: PluginStateRepository;
+    bus?: HookEventBus;
+    /** managed 市场资源（M3 装载桥）；缺省不装载市场根。 */
+    libraries?: Pick<LibraryRepository, 'list'>;
+}, projects: ReadonlyArray<{
+    id: number;
+    path: string;
+}>): Promise<{
+    loader: WeavePluginLoader;
+    loaded: LoadedPluginInfo[];
+}>;

package/node_modules/@weavecode/server/dist/hooks/plugin-loader.js

@@ -0,0 +1 @@
+import{existsSync as C}from"node:fs";import{readFile as $,readdir as W}from"node:fs/promises";import c from"node:path";import{pathToFileURL as D}from"node:url";import{watch as B}from"chokidar";import{builtinRulesDir as P}from"../market/builtin.js";import{HARNESS_EVENT_UNION as I,HookRuleSchema as T,PluginRuleEntrySchema as k,WEAVE_PLUGIN_MANIFEST as A,WeavePluginManifestSchema as O}from"@weavecode/core";import{getDataDir as j}from"../db/paths.js";import{marketLibraryRoots as M}from"../market/resolve.js";import{validateHandler as N}from"./registry.js";import{builtinToolkitRoot as x,discoverToolkitSources as H,discoverWeavePackDirs as U}from"./toolkit-scan.js";export function createPluginLogger(u){return{debug:e=>console.debug(`[plugin:${u}] ${e}`),info:e=>console.info(`[plugin:${u}] ${e}`),warn:e=>console.warn(`[plugin:${u}] ${e}`),error:e=>console.error(`[plugin:${u}] ${e}`)}}const R="@file:";function L(){return c.resolve(x())}export class WeavePluginLoader{deps;handlers=new Map;configs=new Map;plugins=new Map;subscribers=new Map;roots=new Map;watchStop;constructor(e){this.deps=e}list(){return[...this.plugins.values()]}getHandler(e,s){return this.handlers.get(`${e}:${s}`)}getConfig(e){return this.configs.get(e)??{}}async loadRoot(e,s,n){const i=c.resolve(e);this.roots.set(i,{scope:s,projectId:n});let o;try{o=await W(i)}catch{return[]}const t=this.priorIdsUnder(i),d=[];for(const p of o){const l=c.join(i,p);if(this.roots.has(c.resolve(l))||c.resolve(l)===L())continue;const g=await this.loadOne(l,s,n,p);this.plugins.set(g.id,g),d.push(g)}return this.finalizeScan(t,d)}async loadToolkitRoot(e,s,n){const i=c.resolve(e);this.roots.set(i,{scope:s,projectId:n,deep:!0});const o=await U(i),t=this.priorIdsUnder(i),d=[];for(const p of o){await this.ensureToolkitDefaultDisabled(p);const l=await this.loadOne(p,s,n,c.basename(p));this.plugins.set(l.id,l),d.push(l)}return this.finalizeScan(t,d)}async ensureToolkitDefaultDisabled(e){try{const s=JSON.parse(await $(c.join(e,A),"utf8"));typeof s.id=="string"&&!this.deps.states.get(s.id)&&this.deps.states.setEnabled(s.id,!1)}catch{}}priorIdsUnder(e){const s=[...this.roots.keys()].filter(n=>n!==e&&n.startsWith(e+c.sep));return new Set([...this.plugins.values()].filter(n=>n.dir.startsWith(e+c.sep)?!s.some(i=>n.dir.startsWith(i+c.sep)):!1).map(n=>n.id))}finalizeScan(e,s){const n=new Set(s.map(o=>o.id));let i=!1;for(const o of e)n.has(o)||(this.deps.rules.removeByPlugin(o),this.unloadHandlers(o),this.configs.delete(o),this.plugins.delete(o),i=!0,this.emitReload({pluginId:o,status:"rejected",ruleCount:0,removed:!0}));(i||s.length>0)&&this.deps.registry.load();for(const o of s)this.emitReload({pluginId:o.id,status:o.status,ruleCount:o.ruleCount,at:new Date().toISOString()});return s}watchRoots(e=1e3){if(this.watchStop)return this.watchStop;const s=new Map,n=[...this.roots.entries()].filter(([i])=>C(i)).map(([i,o])=>{const t=o.deep?6:o.projectId!==null?3:2,d=B(i,{ignoreInitial:!0,depth:t});return d.on("all",()=>{const p=s.get(i);p&&clearTimeout(p),s.set(i,setTimeout(()=>{s.delete(i);const l=this.roots.get(i);l&&(l.deep?this.loadToolkitRoot(i,l.scope,l.projectId):this.loadRoot(i,l.scope,l.projectId)).catch(()=>{})},e))}),d.on("error",()=>{}),d});return this.watchStop=()=>{for(const i of s.values())clearTimeout(i);s.clear();for(const i of n)i.close();this.watchStop=void 0},this.watchStop}async reloadAll(){for(const[e,s]of[...this.roots])await(s.deep?this.loadToolkitRoot(e,s.scope,s.projectId):this.loadRoot(e,s.scope,s.projectId)).catch(()=>{})}stopWatching(){this.watchStop?.()}async rescanRoots(e,s){await registerPluginRoots(this,{libraries:s},e),this.stopWatching(),await this.reloadAll(),this.watchRoots()}setPluginEnabled(e,s){const n=this.plugins.get(e);if(!n)return!1;this.deps.states.setEnabled(e,s);for(const o of this.deps.rules.listByPlugin(e))this.deps.rules.setEnabled(o.id,s);this.deps.registry.load();const i=s?n.error?"rejected":"active":"disabled";return this.plugins.set(e,{...n,status:i}),this.deps.bus?.emit({kind:"plugin.toggled",pluginId:e,enabled:s,at:new Date().toISOString()}),!0}unloadHandlers(e){for(const s of[...this.handlers.keys()])s.startsWith(`${e}:`)&&this.handlers.delete(s);this.subscribers.delete(e)}notifyEvent(e,s,n){for(const[i,o]of this.subscribers){if(!o.events.has(e))continue;const t=this.configs.get(i)??{};(async()=>{await o.sub.onEvent({eventType:e,payload:s,sessionId:n,config:t,logger:createPluginLogger(i)})})().catch(()=>{})}}emitReload(e){this.deps.bus?.emit({kind:"plugin.reloaded",at:new Date().toISOString(),...e})}async loadOne(e,s,n,i){const o=(r,a,h=i,y="0.0.0")=>{const w=this.plugins.get(r);return w&&w.dir===e&&(this.deps.rules.removeByPlugin(r),this.unloadHandlers(r),this.configs.delete(r)),{id:r,name:h,version:y,dir:e,scope:s,projectId:n,status:"rejected",error:a,ruleCount:0}};let t;try{const r=JSON.parse(await $(c.join(e,A),"utf8")),a=O.safeParse(r);if(!a.success)return o(i,`manifest \u6821\u9A8C\u5931\u8D25: ${a.error.issues[0]?.message??""}`);t=a.data}catch(r){return o(i,`manifest \u8BFB\u53D6\u5931\u8D25: ${r instanceof Error?r.message:String(r)}`)}if(s!=="builtin"&&t.id.startsWith("weave-"))return o(t.id,"id \u4EE5 weave- \u5F00\u5934\u4E3A\u5185\u7F6E\u9884\u8BBE\u547D\u540D\u7A7A\u95F4\u4FDD\u7559",t.name,t.version);const d=this.plugins.get(t.id);if(d&&d.status!=="rejected"&&d.dir!==e)return o(t.id,`\u91CD\u590D\u7684\u63D2\u4EF6 id\uFF08\u5DF2\u7531 ${d.dir} \u6CE8\u518C\uFF09`,t.name,t.version);const p=(t.requires?.events??[]).filter(r=>!I.includes(r));if(p.length>0)return o(t.id,`requires.events \u542B\u672A\u77E5\u4E8B\u4EF6: ${p.join(", ")}`,t.name,t.version);const l=[];for(const r of t.rules)try{const a=JSON.parse(await $(this.resolveWithin(e,r),"utf8"));if(!Array.isArray(a))throw new Error(`${r} \u4E0D\u662F\u6570\u7EC4`);l.push(...a)}catch(a){return o(t.id,`\u89C4\u5219\u6587\u4EF6 ${r}: ${a instanceof Error?a.message:String(a)}`,t.name,t.version)}const g=new Map;for(const r of t.handlers)try{const a=this.resolveWithin(e,r.entry),h=(await import(`${D(a).href}?t=${Date.now()}`)).default;if(!h||typeof h.execute!="function")throw new Error(`${r.entry} \u7684 default \u5BFC\u51FA\u7F3A\u5C11 execute \u51FD\u6570`);if(h.type!==r.type)throw new Error(`${r.entry} \u5BFC\u51FA type="${h.type}" \u4E0E manifest \u58F0\u660E "${r.type}" \u4E0D\u7B26`);g.set(`${t.id}:${r.type}`,h)}catch(a){return o(t.id,`handler ${r.type} \u52A0\u8F7D\u5931\u8D25: ${a instanceof Error?a.message:String(a)}`,t.name,t.version)}let F;if(t.subscribe){const r=t.subscribe.events.filter(a=>!I.includes(a));if(r.length>0)return o(t.id,`subscribe.events \u542B\u672A\u77E5\u4E8B\u4EF6: ${r.join(", ")}`,t.name,t.version);try{const a=this.resolveWithin(e,t.subscribe.entry),h=(await import(`${D(a).href}?t=${Date.now()}`)).default;if(!h||typeof h.onEvent!="function")throw new Error(`${t.subscribe.entry} \u7684 default \u5BFC\u51FA\u7F3A\u5C11 onEvent \u51FD\u6570`);F={events:new Set(t.subscribe.events),sub:h}}catch(a){return o(t.id,`subscriber \u52A0\u8F7D\u5931\u8D25: ${a instanceof Error?a.message:String(a)}`,t.name,t.version)}}const S=[];for(let r=0;r<l.length;r++){const a=l[r],h=typeof a=="object"&&a!==null&&"handler"in a?{...a,handler:_(a.handler,t.id)}:a,y=k.safeParse(h);if(!y.success)return o(t.id,`\u89C4\u5219 #${r} \u6821\u9A8C\u5931\u8D25: ${y.error.issues[0]?.message??""}`,t.name,t.version);const w=y.data;let f=w.handler;if(f.type==="plugin"&&!g.has(`${t.id}:${f.handlerType}`))return o(t.id,`\u89C4\u5219 #${r} \u5F15\u7528\u672A\u58F0\u660E\u7684 handler "${f.handlerType}"`,t.name,t.version);if((f.type==="inject"||f.type==="manual")&&f.template.startsWith(R)){const v=f.template.slice(R.length);try{const b=await $(this.resolveWithin(e,v),"utf8");f={...f,template:b}}catch(b){return o(t.id,`\u89C4\u5219 #${r} \u6A21\u677F ${v}: ${b instanceof Error?b.message:String(b)}`,t.name,t.version)}}let E;try{E=T.parse({...w,handler:f,id:`plugin:${t.id}:${r}`,projectId:n,enabled:w.enabled??!0,priority:w.priority??0,origin:s==="builtin"?"builtin":"plugin",pluginId:t.id}),N(E.source,E.handler)}catch(v){return o(t.id,`\u89C4\u5219 #${r}: ${v instanceof Error?v.message:String(v)}`,t.name,t.version)}S.push(E)}const m=this.deps.states.get(t.id);try{for(const r of S)this.deps.rules.upsertPluginRule(r)}catch(r){return this.deps.rules.removeByPlugin(t.id),o(t.id,`\u89C4\u5219\u5165\u5E93\u5931\u8D25: ${r instanceof Error?r.message:String(r)}`,t.name,t.version)}if(m&&!m.enabled)for(const r of this.deps.rules.listByPlugin(t.id))this.deps.rules.setEnabled(r.id,!1);for(const[r,a]of g)this.handlers.set(r,a);return this.configs.set(t.id,{...t.config??{},...m?.config??{}}),F&&!(m&&!m.enabled)&&this.subscribers.set(t.id,F),{id:t.id,name:t.name,version:t.version,dir:e,scope:s,projectId:n,status:m&&!m.enabled?"disabled":"active",ruleCount:S.length}}resolveWithin(e,s){const n=c.resolve(e),i=c.resolve(n,s);if(i!==n&&!i.startsWith(n+c.sep))throw new Error(`\u8DEF\u5F84\u8D8A\u51FA\u63D2\u4EF6\u76EE\u5F55: ${s}`);return i}}function _(u,e){if(typeof u!="object"||u===null)return u;const s=u;return s.type!=="plugin"||s.pluginId!==void 0?u:{...s,pluginId:e}}export async function registerPluginRoots(u,e,s){const n=[],i=H();if(e.libraries)for(const t of M(e.libraries))i.push({root:t,provenance:"market"});const o=new Set;for(const t of i){const d=c.resolve(t.root);o.has(d)||(o.add(d),n.push(...await u.loadToolkitRoot(t.root,t.provenance==="builtin"?"builtin":"user",null)))}n.push(...await u.loadRoot(P(j()),"builtin",null)),n.push(...await u.loadRoot(c.join(j(),"plugins"),"user",null));for(const t of s)n.push(...await u.loadRoot(c.join(t.path,".weave","plugins"),"project",t.id));return n}export async function loadAllPlugins(u,e){const s=new WeavePluginLoader(u),n=await registerPluginRoots(s,u,e);return{loader:s,loaded:n}}

package/node_modules/@weavecode/server/dist/hooks/plugin-project-state.d.ts

@@ -0,0 +1,35 @@
+import type { PluginStateRepository } from '../repositories/plugin-states.js';
+import type { ProjectRepository, ProjectRow } from '../repositories/projects.js';
+/**
+ * D3 插件启用按项目隔离，即 ToolScope 两档链（user 默认 + project 覆写）：
+ * 每项目显式覆盖写 `projects.meta.plugins`，`plugin_states` 表保持
+ * user 档默认（=「默认启用」开关），不加范围维度、零迁移（§6-3 拍板）。
+ */
+export interface PluginsMeta {
+    syncedAt: string | null;
+    enabled: Record<string, boolean>;
+}
+/** 读 `projects.meta` 列的 plugins 键（缺失/损坏 → 未同步 + 空覆盖）。 */
+export declare function pluginsStateOf(meta: string | null): PluginsMeta;
+/**
+ * 生效单点三分支：`enabled[id]` 有显式记录 → 用之；否则项目已同步
+ * （syncedAt 存在）→ false（已同步未启用）；否则回落全局 plugin_states 行
+ * （未同步项目 = 现状语义）。`defaultEnabled` = 无全局行时的回落默认：
+ * dispatcher/管理面按 loader 语义 true，toolkit 读侧沿用既有 `?? false`。
+ */
+export declare function effective(project: Pick<ProjectRow, 'meta'>, pluginId: string, opts: {
+    states: Pick<PluginStateRepository, 'get'>;
+    defaultEnabled?: boolean;
+}): boolean;
+/** 项目级开关：写 `meta.plugins.enabled[id]`（不触碰全局 plugin_states / 规则级联）。 */
+export declare function setProjectEnabled(project: Pick<ProjectRow, 'id' | 'meta'>, pluginId: string, enabled: boolean, opts: {
+    projects: Pick<ProjectRepository, 'setMeta'>;
+}): void;
+/**
+ * 项目同步：写 `syncedAt` 并对**无显式记录**的已知插件补 `enabled=false`
+ *（同步后默认不启用；显式用户选择永不覆盖）。返回 syncedAt。
+ */
+export declare function syncPlugins(project: Pick<ProjectRow, 'id' | 'meta'>, knownIds: Iterable<string>, opts: {
+    projects: Pick<ProjectRepository, 'setMeta'>;
+    now?: string;
+}): string;

package/node_modules/@weavecode/server/dist/hooks/plugin-project-state.js

@@ -0,0 +1 @@
+export function pluginsStateOf(r){const t={syncedAt:null,enabled:{}};if(r==null)return t;try{const n=JSON.parse(r);if(!n||typeof n!="object"||Array.isArray(n))return t;const e=n.plugins;if(!e||typeof e!="object"||Array.isArray(e))return t;const o=e,c=o.enabled,s={};if(c&&typeof c=="object"&&!Array.isArray(c))for(const[l,a]of Object.entries(c))typeof a=="boolean"&&(s[l]=a);return{syncedAt:typeof o.syncedAt=="string"?o.syncedAt:null,enabled:s}}catch{return t}}export function effective(r,t,n){const e=pluginsStateOf(r.meta);return Object.hasOwn(e.enabled,t)?e.enabled[t]:e.syncedAt!==null?!1:n.states.get(t)?.enabled??n.defaultEnabled??!0}export function setProjectEnabled(r,t,n,e){const o=pluginsStateOf(r.meta);e.projects.setMeta(r.id,{plugins:{syncedAt:o.syncedAt,enabled:{...o.enabled,[t]:n}}})}export function syncPlugins(r,t,n){const e={...pluginsStateOf(r.meta).enabled};for(const c of t)Object.hasOwn(e,c)||(e[c]=!1);const o=n.now??new Date().toISOString();return n.projects.setMeta(r.id,{plugins:{syncedAt:o,enabled:e}}),o}

package/node_modules/@weavecode/server/dist/hooks/prompt-flusher.d.ts

@@ -0,0 +1,10 @@
+import type { MessageDeliverer } from './message-deliverer.js';
+/**
+ * prompt 队列的隐藏冲洗器（消息域重塑）：周期试递排队消息——会话可能在任何
+ * 时刻被打开（peer 注册表 / 终端 pane 随时出现），ingest 即时冲洗（inbox-worker
+ * 挂钩）只覆盖 weave 项目会话，本刷新器补齐其余。双触发幂等（递送键 = 行 id，
+ * 起送即删行）。空队列 = 一次空 Set 迭代，零开销；不绑 SSE 订阅数（递送域
+ * 非 UI 域——没人在看板也要送）。
+ */
+export declare const PROMPT_FLUSH_INTERVAL_MS = 15000;
+export declare function startPromptFlusher(deliverer: Pick<MessageDeliverer, 'flushAll'>): () => void;

package/node_modules/@weavecode/server/dist/hooks/prompt-flusher.js

@@ -0,0 +1 @@
+export const PROMPT_FLUSH_INTERVAL_MS=15e3;export function startPromptFlusher(e){const t=setInterval(()=>{e.flushAll()},15e3);return t.unref?.(),()=>clearInterval(t)}

package/node_modules/@weavecode/server/dist/hooks/promptbox.d.ts

@@ -0,0 +1,34 @@
+/**
+ * prompt 通道的本地文件队列（消息域重塑）：`<dataDir>/hooks/promptbox/<shard>.jsonl`。
+ * 与 outbox 严格分离——outbox 行由目标会话内 hook-handler 消费成 additionalContext
+ * （跨端契约），prompt 行由 **daemon** 冲洗（中继 / 终端注入），handler 永不碰。
+ * shard 与 outbox 同算法（项目 token 哈希前缀）；送达即删行，无 DB。
+ */
+export declare const PROMPTBOX_MAX_LINES = 200;
+/** 队列行：id = 管道发号（MessageDeliverer 的 uuid），daemon 重启后仍可追溯。 */
+export interface PromptboxEntry {
+    id: string;
+    sessionId: string;
+    text: string;
+    /** 单向注入（手动面）——随行落盘，重启后冲洗仍带「无需回复」注记。 */
+    oneWay?: boolean;
+    at: string;
+}
+export declare function promptboxPathOf(hooksDir: string, shardId: string): string;
+/** 追加入队（有界：超上限丢最旧，与 outbox 同型）。 */
+export declare function appendPromptbox(hooksDir: string, token: string, entries: Array<{
+    id: string;
+    sessionId: string;
+    text: string;
+    oneWay?: boolean;
+}>): void;
+/** 读一个项目的全部待递送行。 */
+export declare function readPromptbox(hooksDir: string, token: string): PromptboxEntry[];
+/** 删行（送达后）；ids 为空 = 不动文件。 */
+export declare function removePromptboxEntries(hooksDir: string, token: string, ids: Set<string>): void;
+/** 全库读行（扫所有项目分片）：队列索引与在途计数共用一份目录遍历。 */
+export declare function readAllPromptbox(hooksDir: string): PromptboxEntry[];
+/** 全库扫描：待递送行涉及哪些会话（启动重建队列索引 / 刷新器探活）。 */
+export declare function scanQueuedSessionIds(hooksDir: string): Set<string>;
+/** 按会话删行（会话被删/归档时的级联清理）。返回删除行数。 */
+export declare function removePromptboxBySession(hooksDir: string, sessionId: string): number;

package/node_modules/@weavecode/server/dist/hooks/promptbox.js

@@ -0,0 +1,11 @@
+import{mkdirSync as x,readFileSync as u,readdirSync as y,renameSync as l,writeFileSync as h}from"node:fs";import{join as f}from"node:path";import{hookShardId as m}from"./mirror.js";export const PROMPTBOX_MAX_LINES=200;export function promptboxPathOf(o,r){return f(o,"promptbox",`${r}.jsonl`)}function d(o){const r=[];for(const n of o.split(`
+`))if(n.trim())try{const t=JSON.parse(n);typeof t.id=="string"&&typeof t.sessionId=="string"&&typeof t.text=="string"&&r.push({id:t.id,sessionId:t.sessionId,text:t.text,oneWay:t.oneWay===!0,at:typeof t.at=="string"?t.at:""})}catch{}return r}export function appendPromptbox(o,r,n){if(n.length!==0)try{const t=promptboxPathOf(o,m(r));x(f(o,"promptbox"),{recursive:!0});let e=[];try{e=u(t,"utf8").split(`
+`).filter(c=>c.trim())}catch{e=[]}const p=new Date().toISOString();for(const c of n)e.push(JSON.stringify({...c,at:p}));const i=e.slice(-PROMPTBOX_MAX_LINES),s=`${t}.tmp`;h(s,i.length?i.join(`
+`)+`
+`:""),l(s,t)}catch{}}export function readPromptbox(o,r){try{return d(u(promptboxPathOf(o,m(r)),"utf8"))}catch{return[]}}export function removePromptboxEntries(o,r,n){if(n.size!==0)try{const t=promptboxPathOf(o,m(r));let e;try{e=u(t,"utf8").split(`
+`).filter(s=>s.trim())}catch{return}const p=e.filter(s=>{try{return!n.has(JSON.parse(s).id??"")}catch{return!1}}),i=`${t}.tmp`;h(i,p.length?p.join(`
+`)+`
+`:""),l(i,t)}catch{}}export function readAllPromptbox(o){const r=f(o,"promptbox");let n;try{n=y(r)}catch{return[]}const t=[];for(const e of n)if(e.endsWith(".jsonl"))try{t.push(...d(u(f(r,e),"utf8")))}catch{continue}return t}export function scanQueuedSessionIds(o){return new Set(readAllPromptbox(o).map(r=>r.sessionId))}export function removePromptboxBySession(o,r){const n=f(o,"promptbox");let t;try{t=y(n)}catch{return 0}let e=0;for(const p of t){if(!p.endsWith(".jsonl"))continue;const i=f(n,p);let s;try{s=u(i,"utf8").split(`
+`).filter(a=>a.trim())}catch{continue}const c=s.filter(a=>{try{return JSON.parse(a).sessionId!==r}catch{return!1}});if(c.length!==s.length){e+=s.length-c.length;try{const a=`${i}.tmp`;h(a,c.length?c.join(`
+`)+`
+`:""),l(a,i)}catch{}}}return e}

package/node_modules/@weavecode/server/dist/hooks/push-notify.d.ts

@@ -0,0 +1,42 @@
+import type { SessionRepository } from '../repositories/sessions.js';
+import type { PushSubscriptionRepository, PushSubscriptionRow } from '../repositories/push-subscriptions.js';
+import type { HookEventBus } from './bus.js';
+/** 推送载荷：SW 端按 title/body/tag/showNotification，url 供点击打开。 */
+export interface PushPayload {
+    title: string;
+    body: string;
+    /** 同 tag 的通知互相替换（与页面开着的本地通知去重）。 */
+    tag: string;
+    url: string;
+}
+/**
+ * Web Push 发送器（提醒通道的第三条腿）：浏览器把 dashboard 关掉后，本地
+ * 通知路径全死——只有厂商推送服务能唤起 SW 的 push 事件。订阅 hookBus 的
+ * `watch.fired`（watcher null = dashboard 订阅，与 web toast 同口径；会话
+ * 订阅的通知已走消息域注入，不推）与 `question.pending`（待答提醒默认开启，
+ * 无订阅概念）。发送失败永不影响采集（hooks 非阻塞不变式）：404/410 =
+ * 浏览器端已撤销 → 删行自愈；网络错误保留订阅下轮再试。
+ */
+export declare class PushNotifier {
+    private readonly deps;
+    private readonly vapid;
+    constructor(deps: {
+        subscriptions: Pick<PushSubscriptionRepository, 'list' | 'deleteByEndpoint'>;
+        sessions: Pick<SessionRepository, 'getBySessionId'>;
+        bus: HookEventBus;
+        /** VAPID 密钥文件（测试注入）；缺省 `<dataDir>/push.json`。 */
+        keysPath?: string;
+        /** 发送函数（测试注入）；缺省 web-push。 */
+        send?: (subscription: PushSubscriptionRow, payload: string, vapid: {
+            publicKey: string;
+            privateKey: string;
+        }) => Promise<void>;
+    });
+    /** 订阅面要的 applicationServerKey（base64url 原样）。 */
+    publicKey(): string;
+    private onBus;
+    /** 该帧推不推、推什么；不推的帧返回 null（tag 与 web 本地通知同值，双通道去重）。 */
+    private payloadFor;
+    private labelOf;
+    private pushAll;
+}

package/node_modules/@weavecode/server/dist/hooks/push-notify.js

@@ -0,0 +1,2 @@
+import{chmodSync as r,existsSync as c,mkdirSync as p,readFileSync as l,renameSync as d,writeFileSync as u}from"node:fs";import y from"node:path";import n from"web-push";import{getPushKeysPath as h}from"../db/paths.js";import{watchReasonPhrase as f}from"./watch-engine.js";export class PushNotifier{deps;vapid;constructor(e){this.deps=e,this.vapid=m(e.keysPath??h()),e.bus.subscribe(i=>this.onBus(i))}publicKey(){return this.vapid.publicKey}onBus(e){const i=this.payloadFor(e);if(!i)return;const s=this.deps.subscriptions.list();s.length!==0&&this.pushAll(s,JSON.stringify(i))}payloadFor(e){return e.kind==="watch.fired"?e.watcherSessionId!==null?null:{title:"weave",body:`Session ${this.labelOf(e.targetSessionId)} ${f(e.reason)}`,tag:`weave-watch-${e.targetSessionId}`,url:"/"}:e.kind==="question.pending"?{title:"weave",body:`Session ${this.labelOf(e.sessionId)} is waiting for your answer`,tag:`weave-question-${e.sessionId}`,url:"/"}:null}labelOf(e){return this.deps.sessions.getBySessionId(e)?.title??e.slice(0,8)}async pushAll(e,i){for(const s of e)try{await(this.deps.send??b)(s,i,this.vapid)}catch(o){const a=o.statusCode;(a===404||a===410)&&this.deps.subscriptions.deleteByEndpoint(s.endpoint)}}}async function b(t,e,i){n.setVapidDetails("mailto:weave@localhost",i.publicKey,i.privateKey),await n.sendNotification({endpoint:t.endpoint,keys:{p256dh:t.p256dh,auth:t.auth}},e,{TTL:3600})}function m(t){if(c(t))try{const s=JSON.parse(l(t,"utf8"));if(typeof s.publicKey=="string"&&s.publicKey&&typeof s.privateKey=="string"&&s.privateKey)return{publicKey:s.publicKey,privateKey:s.privateKey}}catch{}const e=n.generateVAPIDKeys();p(y.dirname(t),{recursive:!0});const i=`${t}.tmp`;u(i,`${JSON.stringify(e,null,2)}
+`,{encoding:"utf8",mode:384}),d(i,t);try{r(t,384)}catch{}return e}

package/node_modules/@weavecode/server/dist/hooks/question-tracker.d.ts

@@ -0,0 +1,84 @@
+import { type Harness } from '@weavecode/core';
+import type { BlockingPromptSpec, BlockingQuestion } from '@weavecode/harness';
+import type { HookEventRepository } from '../repositories/hook-events.js';
+import type { SessionRepository } from '../repositories/sessions.js';
+import type { NormalizedHookPayload } from './types.js';
+/**
+ * 阻塞式问答跟踪器（内存态状态机）：从 ingest 事件流派生「会话正卡在等输入」
+ * 的待答面（AskUserQuestion / 计划确认 / 权限确认），供 dashboard 展示与远程
+ * 作答。为什么不走 hookBus 帧：帧域不带 toolName（frameFacts 只提 agent 事实），
+ * 挂点必须在 handleIngestedRecords（解析后的 payload 在手）。
+ *
+ * 置位：PreToolUse(阻塞工具) / Notification(permission_prompt)；
+ * 清除：PostToolUse(同名阻塞工具) 与 UserPromptSubmit/Stop（question 态），
+ * permission 态由任意后续非 Notification 事件清（对话框了结必有下文）。
+ * daemon 重启由 seedFromDb 按最近事件窗口重放重建。
+ *
+ * 例外：卡在阻塞工具里时，该工具自己补发的 permission_prompt 不改写问题面——
+ * 实测 claude 对 AskUserQuestion/ExitPlanMode 恒在 PreToolUse 后 ~6s 补发一条
+ * permission_prompt（bypassPermissions 模式也发，即纯噪声；可重复发），若照单覆盖，
+ * dashboard 会在用户思考的中途把真问题换成合成权限面（选项含义完全不同，答下去发错键序）。
+ * 判据 = 该提醒归属 lastPreTool 且 lastPreTool 是阻塞工具：真权限对话框归属的是要批的
+ * 那个工具（PreToolUse(PowerShell) → permission_prompt → PostToolUse(PowerShell)），
+ * 归属非阻塞工具，照常置位，不会被误吞。
+ *
+ * 另一条：`bypassPermissions` 模式下 claude 根本不弹权限对话框（实测该模式所有
+ * permission_prompt 都是噪声），一律忽略——模式由随事件到达的 raw.permission_mode
+ * 逐条 latch（Notification 自带的 payload 不含此键，取最近一条带它的）。
+ */
+/** 会话当前的待答问题（内存态；事件流派生）。 */
+export interface PendingQuestionEntry {
+    sessionId: string;
+    harness: Harness;
+    /** question = 阻塞工具（问答/计划确认）；permission = 权限确认对话框。 */
+    kind: 'question' | 'permission';
+    questions: BlockingQuestion[];
+    at: string;
+}
+/** 状态机输入（handleIngestedRecords 逐条喂给；seedFromDb 重放同形）。 */
+export interface QuestionEventInput {
+    sessionId: string;
+    /** 事件源（harness 名）；未知源忽略。 */
+    source: string;
+    payload: NormalizedHookPayload | null;
+}
+export interface QuestionTrackerDeps {
+    sessions: Pick<SessionRepository, 'list'>;
+    hookEvents: Pick<HookEventRepository, 'listBySession'>;
+    /** 能力面访问器（测试注入）；缺省 surfaces.ts 模块级 registry。 */
+    surfaceFor?: (harness: Harness) => BlockingPromptSpec | null;
+    /** 新挂起待答（无 → 有）时广播（dashboard 提醒）；不传 = 不广播。 */
+    onPending?: (entry: PendingQuestionEntry) => void;
+}
+export declare class QuestionTracker {
+    private readonly deps;
+    /** sessionId → 待答面。 */
+    private readonly pending;
+    /** 权限确认的上下文（最近一次 PreToolUse）：Notification 不带工具面，从这补。 */
+    private readonly lastPreTool;
+    /** 会话当前权限模式（最近一条带 raw.permission_mode 的事件）。 */
+    private readonly permissionMode;
+    /** seedFromDb 重放期间不广播（重建不是新发生）。 */
+    private seeding;
+    constructor(deps: QuestionTrackerDeps);
+    private specOf;
+    /**
+     * ingest 主路径（也供 seed 重放）：一个事件推进状态机。事件按到达序喂入
+     * （ingest 的插入序 = 事件序），批内顺序由调用方保证。
+     */
+    onEvent(input: QuestionEventInput): void;
+    /** daemon 重启重建：每会话重放最近事件窗口，末态即当前待答面。 */
+    seedFromDb(): void;
+    /** 待答面快照（新在前；GET /messaging/questions）。 */
+    snapshot(): PendingQuestionEntry[];
+    /** 某会话的待答面（作答路由校验用）；无 = null。 */
+    get(sessionId: string): PendingQuestionEntry | null;
+    /**
+     * 作答已发（乐观落位，防重复作答——键序若打进已关的模态框会漏进输入框）。
+     * 整 call 一次提交（含 Submit 步），故整条摘除；PostToolUse 到达照常再清一次。
+     */
+    markAnswered(sessionId: string): void;
+    /** 会话删除级联。 */
+    forgetSession(sessionId: string): void;
+    private harnessOf;
+}

package/node_modules/@weavecode/server/dist/hooks/question-tracker.js

@@ -0,0 +1 @@
+import{isHarness as a}from"@weavecode/core";import{blockingPromptFor as c}from"../surfaces.js";const h=12;export class QuestionTracker{deps;pending=new Map;lastPreTool=new Map;permissionMode=new Map;seeding=!1;constructor(e){this.deps=e}specOf(e){return a(e)?this.deps.surfaceFor?.(e)??c(e):null}onEvent(e){const s=e.payload;if(!s)return;const n=this.specOf(e.source);if(!n)return;const t=e.sessionId,i=typeof s.toolName=="string"?s.toolName:null,p=f(s.raw);if(p&&this.permissionMode.set(t,p),s.eventType==="PreToolUse"){if(i&&this.lastPreTool.set(t,{toolName:i,toolInput:s.toolInput}),i&&n.blockingTools.includes(i)){const l=this.pending.get(t),r={sessionId:t,harness:this.harnessOf(e.source),kind:"question",questions:n.parseQuestions(i,s.toolInput),at:new Date().toISOString()};this.pending.set(t,r),!this.seeding&&l?.kind!=="question"&&this.deps.onPending?.(r)}return}if(s.eventType==="Notification"){if(n.permissionNotificationType&&g(s.raw)===n.permissionNotificationType){const l=this.permissionMode.get(t);if(l!=null&&n.silentPermissionModes.includes(l))return;const r=this.lastPreTool.get(t);if(this.pending.get(t)?.kind==="question"&&r!=null&&n.blockingTools.includes(r.toolName))return;const u=this.lastPreTool.get(t)??{toolName:null,toolInput:null};this.pending.set(t,{sessionId:t,harness:this.harnessOf(e.source),kind:"permission",questions:[n.permissionQuestion(u)],at:new Date().toISOString()})}return}const d=this.pending.get(t);if(d){if(d.kind==="permission"){this.pending.delete(t),this.lastPreTool.delete(t);return}(s.eventType==="PostToolUse"&&i!=null&&n.blockingTools.includes(i)||s.eventType==="UserPromptSubmit"||s.eventType==="Stop")&&(this.pending.delete(t),this.lastPreTool.delete(t))}}seedFromDb(){this.seeding=!0;try{for(const e of this.deps.sessions.list())for(const s of this.deps.hookEvents.listBySession(e.sessionId,h)){let n=null;try{n=JSON.parse(s.payload)}catch{n=null}this.onEvent({sessionId:e.sessionId,source:s.source,payload:n})}}finally{this.seeding=!1}}snapshot(){return[...this.pending.values()].sort((e,s)=>e.at<s.at?1:-1)}get(e){return this.pending.get(e)??null}markAnswered(e){this.pending.delete(e)}forgetSession(e){this.pending.delete(e),this.lastPreTool.delete(e),this.permissionMode.delete(e)}harnessOf(e){return e}}function f(o){if(!o||typeof o!="object")return null;const e=o.permission_mode;return typeof e=="string"&&e?e:null}function g(o){if(!o||typeof o!="object")return null;const e=o.notification_type;return typeof e=="string"&&e?e:null}

package/node_modules/@weavecode/server/dist/hooks/registry.d.ts

@@ -0,0 +1,49 @@
+import { type HandlerConfig, type HookRule, type HookRuleFilter, type HookRuleSource } from '@weavecode/core';
+import type { CreateHookRuleInput, HookRuleRepository } from '../repositories/hook-rules.js';
+/**
+ * 内存规则索引（ruflo HookRegistry 的跨进程形态：handler 不在进程内注册，
+ * 而是按事件名索引 SQLite 加载的规则，供 dispatcher 同步匹配）。
+ * 所有变更经 registry 走 repository 落库后 reload，保证缓存与库一致。
+ */
+export declare class HookRuleRegistry {
+    private readonly repo;
+    /** event → 规则，priority 降序。仅含 source.kind === 'hook-event'（legacy 形已读侧 normalize）。 */
+    private byEvent;
+    private all;
+    /** 规则集变更后的下游同步钩子（mirror 重写）；构造期首次 load 时通常未挂载。 */
+    onChange?: () => void;
+    constructor(repo: HookRuleRepository);
+    /** 从 SQLite 全量重载（外部直接改库后可调用）；读侧把 legacy 'claude-event' normalize 为 hook-event。 */
+    load(): void;
+    list(projectId?: number): HookRule[];
+    get(id: string): HookRule | undefined;
+    /**
+     * 匹配候选：该事件下的规则，priority 降序（projectId 归属过滤在 dispatcher）。
+     * 默认只含已启用；includeDisabled 供 dispatcher 对插件规则做「项目显式启用复活」
+     * （enabled 在那边按插件语义裁决），默认形不变 = 非插件路径语义不变。
+     */
+    candidates(event: string, opts?: {
+        includeDisabled?: boolean;
+    }): HookRule[];
+    create(input: CreateHookRuleInput): HookRule;
+    update(id: string, patch: Partial<CreateHookRuleInput>): HookRule | undefined;
+    setEnabled(id: string, enabled: boolean): HookRule | undefined;
+    remove(id: string): boolean;
+}
+export interface CreateHookRuleBody {
+    name: string;
+    enabled?: boolean;
+    priority?: number;
+    projectId: number | null;
+    source: HookRuleSource;
+    filter?: HookRuleFilter;
+    handler: HandlerConfig;
+    timeoutMs?: number;
+    record?: boolean;
+}
+/**
+ * inject 只允许挂在支持 additionalContext 的事件上（白名单按 harness 分表）。
+ * legacy 'claude-event' 视作 harness='claude'；'any' 拒绝（两 harness 注入通道不同，
+ * 白名单必须按具体 harness 查）；错误文案保留 `requires source.kind` 前缀（存量断言）。
+ */
+export declare function validateHandler(source: HookRuleSource, handler: HandlerConfig): void;

package/node_modules/@weavecode/server/dist/hooks/registry.js

@@ -0,0 +1 @@
+import{INJECTABLE_EVENTS as a,hookSourceHarness as c,normalizeHookRuleSource as s}from"@weavecode/core";export class HookRuleRegistry{repo;byEvent=new Map;all=[];onChange;constructor(e){this.repo=e,this.load()}load(){this.all=this.repo.list().map(e=>({...e,source:s(e.source)})),this.byEvent=new Map;for(const e of this.all){if(e.source.kind!=="hook-event")continue;const t=this.byEvent.get(e.source.event);t?t.push(e):this.byEvent.set(e.source.event,[e])}this.onChange?.()}list(e){return(e===void 0?this.all:this.repo.list(e)).map(t=>({...t,source:s(t.source)}))}get(e){return this.all.find(t=>t.id===e)}candidates(e,t){const n=this.byEvent.get(e)??[];return t?.includeDisabled?[...n]:n.filter(o=>o.enabled)}create(e){const t=s(e.source);validateHandler(t,e.handler);const n=this.repo.create({...e,source:t});return this.load(),n}update(e,t){const n=this.get(e);if(!n)return;const o=t.source?s(t.source):n.source;validateHandler(o,t.handler??n.handler);const i=this.repo.update(e,t.source?{...t,source:o}:t);return i&&this.load(),i}setEnabled(e,t){const n=this.repo.setEnabled(e,t);return n&&this.load(),n}remove(e){const t=this.repo.remove(e);return t&&this.load(),t}}export function validateHandler(r,e){const t=c(r);if(e.type==="inject"){if(t===null||t==="any")throw new Error('inject handler requires source.kind = "hook-event" with a concrete harness (legacy "claude-event" accepted; "any" rejected)');const n=a[t],o=r.kind==="claude-event"||r.kind==="hook-event"?r.event:"";if(!n.includes(o))throw new Error(`inject handler is not supported on event "${o}" (allowed: ${n.join(", ")})`);return}if(e.type==="plugin"&&t===null)throw new Error('plugin handler requires source.kind = "hook-event"')}

package/node_modules/@weavecode/server/dist/hooks/resume-runner.d.ts

@@ -0,0 +1,67 @@
+import { type ResumeCommandSpec } from '@weavecode/harness';
+import type { HookDispatchRepository } from '../repositories/hook-dispatches.js';
+import type { SessionRepository } from '../repositories/sessions.js';
+import type { ProjectRepository } from '../repositories/projects.js';
+import type { HookEventBus } from './bus.js';
+import { HeadlessRunner, type SpawnLike } from './headless-runner.js';
+export type { SpawnChild, SpawnLike } from './headless-runner.js';
+/**
+ * D3 指令池 resume 执行器：把 pending / injected 的 dispatch 用
+ * `claude --resume <sessionId> -p <prompt>` 在项目根下异步执行，
+ * 退出后回写 succeeded/failed/timeout 并广播 bus dispatch.finished。
+ *
+ * 批 4b：bin/args 规格迁入 `@weavecode/harness` 的 `CLAUDE_RESUME`
+ * （ResumeCommandSpec 注入，缺省 = 现行为）；claudeBin / WEAVE_CLAUDE_BIN
+ * 覆盖窗保留。
+ *
+ * session-orchestration 批 1：spawn/输出收集/超时/并发闸抽入 HeadlessRunner
+ * （与消息域 MessageDeliverer 共享同一实例 = 同会话并发闸跨域生效）；本类只保留
+ * dispatch 域的校验链与状态回写。
+ *
+ * run() 只做「校验 → 置 running → spawn」并立即返回（HTTP「已启动」语义）；
+ * 等待退出、超时强杀、状态回写全部走后台，校验后任何异常内部消化为 failed，
+ * 绝不 throw 出 run()。
+ */
+export interface ResumeRunnerDeps {
+    dispatches: HookDispatchRepository;
+    sessions: SessionRepository;
+    projects: ProjectRepository;
+    bus?: HookEventBus;
+    /** 测试注入的 spawn 实现；缺省用 node:child_process.spawn。 */
+    spawnImpl?: SpawnLike;
+    /** 测试注入的强杀实现（缺省：Windows 下 taskkill，POSIX 杀进程组）。 */
+    killImpl?: (pid: number) => void;
+    /** claude 可执行文件名覆盖（测试用）；缺省环境变量，再缺省 spec.bin。 */
+    claudeBin?: string;
+    /** 批 4b：resume 命令规格注入；缺省 CLAUDE_RESUME（与现行为等价）。 */
+    resumeSpec?: ResumeCommandSpec;
+    /** 单次 resume 超时（毫秒），超时强杀 → timeout；缺省 300_000，测试传短值。 */
+    timeoutMs?: number;
+    /** 共享无头执行核（跨域同会话并发闸）；缺省自建（测试隔离用）。 */
+    headless?: HeadlessRunner;
+}
+/** run() 的返回：ok 由路由映射 200，否则 status 即 HTTP 码。 */
+export type RunResult = {
+    ok: true;
+    dispatchId: number;
+} | {
+    ok: false;
+    status: 400 | 404 | 409;
+    error: string;
+};
+export declare class ResumeRunner {
+    private readonly deps;
+    private readonly headless;
+    private readonly claudeBin;
+    private readonly resumeSpec;
+    private readonly timeoutMs?;
+    constructor(deps: ResumeRunnerDeps);
+    /**
+     * 执行一条 dispatch 的 resume。校验链顺序（规格）：
+     * dispatch 404 → 状态非 pending/injected 409 → session 404 → 无项目根 400
+     * → 同 session 并发 409；通过后置 running + spawn，立即返回 ok。
+     */
+    run(dispatchId: number, sessionId: string): Promise<RunResult>;
+    /** 终态落定（幂等）：回写状态 → 广播 finished；内部消化一切异常。 */
+    private settle;
+}

package/node_modules/@weavecode/server/dist/hooks/resume-runner.js

@@ -0,0 +1 @@
+import{CLAUDE_RESUME as a}from"@weavecode/harness";import{HeadlessRunner as o}from"./headless-runner.js";export class ResumeRunner{deps;headless;claudeBin;resumeSpec;timeoutMs;constructor(s){this.deps=s,this.headless=s.headless??new o({spawnImpl:s.spawnImpl,killImpl:s.killImpl}),this.resumeSpec=s.resumeSpec??a,this.claudeBin=s.claudeBin??process.env.WEAVE_CLAUDE_BIN??this.resumeSpec.bin,this.timeoutMs=s.timeoutMs}async run(s,e){const t=this.deps.dispatches.getById(s);if(!t)return{ok:!1,status:404,error:"Dispatch not found"};if(t.status!=="pending"&&t.status!=="injected")return{ok:!1,status:409,error:`Dispatch is ${t.status}`};const i=this.deps.sessions.getBySessionId(e);if(!i)return{ok:!1,status:404,error:"Session not found"};if(i.projectId==null)return{ok:!1,status:400,error:"Session has no project"};const u=this.deps.projects.getById(i.projectId);if(!u)return{ok:!1,status:400,error:"Project not found for session"};if(this.headless.isBusy(e))return{ok:!1,status:409,error:"Session already has a running dispatch"};const n={settled:!1};try{this.deps.dispatches.updateStatus(s,{status:"running"}),this.deps.bus?.emit({kind:"dispatch.started",ruleId:t.ruleId,dispatchId:s,sessionId:e,at:new Date().toISOString()}),this.headless.run({sessionId:e,cwd:u.path,prompt:t.prompt,spec:this.resumeSpec,bin:this.claudeBin,timeoutMs:this.timeoutMs,onSettle:r=>this.settle(t,e,n,r)})||this.settle(t,e,n,{status:"failed",output:null,error:"Session already has a running dispatch"})}catch(r){this.settle(t,e,n,{status:"failed",output:null,error:r instanceof Error?r.message:String(r)})}return{ok:!0,dispatchId:s}}settle(s,e,t,i){if(!t.settled){t.settled=!0;try{this.deps.dispatches.updateStatus(s.id,{status:i.status,output:i.output,error:i.error,finished:!0}),this.deps.bus?.emit({kind:"dispatch.finished",ruleId:s.ruleId,dispatchId:s.id,status:i.status,sessionId:e,at:new Date().toISOString()})}catch{}}}}