@kienntpixon/dieu-phoi 0.7.0 → 0.7.2

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 trong ${res.settings}${res.backup ? ` (sao lưu: ${path.basename(res.backup)})` : ''}`
+      ? `Đã đăng ký PostToolUse(Agent) + SubagentStop + 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') };
@@ -128,6 +141,9 @@ async function cmdDoctor(opts) {
   add(reg.UserPromptSubmit, 'prompt-hook', reg.UserPromptSubmit
     ? 'UserPromptSubmit có — prompt "điều phối" được tạo sẵn task_id + run dir, lượt đầu là scout'
     : 'thiếu hook UserPromptSubmit — mỗi lần điều phối phải chạy `dieu-phoi start` trước scout; chạy lại `dieu-phoi setup`', 'CẢNH BÁO');
+  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');
   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}`
@@ -198,6 +214,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')) {
@@ -219,6 +236,48 @@ 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 `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);
+  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ờ'];
+  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'];
+}
+
+/** `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;
 
@@ -579,28 +638,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) {
@@ -610,27 +720,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') {
@@ -638,7 +754,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})` : ''}.` };
 }
@@ -662,8 +778,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
@@ -726,19 +848,30 @@ function measureOrch(opts, ctx, prof) {
       u = core.orchestratorUsage(file, core.loadPricing(ctx), { cacheFile: core.orchCacheFile(ctx.paths, sid, file) });
     }
   } catch (_) { /* measurement never fails the caller */ }
-  const over = typeof u.ctx_growth === 'number' && u.ctx_growth > softCap;
+  // core 0.7.1 (retro 2026-10-26, C1): past ORCH_NEW_SESSION_TOKENS or ORCH_NEW_SESSION_COMPACTIONS a /compact no longer
+  // helps (session 36cee993: 946k, 20 compactions, 0 user verdicts) -> advise a new session instead.
+  const newSession = (typeof u.ctx_tokens === 'number' && u.ctx_tokens > ORCH_NEW_SESSION_TOKENS)
+    || (typeof u.compactions === 'number' && u.compactions >= ORCH_NEW_SESSION_COMPACTIONS);
+  const over = (typeof u.ctx_growth === 'number' && u.ctx_growth > softCap) || newSession;
   let advice;
   if (!sid) advice = 'Không đo được: không có session (thiếu CLAUDE_CODE_SESSION_ID, dùng --session <id>).';
   else if (u.ctx_tokens === null) advice = 'Không đo được: không thấy transcript của session này.';
-  else if (over) advice = `Context điều phối đã tăng ${u.ctx_growth} token (nền ${u.ctx_baseline}, nay ${u.ctx_tokens}) vượt trần mềm ${softCap}: gõ /compact để nén phiên — trạng thái điều phối sẽ được nạp lại tự động.`;
+  else if (newSession) {
+    advice = `Phiên điều phối đã quá lớn (context ${u.ctx_tokens} token, nén ${u.compactions === null ? '?' : u.compactions} lần; ngưỡng ${ORCH_NEW_SESSION_TOKENS} token hoặc ${ORCH_NEW_SESSION_COMPACTIONS} lần nén): đừng /compact thêm — ghi trạng thái (\`dieu-phoi state --session ${sid}\` + file trạng thái trong run dir), trình cổng 3 phần đã xong, rồi MỞ PHIÊN MỚI và nạp lại từ \`state\`.`;
+  } else if (over) advice = `Context điều phối đã tăng ${u.ctx_growth} token (nền ${u.ctx_baseline}, nay ${u.ctx_tokens}) vượt trần mềm ${softCap}: gõ /compact để nén phiên — trạng thái điều phối sẽ được nạp lại tự động.`;
   else advice = `Context điều phối tăng ${u.ctx_growth}/${softCap} token so với nền ${u.ctx_baseline}, còn trong trần mềm.`;
   return {
     session_id: sid, ctx_tokens: u.ctx_tokens, ctx_baseline: u.ctx_baseline, ctx_growth: u.ctx_growth,
-    cum_usd: u.cum_usd, compactions: u.compactions, soft_cap: softCap, over, advice,
+    cum_usd: u.cum_usd, compactions: u.compactions, soft_cap: softCap, over, new_session: newSession, advice,
   };
 }
 
 const CTX_WARN_KEEP_MS = 14 * 24 * 3600 * 1000;
