@weavecode/weave 0.0.0-stage → 0.1.1

package/node_modules/@weavecode/server/dist/hooks/resume-runner.d.ts

@@ -0,0 +1,67 @@
+import { type ResumeCommandSpec } from '@weavecode/harness';
+import type { HookDispatchRepository } from '../repositories/hook-dispatches.js';
+import type { SessionRepository } from '../repositories/sessions.js';
+import type { ProjectRepository } from '../repositories/projects.js';
+import type { HookEventBus } from './bus.js';
+import { HeadlessRunner, type SpawnLike } from './headless-runner.js';
+export type { SpawnChild, SpawnLike } from './headless-runner.js';
+/**
+ * D3 指令池 resume 执行器：把 pending / injected 的 dispatch 用
+ * `claude --resume <sessionId> -p <prompt>` 在项目根下异步执行，
+ * 退出后回写 succeeded/failed/timeout 并广播 bus dispatch.finished。
+ *
+ * 批 4b：bin/args 规格迁入 `@weavecode/harness` 的 `CLAUDE_RESUME`
+ * （ResumeCommandSpec 注入，缺省 = 现行为）；claudeBin / WEAVE_CLAUDE_BIN
+ * 覆盖窗保留。
+ *
+ * session-orchestration 批 1：spawn/输出收集/超时/并发闸抽入 HeadlessRunner
+ * （与消息域 MessageDeliverer 共享同一实例 = 同会话并发闸跨域生效）；本类只保留
+ * dispatch 域的校验链与状态回写。
+ *
+ * run() 只做「校验 → 置 running → spawn」并立即返回（HTTP「已启动」语义）；
+ * 等待退出、超时强杀、状态回写全部走后台，校验后任何异常内部消化为 failed，
+ * 绝不 throw 出 run()。
+ */
+export interface ResumeRunnerDeps {
+    dispatches: HookDispatchRepository;
+    sessions: SessionRepository;
+    projects: ProjectRepository;
+    bus?: HookEventBus;
+    /** 测试注入的 spawn 实现；缺省用 node:child_process.spawn。 */
+    spawnImpl?: SpawnLike;
+    /** 测试注入的强杀实现（缺省：Windows 下 taskkill，POSIX 杀进程组）。 */
+    killImpl?: (pid: number) => void;
+    /** claude 可执行文件名覆盖（测试用）；缺省环境变量，再缺省 spec.bin。 */
+    claudeBin?: string;
+    /** 批 4b：resume 命令规格注入；缺省 CLAUDE_RESUME（与现行为等价）。 */
+    resumeSpec?: ResumeCommandSpec;
+    /** 单次 resume 超时（毫秒），超时强杀 → timeout；缺省 300_000，测试传短值。 */
+    timeoutMs?: number;
+    /** 共享无头执行核（跨域同会话并发闸）；缺省自建（测试隔离用）。 */
+    headless?: HeadlessRunner;
+}
+/** run() 的返回：ok 由路由映射 200，否则 status 即 HTTP 码。 */
+export type RunResult = {
+    ok: true;
+    dispatchId: number;
+} | {
+    ok: false;
+    status: 400 | 404 | 409;
+    error: string;
+};
+export declare class ResumeRunner {
+    private readonly deps;
+    private readonly headless;
+    private readonly claudeBin;
+    private readonly resumeSpec;
+    private readonly timeoutMs?;
+    constructor(deps: ResumeRunnerDeps);
+    /**
+     * 执行一条 dispatch 的 resume。校验链顺序（规格）：
+     * dispatch 404 → 状态非 pending/injected 409 → session 404 → 无项目根 400
+     * → 同 session 并发 409；通过后置 running + spawn，立即返回 ok。
+     */
+    run(dispatchId: number, sessionId: string): Promise<RunResult>;
+    /** 终态落定（幂等）：回写状态 → 广播 finished；内部消化一切异常。 */
+    private settle;
+}

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

