@kienntpixon/dieu-phoi 0.7.2 → 0.7.3

package/lib/setup.cjs

@@ -67,7 +67,7 @@ function stripOurHooks(settings) {
 // (an old `Agent`-only registration is not "already registered", so `setup` rewrites it).
 const AGENT_MATCHER = 'Agent|Task';
 
-/** True when settings already hold exactly our five entries with this command. */
+/** True when settings already hold exactly our six entries with this command. */
 function alreadyRegistered(settings, cmd) {
   const hooks = settings && settings.hooks;
   if (!hooks || typeof hooks !== 'object') return false;
@@ -81,13 +81,14 @@ function alreadyRegistered(settings, cmd) {
         if (h.command !== cmd) continue;
         if (event === 'PostToolUse' && g.matcher === AGENT_MATCHER) good++;
         else if (event === 'SubagentStop') good++;
+        else if (event === 'SubagentStart' && !g.matcher) good++;
         else if (event === 'SessionStart' && g.matcher === 'compact') good++;
         else if (event === 'UserPromptSubmit' && !g.matcher) good++;
         else if (event === 'PreToolUse' && g.matcher === AGENT_MATCHER) good++;
       }
     }
   }
-  return ours === 5 && good === 5;
+  return ours === 6 && good === 6;
 }
 
 function addOurHooks(settings, hookPath) {
@@ -98,6 +99,9 @@ function addOurHooks(settings, hookPath) {
   h.PostToolUse.push({ matcher: AGENT_MATCHER, hooks: [{ type: 'command', command: cmd, timeout: 10 }] });
   if (!Array.isArray(h.SubagentStop)) h.SubagentStop = [];
   h.SubagentStop.push({ hooks: [{ type: 'command', command: cmd, timeout: 10 }] });
+  // core 0.7.3 (s1): live-agent register (data/live/<agent_id>.json) for the parallel cap; no matcher = every subagent
+  if (!Array.isArray(h.SubagentStart)) h.SubagentStart = [];
+  h.SubagentStart.push({ hooks: [{ type: 'command', command: cmd, timeout: 5 }] });
   // after /compact or auto-compact: re-inject the orchestration state rebuilt from the log
   if (!Array.isArray(h.SessionStart)) h.SessionStart = [];
   h.SessionStart.push({ matcher: 'compact', hooks: [{ type: 'command', command: cmd, timeout: 10 }] });
@@ -282,6 +286,22 @@ function nodePathOf(cmd) {
   return m ? m[1] : undefined;
 }
 
+function realOf(p) {
+  try { return fs.realpathSync.native(p); } catch (_) { return path.resolve(p); }
+}
+
+/**
+ * Rewrite hook commands inside an installed agent file whose node/hook paths resolve (symlink/junction, e.g. an
+ * Orca profile linking ~/.claude) to the same real files as ours, so the comparison ignores path spelling only.
+ */
+function normalizeHookPaths(cur, hookPath, nodePath) {
+  const myNode = realOf(nodePath || process.execPath);
+  const myHook = realOf(hookPath);
+  const mine = hookCommand(hookPath, nodePath).replace(/'/g, "''");
+  return cur.replace(/'"([^"']+)" "([^"']+)"( --[A-Za-z-]+)'/g, (m, n, h, flag) =>
+    (realOf(n) === myNode && realOf(h) === myHook ? `'${mine}${flag}'` : m));
+}
+
 /**
  * State of each dp-* agent file: ok (ours, identical), outdated (ours, differs), missing, foreign (a file with
  * that name we did not write — never touched).
@@ -295,7 +315,10 @@ function agentStatus(claudeDir, hookPath, nodePath) {
     let state = 'missing';
     if (cur !== null) {
       if (!cur.includes(AGENT_MARKER)) state = 'foreign';
-      else state = cur === renderAgent(name, hookPath, nodePath) ? 'ok' : 'outdated';
+      else {
+        const want = renderAgent(name, hookPath, nodePath);
+        state = (cur === want || normalizeHookPaths(cur, hookPath, nodePath) === want) ? 'ok' : 'outdated';
+      }
     }
     return { name, file, state };
   });
@@ -445,7 +468,7 @@ function registration(claudeDir) {
   const perms = permissionEntries(runsDir());
   const legacy = permissionEntries(legacyRunsDirOf(claudeDir));
   const out = {
-    file, PostToolUse: false, SubagentStop: false, SessionStart: false, UserPromptSubmit: false, PreToolUse: false, commands: [], permissions: false, permission_entries: perms,
+    file, PostToolUse: false, SubagentStop: false, SubagentStart: false, SessionStart: false, UserPromptSubmit: false, PreToolUse: false, commands: [], permissions: false, permission_entries: perms,
     runs_dir: perms.dir, runs_dir_exists: fs.existsSync(perms.dir), legacy_permissions: false,
   };
   let obj;
@@ -455,7 +478,7 @@ function registration(claudeDir) {
   out.legacy_permissions = legacy.allow.some((r) => Array.isArray(lp.allow) && lp.allow.includes(r))
     || (Array.isArray(lp.additionalDirectories) && lp.additionalDirectories.includes(legacy.dir));
   const hooks = obj.hooks || {};
-  for (const ev of ['PostToolUse', 'SubagentStop', 'SessionStart', 'UserPromptSubmit', 'PreToolUse']) {
+  for (const ev of ['PostToolUse', 'SubagentStop', 'SubagentStart', 'SessionStart', 'UserPromptSubmit', 'PreToolUse']) {
     for (const g of Array.isArray(hooks[ev]) ? hooks[ev] : []) {
       for (const h of (g && Array.isArray(g.hooks) ? g.hooks : [])) {
         if (!isOurs(h)) continue;

package/lib/worktree.cjs

@@ -7,6 +7,16 @@
 //    `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.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.
+//    Đạt 75% trần → cảnh báo.
+//  - `wt clean --stale-days N` (mặc định wt_stale_days = 7): thêm diện sạch + có dấu + nhánh không có commit chưa merge
+//    vào HEAD chính + cũ ≥ N ngày. Vẫn dry-run; --yes mới gỡ.
+//  - `wt list [--all]`: bảng path/task/tuổi/sạch/node_modules(link|dir|none)/có dấu. Worktree không dấu: chỉ báo.
+// core 0.7.3 (s3): `wt add --deps auto|link|install|none` (OPT-IN, mặc định none; env DIEU_PHOI_WT_DEPS → config wt_deps)
+//    và `--deps-path <thư mục con>`; logic ở lib/deps.cjs. Dấu ghi `deps: link|pnpm|none` + `deps_path`. Gỡ worktree
+//    (removeMarked: verdict/discard/wt clean) unlink junction node_modules TRƯỚC `git worktree remove`, rồi xoá vỏ còn sót.
 // Sự kiện `worktree` (chỉ ở máy, không đồng bộ sink) ghi repo chính để verdict/discard tìm đúng repo.
 const fs = require('fs');
 const path = require('path');
@@ -14,9 +24,13 @@ const cp = require('child_process');
 const core = require('../hook.cjs');
 const agg = require('./aggregate.cjs');
 const { ctxOf, repoOf } = require('./args.cjs');
+const deps = require('./deps.cjs');
 
 const MARK = 'dieu-phoi.json';
 const BRANCH_PREFIX = 'dp/';
+const DAY_MS = 86400000;
+const DEFAULT_MAX_WORKTREES = 8;
+const DEFAULT_STALE_DAYS = 7;
 
 function git(cwd, args) {
   const r = cp.spawnSync('git', args, { cwd, encoding: 'utf8', windowsHide: true, timeout: 60000 });
@@ -52,25 +66,79 @@ function markedWorktrees(common) {
     out.push({
       admin, name, task_id: mark.task_id, root: mark.root || null, branch: mark.branch || null,
       created_ts: mark.created_ts || null, path: wtPath, exists: !!wtPath && fs.existsSync(wtPath),
+      deps: typeof mark.deps === 'string' ? mark.deps : null, deps_path: typeof mark.deps_path === 'string' ? mark.deps_path : '.',
     });
   }
   return out;
 }
 
-/** true = còn thay đổi (kể cả file chưa theo dõi), false = sạch, null = không đọc được. */
+/**
+ * true = còn thay đổi (kể cả file chưa theo dõi), false = sạch, null = không đọc được.
+ * s3: dòng `?? …node_modules/` là link (junction dùng chung do --deps link tạo) không tính là thay đổi.
+ */
 function dirtyOf(wtPath) {
   const r = git(wtPath, ['status', '--porcelain']);
   if (!r.ok) return null;
-  return r.out.length > 0;
+  const lines = r.out.split(/\r?\n/).filter(Boolean).filter((l) => {
+    const m = /^\?\? "?(.*?node_modules)\/?"?$/.exec(l);
+    return !(m && path.basename(m[1]) === 'node_modules' && deps.isLink(path.join(wtPath, m[1])));
+  });
+  return lines.length > 0;
+}
+
+/** Khoá so sánh đường dẫn: resolve symlink/junction nếu còn tồn tại, đổi \ thành /, bỏ / cuối, chữ thường trên Windows. */
+function realKey(p) {
+  if (!p || typeof p !== 'string') return '';
+  let r = path.resolve(p);
+  try { r = fs.realpathSync.native(r); } catch (_) { /* thư mục đã mất: dùng đường dẫn đã resolve */ }
+  r = r.replace(/\\/g, '/').replace(/\/+$/, '');
+  return process.platform === 'win32' ? r.toLowerCase() : r;
+}
+
+/**
+ * s8: kiểm "worktree đang là cwd (hoặc thư mục con) của một agent sống" trước khi gỡ. Đọc sổ agent sống data/live
+ * (core.readLive: bỏ file quá TTL; kèm ý định giao chưa nhận SubagentStart, mang worktree của brief). Trả mô tả agent
+ * ("agent ab12 task xyz") để removeMarked GIỮ worktree, hoặc null. Không ném: sổ lỗi thì coi như không có agent.
+ */
+function liveAgentInWorktree(ctx, wtPath) {
+  const wt = realKey(wtPath);
+  if (!wt) return null;
+  let live;
+  try { live = core.readLive(ctx); } catch (_) { return null; }
+  for (const r of live.agents.concat(live.pending)) {
+    const at = realKey(r.cwd || r.worktree);
+    if (!at || !(at === wt || at.startsWith(`${wt}/`))) continue;
+    const who = r.agent_id ? `agent ${String(r.agent_id).slice(0, 8)}` : 'agent đang chờ nhận';
+    return `${who}${r.task_id ? ` task ${r.task_id}` : ''}`;
+  }
+  return null;
 }
 
-/** Gỡ một worktree có dấu đang còn thư mục. Không --force: còn thay đổi thì giữ. */
-function removeMarked(w, mainDir) {
+/**
+ * Gỡ một worktree có dấu đang còn thư mục. Không --force: còn thay đổi thì giữ.
+ * s3: gỡ junction node_modules (không đi xuyên) TRƯỚC `git worktree remove`; git lỗi thì khôi phục junction.
+ * Gỡ xong mà còn vỏ thư mục (git để lại) thì xoá vỏ bằng removeShell (link chỉ unlink, không vào đích).
+ */
+function removeMarked(w, mainDir, ctx) {
+  const busy = liveAgentInWorktree(ctx, w.path);
+  if (busy) return { removed: false, msg: `giữ ${w.path}: đang là cwd của agent sống (${busy})` };
   const dirty = dirtyOf(w.path);
   if (dirty !== false) return { removed: false, msg: `giữ ${w.path}: ${dirty ? 'còn thay đổi chưa commit' : 'không đọc được trạng thái git'}` };
+  let links;
+  try { links = deps.unlinkDepLinks(w.path, [w.deps_path || '.']); } catch (e) {
+    return { removed: false, msg: `giữ ${w.path}: không gỡ được junction node_modules (${e.message}); KHÔNG gỡ worktree để tránh xoá xuyên junction` };
+  }
   const r = git(mainDir, ['worktree', 'remove', w.path]);
-  if (!r.ok) return { removed: false, msg: `giữ ${w.path}: git worktree remove lỗi (${r.err || 'không rõ'})` };
-  return { removed: true, msg: `đã gỡ worktree ${w.path} (nhánh ${w.branch || '?'} giữ nguyên)` };
+  if (!r.ok) {
+    deps.relink(links);
+    return { removed: false, msg: `giữ ${w.path}: git worktree remove lỗi (${r.err || 'không rõ'})` };
+  }
+  let shell = '';
+  if (fs.existsSync(w.path) || deps.isLink(w.path)) {
+    try { deps.removeShell(w.path); } catch (e) { shell = `; còn vỏ thư mục chưa xoá được (${e.message})`; }
+  }
+  const unl = links.length ? `; đã gỡ junction node_modules trước` : '';
+  return { removed: true, msg: `đã gỡ worktree ${w.path} (nhánh ${w.branch || '?'} giữ nguyên${unl}${shell})` };
 }
 
 function recordWt(ctx, taskId, fields) {
@@ -103,7 +171,7 @@ function cleanupTask(ctx, events, taskId, repoDir) {
     const mine = markedWorktrees(info.common).filter((w) => w.task_id === taskId);
     for (const w of mine) {
       if (!w.exists) { lines.push(`wt: ${w.path || w.name} đã mất thư mục — dọn bằng dieu-phoi wt clean --yes`); continue; }
-      const r = removeMarked(w, info.main);
+      const r = removeMarked(w, info.main, ctx);
       if (r.removed) recordWt(ctx, taskId, { action: 'remove', path: w.path, repo: info.main, reason: 'verdict' });
       lines.push(`wt: ${r.msg}`);
     }
@@ -111,13 +179,102 @@ function cleanupTask(ctx, events, taskId, repoDir) {
   return lines;
 }
 
+// ---- core 0.7.3 (s2): trần, ngưỡng, dọn theo tuổi, bảng ----
+
+/**
+ * Số nguyên không âm: env DIEU_PHOI_<KEY> → config.json → mặc định. Mỗi nguồn hỏng (không phải số nguyên ≥ 0)
+ * rơi xuống nguồn kế tiếp, không nhảy thẳng về mặc định (env "abc" vẫn đọc config.json).
+ */
+function numSetting(ctx, envName, cfgKey, def) {
+  const cfg = ctx && ctx.config ? ctx.config : {};
+  for (const v of [process.env[envName], cfg[cfgKey]]) {
+    if (v === undefined || v === null || v === '') continue;
+    const n = Number(v);
+    if (Number.isInteger(n) && n >= 0) return n;
+  }
+  return def;
+}
+const maxWorktreesOf = (ctx) => numSetting(ctx, 'DIEU_PHOI_MAX_WORKTREES_REPO', 'max_worktrees_repo', DEFAULT_MAX_WORKTREES);
+const staleDaysOf = (ctx) => numSetting(ctx, 'DIEU_PHOI_WT_STALE_DAYS', 'wt_stale_days', DEFAULT_STALE_DAYS);
+/** Ngưỡng cảnh báo = 75% trần, làm tròn lên (8 → 6). */
+const warnAtOf = (max) => Math.ceil(max * 0.75);
+
+/** Khoá so sánh đường dẫn: chuẩn hoá; Windows không phân biệt hoa thường. */
+function pathKey(p) {
+  const r = path.resolve(p);
+  return process.platform === 'win32' ? r.toLowerCase() : r;
+}
+
+/** Mọi mục của `git worktree list --porcelain` (checkout chính đứng đầu). Ném nếu git lỗi. */
+function registeredOf(main) {
+  const r = git(main, ['worktree', 'list', '--porcelain']);
+  if (!r.ok) throw new Error(`git worktree list lỗi: ${r.err || 'không rõ'}`);
+  const out = [];
+  let cur = null;
+  for (const line of r.out.split(/\r?\n/)) {
+    if (line.startsWith('worktree ')) { cur = { path: line.slice(9), branch: null, detached: false }; out.push(cur); }
+    else if (cur && line.startsWith('branch ')) cur.branch = line.slice(7).replace(/^refs\/heads\//, '');
+    else if (cur && line === 'detached') cur.detached = true;
+  }
+  return out;
+}
+
+/** Tuổi (ms) của worktree có dấu: từ created_ts, không có thì mtime thư mục git-dir. */
+function ageMsOf(w) {
+  const t = w.created_ts ? Date.parse(w.created_ts) : NaN;
+  if (Number.isFinite(t)) return Date.now() - t;
+  try { return Date.now() - fs.statSync(w.admin).mtimeMs; } catch (_) { return 0; }
+}
+
+/** Nhánh không có commit nào chưa vào HEAD của checkout chính. Không đọc được nhánh → false (giữ lại). */
+function branchMerged(main, branch) {
+  if (!branch) return false;
+  const r = git(main, ['rev-list', '--count', branch, '--not', 'HEAD']);
+  return r.ok && r.out === '0';
+}
+
+/** Ứng viên dọn: có dấu, thư mục còn, sạch; cũ nhất trước. */
+function cleanCandidates(common) {
+  const tsOf = (w) => (w.created_ts && Number.isFinite(Date.parse(w.created_ts)) ? Date.parse(w.created_ts) : Infinity);
+  return markedWorktrees(common)
+    .filter((w) => w.exists && dirtyOf(w.path) === false)
+    .sort((a, b) => tsOf(a) - tsOf(b));
+}
+
+function candidateLines(common) {
+  const c = cleanCandidates(common);
+  if (!c.length) return 'Không có ứng viên dọn (không có worktree có dấu nào sạch).';
+  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')}`;
+}
+
+/** 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 {
+    const st = fs.lstatSync(path.join(p, 'node_modules'));
+    if (st.isSymbolicLink()) return 'link';
+    return st.isDirectory() ? 'dir' : 'none';
+  } catch (_) { return 'none'; }
+}
+
 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]');
+  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]');
   const taskId = requireTaskId(opts.task);
   const ctx = ctxOf(opts);
+  const depsMode = deps.depsModeOf(opts, ctx);
+  const depsPath = deps.normDepsPath(opts['deps-path']);
   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 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;
+  if (capMsg && opts.force !== true) {
+    throw new Error(`wt add: ${capMsg}; không tạo thêm cho task ${taskId}.\n${candidateLines(common)}\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)`);
   const wtPath = typeof opts.path === 'string' && opts.path
     ? path.resolve(opts.path)
     : path.join(path.dirname(main), `${path.basename(main)}-wt-${taskId}`);
@@ -127,16 +284,38 @@ function wtAdd(opts) {
   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`);
-  const mark = { task_id: taskId, root: main, created_ts: core.nowIso(), branch };
-  fs.writeFileSync(path.join(adminDir, MARK), `${JSON.stringify(mark, null, 2)}\n`);
-  recordWt(ctx, taskId, { action: 'add', path: wtPath, repo: main, branch });
-  const msg = `Đã tạo worktree ${wtPath} trên nhánh ${branch} (dấu dieu-phoi: task ${taskId}). Brief dùng dòng "worktree: ${wtPath}".`;
-  return { code: 0, out: opts.json ? JSON.stringify({ task_id: taskId, path: wtPath, branch }) : msg };
+  const markPath = path.join(adminDir, MARK);
+  const mark = { task_id: taskId, root: main, created_ts: core.nowIso(), branch, deps: 'none', deps_path: depsPath };
+  // Dấu ghi trước khi chuẩn bị deps: nếu chết giữa chừng, worktree vẫn có dấu để wt clean nhận ra.
+  fs.writeFileSync(markPath, `${JSON.stringify(mark, null, 2)}\n`);
+  const d = deps.setupDeps({ main, wtPath, mode: depsMode, depsPath });
+  if (d.deps !== 'none') {
+    mark.deps = d.deps;
+    fs.writeFileSync(markPath, `${JSON.stringify(mark, null, 2)}\n`);
+  }
+  recordWt(ctx, taskId, { action: 'add', path: wtPath, repo: main, branch, deps: mark.deps });
+  const msg = `Đã tạo worktree ${wtPath} trên nhánh ${branch} (dấu dieu-phoi: task ${taskId}; deps ${mark.deps}). Brief dùng dòng "worktree: ${wtPath}".`;
+  const warning = notes.length ? notes.join('\n') : null;
+  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,
+  };
+}
+
+/** --stale-days N (số nguyên ≥ 0) hoặc mặc định cấu hình. */
+function staleDaysArg(opts, ctx) {
+  if (opts['stale-days'] === undefined) return staleDaysOf(ctx);
+  const v = opts['stale-days'];
+  const n = typeof v === 'string' && /^\d+$/.test(v) ? Number(v) : NaN;
+  if (!Number.isInteger(n)) throw new Error('--stale-days cần số nguyên ≥ 0 (số ngày)');
+  return n;
 }
 
 function wtClean(opts) {
   const ctx = ctxOf(opts);
   const { main, common } = mainCheckoutOf(repoOf(opts));
+  const staleDays = staleDaysArg(opts, ctx);
   const events = core.readEvents(ctx);
   const accepted = new Set(events.filter((e) => e && e.kind === 'verdict' && agg.normalizeVerdict(e).by === 'user' && e.outcome === 'accept')
     .map((e) => e.task_id));
@@ -147,6 +326,9 @@ function wtClean(opts) {
     if (!w.exists) why = 'thư mục đã mất';
     else if (accepted.has(w.task_id)) why = 'đã nghiệm thu';
     else if (gone.has(w.task_id)) why = 'đã loại (discard)';
+    else if (ageMsOf(w) >= staleDays * DAY_MS && branchMerged(main, w.branch) && dirtyOf(w.path) === false) {
+      why = `cũ ≥ ${staleDays} ngày, nhánh đã merge vào HEAD`;
+    }
     if (why) rows.push(Object.assign({}, w, { why }));
   }
   if (!rows.length) return { code: 0, out: 'wt clean: không có worktree có dấu nào cần dọn.' };
@@ -163,24 +345,73 @@ function wtClean(opts) {
       } else lines.push(`sẽ bỏ đăng ký ${w.path || w.name}: ${label}`);
       continue;
     }
+    const busy = liveAgentInWorktree(ctx, w.path);
+    if (busy) { lines.push(`giữ ${w.path}: đang là cwd của agent sống (${busy}) — ${label}`); continue; }
     const dirty = dirtyOf(w.path);
     if (dirty !== false) { lines.push(`giữ ${w.path}: ${dirty ? 'còn thay đổi chưa commit' : 'không đọc được trạng thái git'} — ${label}`); continue; }
     if (!apply) { lines.push(`sẽ gỡ ${w.path}: ${label}`); continue; }
-    const r = removeMarked(w, main);
+    const r = removeMarked(w, main, ctx);
     if (r.removed) recordWt(ctx, w.task_id, { action: 'remove', path: w.path, repo: main, reason: w.why });
     lines.push(`${r.msg}: ${label}`);
   }
   const tail = apply ? '' : '\nDry-run: chưa xoá gì. Chạy lại với --yes để thực hiện.';
-  return { code: 0, out: `wt clean (${apply ? 'đã thực hiện' : 'dry-run'}):\n${lines.join('\n')}${tail}` };
+  return { code: 0, out: `wt clean (${apply ? 'đã thực hiện' : 'dry-run'}, ngưỡng cũ ${staleDays} ngày):\n${lines.join('\n')}${tail}` };
+}
+
+/** `dieu-phoi wt list [--all]`: trạng thái worktree của repo. Worktree không dấu chỉ báo, không gỡ. */
+function wtList(opts) {
+  const ctx = ctxOf(opts);
+  const { main, common } = mainCheckoutOf(repoOf(opts));
+  const max = maxWorktreesOf(ctx);
+  const reg = registeredOf(main);
+  const marks = new Map();
+  for (const w of markedWorktrees(common)) if (w.path) marks.set(pathKey(w.path), w);
+  const rows = reg.map((r) => {
+    const isMain = pathKey(r.path) === pathKey(main);
+    const mk = isMain ? null : marks.get(pathKey(r.path)) || null;
+    const exists = fs.existsSync(r.path);
+    const dirty = exists ? dirtyOf(r.path) : null;
+    const state = !exists ? 'mất' : dirty === null ? 'không rõ' : dirty ? 'bẩn' : 'sạch';
+    const ageDays = mk && Number.isFinite(ageMsOf(mk)) && mk.created_ts ? Math.floor(ageMsOf(mk) / DAY_MS) : null;
+    return {
+      path: r.path, branch: r.branch, main: isMain, marked: !!mk, task_id: mk ? mk.task_id : null,
+      age_days: ageDays, state, node_modules: exists ? nodeModulesOf(path.join(r.path, (mk && mk.deps_path) || '.')) : 'none',
+      deps: mk ? mk.deps || '-' : '-',
+    };
+  });
+  const unmarked = rows.filter((r) => !r.main && !r.marked).length;
+  const shown = opts.all === true ? rows : rows.filter((r) => r.marked);
+  const warnAt = max > 0 ? warnAtOf(max) : Infinity;
+  const head = `repo: ${rows.length}/${max > 0 ? max : '∞'} worktree`
+    + (max > 0 && rows.length >= warnAt ? ` (đạt 75% trần — CẢNH BÁO)` : '')
+    + (opts.all === true ? '' : `; ${unmarked} worktree không dấu (chỉ báo; dùng --all để xem)`);
+  if (opts.json) return { code: 0, out: JSON.stringify({ count: rows.length, max, rows: shown }) };
+  if (!shown.length) return { code: 0, out: `${head}\nwt list: không có worktree có dấu nào.` };
+  const table = shown.map((r) => [
+    r.main ? 'chính' : r.marked ? 'có' : 'không',
+    r.task_id || '-',
+    r.age_days === null ? '-' : `${r.age_days}d`,
+    r.state,
+    r.node_modules,
+    r.deps,
+    r.branch || '(detached)',
+    r.path,
+  ]);
+  const heads = ['dấu', 'task', 'tuổi', 'sạch', 'node_modules', 'deps', 'nhánh', 'đường dẫn'];
+  const widths = heads.map((h, i) => Math.max(h.length, ...table.map((row) => String(row[i]).length)));
+  const fmt = (row) => row.map((c, i) => String(c).padEnd(widths[i])).join('  ').trimEnd();
+  return { code: 0, out: [head, fmt(heads), ...table.map(fmt)].join('\n') };
 }
 
-/** `dieu-phoi wt add|clean` (core 0.7.2 s17). */
+/** `dieu-phoi wt add|clean|list` (core 0.7.2 s17; 0.7.3 s2: trần, --stale-days, list). */
 function cmdWt(opts) {
   const sub = opts._[0];
   if (sub === 'add') return wtAdd(opts);
   if (sub === 'clean') return wtClean(opts);
-  throw new Error('Cú pháp: dieu-phoi wt add --task <task_id> [--repo r] [--path dir] [--branch b]\n'
-    + '         dieu-phoi wt clean [--repo r] [--yes]');
+  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'
+    + '         dieu-phoi wt clean [--repo r] [--stale-days N] [--yes]\n'
+    + '         dieu-phoi wt list [--repo r] [--all] [--json]');
 }
 
-module.exports = { cmdWt, cleanupTask, mainCheckoutOf, markedWorktrees, MARK };
+module.exports = { cmdWt, cleanupTask, mainCheckoutOf, markedWorktrees, registeredOf, liveAgentInWorktree, MARK };

package/package.json

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

package/profile/lessons.md

@@ -81,3 +81,5 @@ Câu hỏi bắt buộc hỏi ở cổng 1 cho từng loại task (retro thêm k
 - [2026-11-05] [orch] | * | verify-task-id — 41/756 lượt verify (5,4%) mang task_id không có exec nào (19 không có cả trong plan), 24 verdict agent rơi vào id sai nên bước thật thiếu verdict → thẻ verify chép đúng `task=<id>` từ lượt exec của bước đó (không tự đặt id mới); verifier gộp dùng thẻ `|batch`
 - [2026-11-05] [orch] | * | choose — 425/1.540 lượt exec (28%) giao không chạy `choose` (273 trong phiên d8fe5944: debug chạy opus 61 lượt, $p50 5,5 so với sonnet/medium 1,1) và 138 lượt khác tier của `choose` không ghi override → mỗi lượt exec chạy `choose --json`; giao tier khác thì `--override` để retro học
 - [2026-11-05] plan-design | * | tier-table — kế hoạch xếp opus/medium cho mechanical-edit ≥ 35 lần (n105, $p50 1,50 trong khi haiku/medium $0,03 accept 0,91, sonnet/medium $0,58 accept 0,91) và haiku/low 13 lần (accept 0,73, n15) → cột tier lấy từ `dieu-phoi choose --json` cho từng bước; opus cho mechanical-edit/debug phải ghi lý do một dòng; không xếp haiku/low
+
+- [orch] Exec sửa nhỏ (s≤4): brief chỉ yêu cầu chạy test của module liên quan (node --test <file>); chạy full suite đúng MỘT lần ở verifier/cổng phát hành — không bắt cả exec lẫn verifier chạy full (tốn ~10+ phút mỗi lần trên máy tải nặng).