@shaogefenhao/overnight 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 linksgo2011
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,91 @@
-# Temporary Holding Version
+# overnight
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**让 AI 上夜班。**
+
+把 coding agent 的 plan 排进队列，到点（默认夜间）自动跑，左边看 runner 重试，右边看 agent 输出。
+
+## 它是什么
+
+一个纯脚本化的 Runner。没有 AI 判断、没有魔法：
+
+- **队列 = 一组 plan**：`queue/NNN.yaml` 里是 `plans` 列表（id / title / 文件位置 / depends_on）
+- **依赖调度**：每个 plan 的 `depends_on` 全部完成才轮到它；失败的重试到 `retry.max` 次，依赖它的保持 pending
+- **定时执行**：默认夜间窗口 `20:00-08:00`，也可配成全天
+- **看住不跑飞**：卡死、超时自动杀；失败按次数重试
+- **无打扰会话**：起 agent 带 bypass 权限 + 通用提示词（执行 plan、自行决策、写决策日志）
+- **多 agent**：opencode、claude code，配好命令即可
+- **分屏日志**：左 runner / 右 agent
+
+## plan 必须能重复执行
+
+失败时 overnight 会**原样重启整个 plan**，并且**不会**自动清理工作区。plan 的重启进展
+靠 `dev-build` skill 维护的**进度文件**：`docs/progress/NNN-name.progress.md` 用稳定编号
+记录每步 `[ ]`/`[x]`，重跑时的新 agent 读 plan + 进度，从没完成的地方继续。
+
+## 用法
+
+```bash
+overnight            # 启动，进分屏日志界面（Ctrl+C 退出）
+overnight add "标题"  # 建一个任务：自动生成 plan 骨架 + 队列文件
+overnight status     # 看队列（plan 树）
+overnight logs       # 看今天的报告
+```
+
+### 队列文件
+
+一个队列文件 = 一组 plan，按顺序 + 依赖执行：
+
+```yaml
+title: 项目安全加固          # 元信息：这组任务的标题
+agent: opencode            # 可选，默认 agent
+
+plans:                      # plans 节点：至少一个
+  - id: 001
+    title: 把硬编码密钥迁到环境变量
+    file: docs/plans/001-keys-to-env.md   # plan 文件位置（相对项目根目录）
+    depends_on: []         # 可选，先跑完这些 id 再轮到这个
+  - id: 002
+    title: 补单元测试
+    file: docs/plans/002-unit-tests.md
+    depends_on: [001]
+```
+
+plan 文档放 `docs/plans/`，进度文件放 `docs/progress/`（两者都进 git）。
+
+## 配置（`overnight.yaml`）
+
+```yaml
+agents:
+  opencode: { command: opencode, args: ["run", "--dangerously-skip-permissions", "{prompt}"] }
+  claude:   { command: claude,   args: ["-p", "{prompt}", "--dangerously-skip-permissions"] }
+default_agent: opencode
+
+runner:
+  timeout: 60m        # 单个计划硬超时
+  idle_kill: 10m      # 多久没输出算卡死
+  prompt_template: |  # 追加给 agent 的通用提示词（{plan_file}/{decision_log_dir} 会替换）
+    执行 plan 文件 {plan_file}，执行过程中不要询问，自行决策，
+    并记录决策日志，写入 {decision_log_dir}
+  decision_log_dir: logs/decisions   # 决策日志目录
+
+schedule:
+  window: "20:00-08:00"   # 跨夜窗口；null = 全天
+
+retry:
+  max: 3
+  backoff: 5m
+```
+
+## 在 opencode 里用
+
+仓库带三个 skill：
+
+- `overnight`：把需求排进 overnight 夜间跑（建队列）
+- `dev-plan`：需求 → plan 文档
+- `dev-build`：执行 plan 文档 + 维护进度文件
+
+## 全局安装
+
+```bash
+npm i -g .        # 或 npm link，之后任意目录都能用 overnight
+```

package/package.json

@@ -1,6 +1,47 @@
 {
   "name": "@shaogefenhao/overnight",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "让 AI 上夜班：把 coding agent 的 plan 排进队列，夜里自动跑，左右分屏看 runner 和 agent 日志",
+  "type": "module",
+  "bin": {
+    "overnight": "./src/index.js"
+  },
+  "main": "src/index.js",
+  "scripts": {
+    "start": "node src/index.js",
+    "test": "node --test test/*.test.js",
+    "prepublishOnly": "npm test"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "ai",
+    "coding-agent",
+    "automation",
+    "opencode",
+    "claude",
+    "night"
+  ],
+  "author": {
+    "name": "linksgo2011"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/linksgo2011/overnight.git"
+  },
+  "homepage": "https://github.com/linksgo2011/overnight#readme",
+  "bugs": {
+    "url": "https://github.com/linksgo2011/overnight/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "yaml": "^2.5.1"
+  },
+  "files": [
+    "src"
+  ]
+}

package/src/agents.js

