@kienntpixon/dieu-phoi 0.7.3 → 0.7.5

package/lib/choose.cjs

@@ -145,6 +145,7 @@ function loadProfile(skillDir) {
   return {
     source, dept: r.dept || null, priors, lambda, explore_rate: explore, time_cap_min: timeCap, extra_task_types: extra,
     orch_ctx_soft_cap: softCap, tier_floor: tierFloor,
+    batch_verify_normal: r.batch_verify_normal !== false,
   };
 }
 
@@ -334,23 +335,26 @@ function resolveTaskType(raw, profile) {
 
 // ------------------------------------------------------------------ verify plan (core 0.7.0, mode per request)
 
-const VERIFY_PLANS = ['independent-blocking', 'independent-nonblocking', 'self+batch', 'spot'];
+const VERIFY_PLANS = ['independent-blocking', 'independent-nonblocking', 'self+batch'];
 /** fast: highest score still allowed to drop its own blocking verifier (s<=6 self+batch, s7-8 independent-nonblocking). */
 const FAST_SELF_MAX = 6;
 const FAST_SOFT_MAX = 8;
-/** strict: share of steps that also get a random Opus reviewer spot check. */
-const STRICT_SPOT_RATE = 1 / 3;
-
+/** normal (0.7.4, user decision Q1): s<=4 with no step depending on it -> self+batch (one verifier per group, not per step). */
+const NORMAL_BATCH_MAX = 4;
 /**
  * How one exec step is checked, from the request mode and the step's rubric inputs.
  * The safety floor is evaluated FIRST and wins in every mode: reversible=n, publish/deploy, verifiable=n, score>=9
- * always get an independent blocking verifier. Only after that does the mode loosen (fast) or tighten (strict).
- * opts: { mode, score, verifiable, reversible, publish, dependents, seed }
- * Returns { verify_plan, verify_reason, verify_floor: string[], test_scope: 'selective'|'full' }.
+ * always get an independent blocking verifier. Only after that does fast loosen it, and normal batch the s<=4 steps.
+ * Legacy mode `strict` (removed 0.7.4) reads as normal.
+ * opts: { mode, score, verifiable, reversible, publish, dependents, batchNormal, seed }
+ *   batchNormal === false (profile.batch_verify_normal=false) switches the normal batch off (rollback switch).
+ * Returns { verify_plan, verify_reason, verify_floor: string[], test_scope: 'full' | 'selective' }. Step verification (exec, independent
+ * verifier, batch verifier) always runs the touched-module tests; the full suite runs once at the release gate, not here.
+ * test_scope is 'full' only for a publish/deploy step (that step is the release gate's trigger); every other step is 'selective'.
  */
 function verifyPlanFor(opts) {
-  const mode = opts.mode || core.DEFAULT_MODE;
-  if (!core.MODES.includes(mode)) throw new Error(`--mode phải là ${core.MODES.join('|')}`);
+  const mode = core.normMode(opts.mode || core.DEFAULT_MODE);
+  if (!mode) throw new Error(`--mode phải là ${core.MODES.join('|')}`);
   const score = Number(opts.score);
   const floor = [];
   if (opts.reversible === false) floor.push('khó hoàn tác');
@@ -358,23 +362,24 @@ function verifyPlanFor(opts) {
   if (opts.verifiable === false) floor.push('không kiểm chứng bằng máy');
   if (score >= 9) floor.push(`score ${score}≥9`);
   const out = (plan, reason, scope) => ({ verify_plan: plan, verify_reason: reason, verify_floor: floor, test_scope: scope });
-  if (floor.length) return out('independent-blocking', `sàn an toàn (${floor.join(', ')}) → verifier độc lập chặn bước, mọi mode`, 'full');
+  if (floor.length) return out('independent-blocking', `sàn an toàn (${floor.join(', ')}) → verifier độc lập chặn bước, mọi mode`, opts.publish === true ? 'full' : 'selective');
   if (mode === 'fast') {
     if (score <= FAST_SELF_MAX) {
-      return out('self+batch', `fast, s${score}≤${FAST_SELF_MAX}: exec tự kiểm (test chọn lọc theo file đổi, --verify self); verifier gộp chạy cả suite một lần trước cổng 3`, 'selective');
+      return out('self+batch', `fast, s${score}≤${FAST_SELF_MAX}: exec tự kiểm (test chọn lọc theo file đổi, --verify self); verifier gộp chạy test chọn lọc của các file cả nhóm đã đụng; full suite chỉ ở cổng phát hành`, 'selective');
     }
     if (score <= FAST_SOFT_MAX) {
       return opts.dependents === true
-        ? out('independent-blocking', `fast, s${score}: bước sau phụ thuộc (depends_on) vào bước này → verifier độc lập vẫn chặn`, 'full')
-        : out('independent-nonblocking', `fast, s${score}: verifier độc lập nhưng không chặn bước sau (không bước nào depends_on)`, 'full');
+        ? out('independent-blocking', `fast, s${score}: bước sau phụ thuộc (depends_on) vào bước này → verifier độc lập vẫn chặn`, 'selective')
+        : out('independent-nonblocking', `fast, s${score}: verifier độc lập nhưng không chặn bước sau (không bước nào depends_on)`, 'selective');
     }
   }
-  if (mode === 'strict') {
-    const u = makeRng(opts.seed === undefined || opts.seed === null || opts.seed === true ? undefined : `spot:${opts.seed}`)();
-    if (u < STRICT_SPOT_RATE) return out('spot', 'strict: verifier độc lập chặn + reviewer Opus kiểm ngẫu nhiên (1/3), luôn chạy cả suite', 'full');
-    return out('independent-blocking', 'strict: verifier độc lập chặn, luôn chạy cả suite', 'full');
+  if (mode === 'normal' && score <= NORMAL_BATCH_MAX && opts.batchNormal !== false) {
+    if (opts.dependents !== true) {
+      return out('self+batch', `normal, s${score}≤${NORMAL_BATCH_MAX}, không bước nào phụ thuộc: exec tự kiểm (test chọn lọc theo file đổi, --verify self); verifier gộp chạy test chọn lọc của các file cả nhóm đã đụng (một lần cuối nhóm, trước cổng 3); full suite chỉ ở cổng phát hành`, 'selective');
+    }
+    return out('independent-blocking', `normal, s${score}: bước sau phụ thuộc (depends_on) vào bước này → verifier độc lập chặn`, 'selective');
   }
-  return out('independent-blocking', `${mode}: verifier độc lập chặn bước`, 'full');
+  return out('independent-blocking', `${mode}: verifier độc lập chặn bước`, 'selective');
 }
 
 // ------------------------------------------------------------------ choose
@@ -412,14 +417,14 @@ function choose(opts) {
   }
   const reversible = opts.reversible !== false;
   const verifiable = opts.verifiable !== false;
-  if (opts.mode !== undefined && opts.mode !== null && !core.MODES.includes(opts.mode)) {
+  if (opts.mode !== undefined && opts.mode !== null && !core.normMode(opts.mode)) {
     throw new Error(`--mode phải là ${core.MODES.join('|')} (nhận "${opts.mode}")`);
   }
-  const mode = opts.mode || core.DEFAULT_MODE;
+  const mode = core.normMode(opts.mode || core.DEFAULT_MODE);
+  const profile = opts.profile || loadProfile(null);
   const vp = role === 'exec'
-    ? verifyPlanFor({ mode, score, verifiable, reversible, publish: opts.publish === true, dependents: opts.dependents === true, seed: opts.seed })
+    ? verifyPlanFor({ mode, score, verifiable, reversible, publish: opts.publish === true, dependents: opts.dependents === true, batchNormal: profile.batch_verify_normal, seed: opts.seed })
     : null;
-  const profile = opts.profile || loadProfile(null);
   const lambda = profile.lambda[urgency];
   const rng = makeRng(opts.seed);
   const notes = [];

package/lib/commands.cjs

@@ -411,7 +411,7 @@ function cmdStart(opts) {
     core.modeLine(info),
     ...core.orchLessonLines(info),
     ...core.knowledgeLines(info),
-  ];
+  ].filter((l) => l !== '');
   return { code: 0, out: out.join('\n') };
 }
 
@@ -435,23 +435,24 @@ function modeEvent(ctx, root, mode, source, reason, session) {
 }
 
 /**
- * `dieu-phoi mode --root <root_task_id> [fast|normal|strict] [--reason R] [--session S]`: show or change the mode of a
+ * `dieu-phoi mode --root <root_task_id> [fast|normal] [--reason R] [--session S]`: show or change the mode of a
  * request. One event per change; the same mode again writes nothing. Steps not yet dispatched follow the new mode,
  * dispatched steps keep the mode they were given. Never changes a mode by itself.
  */
 function cmdMode(opts) {
-  const usage = 'Cú pháp: dieu-phoi mode --root <root_task_id> [fast|normal|strict] [--reason R] [--session S] [--json]';
+  const usage = 'Cú pháp: dieu-phoi mode --root <root_task_id> [fast|normal] [--reason R] [--session S] [--json]';
   if (typeof opts.root !== 'string') throw new Error(usage);
   const root = requireTaskId(opts.root);
   const ctx = ctxOf(opts);
   const cur = core.rootModeFromEvents(core.readEvents(ctx), root);
   const was = cur ? cur.mode : core.DEFAULT_MODE;
-  const want = opts._[0];
+  const wantRaw = opts._[0];
   const show = (extra) => (opts.json ? JSON.stringify(Object.assign({ root_task_id: root, mode: was, previous: was, changed: false }, extra)) : null);
-  if (want === undefined) {
+  if (wantRaw === undefined) {
     return { code: 0, out: show({}) || `root ${root}: mode=${was}${cur ? ` (từ ${cur.ts}, nguồn ${cur.source || '?'})` : ' (mặc định, chưa đặt)'}` };
   }
-  if (!core.isMode(want)) throw new Error(`mode phải là ${core.MODES.join('|')} (nhận "${want}"). ${usage}`);
+  const want = userMode(wantRaw);
+  if (!want) throw new Error(`mode phải là ${core.MODES.join('|')} (nhận "${wantRaw}"). ${usage}`);
   if (cur && was === want) {
     return { code: 0, out: show({}) || `root ${root}: vẫn ${want} (không đổi, không ghi sự kiện)` };
   }
@@ -753,6 +754,8 @@ function cmdVerdict(opts) {
     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)), []);
+    // s4 (0.7.5): nhắc số worktree đã merge của repo; --clean-merged thì gỡ luôn (wt clean --merged --yes).
+    wtLines.push(...wt.mergedAfterAccept(ctx, list.map((x) => x.ev.task_id), opts.repo, opts['clean-merged'] === true));
     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.
@@ -774,6 +777,7 @@ function cmdVerdict(opts) {
   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 (ev.by === 'user' && ev.outcome === 'accept') wtLines.push(...wt.mergedAfterAccept(ctx, [ev.task_id], opts.repo, opts['clean-merged'] === true));
   if (opts.json) {
     if (kn && kn.out) process.stderr.write(`${kn.out}\n`);
     if (wtLines.length) process.stderr.write(`${wtLines.join('\n')}\n`);
@@ -980,6 +984,28 @@ function liveLine(live) {
   return `live: phiên ${part(live.session || 0, lim.session)} · máy ${part(live.machine, lim.machine)}${tasks ? ` — ${tasks}` : ''}`;
 }
 
+/**
+ * core 0.7.4 (S1): steps of an approved plan (last 7 days) that run self+batch, whose exec has completed, and that have
+ * neither a batch verifier verdict (reason_code batch-verify) nor a user verdict yet. Gate 3 must not see them unchecked.
+ */
+function batchPendingOf(ctx, events, now) {
+  let files = [];
+  try { files = fs.readdirSync(ctx.paths.plans).filter((f) => f.endsWith('.json')); } catch (_) { return []; }
+  const out = [];
+  for (const f of files) {
+    const rec = core.readJsonFile(path.join(ctx.paths.plans, f), null);
+    if (!rec || !Array.isArray(rec.steps)) continue;
+    const fresh = Date.parse(rec.approved_at) > now - 7 * 24 * 3600 * 1000;
+    if (!fresh) continue;
+    const pending = rec.steps.filter((s) => s && s.verify_plan === 'self+batch' && s.task_id
+      && events.some((e) => e.kind === 'complete' && e.task_id === s.task_id)
+      && !events.some((e) => e.kind === 'verdict' && e.task_id === s.task_id
+        && (String(e.reason_code || '').startsWith('batch-verify') || e.by === 'user')));
+    if (pending.length) out.push({ root_task_id: rec.root_task_id || f.replace(/\.json$/, ''), steps: pending.map((s) => s.id) });
+  }
+  return out;
+}
+
 function cmdState(opts) {
   const ctx = ctxOf(opts);
   const sid = typeof opts.session === 'string' && opts.session ? opts.session
@@ -998,17 +1024,19 @@ function cmdState(opts) {
   const orphans = orphanCount(ctx); // s16: null (unknown) leaves the line out
   const live = core.liveSummary(ctx, sid); // core 0.7.3 (s1)
   const stuck = core.stuckAgents(ctx, { sessionId: sid }); // s6
+  const batchPending = batchPendingOf(ctx, core.readEvents(ctx), Date.now()); // core 0.7.4 (S1)
   if (opts.json) {
     const liveJ = {
       session: live.session, machine: live.machine, limits: live.limits, free_session: freeSlots(live.limits.session, live.session), free_machine: freeSlots(live.limits.machine, live.machine), agents: live.agents,
       stuck: stuck.map((a) => ({ agent_id: a.agent_id, task_id: a.task_id, role: a.role, gen: a.gen, state: a.state, reasons: a.reasons, idle_min: a.idle_min, age_min: a.age_min })),
     };
-    return { code: 0, out: JSON.stringify(Object.assign({}, state, hasDeltas ? { unmerged_deltas: deltas } : {}, orphans === null ? {} : { orphan_procs: orphans }, { live: liveJ }), null, 2) };
+    return { code: 0, out: JSON.stringify(Object.assign({}, state, hasDeltas ? { unmerged_deltas: deltas } : {}, orphans === null ? {} : { orphan_procs: orphans }, { live: liveJ }, batchPending.length ? { batch_pending: batchPending } : {}), null, 2) };
   }
+  const batchLines = batchPending.map((p) => `CẢNH BÁO: ${p.root_task_id}: ${p.steps.length} bước self+batch (${p.steps.join(', ')}) chưa có verdict verifier gộp (batch-verify) — giao verifier gộp (brief H) trước cổng 3`);
   const stuckLines = stuck.length
     ? [`stuck: ${stuck.slice(0, 6).map((a) => `${a.task_id || a.agent_id}:${a.role} ${a.state === 'orphan' ? 'mồ côi' : 'kẹt'} ${a.idle_min}'`).join(', ')} → TaskStop rồi \`dieu-phoi reap --yes\``]
     : [];
-  return { code: 0, out: [core.formatSessionState(state, core.STATE_TEXT_CAP)].concat(deltaLines, orphans === null ? [] : [`orphan_procs: ${orphans}`], [liveLine(live)], stuckLines).join('\n') };
+  return { code: 0, out: [core.formatSessionState(state, core.STATE_TEXT_CAP)].concat(deltaLines, orphans === null ? [] : [`orphan_procs: ${orphans}`], [liveLine(live)], stuckLines, batchLines).join('\n') };
 }
 
 // ------------------------------------------------------------------ reap (core 0.7.3 s6)
@@ -1390,11 +1418,24 @@ function cmdRetro(opts) {
 
 // ------------------------------------------------------------------ choose
 
+/**
+ * A user-supplied mode value: fast | normal; the removed `strict` (0.7.4) is accepted with a warning and becomes
+ * normal; anything else null.
+ */
+function userMode(raw) {
+  if (raw === core.LEGACY_MODE) {
+    process.stderr.write('dieu-phoi: mode strict đã bỏ từ 0.7.4 — dùng normal (sàn an toàn vẫn luôn có verifier độc lập chặn).\n');
+    return core.DEFAULT_MODE;
+  }
+  return core.isMode(raw) ? raw : null;
+}
+
 /** --mode value (validated) or undefined; a bare --mode is an error. */
 function modeOpt(opts) {
   if (opts.mode === undefined) return undefined;
-  if (typeof opts.mode !== 'string' || !core.isMode(opts.mode)) throw new Error(`--mode phải là ${core.MODES.join('|')}`);
-  return opts.mode;
+  const m = typeof opts.mode === 'string' ? userMode(opts.mode) : null;
+  if (!m) throw new Error(`--mode phải là ${core.MODES.join('|')}`);
+  return m;
 }
 
 function chooseInput(opts, ctx, events) {
@@ -1432,15 +1473,39 @@ function overrideEvent(ctx, taskId, taskType, suggested, chosen) {
 }
 
 /**
- * core 0.7.0 (s2): mode_suggest for choose (exec only). The root's CURRENT mode decides (a dispatched step keeps its
- * fast mode, but once the user moved the root back there is nothing to suggest). Never changes the mode.
+ * core 0.7.4 (B1): the step of the approved plan (<plans>/<root>.json) whose task_id is taskId, or null. Its rubric
+ * (score, verifiable, reversible, publish, dependents) is what `choose --task` takes the stricter of.
+ */
+function approvedPlanStep(ctx, taskId) {
+  let files = [];
+  try { files = fs.readdirSync(ctx.paths.plans).filter((f) => f.endsWith('.json')); } catch (_) { return null; }
+  for (const f of files) {
+    const rec = core.readJsonFile(path.join(ctx.paths.plans, f), null);
+    if (!rec || !Array.isArray(rec.steps)) continue;
+    const step = rec.steps.find((s) => s && s.task_id === taskId);
+    if (!step) continue;
+    const dependents = step.dependents === true
+      || rec.steps.some((o) => o && o !== step && Array.isArray(o.depends_on) && o.depends_on.includes(step.id));
+    return Object.assign({}, step, { root: rec.root_task_id || f.replace(/\.json$/, ''), dependents });
+  }
+  return null;
+}
+
+/**
+ * core 0.7.4 (B1): the stricter of the CLI flags and the approved step, field by field — publish, dependents, not
+ * reversible, not verifiable, higher score. Mutates `input`; returns the names it raised (empty = flags already as strict).
+ * Omitting a flag can therefore never loosen a step the plan made blocking.
  */
-function chooseModeSuggest(ctx, input, res, mi) {
-  const root = mi && mi.root ? mi.root : null;
-  const rootEv = root ? core.rootModeFromEvents(input.events, root) : null;
-  const mode = rootEv ? rootEv.mode : res.mode;
-  const sug = core.modeSuggestion(input.events, root, { mode, taskIds: core.rootTaskIds(core.loadPlans(ctx.paths.plans), root) });
-  return { mode_suggest: sug.mode_suggest, mode_suggest_reason: sug.mode_suggest_reason, mode_suggest_root: sug.mode_suggest ? root : null };
+function applyApprovedStep(input, step) {
+  const raised = [];
+  if (step.publish === true && input.publish !== true) { raised.push('publish'); input.publish = true; }
+  if (step.dependents === true && input.dependents !== true) { raised.push('dependents'); input.dependents = true; }
+  if (step.reversible === false && input.reversible !== false) { raised.push('reversible'); input.reversible = false; }
+  if (step.verifiable === false && input.verifiable !== false) { raised.push('verifiable'); input.verifiable = false; }
+  const planScore = Number(step.score);
+  const flagScore = Number(input.score);
+  if (Number.isFinite(planScore) && Number.isFinite(flagScore) && planScore > flagScore) { raised.push('score'); input.score = planScore; }
+  return raised;
 }
 
 function cmdChoose(opts) {
@@ -1450,6 +1515,8 @@ function cmdChoose(opts) {
   }
   if (opts.task !== undefined) requireTaskId(typeof opts.task === 'string' ? opts.task : '');
   const input = chooseInput(opts, ctx, core.readEvents(ctx));
+  const planStep = input.taskId ? approvedPlanStep(ctx, input.taskId) : null;
+  const raised = planStep ? applyApprovedStep(input, planStep) : [];
   let modeSource = 'flag';
   const mi = input.taskId ? core.taskModeInfo(ctx, input.taskId, input.events) : null;
   if (input.mode === undefined) {
@@ -1463,7 +1530,12 @@ function cmdChoose(opts) {
   }
   const res = chooser.choose(input);
   res.mode_source = modeSource;
-  if (res.verify_plan) Object.assign(res, chooseModeSuggest(ctx, input, res, mi));
+  if (planStep) {
+    res.plan_step = { root_task_id: planStep.root, step: planStep.id, verify_plan: planStep.verify_plan || null, raised };
+    if (planStep.verify_plan && res.verify_plan && planStep.verify_plan !== res.verify_plan) {
+      res.plan_deviation = `${planStep.verify_plan} → ${res.verify_plan}`;
+    }
+  }
   const orch = measureOrch(opts, ctx, input.profile);
   res.orch_ctx_tokens = orch.ctx_tokens;
   res.orch_ctx_growth = orch.ctx_growth;
@@ -1485,8 +1557,10 @@ function cmdChoose(opts) {
   }
   if (opts.json) return { code: 0, out: JSON.stringify(res) };
   const typeWarn = res.type_warning && !String(res.reason).includes(res.type_warning) ? `\nCẢNH BÁO: ${res.type_warning}` : '';
-  const sugLine = res.mode_suggest ? `\n${core.modeSuggestLine(res.mode_suggest_root, 'fast', res.mode_suggest_reason)}` : '';
-  const warn = `${typeWarn}${res.orch_ctx_warn ? `\nCẢNH BÁO: ${orch.advice}` : ''}${sugLine}`;
+  const planWarn = res.plan_step && res.plan_step.raised.length
+    ? `\nKế hoạch đã duyệt (${res.plan_step.root_task_id} bước ${res.plan_step.step}): nâng theo ${res.plan_step.raised.join(', ')}` : '';
+  const deviationWarn = res.plan_deviation ? `\nLỆCH kiểm khỏi kế hoạch đã duyệt: ${res.plan_deviation}` : '';
+  const warn = `${typeWarn}${planWarn}${deviationWarn}${res.orch_ctx_warn ? `\nCẢNH BÁO: ${orch.advice}` : ''}`;
   const est =`~${fmtUsd(res.est_cost_usd)} · ~${fmtNum(res.est_time_min)} phút (${res.est_source === 'data' ? 'dữ liệu' : 'ước lượng thô'})`;
   if (res.action === 'ask_user') {
     return { code: 0, out: `HỎI NGƯỜI DÙNG — ${res.reason}${warn}` };
@@ -1541,7 +1615,7 @@ function buildPlanTable(rawSteps, base) {
       verifiable: s.verifiable === undefined ? true : yesNo(s.verifiable, true),
       reversible: s.reversible === undefined ? true : yesNo(s.reversible, true),
       publish: s.publish === undefined ? false : yesNo(s.publish, false),
-      mode: s.mode === undefined || s.mode === null ? null : s.mode,
+      mode: s.mode === undefined || s.mode === null ? null : (userMode(s.mode) || s.mode),
       urgency: s.urgency,
       deps: deps.map(String),
     };
@@ -1570,6 +1644,8 @@ function buildPlanTable(rawSteps, base) {
     const head = {
       step: s.step, title: s.title, type: s.type, task_id: s.task || null, score: Number(s.score),
       verifiable: s.verifiable, reversible: s.reversible, depends_on: s.deps,
+      publish: s.publish === true || base.publish === true,
+      dependents: steps.some((o) => o !== s && o.deps.includes(s.step)),
       mode: s.mode || base.mode || core.DEFAULT_MODE, mode_override: s.mode || null,
     };
     try {
@@ -1635,6 +1711,78 @@ function planTaskIdProblems(plan, root) {
   return problems;
 }
 
+// core 0.7.4 (s1): TÁCH? — a step that is likely to hand off (score ≥ 6; its task_type × tier has handoff rate ≥ 20%
+// over ≥ 10 tasks) is flagged in the table so the planner splits it. Advice only: never blocks --approve.
+const SPLIT_MIN_SCORE = 6;
+const SPLIT_MIN_RATE = 0.2;
+const SPLIT_MIN_N = 10;
+
+/** Model family of a tier or a recorded model id (opus | sonnet | haiku | fable), as choose.cjs matches cells. */
+function modelFamily(m) {
+  const s = String(m || '').toLowerCase();
+  return ['opus', 'sonnet', 'haiku', 'fable'].find((k) => s.includes(k)) || null;
+}
+
+function planSplitWarnings(steps, events) {
+  const samples = agg.handoffSamples(events);
+  const out = [];
+  for (const r of steps) {
+    if (r.action === 'refused' || !r.tier || !(Number(r.score) >= SPLIT_MIN_SCORE)) continue;
+    const type = r.task_type || r.type;
+    const [model, effort] = String(r.tier).split('/');
+    const same = samples.filter((s) => s.task_type === type && modelFamily(s.model) === modelFamily(model) && s.effort === effort);
+    if (same.length < SPLIT_MIN_N) continue;
+    const hand = same.filter((s) => s.handoff);
+    const rate = hand.length / same.length;
+    if (rate < SPLIT_MIN_RATE) continue;
+    const clean = same.filter((s) => !s.handoff);
+    out.push({
+      step: r.step,
+      task_type: type,
+      tier: r.tier,
+      n: same.length,
+      handoff_rate: Math.round(rate * 1000) / 1000,
+      cost_handoff_p50_usd: agg.percentile(hand.map((s) => s.total_cost), 0.5),
+      cost_clean_p50_usd: agg.percentile(clean.map((s) => s.total_cost), 0.5),
+    });
+  }
+  return out;
+}
+
+// core 0.7.4 (s2): TIER↑ — a mechanical type whose override sits above the tier choose would pick is flagged
+// (advice only; --approve is not blocked). The $p50 column and the warning read the same stats cells as `stats`.
+const TIER_UP_TYPES = ['mechanical-edit', 'extract', 'search', 'test-write'];
+
+/** The stats cell (buildCells row) of one task_type × tier, or null. */
+function statCellOf(cells, type, tier) {
+  const [model, effort] = String(tier).split('/');
+  return cells.find((c) => c.task_type === type && modelFamily(c.model) === modelFamily(model) && c.effort === effort) || null;
+}
+
+function planTierWarnings(steps, cells) {
+  const out = [];
+  for (const r of steps) {
+    if (r.action === 'refused' || !r.overridden || !r.suggested_tier || !r.tier) continue;
+    if (!TIER_UP_TYPES.includes(r.task_type)) continue;
+    const hi = chooser.parseTier(r.tier);
+    const lo = chooser.parseTier(r.suggested_tier);
+    if (hi === null || lo === null || hi <= lo) continue;
+    const a = statCellOf(cells, r.task_type, r.tier);
+    const b = statCellOf(cells, r.task_type, r.suggested_tier);
+    out.push({
+      step: r.step,
+      task_type: r.task_type,
+      tier: r.tier,
+      suggested_tier: r.suggested_tier,
+      cost_p50_usd: a && a.n ? a.cost_p50_usd : null,
+      suggested_cost_p50_usd: b && b.n ? b.cost_p50_usd : null,
+      accept_rate: a && a.n ? a.accept_rate : null,
+      suggested_accept_rate: b && b.n ? b.accept_rate : null,
+    });
+  }
+  return out;
+}
+
 /** Mapped ad-hoc labels (bug-fix → debug, …): not an error, but the tag must carry the mapped type. */
 function planTypeNotes(plan) {
   return plan.steps.filter((r) => r.mapped_from).map((r) => `bước ${r.step}: ${r.type_warning}`);
@@ -1692,6 +1840,10 @@ function recordApprovedPlan(ctx, root, stepsFile, plan) {
     steps: plan.steps.map((r) => Object.assign({
       id: r.step, task_id: r.task_id || null, title: r.title === undefined ? null : r.title, type: r.task_type || r.type || null,
       tier: r.action === 'refused' ? null : (r.tier || null), depends_on: r.depends_on,
+      // core 0.7.4 (B1): the rubric `choose --task` takes the stricter of its flags against
+      score: Number.isFinite(Number(r.score)) ? Number(r.score) : null, verifiable: r.verifiable !== false,
+      reversible: r.reversible !== false, publish: r.publish === true, dependents: r.dependents === true,
+      verify_plan: r.verify_plan || null,
     }, r.mode_override ? { mode: r.mode_override } : {})),
     history,
   };
@@ -1733,8 +1885,8 @@ function cmdPlanTable(opts) {
   let fileMode;
   if (raw && !Array.isArray(raw) && typeof raw === 'object' && Array.isArray(raw.steps)) {
     if (raw.mode !== undefined && raw.mode !== null) {
-      if (!core.isMode(raw.mode)) throw new Error(`plan-table: "mode" trong file phải là ${core.MODES.join('|')} (nhận "${raw.mode}")`);
-      fileMode = raw.mode;
+      fileMode = userMode(raw.mode);
+      if (!fileMode) throw new Error(`plan-table: "mode" trong file phải là ${core.MODES.join('|')} (nhận "${raw.mode}")`);
     }
     raw = raw.steps;
   }
@@ -1751,6 +1903,9 @@ function cmdPlanTable(opts) {
   if (problems.length) process.stderr.write(`dieu-phoi plan-table: cảnh báo — ${problems.join('; ')} (cần sửa trước khi --approve)\n`);
   const typeNotes = planTypeNotes(plan);
   if (typeNotes.length) process.stderr.write(`dieu-phoi plan-table: cảnh báo — ${typeNotes.join('; ')}\n`);
+  const splitWarn = planSplitWarnings(plan.steps, base.events);
+  const statCells = agg.analyze(base.events, {}).cells;
+  const tierWarn = planTierWarnings(plan.steps, statCells);
   const rec = opts.approve ? recordApprovedPlan(ctx, String(opts.root), path.resolve(opts.file), plan) : null;
   let modeLogged = false;
   if (rec && (rootEv ? rootEv.mode !== plan.mode : plan.mode !== core.DEFAULT_MODE)) {
@@ -1761,29 +1916,31 @@ function cmdPlanTable(opts) {
   for (const ev of ovs) core.appendEvent(ctx, ev);
   if (rec) recordPlanSuggestions(ctx, plan);
   if (opts.json) {
-    const out = rec ? Object.assign({}, plan, {
+    const steps = plan.steps.map((r) => {
+      const c = r.action === 'refused' || !r.tier ? null : statCellOf(statCells, r.task_type || r.type, r.tier);
+      return Object.assign({}, r, { stats_cost_p50_usd: c && c.n ? c.cost_p50_usd : null, stats_n: c ? c.n : 0 });
+    });
+    const out = Object.assign({}, plan, { steps, split_warn: splitWarn, tier_warn: tierWarn }, rec ? {
       approved: { root_task_id: rec.root_task_id, approval: rec.approval, record: rec.file, overrides_logged: ovs.length, mode_logged: modeLogged },
-    }) : plan;
+    } : {});
     return { code: 0, out: JSON.stringify(out, null, 2) };
   }
-  const lines = ['| Bước | Model/effort | Rubric (điểm · kiểm chứng · đảo ngược) | Lý do | Ước tính | Kiểm |', '|---|---|---|---|---|---|'];
+  const lines = ['| Bước | Model/effort | Rubric (điểm · kiểm chứng · đảo ngược) | Lý do | Ước tính | $p50 | Kiểm |', '|---|---|---|---|---|---|---|'];
   for (const r of plan.steps) {
     const tierCell = r.action === 'refused' ? '—' : (r.action === 'ask_user' ? `${r.tier} (hỏi người dùng)` : r.tier);
     const yn = (v) => (v ? 'y' : 'n');
     const rubric = `${Number.isFinite(r.score) ? r.score : '?'} · ${yn(r.verifiable)} · ${yn(r.reversible)}`;
     const why = `${r.type}${r.depends_on.length ? `, sau ${r.depends_on.join(', ')}` : ''} — ${r.reason.replace(/; profile: .*$/, '')}`;
     const est = r.action === 'refused' ? '-' : `~${fmtUsd(r.est_cost_usd)} · ~${fmtNum(r.est_time_min)} phút${r.est_source === 'rough' ? ' (thô)' : ''}`;
+    const sc = r.action === 'refused' || !r.tier ? null : statCellOf(statCells, r.task_type || r.type, r.tier);
+    const p50 = r.action === 'refused' ? '—' : (sc && sc.n ? `${fmtUsd(sc.cost_p50_usd)} (n ${sc.n})` : '-');
     const kiem = r.action === 'refused' || !r.verify_plan ? '—' : `${r.verify_plan}${r.mode_override ? ` (mode ${r.mode_override})` : ''}`;
-    lines.push(`| ${mdCell(r.title ? `${r.step}. ${r.title}` : r.step)} | ${mdCell(tierCell)} | ${mdCell(rubric)} | ${mdCell(why)} | ${mdCell(est)} | ${mdCell(kiem)} |`);
+    lines.push(`| ${mdCell(r.title ? `${r.step}. ${r.title}` : r.step)} | ${mdCell(tierCell)} | ${mdCell(rubric)} | ${mdCell(why)} | ${mdCell(est)} | ${mdCell(p50)} | ${mdCell(kiem)} |`);
   }
   lines.push('');
   lines.push(`**Tổng chi phí ước tính:** ~${fmtUsd(plan.total_cost_usd)} · **Thời gian (đường găng, chạy song song khi không phụ thuộc):** ~${fmtNum(plan.critical_path_min)} phút (cộng dồn ${fmtNum(plan.sum_time_min)} phút)`);
-  // Mode được hỏi ở cổng 1 chỉ khi root chưa có mode và kế hoạch có ≥4 bước s≤6 (0.7.2); còn lại không hỏi
-  const shortSteps = plan.steps.filter((r) => r.action !== 'refused' && Number.isFinite(r.score) && r.score <= 6).length;
-  const modeText = modeChosen ? plan.mode : (shortSteps >= 4
-    ? `HỎI người dùng chọn mode (${shortSteps} bước s≤6): fast | normal | strict (mặc định normal); đặt bằng \`dieu-phoi mode --root ${typeof opts.root === 'string' ? opts.root : '<root_task_id>'} <mode>\``
-    : 'normal (không hỏi)');
-  lines.push(`**Mode:** ${modeText}${plan.self_batch_steps ? ` · Kiểm (fast): bỏ ${plan.self_batch_steps} verifier riêng, 1 verify gộp (cả suite một lần) trước khi trình người dùng` : ''}`);
+  const modeText = modeChosen ? plan.mode : 'normal (mặc định)';
+  lines.push(`**Mode:** ${modeText}${plan.self_batch_steps ? ` · Kiểm (self+batch): bỏ ${plan.self_batch_steps} verifier riêng, 1 verify gộp (test chọn lọc các file cả nhóm; full suite ở cổng phát hành) trước khi trình người dùng` : ''}`);
   if (plan.rough) lines.push('', '_(thô) = ô chưa đủ 5 task, ước lượng theo giả định token của từng tier._');
   if (plan.refused.length) {
     lines.push('', `**Cảnh báo:** ${plan.refused.length} bước bị từ chối (${plan.refused.map((x) => x.step).join(', ')}), không tính vào tổng — sửa rồi chạy lại.`);
@@ -1791,6 +1948,13 @@ function cmdPlanTable(opts) {
 `);
   }
   if (typeNotes.length) lines.push('', `**Loại task:** ${typeNotes.join('; ')}`);
+  for (const w of splitWarn) {
+    lines.push('', `TÁCH?: ${w.step} — ${w.task_type} ${w.tier} handoff ${Math.round(w.handoff_rate * 100)}% (${w.n}), median ${fmtUsd(w.cost_handoff_p50_usd)} có handoff / ${fmtUsd(w.cost_clean_p50_usd)} không → cân nhắc tách thành ≥2 bước nhỏ hơn`);
+  }
+  const fmtPct = (v) => (v === null || v === undefined ? '-' : `${Math.round(v * 100)}%`);
+  for (const w of tierWarn) {
+    lines.push('', `TIER↑: ${w.step} ${w.tier} vs đề xuất ${w.suggested_tier} ($p50 ${fmtUsd(w.cost_p50_usd)} vs ${fmtUsd(w.suggested_cost_p50_usd)}, accept ${fmtPct(w.accept_rate)} vs ${fmtPct(w.suggested_accept_rate)}) — tier cao hơn choose đề xuất, kiểm lý do trước khi duyệt`);
+  }
   if (rec) lines.push('', `Đã ghi kế hoạch đã duyệt (root ${rec.root_task_id}, lần duyệt ${rec.approval})${ovs.length ? `; ghi ${ovs.length} override` : ''}${modeLogged ? `; ghi mode ${plan.mode}` : ''}`);
   return { code: 0, out: lines.join('\n') };
 }