@weavecode/weave 0.1.2 → 0.1.4

package/node_modules/@weavecode/server/dist/db/paths.d.ts

@@ -1,18 +1,59 @@
 /** Absolute path to the global weave data directory (`<configDir>/weave`). */
 export declare function getDataDir(): string;
+/**
+ * 数据目录的三档（导出/导入迁移的唯一分档口径，落盘点一律先在这里归档）：
+ *
+ * - `data/`  实体数据 —— **迁移**整档带走（库、资源市场副本、上传图片、已安装插件内容）
+ * - `local/` 本机专属身份 —— **不迁移**（换机器要重设口令、重填 key、重签证书、重开自启）
+ * - `cache/` 可弃产物 —— **不迁移**（索引、日志、statusline 缓存、hook 流水、临时安装、daemon 状态）
+ */
+export interface DataRoots {
+    /** 实体数据根；`libraries.path` 的相对基也是它。 */
+    data: string;
+    /** 本机专属身份根。 */
+    local: string;
+    /** 可弃缓存与运行期产物根。 */
+    cache: string;
+}
+export declare function dataRoots(dir?: string): DataRoots;
+/** 实体数据根 `data/`（市场副本、上传、已装插件、库文件）。 */
+export declare function getDataRoot(dir?: string): string;
 /** Absolute path to the SQLite database file. */
-export declare function getDbPath(): string;
-/** Absolute path to the daemon state file (`{ pid, port, startedAt }`). */
-export declare function getDaemonStatePath(): string;
+export declare function getDbPath(dir?: string): string;
+/** 已安装插件内容（SPI 扫描根）；随数据迁移。 */
+export declare function getPluginsDir(dir?: string): string;
+/** 会话图片上传的落盘根（内容寻址 `<sha256>.<ext>`；绝对路径由 harness 引用）。 */
+export declare function getUploadsDir(dir?: string): string;
 /** Absolute path to the daemon auth file (password hash + secrets, 0600). */
-export declare function getAuthPath(): string;
+export declare function getAuthPath(dir?: string): string;
 /** Absolute path to the one-shot initial-password marker (0600; 首个 CLI 命令领取后即删). */
-export declare function getInitialPasswordPath(): string;
+export declare function getInitialPasswordPath(dir?: string): string;
 /** Absolute path to the AI assistant key file (`{ apiKey }`, 0600; 密钥不进 settings 表). */
-export declare function getAiKeyPath(): string;
+export declare function getAiKeyPath(dir?: string): string;
+/** Absolute path to the decision model key file (`{ apiKey }`, 0600; 同 ai.json 口径). */
+export declare function getDecisionKeyPath(dir?: string): string;
 /** Absolute path to the Web Push VAPID keypair file (`{ publicKey, privateKey }`, 0600). */
-export declare function getPushKeysPath(): string;
-/** 会话图片上传的落盘根（内容寻址 `<sha256>.<ext>`；绝对路径由 harness 引用）。 */
-export declare function getUploadsDir(): string;
+export declare function getPushKeysPath(dir?: string): string;
+/**
+ * harness 配置快照根（`<local>/harness-config/<harness>/`）：整份配置文件快照里
+ * 可能带 API key，属本机专属 → 落 `local/`、不进 settings 表、不随迁移带走。
+ */
+export declare function getHarnessConfigDir(dir?: string): string;
+/** 自签证书目录（局域网 HTTPS）。 */
+export declare function getCertsDir(dir?: string): string;
+/** 开机自启脚本（win32 的 VBS）。 */
+export declare function getAutoStartScriptPath(dir?: string): string;
+/** Absolute path to the daemon state file (`{ pid, port, startedAt }`). */
+export declare function getDaemonStatePath(dir?: string): string;
+/** 日志根（接口日志 + 每 harness 的事件采集游标）。 */
+export declare function getLogsDir(dir?: string): string;
 /** 接口日志根（按小时 JSONL：`api-YYYY-MM-DDTHH.jsonl`，见 daemon/api-log.ts）。 */
-export declare function getApiLogsDir(): string;
+export declare function getApiLogsDir(dir?: string): string;
+/** hook 文件化管道的落点根（inbox / mirror / outbox 分片、旁路凭据、promptbox）。 */
+export declare function getHooksDir(dir?: string): string;
+/** statusline 渲染缓存（短命 helper 进程写、daemon 定期回收）。 */
+export declare function getStatuslineDir(dir?: string): string;
+/** 安装等一次性操作的临时区。 */
+export declare function getTmpDir(dir?: string): string;
+/** 项目文件索引快照（`<projectId>.json`，见 daemon/project-files.ts）。 */
+export declare function getIndexDir(dir?: string): string;

