@weavecode/weave 0.1.2 → 0.1.3

package/node_modules/@weavecode/server/dist/hooks/dashboard-rate.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 仪表盘事件速率的进程内快照：每条 ingest 往当前 **10 秒桶** +1，保留 24 小时
+ * （最多 8,640 桶，几十 KB）。读侧 O(图上的点数)，不再按请求扫 `hook_events`。
+ *
+ * 首次读取（daemon 刚起、桶还空）由库回填一次：拉最近一小时的逐秒分布折进桶。
+ * 回填与实时帧都可能在数同一批事件，合并取 **max**（两侧各自只增，同一桶里
+ * 「库里有的」∪「起进程后才计到的」用 max 近似不会翻倍）。
+ */
+export declare const RATE_BUCKET_MS = 10000;
+export declare const RATE_RETAIN_MS: number;
+export declare class DashboardRateCache {
+    /** 桶起点(ms) → 事件数。 */
+    private readonly buckets;
+    private seeded;
+    private lastPrune;
+    /** 总量随 ingest 累加（重启后首次读从库补种）。 */
+    private events;
+    private today;
+    private dayKey;
+    /** 首读回填是否已做过（route 决定要不要拉库）。 */
+    get isSeeded(): boolean;
+    /** 一条已入库事件（主线程 ingest 路径，O(1)）。 */
+    record(now?: number): void;
+    /** 总量（事件总数/今日）；sessions/projects 归调用方另取。 */
+    get totals(): {
+        events: number;
+        today: number;
+    };
+    /** 重启后补种总量基线（只增不减，别覆盖已累计的增量）。 */
+    seedTotals(events: number, today: number): void;
+    /** 最近 `steps` 个桶（含当前），用于增量帧。 */
+    recentBuckets(steps: number, now?: number): Array<{
+        at: string;
+        n: number;
+    }>;
+    /** 回填一次：`series` 是库里逐秒键（`YYYY-MM-DDTHH:MM:SS`，UTC）。 */
+    seed(series: readonly {
+        at: string;
+        n: number;
+    }[]): void;
+    /** 连续桶的计数（缺桶 = 0），`start` 必须对齐到桶起点。 */
+    bucketsFor(start: number, steps: number): number[];
+    /** 24h 外丢弃；节流到每分钟一次（写在热路径上，别每条都扫表）。 */
+    private prune;
+}

package/node_modules/@weavecode/server/dist/hooks/dashboard-rate.js

@@ -0,0 +1 @@
+export const RATE_BUCKET_MS=1e4,RATE_RETAIN_MS=864e5;const h=6e4;export class DashboardRateCache{buckets=new Map;seeded=!1;lastPrune=0;events=0;today=0;dayKey="";get isSeeded(){return this.seeded}record(e=Date.now()){const t=Math.floor(e/1e4)*1e4;this.buckets.set(t,(this.buckets.get(t)??0)+1),this.events+=1;const s=new Date(e).toDateString();s!==this.dayKey&&(this.dayKey=s,this.today!==0&&(this.today=0)),this.today+=1,this.prune(e)}get totals(){return{events:this.events,today:this.today}}seedTotals(e,t){this.events=Math.max(this.events,e),this.today=Math.max(this.today,t),this.dayKey=new Date().toDateString()}recentBuckets(e,t=Date.now()){const s=Math.floor(t/1e4)*1e4-(e-1)*1e4;return Array.from({length:e},(o,n)=>{const a=s+n*1e4;return{at:new Date(a).toISOString().slice(0,19),n:this.buckets.get(a)??0}})}seed(e){const t=new Map;for(const{at:s,n:o}of e){const n=Date.parse(`${s}Z`);if(!Number.isFinite(n))continue;const a=Math.floor(n/1e4)*1e4;t.set(a,(t.get(a)??0)+o)}for(const[s,o]of t)this.buckets.set(s,Math.max(this.buckets.get(s)??0,o));this.seeded=!0}bucketsFor(e,t){return Array.from({length:t},(s,o)=>this.buckets.get(e+o*1e4)??0)}prune(e){if(e-this.lastPrune<6e4)return;this.lastPrune=e;const t=e-864e5;for(const s of this.buckets.keys())s<t&&this.buckets.delete(s)}}

package/node_modules/@weavecode/server/dist/hooks/decision-judge.d.ts

@@ -0,0 +1,14 @@
+import type { ConditionJudge } from './orchestration-engine.js';
+export interface DecisionJudgeConfig {
+    baseUrl: string;
+    model: string;
+    apiKey: string;
+}
+export declare function createDecisionConditionJudge(deps: {
+    /** 每次判断现读（settings 表 + key 文件）——改配置即时生效，不用重启 daemon。 */
+    config: () => Promise<DecisionJudgeConfig | null>;
+    /** 回落判断（装配侧 = fork 子 Agent）。 */
+    fallback: ConditionJudge;
+    fetchImpl?: typeof fetch;
+    timeoutMs?: number;
+}): ConditionJudge;

package/node_modules/@weavecode/server/dist/hooks/decision-judge.js

@@ -0,0 +1 @@
+const p=.7,y=.3,k=1e4;export function createDecisionConditionJudge(s){const r=(t,e)=>({...t,source:"decision-model",...e!==null?{detail:`P(yes)=${e}`}:{}}),c=t=>t>=.7?r({ok:!0},t):t<=.3?r({ok:!1,reason:"condition answered no"},t):{ok:!1};return{async judge(t){const e=t.upstream;if(!e)return{...await s.fallback.judge(t),source:"fork"};const i=await s.config();if(!i)return{...await s.fallback.judge(t),source:"fork"};let o=null;try{o=await m(i,t.condition,e,s)}catch{o=null}if(o===null)return{...await s.fallback.judge(t),source:"fork"};const n=c(o);return!n.ok&&n.source!=="decision-model"?{...await s.fallback.judge(t),source:"fork"}:n},async judgeBatch(t){if(!t.upstream)return Promise.all(t.items.map(async n=>({...await s.fallback.judge({sessionId:t.sessionId,condition:n.condition,upstream:null}),source:"fork"})));const e=await s.config();if(!e)return Promise.all(t.items.map(async n=>({...await s.fallback.judge({sessionId:t.sessionId,condition:n.condition,upstream:t.upstream}),source:"fork"})));const i={};for(const n of t.items)i[n.key]={type:"noul",instructions:n.condition};let o=null;try{o=await l(e,i,t.upstream,s)}catch{o=null}return o?Promise.all(t.items.map(async n=>{const a=o[n.key];return typeof a!="number"||!Number.isFinite(a)?{...await s.fallback.judge({sessionId:t.sessionId,condition:n.condition,upstream:t.upstream}),source:"fork"}:c(a)})):Promise.all(t.items.map(async n=>({...await this.judge({sessionId:t.sessionId,condition:n.condition,upstream:t.upstream})})))}}}async function m(s,r,c,t){return(await l(s,{proceed:{type:"noul",instructions:r}},c,t))?.proceed??null}async function l(s,r,c,t){const e=new AbortController,i=setTimeout(()=>e.abort(),t.timeoutMs??1e4);try{const o=await(t.fetchImpl??fetch)(`${s.baseUrl.replace(/\/+$/,"")}/v1/systemone`,{method:"POST",headers:{authorization:`Bearer ${s.apiKey}`,"content-type":"application/json"},body:JSON.stringify({model:s.model,state:c,questions:r}),signal:e.signal});if(!o.ok)return null;const n=(await o.json()).answers;if(!n||typeof n!="object")return null;const a={};for(const[d,f]of Object.entries(n)){const u=f?.noul;typeof u=="number"&&Number.isFinite(u)&&(a[d]=u)}return Object.keys(a).length>0?a:null}finally{clearTimeout(i)}}

