dsh-knj-workflow 2026.9.21 → 2026.9.22

package/lib/graph.js

@@ -212,14 +212,19 @@ function matchCondition(upstream, when, ctx) {
   }
 }
 
-/** 宽松相等：真值优先严格比较；兼容旧配置存的字符串值（'true'↔true、'5'↔5）。 */
+/** 宽松相等：真值优先严格比较；兼容旧配置存的字符串值（'true'↔true、'5'↔5）。
+ *  注意双向：subagent 输出可能是字符串化的数字/布尔（"5"/"true"），
+ *  条件值也可能是数字/布尔（新版 UI 保存时智能转换）——任意一侧为字符串都要能宽松匹配。 */
 function looseEq(a, b) {
   if (a === b) return true;
-  if (typeof b === 'string') {
-    if (a === true && b === 'true') return true;
-    if (a === false && b === 'false') return true;
-    if (typeof a === 'number' && b !== '' && !isNaN(Number(b)) && Number(b) === a) return true;
-  }
+  // 布尔 ↔ 'true'/'false'（任意一侧字符串）
+  if (a === true && b === 'true') return true;
+  if (a === false && b === 'false') return true;
+  if (b === true && a === 'true') return true;
+  if (b === false && a === 'false') return true;
+  // 数字 ↔ 数字字符串（"5"↔5，任意一侧字符串）
+  if (typeof a === 'number' && typeof b === 'string') return b !== '' && !isNaN(Number(b)) && Number(b) === a;
+  if (typeof b === 'number' && typeof a === 'string') return a !== '' && !isNaN(Number(a)) && Number(a) === b;
   return false;
 }
 
@@ -306,3 +311,52 @@ export function prepareWorkflowForSave(workflow, existing) {
   workflow.revision = (existing?.revision || 0) + 1;
   return { ok: true, workflow };
 }
+
+/**
+ * 把 task 节点按图的拓扑执行顺序排列（从 start 出发沿边 BFS）。
+ * 用途：任务 stageStates 的展示顺序应反映流程走向（如 task1 → task11 → task2 → task3），
+ * 而不是 nodes 数组的声明顺序（节点在画布上的添加顺序可能与连线顺序不一致）。
+ * 规则：
+ *  - 只排 type === 'task' 的节点；start/end/gateway/human 不进入列表但参与连线拓扑。
+ *  - human 节点的去向 routes（或旧 approveTo/rejectTo）视为虚拟出边参与排序——
+ *    否则 human 后续的 task 会因「无真实出边」排到列表尾部（与执行顺序不符）。
+ *  - XOR/AND 网关多出边按声明顺序稳定排列（同一网关后的分支保持 edges 顺序）。
+ *  - 有环（驳回重跑等）时以 BFS 先到为准，环内节点不会导致死循环。
+ * 返回：task 节点 id 数组（按拓扑序）。
+ */
+export function orderTaskNodesByFlow(workflow) {
+  const nodes = Array.isArray(workflow?.nodes) ? workflow.nodes : [];
+  const edges = Array.isArray(workflow?.edges) ? workflow.edges : [];
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  // 邻接表：真实边 + human 虚拟出边（routes / approveTo / rejectTo）
+  const adj = new Map(nodes.map((n) => [n.id, []]));
+  for (const e of edges) {
+    if (e?.from && byId.has(e.from) && e.to && byId.has(e.to)) adj.get(e.from).push(e.to);
+  }
+  for (const n of nodes) {
+    if (n.type !== 'human') continue;
+    for (const r of humanRoutes(n)) {
+      if (r?.to && byId.has(r.to)) adj.get(n.id).push(r.to);
+    }
+  }
+  // BFS 从 start 出发，记录 task 节点首次出现顺序
+  const ordered = [];
+  const seen = new Set();
+  const queue = ['start'];
+  seen.add('start');
+  while (queue.length) {
+    const id = queue.shift();
+    const node = byId.get(id);
+    if (node && node.type === 'task') ordered.push(id);
+    for (const to of adj.get(id) || []) {
+      if (seen.has(to)) continue;
+      seen.add(to);
+      queue.push(to);
+    }
+  }
+  // 未被 start 可达（孤立/异常图）的 task 按声明顺序补尾，避免丢失
+  for (const n of nodes) {
+    if (n.type === 'task' && !seen.has(n.id)) ordered.push(n.id);
+  }
+  return ordered;
+}

package/lib/graph.test.js

@@ -5,7 +5,7 @@
  */
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { validateWorkflow, nextNode, resolveInputs, prepareWorkflowForSave } from './graph.js';
+import { validateWorkflow, nextNode, resolveInputs, prepareWorkflowForSave, orderTaskNodesByFlow } from './graph.js';
 
 // 辅助：构造串行图
 function serialWorkflow(over = {}) {
@@ -389,3 +389,57 @@ test('validateWorkflow: human 多去向 routes 校验（目标无效 / 标签重
   assert.ok(r.errors.some((e) => e.includes('去向标签重复: 驳回')), JSON.stringify(r.errors));
   assert.ok(r.errors.some((e) => e.includes('缺少标签')), JSON.stringify(r.errors));
 });
