@furongjun1999/dsh-memory 0.2.9 → 0.3.1

package/lib/llm_adapter.d.ts

@@ -0,0 +1,123 @@
+/**
+ * llm_adapter.ts —— 白箱 LLM 服务商（WhiteboxLlmAdapter）
+ *
+ * 设计哲学：白箱本身就是 LLM 模型（对外完全对齐 dsh-llm 协议），内部白箱化。
+ *  - provider: 'lingshu-whitebox'（设置页「模型」可见，可被 agent 默认选用）
+ *  - stream(): 调灵枢 wisdom_chat（白箱 CCG 条件路由/组合生成/自校验）
+ *  - token 计数：输入/输出/缓存命中（白箱直答 = 全部 cacheRead，零推理成本）
+ *  - 降级：白箱无把握（route=llm / 桥未就绪）→ 可选 fallback（后续接 deepseek）
+ *
+ * 结构仿官方 @deepseek-ai/dsh-llm-deepseek adapter。
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { LingshuBridge } from './bridge.js';
+export interface LlmStreamChunk {
+    type: 'block-start' | 'text-delta' | 'reasoning-delta' | 'tool-call-delta' | 'block-end' | 'usage' | 'finish';
+    index?: number;
+    blockType?: string;
+    text?: string;
+    id?: string;
+    name?: string;
+    argumentsDelta?: string;
+    block?: {
+        type: string;
+        text?: string;
+        [k: string]: unknown;
+    };
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        cacheReadTokens?: number;
+        cacheWriteTokens?: number;
+    };
+    reason?: string;
+    replayState?: unknown;
+}
+export interface LlmGenerateOptions {
+    provider: string;
+    model: string;
+    reasoningEffort?: string;
+    messages: Array<{
+        role: string;
+        content?: Array<{
+            type?: string;
+            text?: string;
+            arguments?: string;
+            [k: string]: unknown;
+        }>;
+    }>;
+    system?: string;
+    tools?: Array<{
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    }>;
+    temperature?: number;
+    maxTokens?: number;
+    stop?: string[];
+    signal?: AbortSignal;
+    sessionId?: string;
+    purpose?: 'compaction' | 'session-title';
+}
+export declare function estimateTokens(text: string | undefined | null): number;
+/** 从 GenerateOptions 汇总输入 token（system + messages 全部文本）。 */
+export declare function countInputTokens(options: LlmGenerateOptions): number;
+/** 把 DSH 会话消息折叠成白箱可读的对话文本。 */
+export declare function serializeMessages(options: LlmGenerateOptions): string;
+/** 把一段完整文本包装成协议流（确定性整段生成 → 单次流）。 */
+export declare function wrapTextStream(text: string, inputTokens: number, outputTokens: number, cacheReadTokens: number): AsyncIterable<LlmStreamChunk>;
+/**
+ * 白箱知识卡片格式检测：REVERSE_DAILY 直答是知识库内部格式——
+ * 「X是什么…，是『A』vs『B』的矛盾——X（是…（…（…）…）…真相：①…」
+ * 特征（任一强信号命中即判定）：
+ * ① 卡片开头句式：内容含「，是『X』vs『Y』的矛盾——」（矛盾标记+破折号）
+ * ② 「真相：」结构化标记（卡片分段标题）+ 括号密集（>8）
+ * ③ 长文本（>300）+ 高括号密度（>20）+ 无自然语言标点分隔（顿号密集）
+ */
+export declare function isCardFormat(text: string): boolean;
+/** 白箱 adapter 依赖注入。 */
+export interface WhiteboxAdapterDeps {
+    /** 灵枢桥（MCP stdio）——白箱引擎通道。 */
+    bridge?: LingshuBridge;
+    /**
+     * 降级 LLM：白箱未命中（route=llm / 桥未就绪）时转发。由 installWhiteboxLlm
+     * 注入 DSH 的 llm 服务（走 fallbackProvider 路由），实现「白箱优先 + LLM 降级」。
+     */
+    fallback?: {
+        stream(o: LlmGenerateOptions): AsyncIterable<LlmStreamChunk>;
+    };
+}
+/** 白箱 LLM adapter —— 注册为 DSH 的 provider。 */
+export declare class WhiteboxLlmAdapter {
+    private readonly bridge?;
+    private readonly fallback?;
+    constructor(deps?: WhiteboxAdapterDeps);
+    providerInfo(provider: string): {
+        id: string;
+        name: string;
+    };
+    providerRetryPolicy(): undefined;
+    listModels(): Promise<Array<{
+        provider: string;
+        id: string;
+        name: string;
+    }>>;
+    resolveModel(provider: string, model: string): Promise<{
+        provider: string;
+        id: string;
+        name: string;
+    }>;
+    /**
+     * 核心：一次模型调用。白箱优先，无把握降级。
+     * @param options 完全装配的请求（必须 honor options.signal）
+     */
+    stream(options: LlmGenerateOptions): AsyncIterable<LlmStreamChunk>;
+}
+/** provider 路由名（设置页「模型」下拉可见）。 */
+export declare const WHITEBOX_PROVIDER = "lingshu-whitebox";
+/**
+ * 注册白箱 provider 到 DSH llm 服务（动态检测，不强依赖 llm 服务——
+ * 最小 host 无 llm 时跳过，插件其余功能不受影响）。
+ * @returns 注销函数；未注册返回 noop。
+ */
+export declare function installWhiteboxLlm(ctx: Context, bridge: LingshuBridge | undefined): () => void;

