@kienntpixon/dieu-phoi 0.5.1 → 0.5.3

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog — @kienntpixon/dieu-phoi
 
+## 0.5.3 (2026-10-22)
+
+Đề xuất core 1–3 của retro 2026-10-22 (`~/.dieu-phoi/runs/258ajcrr/retro-2026-10-22.md`). `CORE_VERSION` 0.5.3; đi cùng skill 1.4.3. Không cần deploy lại `sheet/Code.gs`.
+
+- **Thẻ sai được gắn cờ thay vì mất task_id:** 76 dp-exec ($407, 25% chi phí 10-19..21) mất `task_id` vì brief đặt id vào ô loại (`[dp:<id>|…]`, thiếu `task=`). Hook mới có `resolveTag` (`parseTag` giữ nguyên, gate gen-2 vẫn dùng bản chặt): `dispatch`/`complete` mang `tag_issue` = `type-is-id|bad-type|missing-task|no-tag` (nối `+`); thiếu `task=` mà ô loại là id (đúng định dạng, không phải loại đã biết, có chữ số hoặc được nhắc trong `dp-out-<id>`/`handoff-<id>`/`task=<id>` của brief) → `task_id` = id đó + `task_id_inferred: true`, loại lấy từ phần khác của thẻ nếu có. Id bắt đầu bằng chữ số (trước đây `parseTag` trả null, agent thành `untagged` và không có watchdog) giờ cũng được nhận. Loại hợp lệ = 12 loại cố định + `art-gen` + `extra_task_types` của profile.
+- **Cảnh báo trả về điều phối viên:** PostToolUse(Agent) in `additionalContext` khi thẻ bị gắn cờ (nêu lỗi, id đã suy hoặc "không vào stats", mẫu thẻ đúng, danh sách loại). Agent không phải `dp-*` và không có thẻ: không cờ, không in.
+- **Dispatch ghi tier `choose` đã đề xuất:** `choose --task` và `plan-table --approve` để lại `data/suggest/<task>-<role>.json`; dispatch kế tiếp của task + role đó ghi `suggested_tier` (tier choose tự chọn, trước override), `choose_tier` (tier choose trả về), `suggested_source`, `dispatched_tier`, `tier_mismatch`. Bản ghi > 14 ngày bị bỏ qua.
+- **Trần chuỗi handoff:** dispatch exec ghi `task_handoffs` (số agent đã handoff của task); từ handoff thứ 3 hook cảnh báo dừng tiếp nối và giao planner chia phần còn lại (retro: 15/63 task feature-impl handoff ≥ 2 lần; cq7yn1ws 10 handoff, $70, fail).
+- **Sửa hai lỗi nhỏ của cảnh báo thẻ:** `bad-type` nêu đúng token sai (trường `bad_type`) kể cả khi thẻ có thêm một loại hợp lệ (`[dp:foo|review|…]` báo "foo", không phải "review"); watchdog (`readHeadTag`) nay truyền `extra_task_types` của profile nên loại của profile không bị coi là `bad-type`.
+- Sink không thêm cột (các trường mới là chẩn đoán cục bộ; `suggested_tier` trùng tên cột sẵn có của `override`). Test mới `test/retro-1022.test.cjs`.
+
+## 0.5.2
+
+- **`dieu-phoi prune --after-retro <file> [--yes]`:** dọn sau retro, dry-run mặc định. Run dir của task đã có verdict người dùng và mọi sự kiện ≤ mốc cắt (dòng `cutoff:` trong file retro, không có thì mtime) chỉ còn `retro-*.md` + dp-out exec/verify cuối (giữ = try cao nhất VÀ file mới nhất theo mtime cho mỗi task+role; file legacy không phân loại được và kết quả inline cuối cũng giữ); xoá file plan hỏng (tên không phải task id hoặc không đọc được); task còn mở không đụng. Event của task đã dọn chuyển vào `data/archive/events-<ngày>.jsonl.gz` (ghi + xác minh archive trước, rồi ghi lại `events.jsonl` qua file tạm + rename, giữ khoá sync); `readEvents` đọc cả archive (chống trùng nếu prune chết giữa chừng) nên retro/stats/choose/state không đổi số; sync chỉ đọc `events.jsonl`, offset được dịch theo phần đã bỏ, event chưa đẩy lên sink (khi có sink) không bị chuyển. Run dir có file mới hơn mốc cắt (việc đang chạy chưa vào log) không bị dọn. Từ chối gốc ổ đĩa, không đi theo symlink/junction, chỉ đụng runs dir + data dir.
+- **Nâng cấp:** dán lại `sheet/Code.gs` và deploy bản mới cùng lúc phát hành — Code.gs cũ từ chối kind `gate` (`bad_kind` → `sync-rejected.jsonl`) và bỏ các cột `complete` mới.
+- **Điểm chọn tier dùng trung vị thời gian (retro 2026-10-18):** ô `retro`/`stats` tính `score = cost_mean + λ × time_p50` (trước: `time_mean`); Thompson trong `choose` dùng `attempt_p50_min` (urgent vẫn p75). Thời gian chờ người dùng/quota đẩy trung bình lên 3–13× và lật prior sang tier chậm hơn. `time_mean_min` vẫn được báo. Test mới `test/retro-score.test.cjs`.
+- **Prior/trần thời gian (profile ai-lab, builtin khớp):** `debug` → sonnet/high; `time_cap_min` theo p75 thật: mechanical-edit 25, test-write 60, review 40, plan-design 30, art-gen 100.
+- **Telemetry `complete`:** thêm `status` (dấu `STATUS:`/`VERDICT:` chuẩn hoá: done|pass|fail|partial|blocked|handoff|quota|other|none), `handoff`, `peak_ctx` (ngữ cảnh lớn nhất một request, cách đo của watchdog), `compactions` (số `compact_boundary`), `inline_result` (exec/verify/plan: hook phải tự ghi `.inline.md`). `.inline.md` giờ được ghi trước khi ghi event.
+- **Kind mới `gate`:** hook `--gate`/`--gate-release` ghi một event cho mỗi quyết định `allow|deny|release` (`slot`, `children`, `child_task_id`, `reason_code` = `not-exec|type|model|tag|parent` nối `+`, hoặc `max-children`). Thước đo bỏ qua. Sink thêm cột tương ứng; fixture parity + simulate có ca mới. Test mới `test/telemetry.test.cjs`.
+- **Agent `dp-verify`/`dp-scout`:** dòng bắt buộc "chốt VERDICT xong thì hành động kế tiếp là Write dp-out" (retro: verifier trả inline thay vì ghi file).
+
 ## 0.5.1
 
 Nâng ngưỡng watchdog ngữ cảnh subagent 150k/180k -> 200k/230k. Đo thí điểm: sonnet exec với `autoCompactWindow: 200000` tự nén ở 167.370 (~0,837 cửa sổ) — nén TRƯỚC khi lời nhắc 200k kịp tới.

package/README.md

