@weavecode/weave 0.0.0-stage → 0.1.1

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

@@ -0,0 +1 @@
+import{EventEmitter as e}from"node:events";export class HookEventBus{emitter=new e;constructor(){this.emitter.setMaxListeners(100)}emit(t){this.emitter.emit("change",t)}subscribe(t){return this.emitter.on("change",t),()=>this.emitter.off("change",t)}}

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

@@ -0,0 +1,95 @@
+import { type Harness } from '@weavecode/core';
+import type { NormalizedHookPayload } from './types.js';
+import type { HookRuleRegistry } from './registry.js';
+import type { PluginHost } from './plugin-loader.js';
+import type { HookDispatchRepository } from '../repositories/hook-dispatches.js';
+import type { SessionRepository } from '../repositories/sessions.js';
+import type { HookEventBus } from './bus.js';
+import type { ProjectRepository, ProjectRow } from '../repositories/projects.js';
+import type { PluginStateRepository } from '../repositories/plugin-states.js';
+export interface IngestContext {
+    /** 本次 ingest 写入 hook_events 的行 id。 */
+    eventId: number;
+    project: ProjectRow;
+    sessionId: string | null;
+    payload: NormalizedHookPayload;
+    /** 事件来源 harness（server.ts 传入 input.source）；规则 harness 过滤按此比对。 */
+    source: Harness;
+    /** hook-handler 的改名交付回执：随响应实际下发的 sessionTitle（未下发 = null）。 */
+    deliveredTitle?: string | null;
+}
+/**
+ * ingest 的注入产出。响应体通道已随 POST /hooks 移除（hook 文件化后注入走
+ * mirror 本地渲染），本接口保留为消费侧的产出形态：additionalContext 仍是全部
+ * 注入片段（语义不变），deferred 是 hook 无法当场交付的部分（plugin 产出、
+ * crossProjectOnly 等未镜像规则），由消费侧写 outbox 顺延给下一次事件。
+ */
+export interface IngestOutcome {
+    additionalContext?: string;
+    sessionTitle?: string;
+    deferred?: string;
+}
+/**
+ * 事件分发器：ingest 后同步匹配（纯内存索引）并按 handler 分发。
+ *
+ * - log：只发 bus 事件，不落 dispatch 行（高频防写放大）
+ * - manual：入池 status=pending（等 dashboard 复制/拖拽执行）
+ * - inject：入池 status=injected；注入本体由 hook 经 mirror 本地渲染交付
+ *   （镜像外规则进 deferred → outbox 顺延）
+ * - webhook：入池 status=running 后异步出站，信号量限并发
+ * - plugin：可注入事件在消费路径上同步执行、产出进 deferred（outbox 顺延），
+ *   整段共享预算；不可注入事件（PreToolUse/Notification 等）与 webhook 同款
+ *   fire-and-forget——prompt 照常入池，只是晚一步落库
+ *
+ * 一切异常在内部吞掉并降级为「无动作」——分发失败永不影响 ingest。
+ */
+export declare class HookDispatcher {
+    private readonly deps;
+    private readonly runningWebhooks;
+    private readonly recentPool;
+    private activeWebhooks;
+    private readonly pendingWebhooks;
+    private activePlugins;
+    private readonly pendingPlugins;
+    constructor(deps: {
+        registry: HookRuleRegistry;
+        dispatches: HookDispatchRepository;
+        bus: HookEventBus;
+        projects: ProjectRepository;
+        /** 会话标题双向 rename（session_title diff + pending 下发）。 */
+        sessions: SessionRepository;
+        /** 插件宿主（plugin-loader）；缺省时 plugin 规则按无动作跳过。 */
+        plugins?: PluginHost;
+        /** D3 项目启用门控的全局回落源（plugin_states 行）；缺省不门控（现状语义）。 */
+        pluginStates?: Pick<PluginStateRepository, 'get'>;
+        /** 测试注入；缺省用全局 fetch。 */
+        fetchImpl?: typeof fetch;
+    });
+    onIngest(ctx: IngestContext): Promise<IngestOutcome>;
+    /** 入池 + 广播 dispatch.created（inject/manual/webhook/plugin 四路共用的建池路径）。 */
+    private createDispatch;
+    /** 同 rule × session 60s 去重：true = 应跳过本规则（防注入指令再触发事件的递归风暴）。 */
+    private dedupe;
+    /** 候选规则：事件索引（启用+priority 降序）→ 项目归属 → 过滤条件。 */
+    private match;
+    /** 该事件能否把插件的 additionalContext 交给会话（白名单按 harness 分表）。 */
+    private injectable;
+    /**
+     * 执行插件处理器：timeoutMs 竞速超时（`budgetMs` = 本次可用预算，取两者更小者），
+     * 任何异常/超时返回 undefined（不注入不入池）。并发闸的排队时间计入同一次竞速，
+     * 排到后照常执行，超时被弃的那次由自己 finally 释放槽位（不会漏槽）。
+     */
+    private runPluginHandler;
+    /** 不可注入事件的插件执行：fire-and-forget，prompt 照常入池（晚一步落库）。 */
+    private runPluginDetached;
+    private summary;
+    private runWebhookAsync;
+    /** 全局并发闸（默认 4）：超出则排队等待。 */
+    private acquireWebhookSlot;
+    private releaseWebhookSlot;
+    /** 插件执行并发闸（默认 4）：超出则排队等待。 */
+    private acquirePluginSlot;
+    private releasePluginSlot;
+    /** 去重窗口 map 清理：只留窗口内条目，防长期运行无限增长。 */
+    private trimDedupe;
+}

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

