@kienntpixon/dieu-phoi 0.7.2 → 0.7.3

package/lib/load.cjs

@@ -0,0 +1,332 @@
+'use strict';
+// core 0.7.3 (s5): đo tải để kiểm giả thuyết (contract jiptvo5g, mục 1) — số agent đồng thời và IO đĩa.
+//   dieu-phoi load sample [--interval 10] [--count 12] [--repo R] [--json]  → data/load.jsonl, một mẫu một dòng
+//   dieu-phoi load report [--days 21] [--json]                              → phút ở mỗi mức đồng thời + tương quan IO
+// Mẫu chỉ chứa số đếm và tốc độ IO: không có đường dẫn, prompt hay nội dung task (log không lộ nội dung).
+// Hook SubagentStart ghi thêm mẫu chỉ-số-đếm (không IO) qua hook.cjs appendLoadSample.
+
+const fs = require('fs');
+const cp = require('child_process');
+const core = require('../hook.cjs');
+const args = require('./args.cjs');
+const { mainCheckoutOf, markedWorktrees } = require('./worktree.cjs');
+
+const DISK_READ = '\\PhysicalDisk(_Total)\\Disk Read Bytes/sec';
+const DISK_WRITE = '\\PhysicalDisk(_Total)\\Disk Write Bytes/sec';
+const PROC_DISKSTATS = '/proc/diskstats';
+const SECTOR_BYTES = 512;
+const DISK_WINDOW_MS = 1000;
+/** Dispatch chưa có complete: tính tối đa bằng này (= stuck_hard_min mặc định của s6). */
+const OPEN_CAP_MS = 120 * 60 * 1000;
+const MIN_MS = 60 * 1000;
+const WHOLE_DISK_RE = /^(sd[a-z]+|vd[a-z]+|xvd[a-z]+|hd[a-z]+|nvme\d+n\d+|mmcblk\d+)$/;
+const MB = 1024 * 1024;
+
+function sleepSync(ms) {
+  if (ms > 0) Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+function num(s) {
+  const t = String(s === undefined || s === null ? '' : s).trim();
+  return t === '' ? NaN : Number(t);
+}
+
+/** typeperf CSV: the last data row ("<date>","<read>","<write>") → {read, write}, or null. */
+function parseTypeperf(text) {
+  let row = null;
+  for (const line of String(text || '').split(/\r?\n/)) {
+    const m = /^"(\d[^"]*)","([^"]*)","([^"]*)"$/.exec(line.trim());
+    if (m) row = m;
+  }
+  if (!row) return null;
+  const read = num(row[2]);
+  const write = num(row[3]);
+  if (!Number.isFinite(read) || !Number.isFinite(write)) return null;
+  return { read, write };
+}
+
+/** /proc/diskstats → byte totals over whole disks only (partitions, loop and ram devices skipped), or null. */
+function parseDiskstats(text) {
+  let read = 0;
+  let write = 0;
+  let any = false;
+  for (const line of String(text || '').split('\n')) {
+    const p = line.trim().split(/\s+/);
+    if (p.length < 10 || !WHOLE_DISK_RE.test(p[2])) continue;
+    read += Number(p[5]) * SECTOR_BYTES;
+    write += Number(p[9]) * SECTOR_BYTES;
+    any = true;
+  }
+  return any ? { read, write } : null;
+}
+
+function typeperfRates() {
+  const out = cp.execFileSync('typeperf', [DISK_READ, DISK_WRITE, '-sc', '1'], {
+    encoding: 'utf8', windowsHide: true, timeout: 15000, stdio: ['ignore', 'pipe', 'ignore'],
+  });
+  return parseTypeperf(out);
+}
+
+function readDiskstats() {
+  try { return parseDiskstats(fs.readFileSync(PROC_DISKSTATS, 'utf8')); } catch (_) { return null; }
+}
+
+/**
+ * Bytes/s over one window. Windows: typeperf samples the window itself. POSIX: /proc/diskstats read twice around a
+ * DISK_WINDOW_MS sleep. Anything missing → null (never throws). deps lets the tests inject the platform and readers.
+ */
+function diskRates(deps) {
+  const d = deps || {};
+  const platform = d.platform || process.platform;
+  let r = null;
+  try {
+    if (platform === 'win32') {
+      r = (d.typeperf || typeperfRates)();
+    } else {
+      const read = d.readDiskstats || readDiskstats;
+      const a = read();
+      (d.sleep || sleepSync)(DISK_WINDOW_MS);
+      const b = read();
+      if (a && b) {
+        const secs = DISK_WINDOW_MS / 1000;
+        r = { read: (b.read - a.read) / secs, write: (b.write - a.write) / secs };
+      }
+    }
+  } catch (_) {
+    r = null;
+  }
+  if (!r) return { disk_read_Bps: null, disk_write_Bps: null };
+  return {
+    disk_read_Bps: Math.max(0, Math.round(r.read)),
+    disk_write_Bps: Math.max(0, Math.round(r.write)),
+  };
+}
+
+/** Marked worktrees that still exist in the repo at `repoDir`, or null when it is not a git checkout. */
+function markedCount(repoDir) {
+  try {
+    const { common } = mainCheckoutOf(repoDir);
+    return markedWorktrees(common).filter((w) => w.exists).length;
+  } catch (_) {
+    return null;
+  }
+}
+
+/** One sample: counts (liveLoadCounts) + IO rates + marked worktrees. */
+function collectSample(ctx, o) {
+  const now = Date.now();
+  const counts = core.liveLoadCounts(ctx, now);
+  const io = diskRates(o.deps);
+  return Object.assign({ ts: new Date(now).toISOString(), src: 'sample' }, counts,
+    { worktrees_marked: markedCount(o.repo) }, io);
+}
+
+/** Takes `count` samples `interval` seconds apart (start to start) and appends each to data/load.jsonl. */
+function sampleLoop(ctx, o) {
+  const file = core.loadFile(ctx);
+  fs.mkdirSync(ctx.paths.data, { recursive: true });
+  const recs = [];
+  for (let i = 0; i < o.count; i++) {
+    const t0 = Date.now();
+    const rec = collectSample(ctx, o);
+    fs.appendFileSync(file, `${JSON.stringify(rec)}\n`);
+    recs.push(rec);
+    if (i < o.count - 1) sleepSync(Math.max(0, o.interval * 1000 - (Date.now() - t0)));
+  }
+  return recs;
+}
+
+function numArg(v, dflt, name, min, max) {
+  if (v === undefined) return dflt;
+  const n = num(v);
+  if (!Number.isFinite(n) || n < min || n > max) throw new Error(`--${name} phải là số trong [${min}, ${max}]`);
+  return n;
+}
+
+function mbps(v) {
+  return Number.isFinite(v) ? `${(v / MB).toFixed(2)} MB/s` : 'n/a';
+}
+
+function cmdLoadSample(opts, deps) {
+  const ctx = args.ctxOf(opts);
+  const count = Math.floor(numArg(opts.count, 12, 'count', 1, 100000));
+  const interval = numArg(opts.interval, 10, 'interval', 0, 86400);
+  const repo = args.repoOf(opts);
+  const recs = sampleLoop(ctx, { count, interval, repo, deps });
+  if (opts.json) return { code: 0, out: JSON.stringify(recs, null, 2) };
+  const lines = recs.map((r) => `  ${r.ts} · máy ${r.live_machine} · hàng đợi ${r.queue} · đọc ${mbps(r.disk_read_Bps)} · ghi ${mbps(r.disk_write_Bps)}`);
+  return { code: 0, out: `dieu-phoi load sample: ${recs.length} mẫu → ${core.loadFile(ctx)}\n${lines.join('\n')}` };
+}
+
+/** Dispatch/complete events → intervals. A complete closes the oldest open dispatch of the same session+task+role. */
+function pairIntervals(events, nowMs) {
+  const sorted = events.slice().sort((a, b) => Date.parse(a.ts) - Date.parse(b.ts));
+  const open = new Map();
+  const out = [];
+  for (const e of sorted) {
+    const t = Date.parse(e.ts);
+    const key = `${e.session || ''}|${e.task_id || ''}|${e.role || ''}`;
+    if (e.kind === 'dispatch') {
+      if (!open.has(key)) open.set(key, []);
+      open.get(key).push({ t, session: e.session || '-' });
+    } else {
+      const q = open.get(key);
+      if (q && q.length) {
+        const s = q.shift();
+        out.push({ s: s.t, e: t, session: s.session, paired: true });
+      }
+    }
+  }
+  let unpaired = 0;
+  for (const q of open.values()) {
+    for (const s of q) {
+      unpaired += 1;
+      out.push({ s: s.t, e: Math.min(s.t + OPEN_CAP_MS, nowMs), session: s.session, paired: false });
+    }
+  }
+  return { intervals: out, unpaired };
+}
+
+function addMs(map, level, ms) {
+  map.set(level, (map.get(level) || 0) + ms);
+}
+
+/** Milliseconds at each concurrency level: machine (every interval) and busiest session (max over sessions). */
+function levelTimes(intervals) {
+  const marks = [];
+  for (const iv of intervals) {
+    marks.push({ t: iv.s, d: 1, sess: iv.session });
+    marks.push({ t: iv.e, d: -1, sess: iv.session });
+  }
+  marks.sort((a, b) => (a.t - b.t) || (a.d - b.d)); // ends before starts at the same instant
+  const machine = new Map();
+  const busiest = new Map();
+  const perSession = new Map();
+  let cur = 0;
+  let maxS = 0;
+  let last = null;
+  for (const m of marks) {
+    if (last !== null && m.t > last) {
+      if (cur > 0) addMs(machine, cur, m.t - last);
+      if (maxS > 0) addMs(busiest, maxS, m.t - last);
+    }
+    last = m.t;
+    cur += m.d;
+    perSession.set(m.sess, (perSession.get(m.sess) || 0) + m.d);
+    maxS = 0;
+    for (const v of perSession.values()) if (v > maxS) maxS = v;
+  }
+  return { machine, busiest };
+}
+
+function pearson(xs, ys) {
+  const n = xs.length;
+  if (n < 3) return null;
+  const mx = xs.reduce((a, b) => a + b, 0) / n;
+  const my = ys.reduce((a, b) => a + b, 0) / n;
+  let cov = 0;
+  let vx = 0;
+  let vy = 0;
+  for (let i = 0; i < n; i++) {
+    cov += (xs[i] - mx) * (ys[i] - my);
+    vx += (xs[i] - mx) ** 2;
+    vy += (ys[i] - my) ** 2;
+  }
+  if (vx === 0 || vy === 0) return null;
+  return cov / Math.sqrt(vx * vy);
+}
+
+function readLoadSamples(ctx, sinceMs) {
+  let text = '';
+  try { text = fs.readFileSync(core.loadFile(ctx), 'utf8'); } catch (_) { return []; }
+  const out = [];
+  for (const line of text.split('\n')) {
+    if (!line.trim()) continue;
+    let r = null;
+    try { r = JSON.parse(line); } catch (_) { continue; }
+    if (r && Date.parse(r.ts) >= sinceMs) out.push(r);
+  }
+  return out;
+}
+
+/** Correlation of disk read with the machine's live agent count, on samples that carry both. */
+function ioCorrelation(samples) {
+  const rows = samples.filter((r) => Number.isFinite(r.live_machine) && Number.isFinite(r.disk_read_Bps));
+  const byLevel = new Map();
+  for (const r of rows) {
+    const g = byLevel.get(r.live_machine) || { n: 0, read: 0, write: 0, writeN: 0 };
+    g.n += 1;
+    g.read += r.disk_read_Bps;
+    if (Number.isFinite(r.disk_write_Bps)) { g.write += r.disk_write_Bps; g.writeN += 1; }
+    byLevel.set(r.live_machine, g);
+  }
+  const levels = [...byLevel.entries()].sort((a, b) => a[0] - b[0]).map(([level, g]) => ({
+    live_machine: level,
+    samples: g.n,
+    mean_read_Bps: Math.round(g.read / g.n),
+    mean_write_Bps: g.writeN ? Math.round(g.write / g.writeN) : null,
+  }));
+  return {
+    samples: rows.length,
+    r: pearson(rows.map((r) => r.live_machine), rows.map((r) => r.disk_read_Bps)),
+    levels,
+  };
+}
+
+function cmdLoadReport(opts) {
+  const ctx = args.ctxOf(opts);
+  const days = numArg(opts.days, 21, 'days', 0.01, 3650);
+  const now = Date.now();
+  const since = now - days * 86400000;
+  const events = core.readEvents(ctx).filter((e) => e && (e.kind === 'dispatch' || e.kind === 'complete')
+    && Date.parse(e.ts) >= since);
+  const { intervals, unpaired } = pairIntervals(events, now);
+  const { machine, busiest } = levelTimes(intervals);
+  const toMin = (ms) => Math.round(ms / MIN_MS * 10) / 10;
+  const levels = new Map();
+  for (const k of new Set([...machine.keys(), ...busiest.keys()])) {
+    levels.set(k, { machine_min: toMin(machine.get(k) || 0), busiest_session_min: toMin(busiest.get(k) || 0) });
+  }
+  const atLeast = (m, n) => toMin([...m.entries()].filter(([k]) => k >= n).reduce((a, [, v]) => a + v, 0));
+  const samples = readLoadSamples(ctx, since);
+  const corr = ioCorrelation(samples);
+  const summary = {
+    days,
+    pairs: intervals.filter((i) => i.paired).length,
+    unpaired,
+    machine_min_at_least: { 7: atLeast(machine, 7), 9: atLeast(machine, 9) },
+    session_min_at_least: { 4: atLeast(busiest, 4) },
+    levels: [...levels.entries()].sort((a, b) => a[0] - b[0]).map(([level, v]) => Object.assign({ level }, v)),
+    load: { samples: samples.length, io_samples: corr.samples, r: corr.r === null ? null : Math.round(corr.r * 100) / 100, by_machine: corr.levels },
+  };
+  if (opts.json) return { code: 0, out: JSON.stringify(summary, null, 2) };
+  return { code: 0, out: formatReport(summary) };
+}
+
+function formatReport(s) {
+  const head = `dieu-phoi load report — ${s.days} ngày · ${s.pairs} agent có cả dispatch và complete · ${s.unpaired} dispatch chưa đóng (tính tối đa 120 phút)`;
+  const rows = ['Đồng thời | toàn máy (phút) | phiên lớn nhất (phút)', '---|---|---'];
+  for (const l of s.levels) rows.push(`${l.level} | ${l.machine_min} | ${l.busiest_session_min}`);
+  if (!s.levels.length) rows.push('(không có agent trong khoảng này)');
+  const mark = `Mốc: toàn máy ≥7 agent ${s.machine_min_at_least[7]} phút · toàn máy ≥9 ${s.machine_min_at_least[9]} phút · một phiên ≥4 ${s.session_min_at_least[4]} phút`;
+  const ld = s.load;
+  const corrLine = ld.io_samples < 3
+    ? `Tải IO: ${ld.samples} mẫu trong data/load.jsonl, ${ld.io_samples} có IO đĩa — chưa đủ để tương quan (chạy \`dieu-phoi load sample\`).`
+    : `Tải IO: ${ld.io_samples} mẫu có IO · tương quan r(agent toàn máy, đọc đĩa) = ${ld.r === null ? 'n/a' : ld.r} (chỉ báo: IO là của cả máy, không riêng agent).`;
+  const lvl = ld.by_machine.map((g) => `${g.live_machine} | ${g.samples} | ${(g.mean_read_Bps / MB).toFixed(2)} | ${g.mean_write_Bps === null ? 'n/a' : (g.mean_write_Bps / MB).toFixed(2)}`);
+  const lvlTable = lvl.length ? ['Agent toàn máy | mẫu | đọc TB (MB/s) | ghi TB (MB/s)', '---|---|---|---', ...lvl] : [];
+  return [head, '', ...rows, '', mark, '', corrLine, ...lvlTable].join('\n');
+}
+
+function cmdLoad(opts) {
+  const sub = opts._[0];
+  if (sub === 'sample') return cmdLoadSample(opts);
+  if (sub === 'report') return cmdLoadReport(opts);
+  throw new Error('Cú pháp: dieu-phoi load sample [--interval 10] [--count 12] [--repo R] [--json]\n'
+    + '         dieu-phoi load report [--days 21] [--json]');
+}
+
+module.exports = {
+  cmdLoad, cmdLoadSample, cmdLoadReport, parseTypeperf, parseDiskstats, diskRates, collectSample, sampleLoop,
+  pairIntervals, levelTimes, pearson, ioCorrelation, readLoadSamples, DISK_READ, DISK_WRITE, OPEN_CAP_MS,
+};

