@kienntpixon/dieu-phoi 0.7.2 → 0.7.4

package/lib/commands.cjs

@@ -77,7 +77,7 @@ function cmdSetup(opts) {
   const lines = [
     `Đã cài hook: ${res.hook}`,
     res.settings_changed
-      ? `Đã đăng ký PostToolUse(Agent) + SubagentStop + SessionStart(compact) + UserPromptSubmit + PreToolUse(Agent) trong ${res.settings}${res.backup ? ` (sao lưu: ${path.basename(res.backup)})` : ''}`
+      ? `Đã đăng ký PostToolUse(Agent) + SubagentStop + SubagentStart + SessionStart(compact) + UserPromptSubmit + PreToolUse(Agent) trong ${res.settings}${res.backup ? ` (sao lưu: ${path.basename(res.backup)})` : ''}`
       : `settings.json đã có hook, không đổi gì (${res.settings})`,
     `Agent dp-*: ${res.agents.map((a) => `${a.name}=${a.action}`).join(', ')}${res.agents.some((a) => a.action === 'skipped-foreign') ? ' (file trùng tên không phải của dieu-phoi: giữ nguyên, đổi tên rồi chạy lại setup)' : ''}`,
     `Thư mục báo cáo subagent: ${res.runs_dir} (quyền: ${res.permissions.allow.join(', ')} + additionalDirectories)`,
@@ -144,6 +144,7 @@ async function cmdDoctor(opts) {
   add(reg.PreToolUse, 'chain-gate', reg.PreToolUse
     ? 'PreToolUse(Agent) có — chặn exec tiếp nối từ handoff thứ 3 (trừ thẻ chain_ok)'
     : 'thiếu hook PreToolUse(Agent) (core 0.7.1) — chuỗi handoff dài không bị chặn; chạy lại `dieu-phoi setup`', 'CẢNH BÁO');
+  add(...liveCheck(ctx, reg));
   const permOk = reg.permissions && reg.runs_dir_exists && !reg.legacy_permissions;
   add(permOk, 'run-permissions', permOk
     ? `${reg.permission_entries.allow.join(', ')} + additionalDirectories ${reg.permission_entries.dir}`
@@ -245,22 +246,51 @@ function orphanScan(list, now) {
   return Array.isArray(list) ? procs.staleOrphans(list, { minAgeMs: ORPHAN_MIN_AGE_MS, now: now === undefined ? Date.now() : now }) : null;
 }
 
+/**
+ * doctor item `live-agents` (core 0.7.3 s1): live register data/live/ + caps. Warns when the SubagentStart hook is missing
+ * (the register then only fills from --watch) or the machine count reached warn_parallel_machine. "Toàn máy" = this
+ * DIEU_PHOI_HOME: sessions with another home have their own register.
+ */
+function liveCheck(ctx, reg) {
+  const s = core.liveSummary(ctx, null);
+  const lim = s.limits;
+  const caps = `trần phiên ${lim.session || 'tắt'}, toàn máy ${lim.machine || 'tắt'}, cảnh báo ${lim.warn || 'tắt'}`;
+  const scope = `"toàn máy" = mọi phiên dùng ${ctx.home}`;
+  if (reg && !reg.SubagentStart) {
+    return [false, 'live-agents', `thiếu hook SubagentStart (core 0.7.3) — sổ agent sống chỉ cập nhật từ --watch; chạy lại dieu-phoi setup (${s.machine} agent sống; ${caps})`, 'CẢNH BÁO'];
+  }
+  const warn = lim.warn > 0 && s.machine >= lim.warn;
+  const list = s.labels.length ? `: ${s.labels.slice(0, 6).join('; ')}${s.labels.length > 6 ? ` (+${s.labels.length - 6})` : ''}` : '';
+  return [!warn, 'live-agents', `${s.machine} agent dieu-phoi đang chạy${list} — ${caps}; ${scope}`, 'CẢNH BÁO'];
+}
+
 /** doctor item `orphan-processes`: warns with pid + age + working set and a Stop-Process hint; never kills. Returns the args of add(). */
 function orphanCheck(ctx, deps) {
   const d = deps || {};
   const now = d.now === undefined ? Date.now() : d.now;
-  const found = orphanScan((d.listProcesses || procs.listProcesses)({ timeoutMs: 4000 }), now);
+  const list = (d.listProcesses || procs.listProcesses)({ timeoutMs: 4000 });
+  const found = orphanScan(list, now);
   if (found === null) return [true, 'orphan-processes', 'không đọc được danh sách process (bỏ qua)'];
   try {
     core.writeFileAtomic(path.join(ctx.paths.data, 'orphan-procs.json'), `${JSON.stringify({ ts: new Date(now).toISOString(), n: found.length })}\n`);
   } catch (_) { /* the cache is optional */ }
-  if (!found.length) return [true, 'orphan-processes', 'không có claude.exe / codebase-memory-mcp mồ côi quá 6 giờ'];
+  // s7: tail / sleep / Claude Code shells left orphaned (Monitor, run_in_background): reported only; `reap --orphans` cleans
+  const minK = orphanKillMin(ctx);
+  const watchers = Array.isArray(list) ? orphanTargets(list, now, minK, d).found : [];
+  const wMb = watchers.reduce((n, p) => n + (p.ws ? Math.round(p.ws / 1048576) : 0), 0);
+  const wTxt = watchers.length
+    ? `${watchers.length} tail/sleep/shell mồ côi quá ${minK} phút (${wMb} MB) — xem rồi dọn: \`dieu-phoi reap --orphans\` (dry-run) rồi thêm --yes (doctor không tự kill)`
+    : '';
+  if (!found.length) {
+    return wTxt ? [false, 'orphan-processes', `không có claude.exe / codebase-memory-mcp mồ côi quá 6 giờ; ${wTxt}`, 'CẢNH BÁO']
+      : [true, 'orphan-processes', 'không có claude.exe / codebase-memory-mcp mồ côi quá 6 giờ'];
+  }
   const mb = found.reduce((n, p) => n + (p.ws_mb || 0), 0);
   const shown = found.slice(0, 8);
   const items = shown.map((p) => `${p.name} pid ${p.pid} (${p.age_h} giờ${p.ws_mb ? `, ${p.ws_mb} MB` : ''})`).join('; ');
   return [false, 'orphan-processes',
     `${found.length} tiến trình mồ côi (cha đã thoát) quá 6 giờ, ${mb} MB: ${items}${found.length > shown.length ? '; …' : ''}`
-    + ` — kiểm tra rồi dọn bằng \`Stop-Process -Id ${shown.map((p) => p.pid).join(',')}\` (doctor không tự kill)`, 'CẢNH BÁO'];
+    + ` — kiểm tra rồi dọn bằng \`Stop-Process -Id ${shown.map((p) => p.pid).join(',')}\` (doctor không tự kill)${wTxt ? `; ${wTxt}` : ''}`, 'CẢNH BÁO'];
 }
 
 /** `state` line: orphan count from a 10-minute cache (data/orphan-procs.json), else one live scan. null = unknown (skip the line). */
@@ -381,7 +411,7 @@ function cmdStart(opts) {
     core.modeLine(info),
     ...core.orchLessonLines(info),
     ...core.knowledgeLines(info),
-  ];
+  ].filter((l) => l !== '');
   return { code: 0, out: out.join('\n') };
 }
 
@@ -405,23 +435,24 @@ function modeEvent(ctx, root, mode, source, reason, session) {
 }
 
 /**
- * `dieu-phoi mode --root <root_task_id> [fast|normal|strict] [--reason R] [--session S]`: show or change the mode of a
+ * `dieu-phoi mode --root <root_task_id> [fast|normal] [--reason R] [--session S]`: show or change the mode of a
  * request. One event per change; the same mode again writes nothing. Steps not yet dispatched follow the new mode,
  * dispatched steps keep the mode they were given. Never changes a mode by itself.
  */
 function cmdMode(opts) {
-  const usage = 'Cú pháp: dieu-phoi mode --root <root_task_id> [fast|normal|strict] [--reason R] [--session S] [--json]';
+  const usage = 'Cú pháp: dieu-phoi mode --root <root_task_id> [fast|normal] [--reason R] [--session S] [--json]';
   if (typeof opts.root !== 'string') throw new Error(usage);
   const root = requireTaskId(opts.root);
   const ctx = ctxOf(opts);
   const cur = core.rootModeFromEvents(core.readEvents(ctx), root);
   const was = cur ? cur.mode : core.DEFAULT_MODE;
-  const want = opts._[0];
+  const wantRaw = opts._[0];
   const show = (extra) => (opts.json ? JSON.stringify(Object.assign({ root_task_id: root, mode: was, previous: was, changed: false }, extra)) : null);
-  if (want === undefined) {
+  if (wantRaw === undefined) {
     return { code: 0, out: show({}) || `root ${root}: mode=${was}${cur ? ` (từ ${cur.ts}, nguồn ${cur.source || '?'})` : ' (mặc định, chưa đặt)'}` };
   }
-  if (!core.isMode(want)) throw new Error(`mode phải là ${core.MODES.join('|')} (nhận "${want}"). ${usage}`);
+  const want = userMode(wantRaw);
+  if (!want) throw new Error(`mode phải là ${core.MODES.join('|')} (nhận "${wantRaw}"). ${usage}`);
   if (cur && was === want) {
     return { code: 0, out: show({}) || `root ${root}: vẫn ${want} (không đổi, không ghi sự kiện)` };
   }
@@ -937,6 +968,41 @@ 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}` : ''}`;
+}
+
+/**
+ * core 0.7.4 (S1): steps of an approved plan (last 7 days) that run self+batch, whose exec has completed, and that have
+ * neither a batch verifier verdict (reason_code batch-verify) nor a user verdict yet. Gate 3 must not see them unchecked.
+ */
+function batchPendingOf(ctx, events, now) {
+  let files = [];
+  try { files = fs.readdirSync(ctx.paths.plans).filter((f) => f.endsWith('.json')); } catch (_) { return []; }
+  const out = [];
+  for (const f of files) {
+    const rec = core.readJsonFile(path.join(ctx.paths.plans, f), null);
+    if (!rec || !Array.isArray(rec.steps)) continue;
+    const fresh = Date.parse(rec.approved_at) > now - 7 * 24 * 3600 * 1000;
+    if (!fresh) continue;
+    const pending = rec.steps.filter((s) => s && s.verify_plan === 'self+batch' && s.task_id
+      && events.some((e) => e.kind === 'complete' && e.task_id === s.task_id)
+      && !events.some((e) => e.kind === 'verdict' && e.task_id === s.task_id
+        && (String(e.reason_code || '').startsWith('batch-verify') || e.by === 'user')));
+    if (pending.length) out.push({ root_task_id: rec.root_task_id || f.replace(/\.json$/, ''), steps: pending.map((s) => s.id) });
+  }
+  return out;
+}
+
 function cmdState(opts) {
   const ctx = ctxOf(opts);
   const sid = typeof opts.session === 'string' && opts.session ? opts.session
@@ -953,10 +1019,217 @@ function cmdState(opts) {
   }
   const state = core.buildSessionState(core.readEvents(ctx), sid, { plansDir: ctx.paths.plans });
   const orphans = orphanCount(ctx); // s16: null (unknown) leaves the line out
+  const live = core.liveSummary(ctx, sid); // core 0.7.3 (s1)
+  const stuck = core.stuckAgents(ctx, { sessionId: sid }); // s6
+  const batchPending = batchPendingOf(ctx, core.readEvents(ctx), Date.now()); // core 0.7.4 (S1)
   if (opts.json) {
-    return { code: 0, out: JSON.stringify(Object.assign({}, state, hasDeltas ? { unmerged_deltas: deltas } : {}, orphans === null ? {} : { orphan_procs: orphans }), null, 2) };
+    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 }, batchPending.length ? { batch_pending: batchPending } : {}), null, 2) };
   }