package/lib/llm_adapter.js

@@ -0,0 +1,243 @@
+/**
+ * llm_adapter.ts —— 白箱 LLM 服务商（WhiteboxLlmAdapter）
+ *
+ * 设计哲学：白箱本身就是 LLM 模型（对外完全对齐 dsh-llm 协议），内部白箱化。
+ *  - provider: 'lingshu-whitebox'（设置页「模型」可见，可被 agent 默认选用）
+ *  - stream(): 调灵枢 wisdom_chat（白箱 CCG 条件路由/组合生成/自校验）
+ *  - token 计数：输入/输出/缓存命中（白箱直答 = 全部 cacheRead，零推理成本）
+ *  - 降级：白箱无把握（route=llm / 桥未就绪）→ 可选 fallback（后续接 deepseek）
+ *
+ * 结构仿官方 @deepseek-ai/dsh-llm-deepseek adapter。
+ */
+// ---- token 估算（确定性启发式：CJK 0.6/字符，其余 /4）----
+export function estimateTokens(text) {
+    if (!text)
+        return 0;
+    let cjk = 0;
+    let other = 0;
+    for (const ch of text) {
+        const code = ch.codePointAt(0);
+        if ((code >= 0x4e00 && code <= 0x9fff) || (code >= 0x3040 && code <= 0x30ff))
+            cjk++;
+        else
+            other++;
+    }
+    return Math.ceil(cjk * 0.6 + other / 4);
+}
+/** 从 GenerateOptions 汇总输入 token（system + messages 全部文本）。 */
+export function countInputTokens(options) {
+    let total = 0;
+    if (options.system)
+        total += estimateTokens(options.system);
+    for (const msg of options.messages ?? []) {
+        for (const block of msg.content ?? []) {
+            if (typeof block?.text === 'string')
+                total += estimateTokens(block.text);
+            if (typeof block?.arguments === 'string')
+                total += estimateTokens(block.arguments);
+        }
+    }
+    return total;
+}
+/** 把 DSH 会话消息折叠成白箱可读的对话文本。 */
+export function serializeMessages(options) {
+    const parts = [];
+    if (options.system)
+        parts.push(`[系统] ${options.system}`);
+    for (const msg of options.messages ?? []) {
+        const text = (msg.content ?? [])
+            .filter((b) => b?.type === 'text' && typeof b.text === 'string')
+            .map((b) => b.text)
+            .join('');
+        if (!text)
+            continue;
+        const role = msg.role === 'assistant' ? '灵枢' : msg.role === 'user' ? '用户' : msg.role;
+        parts.push(`[${role}] ${text}`);
+    }
+    return parts.join('\n');
+}
+/** 把一段完整文本包装成协议流（确定性整段生成 → 单次流）。 */
+export async function* wrapTextStream(text, inputTokens, outputTokens, cacheReadTokens) {
+    yield { type: 'block-start', index: 0, blockType: 'text' };
+    yield { type: 'text-delta', index: 0, text };
+    yield { type: 'block-end', index: 0, block: { type: 'text', text } };
+    yield {
+        type: 'usage',
+        usage: {
+            inputTokens,
+            outputTokens,
+            ...(cacheReadTokens > 0 ? { cacheReadTokens } : {}),
+        },
+    };
+    yield { type: 'finish', reason: 'stop' };
+}
+/**
+ * 白箱知识卡片格式检测：REVERSE_DAILY 直答是知识库内部格式——
+ * 「X是什么…，是『A』vs『B』的矛盾——X（是…（…（…）…）…真相：①…」
+ * 特征（任一强信号命中即判定）：
+ * ① 卡片开头句式：内容含「，是『X』vs『Y』的矛盾——」（矛盾标记+破折号）
+ * ② 「真相：」结构化标记（卡片分段标题）+ 括号密集（>8）
+ * ③ 长文本（>300）+ 高括号密度（>20）+ 无自然语言标点分隔（顿号密集）
+ */
+export function isCardFormat(text) {
+    if (!text)
+        return false;
+    // ① 强信号：矛盾标记句式（「，是『A』vs『B』的矛盾——」）——卡片开头的
+    //    标志性结构，不受长度门槛限制（短卡片也判定）
+    if (/，是『[^』]{1,12}』vs『[^』]{1,12}』的矛盾[——\-]/.test(text))
+        return true;
+    // 短文本（<150）无矛盾标记 → 正常文本
+    if (text.length < 150)
+        return false;
+    // ② 「真相：」+ 括号密集（卡片的分段结构）
+    if (text.includes('真相：')) {
+        const parens = (text.match(/（/g) ?? []).length;
+        if (parens >= 8)
+            return true;
+    }
+    // ③ 超长 + 极高括号密度（卡片展开体）
+    const parens2 = (text.match(/（/g) ?? []).length;
+    if (text.length > 300 && parens2 > 20)
+        return true;
+    return false;
+}
+/** 白箱 LLM adapter —— 注册为 DSH 的 provider。 */
+export class WhiteboxLlmAdapter {
+    bridge;
+    fallback;
+    constructor(deps = {}) {
+        this.bridge = deps.bridge;
+        this.fallback = deps.fallback;
+    }
+    providerInfo(provider) {
+        return { id: provider, name: '白箱灵枢 (lingshu-whitebox)' };
+    }
+    providerRetryPolicy() {
+        return undefined;
+    }
+    async listModels() {
+        return [
+            { provider: 'lingshu-whitebox', id: 'whitebox-v1', name: '白箱引擎 v1 (CCG 条件路由)' },
+            { provider: 'lingshu-whitebox', id: 'whitebox-wisdom', name: '白箱智慧之书' },
+        ];
+    }
+    async resolveModel(provider, model) {
+        return { provider, id: model, name: model };
+    }
+    /**
+     * 核心：一次模型调用。白箱优先，无把握降级。
+     * @param options 完全装配的请求（必须 honor options.signal）
+     */
+    async *stream(options) {
+        const inputTokens = countInputTokens(options);
+        const conversation = serializeMessages(options);
+        // 取最后一条用户文本作为白箱输入（完整对话太长时截尾）
+        const lastUserText = [...(options.messages ?? [])]
+            .reverse()
+            .flatMap((m) => m.content ?? [])
+            .filter((b) => b?.type === 'text')
+            .map((b) => b.text)
+            .join('')
+            .slice(-2000);
+        // ---- 白箱主路径：调灵枢 wisdom_chat ----
+        let whitebox = null;
+        if (this.bridge?.isReady?.()) {
+            try {
+                const r = await this.bridge.callTool('wisdom_chat', {
+                    message: lastUserText || conversation.slice(-4000),
+                    session_id: options.sessionId ?? 'default',
+                }, options.signal);
+                const raw = (r?.content ?? []).map((c) => c.text ?? '').join('\n');
+                // 白箱返回结构：{"reply": "...", "route": "self|llm", "hits": [...], "honest": bool}
+                let text = raw;
+                let route = 'self';
+                try {
+                    const parsed = JSON.parse(raw);
+                    if (parsed.route)
+                        route = parsed.route;
+                    if (typeof parsed.reply === 'string')
+                        text = parsed.reply;
+                    else if (parsed.reply !== undefined)
+                        text = JSON.stringify(parsed.reply);
+                }
+                catch { /* 非 JSON = 纯文本回复 */ }
+                // 质量门槛（v0.4.1）：REVERSE_DAILY 卡片直答是知识库内部格式——
+                // 「X是什么…是『A』vs『B』的矛盾——X（是…（…）」重复+括号嵌套，
+                // 直接当 LLM 输出喂给用户=「重复回答」。检测到卡片特征 → 视为
+                // 未命中，走降级 LLM（白箱不输出内部格式垃圾）。
+                if (route !== 'llm' && text && text.trim() && !isCardFormat(text)) {
+                    whitebox = { text: text.trim(), route };
+                }
+                else if (text && isCardFormat(text)) {
+                    console.warn('[whitebox-llm] 白箱返回知识卡片格式，降级 LLM（内部格式不直出）');
+                }
+            }
+            catch (err) {
+                // 白箱异常不阻塞——记日志后走降级
+                console.warn('[whitebox-llm] 白箱调用失败，降级:', String(err));
+            }
+        }
+        if (whitebox) {
+            const outputTokens = estimateTokens(whitebox.text);
+            // 白箱直答 = 全缓存命中（条件路由固化命中，零推理成本）
+            yield* wrapTextStream(whitebox.text, inputTokens, outputTokens, inputTokens);
+            return;
+        }
+        // ---- 降级路径：白箱无把握 / 桥未就绪 ----
+        if (this.fallback) {
+            console.warn('[whitebox-llm] 白箱未命中，转降级 LLM');
+            yield* this.fallback.stream(options);
+            return;
+        }
+        // 无降级可用：诚实声明（盲区 28：未来承诺不可检验——不假装回答）
+        const honest = '（白箱引擎未命中且降级 LLM 未配置——按白箱纪律，我诚实声明不知道，不编造答案。）';
+        yield* wrapTextStream(honest, inputTokens, estimateTokens(honest), 0);
+    }
+}
+/** provider 路由名（设置页「模型」下拉可见）。 */
+export const WHITEBOX_PROVIDER = 'lingshu-whitebox';
+/**
+ * 注册白箱 provider 到 DSH llm 服务（动态检测，不强依赖 llm 服务——
+ * 最小 host 无 llm 时跳过，插件其余功能不受影响）。
+ * @returns 注销函数；未注册返回 noop。
+ */
+export function installWhiteboxLlm(ctx, bridge) {
+    // 动态检测 llm 服务（P1 模式：timer/webServer 同理）。
+    // 注意：不能直接读 ctx.llm——Cordis 未声明 inject 的属性访问会抛
+    // "cannot get property without inject"；ctx.get('llm') 安全返回 undefined。
+    const llm = ctx.get('llm');
+    if (!llm?.registerAdapter) {
+        ctx.logger?.info?.('dsh-memory: llm 服务不可用，跳过白箱 provider 注册（最小 host）');
+        return () => { };
+    }
+    // 降级 LLM：白箱未命中时转发给 fallbackProvider 路由（默认 deepseek-official，
+    // 可在 settings.yaml 的 llm-whitebox.fallbackProvider 覆盖）。通过 llm.stream
+    // 重路由——保持 DSH 的全链路（重试/瀑布流/用量计量）。
+    const fallbackProvider = 'deepseek-official';
+    const fallback = llm.stream
+        ? {
+            stream(options) {
+                return llm.stream({ ...options, provider: fallbackProvider });
+            },
+        }
+        : undefined;
+    const adapter = new WhiteboxLlmAdapter({ bridge, fallback });
+    try {
+        llm.registerConfigurableProviders?.([{
+                provider: WHITEBOX_PROVIDER,
+                displayName: '白箱灵枢 (Whitebox)',
+                settingsNs: 'llm-whitebox',
+                settingsPath: [],
+            }]);
+        const registration = llm.registerAdapter([WHITEBOX_PROVIDER], adapter);
+        ctx.logger?.info?.('dsh-memory: 白箱 LLM provider 已注册: %s（降级→%s）', WHITEBOX_PROVIDER, fallbackProvider);
+        return () => { try {
+            registration?.replace?.([]);
+        }
+        catch { /* 忽略注销异常 */ } };
+    }
+    catch (err) {
+        ctx.logger?.warn?.('dsh-memory: 白箱 provider 注册失败: %s', String(err));
+        return () => { };
+    }
+}

