@kienntpixon/dieu-phoi 0.7.1 → 0.7.3

package/lib/procs.cjs

@@ -0,0 +1,422 @@
+'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 (kill_leftovers:true, the 0.7.2 behaviour) and killVerified (s7, default 'guarded') are the only kill paths.
+
+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;
+}
+
+// ------------------------------------------------------------------ guarded kill (core 0.7.3 s7)
+
+// Never killed by any dieu-phoi path, whatever the attribution says: Claude Code itself, the shared code graph, console
+// hosts, Docker / WSL / Hyper-V, Unity, the user's apps (Orca, PixChat, editors, terminals, Explorer) and Windows itself.
+const NEVER_KILL_RE = [
+  /^claude(\.exe)?$/, /^codebase-memory-mcp/, /^conhost(\.exe)?$/, /^openconsole(\.exe)?$/, /^windowsterminal(\.exe)?$/,
+  /^com\.docker\./, /^docker/, /^wsl/, /^vmmem/, /^vmwp(\.exe)?$/, /^vmcompute(\.exe)?$/, /^unity/,
+  /^orca/, /^pixchat/, /^explorer(\.exe)?$/, /^code(\.exe)?$/, /^cursor(\.exe)?$/, /^devenv(\.exe)?$/, /^rider/,
+  /^(system|idle|registry|smss|csrss|wininit|winlogon|services|lsass|svchost|dwm|sihost|taskhostw|fontdrvhost|ctfmon|runtimebroker|searchhost|shellexperiencehost|startmenuexperiencehost|memory compression)(\.exe)?$/,
+];
+const isNeverKill = (p) => NEVER_KILL_RE.some((re) => re.test(lower(p && p.name)));
+// What Claude Code's Bash / PowerShell tools start under claude.exe. Other direct children of claude.exe are MCP servers
+// (node, npx, cmd /c, uvx, python...): the session's own, never an agent's leftover.
+const AGENT_SHELL_RE = /^(bash|sh|zsh|dash|powershell|pwsh)(\.exe)?$/;
+// Orphans `reap --orphans` may clean: keep-alive / watcher commands, and Claude Code shells (the snapshot path is in their cmd).
+const ORPHAN_KILL_NAMES = ['tail.exe', 'tail', 'sleep.exe', 'sleep'];
+const isClaudeShell = (p) => AGENT_SHELL_RE.test(lower(p.name)) && /shell-snapshots/i.test(p.cmd || '');
+const normPath = (s) => String(s || '').replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
+
+/**
+ * `kill_leftovers` mode: env DIEU_PHOI_KILL_LEFTOVERS → config → 'guarded'. true/'true'/'1' = 'tree' (0.7.2: kill the tree
+ * roots with taskkill /T), false/'false'/'0'/'off' = 'off', anything else = 'guarded'.
+ */
+function killMode(config, env) {
+  const e = (env || process.env).DIEU_PHOI_KILL_LEFTOVERS;
+  for (const v of [e, config && config.kill_leftovers]) {
+    if (v === undefined || v === null || v === '') continue;
+    if (v === true || /^(true|1|yes|tree)$/i.test(String(v))) return 'tree';
+    if (v === false || /^(false|0|no|off)$/i.test(String(v))) return 'off';
+    return 'guarded';
+  }
+  return 'guarded';
+}
+
+/** The value written as `kill_leftovers` in events: true / false / 'guarded' (what the user would put in config). */
+const killModeValue = (mode) => (mode === 'tree' ? true : mode === 'off' ? false : 'guarded');
+
+/** Has p a claude.exe below it (another session / a nested Claude Code)? Killing p would take that session down. */
+function hostsClaude(list, pid) {
+  return descendants(list, pid).some((c) => /^claude(\.exe)?$/.test(lower(c.name)));
+}
+
+/**
+ * Guarded selection over leftover candidates (descendants of the session's claude.exe created since the agent started, see
+ * leftoverProcesses). Keeps only processes attributable to that agent:
+ *   - not on the never-kill list (nor any ancestor below the root), no claude.exe below it;
+ *   - reached through an agent shell (bash / powershell) that claude.exe started, not through an MCP server;
+ *   - its command line (or an ancestor's, up to the root) is inside the agent's own worktree (`worktree`; the caller passes
+ *     it only when no other agent shares it), OR `exclusive` (no other dp agent of this home ran meanwhile).
+ * Returns { kill: [p], skip: [{pid, name, reason}] }. Pure.
+ */
+function guardedSelect(list, cands, o) {
+  const opt = o || {};
+  const idx = byPid(list);
+  const wt = opt.worktree ? normPath(opt.worktree) : '';
+  const kill = [];
+  const skip = [];
+  for (const p of cands || []) {
+    let reason = null;
+    if (isNeverKill(p)) reason = 'never-kill';
+    else if (hostsClaude(list, p.pid)) reason = 'hosts-claude';
+    else {
+      const chain = [p]; // p up to (not including) the root
+      let cur = p;
+      for (let i = 0; i < 64 && cur && cur.ppid !== opt.rootPid; i++) { cur = idx.get(cur.ppid); if (cur) chain.push(cur); }
+      const top = chain[chain.length - 1];
+      if (!cur || !opt.rootPid || top.ppid !== opt.rootPid) reason = 'not-under-session';
+      else if (!AGENT_SHELL_RE.test(lower(top.name))) reason = 'not-via-agent-shell';
+      else if (chain.some(isNeverKill)) reason = 'never-kill-ancestor';
+      else if (!opt.exclusive && !(wt && chain.some((c) => normPath(c.cmd).includes(wt)))) reason = 'not-attributable';
+    }
+    if (reason) skip.push({ pid: p.pid, name: p.name, reason });
+    else kill.push(p);
+  }
+  return { kill, skip };
+}
+
+/**
+ * Orphans `reap --orphans` may kill: tail / sleep (any cmd) and Claude Code shells (cmd has shell-snapshots) whose parent
+ * is gone (or whose parent pid was reused later), older than minAgeMs, not never-kill, no claude.exe below. Oldest first.
+ */
+function killableOrphans(list, o) {
+  const opt = o || {};
+  const now = typeof opt.now === 'number' ? opt.now : Date.now();
+  const names = new Set(ORPHAN_KILL_NAMES);
+  const idx = byPid(list);
+  return (list || []).filter((p) => (names.has(lower(p.name)) || isClaudeShell(p)) && isOrphan(p, idx)
+    && p.created && now - p.created >= (opt.minAgeMs || 0) && !isNeverKill(p) && !hostsClaude(list, p.pid))
+    .sort((a, b) => a.created - b.created);
+}
+
+// Git-bash (MSYS2) trap: when bash runs its last command it execs it, and on Windows that means a NEW process whose
+// Windows parent (the bash.exe stub) exits at once. A live `bash -c "tail -f x"` / Monitor therefore shows a dead PPID from
+// the first second. Only the MSYS process table (`ps -al`: PID PPID PGID WINPID ...) keeps the logical parent, so on
+// Windows an orphan counts only if MSYS also says so: MSYS parent 1 or no longer in the table.
+const MSYS_PS_CANDIDATES = ['C:\\Program Files\\Git\\usr\\bin\\ps.exe', 'C:\\Program Files (x86)\\Git\\usr\\bin\\ps.exe', 'C:\\msys64\\usr\\bin\\ps.exe'];
+
+/** `ps -al` of MSYS -> { byWin: Map(winpid -> {pid, ppid}), pids: Set(msys pid) }, or null when nothing parses. */
+function parseMsysPs(text) {
+  const byWin = new Map();
+  const pids = new Set();
+  for (const line of String(text || '').split(/\r?\n/)) {
+    const m = /^[ A-Z]\s*(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s/.exec(line);
+    if (!m) continue;
+    const pid = Number(m[1]);
+    pids.add(pid);
+    byWin.set(Number(m[4]), { pid, ppid: Number(m[2]) });
+  }
+  return pids.size ? { byWin, pids } : null;
+}
+
+/**
+ * MSYS process table of this machine, or null (not Windows, no Git-bash ps.exe, error). `hints` = command lines of the
+ * candidates (the ps.exe next to their tail.exe is the right runtime); `exec(file, args, {timeout})` injectable. Never throws.
+ */
+function msysTable(o) {
+  const opt = o || {};
+  const exec = typeof opt.exec === 'function' ? opt.exec : defaultExec;
+  if (process.env.DIEU_PHOI_NO_PROCS === '1' && typeof opt.exec !== 'function') return null;
+  const dirs = [];
+  for (const c of opt.hints || []) {
+    const m = /^"?([A-Za-z]:\\[^"]*?\\usr\\bin)\\[^\\"]+\.exe/i.exec(String(c || ''));
+    if (m && !dirs.includes(m[1])) dirs.push(m[1]);
+  }
+  const files = dirs.map((d) => `${d}\\ps.exe`).concat(MSYS_PS_CANDIDATES, ['ps']);
+  for (const f of files) {
+    try {
+      const out = exec(f, ['-al'], { timeout: opt.timeoutMs || DEFAULT_TIMEOUT_MS });
+      const t = typeof out === 'string' ? parseMsysPs(out) : null;
+      if (t) return t;
+    } catch (_) { /* next */ }
+  }
+  return null;
+}
+
+/**
+ * Orphan candidates that the MSYS table confirms (MSYS parent 1 or gone). msys null = unreadable: nothing is confirmed.
+ * Returns { keep: [p], skip: [{pid, name, reason: 'msys-parent-alive'|'msys-unknown'|'msys-unverifiable'}] }. Pure.
+ */
+function msysConfirm(cands, msys) {
+  const keep = [];
+  const skip = [];
+  for (const p of cands || []) {
+    const m = msys && msys.byWin.get(p.pid);
+    if (!msys) skip.push({ pid: p.pid, name: p.name, reason: 'msys-unverifiable' });
+    else if (!m) skip.push({ pid: p.pid, name: p.name, reason: 'msys-unknown' });
+    else if (m.ppid !== 1 && msys.pids.has(m.ppid)) skip.push({ pid: p.pid, name: p.name, reason: 'msys-parent-alive' });
+    else keep.push(p);
+  }
+  return { keep, skip };
+}
+
+/** Kill single processes (no /T: what is below stays unless it is a target too). Returns the pids stopped; never throws. */
+function killPids(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;
+    try {
+      if ((opt.platform || process.platform) === 'win32') {
+        const r = cp.spawnSync('taskkill', ['/PID', String(pid), '/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;
+}
+
+/**
+ * Re-read the process table right before killing; kill only targets still there with the same creation time and name
+ * (a pid reused by an unrelated process is never killed). `relist()` -> list|null, `kill(pids)` -> pids (default killPids).
+ * Returns { killed: [pid], skipped: [{pid, name, reason: 'gone'|'pid-reused'|'no-created'|'unverifiable'}] }. Never throws.
+ */
+function killVerified(targets, o) {
+  const opt = o || {};
+  let fresh = null;
+  try { fresh = typeof opt.relist === 'function' ? opt.relist() : null; } catch (_) { fresh = null; }
+  if (!Array.isArray(fresh)) return { killed: [], skipped: (targets || []).map((t) => ({ pid: t.pid, name: t.name, reason: 'unverifiable' })) };
+  const idx = byPid(fresh);
+  const ok = [];
+  const skipped = [];
+  for (const t of targets || []) {
+    const cur = idx.get(t.pid);
+    if (!t.created) skipped.push({ pid: t.pid, name: t.name, reason: 'no-created' });
+    else if (!cur) skipped.push({ pid: t.pid, name: t.name, reason: 'gone' });
+    else if (cur.created !== t.created || lower(cur.name) !== lower(t.name)) skipped.push({ pid: t.pid, name: t.name, reason: 'pid-reused' });
+    else ok.push(t.pid);
+  }
+  let killed = [];
+  try { killed = ok.length ? ((typeof opt.kill === 'function' ? opt.kill(ok) : killPids(ok, { deadline: opt.deadline })) || []) : []; } catch (_) { killed = []; }
+  return { killed, skipped };
+}
+
+module.exports = {
+  PS_WIN, ORPHAN_NAMES, LEFTOVER_SKIP_NAMES,
+  parseWindowsJson, parsePs, listProcesses,
+  descendants, ancestors, claudeAncestor, orphans, staleOrphans, isCbmDaemon, leftoverProcesses, killTree,
+  NEVER_KILL_RE, ORPHAN_KILL_NAMES, AGENT_SHELL_RE, isNeverKill, isClaudeShell, isOrphan, killMode, killModeValue, hostsClaude,
+  guardedSelect, killableOrphans, killPids, killVerified, MSYS_PS_CANDIDATES, parseMsysPs, msysTable, msysConfirm,
+};

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 };