@kienntpixon/dieu-phoi 0.7.1 → 0.7.2

package/lib/aggregate.cjs

@@ -125,6 +125,7 @@ function buildAgents(events) {
   const userVerdicts = [];
   const autoVerdicts = [];
   const overrides = [];
+  const implicitOverrides = []; // core 0.7.2 (K4): deviations the hook logged; not the user's overrides
   const steers = [];
   const get = (id) => {
     if (!map.has(id)) map.set(id, { agent_id: id, dispatch: null, completes: [], verdicts: [], steers: [] });
@@ -135,7 +136,7 @@ function buildAgents(events) {
     if (!ev || typeof ev !== 'object') return;
     if (isInternalComplete(ev, dispatched)) return;
     const e = Object.assign({ _idx: idx }, ev);
-    if (ev.kind === 'override') { overrides.push(e); return; }
+    if (ev.kind === 'override') { (ev.source === 'implicit' ? implicitOverrides : overrides).push(e); return; }
     if (ev.kind === 'verdict') {
       const v = Object.assign(e, normalizeVerdict(ev));
       if (v.by === 'user') { userVerdicts.push(v); return; }
@@ -202,7 +203,7 @@ function buildAgents(events) {
       last_complete_ts: a.completes.length ? Math.max(...a.completes.map(tsOf)) : 0,
     });
   }
-  return { agents, userVerdicts, autoVerdicts, overrides, steers };
+  return { agents, userVerdicts, autoVerdicts, overrides, implicitOverrides, steers };
 }
 
 /** Group agents into tasks (sample unit = task_id; agents without task_id are their own task). */
@@ -563,11 +564,11 @@ function orchestrationSummary(events) {
 }
 
 function analyze(events, opts) {
-  const { agents, userVerdicts, autoVerdicts, overrides, steers } = buildAgents(withoutDiscarded(events));
+  const { agents, userVerdicts, autoVerdicts, overrides, implicitOverrides, steers } = buildAgents(withoutDiscarded(events));
   const tasks = buildTasks(agents, userVerdicts, autoVerdicts);
   const cells = buildCells(tasks, opts);
   return {
-    agents, tasks, cells, overrides, userVerdicts, autoVerdicts, steerEvents: steers, steers: buildSteers(tasks, steers, agents),
+    agents, tasks, cells, overrides, implicitOverrides, userVerdicts, autoVerdicts, steerEvents: steers, steers: buildSteers(tasks, steers, agents),
     orchestration: orchestrationSummary(events),
     batch_verify: batchVerifyCells(agents),
   };

package/lib/args.cjs

@@ -4,7 +4,7 @@ const fs = require('fs');
 const path = require('path');
 const core = require('../hook.cjs');
 
-const BOOLEAN_FLAGS = new Set(['json', 'help', 'h', 'purge', 'version', 'v', 'dry-run', 'no-sync', 'approve', 'yes', 'force', 'follow', 'remove', 'dirty', 'no-cache', 'untagged', 'no-knowledge', 'net', 'with-codebase-memory', 'cbm', 'allow-custom-source', 'auto']);
+const BOOLEAN_FLAGS = new Set(['json', 'help', 'h', 'purge', 'version', 'v', 'dry-run', 'no-sync', 'approve', 'yes', 'force', 'follow', 'remove', 'dirty', 'no-cache', 'untagged', 'no-knowledge', 'net', 'with-codebase-memory', 'cbm', 'allow-custom-source', 'auto', 'include-local']);
 
 /** Minimal argv parser: positionals, --k v, --k=v, boolean flags. */
 function parseArgs(argv) {

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 = '***';
@@ -72,6 +84,7 @@ function cmdSetup(opts) {
     `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') };
@@ -201,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')) {
@@ -222,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;
 
@@ -582,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) {
@@ -613,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') {
@@ -641,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})` : ''}.` };
 }
@@ -665,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
@@ -748,7 +867,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×, … */
@@ -820,17 +942,21 @@ function cmdState(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
+  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
@@ -1273,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;
@@ -1366,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);
@@ -1402,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.`);
@@ -1415,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,
 };

package/lib/knowledge.cjs

@@ -574,10 +574,9 @@ function runDirOf(v) {
   return isDir(p) ? { dir: p } : { error: `Không thấy run ${s} (${slash(p)}).` };
 }
 
-/** Task id a delta file belongs to: knowledge-delta-<task_id>[-r<n>].md (8 chars a-z0-9); null = untagged. */
+/** Task id a delta file belongs to: knowledge-delta-<task_id>[-r<n>|-h<n>].md (8 chars a-z0-9; -h<n> = handoff); null = untagged. */
 function deltaTaskOf(file) {
-  const m = /^knowledge-delta-([a-z0-9]{8})(?:-r\d+)?\.md$/i.exec(path.basename(file));
-  return m ? m[1].toLowerCase() : null;
+  return core.deltaTagOf(file);
 }
 
 /**
@@ -585,7 +584,7 @@ function deltaTaskOf(file) {
  * tagged with one of them (plus untagged ones when untagged is true).
  */
 function deltaFiles(runDir, filter) {
-  const num = (f) => { const m = /-r(\d+)\.md$/i.exec(f); return m ? Number(m[1]) : 0; };
+  const num = (f) => { const m = /-[rh](\d+)\.md$/i.exec(f); return m ? Number(m[1]) : 0; };
   return fs.readdirSync(runDir)
     .filter((f) => /^knowledge-delta.*\.md$/i.test(f))
     .filter((f) => {

package/lib/procs.cjs

@@ -0,0 +1,223 @@
+'use strict';
+// s16 (core 0.7.2): read-only look at the process table. Everything here that decides something is a pure function over a
+// plain list [{pid, ppid, name, created (epoch ms | null), ws (bytes | null), cmd}], so tests feed fixture lists and never
+// touch the system. Only listProcesses() and killTree() reach the OS; listProcesses never throws (null on any failure),
+// killTree is called by the hook only when config kill_leftovers is true.
+
+const cp = require('child_process');
+
+const DEFAULT_TIMEOUT_MS = 4000;
+const ORPHAN_NAMES = ['claude.exe', 'codebase-memory-mcp.exe', 'node.exe', 'bash.exe'];
+// never reported as a leftover of one agent: the Claude Code processes themselves and the code-graph server (shared)
+const LEFTOVER_SKIP_NAMES = ['claude.exe', 'claude', 'codebase-memory-mcp.exe', 'codebase-memory-mcp', 'conhost.exe'];
+
+const PS_WIN = [
+  'Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,Name,',
+  "@{n='Created';e={if($_.CreationDate){[int64]($_.CreationDate.ToUniversalTime()-[datetime]'1970-01-01').TotalMilliseconds}else{$null}}},",
+  'WorkingSetSize,',
+  "@{n='Cmd';e={if($_.CommandLine){$_.CommandLine.Substring(0,[Math]::Min(200,$_.CommandLine.Length))}else{$null}}}",
+  ' | ConvertTo-Json -Compress',
+].join('');
+
+const lower = (s) => String(s || '').toLowerCase();
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : (typeof v === 'string' && /^\d+$/.test(v) ? Number(v) : null));
+
+/** Windows JSON from PS_WIN (also a single object when only one process) -> list, or null when it is not that shape. */
+function parseWindowsJson(text) {
+  let j;
+  try { j = JSON.parse(String(text).replace(/^/, '')); } catch (_) { return null; }
+  const arr = Array.isArray(j) ? j : (j && typeof j === 'object' ? [j] : null);
+  if (!arr) return null;
+  const out = [];
+  for (const r of arr) {
+    if (!r || typeof r !== 'object') continue;
+    const pid = num(r.ProcessId);
+    if (pid === null) continue;
+    out.push({
+      pid,
+      ppid: num(r.ParentProcessId) === null ? 0 : num(r.ParentProcessId),
+      name: typeof r.Name === 'string' ? r.Name : '',
+      created: num(r.Created),
+      ws: num(r.WorkingSetSize),
+      cmd: typeof r.Cmd === 'string' ? r.Cmd : null,
+    });
+  }
+  return out.length ? out : null;
+}
+
+const MONTHS = { Jan: 0, Feb: 1, Mar: 2, Apr: 3, May: 4, Jun: 5, Jul: 6, Aug: 7, Sep: 8, Oct: 9, Nov: 10, Dec: 11 };
+
+/** `ps -eo pid,ppid,lstart,comm,args` (lstart = "Wed Nov  5 21:06:01 2026", local time) -> list, or null. */
+function parsePs(text) {
+  const out = [];
+  for (const line of String(text).split(/\r?\n/)) {
+    const m = /^\s*(\d+)\s+(\d+)\s+\w{3}\s+(\w{3})\s+(\d{1,2})\s+(\d{2}):(\d{2}):(\d{2})\s+(\d{4})\s+(\S+)\s*(.*)$/.exec(line);
+    if (!m) continue;
+    const t = new Date(Number(m[8]), MONTHS[m[3]], Number(m[4]), Number(m[5]), Number(m[6]), Number(m[7])).getTime();
+    out.push({ pid: Number(m[1]), ppid: Number(m[2]), name: m[9].replace(/^.*\//, ''), created: Number.isFinite(t) ? t : null, ws: null, cmd: m[10] ? m[10].slice(0, 200) : null });
+  }
+  return out.length ? out : null;
+}
+
+/**
+ * Process list of this machine, or null (any error, timeout, empty or unreadable output). Never throws.
+ * `exec(file, args, {timeout})` -> stdout string is injectable for tests.
+ */
+function listProcesses(opts) {
+  const o = opts || {};
+  const timeout = typeof o.timeoutMs === 'number' && o.timeoutMs > 0 ? o.timeoutMs : DEFAULT_TIMEOUT_MS;
+  const platform = o.platform || process.platform;
+  const exec = typeof o.exec === 'function' ? o.exec : defaultExec;
+  if (process.env.DIEU_PHOI_NO_PROCS === '1' && typeof o.exec !== 'function') return null; // tests: never look at the real machine
+  try {
+    if (platform === 'win32') {
+      const out = exec('powershell', ['-NoProfile', '-NonInteractive', '-Command', PS_WIN], { timeout });
+      return typeof out === 'string' ? parseWindowsJson(out) : null;
+    }
+    const out = exec('ps', ['-eo', 'pid,ppid,lstart,comm,args'], { timeout });
+    return typeof out === 'string' ? parsePs(out) : null;
+  } catch (_) {
+    return null;
+  }
+}
+
+function defaultExec(file, args, o) {
+  const r = cp.spawnSync(file, args, { encoding: 'utf8', timeout: o.timeout, windowsHide: true, maxBuffer: 32 * 1024 * 1024 });
+  if (r.error || r.status !== 0 || r.signal) return null;
+  return r.stdout || '';
+}
+
+function byPid(list) {
+  const m = new Map();
+  for (const p of list || []) m.set(p.pid, p);
+  return m;
+}
+
+/** All descendants of rootPid (children, grandchildren, ...; not rootPid itself). Cycle-safe (pid reuse). */
+function descendants(list, rootPid) {
+  const kids = new Map();
+  for (const p of list || []) {
+    if (p.pid === p.ppid) continue;
+    if (!kids.has(p.ppid)) kids.set(p.ppid, []);
+    kids.get(p.ppid).push(p);
+  }
+  const out = [];
+  const seen = new Set([rootPid]);
+  const queue = [rootPid];
+  while (queue.length) {
+    const cur = queue.shift();
+    for (const c of kids.get(cur) || []) {
+      if (seen.has(c.pid)) continue;
+      seen.add(c.pid);
+      out.push(c);
+      queue.push(c.pid);
+    }
+  }
+  return out;
+}
+
+/** Ancestors of pid, nearest first (stops at a missing parent, a cycle or 64 hops). */
+function ancestors(list, pid) {
+  const idx = byPid(list);
+  const out = [];
+  const seen = new Set([pid]);
+  let cur = idx.get(pid);
+  for (let i = 0; cur && i < 64; i++) {
+    const par = idx.get(cur.ppid);
+    if (!par || seen.has(par.pid)) break;
+    seen.add(par.pid);
+    out.push(par);
+    cur = par;
+  }
+  return out;
+}
+
+/** Nearest ancestor of pid named claude(.exe), or null. */
+function claudeAncestor(list, pid) {
+  return ancestors(list, pid).find((p) => /^claude(\.exe)?$/.test(lower(p.name))) || null;
+}
+
+/** A parent that is gone, or whose pid was reused by a process created after the child. */
+function isOrphan(p, idx) {
+  if (!p.ppid) return false; // pid 0: the system's own roots
+  const par = idx.get(p.ppid);
+  if (!par) return true;
+  return Boolean(par.created && p.created && par.created > p.created);
+}
+
+/**
+ * Processes whose parent is no longer in the list. `names` (case-insensitive; default claude.exe, codebase-memory-mcp.exe,
+ * node.exe, bash.exe), `minAgeMs` + `now` to keep only old ones, `skip(p)` to drop known-legitimate ones.
+ */
+function orphans(list, o) {
+  const opt = o || {};
+  const names = new Set((opt.names || ORPHAN_NAMES).map(lower));
+  const now = typeof opt.now === 'number' ? opt.now : Date.now();
+  const idx = byPid(list);
+  const out = [];
+  for (const p of list || []) {
+    if (!names.has(lower(p.name))) continue;
+    if (!isOrphan(p, idx)) continue;
+    if (opt.minAgeMs && !(p.created && now - p.created >= opt.minAgeMs)) continue;
+    if (typeof opt.skip === 'function' && opt.skip(p)) continue;
+    out.push(p);
+  }
+  return out;
+}
+
+/** The code-graph daemon is meant to outlive any session (shared by all of them): never an orphan to clean. */
+function isCbmDaemon(p) {
+  return /codebase-memory-mcp/i.test(p.name) && /daemon/i.test(p.cmd || '');
+}
+
+/**
+ * Orphaned Claude Code / code-graph processes older than minAgeMs (doctor and state): [{pid, name, age_h, ws_mb}] oldest first.
+ */
+function staleOrphans(list, o) {
+  const opt = o || {};
+  const now = typeof opt.now === 'number' ? opt.now : Date.now();
+  return orphans(list, { names: ['claude.exe', 'claude', 'codebase-memory-mcp.exe', 'codebase-memory-mcp'], minAgeMs: opt.minAgeMs, now, skip: isCbmDaemon })
+    .sort((a, b) => (a.created || 0) - (b.created || 0))
+    .map((p) => ({ pid: p.pid, name: p.name, age_h: Math.round(((now - (p.created || now)) / 3600000) * 10) / 10, ws_mb: p.ws ? Math.round(p.ws / 1048576) : null }));
+}
+
+/**
+ * Processes an agent left behind: descendants of the Claude Code process (rootPid) created at or after startMs, still in the
+ * list, not on the hook's own chain (selfPid and its ancestors), not claude/code-graph/conhost. Pure. Returns the list items;
+ * `roots` = those whose parent is not itself a leftover (what a kill must target; taskkill /T takes their children).
+ */
+function leftoverProcesses(list, o) {
+  const opt = o || {};
+  if (!Array.isArray(list) || !opt.rootPid || !opt.startMs) return { all: [], roots: [] };
+  const own = new Set([opt.selfPid, ...ancestors(list, opt.selfPid).map((p) => p.pid)].filter(Boolean));
+  const skip = new Set((opt.skipNames || LEFTOVER_SKIP_NAMES).map(lower));
+  const all = descendants(list, opt.rootPid).filter((p) => !own.has(p.pid) && p.created && p.created >= opt.startMs && !skip.has(lower(p.name)));
+  const ids = new Set(all.map((p) => p.pid));
+  return { all, roots: all.filter((p) => !ids.has(p.ppid)) };
+}
+
+/** Kill process trees. Windows `taskkill /PID n /T /F`, else SIGTERM. `deadline` (epoch ms) stops early. Returns the pids stopped; never throws. */
+function killTree(pids, o) {
+  const opt = o || {};
+  const done = [];
+  for (const pid of pids || []) {
+    const left = opt.deadline ? opt.deadline - Date.now() : 3000;
+    if (left <= 0) break; // out of time budget: the rest stay reported, not killed
+    try {
+      if ((opt.platform || process.platform) === 'win32') {
+        const r = cp.spawnSync('taskkill', ['/PID', String(pid), '/T', '/F'], { timeout: Math.min(3000, left), windowsHide: true });
+        if (!r.error && r.status === 0) done.push(pid);
+      } else {
+        process.kill(pid, 'SIGTERM');
+        done.push(pid);
+      }
+    } catch (_) { /* gone already or not ours */ }
+  }
+  return done;
+}
+
+module.exports = {
+  PS_WIN, ORPHAN_NAMES, LEFTOVER_SKIP_NAMES,
+  parseWindowsJson, parsePs, listProcesses,
+  descendants, ancestors, claudeAncestor, orphans, staleOrphans, isCbmDaemon, leftoverProcesses, killTree,
+};