@weavecode/weave 0.0.0-stage → 0.1.0

package/node_modules/@weavecode/server/dist/hooks/sequence-engine.d.ts

@@ -0,0 +1,76 @@
+import type { Harness } from '@weavecode/core';
+import type { MessagingSurface } from '@weavecode/harness';
+import type { SessionSequenceRepository, SessionSequenceRow } from '../repositories/session-sequences.js';
+import type { SessionRepository } from '../repositories/sessions.js';
+import type { HookEventBus } from './bus.js';
+import type { MessageDeliverer } from './message-deliverer.js';
+/** D5 跳数上限：一次序列至多 3 步（A→B→C），POST 侧静态校验。 */
+export declare const SEQUENCE_HOP_LIMIT = 3;
+/**
+ * 跨会话序列引擎（session-orchestration 批 3 ②）：手工编排的多步链
+ * `A → B → C`——步 0 由路由触发，此后每步完成即发下一步。
+ *
+ * 无状态设计：权威状态全在 `session_sequences` 行（cursor/steps[].messageId），
+ * 引擎只是 bus/ingest 的监听器 + DB 的推进器，daemon 重启经 rearm() 从行恢复，
+ * 零恢复态机。步完成判据双通道（D6）：
+ *
+ *   headless 步 → `message.finished`（messageId 匹配；failed/timeout = 序列失败）
+ *   inject 步   → 目标会话的 idleSignals 事件（经 MessagingSurface 取，与
+ *                 WatchEngine 同口径同竞态——骑乘 Stop 的提前一拍是已知残差）
+ *
+ * 推进用 cursor CAS（同批 Stop+SessionEnd 双事件只赢一次）；终态用 status CAS。
+ * 一切异常内部吞掉：序列推进失败永不影响采集与消息投递。
+ */
+export declare class SequenceEngine {
+    private readonly deps;
+    constructor(deps: {
+        sequences: Pick<SessionSequenceRepository, 'getById' | 'listRunning' | 'advanceCursor' | 'finish' | 'setStepMessage'>;
+        /** 消息域重塑：步↔消息关联走管道发号 + 内存注册表（无 DB 行可反查）。 */
+        deliverer: Pick<MessageDeliverer, 'send' | 'getMessage'>;
+        sessions: Pick<SessionRepository, 'listWithCounts'>;
+        bus: HookEventBus;
+        /** 能力面访问器（测试注入）；缺省 surfaces.ts 模块级 registry。 */
+        surfaceFor?: (harness: Harness) => MessagingSurface;
+        /** liveness 探测（测试注入）；缺省 claude 注册表全量扫描。 */
+        livenessOf?: () => Map<string, boolean>;
+    });
+    /** 路由插入后触发步 0（await 到 send 落定——响应即可带回 messageId；拒绝即 failed 留痕）。 */
+    trigger(row: SessionSequenceRow): Promise<void>;
+    /** 取消（路由 DELETE）：仅 running 可取消，终态拒绝由路由先行判。 */
+    cancel(id: number): boolean;
+    /**
+     * daemon 重启恢复：running 序列按行重挂——injected/delivered 步续等 idle
+     * （不重发）；messageId 缺席或注册表已随进程死 → **判 interrupted，不重发**
+     * （批 3 的补 fire 语义作废：宁可人续，不往会话重复打 prompt）；headless 步
+     * 的 settle 回调已死 → 按失败收尾；已落终态但帧未达（宕机窗口）→ 按行终态
+     * 补推进。boot 不阻塞。
+     */
+    rearm(): void;
+    /**
+     * ingest 消费路径的事件钩子（与 WatchEngine.onEvent 同形态）：目标会话的
+     * idleSignals 事件 → 本序列当前 inject 步完成。messageId 缺席（下一步
+     * 尚未触发）不响应——idle 信号先于注入落库，属上一拍遗留。
+     */
+    onEvent(input: {
+        sessionId: string;
+        eventType: string;
+        source: Harness;
+    }): void;
+    /** headless 步完成：message.finished 帧按 messageId 匹配当前步。 */
+    private onBus;
+    /** 步完成 → 推进：末步落 done；否则 CAS 推游标后 fire 下一步。 */
+    private advance;
+    /**
+     * 触发一步：send 拒绝即序列失败；成功回填 messageId。headless 的同步失败
+     * 路径（isBusy 竞态/spawn throw）会在 send 返回前就发 finished 帧——彼时
+     * messageId 尚未落库、帧匹配不上，故 send 返回后按消息行终态补判。
+     */
+    private fire;
+    /** 终态落定（status CAS）：并发终态只赢一次，赢家广播 sequence.finished。 */
+    private finish;
+    /**
+     * terminated 补射（挂 SessionSweeper 同 tick）：进行中序列的当前等待目标
+     * 已判死（行消失/claude 注册表 pid 死）→ 序列失败。判不动（null）不猜。
+     */
+    sweepTerminated(): number;
+}

package/node_modules/@weavecode/server/dist/hooks/sequence-engine.js

@@ -0,0 +1 @@
+import{messagingSurfaceFor as c}from"../surfaces.js";import{claudeLivenessById as a,pidAliveOf as u}from"../daemon/claude-liveness.js";export const SEQUENCE_HOP_LIMIT=3;export class SequenceEngine{deps;constructor(e){this.deps=e,this.deps.bus.subscribe(s=>this.onBus(s))}async trigger(e){await this.fire(e.id,e.cursor)}cancel(e){return this.finish(e,"cancelled")}rearm(){try{for(const e of this.deps.sequences.listRunning()){const s=e.steps[e.cursor];if(!s){this.finish(e.id,"done");continue}if(s.messageId==null){this.finish(e.id,"failed",`step ${e.cursor+1} interrupted \u2014 daemon restarted, not re-sent`);continue}const t=this.deps.deliverer.getMessage(s.messageId);if(!(t?.status==="injected"||t?.status==="delivered")){if(t?.status==="running"){this.finish(e.id,"failed","daemon restarted during headless step");continue}t?.status==="succeeded"?this.advance(e):this.finish(e.id,"failed",`step ${e.cursor+1} ${t?.status??"message missing"}`)}}}catch{}}onEvent(e){try{if(!(this.deps.surfaceFor?.(e.source)??c(e.source)).idleSignals.includes(e.eventType))return;for(const s of this.deps.sequences.listRunning()){const t=s.steps[s.cursor];if(!t||t.to!==e.sessionId||t.messageId==null)continue;const i=this.deps.deliverer.getMessage(t.messageId);(i?.status==="injected"||i?.status==="delivered")&&this.advance(s)}}catch{}}onBus(e){if(e.kind==="message.finished")try{for(const s of this.deps.sequences.listRunning())s.steps[s.cursor]?.messageId===e.messageId&&(e.status==="succeeded"?this.advance(s):this.finish(s.id,"failed",`step ${s.cursor+1} ${e.status}`))}catch{}}advance(e){if(e.cursor+1>=e.steps.length){this.finish(e.id,"done");return}this.deps.sequences.advanceCursor(e.id,e.cursor,e.cursor+1)&&this.fire(e.id,e.cursor+1)}async fire(e,s){try{const t=this.deps.sequences.getById(e);if(!t||t.status!=="running"||t.cursor!==s)return;const i=t.steps[s];if(!i)return;this.deps.bus.emit({kind:"sequence.step",sequenceId:e,cursor:s,at:new Date().toISOString()});const n=await this.deps.deliverer.send({toSessionId:i.to,text:i.text,mode:i.mode,fromKind:"dashboard"});if(!n.ok){this.finish(e,"failed",`step ${s+1} rejected: ${n.error}`);return}if(this.deps.sequences.setStepMessage(e,s,n.messageId),n.status==="running"){const r=this.deps.deliverer.getMessage(n.messageId);if(r?.status==="succeeded"||r?.status==="failed"||r?.status==="timeout")if(r.status==="succeeded"){const d=this.deps.sequences.getById(e);d&&this.advance(d)}else this.finish(e,"failed",`step ${s+1} ${r.status}`)}}catch(t){this.finish(e,"failed",t instanceof Error?t.message:String(t))}}finish(e,s,t=null){return this.deps.sequences.finish(e,s,t)?(this.deps.bus.emit({kind:"sequence.finished",sequenceId:e,status:s,error:t,at:new Date().toISOString()}),!0):!1}sweepTerminated(){try{const e=this.deps.livenessOf?.()??a(),s=new Map(this.deps.sessions.listWithCounts().map(i=>[i.sessionId,i]));let t=0;for(const i of this.deps.sequences.listRunning()){const n=i.steps[i.cursor];if(!n)continue;const r=s.get(n.to);r&&u(r,e)!==!1||this.finish(i.id,"failed",`target session ${n.to} terminated`)&&t++}return t}catch{return 0}}}