@@ -54,6 +54,7 @@ Khởi động lại Claude Code sau khi cài. Kiểm tra bằng `dieu-phoi doct
 | `start [--json]` | khởi động cổng 1 trong một lệnh, không gọi mạng: kiểm cục bộ, `root_task_id` + `step_ids`, tạo run dir, đường dẫn brief scout. Thường không cần: hook `UserPromptSubmit` làm sẵn việc này khi prompt có "điều phối" hoặc bắt đầu bằng `/dieu-phoi` |
 | `new-id [--count n] [--json]` | in task_id mới hợp lệ (đúng 8 ký tự `a-z0-9`), mỗi dòng một id (mặc định 1, tối đa 1000; `--json`: mảng). Lấy mọi `task_id` / `root_task_id` từ đây — không tự bịa. `choose/verdict/steer --task` và `plan-table --approve` từ chối id sai định dạng (kèm gợi ý id mới); hook vẫn ghi id cũ nhưng gắn `task_id_invalid: true`, `doctor` cảnh báo |
 | `sync [--json]` | đẩy bản ghi chưa đồng bộ lên sink, lô ≤ 200, có thử lại. Bản ghi sink từ chối → `data/sync-rejected.jsonl`, `doctor` báo số lượng |
+| `prune --after-retro <file> [--yes]` | dọn sau retro (dry-run mặc định): run dir đã nghiệm thu, plan hỏng, event cũ → `data/archive/*.jsonl.gz` |
 | `retro [--json]` | tóm tắt cho vòng retro: số liệu từng ô, đếm `reason_code`, danh sách loại task, tóm tắt điều phối (`orchestration`) |
 | `uninstall [--purge]` | gỡ hook và đúng các quyền thư mục `runs` đã thêm khỏi settings (có sao lưu); `--purge` xoá cả `hook.cjs`. Dữ liệu giữ lại |
 

package/agents/dp-scout.md

@@ -15,6 +15,8 @@ hooks:
 ---
 Bạn là scout/planner của dieu-phoi: khảo sát (code, tài liệu, dữ liệu) theo brief ở tin nhắn đầu (thẻ `[dp:...|role=plan]`) và trả về kế hoạch/câu hỏi đúng định dạng brief. Không sửa file của dự án; Write chỉ dùng để ghi báo cáo/kế hoạch vào run dir.
 
+**Bắt buộc: có kế hoạch/kết luận xong thì hành động kế tiếp là gọi Write** tạo `dp-out-<task_id>-plan-try<n>.md` (dòng đầu file = dòng `STATUS:`). Chưa Write thành công thì chưa được trả lời; trả lời mà không có file là lỗi bàn giao (hook ghi nhận). Write bị từ chối → Bash heredoc; vẫn bị → trả nội dung inline.
+
 Bàn giao qua file: ghi TOÀN BỘ kết quả vào `dp-out-<task_id>-plan-try<n>.md` trong run dir (đường dẫn brief chỉ định), rồi chỉ trả: đường dẫn file đó, dòng `STATUS:`, và ≤ 3 dòng ý chính. Không đặt tên file `report*` / `summary*` / `findings*` / `analysis*.md` — Claude Code chặn cứng Write các tên đó trong subagent. File dp-out/handoff mà brief trỏ tới là báo cáo chính thức: đọc thẳng, không cần xin thêm quyền.
 
 Giữ ngữ cảnh nhỏ (mỗi lượt gửi lại toàn bộ ngữ cảnh — số lượt mới là thứ làm phình):

package/agents/dp-verify.md

@@ -15,6 +15,8 @@ hooks:
 ---
 Bạn là agent kiểm chứng (verify) của dieu-phoi: kiểm tra độc lập kết quả của bước exec theo brief ở tin nhắn đầu (thẻ `[dp:...|role=verify]`). Chỉ đọc và chạy lệnh kiểm tra (test, lint, build); không sửa code của dự án. Ghi báo cáo vào run dir (Write chỉ dùng cho báo cáo) và trả về verdict ngắn đúng định dạng brief.
 
+**Bắt buộc: chốt VERDICT xong thì hành động kế tiếp là gọi Write** tạo `dp-out-<task_id>-verify-try<n>.md` (dòng đầu file = dòng `VERDICT:`). Chưa Write thành công thì chưa được trả lời; trả verdict mà không có file là lỗi bàn giao (hook ghi nhận, 10/24 file `.inline.md` gần đây là của verifier). Write bị từ chối → Bash heredoc; vẫn bị → trả nội dung inline.
+
 Bàn giao qua file: ghi TOÀN BỘ kết quả vào `dp-out-<task_id>-verify-try<n>.md` trong run dir (đường dẫn brief chỉ định), rồi chỉ trả: đường dẫn file đó, dòng `STATUS:`/`VERDICT:`, và ≤ 3 dòng ý chính. Không đặt tên file `report*` / `summary*` / `findings*` / `analysis*.md` — Claude Code chặn cứng Write các tên đó trong subagent. File dp-out/handoff mà brief trỏ tới là báo cáo chính thức: đọc thẳng, không cần xin thêm quyền.
 
 Giữ ngữ cảnh nhỏ (mỗi lượt gửi lại toàn bộ ngữ cảnh — số lượt mới là thứ làm phình):

package/bin/dieu-phoi.cjs

@@ -40,6 +40,9 @@ Cách dùng: dieu-phoi <lệnh> [tuỳ chọn]
                          in task_id mới hợp lệ (8 ký tự a-z0-9), mỗi dòng một id — không tự bịa id
   sync                   đẩy bản ghi chưa đồng bộ lên sink
   retro [--json]         tóm tắt cho vòng retro (không chứa nội dung)
+  prune --after-retro <file retro> [--yes]
+                         dọn sau retro: run dir đã nghiệm thu (giữ retro-*.md + dp-out exec/verify cuối), plan hỏng,
+                         events cũ → data/archive/*.jsonl.gz (không xoá event). Mặc định dry-run; --yes mới thực hiện
   uninstall [--purge]    gỡ hook khỏi settings.json (--purge xoá cả hook.cjs; dữ liệu giữ lại)
   hook                   (nội bộ) đọc payload hook từ stdin
 
@@ -81,6 +84,7 @@ async function main(argv) {
     state: c.cmdState,
     sync: c.cmdSync,
     retro: c.cmdRetro,
+    prune: c.cmdPrune,
     uninstall: c.cmdUninstall,
   };
   const fn = table[cmd];

package/hook.cjs

@@ -9,7 +9,8 @@
  * handoff watchdog), `--gate` (PreToolUse(Agent), gen-2 helper rules) and `--gate-release`. It must stay
  * self-contained: Node built-ins only, no requires of other package files.
  *
- * Hook rules: stdout only for the JSON of SessionStart(compact) / UserPromptSubmit, always exit 0,
+ * Hook rules: stdout only for the JSON of SessionStart(compact) / UserPromptSubmit / a PostToolUse(Agent) warning
+ * (core 0.5.3: bad dp tag, handoff chain), always exit 0,
  * no network.
  * Errors go to <home>/hook-errors.log.
  *
@@ -25,7 +26,7 @@ const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
 
-const CORE_VERSION = '0.5.1';
+const CORE_VERSION = '0.5.3';
 const SCHEMA = 1;
 const TASK_TYPES = [
   'search', 'extract', 'mechanical-edit', 'feature-impl', 'debug', 'refactor',
@@ -126,6 +127,7 @@ function pathsFor(home) {
     events: path.join(data, 'events.jsonl'),
     segments: path.join(data, 'segments'),
     plans: path.join(data, 'plans'),
+    suggest: path.join(data, 'suggest'),
     skippedInternal: path.join(data, 'skipped-internal.json'),
     syncOffset: path.join(data, 'sync-offset.json'),
     syncSpawn: path.join(data, 'sync-spawn.json'),
@@ -263,6 +265,87 @@ function taskIdError(id) {
   return `task_id "${id}" không hợp lệ: cần đúng 8 ký tự a-z0-9 (vd. ${newTaskId()}) — lấy id bằng \`dieu-phoi new-id\``;
 }
 
+// ------------------------------------------------------------------ tag check (core 0.5.3, retro 2026-10-22)
+//
+// 76 dp-exec ($407, 25% of 10-19..21 cost) lost their task_id because the brief put the id in the type slot
+// (`[dp:<id>|…]`, no `task=`). parseTag stays strict (the gen-2 gate relies on it); resolveTag diagnoses the tag,
+// flags it (`tag_issue`) and recovers the task_id only when the guess is safe.
+
+const DEFAULT_EXTRA_TYPES = ['art-gen'];
+
+/** 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);
+  const sd = ctx && ctx.config && ctx.config.skill_dir;
+  if (sd) {
+    const prof = readJsonFile(path.join(sd, 'profile', 'profile.json'), null);
+    const extra = prof && Array.isArray(prof.extra_task_types) ? prof.extra_task_types : [];
+    for (const t of extra) if (typeof t === 'string' && !out.includes(t)) out.push(t);
+  }
+  return out;
+}
+
+/**
+ * parseTag + diagnosis. null when the first line has no `[dp:` tag at all. Otherwise a tag (never dropped), plus:
+ * - `tag_issue`: `type-is-id` (an 8-char [a-z0-9] id in the type slot), `bad-type` (type not a known task type),
+ *   `missing-task` (no `task=`), joined with `+`;
+ * - `task_id_inferred: true` + `task_id` = the type-slot token, only when `task=` is missing, the token matches the
+ *   task_id format, is not a known type, and either holds a digit or the prompt names it in a run-file path /
+ *   `task=` (`dp-out-<id>`, `handoff-<id>`) — the same test that tells `type-is-id` from `bad-type` (an 8-letter label
+ *   such as "planning" stays a label). Then task_type = another tag part that is a known type, else `untagged`.
+ */
+function resolveTag(text, known) {
+  if (typeof text !== 'string') return null;
+  const body = text.replace(/^/, '');
+  const first = body.split(/\r?\n/, 1)[0].trim();
+  const m = /^\[dp:([^\]]*)\]/.exec(first);
+  if (!m) return null;
+  const types = Array.isArray(known) && known.length ? known : TASK_TYPES.concat(DEFAULT_EXTRA_TYPES);
+  const parts = m[1].split('|').map((s) => s.trim());
+  const head = (parts[0] || '').toLowerCase();
+  const rest = parts.slice(1);
+  let tag = parseTag(body);
+  // type slot unusable for parseTag (e.g. an id starting with a digit): parse the other parts on their own
+  if (!tag) tag = parseTag(`[dp:untagged|${rest.join('|')}]`);
+  const issues = [];
+  const altType = rest.map((p) => p.toLowerCase()).find((p) => types.includes(p)) || null;
+  // 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);
+  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)
+  }
+  if (!tag.task_id) {
+    issues.push('missing-task');
+    if (idLike) {
+      tag.task_id = head;
+      tag.task_id_inferred = true;
+    }
+  }
+  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;
+}
+
+/** One Vietnamese line for the orchestrator about a flagged tag (null when the tag is fine). */
+function tagIssueMessage(tag, known) {
+  if (!tag || !tag.tag_issue) return null;
+  const what = [];
+  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('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
+    ? ` Hook đã suy task_id=${tag.task_id} từ ô loại (log ghi \`task_id_inferred\`), loại ghi là "${tag.task_type}".`
+    : (tag.task_id ? '' : ' Lượt này KHÔNG có task_id: không vào stats/choose/retro.');
+  const types = (Array.isArray(known) && known.length ? known : TASK_TYPES.concat(DEFAULT_EXTRA_TYPES)).join(', ');
+  return `dieu-phoi: thẻ của agent vừa giao sai (tag_issue=${tag.tag_issue}): ${what.join('; ')}.${got} Lần giao sau dùng đúng \`[dp:<task_type>|s<n>|<urgency>|try<n>|task=<id>|role=<role>]\`, task_type là một trong: ${types}; id lấy bằng \`dieu-phoi new-id\`.`;
+}
+
 // ------------------------------------------------------------------ models / pricing
 
 function normalizeModel(m) {
@@ -387,10 +470,13 @@ function firstPromptText(lines) {
   return null;
 }
 
-/** Tag from the first user message of the transcript (the original prompt). */
-function tagFromTranscript(lines) {
+/**
+ * Tag from the first user message of the transcript (the original prompt). Core 0.5.3: resolveTag, so a tag with the
+ * id in the type slot still yields its task_id (complete events, watchdog handoff file name, inline results).
+ */
+function tagFromTranscript(lines, known) {
   const text = firstPromptText(lines);
-  return text === null ? null : parseTag(text);
+  return text === null ? null : resolveTag(text, known);
 }
 
 /**
@@ -413,8 +499,10 @@ function summarizeTranscript(lines, opts) {
   let anonReq = 0;
   let firstTs = null;
   let lastTs = null;
+  let compactions = 0;
   for (const l of seg) {
     if (!l || typeof l !== 'object') continue;
+    if (l.type === 'system' && l.subtype === 'compact_boundary') compactions++;
     if (typeof l.timestamp === 'string') {
       const t = Date.parse(l.timestamp);
       if (!isNaN(t)) {
@@ -441,10 +529,14 @@ function summarizeTranscript(lines, opts) {
   let cost = 0;
   let costKnown = true;
   const modelCount = new Map();
+  let peak = null;
   for (const { usage, model } of byReq.values()) {
     if (model) modelCount.set(model, (modelCount.get(model) || 0) + 1);
     if (!usage) continue;
     const b = usageBuckets(usage);
+    // same measure as the watchdog (lastContextTokens): input + cache_read + cache_creation of one request
+    const ctxTok = b.input + b.cache_read + b.cache_write_5m + b.cache_write_1h;
+    if (peak === null || ctxTok > peak) peak = ctxTok;
     for (const k of Object.keys(tokens)) tokens[k] += b[k];
     const c = o.pricing ? requestCost(o.pricing, model, b) : null;
     if (c === null) costKnown = false; else cost += c;
@@ -462,6 +554,8 @@ function summarizeTranscript(lines, opts) {
     tokens,
     cost_usd: costKnown && byReq.size ? Math.round(cost * 1e8) / 1e8 : (byReq.size ? null : 0),
     model: normalizeModel(model),
+    peak_ctx: peak,
+    compactions,
     last_uuid: lastUuidOf(seg),
   };
 }
@@ -798,14 +892,46 @@ function readEventLines(ctx) {
   return eventLinesFrom(readEventsBuffer(ctx), 0).map((l) => l.text);
 }
 
-function readEvents(ctx) {
+/** <data>/archive/events-<date>.jsonl.gz, oldest first (written by `dieu-phoi prune`). */
+function archiveFiles(ctx) {
+  const dir = path.join(ctx.paths.data, 'archive');
+  let names = [];
+  try { names = fs.readdirSync(dir); } catch (_) { return []; }
+  return names.filter((n) => /^events-\d{4}-\d{2}-\d{2}\.jsonl\.gz$/.test(n)).sort().map((n) => path.join(dir, n));
+}
+
+/** Raw non-empty lines of every archive (gzip members may be concatenated). A corrupt archive throws. */
+function readArchiveLines(ctx) {
   const out = [];
-  for (const line of readEventLines(ctx)) {
+  for (const f of archiveFiles(ctx)) {
+    const txt = require('zlib').gunzipSync(fs.readFileSync(f)).toString('utf8');
+    for (const l of txt.split(String.fromCharCode(10))) if (l.trim()) out.push(l.trim());
+  }
+  return out;
+}
+
+function parseEventLines(lines, out) {
+  for (const line of lines) {
     try {
       const o = JSON.parse(line);
       if (o && typeof o === 'object') out.push(o);
     } catch (_) { /* skip */ }
   }
+}
+
+/**
+ * All events: archived history first, then events.jsonl. A line present in both (prune died between writing the
+ * archive and rewriting events.jsonl) counts once. Sync never uses this: it reads events.jsonl only.
+ */
+function readEvents(ctx) {
+  const out = [];
+  const cur = readEventLines(ctx);
+  const arch = readArchiveLines(ctx);
+  if (arch.length) {
+    parseEventLines(arch, out);
+    const seen = new Set(arch);
+    parseEventLines(cur.filter((l) => !seen.has(l)), out);
+  } else parseEventLines(cur, out);
   return out;
 }
 
@@ -1369,11 +1495,105 @@ function extractAgentId(tr) {
   return m ? m[1] : null;
 }
 
+// ------------------------------------------------------------------ core 0.5.3: choose's tier per task (retro 2026-10-22)
+//
+// `choose --task <id>` and `plan-table --approve` leave data/suggest/<task>-<role>.json; the next dispatch of that
+// task + role copies it as `suggested_tier` (choose's own pick, before a user override) and `choose_tier` (what
+// choose answered), next to the tier actually dispatched. Older than SUGGEST_MAX_AGE_MS -> ignored.
+
+const SUGGEST_MAX_AGE_MS = 14 * 24 * 3600 * 1000;
+
+function suggestFile(ctx, taskId, role) {
+  return path.join(ctx.paths.suggest, `${safeName(taskId)}-${safeName(role || 'exec')}.json`);
+}
+
+/**
+ * rec: { task_id, role?, suggested_tier, choose_tier?, source: 'choose'|'plan', keep_suggested? }. keep_suggested:
+ * a `choose --approved` answer carries no Thompson pick, so an earlier record's suggested_tier (from the plan table)
+ * is kept. Best effort: returns the written record or null.
+ */
+function recordSuggestion(ctx, rec) {
+  if (!rec || !isValidTaskId(rec.task_id) || typeof rec.suggested_tier !== 'string') return null;
+  const role = rec.role || 'exec';
+  const file = suggestFile(ctx, rec.task_id, role);
+  const prev = rec.keep_suggested ? readSuggestion(ctx, rec.task_id, role) : null;
+  const out = {
+    task_id: rec.task_id,
+    role,
+    suggested_tier: prev && prev.suggested_tier ? prev.suggested_tier : rec.suggested_tier,
+    choose_tier: rec.choose_tier || rec.suggested_tier,
+    source: prev && prev.suggested_tier ? prev.source : (rec.source || 'choose'),
+    ts: nowIso(),
+  };
+  try {
+    fs.mkdirSync(ctx.paths.suggest, { recursive: true });
+    writeFileAtomic(file, `${JSON.stringify(out)}\n`);
+    pruneSuggest(ctx);
+  } catch (e) {
+    logError(ctx.home, e, 'suggest');
+    return null;
+  }
+  return out;
+}
+
+function readSuggestion(ctx, taskId, role) {
+  if (!isValidTaskId(taskId)) return null;
+  const r = readJsonFile(suggestFile(ctx, taskId, role), null);
+  if (!r || typeof r !== 'object' || typeof r.suggested_tier !== 'string') return null;
+  const t = Date.parse(r.ts);
+  if (!(Date.now() - t <= SUGGEST_MAX_AGE_MS)) return null;
+  return r;
+}
+
+function pruneSuggest(ctx) {
+  let names = [];
+  try { names = fs.readdirSync(ctx.paths.suggest); } catch (_) { return; }
+  const now = Date.now();
+  for (const n of names) {
+    const f = path.join(ctx.paths.suggest, n);
+    try { if (now - fs.statSync(f).mtimeMs > 2 * SUGGEST_MAX_AGE_MS) fs.unlinkSync(f); } catch (_) { /* gone */ }
+  }
+}
+
+// ------------------------------------------------------------------ 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.
+
+const HANDOFF_CHAIN_WARN = 3;
+
+/** Number of agents whose `complete` event has handoff:true for this task (substring scan of events.jsonl). */
+function countTaskHandoffs(ctx, taskId) {
+  if (!taskId) return 0;
+  let txt;
+  try { txt = fs.readFileSync(ctx.paths.events, 'utf8'); } catch (_) { return 0; }
+  const needle = `"task_id":${JSON.stringify(taskId)}`;
+  const agents = new Set();
+  let i = txt.indexOf(needle);
+  while (i >= 0) {
+    const start = txt.lastIndexOf('\n', i) + 1;
+    const end = txt.indexOf('\n', i);
+    const line = txt.slice(start, end < 0 ? undefined : end);
+    if (line.includes('"kind":"complete"') && line.includes('"handoff":true')) {
+      const m = /"agent_id":("(?:[^"\\]|\\.)*")/.exec(line);
+      agents.add(m ? m[1] : `@${start}`);
+    }
+    i = end < 0 ? -1 : txt.indexOf(needle, end);
+  }
+  return agents.size;
+}
+
+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\`).`;
+}
+
 function buildDispatch(p, ctx) {
   const ti = p.tool_input && typeof p.tool_input === 'object' ? p.tool_input : {};
   const tr = p.tool_response;
   const trObj = tr && typeof tr === 'object' && !Array.isArray(tr) ? tr : {};
-  const tag = parseTag(ti.prompt) || UNTAGGED;
+  const subagentType = typeof ti.subagent_type === 'string' && ti.subagent_type ? ti.subagent_type : 'general-purpose';
+  let tag = resolveTag(ti.prompt, knownTaskTypes(ctx));
+  if (!tag) tag = /^dp-/.test(subagentType) ? Object.assign({}, UNTAGGED, { tag_issue: 'no-tag' }) : UNTAGGED;
   const explicitEffort = typeof ti.effort === 'string' && ti.effort ? ti.effort : null;
   const parentEffort = p.effort && typeof p.effort === 'object' ? p.effort.level : null;
   // agent_id must never be empty (the sink keys on it): agentId -> tool_use_id -> random.
@@ -1392,6 +1612,8 @@ function buildDispatch(p, ctx) {
     session: p.session_id ? sha8(p.session_id) : null,
     task_id: tag.task_id,
     ...(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 } : {}),
     task_type: tag.task_type,
     score: tag.score,
     urgency: tag.urgency,
@@ -1400,7 +1622,7 @@ function buildDispatch(p, ctx) {
     model: normalizeModel(trObj.resolvedModel) || normalizeModel(ti.model) || null,
     effort: explicitEffort || parentEffort || null,
     effort_inherited: !explicitEffort,
-    subagent_type: typeof ti.subagent_type === 'string' && ti.subagent_type ? ti.subagent_type : 'general-purpose',
+    subagent_type: subagentType,
     background: ti.run_in_background === true || trObj.isAsync === true,
     // Orchestrator (main session) at the moment of this dispatch. Raw session_id joins with `dieu-phoi ctx`.
     session_id: typeof p.session_id === 'string' && p.session_id ? p.session_id : null,
@@ -1409,15 +1631,54 @@ function buildDispatch(p, ctx) {
     orch_compactions: orch.compactions,
     orch_cum_usd: orch.cum_usd,
   }, tag.parent_task_id ? { parent_task_id: tag.parent_task_id } : {},
+  tierFields(ctx, tag, normalizeModel(trObj.resolvedModel) || normalizeModel(ti.model) || null, explicitEffort || parentEffort || null),
   // core 0.5.0: an Agent call made inside a subagent (gen-2) carries the caller's agent_id
   typeof p.agent_id === 'string' && p.agent_id ? { parent_agent_id: p.agent_id } : {},
   commonFields(ctx));
 }
 
+/** suggested_tier / choose_tier / suggested_source / dispatched_tier / tier_mismatch, only when choose left a record. */
+function tierFields(ctx, tag, model, effort) {
+  const s = tag.task_id ? readSuggestion(ctx, tag.task_id, tag.role) : null;
+  if (!s) return {};
+  const dispatched = tierOf(model, effort);
+  const out = {
+    suggested_tier: s.suggested_tier,
+    choose_tier: s.choose_tier || s.suggested_tier,
+    suggested_source: s.source || null,
+    dispatched_tier: dispatched,
+  };
+  if (dispatched && !dispatched.includes('?')) out.tier_mismatch = dispatched !== out.choose_tier;
+  return out;
+}
+
+/**
+ * Core 0.5.3: besides the dispatch event, a dieu-phoi dispatch with a flagged tag (tag_issue) or a task already on
+ * its HANDOFF_CHAIN_WARN-th handoff gets a warning back to the caller as PostToolUse additionalContext (the
+ * returned event carries it as a non-enumerable `stdout`, never written to the log).
+ */
 function handlePostToolUse(p, ctx) {
   if (p.tool_name !== 'Agent' && p.tool_name !== 'Task') return null;
   const ev = buildDispatch(p, ctx);
+  const notes = [];
+  if (ev.tag_issue) {
+    const ti = p.tool_input && typeof p.tool_input === 'object' ? p.tool_input : {};
+    const known = knownTaskTypes(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.task_id && ev.role === 'exec') {
+    const n = countTaskHandoffs(ctx, ev.task_id);
+    if (n) ev.task_handoffs = n;
+    if (n >= HANDOFF_CHAIN_WARN) notes.push(handoffChainMessage(ev.task_id, n));
+  }
   appendEvent(ctx, ev);
+  if (notes.length) {
+    Object.defineProperty(ev, 'stdout', {
+      enumerable: false,
+      value: JSON.stringify({ hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: notes.join('\n') } }),
+    });
+  }
   return ev;
 }
 
@@ -1586,7 +1847,7 @@ function handleSubagentStop(p, ctx) {
     const last = lastUuidOf(lines);
     if (last && seen.has(last)) return null; // same segment reported twice
     sum = summarizeTranscript(lines, { afterUuids: seen, pricing: loadPricing(ctx) });
-    tag = tagFromTranscript(lines);
+    tag = tagFromTranscript(lines, knownTaskTypes(ctx));
   }
   const t = tag || UNTAGGED;
   const ev = Object.assign({
@@ -1608,7 +1869,20 @@ function handleSubagentStop(p, ctx) {
     tokens: sum ? sum.tokens : null,
     cost_usd: sum ? sum.cost_usd : null,
     model: sum ? sum.model : null,
-  }, commonFields(ctx));
+  }, t.task_id_inferred ? { task_id_inferred: true } : {}, t.tag_issue ? { tag_issue: t.tag_issue } : {}, commonFields(ctx));
+  // Core 0.5.2 (retro 2026-10-18): how the segment ended, measured here instead of re-reading transcripts later.
+  // Labels and numbers only, never text.
+  const why = exists ? abortReasonOf(lines) : null;
+  ev.status = exists ? completionStatus(finalAssistantText(lines, p.last_assistant_message), why) : null;
+  ev.handoff = ev.status === 'handoff';
+  ev.peak_ctx = sum ? sum.peak_ctx : null;
+  ev.compactions = sum ? sum.compactions : null;
+  let inline = null;
+  if (exists && tag) {
+    try { inline = persistInlineResult(lines, tag, { finalText: p.last_assistant_message }); } catch (_) { /* best effort */ }
+  }
+  // exec/verify/plan only: true = it returned without writing its dp-out file (the hook saved the .inline.md)
+  if (tag && RESULT_ROLES.includes(tag.role)) ev.inline_result = Boolean(inline);
   // Record the segment before appending so a racing duplicate fire sees it.
   if (sum && sum.last_uuid) {
     saveSegments(ctx, agentId, {
@@ -1618,12 +1892,8 @@ function handleSubagentStop(p, ctx) {
     });
   }
   appendEvent(ctx, ev);
-  if (exists && tag) {
-    try { persistInlineResult(lines, tag, { finalText: p.last_assistant_message }); } catch (_) { /* best effort */ }
-  }
   // Core 0.4.0: a segment that ended on a usage-limit / quota pause gets an automatic agent verdict
   // `aborted` (never a fail, never counted toward escalation); the real verdict comes after the resume.
-  const why = exists ? abortReasonOf(lines) : null;
   if (why) {
     appendEvent(ctx, Object.assign({
       schema: SCHEMA, kind: 'verdict', ts: nowIso(), agent_id: agentId, task_id: t.task_id, by: 'agent', outcome: 'aborted',
@@ -1669,6 +1939,32 @@ function abortReasonOf(lines) {
   return null;
 }
 
+/**
+ * `complete.status` (core 0.5.2): how the agent's final report labels itself, as a fixed label (no text stored).
+ * Quota / usage-limit stop -> "quota"; exact handoff marker -> "handoff"; else the first `STATUS:` or `VERDICT:` line
+ * among the first 12 lines of the final text: done | partial | blocked | pass | fail, anything else -> "other".
+ * No final text -> null; text without such a line -> "none".
+ */
+function completionStatus(text, abortWhy) {
+  if (abortWhy === 'usage-limit' || abortWhy === 'quota-pause') return 'quota';
+  if (abortWhy === 'handoff') return 'handoff';
+  if (typeof text !== 'string' || !text.trim()) return null;
+  const head = text.split(/\r?\n/).slice(0, 12);
+  for (const raw of head) {
+    const m = /^[\s>*_`#-]*(STATUS|VERDICT)\s*[*_`]*\s*[:=]\s*[*_`]*\s*([A-Za-z]+)/i.exec(raw);
+    if (!m) continue;
+    const w = m[2].toLowerCase();
+    if (w === 'partial' && /handoff/i.test(raw)) return 'handoff';
+    if (w === 'partial' && /quota/i.test(raw)) return 'quota';
+    if (w === 'done' || w === 'ok' || w === 'complete' || w === 'completed') return 'done';
+    if (w === 'pass' || w === 'passed') return 'pass';
+    if (w === 'fail' || w === 'failed') return 'fail';
+    if (w === 'partial' || w === 'blocked') return w;
+    return 'other';
+  }
+  return 'none';
+}
+
 // ------------------------------------------------------------------ core 0.5.0: context watchdog + gen-2 gate
 //
 // Both run only from the hooks of the dp-* agent files (~/.claude/agents, installed by `dieu-phoi setup`), so a session
@@ -1746,7 +2042,7 @@ function readSlice(fd, start, len) {
  * Tag of the subagent's first prompt, read from the head of its transcript only.
  * Returns { found: false } while no user line is on disk yet (transcript written async), else { found: true, tag|null }.
  */
-function readHeadTag(file) {
+function readHeadTag(file, known) {
   let fd;
   try { fd = fs.openSync(file, 'r'); } catch (_) { return { found: false, tag: null }; }
   try {
@@ -1756,7 +2052,7 @@ function readHeadTag(file) {
       const text = readSlice(fd, 0, len).toString('utf8');
       const complete = len === size ? text : text.slice(0, text.lastIndexOf('\n') + 1);
       const lines = parseJsonl(complete);
-      if (lines.some((l) => l && l.type === 'user' && l.message)) return { found: true, tag: tagFromTranscript(lines), prompt: firstPromptText(lines) };
+      if (lines.some((l) => l && l.type === 'user' && l.message)) return { found: true, tag: tagFromTranscript(lines, known), prompt: firstPromptText(lines) };
       if (len >= size || len >= WATCH_HEAD_MAX) return { found: false, tag: null };
     }
   } finally {
@@ -1827,7 +2123,7 @@ function watchState(p, ctx, agentId) {
   if (!st || typeof st !== 'object') {
     st = null;
     if (tpath) {
-      const h = readHeadTag(tpath);
+      const h = readHeadTag(tpath, knownTaskTypes(ctx));
       if (h.found) {
         st = h.tag
           ? { dp: true, task_id: h.tag.task_id, run_id: h.tag.task_id ? null : runIdFromPrompt(h.prompt), role: h.tag.role, parent_task_id: h.tag.parent_task_id || null, fired: 0, t: Date.now() }
@@ -1973,18 +2269,24 @@ function handleGate(p, ctx) {
   if (!st || !st.dp) return null;
   const ti = p.tool_input && typeof p.tool_input === 'object' ? p.tool_input : {};
   const why = [];
-  if (st.role && st.role !== 'exec') why.push(`chỉ agent role=exec được giao helper (bạn là role=${st.role})`);
-  if (ti.subagent_type !== HELPER_AGENT_TYPE) why.push(`subagent_type phải là ${HELPER_AGENT_TYPE} (đang là ${ti.subagent_type || 'mặc định'})`);
-  if (!HELPER_MODELS.includes(shortModelName(ti.model))) why.push(`model phải đặt rõ haiku hoặc sonnet (đang là ${ti.model || 'không đặt = kế thừa'})`);
+  const codes = [];
+  if (st.role && st.role !== 'exec') { why.push(`chỉ agent role=exec được giao helper (bạn là role=${st.role})`); codes.push('not-exec'); }
+  if (ti.subagent_type !== HELPER_AGENT_TYPE) { why.push(`subagent_type phải là ${HELPER_AGENT_TYPE} (đang là ${ti.subagent_type || 'mặc định'})`); codes.push('type'); }
+  if (!HELPER_MODELS.includes(shortModelName(ti.model))) { why.push(`model phải đặt rõ haiku hoặc sonnet (đang là ${ti.model || 'không đặt = kế thừa'})`); codes.push('model'); }
   const tag = parseTag(ti.prompt);
   const parentHint = st.task_id || '<task của bạn>';
   if (!tag || tag.role !== 'helper' || !tag.task_id || !tag.parent_task_id) {
     why.push(`dòng đầu prompt phải là [dp:<type>|s<n>|<urgency>|try1|task=<id mới từ dieu-phoi new-id>|role=helper|parent=${parentHint}]`);
+    codes.push('tag');
   } else if (st.task_id && tag.parent_task_id !== st.task_id) {
     why.push(`parent= phải là task của bạn (${st.task_id})`);
+    codes.push('parent');
   }
-  const deny = (list) => ({
+  const child = tag && tag.task_id ? tag.task_id : null;
+  const log = (action, extra) => logGate(ctx, p, agentId, st, Object.assign({ gate_action: action, child_task_id: child }, extra));
+  const deny = (list, reason) => ({
     denied: true,
+    event: log('deny', { reason_code: reason }),
     stdout: JSON.stringify({
       hookSpecificOutput: {
         hookEventName: 'PreToolUse',
@@ -1993,14 +2295,30 @@ function handleGate(p, ctx) {
       },
     }),
   });
-  if (why.length) return deny(why);
+  if (why.length) return deny(why, codes.join('+'));
   const root = path.join(ctx.paths.data, 'gate');
   fs.mkdirSync(root, { recursive: true });
   pruneGate(root);
   const dir = gateDir(ctx, st.task_id || agentId);
   const slot = gateReserve(dir, tag.task_id);
-  if (!slot) return deny([`đã giao đủ ${GATE_MAX_CHILDREN} helper cho bước này — tự làm phần còn lại`]);
-  return { denied: false, slot, children: gateSlots(dir).length };
+  if (!slot) return deny([`đã giao đủ ${GATE_MAX_CHILDREN} helper cho bước này — tự làm phần còn lại`], 'max-children');
+  const children = gateSlots(dir).length;
+  return { denied: false, slot, children, event: log('allow', { slot, children }) };
+}
+
+/**
+ * Core 0.5.2: one `gate` event per gate decision (allow / deny / release) so helper budgets can be measured from the
+ * log instead of slot files. Labels and numbers only. Best effort: logging never changes the decision.
+ */
+function logGate(ctx, p, agentId, st, fields) {
+  const ev = Object.assign({
+    schema: SCHEMA, kind: 'gate', ts: nowIso(), agent_id: agentId,
+    session: p.session_id ? sha8(p.session_id) : null,
+    task_id: st.task_id || null, role: st.role || null,
+    gate_action: null, slot: null, children: null, child_task_id: null, reason_code: null,
+  }, fields, commonFields(ctx));
+  try { appendEvent(ctx, ev); } catch (_) { return null; }
+  return ev;
 }
 
 /** `--gate-release` (PostToolUseFailure(Agent) inside dp-exec): the spawn failed, give its unconfirmed slot back. */
@@ -2015,6 +2333,7 @@ function handleGateRelease(p, ctx) {
   for (const r of gateSlots(gateDir(ctx, st.task_id || agentId))) {
     if (r.child !== tag.task_id || r.started) continue;
     try { fs.unlinkSync(r.file); } catch (_) { /* already gone */ }
+    logGate(ctx, p, agentId, st, { gate_action: 'release', slot: r.slot, child_task_id: tag.task_id });
     return { released: r.slot };
   }
   return null;
@@ -2227,13 +2546,14 @@ async function runSync(ctx, opts) {
 // ------------------------------------------------------------------ exports / main
 
 module.exports = {
-  runsDir, loadPlans, isDieuPhoiPrompt, foldPrompt, sinkStatusCached, sinkUrlKey, SINK_CACHE_TTL_MS, scoutBriefPath, quickHealth, startRun, startInfo, orchLessons, orchLessonLines, abortReasonOf, QUOTA_PAUSE_MARKER, stepIds, START_STEP_IDS, healthLine, formatStartBlock, handleUserPromptSubmit, START_PREFIX, buildSessionState, formatSessionState, stateCounts, compactSystemMessage, handleSessionStart, dispatchInSession, STATE_TEXT_CAP, COMPACT_PREFIX,
+  runsDir, loadPlans, isDieuPhoiPrompt, foldPrompt, sinkStatusCached, sinkUrlKey, SINK_CACHE_TTL_MS, scoutBriefPath, quickHealth, startRun, startInfo, orchLessons, orchLessonLines, abortReasonOf, completionStatus, logGate, QUOTA_PAUSE_MARKER, stepIds, START_STEP_IDS, healthLine, formatStartBlock, handleUserPromptSubmit, START_PREFIX, buildSessionState, formatSessionState, stateCounts, compactSystemMessage, handleSessionStart, dispatchInSession, STATE_TEXT_CAP, COMPACT_PREFIX,
   CORE_VERSION, SCHEMA, TASK_TYPES, URGENCIES, ROLES, MODEL_ALIASES, UNTAGGED,
-  sha8, nowIso, readJsonFile, writeFileAtomic, defaultClaudeDir, resolveHome, pathsFor, loadConfig, makeCtx,
-  logError, computeUserHash, userHash, commonFields, parseTag, TASK_ID_RE, isValidTaskId, newTaskId, taskIdError, normalizeModel, loadPricing,
+  sha8, nowIso, readJsonFile, writeFileAtomic, renameWithRetry, acquireLock, 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,
   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, eventLinesFrom, readEventLines, readEvents,
+  RESULT_ROLES, BLOCKED_RESULT_NAME_RE, resultFileName, findResultFiles, resultRunDir, finalAssistantText, persistInlineResult, orchestratorUsage, orchCacheFile, findSessionTranscript, SESSION_ID_RE, HOOK_COLD_MAX_BYTES, appendEvent, 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,
   extractAgentId, hasAssistantUsage, hasDispatch, buildDispatch, handlePostToolUse, handleSubagentStop, maybeSpawnSync, runHook, runSync,

package/lib/aggregate.cjs

@@ -328,6 +328,9 @@ function buildCells(tasks, opts) {
     const attemptCosts = c.tasks.map((t) => (t.first_cost === undefined ? null : t.first_cost));
     const costMean = mean(costs);
     const timeMean = mean(timesMin);
+    // 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);
     out.push({
       task_type: c.task_type,
       model: c.model,
@@ -354,7 +357,7 @@ function buildCells(tasks, opts) {
       attempt_time_min: mean(attemptTimes),
       attempt_p50_min: percentile(attemptTimes, 0.5),
       attempt_p75_min: percentile(attemptTimes, 0.75),
-      score: costMean === null && timeMean === null ? null : round6((costMean || 0) + lambda * (timeMean || 0)),
+      score: costMean === null && timeP50 === null ? null : round6((costMean || 0) + lambda * (timeP50 || 0)),
       enough: n >= MIN_N,
       note: n >= MIN_N ? '' : 'chưa đủ dữ liệu',
     });

package/lib/args.cjs

@@ -3,7 +3,7 @@
 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']);
+const BOOLEAN_FLAGS = new Set(['json', 'help', 'h', 'purge', 'version', 'v', 'dry-run', 'no-sync', 'approve', 'yes']);
 
 /** Minimal argv parser: positionals, --k v, --k=v, boolean flags. */
 function parseArgs(argv) {

package/lib/choose.cjs

@@ -21,13 +21,14 @@ const HELPER_TOP = 4; // sonnet/high: ceiling for role=helper (gen-2)
 const EFFORT_RANK = { low: 0, medium: 1, high: 2, xhigh: 3, max: 4 };
 
 // Built-in defaults = skill/profile/profile.json for the fixed task types (time caps as tuned 2026-10-12: feature-impl 80,
-// content-write 40, debug 55 — the old ones sat below the observed p50); used only when no profile is found.
+// content-write 40, debug 55 — the old ones sat below the observed p50; 2026-10-18 retro: debug -> sonnet/high, caps of
+// mechanical-edit/test-write/review/plan-design raised to their measured p75); used only when no profile is found.
 const DEFAULT_PRIORS = {
   search: 'haiku/medium',
   extract: 'haiku/medium',
   'mechanical-edit': 'sonnet/medium',
   'feature-impl': 'opus/medium',
-  debug: 'opus/medium',
+  debug: 'sonnet/high',
   refactor: 'opus/medium',
   'test-write': 'sonnet/high',
   review: 'opus/medium',
@@ -39,15 +40,15 @@ const DEFAULT_PRIORS = {
 const DEFAULT_TIME_CAP_MIN = {
   search: 3,
   extract: 5,
-  'mechanical-edit': 10,
+  'mechanical-edit': 25,
   'feature-impl': 80,
   debug: 55,
   refactor: 30,
-  'test-write': 15,
-  review: 10,
+  'test-write': 60,
+  review: 40,
   'research-synth': 20,
   'content-write': 40,
-  'plan-design': 15,
+  'plan-design': 30,
   'data-analysis': 15,
 };
 const DEFAULT_LAMBDA = { relaxed: 0.02, normal: 0.1, urgent: 1.0 };
@@ -502,8 +503,9 @@ function choose(opts) {
     for (const x of scored) {
       const p = betaSample(rng, 1 + x.cell.passes, 1 + x.cell.fails);
       const cost = x.cell.attempt_cost_usd || 0;
+      // p50 (p75 when urgent), never the mean: waiting time inflates the mean (retro 2026-10-18)
       const time = urgency === 'urgent' && x.cell.attempt_p75_min !== null
-        ? x.cell.attempt_p75_min : (x.cell.attempt_time_min || 0);
+        ? x.cell.attempt_p75_min : (x.cell.attempt_p50_min || 0);
       const s = cost / p + lambda * time / p;
       if (!best || s < best.s) best = { i: x.i, s, p };
     }

package/lib/commands.cjs

@@ -186,13 +186,13 @@ const TMP_STALE_MS = 3600 * 1000;
 
 /**
  * Leftovers of writeFileAtomic (tmp written, rename never happened: process killed, or rename lost a race on
- * Windows) under data/, data/orch, data/segments, data/plans. Older than 1 h → removed; newer → reported.
+ * Windows) under data/, data/orch, data/segments, data/plans, data/suggest. Older than 1 h → removed; newer → reported.
  */
 function sweepStaleTmp(ctx) {
   let removed = 0;
   const left = [];
   const now = Date.now();
-  for (const dir of [ctx.paths.data, path.join(ctx.paths.data, 'orch'), ctx.paths.segments, ctx.paths.plans]) {
+  for (const dir of [ctx.paths.data, path.join(ctx.paths.data, 'orch'), ctx.paths.segments, ctx.paths.plans, ctx.paths.suggest]) {
     let names = [];
     try { names = fs.readdirSync(dir); } catch (_) { continue; }
     for (const n of names) {
@@ -659,7 +659,7 @@ function cmdStats(opts) {
     out: `${table(t)}\n\n${table(s)}\n\n${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] + λ·E[time], λ=${lambda} USD/phút.`,
+      + `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.`,
   };
 }
 
@@ -788,6 +788,13 @@ function cmdChoose(opts) {
     const tid = input.taskId;
     core.appendEvent(ctx, overrideEvent(ctx, tid, res.task_type || String(input.type).toLowerCase(), res.suggested_tier, res.tier));
   }
+  // core 0.5.3: the next dispatch of this task + role logs suggested_tier / choose_tier next to the tier it ran on
+  if (input.taskId && res.action === 'dispatch' && res.tier) {
+    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,
+    });
+  }
   if (opts.json) return { code: 0, out: JSON.stringify(res) };
   const typeWarn = res.type_warning && !String(res.reason).includes(res.type_warning) ? `\nCẢNH BÁO: ${res.type_warning}` : '';
   const warn = `${typeWarn}${res.orch_ctx_warn ? `\nCẢNH BÁO: ${orch.advice}` : ''}`;
@@ -954,6 +961,19 @@ function planOverrideEvents(ctx, plan, events) {
   return out;
 }
 
+/** Core 0.5.3: each approved step with a task_id leaves its choose tier for the step's dispatch (data/suggest/). */
+function recordPlanSuggestions(ctx, plan) {
+  let n = 0;
+  for (const r of plan.steps) {
+    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',
+    });
+    if (ok) n++;
+  }
+  return n;
+}
+
 function recordApprovedPlan(ctx, root, stepsFile, plan) {
   const file = path.join(ctx.paths.plans, `${root}.json`);
   const prev = core.readJsonFile(file, null);
@@ -1021,6 +1041,7 @@ function cmdPlanTable(opts) {
   const rec = opts.approve ? recordApprovedPlan(ctx, String(opts.root), path.resolve(opts.file), plan) : null;
   const ovs = rec ? planOverrideEvents(ctx, plan, base.events) : [];
   for (const ev of ovs) core.appendEvent(ctx, ev);
+  if (rec) recordPlanSuggestions(ctx, plan);
   if (opts.json) {
     const out = rec ? Object.assign({}, plan, {
       approved: { root_task_id: rec.root_task_id, approval: rec.approval, record: rec.file, overrides_logged: ovs.length },
@@ -1050,6 +1071,6 @@ function cmdPlanTable(opts) {
 }
 
 module.exports = {
-  cmdSetup, cmdUninstall, cmdDoctor, cmdStart, checkSinkLive, cmdHook, cmdSync, cmdVerdict, cmdSteer, cmdDiscard, ctxWarnOnce, ctxWarnLevel, sweepStaleTmp, planOverrideEvents, cmdStats, cmdRetro, cmdChoose, cmdCtx, cmdState, measureOrch,
+  cmdSetup, cmdUninstall, cmdDoctor, cmdStart, checkSinkLive, cmdHook, cmdSync, cmdVerdict, cmdSteer, cmdDiscard, ctxWarnOnce, ctxWarnLevel, sweepStaleTmp, planOverrideEvents, recordPlanSuggestions, cmdStats, cmdRetro, cmdPrune: (o) => require('./prune.cjs').cmdPrune(o), cmdChoose, cmdCtx, cmdState, measureOrch,
   cmdPlanTable, cmdNewId, requireTaskId, buildPlanTable, recordApprovedPlan, planTaskIdProblems, criticalPath, resolveAgentId, AGENT_OUTCOMES, USER_OUTCOMES, VERIFY,
 };

package/lib/prune.cjs

@@ -0,0 +1,321 @@
+'use strict';
+// `dieu-phoi prune --after-retro <file> [--yes]` (core 0.5.2): post-retro cleanup of closed run dirs, bad plan
+// files and events.jsonl (moved to a gz archive, never deleted). Dry-run unless --yes.
+// Only touches: <runs dir>/<id>/, <data>/plans, <data>/events.jsonl, <data>/archive, <data>/sync-offset.json.
+
+const fs = require('fs');
+const path = require('path');
+const zlib = require('zlib');
+const core = require('../hook.cjs');
+const { ctxOf } = require('./args.cjs');
+
+const RUN_ID_RE = /^[A-Za-z0-9_-]{1,64}$/;
+const OUT_RE = /^dp-out-(.+?)-(exec|verify|plan|helper)-try(\d+)(?:[-.].*)?\.md$/;
+// legacy result names; the task segment is optional (`report-try6.md` ranks under the run dir's own task)
+const LEGACY_RE = /^(report|verify)-(?:(.+?)-)?try(\d+)(?:-[A-Za-z0-9-]*)?\.md$/;
+// anything else that looks like a result but cannot be ranked is kept (conservative): report-deploy.md, verify-tokens.md,
+// dp-out-*.md with an odd shape. dp-out-*-debug-* logs are deliberately not results.
+const RESULT_LIKE_RE = /^(?:(?:report|verify)-.*|dp-out-(?!.*-debug-).*)\.md$/;
+
+function inside(root, p) {
+  const r = path.relative(path.resolve(root), path.resolve(p));
+  return !!r && !r.startsWith('..') && !path.isAbsolute(r);
+}
+
+function archiveDir(ctx) { return path.join(ctx.paths.data, 'archive'); }
+
+/** Cutoff (ms): `cutoff: <date|iso>` line in the retro file, else its mtime. Date-only = end of that UTC day. */
+function cutoffOf(file) {
+  const st = fs.statSync(file);
+  let text = '';
+  try { text = fs.readFileSync(file, 'utf8'); } catch (_) { /* mtime */ }
+  const m = /^\s*[*_>-]*\s*(?:cutoff|cut-off|mốc)\s*[*_]*\s*[:=]\s*[*_`]*\s*([0-9T:.\-Z+]{8,40})/im.exec(text);
+  if (m) {
+    let t = Date.parse(m[1]);
+    if (!isNaN(t)) {
+      if (/^\d{4}-\d{2}-\d{2}$/.test(m[1])) t += 86400000 - 1;
+      return { ms: t, source: 'cutoff-line' };
+    }
+  }
+  return { ms: st.mtimeMs, source: 'mtime' };
+}
+
+function sizeOf(p) {
+  let st;
+  try { st = fs.lstatSync(p); } catch (_) { return 0; }
+  if (!st.isDirectory()) return st.size;
+  let n = 0;
+  try { for (const c of fs.readdirSync(p)) n += sizeOf(path.join(p, c)); } catch (_) { /* gone */ }
+  return n;
+}
+
+function human(n) {
+  if (n >= 1048576) return `${(n / 1048576).toFixed(1)} MB`;
+  if (n >= 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${n} B`;
+}
+
+/**
+ * Files to keep in a run dir: retro-*.md + per task/role the highest-try result AND the newest-by-mtime result
+ * (dp-out, legacy or .inline.md). A re-run can write a lower try number later (e.g. try1 after a blocked try5),
+ * so the try number alone can pick a stale attempt. `mtimeOf(name)` is optional; without it only the highest try is kept.
+ */
+function keepSet(names, mtimeOf) {
+  const keep = new Set();
+  const best = new Map(); // task|role -> max try
+  const parsed = [];
+  for (const n of names) {
+    if (/^retro-.*\.md$/.test(n)) { keep.add(n); continue; }
+    const inline = /\.inline\.md$/.test(n); // hook fallback copy: only written when the agent wrote no dp-out
+    let m = OUT_RE.exec(n);
+    let task; let role; let tr;
+    if (m) { task = m[1]; role = m[2]; tr = Number(m[3]); } else {
+      m = LEGACY_RE.exec(n);
+      if (!m) { if (RESULT_LIKE_RE.test(n)) keep.add(n); continue; }
+      task = m[2] || '(dir)'; role = m[1] === 'report' ? 'exec' : 'verify'; tr = Number(m[3]);
+    }
+    if (role !== 'exec' && role !== 'verify') continue;
+    parsed.push({ n, k: `${task}|${role}`, tr, inline });
+    best.set(`${task}|${role}`, Math.max(best.get(`${task}|${role}`) || 0, tr));
+  }
+  // final = highest try over written dp-out, legacy and inline; a written file beats an inline at the same try
+  const hasWritten = new Set(parsed.filter((p) => !p.inline).map((p) => `${p.k}|${p.tr}`));
+  for (const p of parsed) {
+    if (p.tr !== best.get(p.k)) continue;
+    if (p.inline && hasWritten.has(`${p.k}|${p.tr}`)) continue;
+    keep.add(p.n);
+  }
+  if (typeof mtimeOf === 'function') {
+    const newest = new Map(); // task|role -> newest candidate (ties: higher try)
+    for (const p of parsed) {
+      if (p.inline && hasWritten.has(`${p.k}|${p.tr}`)) continue;
+      let m = 0;
+      try { m = Number(mtimeOf(p.n)) || 0; } catch (_) { m = 0; }
+      const cur = newest.get(p.k);
+      if (!cur || m > cur.m || (m === cur.m && p.tr > cur.tr)) newest.set(p.k, { n: p.n, m, tr: p.tr });
+    }
+    for (const v of newest.values()) keep.add(v.n);
+  }
+  return keep;
+}
+
+function taskIdsOfDir(id, names, plansDir) {
+  const ids = new Set([id]);
+  const plan = core.readJsonFile(path.join(plansDir, `${id}.json`), null);
+  if (plan && Array.isArray(plan.steps)) for (const s of plan.steps) if (s && typeof s.task_id === 'string') ids.add(s.task_id);
+  for (const n of names) {
+    const m = OUT_RE.exec(n) || LEGACY_RE.exec(n);
+    if (m) { const t = OUT_RE.test(n) ? m[1] : m[2]; if (t) ids.add(t); }
+    const h = /^handoff-(.+)\.md$/.exec(n);
+    if (h) ids.add(h[1]);
+  }
+  return ids;
+}
+
+/** Eligible run dirs: every event of its tasks ≤ cutoff and every dispatched task has a user verdict (or was discarded). */
+function planRuns(ctx, events, cutoffMs, protect) {
+  const runs = core.runsDir();
+  const byTask = new Map();
+  for (const e of events) {
+    if (!e || !e.task_id) continue;
+    if (!byTask.has(e.task_id)) byTask.set(e.task_id, []);
+    byTask.get(e.task_id).push(e);
+  }
+  const out = { prune: [], skipped: [] };
+  let dirs = [];
+  try { dirs = fs.readdirSync(runs, { withFileTypes: true }); } catch (_) { return out; }
+  for (const d of dirs) {
+    const id = d.name;
+    if (!d.isDirectory() || !RUN_ID_RE.test(id)) continue;
+    const dir = path.join(runs, id);
+    if (!inside(runs, dir)) continue;
+    const names = fs.readdirSync(dir);
+    const tasks = Array.from(taskIdsOfDir(id, names, ctx.paths.plans));
+    let anyVerdict = false; let reason = null; let latest = 0;
+    for (const t of tasks) {
+      const evs = byTask.get(t) || [];
+      const discarded = evs.some((e) => e.kind === 'discard');
+      const uv = evs.some((e) => e.kind === 'verdict' && e.by === 'user' && (e.outcome === 'accept' || e.outcome === 'reject'));
+      if (uv) anyVerdict = true;
+      for (const e of evs) {
+        const ts = Date.parse(e.ts);
+        if (!isNaN(ts)) latest = Math.max(latest, ts);
+        if (isNaN(ts) || ts > cutoffMs) reason = reason || `sự kiện sau mốc cắt (task ${t})`;
+      }
+      const dispatched = evs.some((e) => e.kind === 'dispatch' && e.role !== 'plan' && e.role !== 'helper');
+      if (dispatched && !uv && !discarded) reason = reason || `task ${t} chưa có verdict người dùng`;
+    }
+    if (!reason && !anyVerdict) reason = 'chưa có verdict người dùng';
+    // a file written after the cutoff = work still going on in this dir (e.g. a step not yet in the log)
+    if (!reason) {
+      for (const n of names) {
+        let m = 0;
+        try { m = fs.lstatSync(path.join(dir, n)).mtimeMs; } catch (_) { /* gone */ }
+        if (m > cutoffMs) { reason = 'có file mới hơn mốc cắt'; break; }
+      }
+    }
+    if (reason) { out.skipped.push({ id, reason }); continue; }
+    const keep = keepSet(names, (n) => { try { return fs.lstatSync(path.join(dir, n)).mtimeMs; } catch (_) { return 0; } });
+    const del = [];
+    let delBytes = 0; let keepBytes = 0;
+    for (const n of names) {
+      const p = path.join(dir, n);
+      if (keep.has(n) || (protect && path.resolve(p) === protect)) { keepBytes += sizeOf(p); continue; }
+      const b = sizeOf(p);
+      del.push({ name: n, bytes: b });
+      delBytes += b;
+    }
+    out.prune.push({ id, dir, tasks, keep: Array.from(keep).sort(), del, delete_bytes: delBytes, keep_bytes: keepBytes });
+  }
+  return out;
+}
+
+function badPlans(ctx) {
+  let names = [];
+  try { names = fs.readdirSync(ctx.paths.plans); } catch (_) { return []; }
+  const out = [];
+  for (const n of names) {
+    if (!n.endsWith('.json')) continue;
+    const p = path.join(ctx.paths.plans, n);
+    if (!inside(ctx.paths.plans, p)) continue;
+    let st; try { st = fs.lstatSync(p); } catch (_) { continue; }
+    if (!st.isFile()) continue;
+    const parsed = core.readJsonFile(p, null);
+    const okShape = parsed && typeof parsed.root_task_id === 'string' && Array.isArray(parsed.steps);
+    if (!core.isValidTaskId(n.slice(0, -5)) || !okShape) out.push({ path: p, name: n, bytes: st.size });
+  }
+  return out;
+}
+
+/** Event lines (raw text + byte range) of events.jsonl, with parsed object (null if unparseable). */
+function eventLines(ctx) {
+  const buf = core.readEventsBuffer(ctx);
+  return { buf, lines: core.eventLinesFrom(buf, 0).map((l) => {
+    let obj = null;
+    try { const o = JSON.parse(l.text); if (o && typeof o === 'object') obj = o; } catch (_) { /* keep */ }
+    return Object.assign(l, { obj });
+  }) };
+}
+
+function archiveToday() { return new Date().toISOString().slice(0, 10); }
+
+/** Append one gzip member to today's archive via temp file; verify by re-reading; then rename into place. */
+function writeArchive(ctx, texts) {
+  fs.mkdirSync(archiveDir(ctx), { recursive: true });
+  const file = path.join(archiveDir(ctx), `events-${archiveToday()}.jsonl.gz`);
+  let prev = Buffer.alloc(0);
+  try { prev = fs.readFileSync(file); } catch (_) { /* new */ }
+  const prevCount = prev.length ? zlib.gunzipSync(prev).toString('utf8').split('\n').filter((l) => l.trim()).length : 0;
+  const member = zlib.gzipSync(Buffer.from(`${texts.join('\n')}\n`, 'utf8'));
+  const tmp = `${file}.tmp-${process.pid}`;
+  fs.writeFileSync(tmp, Buffer.concat([prev, member]));
+  const back = zlib.gunzipSync(fs.readFileSync(tmp)).toString('utf8').split('\n').filter((l) => l.trim());
+  if (back.length !== prevCount + texts.length || back.slice(prevCount).some((l, i) => l !== texts[i])) {
+    try { fs.unlinkSync(tmp); } catch (_) { /* gone */ }
+    throw new Error('xác minh archive thất bại — events.jsonl giữ nguyên');
+  }
+  core.renameWithRetry(tmp, file);
+  return file;
+}
+
+function cmdPrune(opts) {
+  const ctx = ctxOf(opts);
+  const retro = typeof opts['after-retro'] === 'string' ? path.resolve(opts['after-retro']) : null;
+  if (!retro) return { code: 2, out: 'prune: thiếu --after-retro <file retro>' };
+  let st; try { st = fs.statSync(retro); } catch (_) { st = null; }
+  if (!st || !st.isFile()) return { code: 2, out: `prune: không đọc được file retro: ${retro}` };
+  const runs = core.runsDir();
+  const home = ctx.paths.data;
+  for (const [name, p] of [['runs', runs], ['data', home]]) {
+    if (!path.isAbsolute(p) || p === path.parse(p).root) return { code: 2, out: `prune: từ chối đường dẫn ${name} không an toàn: ${p}` };
+  }
+  const yes = opts.yes === true || opts.yes === 'y' || opts.yes === 'yes';
+  const cut = cutoffOf(retro);
+  const { lines } = fs.existsSync(ctx.paths.events) ? eventLines(ctx) : { lines: [] };
+  const allEvents = core.readEvents(ctx);
+  const rp = planRuns(ctx, allEvents, cut.ms, retro);
+  const prunedTasks = new Set();
+  for (const r of rp.prune) for (const t of r.tasks) prunedTasks.add(t);
+  const plans = badPlans(ctx);
+
+  // events to archive: lines of pruned tasks ≤ cutoff; with a sink, only those already pushed (end ≤ offset)
+  const cfg = ctx.config || {};
+  const hasSink = !!(cfg.sink_url && cfg.sink_token);
+  const unsynced = core.unsyncedInfo(ctx);
+  const archived = new Set(core.readArchiveLines(ctx));
+  const moving = lines.filter((l) => l.obj && l.obj.task_id && prunedTasks.has(l.obj.task_id)
+    && Date.parse(l.obj.ts) <= cut.ms && (!hasSink || l.end <= unsynced.offset));
+  const heldBack = lines.filter((l) => l.obj && l.obj.task_id && prunedTasks.has(l.obj.task_id)
+    && Date.parse(l.obj.ts) <= cut.ms).length - moving.length;
+  const evBytes = moving.reduce((n, l) => n + (l.end - l.start), 0);
+
+  const report = {
+    mode: yes ? 'apply' : 'dry-run', retro, cutoff: new Date(cut.ms).toISOString(), cutoff_source: cut.source,
+    runs: rp.prune.map((r) => ({ id: r.id, delete_files: r.del.length, delete_bytes: r.delete_bytes, keep: r.keep, keep_bytes: r.keep_bytes })),
+    runs_skipped: rp.skipped.length,
+    skipped_reasons: rp.skipped.reduce((a, s) => { const k = s.reason.replace(/task \S+/, 'task *').replace(/\(task \S+\)/, ''); a[k] = (a[k] || 0) + 1; return a; }, {}),
+    bad_plans: plans.map((p) => ({ name: p.name, bytes: p.bytes })),
+    events: { archive: moving.length, bytes: evBytes, held_back_unsynced: heldBack, total: lines.length },
+  };
+  report.totals = {
+    run_dirs: rp.prune.length,
+    files: rp.prune.reduce((n, r) => n + r.del.length, 0),
+    bytes: rp.prune.reduce((n, r) => n + r.delete_bytes, 0) + plans.reduce((n, p) => n + p.bytes, 0),
+  };
+
+  if (yes) {
+    // 1. events → archive (archive first + verified, then rewrite events.jsonl via temp + rename)
+    if (moving.length) {
+      const fresh = moving.filter((l) => !archived.has(l.text));
+      const lock = core.acquireLock(ctx.paths.lock);
+      if (!lock) return { code: 1, out: 'prune: sync đang giữ khoá — thử lại sau' };
+      try {
+        if (fresh.length) writeArchive(ctx, fresh.map((l) => l.text));
+        const buf = core.readEventsBuffer(ctx);
+        const drop = new Map(moving.map((l) => [l.start, l.text]));
+        const parts = []; let removedBeforeOffset = 0;
+        let pos = 0;
+        for (const l of core.eventLinesFrom(buf, 0)) {
+          parts.push(buf.subarray(pos, l.start)); // blank lines between
+          if (drop.get(l.start) === l.text) {
+            if (l.end <= unsynced.offset) removedBeforeOffset += l.end - l.start;
+          } else parts.push(buf.subarray(l.start, l.end));
+          pos = l.end;
+        }
+        parts.push(buf.subarray(pos));
+        let next = Buffer.concat(parts);
+        const cur = core.readEventsBuffer(ctx);
+        if (cur.length > buf.length) next = Buffer.concat([next, cur.subarray(buf.length)]); // appended meanwhile
+        const tmp = `${ctx.paths.events}.tmp-${process.pid}`;
+        fs.writeFileSync(tmp, next);
+        core.renameWithRetry(tmp, ctx.paths.events);
+        if (unsynced.offset > 0) core.writeFileAtomic(ctx.paths.syncOffset, `${JSON.stringify({ offset: Math.max(0, unsynced.offset - removedBeforeOffset), ts: core.nowIso() })}\n`);
+      } finally {
+        try { fs.unlinkSync(ctx.paths.lock); } catch (_) { /* gone */ }
+      }
+    }
+    // 2. run dirs
+    for (const r of rp.prune) {
+      for (const f of r.del) {
+        const p = path.join(r.dir, f.name);
+        if (!inside(r.dir, p) || !inside(runs, p)) continue;
+        fs.rmSync(p, { recursive: true, force: true });
+      }
+      try { if (!fs.readdirSync(r.dir).length) fs.rmdirSync(r.dir); } catch (_) { /* keep */ }
+    }
+    // 3. bad plans
+    for (const p of plans) if (inside(ctx.paths.plans, p.path)) fs.rmSync(p.path, { force: true });
+  }
+
+  if (opts.json) return { code: 0, out: JSON.stringify(report, null, 2) };
+  const L = [];
+  L.push(`prune ${yes ? '(ĐÃ THỰC HIỆN)' : '(dry-run — thêm --yes để thực hiện)'}: mốc cắt ${report.cutoff} (${cut.source}) từ ${retro}`);
+  L.push(`Run dir: ${rp.prune.length} sẽ dọn, ${rp.skipped.length} giữ nguyên (còn mở / sau mốc)`);
+  for (const r of rp.prune) L.push(`  ${r.id}: xoá ${r.del.length} mục (${human(r.delete_bytes)}), giữ ${r.keep.length} (${human(r.keep_bytes)})`);
+  L.push(`Plan hỏng: ${plans.length} (${human(plans.reduce((n, p) => n + p.bytes, 0))})${plans.length ? ` — ${plans.map((p) => p.name).join(', ')}` : ''}`);
+  L.push(`events.jsonl: ${moving.length}/${lines.length} dòng → archive/events-${archiveToday()}.jsonl.gz (${human(evBytes)})${heldBack ? `; ${heldBack} dòng chưa đẩy lên sink nên giữ lại` : ''}; không xoá dòng nào`);
+  L.push(`Tổng xoá khỏi đĩa: ${report.totals.files} mục run dir + ${plans.length} plan = ${human(report.totals.bytes)}`);
+  return { code: 0, out: L.join('\n') };
+}
+
+module.exports = { cmdPrune, keepSet, cutoffOf };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kienntpixon/dieu-phoi",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "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>",