@kienntpixon/dieu-phoi 0.7.4 → 0.7.6

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog — @kienntpixon/dieu-phoi
 
+## 0.7.6 (2026-11-07)
+
+Đi cùng skill 1.6.6. `CORE_VERSION` 0.7.6. Không đổi sink (`sheet/Code.gs`, `fixtures/` giữ nguyên).
+**Sau khi cài:** `npm i -g @kienntpixon/dieu-phoi` + **`dieu-phoi setup` (bắt buộc: hook cài nay đi kèm `bin/lib/`)** + `dieu-phoi doctor`.
+
+- **`wt gc [--repo R | --all-repos] [--yes] [--json] [--no-measure]`:** quét MỌI worktree đăng ký trong git (có dấu hay không) và xếp lớp `safe` / `keep-slot` / `abandoned` / `keep` / `prunable` / `shell` / `temp-branch`, kèm dung lượng từng mục và tổng thu hồi (ước lượng, trần thời gian). Dry-run mặc định; `--yes` chỉ gỡ `safe`, vỏ mồ côi, mục prunable và nhánh tạm đã merge. Nhàn rỗi tính theo mốc mới nhất của commit cuối, file mới nhất trong worktree và agent sống; không biết thì không bao giờ safe. Slot tên tự đặt (`keep-slot`) KHÔNG BAO GIỜ tự gỡ. Lớp `abandoned` (chưa merge, nhàn rỗi ≥ `wt_abandon_days` = 14) chỉ liệt kê.
+- **Sổ repo + `wt repos [--seed <dir>…] [--depth N] [--json]`:** `data/repos.json` ghi repo mà hook (cwd, repo đích của brief), agent sống, `wt add` và sự kiện worktree chạm tới; `--seed` quét thư mục. `wt gc --all-repos` đọc sổ này.
+- **Dọn tự động, chỉ bốn lớp an toàn — safe, vỏ, prunable, nhánh tạm `-d`; không bao giờ bỏ dở/keep/slot (`wt_auto_gc` = `safe`|`off`, mặc định `safe`):** (a) `verdict … accept` của người dùng gc ở repo vừa nghiệm thu (`--clean-merged` còn là bí danh); (b) hook `UserPromptSubmit` spawn nền `hook.cjs --gc-auto` mỗi `wt_gc_interval_h` (6) giờ, có khoá và nhật ký `data/gc-log.jsonl`, không chặn prompt; (c) ổ chứa repo còn dưới `wt_disk_low_gb` (15, 0 = tắt) GB: một dòng cảnh báo kèm số GB thu hồi được ở lớp cần duyệt, và gc safe chạy ngay. Đường đĩa spawn tối đa mỗi 30 phút. MỖI lần gỡ ghi một sự kiện `worktree` riêng (`remove`, `remove-shell`, `prune`, `branch-delete`, kèm `trigger`) + `wt_gc_auto` có `paths` và `branches`; `state` hiện cả hai. Lỗi lặp do thiếu `bin/lib` chỉ ghi `hook-errors.log` một lần mỗi 24 giờ. `wt_keep` thêm mẫu slot giữ lại.
+- **Sửa: hook cài bằng `setup` thiếu `lib/`.** Từ 0.7.6 s2 hook nạp `./lib/repos.cjs` / `./lib/wtgc.cjs`, nhưng `setup` chỉ chép một file, nên hook cài sẽ lỗi nạp (lỗi này có từ commit nền b8c5011). `setup` nay chép toàn bộ `lib/*.cjs` vào `bin/lib/` (`uninstall --purge` xoá). Tính năng phụ (sổ repo, cảnh báo ổ, gc nền) bọc try/catch: thiếu `bin/lib` chỉ ghi `errors.log`, prompt không bao giờ hỏng. Test chạy bản đã cài từ thư mục setup tạm.
+- **Hoãn sang 0.7.7 (s4):** tag `dp-archive/<branch>-<yyyymmdd>` và `wt gc --abandoned --yes` cho lớp bỏ dở. 0.7.6 chưa gắn tag, chưa gỡ lớp này.
+
+## 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,8 +49,20 @@ 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)
+  wt repos [--seed <dir>…] [--depth N] [--json]
+                         sổ repo đã chạm (data/repos.json): --seed quét thư mục tới độ sâu N (mặc định 3), sự kiện worktree và git worktree list của repo đã biết
+  wt gc [--repo R | --all-repos] [--yes] [--json] [--no-measure]
+                         quét MỌI worktree đăng ký trong git (có dấu hay không; --all-repos = mọi repo trong sổ repo) và xếp lớp:
+                         safe (nhánh đang checkout đã vào một nhánh bền bất kỳ, sạch, không agent sống, không khoá thật; có dấu: tuổi ≥ 1 giờ
+                         + verdict pass/accept; không dấu hoặc thiếu verdict: nhàn rỗi > 24 giờ), keep-slot (tên tự đặt, Library/, lane/*,
+                         .dieu-phoi-keep, wt_keep: không bao giờ tự gỡ), abandoned (chưa merge, nhàn rỗi ≥ wt_abandon_days 14: chỉ liệt kê),
+                         keep (kèm lý do), prunable, vỏ mồ côi, nhánh tạm đã merge. Báo dung lượng từng mục + tổng thu hồi (ước lượng, trần thời gian).
+                         Dry-run mặc định; --yes chỉ gỡ safe + vỏ + prune + git branch -d nhánh tạm
   steer <agent_id> --kind minor|plan|redirect [--reason R]
   steer --task <task_id> --kind minor|plan|redirect [--reason R]
                          ghi một lần người dùng lái giữa chừng (--task: chỉ các agent đang chạy của task)

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.6';
 const SCHEMA = 1;
 const TASK_TYPES = [
   'search', 'extract', 'mechanical-edit', 'feature-impl', 'debug', 'refactor',
@@ -205,6 +205,27 @@ function logError(home, err, where) {
   } catch (_) { /* nothing left to do */ }
 }
 
