@kienntpixon/dieu-phoi 0.7.2 → 0.7.4

package/lib/aggregate.cjs

@@ -574,9 +574,27 @@ function analyze(events, opts) {
   };
 }
 
+/**
+ * core 0.7.4 (s1): one sample per task that has a first exec attempt (excluded tasks left out). `model`/`effort` are
+ * that attempt's (the cell buildCells uses), `handoff` = some segment of that attempt's chain ended on an auto-handoff,
+ * `total_cost` = the task's cost over all segments. Only plan-table's TÁCH? warning reads these; it is advice, not a gate.
+ */
+function handoffSamples(events) {
+  const { agents, userVerdicts, autoVerdicts } = buildAgents(withoutDiscarded(events));
+  return buildTasks(agents, userVerdicts, autoVerdicts)
+    .filter((t) => t.first && !t.excluded)
+    .map((t) => ({
+      task_type: t.task_type,
+      model: t.first.model,
+      effort: t.first.effort,
+      handoff: t.first_chain.some((a) => a.handoff),
+      total_cost: t.total_cost,
+    }));
+}
+
 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, isBatchVerify, batchVerifyCells, orchestrationSummary, analyze, cellKey, mean, percentile, tsOf, steerIdOf,
+  buildCells, buildSteers, canonicalCells, isBatchVerify, batchVerifyCells, orchestrationSummary, analyze, handoffSamples, cellKey, mean, percentile, tsOf, steerIdOf,
 };
 
 // ------------------------------------------------------------------ core 0.7.0 (s2): stats split by mode