+// 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×, … */
 function ctxWarnLevel(growth, cap) {
@@ -808,13 +941,22 @@ 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.scanUnmergedDeltasFor(ctx);
+  const deltaLines = core.unmergedDeltaLines(deltas);
+  const hasDeltas = core.hasUnmergedDeltas(deltas);
   if (!sid) {
-    if (opts.json) return { code: 0, out: JSON.stringify({ session_id: null, generated_at: core.nowIso(), runs_dir: null, plans: [], tasks: [] }) };
-    return { code: 0, out: 'Không có session (thiếu CLAUDE_CODE_SESSION_ID, dùng --session <id>).' };
+    if (opts.json) {
+      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(state, null, 2) };
-  return { code: 0, out: core.formatSessionState(state, core.STATE_TEXT_CAP) };
+  const orphans = orphanCount(ctx); // s16: null (unknown) leaves the line out
+  if (opts.json) {
+    return { code: 0, out: JSON.stringify(Object.assign({}, state, hasDeltas ? { unmerged_deltas: deltas } : {}, orphans === null ? {} : { orphan_procs: orphans }), null, 2) };
+  }
+  return { code: 0, out: [core.formatSessionState(state, core.STATE_TEXT_CAP)].concat(deltaLines, orphans === null ? [] : [`orphan_procs: ${orphans}`]).join('\n') };
 }
 
 // ------------------------------------------------------------------ stats / retro
@@ -832,13 +974,13 @@ function cmdStats(opts) {
   const ctx = ctxOf(opts);
   const { lambda } = lambdaOf(opts, ctx);
   const events = core.readEvents(ctx);
-  const { cells, steers, orchestration, tasks } = agg.analyze(events, { lambda });
+  const { cells, steers, orchestration, tasks, batch_verify: batchVerify } = agg.analyze(events, { lambda });
   const modes = agg.modeSummary(events, tasks);
   const type = typeof opts.type === 'string' ? opts.type : null;
   const rows = type ? cells.filter((c) => c.task_type === type) : cells;
   const steerRows = type ? steers.filter((s) => s.task_type === type) : steers;
   if (opts.json) {
-    return { code: 0, out: JSON.stringify({ lambda_usd_per_min: lambda, min_n: agg.MIN_N, cells: rows, steers: steerRows, orchestration, modes }, null, 2) };
+    return { code: 0, out: JSON.stringify({ lambda_usd_per_min: lambda, min_n: agg.MIN_N, cells: rows, steers: steerRows, orchestration, modes, batch_verify: batchVerify }, null, 2) };
   }
   if (!rows.length) {
     return { code: 0, out: orchestration.sessions ? `Chưa có dữ liệu theo ô.\n${orchLine(orchestration)}` : 'Chưa có dữ liệu.' };
@@ -865,7 +1007,7 @@ function cmdStats(opts) {
   }
   return {
     code: 0,
-    out: `${table(t)}\n\n${table(s)}\n\n${modeTable(modes)}${orchLine(orchestration)}\n\n`
+    out: `${table(t)}\n\n${table(s)}\n\n${modeTable(modes)}${batchVerifyTable(batchVerify)}${orchLine(orchestration)}\n\n`
       + 'n = task tính tỉ lệ (/số đã giao, (-k) = bị loại: reject-scope hoặc lượt exec đầu bị steer plan/redirect). '
       + 'accept% = thành công theo verdict người dùng đầu tiên, chưa có thì verdict agent; agent_pass% = chỉ tầng agent. '
       + `E[cost], E[time] tính trọn mọi lượt + review của task. score = E[cost] + λ·p50[time] (trung vị, không dùng TB: thời gian chờ thổi phồng TB), λ=${lambda} USD/phút.`,
@@ -890,6 +1032,20 @@ function modeTable(modes) {
   return `${table(t)}\n\n`;
 }
 
+/** core 0.7.1 (C5): the batched verifiers' own cell (model/effort), kept out of the task cells; '' when none. */
+function batchVerifyTable(rows) {
+  if (!rows || !rows.length) return '';
+  const t = [['verifier gộp', 'lần', 'task', 'Σ cost', 'E[cost]', 'p50 cost', 'p50 time']];
+  for (const r of rows) {
+    t.push([
+      `${chooser.shortModel(r.model) || r.model || '?'}/${r.effort || '?'}`, r.n, r.tasks,
+      fmtUsd(r.cost_total_usd), fmtUsd(r.cost_mean_usd), fmtUsd(r.cost_p50_usd),
+      r.time_p50_min === null ? '-' : `${fmtNum(r.time_p50_min)}m`,
+    ]);
+  }
+  return `${table(t)}\n(chi phí verifier gộp là ô riêng, không cộng vào ô task_type × tier của bước fast mang task_id của nó)\n\n`;
+}
+
 /** One retro line: per mode with tasks. */
 function modeRetroLine(modes) {
   const parts = agg.MODE_KEYS.filter((m) => modes[m].tasks).map((m) => {
@@ -906,7 +1062,7 @@ function cmdRetro(opts) {
   const ctx = ctxOf(opts);
   const { prof, lambda } = lambdaOf(opts, ctx);
   const events = core.readEvents(ctx);
-  const { agents, tasks, cells, steers, userVerdicts, overrides, orchestration } = agg.analyze(events, { lambda });
+  const { agents, tasks, cells, steers, userVerdicts, overrides, orchestration, batch_verify: batchVerify } = agg.analyze(events, { lambda });
   const modes = agg.modeSummary(events, tasks);
   const reasons = {};
   const outcomes = {};
@@ -964,6 +1120,7 @@ function cmdRetro(opts) {
     overrides: overrides.map((o) => ({ ts: o.ts, task_type: o.task_type, suggested_tier: o.suggested_tier, chosen_tier: o.chosen_tier })),
     orchestration,
     modes,
+    batch_verify: batchVerify,
     cells,
   };
   if (opts.json) return { code: 0, out: JSON.stringify(summary, null, 2) };
@@ -977,6 +1134,7 @@ function cmdRetro(opts) {
     `Steer nhiều (brainstorm hỏi quá ít): ${highSteer.map((s) => `${s.task_type} ${pct(s.steer_rate)}`).join(', ') || '-'}`,
     orchLine(orchestration),
     modeRetroLine(modes),
+    ...(batchVerify.length ? [`Verifier gộp (ô riêng): ${batchVerify.map((r) => `${chooser.shortModel(r.model) || r.model || '?'}/${r.effort || '?'} ×${r.n}, Σ ${fmtUsd(r.cost_total_usd)}, p50 ${r.time_p50_min === null ? '-' : `${fmtNum(r.time_p50_min)}m`}`).join(' · ')}`] : []),
     'Chi tiết theo ô: `dieu-phoi stats`; đưa cho LLM: `dieu-phoi retro --json`.',
   ];
   return { code: 0, out: lines.join('\n') };
@@ -1062,6 +1220,7 @@ function cmdChoose(opts) {
   res.orch_ctx_tokens = orch.ctx_tokens;
   res.orch_ctx_growth = orch.ctx_growth;
   res.orch_ctx_over = orch.over;
+  res.orch_new_session = orch.new_session === true;
   res.orch_ctx_warn = ctxWarnOnce(ctx, orch); // over AND a new threshold crossed since the last warning
   if (res.overridden) {
     const tid = input.taskId;
@@ -1072,6 +1231,8 @@ function cmdChoose(opts) {
     core.recordSuggestion(ctx, {
       task_id: input.taskId, role: res.role || input.role, suggested_tier: res.suggested_tier || res.tier, choose_tier: res.tier,
       source: 'choose', keep_suggested: input.approved !== null && !res.overridden,
+      choose_task_type: res.task_type, choose_score: res.score, explored: res.explored, reason_code: res.reason_code,
+      thompson_score: res.thompson_score === null ? undefined : res.thompson_score,
     });
   }
   if (opts.json) return { code: 0, out: JSON.stringify(res) };
@@ -1238,7 +1399,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;
@@ -1257,6 +1419,8 @@ function recordPlanSuggestions(ctx, plan) {
     if (!r.task_id || !r.tier || r.action !== 'dispatch') continue;
     const ok = core.recordSuggestion(ctx, {
       task_id: r.task_id, role: r.role || 'exec', suggested_tier: r.suggested_tier || r.tier, choose_tier: r.tier, source: 'plan',
+      choose_task_type: r.task_type, choose_score: r.score, explored: r.explored, reason_code: r.reason_code,
+      thompson_score: r.thompson_score === null ? undefined : r.thompson_score,
     });
     if (ok) n++;
   }
@@ -1329,6 +1493,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);
@@ -1365,7 +1530,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.`);
@@ -1378,6 +1548,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, orphanCheck, orphanCount, measureOrch,
   cmdPlanTable, cmdNewId, requireTaskId, buildPlanTable, recordApprovedPlan, planTaskIdProblems, criticalPath, resolveAgentId, AGENT_OUTCOMES, USER_OUTCOMES, VERIFY,
 };