package/node_modules/@weavecode/server/dist/hooks/session-purge.d.ts

@@ -0,0 +1,33 @@
+import type { HookDispatchRepository } from '../repositories/hook-dispatches.js';
+import type { HookEventRepository } from '../repositories/hook-events.js';
+import type { SessionSequenceRepository } from '../repositories/session-sequences.js';
+import type { SessionWatchRepository } from '../repositories/session-watches.js';
+import type { SessionRepository } from '../repositories/sessions.js';
+import type { MessageDeliverer } from './message-deliverer.js';
+import type { QuestionTracker } from './question-tracker.js';
+export interface SessionPurgeDeps {
+    sessions: SessionRepository;
+    events: HookEventRepository;
+    dispatches?: Pick<HookDispatchRepository, 'deleteBySession'>;
+    /** 消息域（消息域重塑）：内存态 + promptbox 队列行级联清（计数口径同旧 DB）。 */
+    deliverer?: Pick<MessageDeliverer, 'forgetSession'>;
+    /** 空闲订阅（批 2）：目标或订阅方任一指向该会话的行一并清（不计数）。 */
+    watches?: Pick<SessionWatchRepository, 'deleteBySession'>;
+    /** 跨会话序列（批 3）：任一步目标指向该会话的行一并清（不计数）。 */
+    sequences?: Pick<SessionSequenceRepository, 'deleteMentioning'>;
+    /** 阻塞问答：待答内存态一并清（不计数）。 */
+    questions?: Pick<QuestionTracker, 'forgetSession'>;
+    /** 转录探测：内存里的 transcriptPath 一并清（不计数）。 */
+    probe?: {
+        forget(sessionId: string): void;
+    };
+}
+/**
+ * 删会话的数据清理：会话行 + 该会话的采集事件 + 指令池派发 + 消息管道在途一并清。
+ * 手动删除（`DELETE /sessions/:id`）与空会话自动清理走同一条路径——两处清理口径不分家。
+ */
+export declare function purgeSession(deps: SessionPurgeDeps, sessionId: string): {
+    events: number;
+    dispatches: number;
+    messages: number;
+};

package/node_modules/@weavecode/server/dist/hooks/session-purge.js

@@ -0,0 +1 @@
+export function purgeSession(e,s){const n=e.events.deleteBySession(s),o=e.dispatches?.deleteBySession(s)??0,i=e.deliverer?.forgetSession(s)??0;return e.watches?.deleteBySession(s),e.sequences?.deleteMentioning(new Set([s])),e.questions?.forgetSession(s),e.probe?.forget(s),e.sessions.remove(s),{events:n,dispatches:o,messages:i}}

package/node_modules/@weavecode/server/dist/hooks/session-sweeper.d.ts

@@ -0,0 +1,38 @@
+import { type SessionPurgeDeps } from './session-purge.js';
+import type { WatchEngine } from './watch-engine.js';
+import type { SequenceEngine } from './sequence-engine.js';
+export declare const SWEEP_INTERVAL_MS: number;
+/**
+ * 定时清无 prompt 幽灵会话：从未收到 UserPromptSubmit（事件全是会话引导类——
+ * 典型形状是开了就走的 SessionStart 单例，或 SessionStart + 闲置 Notification
+ * 组合），且静默超过保活窗。判据与期限的单一事实源 = sessions 仓储的
+ * `listWithCounts`（`autoDeleteAt` 计算列）——本清扫器只做「过期即清」；
+ * 收到过 prompt 的会话 autoDeleteAt 为 null，永不自动删（遵循全局事件保留期）。
+ *
+ * 注：新入库路径已不再为「仅 SessionStart」会话建行（inbox-worker 的
+ * needsSessionRow 判据）；本清扫器管住其余一切无 prompt 形状与该改动之前的
+ * 遗留存量行。
+ */
+export declare class SessionSweeper {
+    private readonly deps;
+    private readonly now;
+    constructor(deps: SessionPurgeDeps & {
+        /** 空闲订阅补射（批 2）：挂同一 tick——daemon 重启/目标异常终止后扫 pending。 */
+        watchEngine?: Pick<WatchEngine, 'sweepTerminated'>;
+        /** 序列补射（批 3）：同 tick——进行中序列的等待目标已死即序列失败。 */
+        sequenceEngine?: Pick<SequenceEngine, 'sweepTerminated'>;
+    }, now?: () => number);
+    /** 清一轮，返回清掉的会话数（无候选即 0，可反复调用）。 */
+    sweep(): number;
+    /** 起定时器。unref：定时器不吊住 daemon 退出。 */
+    start(): NodeJS.Timeout;
+}
+/**
+ * 两个 daemon 入口（生产 start.ts / dev dev-entry.ts）共用的装配点——
+ * 这层封装的存在理由就是入口漂移：dev 入口曾漏挂清扫器，导致幽灵会话
+ * 在 dev 下永远不被清（存量行一直显示在会话列表，判据见 autoDeleteAt）。
+ */
+export declare function startSessionSweeper(deps: SessionPurgeDeps & {
+    watchEngine?: Pick<WatchEngine, 'sweepTerminated'>;
+    sequenceEngine?: Pick<SequenceEngine, 'sweepTerminated'>;
+}): NodeJS.Timeout;

package/node_modules/@weavecode/server/dist/hooks/session-sweeper.js