@@ -584,7 +602,7 @@ module.exports = {
 // 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 MODE_KEYS = ['fast', 'normal']; // legacy 'strict' dispatches count as normal (0.7.4)
 const NO_CATCH_VERIFY = new Set(['self', 'none']);
 
 /**

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

package/lib/cbm.cjs

@@ -117,9 +117,15 @@ function binArgv(bin, args) {
   return /\.c?js$/i.test(bin) ? [process.execPath, [bin, ...args]] : [bin, args];
 }
 
+/** Timeout (ms) of a cbm sub-process; env override DIEU_PHOI_CBM_<name>_TIMEOUT_MS (tests under heavy load), default unchanged. */
+function cbmTimeout(name, dflt) {
+  const n = Number(process.env[`DIEU_PHOI_CBM_${name}_TIMEOUT_MS`]);
+  return Number.isFinite(n) && n > 0 ? n : dflt;
+}
+
 function probeVersion(bin, timeoutMs) {
   const [cmd, args] = binArgv(bin, ['--version']);
-  const r = cp.spawnSync(cmd, args, { encoding: 'utf8', timeout: timeoutMs || 3000, windowsHide: true });
+  const r = cp.spawnSync(cmd, args, { encoding: 'utf8', timeout: timeoutMs || cbmTimeout('PROBE', 3000), windowsHide: true });
   if (r.error || r.status !== 0) return null;
   const m = /(\d+\.\d+\.\d+)/.exec(`${r.stdout || ''}`);
   return m ? m[1] : null;
@@ -275,7 +281,7 @@ function doctorChecks({ claudeDir, repo, net, deep, cacheFile, env, now }) {
   const version = probeVersion(found.path);
   const wantDaemon = !!(deep || net);
   const cached = wantDaemon ? null : readDaemonCache(cacheFile, found.path, version, nowMs);
-  const daemonP = wantDaemon ? daemonStatus(found.path, 5000) : Promise.resolve(null);
+  const daemonP = wantDaemon ? daemonStatus(found.path, cbmTimeout('DAEMON', 5000)) : Promise.resolve(null);
   const latestP = net ? latestVersion(e).then((v) => ({ v }), (err) => ({ err: err.message })) : Promise.resolve(null);
   return (async () => {
     add(!!version && regs.length > 0, 'codebase-memory', `${version ? `v${version}` : 'không chạy được `--version`'} tại ${toSlash(found.path)} (${found.source})${regs.length

package/lib/choose.cjs

@@ -145,6 +145,7 @@ function loadProfile(skillDir) {
   return {
     source, dept: r.dept || null, priors, lambda, explore_rate: explore, time_cap_min: timeCap, extra_task_types: extra,
     orch_ctx_soft_cap: softCap, tier_floor: tierFloor,
+    batch_verify_normal: r.batch_verify_normal !== false,
   };
 }
 
@@ -334,23 +335,26 @@ function resolveTaskType(raw, profile) {
 
 // ------------------------------------------------------------------ verify plan (core 0.7.0, mode per request)
 
-const VERIFY_PLANS = ['independent-blocking', 'independent-nonblocking', 'self+batch', 'spot'];
+const VERIFY_PLANS = ['independent-blocking', 'independent-nonblocking', 'self+batch'];
 /** 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;
-
+/** normal (0.7.4, user decision Q1): s<=4 with no step depending on it -> self+batch (one verifier per group, not per step). */
+const NORMAL_BATCH_MAX = 4;
 /**
  * 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' }.
+ * always get an independent blocking verifier. Only after that does fast loosen it, and normal batch the s<=4 steps.
+ * Legacy mode `strict` (removed 0.7.4) reads as normal.
+ * opts: { mode, score, verifiable, reversible, publish, dependents, batchNormal, seed }
+ *   batchNormal === false (profile.batch_verify_normal=false) switches the normal batch off (rollback switch).
+ * Returns { verify_plan, verify_reason, verify_floor: string[], test_scope: 'full' | 'selective' }. Step verification (exec, independent
+ * verifier, batch verifier) always runs the touched-module tests; the full suite runs once at the release gate, not here.
+ * test_scope is 'full' only for a publish/deploy step (that step is the release gate's trigger); every other step is 'selective'.
  */
 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 mode = core.normMode(opts.mode || core.DEFAULT_MODE);
+  if (!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');
@@ -358,23 +362,24 @@ function verifyPlanFor(opts) {
   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 (floor.length) return out('independent-blocking', `sàn an toàn (${floor.join(', ')}) → verifier độc lập chặn bước, mọi mode`, opts.publish === true ? 'full' : 'selective');
   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');
+      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 test chọn lọc của các file cả nhóm đã đụng; full suite chỉ ở cổng phát hành`, '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');
+        ? 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`, 'selective')
+        : 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)`, 'selective');
     }
   }
-  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');
+  if (mode === 'normal' && score <= NORMAL_BATCH_MAX && opts.batchNormal !== false) {
+    if (opts.dependents !== true) {
+      return out('self+batch', `normal, s${score}≤${NORMAL_BATCH_MAX}, không bước nào phụ thuộc: exec tự kiểm (test chọn lọc theo file đổi, --verify self); verifier gộp chạy test chọn lọc của các file cả nhóm đã đụng (một lần cuối nhóm, trước cổng 3); full suite chỉ ở cổng phát hành`, 'selective');
+    }
+    return out('independent-blocking', `normal, s${score}: bước sau phụ thuộc (depends_on) vào bước này → verifier độc lập chặn`, 'selective');
   }
-  return out('independent-blocking', `${mode}: verifier độc lập chặn bước`, 'full');
+  return out('independent-blocking', `${mode}: verifier độc lập chặn bước`, 'selective');
 }
 
 // ------------------------------------------------------------------ choose
@@ -412,14 +417,14 @@ 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)) {
+  if (opts.mode !== undefined && opts.mode !== null && !core.normMode(opts.mode)) {
     throw new Error(`--mode phải là ${core.MODES.join('|')} (nhận "${opts.mode}")`);
   }
-  const mode = opts.mode || core.DEFAULT_MODE;
+  const mode = core.normMode(opts.mode || core.DEFAULT_MODE);
+  const profile = opts.profile || loadProfile(null);
   const vp = role === 'exec'
-    ? verifyPlanFor({ mode, score, verifiable, reversible, publish: opts.publish === true, dependents: opts.dependents === true, seed: opts.seed })
+    ? verifyPlanFor({ mode, score, verifiable, reversible, publish: opts.publish === true, dependents: opts.dependents === true, batchNormal: profile.batch_verify_normal, seed: opts.seed })
     : null;
-  const profile = opts.profile || loadProfile(null);
   const lambda = profile.lambda[urgency];
   const rng = makeRng(opts.seed);
   const notes = [];