package/lib/procs.cjs

@@ -2,7 +2,7 @@
 // s16 (core 0.7.2): read-only look at the process table. Everything here that decides something is a pure function over a
 // plain list [{pid, ppid, name, created (epoch ms | null), ws (bytes | null), cmd}], so tests feed fixture lists and never
 // touch the system. Only listProcesses() and killTree() reach the OS; listProcesses never throws (null on any failure),
-// killTree is called by the hook only when config kill_leftovers is true.
+// killTree (kill_leftovers:true, the 0.7.2 behaviour) and killVerified (s7, default 'guarded') are the only kill paths.
 
 const cp = require('child_process');
 
@@ -216,8 +216,207 @@ function killTree(pids, o) {
   return done;
 }
 
+// ------------------------------------------------------------------ guarded kill (core 0.7.3 s7)
+
+// Never killed by any dieu-phoi path, whatever the attribution says: Claude Code itself, the shared code graph, console
+// hosts, Docker / WSL / Hyper-V, Unity, the user's apps (Orca, PixChat, editors, terminals, Explorer) and Windows itself.
+const NEVER_KILL_RE = [
+  /^claude(\.exe)?$/, /^codebase-memory-mcp/, /^conhost(\.exe)?$/, /^openconsole(\.exe)?$/, /^windowsterminal(\.exe)?$/,
+  /^com\.docker\./, /^docker/, /^wsl/, /^vmmem/, /^vmwp(\.exe)?$/, /^vmcompute(\.exe)?$/, /^unity/,
+  /^orca/, /^pixchat/, /^explorer(\.exe)?$/, /^code(\.exe)?$/, /^cursor(\.exe)?$/, /^devenv(\.exe)?$/, /^rider/,
+  /^(system|idle|registry|smss|csrss|wininit|winlogon|services|lsass|svchost|dwm|sihost|taskhostw|fontdrvhost|ctfmon|runtimebroker|searchhost|shellexperiencehost|startmenuexperiencehost|memory compression)(\.exe)?$/,
+];
+const isNeverKill = (p) => NEVER_KILL_RE.some((re) => re.test(lower(p && p.name)));
+// What Claude Code's Bash / PowerShell tools start under claude.exe. Other direct children of claude.exe are MCP servers
+// (node, npx, cmd /c, uvx, python...): the session's own, never an agent's leftover.
+const AGENT_SHELL_RE = /^(bash|sh|zsh|dash|powershell|pwsh)(\.exe)?$/;
+// Orphans `reap --orphans` may clean: keep-alive / watcher commands, and Claude Code shells (the snapshot path is in their cmd).
+const ORPHAN_KILL_NAMES = ['tail.exe', 'tail', 'sleep.exe', 'sleep'];
+const isClaudeShell = (p) => AGENT_SHELL_RE.test(lower(p.name)) && /shell-snapshots/i.test(p.cmd || '');
+const normPath = (s) => String(s || '').replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
+
+/**
+ * `kill_leftovers` mode: env DIEU_PHOI_KILL_LEFTOVERS → config → 'guarded'. true/'true'/'1' = 'tree' (0.7.2: kill the tree
+ * roots with taskkill /T), false/'false'/'0'/'off' = 'off', anything else = 'guarded'.
+ */
+function killMode(config, env) {
+  const e = (env || process.env).DIEU_PHOI_KILL_LEFTOVERS;
+  for (const v of [e, config && config.kill_leftovers]) {
+    if (v === undefined || v === null || v === '') continue;
+    if (v === true || /^(true|1|yes|tree)$/i.test(String(v))) return 'tree';
+    if (v === false || /^(false|0|no|off)$/i.test(String(v))) return 'off';
+    return 'guarded';
+  }
+  return 'guarded';
+}
+
+/** The value written as `kill_leftovers` in events: true / false / 'guarded' (what the user would put in config). */
+const killModeValue = (mode) => (mode === 'tree' ? true : mode === 'off' ? false : 'guarded');
+
+/** Has p a claude.exe below it (another session / a nested Claude Code)? Killing p would take that session down. */
+function hostsClaude(list, pid) {
+  return descendants(list, pid).some((c) => /^claude(\.exe)?$/.test(lower(c.name)));
+}
+
+/**
+ * Guarded selection over leftover candidates (descendants of the session's claude.exe created since the agent started, see
+ * leftoverProcesses). Keeps only processes attributable to that agent:
+ *   - not on the never-kill list (nor any ancestor below the root), no claude.exe below it;
+ *   - reached through an agent shell (bash / powershell) that claude.exe started, not through an MCP server;
+ *   - its command line (or an ancestor's, up to the root) is inside the agent's own worktree (`worktree`; the caller passes
+ *     it only when no other agent shares it), OR `exclusive` (no other dp agent of this home ran meanwhile).
+ * Returns { kill: [p], skip: [{pid, name, reason}] }. Pure.
+ */
+function guardedSelect(list, cands, o) {
+  const opt = o || {};
+  const idx = byPid(list);
+  const wt = opt.worktree ? normPath(opt.worktree) : '';
+  const kill = [];
+  const skip = [];
+  for (const p of cands || []) {
+    let reason = null;
+    if (isNeverKill(p)) reason = 'never-kill';
+    else if (hostsClaude(list, p.pid)) reason = 'hosts-claude';
+    else {
+      const chain = [p]; // p up to (not including) the root
+      let cur = p;
+      for (let i = 0; i < 64 && cur && cur.ppid !== opt.rootPid; i++) { cur = idx.get(cur.ppid); if (cur) chain.push(cur); }
+      const top = chain[chain.length - 1];
+      if (!cur || !opt.rootPid || top.ppid !== opt.rootPid) reason = 'not-under-session';
+      else if (!AGENT_SHELL_RE.test(lower(top.name))) reason = 'not-via-agent-shell';
+      else if (chain.some(isNeverKill)) reason = 'never-kill-ancestor';
+      else if (!opt.exclusive && !(wt && chain.some((c) => normPath(c.cmd).includes(wt)))) reason = 'not-attributable';
+    }
+    if (reason) skip.push({ pid: p.pid, name: p.name, reason });
+    else kill.push(p);
+  }
+  return { kill, skip };
+}
+
+/**
+ * Orphans `reap --orphans` may kill: tail / sleep (any cmd) and Claude Code shells (cmd has shell-snapshots) whose parent
+ * is gone (or whose parent pid was reused later), older than minAgeMs, not never-kill, no claude.exe below. Oldest first.
+ */
+function killableOrphans(list, o) {
+  const opt = o || {};
+  const now = typeof opt.now === 'number' ? opt.now : Date.now();
+  const names = new Set(ORPHAN_KILL_NAMES);
+  const idx = byPid(list);
+  return (list || []).filter((p) => (names.has(lower(p.name)) || isClaudeShell(p)) && isOrphan(p, idx)
+    && p.created && now - p.created >= (opt.minAgeMs || 0) && !isNeverKill(p) && !hostsClaude(list, p.pid))
+    .sort((a, b) => a.created - b.created);
+}
+
+// Git-bash (MSYS2) trap: when bash runs its last command it execs it, and on Windows that means a NEW process whose
+// Windows parent (the bash.exe stub) exits at once. A live `bash -c "tail -f x"` / Monitor therefore shows a dead PPID from
+// the first second. Only the MSYS process table (`ps -al`: PID PPID PGID WINPID ...) keeps the logical parent, so on
+// Windows an orphan counts only if MSYS also says so: MSYS parent 1 or no longer in the table.
+const MSYS_PS_CANDIDATES = ['C:\\Program Files\\Git\\usr\\bin\\ps.exe', 'C:\\Program Files (x86)\\Git\\usr\\bin\\ps.exe', 'C:\\msys64\\usr\\bin\\ps.exe'];
+
+/** `ps -al` of MSYS -> { byWin: Map(winpid -> {pid, ppid}), pids: Set(msys pid) }, or null when nothing parses. */
+function parseMsysPs(text) {
+  const byWin = new Map();
+  const pids = new Set();
+  for (const line of String(text || '').split(/\r?\n/)) {
+    const m = /^[ A-Z]\s*(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s/.exec(line);
+    if (!m) continue;
+    const pid = Number(m[1]);
+    pids.add(pid);
+    byWin.set(Number(m[4]), { pid, ppid: Number(m[2]) });
+  }
+  return pids.size ? { byWin, pids } : null;
+}
+
+/**
+ * MSYS process table of this machine, or null (not Windows, no Git-bash ps.exe, error). `hints` = command lines of the
+ * candidates (the ps.exe next to their tail.exe is the right runtime); `exec(file, args, {timeout})` injectable. Never throws.
+ */
+function msysTable(o) {
+  const opt = o || {};
+  const exec = typeof opt.exec === 'function' ? opt.exec : defaultExec;
+  if (process.env.DIEU_PHOI_NO_PROCS === '1' && typeof opt.exec !== 'function') return null;
+  const dirs = [];
+  for (const c of opt.hints || []) {
+    const m = /^"?([A-Za-z]:\\[^"]*?\\usr\\bin)\\[^\\"]+\.exe/i.exec(String(c || ''));
+    if (m && !dirs.includes(m[1])) dirs.push(m[1]);
+  }
+  const files = dirs.map((d) => `${d}\\ps.exe`).concat(MSYS_PS_CANDIDATES, ['ps']);
+  for (const f of files) {
+    try {
+      const out = exec(f, ['-al'], { timeout: opt.timeoutMs || DEFAULT_TIMEOUT_MS });
+      const t = typeof out === 'string' ? parseMsysPs(out) : null;
+      if (t) return t;
+    } catch (_) { /* next */ }
+  }
+  return null;
+}
+
+/**
+ * Orphan candidates that the MSYS table confirms (MSYS parent 1 or gone). msys null = unreadable: nothing is confirmed.
+ * Returns { keep: [p], skip: [{pid, name, reason: 'msys-parent-alive'|'msys-unknown'|'msys-unverifiable'}] }. Pure.
+ */
+function msysConfirm(cands, msys) {
+  const keep = [];
+  const skip = [];
+  for (const p of cands || []) {
+    const m = msys && msys.byWin.get(p.pid);
+    if (!msys) skip.push({ pid: p.pid, name: p.name, reason: 'msys-unverifiable' });
+    else if (!m) skip.push({ pid: p.pid, name: p.name, reason: 'msys-unknown' });
+    else if (m.ppid !== 1 && msys.pids.has(m.ppid)) skip.push({ pid: p.pid, name: p.name, reason: 'msys-parent-alive' });
+    else keep.push(p);
+  }
+  return { keep, skip };
+}
+
+/** Kill single processes (no /T: what is below stays unless it is a target too). Returns the pids stopped; never throws. */
+function killPids(pids, o) {
+  const opt = o || {};
+  const done = [];
+  for (const pid of pids || []) {
+    const left = opt.deadline ? opt.deadline - Date.now() : 3000;
+    if (left <= 0) break;
+    try {
+      if ((opt.platform || process.platform) === 'win32') {
+        const r = cp.spawnSync('taskkill', ['/PID', String(pid), '/F'], { timeout: Math.min(3000, left), windowsHide: true });
+        if (!r.error && r.status === 0) done.push(pid);
+      } else {
+        process.kill(pid, 'SIGTERM');
+        done.push(pid);
+      }
+    } catch (_) { /* gone already or not ours */ }
+  }
+  return done;
+}
+
+/**
+ * Re-read the process table right before killing; kill only targets still there with the same creation time and name
+ * (a pid reused by an unrelated process is never killed). `relist()` -> list|null, `kill(pids)` -> pids (default killPids).
+ * Returns { killed: [pid], skipped: [{pid, name, reason: 'gone'|'pid-reused'|'no-created'|'unverifiable'}] }. Never throws.
+ */
+function killVerified(targets, o) {
+  const opt = o || {};
+  let fresh = null;
+  try { fresh = typeof opt.relist === 'function' ? opt.relist() : null; } catch (_) { fresh = null; }
+  if (!Array.isArray(fresh)) return { killed: [], skipped: (targets || []).map((t) => ({ pid: t.pid, name: t.name, reason: 'unverifiable' })) };
+  const idx = byPid(fresh);
+  const ok = [];
+  const skipped = [];
+  for (const t of targets || []) {
+    const cur = idx.get(t.pid);
+    if (!t.created) skipped.push({ pid: t.pid, name: t.name, reason: 'no-created' });
+    else if (!cur) skipped.push({ pid: t.pid, name: t.name, reason: 'gone' });
+    else if (cur.created !== t.created || lower(cur.name) !== lower(t.name)) skipped.push({ pid: t.pid, name: t.name, reason: 'pid-reused' });
+    else ok.push(t.pid);
+  }
+  let killed = [];
+  try { killed = ok.length ? ((typeof opt.kill === 'function' ? opt.kill(ok) : killPids(ok, { deadline: opt.deadline })) || []) : []; } catch (_) { killed = []; }
+  return { killed, skipped };
+}
+
 module.exports = {
   PS_WIN, ORPHAN_NAMES, LEFTOVER_SKIP_NAMES,
   parseWindowsJson, parsePs, listProcesses,
   descendants, ancestors, claudeAncestor, orphans, staleOrphans, isCbmDaemon, leftoverProcesses, killTree,
+  NEVER_KILL_RE, ORPHAN_KILL_NAMES, AGENT_SHELL_RE, isNeverKill, isClaudeShell, isOrphan, killMode, killModeValue, hostsClaude,
+  guardedSelect, killableOrphans, killPids, killVerified, MSYS_PS_CANDIDATES, parseMsysPs, msysTable, msysConfirm,
 };