package/lib/mutual.d.ts

@@ -26,7 +26,9 @@ export declare function judgeStamp(stamp: {
     ageMs: number;
     task_running: boolean;
 } | null, opts?: MutualOptions): 'alive' | 'alive_working' | 'warning' | 'dead' | 'no_stamp';
-/** 检测 harness 进程是否存在（wmic） */
+/** 检测 harness 进程是否存在
+ * P1 完善（GPT 审查·wmic 兼容）：wmic 在 Win11+ 已被移除——失败时
+ * fallback PowerShell Get-CimInstance（Win）；非 Windows 用 ps 查询。 */
 export declare function harnessRunning(): Promise<boolean>;
 /** detached 拉起 A 侧 harness.guardian（幂等：先确认不存在） */
 export declare function ensureHarness(python?: string, opts?: MutualOptions): Promise<'started' | 'already' | 'failed'>;
@@ -78,6 +80,7 @@ export declare function llmReview(claim: string, whitebox: VerifyResult['whitebo
 }>): Promise<VerifyResult['llm_review']>;
 /** 综合 verdict（白箱优先） */
 export declare function combineVerdict(w: VerifyResult['whitebox'], l: VerifyResult['llm_review']): VerifyResult['verdict'];
+export declare function safeTaskId(id: string): boolean;
 /** 处理单个任务：双通道验证 → 写回 result */
 export declare function processTask(task: VerifyTask, verifyFn: (c: string) => Promise<{
     judgment: string;
@@ -87,14 +90,13 @@ export declare function processTask(task: VerifyTask, verifyFn: (c: string) => P
 }>, reviewFn: (c: string, w: VerifyResult['whitebox']) => Promise<{
     conclusion: string;
     reason: string;
-}>, opts?: MutualOptions): Promise<VerifyResult>;
+}>, opts?: MutualOptions): Promise<VerifyResult | null>;
 export declare function log(opts: MutualOptions, msg: string): void;
 export declare function writeLastContact(opts?: MutualOptions): void;
 export declare function installMutualMaintenance(ctx: {
     logger: {
         info(m: string): void;
     };
-    interval(ms: number, fn: () => void): () => void;
     effect(fn: () => () => void, name?: string): void;
 }, config?: Partial<MutualOptions>, hooks?: {
     verify?: (c: string) => Promise<{

package/lib/mutual.js

@@ -75,30 +75,79 @@ function execP(cmd) {
         });
     });
 }