@@ -0,0 +1 @@
+import{CLAUDE_RESUME as o}from"@weavecode/harness";import{HeadlessRunner as l}from"./headless-runner.js";export class ResumeRunner{deps;headless;claudeBin;resumeSpec;timeoutMs;constructor(t){this.deps=t,this.headless=t.headless??new l({spawnImpl:t.spawnImpl,killImpl:t.killImpl}),this.resumeSpec=t.resumeSpec??o,this.claudeBin=t.claudeBin??process.env.WEAVE_CLAUDE_BIN??this.resumeSpec.bin,this.timeoutMs=t.timeoutMs}async run(t,e){const s=this.deps.dispatches.getById(t);if(!s)return{ok:!1,status:404,error:"Dispatch not found"};if(s.status!=="pending"&&s.status!=="injected")return{ok:!1,status:409,error:`Dispatch is ${s.status}`};const r=this.deps.sessions.getBySessionId(e);if(!r)return{ok:!1,status:404,error:"Session not found"};if(r.projectId==null)return{ok:!1,status:400,error:"Session has no project"};const a=this.deps.projects.getById(r.projectId);if(!a)return{ok:!1,status:400,error:"Project not found for session"};if(this.headless.isBusy(e))return{ok:!1,status:409,error:"Session already has a running dispatch"};const u={settled:!1};try{this.deps.dispatches.updateStatus(t,{status:"running"}),this.deps.bus?.emit({kind:"dispatch.started",ruleId:s.ruleId,dispatchId:t,sessionId:e,at:new Date().toISOString()}),this.headless.run({sessionId:e,cwd:a.path,prompt:s.prompt,spec:this.resumeSpec,bin:this.claudeBin,timeoutMs:this.timeoutMs,onSettle:n=>this.settle(s,e,u,n)})||this.settle(s,e,u,{status:"failed",output:null,error:"Session already has a running dispatch"})}catch(i){this.settle(s,e,u,{status:"failed",output:null,error:i instanceof Error?i.message:String(i)})}return{ok:!0,dispatchId:t}}settle(t,e,s,r){if(!s.settled){s.settled=!0;try{this.deps.dispatches.updateStatus(t.id,{status:r.status,output:r.output,error:r.error,finished:!0}),this.deps.bus?.emit({kind:"dispatch.finished",ruleId:t.ruleId,dispatchId:t.id,status:r.status,sessionId:e,at:new Date().toISOString()})}catch{}}}}

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

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

