@feng0531/dsh-execution-bus 0.11.3 → 0.12.0

package/README.md

@@ -4,7 +4,7 @@
 
 “萧何”是产品与模式显示名，执行总线是其技术功能；不新增人物 Agent，不进行角色扮演。仓库 dsh-execution-bus、npm 包名、execution_bus 工具名及 execution-bus-test 预设 ID 保持不变。历史版本发布说明保留当时名称。
 
-DSH 独立插件：`@feng0531/dsh-execution-bus` · 当前版本 **0.11.3**
+DSH 独立插件：`@feng0531/dsh-execution-bus` · 当前版本 **0.12.0**
 
 > 萧何模式从宿主已声明的 PTC 组合派生，保留日常工具，再叠加可选执行总线。已验证隔离的真实 Node PTC → 原 read + 总线调用，以及脚本模型内存会话；真实模型、桌面界面与实际沙箱仍未验收。**不支持重启后恢复任务。**
 
@@ -130,7 +130,7 @@ flowchart TD
 2. 在你选定的隔离 DSH 配置依赖目录安装固定版本，不要在 DSH 程序安装目录执行：
 
    ```powershell
-   npm install --ignore-scripts @feng0531/dsh-execution-bus@0.11.3
+   npm install --ignore-scripts @feng0531/dsh-execution-bus@0.12.0
    ```
 
    这是 npm 目录示例。若目标配置使用 pnpm，应沿用其包管理器，不混用锁文件。遇到宿主 peer 版本冲突就停止，不用强制安装绕过。
