dsh-plugin-t-expert 0.3.84 → 0.3.89

package/lib/teams/harness-compat.js

@@ -1,561 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import { SubagentError } from '@deepseek-ai/dsh-subagent';
-/**
- * Exact protocol exported by dsh-subagent/internal in Alpha.5 and rc.1.
- * That subpath does not exist in Alpha.2, so importing it statically prevents
- * the plugin from loading there. This small adapter uses the same process-
- * stable symbol and call signature as upstream queueHostSubagentPrompt.
- * Source: packages/subagent/subagent/src/internal.ts at dsh-v0.1.2-rc.1.
- */
-const hostPromptQueue = Symbol.for('dsh.subagent.queuePrompt');
-// 0.1.5 keeps queueHostSubagentPrompt but replaces its symbol with this
-// delivery-mode-aware implementation (packages/subagent/subagent/src/internal.ts).
-const hostPromptDeliver = Symbol.for('dsh.subagent.deliverPrompt');
-/**
- * 全局共识符号（"约定俗成的键"）。
- *
- * 为什么默认就用它：上游**刻意**用 `Symbol.for`（全局符号注册表）而不是模块内 `Symbol()` ——
- * 同一个实现会同时存在于"打包过的运行时入口"与"未打包的 internal 子路径"两处，只有全局注册表
- * 才能让两边对上暗号（见上游 internal.ts 的注释）。所以我们按同一约定对接，不需要 import
- * 任何东西就能认得那两个键。
- *
- * 但它**不是权威**：符号串改了、或者上游换成非全局符号，这里就找不到了（B-1 会响亮拒绝）。
- * 权威在 `@deepseek-ai/dsh-subagent/internal` 的导出里，由 `resolveHarnessAuthority()` 动态取
- * （见该函数的说明）——这里只是它的**兜底默认值**。
- */
-const GLOBAL_SYMBOLS = { deliver: hostPromptDeliver, queue: hostPromptQueue };
-/**
- * 当前生效的符号键：默认是上面那两个全局符号，解析出权威符号后换成权威那份。
- * 所有读 `ctx.subagents[键]` 的地方都必须走 `routeKey()` / `activeSymbols`，不许再直接引用
- * 全局符号 —— 否则"换了键"只改了自检、运行期还按旧键找。
- */
-const activeSymbols = { ...GLOBAL_SYMBOLS };
-/** 路由 → 运行期真正要读的属性键（字符串方法名，或 symbol）。 */
-function routeKey(route) {
-    return route.symbol === undefined ? route.key : activeSymbols[route.symbol];
-}
-/** 路由 → 人类可读标签（符号路由现算，换了键时标签跟着变，不会说谎）。 */
-function routeLabel(route) {
-    return route.symbol === undefined ? route.label : `subagents[${String(activeSymbols[route.symbol])}]`;
-}
-/**
- * 宿主投递契约的**期望形状**（B-1/B-2）。
- *
- * 为什么要把"我们反推出来的口径"写成一张表：本文件对接的是**未文档化内部实现** ——
- * 上游改个形参个数、换个转发形态，TypeScript 看不见、tsc 也拦不住，症状只会是
- * "队长叫不醒成员"或"共享服务被按错的参数调用"。表在这里，运行期就能据此做签名断言，
- * 自检也拿它当单一真源（见 tools/verify.mjs 的 [13f] 与 [19] 的端到端那两条）。
- *
- * `arity` 两档，区别是**我们有多确信**：
- *   · 数字 = 内部符号函数（`Symbol.for(...)`），形参个数是逐字核对上游源码得到的。上游加必填
- *     参数、调整顺序、改转发形态都会让 `Function.length` 变 —— 那正是要被拦下来的。
- *   · null = 公开方法（`followup` / `sendMessage`）：名字是公开的，但实现允许少声明形参
- *     （短实现、转发实现、自检桩），所以只校验"可调用"，不校验个数。
- *
- * `role` 说明这条路能拿来干什么：`queue` 才是"宿主写给某个子代理的一轮"（FIFO 投递），
- * `steer` 是 steer 语义 —— **绝不能拿它顶替投递**（见 `queueMemberPrompt` 的说明）。
- */
-export const HARNESS_ROUTES = [
-    { key: 'followup', label: 'subagents.followup', arity: null, role: 'queue' },
-    { symbol: 'deliver', label: 'subagents[deliverPrompt symbol]', arity: 6, role: 'queue' },
-    { symbol: 'queue', label: 'subagents[queuePrompt symbol]', arity: 5, role: 'queue' },
-    { key: 'sendMessage', label: 'subagents.sendMessage', arity: null, role: 'steer' },
-];
-
-/**
- * 逐条路由的签名问题（空数组 = 形状与实测一致）。**只读**，不改任何东西、也不抛错。
- * @param runtime - `ctx.subagents` 服务对象。
- * @returns 人类可读的问题清单。
- */
-function deliverySignatureProblems(runtime) {
-    const problems = [];
-    for (const route of HARNESS_ROUTES) {
-        // 只对内部符号函数断言：公开方法的形参个数不是契约的一部分（见 HARNESS_ROUTES 的说明）。
-        if (route.arity === null)
-            continue;
-        const fn = runtime?.[routeKey(route)];
-        if (typeof fn !== 'function')
-            continue;
-        if (fn.length !== route.arity) {
-            problems.push(`${routeLabel(route)} declares ${fn.length} parameters, expected ${route.arity}`);
-        }
-    }
-    return problems;
-}
-function boundary(runtime) {
-    return runtime;
-}
-function unsupported(detail) {
-    throw new Error(`t-team: unsupported Harness subagent contract (${detail}); use an explicitly tested Harness version and a coherent dependency installation`);
-}
-/**
- * 这个兼容层**实测过**的 Harness 版本（A-1/E-1）。
- *
- * 为什么要写出来：`guardSubagentDelivery` 会覆写共享的 `ctx.subagents` 服务，用的两个
- * `Symbol.for` 与调用签名都来自**未文档化的上游内部实现**。上游一旦改动，症状是"团队功能
- * 突然不可用（引擎降级）"，没有这张表就只能靠猜。升级 Harness 后**必须**把这里改成
- * "已实测通过"再发布，未知版本会走 `unsupported()` 明确报错（而不是半死）。
- */
-export const TESTED_HARNESS_VERSIONS = ['0.1.5-rc.1', '0.1.5-rc.2'];
-/** 单个属性能否被安全覆写：可写数据属性、有 setter 的访问器，或对象可扩展时的新属性。 */
-function canAssign(object, key) {
-    const descriptor = Object.getOwnPropertyDescriptor(object, key);
-    if (descriptor === undefined)
-        return Object.isExtensible(object);
-    if ('value' in descriptor)
-        return descriptor.writable === true;
-    return typeof descriptor.set === 'function';
-}
-/** 覆写前先确认**每一个**目标属性都可写，否则响亮失败（避免 strict mode 下抛裸 TypeError）。 */
-function assertAssignable(object, keys) {
-    const blocked = keys.filter((key) => !canAssign(object, key));
-    if (blocked.length > 0) {
-        const names = blocked.map((key) => (typeof key === 'symbol' ? key.toString() : key)).join(', ');
-        return unsupported(`subagent service properties are not writable (${names}); upstream may have frozen or accessor-ized the service`);
-    }
-}
-/** Read child-owned history, excluding any descriptor inherited from a parent. */
-export function sessionOwnEvents(session) {
-    const current = session;
-    if (typeof current.ownEvents === 'function')
-        return current.ownEvents.call(session);
-    const legacy = session;
-    if (!Array.isArray(legacy.events))
-        return unsupported('missing ownEvents/legacy session log');
-    return legacy.events.slice(legacy.header.seedLength ?? 0);
-}
-/** Install before the first request, including cold resume, with HMR cleanup. */
-export function installContinuableMemberSetup(ctx, setup) {
-    const runtime = boundary(ctx.subagents);
-    if (typeof runtime.registerContinuableSetup === 'function') {
-        // Upstream owns this registration with this.ctx.effect. Cordis resolves
-        // that ctx to the accessing plugin, so its disposal revokes installations
-        // even while the subagents service and child Agents remain live.
-        runtime.registerContinuableSetup.call(ctx.subagents, (childCtx) => {
-            if (childCtx.agent === undefined)
-                return unsupported('legacy setup lacks child Agent');
-            return setup(childCtx, childCtx.agent);
-        });
-        return;
-    }
-    if ((typeof runtime[activeSymbols.queue] !== 'function' && typeof runtime[activeSymbols.deliver] !== 'function') || typeof runtime.sendMessage !== 'function') {
-        return unsupported('missing continuable setup and modern host queue');
-    }
-    const installed = new WeakSet();
-    const active = new Set();
-    ctx.effect(() => {
-        const stop = ctx.on('agent/session-start', ({ agent }) => {
-            if (installed.has(agent))
-                return;
-            // Deliberately synchronous: awaiting here loses the first-request race.
-            let teardown;
-            try {
-                teardown = setup(agent.ctx, agent);
-            }
-            catch (error) {
-                // session-start is a notification: Harness logs a thrown listener and
-                // still admits the first prompt. Reject request assembly explicitly so
-                // a malformed saved route cannot silently execute on a default model.
-                const failure = new Error(`t-team: member initialization failed: ${String(error)}`, { cause: error });
-                ctx.logger.warn(failure.message);
-                teardown = agent.ctx.on('agent/request', () => { throw failure; });
-            }
-            installed.add(agent);
-            let disposed = false;
-            const dispose = () => {
-                if (disposed)
-                    return;
-                disposed = true;
-                active.delete(dispose);
-                installed.delete(agent);
-                teardown();
-            };
-            active.add(dispose);
-            // Listeners contributed to agent.ctx already follow its lifetime. Also
-            // release our bookkeeping and remove them if this plugin is reloaded.
-            try {
-                agent.ctx.effect(() => dispose, 't-team: child compatibility setup');
-            }
-            catch (error) {
-                dispose();
-                throw error;
-            }
-        });
-        return () => {
-            stop();
-            for (const dispose of [...active])
-                dispose();
-        };
-    }, 't-team: member lifecycle compatibility');
-}
-/**
- * Queue a distinct host-authored turn; never substitute model-message steer.
- *
- * B-1：候选路由按 `HARNESS_ROUTES` 的顺序取第一条**形状对得上**的；内部符号函数的形参个数
- * 与实测不符时**直接跳过它**，而不是拿错的参数表去调 ——
- * 前者是"这条投递走不了（响亮）"，后者是"按错顺序调共享服务（静默）"，后者更糟。
- */
-export async function queueMemberPrompt(runtime, parent, childId, content, signal, retried = false) {
-    const host = boundary(runtime);
-    const source = { kind: 'plugin', plugin: 't-team' };
-    const skipped = [];
-    // ⓪ 官方适配函数优先：`@deepseek-ai/dsh-subagent/internal` 导出的 queueHostSubagentPrompt 就是
-    //    「投递给某个子代理一轮」的正式写法（上游内部也是 `runtime[deliverPrompt](…, 'queue')`）。
-    //    走它等于把**反推出来的调用形态**换成上游自己维护的那一份：上游改投递模式时，我们跟着受益。
-    //    前置条件与它自己一样：运行时上那个符号方法得在（否则它内部会 TypeError）。
-    const adapter = authorityState.adapter;
-    if (typeof adapter === 'function'
-        && typeof host[activeSymbols.deliver] === 'function'
-        && (authorityState.adapterArity === undefined || authorityState.adapterArity === HARNESS_ADAPTER_ARITY)) {
-        return adapter(host, parent, childId, content, source, signal);
-    }
-    for (const route of HARNESS_ROUTES) {
-        if (route.role !== 'queue')
-            continue;
-        const fn = host[routeKey(route)];
-        if (typeof fn !== 'function')
-            continue;
-        if (route.arity !== null && fn.length !== route.arity) {
-            skipped.push(`${routeLabel(route)} declares ${fn.length} parameters, expected ${route.arity}`);
-            continue;
-        }
-        // 公开的 `followup` 收 options 包；两个内部符号收扁平参数（deliver 还多一个投递模式）。
-        if (route.key === 'followup') {
-            return fn.call(runtime, parent, childId, content, { source, signal });
-        }
-        if (route.symbol === 'deliver') {
-            return fn.call(runtime, parent, childId, content, source, signal, 'queue');
-        }
-        return fn.call(runtime, parent, childId, content, source, signal);
-    }
-    // 都不可用：如果权威解析还没回来，**等它一次再重试**（投递是异步的，等得起）。
-    // 这一等救的是"符号口径变了、而首挂又早于解析完成"的窗口；只有失败路径才会走到这里。
-    if (!retried && !authorityState.settled) {
-        await resolveHarnessAuthority();
-        return queueMemberPrompt(runtime, parent, childId, content, signal, true);
-    }
-    return unsupported(skipped.length > 0
-        ? `no usable host FIFO delivery route (${skipped.join('; ')})`
-        : 'missing host FIFO delivery');
-}
-/** Guard all resumable delivery paths, preserving the native service receiver. */
-export function guardSubagentDelivery(ctx, isRetired) {
-    const runtime = ctx.subagents;
-    const host = boundary(runtime);
-    const legacy = host.followup;
-    const queue = host[activeSymbols.queue];
-    const deliver = host[activeSymbols.deliver];
-    const send = host.sendMessage;
-    if (typeof legacy !== 'function' && ((typeof queue !== 'function' && typeof deliver !== 'function') || typeof send !== 'function')) {
-        return unsupported('cannot install complete retired-member guard');
-    }
-    // B-1：**签名断言**，且刻意放在可写性探测之前 —— 先确认"我们理解这个函数"，再谈"能不能改它"。
-    //
-    // 为什么这里用**硬失败**（降级引擎）而不是像调用路径那样跳过：下面包的是**共享的**
-    // `ctx.subagents` 服务，四个入口一个不少地换成我们的包装。只要有一条路由的形参口径不明，
-    // 包装层就可能按错的参数顺序转发 —— 受害的不是"我们这一条投递"，而是所有走这个服务对象的
-    // 投递，而且完全静默。宁可这一刻响一声（引擎降级、原因进日志与提示段），也不装一个签名不明的守卫。
-    const signatureProblems = deliverySignatureProblems(host);
-    if (signatureProblems.length > 0) {
-        return unsupported(`undocumented delivery signature changed (${signatureProblems.join('; ')}); re-verify this adapter against the installed @deepseek-ai/dsh-subagent and extend TESTED_HARNESS_VERSIONS`);
-    }
-    // A-1/E-1：**先探测可写性再动手**。过去直接赋值，若上游把服务冻结（`Object.freeze`）
-    // 或改成只有 getter 的访问器，strict mode 下这里会抛一个与"版本不支持"毫无关系的裸
-    // TypeError；现在会得到明确原因。同时这也是一次"契约变了"的早期信号。
-    const targets = [
-        ...(typeof legacy === 'function' ? ['followup'] : []),
-        ...(typeof queue === 'function' ? [activeSymbols.queue] : []),
-        ...(typeof deliver === 'function' ? [activeSymbols.deliver] : []),
-        ...(typeof send === 'function' ? ['sendMessage'] : []),
-    ];
-    assertAssignable(host, targets);
-    ctx.effect(() => {
-        const descriptors = new Map([
-            ['followup', Object.getOwnPropertyDescriptor(host, 'followup')],
-            [activeSymbols.queue, Object.getOwnPropertyDescriptor(host, activeSymbols.queue)],
-            [activeSymbols.deliver, Object.getOwnPropertyDescriptor(host, activeSymbols.deliver)],
-            ['sendMessage', Object.getOwnPropertyDescriptor(host, 'sendMessage')],
-        ]);
-        let active = true;
-        const check = async (sender, targetId) => {
-            if (active && await isRetired(sender, targetId)) {
-                throw new SubagentError(`T Team member "${targetId}" was retired and cannot be resumed`, 'NOT_RESUMABLE');
-            }
-        };
-        const guardedLegacy = async (parent, childId, content, options) => {
-            await check(parent, childId);
-            return legacy.call(runtime, parent, childId, content, options);
-        };
-        const guardedQueue = async (parent, childId, content, source, signal) => {
-            await check(parent, childId);
-            return queue.call(runtime, parent, childId, content, source, signal);
-        };
-        const guardedSend = async (sender, targetId, content, options) => {
-            await check(sender, targetId);
-            return send.call(runtime, sender, targetId, content, options);
-        };
-        const guardedDeliver = async (parent, childId, content, source, signal, delivery) => {
-            await check(parent, childId);
-            return deliver.call(runtime, parent, childId, content, source, signal, delivery);
-        };
-        if (typeof legacy === 'function')
-            host.followup = guardedLegacy;
-        if (typeof queue === 'function')
-            host[activeSymbols.queue] = guardedQueue;
-        if (typeof deliver === 'function')
-            host[activeSymbols.deliver] = guardedDeliver;
-        if (typeof send === 'function')
-            host.sendMessage = guardedSend;
-        // Cordis wraps method reads in fresh Proxies. Compare the actual own
-        // descriptor to restore only our contribution, including prototype methods.
-        const restore = (key, installed) => {
-            if (Object.getOwnPropertyDescriptor(host, key)?.value !== installed)
-                return;
-            const original = descriptors.get(key);
-            if (original === undefined)
-                Reflect.deleteProperty(host, key);
-            else
-                Object.defineProperty(host, key, original);
-        };
-        return () => {
-            active = false;
-            if (typeof legacy === 'function')
-                restore('followup', guardedLegacy);
-            if (typeof queue === 'function')
-                restore(activeSymbols.queue, guardedQueue);
-            if (typeof deliver === 'function')
-                restore(activeSymbols.deliver, guardedDeliver);
-            if (typeof send === 'function')
-                restore('sendMessage', guardedSend);
-        };
-    }, 't-team: retired member guard');
-}
-
-// ---------------------------------------------------------------- B-3：权威契约解析（动态 import）
-
-const HARNESS_INTERNAL_SUBPATH = '@deepseek-ai/dsh-subagent/internal';
-/**
- * `queueHostSubagentPrompt(runtime, parent, childId, content, source, signal)` 的形参个数（6）。
- * 与 HARNESS_ROUTES 的 arity 同一性质：逐字核对上游导出面得到的；对不上就不用它（见下）。
- */
-const HARNESS_ADAPTER_ARITY = 6;
-/**
- * 权威契约的当前状态（`resolveHarnessAuthority()` 的落点）。
- * 初值 = "还没解析"：一切按全局共识符号走（见 GLOBAL_SYMBOLS）。
- */
-let authorityState = { settled: false, ok: false, changed: false, adapter: undefined, adapterArity: undefined, error: '' };
-let authorityPromise;
-const defaultImporter = (specifier) => import(specifier);
-/**
- * 解析宿主 `@deepseek-ai/dsh-subagent/internal` 这个**未文档化但已导出**的子路径，拿到两样东西：
- *   · `deliverSubagentPrompt` —— 权威的投递符号（我们按 `Symbol.for` 猜的那个键的**真身**）；
- *   · `queueHostSubagentPrompt` —— 官方适配函数（上游自己就是 `runtime[deliverPrompt](…, 'queue')`）。
- *
- * 为什么用动态而不是静态 import：那个子路径在 Alpha.2 上**不存在**，静态 import 会让插件在那些
- * 版本上整个加载不起来（见文件顶部说明）。动态 import 失败只是少一条兜底路径，不影响加载。
- *
- * 为什么值得做：全局符号是"约定"，这个子路径是"**导出面**"（带类型声明）。上游把符号串改掉、
- * 或换成非全局符号时，全局符号就找不到了 —— B-1 会因此响亮拒绝装守卫、引擎降级；而这里能拿到
- * 真身，于是还能continue工作：`activeSymbols` 就地更换，所有读取点自动跟着走。
- *
- * 失败语义：解析不到（老宿主 / 安装树取不到 / 导出面变了）**不算错误** —— 退回全局共识符号，
- * 报告里如实写 `authority.error`，绝不猜。
- *
- * @param options - `importer` 可注入解析器。自检用它喂一个"换了键"的假模块来验证这条路径，
- *   验完再喂回默认解析器还原（见 tools/verify.mjs 的 [13g]）。
- * @returns 权威契约报告 `{ ok, deliver, adapter, adapterArity, changed, error }`。
- */
-export function resolveHarnessAuthority(options = {}) {
-    const injected = typeof options.importer === 'function' ? options.importer : undefined;
-    if (injected !== undefined)
-        return loadHarnessAuthority(injected).then(applyHarnessAuthority);
-    return (authorityPromise ??= loadHarnessAuthority(defaultImporter).then(applyHarnessAuthority));
-}
-async function loadHarnessAuthority(importer) {
-    const report = { ok: false, deliver: undefined, adapter: undefined, adapterArity: undefined, changed: false, error: '' };
-    try {
-        const mod = await importer(HARNESS_INTERNAL_SUBPATH);
-        const deliver = mod?.deliverSubagentPrompt;
-        if (typeof deliver === 'symbol') {
-            report.ok = true;
-            report.deliver = deliver;
-            // "换了键"= 权威符号与全局共识符号不是同一个对象（rc.1/rc.2 上两者相等，什么都不用变）。
-            report.changed = deliver !== GLOBAL_SYMBOLS.deliver;
-        }
-        if (typeof mod?.queueHostSubagentPrompt === 'function') {
-            report.adapter = mod.queueHostSubagentPrompt;
-            report.adapterArity = mod.queueHostSubagentPrompt.length;
-        }
-        if (!report.ok)
-            report.error = 'internal subpath resolved but exports no delivery symbol';
-    }
-    catch (error) {
-        report.error = error instanceof Error ? error.message : String(error);
-    }
-    return report;
-}
-/** 把解析结果落到模块状态（`activeSymbols.deliver` / `authorityState`）。 */
-function applyHarnessAuthority(report) {
-    authorityState = {
-        settled: true,
-        ok: report.ok,
-        changed: report.changed,
-        adapter: report.adapter,
-        adapterArity: report.adapterArity,
-        error: report.error,
-    };
-    if (report.ok)
-        activeSymbols.deliver = report.deliver;
-    return report;
-}
-
-// ---------------------------------------------------------------- B-2：运行期软闸门
-
-const HARNESS_PACKAGE = '@deepseek-ai/dsh-subagent';
-/** 版本探测结果缓存（一份安装在一个进程里不会变；解析不到就记空串，绝不重试、也绝不猜）。 */
-let detectedVersion;
-/**
- * 读宿主 `@deepseek-ai/dsh-subagent` 的版本（best-effort；读不到返回空串）。
- *
- * 为什么读它：本文件对接的是**未文档化内部实现**，实测矩阵只能人工维护（见
- * `TESTED_HARNESS_VERSIONS`）。把"宿主到底是哪一版"记下来，出问题时才能一句话说清是不是
- * 版本没在矩阵里，而不是让维护者从 `deliverPrompt` 的形参个数往回猜。
- *
- * 用**本文件自己的位置**做解析基准（`createRequire(import.meta.url)`）：这个文件既然能静态
- * import 到 `@deepseek-ai/dsh-subagent`，就一定能 resolve 到它的 `package.json`。解析失败不算
- * 错误（某些封装安装树里可能取不到），报告里会写 `version: ''`，由形状探测兜底。
- * @returns 形如 `0.1.5-rc.2` 的版本串，或空串。
- */
-function detectHarnessVersion() {
-    if (detectedVersion !== undefined)
-        return detectedVersion;
-    detectedVersion = '';
-    try {
-        const require = createRequire(import.meta.url);
-        const manifest = JSON.parse(readFileSync(require.resolve(`${HARNESS_PACKAGE}/package.json`), 'utf8'));
-        if (typeof manifest?.version === 'string')
-            detectedVersion = manifest.version;
-    }
-    catch {
-        /* 读不到就只按形状判断；报告里的 reason 会如实写 version-unknown */
-    }
-    return detectedVersion;
-}
-/** 当前会真正被 `queueMemberPrompt` 用的那条投递路由（没有可用路由时返回 `none`）。 */
-function usableDeliveryRoute(runtime) {
-    const adapter = authorityState.adapter;
-    if (typeof adapter === 'function' && typeof runtime?.[activeSymbols.deliver] === 'function') {
-        return `@deepseek-ai/dsh-subagent/internal queueHostSubagentPrompt`;
-    }
-    for (const route of HARNESS_ROUTES) {
-        if (route.role !== 'queue')
-            continue;
-        const fn = runtime?.[routeKey(route)];
-        if (typeof fn !== 'function')
-            continue;
-        if (route.arity !== null && fn.length !== route.arity)
-            continue;
-        return routeLabel(route);
-    }
-    return 'none';
-}
-/**
- * 宿主 subagent 契约体检（B-2 的探测半边）—— **纯读、绝不抛错**：它是诊断，不是门禁。
- *
- * 和 B-1 的分工：B-1 是"装守卫那一刻的硬断言"（签名不符就不装，见 `guardSubagentDelivery`），
- * 这里则给"引擎一切正常、但宿主是未实测版本"这种**没有症状的状态**留一个可读的结论 ——
- * 上游改契约最常见的结局不是立刻崩，而是某天"队长叫不醒成员"，那时只有这条结论能解释原因。
- *
- * @param ctx - 插件上下文（只读 `ctx.subagents`；服务缺席也算一种结果，不抛错）。
- * @param options - `version` 可覆盖版本探测（自检用：用确定的值验证判定规则，不依赖本机装了什么）。
- * @returns 契约报告：`version` / `tested` / `reason` / `drift` / `route` / `routes` / `signature`。
- */
-export function probeHarnessContract(ctx, options = {}) {
-    const runtime = ctx?.subagents;
-    const routes = HARNESS_ROUTES.map((route) => {
-        const fn = runtime?.[routeKey(route)];
-        const present = typeof fn === 'function';
-        return {
-            label: routeLabel(route),
-            role: route.role,
-            present,
-            arity: present ? fn.length : undefined,
-            expected: route.arity === null ? undefined : route.arity,
-            ok: present && (route.arity === null || fn.length === route.arity),
-        };
-    });
-    const drift = [...deliverySignatureProblems(runtime)];
-    // 官方适配函数也是契约的一部分：形参个数对不上就**不用它**（调用路径见 queueMemberPrompt），
-    // 并且要出现在报告里 —— 否则"我们悄悄退回了自己拼参数的调用形态"这件事没人知道。
-    if (typeof authorityState.adapter === 'function'
-        && authorityState.adapterArity !== undefined
-        && authorityState.adapterArity !== HARNESS_ADAPTER_ARITY) {
-        drift.push(`${HARNESS_INTERNAL_SUBPATH} queueHostSubagentPrompt declares ${authorityState.adapterArity} parameters, expected ${HARNESS_ADAPTER_ARITY}`);
-    }
-    const version = typeof options.version === 'string' ? options.version : detectHarnessVersion();
-    const reason = drift.length > 0
-        ? 'contract-drift'
-        : authorityState.changed
-            ? 'symbol-renamed'
-            : version === ''
-                ? 'version-unknown'
-                : TESTED_HARNESS_VERSIONS.includes(version) ? '' : 'untested-version';
-    return {
-        version,
-        tested: reason === '',
-        reason,
-        drift,
-        route: usableDeliveryRoute(runtime),
-        // 权威解析（B-3）的状态：`changed` 为真表示宿主的投递符号**换了口径**、已自动改用真身。
-        authority: {
-            settled: authorityState.settled,
-            ok: authorityState.ok,
-            changed: authorityState.changed,
-            adapter: typeof authorityState.adapter === 'function',
-            error: authorityState.error,
-        },
-        routes,
-        signature: `${version}|${reason}|${drift.join('; ')}`,
-    };
-}
-/**
- * 契约报告 → 一句**可执行**的诊断（供日志与提示段共用）。
- * @param report - `probeHarnessContract()` 的结果。
- * @returns 英文单行描述（与 `unsupported()` 的消息同语言，日志里成一条线）。
- */
-export function harnessContractWarning(report) {
-    const where = report.route === 'none' ? 'no usable delivery route' : `delivery goes through ${report.route}`;
-    if (report.reason === 'contract-drift') {
-        return `subagent contract drifted from the tested shape (${report.drift.join('; ')}); ${where}. Waking members / blocking retired members can now misbehave — re-verify lib/teams/harness-compat.js against the installed @deepseek-ai/dsh-subagent and extend TESTED_HARNESS_VERSIONS.`;
-    }
-    if (report.reason === 'symbol-renamed') {
-        return `@deepseek-ai/dsh-subagent no longer keys host delivery with the documented global symbol; switched to the authoritative symbol exported by ${HARNESS_INTERNAL_SUBPATH} (${where}). Team features keep working — re-verify this adapter against the installed host and extend TESTED_HARNESS_VERSIONS so the switch stops being silent.`;
-    }
-    if (report.reason === 'version-unknown') {
-        return `could not resolve the installed @deepseek-ai/dsh-subagent version; shape matches the tested contract, ${where}. If team features misbehave after a Harness upgrade, check this line first.`;
-    }
-    return `@deepseek-ai/dsh-subagent ${report.version} is not in the tested matrix (${TESTED_HARNESS_VERSIONS.join(' / ')}); shape matches the tested contract, ${where}. Team features run on a best-effort contract — re-verify and extend TESTED_HARNESS_VERSIONS.`;
-}
-/** 已经报过的契约签名：同一份签名只报一次，避免每次挂载/热重载都刷同一条日志。 */
-const reportedContracts = new Set();
-/**
- * 体检 + **同签名只报一次**的告警（B-2 的出声半边）。
- *
- * 为什么按签名去重而不是"一个布尔量只报一次"：宿主换了版本、或形状变了，`signature` 就变了 ——
- * 那是一次**新的**事实，必须再出声（"报过一次就永远闭嘴"正是要避免的另一种静默）。
- * 已实测（版本在矩阵内且无漂移）时**完全不出声**：常态不该占日志，也不该占提示词预算。
- *
- * @param ctx - 插件上下文。
- * @param logger - 宿主 logger（缺席时静默降级 —— 不写 console：桌面/Web 里 console 无人可见）。
- * @param options - 同 `probeHarnessContract`。
- * @returns 契约报告（调用方可以直接拿去渲染状态行）。
- */
-export function reportHarnessContract(ctx, logger, options = {}) {
-    const report = probeHarnessContract(ctx, options);
-    if (report.tested || reportedContracts.has(report.signature))
-        return report;
-    reportedContracts.add(report.signature);
-    logger?.warn?.(`[t-team] ${harnessContractWarning(report)}`);
-    return report;
-}