+
+test('orderTaskNodesByFlow: 节点按拓扑执行顺序而非声明顺序（task11 声明在尾部但连线在中间）', () => {
+  // 复现 wf-gate 实测：画布上先加了 task-2/task-3、后加 task11（nodes 声明序 task-1, task-2, task-3, task11），
+  // 但连线是 start→task-1→task11→gw→(task-2|task-3)。stageStates 若按声明序生成会把 task11 排到最底，
+  // 与真实执行顺序（task1→task11→task2/task3）不符。
+  const wf = {
+    id: 'wf-gate', schemaVersion: 2, revision: 2,
+    nodes: [
+      { id: 'start', type: 'start' },
+      { id: 'end', type: 'end' },
+      { id: 'task-1', type: 'task', title: 'task-1' },
+      { id: 'task-2', type: 'task', title: 'task-2' },
+      { id: 'task-3', type: 'task', title: 'task-3' },
+      { id: 'task11', type: 'task', title: 'task11' },
+      { id: 'gw', type: 'gateway-xor' },
+    ],
+    edges: [
+      { from: 'start', to: 'task-1' },
+      { from: 'task-2', to: 'end' },
+      { from: 'task-3', to: 'end' },
+      { from: 'task-1', to: 'task11' },
+      { from: 'task11', to: 'gw' },
+      { from: 'gw', to: 'task-2' },
+      { from: 'gw', to: 'task-3' },
+    ],
+  };
+  const ordered = orderTaskNodesByFlow(wf);
+  assert.deepEqual(ordered, ['task-1', 'task11', 'task-2', 'task-3'],
+    `应按执行顺序排列，实际: ${JSON.stringify(ordered)}`);
+});
+
+test('orderTaskNodesByFlow: human 节点去向（routes）后的 task 参与拓扑排序', () => {
+  const wf = {
+    id: 'wf-human', schemaVersion: 2, revision: 1,
+    nodes: [
+      { id: 'start', type: 'start' },
+      { id: 'task-1', type: 'task', title: 'task-1' },
+      { id: 'review', type: 'human', routes: [{ label: '通过', to: 'task-2' }, { label: '驳回', to: 'fix' }] },
+      { id: 'task-2', type: 'task', title: 'task-2' },
+      { id: 'fix', type: 'task', title: 'fix' },
+      { id: 'end', type: 'end' },
+    ],
+    edges: [
+      { from: 'start', to: 'task-1' },
+      { from: 'task-1', to: 'review' },
+      { from: 'task-2', to: 'end' },
+      { from: 'fix', to: 'task-2' }, // 驳回→fix→task-2（与 review 同层，BFS 先到为准）
+    ],
+  };
+  const ordered = orderTaskNodesByFlow(wf);
+  // start → task-1 → review(human) → task-2 与 fix；BFS 队列按邻接声明序先 task-2 后 fix
+  assert.deepEqual(ordered, ['task-1', 'task-2', 'fix'],
+    `human 后的 task 应继续排在拓扑序中，实际: ${JSON.stringify(ordered)}`);
+});

package/lib/index.js

@@ -12,10 +12,23 @@
 import { homedir } from 'node:os';
 import { join, dirname, resolve, relative, isAbsolute } from 'node:path';
 import { mkdir, readFile, writeFile, readdir, rm, rename, stat, realpath } from 'node:fs/promises';
