@kienntpixon/dieu-phoi 0.7.0 → 0.7.2

package/lib/knowledge.cjs

@@ -14,6 +14,7 @@
 //
 // Delta (written by agents into a run dir as knowledge-delta*.md, merged at gate 3):
 //   repo: <path of the repo/worktree the delta was checked against>   (header, before the first `## `)
+//         or a short name (`pff-tailor`) that matches exactly one known store (its name / dir name / a recorded root)
 //   head: <sha>                                                         (optional; else HEAD read from repo:)
 //   ## +<id>        new section          ## <id>     replace an existing one
 //   title: / tags: a, b / paths: glob, glob / base: <sha>#<rev>   (meta lines right under the heading)
@@ -27,7 +28,6 @@
 const fs = require('fs');
 const path = require('path');
 const cp = require('child_process');
-const crypto = require('crypto');
 const core = require('../hook.cjs');
 const { repoOf } = require('./args.cjs');
 
@@ -55,7 +55,8 @@ const KNOWLEDGE_HELP = `Cách dùng: dieu-phoi knowledge <lệnh> [--repo <đư
   merge --run <id|thư mục run> [--task <id>[,<id>] [--untagged]] [--dry-run] [--json]
                          gộp mọi knowledge-delta*.md của run (--task: chỉ knowledge-delta-<task_id>[-r<n>].md của các
                          task đó, --untagged: thêm file không mang task_id; verdict accept tự gọi bước này) vào kho của repo ghi ở header "repo:" (không có thì
-                         --repo/cwd): khoá knowledge.lock, ghi tmp+rename, bản cũ vào history/, sha = HEAD của repo đó.
+                         --repo/cwd; "repo:" là tên ngắn như pff-tailor thì khớp kho đã biết nếu duy nhất — HEAD lấy từ repo đã ghi
+                         nhớ (meta.json roots), --repo hoặc dòng head:): khoá knowledge.lock, ghi tmp+rename, bản cũ vào history/, sha = HEAD của 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"
@@ -573,10 +574,9 @@ function runDirOf(v) {
   return isDir(p) ? { dir: p } : { error: `Không thấy run ${s} (${slash(p)}).` };
 }
 
-/** Task id a delta file belongs to: knowledge-delta-<task_id>[-r<n>].md (8 chars a-z0-9); null = untagged. */
+/** Task id a delta file belongs to: knowledge-delta-<task_id>[-r<n>|-h<n>].md (8 chars a-z0-9; -h<n> = handoff); null = untagged. */
 function deltaTaskOf(file) {
-  const m = /^knowledge-delta-([a-z0-9]{8})(?:-r\d+)?\.md$/i.exec(path.basename(file));
-  return m ? m[1].toLowerCase() : null;
+  return core.deltaTagOf(file);
 }
 
 /**
@@ -584,7 +584,7 @@ function deltaTaskOf(file) {
  * tagged with one of them (plus untagged ones when untagged is true).
  */
 function deltaFiles(runDir, filter) {
-  const num = (f) => { const m = /-r(\d+)\.md$/i.exec(f); return m ? Number(m[1]) : 0; };
+  const num = (f) => { const m = /-[rh](\d+)\.md$/i.exec(f); return m ? Number(m[1]) : 0; };
   return fs.readdirSync(runDir)
     .filter((f) => /^knowledge-delta.*\.md$/i.test(f))
     .filter((f) => {
@@ -609,8 +609,25 @@ function sameContent(cur, body, next) {
 const APPLIED_MAX = 300;
 
 /** sha256 of the delta text, BOM and CRLF normalised so a CRLF checkout hashes like the LF original. */
-function deltaHash(text) {
-  return crypto.createHash('sha256').update(String(text).replace(/^/, '').replace(/\r\n?/g, '\n')).digest('hex');
+const deltaHash = core.deltaHash; // shared with the unmerged-delta scan in hook.cjs
+
+/** Main checkout of the repo `info` describes (a linked worktree is deleted later; the checkout stays). */
+function mainRootOf(info) {
+  const common = info && info.common_dir ? String(info.common_dir) : '';
+  if (common && path.basename(common) === '.git') return slash(path.dirname(common));
+  return info && info.root ? slash(info.root) : null;
+}
+
+/** Remember where a store's repo lives (meta.json `roots`, newest first, <= 5) so a bare `repo: <name>` can find HEAD. */
+function noteRoot(dir, info) {
+  const root = mainRootOf(info);
+  if (!root || !isDir(dir)) return;
+  const file = path.join(dir, 'meta.json');
+  const meta = core.readJsonFile(file, {}) || {};
+  const roots = Array.isArray(meta.roots) ? meta.roots : [];
+  if (roots[0] === root) return;
+  const next = [root].concat(roots.filter((r) => r !== root)).slice(0, 5);
+  core.writeFileAtomic(file, `${JSON.stringify(Object.assign({}, meta, { roots: next }), null, 2)}\n`);
 }
 
 function appliedOf(dir) {
@@ -741,9 +758,11 @@ function applyDelta(delta, info, sha, dry, src) {
     core.writeFileAtomic(path.join(dir, 'index.json'), `${JSON.stringify(idx, null, 2)}\n`);
     ensureMeta(dir, info);
   }
-  if (changed && !dry && src && !results.some((r) => r.op === 'conflict' || r.op === 'reject')) {
+  if (!dry && src && isDir(dir) && !results.some((r) => r.op === 'conflict' || r.op === 'reject')) {
+    // also when every section was already merged ("same"): the file counts as handled, not as an unmerged delta
     recordApplied(dir, info, { sha256: src.hash, file: src.file, run: src.run, at: now.toISOString() });
   }
+  if (!dry && changed && info.common_dir) noteRoot(dir, info);
   return { results };
 }
 
@@ -766,6 +785,45 @@ function describe(r) {
   return `${OP_MARK[r.op] || '?'} ${r.id} BỊ TỪ CHỐI: ${r.why}`;
 }
 
+/**
+ * Where a delta goes: { target, info } — target = repo dir to read HEAD from (null when only the store is known),
+ * info = project identity (resolveProject, or the bare store entry for a short `repo:` name). Order: a short name that
+ * matches exactly one known store, then the path, then --repo as the fallback for a repo that no longer exists.
+ */
+function targetOf(delta, opts, rep) {
+  const err = (error) => ({ error });
+  if (!delta.repo) return finish(repoOf(opts));
+  if (core.isBareRepoName(delta.repo)) {
+    const hit = core.storeByName(delta.repo);
+    if (hit.matches.length > 1) {
+      return err(`repo: ${delta.repo} khớp ${hit.matches.length} kho (${hit.matches.map((m) => m.dir_name).join(', ')}) — ghi đường dẫn đầy đủ hoặc chạy với --repo`);
+    }
+    if (hit.store) {
+      const st = hit.store;
+      rep.note = `repo: ${delta.repo} → kho ${st.dir_name}`;
+      const cands = st.roots.map((r) => core.nativePath(r)).concat(opts.repo !== undefined ? [repoOf(opts)] : []);
+      for (const c of cands) {
+        if (!isDir(c)) continue;
+        const pi = core.resolveProject(c);
+        if (pi && pi.dir === st.dir) return { target: path.resolve(c), info: pi };
+      }
+      return { target: null, info: { dir: st.dir, dir_name: st.dir_name, key: st.key, name: st.name } };
+    }
+  }
+  if (delta.repo) {
+    const p = path.resolve(core.nativePath(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>`);
+  }
+  return err('không xác định được repo');
+  function finish(target) {
+    const info = core.resolveProject(target);
+    return info ? { target, info } : err(`không phải repo git: ${slash(target)}`);
+  }
+}
+
 function cmdMerge(opts) {
   const rd = runDirOf(opts.run);
   if (rd.error) return { code: 1, out: rd.error };
@@ -786,23 +844,20 @@ function cmdMerge(opts) {
       src = { hash: deltaHash(text), file: path.basename(file), run: path.basename(rd.dir) };
     } catch (e) { rep.error = `không đọc được: ${e.message}`; totals.error++; continue; }
     if (!delta.sections.length) { rep.error = 'không có mục "## <id>" nào'; totals.error++; continue; }
-    let target = null;
-    if (delta.repo) {
-      const p = path.resolve(core.nativePath(delta.repo));
-      if (isDir(p)) target = p;
-      else if (opts.repo !== undefined) { target = repoOf(opts); rep.note = `repo: ${delta.repo} không còn — dùng --repo`; } else {
-        rep.error = `repo: ${delta.repo} không tồn tại (worktree đã xoá?) — chạy lại với --repo <đường dẫn repo>`; totals.error++; continue;
-      }
-    } else target = repoOf(opts);
-    const info = core.resolveProject(target);
-    if (!info) { rep.error = `không phải repo git: ${slash(target)}`; totals.error++; continue; }
+    const t = targetOf(delta, opts, rep);
+    if (t.error) { rep.error = t.error; totals.error++; continue; }
+    const { target, info } = t;
     let sha = null;
     if (delta.head) {
       if (!/^[0-9a-f]{7,64}$/i.test(delta.head)) { rep.error = `head: không phải sha: ${delta.head}`; totals.error++; continue; }
       sha = delta.head.toLowerCase();
-    } else sha = headShaOf(target);
-    if (!sha) { rep.error = `không xác định được HEAD của ${slash(target)} (repo chưa có commit?) — thêm dòng "head: <sha>" vào delta`; totals.error++; continue; }
-    Object.assign(rep, { repo: slash(target), store: info.dir, key: info.key, sha });
+    } else if (target) sha = headShaOf(target);
+    if (!sha) {
+      rep.error = target ? `không xác định được HEAD của ${slash(target)} (repo chưa có commit?) — thêm dòng "head: <sha>" vào delta`
+        : `repo: ${delta.repo} khớp kho ${info.dir_name} nhưng chưa biết repo nằm đâu để đọc HEAD — thêm dòng "head: <sha>" vào delta hoặc chạy với --repo <đường dẫn repo>`;
+      totals.error++; continue;
+    }
+    Object.assign(rep, { repo: target ? slash(target) : null, store: info.dir, key: info.key, sha });
     let out;
     if (dry) out = applyDelta(delta, info, sha, true, src);
     else {

package/lib/procs.cjs

@@ -0,0 +1,223 @@
+'use strict';
+// s16 (core 0.7.2): read-only look at the process table. Everything here that decides something is a pure function over a
+// plain list [{pid, ppid, name, created (epoch ms | null), ws (bytes | null), cmd}], so tests feed fixture lists and never
+// touch the system. Only listProcesses() and killTree() reach the OS; listProcesses never throws (null on any failure),
+// killTree is called by the hook only when config kill_leftovers is true.
+
+const cp = require('child_process');
+
+const DEFAULT_TIMEOUT_MS = 4000;
+const ORPHAN_NAMES = ['claude.exe', 'codebase-memory-mcp.exe', 'node.exe', 'bash.exe'];
+// never reported as a leftover of one agent: the Claude Code processes themselves and the code-graph server (shared)
+const LEFTOVER_SKIP_NAMES = ['claude.exe', 'claude', 'codebase-memory-mcp.exe', 'codebase-memory-mcp', 'conhost.exe'];
+
+const PS_WIN = [
+  'Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,Name,',
+  "@{n='Created';e={if($_.CreationDate){[int64]($_.CreationDate.ToUniversalTime()-[datetime]'1970-01-01').TotalMilliseconds}else{$null}}},",
+  'WorkingSetSize,',
+  "@{n='Cmd';e={if($_.CommandLine){$_.CommandLine.Substring(0,[Math]::Min(200,$_.CommandLine.Length))}else{$null}}}",
+  ' | ConvertTo-Json -Compress',
+].join('');
+
+const lower = (s) => String(s || '').toLowerCase();
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : (typeof v === 'string' && /^\d+$/.test(v) ? Number(v) : null));
+
+/** Windows JSON from PS_WIN (also a single object when only one process) -> list, or null when it is not that shape. */
+function parseWindowsJson(text) {
+  let j;
+  try { j = JSON.parse(String(text).replace(/^/, '')); } catch (_) { return null; }
+  const arr = Array.isArray(j) ? j : (j && typeof j === 'object' ? [j] : null);
+  if (!arr) return null;
+  const out = [];
+  for (const r of arr) {
+    if (!r || typeof r !== 'object') continue;
+    const pid = num(r.ProcessId);
+    if (pid === null) continue;
+    out.push({
+      pid,
+      ppid: num(r.ParentProcessId) === null ? 0 : num(r.ParentProcessId),
+      name: typeof r.Name === 'string' ? r.Name : '',
+      created: num(r.Created),
+      ws: num(r.WorkingSetSize),
+      cmd: typeof r.Cmd === 'string' ? r.Cmd : null,
+    });
+  }
+  return out.length ? out : null;
+}
+
+const MONTHS = { Jan: 0, Feb: 1, Mar: 2, Apr: 3, May: 4, Jun: 5, Jul: 6, Aug: 7, Sep: 8, Oct: 9, Nov: 10, Dec: 11 };
+
+/** `ps -eo pid,ppid,lstart,comm,args` (lstart = "Wed Nov  5 21:06:01 2026", local time) -> list, or null. */
+function parsePs(text) {
+  const out = [];
+  for (const line of String(text).split(/\r?\n/)) {
+    const m = /^\s*(\d+)\s+(\d+)\s+\w{3}\s+(\w{3})\s+(\d{1,2})\s+(\d{2}):(\d{2}):(\d{2})\s+(\d{4})\s+(\S+)\s*(.*)$/.exec(line);
+    if (!m) continue;
+    const t = new Date(Number(m[8]), MONTHS[m[3]], Number(m[4]), Number(m[5]), Number(m[6]), Number(m[7])).getTime();
+    out.push({ pid: Number(m[1]), ppid: Number(m[2]), name: m[9].replace(/^.*\//, ''), created: Number.isFinite(t) ? t : null, ws: null, cmd: m[10] ? m[10].slice(0, 200) : null });
+  }
+  return out.length ? out : null;
+}
+
+/**
+ * Process list of this machine, or null (any error, timeout, empty or unreadable output). Never throws.
+ * `exec(file, args, {timeout})` -> stdout string is injectable for tests.
+ */
+function listProcesses(opts) {
+  const o = opts || {};
+  const timeout = typeof o.timeoutMs === 'number' && o.timeoutMs > 0 ? o.timeoutMs : DEFAULT_TIMEOUT_MS;
+  const platform = o.platform || process.platform;
+  const exec = typeof o.exec === 'function' ? o.exec : defaultExec;
+  if (process.env.DIEU_PHOI_NO_PROCS === '1' && typeof o.exec !== 'function') return null; // tests: never look at the real machine
+  try {
+    if (platform === 'win32') {
+      const out = exec('powershell', ['-NoProfile', '-NonInteractive', '-Command', PS_WIN], { timeout });
+      return typeof out === 'string' ? parseWindowsJson(out) : null;
+    }
+    const out = exec('ps', ['-eo', 'pid,ppid,lstart,comm,args'], { timeout });
+    return typeof out === 'string' ? parsePs(out) : null;
+  } catch (_) {
+    return null;
+  }
+}
+
+function defaultExec(file, args, o) {
+  const r = cp.spawnSync(file, args, { encoding: 'utf8', timeout: o.timeout, windowsHide: true, maxBuffer: 32 * 1024 * 1024 });
+  if (r.error || r.status !== 0 || r.signal) return null;
+  return r.stdout || '';
+}
+
+function byPid(list) {
+  const m = new Map();
+  for (const p of list || []) m.set(p.pid, p);
+  return m;
+}
+
+/** All descendants of rootPid (children, grandchildren, ...; not rootPid itself). Cycle-safe (pid reuse). */
+function descendants(list, rootPid) {
+  const kids = new Map();
+  for (const p of list || []) {
+    if (p.pid === p.ppid) continue;
+    if (!kids.has(p.ppid)) kids.set(p.ppid, []);
+    kids.get(p.ppid).push(p);
+  }
+  const out = [];
+  const seen = new Set([rootPid]);
+  const queue = [rootPid];
+  while (queue.length) {
+    const cur = queue.shift();
+    for (const c of kids.get(cur) || []) {
+      if (seen.has(c.pid)) continue;
+      seen.add(c.pid);
+      out.push(c);
+      queue.push(c.pid);
+    }
+  }
+  return out;
+}
+
+/** Ancestors of pid, nearest first (stops at a missing parent, a cycle or 64 hops). */
+function ancestors(list, pid) {
+  const idx = byPid(list);
+  const out = [];
+  const seen = new Set([pid]);
+  let cur = idx.get(pid);
+  for (let i = 0; cur && i < 64; i++) {
+    const par = idx.get(cur.ppid);
+    if (!par || seen.has(par.pid)) break;
+    seen.add(par.pid);
+    out.push(par);
+    cur = par;
+  }
+  return out;
+}
+
+/** Nearest ancestor of pid named claude(.exe), or null. */
+function claudeAncestor(list, pid) {
+  return ancestors(list, pid).find((p) => /^claude(\.exe)?$/.test(lower(p.name))) || null;
+}
+
+/** A parent that is gone, or whose pid was reused by a process created after the child. */
+function isOrphan(p, idx) {
+  if (!p.ppid) return false; // pid 0: the system's own roots
+  const par = idx.get(p.ppid);
+  if (!par) return true;
+  return Boolean(par.created && p.created && par.created > p.created);
+}
+
+/**
+ * Processes whose parent is no longer in the list. `names` (case-insensitive; default claude.exe, codebase-memory-mcp.exe,
+ * node.exe, bash.exe), `minAgeMs` + `now` to keep only old ones, `skip(p)` to drop known-legitimate ones.
+ */
+function orphans(list, o) {
+  const opt = o || {};
+  const names = new Set((opt.names || ORPHAN_NAMES).map(lower));
+  const now = typeof opt.now === 'number' ? opt.now : Date.now();
+  const idx = byPid(list);
+  const out = [];
+  for (const p of list || []) {
+    if (!names.has(lower(p.name))) continue;
+    if (!isOrphan(p, idx)) continue;
+    if (opt.minAgeMs && !(p.created && now - p.created >= opt.minAgeMs)) continue;
+    if (typeof opt.skip === 'function' && opt.skip(p)) continue;
+    out.push(p);
+  }
+  return out;
+}
+
+/** The code-graph daemon is meant to outlive any session (shared by all of them): never an orphan to clean. */
+function isCbmDaemon(p) {
+  return /codebase-memory-mcp/i.test(p.name) && /daemon/i.test(p.cmd || '');
+}
+
+/**
+ * Orphaned Claude Code / code-graph processes older than minAgeMs (doctor and state): [{pid, name, age_h, ws_mb}] oldest first.
+ */
+function staleOrphans(list, o) {
+  const opt = o || {};
+  const now = typeof opt.now === 'number' ? opt.now : Date.now();
+  return orphans(list, { names: ['claude.exe', 'claude', 'codebase-memory-mcp.exe', 'codebase-memory-mcp'], minAgeMs: opt.minAgeMs, now, skip: isCbmDaemon })
+    .sort((a, b) => (a.created || 0) - (b.created || 0))
+    .map((p) => ({ pid: p.pid, name: p.name, age_h: Math.round(((now - (p.created || now)) / 3600000) * 10) / 10, ws_mb: p.ws ? Math.round(p.ws / 1048576) : null }));
+}
+
+/**
+ * Processes an agent left behind: descendants of the Claude Code process (rootPid) created at or after startMs, still in the
+ * list, not on the hook's own chain (selfPid and its ancestors), not claude/code-graph/conhost. Pure. Returns the list items;
+ * `roots` = those whose parent is not itself a leftover (what a kill must target; taskkill /T takes their children).
+ */
+function leftoverProcesses(list, o) {
+  const opt = o || {};
+  if (!Array.isArray(list) || !opt.rootPid || !opt.startMs) return { all: [], roots: [] };
+  const own = new Set([opt.selfPid, ...ancestors(list, opt.selfPid).map((p) => p.pid)].filter(Boolean));
+  const skip = new Set((opt.skipNames || LEFTOVER_SKIP_NAMES).map(lower));
+  const all = descendants(list, opt.rootPid).filter((p) => !own.has(p.pid) && p.created && p.created >= opt.startMs && !skip.has(lower(p.name)));
+  const ids = new Set(all.map((p) => p.pid));
+  return { all, roots: all.filter((p) => !ids.has(p.ppid)) };
+}
+
+/** Kill process trees. Windows `taskkill /PID n /T /F`, else SIGTERM. `deadline` (epoch ms) stops early. Returns the pids stopped; never throws. */
+function killTree(pids, o) {
+  const opt = o || {};
+  const done = [];
+  for (const pid of pids || []) {
+    const left = opt.deadline ? opt.deadline - Date.now() : 3000;
+    if (left <= 0) break; // out of time budget: the rest stay reported, not killed
+    try {
+      if ((opt.platform || process.platform) === 'win32') {
+        const r = cp.spawnSync('taskkill', ['/PID', String(pid), '/T', '/F'], { timeout: Math.min(3000, left), windowsHide: true });
+        if (!r.error && r.status === 0) done.push(pid);
+      } else {
+        process.kill(pid, 'SIGTERM');
+        done.push(pid);
+      }
+    } catch (_) { /* gone already or not ours */ }
+  }
+  return done;
+}
+
+module.exports = {
+  PS_WIN, ORPHAN_NAMES, LEFTOVER_SKIP_NAMES,
+  parseWindowsJson, parsePs, listProcesses,
+  descendants, ancestors, claudeAncestor, orphans, staleOrphans, isCbmDaemon, leftoverProcesses, killTree,
+};

package/lib/profile-scan.cjs

@@ -0,0 +1,85 @@
+'use strict';
+// `dieu-phoi profile scan` (core 0.7.2): look for secrets / machine-specific data in the profile files before they are
+// published (Skill Hub zip, repo). Regex-only: it cannot see customer, person or secret-project NAMES - the user still
+// reads the lessons diff (see profile publish). It never prints a matched value, only file:line:kind.
+
+const fs = require('fs');
+const path = require('path');
+
+const SCAN_FILES = ['lessons.md', 'profile.json', 'unity-lanes.md'];
+
+const PLACEHOLDER = /^(?:<[^>]*>?|\$\{?\w+\}?|%\w+%|\*+|\.{2,}|…|x{3,}|["'`]?[.…]*["'`]?|["'`]?<.*)$/i;
+
+// kind → [regex, optional filter(matchText, line) → boolean]. Every regex needs the g flag.
+const RULES = [
+  ['abs-path', /(?<![A-Za-z0-9])[A-Za-z]:[\\/](?![\\/])[^\s`'")\]]*|(?<![\w.])\/(?:Users|home)\/[^\s/`'")]+/g],
+  ['ipv4', /(?<![\d.])(?:\d{1,3}\.){3}\d{1,3}(?![\d.]*\d)/g, (m) => {
+    const o = m.split('.').map(Number);
+    if (o.some((n) => n > 255)) return false;
+    return !(m === '127.0.0.1' || m === '0.0.0.0'); // loopback / any-address: not machine data
+  }],
+  ['email', /[A-Za-z0-9._%+-]+@[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)+/g],
+  ['signed-url', /https?:\/\/[^\s)>"'`]*[?&](?:sig|signature|token|access_token|key|X-Amz-[A-Za-z-]+|X-Goog-[A-Za-z-]+)=[^\s)>"'`]*/gi],
+  ['token-prefix', /\b(?:sk-[A-Za-z0-9_-]{8,}|ghp_[A-Za-z0-9]{8,}|gho_[A-Za-z0-9]{8,}|glpat-[A-Za-z0-9_-]{8,}|npm_[A-Za-z0-9]{8,}|xox[abprso]-[A-Za-z0-9-]{8,}|AKIA[0-9A-Z]{12,})|\bBearer\s+[A-Za-z0-9._~+/-]{8,}/g],
+  ['secret-assign', /\b[A-Za-z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD)[A-Za-z0-9_]*\s*=\s*(\S+)/gi, (m) => {
+    const v = m.slice(m.indexOf('=') + 1).trim();
+    return !!v && !PLACEHOLDER.test(v);
+  }],
+  ['long-hex', /\b[0-9a-fA-F]{32,}\b/g],
+  ['long-base64', /(?<![A-Za-z0-9+/_-])[A-Za-z0-9+/_-]{32,}={0,2}(?![A-Za-z0-9+/_-])/g, (m) => /[a-z]/.test(m) && /[A-Z]/.test(m) && /\d/.test(m)],
+];
+
+// Known false positives. Match is the literal matched text (never a secret); `reason` is shown in the output.
+const ALLOW = [
+  { file: 'unity-lanes.md', kind: 'abs-path', match: 'D:/', reason: 'ví dụ gốc ổ đĩa "D:/" cho PFF_DATA_ROOT, không có đường dẫn thật' },
+];
+
+function allowed(file, kind, match) {
+  return ALLOW.find((a) => a.file === file && a.kind === kind && a.match === match) || null;
+}
+
+/** Findings of one text: [{line, kind, allowed: reason|null}] (values are not returned). */
+function scanText(file, text) {
+  const out = [];
+  const lines = String(text).replace(/^/, '').split(/\r?\n/);
+  lines.forEach((ln, i) => {
+    const seen = new Set();
+    for (const [kind, re, filter] of RULES) {
+      re.lastIndex = 0;
+      let m;
+      while ((m = re.exec(ln))) {
+        if (m[0] === '') { re.lastIndex++; continue; }
+        if (filter && !filter(m[0], ln)) continue;
+        if (seen.has(kind)) continue; // one finding per kind per line is enough to point at it
+        seen.add(kind);
+        const al = allowed(file, kind, m[0]);
+        out.push({ file, line: i + 1, kind, allowed: al ? al.reason : null });
+      }
+    }
+  });
+  return out;
+}
+
+/** Scan files of a profile dir (or {file: text} map). → {findings, files, clean}. */
+function scanProfile(source) {
+  const texts = {};
+  if (typeof source === 'string') {
+    for (const f of SCAN_FILES) {
+      try { texts[f] = fs.readFileSync(path.join(source, f), 'utf8'); } catch (e) { if (e.code !== 'ENOENT') throw e; }
+    }
+  } else Object.assign(texts, source);
+  const findings = [];
+  for (const [f, t] of Object.entries(texts)) findings.push(...scanText(f, t));
+  const hits = findings.filter((x) => !x.allowed);
+  return { files: Object.keys(texts), findings, hits, skipped: findings.filter((x) => x.allowed), clean: hits.length === 0 };
+}
+
+function formatScan(r, dir) {
+  const L = [`profile scan ${dir ? `${String(dir).replace(/\\/g, '/')} ` : ''}— ${r.files.join(', ') || '(không có file)'}`];
+  for (const x of r.hits) L.push(`  ! ${x.file}:${x.line}: ${x.kind}`);
+  for (const x of r.skipped) L.push(`  ~ ${x.file}:${x.line}: ${x.kind} (bỏ qua — ${x.allowed})`);
+  L.push(r.clean ? `  sạch: ${r.skipped.length} dương tính giả đã bỏ qua` : `  ${r.hits.length} chỗ nghi ngờ (giá trị không in). Xem dòng đó, sửa hoặc xác nhận dương tính giả, rồi quét lại.`);
+  return L.join('\n');
+}
+
+module.exports = { scanText, scanProfile, formatScan, SCAN_FILES, ALLOW };

package/lib/profile-seed.cjs

@@ -0,0 +1,147 @@
+'use strict';
+// Gói npm mang bản tuyển của profile (cli/profile/, do scripts/pack-profile.cjs chép từ skill/profile lúc prepack).
+// `setup` gộp vào profile đã cài (<skill>/profile):
+//   - lessons.md: dòng gạch đầu dòng nào chưa có → nối vào CUỐI file; dòng có sẵn và dòng riêng của máy không đụng tới;
+//   - .lessons.published.md: cộng dồn các dòng đã tuyển (dòng riêng máy không bao giờ vào đây, nên publish vẫn nhận ra chúng);
+//   - unity-lanes.md: chưa có → chép; đã có → không ghi đè, chỉ báo số dòng khác;
+//   - profile.json: không đụng.
+// Idempotent: chạy lại không thêm gì. So khớp dòng theo normLine = norm() của tools/lessons_sync.cjs
+// (bỏ gạch đầu dòng, [ngày] đầu, khoảng trắng thừa, chữ hoa, dấu chấm cuối) → dòng chỉ khác ngày/dấu chấm không nhân đôi.
+
+const fs = require('fs');
+const path = require('path');
+const core = require('../hook.cjs');
+
+const PUBLISHED = '.lessons.published.md';
+const UNITY = 'unity-lanes.md';
+const BULLET_RE = /^\s*[-*] +/;
+
+const lf = (txt) => String(txt).replace(/^/, '').replace(/\r\n/g, '\n');
+
+function readLF(file) {
+  try { return lf(fs.readFileSync(file, 'utf8')); } catch (e) { if (e.code === 'ENOENT') return null; throw e; }
+}
+
+/** Bullet lines outside ``` fences, trimmed (same reading as lessons_sync.cjs). */
+function bulletsOf(txt) {
+  const out = [];
+  let fence = false;
+  for (const raw of String(txt || '').split(/\r?\n/)) {
+    if (/^\s*```/.test(raw)) { fence = !fence; continue; }
+    if (fence || !BULLET_RE.test(raw)) continue;
+    out.push(raw.trim());
+  }
+  return out;
+}
+
+/** Comparison key, same as lessons_sync.cjs norm(): no bullet, no leading [date], lower-case, single spaces, no final period. */
+function normLine(line) {
+  return String(line).replace(BULLET_RE, '').replace(/^\[\d{4}-\d{2}-\d{2}\]\s*/, '')
+    .replace(/\s+/g, ' ').trim().replace(/[.\s]+$/, '').toLowerCase();
+}
+
+/** Bullets of srcTxt whose key is not in `have` (and not repeated inside srcTxt). */
+function newBullets(srcTxt, have) {
+  const seen = new Set(have);
+  const out = [];
+  for (const l of bulletsOf(srcTxt)) {
+    const k = normLine(l);
+    if (!k || seen.has(k)) continue;
+    seen.add(k);
+    out.push(l);
+  }
+  return out;
+}
+
+/** Text with `lines` appended after its last line (one newline between). */
+function appendLines(txt, lines) {
+  return `${txt.replace(/\n*$/, '\n')}${lines.join('\n')}\n`;
+}
+
+/**
+ * seedProfile(srcDir, dstDir, { dryRun }) — srcDir: <pkg>/profile, dstDir: <skill>/profile (phải đã tồn tại).
+ * → { src, dst, dry_run, skipped?, lessons: {action, added}, published: {action}, unity_lanes: {action, diff} }
+ * action: lessons copied|appended|unchanged; published written|appended|unchanged; unity_lanes copied|kept|unchanged.
+ */
+function seedProfile(srcDir, dstDir, opts) {
+  const dry = !!(opts && opts.dryRun);
+  const res = {
+    src: srcDir, dst: dstDir, dry_run: dry,
+    lessons: { action: 'unchanged', added: 0 }, published: { action: 'unchanged' }, unity_lanes: { action: 'unchanged', diff: 0 },
+  };
+  const srcL = readLF(path.join(srcDir, 'lessons.md'));
+  if (srcL === null) return Object.assign(res, { skipped: 'no-package-lessons' });
+  if (!fs.existsSync(dstDir) || !fs.statSync(dstDir).isDirectory()) return Object.assign(res, { skipped: 'no-skill-profile' });
+
+  // lessons.md
+  const dstFile = path.join(dstDir, 'lessons.md');
+  const dstL = readLF(dstFile);
+  let lessonsOut = null;
+  if (dstL === null) {
+    lessonsOut = srcL;
+    res.lessons = { action: 'copied', added: bulletsOf(srcL).length };
+  } else {
+    const add = newBullets(srcL, new Set(bulletsOf(dstL).map(normLine)));
+    if (add.length) {
+      lessonsOut = appendLines(dstL, add);
+      res.lessons = { action: 'appended', added: add.length };
+    }
+  }
+
+  // .lessons.published.md
+  const pubFile = path.join(dstDir, PUBLISHED);
+  const pubOld = readLF(pubFile);
+  let pubOut = null;
+  if (pubOld === null) {
+    pubOut = srcL;
+    res.published = { action: 'written' };
+  } else {
+    const add = newBullets(srcL, new Set(bulletsOf(pubOld).map(normLine)));
+    if (add.length) {
+      pubOut = appendLines(pubOld, add);
+      res.published = { action: 'appended' };
+    }
+  }
+
+  // unity-lanes.md
+  const srcU = readLF(path.join(srcDir, UNITY));
+  let unityOut = null;
+  if (srcU !== null) {
+    const dstU = readLF(path.join(dstDir, UNITY));
+    if (dstU === null) {
+      unityOut = srcU;
+      res.unity_lanes = { action: 'copied', diff: srcU.split('\n').filter((l) => l.trim()).length };
+    } else if (dstU !== srcU) {
+      const have = new Set(dstU.split('\n'));
+      res.unity_lanes = { action: 'kept', diff: srcU.split('\n').filter((l) => l.trim() && !have.has(l)).length };
+    }
+  }
+
+  if (!dry) {
+    if (lessonsOut !== null) core.writeFileAtomic(dstFile, lessonsOut);
+    if (pubOut !== null) core.writeFileAtomic(pubFile, pubOut);
+    if (unityOut !== null) core.writeFileAtomic(path.join(dstDir, UNITY), unityOut);
+  }
+  return res;
+}
+
+/** Dòng tóm tắt tiếng Việt cho `setup` (không in nội dung dòng). */
+function seedSummary(res) {
+  if (res.skipped) {
+    return res.skipped === 'no-package-lessons'
+      ? 'Profile gói npm: không có (chạy từ bản đã đóng gói mới có lessons đã tuyển)'
+      : 'Profile gói npm: bỏ qua (không thấy profile/ của skill)';
+  }
+  const tag = res.dry_run ? ' (dry-run, không ghi)' : '';
+  const L = res.lessons.action === 'copied' ? `lessons.md chép mới (${res.lessons.added} dòng bài học)`
+    : res.lessons.action === 'appended' ? `lessons.md thêm ${res.lessons.added} dòng mới của bản tuyển`
+      : 'lessons.md không đổi';
+  const U = res.unity_lanes.action === 'copied' ? 'unity-lanes.md chép mới'
+    : res.unity_lanes.action === 'kept' ? `unity-lanes.md giữ bản cài (khác ${res.unity_lanes.diff} dòng so với gói; không ghi đè)`
+      : 'unity-lanes.md không đổi';
+  const P = res.published.action === 'appended' ? '; .lessons.published.md cộng thêm dòng đã tuyển'
+    : res.published.action === 'written' ? '; .lessons.published.md ghi mới' : '';
+  return `Profile: ${L}; ${U}${P}${tag}`;
+}
+
+module.exports = { PUBLISHED, BULLET_RE, bulletsOf, normLine, seedProfile, seedSummary };