@weavecode/weave 0.0.0-stage → 0.1.1

package/node_modules/@weavecode/server/dist/hooks/message-deliverer.d.ts

@@ -0,0 +1,486 @@
+import { type Harness } from '@weavecode/core';
+import type { MessagingSurface } from '@weavecode/harness';
+import type { HookEventRepository } from '../repositories/hook-events.js';
+import type { ProjectRepository } from '../repositories/projects.js';
+import type { SessionRepository } from '../repositories/sessions.js';
+import { type SessionTerminal } from '../daemon/opener.js';
+import type { HookEventBus } from './bus.js';
+import { HeadlessRunner, type SpawnLike } from './headless-runner.js';
+/**
+ * 消息域投递器（消息域重塑：纯递送管道，非记录系统）——消息不落任何 DB 行，
+ * 唯一归宿是目标会话自己的转录；weave 仅投递前短暂持有：
+ *
+ *   prompt  → 层① 原生 peer 消息中继（claude SendMessage，经受限 headless 进程）
+ *             层② 终端 send-text 兜底（无原生机制的 harness；TerminalBackend 通道）
+ *             层③ promptbox 队列（`<dataDir>/hooks/promptbox/<shard>.jsonl`，送达即删行）
+ *   inject  → outbox 顺延注入（fire-and-forget，随目标会话下一拍 hook 事件送达）
+ *   headless → 无头强制回合（running → 终态）
+ *   auto    → turnOpen 忙 → inject（绝不无头抢占）；闲 → headless
+ *
+ * 内存态注册表只放「pending 之后」的消息（投递中 / headless 在途 / 终态结果）；
+ * pending 只存在于 promptbox 文件。重启即丢 headless 终态 = 显式高级选项的
+ * 已文档代价。通道规格全部来自 MessagingSurface 能力面，本类不含 harness 硬编码。
+ *
+ * 层③ 只收「还有可能送达」的行：三层全无通路且目标已判死（claude 注册表
+ * `pidAlive === false`）时**不入队**，落 failed + `reason: 'offline'`（web 出中文
+ * 说明）——死会话的队列行永远不会被取走，排在那里只是骗人。判不动（null）不猜，
+ * 照旧入队。
+ *
+ * **同一会话严格按发送顺序投递**（顺序即真相：到达顺序错乱比慢一拍更糟）：
+ * 队头还压着（上一条终端投递没回执 / 队列有积压 / 泵在推进）时新消息只入队尾，
+ * 由冲洗泵一条条推进；终端层把一条贴进输入框后必须等它的 UPS 回执才发下一条
+ * ——再贴一份会在同一个框里叠成一段，两条消息并成一条提交（直投/中继不压：
+ * 交出去即进入会话自己的队列，会话按序处理）。
+ *
+ * send() 校验失败同步返回错误码；成功立即返回（inject 已落 outbox，headless
+ * 「已启动」，prompt 视层可用性返回 delivering/pending），终态经回调后台落定，
+ * 绝不 throw 出 send()。
+ */
+/** 投递模式（路由入参；auto = 裁决后落 inject/headless）。 */
+export type MessageMode = 'prompt' | 'inject' | 'headless' | 'auto';
+/** 发起方（仅信封渲染用，管道不记录来源）。 */
+export type MessageFromKind = 'dashboard' | 'session';
+/** 管道消息状态：pending 只活在 promptbox 文件，其余在内存注册表。 */
+export type PipeStatus = 'pending' | 'delivering' | 'running' | 'injected' | 'delivered' | 'succeeded' | 'failed' | 'timeout';
+/** 随 prompt 投递的图（上传件引用；路径 = 落盘件的绝对路径，harness 合成引用形态）。 */
+export interface MessageImage {
+    id: string;
+    name: string;
+    mediaType: string;
+    path: string;
+}
+/** 管道消息（内存态；发号 = uuid，全生命周期稳定）。 */
+export interface PipeMessage {
+    id: string;
+    sessionId: string;
+    /** **用户原文**（回执比对、气泡文案都用它）；投递出去的文本是它经 harness
+     *  `imageAttach.composePrompt` 合成的形态（带图时追加图引用），见 `wireTextOf`。 */
+    text: string;
+    /** 随附图（空/缺省 = 纯文本消息）。 */
+    images?: MessageImage[];
+    mode: MessageMode;
+    /** 单向注入（手动面：无接收方会话，中继载荷带「无需回复」注记）；编排域不置。 */
+    oneWay?: boolean;
+    /** 发送人强制层② 终端（层序收窄成只剩它，且重发沿用）。 */
+    forceTerminal?: boolean;
+    /** prompt 通道的实际落法（socket 直投 / 中继 / 终端 send-text）。 */
+    via?: 'socket' | 'relay' | 'terminal';
+    /** 投递回执：会话自己的 UserPromptSubmit 与本文匹配上了（真到达，非「已交给」）。 */
+    acked?: boolean;
+    /** 回执命中的那条开轮事件 id：对话面据此把投递行精确挂到它的气泡上（比比对
+     *  原文可靠——重发只补的那记回车提交的是整个输入框，投递行记的原文与实际提交
+     *  的文本可以不一样）。 */
+    ackedEventId?: number | null;
+    /** 终态落定时刻（在途视图驻留窗口的起点；在途态无值）。 */
+    settledAt?: string | null;
+    /** 本条 = 该会话暂停闸的成因（未回执 / 投递失败）；重发或回执清除。 */
+    stalled?: boolean;
+    /** 判死而没投出去（会话进程不在、三层全无通路）：`failed` 的成因，web 据此出中文说明。 */
+    reason?: 'offline';
+    /** 实际投递通道（auto 落定后回填；pending = 尚未裁决成通道）。 */
+    channel: 'prompt' | 'inject' | 'headless' | null;
+    status: PipeStatus;
+    output?: string | null;
+    error?: string | null;
+    at: string;
+}
+/** 终端 send-text 兜底通道（层②）：TerminalBackend 能力面的消费侧形状。 */
+export interface PromptTerminal {
+    /** 通道可用性（同步声明；装配侧随 settings 终端后端能力变化，能力矩阵取用）。 */
+    available(): boolean;
+    /** 可注入 pane（id / 标题 / 工作目录；取不到的字段为 null）。 */
+    listPanes(): Promise<Array<{
+        id: string;
+        title: string | null;
+        cwd: string | null;
+    }>>;
+    /**
+     * 终端定位（hook 旁路上报的 pane env → pane id，**含存在性校验**：解析不出、
+     * mux 或 pane 已不在 = null）。可缺省（老装配/无定位能力的终端 = 恒回落标题+cwd）。
+     */
+    locatePane?(env: Record<string, string>): Promise<string | null>;
+    /**
+     * 会话 → 所在可见屏幕（会话列表分块的数据面）。可缺省（无枚举能力的终端 =
+     * 恒空表，那些会话不分组）；env 表批量进出（后端一次枚举摊平全部会话）。
+     */
+    locateScreens?(envs: Record<string, Record<string, string>>): Promise<Record<string, SessionTerminal | null>>;
+    /** 往 pane 注入一段 prompt（原文 + 提交键）。 */
+    sendText(paneId: string, text: string): Promise<void>;
+    /** 裸键序注入（作答的选项键 / 中断的 ESC：模态框只吃键盘，不吃粘贴文本）。 */
+    sendKeys(paneId: string, keys: string): Promise<void>;
+    /** 关掉这个 pane（会话生命周期收尾）；无通道的后端明确拒绝。 */
+    closePane(paneId: string): Promise<void>;
+}
+export interface MessageDelivererDeps {
+    sessions: SessionRepository;
+    projects: ProjectRepository;
+    /** harness 归属判定用：目标会话最新事件的 source（与 open-terminal 同口径）。 */
+    hookEvents: HookEventRepository;
+    bus?: HookEventBus;
+    /** 共享无头执行核（与 ResumeRunner 同实例 = 跨域同会话并发闸；中继经合成键不占目标会话闸）。 */
+    headless?: HeadlessRunner;
+    /** 测试注入的 spawn 实现；缺省经 HeadlessRunner 用 node:child_process.spawn。 */
+    spawnImpl?: SpawnLike;
+    /** 测试注入的强杀实现。 */
+    killImpl?: (pid: number) => void;
+    /** harness 可执行覆盖（测试用）；缺省环境变量，再缺省 spec.bin。 */
+    bin?: string;
+    /** 无头回合超时（毫秒）；缺省 HeadlessRunner 默认 300s。 */
+    timeoutMs?: number;
+    /** prompt 中继超时（毫秒）；**缺省 0 = 不设超时**——投递的等待发生在目标
+     *  会话内（忙则等它下一拍 tool round 取走），设上限会把正常投递误判 timeout。 */
+    relayTimeoutMs?: number;
+    /** hooks 根目录（测试注入）；缺省 hooksRoot()。 */
+    hooksDir?: string;
+    /** 能力面访问器（测试注入）；缺省 surfaces.ts 模块级 registry。 */
+    surfaceFor?: (harness: Harness) => MessagingSurface;
+    /** 层② 终端 send-text 通道（装配侧按 TerminalBackend 能力注入；缺省无兜底）。 */
+    terminal?: PromptTerminal;
+    /** 冲洗节流：同一会话两次投递之间的最小间隔（毫秒）；缺省 1000。Claude Code 对
+     *  同一会话的快速突发会在**发送侧**拒收（见 docs/plan/session-orchestration.md）。 */
+    flushGapMs?: number;
+    /** 终态驻留窗口（毫秒）；缺省 60s——delivered/injected/succeeded 短时留在在途
+     *  视图展示 via/acked，过后消失（failed/timeout/暂停闸成因常驻）。 */
+    visibleTtlMs?: number;
+    /** 未回执闸窗口（毫秒）；缺省 120s——prompt 送达后没等到 UPS 回执即暂停该会话
+     *  的队列冲洗（防继续向 Held/Refused 的会话灌消息），手动重发或回执解除。 */
+    ackStallMs?: number;
+    /** 会话存活图（测试注入）；缺省 `claudeLivenessById()`——同两个引擎（watch/sequence）
+     *  的取法：没有注册表就空图，会话一律「查不动」，不猜。 */
+    livenessOf?: () => Map<string, boolean>;
+}
+/** send() 入参（路由层已做 zod 形状校验）。 */
+export interface SendInput {
+    toSessionId: string;
+    text: string;
+    mode: MessageMode;
+    fromKind: MessageFromKind;
+    fromSessionId?: string | null;
+    /** 单向注入（手动面置 true：无接收方会话）；编排域省略 = 双向对话保留。 */
+    oneWay?: boolean;
+    /** 强制层② 终端 send-text（手动面下拉选的通道）：跳过直投与中继——宿主把
+     *  终端击键当用户输入，另外两层都是「另一个会话发的」。 */
+    forceTerminal?: boolean;
+    /** 随附图（已落盘的上传件）；带图且目标 harness 的 `imageAttach` 为 null 即 409。 */
+    images?: readonly MessageImage[];
+}
+/** send() 返回：ok 由路由映射 200，否则 status 即 HTTP 码。 */
+export type SendResult = {
+    ok: true;
+    messageId: string;
+    status: PipeStatus;
+    message: PipeMessage;
+} | {
+    ok: false;
+    status: 400 | 404 | 409;
+    error: string;
+};
+/** answer() 返回（作答不建消息条目，无 messageId）。 */
+export type AnswerResult = {
+    ok: true;
+} | {
+    ok: false;
+    status: 400 | 404 | 409;
+    error: string;
+};
+/** 通道现况：ready = 现在就能投；unknown = 判不动（终端只剩标题/cwd 回落，被动面看不出来）。 */
+interface ChannelState<R extends string> {
+    status: 'ready' | 'unavailable' | 'unknown';
+    reason: R | null;
+}
+/** 会话级投递诊断（`diagnose` 返回值；只含布尔与枚举，无凭据值）。 */
+export interface SessionDeliveryDiagnosis {
+    /** 存活三态（同 `pidAliveOf` 口径：判不动 = null）。 */
+    alive: boolean | null;
+    inbox: ChannelState<'no-mechanism' | 'no-credentials' | 'auth-token-required'>;
+    relay: ChannelState<'no-mechanism' | 'no-peer-name'>;
+    terminal: ChannelState<'no-backend' | 'no-pane-env'>;
+    /** 该会话有没有上报过 pane 定位 env。 */
+    paneEnvReported: boolean;
+    /** 队列里压着的行数。 */
+    pending: number;
+    /** 暂停闸是否已置（未回执超窗 / 投递失败）。 */
+    stalled: boolean;
+}
+export declare class MessageDeliverer {
+    private readonly deps;
+    private readonly headless;
+    private readonly hooksDir;
+    /** 内存态注册表（pending 之后的生命周期）。 */
+    private readonly memory;
+    /** 有队列行的会话（ingest 冲洗守卫 + 刷新器探活索引；构造时从磁盘重建）。 */
+    private readonly queuedSessions;
+    /** 会话 inbox 直投目标（hook 旁路上报，落 `<dataDir>/hooks/inbox-targets.json` 0600）。 */
+    private readonly inboxSockets;
+    /**
+     * 会话所在终端 pane 的定位 env（hook 旁路上报）。落
+     * `<dataDir>/hooks/pane-envs.json` 0600——**只解 daemon 自己的重启**：pane 活在
+     * 会话终端里，重启不动它；不落盘的话重启后要等下一次 hook 事件才认回 pane，而
+     * 长时间没动静的会话根本等不到，于是从终端分组里掉出去。
+     */
+    private readonly paneEnvs;
+    /** 上次落盘的 pane env（hook 每次事件都上报，值没变就不重写盘）。 */
+    private persistedPaneEnvs;
+    /** 已排自续冲洗的会话（防重复排拍）。 */
+    private readonly flushScheduled;
+    /** 正在冲洗的会话（重入闸：异步冲洗 + 多条触发源，防同批行被投两次）。 */
+    private readonly flushing;
+    /** 队列暂停闸（sessionId → 成因消息）：未回执超窗 / 投递失败即置；重发或回执解除。 */
+    private readonly stalled;
+    /**
+     * 队头在等回执（sessionId → 消息 id）：层② 终端把一条贴进输入框后，下一条必须
+     * 等它的 UPS 才发——再贴一份会在同一个框里叠成一段，两条消息并成一条提交。
+     * 直投/中投不压（交出去即入会话自己的队列，会话按序处理）。
+     */
+    private readonly awaitingAck;
+    /**
+     * 刚删掉的队列行 id：冲洗「先把队列读进内存、再逐条投递」——这中间被删的行
+     * 仍在手里那一批里，靠它跳过（否则删掉的消息照样发出去）。只兜这一个窗口，
+     * 故只留最近 `DISMISS_GUARD_MAX` 条。
+     */
+    private readonly dismissedIds;
+    constructor(deps: MessageDelivererDeps);
+    /**
+     * 裁决表（规格顺序）：session 404 → harness 无法判定 400 → 按模式落通道
+     * （auto 忙闲 / prompt 层可用性）→ 通道不支持 409+reason → 无项目 400/404 →
+     * headless 被占 409。通过后发号、广播 message.created 并立即投递。
+     */
+    send(input: SendInput): Promise<SendResult>;
+    /** 管道消息现查（内存态；sequence 引擎 / 路由回显用）。 */
+    getMessage(id: string): PipeMessage | null;
+    /**
+     * 在途视图（GET /sessions/:id/messages）：promptbox 待递送 ∪ 内存态——
+     * 在途（delivering/running）与 failed/timeout/暂停闸成因常驻；delivered/
+     * injected/succeeded 在驻留窗口（visibleTtlMs）内展示 via/acked，过后消失
+     * （历史在目标会话自己的转录里）。例外 = **已送达还没回执**的：过了窗口也留着，
+     * 它就是「还没落进对话」，等回执或未回执闸落定再说。
+     */
+    listVisible(sessionId: string): PipeMessage[];
+    /** 该会话是否有队列行（ingest 冲洗守卫，O(1)）。 */
+    hasQueued(sessionId: string): boolean;
+    /**
+     * 在途计数（sessionId → 条数）：队列 pending（未送达）∪ 内存 delivering/running
+     * （在飞）。会话行角标用——终态（injected/delivered/succeeded/…）不计。
+     */
+    listInflightCounts(): Map<string, number>;
+    /** 层② 终端 send-text 通道是否装配（能力矩阵 prompt 列合成用）。 */
+    hasTerminalChannel(): boolean;
+    /**
+     * 自续冲洗：本轮投出去过（有进展）但队列仍有行 → 隔一拍继续，直到排空。
+     * 只有「有进展」才续（通道不可用时不续，避免热循环）；沿用节流间隔作拍长。
+     */
+    private scheduleFlushContinuation;
+    /** 等回执的那条已经落地（回执到 / 失败 / 行没了）→ 撤防，返回 true。 */
+    private ackGateOpen;
+    /**
+     * 队头是否还压着：上一条终端投递没回执 / 队列有积压 / 泵正在推进。
+     * 是 → 新消息只能排到队尾；不是 → 立刻投（低延迟路径）。
+     */
+    private blockedAhead;
+    /**
+     * hook 旁路上报的会话 inbox 目标（内存态；socket 空 = 该会话此刻不可直投）。
+     * token 只在此存活，不落库、不进 UI、不写日志。
+     */
+    noteInboxSocket(sessionId: string, target: {
+        socket: string;
+        token: string | null;
+    } | null): void;
+    /**
+     * hook 旁路上报的会话 pane 定位 env（**每个 hook 事件覆盖刷新**：会话换 pane /
+     * resume 到新窗口后，下一次事件就把定位改过来，与 inbox 凭据同一自愈口径）。
+     */
+    notePaneEnv(sessionId: string, env: Record<string, string>): void;
+    /** 原子写（临时文件 + rename）+ 0600；失败静默（内存态照常能定位，下次再落）。 */
+    private persistPaneEnvs;
+    /**
+     * 会话退出（`SessionEnd` 到达）：旁路事实随进程作废——inbox 凭据出盘（旧 socket
+     * 已死，留着只会让下一次投递白试一轮）、pane 定位清（窗口随会话关）。**会话行与
+     * 它的对话照常保留**（那是历史，不是旁路事实），所以不走 `forgetSession` 的删会话
+     * 级联；压队的行此刻也已成死信 → 一并按 offline 落定（同 A 的口径）。
+     */
+    sessionExited(sessionId: string): void;
+    /**
+     * 会话 → 所在可见屏幕（会话列表分块的数据面）。旁路 env 与投递路径共用同一份
+     * 缓存，不另采一次；后端没有反查能力 = 空表（那些会话不分组）。顺手摘掉已判死
+     * 会话的 env：那是上一次见到它时的快照，它不会再来报一次，留着只会让死会话常占块头。
+     */
+    sessionTerminals(): Promise<Record<string, SessionTerminal | null>>;
+    /**
+     * 会话级投递诊断（只读内存态 + 既有 repo，纯现算）：三通道各自「现在能不能投」
+     * + 队列积压/暂停闸。判定条件集就是投递路径的可用前提，不另立第二份事实源。
+     *
+     * 只回布尔与枚举——**socket 地址与 token 永不出栈**（与「凭据不进 UI/日志」同口径）。
+     */
+    diagnose(sessionId: string): SessionDeliveryDiagnosis;
+    /**
+     * 投递回执：会话自己的 UserPromptSubmit 到了 —— 其 prompt 原文与在途条目匹配
+     * 即成真（`acked`）。中继/终端/socket 三路通用（中继的原文外面裹着 Claude Code
+     * 自己的 `<cross-session-message …>` 壳，比对时归一掉）。返回命中消息的随附图
+     * id（调用方挂到开轮事件上做气泡缩略图；空表 = 命中但没图 / 没命中）。
+     *
+     * 带图的消息比对放宽：claude 的粘贴处理器把图路径从 prompt 剥掉、还会把多行
+     * 文本 chunk 用空串连起来，`msg.text` 与 UPS 原文可能对不上——对不上不代表
+     * 没送达，按「去空白后相同」再认一次；纯图发送（无用户文本）的 UPS prompt 是
+     * 空的 / 只剩 `[Image #N]`，无文本可比，这样一条 UPS 认领最新那条纯图在途。
+     *
+     * `eventId` = 这条 UPS 自己的事件 id：命中即记下来，对话面据此把投递行精确挂到
+     * 对应气泡上（见 `PipeMessage.ackedEventId`）。
+     */
+    onSessionPrompt(sessionId: string, prompt: string, eventId?: number): string[];
+    /** 未回执闸布防：prompt 送达后 ackStallMs 内没等到 UPS 回执 → 暂停该会话队列。 */
+    private armAckWatch;
+    /** 置闸：成因消息标记 stalled（常驻在途视图）+ message.stalled 帧（web 重拉）。 */
+    private stall;
+    /**
+     * 远程作答（阻塞式交互）：向目标会话所在 pane 发裸键序——模态框只吃键盘，
+     * inbox/中继投递答不了。键序经白名单（`ANSWER_KEYS`）；pane 匹配复用层② 的
+     * 标题 + cwd 判定（歧义/找不到 pane = 409，不去别的终端乱打）。成功由调用
+     * 方乐观标记已答（PostToolUse 到达照常清除）。
+     */
+    answer(sessionId: string, atoms: readonly string[]): Promise<AnswerResult>;
+    /**
+     * 中断目标会话正在跑的回合（dashboard 停止按钮）：往 pane 打**一记 ESC**。
+     * 键序固定死在服务端（**不当参数收**）——这条通道一放开就是任意击键注入；
+     * 且只打一记：claude 里 ESC 一次是中断，连打两次是开历史回退菜单。
+     */
+    interrupt(sessionId: string): Promise<AnswerResult>;
+    /**
+     * 关掉会话所在的 pane（会话生命周期收尾）：宿主随 pane 一起退出——这是「退出
+     * 会话」的远程等价（harness 没有「请退出」这种信号）。**会话行与它的对话照常
+     * 保留**（那是历史，同 SessionEnd 口径），只把它从「活着」的世界里摘出去。
+     */
+    closePane(sessionId: string): Promise<AnswerResult>;
+    /**
+     * 执行模式切换（Shift+Tab 的远程等价）：一记固定键，宿主自己算下一个模式。
+     * 答「现在是哪个模式」不由这里管——Shift+Tab 不发任何 hook 事件、不落转录，
+     * 实时态只能是 hook 事件里最近一次的 `permission_mode`（「最后已知」）。
+     */
+    cycleMode(sessionId: string): Promise<AnswerResult>;
+    /**
+     * 模型切换：往会话的输入行打宿主自己的 `/model <名>` 并提交（会话级、不落盘）。
+     * 名字是**用户自填**的（网关模型 ID 会增删，不做静态映射表），故只验形态不验
+     * 词表——宿主对未知名自己回 `Unknown model '…'`，那句话进会话转录、用户看得见。
+     */
+    setModel(sessionId: string, name: string): Promise<AnswerResult>;
+    /**
+     * 键序注入路径（作答 / 中断 / 关 pane）共用的落点解析：会话 → 项目 → 终端通道
+     * → pane。全部失败原因是**可判定的语义拒绝**（404/409），调用方原样回给 HTTP；
+     * 两条 409 是给用户看的（web 直拼在「停止失败：」这类动作名后面），故写成中文
+     * 修法，动作名随调用方换。
+     */
+    private sessionKeysTarget;
+    /**
+     * 手动重发（暂停闸的解除动作）：prompt 通道 failed 或 delivered-未回执 的消息
+     * 重走投递（socket → 中继 → 终端 → 队列），重发即解闸并重新布防回执闸。
+     */
+    resend(messageId: string): Promise<SendResult>;
+    /**
+     * 删除一条在途视图里的消息行（dashboard「删除」）：内存行摘掉、队列待递送行
+     * （pending 只活在 promptbox 文件里）删行——两种都不再出现在这个会话的对话尾巴上。
+     * 内存行**不影响已投递的内容**（真到了会话，转录里的记录仍在）；队列行则是
+     * **取消发送**（还没出去）。内存行若正是暂停闸的成因 → 一并解闸（否则闸留着却
+     * 没有成因行可看、可操作），并续排空积压（下一条各自重新布防回执闸）。在飞
+     * （delivering/running）的行不删：落定回调会把行写回来，删了也白删。
+     */
+    dismiss(sessionId: string, messageId: string): AnswerResult;
+    /** 删掉队列里的一条待递送行（读到的行自己带 sessionId，配不上即不算命中）。 */
+    private dropQueued;
+    /**
+     * 队列冲洗（幂等）：直投命中即走；否则中继 / 终端按面定序（手动面终端优先）；
+     * 都不行留队列。
+     * **严格串行**：一轮只送一条，等它的 UPS 回执到了再自续下一拍——同一队列由各模式共用，
+     * 顺序与「一条一条」是队列本身的语义，不是各通道各自节流的副产品。
+     */
+    flushSession(sessionId: string): Promise<void>;
+    private flushSessionInner;
+    /** 队列空了就把冲洗索引摘掉（本轮提前返回的路径都得过它，否则刷新器永远白探）。 */
+    private settleQueueIndex;
+    /** 刷新器入口：扫全部队列会话（只在队列非空时被调用才有意义）。 */
+    flushAll(): Promise<void>;
+    /** 会话删除级联：内存态 + 队列行。返回清理行数（口径与旧 DB 计数一致）。 */
+    forgetSession(sessionId: string): number;
+    /** 项目归档级联（内存态按会话→项目归属判定；队列行按会话逐个清）。 */
+    forgetProject(projectId: number): number;
+    /** harness 归属 = 最新事件 source（open-terminal 同口径）。 */
+    private surfaceOfSession;
+    /**
+     * mode → 实际通道。prompt = 层① 原生 || 层② 终端通道（都没有才 409）；
+     * auto 的忙/闲基准 = turnOpenOf，忙 → inject（无通道才拒绝，绝不无头抢占），
+     * 闲 → headless。对象 = 拒绝（409 reason）；字符串 = 选中的通道。
+     */
+    private resolveChannel;
+    /** 不支持原因：面声明优先，缺省兜底文案。 */
+    private unsupportedReason;
+    /**
+     * 目标会话的 pane：① **hook 旁路上报的终端定位**（精确——会话自己所在的 pane，
+     * 与标题是否漂移无关，也覆盖从没上报过标题的会话；后端已做存在性校验）→
+     * ② 回落「标题（剥 spinner 前缀，字符集含 ◐ 等输入等待态）+ 项目 cwd」启发式
+     * （无定位能力的终端 / 老 hook），歧义拒绝不打。
+     */
+    private terminalPaneFor;
+    /** 层② 通道现取（装配期注入；与 settings 的 preset 无关，只有「没装」才是 null）。 */
+    private terminalChannel;
+    /** prompt 通道入口（send 的即时路径）：层① 命中即时中继，层② 异步找 pane，都不行入队。 */
+    private deliverPrompt;
+    /**
+     * 层①-a 直投尝试：成功返回落定后的内存行；回落（无面 / 非手动 / 无目标 / 写失败）
+     * 返回 null。**队列冲洗也走它**——冲洗恰好由「刚上报凭据的那条 hook 事件」触发，
+     * 命中率最高；队列绕过它直奔中继，手动面就会凭空多出跨会话包裹与英文注记。
+     */
+    private tryInboxDeliver;
+    /** 入队（promptbox 追加 + 会话索引登记）。 */
+    private queueEntry;
+    /**
+     * 该会话是否已判死：claude 注册表 `pidAlive === false` 才认，`null` 不猜
+     * （codex / 新会话豁免窗 / SessionStart 空壳行都落 null）。判据与「已终止」
+     * 态、两条 terminated 补射同源（claude-liveness 的 pidAliveOf）——消息行与
+     * 会话行不会各说各话。
+     */
+    private sessionJudgedDead;
+    /**
+     * 判死落定：三层全无通路、目标进程又不在——**不假装排队**，落 `failed` +
+     * `reason: 'offline'`（`message.finished` 帧照抛，既有 messageFailed 订阅提醒
+     * 生效）。**刻意不置暂停闸**：队列整批转 offline 后已空，闸只会挡住用户重发
+     * ——重发是有意的可逆出口（判活残差 / 会话其实活着时，一点就回来）。
+     */
+    private failOffline;
+    /** 冲洗时判死：**该会话全部队列行**都是死信（死会话投不进去），整批落定 + 清队。 */
+    private failQueuedOffline;
+    /**
+     * 层① 中继：复用 HeadlessRunner 的 spawn 基建（win32 shell 单串 + stdin +
+     * 超时），键 = 合成键（不占目标会话的 headless 并发闸）。返回是否启动成功。
+     */
+    private runRelay;
+    /**
+     * 中继终态：成功 = delivered（+message.delivered，布防回执闸；中继闸释放后若还有
+     * 积压继续下一批）；失败 = failed 留内存可见（+message.finished）并置暂停闸——
+     * 不自动重试（避免对活着但拒收的会话反复打中继），手动重发解除。
+     */
+    private settleRelay;
+    /** 层② 终端注入终态（语义同中继：成功 delivered / 失败 failed 可见）。 */
+    private runTerminalPrompt;
+    /**
+     * 层② 只补一记回车（重发「已贴进框、没回执」的行）：文本在上一次投递里已经
+     * 落到会话的输入框，缺的只是那记提交键——重贴一次会在框里叠一份，用户收到
+     * 两遍正文与两遍图。
+     */
+    private runTerminalSubmit;
+    private runTerminal;
+    /**
+     * 投递文本 = 用户原文经 harness `imageAttach.composePrompt` 现合成（带图时在
+     * 原文后追加图引用形态）。**只在投递那一刻合成**——`msg.text` 恒为用户原文
+     * （回执比对与气泡文案都要它），队列行也不存合成结果（换 harness 后仍按现面合成）。
+     */
+    private wireTextOf;
+    private hasImages;
+    /** inject 通道：信封写 outbox → injected（fire-and-forget 语义）。 */
+    private deliverInject;
+    /** headless 通道：置 running → 无头 spawn；终态经 onSettle 后台回写。 */
+    private deliverHeadless;
+    /** 信封：面可覆写（harness 自己的表示法）；缺省 weave 通用头 + 正文。 */
+    private renderEnvelope;
+    /** 终态落定（幂等，per-run state 守卫）：回写 → message.finished。 */
+    private settle;
+    private bus;
+}
+export {};

