@kienntpixon/dieu-phoi 0.7.1 → 0.7.3

package/lib/profile.cjs

@@ -11,6 +11,11 @@
 //                                 the proposal plus those lines (each after the line it followed, else at the end);
 //                               - lessons.md lines edited/deleted since base, or profile.json changed at all → stop,
 //                                 exit 2, write nothing (the user decides).
+//   profile scan [--dir <profile>]   regex scan for secrets / machine data (profile-scan.cjs); exit 2 on a hit.
+//   profile publish --to <repo>/skill/profile [--curated <file>] [--include-local] [--dry-run]
+//                               copy the installed curated profile into the repo, minus this machine's own lines, after a scan.
+//                               `apply` records what the retro approved in profile/.lessons.curated.md; a lessons.md line
+//                               that is in neither .lessons.published.md nor that record is machine-local and is left out.
 // `>>` appenders take no lock: the live file is re-read right before the renames and the merge redone if it moved
 // (up to 5 times). What is left is the sub-millisecond gap between that last read and the rename.
 
@@ -18,6 +23,7 @@ const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 const core = require('../hook.cjs');
+const { BULLET_RE, bulletsOf, normLine } = require('./profile-seed.cjs');
 
 const BASE_DIR = 'profile-base';
 const FILES = { lessons: 'lessons.md', profile: 'profile.json' };
@@ -31,7 +37,16 @@ const HELP = `Cách dùng: dieu-phoi profile <lệnh> [--skill-dir P] [--json]
   apply --base <thư mục> [--lessons <file đề xuất>] [--profile <file đề xuất>] [--dry-run]
                          áp retro đã duyệt, dưới khoá profile/profile.lock. File chưa đổi từ base → ghi đề xuất.
                          lessons.md chỉ có dòng THÊM MỚI (phiên khác >> bài học) → tự gộp các dòng đó vào đề xuất.
-                         lessons.md có dòng cũ bị sửa/xoá, hoặc profile.json đã đổi → dừng, exit 2, không ghi gì`;
+                         lessons.md có dòng cũ bị sửa/xoá, hoặc profile.json đã đổi → dừng, exit 2, không ghi gì
+                         (ghi thêm profile/.lessons.curated.md = các dòng bài học retro đã duyệt, cho profile publish)
+  scan [--dir <profile>]  quét lessons.md, profile.json, unity-lanes.md tìm đường dẫn tuyệt đối, IPv4, email, URL ký, tiền tố
+                         token, KEY/TOKEN/SECRET/PASSWORD=<giá trị>, chuỗi hex/base64 dài. In file:dòng:loại, KHÔNG in giá trị;
+                         exit 2 khi có chỗ nghi ngờ. Dương tính giả đã biết nằm trong ALLOW của lib/profile-scan.cjs (kèm lý do)
+  publish --to <repo>/skill/profile [--curated <file>[,<file>]] [--include-local] [--dry-run]
+                         chép profile đã cài (lessons.md, profile.json, unity-lanes.md) sang repo: bỏ dòng bài học riêng của máy
+                         (không có trong .lessons.published.md và không nằm trong .lessons.curated.md / --curated), chuẩn hoá LF,
+                         quét secret TRƯỚC khi ghi (có chỗ nghi ngờ → exit 2, không ghi gì), in tóm tắt khác biệt.
+                         Không commit, không push, không đụng Hub: người dùng đọc \`git diff -- skill/profile\` rồi quyết định`;
 
 const sha = (txt) => crypto.createHash('sha256').update(txt, 'utf8').digest('hex');
 const lf = (txt) => String(txt).replace(/^/, '').replace(/\r\n/g, '\n');