@@ -0,0 +1,8 @@
+import{INJECTABLE_EVENTS as I,TITLE_EFFECTIVE_EVENTS as y,hookSourceHarness as P}from"@weavecode/core";import{createPluginLogger as b}from"./plugin-loader.js";import{readHooksEnabled as S}from"../daemon/settings.js";import{effective as k,pluginsStateOf as v}from"./plugin-project-state.js";import{runWebhook as w}from"./handlers/webhook.js";import{DISPATCH_MARKER as c,extractFilePath as h,isCrossProjectPath as j,matchesAnyGlob as T,projectLabel as D,renderTemplate as E,templateVars as W}from"./match.js";const g=6e4,N=4,_=4,O=3e3;export class HookDispatcher{deps;runningWebhooks=new Set;recentPool=new Map;activeWebhooks=0;pendingWebhooks=[];activePlugins=0;pendingPlugins=[];constructor(e){this.deps=e}async onIngest(e){try{if(!S())return{};this.deps.plugins?.notifyEvent?.(e.payload.eventType,e.payload,e.sessionId);const t={};if(e.sessionId){const s=C(e.payload);s!==null&&this.deps.sessions.applyReportedTitle(e.sessionId,s)&&this.deps.bus.emit({kind:"session.renamed",sessionId:e.sessionId,title:s,at:new Date().toISOString()});const o=this.deps.sessions.getBySessionId(e.sessionId)?.pendingTitle;if(o){t.sessionTitle=o;const l=y[e.source].includes(e.payload.eventType);(e.deliveredTitle===o&&l||s!==null)&&this.deps.sessions.confirmPendingTitle(e.sessionId,o)&&this.deps.bus.emit({kind:"session.renamed",sessionId:e.sessionId,title:o,at:new Date().toISOString()})}}const r=this.match(e);if(r.length===0)return t;const n=[],i=[],a=Date.now(),d=a+O;for(const s of r)if(this.deps.bus.emit({kind:"rule.matched",ruleId:s.id,eventId:e.eventId,sessionId:e.sessionId,at:new Date(a).toISOString()}),s.handler.type!=="log"){if(s.handler.type==="manual"||s.handler.type==="inject"){if(this.dedupe(s,e,a))continue;const o=E(s.handler.template,W({event:e.payload.eventType,tool:e.payload.toolName,filePath:h(e.payload.toolInput),cwd:e.payload.cwd,session:e.sessionId,project:D(e.project.path),rule:s.name}))+`
+${c}`,l=s.handler.type==="inject"?"injected":"pending";this.createDispatch(s,e,{prompt:o,status:l,mode:s.handler.type==="inject"?"auto":"manual"}),s.handler.type==="inject"&&(s.filter.crossProjectOnly?i.push(o):n.push(o));continue}if(s.handler.type==="webhook"){if(this.runningWebhooks.has(s.id))continue;this.runningWebhooks.add(s.id);const o=this.createDispatch(s,e,{prompt:`webhook ${s.handler.url}`,status:"running",mode:"auto"});this.deps.bus.emit({kind:"dispatch.started",ruleId:s.id,dispatchId:o.id,sessionId:e.sessionId,at:new Date().toISOString()}),this.runWebhookAsync(s,this.summary(s,e),o.id);continue}if(s.handler.type==="plugin"){const o=this.deps.plugins;if(!o)continue;const l=o.getHandler(s.handler.pluginId,s.handler.handlerType);if(!l||this.dedupe(s,e,a))continue;if(!this.injectable(e)){this.runPluginDetached(s,e,o,l);continue}const u=d-Date.now();if(u<=0)continue;const p=await this.runPluginHandler(s,e,o,l,u);if(!p)continue;p.prompt&&this.createDispatch(s,e,{prompt:p.prompt+`
+${c}`,status:"pending",mode:"auto"}),p.additionalContext&&i.push(p.additionalContext)}}return(n.length>0||i.length>0)&&(t.additionalContext=[...n,...i].join(`
+
+`)),i.length>0&&(t.deferred=i.join(`
+
+`)),t}catch{return{}}}createDispatch(e,t,r){const n=this.deps.dispatches.insert({ruleId:e.id,eventId:t.eventId,sessionId:t.sessionId,...r});return this.deps.bus.emit({kind:"dispatch.created",ruleId:e.id,dispatchId:n.id,status:r.status,mode:n.mode,sessionId:t.sessionId,at:n.startedAt}),n}dedupe(e,t,r){const n=`${e.id}:${t.sessionId??""}`,i=this.recentPool.get(n);return i!==void 0&&r-i<g?!0:(this.recentPool.set(n,r),this.trimDedupe(r),!1)}match(e){const t=this.deps.pluginStates,r=t?v(e.project.meta).enabled:null;let n=null;return this.deps.registry.candidates(e.payload.eventType,t?{includeDisabled:!0}:void 0).filter(i=>{const a=P(i.source);if(a!==null&&a!=="any"&&a!==e.source||i.projectId!==null&&i.projectId!==e.project.id)return!1;if(i.pluginId!==null){if(!i.enabled&&r?.[i.pluginId]!==!0||t&&!k(e.project,i.pluginId,{states:t}))return!1}else if(!i.enabled)return!1;const d=i.filter;if(d.toolNames?.length&&(!e.payload.toolName||!d.toolNames.includes(e.payload.toolName)))return!1;if(d.pathGlobs?.length){const s=h(e.payload.toolInput);if(!s||!T(s,d.pathGlobs))return!1}if(d.crossProjectOnly){const s=h(e.payload.toolInput)??e.payload.cwd;if(!s||(n??=this.deps.projects.list().map(o=>o.path).filter(o=>o!==e.project.path),!j(s,e.project.path,n)))return!1}return!0})}injectable(e){const t=e.payload.eventType;return t!==null&&I[e.source].includes(t)}async runPluginHandler(e,t,r,n,i){if(e.handler.type!=="plugin")return;const{pluginId:a}=e.handler,d=b(a),s=i===void 0?e.timeoutMs:Math.min(e.timeoutMs,i);let o;try{const l=(async()=>{await this.acquirePluginSlot();try{return await n.execute({event:t.payload,rule:e,config:r.getConfig(a),logger:d})}finally{this.releasePluginSlot()}})(),u=await Promise.race([l,new Promise((p,m)=>{o=setTimeout(()=>m(new Error("plugin handler timeout")),s)})]);return u&&typeof u=="object"?u:void 0}catch{return}finally{o&&clearTimeout(o)}}async runPluginDetached(e,t,r,n){try{const i=await this.runPluginHandler(e,t,r,n);if(!i?.prompt)return;this.createDispatch(e,t,{prompt:i.prompt+`
+${c}`,status:"pending",mode:"auto"})}catch{}}summary(e,t){return{ruleId:e.id,ruleName:e.name,projectId:t.project.id,sessionId:t.sessionId,event:t.payload.eventType,toolName:t.payload.toolName,filePath:h(t.payload.toolInput),cwd:t.payload.cwd,at:new Date().toISOString()}}async runWebhookAsync(e,t,r){await this.acquireWebhookSlot();try{const n=await w(e,t,this.deps.fetchImpl);this.deps.dispatches.updateStatus(r,{status:n.status,output:n.output??null,error:n.error??null,finished:!0}),this.deps.bus.emit({kind:"dispatch.finished",ruleId:e.id,dispatchId:r,status:n.status,sessionId:t.sessionId,at:new Date().toISOString()})}catch(n){this.deps.dispatches.updateStatus(r,{status:"failed",error:String(n),finished:!0}),this.deps.bus.emit({kind:"dispatch.finished",ruleId:e.id,dispatchId:r,status:"failed",sessionId:t.sessionId,at:new Date().toISOString()})}finally{this.runningWebhooks.delete(e.id),this.releaseWebhookSlot()}}acquireWebhookSlot(){return this.activeWebhooks<N?(this.activeWebhooks++,Promise.resolve()):new Promise(e=>{this.pendingWebhooks.push(()=>{this.activeWebhooks++,e()})})}releaseWebhookSlot(){this.activeWebhooks--;const e=this.pendingWebhooks.shift();e&&e()}acquirePluginSlot(){return this.activePlugins<_?(this.activePlugins++,Promise.resolve()):new Promise(e=>{this.pendingPlugins.push(()=>{this.activePlugins++,e()})})}releasePluginSlot(){this.activePlugins--;const e=this.pendingPlugins.shift();e&&e()}trimDedupe(e){if(!(this.recentPool.size<1e3))for(const[t,r]of this.recentPool)e-r>=g&&this.recentPool.delete(t)}}function C(f){const e=f.raw;if(typeof e!="object"||e===null)return null;const t=e.session_title;return typeof t=="string"&&t.length>0?t:null}