-  return { code: 0, out: [core.formatSessionState(state, core.STATE_TEXT_CAP)].concat(deltaLines, orphans === null ? [] : [`orphan_procs: ${orphans}`]).join('\n') };
+  const batchLines = batchPending.map((p) => `CẢNH BÁO: ${p.root_task_id}: ${p.steps.length} bước self+batch (${p.steps.join(', ')}) chưa có verdict verifier gộp (batch-verify) — giao verifier gộp (brief H) trước cổng 3`);
+  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, batchLines).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
@@ -1142,11 +1415,24 @@ function cmdRetro(opts) {
 
 // ------------------------------------------------------------------ choose
 
+/**
+ * A user-supplied mode value: fast | normal; the removed `strict` (0.7.4) is accepted with a warning and becomes
+ * normal; anything else null.
+ */
+function userMode(raw) {
+  if (raw === core.LEGACY_MODE) {
+    process.stderr.write('dieu-phoi: mode strict đã bỏ từ 0.7.4 — dùng normal (sàn an toàn vẫn luôn có verifier độc lập chặn).\n');
+    return core.DEFAULT_MODE;
+  }
+  return core.isMode(raw) ? raw : null;
+}
+
 /** --mode value (validated) or undefined; a bare --mode is an error. */
 function modeOpt(opts) {
   if (opts.mode === undefined) return undefined;
-  if (typeof opts.mode !== 'string' || !core.isMode(opts.mode)) throw new Error(`--mode phải là ${core.MODES.join('|')}`);
-  return opts.mode;
+  const m = typeof opts.mode === 'string' ? userMode(opts.mode) : null;
+  if (!m) throw new Error(`--mode phải là ${core.MODES.join('|')}`);
+  return m;
 }
 
 function chooseInput(opts, ctx, events) {
@@ -1184,15 +1470,39 @@ function overrideEvent(ctx, taskId, taskType, suggested, chosen) {
 }
 
 /**
- * core 0.7.0 (s2): mode_suggest for choose (exec only). The root's CURRENT mode decides (a dispatched step keeps its
- * fast mode, but once the user moved the root back there is nothing to suggest). Never changes the mode.
+ * core 0.7.4 (B1): the step of the approved plan (<plans>/<root>.json) whose task_id is taskId, or null. Its rubric
+ * (score, verifiable, reversible, publish, dependents) is what `choose --task` takes the stricter of.
+ */
+function approvedPlanStep(ctx, taskId) {
+  let files = [];
+  try { files = fs.readdirSync(ctx.paths.plans).filter((f) => f.endsWith('.json')); } catch (_) { return null; }
+  for (const f of files) {
+    const rec = core.readJsonFile(path.join(ctx.paths.plans, f), null);
+    if (!rec || !Array.isArray(rec.steps)) continue;
+    const step = rec.steps.find((s) => s && s.task_id === taskId);
+    if (!step) continue;
+    const dependents = step.dependents === true
+      || rec.steps.some((o) => o && o !== step && Array.isArray(o.depends_on) && o.depends_on.includes(step.id));
+    return Object.assign({}, step, { root: rec.root_task_id || f.replace(/\.json$/, ''), dependents });
+  }
+  return null;
+}
+
+/**
+ * core 0.7.4 (B1): the stricter of the CLI flags and the approved step, field by field — publish, dependents, not
+ * reversible, not verifiable, higher score. Mutates `input`; returns the names it raised (empty = flags already as strict).
+ * Omitting a flag can therefore never loosen a step the plan made blocking.
  */
-function chooseModeSuggest(ctx, input, res, mi) {
-  const root = mi && mi.root ? mi.root : null;
-  const rootEv = root ? core.rootModeFromEvents(input.events, root) : null;
-  const mode = rootEv ? rootEv.mode : res.mode;
-  const sug = core.modeSuggestion(input.events, root, { mode, taskIds: core.rootTaskIds(core.loadPlans(ctx.paths.plans), root) });
-  return { mode_suggest: sug.mode_suggest, mode_suggest_reason: sug.mode_suggest_reason, mode_suggest_root: sug.mode_suggest ? root : null };
+function applyApprovedStep(input, step) {
+  const raised = [];
+  if (step.publish === true && input.publish !== true) { raised.push('publish'); input.publish = true; }
+  if (step.dependents === true && input.dependents !== true) { raised.push('dependents'); input.dependents = true; }
+  if (step.reversible === false && input.reversible !== false) { raised.push('reversible'); input.reversible = false; }
+  if (step.verifiable === false && input.verifiable !== false) { raised.push('verifiable'); input.verifiable = false; }
+  const planScore = Number(step.score);
+  const flagScore = Number(input.score);
+  if (Number.isFinite(planScore) && Number.isFinite(flagScore) && planScore > flagScore) { raised.push('score'); input.score = planScore; }
+  return raised;
 }
 
 function cmdChoose(opts) {
@@ -1202,6 +1512,8 @@ function cmdChoose(opts) {
   }
   if (opts.task !== undefined) requireTaskId(typeof opts.task === 'string' ? opts.task : '');
   const input = chooseInput(opts, ctx, core.readEvents(ctx));
+  const planStep = input.taskId ? approvedPlanStep(ctx, input.taskId) : null;
+  const raised = planStep ? applyApprovedStep(input, planStep) : [];
   let modeSource = 'flag';
   const mi = input.taskId ? core.taskModeInfo(ctx, input.taskId, input.events) : null;
   if (input.mode === undefined) {
@@ -1215,7 +1527,12 @@ function cmdChoose(opts) {
   }
   const res = chooser.choose(input);
   res.mode_source = modeSource;
-  if (res.verify_plan) Object.assign(res, chooseModeSuggest(ctx, input, res, mi));
+  if (planStep) {
+    res.plan_step = { root_task_id: planStep.root, step: planStep.id, verify_plan: planStep.verify_plan || null, raised };
+    if (planStep.verify_plan && res.verify_plan && planStep.verify_plan !== res.verify_plan) {
+      res.plan_deviation = `${planStep.verify_plan} → ${res.verify_plan}`;
+    }
+  }
   const orch = measureOrch(opts, ctx, input.profile);
   res.orch_ctx_tokens = orch.ctx_tokens;
   res.orch_ctx_growth = orch.ctx_growth;
@@ -1237,8 +1554,10 @@ function cmdChoose(opts) {
   }
   if (opts.json) return { code: 0, out: JSON.stringify(res) };
   const typeWarn = res.type_warning && !String(res.reason).includes(res.type_warning) ? `\nCẢNH BÁO: ${res.type_warning}` : '';
-  const sugLine = res.mode_suggest ? `\n${core.modeSuggestLine(res.mode_suggest_root, 'fast', res.mode_suggest_reason)}` : '';
-  const warn = `${typeWarn}${res.orch_ctx_warn ? `\nCẢNH BÁO: ${orch.advice}` : ''}${sugLine}`;
+  const planWarn = res.plan_step && res.plan_step.raised.length
+    ? `\nKế hoạch đã duyệt (${res.plan_step.root_task_id} bước ${res.plan_step.step}): nâng theo ${res.plan_step.raised.join(', ')}` : '';
+  const deviationWarn = res.plan_deviation ? `\nLỆCH kiểm khỏi kế hoạch đã duyệt: ${res.plan_deviation}` : '';
+  const warn = `${typeWarn}${planWarn}${deviationWarn}${res.orch_ctx_warn ? `\nCẢNH BÁO: ${orch.advice}` : ''}`;
   const est =`~${fmtUsd(res.est_cost_usd)} · ~${fmtNum(res.est_time_min)} phút (${res.est_source === 'data' ? 'dữ liệu' : 'ước lượng thô'})`;
   if (res.action === 'ask_user') {
     return { code: 0, out: `HỎI NGƯỜI DÙNG — ${res.reason}${warn}` };
@@ -1293,7 +1612,7 @@ function buildPlanTable(rawSteps, base) {
       verifiable: s.verifiable === undefined ? true : yesNo(s.verifiable, true),
       reversible: s.reversible === undefined ? true : yesNo(s.reversible, true),
       publish: s.publish === undefined ? false : yesNo(s.publish, false),
-      mode: s.mode === undefined || s.mode === null ? null : s.mode,
+      mode: s.mode === undefined || s.mode === null ? null : (userMode(s.mode) || s.mode),
       urgency: s.urgency,
       deps: deps.map(String),
     };
@@ -1322,6 +1641,8 @@ function buildPlanTable(rawSteps, base) {
     const head = {
       step: s.step, title: s.title, type: s.type, task_id: s.task || null, score: Number(s.score),
       verifiable: s.verifiable, reversible: s.reversible, depends_on: s.deps,
+      publish: s.publish === true || base.publish === true,
+      dependents: steps.some((o) => o !== s && o.deps.includes(s.step)),
       mode: s.mode || base.mode || core.DEFAULT_MODE, mode_override: s.mode || null,
     };
     try {
@@ -1387,6 +1708,78 @@ function planTaskIdProblems(plan, root) {
   return problems;
 }
 
+// core 0.7.4 (s1): TÁCH? — a step that is likely to hand off (score ≥ 6; its task_type × tier has handoff rate ≥ 20%
+// over ≥ 10 tasks) is flagged in the table so the planner splits it. Advice only: never blocks --approve.
+const SPLIT_MIN_SCORE = 6;
+const SPLIT_MIN_RATE = 0.2;
+const SPLIT_MIN_N = 10;
+
+/** Model family of a tier or a recorded model id (opus | sonnet | haiku | fable), as choose.cjs matches cells. */
+function modelFamily(m) {
+  const s = String(m || '').toLowerCase();
+  return ['opus', 'sonnet', 'haiku', 'fable'].find((k) => s.includes(k)) || null;
+}
+
+function planSplitWarnings(steps, events) {
+  const samples = agg.handoffSamples(events);
+  const out = [];
+  for (const r of steps) {
+    if (r.action === 'refused' || !r.tier || !(Number(r.score) >= SPLIT_MIN_SCORE)) continue;
+    const type = r.task_type || r.type;
+    const [model, effort] = String(r.tier).split('/');
+    const same = samples.filter((s) => s.task_type === type && modelFamily(s.model) === modelFamily(model) && s.effort === effort);
+    if (same.length < SPLIT_MIN_N) continue;
+    const hand = same.filter((s) => s.handoff);
+    const rate = hand.length / same.length;
+    if (rate < SPLIT_MIN_RATE) continue;
+    const clean = same.filter((s) => !s.handoff);
+    out.push({
+      step: r.step,
+      task_type: type,
+      tier: r.tier,
+      n: same.length,
+      handoff_rate: Math.round(rate * 1000) / 1000,
+      cost_handoff_p50_usd: agg.percentile(hand.map((s) => s.total_cost), 0.5),
+      cost_clean_p50_usd: agg.percentile(clean.map((s) => s.total_cost), 0.5),
+    });
+  }
+  return out;
+}
+
+// core 0.7.4 (s2): TIER↑ — a mechanical type whose override sits above the tier choose would pick is flagged
+// (advice only; --approve is not blocked). The $p50 column and the warning read the same stats cells as `stats`.
+const TIER_UP_TYPES = ['mechanical-edit', 'extract', 'search', 'test-write'];
+
+/** The stats cell (buildCells row) of one task_type × tier, or null. */
+function statCellOf(cells, type, tier) {
+  const [model, effort] = String(tier).split('/');
+  return cells.find((c) => c.task_type === type && modelFamily(c.model) === modelFamily(model) && c.effort === effort) || null;
+}
+
+function planTierWarnings(steps, cells) {
+  const out = [];
+  for (const r of steps) {
+    if (r.action === 'refused' || !r.overridden || !r.suggested_tier || !r.tier) continue;
+    if (!TIER_UP_TYPES.includes(r.task_type)) continue;
+    const hi = chooser.parseTier(r.tier);
+    const lo = chooser.parseTier(r.suggested_tier);
+    if (hi === null || lo === null || hi <= lo) continue;
+    const a = statCellOf(cells, r.task_type, r.tier);
+    const b = statCellOf(cells, r.task_type, r.suggested_tier);
+    out.push({
+      step: r.step,
+      task_type: r.task_type,
+      tier: r.tier,
+      suggested_tier: r.suggested_tier,
+      cost_p50_usd: a && a.n ? a.cost_p50_usd : null,
+      suggested_cost_p50_usd: b && b.n ? b.cost_p50_usd : null,
+      accept_rate: a && a.n ? a.accept_rate : null,
+      suggested_accept_rate: b && b.n ? b.accept_rate : null,
+    });
+  }
+  return out;
+}
+
 /** Mapped ad-hoc labels (bug-fix → debug, …): not an error, but the tag must carry the mapped type. */
 function planTypeNotes(plan) {
   return plan.steps.filter((r) => r.mapped_from).map((r) => `bước ${r.step}: ${r.type_warning}`);
@@ -1444,6 +1837,10 @@ function recordApprovedPlan(ctx, root, stepsFile, plan) {
     steps: plan.steps.map((r) => Object.assign({
       id: r.step, task_id: r.task_id || null, title: r.title === undefined ? null : r.title, type: r.task_type || r.type || null,
       tier: r.action === 'refused' ? null : (r.tier || null), depends_on: r.depends_on,
+      // core 0.7.4 (B1): the rubric `choose --task` takes the stricter of its flags against
+      score: Number.isFinite(Number(r.score)) ? Number(r.score) : null, verifiable: r.verifiable !== false,
+      reversible: r.reversible !== false, publish: r.publish === true, dependents: r.dependents === true,
+      verify_plan: r.verify_plan || null,
     }, r.mode_override ? { mode: r.mode_override } : {})),
     history,
   };
@@ -1485,8 +1882,8 @@ function cmdPlanTable(opts) {
   let fileMode;
   if (raw && !Array.isArray(raw) && typeof raw === 'object' && Array.isArray(raw.steps)) {
     if (raw.mode !== undefined && raw.mode !== null) {
-      if (!core.isMode(raw.mode)) throw new Error(`plan-table: "mode" trong file phải là ${core.MODES.join('|')} (nhận "${raw.mode}")`);
-      fileMode = raw.mode;
+      fileMode = userMode(raw.mode);
+      if (!fileMode) throw new Error(`plan-table: "mode" trong file phải là ${core.MODES.join('|')} (nhận "${raw.mode}")`);
     }
     raw = raw.steps;
   }
@@ -1503,6 +1900,9 @@ function cmdPlanTable(opts) {
   if (problems.length) process.stderr.write(`dieu-phoi plan-table: cảnh báo — ${problems.join('; ')} (cần sửa trước khi --approve)\n`);
   const typeNotes = planTypeNotes(plan);
   if (typeNotes.length) process.stderr.write(`dieu-phoi plan-table: cảnh báo — ${typeNotes.join('; ')}\n`);
+  const splitWarn = planSplitWarnings(plan.steps, base.events);
+  const statCells = agg.analyze(base.events, {}).cells;
+  const tierWarn = planTierWarnings(plan.steps, statCells);
   const rec = opts.approve ? recordApprovedPlan(ctx, String(opts.root), path.resolve(opts.file), plan) : null;
   let modeLogged = false;
   if (rec && (rootEv ? rootEv.mode !== plan.mode : plan.mode !== core.DEFAULT_MODE)) {
@@ -1513,29 +1913,31 @@ function cmdPlanTable(opts) {
   for (const ev of ovs) core.appendEvent(ctx, ev);
   if (rec) recordPlanSuggestions(ctx, plan);
   if (opts.json) {
-    const out = rec ? Object.assign({}, plan, {
+    const steps = plan.steps.map((r) => {
+      const c = r.action === 'refused' || !r.tier ? null : statCellOf(statCells, r.task_type || r.type, r.tier);
+      return Object.assign({}, r, { stats_cost_p50_usd: c && c.n ? c.cost_p50_usd : null, stats_n: c ? c.n : 0 });
+    });
+    const out = Object.assign({}, plan, { steps, split_warn: splitWarn, tier_warn: tierWarn }, rec ? {
       approved: { root_task_id: rec.root_task_id, approval: rec.approval, record: rec.file, overrides_logged: ovs.length, mode_logged: modeLogged },
-    }) : plan;
+    } : {});
     return { code: 0, out: JSON.stringify(out, null, 2) };
   }
-  const lines = ['| Bước | Model/effort | Rubric (điểm · kiểm chứng · đảo ngược) | Lý do | Ước tính | Kiểm |', '|---|---|---|---|---|---|'];
+  const lines = ['| Bước | Model/effort | Rubric (điểm · kiểm chứng · đảo ngược) | Lý do | Ước tính | $p50 | Kiểm |', '|---|---|---|---|---|---|---|'];
   for (const r of plan.steps) {
     const tierCell = r.action === 'refused' ? '—' : (r.action === 'ask_user' ? `${r.tier} (hỏi người dùng)` : r.tier);
     const yn = (v) => (v ? 'y' : 'n');
     const rubric = `${Number.isFinite(r.score) ? r.score : '?'} · ${yn(r.verifiable)} · ${yn(r.reversible)}`;
     const why = `${r.type}${r.depends_on.length ? `, sau ${r.depends_on.join(', ')}` : ''} — ${r.reason.replace(/; profile: .*$/, '')}`;
     const est = r.action === 'refused' ? '-' : `~${fmtUsd(r.est_cost_usd)} · ~${fmtNum(r.est_time_min)} phút${r.est_source === 'rough' ? ' (thô)' : ''}`;
+    const sc = r.action === 'refused' || !r.tier ? null : statCellOf(statCells, r.task_type || r.type, r.tier);
+    const p50 = r.action === 'refused' ? '—' : (sc && sc.n ? `${fmtUsd(sc.cost_p50_usd)} (n ${sc.n})` : '-');
     const kiem = r.action === 'refused' || !r.verify_plan ? '—' : `${r.verify_plan}${r.mode_override ? ` (mode ${r.mode_override})` : ''}`;
-    lines.push(`| ${mdCell(r.title ? `${r.step}. ${r.title}` : r.step)} | ${mdCell(tierCell)} | ${mdCell(rubric)} | ${mdCell(why)} | ${mdCell(est)} | ${mdCell(kiem)} |`);
+    lines.push(`| ${mdCell(r.title ? `${r.step}. ${r.title}` : r.step)} | ${mdCell(tierCell)} | ${mdCell(rubric)} | ${mdCell(why)} | ${mdCell(est)} | ${mdCell(p50)} | ${mdCell(kiem)} |`);
   }
   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)`);
-  // 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` : ''}`);
+  const modeText = modeChosen ? plan.mode : 'normal (mặc định)';
+  lines.push(`**Mode:** ${modeText}${plan.self_batch_steps ? ` · Kiểm (self+batch): bỏ ${plan.self_batch_steps} verifier riêng, 1 verify gộp (test chọn lọc các file cả nhóm; full suite ở cổng phát hành) 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.`);
@@ -1543,11 +1945,18 @@ function cmdPlanTable(opts) {
 `);
   }
   if (typeNotes.length) lines.push('', `**Loại task:** ${typeNotes.join('; ')}`);
+  for (const w of splitWarn) {
+    lines.push('', `TÁCH?: ${w.step} — ${w.task_type} ${w.tier} handoff ${Math.round(w.handoff_rate * 100)}% (${w.n}), median ${fmtUsd(w.cost_handoff_p50_usd)} có handoff / ${fmtUsd(w.cost_clean_p50_usd)} không → cân nhắc tách thành ≥2 bước nhỏ hơn`);
+  }
+  const fmtPct = (v) => (v === null || v === undefined ? '-' : `${Math.round(v * 100)}%`);
+  for (const w of tierWarn) {
+    lines.push('', `TIER↑: ${w.step} ${w.tier} vs đề xuất ${w.suggested_tier} ($p50 ${fmtUsd(w.cost_p50_usd)} vs ${fmtUsd(w.suggested_cost_p50_usd)}, accept ${fmtPct(w.accept_rate)} vs ${fmtPct(w.suggested_accept_rate)}) — tier cao hơn choose đề xuất, kiểm lý do trước khi duyệt`);
+  }
   if (rec) lines.push('', `Đã ghi kế hoạch đã duyệt (root ${rec.root_task_id}, lần duyệt ${rec.approval})${ovs.length ? `; ghi ${ovs.length} override` : ''}${modeLogged ? `; ghi mode ${plan.mode}` : ''}`);
   return { code: 0, out: lines.join('\n') };
 }
 
 module.exports = {
-  ORCH_NEW_SESSION_TOKENS, ORCH_NEW_SESSION_COMPACTIONS, skillDirOf, cmdSetup, cmdUninstall, cmdDoctor, cmdStart, checkSinkLive, cmdHook, cmdSync, cmdVerdict, cmdSteer, cmdDiscard, ctxWarnOnce, ctxWarnLevel, sweepStaleTmp, planOverrideEvents, recordPlanSuggestions, cmdStats, cmdRetro, cmdPrune: (o) => require('./prune.cjs').cmdPrune(o), cmdChoose, cmdMode, modeEvent, cmdCtx, cmdState, orphanCheck, orphanCount, measureOrch,
+  ORCH_NEW_SESSION_TOKENS, ORCH_NEW_SESSION_COMPACTIONS, skillDirOf, cmdSetup, cmdUninstall, cmdDoctor, cmdStart, checkSinkLive, cmdHook, cmdSync, cmdVerdict, cmdSteer, cmdDiscard, ctxWarnOnce, ctxWarnLevel, sweepStaleTmp, planOverrideEvents, recordPlanSuggestions, cmdStats, cmdRetro, cmdPrune: (o) => require('./prune.cjs').cmdPrune(o), cmdChoose, cmdMode, modeEvent, cmdCtx, cmdState, cmdReap, reapProcsOf, orphanKillMin, orphanCheck, orphanCount, liveCheck, liveLine, freeSlots, measureOrch,
   cmdPlanTable, cmdNewId, requireTaskId, buildPlanTable, recordApprovedPlan, planTaskIdProblems, criticalPath, resolveAgentId, AGENT_OUTCOMES, USER_OUTCOMES, VERIFY,
 };