@kienntpixon/dieu-phoi 0.7.3 → 0.7.4

package/hook.cjs

@@ -6,7 +6,8 @@
  * This file is copied verbatim to ~/.claude/dieu-phoi/bin/hook.cjs by `dieu-phoi setup`
  * and run by Claude Code on PostToolUse(Agent), SubagentStop, SessionStart(compact) and UserPromptSubmit; the dp-* agent
  * files (`dieu-phoi setup` -> ~/.claude/agents) also run it inside those subagents as `--watch` (PostToolUse, context
- * handoff watchdog), `--gate` (PreToolUse(Agent), gen-2 helper rules) and `--gate-release`. It must stay
+ * handoff watchdog), `--gate` (PreToolUse(Agent), gen-2 helper rules), `--gate-bash` (PreToolUse(Bash), no
+ * `knowledge review|merge`) and `--gate-release`. It must stay
  * self-contained: Node built-ins only, no requires of other package files.
  *
  * Hook rules: stdout only for the JSON of SessionStart(compact) / UserPromptSubmit / a PostToolUse(Agent) warning
@@ -19,6 +20,7 @@
  *   node hook.cjs --watch    -> dp subagent PostToolUse: context watchdog (additionalContext JSON or nothing)
  *   node hook.cjs --gate     -> dp-exec PreToolUse(Agent): allow / deny a gen-2 helper spawn
  *   node hook.cjs --gate-release -> dp-exec PostToolUseFailure(Agent): give a failed spawn's helper slot back
+ *   node hook.cjs --gate-bash -> dp-* PreToolUse(Bash|PowerShell): deny `knowledge review|merge` in a subagent
  */
 
 const fs = require('fs');
@@ -26,7 +28,7 @@ const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
 
