@weavecode/weave 0.1.0 → 0.1.1

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

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

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

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

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

@@ -24,16 +24,29 @@ export interface InboxDeliveryOptions {
 /** `/status` 的 Peer address 带 `uds:` 前缀；env 里不带。两种都接受。 */
 export declare function inboxSocketPathOf(socket: string): string;
 export declare function deliverViaInboxSocket(spec: PromptInboxSpec, target: InboxTarget, text: string, options?: InboxDeliveryOptions): Promise<void>;
+/** 直投凭据落盘文件名（放 `<dataDir>/hooks/` 下；装配侧拼路径用同一常量）。 */
+export declare const INBOX_TARGETS_FILE = "inbox-targets.json";
 /**
- * sessionId → 该会话的 inbox 目标（内存态，**凭据不落库、不进 UI、不写日志**）：
- * 由 hook 事件旁路上报（hook 进程是会话自己的 child，继承会话导出的 env）。
- * 凭据**每会话进程一份**（resume 后 socket 名重生成、旧值即废），所以不持久化；
- * 会话删除/归档时 forget。
+ * sessionId → 该会话的 inbox 目标：由 hook 事件旁路上报（hook 进程是会话自己的 child，
+ * 继承会话导出的 env），并落 `<dataDir>/hooks/inbox-targets.json`（0600，与 auth.json
+ * 同口径的非 UI 面）。**凭据不进 payload、不落库、不进 UI、不写日志**。
+ *
+ * 为什么要落盘：凭据活在**会话进程**里（socket 由它托管、token 每进程一份），daemon
+ * 重启不动它们——只落 daemon 自己的记忆。于是「重启后首条手动消息只能走终端/中继」
+ * 这个窗口消失（原先要等下一次 hook 事件把凭据带回来）。会话自己 resume/重启换了
+ * socket（旧值即废）时，覆盖前那一刻只会**连不上 → 回落**，不猜不误投；新值随下一次
+ * hook 事件覆盖写回。会话删除/归档时 forget（落盘行一并清）。
  */
 export declare class InboxSocketRegistry {
+    private readonly file?;
     private readonly bySession;
+    /** 上次落盘的内容（hook 每次事件都上报，值没变就不重写盘）。 */
+    private persisted;
+    constructor(file?: string | undefined);
     /** 上报/刷新（hook 每次事件都会带，覆盖写即最新）。socket 为空 = 该会话没有可用 inbox。 */
     set(sessionId: string, target: InboxTarget | null): void;
     get(sessionId: string): InboxTarget | undefined;
     forget(sessionId: string): void;
+    /** 原子写（临时文件 + rename）+ 0600（Windows 上 chmod 近似 no-op，无害）。 */
+    private persist;
 }

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

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

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

@@ -20,6 +20,11 @@ import type { QuestionTracker } from './question-tracker.js';
  * 为 `.failed.jsonl` 防毒丸热循环。行内 token 解析项目（项目已删 → 丢行，同
  * 旧 /hooks 401 语义；归档项目同样丢行——server 不消费，行即焚）；不可归因
  * 的坏行直接丢（重试无意义）。
+ *
+ * **shard 按项目 token 分片**（hook-handler 认 token 不认会话）⇒ 同一 claim 里
+ * 常混着**同项目多个会话**的行。故凡会话级事实（inbox 凭据、pane env、改名回执）
+ * 一律**逐行**取，不得按组聚合——取整组最后一个会把 A 会话的 socket 记到 B 头上，
+ * 而直投照这个映射送，消息就落进别的会话（实事故，见 docs/DECISIONS.md）。
  */
 export declare const INBOX_TICK_MS = 200;
 export declare const INBOX_CLAIM_SUFFIX = ".claim.jsonl";
@@ -33,7 +38,8 @@ export interface InboxRecord {
     deliveredTitle?: string | null;
     /**
      * 该会话的 inbox 直投凭据（hook 进程是会话自己的 child，继承这两个 env）。
-     * **旁路字段：不进 payload、不落库**——主线程只放内存供 layer① 直投用。
+     * **逐行字段**（同 claim 里各会话的 socket 不同）；**旁路字段：不进 payload、
+     * 不落库**——主线程只放内存供 layer① 直投用。
      */
     messaging?: {
         socket: string;
@@ -41,8 +47,8 @@ export interface InboxRecord {
     } | null;
     /**
      * 该会话所在终端 pane 的定位 env（hook 进程生在会话自己的 pane 里）。
-     * **逐行字段**（同一 claim 里不同会话的 pane 不同，不能像 messaging 那样取整组
-     * 最后一个——错配会把键序打进别的会话的模态框）；同样不进 payload、不落库。
+     * **逐行字段**（同一 claim 里不同会话的 pane 不同——错配会把键序打进别的会话
+     * 的模态框）；同样不进 payload、不落库。
      */
     terminalEnv?: Record<string, string> | null;
 }
@@ -85,14 +91,22 @@ export interface IngestedHandlerDeps {
         } | null): void;
         /** hook 旁路上报的会话 pane 定位 env（内存态；层② 精确定位用）。 */
         notePaneEnv?(sessionId: string, env: Record<string, string>): void;
-        /** UPS 事件 = 投递回执判据（prompt 原文与在途条目匹配）。 */
-        onSessionPrompt?(sessionId: string, prompt: string): void;
+        /** UPS 事件 = 投递回执判据（prompt 原文与在途条目匹配）；返回命中消息的随附图 id。
+         *  `eventId` 随回执记下（对话面按它把投递行挂到这条事件的气泡上）。 */
+        onSessionPrompt?(sessionId: string, prompt: string, eventId?: number): string[];
+        /** 会话退出事件（`HARNESS_LIFECYCLE[<harness>].sessionExit`）= 旁路事实作废点。 */
+        sessionExited?(sessionId: string): void;
     };
     /** 阻塞式问答跟踪（toolName 不进帧域，挂点在此）；缺省不跟踪。 */
     questionTracker?: Pick<QuestionTracker, 'onEvent'>;
