@kienntpixon/dieu-phoi 0.6.1 → 0.7.0

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));
@@ -173,7 +183,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 +200,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,6 +278,10 @@ 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);
@@ -283,6 +304,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)),
@@ -309,11 +333,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 +361,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 +391,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 +522,102 @@ 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),
   };
 }
 
 module.exports = {
-  MIN_N, FAIL_OUTCOMES, HEAVY_STEERS, ABORTED, QUOTA_REASON_RE, HANDOFF_REASON_RE, discardedTaskIds, withoutDiscarded, 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, isSelf, isInternalComplete, buildAgents, buildTasks,
   buildCells, buildSteers, canonicalCells, 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

@@ -334,10 +334,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 +414,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);
@@ -436,6 +489,11 @@ function choose(opts) {
       tier: tierName(idx),
       role,
       task_type: type,
+      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 || {});
@@ -535,5 +593,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,
+  TYPE_ALIASES, resolveTaskType, verifyPlanFor, VERIFY_PLANS,
 };