package/node_modules/@weavecode/server/dist/hooks/delivery/ack-gate.d.ts

@@ -0,0 +1,109 @@
+import type { PipeMessage } from '../message-deliverer.js';
+/**
+ * 回执闸与暂停闸（消息域投递的「1 送 1 回」秩序）：
+ *
+ * - **回执闸**（`awaitingAck`）：同会话队头在等它的 UPS 回执——终端层把一条贴进
+ *   输入框后必须等回执才发下一条，再贴一份会在同一个框里叠成一段（两条并一条提交）。
+ * - **暂停闸**（`stalled`）：未回执超窗 / 投递失败 → 该会话队列冲洗暂停；解除 =
+ *   回执命中 / 手动重发 / 到点自动清除（「已发出却没回执」的行到点直接从队列清除）。
+ *
+ * 两个闸的状态都活在宿主（MessageDeliverer）的 Map 里，本模块只承载**判定与计时
+ * 逻辑**；宿主以回调形式提供状态读写（`store`），闸自己不持有数据——测试可以直接
+ * 注入假 store。
+ */
+/** 暂停闸成因：`unacked` = 已发出却没等到回执；`failed` = 投递失败。 */
+export type StallReason = 'unacked' | 'failed';
+export interface AckGateTimes {
+    /** 未回执判 stall 的等待窗（ms）。 */
+    ackStallMs: number;
+    /** stall 自动解除窗（ms）；「已发出却没回执」的行到点从队列清除。 */
+    ackStallReleaseMs: number;
+    /** 斜杠命令的回执宽限（ms）：内建命令不发 UPS，宽限过即按已送达收。 */
+    commandAckGraceMs: number;
+}
+export interface AckGateStore {
+    /** 队头在等的消息 id（sessionId → messageId）。 */
+    awaitingAck: Map<string, string>;
+    /** 暂停闸（sessionId → 成因）。 */
+    stalled: Map<string, {
+        messageId: string;
+        reason: StallReason;
+    }>;
+    /** 内存消息行（闸读写它的 acked/status/stalled/releaseAt）。 */
+    memory: Map<string, PipeMessage>;
+}
+export interface AckGateEvents {
+    /** 消息域帧（message.stalled 等）；失败静默由宿主的 bus 包装保证。 */
+    emit(message: {
+        kind: string;
+        [key: string]: unknown;
+    }): void;
+}
+export declare class AckGate {
+    private readonly store;
+    private readonly times;
+    private readonly events;
+    constructor(store: AckGateStore, times: AckGateTimes, events: AckGateEvents);
+    /** 等回执的那条已经落地（回执到 / 失败 / 行没了）→ 撤防，返回 true。 */
+    open(sessionId: string): boolean;
+    /** 队头在等回执？（send 的低延迟路径用：压着就只能排队。） */
+    awaiting(sessionId: string): boolean;
+    /** 队头在等的那条消息 id（重发「只补回车」判定用）。 */
+    headOf(sessionId: string): string | undefined;
+    /** 占住队头（投递出手即登记：下一条必须等它的回执）。 */
+    await(sessionId: string, messageId: string): void;
+    /** 撤防（回执命中 / 行被删 / 会话退出时）。 */
+    release(sessionId: string, messageId?: string): void;
+    /** 该会话是否处于暂停闸（冲洗入口的第一道检查）。 */
+    isStalled(sessionId: string): boolean;
+    /** 暂停闸成因行（重发判定 / 诊断面用）。 */
+    stallCause(sessionId: string): {
+        messageId: string;
+        reason: StallReason;
+    } | undefined;
+    /** 解除暂停闸（回执命中 / 手动重发 / 行删除时）。 */
+    clearStall(sessionId: string, messageId?: string): void;
+    /**
+     * 未回执闸布防：prompt 送达后 `ackStallMs` 内没等到 UPS 回执 → 暂停该会话队列。
+     * 斜杠命令走 `armCommandAck`（内建命令压根不发 UPS）。
+     */
+    armAckWatch(msg: PipeMessage): void;
+    /**
+     * 斜杠命令的回执收尾：给一个短窗口等 UPS——skill/插件命令会报，届时正常核销；
+     * 窗口过期还没回执 = 宿主内建命令（`/compact` 之类压根不发 UPS），按已送达收、
+     * 解闸续排，**不布防未回执闸**（否则压缩几分钟里整段显示「发送中」）。
+     */
+    armCommandAck(messageId: string, onRelease: (sessionId: string) => void): void;
+    /** 置闸：成因消息标记 stalled（常驻在途视图）+ message.stalled 帧（web 重拉）。 */
+    stall(sessionId: string, msg: PipeMessage, reason: StallReason): void;
+    /**
+     * 闸到点自动解除：回执一直不来 = 那条很可能压根没进对话（贴着文本按下去的时候
+     * 会话正在重启，输入框被清掉就是这样），闸不能因此把该会话的队列永久停住。
+     * 「已发出却没回执」的行到点**直接从队列清除**（用户裁决：正文只在这一行里，
+     * 窗口期就是给人看清与重发的）；投递失败的行留着等人重发，只解闸续排。
+     */
+    autoRelease(sessionId: string, messageId: string): void;
+    /** 到点清除 / 手动删除共用的收尾：摘行 + 解闸 + 撤防 + dismissed 帧 + 续排回调。 */
+    dropAndRelease(sessionId: string, messageId: string): void;
+    /** 闸解除后的续排钩子（宿主接 `scheduleFlushContinuation`）。 */
+    onAutoRelease?: (sessionId: string) => void;
+    /** 最近一次 `acknowledge` 是否命中（宿主据此决定要不要续排排空）。 */
+    hitLast: boolean;
+    /**
+     * 投递回执核销（UPS 到达）：prompt 原文与在途条目匹配即成真。一条 UPS 可以
+     * 核销多条在途（宿主把连发的几条合成一次提交）；返回命中消息的随附图 id。
+     * 比对规则：剥跨会话壳折叠空白后「包含」；短文本（< `ackMinText`）认**尾部相等**
+     * （层② 往框里追加，框里先在的内容只会垫在前面）；带图消息再去尽空白比一次。
+     */
+    acknowledge(sessionId: string, prompt: string, eventId: number | undefined, opts: {
+        ackMinText: number;
+    }): string[];
+    /** 会话退出：进程没了，这一条的回执再也不会到——撤防即可（死信落定归宿主）。 */
+    sessionExited(sessionId: string): void;
+    /** 测试/等待辅助：到点再解析（原实现内联在 awaitInboxReady 的轮询里）。 */
+    static sleep: (ms: number) => Promise<void>;
+}
+/** 回执比对归一：剥掉 Claude Code 给会话间消息裹的外壳再折叠空白。 */
+export declare function normalizePromptText(text: string): string;
+/** 带图消息的二次归一（粘贴处理器会把多行 chunk 用空串连起来）：去尽空白再比。 */
+export declare function stripSpace(text: string): string;

