@kienntpixon/dieu-phoi 0.6.1 → 0.7.1

package/hook.cjs

@@ -26,7 +26,7 @@ const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
 
-const CORE_VERSION = '0.6.1';
+const CORE_VERSION = '0.7.1';
 const SCHEMA = 1;
 const TASK_TYPES = [
   'search', 'extract', 'mechanical-edit', 'feature-impl', 'debug', 'refactor',
@@ -270,6 +270,10 @@ function parseTag(text) {
       tag.role = mm[1];
     } else if ((mm = /^parent=([A-Za-z0-9_-]{1,32})$/.exec(p))) {
       tag.parent_task_id = mm[1]; // core 0.5.0: gen-2 helper -> the dp-exec step that spawned it
+    } else if (p === 'chain_ok') {
+      tag.chain_ok = true; // core 0.7.1 (C1): the user agreed to continue a long handoff chain
+    } else if (p === 'batch') {
+      tag.batch = true; // core 0.7.1 (C5): the one batched verifier of a fast request
     }
   }
   return tag;
@@ -311,6 +315,24 @@ function taskIdError(id) {
 
 const DEFAULT_EXTRA_TYPES = ['art-gen'];
 
+// Ad-hoc labels seen in real logs → the closest fixed type (core 0.4.0 in choose; core 0.7.1: shared with the hook so a
+// dispatch tag with such a label is mapped too, tag_issue=aliased instead of bad-type). A label maps only when its target
+// is known (fixed list or the profile's extra_task_types), e.g. art-fix → art-gen needs art-gen in the profile.
+const TYPE_ALIASES = {
+  'bug-fix': 'debug', bugfix: 'debug', fix: 'debug', bug: 'debug',
+  config: 'mechanical-edit', shell: 'mechanical-edit', deploy: 'mechanical-edit', ops: 'mechanical-edit', edit: 'mechanical-edit',
+  docs: 'content-write', doc: 'content-write', documentation: 'content-write', writing: 'content-write', copy: 'content-write',
+  design: 'plan-design', plan: 'plan-design', planning: 'plan-design', architecture: 'plan-design',
+  research: 'research-synth', synth: 'research-synth',
+  test: 'test-write', tests: 'test-write',
+  analysis: 'data-analysis', data: 'data-analysis',
+  impl: 'feature-impl', feature: 'feature-impl', implement: 'feature-impl',
+  'code-review': 'review',
+  'art-fix': 'art-gen', art: 'art-gen',
+  // retro 2026-10-26 (C2): scout/read labels
+  scan: 'search', read: 'search', 'code-read': 'search', explore: 'search', scout: 'search', lookup: 'search',
+};
+
 /** Fixed task types + the profile's extra_task_types (art-gen when no profile is readable). */
 function knownTaskTypes(ctx) {
   const out = TASK_TYPES.concat(DEFAULT_EXTRA_TYPES);
@@ -350,10 +372,19 @@ function resolveTag(text, known) {
   // an id, not a label: id format, not a known type, and a digit or a run-file / task= mention ("planning" is a label)
   const named = new RegExp(`(?:dp-out-|handoff-|task=)${escRe(head)}(?![a-z0-9])`).test(body.slice(first.length));
   const idLike = TASK_ID_RE.test(head) && !types.includes(head) && (/\d/.test(head) || named);
+  let aliased = null;
   if (idLike) issues.push('type-is-id');
   else if (!types.includes(head)) {
-    issues.push('bad-type');
-    tag.bad_type = parts[0]; // the offending token (task_type may be replaced by a valid altType below)
+    const target = Object.prototype.hasOwnProperty.call(TYPE_ALIASES, head) ? TYPE_ALIASES[head] : null;
+    if (target && types.includes(target)) {
+      // core 0.7.1 (C2): a known ad-hoc label maps to its fixed type; the data pools instead of being lost
+      issues.push('aliased');
+      aliased = target;
+      tag.type_alias_from = parts[0];
+    } else {
+      issues.push('bad-type');
+      tag.bad_type = parts[0]; // the offending token (task_type may be replaced by a valid altType below)
+    }
   }
   if (!tag.task_id) {
     issues.push('missing-task');
@@ -362,7 +393,8 @@ function resolveTag(text, known) {
       tag.task_id_inferred = true;
     }
   }
-  if (idLike || tag.task_type === 'untagged') tag.task_type = altType || 'untagged';
+  if (aliased) tag.task_type = aliased;
+  else if (idLike || tag.task_type === 'untagged') tag.task_type = altType || 'untagged';
   else if (!types.includes(tag.task_type) && altType) tag.task_type = altType;
   if (issues.length) tag.tag_issue = issues.join('+');
   return tag;
@@ -375,6 +407,7 @@ function tagIssueMessage(tag, known) {
   const codes = tag.tag_issue.split('+');
   if (codes.includes('no-tag')) what.push('agent dp-* được giao mà không có thẻ `[dp:...]` ở dòng đầu prompt');
   if (codes.includes('type-is-id')) what.push('ô đầu của thẻ là một task id, không phải loại task');
+  if (codes.includes('aliased')) what.push(`loại "${tag.type_alias_from}" không cố định — hook đã ghi thành "${tag.task_type}" (dùng đúng loại này trong thẻ)`);
   if (codes.includes('bad-type')) what.push(`loại "${tag.bad_type || tag.task_type}" không nằm trong danh sách loại hợp lệ`);
   if (codes.includes('missing-task')) what.push('thiếu `task=<id>`');
   const got = tag.task_id_inferred
@@ -1118,6 +1151,9 @@ function buildSessionState(events, sessionId, opts) {
   for (const id of [...planOfRoot.keys(), ...stepOf.keys()]) {
     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);
   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;
@@ -1168,6 +1204,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),
       }, planInfo, {
         approved_tier: pApproved || ps.step.tier || null, last_tier: null, attempts: [], user_verdict: null, last_steer: null,
         run_dir: planDir, last_ts: null,
@@ -1225,6 +1262,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)),
     }, planInfo, {
       approved_tier: approved,
       last_tier: lastExecAny ? tierOf(lastExecAny.model, lastExecAny.effort) : null,
@@ -1235,10 +1273,26 @@ function buildSessionState(events, sessionId, opts) {
       last_ts: lastMs ? new Date(lastMs).toISOString() : null,
     }));
   }