@@ -0,0 +1 @@
+import{purgeSession as r}from"./session-purge.js";export const SWEEP_INTERVAL_MS=5*6e4;export class SessionSweeper{deps;now;constructor(e,s=Date.now){this.deps=e,this.now=s}sweep(){const e=this.now();let s=0;for(const t of this.deps.sessions.listWithCounts()){const o=t.autoDeleteAt==null?null:Date.parse(t.autoDeleteAt);o==null||e<o||(r(this.deps,t.sessionId),s++)}return this.deps.watchEngine?.sweepTerminated(),this.deps.sequenceEngine?.sweepTerminated(),s}start(){this.sweep();const e=setInterval(()=>this.sweep(),SWEEP_INTERVAL_MS);return e.unref(),e}}export function startSessionSweeper(n){return new SessionSweeper(n).start()}

package/node_modules/@weavecode/server/dist/hooks/toolkit-scan.d.ts

@@ -0,0 +1,62 @@
+import { type Harness } from '@weavecode/core';
+/**
+ * 批 10 工具包扫描：内置仓 `plugins/<scope>/<pack>/` 与 managed
+ * 市场资源根走同一条扫描管线，唯一区别是 provenance。
+ * 不发明新格式——三种识别沿用既有约定：
+ *   ① `.claude-plugin/plugin.json` → CC 插件包（组件清单由原生约定推导）
+ *   ② `weave-plugin.json`          → weave 规则包（装载复用 plugin-loader）
+ *   ③ 仅 `skills/` 等裸表面        → 表面解包包
+ * 一个包可同时命中 ①②。
+ */
+export type ToolkitProvenance = 'builtin' | 'market';
+/** 工具箱类型徽标：weave.json 显式标注优先，缺省由包内容推导。 */
+export type ToolkitKind = 'skill' | 'hook' | 'mod' | 'rule' | 'surface';
+export type ToolkitComponent = 'skill' | 'command' | 'agent' | 'hook' | 'mod' | 'rule';
+export interface ToolkitSource {
+    /** 扫描根：内置 harness-tools 根，或 managed 市场资源根。 */
+    root: string;
+    provenance: ToolkitProvenance;
+}
+export interface ToolkitPack {
+    /** 包 id：weave manifest.id 优先，否则目录名。 */
+    id: string;
+    name: string;
+    version: string;
+    description?: string;
+    /** 功能范围分组（根下一级容器目录名；包直接放根下时为空串）。 */
+    scope: string;
+    /** 源包目录（绝对路径）。 */
+    dir: string;
+    provenance: ToolkitProvenance;
+    /** 所属扫描根（同 id 多来源时消歧）。 */
+    sourceRoot: string;
+    targets: Harness[];
+    kind: ToolkitKind;
+    components: ToolkitComponent[];
+    /** 有 `.claude-plugin/plugin.json`（CC 原生包）。 */
+    ccPack: boolean;
+    /** 有 `weave-plugin.json`（weave 规则成分，走 plugin-loader）。 */
+    weavePack: boolean;
+    /** skills/ 下的 skill 目录名（表面解包用）。 */
+    skills: string[];
+}
+/** 内置工具包源根 = 落地在数据目录里的内置仓 `plugins/`（见 `market/builtin.ts`）。 */
+export declare function builtinToolkitRoot(): string;
+/** 目录是否为一个工具包包位（四种识别任一命中）。 */
+export declare function isToolkitPackDir(dir: string): Promise<boolean>;
+/** 解析单个包目录；三种识别全未命中（无可装载成分）→ null。 */
+export declare function parseToolkitPack(dir: string, source: ToolkitSource, scope: string): Promise<ToolkitPack | null>;
+/**
+ * 递归发现扫描根下的全部包：根自身可为包（外置目录直接指到包），
+ * 否则下钻到 level ≤ 2（root → scope → pack；market 源放宽到 10 对齐
+ * 市场扫描）；命中包即停（包不嵌套）。
+ * 例外：market 源根层仅裸表面命中 → 视为容器继续下钻（见 isStrictPackDir）。
+ */
+export declare function discoverToolkitPacks(source: ToolkitSource): Promise<ToolkitPack[]>;
+/** 内置扫描根；managed 市场资源根由调用方按 libraries 补入（同一管线，仅 provenance 不同）。 */
+export declare function discoverToolkitSources(): ToolkitSource[];
+/**
+ * 扫描根下含 `weave-plugin.json` 的包目录（depth ≤ 2，同 discoverToolkitPacks
+ * 的下钻规则但只认 weave 成分）——plugin-loader 的深度扫描入口。
+ */
+export declare function discoverWeavePackDirs(root: string): Promise<string[]>;

package/node_modules/@weavecode/server/dist/hooks/toolkit-scan.js

@@ -0,0 +1 @@
+import{readFile as R,readdir as h,stat as w}from"node:fs/promises";import a from"node:path";import{WEAVE_PLUGIN_MANIFEST as k,WeavePluginManifestSchema as I,HARNESS_KEYS as G}from"@weavecode/core";import{builtinPacksDir as J}from"../market/builtin.js";import{getDataDir as K}from"../db/paths.js";import{hasNonEmptyModules as T}from"../watch/plugin-mods.js";const D=".claude-plugin",A="plugin.json",L="weave.json",F=2,O=10,S=["claude"];export function builtinToolkitRoot(){return a.resolve(J(K()))}async function j(n){try{return(await w(n)).isDirectory()}catch{return!1}}async function f(n){try{const t=JSON.parse(await R(n,"utf8"));return t&&typeof t=="object"&&!Array.isArray(t)?t:null}catch{return null}}export async function isToolkitPackDir(n){return await b(n)?!0:await j(a.join(n,"skills"))||await j(a.join(n,"commands"))||await j(a.join(n,"agents"))}async function b(n){if(await f(a.join(n,D,A)))return!0;try{return await w(a.join(n,k)),!0}catch{}return T(await f(a.join(n,"hooks","hooks.json")))}async function V(n){try{return(await h(n,{withFileTypes:!0})).filter(t=>t.isDirectory()).map(t=>t.name).sort()}catch{return[]}}async function x(n){try{return(await h(n,{withFileTypes:!0})).filter(t=>t.isFile()&&t.name.endsWith(".md")).map(t=>t.name.replace(/\.md$/,"")).sort()}catch{return[]}}function C(n){if(!Array.isArray(n)||n.length===0)return S;const t=n.filter(r=>G.includes(r));return t.length>0?t:S}export async function parseToolkitPack(n,t,r){const s=a.basename(n),o=await f(a.join(n,D,A)),i=await f(a.join(n,k)),e=await f(a.join(n,L)),p=await V(a.join(n,"skills")),d=await x(a.join(n,"commands")),c=await x(a.join(n,"agents")),m=await f(a.join(n,"hooks","hooks.json")),v=T(m),g=!!m&&typeof m.hooks=="object"&&m.hooks!==null,u=[];if(p.length>0&&u.push("skill"),d.length>0&&u.push("command"),c.length>0&&u.push("agent"),v?u.push("mod"):g&&u.push("hook"),i&&u.push("rule"),u.length===0)return null;const y=typeof e?.kind=="string"?e.kind:null,N=y&&["skill","hook","mod","rule","surface"].includes(y)?y:v?"mod":g?"hook":i&&!o?"rule":p.length>0?"skill":"surface",l=i?I.safeParse(i):null,W=l?.success?l.data.id:s,_=(typeof o?.name=="string"?o.name:void 0)??(l?.success?l.data.name:void 0)??s,M=(l?.success?l.data.version:void 0)??(typeof o?.version=="string"?o.version:void 0)??"0.0.0",P=(typeof o?.description=="string"?o.description:void 0)??(l?.success?l.data.description:void 0);return{id:W,name:_,version:M,...P?{description:P}:{},scope:r,dir:n,provenance:t.provenance,sourceRoot:t.root,targets:C(e?.targets),kind:N,components:u,ccPack:!!o,weavePack:!!i,skills:p}}function E(n){return n==="node_modules"||n.startsWith(".")}export async function discoverToolkitPacks(n){const t=[],r=n.provenance==="market",s=r?O:F,o=async(i,e,p)=>{if(await isToolkitPackDir(i)&&!(e===0&&r&&!await b(i))){const c=await parseToolkitPack(i,n,p);c&&t.push(c);return}if(e>=s)return;let d;try{d=await h(i,{withFileTypes:!0})}catch{return}for(const c of d)!c.isDirectory()||E(c.name)||await o(a.join(i,c.name),e+1,e===0?c.name:p)};return await o(n.root,0,""),t}export function discoverToolkitSources(){return[{root:builtinToolkitRoot(),provenance:"builtin"}]}export async function discoverWeavePackDirs(n){const t=[],r=async(s,o)=>{try{await w(a.join(s,k)),t.push(s);return}catch{}if(o>=F)return;let i;try{i=await h(s,{withFileTypes:!0})}catch{return}for(const e of i)!e.isDirectory()||E(e.name)||await r(a.join(s,e.name),o+1)};return await r(n,0),t}

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

