@kienntpixon/dieu-phoi 0.7.0 → 0.7.1

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog — @kienntpixon/dieu-phoi
 
+## 0.7.1 (2026-10-26)
+
+Đề xuất core C1–C6 của retro 2026-10-26 (run 4b3mohix, task fgcq8dl9). `CORE_VERSION` 0.7.1; đi cùng skill 1.6.1.
+**Thứ tự phát hành:** deploy Code.gs bản mới (cột `batch`, C5) TRƯỚC, rồi `npm i -g` + `dieu-phoi setup`.
+
+- **`setup`: matcher `Agent|Task`** (task y5lcc5vx): hook PostToolUse/PreToolUse đăng ký cho cả tên công cụ `Agent` (Claude Code hiện tại) lẫn `Task`
+  (bản cũ). Đăng ký cũ chỉ `Agent` không còn tính là "đã đăng ký" → `setup` viết lại (không nhân đôi); `doctor` nhận cả hai.
+
+- **C5 — verifier gộp là ô riêng** (task meq4adm7): agent `role=verify` có `batch:true` (thẻ `|batch`) không còn cộng chi phí/thời gian
+  vào task mang `task_id` của nó (tức ô `task_type × tier` của bước fast cuối) — ở cả `aggregate` lẫn `sheet/Code.gs` (cột mới `batch`).
+  `stats --json`/`retro --json` thêm `batch_verify: [{model, effort, n, tasks, cost_total_usd, cost_mean_usd, cost_p50_usd,
+  time_mean_min, time_p50_min}]` (CLI-only, ngoài parity); `stats` in bảng "verifier gộp", `retro` thêm một dòng. Thống kê theo mode
+  (`verify_min`…), `sub_usd_total`, `totals.cost_usd` vẫn tính nó. Dữ liệu cũ (không `batch`) không đổi số. **Sink: dán lại Code.gs**
+  (≈ 39 KB → minify khi deploy qua gws); Code.gs cũ làm rơi `batch` nên ô sink còn lệch CLI tới khi deploy.
+- **C6 — delta knowledge chưa gộp + `repo:` tên ngắn** (task 1l9as0f3): `start` (khối hook, bản chữ, `--json` `unmerged_deltas`) và `state` (dòng cuối, `--json`)
+  cảnh báo `knowledge_delta: N file delta chưa gộp quá 24h …` khi có `knowledge-delta*.md` tuổi 24 h–30 ngày mà hash không nằm trong sổ `applied` của kho nào
+  (quét ~20 ms, chỉ đọc file). `knowledge merge`: header `repo:` nhận tên ngắn/basename (`pff-tailor`) nếu khớp đúng một kho đã biết (`name`, tên thư mục kho hoặc
+  basename của `roots`); HEAD từ `head:`, `roots` (mới: `meta.json` ghi checkout chính sau mỗi lần gộp có đổi) hoặc `--repo`; khớp ≥ 2 kho hoặc không khớp → lỗi rõ ràng.
+  File delta mà mọi mục đều "không đổi" nay cũng được ghi vào `applied` (để hết cảnh báo; test `knowledge-idem` cập nhật: meta.json chỉ thêm sổ `applied`).
+  Delta cũ gộp trước khi có sổ sẽ còn bị cảnh báo đến khi chạy `knowledge merge` một lần (idempotent, thành "không đổi").
+- **C4 — sàn tier theo sở thích (`tier_floor`)**: profile.json có thể ghi `tier_floor {task_type: "model/effort"}`; `choose` lấy
+  max(sàn này, sàn an toàn, leo thang), không thăm dò xuống dưới, Thompson không chọn ô thấp hơn dù dữ liệu nghiêng về ô rẻ hơn.
+  Chỉ siết (trên trần → kẹp opus/medium; ngoài thang → bỏ). `--override`/`--approved` thấp hơn sàn vẫn giữ, có ghi chú.
+- **C3 — telemetry của `choose`**: kết quả có thêm `score`, `reason_code` (`thompson | floor | escalation | prior | user-prior | explore |
+  plan | override | ask | unknown-type`), `thompson_score`; bản ghi `data/suggest/*.json` lưu `choose_task_type`, `choose_score`, `explored`,
+  `reason_code`, `thompson_score`, dispatch chép thành `choose_*` (chỉ ở máy). Thẻ ghi loại khác loại đã hỏi `choose` → `choose_type_mismatch:true`
+  + PostToolUse nhắc điều phối viên.
+- **C2 — bí danh task_type trong hook**: bảng bí danh dời sang hook.cjs (`TYPE_ALIASES`, `choose` dùng chung) và thêm
+  `scan`/`read`/`code-read`/`explore`/`scout`/`lookup` → `search`. Thẻ dispatch mang nhãn có bí danh (vd. `architecture`, `shell`, `config`,
+  `deploy`) được ghi `task_type` = loại đích, `tag_issue=aliased` + `type_alias_from` thay cho `bad-type` (số liệu gộp vào ô đúng).
+- **C1 — trần phiên/chuỗi handoff**: cảnh báo PostToolUse dời về handoff **thứ 2** (`HANDOFF_CHAIN_WARN=2`); hook PreToolUse(Agent) mới
+  (setup đăng ký thêm, `doctor` mục `chain-gate`) **từ chối** lượt exec tiếp nối của task đã handoff ≥ 3 lần (sự kiện `gate` `deny`,
+  `reason_code=handoff-chain`, `agent_id=task:<id>`) trừ khi thẻ có `|chain_ok` (dispatch ghi `chain_ok:true`); trong subagent không áp.
+  `ctx`/`choose`: context > 400k hoặc ≥ 5 lần nén → `new_session:true` (`choose`: `orch_new_session`), `over:true`, advice "mở phiên mới
+  + `state`" thay cho `/compact`. Thẻ cũng nhận cờ `|batch` (C5). **Cần chạy lại `dieu-phoi setup`.**
+
 ## 0.7.0 (2026-10-23)
 
 `CORE_VERSION` 0.7.0; đi cùng skill 1.6.0. Chế độ `fast | normal | strict` theo yêu cầu (nhánh `fast-mode`, kế hoạch hzgqonzr; egm0w7mx, ue15wumm, d1m3rg7s). Sự kiện `mode` chỉ ở máy, không gửi sink. `sheet/Code.gs` ĐỔI ở phần dữ liệu học fast (d1m3rg7s): **deploy Apps Script trước khi phát hành CLI** (sink cũ đọc `by=auto` thành verdict agent).

package/hook.cjs

@@ -26,7 +26,7 @@ const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
 
-const CORE_VERSION = '0.7.0';
+const CORE_VERSION = '0.7.1';
 const SCHEMA = 1;
 const TASK_TYPES = [
   'search', 'extract', 'mechanical-edit', 'feature-impl', 'debug', 'refactor',
@@ -270,6 +270,10 @@ function parseTag(text) {
       tag.role = mm[1];
     } else if ((mm = /^parent=([A-Za-z0-9_-]{1,32})$/.exec(p))) {
       tag.parent_task_id = mm[1]; // core 0.5.0: gen-2 helper -> the dp-exec step that spawned it
+    } else if (p === 'chain_ok') {
+      tag.chain_ok = true; // core 0.7.1 (C1): the user agreed to continue a long handoff chain
+    } else if (p === 'batch') {
+      tag.batch = true; // core 0.7.1 (C5): the one batched verifier of a fast request
     }
   }
   return tag;