package/node_modules/@weavecode/server/dist/hooks/handlers/webhook.d.ts

@@ -0,0 +1,26 @@
+import type { HookRule } from '@weavecode/core';
+/** 事件摘要——出站 webhook body 只带这些字段（不透传全量 toolResponse，收窄外泄面）。 */
+export interface EventSummary {
+    ruleId: string;
+    ruleName: string;
+    projectId: number;
+    sessionId: string | null;
+    event: string;
+    toolName: string | null;
+    /** toolInput.file_path（若事件携带）。 */
+    filePath: string | null;
+    cwd: string | null;
+    at: string;
+}
+export interface WebhookResult {
+    ok: boolean;
+    status: 'succeeded' | 'failed' | 'timeout';
+    output?: string;
+    error?: string;
+}
+/**
+ * 出站 webhook 处理器：POST 事件摘要到外部系统。
+ * 边界：仅 http/https、5s 超时、响应体截断 4KB、可选 HMAC-SHA256 签名头
+ * `X-Weave-Signature: sha256=<hex>`（secret 即签名密钥）。
+ */
+export declare function runWebhook(rule: HookRule, summary: EventSummary, fetchImpl?: typeof fetch): Promise<WebhookResult>;

package/node_modules/@weavecode/server/dist/hooks/handlers/webhook.js

@@ -0,0 +1 @@
+import{createHmac as l}from"node:crypto";const u=5e3,d=4096;export async function runWebhook(s,i,c=fetch){const e=s.handler;if(e.type!=="webhook")return{ok:!1,status:"failed",error:`rule ${s.id} is not a webhook handler`};let r;try{r=new URL(e.url)}catch{return{ok:!1,status:"failed",error:`invalid url: ${e.url}`}}if(r.protocol!=="http:"&&r.protocol!=="https:")return{ok:!1,status:"failed",error:`unsupported protocol: ${r.protocol}`};const a=JSON.stringify(i),n={"content-type":"application/json","user-agent":"weave-daemon",...e.headers??{}};e.secret&&(n["x-weave-signature"]=`sha256=${l("sha256",e.secret).update(a).digest("hex")}`);try{const t=await c(r,{method:"POST",headers:n,body:a,signal:AbortSignal.timeout(u)}),o=(await t.text()).slice(0,d);return t.ok?{ok:!0,status:"succeeded",output:o||`HTTP ${t.status}`}:{ok:!1,status:"failed",error:`HTTP ${t.status}`,output:o}}catch(t){const o=t instanceof Error&&(t.name==="TimeoutError"||t.name==="AbortError");return{ok:!1,status:o?"timeout":"failed",error:o?`webhook timed out after ${u}ms`:String(t)}}}

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