+import { appendFileSync, mkdirSync, readFileSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import z from '@deepseek-ai/schemastery';
-import { readFileSync } from 'node:fs';
-import { validateWorkflow, prepareWorkflowForSave } from './graph.js';
+import { validateWorkflow, prepareWorkflowForSave, orderTaskNodesByFlow } from './graph.js';
+
+// ---- 运行时诊断日志（排查 runs 生命周期：human 决策后任务卡 running）----
+// 只记录关键状态转换，避免刷屏；写入独立文件便于事后查看，不依赖宿主 logger 落点。
+const DEBUG_LOG_DIR = join(homedir(), '.dsh', 'dev-orchestrator');
+const DEBUG_LOG = join(DEBUG_LOG_DIR, 'knj-host-debug.log');
+let _dbgInited = false;
+function dbg(event, data) {
+  try {
+    if (!_dbgInited) { mkdirSync(DEBUG_LOG_DIR, { recursive: true }); _dbgInited = true; }
+    const line = JSON.stringify({ ts: new Date().toISOString(), event, ...data });
+    appendFileSync(DEBUG_LOG, line + '\n', 'utf8');
+  } catch { /* 日志失败不影响主流程 */ }
+}
 
 export const name = 'dsh-knj-workflow';
 
@@ -187,11 +200,14 @@ export class DevTaskStore {
     // 串行化同一任务的写入：事件回调（phase/agent-end/end）可能并发触发 saveTask，
     // Windows 上并发写同一文件会互相踩踏。
     const prev = this._queues.get(task.id) || Promise.resolve();
+    dbg('store.saveTask: 排队', { taskId: task.id, queueDepth: this._queues.has(task.id) ? 1 : 0 });
     const next = prev.then(async () => {
       await writeJson(file, task);
+      dbg('store.saveTask: 写盘完成', { taskId: task.id });
     });
     this._queues.set(task.id, next.catch(() => {})); // 队列本身吞掉错误，避免整链断掉
     await next;
+    dbg('store.saveTask: await 返回', { taskId: task.id });
     return task;
   }
   /**
@@ -203,15 +219,19 @@ export class DevTaskStore {
     await mkdir(join(this.tasksDir, id), { recursive: true });
     const file = this.taskFile(id);
     const prev = this._queues.get(id) || Promise.resolve();
+    dbg('store.mutateTask: 排队', { taskId: id, queueDepth: this._queues.has(id) ? 1 : 0 });
     const next = prev.then(async () => {
       const t = await readJson(file, null);
       if (!t) return null;
       await mutator(t);
       await writeJson(file, t);
+      dbg('store.mutateTask: 写盘完成', { taskId: id });
       return t;
     });
     this._queues.set(id, next.catch(() => {}));
-    return await next;
+    const out = await next;
+    dbg('store.mutateTask: await 返回', { taskId: id });
+    return out;
   }
   async deleteTask(id) {
     DevTaskStore.assertSafeId(id);
@@ -377,10 +397,12 @@ export class WorkflowBridge {
     // 并发守卫：检查 + 同步占位必须在任何 await 之前原子完成，堵住 TOCTOU 竞态——
     // 否则两个并发请求会双双通过守卫、启动两份 subagent（双倍 LLM 成本 + 互踩 stage）。
     if (this.runs.has(task.id)) {
+      dbg('startTask: 并发守卫命中（runs 已有条目）', { taskId: task.id, optsKeys: Object.keys(opts) });
       throw new RunAlreadyActiveError(`任务 ${task.id} 已有运行中的 run，请先等待完成或取消后再启动`);
     }
     const pendingMarker = {};
     this.runs.set(task.id, pendingMarker);
+    dbg('startTask: 占位已登记', { taskId: task.id, optsKeys: Object.keys(opts) });
     try {
     // 任务快照优先：运行只用创建时的快照，与工作流后续修改解耦
     const workflow = task.workflowSnapshot || await this.store.getWorkflow(task.workflowId);
@@ -491,6 +513,7 @@ export class WorkflowBridge {
 
     this.listeners.set(task.id, run.id);
     this.runs.set(task.id, run);
+    dbg('startTask: run 已登记', { taskId: task.id, runId: run.id });
     if (parentHandle) this.parentHandles.set(run.id, parentHandle);
     this.monitorRun(task, run);
     return { runId: run.id };
@@ -498,12 +521,14 @@ export class WorkflowBridge {
       // 早期失败（workflow 缺失 / 无 parent / 引擎不可用 / engine.start 抛错）：
       // 清除占位标记，让任务可再次启动。真实 run 已登记时（成功路径）不会走到这里。
       if (this.runs.get(task.id) === pendingMarker) this.runs.delete(task.id);
+      dbg('startTask: 启动失败（已清理占位）', { taskId: task.id, error: error instanceof Error ? error.message : String(error) });
       throw error;
     }
   }
 
   /** 监听 run 事件并回写任务状态（事件签名：(info, payload)） */
   async monitorRun(task, run) {
+    dbg('monitorRun: 注册监听', { taskId: task.id, runId: run.id });
     const ctx = this.ctx;
     const matches = (info) => info?.id === run.id;
 
@@ -577,6 +602,14 @@ export class WorkflowBridge {
     // 不能拿它 finalizeTask，否则会用空 results 覆盖正确结果（已踩坑）。
     // run.result 契约上永不 reject，直接 await 设置终态 + 清理监听器。
     run.result.then(async (result) => {
+      dbg('monitorRun: result 落定', {
+        taskId: task.id, runId: run.id,
+        stopReason: result?.stopReason,
+        paused: !!(result?.value && result.value.paused),
+        runsIsRun: this.runs.get(task.id) === run,
+        runsHas: this.runs.has(task.id),
+        valueKeys: result?.value ? Object.keys(result.value) : [],
+      });
       try {
         // 只允许「当前活跃 run」写终态：cancel→resume 时旧 run 的 result 晚到，
         // 若不校验会覆盖新 run 状态；parent 按 runId 管理，旧 run 只 dispose 自己的 parent，
@@ -586,13 +619,19 @@ export class WorkflowBridge {
         }
       } catch {}
       // 清理放 finally 语义（即使 finalizeTask 抛错也必须 off 监听器 + dispose parent）
-      ctx.off('workflow/phase', onPhase);
-      ctx.off('workflow/agent-start', onAgentStart);
-      ctx.off('workflow/agent-end', onAgentEnd);
-      ctx.off('workflow/log', onLog);
+      // 注意：ctx.off 在真实环境可能抛错（监听器已随 ctx 生命周期注销等），必须各自独立 try——
+      // 若 ctx.off 抛错冒泡到外层 .catch，后面的 runs.delete 永不执行 → runs 残留 →
+      // decide/resume 全部被并发守卫 409 卡死（人工节点无法继续，实测复现）。
+      try { ctx.off('workflow/phase', onPhase); } catch {}
+      try { ctx.off('workflow/agent-start', onAgentStart); } catch {}
+      try { ctx.off('workflow/agent-end', onAgentEnd); } catch {}
+      try { ctx.off('workflow/log', onLog); } catch {}
       if (this.runs.get(task.id) === run) {
         this.listeners.delete(task.id);
         this.runs.delete(task.id);
+        dbg('monitorRun: runs 已清理', { taskId: task.id, runId: run.id });
+      } else {
+        dbg('monitorRun: runs 清理被跳过（runs 已被替换/删除）', { taskId: task.id, runId: run.id, runsHas: this.runs.has(task.id) });
       }
       // 关键：run 是 holder-owned，契约要求持有者在 result 落定后调用 run.dispose()
       // 释放引擎侧资源（等待子清理收敛）。不调用的话引擎 run 持续占用 parent 的
@@ -611,12 +650,15 @@ export class WorkflowBridge {
         this.parentHandles.delete(run.id);
         try { await handle.dispose?.(); } catch (e) { /* 忽略 dispose 失败，任务已终态 */ }
       }
-    }).catch(() => {});
+    }).catch((error) => {
+      dbg('monitorRun: result.then 回调异常（清理可能被跳过 → runs 残留）', { taskId: task.id, error: error instanceof Error ? error.message : String(error) });
+    });
   }
 
   /** 取消后台 run（真正停止，否则 finalizeTask 会把 cancelled 覆盖成 success/failed） */
   cancelTask(taskId) {
     const run = this.runs.get(taskId);
+    dbg('cancelTask: 调用', { taskId, hasRun: !!run, isMarker: run !== undefined && run !== null && typeof run !== 'object' ? false : (!!run && typeof run.cancel !== 'function') });
     if (run && typeof run.cancel === 'function') run.cancel();
   }
 