@@ -0,0 +1,115 @@
+// 多 agent 适配（opencode / claude code ...）
+import { spawn } from 'node:child_process';
+import { appendFileSync, writeFileSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+// OpenCode 桌面 App 注入的变量会让子进程误连桌面富服务（Session not found），
+// 起 agent 时必须剥掉；其余环境变量原样继承
+const OPENCODE_DESKTOP_VARS = ['OPENCODE_CLIENT', 'OPENCODE_SERVER_USERNAME', 'OPENCODE_SERVER_PASSWORD'];
+function agentEnv() {
+  const env = { ...process.env };
+  for (const k of OPENCODE_DESKTOP_VARS) delete env[k];
+  return env;
+}
+
+export class Agent {
+  constructor(cfg) {
+    this.cfg = cfg;
+    this.templates = cfg.agents;
+  }
+
+  resolve(name) {
+    const key = name || this.cfg.default_agent;
+    const tpl = this.templates[key];
+    if (!tpl) {
+      const known = Object.keys(this.templates).join(', ');
+      throw new Error(`没配置 agent "${key}"。已知的: ${known}`);
+    }
+    return { name: key, ...tpl };
+  }
+
+  // 起一个 agent 跑 prompt，收集输出
+  run(name, prompt, { onOutput } = {}) {
+    const tpl = this.resolve(name);
+
+    // 数组传参，prompt 里的空格引号不会炸
+    const args = tpl.args.map((a) => String(a).replace('{prompt}', prompt));
+
+    // spawn 不认 ~，手动展开
+    const cmd = String(tpl.command).replace(/^~(?=\/|$)/, homedir());
+
+    const proc = spawn(cmd, args, {
+      cwd: this.cfg.paths.root,
+      env: agentEnv(),
+      stdio: ['ignore', 'pipe', 'pipe'],
+      // 独立进程组，这样 kill 能连带干掉 agent 起的子进程
+      detached: true,
+    });
+
+    let buf = '';
+    let errBuf = '';
+    const push = (s, isErr) => {
+      buf += s;
+      if (isErr) errBuf += s;
+      onOutput?.(s, isErr);
+    };
+
+    proc.stdout.on('data', (d) => push(d.toString(), false));
+    proc.stderr.on('data', (d) => push(d.toString(), true));
+
+    return {
+      name: tpl.name,
+      command: `${tpl.command} ${tpl.args.map((a) => String(a).replace('{prompt}', '"…"')).join(' ')}`,
+      proc,
+      get output() { return buf; },
+      get stderr() { return errBuf; },
+      pid: proc.pid,
+    };
+  }
+
+  // 杀掉整个进程组：agent 起的子进程（dev server、测试进程）也得死
+  kill(handle, { graceMs = 3000 } = {}) {
+    if (!handle?.proc || handle._killed) return;
+    const pid = handle.proc.pid;
+    if (pid == null) return;
+    handle._killed = true;
+
+    // agent 自己可能不转发信号给子进程，所以只杀父进程会留一堆孤儿
+    const fire = (sig) => {
+      try { process.kill(-pid, sig); return; } catch { /* 没有独立进程组 */ }
+      try { handle.proc.kill(sig); } catch { /* 已经死了 */ }
+    };
+
+    fire('SIGTERM');
+
+    // SIGTERM 不一定管用（agent 常忽略），必须补一刀 SIGKILL
+    // 不能 unref：这个定时器是防止留孤儿进程的唯一保障
+    this._pending = new Promise((resolve) => {
+      setTimeout(() => {
+        try { process.kill(-pid, 0); } catch { return resolve(); }  // 已经死了
+        fire('SIGKILL');
+        resolve();
+      }, graceMs);
+    });
+  }
+
+  // 等所有 kill 的兜底都发完（测试和优雅退出用）
+  drainKills() {
+    return this._pending || Promise.resolve();
+  }
+}
+
+export function tail(str, lines) {
+  const arr = String(str).split('\n');
+  return arr.slice(-lines).join('\n');
+}
+
+// 报告：一天一个 md 文件，纯记录 runner 干了啥（无 AI 判断）
+export function appendReport(cfg, section) {
+  const day = new Date().toISOString().slice(0, 10);
+  const file = join(cfg.paths.reports, `${day}.md`);
+
+  if (!existsSync(file)) writeFileSync(file, `# ${day}\n`, 'utf8');
+  appendFileSync(file, section, 'utf8');
+}

package/src/config.js

@@ -0,0 +1,125 @@
+// 配置加载 + 时长解析 + 窗口判断
+import { readFileSync, existsSync, mkdirSync } from 'node:fs';
+import { resolve } from 'node:path';
+import YAML from 'yaml';
+
+const CONFIG_FILE = 'overnight.yaml';
+
+const DEFAULTS = {
+  agents: {
+    opencode: { command: 'opencode', args: ['run', '--dangerously-skip-permissions', '{prompt}'] },
+    claude: { command: 'claude', args: ['-p', '{prompt}', '--dangerously-skip-permissions'] },
+  },
+  default_agent: 'opencode',
+  runner: {
+    timeout: '60m',
+    idle_kill: '10m',
+    tail_lines: 80,
+    prompt_template: '执行 plan 文件 {plan_file}，执行过程中不要询问，自行决策，并记录决策日志，写入 {decision_log_dir}',
+    decision_log_dir: 'logs/decisions',
+  },
+  schedule: {
+    window: '20:00-08:00',   // null / 空 = 全天
+    idle_sleep: '24h',
+  },
+  retry: { max: 3, backoff: '5m' },
+  report: { dir: 'reports' },
+};
+
+function deepMerge(base, over) {
+  if (over === undefined) return base;
+  // null 是显式覆盖（比如 schedule.window: null 表示全天），不能当成没填
+  if (over === null || Array.isArray(over) || typeof over !== 'object') return over;
+  if (typeof base !== 'object' || base === null) return over;
+  const out = { ...base };
+  for (const [k, v] of Object.entries(over)) {
+    out[k] = k in base ? deepMerge(base[k], v) : v;
+  }
+  return out;
+}
+
+// ${VAR} 展开
+function expandEnv(str) {
+  return String(str).replace(/\$\{(\w+)\}/g, (_, name) => process.env[name] ?? '');
+}
+
+function deepExpand(obj) {
+  if (typeof obj === 'string') return expandEnv(obj);
+  if (Array.isArray(obj)) return obj.map(deepExpand);
+  if (obj && typeof obj === 'object') {
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) out[k] = deepExpand(v);
+    return out;
+  }
+  return obj;
+}
+
+export function loadConfig(cwd = process.cwd()) {
+  const file = resolve(cwd, CONFIG_FILE);
+  let user = {};
+  if (existsSync(file)) {
+    try {
+      user = YAML.parse(readFileSync(file, 'utf8')) || {};
+    } catch (e) {
+      throw new Error(`${CONFIG_FILE} 解析失败: ${e.message}`);
+    }
+  }
+
+  const cfg = deepExpand(deepMerge(DEFAULTS, user));
+
+  // 时长转毫秒
+  cfg.runner.timeoutMs = parseDuration(cfg.runner.timeout);
+  cfg.runner.idleKillMs = parseDuration(cfg.runner.idle_kill);
+  cfg.schedule.idleSleepMs = parseDuration(cfg.schedule.idle_sleep);
+  cfg.retry.backoffMs = parseDuration(cfg.retry.backoff);
+
+  // 目录
+  cfg.paths = {
+    root: cwd,
+    queue: resolve(cwd, 'queue'),
+    plans: resolve(cwd, 'docs', 'plans'),
+    progress: resolve(cwd, 'docs', 'progress'),
+    decisions: resolve(cwd, cfg.runner.decision_log_dir),
+    logs: resolve(cwd, 'logs'),
+    reports: resolve(cwd, cfg.report.dir),
+  };
+  for (const p of [cfg.paths.queue, cfg.paths.plans, cfg.paths.progress,
+    cfg.paths.decisions, cfg.paths.logs, cfg.paths.reports]) {
+    if (!existsSync(p)) mkdirSync(p, { recursive: true });
+  }
+
+  return cfg;
+}
+
+// 60m / 30s / 2h / 1d
+export function parseDuration(s) {
+  if (typeof s === 'number') return s * 1000;
+  const m = String(s).trim().match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)?$/i);
+  if (!m) throw new Error(`时长格式不对: ${s}`);
+  const n = parseFloat(m[1]);
+  const unit = (m[2] || 'm').toLowerCase();
+  const mult = { ms: 1, s: 1000, m: 60000, h: 3600000, d: 86400000 }[unit];
+  return n * mult;
+}
+
+// "20:00-08:00" -> 是否在窗口内（支持跨夜）；null/空 = 全天
+export function parseWindow(str) {
+  if (str === null || str === undefined || String(str).trim() === '') return null;
+  const m = String(str).match(/^(\d{1,2}):(\d{2})\s*-\s*(\d{1,2}):(\d{2})$/);
+  if (!m) throw new Error(`时间窗口格式不对: ${str}（应该像 20:00-08:00，或 null 表示全天）`);
+
+  const toMin = (h, mm) => parseInt(h, 10) * 60 + parseInt(mm, 10);
+  const start = toMin(m[1], m[2]);
+  const end = toMin(m[3], m[4]);
+
+  if (start === end) return { start, end, always: true };
+  return { start, end, always: false, crossNight: end < start };
+}
+
+export function inWindow(window, now = new Date()) {
+  if (!window || window.always) return true;
+  const cur = now.getHours() * 60 + now.getMinutes();
+  const { start, end, crossNight } = window;
+  if (crossNight) return cur >= start || cur < end;
+  return cur >= start && cur < end;
+}