@@ -0,0 +1,91 @@
+import { type SpawnOptions } from 'node:child_process';
+import type { ResumeCommandSpec } from '@weavecode/harness';
+/**
+ * 无头回合执行核心（session-orchestration 批 1 自 resume-runner 抽出）：
+ * spawn `spec.args(sessionId, prompt)`、输出收集、超时强杀、**跨域共享的同会话
+ * 并发闸**——指令池派发（ResumeRunner）与点对点消息（MessageDeliverer）用同一
+ * 实例，两个 claude --resume 进程绝不落在同一会话上。
+ *
+ * run() 同步返回（「已启动」语义）；等待退出、超时、onSettle 回调全走后台，
+ * 任何异常内部消化为 failed 终态，绝不 throw。
+ */
+/** 子进程句柄的最小结构：真实 ChildProcess 与测试的 EventEmitter fake 都满足。 */
+export interface SpawnChild {
+    pid?: number;
+    /** listener 用 `(...args: never[]) => void`：never 可赋给任意具体参数类型，
+     *  调用方得以直接写 `(code: number | null) => …` 而无需类型断言。 */
+    on(event: string, listener: (...args: never[]) => void): unknown;
+    stdin?: {
+        on(event: string, listener: (...args: never[]) => void): unknown;
+        write(chunk: string): unknown;
+        end(): unknown;
+    } | null;
+    stdout?: {
+        on(event: string, listener: (...args: never[]) => void): unknown;
+    } | null;
+    stderr?: {
+        on(event: string, listener: (...args: never[]) => void): unknown;
+    } | null;
+}
+/** 测试注入的 spawn 签名；缺省用 node:child_process.spawn。 */
+export type SpawnLike = (command: string, args: readonly string[], options: SpawnOptions) => SpawnChild;
+export interface HeadlessSettleResult {
+    status: 'succeeded' | 'failed' | 'timeout';
+    output: string | null;
+    error: string | null;
+}
+export interface HeadlessRunInput {
+    sessionId: string;
+    cwd: string;
+    prompt: string;
+    spec: ResumeCommandSpec;
+    bin: string;
+    /** 单次超时（毫秒），超时强杀 → timeout；**0 = 不设看门狗**（投递等待发生在
+     *  目标会话内的场景，如 prompt 中继——设上限只会把正常投递误判成 timeout）。 */
+    timeoutMs?: number;
+    /**
+     * 是否自成进程组（POSIX `detached`）。缺省 true——headless 回合跑得长、可整组
+     * 强杀。**中继传 false**：它是本轮次的一次性子进程，应当跟 daemon 同进程组、
+     * 随 daemon 退出被回收，不留独立进程占资源。win32 shell 模式恒 false（实测
+     * shell+detached 管道输出全丢）。
+     */
+    detached?: boolean;
+    onSettle: (result: HeadlessSettleResult) => void;
+}
+export interface HeadlessRunnerDeps {
+    /** 测试注入的 spawn 实现；缺省用 node:child_process.spawn。 */
+    spawnImpl?: SpawnLike;
+    /** 测试注入的强杀实现（缺省：Windows 下 taskkill，POSIX 杀进程组）。 */
+    killImpl?: (pid: number) => void;
+}
+export declare class HeadlessRunner {
+    private readonly spawnImpl;
+    private readonly killImpl;
+    /** sessionId → 进行中的回合（并发闸）；终态落定后清除。 */
+    private readonly active;
+    /** sessionId → 在飞子进程 pid（daemon 退出时统一回收；终态/退出后清除）。 */
+    private readonly livePids;
+    constructor(deps?: HeadlessRunnerDeps);
+    /** 该会话是否已有无头回合在跑（跨 dispatch/message 域共享）。 */
+    isBusy(sessionId: string): boolean;
+    /**
+     * 回收全部在飞子进程（daemon 退出时调用）：这些进程是 daemon 的子进程，
+     * 不该比 daemon 活得久。win32 → taskkill /T /F（整棵进程树）；POSIX →
+     * 先杀进程组（detached 子进程自成组）再回退单进程（非 detached 的子进程，
+     * 如中继）——三平台同一入口，无平台分支。返回强杀尝试数。
+     */
+    killAll(): number;
+    /**
+     * 启动一次无头回合：同会话已占用返回 false（调用方映射 409）。
+     * 通过后立即返回 true；终态经 onSettle 后台送达。
+     */
+    run(input: HeadlessRunInput): boolean;
+    /** spawn 并挂上输出收集 / 退出 / 超时监听；同步完成，不等待退出。 */
+    private watch;
+    /** 终态落定（**按次**幂等）：守卫是本次 run 的 state 标志而非共享闸——同会话
+     * 前一回合的迟到事件不得吞掉后一回合的 settle。清闸 → 回调 onSettle；回调
+     * 异常只吞（后台回调不冒泡）。 */
+    private settle;
+}
+/** 默认强杀：Windows 用 taskkill 杀进程树；POSIX 杀 detached 进程组，失败回退单进程。 */
+export declare function defaultKill(pid: number): void;

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