@@ -179,6 +194,7 @@ function cmdApply(opts) {
 `);
       if (todo.some((w) => readText(path.join(dir, w.f)) !== w.cur)) continue; // a `>>` landed while we merged: redo
       for (const w of todo) core.writeFileAtomic(path.join(dir, w.f), w.text);
+      if (props.lessons !== undefined) recordCurated(dir, props.lessons);
       written = true;
       break;
     }
@@ -193,11 +209,135 @@ function cmdApply(opts) {
   return { code: 0, out: `${dry ? '(dry-run — không ghi gì)\n' : ''}profile ${slash(dir)}:\n${lines.join('\n')}` };
 }
 
+// ---------------------------------------------------------------- scan / publish (0.7.2)
+
+const PUBLISHED = '.lessons.published.md'; // written by tools/lessons_sync.cjs update
+const CURATED = '.lessons.curated.md'; // written by profile apply: the bullets a retro approved
+const PUBLISH_FILES = ['lessons.md', 'profile.json', 'unity-lanes.md'];
+const LOCAL_MARK = /^\s*<!--\s*dòng riêng của máy/;
+
+/** apply → remember which lessons bullets the retro approved, so publish can tell them from machine-local `>>` lines. */
+function recordCurated(dir, proposalTxt) {
+  const file = path.join(dir, CURATED);
+  const old = readText(file);
+  const have = new Set(bulletsOf(old).map(normLine));
+  const add = bulletsOf(proposalTxt).filter((l) => !have.has(normLine(l)));
+  if (!add.length && old !== null) return;
+  const head = old === null ? '# dòng bài học retro đã duyệt (profile apply ghi; profile publish đọc) — đừng sửa tay\n' : old.replace(/\n*$/, '\n');
+  core.writeFileAtomic(file, `${head}${add.join('\n')}${add.length ? '\n' : ''}`);
+}
+
+function cmdScan(opts) {
+  const sc = require('./profile-scan.cjs');
+  const dir = typeof opts.dir === 'string' ? path.resolve(core.nativePath(opts.dir)) : profileDir(opts);
+  if (!fs.existsSync(dir)) return { code: 1, out: `không thấy thư mục ${slash(dir)}` };
+  const r = sc.scanProfile(dir);
+  const code = r.clean ? 0 : 2;
+  if (opts.json) return { code, out: JSON.stringify({ dir: slash(dir), files: r.files, clean: r.clean, hits: r.hits, skipped: r.skipped }, null, 2) };
+  return { code, out: sc.formatScan(r, dir) };
+}
+
+/** Multiset line diff: how many lines of `next` are new / gone compared with `prev` (order ignored). */
+function lineDelta(prev, next) {
+  const count = new Map();
+  for (const l of String(prev || '').split('\n')) count.set(l, (count.get(l) || 0) + 1);
+  let added = 0;
+  for (const l of String(next).split('\n')) {
+    const n = count.get(l) || 0;
+    if (n > 0) count.set(l, n - 1); else added++;
+  }
+  let removed = 0;
+  for (const n of count.values()) removed += n;
+  return { added, removed };
+}
+
+function dropLines(txt, drop) {
+  const out = [];
+  let after = false; // the previous line was dropped: do not leave two blank lines behind
+  for (const raw of txt.split('\n')) {
+    const key = BULLET_RE.test(raw) ? raw.trim() : null;
+    if (LOCAL_MARK.test(raw) || (key !== null && drop.has(key))) { after = true; continue; }
+    if (after && raw.trim() === '' && out.length && out[out.length - 1].trim() === '') continue;
+    after = false;
+    out.push(raw);
+  }
+  return out.join('\n');
+}
+
+function cmdPublish(opts) {
+  if (typeof opts.to !== 'string' || !opts.to.trim()) return { code: 1, out: 'profile publish cần --to <repo>/skill/profile (thư mục profile của repo).' };
+  const to = path.resolve(core.nativePath(opts.to));
+  if (!fs.existsSync(to) || !fs.statSync(to).isDirectory()) return { code: 1, out: `--to không phải thư mục: ${slash(to)}` };
+  const from = profileDir(opts);
+  if (path.resolve(from).toLowerCase() === to.toLowerCase()) return { code: 1, out: '--to trùng thư mục profile đã cài.' };
+  const sc = require('./profile-scan.cjs');
+  const dry = !!opts['dry-run'];
+
+  const installed = readText(path.join(from, 'lessons.md'));
+  if (installed === null) return { code: 1, out: `không thấy ${slash(path.join(from, 'lessons.md'))}` };
+  const published = readText(path.join(from, PUBLISHED));
+  const keys = new Set(bulletsOf(published === null ? installed : published).map(normLine));
+  const curatedFiles = [path.join(from, CURATED)];
+  if (typeof opts.curated === 'string') curatedFiles.push(...opts.curated.split(',').map((f) => path.resolve(core.nativePath(f.trim()))).filter(Boolean));
+  for (const f of curatedFiles) {
+    const t = readText(f);
+    if (t === null) { if (f !== curatedFiles[0]) return { code: 1, out: `không thấy file --curated ${slash(f)}` }; continue; }
+    for (const l of bulletsOf(t)) keys.add(normLine(l));
+  }
+  const local = [];
+  const seen = new Set();
+  for (const l of bulletsOf(installed)) {
+    const k = normLine(l);
+    if (keys.has(k) || seen.has(k)) continue;
+    seen.add(k);
+    local.push(l);
+  }
+  const drop = opts['include-local'] ? new Set() : new Set(local);
+
+  const texts = {};
+  texts['lessons.md'] = dropLines(installed, drop);
+  for (const f of PUBLISH_FILES.slice(1)) {
+    const t = readText(path.join(from, f));
+    if (t !== null) texts[f] = t;
+  }
+  const scan = sc.scanProfile(texts);
+  const files = Object.entries(texts).map(([f, t]) => {
+    const prev = readText(path.join(to, f));
+    return Object.assign({ file: f, same: prev === t, new: prev === null }, prev === t ? { added: 0, removed: 0 } : lineDelta(prev, t));
+  });
+  const res = {
+    from: slash(from), to: slash(to), dry_run: dry, published_record: published !== null,
+    local_lines: local.length, local_excluded: opts['include-local'] ? 0 : local.length,
+    local_preview: local.map((l) => `${l.replace(BULLET_RE, '').replace(/\s+/g, ' ').slice(0, 70)}…`),
+    scan: { clean: scan.clean, hits: scan.hits, skipped: scan.skipped }, files, written: false,
+  };
+  if (!scan.clean) {
+    res.stopped = 'scan';
+    if (opts.json) return { code: 2, out: JSON.stringify(res, null, 2) };
+    return { code: 2, out: `DỪNG — không ghi gì:\n${sc.formatScan(scan, from)}\nSửa file đã cài (hoặc thêm dương tính giả có lý do vào ALLOW) rồi publish lại.` };
+  }
+  if (!dry) {
+    for (const f of files.filter((x) => !x.same)) core.writeFileAtomic(path.join(to, f.file), texts[f.file]);
+    res.written = true;
+  }
+  if (opts.json) return { code: 0, out: JSON.stringify(res, null, 2) };
+  const L = [`${dry ? '(dry-run — không ghi gì)\n' : ''}profile publish ${slash(from)} → ${slash(to)}`];
+  for (const f of files) L.push(`  ${f.same ? '=' : (dry ? '~' : '✓')} ${f.file}${f.same ? ' (không đổi)' : ` (+${f.added} −${f.removed} dòng${f.new ? ', file mới' : ''})`}`);
+  if (!res.published_record) L.push(`  ! thiếu ${PUBLISHED}: không phân biệt được dòng riêng của máy — coi mọi dòng là đã tuyển`);
+  L.push(`  dòng riêng của máy: ${local.length}${opts['include-local'] ? ' (--include-local: vẫn chép)' : local.length ? ' — bỏ ra, không chép:' : ''}`);
+  if (!opts['include-local']) for (const p of res.local_preview) L.push(`    - ${p}`);
+  L.push(`  scan: ${scan.clean ? 'sạch' : 'CÓ'}${scan.skipped.length ? `, bỏ qua ${scan.skipped.length} dương tính giả (${scan.skipped.map((x) => `${x.file}:${x.line}:${x.kind}`).join(', ')})` : ''}`);
+  L.push('  Kế tiếp: đọc `git diff -- skill/profile` trong repo (tên khách hàng/người/dự án mật mà regex không bắt được), rồi mới commit.');
+  return { code: 0, out: L.join('\n') };
+}
+
 function cmdProfile(opts) {
   const sub = opts._.shift();
   if (!sub || opts.help || opts.h || sub === 'help') return { code: sub || opts.help || opts.h ? 0 : 1, out: HELP };
   if (sub === 'base') return cmdBase(opts);
   if (sub === 'apply') return cmdApply(opts);
+  if (sub === 'scan') return cmdScan(opts);
+  if (sub === 'publish') return cmdPublish(opts);
   return { code: 1, out: `Lệnh profile lạ: ${sub}\n\n${HELP}` };
 }
 

package/lib/prune.cjs

@@ -55,17 +55,24 @@ function human(n) {
   return `${n} B`;
 }
 
+// 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;
+
 /**
  * Files to keep in a run dir: retro-*.md + per task/role the highest-try result AND the newest-by-mtime result
  * (dp-out, legacy or .inline.md). A re-run can write a lower try number later (e.g. try1 after a blocked try5),
  * so the try number alone can pick a stale attempt. `mtimeOf(name)` is optional; without it only the highest try is kept.
  */
-function keepSet(names, mtimeOf) {
+function keepSet(names, mtimeOf, unmerged) {
   const keep = new Set();
   const best = new Map(); // task|role -> max try
   const parsed = [];
   for (const n of names) {
     if (/^retro-.*\.md$/.test(n)) { keep.add(n); continue; }
+    if (KEEP_RE.test(n)) { keep.add(n); continue; }
+    // a delta no store has applied yet is still work to merge; a merged one is only history
+    if (DELTA_RE.test(n)) { if (typeof unmerged !== 'function' || unmerged(n)) keep.add(n); continue; }
     const inline = /\.inline\.md$/.test(n); // hook fallback copy: only written when the agent wrote no dp-out
     let m = OUT_RE.exec(n);
     let task; let role; let tr;
@@ -113,7 +120,10 @@ function taskIdsOfDir(id, names, plansDir) {
 }
 
 /** Eligible run dirs: every event of its tasks ≤ cutoff and every dispatched task has a user verdict (or was discarded). */
-function planRuns(ctx, events, cutoffMs, protect) {
+function planRuns(ctx, events, cutoffMs, protect, popts) {
+  const po = popts || {};
+  const nowMs = typeof po.now === 'number' ? po.now : Date.now();
+  const cls = core.deltaClassifier(events, ctx.paths.plans);
   const runs = core.runsDir();
   const byTask = new Map();
   for (const e of events) {
@@ -124,9 +134,17 @@ function planRuns(ctx, events, cutoffMs, protect) {
   const out = { prune: [], skipped: [] };
   let dirs = [];
   try { dirs = fs.readdirSync(runs, { withFileTypes: true }); } catch (_) { return out; }
+  let applied = null; // sha256 of every delta a knowledge store has applied (read once, lazily)
+  const appliedSet = () => {
+    if (!applied) {
+      applied = new Set();
+      try { for (const st of core.storeCatalog()) for (const h of st.applied) applied.add(h); } catch (_) { /* none known: keep every delta */ }
+    }
+    return applied;
+  };
   for (const d of dirs) {
     const id = d.name;
-    if (!d.isDirectory() || !RUN_ID_RE.test(id)) continue;
+    if (!d.isDirectory() || !RUN_ID_RE.test(id) || id.startsWith('_')) continue; // _archive is ours, not a run
     const dir = path.join(runs, id);
     if (!inside(runs, dir)) continue;
     const names = fs.readdirSync(dir);
@@ -155,17 +173,34 @@ function planRuns(ctx, events, cutoffMs, protect) {
       }
     }
     if (reason) { out.skipped.push({ id, reason }); continue; }
-    const keep = keepSet(names, (n) => { try { return fs.lstatSync(path.join(dir, n)).mtimeMs; } catch (_) { return 0; } });
+    const unmerged = (n) => {
+      let text = null;
+      try { text = fs.readFileSync(path.join(dir, n), 'utf8'); } catch (_) { return true; }
+      return !appliedSet().has(core.deltaHash(text));
+    };
+    const keep = keepSet(names, (n) => { try { return fs.lstatSync(path.join(dir, n)).mtimeMs; } catch (_) { return 0; } }, unmerged);
+    // retro 11-05 K1: an unmerged delta older than 30 d that the user never judged is history, not work: move it to
+    // runs/_archive/deltas/<run>/ (never deleted) so it stops being kept here and warned about.
+    const archive = [];
+    for (const n of names) {
+      if (!DELTA_RE.test(n) || !keep.has(n) || !unmerged(n)) continue;
+      let m = 0;
+      try { m = fs.lstatSync(path.join(dir, n)).mtimeMs; } catch (_) { continue; }
+      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);
+    const keepDeltas = names.filter((n) => DELTA_RE.test(n) && keep.has(n)).length;
     const del = [];
     let delBytes = 0; let keepBytes = 0;
     for (const n of names) {
       const p = path.join(dir, n);
+      if (archive.includes(n)) continue;
       if (keep.has(n) || (protect && path.resolve(p) === protect)) { keepBytes += sizeOf(p); continue; }
       const b = sizeOf(p);
       del.push({ name: n, bytes: b });
       delBytes += b;
     }
-    out.prune.push({ id, dir, tasks, keep: Array.from(keep).sort(), del, delete_bytes: delBytes, keep_bytes: keepBytes });
+    out.prune.push({ id, dir, tasks, keep: Array.from(keep).sort(), keep_deltas: keepDeltas, archive, del, delete_bytes: delBytes, keep_bytes: keepBytes });
   }
   return out;
 }
@@ -255,7 +290,7 @@ function cmdPrune(opts) {
   const cut = cutoffOf(retro);
   const { lines } = fs.existsSync(ctx.paths.events) ? eventLines(ctx) : { lines: [] };
   const allEvents = core.readEvents(ctx);
-  const rp = planRuns(ctx, allEvents, cut.ms, retro);
+  const rp = planRuns(ctx, allEvents, cut.ms, retro, { now: typeof opts.now === 'number' ? opts.now : undefined });
   const prunedTasks = new Set();
   for (const r of rp.prune) for (const t of r.tasks) prunedTasks.add(t);
   const plans = badPlans(ctx);
@@ -273,7 +308,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_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, 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 })),
@@ -281,10 +316,13 @@ function cmdPrune(opts) {
   };
   report.totals = {
     run_dirs: rp.prune.length,
+    archive_deltas: rp.prune.reduce((n, r) => n + r.archive.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),
   };
 
+  let removedLines = 0; // lines actually dropped from events.jsonl under the lock (what the message reports)
+  let freshCount = 0; // of those, lines newly written into the archive (the rest were there from an earlier run)
   if (yes) {
     // 0. a session other than this one touched the log recently => refuse (a live hook could be mid-append)
     const busy = opts.force === true ? null : otherSessionActive(ctx, opts, allEvents);
@@ -299,6 +337,7 @@ function cmdPrune(opts) {
     // 1. events → archive (archive first + verified, then rewrite events.jsonl via temp + rename)
     if (moving.length) {
       const fresh = moving.filter((l) => !archived.has(l.text));
+      freshCount = fresh.length;
       const lock = core.acquireLock(ctx.paths.lock);
       if (!lock) return { code: 1, out: 'prune: sync đang giữ khoá — thử lại sau' };
       try {
@@ -315,6 +354,7 @@ function cmdPrune(opts) {
           for (const l of core.eventLinesFrom(buf, 0)) {
             parts.push(buf.subarray(pos, l.start)); // blank lines between
             if (drop.get(l.start) === l.text) {
+              removedLines++;
               if (l.end <= off) removedBeforeOffset += l.end - l.start;
             } else parts.push(buf.subarray(l.start, l.end));
             pos = l.end;
@@ -331,6 +371,20 @@ function cmdPrune(opts) {
         try { fs.unlinkSync(ctx.paths.lock); } catch (_) { /* gone */ }
       }
     }
+    report.events.moved = removedLines;
+    report.events.archived_new = freshCount;
+    // 2a. unmerged deltas older than 30 d without a user verdict -> runs/_archive/deltas/<run>/ (moved, not deleted)
+    for (const r of rp.prune) {
+      for (const n of r.archive) {
+        const from = path.join(r.dir, n);
+        const toDir = path.join(runs, '_archive', 'deltas', r.id);
+        if (!inside(r.dir, from) || !inside(runs, toDir)) continue;
+        fs.mkdirSync(toDir, { recursive: true });
+        let to = path.join(toDir, n);
+        if (fs.existsSync(to)) to = path.join(toDir, `${Date.now()}-${n}`);
+        core.renameWithRetry(from, to);
+      }
+    }
     // 2. run dirs
     for (const r of rp.prune) {
       for (const f of r.del) {
@@ -348,9 +402,12 @@ 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)})`);
+  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/` : ''}`);
   L.push(`Plan hỏng: ${plans.length} (${human(plans.reduce((n, p) => n + p.bytes, 0))})${plans.length ? ` — ${plans.map((p) => p.name).join(', ')}` : ''}`);
