@kienntpixon/dieu-phoi 0.5.1 → 0.5.2

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog — @kienntpixon/dieu-phoi
 
+## 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

@@ -25,7 +25,7 @@ const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
 
-const CORE_VERSION = '0.5.1';
+const CORE_VERSION = '0.5.2';
 const SCHEMA = 1;
 const TASK_TYPES = [
   'search', 'extract', 'mechanical-edit', 'feature-impl', 'debug', 'refactor',
@@ -413,8 +413,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 +443,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 +468,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 +806,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;
 }
 
@@ -1609,6 +1649,19 @@ function handleSubagentStop(p, ctx) {
     cost_usd: sum ? sum.cost_usd : null,
     model: sum ? sum.model : null,
   }, 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 +1671,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 +1718,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
@@ -1973,18 +2048,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 +2074,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 +2112,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 +2325,13 @@ 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,
+  sha8, nowIso, readJsonFile, writeFileAtomic, renameWithRetry, acquireLock, defaultClaudeDir, resolveHome, pathsFor, loadConfig, makeCtx,
   logError, computeUserHash, userHash, commonFields, parseTag, 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

@@ -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.`,
   };
 }
 
@@ -1050,6 +1050,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, 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.2",
   "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>",