@kienntpixon/dieu-phoi 0.7.0 → 0.7.2

package/lib/aggregate.cjs

@@ -125,6 +125,7 @@ function buildAgents(events) {
   const userVerdicts = [];
   const autoVerdicts = [];
   const overrides = [];
+  const implicitOverrides = []; // core 0.7.2 (K4): deviations the hook logged; not the user's overrides
   const steers = [];
   const get = (id) => {
     if (!map.has(id)) map.set(id, { agent_id: id, dispatch: null, completes: [], verdicts: [], steers: [] });
@@ -135,7 +136,7 @@ function buildAgents(events) {
     if (!ev || typeof ev !== 'object') return;
     if (isInternalComplete(ev, dispatched)) return;
     const e = Object.assign({ _idx: idx }, ev);
-    if (ev.kind === 'override') { overrides.push(e); return; }
+    if (ev.kind === 'override') { (ev.source === 'implicit' ? implicitOverrides : overrides).push(e); return; }
     if (ev.kind === 'verdict') {
       const v = Object.assign(e, normalizeVerdict(ev));
       if (v.by === 'user') { userVerdicts.push(v); return; }
@@ -173,6 +174,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,
@@ -200,7 +203,7 @@ function buildAgents(events) {
       last_complete_ts: a.completes.length ? Math.max(...a.completes.map(tsOf)) : 0,
     });
   }
-  return { agents, userVerdicts, autoVerdicts, overrides, steers };
+  return { agents, userVerdicts, autoVerdicts, overrides, implicitOverrides, steers };
 }
 
 /** Group agents into tasks (sample unit = task_id; agents without task_id are their own task). */
@@ -284,7 +287,9 @@ function buildTasks(agents, userVerdicts, autoVerdicts) {
     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,
@@ -315,6 +320,43 @@ function buildTasks(agents, userVerdicts, autoVerdicts) {
   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 || '?'}`;
 }
@@ -522,18 +564,19 @@ function orchestrationSummary(events) {
 }
 
 function analyze(events, opts) {
-  const { agents, userVerdicts, autoVerdicts, overrides, steers } = buildAgents(withoutDiscarded(events));
+  const { agents, userVerdicts, autoVerdicts, overrides, implicitOverrides, steers } = buildAgents(withoutDiscarded(events));
   const tasks = buildTasks(agents, userVerdicts, autoVerdicts);
   const cells = buildCells(tasks, opts);
   return {
-    agents, tasks, cells, overrides, userVerdicts, autoVerdicts, steerEvents: steers, steers: buildSteers(tasks, steers, agents),
+    agents, tasks, cells, overrides, implicitOverrides, userVerdicts, autoVerdicts, steerEvents: steers, steers: buildSteers(tasks, steers, agents),
     orchestration: orchestrationSummary(events),
+    batch_verify: batchVerifyCells(agents),
   };
 }
 
 module.exports = {
   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, orchestrationSummary, analyze, cellKey, mean, percentile, tsOf, steerIdOf,
+  buildCells, buildSteers, canonicalCells, isBatchVerify, batchVerifyCells, orchestrationSummary, analyze, cellKey, mean, percentile, tsOf, steerIdOf,
 };
 
 // ------------------------------------------------------------------ core 0.7.0 (s2): stats split by mode

package/lib/args.cjs

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

package/lib/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
@@ -451,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');
@@ -489,6 +492,7 @@ 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,
@@ -501,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) {
@@ -509,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 = [];
@@ -552,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) {
@@ -568,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)`;
   }
 
@@ -576,17 +590,19 @@ 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 = {