@kienntpixon/dieu-phoi 0.3.0 → 0.5.0

package/lib/aggregate.cjs

@@ -9,6 +9,15 @@ const core = require('../hook.cjs');
 const MIN_N = 5;
 const FAIL_OUTCOMES = new Set(['fail', 'timeout']);
 const HEAVY_STEERS = new Set(['plan', 'redirect']);
+// core 0.4.0: an agent stopped by a usage-limit/quota pause is `aborted` — neither pass nor fail. Legacy
+// rows recorded such pauses as `timeout` with a quota-ish reason_code; they are read as `aborted` too.
+const ABORTED = 'aborted';
+// Exact markers only (anchored): `quota-pause`, `usage-limit`, the hook's `auto-*` codes and the legacy
+// `paused-for-quota-*` codes the orchestrator wrote before 0.4.0. A reason that merely mentions a rate limit stays a timeout.
+const QUOTA_REASON_RE = /^(?:quota-pause|usage-limit|auto-quota-pause|auto-usage-limit|paused-for-quota)(?:-|$)/;
+// core 0.5.0: `aborted` with this reason = the agent stopped on the context watchdog and wrote handoff.md. Its
+// continuation (next exec agent of the task with the same try) carries the attempt's agent-layer result.
+const HANDOFF_REASON_RE = /^(?:auto-)?handoff(?:-|$)/;
 
 function tsOf(ev) {
   const t = Date.parse(ev && ev.ts);
@@ -56,7 +65,33 @@ function normalizeVerdict(ev) {
   const by = ev.by === 'user' ? 'user' : 'agent';
   let cause = ev.cause || null;
   if (by === 'user' && ev.outcome === 'reject' && cause !== 'scope') cause = 'quality';
-  return { by, outcome: ev.outcome, cause, round: Number(ev.round) || null };
+  let outcome = ev.outcome;
+  if (by === 'agent' && outcome === 'timeout' && typeof ev.reason_code === 'string' && QUOTA_REASON_RE.test(ev.reason_code)) {
+    outcome = ABORTED;
+  }
+  return { by, outcome, cause, round: Number(ev.round) || null };
+}
+
+/**
+ * Task ids withdrawn with `dieu-phoi discard --task` (kind=discard). Every event of such a task — and every
+ * event of an agent dispatched for it — is left out of tasks, cells and steers (CONTRACT "Sự kiện cục bộ").
+ */
+function discardedTaskIds(events) {
+  const out = new Set();
+  for (const ev of events) if (ev && ev.kind === 'discard' && typeof ev.task_id === 'string' && ev.task_id) out.add(ev.task_id);
+  return out;
+}
+
+/** Events with discarded tasks (and the discard records themselves) replaced by null; order kept. */
+function withoutDiscarded(events) {
+  const gone = discardedTaskIds(events);
+  const agents = new Set(events.filter((ev) => ev && ev.kind === 'dispatch' && gone.has(ev.task_id)).map((ev) => ev.agent_id));
+  return events.map((ev) => {
+    if (!ev || typeof ev !== 'object' || ev.kind === 'discard') return null;
+    if (gone.has(ev.task_id) || agents.has(ev.agent_id)) return null;
+    if (typeof ev.agent_id === 'string' && ev.agent_id.startsWith('task:') && gone.has(ev.agent_id.slice(5))) return null;
+    return ev;
+  });
 }
 
 function blank(v) {
@@ -111,7 +146,9 @@ function buildAgents(events) {
     const d = a.dispatch || {};
     const c0 = a.completes[0] || {};
     const cl = a.completes[a.completes.length - 1] || {};
-    const v = a.verdicts.slice().sort((x, y) => tsOf(x) - tsOf(y) || x._idx - y._idx);
+    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 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));
@@ -137,6 +174,10 @@ function buildAgents(events) {
       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,
+      // 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,
+      handoff: vAll.some((x) => x.outcome === ABORTED && HANDOFF_REASON_RE.test(String(x.reason_code || ''))),
       verify: verdict ? verdict.verify : null,
       reason_code: verdict ? verdict.reason_code : null,
       steers: a.steers.map((s) => s.steer_kind).filter(Boolean),
@@ -169,22 +210,41 @@ function buildTasks(agents, userVerdicts) {
   const tasks = [];
   for (const t of map.values()) {
     const byTry = (x, y) => (x.try - y.try) || (x.ts - y.ts) || (x._idx - y._idx);
-    const attempts = t.agents.filter((a) => a.role !== 'verify').sort(byTry);
+    // gen-2 helpers (role=helper, own task_id) are never attempts
+    const attempts = t.agents.filter((a) => a.role !== 'verify' && a.role !== 'helper').sort(byTry);
     const verifies = t.agents.filter((a) => a.role === 'verify');
     // First exec attempt: lowest try among role=exec (ties: earliest). No exec attempt -> no sample.
-    const first = t.agents.filter((a) => a.role === 'exec').sort(byTry)[0] || null;
+    const execs = t.agents.filter((a) => a.role === 'exec').sort(byTry);
+    const first = execs[0] || null;
+    // core 0.5.0: a first exec that stopped on a context handoff (no result of its own) passes the agent layer to its
+    // continuation(s) with the same try; the tier stays the first exec's.
+    let firstRes = first;
+    const chain = first ? [first] : [];
+    for (let i = 1; firstRes && !firstRes.first_outcome && firstRes.handoff && i < execs.length && execs[i].try === first.try; i++) {
+      firstRes = execs[i];
+      chain.push(firstRes);
+    }
     const user = t.user.slice().sort((x, y) => ((x.round || 0) - (y.round || 0)) || (tsOf(x) - tsOf(y)) || (x._idx - y._idx));
 
-    // Effective per-attempt outcome for escalation: agent verdict, overridden by a user verdict
-    // landing on the latest attempt dispatched before it (reject/quality = fail, accept = pass).
-    for (const a of attempts) a.eff_outcome = a.outcome === 'pass' ? 'pass' : (FAIL_OUTCOMES.has(a.outcome) ? 'fail' : null);
+    // Results for escalation. Each agent verdict of an attempt is one result at its tier (a retry by
+    // SendMessage to the same agent is a new result); a user verdict adds a result to the latest attempt
+    // dispatched before it (reject/quality = fail, accept = pass). eff_outcome = the attempt's latest result.
+    for (const a of attempts) {
+      a.results = (a.verdict_seq || [])
+        .filter((x) => x.outcome === 'pass' || FAIL_OUTCOMES.has(x.outcome))
+        .map((x) => ({ outcome: x.outcome === 'pass' ? 'pass' : 'fail', ts: x.ts, idx: x.idx }));
+      a.eff_outcome = a.results.length ? a.results[a.results.length - 1].outcome : null;
+    }
     for (const v of user) {
       if (v.cause === 'scope') continue;
       const vt = tsOf(v);
       let target = null;
       for (const a of attempts) if (a.ts <= vt && (!target || a.ts >= target.ts)) target = a;
       if (!target) target = attempts[attempts.length - 1] || null;
-      if (target) target.eff_outcome = v.outcome === 'accept' ? 'pass' : 'fail';
+      if (target) {
+        target.eff_outcome = v.outcome === 'accept' ? 'pass' : 'fail';
+        target.results.push({ outcome: target.eff_outcome, ts: vt, idx: v._idx, user: true });
+      }
     }
 
     const firstUser = user[0] || null;
@@ -194,8 +254,8 @@ function buildTasks(agents, userVerdicts) {
       else userOutcome = firstUser.cause === 'scope' ? 'reject_scope' : 'reject_quality';
     }
     // Agent layer of the first exec attempt: its first agent verdict.
-    const agentFirst = first && first.first_outcome && (first.first_outcome === 'pass' || FAIL_OUTCOMES.has(first.first_outcome))
-      ? first.first_outcome === 'pass' : null;
+    const agentFirst = firstRes && firstRes.first_outcome && (firstRes.first_outcome === 'pass' || FAIL_OUTCOMES.has(firstRes.first_outcome))
+      ? firstRes.first_outcome === 'pass' : null;
     let success = null;
     let source = null;
     if (userOutcome === 'accept') { success = true; source = 'user'; } else if (userOutcome === 'reject_quality') { success = false; source = 'user'; } else if (!userOutcome && agentFirst !== null) {
@@ -209,6 +269,11 @@ function buildTasks(agents, userVerdicts) {
       task_id: t.task_id,
       task_type: first ? first.task_type : (t.agents[0] && t.agents[0].task_type) || 'untagged',
       first,
+      // the first attempt as a whole: its exec segment plus every handoff continuation (time/cost summed over all
+      // segments; the result comes from the last one, firstRes)
+      first_chain: chain,
+      first_cost: chain.length ? sumOrNull(chain.map((a) => a.cost_usd)) : null,
+      first_time_s: chain.length ? sumOrNull(chain.map((a) => a.duration_s)) : null,
       attempts,
       verifies,
       user_verdicts: user,
@@ -258,8 +323,9 @@ function buildCells(tasks, opts) {
     const passes = c.tasks.filter((t) => t.success).length;
     const costs = c.tasks.map((t) => t.total_cost);
     const timesMin = c.tasks.map((t) => (t.total_time_s === null ? null : t.total_time_s / 60));
-    const attemptTimes = c.tasks.map((t) => (t.first.duration_s === null ? null : t.first.duration_s / 60));
-    const attemptCosts = c.tasks.map((t) => t.first.cost_usd);
+    // a handoff chain is one attempt: all its segments count (t.first alone would bill only the first segment)
+    const attemptTimes = c.tasks.map((t) => (t.first_time_s === null || t.first_time_s === undefined ? null : t.first_time_s / 60));
+    const attemptCosts = c.tasks.map((t) => (t.first_cost === undefined ? null : t.first_cost));
     const costMean = mean(costs);
     const timeMean = mean(timesMin);
     out.push({
@@ -307,13 +373,19 @@ function canonicalCells(cells) {
   return cells.map((c) => Object.fromEntries(CANONICAL_CELL_FIELDS.map((k) => [k, c[k] === undefined ? null : c[k]])));
 }
 
-/** Steering per task_type, counted in distinct user actions (steer_id), not events. */
+/**
+ * Steering per task_type, counted in distinct user actions (steer_id), not events. Core 0.4.0: only
+ * exec-phase steers count — a steer on a role=exec agent, or a task-level steer on a task that has an exec
+ * attempt. Steers on scouts/planners (gate-1 Q&A) and on verifiers go to `plan_phase_actions` and never
+ * touch actions / steer_rate.
+ */
 function buildSteers(tasks, steers, agents) {
   const typeOfTask = new Map(tasks.map((t) => [t.task_id, t.task_type]));
+  const execTask = new Set(tasks.filter((t) => t.first && t.task_id).map((t) => t.task_id));
   const agentById = new Map(agents.map((a) => [a.agent_id, a]));
   const by = {};
   const row = (type) => by[type] || (by[type] = {
-    task_type: type, tasks: 0, steered_tasks: 0, actions: 0, minor: 0, plan: 0, redirect: 0, _tasks: new Set(), _ids: new Set(),
+    task_type: type, tasks: 0, steered_tasks: 0, actions: 0, minor: 0, plan: 0, redirect: 0, _tasks: new Set(), _ids: new Set(), _plan: new Set(),
   });
   for (const t of tasks) if (t.first) row(t.task_type).tasks++;
   for (const s of steers) {
@@ -322,6 +394,8 @@ function buildSteers(tasks, steers, agents) {
     const type = (taskId && typeOfTask.get(taskId)) || s.task_type || (a && a.task_type) || 'untagged';
     const r = row(type);
     const id = steerIdOf(s);
+    const execPhase = a ? a.role === 'exec' : !(taskId && typeOfTask.has(taskId) && !execTask.has(taskId));
+    if (!execPhase) { r._plan.add(id); continue; }
     if (r._ids.has(id)) continue;
     r._ids.add(id);
     r.actions++;
@@ -334,6 +408,7 @@ function buildSteers(tasks, steers, agents) {
       task_type: r.task_type, tasks: r.tasks, steered_tasks: steered, actions: r.actions,
       minor: r.minor, plan: r.plan, redirect: r.redirect,
       steer_rate: r.tasks ? round6(Math.min(1, steered / r.tasks)) : 0,
+      plan_phase_actions: Array.from(r._plan).filter((x) => !r._ids.has(x)).length,
     };
     return outRow;
   }).sort((a, b) => b.steer_rate - a.steer_rate || a.task_type.localeCompare(b.task_type));
@@ -345,7 +420,8 @@ function finiteNum(v) {
 
 /**
  * Orchestration cost (CONTRACT "Thước đo" mục 6). Sessions = distinct non-empty `session_id` over
- * dispatch events. Per session: ctx = max orch_ctx_tokens, usd = max orch_cum_usd, growth = max of
+ * dispatch events. Per session: ctx = max orch_ctx_tokens, usd = max orch_cum_usd minus orch_cum_usd of the
+ * session's first dispatch carrying a number (core 0.4.0; never negative), growth = max of
  * max(0, orch_ctx_tokens - orch_ctx_baseline) over dispatches carrying both, comp = max orch_compactions
  * (numbers only). compactions_total = sum of per-session comp, compactions_max = max.
  * Each agent belongs to the session of its FIRST dispatch (file order); sub_usd_total sums the
@@ -357,11 +433,14 @@ function orchestrationSummary(events) {
   for (const ev of events) {
     if (!ev || ev.kind !== 'dispatch' || typeof ev.session_id !== 'string' || !ev.session_id) continue;
     const sid = ev.session_id;
-    if (!sessions.has(sid)) sessions.set(sid, { ctx: null, usd: null, growth: null, comp: null });
+    if (!sessions.has(sid)) sessions.set(sid, { ctx: null, usd: null, base: null, growth: null, comp: null });
     const s = sessions.get(sid);
     const c = finiteNum(ev.orch_ctx_tokens);
     const u = finiteNum(ev.orch_cum_usd);
     if (c !== null && (s.ctx === null || c > s.ctx)) s.ctx = c;
+    // core 0.4.0: orchestrator cost counts from the session's FIRST dispatch carrying a number (file order),
+    // not from session start — whatever the session did before it started dispatching is not orchestration.
+    if (u !== null && s.base === null) s.base = u;
     if (u !== null && (s.usd === null || u > s.usd)) s.usd = u;
     const k = finiteNum(ev.orch_compactions);
     if (k !== null && (s.comp === null || k > s.comp)) s.comp = k;
@@ -386,7 +465,7 @@ function orchestrationSummary(events) {
     if (s.ctx !== null) ctxs.push(s.ctx);
     if (s.growth !== null) growths.push(s.growth);
     if (s.comp !== null) comps.push(s.comp);
-    if (s.usd !== null) orch += s.usd;
+    if (s.usd !== null) orch += Math.max(0, s.usd - s.base);
   }
   return {
     sessions: sessions.size,
@@ -403,7 +482,7 @@ function orchestrationSummary(events) {
 }
 
 function analyze(events, opts) {
-  const { agents, userVerdicts, overrides, steers } = buildAgents(events);
+  const { agents, userVerdicts, overrides, steers } = buildAgents(withoutDiscarded(events));
   const tasks = buildTasks(agents, userVerdicts);
   const cells = buildCells(tasks, opts);
   return {
@@ -413,6 +492,6 @@ function analyze(events, opts) {
 }
 
 module.exports = {
-  MIN_N, FAIL_OUTCOMES, HEAVY_STEERS, CANONICAL_CELL_FIELDS, normalizeVerdict, isInternalComplete, buildAgents, buildTasks,
+  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,
 };

package/lib/choose.cjs

@@ -17,9 +17,11 @@ const LADDER = [
   { model: 'opus', effort: 'medium' },
 ];
 const TOP = LADDER.length - 1;
+const HELPER_TOP = 4; // sonnet/high: ceiling for role=helper (gen-2)
 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.
+// Built-in defaults = skill/profile/profile.json for the fixed task types (time caps as tuned 2026-10-12: feature-impl 80,
+// content-write 40, debug 55 — the old ones sat below the observed p50); used only when no profile is found.
 const DEFAULT_PRIORS = {
   search: 'haiku/medium',
   extract: 'haiku/medium',
@@ -38,13 +40,13 @@ const DEFAULT_TIME_CAP_MIN = {
   search: 3,
   extract: 5,
   'mechanical-edit': 10,
-  'feature-impl': 25,
-  debug: 25,
+  'feature-impl': 80,
+  debug: 55,
   refactor: 30,
   'test-write': 15,
   review: 10,
   'research-synth': 20,
-  'content-write': 15,
+  'content-write': 40,
   'plan-design': 15,
   'data-analysis': 15,
 };
@@ -187,25 +189,35 @@ const OPUS_MEDIUM = 5;
  * - 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 the opus/medium ceiling -> 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.
+ * Fail = agent fail|timeout or user reject cause=quality. Core 0.4.0: every result counts, so a retry by
+ * SendMessage to the same agent (fail, then fail again) is two fails at that tier; `aborted` (quota pause)
+ * is never a result. 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)
+    .filter((a) => a.role !== 'verify' && !a.steered)
+    .map((a) => ({
+      a,
+      i: tierIndex(a.model, a.effort),
+      results: Array.isArray(a.results) ? a.results : (a.eff_outcome ? [{ outcome: a.eff_outcome, ts: a.ts, idx: 0 }] : []),
+    }))
+    .filter((x) => x.i !== null && x.results.length)
     .sort((x, y) => (x.a.try - y.a.try) || (x.a.ts - y.a.ts));
   if (!att.length) return none;
+  const res = [];
+  for (const x of att) {
+    const rs = x.results.slice().sort((p, q) => (p.ts - q.ts) || ((p.idx || 0) - (q.idx || 0)));
+    for (const r of rs) res.push({ i: x.i, outcome: r.outcome });
+  }
   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 totalFails = res.filter((r) => r.outcome === 'fail').length;
+  const last = res[res.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 (last.outcome !== 'fail') return Object.assign(base, { floor: cur, note: null });
+  const fails = res.filter((r) => r.i === cur && r.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` });
   }
@@ -287,6 +299,40 @@ function estimateFor(idx, cell, pricing) {
   return roughEstimate(idx, 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',
+};
+
+/**
+ * { type, known, mapped_from, warning }: a fixed/extra type passes; an ad-hoc label with a known alias target
+ * maps to it (with a warning); anything else stays unknown (choose asks the user to pick a fixed type).
+ */
+function resolveTaskType(raw, profile) {
+  const t = String(raw || '').toLowerCase();
+  const extra = (profile && profile.extra_task_types) || [];
+  const isKnown = (x) => core.TASK_TYPES.includes(x) || extra.includes(x);
+  if (isKnown(t)) return { type: t, known: true, mapped_from: null, warning: null };
+  const target = TYPE_ALIASES[t];
+  if (target && isKnown(target)) {
+    return { type: target, known: true, mapped_from: t, warning: `loại "${t}" không cố định → dùng "${target}" (ghi --type ${target} trong thẻ)` };
+  }
+  const list = core.TASK_TYPES.concat(extra).join(', ');
+  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` };
+}
+
 // ------------------------------------------------------------------ choose
 
 /**
@@ -296,8 +342,8 @@ function estimateFor(idx, cell, pricing) {
  * 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 rawType = String(opts.type || '').toLowerCase();
+  if (!rawType) 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');
@@ -327,12 +373,15 @@ function choose(opts) {
   const notes = [];
 
   const analysis = agg.analyze(opts.events || [], { lambda });
-  const known = core.TASK_TYPES.includes(type) || profile.extra_task_types.includes(type);
+  const rt = resolveTaskType(rawType, profile);
+  const type = rt.type;
+  const known = rt.known;
+  if (rt.warning) notes.push(rt.warning);
   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`);
+    if (known) notes.push('không có prior, dùng opus/medium');
   }
   const ov = overridePrior(analysis.overrides, type);
   if (ov && ov.tier !== prior) {
@@ -370,7 +419,10 @@ function choose(opts) {
     && shortModel(c.model) === LADDER[i].model && c.effort === LADDER[i].effort) || null;
 
   const src = profile.source || 'builtin';
-  const finish = (idx, reason, explored, extra) => {
+  const finish = (idx0, reason0, explored, extra) => {
+    // core 0.5.0: a gen-2 helper (spawned by a dp-exec) is haiku|sonnet only — clamp to sonnet/high
+    const idx = role === 'helper' ? Math.min(idx0, HELPER_TOP) : idx0;
+    const reason = idx === idx0 ? reason0 : `${reason0}; helper: trần ${tierName(HELPER_TOP)}`;
     const t = LADDER[idx];
     const cell = cellAt(idx);
     return Object.assign({
@@ -382,10 +434,17 @@ function choose(opts) {
       explored,
       tier: tierName(idx),
       role,
+      task_type: type,
       budget_s: budgetFor(cell),
-    }, estimateFor(idx, cell, opts.pricing), { profile_source: src }, extra || {});
+    }, estimateFor(idx, cell, opts.pricing), { profile_source: src },
+    rt.mapped_from ? { mapped_from: rt.mapped_from } : {}, rt.warning ? { type_warning: rt.warning } : {}, extra || {});
   };
 
+  // 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 });
+  }
+
   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(', ')}).`);
   }
@@ -474,4 +533,5 @@ 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,
 };