-    /** 会话转录路径上报（中断态探测用；转录路径在 payload 里，帧域不带）。 */
+    /** 会话转录路径上报（中断态探测用；转录路径在 payload 里，帧域不带）+ 换模型落定。 */
     sessionProbe?: {
         noteTranscript(sessionId: string, path: string | null): void;
+        noteModel(sessionId: string, model: string): void;
+    };
+    /** 上传件落库面：回执命中时把该消息的随附图挂到开轮事件上（气泡缩略图）。 */
+    uploads?: {
+        linkToEvent(eventId: number, uploadIds: readonly string[]): void;
     };
 }
 /**

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

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

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

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

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

@@ -21,6 +21,17 @@ import { HeadlessRunner, type SpawnLike } from './headless-runner.js';
  * pending 只存在于 promptbox 文件。重启即丢 headless 终态 = 显式高级选项的
  * 已文档代价。通道规格全部来自 MessagingSurface 能力面，本类不含 harness 硬编码。
  *
+ * 层③ 只收「还有可能送达」的行：三层全无通路且目标已判死（claude 注册表
+ * `pidAlive === false`）时**不入队**，落 failed + `reason: 'offline'`（web 出中文
+ * 说明）——死会话的队列行永远不会被取走，排在那里只是骗人。判不动（null）不猜，
+ * 照旧入队。
+ *
+ * **同一会话严格按发送顺序投递**（顺序即真相：到达顺序错乱比慢一拍更糟）：
+ * 队头还压着（上一条终端投递没回执 / 队列有积压 / 泵在推进）时新消息只入队尾，
+ * 由冲洗泵一条条推进；终端层把一条贴进输入框后必须等它的 UPS 回执才发下一条
+ * ——再贴一份会在同一个框里叠成一段，两条消息并成一条提交（直投/中继不压：
+ * 交出去即进入会话自己的队列，会话按序处理）。
+ *
  * send() 校验失败同步返回错误码；成功立即返回（inject 已落 outbox，headless
  * 「已启动」，prompt 视层可用性返回 delivering/pending），终态经回调后台落定，
  * 绝不 throw 出 send()。
@@ -31,22 +42,41 @@ 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;
@@ -78,6 +108,8 @@ export interface PromptTerminal {
     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;
@@ -113,6 +145,9 @@ export interface MessageDelivererDeps {
     /** 未回执闸窗口（毫秒）；缺省 120s——prompt 送达后没等到 UPS 回执即暂停该会话
      *  的队列冲洗（防继续向 Held/Refused 的会话灌消息），手动重发或回执解除。 */
     ackStallMs?: number;