@@ -0,0 +1,37 @@
+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;
+    };
+    /** 上传件（不计数）：事件清完顺带回收再没有人引用的图（文件 + 行）。 */
+    uploads?: {
+        pruneUnreferenced(): number;
+    };
+}
+/**
+ * 删会话的数据清理：会话行 + 该会话的采集事件 + 指令池派发 + 消息管道在途一并清。
+ * 手动删除（`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,t){const n=e.events.deleteBySession(t);e.uploads?.pruneUnreferenced();const r=e.dispatches?.deleteBySession(t)??0,o=e.deliverer?.forgetSession(t)??0;return e.watches?.deleteBySession(t),e.sequences?.deleteMentioning(new Set([t])),e.questions?.forgetSession(t),e.probe?.forget(t),e.sessions.remove(t),{events:n,dispatches:r,messages:o}}

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

@@ -0,0 +1,35 @@
+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;
+/**
+ * 定时清过期会话：判据与期限的单一事实源 = sessions 仓储的 `listWithCounts`
+ * （`autoDeleteAt` 计算列，两档——没等到用户 prompt 的新会话 1 小时快过期、
+ * 收到过 prompt 的走 settings `sessions.idleDays` 闲置窗），本清扫器只做「过期即清」。
+ *
+ * 注：入库路径对**每个**首现 sessionId 都建档（含仅一条 SessionStart 的新会话
+ * ——新建会话要马上出现在列表），期限倒计时随行展示，看得见它还剩多久。
+ */
+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.uploads?.pruneUnreferenced(),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 L,readdir as h,stat as w}from"node:fs/promises";import e from"node:path";import{WEAVE_PLUGIN_MANIFEST as y,WeavePluginManifestSchema as R,HARNESS_KEYS as I}from"@weavecode/core";import{builtinPacksDir as W}from"../market/builtin.js";import{getDataDir as J}from"../db/paths.js";import{hasNonEmptyModules as E}from"../watch/plugin-mods.js";const S=".claude-plugin",v="plugin.json",K="weave.json",D=2,O=10,_=["claude"];export function builtinToolkitRoot(){return e.resolve(W(J()))}async function d(t){try{return(await w(t)).isDirectory()}catch{return!1}}async function p(t){try{const n=JSON.parse(await L(t,"utf8"));return n&&typeof n=="object"&&!Array.isArray(n)?n:null}catch{return null}}export async function isToolkitPackDir(t){return await N(t)?!0:await d(e.join(t,"skills"))||await d(e.join(t,"commands"))||await d(e.join(t,"agents"))}async function N(t){if(await p(e.join(t,S,v)))return!0;try{return await w(e.join(t,y)),!0}catch{}return E(await p(e.join(t,"hooks","hooks.json")))}async function V(t){try{return(await h(t,{withFileTypes:!0})).filter(o=>o.isDirectory()).map(o=>o.name).sort()}catch{return[]}}async function P(t){try{return(await h(t,{withFileTypes:!0})).filter(o=>o.isFile()&&o.name.endsWith(".md")).map(o=>o.name.replace(/\.md$/,"")).sort()}catch{return[]}}function G(t){if(!Array.isArray(t)||t.length===0)return _;const n=t.filter(o=>I.includes(o));return n.length>0?n:_}export async function parseToolkitPack(t,n,o){const i=e.basename(t),a=await p(e.join(t,S,v)),s=await p(e.join(t,y)),r=await p(e.join(t,K)),m=await V(e.join(t,"skills")),g=await P(e.join(t,"commands")),c=await P(e.join(t,"agents")),f=await p(e.join(t,"hooks","hooks.json")),j=E(f),T=!!f&&typeof f.hooks=="object"&&f.hooks!==null,u=[];if(m.length>0&&u.push("skill"),g.length>0&&u.push("command"),c.length>0&&u.push("agent"),j?u.push("mod"):T&&u.push("hook"),s&&u.push("rule"),u.length===0)return null;const k=typeof r?.kind=="string"?r.kind:null,F=k&&["skill","hook","mod","rule","surface"].includes(k)?k:j?"mod":T?"hook":s&&!a?"rule":m.length>0?"skill":"surface",l=s?R.safeParse(s):null,C=l?.success?l.data.id:i,b=(typeof a?.name=="string"?a.name:void 0)??(l?.success?l.data.name:void 0)??i,x=(l?.success?l.data.version:void 0)??(typeof a?.version=="string"?a.version:void 0)??"0.0.0",A=(typeof a?.description=="string"?a.description:void 0)??(l?.success?l.data.description:void 0);return{id:C,name:b,version:x,...A?{description:A}:{},scope:o,dir:t,provenance:n.provenance,sourceRoot:n.root,targets:G(r?.targets),kind:F,components:u,ccPack:!!a,weavePack:!!s,skills:m}}function M(t){return t==="node_modules"||t.startsWith(".")}export async function discoverToolkitPacks(t){const n=t.provenance==="market",o=n?O:D,i=async(a,s,r)=>{if(await isToolkitPackDir(a)&&!(s===0&&n&&!await N(a))){const f=await parseToolkitPack(a,t,r);return f?[f]:[]}if(s>=o)return[];let m;try{m=await h(a,{withFileTypes:!0})}catch{return[]}return(await Promise.all(m.filter(c=>c.isDirectory()&&!M(c.name)).map(c=>i(e.join(a,c.name),s+1,s===0?c.name:r)))).flat()};return i(t.root,0,"")}export function discoverToolkitSources(){return[{root:builtinToolkitRoot(),provenance:"builtin"}]}export async function discoverWeavePackDirs(t){const n=[],o=async(i,a)=>{try{await w(e.join(i,y)),n.push(i);return}catch{}if(a>=D)return;let s;try{s=await h(i,{withFileTypes:!0})}catch{return}for(const r of s)!r.isDirectory()||M(r.name)||await o(e.join(i,r.name),a+1)};return await o(t,0),n}

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