+/**
+ * Lỗi lặp lại theo prompt (thiếu bin/lib ở bản cài lẻ): chỉ ghi MỘT lần mỗi LOG_ONCE_MS cho mỗi (nơi, mã lỗi).
+ * Mốc ở <home>/hook-errors-once.json; không đọc/ghi được mốc thì cứ ghi (thà ồn còn hơn câm).
+ */
+const LOG_ONCE_MS = 24 * 3600000;
+function logErrorOnce(home, err, where, now) {
+  try {
+    const p = pathsFor(home || resolveHome());
+    const f = path.join(p.home, 'hook-errors-once.json');
+    const t = typeof now === 'number' ? now : Date.now();
+    const key = where + ':' + String((err && (err.code || err.message)) || err).slice(0, 120);
+    let m = {};
+    try { m = JSON.parse(fs.readFileSync(f, 'utf8')) || {}; } catch (_) { m = {}; }
+    if (t - (Number(m[key]) || 0) < LOG_ONCE_MS) return;
+    m[key] = t;
+    fs.mkdirSync(p.home, { recursive: true });
+    fs.writeFileSync(f, JSON.stringify(m) + '\n');
+  } catch (_) { /* không ghi được mốc: vẫn ghi lỗi */ }
+  logError(home, err, where);
+}
+
 // ------------------------------------------------------------------ identity
 
 function computeUserHash() {
@@ -946,6 +967,10 @@ const EVENTS_LOCK_WAIT_MS = 1500;
 
 function appendEvent(ctx, ev) {
   fs.mkdirSync(ctx.paths.data, { recursive: true });
+  // core 0.7.6 (s2): sự kiện worktree (add/remove/gc) có repo → sổ repo đã chạm (best effort)
+  try {
+    if (ev && ev.kind === 'worktree' && typeof ev.repo === 'string' && ev.repo) require('./lib/repos.cjs').recordRepo(ctx.paths.data, ev.repo, 'worktree');
+  } catch (_) { /* sổ repo không được làm hỏng sự kiện */ }
   // Core 0.5.4: appends take events.lock so `prune --yes` (which rewrites the file under the same lock) can never
   // lose a line that lands between its read and its rename. Lock wait is capped well under the shortest hook timeout
   // (UserPromptSubmit 5 s) so a stuck lock cannot get the hook killed mid-write; on timeout append anyway (never drop telemetry).
@@ -1708,21 +1733,174 @@ function formatStartBlock(info) {
   ].filter((l) => l !== '').join('\n');
 }
 
+// ------------------------------------------------------------------ r1 s5 (core 0.7.6): gc nền tự động
+// Hook chỉ làm việc RẺ: đọc data/gc-auto.json (+ sổ repo, statfs mỗi ổ) rồi spawn tách rời `hook.cjs --gc-auto`; không require wtgc.
+// Chỉ lớp safe (gc quyết định bằng kiểm tra tươi, xem wtgc.cjs); lớp bỏ dở / slot / keep KHÔNG BAO GIỜ tự gỡ.
+const GC_AUTO_FILE = 'gc-auto.json'; // { t: lần spawn theo giờ, disk_t: lần spawn vì thiếu đĩa, warn_t: lần cảnh báo }
+const GC_TOTALS_FILE = 'gc-totals.json'; // do tiến trình gc nền ghi: { ts, abandoned_bytes, keep_slot_bytes, reclaimed_bytes }
+const GC_LOCK_FILE = 'gc-auto.lock';
+const GC_LOCK_STALE_MS = 30 * 60 * 1000;
+const GC_DISK_GAP_MS = 30 * 60 * 1000; // spawn vì thiếu đĩa: cách nhau tối thiểu
+const GC_WARN_GAP_MS = 30 * 60 * 1000; // cảnh báo thiếu đĩa: cách nhau tối thiểu (mỗi prompt một dòng là ồn)
+const GC_DEFAULT_INTERVAL_H = 6;
+const GC_DEFAULT_DISK_LOW_GB = 15;
+const GC_GB = 1073741824;
+
+/** wt_auto_gc: env DIEU_PHOI_WT_AUTO_GC -> config.json -> 'safe'. off/false/0/no -> 'off', còn lại 'safe'. */
+function autoGcModeOf(ctx) {
+  const cfg = ctx && ctx.config ? ctx.config : {};
+  const v = [process.env.DIEU_PHOI_WT_AUTO_GC, cfg.wt_auto_gc].find((x) => x !== undefined && x !== null && x !== '');
+  const s = String(v === undefined ? 'safe' : v).trim().toLowerCase();
+  return ['off', 'false', '0', 'no'].includes(s) ? 'off' : 'safe';
+}
+
+/** Số >= 0 (có thể thập phân): env DIEU_PHOI_<KEY> -> config.json -> mặc định; nguồn hỏng rơi xuống nguồn kế. */
+function gcNumberOf(ctx, key, def) {
+  const cfg = ctx && ctx.config ? ctx.config : {};
+  for (const v of [process.env['DIEU_PHOI_' + key.toUpperCase()], cfg[key]]) {
+    if (v === undefined || v === null || v === '') continue;
+    const n = Number(v);
+    if (Number.isFinite(n) && n >= 0) return n;
+  }
+  return def;
+}
+
+/** Ổ chứa repo đã đăng ký có dưới lowGb GB trống không -> [{ drive, free_bytes }] (rẻ: một statfs mỗi ổ). */
+function lowDisksOf(ctx, lowGb, statfs) {
+  let reg;
+  try { reg = require('./lib/repos.cjs').readRegistry(ctx.paths.data); } catch (e) {
+    // thiếu/hỏng lib (cài lẻ): không có sổ repo thì không cảnh báo ổ; nhưng gc theo giờ vẫn chạy. Ghi lỗi để doctor thấy.
+    try { logErrorOnce(ctx.home, e, 'disk-registry'); } catch (_) { /* hết cách */ }
+    return [];
+  }
+  const sf = statfs || ((p) => fs.statfsSync(p));
+  const seen = new Set();
+  const low = [];
+  for (const repo of Object.keys(reg)) {
+    let key;
+    let probe = repo;
+    if (process.platform === 'win32') { probe = path.parse(repo).root; key = probe.toLowerCase(); } else {
+      try { key = String(fs.statSync(repo).dev); } catch (_) { continue; }
+    }
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    try {
+      const s = sf(probe);
+      const free = Number(s.bavail) * Number(s.bsize);
+      if (Number.isFinite(free) && free < lowGb * GC_GB) low.push({ drive: probe, free_bytes: free });
+    } catch (_) { /* ổ không đọc được: bỏ qua */ }
+  }
+  return low;
+}
+
+/** Tạo khoá (wx); khoá cũ hơn GC_LOCK_STALE_MS bị chiếm lại. true = đã giữ khoá. */
+function takeGcLock(file, now) {
+  for (let i = 0; i < 2; i++) {
+    try {
+      const fd = fs.openSync(file, 'wx');
+      fs.writeSync(fd, JSON.stringify({ t: now, pid: process.pid }) + '\n');
+      fs.closeSync(fd);
+      return true;
+    } catch (e) {
+      if (e.code !== 'EEXIST') return false;
+      try { if (Date.now() - fs.statSync(file).mtimeMs <= GC_LOCK_STALE_MS) return false; fs.unlinkSync(file); } catch (_) { return false; }
+    }
+  }
+  return false;
+}
+
+/**
+ * Mỗi prompt (rẻ, không chặn): quá wt_gc_interval_h (6) hoặc ổ chứa repo dưới wt_disk_low_gb (15) -> spawn tách rời gc lớp safe.
+ * Mốc ghi TRƯỚC khi spawn (hai prompt liền nhau chỉ spawn một lần); khoá data/gc-auto.lock chặn chạy chồng.
+ * deps (test): now, statfs, spawn(exe, args, env), cmd:[exe, args]. Trả { spawned, reason, message }.
+ */
+function autoGcTick(ctx, deps) {
+  const d = deps || {};
+  const res = { spawned: false, reason: null, message: null };
+  try {
+    if (autoGcModeOf(ctx) === 'off') { res.reason = 'off'; return res; }
+    const injected = !!(d.spawn || d.cmd);
+    if (!injected && (process.env.DIEU_PHOI_NO_SPAWN === '1' || process.env.NODE_TEST_CONTEXT)) { res.reason = 'no-spawn'; return res; }
+    const now = typeof d.now === 'number' ? d.now : Date.now();
+    const file = path.join(ctx.paths.data, GC_AUTO_FILE);
+    const st = readJsonFile(file, {}) || {};
+    const intervalMs = gcNumberOf(ctx, 'wt_gc_interval_h', GC_DEFAULT_INTERVAL_H) * 3600000;
+    const lowGb = gcNumberOf(ctx, 'wt_disk_low_gb', GC_DEFAULT_DISK_LOW_GB);
+    const low = lowGb > 0 ? lowDisksOf(ctx, lowGb, d.statfs) : [];
+    const timed = intervalMs > 0 && now - (Number(st.t) || 0) >= intervalMs;
+    const disk = low.length > 0 && now - (Number(st.disk_t) || 0) >= GC_DISK_GAP_MS;
+    let running = false;
+    if (timed || disk) {
+      const lock = path.join(ctx.paths.data, GC_LOCK_FILE);
+      fs.mkdirSync(ctx.paths.data, { recursive: true });
+      if (!takeGcLock(lock, now)) { running = true; res.reason = 'locked'; } else {
+        const next = Object.assign({}, st, { t: now });
+        if (disk) next.disk_t = now;
+        writeFileAtomic(file, JSON.stringify(next) + '\n'); // mốc trước khi spawn
+        Object.assign(st, next);
+        try {
+          const cmd = d.cmd || [process.execPath, [__filename, '--gc-auto']];
+          const env = Object.assign({}, process.env, { DIEU_PHOI_HOME: ctx.home, DIEU_PHOI_GC_TRIGGER: disk && !timed ? 'disk' : 'hook' });
+          if (d.spawn) d.spawn(cmd[0], cmd[1], env); else {
+            const child = require('child_process').spawn(cmd[0], cmd[1], { detached: true, stdio: 'ignore', windowsHide: true, env });
+            child.on('error', (e) => { logError(ctx.home, e, 'spawn-gc'); try { fs.unlinkSync(lock); } catch (_) { /* đã mất */ } });
+            child.unref();
+          }
+          res.spawned = true;
+          res.reason = disk && !timed ? 'disk' : 'interval';
+        } catch (e) {
+          logError(ctx.home, e, 'spawn-gc');
+          try { fs.unlinkSync(lock); } catch (_) { /* đã mất */ }
+        }
+      }
+    }
+    if (low.length && now - (Number(st.warn_t) || 0) >= GC_WARN_GAP_MS) {
+      const tot = readJsonFile(path.join(ctx.paths.data, GC_TOTALS_FILE), null);
+      const need = tot ? (Number(tot.abandoned_bytes) || 0) + (Number(tot.keep_slot_bytes) || 0) : null;
+      const gb = (n) => (n / GC_GB).toFixed(1);
+      const drives = low.map((x) => x.drive.replace(/[\\/]+$/, '') + ' còn ' + gb(x.free_bytes) + ' GB').join(', ');
+      const figure = need === null ? 'chưa đo lớp cần duyệt' : 'thu hồi được ≥ ' + gb(need) + ' GB ở lớp bỏ dở/slot (cần duyệt)';
+      const doing = res.spawned || running ? 'đang dọn nền lớp safe' : 'lớp safe vừa dọn gần đây';
+      res.message = 'dieu-phoi: ổ ' + drives + ' (< ' + lowGb + ' GB); ' + doing + '; ' + figure + '. Xem lớp bỏ dở/giữ (không tự gỡ): dieu-phoi wt gc --all-repos --measure';
+      writeFileAtomic(file, JSON.stringify(Object.assign({}, st, { warn_t: now })) + '\n');
+    }
+  } catch (e) {
+    try { logErrorOnce(ctx.home, e, 'gc-tick'); } catch (_) { /* hết cách */ }
+  }
+  return res;
+}
+
+/** Tiến trình nền (hook.cjs --gc-auto): gc lớp safe mọi repo, ghi log + sự kiện; luôn nhả khoá. */
+function runGcChild() {
+  const ctx = makeCtx();
+  try {
+    require('./lib/wtgc.cjs').autoGc(ctx, { allRepos: true, trigger: process.env.DIEU_PHOI_GC_TRIGGER || 'hook' });
+  } catch (e) {
+    logError(ctx.home, e, 'gc-auto');
+  } finally {
+    try { fs.unlinkSync(path.join(ctx.paths.data, GC_LOCK_FILE)); } catch (_) { /* đã mất */ }
+  }
+}
+
 /** UserPromptSubmit: on a dieu-phoi prompt, pre-create the run and inject id/run dir/health/brief. */
-function handleUserPromptSubmit(p, ctx) {
+function handleUserPromptSubmit(p, ctx, gcDeps) {
   // s6: stuck/orphaned agents of this session → TaskStop + reap reminder, on any prompt (not only dieu-phoi ones)
   const stuck = typeof p.session_id === 'string' && p.session_id && !watchAgentId(p) ? stuckReminder(ctx, { sessionId: p.session_id }) : null;
+  // r1 s5: gc nền lớp safe, không chặn prompt. r1 s6: tính năng phụ — mọi lỗi (thiếu lib, statfs, spawn) chỉ ghi log, prompt vẫn đi tiếp.
+  let gcTick = { spawned: false, reason: 'error', message: null };
+  try { gcTick = autoGcTick(ctx, gcDeps || null); } catch (e) { try { logError(ctx.home, e, 'gc-tick'); } catch (_) { /* hết cách */ } }
+  const sys = gcTick.message ? { systemMessage: gcTick.message } : {};
   if (!isDieuPhoiPrompt(p.prompt)) {
-    if (!stuck) return null;
-    return { stdout: JSON.stringify({ hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: stuck } }), stuck: true };
+    if (!stuck) return gcTick.message ? { stdout: JSON.stringify(sys), gc: gcTick } : null;
+    return { stdout: JSON.stringify(Object.assign({ hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: stuck } }, sys)), stuck: true };
   }
   const info = startInfo(ctx, typeof p.cwd === 'string' ? p.cwd : null);
   const text = stuck ? `${formatStartBlock(info)}
 ${stuck}` : formatStartBlock(info);
   return {
-    stdout: JSON.stringify({
+    stdout: JSON.stringify(Object.assign({
       hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: text },
-    }),
+    }, sys)),
     info,
   };
 }