@@ -0,0 +1,167 @@
+import type { PluginScope, PluginSurface } from '@weavecode/harness';
+import type { ProjectRepository } from '../repositories/projects.js';
+import type { LibraryRepository } from '../repositories/libraries.js';
+import type { PluginStateRepository } from '../repositories/plugin-states.js';
+import type { LoadedPluginInfo, PluginManager } from './plugin-loader.js';
+import { type ToolkitPack, type ToolkitProvenance } from './toolkit-scan.js';
+/**
+ * 批 10 工具包服务，批 3 改 CC 原生包管线：按包成分分三条既有管线启用/禁用——
+ *   ① CC 原生包（mod 同机制，H2）→ harness PluginSurface 全局安装（幂等两步
+ *      CLI）+ 项目 settings `enabledPlugins` 开关；**项目插件位零副本**（宿主
+ *      不扫描项目 `.claude/plugins/`——H4，存量副本读时自愈清扫，list 报
+ *      legacyCopies），disable 只关项目启用、全局安装保留；
+ *   ② 表面解包（裸表面/Codex → 批 4a AssetSurface 目标目录，同 checksum 清扫）；
+ *   ③ weave 规则成分（按项目 `meta.plugins.enabled` 开关——D3 effective 单点，
+ *      全局 plugin_states 仍是「默认启用」，不再按项目 flip）。
+ * 状态单一事实源 = 落盘事实 + D3 effective；`projects.meta.toolkit.enabled[]`
+ * 只是索引，读侧以磁盘与 effective 校验为准（meta 读时自愈）。
+ */
+export type ToolkitErrorCode = 'not-found' | 'host-version' | 'invalid';
+export declare class ToolkitError extends Error {
+    readonly code: ToolkitErrorCode;
+    constructor(message: string, code: ToolkitErrorCode);
+}
+/** 启用时写入的包级记录（marker + checksum，`.weave/toolkit/<id>.json`）。 */
+export interface ToolkitRecord {
+    packId: string;
+    provenance: ToolkitProvenance;
+    sourceRoot: string;
+    sourceDir: string;
+    enabledAt: string;
+    /** 相对项目根的 posix 路径 → 启用时内容 sha256（禁用比对改写用）。 */
+    files: Record<string, string>;
+}
+export interface ToolkitPackInfo extends ToolkitPack {
+    /** 所属仓库 namespace（市场身份，`marketIdOf(pack.dir)`）：内置包 = `weave`、
+     *  外部市场包 = 该市场 id、不在任何市场下的包缺省（前端归「本地」）。 */
+    namespace?: string;
+    /** 读侧：落盘/级联事实校验后的启用态。 */
+    enabled: boolean;
+    /** 是否已安装（CC/mod = harness 全局安装态；表面包 = 本项目落盘记录；weave 装载即源恒 true）。 */
+    installed: boolean;
+    /** CC 注册键 `<name>@<市场>`：仅 CC 落地包（targets 含 claude）有；表面/纯 SPI 包无。 */
+    key?: string;
+    /** 该键已登记的安装 scope（`user` = 全局装、`project` = 项目内装）；未装为空。 */
+    scopes?: PluginScope[];
+    /** weave 成分的装载状态（loader 未就绪时缺省）。 */
+    weave?: {
+        status: LoadedPluginInfo['status'];
+        ruleCount: number;
+        error?: string;
+    };
+}
+export interface ToolkitListResult {
+    packs: ToolkitPackInfo[];
+    /** 项目插件位残留（Weave 旧副本；宿主不加载，可安全清理）。 */
+    legacyCopies: string[];
+}
+export interface ToolkitToggleResult {
+    pack: ToolkitPackInfo;
+    warnings: string[];
+}
+/** mod 类包的宿主版本下限（Claude Code ≥ 2.1.287 契约，EARLY ACCESS）。 */
+export declare const MIN_MOD_HOST_VERSION: readonly [2, 1, 287];
+/** 版本字符串（semver）是否 ≥ min。 */
+export declare function isVersionAtLeast(version: string, min: readonly number[]): boolean;
+/**
+ * 宿主 Claude Code 版本（mod 启用闸）。`claude --version` 解析首个 semver，
+ * 成功结果缓存 10 分钟；不可得返回 null（调用方降级为提示不拦截——weave server
+ * 侧无法可靠获取时宁可放行并告警，也不让低误报挡住功能）。
+ */
+export declare function detectClaudeVersion(): Promise<string | null>;
+/**
+ * 项目内「哪个文件是哪个仓库铺下来的」——落盘记录（`.weave/toolkit/<id>.json`）
+ * 是唯一能回答此问的事实：记录写着包从哪个目录装来（`sourceDir`），市场身份经
+ * `marketIdOf` 取。不在任何市场下的包（手加目录）没有仓库可归，不打标记；用户
+ * 自己写的文件同样不在记录里，也就不打标记。
+ */
+export declare function projectFileNamespaces(projectPath: string): Promise<Map<string, string>>;
+/**
+ * uninstall 面：所有包落盘记录的 rel → 启用时内容 sha256。与
+ * `projectFileNamespaces` 同源（`.weave/toolkit/*.json` 是唯一事实），多了
+ * 内容指纹——uninstall 只删当前内容仍与安装时一致的文件，用户改过的留下。
+ */
+export declare function projectPackFiles(projectPath: string): Promise<Map<string, string>>;
+/** 宿主版本闸（5.6）：mod 包 enable 前校验；不可得时降级为 warning。 */
+export interface ModHostGate {
+    ok: boolean;
+    message?: string;
+    warning?: string;
+}
+export declare function evaluateModHostGate(version: string | null): ModHostGate;
+export interface ToolkitServiceDeps {
+    projects: ProjectRepository;
+    states: PluginStateRepository;
+    /** loader 门面（daemon 侧为 PluginManager；测试可注入桩）。 */
+    plugins: Pick<PluginManager, 'list' | 'setPluginEnabled'>;
+    /** 覆盖内置扫描根（测试）。 */
+    builtinRoot?: string;
+    /** managed 市场资源（M3 装载桥：市场根同管线入扫描源）；缺省不扫市场。 */
+    libraries?: Pick<LibraryRepository, 'list'>;
+    /** 覆盖宿主版本探测（测试）。 */
+    claudeVersion?: () => Promise<string | null>;
+    /** 插件安装面（测试注入假 exec 的 surface；缺省经 registry 取 Claude 面）。 */
+    pluginSurface?: PluginSurface;
+}
+export declare class ToolkitService {
+    private readonly deps;
+    constructor(deps: ToolkitServiceDeps);
+    /** 扫描源：内置根（测试可覆盖）+ managed 市场资源根。 */
+    private sources;
+    private allPacks;
+    /**
+     * 包清单 + 启用态（读侧以落盘/级联校验），顺带把 meta 索引自愈到事实、
+     * 清扫存量项目插件副本。`source` 消歧：同 id 可同时来自内置与市场
+     * （provenance 不同），精确匹配 sourceRoot，缺省 builtin 优先。
+     */
+    list(projectId: number): Promise<ToolkitListResult>;
+    /** 幂等启用：已启用（记录在且文件齐）→ 无任何写入，直接回后置状态。 */
+    enable(projectId: number, packId: string, sourceRoot?: string): Promise<ToolkitToggleResult>;
+    /** 幂等禁用：表面/解包文件按 checksum 删除（改写保留），记录删除；CC 原生包
+     * 只关项目启用（enabledPlugins=false），全局安装保留。 */
+    disable(projectId: number, packId: string, sourceRoot?: string): Promise<ToolkitToggleResult>;
+    /** disable/uninstall 共用清理（与原 disable 主体逐段等价）：表面文件按
+     * checksum 删除（改写保留）、CC 关项目启用、weave 关 meta、清启用索引。 */
+    private applyDisabled;
+    /** 卸载 = disable 全部清理 + CC/mod 包从 harness 全局卸载（与 `claude plugin
+     * uninstall` 对齐；未安装由 surface 幂等吞掉；marketplace 源保留可重装）。
+     * mod 宿主版本闸不适用（卸载不加载宿主）。 */
+    uninstall(projectId: number, packId: string, sourceRoot?: string): Promise<ToolkitToggleResult>;
+    /** 文件管线清扫（disable 与 uninstall 共用）。 */
+    private removePackFiles;
+    private requireProject;
+    private resolvePack;
+    /**
+     * 启用态 = 各成分事实的 AND：表面/解包成分看落盘，CC 原生包看「全局已装 &&
+     * 项目 enabledPlugins 开」（批 3 判据），weave 成分看 D3 effective（项目覆盖
+     * → 已同步未启用 → 回落全局）。
+     * 读记录即触发存量项目副本自愈（读时清扫）。
+     */
+    private computeEnabled;
+    /** 该键已登记的安装 scope（读 installed_plugins.json；UI 用来显示"装在哪一处"）。 */
+    private installedScopes;
+    private packInfo;
+    /**
+     * 安装态（市场「安装/已装」判定）：CC/mod 看 harness 全局安装记录；
+     * weave 成分随扫描源热载无安装概念；表面包看本项目落盘账本（启用即已装）。
+     */
+    private computeInstalled;
+    private enabledIndex;
+    private rememberEnabled;
+    /** meta 索引自愈到事实（读侧以落盘/级联为准，索引只跟随）。 */
+    private healMeta;
+    /** 插件安装面（deps 可注入假 exec；缺省经 registry 取 Claude 面——批 3 最浅接入）。 */
+    private pluginSurface;
+    /**
+     * 读记录 + 存量项目插件副本自愈（仿 healMeta）：旧管线把 CC 包复制进项目
+     * 插件位，宿主从不加载（H4）——按 checksum 删副本并重写记录；用户改写过的
+     * 文件保留（由 legacyCopies 报出，清理走显式端点）。
+     */
+    private readRecordHealed;
+    /** 项目插件位残留清单（readRecordHealed 覆盖不到的孤儿副本在此报出）。 */
+    private scanLegacyCopies;
+    /** 幂等清理项目插件位残留（宿主不加载的死数据，清理不改变任何加载行为）。 */
+    cleanupLegacyCopies(projectId: number): Promise<{
+        removed: string[];
+    }>;
+}

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

