dsh-supercrew 0.1.3 → 0.1.4

package/README.md

@@ -129,6 +129,10 @@ worker 以 `--permission-mode danger-full-access --approval-policy never` 跑：
 - 所以 `--cwd` 要指到具体项目目录，别指整个盘；触发词别设得太宽。
 - 要高隔离就在专门的 OS 账号里跑。
 
+## 交流群
+
+QQ 群：**1126694040**（DSH / supercrew 的问题都可以在这里问）
+
 ## 许可
 
 MIT

package/bin/supercrew.mjs

@@ -32,6 +32,7 @@ const ROOT = path.resolve(HERE, '..');
 const MAP = {
   panel: ['panel.mjs', null],
   watch: ['crew-watch.mjs', 'loop'],
+  work: ['crew.mjs', 'work'],
   add: ['crew.mjs', 'add'],
   run: ['crew.mjs', 'run'],
   list: ['crew.mjs', 'list'],
@@ -42,6 +43,7 @@ const MAP = {
   once: ['crew-watch.mjs', 'once'],
   loop: ['crew-watch.mjs', 'loop'],
   reply: ['crew-watch.mjs', 'reply'],
+  selftest: ['selftest.mjs', null],
 };
 
 const argv = process.argv.slice(2);
@@ -52,21 +54,22 @@ if (!cmd || cmd === '-h' || cmd === '--help') {
   console.log(`supercrew —— 工单制团队系统
 
   supercrew panel              起看板（默认 3090）
-  supercrew watch              守着 QQ 收需求、派活、回话
-  supercrew add "<需求>"       手工开工单（可加 --cwd <目录>）
+  supercrew watch              守着入口收需求、派活、回话
+  supercrew work "<活>"        工作区的活：开单并立刻派出去（可加 --cwd <目录>）
+  supercrew add "<需求>"       只开单，不派（可加 --cwd <目录>）
   supercrew run [--all]        派工
   supercrew list               看所有工单
   supercrew requeue            把卡住的工单放回队列
-  supercrew scan | judge       只看群里有什么 / 门卫怎么判
-  supercrew selftest           自检
+  supercrew scan | judge       只看入口有什么 / 门卫怎么判
+  supercrew selftest           装完先跑这个：连「worker 能不能正确读写中文」一起测
 
 环境变量见 README。`);
   process.exit(0);
 }
 
-if (cmd === 'selftest') {
-  cmd = 'add';
-  extra = ['在当前目录创建文件 hello.txt，内容写一句你好', '--cwd', ROOT];
+if (cmd === 'selftest' && extra.includes('--quick')) {
+  // 只查环境与进程，不真派 worker —— 快
+  cmd = 'selftest';
 }
 
 const entry = MAP[cmd];

package/crew-watch.mjs

@@ -93,6 +93,31 @@ export function stripTrigger(text) {
   return text.replace(new RegExp(TRIGGER.source, 'g'), '').replace(/^[\s:：,，.。!！?？-]+/, '').trim();
 }
 
+// 心跳：让别人（看板）看得出"值守还活着、它刚扫过什么"。
+// 没有这个的话，看板上「没有在干的单」和「值守已经死了」长得一模一样。
+const HEARTBEAT = path.join(
+  process.env.CREW_HOME || path.join(process.env.USERPROFILE || '.', '.dsh-supercrew'),
+  'watch-heartbeat.json');
+
+function bumpHeartbeat(patch = {}) {
+  let h = {};
+  try { h = JSON.parse(fs.readFileSync(HEARTBEAT, 'utf8')); } catch { h = {}; }
+  const now = new Date().toISOString();
+  h.at = now;
+  h.pid = process.pid;
+  h.rounds = (h.rounds || 0) + (patch.round ? 1 : 0);
+  h.uptimeSec = h.startedAt ? Math.round((Date.parse(now) - Date.parse(h.startedAt)) / 1000) : 0;
+  if (!h.startedAt) h.startedAt = now;
+  // 累计计数（看板顶部那几个数字）
+  for (const k of ['seen', 'opened', 'blocked', 'failed']) {
+    if (patch[k]) h[k] = (h[k] || 0) + patch[k];
+  }
+  if (patch.recent) h.recent = patch.recent.slice(0, 12);
+  if (patch.note) h.note = patch.note;
+  try { saveJson(HEARTBEAT, h); } catch { /* 心跳写不进去不该影响值守 */ }
+  return h;
+}
+
 function seenSet() { return new Set(loadJson(SEEN, [])); }
 function markSeen(keys) {
   const s = seenSet();
@@ -164,6 +189,23 @@ export async function intake({ dryRun = false, concurrency = 4 } = {}) {
   await Promise.all(lanes);
 
   if (!dryRun) markSeen(found.map(seenKey));
+
+  // 记心跳：这一轮扫到几条、开了几单、拦下几条、判过的都长什么样
+  if (!dryRun) {
+    const recent = [
+      ...made.map((t) => ({ text: (t.judged && t.judged.original) || t.body, isTask: true, title: t.title })),
+      ...skipped.map((s) => ({ text: s.text, isTask: false, why: s.why })),
+    ].slice(0, 12);
+    bumpHeartbeat({
+      round: true,
+      seen: found.length,
+      opened: made.length,
+      blocked: skipped.length,
+      failed: failed.length,
+      recent,
+      note: found.length ? '' : '这一轮没人叫我',
+    });
+  }
   return { made, skipped, failed };
 }
 
@@ -261,19 +303,42 @@ async function main() {
     }
   } else if (cmd === 'loop') {
     console.log('守着…… Ctrl+C 退出');
+    bumpHeartbeat({ note: '值守起来了' });     // 先写一条，让看板立刻看到它还活着
     for (;;) {
       try {
+        // 先接管「开了但没人派」的单 —— 从看板输入框、CLI 丢进来的活都落在 queued，
+        // 以前必须有人去点卡片上的按钮才会跑，所以看起来像「它一点不干」。
+        // CREW_AUTO_RUN=0 可以关掉这个行为（只想手动派的时候）。
+        if (process.env.CREW_AUTO_RUN !== '0') {
+          const queued = loadAllTickets().filter((t) => t.state === 'queued');
+          for (const q of queued) {
+            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}` });
+          }
+        }
+
         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}` });
         }
       } catch (e) {
         console.error('这一轮出错：', e.message);
+        bumpHeartbeat({ note: `这一轮出错：${e.message}` });
       }
       await new Promise((r) => setTimeout(r, 15000));
     }

package/crew.mjs

@@ -255,7 +255,24 @@ function modelPatchFile() {
 }
 
 // ── 派工：起一个 worker（headless 一次性会话）─────────────────────────────
-function runWorkerOnce(ticket, onSpawn) {
+// liveFile：worker 一边跑一边把输出追加进去，看板靠它显示「它现在在干什么」。
+// 不给就只把结果留在内存里（老行为）。
+
+/**
+ * 把「这台机器的常识」拼在活前面。
+ * 不拼的话 worker 会用 PowerShell 的 Get-Content 读中文文件，踩进 GBK 乱码里绕圈
+ * （实测一次「统计 .mjs 行数」的活，它花五分钟在推理编码问题，最后没产出）。
+ */
+function withBrief(body) {
+  try {
+    const brief = fs.readFileSync(path.join(__dirname, 'worker-brief.md'), 'utf8');
+    return `${brief}\n\n---\n\n# 你这次的活\n\n${body}`;
+  } catch {
+    return body;
+  }
+}
+
+function runWorkerOnce(ticket, onSpawn, liveFile, onWarn) {
   return new Promise((resolve) => {
     const dsh = findDsh();
     const patches = [PATCH];
@@ -264,7 +281,7 @@ function runWorkerOnce(ticket, onSpawn) {
 
     const args = ['--profile', WORKER_PROFILE];
     for (const p of patches) args.push('--patch', p);
-    args.push('--permission-mode', 'danger-full-access', '--approval-policy', 'never', ticket.body);
+    args.push('--permission-mode', 'danger-full-access', '--approval-policy', 'never', withBrief(ticket.body));
 
     const started = Date.now();
     const L = resolveLaunch(dsh);
@@ -289,12 +306,55 @@ function runWorkerOnce(ticket, onSpawn) {
 
     let out = '', err = '', killed = false;
 
+    // 实时日志：先写个头（含 pid 与开始时间），之后逐块追加。
+    // 写失败只忽略 —— 看不到实时输出，但活照干。
+    if (liveFile) {
+      try {
+        fs.writeFileSync(liveFile,
+          `# ${ticket.id}\n# cwd: ${ticket.cwd}\n# pid: ${child.pid}\n# started: ${new Date().toISOString()}\n\n`,
+          'utf8');
+      } catch { /* 忽略 */ }
+    }
+    const feed = (s) => {
+      if (!liveFile) return;
+      try { fs.appendFileSync(liveFile, s, 'utf8'); } catch { /* 忽略 */ }
+    };
+
+    // ── 绕圈检测 ────────────────────────────────────────────────────────
+    // 最常见的一个坑：worker 用 PowerShell 读中文文件，GBK 解码出乱码之后
+    // 开始长篇推理「到底是 UTF-8 还是行数算错了」，几分钟过去什么产出都没有。
+    // 一在输出里看到典型乱码就把这张单标上 warn，看板顶一条黄牌 ——
+    // 这样别人装上跑出问题，不用翻日志也知道卡在哪。
+    const MOJIBAKE = /鈥|锟斤拷|锟|\uFFFD\uFFFD/;
+    let mojibake = false;
+    const checkMojibake = (s) => {
+      if (mojibake || !MOJIBAKE.test(s)) return;
+      mojibake = true;
+      feed('\n[crew] ⚠️ 输出里出现编码乱码（鈥…）—— worker 八成在用 shell 读中文文件，'
+         + '而不是 read 工具。它接下来的推理很可能都在绕这个坑。\n');
+      if (typeof onWarn === 'function') {
+        try {
+          onWarn('worker 读中文时踩了编码坑（可能用了 shell 而不是 read 工具）');
+        } catch { /* 标注失败不影响干活 */ }
+      }
+    };
+    // stderr 是 worker 的思考过程（headless 把推理写那儿），stdout 是结果。
+    // 只在第一次出现 stderr 时插一条分隔线 —— 给每个 chunk 都加前缀的话，
+    // chunk 边界会把一句话切碎，看起来像 [stderr] xxx[stderr] yyy。
+    let sawErr = false;
+    const feedErr = (s) => {
+      if (!liveFile) return;
+      if (!sawErr) { sawErr = true; feed('\n—— worker 的思考（stderr）——\n'); }
+      feed(s);
+    };
+
     // 超时保护：worker 自己卡住时（实测常见于它起的浏览器进程没退出）不能让工单
     // 永远挂在 working。超时就整棵进程树杀掉。默认 10 分钟，CREW_TIMEOUT_MS 可调。
     const TIMEOUT = Number(process.env.CREW_TIMEOUT_MS || 10 * 60 * 1000);
     const timer = setTimeout(() => {
       killed = true;
       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 });
       } catch {
@@ -306,8 +366,8 @@ function runWorkerOnce(ticket, onSpawn) {
     child.stdout.setEncoding('utf8');
     child.stderr.setEncoding('utf8');
     const cap = (s) => (s.length > MAX_OUT ? s.slice(0, MAX_OUT) + `\n…（超过 ${MAX_OUT} 字节已截断）` : s);
-    child.stdout.on('data', (d) => { if (out.length < MAX_OUT) out += d; });
-    child.stderr.on('data', (d) => { if (err.length < MAX_OUT) err += d; });
+    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 }); });
@@ -344,6 +404,14 @@ export async function runTicket(id, { force = false } = {}) {
       } catch (e) {
         log(`记 pid 失败（不影响干活）: ${e.message}`);
       }
+    }, path.join(DIRS.runs, `${t.id}.live.log`), (msg) => {
+      // 绕圈检测报上来的问题 → 落进工单，看板顶上会显示一条黄牌
+      try {
+        const cur = loadOne(id);
+        cur.warn = msg;
+        cur.updatedAt = new Date().toISOString();
+        save(cur);
+      } catch { /* 标注失败不影响干活 */ }
     });
 
     // 日志名带上时间戳，避免并发重试互相覆盖（attempts 只在本进程内递增）
@@ -496,6 +564,34 @@ async function main() {
     t.finishedAt = new Date().toISOString();
     save(t);
     console.log(`${id} → ${t.state}`);
+  } else if (cmd === 'work') {
+    // 「工作区的活」：主会话（我）接到活之后，用这个把活交给团队系统去干。
+    // 默认工作目录就是当前目录，来源记成 workspace，开完单立刻派出去。
+    const body = positional.join(' ').trim();
+    if (!body) {
+      console.error('用法：node crew.mjs work "<活>" [--cwd <目录>] [--title <标题>] [--no-run]');
+      process.exitCode = 2;
+      return;
+    }
+    const cwd = typeof opts.cwd === 'string' ? opts.cwd : process.cwd();
+    const t = addTicket({
+      body,
+      cwd,
+      title: typeof opts.title === 'string' ? opts.title : '',
+      source: 'workspace',
+    });
+    console.log(`${t.id} 已开工单（来源 workspace）`);
+    console.log(`  活：${t.title}`);
+    console.log(`  工作目录：${t.cwd}`);
+    if (opts['no-run']) {
+      console.log('  （--no-run：只开单，等值守或你自己派）');
+    } else {
+      console.log('  派出去干活……');
+      const done = await runTicket(t.id);
+      if (!done) { console.log('  （被别的进程抢走了）'); return; }
+      console.log(`  ${done.state === 'done' ? '✔ 干完了' : '✘ 失败了'}`);
+      console.log(`  ${String(done.state === 'done' ? done.result : done.error || '').slice(0, 800)}`);
+    }
   } else if (cmd === 'list') {
     const all = loadAll();
     if (!all.length) console.log('（还没有工单）');
@@ -506,8 +602,9 @@ async function main() {
     if (!fs.existsSync(tpath(id))) { console.error(`没有这张工单: ${id}`); process.exitCode = 1; return; }
     console.log(JSON.stringify(loadOne(id), null, 2));
   } else {
-    console.log('用法：node crew.mjs <add|run|list|show|note|done|requeue> ...');
-    console.log('  add "<需求>" [--cwd <目录>] [--title <标题>] [--source <来源>]   开工单');
+    console.log('用法：node crew.mjs <work|add|run|list|show|note|done|requeue> ...');
+    console.log('  work "<活>" [--cwd <目录>] [--title <标题>] [--no-run]          工作区的活：开单并立刻派出去');
+    console.log('  add "<需求>" [--cwd <目录>] [--title <标题>] [--source <来源>]   只开单，不派');
     console.log('  run [--all]                                                     派出去（起 headless worker）');
     console.log('  list | show <id>                                                看工单');
     console.log('  note <id> "<备注>"                                              给工单记一笔');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-supercrew",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "private": false,
   "type": "module",
   "description": "给 DeepSeek Harness 装一个团队：收需求 → 门卫判断 → 开工单 → 派独立 worker 干活 → 结果回报。模型可配（默认用你当前在用的，免费池当备选），不依赖 tmux。",
@@ -43,7 +43,9 @@
     "README.md",
     "INSTALL.md",
     "DESIGN.md",
-    "LICENSE"
+    "LICENSE",
+    "selftest.mjs",
+    "worker-brief.md"
   ],
   "publishConfig": {
     "access": "public"
@@ -51,8 +53,10 @@
   "scripts": {
     "panel": "node panel.mjs",
     "watch": "node crew-watch.mjs loop",
-    "selftest": "node crew.mjs add \"在当前目录创建文件 hello.txt，内容写一句你好\" && node crew.mjs run",
-    "check": "node --check crew.mjs && node --check crew-watch.mjs && node --check panel.mjs && node --check lib/index.js && node --check lib/router.mjs && node --check bin/supercrew.mjs"
+    "selftest": "node selftest.mjs",
+    "check": "node --check crew.mjs && node --check crew-watch.mjs && node --check panel.mjs && 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",
@@ -62,4 +66,4 @@
   "bugs": {
     "url": "https://github.com/wesqaz111/dsh-supercrew/issues"
   }
-}
+}

package/panel.mjs

@@ -2,8 +2,8 @@
 /**
  * crew-panel —— 团队系统的脸
  *
- * 一个只读为主的本地看板：待办 / 在干 / 已完成 / 失败。
- * 顺手能新建工单、能把待办的派出去。
+ * 一个本地看板：待办 / 在干 / 已完成 / 失败。
+ * 能新建工单、能把待办的派出去，**点开一张单能看它现在在干什么**（实时输出）。
  *
  * 用法：node panel.mjs [--port=3090]      （--port 3090 也认）
  * 环境变量：CREW_PANEL_PORT、CREW_HOME、CREW_WORKDIR
@@ -13,6 +13,8 @@
  *   - 派工能不能重复，靠的是内核的文件锁（crew.mjs 的 acquireLock），不是前端按钮。
  *     按钮的禁用只是让人看出来"已经派出去了"。
  *   - 工单标题和结果会进 HTML，esc 必须连引号一起转义（属性里也能注入）。
+ *   - 实时输出读的是 <CREW_HOME>/runs/<id>.live.log（worker 边跑边追加）。
+ *     只读尾部，别把整个大日志塞进浏览器。
  */
 import http from 'node:http';
 import fs from 'node:fs';
@@ -28,10 +30,35 @@ function argPort() {
   return Number(process.env.CREW_PANEL_PORT || 3090);
 }
 const PORT = argPort();
+const HOME = process.env.CREW_HOME || path.join(process.env.USERPROFILE || process.env.HOME || '.', '.dsh-supercrew');
+const RUNS = path.join(HOME, 'runs');
 
 // 正在跑的工单 id —— 只用于给前端一个即时反馈，真正的防重复在内核的锁里
 const running = new Set();
 
+/** 读实时日志的尾部；文件不在/读不动就回空。 */
+function tail(file, maxBytes = 24 * 1024) {
+  try {
+    const st = fs.statSync(file);
+    if (!st.isFile() || st.size === 0) return '';
+    const from = Math.max(0, st.size - maxBytes);
+    const fd = fs.openSync(file, 'r');
+    try {
+      const buf = Buffer.alloc(Math.min(maxBytes, st.size - from));
+      fs.readSync(fd, buf, 0, buf.length, from);
+      return buf.toString('utf8');
+    } finally { fs.closeSync(fd); }
+  } catch { return ''; }
+}
+
+/** 日志里最后一条有内容的行（给卡片做「最新动态」预览）。 */
+function lastLine(file) {
+  const t = tail(file, 8 * 1024);
+  if (!t) return '';
+  const lines = t.split(/\r?\n/).filter((l) => l.trim() && !l.startsWith('#'));
+  return lines.length ? lines[lines.length - 1].slice(0, 200) : '';
+}
+
 const HTML = String.raw`<!doctype html>
 <html lang="zh-CN"><head>
 <meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
@@ -46,11 +73,26 @@ const HTML = String.raw`<!doctype html>
   h1{margin:0;font-size:19px;font-weight:600;letter-spacing:.3px}
   .sub{color:var(--dim);font-size:12.5px}
   .err{color:var(--failed);font-size:12.5px}
+  .warn{margin-top:6px;padding:5px 8px;border-radius:6px;font-size:11.5px;line-height:1.45;
+        color:#ffd98a;background:rgba(255,179,71,.10);border:1px solid rgba(255,179,71,.30)}
+  /* 值守状态条：让人一眼看出「它在盯着」还是「它死了」 */
+  .watch{margin:8px 26px 0;display:flex;align-items:center;gap:9px;flex-wrap:wrap;
+       font-size:12.5px;color:#c3cbdd}
+  .watch .dot{width:9px;height:9px;border-radius:50%;background:#5c6478;flex:none}
+  .watch .dot.on{background:var(--done);box-shadow:0 0 8px rgba(67,209,158,.7);
+       animation:pulse 2s ease-in-out infinite}
+  .watch .dot.off{background:var(--failed)}
+  @keyframes pulse{0%,100%{opacity:1}50%{opacity:.35}}
+  .watch .dim{color:var(--dim)}
+  .watch.recent{margin-top:4px;padding-left:35px;flex-direction:column;align-items:flex-start;gap:2px}
+  .watch.recent .j{font-size:12px;color:var(--dim);white-space:nowrap;overflow:hidden;
+       text-overflow:ellipsis;max-width:min(1100px,92vw)}
+  .watch.recent .j b{color:#8fd6b4;font-weight:600}
+  .watch.recent .j i{color:#ffb347;font-style:normal}
   .bar{margin:10px 26px 0;display:flex;gap:8px;flex-wrap:wrap}
   input,button,textarea{font:inherit;color:var(--fg);background:#11151f;border:1px solid var(--line);
        border-radius:9px;padding:9px 12px;outline:none}
   input{flex:1;min-width:240px}
-  textarea{width:100%;min-height:64px;resize:vertical}
   button{cursor:pointer;background:#1d2334;transition:.15s}
   button:hover{background:#252c42;border-color:#37405a}
   button:disabled{opacity:.5;cursor:default}
@@ -61,17 +103,35 @@ const HTML = String.raw`<!doctype html>
   .col h2{margin:2px 4px 12px;font-size:13px;font-weight:600;color:var(--dim);letter-spacing:.5px;
        display:flex;justify-content:space-between}
   .card{background:var(--card);border:1px solid var(--line);border-radius:11px;padding:11px 12px;
-       margin-bottom:9px;border-left:3px solid var(--queued)}
+       margin-bottom:9px;border-left:3px solid var(--queued);cursor:pointer}
+  .card:hover{border-color:#37405a}
   .card[data-s=working]{border-left-color:var(--working)}
   .card[data-s=done]{border-left-color:var(--done)}
   .card[data-s=failed]{border-left-color:var(--failed)}
   .card .t{font-weight:600;margin-bottom:3px;word-break:break-word}
   .card .m{color:var(--dim);font-size:12px;display:flex;gap:8px;flex-wrap:wrap}
+  .card .live{margin-top:6px;font:11.5px/1.45 Consolas,monospace;color:#8fd6b4;
+       white-space:nowrap;overflow:hidden;text-overflow:ellipsis;opacity:.9}
   .card .r{margin-top:7px;padding-top:7px;border-top:1px dashed var(--line);color:#c9d2e6;
        font-size:12.5px;white-space:pre-wrap;max-height:150px;overflow:auto}
   .card button{margin-top:8px;padding:5px 10px;font-size:12px}
   .empty{color:#5c6478;font-size:12.5px;padding:6px 4px}
-  @media(max-width:1000px){.board{grid-template-columns:repeat(2,minmax(0,1fr))}}
+  /* 右侧抽屉：看单张工单的实时输出 */
+  #drawer{position:fixed;top:0;right:0;width:min(720px,60vw);height:100vh;background:#0e1119;
+       border-left:1px solid var(--line);box-shadow:-20px 0 60px rgba(0,0,0,.5);
+       transform:translateX(102%);transition:transform .22s ease;display:flex;flex-direction:column;z-index:9}
+  #drawer.open{transform:none}
+  #drawer .dh{padding:18px 20px 12px;border-bottom:1px solid var(--line)}
+  #drawer .dh h2{margin:0 0 6px;font-size:16px}
+  #drawer .dh .m{color:var(--dim);font-size:12px;display:flex;gap:10px;flex-wrap:wrap}
+  #drawer .dh button{position:absolute;top:16px;right:18px;padding:4px 10px}
+  #log{flex:1;overflow:auto;margin:0;padding:16px 20px;font:12px/1.6 Consolas,"Cascadia Mono",monospace;
+       white-space:pre-wrap;word-break:break-word;color:#c6d0e4;background:#0a0d14}
+  #log .err{color:#ff9aa4}
+  #drawer .df{padding:10px 20px;border-top:1px solid var(--line);color:var(--dim);font-size:12px;
+       display:flex;justify-content:space-between;gap:10px}
+  @media(max-width:1000px){.board{grid-template-columns:repeat(2,minmax(0,1fr))}
+    #drawer{width:100vw}}
 </style></head>
 <body>
 <header>
@@ -80,6 +140,13 @@ const HTML = String.raw`<!doctype html>
   <span class="err" id="err"></span>
 </header>
 
+<div class="watch" id="watch">
+  <span class="dot" id="w-dot"></span>
+  <span id="w-text">值守状态读取中…</span>
+  <span class="dim" id="w-counts"></span>
+</div>
+<div class="watch recent" id="w-recent"></div>
+
 <div class="bar">
   <input id="req" placeholder="丢一个需求进来，比如：把图片按日期整理成文件夹">
   <button class="primary" onclick="add()">开工单</button>
@@ -88,6 +155,16 @@ const HTML = String.raw`<!doctype html>
 
 <div class="board" id="board"></div>
 
+<aside id="drawer">
+  <div class="dh">
+    <button onclick="closeDrawer()">关闭</button>
+    <h2 id="d-title">—</h2>
+    <div class="m" id="d-meta"></div>
+  </div>
+  <pre id="log">（还没有输出）</pre>
+  <div class="df"><span id="d-foot"></span><span id="d-auto">每 1 秒刷新</span></div>
+</aside>
+
 <script>
 const COLS = [['queued','待办'],['working','在干'],['done','已完成'],['failed','失败']];
 // 引号也要转：卡片是拼字符串进 HTML 的，id/state 会落在属性里
@@ -98,6 +175,45 @@ const giveUp = (e) => {
   document.getElementById('err').textContent = '看板读不到数据：' + (e && e.message ? e.message : e);
 };
 
+let OPEN = null;        // 抽屉里正看哪张单
+let openTimer = null;
+
+// 值守状态：它是这套系统里唯一「一直在跑」的东西，得让人看得见
+async function loadWatch(){
+  let h;
+  try {
+    const r = await fetch('/api/heartbeat');
+    h = await r.json();
+  } catch { return; }
+  const dot = document.getElementById('w-dot');
+  const txt = document.getElementById('w-text');
+  const cnt = document.getElementById('w-counts');
+  const rec = document.getElementById('w-recent');
+
+  if (!h || !h.at) {
+    dot.className = 'dot off';
+    txt.textContent = '值守没在跑' + (h && h.note ? '：' + h.note : '');
+    cnt.textContent = '';
+    rec.innerHTML = '';
+    return;
+  }
+  const age = h.ageSec == null ? '?' : h.ageSec;
+  dot.className = 'dot ' + (h.alive ? 'on' : 'off');
+  txt.innerHTML = h.alive
+    ? '值守在盯着（' + age + ' 秒前扫过 · pid ' + (h.pid || '?') + '）'
+    : '值守的<b>心跳停了</b>（最后 ' + age + ' 秒前 · pid ' + (h.pid || '?') + '）';
+  if (h.note) txt.innerHTML += '　·　' + esc(h.note);
+  cnt.textContent = '累计：叫我 ' + (h.seen || 0) + ' 条 · 开单 ' + (h.opened || 0)
+    + ' 张 · 拦下闲聊 ' + (h.blocked || 0) + ' 条 · 第 ' + (h.rounds || 0) + ' 轮';
+  rec.innerHTML = (h.recent || []).slice(0, 6).map(function(x){
+    return '<div class="j">' + (x.isTask ? '<b>✔ 派活</b>' : '<i>· 拦下</i>') + '　'
+      + esc(String(x.text || '').slice(0, 90))
+      + (x.isTask ? (x.title ? '　→ ' + esc(x.title) : '')
+                  : (x.why ? '　← ' + esc(x.why) : ''))
+      + '</div>';
+  }).join('');
+}
+
 async function load(){
   let list;
   try {
@@ -111,9 +227,11 @@ async function load(){
 
   const by = {queued:[],working:[],done:[],failed:[]};
   for (const t of list) { (by[t.state] || by.queued).push(t); }
+  const busy = list.filter(t => t.state === 'working').length;
   document.getElementById('stat').textContent =
-    '共 ' + list.length + ' 张工单 · 待办 ' + by.queued.length + ' · 在干 ' + by.working.length
-    + ' · 完成 ' + by.done.length + ' · 失败 ' + by.failed.length;
+    '共 ' + list.length + ' 张工单 · 待办 ' + by.queued.length + ' · 在干 ' + busy
+    + ' · 完成 ' + by.done.length + ' · 失败 ' + by.failed.length
+    + (busy ? '　·　有活正在干' : '');
   const board = document.getElementById('board');
   board.innerHTML = COLS.map(function(pair){
     const k = pair[0], label = pair[1];
@@ -132,14 +250,27 @@ function card(t){
       + (busy ? '在干…' : '派出去') + '</button>'
     : '';
   const reply = t.replyError ? '<div class="m" style="color:var(--failed)">回传失败：' + esc(String(t.replyError).slice(0,120)) + '</div>' : '';
-  return '<article class="card" data-s="' + esc(t.state) + '"><div class="t">' + esc(t.title) + '</div>'
-    + '<div class="m"><span>' + esc(t.id) + '</span><span>' + when + '</span><span>' + esc(t.source || '') + '</span></div>'
-    + body + reply + go + '</article>';
+  // 绕圈黄牌：worker 在读中文/编码上踩坑时被 crew.mjs 标出来，外人不用翻日志就知道问题在哪
+  const warn = t.warn ? '<div class="warn">⚠️ ' + esc(String(t.warn).slice(0,160)) + '</div>' : '';
+  // 在干的单，把「它现在在干什么」的最后一行显示出来
+  const live = (busy && t.liveTail) ? '<div class="live">▸ ' + esc(t.liveTail) + '</div>' : '';
+  const secs = busy && t.pid ? '<span>pid ' + esc(t.pid) + '</span>' : '';
+  return '<article class="card" data-s="' + esc(t.state) + '" data-id="' + esc(t.id) + '">'
+    + '<div class="t">' + esc(t.title) + '</div>'
+    + '<div class="m"><span>' + esc(t.id) + '</span><span>' + when + '</span>' + secs
+    + '<span>' + esc(t.source || '') + '</span></div>'
+    + live + warn + body + reply + go + '</article>';
 }
 
 document.addEventListener('click', function(e){
-  const b = e.target && e.target.closest ? e.target.closest('button.go') : null;
-  if (b && !b.disabled) { b.disabled = true; b.textContent = '在干…'; run(b.dataset.id); }
+  const go = e.target && e.target.closest ? e.target.closest('button.go') : null;
+  if (go) {
+    e.stopPropagation();
+    if (!go.disabled) { go.disabled = true; go.textContent = '在干…'; run(go.dataset.id); }
+    return;
+  }
+  const c = e.target && e.target.closest ? e.target.closest('.card') : null;
+  if (c) openDrawer(c.dataset.id);
 });
 
 async function add(){
@@ -169,8 +300,56 @@ async function run(id){
   load();
 }
 
+// ── 抽屉：一张单的实时输出 ────────────────────────────────────────────
+function openDrawer(id){
+  OPEN = id;
+  document.getElementById('drawer').classList.add('open');
+  document.getElementById('log').textContent = '（读取中…）';
+  tick();
+  if (openTimer) clearInterval(openTimer);
+  openTimer = setInterval(tick, 1000);
+}
+function closeDrawer(){
+  OPEN = null;
+  document.getElementById('drawer').classList.remove('open');
+  if (openTimer) { clearInterval(openTimer); openTimer = null; }
+}
+async function tick(){
+  if (!OPEN) return;
+  let j;
+  try {
+    const r = await fetch('/api/live/' + encodeURIComponent(OPEN));
+    j = await r.json();
+    if (!r.ok) throw new Error(j && j.error ? j.error : ('HTTP ' + r.status));
+  } catch (e) {
+    document.getElementById('d-foot').textContent = '读不到：' + e.message;
+    return;
+  }
+  document.getElementById('d-title').textContent = j.title || j.id;
+  const meta = ['状态 ' + j.state, '来源 ' + (j.source || '—')];
+  if (j.pid) meta.push('pid ' + j.pid);
+  if (j.seconds != null) meta.push('已跑 ' + j.seconds + ' 秒');
+  if (j.attempts) meta.push('第 ' + j.attempts + ' 次');
+  if (j.cwd) meta.push(j.cwd);
+  document.getElementById('d-meta').textContent = meta.join('　·　');
+
+  const pre = document.getElementById('log');
+  const txt = j.log || '（还没有输出）';
+  const atBottom = pre.scrollTop + pre.clientHeight >= pre.scrollHeight - 40;
+  pre.textContent = txt;
+  if (atBottom) pre.scrollTop = pre.scrollHeight;   // 用户往上翻了就别硬拽回来
+  document.getElementById('d-foot').textContent =
+    j.state === 'working' ? '正在干…' : (j.state === 'done' ? '已完成' : (j.state === 'failed' ? '失败' : '待办'));
+  document.getElementById('d-auto').textContent = j.state === 'working' ? '每 1 秒刷新' : '已结束（停在最后状态）';
+}
+
 load();
 setInterval(load, 5000);
+loadWatch();
+setInterval(loadWatch, 3000);
+// ?open=<id> 直接打开那张单的实时输出（方便分享链接、也方便截图）
+const _sp = new URLSearchParams(location.search);
+if (_sp.get('open')) openDrawer(_sp.get('open'));
 </script></body></html>`;
 
 const server = http.createServer(async (req, res) => {
@@ -185,9 +364,52 @@ const server = http.createServer(async (req, res) => {
       return res.end(HTML);
     }
 
+    if (req.method === 'GET' && url.pathname === '/api/heartbeat') {
+      // 值守的心跳：没有它的话，「没在干的单」和「值守已经死了」在看板上长得一样
+      let h = null;
+      try { h = JSON.parse(fs.readFileSync(path.join(HOME, 'watch-heartbeat.json'), 'utf8')); }
+      catch { h = null; }
+      if (!h) return json({ alive: false, note: '值守还没写过心跳（没起来过，或 CREW_HOME 不对）' });
+      const ageSec = h.at ? Math.round((Date.now() - Date.parse(h.at)) / 1000) : null;
+      // 心跳超过 40 秒没更新 = 值守大概死了（它 15 秒一轮）
+      return json({
+        ...h,
+        ageSec,
+        alive: ageSec != null && ageSec < 40,
+      });
+    }
+
     if (req.method === 'GET' && url.pathname === '/api/tickets') {
       // loadAllTickets 自己会跳过坏文件；真抛错也让这里回 500 + 原因，而不是整个看板卡住
-      return json(loadAllTickets());
+      const list = loadAllTickets();
+      // 正在跑的单，附一行「它现在在干什么」给卡片预览
+      for (const t of list) {
+        if (t.state === 'working') {
+          t.liveTail = lastLine(path.join(RUNS, `${t.id}.live.log`)) || '';
+        }
+      }
+      return json(list);
+    }
+
+    if (req.method === 'GET' && url.pathname.startsWith('/api/live/')) {
+      const id = decodeURIComponent(url.pathname.slice('/api/live/'.length));
+      if (!/^[A-Za-z0-9_-]+$/.test(id)) return json({ error: 'id 不合法' }, 400);
+      const t = loadAllTickets().find((x) => x.id === id);
+      if (!t) return json({ error: '没有这张工单' }, 404);
+      const started = t.startedAt ? Date.parse(t.startedAt)
+                    : (t.updatedAt ? Date.parse(t.updatedAt) : null);
+      const endRef = t.state === 'working' ? Date.now()
+                   : (t.finishedAt ? Date.parse(t.finishedAt)
+                   : (t.updatedAt ? Date.parse(t.updatedAt) : null));
+      return json({
+        id: t.id, title: t.title, state: t.state, source: t.source, cwd: t.cwd,
+        pid: t.state === 'working' ? t.pid : null,
+        attempts: t.attempts,
+        seconds: started && endRef ? Math.max(0, Math.round((endRef - started) / 1000)) : null,
+        result: t.result, error: t.error, replyError: t.replyError, warn: t.warn || null,
+        log: tail(path.join(RUNS, `${t.id}.live.log`)) || (
+          t.result ? '## 结果\n' + t.result : (t.error ? '## 错误\n' + t.error : '')),
+      });
     }
 
     if (req.method === 'POST' && url.pathname === '/api/add') {
@@ -202,11 +424,22 @@ const server = http.createServer(async (req, res) => {
         cwd: b.cwd || process.env.CREW_WORKDIR || process.cwd(),
         source: 'panel',
       });
+      // 开完单就直接派出去 —— 以前还得再去点卡片上的按钮，
+      // 不点它就一直是「待办」，看着就像「它一点不干」。
+      // 想手动派就传 autoRun:false。
+      if (b.autoRun !== false && !running.has(t.id)) {
+        running.add(t.id);
+        runTicket(t.id)
+          .then((done) => { if (done) console.log(`[panel] ${t.id} → ${done.state}`); })
+          .catch((e) => console.error(`[panel] ${t.id} 自动派工出错：${e.message}`))
+          .finally(() => running.delete(t.id));
+      }
       return json(t);
     }
 
     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);
       if (running.has(id)) return json({ started: false, reason: '这张工单已经在派了' });
       running.add(id);
       // 后台跑：同步等会把浏览器请求挂住好几分钟，而且拿不到中途状态
@@ -225,5 +458,5 @@ const server = http.createServer(async (req, res) => {
 
 server.listen(PORT, '127.0.0.1', () => {
   console.log(`团队看板：http://127.0.0.1:${PORT}/`);
-  console.log(`数据目录：${process.env.CREW_HOME || '(默认)'}`);
+  console.log(`数据目录：${HOME}`);
 });

package/selftest.mjs

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+/**
+ * supercrew selftest —— 装完跑一次，看这台机器上能不能正常干活。
+ *
+ * 它不只检查「进程能不能起来」，而是**真的让一个 worker 去读一个含中文的文件**，
+ * 看它读出来的是不是正确的中文。这是最容易出问题、又最难被发现的地方：
+ * worker 若用 shell 读文件，中文会变乱码（鈥斺€?），活就全废了，而用户不会知道。
+ *
+ * 用法：node selftest.mjs [--quick] [--cwd <目录>]
+ *   --quick  只查环境与进程，不真派 worker（几秒出结果）
+ */
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+// selftest.mjs 就在仓库根目录，所以 HERE 本身就是 ROOT
+const ROOT = HERE;
+const ARGS = process.argv.slice(2);
+const QUICK = ARGS.includes('--quick');
+const ci = ARGS.indexOf('--cwd');
+const WORKDIR = ci >= 0 && ARGS[ci + 1] ? ARGS[ci + 1] : fs.mkdtempSync(path.join(os.tmpdir(), 'crew-self-'));
+
+// 一段中文样本：含标点、破折号、数字，正好覆盖那些会被编码搞坏的东西
+const SAMPLE = '中文自检样本：破折号——全角引号「引号」·数字 1234567890·英文 mixed text';
+const SAMPLE_TITLE = '自检样本.md';
+
+const results = [];
+function check(name, ok, detail) {
+  results.push({ name, ok, detail: detail || '' });
+  console.log(`  ${ok === true ? '✓' : ok === false ? '✗' : '·'} ${name}${detail ? ' —— ' + detail : ''}`);
+  return ok;
+}
+
+function run(cmd, args, opts = {}) {
+  return new Promise((resolve) => {
+    const p = spawn(cmd, args, { windowsHide: true, ...opts });
+    let out = '', err = '';
+    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 }));
+  });
+}
+
+/** 找 dsh 启动器（同 crew.mjs 的逻辑，这里只做必要的一份） */
+function findDsh() {
+  const cands = [];
+  const add = (p) => p && cands.push(p);
+  if (process.env.CREW_DSH) add(process.env.CREW_DSH);
+  for (const base of [process.env.LOCALAPPDATA, path.join(os.homedir(), 'AppData', 'Local')]) {
+    if (base) add(path.join(base, 'Programs', 'DeepSeek Harness', 'resources', 'runtime', 'cli', 'bin', 'dsh.cmd'));
+  }
+  try {
+    for (const u of fs.readdirSync('C:\\Users')) {
+      add(path.join('C:\\Users', u, 'AppData', 'Local', 'Programs', 'DeepSeek Harness',
+                    'resources', 'runtime', 'cli', 'bin', 'dsh.cmd'));
+    }
+  } catch { /* 没有权限就算了 */ }
+  return cands.find((p) => { try { return fs.existsSync(p); } catch { return false; } }) || null;
+}
+
+function resolveLaunch(dshCmd) {
+  const raw = fs.readFileSync(dshCmd, 'utf8');
+  const m = raw.match(/"([^"]*DeepSeek Harness\.exe)"\s+--expose-internals\s+"([^"]+)"/i);
+  if (!m) return null;
+  const dir = path.dirname(dshCmd);
+  let exe = m[1].replace(/%~dp0/gi, '');
+  let cli = m[2].replace(/%~dp0/gi, '');
+  if (!path.isAbsolute(exe)) exe = path.resolve(dir, exe);
+  if (!path.isAbsolute(cli)) cli = path.resolve(dir, cli);
+  return { exe, cli };
+}
+
+/** 有没有典型的中文乱码 */
+const MOJIBAKE = /鈥|锟斤拷|锟|\uFFFD\uFFFD/;
+
+console.log('supercrew 自检\n');
+
+// ── 1. 环境 ───────────────────────────────────────────────────────────────
+console.log('[1] 环境');
+check('node 版本', Number(process.versions.node.split('.')[0]) >= 22, `v${process.versions.node}`);
+const dsh = findDsh();
+check('找得到 dsh 启动器', !!dsh, dsh || '没找到（可以用 CREW_DSH 指定）');
+const L = dsh ? resolveLaunch(dsh) : null;
+check('dsh 启动器能解析', !!L, L ? L.exe : '解析失败');
+
+const workerProfile = process.env.CREW_WORKER_PROFILE || 'headless';
+const dshHome = process.env.DSH_HOME || path.join(os.homedir(), '.dsh');
+check(`worker profile「${workerProfile}」存在`,
+      fs.existsSync(path.join(dshHome, 'profiles', workerProfile)),
+      path.join(dshHome, 'profiles', workerProfile));
+
+const patch = process.env.CREW_PATCH || path.join(ROOT, 'worker-models.yml');
+check('模型 patch 文件在', fs.existsSync(patch), patch);
+const brief = path.join(ROOT, 'worker-brief.md');
+check('worker 常识文件在', fs.existsSync(brief), brief);
+
+// ── 2. 看板与值守 ─────────────────────────────────────────────────────────
+console.log('\n[2] 看板与值守');
+const port = Number(process.env.CREW_PANEL_PORT || 3090);
+async function http(pathname) {
+  try {
+    const r = await fetch(`http://127.0.0.1:${port}${pathname}`, { signal: AbortSignal.timeout(5000) });
+    return { ok: r.ok, body: await r.text() };
+  } catch (e) { return { ok: false, body: String(e.message) }; }
+}
+const hb = await http('/api/heartbeat');
+try {
+  const h = JSON.parse(hb.body);
+  check('看板在线且值守有心跳', hb.ok && h.alive === true,
+        hb.ok ? `最后心跳 ${h.ageSec ?? '?'} 秒前` : hb.body.slice(0, 60));
+} catch {
+  check('看板在线且值守有心跳', false, hb.body.slice(0, 60) || '看板没响应');
+}
+
+if (QUICK) {
+  console.log('\n（--quick：跳过真正派 worker 的测试）');
+} else {
+  // ── 3. worker 能不能正确读中文（最重要的一项）────────────────────────────
+  console.log('\n[3] 派一个 worker 读中文文件（这是最容易坏的地方）');
+  fs.mkdirSync(WORKDIR, { recursive: true });
+  const sampleFile = path.join(WORKDIR, SAMPLE_TITLE);
+  fs.writeFileSync(sampleFile, SAMPLE, 'utf8');
+
+  if (!L) {
+    check('worker 读中文', false, '没有可用的 dsh，跳过');
+  } else {
+    const task = `读一下 ${sampleFile} 这个文件，把它里面的内容一字不差地原样输出出来。`
+               + `只输出文件内容本身，不要加任何解释、不要加代码块。`;
+    const argv = ['--profile', workerProfile];
+    if (fs.existsSync(patch)) argv.push('--patch', patch);
+    argv.push('--permission-mode', 'danger-full-access', '--approval-policy', 'never', task);
+
+    const t0 = Date.now();
+    const r = await run(L.exe, ['--expose-internals', L.cli, ...argv], {
+      cwd: WORKDIR,
+      env: { ...process.env, ELECTRON_RUN_AS_NODE: '1' },
+    });
+    const secs = Math.round((Date.now() - t0) / 1000);
+    const got = (r.out || '').trim();
+
+    if (r.rc !== 0) {
+      check('worker 读中文', false, `worker 退出码 ${r.rc}（${secs} 秒）：${(r.err || '').trim().split('\n').slice(-2).join(' ').slice(0, 160)}`);
+    } else if (MOJIBAKE.test(got) || MOJIBAKE.test(r.err)) {
+      check('worker 读中文', false,
+            `读出来是乱码 —— 它在用 shell 读文件。样本：${got.slice(0, 80)}`);
+    } else if (got.includes('自检样本') && got.includes('破折号')) {
+      check('worker 读中文', true, `${secs} 秒，读回来的中文是对的`);
+    } else {
+      check('worker 读中文', false, `${secs} 秒，但内容对不上：${got.slice(0, 100)}`);
+    }
+  }
+
+  // ── 4. worker 能不能正确写中文 ──────────────────────────────────────────
+  console.log('\n[4] 派一个 worker 写中文文件');
+  if (!L) {
+    check('worker 写中文', false, '没有可用的 dsh，跳过');
+  } else {
+    const outFile = path.join(WORKDIR, '自检输出.md');
+    const task2 = `把这句话一字不差地写进文件 ${outFile}（UTF-8 编码）：\n${SAMPLE}\n`
+                + `写完只回答「已写入」四个字。`;
+    const argv2 = ['--profile', workerProfile];
+    if (fs.existsSync(patch)) argv2.push('--patch', patch);
+    argv2.push('--permission-mode', 'danger-full-access', '--approval-policy', 'never', task2);
+
+    const t0 = Date.now();
+    const r2 = await run(L.exe, ['--expose-internals', L.cli, ...argv2], {
+      cwd: WORKDIR,
+      env: { ...process.env, ELECTRON_RUN_AS_NODE: '1' },
+    });
+    const secs2 = Math.round((Date.now() - t0) / 1000);
+    if (!fs.existsSync(outFile)) {
+      check('worker 写中文', false, `${secs2} 秒，但文件没生成：${(r2.err || '').trim().split('\n').slice(-2).join(' ').slice(0, 140)}`);
+    } else {
+      const written = fs.readFileSync(outFile, 'utf8');
+      if (MOJIBAKE.test(written)) check('worker 写中文', false, `写进去的是乱码：${written.slice(0, 80)}`);
+      else if (written.includes('自检样本') && written.includes('破折号')) check('worker 写中文', true, `${secs2} 秒，落盘的中文是对的`);
+      else check('worker 写中文', false, `内容对不上：${written.slice(0, 100)}`);
+    }
+  }
+}
+
+// ── 5. 结论 ───────────────────────────────────────────────────────────────
+const bad = results.filter((r) => r.ok === false);
+console.log('\n' + '─'.repeat(50));
+if (!bad.length) {
+  console.log(`全部通过（${results.length} 项）。这套东西在这台机器上能正常干活。`);
+  process.exit(0);
+}
+console.log(`${bad.length} 项没过：`);
+for (const b of bad) console.log(`  ✗ ${b.name} —— ${b.detail}`);
+console.log('\n中文读/写那两项没过的话：worker 在用 shell 读文件（GBK 乱码）。');
+console.log('先确认 worker-brief.md 在包目录里、并且已随任务一起发给 worker。');
+process.exit(1);

package/worker-brief.md

@@ -0,0 +1,56 @@
+# 干活之前，先看这一页
+
+你是这个团队系统里的 worker（一次性的干活会话）。这一页是本机的规矩，照做能省掉大量绕圈。
+
+## 一、读文件：用 read 工具，不要用 shell 命令
+
+你手上有 **read / glob / grep 这些文件工具**，它们会自动处理编码。**读文件就用它们。**
+
+不要用 shell 去读文件 —— 尤其不要用 PowerShell 的 `Get-Content`：这台机器上它默认按
+GBK 解码，读 UTF-8 的中文文件会变乱码（`鈥斺€?` 这种），**而且行数也会算错**
+（GBK 解码器会把换行字节当成多字节字符的一部分吃掉，几行会并成一行）。
+
+只有 read 工具做不了的事（数行数、批量统计），才用 **python**：
+
+```python
+# 数行数
+python -c "print(sum(1 for _ in open(r'D:\path\file.mjs', encoding='utf-8')))"
+```
+
+Python 在 `D:\Python312\python.exe`（**不在 PATH，要写全路径**）。
+
+## 二、开工前先自检（30 秒）
+
+动手之前，先确认你能正确读到中文：用 **read 工具**读一个含中文的文件，看一眼中文是不是正常的。
+
+若显示成 `鈥斺€?` 这类乱码，说明你走错路了 —— 换回 read 工具，或者用 python 指定 `encoding='utf-8'`。
+
+这 30 秒能省掉十分钟的绕圈。
+
+## 三、找文件 / 搜内容
+
+- 找文件用 **glob**，搜内容用 **grep**（它们不碰 shell，编码是稳的）。
+- 万不得已用 shell 时：不要用 `Select-String` 搜中文（同上面的理由）。
+
+## 四、写文件
+
+产出**一定要落盘**到指定的文件名。用工具写；用 shell 写就用 python 并显式 `encoding='utf-8'`。
+
+## 五、路径
+
+- 用**绝对路径**，别依赖当前目录。
+- python 字符串里用 `r'D:\...'` 原始字符串，别写裸反斜杠。
+
+## 六、干活的原则
+
+1. 先看一眼目标长什么样，再动手 —— 别猜。
+2. 同一个问题试两次不通就**换办法**，别在环境上死磕。
+3. 有产出就落盘，别只留在推理里。
+4. 最后用一两句话说明：干了什么、产出在哪个文件。
+
+## 七、卡住了怎么办
+
+- 命令报错 → 换 read/glob/grep 或 python 做同一件事，而不是反复调 shell 参数。
+- 读文件乱码 → 你一定走了 shell，改用 read 工具。
+- **超过 3 分钟没有任何产出** → 停下来，写清楚你卡在哪、试过什么，然后结束。
+  留一条说得清的失败说明，比继续绕圈有用得多。