-const CORE_VERSION = '0.7.3';
+const CORE_VERSION = '0.7.4';
 const SCHEMA = 1;
 const TASK_TYPES = [
   'search', 'extract', 'mechanical-edit', 'feature-impl', 'debug', 'refactor',
@@ -1172,8 +1174,8 @@ function buildSessionState(events, sessionId, opts) {
     if (!seenTask.has(id) && !discarded.has(id)) { seenTask.add(id); taskIds.push(id); }
   }
   const modeEvents = new Map();
-  for (const ev of events) if (ev && ev.kind === 'mode' && isMode(ev.mode) && typeof ev.root_task_id === 'string') modeEvents.set(ev.root_task_id, ev);
-  const modeOfRoot = (root) => (modeEvents.has(root) ? modeEvents.get(root).mode : DEFAULT_MODE);
+  for (const ev of events) if (ev && ev.kind === 'mode' && normMode(ev.mode) && typeof ev.root_task_id === 'string') modeEvents.set(ev.root_task_id, ev);
+  const modeOfRoot = (root) => (modeEvents.has(root) ? normMode(modeEvents.get(root).mode) : DEFAULT_MODE);
   const per = new Map(taskIds.map((id) => [id, { dispatches: [], user: [], steers: [], overrides: [], agentIds: new Set() }]));
   events.forEach((ev, i) => {
     if (!ev || typeof ev !== 'object') return;
@@ -1225,7 +1227,7 @@ function buildSessionState(events, sessionId, opts) {
       const pApproved = pov && evMs(pov) > (Date.parse(ps.plan.approved_at) || 0) ? pov.chosen_tier || null : null;
       tasks.push(Object.assign({
         task_id: id, task_type: ps.step.type || null, gate: 2, pending: true, verify_only: false, round: 0,
-        mode: isMode(ps.step.mode) ? ps.step.mode : modeOfRoot(ps.plan.root_task_id),
+        mode: normMode(ps.step.mode) || modeOfRoot(ps.plan.root_task_id),
       }, planInfo, {
         approved_tier: pApproved || ps.step.tier || null, last_tier: null, attempts: [], user_verdict: null, last_steer: null,
         run_dir: planDir, last_ts: null,
@@ -1283,7 +1285,7 @@ function buildSessionState(events, sessionId, opts) {
       pending: false,
       verify_only: attempts.length > 0 && attempts.every((a) => a.role === 'verify'),
       round,
-      mode: dispatchModeFromEvents(t.dispatches, id) || (ps && isMode(ps.step.mode) ? ps.step.mode : modeOfRoot(plan ? plan.root_task_id : id)),
+      mode: dispatchModeFromEvents(t.dispatches, id) || (ps && normMode(ps.step.mode)) || modeOfRoot(plan ? plan.root_task_id : id),
     }, planInfo, {
       approved_tier: approved,
       last_tier: lastExecAny ? tierOf(lastExecAny.model, lastExecAny.effort) : null,
@@ -1301,12 +1303,9 @@ function buildSessionState(events, sessionId, opts) {
   for (const [root, ev] of modeEvents) if (ev.session_id === sessionId || ev.session === sidHash) modeRoots.add(root);
   const modes = Array.from(modeRoots).map((root) => {
     const ev = modeEvents.get(root);
-    const mode = ev ? ev.mode : DEFAULT_MODE;
-    // core 0.7.0 (s2): suggestion only — the mode itself never changes here
-    const sug = modeSuggestion(events, root, { mode, taskIds: rootTaskIds(allPlans, root) });
+    const mode = ev ? normMode(ev.mode) : DEFAULT_MODE;
     return {
       root_task_id: root, mode, since: ev ? ev.ts : null, source: ev ? ev.source || null : 'default', reason_code: ev ? ev.reason_code || null : null,
-      mode_suggest: sug.mode_suggest, mode_suggest_reason: sug.mode_suggest_reason,
     };
   });
   const orphans = findOrphanAgents(events, taskIds.filter((id) => !discarded.has(id)), { nowMs: o.nowMs });
@@ -1470,14 +1469,7 @@ function compactSystemMessage(state) {
 function modesLine(state) {
   const ms = Array.isArray(state.modes) ? state.modes : [];
   if (!ms.length) return '';
-  const sug = ms.slice(-6).filter((m) => m.mode_suggest).map((m) => `\n${modeSuggestLine(m.root_task_id, m.mode, m.mode_suggest_reason)}`).join('');
-  return `\nMode (theo yêu cầu, đổi bằng \`dieu-phoi mode --root <id> <mode>\`): ${ms.slice(-6).map((m) => `${m.root_task_id}=${m.mode}`).join(', ')}.${sug}`;
-}
-
-/** One line telling the orchestrator to ASK the user about returning to normal (never switch by itself). */
-function modeSuggestLine(root, mode, reason) {
-  return `GỢI Ý mode: ${root ? `${root} đang ${mode}` : `đang ${mode}`} — hỏi người dùng có muốn quay về normal không (${reason}); `
-    + `chỉ đổi khi người dùng đồng ý: \`dieu-phoi mode --root ${root || '<root>'} normal\`. KHÔNG tự đổi mode.`;
+  return `\nMode (theo yêu cầu, đổi bằng \`dieu-phoi mode --root <id> <mode>\`): ${ms.slice(-6).map((m) => `${m.root_task_id}=${m.mode}`).join(', ')}.`;
 }
 
 function formatSessionState(state, cap) {
@@ -1695,9 +1687,10 @@ function orchLessonLines(info) {
   return ls.length ? ['bài học cho điều phối viên (profile/lessons.md, [orch]):'].concat(ls.map((l) => `  - ${l}`)) : [];
 }
 
-/** Gate-1 mode line: the chosen mode, or the reminder to ASK the user (default normal). */
+/** Gate-1 mode line: only when a mode was chosen (`start --mode fast`); '' otherwise (no mode question, default normal). */
 function modeLine(info) {
-  return info && isMode(info.mode) ? `mode: ${info.mode} (đã ghi cho root ${info.id}; đổi: dieu-phoi mode --root ${info.id} <mode>)` : MODE_ASK_LINE;
+  const m = info && normMode(info.mode);
+  return m ? `mode: ${m} (đã ghi cho root ${info.id}; đổi: dieu-phoi mode --root ${info.id} <mode>)` : '';
 }
 
 function formatStartBlock(info) {
@@ -1712,7 +1705,7 @@ function formatStartBlock(info) {
     ...orchLessonLines(info),
     ...knowledgeLines(info),
     'Dùng khối này cho yêu cầu MỚI ở cổng 1 (không dùng nếu đang giữa một lần điều phối). Không chạy `dieu-phoi doctor` / `new-id` / mkdir: lượt đầu tiên là Agent scout + câu hỏi cổng 1 cho người dùng.',
-  ].join('\n');
+  ].filter((l) => l !== '').join('\n');
 }
 
 /** UserPromptSubmit: on a dieu-phoi prompt, pre-create the run and inject id/run dir/health/brief. */
@@ -1870,29 +1863,36 @@ function handoffChainMessage(taskId, n) {
   return `dieu-phoi: task ${taskId} đã handoff ${n} lần (cảnh báo từ ${HANDOFF_CHAIN_WARN}; từ ${HANDOFF_CHAIN_DENY} hook chặn lượt exec tiếp nối, trừ thẻ có \`chain_ok\` khi người dùng đồng ý). Đừng nối tiếp thêm: nếu agent vừa giao là agent tiếp nối, cân nhắc dừng nó và giao planner (dp-scout) đọc handoff-${taskId}.md rồi chia phần còn lại thành bước mới (task_id mới từ \`dieu-phoi new-id\`).`;
 }
 
-// ------------------------------------------------------------------ core 0.7.0: mode per request (fast | normal | strict)
+// ------------------------------------------------------------------ core 0.7.0: mode per request (fast | normal; 0.7.4: strict removed)
 //
 // A request (root_task_id) has a mode; the user picks it at gate 1 (`start --mode`, `plan-table` file, or
 // `dieu-phoi mode --root R <mode>` at any time). Every change is one local-only event kind=mode. A step not yet
 // dispatched follows the root's current mode (or its own `mode` override in the approved plan); a step already
 // dispatched keeps the mode its first exec dispatch recorded. Nothing here ever changes a mode by itself.
 
-const MODES = ['fast', 'normal', 'strict'];
+const MODES = ['fast', 'normal'];
 const DEFAULT_MODE = 'normal';
+/** Removed in 0.7.4: old events/plans/configs may still carry it; every reader treats it as normal. */
+const LEGACY_MODE = 'strict';
 /** Event kinds that stay on this machine: runSync does not send them (an older sink would answer bad_kind). */
 const LOCAL_ONLY_KINDS = new Set(['mode', 'knowledge_merge', 'leftover', 'worktree', 'reap', 'reap_orphans']);
-const MODE_ASK_LINE = 'mode: chưa chọn — chỉ hỏi ở cổng 1 khi plan-table báo ≥4 bước s≤6 (fast | normal | strict, mặc định normal); '
-  + 'đặt bằng `dieu-phoi mode --root <root_task_id> <mode>`';
-
+/** A mode the user may choose now (fast | normal). */
 function isMode(m) {
   return typeof m === 'string' && MODES.includes(m);
 }
 
+/** Mode as stored/read: fast | normal; legacy 'strict' reads as normal; anything else null. */
+function normMode(m) {
+  if (typeof m !== 'string') return null;
+  if (m === LEGACY_MODE) return DEFAULT_MODE;
+  return MODES.includes(m) ? m : null;
+}
+
 /** Last mode event of `root` in an events array (null when none). */
 function rootModeFromEvents(events, root) {
   let last = null;
   for (const ev of events) {
-    if (ev && ev.kind === 'mode' && ev.root_task_id === root && isMode(ev.mode)) last = ev;
+    if (ev && ev.kind === 'mode' && ev.root_task_id === root && normMode(ev.mode)) last = ev.mode === normMode(ev.mode) ? ev : Object.assign({}, ev, { mode: normMode(ev.mode) });
   }
   return last;
 }
@@ -1910,7 +1910,7 @@ function rootModeFromText(txt, root) {
     if (line.includes(rootNeedle)) {
       try {
         const ev = JSON.parse(line);
-        if (ev && ev.kind === 'mode' && isMode(ev.mode)) last = ev;
+        if (ev && ev.kind === 'mode' && normMode(ev.mode)) last = ev.mode === normMode(ev.mode) ? ev : Object.assign({}, ev, { mode: normMode(ev.mode) });
       } catch (_) { /* corrupt line */ }
     }
     i = end < 0 ? -1 : txt.indexOf(needle, end);
@@ -1921,7 +1921,7 @@ function rootModeFromText(txt, root) {
 /** Mode the first exec dispatch of `taskId` recorded (a dispatched step keeps its mode), from an events array. */
 function dispatchModeFromEvents(events, taskId) {
   for (const ev of events) {
-    if (ev && ev.kind === 'dispatch' && ev.task_id === taskId && (ev.role || 'exec') === 'exec' && isMode(ev.mode)) return ev.mode;
+    if (ev && ev.kind === 'dispatch' && ev.task_id === taskId && (ev.role || 'exec') === 'exec' && normMode(ev.mode)) return normMode(ev.mode);
   }
   return null;
 }
@@ -1935,7 +1935,7 @@ function dispatchModeFromText(txt, taskId) {
     const line = txt.slice(start, end < 0 ? undefined : end);
     if (line.includes('"kind":"dispatch"') && !line.includes('"role":"verify"') && !line.includes('"role":"plan"') && !line.includes('"role":"helper"')) {
       const m = /"mode":"(fast|normal|strict)"/.exec(line);
-      if (m) return m[1];
+      if (m) return normMode(m[1]);
     }
     i = end < 0 ? -1 : txt.indexOf(needle, end);
   }
@@ -1966,7 +1966,7 @@ function taskModeInfo(ctx, taskId, events) {
     const locked = events ? dispatchModeFromEvents(events, taskId) : dispatchModeFromText(txt, taskId);
     if (locked) return { mode: locked, source: 'dispatched', root };
   }
-  if (pl && pl.step && isMode(pl.step.mode)) return { mode: pl.step.mode, source: 'step', root };
+  if (pl && pl.step && normMode(pl.step.mode)) return { mode: normMode(pl.step.mode), source: 'step', root };
   if (root) {
     const ev = events ? rootModeFromEvents(events, root) : rootModeFromText(txt, root);
     if (ev) return { mode: ev.mode, source: 'root', root };
@@ -1974,90 +1974,6 @@ function taskModeInfo(ctx, taskId, events) {
   return { mode: DEFAULT_MODE, source: 'default', root };
 }
 
-// core 0.7.0 (s2): signals for SUGGESTING a return to normal. The CLI never switches the mode itself; only the
-// user's `dieu-phoi mode` does. A suggestion is computed only while the root is in fast.
-const FAST_FAIL_WINDOW = 10;     // last N fast exec steps (all roots, file order of their first exec dispatch)
-const FAST_FAIL_MIN_N = 5;       // fewer fast steps than this -> no rate signal yet
-const FAST_FAIL_RATE = 0.15;     // >= this share failed -> suggest normal
-const BATCH_VERIFY_RE = /^batch-verify(?:-|$)/;
-const QUOTA_VERDICT_RE = /^(?:quota-pause|usage-limit|auto-quota-pause|auto-usage-limit|paused-for-quota)(?:-|$)/;
-
-/** A user reject that counts as a quality signal (legacy `rework` too); scope rejects (request changed) do not. */
-function isQualityReject(ev) {
-  if (ev.outcome === 'rework' && !ev.by) return true;
-  return ev.by === 'user' && ev.outcome === 'reject' && ev.cause !== 'scope';
-}
-
-/** Agent-layer fail (fail / timeout, never a quota pause or aborted). */
-function isAgentFail(ev) {
-  if (ev.by === 'user' || ev.by === 'auto') return false;
-  if (ev.outcome === 'fail') return true;
-  return ev.outcome === 'timeout' && !QUOTA_VERDICT_RE.test(String(ev.reason_code || ''));
-}
-
-/**
- * Fail rate over the last FAST_FAIL_WINDOW fast exec steps (any root): a step is a task whose first exec dispatch
- * recorded mode=fast; it failed when it has an agent-layer fail or a quality reject. Discarded tasks are left out.
- * Returns { n, failed, rate } (rate null when n = 0).
- */
-function fastFailRate(events) {
-  const gone = new Set();
-  for (const ev of events) if (ev && ev.kind === 'discard' && typeof ev.task_id === 'string') gone.add(ev.task_id);
-  const order = [];
-  const seen = new Set();
-  for (const ev of events) {
-    if (!ev || ev.kind !== 'dispatch' || typeof ev.task_id !== 'string' || !ev.task_id) continue;
-    if ((ev.role || 'exec') !== 'exec' || seen.has(ev.task_id)) continue;
-    seen.add(ev.task_id);
-    if (ev.mode === 'fast' && !gone.has(ev.task_id)) order.push(ev.task_id);
-  }
-  const win = new Set(order.slice(-FAST_FAIL_WINDOW));
-  const failed = new Set();
-  for (const ev of events) {
-    if (ev && ev.kind === 'verdict' && win.has(ev.task_id) && (isAgentFail(ev) || isQualityReject(ev))) failed.add(ev.task_id);
-  }
-  return { n: win.size, failed: failed.size, rate: win.size ? failed.size / win.size : null };
-}
-
-/**
- * Should the orchestrator SUGGEST (never apply) a return to normal for `root`? Only while `mode` (the root's current
- * mode) is fast. Signals, each with a short Vietnamese reason:
- *   - batch-verify: an agent verdict fail with reason batch-verify on a task of the root, after the root's last mode event;
- *   - reject: a quality reject (user) on a task of the root, after that mode event;
- *   - fail-rate: >= 15% failed among the last 10 fast steps (all roots; needs >= 5 steps).
- * `taskIds` = the root and its plan's step task ids. Returns { mode_suggest: 'normal'|null, mode_suggest_reason,
- * mode_suggest_signals[] }.
- */
-function modeSuggestion(events, root, o) {
-  const opts = o || {};
-  const none = { mode_suggest: null, mode_suggest_reason: null, mode_suggest_signals: [] };
-  if (opts.mode !== 'fast') return none;
-  const ids = new Set(opts.taskIds || []);
-  if (root) ids.add(root);
-  const last = root ? rootModeFromEvents(events, root) : null;
-  const since = last ? (Date.parse(last.ts) || 0) : 0;
-  const signals = [];
-  const reasons = [];
-  let batch = null;
-  let reject = null;
-  for (const ev of events) {
-    if (!ev || ev.kind !== 'verdict' || !ids.has(ev.task_id)) continue;
-    const t = Date.parse(ev.ts) || 0;
-    if (t < since) continue;
-    if (!batch && ev.outcome === 'fail' && BATCH_VERIFY_RE.test(String(ev.reason_code || ''))) batch = ev.task_id;
-    if (!reject && isQualityReject(ev)) reject = ev.task_id;
-  }
-  if (batch) { signals.push('batch-verify'); reasons.push(`verifier gộp báo fail (task ${batch})`); }
-  if (reject) { signals.push('reject'); reasons.push(`người dùng reject (task ${reject})`); }
-  const fr = fastFailRate(events);
-  if (fr.n >= FAST_FAIL_MIN_N && fr.rate >= FAST_FAIL_RATE) {
-    signals.push('fail-rate');
-    reasons.push(`${fr.failed}/${fr.n} bước fast gần nhất fail (${Math.round(fr.rate * 100)}% ≥ ${Math.round(FAST_FAIL_RATE * 100)}%)`);
-  }
-  if (!signals.length) return none;
-  return { mode_suggest: 'normal', mode_suggest_reason: reasons.join('; '), mode_suggest_signals: signals };
-}
-
 /** Task ids of a root: the root itself plus the step task ids of its approved plan (if any). */
 function rootTaskIds(plans, root) {
   const out = new Set(root ? [root] : []);
@@ -2330,8 +2246,10 @@ function readHead(start) {
 
 // ------------------------------------------------------------------ core 0.6.0, s3: knowledge freshness
 //
-// A knowledge section is stale when a file matching its `paths` globs differs between the commit it was merged at
-// (`sha`) and the HEAD of the worktree asking. Used by the start block here and by `knowledge get/list/status`
+// A knowledge section is stale when a file named by one of its plain (non-glob) `paths` entries differs between the
+// commit it was merged at (`sha`) and the HEAD of the worktree asking. A file that only matches a glob entry (`**`,
+// `*`, `?`) gives state `drift`: shown lightly, never counted as stale (rule 2, 0.7.4 s5; cache entries carry `rule`).
+// Used by the start block here and by `knowledge get/list/status`
 // (lib/knowledge.cjs). Lives in hook.cjs because the installed hook is a single file (builtins only). Rules, from
 // measurements on the pixon-fast-forward repos (contract r1-2 §2):
 //   - ONE git process per check, whatever the number of distinct section shas: `git diff-tree --stdin` reads one
@@ -2350,8 +2268,69 @@ const FRESH_CACHE_MAX = 12; // HEADs remembered per store (worktrees of one repo
 const DIFF_TIMEOUT_MS = 10000;
 const HOOK_DIFF_TIMEOUT_MS = 1500;
 const DIRTY_TIMEOUT_MS = 2000;
+// Tests only: DIEU_PHOI_GIT_STATUS_TIMEOUT_MS overrides the `git status` bound of --dirty (a busy Windows box overruns 2 s);
+// invalid or non-positive values are ignored, the product default stays DIRTY_TIMEOUT_MS.
+function dirtyTimeoutMs() {
+  const v = Number(process.env.DIEU_PHOI_GIT_STATUS_TIMEOUT_MS);
+  return Number.isFinite(v) && v > 0 ? v : DIRTY_TIMEOUT_MS;
+}
 const PATHSPEC_MAX_CHARS = 6000; // beyond this: no pathspec (Windows command line limit), filter in JS only
 const STALE_FILES_KEEP = 50; // stale files kept per section (the count stays exact)
+const FRESH_RULE = 4; // 4 (0.7.4 s9): rule 3 + identifiers compared as nameKey (kebab/camel match), >= 3 chars; cache of rule 3 dropped
+const GLOB_CHARS_RE = /[*?]/;
+const LARGE_FILE_BYTES = 30000; // above this a plain path counts only when a changed line names one of the entry's identifiers
+// A changed line that is only a version bump (package.json, SKILL.md frontmatter, a `const CORE_VERSION = '…'` in code) or blank: routine, never stale.
+const ROUTINE_LINE_RES = [/^\s*$/, /^\s*"version"\s*:\s*"[^"]*",?\s*$/, /^\s*version\s*:\s*[^\s#]+\s*$/,
+  /^\s*(?:const|let|var)\s+\w*VERSION\w*\s*=\s*(['"])[^'"]*\1;?\s*$/];
+// Words too common in code to tell an entry's identifiers from ordinary lines.
+const NAME_STOPWORDS = new Set(['const', 'return', 'function', 'string', 'number', 'object', 'boolean', 'undefined',
+  'files', 'file', 'json', 'path', 'paths', 'value', 'values', 'state', 'null', 'true', 'false', 'test', 'tests', 'node', 'cli']);
+
+function plainPathsOf(s) { return (s.paths || []).filter((g) => !GLOB_CHARS_RE.test(g)); }
+function isChangelogPath(f) { return /(^|\/)CHANGELOG[^/]*$/i.test(f); }
+function entryAboutChangelog(s) { return [s.id, s.title, ...(s.tags || [])].some((x) => /changelog/i.test(String(x || ''))); }
+function isRoutineLine(t) { return ROUTINE_LINE_RES.some((re) => re.test(t)); }
+function isLargeFile(root, f) {
+  try { return fs.statSync(path.join(root, f)).size > LARGE_FILE_BYTES; } catch (_) { return false; }
+}
+function readSectionBody(dir, id) {
+  try { return fs.readFileSync(path.join(dir, 'sections', `${id}.md`), 'utf8'); } catch (_) { return ''; }
+}
+/** Comparable form of an identifier: lower-case letters and digits only (`plan-table` ~ `cmdPlanTable` ~ `plantable`). */
+function nameKey(t) { return String(t || '').toLowerCase().replace(/[^a-z0-9]/g, ''); }
+/** Identifiers an entry names: the pieces of its backtick spans and the words of its id (nameKey form, >= 3 chars). */
+function namesOf(s, body) {
+  const out = new Set();
+  for (const m of String(body || '').matchAll(/`([^`\n]{2,200})`/g)) {
+    for (const t of m[1].split(/[\s(),;:=<>[\]{}'"|]+/)) {
+      const low = nameKey(t);
+      if (low.length >= 3 && /[a-z]/.test(low) && !NAME_STOPWORDS.has(low)) out.add(low);
+    }
+  }
+  for (const p of String(s.id || '').split('-')) if (p.length >= 5) out.add(nameKey(p));
+  return Array.from(out);
+}
+/**
+ * Changed lines (added and removed text, no diff markers) of `files` between sha and head, one git diff with -U0.
+ * Returns { byFile: Map<file, string[]> } or null when git fails.
+ */
+function changedLinesOf(root, sha, head, files, timeoutMs) {
+  const r = runGit(root, ['--literal-pathspecs', 'diff', '-U0', '--no-renames', '--no-color', '--no-ext-diff', sha, head, '--', ...files], undefined, timeoutMs);
+  if (!r.ok) return null;
+  const byFile = new Map();
+  let cur = null;
+  let inHunk = false;
+  for (const raw of r.stdout.split('\n')) {
+    const line = raw.replace(/\r$/, '');
+    if (line.startsWith('diff --git ')) {
+      const m = / b\/(.*)$/.exec(line);
+      cur = m ? m[1] : null; inHunk = false;
+      if (cur && !byFile.has(cur)) byFile.set(cur, []);
+    } else if (line.startsWith('@@')) inHunk = true;
+    else if (inHunk && cur && (line.startsWith('+') || line.startsWith('-'))) byFile.get(cur).push(line.slice(1));
+  }
+  return { byFile };
+}
 const FULL_SHA_RE = /^[0-9a-f]{40}([0-9a-f]{24})?$/i;
 
 /**
@@ -2444,7 +2423,7 @@ function diffShas(root, shas, head, globs, timeoutMs) {
 function dirtyFiles(root, globs, timeoutMs) {
   const spec = pathspecOf(globs);
   const base = ['status', '--porcelain=v1', '-z', '-uno', '--no-renames'];
-  const r = runGit(root, spec ? base.concat('--', spec) : base, undefined, timeoutMs || DIRTY_TIMEOUT_MS);
+  const r = runGit(root, spec ? base.concat('--', spec) : base, undefined, timeoutMs || dirtyTimeoutMs());
   if (!r.ok) return { error: r.error, timedOut: !!r.timedOut, ms: r.ms };
   const files = r.stdout.split('\0').filter((x) => x.length > 3).map((x) => x.slice(3));
   return { files, ms: r.ms };
@@ -2470,7 +2449,7 @@ function readFreshCache(dir) {
 
 function cachedFor(dir, head, stamp) {
   if (!head || !stamp) return null;
-  return readFreshCache(dir).entries.find((e) => e.head === head && e.index_mtime === stamp.mtime && e.index_size === stamp.size) || null;
+  return readFreshCache(dir).entries.find((e) => e.rule === FRESH_RULE && e.head === head && e.index_mtime === stamp.mtime && e.index_size === stamp.size) || null;
 }
 
 /** Best effort (tmp+rename, last writer wins); a store that vanished or is read-only only loses the cache. */
@@ -2482,7 +2461,7 @@ function writeFreshCache(dir, entry) {
 }
 
 function freshCounts(sections) {
-  const c = { total: 0, fresh: 0, stale: 0, unknown: 0 };
+  const c = { total: 0, fresh: 0, stale: 0, drift: 0, unknown: 0 };
   for (const s of Object.values(sections)) { c.total++; c[s.state] = (c[s.state] || 0) + 1; }
   return c;
 }
@@ -2509,7 +2488,8 @@ function computeFreshness(o) {
   if (!head) why = o.head && o.head.unsupported ? `HEAD không đọc được từ file (${o.head.unsupported})` : 'không đọc được HEAD (repo chưa có commit?)';
   else if (!o.root) why = 'repo không có thư mục làm việc (bare)';
   for (const s of idx.sections) {
-    const sha = String(s.sha || '').toLowerCase();
+    // review mark (s6): an entry reviewed at reviewed_sha (full sha) is judged from that sha on; a merge that replaces the entry drops the mark
+    const sha = String(FULL_SHA_RE.test(String(s.reviewed_sha || '')) ? s.reviewed_sha : (s.sha || '')).toLowerCase();
     if (why) sections[s.id] = { state: 'unknown', why };
     else if (!sha || sha === 'none') sections[s.id] = { state: 'unknown', why: 'mục chưa có sha' };
     else if (sha === head) sections[s.id] = { state: 'fresh' };
@@ -2523,19 +2503,65 @@ function computeFreshness(o) {
     const d = diffShas(o.root, Array.from(pending.keys()), head, globs, o.timeoutMs || DIFF_TIMEOUT_MS);
     out.ms_git = d.ms || 0;
     if (d.error) error = d.error;
+    // rule 3 (0.7.4 s5b): read the changed lines of the plain-path files that could make an entry stale (one git
+    // diff per distinct sha, only on a cache miss); CHANGELOG files an entry is not about are never read
+    const timeout = o.timeoutMs || DIFF_TIMEOUT_MS;
+    const want = new Map(); // sha -> Set(file)
+    for (const [sha, list] of pending) {
+      if (d.error || d.missing.has(sha)) continue;
+      for (const s of list) {
+        const plain = plainPathsOf(s);
+        for (const f of d.bySha.get(sha) || []) {
+          if (!plain.some((g) => globMatch(g, f))) continue;
+          if (isChangelogPath(f) && !entryAboutChangelog(s)) continue;
+          if (!want.has(sha)) want.set(sha, new Set());
+          want.get(sha).add(f);
+        }
+      }
+    }
+    const lines = new Map(); // `${sha}\0${file}` -> changed texts, or null when git could not say
+    for (const [sha, set] of want) {
+      const r = changedLinesOf(o.root, sha, head, Array.from(set), timeout);
+      for (const f of set) lines.set(`${sha}\0${f}`, r ? (r.byFile.get(f) || []) : null);
+    }
+    const names = new Map(); // section id -> identifiers it names (read lazily)
+    const namesFor = (s) => {
+      if (!names.has(s.id)) names.set(s.id, namesOf(s, readSectionBody(o.dir, s.id)));
+      return names.get(s.id);
+    };
+    const counts = (sha, s, f) => { // does this changed plain-path file make the entry stale?
+      if (isChangelogPath(f) && !entryAboutChangelog(s)) return false;
+      const texts = lines.get(`${sha}\0${f}`);
+      if (!texts) return true; // content unknown: count the change, never hide it
+      const real = texts.filter((t) => !isRoutineLine(t));
+      if (!real.length) return false; // only version bumps / blank lines
+      if (!isLargeFile(o.root, f)) return true;
+      const nm = namesFor(s);
+      return real.some((t) => { const low = nameKey(t); return nm.some((x) => low.includes(x)); });
+    };
     for (const [sha, list] of pending) {
       for (const s of list) {
         if (d.error) { sections[s.id] = { state: 'unknown', why: `git diff-tree lỗi: ${d.error}` }; continue; }
         if (d.missing.has(sha)) { sections[s.id] = { state: 'unknown', why: `commit ${sha.slice(0, 7)} không có trong repo này (clone/nhánh khác chưa fetch?)` }; continue; }
-        const files = d.bySha.get(sha).filter((f) => (s.paths || []).some((g) => globMatch(g, f)));
-        sections[s.id] = files.length ? { state: 'stale', files: files.slice(0, STALE_FILES_KEEP), n_files: files.length } : { state: 'fresh' };
+        const changed = d.bySha.get(sha) || [];
+        const plain = plainPathsOf(s);
+        const globPaths = (s.paths || []).filter((g) => GLOB_CHARS_RE.test(g));
+        const named = [];
+        const soft = []; // changed, but not counted as stale: glob-only, routine, CHANGELOG, lines the entry does not name
+        for (const f of changed) {
+          if (plain.some((g) => globMatch(g, f))) (counts(sha, s, f) ? named : soft).push(f);
+          else if (globPaths.some((g) => globMatch(g, f))) soft.push(f);
+        }
+        if (named.length) sections[s.id] = { state: 'stale', files: named.slice(0, STALE_FILES_KEEP), n_files: named.length };
+        else if (soft.length) sections[s.id] = { state: 'drift', files: soft.slice(0, STALE_FILES_KEEP), n_files: soft.length };
+        else sections[s.id] = { state: 'fresh' };
       }
     }
   }
   Object.assign(out, { computed: new Date().toISOString(), sections, counts: freshCounts(sections) });
   if (error) out.error = error;
   if (head && !error && o.cache !== false && stamp) {
-    writeFreshCache(o.dir, { head, index_mtime: stamp.mtime, index_size: stamp.size, computed: out.computed, sections });
+    writeFreshCache(o.dir, { rule: FRESH_RULE, head, index_mtime: stamp.mtime, index_size: stamp.size, computed: out.computed, sections });
   }
   return out;
 }
@@ -2560,12 +2586,14 @@ function shortFileList(files, n) {
   return f.slice(0, k).join(', ') + (f.length > k ? ` (+${f.length - k})` : '');
 }
 
-/** "N mục, k stale (ids), u không xác định (ids)". */
+/** "N mục, k stale (ids), d drift (ids), u không xác định (ids)"; drift only when present (it is not stale). */
 function knowledgeSummary(fr, n) {
   const ids = (st) => Object.keys(fr.sections).filter((id) => fr.sections[id].state === st);
   const stale = ids('stale');
+  const drift = ids('drift');
   const unk = ids('unknown');
   const parts = [`${n} mục`, `${stale.length} stale${stale.length ? ` (${shortFileList(stale, 6)})` : ''}`];
+  if (drift.length) parts.push(`${drift.length} drift (${shortFileList(drift, 4)})`);
   if (unk.length) parts.push(`${unk.length} không xác định (${shortFileList(unk, 4)})`);
   return parts.join(', ');
 }
@@ -4609,7 +4637,7 @@ function verifyOrphanGate(p, ctx, tag) {
     denied: true,
     event: ev,
     stdout: preToolDeny(`dieu-phoi: verifier của task ${tag.task_id} không có lượt exec nào trong phiên này và không nằm trong kế hoạch đã duyệt — `
-      + 'không chạy verifier cho việc chưa giao. Giao exec của task trước; verifier gộp của mode fast dùng thẻ `|batch`.'),
+      + 'không chạy verifier cho việc chưa giao. Giao exec của task trước; verifier gộp (fast, normal s≤4) dùng thẻ `|batch`.'),
   };
 }
 
@@ -4747,6 +4775,43 @@ function logGate(ctx, p, agentId, st, fields) {
   return ev;
 }
 
+/**
+ * `--gate-bash` (PreToolUse(Bash|PowerShell) inside dp-* subagents): `knowledge review|merge` writes knowledge
+ * outside the accept gate (a subagent could clear a STALE mark on its own). Deny it; the coordinator runs it.
+ * Matching (0.7.4 S4a): split on `| ; & newline`. In a segment, a token naming the CLI (`dieu-phoi`, `dieu-phoi.cjs|.cmd|.js`,
+ * optional `@version`, optional path: `node D:/x/dieu-phoi.cjs`, `npx @kienntpixon/dieu-phoi@0.7.4`) comes before a `knowledge`
+ * token; between `knowledge` and the subcommand only flags are allowed (`--repo x`, `--repo=x`, before or after `knowledge`,
+ * a flag's one value skipped), then `review|merge`. Known limit: a shell variable or alias hiding the CLI name
+ * (`$DP knowledge review`) is not seen; this gate is a guard for subagents, not a sandbox.
+ */
+const KNOWLEDGE_WRITE_SUBS = new Set(['review', 'merge']);
+const DP_CLI_TOKEN_RE = /(?:^|[\/\\])dieu-phoi(?:\.cjs|\.cmd|\.js)?(?:@\S*)?$/;
+function isKnowledgeWriteCall(cmd) {
+  for (const seg of cmd.split(/[|;&\n]/)) {
+    const toks = (seg.match(/"[^"]*"|'[^']*'|\S+/g) || []).map((t) => t.replace(/^["']|["']$/g, ''));
+    for (let i = 0; i < toks.length; i++) {
+      if (!DP_CLI_TOKEN_RE.test(toks[i])) continue;
+      for (let j = i + 1; j < toks.length; j++) {
+        if (toks[j] !== 'knowledge') continue;
+        let flagValue = false; // previous token was a flag without `=`, so this word may be its value
+        for (let k = j + 1; k < toks.length; k++) {
+          const t = toks[k];
+          if (KNOWLEDGE_WRITE_SUBS.has(t)) return true;
+          if (t.startsWith('-')) { flagValue = !t.includes('='); continue; }
+          if (!flagValue) break;
+          flagValue = false;
+        }
+      }
+    }
+  }
+  return false;
+}
+function handleGateBash(p) {
+  const cmd = p.tool_input && typeof p.tool_input.command === 'string' ? p.tool_input.command : '';
+  if (!isKnowledgeWriteCall(cmd)) return null;
+  return { stdout: preToolDeny('dp-*: subagent không được chạy `knowledge review|merge` (đường ghi knowledge ngoài cổng accept). Báo điều phối viên thay vì tự chạy.') };
+}
+
 /** `--gate-release` (PostToolUseFailure(Agent) inside dp-exec): the spawn failed, give its unconfirmed slot back. */
 function handleGateRelease(p, ctx) {
   if (p.tool_name !== 'Agent' && p.tool_name !== 'Task') return null;
@@ -4819,6 +4884,7 @@ function runHook(opts) {
     if (o.mode === 'watch') return handleWatch(p, ctx, o); // { stdout } or null
     if (o.mode === 'gate') return handleGate(p, ctx, o); // { stdout } or null
     if (o.mode === 'gate-release') return handleGateRelease(p, ctx); // { released } or null, prints nothing
+    if (o.mode === 'gate-bash') return handleGateBash(p); // { stdout } (deny) or null
     if (name === 'PreToolUse') return handleChainGate(p, ctx); // { stdout } (deny / warn) or null
     if (name === 'SubagentStart') return handleSubagentStart(p, ctx); // live record or null, prints nothing
     if (name === 'SessionStart') return handleSessionStart(p, ctx); // { stdout } or null, never an event
@@ -4982,8 +5048,8 @@ async function runSync(ctx, opts) {
 
 module.exports = {
   runsDir, loadPlans, isDieuPhoiPrompt, foldPrompt, sinkStatusCached, sinkUrlKey, SINK_CACHE_TTL_MS, scoutBriefPath, quickHealth, startRun, startInfo, startKnowledgeOf, knowledgeLines, orchLessons, orchLessonLines, abortReasonOf, completionStatus, logGate, QUOTA_PAUSE_MARKER, stepIds, START_STEP_IDS, healthLine, formatStartBlock, handleUserPromptSubmit, START_PREFIX, buildSessionState, findOrphanAgents, orphanLines, ORPHAN_MIN_MS, ORPHAN_NO_COMPLETE_MS, formatSessionState, stateCounts, compactSystemMessage, handleSessionStart, dispatchInSession, STATE_TEXT_CAP, COMPACT_PREFIX,
-  modeLine, MODES, DEFAULT_MODE, LOCAL_ONLY_KINDS, MODE_ASK_LINE, isMode, rootModeFromEvents, rootModeFromText, dispatchModeFromEvents, taskModeInfo, planOfTask, modeFields,
-  modeSuggestion, modeSuggestLine, fastFailRate, rootTaskIds, FAST_FAIL_WINDOW, FAST_FAIL_MIN_N, FAST_FAIL_RATE,
+  modeLine, MODES, DEFAULT_MODE, LOCAL_ONLY_KINDS, isMode, normMode, LEGACY_MODE, rootModeFromEvents, rootModeFromText, dispatchModeFromEvents, taskModeInfo, planOfTask, modeFields,
+  rootTaskIds,
   testCommandInfo, testTimeOf, testSFromText,
   CORE_VERSION, SCHEMA, TASK_TYPES, URGENCIES, ROLES, MODEL_ALIASES, UNTAGGED, TYPE_ALIASES,
   sha8, nowIso, readJsonFile, writeFileAtomic, renameWithRetry, acquireLock, acquireFileLock, withFileLock, defaultClaudeDir, resolveHome, pathsFor, loadConfig, makeCtx,
@@ -5012,7 +5078,8 @@ if (require.main === module) {
       .finally(() => process.exit(0));
   } else {
     const mode = process.argv.includes('--watch') ? 'watch'
-      : (process.argv.includes('--gate-release') ? 'gate-release' : (process.argv.includes('--gate') ? 'gate' : null));
+      : (process.argv.includes('--gate-release') ? 'gate-release'
+        : (process.argv.includes('--gate-bash') ? 'gate-bash' : (process.argv.includes('--gate') ? 'gate' : null)));
     const r = runHook({ mode });
     if (r && typeof r.stdout === 'string') process.stdout.write(r.stdout);
     process.exitCode = 0;

package/lib/aggregate.cjs

@@ -574,9 +574,27 @@ function analyze(events, opts) {
   };
 }
 
+/**
+ * core 0.7.4 (s1): one sample per task that has a first exec attempt (excluded tasks left out). `model`/`effort` are
+ * that attempt's (the cell buildCells uses), `handoff` = some segment of that attempt's chain ended on an auto-handoff,
+ * `total_cost` = the task's cost over all segments. Only plan-table's TÁCH? warning reads these; it is advice, not a gate.
+ */
+function handoffSamples(events) {
+  const { agents, userVerdicts, autoVerdicts } = buildAgents(withoutDiscarded(events));
+  return buildTasks(agents, userVerdicts, autoVerdicts)
+    .filter((t) => t.first && !t.excluded)
+    .map((t) => ({
+      task_type: t.task_type,
+      model: t.first.model,
+      effort: t.first.effort,
+      handoff: t.first_chain.some((a) => a.handoff),
+      total_cost: t.total_cost,
+    }));
+}
+
 module.exports = {
   MIN_N, FAIL_OUTCOMES, HEAVY_STEERS, ABORTED, QUOTA_REASON_RE, HANDOFF_REASON_RE, discardedTaskIds, withoutDiscarded, CANONICAL_CELL_FIELDS, normalizeVerdict, isSelf, isInternalComplete, buildAgents, buildTasks,
-  buildCells, buildSteers, canonicalCells, isBatchVerify, batchVerifyCells, orchestrationSummary, analyze, cellKey, mean, percentile, tsOf, steerIdOf,
+  buildCells, buildSteers, canonicalCells, isBatchVerify, batchVerifyCells, orchestrationSummary, analyze, handoffSamples, cellKey, mean, percentile, tsOf, steerIdOf,
 };
 
 // ------------------------------------------------------------------ core 0.7.0 (s2): stats split by mode
@@ -584,7 +602,7 @@ module.exports = {
 // Kept apart from the canonical cells (not part of the CLI <-> sink parity yet). A task's mode = `mode` of its first
 // exec dispatch; tasks dispatched before modes existed (no `mode`) count as normal.
 
-const MODE_KEYS = ['fast', 'normal', 'strict'];
+const MODE_KEYS = ['fast', 'normal']; // legacy 'strict' dispatches count as normal (0.7.4)
 const NO_CATCH_VERIFY = new Set(['self', 'none']);
 
 /**