@kienntpixon/dieu-phoi 0.7.2 → 0.7.3

package/lib/args.cjs

@@ -4,7 +4,7 @@ const fs = require('fs');
 const path = require('path');
 const core = require('../hook.cjs');
 
-const BOOLEAN_FLAGS = new Set(['json', 'help', 'h', 'purge', 'version', 'v', 'dry-run', 'no-sync', 'approve', 'yes', 'force', 'follow', 'remove', 'dirty', 'no-cache', 'untagged', 'no-knowledge', 'net', 'with-codebase-memory', 'cbm', 'allow-custom-source', 'auto', 'include-local']);
+const BOOLEAN_FLAGS = new Set(['json', 'help', 'h', 'purge', 'version', 'v', 'dry-run', 'no-sync', 'approve', 'yes', 'force', 'follow', 'remove', 'dirty', 'no-cache', 'untagged', 'no-knowledge', 'net', 'with-codebase-memory', 'cbm', 'allow-custom-source', 'auto', 'include-local', 'orphans']);
 
 /** Minimal argv parser: positionals, --k v, --k=v, boolean flags. */
 function parseArgs(argv) {

package/lib/cbm.cjs

@@ -117,9 +117,15 @@ function binArgv(bin, args) {
   return /\.c?js$/i.test(bin) ? [process.execPath, [bin, ...args]] : [bin, args];
 }
 
+/** Timeout (ms) of a cbm sub-process; env override DIEU_PHOI_CBM_<name>_TIMEOUT_MS (tests under heavy load), default unchanged. */
+function cbmTimeout(name, dflt) {
+  const n = Number(process.env[`DIEU_PHOI_CBM_${name}_TIMEOUT_MS`]);
+  return Number.isFinite(n) && n > 0 ? n : dflt;
+}
+
 function probeVersion(bin, timeoutMs) {
   const [cmd, args] = binArgv(bin, ['--version']);
-  const r = cp.spawnSync(cmd, args, { encoding: 'utf8', timeout: timeoutMs || 3000, windowsHide: true });
+  const r = cp.spawnSync(cmd, args, { encoding: 'utf8', timeout: timeoutMs || cbmTimeout('PROBE', 3000), windowsHide: true });
   if (r.error || r.status !== 0) return null;
   const m = /(\d+\.\d+\.\d+)/.exec(`${r.stdout || ''}`);
   return m ? m[1] : null;
@@ -275,7 +281,7 @@ function doctorChecks({ claudeDir, repo, net, deep, cacheFile, env, now }) {
   const version = probeVersion(found.path);
   const wantDaemon = !!(deep || net);
   const cached = wantDaemon ? null : readDaemonCache(cacheFile, found.path, version, nowMs);
-  const daemonP = wantDaemon ? daemonStatus(found.path, 5000) : Promise.resolve(null);
+  const daemonP = wantDaemon ? daemonStatus(found.path, cbmTimeout('DAEMON', 5000)) : Promise.resolve(null);
   const latestP = net ? latestVersion(e).then((v) => ({ v }), (err) => ({ err: err.message })) : Promise.resolve(null);
   return (async () => {
     add(!!version && regs.length > 0, 'codebase-memory', `${version ? `v${version}` : 'không chạy được `--version`'} tại ${toSlash(found.path)} (${found.source})${regs.length

package/lib/commands.cjs

@@ -77,7 +77,7 @@ function cmdSetup(opts) {
   const lines = [
     `Đã cài hook: ${res.hook}`,
     res.settings_changed
-      ? `Đã đăng ký PostToolUse(Agent) + SubagentStop + SessionStart(compact) + UserPromptSubmit + PreToolUse(Agent) trong ${res.settings}${res.backup ? ` (sao lưu: ${path.basename(res.backup)})` : ''}`
+      ? `Đã đăng ký PostToolUse(Agent) + SubagentStop + SubagentStart + SessionStart(compact) + UserPromptSubmit + PreToolUse(Agent) trong ${res.settings}${res.backup ? ` (sao lưu: ${path.basename(res.backup)})` : ''}`
       : `settings.json đã có hook, không đổi gì (${res.settings})`,
     `Agent dp-*: ${res.agents.map((a) => `${a.name}=${a.action}`).join(', ')}${res.agents.some((a) => a.action === 'skipped-foreign') ? ' (file trùng tên không phải của dieu-phoi: giữ nguyên, đổi tên rồi chạy lại setup)' : ''}`,
     `Thư mục báo cáo subagent: ${res.runs_dir} (quyền: ${res.permissions.allow.join(', ')} + additionalDirectories)`,
@@ -144,6 +144,7 @@ async function cmdDoctor(opts) {
   add(reg.PreToolUse, 'chain-gate', reg.PreToolUse
     ? 'PreToolUse(Agent) có — chặn exec tiếp nối từ handoff thứ 3 (trừ thẻ chain_ok)'
     : 'thiếu hook PreToolUse(Agent) (core 0.7.1) — chuỗi handoff dài không bị chặn; chạy lại `dieu-phoi setup`', 'CẢNH BÁO');
+  add(...liveCheck(ctx, reg));
   const permOk = reg.permissions && reg.runs_dir_exists && !reg.legacy_permissions;
   add(permOk, 'run-permissions', permOk
     ? `${reg.permission_entries.allow.join(', ')} + additionalDirectories ${reg.permission_entries.dir}`
@@ -245,22 +246,51 @@ function orphanScan(list, now) {
   return Array.isArray(list) ? procs.staleOrphans(list, { minAgeMs: ORPHAN_MIN_AGE_MS, now: now === undefined ? Date.now() : now }) : null;
 }
 
+/**
+ * doctor item `live-agents` (core 0.7.3 s1): live register data/live/ + caps. Warns when the SubagentStart hook is missing
+ * (the register then only fills from --watch) or the machine count reached warn_parallel_machine. "Toàn máy" = this
+ * DIEU_PHOI_HOME: sessions with another home have their own register.
+ */
+function liveCheck(ctx, reg) {
+  const s = core.liveSummary(ctx, null);
+  const lim = s.limits;
+  const caps = `trần phiên ${lim.session || 'tắt'}, toàn máy ${lim.machine || 'tắt'}, cảnh báo ${lim.warn || 'tắt'}`;
+  const scope = `"toàn máy" = mọi phiên dùng ${ctx.home}`;
+  if (reg && !reg.SubagentStart) {
+    return [false, 'live-agents', `thiếu hook SubagentStart (core 0.7.3) — sổ agent sống chỉ cập nhật từ --watch; chạy lại dieu-phoi setup (${s.machine} agent sống; ${caps})`, 'CẢNH BÁO'];
+  }
+  const warn = lim.warn > 0 && s.machine >= lim.warn;
+  const list = s.labels.length ? `: ${s.labels.slice(0, 6).join('; ')}${s.labels.length > 6 ? ` (+${s.labels.length - 6})` : ''}` : '';
+  return [!warn, 'live-agents', `${s.machine} agent dieu-phoi đang chạy${list} — ${caps}; ${scope}`, 'CẢNH BÁO'];
+}
+
 /** doctor item `orphan-processes`: warns with pid + age + working set and a Stop-Process hint; never kills. Returns the args of add(). */
 function orphanCheck(ctx, deps) {
   const d = deps || {};
   const now = d.now === undefined ? Date.now() : d.now;
-  const found = orphanScan((d.listProcesses || procs.listProcesses)({ timeoutMs: 4000 }), now);
+  const list = (d.listProcesses || procs.listProcesses)({ timeoutMs: 4000 });
+  const found = orphanScan(list, now);
   if (found === null) return [true, 'orphan-processes', 'không đọc được danh sách process (bỏ qua)'];
   try {
     core.writeFileAtomic(path.join(ctx.paths.data, 'orphan-procs.json'), `${JSON.stringify({ ts: new Date(now).toISOString(), n: found.length })}\n`);
   } catch (_) { /* the cache is optional */ }
-  if (!found.length) return [true, 'orphan-processes', 'không có claude.exe / codebase-memory-mcp mồ côi quá 6 giờ'];
+  // s7: tail / sleep / Claude Code shells left orphaned (Monitor, run_in_background): reported only; `reap --orphans` cleans
+  const minK = orphanKillMin(ctx);
+  const watchers = Array.isArray(list) ? orphanTargets(list, now, minK, d).found : [];
+  const wMb = watchers.reduce((n, p) => n + (p.ws ? Math.round(p.ws / 1048576) : 0), 0);
+  const wTxt = watchers.length
+    ? `${watchers.length} tail/sleep/shell mồ côi quá ${minK} phút (${wMb} MB) — xem rồi dọn: \`dieu-phoi reap --orphans\` (dry-run) rồi thêm --yes (doctor không tự kill)`
+    : '';
+  if (!found.length) {
+    return wTxt ? [false, 'orphan-processes', `không có claude.exe / codebase-memory-mcp mồ côi quá 6 giờ; ${wTxt}`, 'CẢNH BÁO']
+      : [true, 'orphan-processes', 'không có claude.exe / codebase-memory-mcp mồ côi quá 6 giờ'];
+  }
   const mb = found.reduce((n, p) => n + (p.ws_mb || 0), 0);
   const shown = found.slice(0, 8);
   const items = shown.map((p) => `${p.name} pid ${p.pid} (${p.age_h} giờ${p.ws_mb ? `, ${p.ws_mb} MB` : ''})`).join('; ');
   return [false, 'orphan-processes',
     `${found.length} tiến trình mồ côi (cha đã thoát) quá 6 giờ, ${mb} MB: ${items}${found.length > shown.length ? '; …' : ''}`
-    + ` — kiểm tra rồi dọn bằng \`Stop-Process -Id ${shown.map((p) => p.pid).join(',')}\` (doctor không tự kill)`, 'CẢNH BÁO'];
+    + ` — kiểm tra rồi dọn bằng \`Stop-Process -Id ${shown.map((p) => p.pid).join(',')}\` (doctor không tự kill)${wTxt ? `; ${wTxt}` : ''}`, 'CẢNH BÁO'];
 }
 
 /** `state` line: orphan count from a 10-minute cache (data/orphan-procs.json), else one live scan. null = unknown (skip the line). */
@@ -937,6 +967,19 @@ function orchLine(o) {
  * Orchestration state of one session rebuilt purely from events.jsonl (same builder the SessionStart(compact)
  * hook uses). Session = --session, else env CLAUDE_CODE_SESSION_ID. Run dirs are pointed to, never read.
  */
+/** Free slots under a cap (null = cap off). */
+function freeSlots(cap, n) {
+  return cap > 0 ? Math.max(0, cap - (Number(n) || 0)) : null;
+}
+
+/** `state` line: live agents of this session / machine and free slots under the parallel caps. */
+function liveLine(live) {
+  const lim = live.limits;
+  const part = (n, cap) => `${n}/${cap > 0 ? cap : 'tắt'}${cap > 0 ? ` (trống ${freeSlots(cap, n)})` : ''}`;
+  const tasks = live.agents.filter((a) => a.task_id).slice(0, 6).map((a) => `${a.task_id}:${a.role}`).join(', ');
+  return `live: phiên ${part(live.session || 0, lim.session)} · máy ${part(live.machine, lim.machine)}${tasks ? ` — ${tasks}` : ''}`;
+}
+
 function cmdState(opts) {
   const ctx = ctxOf(opts);
   const sid = typeof opts.session === 'string' && opts.session ? opts.session
@@ -953,10 +996,215 @@ function cmdState(opts) {
   }
   const state = core.buildSessionState(core.readEvents(ctx), sid, { plansDir: ctx.paths.plans });
   const orphans = orphanCount(ctx); // s16: null (unknown) leaves the line out
+  const live = core.liveSummary(ctx, sid); // core 0.7.3 (s1)
+  const stuck = core.stuckAgents(ctx, { sessionId: sid }); // s6
+  if (opts.json) {
+    const liveJ = {
+      session: live.session, machine: live.machine, limits: live.limits, free_session: freeSlots(live.limits.session, live.session), free_machine: freeSlots(live.limits.machine, live.machine), agents: live.agents,
+      stuck: stuck.map((a) => ({ agent_id: a.agent_id, task_id: a.task_id, role: a.role, gen: a.gen, state: a.state, reasons: a.reasons, idle_min: a.idle_min, age_min: a.age_min })),
+    };
+    return { code: 0, out: JSON.stringify(Object.assign({}, state, hasDeltas ? { unmerged_deltas: deltas } : {}, orphans === null ? {} : { orphan_procs: orphans }, { live: liveJ }), null, 2) };
+  }
+  const stuckLines = stuck.length
+    ? [`stuck: ${stuck.slice(0, 6).map((a) => `${a.task_id || a.agent_id}:${a.role} ${a.state === 'orphan' ? 'mồ côi' : 'kẹt'} ${a.idle_min}'`).join(', ')} → TaskStop rồi \`dieu-phoi reap --yes\``]
+    : [];
+  return { code: 0, out: [core.formatSessionState(state, core.STATE_TEXT_CAP)].concat(deltaLines, orphans === null ? [] : [`orphan_procs: ${orphans}`], [liveLine(live)], stuckLines).join('\n') };
+}
+
+// ------------------------------------------------------------------ reap (core 0.7.3 s6)
+
+const posixPath = (p) => String(p || '').replace(/\\/g, '/');
+const normPath = (p) => String(p || '').replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
+
+/**
+ * Child processes attributable to a stuck agent: created after it started, command line inside its cwd (worktree), not a
+ * Claude Code / code-graph / conhost process, not this process' own chain. Only when no other live agent shares that cwd —
+ * otherwise attribution is a guess. s7: `targets` / `skips` = what the guarded kill may take / keeps and why. Pure.
+ */
+function reapProcsOf(a, list, sharedCwds, selfPid) {
+  if (!Array.isArray(list) || !a.cwd) return { procs: [], attributable: false };
+  const cwd = normPath(a.cwd);
+  if (!cwd || sharedCwds.has(cwd)) return { procs: [], attributable: false };
+  const own = new Set([selfPid, ...procs.ancestors(list, selfPid).map((p) => p.pid)]);
+  const skip = new Set(procs.LEFTOVER_SKIP_NAMES.map((n) => n.toLowerCase()));
+  const hits = list.filter((p) => !own.has(p.pid) && p.created && p.created >= a.start_ms && !skip.has(String(p.name || '').toLowerCase())
+    && normPath(p.cmd).includes(cwd));
+  const ids = new Set(hits.map((p) => p.pid));
+  // s7 guarded: of those, what may be killed — never-kill names, nothing hosting a claude.exe, and under a live claude.exe
+  // only through an agent shell (bash / powershell), never through an MCP server. Below no claude.exe = the agent's shell
+  // died (TaskStop) and left it; the worktree cmd already ties it to this agent.
+  const targets = [];
+  const skips = [];
+  for (const p of hits) {
+    const c = procs.claudeAncestor(list, p.pid);
+    if (c) {
+      const sel = procs.guardedSelect(list, [p], { rootPid: c.pid, exclusive: true });
+      if (sel.kill.length) targets.push(p); else skips.push(sel.skip[0]);
+    } else if (procs.isNeverKill(p)) skips.push({ pid: p.pid, name: p.name, reason: 'never-kill' });
+    else if (procs.hostsClaude(list, p.pid)) skips.push({ pid: p.pid, name: p.name, reason: 'hosts-claude' });
+    else targets.push(p);
+  }
+  return { procs: hits, roots: hits.filter((p) => !ids.has(p.ppid)), attributable: true, targets, skips };
+}
+
+/**
+ * Orphans that `reap --orphans` may kill (procs.killableOrphans), and on Windows only those the MSYS table also calls
+ * orphaned (Git-bash exec makes live `bash -c "tail -f"` look parentless). deps.msys = table|null for tests; otherwise
+ * read on win32 only. Returns { found, skipped: [{pid, name, reason}] }.
+ */
+function orphanTargets(list, now, minMin, d) {
+  const cands = procs.killableOrphans(list, { now, minAgeMs: minMin * 60000 });
+  const useMsys = Object.prototype.hasOwnProperty.call(d || {}, 'msys') || process.platform === 'win32';
+  if (!useMsys || !cands.length) return { found: cands, skipped: [] };
+  const msys = Object.prototype.hasOwnProperty.call(d || {}, 'msys') ? d.msys : procs.msysTable({ hints: cands.map((p) => p.cmd) });
+  const r = procs.msysConfirm(cands, msys);
+  return { found: r.keep, skipped: r.skip };
+}
+
+/** `orphan_kill_min` (s7): env DIEU_PHOI_ORPHAN_KILL_MIN → config → 60. Minutes ≥ 1 (0 / junk = the default). */
+const ORPHAN_KILL_MIN_DEFAULT = 60;
+function orphanKillMin(ctx) {
+  for (const v of [process.env.DIEU_PHOI_ORPHAN_KILL_MIN, ctx.config && ctx.config.orphan_kill_min]) {
+    if (v === undefined || v === null || v === '') continue;
+    const n = Number(v);
+    if (Number.isFinite(n) && n >= 1) return n;
+  }
+  return ORPHAN_KILL_MIN_DEFAULT;
+}
+
+/**
+ * `dieu-phoi reap [--yes] [--session <id>] [--json]`: stuck / orphaned live agents (data/live) of every session on this
+ * DIEU_PHOI_HOME, or one session. Dry-run by default. --yes deletes their live files (frees the parallel-cap slot; a live
+ * agent's next --watch re-registers it), writes one `reap` event each (local only), and kills their child processes only
+ * when attributable to that agent alone: kill_leftovers 'guarded' (default, s7) = reapProcsOf targets, each re-checked
+ * (pid + creation time) right before; true = the 0.7.2 tree kill; false = never. Worktrees are never removed.
+ * --orphans adds tail / sleep / Claude Code shells orphaned for over orphan_kill_min (60) minutes (killed with --yes).
+ * deps (tests): { procs: list|null, relist() -> list (default: procs again), kill(pids) -> pids, now }.
+ */
+function cmdReap(opts, deps) {
+  const d = deps || {};
+  const ctx = ctxOf(opts);
+  const yes = opts.yes === true || opts.yes === 'y' || opts.yes === 'yes';
+  const sid = typeof opts.session === 'string' && opts.session ? opts.session : null;
+  const now = typeof d.now === 'number' ? d.now : Date.now();
+  const lim = core.stuckLimits(ctx);
+  const all = core.readLive(ctx, now).agents;
+  const cands = core.stuckAgents(ctx, { now, limits: lim, sessionId: sid });
+  const candIds = new Set(cands.map((a) => a.agent_id));
+  // cwd shared with another agent (live and not reaped, or a second candidate) = processes cannot be told apart
+  const cwdCount = new Map();
+  for (const r of all) { const c = normPath(r.cwd); if (c) cwdCount.set(c, (cwdCount.get(c) || 0) + 1); }
+  const shared = new Set(Array.from(cwdCount).filter(([, n]) => n > 1).map(([c]) => c));
+  const wantOrphans = opts.orphans === true;
+  const readList = () => (Object.prototype.hasOwnProperty.call(d, 'procs') ? d.procs : procs.listProcesses({ timeoutMs: 5000 }));
+  const list = cands.length || wantOrphans ? readList() : null;
+  // re-read right before killing (pid reuse); tests pass d.relist (a later process table) or reuse d.procs
+  const relist = typeof d.relist === 'function' ? d.relist : readList;
+  const mode = procs.killMode(ctx.config);
+  const killOn = mode !== 'off';
+  const killVal = procs.killModeValue(mode);
+  const kill = typeof d.kill === 'function' ? d.kill : null;
+  const rows = [];
+  for (const a of cands) {
+    const pr = reapProcsOf(a, list, shared, process.pid);
+    const row = Object.assign({}, a, {
+      procs: pr.procs.map((p) => ({ pid: p.pid, name: p.name })), procs_attributable: pr.attributable,
+      kill_targets: mode === 'guarded' && pr.targets ? pr.targets.map((p) => p.pid) : [],
+      kill_skips: mode === 'guarded' && pr.skips ? pr.skips : [],
+      killed: [], removed: false,
+    });
+    delete row.start_ms; delete row.notified;
+    if (yes) {
+      if (mode === 'tree' && pr.roots && pr.roots.length) {
+        row.killed = (kill ? kill(pr.roots.map((p) => p.pid)) : procs.killTree(pr.roots.map((p) => p.pid), { deadline: Date.now() + 10000 })) || [];
+      } else if (mode === 'guarded' && pr.targets && pr.targets.length) {
+        const res = procs.killVerified(pr.targets, { relist, kill, deadline: Date.now() + 10000 });
+        row.killed = res.killed;
+        row.kill_skips = row.kill_skips.concat(res.skipped);
+      }
+      row.removed = core.removeLive(ctx, a.agent_id);
+      try {
+        core.appendEvent(ctx, Object.assign({
+          schema: core.SCHEMA, kind: 'reap', ts: core.nowIso(), agent_id: a.agent_id, task_id: a.task_id, role: a.role, gen: a.gen,
+          parent_task_id: a.parent_task_id, session: a.session_id ? core.sha8(a.session_id) : null, reap_state: a.state,
+          reasons: a.reasons, idle_min: a.idle_min, age_min: a.age_min, worktree: a.cwd ? posixPath(a.cwd) : null,
+          procs: row.procs.length, killed: row.killed.length, killed_pids: row.killed.slice(0, 20), kill_leftovers: killVal, removed: row.removed,
+        }, row.kill_skips.length ? { kill_skips: row.kill_skips.slice(0, 20).map((s) => ({ pid: s.pid, name: String(s.name || '').toLowerCase(), reason: s.reason })) } : {},
+        core.commonFields(ctx)));
+      } catch (e) { core.logError(ctx.home, e, 'reap-event'); }
+    }
+    rows.push(row);
+  }
+  const ok = all.filter((r) => !candIds.has(r.agent_id) && (!sid || r.session_id === sid)).length;
+  // s7: `--orphans` — tail / sleep / Claude Code shells whose parent is gone, older than orphan_kill_min. Dry-run lists them;
+  // --yes kills each after re-checking pid + creation time (never with kill_leftovers:false). One local event reap_orphans.
+  let orph = null;
+  if (wantOrphans) {
+    const minMin = orphanKillMin(ctx);
+    const ot = Array.isArray(list) ? orphanTargets(list, now, minMin, d) : { found: [], skipped: [] };
+    const found = ot.found;
+    orph = {
+      min_age_min: minMin, listed: Array.isArray(list), n: found.length,
+      procs: found.map((p) => ({ pid: p.pid, name: p.name, age_min: Math.round((now - p.created) / 60000), cmd: p.cmd ? String(p.cmd).slice(0, 100) : null })),
+      killed: [], skipped: [], kept: ot.skipped,
+    };
+    if (yes && killOn && found.length) {
+      const res = procs.killVerified(found, { relist, kill, deadline: Date.now() + Math.max(20000, found.length * 3000) });
+      orph.killed = res.killed;
+      orph.skipped = res.skipped;
+    }
+    if (yes) {
+      try {
+        core.appendEvent(ctx, Object.assign({
+          schema: core.SCHEMA, kind: 'reap_orphans', ts: core.nowIso(), n: found.length, killed: orph.killed.length,
+          killed_pids: orph.killed.slice(0, 50), skipped: orph.skipped.slice(0, 20).map((s) => ({ pid: s.pid, reason: s.reason })),
+          names: Array.from(new Set(found.map((p) => String(p.name || '').toLowerCase()))).slice(0, 8), min_age_min: minMin, kill_leftovers: killVal,
+        }, core.commonFields(ctx)));
+      } catch (e) { core.logError(ctx.home, e, 'reap-orphans-event'); }
+    }
+  }
   if (opts.json) {
-    return { code: 0, out: JSON.stringify(Object.assign({}, state, hasDeltas ? { unmerged_deltas: deltas } : {}, orphans === null ? {} : { orphan_procs: orphans }), null, 2) };
+    return { code: 0, out: JSON.stringify(Object.assign({ dry_run: !yes, limits: lim, kill_leftovers: killVal, procs_listed: Array.isArray(list), live_ok: ok, agents: rows }, orph ? { orphans: orph } : {}), null, 2) };
   }
-  return { code: 0, out: [core.formatSessionState(state, core.STATE_TEXT_CAP)].concat(deltaLines, orphans === null ? [] : [`orphan_procs: ${orphans}`]).join('\n') };
+  const head = `reap${yes ? '' : ' (dry-run)'}: ${rows.length} agent kẹt/mồ côi${sid ? ` trong phiên ${core.sha8(sid)}` : ' trên máy'}; ${ok} agent live còn bình thường `
+    + `(ngưỡng: im ${lim.idle || 'tắt'} phút · tổng ${lim.hard || 'tắt'} phút · sau STATUS ${lim.after_status || 'tắt'} phút).`;
+  const lines = [head];
+  for (const r of rows) {
+    const who = `agent ${r.agent_id} task ${r.task_id || '?'} (${r.role || '?'}, gen ${r.gen}${r.session_id ? `, phiên ${core.sha8(r.session_id)}` : ''})`;
+    const procTxt = !Array.isArray(list) ? 'tiến trình: không đọc được bảng process'
+      : (!r.procs_attributable ? 'tiến trình: không quy được về riêng agent này (không có cwd / cwd dùng chung)'
+        : `tiến trình con: ${r.procs.length ? r.procs.slice(0, 6).map((p) => `${p.name} ${p.pid}`).join(', ') + (r.procs.length > 6 ? ` (+${r.procs.length - 6})` : '') : 'không có'}`);
+    const guardTxt = mode === 'guarded' && r.procs.length
+      ? `; sẽ kill ${r.kill_targets.length}${r.kill_targets.length ? ` (${r.kill_targets.slice(0, 6).join(', ')})` : ''}${r.kill_skips.length ? `, giữ ${r.kill_skips.length} [${Array.from(new Set(r.kill_skips.map((s) => s.reason))).join(', ')}]` : ''}`
+      : '';
+    const act = !yes ? '' : ` → ${r.removed ? 'đã xoá file live' : 'file live đã mất'}${r.killed.length ? `, đã kill ${r.killed.length}` : (r.procs.length ? (killOn ? ', không kill được / không có gì quy chắc về agent' : ', không kill (kill_leftovers=false)') : '')}`;
+    lines.push(`- ${who}: ${r.state === 'orphan' ? 'mồ côi' : 'kẹt'} [${core.stuckReasonText(r)}]; chạy ${r.age_min} phút, im ${r.idle_min} phút; ${procTxt}${guardTxt}${r.cwd ? `; worktree ${posixPath(r.cwd)} giữ nguyên` : ''}${act}`);
+  }
+  if (rows.length && !yes) {
+    lines.push('Agent còn sống thì TaskStop <agent_id> trong phiên của nó trước; rồi `dieu-phoi reap --yes` xoá file live (trả chỗ trần) + ghi event reap.'
+      + (mode === 'guarded' ? ' Chỉ tiến trình ghi "sẽ kill" bị kill (kill_leftovers=guarded: kiểm lại pid + giờ tạo ngay trước khi kill).'
+        : mode === 'tree' ? ' Cây tiến trình con quy được về agent sẽ bị kill (kill_leftovers=true).' : ' Tiến trình con chỉ được liệt kê (kill_leftovers=false).'));
+  }
+  if (orph) {
+    const groups = new Map();
+    for (const p of orph.procs) groups.set(String(p.name).toLowerCase(), (groups.get(String(p.name).toLowerCase()) || 0) + 1);
+    const oldest = orph.procs.length ? Math.max(...orph.procs.map((p) => p.age_min)) : 0;
+    lines.push(!orph.listed ? 'orphans: không đọc được bảng process'
+      : `orphans${yes ? '' : ' (dry-run)'}: ${orph.n} tiến trình mồ côi (cha đã thoát) quá ${orph.min_age_min} phút`
+        + (orph.n ? ` — ${Array.from(groups).map(([n, c]) => `${n} ×${c}`).join(', ')}; cũ nhất ${Math.round(oldest / 60)} giờ` : ''));
+    if (orph.kept.length) {
+      const why = new Map();
+      for (const k of orph.kept) why.set(k.reason, (why.get(k.reason) || 0) + 1);
+      lines.push(`  giữ ${orph.kept.length} cái trông mồ côi nhưng chưa chắc: ${Array.from(why).map(([r, c]) => `${r} ×${c}`).join(', ')} (msys-parent-alive = bash cha còn sống theo MSYS, việc nền đang chạy)`);
+    }
+    for (const p of orph.procs.slice(0, 10)) lines.push(`  ${p.name} ${p.pid} (${p.age_min} phút)${p.cmd ? `: ${p.cmd}` : ''}`);
+    if (orph.procs.length > 10) lines.push(`  … +${orph.procs.length - 10}`);
+    if (yes) {
+      lines.push(!killOn ? '  → không kill (kill_leftovers=false)'
+        : `  → đã kill ${orph.killed.length}/${orph.n}${orph.skipped.length ? `; bỏ qua ${orph.skipped.length} [${Array.from(new Set(orph.skipped.map((s) => s.reason))).join(', ')}]` : ''}; event reap_orphans`);
+    } else if (orph.n) lines.push('  `dieu-phoi reap --orphans --yes` để kill (kiểm lại pid + giờ tạo ngay trước khi kill).');
+  }
+  return { code: 0, out: lines.join('\n') };
 }
 
 // ------------------------------------------------------------------ stats / retro
@@ -1548,6 +1796,6 @@ function cmdPlanTable(opts) {
 }
 
 module.exports = {
-  ORCH_NEW_SESSION_TOKENS, ORCH_NEW_SESSION_COMPACTIONS, skillDirOf, cmdSetup, cmdUninstall, cmdDoctor, cmdStart, checkSinkLive, cmdHook, cmdSync, cmdVerdict, cmdSteer, cmdDiscard, ctxWarnOnce, ctxWarnLevel, sweepStaleTmp, planOverrideEvents, recordPlanSuggestions, cmdStats, cmdRetro, cmdPrune: (o) => require('./prune.cjs').cmdPrune(o), cmdChoose, cmdMode, modeEvent, cmdCtx, cmdState, orphanCheck, orphanCount, measureOrch,
+  ORCH_NEW_SESSION_TOKENS, ORCH_NEW_SESSION_COMPACTIONS, skillDirOf, cmdSetup, cmdUninstall, cmdDoctor, cmdStart, checkSinkLive, cmdHook, cmdSync, cmdVerdict, cmdSteer, cmdDiscard, ctxWarnOnce, ctxWarnLevel, sweepStaleTmp, planOverrideEvents, recordPlanSuggestions, cmdStats, cmdRetro, cmdPrune: (o) => require('./prune.cjs').cmdPrune(o), cmdChoose, cmdMode, modeEvent, cmdCtx, cmdState, cmdReap, reapProcsOf, orphanKillMin, orphanCheck, orphanCount, liveCheck, liveLine, freeSlots, measureOrch,
   cmdPlanTable, cmdNewId, requireTaskId, buildPlanTable, recordApprovedPlan, planTaskIdProblems, criticalPath, resolveAgentId, AGENT_OUTCOMES, USER_OUTCOMES, VERIFY,
 };

package/lib/deps.cjs

@@ -0,0 +1,162 @@
+'use strict';
+// core 0.7.3 (s3): node_modules dùng chung cho worktree của dieu-phoi. OPT-IN: mặc định `none`.
+//  - `--deps auto|link|install|none` (hoặc env DIEU_PHOI_WT_DEPS → config.json `wt_deps` → none).
+//  - install (và auto khi có pnpm-lock.yaml): `pnpm install --frozen-lockfile --offline` (store hardlink, không tải mạng).
+//  - link (và auto khi không có pnpm-lock.yaml): junction <worktree>/<deps_path>/node_modules → node_modules của checkout
+//    chính, CHỈ khi package-lock.json giống hệt từng byte, package.json không có `workspaces`, và checkout chính có
+//    node_modules là thư mục thật. Còn lại → none + gợi ý. Không bao giờ ghi vào node_modules của checkout chính.
+//  - Gỡ an toàn: unlinkDepLinks gỡ junction (không đi xuyên) TRƯỚC `git worktree remove`; removeShell xoá vỏ còn sót
+//    bằng cách duyệt lstat, link nào cũng chỉ unlink, không bao giờ đi vào đích.
+const fs = require('fs');
+const path = require('path');
+const cp = require('child_process');
+
+const MODES = ['auto', 'link', 'install', 'none'];
+const INSTALL_TIMEOUT_MS = 10 * 60 * 1000;
+
+function isLink(p) {
+  try { return fs.lstatSync(p).isSymbolicLink(); } catch (_) { return false; }
+}
+function isRealDir(p) {
+  try { const st = fs.lstatSync(p); return st.isDirectory() && !st.isSymbolicLink(); } catch (_) { return false; }
+}
+
+/** deps_path tương đối, nằm trong worktree ('.' = gốc). Ném nếu tuyệt đối hoặc thoát ra ngoài. */
+function normDepsPath(p) {
+  if (p === undefined || p === null || p === true || p === '') return '.';
+  if (typeof p !== 'string' || path.isAbsolute(p)) throw new Error('--deps-path cần đường dẫn tương đối trong repo (vd. cli)');
+  const n = path.normalize(p).replace(/\\/g, '/').replace(/\/+$/, '') || '.';
+  if (n === '..' || n.startsWith('../')) throw new Error('--deps-path không được ra ngoài repo');
+  return n;
+}
+
+/** Chế độ: --deps → env DIEU_PHOI_WT_DEPS → config `wt_deps` → none. Giá trị hỏng từ cờ thì ném; từ env/config thì none. */
+function depsModeOf(opts, ctx) {
+  if (opts && opts.deps !== undefined) {
+    if (typeof opts.deps !== 'string' || !MODES.includes(opts.deps)) throw new Error(`--deps cần một trong: ${MODES.join('|')}`);
+    return opts.deps;
+  }
+  const env = process.env.DIEU_PHOI_WT_DEPS;
+  const raw = env !== undefined && env !== '' ? env : (ctx && ctx.config ? ctx.config.wt_deps : undefined);
+  return typeof raw === 'string' && MODES.includes(raw) ? raw : 'none';
+}
+
+function readFileOrNull(p) {
+  try { return fs.readFileSync(p); } catch (_) { return null; }
+}
+
+/** Lý do không được junction (null = được). */
+function linkBlocker(mainDir, wtDir) {
+  const wtLock = readFileOrNull(path.join(wtDir, 'package-lock.json'));
+  if (!wtLock) return 'worktree không có package-lock.json';
+  const mainLock = readFileOrNull(path.join(mainDir, 'package-lock.json'));
+  if (!mainLock) return 'checkout chính không có package-lock.json';
+  // Giống hệt từng byte, chỉ bỏ qua khác biệt CRLF/LF (core.autocrlf trên Windows checkout worktree ra CRLF trong khi
+  // npm ghi LF vào checkout chính; nội dung lock vẫn là một).
+  const lf = (b) => b.toString('utf8').replace(/\r\n/g, '\n');
+  if (!wtLock.equals(mainLock) && lf(wtLock) !== lf(mainLock)) return 'package-lock.json khác checkout chính';
+  let pkg;
+  try { pkg = JSON.parse(fs.readFileSync(path.join(wtDir, 'package.json'), 'utf8')); } catch (_) { return 'không đọc được package.json'; }
+  if (pkg && pkg.workspaces) return 'package.json có workspaces';
+  if (!isRealDir(path.join(mainDir, 'node_modules'))) return 'checkout chính chưa có node_modules (thư mục thật)';
+  if (fs.existsSync(path.join(wtDir, 'node_modules')) || isLink(path.join(wtDir, 'node_modules'))) return 'worktree đã có node_modules';
+  return null;
+}
+
+/** Lệnh pnpm: env DIEU_PHOI_PNPM_BIN (đường dẫn) hoặc `pnpm` trên PATH. .cmd/.bat (và `pnpm` trên Windows) cần shell. */
+function pnpmSpawn(args, cwd, timeout) {
+  const bin = process.env.DIEU_PHOI_PNPM_BIN || 'pnpm';
+  const shell = process.platform === 'win32' && (!process.env.DIEU_PHOI_PNPM_BIN || /\.(cmd|bat)$/i.test(bin));
+  const cmd = shell && /\s/.test(bin) ? `"${bin}"` : bin;
+  return cp.spawnSync(cmd, args, { cwd, encoding: 'utf8', windowsHide: true, timeout, shell });
+}
+
+function pnpmInstall(wtDir) {
+  const v = pnpmSpawn(['--version'], wtDir, 30000);
+  if (v.error || v.status !== 0) return { deps: 'none', note: 'deps none: repo dùng pnpm nhưng không chạy được pnpm (vắng trên PATH?) — cài pnpm rồi chạy `pnpm install --offline` trong worktree' };
+  const r = pnpmSpawn(['install', '--frozen-lockfile', '--offline'], wtDir, INSTALL_TIMEOUT_MS);
+  if (r.error || r.status !== 0) {
+    const tail = String((r.stderr || '') + (r.stdout || '')).trim().split(/\r?\n/).slice(-3).join(' | ');
+    return { deps: 'none', note: `deps none: pnpm install --frozen-lockfile --offline lỗi (${r.error ? r.error.message : `exit ${r.status}`}${tail ? `: ${tail}` : ''}) — store thiếu gói? chạy pnpm install có mạng trong worktree` };
+  }
+  return { deps: 'pnpm', note: 'deps pnpm: đã chạy pnpm install --frozen-lockfile --offline (hardlink từ store)' };
+}
+
+/**
+ * Chuẩn bị node_modules cho worktree vừa tạo. Không ném: lỗi nào cũng thành deps none + ghi chú.
+ * Trả { deps: 'link'|'pnpm'|'none', note|null }.
+ */
+function setupDeps({ main, wtPath, mode, depsPath }) {
+  if (mode === 'none') return { deps: 'none', note: null };
+  const rel = depsPath || '.';
+  const mainDir = path.join(main, rel);
+  const wtDir = path.join(wtPath, rel);
+  if (!fs.existsSync(path.join(wtDir, 'package.json'))) return { deps: 'none', note: `deps none: không có package.json ở ${rel} (dùng --deps-path <thư mục con>)` };
+  const pnpm = fs.existsSync(path.join(wtDir, 'pnpm-lock.yaml'));
+  if (pnpm && (mode === 'auto' || mode === 'install')) return pnpmInstall(wtDir);
+  if (pnpm) return { deps: 'none', note: 'deps none: repo dùng pnpm — dùng --deps install (hoặc auto) thay cho link' };
+  if (mode === 'install') return { deps: 'none', note: 'deps none: --deps install chỉ hỗ trợ pnpm (không có pnpm-lock.yaml); repo npm dùng --deps link hoặc auto' };
+  const why = linkBlocker(mainDir, wtDir);
+  if (why) return { deps: 'none', note: `deps none: không junction được (${why}) — chạy npm ci trong worktree nếu cần` };
+  try {
+    fs.symlinkSync(path.join(mainDir, 'node_modules'), path.join(wtDir, 'node_modules'), 'junction');
+  } catch (e) {
+    return { deps: 'none', note: `deps none: tạo junction lỗi (${e.message})` };
+  }
+  return { deps: 'link', note: `deps link: ${path.join(wtDir, 'node_modules')} → ${path.join(mainDir, 'node_modules')} (junction, dùng chung, không ghi vào)` };
+}
+
+/** Bỏ một link (symlink/junction) mà không đi xuyên. Ném nếu p không phải link. */
+function unlinkOnly(p) {
+  if (!isLink(p)) throw new Error(`không phải link: ${p}`);
+  try { fs.unlinkSync(p); } catch (e) {
+    // Windows: junction/symlink thư mục đôi khi cần rmdir (RemoveDirectory chỉ bỏ reparse point, không chạm đích).
+    if (process.platform === 'win32') fs.rmdirSync(p); else throw e;
+  }
+}
+
+/**
+ * Gỡ mọi link node_modules của worktree (ở gốc và ở các deps_path) TRƯỚC `git worktree remove`.
+ * Trả [{ path, target }] để khôi phục nếu gỡ worktree thất bại. Ném nếu không gỡ được (khi đó KHÔNG được gỡ worktree).
+ */
+function unlinkDepLinks(wtPath, depsPaths) {
+  const seen = new Set();
+  const out = [];
+  for (const rel of ['.', ...(depsPaths || [])]) {
+    const p = path.join(wtPath, rel || '.', 'node_modules');
+    const key = path.resolve(p);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    if (!isLink(p)) continue;
+    let target = null;
+    try { target = fs.readlinkSync(p); } catch (_) { /* vẫn gỡ */ }
+    unlinkOnly(p);
+    if (isLink(p) || fs.existsSync(p)) throw new Error(`gỡ link ${p} không xong`);
+    out.push({ path: p, target });
+  }
+  return out;
+}
+
+/** Khôi phục link đã gỡ (best effort) khi `git worktree remove` thất bại. */
+function relink(links) {
+  for (const l of links || []) {
+    if (!l.target || fs.existsSync(l.path) || isLink(l.path)) continue;
+    try { fs.symlinkSync(l.target, l.path, 'junction'); } catch (_) { /* best effort */ }
+  }
+}
+
+/**
+ * Xoá vỏ thư mục worktree còn sót sau `git worktree remove` (git để lại junction/thư mục rỗng).
+ * Duyệt bằng lstat: link → chỉ unlink (không vào đích), file → xoá, thư mục thật → đệ quy rồi rmdir.
+ * Không bao giờ dùng rmSync recursive trên cây có thể chứa link.
+ */
+function removeShell(dir) {
+  if (isLink(dir)) { unlinkOnly(dir); return; }
+  let st;
+  try { st = fs.lstatSync(dir); } catch (_) { return; }
+  if (!st.isDirectory()) { fs.unlinkSync(dir); return; }
+  for (const name of fs.readdirSync(dir)) removeShell(path.join(dir, name));
+  fs.rmdirSync(dir);
+}
+
+module.exports = { MODES, depsModeOf, normDepsPath, setupDeps, unlinkDepLinks, relink, removeShell, isLink };