@kienntpixon/dieu-phoi 0.7.3 → 0.7.5

package/lib/knowledge.cjs

@@ -40,7 +40,9 @@ const KNOWLEDGE_HELP = `Cách dùng: dieu-phoi knowledge <lệnh> [--repo <đư
                          thư mục). Không --from thì tự lấy kho của khoá git-common-dir nếu có
   list [--follow] [--dirty] [--json]
                          các mục của kho (id, tiêu đề, số dòng, sha#rev, tags, paths) + repo liên quan (related),
-                         mỗi mục gắn ok / STALE / ? (độ tươi so với HEAD của worktree đang đứng)
+                         mỗi mục gắn ok / STALE / drift / ? (độ tươi so với HEAD của worktree đang đứng; drift = chỉ file
+                         file đổi nhưng không làm mục stale: glob, bản version, CHANGELOG, dòng không nêu tên mục);
+                         cuối dòng tổng: số mục không stale
   status [--follow] [--dirty] [--no-cache] [--json]
                          chỉ độ tươi: mục nào stale (file nào đổi sau sha của mục), mục nào không xác định (sha không
                          có trong repo này…). Một tiến trình git (diff-tree --no-renames, pathspec = paths của các mục),
@@ -60,6 +62,8 @@ const KNOWLEDGE_HELP = `Cách dùng: dieu-phoi knowledge <lệnh> [--repo <đư
                          "## +id" thêm mục (bắt buộc paths:), "## id" thay mục (bắt buộc base: <sha>#<rev>); base cũ
                          → xung đột, không ghi đè; mục > 40 dòng bị từ chối. Có xung đột/từ chối → exit 2.
                          Idempotent: file delta đã gộp (hash trong meta.json) và mục trùng một rev cũ trong history/ → "không đổi"
+  review <id> [--repo]   đánh dấu mục đã xem xét: reviewed_sha = HEAD hiện tại (ghi dưới khoá kho); độ tươi chỉ tính thay đổi sau sha đó.
+                         Mục bị thay bằng merge sẽ mất dấu này. Không đổi nội dung mục.
   bootstrap [--children <mẫu tên>[,…]] [--json]
                          chỉ đọc: liệt kê nguồn để seed kho (CLAUDE.md/README/AGENTS.md của repo, context-r/contract/
                          handoff cũ trong runs có nhắc repo), mục đã có, mục nên có và mẫu delta. --children: repo anh em
@@ -272,7 +276,10 @@ function sectionOut(repo, sec, body, fr) {
   const f = fr && fr.sections && fr.sections[sec.id];
   if (f) {
     out.fresh = f.state;
-    if (f.files) { out.stale = f.files; out.stale_count = f.n_files || f.files.length; }
+    if (f.files) {
+      const k = f.state === 'drift' ? 'drift' : 'stale';
+      out[k] = f.files; out[`${k}_count`] = f.n_files || f.files.length;
+    }
     if (f.why) out.fresh_why = f.why;
     if (f.dirty) out.dirty = f.dirty;
   }
@@ -299,6 +306,7 @@ function freshnessOf(storeDir, idx, start, opts) {
 
 function freshLine(s) {
   if (s.fresh === 'stale') return `STALE — ${s.stale_count} file đổi sau sha của mục: ${core.shortFileList(s.stale, 5)} (kiểm lại trước khi dùng)`;
+  if (s.fresh === 'drift') return `drift — ${s.drift_count} file đổi nhưng không tính stale: ${core.shortFileList(s.drift, 5)}`;
   if (s.fresh === 'unknown') return `độ tươi: không xác định — ${s.fresh_why}`;
   if (s.fresh === 'fresh') return 'độ tươi: tươi';
   return null;
@@ -415,7 +423,7 @@ function cmdGet(opts) {
   return { code, out: parts.join('\n\n') };
 }
 
-const FRESH_MARK = { fresh: 'ok   ', stale: 'STALE', unknown: '?    ' };
+const FRESH_MARK = { fresh: 'ok   ', stale: 'STALE', drift: 'drift', unknown: '?    ' };
 
 function listLines(idx, fr, dir) {
   return idx.sections.map((s) => {
@@ -429,7 +437,8 @@ function listLines(idx, fr, dir) {
 function freshHeader(fr, n) {
   if (!fr) return '';
   const head = fr.head ? `HEAD ${fr.head.slice(0, 7)}${fr.branch ? ` (${fr.branch})` : ''}` : 'HEAD ?';
-  return `${head} · ${core.knowledgeSummary(fr, n)} · ${fr.cached ? 'cache' : `tính mới${fr.ms_git ? ` (git ${fr.ms_git} ms)` : ''}`}${fr.error ? ` · git lỗi: ${fr.error}` : ''}`;
+  const notStale = n - ((fr.counts && fr.counts.stale) || 0);
+  return `${head} · ${core.knowledgeSummary(fr, n)} · ${notStale} không stale · ${fr.cached ? 'cache' : `tính mới${fr.ms_git ? ` (git ${fr.ms_git} ms)` : ''}`}${fr.error ? ` · git lỗi: ${fr.error}` : ''}`;
 }
 
 /** Details under list/status: stale files, unknown reasons, uncommitted files (--dirty). */
@@ -440,6 +449,7 @@ function freshDetails(idx, fr) {
     const f = fr.sections[s.id];
     if (!f) continue;
     if (f.state === 'stale') out.push(`    ${s.id}: ${f.n_files || f.files.length} file đổi — ${core.shortFileList(f.files, 5)}`);
+    else if (f.state === 'drift') out.push(`    ${s.id}: drift (không tính stale) — ${f.n_files || f.files.length} file đổi — ${core.shortFileList(f.files, 5)}`);
     else if (f.state === 'unknown') out.push(`    ${s.id}: không xác định — ${f.why}`);
     if (f.dirty) out.push(`    ${s.id}: chưa commit — ${core.shortFileList(f.dirty, 5)}`);
   }
@@ -511,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) {
@@ -524,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();
@@ -811,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) {
@@ -1035,6 +1058,38 @@ function cmdLink(opts) {
   return { code: 0, out: `${verb}: ${other.name} là ${opts.rel === 'child' ? 'con' : 'cha'} của ${info.name}${a.changed || b.changed ? '' : ' (không đổi)'}.` };
 }
 
+/**
+ * Review mark (s6): records reviewed_sha = HEAD of the checkout around --repo on one section, under the store lock.
+ * freshness then counts only the changes after that sha. Body, paths and base are untouched; a merge that replaces the
+ * section writes a new entry without the mark, so new content is never shown as reviewed.
+ */
+function cmdReview(opts) {
+  const { start, info } = infoOf(opts, false);
+  if (!info) return notRepo(start);
+  const ids = opts._.map(String).filter((t) => t.trim());
+  if (ids.length !== 1 || !ID_RE.test(ids[0])) return { code: 1, out: `Cần đúng một <id> mục.\n\n${KNOWLEDGE_HELP.trimEnd()}` };
+  const id = ids[0];
+  const g = core.findGit(start);
+  const h = g ? core.readHead(g) : null;
+  const sha = h && h.sha ? h.sha : (h && h.unsupported ? headShaOf(start) : null);
+  if (!sha || !/^[0-9a-f]{40,64}$/i.test(sha)) return { code: 1, out: 'Không đọc được HEAD đầy đủ của repo (chưa có commit?).' };
+  const ri = readIndex(info.dir);
+  if (ri.error) return { code: 1, out: ri.error };
+  if (!ri.exists) return { code: 1, out: `Kho chưa có mục nào: ${info.dir}.` };
+  const lk = withLock(path.join(info.dir, 'knowledge.lock'), () => {
+    const cur = readIndex(info.dir);
+    if (cur.error) return { code: 1, out: cur.error };
+    const at = cur.idx.sections.findIndex((s) => s.id === id);
+    if (at < 0) return { code: 1, out: `Chưa có mục ${id} trong kho ${info.name}.` };
+    const prev = cur.idx.sections[at].reviewed_sha || null;
+    cur.idx.sections[at] = Object.assign({}, cur.idx.sections[at], { reviewed_sha: sha.toLowerCase(), reviewed_at: new Date().toISOString() });
+    core.writeFileAtomic(path.join(info.dir, 'index.json'), `${JSON.stringify(cur.idx, null, 2)}\n`);
+    return { code: 0, out: `review ${id}: reviewed_sha ${shortSha(sha)}${prev ? ` (trước: ${shortSha(prev)})` : ''}` };
+  }, LOCK_TRIES);
+  if (lk.locked) return { code: 1, out: 'Kho đang bị khoá (knowledge.lock), thử lại.' };
+  return lk.value;
+}
+
 function cmdKnowledge(opts) {
   const sub = opts._.shift();
   if (!sub || opts.help || opts.h || sub === 'help') {
@@ -1045,6 +1100,7 @@ function cmdKnowledge(opts) {
   if (sub === 'get') return cmdGet(opts);
   if (sub === 'list') return cmdList(opts);
   if (sub === 'status') return cmdStatus(opts);
+  if (sub === 'review') return cmdReview(opts);
   if (sub === 'merge') return cmdMerge(opts);
   if (sub === 'link') return cmdLink(opts);
   if (sub === 'bootstrap') return cmdBootstrap(opts);

package/lib/prune.cjs

@@ -1,6 +1,8 @@
 '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.
+// `dieu-phoi prune --after-retro <file> [--yes] [--delta-days N]` (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. 0.7.4 (s6): with
+// --delta-days N (default 30) rejected unmerged deltas of runs idle > N days are deleted; accepted ones never.
+// s9: `--delta-days N` alone (no --after-retro) runs only that delta step (cmdPruneDeltas).
 // Only touches: <runs dir>/<id>/, <data>/plans, <data>/events.jsonl, <data>/archive, <data>/sync-offset.json.
 
 const fs = require('fs');
@@ -58,6 +60,8 @@ function human(n) {
 // contract/steps/plan/handoff files of a run dir: the record of what was planned and handed over (never pruned)
 const KEEP_RE = /^(?:contract-r.*\.md|steps-r.*\.json|plan.*\.md|handoff-.*\.md)$/;
 const DELTA_RE = /^knowledge-delta.*\.md$/i;
+const DAY_MS = 86400000;
+const DELTA_DAYS_DEFAULT = 30;
 
 /**
  * Files to keep in a run dir: retro-*.md + per task/role the highest-try result AND the newest-by-mtime result
@@ -123,6 +127,7 @@ function taskIdsOfDir(id, names, plansDir) {
 function planRuns(ctx, events, cutoffMs, protect, popts) {
   const po = popts || {};
   const nowMs = typeof po.now === 'number' ? po.now : Date.now();
+  const deltaDays = typeof po.deltaDays === 'number' ? po.deltaDays : 0;
   const cls = core.deltaClassifier(events, ctx.paths.plans);
   const runs = core.runsDir();
   const byTask = new Map();
@@ -149,6 +154,19 @@ function planRuns(ctx, events, cutoffMs, protect, popts) {
     if (!inside(runs, dir)) continue;
     const names = fs.readdirSync(dir);
     const tasks = Array.from(taskIdsOfDir(id, names, ctx.paths.plans));
+    if (po.deltaOnly) { // s9 `prune --delta-days N` alone: only the rejected unmerged deltas of an idle run, nothing else
+      let runMs = 0;
+      for (const n of names) { try { runMs = Math.max(runMs, fs.lstatSync(path.join(dir, n)).mtimeMs); } catch (_) { /* gone */ } }
+      if (nowMs - runMs <= deltaDays * DAY_MS) continue;
+      const drops = names.filter((n) => {
+        if (!DELTA_RE.test(n) || cls.deltaState(id, core.deltaTagOf(n)) !== 'reject') return false;
+        let text = null;
+        try { text = fs.readFileSync(path.join(dir, n), 'utf8'); } catch (_) { return false; }
+        return !appliedSet().has(core.deltaHash(text));
+      });
+      if (drops.length) out.prune.push({ id, dir, tasks, keep: [], keep_deltas: 0, archive: [], drop_deltas: drops, del: [], delete_bytes: 0, keep_bytes: 0 });
+      continue;
+    }
     let anyVerdict = false; let reason = null; let latest = 0;
     for (const t of tasks) {
       const evs = byTask.get(t) || [];
@@ -189,6 +207,21 @@ function planRuns(ctx, events, cutoffMs, protect, popts) {
       if (nowMs - m > core.DELTA_WINDOW_MS && cls.deltaState(id, core.deltaTagOf(n)) === null) archive.push(n);
     }
     for (const n of archive) keep.delete(n);
+    // s6 --delta-days N: a delta the user REJECTED, unmerged, in a run idle for more than N days, is no work any more:
+    // deleted with --yes. Accepted-but-unmerged (K7) and no-verdict deltas (K1: archived above, never deleted) stay.
+    const dropDeltas = [];
+    if (deltaDays > 0) {
+      let runMs = 0;
+      for (const n of names) { try { runMs = Math.max(runMs, fs.lstatSync(path.join(dir, n)).mtimeMs); } catch (_) { /* gone */ } }
+      if (nowMs - runMs > deltaDays * DAY_MS) {
+        for (const n of names) {
+          if (!DELTA_RE.test(n) || !keep.has(n) || archive.includes(n)) continue;
+          if (cls.deltaState(id, core.deltaTagOf(n)) !== 'reject' || !unmerged(n)) continue;
+          keep.delete(n);
+          dropDeltas.push(n);
+        }
+      }
+    }
     const keepDeltas = names.filter((n) => DELTA_RE.test(n) && keep.has(n)).length;
     const del = [];
     let delBytes = 0; let keepBytes = 0;
@@ -200,7 +233,7 @@ function planRuns(ctx, events, cutoffMs, protect, popts) {
       del.push({ name: n, bytes: b });
       delBytes += b;
     }
-    out.prune.push({ id, dir, tasks, keep: Array.from(keep).sort(), keep_deltas: keepDeltas, archive, del, delete_bytes: delBytes, keep_bytes: keepBytes });
+    out.prune.push({ id, dir, tasks, keep: Array.from(keep).sort(), keep_deltas: keepDeltas, archive, drop_deltas: dropDeltas, del, delete_bytes: delBytes, keep_bytes: keepBytes });
   }
   return out;
 }
@@ -275,10 +308,46 @@ function otherSessionActive(ctx, opts, events) {
   return count ? { count, sessions: Array.from(sessions), last: new Date(last).toISOString(), ownKnown: !!own } : null;
 }
 
+/**
+ * s9 `prune --delta-days N` without --after-retro: deletes (with --yes) only the rejected, unmerged deltas of runs idle
+ * for more than N days. No run dir is archived, no event moves, no bad plan goes. Dry-run otherwise.
+ */
+function cmdPruneDeltas(opts, ctx) {
+  const dd = opts['delta-days'];
+  const deltaDays = dd === true ? DELTA_DAYS_DEFAULT : Number(dd);
+  if (!Number.isFinite(deltaDays) || deltaDays < 0) return { code: 2, out: `prune: --delta-days phải là số ngày ≥ 0 (nhận: ${dd})` };
+  const runs = core.runsDir();
+  if (!path.isAbsolute(runs) || runs === path.parse(runs).root) return { code: 2, out: `prune: từ chối đường dẫn runs không an toàn: ${runs}` };
+  const yes = opts.yes === true || opts.yes === 'y' || opts.yes === 'yes';
+  const rp = planRuns(ctx, core.readEvents(ctx), 0, null, { now: typeof opts.now === 'number' ? opts.now : undefined, deltaDays, deltaOnly: true });
+  let removed = 0;
+  if (yes) {
+    for (const r of rp.prune) {
+      for (const n of r.drop_deltas) {
+        const p = path.join(r.dir, n);
+        if (!inside(r.dir, p) || !inside(runs, p)) continue;
+        fs.rmSync(p, { force: true });
+        removed++;
+      }
+    }
+  }
+  const total = rp.prune.reduce((n, r) => n + r.drop_deltas.length, 0);
+  if (opts.json) {
+    return { code: 0, out: JSON.stringify({ mode: yes ? 'apply' : 'dry-run', delta_only: true, delta_days: deltaDays,
+      runs: rp.prune.map((r) => ({ id: r.id, drop_deltas: r.drop_deltas })), totals: { drop_deltas: total, removed } }, null, 2) };
+  }
+  const L = [];
+  L.push(`prune --delta-days ${deltaDays} ${yes ? '(ĐÃ THỰC HIỆN)' : '(dry-run — thêm --yes để thực hiện)'}: chỉ delta đã từ chối, chưa gộp, của run rảnh > ${deltaDays} ngày`);
+  for (const r of rp.prune) L.push(`  ${r.id}: ${yes ? 'xoá' : 'sẽ xoá'} ${r.drop_deltas.length} delta (${r.drop_deltas.join(', ')})`);
+  L.push(`Tổng: ${total} delta ${yes ? `đã xoá ${removed}` : 'sẽ xoá'}. Không đụng run dir khác, events.jsonl, plan hay archive.`);
+  return { code: 0, out: L.join('\n') };
+}
+
 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>' };
+  if (!retro && opts['delta-days'] !== undefined) return cmdPruneDeltas(opts, ctx);
+  if (!retro) return { code: 2, out: 'prune: thiếu --after-retro <file retro> (hoặc --delta-days N để chỉ dọn delta đã từ chối)' };
   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();
@@ -287,10 +356,14 @@ function cmdPrune(opts) {
     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';
+  // --delta-days N (default 30; 0 = off): rejected unmerged deltas of runs idle > N days are deleted with --yes
+  const dd = opts['delta-days'];
+  const deltaDays = dd === undefined ? DELTA_DAYS_DEFAULT : (dd === true ? DELTA_DAYS_DEFAULT : Number(dd));
+  if (!Number.isFinite(deltaDays) || deltaDays < 0) return { code: 2, out: `prune: --delta-days phải là số ngày ≥ 0 (nhận: ${dd})` };
   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, { now: typeof opts.now === 'number' ? opts.now : undefined });
+  const rp = planRuns(ctx, allEvents, cut.ms, retro, { now: typeof opts.now === 'number' ? opts.now : undefined, deltaDays });
   const prunedTasks = new Set();
   for (const r of rp.prune) for (const t of r.tasks) prunedTasks.add(t);
   const plans = badPlans(ctx);
@@ -308,7 +381,7 @@ function cmdPrune(opts) {
 
   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_deltas: r.keep_deltas, archive_deltas: r.archive.length, keep_bytes: r.keep_bytes })),
+    runs: rp.prune.map((r) => ({ id: r.id, delete_files: r.del.length, delete_bytes: r.delete_bytes, keep: r.keep, keep_deltas: r.keep_deltas, archive_deltas: r.archive.length, drop_deltas: r.drop_deltas.length, 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 })),
@@ -317,6 +390,7 @@ function cmdPrune(opts) {
   report.totals = {
     run_dirs: rp.prune.length,
     archive_deltas: rp.prune.reduce((n, r) => n + r.archive.length, 0),
+    drop_deltas: rp.prune.reduce((n, r) => n + r.drop_deltas.length, 0),
     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),
   };
@@ -402,7 +476,7 @@ function cmdPrune(opts) {
   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)}), trong đó delta chưa gộp ${r.keep_deltas}${r.archive.length ? `; chuyển ${r.archive.length} delta >30 ngày chưa có verdict sang _archive/deltas/` : ''}`);
+  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)}), trong đó delta chưa gộp ${r.keep_deltas}${r.archive.length ? `; chuyển ${r.archive.length} delta >30 ngày chưa có verdict sang _archive/deltas/` : ''}${r.drop_deltas.length ? `; xoá ${r.drop_deltas.length} delta đã từ chối (run nằm yên >${deltaDays} ngày)` : ''}`);
   L.push(`Plan hỏng: ${plans.length} (${human(plans.reduce((n, p) => n + p.bytes, 0))})${plans.length ? ` — ${plans.map((p) => p.name).join(', ')}` : ''}`);
   const evTxt = yes
     ? `đã chuyển ${removedLines}/${lines.length} dòng vào archive và xoá khỏi events.jsonl (${freshCount} dòng ghi mới${freshCount ? ` vào archive/events-${archiveToday()}.jsonl.gz` : ''}; ${human(evBytes)})`

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.3",
+  "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>",

package/profile/lessons.md

@@ -20,7 +20,6 @@ Nhiều máy: file trong skill đã publish là bản đã duyệt (một nguồ
 
 Câu hỏi bắt buộc hỏi ở cổng 1 cho từng loại task (retro thêm khi tỉ lệ steer cao). Định dạng: `- <task_type>: <câu hỏi>`
 
-- *: (chỉ khi kế hoạch có ≥ 4 bước s≤6) Chọn mode? fast (bước s≤6 không verifier riêng, test chọn lọc, một verifier gộp chạy cả suite trước khi trình, tự nghiệm thu rồi bạn duyệt cuối) | normal (mặc định) | strict (luôn cả suite + kiểm ngẫu nhiên 1/3). Kế hoạch nhỏ hơn: dùng normal, không hỏi (retro 11-05: 46/46 lần chọn normal, fast 0 lần qua 2 retro). Sàn an toàn giữ ở mọi mode; đổi được giữa chừng.
 - extract: Cần đúng những trường nào, đầu ra định dạng gì (bảng/JSON/cột Sheet), và khi các nguồn lệch nhau thì nguồn nào là chuẩn? (retro 11-05: steer_rate 0,3, n10)
 
 ## Bài học