package/node_modules/@weavecode/server/dist/db/paths.js

@@ -1 +1 @@
-import t from"node:path";import{detectPlatform as n}from"@weavecode/core";export function getDataDir(){return t.join(n().configDir,"weave")}export function getDbPath(){return t.join(getDataDir(),"weave.db")}export function getDaemonStatePath(){return t.join(getDataDir(),"daemon.json")}export function getAuthPath(){return t.join(getDataDir(),"auth.json")}export function getInitialPasswordPath(){return t.join(getDataDir(),"initial-password")}export function getAiKeyPath(){return t.join(getDataDir(),"ai.json")}export function getPushKeysPath(){return t.join(getDataDir(),"push.json")}export function getUploadsDir(){return t.join(getDataDir(),"uploads")}export function getApiLogsDir(){return t.join(getDataDir(),"logs","api")}
+import o from"node:path";import{detectPlatform as n}from"@weavecode/core";export function getDataDir(){return o.join(n().configDir,"weave")}export function dataRoots(t=getDataDir()){return{data:o.join(t,"data"),local:o.join(t,"local"),cache:o.join(t,"cache")}}export function getDataRoot(t){return dataRoots(t).data}export function getDbPath(t){return o.join(dataRoots(t).data,"weave.db")}export function getPluginsDir(t){return o.join(dataRoots(t).data,"plugins")}export function getUploadsDir(t){return o.join(dataRoots(t).data,"uploads")}export function getAuthPath(t){return o.join(dataRoots(t).local,"auth.json")}export function getInitialPasswordPath(t){return o.join(dataRoots(t).local,"initial-password")}export function getAiKeyPath(t){return o.join(dataRoots(t).local,"ai.json")}export function getDecisionKeyPath(t){return o.join(dataRoots(t).local,"decision.json")}export function getPushKeysPath(t){return o.join(dataRoots(t).local,"push.json")}export function getHarnessConfigDir(t){return o.join(dataRoots(t).local,"harness-config")}export function getCertsDir(t){return o.join(dataRoots(t).local,"certs")}export function getAutoStartScriptPath(t){return o.join(dataRoots(t).local,"weave-autostart.vbs")}export function getDaemonStatePath(t){return o.join(dataRoots(t).cache,"daemon.json")}export function getLogsDir(t){return o.join(dataRoots(t).cache,"logs")}export function getApiLogsDir(t){return o.join(getLogsDir(t),"api")}export function getHooksDir(t){return o.join(dataRoots(t).cache,"hooks")}export function getStatuslineDir(t){return o.join(dataRoots(t).cache,"statusline")}export function getTmpDir(t){return o.join(dataRoots(t).cache,"tmp")}export function getIndexDir(t){return o.join(dataRoots(t).cache,"index")}

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

@@ -18,6 +18,8 @@ export type HookBusMessage = {
         id: string;
         status: string;
     }>;
