@kienntpixon/dieu-phoi 0.6.1 → 0.7.1

package/lib/aggregate.cjs

@@ -56,13 +56,14 @@ function round6(v) {
 
 /**
  * Normalize a verdict to the two-layer model. Legacy `rework` (no `by`) = user reject/quality;
- * missing `by` otherwise = agent layer.
+ * missing `by` otherwise = agent layer. Core 0.7.0: `by=auto` (fast-mode self-acceptance) is its own layer —
+ * never a user verdict, never an agent verdict (CONTRACT "Mode theo yêu cầu").
  */
 function normalizeVerdict(ev) {
   if (ev.outcome === 'rework' && !ev.by) {
     return { by: 'user', outcome: 'reject', cause: 'quality', round: Number(ev.round) || null };
   }
-  const by = ev.by === 'user' ? 'user' : 'agent';
+  const by = ev.by === 'user' ? 'user' : (ev.by === 'auto' ? 'auto' : 'agent');
   let cause = ev.cause || null;
   if (by === 'user' && ev.outcome === 'reject' && cause !== 'scope') cause = 'quality';
   let outcome = ev.outcome;
@@ -111,12 +112,18 @@ function steerIdOf(ev) {
   return typeof ev.steer_id === 'string' && ev.steer_id ? ev.steer_id : `${ev.agent_id}|${ev.ts}`;
 }
 
+/** core 0.7.0: an exec's own selective-test verdict (`verify=self`) is not evidence for the agent layer. */
+function isSelf(v) {
+  return !!v && v.verify === 'self';
+}
+
 /**
- * Join events. Returns agents (one per real agent), userVerdicts (task layer), overrides, steers.
+ * Join events. Returns agents (one per real agent), userVerdicts (task layer), autoVerdicts (by=auto), overrides, steers.
  */
 function buildAgents(events) {
   const map = new Map();
   const userVerdicts = [];
+  const autoVerdicts = [];
   const overrides = [];
   const steers = [];
   const get = (id) => {
@@ -132,6 +139,7 @@ function buildAgents(events) {
     if (ev.kind === 'verdict') {
       const v = Object.assign(e, normalizeVerdict(ev));
       if (v.by === 'user') { userVerdicts.push(v); return; }
+      if (v.by === 'auto') { autoVerdicts.push(v); return; }
     }
     if (ev.kind === 'steer') steers.push(e);
     if (typeof ev.agent_id !== 'string' || !ev.agent_id) return;
@@ -149,6 +157,8 @@ function buildAgents(events) {
     const vAll = a.verdicts.slice().sort((x, y) => tsOf(x) - tsOf(y) || x._idx - y._idx);
     // `aborted` (quota pause) is neither pass nor fail: it never sets the outcome nor counts as a result.
     const v = vAll.filter((x) => x.outcome !== ABORTED);
+    const checked = v.filter((x) => !isSelf(x));
+    const selfs = v.filter(isSelf);
     const verdict = v.length ? v[v.length - 1] : null;
     const firstVerdictTs = v.length ? tsOf(v[0]) : Infinity;
     const pick = (k) => (d[k] !== undefined && d[k] !== null ? d[k] : (c0[k] !== undefined && c0[k] !== null ? c0[k] : null));
@@ -163,6 +173,8 @@ function buildAgents(events) {
       task_id: pick('task_id') || (verdict && verdict.task_id) || (a.steers[0] && a.steers[0].task_id) || null,
       try: Number(pick('try')) || 1,
       role: pick('role') || 'exec',
+      // core 0.7.1 (C5): the one batched verifier of a fast request (tag `|batch`, dispatch `batch:true`)
+      batch: pick('batch') === true,
       score: d.score !== undefined ? d.score : null,
       urgency: d.urgency || null,
       model: core.normalizeModel(cl.model) || core.normalizeModel(d.model) || null,
@@ -173,7 +185,10 @@ function buildAgents(events) {
       duration_s: a.completes.length ? sumOrNull(a.completes.map((x) => x.duration_s)) : null,
       tool_uses: a.completes.length ? sumOrNull(a.completes.map((x) => x.tool_uses)) : null,
       outcome: verdict ? verdict.outcome : null,
-      first_outcome: v.length ? v[0].outcome : null,
+      // agent layer = first verdict that is not the exec's own selective tests (verify=self, core 0.7.0)
+      first_outcome: checked.length ? checked[0].outcome : null,
+      self_first: selfs.length ? selfs[0].outcome : null,
+      self_verdicts: selfs.length,
       // every non-aborted agent verdict in time order: a retry by SendMessage to the same agent is a new result
       verdict_seq: v.map((x) => ({ outcome: x.outcome, ts: tsOf(x), idx: x._idx })),
       aborted: vAll.length > 0 && vAll[vAll.length - 1].outcome === ABORTED,
@@ -187,24 +202,28 @@ function buildAgents(events) {
       last_complete_ts: a.completes.length ? Math.max(...a.completes.map(tsOf)) : 0,
     });
   }
-  return { agents, userVerdicts, overrides, steers };
+  return { agents, userVerdicts, autoVerdicts, overrides, steers };
 }
 
 /** Group agents into tasks (sample unit = task_id; agents without task_id are their own task). */
-function buildTasks(agents, userVerdicts) {
+function buildTasks(agents, userVerdicts, autoVerdicts) {
   const map = new Map();
   const byAgent = new Map();
   for (const a of agents) {
     const key = a.task_id ? `task:${a.task_id}` : `agent:${a.agent_id}`;
-    if (!map.has(key)) map.set(key, { key, task_id: a.task_id, agents: [], user: [] });
+    if (!map.has(key)) map.set(key, { key, task_id: a.task_id, agents: [], user: [], auto: [] });
     map.get(key).agents.push(a);
     byAgent.set(a.agent_id, key);
   }
+  for (const v of autoVerdicts || []) {
+    const t = v.task_id ? map.get(`task:${v.task_id}`) : null;
+    if (t) t.auto.push(v);
+  }
   for (const v of userVerdicts || []) {
     let key = v.task_id ? `task:${v.task_id}` : null;
     if (!key && v.agent_id) key = byAgent.get(v.agent_id) || null; // legacy rework without task_id
     if (!key) continue;
-    if (!map.has(key)) map.set(key, { key, task_id: v.task_id, agents: [], user: [] });
+    if (!map.has(key)) map.set(key, { key, task_id: v.task_id, agents: [], user: [], auto: [] });
     map.get(key).user.push(v);
   }
   const tasks = [];
@@ -261,9 +280,15 @@ function buildTasks(agents, userVerdicts) {
     if (userOutcome === 'accept') { success = true; source = 'user'; } else if (userOutcome === 'reject_quality') { success = false; source = 'user'; } else if (!userOutcome && agentFirst !== null) {
       success = agentFirst; source = 'agent';
     }
+    // core 0.7.0: by=auto never decides success; a user reject after the first auto accept overturns it.
+    const autoTs = t.auto.filter((v) => v.outcome === 'accept').map(tsOf);
+    const autoAccept = autoTs.length > 0;
+    const autoOverturned = autoAccept && user.some((v) => v.outcome === 'reject' && tsOf(v) > Math.min(...autoTs));
     const lastUser = user[user.length - 1] || null;
     const accepted = lastUser ? lastUser.outcome === 'accept' : attempts.some((a) => a.outcome === 'pass');
-    const costed = t.agents.filter((a) => a.completed || a.outcome);
+    // core 0.7.1 (C5): the batched verifier checks every fast step of a request; it is billed to its own cell
+    // (batchVerifyCells), never to the task_type x tier of the fast step whose task_id it carries.
+    const costed = t.agents.filter((a) => (a.completed || a.outcome) && !isBatchVerify(a));
     tasks.push({
       key: t.key,
       task_id: t.task_id,
@@ -283,6 +308,9 @@ function buildTasks(agents, userVerdicts) {
       excluded: !!(first && first.steered) || userOutcome === 'reject_scope',
       accepted,
       agent_first_pass: agentFirst,
+      self_first: firstRes ? firstRes.self_first : null,
+      auto_accept: autoAccept,
+      auto_overturned: autoOverturned,
       // agents with a verdict but no complete event (hook missed) make cost/time unknown (null)
       total_cost: sumOrNull(costed.map((a) => a.cost_usd)),
       total_time_s: sumOrNull(costed.map((a) => a.duration_s)),
@@ -291,6 +319,43 @@ function buildTasks(agents, userVerdicts) {
   return tasks;
 }
 
+/** core 0.7.1 (C5): a role=verify agent dispatched with `batch:true`. */
+function isBatchVerify(a) {
+  return !!a && a.role === 'verify' && a.batch === true;
+}
+
+/**
+ * core 0.7.1 (C5), CLI only: batched verifiers grouped by their own model x effort. Agents with a complete or a
+ * verdict; cost/time per agent = sum over its complete segments (null when unknown, left out of the percentiles).
+ */
+function batchVerifyCells(agents) {
+  const groups = new Map();
+  for (const a of agents || []) {
+    if (!isBatchVerify(a) || !(a.completed || a.outcome)) continue;
+    const key = `${a.model || '?'}|${a.effort || '?'}`;
+    if (!groups.has(key)) groups.set(key, { model: a.model, effort: a.effort, agents: [] });
+    groups.get(key).agents.push(a);
+  }
+  const out = [];
+  for (const g of groups.values()) {
+    const costs = g.agents.map((a) => a.cost_usd);
+    const times = g.agents.map((a) => (a.duration_s === null ? null : a.duration_s / 60));
+    out.push({
+      model: g.model,
+      effort: g.effort,
+      n: g.agents.length,
+      tasks: [...new Set(g.agents.map((a) => a.task_id).filter(Boolean))].length,
+      cost_total_usd: round6(costs.reduce((s, c) => s + (typeof c === 'number' && isFinite(c) ? c : 0), 0)),
+      cost_mean_usd: round6(mean(costs)),
+      cost_p50_usd: round6(percentile(costs, 0.5)),
+      time_mean_min: round6(mean(times)),
+      time_p50_min: round6(percentile(times, 0.5)),
+    });
+  }
+  out.sort((a, b) => String(a.model).localeCompare(String(b.model)) || String(a.effort).localeCompare(String(b.effort)));
+  return out;
+}
+
 function cellKey(type, model, effort) {
   return `${type}|${model || '?'}|${effort || '?'}`;
 }
@@ -309,11 +374,17 @@ function buildCells(tasks, opts) {
     if (!f) continue;
     const key = cellKey(t.task_type, f.model, f.effort);
     if (!cells.has(key)) {
-      cells.set(key, { task_type: t.task_type, model: f.model, effort: f.effort, dispatched: 0, excluded: 0, tasks: [], agentTasks: [] });
+      cells.set(key, {
+        task_type: t.task_type, model: f.model, effort: f.effort, dispatched: 0, excluded: 0, tasks: [], agentTasks: [], selfTasks: [], verdicted: 0, auto: 0, overturned: 0,
+      });
     }
     const c = cells.get(key);
     c.dispatched++;
+    if (t.auto_accept) c.auto++;
+    if (t.auto_overturned) c.overturned++;
     if (t.excluded) { c.excluded++; continue; }
+    if (t.self_first) c.selfTasks.push(t);
+    if (t.self_first || t.agent_first_pass !== null) c.verdicted++;
     if (t.success !== null) c.tasks.push(t);
     if (t.agent_first_pass !== null) c.agentTasks.push(t);
   }
@@ -331,6 +402,9 @@ function buildCells(tasks, opts) {
     // score uses the time median, not the mean: waits for the user (gate 3, quota pauses) inflate the mean
     // 3-13x (retro 2026-10-18: art-gen sonnet mean 483 vs p50 37 min) and would flip priors to slower tiers.
     const timeP50 = percentile(timesMin, 0.5);
+    const notes = [];
+    if (n < MIN_N) notes.push('chưa đủ dữ liệu');
+    if (c.verdicted && c.selfTasks.length / c.verdicted > 0.5) notes.push('ít bằng chứng');
     out.push({
       task_type: c.task_type,
       model: c.model,
@@ -358,8 +432,12 @@ function buildCells(tasks, opts) {
       attempt_p50_min: percentile(attemptTimes, 0.5),
       attempt_p75_min: percentile(attemptTimes, 0.75),
       score: costMean === null && timeP50 === null ? null : round6((costMean || 0) + lambda * (timeP50 || 0)),
+      n_self: c.selfTasks.length,
+      self_pass: c.selfTasks.filter((t) => t.self_first === 'pass').length,
+      auto_accept: c.auto,
+      auto_overturned: c.overturned,
       enough: n >= MIN_N,
-      note: n >= MIN_N ? '' : 'chưa đủ dữ liệu',
+      note: notes.join('; '),
     });
   }
   out.sort((a, b) => a.task_type.localeCompare(b.task_type)
@@ -485,16 +563,103 @@ function orchestrationSummary(events) {
 }
 
 function analyze(events, opts) {
-  const { agents, userVerdicts, overrides, steers } = buildAgents(withoutDiscarded(events));
-  const tasks = buildTasks(agents, userVerdicts);
+  const { agents, userVerdicts, autoVerdicts, overrides, steers } = buildAgents(withoutDiscarded(events));
+  const tasks = buildTasks(agents, userVerdicts, autoVerdicts);
   const cells = buildCells(tasks, opts);
   return {
-    agents, tasks, cells, overrides, userVerdicts, steerEvents: steers, steers: buildSteers(tasks, steers, agents),
+    agents, tasks, cells, overrides, userVerdicts, autoVerdicts, steerEvents: steers, steers: buildSteers(tasks, steers, agents),
     orchestration: orchestrationSummary(events),
+    batch_verify: batchVerifyCells(agents),
   };
 }
 
 module.exports = {
-  MIN_N, FAIL_OUTCOMES, HEAVY_STEERS, ABORTED, QUOTA_REASON_RE, HANDOFF_REASON_RE, discardedTaskIds, withoutDiscarded, CANONICAL_CELL_FIELDS, normalizeVerdict, isInternalComplete, buildAgents, buildTasks,
-  buildCells, buildSteers, canonicalCells, orchestrationSummary, analyze, cellKey, mean, percentile, tsOf, steerIdOf,
+  MIN_N, FAIL_OUTCOMES, HEAVY_STEERS, ABORTED, QUOTA_REASON_RE, HANDOFF_REASON_RE, discardedTaskIds, withoutDiscarded, CANONICAL_CELL_FIELDS, normalizeVerdict, isSelf, isInternalComplete, buildAgents, buildTasks,
+  buildCells, buildSteers, canonicalCells, isBatchVerify, batchVerifyCells, orchestrationSummary, analyze, cellKey, mean, percentile, tsOf, steerIdOf,
 };
+
+// ------------------------------------------------------------------ core 0.7.0 (s2): stats split by mode
+//
+// Kept apart from the canonical cells (not part of the CLI <-> sink parity yet). A task's mode = `mode` of its first
+// exec dispatch; tasks dispatched before modes existed (no `mode`) count as normal.
+
+const MODE_KEYS = ['fast', 'normal', 'strict'];
+const NO_CATCH_VERIFY = new Set(['self', 'none']);
+
+/**
+ * Per mode: tasks, verified_tasks (a verify agent ran), catch_rate (share of exec agent verdicts checked by something
+ * other than self/none that came back fail), self_verdicts, batch_verify_fails, user_verdict_tasks, rejects (quality),
+ * reject_rate, verify_min (minutes of verify agents), test_s (sum of complete.test_s over the task's agents),
+ * test_s_per_task, full_suite_runs. `events` = the same events given to analyze(); `tasks` = analyze().tasks.
+ */
+function modeSummary(events, tasks) {
+  const evs = withoutDiscarded(events).filter(Boolean);
+  const dispatchMode = new Map();
+  const tests = new Map();
+  const verdicts = new Map();
+  for (const ev of evs) {
+    if (ev.kind === 'dispatch' && typeof ev.agent_id === 'string' && !dispatchMode.has(ev.agent_id)) dispatchMode.set(ev.agent_id, ev.mode);
+    if (ev.kind === 'complete' && typeof ev.agent_id === 'string') {
+      const t = tests.get(ev.agent_id) || { s: 0, timed: 0, full: 0 };
+      const s = finiteNum(ev.test_s);
+      if (s !== null) { t.s += s; t.timed++; }
+      t.full += finiteNum(ev.full_suite_runs) || 0;
+      tests.set(ev.agent_id, t);
+    }
+    if (ev.kind === 'verdict' && ev.by !== 'user' && typeof ev.agent_id === 'string') {
+      if (!verdicts.has(ev.agent_id)) verdicts.set(ev.agent_id, []);
+      verdicts.get(ev.agent_id).push(ev);
+    }
+  }
+  const out = {};
+  for (const m of MODE_KEYS) {
+    out[m] = {
+      tasks: 0, verified_tasks: 0, checked_verdicts: 0, caught: 0, catch_rate: null, self_verdicts: 0, batch_verify_fails: 0,
+      user_verdict_tasks: 0, rejects: 0, reject_rate: null, verify_min: 0, test_s: 0, test_timed_tasks: 0, test_s_per_task: null, full_suite_runs: 0,
+    };
+  }
+  for (const t of tasks || []) {
+    if (!t.first) continue;
+    const raw = dispatchMode.get(t.first.agent_id);
+    const r = out[MODE_KEYS.includes(raw) ? raw : 'normal'];
+    r.tasks++;
+    if (t.verifies.length) r.verified_tasks++;
+    for (const v of t.verifies) r.verify_min += (finiteNum(v.duration_s) || 0) / 60;
+    let ts = 0;
+    let timed = false;
+    for (const a of t.attempts.concat(t.verifies)) {
+      const x = tests.get(a.agent_id);
+      if (!x) continue;
+      if (x.timed) { ts += x.s; timed = true; }
+      r.full_suite_runs += x.full;
+    }
+    if (timed) { r.test_s += ts; r.test_timed_tasks++; }
+    for (const a of t.attempts) {
+      if (a.role !== 'exec') continue;
+      for (const v of verdicts.get(a.agent_id) || []) {
+        if (v.outcome === 'fail' && /^batch-verify(?:-|$)/.test(String(v.reason_code || ''))) r.batch_verify_fails++;
+        if (v.verify === 'self') r.self_verdicts++;
+        if (v.outcome !== 'pass' && v.outcome !== 'fail') continue;
+        if (NO_CATCH_VERIFY.has(v.verify || 'none')) continue;
+        r.checked_verdicts++;
+        if (v.outcome === 'fail') r.caught++;
+      }
+    }
+    if (t.user_verdicts.length) {
+      r.user_verdict_tasks++;
+      if (t.user_verdicts.some((v) => v.outcome === 'reject' && v.cause !== 'scope')) r.rejects++;
+    }
+  }
+  for (const m of MODE_KEYS) {
+    const r = out[m];
+    r.catch_rate = r.checked_verdicts ? round6(r.caught / r.checked_verdicts) : null;
+    r.reject_rate = r.user_verdict_tasks ? round6(r.rejects / r.user_verdict_tasks) : null;
+    r.verify_min = round6(r.verify_min);
+    r.test_s = round6(r.test_s);
+    r.test_s_per_task = r.test_timed_tasks ? round6(r.test_s / r.test_timed_tasks) : null;
+  }
+  return out;
+}
+
+module.exports.MODE_KEYS = MODE_KEYS;
+module.exports.modeSummary = modeSummary;

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']);
+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']);
 
 /** Minimal argv parser: positionals, --k v, --k=v, boolean flags. */
 function parseArgs(argv) {

package/lib/choose.cjs

@@ -132,9 +132,19 @@ function loadProfile(skillDir) {
     const v = Number(r.orch_ctx_soft_cap);
     if (isFinite(v) && v > 0) softCap = Math.min(DEFAULT_ORCH_CTX_SOFT_CAP, Math.floor(v));
   }
+  // core 0.7.1 (retro 2026-10-26, C4): per-type tier floor from the user's preference (e.g. art-gen -> opus/medium).
+  // Only tightens: choose takes max(floor, safety floors, escalation); an entry off the ladder is ignored.
+  const tierFloor = {};
+  if (r.tier_floor && typeof r.tier_floor === 'object' && !Array.isArray(r.tier_floor)) {
+    for (const [k, v] of Object.entries(r.tier_floor)) {
+      if (k.startsWith('_')) continue;
+      const idx = parsePrior(v);
+      if (idx !== null) tierFloor[String(k).toLowerCase()] = idx;
+    }
+  }
   return {
     source, dept: r.dept || null, priors, lambda, explore_rate: explore, time_cap_min: timeCap, extra_task_types: extra,
-    orch_ctx_soft_cap: softCap,
+    orch_ctx_soft_cap: softCap, tier_floor: tierFloor,
   };
 }
 
@@ -302,20 +312,8 @@ function estimateFor(idx, cell, pricing) {
 
 // ------------------------------------------------------------------ task type guard
 
-// Ad-hoc labels seen in real logs → the closest fixed type (core 0.4.0). A label maps only when its target
-// is known (fixed list or the profile's extra_task_types), e.g. art-fix → art-gen needs art-gen in the profile.
-const TYPE_ALIASES = {
-  'bug-fix': 'debug', bugfix: 'debug', fix: 'debug', bug: 'debug',
-  config: 'mechanical-edit', shell: 'mechanical-edit', deploy: 'mechanical-edit', ops: 'mechanical-edit', edit: 'mechanical-edit',
-  docs: 'content-write', doc: 'content-write', documentation: 'content-write', writing: 'content-write', copy: 'content-write',
-  design: 'plan-design', plan: 'plan-design', planning: 'plan-design', architecture: 'plan-design',
-  research: 'research-synth', synth: 'research-synth',
-  test: 'test-write', tests: 'test-write',
-  analysis: 'data-analysis', data: 'data-analysis',
-  impl: 'feature-impl', feature: 'feature-impl', implement: 'feature-impl',
-  'code-review': 'review',
-  'art-fix': 'art-gen', art: 'art-gen',
-};
+// Ad-hoc labels → the closest fixed type: the table lives in hook.cjs (core 0.7.1) so dispatch tags map the same way.
+const TYPE_ALIASES = core.TYPE_ALIASES;
 
 /**
  * { type, known, mapped_from, warning }: a fixed/extra type passes; an ad-hoc label with a known alias target
@@ -334,10 +332,56 @@ function resolveTaskType(raw, profile) {
   return { type: t, known: false, mapped_from: null, warning: `loại "${t}" không có trong danh sách cố định (${list}) — chọn loại gần nhất hoặc hỏi người dùng` };
 }
 
+// ------------------------------------------------------------------ verify plan (core 0.7.0, mode per request)
+
+const VERIFY_PLANS = ['independent-blocking', 'independent-nonblocking', 'self+batch', 'spot'];
+/** 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;
+
+/**
+ * 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' }.
+ */
+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 score = Number(opts.score);
+  const floor = [];
+  if (opts.reversible === false) floor.push('khó hoàn tác');
+  if (opts.publish === true) floor.push('publish/deploy');
+  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 (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');
+    }
+    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');
+    }
+  }
+  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');
+  }
+  return out('independent-blocking', `${mode}: verifier độc lập chặn bước`, 'full');
+}
+
 // ------------------------------------------------------------------ choose
 
 /**
- * opts: { type, score, urgency, reversible, verifiable, role, seed, events, profile, taskId, override, pricing }
+ * opts: { type, score, urgency, reversible, verifiable, role, seed, events, profile, taskId, override, pricing,
+ *         mode, publish, dependents }  (mode/publish/dependents only drive verify_plan, never the tier)
  * Returns { action, model, model_id, effort, reason, explored, tier, budget_s, est_cost_usd,
  *           est_time_min, est_source, profile_source, suggested_tier?, overridden? , fails?, tried? }.
  * Throws when an override goes below a safety floor or off the ladder.
@@ -368,6 +412,13 @@ 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)) {
+    throw new Error(`--mode phải là ${core.MODES.join('|')} (nhận "${opts.mode}")`);
+  }
+  const mode = opts.mode || core.DEFAULT_MODE;
+  const vp = role === 'exec'
+    ? verifyPlanFor({ mode, score, verifiable, reversible, publish: opts.publish === true, dependents: opts.dependents === true, seed: opts.seed })
+    : null;
   const profile = opts.profile || loadProfile(null);
   const lambda = profile.lambda[urgency];
   const rng = makeRng(opts.seed);
@@ -398,6 +449,11 @@ function choose(opts) {
   if (!verifiable) { safetyFloor = Math.max(safetyFloor, OPUS_MEDIUM); floorWhy.push('không kiểm chứng bằng máy → tối thiểu opus/medium'); }
   if (!reversible && role === 'exec') { safetyFloor = Math.max(safetyFloor, OPUS_MEDIUM); floorWhy.push('khó hoàn tác → tối thiểu opus/medium'); }
 
+  // Preference floor from the profile (tier_floor): never lowers a safety floor (max), never above the ceiling.
+  const prefFloor = known && profile.tier_floor && Number.isInteger(profile.tier_floor[type])
+    ? Math.min(TOP, profile.tier_floor[type]) : 0;
+  const prefWhy = prefFloor > 0 ? `tier_floor của profile: ${type} tối thiểu ${tierName(prefFloor)}` : null;
+
   const noExploreWhy = [];
   if (score >= 9) noExploreWhy.push(`score ${score}≥9`);
   if (!verifiable) noExploreWhy.push('không kiểm chứng bằng máy');
@@ -436,6 +492,12 @@ function choose(opts) {
       tier: tierName(idx),
       role,
       task_type: type,
+      score,
+      mode,
+      verify_plan: vp ? vp.verify_plan : null,
+      verify_reason: vp ? vp.verify_reason : null,
+      verify_floor: vp ? vp.verify_floor : null,
+      test_scope: vp ? vp.test_scope : null,
       budget_s: budgetFor(cell),
     }, estimateFor(idx, cell, opts.pricing), { profile_source: src },
     rt.mapped_from ? { mapped_from: rt.mapped_from } : {}, rt.warning ? { type_warning: rt.warning } : {}, extra || {});
@@ -443,7 +505,7 @@ function choose(opts) {
 
   // Unknown task type (not fixed, not in the profile, no alias): its stats would never pool — ask first.
   if (!known) {
-    return finish(Math.max(prior, safetyFloor), rt.warning, false, { action: 'ask_user', unknown_type: true });
+    return finish(Math.max(prior, safetyFloor), rt.warning, false, { action: 'ask_user', unknown_type: true, reason_code: 'unknown-type' });
   }
 
   if (overrideIdx !== null && overrideIdx < safetyFloor) {
@@ -451,34 +513,37 @@ function choose(opts) {
   }
   // Escalation beats override/approval: the user must decide first.
   if (esc.ask) {
-    const userIdx = overrideIdx !== null ? overrideIdx : (approvedIdx !== null ? approvedIdx : 0);
+    const userIdx = overrideIdx !== null ? overrideIdx : (approvedIdx !== null ? approvedIdx : prefFloor);
     const idx = Math.max(userIdx, esc.floor, safetyFloor);
-    return finish(idx, esc.note, false, { action: 'ask_user', fails: esc.fails, tried: esc.tried });
+    return finish(idx, esc.note, false, { action: 'ask_user', fails: esc.fails, tried: esc.tried, reason_code: 'ask' });
   }
 
   // Tier approved by the user in the plan table: no Thompson/exploration; only floors can raise it.
   if (approvedIdx !== null) {
     const forced = Math.max(safetyFloor, esc.floor);
     if (approvedIdx >= forced) {
-      const n = esc.note ? `; ${esc.note}` : '';
-      return finish(approvedIdx, `người dùng đã duyệt ${tierName(approvedIdx)} trong bảng phân công${n}`, false, { deviation: false });
+      let n = esc.note ? `; ${esc.note}` : '';
+      if (approvedIdx < prefFloor) n += `; dưới ${prefWhy} (người dùng duyệt nên giữ)`;
+      return finish(approvedIdx, `người dùng đã duyệt ${tierName(approvedIdx)} trong bảng phân công${n}`, false, { deviation: false, reason_code: 'plan' });
     }
     const why = [];
     if (safetyFloor > approvedIdx) why.push(`sàn an toàn ${tierName(safetyFloor)} (${floorWhy.join(', ')})`);
     if (esc.floor > approvedIdx) why.push(esc.note || `leo thang → ${tierName(esc.floor)}`);
-    return finish(forced, `lệch khỏi tier đã duyệt ${tierName(approvedIdx)} → ${tierName(forced)}: ${why.join('; ')}`, false, { deviation: true, approved_tier: tierName(approvedIdx) });
+    return finish(forced, `lệch khỏi tier đã duyệt ${tierName(approvedIdx)} → ${tierName(forced)}: ${why.join('; ')}`, false, { deviation: true, approved_tier: tierName(approvedIdx), reason_code: 'plan' });
   }
   if (esc.note && !esc.ask) notes.push(esc.note);
 
-  const floor = Math.max(safetyFloor, esc.ask ? 0 : esc.floor);
+  const floor = Math.max(safetyFloor, esc.ask ? 0 : esc.floor, prefFloor);
   const base = Math.min(TOP, Math.max(prior, floor));
   if (base > prior) {
     const why = floorWhy.slice();
     if (esc.floor > prior && esc.floor >= safetyFloor && !esc.ask) why.push(`leo thang → ${tierName(esc.floor)}`);
+    if (prefFloor > prior) why.push(prefWhy);
     notes.unshift(`sàn ${tierName(base)} cao hơn ${priorWhy} ${tierName(prior)}: ${why.join(', ') || 'luật an toàn'}`);
   } else if (floorWhy.length) {
     notes.push(`sàn an toàn: ${floorWhy.join(', ')}`);
   }
+  if (prefFloor > 0 && base <= prior) notes.push(prefWhy);
 
   const minIdx = noExplore ? base : floor;
   const candidates = [];
@@ -494,10 +559,15 @@ function choose(opts) {
 
   let chosen = base;
   let why;
+  // core 0.7.1 (C3): why this tier, as a code — thompson | floor | escalation | prior | user-prior | explore | plan | override | ask | unknown-type
+  let code;
+  let tsScore = null;
   const baseCell = cellAt(base);
   const scored = pool.filter((x) => x.cell && x.cell.enough);
   if (!baseCell || !baseCell.enough || !scored.length) {
     why = `${priorWhy} ${tierName(base)} (${baseCell ? `n=${baseCell.n}` : 'n=0'}, chưa đủ dữ liệu)`;
+    if (base > prior) code = esc.floor === base && esc.floor > Math.max(safetyFloor, prefFloor) ? 'escalation' : 'floor';
+    else code = priorWhy === 'prior' ? 'prior' : 'user-prior';
   } else {
     let best = null;
     for (const x of scored) {
@@ -510,6 +580,8 @@ function choose(opts) {
       if (!best || s < best.s) best = { i: x.i, s, p };
     }
     chosen = best.i;
+    code = 'thompson';
+    tsScore = Math.round(best.s * 1000) / 1000;
     why = `Thompson: ${tierName(chosen)} điểm ${best.s.toFixed(3)} (p≈${best.p.toFixed(2)}, ${scored.length} ô đủ dữ liệu)`;
   }
 
@@ -518,22 +590,24 @@ function choose(opts) {
   if (!noExplore && chosen - 1 >= floor && u < profile.explore_rate) {
     chosen -= 1;
     explored = true;
+    code = 'explore';
     why = `thăm dò xuống ${tierName(chosen)} (xác suất ${profile.explore_rate}); ${why}`;
   }
 
   if (overrideIdx !== null) {
     const sugg = tierName(chosen);
-    return finish(overrideIdx, `người dùng chọn ${tierName(overrideIdx)} (đề xuất là ${sugg}: ${why})`, false, {
-      overridden: overrideIdx !== chosen, suggested_tier: sugg,
+    const below = overrideIdx < prefFloor ? `; dưới ${prefWhy} (người dùng chọn nên giữ)` : '';
+    return finish(overrideIdx, `người dùng chọn ${tierName(overrideIdx)} (đề xuất là ${sugg}: ${why})${below}`, false, {
+      overridden: overrideIdx !== chosen, suggested_tier: sugg, reason_code: 'override', suggested_reason_code: code, thompson_score: tsScore,
     });
   }
   if (noExplore) notes.push(`không thăm dò: ${noExploreWhy.join(', ')}`);
-  return finish(chosen, [why].concat(notes).join('; '), explored);
+  return finish(chosen, [why].concat(notes).join('; '), explored, { reason_code: code, thompson_score: tsScore });
 }
 
 module.exports = {
   DEFAULT_ORCH_CTX_SOFT_CAP,
   LADDER, DEFAULT_PRIORS, DEFAULT_LAMBDA, DEFAULT_TIME_CAP_MIN, ROUGH, tierIndex, tierName, parsePrior,
   parseTier, loadProfile, makeRng, betaSample, escalation, overridePrior, roughEstimate, choose, shortModel,
-  TYPE_ALIASES, resolveTaskType,
+  TYPE_ALIASES, resolveTaskType, verifyPlanFor, VERIFY_PLANS,
 };