@kienntpixon/dieu-phoi 0.6.0 → 0.7.0

package/lib/commands.cjs

@@ -8,13 +8,14 @@ const core = require('../hook.cjs');
 const agg = require('./aggregate.cjs');
 const chooser = require('./choose.cjs');
 const setupLib = require('./setup.cjs');
+const cbm = require('./cbm.cjs');
 const { claudeDirOf, ctxOf, yesNo, repoOf } = require('./args.cjs');
 
 const AGENT_OUTCOMES = ['pass', 'fail', 'timeout', 'aborted'];
 const USER_OUTCOMES = ['accept', 'reject'];
 const CAUSES = ['quality', 'scope'];
 const STEER_KINDS = ['minor', 'plan', 'redirect'];
-const VERIFY = ['tests', 'lint', 'review', 'judgment', 'none'];
+const VERIFY = ['tests', 'lint', 'review', 'judgment', 'self', 'none'];
 const INVALID_ID_WINDOW_DAYS = 7;
 const NEW_ID_MAX = 1000;
 
@@ -48,6 +49,7 @@ function table(rows) {
 // ------------------------------------------------------------------ setup / uninstall
 
 function cmdSetup(opts) {
+  if (opts['with-codebase-memory']) return cmdSetupWithCbm(opts);
   const res = setupLib.setup({
     claudeDir: claudeDirOf(opts),
     dept: typeof opts.dept === 'string' ? opts.dept : undefined,
@@ -75,6 +77,30 @@ function cmdSetup(opts) {
   return { code: 0, out: lines.join('\n') };
 }
 
+/** `setup --with-codebase-memory [--force] [--cbm-dir D]`: normal setup, then install + register codebase-memory-mcp. */
+async function cmdSetupWithCbm(opts) {
+  const base = cmdSetup(Object.assign({}, opts, { 'with-codebase-memory': false, json: false }));
+  let res;
+  let err = null;
+  try {
+    res = await cbm.install({ claudeDir: claudeDirOf(opts), force: !!opts.force, dir: typeof opts['cbm-dir'] === 'string' ? opts['cbm-dir'] : undefined, allowCustomSource: !!opts['allow-custom-source'] });
+  } catch (e) {
+    err = e.message;
+  }
+  if (opts.json) return { code: err ? 1 : 0, out: JSON.stringify({ setup: 'ok', codebase_memory: err ? { ok: false, error: err } : res }, null, 2) };
+  const lines = [base.out];
+  if (err) {
+    lines.push(`codebase-memory-mcp: LỖI — ${err} (setup dieu-phoi vẫn xong; không có gì bị ghi đè)`);
+  } else {
+    const act = { kept: 'đã có, giữ nguyên (--force để cài lại)', installed: 'đã cài', replaced: 'đã thay' }[res.action];
+    lines.push(`codebase-memory-mcp: ${act} v${res.version || '?'} tại ${res.binary.replace(/\\/g, '/')}${res.backup ? ` (bản cũ: ${path.basename(res.backup)})` : ''}`);
+    lines.push(`MCP (user scope): ${{ kept: 'đã đăng ký, giữ nguyên', 'kept-other': 'đã đăng ký (binary khác), giữ nguyên', added: 'đã đăng ký bằng `claude mcp add`', replaced: 'đã đăng ký lại', restored: 'đăng ký mới lỗi — đã khôi phục đăng ký cũ', manual: 'chưa đăng ký (xem ghi chú)' }[res.mcp]}`);
+    for (const n of res.notes) lines.push(`  - ${n}`);
+    if (res.action !== 'kept' || res.mcp === 'added' || res.mcp === 'replaced') lines.push('Khởi động lại các phiên Claude Code để nạp MCP; kiểm bằng `dieu-phoi doctor`.');
+  }
+  return { code: err ? 1 : 0, out: lines.join('\n') };
+}
+
 function cmdUninstall(opts) {
   const res = setupLib.uninstall({ claudeDir: claudeDirOf(opts), purge: !!opts.purge });
   if (opts.json) return { code: 0, out: JSON.stringify(res, null, 2) };
@@ -116,6 +142,14 @@ async function cmdDoctor(opts) {
   const sd = ctx.config.skill_dir;
   add(!!sd && fs.existsSync(path.join(sd, 'profile', 'profile.json')), 'profile',
     sd ? path.join(sd, 'profile', 'profile.json') : 'không có skill_dir — choose dùng priors mặc định', 'CẢNH BÁO');
+  // codebase-memory-mcp (optional): started here so its `daemon status` (~2.7 s, only with --cbm/--net; else a 10-minute
+  // cache) overlaps the hook-run check below
+  let cbmP = Promise.resolve([]);
+  try {
+    cbmP = cbm.doctorChecks({ claudeDir, repo: repoOf(opts), net: !!opts.net, deep: !!opts.cbm, cacheFile: path.join(ctx.paths.data, 'cbm-daemon.json') }).catch((e) => [{ ok: true, level: 'OK', name: 'codebase-memory', detail: `bỏ qua kiểm (${e.message})` }]);
+  } catch (e) {
+    cbmP = Promise.resolve([{ ok: true, level: 'OK', name: 'codebase-memory', detail: `bỏ qua kiểm (${e.message})` }]);
+  }
   if (reg.commands.length) {
     const cmd = reg.commands[0];
     const t0 = Date.now();
@@ -168,13 +202,17 @@ async function cmdDoctor(opts) {
     const cached = opts.net ? null : core.sinkStatusCached(ctx);
     if (cached && (cached.state === 'ok' || cached.state === 'fail')) {
       add(cached.state === 'ok', 'sink', `${ctx.config.sink_url} → ${cached.state === 'ok' ? 'ok' : `lỗi: ${cached.detail}`} (bộ nhớ đệm: ${cached.source} lúc ${cached.ts}; \`doctor --net\` để kiểm trực tiếp)`);
+    } else if (!opts.net && recentSinkTimeout(ctx)) {
+      const t = recentSinkTimeout(ctx);
+      add(false, 'sink', `${ctx.config.sink_url} → chậm/không xác định: lần kiểm lúc ${t.ts} không phản hồi kịp (chưa coi là lỗi); \`doctor --net\` để thử lại`, 'CẢNH BÁO');
     } else {
       const live = await checkSinkLive(ctx);
-      add(live.ok, 'sink', `${ctx.config.sink_url} → ${live.detail}`);
+      add(live.ok, 'sink', `${ctx.config.sink_url} → ${live.detail}`, live.slow ? 'CẢNH BÁO' : undefined);
     }
   } else {
     add(true, 'sink', 'chưa cấu hình (chỉ lưu cục bộ)');
   }
+  for (const c of await cbmP) checks.push(c);
   const failed = checks.some((c) => c.level === 'LỖI');
   if (opts.json) return { code: failed ? 1 : 0, out: JSON.stringify({ ok: !failed, runs_dir: reg.runs_dir, checks }, null, 2) };
   const out = checks.map((c) => `[${c.level}] ${c.name}: ${c.detail}`).join('\n');
@@ -208,26 +246,45 @@ function sweepStaleTmp(ctx) {
   return { removed, left };
 }
 
-/** Live sink check (view=stats); result cached in data/sink-check.json for 24 h. */
+/** The doctor's own timed-out sink check for the current sink, if less than 1 h old (else null): plain `doctor` does not retry a 20 s wait each time. */
+function recentSinkTimeout(ctx) {
+  const chk = core.readJsonFile(ctx.paths.sinkCheck, null);
+  if (!chk || !chk.timeout || chk.url !== core.sinkUrlKey(ctx.config)) return null;
+  const t = Date.parse(chk.ts);
+  return t && Date.now() - t < 3600 * 1000 && t <= Date.now() + 60000 ? { ts: chk.ts } : null;
+}
+
+/**
+ * Live sink check (view=stats); result cached in data/sink-check.json for 24 h. Apps Script often needs 8-15 s, so the
+ * timeout is 20 s (DIEU_PHOI_SINK_CHECK_TIMEOUT_MS overrides, for tests). A timeout is not a hard failure: it is
+ * reported as slow/unknown (CẢNH BÁO) and cached with `timeout: true`, which the cache readers ignore.
+ */
 async function checkSinkLive(ctx) {
   let ok = false;
+  let slow = false;
   let detail;
+  const ms = Number(process.env.DIEU_PHOI_SINK_CHECK_TIMEOUT_MS) > 0 ? Number(process.env.DIEU_PHOI_SINK_CHECK_TIMEOUT_MS) : 20000;
   try {
     const u = new URL(ctx.config.sink_url);
     u.searchParams.set('token', ctx.config.sink_token);
     u.searchParams.set('view', 'stats');
-    const res = await fetch(u, { redirect: 'follow', signal: AbortSignal.timeout(8000) });
+    const res = await fetch(u, { redirect: 'follow', signal: AbortSignal.timeout(ms) });
     const txt = await res.text();
     ok = res.ok;
     try { const b = JSON.parse(txt); if (b && b.ok === false) ok = false; } catch (_) { ok = false; }
     detail = `HTTP ${res.status}`;
   } catch (e) {
-    detail = e.message;
+    if (e && (e.name === 'TimeoutError' || e.name === 'AbortError')) {
+      slow = true;
+      detail = `chậm/không xác định: không phản hồi trong ${Math.round(ms / 1000)} s (Apps Script thường mất 8-15 s; chạy lại \`doctor --net\`, hoặc xem kết quả sync nền)`;
+    } else {
+      detail = e.message;
+    }
   }
   try {
-    core.writeFileAtomic(ctx.paths.sinkCheck, `${JSON.stringify({ ts: core.nowIso(), ok, detail, url: core.sinkUrlKey(ctx.config) })}\n`);
+    core.writeFileAtomic(ctx.paths.sinkCheck, `${JSON.stringify({ ts: core.nowIso(), ok, detail, url: core.sinkUrlKey(ctx.config), ...(slow ? { timeout: true } : {}) })}\n`);
   } catch (_) { /* cache is best effort */ }
-  return { ok, detail };
+  return { ok, detail, slow };
 }
 
 // ------------------------------------------------------------------ start
@@ -238,8 +295,13 @@ async function checkSinkLive(ctx) {
  */
 function cmdStart(opts) {
   const ctx = ctxOf(opts);
+  const wantMode = modeOpt(opts); // validate before the run dir is created
   const reg = setupLib.registration(claudeDirOf(opts));
   const info = core.startInfo(ctx, repoOf(opts));
+  if (wantMode) {
+    core.appendEvent(ctx, modeEvent(ctx, info.id, wantMode, 'start', opts.reason));
+    info.mode = wantMode;
+  }
   const h = info.health;
   if (!fs.existsSync(ctx.paths.hook)) h.problems.unshift(`chưa cài hook (${ctx.paths.hook}) — chạy \`dieu-phoi setup --dept <phòng>\`, log không được ghi`);
   else if (!(reg.PostToolUse && reg.SubagentStop && reg.SessionStart)) h.problems.unshift('hook chưa đăng ký đủ trong settings.json — chạy lại `dieu-phoi setup`, log/trạng thái không được ghi');
@@ -257,12 +319,58 @@ function cmdStart(opts) {
     `step_ids: ${info.step_ids.join(' ')}`,
     `health: ${core.healthLine(h)}`,
     `scout_brief: ${info.scout_brief || '(không thấy — dùng references/brief-template.md mục E)'}`,
+    core.modeLine(info),
     ...core.orchLessonLines(info),
     ...core.knowledgeLines(info),
   ];
   return { code: 0, out: out.join('\n') };
 }
 
+// ------------------------------------------------------------------ mode
+
+/** One local-only mode event for a request (root_task_id). source: start | cmd | plan. */
+function modeEvent(ctx, root, mode, source, reason, session) {
+  const sid = typeof session === 'string' && session ? session : (process.env.CLAUDE_CODE_SESSION_ID || null);
+  return Object.assign({
+    schema: core.SCHEMA,
+    kind: 'mode',
+    ts: core.nowIso(),
+    agent_id: `root:${root}`,
+    task_id: null,
+    root_task_id: root,
+    mode,
+    source,
+    reason_code: kebab(reason),
+    session_id: sid,
+  }, core.commonFields(ctx));
+}
+
+/**
+ * `dieu-phoi mode --root <root_task_id> [fast|normal|strict] [--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]';
+  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 show = (extra) => (opts.json ? JSON.stringify(Object.assign({ root_task_id: root, mode: was, previous: was, changed: false }, extra)) : null);
+  if (want === 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}`);
+  if (cur && was === want) {
+    return { code: 0, out: show({}) || `root ${root}: vẫn ${want} (không đổi, không ghi sự kiện)` };
+  }
+  core.appendEvent(ctx, modeEvent(ctx, root, want, 'cmd', opts.reason, opts.session));
+  if (opts.json) return { code: 0, out: JSON.stringify({ root_task_id: root, mode: want, previous: was, changed: true }) };
+  return { code: 0, out: `root ${root}: ${was} → ${want} (áp cho bước chưa giao; bước đã giao giữ mode lúc giao)` };
+}
+
 // ------------------------------------------------------------------ hook / sync
 
 function cmdHook(opts) {
@@ -369,6 +477,7 @@ function verdictUser(opts, ctx, events) {
   if (typeof taskId !== 'string' || !taskId) throw new Error('--task cần task_id');
   requireTaskId(taskId);
   if (!USER_OUTCOMES.includes(outcome)) throw new Error(`verdict --task: outcome phải là ${USER_OUTCOMES.join('|')}`);
+  if (opts.auto && outcome !== 'accept') throw new Error('--auto chỉ dùng với accept (tự nghiệm thu bước fast); reject luôn là của người dùng: verdict --task <task_id> reject --cause quality|scope');
   let cause = typeof opts.cause === 'string' ? opts.cause : null;
   if (outcome === 'reject' && !CAUSES.includes(cause)) throw new Error(`reject cần --cause ${CAUSES.join('|')} (scope = yêu cầu đổi/thiếu, không phải lỗi model)`);
   if (outcome === 'accept') cause = null;
@@ -376,6 +485,7 @@ function verdictUser(opts, ctx, events) {
   if (!known) throw new Error(`Không thấy task "${taskId}" trong log.`);
   const rounds = events.filter((e) => e.kind === 'verdict' && e.task_id === taskId
     && agg.normalizeVerdict(e).by === 'user').map((e) => Number(e.round) || 1);
+  if (opts.auto) return verdictAuto(opts, ctx, events, taskId, rounds);
   let round = (rounds.length ? Math.max(...rounds) : 0) + 1;
   if (opts.round !== undefined) {
     round = Number(opts.round);
@@ -396,6 +506,33 @@ function verdictUser(opts, ctx, events) {
   }, core.commonFields(ctx));
 }
 
+/**
+ * `verdict --task <task_id> accept --auto` (core 0.7.0): a fast-mode step that passed the batch verifier is accepted
+ * automatically (`by=auto`). Not a user verdict: never counts in accept_rate/user_outcomes/rounds, never merges
+ * knowledge; the user's final `verdict --root … accept` (by=user) or a later reject (wins) still decides.
+ */
+function verdictAuto(opts, ctx, events, taskId, userRounds) {
+  if (opts.round !== undefined || opts.cause !== undefined) throw new Error('--auto không nhận --round/--cause');
+  if (userRounds.length) throw new Error(`Task ${taskId} đã có verdict người dùng; --auto chỉ dùng trước khi người dùng nghiệm thu.`);
+  const mode = core.taskModeInfo(ctx, taskId, events).mode;
+  if (mode !== 'fast') throw new Error(`--auto chỉ cho bước mode fast (task ${taskId} đang ${mode}); bước khác chờ người dùng nghiệm thu.`);
+  const exec = events.find((e) => e.kind === 'dispatch' && e.task_id === taskId && (e.role || 'exec') === 'exec');
+  if (exec && typeof exec.score === 'number' && exec.score > 6) throw new Error(`--auto chỉ cho bước score ≤ 6 (task ${taskId} score ${exec.score}).`);
+  return Object.assign({
+    schema: core.SCHEMA,
+    kind: 'verdict',
+    ts: core.nowIso(),
+    agent_id: `task:${taskId}`,
+    task_id: taskId,
+    by: 'auto',
+    outcome: 'accept',
+    cause: null,
+    round: null,
+    verify: 'tests',
+    reason_code: kebab(opts.reason),
+  }, core.commonFields(ctx));
+}
+
 /**
  * `verdict --root <root> accept [--steps a,b]` (core 0.4.0): the user accepts the steps of the latest approved plan
  * in one call. Covers every step whose task has an exec dispatch and no user verdict yet (a step already rejected
@@ -403,6 +540,7 @@ function verdictUser(opts, ctx, events) {
  */
 function verdictRoot(opts, ctx, events) {
   const root = requireTaskId(String(opts.root));
+  if (opts.auto) throw new Error('verdict --root là người dùng duyệt cuối (by=user), không nhận --auto; tự nghiệm thu từng bước: verdict --task <task_id> accept --auto');
   if (opts._[0] !== 'accept') {
     throw new Error('verdict --root chỉ nhận accept; bước không đạt → dieu-phoi verdict --task <task_id> reject --cause quality|scope');
   }
@@ -495,6 +633,9 @@ function cmdVerdict(opts) {
     if (kn) process.stderr.write(`${kn.out}\n`);
     return { code: 0, out: JSON.stringify(ev) };
   }
+  if (ev.by === 'auto') {
+    return { code: 0, out: `Đã ghi tự nghiệm thu (by=auto) cho task ${ev.task_id}: không tính vào accept_rate; người dùng vẫn duyệt cuối (verdict --root <root> accept) hoặc reject (thắng auto).` };
+  }
   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 };
@@ -690,12 +831,14 @@ function pct(v) {
 function cmdStats(opts) {
   const ctx = ctxOf(opts);
   const { lambda } = lambdaOf(opts, ctx);
-  const { cells, steers, orchestration } = agg.analyze(core.readEvents(ctx), { lambda });
+  const events = core.readEvents(ctx);
+  const { cells, steers, orchestration, tasks } = 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 }, null, 2) };
+    return { code: 0, out: JSON.stringify({ lambda_usd_per_min: lambda, min_n: agg.MIN_N, cells: rows, steers: steerRows, orchestration, modes }, 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.' };
@@ -722,13 +865,40 @@ function cmdStats(opts) {
   }
   return {
     code: 0,
-    out: `${table(t)}\n\n${table(s)}\n\n${orchLine(orchestration)}\n\n`
+    out: `${table(t)}\n\n${table(s)}\n\n${modeTable(modes)}${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.`,
   };
 }
 
+/** Stats by mode (core 0.7.0): one row per mode with tasks, then a blank line; '' when only normal has data. */
+function modeTable(modes) {
+  const keys = agg.MODE_KEYS.filter((m) => modes[m] && modes[m].tasks);
+  if (!keys.length || (keys.length === 1 && keys[0] === 'normal')) return '';
+  const t = [['mode', 'task', 'có verifier', 'catch%', 'reject%', 'phút verify', 'test_s', 'test_s/task', 'lần cả suite', 'verdict self', 'fail verify gộp']];
+  for (const m of keys) {
+    const r = modes[m];
+    t.push([
+      m, r.tasks, r.verified_tasks,
+      r.checked_verdicts ? `${pct(r.catch_rate)} (${r.checked_verdicts})` : '-',
+      r.user_verdict_tasks ? `${pct(r.reject_rate)} (${r.user_verdict_tasks})` : '-',
+      fmtNum(r.verify_min), fmtNum(r.test_s), r.test_s_per_task === null ? '-' : fmtNum(r.test_s_per_task),
+      r.full_suite_runs, r.self_verdicts, r.batch_verify_fails,
+    ]);
+  }
+  return `${table(t)}\n\n`;
+}
+
+/** One retro line: per mode with tasks. */
+function modeRetroLine(modes) {
+  const parts = agg.MODE_KEYS.filter((m) => modes[m].tasks).map((m) => {
+    const r = modes[m];
+    return `${m} ${r.tasks} task, catch ${pct(r.catch_rate)}, reject ${pct(r.reject_rate)}, verify ${fmtNum(r.verify_min)}m, test ${fmtNum(r.test_s)}s, cả suite ×${r.full_suite_runs}`;
+  });
+  return `Theo mode: ${parts.join(' · ') || '-'}`;
+}
+
 const HIGH_STEER_RATE = 0.3;
 const HIGH_STEER_MIN_TASKS = 3;
 
@@ -737,6 +907,7 @@ function cmdRetro(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 modes = agg.modeSummary(events, tasks);
   const reasons = {};
   const outcomes = {};
   const userOutcomes = {};
@@ -776,6 +947,10 @@ function cmdRetro(opts) {
       multi_attempt_tasks: escalations,
       discarded_tasks: agg.discardedTaskIds(events).size,
       overrides: overrides.length,
+      // core 0.7.0: fast-mode evidence kept apart from the learning data (CONTRACT "Mode theo yêu cầu")
+      self_verdicts: agents.reduce((s, a) => s + (a.self_verdicts || 0), 0),
+      auto_accept: tasks.filter((t) => t.auto_accept).length,
+      auto_overturned: tasks.filter((t) => t.auto_overturned).length,
       cost_usd: agents.reduce((s, a) => s + (a.cost_usd || 0), 0),
     },
     lambda_usd_per_min: prof.lambda,
@@ -788,6 +963,7 @@ function cmdRetro(opts) {
     high_steer_task_types: highSteer,
     overrides: overrides.map((o) => ({ ts: o.ts, task_type: o.task_type, suggested_tier: o.suggested_tier, chosen_tier: o.chosen_tier })),
     orchestration,
+    modes,
     cells,
   };
   if (opts.json) return { code: 0, out: JSON.stringify(summary, null, 2) };
@@ -795,10 +971,12 @@ function cmdRetro(opts) {
     `Retro ${summary.dept || ''} — ${summary.period ? `${summary.period.from.slice(0, 10)} → ${summary.period.to.slice(0, 10)}` : 'chưa có dữ liệu'}`,
     `${summary.totals.tasks} task, ${summary.totals.agents} agent, chi phí ≈ ${fmtUsd(summary.totals.cost_usd)}, ${summary.totals.untagged_agents} agent không thẻ, ${summary.totals.no_user_verdict_tasks} task chưa có verdict người dùng, ${escalations} task nhiều lượt, ${overrides.length} override.`,
     `Người dùng: ${Object.entries(userOutcomes).map(([k, v]) => `${k}=${v}`).join(', ') || '-'} · Agent: ${Object.entries(outcomes).map(([k, v]) => `${k}=${v}`).join(', ') || '-'}`,
+    `Fast: verdict self=${summary.totals.self_verdicts} (không vào agent_pass_rate), tự nghiệm thu auto_accept=${summary.totals.auto_accept}, người dùng lật auto_overturned=${summary.totals.auto_overturned}`,
     `Lý do hay gặp: ${summary.reason_codes.slice(0, 8).map((r) => `${r.code}×${r.count}`).join(', ') || '-'}`,
     `Loại task: ${summary.task_types.map((t) => `${t.task_type}(${t.n})`).join(', ') || '-'}`,
     `Steer nhiều (brainstorm hỏi quá ít): ${highSteer.map((s) => `${s.task_type} ${pct(s.steer_rate)}`).join(', ') || '-'}`,
     orchLine(orchestration),
+    modeRetroLine(modes),
     'Chi tiết theo ô: `dieu-phoi stats`; đưa cho LLM: `dieu-phoi retro --json`.',
   ];
   return { code: 0, out: lines.join('\n') };
@@ -806,6 +984,13 @@ function cmdRetro(opts) {
 
 // ------------------------------------------------------------------ choose
 
+/** --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;
+}
+
 function chooseInput(opts, ctx, events) {
   return {
     type: opts.type,
@@ -813,6 +998,9 @@ function chooseInput(opts, ctx, events) {
     urgency: typeof opts.urgency === 'string' ? opts.urgency : 'normal',
     reversible: yesNo(opts.reversible, true),
     verifiable: yesNo(opts.verifiable, true),
+    publish: yesNo(opts.publish, false),
+    dependents: yesNo(opts.dependents, false),
+    mode: modeOpt(opts),
     role: typeof opts.role === 'string' ? opts.role : 'exec',
     seed: opts.seed,
     taskId: typeof opts.task === 'string' ? opts.task : null,
@@ -837,6 +1025,18 @@ function overrideEvent(ctx, taskId, taskType, suggested, chosen) {
   }, core.commonFields(ctx));
 }
 
+/**
+ * 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.
+ */
+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 cmdChoose(opts) {
   const ctx = ctxOf(opts);
   if (opts.override !== undefined && typeof opts.task !== 'string') {
@@ -844,7 +1044,20 @@ function cmdChoose(opts) {
   }
   if (opts.task !== undefined) requireTaskId(typeof opts.task === 'string' ? opts.task : '');
   const input = chooseInput(opts, ctx, core.readEvents(ctx));
+  let modeSource = 'flag';
+  const mi = input.taskId ? core.taskModeInfo(ctx, input.taskId, input.events) : null;
+  if (input.mode === undefined) {
+    if (mi) {
+      input.mode = mi.mode;
+      modeSource = mi.source;
+    } else {
+      input.mode = core.DEFAULT_MODE;
+      modeSource = 'default';
+    }
+  }
   const res = chooser.choose(input);
+  res.mode_source = modeSource;
+  if (res.verify_plan) Object.assign(res, chooseModeSuggest(ctx, input, res, mi));
   const orch = measureOrch(opts, ctx, input.profile);
   res.orch_ctx_tokens = orch.ctx_tokens;
   res.orch_ctx_growth = orch.ctx_growth;
@@ -863,14 +1076,15 @@ 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 warn = `${typeWarn}${res.orch_ctx_warn ? `\nCẢNH BÁO: ${orch.advice}` : ''}`;
+  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 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}` };
   }
   return {
     code: 0,
-    out: `model=${res.model} effort=${res.effort}${res.explored ? ' (thăm dò)' : ''}${res.overridden ? ' (override)' : ''}${res.deviation ? ' (LỆCH khỏi tier đã duyệt)' : ''} ${est} — ${res.reason}${warn}`,
+    out: `model=${res.model} effort=${res.effort}${res.explored ? ' (thăm dò)' : ''}${res.overridden ? ' (override)' : ''}${res.deviation ? ' (LỆCH khỏi tier đã duyệt)' : ''} ${est} — ${res.reason}${res.verify_plan ? ` | mode=${res.mode} kiểm=${res.verify_plan} (${res.test_scope === 'selective' ? 'test chọn lọc' : 'cả suite'})` : ''}${warn}`,
   };
 }
 
@@ -917,6 +1131,8 @@ function buildPlanTable(rawSteps, base) {
       score: s.score,
       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,
       urgency: s.urgency,
       deps: deps.map(String),
     };
@@ -933,6 +1149,9 @@ function buildPlanTable(rawSteps, base) {
       verifiable: s.verifiable,
       reversible: s.reversible,
       urgency: s.urgency || base.urgency,
+      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,
       taskId: s.task || base.taskId,
       override: s.override || base.override,
       role: s.role || base.role,
@@ -942,6 +1161,7 @@ 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,
+      mode: s.mode || base.mode || core.DEFAULT_MODE, mode_override: s.mode || null,
     };
     try {
       return Object.assign(head, call());
@@ -958,7 +1178,10 @@ function buildPlanTable(rawSteps, base) {
   const ok = rows.filter((r) => r.action !== 'refused');
   const costs = ok.map((r) => r.est_cost_usd);
   const totalCost = costs.every((c) => typeof c === 'number') ? costs.reduce((a, b) => a + b, 0) : null;
+  const selfBatch = rows.filter((r) => r.verify_plan === 'self+batch').length;
   return {
+    mode: base.mode || core.DEFAULT_MODE,
+    self_batch_steps: selfBatch,
     steps: rows,
     refused: rows.filter((r) => r.action === 'refused').map((r) => ({ step: r.step, error: r.error })),
     total_cost_usd: totalCost === null ? null : Math.round(totalCost * 1000) / 1000,
@@ -1054,10 +1277,10 @@ function recordApprovedPlan(ctx, root, stepsFile, plan) {
     steps_file: stepsFile.split(path.sep).join('/'),
     approved_at: core.nowIso(),
     approval: prevApproval(prev) + 1,
-    steps: plan.steps.map((r) => ({
+    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,
-    })),
+    }, r.mode_override ? { mode: r.mode_override } : {})),
     history,
   };
   core.writeFileAtomic(file, `${JSON.stringify(rec, null, 2)}\n`);
@@ -1094,8 +1317,19 @@ function cmdPlanTable(opts) {
     throw new Error(`plan-table: không đọc được ${opts.file}: ${e.message}`);
   }
   const ctx = ctxOf(opts);
+  // steps.json: array (old) or { mode?, steps: [...] }; root mode = --mode > current mode event of --root > file.mode > normal
+  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;
+    }
+    raw = raw.steps;
+  }
   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;
+  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);
   if (opts.approve && problems.length) {
@@ -1105,26 +1339,33 @@ function cmdPlanTable(opts) {
   const typeNotes = planTypeNotes(plan);
   if (typeNotes.length) process.stderr.write(`dieu-phoi plan-table: cảnh báo — ${typeNotes.join('; ')}\n`);
   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)) {
+    core.appendEvent(ctx, modeEvent(ctx, rec.root_task_id, plan.mode, 'plan', opts.reason));
+    modeLogged = true;
+  }
   const ovs = rec ? planOverrideEvents(ctx, plan, base.events) : [];
   for (const ev of ovs) core.appendEvent(ctx, ev);
   if (rec) recordPlanSuggestions(ctx, plan);
   if (opts.json) {
     const out = rec ? Object.assign({}, plan, {
-      approved: { root_task_id: rec.root_task_id, approval: rec.approval, record: rec.file, overrides_logged: ovs.length },
+      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 |', '|---|---|---|---|---|'];
+  const lines = ['| Bước | Model/effort | Rubric (điểm · kiểm chứng · đảo ngược) | Lý do | Ước tính | 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ô)' : ''}`;
-    lines.push(`| ${mdCell(r.title ? `${r.step}. ${r.title}` : r.step)} | ${mdCell(tierCell)} | ${mdCell(rubric)} | ${mdCell(why)} | ${mdCell(est)} |`);
+    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('');
   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` : ''}`);
   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.`);
@@ -1132,11 +1373,11 @@ function cmdPlanTable(opts) {
 `);
   }
   if (typeNotes.length) lines.push('', `**Loại task:** ${typeNotes.join('; ')}`);
-  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` : ''}`);
+  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 = {
-  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, cmdCtx, cmdState, measureOrch,
+  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,
   cmdPlanTable, cmdNewId, requireTaskId, buildPlanTable, recordApprovedPlan, planTaskIdProblems, criticalPath, resolveAgentId, AGENT_OUTCOMES, USER_OUTCOMES, VERIFY,
 };

package/lib/knowledge.cjs

@@ -1,5 +1,5 @@
 'use strict';
-// `dieu-phoi knowledge ...` — per-project knowledge store (core 0.6.0, unreleased).
+// `dieu-phoi knowledge ...` — per-project knowledge store (core 0.6.0).
 // s1: project identity (path, rekey). s2: the store itself — index.json + sections/<id>.md + history/, read with
 // get/list, written only by `merge --run <id>` (lock, tmp+rename, history, 40-line cap, sha/rev conflicts), and
 // cross-repo links (related: child|parent) for a parent repo whose sessions work in its child repos.

package/lib/profile.cjs

@@ -1,5 +1,5 @@
 'use strict';
-// `dieu-phoi profile base|apply` (core 0.6.0, unreleased): apply an approved retro to <skill>/profile/lessons.md and
+// `dieu-phoi profile base|apply` (core 0.6.0): apply an approved retro to <skill>/profile/lessons.md and
 // profile.json without overwriting what other sessions wrote meanwhile.
 //
 //   profile base --save <dir>   snapshot both files into <dir>/profile-base/ (+ base.json with their sha256) before the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kienntpixon/dieu-phoi",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Hook + CLI ghi log subagent của Claude Code và chọn model/effort theo chi phí + thời gian tới lúc nghiệm thu.",
   "license": "MIT",
   "author": "kiennt <kiennt@pixon.games>",