@kienntpixon/dieu-phoi 0.0.0-stage → 0.1.0

package/lib/choose.cjs

@@ -0,0 +1,466 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const core = require('../hook.cjs');
+const agg = require('./aggregate.cjs');
+
+// Tier ladder, cheapest first. Ceiling = opus/high (core safety rule).
+const LADDER = [
+  { model: 'haiku', effort: 'low' },
+  { model: 'haiku', effort: 'medium' },
+  { model: 'haiku', effort: 'high' },
+  { model: 'sonnet', effort: 'medium' },
+  { model: 'sonnet', effort: 'high' },
+  { model: 'opus', effort: 'medium' },
+  { model: 'opus', effort: 'high' },
+];
+const TOP = LADDER.length - 1;
+const EFFORT_RANK = { low: 0, medium: 1, high: 2, xhigh: 3, max: 4 };
+
+// Built-in defaults = skill/profile/profile.json (v1.0.0); used only when no profile is found.
+const DEFAULT_PRIORS = {
+  search: 'haiku/medium',
+  extract: 'haiku/medium',
+  'mechanical-edit': 'sonnet/medium',
+  'feature-impl': 'opus/medium',
+  debug: 'opus/medium',
+  refactor: 'opus/medium',
+  'test-write': 'sonnet/high',
+  review: 'opus/medium',
+  'research-synth': 'opus/medium',
+  'content-write': 'sonnet/high',
+  'plan-design': 'opus/high',
+  'data-analysis': 'sonnet/high',
+};
+const DEFAULT_TIME_CAP_MIN = {
+  search: 3,
+  extract: 5,
+  'mechanical-edit': 10,
+  'feature-impl': 25,
+  debug: 25,
+  refactor: 30,
+  'test-write': 15,
+  review: 10,
+  'research-synth': 20,
+  'content-write': 15,
+  'plan-design': 15,
+  'data-analysis': 15,
+};
+const DEFAULT_LAMBDA = { relaxed: 0.02, normal: 0.1, urgent: 1.0 };
+const DEFAULT_EXPLORE = 0.1;
+
+function tierName(i) {
+  return `${LADDER[i].model}/${LADDER[i].effort}`;
+}
+
+function shortModel(m) {
+  const id = core.normalizeModel(m);
+  if (!id) return null;
+  for (const k of ['opus', 'sonnet', 'haiku', 'fable']) if (id.includes(k)) return k;
+  return null;
+}
+
+/** Map any (model, effort) onto the ladder, clamped to the ceiling. Fable -> opus. */
+function tierIndex(model, effort) {
+  let m = shortModel(model);
+  if (!m) return null;
+  if (m === 'fable') m = 'opus';
+  const e = EFFORT_RANK[String(effort || 'medium').toLowerCase()];
+  const er = e === undefined ? 1 : e;
+  const same = LADDER.map((t, i) => ({ t, i })).filter((x) => x.t.model === m);
+  let best = same[0];
+  for (const x of same) if (EFFORT_RANK[x.t.effort] <= er) best = x;
+  if (er < EFFORT_RANK[same[0].t.effort]) best = same[0];
+  return best.i;
+}
+
+function parsePrior(p) {
+  if (!p) return null;
+  if (typeof p === 'string') {
+    const [m, e] = p.split('/');
+    return tierIndex(m, e);
+  }
+  if (typeof p === 'object') return tierIndex(p.model, p.effort);
+  return null;
+}
+
+/** Load profile.json from <skillDir>/profile, merged over built-in defaults. */
+function loadProfile(skillDir) {
+  let raw = null;
+  let source = 'builtin';
+  if (skillDir) {
+    const f = path.join(skillDir, 'profile', 'profile.json');
+    if (fs.existsSync(f)) {
+      raw = core.readJsonFile(f, null);
+      if (raw) source = f.split(path.sep).join('/');
+    }
+  }
+  const r = raw && typeof raw === 'object' ? raw : {};
+  const priors = {};
+  for (const [k, v] of Object.entries(DEFAULT_PRIORS)) priors[k] = parsePrior(v);
+  if (r.priors && typeof r.priors === 'object') {
+    for (const [k, v] of Object.entries(r.priors)) {
+      const idx = parsePrior(v);
+      if (idx !== null) priors[k] = idx;
+    }
+  }
+  const lambda = Object.assign({}, DEFAULT_LAMBDA);
+  if (r.lambda_usd_per_min && typeof r.lambda_usd_per_min === 'object') {
+    for (const u of core.URGENCIES) {
+      const v = Number(r.lambda_usd_per_min[u]);
+      if (isFinite(v) && v >= 0) lambda[u] = v;
+    }
+  }
+  let explore = DEFAULT_EXPLORE;
+  if (r.explore_rate !== undefined) {
+    const v = Number(r.explore_rate);
+    if (isFinite(v)) explore = Math.min(1, Math.max(0, v));
+  }
+  const timeCap = Object.assign({}, DEFAULT_TIME_CAP_MIN,
+    r.time_cap_min && typeof r.time_cap_min === 'object' ? r.time_cap_min : {});
+  const extra = Array.isArray(r.extra_task_types) ? r.extra_task_types.map(String) : [];
+  return { source, dept: r.dept || null, priors, lambda, explore_rate: explore, time_cap_min: timeCap, extra_task_types: extra };
+}
+
+// ------------------------------------------------------------------ seeded RNG
+
+function makeRng(seed) {
+  let a;
+  if (seed === undefined || seed === null || seed === true) a = crypto.randomBytes(4).readUInt32LE(0);
+  else a = crypto.createHash('sha256').update(String(seed)).digest().readUInt32LE(0);
+  return function mulberry32() {
+    a = (a + 0x6D2B79F5) >>> 0;
+    let t = a;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+function normal(rng) {
+  let u = 0;
+  while (u === 0) u = rng();
+  const v = rng();
+  return Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
+}
+
+function gamma(rng, k) {
+  if (k < 1) return gamma(rng, k + 1) * rng() ** (1 / k);
+  const d = k - 1 / 3;
+  const c = 1 / Math.sqrt(9 * d);
+  for (;;) {
+    let x;
+    let v;
+    do { x = normal(rng); v = 1 + c * x; } while (v <= 0);
+    v = v * v * v;
+    const u = rng();
+    if (u < 1 - 0.0331 * x ** 4) return d * v;
+    if (Math.log(u) < 0.5 * x * x + d * (1 - v + Math.log(v))) return d * v;
+  }
+}
+
+function betaSample(rng, a, b) {
+  const x = gamma(rng, a);
+  const y = gamma(rng, b);
+  return x / (x + y);
+}
+
+// ------------------------------------------------------------------ escalation
+
+const OPUS_MEDIUM = 5;
+
+/**
+ * Escalation within one task_id (CONTRACT "Luật an toàn"):
+ * - one fail at a tier -> same tier again (retry with the error);
+ * - two fails at the same tier -> next tier up;
+ * - if that next tier would exceed opus/medium for role=exec -> ask the user (no auto re-plan).
+ * Fail = agent fail|timeout or user reject cause=quality (eff_outcome). Attempts steered
+ * plan/redirect by the user are ignored.
+ */
+function escalation(task, role) {
+  const none = { floor: 0, ask: false, note: null, fails: 0, tried: [] };
+  if (!task) return none;
+  const att = task.attempts
+    .filter((a) => a.eff_outcome && a.role !== 'verify' && !a.steered)
+    .map((a) => ({ a, i: tierIndex(a.model, a.effort) }))
+    .filter((x) => x.i !== null)
+    .sort((x, y) => (x.a.try - y.a.try) || (x.a.ts - y.a.ts));
+  if (!att.length) return none;
+  const tried = Array.from(new Set(att.map((x) => tierName(x.i))));
+  const totalFails = att.filter((x) => x.a.eff_outcome === 'fail').length;
+  const last = att[att.length - 1];
+  const cur = last.i;
+  const base = { tried, fails: totalFails, ask: false };
+  if (last.a.eff_outcome !== 'fail') return Object.assign(base, { floor: cur, note: null });
+  const fails = att.filter((x) => x.i === cur && x.a.eff_outcome === 'fail').length;
+  if (fails < 2) {
+    return Object.assign(base, { floor: cur, note: `task fail 1 lần ở ${tierName(cur)} → làm lại cùng tier kèm lỗi` });
+  }
+  const next = cur + 1;
+  if (((role || 'exec') === 'exec' && next > OPUS_MEDIUM) || next > TOP) {
+    return Object.assign(base, {
+      floor: Math.min(TOP, next), ask: true,
+      note: `task đã fail ${totalFails} lần (đã thử ${tried.join(', ')}); tier kế vượt opus/medium — hỏi người dùng: làm rõ yêu cầu, đổi kế hoạch hay chạy opus/high`,
+    });
+  }
+  return Object.assign(base, { floor: next, note: `task fail ${fails} lần ở ${tierName(cur)} → lên ${tierName(next)}` });
+}
+
+// ------------------------------------------------------------------ override learning
+
+function parseTier(s) {
+  if (typeof s !== 'string') return null;
+  const [m, e] = s.trim().toLowerCase().split('/');
+  const i = LADDER.findIndex((t) => t.model === shortModel(m) && t.effort === e);
+  return i >= 0 ? i : null;
+}
+
+/**
+ * Prior learned from the user's overrides for a task type: the last >=3 overrides all moved in
+ * the same direction and >=3 of the last 5 chose the same tier -> that tier.
+ * At most one override per task_id counts (its latest); overrides equal to the suggestion are ignored.
+ */
+function overridePrior(overrides, type) {
+  const perTask = new Map();
+  (overrides || [])
+    .filter((o) => o.task_type === type)
+    .map((o) => ({ s: parseTier(o.suggested_tier), c: parseTier(o.chosen_tier), t: agg.tsOf(o), i: o._idx || 0, task: o.task_id }))
+    .filter((o) => o.s !== null && o.c !== null && o.s !== o.c)
+    .sort((a, b) => a.t - b.t || a.i - b.i)
+    .forEach((o, k) => perTask.set(o.task ? `t:${o.task}` : `i:${k}`, o));
+  const list = Array.from(perTask.values()).sort((a, b) => a.t - b.t || a.i - b.i);
+  if (list.length < 3) return null;
+  const last3 = list.slice(-3).map((o) => Math.sign(o.c - o.s));
+  if (last3[0] === 0 || !last3.every((d) => d === last3[0])) return null;
+  const counts = new Map();
+  for (const o of list.slice(-5)) counts.set(o.c, (counts.get(o.c) || 0) + 1);
+  let best = null;
+  for (const [tier, n] of counts) if (!best || n > best.n || (n === best.n && tier > best.tier)) best = { tier, n };
+  if (!best || best.n < 3) return null;
+  return { tier: best.tier, n: best.n, direction: last3[0] > 0 ? 'lên' : 'xuống' };
+}
+
+// ------------------------------------------------------------------ rough estimates
+
+// Rough per-attempt token assumption by tier when a cell has n<5 (documented in README):
+// uncached input incl. ~44k system prompt + context, output incl. thinking. Minutes are guesses.
+const ROUGH = {
+  'haiku/low': { input: 50000, output: 2000, minutes: 1 },
+  'haiku/medium': { input: 50000, output: 4000, minutes: 2 },
+  'haiku/high': { input: 55000, output: 6000, minutes: 3 },
+  'sonnet/medium': { input: 55000, output: 6000, minutes: 4 },
+  'sonnet/high': { input: 60000, output: 8000, minutes: 6 },
+  'opus/medium': { input: 60000, output: 8000, minutes: 8 },
+  'opus/high': { input: 80000, output: 12000, minutes: 12 },
+};
+
+function roughEstimate(idx, pricing) {
+  const name = tierName(idx);
+  const r = ROUGH[name];
+  const p = pricing || core.loadPricing(null);
+  const c = core.requestCost(p, core.MODEL_ALIASES[LADDER[idx].model], {
+    input: r.input, output: r.output, thinking: 0, cache_write_5m: 0, cache_write_1h: 0, cache_read: 0,
+  });
+  return { est_cost_usd: c === null ? null : Math.round(c * 1000) / 1000, est_time_min: r.minutes, est_source: 'rough' };
+}
+
+function estimateFor(idx, cell, pricing) {
+  if (cell && cell.enough && cell.attempt_p50_min !== null) {
+    return {
+      est_cost_usd: cell.attempt_cost_p50 === null ? null : Math.round(cell.attempt_cost_p50 * 1000) / 1000,
+      est_time_min: Math.round(cell.attempt_p50_min * 10) / 10,
+      est_source: 'data',
+    };
+  }
+  return roughEstimate(idx, pricing);
+}
+
+// ------------------------------------------------------------------ choose
+
+/**
+ * opts: { type, score, urgency, reversible, verifiable, role, seed, events, profile, taskId, override, pricing }
+ * 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.
+ */
+function choose(opts) {
+  const type = String(opts.type || '').toLowerCase();
+  if (!type) throw new Error('Thiếu --type');
+  const score = Number(opts.score);
+  if (opts.score === undefined || opts.score === null || opts.score === true || !isFinite(score)
+    || score < 0 || score > 12) throw new Error('--score phải trong 0–12');
+  const urgency = opts.urgency || 'normal';
+  if (!core.URGENCIES.includes(urgency)) throw new Error(`--urgency phải là ${core.URGENCIES.join('|')}`);
+  const role = opts.role || 'exec';
+  if (!core.ROLES.includes(role)) throw new Error(`--role phải là ${core.ROLES.join('|')}`);
+  const ladderList = LADDER.map((t) => `${t.model}/${t.effort}`).join(', ');
+  let overrideIdx = null;
+  if (opts.override !== undefined && opts.override !== null) {
+    overrideIdx = parseTier(String(opts.override));
+    if (overrideIdx === null) {
+      throw new Error(`--override "${opts.override}" không nằm trên thang tier (trần opus/high, không Fable): ${ladderList}`);
+    }
+  }
+  let approvedIdx = null;
+  if (opts.approved !== undefined && opts.approved !== null) {
+    approvedIdx = parseTier(String(opts.approved));
+    if (approvedIdx === null) throw new Error(`--approved "${opts.approved}" không nằm trên thang tier: ${ladderList}`);
+    if (overrideIdx !== null) throw new Error('Dùng --override hoặc --approved, không dùng cả hai');
+  }
+  const reversible = opts.reversible !== false;
+  const verifiable = opts.verifiable !== false;
+  const profile = opts.profile || loadProfile(null);
+  const lambda = profile.lambda[urgency];
+  const rng = makeRng(opts.seed);
+  const notes = [];
+
+  const analysis = agg.analyze(opts.events || [], { lambda });
+  const known = core.TASK_TYPES.includes(type) || profile.extra_task_types.includes(type);
+  let prior = profile.priors[type];
+  let priorWhy = 'prior';
+  if (prior === undefined || prior === null) {
+    prior = OPUS_MEDIUM;
+    notes.push(known ? 'không có prior, dùng opus/medium' : `loại "${type}" lạ, dùng opus/medium`);
+  }
+  const ov = overridePrior(analysis.overrides, type);
+  if (ov && ov.tier !== prior) {
+    notes.push(`prior ${tierName(prior)} → ${tierName(ov.tier)} theo override của người dùng (${ov.n}/5 lần gần nhất, cùng hướng ${ov.direction})`);
+    prior = ov.tier;
+    priorWhy = 'prior theo override của người dùng';
+  }
+
+  // Safety floors (core only; a profile can never lower them).
+  let safetyFloor = 0;
+  const floorWhy = [];
+  if (score >= 9) { safetyFloor = Math.max(safetyFloor, TOP); floorWhy.push(`score ${score}≥9 → tối thiểu opus/high`); }
+  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'); }
+
+  const noExploreWhy = [];
+  if (score >= 9) noExploreWhy.push(`score ${score}≥9`);
+  if (!verifiable) noExploreWhy.push('không kiểm chứng bằng máy');
+  if (!reversible) noExploreWhy.push('khó hoàn tác');
+  if (urgency === 'urgent') noExploreWhy.push('urgent');
+  if (overrideIdx !== null) noExploreWhy.push('người dùng chọn tier');
+  const noExplore = noExploreWhy.length > 0;
+
+  const task = opts.taskId ? analysis.tasks.find((t) => t.task_id === opts.taskId) : null;
+  if (opts.taskId && !task) notes.push(`chưa thấy task ${opts.taskId} trong log`);
+  const esc = escalation(task, role);
+
+  const capMin = Number(profile.time_cap_min[type]);
+  const budgetFor = (cell) => {
+    if (cell && cell.enough && cell.attempt_p50_min !== null) return Math.round(cell.attempt_p50_min * 2 * 60);
+    return isFinite(capMin) && capMin > 0 ? Math.round(capMin * 60) : null;
+  };
+
+  const cellAt = (i) => analysis.cells.find((c) => c.task_type === type
+    && shortModel(c.model) === LADDER[i].model && c.effort === LADDER[i].effort) || null;
+
+  const src = profile.source || 'builtin';
+  const finish = (idx, reason, explored, extra) => {
+    const t = LADDER[idx];
+    const cell = cellAt(idx);
+    return Object.assign({
+      action: 'dispatch',
+      model: t.model,
+      model_id: core.MODEL_ALIASES[t.model],
+      effort: t.effort,
+      reason: `${reason}; profile: ${src}`,
+      explored,
+      tier: tierName(idx),
+      role,
+      budget_s: budgetFor(cell),
+    }, estimateFor(idx, cell, opts.pricing), { profile_source: src }, extra || {});
+  };
+
+  if (overrideIdx !== null && overrideIdx < safetyFloor) {
+    throw new Error(`Từ chối override ${tierName(overrideIdx)}: dưới sàn an toàn ${tierName(safetyFloor)} (${floorWhy.join(', ')}).`);
+  }
+  // Escalation beats override/approval: the user must decide first.
+  if (esc.ask) {
+    const userIdx = overrideIdx !== null ? overrideIdx : (approvedIdx !== null ? approvedIdx : 0);
+    const idx = Math.max(userIdx, esc.floor, safetyFloor);
+    return finish(idx, esc.note, false, { action: 'ask_user', fails: esc.fails, tried: esc.tried });
+  }
+
+  // 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 });
+    }
+    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) });
+  }
+  if (esc.note && !esc.ask) notes.push(esc.note);
+
+  const floor = Math.max(safetyFloor, esc.ask ? 0 : esc.floor);
+  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)}`);
+    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(', ')}`);
+  }
+
+  const minIdx = noExplore ? base : floor;
+  const candidates = [];
+  for (let i = minIdx; i <= TOP; i++) {
+    const c = cellAt(i);
+    if (i === base || (c && c.enough)) candidates.push({ i, cell: c });
+  }
+  // Tiers whose p75 time breaks the type's time cap are dropped (if anything else remains).
+  const capped = candidates.filter((x) => !(isFinite(capMin) && capMin > 0 && x.cell && x.cell.enough
+    && x.cell.attempt_p75_min !== null && x.cell.attempt_p75_min > capMin));
+  const pool = capped.length ? capped : candidates;
+  if (capped.length < candidates.length) notes.push('loại tier có p75 vượt trần thời gian');
+
+  let chosen = base;
+  let why;
+  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)`;
+  } else {
+    let best = null;
+    for (const x of scored) {
+      const p = betaSample(rng, 1 + x.cell.passes, 1 + x.cell.fails);
+      const cost = x.cell.attempt_cost_usd || 0;
+      const time = urgency === 'urgent' && x.cell.attempt_p75_min !== null
+        ? x.cell.attempt_p75_min : (x.cell.attempt_time_min || 0);
+      const s = cost / p + lambda * time / p;
+      if (!best || s < best.s) best = { i: x.i, s, p };
+    }
+    chosen = best.i;
+    why = `Thompson: ${tierName(chosen)} điểm ${best.s.toFixed(3)} (p≈${best.p.toFixed(2)}, ${scored.length} ô đủ dữ liệu)`;
+  }
+
+  let explored = false;
+  const u = rng();
+  if (!noExplore && chosen - 1 >= floor && u < profile.explore_rate) {
+    chosen -= 1;
+    explored = true;
+    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,
+    });
+  }
+  if (noExplore) notes.push(`không thăm dò: ${noExploreWhy.join(', ')}`);
+  return finish(chosen, [why].concat(notes).join('; '), explored);
+}
+
+module.exports = {
+  LADDER, DEFAULT_PRIORS, DEFAULT_LAMBDA, DEFAULT_TIME_CAP_MIN, ROUGH, tierIndex, tierName, parsePrior,
+  parseTier, loadProfile, makeRng, betaSample, escalation, overridePrior, roughEstimate, choose, shortModel,
+};