@@ -632,12 +674,15 @@ export class WorkflowBridge {
     const value = result?.value;
     // 人工节点暂停：标记 waiting-human + 落盘断点（result.value 是编排器 return 值）
     if (value?.paused) {
-      await this.store.mutateTask(taskId, (t) => {
+      dbg('finalizeTask: paused 分支（人工暂停）', { taskId, pausedAt: value.pausedAt });
+      const m1 = await this.store.mutateTask(taskId, (t) => {
         t.status = 'waiting-human';
         t.currentStage = value.pausedAt;
         t.humanState = { humanId: value.pausedAt, results: value.results || {} };
       });
+      dbg('finalizeTask: paused mutateTask 完成', { taskId, m1Status: m1?.status });
       await this.store.saveResults(taskId, value.results || {});
+      dbg('finalizeTask: paused saveResults 完成', { taskId });
       return;
     }
     const stopReason = result?.stopReason;
@@ -802,7 +847,10 @@ export function registerRoutes(ctx, store, bridge, prefix) {
         workflowSnapshot: workflow,
         status: 'pending',
         currentStage: null,
-        stageStates: workflow.nodes.filter((n) => n.type === 'task').map((n) => ({ id: n.id, title: n.title, status: 'pending' })),
+        stageStates: orderTaskNodesByFlow(workflow).map((id) => {
+          const n = workflow.nodes.find((x) => x.id === id);
+          return { id, title: n?.title || id, status: 'pending' };
+        }),
         createdAt: nowIso(),
         ...(body.notes ? { notes: body.notes } : {}),
         // 需求描述必须保存：编排器各节点 prompt 要靠它注入「用户输入的需求内容」
@@ -933,7 +981,10 @@ export function registerRoutes(ctx, store, bridge, prefix) {
       if (!t) return sendJson(c.res, 404, { error: 'task not found' });
       // 取消中守卫：cancel 异步落定（最长约 5s），期间 runs 条目仍在——改状态前先问，
       // 避免「取消后立即续跑」被旧守卫误拦后把任务误标 failed（任务永久卡死）。
-      if (bridge.isRunning(c.params.id)) return sendJson(c.res, 409, { error: '任务正在取消/运行中，请稍候再续跑' });
+      if (bridge.isRunning(c.params.id)) {
+        dbg('resume: isRunning 预检拦截（runs 仍有条目）', { taskId: c.params.id, mode: body.mode });
+        return sendJson(c.res, 409, { error: '任务正在取消/运行中，请稍候再续跑' });
+      }
       // 断点来源：续跑（mode=resume）读 stage 文件（每节点完成时编排器 checkpoint 落盘），
       // orchestrator 跳过已完成节点从断点继续；重跑（mode=rerun）清空 initialResults 从头执行。
       // 注意：results.json 在取消时是空的（编排器被中断，中间结果不落盘），不能作为断点来源。
@@ -1013,6 +1064,10 @@ export function registerRoutes(ctx, store, bridge, prefix) {
     ['POST', '/tasks/:id/decide', async (c) => {
       const body = await readBody(c.req);
       const t = await store.getTask(c.params.id);
+      dbg('decide: 请求进入', {
+        taskId: c.params.id, decision: body?.decision, hasFeedback: typeof body?.feedback === 'string' && !!body.feedback.trim(),
+        taskStatus: t?.status, hasHumanState: !!(t && t.humanState), humanId: t?.humanState?.humanId,
+      });
       if (!t) return sendJson(c.res, 404, { error: 'task not found' });
       if (t.status !== 'waiting-human' || !t.humanState) return sendJson(c.res, 400, { error: 'task not waiting for human' });
       const { humanId, results } = t.humanState;
@@ -1030,6 +1085,10 @@ export function registerRoutes(ctx, store, bridge, prefix) {
       const feedback = typeof body.feedback === 'string' ? body.feedback.trim() : '';
       // 记录决策历史，便于事后追溯（第几轮审批、结论、意见）
       t.decisions = [...(t.decisions || []), { humanId, decision, feedback, at: nowIso() }];
+      // 保存决策前的现场：startTask 若被并发守卫拒绝（RunAlreadyActiveError）必须回滚，
+      // 否则 humanState 已清、任务已置 running，用户无法再决策、任务永久卡死（无法恢复）。
+      const pendingHumanState = t.humanState;
+      const pendingDecision = t.decisions[t.decisions.length - 1];
       t.status = 'running';
       t.humanState = null;
       t.error = undefined;
@@ -1043,8 +1102,28 @@ export function registerRoutes(ctx, store, bridge, prefix) {
         });
         sendJson(c.res, 200, { task: t, runId });
       } catch (e) {
-        if (e instanceof RunAlreadyActiveError) return sendJson(c.res, 409, { error: e.message });
-        // humanState 已清、决策已记录——无法回滚，但至少要标记 failed，避免任务卡 running
+        dbg('decide: startTask 抛错', {
+          taskId: c.params.id, decision,
+          isRunAlreadyActive: e instanceof RunAlreadyActiveError,
+          error: e instanceof Error ? e.message : String(e),
+        });
+        if (e instanceof RunAlreadyActiveError) {
+          // 并发守卫拒绝 = 决策未被编排器消费（新 run 没起来）。回滚到 waiting-human，
+          // 保留 humanState 与决策历史供用户重试，而不是留下一个卡死的 running 任务。
+          await store.mutateTask(c.params.id, (tt) => {
+            tt.status = 'waiting-human';
+            tt.humanState = pendingHumanState;
+            tt.currentStage = pendingHumanState?.humanId || tt.currentStage;
+            tt.error = undefined;
+            // 去掉刚追加但未生效的决策（避免 buildDecidedMap 重放成"已决策"跳过 human）
+            if (pendingDecision) {
+              const idx = (tt.decisions || []).findIndex((d) => d === pendingDecision || (d.humanId === pendingDecision.humanId && d.at === pendingDecision.at));
+              if (idx >= 0) tt.decisions = (tt.decisions || []).filter((_, i) => i !== idx);
+            }
+          }).catch(() => {});
+          return sendJson(c.res, 409, { error: e.message });
+        }
+        // 决策后启动失败（非并发）：humanState 已清、决策已记录——无法回滚，但至少要标记 failed，避免任务卡 running
         await store.mutateTask(c.params.id, (tt) => {
           tt.status = 'failed';
           tt.error = `决策后继续失败：${e instanceof Error ? e.message : String(e)}`;
@@ -1179,7 +1258,10 @@ function registerCommands(ctx, store, bridge) {
             workflowRevision: workflow.revision || 1,
             workflowSnapshot: workflow,
             status: 'pending',
-            stageStates: workflow.nodes.filter((n) => n.type === 'task').map((n) => ({ id: n.id, title: n.title, status: 'pending' })),
+            stageStates: orderTaskNodesByFlow(workflow).map((id) => {
+              const n = workflow.nodes.find((x) => x.id === id);
+              return { id, title: n?.title || id, status: 'pending' };
+            }),
             createdAt: nowIso(),
           };
           await store.saveTask(task);

package/lib/orchestrator.js

@@ -95,14 +95,19 @@ function matchCondition(upstream, when) {
   return false;
 }
 
-/** 宽松相等：真值优先严格比较；兼容旧配置存的字符串值（'true'↔true、'5'↔5）。 */
+/** 宽松相等：真值优先严格比较；兼容旧配置存的字符串值（'true'↔true、'5'↔5）。
+ *  注意双向：subagent 输出可能是字符串化的数字/布尔（"5"/"true"），
+ *  条件值也可能是数字/布尔（新版 UI 保存时智能转换）——任意一侧为字符串都要能宽松匹配。 */
 function looseEq(a, b) {
   if (a === b) return true;
-  if (typeof b === 'string') {
-    if (a === true && b === 'true') return true;
-    if (a === false && b === 'false') return true;
-    if (typeof a === 'number' && b !== '' && !isNaN(Number(b)) && Number(b) === a) return true;
-  }
+  // 布尔 ↔ 'true'/'false'（任意一侧字符串）
+  if (a === true && b === 'true') return true;
+  if (a === false && b === 'false') return true;
+  if (b === true && a === 'true') return true;
+  if (b === false && a === 'false') return true;
+  // 数字 ↔ 数字字符串（"5"↔5，任意一侧字符串）
+  if (typeof a === 'number' && typeof b === 'string') return b !== '' && !isNaN(Number(b)) && Number(b) === a;
+  if (typeof b === 'number' && typeof a === 'string') return a !== '' && !isNaN(Number(a)) && Number(a) === b;
   return false;
 }
 

package/lib/orchestrator.test.js

@@ -237,6 +237,31 @@ test('orchestrator: 条件值字符串宽松匹配旧配置（"true" 匹配布
   assert.ok(!r.agentCalls.includes('修复'), JSON.stringify(r.agentCalls));
 });
 
+test('orchestrator: 反向宽松匹配——subagent 输出字符串数字 "5"、条件值为数字 5 也应命中（实测 wf-gate 失败场景）', async () => {
+  const wf = {
+    id: 'wf', nodes: [
+      { id: 'start', type: 'start' },
+      { id: 'task11', type: 'task', title: 'task11', inputs: [], body: { prompt: '', mode: 'single', output: {} } },
+      { id: 'gw', type: 'gateway-xor', title: '网关' },
+      { id: 'task2', type: 'task', title: 'task-2', inputs: [], body: { prompt: '', mode: 'single', output: {} } },
+      { id: 'task3', type: 'task', title: 'task-3', inputs: [], body: { prompt: '', mode: 'single', output: {} } },
+      { id: 'end', type: 'end' },
+    ],
+    edges: [
+      { from: 'start', to: 'task11' },
+      { from: 'task11', to: 'gw' },
+      // 条件值是数字 5（新版 UI 保存时智能转换 '5'→5）
+      { from: 'gw', to: 'task2', when: { field: 'taskResult', op: 'eq', value: 5 } },
+      { from: 'gw', to: 'task3', default: true },
+      { from: 'task2', to: 'end' }, { from: 'task3', to: 'end' },
+    ],
+  };
+  // subagent 把 taskResult 输出成了字符串 "5"（没有声明 type:number 时 LLM 常见）
+  const r = await runOrchestrator(wf, (label) => (label === 'task11' ? { taskResult: '5' } : { ok: true }));
+  assert.ok(r.agentCalls.includes('task-2'), `应命中数字条件分支 task-2，实际: ${JSON.stringify(r.agentCalls)}`);
+  assert.ok(!r.agentCalls.includes('task-3'), JSON.stringify(r.agentCalls));
+});
+
 // 构造 AND split/join 图
 function andWorkflow() {
   return {

package/lib/repro-decide-order.test.js

@@ -0,0 +1,73 @@
+/**
+ * 复现 2：decide 路由的状态破坏顺序。
+ * 现场：任务 waiting-human（humanState 有值）→ 用户点驳回 → decide 路由先
+ *        t.status='running'; t.humanState=null; saveTask → 再 bridge.startTask。
+ *        若此刻 runs Map 仍残留旧 run（decide 前的 run 尚未清理/或并发 run 活跃），
+ *        startTask 抛 RunAlreadyActiveError → 路由返回 409 但不恢复任务状态 →
+ *        任务永久卡 running + humanState 已丢 → 无法再次决策、resume 也被 isRunning 挡住。
+ * 运行：node --test lib/repro-decide-order.test.js
+ */
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import { registerRoutes, RunAlreadyActiveError } from './index.js';
+
+const WF = {
+  id: 'wf1', name: 'WF',
+  nodes: [
+    { id: 'start', type: 'start' },
+    { id: 'task-1', type: 'task', title: 'A', body: { prompt: 'p' } },
+    { id: 'human-1', type: 'human', title: '审批', routes: [{ label: '通过', to: 'task-2' }, { label: '不通过', to: 'task-3' }] },
+    { id: 'task-2', type: 'task', title: 'B', body: { prompt: 'p' } },
+    { id: 'task-3', type: 'task', title: 'C', body: { prompt: 'p' } },
+    { id: 'end', type: 'end' },
+  ],
+  edges: [
+    { from: 'start', to: 'task-1' }, { from: 'task-1', to: 'human-1' },
+    { from: 'task-2', to: 'end' }, { from: 'task-3', to: 'end' },
+  ],
+};
+
+function makeWaitingTask() {
+  return {
+    id: 'task-w', title: 'W', workflowId: 'wf1', cwd: 'D:/w', workflowSnapshot: WF,
+    status: 'waiting-human',
+    currentStage: 'human-1',
+    humanState: { humanId: 'human-1', results: { 'task-1': { ok: true } } },
+    stageStates: [
+      { id: 'task-1', status: 'done' }, { id: 'task-2', status: 'pending' }, { id: 'task-3', status: 'pending' },
+    ],
+  };
+}
+
+/** 路由直驱：bridge.startTask 抛 RunAlreadyActiveError（模拟 decide 前旧 run 尚未清理/有并发 run） */
+test('decide：startTask 被 409 拒绝时不得破坏 waiting-human 任务状态（可重试）', async () => {
+  let saved = null;
+  const store = {
+    tasksDir: '.tasks',
+    async getTask(id) { return id === 'task-w' ? JSON.parse(JSON.stringify(saved)) : null; },
+    async saveTask(t) { saved = JSON.parse(JSON.stringify(t)); },
+    async mutateTask(id, fn) { if (saved && saved.id === id) { fn(saved); } },
+    async saveResults() {}, async readResults() { return {}; }, async readStage() { return null; },
+  };
+  const bridge = {
+    isRunning: () => true, // decide 前仍有活跃 run（旧 run 残留 / 并发）
+    async startTask() { throw new RunAlreadyActiveError('任务 task-w 已有运行中的 run'); },
+  };
+  const registrations = [];
+  registerRoutes({ effect(fn) { fn(); return () => {}; }, webServer: { register: (r) => registrations.push(r) } }, store, bridge, '');
+  const { handler } = registrations[0]; // register({ kind:'prefix', path, handler })
+
+  saved = makeWaitingTask();
+  const req = new EventEmitter();
+  req.method = 'POST';
+  req.url = '/tasks/task-w/decide';
+  const res = { headersSent: false, statusCode: 0, body: null, writeHead(s) { this.statusCode = s; this.headersSent = true; }, end(d) { this.body = d ? JSON.parse(d) : null; } };
+  process.nextTick(() => { req.emit('data', JSON.stringify({ decision: '不通过', feedback: 'x' })); req.emit('end'); });
+  await handler(req, res);
+
+  assert.equal(res.statusCode, 409, '并发守卫应 409');
+  assert.equal(saved.status, 'waiting-human',
+    'BUG：startTask 被拒后任务状态被改成 running，卡死且 humanState 已丢（无法重试决策）');
+  assert.ok(saved.humanState, 'BUG：humanState 被清空，任务无法再次 decide');
+});

package/lib/repro-paused-runs.test.js

@@ -0,0 +1,112 @@
+/**
+ * 复现：human paused 后 runs Map 是否残留（导致 decide/resume 被并发守卫 409 卡死）。
+ * 现场：task-mtk40fjd 点驳回后任务卡 running，resume 返回 409「任务正在取消/运行中」，
+ *       且没有创建第二个 parent 会话 → decide 的 startTask 在 runs.has 处抛 RunAlreadyActiveError。
+ * 运行：node --test lib/repro-paused-runs.test.js
+ */
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { WorkflowBridge, RunAlreadyActiveError } from './index.js';
+
+const WF_HUMAN = {
+  id: 'wf-human', name: 'H',
+  nodes: [
+    { id: 'start', type: 'start' },
+    { id: 'task-1', type: 'task', title: 'T1', body: { prompt: 'p1' } },
+    { id: 'human-1', type: 'human', title: '审批', routes: [{ label: '通过', to: 'task-2' }, { label: '不通过', to: 'task-3' }] },
+    { id: 'task-2', type: 'task', title: 'T2', body: { prompt: 'p2' } },
+    { id: 'task-3', type: 'task', title: 'T3', body: { prompt: 'p3' } },
+    { id: 'end', type: 'end' },
+  ],
+  edges: [
+    { from: 'start', to: 'task-1' }, { from: 'task-1', to: 'human-1' },
+    { from: 'task-2', to: 'end' }, { from: 'task-3', to: 'end' },
+  ],
+};
+
+function makeTask() {
+  return { id: 'task-x', title: 'X', workflowId: 'wf-human', cwd: 'D:/w', workflowSnapshot: WF_HUMAN };
+}
+
+/** 内存态 store：getTask/mutateTask/saveTask/saveResults 真实生效，供 decide 路由校验 humanState */
+function makeStore() {
+  let task = null;
+  const results = {};
+  return {
+    tasksDir: '.tasks',
+    async getWorkflow() { return WF_HUMAN; },
+    async getTask(id) { return task && task.id === id ? JSON.parse(JSON.stringify(task)) : null; },
+    async saveTask(t) { task = JSON.parse(JSON.stringify(t)); },
+    async mutateTask(id, fn) { if (task && task.id === id) { fn(task); } },
+    async saveResults(id, r) { Object.assign(results, r); },
+    async readResults() { return { ...results }; },
+    async writeStage() {}, async readStage() { return null; },
+  };
+}
+
+/** ctx mock：agents.create 提供 parent，engine.start 返回可编程 result 的 run */
+function makeEnv(resultProvider) {
+  const created = [];
+  const engine = {
+    start() {
+      return {
+        id: 'run-' + created.length,
+        cancel() {},
+        dispose() {},
+        result: Promise.resolve(typeof resultProvider === 'function' ? resultProvider(created.length) : resultProvider),
+      };
+    },
+  };
+  const parentAgent = { id: 'parent-1', scope: { ctx: { get: (n) => (n === 'workflowEngine' ? engine : undefined) } } };
+  const seed = { session: { header: { cwd: 'D:/w' } }, options: {} };
+  const ctx = {
+    on() {}, off() {},
+    logger: { info() {}, warn() {} },
+    get(name) {
+      if (name === 'agents') return {
+        currentInitiator: () => seed,
+        roots: () => [seed],
+        async create(opts) { created.push(opts); return { agent: parentAgent, dispose: async () => {} }; },
+      };
+      return undefined;
+    },
+  };
+  return { ctx, store: makeStore(), created, engine };
+}
+
+test('复现：第一次 run paused 结束后 runs 应清理，isRunning 应为 false', async () => {
+  const { ctx, store } = makeEnv({ stopReason: 'completed', value: { paused: true, pausedAt: 'human-1', results: { 'task-1': { ok: true } }, stageLog: [{ id: 'task-1' }] } });
+  const bridge = new WorkflowBridge(ctx, store, 'script');
+  const task = makeTask();
+  await bridge.startTask(task, {});
+  assert.equal(bridge.isRunning(task.id), true, '启动后应运行中');
+
+  // 等 run.result.then 的清理（monitorRun 在 result settle 后删 runs）
+  await new Promise((r) => setTimeout(r, 50));
+  assert.equal(bridge.isRunning(task.id), false,
+    'BUG：paused 后 runs 未清理，decide/resume 会被并发守卫 409 卡死');
+});
+
+test('复现：paused 清理后，decide 再次 startTask 必须成功（不被 409 拒）', async () => {
+  let calls = 0;
+  const { ctx, store } = makeEnv(() => {
+    calls++;
+    // 第一次 run：跑到 human 暂停；第二次 run：正常完成（本次只验证 startTask 不被拒）
+    return calls === 1
+      ? { stopReason: 'completed', value: { paused: true, pausedAt: 'human-1', results: { 'task-1': { ok: true } }, stageLog: [{ id: 'task-1' }] } }
+      : { stopReason: 'completed', value: { results: { 'task-1': { ok: true }, 'task-3': { ok: true } }, stageLog: [{ id: 'task-1' }, { id: 'task-3' }] } };
+  });
+  const bridge = new WorkflowBridge(ctx, store, 'script');
+  const task = makeTask();
+  await bridge.startTask(task, {});
+  await new Promise((r) => setTimeout(r, 50));
+  assert.equal(bridge.isRunning(task.id), false, 'paused 后应可再启动');
+
+  // 模拟 decide 后的第二次启动（带决策继续）
+  try {
+    await bridge.startTask(task, { decision: { humanId: 'human-1', value: '不通过' }, initialResults: { 'task-1': { ok: true } }, decided: { 'human-1': '不通过' } });
+    assert.equal(calls, 2, '第二次 startTask 应成功启动新 run');
+  } catch (e) {
+    assert.fail('decide 后 startTask 被拒（' + (e instanceof RunAlreadyActiveError ? 'RunAlreadyActiveError: ' : '') + e.message + '）');
+  }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-knj-workflow",
-  "version": "2026.9.21",
+  "version": "2026.9.22",
   "description": "KNJ 开发任务编排插件：配置驱动的工作流 + 开发任务管理 + 可视化阶段进度（DeepSeek Harness）",
   "author": "knj",
   "license": "MIT",