+  // modes of the roots this session works on: plan roots, tasks' own roots, and roots whose mode event was written here
+  const sidHash = sha8(sessionId);
+  const modeRoots = new Set(plans.map((p) => p.root_task_id));
+  for (const id of taskIds) if (modeEvents.has(id)) modeRoots.add(id);
+  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) });
+    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,
+    };
+  });
   return {
     session_id: sessionId,
     generated_at: nowIso(),
     runs_dir: `${runs}/`,
+    modes,
     plans: plans.map((p) => ({
       root_task_id: p.root_task_id,
       approval: Number.isInteger(p.approval) ? p.approval : (Number.isInteger(p.round) ? p.round : null),
@@ -1268,7 +1322,8 @@ function taskLines(t) {
     + `${t.round ? ` · vòng ${t.round}` : ''}${t.approved_tier ? ` · duyệt ${t.approved_tier}` : ''}`
     + `${t.last_tier && t.last_tier !== t.approved_tier ? ` · tier cuối ${t.last_tier}` : ''}`
     + `${t.user_verdict ? ` · người dùng: ${t.user_verdict.outcome}${t.user_verdict.cause ? `/${t.user_verdict.cause}` : ''}` : ''}`
-    + `${t.last_steer ? ` · steer: ${t.last_steer}` : ''}`;
+    + `${t.last_steer ? ` · steer: ${t.last_steer}` : ''}`
+    + `${t.mode && t.mode !== DEFAULT_MODE ? ` · mode ${t.mode}` : ''}`;
   const att = t.attempts.map((a) => `${a.agent_id} ${a.role}${a.try ? ` try${a.try}` : ''} ${tierOf(a.model, a.effort) || '?'} ${a.status}`);
   const out = [head];
   if (att.length) out.push(`${indent}    ${att.join(' | ')}`);
@@ -1310,11 +1365,26 @@ function compactSystemMessage(state) {
   return `dieu-phoi: đã nạp lại trạng thái điều phối sau khi nén (${c.tasks} task, ${c.running} agent đang chạy, ${c.pending} bước chưa giao)`;
 }
 
+/** "\nMode: <root>=<mode> …" for the roots of a session (last 6); '' when the state carries none. */
+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.`;
+}
+
 function formatSessionState(state, cap) {
   const limit = cap || STATE_TEXT_CAP;
   const { open, pending, running } = stateCounts(state);
   const header = `Phiên ${state.session_id}: ${state.tasks.length} task (${open.length} chưa xong, ${pending} bước chưa giao, ${running} agent đang chạy). `
-    + `Thư mục chạy: ${state.runs_dir} (chỉ trỏ tới, không tự đọc).`;
+    + `Thư mục chạy: ${state.runs_dir} (chỉ trỏ tới, không tự đọc).`
+    + modesLine(state);
   if (!state.tasks.length) return `${header}\nChưa có task nào được giao trong phiên này.`;
   const byAge = (a, b) => String(a.last_ts || '').localeCompare(String(b.last_ts || ''));
   const dropOrder = state.tasks.filter((t) => t.gate === 'done').sort(byAge)
@@ -1503,16 +1573,19 @@ function startInfo(ctx, cwd) {
   const run = startRun();
   const health = quickHealth(ctx, run.runs);
   const info = {
-    id: run.id, run_dir: run.run_dir, step_ids: stepIds(run.id, START_STEP_IDS), health, scout_brief: scoutBriefPath(ctx),
+    id: run.id, run_dir: run.run_dir, step_ids: stepIds(run.id, START_STEP_IDS), health, scout_brief: scoutBriefPath(ctx), mode: null,
     orch_lessons: orchLessons(ctx),
   };
   const k = startKnowledgeOf(cwd);
   if (k) info.knowledge = k;
+  const d = scanUnmergedDeltas();
+  if (d.count) info.unmerged_deltas = d;
   return info;
 }
 
 function knowledgeLines(info) {
-  return info && info.knowledge && Array.isArray(info.knowledge.lines) ? info.knowledge.lines : [];
+  const own = info && info.knowledge && Array.isArray(info.knowledge.lines) ? info.knowledge.lines : [];
+  return own.concat(unmergedDeltaLines(info && info.unmerged_deltas));
 }
 
 function orchLessonLines(info) {
@@ -1520,6 +1593,11 @@ 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). */
+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;
+}
+
 function formatStartBlock(info) {
   return [
     START_PREFIX,
@@ -1528,6 +1606,7 @@ function formatStartBlock(info) {
     `step_ids: ${info.step_ids.join(' ')}`,
     `health: ${healthLine(info.health)}`,
     `scout_brief: ${info.scout_brief || '(không thấy — dùng references/brief-template.md mục E)'}`,
+    modeLine(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.',
@@ -1590,6 +1669,12 @@ function recordSuggestion(ctx, rec) {
     source: prev && prev.suggested_tier ? prev.source : (rec.source || 'choose'),
     ts: nowIso(),
   };
+  // core 0.7.1 (retro 2026-10-26, C3): why choose answered that tier, copied onto the dispatch as choose_*
+  for (const [k, ok] of [['choose_task_type', (v) => typeof v === 'string' && v.length <= 40],
+    ['choose_score', (v) => typeof v === 'number' && isFinite(v)], ['explored', (v) => typeof v === 'boolean'],
+    ['reason_code', (v) => typeof v === 'string' && v.length <= 24], ['thompson_score', (v) => typeof v === 'number' && isFinite(v)]]) {
+    if (ok(rec[k])) out[k] = rec[k];
+  }
   try {
     fs.mkdirSync(ctx.paths.suggest, { recursive: true });
     writeFileAtomic(file, `${JSON.stringify(out)}\n`);
@@ -1623,9 +1708,11 @@ function pruneSuggest(ctx) {
 // ------------------------------------------------------------------ core 0.5.3: handoff chains (retro 2026-10-22)
 //
 // 15/63 feature-impl tasks handed off >= 2 times (19% of feature-impl cost); one chain ran 10 handoffs ($70) and
-// failed. From the 3rd handoff of a task the orchestrator is told to stop continuing and have a planner re-split.
+// failed. Core 0.7.1 (retro 2026-10-26, C1): the warning moves to the 2nd handoff (matching the lesson "stop after the
+// 2nd"), and from the 3rd the global PreToolUse(Agent) gate denies another exec continuation unless the tag has chain_ok.
 
-const HANDOFF_CHAIN_WARN = 3;
+const HANDOFF_CHAIN_WARN = 2;
+const HANDOFF_CHAIN_DENY = 3;
 
 /** Number of agents whose `complete` event has handoff:true for this task (substring scan of events.jsonl). */
 function countTaskHandoffs(ctx, taskId) {
@@ -1649,7 +1736,204 @@ function countTaskHandoffs(ctx, taskId) {
 }
 
 function handoffChainMessage(taskId, n) {
-  return `dieu-phoi: task ${taskId} đã handoff ${n} lần (trần ${HANDOFF_CHAIN_WARN}). Đừ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\`).`;
+  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)
+//
+// 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 DEFAULT_MODE = 'normal';
+/** 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']);
+const MODE_ASK_LINE = 'mode: HỎI người dùng chọn mode cho yêu cầu này — fast (bỏ verifier riêng ở bước s≤6, test chọn lọc, '
+  + 'một verifier gộp) | normal | strict (mặc định normal nếu không trả lời); đặt bằng `dieu-phoi mode --root <root_task_id> <mode>`';
+
+function isMode(m) {
+  return typeof m === 'string' && MODES.includes(m);
+}
+
+/** 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;
+  }
+  return last;
+}
+
+/** Same, from the text of events.jsonl (hook hot path: substring scan, no full parse). */
+function rootModeFromText(txt, root) {
+  const needle = '"kind":"mode"';
+  const rootNeedle = `"root_task_id":${JSON.stringify(root)}`;
+  let last = null;
+  let i = txt.indexOf(needle);
+  while (i >= 0) {
+    const start = txt.lastIndexOf('\n', i) + 1;
+    const end = txt.indexOf('\n', i);
+    const line = txt.slice(start, end < 0 ? undefined : end);
+    if (line.includes(rootNeedle)) {
+      try {
+        const ev = JSON.parse(line);
+        if (ev && ev.kind === 'mode' && isMode(ev.mode)) last = ev;
+      } catch (_) { /* corrupt line */ }
+    }
+    i = end < 0 ? -1 : txt.indexOf(needle, end);
+  }
+  return last;
+}
+
+/** 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;
+  }
+  return null;
+}
+
+function dispatchModeFromText(txt, taskId) {
+  const needle = `"task_id":${JSON.stringify(taskId)}`;
+  let i = txt.indexOf(needle);
+  while (i >= 0) {
+    const start = txt.lastIndexOf('\n', i) + 1;
+    const end = txt.indexOf('\n', i);
+    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];
+    }
+    i = end < 0 ? -1 : txt.indexOf(needle, end);
+  }
+  return null;
+}
+
+/** Approved plan holding `taskId` as a step (or as its root): { root, step|null } or null. */
+function planOfTask(ctx, taskId) {
+  for (const p of loadPlans(ctx.paths.plans)) {
+    const step = p.steps.find((s) => s && s.task_id === taskId);
+    if (step) return { root: p.root_task_id, step };
+  }
+  for (const p of loadPlans(ctx.paths.plans)) if (p.root_task_id === taskId) return { root: taskId, step: null };
+  return null;
+}
+
+/**
+ * Mode a task runs in: its first exec dispatch (locked) > its step `mode` in the approved plan > the root's current
+ * mode event > normal. `events` (array) is for the CLI; without it the hook scans events.jsonl as text.
+ * Returns { mode, source: 'dispatched'|'step'|'root'|'default', root }.
+ */
+function taskModeInfo(ctx, taskId, events) {
+  let txt = null;
+  if (!events) { try { txt = fs.readFileSync(ctx.paths.events, 'utf8'); } catch (_) { txt = ''; } }
+  const pl = taskId ? planOfTask(ctx, taskId) : null;
+  const root = pl ? pl.root : (taskId || null);
+  if (taskId) {
+    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 (root) {
+    const ev = events ? rootModeFromEvents(events, root) : rootModeFromText(txt, root);
+    if (ev) return { mode: ev.mode, source: 'root', root };
+  }
+  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] : []);
+  for (const p of plans || []) {
+    if (p && p.root_task_id === root) for (const s of p.steps || []) if (s && s.task_id) out.add(s.task_id);
+  }
+  return out;
 }
 
 // ------------------------------------------------------------------ core 0.6.0: project identity
@@ -2181,6 +2465,135 @@ function relatedStatus(r) {
   return { name: r.name, rel: r.rel, n, counts: freshCounts(hit.sections), text: `${knowledgeSummary({ sections: hit.sections }, n)} (cache)` };
 }
 
+// ---- retro 2026-10-26 (C6): knowledge deltas that nobody merged
+
+const DELTA_WARN_MS = 24 * 3600 * 1000; // younger than this: the session may still be about to accept/merge
+const DELTA_WINDOW_MS = 30 * 24 * 3600 * 1000; // older than this: stale history, not a warning any more
+const DELTA_SCAN_MAX = 300;
+
+/** sha256 of a delta file as `knowledge merge` records it in meta.json `applied` (BOM and CRLF ignored). */
+function deltaHash(text) {
+  return crypto.createHash('sha256').update(String(text).replace(/^/, '').replace(/\r\n?/g, '\n')).digest('hex');
+}
+
+/** The `repo:` header of a delta text (before its first `## `), unquoted; null when absent. */
+function deltaRepoOf(text) {
+  for (const line of String(text).replace(/^/, '').split(/\r?\n/)) {
+    if (/^##\s/.test(line)) return null;
+    const m = /^\s*repo\s*:\s*(.+?)\s*$/i.exec(line);
+    if (m) return m[1].replace(/[.;,]+$/, '').replace(/^[`"'](.*)[`"']$/, '$1').trim() || null;
+  }
+  return null;
+}
+
+/** A `repo:` value that is a short name (no path separator, no drive), e.g. `pff-tailor`. */
+function isBareRepoName(v) {
+  return typeof v === 'string' && /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(v.trim());
+}
+
+/** Every knowledge store under projectsDir(): { dir_name, dir, name, key, roots, applied:Set<sha256> } — file reads only. */
+function storeCatalog() {
+  const root = projectsDir();
+  let names;
+  try { names = fs.readdirSync(root); } catch (_) { return []; }
+  const out = [];
+  for (const n of names) {
+    const dir = path.join(root, n);
+    if (!isStoreDirName(n) || !isDir(dir)) continue;
+    const meta = readJsonFile(path.join(dir, 'meta.json'), null);
+    const idx = readJsonFile(path.join(dir, 'index.json'), null);
+    if (!meta && !idx) continue;
+    const m = meta && typeof meta === 'object' ? meta : {};
+    const i = idx && typeof idx === 'object' ? idx : {};
+    out.push({
+      dir_name: n,
+      dir: toSlash(dir),
+      name: String(i.name || m.name || n.replace(/-[0-9a-f]{8}$/, '')),
+      key: i.key || (Array.isArray(m.keys) ? m.keys[0] : null) || null,
+      roots: Array.isArray(m.roots) ? m.roots.filter((r) => typeof r === 'string' && r) : [],
+      applied: new Set((Array.isArray(m.applied) ? m.applied : []).map((a) => a && a.sha256).filter(Boolean)),
+    });
+  }
+  return out;
+}
+
+/**
+ * Known store a bare repo name refers to: its `name`, its directory name, or the basename of a recorded root equals
+ * `name` (case-insensitive). { matches, store } — store only when exactly one store matches.
+ */
+function storeByName(name, stores) {
+  const want = String(name).trim().toLowerCase();
+  const matches = (stores || storeCatalog()).filter((s) => s.name.toLowerCase() === want || s.dir_name.toLowerCase() === want
+    || s.roots.some((r) => path.basename(r).toLowerCase() === want));
+  return { matches, store: matches.length === 1 ? matches[0] : null };
+}
+
+/**
+ * Delta files in run dirs that are 24 h .. 30 d old and that no store has applied (hash in meta.json `applied`).
+ * { count, runs: [{ run, n, oldest_ms, repos: { name: n } }], truncated } — never throws; count 0 when all is merged.
+ */
+function scanUnmergedDeltas(opts) {
+  const o = opts || {};
+  const now = o.now || Date.now();
+  const warnMs = o.warnMs === undefined ? DELTA_WARN_MS : o.warnMs;
+  const windowMs = o.windowMs === undefined ? DELTA_WINDOW_MS : o.windowMs;
+  const res = { count: 0, runs: [], truncated: false };
+  try {
+    const runs = runsDir();
+    const applied = new Set();
+    for (const s of storeCatalog()) for (const h of s.applied) applied.add(h);
+    let seen = 0;
+    for (const run of fs.readdirSync(runs)) {
+      const dir = path.join(runs, run);
+      let st;
+      try { st = fs.statSync(dir); } catch (_) { continue; }
+      if (!st.isDirectory() || now - st.mtimeMs > windowMs) continue;
+      let names;
+      try { names = fs.readdirSync(dir); } catch (_) { continue; }
+      const row = { run, n: 0, oldest_ms: 0, repos: {} };
+      for (const f of names) {
+        if (!/^knowledge-delta.*\.md$/i.test(f)) continue;
+        const file = path.join(dir, f);
+        let fst;
+        try { fst = fs.statSync(file); } catch (_) { continue; }
+        const age = now - fst.mtimeMs;
+        if (age < warnMs || age > windowMs) continue;
+        if (seen++ >= DELTA_SCAN_MAX) { res.truncated = true; break; }
+        const text = readTextFile(file);
+        if (text == null || applied.has(deltaHash(text))) continue;
+        const repo = deltaRepoOf(text);
+        const label = repo ? (isBareRepoName(repo) ? repo : path.basename(repo.replace(/[\\/]+$/, ''))) : '?';
+        row.n++;
+        row.oldest_ms = Math.max(row.oldest_ms, age);
+        row.repos[label] = (row.repos[label] || 0) + 1;
+      }
+      if (row.n) { res.runs.push(row); res.count += row.n; }
+      if (res.truncated) break;
+    }
+    res.runs.sort((a, b) => b.n - a.n || b.oldest_ms - a.oldest_ms);
+  } catch (e) {
+    res.error = e.message;
+  }
+  return res;
+}
+
+function ageText(ms) {
+  return ms >= 48 * 3600 * 1000 ? `${Math.floor(ms / 86400000)} ngày` : `${Math.floor(ms / 3600000)} giờ`;
+}
+
+/** One warning line (as an array, empty when nothing is pending) for the start block and `state`. */
+function unmergedDeltaLines(scan) {
+  if (!scan || !scan.count) return [];
+  const oldest = Math.max(...scan.runs.map((r) => r.oldest_ms));
+  const repos = {};
+  for (const r of scan.runs) for (const [k, v] of Object.entries(r.repos)) repos[k] = (repos[k] || 0) + v;
+  const repoText = Object.entries(repos).sort((a, b) => b[1] - a[1]).slice(0, 4).map(([k, v]) => `${k} ×${v}`).join(', ');
+  const runText = scan.runs.slice(0, 3).map((r) => `${r.run} ×${r.n}`).join(', ') + (scan.runs.length > 3 ? ` (+${scan.runs.length - 3} run)` : '');
+  const more = scan.truncated ? ' (chỉ quét một phần)' : '';
+  return [`knowledge_delta: ${scan.count} file delta chưa gộp quá 24h${more} — run ${runText}; kho ${repoText}; cũ nhất ${ageText(oldest)}. `
+    + `Gộp: \`dieu-phoi knowledge merge --run ${scan.runs[0].run} --dry-run\` rồi bỏ --dry-run (hoặc verdict accept); bỏ qua nếu cố ý không gộp.`];
+}
+
 /**
  * Knowledge lines for the start block of the repo at `cwd`; null outside a repo or when the repo has no store.
  * Refreshes this repo only (at most one git diff-tree, on a cache miss, bounded by HOOK_DIFF_TIMEOUT_MS; never git
@@ -2278,6 +2691,9 @@ function buildDispatch(p, ctx) {
     ...(tag.task_id && !isValidTaskId(tag.task_id) ? { task_id_invalid: true } : {}),
     ...(tag.task_id_inferred ? { task_id_inferred: true } : {}),
     ...(tag.tag_issue ? { tag_issue: tag.tag_issue } : {}),
+    ...(tag.type_alias_from ? { type_alias_from: tag.type_alias_from } : {}),
+    ...(tag.chain_ok ? { chain_ok: true } : {}),
+    ...(tag.batch ? { batch: true } : {}),
     task_type: tag.task_type,
     score: tag.score,
     urgency: tag.urgency,
@@ -2296,12 +2712,24 @@ function buildDispatch(p, ctx) {
     orch_cum_usd: orch.cum_usd,
   }, tag.parent_task_id ? { parent_task_id: tag.parent_task_id } : {},
   projectFields(p),
+  modeFields(ctx, tag),
   tierFields(ctx, tag, normalizeModel(trObj.resolvedModel) || normalizeModel(ti.model) || null, explicitEffort || parentEffort || null),
   // core 0.5.0: an Agent call made inside a subagent (gen-2) carries the caller's agent_id
   typeof p.agent_id === 'string' && p.agent_id ? { parent_agent_id: p.agent_id } : {},
   commonFields(ctx));
 }
 
+/** core 0.7.1 (C3): the tier came from `choose` for another task type than the tag carries. */
+function chooseTypeMismatchMessage(ev) {
+  return `dieu-phoi: task ${ev.task_id} được \`choose\` tính cho loại "${ev.choose_task_type}" nhưng thẻ ghi "${ev.task_type}" — tier ${ev.choose_tier} có thể không hợp loại này. Lần sau gọi \`choose --type ${ev.task_type}\` (hoặc sửa thẻ cho đúng loại choose trả).`;
+}
+
+/** core 0.7.0: mode of the task at the moment of this dispatch (kept by later tries), only when the tag carries a task_id. */
+function modeFields(ctx, tag) {
+  if (!tag || !tag.task_id || !isValidTaskId(tag.task_id)) return {};
+  try { return { mode: taskModeInfo(ctx, tag.task_id).mode }; } catch (_) { return {}; }
+}
+
 /** suggested_tier / choose_tier / suggested_source / dispatched_tier / tier_mismatch, only when choose left a record. */
 function tierFields(ctx, tag, model, effort) {
   const s = tag.task_id ? readSuggestion(ctx, tag.task_id, tag.role) : null;
@@ -2314,6 +2742,15 @@ function tierFields(ctx, tag, model, effort) {
     dispatched_tier: dispatched,
   };
   if (dispatched && !dispatched.includes('?')) out.tier_mismatch = dispatched !== out.choose_tier;
+  // core 0.7.1 (C3): choose's own inputs/reason, and whether choose was asked about another task type
+  if (typeof s.choose_task_type === 'string') {
+    out.choose_task_type = s.choose_task_type;
+    if (tag.task_type && tag.task_type !== s.choose_task_type) out.choose_type_mismatch = true;
+  }
+  if (typeof s.choose_score === 'number') out.choose_score = s.choose_score;
+  if (typeof s.explored === 'boolean') out.choose_explored = s.explored;
+  if (typeof s.reason_code === 'string') out.choose_reason = s.reason_code;
+  if (typeof s.thompson_score === 'number') out.choose_thompson_score = s.thompson_score;
   return out;
 }
 
@@ -2332,6 +2769,7 @@ function handlePostToolUse(p, ctx) {
     const tag = resolveTag(ti.prompt, known) || { tag_issue: ev.tag_issue, task_id: null, task_type: ev.task_type };
     notes.push(tagIssueMessage(tag, known));
   }
+  if (ev.choose_type_mismatch) notes.push(chooseTypeMismatchMessage(ev));
   if (ev.task_id && ev.role === 'exec') {
     const n = countTaskHandoffs(ctx, ev.task_id);
     if (n) ev.task_handoffs = n;
@@ -2548,6 +2986,16 @@ function handleSubagentStop(p, ctx) {
   }
   // exec/verify/plan only: true = it returned without writing its dp-out file (the hook saved the .inline.md)
   if (tag && RESULT_ROLES.includes(tag.role)) ev.inline_result = Boolean(inline);
+  // core 0.7.0 (s2): seconds spent running tests in this segment (transcript; else the dp-out `TEST_S:` line)
+  const tt = exists && sum ? testTimeOf(lines.slice(sum.segment_start)) : null;
+  ev.test_s = tt ? tt.test_s : null;
+  ev.test_runs = tt ? tt.test_runs : null;
+  ev.full_suite_runs = tt ? tt.full_suite_runs : null;
+  ev.test_s_source = ev.test_s !== null ? 'transcript' : null;
+  if (ev.test_s === null && exists && tag) {
+    const v = testSFromResultFile(lines, tag);
+    if (v !== null) { ev.test_s = v; ev.test_s_source = 'dp-out'; }
+  }
   // Record the segment before appending so a racing duplicate fire sees it.
   if (sum && sum.last_uuid) {
     saveSegments(ctx, agentId, {
@@ -2630,6 +3078,134 @@ function completionStatus(text, abortWhy) {
   return 'none';
 }
 
+// ------------------------------------------------------------------ core 0.7.0 (s2): time spent running tests
+//
+// Measured at SubagentStop from the subagent transcript: every Bash/PowerShell tool_use whose command runs tests is
+// paired with its tool_result line; test_s = sum of (result timestamp - tool_use timestamp). This is the same span a
+// PreToolUse/PostToolUse(Bash) pair would give, without registering hooks on every Bash call of every session (the
+// dp-* agents only hook PostToolUse, which carries no start time). Backgrounded commands return at once, so they are
+// counted (test_runs) but not timed. Nothing timed -> fall back to the `TEST_S:` line of the agent's dp-out file.
+
+const TEST_TOOL_NAMES = new Set(['Bash', 'PowerShell']);
+const PKG_RUNNERS = new Set(['npm', 'pnpm', 'yarn', 'bun']);
+const TEST_FILE_RE = /\.(?:test|spec)\.[cm]?[jt]sx?$|(?:^|[\\/])tests?[\\/][^\s]*\.[cm]?[jt]sx?$/;
+
+/** Positional args (not flags) of a token list. */
+function positionals(toks) {
+  return toks.filter((t) => t && !t.startsWith('-'));
+}
+
+/** One command segment (no && ; |) -> null (not a test run) or { full } (full = whole suite, no file/filter args). */
+function testSegmentInfo(seg) {
+  let s = ` ${seg} `.replace(/\s\d?>>?&?\s*[^\s]+/g, ' ').trim();
+  for (let k = 0; k < 6; k++) {
+    const n = s.replace(/^(?:[A-Za-z_][A-Za-z0-9_]*=[^\s]*\s+|time\s+|env\s+|rtk\s+(?:bypass\s+)?|timeout\s+[0-9]+[a-z]*\s+|npx\s+(?:--yes\s+|-y\s+)?|&\s*)/, '');
+    if (n === s) break;
+    s = n;
+  }
+  const toks = s.split(/\s+/).filter(Boolean).map((t) => t.replace(/^["']|["']$/g, ''));
+  if (!toks.length) return null;
+  const head = toks[0].replace(/\.(?:cmd|exe)$/i, '').split(/[\\/]/).pop();
+  if (PKG_RUNNERS.has(head)) {
+    let i = 1;
+    if (toks[i] === 'run' || toks[i] === 'run-script') i++;
+    const script = toks[i] || '';
+    if (script !== 'test' && script !== 't' && !/^test:/.test(script)) return null;
+    // `npm test` alone = the whole suite; a `test:<x>` script or extra args (`npm test -- file`) = a subset
+    return { full: (script === 'test' || script === 't') && positionals(toks.slice(i + 1)).length === 0 };
+  }
+  if (head === 'node') {
+    if (toks.includes('--test')) return { full: !positionals(toks.slice(1)).some((t) => /\.[cm]?[jt]sx?$/.test(t)) };
+    const file = positionals(toks.slice(1))[0] || '';
+    return TEST_FILE_RE.test(file) ? { full: false } : null;
+  }
+  if (head === 'pytest' || head === 'py.test') return { full: positionals(toks.slice(1)).length === 0 };
+  if (/^python[0-9.]*$|^py$/.test(head) && toks[1] === '-m' && toks[2] === 'pytest') return { full: positionals(toks.slice(3)).length === 0 };
+  if (head === 'jest') return { full: positionals(toks.slice(1)).length === 0 };
+  if (head === 'vitest') {
+    const rest = toks.slice(1);
+    if (rest[0] === 'run') rest.shift();
+    return { full: positionals(rest).length === 0 };
+  }
+  if (head === 'go' && toks[1] === 'test') return { full: toks.slice(2).includes('./...') };
+  if ((head === 'cargo' || head === 'dotnet') && toks[1] === 'test') return { full: positionals(toks.slice(2)).length === 0 };
+  return null;
+}
+
+/** A shell command -> null (runs no tests) or { full } (true when any test segment runs a whole suite). */
+function testCommandInfo(cmd) {
+  if (typeof cmd !== 'string' || !cmd.trim()) return null;
+  let hit = null;
+  for (const seg of cmd.split(/&&|\|\||;|\||\r?\n/)) {
+    const t = seg.trim();
+    if (!t) continue;
+    const info = testSegmentInfo(t);
+    if (info) hit = { full: Boolean((hit && hit.full) || info.full) };
+  }
+  return hit;
+}
+
+/**
+ * Test runs in transcript lines (one segment). Returns { test_s, test_runs, full_suite_runs }: test_s = seconds summed
+ * over the timed (foreground, with a result) test commands, null when none was timed; counts include backgrounded runs.
+ */
+function testTimeOf(lines) {
+  const open = new Map();
+  let runs = 0;
+  let full = 0;
+  let timed = 0;
+  let ms = 0;
+  for (const l of lines || []) {
+    if (!l || typeof l !== 'object' || !l.message || !Array.isArray(l.message.content)) continue;
+    const t = typeof l.timestamp === 'string' ? Date.parse(l.timestamp) : NaN;
+    if (l.type === 'assistant') {
+      for (const b of l.message.content) {
+        if (!b || b.type !== 'tool_use' || !TEST_TOOL_NAMES.has(b.name) || !b.input) continue;
+        const info = testCommandInfo(b.input.command);
+        if (!info) continue;
+        runs++;
+        if (info.full) full++;
+        if (b.id && b.input.run_in_background !== true && !isNaN(t)) open.set(b.id, t);
+      }
+    } else if (l.type === 'user') {
+      for (const b of l.message.content) {
+        if (!b || b.type !== 'tool_result' || !open.has(b.tool_use_id)) continue;
+        const t0 = open.get(b.tool_use_id);
+        open.delete(b.tool_use_id);
+        if (!isNaN(t) && t >= t0) { ms += t - t0; timed++; }
+      }
+    }
+  }
+  return { test_s: timed ? Math.round(ms / 100) / 10 : null, test_runs: runs, full_suite_runs: full };
+}
+
+/** Seconds from a `TEST_S: <n>[s|m|phút]` line of a result file's text (first 200 lines), or null. */
+function testSFromText(text) {
+  const head = String(text || '').split(/\r?\n/).slice(0, 200);
+  for (const raw of head) {
+    const m = /^[\s>*_`#-]*TEST_S\s*[*_`]*\s*[:=]\s*[*_`~≈]*\s*([0-9]+(?:[.,][0-9]+)?)\s*(giây|phút|ph|min|m|s)?\b/i.exec(raw);
+    if (!m) continue;
+    const n = Number(m[1].replace(',', '.'));
+    if (!isFinite(n) || n < 0) return null;
+    const unit = (m[2] || 's').toLowerCase();
+    return Math.round((unit === 's' || unit === 'giây' ? n : n * 60) * 10) / 10;
+  }
+  return null;
+}
+
+/** test_s from the agent's dp-out file(s) for (task, role, try) in the run dir its brief names, or null. Never throws. */
+function testSFromResultFile(lines, tag) {
+  try {
+    if (!tag || !RESULT_ROLES.includes(tag.role) || !tag.task_id) return null;
+    const dir = resultRunDir(firstPromptText(lines), tag.task_id);
+    for (const f of findResultFiles(dir, tag.task_id, tag.role, tag.try)) {
+      const v = testSFromText(readTextFile(f));
+      if (v !== null) return v;
+    }
+  } catch (_) { /* best effort */ }
+  return null;
+}
+
 // ------------------------------------------------------------------ core 0.5.0: context watchdog + gen-2 gate
 //
 // Both run only from the hooks of the dp-* agent files (~/.claude/agents, installed by `dieu-phoi setup`), so a session
@@ -2902,6 +3478,36 @@ function gateReserve(dir, child) {
   return 0;
 }
 
+/**
+ * Core 0.7.1 (C1): global PreToolUse(Agent) in the orchestrating session. An exec dispatch of a task that already
+ * handed off HANDOFF_CHAIN_DENY times is denied (the 4th, 5th… segment of one chain cost $15-36 per task in session
+ * 36cee993) unless the tag carries `chain_ok`. Inside a subagent (agent_id) this does nothing: --gate handles gen-2.
+ */
+function handleChainGate(p, ctx) {
+  if (p.tool_name !== 'Agent' && p.tool_name !== 'Task') return null;
+  if (watchAgentId(p)) return null;
+  const ti = p.tool_input && typeof p.tool_input === 'object' ? p.tool_input : {};
+  const tag = resolveTag(ti.prompt, knownTaskTypes(ctx));
+  if (!tag || tag.role !== 'exec' || !tag.task_id || !isValidTaskId(tag.task_id) || tag.chain_ok) return null;
+  const n = countTaskHandoffs(ctx, tag.task_id);
+  if (n < HANDOFF_CHAIN_DENY) return null;
+  const ev = logGate(ctx, p, `task:${tag.task_id}`, { task_id: tag.task_id, role: 'exec' },
+    { gate_action: 'deny', reason_code: 'handoff-chain', children: n });
+  return {
+    denied: true,
+    event: ev,
+    stdout: JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'deny',
+        permissionDecisionReason: `dieu-phoi: task ${tag.task_id} đã handoff ${n} lần (trần ${HANDOFF_CHAIN_DENY}) — không giao thêm exec tiếp nối. `
+          + `Giao planner (dp-scout) đọc handoff-${tag.task_id}.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\`). `
+          + 'Chỉ khi người dùng đồng ý nối tiếp: thêm `|chain_ok` vào thẻ.',
+      },
+    }),
+  };
+}
+
 /** Mark the reservation of `child` as a real spawn. Returns true when its slot was found. */
 function gateConfirm(ctx, key, child) {
   if (!key || !child) return false;
@@ -3058,6 +3664,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 (name === 'PreToolUse') return handleChainGate(p, ctx); // { stdout } (deny) or null
     if (name === 'SessionStart') return handleSessionStart(p, ctx); // { stdout } or null, never an event
     if (name === 'UserPromptSubmit') return handleUserPromptSubmit(p, ctx); // { stdout } or null
     if (name === 'SubagentStop') ev = handleSubagentStop(p, ctx);
@@ -3175,7 +3782,7 @@ async function runSync(ctx, opts) {
       for (const l of batch) {
         try {
           const r = JSON.parse(l.text);
-          if (r && typeof r === 'object' && !Array.isArray(r)) {
+          if (r && typeof r === 'object' && !Array.isArray(r) && !LOCAL_ONLY_KINDS.has(r.kind)) {
             delete r.synced;
             records.push(r);
           }
@@ -3212,16 +3819,19 @@ 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, formatSessionState, stateCounts, compactSystemMessage, handleSessionStart, dispatchInSession, STATE_TEXT_CAP, COMPACT_PREFIX,
-  CORE_VERSION, SCHEMA, TASK_TYPES, URGENCIES, ROLES, MODEL_ALIASES, UNTAGGED,
+  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,
+  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,
   logError, computeUserHash, userHash, commonFields, parseTag, resolveTag, knownTaskTypes, tagIssueMessage, DEFAULT_EXTRA_TYPES,
-  recordSuggestion, readSuggestion, suggestFile, SUGGEST_MAX_AGE_MS, countTaskHandoffs, handoffChainMessage, HANDOFF_CHAIN_WARN, tierFields, TASK_ID_RE, isValidTaskId, newTaskId, taskIdError, normalizeModel, loadPricing,
+  recordSuggestion, readSuggestion, suggestFile, SUGGEST_MAX_AGE_MS, countTaskHandoffs, handoffChainMessage, HANDOFF_CHAIN_WARN, HANDOFF_CHAIN_DENY, handleChainGate, tierFields, TASK_ID_RE, isValidTaskId, newTaskId, taskIdError, normalizeModel, loadPricing,
   priceFor, usageBuckets, requestCost, parseJsonl, readTranscript, lastUuidOf,
   firstPromptText, tagFromTranscript, summarizeTranscript,
   RESULT_ROLES, BLOCKED_RESULT_NAME_RE, resultFileName, findResultFiles, resultRunDir, finalAssistantText, persistInlineResult, orchestratorUsage, orchCacheFile, findSessionTranscript, SESSION_ID_RE, HOOK_COLD_MAX_BYTES, appendEvent, EVENTS_LOCK_WAIT_MS, eventLinesFrom, readEventLines, readEvents, readEventsBuffer, archiveFiles, readArchiveLines,
   loadSyncOffset, saveSyncOffset, recordRejected, unsyncedInfo, loadSegments, saveSegments, segmentFile,
   HANDOFF_MARKER, HANDOFF_THRESHOLDS, watchThresholds, GATE_MAX_CHILDREN, HELPER_AGENT_TYPE, watchAgentId, subagentTranscriptPath, readHeadTag, lastContextTokens, watchState, handoffMessage, handleWatch, handleGate, handleGateRelease, gateDir, gateSlots, gateReserve, gateConfirm, GATE_PENDING_MS,
-  globMatch, pathspecOf, diffShas, dirtyFiles, computeFreshness, addDirty, indexStamp, freshnessCacheFile, readFreshCache, cachedFor, freshCounts, knowledgeSummary, shortFileList, readStoreIndex, relatedStatus, startKnowledge, FRESH_CACHE_MAX, DIFF_TIMEOUT_MS, HOOK_DIFF_TIMEOUT_MS, DIRTY_TIMEOUT_MS,
+  globMatch, pathspecOf, diffShas, dirtyFiles, computeFreshness, addDirty, indexStamp, freshnessCacheFile, readFreshCache, cachedFor, freshCounts, knowledgeSummary, shortFileList, readStoreIndex, relatedStatus, startKnowledge, deltaHash, deltaRepoOf, isBareRepoName, storeCatalog, storeByName, scanUnmergedDeltas, unmergedDeltaLines, DELTA_WARN_MS, FRESH_CACHE_MAX, DIFF_TIMEOUT_MS, HOOK_DIFF_TIMEOUT_MS, DIRTY_TIMEOUT_MS,
   projectsDir, findGit, originUrlFromConfig, normalizeRemoteUrl, resolveProject, readHead, repoFromBrief, projectFields, nativePath, isStoreDirName, aliasesFile, loadAliases, keyDirName,
   extractAgentId, hasAssistantUsage, hasDispatch, buildDispatch, handlePostToolUse, handleSubagentStop, maybeSpawnSync, runHook, runSync,
 };