dsh-supercrew 0.1.5 → 0.1.8

package/bin/supercrew.mjs

@@ -92,3 +92,11 @@ const child = spawn(process.execPath, args, {
   env,
 });
 child.on('exit', (code) => process.exit(code ?? 0));
+// ★ spawn 失败是异步的：不监听的话，node 不在该在的位置时只打印一个未捕获
+//   异常栈，用户看到的要么是「什么都没发生」、要么是一坨内部路径。
+child.on('error', (e) => {
+  console.error(`起不来子命令 ${cmd}：${e.message}`);
+  console.error(`  用的 node: ${NODE}`);
+  console.error(`  要跑的脚本: ${path.join(ROOT, file)}`);
+  process.exit(1);
+});

package/client.js

@@ -1,9 +1,9 @@
 /**
  * dsh-supercrew 的界面部分：会话头部一枚状态胶囊。
  *
- * 值来自看板的 /api/heartbeat（每 3 秒拉一次）：
- *   🟢 值守中 · 344 轮     它盯着，手上没活
- *   🟡 正在干 TMWDxxxxxxxx 手上有一张单
+ * 值来自看板的 /api/heartbeat + /api/tickets（每 3 秒拉一次）：
+ *   🟢 值守中 · 412 轮     它盯着，手上没活
+ *   🟡 正在干 2 张         手上正干着活
  *   🔴 值守掉线            心跳断了（或看板没起来）
  * 点一下打开看板。
  */