@@ -0,0 +1,5 @@
+import{cp as I,mkdir as b,readFile as C,readdir as h,rm as w,writeFile as x}from"node:fs/promises";import{spawn as P}from"node:child_process";import{homedir as M}from"node:os";import c from"node:path";import{hashFile as k}from"../install/fingerprint.js";import{fileAssetTargetDir as H}from"../install/file-assets.js";import{assetSurfaceFor as $,pluginSurfaceFor as q}from"../surfaces.js";import{marketLibraryRoots as A}from"../market/resolve.js";import{marketIdOf as m}from"../market/identity.js";import{installPluginPack as N}from"../install/plugin-install.js";import{effective as _,setProjectEnabled as O}from"./plugin-project-state.js";import{builtinToolkitRoot as L,discoverToolkitPacks as V}from"./toolkit-scan.js";export class ToolkitError extends Error{code;constructor(e,t){super(e),this.code=t,this.name="ToolkitError"}}export const MIN_MOD_HOST_VERSION=[2,1,287];export function isVersionAtLeast(r,e){const t=r.split(".").map(s=>Number.parseInt(s,10));for(let s=0;s<e.length;s++){const a=Number.isFinite(t[s])?t[s]:0;if(a>e[s])return!0;if(a<e[s])return!1}return!0}let y;function K(r){if(!(r.exitCode!==null||r.signalCode!==null)){if(process.platform==="win32"&&r.pid!==void 0){P("taskkill",["/pid",String(r.pid),"/t","/f"],{windowsHide:!0,stdio:"ignore"}).unref();return}r.kill("SIGKILL")}}export async function detectClaudeVersion(){if(y&&Date.now()-y.at<6e5)return y.value;const r=await new Promise(e=>{let t="";const s=process.platform==="win32"?P("claude --version",{windowsHide:!0,shell:!0,stdio:["ignore","pipe","pipe"]}):P("claude",["--version"],{windowsHide:!0,stdio:["ignore","pipe","pipe"]}),a=setTimeout(()=>{K(s),e(null)},5e3);s.stdout?.on("data",i=>t+=i.toString()),s.on("error",()=>{clearTimeout(a),e(null)}),s.on("close",()=>{clearTimeout(a);const i=/(\d+\.\d+\.\d+)/.exec(t);e(i?i[1]:null)})});return r!==null&&(y={value:r,at:Date.now()}),r}async function S(r,e,t){let s;try{s=await h(c.join(r,...e.split("/").filter(Boolean)),{withFileTypes:!0})}catch{return}for(const a of s){if(a.name==="node_modules"||a.name===".git")continue;const i=e?`${e}/${a.name}`:a.name;a.isDirectory()?await S(r,i,t):t.push({rel:i,abs:c.join(r,...i.split("/"))})}}const f=r=>r.ccPack||r.kind==="mod";async function R(r,e){const t=[],s=e.targets.includes("claude");if(e.skills.length>0)for(const a of e.targets){if(a==="claude"&&f(e))continue;const i=$(a).projectSkillsDir();for(const o of e.skills){const n=[];await S(c.join(e.dir,"skills",o),"",n);for(const l of n)t.push({src:l.abs,rel:`${i}/${o}/${l.rel}`})}}if(s&&!f(e))for(const[a,i]of[["commands","command"],["agents","agent"]]){const o=c.join(e.dir,a),n=[];if(await S(o,"",n),n.length===0)continue;const l=H(i,"claude","project",r,M());for(const u of n){const g=u.rel.split("/").pop();t.push({src:u.abs,rel:j(c.relative(r,c.join(l,g)))})}}return t}function j(r){return r.split(c.sep).join("/")}function E(r,e){return c.join(r,".weave","toolkit",`${e}.json`)}async function v(r){try{const e=JSON.parse(await C(r,"utf8"));return e&&typeof e=="object"&&typeof e.packId=="string"?e:null}catch{return null}}export async function projectFileNamespaces(r){const e=new Map,t=c.join(r,".weave","toolkit");let s;try{s=await h(t)}catch{return e}for(const a of s){if(!a.endsWith(".json"))continue;const i=await v(c.join(t,a)),o=i?m(i.sourceDir):void 0;if(!(!i||!o))for(const n of Object.keys(i.files))e.set(n,o)}return e}export async function projectPackFiles(r){const e=new Map,t=c.join(r,".weave","toolkit");let s;try{s=await h(t)}catch{return e}for(const a of s){if(!a.endsWith(".json"))continue;const i=await v(c.join(t,a));if(i)for(const[o,n]of Object.entries(i.files))typeof n=="string"&&e.set(o,n)}return e}async function T(r){try{return await C(r),!0}catch{return!1}}async function B(r,e){const t=new Set;for(const a of e){let i=c.posix.dirname(a);for(;i&&i!=="."&&i!=="/";)t.add(i),i=c.posix.dirname(i)}const s=[...t].sort((a,i)=>i.split("/").length-a.split("/").length);for(const a of s){const i=c.join(r,...a.split("/"));try{(await h(i)).length===0&&await w(i,{recursive:!0,force:!0})}catch{}}}export function evaluateModHostGate(r){return process.env.WEAVE_SKIP_MOD_VERSION_CHECK==="1"?{ok:!0}:r?isVersionAtLeast(r,MIN_MOD_HOST_VERSION)?{ok:!0}:{ok:!1,message:`\u5BBF\u4E3B Claude Code ${r} \u4F4E\u4E8E 2.1.287\uFF0Cmod \u5DE5\u5177\u5305\u4E0D\u843D\u76D8\uFF08\u8BF7\u5148\u5347\u7EA7 Claude Code\uFF09`}:{ok:!0,warning:"\u65E0\u6CD5\u68C0\u6D4B\u5BBF\u4E3B Claude Code \u7248\u672C\uFF0Cmod \u5DE5\u5177\u5305\u9700\u8981 \u2265 2.1.287 \u624D\u80FD\u88AB\u52A0\u8F7D"}}export class ToolkitService{deps;constructor(e){this.deps=e}sources(){const e=[{root:this.deps.builtinRoot??L(),provenance:"builtin"}];if(this.deps.libraries)for(const s of A(this.deps.libraries))e.push({root:s,provenance:"market"});const t=new Set;return e.filter(s=>{const a=c.resolve(s.root);return t.has(a)?!1:(t.add(a),!0)})}async allPacks(){const e=[];for(const t of this.sources())e.push(...await V(t));return e}async list(e){const t=this.requireProject(e),s=await this.allPacks(),a=[];for(const i of s)a.push(await this.packInfo(t,i));return await this.healMeta(t,a),{packs:a,legacyCopies:await this.scanLegacyCopies(t)}}async enable(e,t,s){const a=this.requireProject(e),i=await this.resolvePack(t,s),o=[];if(i.kind==="mod"&&i.targets.includes("claude")){const d=this.deps.claudeVersion??detectClaudeVersion,p=evaluateModHostGate(await d());if(!p.ok)throw new ToolkitError(p.message??"mod host gate","host-version");p.warning&&o.push(p.warning)}const n=a.path;if(f(i)&&i.targets.includes("claude")){const d=this.pluginSurface();await N(d,i),await d.setProjectEnabled(n,i.name,!0,m(i.dir))}const l=E(n,i.id),u=await this.readRecordHealed(n,i.id),g=u??{packId:i.id,provenance:i.provenance,sourceRoot:i.sourceRoot,sourceDir:i.dir,enabledAt:new Date().toISOString(),files:{}};let F=u===null;const D=await R(n,i);for(const d of D){const p=c.join(n,...d.rel.split("/"));if(g.files[d.rel]!==void 0){await T(p)||(await b(c.dirname(p),{recursive:!0}),await I(d.src,p));continue}await k(p)==="missing"&&(await b(c.dirname(p),{recursive:!0}),await I(d.src,p),g.files[d.rel]=await k(d.src),F=!0)}return D.length>0?F&&(await b(c.dirname(l),{recursive:!0}),await x(l,JSON.stringify(g,null,2)+`
+`,"utf8")):u&&await w(l,{force:!0}),i.weavePack&&O(a,i.id,!0,{projects:this.deps.projects}),this.rememberEnabled(a,i.id,!0),{pack:await this.packInfo(this.requireProject(e),i),warnings:o}}async disable(e,t,s){const a=this.requireProject(e),i=await this.resolvePack(t,s);return await this.applyDisabled(a,i),{pack:await this.packInfo(this.requireProject(e),i),warnings:[]}}async applyDisabled(e,t){await this.removePackFiles(e,t,t.sourceRoot),f(t)&&t.targets.includes("claude")&&await this.pluginSurface().setProjectEnabled(e.path,t.name,!1,m(t.dir)),t.weavePack&&O(e,t.id,!1,{projects:this.deps.projects}),this.rememberEnabled(e,t.id,!1)}async uninstall(e,t,s){const a=this.requireProject(e),i=await this.resolvePack(t,s);return await this.applyDisabled(a,i),f(i)&&i.targets.includes("claude")&&await this.pluginSurface().uninstall(i.name,m(i.dir)),{pack:await this.packInfo(this.requireProject(e),i),warnings:[]}}async removePackFiles(e,t,s){const a=E(e.path,t.id),i=await v(a);if(!i||s&&c.resolve(i.sourceRoot)!==c.resolve(s))return;const o=[];for(const[n,l]of Object.entries(i.files)){const u=c.join(e.path,...n.split("/"));await k(u)===l&&(await w(u,{force:!0}),o.push(n))}await w(a,{force:!0}),await B(e.path,o)}requireProject(e){const t=this.deps.projects.getById(e);if(!t)throw new ToolkitError(`Project not found: ${e}`,"not-found");return t}async resolvePack(e,t){const s=(await this.allPacks()).filter(i=>i.id===e);if(t){const i=s.find(o=>c.resolve(o.sourceRoot)===c.resolve(t));if(i)return i}const a=s.find(i=>i.provenance==="builtin")??s[0];if(!a)throw new ToolkitError(`Toolkit pack not found: ${e}`,"not-found");return a}async computeEnabled(e,t){const s=[],a=await this.readRecordHealed(e.path,t.id);if((await R(e.path,t)).length>0){let i=!!a;if(a){for(const o of Object.keys(a.files))if(!await T(c.join(e.path,...o.split("/")))){i=!1;break}}s.push(i)}if(f(t)&&t.targets.includes("claude")){const i=this.pluginSurface(),o=m(t.dir);s.push(await i.isInstalled(t.name,o)&&await i.readProjectEnabled(e.path,t.name,o))}return t.weavePack&&s.push(_(e,t.id,{states:this.deps.states,defaultEnabled:!1})),s.length>0?s.every(Boolean):!1}async installedScopes(e){const t=(await this.pluginSurface().readInstalled())[e];return!t||t.length===0?void 0:[...new Set(t.map(s=>s.scope??"user"))]}async packInfo(e,t){const s=await this.computeEnabled(e,t),a=m(t.dir),i=f(t)&&t.targets.includes("claude")?this.pluginSurface().pluginKey(t.name,a):void 0,o=i?await this.installedScopes(i):void 0,n={...t,...a?{namespace:a}:{},enabled:s,installed:await this.computeInstalled(e,t,s),...i?{key:i}:{},...o&&o.length>0?{scopes:o}:{}};if(t.weavePack){const l=this.deps.plugins.list().find(u=>u.id===t.id);l&&(n.weave={status:l.status,ruleCount:l.ruleCount,...l.error?{error:l.error}:{}})}return n}async computeInstalled(e,t,s){return t.weavePack&&!f(t)?!0:f(t)&&t.targets.includes("claude")?this.pluginSurface().isInstalled(t.name,m(t.dir)):s||!!await this.readRecordHealed(e.path,t.id)}enabledIndex(e){const t=this.deps.projects.getMeta(e.id)?.toolkit,s=t&&typeof t=="object"?t.enabled:void 0;return Array.isArray(s)?s.filter(a=>typeof a=="string"):[]}rememberEnabled(e,t,s){const a=new Set(this.enabledIndex(e));s?a.add(t):a.delete(t),this.deps.projects.setMeta(e.id,{toolkit:{enabled:[...a].sort()}})}async healMeta(e,t){const s=[...new Set(t.filter(n=>n.enabled).map(n=>n.id))].sort(),a=[...new Set(this.enabledIndex(e))].sort(),i=new Set(t.map(n=>n.id)),o=[...new Set([...a.filter(n=>!i.has(n)),...s])].sort();o.join(`
+`)!==a.join(`
+`)&&this.deps.projects.setMeta(e.id,{toolkit:{enabled:o}})}pluginSurface(){return this.deps.pluginSurface??q("claude")}async readRecordHealed(e,t){const s=E(e,t),a=await v(s);if(!a)return null;const i=j(c.relative(e,this.pluginSurface().projectPluginDir(e))),o=Object.keys(a.files).filter(l=>l.startsWith(`${i}/`));if(o.length===0)return a;const n=[];for(const l of o){const u=c.join(e,...l.split("/"));await k(u)===a.files[l]&&(await w(u,{force:!0}),n.push(l)),delete a.files[l]}return await B(e,n),await x(s,JSON.stringify(a,null,2)+`
+`,"utf8"),a}async scanLegacyCopies(e){const t=this.pluginSurface().projectPluginDir(e.path);let s;try{s=await h(t,{withFileTypes:!0})}catch{return[]}return s.map(a=>j(c.relative(e.path,c.join(t,a.name)))).sort()}async cleanupLegacyCopies(e){const t=this.requireProject(e),s=this.pluginSurface().projectPluginDir(t.path);let a;try{a=await h(s,{withFileTypes:!0})}catch{return{removed:[]}}const i=[];for(const o of a){const n=c.join(s,o.name);await w(n,{recursive:!0,force:!0}),i.push(j(c.relative(t.path,n)))}try{(await h(s)).length===0&&await w(s,{recursive:!0,force:!0})}catch{}return{removed:i.sort()}}}

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