@@ -0,0 +1,2 @@
+import{spawn as k}from"node:child_process";const A=3e5,T=32*1024,_=2e3;export class HeadlessRunner{spawnImpl;killImpl;active=new Set;livePids=new Map;constructor(t={}){this.spawnImpl=t.spawnImpl??k,this.killImpl=t.killImpl??defaultKill}isBusy(t){return this.active.has(t)}killAll(){let t=0;for(const s of this.livePids.values())try{this.killImpl(s),t++}catch{}return this.livePids.clear(),t}run(t){if(this.active.has(t.sessionId))return!1;this.active.add(t.sessionId);const s={settled:!1};try{this.watch(t,s)}catch(l){this.settle(t,s,{status:"failed",output:null,error:y(l)})}return!0}watch(t,s){const l=t.timeoutMs??A,a=t.spec.promptStdin===!0,p=t.spec.args(t.sessionId,a?"":t.prompt),u=a&&process.platform==="win32"&&!/[\s"\\/]/.test(t.bin),E=(t.detached??!0)&&!u,m={cwd:t.cwd,detached:E,windowsHide:!0,shell:u,stdio:[a?"pipe":"ignore","pipe","pipe"],env:(()=>{const e={...process.env,WEAVE_HOOK_DISPATCH:"1"};return delete e.CLAUDE_CODE_CHILD_SESSION,e})()},r=u?this.spawnImpl([t.bin,...p].join(" "),[],m):this.spawnImpl(t.bin,p,m);if(r.pid!==void 0&&this.livePids.set(t.sessionId,r.pid),a){r.stdin?.on("error",()=>{});try{r.stdin?.write(t.prompt),r.stdin?.end()}catch{}}const I=[],h=[];let w=0,S=0;const v=(e,n,o)=>{if(n>=T)return n;const c=T-n;return e.push(o.length>c?o.subarray(0,c):o),n+Math.min(o.length,c)},f=()=>Buffer.concat([...I,...h]).toString("utf8"),M=()=>{const e=Buffer.concat(h).toString("utf8");return e.length>_?e.slice(-_):e};r.stdout?.on("data",e=>{w=v(I,w,e)}),r.stderr?.on("data",e=>{S=v(h,S,e)});const d=l>0?setTimeout(()=>{if(r.pid!==void 0)try{this.killImpl(r.pid)}catch{}this.settle(t,s,{status:"timeout",output:f(),error:`Timeout after ${l}ms`})},l):null;r.on("error",e=>{d!==null&&clearTimeout(d),this.settle(t,s,{status:"failed",output:f(),error:y(e)})}),r.on("exit",(e,n)=>{d!==null&&clearTimeout(d);const o=f();if(e===0){this.settle(t,s,{status:"succeeded",output:o,error:null});return}const c=e!==null?`exit ${e}`:`exit signal ${n??"unknown"}`,g=M();this.settle(t,s,{status:"failed",output:o,error:g?`${c}
+${g}`:c})})}settle(t,s,l){if(!s.settled){s.settled=!0,this.active.delete(t.sessionId),this.livePids.delete(t.sessionId);try{t.onSettle(l)}catch{}}}}export function defaultKill(i){if(process.platform==="win32"){try{k("taskkill",["/PID",String(i),"/T","/F"],{windowsHide:!0,stdio:"ignore"}).on("error",()=>{})}catch{}return}try{process.kill(-i,"SIGKILL")}catch{try{process.kill(i,"SIGKILL")}catch{}}}function y(i){return i instanceof Error?i.message:String(i)}

package/node_modules/@weavecode/server/dist/hooks/inbox-socket.d.ts

@@ -0,0 +1,52 @@
+import type { PromptInboxSpec } from '@weavecode/harness';
+/**
+ * 会话本地收件箱「通用传输」：连上 harness 给的地址 → 写 harness 组好的帧 → 关。
+ *
+ * **协议不在本模块**：帧格式、键名、平台认证要求全归 harness 的 `PromptInboxSpec`
+ * （claude 的 inbox socket 规格见 weave-harness/src/claude/prompt-inbox.ts）——本模块
+ * 只做「连、写、关、超时」这类与 harness 无关的机械动作，其他 harness 有同类机制时
+ * 只需声明自己的 spec。
+ *
+ * 成功 = 已写进地址并关闭连接（**不等于**对方已读：接收侧可能 Held/Refused）。
+ * 失败（连不上/超时/该平台缺凭据）→ reject，调用方回落中继/终端/队列。
+ */
+export interface InboxTarget {
+    /** 会话自己的直投地址（hook 旁路上报；`uds:` 前缀可有可无）。 */
+    socket: string;
+    /** 会话自己的凭据（无 = null，能否投由 spec 的平台要求决定）。 */
+    token: string | null;
+}
+export interface InboxDeliveryOptions {
+    /** 连接 + 写入总超时；缺省 3000ms（接收侧自有关闭上限 30s，我们更严，防挂死）。 */
+    timeoutMs?: number;
+    platform?: string;
+}
+/** `/status` 的 Peer address 带 `uds:` 前缀；env 里不带。两种都接受。 */
+export declare function inboxSocketPathOf(socket: string): string;
+export declare function deliverViaInboxSocket(spec: PromptInboxSpec, target: InboxTarget, text: string, options?: InboxDeliveryOptions): Promise<void>;
+/** 直投凭据落盘文件名（放 `<dataDir>/hooks/` 下；装配侧拼路径用同一常量）。 */
+export declare const INBOX_TARGETS_FILE = "inbox-targets.json";
+/**
+ * sessionId → 该会话的 inbox 目标：由 hook 事件旁路上报（hook 进程是会话自己的 child，
+ * 继承会话导出的 env），并落 `<dataDir>/hooks/inbox-targets.json`（0600，与 auth.json
+ * 同口径的非 UI 面）。**凭据不进 payload、不落库、不进 UI、不写日志**。
+ *
+ * 为什么要落盘：凭据活在**会话进程**里（socket 由它托管、token 每进程一份），daemon
+ * 重启不动它们——只落 daemon 自己的记忆。于是「重启后首条手动消息只能走终端/中继」
+ * 这个窗口消失（原先要等下一次 hook 事件把凭据带回来）。会话自己 resume/重启换了
+ * socket（旧值即废）时，覆盖前那一刻只会**连不上 → 回落**，不猜不误投；新值随下一次
+ * hook 事件覆盖写回。会话删除/归档时 forget（落盘行一并清）。
+ */
+export declare class InboxSocketRegistry {
+    private readonly file?;
+    private readonly bySession;
+    /** 上次落盘的内容（hook 每次事件都上报，值没变就不重写盘）。 */
+    private persisted;
+    constructor(file?: string | undefined);
+    /** 上报/刷新（hook 每次事件都会带，覆盖写即最新）。socket 为空 = 该会话没有可用 inbox。 */
+    set(sessionId: string, target: InboxTarget | null): void;
+    get(sessionId: string): InboxTarget | undefined;
+    forget(sessionId: string): void;
+    /** 原子写（临时文件 + rename）+ 0600（Windows 上 chmod 近似 no-op，无害）。 */
+    private persist;
+}

package/node_modules/@weavecode/server/dist/hooks/inbox-socket.js

@@ -0,0 +1,2 @@
+import a from"node:net";import{chmodSync as y,mkdirSync as d,readFileSync as k,renameSync as S,writeFileSync as b}from"node:fs";import{dirname as x}from"node:path";export function inboxSocketPathOf(s){return s.startsWith("uds:")?s.slice(4):s}export function deliverViaInboxSocket(s,t,e,o={}){const c=o.platform??process.platform,n=o.timeoutMs??3e3,l=inboxSocketPathOf(t.socket);return s.requiresAuthOn(c)&&!t.token?Promise.reject(new Error(`inbox delivery requires a token on platform "${c}"`)):new Promise((p,m)=>{const h=s.frame({token:t.token,text:e});let f=!1;const u=i=>{f||(f=!0,r.destroy(),m(i))},r=a.connect(l);r.setTimeout(n),r.on("timeout",()=>u(new Error(`inbox socket timeout after ${n}ms`))),r.on("error",i=>u(i)),r.on("connect",()=>{r.write(h,i=>{i?u(i):r.end()})}),r.on("close",()=>{f||(f=!0,p())})})}export const INBOX_TARGETS_FILE="inbox-targets.json";function O(s){try{const t=JSON.parse(k(s,"utf8"));if(typeof t!="object"||t===null)return{};const e={};for(const[o,c]of Object.entries(t)){const n=c;typeof n?.socket!="string"||!n.socket||(e[o]={socket:n.socket,token:typeof n.token=="string"&&n.token?n.token:null})}return e}catch{return{}}}export class InboxSocketRegistry{file;bySession;persisted;constructor(t){this.file=t;const e=t?O(t):{};this.bySession=new Map(Object.entries(e)),this.persisted=JSON.stringify(e)}set(t,e){const o=this.bySession.get(t);if(!e?.socket){o&&(this.bySession.delete(t),this.persist());return}o&&o.socket===e.socket&&o.token===e.token||(this.bySession.set(t,e),this.persist())}get(t){return this.bySession.get(t)}forget(t){this.bySession.delete(t)&&this.persist()}persist(){if(!this.file)return;const t=JSON.stringify(Object.fromEntries(this.bySession));if(t!==this.persisted)try{d(x(this.file),{recursive:!0});const e=`${this.file}.tmp`;b(e,`${t}
+`,{encoding:"utf8",mode:384}),S(e,this.file),y(this.file,384),this.persisted=t}catch{}}}

package/node_modules/@weavecode/server/dist/hooks/inbox-worker.d.ts

@@ -0,0 +1,127 @@
+import { Worker } from 'node:worker_threads';
+import { type EventSource } from '@weavecode/harness';
+import { HookEventRepository, type HookEventInput } from '../repositories/hook-events.js';
+import { ProjectRepository } from '../repositories/projects.js';
+import { SessionRepository } from '../repositories/sessions.js';
+import type { HookEventBus } from './bus.js';
+import type { HookDispatcher } from './dispatcher.js';
+import type { WatchEngine } from './watch-engine.js';
+import type { SequenceEngine } from './sequence-engine.js';
+import type { MessageDeliverer } from './message-deliverer.js';
+import type { QuestionTracker } from './question-tracker.js';
+/**
+ * inbox 消费线程（hook 文件化管道的 daemon 侧）：hook-handler.cjs 把事件追加到
+ * `<dataDir>/hooks/inbox/<shard>.jsonl`（行形 `{v, token, report}`，纯传输缓冲、
+ * 入库即删）；本模块在 worker_threads 里认领→入库，主线程收 postMessage 后补
+ * SSE/dispatcher/outbox。
+ *
+ * 竞争协议（复用 spool 的 rename-claim）：rename 原子先到先得，输家 ENOENT 空手；
+ * 崩在半途留下 `.claim.jsonl` 下轮先清。入库失败的行留盘重试，连续失败 parked
+ * 为 `.failed.jsonl` 防毒丸热循环。行内 token 解析项目（项目已删 → 丢行，同
+ * 旧 /hooks 401 语义；归档项目同样丢行——server 不消费，行即焚）；不可归因
+ * 的坏行直接丢（重试无意义）。
+ *
+ * **shard 按项目 token 分片**（hook-handler 认 token 不认会话）⇒ 同一 claim 里
+ * 常混着**同项目多个会话**的行。故凡会话级事实（inbox 凭据、pane env、改名回执）
+ * 一律**逐行**取，不得按组聚合——取整组最后一个会把 A 会话的 socket 记到 B 头上，
+ * 而直投照这个映射送，消息就落进别的会话（实事故，见 docs/DECISIONS.md）。
+ */
+export declare const INBOX_TICK_MS = 200;
+export declare const INBOX_CLAIM_SUFFIX = ".claim.jsonl";
+export declare const INBOX_FAILED_SUFFIX = ".failed.jsonl";
+/** worker → 主线程的入库记录（结构化克隆友好，全是 plain JSON）。 */
+export interface InboxRecord {
+    eventId: number;
+    projectId: number;
+    input: HookEventInput;
+    /** hook-handler 的改名交付回执（未下发 = null）——透传 dispatcher 落定 pending。 */
+    deliveredTitle?: string | null;
+    /**
+     * 该会话的 inbox 直投凭据（hook 进程是会话自己的 child，继承这两个 env）。
+     * **逐行字段**（同 claim 里各会话的 socket 不同）；**旁路字段：不进 payload、
+     * 不落库**——主线程只放内存供 layer① 直投用。
+     */
+    messaging?: {
+        socket: string;
+        token: string | null;
+    } | null;
+    /**
+     * 该会话所在终端 pane 的定位 env（hook 进程生在会话自己的 pane 里）。
+     * **逐行字段**（同一 claim 里不同会话的 pane 不同——错配会把键序打进别的会话
+     * 的模态框）；同样不进 payload、不落库。
+     */
+    terminalEnv?: Record<string, string> | null;
+}
+export interface InboxDrainDeps {
+    hooksDir: string;
+    projects: Pick<ProjectRepository, 'getByToken'>;
+    hookEvents: HookEventRepository;
+    hookSessions: SessionRepository;
+    adapters: readonly EventSource[];
+}
+/**
+ * 一轮消费，两阶段（顺序是安全前提）：
+ * ① 先清所有残留 claim（上轮崩在半途的）；② 再把活文件 rename 认领、逐个消费。
+ * 先 ① 后 ② 保证 rename 不会覆盖尚未消费的 claim（rename 在 POSIX 下静默覆盖
+ * ＝丢数据）；认领失败的（另一进程先到 / 文件被删）本轮跳过。
+ */
+export declare function drainInboxOnce(deps: InboxDrainDeps, attempts?: Map<string, number>): InboxRecord[];
+/**
+ * 停放文件复活（启动时一次）：`.failed.jsonl` 是「连续失败达上限」的保护区，
+ * 停在盘上等人工处理。但多数失败是瞬时争用（多写者/重建 WAL）——进程重启后
+ * 给它新一轮机会：rename 成 claim，消费线程第一阶段就会先消费它；再失败会重新
+ * 停放，不会热循环。
+ */
+export declare function unparkFailedInbox(hooksDir: string): number;
+export interface IngestedHandlerDeps {
+    projects: Pick<ProjectRepository, 'getById'>;
+    hooksDir: string;
+    bus?: HookEventBus;
+    dispatcher?: HookDispatcher;
+    /** 空闲订阅引擎（session-orchestration 批 2）：见目标会话的 idleSignals 即 fire。 */
+    watchEngine?: Pick<WatchEngine, 'onEvent'>;
+    /** 序列引擎（批 3）：inject 步的完成判据 = 目标 idleSignals 事件。 */
+    sequenceEngine?: Pick<SequenceEngine, 'onEvent'>;
+    /** prompt 队列冲洗 + inbox 直投凭据上报 + 投递回执（消息域重塑）；缺省功能降级。 */
+    messagePipe?: Pick<MessageDeliverer, 'hasQueued' | 'flushSession'> & {
+        /** hook 旁路上报的会话 inbox 目标（内存态）。 */
+        noteInboxSocket?(sessionId: string, target: {
+            socket: string;
+            token: string | null;
+        } | null): void;
+        /** hook 旁路上报的会话 pane 定位 env（内存态；层② 精确定位用）。 */
+        notePaneEnv?(sessionId: string, env: Record<string, string>): void;
+        /** UPS 事件 = 投递回执判据（prompt 原文与在途条目匹配）；返回命中消息的随附图 id。
+         *  `eventId` 随回执记下（对话面按它把投递行挂到这条事件的气泡上）。 */
+        onSessionPrompt?(sessionId: string, prompt: string, eventId?: number): string[];
+        /** 会话退出事件（`HARNESS_LIFECYCLE[<harness>].sessionExit`）= 旁路事实作废点。 */
+        sessionExited?(sessionId: string): void;
+    };
+    /** 阻塞式问答跟踪（toolName 不进帧域，挂点在此）；缺省不跟踪。 */
+    questionTracker?: Pick<QuestionTracker, 'onEvent'>;
+    /** 会话转录路径上报（中断态探测用；转录路径在 payload 里，帧域不带）+ 换模型落定。 */
+    sessionProbe?: {
+        noteTranscript(sessionId: string, path: string | null): void;
+        noteModel(sessionId: string, model: string): void;
+    };
+    /** 上传件落库面：回执命中时把该消息的随附图挂到开轮事件上（气泡缩略图）。 */
+    uploads?: {
+        linkToEvent(eventId: number, uploadIds: readonly string[]): void;
+    };
+}
+/**
+ * worker 入库记录的主线程消费：每条补发 `event.ingested` SSE（任务面板实时），
+ * 再进 dispatcher（manual/webhook/log/plugin、会话标题双向）与 watch 引擎
+ * （空闲订阅触发，消息域与规则域平行），插件注入产出写 outbox 顺延给下一次 hook 事件。
+ */
+export declare function handleIngestedRecords(deps: IngestedHandlerDeps, records: InboxRecord[]): void;
+export interface InboxWorkerOptions {
+    dbPath: string;
+    hooksDir: string;
+    tickMs?: number;
+}
+/**
+ * 起 inbox 消费线程。自举 URL 即本文件（tsx 直跑 .ts、tsc 产物跑 .js 都成立；
+ * daemon 由 `node --import tsx` 起，worker 继承 execArgv 获得同样的 TS 能力）。
+ */
+export declare function startInboxWorker(opts: InboxWorkerOptions): Worker;

package/node_modules/@weavecode/server/dist/hooks/inbox-worker.js

@@ -0,0 +1,4 @@
+import{existsSync as g,readdirSync as h,readFileSync as k,renameSync as f,unlinkSync as j,writeFileSync as b}from"node:fs";import{join as a}from"node:path";import{isMainThread as T,parentPort as x,Worker as E,workerData as I}from"node:worker_threads";import{createRuntimeRegistry as S,frameFacts as w,switchedModelOf as M}from"@weavecode/harness";import{HARNESS_LIFECYCLE as O,isHarness as F}from"@weavecode/core";import{openDatabase as W}from"../db/db.js";import{HookEventRepository as D}from"../repositories/hook-events.js";import{ProjectRepository as P}from"../repositories/projects.js";import{SessionRepository as R}from"../repositories/sessions.js";import{appendOutbox as _}from"./mirror.js";export const INBOX_TICK_MS=200,INBOX_CLAIM_SUFFIX=".claim.jsonl",INBOX_FAILED_SUFFIX=".failed.jsonl";const L=5;export function drainInboxOnce(n,t=new Map){const e=a(n.hooksDir,"inbox");let i;try{i=h(e)}catch{return[]}const s=[];for(const c of i)c.endsWith(INBOX_FAILED_SUFFIX)||c.endsWith(".tmp")||c.endsWith(INBOX_CLAIM_SUFFIX)||c.endsWith(".jsonl")&&s.push(c);const o=[];for(const c of i)c.endsWith(INBOX_CLAIM_SUFFIX)&&o.push(...v(n,a(e,c),t));for(const c of s){const l=a(e,`${c.slice(0,-6)}${INBOX_CLAIM_SUFFIX}`);if(!g(l)){try{f(a(e,c),l)}catch{continue}o.push(...v(n,l,t))}}return o}function v(n,t,e){let i;try{i=k(t,"utf8").split(`
+`)}catch{return[]}const s=new Map;for(const u of i){const d=u.trim();if(!d)continue;const r=C(d);if(!r)continue;const p=s.get(r.token)??{lines:[],inputs:[],delivered:[],terminals:[],messaging:[]};if(p.lines.push(d),p.project||(p.project=n.projects.getByToken(r.token),s.set(r.token,p)),!p.project||p.project.archivedAt)continue;const m=r.report&&typeof r.report=="object"?n.adapters.find(y=>y.source===r.report.source):void 0;if(!(!m||!r.report.eventType))try{p.inputs.push(m.normalize(r.report,p.project.id)),p.delivered.push(r.report.deliveredTitle??null),p.terminals.push(r.terminalEnv),p.messaging.push(r.messaging)}catch{}}const o=[],c=[];for(const u of s.values())if(!(!u.project||u.inputs.length===0))try{const d=A(n,u.project,u.inputs);for(let r=0;r<u.inputs.length;r++)o.push({eventId:d[r],projectId:u.project.id,input:u.inputs[r],deliveredTitle:u.delivered[r]??null,messaging:u.messaging[r]??null,terminalEnv:u.terminals[r]??null})}catch{c.push(...u.lines)}if(c.length===0){e.delete(t);try{j(t)}catch{}return o}const l=(e.get(t)??0)+1;if(e.set(t,l),l>=L){e.delete(t);try{f(t,t.replace(INBOX_CLAIM_SUFFIX,INBOX_FAILED_SUFFIX))}catch{}return o}try{b(t,c.join(`
+`)+`
+`)}catch{}return o}function A(n,t,e){const i=n.hookEvents.insertMany(e),s=new Set;for(const o of e)!o.sessionId||s.has(o.sessionId)||(s.add(o.sessionId),n.hookSessions.touch(o.sessionId,t.id));return i}function C(n){try{const t=JSON.parse(n);if(!t||typeof t.token!="string"||!t.token||!t.report||typeof t.report!="object")return null;const e=t.messaging?.socket,i=typeof e=="string"&&e?{socket:e,token:typeof t.messaging?.token=="string"?t.messaging.token:null}:null;return{token:t.token,report:t.report,messaging:i,terminalEnv:N(t.terminal)}}catch{return null}}function N(n){if(typeof n!="object"||n===null)return null;const t={};for(const[e,i]of Object.entries(n))typeof i=="string"&&i&&(t[e]=i);return Object.keys(t).length>0?t:null}export function unparkFailedInbox(n){const t=a(n,"inbox");let e;try{e=h(t)}catch{return 0}let i=0;for(const s of e){if(!s.endsWith(INBOX_FAILED_SUFFIX))continue;const o=a(t,`${s.slice(0,-INBOX_FAILED_SUFFIX.length)}${INBOX_CLAIM_SUFFIX}`);if(!g(o))try{f(a(t,s),o),i++}catch{}}return i}export function handleIngestedRecords(n,t){for(const e of t){const i=n.projects.getById(e.projectId);if(!i)continue;let s=null;try{s=JSON.parse(e.input.payload)}catch{s=null}if(n.bus?.emit({kind:"event.ingested",eventId:e.eventId,projectId:i.id,sessionId:e.input.sessionId??null,eventType:e.input.eventType,...w(s),at:new Date().toISOString()}),e.input.sessionId){n.questionTracker?.onEvent({sessionId:e.input.sessionId,source:e.input.source,payload:s}),n.watchEngine?.onEvent({sessionId:e.input.sessionId,eventType:e.input.eventType,source:e.input.source}),n.sequenceEngine?.onEvent({sessionId:e.input.sessionId,eventType:e.input.eventType,source:e.input.source}),e.messaging&&n.messagePipe?.noteInboxSocket?.(e.input.sessionId,e.messaging),n.sessionProbe?.noteTranscript(e.input.sessionId,s?.transcriptPath??null);const o=M(e.input.eventType,s?.raw);if(o&&n.sessionProbe?.noteModel?.(e.input.sessionId,o),e.terminalEnv&&n.messagePipe?.notePaneEnv?.(e.input.sessionId,e.terminalEnv),e.input.eventType==="UserPromptSubmit"){const l=n.messagePipe?.onSessionPrompt?.(e.input.sessionId,B(s)??"",e.eventId)??[];l.length>0&&n.uploads?.linkToEvent(e.eventId,l)}const c=F(e.input.source)?O[e.input.source].sessionExit:null;c!==null&&e.input.eventType===c&&n.messagePipe?.sessionExited?.(e.input.sessionId),n.messagePipe?.hasQueued(e.input.sessionId)&&n.messagePipe.flushSession(e.input.sessionId)}n.dispatcher&&n.dispatcher.onIngest({eventId:e.eventId,project:i,sessionId:e.input.sessionId??null,payload:s??{eventType:e.input.eventType,toolName:null,toolInput:null,toolResponse:null,cwd:null,transcriptPath:null,raw:null},source:e.input.source,deliveredTitle:e.deliveredTitle??null}).then(o=>{o.deferred&&e.input.sessionId&&_(n.hooksDir,i.token,[{sessionId:e.input.sessionId,text:o.deferred}])}).catch(()=>{})}}function B(n){const t=n?.raw;return typeof t?.prompt=="string"&&t.prompt?t.prompt:null}export function startInboxWorker(n){return new E(new URL(import.meta.url),{workerData:{inboxWorker:!0,...n}})}if(!T&&I?.inboxWorker===!0){const n=I,t=W(n.dbPath),e={hooksDir:n.hooksDir,projects:new P(t),hookEvents:new D(t),hookSessions:new R(t),adapters:S().byCapability("events").flatMap(o=>o.events??[])},i=new Map,s=()=>{try{const o=drainInboxOnce(e,i);o.length>0&&x?.postMessage(o)}catch(o){console.error("[weave] inbox drain failed:",o)}};s(),setInterval(s,n.tickMs??INBOX_TICK_MS)}

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

@@ -0,0 +1,37 @@
+/** 注入指令的防递归标记：inject/manual 渲染的指令携带它，采集侧据此跳过自动规则。 */
+export declare const DISPATCH_MARKER = "<!--weave-dispatch-->";
+/** 反斜杠归一为 posix（Windows 的 file_path 是原生分隔符）。 */
+export declare function normalizePosix(p: string): string;
+/**
+ * glob 编译为 RegExp：双星号+分隔符匹配任意层前缀、双星号匹配任意段、
+ * 星号匹配单段内、问号匹配单字符。大小写不敏感（Windows 路径）。
+ */
+export declare function globToRegex(glob: string): RegExp;
+/** file_path 与 glob 匹配（两侧都归一为 posix）。 */
+export declare function matchGlob(filePath: string, glob: string): boolean;
+/** 从 toolInput 提取文件路径（Write/Edit 的 file_path、NotebookEdit 的 notebook_path）。 */
+export declare function extractFilePath(toolInput: unknown): string | null;
+/**
+ * 多项目交互判定：target 落在**其他**已注册项目根下（而非当前项目自身）。
+ * currentPath 排除自身；无命中返回 false。
+ */
+export declare function isCrossProjectPath(target: string, currentPath: string, otherProjectPaths: string[]): boolean;
+/**
+ * 渲染指令模板：`{event}` `{tool}` `{file}` `{cwd}` `{session}` `{project}` `{rule}`
+ * 未知占位原样保留（缺参可见，不渲染 undefined）。
+ */
+export declare function renderTemplate(template: string, vars: Record<string, string | null | undefined>): string;
+/** 事件 → 模板变量。 */
+export declare function templateVars(input: {
+    event: string;
+    tool: string | null;
+    filePath: string | null;
+    cwd: string | null;
+    session: string | null;
+    project: string;
+    rule: string;
+}): Record<string, string | null>;
+/** toolInput.file_path 是否落在任一 glob（posix 归一后比较）。 */
+export declare function matchesAnyGlob(filePath: string, globs: string[]): boolean;
+/** 项目根 basename（会话/指令里展示用）。 */
+export declare function projectLabel(projectPath: string): string;

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

@@ -0,0 +1 @@
+import f from"node:path";export const DISPATCH_MARKER="<!--weave-dispatch-->";const s=e=>process.platform==="win32"?e.toLowerCase():e;export function normalizePosix(e){return e.replace(/\\/g,"/")}function a(e){return/[.+^${}()|[\]\\]/.test(e)?`\\${e}`:e}const l=new Map;export function globToRegex(e){const r=l.get(e);if(r)return r;let t="";for(let n=0;n<e.length;n++){const c=e[n];c==="*"?e[n+1]==="*"?(n++,e[n+1]==="/"?(n++,t+="(?:.*/)?"):t+=".*"):t+="[^/]*":c==="?"?t+="[^/]":t+=a(c)}const o=new RegExp(`^${t}$`,"i");return l.set(e,o),o}export function matchGlob(e,r){return globToRegex(r).test(normalizePosix(e))}export function extractFilePath(e){if(typeof e!="object"||e===null)return null;const r=e;for(const t of["file_path","notebook_path","filePath"]){const o=r[t];if(typeof o=="string"&&o.length>0)return o}return null}function i(e,r){const t=s(normalizePosix(e)),o=s(normalizePosix(r).replace(/\/+$/,""));return t===o||t.startsWith(`${o}/`)}export function isCrossProjectPath(e,r,t){const o=s(normalizePosix(r));return i(e,r)?!1:t.some(n=>s(normalizePosix(n))!==o&&i(e,n))}export function renderTemplate(e,r){return e.replace(/\{(\w+)\}/g,(t,o)=>{const n=r[o];return n==null?t:String(n)})}export function templateVars(e){return{event:e.event,tool:e.tool,file:e.filePath?normalizePosix(e.filePath):null,cwd:e.cwd?normalizePosix(e.cwd):null,session:e.session,project:e.project,rule:e.rule}}export function matchesAnyGlob(e,r){return r.some(t=>matchGlob(e,t))}export function projectLabel(e){return f.basename(normalizePosix(e).replace(/\/+$/,""))||e}