+    /** 会话存活图（测试注入）；缺省 `claudeLivenessById()`——同两个引擎（watch/sequence）
+     *  的取法：没有注册表就空图，会话一律「查不动」，不猜。 */
+    livenessOf?: () => Map<string, boolean>;
 }
 /** send() 入参（路由层已做 zod 形状校验）。 */
 export interface SendInput {
@@ -123,6 +158,11 @@ export interface SendInput {
     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 = {
@@ -143,6 +183,25 @@ export type AnswerResult = {
     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;
@@ -151,16 +210,29 @@ export declare class MessageDeliverer {
     private readonly memory;
     /** 有队列行的会话（ingest 冲洗守卫 + 刷新器探活索引；构造时从磁盘重建）。 */
     private readonly queuedSessions;
-    /** 会话 inbox 直投目标（hook 旁路上报；token 只在内存）。 */
+    /** 会话 inbox 直投目标（hook 旁路上报，落 `<dataDir>/hooks/inbox-targets.json` 0600）。 */
     private readonly inboxSockets;
-    /** 会话所在终端 pane 的定位 env（hook 旁路上报；纯内存，随会话走）。 */
+    /**
+     * 会话所在终端 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：冲洗「先把队列读进内存、再逐条投递」——这中间被删的行
      * 仍在手里那一批里，靠它跳过（否则删掉的消息照样发出去）。只兜这一个窗口，
@@ -180,7 +252,8 @@ export declare class MessageDeliverer {
      * 在途视图（GET /sessions/:id/messages）：promptbox 待递送 ∪ 内存态——
      * 在途（delivering/running）与 failed/timeout/暂停闸成因常驻；delivered/
      * injected/succeeded 在驻留窗口（visibleTtlMs）内展示 via/acked，过后消失
-     * （历史在目标会话自己的转录里）。
+     * （历史在目标会话自己的转录里）。例外 = **已送达还没回执**的：过了窗口也留着，
+     * 它就是「还没落进对话」，等回执或未回执闸落定再说。
      */
     listVisible(sessionId: string): PipeMessage[];
     /** 该会话是否有队列行（ingest 冲洗守卫，O(1)）。 */
@@ -197,6 +270,13 @@ export declare class MessageDeliverer {
      * 只有「有进展」才续（通道不可用时不续，避免热循环）；沿用节流间隔作拍长。
      */
     private scheduleFlushContinuation;
+    /** 等回执的那条已经落地（回执到 / 失败 / 行没了）→ 撤防，返回 true。 */
+    private ackGateOpen;
+    /**
+     * 队头是否还压着：上一条终端投递没回执 / 队列有积压 / 泵正在推进。
+     * 是 → 新消息只能排到队尾；不是 → 立刻投（低延迟路径）。
+     */
+    private blockedAhead;
     /**
      * hook 旁路上报的会话 inbox 目标（内存态；socket 空 = 该会话此刻不可直投）。
      * token 只在此存活，不落库、不进 UI、不写日志。
@@ -210,17 +290,43 @@ export declare class MessageDeliverer {
      * resume 到新窗口后，下一次事件就把定位改过来，与 inbox 凭据同一自愈口径）。
      */
     notePaneEnv(sessionId: string, env: Record<string, string>): void;
+    /** 原子写（临时文件 + rename）+ 0600；失败静默（内存态照常能定位，下次再落）。 */
+    private persistPaneEnvs;
     /**
-     * 会话 → 所在可见屏幕（会话列表分块的数据面，只读）。旁路 env 与投递路径共用
-     * 同一份缓存，不另采一次；后端没有反查能力 = 空表（那些会话不分组）。
+     * 会话退出（`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 …>` 壳，比对时归一掉）。
+     * 自己的 `<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): void;
+    onSessionPrompt(sessionId: string, prompt: string, eventId?: number): string[];
     /** 未回执闸布防：prompt 送达后 ackStallMs 内没等到 UPS 回执 → 暂停该会话队列。 */
     private armAckWatch;
     /** 置闸：成因消息标记 stalled（常驻在途视图）+ message.stalled 帧（web 重拉）。 */
@@ -239,8 +345,28 @@ export declare class MessageDeliverer {
      */
     interrupt(sessionId: string): Promise<AnswerResult>;
     /**
-     * 键序注入路径（作答 / 中断）共用的落点解析：会话 → 项目 → 终端通道 → pane。
-     * 全部失败原因是**可判定的语义拒绝**（404/409），调用方原样回给 HTTP。
+     * 关掉会话所在的 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;
     /**
@@ -262,12 +388,13 @@ export declare class MessageDeliverer {
     /**
      * 队列冲洗（幂等）：直投命中即走；否则中继 / 终端按面定序（手动面终端优先）；
      * 都不行留队列。
-     * **节流**（Claude Code 对同一会话的快速突发在发送侧拒收）：一轮最多 `FLUSH_PASS_MAX`
-     * 条、条间至少 `flushGapMs`（中继路径本就被同会话中继闸天然间隔，终端路径没有，
-     * 所以节流在这里统一兜）。超出的留队列，下轮触发（ingest / 刷新器）继续。
+     * **严格串行**：一轮只送一条，等它的 UPS 回执到了再自续下一拍——同一队列由各模式共用，
+     * 顺序与「一条一条」是队列本身的语义，不是各通道各自节流的副产品。
      */
     flushSession(sessionId: string): Promise<void>;
     private flushSessionInner;
+    /** 队列空了就把冲洗索引摘掉（本轮提前返回的路径都得过它，否则刷新器永远白探）。 */
+    private settleQueueIndex;
     /** 刷新器入口：扫全部队列会话（只在队列非空时被调用才有意义）。 */
     flushAll(): Promise<void>;
     /** 会话删除级联：内存态 + 队列行。返回清理行数（口径与旧 DB 计数一致）。 */
@@ -291,7 +418,7 @@ export declare class MessageDeliverer {
      * （无定位能力的终端 / 老 hook），歧义拒绝不打。
      */
     private terminalPaneFor;
-    /** 层② 通道现取（available 是随 settings 变的诚实声明，不可缓存到构造期）。 */
+    /** 层② 通道现取（装配期注入；与 settings 的 preset 无关，只有「没装」才是 null）。 */
     private terminalChannel;
     /** prompt 通道入口（send 的即时路径）：层① 命中即时中继，层② 异步找 pane，都不行入队。 */
     private deliverPrompt;
@@ -303,6 +430,22 @@ export declare class MessageDeliverer {
     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 并发闸）。返回是否启动成功。
@@ -316,6 +459,20 @@ export declare class MessageDeliverer {
     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 后台回写。 */
@@ -326,3 +483,4 @@ export declare class MessageDeliverer {
     private settle;
     private bus;
 }
+export {};