package/node_modules/@weavecode/server/dist/hooks/message-deliverer.js

@@ -0,0 +1,4 @@
+import{randomUUID as A}from"node:crypto";import{chmodSync as D,mkdirSync as j,readFileSync as T,renameSync as P,writeFileSync as M}from"node:fs";import{tmpdir as _}from"node:os";import{dirname as B,join as p}from"node:path";import{WEAVE_INJECTION_MARKER as C,isHarness as R}from"@weavecode/core";import{messagingSurfaceFor as W}from"../surfaces.js";import{claudeLivenessById as g,pidAliveOf as v}from"../daemon/claude-liveness.js";import{normalizeDirKey as I}from"../daemon/opener.js";import{HeadlessRunner as F}from"./headless-runner.js";import{appendOutbox as q,hooksRoot as N}from"./mirror.js";import{INBOX_TARGETS_FILE as $,InboxSocketRegistry as K,deliverViaInboxSocket as L}from"./inbox-socket.js";import{appendPromptbox as Q,readAllPromptbox as H,readPromptbox as m,removePromptboxBySession as J,removePromptboxEntries as f,scanQueuedSessionIds as G}from"./promptbox.js";const U=()=>_(),V=1e3,X=6e4,z=12e4,Z=8,Y="Session is not running",ee=200,w=/^(?:[1-9]|n|\t|\r|\x1b\[B)$/,se=/^[^\x00-\x1f\x7f]*$/,te="\x1B",ie="\x1B[Z",ne=/^[^\s\x00-\x1f\x7f]{1,128}$/,re=u=>`/model ${u}`,oe=120,k=C;function y(u){return u.replace(/<\/?cross-session-message[^>]*>/g,"").replace(/\s+/g," ").trim()}function ae(u){const e=u.trimStart();return e.startsWith(k)?e.slice(k.length):e}function b(u){return u.replace(/\s+/g,"")}const O="pane-envs.json";function de(u){try{const e=JSON.parse(T(u,"utf8"));if(typeof e!="object"||e===null)return{};const t={};for(const[s,i]of Object.entries(e)){if(typeof i!="object"||i===null)continue;const n={};for(const[r,o]of Object.entries(i))typeof o=="string"&&o&&(n[r]=o);Object.keys(n).length>0&&(t[s]=n)}return t}catch{return{}}}const le=u=>new Promise(e=>setTimeout(e,u));export class MessageDeliverer{deps;headless;hooksDir;memory=new Map;queuedSessions;inboxSockets;paneEnvs;persistedPaneEnvs;flushScheduled=new Set;flushing=new Set;stalled=new Map;awaitingAck=new Map;dismissedIds=new Set;constructor(e){this.deps=e,this.headless=e.headless??new F({spawnImpl:e.spawnImpl,killImpl:e.killImpl}),this.hooksDir=e.hooksDir??N(),this.inboxSockets=new K(p(this.hooksDir,$));const t=de(p(this.hooksDir,O));this.paneEnvs=new Map(Object.entries(t)),this.persistedPaneEnvs=JSON.stringify(t),this.queuedSessions=G(this.hooksDir)}async send(e){const t=this.deps.sessions.getBySessionId(e.toSessionId);if(!t)return{ok:!1,status:404,error:"Session not found"};const s=this.surfaceOfSession(e.toSessionId);if(!s)return{ok:!1,status:400,error:"Session has no hook events to determine its harness"};const i=e.images?[...e.images]:[];if(i.length>0&&!s.imageAttach)return{ok:!1,status:409,error:"This harness cannot receive images"};const n=this.resolveChannel(e.mode,e.toSessionId,s);if(typeof n!="string")return{ok:!1,status:409,error:n.reason};if(t.projectId==null)return{ok:!1,status:400,error:"Session is not bound to a project"};const r=this.deps.projects.getById(t.projectId);if(!r)return{ok:!1,status:404,error:"Project not found"};if(n==="headless"&&this.headless.isBusy(e.toSessionId))return{ok:!1,status:409,error:"Session already has a running run"};const o={fromLabel:e.fromKind==="session"?`session ${e.fromSessionId??"unknown"}`:e.fromKind,at:new Date().toISOString(),mode:n},a={id:A(),sessionId:e.toSessionId,text:e.text,...i.length>0?{images:i}:{},mode:e.mode,oneWay:e.oneWay===!0,...e.forceTerminal===!0?{forceTerminal:!0}:{},channel:n,status:"pending",at:o.at},d=n==="prompt"&&this.blockedAhead(a.sessionId);d&&(this.queueEntry(a,r.token),this.scheduleFlushContinuation(a.sessionId));const l=d?{ok:!0,messageId:a.id,status:"pending",message:a}:n==="inject"?this.deliverInject(a,r.token,o,s):n==="headless"?this.deliverHeadless(a,r.path,o,s):await this.deliverPrompt(a,t,r,s);return this.bus({kind:"message.created",messageId:a.id,sessionId:a.sessionId,mode:a.mode,at:a.at}),l}getMessage(e){return this.memory.get(e)??null}listVisible(e){const t=this.deps.visibleTtlMs??X,s=Date.now(),i=[],n=this.deps.sessions.getBySessionId(e);if(n?.projectId!=null){const r=this.deps.projects.getById(n.projectId);if(r)for(const o of m(this.hooksDir,r.token))o.sessionId===e&&i.push({id:o.id,sessionId:e,text:o.text,...o.images&&o.images.length>0?{images:o.images}:{},mode:"prompt",oneWay:o.oneWay===!0,...o.forceTerminal===!0?{forceTerminal:!0}:{},channel:"prompt",status:"pending",at:o.at})}for(const r of this.memory.values()){if(r.sessionId!==e)continue;if(r.stalled===!0||r.status==="delivering"||r.status==="running"){i.push(r);continue}if(r.status==="failed"||r.status==="timeout"){i.push(r);continue}const o=r.settledAt?Date.parse(r.settledAt):NaN;(r.status==="delivered"&&r.acked!==!0||!Number.isNaN(o)&&s-o<t)&&i.push(r)}return i.sort((r,o)=>r.at<o.at?-1:1)}hasQueued(e){return this.queuedSessions.has(e)}listInflightCounts(){const e=new Map,t=s=>{e.set(s,(e.get(s)??0)+1)};for(const s of H(this.hooksDir))t(s.sessionId);for(const s of this.memory.values())(s.status==="delivering"||s.status==="running")&&t(s.sessionId);return e}hasTerminalChannel(){return this.terminalChannel()!=null}scheduleFlushContinuation(e){if(this.flushScheduled.has(e))return;this.flushScheduled.add(e),setTimeout(()=>{this.flushScheduled.delete(e),this.flushSession(e)},this.deps.flushGapMs??V).unref?.()}ackGateOpen(e){const t=this.awaitingAck.get(e);if(t===void 0)return!0;const s=this.memory.get(t);return s&&s.acked!==!0&&s.status!=="failed"&&s.status!=="timeout"?!1:(this.awaitingAck.delete(e),!0)}blockedAhead(e){return this.ackGateOpen(e)?this.queuedSessions.has(e)||this.flushing.has(e):!0}noteInboxSocket(e,t){this.inboxSockets.set(e,t)}notePaneEnv(e,t){this.paneEnvs.set(e,t),this.persistPaneEnvs()}persistPaneEnvs(){const e=JSON.stringify(Object.fromEntries(this.paneEnvs));if(e===this.persistedPaneEnvs)return;const t=p(this.hooksDir,O);try{j(B(t),{recursive:!0});const s=`${t}.tmp`;M(s,`${e}
+`,{encoding:"utf8",mode:384}),P(s,t),D(t,384),this.persistedPaneEnvs=e}catch{}}sessionExited(e){this.inboxSockets.forget(e),this.paneEnvs.delete(e),this.persistPaneEnvs(),this.awaitingAck.delete(e);const t=this.deps.sessions.getBySessionId(e),s=t?.projectId==null?null:this.deps.projects.getById(t.projectId);if(!s)return;const i=m(this.hooksDir,s.token).filter(n=>n.sessionId===e);this.failQueuedOffline(e,i.filter(n=>!this.dismissedIds.has(n.id)))}async sessionTerminals(){const e=this.terminalChannel();if(!e?.locateScreens||this.paneEnvs.size===0)return{};const t={},s=this.deps.livenessOf?.()??g();for(const[i,n]of this.paneEnvs){if(this.sessionJudgedDead(i,s)){this.paneEnvs.delete(i),this.persistPaneEnvs();continue}t[i]=n}return e.locateScreens(t)}diagnose(e){const t=this.surfaceOfSession(e),s=this.deps.sessions.livenessRowOf(e),i=s?v(s,this.deps.livenessOf?.()??g()):null,n=t?.promptInbox??null,r=this.inboxSockets.get(e),o=n?r?n.requiresAuthOn(process.platform)&&!r.token?{status:"unavailable",reason:"auth-token-required"}:{status:"ready",reason:null}:{status:"unavailable",reason:"no-credentials"}:{status:"unavailable",reason:"no-mechanism"},a=t?.prompt?.resolve(e)??null,d=t?.prompt?a?{status:"ready",reason:null}:{status:"unavailable",reason:"no-peer-name"}:{status:"unavailable",reason:"no-mechanism"},l=this.paneEnvs.has(e),h=this.terminalChannel()?l?{status:"ready",reason:null}:{status:"unknown",reason:"no-pane-env"}:{status:"unavailable",reason:"no-backend"},c=this.deps.sessions.getBySessionId(e),S=c?.projectId==null?null:this.deps.projects.getById(c.projectId),E=S?m(this.hooksDir,S.token).filter(x=>x.sessionId===e).length:0;return{alive:i,inbox:o,relay:d,terminal:h,paneEnvReported:l,pending:E,stalled:this.stalled.has(e)}}onSessionPrompt(e,t,s){const i=y(ae(t)),n=i.replace(/\[Image #\d+\]/gi,"").trim(),r=[];let o=!1;for(const a of[...this.memory.values()].reverse()){if(a.sessionId!==e||a.acked||a.mode!=="prompt")continue;const d=y(a.text),l=!!d&&(d.length>=Z?i.includes(d):i===d),h=(a.images?.length??0)>0&&(d?b(i).includes(b(d)):n.length===0);!l&&!h||(o=!0,this.memory.set(a.id,{...a,acked:!0,stalled:!1,...s===void 0?{}:{ackedEventId:s}}),this.stalled.get(e)?.messageId===a.id&&this.stalled.delete(e),this.awaitingAck.get(e)===a.id&&this.awaitingAck.delete(e),r.push(...a.images?.map(c=>c.id)??[]),this.bus({kind:"message.acknowledged",messageId:a.id,sessionId:e,at:new Date().toISOString()}))}return o&&this.queuedSessions.has(e)&&this.scheduleFlushContinuation(e),r}armAckWatch(e){setTimeout(()=>{const s=this.memory.get(e.id);!s||s.acked||s.status!=="delivered"||this.stall(s.sessionId,s,"unacked")},this.deps.ackStallMs??z).unref?.()}stall(e,t,s){this.stalled.set(e,{messageId:t.id,reason:s});const i=this.memory.get(t.id);i&&this.memory.set(t.id,{...i,stalled:!0}),this.bus({kind:"message.stalled",messageId:t.id,sessionId:e,reason:s,at:new Date().toISOString()})}async answer(e,t){if(t.length===0||!w.test(t[0])||t.some(i=>!w.test(i)&&!se.test(i)))return{ok:!1,status:400,error:"Invalid answer keys"};const s=await this.sessionKeysTarget(e);if(!s.ok)return s;try{for(const[i,n]of t.entries())i>0&&await le(oe),await s.terminal.sendKeys(s.paneId,n);return{ok:!0}}catch(i){return{ok:!1,status:409,error:i instanceof Error?i.message:String(i)}}}async interrupt(e){const t=await this.sessionKeysTarget(e);if(!t.ok)return t;try{return await t.terminal.sendKeys(t.paneId,te),{ok:!0}}catch(s){return{ok:!1,status:409,error:s instanceof Error?s.message:String(s)}}}async closePane(e){const t=await this.sessionKeysTarget(e,"\u5173\u95ED");if(!t.ok)return t;try{return await t.terminal.closePane(t.paneId),{ok:!0}}catch(s){return{ok:!1,status:409,error:s instanceof Error?s.message:String(s)}}}async cycleMode(e){const t=await this.sessionKeysTarget(e);if(!t.ok)return t;try{return await t.terminal.sendKeys(t.paneId,ie),{ok:!0}}catch(s){return{ok:!1,status:409,error:s instanceof Error?s.message:String(s)}}}async setModel(e,t){const s=t.trim();if(!ne.test(s))return{ok:!1,status:400,error:"\u6A21\u578B\u540D\u5F62\u6001\u4E0D\u5408\u6CD5\uFF08\u4E0D\u542B\u7A7A\u767D\u4E0E\u63A7\u5236\u5B57\u7B26\uFF0C\u2264128 \u5B57\u7B26\uFF09"};const i=await this.sessionKeysTarget(e);if(!i.ok)return i;try{return await i.terminal.sendText(i.paneId,re(s)),{ok:!0}}catch(n){return{ok:!1,status:409,error:n instanceof Error?n.message:String(n)}}}async sessionKeysTarget(e,t="\u51FB\u952E"){const s=this.deps.sessions.getBySessionId(e);if(!s)return{ok:!1,status:404,error:"Session not found"};if(s.projectId==null)return{ok:!1,status:400,error:"Session is not bound to a project"};const i=this.deps.projects.getById(s.projectId);if(!i)return{ok:!1,status:404,error:"Project not found"};const n=this.terminalChannel();if(!n)return{ok:!1,status:409,error:`\u7EC8\u7AEF\u901A\u9053\u672A\u88C5\u914D\uFF0C\u65E0\u6CD5\u8FDC\u7A0B${t}`};const r=await this.terminalPaneFor(s,i);return r?{ok:!0,terminal:n,paneId:r.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${t}\u901A\u9053`}}async resend(e){const t=this.memory.get(e);if(!t)return{ok:!1,status:404,error:"Message not found"};if(!(t.channel==="prompt"&&(t.status==="failed"||t.status==="delivered"&&!t.acked)))return{ok:!1,status:409,error:"Message is not resendable"};const i=this.deps.sessions.getBySessionId(t.sessionId);if(!i)return{ok:!1,status:404,error:"Session not found"};if(i.projectId==null)return{ok:!1,status:400,error:"Session is not bound to a project"};const n=this.deps.projects.getById(i.projectId);if(!n)return{ok:!1,status:404,error:"Project not found"};const r=this.surfaceOfSession(t.sessionId);if(!r)return{ok:!1,status:400,error:"Session has no hook events to determine its harness"};if(this.stalled.get(t.sessionId)?.messageId===e&&this.stalled.delete(t.sessionId),t.status==="delivered"&&t.via==="terminal"&&this.terminalChannel()){const d=await this.terminalPaneFor(i,n);if(d)return this.memory.set(e,{...t,status:"delivering",stalled:!1,settledAt:null}),this.runTerminalSubmit(e,d.id),this.bus({kind:"message.created",messageId:e,sessionId:t.sessionId,mode:t.mode,at:new Date().toISOString()}),{ok:!0,messageId:e,status:"delivering",message:this.memory.get(e)}}this.memory.delete(e);const o={...t,status:"pending",stalled:!1,acked:!1,settledAt:null},a=await this.deliverPrompt(o,i,n,r);return this.bus({kind:"message.created",messageId:o.id,sessionId:o.sessionId,mode:o.mode,at:new Date().toISOString()}),a}dismiss(e,t){const s=this.memory.get(t);if(s){if(s.status==="delivering"||s.status==="running")return{ok:!1,status:409,error:"Message is still in flight"};this.memory.delete(t),this.stalled.get(s.sessionId)?.messageId===t&&this.stalled.delete(s.sessionId),this.awaitingAck.get(s.sessionId)===t&&this.awaitingAck.delete(s.sessionId),this.queuedSessions.has(s.sessionId)&&this.scheduleFlushContinuation(s.sessionId)}else if(!this.dropQueued(e,t))return{ok:!1,status:404,error:"Message not found"};return this.bus({kind:"message.dismissed",messageId:t,sessionId:e,at:new Date().toISOString()}),{ok:!0}}dropQueued(e,t){const s=this.deps.sessions.getBySessionId(e);if(s?.projectId==null)return!1;const i=this.deps.projects.getById(s.projectId);if(!i)return!1;const n=m(this.hooksDir,i.token);if(!n.some(r=>r.id===t&&r.sessionId===e))return!1;for(f(this.hooksDir,i.token,new Set([t])),this.dismissedIds.add(t);this.dismissedIds.size>ee;){const r=this.dismissedIds.values().next().value;if(r===void 0)break;this.dismissedIds.delete(r)}return n.some(r=>r.sessionId===e&&r.id!==t)||this.queuedSessions.delete(e),!0}async flushSession(e){if(!this.stalled.has(e)&&!this.flushing.has(e)&&this.queuedSessions.has(e)){this.flushing.add(e);try{await this.flushSessionInner(e)}catch{}finally{this.flushing.delete(e)}}}async flushSessionInner(e){if(!this.ackGateOpen(e))return;const t=this.deps.sessions.getBySessionId(e);if(t?.projectId==null)return;const s=this.deps.projects.getById(t.projectId);if(!s)return;const i=m(this.hooksDir,s.token).filter(o=>o.sessionId===e);if(i.length===0){this.queuedSessions.delete(e);return}if(this.sessionJudgedDead(e)){this.failQueuedOffline(e,i.filter(o=>!this.dismissedIds.has(o.id)));return}const n=this.surfaceOfSession(e),r=n?.prompt??null;for(const o of i){if(this.stalled.has(e))return;if(this.dismissedIds.has(o.id))continue;const a={id:o.id,sessionId:e,text:o.text,...o.images&&o.images.length>0?{images:o.images}:{},mode:"prompt",oneWay:o.oneWay===!0,...o.forceTerminal===!0?{forceTerminal:!0}:{},via:"socket",channel:"prompt",status:"pending",at:o.at};if(this.hasImages(a)&&this.terminalChannel()){const h=await this.terminalPaneFor(t,s);if(h){f(this.hooksDir,s.token,new Set([o.id])),this.memory.set(a.id,{...a,via:"terminal",status:"delivering"}),this.awaitingAck.set(e,a.id),await this.runTerminalPrompt(a.id,h.id,this.wireTextOf(a)),this.settleQueueIndex(e,s.token);return}}if(n&&await this.tryInboxDeliver(a,n)){f(this.hooksDir,s.token,new Set([o.id])),this.settleQueueIndex(e,s.token);return}const d=r?.resolve(e)??null,l=a.forceTerminal===!0?["terminal"]:a.oneWay===!0?["terminal","relay"]:["relay","terminal"];for(const h of l){if(h==="relay"&&r&&d){if(this.memory.set(a.id,{...a,status:"delivering",via:"relay"}),!this.runRelay(a,r,d.name)){this.memory.delete(a.id);return}this.awaitingAck.set(e,a.id),f(this.hooksDir,s.token,new Set([o.id]));break}if(h==="terminal"&&this.terminalChannel()){const c=await this.terminalPaneFor(t,s);if(c){f(this.hooksDir,s.token,new Set([o.id])),this.memory.set(a.id,{...a,via:"terminal",status:"delivering"}),this.awaitingAck.set(e,a.id),await this.runTerminalPrompt(a.id,c.id,this.wireTextOf(a));break}}}if(this.awaitingAck.get(e)===a.id){this.settleQueueIndex(e,s.token);return}return}this.settleQueueIndex(e,s.token)}settleQueueIndex(e,t){m(this.hooksDir,t).every(s=>s.sessionId!==e)&&this.queuedSessions.delete(e)}async flushAll(){for(const e of[...this.queuedSessions])await this.flushSession(e)}forgetSession(e){let t=0;for(const[s,i]of this.memory)i.sessionId===e&&(this.memory.delete(s),t++);return t+=J(this.hooksDir,e),this.queuedSessions.delete(e),this.stalled.delete(e),this.awaitingAck.delete(e),this.inboxSockets.forget(e),this.paneEnvs.delete(e),this.persistPaneEnvs(),t}forgetProject(e){let t=0;for(const[s,i]of this.memory)this.deps.sessions.getBySessionId(i.sessionId)?.projectId===e&&(this.memory.delete(s),this.inboxSockets.forget(i.sessionId),this.paneEnvs.delete(i.sessionId),this.stalled.delete(i.sessionId),this.awaitingAck.delete(i.sessionId),t++);for(const s of[...this.queuedSessions])this.deps.sessions.getBySessionId(s)?.projectId===e&&(t+=this.forgetSession(s));return this.persistPaneEnvs(),t}surfaceOfSession(e){const t=this.deps.hookEvents.listBySession(e,1),s=t[t.length-1]?.source;return R(s)?this.deps.surfaceFor?.(s)??W(s):null}resolveChannel(e,t,s){if(e==="prompt")return s.prompt||this.terminalChannel()?"prompt":{reason:s.unsupportedReasons?.prompt??`Harness "${s.harness}" has no native prompt channel and the configured terminal cannot inject text`};if(e==="inject"||e==="headless")return(e==="inject"?s.inject:s.headless)?e:{reason:this.unsupportedReason(s,e)};const n=this.deps.sessions.turnOpenOf(t)?"inject":"headless";return(n==="inject"?s.inject:s.headless)?n:{reason:this.unsupportedReason(s,n)}}unsupportedReason(e,t){return e.unsupportedReasons?.[t]??`Harness "${e.harness}" does not support the ${t} messaging channel`}async terminalPaneFor(e,t){const s=this.terminalChannel();if(!s)return null;const i=this.paneEnvs.get(e.sessionId);if(i){const d=await s.locatePane?.(i).catch(()=>null);if(d)return{id:d}}if(!e.title)return null;const n=e.title.replace(/^[✻✽✶✳✢⋅◦✦✧∘◐◑◒◓*]+\s*/,""),r=I(t.path,process.platform);let o;try{o=await s.listPanes()}catch{return null}const a=o.filter(d=>d.title!=null&&d.cwd!=null&&r!=null&&d.title.replace(/^[✻✽✶✳✢⋅◦✦✧∘◐◑◒◓*]+\s*/,"")===n&&I(d.cwd,process.platform)===r);return a.length===1?a[0]:null}terminalChannel(){const e=this.deps.terminal;return e&&e.available()?e:null}async deliverPrompt(e,t,s,i){if(this.sessionJudgedDead(e.sessionId))return{ok:!0,messageId:e.id,status:"failed",message:this.failOffline(e)};if(this.hasImages(e)&&this.terminalChannel()){const l=await this.terminalPaneFor(t,s);if(l)return this.memory.set(e.id,{...e,status:"delivering",via:"terminal"}),this.awaitingAck.set(e.sessionId,e.id),this.runTerminalPrompt(e.id,l.id,this.wireTextOf(e)),{ok:!0,messageId:e.id,status:"delivering",message:this.memory.get(e.id)}}const n=await this.tryInboxDeliver(e,i);if(n)return{ok:!0,messageId:e.id,status:"delivered",message:n};const r=i.prompt,o=r?.resolve(e.sessionId)??null,a=e.forceTerminal===!0?["terminal"]:e.oneWay===!0?["terminal","relay"]:["relay","terminal"];for(const l of a){if(l==="relay"&&r&&o){if(this.memory.set(e.id,{...e,status:"delivering",via:"relay"}),this.runRelay(e,r,o.name))return this.awaitingAck.set(e.sessionId,e.id),{ok:!0,messageId:e.id,status:"delivering",message:this.memory.get(e.id)};this.memory.delete(e.id)}if(l==="terminal"&&this.terminalChannel()){const h=await this.terminalPaneFor(t,s);if(h)return this.memory.set(e.id,{...e,status:"delivering",via:"terminal"}),this.awaitingAck.set(e.sessionId,e.id),this.runTerminalPrompt(e.id,h.id,this.wireTextOf(e)),{ok:!0,messageId:e.id,status:"delivering",message:this.memory.get(e.id)}}}if(this.sessionJudgedDead(e.sessionId))return{ok:!0,messageId:e.id,status:"failed",message:this.failOffline(e)};this.queueEntry(e,s.token);const d={...e,status:"pending"};return{ok:!0,messageId:e.id,status:"pending",message:d}}async tryInboxDeliver(e,t){const s=t.promptInbox,i=this.inboxSockets.get(e.sessionId);if(!s||e.oneWay!==!0||!i||e.forceTerminal===!0)return null;this.memory.set(e.id,{...e,status:"delivering",via:"socket"});try{await L(s,i,`${k}${this.wireTextOf(e)}`)}catch{return this.memory.delete(e.id),null}const n={...this.memory.get(e.id),status:"delivered",via:"socket",settledAt:new Date().toISOString()};return this.memory.set(e.id,n),this.awaitingAck.set(e.sessionId,e.id),this.armAckWatch(n),this.bus({kind:"message.delivered",messageId:e.id,sessionId:e.sessionId,at:new Date().toISOString()}),n}queueEntry(e,t){Q(this.hooksDir,t,[{id:e.id,sessionId:e.sessionId,text:e.text,oneWay:e.oneWay===!0,...e.forceTerminal===!0?{forceTerminal:!0}:{},...e.images&&e.images.length>0?{images:e.images}:{}}]),this.queuedSessions.add(e.sessionId)}sessionJudgedDead(e,t=this.deps.livenessOf?.()??g()){const s=this.deps.sessions.livenessRowOf(e);return s?v(s,t)===!1:!1}failOffline(e){const t=new Date().toISOString(),s={...e,status:"failed",reason:"offline",error:Y,settledAt:t};return this.memory.set(e.id,s),this.bus({kind:"message.finished",messageId:e.id,sessionId:e.sessionId,status:"failed",at:t}),s}failQueuedOffline(e,t){const s=this.deps.sessions.getBySessionId(e),i=s?.projectId==null?null:this.deps.projects.getById(s.projectId);if(!(!i||t.length===0)){for(const n of t)this.failOffline({id:n.id,sessionId:e,text:n.text,...n.images&&n.images.length>0?{images:n.images}:{},mode:"prompt",oneWay:n.oneWay===!0,channel:"prompt",status:"pending",at:n.at});f(this.hooksDir,i.token,new Set(t.map(n=>n.id))),this.queuedSessions.delete(e)}}runRelay(e,t,s){try{return this.headless.run({sessionId:`prompt-relay:${e.sessionId}`,cwd:U(),prompt:t.instruction(s,this.wireTextOf(e),{oneWay:e.oneWay===!0}),spec:{supported:!0,bin:t.bin,args:()=>[...t.args],promptStdin:!0},bin:this.deps.bin??process.env.WEAVE_CLAUDE_BIN??t.bin,timeoutMs:this.deps.relayTimeoutMs??0,detached:!1,onSettle:i=>this.settleRelay(e.id,i)})}catch(i){return this.settleRelay(e.id,{status:"failed",output:null,error:i instanceof Error?i.message:String(i)}),!0}}settleRelay(e,t){const s=this.memory.get(e);if(!s)return;if(t.status==="succeeded"){this.queuedSessions.has(s.sessionId)&&this.scheduleFlushContinuation(s.sessionId);const n={...s,status:"delivered",settledAt:new Date().toISOString()};this.memory.set(e,n),this.armAckWatch(n),this.bus({kind:"message.delivered",messageId:e,sessionId:s.sessionId,at:new Date().toISOString()});return}if(s.acked===!0){const n=new Date().toISOString();this.memory.set(e,{...s,status:"delivered",settledAt:n}),this.bus({kind:"message.delivered",messageId:e,sessionId:s.sessionId,at:n});return}const i={...s,status:"failed",error:t.error??`prompt relay ${t.status}`,settledAt:new Date().toISOString()};this.memory.set(e,i),this.stall(s.sessionId,i,"failed"),this.bus({kind:"message.finished",messageId:e,sessionId:s.sessionId,status:"failed",at:new Date().toISOString()})}async runTerminalPrompt(e,t,s){await this.runTerminal(e,i=>i.sendText(t,s))}async runTerminalSubmit(e,t){await this.runTerminal(e,s=>s.sendKeys(t,"\r"))}async runTerminal(e,t){const s=this.memory.get(e);if(!s)return;const i=this.terminalChannel();if(i)try{await t(i);const r={...this.memory.get(e)??s,status:"delivered",settledAt:new Date().toISOString()};this.memory.set(e,r),this.armAckWatch(r),this.bus({kind:"message.delivered",messageId:e,sessionId:s.sessionId,at:new Date().toISOString()})}catch(n){const r=this.memory.get(e)??s;if(r.acked===!0){const a=new Date().toISOString();this.memory.set(e,{...r,status:"delivered",settledAt:a}),this.bus({kind:"message.delivered",messageId:e,sessionId:r.sessionId,at:a});return}const o={...r,status:"failed",error:n instanceof Error?n.message:String(n),settledAt:new Date().toISOString()};this.memory.set(e,o),this.stall(s.sessionId,o,"failed"),this.bus({kind:"message.finished",messageId:e,sessionId:s.sessionId,status:"failed",at:new Date().toISOString()})}}wireTextOf(e){const t=e.images;return!t||t.length===0?e.text:this.surfaceOfSession(e.sessionId)?.imageAttach?.composePrompt(e.text,t)??e.text}hasImages(e){return(e.images?.length??0)>0}deliverInject(e,t,s,i){const n=this.renderEnvelope(this.wireTextOf(e),s,i);q(this.hooksDir,t,[{sessionId:e.sessionId,text:n}]);const r={...e,status:"injected",settledAt:new Date().toISOString()};return this.memory.set(r.id,r),this.bus({kind:"message.delivered",messageId:r.id,sessionId:r.sessionId,at:new Date().toISOString()}),{ok:!0,messageId:r.id,status:"injected",message:r}}deliverHeadless(e,t,s,i){const n=i.headless,r={...e,status:"running"};this.memory.set(r.id,r);const o={settled:!1};try{this.headless.run({sessionId:r.sessionId,cwd:t,prompt:this.renderEnvelope(this.wireTextOf(r),s,i),spec:n,bin:this.deps.bin??process.env.WEAVE_CLAUDE_BIN??n.bin,timeoutMs:this.deps.timeoutMs,onSettle:d=>this.settle(r,o,d)})||this.settle(r,o,{status:"failed",output:null,error:"Session already has a running run"})}catch(a){this.settle(r,o,{status:"failed",output:null,error:a instanceof Error?a.message:String(a)})}return{ok:!0,messageId:r.id,status:"running",message:this.memory.get(r.id)}}renderEnvelope(e,t,s){return s.renderEnvelope?.(e,t)??`[weave message] from=${t.fromLabel} at=${t.at} mode=${t.mode}
+
+${e}`}settle(e,t,s){if(t.settled)return;t.settled=!0;const i=this.memory.get(e.id);if(i)try{this.memory.set(e.id,{...i,status:s.status,output:s.output,error:s.error,settledAt:new Date().toISOString()}),this.bus({kind:"message.finished",messageId:e.id,sessionId:e.sessionId,status:s.status,at:new Date().toISOString()})}catch{}}bus(e){try{this.deps.bus?.emit(e)}catch{}}}

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

@@ -0,0 +1,81 @@
+import type { HookRule } from '@weavecode/core';
+import type { ProjectRow, ProjectRepository } from '../repositories/projects.js';
+import type { SessionRepository } from '../repositories/sessions.js';
+import type { HookRuleRegistry } from './registry.js';
+import type { HookEventBus } from './bus.js';
+/**
+ * hook 文件化管道的 daemon 侧落点（`<dataDir>/hooks/`）：
+ * - `inbox/<shard>.jsonl`  hook → daemon 事件采集（hook-handler.cjs 只追加）
+ * - `mirror/<shard>.json`  daemon → hook 注入计划（本模块原子重写）
+ * - `outbox/<shard>.jsonl` daemon → hook 顺延注入（消费侧追加、hook 消费即删行）
+ *
+ * 目录名/shard 算法/文档形是跨端契约：生成脚本无依赖不能 import，helpers-gen.ts
+ * 以字面量保持同步。
+ */
+export declare const MIRROR_VERSION = 1;
+export declare const OUTBOX_MAX_LINES = 200;
+/** shard = 项目 token 的哈希前缀：纯分片键，不含语义；行内自带 token 解析项目。 */
+export declare function hookShardId(token: string): string;
+export declare function hooksRoot(dataDir?: string): string;
+export declare function mirrorPathOf(hooksDir: string, shardId: string): string;
+export declare function outboxPathOf(hooksDir: string, shardId: string): string;
+/** mirror 规则条目（hook 本地匹配所需的投影；数组序 = 匹配序 = priority 降序）。 */
+export interface MirrorRule {
+    id: string;
+    name: string;
+    events: string[];
+    tools: string[] | null;
+    globs: string[] | null;
+    template: string;
+}
+export interface HookMirrorDoc {
+    version: number;
+    /** {project} 模板变量（项目根 basename，与 dispatcher 的 projectLabel 同源）。 */
+    project: string;
+    pendingTitles: Record<string, string>;
+    rules: MirrorRule[];
+}
+/**
+ * 项目 → hook 本地注入计划。只投影 inject 规则（manual/webhook/log/plugin 的
+ * 动作都在消费侧）：harness 必须是 claude（hook-handler.cjs 只挂在 Claude Code）；
+ * crossProjectOnly 需要全项目表参与判定、hook 无法本地裁决 → 不投影，其注入走
+ * outbox 顺延。
+ */
+export declare function buildMirrorDoc(project: ProjectRow, rules: HookRule[], pendingTitles: Record<string, string>): HookMirrorDoc;
+export interface MirrorWriterDeps {
+    /** 覆盖 dataDir（测试注入）；缺省 getDataDir()。 */
+    dataDir?: string;
+    projects: Pick<ProjectRepository, 'list' | 'getById'>;
+    rules: Pick<HookRuleRegistry, 'list'>;
+    sessions: Pick<SessionRepository, 'list' | 'getBySessionId'>;
+}
+/**
+ * 把注入计划镜像到 `<dataDir>/hooks/mirror/<shard>.json`（tmp + rename 原子换）。
+ * 同步点：规则变更（registry.onChange → syncAll）、会话标题变更（bus
+ * session.renamed / PATCH rename → syncProject）。写失败吞掉——mirror 缺失只损失
+ * 注入，采集不受影响（hook 对缺失/坏 mirror 按空计划处理）。
+ */
+export declare class MirrorWriter {
+    private readonly deps;
+    private readonly dataDir;
+    constructor(deps: MirrorWriterDeps);
+    syncAll(): void;
+    syncProject(projectId: number): void;
+    write(token: string, doc: HookMirrorDoc): void;
+    /** bus 订阅：session.renamed（改名挂起/采纳/交付落定）→ 该会话所属项目的 mirror 重同步。 */
+    attachToBus(bus: Pick<HookEventBus, 'subscribe'>): void;
+}
+export interface OutboxEntry {
+    sessionId: string;
+    text: string;
+}
+/**
+ * inbox 追加（daemon 侧）：旧版 hook-handler 的 POST /hooks 兼容口把报告转投
+ * 这里，与新版 hook 走同一条采集管道。行形 `{v, token, report}` 是跨端契约。
+ */
+export declare function appendInbox(hooksDir: string, token: string, report: unknown): void;
+/**
+ * 顺延注入追加（消费侧：dispatcher 产出的 plugin / 未镜像规则注入，交给同一
+ * 会话的下一次 hook 事件带进会话）。有界：超过行上限丢最旧。
+ */
+export declare function appendOutbox(hooksDir: string, token: string, entries: OutboxEntry[]): void;

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

@@ -0,0 +1,5 @@
+import{createHash as h}from"node:crypto";import{mkdirSync as a,readFileSync as u,renameSync as d,writeFileSync as p}from"node:fs";import{join as n}from"node:path";import{hookSourceHarness as m}from"@weavecode/core";import{getDataDir as l}from"../db/paths.js";import{projectLabel as y}from"./match.js";export const MIRROR_VERSION=1,OUTBOX_MAX_LINES=200;export function hookShardId(i){return h("sha256").update(i).digest("hex").slice(0,16)}export function hooksRoot(i=l()){return n(i,"hooks")}export function mirrorPathOf(i,r){return n(i,"mirror",`${r}.json`)}export function outboxPathOf(i,r){return n(i,"outbox",`${r}.jsonl`)}export function buildMirrorDoc(i,r,e){const o=r.filter(t=>!(t.source.kind!=="hook-event"||m(t.source)!=="claude"||t.handler.type!=="inject"||!t.enabled||t.projectId!==null&&t.projectId!==i.id||t.filter.crossProjectOnly)).sort((t,s)=>s.priority-t.priority).map(t=>({id:t.id,name:t.name,events:[t.source.kind==="hook-event"?t.source.event:""],tools:t.filter.toolNames?.length?[...t.filter.toolNames]:null,globs:t.filter.pathGlobs?.length?[...t.filter.pathGlobs]:null,template:t.handler.type==="inject"?t.handler.template:""}));return{version:MIRROR_VERSION,project:y(i.path),pendingTitles:e,rules:o}}export class MirrorWriter{deps;dataDir;constructor(r){this.deps=r,this.dataDir=r.dataDir??l()}syncAll(){for(const r of this.deps.projects.list())this.syncProject(r.id)}syncProject(r){const e=this.deps.projects.getById(r);if(!e||e.archivedAt)return;const o={};for(const t of this.deps.sessions.list(r))t.pendingTitle&&(o[t.sessionId]=t.pendingTitle);this.write(e.token,buildMirrorDoc(e,this.deps.rules.list(),o))}write(r,e){try{const o=mirrorPathOf(hooksRoot(this.dataDir),hookShardId(r));a(n(hooksRoot(this.dataDir),"mirror"),{recursive:!0});const t=`${o}.tmp`;p(t,JSON.stringify(e)),d(t,o)}catch{}}attachToBus(r){r.subscribe(e=>{if(e.kind!=="session.renamed"||!e.sessionId)return;const o=this.deps.sessions.getBySessionId(e.sessionId);o?.projectId!=null&&this.syncProject(o.projectId)})}}export function appendInbox(i,r,e){const o=n(i,"inbox");a(o,{recursive:!0}),p(n(o,`${hookShardId(r)}.jsonl`),JSON.stringify({v:1,token:r,report:e})+`
+`,{flag:"a"})}export function appendOutbox(i,r,e){if(e.length!==0)try{const o=outboxPathOf(i,hookShardId(r));a(n(i,"outbox"),{recursive:!0});let t=[];try{t=u(o,"utf8").split(`
+`).filter(c=>c.trim())}catch{t=[]}for(const c of e)t.push(JSON.stringify({...c,at:new Date().toISOString()}));const s=t.slice(-OUTBOX_MAX_LINES),f=`${o}.tmp`;p(f,s.length?s.join(`
+`)+`
+`:""),d(f,o)}catch{}}