@kienntpixon/dieu-phoi 0.7.4 → 0.7.5

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog — @kienntpixon/dieu-phoi
 
+## 0.7.5 (2026-11-06)
+
+Đi cùng skill 1.6.5. `CORE_VERSION` 0.7.5. Không đổi sink (`sheet/Code.gs`, `fixtures/` giữ nguyên).
+**Sau khi cài:** `npm i -g @kienntpixon/dieu-phoi` + `dieu-phoi setup` + `dieu-phoi doctor`.
+
+- **`wt clean --merged [--repo R] [--yes]`:** gỡ worktree có dấu và nhánh local khi nhánh đã vào HEAD checkout chính. Điều kiện: tuổi ≥ 1 giờ (worktree mới chưa commit luôn "đã merge"), verdict gần nhất của task không thuộc reject/fail/timeout/aborted, sạch, không agent sống. Dry-run mặc định; `git branch -d` (không force).
+- **Nhắc sau nghiệm thu:** `verdict --root … accept` / `verdict --task … accept` của người dùng in một dòng số worktree đã merge của repo; `--clean-merged` gỡ luôn (như `wt clean --merged --yes`).
+- **`wt add --base <ref>`:** tạo nhánh từ commit chọn được, sửa known issue 0.7.4 (trước đây luôn từ HEAD checkout chính). Ở mức cảnh báo 75% hoặc khi bị chặn trần, `wt add` gợi ý worktree của bước đã xong có thể tái dùng (sạch, không agent sống, verdict pass/accept); không tự dùng lại.
+- **Knowledge delta, header `repo:`:** nhận cả dạng hiển thị `repo: <tên> (<tag>) — <dir>` (chép từ `knowledge get`) lẫn đường dẫn thô, LF/CRLF. Lỗi nay nói đúng nguyên nhân: tên ngắn không khớp kho nào / thư mục trong header không còn (worktree đã gỡ hoặc header sai) / đường dẫn không tồn tại.
+
 ## 0.7.4 (2026-11-06)
 
 Đi cùng skill 1.6.4. `CORE_VERSION` 0.7.4. Không đổi sink (`sheet/Code.gs` giữ nguyên).

package/bin/dieu-phoi.cjs

@@ -35,10 +35,11 @@ Cách dùng: dieu-phoi <lệnh> [tuỳ chọn]
   verdict --root <root_task_id> accept [--steps a,b]
                          người dùng nhận mọi bước đã giao exec của kế hoạch đã duyệt chưa có verdict người dùng
                          accept (--task/--root) tự gộp knowledge-delta-<task_id>*.md của run vào kho (--no-knowledge: bỏ)
+                         accept của người dùng nhắc số worktree đã merge của repo (một dòng); --clean-merged: gỡ luôn (wt clean --merged --yes)
   discard --task <task_id> [--reason R]
                          loại một task nhầm khỏi thống kê/choose/state (ghi sự kiện discard, không sửa log);
                          gỡ worktree có dấu của task nếu sạch (còn thay đổi thì giữ và báo)
-  wt add --task <task_id> [--repo R] [--path D] [--branch B] [--force] [--deps auto|link|install|none] [--deps-path D]
+  wt add --task <task_id> [--repo R] [--path D] [--branch B] [--base REF] [--force] [--deps auto|link|install|none] [--deps-path D]
                          tạo worktree cho một bước: <cha repo>/<tên repo>-wt-<task_id> trên nhánh dp/<task_id>,
                          có dấu dieu-phoi (điều phối viên dùng lệnh này, không git worktree add tay).
                          Repo đủ max_worktrees_repo (8; đếm cả checkout chính) thì từ chối kèm ứng viên dọn; --force vượt trần.
@@ -48,6 +49,9 @@ Cách dùng: dieu-phoi <lệnh> [tuỳ chọn]
   wt clean [--repo R] [--stale-days N] [--yes]
                          liệt kê worktree có dấu mà task đã nghiệm thu / bị loại, thư mục đã mất, hoặc sạch + nhánh đã merge
                          + cũ ≥ N ngày (mặc định wt_stale_days 7); mặc định dry-run, --yes mới gỡ (còn thay đổi luôn giữ; nhánh giữ nguyên)