@@ -1875,7 +2053,7 @@ const DEFAULT_MODE = 'normal';
 /** Removed in 0.7.4: old events/plans/configs may still carry it; every reader treats it as normal. */
 const LEGACY_MODE = 'strict';
 /** Event kinds that stay on this machine: runSync does not send them (an older sink would answer bad_kind). */
-const LOCAL_ONLY_KINDS = new Set(['mode', 'knowledge_merge', 'leftover', 'worktree', 'reap', 'reap_orphans']);
+const LOCAL_ONLY_KINDS = new Set(['mode', 'knowledge_merge', 'leftover', 'worktree', 'reap', 'reap_orphans', 'wt_gc_auto']);
 /** A mode the user may choose now (fast | normal). */
 function isMode(m) {
   return typeof m === 'string' && MODES.includes(m);
@@ -2897,6 +3075,31 @@ function projectFields(p) {
   return {};
 }
 
+/**
+ * core 0.7.6 (s2): ghi repo của cwd payload và repo đích của brief vào data/repos.json (best effort, không spawn git).
+ * Module lười nạp trong try: lỗi nạp không được làm hỏng hook.
+ */
+function recordReposFromPayload(p, ctx) {
+  if (!p || typeof p !== 'object' || !ctx || !ctx.paths || !ctx.paths.data) return;
+  const R = require('./lib/repos.cjs');
+  const dataDir = ctx.paths.data;
+  const name = typeof p.hook_event_name === 'string' ? p.hook_event_name : '';
+  const src = /^Subagent/.test(name) ? 'live' : 'hook';
+  const ti = p.tool_input && typeof p.tool_input === 'object' ? p.tool_input : {};
+  const prompt = typeof ti.prompt === 'string' ? ti.prompt : '';
+  const cwd = typeof p.cwd === 'string' && p.cwd ? p.cwd : null;
+  // (a) `git [-C repo] worktree add` trong Bash (Pre/Post): repo resolve bằng git rev-parse --git-common-dir
+  if (p.tool_name === 'Bash' && typeof ti.command === 'string') R.recordWorktreeAddCommand(dataDir, ti.command, cwd);
+  // (b) SubagentStart/Stop: cwd payload và worktree: của brief (Claude Code isolation) → checkout chính của nó
+  const cands = [cwd, prompt ? repoFromBrief(prompt) : null, prompt ? briefWorktree(prompt) : null];
+  const seen = new Set();
+  for (const d of cands) {
+    if (!d || seen.has(d)) continue;
+    seen.add(d);
+    R.recordRepo(dataDir, d, src);
+  }
+}
+
 /** Run dir id the brief points at (retro 11-05 K1: accept finds the delta there whatever the plan/root says), else null. */
 function dispatchRun(prompt) {
   try {
@@ -4879,6 +5082,7 @@ function runHook(opts) {
     if (!raw || !raw.trim()) return null;
     const p = JSON.parse(raw.replace(/^/, ''));
     const ctx = makeCtx(home);
+    try { recordReposFromPayload(p, ctx); } catch (_) { /* sổ repo (core 0.7.6): best effort, không chặn hook */ }
     let ev = null;
     const name = p.hook_event_name;
     if (o.mode === 'watch') return handleWatch(p, ctx, o); // { stdout } or null
@@ -4893,6 +5097,8 @@ function runHook(opts) {
       // s7: keep the live record (worktree, start) for the guarded leftover kill before the file goes
       let live = null;
       try { live = typeof p.agent_id === 'string' && p.agent_id ? readJsonFile(liveFile(ctx, p.agent_id), null) : null; } catch (_) { live = null; }
+      // (b) core 0.7.6: worktree của agent (live.cwd) → checkout chính vào sổ repo, trước khi live bị xoá
+      try { if (live && typeof live.cwd === 'string' && live.cwd) require('./lib/repos.cjs').recordRepo(ctx.paths.data, live.cwd, 'live'); } catch (_) { /* best effort */ }
       try { removeLive(ctx, p.agent_id); } catch (e) { logError(home, e, 'live-remove'); }
       const r = handleSubagentStop(p, ctx, { live });
       if (r && typeof r.stdout === 'string') return r; // s15: block decision, printed as the hook's JSON answer
@@ -5047,7 +5253,7 @@ async function runSync(ctx, opts) {
 // ------------------------------------------------------------------ exports / main
 
 module.exports = {
-  runsDir, loadPlans, isDieuPhoiPrompt, foldPrompt, sinkStatusCached, sinkUrlKey, SINK_CACHE_TTL_MS, scoutBriefPath, quickHealth, startRun, startInfo, startKnowledgeOf, knowledgeLines, orchLessons, orchLessonLines, abortReasonOf, completionStatus, logGate, QUOTA_PAUSE_MARKER, stepIds, START_STEP_IDS, healthLine, formatStartBlock, handleUserPromptSubmit, START_PREFIX, buildSessionState, findOrphanAgents, orphanLines, ORPHAN_MIN_MS, ORPHAN_NO_COMPLETE_MS, formatSessionState, stateCounts, compactSystemMessage, handleSessionStart, dispatchInSession, STATE_TEXT_CAP, COMPACT_PREFIX,
+  runsDir, loadPlans, isDieuPhoiPrompt, foldPrompt, sinkStatusCached, sinkUrlKey, SINK_CACHE_TTL_MS, scoutBriefPath, quickHealth, startRun, startInfo, startKnowledgeOf, knowledgeLines, orchLessons, orchLessonLines, abortReasonOf, completionStatus, logGate, QUOTA_PAUSE_MARKER, stepIds, START_STEP_IDS, healthLine, formatStartBlock, handleUserPromptSubmit, autoGcTick, autoGcModeOf, gcNumberOf, lowDisksOf, runGcChild, START_PREFIX, buildSessionState, findOrphanAgents, orphanLines, ORPHAN_MIN_MS, ORPHAN_NO_COMPLETE_MS, formatSessionState, stateCounts, compactSystemMessage, handleSessionStart, dispatchInSession, STATE_TEXT_CAP, COMPACT_PREFIX,
   modeLine, MODES, DEFAULT_MODE, LOCAL_ONLY_KINDS, isMode, normMode, LEGACY_MODE, rootModeFromEvents, rootModeFromText, dispatchModeFromEvents, taskModeInfo, planOfTask, modeFields,
   rootTaskIds,
   testCommandInfo, testTimeOf, testSFromText,
@@ -5070,7 +5276,10 @@ module.exports = {
 if (require.main === module) {
   process.on('uncaughtException', (e) => { logError(null, e, 'uncaught'); process.exit(0); });
   process.on('unhandledRejection', (e) => { logError(null, e, 'unhandled'); process.exit(0); });
-  if (process.argv.includes('--sync')) {
+  if (process.argv.includes('--gc-auto')) {
+    runGcChild();
+    process.exit(0);
+  } else if (process.argv.includes('--sync')) {
     const ctx = makeCtx();
     runSync(ctx)
       .then((r) => { if (!r.ok) logError(ctx.home, new Error(r.error), 'sync'); })

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', 'all-repos', 'measure', 'no-measure']);
 
 /** 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.gcAfterAccept(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.gcAfterAccept(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`);
@@ -810,7 +813,7 @@ function cmdDiscard(opts) {
   core.appendEvent(ctx, ev);
   const n = events.filter((e) => e.task_id === taskId).length;
   // s17: task bị loại → gỡ worktree có dấu của task (sạch); còn thay đổi thì giữ và báo.
-  const wtLines = wt.cleanupTask(ctx, events, taskId, opts.repo);
+  const wtLines = wt.cleanupTask(ctx, events, taskId, opts.repo, { discard: true });
   if (opts.json) {
     if (wtLines.length) process.stderr.write(`${wtLines.join('\n')}\n`);
     return { code: 0, out: JSON.stringify(ev) };
@@ -1011,11 +1014,13 @@ function cmdState(opts) {
   const deltas = core.scanUnmergedDeltasFor(ctx);
   const deltaLines = core.unmergedDeltaLines(deltas);
   const hasDeltas = core.hasUnmergedDeltas(deltas);
+  const gcState = require('./wtgc.cjs').autoGcState(core.readEvents(ctx)); // r1 s5 (d): gc tự động đã gỡ gì
+  const gcLines = require('./wtgc.cjs').autoGcLines(core.readEvents(ctx));
   if (!sid) {
     if (opts.json) {
-      return { code: 0, out: JSON.stringify(Object.assign({ session_id: null, generated_at: core.nowIso(), runs_dir: null, plans: [], tasks: [] }, hasDeltas ? { unmerged_deltas: deltas } : {})) };
+      return { code: 0, out: JSON.stringify(Object.assign({ session_id: null, generated_at: core.nowIso(), runs_dir: null, plans: [], tasks: [] }, hasDeltas ? { unmerged_deltas: deltas } : {}, gcState ? { wt_gc_auto: gcState } : {})) };
     }
-    return { code: 0, out: ['Không có session (thiếu CLAUDE_CODE_SESSION_ID, dùng --session <id>).'].concat(deltaLines).join('\n') };
+    return { code: 0, out: ['Không có session (thiếu CLAUDE_CODE_SESSION_ID, dùng --session <id>).'].concat(deltaLines, gcLines).join('\n') };
   }
   const state = core.buildSessionState(core.readEvents(ctx), sid, { plansDir: ctx.paths.plans });
   const orphans = orphanCount(ctx); // s16: null (unknown) leaves the line out
@@ -1027,13 +1032,13 @@ function cmdState(opts) {
       session: live.session, machine: live.machine, limits: live.limits, free_session: freeSlots(live.limits.session, live.session), free_machine: freeSlots(live.limits.machine, live.machine), agents: live.agents,
       stuck: stuck.map((a) => ({ agent_id: a.agent_id, task_id: a.task_id, role: a.role, gen: a.gen, state: a.state, reasons: a.reasons, idle_min: a.idle_min, age_min: a.age_min })),
     };
-    return { code: 0, out: JSON.stringify(Object.assign({}, state, hasDeltas ? { unmerged_deltas: deltas } : {}, orphans === null ? {} : { orphan_procs: orphans }, { live: liveJ }, batchPending.length ? { batch_pending: batchPending } : {}), null, 2) };
+    return { code: 0, out: JSON.stringify(Object.assign({}, state, hasDeltas ? { unmerged_deltas: deltas } : {}, gcState ? { wt_gc_auto: gcState } : {}, orphans === null ? {} : { orphan_procs: orphans }, { live: liveJ }, batchPending.length ? { batch_pending: batchPending } : {}), null, 2) };
   }
   const batchLines = batchPending.map((p) => `CẢNH BÁO: ${p.root_task_id}: ${p.steps.length} bước self+batch (${p.steps.join(', ')}) chưa có verdict verifier gộp (batch-verify) — giao verifier gộp (brief H) trước cổng 3`);
   const stuckLines = stuck.length
     ? [`stuck: ${stuck.slice(0, 6).map((a) => `${a.task_id || a.agent_id}:${a.role} ${a.state === 'orphan' ? 'mồ côi' : 'kẹt'} ${a.idle_min}'`).join(', ')} → TaskStop rồi \`dieu-phoi reap --yes\``]
     : [];
-  return { code: 0, out: [core.formatSessionState(state, core.STATE_TEXT_CAP)].concat(deltaLines, orphans === null ? [] : [`orphan_procs: ${orphans}`], [liveLine(live)], stuckLines, batchLines).join('\n') };
+  return { code: 0, out: [core.formatSessionState(state, core.STATE_TEXT_CAP)].concat(deltaLines, orphans === null ? [] : [`orphan_procs: ${orphans}`], [liveLine(live)], stuckLines, batchLines, gcLines).join('\n') };
 }
 
 // ------------------------------------------------------------------ reap (core 0.7.3 s6)

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) {