@@ -0,0 +1,35 @@
+/**
+ * @weavecode/server — hook ingestion types.
+ *
+ * The injected project hook script (hook-handler.cjs) is a thin forwarder: it
+ * reads the agent's stdin JSON and POSTs a {@link HookReport} to the daemon.
+ * The daemon-side HookAdapter normalizes the raw payload into a structured
+ * {@link NormalizedHookPayload} before persisting to hook_events.
+ */
+import type { Harness } from '@weavecode/core';
+/** Payload posted by an injected project hook script. */
+export interface HookReport {
+    source: Harness;
+    eventType: string;
+    sessionId?: string | null;
+    cwd?: string;
+    /** Raw JSON captured from the agent's hook stdin. */
+    payload: string;
+    /** 改名交付回执：本事件随 hook 响应实际下发的 sessionTitle（未下发 = null）。
+     *  daemon 据此落定 pending_title——徽标在生效当拍清除，不待下一次上报。 */
+    deliveredTitle?: string | null;
+}
+/**
+ * Structured, source-agnostic representation of a hook event, serialized into
+ * `hook_events.payload`. Extracted by a HookAdapter from the raw agent payload.
+ */
+export interface NormalizedHookPayload {
+    eventType: string;
+    toolName: string | null;
+    toolInput: unknown;
+    toolResponse: unknown;
+    cwd: string | null;
+    transcriptPath: string | null;
+    /** The original raw payload, preserved for debugging/forward-compat. */
+    raw: unknown;
+}

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

