@kienntpixon/dieu-phoi 0.7.2 → 0.7.4

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

@@ -1,6 +1,8 @@
 'use strict';
-// `dieu-phoi prune --after-retro <file> [--yes]` (core 0.5.2): post-retro cleanup of closed run dirs, bad plan
-// files and events.jsonl (moved to a gz archive, never deleted). Dry-run unless --yes.
+// `dieu-phoi prune --after-retro <file> [--yes] [--delta-days N]` (core 0.5.2): post-retro cleanup of closed run dirs,
+// bad plan files and events.jsonl (moved to a gz archive, never deleted). Dry-run unless --yes. 0.7.4 (s6): with
+// --delta-days N (default 30) rejected unmerged deltas of runs idle > N days are deleted; accepted ones never.
+// s9: `--delta-days N` alone (no --after-retro) runs only that delta step (cmdPruneDeltas).
 // Only touches: <runs dir>/<id>/, <data>/plans, <data>/events.jsonl, <data>/archive, <data>/sync-offset.json.
 
 const fs = require('fs');
@@ -58,6 +60,8 @@ function human(n) {
 // contract/steps/plan/handoff files of a run dir: the record of what was planned and handed over (never pruned)
 const KEEP_RE = /^(?:contract-r.*\.md|steps-r.*\.json|plan.*\.md|handoff-.*\.md)$/;
 const DELTA_RE = /^knowledge-delta.*\.md$/i;
+const DAY_MS = 86400000;
+const DELTA_DAYS_DEFAULT = 30;
 
 /**
  * Files to keep in a run dir: retro-*.md + per task/role the highest-try result AND the newest-by-mtime result
@@ -123,6 +127,7 @@ function taskIdsOfDir(id, names, plansDir) {
 function planRuns(ctx, events, cutoffMs, protect, popts) {
   const po = popts || {};
   const nowMs = typeof po.now === 'number' ? po.now : Date.now();
+  const deltaDays = typeof po.deltaDays === 'number' ? po.deltaDays : 0;
   const cls = core.deltaClassifier(events, ctx.paths.plans);
   const runs = core.runsDir();
   const byTask = new Map();
@@ -149,6 +154,19 @@ function planRuns(ctx, events, cutoffMs, protect, popts) {
     if (!inside(runs, dir)) continue;
     const names = fs.readdirSync(dir);
     const tasks = Array.from(taskIdsOfDir(id, names, ctx.paths.plans));
+    if (po.deltaOnly) { // s9 `prune --delta-days N` alone: only the rejected unmerged deltas of an idle run, nothing else
+      let runMs = 0;
+      for (const n of names) { try { runMs = Math.max(runMs, fs.lstatSync(path.join(dir, n)).mtimeMs); } catch (_) { /* gone */ } }
+      if (nowMs - runMs <= deltaDays * DAY_MS) continue;
+      const drops = names.filter((n) => {
+        if (!DELTA_RE.test(n) || cls.deltaState(id, core.deltaTagOf(n)) !== 'reject') return false;
+        let text = null;
+        try { text = fs.readFileSync(path.join(dir, n), 'utf8'); } catch (_) { return false; }
+        return !appliedSet().has(core.deltaHash(text));
+      });
+      if (drops.length) out.prune.push({ id, dir, tasks, keep: [], keep_deltas: 0, archive: [], drop_deltas: drops, del: [], delete_bytes: 0, keep_bytes: 0 });
+      continue;
+    }
     let anyVerdict = false; let reason = null; let latest = 0;
     for (const t of tasks) {
       const evs = byTask.get(t) || [];
@@ -189,6 +207,21 @@ function planRuns(ctx, events, cutoffMs, protect, popts) {
       if (nowMs - m > core.DELTA_WINDOW_MS && cls.deltaState(id, core.deltaTagOf(n)) === null) archive.push(n);
     }
     for (const n of archive) keep.delete(n);
+    // s6 --delta-days N: a delta the user REJECTED, unmerged, in a run idle for more than N days, is no work any more:
+    // deleted with --yes. Accepted-but-unmerged (K7) and no-verdict deltas (K1: archived above, never deleted) stay.
+    const dropDeltas = [];
+    if (deltaDays > 0) {
+      let runMs = 0;
+      for (const n of names) { try { runMs = Math.max(runMs, fs.lstatSync(path.join(dir, n)).mtimeMs); } catch (_) { /* gone */ } }
+      if (nowMs - runMs > deltaDays * DAY_MS) {
+        for (const n of names) {
+          if (!DELTA_RE.test(n) || !keep.has(n) || archive.includes(n)) continue;
+          if (cls.deltaState(id, core.deltaTagOf(n)) !== 'reject' || !unmerged(n)) continue;
+          keep.delete(n);
+          dropDeltas.push(n);
+        }
+      }
+    }
     const keepDeltas = names.filter((n) => DELTA_RE.test(n) && keep.has(n)).length;
     const del = [];
     let delBytes = 0; let keepBytes = 0;
@@ -200,7 +233,7 @@ function planRuns(ctx, events, cutoffMs, protect, popts) {
       del.push({ name: n, bytes: b });
       delBytes += b;
     }
-    out.prune.push({ id, dir, tasks, keep: Array.from(keep).sort(), keep_deltas: keepDeltas, archive, del, delete_bytes: delBytes, keep_bytes: keepBytes });
+    out.prune.push({ id, dir, tasks, keep: Array.from(keep).sort(), keep_deltas: keepDeltas, archive, drop_deltas: dropDeltas, del, delete_bytes: delBytes, keep_bytes: keepBytes });
   }
   return out;
 }