package/src/index.js

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+// overnight — 让 AI 上夜班。queue 里的一组 plan 排好队，到点自动串行执行。
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { loadConfig, parseWindow, inWindow } from './config.js';
+import { Queue } from './queue.js';
+import { Runner, sleep } from './runner.js';
+import { appendReport } from './agents.js';
+import { TUI } from './tui.js';
+
+const argv = process.argv.slice(2);
+const CMD = argv[0] || 'run';
+
+const PLAN_STATUS_TEXT = { done: 'done', failed: 'FAILED', broken: 'broken', running: 'RUNNING', pending: 'pending' };
+
+const cfg = loadConfig();
+const queue = new Queue(cfg);
+
+const state = { current: null, paused: false, windowLabel: '—' };
+
+switch (CMD) {
+  case 'init':
+    init();
+    break;
+  case 'logs':
+  case 'report':
+    showReport(argv[1]);
+    break;
+  case 'status':
+    showStatus();
+    break;
+  case 'add':
+    add();
+    break;
+  default:
+    run();
+}
+
+function init() {
+  console.log(existsSync('overnight.yaml') ? 'overnight.yaml 已存在' : '没有 overnight.yaml，会用默认配置运行。');
+  console.log('\n用法:');
+  console.log('  overnight              启动，进分屏日志界面');
+  console.log('  overnight add "标题"    建一个队列任务（自动生成 plan 骨架）');
+  console.log('  overnight status       看队列（按 plan 树）');
+  console.log('  overnight logs         看今天的报告');
+  process.exit(0);
+}
+
+function showReport(day) {
+  const d = day || new Date().toISOString().slice(0, 10);
+  const f = join(cfg.paths.reports, `${d}.md`);
+  if (!existsSync(f)) { console.log(`没有 ${d} 的报告`); process.exit(0); }
+  console.log(readFileSync(f, 'utf8'));
+}
+
+function showStatus() {
+  const jobs = queue.list();
+  console.log(`\n队列 ${jobs.length} 条：\n`);
+  for (const j of jobs) {
+    console.log(`  ${j.id}  ${j.status.padEnd(7)} ${j.title}`);
+    if (j.broken) {
+      console.log(dim(`      ! ${j.broken}`));
+      continue;
+    }
+    for (const p of j.plans) {
+      const st = PLAN_STATUS_TEXT[p.status] || p.status;
+      const dep = p.depends_on.length ? dim(` (depends_on: ${p.depends_on.join(',')})`) : '';
+      const re = p.reason ? dim(` — ${p.reason}`) : '';
+      console.log(`      ${st.padEnd(8)} ${p.id}  ${p.title}${dep}${re}`);
+    }
+  }
+  console.log('');
+}
+
+function dim(s) {
+  return `\x1b[2m${s}\x1b[0m`;
+}
+
+// ---- add：生成 plan 骨架 + 队列文件 ----
+
+function slugify(s) {
+  const slug = String(s).toLowerCase()
+    .replace(/[^a-z0-9\u4e00-\u9fff]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  return slug || 'plan';
+}
+
+function add() {
+  const args = argv.slice(1);
+  if (!args.length) {
+    console.error('用法: overnight add "标题" [agent]');
+    process.exit(1);
+  }
+  // 最后一个参数是已知 agent 名时当该 job 的 agent 用
+  let title, agent = null;
+  if (args.length >= 2 && cfg.agents[args[args.length - 1]]) {
+    agent = args.pop();
+  }
+  title = args.join(' ');
+
+  // 下一个可用编号（和 queue.add 的算法一致）
+  let n = 1;
+  while (existsSync(join(cfg.paths.queue, `${String(n).padStart(3, '0')}.yaml`))) n++;
+  const jobId = String(n).padStart(3, '0');
+  const planFile = `docs/plans/${jobId}-${slugify(title)}.md`;
+
+  writeFileSync(join(cfg.paths.root, planFile), planSkeleton(title, planFile), 'utf8');
+  const id = queue.add({ title, planFile, agent });
+  console.log(`已加入: ${id}`);
+  console.log(`  queue 文件: queue/${id}.yaml`);
+  console.log(`  plan 文档:  ${planFile}（自己补步骤和验收）`);
+  process.exit(0);
+}
+
+function planSkeleton(title, planFile) {
+  const progress = planFile.replace(/^docs\/plans\//, 'docs/progress/').replace(/\.md$/, '.progress.md');
+  return `# plan 001 — ${title}
+
+> 执行第一条：用 dev-build 维护进度，**这个 plan 必须能安全重跑**。
+> 先读进度文件 \`${progress}\` 和现状（git status / git diff），做过的跳过，别重复。
+
+## 1. 现状检查
+- 「运行指令」确认现在的基线
+
+## 2. 步骤
+1. （第一步）
+2. （第二步）
+
+## 3. 验收
+- （可测试的标准）
+`;
+}
+
+// ---- 主循环 ----
+
+async function run() {
+  const win = parseWindow(cfg.schedule.window);
+  const label = () => {
+    if (!win) return '全天';
+    return inWindow(win) ? '窗口内' : '窗外';
+  };
+  state.windowLabel = label();
+
+  // 新会话：把之前失败的 plan 打回 pending，给它们新的尝试
+  queue.resetFailed();
+  queue.prune();
+
+  const tui = new TUI(cfg, { queue, state });
+  const runner = new Runner(cfg, {
+    log: (l) => tui.log(l),
+    onAgentOutput: (s) => tui.agentOutput(s),
+  });
+
+  (async () => {
+    while (true) {
+      try {
+        state.windowLabel = label();
+
+        // 有 plan 在跑就等它跑完（跑起来的任务不打断）
+        if (state.current) { await sleep(20_000); continue; }
+
+        // 窗口只决定要不要开新任务
+        if (win && !inWindow(win)) { await sleep(60_000); continue; }
+
+        queue.prune();
+        const nxt = queue.next();       // { job, plan } 或 null
+        if (!nxt) { await sleep(cfg.schedule.idleSleepMs); continue; }
+
+        const { job, plan } = nxt;
+        state.current = { jobId: job.id, planId: plan.id, startedAt: Date.now() };
+        queue.markPlan(job.id, plan.id, 'running');
+        appendReport(cfg, `\n## 开始 — ${job.id}/${plan.id} (${plan.title})\n`
+          + `- plan: ${plan.relFile}\n- agent: ${job.agent || cfg.default_agent}\n`);
+
+        const res = await runner.runPlan(job, plan);
+
+        state.current = null;
+        queue.markPlan(job.id, plan.id, res.status, { reason: res.attempts > 1 ? `尝试了 ${res.attempts} 次` : null });
+        tui.log(`[${job.id}/${plan.id}] ${res.status}${res.reason ? ' — ' + res.reason : ''}`);
+
+        await sleep(1000);
+      } catch (e) {
+        tui.log('主循环出错: ' + e.message);
+        await sleep(60_000);
+      }
+    }
+  })();
+
+  tui.start();
+}

package/src/queue.js

@@ -0,0 +1,330 @@
+// 队列读写：queue/*.yaml（plans 格式）+ state.json
+// 一个队列文件 = 一组 plan；每个 plan 有 id/title/file/depends_on（文件内依赖）
+import { readdirSync, readFileSync, writeFileSync, existsSync, unlinkSync, renameSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import YAML from 'yaml';
+
+const JOB_STATUS = { PENDING: 'pending', RUNNING: 'running', DONE: 'done', FAILED: 'failed', BROKEN: 'broken' };
+const PLAN_STATUS = { PENDING: 'pending', RUNNING: 'running', DONE: 'done', FAILED: 'failed', BROKEN: 'broken' };
+
+export class Queue {
+  constructor(cfg) {
+    this.cfg = cfg;
+    this.dir = cfg.paths.queue;
+    this.stateFile = join(this.dir, 'state.json');
+    this.state = this.#loadState();
+    this.listeners = new Set();
+  }
+
+  #loadState() {
+    if (!existsSync(this.stateFile)) return {};
+    try {
+      return JSON.parse(readFileSync(this.stateFile, 'utf8')) || {};
+    } catch {
+      return {};
+    }
+  }
+
+  #saveState() {
+    // 先写临时文件再 rename，避免写一半断电
+    const tmp = `${this.stateFile}.tmp`;
+    writeFileSync(tmp, JSON.stringify(this.state, null, 2));
+    renameSync(tmp, this.stateFile);
+  }
+
+  onChange(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+
+  #emit() {
+    for (const fn of this.listeners) {
+      try { fn(this.list()); } catch { /* 监听器出错不影响主流程 */ }
+    }
+  }
+
+  // ---- 解析 ----
+
+  #parseJobs() {
+    let files = [];
+    try {
+      files = readdirSync(this.dir)
+        .filter((f) => /\.ya?ml$/i.test(f) && !f.startsWith('_'))
+        .sort();
+    } catch {
+      return [];
+    }
+
+    const jobs = [];
+    for (const f of files) {
+      const jobId = f.replace(/\.ya?ml$/i, '');
+      jobs.push(this.#parseJob(jobId, f));
+    }
+    return jobs;
+  }
+
+  #parseJob(jobId, fileName) {
+    let raw;
+    try {
+      raw = YAML.parse(readFileSync(join(this.dir, fileName), 'utf8')) || {};
+    } catch (e) {
+      return this.#brokenJob(jobId, fileName, `yaml 解析失败: ${e.message}`);
+    }
+
+    if (!Array.isArray(raw.plans) || raw.plans.length === 0) {
+      return this.#brokenJob(jobId, fileName, 'plans 节点缺失或为空');
+    }
+
+    const plans = raw.plans.map((p, i) => this.#parsePlan(jobId, p, i));
+
+    const cycle = this.#findCycle(plans);
+    if (cycle.length) {
+      for (const c of cycle) {
+        c.status = PLAN_STATUS.BROKEN;
+        c.reason = `依赖成环: ${cycle.map((x) => x.id).join(' -> ')}`;
+      }
+    }
+
+    return {
+      id: jobId,
+      file: fileName,
+      title: raw.title || fileName,
+      agent: raw.agent || null,          // null = 用默认 agent
+      plans,
+      broken: null,
+    };
+  }
+
+  #brokenJob(jobId, fileName, reason) {
+    return { id: jobId, file: fileName, title: fileName, agent: null, plans: [], broken: reason };
+  }
+
+  #parsePlan(jobId, p, idx) {
+    const id = String(p?.id ?? (idx + 1)).
+      // YAML 把 001 读成八进制 1，统一补成三位
+      replace(/^\d+$/, (m) => m.padStart(3, '0'));
+    const plan = {
+      id,
+      jobId,
+      title: p?.title || id,
+      relFile: p?.file || null,
+      depends_on: Array.isArray(p?.depends_on)
+        ? p.depends_on.map(String).map((d) => d.replace(/^\d+$/, (m) => m.padStart(3, '0')))
+        : [],
+      status: this.state[jobId]?.plans?.[id]?.status || PLAN_STATUS.PENDING,
+      reason: this.state[jobId]?.plans?.[id]?.reason || null,
+      content: null,
+    };
+
+    // 读 plan 文档；缺文件 = broken
+    if (plan.relFile) {
+      const abs = resolve(this.cfg.paths.root, plan.relFile);
+      if (existsSync(abs)) {
+        plan.content = readFileSync(abs, 'utf8');
+      } else {
+        plan.status = PLAN_STATUS.BROKEN;
+        plan.reason = `plan 文件不存在: ${plan.relFile}`;
+      }
+    } else {
+      plan.status = PLAN_STATUS.BROKEN;
+      plan.reason = '缺少 file 字段';
+    }
+
+    // 依赖的 plan id 不存在
+    for (const dep of plan.depends_on) {
+      if (plan.status === PLAN_STATUS.BROKEN) break;
+      // 存在性检查放到 job 级（这里拿不到完整列表），见 #findBrokenDeps
+    }
+    return plan;
+  }
+
+  // 返回成环的 plan 数组（空 = 无环）
+  #findCycle(plans) {
+    const byId = new Map(plans.map((p) => [p.id, p]));
+    const color = new Map(plans.map((p) => [p.id, 0]));   // 0 未访问 / 1 访问中 / 2 完成
+    const stack = [];
+
+    const visit = (id) => {
+      if (!byId.has(id) || byId.get(id).status === PLAN_STATUS.BROKEN) return [];
+      if (color.get(id) === 1) {
+        // 找到环：从栈顶往回切到当前 id
+        const i = stack.lastIndexOf(id);
+        return stack.slice(i).map((x) => byId.get(x));
+      }
+      if (color.get(id) === 2) return [];
+      color.set(id, 1);
+      stack.push(id);
+      for (const dep of byId.get(id).depends_on) {
+        const c = visit(dep);
+        if (c.length) return c;
+      }
+      stack.pop();
+      color.set(id, 2);
+      return [];
+    };
+
+    for (const p of plans) {
+      const c = visit(p.id);
+      if (c.length) return c;
+    }
+    return [];
+  }
+
+  #brokenDeps(job) {
+    const ids = new Set(job.plans.map((p) => p.id));
+    for (const p of job.plans) {
+      if (p.status === PLAN_STATUS.BROKEN) continue;
+      for (const dep of p.depends_on) {
+        if (!ids.has(dep)) {
+          p.status = PLAN_STATUS.BROKEN;
+          p.reason = `依赖的 plan 不存在: ${dep}`;
+        }
+      }
+    }
+  }
+
+  // ---- 查询 ----
+
+  list() {
+    const jobs = this.#parseJobs();
+    for (const j of jobs) {
+      if (!j.broken) this.#brokenDeps(j);
+      j.status = this.#jobStatus(j);
+      if (j.broken) j.status = JOB_STATUS.BROKEN;
+    }
+    return this.#sorted(jobs);
+  }
+
+  #jobStatus(job) {
+    if (job.broken) return JOB_STATUS.BROKEN;
+    const s = job.plans.map((p) => p.status);
+    if (s.some((x) => x === PLAN_STATUS.RUNNING)) return JOB_STATUS.RUNNING;
+    if (s.every((x) => x === PLAN_STATUS.DONE)) return JOB_STATUS.DONE;
+    if (s.some((x) => x === PLAN_STATUS.FAILED || x === PLAN_STATUS.BROKEN)) return JOB_STATUS.FAILED;
+    return JOB_STATUS.PENDING;
+  }
+
+  // 下一个能执行的 plan：{ job, plan } 或 null
+  // 依赖没解完的（含依赖失败/成环）不会返回
+  next() {
+    for (const job of this.list()) {
+      if (job.broken) continue;
+      for (const plan of job.plans) {
+        if (plan.status !== PLAN_STATUS.PENDING) continue;
+        if (this.ready(job, plan)) return { job, plan };
+      }
+    }
+    return null;
+  }
+
+  // plan 的 depends_on 全部为 done
+  ready(job, plan) {
+    if (plan.status !== PLAN_STATUS.PENDING) return false;
+    for (const dep of plan.depends_on) {
+      const d = job.plans.find((p) => p.id === dep);
+      if (!d || d.status !== PLAN_STATUS.DONE) return false;
+    }
+    return true;
+  }
+
+  // 新会话开始时：把失败的 plan 打回 pending，让它们今晚/下轮重新尝试。
+  // 顺带清掉卡在 running 的残留（上次被 kill 时留下，新会话里没人真在跑它）
+  resetFailed() {
+    let changed = false;
+    for (const job of this.#parseJobs()) {
+      if (job.broken) continue;
+      for (const p of job.plans) {
+        const st = p.status;
+        if ((st === PLAN_STATUS.FAILED || st === PLAN_STATUS.RUNNING)
+          && this.state[job.id]?.plans?.[p.id]) {
+          this.state[job.id].plans[p.id].status = PLAN_STATUS.PENDING;
+          this.state[job.id].plans[p.id].reason = null;
+          changed = true;
+        }
+      }
+    }
+    if (changed) this.#saveState();
+  }
+
+  // ---- 操作 ----
+
+  // 新增一个队列文件（引用已存在的 plan 文档）
+  add({ title, planFile, agent = null }) {
+    let n = 1;
+    while (existsSync(join(this.dir, `${String(n).padStart(3, '0')}.yaml`))) n++;
+    const jobId = String(n).padStart(3, '0');
+    const body = {
+      title,
+      ...(agent ? { agent } : {}),
+      plans: [{
+        id: '001',
+        title,
+        file: planFile,
+        depends_on: [],
+      }],
+    };
+    writeFileSync(join(this.dir, `${jobId}.yaml`), YAML.stringify(body, null, 2), 'utf8');
+    this.#emit();
+    return jobId;
+  }
+
+  remove(jobId) {
+    const f = join(this.dir, `${jobId}.yaml`);
+    if (!existsSync(f)) return false;
+    unlinkSync(f);
+    delete this.state[jobId];
+    this.#saveState();
+    this.#emit();
+    return true;
+  }
+
+  markPlan(jobId, planId, status, extra = {}) {
+    const jobState = (this.state[jobId] ||= { plans: {} });
+    jobState.plans[planId] = { status, at: new Date().toISOString(), ...extra };
+    this.#saveState();
+    this.#emit();
+  }
+
+  // 任务文件被删了，state 里对应的记录清掉
+  prune() {
+    const jobs = this.#parseJobs();
+    const jobIds = new Set(jobs.map((j) => j.id));
+    let changed = false;
+
+    for (const id of Object.keys(this.state)) {
+      if (id === '__order') continue;
+      if (!jobIds.has(id)) { delete this.state[id]; changed = true; }
+    }
+
+    // 文件内删掉的 plan，清掉对应状态
+    for (const job of jobs) {
+      const st = this.state[job.id];
+      if (!st?.plans) continue;
+      const alive = new Set(job.plans.map((p) => p.id));
+      for (const pid of Object.keys(st.plans)) {
+        if (!alive.has(pid)) { delete st.plans[pid]; changed = true; }
+      }
+    }
+
+    // 顺序表里删掉已经不存在的 id
+    if (Array.isArray(this.state.__order)) {
+      const before = this.state.__order.length;
+      this.state.__order = this.state.__order.filter((id) => jobIds.has(id));
+      if (this.state.__order.length !== before) changed = true;
+    }
+
+    if (changed) this.#saveState();
+  }
+
+  // ---- 排序 ----
+
+  // state.json 里记的顺序优先，没记的按文件名追加
+  #sorted(jobs) {
+    const order = this.state.__order || [];
+    const rank = (id) => {
+      const i = order.indexOf(id);
+      return i === -1 ? 1e9 : i;
+    };
+    return [...jobs].sort((a, b) => rank(a.id) - rank(b.id) || a.id.localeCompare(b.id));
+  }
+}