-/** 检测 harness 进程是否存在（wmic） */
+/** 检测 harness 进程是否存在
+ * P1 完善（GPT 审查·wmic 兼容）：wmic 在 Win11+ 已被移除——失败时
+ * fallback PowerShell Get-CimInstance（Win）；非 Windows 用 ps 查询。 */
 export async function harnessRunning() {
-    const out = await execP(`wmic process where "name='python.exe'" get commandline 2>nul`);
-    return out.includes('harness.guardian') || out.includes('harness.main');
+    if (process.platform === 'win32') {
+        // ① wmic（旧 Win10 可用）
+        const out = await execP(`wmic process where "name='python.exe'" get commandline 2>nul`);
+        if (out.includes('harness.guardian') || out.includes('harness.main'))
+            return true;
+        // ② wmic 不可用（Win11 移除）→ PowerShell
+        const psOut = await execP(`powershell -NoProfile -Command "Get-CimInstance Win32_Process -Filter \\"name='python.exe'\\" | Select-Object -ExpandProperty CommandLine"`);
+        return psOut.includes('harness.guardian') || psOut.includes('harness.main');
+    }
+    // 非 Windows（Linux/macOS）：ps 查询
+    const psOut = await execP(`ps -eo command | grep -E 'harness\\.(guardian|main)' | grep -v grep`);
+    return !!psOut;
 }
 /** detached 拉起 A 侧 harness.guardian（幂等：先确认不存在） */
 export async function ensureHarness(python = 'python', opts = DEFAULTS) {
     const running = await harnessRunning();
     if (running)
         return 'already';
-    try {
-        const child = spawn(python, ['-m', 'harness.guardian'], {
-            windowsHide: true,
-            detached: true,
-            stdio: 'ignore',
+    // P1 修复（GPT 审查）：spawn 找不到可执行文件是异步 error 事件，无监听
+    // 会直接崩 Node（Unhandled 'error' event）。加监听 + 超时判定拉起失败。
+    return new Promise((resolve) => {
+        let child = null;
+        let failTimer = null;
+        let okTimer = null;
+        let settled = false;
+        const finish = (r) => {
+            if (settled)
+                return;
+            settled = true;
+            if (failTimer)
+                clearTimeout(failTimer);
+            if (okTimer)
+                clearTimeout(okTimer);
+            resolve(r);
+        };
+        try {
+            child = spawn(python, ['-m', 'harness.guardian'], {
+                windowsHide: true,
+                detached: true,
+                stdio: 'ignore',
+            });
+        }
+        catch (e) {
+            log(opts, `守护失败：${String(e)}`);
+            finish('failed');
+            return;
+        }
+        // 拉起失败（python 不存在等）→ 记录 + failed，不崩 Node。
+        // spawn 的 error 事件是异步的：不能立即判 started——等 50ms error 窗口，
+        // 无 error 才算拉起成功（GPT 审查：此前立即返回 started，错误路径也报成功）。
+        child.on('error', (err) => {
+            log(opts, `守护拉起错误：${err.message}`);
+            finish('failed');
         });
+        // 拉起成功但立即退出（harness.guardian 不存在）→ failed
+        child.on('exit', (code) => {
+            if (code !== null && code !== 0) {
+                log(opts, `守护进程退出 code=${code}（guardian 可能不可用）`);
+                finish('failed');
+            }
+        });
+        okTimer = setTimeout(() => finish('started'), 50);
+        failTimer = setTimeout(() => {
+            log(opts, `守护拉起超时（10s 无健康确认）`);
+            finish('failed');
+        }, 10_000);
         child.unref();
         log(opts, `守护动作：拉起 harness.guardian（pid=${child.pid ?? '?'}）`);
-        return 'started';
-    }
-    catch (e) {
-        log(opts, `守护失败：${String(e)}`);
-        return 'failed';
-    }
+    });
 }
 /** 扫描互维目录里 A→B 的 pending 任务 */
 export function scanTasks(opts = DEFAULTS) {
@@ -139,6 +188,11 @@ export async function llmReview(claim, whitebox, reviewFn) {
 /** 综合 verdict（白箱优先） */
 export function combineVerdict(w, l) {
     const c = l.conclusion || '';
+    // P1 修复（GPT 审查）：白箱通道异常 → fail-closed（不因复核「同意」而 pass）
+    if (w.judgment.startsWith('whitebox_error') || w.judgment.startsWith('llm_error')
+        || w.d_norm < 0) {
+        return 'needs_revision';
+    }
     if (w.judgment.startsWith('采纳')) {
         // 白箱采纳：复核质疑/不同意→needs_revision（白箱优先，记录分歧）；否则 pass
         return c.includes('质疑') || c.includes('不同意') || c.includes('不通过')
@@ -149,43 +203,73 @@ export function combineVerdict(w, l) {
     // 证据不足/无法判断 → 白箱不确定，交给复核决定（「不同意」须排除「同意」子串）
     if (c.includes('不同意') || c.includes('不通过'))
         return 'needs_revision';
-    if (c.includes('通过') || c.includes('同意') || c.includes('质疑'))
+    if (c.includes('通过') || c.includes('同意'))
         return 'pass';
+    // P1 修复（GPT 审查）：「质疑」是分歧信号——白箱不确定 + 复核质疑 → 需要修订，
+    // 此前把「质疑」当 pass 与白箱采纳分支语义矛盾。
+    if (c.includes('质疑'))
+        return 'needs_revision';
     return 'needs_revision';
 }
+/** 任务 ID 安全校验（P1 修复：防路径穿越——task.id 可含 ../../ 写目录外） */
+const TASK_ID_RE = /^[A-Za-z0-9._-]{1,64}$/;
+export function safeTaskId(id) {
+    return TASK_ID_RE.test(id) && !id.includes('..');
+}
 /** 处理单个任务：双通道验证 → 写回 result */
 export async function processTask(task, verifyFn, reviewFn, opts = DEFAULTS) {
     const dir = path.join(netDir(opts), 'tasks');
+    // P1 修复（GPT 审查）：task.id 路径穿越——非法 id 拒绝处理，不写任何文件
+    if (!safeTaskId(task.id)) {
+        log(opts, `任务 ${JSON.stringify(task.id)} 非法（路径穿越风险），拒绝处理`);
+        throw new Error(`非法任务 id: ${task.id}`);
+    }
     const taskPath = path.join(dir, `task-${task.id}.json`);
-    // 标记 processing
+    // P1 完善（GPT 审查·任务竞态）：原子 claim——rename task→processing。
+    // 多实例同时 scanTasks 读到同一 pending 时，rename 只有一方成功；
+    // 失败（文件已被 rename/不存在）= 其他实例正在处理 → 跳过（返回 null）。
+    // 此前无锁：多实例都写 processing/result/done，结果互相覆盖。
+    const claimPath = path.join(dir, `processing-${task.id}.json`);
     try {
-        fs.writeFileSync(taskPath, JSON.stringify({ ...task, status: 'processing' }, null, 2), 'utf-8');
+        fs.renameSync(taskPath, claimPath);
+    }
+    catch {
+        return null; // 已被其他实例 claim，或文件不存在
     }
-    catch { /* 非阻塞 */ }
-    const w = await whiteboxVerify(task.payload.claim, verifyFn);
-    const l = await llmReview(task.payload.claim, w, reviewFn);
-    const verdict = combineVerdict(w, l);
-    const result = {
-        task_id: task.id,
-        verdict,
-        whitebox: w,
-        llm_review: l,
-        reasons: [
-            `白箱判定：${w.judgment}（best=${w.best}，d_norm=${w.d_norm}）`,
-            `复核结论：${l.conclusion}`,
-        ],
-        evidence: [task.payload.source_ref || ''].filter(Boolean),
-        verifier: 'B',
-        at: Date.now() / 1000,
-    };
-    fs.writeFileSync(path.join(dir, `result-${task.id}.json`), JSON.stringify(result, null, 2), 'utf-8');
-    // 标记 done
     try {
-        fs.writeFileSync(taskPath, JSON.stringify({ ...task, status: 'done' }, null, 2), 'utf-8');
+        const w = await whiteboxVerify(task.payload.claim, verifyFn);
+        const l = await llmReview(task.payload.claim, w, reviewFn);
+        const verdict = combineVerdict(w, l);
+        const result = {
+            task_id: task.id,
+            verdict,
+            whitebox: w,
+            llm_review: l,
+            reasons: [
+                `白箱判定：${w.judgment}（best=${w.best}，d_norm=${w.d_norm}）`,
+                `复核结论：${l.conclusion}`,
+            ],
+            evidence: [task.payload.source_ref || ''].filter(Boolean),
+            verifier: 'B',
+            at: Date.now() / 1000,
+        };
+        // 结果先写 tmp 再 rename（原子，防半写文件）
+        const resultTmp = path.join(dir, `result-${task.id}.json.tmp`);
+        fs.writeFileSync(resultTmp, JSON.stringify(result, null, 2), 'utf-8');
+        fs.renameSync(resultTmp, path.join(dir, `result-${task.id}.json`));
+        // 完成：清理 claim 文件（rename 回 done 标记供审计）
+        fs.renameSync(claimPath, path.join(dir, `done-${task.id}.json`));
+        log(opts, `任务 ${task.id} 验证完成：${verdict}`);
+        return result;
+    }
+    catch (e) {
+        // 处理失败：释放 claim（rename 回 task 供重试）
+        try {
+            fs.renameSync(claimPath, taskPath);
+        }
+        catch { /* 文件可能已不在 */ }
+        throw e;
     }
-    catch { /* 非阻塞 */ }
-    log(opts, `任务 ${task.id} 验证完成：${verdict}`);
-    return result;
 }
 // ---------------------------------------------------------------------------
 // 日志 / last_contact
@@ -209,7 +293,13 @@ export function writeLastContact(opts = DEFAULTS) {
 export function installMutualMaintenance(ctx, config = {}, hooks = {}) {
     const opts = { ...DEFAULTS, ...config };
     // 1. 心跳写戳 + 守护 A（10min 周期）
-    const heartbeatDispose = ctx.interval(opts.heartbeatMs, () => {
+    // P1 修复（GPT 审查）：cordis-plugin-timer 签名是 interval(callback, delay)
+    // ——此前 (ms, fn) 写反：数字被当 callback、函数被当 delay，回调永不执行，
+    // 互维心跳/任务扫描实际不工作。
+    // P2 修复：不能用 ctx.interval——那是 cordis-plugin-timer 注入的快捷属性，
+    // 未声明 `timer` inject 时访问抛 "cannot get property without inject"。
+    // 改用 Node 原生 setInterval（互维不需要 Cordis effect 生命周期管理）。
+    const heartbeatTimer = setInterval(() => {
         try {
             writeHeartbeat(opts);
             // 守护 A：harness 不在 → 拉起
@@ -227,9 +317,10 @@ export function installMutualMaintenance(ctx, config = {}, hooks = {}) {
             writeLastContact(opts);
         }
         catch (e) { /* 单次失败不中断 */ }
-    });
+    }, opts.heartbeatMs);
+    heartbeatTimer.unref?.();
     // 2. 任务轮询（30s 周期，检查 A→B 任务）
-    const taskDispose = ctx.interval(30_000, () => {
+    const taskTimer = setInterval(() => {
         try {
             const tasks = scanTasks(opts);
             for (const t of tasks) {
@@ -241,13 +332,14 @@ export function installMutualMaintenance(ctx, config = {}, hooks = {}) {
             }
         }
         catch (e) { /* 单次失败不中断 */ }
-    });
+    }, 30_000);
+    taskTimer.unref?.();
     // 3. effect 作用域清理
     ctx.effect(() => {
         return () => {
             try {
-                heartbeatDispose();
-                taskDispose();
+                clearInterval(heartbeatTimer);
+                clearInterval(taskTimer);
             }
             catch { /* 清理失败不阻塞 */ }
         };