@@ -0,0 +1 @@
+export{};

package/node_modules/@weavecode/server/dist/hooks/watch-engine.d.ts

@@ -0,0 +1,79 @@
+import { type Harness } from '@weavecode/core';
+import type { MessagingSurface } from '@weavecode/harness';
+import type { SessionWatchRepository, SessionWatchRow, WatchOn } from '../repositories/session-watches.js';
+import type { SessionRepository } from '../repositories/sessions.js';
+import type { HookEventBus } from './bus.js';
+import type { MessageDeliverer } from './message-deliverer.js';
+/**
+ * 会话订阅引擎（session-orchestration 批 2 + 提醒类型）：`session_watches` 的
+ * one-shot 触发器，三条 fire 路径（订阅的 `onEvents` 决定听哪几条）——
+ *
+ * ① onEvent：ingest 消费路径见到**目标会话**的事件 → `idle` 听 idleSignals
+ *    全集（经 MessagingSurface 取），`turnEnd` 只听一轮对话结束
+ *    （HARNESS_LIFECYCLE[<harness>].close，claude = Stop）——两者都不散写
+ *    Stop/SessionEnd 字面量；
+ * ② onBus：`message.finished` 且终态 failed/timeout → `messageFailed`；
+ * ③ sweepTerminated：既有 SessionSweeper tick 挂钩——daemon 重启或目标异常
+ *    终止（未打 idle 信号，claude 注册表判死）后的补射（第七章 7.3-1）；只补
+ *    空闲类订阅（投递类等的是投递事件，进程死不给它编触发）。
+ *
+ * fire 语义（D3）：watcher 是会话 → 通知文本经 MessageDeliverer 的 inject
+ * 通道注入（非抢占，随它下一拍 hook 事件收到；线程留痕 + message.* 帧）；
+ * watcher 是 dashboard → watch.fired 帧由 web toast + 浏览器通知。markFired
+ * 先行（CAS），投递结果不再回滚——one-shot 落定即失效。
+ *
+ * 一切异常在内部吞掉：watch 失败永不影响采集（hooks 非阻塞不变式）。
+ */
+export declare class WatchEngine {
+    private readonly deps;
+    /** 订阅 id → 上次命中的时刻：同一次转场可能带来多个事件（Stop + SessionEnd），
+     *  窗口内的重复命中不重复计数/提醒（计数订阅的一次 = 一次转场）。 */
+    private readonly lastHitAt;
+    constructor(deps: {
+        watches: Pick<SessionWatchRepository, 'listPendingByTarget' | 'listPending' | 'consumeHit'>;
+        deliverer: Pick<MessageDeliverer, 'send'>;
+        sessions: Pick<SessionRepository, 'getBySessionId' | 'listWithCounts' | 'turnOpenOf'>;
+        bus: HookEventBus;
+        /** 能力面访问器（测试注入）；缺省 surfaces.ts 模块级 registry。 */
+        surfaceFor?: (harness: Harness) => MessagingSurface;
+        /** liveness 探测（测试注入）；缺省 claude 注册表全量扫描。 */
+        livenessOf?: () => Map<string, boolean>;
+    });
+    /**
+     * ingest 消费路径的事件钩子（fire-and-forget；内部全吞）。source 即目标
+     * 会话的 harness（事件来自它）——空闲/回合结束判定按 harness 表取。
+     */
+    onEvent(input: {
+        sessionId: string;
+        eventType: string;
+        source: Harness;
+    }): void;
+    /** 管道终态帧：目标会话的消息投递失败/超时 → `messageFailed` 订阅。 */
+    private onBus;
+    /**
+     * 订阅落库后的即时段（路由插入后调用）：目标**此刻已空闲**（turnOpen
+     * false——服务端基线）→ 立即 fire，不等下一拍。「空闲时提醒我」点在空闲
+     * 会话上，答案就是现在；turnOpen 未知（null）不猜。投递类订阅没有「此刻
+     * 已成真」态，不参与即时段。
+     */
+    created(row: SessionWatchRow): void;
+    /**
+     * terminated 补射：全部 pending 订阅里，目标已判死（claude 注册表 pidAlive
+     * false；目标行已消失 = 等待永不可解）的补 fire。判不动（null）不猜——
+     * 会话可能只是安静。返回补射数（可反复调用，已 fire 的自然不在 pending）。
+     */
+    sweepTerminated(): number;
+    /**
+     * fire 一条订阅（one-shot）：CAS 落定 → 按订阅方分流。返回 false = 并发
+     * 路径（同批 Stop+SessionEnd / 补射与 ingest 竞速）已 fire，本次零副作用。
+     * 同步方法——markFired/bus.emit 均同步；注入投递 fire-and-forget。
+     */
+    private fire;
+    /**
+     * 缺省通知文本（server 单点）：载荷自包含纪律（第七章 7.3-4）——触发类
+     * 消息必须自带「为何此刻收到」，接收会话的上下文可能已被压缩。
+     */
+    private defaultNotify;
+}
+/** 触发类型的英文措辞（注入文本与推送载荷共用同一出处）。 */
+export declare function watchReasonPhrase(reason: WatchOn): string;