package/src/runner.js

@@ -0,0 +1,166 @@
+// Runner：纯脚本看护。起 agent、盯三条线（退出/卡死/超时）、失败按次数重试。
+// 调度按 plan 粒度：谁 ready 谁跑；deps 没解完的（含依赖失败）不碰。
+import { createWriteStream, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { Agent, tail, appendReport } from './agents.js';
+
+export const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+const fmtDur = (ms) => {
+  const s = Math.floor(ms / 1000);
+  const h = Math.floor(s / 3600);
+  const m = Math.floor((s % 3600) / 60);
+  const sec = s % 60;
+  return h ? `${h}小时${m}分` : m ? `${m}分${sec}秒` : `${sec}秒`;
+};
+
+// 退出码 + 日志关键字 -> 人话原因（只归类，不决策）
+const SIGNATURES = [
+  [/out of memory|heap out of memory|ENOMEM|oom-?kill/i, '内存爆了 (OOM)'],
+  [/ENOTFOUND|ETIMEDOUT|ECONNREFUSED|ECONNRESET|getaddrinfo/i, '网络不通'],
+  [/rate.?limit|429|too many requests|quota/i, 'API 限流 / 额度用完'],
+  [/authentication|401|403|invalid.*key|unauthorized/i, '认证失败 (key 过期?)'],
+  [/permission denied|EACCES|not permitted/i, '权限不足'],
+  [/git.*conflict|CONFLICT|merge.*fail/i, 'git 冲突'],
+  [/test.*fail|assertion|jest.*failed|npm ERR! test/i, '测试没过'],
+  [/command not found|ENOENT/i, '命令找不到'],
+  [/ENOSPC|no space left/i, '磁盘满了'],
+];
+
+export function classifyExit(code, sig, output) {
+  for (const [re, why] of SIGNATURES) {
+    if (re.test(output)) return why;
+  }
+  if (code === 137) return '内存爆了 (OOM)';
+  if (code === 143) return '被正常终止 (SIGTERM)';
+  if (sig) return `被信号 ${sig} 杀掉`;
+  return `进程异常退出 (code ${code})`;
+}
+
+export class Runner {
+  constructor(cfg, { log, onAgentOutput } = {}) {
+    this.cfg = cfg;
+    this.agent = new Agent(cfg);
+    this.log = log || (() => {});            // runner 日志 -> 左栏
+    this.onAgentOutput = onAgentOutput || (() => {});  // agent 输出 -> 右栏
+    this.current = null;
+  }
+
+  // 按配置把 prompt_template 拼上 plan 全文
+  buildPrompt(plan) {
+    const tpl = this.cfg.runner.prompt_template || '';
+    const header = tpl
+      .replace(/\{plan_file\}/g, plan.relFile || plan.title)
+      .replace(/\{decision_log_dir\}/g, this.cfg.runner.decision_log_dir)
+      .trim();
+    return [header, '--- plan 内容 ---', plan.content].filter(Boolean).join('\n\n');
+  }
+
+  // 跑一个 plan：单 plan 重试，最多 retry.max 次
+  async runPlan(job, plan) {
+    const max = this.cfg.retry.max;
+    let lastErr = '';
+
+    for (let attempt = 1; attempt <= max; attempt++) {
+      // 重放同一份 prompt：plan 自己靠 docs/progress/ 的进度文件续跑
+      const prompt = this.buildPrompt(plan);
+      const res = await this.#oneShot(job, plan, prompt, attempt);
+      if (res.status === 'done') return { status: 'done', attempts: attempt };
+
+      lastErr = res.error;
+      this.#report(job, plan, attempt, res.reason, res.error, attempt < max ? 'retry' : 'failed');
+      this.log(`✗ [${job.id}/${plan.id}] 第 ${attempt}/${max} 次失败 — ${res.reason}`);
+
+      if (attempt < max) await sleep(this.cfg.retry.backoffMs);
+    }
+
+    return { status: 'failed', attempts: max, reason: lastErr ? '重试用完' : '重试用完' };
+  }
+
+  // 跑一次，盯到出结果
+  async #oneShot(job, plan, prompt, attempt) {
+    mkdirSync(this.cfg.paths.logs, { recursive: true });
+    const logFile = join(this.cfg.paths.logs, `${job.id}-${plan.id}-a${attempt}.log`);
+
+    let handle;
+    try {
+      handle = this.agent.run(job.agent || this.cfg.default_agent, prompt, {
+        onOutput: (s) => this.onAgentOutput(s),
+      });
+    } catch (e) {
+      return { status: 'err', reason: '启动失败', error: e.message };
+    }
+
+    this.current = { job, plan, handle, startedAt: Date.now() };
+    this.log(`▶ [${job.id}/${plan.id}] 第 ${attempt} 次: ${handle.name} — ${handle.command}`);
+
+    const outcome = await this.#watch(job, plan, handle, logFile);
+    this.current = null;
+    return outcome;
+  }
+
+  // 三条线：退出 / 卡死 / 超时
+  #watch(job, plan, handle, logFile) {
+    const { idleKillMs, timeoutMs, tailLines } = this.cfg.runner;
+    const started = Date.now();
+    const tag = `${job.id}/${plan.id}`;
+
+    return new Promise((resolve) => {
+      let settled = false;
+      let idleTimer, hardTimer;
+      const done = (r) => {
+        if (settled) return;
+        settled = true;
+        clearInterval(idleTimer);
+        clearTimeout(hardTimer);
+        resolve(r);
+      };
+
+      // 1. 进程退出
+      handle.proc.on('exit', (code, sig) => {
+        if (code === 0) {
+          this.log(`✓ [${tag}] 完成，跑了 ${fmtDur(Date.now() - started)}`);
+          return done({ status: 'done' });
+        }
+        const all = handle.output + '\n' + handle.stderr;
+        const err = tail(all, tailLines) || `进程退出 code=${code} sig=${sig}，无输出`;
+        done({ status: 'err', reason: classifyExit(code, sig, all), error: err });
+      });
+
+      handle.proc.on('error', (e) => {
+        done({ status: 'err', reason: '进程起不来', error: e.message });
+      });
+
+      // 2. 卡死：多久没新输出
+      let last = Date.now();
+      const poll = Math.max(1000, Math.min(30_000, Math.floor(idleKillMs / 3)));
+      idleTimer = setInterval(() => {
+        if (Date.now() - last > idleKillMs) {
+          this.agent.kill(handle);
+          done({ status: 'err', reason: '卡死（长时间无输出）',
+            error: tail(handle.output + '\n' + handle.stderr, tailLines) });
+        }
+      }, poll);
+
+      // 3. 硬超时
+      hardTimer = setTimeout(() => {
+        this.agent.kill(handle);
+        done({ status: 'err', reason: '超时', error: tail(handle.output, tailLines) });
+      }, timeoutMs);
+
+      // 落盘原始输出，方便事后翻
+      const stream = createWriteStream(logFile, { flags: 'w' });
+      handle.proc.stdout.on('data', (d) => { last = Date.now(); stream.write(d); });
+      handle.proc.stderr.on('data', (d) => { last = Date.now(); stream.write(d); });
+      handle.proc.on('exit', () => stream.end());
+    });
+  }
+
+  #report(job, plan, attempt, reason, err, result) {
+    const now = new Date().toLocaleTimeString('zh-CN', { hour12: false });
+    appendReport(this.cfg,
+      `\n## ${result === 'retry' ? '重试' : '失败'} — ${job.id}/${plan.id} (${now})\n`
+      + `- 任务: ${plan.title}\n- 第 ${attempt} 次尝试，${reason}\n`
+      + `- 日志末尾:\n\`\`\`\n${String(err).slice(-600)}\n\`\`\`\n`);
+  }
+}