-  L.push(`events.jsonl: ${moving.length}/${lines.length} dòng → archive/events-${archiveToday()}.jsonl.gz (${human(evBytes)})${heldBack ? `; ${heldBack} dòng chưa đẩy lên sink nên giữ lại` : ''}; không xoá dòng nào`);
+  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)})`
+    : `sẽ chuyển ${moving.length}/${lines.length} dòng vào archive/events-${archiveToday()}.jsonl.gz và xoá khỏi events.jsonl (${human(evBytes)})`;
+  L.push(`events.jsonl: ${evTxt}${heldBack ? `; ${heldBack} dòng chưa đẩy lên sink nên giữ lại` : ''}`);
   L.push(`Tổng xoá khỏi đĩa: ${report.totals.files} mục run dir + ${plans.length} plan = ${human(report.totals.bytes)}`);
   return { code: 0, out: L.join('\n') };
 }

package/lib/setup.cjs

@@ -4,10 +4,16 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const core = require('../hook.cjs');
+const { seedProfile } = require('./profile-seed.cjs');
 
 const PKG_ROOT = path.join(__dirname, '..');
 const MARKER = 'dieu-phoi/bin/hook.cjs';
 
+/** <pkg>/profile (mang lessons đã tuyển); DIEU_PHOI_TEST_PROFILE_SRC chỉ để test trỏ tới thư mục khác. */
+function profileSrcDir() {
+  return process.env.DIEU_PHOI_TEST_PROFILE_SRC || path.join(PKG_ROOT, 'profile');
+}
+
 function tsStamp(d) {
   const x = d || new Date();
   const p = (n) => String(n).padStart(2, '0');
@@ -61,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;
@@ -75,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) {
@@ -92,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 }] });
@@ -276,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).
@@ -289,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 };
   });
@@ -322,17 +351,36 @@ function removeAgents(claudeDir) {
  * Install: copy hook + pricing, register hooks, write config.
  * opts: { claudeDir, dept, sinkUrl, sinkToken, skillDir }
  */
+/** Skill dir của lần cài này: --skill-dir, rồi skill_dir đã nhớ trong config (còn hợp lệ), rồi tìm dưới claudeDir. */
+function skillDirOfInstall(opts, claudeDir, home) {
+  let skillDir = opts.skillDir ? path.resolve(opts.skillDir) : null;
+  if (!skillDir) {
+    const cfg = core.loadConfig(home);
+    if (cfg.skill_dir && fs.existsSync(path.join(cfg.skill_dir, 'profile', 'profile.json'))) skillDir = cfg.skill_dir;
+  }
+  return skillDir || findSkillDir(claudeDir);
+}
+
 function setup(opts) {
   const claudeDir = path.resolve(opts.claudeDir);
   const home = path.join(claudeDir, 'dieu-phoi');
   const paths = core.pathsFor(home);
+  if (opts.dryRun) {
+    // --dry-run: chỉ báo phần profile sẽ gộp; không ghi hook, settings, agent hay config
+    const sd = skillDirOfInstall(opts, claudeDir, home);
+    return {
+      dry_run: true, home, settings: path.join(claudeDir, 'settings.json'), skill_dir: sd ? toSlash(sd) : null,
+      profile: sd ? seedProfile(profileSrcDir(), path.join(sd, 'profile'), { dryRun: true }) : { skipped: 'no-skill-dir' },
+    };
+  }
   fs.mkdirSync(paths.bin, { recursive: true });
   fs.mkdirSync(paths.data, { recursive: true });
 
   // 1. hook + pricing (LF, self-contained)
-  for (const f of ['hook.cjs', 'pricing.json']) {
+  // s16: lib/procs.cjs rides along as bin/procs.cjs (the hook requires ./procs.cjs for the leftover-process scan)
+  for (const [f, dest] of [['hook.cjs', 'hook.cjs'], ['pricing.json', 'pricing.json'], [path.join('lib', 'procs.cjs'), 'procs.cjs']]) {
     const src = fs.readFileSync(path.join(PKG_ROOT, f), 'utf8').replace(/\r\n/g, '\n');
-    core.writeFileAtomic(path.join(paths.bin, f), src);
+    core.writeFileAtomic(path.join(paths.bin, dest), src);
   }
 
   // 2. config
@@ -340,15 +388,13 @@ function setup(opts) {
   if (opts.dept !== undefined) cfg.dept = String(opts.dept);
   if (opts.sinkUrl !== undefined) cfg.sink_url = String(opts.sinkUrl);
   if (opts.sinkToken !== undefined) cfg.sink_token = String(opts.sinkToken);
-  let skillDir = opts.skillDir ? path.resolve(opts.skillDir) : null;
-  if (!skillDir && cfg.skill_dir && fs.existsSync(path.join(cfg.skill_dir, 'profile', 'profile.json'))) {
-    skillDir = cfg.skill_dir;
-  }
-  if (!skillDir) skillDir = findSkillDir(claudeDir);
+  const skillDir = skillDirOfInstall(opts, claudeDir, home);
   if (skillDir) {
     cfg.skill_dir = toSlash(skillDir);
     cfg.skill_version = skillVersionOf(skillDir) || cfg.skill_version || null;
   }
+  // 2b. lessons đã tuyển của gói → profile đã cài (chỉ thêm dòng mới; dòng riêng của máy giữ nguyên)
+  const profile = skillDir ? seedProfile(profileSrcDir(), path.join(skillDir, 'profile'), {}) : { skipped: 'no-skill-dir' };
   if (!cfg.user_hash) cfg.user_hash = core.computeUserHash();
   cfg.core_version = core.CORE_VERSION;
   if (!cfg.installed_at) cfg.installed_at = core.nowIso();
@@ -391,6 +437,7 @@ function setup(opts) {
     permissions: perms,
     legacy_permissions_removed: legacyRemoved,
     config: cfg,
+    profile,
   };
 }
 
@@ -421,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;
@@ -431,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;