+    /** raw.source（SessionStart 的 startup/resume/compact/clear——压缩收尾笔靠它认）。 */
+    rawSource?: string;
     at: string;
 } | {
     kind: 'rule.matched';
@@ -127,15 +129,63 @@ export type HookBusMessage = {
     sideQuestionId: number;
     at: string;
 } | {
-    kind: 'sequence.step';
-    sequenceId: number;
-    cursor: number;
+    kind: 'narration.updated';
+    sessionId: string;
+    segs: Array<{
+        at: string | null;
+        text: string;
+    }>;
+    at: string;
+} | {
+    kind: 'dashboard.totals';
+    at: string;
+    totals: {
+        projects: number;
+        sessions: number;
+        events: number;
+        today: number;
+    };
+} | {
+    kind: 'dashboard.series';
+    at: string;
+    series: Array<{
+        at: string;
+        n: number;
+    }>;
+} | {
+    kind: 'dashboard.delta';
+    at: string;
+    series: Array<{
+        at: string;
+        n: number;
+    }>;
+    totals: {
+        projects: number;
+        sessions: number;
+        events: number;
+        today: number;
+    };
+} | {
+    kind: 'orchestration.run';
+    orchestrationId: number;
+    runId: number;
+    status: 'running' | 'done' | 'failed' | 'cancelled' | 'interrupted';
+    trigger: 'manual' | 'webhook' | 'cron';
+    deliveries: number;
+    pendingCounts: Record<string, number>;
     at: string;
 } | {
-    kind: 'sequence.finished';
-    sequenceId: number;
-    status: 'done' | 'failed' | 'cancelled';
-    error: string | null;
+    kind: 'orchestration.delivery';
+    orchestrationId: number;
+    runId: number;
+    /** 边 id（起点投递为空串）；画布按它点亮那一条边。 */
+    edgeId: string;
+    from: string;
+    to: string;
+    ok: boolean;
+    error?: string;
+    deliveries: number;
+    pendingCounts: Record<string, number>;
     at: string;
 };
 export declare class HookEventBus {

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(t=Date.now()){const e=Math.floor(t/1e4)*1e4;this.buckets.set(e,(this.buckets.get(e)??0)+1),this.events+=1;const s=new Date(t).toDateString();s!==this.dayKey&&(this.dayKey=s,this.today!==0&&(this.today=0)),this.today+=1,this.prune(t)}get totals(){return{events:this.events,today:this.today}}seedTotals(t,e){this.events=Math.max(this.events,t),this.today=Math.max(this.today,e),this.dayKey=new Date().toDateString()}recentBuckets(t,e=Date.now()){const a=Math.floor(e/1e4)*1e4-(t-1)*1e4;return Array.from({length:t},(o,n)=>{const r=a+n*1e4;return{at:new Date(r).toISOString().slice(0,19),n:this.buckets.get(r)??0}})}seed(t){const e=new Map;for(const{at:s,n:a}of t){const o=Date.parse(`${s}Z`);if(!Number.isFinite(o))continue;const n=Math.floor(o/1e4)*1e4;e.set(n,(e.get(n)??0)+a)}for(const[s,a]of e)this.buckets.set(s,Math.max(this.buckets.get(s)??0,a));this.seeded=!0}bucketsFor(t,e){return Array.from({length:e},(s,a)=>this.buckets.get(t+a*1e4)??0)}prune(t){if(t-this.lastPrune<6e4)return;this.lastPrune=t;const e=t-864e5;for(const s of this.buckets.keys())s<e&&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 k=.7,w=.3,b=1e4;export function createDecisionConditionJudge(o){const i=(e,n)=>({...e,source:"decision-model",...n!==null?{detail:`P(yes)=${n}`}:{}}),c=e=>e>=.7?i({ok:!0},e):e<=.3?i({ok:!1,reason:"condition answered no"},e):{ok:!1};return{async judge(e){const n=e.upstream;if(!n)return{...await o.fallback.judge(e),source:"fork"};const r=await o.config();if(!r)return{...await o.fallback.judge(e),source:"fork"};let s=null;try{s=await y(r,e.condition,n,o)}catch{s=null}if(s===null)return{...await o.fallback.judge(e),source:"fork"};const t=c(s);return!t.ok&&t.source!=="decision-model"?{...await o.fallback.judge(e),source:"fork"}:t},async judgeBatch(e){if(!e.upstream)return Promise.all(e.items.map(async t=>({...await o.fallback.judge({sessionId:e.sessionId,condition:t.condition,upstream:null}),source:"fork"})));const n=await o.config();if(!n)return Promise.all(e.items.map(async t=>({...await o.fallback.judge({sessionId:e.sessionId,condition:t.condition,upstream:e.upstream}),source:"fork"})));const r={};for(const t of e.items)r[t.key]={type:"noul",instructions:t.condition};let s=null;try{s=await f(n,r,e.upstream,o)}catch{s=null}return s?Promise.all(e.items.map(async t=>{const a=s[t.key];return typeof a!="number"||!Number.isFinite(a)?{...await o.fallback.judge({sessionId:e.sessionId,condition:t.condition,upstream:e.upstream}),source:"fork"}:c(a)})):Promise.all(e.items.map(async t=>({...await this.judge({sessionId:e.sessionId,condition:t.condition,upstream:e.upstream})})))}}}async function y(o,i,c,e){return(await f(o,{proceed:{type:"noul",instructions:i}},c,e))?.proceed??null}async function f(o,i,c,e){const n=new AbortController,r=setTimeout(()=>n.abort(),e.timeoutMs??1e4);try{const s=await(e.fetchImpl??fetch)(`${o.baseUrl.replace(/\/+$/,"")}/v1/systemone`,{method:"POST",headers:{authorization:`Bearer ${o.apiKey}`,"content-type":"application/json"},body:JSON.stringify({model:o.model,state:c,questions:i}),signal:n.signal});if(!s.ok)return null;const a=(await s.json()).answers;if(!a||typeof a!="object")return null;const l={};for(const[m,d]of Object.entries(a)){const u=d?.noul;typeof u=="number"&&Number.isFinite(u)&&(l[m]=u)}return Object.keys(l).length>0?l:null}finally{clearTimeout(r)}}

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

@@ -0,0 +1,129 @@
+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），按已送达收、
+     * 解闸续排，**不布防未回执闸**（否则压缩几分钟里整段显示「发送中」）。
+     * 翻牌要发帧：web 只靠 message.* 帧刷新投递行，静默翻牌 = 「已发出」挂到行消失。
+     */
+    armCommandAck(messageId: string, onRelease: (sessionId: string) => void): void;
+    /**
+     * 活动旁证翻牌：内建命令没有 UPS 回执，宿主受理命令后的任何 hook 事件
+     * （`/compact` → PreCompact…）都是「命令已执行」的证据——该会话还挂着
+     * 「已发出未回执」的命令行就及时翻牌（5s 短窗口只是兜底）。普通文本行有
+     * UPS 正路，不掺和（会话重启清空输入框那类「发了没进」要靠未回执闸说话）。
+     * 返回是否翻了牌（测试用）。
+     */
+    noteActivity(sessionId: string): boolean;
+    /** 翻牌收尾（armCommandAck / noteActivity 共用）：标 acked + 撤防 + 帧。 */
+    private acknowledge_;
+    /** 置闸：成因消息标记 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`）认**尾部相等**
+     * （层② 往框里追加，框里先在的内容只会垫在前面）；带图消息再去尽空白比一次。
+     * 占位内联的图片路径（web 胶囊原地展开）宿主会剥掉换成 `[Image #N]`——比对前
+     * 把 want 里的图片附件路径一并剥掉（与 web 对话面的 claims 同一条规则）。
+     */
+    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;
+/** 占位内联的图片路径从 want 里剥掉（宿主粘贴处理器把它们换成 `[Image #N]`，
+ *  回执原文里路径没了——不剥就永远比不中）。只剥**图片**附件的路径：文件路径
+ *  宿主不转记号、原样留在 UPS 里，剥了反而制造假命中。 */
+export declare function dropInlineImagePaths(text: string, attachments: readonly {
+    path: string;
+    mediaType: string;
+}[] | undefined): string;

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

@@ -0,0 +1 @@
+import{isSlashCommand as f}from"../message-deliverer.js";import{isImageMediaType as k}from"../../repositories/uploads.js";const p=a=>new Promise(e=>setTimeout(e,a));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 s=this.store.memory.get(e.id);!s||s.acked||s.status!=="delivered"||this.stall(e.sessionId,s,"unacked")},this.times.ackStallMs).unref?.()}armCommandAck(e,t){setTimeout(()=>{const i=this.store.memory.get(e);!i||i.acked||i.status!=="delivered"||(this.acknowledge_(i.sessionId,e),t(i.sessionId))},this.times.commandAckGraceMs).unref?.()}noteActivity(e){let t=!1;for(const s of this.store.memory.values())s.sessionId!==e||s.acked||s.status!=="delivered"||s.mode!=="prompt"||!f(s.text)||(this.acknowledge_(e,s.id),t=!0);return t}acknowledge_(e,t){const s=this.store.memory.get(t);!s||s.acked||(this.store.memory.set(t,{...s,acked:!0}),this.release(e,t),this.events.emit({kind:"message.acknowledged",messageId:t,sessionId:e,at:new Date().toISOString()}))}stall(e,t,s){this.store.stalled.set(e,{messageId:t.id,reason:s});const i=this.store.memory.get(t.id),n=i&&i.status==="delivered"&&i.acked!==!0?new Date(Date.now()+this.times.ackStallReleaseMs).toISOString():null;i&&this.store.memory.set(t.id,{...i,stalled:!0,releaseAt:n}),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,i){const n=normalizePromptText(t),l=n.replace(/\[Image #\d+\]/gi,"").trim(),d=[];let c=!1;this.hitLast=!1;for(const r of[...this.store.memory.values()].reverse()){if(r.sessionId!==e||r.acked||r.mode!=="prompt")continue;const o=normalizePromptText(r.text),h=dropInlineImagePaths(o,r.attachments),u=!!o&&(o.length>=i.ackMinText?n.includes(o):n.endsWith(o)),m=(r.attachments?.length??0)>0&&(h?stripSpace(l).includes(stripSpace(h))||stripSpace(n).includes(stripSpace(o)):l.length===0);!u&&!m||(c=!0,this.store.memory.set(r.id,{...r,acked:!0,stalled:!1,...s===void 0?{}:{ackedEventId:s}}),this.store.stalled.get(e)?.messageId===r.id&&this.store.stalled.delete(e),this.release(e,r.id),d.push(...r.attachments?.map(g=>g.id)??[]),this.events.emit({kind:"message.acknowledged",messageId:r.id,sessionId:e,at:new Date().toISOString()}))}return this.hitLast=c,c?d:[]}sessionExited(e){this.release(e)}static sleep=p}export function normalizePromptText(a){return a.replace(/<\/?cross-session-message[^>]*>/g,"").replace(/\s+/g," ").trim()}export function stripSpace(a){return a.replace(/\s+/g,"")}export function dropInlineImagePaths(a,e){const t=(e??[]).filter(s=>s.path&&k(s.mediaType)).map(s=>s.path.replace(/[.*+?^${}()|[\]\\]/g,"\\$&"));return t.length===0?a:a.replace(new RegExp(t.join("|"),"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 f}from"node:child_process";import{defaultKill as p}from"../headless-runner.js";import{tmpdir as l}from"node:os";import{isImageMediaType as w}from"../../repositories/uploads.js";export function wireTextOf(t,e){const i=t.attachments;return!i||i.length===0?t.text:e(t.sessionId)?.attach?.composePrompt(t.text,i)??t.text}export function hasImages(t){return(t.attachments??[]).some(e=>w(e.mediaType))}export function spawnOnce(t,e,i,s){const c=s??((a,n,o)=>f(a,[...n],o));return new Promise((a,n)=>{const o=c(t,e,{cwd:l(),windowsHide:!0,stdio:["ignore","pipe","pipe"]}),m=[];o.stdout?.on("data",r=>m.push(r)),o.stderr?.on("data",r=>m.push(r));const d=setTimeout(()=>{if(o.pid!==void 0)try{p(o.pid)}catch{}n(new Error(`queue timeout after ${i}ms`))},i);o.on("error",r=>{clearTimeout(d),n(r)}),o.on("exit",r=>{if(clearTimeout(d),r===0){a();return}const u=Buffer.concat(m).toString("utf8").slice(-500);n(new Error(`queue exit ${r}${u?`: ${u}`:""}`))})})}export function settleDelivered(t,e,i){const s={...e,status:"delivered",via:i,settledAt:new Date().toISOString()};return t.setMemory(s),t.awaitAck(e.sessionId,e.id),t.isSlashCommand(e.text)?t.armCommandAck(e.id):t.armAckWatch(s),t.emit({kind:"message.delivered",messageId:e.id,sessionId:e.sessionId,at:new Date().toISOString()}),s}

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

@@ -0,0 +1,74 @@
+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;
+/**
+ * 作答原子形态与原子间隔（宿主把连打的字符当粘贴/筛选输入，必须一次一个）。
+ * 字母原子 = 两家宿主模态框的**稳定快捷键**：`n`（claude 备注 / codex decline）、
+ * `y`/`d`（codex 审批 overlay 的 approve/deny，keymap 硬编码默认）——键序本身
+ * 仍由 harness 规格拼出，白名单只挡任意击键。`\x1b[Z` = shift+tab（plan 反馈行
+ * 的提交键；与下移 `\x1b[B` 同构，逐字符写 conhost 后 TUI 读到的就是这条字节流）。
+ */
+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 x,isHarness as f}from"@weavecode/core";import{normalizeDirKey as p}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]|y|n|d|\t|\r|\x1b\[B|\x1b\[Z)$/,ANSWER_TEXT=/^[^\x00-\x1f\x7f]*$/,ANSWER_ATOM_GAP_MS=120,sleep=t=>new Promise(o=>setTimeout(o,t));export async function sessionKeysTarget(t,o,e="\u51FB\u952E",r="both"){const n=t.sessions.getBySessionId(o);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 l=t.projects.getById(n.projectId);if(!l)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 c=await t.terminalPaneFor(n,l,r);return c?{ok:!0,terminal:i,paneId:c.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,o){const e=t.listBySession(o,1),r=e[e.length-1]?.source;return f(r)?x[r]?.effortLevels??[]:[]}export function sideQuestionSurfaceOf(t,o,e){const r=t.listBySession(o,1),n=r[r.length-1]?.source;return f(n)?e?.(n)??null:null}export async function locateTerminalPane(t,o,e,r,n="both"){if(!t)return null;const l=n==="heuristic"?void 0:o.get(e.sessionId);if(l){const s=await t.locatePane?.(l).catch(()=>null);if(s)return{id:s}}if(!e.title)return null;const i=e.title.replace(/^[✻✽✶✳✢⋅◦✦✧∘◐◑◒◓*]+\s*/,""),c=p(r.path,process.platform);let a;try{a=await t.listPanes()}catch{return null}const u=a.filter(s=>s.title!=null&&s.cwd!=null&&c!=null&&s.title.replace(/^[✻✽✶✳✢⋅◦✦✧∘◐◑◒◓*]+\s*/,"")===i&&p(s.cwd,process.platform)===c);return u.length===1?u[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;
+/**
+ * 该会话是否已判死：存活图 `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{pidAliveOf as f}from"../../daemon/claude-liveness.js";import{combinedLivenessOf as c}from"../../daemon/liveness.js";import{appendPromptbox as m,removePromptboxEntries as p}from"../promptbox.js";export const OFFLINE_ERROR="Session is not running";export function appendQueueEntry(n,o,t){m(n,o,[{id:t.id,sessionId:t.sessionId,text:t.text,oneWay:t.oneWay===!0,...t.forceTerminal===!0?{forceTerminal:!0}:{},...t.attachments&&t.attachments.length>0?{attachments:t.attachments}:{}}])}export function sessionJudgedDead(n,o,t=c()){const s=n.livenessRowOf(o);return s?f(s,t)===!1:!1}export function failOffline(n,o,t){const s=new Date().toISOString(),i={...t,status:"failed",reason:"offline",error:OFFLINE_ERROR,settledAt:s};return n.set(t.id,i),o({kind:"message.finished",messageId:t.id,sessionId:t.sessionId,status:"failed",at:s}),i}export function failQueuedOffline(n,o,t,s,i,a){const r=n.sessions.getBySessionId(i),d=r?.projectId==null?null:n.projects.getById(r.projectId);if(!(!d||a.length===0)){for(const e of a)failOffline(t,s,{id:e.id,sessionId:i,text:e.text,...e.attachments&&e.attachments.length>0?{attachments:e.attachments}:{},mode:"prompt",oneWay:e.oneWay===!0,channel:"prompt",status:"pending",at:e.at});p(o,d.token,new Set(a.map(e=>e.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 o}from"node:os";import{isSlashCommand as a}from"../message-deliverer.js";export function runRelay(t,s,i,e,n){try{return t.headless.run({sessionId:`prompt-relay:${s.sessionId}`,cwd:o(),prompt:i.instruction(e,n,{oneWay:s.oneWay===!0}),spec:{supported:!0,bin:i.bin,args:()=>[...i.args],promptStdin:!0},bin:t.bin??process.env.WEAVE_CLAUDE_BIN??i.bin,timeoutMs:t.relayTimeoutMs??0,detached:!1,onSettle:r=>settleRelay(t,s.id,r)})}catch(r){return settleRelay(t,s.id,{status:"failed",output:null,error:r instanceof Error?r.message:String(r)}),!0}}export function settleRelay(t,s,i){const e=t.getMemory(s);if(!e)return;if(i.status==="succeeded"){t.onReleased(e.sessionId);const r={...e,status:"delivered",settledAt:new Date().toISOString()};t.setMemory(r),a(e.text)?t.armCommandAck(s,t.onReleased):t.armAckWatch(r),t.emit({kind:"message.delivered",messageId:s,sessionId:e.sessionId,at:new Date().toISOString()});return}if(e.acked===!0){const r=new Date().toISOString();t.setMemory({...e,status:"delivered",settledAt:r}),t.emit({kind:"message.delivered",messageId:s,sessionId:e.sessionId,at:r});return}const n={...e,status:"failed",error:i.error??`prompt relay ${i.status}`,settledAt:new Date().toISOString()};t.setMemory(n),t.stall(e.sessionId,n,"failed"),t.emit({kind:"message.finished",messageId:s,sessionId:e.sessionId,status:"failed",at:new Date().toISOString()})}export{o as tmpdir};