package/src/tui.js

@@ -0,0 +1,175 @@
+// TUI：左右分屏。左 = runner 日志（派单/重试），右 = agent 实时输出。
+// 纯显示，无交互。Ctrl+C 退出。
+const ESC = '\x1b';
+const hideCursor = () => process.stdout.write(`${ESC}[?25l`);
+const showCursor = () => process.stdout.write(`${ESC}[?25h`);
+const enterAlt = () => process.stdout.write(`${ESC}[?1049h`);
+const leaveAlt = () => process.stdout.write(`${ESC}[?1049l`);
+const home = () => `${ESC}[H`;
+const clearScreen = () => `${ESC}[2J${ESC}[H`;
+
+const dim = (s) => `${ESC}[2m${s}${ESC}[0m`;
+const bold = (s) => `${ESC}[1m${s}${ESC}[0m`;
+const cyan = (s) => `${ESC}[36m${s}${ESC}[0m`;
+const yellow = (s) => `${ESC}[33m${s}${ESC}[0m`;
+const green = (s) => `${ESC}[32m${s}${ESC}[0m`;
+
+// 去掉 ANSI 转义，避免 agent 自带颜色冲垮分栏
+const ANSI = new RegExp(`${ESC}\\[[0-9;?]*[A-Za-z]`, 'g');
+const stripAnsi = (s) => String(s).replace(ANSI, '').replace(/\t/g, '    ');
+
+// 东亚宽字符算 2 列，不然中文分栏会错位
+function charWidth(ch) {
+  const cp = ch.codePointAt(0);
+  if (cp === 0x200d || cp === 0xfe0f || cp === 0x200b) return 0;
+  if (cp >= 0x1f300 && cp <= 0x1faff) return 2;
+  if (cp >= 0x2600 && cp <= 0x27bf) return 2;
+  if (
+    (cp >= 0x1100 && cp <= 0x115f) ||
+    (cp >= 0x2e80 && cp <= 0xa4cf) ||
+    (cp >= 0xac00 && cp <= 0xd7a3) ||
+    (cp >= 0xf900 && cp <= 0xfaff) ||
+    (cp >= 0xfe30 && cp <= 0xfe6f) ||
+    (cp >= 0xff00 && cp <= 0xff60) ||
+    (cp >= 0xffe0 && cp <= 0xffe6) ||
+    (cp >= 0x3000 && cp <= 0x303f)
+  ) return 2;
+  return 1;
+}
+
+export const visWidth = (s) => {
+  let w = 0;
+  for (const ch of s) w += charWidth(ch);
+  return w;
+};
+
+export const padTo = (s, width) => s + ' '.repeat(Math.max(0, width - visWidth(s)));
+
+// 按显示宽度折行
+export function wrapLine(line, width) {
+  if (width < 1) return [''];
+  const out = [];
+  let cur = '';
+  let w = 0;
+  for (const ch of line) {
+    const c = charWidth(ch);
+    if (w + c > width && cur) { out.push(cur); cur = ''; w = 0; }
+    cur += ch;
+    w += c;
+  }
+  out.push(cur);
+  return out;
+}
+
+const fmtDur = (ms) => {
+  const s = Math.floor(ms / 1000);
+  const h = Math.floor(s / 3600);
+  const m = Math.floor((s % 3600) / 60);
+  return h ? `${h}h${m}m` : m ? `${m}m${s % 60}s` : `${s}s`;
+};
+
+export class TUI {
+  constructor(cfg, { queue, state }) {
+    this.cfg = cfg;
+    this.queue = queue;
+    this.state = state;              // { current, paused, windowLabel }
+    this.runnerLog = [];             // 左栏：runner 事件
+    this.agentLog = [];              // 右栏：agent 输出
+    this._agentBuf = '';
+    this.rendering = false;
+  }
+
+  start() {
+    enterAlt();
+    hideCursor();
+    process.on('SIGINT', () => this.stop());
+    process.on('SIGTERM', () => this.stop());
+    process.stdout.on('resize', () => this.render());
+    this.timer = setInterval(() => this.render(), 250);
+    this.render();
+  }
+
+  stop() {
+    clearInterval(this.timer);
+    process.stdout.write(clearScreen());
+    leaveAlt();
+    showCursor();
+    process.exit(0);
+  }
+
+  // 左栏：runner 日志
+  log(line) {
+    for (const l of stripAnsi(line).split('\n')) this.runnerLog.push(l);
+    if (this.runnerLog.length > 2000) this.runnerLog.splice(0, 1000);
+  }
+
+  // 右栏：agent 原始输出，按行切
+  agentOutput(chunk) {
+    this._agentBuf += stripAnsi(chunk).replace(/\r/g, '');
+    const parts = this._agentBuf.split('\n');
+    this._agentBuf = parts.pop();
+    for (const p of parts) this.agentLog.push(p);
+    if (this.agentLog.length > 2000) this.agentLog.splice(0, 1000);
+  }
+
+  // 顶部边框，内嵌标题：┌─ runner ──┬─ agent 001 ──┐
+  #topRow(leftW, rightW, rightLabel) {
+    const seg = (label, w, lc, mc) => {
+      const t = label ? ` ${label} ` : '';
+      const tW = visWidth(t);
+      return lc + (t ? t + '─'.repeat(Math.max(0, w - tW)) : '─'.repeat(w)) + mc;
+    };
+    return seg('runner', leftW, '┌', '┬') + seg(rightLabel, rightW, '', '┐');
+  }
+
+  render() {
+    if (this.rendering) return;
+    this.rendering = true;
+
+    const W = process.stdout.columns || 100;
+    const H = process.stdout.rows || 30;
+    const total = Math.max(20, W - 1);       // 末列留空，防止自动换行
+    const leftW = Math.max(16, Math.floor((total - 1) * 0.38));
+    const rightW = total - leftW - 1;
+    const bodyH = Math.max(3, H - 4);        // 标题 + 上下边框 + 状态行
+
+    const jobs = this.queue.list();
+    const cur = this.state.current;
+    const agentLabel = cur ? `agent ${cur.jobId}/${cur.planId}` : 'agent';
+
+    const lines = [];
+    lines.push(bold('overnight'.padEnd(12)) + dim(' 让 AI 上夜班 · Ctrl+C 退出'));
+    lines.push(this.#topRow(leftW, rightW, agentLabel));
+
+    // 两栏各自折行，取最后 bodyH 行，底对齐
+    const leftWrapped = wrapAll(this.runnerLog, leftW).slice(-bodyH);
+    const rightWrapped = wrapAll(this.agentLog, rightW).slice(-bodyH);
+    while (leftWrapped.length < bodyH) leftWrapped.unshift('');
+    while (rightWrapped.length < bodyH) rightWrapped.unshift('');
+
+    for (let i = 0; i < bodyH; i++) {
+      lines.push('│' + padTo(leftWrapped[i], leftW) + '│' + padTo(rightWrapped[i], rightW) + '│');
+    }
+
+    lines.push('└' + '─'.repeat(leftW) + '┴' + '─'.repeat(rightW) + '┘');
+
+    // 状态行：统计的是 plan 粒度
+    const pendingPlans = jobs.reduce((n, j) => n + (j.broken ? 0 : j.plans.filter((p) => p.status === 'pending').length), 0);
+    const totalPlans = jobs.reduce((n, j) => n + (j.broken ? 0 : j.plans.length), 0);
+    const curInfo = cur
+      ? `当前 ${cur.jobId}/${cur.planId} (跑了 ${fmtDur(Date.now() - cur.startedAt)})`
+      : '待命';
+    const status = `plans ${pendingPlans}/${totalPlans} 待跑 · ${curInfo} · 窗口 ${this.state.windowLabel}`
+      + (this.state.paused ? ' · 已暂停' : '');
+    lines.push(cyan(status));
+
+    process.stdout.write(home() + lines.join('\n') + `${ESC}[0K`);
+    this.rendering = false;
+  }
+}
+
+function wrapAll(arr, width) {
+  const out = [];
+  for (const line of arr) out.push(...wrapLine(line, width));
+  return out;
+}