package/lib/prune.cjs

@@ -321,6 +321,8 @@ function cmdPrune(opts) {
     bytes: rp.prune.reduce((n, r) => n + r.delete_bytes, 0) + plans.reduce((n, p) => n + p.bytes, 0),
   };
 
+  let removedLines = 0; // lines actually dropped from events.jsonl under the lock (what the message reports)
+  let freshCount = 0; // of those, lines newly written into the archive (the rest were there from an earlier run)
   if (yes) {
     // 0. a session other than this one touched the log recently => refuse (a live hook could be mid-append)
     const busy = opts.force === true ? null : otherSessionActive(ctx, opts, allEvents);
@@ -335,6 +337,7 @@ function cmdPrune(opts) {
     // 1. events → archive (archive first + verified, then rewrite events.jsonl via temp + rename)
     if (moving.length) {
       const fresh = moving.filter((l) => !archived.has(l.text));
+      freshCount = fresh.length;
       const lock = core.acquireLock(ctx.paths.lock);
       if (!lock) return { code: 1, out: 'prune: sync đang giữ khoá — thử lại sau' };
       try {
@@ -351,6 +354,7 @@ function cmdPrune(opts) {
           for (const l of core.eventLinesFrom(buf, 0)) {
             parts.push(buf.subarray(pos, l.start)); // blank lines between
             if (drop.get(l.start) === l.text) {
+              removedLines++;
               if (l.end <= off) removedBeforeOffset += l.end - l.start;
             } else parts.push(buf.subarray(l.start, l.end));
             pos = l.end;
@@ -367,6 +371,8 @@ function cmdPrune(opts) {
         try { fs.unlinkSync(ctx.paths.lock); } catch (_) { /* gone */ }
       }
     }
+    report.events.moved = removedLines;
+    report.events.archived_new = freshCount;
     // 2a. unmerged deltas older than 30 d without a user verdict -> runs/_archive/deltas/<run>/ (moved, not deleted)
     for (const r of rp.prune) {
       for (const n of r.archive) {
@@ -398,7 +404,10 @@ function cmdPrune(opts) {
   L.push(`Run dir: ${rp.prune.length} sẽ dọn, ${rp.skipped.length} giữ nguyên (còn mở / sau mốc)`);
   for (const r of rp.prune) L.push(`  ${r.id}: xoá ${r.del.length} mục (${human(r.delete_bytes)}), giữ ${r.keep.length} (${human(r.keep_bytes)}), trong đó delta chưa gộp ${r.keep_deltas}${r.archive.length ? `; chuyển ${r.archive.length} delta >30 ngày chưa có verdict sang _archive/deltas/` : ''}`);
   L.push(`Plan hỏng: ${plans.length} (${human(plans.reduce((n, p) => n + p.bytes, 0))})${plans.length ? ` — ${plans.map((p) => p.name).join(', ')}` : ''}`);
-  L.push(`events.jsonl: ${moving.length}/${lines.length} dòng → archive/events-${archiveToday()}.jsonl.gz (${human(evBytes)})${heldBack ? `; ${heldBack} dòng chưa đẩy lên sink nên giữ lại` : ''}; không xoá dòng nào`);
+  const evTxt = yes
+    ? `đã chuyển ${removedLines}/${lines.length} dòng vào archive và xoá khỏi events.jsonl (${freshCount} dòng ghi mới${freshCount ? ` vào archive/events-${archiveToday()}.jsonl.gz` : ''}; ${human(evBytes)})`
+    : `sẽ chuyển ${moving.length}/${lines.length} dòng vào archive/events-${archiveToday()}.jsonl.gz và xoá khỏi events.jsonl (${human(evBytes)})`;
+  L.push(`events.jsonl: ${evTxt}${heldBack ? `; ${heldBack} dòng chưa đẩy lên sink nên giữ lại` : ''}`);
   L.push(`Tổng xoá khỏi đĩa: ${report.totals.files} mục run dir + ${plans.length} plan = ${human(report.totals.bytes)}`);
   return { code: 0, out: L.join('\n') };
 }