@@ -275,10 +308,46 @@ function otherSessionActive(ctx, opts, events) {
   return count ? { count, sessions: Array.from(sessions), last: new Date(last).toISOString(), ownKnown: !!own } : null;
 }
 
+/**
+ * s9 `prune --delta-days N` without --after-retro: deletes (with --yes) only the rejected, unmerged deltas of runs idle
+ * for more than N days. No run dir is archived, no event moves, no bad plan goes. Dry-run otherwise.
+ */
+function cmdPruneDeltas(opts, ctx) {
+  const dd = opts['delta-days'];
+  const deltaDays = dd === true ? DELTA_DAYS_DEFAULT : Number(dd);
+  if (!Number.isFinite(deltaDays) || deltaDays < 0) return { code: 2, out: `prune: --delta-days phải là số ngày ≥ 0 (nhận: ${dd})` };
+  const runs = core.runsDir();
+  if (!path.isAbsolute(runs) || runs === path.parse(runs).root) return { code: 2, out: `prune: từ chối đường dẫn runs không an toàn: ${runs}` };
+  const yes = opts.yes === true || opts.yes === 'y' || opts.yes === 'yes';
+  const rp = planRuns(ctx, core.readEvents(ctx), 0, null, { now: typeof opts.now === 'number' ? opts.now : undefined, deltaDays, deltaOnly: true });
+  let removed = 0;
+  if (yes) {
+    for (const r of rp.prune) {
+      for (const n of r.drop_deltas) {
+        const p = path.join(r.dir, n);
+        if (!inside(r.dir, p) || !inside(runs, p)) continue;
+        fs.rmSync(p, { force: true });
+        removed++;
+      }
+    }
+  }
+  const total = rp.prune.reduce((n, r) => n + r.drop_deltas.length, 0);
+  if (opts.json) {
+    return { code: 0, out: JSON.stringify({ mode: yes ? 'apply' : 'dry-run', delta_only: true, delta_days: deltaDays,
+      runs: rp.prune.map((r) => ({ id: r.id, drop_deltas: r.drop_deltas })), totals: { drop_deltas: total, removed } }, null, 2) };
+  }
+  const L = [];
+  L.push(`prune --delta-days ${deltaDays} ${yes ? '(ĐÃ THỰC HIỆN)' : '(dry-run — thêm --yes để thực hiện)'}: chỉ delta đã từ chối, chưa gộp, của run rảnh > ${deltaDays} ngày`);
+  for (const r of rp.prune) L.push(`  ${r.id}: ${yes ? 'xoá' : 'sẽ xoá'} ${r.drop_deltas.length} delta (${r.drop_deltas.join(', ')})`);
+  L.push(`Tổng: ${total} delta ${yes ? `đã xoá ${removed}` : 'sẽ xoá'}. Không đụng run dir khác, events.jsonl, plan hay archive.`);
+  return { code: 0, out: L.join('\n') };
+}
+
 function cmdPrune(opts) {
   const ctx = ctxOf(opts);
   const retro = typeof opts['after-retro'] === 'string' ? path.resolve(opts['after-retro']) : null;
-  if (!retro) return { code: 2, out: 'prune: thiếu --after-retro <file retro>' };
+  if (!retro && opts['delta-days'] !== undefined) return cmdPruneDeltas(opts, ctx);
+  if (!retro) return { code: 2, out: 'prune: thiếu --after-retro <file retro> (hoặc --delta-days N để chỉ dọn delta đã từ chối)' };
   let st; try { st = fs.statSync(retro); } catch (_) { st = null; }
   if (!st || !st.isFile()) return { code: 2, out: `prune: không đọc được file retro: ${retro}` };
   const runs = core.runsDir();
@@ -287,10 +356,14 @@ function cmdPrune(opts) {
     if (!path.isAbsolute(p) || p === path.parse(p).root) return { code: 2, out: `prune: từ chối đường dẫn ${name} không an toàn: ${p}` };
   }
   const yes = opts.yes === true || opts.yes === 'y' || opts.yes === 'yes';
+  // --delta-days N (default 30; 0 = off): rejected unmerged deltas of runs idle > N days are deleted with --yes
+  const dd = opts['delta-days'];
+  const deltaDays = dd === undefined ? DELTA_DAYS_DEFAULT : (dd === true ? DELTA_DAYS_DEFAULT : Number(dd));
+  if (!Number.isFinite(deltaDays) || deltaDays < 0) return { code: 2, out: `prune: --delta-days phải là số ngày ≥ 0 (nhận: ${dd})` };
   const cut = cutoffOf(retro);
   const { lines } = fs.existsSync(ctx.paths.events) ? eventLines(ctx) : { lines: [] };
   const allEvents = core.readEvents(ctx);
-  const rp = planRuns(ctx, allEvents, cut.ms, retro, { now: typeof opts.now === 'number' ? opts.now : undefined });
+  const rp = planRuns(ctx, allEvents, cut.ms, retro, { now: typeof opts.now === 'number' ? opts.now : undefined, deltaDays });
   const prunedTasks = new Set();
   for (const r of rp.prune) for (const t of r.tasks) prunedTasks.add(t);
   const plans = badPlans(ctx);
@@ -308,7 +381,7 @@ function cmdPrune(opts) {
 
   const report = {
     mode: yes ? 'apply' : 'dry-run', retro, cutoff: new Date(cut.ms).toISOString(), cutoff_source: cut.source,
-    runs: rp.prune.map((r) => ({ id: r.id, delete_files: r.del.length, delete_bytes: r.delete_bytes, keep: r.keep, keep_deltas: r.keep_deltas, archive_deltas: r.archive.length, keep_bytes: r.keep_bytes })),
+    runs: rp.prune.map((r) => ({ id: r.id, delete_files: r.del.length, delete_bytes: r.delete_bytes, keep: r.keep, keep_deltas: r.keep_deltas, archive_deltas: r.archive.length, drop_deltas: r.drop_deltas.length, keep_bytes: r.keep_bytes })),
     runs_skipped: rp.skipped.length,
     skipped_reasons: rp.skipped.reduce((a, s) => { const k = s.reason.replace(/task \S+/, 'task *').replace(/\(task \S+\)/, ''); a[k] = (a[k] || 0) + 1; return a; }, {}),
     bad_plans: plans.map((p) => ({ name: p.name, bytes: p.bytes })),
@@ -317,10 +390,13 @@ function cmdPrune(opts) {
   report.totals = {
     run_dirs: rp.prune.length,
     archive_deltas: rp.prune.reduce((n, r) => n + r.archive.length, 0),
+    drop_deltas: rp.prune.reduce((n, r) => n + r.drop_deltas.length, 0),
     files: rp.prune.reduce((n, r) => n + r.del.length, 0),
     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 +411,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 +428,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 +445,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) {
@@ -396,9 +476,12 @@ function cmdPrune(opts) {
   const L = [];
   L.push(`prune ${yes ? '(ĐÃ THỰC HIỆN)' : '(dry-run — thêm --yes để thực hiện)'}: mốc cắt ${report.cutoff} (${cut.source}) từ ${retro}`);
   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/` : ''}`);
+  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/` : ''}${r.drop_deltas.length ? `; xoá ${r.drop_deltas.length} delta đã từ chối (run nằm yên >${deltaDays} ngày)` : ''}`);
   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') };
 }

package/lib/setup.cjs

@@ -67,7 +67,7 @@ function stripOurHooks(settings) {
 // (an old `Agent`-only registration is not "already registered", so `setup` rewrites it).
 const AGENT_MATCHER = 'Agent|Task';
 
-/** True when settings already hold exactly our five entries with this command. */
+/** True when settings already hold exactly our six entries with this command. */
 function alreadyRegistered(settings, cmd) {
   const hooks = settings && settings.hooks;
   if (!hooks || typeof hooks !== 'object') return false;
@@ -81,13 +81,14 @@ function alreadyRegistered(settings, cmd) {
         if (h.command !== cmd) continue;
         if (event === 'PostToolUse' && g.matcher === AGENT_MATCHER) good++;
         else if (event === 'SubagentStop') good++;
+        else if (event === 'SubagentStart' && !g.matcher) good++;
         else if (event === 'SessionStart' && g.matcher === 'compact') good++;
         else if (event === 'UserPromptSubmit' && !g.matcher) good++;
         else if (event === 'PreToolUse' && g.matcher === AGENT_MATCHER) good++;
       }
     }
   }
-  return ours === 5 && good === 5;
+  return ours === 6 && good === 6;
 }
 
 function addOurHooks(settings, hookPath) {
@@ -98,6 +99,9 @@ function addOurHooks(settings, hookPath) {
   h.PostToolUse.push({ matcher: AGENT_MATCHER, hooks: [{ type: 'command', command: cmd, timeout: 10 }] });
   if (!Array.isArray(h.SubagentStop)) h.SubagentStop = [];
   h.SubagentStop.push({ hooks: [{ type: 'command', command: cmd, timeout: 10 }] });
+  // core 0.7.3 (s1): live-agent register (data/live/<agent_id>.json) for the parallel cap; no matcher = every subagent
+  if (!Array.isArray(h.SubagentStart)) h.SubagentStart = [];
+  h.SubagentStart.push({ hooks: [{ type: 'command', command: cmd, timeout: 5 }] });
   // after /compact or auto-compact: re-inject the orchestration state rebuilt from the log
   if (!Array.isArray(h.SessionStart)) h.SessionStart = [];
   h.SessionStart.push({ matcher: 'compact', hooks: [{ type: 'command', command: cmd, timeout: 10 }] });
@@ -282,6 +286,22 @@ function nodePathOf(cmd) {
   return m ? m[1] : undefined;
 }
 
+function realOf(p) {
+  try { return fs.realpathSync.native(p); } catch (_) { return path.resolve(p); }
+}
+
+/**
+ * Rewrite hook commands inside an installed agent file whose node/hook paths resolve (symlink/junction, e.g. an
+ * Orca profile linking ~/.claude) to the same real files as ours, so the comparison ignores path spelling only.
+ */
+function normalizeHookPaths(cur, hookPath, nodePath) {
+  const myNode = realOf(nodePath || process.execPath);
+  const myHook = realOf(hookPath);
+  const mine = hookCommand(hookPath, nodePath).replace(/'/g, "''");
+  return cur.replace(/'"([^"']+)" "([^"']+)"( --[A-Za-z-]+)'/g, (m, n, h, flag) =>
+    (realOf(n) === myNode && realOf(h) === myHook ? `'${mine}${flag}'` : m));
+}
+
 /**
  * State of each dp-* agent file: ok (ours, identical), outdated (ours, differs), missing, foreign (a file with
  * that name we did not write — never touched).
@@ -295,7 +315,10 @@ function agentStatus(claudeDir, hookPath, nodePath) {
     let state = 'missing';
     if (cur !== null) {
       if (!cur.includes(AGENT_MARKER)) state = 'foreign';
-      else state = cur === renderAgent(name, hookPath, nodePath) ? 'ok' : 'outdated';
+      else {
+        const want = renderAgent(name, hookPath, nodePath);
+        state = (cur === want || normalizeHookPaths(cur, hookPath, nodePath) === want) ? 'ok' : 'outdated';
+      }
     }
     return { name, file, state };
   });
@@ -445,7 +468,7 @@ function registration(claudeDir) {
   const perms = permissionEntries(runsDir());
   const legacy = permissionEntries(legacyRunsDirOf(claudeDir));
   const out = {
-    file, PostToolUse: false, SubagentStop: false, SessionStart: false, UserPromptSubmit: false, PreToolUse: false, commands: [], permissions: false, permission_entries: perms,
+    file, PostToolUse: false, SubagentStop: false, SubagentStart: false, SessionStart: false, UserPromptSubmit: false, PreToolUse: false, commands: [], permissions: false, permission_entries: perms,
     runs_dir: perms.dir, runs_dir_exists: fs.existsSync(perms.dir), legacy_permissions: false,
   };
   let obj;
@@ -455,7 +478,7 @@ function registration(claudeDir) {
   out.legacy_permissions = legacy.allow.some((r) => Array.isArray(lp.allow) && lp.allow.includes(r))
     || (Array.isArray(lp.additionalDirectories) && lp.additionalDirectories.includes(legacy.dir));
   const hooks = obj.hooks || {};
-  for (const ev of ['PostToolUse', 'SubagentStop', 'SessionStart', 'UserPromptSubmit', 'PreToolUse']) {
+  for (const ev of ['PostToolUse', 'SubagentStop', 'SubagentStart', 'SessionStart', 'UserPromptSubmit', 'PreToolUse']) {
     for (const g of Array.isArray(hooks[ev]) ? hooks[ev] : []) {
       for (const h of (g && Array.isArray(g.hooks) ? g.hooks : [])) {
         if (!isOurs(h)) continue;