@@ -205,6 +205,13 @@ PTC 是 DSH 的程序化工具调用入口。在 `run_code` 内使用 `await too
 
 **跨步骤取回的正确姿势（0.11.1 补充）：** 同一 `run_code` 程序内，未完成的 request 会阻塞后发工具调用的结果提交（宿主按提交顺序结算）；不要在同一个程序里“启动后立刻 status 轮询”。启动步骤只发请求并尽早结束程序，下一步再用同一 `requestId` 的 `status`/`result`（或重发同一 request）附着取回——pilot 实测单次执行、返回 `reused:true`。
 
+### 调度与互斥（0.12.0）
+
+- **队列类别**：内置 Handler 分为 `fs`（read/glob/grep/edit/write）、`command`（pwsh）、`diagnostic`（test）。同会话内按类别优先级 + 等待老化选择：长命令不会长期压住文件/搜索类任务，等待超过阈值会逐步削平类别差距。
+- **舱壁**：Handler 可声明 `maxConcurrency`，同一 Handler 运行数受限；`execution_bus_state` 的 `waitReason` 会显示 `concurrency`/`dispatch`/`resource`，运行超过 30 秒的任务标记 `longRunning`。
+- **资源互斥**：`host.edit`/`host.write` 按 `file_path` 资源键在**同一总线实例内**串行，避免同文件并发写；失败/取消/关闭都会释放。它是插件内互斥，不是 OS 文件锁或跨进程保证。
+- **唯一任务**：`host.read`/`host.glob`/`host.grep` 声明 payload 去重；同会话同输入且已有成功结果时，新 requestId 直接复用并返回 `reused:true`（失败结果不缓存，不会把失败当成功复用）。
+
 **0.9.0 起，预算到期不再连带取消已受理执行。** `run_code` 因时间预算到期或程序结束时，宿主会中断其中的工具子调用；总线把这种中断视为**只停止等待**：已受理执行与宿主 Job 继续，程序返回预算错误后，可在后续 `run_code` 中用同一 `requestId` 的 `status`/`result` 取回结果，或用 `cancel` 取消。用户主动中断、会话取消、沙箱模式变化等其他原因仍会请求取消整个执行。该识别依赖 DSH 0.2.1-rc.2 的中断原因字符串（见[宿主兼容性](<docs/host-compatibility.md>)），不是宿主公开稳定契约；进程退出仍会丢失全部内存状态，保留期一小时。
 
 ## 如何理解任务状态？
@@ -280,7 +287,7 @@ npm run test:install    # 临时目录安装，不操作日常 DSH
 
 - [协议和投递语义](<docs/protocol.md>)：字段、状态、重复处理与取消规则。
 - [宿主兼容性与源码调用链](<docs/host-compatibility.md>)：为什么可以等待，为什么不能跨重启恢复。
-- [验证记录](<docs/validation.md>)、[0.11.3 发布说明](<docs/releases/0.11.3.md>)：已验证与未验证范围。
+- [验证记录](<docs/validation.md>)、[0.12.0 发布说明](<docs/releases/0.12.0.md>)：已验证与未验证范围。
 - [同类项目源码整合](<docs/INTEGRATION.md>)：固定来源、采用范围、许可与验证边界。
 - [维护者发布流程](<docs/RELEASING.md>)：标签 CI、安装包校验与正式发布门禁。
 

package/THIRD_PARTY_NOTICES.md

@@ -5,3 +5,5 @@
 CI 与发布组织方式参考 dsh-vcs，并按本项目执行能力重新实现；本包不含 Monaco、React 或 SVN 实现。
 
 0.5.0 定向参考 dsh-llm-rate-limit（MIT，hanruochong）、dsh-nightshift（MIT，contributors）和 dsh-input-traffic（MIT，contributors）的准入、生命周期和会话视图原则，按本项目契约自行实现，没有复制其源码或捆绑依赖。AsyncGate 与 cc-multi-process-mcp 仅用于边界比较，所查快照未发现 LICENSE，不复制代码。固定来源与阅读范围见 [整合说明](<docs/INTEGRATION.md>)。
+
+0.12.0 定向阅读 Temporal（文档；SDK MIT）、Restate（文档；BUSL-1.1，未复制代码）、DBOS（文档；Transact MIT）、Oban（Apache-2.0）、BullMQ（MIT）与 Resilience4j（Apache-2.0）的公开文档/README，按本插件边界重新实现调度隔离与资源互斥，没有复制第三方源码或新增运行依赖。fast-check（MIT，dubzzz）仅作为开发依赖用于属性测试，不进入本项目 tgz。

package/dist/bus.d.ts

@@ -6,6 +6,14 @@ export interface AdmissionPolicy {
     sessionQueueLimit?: number;
     maxQueueWaitMs?: number;
 }
+export interface SchedulerPolicy {
+    /** Handler.queue → 类别优先级（数值越小越先出队）。 */
+    queueClassOrder?: Readonly<Record<string, number>>;
+    /** 等待多久提升一级（最多提升两级）。 */
+    queueAgingMs?: number;
+    /** 运行超过该阈值时在状态快照标记 longRunning。 */
+    longRunningMs?: number;
+}
 /** Volatile single-process bus; no acceptance durability or automatic execution retry. */
 export declare class ExecutionBus {
     readonly options: {
@@ -16,11 +24,17 @@ export declare class ExecutionBus {
         retentionMs: number;
     };
     readonly admission: AdmissionPolicy;
+    readonly scheduler: Readonly<Required<SchedulerPolicy>>;
     private entries;
     private handlers;
     private queue;
     private readyOwners;
     private running;
+    private runningByHandler;
+    /** 资源键 → 占用它的运行中 Entry；有副作用 Handler 据此互斥。 */
+    private resourceLocks;
+    /** payload 指纹 → 已成功或运行中的 Entry，用于唯一任务复用。 */
+    private dedupeIndex;
     private retainedResultBytes;
     private closed;
     private telemetry;
@@ -40,6 +54,7 @@ export declare class ExecutionBus {
             job_released?: number | undefined;
             job_error?: number | undefined;
             reused?: number | undefined;
+            unique_reused?: number | undefined;
         };
         traces: {
             operation: number;
@@ -55,7 +70,7 @@ export declare class ExecutionBus {
         recordLimit: number;
         resultBytes: number;
         retentionMs: number;
-    }, admission?: AdmissionPolicy);
+    }, admission?: AdmissionPolicy, scheduler?: Readonly<Required<SchedulerPolicy>>);
     register(name: string, handler: Handler): () => void;
     private key;
     private emit;
@@ -81,6 +96,17 @@ export declare class ExecutionBus {
     private admitInvocation;
     /** 若启用了排队期限，登记到期结算为 QUEUE_WAIT_TIMEOUT 的计时器。 */
     private scheduleQueueDeadline;
+    /** 计算并校验 Handler 的资源键；失败则请求不进入队列。 */
+    private resourcesFor;
+    /** 唯一任务命中已成功终态时，构造一个不再执行 Handler 的只读结果记录。 */
+    private syntheticUnique;
+    private releaseResources;
+    /** 是否有空闲槽位供此 Entry 开始执行（Handler 舱壁 + 资源互斥）。 */
+    private eligible;
+    /** 类别优先级 + 等待老化：分数越低越先出队，长时间等待会逐步压过类别差异。 */
+    private effectivePriority;
+    /** 对已到期的排队任务结算 QUEUE_WAIT_TIMEOUT，再从队列移除。 */
+    private expireQueued;
     private attachment;
     command(owner: Owner, raw: unknown): RecordView;
     private removeQueued;
@@ -104,6 +130,7 @@ export declare class ExecutionBus {
             error: string | null;
             progress: number | null;
             waitReason: string | null;
+            longRunning: boolean;
             phase: string;
             queueMs: number;
             runMs: number;
@@ -113,7 +140,7 @@ export declare class ExecutionBus {
     };
     private cancel;
     private finish;
-    /** 按会话轮转挑选下一个出队项：各会话内部 FIFO，跨会话公平。 */
+    /** 按会话轮转选择下一个可执行项：会话内按类别优先级 + 老化，跨会话公平。 */
     private nextQueuedIndex;
     private pump;
     private run;

package/dist/bus.js

@@ -4,7 +4,7 @@ import { Diagnostics } from "./diagnostics.js";
 import { ERRORS } from "./error-codes.js";
 import { assertJson } from "./json.js";
 import { LIMITS } from "./limits.js";
-import { CORE_DEFAULTS } from "./product.js";
+import { CORE_DEFAULTS, SCHEDULER_POLICY } from "./product.js";
 import { canonical, freezeJson, object, parse } from "./protocol.js";
 export { object, parse };
 const isTerminal = (s) => !["queued", "running"].includes(s);
@@ -16,11 +16,17 @@ function hashPayload(payload) {
 export class ExecutionBus {
     options;
     admission;
+    scheduler;
     entries = new Map();
     handlers = new Map();
     queue = [];
     readyOwners = [];
     running = 0;
+    runningByHandler = new Map();
+    /** 资源键 → 占用它的运行中 Entry；有副作用 Handler 据此互斥。 */
+    resourceLocks = new Map();
+    /** payload 指纹 → 已成功或运行中的 Entry，用于唯一任务复用。 */
+    dedupeIndex = new Map();
     retainedResultBytes = 0;
     closed = false;
     telemetry = new Diagnostics();
@@ -36,9 +42,36 @@ export class ExecutionBus {
     }
     closing;
     shutdownPhase = "open";
-    constructor(options = CORE_DEFAULTS, admission = {}) {
+    constructor(options = CORE_DEFAULTS, admission = {}, scheduler = SCHEDULER_POLICY) {
         this.options = options;
         this.admission = admission;
+        this.scheduler = scheduler;
+        const schedulerKeys = ["queueClassOrder", "queueAgingMs", "longRunningMs"];
+        if (!scheduler ||
+            typeof scheduler !== "object" ||
+            Array.isArray(scheduler) ||
+            Reflect.ownKeys(scheduler).some((key) => typeof key !== "string" || !schedulerKeys.includes(key)))
+            throw Error(ERRORS.INVALID_OPTIONS);
+        if (!Number.isSafeInteger(scheduler.queueAgingMs) ||
+            scheduler.queueAgingMs < 1 ||
+            !Number.isSafeInteger(scheduler.longRunningMs) ||
+            scheduler.longRunningMs < 1)
+            throw Error(ERRORS.INVALID_OPTIONS);
+        const order = scheduler.queueClassOrder;
+        if (!order || typeof order !== "object" || Array.isArray(order))
+            throw Error(ERRORS.INVALID_OPTIONS);
+        for (const [className, rank] of Object.entries(order))
+            if (typeof className !== "string" ||
+                className.length === 0 ||
+                className.length > 64 ||
+                !Number.isSafeInteger(rank) ||
+                rank < 0)
+                throw Error(ERRORS.INVALID_OPTIONS);
+        this.scheduler = Object.freeze({
+            queueClassOrder: Object.freeze({ ...order }),
+            queueAgingMs: scheduler.queueAgingMs,
+            longRunningMs: scheduler.longRunningMs,
+        });
         const allowed = ["sessionQueueLimit", "maxQueueWaitMs"];
         if (!admission ||
             typeof admission !== "object" ||
@@ -79,6 +112,19 @@ export class ExecutionBus {
     register(name, handler) {
         if (this.handlers.has(name))
             throw Error(ERRORS.DUPLICATE_HANDLER);
+        if (!handler ||
+            typeof handler !== "object" ||
+            (handler.queue !== undefined &&
+                (typeof handler.queue !== "string" ||
+                    handler.queue.length === 0 ||
+                    handler.queue.length > 64)) ||
+            (handler.maxConcurrency !== undefined &&
+                (!Number.isSafeInteger(handler.maxConcurrency) ||
+                    handler.maxConcurrency < 1)) ||
+            (handler.dedupe !== undefined && handler.dedupe !== "payload") ||
+            (handler.dedupe === "payload" && handler.idempotent !== true) ||
+            (handler.resources !== undefined && typeof handler.resources !== "function"))
+            throw Error(ERRORS.INVALID_HANDLER_OPTIONS);
         const registration = { handler, token: Symbol(name) };
         this.handlers.set(name, registration);
         let disposed = false;
@@ -145,6 +191,10 @@ export class ExecutionBus {
                 this.retainedResultBytes -= e.resultBytes;
                 this.entries.delete(k);
             }
+        const live = new Set(this.entries.values());
+        for (const [key, e] of this.dedupeIndex)
+            if (!live.has(e))
+                this.dedupeIndex.delete(key);
     }
     submit(owner, raw, onEvent, invoke) {
         if (this.closed)
@@ -199,6 +249,26 @@ export class ExecutionBus {
         if (!handler)
             throw Error(ERRORS.UNKNOWN_HANDLER);
         handler.validate(parts.input);
+        const dedupeKey = handler.dedupe === "payload"
+            ? JSON.stringify([owner.sessionId, parts.handler, fingerprint])
+            : undefined;
+        if (dedupeKey !== undefined) {
+            const target = this.dedupeIndex.get(dedupeKey);
+            if (target !== undefined &&
+                target.view.state === "succeeded" &&
+                isTerminal(target.view.state)) {
+                try {
+                    const unique = this.syntheticUnique(owner, m, parts, key, fingerprint, handler, target, dedupeKey);
+                    return this.attachment(unique, onEvent, m.messageId, true);
+                }
+                catch (error) {
+                    if (error instanceof Error && error.message === ERRORS.BACKPRESSURE)
+                        throw error;
+                    // 结果不可克隆时退回正常执行，避免把唯一缓存错误变成请求失败。
+                }
+            }
+        }
+        const resources = this.resourcesFor(handler, parts.input);
         if (this.entries.size >= this.options.recordLimit ||
             this.queue.length >= this.options.queueLimit)
             throw Error(ERRORS.BACKPRESSURE);
@@ -216,6 +286,10 @@ export class ExecutionBus {
             owner: owner.sessionId,
             fingerprint,
             handler,
+            handlerName: parts.handler,
+            queueClass: handler.queue ?? "default",
+            resources,
+            dedupeKey,
             input: structuredClone(parts.input),
             view: {
                 requestId: m.requestId,
@@ -235,6 +309,8 @@ export class ExecutionBus {
             messages: new Map([[m.messageId, canonical(m)]]),
         };
         this.entries.set(key, e);
+        if (dedupeKey !== undefined)
+            this.dedupeIndex.set(dedupeKey, e);
         this.telemetry.record(e.trace, "accepted");
         const attached = this.attachment(e, onEvent, m.messageId);
         this.queue.push(e);
@@ -262,6 +338,112 @@ export class ExecutionBus {
         };
         e.queueTimer = setTimeout(expire, this.admission.maxQueueWaitMs);
     }
+    /** 计算并校验 Handler 的资源键；失败则请求不进入队列。 */
+    resourcesFor(handler, input) {
+        if (handler.resources === undefined)
+            return [];
+        let raw;
+        try {
+            raw = handler.resources(input);
+        }
+        catch {
+            throw Error(ERRORS.INVALID_RESOURCES);
+        }
+        if (!Array.isArray(raw) || raw.length > 8)
+            throw Error(ERRORS.INVALID_RESOURCES);
+        const resources = [];
+        for (const resource of raw) {
+            if (typeof resource !== "string" ||
+                resource.length === 0 ||
+                resource.length > 256)
+                throw Error(ERRORS.INVALID_RESOURCES);
+            if (!resources.includes(resource))
+                resources.push(resource);
+        }
+        resources.sort();
+        return resources;
+    }
+    /** 唯一任务命中已成功终态时，构造一个不再执行 Handler 的只读结果记录。 */
+    syntheticUnique(owner, m, parts, key, fingerprint, handler, target, dedupeKey) {
+        if (this.entries.size >= this.options.recordLimit)
+            throw Error(ERRORS.BACKPRESSURE);
+        const snapshot = freezeJson(structuredClone({
+            requestId: m.requestId,
+            state: "succeeded",
+            sequence: 1,
+            cancelRequested: false,
+            delivery: "pending",
+            result: target.view.result,
+        }));
+        let resolve;
+        const done = new Promise((r) => (resolve = r));
+        const e = {
+            trace: this.telemetry.begin(),
+            resultBytes: 0,
+            invoke: undefined,
+            correlationId: m.messageId,
+            owner: owner.sessionId,
+            fingerprint,
+            handler,
+            handlerName: parts.handler,
+            queueClass: handler.queue ?? "default",
+            resources: [],
+            dedupeKey,
+            input: structuredClone(parts.input),
+            view: { ...snapshot, sequence: 1 },
+            controller: new AbortController(),
+            done,
+            resolve,
+            listeners: new Set(),
+            notifications: [],
+            dispatching: false,
+            sourceSequence: 0,
+            created: Date.now(),
+            messages: new Map([[m.messageId, canonical(m)]]),
+        };
+        this.entries.set(key, e);
+        this.telemetry.record(e.trace, "accepted");
+        this.telemetry.record(e.trace, "unique_reused");
+        e.resolve(snapshot);
+        return e;
+    }
+    releaseResources(e) {
+        for (const resource of e.resources)
+            if (this.resourceLocks.get(resource) === e)
+                this.resourceLocks.delete(resource);
+    }
+    /** 是否有空闲槽位供此 Entry 开始执行（Handler 舱壁 + 资源互斥）。 */
+    eligible(e, now) {
+        void now;
+        const limit = e.handler.maxConcurrency;
+        if (limit !== undefined &&
+            (this.runningByHandler.get(e.handler) ?? 0) >= limit)
+            return false;
+        for (const resource of e.resources)
+            if (this.resourceLocks.has(resource))
+                return false;
+        return true;
+    }
+    /** 类别优先级 + 等待老化：分数越低越先出队，长时间等待会逐步压过类别差异。 */
+    effectivePriority(e, now) {
+        const rank = this.scheduler.queueClassOrder[e.queueClass] ?? 3;
+        const boost = Math.min(2, Math.floor(Math.max(0, now - e.trace.at) / this.scheduler.queueAgingMs));
+        // 老化只削平类别差距，不把优先级推到负值；同分时按队列先后（FIFO）决出。
+        return Math.max(0, rank - boost);
+    }
+    /** 对已到期的排队任务结算 QUEUE_WAIT_TIMEOUT，再从队列移除。 */
+    expireQueued(now) {
+        for (const e of [...this.queue]) {
+            if (e.view.state !== "queued") {
+                this.removeQueued(e);
+                continue;
+            }
+            if (e.deadline !== undefined && now >= e.deadline) {
+                this.removeQueued(e);
+                this.finish(e, "failed", undefined, "QUEUE_WAIT_TIMEOUT");
+            }
+        }
+    }
     attachment(e, onEvent, id, reused = false) {
         // 每次附着独立占配额，即使调用方复用同一个回调。
         const listener = onEvent ? (event) => onEvent(event) : undefined;
@@ -349,8 +531,14 @@ export class ExecutionBus {
             waitReason: e.view.state === "queued"
                 ? this.running >= this.options.concurrency
                     ? "concurrency"
-                    : "dispatch"
+                    : this.eligible(e, now)
+                        ? "dispatch"
+                        : "resource"
                 : null,
+            longRunning: e.view.state === "running" &&
+                e.startedAt !== undefined &&
+                (e.finishedAt ?? now) - e.startedAt >=
+                    this.scheduler.longRunningMs,
             phase: isTerminal(e.view.state)
                 ? e.view.delivery === "returned"
                     ? "returned"
@@ -393,6 +581,11 @@ export class ExecutionBus {
     finish(e, state, result, error, resultBytes = 0) {
         if (isTerminal(e.view.state))
             return;
+        this.releaseResources(e);
+        if (e.dedupeKey !== undefined &&
+            this.dedupeIndex.get(e.dedupeKey) === e &&
+            state !== "succeeded")
+            this.dedupeIndex.delete(e.dedupeKey);
         if (e.queueTimer !== undefined) {
             clearTimeout(e.queueTimer);
             e.queueTimer = undefined;
@@ -435,44 +628,66 @@ export class ExecutionBus {
         if (!e.dispatching)
             e.listeners.clear();
     }
-    /** 按会话轮转挑选下一个出队项：各会话内部 FIFO，跨会话公平。 */
-    nextQueuedIndex() {
-        let index = -1;
-        while (this.readyOwners.length && index < 0) {
+    /** 按会话轮转选择下一个可执行项：会话内按类别优先级 + 老化，跨会话公平。 */
+    nextQueuedIndex(now) {
+        const owners = this.readyOwners.length;
+        for (let n = 0; n < owners; n++) {
             const owner = this.readyOwners.shift();
-            const i = this.queue.findIndex((entry) => entry.owner === owner);
-            if (i >= 0) {
-                index = i;
-                // 找到后，若该会话仍有其它排队任务，保留其轮次避免单个会话饥饿。
-                if (this.queue.some((entry, j) => j !== i && entry.owner === owner))
+            let chosen = -1;
+            let chosenScore = Infinity;
+            for (let i = 0; i < this.queue.length; i++) {
+                const e = this.queue[i];
+                if (e.owner !== owner || !this.eligible(e, now))
+                    continue;
+                const score = this.effectivePriority(e, now);
+                if (score < chosenScore) {
+                    chosen = i;
+                    chosenScore = score;
+                }
+            }
+            if (chosen < 0) {
+                // 该会话暂时全部被舱壁/资源阻塞；保留轮次，等释放后重新争取。
+                if (this.queue.some((entry) => entry.owner === owner))
                     this.readyOwners.push(owner);
+                continue;
             }
+            if (this.queue.some((entry, i) => i !== chosen && entry.owner === owner))
+                this.readyOwners.push(owner);
+            return chosen;
         }
-        return index < 0 ? 0 : index;
+        return -1;
     }
     pump() {
-        while (!this.closed &&
-            this.running < this.options.concurrency &&
-            this.queue.length) {
-            const index = this.nextQueuedIndex();
+        while (!this.closed) {
+            const now = performance.now();
+            this.expireQueued(now);
+            if (this.running >= this.options.concurrency || this.queue.length === 0)
+                return;
+            const index = this.nextQueuedIndex(now);
+            if (index < 0)
+                return;
             const e = this.queue.splice(index, 1)[0];
             if (e.view.state !== "queued")
                 continue;
-            if (e.deadline !== undefined && performance.now() >= e.deadline) {
-                this.finish(e, "failed", undefined, "QUEUE_WAIT_TIMEOUT");
-                continue;
-            }
             if (e.queueTimer !== undefined) {
                 clearTimeout(e.queueTimer);
                 e.queueTimer = undefined;
             }
             e.startedAt = performance.now();
             this.running++;
+            this.runningByHandler.set(e.handler, (this.runningByHandler.get(e.handler) ?? 0) + 1);
+            for (const resource of e.resources)
+                this.resourceLocks.set(resource, e);
             e.view.state = "running";
             this.telemetry.record(e.trace, "started");
             this.emit(e, "started", {});
             void this.run(e).finally(() => {
                 this.running--;
+                const remaining = (this.runningByHandler.get(e.handler) ?? 1) - 1;
+                if (remaining > 0)
+                    this.runningByHandler.set(e.handler, remaining);
+                else
+                    this.runningByHandler.delete(e.handler);
                 this.pump();
             });
         }
@@ -545,6 +760,9 @@ export class ExecutionBus {
             await Promise.all(entries.map((e) => e.done));
             this.handlers.clear();
             this.entries.clear();
+            this.dedupeIndex.clear();
+            this.resourceLocks.clear();
+            this.runningByHandler.clear();
             this.retainedResultBytes = 0;
             this.queue = [];
             this.readyOwners = [];

package/dist/diagnostics.d.ts

@@ -1,4 +1,4 @@
-export type TraceStage = "accepted" | "started" | "cancel_requested" | "terminal" | "returned" | "job_created" | "job_released" | "job_error" | "reused";
+export type TraceStage = "accepted" | "started" | "cancel_requested" | "terminal" | "returned" | "job_created" | "job_released" | "job_error" | "reused" | "unique_reused";
 export interface Trace {
     operation: number;
     stage: TraceStage;
@@ -30,6 +30,7 @@ export declare class Diagnostics {
             job_released?: number | undefined;
             job_error?: number | undefined;
             reused?: number | undefined;
+            unique_reused?: number | undefined;
         };
         traces: {
             operation: number;

package/dist/error-codes.d.ts

@@ -38,6 +38,8 @@ export declare const ERRORS: Readonly<{
     INVALID_OPTIONS: "INVALID_OPTIONS";
     DUPLICATE_HANDLER: "DUPLICATE_HANDLER";
     MUTATING_REUSE_DENIED: "MUTATING_REUSE_DENIED";
+    INVALID_HANDLER_OPTIONS: "INVALID_HANDLER_OPTIONS";
+    INVALID_RESOURCES: "INVALID_RESOURCES";
     DUPLICATE_EXECUTION_HANDLE: "DUPLICATE_EXECUTION_HANDLE";
     INVALID_STATE_QUERY: "INVALID_STATE_QUERY";
     HOST_READ_FAILED: "HOST_READ_FAILED";

package/dist/error-codes.js

@@ -41,6 +41,8 @@ export const ERRORS = Object.freeze({
     INVALID_OPTIONS: "INVALID_OPTIONS",
     DUPLICATE_HANDLER: "DUPLICATE_HANDLER",
     MUTATING_REUSE_DENIED: "MUTATING_REUSE_DENIED",
+    INVALID_HANDLER_OPTIONS: "INVALID_HANDLER_OPTIONS",
+    INVALID_RESOURCES: "INVALID_RESOURCES",
     // —— 宿主投影（execution / plugin） ——
     DUPLICATE_EXECUTION_HANDLE: "DUPLICATE_EXECUTION_HANDLE",
     INVALID_STATE_QUERY: "INVALID_STATE_QUERY",

package/dist/execution.d.ts

@@ -49,6 +49,7 @@ export declare class ExecutionOwner {
             job_released?: number | undefined;
             job_error?: number | undefined;
             reused?: number | undefined;
+            unique_reused?: number | undefined;
         };
         traces: {
             operation: number;

package/dist/handlers.d.ts

@@ -5,9 +5,13 @@ export declare function hostToolHandler(toolName: string, opts: {
     idempotent: boolean;
     validate(input: Record<string, unknown>): void;
     prepare?(input: Record<string, unknown>): Record<string, unknown>;
+    queue?: string;
+    maxConcurrency?: number;
+    resources?(input: Record<string, unknown>): readonly string[];
+    dedupe?: "payload";
 }): Handler;
 export declare const testHandler: Handler;
-/** 读取：无副作用，幂等，终态结果可复用。 */
+/** 读取：无副作用，幂等，终态结果可复用；可按 payload 指纹做唯一任务。 */
 export declare const readHandler: Handler;
 /** 文件名搜索：只读，幂等，终态结果可复用；搜索基数由宿主工具限制。 */
 export declare const globHandler: Handler;

package/dist/handlers.js

@@ -8,6 +8,10 @@ export function hostToolHandler(toolName, opts) {
     void toolName;
     return {
         idempotent: opts.idempotent,
+        queue: opts.queue,
+        maxConcurrency: opts.maxConcurrency,
+        resources: opts.resources,
+        dedupe: opts.dedupe,
         validate: opts.validate,
         async run(input, ctx) {
             if (!ctx.invoke)
@@ -18,6 +22,7 @@ export function hostToolHandler(toolName, opts) {
 }
 export const testHandler = {
     idempotent: true,
+    queue: "diagnostic",
     validate(input) {
         if (Object.keys(input).some((k) => !["delayMs", "fail"].includes(k)) ||
             !Number.isSafeInteger(input.delayMs) ||
@@ -61,9 +66,15 @@ function validateEdit(input) {
         (input.replace_all !== undefined && typeof input.replace_all !== "boolean"))
         throw Error(ERRORS.INVALID_EDIT_INPUT);
 }
-/** 读取：无副作用，幂等，终态结果可复用。 */
+/** 同一路径的文件写入/编辑互斥；路径按调用原文作为资源键（不做跨平台归一化）。 */
+function fileResource(input) {
+    return ["file:" + String(input.file_path)];
+}
+/** 读取：无副作用，幂等，终态结果可复用；可按 payload 指纹做唯一任务。 */
 export const readHandler = hostToolHandler("read", {
     idempotent: true,
+    queue: "fs",
+    dedupe: "payload",
     validate: validateRead,
     prepare: (input) => ({
         ...input,
@@ -81,6 +92,8 @@ function validateGlob(input) {
 /** 文件名搜索：只读，幂等，终态结果可复用；搜索基数由宿主工具限制。 */
 export const globHandler = hostToolHandler("glob", {
     idempotent: true,
+    queue: "fs",
+    dedupe: "payload",
     validate: validateGlob,
 });
 function validateGrep(input) {
@@ -111,6 +124,8 @@ function validateGrep(input) {
 /** 内容搜索：只读，幂等，终态结果可复用；匹配上限由宿主工具限制。 */
 export const grepHandler = hostToolHandler("grep", {
     idempotent: true,
+    queue: "fs",
+    dedupe: "payload",
     validate: validateGrep,
 });
 function validateWrite(input) {
@@ -124,11 +139,15 @@ function validateWrite(input) {
 /** 写入：有副作用，非幂等，终态结果不可复用。 */
 export const writeHandler = hostToolHandler("write", {
     idempotent: false,
+    queue: "fs",
+    resources: fileResource,
     validate: validateWrite,
 });
 /** 编辑：有副作用，非幂等，终态结果不可复用。 */
 export const editHandler = hostToolHandler("edit", {
     idempotent: false,
+    queue: "fs",
+    resources: fileResource,
     validate: validateEdit,
 });
 /** 与宿主 pwsh 工具一致的提权目标；沙箱组合未提供提权面时由宿主拒绝。 */
@@ -170,5 +189,6 @@ function validatePwsh(input) {
 /** 命令执行：有副作用，非幂等，终态结果不可复用；后台模式返回 Job ID 不等于完成。 */
 export const pwshHandler = hostToolHandler("pwsh", {
     idempotent: false,
+    queue: "command",
     validate: validatePwsh,
 });

package/dist/product.d.ts

@@ -23,6 +23,12 @@ export declare const HANDLER_LIMITS: Readonly<{
     readPathChars: 2048;
     diagnosticDelayMs: 30000;
 }>;
+/** 调度策略：类别优先级 + 等待老化 + 长任务诊断阈值。 */
+export declare const SCHEDULER_POLICY: Readonly<{
+    longRunningMs: 30000;
+    queueAgingMs: 30000;
+    queueClassOrder: Readonly<Record<string, number>>;
+}>;
 export declare const REQUEST_PARAMETERS: {
     readonly oneOf: readonly [...{
         type: "object";

package/dist/product.js

@@ -23,6 +23,17 @@ export const HANDLER_LIMITS = Object.freeze({
     readPathChars: 2048,
     diagnosticDelayMs: 30000,
 });
+/** 调度策略：类别优先级 + 等待老化 + 长任务诊断阈值。 */
+export const SCHEDULER_POLICY = Object.freeze({
+    longRunningMs: 30000,
+    queueAgingMs: 30000,
+    queueClassOrder: Object.freeze({
+        fs: 0,
+        diagnostic: 1,
+        command: 2,
+        default: 3,
+    }),
+});
 /** 每个 Handler 的模型可见输入声明。只用于工具 schema/SDK 生成；运行时仍由 Handler.validate 严格校验。 */
 const INPUT_SCHEMAS = {
     test: {

package/dist/protocol.d.ts

@@ -24,6 +24,17 @@ export interface Handler {
     /** 是否可安全复用终态结果。省略默认 true（可复用，向后兼容）；
      *  显式 false = 有副作用，终态结果复用将被拒绝（运行中等待仍放行）。 */
     readonly idempotent?: boolean;
+    /** 调度队列类别；默认按 "default"。不同类别之间按类别优先级 + 等待老化排序，
+     *  避免长任务类独占出队顺序。 */
+    readonly queue?: string;
+    /** 同一 Handler 同时在跑的上限；省略表示只受全局并发限制（舱壁）。 */
+    readonly maxConcurrency?: number;
+    /** 可选资源键（如文件路径）：同键请求在总线内互斥，避免并发写同一资源。
+     *  由 Handler 在执行前从输入推导；返回空数组表示不占用资源。 */
+    resources?(input: Record<string, unknown>): readonly string[];
+    /** 唯一任务策略："payload" 表示幂等只读 Handler 可按 handler+input 指纹复用
+     *  已成功的终态结果（不同 requestId）；省略表示只按 requestId 去重。 */
+    readonly dedupe?: "payload";
     validate(input: Record<string, unknown>): void;
     run(input: Record<string, unknown>, ctx: {
         signal: AbortSignal;

package/docs/INTEGRATION.md

@@ -21,6 +21,33 @@
 | [cc-multi-process-mcp / 234823f1](https://github.com/L-x-C/cc-multi-process-mcp/tree/234823f15616d7e9c759072e940396d939f823c2) | main.py 的进程检测、信号回收、同步/异步执行、结果文件和清理路径 | 不引入自建进程池或轮询。源码的 skip_permissions 默认和 /tmp 存储不适合本插件宿主边界；未发现 LICENSE 文件，不复制代码 |
 
 这是相关路径的定向阅读，不是五仓全量逐文件安全审核。参考快照在开发目录，明确忽略，不进入源码提交或 npm 包。
+## 0.12.0 追加整合：调度隔离、资源互斥、唯一任务与属性测试
+
+本轮以 0.11.3 为基线，读取以下公开文档/README（2026-10-18，文档站点与仓库链接；未复制源码，未新增运行依赖），只采用与插件边界相符的机制：
+
+| 来源 | 实际阅读内容 | 采用与不采用 |
+|---|---|---|
+| [Temporal Workflow Id / Reuse Policy](https://docs.temporal.io/workflow-execution/workflowid-runid) | Workflow Id 唯一性、Run Id 区分、关闭后复用策略 | 参考“稳定逻辑编号 + 复用策略”分层；不引入持久化运行历史 |
+| [Restate 文档](https://docs.restate.dev/)（BUSL-1.1，仅文档） | exactly-once、按 scope 的并发/流量控制、virtual object 串行化 | 参考“按类别/资源隔离并发”；不复制代码，不引入其运行时 |
+| [DBOS 文档](https://docs.dbos.dev/) | durable queues、exactly-once、事务入队 | 仅对照边界；无持久化宿主契约，不实现 |
+| [Oban 文档](https://oban.hexdocs.pm/Oban.html)（Apache-2.0） | 队列独立并发上限、唯一任务、10 级优先级 | 实现 Handler.queue 类别 + 优先级 + 等待老化；不引入数据库/自动重试 |
+| [BullMQ README](https://github.com/taskforcesh/bullmq)（MIT） | priorities、concurrency、rate limiter、stalled jobs | 参考优先级/舱壁；不引入 Redis/停滞重排 |
+| [Resilience4j README](https://github.com/resilience4j/resilience4j)（Apache-2.0） | Bulkhead、TimeLimiter | 实现 Handler.maxConcurrency 舱壁；超时暂只做 longRunning 诊断 |
+| [fast-check](https://github.com/dubzzz/fast-check)（MIT，devDependency） | 属性测试 API | 新增随机序列不变量回归；仅开发依赖，不进入 tgz |
+
+本轮实现（0.12.0）：
+
+1. Handler 调度声明：queue、maxConcurrency、resources(input)、dedupe:"payload"；register 时校验。
+2. 调度：同会话内按类别优先级（fs < diagnostic < command < default）+ 等待老化（每 30 秒削平一级，最多两级）选择；跨会话仍按会话轮转；Handler.maxConcurrency 作为舱壁。
+3. 资源互斥：Handler.resources 返回稳定字符串键（host.edit/host.write 使用 file:<file_path>）；同一总线实例内同键串行，失败/取消/关闭释放；排队期限仍然有效。
+4. 唯一任务：幂等 Handler 声明 dedupe:"payload"（host.read/glob/grep）；同会话同 handler+payload 已有 succeeded 终态时，新 requestId 直接复用快照并带 reused:true；失败结果不缓存。
+5. 诊断：execution_bus_state 任务增加 longRunning（30 秒阈值）；waitReason 增加 resource。
+6. 测试：新增 8 项调度/唯一/资源回归、2 项 fast-check 属性回归与 2 项插件级 Handler 回归。
+
+不采用：Oban/BullMQ 的数据库/Redis 持久化、自动重试、停滞重排；Temporal/DBOS 的持久化执行与跨重启恢复（缺宿主契约）；Restate 源码（BUSL-1.1）。资源互斥仅在单个总线实例内有效，不是 OS 文件锁或跨进程保证。
+
+许可：本轮未复制第三方源码；fast-check 作为 devDependency 使用（MIT），不进入 tgz；Restate 文档仅作机制参考（BUSL-1.1）。
+
 
 ## 许可与实现归属
 

package/docs/PRODUCT.md

@@ -12,6 +12,8 @@
 
 0.11.0 根据 pilot 收紧为收益导向触发：重复提交/重试去重、预算结束后继续/跨步骤取回、多等待者同一执行才用总线，时长本身不是理由；新增简化调用（requestId+handler+input，messageId 自动生成）与控制（requestId+type），完整 v1 消息仍兼容；快照在复用时带 reused:true，并新增只读的会话采用率统计脚本。
 
+0.12.0 补充调度隔离：Handler 可声明调度类别、舱壁、资源键与 payload 唯一任务；内置写 Handler 按文件路径互斥，只读 Handler 的相同输入可在不同 requestId 间复用成功结果；状态快照增加 longRunning 与 resource 等待原因。参考来源与许可见 [整合说明](<INTEGRATION.md>)，未引入第三方运行依赖；fast-check 仅用于开发属性测试。
+
 ## 入口及配置层次
 
 | 入口 | 谁使用 | 责任 |

package/docs/protocol.md

@@ -110,7 +110,7 @@ core 不传配置时用默认值；显式配置必须完整包含 concurrency、
 
 期限使用单调时钟，计时器及出队前均检查，超期只将 queued 结算 failed / QUEUE_WAIT_TIMEOUT，不调用 Handler、不设置 cancelRequested、不重试，沿原 done/Job 返回。开始运行、取消或关闭时清除计时器。事件循环繁忙会令通知晚于期限，但不会让超期任务出队执行。已运行任务继续遵守原执行/取消规则。
 
-execution_bus_state 工具仅接受 {}，从宿主 Agent 取 sessionId，拒绝匿名或自报身份，关闭后拒绝查询。它读取 core inspect 的不可变快照，不创建 Job、不改变消息额度；查询会做正常终态 TTL 清理。不包含输入/输出，不访问其他会话。最多 50 条、活跃优先，其后按受理次序倒序列出终态；总数未截断，truncated 提示列表截断。元数据含 requestId、state、delivery、cancelRequested、固定 error/progress、waitReason、queueMs/runMs/remainingQueueMs。phase terminal 只表示执行终态且尚未标记返回，不代表可推断宿主 Job 清理进度。
+execution_bus_state 工具仅接受 {}，从宿主 Agent 取 sessionId，拒绝匿名或自报身份，关闭后拒绝查询。它读取 core inspect 的不可变快照，不创建 Job、不改变消息额度；查询会做正常终态 TTL 清理。不包含输入/输出，不访问其他会话。最多 50 条、活跃优先，其后按受理次序倒序列出终态；总数未截断，truncated 提示列表截断。元数据含 requestId、state、delivery、cancelRequested、固定 error/progress、waitReason（concurrency/dispatch/resource）、longRunning（运行超过 30 秒）、queueMs/runMs/remainingQueueMs。phase terminal 只表示执行终态且尚未标记返回，不代表可推断宿主 Job 清理进度。
 
 core inspect(trustedOwner) 要求非空 sessionId，但不提供鉴权，可信身份和访问控制属于嵌入宿主。勿把 core 的任意 owner 参数直接暴露给远端。状态不是持久审计/模型消费回执，不应循环调用。
 
@@ -128,4 +128,6 @@ core 实例的 `diagnostics()` 返回只读用途的独立快照：阶段计数
 
 0.11.0 起，模型可传简化输入：请求 `{requestId, handler, input, messageId?}`、控制 `{requestId, type, messageId?}`；插件在进入总线前补齐完整 v1 消息，完整 v1 消息仍被接受。返回快照在附着已有执行时追加可选 `reused:true`，只表示复用了逻辑执行，不代表外部副作用对账。
 
+0.12.0 扩展 Handler 可选声明：`queue`（调度类别，内置 fs/diagnostic/command）、`maxConcurrency`（同一 Handler 舱壁）、`resources(input)`（资源键串行）、`dedupe:"payload"`（幂等 Handler 的唯一任务复用）。调度和资源锁只在单个总线实例内生效；资源键是调用方提供的字符串，不是 OS 文件锁或跨进程保证。唯一任务只复用 succeeded 终态，失败/取消/unknown 不缓存；命中时返回快照带 `reused:true`，且不会再次执行 Handler。
+
 内置 test、host.read、host.glob 与 host.grep 没有副作用；host.edit、host.write 与 host.pwsh 是非幂等写/命令 Handler，通过 `Handler.idempotent=false` 显式声明，其终态结果复用被 `MUTATING_REUSE_DENIED` 拒绝，运行中的重复附着仍只等待同一执行。0.8.0 新增宿主工具输入错误码 INVALID_GLOB_INPUT、INVALID_GREP_INPUT 与 INVALID_PWSH_INPUT；协议既有错误码不改名。host.pwsh 的后台结果只是宿主 Job ID，不是完成回执。当前没有 ctx.executionBus 服务、远端传输、跨插件动态注册或外部副作用对账契约。扩展有副作用 Handler 前必须显式声明幂等并另行设计授权与崩溃对账，不能仅依赖本版请求键。

package/docs/releases/0.12.0.md

@@ -0,0 +1,20 @@
+# 萧何 / Xiao He 0.12.0
+
+## 调度隔离、资源互斥与唯一任务（开源机制整合）
+
+本版把一组调度/可靠性机制收敛进总线。参考来源、实际阅读范围与许可见 [整合说明](<../INTEGRATION.md>)；本轮未复制第三方源码、未新增运行依赖。
+
+- **Handler 调度声明**：新增可选 `queue`（类别）、`maxConcurrency`（舱壁）、`resources(input)`（资源键）、`dedupe:"payload"`（唯一任务）；注册时校验（`INVALID_HANDLER_OPTIONS`/`INVALID_RESOURCES`）。
+- **调度**：同会话内按类别优先级（fs < diagnostic < command < default）+ 等待老化（每 30 秒削平一级，最多两级）选择；跨会话仍按会话轮转；`maxConcurrency` 限制同一 Handler 并发。排队期限、取消、关闭与结果语义不变。
+- **资源互斥**：`host.edit`/`host.write` 以 `file:<file_path>` 为资源键，在同一总线实例内串行执行；失败/取消/关闭释放资源；排队期限继续生效。**不是 OS 文件锁或跨进程保证。**
+- **唯一任务**：`host.read`/`host.glob`/`host.grep` 声明 payload 去重；同会话同 handler+input 已有 `succeeded` 终态时，新 requestId 直接复用快照并返回 `reused:true`，不重复执行 Handler；失败/取消/unknown 不缓存。
+- **诊断**：`execution_bus_state` 任务增加 `longRunning`（运行超过 30 秒）；`waitReason` 增加 `resource`。
+- **开发验证**：新增 8 项调度/唯一/资源回归、2 项 fast-check 属性回归与 2 项插件级 Handler 回归；全量 **122** 项测试通过。fast-check 仅 devDependency（MIT），不进入 tgz。
+
+## 升级说明
+
+需要 DSH 0.2.1-rc.2。wire 协议与工具调用形状不变；新增能力只在 core/Handler 层，宿主预设、工具名与既有错误码不变。默认调度对内置 Handler 生效（类别优先级与文件互斥），如需完全旧行为应自行评估 effect。不自动安装、重写日常配置或重启 DSH。
+
+## 验证与限制
+
+本地全量 122 项测试通过；属性测试固定种子，不是穷尽证明。调度与资源锁只在单个总线实例内；跨会话/跨进程/OS 级互斥、外部副作用对账、持久化与自动重试均未实现。真实模型、桌面 UI 与实际沙箱仍未完整验收。

package/docs/validation.md

@@ -1,6 +1,6 @@
 # 验证范围与使用限制
 
-本文说明当前版本的证据边界，不是生产环境认证。当前能力基线为 **v0.11.3**，在 0.5.0 的会话准入/排队、0.7.0 的宿主工具转发、0.8.0 的搜索/命令 Handler、0.9.0 的预算分离等待与 0.10.0 的采用面改造上，收紧为收益导向触发并加入简化调用、复用标记与本地采用率统计；0.11.1 补充跨步骤取回姿势，0.11.3 补记收益导向 vs 总线优先的指引级 A/B 证据；预设沿用 v0.3.0 的宿主 PTC 声明派生方式。验证环境为 Windows、Node.js 24.21.0，宿主组件锁定 DSH 0.2.1-rc.2、Cordis 4.0.4。
+本文说明当前版本的证据边界，不是生产环境认证。当前能力基线为 **v0.12.0**，在 0.5.0 的会话准入/排队、0.7.0 的宿主工具转发、0.8.0 的搜索/命令 Handler、0.9.0 的预算分离等待与 0.10.0 的采用面改造上，收紧为收益导向触发并加入简化调用、复用标记与本地采用率统计；0.11.1 补充跨步骤取回姿势，0.11.3 补记指引级 A/B 证据，0.12.0 加入调度类别/舱壁/资源互斥/唯一任务与属性测试；预设沿用 v0.3.0 的宿主 PTC 声明派生方式。验证环境为 Windows、Node.js 24.21.0，宿主组件锁定 DSH 0.2.1-rc.2、Cordis 4.0.4。
 
 ## 已验证什么？
 
@@ -12,6 +12,8 @@
 | PTC 预算分离等待 | 真实 Node PTC `run_code` 以 2 秒预算等待 5 秒总线执行：预算到期后执行继续、宿主 Job 保留、同 requestId 取回结果；外部中断仍取消执行 | 在 DSH 0.2.1-rc.2 实际中断原因下成立；固定字符串不是跨版本契约 |
 | 简化调用与复用标记 | 简化请求/控制、完整 v1 消息兼容、终态与运行中复用返回 `reused:true`、非法形状拒绝 | 组件级测试确认；不改变 wire 语义与副作用边界 |
 | 采用策略 A/B（指引级） | 同一版本 0.11.2、同一模型、5 类任务各 5 个全新子会话：可选触发 vs 总线优先指引，统计总线调用/复用/耗时 | 指出可选触发更优（总线优先把一次性长命令也包装、并有约 19s 排队延迟）；非预设级、并发单机小样本，非统计显著 |
+| 调度隔离与资源互斥 | Handler queue/maxConcurrency/resources、类别优先级 + 等待老化、资源等待期限、waitReason/longRunning、唯一任务只复用 succeeded | 组件级回归确认；仅在单个总线实例内成立，不是 OS 锁或跨进程保证 |
+| 属性测试 | fast-check 随机提交/重放与容量压力不变量（固定种子） | 开发依赖（MIT）；随机覆盖不是穷尽验证，种子固定保证可复现 |
 | 预设隔离 | AgentPresetRegistry 与 Loader | 派生预设可激活；源 ptc 声明不变、普通 Agent 不可见总线；原 write/edit/Job 工具保留，宿主前置策略拒绝仍有效 |
 | 故障注入 | 克隆失败、观察者拒绝、Job 等待/清理异常、先行移除与卸载交错 | 指定故障下的回归约束；不证明所有故障组合都已覆盖 |
 | 候选包 | 严格文件白名单、临时目录生产依赖安装、入口注册 | 包可安装和加载；安装验证使用简化宿主夹具，不是桌面插件管理器验收 |
@@ -51,6 +53,7 @@ eb95b4e51675f5f1821275e0812ef4dd4984b1aba45a52fbc6bab3518bbf6f38
 | 从真实 tgz 经宿主插件管理器加载预设、卸载与回滚 | 未完成完整桌面流程；源码工作区的 Loader 测试不能替代 |
 | 真实 glob/grep/pwsh 工具实现 | 未在测试环境启用：真实搜索工具依赖打包 ripgrep 与 subprocess 服务，真实 pwsh 依赖 shell/sandbox/审批组合；本版只验证按 handler 名转发、输入校验、幂等分流与失败固定码 |
 | 跨版本 PTC 中断原因 | 分离等待只识别 DSH 0.2.1-rc.2 实际使用的固定中断原因字符串；宿主升级后未知原因保守按取消处理，需复核 |
+| 跨会话/跨进程资源互斥 | 未实现：资源键互斥只在单个总线实例内；不提供 OS 级文件锁，宿主插件总线作用域需按实际部署核对 |
 | 模式采用率与效果 | 已完成指引级 A/B（可选触发 vs 总线优先），但非预设级、并发单机小样本，不具统计显著性；轮次/耗时/成功率的大样本对照仍未完成，不能由 schema 或单元测试推断 |
 | 磁盘会话结果提交及重启恢复原调用 | 未验收磁盘提交；本插件不支持跨重启恢复 |
 | 减少真实模型轮次、状态查询或总耗时的对照 | 未验证，不给提升比例 |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feng0531/dsh-execution-bus",
-  "version": "0.11.3",
+  "version": "0.12.0",
   "type": "module",
   "private": false,
   "license": "SEE LICENSE IN LICENSE",
@@ -74,6 +74,7 @@
     "@deepseek-ai/dsh-tool-jobs": "0.2.1-rc.2",
     "@types/js-yaml": "4.0.9",
     "@types/node": "^22",
+    "fast-check": "^4.10.2",
     "prettier": "3.6.2",
     "typescript": "~5.9.3",
     "yaml": "2.9.1"