@furongjun1999/dsh-memory 0.2.9 → 0.3.0

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,10 @@ 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，回调永不执行，
+    // 互维心跳/任务扫描实际不工作。
+    const heartbeatDispose = ctx.interval(() => {
         try {
             writeHeartbeat(opts);
             // 守护 A：harness 不在 → 拉起
@@ -227,9 +314,9 @@ export function installMutualMaintenance(ctx, config = {}, hooks = {}) {
             writeLastContact(opts);
         }
         catch (e) { /* 单次失败不中断 */ }
-    });
+    }, opts.heartbeatMs);
     // 2. 任务轮询（30s 周期，检查 A→B 任务）
-    const taskDispose = ctx.interval(30_000, () => {
+    const taskDispose = ctx.interval(() => {
         try {
             const tasks = scanTasks(opts);
             for (const t of tasks) {
@@ -241,7 +328,7 @@ export function installMutualMaintenance(ctx, config = {}, hooks = {}) {
             }
         }
         catch (e) { /* 单次失败不中断 */ }
-    });
+    }, 30_000);
     // 3. effect 作用域清理
     ctx.effect(() => {
         return () => {