@@ -18,14 +18,21 @@ window.__ModuleLoader__.load({
 
     function Capsule() {
       const [hb, setHb] = React.useState(null);
+      const [busy, setBusy] = React.useState(0);
 
       React.useEffect(() => {
         let alive = true;
         const pull = async () => {
           try {
-            const r = await fetch(`${PANEL}/api/heartbeat`, { cache: 'no-store' });
-            const j = await r.json();
-            if (alive) setHb(j);
+            const hbRes = await fetch(`${PANEL}/api/heartbeat`, { cache: 'no-store' });
+            const j = await hbRes.json();
+            let n = 0;
+            try {
+              const tRes = await fetch(`${PANEL}/api/tickets`, { cache: 'no-store' });
+              const list = await tRes.json();
+              if (Array.isArray(list)) n = list.filter((t) => t && t.state === 'working').length;
+            } catch { /* 工单拉不到不算错，胶囊照样显示值守状态 */ }
+            if (alive) { setHb(j); setBusy(n); }
           } catch {
             if (alive) setHb({ alive: false, offline: true });
           }
@@ -36,11 +43,12 @@ window.__ModuleLoader__.load({
       }, []);
 
       const offline = !hb || hb.alive === false;
-      const working = !offline && typeof hb.note === 'string' && /正在干|接管待办/.test(hb.note);
+      const working = !offline && busy > 0;
       const color = offline ? '#e5484d' : (working ? '#f5a623' : '#2ecc71');
       const text = offline
         ? '值守掉线'
-        : (working ? hb.note : `值守中${hb.rounds ? ` · ${hb.rounds} 轮` : ''}`);
+        : (working ? `正在干 ${busy} 张`
+          : `值守中${hb.rounds ? ` · ${hb.rounds} 轮` : ''}`);
 
       return h('button', {
         type: 'button',

package/crew-watch.mjs

@@ -33,7 +33,17 @@ import { judge } from './lib/router.mjs';
 const SOCIAL = process.env.CREW_SOCIAL || 'D:\\sf\\surfcore-main\\state\\social-v2.json';
 const API = process.env.CREW_API || 'http://127.0.0.1:3100';
 const TOKENFILE = process.env.CREW_TOKENFILE || 'D:\\sf\\surfcore-main\\state\\console-token';
-const TRIGGER = new RegExp(process.env.CREW_TRIGGER || '@真白|@椎名真白|干活|派活|帮我做');
+// 环境变量写坏了（比如 CREW_TRIGGER='@真白|(干活' 少个括号）不能让值守直接起不来
+// —— 那等于整个系统全哑，而报错只会指向这一行正则，看不出是哪个变量干的。
+const TRIGGER = (() => {
+  const raw = process.env.CREW_TRIGGER || '@真白|@椎名真白|干活|派活|帮我做';
+  try {
+    return new RegExp(raw);
+  } catch (e) {
+    console.error(`[crew-watch] CREW_TRIGGER 不是合法正则（${e.message}），退回默认值。`);
+    return new RegExp('@真白|@椎名真白|干活|派活|帮我做');
+  }
+})();
 const SEEN = path.join(
   process.env.CREW_HOME || path.join(process.env.USERPROFILE || '.', '.dsh-supercrew'),
   'seen.json',
@@ -114,6 +124,7 @@ function bumpHeartbeat(patch = {}) {
   }
   if (patch.recent) h.recent = patch.recent.slice(0, 12);
   if (patch.note) h.note = patch.note;
+  if (patch.qq !== undefined) h.qq = patch.qq;   // 耳朵还挂着吗（看板与状态胶囊上显示）
   try { saveJson(HEARTBEAT, h); } catch { /* 心跳写不进去不该影响值守 */ }
   return h;
 }
@@ -125,6 +136,29 @@ function markSeen(keys) {
   saveJson(SEEN, [...s].slice(-3000));
 }
 
+/**
+ * 耳朵还在不在？
+ *
+ * 我们的 QQ 入口整个架在 surfcore 桥上：消息从桥写的 social-v2.json 里读，
+ * 回话走桥的控制台端口。桥要是没跑，我们就会一直对着一份冻结的文件「认真听」，
+ * 看起来像在干活，其实什么也收不到 —— 所以每一轮都先探一下端口，探不到就
+ * 明说，别再假装在听。
+ *
+ * 注意：桥对未授权的请求会回 401，那也算活着 —— 只要连得上就说明进程在。
+ */
+export async function bridgeAlive(timeoutMs = 3000) {
+  const ctl = new AbortController();
+  const timer = setTimeout(() => ctl.abort(), timeoutMs);
+  try {
+    const r = await fetch(`${API}/api/status`, { signal: ctl.signal });
+    return r.status > 0;              // 200/401/403 都说明端口有人听
+  } catch {
+    return false;                     // 连接被拒 / 超时 → 桥没跑
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 export function scan({ onlyNew = true } = {}) {
   const social = readSocial();
   const seen = seenSet();
@@ -161,8 +195,14 @@ export async function intake({ dryRun = false, concurrency = 4 } = {}) {
       try {
         // 门卫：@ 我一下不等于给我派了活。判不出就放过（宁可漏，不可瞎干）。
         const j = await judge(body);
+        // ★ 「判不出来」和「判成闲聊」必须分开：前者不记 seen（下一轮还能重判）。
+        //   混在一起的话，网关卡一下 / 超时一次，这批需求就被永久吞掉了。
+        if (j.ok === false) {
+          failed.push({ key: m.key, msgId: String(m.id ?? ''), text: body.slice(0, 40), why: j.reason });
+          continue;
+        }
         if (!j.isTask) {
-          skipped.push({ key: m.key, from: m.from, text: body, why: j.reason });
+          skipped.push({ key: m.key, msgId: String(m.id ?? ''), from: m.from, text: body, why: j.reason });
           continue;
         }
         if (dryRun) { made.push({ dryRun: true, ...j, chatKey: m.key, msgId: m.id }); continue; }
@@ -188,7 +228,15 @@ export async function intake({ dryRun = false, concurrency = 4 } = {}) {
   });
   await Promise.all(lanes);
 
-  if (!dryRun) markSeen(found.map(seenKey));
+  if (!dryRun) {
+    // 只标记「真正处理过的」：开单成功、或门卫确认是闲聊。
+    // 判不出来 / 开单出错的留着 —— 下一轮还能重判，不然需求就永久丢了。
+    const handled = new Set([
+      ...made.map((t) => `${t.chatKey}|${t.msgId}`),
+      ...skipped.map((s) => `${s.key}|${s.msgId}`),
+    ]);
+    markSeen(found.filter((m) => handled.has(`${m.key}|${m.id ?? ''}`)).map(seenKey));
+  }
 
   // 记心跳：这一轮扫到几条、开了几单、拦下几条、判过的都长什么样
   if (!dryRun) {
@@ -221,8 +269,24 @@ function sanitize(s) {
 
 /** 把结果发回它来的会话；失败会把原因记进工单，方便事后补发 */
 export async function reply(ticket) {
+  // ★ 失败要留痕：没有来源会话 / 没有 agentToken / 令牌文件读不到，是最常见的三个
+  //   失败点。工单 done 之后不会再跑，这类失败要是直接 throw，看板上什么都不显示，
+  //   结果就永远没发出去而没人知道。所以一律写 replyError 再返回。
+  const fail = (msg) => {
+    try {
+      const fresh = loadAllTickets().find((t) => t.id === ticket.id);
+      if (fresh) {
+        fresh.replyAt = new Date().toISOString();
+        fresh.replyStatus = -1;
+        fresh.replyError = msg;
+        saveTicket(fresh);
+      }
+    } catch { /* 记账失败就算了，别因为记账影响主流程 */ }
+    return { status: -1, body: msg };
+  };
+
   const key = ticket.chatKey;
-  if (!key) throw new Error('这张工单没有来源会话');
+  if (!key) return fail('这张工单没有来源会话');
 
   // 两个令牌都要带：
   //   ① x-console-token —— 桥的全局关卡（所有 /api/* 都查它）
@@ -232,8 +296,10 @@ export async function reply(ticket) {
   const social = readSocial();
   const conv = (social.conversations || {})[key] || {};
   const agentToken = conv.agentToken || '';
-  if (!agentToken) throw new Error(`会话 ${key} 没有 agentToken，发不出去`);
-  const consoleToken = fs.readFileSync(TOKENFILE, 'utf8').trim();
+  if (!agentToken) return fail(`会话 ${key} 没有 agentToken，发不出去`);
+  let consoleToken = '';
+  try { consoleToken = fs.readFileSync(TOKENFILE, 'utf8').trim(); }
+  catch (e) { return fail(`读不到控制台令牌（${TOKENFILE}）：${e.message}`); }
 
   const isGroup = key.startsWith('group:');
   const id = key.split(':')[1];
@@ -304,37 +370,91 @@ async function main() {
   } else if (cmd === 'loop') {
     console.log('守着…… Ctrl+C 退出');
     bumpHeartbeat({ note: '值守起来了' });     // 先写一条，让看板立刻看到它还活着
+    // ★ 独立的心跳：不管下面那圈卡在哪个 worker 上，心跳照跳。
+    //   以前没有它的时候，一旦接管了一张要跑十分钟的单，心跳就跟着停，
+    //   看板（和会话头部那枚胶囊）会显示「值守掉线」—— 明明它在干活。
+    const beat = setInterval(() => { try { bumpHeartbeat({}); } catch { /* ignore */ } }, 8000);
+    beat.unref?.();
+    let qqDownRounds = 0;                      // 桥断了几轮（断着的时候不重复刷屏）
+    const running = new Set();                 // 正在后台跑的单，别重复派
     for (;;) {
       try {
         // 先接管「开了但没人派」的单 —— 从看板输入框、CLI 丢进来的活都落在 queued，
         // 以前必须有人去点卡片上的按钮才会跑，所以看起来像「它一点不干」。
         // CREW_AUTO_RUN=0 可以关掉这个行为（只想手动派的时候）。
+        //
+        // ★ 不 await：worker 一张单可能跑十分钟，等它就把整圈堵死了（新单收不到、
+        //   心跳也停）。这里只把「谁在跑」记进 running，跑完由回调收尾。
         if (process.env.CREW_AUTO_RUN !== '0') {
-          const queued = loadAllTickets().filter((t) => t.state === 'queued');
+          // 一次能同时开几个 worker。每张单是一个独立的 headless 进程（独立上下文、
+          // 独立工作目录），并行才叫团队；但每个进程都吃内存，所以要有个上限。
+          const MAX_WORKERS = Math.max(1, Number(process.env.CREW_MAX_WORKERS || 3));
+          const room = MAX_WORKERS - running.size;
+          const queued = room > 0
+            ? loadAllTickets().filter((t) => t.state === 'queued' && !running.has(t.id)).slice(0, room)
+            : [];
           for (const q of queued) {
+            running.add(q.id);
             console.log(`⏳ 接管待办 ${q.id} ${q.title}`);
             bumpHeartbeat({ note: `接管待办 ${q.id}：${q.title}` });
-            const done = await runTicket(q.id);
-            if (!done) { console.log('  （被别的进程抢走了）'); continue; }
-            console.log(`  → ${done.state}  ${(done.result || done.error || '').slice(0, 120)}`);
-            if (done.chatKey) {
-              const rr = await reply(done);
-              console.log(`  结果回传：${rr.status}`);
-            }
-            bumpHeartbeat({ note: `${q.id} ${done.state}` });
+            (async () => {
+              try {
+                const done = await runTicket(q.id);
+                if (!done) { console.log('  （被别的进程抢走了）'); return; }
+                console.log(`  → ${done.state}  ${(done.result || done.error || '').slice(0, 120)}`);
+                if (done.chatKey) {
+                  const rr = await reply(done);
+                  console.log(`  结果回传：${rr.status}`);
+                }
+                bumpHeartbeat({ note: `${q.id} ${done.state}` });
+              } catch (e) {
+                console.log(`  ✗ ${q.id} 出错：${e.message}`);
+                bumpHeartbeat({ note: `${q.id} 出错：${e.message}` });
+              } finally {
+                running.delete(q.id);
+              }
+            })();
           }
         }
 
-        const r = await intake();
-        if (r.made.length || r.failed.length) showJudged(r);
-        for (const t of r.made) {
-          console.log(`▶ ${t.id} ${t.title}`);
-          bumpHeartbeat({ note: `正在干 ${t.id}：${t.title}` });
-          const done = await runTicket(t.id);
-          if (!done) { console.log('  （被别的进程抢走了）'); continue; }
-          const rr = await reply(done);
-          console.log(`  结果回传：${rr.status}${rr.status >= 300 ? ` —— ${String(rr.body).slice(0, 120)}` : ''}`);
-          bumpHeartbeat({ note: `${t.id} 干完，结果回传 ${rr.status}` });
+        // 耳朵还挂着吗？桥没跑就别对着那份冻结的文件继续听 —— 但只跳 QQ 这一段，
+        // 上面的「接管待办」和下面的循环照旧，工作区的活不受影响。
+        const up = await bridgeAlive();
+        if (!up) {
+          qqDownRounds += 1;
+          bumpHeartbeat({
+            qq: false,
+            note: qqDownRounds === 1
+              ? 'QQ 入口断了（surfcore 桥没在跑）· 只盯工作区'
+              : `QQ 入口断着（已 ${qqDownRounds} 轮）· 只盯工作区`,
+          });
+        } else {
+          qqDownRounds = 0;
+          bumpHeartbeat({ qq: true });
+          const r = await intake();
+          if (r.made.length || r.failed.length) showJudged(r);
+          for (const t of r.made) {
+            if (running.has(t.id)) continue;
+            // ★ 这里也不能 await：一张 QQ 单跑十分钟，等的就是这个「耳朵」被堵死的样子。
+            //   丢进后台、记进 running，跑完（含回传）由回调收尾。
+            running.add(t.id);
+            console.log(`▶ ${t.id} ${t.title}`);
+            bumpHeartbeat({ note: `正在干 ${t.id}：${t.title}` });
+            (async () => {
+              try {
+                const done = await runTicket(t.id);
+                if (!done) { console.log('  （被别的进程抢走了）'); return; }
+                const rr = await reply(done);
+                console.log(`  结果回传：${rr.status}${rr.status >= 300 ? ` —— ${String(rr.body).slice(0, 120)}` : ''}`);
+                bumpHeartbeat({ note: `${t.id} 干完，结果回传 ${rr.status}` });
+              } catch (e) {
+                console.log(`  ✗ ${t.id} 出错：${e.message}`);
+                bumpHeartbeat({ note: `${t.id} 出错：${e.message}` });
+              } finally {
+                running.delete(t.id);
+              }
+            })();
+          }
         }
       } catch (e) {
         console.error('这一轮出错：', e.message);

package/crew.mjs

@@ -126,7 +126,14 @@ function loadOne(id) {
 }
 
 function newId() {
-  return 'T' + Date.now().toString(36).toUpperCase() + Math.random().toString(36).slice(2, 4).toUpperCase();
+  // 原来只有 2 位随机后缀，同一毫秒内连开几张单有小概率撞号 —— 撞上就是
+  // 后一张覆盖前一张的 JSON。改成 8 位后缀 + 落盘前确认文件确实不存在。
+  for (let i = 0; i < 20; i++) {
+    const id = 'T' + Date.now().toString(36).toUpperCase()
+             + Math.random().toString(36).slice(2, 10).toUpperCase();
+    if (!fs.existsSync(tpath(id))) return id;
+  }
+  throw new Error('生成工单号失败：连续 20 次都撞上了（系统时间被拨回去了？）');
 }
 
 export function addTicket({ title, body, cwd, source = 'cli', requester = '', chatKey = '', msgId = '' }) {
@@ -184,8 +191,14 @@ function acquireLock(id) {
     try { holder = Number(fs.readFileSync(p, 'utf8')) || 0; } catch { /* 读不到就当死的 */ }
     if (!pidAlive(holder)) {
       log(`发现 ${id} 的陈旧锁（pid ${holder || '未知'} 已不在），抢过来`);
-      try { fs.unlinkSync(p); } catch { /* 别人先删了也行 */ }
-      try { return write(); } catch { return null; }
+      // 删锁和重建之间有个空窗：另一个进程可能正好在这时抢到。抢不到就重试，
+      // 连试三次还不行就认输 —— 不重试的话，两个进程同时发现陈旧锁时，
+      // 其中一个会白等一整轮才等到下次机会。
+      for (let i = 0; i < 3; i++) {
+        try { fs.unlinkSync(p); } catch { /* 别人先删了也行 */ }
+        try { return write(); } catch { /* 又被人抢了，再试 */ }
+      }
+      return null;
     }
     return null;
   }
@@ -356,7 +369,12 @@ function runWorkerOnce(ticket, onSpawn, liveFile, onWarn) {
       err += `\n[crew] worker 超过 ${Math.round(TIMEOUT / 1000)} 秒仍未结束，已强杀整棵进程树`;
       feed(`\n[crew] 超过 ${Math.round(TIMEOUT / 1000)} 秒未结束，超时强杀\n`);
       try {
-        spawn('taskkill', ['/PID', String(child.pid), '/T', '/F'], { windowsHide: true });
+        const tk = spawn('taskkill', ['/PID', String(child.pid), '/T', '/F'], { windowsHide: true });
+        // spawn 的失败是异步 'error' 事件，外面这层 try/catch 抓不到 —— 没人监听就是
+        // 未捕获异常，会把值守整个带崩（而此刻可能还有别的 worker 在跑），
+        // 本该兜底的 child.kill 也永远走不到。
+        tk.on('error', () => { try { child.kill('SIGKILL'); } catch { /* 尽力而为 */ } });
+        tk.on('close', (c) => { if (c !== 0) { try { child.kill('SIGKILL'); } catch { /* 尽力而为 */ } } });
       } catch {
         try { child.kill('SIGKILL'); } catch { /* 尽力而为 */ }
       }
@@ -369,9 +387,16 @@ function runWorkerOnce(ticket, onSpawn, liveFile, onWarn) {
     child.stdout.on('data', (d) => { checkMojibake(d); if (out.length < MAX_OUT) out += d; feed(d); });
     child.stderr.on('data', (d) => { checkMojibake(d); if (err.length < MAX_OUT) err += d; feedErr(d); });
 
-    child.on('error', (e) => { clearTimeout(timer); resolve({ rc: -1, out: cap(out), err: cap(err + '\n' + e.message), seconds: 0, pid: child.pid }); });
-    child.on('close', (rc) => { clearTimeout(timer); resolve({ rc, out: cap(out), err: cap(err), seconds: (Date.now() - started) / 1000, pid: child.pid }); });
-    process.once('exit', () => { if (!killed && child.pid) { killed = true; try { child.kill(); } catch { /* 尽力而为 */ } } });
+    // ★ exit 兜底必须在收尾时摘掉。它是每派一张单加一个监听器，而 process 默认上限
+    //   10 个 —— 值守跑十几张单就开始刷 MaxListenersExceededWarning；更糟的是每个
+    //   监听器都攥着 child（连带它的 stdout/stderr 缓冲，各上限 1MB），已完成的单
+    //   输出永远不回收，值守内存只涨不落。
+    const onExit = () => { if (!killed && child.pid) { killed = true; try { child.kill(); } catch { /* 尽力而为 */ } } };
+    process.once('exit', onExit);
+    const unhook = () => { try { process.removeListener('exit', onExit); } catch { /* 尽力而为 */ } };
+
+    child.on('error', (e) => { clearTimeout(timer); unhook(); resolve({ rc: -1, out: cap(out), err: cap(err + '\n' + e.message), seconds: 0, pid: child.pid }); });
+    child.on('close', (rc) => { clearTimeout(timer); unhook(); resolve({ rc, out: cap(out), err: cap(err), seconds: (Date.now() - started) / 1000, pid: child.pid }); });
   });
 }
 
@@ -527,15 +552,27 @@ async function main() {
     console.log('  下一步： node crew.mjs run');
   } else if (cmd === 'run') {
     const all = !!opts.all;
-    do {
-      const q = pending();
-      if (!q.length) { console.log('没有排队的工单。'); break; }
+    // ★ 抢不到锁时不能直接 continue：pending() 仍然会把那张单排在第一，于是
+    //   do/while 原地空转，CPU 打满却什么也不干（review.md #6）。记下来跳过。
+    const skipped = new Set();
+    for (;;) {
+      const q = pending().filter((t) => !skipped.has(t.id));
+      if (!q.length) {
+        console.log(skipped.size ? '剩下的都被别的进程处理着。' : '没有排队的工单。');
+        break;
+      }
       const t = q[0];
       console.log(`▶ 派工 ${t.id}：${t.title}`);
       const done = await runTicket(t.id);
-      if (!done) { console.log('  （被别的进程抢走了，换下一张）'); continue; }
+      if (!done) {
+        skipped.add(t.id);
+        console.log('  （被别的进程抢走了，跳过这张）');
+        continue;
+      }
       console.log(`  ${done.state === 'done' ? '✔ 完成' : '✘ 失败'}  ${done.state === 'done' ? done.result.slice(0, 200) : done.error}`);
-    } while (all);
+      skipped.clear(); // 干完一张，之前卡住的单可能已经松手了，重新扫一遍
+      if (!all) break;
+    }
   } else if (cmd === 'requeue') {
     const staleMin = Number(typeof opts.stale === 'string' ? opts.stale : STALE_MIN);
     const moved = requeueStale({ staleMin, id: typeof opts.id === 'string' ? opts.id : null });

package/lib/router.mjs

@@ -74,6 +74,7 @@ export async function judge(text, { context = '' } = {}) {
       const r = await askOnce(model, user);
       if (r.ok) {
         return {
+          ok: true,
           isTask: !!r.o.isTask,
           title: (r.o.title || '').slice(0, 40),
           body: r.o.body || text,
@@ -86,7 +87,10 @@ export async function judge(text, { context = '' } = {}) {
       tried.push(`${model}: ${e.message}`);
     }
   }
-  return { isTask: false, reason: '所有模型都没判出来（保守放过）', tried };
+  // ★ 这里必须和「真的是闲聊」分开：调用方（crew-watch）只对 ok:true 且 isTask:false
+  //   的消息记 seen。判不出来还记 seen 的话，网关卡一下、超时一次，那批需求就被
+  //   永久吞掉了 —— 下次再扫到也不认。
+  return { ok: false, isTask: null, reason: '所有模型都没判出来（保守放过，不记 seen）', tried };
 }
 
 // 直接命令行跑：node router.mjs "帮我写个 python 脚本算质数"

package/package.json

@@ -1,79 +1,81 @@
-{
-  "name": "dsh-supercrew",
-  "version": "0.1.5",
-  "private": false,
-  "type": "module",
-  "description": "给 DeepSeek Harness 装一个团队：收需求 → 门卫判断 → 开工单 → 派独立 worker 干活 → 结果回报。模型可配（默认用你当前在用的，免费池当备选），不依赖 tmux。",
-  "keywords": [
-    "dsh",
-    "dsh-plugin",
-    "deepseek-harness",
-    "agent",
-    "orchestration",
-    "multi-agent",
-    "teams",
-    "superagent",
-    "task-queue"
-  ],
-  "license": "MIT",
-  "author": "dafeiyu",
-  "engines": {
-    "node": ">=22.19.0",
-    "dsh": ">=0.2.2-rc.1"
-  },
-  "main": "lib/index.js",
-  "exports": {
-    ".": "./lib/index.js",
-    "./client": "./client.js"
-  },
-  "bin": {
-    "supercrew": "./bin/supercrew.mjs"
-  },
-  "dsh": {
-    "bundle": {
-      "patch": "./cordis.patch.yml"
-    },
-    "client": {
-      "platform": "web",
-      "immediately": true,
-      "inject": ["@deepseek-ai/dsh-client-ui-conversation"]
-    }
-  },
-  "files": [
-    "lib/",
-    "bin/",
-    "skills/",
-    "panel.mjs",
-    "crew.mjs",
-    "crew-watch.mjs",
-    "client.js",
-    "worker-models.yml",
-    "cordis.patch.yml",
-    "crew_guard.ps1",
-    "README.md",
-    "INSTALL.md",
-    "DESIGN.md",
-    "LICENSE",
-    "selftest.mjs",
-    "worker-brief.md"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "panel": "node panel.mjs",
-    "watch": "node crew-watch.mjs loop",
-    "selftest": "node selftest.mjs",
-    "check": "node --check crew.mjs && node --check crew-watch.mjs && node --check panel.mjs && node --check client.js && node --check lib/index.js && node --check lib/router.mjs && node --check bin/supercrew.mjs",
-    "selftest:quick": "node selftest.mjs --quick",
-    "work": "node crew.mjs work"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/wesqaz111/dsh-supercrew.git"
-  },
-  "homepage": "https://github.com/wesqaz111/dsh-supercrew#readme",
-  "bugs": {
-    "url": "https://github.com/wesqaz111/dsh-supercrew/issues"
-  }
-}
+{
+  "name": "dsh-supercrew",
+  "version": "0.1.8",
+  "private": false,
+  "type": "module",
+  "description": "给 DeepSeek Harness 装一个团队：收需求 → 门卫判断 → 开工单 → 派独立 worker 干活 → 结果回报。模型可配（默认用你当前在用的，免费池当备选），不依赖 tmux。",
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "agent",
+    "orchestration",
+    "multi-agent",
+    "teams",
+    "superagent",
+    "task-queue"
+  ],
+  "license": "MIT",
+  "author": "dafeiyu",
+  "engines": {
+    "node": ">=22.19.0",
+    "dsh": ">=0.2.2-rc.1"
+  },
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./client.js"
+  },
+  "bin": {
+    "supercrew": "./bin/supercrew.mjs"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-conversation"
+      ]
+    }
+  },
+  "files": [
+    "lib/",
+    "bin/",
+    "skills/",
+    "panel.mjs",
+    "crew.mjs",
+    "crew-watch.mjs",
+    "client.js",
+    "worker-models.yml",
+    "cordis.patch.yml",
+    "crew_guard.ps1",
+    "README.md",
+    "INSTALL.md",
+    "DESIGN.md",
+    "LICENSE",
+    "selftest.mjs",
+    "worker-brief.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "panel": "node panel.mjs",
+    "watch": "node crew-watch.mjs loop",
+    "selftest": "node selftest.mjs",
+    "check": "node --check crew.mjs && node --check crew-watch.mjs && node --check panel.mjs && node --check client.js && node --check lib/index.js && node --check lib/router.mjs && node --check bin/supercrew.mjs",
+    "selftest:quick": "node selftest.mjs --quick",
+    "work": "node crew.mjs work"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wesqaz111/dsh-supercrew.git"
+  },
+  "homepage": "https://github.com/wesqaz111/dsh-supercrew#readme",
+  "bugs": {
+    "url": "https://github.com/wesqaz111/dsh-supercrew/issues"
+  }
+}

package/panel.mjs

@@ -19,7 +19,8 @@
 import http from 'node:http';
 import fs from 'node:fs';
 import path from 'node:path';
-import { loadAllTickets, addTicket, runTicket } from './crew.mjs';
+import { loadAllTickets, addTicket, saveTicket, runTicket } from './crew.mjs';
+import { judge } from './lib/router.mjs';
 
 function argPort() {
   const argv = process.argv.slice(2);
@@ -44,9 +45,14 @@ function tail(file, maxBytes = 24 * 1024) {
     const from = Math.max(0, st.size - maxBytes);
     const fd = fs.openSync(file, 'r');
     try {
+      // readSync 只保证「最多读这么多」，短读时缓冲区尾部是未写入的 \0 —— 直接
+      // 全域 toString 会把一串 NUL 塞进浏览器。用返回值 n 截断。
       const buf = Buffer.alloc(Math.min(maxBytes, st.size - from));
-      fs.readSync(fd, buf, 0, buf.length, from);
-      return buf.toString('utf8');
+      const n = fs.readSync(fd, buf, 0, buf.length, from);
+      let s = buf.subarray(0, n).toString('utf8');
+      // from > 0 时起点很可能劈开一个汉字，开头会出现  或半行 —— 丢掉第一行残片
+      if (from > 0) s = s.replace(/^[^\n]*\n/, '');
+      return s;
     } finally { fs.closeSync(fd); }
   } catch { return ''; }
 }
@@ -363,6 +369,20 @@ const server = http.createServer(async (req, res) => {
     res.end(JSON.stringify(o));
   };
   try {
+    // ★ 防跨站派工：本机任意网页都能 POST 到这里，而 /api/add 会立刻派一个
+    //   --permission-mode danger-full-access 的 worker —— 等于「打开一个网页就能让
+    //   这台机器执行任意命令」。浏览器发起的请求一定带 Origin，本机脚本不会带。
+    //   所以：写操作（POST）带 Origin 一律拒；再要求 content-type 是 application/json
+    //   （simple request 只能发 text/plain，加这一条把不触发预检的那条路也堵掉）。
+    //   读操作（GET）不拦 —— 会话头部那枚胶囊就是从 DSH 页面跨端口来读心跳的。
+    if (req.method === 'POST') {
+      if (req.headers.origin) {
+        return json({ error: '拒绝来自浏览器的写调用（防跨站派工）；请用本机脚本或 crew.mjs' }, 403);
+      }
+      if (!String(req.headers['content-type'] || '').includes('application/json')) {
+        return json({ error: 'content-type 必须是 application/json' }, 415);
+      }
+    }
     if (req.method === 'GET' && (url.pathname === '/' || url.pathname === '/index.html')) {
       res.writeHead(200, {
         'content-type': 'text/html; charset=utf-8',
@@ -395,7 +415,17 @@ const server = http.createServer(async (req, res) => {
           t.liveTail = lastLine(path.join(RUNS, `${t.id}.live.log`)) || '';
         }
       }
-      return json(list);
+      // ★ 只回列表要用的字段，result/error 截到 2000 字。整份可能是 1MB × 单数，
+      //   而前端只显示 600 字 —— 每 5 秒轮询传几 MB JSON，浏览器和 node 都会卡。
+      //   要看全文有 /api/live/:id。
+      return json(list.map((t) => ({
+        id: t.id, title: t.title, state: t.state, source: t.source,
+        createdAt: t.createdAt, startedAt: t.startedAt, finishedAt: t.finishedAt,
+        pid: t.pid, attempts: t.attempts, warn: t.warn, replyError: t.replyError,
+        liveTail: t.liveTail,
+        result: t.result ? String(t.result).slice(0, 2000) : null,
+        error: t.error ? String(t.error).slice(0, 2000) : null,
+      })));
     }
 
     if (req.method === 'GET' && url.pathname.startsWith('/api/live/')) {
@@ -444,6 +474,55 @@ const server = http.createServer(async (req, res) => {
       return json(t);
     }
 
+    // POST /api/ask —— 让「别的程序」把「有人叫我了」递进来。
+    //
+    // 为什么需要它：QQ 那边的入口原本架在 surfcore 桥上（读它写的 social-v2.json）。
+    // 桥停了以后，我们这边就收不到任何东西了。现在换一条不依赖桥的路：
+    // 谁听见了消息，就把它整句 POST 到这里，门卫在这里判 —— 是活就开单派出去，
+    // 是闲聊就只回一句「没开单」，不占工单列表。
+    if (req.method === 'POST' && url.pathname === '/api/ask') {
+      let raw = '';
+      for await (const c of req) raw += c;
+      let b = {};
+      try { b = JSON.parse(raw || '{}'); } catch { return json({ error: '请求体不是合法 JSON' }, 400); }
+      const text = String(b.text || '').trim();
+      if (!text) return json({ error: 'text 不能为空' }, 400);
+      const chatKey = b.chatKey ? String(b.chatKey) : '';
+      const from = b.from ? String(b.from) : '';
+
+      let j;
+      try {
+        j = await judge(text);
+      } catch (e) {
+        // 门卫挂了不该当成「那就干吧」—— 宁可漏，也不瞎干
+        return json({ isTask: null, error: `门卫没判出来：${e.message}` });
+      }
+      if (!j.isTask) {
+        return json({ isTask: false, why: j.reason || '', text: text.slice(0, 80) });
+      }
+
+      const t = addTicket({
+        body: j.body || text,
+        title: j.title || text.slice(0, 40),
+        cwd: b.cwd || process.env.CREW_WORKDIR || process.cwd(),
+        source: chatKey ? `qq:${chatKey}` : (b.source ? String(b.source) : 'ask'),
+        requester: from,
+        chatKey,                                   // 回话要用（reply 靠它找原会话）
+        msgId: b.msgId ? String(b.msgId) : '',
+      });
+      t.judged = { reason: j.reason, by: j.by, original: text };
+      saveTicket(t);
+
+      if (b.autoRun !== false && !running.has(t.id)) {
+        running.add(t.id);
+        runTicket(t.id)
+          .then((done) => { if (done) console.log(`[ask] ${t.id} → ${done.state}`); })
+          .catch((e) => console.error(`[ask] ${t.id} 派工出错：${e.message}`))
+          .finally(() => running.delete(t.id));
+      }
+      return json({ isTask: true, id: t.id, title: t.title, why: j.reason || '' });
+    }
+
     if (req.method === 'POST' && url.pathname.startsWith('/api/run/')) {
       const id = decodeURIComponent(url.pathname.slice('/api/run/'.length));
       if (!/^[A-Za-z0-9_-]+$/.test(id)) return json({ error: 'id 不合法' }, 400);
@@ -463,6 +542,18 @@ const server = http.createServer(async (req, res) => {
   }
 });
 
+// ★ 端口被占时 listen 的失败是异步事件 —— 没人监听就是未捕获异常，栈里只有
+//   EADDRINUSE，看不出是「谁」占了。
+server.on('error', (e) => {
+  if (e && e.code === 'EADDRINUSE') {
+    console.error(`端口 ${PORT} 已被占用：先跑 netstat -ano | findstr :${PORT} 看是谁，`
+                + `或者换一个 --port=<其他端口>。`);
+  } else {
+    console.error('看板起不来：', e);
+  }
+  process.exit(1);
+});
+
 server.listen(PORT, '127.0.0.1', () => {
   console.log(`团队看板：http://127.0.0.1:${PORT}/`);
   console.log(`数据目录：${HOME}`);

package/selftest.mjs

@@ -37,11 +37,28 @@ function check(name, ok, detail) {
 function run(cmd, args, opts = {}) {
   return new Promise((resolve) => {
     const p = spawn(cmd, args, { windowsHide: true, ...opts });
-    let out = '', err = '';
+    let out = '', err = '', done = false;
+    // ★ 不设编码时 chunk 边界会把中文劈成乱码 —— 下面「worker 读中文」那项就会
+    //   误报失败（自检说系统坏了，其实是自检自己坏了）。
+    p.stdout.setEncoding('utf8');
+    p.stderr.setEncoding('utf8');
+    // ★ 没有超时会永久挂住：worker 起浏览器不退时实测过，自检就卡在那儿不说话。
+    const limit = opts.timeoutMs || 120000;
+    const timer = setTimeout(() => {
+      if (done) return;
+      done = true;
+      try {
+        spawn('taskkill', ['/PID', String(p.pid), '/T', '/F'], { windowsHide: true })
+          .on('error', () => { /* 杀不掉就算了，至少不再等它 */ });
+      } catch { /* 尽力而为 */ }
+      resolve({ rc: -2, out, err: err + `\n（超过 ${limit}ms 未结束，已强杀）` });
+    }, limit);
+    if (timer.unref) timer.unref();
+    const finish = (r) => { if (done) return; done = true; clearTimeout(timer); resolve(r); };
     p.stdout.on('data', (d) => { out += d; });
     p.stderr.on('data', (d) => { err += d; });
-    p.on('error', (e) => resolve({ rc: -1, out, err: String(e.message) }));
-    p.on('close', (rc) => resolve({ rc, out, err }));
+    p.on('error', (e) => finish({ rc: -1, out, err: String(e.message) }));
+    p.on('close', (rc) => finish({ rc, out, err }));
   });
 }
 

package/worker-brief.md

@@ -7,7 +7,7 @@
 你手上有 **read / glob / grep 这些文件工具**，它们会自动处理编码。**读文件就用它们。**
 
 不要用 shell 去读文件 —— 尤其不要用 PowerShell 的 `Get-Content`：这台机器上它默认按
-GBK 解码，读 UTF-8 的中文文件会变乱码（`鈥斺€?` 这种），**而且行数也会算错**
+GBK 解码，读 UTF-8 的中文文件会变乱码（看起来像一堆方块、问号、`é–` 这类怪符号），**而且行数也会算错**
 （GBK 解码器会把换行字节当成多字节字符的一部分吃掉，几行会并成一行）。
 
 只有 read 工具做不了的事（数行数、批量统计），才用 **python**：
@@ -23,7 +23,7 @@ Python 在 `D:\Python312\python.exe`（**不在 PATH，要写全路径**）。
 
 动手之前，先确认你能正确读到中文：用 **read 工具**读一个含中文的文件，看一眼中文是不是正常的。
 
-若显示成 `鈥斺€?` 这类乱码，说明你走错路了 —— 换回 read 工具，或者用 python 指定 `encoding='utf-8'`。
+若显示成一堆怪符号（方块、问号、`é–` 之类），说明你走错路了 —— 换回 read 工具，或者用 python 指定 `encoding='utf-8'`。
 
 这 30 秒能省掉十分钟的绕圈。