+  wt clean --merged [--repo R] [--yes]
+                         gỡ worktree có dấu mà nhánh đã vào HEAD checkout chính, có verdict (không reject/fail), tuổi ≥ 1 giờ,
+                         không agent sống, sạch; rồi git branch -d nhánh. Dry-run mặc định; không đụng checkout chính / worktree không dấu
   wt list [--repo R] [--all] [--json]
                          bảng worktree có dấu: task, tuổi, sạch/bẩn, node_modules (link|dir|none), deps của dấu; --all thêm worktree không dấu (chỉ báo)
   steer <agent_id> --kind minor|plan|redirect [--reason R]

package/hook.cjs

@@ -28,7 +28,7 @@ const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
 
-const CORE_VERSION = '0.7.4';
+const CORE_VERSION = '0.7.5';
 const SCHEMA = 1;
 const TASK_TYPES = [
   'search', 'extract', 'mechanical-edit', 'feature-impl', 'debug', 'refactor',

package/lib/args.cjs

@@ -4,7 +4,7 @@ const fs = require('fs');
 const path = require('path');
 const core = require('../hook.cjs');
 
-const BOOLEAN_FLAGS = new Set(['json', 'help', 'h', 'purge', 'version', 'v', 'dry-run', 'no-sync', 'approve', 'yes', 'force', 'follow', 'remove', 'dirty', 'no-cache', 'untagged', 'no-knowledge', 'net', 'with-codebase-memory', 'cbm', 'allow-custom-source', 'auto', 'include-local', 'orphans']);
+const BOOLEAN_FLAGS = new Set(['json', 'help', 'h', 'purge', 'version', 'v', 'dry-run', 'no-sync', 'approve', 'yes', 'force', 'follow', 'remove', 'dirty', 'no-cache', 'untagged', 'no-knowledge', 'net', 'with-codebase-memory', 'cbm', 'allow-custom-source', 'auto', 'include-local', 'orphans', 'merged', 'clean-merged']);
 
 /** Minimal argv parser: positionals, --k v, --k=v, boolean flags. */
 function parseArgs(argv) {

package/lib/commands.cjs

@@ -754,6 +754,8 @@ function cmdVerdict(opts) {
     const kn = knowledgeOnAccept(opts, ctx, root, [root].concat(list.map((x) => x.ev.task_id)), true, events);
     // s17: accept của người dùng gỡ worktree có dấu của từng bước (sạch); còn thay đổi thì giữ và báo.
     const wtLines = list.reduce((acc, x) => acc.concat(wt.cleanupTask(ctx, events, x.ev.task_id, opts.repo)), []);
+    // s4 (0.7.5): nhắc số worktree đã merge của repo; --clean-merged thì gỡ luôn (wt clean --merged --yes).
+    wtLines.push(...wt.mergedAfterAccept(ctx, list.map((x) => x.ev.task_id), opts.repo, opts['clean-merged'] === true));
     if (!list.length) {
       // Every step was already judged (e.g. accepted one by one with --task): still merge the root + untagged deltas.
       // Exit code follows the merge (0 merged or nothing new, 2 conflict or reject, 1 error); no delta at all keeps the old "nothing to do" error.
@@ -775,6 +777,7 @@ function cmdVerdict(opts) {
   const kn = ev.by === 'user' && ev.outcome === 'accept' ? knowledgeOnAccept(opts, ctx, rootOfTask(ctx, ev.task_id), [ev.task_id], false, events) : null;
   // s17: người dùng accept → gỡ worktree có dấu của task (sạch); reject giữ nguyên để làm lại.
   const wtLines = ev.by === 'user' && ev.outcome === 'accept' ? wt.cleanupTask(ctx, events, ev.task_id, opts.repo) : [];
+  if (ev.by === 'user' && ev.outcome === 'accept') wtLines.push(...wt.mergedAfterAccept(ctx, [ev.task_id], opts.repo, opts['clean-merged'] === true));
   if (opts.json) {
     if (kn && kn.out) process.stderr.write(`${kn.out}\n`);
     if (wtLines.length) process.stderr.write(`${wtLines.join('\n')}\n`);

package/lib/knowledge.cjs

@@ -521,7 +521,7 @@ function splitList(v, lower) {
 /** Parse a delta file: { repo, head, sections: [{ add, rawId, id, title?, tags?, paths?, base?, body, lines }] }. */
 function parseDelta(text) {
   const lines = String(text).replace(/^/, '').split(LINE_BREAK);
-  const out = { repo: null, head: null, sections: [] };
+  const out = { repo: null, repoDir: null, head: null, sections: [] };
   let cur = null;
   let fence = false;
   for (const line of lines) {
@@ -534,7 +534,16 @@ function parseDelta(text) {
     }
     if (cur) { cur.raw.push(line); continue; }
     const m = /^\s*(repo|head)\s*:\s*(.+?)\s*$/i.exec(line);
-    if (m && !out[m[1].toLowerCase()]) out[m[1].toLowerCase()] = unquote(m[2].replace(/[.;,]+$/, '')).replace(/[.;,]+$/, '');
+    if (m && !out[m[1].toLowerCase()]) {
+      const val = unquote(m[2].replace(/[.;,]+$/, '')).replace(/[.;,]+$/, '');
+      const k = m[1].toLowerCase();
+      // display form written by repoLine(): `name (tag) — dir` -> name + dir
+      const dm = k === 'repo' ? /^(.*?)\s+—\s+(.+)$/.exec(val) : null;
+      if (dm) {
+        out.repo = dm[1].replace(/\s*\([^)]*\)\s*$/, '').trim() || dm[2].trim();
+        out.repoDir = dm[2].trim();
+      } else out[k] = val;
+    }
   }
   for (const s of out.sections) {
     s.id = s.rawId.toLowerCase();
@@ -821,11 +830,15 @@ function targetOf(delta, opts, rep) {
     }
   }
   if (delta.repo) {
-    const p = path.resolve(core.nativePath(delta.repo));
+    const shown = delta.repoDir ? `${delta.repo} — ${delta.repoDir}` : delta.repo;
+    const p = path.resolve(core.nativePath(delta.repoDir || delta.repo));
     if (isDir(p)) return finish(p);
-    if (opts.repo !== undefined) { rep.note = `repo: ${delta.repo} không còn — dùng --repo`; return finish(repoOf(opts)); }
-    const bare = core.isBareRepoName(delta.repo);
-    return err(`repo: ${delta.repo} ${bare ? 'không khớp kho nào đã biết và không phải thư mục' : 'không tồn tại (worktree đã xoá?)'} — chạy lại với --repo <đường dẫn repo>`);
+    if (opts.repo !== undefined) { rep.note = `repo: ${shown} không còn — dùng --repo`; return finish(repoOf(opts)); }
+    const bare = !delta.repoDir && core.isBareRepoName(delta.repo);
+    const why = bare ? 'tên ngắn không khớp kho nào đã biết (chưa có kho tri thức?) và không phải thư mục'
+      : delta.repoDir ? `thư mục ${slash(delta.repoDir)} không tồn tại (worktree đã xoá, hoặc đường dẫn trong header sai?)`
+        : 'không tồn tại (worktree đã xoá, hoặc header repo: sai?)';
+    return err(`repo: ${shown} ${why} — chạy lại với --repo <đường dẫn repo>`);
   }
   return err('không xác định được repo');
   function finish(target) {

package/lib/worktree.cjs

@@ -7,6 +7,9 @@
 //    `git worktree remove` (không --force), nhánh giữ nguyên; còn thay đổi chưa commit thì giữ và báo.
 //    Worktree không dấu không bị đụng.
 //  - `wt clean` (dry-run mặc định) liệt kê worktree có dấu mà task đã nghiệm thu / bị loại, hoặc thư mục đã mất.
+// core 0.7.5 (s4):
+//  - `wt clean --merged`: gỡ worktree có dấu mà nhánh đã vào HEAD checkout chính, có verdict (không reject/fail),
+//    tuổi ≥ 1 giờ, không agent sống, sạch; rồi `git branch -d`. verdict accept của người dùng chỉ nhắc (--clean-merged: gỡ).
 // core 0.7.3 (s2):
 //  - Trần worktree/repo (max_worktrees_repo, mặc định 8, 0 = tắt): `wt add` đếm mọi mục của `git worktree list`
 //    (gồm checkout chính, có dấu hay không). Đủ trần → từ chối kèm ứng viên dọn (sạch, có dấu, cũ nhất); --force bỏ qua.
@@ -31,6 +34,11 @@ const BRANCH_PREFIX = 'dp/';
 const DAY_MS = 86400000;
 const DEFAULT_MAX_WORKTREES = 8;
 const DEFAULT_STALE_DAYS = 7;
+// s3 (core 0.7.5): verdict cuối không thuộc nhóm này thì bước chưa xong (nhánh không có commit mới vẫn "đã merge").
+const NOT_DONE = new Set(['reject', 'fail', 'timeout', 'aborted']);
+// s4 (0.7.5): `wt clean --merged` chỉ gỡ worktree tuổi ≥ 1 giờ có verdict (pass/accept). Worktree vừa tạo có 0 commit
+// nên "đã merge" tầm thường; không có ngưỡng này thì bước đang chờ agent đầu tiên có thể bị gỡ.
+const MERGED_MIN_AGE_MS = 60 * 60 * 1000;
 
 function git(cwd, args) {
   const r = cp.spawnSync('git', args, { cwd, encoding: 'utf8', windowsHide: true, timeout: 60000 });
@@ -247,6 +255,35 @@ function candidateLines(common) {
   return `Ứng viên dọn (sạch, có dấu, cũ nhất trước):\n${c.map((w) => `  - ${w.path} task=${w.task_id} tạo ${w.created_ts || '?'}`).join('\n')}`;
 }
 
+/**
+ * s3 (core 0.7.5): worktree có dấu của bước đã xong, có thể tái dùng. Điều kiện: còn thư mục, sạch, không có agent
+ * sống, task không bị loại, và (verdict cuối của task là pass/accept, hoặc nhánh đã vào HEAD mà task đã có verdict).
+ * Nhánh "đã merge" một mình không đủ: worktree vừa tạo, chưa commit, cũng có 0 commit ngoài HEAD.
+ * Chỉ để báo, không bao giờ tự dùng lại. Không có ứng viên thì trả chuỗi rỗng.
+ */
+function reusableLines(ctx, main, common) {
+  const events = core.readEvents(ctx);
+  const gone = agg.discardedTaskIds(events);
+  const last = new Map();
+  for (const e of events) {
+    if (e && e.kind === 'verdict' && typeof e.task_id === 'string') last.set(e.task_id, agg.normalizeVerdict(e).outcome);
+  }
+  const rows = [];
+  for (const w of markedWorktrees(common)) {
+    if (!w.exists || gone.has(w.task_id)) continue;
+    const v = last.get(w.task_id);
+    let why = null;
+    if (v === 'pass' || v === 'accept') why = `verdict ${v}`;
+    else if (v !== undefined && !NOT_DONE.has(v) && branchMerged(main, w.branch)) why = 'nhánh đã vào HEAD';
+    if (!why) continue;
+    if (liveAgentInWorktree(ctx, w.path)) continue;
+    if (dirtyOf(w.path) !== false) continue;
+    rows.push(`  - ${w.path} task=${w.task_id} nhánh=${w.branch || '?'} (${why})`);
+  }
+  if (!rows.length) return '';
+  return `Worktree bước đã xong có thể tái dùng (chỉ báo, không tự dùng lại; gỡ bằng dieu-phoi wt clean sau khi xem dry-run):\n${rows.join('\n')}`;
+}
+
 /** Trạng thái node_modules của một worktree: link (symlink/junction), dir (thư mục thật), none. */
 function nodeModulesOf(p) {
   try {
@@ -256,8 +293,22 @@ function nodeModulesOf(p) {
   } catch (_) { return 'none'; }
 }
 
+/**
+ * s3 (core 0.7.5): --base <ref> cho `wt add`. Không có --base → nhánh mới từ HEAD của checkout chính (như cũ).
+ * Ref phải là commit hợp lệ trong repo chính; không bắt đầu bằng `-` (tránh bị git hiểu là tuỳ chọn).
+ */
+function baseArg(opts, main) {
+  if (opts.base === undefined) return null;
+  if (typeof opts.base !== 'string' || !opts.base || opts.base.startsWith('-')) {
+    throw new Error('wt add: --base cần tên ref (nhánh, tag hoặc commit), không bắt đầu bằng "-"');
+  }
+  const v = git(main, ['rev-parse', '--verify', '--quiet', `${opts.base}^{commit}`]);
+  if (!v.ok || !v.out) throw new Error(`wt add: --base "${opts.base}" không phải commit/nhánh hợp lệ trong ${main}`);
+  return opts.base;
+}
+
 function wtAdd(opts) {
-  if (typeof opts.task !== 'string') throw new Error('Cú pháp: dieu-phoi wt add --task <task_id> [--repo r] [--path dir] [--branch b] [--force] [--deps auto|link|install|none] [--deps-path dir]');
+  if (typeof opts.task !== 'string') throw new Error('Cú pháp: dieu-phoi wt add --task <task_id> [--repo r] [--path dir] [--branch b] [--base ref] [--force] [--deps auto|link|install|none] [--deps-path dir]');
   const taskId = requireTaskId(opts.task);
   const ctx = ctxOf(opts);
   const depsMode = deps.depsModeOf(opts, ctx);
@@ -265,22 +316,30 @@ function wtAdd(opts) {
   const { main, common } = mainCheckoutOf(repoOf(opts));
   const dup = markedWorktrees(common).filter((w) => w.task_id === taskId && w.exists);
   if (dup.length) throw new Error(`task ${taskId} đã có worktree có dấu: ${dup.map((w) => w.path).join(', ')}`);
+  const base = baseArg(opts, main);
   const max = maxWorktreesOf(ctx);
   const total = registeredOf(main).length;
   const capMsg = max > 0 && total >= max ? `repo đã có ${total}/${max} worktree (trần max_worktrees_repo)` : null;
+  const near = max > 0 && total + 1 >= warnAtOf(max);
   if (capMsg && opts.force !== true) {
+    const hint = reusableLines(ctx, main, common);
     throw new Error(`wt add: ${capMsg}; không tạo thêm cho task ${taskId}.\n${candidateLines(common)}\n`
+      + (hint ? `${hint}\n` : '')
       + 'Dọn: dieu-phoi wt clean --yes (sau khi xem dry-run) hoặc dieu-phoi wt list --all; tạo vượt trần: thêm --force.');
   }
   const notes = [];
   if (capMsg) notes.push(`CẢNH BÁO: vượt trần (--force): ${capMsg}`);
-  else if (max > 0 && total + 1 >= warnAtOf(max)) notes.push(`CẢNH BÁO: repo sẽ có ${total + 1}/${max} worktree (đạt 75% trần)`);
+  else if (near) notes.push(`CẢNH BÁO: repo sẽ có ${total + 1}/${max} worktree (đạt 75% trần)`);
+  if (capMsg || near) {
+    const hint = reusableLines(ctx, main, common);
+    if (hint) notes.push(hint);
+  }
   const wtPath = typeof opts.path === 'string' && opts.path
     ? path.resolve(opts.path)
     : path.join(path.dirname(main), `${path.basename(main)}-wt-${taskId}`);
   if (fs.existsSync(wtPath)) throw new Error(`wt add: ${wtPath} đã tồn tại`);
   const branch = typeof opts.branch === 'string' && opts.branch ? opts.branch : `${BRANCH_PREFIX}${taskId}`;
-  const r = git(main, ['worktree', 'add', '-b', branch, wtPath]);
+  const r = git(main, ['worktree', 'add', '-b', branch, wtPath, ...(base ? [base] : [])]);
   if (!r.ok) throw new Error(`git worktree add lỗi: ${r.err || 'không rõ'}`);
   const adminDir = git(wtPath, ['rev-parse', '--path-format=absolute', '--git-dir']).out;
   if (!adminDir) throw new Error(`worktree ${wtPath} tạo xong nhưng không đọc được git-dir để ghi dấu`);
@@ -299,7 +358,7 @@ function wtAdd(opts) {
   const text = [msg, d.note, warning].filter(Boolean).join('\n');
   return {
     code: 0,
-    out: opts.json ? JSON.stringify({ task_id: taskId, path: wtPath, branch, total: total + 1, max, warning, deps: mark.deps, deps_path: depsPath, deps_note: d.note }) : text,
+    out: opts.json ? JSON.stringify({ task_id: taskId, path: wtPath, branch, base: base || null, total: total + 1, max, warning, deps: mark.deps, deps_path: depsPath, deps_note: d.note }) : text,
   };
 }
 
@@ -404,14 +463,114 @@ function wtList(opts) {
 }
 
 /** `dieu-phoi wt add|clean|list` (core 0.7.2 s17; 0.7.3 s2: trần, --stale-days, list). */
+// ---- s4 (0.7.5): wt clean --merged và nhắc sau verdict accept ----
+
+/**
+ * Worktree có dấu mà nhánh đã vào HEAD của checkout chính (không gồm checkout chính). go = gỡ được: có verdict không
+ * phải reject/fail/timeout/aborted, tuổi ≥ MERGED_MIN_AGE_MS, không agent sống, sạch. kept = [{ w, why }] còn lại kèm
+ * lý do. Chỉ đọc; cũ nhất trước.
+ */
+function mergedPlan(ctx, main, common, events) {
+  const last = new Map();
+  for (const e of events) {
+    if (e && e.kind === 'verdict' && typeof e.task_id === 'string') last.set(e.task_id, agg.normalizeVerdict(e).outcome);
+  }
+  const tsOf = (w) => (w.created_ts && Number.isFinite(Date.parse(w.created_ts)) ? Date.parse(w.created_ts) : Infinity);
+  const go = [];
+  const kept = [];
+  for (const w of markedWorktrees(common).sort((a, b) => tsOf(a) - tsOf(b))) {
+    if (!w.exists || !w.branch || pathKey(w.path) === pathKey(main)) continue;
+    if (!branchMerged(main, w.branch)) continue;
+    const v = last.get(w.task_id);
+    let why = null;
+    if (ageMsOf(w) < MERGED_MIN_AGE_MS) why = 'mới tạo dưới 1 giờ';
+    else if (v === undefined) why = 'chưa có verdict';
+    else if (NOT_DONE.has(v)) why = `verdict ${v}`;
+    else {
+      const busy = liveAgentInWorktree(ctx, w.path);
+      if (busy) why = `đang là cwd của agent sống (${busy})`;
+      else if (dirtyOf(w.path) !== false) why = 'còn thay đổi chưa commit hoặc không đọc được trạng thái git';
+    }
+    if (why) kept.push({ w, why });
+    else go.push(w);
+  }
+  return { go, kept };
+}
+
+/**
+ * Thực hiện (apply) hoặc liệt kê (dry-run) mergedPlan. Gỡ worktree bằng removeMarked (không --force), rồi
+ * `git branch -d` nhánh (từ chối nếu chưa merge vào HEAD: an toàn). Trả { n, removed, lines }. Không ném.
+ */
+function mergedRun(ctx, main, common, apply) {
+  const { go, kept } = mergedPlan(ctx, main, common, core.readEvents(ctx));
+  const lines = kept.map(({ w, why }) => `giữ ${w.path}: ${why} — task=${w.task_id} nhánh=${w.branch}`);
+  let removed = 0;
+  for (const w of go) {
+    const label = `task=${w.task_id} nhánh=${w.branch}`;
+    if (!apply) {
+      lines.push(`sẽ gỡ ${w.path} và xoá nhánh (git branch -d): ${label} (đã merge, có verdict, sạch, không agent sống)`);
+      continue;
+    }
+    const r = removeMarked(w, main, ctx);
+    if (!r.removed) { lines.push(`${r.msg}: ${label}`); continue; }
+    removed++;
+    recordWt(ctx, w.task_id, { action: 'remove', path: w.path, repo: main, reason: 'merged' });
+    const b = git(main, ['branch', '-d', w.branch]);
+    lines.push(`đã gỡ worktree ${w.path}; ${b.ok ? `đã xoá nhánh ${w.branch} (git branch -d)` : `giữ nhánh ${w.branch}: git branch -d lỗi (${b.err || 'không rõ'})`}: ${label}`);
+  }
+  return { n: go.length, removed, lines };
+}
+
+/** `dieu-phoi wt clean --merged [--repo R] [--yes]`: dry-run mặc định; không đụng --stale-days hay worktree không dấu. */
+function wtCleanMerged(opts) {
+  const ctx = ctxOf(opts);
+  const { main, common } = mainCheckoutOf(repoOf(opts));
+  const apply = opts.yes === true;
+  const r = mergedRun(ctx, main, common, apply);
+  if (!r.lines.length) return { code: 0, out: 'wt clean --merged: không có worktree có dấu nào đã merge vào HEAD.' };
+  const tail = apply ? '' : '\nDry-run: chưa xoá gì. Chạy lại với --yes để thực hiện.';
+  const head = `wt clean --merged (${apply ? 'đã thực hiện' : 'dry-run'}): ${r.n} worktree đã merge${apply ? `, đã gỡ ${r.removed}` : ''}`;
+  return { code: 0, out: `${head}\n${r.lines.join('\n')}${tail}` };
+}
+
+/**
+ * Sau verdict accept của NGƯỜI DÙNG (--task hoặc --root): một dòng nhắc số worktree đã merge của từng repo liên quan
+ * (repo lấy từ sự kiện worktree của các task, cộng --repo nếu có). clean (--clean-merged): gỡ luôn như
+ * `wt clean --merged --yes`. Không ném: lỗi thành một dòng báo.
+ */
+function mergedAfterAccept(ctx, taskIds, repoDir, clean) {
+  const lines = [];
+  try {
+    const events = core.readEvents(ctx);
+    const repos = new Set();
+    for (const id of taskIds) for (const r of reposOfTask(events, id, repoDir)) repos.add(r);
+    for (const repo of repos) {
+      let info;
+      try { info = mainCheckoutOf(repo); } catch (e) { lines.push(`wt --merged: bỏ qua ${repo} (${e.message})`); continue; }
+      if (clean) {
+        const r = mergedRun(ctx, info.main, info.common, true);
+        if (!r.lines.length) lines.push(`wt --clean-merged: không có worktree đã merge nào của ${info.main}`);
+        for (const x of r.lines) lines.push(`wt --clean-merged: ${x}`);
+        continue;
+      }
+      const n = mergedPlan(ctx, info.main, info.common, events).go.length;
+      if (n) lines.push(`wt: ${n} worktree đã merge của ${info.main}; dọn: dieu-phoi wt clean --merged --repo ${info.main} --yes (hoặc thêm --clean-merged vào lệnh verdict)`);
+    }
+  } catch (e) {
+    lines.push(`wt --merged: bỏ qua (${e.message})`);
+  }
+  return lines;
+}
+
 function cmdWt(opts) {
   const sub = opts._[0];
   if (sub === 'add') return wtAdd(opts);
-  if (sub === 'clean') return wtClean(opts);
+  if (sub === 'clean') return opts.merged === true ? wtCleanMerged(opts) : wtClean(opts);
   if (sub === 'list') return wtList(opts);
-  throw new Error('Cú pháp: dieu-phoi wt add --task <task_id> [--repo r] [--path dir] [--branch b] [--force] [--deps auto|link|install|none] [--deps-path dir]\n'
+  throw new Error('Cú pháp: dieu-phoi wt add --task <task_id> [--repo r] [--path dir] [--branch b] [--base ref] [--force] [--deps auto|link|install|none] [--deps-path dir]\n'
     + '         dieu-phoi wt clean [--repo r] [--stale-days N] [--yes]\n'
+    + '         dieu-phoi wt clean --merged [--repo r] [--yes]\n'
     + '         dieu-phoi wt list [--repo r] [--all] [--json]');
 }
 
-module.exports = { cmdWt, cleanupTask, mainCheckoutOf, markedWorktrees, registeredOf, liveAgentInWorktree, MARK };
+module.exports = { cmdWt, cleanupTask, mergedAfterAccept, mainCheckoutOf, markedWorktrees, registeredOf, liveAgentInWorktree, MARK };

package/package.json

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