package/node_modules/@weavecode/server/dist/hooks/delivery/ack-gate.js

@@ -0,0 +1 @@
+const u=r=>new Promise(e=>setTimeout(e,r));export class AckGate{store;times;events;constructor(e,t,s){this.store=e,this.times=t,this.events=s}open(e){const t=this.store.awaitingAck.get(e);if(t===void 0)return!0;const s=this.store.memory.get(t);return s&&s.acked!==!0&&s.status!=="failed"&&s.status!=="timeout"?!1:(this.store.awaitingAck.delete(e),!0)}awaiting(e){return!this.open(e)}headOf(e){return this.store.awaitingAck.get(e)}await(e,t){this.store.awaitingAck.set(e,t)}release(e,t){if(t===void 0){this.store.awaitingAck.delete(e);return}this.store.awaitingAck.get(e)===t&&this.store.awaitingAck.delete(e)}isStalled(e){return this.store.stalled.has(e)}stallCause(e){return this.store.stalled.get(e)}clearStall(e,t){const s=this.store.stalled.get(e);s&&(t===void 0||s.messageId===t)&&this.store.stalled.delete(e)}armAckWatch(e){setTimeout(()=>{const t=this.store.memory.get(e.id);!t||t.acked||t.status!=="delivered"||this.stall(e.sessionId,t,"unacked")},this.times.ackStallMs).unref?.()}armCommandAck(e,t){setTimeout(()=>{const s=this.store.memory.get(e);!s||s.acked||s.status!=="delivered"||(this.store.memory.set(e,{...s,acked:!0}),this.release(s.sessionId,e),t(s.sessionId))},this.times.commandAckGraceMs).unref?.()}stall(e,t,s){this.store.stalled.set(e,{messageId:t.id,reason:s});const a=this.store.memory.get(t.id),o=a&&a.status==="delivered"&&a.acked!==!0?new Date(Date.now()+this.times.ackStallReleaseMs).toISOString():null;a&&this.store.memory.set(t.id,{...a,stalled:!0,releaseAt:o}),this.events.emit({kind:"message.stalled",messageId:t.id,sessionId:e,reason:s,at:new Date().toISOString()}),setTimeout(()=>this.autoRelease(e,t.id),this.times.ackStallReleaseMs).unref?.()}autoRelease(e,t){if(this.store.stalled.get(e)?.messageId!==t)return;const s=this.store.memory.get(t);if(s&&s.status==="delivered"&&s.acked!==!0){this.dropAndRelease(e,t);return}this.store.stalled.delete(e),this.release(e,t),this.onAutoRelease?.(e)}dropAndRelease(e,t){this.store.memory.delete(t),this.store.stalled.delete(e),this.release(e,t),this.events.emit({kind:"message.dismissed",messageId:t,sessionId:e,at:new Date().toISOString()}),this.onAutoRelease?.(e)}onAutoRelease;hitLast=!1;acknowledge(e,t,s,a){const o=normalizePromptText(t),h=o.replace(/\[Image #\d+\]/gi,"").trim(),l=[];let d=!1;this.hitLast=!1;for(const i of[...this.store.memory.values()].reverse()){if(i.sessionId!==e||i.acked||i.mode!=="prompt")continue;const n=normalizePromptText(i.text),m=!!n&&(n.length>=a.ackMinText?o.includes(n):o.endsWith(n)),c=(i.attachments?.length??0)>0&&(n?stripSpace(o).includes(stripSpace(n)):h.length===0);!m&&!c||(d=!0,this.store.memory.set(i.id,{...i,acked:!0,stalled:!1,...s===void 0?{}:{ackedEventId:s}}),this.store.stalled.get(e)?.messageId===i.id&&this.store.stalled.delete(e),this.release(e,i.id),l.push(...i.attachments?.map(g=>g.id)??[]),this.events.emit({kind:"message.acknowledged",messageId:i.id,sessionId:e,at:new Date().toISOString()}))}return this.hitLast=d,d?l:[]}sessionExited(e){this.release(e)}static sleep=u}export function normalizePromptText(r){return r.replace(/<\/?cross-session-message[^>]*>/g,"").replace(/\s+/g," ").trim()}export function stripSpace(r){return r.replace(/\s+/g,"")}

package/node_modules/@weavecode/server/dist/hooks/delivery/channels.d.ts

@@ -0,0 +1,39 @@
+import type { MessagingSurface } from '@weavecode/harness';
+import type { SpawnLike } from '../headless-runner.js';
+import type { PipeMessage } from '../message-deliverer.js';
+/**
+ * 层① 投递通道的「尝试一次」实现：宿主队列（codex queue）与会话本地 inbox
+ * socket 直投。两者都是「成功即 delivered、失败即静默回落下一层」——回落不留痕
+ * 是语义的一部分（凭据失效 / 会话不在 / CLI 起不来都是暂态）。
+ *
+ * 回执布防（armCommandAck / armAckWatch）与内存登记由宿主回调完成——本模块只管
+ * 「把文本送出去」与「送出去之后长什么样」。
+ */
+export interface ChannelAttemptDeps {
+    /** 内存行登记（delivering / delivered 都要可见）。 */
+    setMemory(msg: PipeMessage): void;
+    /** 摘内存行（回落时不留痕）。 */
+    deleteMemory(messageId: string): void;
+    /** 占住队头（送出即登记，等它的 UPS）。 */
+    awaitAck(sessionId: string, messageId: string): void;
+    /** 斜杠命令判定（内建命令不发 UPS，回执收尾走短窗口）。 */
+    isSlashCommand(text: string): boolean;
+    /** 回执布防（普通 prompt）。 */
+    armAckWatch(msg: PipeMessage): void;
+    /** 回执布防（斜杠命令短窗口）。 */
+    armCommandAck(messageId: string): void;
+    /** 消息域帧。 */
+    emit(message: {
+        kind: string;
+        [key: string]: unknown;
+    }): void;
+    spawnImpl?: SpawnLike;
+}
+/** 投递文本 = 用户原文经 harness `attach.composePrompt` 现合成（带附件时追加引用）。 */
+export declare function wireTextOf(entry: PipeMessage, surfaceOfSession: (sessionId: string) => MessagingSurface | null): string;
+/** 有没有图（**不是**有没有附件）：宿主队列拒收图，只有图才逼着走终端。 */
+export declare function hasImages(entry: PipeMessage): boolean;
+/** 一次性子进程：收集输出、超时强杀；非零退出 / spawn 失败都算拒绝。 */
+export declare function spawnOnce(bin: string, args: readonly string[], timeoutMs: number, spawnImpl?: SpawnLike): Promise<void>;
+/** 落定 delivered 行（内存 + 帧 + 回执布防）——队列/直投两路共用的收尾。 */
+export declare function settleDelivered(deps: ChannelAttemptDeps, entry: PipeMessage, via: 'queue' | 'socket'): PipeMessage;

package/node_modules/@weavecode/server/dist/hooks/delivery/channels.js

@@ -0,0 +1 @@
+import{spawn as p}from"node:child_process";import{defaultKill as f}from"../headless-runner.js";import{tmpdir as l}from"node:os";import{isImageMediaType as w}from"../../repositories/uploads.js";export function wireTextOf(e,t){const o=e.attachments;return!o||o.length===0?e.text:t(e.sessionId)?.attach?.composePrompt(e.text,o)??e.text}export function hasImages(e){return(e.attachments??[]).some(t=>w(t.mediaType))}export function spawnOnce(e,t,o,r){const u=r??((a,n,s)=>p(a,[...n],s));return new Promise((a,n)=>{const s=u(e,t,{cwd:l(),windowsHide:!0,stdio:["ignore","pipe","pipe"]}),m=[];s.stdout?.on("data",i=>m.push(i)),s.stderr?.on("data",i=>m.push(i));const d=setTimeout(()=>{if(s.pid!==void 0)try{f(s.pid)}catch{}n(new Error(`queue timeout after ${o}ms`))},o);s.on("error",i=>{clearTimeout(d),n(i)}),s.on("exit",i=>{if(clearTimeout(d),i===0){a();return}const c=Buffer.concat(m).toString("utf8").slice(-500);n(new Error(`queue exit ${i}${c?`: ${c}`:""}`))})})}export function settleDelivered(e,t,o){const r={...t,status:"delivered",via:o,settledAt:new Date().toISOString()};return e.setMemory(r),e.awaitAck(t.sessionId,t.id),e.isSlashCommand(t.text)?e.armCommandAck(t.id):e.armAckWatch(r),e.emit({kind:"message.delivered",messageId:t.id,sessionId:t.sessionId,at:new Date().toISOString()}),r}

package/node_modules/@weavecode/server/dist/hooks/delivery/keys.d.ts

@@ -0,0 +1,68 @@
+import type { MessagingSurface } from '@weavecode/harness';
+import type { ProjectRepository } from '../../repositories/projects.js';
+import type { SessionRepository } from '../../repositories/sessions.js';
+import type { HookEventRepository } from '../../repositories/hook-events.js';
+import type { AnswerResult, PaneTargetSource, PromptTerminal } from '../message-deliverer.js';
+/**
+ * 键序注入域（会话控制面）的共享落点解析与常量：作答 / 中断 / 关 pane / 模式 /
+ * 模型 / 思考强度 / 旁路会话全部经由「会话 → 项目 → 终端通道 → pane」这一条
+ * 解析链，失败原因是**可判定的语义拒绝**（404/409），调用方原样回给 HTTP。
+ */
+/** 中断键 = 一记 ESC（claude 里连打两次是历史回退菜单，故只打一记）。 */
+export declare const ESC = "\u001B";
+/** 执行模式切换键 = 一记 Shift+Tab（固定死在服务端，不当参数收）。 */
+export declare const SHIFT_TAB = "\u001B[Z";
+/** 手动提交键 = 一记回车（提交宿主输入框里现成的内容；与层② 补打同一字节）。 */
+export declare const ENTER = "\r";
+/** 手动中断键 = 一记 Ctrl+C（宿主 TUI 的硬中断；wt 侧编成 VK_C + CTRL 按下）。 */
+export declare const CTRL_C = "\u0003";
+/** 模型名形态：不含空白/控制字符、≤128 字符（贴宿主 `/model` 的 `\S*` 文法）。 */
+export declare const MODEL_NAME: RegExp;
+export declare const modelCommand: (name: string) => string;
+export declare const effortCommand: (level: string) => string;
+/** 作答原子形态与原子间隔（宿主把连打的字符当粘贴/筛选输入，必须一次一个）。 */
+export declare const ANSWER_ATOM: RegExp;
+export declare const ANSWER_TEXT: RegExp;
+export declare const ANSWER_ATOM_GAP_MS = 120;
+export declare const sleep: (ms: number) => Promise<void>;
+export interface KeysTargetDeps {
+    sessions: Pick<SessionRepository, 'getBySessionId'>;
+    projects: Pick<ProjectRepository, 'getById'>;
+    hookEvents: Pick<HookEventRepository, 'listBySession'>;
+    /** 层② 通道现取（null = 未装配）。 */
+    terminalChannel(): PromptTerminal | null;
+    /** pane 定位（locator 优先、标题+cwd 回落；heuristic 跳过 locator）。 */
+    terminalPaneFor(session: {
+        sessionId: string;
+        title: string | null;
+    }, project: {
+        path: string;
+    }, source?: PaneTargetSource): Promise<{
+        id: string;
+    } | null>;
+}
+/**
+ * 键序注入路径（作答 / 中断 / 关 pane / 模式 / 模型 / 档位 / 旁路）共用的落点解析。
+ * 两条 409 是给用户看的（web 直拼在「停止失败：」这类动作名后面），故写成中文
+ * 修法，动作名随调用方换。
+ */
+export declare function sessionKeysTarget(deps: KeysTargetDeps, sessionId: string, action?: string, source?: PaneTargetSource): Promise<{
+    ok: true;
+    terminal: PromptTerminal;
+    paneId: string;
+} | Extract<AnswerResult, {
+    ok: false;
+}>>;
+/** 思考强度的档位词表（core 表该会话 harness 的 `effortLevels`；判不出 harness = 空）。 */
+export declare function effortLevelsOf(hookEvents: Pick<HookEventRepository, 'listBySession'>, sessionId: string): string[];
+/** 旁路会话面（claude = `/btw`）现取：判不出 harness / 面缺席 = null。 */
+export declare function sideQuestionSurfaceOf(hookEvents: Pick<HookEventRepository, 'listBySession'>, sessionId: string, surfaceFor: ((harness: import('@weavecode/core').Harness) => MessagingSurface) | undefined): MessagingSurface | null;
+/** pane 定位（层② 共用）：locator 优先、标题+cwd 回落；heuristic 跳过 locator。 */
+export declare function locateTerminalPane(terminal: PromptTerminal | null, paneEnvs: ReadonlyMap<string, Record<string, string>>, session: {
+    sessionId: string;
+    title: string | null;
+}, project: {
+    path: string;
+}, source?: PaneTargetSource): Promise<{
+    id: string;
+} | null>;

package/node_modules/@weavecode/server/dist/hooks/delivery/keys.js

@@ -0,0 +1 @@
+import{HARNESS_SESSION_CONTROL as A,isHarness as f}from"@weavecode/core";import{normalizeDirKey as E}from"../../daemon/opener.js";export const ESC="\x1B",SHIFT_TAB="\x1B[Z",ENTER="\r",CTRL_C="",MODEL_NAME=/^[^\s\x00-\x1f\x7f]{1,128}$/,modelCommand=t=>`/model ${t}`,effortCommand=t=>`/effort ${t}`,ANSWER_ATOM=/^(?:[1-9]|n|\t|\r|\x1b\[B)$/,ANSWER_TEXT=/^[^\x00-\x1f\x7f]*$/,ANSWER_ATOM_GAP_MS=120,sleep=t=>new Promise(u=>setTimeout(u,t));export async function sessionKeysTarget(t,u,e="\u51FB\u952E",r="both"){const n=t.sessions.getBySessionId(u);if(!n)return{ok:!1,status:404,error:"Session not found"};if(n.projectId==null)return{ok:!1,status:400,error:"Session is not bound to a project"};const s=t.projects.getById(n.projectId);if(!s)return{ok:!1,status:404,error:"Project not found"};const i=t.terminalChannel();if(!i)return{ok:!1,status:409,error:`\u7EC8\u7AEF\u901A\u9053\u672A\u88C5\u914D\uFF0C\u65E0\u6CD5\u8FDC\u7A0B${e}`};const l=await t.terminalPaneFor(n,s,r);return l?{ok:!0,terminal:i,paneId:l.id}:{ok:!1,status:409,error:`\u627E\u4E0D\u5230\u4F1A\u8BDD\u6240\u5728\u7684\u7EC8\u7AEF\u7A97\u53E3\u2014\u2014\u8FD9\u4E2A\u4F1A\u8BDD\u6240\u5728\u7EC8\u7AEF\u6CA1\u6709\u53EF\u7528\u7684\u8FDC\u7A0B${e}\u901A\u9053`}}export function effortLevelsOf(t,u){const e=t.listBySession(u,1),r=e[e.length-1]?.source;return f(r)?A[r]?.effortLevels??[]:[]}export function sideQuestionSurfaceOf(t,u,e){const r=t.listBySession(u,1),n=r[r.length-1]?.source;return f(n)?e?.(n)??null:null}export async function locateTerminalPane(t,u,e,r,n="both"){if(!t)return null;const s=n==="heuristic"?void 0:u.get(e.sessionId);if(s){const o=await t.locatePane?.(s).catch(()=>null);if(o)return{id:o}}if(!e.title)return null;const i=e.title.replace(/^[✻✽✶✳✢⋅◦✦✧∘◐◑◒◓*]+\s*/,""),l=E(r.path,process.platform);let a;try{a=await t.listPanes()}catch{return null}const c=a.filter(o=>o.title!=null&&o.cwd!=null&&l!=null&&o.title.replace(/^[✻✽✶✳✢⋅◦✦✧∘◐◑◒◓*]+\s*/,"")===i&&E(o.cwd,process.platform)===l);return c.length===1?c[0]:null}

package/node_modules/@weavecode/server/dist/hooks/delivery/queue.d.ts

@@ -0,0 +1,39 @@
+import type { SessionRepository } from '../../repositories/sessions.js';
+import type { ProjectRepository } from '../../repositories/projects.js';
+import { type PromptboxEntry } from '../promptbox.js';
+import type { PipeMessage } from '../message-deliverer.js';
+/**
+ * 层③ promptbox 队列的纯函数与死信落定：入队、判死、判死落定（整批 offline）。
+ *
+ * 队列文件是唯一事实源（`<dataDir>/hooks/promptbox/<shard>.jsonl`，送达即删行）；
+ * 「哪些会话有队列」的索引（queuedSessions）与冲洗泵归宿主，本模块只做单行/整批
+ * 的文件操作与落定形态——测试可以直接对着临时目录跑。
+ */
+export declare const OFFLINE_ERROR = "Session is not running";
+/** 入队（promptbox 追加；会话索引由宿主登记）。 */
+export declare function appendQueueEntry(hooksDir: string, token: string, entry: PipeMessage): void;
+/**
+ * 该会话是否已判死：claude 注册表 `pidAlive === false` 才认，`null` 不猜
+ * （codex / 新会话豁免窗 / SessionStart 空壳行都落 null）。判据与「已终止」
+ * 态、两条 terminated 补射同源（claude-liveness 的 pidAliveOf）——消息行与
+ * 会话行不会各说各话。
+ */
+export declare function sessionJudgedDead(sessions: Pick<SessionRepository, 'livenessRowOf'>, sessionId: string, liveness?: Map<string, boolean>): boolean;
+/**
+ * 判死落定（单行）：三层全无通路、目标进程又不在——**不假装排队**，落 `failed` +
+ * `reason: 'offline'`（`message.finished` 帧照抛，既有 messageFailed 订阅提醒
+ * 生效）。**刻意不置暂停闸**：队列整批转 offline 后已空，闸只会挡住用户重发
+ * ——重发是有意的可逆出口（判活残差 / 会话其实活着时，一点就回来）。
+ */
+export declare function failOffline(memory: Map<string, PipeMessage>, emit: (message: {
+    kind: string;
+    [key: string]: unknown;
+}) => void, entry: PipeMessage): PipeMessage;
+/** 冲洗时判死：**该会话全部队列行**都是死信（死会话投不进去），整批落定 + 清队。 */
+export declare function failQueuedOffline(deps: {
+    sessions: Pick<SessionRepository, 'getBySessionId'>;
+    projects: Pick<ProjectRepository, 'getById'>;
+}, hooksDir: string, memory: Map<string, PipeMessage>, emit: (message: {
+    kind: string;
+    [key: string]: unknown;
+}) => void, sessionId: string, entries: readonly PromptboxEntry[]): void;

package/node_modules/@weavecode/server/dist/hooks/delivery/queue.js

@@ -0,0 +1 @@
+import{claudeLivenessById as c,pidAliveOf as f}from"../../daemon/claude-liveness.js";import{appendPromptbox as m,removePromptboxEntries as p}from"../promptbox.js";export const OFFLINE_ERROR="Session is not running";export function appendQueueEntry(n,s,e){m(n,s,[{id:e.id,sessionId:e.sessionId,text:e.text,oneWay:e.oneWay===!0,...e.forceTerminal===!0?{forceTerminal:!0}:{},...e.attachments&&e.attachments.length>0?{attachments:e.attachments}:{}}])}export function sessionJudgedDead(n,s,e=c()){const o=n.livenessRowOf(s);return o?f(o,e)===!1:!1}export function failOffline(n,s,e){const o=new Date().toISOString(),a={...e,status:"failed",reason:"offline",error:OFFLINE_ERROR,settledAt:o};return n.set(e.id,a),s({kind:"message.finished",messageId:e.id,sessionId:e.sessionId,status:"failed",at:o}),a}export function failQueuedOffline(n,s,e,o,a,i){const r=n.sessions.getBySessionId(a),d=r?.projectId==null?null:n.projects.getById(r.projectId);if(!(!d||i.length===0)){for(const t of i)failOffline(e,o,{id:t.id,sessionId:a,text:t.text,...t.attachments&&t.attachments.length>0?{attachments:t.attachments}:{},mode:"prompt",oneWay:t.oneWay===!0,channel:"prompt",status:"pending",at:t.at});p(s,d.token,new Set(i.map(t=>t.id)))}}

package/node_modules/@weavecode/server/dist/hooks/delivery/relay.d.ts

@@ -0,0 +1,44 @@
+import { tmpdir } from 'node:os';
+import type { PromptRelaySpec } from '@weavecode/harness';
+import type { HeadlessRunner, HeadlessSettleResult } from '../headless-runner.js';
+import type { PipeMessage } from '../message-deliverer.js';
+/**
+ * 层① 原生中继（claude SendMessage）：复用 HeadlessRunner 的 spawn 基建
+ * （win32 shell 单串 + stdin + 超时），键 = 合成键（不占目标会话的 headless
+ * 并发闸）。中继是**本轮次的一次性子进程**：与 daemon 同进程组，随 daemon
+ * 退出回收，不留独立进程占资源。
+ *
+ * 终态语义：成功 = delivered（布防回执闸；中继闸释放后若还有积压继续下一批）；
+ * 失败 = failed 留内存可见并置暂停闸——不自动重试（避免对活着但拒收的会话反复
+ * 打中继），手动重发解除。回执先到 = 消息确实送进去了（中继 exit 状态只管进程、
+ * 不管送达），这时翻成 failed 会把已送达的会话队列无限期停住。
+ */
+export interface RelayDeps {
+    headless: HeadlessRunner;
+    /** 内存行读取（settle 需要按 id 取当前行——写期间回执可能已到）。 */
+    getMemory(messageId: string): PipeMessage | null;
+    /** 内存行登记/摘除。 */
+    setMemory(msg: PipeMessage): void;
+    /** 占住队头（送出即登记）。 */
+    awaitAck(sessionId: string, messageId: string): void;
+    /** 暂停闸（失败时置）。 */
+    stall(sessionId: string, msg: PipeMessage, reason: 'failed'): void;
+    /** 斜杠命令判定。 */
+    isSlashCommand(text: string): boolean;
+    armAckWatch(msg: PipeMessage): void;
+    armCommandAck(messageId: string, onRelease: (sessionId: string) => void): void;
+    /** 中继闸释放后若还有积压，续排下一批。 */
+    onReleased(sessionId: string): void;
+    emit(message: {
+        kind: string;
+        [key: string]: unknown;
+    }): void;
+    /** 覆写 bin（测试注入；缺省 WEAVE_CLAUDE_BIN → relay.bin）。 */
+    bin?: string;
+    relayTimeoutMs?: number;
+}
+/** 中继启动（fire-and-forget）：返回是否启动成功（失败也已落终态，视作启动过）。 */
+export declare function runRelay(deps: RelayDeps, entry: PipeMessage, relay: PromptRelaySpec, peerName: string, wireText: string): boolean;
+/** 中继终态（幂等由 HeadlessRunner 的 per-run state 保证）。 */
+export declare function settleRelay(deps: RelayDeps, messageId: string, result: HeadlessSettleResult): void;
+export { tmpdir };

package/node_modules/@weavecode/server/dist/hooks/delivery/relay.js

@@ -0,0 +1 @@
+import{tmpdir as a}from"node:os";import{isSlashCommand as i}from"../message-deliverer.js";export function runRelay(e,r,n,s,o){try{return e.headless.run({sessionId:`prompt-relay:${r.sessionId}`,cwd:a(),prompt:n.instruction(s,o,{oneWay:r.oneWay===!0}),spec:{supported:!0,bin:n.bin,args:()=>[...n.args],promptStdin:!0},bin:e.bin??process.env.WEAVE_CLAUDE_BIN??n.bin,timeoutMs:e.relayTimeoutMs??0,detached:!1,onSettle:t=>settleRelay(e,r.id,t)})}catch(t){return settleRelay(e,r.id,{status:"failed",output:null,error:t instanceof Error?t.message:String(t)}),!0}}export function settleRelay(e,r,n){const s=e.getMemory(r);if(!s)return;if(n.status==="succeeded"){e.onReleased(s.sessionId);const t={...s,status:"delivered",settledAt:new Date().toISOString()};e.setMemory(t),i(s.text)?e.armCommandAck(r,e.onReleased):e.armAckWatch(t),e.emit({kind:"message.delivered",messageId:r,sessionId:s.sessionId,at:new Date().toISOString()});return}if(s.acked===!0){const t=new Date().toISOString();e.setMemory({...s,status:"delivered",settledAt:t}),e.emit({kind:"message.delivered",messageId:r,sessionId:s.sessionId,at:t});return}const o={...s,status:"failed",error:n.error??`prompt relay ${n.status}`,settledAt:new Date().toISOString()};e.setMemory(o),e.stall(s.sessionId,o,"failed"),e.emit({kind:"message.finished",messageId:r,sessionId:s.sessionId,status:"failed",at:new Date().toISOString()})}export{a as tmpdir};

package/node_modules/@weavecode/server/dist/hooks/delivery/send.d.ts

@@ -0,0 +1,50 @@
+import type { MessagingSurface, MessageMeta } from '@weavecode/harness';
+import type { SessionRepository } from '../../repositories/sessions.js';
+import type { HeadlessRunner } from '../headless-runner.js';
+import type { HookEventBus } from '../bus.js';
+import type { MessageMode, PipeMessage } from '../message-deliverer.js';
+/**
+ * send() 的通道裁决与 inject/headless 落地：mode → 实际通道的唯一裁决点，
+ * 以及两个「立即返回终态或在途」的非 prompt 通道。
+ */
+/** 通道裁决结果：mode=auto 落到实际通道后才存在。 */
+export type ResolvedChannel = 'prompt' | 'inject' | 'headless';
+/**
+ * mode → 实际通道。prompt = 层① 原生 || 层② 终端通道（都没有才 409）；
+ * auto 的忙/闲基准 = turnOpenOf，忙 → inject（无通道才拒绝，绝不无头抢占），
+ * 闲 → headless。对象 = 拒绝（409 reason）；字符串 = 选中的通道。
+ */
+export declare function resolveChannel(deps: Pick<SessionRepository, 'turnOpenOf'>, hasTerminalChannel: () => boolean, mode: MessageMode, sessionId: string, surface: MessagingSurface): ResolvedChannel | {
+    reason: string;
+};
+/** 不支持原因：面声明优先，缺省兜底文案。 */
+export declare function unsupportedReason(surface: MessagingSurface, channel: Exclude<ResolvedChannel, 'prompt'>): string;
+/** 信封：面可覆写（harness 自己的表示法）；缺省 weave 通用头 + 正文。 */
+export declare function renderEnvelope(text: string, meta: MessageMeta, surface: MessagingSurface): string;
+export interface InjectDeps {
+    hooksDir: string;
+    memory: Map<string, PipeMessage>;
+    bus: Pick<HookEventBus, 'emit'>;
+}
+/** inject 通道：信封写 outbox → injected（fire-and-forget 语义）。 */
+export declare function deliverInject(deps: InjectDeps, entry: PipeMessage, token: string, meta: MessageMeta, surface: MessagingSurface, wireText: string): {
+    ok: true;
+    messageId: string;
+    status: 'injected';
+    message: PipeMessage;
+};
+export interface HeadlessDeps {
+    memory: Map<string, PipeMessage>;
+    headless: HeadlessRunner;
+    bus: Pick<HookEventBus, 'emit'>;
+    /** 覆写 bin（测试注入；缺省 WEAVE_CLAUDE_BIN → spec.bin）。 */
+    bin?: string;
+    timeoutMs?: number;
+}
+/** headless 通道：置 running → 无头 spawn；终态经 onSettle 后台回写（幂等）。 */
+export declare function deliverHeadless(deps: HeadlessDeps, entry: PipeMessage, cwd: string, meta: MessageMeta, surface: MessagingSurface, wireText: string): {
+    ok: true;
+    messageId: string;
+    status: 'running';
+    message: PipeMessage;
+};

package/node_modules/@weavecode/server/dist/hooks/delivery/send.js

@@ -0,0 +1,3 @@
+import{appendOutbox as p}from"../mirror.js";export function resolveChannel(e,s,n,o,t){if(n==="prompt")return t.prompt||t.queuedPrompt||s()?"prompt":{reason:t.unsupportedReasons?.prompt??`Harness "${t.harness}" has no native prompt channel and the configured terminal cannot inject text`};if(n==="inject"||n==="headless")return(n==="inject"?t.inject:t.headless)?n:{reason:unsupportedReason(t,n)};const i=e.turnOpenOf(o)?"inject":"headless";return(i==="inject"?t.inject:t.headless)?i:{reason:unsupportedReason(t,i)}}export function unsupportedReason(e,s){return e.unsupportedReasons?.[s]??`Harness "${e.harness}" does not support the ${s} messaging channel`}export function renderEnvelope(e,s,n){return n.renderEnvelope?.(e,s)??`[weave message] from=${s.fromLabel} at=${s.at} mode=${s.mode}
+
+${e}`}export function deliverInject(e,s,n,o,t,i){const d=renderEnvelope(i,o,t);p(e.hooksDir,n,[{sessionId:s.sessionId,text:d}]);const r={...s,status:"injected",settledAt:new Date().toISOString()};return e.memory.set(r.id,r),e.bus.emit({kind:"message.delivered",messageId:r.id,sessionId:s.sessionId,at:new Date().toISOString()}),{ok:!0,messageId:r.id,status:"injected",message:r}}export function deliverHeadless(e,s,n,o,t,i){const d=t.headless,r={...s,status:"running"};e.memory.set(r.id,r);const u={settled:!1};try{e.headless.run({sessionId:r.sessionId,cwd:n,prompt:renderEnvelope(i,o,t),spec:d,bin:e.bin??process.env.WEAVE_CLAUDE_BIN??d.bin,timeoutMs:e.timeoutMs,onSettle:a=>m(e,r,u,a)})||m(e,r,u,{status:"failed",output:null,error:"Session already has a running run"})}catch(a){m(e,r,u,{status:"failed",output:null,error:a instanceof Error?a.message:String(a)})}return{ok:!0,messageId:r.id,status:"running",message:e.memory.get(r.id)}}function m(e,s,n,o){if(n.settled)return;n.settled=!0;const t=e.memory.get(s.id);if(t)try{e.memory.set(s.id,{...t,status:o.status,output:o.output,error:o.error,settledAt:new Date().toISOString()}),e.bus.emit({kind:"message.finished",messageId:s.id,sessionId:s.sessionId,status:o.status,at:new Date().toISOString()})}catch{}}

package/node_modules/@weavecode/server/dist/hooks/delivery/views.d.ts

@@ -0,0 +1,29 @@
+import type { SessionTerminal } from '../../daemon/opener.js';
+import type { ProjectRepository } from '../../repositories/projects.js';
+import type { SessionRepository } from '../../repositories/sessions.js';
+import type { PipeMessage } from '../message-deliverer.js';
+/**
+ * 在途视图（GET /sessions/:id/messages 的数据面）：promptbox 待递送 ∪ 内存态——
+ * 终态短时驻留（delivered/injected/succeeded 在 settledAt+ttl 内可见，展示
+ * via/acked），failed/timeout/暂停闸成因常驻。历史在会话自己的转录里。
+ */
+export declare function listVisible(deps: {
+    sessions: Pick<SessionRepository, 'getBySessionId'>;
+    projects: Pick<ProjectRepository, 'getById'>;
+}, hooksDir: string, memory: ReadonlyMap<string, PipeMessage>, sessionId: string, ttlMs: number): PipeMessage[];
+/**
+ * 在途计数（sessionId → 条数）：队列 pending（未送达）∪ 内存 delivering/running
+ * （在飞）。会话行角标用——终态（injected/delivered/succeeded/…）不计。
+ */
+export declare function listInflightCounts(hooksDir: string, memory: ReadonlyMap<string, PipeMessage>): Map<string, number>;
+/**
+ * 会话 → 所在可见屏幕（会话列表分块的数据面）。旁路 env 与投递路径共用同一份
+ * 缓存，不另采一次；后端没有反查能力 = 空表（那些会话不分组）。顺手摘掉已判死
+ * 会话的 env：那是上一次见到它时的快照，它不会再来报一次，留着只会让死会话常占块头。
+ */
+export declare function sessionTerminals(deps: {
+    sessions: Pick<SessionRepository, 'livenessRowOf'>;
+    livenessOf?: () => Map<string, boolean>;
+}, terminal: {
+    locateScreens?(envs: Record<string, Record<string, string>>): Promise<Record<string, SessionTerminal | null>>;
+} | null, paneEnvs: Map<string, Record<string, string>>, persistPaneEnvs: () => void): Promise<Record<string, SessionTerminal | null>>;

package/node_modules/@weavecode/server/dist/hooks/delivery/views.js

@@ -0,0 +1 @@
+import{claudeLivenessById as d}from"../../daemon/claude-liveness.js";import{readAllPromptbox as l,readPromptbox as f}from"../promptbox.js";import{sessionJudgedDead as p}from"./queue.js";function m(n,s){return{id:s.id,sessionId:n,text:s.text,...s.attachments&&s.attachments.length>0?{attachments:s.attachments}:{},mode:"prompt",oneWay:s.oneWay===!0,...s.forceTerminal===!0?{forceTerminal:!0}:{},channel:"prompt",status:"pending",at:s.at}}export function listVisible(n,s,o,a,e){const c=Date.now(),i=[],r=n.sessions.getBySessionId(a);if(r?.projectId!=null){const t=n.projects.getById(r.projectId);if(t)for(const u of f(s,t.token))u.sessionId===a&&i.push(m(a,u))}for(const t of o.values()){if(t.sessionId!==a)continue;if(t.stalled===!0||t.status==="delivering"||t.status==="running"){i.push(t);continue}if(t.status==="failed"||t.status==="timeout"){i.push(t);continue}const u=t.settledAt?Date.parse(t.settledAt):NaN;(t.status==="delivered"&&t.acked!==!0||!Number.isNaN(u)&&c-u<e)&&i.push(t)}return i.sort((t,u)=>t.at<u.at?-1:1)}export function listInflightCounts(n,s){const o=new Map,a=e=>{o.set(e,(o.get(e)??0)+1)};for(const e of l(n))a(e.sessionId);for(const e of s.values())(e.status==="delivering"||e.status==="running")&&a(e.sessionId);return o}export async function sessionTerminals(n,s,o,a){if(!s?.locateScreens||o.size===0)return{};const e={},c={},i=n.livenessOf?.()??d();for(const[r,t]of o){if(p(n.sessions,r,i)){o.delete(r),a(),c[r]=null;continue}e[r]=t}return{...c,...await s.locateScreens(e)}}

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

@@ -46,6 +46,8 @@ export interface IngestOutcome {
 export declare class HookDispatcher {
     private readonly deps;
     private readonly runningWebhooks;
+    /** classify：规则级冷却（防下游回环）与「最后一次尝试」时刻。 */
+    private readonly lastClassifyAt;
     private readonly recentPool;
     private activeWebhooks;
     private readonly pendingWebhooks;
@@ -64,6 +66,11 @@ export declare class HookDispatcher {
         pluginStates?: Pick<PluginStateRepository, 'get'>;
         /** 测试注入；缺省用全局 fetch。 */
         fetchImpl?: typeof fetch;
+        /** classify：对某一轮 fork 无头子 agent 判定类别（装配侧 = edgeExtract.run）。 */
+        classify?: (input: {
+            sessionId: string;
+            prompt: string;
+        }) => Promise<string | null>;
     });
     onIngest(ctx: IngestContext): Promise<IngestOutcome>;
     /** 入池 + 广播 dispatch.created（inject/manual/webhook/plugin 四路共用的建池路径）。 */
@@ -83,6 +90,10 @@ export declare class HookDispatcher {
     /** 不可注入事件的插件执行：fire-and-forget，prompt 照常入池（晚一步落库）。 */
     private runPluginDetached;
     private summary;
+    /** 本轮的最终输出（Stop 的 last_assistant_message）；没有就当不适用。 */
+    private turnText;
+    /** classify：fork 一个无头回合判定类别 → 命中标签就出站 POST 到下游。 */
+    private runClassifyAsync;
     private runWebhookAsync;
     /** 全局并发闸（默认 4）：超出则排队等待。 */
     private acquireWebhookSlot;

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

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