@@ -0,0 +1,175 @@
+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;
+    private packsCache;
+    constructor(deps: ToolkitServiceDeps);
+    /** 扫描源：内置根（测试可覆盖）+ managed 市场资源根。 */
+    private sources;
+    /**
+     * 各扫描源并行发现（市场源要下钻 10 层，一个一个来就是把最慢的那个乘上根数）。
+     *
+     * 盘上清单只在装/卸/导入市场时才变，而 `list` 是面板每次打开都要打的一发
+     * （实测 ~200ms）——10s 内复用上一次的扫描结果，在飞请求共用同一个 Promise
+     * （单飞）。缓存键带扫描根集合：导入/移除市场换了根即重扫，不等 TTL。
+     */
+    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 P,readFile as T,readdir as h,rm as w,writeFile as F}from"node:fs/promises";import{spawn as S}from"node:child_process";import{homedir as H}from"node:os";import c from"node:path";import{hashFile as y}from"../install/fingerprint.js";import{fileAssetTargetDir as L}from"../install/file-assets.js";import{assetSurfaceFor as N,pluginSurfaceFor as $}from"../surfaces.js";import{marketLibraryRoots as q}from"../market/resolve.js";import{marketIdOf as m}from"../market/identity.js";import{installPluginPack as A}from"../install/plugin-install.js";import{effective as V,setProjectEnabled as O}from"./plugin-project-state.js";import{builtinToolkitRoot as K,discoverToolkitPacks as B}from"./toolkit-scan.js";export class ToolkitError extends Error{code;constructor(t,e){super(t),this.code=e,this.name="ToolkitError"}}export const MIN_MOD_HOST_VERSION=[2,1,287];const W=1e4;export function isVersionAtLeast(a,t){const e=a.split(".").map(n=>Number.parseInt(n,10));for(let n=0;n<t.length;n++){const s=Number.isFinite(e[n])?e[n]:0;if(s>t[n])return!0;if(s<t[n])return!1}return!0}let b;function J(a){if(!(a.exitCode!==null||a.signalCode!==null)){if(process.platform==="win32"&&a.pid!==void 0){S("taskkill",["/pid",String(a.pid),"/t","/f"],{windowsHide:!0,stdio:"ignore"}).unref();return}a.kill("SIGKILL")}}export async function detectClaudeVersion(){if(b&&Date.now()-b.at<6e5)return b.value;const a=await new Promise(t=>{let e="";const n=process.platform==="win32"?S("claude --version",{windowsHide:!0,shell:!0,stdio:["ignore","pipe","pipe"]}):S("claude",["--version"],{windowsHide:!0,stdio:["ignore","pipe","pipe"]}),s=setTimeout(()=>{J(n),t(null)},5e3);n.stdout?.on("data",i=>e+=i.toString()),n.on("error",()=>{clearTimeout(s),t(null)}),n.on("close",()=>{clearTimeout(s);const i=/(\d+\.\d+\.\d+)/.exec(e);t(i?i[1]:null)})});return a!==null&&(b={value:a,at:Date.now()}),a}async function C(a,t,e){let n;try{n=await h(c.join(a,...t.split("/").filter(Boolean)),{withFileTypes:!0})}catch{return}for(const s of n){if(s.name==="node_modules"||s.name===".git")continue;const i=t?`${t}/${s.name}`:s.name;s.isDirectory()?await C(a,i,e):e.push({rel:i,abs:c.join(a,...i.split("/"))})}}const p=a=>a.ccPack||a.kind==="mod";async function R(a,t){const e=[],n=t.targets.includes("claude");if(t.skills.length>0)for(const s of t.targets){if(s==="claude"&&p(t))continue;const i=N(s).projectSkillsDir();for(const o of t.skills){const r=[];await C(c.join(t.dir,"skills",o),"",r);for(const l of r)e.push({src:l.abs,rel:`${i}/${o}/${l.rel}`})}}if(n&&!p(t))for(const[s,i]of[["commands","command"],["agents","agent"]]){const o=c.join(t.dir,s),r=[];if(await C(o,"",r),r.length===0)continue;const l=L(i,"claude","project",a,H());for(const u of r){const g=u.rel.split("/").pop();e.push({src:u.abs,rel:v(c.relative(a,c.join(l,g)))})}}return e}function v(a){return a.split(c.sep).join("/")}function x(a,t){return c.join(a,".weave","toolkit",`${t}.json`)}async function k(a){try{const t=JSON.parse(await T(a,"utf8"));return t&&typeof t=="object"&&typeof t.packId=="string"?t:null}catch{return null}}export async function projectFileNamespaces(a){const t=new Map,e=c.join(a,".weave","toolkit");let n;try{n=await h(e)}catch{return t}for(const s of n){if(!s.endsWith(".json"))continue;const i=await k(c.join(e,s)),o=i?m(i.sourceDir):void 0;if(!(!i||!o))for(const r of Object.keys(i.files))t.set(r,o)}return t}export async function projectPackFiles(a){const t=new Map,e=c.join(a,".weave","toolkit");let n;try{n=await h(e)}catch{return t}for(const s of n){if(!s.endsWith(".json"))continue;const i=await k(c.join(e,s));if(i)for(const[o,r]of Object.entries(i.files))typeof r=="string"&&t.set(o,r)}return t}async function M(a){try{return await T(a),!0}catch{return!1}}async function _(a,t){const e=new Set;for(const s of t){let i=c.posix.dirname(s);for(;i&&i!=="."&&i!=="/";)e.add(i),i=c.posix.dirname(i)}const n=[...e].sort((s,i)=>i.split("/").length-s.split("/").length);for(const s of n){const i=c.join(a,...s.split("/"));try{(await h(i)).length===0&&await w(i,{recursive:!0,force:!0})}catch{}}}export function evaluateModHostGate(a){return process.env.WEAVE_SKIP_MOD_VERSION_CHECK==="1"?{ok:!0}:a?isVersionAtLeast(a,MIN_MOD_HOST_VERSION)?{ok:!0}:{ok:!1,message:`\u5BBF\u4E3B Claude Code ${a} \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;packsCache;constructor(t){this.deps=t}sources(){const e=[{root:this.deps.builtinRoot??K(),provenance:"builtin"}];if(this.deps.libraries)for(const s of q(this.deps.libraries))e.push({root:s,provenance:"market"});const n=new Set;return e.filter(s=>{const i=c.resolve(s.root);return n.has(i)?!1:(n.add(i),!0)})}async allPacks(){const t=this.sources(),e=t.map(r=>c.resolve(r.root)).join("|"),n=Date.now(),s=this.packsCache;if(s&&s.key===e&&n-s.at<W)return s.packs;const i=Promise.all(t.map(r=>B(r))).then(r=>r.flat()),o={at:n,key:e,packs:i};return this.packsCache=o,i.catch(()=>{this.packsCache===o&&(this.packsCache=void 0)}),i}async list(t){const e=this.requireProject(t),n=await this.allPacks(),s=await Promise.all(n.map(i=>this.packInfo(e,i)));return await this.healMeta(e,s),{packs:s,legacyCopies:await this.scanLegacyCopies(e)}}async enable(t,e,n){const s=this.requireProject(t),i=await this.resolvePack(e,n),o=[];if(i.kind==="mod"&&i.targets.includes("claude")){const d=this.deps.claudeVersion??detectClaudeVersion,f=evaluateModHostGate(await d());if(!f.ok)throw new ToolkitError(f.message??"mod host gate","host-version");f.warning&&o.push(f.warning)}const r=s.path;if(p(i)&&i.targets.includes("claude")){const d=this.pluginSurface();await A(d,i),await d.setProjectEnabled(r,i.name,!0,m(i.dir))}const u=x(r,i.id),g=await this.readRecordHealed(r,i.id),j=g??{packId:i.id,provenance:i.provenance,sourceRoot:i.sourceRoot,sourceDir:i.dir,enabledAt:new Date().toISOString(),files:{}};let E=g===null;const D=await R(r,i);for(const d of D){const f=c.join(r,...d.rel.split("/"));if(j.files[d.rel]!==void 0){await M(f)||(await P(c.dirname(f),{recursive:!0}),await I(d.src,f));continue}await y(f)==="missing"&&(await P(c.dirname(f),{recursive:!0}),await I(d.src,f),j.files[d.rel]=await y(d.src),E=!0)}return D.length>0?E&&(await P(c.dirname(u),{recursive:!0}),await F(u,JSON.stringify(j,null,2)+`
+`,"utf8")):g&&await w(u,{force:!0}),i.weavePack&&O(s,i.id,!0,{projects:this.deps.projects}),this.rememberEnabled(s,i.id,!0),{pack:await this.packInfo(this.requireProject(t),i),warnings:o}}async disable(t,e,n){const s=this.requireProject(t),i=await this.resolvePack(e,n);return await this.applyDisabled(s,i),{pack:await this.packInfo(this.requireProject(t),i),warnings:[]}}async applyDisabled(t,e){await this.removePackFiles(t,e,e.sourceRoot),p(e)&&e.targets.includes("claude")&&await this.pluginSurface().setProjectEnabled(t.path,e.name,!1,m(e.dir)),e.weavePack&&O(t,e.id,!1,{projects:this.deps.projects}),this.rememberEnabled(t,e.id,!1)}async uninstall(t,e,n){const s=this.requireProject(t),i=await this.resolvePack(e,n);return await this.applyDisabled(s,i),p(i)&&i.targets.includes("claude")&&await this.pluginSurface().uninstall(i.name,m(i.dir)),{pack:await this.packInfo(this.requireProject(t),i),warnings:[]}}async removePackFiles(t,e,n){const s=x(t.path,e.id),i=await k(s);if(!i||n&&c.resolve(i.sourceRoot)!==c.resolve(n))return;const o=[];for(const[r,l]of Object.entries(i.files)){const u=c.join(t.path,...r.split("/"));await y(u)===l&&(await w(u,{force:!0}),o.push(r))}await w(s,{force:!0}),await _(t.path,o)}requireProject(t){const e=this.deps.projects.getById(t);if(!e)throw new ToolkitError(`Project not found: ${t}`,"not-found");return e}async resolvePack(t,e){this.packsCache=void 0;const n=(await this.allPacks()).filter(o=>o.id===t);if(e){const o=n.find(r=>c.resolve(r.sourceRoot)===c.resolve(e));if(o)return o}const i=n.find(o=>o.provenance==="builtin")??n[0];if(!i)throw new ToolkitError(`Toolkit pack not found: ${t}`,"not-found");return i}async computeEnabled(t,e){const n=[],s=await this.readRecordHealed(t.path,e.id);if((await R(t.path,e)).length>0){let o=!!s;if(s){for(const r of Object.keys(s.files))if(!await M(c.join(t.path,...r.split("/")))){o=!1;break}}n.push(o)}if(p(e)&&e.targets.includes("claude")){const o=this.pluginSurface(),r=m(e.dir);n.push(await o.isInstalled(e.name,r)&&await o.readProjectEnabled(t.path,e.name,r))}return e.weavePack&&n.push(V(t,e.id,{states:this.deps.states,defaultEnabled:!1})),n.length>0?n.every(Boolean):!1}async installedScopes(t){const e=(await this.pluginSurface().readInstalled())[t];return!e||e.length===0?void 0:[...new Set(e.map(s=>s.scope??"user"))]}async packInfo(t,e){const n=await this.computeEnabled(t,e),s=m(e.dir),i=p(e)&&e.targets.includes("claude")?this.pluginSurface().pluginKey(e.name,s):void 0,o=i?await this.installedScopes(i):void 0,r={...e,...s?{namespace:s}:{},enabled:n,installed:await this.computeInstalled(t,e,n),...i?{key:i}:{},...o&&o.length>0?{scopes:o}:{}};if(e.weavePack){const l=this.deps.plugins.list().find(u=>u.id===e.id);l&&(r.weave={status:l.status,ruleCount:l.ruleCount,...l.error?{error:l.error}:{}})}return r}async computeInstalled(t,e,n){return e.weavePack&&!p(e)?!0:p(e)&&e.targets.includes("claude")?this.pluginSurface().isInstalled(e.name,m(e.dir)):n||!!await this.readRecordHealed(t.path,e.id)}enabledIndex(t){const n=this.deps.projects.getMeta(t.id)?.toolkit,s=n&&typeof n=="object"?n.enabled:void 0;return Array.isArray(s)?s.filter(i=>typeof i=="string"):[]}rememberEnabled(t,e,n){const s=new Set(this.enabledIndex(t));n?s.add(e):s.delete(e),this.deps.projects.setMeta(t.id,{toolkit:{enabled:[...s].sort()}})}async healMeta(t,e){const n=[...new Set(e.filter(r=>r.enabled).map(r=>r.id))].sort(),s=[...new Set(this.enabledIndex(t))].sort(),i=new Set(e.map(r=>r.id)),o=[...new Set([...s.filter(r=>!i.has(r)),...n])].sort();o.join(`
+`)!==s.join(`
+`)&&this.deps.projects.setMeta(t.id,{toolkit:{enabled:o}})}pluginSurface(){return this.deps.pluginSurface??$("claude")}async readRecordHealed(t,e){const n=x(t,e),s=await k(n);if(!s)return null;const i=v(c.relative(t,this.pluginSurface().projectPluginDir(t))),o=Object.keys(s.files).filter(l=>l.startsWith(`${i}/`));if(o.length===0)return s;const r=[];for(const l of o){const u=c.join(t,...l.split("/"));await y(u)===s.files[l]&&(await w(u,{force:!0}),r.push(l)),delete s.files[l]}return await _(t,r),await F(n,JSON.stringify(s,null,2)+`
+`,"utf8"),s}async scanLegacyCopies(t){const e=this.pluginSurface().projectPluginDir(t.path);let n;try{n=await h(e,{withFileTypes:!0})}catch{return[]}return n.map(s=>v(c.relative(t.path,c.join(e,s.name)))).sort()}async cleanupLegacyCopies(t){const e=this.requireProject(t),n=this.pluginSurface().projectPluginDir(e.path);let s;try{s=await h(n,{withFileTypes:!0})}catch{return{removed:[]}}const i=[];for(const o of s){const r=c.join(n,o.name);await w(r,{recursive:!0,force:!0}),i.push(v(c.relative(e.path,r)))}try{(await h(n)).length===0&&await w(n,{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{};