@kienntpixon/dieu-phoi 0.7.1 → 0.7.3

package/lib/commands.cjs

@@ -9,6 +9,8 @@ const agg = require('./aggregate.cjs');
 const chooser = require('./choose.cjs');
 const setupLib = require('./setup.cjs');
 const cbm = require('./cbm.cjs');
+const procs = require('./procs.cjs');
+const wt = require('./worktree.cjs');
 const { claudeDirOf, ctxOf, yesNo, repoOf } = require('./args.cjs');
 
 const AGENT_OUTCOMES = ['pass', 'fail', 'timeout', 'aborted'];
@@ -49,14 +51,24 @@ function table(rows) {
 // ------------------------------------------------------------------ setup / uninstall
 
 function cmdSetup(opts) {
-  if (opts['with-codebase-memory']) return cmdSetupWithCbm(opts);
+  if (opts['with-codebase-memory'] && !opts['dry-run']) return cmdSetupWithCbm(opts);
   const res = setupLib.setup({
     claudeDir: claudeDirOf(opts),
     dept: typeof opts.dept === 'string' ? opts.dept : undefined,
     sinkUrl: typeof opts['sink-url'] === 'string' ? opts['sink-url'] : undefined,
     sinkToken: typeof opts['sink-token'] === 'string' ? opts['sink-token'] : undefined,
     skillDir: typeof opts['skill-dir'] === 'string' ? opts['skill-dir'] : undefined,
+    dryRun: opts['dry-run'] === true,
   });
+  const seed = require('./profile-seed.cjs').seedSummary(res.profile);
+  if (res.dry_run) {
+    if (opts.json) return { code: 0, out: JSON.stringify(res, null, 2) };
+    return { code: 0, out: [
+      'setup --dry-run: không ghi gì (hook, settings.json, agent dp-*, config đều giữ nguyên)',
+      seed,
+      `Skill: ${res.skill_dir || '(không thấy; dùng --skill-dir)'}`,
+    ].join('\n') };
+  }
   if (opts.json) {
     const safe = Object.assign({}, res, { config: Object.assign({}, res.config) });
     if (safe.config.sink_token) safe.config.sink_token = '***';
@@ -65,13 +77,14 @@ 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)`,
     `Phòng ban: ${res.config.dept || '(chưa đặt, dùng --dept)'}`,
     `Sink: ${res.config.sink_url ? res.config.sink_url : '(chưa có — log chỉ lưu cục bộ)'}`,
     `Skill: ${res.config.skill_dir || '(không thấy; dùng --skill-dir)'}${res.config.skill_version ? ` v${res.config.skill_version}` : ''}`,
+    seed,
     'Khởi động lại Claude Code (hoặc mở /hooks) để hook có hiệu lực.',
   ];
   return { code: 0, out: lines.join('\n') };
@@ -131,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}`
@@ -201,6 +215,7 @@ async function cmdDoctor(opts) {
   if (orch.ctx_tokens !== null) {
     add(!orch.over, 'orch-ctx', `session ${orch.session_id}: ${orch.ctx_tokens} token, tăng ${orch.ctx_growth}/${orch.soft_cap}, ≈ ${fmtUsd(orch.cum_usd)} — ${orch.advice}`, 'CẢNH BÁO');
   }
+  add(...orphanCheck(ctx));
   if (ctx.config.sink_url && ctx.config.sink_token) {
     const cached = opts.net ? null : core.sinkStatusCached(ctx);
     if (cached && (cached.state === 'ok' || cached.state === 'fail')) {
@@ -222,6 +237,77 @@ async function cmdDoctor(opts) {
   return { code: failed ? 1 : 0, out };
 }
 
+// s16 (core 0.7.2): Claude Code / code-graph processes whose parent is gone and that are older than this
+const ORPHAN_MIN_AGE_MS = 6 * 3600 * 1000;
+const ORPHAN_CACHE_MS = 10 * 60 * 1000;
+
+/** Orphaned claude.exe / codebase-memory-mcp older than 6 h from a process list: [{pid,name,age_h,ws_mb}], or null when the list is unreadable. */
+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 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 */ }
+  // 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)${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). */
+function orphanCount(ctx, deps) {
+  const d = deps || {};
+  const now = d.now === undefined ? Date.now() : d.now;
+  const file = path.join(ctx.paths.data, 'orphan-procs.json');
+  const c = core.readJsonFile(file, null);
+  const at = c && typeof c.ts === 'string' ? Date.parse(c.ts) : NaN;
+  if (c && Number.isFinite(at) && now - at >= 0 && now - at < ORPHAN_CACHE_MS) return typeof c.n === 'number' ? c.n : null;
+  const found = orphanScan((d.listProcesses || procs.listProcesses)({ timeoutMs: 4000 }), now);
+  try {
+    core.writeFileAtomic(file, `${JSON.stringify({ ts: new Date(now).toISOString(), n: found ? found.length : null })}\n`);
+  } catch (_) { /* the cache is optional */ }
+  return found ? found.length : null;
+}
+
 const TMP_RE = /\.tmp-\d+-[0-9a-f]+$/;
 const TMP_STALE_MS = 3600 * 1000;
 
@@ -582,28 +668,79 @@ function rootOfTask(ctx, taskId) {
 }
 
 /**
- * Gate 3 (core 0.6.0): a user accept merges the run's knowledge deltas of the accepted tasks
- * (knowledge-delta-<task_id>[-r<n>].md; on --root also the root's own and untagged ones). Never fails the verdict:
- * conflicts/rejections are reported with the command to retry. --no-knowledge skips it.
+ * Run dirs that hold knowledge deltas of `tasks` (retro 11-05 K1). The delta of a task lives where its agent was told to
+ * write (the dispatch `run`, 0.7.2), which is not always runs/<root>: a loose task or one outside the approved plan has
+ * root = itself yet its brief points at the session's run. Order: runs/<root> (also takes untagged deltas when
+ * `untagged`), the dispatch `run` of each task, then any other run dir with a file tagged with one of the tasks.
+ * [{ id, dir, files, untagged }]; `scanned` = how many run dirs the fallback looked at; `rootDirExists`.
  */
-function knowledgeOnAccept(opts, ctx, root, tasks, untagged) {
-  if (opts['no-knowledge']) return null;
+function deltaRunDirs(root, tasks, events, untagged) {
   const kn = require('./knowledge.cjs');
-  const runDir = path.join(core.runsDir(), root);
-  const filter = { tasks: new Set(tasks), untagged };
+  const runsRoot = core.runsDir();
+  const want = new Set(tasks);
+  const seen = new Set();
+  const found = [];
+  let scanned = 0;
+  const consider = (id, withUntagged) => {
+    if (typeof id !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(id) || seen.has(id)) return false;
+    seen.add(id);
+    const dir = path.join(runsRoot, id);
+    try {
+      if (!fs.statSync(dir).isDirectory()) return false;
+      const files = kn.deltaFiles(dir, { tasks: want, untagged: withUntagged });
+      if (files.length) found.push({ id, dir, files, untagged: withUntagged });
+      return true;
+    } catch (_) { return false; }
+  };
+  const rootDirExists = consider(root, untagged);
+  for (const e of events || []) if (e && e.kind === 'dispatch' && want.has(e.task_id)) consider(e.run, false);
   try {
-    if (!fs.statSync(runDir).isDirectory() || !kn.deltaFiles(runDir, filter).length) return null;
-  } catch (_) { return null; }
+    for (const id of fs.readdirSync(runsRoot)) { scanned++; consider(id, false); }
+  } catch (_) { /* no runs dir */ }
+  return { found, scanned, rootDirExists };
+}
+
+/**
+ * Gate 3 (core 0.6.0): a user accept merges the knowledge deltas of the accepted tasks (knowledge-delta-<task_id>
+ * [-r<n>|-h<n>].md; on --root also the root's own and untagged ones) wherever they are (see deltaRunDirs). Never fails
+ * the verdict: conflicts/rejections are reported with the command to retry. --no-knowledge skips it.
+ * 0.7.2: never silent. It appends a local `knowledge_merge {code, files, runs}` event on every call (also with 0 files),
+ * and says so when no delta was found although the root's run dir is missing. Returns { code, out, files }.
+ */
+function knowledgeOnAccept(opts, ctx, root, tasks, untagged, events) {
+  if (opts['no-knowledge']) return null;
+  const kn = require('./knowledge.cjs');
+  const { found, scanned, rootDirExists } = deltaRunDirs(root, tasks, events, untagged);
+  const nFiles = found.reduce((n, f) => n + f.files.length, 0);
   const taskArg = tasks.join(',');
-  const retry = `dieu-phoi knowledge merge --run ${root} --task ${taskArg}${untagged ? ' --untagged' : ''}`;
-  let r;
-  try {
-    r = kn.cmdMerge({ _: [], run: runDir, task: taskArg, untagged, repo: opts.repo });
-  } catch (e) {
-    return { code: 1, out: `knowledge: gộp lỗi (${e.message}) — chạy lại: ${retry}` };
+  const outs = [];
+  let code = 0;
+  for (const f of found) {
+    const retry = `dieu-phoi knowledge merge --run ${f.id} --task ${taskArg}${f.untagged ? ' --untagged' : ''}`;
+    let r;
+    try {
+      r = kn.cmdMerge({ _: [], run: f.dir, task: taskArg, untagged: f.untagged, repo: opts.repo });
+    } catch (e) {
+      code = Math.max(code, 1);
+      outs.push(`knowledge: gộp lỗi (${e.message}) — chạy lại: ${retry}`);
+      continue;
+    }
+    code = Math.max(code, r.code);
+    const tail = r.code ? `\n→ có mục chưa gộp: get lại mục đó, chép dòng base: mới vào delta (hoặc bỏ mục), rồi ${retry}` : '';
+    outs.push(`knowledge (tự gộp khi accept, run ${f.id}):\n${r.out}${tail}`);
   }
-  const tail = r.code ? `\n→ có mục chưa gộp: get lại mục đó, chép dòng base: mới vào delta (hoặc bỏ mục), rồi ${retry}` : '';
-  return { code: r.code, out: `knowledge (tự gộp khi accept):\n${r.out}${tail}` };
+  let note = '';
+  if (!nFiles) {
+    // nothing to merge is normal for most tasks; say it only when the run dir the root names is missing (the s1 silent case)
+    if (!rootDirExists) note = `knowledge: không có delta của ${taskArg} (run ${root} không tồn tại; đã quét ${scanned} run dir theo tên knowledge-delta-<task>*).`;
+  }
+  try {
+    core.appendEvent(ctx, Object.assign({
+      schema: core.SCHEMA, kind: 'knowledge_merge', ts: core.nowIso(), agent_id: `km:${tasks[0]}`, task_id: tasks[0],
+      code, files: nFiles, runs: found.map((f) => f.id), tasks: tasks.slice(0, 20),
+    }, core.commonFields(ctx)));
+  } catch (_) { /* the log is best effort here: the merge result is still printed */ }
+  return { code, files: nFiles, out: outs.concat(note ? [note] : []).join('\n') };
 }
 
 function cmdVerdict(opts) {
@@ -613,27 +750,33 @@ function cmdVerdict(opts) {
     const list = verdictRoot(opts, ctx, events);
     for (const x of list) core.appendEvent(ctx, x.ev);
     const root = String(opts.root);
-    const kn = knowledgeOnAccept(opts, ctx, root, [root].concat(list.map((x) => x.ev.task_id)), true);
+    const kn = knowledgeOnAccept(opts, ctx, root, [root].concat(list.map((x) => x.ev.task_id)), true, events);
+    // s17: accept của người dùng gỡ worktree có dấu của từng bước (sạch); còn thay đổi thì giữ và báo.
+    const wtLines = list.reduce((acc, x) => acc.concat(wt.cleanupTask(ctx, events, x.ev.task_id, opts.repo)), []);
     if (!list.length) {
       // Every step was already judged (e.g. accepted one by one with --task): still merge the root + untagged deltas.
       // Exit code follows the merge (0 merged or nothing new, 2 conflict or reject, 1 error); no delta at all keeps the old "nothing to do" error.
-      if (!kn) throw new Error(list.emptyMsg);
+      if (!kn || !kn.files) throw new Error(`${list.emptyMsg}${kn && kn.out ? `\n${kn.out}` : ''}`);
       const msg = `Không còn bước nào của ${root} chờ nghiệm thu; chỉ gộp delta của root và delta không thẻ.`;
       if (opts.json) { process.stderr.write(`${msg}\n${kn.out}\n`); return { code: kn.code, out: '[]' }; }
       return { code: kn.code, out: `${msg}\n${kn.out}` };
     }
     if (opts.json) {
-      if (kn) process.stderr.write(`${kn.out}\n`);
+      if (kn && kn.out) process.stderr.write(`${kn.out}\n`);
+      if (wtLines.length) process.stderr.write(`${wtLines.join('\n')}\n`);
       return { code: 0, out: JSON.stringify(list.map((x) => x.ev)) };
     }
     const msg = `Đã ghi người dùng accept cho ${list.length} bước của ${opts.root}: ${list.map((x) => `${x.step}=${x.ev.task_id}`).join(', ')}.`;
-    return { code: 0, out: kn ? `${msg}\n${kn.out}` : msg };
+    return { code: 0, out: [msg].concat(wtLines, kn && kn.out ? [kn.out] : []).join('\n') };
   }
   const ev = typeof opts.task === 'string' ? verdictUser(opts, ctx, events) : verdictAgent(opts, ctx, events);
   core.appendEvent(ctx, ev);
-  const kn = ev.by === 'user' && ev.outcome === 'accept' ? knowledgeOnAccept(opts, ctx, rootOfTask(ctx, ev.task_id), [ev.task_id], false) : null;
+  const kn = ev.by === 'user' && ev.outcome === 'accept' ? knowledgeOnAccept(opts, ctx, rootOfTask(ctx, ev.task_id), [ev.task_id], false, events) : null;
+  // s17: người dùng accept → gỡ worktree có dấu của task (sạch); reject giữ nguyên để làm lại.
+  const wtLines = ev.by === 'user' && ev.outcome === 'accept' ? wt.cleanupTask(ctx, events, ev.task_id, opts.repo) : [];
   if (opts.json) {
-    if (kn) process.stderr.write(`${kn.out}\n`);
+    if (kn && kn.out) process.stderr.write(`${kn.out}\n`);
+    if (wtLines.length) process.stderr.write(`${wtLines.join('\n')}\n`);
     return { code: 0, out: JSON.stringify(ev) };
   }
   if (ev.by === 'auto') {
@@ -641,7 +784,7 @@ function cmdVerdict(opts) {
   }
   if (ev.by === 'user') {
     const msg = `Đã ghi người dùng ${ev.outcome}${ev.cause ? ` (${ev.cause})` : ''} cho task ${ev.task_id}, vòng ${ev.round}.`;
-    return { code: 0, out: kn ? `${msg}\n${kn.out}` : msg };
+    return { code: 0, out: [msg].concat(wtLines, kn && kn.out ? [kn.out] : []).join('\n') };
   }
   return { code: 0, out: `Đã ghi ${ev.outcome} cho ${ev.agent_id}${ev.task_id ? ` (task ${ev.task_id})` : ''}.` };
 }
@@ -665,8 +808,14 @@ function cmdDiscard(opts) {
   }, core.commonFields(ctx));
   core.appendEvent(ctx, ev);
   const n = events.filter((e) => e.task_id === taskId).length;
-  if (opts.json) return { code: 0, out: JSON.stringify(ev) };
-  return { code: 0, out: `Đã loại task ${taskId} (${n} bản ghi) khỏi thống kê, choose và state. Log không bị sửa; sink nhận bản ghi discard ở lần sync kế tiếp.` };
+  // s17: task bị loại → gỡ worktree có dấu của task (sạch); còn thay đổi thì giữ và báo.
+  const wtLines = wt.cleanupTask(ctx, events, taskId, opts.repo);
+  if (opts.json) {
+    if (wtLines.length) process.stderr.write(`${wtLines.join('\n')}\n`);
+    return { code: 0, out: JSON.stringify(ev) };
+  }
+  const msg = `Đã loại task ${taskId} (${n} bản ghi) khỏi thống kê, choose và state. Log không bị sửa; sink nhận bản ghi discard ở lần sync kế tiếp.`;
+  return { code: 0, out: [msg].concat(wtLines).join('\n') };
 }
 
 // ------------------------------------------------------------------ steer
@@ -748,7 +897,10 @@ function measureOrch(opts, ctx, prof) {
 }
 
 const CTX_WARN_KEEP_MS = 14 * 24 * 3600 * 1000;
-const ORCH_NEW_SESSION_TOKENS = 400000;
+// core 0.7.2 (s11 9y3nh4cb, log 62 phiên / 4.749 lượt điều phối, số liệu trong dp-out): 400k -> 250k. Chi phí điều
+// phối mỗi lượt đứng ~0,27–0,29 $ tới 250k rồi nhảy 0,45 $ ở 250–400k; median ctx trước bước nén 211k (150–250k). Bắt buộc
+// < SESSION_CAP_TOKENS (800k) và < SESSION_CAP_COMPACTIONS (10) — test ctx-compact-count bảo vệ bất biến này.
+const ORCH_NEW_SESSION_TOKENS = 250000;
 const ORCH_NEW_SESSION_COMPACTIONS = 5;
 
 /** 0 = within the cap; 1 = over the cap, 2 = over 2×, 3 = over 4×, … */
@@ -815,22 +967,244 @@ 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
     : (process.env.CLAUDE_CODE_SESSION_ID || null);
   // retro C6: knowledge deltas older than 24 h that no store has applied (file reads only, never throws)
-  const deltas = core.scanUnmergedDeltas();
+  const deltas = core.scanUnmergedDeltasFor(ctx);
   const deltaLines = core.unmergedDeltaLines(deltas);
+  const hasDeltas = core.hasUnmergedDeltas(deltas);
   if (!sid) {
     if (opts.json) {
-      return { code: 0, out: JSON.stringify(Object.assign({ session_id: null, generated_at: core.nowIso(), runs_dir: null, plans: [], tasks: [] }, deltas.count ? { unmerged_deltas: deltas } : {})) };
+      return { code: 0, out: JSON.stringify(Object.assign({ session_id: null, generated_at: core.nowIso(), runs_dir: null, plans: [], tasks: [] }, hasDeltas ? { unmerged_deltas: deltas } : {})) };
     }
     return { code: 0, out: ['Không có session (thiếu CLAUDE_CODE_SESSION_ID, dùng --session <id>).'].concat(deltaLines).join('\n') };
   }
   const state = core.buildSessionState(core.readEvents(ctx), sid, { plansDir: ctx.paths.plans });
-  if (opts.json) return { code: 0, out: JSON.stringify(deltas.count ? Object.assign({}, state, { unmerged_deltas: deltas }) : state, null, 2) };
-  return { code: 0, out: [core.formatSessionState(state, core.STATE_TEXT_CAP)].concat(deltaLines).join('\n') };
+  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({ dry_run: !yes, limits: lim, kill_leftovers: killVal, procs_listed: Array.isArray(list), live_ok: ok, agents: rows }, orph ? { orphans: orph } : {}), null, 2) };
+  }
+  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
@@ -1273,7 +1647,8 @@ function planTypeNotes(plan) {
  * `choose --override` already logged adds nothing.
  */
 function planOverrideEvents(ctx, plan, events) {
-  const seen = new Set(events.filter((e) => e.kind === 'override').map((e) => `${e.task_id}|${e.chosen_tier}`));
+  // core 0.7.2 (K4): an implicit override must not hide the user's override of the same tier from the learning
+  const seen = new Set(events.filter((e) => e.kind === 'override' && e.source !== 'implicit').map((e) => `${e.task_id}|${e.chosen_tier}`));
   const out = [];
   for (const r of plan.steps) {
     if (!r.overridden || !r.task_id || !r.tier || !r.suggested_tier) continue;
@@ -1366,6 +1741,7 @@ function cmdPlanTable(opts) {
   const base = chooseInput(Object.assign({}, opts, { type: 'x', score: 0, override: undefined }), ctx, core.readEvents(ctx));
   delete base.override;
   const rootEv = typeof opts.root === 'string' && core.isValidTaskId(opts.root) ? core.rootModeFromEvents(base.events, opts.root) : null;
+  const modeChosen = Boolean(base.mode || rootEv || fileMode);
   base.mode = base.mode || (rootEv ? rootEv.mode : null) || fileMode || core.DEFAULT_MODE;
   const plan = buildPlanTable(raw, base);
   const problems = planTaskIdProblems(plan, opts.approve ? String(opts.root) : null);
@@ -1402,7 +1778,12 @@ function cmdPlanTable(opts) {
   }
   lines.push('');
   lines.push(`**Tổng chi phí ước tính:** ~${fmtUsd(plan.total_cost_usd)} · **Thời gian (đường găng, chạy song song khi không phụ thuộc):** ~${fmtNum(plan.critical_path_min)} phút (cộng dồn ${fmtNum(plan.sum_time_min)} phút)`);
-  lines.push(`**Mode:** ${plan.mode}${plan.self_batch_steps ? ` · Kiểm (fast): bỏ ${plan.self_batch_steps} verifier riêng, 1 verify gộp (cả suite một lần) trước khi trình người dùng` : ''}`);
+  // Mode được hỏi ở cổng 1 chỉ khi root chưa có mode và kế hoạch có ≥4 bước s≤6 (0.7.2); còn lại không hỏi
+  const shortSteps = plan.steps.filter((r) => r.action !== 'refused' && Number.isFinite(r.score) && r.score <= 6).length;
+  const modeText = modeChosen ? plan.mode : (shortSteps >= 4
+    ? `HỎI người dùng chọn mode (${shortSteps} bước s≤6): fast | normal | strict (mặc định normal); đặt bằng \`dieu-phoi mode --root ${typeof opts.root === 'string' ? opts.root : '<root_task_id>'} <mode>\``
+    : 'normal (không hỏi)');
+  lines.push(`**Mode:** ${modeText}${plan.self_batch_steps ? ` · Kiểm (fast): bỏ ${plan.self_batch_steps} verifier riêng, 1 verify gộp (cả suite một lần) trước khi trình người dùng` : ''}`);
   if (plan.rough) lines.push('', '_(thô) = ô chưa đủ 5 task, ước lượng theo giả định token của từng tier._');
   if (plan.refused.length) {
     lines.push('', `**Cảnh báo:** ${plan.refused.length} bước bị từ chối (${plan.refused.map((x) => x.step).join(', ')}), không tính vào tổng — sửa rồi chạy lại.`);
@@ -1415,6 +1796,6 @@ function cmdPlanTable(opts) {
 }
 
 module.exports = {
-  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, 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,
 };