@@ -311,6 +315,24 @@ function taskIdError(id) {
 
 const DEFAULT_EXTRA_TYPES = ['art-gen'];
 
+// Ad-hoc labels seen in real logs → the closest fixed type (core 0.4.0 in choose; core 0.7.1: shared with the hook so a
+// dispatch tag with such a label is mapped too, tag_issue=aliased instead of bad-type). 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',
+  // retro 2026-10-26 (C2): scout/read labels
+  scan: 'search', read: 'search', 'code-read': 'search', explore: 'search', scout: 'search', lookup: 'search',
+};
+
 /** Fixed task types + the profile's extra_task_types (art-gen when no profile is readable). */
 function knownTaskTypes(ctx) {
   const out = TASK_TYPES.concat(DEFAULT_EXTRA_TYPES);
@@ -350,10 +372,19 @@ function resolveTag(text, known) {
   // an id, not a label: id format, not a known type, and a digit or a run-file / task= mention ("planning" is a label)
   const named = new RegExp(`(?:dp-out-|handoff-|task=)${escRe(head)}(?![a-z0-9])`).test(body.slice(first.length));
   const idLike = TASK_ID_RE.test(head) && !types.includes(head) && (/\d/.test(head) || named);
+  let aliased = null;
   if (idLike) issues.push('type-is-id');
   else if (!types.includes(head)) {
-    issues.push('bad-type');
-    tag.bad_type = parts[0]; // the offending token (task_type may be replaced by a valid altType below)
+    const target = Object.prototype.hasOwnProperty.call(TYPE_ALIASES, head) ? TYPE_ALIASES[head] : null;
+    if (target && types.includes(target)) {
+      // core 0.7.1 (C2): a known ad-hoc label maps to its fixed type; the data pools instead of being lost
+      issues.push('aliased');
+      aliased = target;
+      tag.type_alias_from = parts[0];
+    } else {
+      issues.push('bad-type');
+      tag.bad_type = parts[0]; // the offending token (task_type may be replaced by a valid altType below)
+    }
   }
   if (!tag.task_id) {
     issues.push('missing-task');
@@ -362,7 +393,8 @@ function resolveTag(text, known) {
       tag.task_id_inferred = true;
     }
   }
-  if (idLike || tag.task_type === 'untagged') tag.task_type = altType || 'untagged';
+  if (aliased) tag.task_type = aliased;
+  else if (idLike || tag.task_type === 'untagged') tag.task_type = altType || 'untagged';
   else if (!types.includes(tag.task_type) && altType) tag.task_type = altType;
   if (issues.length) tag.tag_issue = issues.join('+');
   return tag;
@@ -375,6 +407,7 @@ function tagIssueMessage(tag, known) {
   const codes = tag.tag_issue.split('+');
   if (codes.includes('no-tag')) what.push('agent dp-* được giao mà không có thẻ `[dp:...]` ở dòng đầu prompt');
   if (codes.includes('type-is-id')) what.push('ô đầu của thẻ là một task id, không phải loại task');
+  if (codes.includes('aliased')) what.push(`loại "${tag.type_alias_from}" không cố định — hook đã ghi thành "${tag.task_type}" (dùng đúng loại này trong thẻ)`);
   if (codes.includes('bad-type')) what.push(`loại "${tag.bad_type || tag.task_type}" không nằm trong danh sách loại hợp lệ`);
   if (codes.includes('missing-task')) what.push('thiếu `task=<id>`');
   const got = tag.task_id_inferred
@@ -1545,11 +1578,14 @@ function startInfo(ctx, cwd) {
   };
   const k = startKnowledgeOf(cwd);
   if (k) info.knowledge = k;
+  const d = scanUnmergedDeltas();
+  if (d.count) info.unmerged_deltas = d;
   return info;
 }
 
 function knowledgeLines(info) {
-  return info && info.knowledge && Array.isArray(info.knowledge.lines) ? info.knowledge.lines : [];
+  const own = info && info.knowledge && Array.isArray(info.knowledge.lines) ? info.knowledge.lines : [];
+  return own.concat(unmergedDeltaLines(info && info.unmerged_deltas));
 }
 
 function orchLessonLines(info) {
@@ -1633,6 +1669,12 @@ function recordSuggestion(ctx, rec) {
     source: prev && prev.suggested_tier ? prev.source : (rec.source || 'choose'),
     ts: nowIso(),
   };
+  // core 0.7.1 (retro 2026-10-26, C3): why choose answered that tier, copied onto the dispatch as choose_*
+  for (const [k, ok] of [['choose_task_type', (v) => typeof v === 'string' && v.length <= 40],
+    ['choose_score', (v) => typeof v === 'number' && isFinite(v)], ['explored', (v) => typeof v === 'boolean'],
+    ['reason_code', (v) => typeof v === 'string' && v.length <= 24], ['thompson_score', (v) => typeof v === 'number' && isFinite(v)]]) {
+    if (ok(rec[k])) out[k] = rec[k];
+  }
   try {
     fs.mkdirSync(ctx.paths.suggest, { recursive: true });
     writeFileAtomic(file, `${JSON.stringify(out)}\n`);
@@ -1666,9 +1708,11 @@ function pruneSuggest(ctx) {
 // ------------------------------------------------------------------ core 0.5.3: handoff chains (retro 2026-10-22)
 //
 // 15/63 feature-impl tasks handed off >= 2 times (19% of feature-impl cost); one chain ran 10 handoffs ($70) and
-// failed. From the 3rd handoff of a task the orchestrator is told to stop continuing and have a planner re-split.
+// failed. Core 0.7.1 (retro 2026-10-26, C1): the warning moves to the 2nd handoff (matching the lesson "stop after the
+// 2nd"), and from the 3rd the global PreToolUse(Agent) gate denies another exec continuation unless the tag has chain_ok.
 
-const HANDOFF_CHAIN_WARN = 3;
+const HANDOFF_CHAIN_WARN = 2;
+const HANDOFF_CHAIN_DENY = 3;
 
 /** Number of agents whose `complete` event has handoff:true for this task (substring scan of events.jsonl). */
 function countTaskHandoffs(ctx, taskId) {
@@ -1692,7 +1736,7 @@ function countTaskHandoffs(ctx, taskId) {
 }
 
 function handoffChainMessage(taskId, n) {
-  return `dieu-phoi: task ${taskId} đã handoff ${n} lần (trần ${HANDOFF_CHAIN_WARN}). Đừng nối tiếp thêm: nếu agent vừa giao là agent tiếp nối, cân nhắc dừng nó và giao planner (dp-scout) đọc handoff-${taskId}.md rồi chia phần còn lại thành bước mới (task_id mới từ \`dieu-phoi new-id\`).`;
+  return `dieu-phoi: task ${taskId} đã handoff ${n} lần (cảnh báo từ ${HANDOFF_CHAIN_WARN}; từ ${HANDOFF_CHAIN_DENY} hook chặn lượt exec tiếp nối, trừ thẻ có \`chain_ok\` khi người dùng đồng ý). Đừng nối tiếp thêm: nếu agent vừa giao là agent tiếp nối, cân nhắc dừng nó và giao planner (dp-scout) đọc handoff-${taskId}.md rồi chia phần còn lại thành bước mới (task_id mới từ \`dieu-phoi new-id\`).`;
 }
 
 // ------------------------------------------------------------------ core 0.7.0: mode per request (fast | normal | strict)
@@ -2421,6 +2465,135 @@ function relatedStatus(r) {
   return { name: r.name, rel: r.rel, n, counts: freshCounts(hit.sections), text: `${knowledgeSummary({ sections: hit.sections }, n)} (cache)` };
 }
 
+// ---- retro 2026-10-26 (C6): knowledge deltas that nobody merged
+
+const DELTA_WARN_MS = 24 * 3600 * 1000; // younger than this: the session may still be about to accept/merge
+const DELTA_WINDOW_MS = 30 * 24 * 3600 * 1000; // older than this: stale history, not a warning any more
+const DELTA_SCAN_MAX = 300;
+
+/** sha256 of a delta file as `knowledge merge` records it in meta.json `applied` (BOM and CRLF ignored). */
+function deltaHash(text) {
+  return crypto.createHash('sha256').update(String(text).replace(/^/, '').replace(/\r\n?/g, '\n')).digest('hex');
+}
+
+/** The `repo:` header of a delta text (before its first `## `), unquoted; null when absent. */
+function deltaRepoOf(text) {
+  for (const line of String(text).replace(/^/, '').split(/\r?\n/)) {
+    if (/^##\s/.test(line)) return null;
+    const m = /^\s*repo\s*:\s*(.+?)\s*$/i.exec(line);
+    if (m) return m[1].replace(/[.;,]+$/, '').replace(/^[`"'](.*)[`"']$/, '$1').trim() || null;
+  }
+  return null;
+}
+
+/** A `repo:` value that is a short name (no path separator, no drive), e.g. `pff-tailor`. */
+function isBareRepoName(v) {
+  return typeof v === 'string' && /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(v.trim());
+}
+
+/** Every knowledge store under projectsDir(): { dir_name, dir, name, key, roots, applied:Set<sha256> } — file reads only. */
+function storeCatalog() {
+  const root = projectsDir();
+  let names;
+  try { names = fs.readdirSync(root); } catch (_) { return []; }
+  const out = [];
+  for (const n of names) {
+    const dir = path.join(root, n);
+    if (!isStoreDirName(n) || !isDir(dir)) continue;
+    const meta = readJsonFile(path.join(dir, 'meta.json'), null);
+    const idx = readJsonFile(path.join(dir, 'index.json'), null);
+    if (!meta && !idx) continue;
+    const m = meta && typeof meta === 'object' ? meta : {};
+    const i = idx && typeof idx === 'object' ? idx : {};
+    out.push({
+      dir_name: n,
+      dir: toSlash(dir),
+      name: String(i.name || m.name || n.replace(/-[0-9a-f]{8}$/, '')),
+      key: i.key || (Array.isArray(m.keys) ? m.keys[0] : null) || null,
+      roots: Array.isArray(m.roots) ? m.roots.filter((r) => typeof r === 'string' && r) : [],
+      applied: new Set((Array.isArray(m.applied) ? m.applied : []).map((a) => a && a.sha256).filter(Boolean)),
+    });
+  }
+  return out;
+}
+
+/**
+ * Known store a bare repo name refers to: its `name`, its directory name, or the basename of a recorded root equals
+ * `name` (case-insensitive). { matches, store } — store only when exactly one store matches.
+ */
+function storeByName(name, stores) {
+  const want = String(name).trim().toLowerCase();
+  const matches = (stores || storeCatalog()).filter((s) => s.name.toLowerCase() === want || s.dir_name.toLowerCase() === want
+    || s.roots.some((r) => path.basename(r).toLowerCase() === want));
+  return { matches, store: matches.length === 1 ? matches[0] : null };
+}
+
+/**
+ * Delta files in run dirs that are 24 h .. 30 d old and that no store has applied (hash in meta.json `applied`).
+ * { count, runs: [{ run, n, oldest_ms, repos: { name: n } }], truncated } — never throws; count 0 when all is merged.
+ */
+function scanUnmergedDeltas(opts) {
+  const o = opts || {};
+  const now = o.now || Date.now();
+  const warnMs = o.warnMs === undefined ? DELTA_WARN_MS : o.warnMs;
+  const windowMs = o.windowMs === undefined ? DELTA_WINDOW_MS : o.windowMs;
+  const res = { count: 0, runs: [], truncated: false };
+  try {
+    const runs = runsDir();
+    const applied = new Set();
+    for (const s of storeCatalog()) for (const h of s.applied) applied.add(h);
+    let seen = 0;
+    for (const run of fs.readdirSync(runs)) {
+      const dir = path.join(runs, run);
+      let st;
+      try { st = fs.statSync(dir); } catch (_) { continue; }
+      if (!st.isDirectory() || now - st.mtimeMs > windowMs) continue;
+      let names;
+      try { names = fs.readdirSync(dir); } catch (_) { continue; }
+      const row = { run, n: 0, oldest_ms: 0, repos: {} };
+      for (const f of names) {
+        if (!/^knowledge-delta.*\.md$/i.test(f)) continue;
+        const file = path.join(dir, f);
+        let fst;
+        try { fst = fs.statSync(file); } catch (_) { continue; }
+        const age = now - fst.mtimeMs;
+        if (age < warnMs || age > windowMs) continue;
+        if (seen++ >= DELTA_SCAN_MAX) { res.truncated = true; break; }
+        const text = readTextFile(file);
+        if (text == null || applied.has(deltaHash(text))) continue;
+        const repo = deltaRepoOf(text);
+        const label = repo ? (isBareRepoName(repo) ? repo : path.basename(repo.replace(/[\\/]+$/, ''))) : '?';
+        row.n++;
+        row.oldest_ms = Math.max(row.oldest_ms, age);
+        row.repos[label] = (row.repos[label] || 0) + 1;
+      }
+      if (row.n) { res.runs.push(row); res.count += row.n; }
+      if (res.truncated) break;
+    }
+    res.runs.sort((a, b) => b.n - a.n || b.oldest_ms - a.oldest_ms);
+  } catch (e) {
+    res.error = e.message;
+  }
+  return res;
+}
+
+function ageText(ms) {
+  return ms >= 48 * 3600 * 1000 ? `${Math.floor(ms / 86400000)} ngày` : `${Math.floor(ms / 3600000)} giờ`;
+}
+
+/** One warning line (as an array, empty when nothing is pending) for the start block and `state`. */
+function unmergedDeltaLines(scan) {
+  if (!scan || !scan.count) return [];
+  const oldest = Math.max(...scan.runs.map((r) => r.oldest_ms));
+  const repos = {};
+  for (const r of scan.runs) for (const [k, v] of Object.entries(r.repos)) repos[k] = (repos[k] || 0) + v;
+  const repoText = Object.entries(repos).sort((a, b) => b[1] - a[1]).slice(0, 4).map(([k, v]) => `${k} ×${v}`).join(', ');
+  const runText = scan.runs.slice(0, 3).map((r) => `${r.run} ×${r.n}`).join(', ') + (scan.runs.length > 3 ? ` (+${scan.runs.length - 3} run)` : '');
+  const more = scan.truncated ? ' (chỉ quét một phần)' : '';
+  return [`knowledge_delta: ${scan.count} file delta chưa gộp quá 24h${more} — run ${runText}; kho ${repoText}; cũ nhất ${ageText(oldest)}. `
+    + `Gộp: \`dieu-phoi knowledge merge --run ${scan.runs[0].run} --dry-run\` rồi bỏ --dry-run (hoặc verdict accept); bỏ qua nếu cố ý không gộp.`];
+}
+
 /**
  * Knowledge lines for the start block of the repo at `cwd`; null outside a repo or when the repo has no store.
  * Refreshes this repo only (at most one git diff-tree, on a cache miss, bounded by HOOK_DIFF_TIMEOUT_MS; never git
@@ -2518,6 +2691,9 @@ function buildDispatch(p, ctx) {
     ...(tag.task_id && !isValidTaskId(tag.task_id) ? { task_id_invalid: true } : {}),
     ...(tag.task_id_inferred ? { task_id_inferred: true } : {}),
     ...(tag.tag_issue ? { tag_issue: tag.tag_issue } : {}),
+    ...(tag.type_alias_from ? { type_alias_from: tag.type_alias_from } : {}),
+    ...(tag.chain_ok ? { chain_ok: true } : {}),
+    ...(tag.batch ? { batch: true } : {}),
     task_type: tag.task_type,
     score: tag.score,
     urgency: tag.urgency,
@@ -2543,6 +2719,11 @@ function buildDispatch(p, ctx) {
   commonFields(ctx));
 }
 
+/** core 0.7.1 (C3): the tier came from `choose` for another task type than the tag carries. */
+function chooseTypeMismatchMessage(ev) {
+  return `dieu-phoi: task ${ev.task_id} được \`choose\` tính cho loại "${ev.choose_task_type}" nhưng thẻ ghi "${ev.task_type}" — tier ${ev.choose_tier} có thể không hợp loại này. Lần sau gọi \`choose --type ${ev.task_type}\` (hoặc sửa thẻ cho đúng loại choose trả).`;
+}
+
 /** core 0.7.0: mode of the task at the moment of this dispatch (kept by later tries), only when the tag carries a task_id. */
 function modeFields(ctx, tag) {
   if (!tag || !tag.task_id || !isValidTaskId(tag.task_id)) return {};
@@ -2561,6 +2742,15 @@ function tierFields(ctx, tag, model, effort) {
     dispatched_tier: dispatched,
   };
   if (dispatched && !dispatched.includes('?')) out.tier_mismatch = dispatched !== out.choose_tier;
+  // core 0.7.1 (C3): choose's own inputs/reason, and whether choose was asked about another task type
+  if (typeof s.choose_task_type === 'string') {
+    out.choose_task_type = s.choose_task_type;
+    if (tag.task_type && tag.task_type !== s.choose_task_type) out.choose_type_mismatch = true;
+  }
+  if (typeof s.choose_score === 'number') out.choose_score = s.choose_score;
+  if (typeof s.explored === 'boolean') out.choose_explored = s.explored;
+  if (typeof s.reason_code === 'string') out.choose_reason = s.reason_code;
+  if (typeof s.thompson_score === 'number') out.choose_thompson_score = s.thompson_score;
   return out;
 }
 
@@ -2579,6 +2769,7 @@ function handlePostToolUse(p, ctx) {
     const tag = resolveTag(ti.prompt, known) || { tag_issue: ev.tag_issue, task_id: null, task_type: ev.task_type };
     notes.push(tagIssueMessage(tag, known));
   }
+  if (ev.choose_type_mismatch) notes.push(chooseTypeMismatchMessage(ev));
   if (ev.task_id && ev.role === 'exec') {
     const n = countTaskHandoffs(ctx, ev.task_id);
     if (n) ev.task_handoffs = n;
@@ -3287,6 +3478,36 @@ function gateReserve(dir, child) {
   return 0;
 }
 
+/**
+ * Core 0.7.1 (C1): global PreToolUse(Agent) in the orchestrating session. An exec dispatch of a task that already
+ * handed off HANDOFF_CHAIN_DENY times is denied (the 4th, 5th… segment of one chain cost $15-36 per task in session
+ * 36cee993) unless the tag carries `chain_ok`. Inside a subagent (agent_id) this does nothing: --gate handles gen-2.
+ */
+function handleChainGate(p, ctx) {
+  if (p.tool_name !== 'Agent' && p.tool_name !== 'Task') return null;
+  if (watchAgentId(p)) return null;
+  const ti = p.tool_input && typeof p.tool_input === 'object' ? p.tool_input : {};
+  const tag = resolveTag(ti.prompt, knownTaskTypes(ctx));
+  if (!tag || tag.role !== 'exec' || !tag.task_id || !isValidTaskId(tag.task_id) || tag.chain_ok) return null;
+  const n = countTaskHandoffs(ctx, tag.task_id);
+  if (n < HANDOFF_CHAIN_DENY) return null;
+  const ev = logGate(ctx, p, `task:${tag.task_id}`, { task_id: tag.task_id, role: 'exec' },
+    { gate_action: 'deny', reason_code: 'handoff-chain', children: n });
+  return {
+    denied: true,
+    event: ev,
+    stdout: JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'deny',
+        permissionDecisionReason: `dieu-phoi: task ${tag.task_id} đã handoff ${n} lần (trần ${HANDOFF_CHAIN_DENY}) — không giao thêm exec tiếp nối. `
+          + `Giao planner (dp-scout) đọc handoff-${tag.task_id}.md rồi chia phần còn lại thành bước mới (task_id mới từ \`dieu-phoi new-id\`). `
+          + 'Chỉ khi người dùng đồng ý nối tiếp: thêm `|chain_ok` vào thẻ.',
+      },
+    }),
+  };
+}
+
 /** Mark the reservation of `child` as a real spawn. Returns true when its slot was found. */
 function gateConfirm(ctx, key, child) {
   if (!key || !child) return false;
@@ -3443,6 +3664,7 @@ function runHook(opts) {
     if (o.mode === 'watch') return handleWatch(p, ctx, o); // { stdout } or null
     if (o.mode === 'gate') return handleGate(p, ctx, o); // { stdout } or null
     if (o.mode === 'gate-release') return handleGateRelease(p, ctx); // { released } or null, prints nothing
+    if (name === 'PreToolUse') return handleChainGate(p, ctx); // { stdout } (deny) or null
     if (name === 'SessionStart') return handleSessionStart(p, ctx); // { stdout } or null, never an event
     if (name === 'UserPromptSubmit') return handleUserPromptSubmit(p, ctx); // { stdout } or null
     if (name === 'SubagentStop') ev = handleSubagentStop(p, ctx);
@@ -3600,16 +3822,16 @@ module.exports = {
   modeLine, MODES, DEFAULT_MODE, LOCAL_ONLY_KINDS, MODE_ASK_LINE, isMode, rootModeFromEvents, rootModeFromText, dispatchModeFromEvents, taskModeInfo, planOfTask, modeFields,
   modeSuggestion, modeSuggestLine, fastFailRate, rootTaskIds, FAST_FAIL_WINDOW, FAST_FAIL_MIN_N, FAST_FAIL_RATE,
   testCommandInfo, testTimeOf, testSFromText,
-  CORE_VERSION, SCHEMA, TASK_TYPES, URGENCIES, ROLES, MODEL_ALIASES, UNTAGGED,
+  CORE_VERSION, SCHEMA, TASK_TYPES, URGENCIES, ROLES, MODEL_ALIASES, UNTAGGED, TYPE_ALIASES,
   sha8, nowIso, readJsonFile, writeFileAtomic, renameWithRetry, acquireLock, acquireFileLock, withFileLock, defaultClaudeDir, resolveHome, pathsFor, loadConfig, makeCtx,
   logError, computeUserHash, userHash, commonFields, parseTag, resolveTag, knownTaskTypes, tagIssueMessage, DEFAULT_EXTRA_TYPES,
-  recordSuggestion, readSuggestion, suggestFile, SUGGEST_MAX_AGE_MS, countTaskHandoffs, handoffChainMessage, HANDOFF_CHAIN_WARN, tierFields, TASK_ID_RE, isValidTaskId, newTaskId, taskIdError, normalizeModel, loadPricing,
+  recordSuggestion, readSuggestion, suggestFile, SUGGEST_MAX_AGE_MS, countTaskHandoffs, handoffChainMessage, HANDOFF_CHAIN_WARN, HANDOFF_CHAIN_DENY, handleChainGate, tierFields, TASK_ID_RE, isValidTaskId, newTaskId, taskIdError, normalizeModel, loadPricing,
   priceFor, usageBuckets, requestCost, parseJsonl, readTranscript, lastUuidOf,
   firstPromptText, tagFromTranscript, summarizeTranscript,
   RESULT_ROLES, BLOCKED_RESULT_NAME_RE, resultFileName, findResultFiles, resultRunDir, finalAssistantText, persistInlineResult, orchestratorUsage, orchCacheFile, findSessionTranscript, SESSION_ID_RE, HOOK_COLD_MAX_BYTES, appendEvent, EVENTS_LOCK_WAIT_MS, eventLinesFrom, readEventLines, readEvents, readEventsBuffer, archiveFiles, readArchiveLines,
   loadSyncOffset, saveSyncOffset, recordRejected, unsyncedInfo, loadSegments, saveSegments, segmentFile,
   HANDOFF_MARKER, HANDOFF_THRESHOLDS, watchThresholds, GATE_MAX_CHILDREN, HELPER_AGENT_TYPE, watchAgentId, subagentTranscriptPath, readHeadTag, lastContextTokens, watchState, handoffMessage, handleWatch, handleGate, handleGateRelease, gateDir, gateSlots, gateReserve, gateConfirm, GATE_PENDING_MS,
-  globMatch, pathspecOf, diffShas, dirtyFiles, computeFreshness, addDirty, indexStamp, freshnessCacheFile, readFreshCache, cachedFor, freshCounts, knowledgeSummary, shortFileList, readStoreIndex, relatedStatus, startKnowledge, FRESH_CACHE_MAX, DIFF_TIMEOUT_MS, HOOK_DIFF_TIMEOUT_MS, DIRTY_TIMEOUT_MS,
+  globMatch, pathspecOf, diffShas, dirtyFiles, computeFreshness, addDirty, indexStamp, freshnessCacheFile, readFreshCache, cachedFor, freshCounts, knowledgeSummary, shortFileList, readStoreIndex, relatedStatus, startKnowledge, deltaHash, deltaRepoOf, isBareRepoName, storeCatalog, storeByName, scanUnmergedDeltas, unmergedDeltaLines, DELTA_WARN_MS, FRESH_CACHE_MAX, DIFF_TIMEOUT_MS, HOOK_DIFF_TIMEOUT_MS, DIRTY_TIMEOUT_MS,
   projectsDir, findGit, originUrlFromConfig, normalizeRemoteUrl, resolveProject, readHead, repoFromBrief, projectFields, nativePath, isStoreDirName, aliasesFile, loadAliases, keyDirName,
   extractAgentId, hasAssistantUsage, hasDispatch, buildDispatch, handlePostToolUse, handleSubagentStop, maybeSpawnSync, runHook, runSync,
 };

package/lib/aggregate.cjs

@@ -173,6 +173,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,
@@ -284,7 +286,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 +319,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 || '?'}`;
 }
@@ -528,12 +569,13 @@ function analyze(events, opts) {
   return {
     agents, tasks, cells, overrides, 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/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 = {

package/lib/commands.cjs

@@ -65,7 +65,7 @@ function cmdSetup(opts) {
   const lines = [
     `Đã cài hook: ${res.hook}`,
     res.settings_changed
-      ? `Đã đăng ký PostToolUse(Agent) + SubagentStop + SessionStart(compact) + UserPromptSubmit trong ${res.settings}${res.backup ? ` (sao lưu: ${path.basename(res.backup)})` : ''}`
+      ? `Đã đăng ký PostToolUse(Agent) + SubagentStop + SessionStart(compact) + UserPromptSubmit + PreToolUse(Agent) trong ${res.settings}${res.backup ? ` (sao lưu: ${path.basename(res.backup)})` : ''}`
       : `settings.json đã có hook, không đổi gì (${res.settings})`,
     `Agent dp-*: ${res.agents.map((a) => `${a.name}=${a.action}`).join(', ')}${res.agents.some((a) => a.action === 'skipped-foreign') ? ' (file trùng tên không phải của dieu-phoi: giữ nguyên, đổi tên rồi chạy lại setup)' : ''}`,
     `Thư mục báo cáo subagent: ${res.runs_dir} (quyền: ${res.permissions.allow.join(', ')} + additionalDirectories)`,
@@ -128,6 +128,9 @@ async function cmdDoctor(opts) {
   add(reg.UserPromptSubmit, 'prompt-hook', reg.UserPromptSubmit
     ? 'UserPromptSubmit có — prompt "điều phối" được tạo sẵn task_id + run dir, lượt đầu là scout'
     : 'thiếu hook UserPromptSubmit — mỗi lần điều phối phải chạy `dieu-phoi start` trước scout; chạy lại `dieu-phoi setup`', 'CẢNH BÁO');
+  add(reg.PreToolUse, 'chain-gate', reg.PreToolUse
+    ? 'PreToolUse(Agent) có — chặn exec tiếp nối từ handoff thứ 3 (trừ thẻ chain_ok)'
+    : 'thiếu hook PreToolUse(Agent) (core 0.7.1) — chuỗi handoff dài không bị chặn; chạy lại `dieu-phoi setup`', 'CẢNH BÁO');
   const permOk = reg.permissions && reg.runs_dir_exists && !reg.legacy_permissions;
   add(permOk, 'run-permissions', permOk
     ? `${reg.permission_entries.allow.join(', ')} + additionalDirectories ${reg.permission_entries.dir}`
@@ -726,19 +729,27 @@ function measureOrch(opts, ctx, prof) {
       u = core.orchestratorUsage(file, core.loadPricing(ctx), { cacheFile: core.orchCacheFile(ctx.paths, sid, file) });
     }
   } catch (_) { /* measurement never fails the caller */ }
-  const over = typeof u.ctx_growth === 'number' && u.ctx_growth > softCap;
+  // core 0.7.1 (retro 2026-10-26, C1): past ORCH_NEW_SESSION_TOKENS or ORCH_NEW_SESSION_COMPACTIONS a /compact no longer
+  // helps (session 36cee993: 946k, 20 compactions, 0 user verdicts) -> advise a new session instead.
+  const newSession = (typeof u.ctx_tokens === 'number' && u.ctx_tokens > ORCH_NEW_SESSION_TOKENS)
+    || (typeof u.compactions === 'number' && u.compactions >= ORCH_NEW_SESSION_COMPACTIONS);
+  const over = (typeof u.ctx_growth === 'number' && u.ctx_growth > softCap) || newSession;
   let advice;
   if (!sid) advice = 'Không đo được: không có session (thiếu CLAUDE_CODE_SESSION_ID, dùng --session <id>).';
   else if (u.ctx_tokens === null) advice = 'Không đo được: không thấy transcript của session này.';
-  else if (over) advice = `Context điều phối đã tăng ${u.ctx_growth} token (nền ${u.ctx_baseline}, nay ${u.ctx_tokens}) vượt trần mềm ${softCap}: gõ /compact để nén phiên — trạng thái điều phối sẽ được nạp lại tự động.`;
+  else if (newSession) {
+    advice = `Phiên điều phối đã quá lớn (context ${u.ctx_tokens} token, nén ${u.compactions === null ? '?' : u.compactions} lần; ngưỡng ${ORCH_NEW_SESSION_TOKENS} token hoặc ${ORCH_NEW_SESSION_COMPACTIONS} lần nén): đừng /compact thêm — ghi trạng thái (\`dieu-phoi state --session ${sid}\` + file trạng thái trong run dir), trình cổng 3 phần đã xong, rồi MỞ PHIÊN MỚI và nạp lại từ \`state\`.`;
+  } else if (over) advice = `Context điều phối đã tăng ${u.ctx_growth} token (nền ${u.ctx_baseline}, nay ${u.ctx_tokens}) vượt trần mềm ${softCap}: gõ /compact để nén phiên — trạng thái điều phối sẽ được nạp lại tự động.`;
   else advice = `Context điều phối tăng ${u.ctx_growth}/${softCap} token so với nền ${u.ctx_baseline}, còn trong trần mềm.`;
   return {
     session_id: sid, ctx_tokens: u.ctx_tokens, ctx_baseline: u.ctx_baseline, ctx_growth: u.ctx_growth,
-    cum_usd: u.cum_usd, compactions: u.compactions, soft_cap: softCap, over, advice,
+    cum_usd: u.cum_usd, compactions: u.compactions, soft_cap: softCap, over, new_session: newSession, advice,
   };
 }
 
 const CTX_WARN_KEEP_MS = 14 * 24 * 3600 * 1000;
+const ORCH_NEW_SESSION_TOKENS = 400000;
+const ORCH_NEW_SESSION_COMPACTIONS = 5;
 
 /** 0 = within the cap; 1 = over the cap, 2 = over 2×, 3 = over 4×, … */
 function ctxWarnLevel(growth, cap) {
@@ -808,13 +819,18 @@ function cmdState(opts) {
   const ctx = ctxOf(opts);
   const sid = typeof opts.session === 'string' && opts.session ? opts.session
     : (process.env.CLAUDE_CODE_SESSION_ID || null);
+  // retro C6: knowledge deltas older than 24 h that no store has applied (file reads only, never throws)
+  const deltas = core.scanUnmergedDeltas();
+  const deltaLines = core.unmergedDeltaLines(deltas);
   if (!sid) {
-    if (opts.json) return { code: 0, out: JSON.stringify({ session_id: null, generated_at: core.nowIso(), runs_dir: null, plans: [], tasks: [] }) };
-    return { code: 0, out: 'Không có session (thiếu CLAUDE_CODE_SESSION_ID, dùng --session <id>).' };
+    if (opts.json) {
+      return { code: 0, out: JSON.stringify(Object.assign({ session_id: null, generated_at: core.nowIso(), runs_dir: null, plans: [], tasks: [] }, deltas.count ? { unmerged_deltas: deltas } : {})) };
+    }
+    return { code: 0, out: ['Không có session (thiếu CLAUDE_CODE_SESSION_ID, dùng --session <id>).'].concat(deltaLines).join('\n') };
   }
   const state = core.buildSessionState(core.readEvents(ctx), sid, { plansDir: ctx.paths.plans });
-  if (opts.json) return { code: 0, out: JSON.stringify(state, null, 2) };
-  return { code: 0, out: core.formatSessionState(state, core.STATE_TEXT_CAP) };
+  if (opts.json) return { code: 0, out: JSON.stringify(deltas.count ? Object.assign({}, state, { unmerged_deltas: deltas }) : state, null, 2) };
+  return { code: 0, out: [core.formatSessionState(state, core.STATE_TEXT_CAP)].concat(deltaLines).join('\n') };
 }
 
 // ------------------------------------------------------------------ stats / retro
@@ -832,13 +848,13 @@ function cmdStats(opts) {
   const ctx = ctxOf(opts);
   const { lambda } = lambdaOf(opts, ctx);
   const events = core.readEvents(ctx);
-  const { cells, steers, orchestration, tasks } = agg.analyze(events, { lambda });
+  const { cells, steers, orchestration, tasks, batch_verify: batchVerify } = agg.analyze(events, { lambda });
   const modes = agg.modeSummary(events, tasks);
   const type = typeof opts.type === 'string' ? opts.type : null;
   const rows = type ? cells.filter((c) => c.task_type === type) : cells;
   const steerRows = type ? steers.filter((s) => s.task_type === type) : steers;
   if (opts.json) {
-    return { code: 0, out: JSON.stringify({ lambda_usd_per_min: lambda, min_n: agg.MIN_N, cells: rows, steers: steerRows, orchestration, modes }, null, 2) };
+    return { code: 0, out: JSON.stringify({ lambda_usd_per_min: lambda, min_n: agg.MIN_N, cells: rows, steers: steerRows, orchestration, modes, batch_verify: batchVerify }, null, 2) };
   }
   if (!rows.length) {
     return { code: 0, out: orchestration.sessions ? `Chưa có dữ liệu theo ô.\n${orchLine(orchestration)}` : 'Chưa có dữ liệu.' };
@@ -865,7 +881,7 @@ function cmdStats(opts) {
   }
   return {
     code: 0,
-    out: `${table(t)}\n\n${table(s)}\n\n${modeTable(modes)}${orchLine(orchestration)}\n\n`
+    out: `${table(t)}\n\n${table(s)}\n\n${modeTable(modes)}${batchVerifyTable(batchVerify)}${orchLine(orchestration)}\n\n`
       + 'n = task tính tỉ lệ (/số đã giao, (-k) = bị loại: reject-scope hoặc lượt exec đầu bị steer plan/redirect). '
       + 'accept% = thành công theo verdict người dùng đầu tiên, chưa có thì verdict agent; agent_pass% = chỉ tầng agent. '
       + `E[cost], E[time] tính trọn mọi lượt + review của task. score = E[cost] + λ·p50[time] (trung vị, không dùng TB: thời gian chờ thổi phồng TB), λ=${lambda} USD/phút.`,
@@ -890,6 +906,20 @@ function modeTable(modes) {
   return `${table(t)}\n\n`;
 }
 
+/** core 0.7.1 (C5): the batched verifiers' own cell (model/effort), kept out of the task cells; '' when none. */
+function batchVerifyTable(rows) {
+  if (!rows || !rows.length) return '';
+  const t = [['verifier gộp', 'lần', 'task', 'Σ cost', 'E[cost]', 'p50 cost', 'p50 time']];
+  for (const r of rows) {
+    t.push([
+      `${chooser.shortModel(r.model) || r.model || '?'}/${r.effort || '?'}`, r.n, r.tasks,
+      fmtUsd(r.cost_total_usd), fmtUsd(r.cost_mean_usd), fmtUsd(r.cost_p50_usd),
+      r.time_p50_min === null ? '-' : `${fmtNum(r.time_p50_min)}m`,
+    ]);
+  }
+  return `${table(t)}\n(chi phí verifier gộp là ô riêng, không cộng vào ô task_type × tier của bước fast mang task_id của nó)\n\n`;
+}
+
 /** One retro line: per mode with tasks. */
 function modeRetroLine(modes) {
   const parts = agg.MODE_KEYS.filter((m) => modes[m].tasks).map((m) => {
@@ -906,7 +936,7 @@ function cmdRetro(opts) {
   const ctx = ctxOf(opts);
   const { prof, lambda } = lambdaOf(opts, ctx);
   const events = core.readEvents(ctx);
-  const { agents, tasks, cells, steers, userVerdicts, overrides, orchestration } = agg.analyze(events, { lambda });
+  const { agents, tasks, cells, steers, userVerdicts, overrides, orchestration, batch_verify: batchVerify } = agg.analyze(events, { lambda });
   const modes = agg.modeSummary(events, tasks);
   const reasons = {};
   const outcomes = {};
@@ -964,6 +994,7 @@ function cmdRetro(opts) {
     overrides: overrides.map((o) => ({ ts: o.ts, task_type: o.task_type, suggested_tier: o.suggested_tier, chosen_tier: o.chosen_tier })),
     orchestration,
     modes,
+    batch_verify: batchVerify,
     cells,
   };
   if (opts.json) return { code: 0, out: JSON.stringify(summary, null, 2) };
@@ -977,6 +1008,7 @@ function cmdRetro(opts) {
     `Steer nhiều (brainstorm hỏi quá ít): ${highSteer.map((s) => `${s.task_type} ${pct(s.steer_rate)}`).join(', ') || '-'}`,
     orchLine(orchestration),
     modeRetroLine(modes),
+    ...(batchVerify.length ? [`Verifier gộp (ô riêng): ${batchVerify.map((r) => `${chooser.shortModel(r.model) || r.model || '?'}/${r.effort || '?'} ×${r.n}, Σ ${fmtUsd(r.cost_total_usd)}, p50 ${r.time_p50_min === null ? '-' : `${fmtNum(r.time_p50_min)}m`}`).join(' · ')}`] : []),
     'Chi tiết theo ô: `dieu-phoi stats`; đưa cho LLM: `dieu-phoi retro --json`.',
   ];
   return { code: 0, out: lines.join('\n') };
@@ -1062,6 +1094,7 @@ function cmdChoose(opts) {
   res.orch_ctx_tokens = orch.ctx_tokens;
   res.orch_ctx_growth = orch.ctx_growth;
   res.orch_ctx_over = orch.over;
+  res.orch_new_session = orch.new_session === true;
   res.orch_ctx_warn = ctxWarnOnce(ctx, orch); // over AND a new threshold crossed since the last warning
   if (res.overridden) {
     const tid = input.taskId;
@@ -1072,6 +1105,8 @@ function cmdChoose(opts) {
     core.recordSuggestion(ctx, {
       task_id: input.taskId, role: res.role || input.role, suggested_tier: res.suggested_tier || res.tier, choose_tier: res.tier,
       source: 'choose', keep_suggested: input.approved !== null && !res.overridden,
+      choose_task_type: res.task_type, choose_score: res.score, explored: res.explored, reason_code: res.reason_code,
+      thompson_score: res.thompson_score === null ? undefined : res.thompson_score,
     });
   }
   if (opts.json) return { code: 0, out: JSON.stringify(res) };
@@ -1257,6 +1292,8 @@ function recordPlanSuggestions(ctx, plan) {
     if (!r.task_id || !r.tier || r.action !== 'dispatch') continue;
     const ok = core.recordSuggestion(ctx, {
       task_id: r.task_id, role: r.role || 'exec', suggested_tier: r.suggested_tier || r.tier, choose_tier: r.tier, source: 'plan',
+      choose_task_type: r.task_type, choose_score: r.score, explored: r.explored, reason_code: r.reason_code,
+      thompson_score: r.thompson_score === null ? undefined : r.thompson_score,
     });
     if (ok) n++;
   }

package/lib/knowledge.cjs

@@ -14,6 +14,7 @@
 //
 // Delta (written by agents into a run dir as knowledge-delta*.md, merged at gate 3):
 //   repo: <path of the repo/worktree the delta was checked against>   (header, before the first `## `)
+//         or a short name (`pff-tailor`) that matches exactly one known store (its name / dir name / a recorded root)
 //   head: <sha>                                                         (optional; else HEAD read from repo:)
 //   ## +<id>        new section          ## <id>     replace an existing one
 //   title: / tags: a, b / paths: glob, glob / base: <sha>#<rev>   (meta lines right under the heading)
@@ -27,7 +28,6 @@
 const fs = require('fs');
 const path = require('path');
 const cp = require('child_process');
-const crypto = require('crypto');
 const core = require('../hook.cjs');
 const { repoOf } = require('./args.cjs');
 
@@ -55,7 +55,8 @@ const KNOWLEDGE_HELP = `Cách dùng: dieu-phoi knowledge <lệnh> [--repo <đư
   merge --run <id|thư mục run> [--task <id>[,<id>] [--untagged]] [--dry-run] [--json]
                          gộp mọi knowledge-delta*.md của run (--task: chỉ knowledge-delta-<task_id>[-r<n>].md của các
                          task đó, --untagged: thêm file không mang task_id; verdict accept tự gọi bước này) vào kho của repo ghi ở header "repo:" (không có thì
-                         --repo/cwd): khoá knowledge.lock, ghi tmp+rename, bản cũ vào history/, sha = HEAD của repo đó.
+                         --repo/cwd; "repo:" là tên ngắn như pff-tailor thì khớp kho đã biết nếu duy nhất — HEAD lấy từ repo đã ghi
+                         nhớ (meta.json roots), --repo hoặc dòng head:): khoá knowledge.lock, ghi tmp+rename, bản cũ vào history/, sha = HEAD của repo đó.
                          "## +id" thêm mục (bắt buộc paths:), "## id" thay mục (bắt buộc base: <sha>#<rev>); base cũ
                          → xung đột, không ghi đè; mục > 40 dòng bị từ chối. Có xung đột/từ chối → exit 2.
                          Idempotent: file delta đã gộp (hash trong meta.json) và mục trùng một rev cũ trong history/ → "không đổi"
@@ -609,8 +610,25 @@ function sameContent(cur, body, next) {
 const APPLIED_MAX = 300;
 
 /** sha256 of the delta text, BOM and CRLF normalised so a CRLF checkout hashes like the LF original. */
-function deltaHash(text) {
-  return crypto.createHash('sha256').update(String(text).replace(/^/, '').replace(/\r\n?/g, '\n')).digest('hex');
+const deltaHash = core.deltaHash; // shared with the unmerged-delta scan in hook.cjs
+
+/** Main checkout of the repo `info` describes (a linked worktree is deleted later; the checkout stays). */
+function mainRootOf(info) {
+  const common = info && info.common_dir ? String(info.common_dir) : '';
+  if (common && path.basename(common) === '.git') return slash(path.dirname(common));
+  return info && info.root ? slash(info.root) : null;
+}
+
+/** Remember where a store's repo lives (meta.json `roots`, newest first, <= 5) so a bare `repo: <name>` can find HEAD. */
+function noteRoot(dir, info) {
+  const root = mainRootOf(info);
+  if (!root || !isDir(dir)) return;
+  const file = path.join(dir, 'meta.json');
+  const meta = core.readJsonFile(file, {}) || {};
+  const roots = Array.isArray(meta.roots) ? meta.roots : [];
+  if (roots[0] === root) return;
+  const next = [root].concat(roots.filter((r) => r !== root)).slice(0, 5);
+  core.writeFileAtomic(file, `${JSON.stringify(Object.assign({}, meta, { roots: next }), null, 2)}\n`);
 }
 
 function appliedOf(dir) {
@@ -741,9 +759,11 @@ function applyDelta(delta, info, sha, dry, src) {
     core.writeFileAtomic(path.join(dir, 'index.json'), `${JSON.stringify(idx, null, 2)}\n`);
     ensureMeta(dir, info);
   }
-  if (changed && !dry && src && !results.some((r) => r.op === 'conflict' || r.op === 'reject')) {
+  if (!dry && src && isDir(dir) && !results.some((r) => r.op === 'conflict' || r.op === 'reject')) {
+    // also when every section was already merged ("same"): the file counts as handled, not as an unmerged delta
     recordApplied(dir, info, { sha256: src.hash, file: src.file, run: src.run, at: now.toISOString() });
   }
+  if (!dry && changed && info.common_dir) noteRoot(dir, info);
   return { results };
 }
 
@@ -766,6 +786,45 @@ function describe(r) {
   return `${OP_MARK[r.op] || '?'} ${r.id} BỊ TỪ CHỐI: ${r.why}`;
 }
 
+/**
+ * Where a delta goes: { target, info } — target = repo dir to read HEAD from (null when only the store is known),
+ * info = project identity (resolveProject, or the bare store entry for a short `repo:` name). Order: a short name that
+ * matches exactly one known store, then the path, then --repo as the fallback for a repo that no longer exists.
+ */
+function targetOf(delta, opts, rep) {
+  const err = (error) => ({ error });
+  if (!delta.repo) return finish(repoOf(opts));
+  if (core.isBareRepoName(delta.repo)) {
+    const hit = core.storeByName(delta.repo);
+    if (hit.matches.length > 1) {
+      return err(`repo: ${delta.repo} khớp ${hit.matches.length} kho (${hit.matches.map((m) => m.dir_name).join(', ')}) — ghi đường dẫn đầy đủ hoặc chạy với --repo`);
+    }
+    if (hit.store) {
+      const st = hit.store;
+      rep.note = `repo: ${delta.repo} → kho ${st.dir_name}`;
+      const cands = st.roots.map((r) => core.nativePath(r)).concat(opts.repo !== undefined ? [repoOf(opts)] : []);
+      for (const c of cands) {
+        if (!isDir(c)) continue;
+        const pi = core.resolveProject(c);
+        if (pi && pi.dir === st.dir) return { target: path.resolve(c), info: pi };
+      }
+      return { target: null, info: { dir: st.dir, dir_name: st.dir_name, key: st.key, name: st.name } };
+    }
+  }
+  if (delta.repo) {
+    const p = path.resolve(core.nativePath(delta.repo));
+    if (isDir(p)) return finish(p);
+    if (opts.repo !== undefined) { rep.note = `repo: ${delta.repo} không còn — dùng --repo`; return finish(repoOf(opts)); }
+    const bare = core.isBareRepoName(delta.repo);
+    return err(`repo: ${delta.repo} ${bare ? 'không khớp kho nào đã biết và không phải thư mục' : 'không tồn tại (worktree đã xoá?)'} — chạy lại với --repo <đường dẫn repo>`);
+  }
+  return err('không xác định được repo');
+  function finish(target) {
+    const info = core.resolveProject(target);
+    return info ? { target, info } : err(`không phải repo git: ${slash(target)}`);
+  }
+}
+
 function cmdMerge(opts) {
   const rd = runDirOf(opts.run);
   if (rd.error) return { code: 1, out: rd.error };
@@ -786,23 +845,20 @@ function cmdMerge(opts) {
       src = { hash: deltaHash(text), file: path.basename(file), run: path.basename(rd.dir) };
     } catch (e) { rep.error = `không đọc được: ${e.message}`; totals.error++; continue; }
     if (!delta.sections.length) { rep.error = 'không có mục "## <id>" nào'; totals.error++; continue; }
-    let target = null;
-    if (delta.repo) {
-      const p = path.resolve(core.nativePath(delta.repo));
-      if (isDir(p)) target = p;
-      else if (opts.repo !== undefined) { target = repoOf(opts); rep.note = `repo: ${delta.repo} không còn — dùng --repo`; } else {
-        rep.error = `repo: ${delta.repo} không tồn tại (worktree đã xoá?) — chạy lại với --repo <đường dẫn repo>`; totals.error++; continue;
-      }
-    } else target = repoOf(opts);
-    const info = core.resolveProject(target);
-    if (!info) { rep.error = `không phải repo git: ${slash(target)}`; totals.error++; continue; }
+    const t = targetOf(delta, opts, rep);
+    if (t.error) { rep.error = t.error; totals.error++; continue; }
+    const { target, info } = t;
     let sha = null;
     if (delta.head) {
       if (!/^[0-9a-f]{7,64}$/i.test(delta.head)) { rep.error = `head: không phải sha: ${delta.head}`; totals.error++; continue; }
       sha = delta.head.toLowerCase();
-    } else sha = headShaOf(target);
-    if (!sha) { rep.error = `không xác định được HEAD của ${slash(target)} (repo chưa có commit?) — thêm dòng "head: <sha>" vào delta`; totals.error++; continue; }
-    Object.assign(rep, { repo: slash(target), store: info.dir, key: info.key, sha });
+    } else if (target) sha = headShaOf(target);
+    if (!sha) {
+      rep.error = target ? `không xác định được HEAD của ${slash(target)} (repo chưa có commit?) — thêm dòng "head: <sha>" vào delta`
+        : `repo: ${delta.repo} khớp kho ${info.dir_name} nhưng chưa biết repo nằm đâu để đọc HEAD — thêm dòng "head: <sha>" vào delta hoặc chạy với --repo <đường dẫn repo>`;
+      totals.error++; continue;
+    }
+    Object.assign(rep, { repo: target ? slash(target) : null, store: info.dir, key: info.key, sha });
     let out;
     if (dry) out = applyDelta(delta, info, sha, true, src);
     else {

package/lib/setup.cjs

@@ -57,7 +57,11 @@ function stripOurHooks(settings) {
   return removed;
 }
 
-/** True when settings already hold exactly our four entries with this command. */
+// core 0.7.1: the subagent tool is `Agent` in current Claude Code and `Task` in older builds — match both
+// (an old `Agent`-only registration is not "already registered", so `setup` rewrites it).
+const AGENT_MATCHER = 'Agent|Task';
+
+/** True when settings already hold exactly our five entries with this command. */
 function alreadyRegistered(settings, cmd) {
   const hooks = settings && settings.hooks;
   if (!hooks || typeof hooks !== 'object') return false;
@@ -69,14 +73,15 @@ function alreadyRegistered(settings, cmd) {
         if (!isOurs(h)) continue;
         ours++;
         if (h.command !== cmd) continue;
-        if (event === 'PostToolUse' && g.matcher === 'Agent') good++;
+        if (event === 'PostToolUse' && g.matcher === AGENT_MATCHER) good++;
         else if (event === 'SubagentStop') good++;
         else if (event === 'SessionStart' && g.matcher === 'compact') good++;
         else if (event === 'UserPromptSubmit' && !g.matcher) good++;
+        else if (event === 'PreToolUse' && g.matcher === AGENT_MATCHER) good++;
       }
     }
   }
-  return ours === 4 && good === 4;
+  return ours === 5 && good === 5;
 }
 
 function addOurHooks(settings, hookPath) {
@@ -84,7 +89,7 @@ function addOurHooks(settings, hookPath) {
   if (!settings.hooks || typeof settings.hooks !== 'object') settings.hooks = {};
   const h = settings.hooks;
   if (!Array.isArray(h.PostToolUse)) h.PostToolUse = [];
-  h.PostToolUse.push({ matcher: 'Agent', hooks: [{ type: 'command', command: cmd, timeout: 10 }] });
+  h.PostToolUse.push({ matcher: AGENT_MATCHER, hooks: [{ type: 'command', command: cmd, timeout: 10 }] });
   if (!Array.isArray(h.SubagentStop)) h.SubagentStop = [];
   h.SubagentStop.push({ hooks: [{ type: 'command', command: cmd, timeout: 10 }] });
   // after /compact or auto-compact: re-inject the orchestration state rebuilt from the log
@@ -93,6 +98,9 @@ function addOurHooks(settings, hookPath) {
   // on a dieu-phoi prompt: pre-create the run dir + id so the first tool call can be the scout (no shell)
   if (!Array.isArray(h.UserPromptSubmit)) h.UserPromptSubmit = [];
   h.UserPromptSubmit.push({ hooks: [{ type: 'command', command: cmd, timeout: 5 }] });
+  // core 0.7.1 (C1): deny another exec continuation of a task that already handed off 3 times (unless chain_ok)
+  if (!Array.isArray(h.PreToolUse)) h.PreToolUse = [];
+  h.PreToolUse.push({ matcher: AGENT_MATCHER, hooks: [{ type: 'command', command: cmd, timeout: 5 }] });
 }
 
 // ------------------------------------------------------------------ run-dir permissions
@@ -413,7 +421,7 @@ function registration(claudeDir) {
   const perms = permissionEntries(runsDir());
   const legacy = permissionEntries(legacyRunsDirOf(claudeDir));
   const out = {
-    file, PostToolUse: false, SubagentStop: false, SessionStart: false, UserPromptSubmit: false, commands: [], permissions: false, permission_entries: perms,
+    file, PostToolUse: false, SubagentStop: false, SessionStart: false, UserPromptSubmit: false, PreToolUse: false, commands: [], permissions: false, permission_entries: perms,
     runs_dir: perms.dir, runs_dir_exists: fs.existsSync(perms.dir), legacy_permissions: false,
   };
   let obj;
@@ -423,11 +431,11 @@ function registration(claudeDir) {
   out.legacy_permissions = legacy.allow.some((r) => Array.isArray(lp.allow) && lp.allow.includes(r))
     || (Array.isArray(lp.additionalDirectories) && lp.additionalDirectories.includes(legacy.dir));
   const hooks = obj.hooks || {};
-  for (const ev of ['PostToolUse', 'SubagentStop', 'SessionStart', 'UserPromptSubmit']) {
+  for (const ev of ['PostToolUse', 'SubagentStop', 'SessionStart', 'UserPromptSubmit', 'PreToolUse']) {
     for (const g of Array.isArray(hooks[ev]) ? hooks[ev] : []) {
       for (const h of (g && Array.isArray(g.hooks) ? g.hooks : [])) {
         if (!isOurs(h)) continue;
-        if (ev === 'PostToolUse' && g.matcher && !/\bAgent\b/.test(g.matcher)) continue;
+        if ((ev === 'PostToolUse' || ev === 'PreToolUse') && g.matcher && !/\b(Agent|Task)\b/.test(g.matcher)) continue;
         if (ev === 'SessionStart' && g.matcher !== 'compact') continue;
         out[ev] = true;
         out.commands.push(h.command);
@@ -438,6 +446,6 @@ function registration(claudeDir) {
 }
 
 module.exports = {
-  MARKER, AGENT_NAMES, AGENT_MARKER, renderAgent, agentStatus, nodePathOf, installAgents, removeAgents, agentsDirOf, setup, uninstall, registration, stripOurHooks, addOurHooks, alreadyRegistered, hookCommand,
+  MARKER, AGENT_NAMES, AGENT_MARKER, renderAgent, agentStatus, nodePathOf, installAgents, removeAgents, agentsDirOf, setup, uninstall, registration, stripOurHooks, addOurHooks, alreadyRegistered, hookCommand, AGENT_MATCHER,
   skillVersionOf, findSkillDir, tsStamp, runsDir, legacyRunsDirOf, permissionEntries, addOurPermissions, stripOurPermissions, hasOurPermissions,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kienntpixon/dieu-phoi",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Hook + CLI ghi log subagent của Claude Code và chọn model/effort theo chi phí + thời gian tới lúc nghiệm thu.",
   "license": "MIT",
   "author": "kiennt <kiennt@pixon.games>",