package/node_modules/@weavecode/server/dist/hooks/watch-engine.js

@@ -0,0 +1 @@
+import{HARNESS_LIFECYCLE as r}from"@weavecode/core";import{messagingSurfaceFor as a}from"../surfaces.js";import{claudeLivenessById as c,pidAliveOf as l}from"../daemon/claude-liveness.js";const u=1e3;export class WatchEngine{deps;lastHitAt=new Map;constructor(s){this.deps=s,s.bus.subscribe(e=>this.onBus(e))}onEvent(s){try{const e=(this.deps.surfaceFor?.(s.source)??a(s.source)).idleSignals.includes(s.eventType),i=r[s.source].close.includes(s.eventType);if(!e&&!i)return;for(const t of this.deps.watches.listPendingByTarget(s.sessionId))i&&t.onEvents.includes("turnEnd")?this.fire(t,"turnEnd"):e&&t.onEvents.includes("idle")&&this.fire(t,"idle")}catch{}}onBus(s){if(s.kind==="message.finished"&&!(s.status!=="failed"&&s.status!=="timeout"))try{for(const e of this.deps.watches.listPendingByTarget(s.sessionId))e.onEvents.includes("messageFailed")&&this.fire(e,"messageFailed")}catch{}}created(s){try{if(!s.onEvents.includes("idle")&&!s.onEvents.includes("turnEnd"))return;this.deps.sessions.turnOpenOf(s.targetSessionId)===!1&&this.fire(s,s.onEvents.includes("idle")?"idle":"turnEnd")}catch{}}sweepTerminated(){try{const s=this.deps.livenessOf?.()??c(),e=new Map(this.deps.sessions.listWithCounts().map(t=>[t.sessionId,t]));let i=0;for(const t of this.deps.watches.listPending()){if(!t.onEvents.includes("idle")&&!t.onEvents.includes("turnEnd"))continue;const n=e.get(t.targetSessionId);n&&l(n,s)!==!1||this.fire(t,"idle")&&i++}return i}catch{return 0}}fire(s,e){const i=Date.now(),t=this.lastHitAt.get(s.id);if(t!==void 0&&i-t<u)return!1;const n=this.deps.watches.consumeHit(s.id);if(!n)return!1;this.lastHitAt.set(s.id,i),n.firedAt!==null&&this.lastHitAt.delete(s.id);const o=new Date(i).toISOString();return this.deps.bus.emit({kind:"watch.fired",watchId:s.id,targetSessionId:s.targetSessionId,watcherSessionId:s.watcherSessionId,reason:e,at:o}),s.watcherSessionId==null||this.deps.deliverer.send({toSessionId:s.watcherSessionId,text:s.notify??this.defaultNotify(s.targetSessionId,e),fromKind:"session",fromSessionId:s.targetSessionId,mode:"inject"}).catch(()=>{}),!0}defaultNotify(s,e){return`Session ${this.deps.sessions.getBySessionId(s)?.title??s.slice(0,8)} ${watchReasonPhrase(e)} (trigger=watch:${s})`}}export function watchReasonPhrase(d){return d==="messageFailed"?"had a failed message delivery":d==="turnEnd"?"finished its turn":"is now idle"}